diff options
Diffstat (limited to 'scalalib/src/test/resource/better-files')
40 files changed, 0 insertions, 5899 deletions
diff --git a/scalalib/src/test/resource/better-files/.gitignore b/scalalib/src/test/resource/better-files/.gitignore deleted file mode 100644 index 6f460f93..00000000 --- a/scalalib/src/test/resource/better-files/.gitignore +++ /dev/null @@ -1,206 +0,0 @@ -# Created by https://www.gitignore.io/api/linux,osx,windows,intellij,eclipse,sbt,scala - -### Eclipse ### - -.metadata -bin/ -tmp/ -*.tmp -*.bak -*.swp -*~.nib -local.properties -.settings/ -.loadpath -.recommenders - -# External tool builders -.externalToolBuilders/ - -# Locally stored "Eclipse launch configurations" -*.launch - -# PyDev specific (Python IDE for Eclipse) -*.pydevproject - -# CDT-specific (C/C++ Development Tooling) -.cproject - -# Java annotation processor (APT) -.factorypath - -# PDT-specific (PHP Development Tools) -.buildpath - -# sbteclipse plugin -.target - -# Tern plugin -.tern-project - -# TeXlipse plugin -.texlipse - -# STS (Spring Tool Suite) -.springBeans - -# Code Recommenders -.recommenders/ - -# Scala IDE specific (Scala & Java development for Eclipse) -.cache-main -.scala_dependencies -.worksheet - -### Eclipse Patch ### -# Eclipse Core -.project - -# JDT-specific (Eclipse Java Development Tools) -.classpath - -### Intellij ### -# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and Webstorm -# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839 -.idea/ - -# User-specific stuff: -.idea/**/workspace.xml -.idea/**/tasks.xml -.idea/dictionaries - -# Sensitive or high-churn files: -.idea/**/dataSources/ -.idea/**/dataSources.ids -.idea/**/dataSources.xml -.idea/**/dataSources.local.xml -.idea/**/sqlDataSources.xml -.idea/**/dynamic.xml -.idea/**/uiDesigner.xml - -# Gradle: -.idea/**/gradle.xml -.idea/**/libraries - -# CMake -cmake-build-debug/ - -# Mongo Explorer plugin: -.idea/**/mongoSettings.xml - -## File-based project format: -*.iws - -## Plugin-specific files: - -# IntelliJ -/out/ - -# mpeltonen/sbt-idea plugin -.idea_modules/ - -# JIRA plugin -atlassian-ide-plugin.xml - -# Cursive Clojure plugin -.idea/replstate.xml - -# Crashlytics plugin (for Android Studio and IntelliJ) -com_crashlytics_export_strings.xml -crashlytics.properties -crashlytics-build.properties -fabric.properties - -### Intellij Patch ### -# Comment Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-215987721 - -# *.iml -# modules.xml -# .idea/misc.xml -# *.ipr - -# Sonarlint plugin -.idea/sonarlint - -### Linux ### -*~ - -# temporary files which can be created if a process still has a handle open of a deleted file -.fuse_hidden* - -# KDE directory preferences -.directory - -# Linux trash folder which might appear on any partition or disk -.Trash-* - -# .nfs files are created when an open file is removed but is still being accessed -.nfs* - -### OSX ### -*.DS_Store -.AppleDouble -.LSOverride - -# Icon must end with two \r -Icon - -# Thumbnails -._* - -# Files that might appear in the root of a volume -.DocumentRevisions-V100 -.fseventsd -.Spotlight-V100 -.TemporaryItems -.Trashes -.VolumeIcon.icns -.com.apple.timemachine.donotpresent - -# Directories potentially created on remote AFP share -.AppleDB -.AppleDesktop -Network Trash Folder -Temporary Items -.apdisk - -### SBT ### -# Simple Build Tool -# http://www.scala-sbt.org/release/docs/Getting-Started/Directories.html#configuring-version-control - -dist/* -target/ -lib_managed/ -src_managed/ -project/boot/ -project/plugins/project/ -.history -.cache -.lib/ - -### Scala ### -*.class -*.log - -### Windows ### -# Windows thumbnail cache files -Thumbs.db -ehthumbs.db -ehthumbs_vista.db - -# Folder config file -Desktop.ini - -# Recycle Bin used on file shares -$RECYCLE.BIN/ - -# Windows Installer files -*.cab -*.msi -*.msm -*.msp - -# Windows shortcuts -*.lnk - -# End of https://www.gitignore.io/api/linux,osx,windows,intellij,eclipse,sbt,scala diff --git a/scalalib/src/test/resource/better-files/CHANGES.md b/scalalib/src/test/resource/better-files/CHANGES.md deleted file mode 100644 index 4103ef04..00000000 --- a/scalalib/src/test/resource/better-files/CHANGES.md +++ /dev/null @@ -1,73 +0,0 @@ -better-files follows the following `MAJOR.MINOR.PATCH` release conventions: -- **Changes in `PATCH` version**: - - Minor functionality changes (usually bug fixes) - - No breaking public API changes - - New APIs might be added -- **Change in `MINOR` version**: - - In addition to `PATCH` changes - - Minor API shape changes e.g. renaming, deprecations - - Trivial to modify code to address compilation issues -- **Change in `MAJOR` version**: - - In addition to `MINOR` changes - - Significant structural and API changes - ------------ - -## v4.0.0 -* [Issue #129](https://github.com/pathikrit/better-files/issues/129): JSR-203 and JimFS compatibility -* [Issue #88](https://github.com/pathikrit/better-files/issues/88): Strongly typed relative and absolute path APIs -* [Issue #122](https://github.com/pathikrit/better-files/issues/122): Scala Platform Release - Support for Scala 2.13 and 2.11 -* Move Scanner to own module that depends on cats/shapeless -* Remove implicit options from all APIs - -## v3.2.1 -* [Issue #193](https://github.com/pathikrit/better-files/issues/193): Handle fast changing directory watching on Windows -* [Issue #195](https://github.com/pathikrit/better-files/issues/195): Do not swallow `FileAlreadyExistsException` when creating directory or file -* [Add](https://github.com/pathikrit/better-files/commit/00f27867ebd0cddec1ace7835dcc2375869fb3ae) method to check verified file existence (or non-existence) -* [Issue #198](https://github.com/pathikrit/better-files/issues/198): `InputStreamOps#asString` doesn't close the stream on exception -* [PR #199](https://github.com/pathikrit/better-files/pull/199): Utils for Object I/O - -## v3.2.0 -* [Rename](https://github.com/pathikrit/better-files/commit/ec34a6f843fec941b51bdddafc2e07e5bc0e1cbb) PosixFilePermissions.OTHERS* APIs -* [Issue #186](https://github.com/pathikrit/better-files/issues/186): Splitter based Scanner -* [Issue #173](https://github.com/pathikrit/better-files/issues/173): Better ARM handling of fatal errors -* [Issue #182](https://github.com/pathikrit/better-files/issues/182): Move and Copy *into* directory utils -* [Issue #189](https://github.com/pathikrit/better-files/issues/189): Util to read String from an InputStream -* [Issue #187](https://github.com/pathikrit/better-files/issues/187): Readers for `java.time.*` and `java.sql.*` -* [Restore File.usingTemp](https://github.com/pathikrit/better-files/commit/35184a642245db3d1e41fc02c7bfbec0b19a43bb) first introduced in [7c60ca](https://github.com/pathikrit/better-files/commit/d3522e8da63b55c7d3fa14cc9b0b76acd57c60ca) -* [Fix](https://github.com/pathikrit/better-files/pull/184) bug in appendBytes - -## v3.1.0 -* [Issue #140](https://github.com/pathikrit/better-files/issues/140): Batch up events for file monitoring -* [Issue #136](https://github.com/pathikrit/better-files/issues/136): Use execution contexts for file monitoring -* [Issue #152](https://github.com/pathikrit/better-files/issues/152): Streamed unzipping -* [Issue #150](https://github.com/pathikrit/better-files/issues/150): `ManagedResource[File]` for temp files -* [Issue #126](https://github.com/pathikrit/better-files/pull/159): New Typeclassed approach to ARM -* [Issue #160](https://github.com/pathikrit/better-files/issues/160): Ability to convert Reader/Writer to Input/Output streams -* [Issue #77](https://github.com/pathikrit/better-files/issues/77): Better UNIX-y behaviour for `cp` and `mv` DSL utils -* [Issue #169](https://github.com/pathikrit/better-files/issues/169): Support for symbols in file DSL -* [Issue #171](https://github.com/pathikrit/better-files/issues/171): Handle `createDirectories()` on symlinks to existing directories - -## v3.0.0 -* [Issue #9](https://github.com/pathikrit/better-files/issues/9): File resource utils -* [Issue #114](https://github.com/pathikrit/better-files/issues/114): Glob with automatic path -* [Issue #107](https://github.com/pathikrit/better-files/issues/107): Handle Byte-order markers -* [PR #113](https://github.com/pathikrit/better-files/pull/113): File anchor util -* [Issue #105](https://github.com/pathikrit/better-files/issues/105): Remove dependency on scala.io -* [File.usingTemp](https://github.com/pathikrit/better-files/commit/d3522e8da63b55c7d3fa14cc9b0b76acd57c60ca) -* [Optional symbolic operations](https://github.com/pathikrit/better-files/issues/102) -* [PR #100](https://github.com/pathikrit/better-files/pull/100): Fix issue in unzip of parents -* [PR #101](https://github.com/pathikrit/better-files/pull/101): Removed File.Type -* [Issue #96](https://github.com/pathikrit/better-files/issues/96): Teeing outputstreams -* [File.testPermission](https://github.com/pathikrit/better-files/commit/7b175c582643790e4d2fd21552e47cc9c615dfbb) -* [File.nonEmpty](https://github.com/pathikrit/better-files/commit/18c9cd51b7b2e503ff4944050ac5119470869e6e) -* [Update metadata API](https://github.com/pathikrit/better-files/commit/c3d65951d80f09b813e158a9e3a1785c622353b3) -* [Issue #80](https://github.com/pathikrit/better-files/issues/80): Unzip filters -* [PR #107](https://github.com/pathikrit/better-files/pull/127): Java serialization utils - -## v2.17.1 -* [PR #99](https://github.com/pathikrit/better-files/pull/99): Release for Scala 2.12 - -## v2.17.0 -* [PR #78](https://github.com/pathikrit/better-files/pull/78): Change `write(Array[Byte])` to `writeByteArray()`. Same for `append` -* [Issue #76](https://github.com/pathikrit/better-files/issues/76): Move `better.files.Read` typeclass to `better.files.Scanner.Read` diff --git a/scalalib/src/test/resource/better-files/LICENSE b/scalalib/src/test/resource/better-files/LICENSE deleted file mode 100644 index a63964f8..00000000 --- a/scalalib/src/test/resource/better-files/LICENSE +++ /dev/null @@ -1,21 +0,0 @@ -The MIT License (MIT) - -Copyright (c) 2017 Pathikrit Bhowmick - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. diff --git a/scalalib/src/test/resource/better-files/README.md b/scalalib/src/test/resource/better-files/README.md deleted file mode 100644 index 9877c3bc..00000000 --- a/scalalib/src/test/resource/better-files/README.md +++ /dev/null @@ -1,637 +0,0 @@ -# better-files [![License][licenseImg]][licenseLink] [![CircleCI][circleCiImg]][circleCiLink] [![Codacy][codacyImg]][codacyLink] - -`better-files` is a [dependency-free](project/Dependencies.scala) *pragmatic* [thin Scala wrapper](core/src/main/scala/better/files/File.scala) around [Java NIO](https://docs.oracle.com/javase/tutorial/essential/io/fileio.html). - -## Talks [![Gitter][gitterImg]][gitterLink] - - [ScalaDays NYC 2016][scalaDaysNyc2016Event] ([slides][scalaDaysNyc2016Slides]) - - <a href="http://www.youtube.com/watch?feature=player_embedded&v=uaYKkpqs6CE" target="_blank"> - <img src="site/tech_talk_preview.png" alt="ScalaDays NYC 2016: Introduction to better-files" width="480" height="360" border="10" /> - </a> - - - [ScalaDays Berlin 2016][scalaDaysBerlin2016Event] ([video][scalaDaysBerlin2016Video], [slides][scalaDaysBerlin2016Slides]) - - [Scalæ by the Bay 2016][scalæByTheBay2016Event] ([video][scalæByTheBay2016Video], [slides][scalæByTheBay2016Slides]) - -## Tutorial [![Scaladoc][scaladocImg]][scaladocLink] - 0. [Instantiation](#instantiation) - 0. [Simple I/O](#file-readwrite) - 0. [Streams](#streams) - 0. [Encodings](#encodings) - 0. [Java serialization utils](#java-serialization-utils) - 0. [Java compatibility](#java-interoperability) - 0. [Globbing](#globbing) - 0. [File system operations](#file-system-operations) - 0. [Temporary files](#temporary-files) - 0. [UNIX DSL](#unix-dsl) - 0. [File attributes](#file-attributes) - 0. [File comparison](#file-comparison) - 0. [Zip/Unzip](#zip-apis) - 0. [Automatic Resource Management](#lightweight-arm) - 0. [Scanner](#scanner) - 0. [File Monitoring](#file-monitoring) - 0. [Reactive File Watcher](#akka-file-watcher) - -## sbt [![UpdateImpact][updateImpactImg]][updateImpactLink] -In your `build.sbt`, add this: -```scala -libraryDependencies += "com.github.pathikrit" %% "better-files" % version -``` -To use the [Akka based file monitor](akka), also add this: -```scala -libraryDependencies ++= Seq( - "com.github.pathikrit" %% "better-files-akka" % version, - "com.typesafe.akka" %% "akka-actor" % "2.5.6" -) -``` -Latest `version`: [![Maven][mavenImg]][mavenLink] [![Scaladex][scaladexImg]][scaladexLink] - -Although this library is currently only actively developed for Scala 2.12 and 2.13, -you can find reasonably recent versions of this library for Scala 2.10 and 2.11 [here](https://oss.sonatype.org/#nexus-search;quick~better-files). - -## Tests [![codecov][codecovImg]][codecovLink] -* [FileSpec](core/src/test/scala/better/files/FileSpec.scala) -* [FileWatcherSpec](akka/src/test/scala/better/files/FileWatcherSpec.scala) -* [Benchmarks](benchmarks/) - -[licenseImg]: https://img.shields.io/github/license/pathikrit/better-files.svg -[licenseImg2]: https://img.shields.io/:license-mit-blue.svg -[licenseLink]: LICENSE - -[circleCiImg]: https://img.shields.io/circleci/project/pathikrit/better-files/master.svg -[circleCiImg2]: https://circleci.com/gh/pathikrit/better-files/tree/master.svg -[circleCiLink]: https://circleci.com/gh/pathikrit/better-files - -[codecovImg]: https://img.shields.io/codecov/c/github/pathikrit/better-files/master.svg -[codecovImg2]: https://codecov.io/github/pathikrit/better-files/coverage.svg?branch=master -[codecovLink]: http://codecov.io/github/pathikrit/better-files?branch=master - -[codacyImg]: https://img.shields.io/codacy/0e2aeb7949bc49e6802afcc43a7a1aa1.svg -[codacyImg2]: https://api.codacy.com/project/badge/grade/0e2aeb7949bc49e6802afcc43a7a1aa1 -[codacyLink]: https://www.codacy.com/app/pathikrit/better-files/dashboard - -[mavenImg]: https://img.shields.io/maven-central/v/com.github.pathikrit/better-files_2.12.svg -[mavenImg2]: https://maven-badges.herokuapp.com/maven-central/com.github.pathikrit/better-files_2.12/badge.svg -[mavenLink]: http://search.maven.org/#search%7Cga%7C1%7Cbetter-files - -[gitterImg]: https://img.shields.io/gitter/room/pathikrit/better-files.svg -[gitterImg2]: https://badges.gitter.im/Join%20Chat.svg -[gitterLink]: https://gitter.im/pathikrit/better-files - -[scaladexImg]: https://index.scala-lang.org/pathikrit/better-files/better-files/latest.svg -[scaladexLink]: https://index.scala-lang.org/pathikrit/better-files - -[scaladocImg]: https://www.javadoc.io/badge/com.github.pathikrit/better-files_2.12.svg?color=blue&label=scaladocs -<!--[scaladocLink]: https://www.javadoc.io/page/com.github.pathikrit/better-files_2.12/latest/better/files/File.html--> -[scaladocLink]: http://pathikrit.github.io/better-files/latest/api/better/files/File.html - -[updateImpactImg]: https://app.updateimpact.com/badge/704376701047672832/root.svg?config=compile -[updateImpactLink]: https://app.updateimpact.com/latest/704376701047672832/root - -[scalaDaysNyc2016Event]: http://event.scaladays.org/scaladays-nyc-2016/#!#schedulePopupExtras-7664 -[scalaDaysNyc2016Video]: https://www.youtube.com/watch?v=uaYKkpqs6CE -<!--[scalaDaysNyc2016VideoPreview]: http://img.youtube.com/vi/uaYKkpqs6CE/0.jpg--> -[scalaDaysNyc2016VideoPreview]: site/tech_talk_preview.png -[scalaDaysNyc2016Slides]: https://slides.com/pathikrit/better-files/ - -[scalaDaysBerlin2016Event]: http://event.scaladays.org/scaladays-berlin-2016#!#schedulePopupExtras-7668 -[scalaDaysBerlin2016Video]: https://www.youtube.com/watch?v=m2YsD5cgnzI -[scalaDaysBerlin2016Slides]: https://slides.com/pathikrit/better-files/ - -[scalæByTheBay2016Event]: http://sched.co/7iUn -[scalæByTheBay2016Video]: https://www.youtube.com/watch?v=bLiCE6NGjrk&t=251s -[scalæByTheBay2016Slides]: https://slides.com/pathikrit/better-files/ - -------- -### Instantiation -The following are all equivalent: -```scala -import better.files._ -import java.io.{File => JFile} - -val f = File("/User/johndoe/Documents") // using constructor -val f1: File = file"/User/johndoe/Documents" // using string interpolator -val f2: File = "/User/johndoe/Documents".toFile // convert a string path to a file -val f3: File = new JFile("/User/johndoe/Documents").toScala // convert a Java file to Scala -val f4: File = root/"User"/"johndoe"/"Documents" // using root helper to start from root -val f5: File = `~` / "Documents" // also equivalent to `home / "Documents"` -val f6: File = "/User"/"johndoe"/"Documents" // using file separator DSL -val f7: File = "/User"/'johndoe/'Documents // same as above but using Symbols instead of Strings -val f8: File = home/"Documents"/"presentations"/`..` // use `..` to navigate up to parent -``` - -**Note**: Rename the import if you think the usage of the class `File` may confuse your teammates: -```scala -import better.files.{File => ScalaFile, _} -import java.io.File -``` -I personally prefer renaming the Java crap instead: -```scala -import better.files._ -import java.io.{File => JFile} -``` - -### File Read/Write -Dead simple I/O: -```scala -val file = root/"tmp"/"test.txt" -file.overwrite("hello") -file.appendLine().append("world") -assert(file.contentAsString == "hello\nworld") -``` -If you are someone who likes symbols, then the above code can also be written as: -```scala -import better.files.Dsl.SymbolicOperations - -file < "hello" // same as file.overwrite("hello") -file << "world" // same as file.appendLines("world") -assert(file! == "hello\nworld") -``` -Or even, right-associatively: -```scala -import better.files.Dsl.SymbolicOperations - -"hello" `>:` file -"world" >>: file -val bytes: Array[Byte] = file.loadBytes -``` -[Fluent Interface](https://en.wikipedia.org/wiki/Fluent_interface): -```scala - (root/"tmp"/"diary.txt") - .createIfNotExists() - .appendLine() - .appendLines("My name is", "Inigo Montoya") - .moveToDirectory(home/"Documents") - .renameTo("princess_diary.txt") - .changeExtensionTo(".md") - .lines -``` - -### Streams -Various ways to slurp a file without loading the contents into memory: - ```scala -val bytes : Iterator[Byte] = file.bytes -val chars : Iterator[Char] = file.chars -val lines : Iterator[String] = file.lineIterator //file.lines loads all lines in memory -``` -Note: The above APIs can be traversed at most once e.g. `file.bytes` is a `Iterator[Byte]` which only allows `TraversableOnce`. -To traverse it multiple times without creating a new iterator instance, convert it into some other collection e.g. `file.bytes.toStream` - -You can write an `Iterator[Byte]` or an `Iterator[String]` back to a file: -```scala -file.writeBytes(bytes) -file.printLines(lines) -``` - -### Encodings -You can supply your own charset too for anything that does a read/write (it assumes `java.nio.charset.Charset.defaultCharset()` if you don't provide one): -```scala -val content: String = file.contentAsString // default charset - -// custom charset: -import java.nio.charset.Charset -file.contentAsString(charset = Charset.forName("US-ASCII")) - -//or simply using implicit conversion from Strings -file.write("hello world")(charset = "US-ASCII") - ``` - -Note: By default, `better-files` [correctly handles BOMs while decoding](core/src/main/scala/better/files/UnicodeCharset.scala). -If you wish to have the [incorrect JDK behaviour](http://bugs.java.com/bugdatabase/view_bug.do?bug_id=4508058), -you would need to supply Java's UTF-8 charset e.g.: -```scala -file.contentAsString(charset = Charset.forName("UTF-8")) // Default incorrect JDK behaviour for UTF-8 (see: JDK-4508058) -``` - -If you also wish to write BOMs while encoding, you would need to supply it as: -```scala -file.write("hello world")(charset = UnicodeCharset("UTF-8", writeByteOrderMarkers = true)) -``` - -### Java serialization utils -Some common utils to serialize/deserialize using Java's serialization util -```scala -case class Person(name: String, age: Int) -val person = new Person("Chris", 24) - -// Write -file.newOutputStream.buffered.asObjectOutputStream.serialize(obj).flush() - -// Read -val person2 = file.newInputStream.buffered.asObjectInputStream.readObject().asInstanceOf[Person] -assert(person == person2) -``` - -The above can be simply written as: -```scala -val person2: Person = file.writeSerialized(person).readDeserialized[Person] -assert(person == person2) -``` - -### Java interoperability -You can always access the Java I/O classes: -```scala -val file: File = tmp / "hello.txt" -val javaFile : java.io.File = file.toJava -val uri : java.net.URI = file.uri -val url : java.net.URL = file.url -val reader : java.io.BufferedReader = file.newBufferedReader -val outputstream : java.io.OutputStream = file.newOutputStream -val writer : java.io.BufferedWriter = file.newBufferedWriter -val inputstream : java.io.InputStream = file.newInputStream -val path : java.nio.file.Path = file.path -val fs : java.nio.file.FileSystem = file.fileSystem -val channel : java.nio.channel.FileChannel = file.newFileChannel -val ram : java.io.RandomAccessFile = file.newRandomAccess -val fr : java.io.FileReader = file.newFileReader -val fw : java.io.FileWriter = file.newFileWriter(append = true) -val printer : java.io.PrintWriter = file.newPrintWriter -``` -The library also adds some useful [implicits](http://pathikrit.github.io/better-files/latest/api/better/files/Implicits.html) to above classes e.g.: -```scala -file1.reader > file2.writer // pipes a reader to a writer -System.in > file2.out // pipes an inputstream to an outputstream -src.pipeTo(sink) // if you don't like symbols - -val bytes : Iterator[Byte] = inputstream.bytes -val bis : BufferedInputStream = inputstream.buffered -val bos : BufferedOutputStream = outputstream.buffered -val reader : InputStreamReader = inputstream.reader -val writer : OutputStreamWriter = outputstream.writer -val printer : PrintWriter = outputstream.printWriter -val br : BufferedReader = reader.buffered -val bw : BufferedWriter = writer.buffered -val mm : MappedByteBuffer = fileChannel.toMappedByteBuffer -val str : String = inputstream.asString //Read a string from an InputStream -``` -`better-files` also supports [certain conversions that are not supported out of the box by the JDK](https://stackoverflow.com/questions/62241/how-to-convert-a-reader-to-inputstream-and-a-writer-to-outputstream) - -[`tee`](http://stackoverflow.com/questions/7987395/) multiple outputstreams: -```scala -val s3 = s1 tee s2 -s3.printWriter.println(s"Hello world") // gets written to both s1 and s2 -``` - -### Globbing -No need to port [this](http://docs.oracle.com/javase/tutorial/essential/io/find.html) to Scala: -```scala -val dir = "src"/"test" -val matches: Iterator[File] = dir.glob("*.{java,scala}") -// above code is equivalent to: -dir.listRecursively.filter(f => f.extension == Some(".java") || f.extension == Some(".scala")) -``` - -You can even use more advanced regex syntax instead of [glob syntax](http://docs.oracle.com/javase/tutorial/essential/io/fileOps.html#glob): -```scala -val matches = dir.globRegex("^\\w*$".r) //equivalent to dir.glob("^\\w*$")(syntax = File.PathMatcherSyntax.regex) -``` - -By default, glob syntax in `better-files` is [different from](https://github.com/pathikrit/better-files/issues/114) -the default JDK glob behaviour since it always includes path. To use the default behaviour: -```scala -dir.glob("**/*.txt", includePath = false) // JDK default -//OR -dir.glob("*.txt", includePath = true) // better-files default -``` -You can also extend the `File.PathMatcherSyntax` to create your own matchers. - -For custom cases: -```scala -dir.collectChildren(_.isSymbolicLink) // collect all symlinks in a directory -``` -For simpler cases, you can always use `dir.list` or `dir.walk(maxDepth: Int)` - -### File system operations -Utilities to `ls`, `cp`, `rm`, `mv`, `ln`, `md5`, `touch`, `cat` etc: -```scala -file.touch() -file.delete() // unlike the Java API, also works on directories as expected (deletes children recursively) -file.clear() // If directory, deletes all children; if file clears contents -file.renameTo(newName: String) -file.moveTo(destination) -file.moveToDirectory(destination) -file.copyTo(destination) // unlike the default API, also works on directories (copies recursively) -file.copyToDirectory(destination) -file.linkTo(destination) // ln destination file -file.symbolicLinkTo(destination) // ln -s destination file -file.{checksum, md5, sha1, sha256, sha512, digest} // also works for directories -file.setOwner(user: String) // chown user file -file.setGroup(group: String) // chgrp group file -Seq(file1, file2) `>:` file3 // same as cat file1 file2 > file3 (must import import better.files.Dsl.SymbolicOperations) -Seq(file1, file2) >>: file3 // same as cat file1 file2 >> file3 (must import import better.files.Dsl.SymbolicOperations) -file.isReadLocked; file.isWriteLocked; file.isLocked -File.numberOfOpenFileDescriptors // number of open file descriptors -``` -You can also load resources from your classpath using `File.resource` or `File.copyResource`. - -### Temporary files -Utils to create temporary files: -```scala -File.newTemporaryDirectory() -File.newTemporaryFile() -``` -The above APIs allow optional specifications of `prefix`, `suffix` and `parentDir`. -These files are [not deleted automatically on exit by the JVM](http://stackoverflow.com/questions/16691437/when-are-java-temporary-files-deleted) (you have to set `deleteOnExit` which adds to `shutdownHook`). - -A cleaner alternative is to use self-deleting file contexts which deletes the file immediately when done: -```scala -for { - tempFile <- File.temporaryFile() -} doSomething(tempFile) // tempFile is auto deleted at the end of this block - even if an exception happens -``` - -OR equivalently: -```scala -File.usingTemporaryFile() {tempFile => - //do something -} // tempFile is auto deleted at the end of this block - even if an exception happens -``` - -You can make any files temporary (i.e. delete after use) by doing this: -```scala -val foo = File.home / "Downloads" / "foo.txt" - -for { - temp <- foo.toTemporary -} doSomething(temp) // foo is deleted at the end of this block - even if an exception happens -``` - -### UNIX DSL -All the above can also be expressed using [methods](http://pathikrit.github.io/better-files/latest/api/better/files/Dsl$.html) reminiscent of the command line: -```scala -import better.files._ -import better.files.Dsl._ // must import Dsl._ to bring in these utils - -pwd / cwd // current dir -cp(file1, file2) -mv(file1, file2) -rm(file) /*or*/ del(file) -ls(file) /*or*/ dir(file) -ln(file1, file2) // hard link -ln_s(file1, file2) // soft link -cat(file1) -cat(file1) >>: file -touch(file) -mkdir(file) -mkdirs(file) // mkdir -p -chown(owner, file) -chgrp(owner, file) -chmod_+(permission, files) // add permission -chmod_-(permission, files) // remove permission -md5(file); sha1(file); sha256(file); sha512(file) -unzip(zipFile)(targetDir) -zip(file*)(targetZipFile) -``` - -### File attributes -Query various file attributes e.g.: -```scala -file.name // simpler than java.io.File#getName -file.extension -file.contentType -file.lastModifiedTime // returns JSR-310 time -file.owner -file.group -file.isDirectory; file.isSymbolicLink; file.isRegularFile -file.isHidden -file.hide(); file.unhide() -file.isOwnerExecutable; file.isGroupReadable // etc. see file.permissions -file.size // for a directory, computes the directory size -file.posixAttributes; file.dosAttributes // see file.attributes -file.isEmpty // true if file has no content (or no children if directory) or does not exist -file.isParentOf; file.isChildOf; file.isSiblingOf; file.siblings -file("dos:system") = true // set custom meta-data for file (similar to Files.setAttribute) -``` -All the above APIs let you specify the [`LinkOption`](http://docs.oracle.com/javase/8/docs/api/java/nio/file/LinkOption.html) either directly: -```scala -file.isDirectory(LinkOption.NOFOLLOW_LINKS) -``` -Or using the [`File.LinkOptions`](http://pathikrit.github.io/better-files/latest/api/better/files/File$$LinkOptions$.html) helper: -```scala -file.isDirectory(File.LinkOptions.noFollow) -``` - -`chmod`: -```scala -import java.nio.file.attribute.PosixFilePermission -file.addPermission(PosixFilePermission.OWNER_EXECUTE) // chmod +X file -file.removePermission(PosixFilePermission.OWNER_WRITE) // chmod -w file -assert(file.permissionsAsString == "rw-r--r--") - -// The following are all equivalent: -assert(file.permissions contains PosixFilePermission.OWNER_EXECUTE) -assert(file.testPermission(PosixFilePermission.OWNER_EXECUTE)) -assert(file.isOwnerExecutable) -``` - -### File comparison -Use `==` to check for path-based equality and `===` for content-based equality: -```scala -file1 == file2 // equivalent to `file1.isSamePathAs(file2)` -file1 === file2 // equivalent to `file1.isSameContentAs(file2)` (works for regular-files and directories) -file1 != file2 // equivalent to `!file1.isSamePathAs(file2)` -file1 !== file2 // equivalent to `!file1.isSameContentAs(file2)` -``` -There are also various [`Ordering[File]` instances](http://pathikrit.github.io/better-files/latest/api/better/files/File$$Order$.html) included, e.g.: -```scala -val files = myDir.list.toSeq -files.sorted(File.Order.byName) -files.max(File.Order.bySize) -files.min(File.Order.byDepth) -files.max(File.Order.byModificationTime) -files.sorted(File.Order.byDirectoriesFirst) -``` - -### Zip APIs -You don't have to lookup on StackOverflow "[How to zip/unzip in Java/Scala?](http://stackoverflow.com/questions/9324933/)": -```scala -// Unzipping: -val zipFile: File = file"path/to/research.zip" -val research: File = zipFile.unzipTo(destination = home/"Documents"/"research") - -// Zipping: -val zipFile: File = directory.zipTo(destination = home/"Desktop"/"toEmail.zip") - -// Zipping in: -val zipFile = File("countries.zip").zipIn(file"usa.txt", file"russia.txt") - -// Zipping/Unzipping to temporary files/directories: -val someTempZipFile: File = directory.zip() -val someTempDir: File = zipFile.unzip() -assert(directory === someTempDir) - -// Gzip handling: -File("countries.gz").newInputStream.gzipped.lines.take(10).foreach(println) -``` - -### Lightweight ARM -Auto-close Java closeables: -```scala -for { - in <- file1.newInputStream.autoClosed - out <- file2.newOutputStream.autoClosed -} in.pipeTo(out) -// The input and output streams are auto-closed once out of scope -``` -`better-files` provides convenient managed versions of all the Java closeables e.g. instead of writing: -```scala -for { - reader <- file.newBufferedReader.autoClosed -} foo(reader) -``` -You can write: -```scala -for { - reader <- file.bufferedReader // returns ManagedResource[BufferedReader] -} foo(reader) - -// or simply: -file.bufferedReader.foreach(foo) -``` - -You can also define your own custom disposable resources e.g.: -```scala -trait Shutdownable { - def shutdown(): Unit = () -} - -object Shutdownable { - implicit val disposable: Disposable[Shutdownable] = Disposable(_.shutdown()) -} - -val s: Shutdownable = .... - -for { - instance <- new ManagedResource(s) -} doSomething(s) // s is disposed after this -``` - -### Scanner -Although [`java.util.Scanner`](http://docs.oracle.com/javase/8/docs/api/java/util/Scanner.html) has a feature-rich API, it only allows parsing primitives. -It is also [notoriously slow](https://www.cpe.ku.ac.th/~jim/java-io.html) since it uses regexes and does un-Scala things like returns nulls and throws exceptions. - -`better-files` provides a [faster](benchmarks#benchmarks), richer, safer, more idiomatic and compossible [Scala replacement](http://pathikrit.github.io/better-files/latest/api/better/files/Scanner.html) -that [does not use regexes](core/src/main/scala/better/files/Scanner.scala), allows peeking, accessing line numbers, returns `Option`s whenever possible and lets the user mixin custom parsers: -```scala -val data = t1 << s""" - | Hello World - | 1 true 2 3 -""".stripMargin -val scanner: Scanner = data.newScanner() -assert(scanner.next[String] == "Hello") -assert(scanner.lineNumber == 1) -assert(scanner.next[String] == "World") -assert(scanner.next[(Int, Boolean)] == (1, true)) -assert(scanner.tillEndOfLine() == " 2 3") -assert(!scanner.hasNext) -``` -If you are simply interested in tokens, you can use `file.tokens()` - -Writing your own custom scanners: -```scala -sealed trait Animal -case class Dog(name: String) extends Animal -case class Cat(name: String) extends Animal - -implicit val animalParser: Scannable[Animal] = Scannable {scanner => - val name = scanner.next[String] - if (name == "Garfield") Cat(name) else Dog(name) -} - -val scanner = file.newScanner() -println(scanner.next[Animal]) -``` - -The [shapeless-scanner](shapeless/src/main/scala/better/files/ShapelessScanner.scala) module lets you scan [`HList`s](https://github.com/milessabin/shapeless/blob/master/core/src/main/scala/shapeless/hlists.scala): -```scala -val in = Scanner(""" - 12 Bob True - 13 Mary False - 26 Rick True -""") - -import shapeless._ - -type Row = Int :: String :: Boolean :: HNil - -val out = Seq.fill(3)(in.next[Row]) -assert(out == Seq( - 12 :: "Bob" :: true :: HNil, - 13 :: "Mary" :: false :: HNil, - 26 :: "Rick" :: true :: HNil -)) -``` - -[and case-classes](https://meta.plasm.us/posts/2015/11/08/type-classes-and-generic-derivation/): - -```scala -case class Person(id: Int, name: String, isMale: Boolean) -val out2 = Seq.fill(3)(in.next[Person]) -``` - -Simple CSV reader: -```scala -val file = """ - 23,foo - 42,bar -""" -val csvScanner = file.newScanner(StringSpliiter.on(',')) -csvScanner.next[Int] //23 -csvScanner.next[String] //foo -``` - -### File Monitoring -Vanilla Java watchers: -```scala -import java.nio.file.{StandardWatchEventKinds => EventType} -val service: java.nio.file.WatchService = myDir.newWatchService -myDir.register(service, events = Seq(EventType.ENTRY_CREATE, EventType.ENTRY_DELETE)) -``` -The above APIs are [cumbersome to use](https://docs.oracle.com/javase/tutorial/essential/io/notification.html#process) (involves a lot of type-casting and null-checking), -are based on a blocking [polling-based model](http://docs.oracle.com/javase/8/docs/api/java/nio/file/WatchKey.html), -does not easily allow [recursive watching of directories](https://docs.oracle.com/javase/tutorial/displayCode.html?code=https://docs.oracle.com/javase/tutorial/essential/io/examples/WatchDir.java) -and nor does it easily allow [watching regular files](http://stackoverflow.com/questions/16251273/) without writing a lot of Java boilerplate. - -`better-files` abstracts all the above ugliness behind a [simple interface](core/src/main/scala/better/files/File.scala#1100): -```scala -val watcher = new FileMonitor(myDir, recursive = true) { - override def onCreate(file: File, count: Int) = println(s"$file got created") - override def onModify(file: File, count: Int) = println(s"$file got modified $count times") - override def onDelete(file: File, count: Int) = println(s"$file got deleted") -} -watcher.start() -``` -Sometimes, instead of overwriting each of the 3 methods above, it is more convenient to override the dispatcher itself: -```scala -import java.nio.file.{Path, StandardWatchEventKinds => EventType, WatchEvent} - -val watcher = new FileMonitor(myDir, recursive = true) { - override def onEvent(eventType: WatchEvent.Kind[Path], file: File, count: Int) = eventType match { - case EventType.ENTRY_CREATE => println(s"$file got created") - case EventType.ENTRY_MODIFY => println(s"$file got modified $count") - case EventType.ENTRY_DELETE => println(s"$file got deleted") - } -} -``` - -### Akka File Watcher -`better-files` also provides a powerful yet concise [reactive file watcher](akka/src/main/scala/better/files/FileWatcher.scala) -based on [Akka actors](http://doc.akka.io/docs/akka/snapshot/scala/actors.html) that supports dynamic dispatches: - ```scala -import akka.actor.{ActorRef, ActorSystem} -import better.files._, FileWatcher._ - -implicit val system = ActorSystem("mySystem") - -val watcher: ActorRef = (home/"Downloads").newWatcher(recursive = true) - -// register partial function for an event -watcher ! on(EventType.ENTRY_DELETE) { - case file if file.isDirectory => println(s"$file got deleted") -} - -// watch for multiple events -watcher ! when(events = EventType.ENTRY_CREATE, EventType.ENTRY_MODIFY) { - case (EventType.ENTRY_CREATE, file, count) => println(s"$file got created") - case (EventType.ENTRY_MODIFY, file, count) => println(s"$file got modified $count times") -} -``` diff --git a/scalalib/src/test/resource/better-files/akka/README.md b/scalalib/src/test/resource/better-files/akka/README.md deleted file mode 100644 index 391cec2e..00000000 --- a/scalalib/src/test/resource/better-files/akka/README.md +++ /dev/null @@ -1,394 +0,0 @@ -Reproduction of [this Java Advent article](http://www.javaadvent.com/2015/12/reactive-file-system-monitoring-using-akka-actors.html) - ------ - -In this article, we will discuss: - -0. File system monitoring using [Java NIO.2][nio2] -1. Common pitfalls of the default Java library -2. Design a simple thread-based file system monitor -3. Use the above to design a reactive file system monitor using the [actor][akka] [model][actorModel] - -**Note**: Although all the code samples here are in Scala, it can be rewritten in simple Java too. To quickly familiarize yourself with Scala syntax, [here is a very short and nice Scala cheatsheet][cheatsheet]. For a more comprehensive guide to Scala for Java programmers, [consult this][cheatsheet2] (not needed to follow this article). - -For the absolute shortest cheatsheet, the following Java code: - -```java -public void foo(int x, int y) { - int z = x + y - if (z == 1) { - System.out.println(x); - } else { - System.out.println(y); - } -} -``` - -is equivalent to the following Scala code: - -```scala -def foo(x: Int, y: Int): Unit = { - val z: Int = x + y - z match { - case 1 => println(x) - case _ => println(y) - } -} -``` - - -All the code presented here is available under MIT license as part of the [better-files][better-files-watcher] library on [GitHub][better-files]. - ------------ - -Let's say you are tasked to build a cross-platform desktop file-search engine. You quickly realize that after the initial indexing of all the files, you need to also quickly reindex any new files (or directories) that got created or updated. A naive way would be to simply rescan the entire file system every few minutes; but that would be incredibly inefficient since most operating systems expose file system notification APIs that allow the application programmer to register callbacks for changes e.g. [ionotify][ionotify-wiki] in Linux, [FSEvenets][fsevents-wiki] in Mac and [FindFirstChangeNotification][FindFirstChangeNotification] in Windows. - -But now you are stuck dealing with OS-specific APIs! Thankfully, beginning Java SE 7, we have a platform independent abstraction for watching file system changes via the [WatchService API][javadoc-watchservice]. The WatchService API was developed as part of [Java NIO.2][nio2-wiki], under [JSR-51][jsr-51] and here is a "hello world" example of using it to watch a given [Path][javadoc-path]: - -```scala -import java.nio.file._ -import java.nio.file.StandardWatchEventKinds._ -import scala.collection.JavaConversions._ - -def watch(directory: Path): Unit = { - // First create the service - val service: WatchService = directory.getFileSystem.newWatchService() - - // Register the service to the path and also specify which events we want to be notified about - directory.register(service, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY) - - while (true) { - val key: WatchKey = service.take() // Wait for this key to be signalled - for {event <- key.pollEvents()} { - // event.context() is the path to the file that got changed - event.kind() match { - case ENTRY_CREATE => println(s"${event.context()} got created") - case ENTRY_MODIFY => println(s"${event.context()} got modified") - case ENTRY_DELETE => println(s"${event.context()} got deleted") - case _ => - // This can happen when OS discards or loses an event. - // See: http://docs.oracle.com/javase/8/docs/api/java/nio/file/StandardWatchEventKinds.html#OVERFLOW - println(s"Unknown event $event happened at ${event.context()}") - } - } - key.reset() // Do not forget to do this!! See: http://stackoverflow.com/questions/20180547/ - } -} -``` - -Although the above is a good first attempt, it lacks in several aspects: - -0. **Bad Design**: The above code looks unnatural and you probably had to [look it up on StackOverflow][so-down] to get it right. Can we do better? -2. **Bad Design**: The code does not do a very good job of handling errors. What happens when we encounter a file we could not open? -3. **Gotcha**: The Java API only allows us to watch the directory for changes to its direct children; it [does not recursively watch a directory][so-recursive-watching] for you. -4. **Gotcha**: The Java API [does not allow us to watch a single file][so-only-watch-dirs], only a directory. -5. **Gotcha**: Even if we resolve the aformentioned issues, the Java API [does not automatically start watching a new child file][so-autowatch] or directory created under the root. -6. **Bad Design**: The code as implemented above, exposes a blocking/polling, thread-based model. Can we use a better concurrency abstraction? - ------------ - - -Let's start with each of the above concerns. - -* **A better interface**: Here is what *my ideal* interface would look like: - -```scala -abstract class FileMonitor(root: Path) { - def start(): Unit - def onCreate(path: Path): Unit - def onModify(path: Path): Unit - def onDelete(path: Path): Unit - def stop(): Unit -} -``` - -That way, I can simply write the example code as: - -```scala -val watcher = new FileMonitor(myFile) { - override def onCreate(path: Path) = println(s"$path got created") - override def onModify(path: Path) = println(s"$path got modified") - override def onDelete(path: Path) = println(s"$path got deleted") -} -watcher.start() -``` - -Ok, let's try to adapt the first example using a Java `Thread` so that we can expose "my ideal interface": - -```scala -trait FileMonitor { // My ideal interface - val root: Path // starting file - def start(): Unit // start the monitor - def onCreate(path: Path) = {} // on-create callback - def onModify(path: Path) = {} // on-modify callback - def onDelete(path: Path) = {} // on-delete callback - def onUnknownEvent(event: WatchEvent[_]) = {} // handle lost/discarded events - def onException(e: Throwable) = {} // handle errors e.g. a read error - def stop(): Unit // stop the monitor -} -``` - -And here is a very basic thread-based implementation: - -```scala -class ThreadFileMonitor(val root: Path) extends Thread with FileMonitor { - setDaemon(true) // daemonize this thread - setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler { - override def uncaughtException(thread: Thread, exception: Throwable) = onException(exception) - }) - - val service = root.getFileSystem.newWatchService() - - override def run() = Iterator.continually(service.take()).foreach(process) - - override def interrupt() = { - service.close() - super.interrupt() - } - - override def start() = { - watch(root) - super.start() - } - - protected[this] def watch(file: Path): Unit = { - file.register(service, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY) - } - - protected[this] def process(key: WatchKey) = { - key.pollEvents() foreach { - case event: WatchEvent[Path] => dispatch(event.kind(), event.context()) - case event => onUnknownEvent(event) - } - key.reset() - } - - def dispatch(eventType: WatchEvent.Kind[Path], file: Path): Unit = { - eventType match { - case ENTRY_CREATE => onCreate(file) - case ENTRY_MODIFY => onModify(file) - case ENTRY_DELETE => onDelete(file) - } - } -} -``` - -The above looks much cleaner! Now we can watch files to our heart's content without poring over the details of JavaDocs by simply implementing the `onCreate(path)`, `onModify(path)`, `onDelete(path)` etc. - -* **Exception handling**: This is already done above. `onException` gets called whenever we encounter an exception and the invoker can decide what to do next by implementing it. - -* **Recursive watching**: The Java API **does not allow recursive watching of directories**. We need to modify the `watch(file)` to recursively attach the watcher: - -```scala -def watch(file: Path, recursive: Boolean = true): Unit = { - if (Files.isDirectory(file)) { - file.register(service, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY) - // recursively call watch on children of this file - if (recursive) { - Files.list(file).iterator() foreach {f => watch(f, recursive)} - } - } -} -``` - -* **Watching regular files**: As mentioned before, the Java API **can only watch directories**. One hack we can do to watch single files is to set a watcher on its parent directory and only react if the event trigerred on the file itself. - -```scala -override def start() = { - if (Files.isDirectory(root)) { - watch(root, recursive = true) - } else { - watch(root.getParent, recursive = false) - } - super.start() -} -``` - -And, now in `process(key)`, we make sure we react to either a directory or that file only: - -```scala -def reactTo(target: Path) = Files.isDirectory(root) || (root == target) -``` - -And, we check before `dispatch` now: - -```scala -case event: WatchEvent[Path] => - val target = event.context() - if (reactTo(target)) { - dispatch(event.kind(), target) - } -``` - -* **Auto-watching new items**: The Java API, **does not auto-watch any new sub-files**. We can address this by attaching the watcher ourselves in `process(key)` when an `ENTRY_CREATE` event is fired: - -```scala -if (reactTo(target)) { - if (Files.isDirectory(root) && event.kind() == ENTRY_CREATE) { - watch(root.resolve(target)) - } - dispatch(event.kind(), target) -} -``` - -Putting it all together, we have our final [`FileMonitor.scala`][FileMonitor.scala]: - -```scala -class ThreadFileMonitor(val root: Path) extends Thread with FileMonitor { - setDaemon(true) // daemonize this thread - setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler { - override def uncaughtException(thread: Thread, exception: Throwable) = onException(exception) - }) - - val service = root.getFileSystem.newWatchService() - - override def run() = Iterator.continually(service.take()).foreach(process) - - override def interrupt() = { - service.close() - super.interrupt() - } - - override def start() = { - if (Files.isDirectory(root)) { - watch(root, recursive = true) - } else { - watch(root.getParent, recursive = false) - } - super.start() - } - - protected[this] def watch(file: Path, recursive: Boolean = true): Unit = { - if (Files.isDirectory(file)) { - file.register(service, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY) - if (recursive) { - Files.list(file).iterator() foreach {f => watch(f, recursive)} - } - } - } - - private[this] def reactTo(target: Path) = Files.isDirectory(root) || (root == target) - - protected[this] def process(key: WatchKey) = { - key.pollEvents() foreach { - case event: WatchEvent[Path] => - val target = event.context() - if (reactTo(target)) { - if (Files.isDirectory(root) && event.kind() == ENTRY_CREATE) { - watch(root.resolve(target)) - } - dispatch(event.kind(), target) - } - case event => onUnknownEvent(event) - } - key.reset() - } - - def dispatch(eventType: WatchEvent.Kind[Path], file: Path): Unit = { - eventType match { - case ENTRY_CREATE => onCreate(file) - case ENTRY_MODIFY => onModify(file) - case ENTRY_DELETE => onDelete(file) - } - } -} -``` - ------ -Now, that we have addressed all the gotchas and distanced ourselves from the intricacies of the WatchService API, we are still tightly coupled to the thread-based API. -We will use the above class to expose a different concurrency model, namely, the [actor model][actorModel2] instead to design a reactive, dynamic and resilient file-system watcher using [Akka][akka-docs]. Although the [construction of Akka actors][akka-actors] is beyond the scope of this article, we will present a very simple actor that uses the `ThreadFileMonitor`: - -```scala -import java.nio.file.{Path, WatchEvent} - -import akka.actor._ - -class FileWatcher(file: Path) extends ThreadFileMonitor(file) with Actor { - import FileWatcher._ - - // MultiMap from Events to registered callbacks - protected[this] val callbacks = newMultiMap[Event, Callback] - - // Override the dispatcher from ThreadFileMonitor to inform the actor of a new event - override def dispatch(event: Event, file: Path) = self ! Message.NewEvent(event, file) - - // Override the onException from the ThreadFileMonitor - override def onException(exception: Throwable) = self ! Status.Failure(exception) - - // when actor starts, start the ThreadFileMonitor - override def preStart() = super.start() - - // before actor stops, stop the ThreadFileMonitor - override def postStop() = super.interrupt() - - override def receive = { - case Message.NewEvent(event, target) if callbacks contains event => - callbacks(event) foreach {f => f(event -> target)} - - case Message.RegisterCallback(events, callback) => - events foreach {event => callbacks.addBinding(event, callback)} - - case Message.RemoveCallback(event, callback) => - callbacks.removeBinding(event, callback) - } -} - -object FileWatcher { - type Event = WatchEvent.Kind[Path] - type Callback = PartialFunction[(Event, Path), Unit] - - sealed trait Message - object Message { - case class NewEvent(event: Event, file: Path) extends Message - case class RegisterCallback(events: Seq[Event], callback: Callback) extends Message - case class RemoveCallback(event: Event, callback: Callback) extends Message - } -} -``` - -This allows us to dynamically register and remove callbacks to react to file system events: - -```scala -// initialize the actor instance -val system = ActorSystem("mySystem") -val watcher: ActorRef = system.actorOf(Props(new FileWatcher(Paths.get("/home/pathikrit")))) - -// util to create a RegisterCallback message for the actor -def when(events: Event*)(callback: Callback): Message = { - Message.RegisterCallback(events.distinct, callback) -} - -// send the register callback message for create/modify events -watcher ! when(events = ENTRY_CREATE, ENTRY_MODIFY) { - case (ENTRY_CREATE, file) => println(s"$file got created") - case (ENTRY_MODIFY, file) => println(s"$file got modified") -} -``` - -Full source: [`FileWatcher.scala`][FileWatcher.scala] - ------ - -[actorModel]: https://en.wikipedia.org/wiki/Actor_model -[actorModel2]: http://berb.github.io/diploma-thesis/original/054_actors.html -[akka]: http://akka.io -[akka-actors]: http://doc.akka.io/docs/akka/snapshot/scala/actors.html -[akka-docs]: http://doc.akka.io/docs/akka/2.4.1/java.html -[better-files]: https://github.com/pathikrit/better-files -[better-files-watcher]: https://github.com/pathikrit/better-files#akka-file-watcher -[cheatsheet]: http://learnxinyminutes.com/docs/scala/ -[cheatsheet2]: http://techblog.realestate.com.au/java-to-scala-cheatsheet/ -[FileWatcher.scala]: https://github.com/pathikrit/better-files/blob/2ea6bb694551f1fe6e9ce58dbd1b814391a02e5a/akka/src/main/scala/better/files/FileWatcher.scala -[FileMonitor.scala]: https://github.com/pathikrit/better-files/blob/2ea6bb694551f1fe6e9ce58dbd1b814391a02e5a/core/src/main/scala/better/files/FileMonitor.scala -[FindFirstChangeNotification]: https://msdn.microsoft.com/en-us/library/aa364417(VS.85).aspx -[fsevents-wiki]: https://en.wikipedia.org/wiki/FSEvents -[ionotify-wiki]: https://en.wikipedia.org/wiki/Inotify -[nio2]: https://docs.oracle.com/javase/tutorial/essential/io/fileio.html -[nio2-wiki]: https://en.wikipedia.org/wiki/Non-blocking_I/O_(Java) -[jsr-51]: https://www.jcp.org/en/jsr/detail?id=51 -[javadoc-path]: https://docs.oracle.com/javase/8/docs/api/java/nio/file/Path.html -[javadoc-watchservice]: https://docs.oracle.com/javase/8/docs/api/java/nio/file/WatchService.html -[so-autowatch]: https://github.com/lloydmeta/schwatcher/issues/44 -[so-down]: http://memecrunch.com/meme/YBHZ/stackoverflow-is-down/image.jpg -[so-recursive-watching]: http://stackoverflow.com/questions/18701242/how-to-watch-a-folder-and-subfolders-for-changes -[so-only-watch-dirs]: http://stackoverflow.com/questions/16251273/can-i-watch-for-single-file-change-with-watchservice-not-the-whole-directory diff --git a/scalalib/src/test/resource/better-files/akka/src/main/scala/better/files/FileWatcher.scala b/scalalib/src/test/resource/better-files/akka/src/main/scala/better/files/FileWatcher.scala deleted file mode 100644 index 66594d20..00000000 --- a/scalalib/src/test/resource/better-files/akka/src/main/scala/better/files/FileWatcher.scala +++ /dev/null @@ -1,67 +0,0 @@ -package better.files - -import akka.actor._ - -/** - * An actor that can watch a file or a directory - * Instead of directly calling the constructor of this, call file.newWatcher to create the actor - * - * @param file watch this file (or directory) - * @param maxDepth In case of directories, how much depth should we watch - */ -class FileWatcher(file: File, maxDepth: Int) extends Actor { - import FileWatcher._ - - def this(file: File, recursive: Boolean = true) = this(file, if (recursive) Int.MaxValue else 0) - - protected[this] val callbacks = newMultiMap[Event, Callback] - - protected[this] val monitor: File.Monitor = new FileMonitor(file, maxDepth) { - override def onEvent(event: Event, file: File, count: Int) = self ! Message.NewEvent(event, file, count) - override def onException(exception: Throwable) = self ! Status.Failure(exception) - } - - override def preStart() = monitor.start()(executionContext = context.dispatcher) - - override def receive = { - case Message.NewEvent(event, target, count) if callbacks.contains(event) => callbacks(event).foreach(f => repeat(count)(f(event -> target))) - case Message.RegisterCallback(events, callback) => events.foreach(event => callbacks.addBinding(event, callback)) - case Message.RemoveCallback(event, callback) => callbacks.removeBinding(event, callback) - } - - override def postStop() = monitor.stop() -} - -object FileWatcher { - import java.nio.file.{Path, WatchEvent} - - type Event = WatchEvent.Kind[Path] - type Callback = PartialFunction[(Event, File), Unit] - - sealed trait Message - object Message { - case class NewEvent(event: Event, file: File, count: Int) extends Message - case class RegisterCallback(events: Traversable[Event], callback: Callback) extends Message - case class RemoveCallback(event: Event, callback: Callback) extends Message - } - - implicit val disposeActorSystem: Disposable[ActorSystem] = - Disposable(_.terminate()) - - implicit class FileWatcherOps(file: File) { - def watcherProps(recursive: Boolean): Props = - Props(new FileWatcher(file, recursive)) - - def newWatcher(recursive: Boolean = true)(implicit system: ActorSystem): ActorRef = - system.actorOf(watcherProps(recursive)) - } - - def when(events: Event*)(callback: Callback): Message = - Message.RegisterCallback(events, callback) - - def on(event: Event)(callback: File => Unit): Message = - when(event) { case (`event`, file) => callback(file) } - - def stop(event: Event, callback: Callback): Message = - Message.RemoveCallback(event, callback) -} diff --git a/scalalib/src/test/resource/better-files/akka/src/test/scala/better/files/FileWatcherSpec.scala b/scalalib/src/test/resource/better-files/akka/src/test/scala/better/files/FileWatcherSpec.scala deleted file mode 100644 index 014373cd..00000000 --- a/scalalib/src/test/resource/better-files/akka/src/test/scala/better/files/FileWatcherSpec.scala +++ /dev/null @@ -1,101 +0,0 @@ -package better.files - -import Dsl._ - -import scala.concurrent.duration._ -import scala.collection.mutable -import scala.language.postfixOps - -class FileWatcherSpec extends CommonSpec { - "file watcher" should "watch directories" in { - assume(isCI) - File.usingTemporaryDirectory() {dir => - (dir / "a" / "b" / "c.txt").createIfNotExists(createParents = true) - - var actualEvents = List.empty[String] - def output(file: File, event: String) = synchronized { - val msg = s"${dir.path relativize file.path} got $event" - println(msg) - actualEvents = msg :: actualEvents - } - /***************************************************************************/ - import java.nio.file.{StandardWatchEventKinds => Events} - import FileWatcher._ - - import akka.actor.{ActorRef, ActorSystem} - implicit val system = ActorSystem() - - val watcher: ActorRef = dir.newWatcher() - - watcher ! when(events = Events.ENTRY_CREATE, Events.ENTRY_MODIFY) { // watch for multiple events - case (Events.ENTRY_CREATE, file) => output(file, "created") - case (Events.ENTRY_MODIFY, file) => output(file, "modified") - } - - watcher ! on(Events.ENTRY_DELETE)(file => output(file, "deleted")) // register partial function for single event - /***************************************************************************/ - sleep(5 seconds) - - val expectedEvents = mutable.ListBuffer.empty[String] - - def doIO[U](logs: String*)(f: => U): Unit = { - expectedEvents ++= logs - f - sleep() - } - - doIO("a/b/c.txt got modified") { - (dir / "a" / "b" / "c.txt").writeText("Hello world") - } - doIO("a/b got deleted", "a/b/c.txt got deleted") { - rm(dir / "a" / "b") - } - doIO("d got created") { - mkdir(dir / "d") - } - doIO("d/e.txt got created") { - touch(dir / "d" / "e.txt") - } - doIO("d/f got created") { - mkdirs(dir / "d" / "f" / "g") - } - doIO("d/f/g/e.txt got created") { - touch(dir / "d" / "f" / "g" / "e.txt") - } - - doIO("a/e.txt got created", "d/f/g/e.txt got deleted") { - (dir / "d" / "f" / "g" / "e.txt") moveTo (dir / "a" / "e.txt") - } - - sleep(10 seconds) - - println( - s""" - |Expected=${expectedEvents.sorted} - |Actual=${actualEvents.sorted} - |""".stripMargin) - - expectedEvents.diff(actualEvents) shouldBe empty - - def checkNotWatching[U](msg: String)(f: => U) = { - val before = List(actualEvents : _*) - f - sleep() - val after = List(actualEvents : _*) - assert(before === after, msg) - } - - system.stop(watcher) - sleep() - checkNotWatching("stop watching after actor is stopped") { - mkdirs(dir / "e") - } - - system.terminate() - sleep() - checkNotWatching("stop watching after actor-system is stopped") { - mkdirs(dir / "f") - } - } - } -} diff --git a/scalalib/src/test/resource/better-files/benchmarks/README.md b/scalalib/src/test/resource/better-files/benchmarks/README.md deleted file mode 100644 index ed092ece..00000000 --- a/scalalib/src/test/resource/better-files/benchmarks/README.md +++ /dev/null @@ -1,24 +0,0 @@ -Benchmarks -==== -* [Scanner benchmarks](src/main/scala/better/files/Scanners.scala): -``` -> sbt "benchmarks/test" -JavaScanner : 2191 ms -StringBuilderScanner : 1325 ms -CharBufferScanner : 1117 ms -StreamingScanner : 212 ms -IterableScanner : 365 ms -IteratorScanner : 297 ms -BetterFilesScanner : 272 ms -ArrayBufferScanner : 220 ms -FastJavaIOScanner2 : 181 ms -FastJavaIOScanner : 179 ms -``` - ----- - -[![YourKit](https://www.yourkit.com/images/yklogo.png)](https://www.yourkit.com/) - -YourKit supports better-files with its full-featured Java Profiler. -YourKit, LLC is the creator of [YourKit Java Profiler](https://www.yourkit.com/java/profiler/) and [YourKit .NET Profiler](https://www.yourkit.com/.net/profiler/), -innovative and intelligent tools for profiling Java and .NET applications. diff --git a/scalalib/src/test/resource/better-files/benchmarks/src/main/java/better/files/ArrayBufferScanner.java b/scalalib/src/test/resource/better-files/benchmarks/src/main/java/better/files/ArrayBufferScanner.java deleted file mode 100644 index 50550704..00000000 --- a/scalalib/src/test/resource/better-files/benchmarks/src/main/java/better/files/ArrayBufferScanner.java +++ /dev/null @@ -1,78 +0,0 @@ -package better.files; - -import java.io.BufferedReader; -import java.io.IOException; -import java.io.UncheckedIOException; -import java.util.Arrays; - -/** - * Hand built using a char buffer - */ -public class ArrayBufferScanner extends AbstractScanner { - private char[] buffer = new char[1 << 4]; - private int pos = 1; - - private BufferedReader reader; - - public ArrayBufferScanner(BufferedReader reader) { - super(reader); - this.reader = reader; - } - - @Override - public boolean hasNext() { - return pos > 0; - } - - private void loadBuffer() { - pos = 0; - try { - for (int i; (i = reader.read()) != -1; ) { - char c = (char) i; - if (c != ' ' && c != '\n' && c != '\t' && c != '\r' && c != '\f') { - if (pos == buffer.length) buffer = Arrays.copyOf(buffer, 2 * pos); - buffer[pos++] = c; - } else if (pos != 0) break; - } - } catch (IOException e) { - throw new UncheckedIOException(e); - } - } - - public String current() { - return String.copyValueOf(buffer, 0, pos); - } - - @Override - public String next() { - loadBuffer(); - return current(); - } - - @Override - public String nextLine() { - try { - return reader.readLine(); - } catch (IOException e) { - throw new UncheckedIOException(e); - } - } - - @Override - public int nextInt() { - loadBuffer(); - final int radix = 10; - int result = 0; - int i = buffer[0] == '-' || buffer[0] == '+' ? 1 : 0; - for (checkValidNumber(pos > i); i < pos; i++) { - int digit = buffer[i] - '0'; - checkValidNumber(0 <= digit && digit <= 9); - result = result * radix + digit; - } - return buffer[0] == '-' ? -result : result; - } - - private void checkValidNumber(boolean condition) { - if (!condition) throw new NumberFormatException(current()); - } -} diff --git a/scalalib/src/test/resource/better-files/benchmarks/src/main/scala/better/files/Scanners.scala b/scalalib/src/test/resource/better-files/benchmarks/src/main/scala/better/files/Scanners.scala deleted file mode 100644 index 791e6039..00000000 --- a/scalalib/src/test/resource/better-files/benchmarks/src/main/scala/better/files/Scanners.scala +++ /dev/null @@ -1,158 +0,0 @@ -package better.files - -import java.io.BufferedReader - -/** - * Base interface to test - */ -abstract class AbstractScanner(protected[this] val reader: BufferedReader) { - def hasNext: Boolean - def next(): String - def nextInt() = next().toInt - def nextLine() = reader.readLine() - def close() = reader.close() -} - -/** - * Based on java.util.Scanner - */ -class JavaScanner(reader: BufferedReader) extends AbstractScanner(reader) { - private[this] val scanner = new java.util.Scanner(reader) - override def hasNext = scanner.hasNext - override def next() = scanner.next() - override def nextInt() = scanner.nextInt() - override def nextLine() = { - scanner.nextLine() - scanner.nextLine() - } - override def close() = scanner.close() -} - -/** - * Based on StringTokenizer + resetting the iterator - */ -class IterableScanner(reader: BufferedReader) extends AbstractScanner(reader) with Iterable[String] { - override def iterator = for { - line <- Iterator.continually(reader.readLine()).takeWhile(_ != null) - tokenizer = new java.util.StringTokenizer(line) - _ <- Iterator.continually(tokenizer).takeWhile(_.hasMoreTokens) - } yield tokenizer.nextToken() - - private[this] var current = iterator - override def hasNext = current.hasNext - override def next() = current.next() - override def nextLine() = { - current = iterator - super.nextLine() - } -} - -/** - * Based on a mutating var StringTokenizer - */ -class IteratorScanner(reader: BufferedReader) extends AbstractScanner(reader) with Iterator[String] { - import java.util.StringTokenizer - private[this] val tokenizers = Iterator.continually(reader.readLine()).takeWhile(_ != null).map(new StringTokenizer(_)).filter(_.hasMoreTokens) - private[this] var current: Option[StringTokenizer] = None - - @inline private[this] def tokenizer(): Option[StringTokenizer] = current.find(_.hasMoreTokens) orElse { - current = if (tokenizers.hasNext) Some(tokenizers.next()) else None - current - } - override def hasNext = tokenizer().nonEmpty - override def next() = tokenizer().get.nextToken() - override def nextLine() = { - current = None - super.nextLine() - } -} - -/** - * Based on java.io.StreamTokenizer - */ -class StreamingScanner(reader: BufferedReader) extends AbstractScanner(reader) with Iterator[String] { - import java.io.StreamTokenizer - private[this] val in = new StreamTokenizer(reader) - - override def hasNext = in.ttype != StreamTokenizer.TT_EOF - override def next() = { - in.nextToken() - in.sval - } - override def nextInt() = nextDouble().toInt - def nextDouble() = { - in.nextToken() - in.nval - } -} - -/** - * Based on a reusable StringBuilder - */ -class StringBuilderScanner(reader: BufferedReader) extends AbstractScanner(reader) with Iterator[String] { - private[this] val chars = reader.chars - private[this] val buffer = new StringBuilder() - - override def next() = { - buffer.clear() - while (buffer.isEmpty && hasNext) { - chars.takeWhile(c => !c.isWhitespace).foreach(buffer += _) - } - buffer.toString() - } - override def hasNext = chars.hasNext -} - -/** - * Scala version of the ArrayBufferScanner - */ -class CharBufferScanner(reader: BufferedReader) extends AbstractScanner(reader) with Iterator[String] { - private[this] val chars = reader.chars - private[this] var buffer = Array.ofDim[Char](1<<4) - - override def next() = { - var pos = 0 - while (pos == 0 && hasNext) { - for { - c <- chars.takeWhile(c => c != ' ' && c != '\n') - } { - if (pos == buffer.length) buffer = java.util.Arrays.copyOf(buffer, 2 * pos) - buffer(pos) = c - pos += 1 - } - } - String.copyValueOf(buffer, 0, pos) - } - override def hasNext = chars.hasNext -} - -/** - * Scanner using https://github.com/williamfiset/FastJavaIO - */ -class FastJavaIOScanner(reader: BufferedReader) extends AbstractScanner(reader) { - protected def is: java.io.InputStream = new org.apache.commons.io.input.ReaderInputStream(reader, defaultCharset) - - private[this] val fastReader = new fastjavaio.InputReader(is) - - override def hasNext = true //TODO: https://github.com/williamfiset/FastJavaIO/issues/3 - override def next() = fastReader.readStr() - override def nextInt() = fastReader.readInt() - override def nextLine() = fastReader.readLine() -} - -/** - * Same as FastJavaIOScanner but uses better-files's Reader => InputStream - */ -class FastJavaIOScanner2(reader: BufferedReader) extends FastJavaIOScanner(reader) { - override def is = reader.toInputStream -} - -/** - * Based on the better-files implementation - */ -class BetterFilesScanner(reader: BufferedReader) extends AbstractScanner(reader) { - private[this] val scanner = Scanner(reader) - override def hasNext = scanner.hasNext - override def next() = scanner.next - override def nextLine() = scanner.nextLine() -} diff --git a/scalalib/src/test/resource/better-files/benchmarks/src/test/scala/better/files/Benchmark.scala b/scalalib/src/test/resource/better-files/benchmarks/src/test/scala/better/files/Benchmark.scala deleted file mode 100644 index 68b734e1..00000000 --- a/scalalib/src/test/resource/better-files/benchmarks/src/test/scala/better/files/Benchmark.scala +++ /dev/null @@ -1,10 +0,0 @@ -package better.files - -import org.scalatest.FunSuite - -trait Benchmark extends FunSuite { - def profile[A](f: => A): (A, Long) = { - val t = System.nanoTime() - (f, ((System.nanoTime() - t)/1e6).toLong) - } -} diff --git a/scalalib/src/test/resource/better-files/benchmarks/src/test/scala/better/files/EncodingBenchmark.scala b/scalalib/src/test/resource/better-files/benchmarks/src/test/scala/better/files/EncodingBenchmark.scala deleted file mode 100644 index aa09bc77..00000000 --- a/scalalib/src/test/resource/better-files/benchmarks/src/test/scala/better/files/EncodingBenchmark.scala +++ /dev/null @@ -1,39 +0,0 @@ -package better.files - -import java.nio.charset.Charset - -import scala.util.Random - -class EncodingBenchmark extends Benchmark { - - def testWrite(file: File, charset: Charset) = profile { - for { - writer <- file.bufferedWriter(charset) - content <- Iterator.continually(Random.nextString(10000)).take(1000) - } writer.write(content + "\n") - } - - def testRead(file: File, charset: Charset) = profile { - for { - reader <- file.bufferedReader(charset) - line <- reader.lines().autoClosed - } line - } - - def run(charset: Charset) = { - File.temporaryFile() foreach {file => - val (_, w) = testWrite(file, charset) - info(s"Charset=$charset, write=$w ms") - - val (_, r) = testRead(file, charset) - info(s"Charset=$charset, read=$r ms") - } - } - - test("encoding") { - val utf8 = Charset.forName("UTF-8") - run(charset = utf8) - info("-------------") - run(charset = UnicodeCharset(utf8)) - } -} diff --git a/scalalib/src/test/resource/better-files/benchmarks/src/test/scala/better/files/ScannerBenchmark.scala b/scalalib/src/test/resource/better-files/benchmarks/src/test/scala/better/files/ScannerBenchmark.scala deleted file mode 100644 index 83082b9a..00000000 --- a/scalalib/src/test/resource/better-files/benchmarks/src/test/scala/better/files/ScannerBenchmark.scala +++ /dev/null @@ -1,66 +0,0 @@ -package better.files - -import java.io.{BufferedReader, StringReader} - -class ScannerBenchmark extends Benchmark { - val file = File.newTemporaryFile() - val n = 1000 - repeat(n) { - file.appendLine(-n to n mkString " ") - .appendLine("hello " * n) - .appendLine("world " * n) - } - val scanners: Seq[BufferedReader => AbstractScanner] = Seq( - new JavaScanner(_), - new StringBuilderScanner(_), - new CharBufferScanner(_), - new StreamingScanner(_), - new IterableScanner(_), - new IteratorScanner(_), - new BetterFilesScanner(_), - new ArrayBufferScanner(_), - new FastJavaIOScanner2(_), - new FastJavaIOScanner(_) - ) - - def runTest(scanner: AbstractScanner) = { - val (_, time) = profile(run(scanner)) - scanner.close() - info(f"${scanner.getClass.getSimpleName.padTo(25, ' ')}: $time%4d ms") - } - - def run(scanner: AbstractScanner): Unit = repeat(n) { - assert(scanner.hasNext) - val ints = List.fill(2 * n + 1)(scanner.nextInt()) - val line = "" //scanner.nextLine() - val words = IndexedSeq.fill(2 * n)(scanner.next()) - (line, ints, words) - } - - test("scanner") { - info("Warming up ...") - scanners foreach { scannerBuilder => - val canaryData = - """ - |10 -23 - |Hello World - |Hello World - |19 - """.stripMargin - val scanner = scannerBuilder(new BufferedReader(new StringReader(canaryData))) - info(s"Testing ${scanner.getClass.getSimpleName} for correctness") - assert(scanner.hasNext) - assert(scanner.nextInt() == 10) - assert(scanner.nextInt() == -23) - assert(scanner.next() == "Hello") - assert(scanner.next() == "World") - val l = scanner.nextLine() - assert(l == "Hello World", l) - assert(scanner.nextInt() == 19) - //assert(!scanner.hasNext) - } - - info("Running benchmark ...") - scanners foreach { scanner => runTest(scanner(file.newBufferedReader)) } - } -} diff --git a/scalalib/src/test/resource/better-files/build.sbt b/scalalib/src/test/resource/better-files/build.sbt deleted file mode 100644 index a3ae7a81..00000000 --- a/scalalib/src/test/resource/better-files/build.sbt +++ /dev/null @@ -1,163 +0,0 @@ -val username = "pathikrit" -val repo = "better-files" - -lazy val commonSettings = Seq( - organization := s"com.github.$username", - scalaVersion := "2.12.3", - crossScalaVersions := Seq("2.12.3"), - crossVersion := CrossVersion.binary, - javacOptions ++= Seq("-source", "1.8", "-target", "1.8", "-Xlint"), - scalacOptions ++= Seq( - "-deprecation", // Emit warning and location for usages of deprecated APIs. - "-encoding", "utf-8", // Specify character encoding used by source files. - "-explaintypes", // Explain type errors in more detail. - "-feature", // Emit warning and location for usages of features that should be imported explicitly. - "-language:existentials", // Existential types (besides wildcard types) can be written and inferred - "-language:experimental.macros", // Allow macro definition (besides implementation and application) - "-language:higherKinds", // Allow higher-kinded types - "-language:implicitConversions", // Allow definition of implicit functions called views - "-unchecked", // Enable additional warnings where generated code depends on assumptions. - "-Xcheckinit", // Wrap field accessors to throw an exception on uninitialized access. - "-Xfatal-warnings", // Fail the compilation if there are any warnings. - "-Xfuture", // Turn on future language features. - "-Xlint:adapted-args", // Warn if an argument list is modified to match the receiver. - "-Xlint:by-name-right-associative", // By-name parameter of right associative operator. - "-Xlint:constant", // Evaluation of a constant arithmetic expression results in an error. - "-Xlint:delayedinit-select", // Selecting member of DelayedInit. - "-Xlint:doc-detached", // A Scaladoc comment appears to be detached from its element. - "-Xlint:inaccessible", // Warn about inaccessible types in method signatures. - "-Xlint:infer-any", // Warn when a type argument is inferred to be `Any`. - "-Xlint:missing-interpolator", // A string literal appears to be missing an interpolator id. - "-Xlint:nullary-override", // Warn when non-nullary `def f()' overrides nullary `def f'. - "-Xlint:nullary-unit", // Warn when nullary methods return Unit. - "-Xlint:option-implicit", // Option.apply used implicit view. - "-Xlint:package-object-classes", // Class or object defined in package object. - "-Xlint:poly-implicit-overload", // Parameterized overloaded implicit methods are not visible as view bounds. - "-Xlint:private-shadow", // A private field (or class parameter) shadows a superclass field. - "-Xlint:stars-align", // Pattern sequence wildcard must align with sequence component. - "-Xlint:type-parameter-shadow", // A local type parameter shadows a type already in scope. - "-Xlint:unsound-match", // Pattern match may not be typesafe. - "-Yno-adapted-args", // Do not adapt an argument list (either by inserting () or creating a tuple) to match the receiver. - "-Ypartial-unification", // Enable partial unification in type constructor inference - "-Ywarn-dead-code", // Warn when dead code is identified. - "-Ywarn-extra-implicit", // Warn when more than one implicit parameter section is defined. - "-Ywarn-inaccessible", // Warn about inaccessible types in method signatures. - "-Ywarn-infer-any", // Warn when a type argument is inferred to be `Any`. - "-Ywarn-nullary-override", // Warn when non-nullary `def f()' overrides nullary `def f'. - "-Ywarn-nullary-unit", // Warn when nullary methods return Unit. - "-Ywarn-numeric-widen", // Warn when numerics are widened. - "-Ywarn-unused:implicits", // Warn if an implicit parameter is unused. - "-Ywarn-unused:imports", // Warn if an import selector is not referenced. - "-Ywarn-unused:locals", // Warn if a local definition is unused. - "-Ywarn-unused:params", // Warn if a value parameter is unused. - "-Ywarn-unused:patvars", // Warn if a variable bound in a pattern is unused. - "-Ywarn-unused:privates", // Warn if a private member is unused. - "-Ywarn-value-discard" // Warn when non-Unit expression results are unused. - ), - libraryDependencies += Dependencies.scalatest, - updateImpactOpenBrowser := false -) - -lazy val core = (project in file("core")) - .settings(commonSettings: _*) - .settings(publishSettings: _*) - .settings( - name := repo, - description := "Simple, safe and intuitive I/O in Scala" - ) - -lazy val akka = (project in file("akka")) - .settings(commonSettings: _*) - .settings(publishSettings: _*) - .settings( - name := s"$repo-akka", - description := "Reactive file watcher using Akka actors", - libraryDependencies += Dependencies.akka - ) - .dependsOn(core % "test->test;compile->compile") - -lazy val shapelessScanner = (project in file("shapeless")) - .settings(commonSettings: _*) - .settings(noPublishSettings: _*) - .settings( - name := s"shapeless-scanner", - description := "Shapeless Scanner", - libraryDependencies += Dependencies.shapeless - ) - .dependsOn(core % "test->test;compile->compile") - -lazy val benchmarks = (project in file("benchmarks")) - .settings(commonSettings: _*) - .settings(noPublishSettings: _*) - .settings( - name := s"$repo-benchmarks", - libraryDependencies ++= Seq( - Dependencies.commonsio, - Dependencies.fastjavaio - ) - ) - .dependsOn(core % "test->test;compile->compile") - -lazy val root = (project in file(".")) - .settings(commonSettings: _*) - .settings(docSettings: _*) - .settings(noPublishSettings: _*) - .settings(releaseSettings: _*) - .aggregate(core, akka, shapelessScanner, benchmarks) - -import UnidocKeys._ -lazy val docSettings = unidocSettings ++ site.settings ++ ghpages.settings ++ Seq( - autoAPIMappings := true, - unidocProjectFilter in (ScalaUnidoc, unidoc) := inProjects(core, akka), - SiteKeys.siteSourceDirectory := file("site"), - site.addMappingsToSiteDir(mappings in (ScalaUnidoc, packageDoc), "latest/api"), - git.remoteRepo := s"git@github.com:$username/$repo.git" -) - -import ReleaseTransformations._ -lazy val releaseSettings = Seq( - releaseProcess := Seq[ReleaseStep]( - checkSnapshotDependencies, - inquireVersions, - //runClean, - runTest, - setReleaseVersion, - commitReleaseVersion, - tagRelease, - publishArtifacts, - setNextVersion, - commitNextVersion, - releaseStepCommand("sonatypeReleaseAll"), - pushChanges - ) -) - -lazy val noPublishSettings = Seq( - publish := (), - publishLocal := (), - publishArtifact := false -) - -lazy val publishSettings = Seq( - homepage := Some(url(s"https://github.com/$username/$repo")), - licenses += "MIT" -> url(s"https://github.com/$username/$repo/blob/master/LICENSE"), - scmInfo := Some(ScmInfo(url(s"https://github.com/$username/$repo"), s"git@github.com:$username/$repo.git")), - apiURL := Some(url(s"https://$username.github.io/$repo/latest/api/")), - releaseCrossBuild := true, - releasePublishArtifactsAction := PgpKeys.publishSigned.value, - publishMavenStyle := true, - publishArtifact in Test := false, - publishTo := Some(if (isSnapshot.value) Opts.resolver.sonatypeSnapshots else Opts.resolver.sonatypeStaging), - credentials ++= (for { - username <- sys.env.get("SONATYPE_USERNAME") - password <- sys.env.get("SONATYPE_PASSWORD") - } yield Credentials("Sonatype Nexus Repository Manager", "oss.sonatype.org", username, password)).toSeq, - pomExtra := - <developers> - <developer> - <id>{username}</id> - <name>Pathikrit Bhowmick</name> - <url>http://github.com/{username}</url> - </developer> - </developers> -) diff --git a/scalalib/src/test/resource/better-files/circle.yml b/scalalib/src/test/resource/better-files/circle.yml deleted file mode 100644 index 0ca8d9b9..00000000 --- a/scalalib/src/test/resource/better-files/circle.yml +++ /dev/null @@ -1,21 +0,0 @@ -machine: - environment: - SBT_GHPAGES_COMMIT_MESSAGE: 'Publishing Scaladoc [ci skip]' - java: - version: oraclejdk8 - -test: - override: - - sbt clean coverage +test - -deployment: - master: - branch: master - owner: pathikrit - commands: - - sbt updateImpactSubmit coverageReport coverageAggregate codacyCoverage - - bash <(curl -s https://codecov.io/bash) - - git config --global user.email "pathikritbhowmick@msn.com" - - git config --global user.name "circle-ci" - - git config --global push.default simple - - sbt ghpagesPushSite +publish diff --git a/scalalib/src/test/resource/better-files/core/src/main/scala/better/files/Dsl.scala b/scalalib/src/test/resource/better-files/core/src/main/scala/better/files/Dsl.scala deleted file mode 100644 index 3bacd91d..00000000 --- a/scalalib/src/test/resource/better-files/core/src/main/scala/better/files/Dsl.scala +++ /dev/null @@ -1,155 +0,0 @@ -package better.files - -import java.nio.charset.Charset -import java.nio.file.attribute.{PosixFileAttributes, PosixFilePermission, PosixFilePermissions} -import java.util.zip.Deflater - -import scala.collection.JavaConverters._ - -/** - * Do file ops using a UNIX command line DSL - */ -object Dsl { - def ~ : File = - File.home - - def pwd: File = - File.currentWorkingDirectory - - def cwd: File = - pwd - - val `..`: File => File = - _.parent - - val `.`: File => File = - identity - - /** - * Adds some symbolic operations to file - * @param file - */ - implicit class SymbolicOperations(val file: File) { - /** - * Allows navigation up e.g. file / .. / .. - * - * @param f - * @return - */ - def /(f: File => File): File = - f(file) - - def <<(line: String)(implicit charset: Charset = defaultCharset): file.type = - file.appendLines(line)(charset) - - def >>:(line: String)(implicit charset: Charset = defaultCharset): file.type = - file.appendLines(line)(charset) - - def <(text: String)(implicit openOptions: File.OpenOptions = File.OpenOptions.default, charset: Charset = defaultCharset): file.type = - file.write(text)(openOptions, charset) - - def `>:`(text: String)(implicit openOptions: File.OpenOptions = File.OpenOptions.default, charset: Charset = defaultCharset): file.type = - file.write(text)(openOptions, charset) - - def `!`(implicit charset: Charset = defaultCharset): String = - file.contentAsString(charset) - - def `===`(that: File): Boolean = - file.isSameContentAs(that) - - def !==(that: File): Boolean = - !(file === that) - } - - def cp(from: File, to: File): File = { - if (to.isDirectory) { - from.copyToDirectory(to) - } else { - from.copyTo(to, overwrite = true) - } - } - - def mv(from: File, to: File): File = { - if (to.isDirectory) { - from.moveToDirectory(to) - } else { - from.moveTo(to, overwrite = true) - } - } - - def rm(file: File): File = - file.delete(swallowIOExceptions = true) - - def del(file: File): File = - rm(file) - - def ln(file1: File, file2: File): File = - file1.linkTo(file2) - - def ln_s(file1: File, file2: File): File = - file1.symbolicLinkTo(file2) - - def cat(files: File*): Seq[Iterator[Byte]] = - files.map(_.bytes) - - def ls(file: File): Files = - file.list - - def dir(file: File): Files = - ls(file) - - def ls_r(file: File): Files = - file.listRecursively - - def touch(file: File): File = - file.touch() - - def mkdir(file: File): File = - file.createDirectory() - - def md5(file: File): String = - file.md5 - - def sha1(file: File): String = - file.sha1 - - def sha256(file: File): String = - file.sha256 - - def sha512(file: File): String = - file.sha512 - - def mkdirs(file: File): File = - file.createDirectories() - - def chown(owner: String, file: File): File = - file.setOwner(owner) - - def chgrp(group: String, file: File): File = - file.setGroup(group) - - /** - * Update permission of this file - * - * @param permissions Must be 9 character POSIX permission representation e.g. "rwxr-x---" - * @param file - * @return file - */ - def chmod(permissions: String, file: File): File = - file.setPermissions(PosixFilePermissions.fromString(permissions).asScala.toSet) - - def chmod_+(permission: PosixFilePermission, file: File): File = - file.addPermission(permission) - - def chmod_-(permission: PosixFilePermission, file: File): File = - file.removePermission(permission) - - def stat(file: File): PosixFileAttributes = - file.posixAttributes - - def unzip(zipFile: File)(destination: File)(implicit charset: Charset = defaultCharset): destination.type = - zipFile.unzipTo(destination)(charset) - - def zip(files: File*)(destination: File, compressionLevel: Int = Deflater.DEFAULT_COMPRESSION)(implicit charset: Charset = defaultCharset): destination.type = - destination.zipIn(files.iterator, compressionLevel)(charset) -} diff --git a/scalalib/src/test/resource/better-files/core/src/main/scala/better/files/File.scala b/scalalib/src/test/resource/better-files/core/src/main/scala/better/files/File.scala deleted file mode 100644 index eb11cd93..00000000 --- a/scalalib/src/test/resource/better-files/core/src/main/scala/better/files/File.scala +++ /dev/null @@ -1,1257 +0,0 @@ -package better.files - -import java.io.{File => JFile, _} -import java.net.{URI, URL} -import java.nio.charset.Charset -import java.nio.channels._ -import java.nio.file._ -import java.nio.file.attribute._ -import java.security.{DigestInputStream, MessageDigest} -import java.time.Instant -import java.util.regex.Pattern -import java.util.zip._ -import javax.xml.bind.DatatypeConverter - -import scala.collection.JavaConverters._ -import scala.concurrent.ExecutionContext -import scala.util.Properties -import scala.util.matching.Regex - -/** - * Scala wrapper around java.nio.files.Path - */ -class File private(val path: Path)(implicit val fileSystem: FileSystem = path.getFileSystem) { - //TODO: LinkOption? - - def pathAsString: String = - path.toString - - def toJava: JFile = - new JFile(path.toAbsolutePath.toString) - - /** - * Name of file - * Certain files may not have a name e.g. root directory - returns empty string in that case - * - * @return - */ - def name: String = - nameOption.getOrElse("") - - /** - * Certain files may not have a name e.g. root directory - returns None in that case - * - * @return - */ - def nameOption: Option[String] = - Option(path.getFileName).map(_.toString) - - def root: File = - path.getRoot - - def nameWithoutExtension: String = - nameWithoutExtension(includeAll = true) - - /** - * @param includeAll - * For files with multiple extensions e.g. "bundle.tar.gz" - * nameWithoutExtension(includeAll = true) returns "bundle" - * nameWithoutExtension(includeAll = false) returns "bundle.tar" - * @return - */ - def nameWithoutExtension(includeAll: Boolean): String = - if (hasExtension) name.substring(0, indexOfExtension(includeAll)) else name - - /** - * @return extension (including the dot) of this file if it is a regular file and has an extension, else None - */ - def extension: Option[String] = - extension() - - /** - * @param includeDot whether the dot should be included in the extension or not - * @param includeAll whether all extension tokens should be included, or just the last one e.g. for bundle.tar.gz should it be .tar.gz or .gz - * @param toLowerCase to lowercase the extension or not e.g. foo.HTML should have .html or .HTML - * @return extension of this file if it is a regular file and has an extension, else None - */ - def extension(includeDot: Boolean = true, includeAll: Boolean = false, toLowerCase: Boolean = true): Option[String] = - when(hasExtension) { - val dot = indexOfExtension(includeAll) - val index = if (includeDot) dot else dot + 1 - val extension = name.substring(index) - if (toLowerCase) extension.toLowerCase else extension - } - - private[this] def indexOfExtension(includeAll: Boolean) = - if (includeAll) name.indexOf(".") else name.lastIndexOf(".") - - /** - * Returns the extension if file is a regular file - * If file is unreadable or does not exist, it is assumed to be not a regular file - * See: https://github.com/pathikrit/better-files/issues/89 - * - * @return - */ - def hasExtension: Boolean = - (isRegularFile || notExists) && name.contains(".") - - /** - * Changes the file-extension by renaming this file; if file does not have an extension, it adds the extension - * Example usage file"foo.java".changeExtensionTo(".scala") - */ - def changeExtensionTo(extension: String): File = - if (isRegularFile) renameTo(s"$nameWithoutExtension$extension") else this - - def contentType: Option[String] = - Option(Files.probeContentType(path)) - - /** - * Return parent of this file - * NOTE: This API returns null if this file is the root; - * please use parentOption if you expect to handle roots - * - * @see parentOption - * @return - */ - def parent: File = - parentOption.orNull - - /** - * - * @return Some(parent) of this file or None if this is the root and thus has no parent - */ - def parentOption: Option[File] = - Option(path.getParent).map(File.apply) - - def /(child: String): File = - path.resolve(child) - - def /(child: Symbol): File = - this / child.name - - def createChild(child: String, asDirectory: Boolean = false, createParents: Boolean = false)(implicit attributes: File.Attributes = File.Attributes.default, linkOptions: File.LinkOptions = File.LinkOptions.default): File = - (this / child).createIfNotExists(asDirectory, createParents)(attributes, linkOptions) - - /** - * Create this file. If it exists, don't do anything - * - * @param asDirectory If you want this file to be created as a directory instead, set this to true (false by default) - * @param createParents If you also want all the parents to be created from root to this file (false by defailt) - * @param attributes - * @param linkOptions - * @return - */ - def createIfNotExists(asDirectory: Boolean = false, createParents: Boolean = false)(implicit attributes: File.Attributes = File.Attributes.default, linkOptions: File.LinkOptions = File.LinkOptions.default): this.type = { - if (exists(linkOptions)) { - this - } else if (asDirectory) { - createDirectories()(attributes) - } else { - if (createParents) parent.createDirectories()(attributes) - try { - createFile()(attributes) - } catch { - case _: FileAlreadyExistsException if isRegularFile(linkOptions) => // We don't really care if it exists already - } - this - } - } - - /** - * Create this file - * - * @param attributes - * @return - */ - def createFile()(implicit attributes: File.Attributes = File.Attributes.default): this.type = { - Files.createFile(path, attributes: _*) - this - } - - def exists(implicit linkOptions: File.LinkOptions = File.LinkOptions.default): Boolean = - Files.exists(path, linkOptions: _*) - - def notExists(implicit linkOptions: File.LinkOptions = File.LinkOptions.default): Boolean = - Files.notExists(path, linkOptions: _*) - - def sibling(name: String): File = - path.resolveSibling(name) - - def isSiblingOf(sibling: File): Boolean = - sibling.isChildOf(parent) - - def siblings: Files = - parent.list.filterNot(_ == this) - - def isChildOf(parent: File): Boolean = - parent.isParentOf(this) - - /** - * Check if this directory contains this file - * - * @param file - * @return true if this is a directory and it contains this file - */ - def contains(file: File): Boolean = - isDirectory && (file.path startsWith path) - - def isParentOf(child: File): Boolean = - contains(child) - - def bytes: Iterator[Byte] = - newInputStream.buffered.bytes //TODO: ManagedResource here? - - def loadBytes: Array[Byte] = - Files.readAllBytes(path) - - def byteArray: Array[Byte] = - loadBytes - - /** - * Create this directory - * - * @param attributes - * @return - */ - def createDirectory()(implicit attributes: File.Attributes = File.Attributes.default): this.type = { - Files.createDirectory(path, attributes: _*) - this - } - - /** - * Create this directory and all its parents - * Unlike the JDK, this by default sanely handles the JDK-8130464 bug - * If you want default Java behaviour, use File.LinkOptions.noFollow - * - * @param attributes - * @return - */ - def createDirectories()(implicit attributes: File.Attributes = File.Attributes.default, linkOptions: File.LinkOptions = File.LinkOptions.default): this.type = { - try { - Files.createDirectories(path, attributes: _*) - } catch { - case _: FileAlreadyExistsException if isDirectory(linkOptions) => // work around for JDK-8130464 - } - this - } - - def chars(implicit charset: Charset = defaultCharset): Iterator[Char] = - newBufferedReader(charset).chars //TODO: ManagedResource here? - - /** - * Load all lines from this file - * Note: Large files may cause an OutOfMemory in which case, use the streaming version @see lineIterator - * - * @param charset - * @return all lines in this file - */ - def lines(implicit charset: Charset = defaultCharset): Traversable[String] = - Files.readAllLines(path, charset).asScala - - /** - * Iterate over lines in a file (auto-close stream on complete) - * NOTE: If the iteration is partial, it may leave a stream open - * If you want partial iteration use @see lines() - * - * @param charset - * @return - */ - def lineIterator(implicit charset: Charset = defaultCharset): Iterator[String] = - Files.lines(path, charset).toAutoClosedIterator - - def tokens(splitter: StringSplitter = StringSplitter.default)(implicit charset: Charset = defaultCharset): Iterator[String] = - newBufferedReader(charset).tokens(splitter) - - def contentAsString(implicit charset: Charset = defaultCharset): String = - new String(byteArray, charset) - - def printLines(lines: Iterator[Any])(implicit openOptions: File.OpenOptions = File.OpenOptions.append): this.type = { - for { - pw <- printWriter()(openOptions) - line <- lines - } pw.println(line) - this - } - - /** - * For large number of lines that may not fit in memory, use printLines - * - * @param lines - * @param charset - * @return - */ - def appendLines(lines: String*)(implicit charset: Charset = defaultCharset): this.type = { - Files.write(path, lines.asJava, charset, File.OpenOptions.append: _*) - this - } - - def appendLine(line: String = "")(implicit charset: Charset = defaultCharset): this.type = - appendLines(line)(charset) - - def append(text: String)(implicit charset: Charset = defaultCharset): this.type = - appendByteArray(text.getBytes(charset)) - - def appendText(text: String)(implicit charset: Charset = defaultCharset): this.type = - append(text)(charset) - - def appendByteArray(bytes: Array[Byte]): this.type = { - Files.write(path, bytes, File.OpenOptions.append: _*) - this - } - - def appendBytes(bytes: Iterator[Byte]): this.type = - writeBytes(bytes)(openOptions = File.OpenOptions.append) - - /** - * Write byte array to file. For large contents consider using the writeBytes - * - * @param bytes - * @return this - */ - def writeByteArray(bytes: Array[Byte])(implicit openOptions: File.OpenOptions = File.OpenOptions.default): this.type = { - Files.write(path, bytes, openOptions: _*) - this - } - - def writeBytes(bytes: Iterator[Byte])(implicit openOptions: File.OpenOptions = File.OpenOptions.default): this.type = { - outputStream(openOptions).foreach(_.buffered write bytes) - this - } - - def write(text: String)(implicit openOptions: File.OpenOptions = File.OpenOptions.default, charset: Charset = defaultCharset): this.type = - writeByteArray(text.getBytes(charset))(openOptions) - - def writeText(text: String)(implicit openOptions: File.OpenOptions = File.OpenOptions.default, charset: Charset = defaultCharset): this.type = - write(text)(openOptions, charset) - - def overwrite(text: String)(implicit openOptions: File.OpenOptions = File.OpenOptions.default, charset: Charset = defaultCharset): this.type = - write(text)(openOptions, charset) - - def newRandomAccess(mode: File.RandomAccessMode = File.RandomAccessMode.read): RandomAccessFile = - new RandomAccessFile(toJava, mode.value) - - def randomAccess(mode: File.RandomAccessMode = File.RandomAccessMode.read): ManagedResource[RandomAccessFile] = - newRandomAccess(mode).autoClosed //TODO: Mode enum? - - def newBufferedReader(implicit charset: Charset = defaultCharset): BufferedReader = - Files.newBufferedReader(path, charset) - - def bufferedReader(implicit charset: Charset = defaultCharset): ManagedResource[BufferedReader] = - newBufferedReader(charset).autoClosed - - def newBufferedWriter(implicit charset: Charset = defaultCharset, openOptions: File.OpenOptions = File.OpenOptions.default): BufferedWriter = - Files.newBufferedWriter(path, charset, openOptions: _*) - - def bufferedWriter(implicit charset: Charset = defaultCharset, openOptions: File.OpenOptions = File.OpenOptions.default): ManagedResource[BufferedWriter] = - newBufferedWriter(charset, openOptions).autoClosed - - def newFileReader: FileReader = - new FileReader(toJava) - - def fileReader: ManagedResource[FileReader] = - newFileReader.autoClosed - - def newFileWriter(append: Boolean = false): FileWriter = - new FileWriter(toJava, append) - - def fileWriter(append: Boolean = false): ManagedResource[FileWriter] = - newFileWriter(append).autoClosed - - def newPrintWriter(autoFlush: Boolean = false)(implicit openOptions: File.OpenOptions = File.OpenOptions.default): PrintWriter = - new PrintWriter(newOutputStream(openOptions), autoFlush) - - def printWriter(autoFlush: Boolean = false)(implicit openOptions: File.OpenOptions = File.OpenOptions.default): ManagedResource[PrintWriter] = - newPrintWriter(autoFlush)(openOptions).autoClosed - - def newInputStream(implicit openOptions: File.OpenOptions = File.OpenOptions.default): InputStream = - Files.newInputStream(path, openOptions: _*) - - def inputStream(implicit openOptions: File.OpenOptions = File.OpenOptions.default): ManagedResource[InputStream] = - newInputStream(openOptions).autoClosed - - //TODO: Move this to inputstream implicit - def newDigestInputStream(digest: MessageDigest)(implicit openOptions: File.OpenOptions = File.OpenOptions.default): DigestInputStream = - new DigestInputStream(newInputStream(openOptions), digest) - - def digestInputStream(digest: MessageDigest)(implicit openOptions: File.OpenOptions = File.OpenOptions.default): ManagedResource[DigestInputStream] = - newDigestInputStream(digest)(openOptions).autoClosed - - def newScanner(splitter: StringSplitter = StringSplitter.default)(implicit charset: Charset = defaultCharset): Scanner = - Scanner(newBufferedReader(charset), splitter) - - def scanner(splitter: StringSplitter = StringSplitter.default)(implicit charset: Charset = defaultCharset): ManagedResource[Scanner] = - newScanner(splitter)(charset).autoClosed - - def newOutputStream(implicit openOptions: File.OpenOptions = File.OpenOptions.default): OutputStream = - Files.newOutputStream(path, openOptions: _*) - - def outputStream(implicit openOptions: File.OpenOptions = File.OpenOptions.default): ManagedResource[OutputStream] = - newOutputStream(openOptions).autoClosed - - def newZipOutputStream(implicit openOptions: File.OpenOptions = File.OpenOptions.default, charset: Charset = defaultCharset): ZipOutputStream = - new ZipOutputStream(newOutputStream(openOptions), charset) - - def zipInputStream(implicit charset: Charset = defaultCharset): ManagedResource[ZipInputStream] = - newZipInputStream(charset).autoClosed - - def newZipInputStream(implicit charset: Charset = defaultCharset): ZipInputStream = - new ZipInputStream(new FileInputStream(toJava).buffered, charset) - - def zipOutputStream(implicit openOptions: File.OpenOptions = File.OpenOptions.default, charset: Charset = defaultCharset): ManagedResource[ZipOutputStream] = - newZipOutputStream(openOptions, charset).autoClosed - - def newFileChannel(implicit openOptions: File.OpenOptions = File.OpenOptions.default, attributes: File.Attributes = File.Attributes.default): FileChannel = - FileChannel.open(path, openOptions.toSet.asJava, attributes: _*) - - def fileChannel(implicit openOptions: File.OpenOptions = File.OpenOptions.default, attributes: File.Attributes = File.Attributes.default): ManagedResource[FileChannel] = - newFileChannel(openOptions, attributes).autoClosed - - def newAsynchronousFileChannel(implicit openOptions: File.OpenOptions = File.OpenOptions.default): AsynchronousFileChannel = - AsynchronousFileChannel.open(path, openOptions: _*) - - def asynchronousFileChannel(implicit openOptions: File.OpenOptions = File.OpenOptions.default): ManagedResource[AsynchronousFileChannel] = - newAsynchronousFileChannel(openOptions).autoClosed - - def newWatchService: WatchService = - fileSystem.newWatchService() - - def watchService: ManagedResource[WatchService] = - newWatchService.autoClosed - - /** - * Serialize a object using Java's serializer into this file - * - * @param obj - * @return - */ - def writeSerialized(obj: Serializable)(implicit openOptions: File.OpenOptions = File.OpenOptions.default): this.type = { - createIfNotExists().outputStream(openOptions).foreach(_.asObjectOutputStream().serialize(obj).flush()) - this - } - - /** - * Deserialize a object using Java's default serialization from this file - * - * @return - */ - def readDeserialized[A](implicit openOptions: File.OpenOptions = File.OpenOptions.default): A = - inputStream(openOptions).map(_.asObjectInputStream().deserialize[A]) - - def register(service: WatchService, events: File.Events = File.Events.all): this.type = { - path.register(service, events.toArray) - this - } - - def digest(algorithm: MessageDigest): Array[Byte] = { - listRelativePaths.toSeq.sorted foreach { relativePath => - val file: File = path.resolve(relativePath) - if(file.isDirectory) { - algorithm.update(relativePath.toString.getBytes) - } else { - file.digestInputStream(algorithm).foreach(_.pipeTo(NullOutputStream)) - } - } - algorithm.digest() - } - - /** - * Set a file attribute e.g. file("dos:system") = true - * - * @param attribute - * @param value - * @param linkOptions - * @return - */ - def update(attribute: String, value: Any)(implicit linkOptions: File.LinkOptions = File.LinkOptions.default): this.type = { - Files.setAttribute(path, attribute, value, linkOptions : _*) - this - } - - /** - * @return checksum of this file (or directory) in hex format - */ - def checksum(algorithm: MessageDigest): String = - DatatypeConverter.printHexBinary(digest(algorithm)) - - def md5: String = - checksum("MD5") - - def sha1: String = - checksum("SHA-1") - - def sha256: String = - checksum("SHA-256") - - def sha512: String = - checksum("SHA-512") - - /** - * @return Some(target) if this is a symbolic link (to target) else None - */ - def symbolicLink: Option[File] = - when(isSymbolicLink)(new File(Files.readSymbolicLink(path))) - - /** - * @return true if this file (or the file found by following symlink) is a directory - */ - def isDirectory(implicit linkOptions: File.LinkOptions = File.LinkOptions.default): Boolean = - Files.isDirectory(path, linkOptions: _*) - - /** - * @return true if this file (or the file found by following symlink) is a regular file - */ - def isRegularFile(implicit linkOptions: File.LinkOptions = File.LinkOptions.default): Boolean = - Files.isRegularFile(path, linkOptions: _*) - - def isSymbolicLink: Boolean = - Files.isSymbolicLink(path) - - def isHidden: Boolean = - Files.isHidden(path) - - /** - * Check if a file is locked. - * - * @param mode The random access mode. - * @param position The position at which the locked region is to start; must be non-negative. - * @param size The size of the locked region; must be non-negative, and the sum position + size must be non-negative. - * @param isShared true to request a shared lock, false to request an exclusive lock. - * @return True if the file is locked, false otherwise. - */ - def isLocked(mode: File.RandomAccessMode, position: Long = 0L, size: Long = Long.MaxValue, isShared: Boolean = false)(implicit linkOptions: File.LinkOptions = File.LinkOptions.default): Boolean = - try { - usingLock(mode) {channel => - channel.tryLock(position, size, isShared).release() - false - } - } catch { - case _: OverlappingFileLockException | _: NonWritableChannelException | _: NonReadableChannelException => true - - // Windows throws a `FileNotFoundException` if the file is locked (see: https://github.com/pathikrit/better-files/pull/194) - case _: FileNotFoundException if verifiedExists(linkOptions).getOrElse(true) => true - } - - /** - * @see https://docs.oracle.com/javase/tutorial/essential/io/check.html - * @see https://stackoverflow.com/questions/30520179/why-does-file-exists-return-true-even-though-files-exists-in-the-nio-files - * - * @return - * Some(true) if file is guaranteed to exist - * Some(false) if file is guaranteed to not exist - * None if the status is unknown e.g. if file is unreadable - */ - def verifiedExists(implicit linkOptions: File.LinkOptions = File.LinkOptions.default): Option[Boolean] = { - if (exists(linkOptions)) { - Some(true) - } else if(notExists(linkOptions)) { - Some(false) - } else { - None - } - } - - def usingLock[U](mode: File.RandomAccessMode)(f: FileChannel => U): U = - newRandomAccess(mode).getChannel.autoClosed.map(f) - - def isReadLocked(position: Long = 0L, size: Long = Long.MaxValue, isShared: Boolean = false) = - isLocked(File.RandomAccessMode.read, position, size, isShared) - - def isWriteLocked(position: Long = 0L, size: Long = Long.MaxValue, isShared: Boolean = false) = - isLocked(File.RandomAccessMode.readWrite, position, size, isShared) - - def list: Files = - Files.list(path) - - def children: Files = list - - def entries: Files = list - - def listRecursively(implicit visitOptions: File.VisitOptions = File.VisitOptions.default): Files = - walk()(visitOptions).filterNot(isSamePathAs) - - /** - * Walk the directory tree recursively upto maxDepth - * - * @param maxDepth - * @return List of children in BFS maxDepth level deep (includes self since self is at depth = 0) - */ - def walk(maxDepth: Int = Int.MaxValue)(implicit visitOptions: File.VisitOptions = File.VisitOptions.default): Files = - Files.walk(path, maxDepth, visitOptions: _*) //TODO: that ignores I/O errors? - - def pathMatcher(syntax: File.PathMatcherSyntax, includePath: Boolean)(pattern: String): PathMatcher = - syntax(this, pattern, includePath) - - /** - * Util to glob from this file's path - * - * - * @param includePath If true, we don't need to set path glob patterns - * e.g. instead of **//*.txt we just use *.txt - * @return Set of files that matched - */ - //TODO: Consider removing `syntax` as implicit. You often want to control this on a per method call basis - def glob(pattern: String, includePath: Boolean = true)(implicit syntax: File.PathMatcherSyntax = File.PathMatcherSyntax.default, visitOptions: File.VisitOptions = File.VisitOptions.default): Files = - pathMatcher(syntax, includePath)(pattern).matches(this)(visitOptions) - - /** - * Util to match from this file's path using Regex - * - * @param includePath If true, we don't need to set path glob patterns - * e.g. instead of **//*.txt we just use *.txt - * @see glob - * @return Set of files that matched - */ - def globRegex(pattern: Regex, includePath: Boolean = true)(implicit visitOptions: File.VisitOptions = File.VisitOptions.default): Files = - glob(pattern.regex, includePath)(syntax = File.PathMatcherSyntax.regex, visitOptions = visitOptions) - - /** - * More Scala friendly way of doing Files.walk - * Note: This is lazy (returns an Iterator) and won't evaluate till we reify the iterator (e.g. using .toList) - * - * @param matchFilter - * @return - */ - def collectChildren(matchFilter: File => Boolean)(implicit visitOptions: File.VisitOptions = File.VisitOptions.default): Files = - walk()(visitOptions).filter(matchFilter) - - def uri: URI = - path.toUri - - def url: URL = - uri.toURL - - /** - * @return file size (for directories, return size of the directory) in bytes - */ - def size(implicit visitOptions: File.VisitOptions = File.VisitOptions.default): Long = - walk()(visitOptions).map(f => Files.size(f.path)).sum - - def permissions(implicit linkOptions: File.LinkOptions = File.LinkOptions.default): Set[PosixFilePermission] = - Files.getPosixFilePermissions(path, linkOptions: _*).asScala.toSet - - def permissionsAsString(implicit linkOptions: File.LinkOptions = File.LinkOptions.default): String = - PosixFilePermissions.toString(permissions(linkOptions).asJava) - - def setPermissions(permissions: Set[PosixFilePermission]): this.type = { - Files.setPosixFilePermissions(path, permissions.asJava) - this - } - - def addPermission(permission: PosixFilePermission)(implicit linkOptions: File.LinkOptions = File.LinkOptions.default): this.type = - setPermissions(permissions(linkOptions) + permission) - - def removePermission(permission: PosixFilePermission)(implicit linkOptions: File.LinkOptions = File.LinkOptions.default): this.type = - setPermissions(permissions(linkOptions) - permission) - - /** - * test if file has this permission - */ - def testPermission(permission: PosixFilePermission)(implicit linkOptions: File.LinkOptions = File.LinkOptions.default): Boolean = - permissions(linkOptions)(permission) - - def isOwnerReadable(implicit linkOptions: File.LinkOptions = File.LinkOptions.default): Boolean = - testPermission(PosixFilePermission.OWNER_READ)(linkOptions) - - def isOwnerWritable(implicit linkOptions: File.LinkOptions = File.LinkOptions.default): Boolean = - testPermission(PosixFilePermission.OWNER_WRITE)(linkOptions) - - def isOwnerExecutable(implicit linkOptions: File.LinkOptions = File.LinkOptions.default): Boolean = - testPermission(PosixFilePermission.OWNER_EXECUTE)(linkOptions) - - def isGroupReadable(implicit linkOptions: File.LinkOptions = File.LinkOptions.default): Boolean = - testPermission(PosixFilePermission.GROUP_READ)(linkOptions) - - def isGroupWritable(implicit linkOptions: File.LinkOptions = File.LinkOptions.default): Boolean = - testPermission(PosixFilePermission.GROUP_WRITE)(linkOptions) - - def isGroupExecutable(implicit linkOptions: File.LinkOptions = File.LinkOptions.default): Boolean = - testPermission(PosixFilePermission.GROUP_EXECUTE)(linkOptions) - - def isOthersReadable(implicit linkOptions: File.LinkOptions = File.LinkOptions.default): Boolean = - testPermission(PosixFilePermission.OTHERS_READ)(linkOptions) - - def isOthersWritable(implicit linkOptions: File.LinkOptions = File.LinkOptions.default): Boolean = - testPermission(PosixFilePermission.OTHERS_WRITE)(linkOptions) - - def isOthersExecutable(implicit linkOptions: File.LinkOptions = File.LinkOptions.default): Boolean = - testPermission(PosixFilePermission.OTHERS_EXECUTE)(linkOptions) - - /** - * This differs from the above as this checks if the JVM can read this file even though the OS cannot in certain platforms - * - * @see isOwnerReadable - * @return - */ - def isReadable: Boolean = - toJava.canRead - - def isWriteable: Boolean = - toJava.canWrite - - def isExecutable: Boolean = - toJava.canExecute - - def attributes(implicit linkOptions: File.LinkOptions = File.LinkOptions.default): BasicFileAttributes = - Files.readAttributes(path, classOf[BasicFileAttributes], linkOptions: _*) - - def posixAttributes(implicit linkOptions: File.LinkOptions = File.LinkOptions.default): PosixFileAttributes = - Files.readAttributes(path, classOf[PosixFileAttributes], linkOptions: _*) - - def dosAttributes(implicit linkOptions: File.LinkOptions = File.LinkOptions.default): DosFileAttributes = - Files.readAttributes(path, classOf[DosFileAttributes], linkOptions: _*) - - def owner(implicit linkOptions: File.LinkOptions = File.LinkOptions.default): UserPrincipal = - Files.getOwner(path, linkOptions: _*) - - def ownerName(implicit linkOptions: File.LinkOptions = File.LinkOptions.default): String = - owner(linkOptions).getName - - def group(implicit linkOptions: File.LinkOptions = File.LinkOptions.default): GroupPrincipal = - posixAttributes(linkOptions).group() - - def groupName(implicit linkOptions: File.LinkOptions = File.LinkOptions.default): String = - group(linkOptions).getName - - def setOwner(owner: String): this.type = { - Files.setOwner(path, fileSystem.getUserPrincipalLookupService.lookupPrincipalByName(owner)) - this - } - - def setGroup(group: String): this.type = { - Files.setOwner(path, fileSystem.getUserPrincipalLookupService.lookupPrincipalByGroupName(group)) - this - } - - /** - * Similar to the UNIX command touch - create this file if it does not exist and set its last modification time - */ - def touch(time: Instant = Instant.now())(implicit attributes: File.Attributes = File.Attributes.default, linkOptions: File.LinkOptions = File.LinkOptions.default): this.type = { - Files.setLastModifiedTime(createIfNotExists()(attributes, linkOptions).path, FileTime.from(time)) - this - } - - def lastModifiedTime(implicit linkOptions: File.LinkOptions = File.LinkOptions.default): Instant = - Files.getLastModifiedTime(path, linkOptions: _*).toInstant - - /** - * Deletes this file or directory - * - * @param swallowIOExceptions If this is set to true, any exception thrown is swallowed - */ - def delete(swallowIOExceptions: Boolean = false): this.type = { - try { - if (isDirectory) list.foreach(_.delete(swallowIOExceptions)) - Files.delete(path) - } catch { - case _: IOException if swallowIOExceptions => //e.printStackTrace() //swallow - } - this - } - - def renameTo(newName: String): File = - moveTo(path.resolveSibling(newName)) - - /** - * - * @param destination - * @param overwrite - * @return destination - */ - def moveTo(destination: File, overwrite: Boolean = false): destination.type = { - Files.move(path, destination.path, File.CopyOptions(overwrite): _*) - destination - } - - /** - * Moves this file into the given directory - * @param directory - * - * @return the File referencing the new file created under destination - */ - def moveToDirectory(directory: File)(implicit linkOptions: File.LinkOptions = File.LinkOptions.default): File = { - require(directory.isDirectory(linkOptions), s"$directory must be a directory") - moveTo(directory / this.name) - } - - /** - * - * @param destination - * @param overwrite - * @return destination - */ - def copyTo(destination: File, overwrite: Boolean = false)(implicit copyOptions: File.CopyOptions = File.CopyOptions(overwrite)): destination.type = { - if (isDirectory) {//TODO: maxDepth? - Files.walkFileTree(path, new SimpleFileVisitor[Path] { - def newPath(subPath: Path): Path = destination.path.resolve(path.relativize(subPath)) - - override def preVisitDirectory(dir: Path, attrs: BasicFileAttributes) = { - Files.createDirectories(newPath(dir)) - super.preVisitDirectory(dir, attrs) - } - - override def visitFile(file: Path, attrs: BasicFileAttributes) = { - Files.copy(file, newPath(file), copyOptions: _*) - super.visitFile(file, attrs) - } - }) - } else { - Files.copy(path, destination.path, copyOptions: _*) - } - destination - } - - /** - * Copies this file into the given directory - * @param directory - * - * @return the File referencing the new file created under destination - */ - def copyToDirectory(directory: File)(implicit linkOptions: File.LinkOptions = File.LinkOptions.default, copyOptions: File.CopyOptions = File.CopyOptions.default): File = { - require(directory.isDirectory(linkOptions), s"$directory must be a directory") - copyTo(directory / this.name)(copyOptions) - } - - def symbolicLinkTo(destination: File)(implicit attributes: File.Attributes = File.Attributes.default): destination.type = { - Files.createSymbolicLink(path, destination.path, attributes: _*) - destination - } - - def linkTo(destination: File, symbolic: Boolean = false)(implicit attributes: File.Attributes = File.Attributes.default): destination.type = { - if (symbolic) { - symbolicLinkTo(destination)(attributes) - } else { - Files.createLink(destination.path, path) - destination - } - } - - def listRelativePaths(implicit visitOptions: File.VisitOptions = File.VisitOptions.default): Iterator[Path] = - walk()(visitOptions).map(relativize) - - def relativize(destination: File): Path = - path.relativize(destination.path) - - def isSamePathAs(that: File): Boolean = - this.path == that.path - - def isSameFileAs(that: File): Boolean = - Files.isSameFile(this.path, that.path) - - /** - * @return true if this file is exactly same as that file - * For directories, it checks for equivalent directory structure - */ - def isSameContentAs(that: File): Boolean = - isSimilarContentAs(that) - - /** - * Almost same as isSameContentAs but uses faster md5 hashing to compare (and thus small chance of false positive) - * Also works for directories - * - * @param that - * @return - */ - def isSimilarContentAs(that: File): Boolean = - this.md5 == that.md5 - - override def equals(obj: Any) = { - obj match { - case file: File => isSamePathAs(file) - case _ => false - } - } - - /** - * @param linkOptions - * @return true if file is not present or empty directory or 0-bytes file - */ - def isEmpty(implicit linkOptions: File.LinkOptions = File.LinkOptions.default): Boolean = { - if (isDirectory(linkOptions)) { - children.isEmpty - } else if (isRegularFile(linkOptions)) { - toJava.length() == 0 - } else { - notExists(linkOptions) - } - } - - /** - * - * @param linkOptions - * @return for directories, true if it has no children, false otherwise - * for files, true if it is a 0-byte file, false otherwise - * else true if it exists, false otherwise - */ - def nonEmpty(implicit linkOptions: File.LinkOptions = File.LinkOptions.default): Boolean = - !isEmpty(linkOptions) - - /** - * If this is a directory, remove all its children - * If its a file, empty the contents - * - * @return this - */ - def clear()(implicit linkOptions: File.LinkOptions = File.LinkOptions.default): this.type = { - if (isDirectory(linkOptions)) { - children.foreach(_.delete()) - } else { - writeByteArray(Array.emptyByteArray)(File.OpenOptions.default) - } - this - } - - def deleteOnExit(): this.type = { - toJava.deleteOnExit() - this - } - - override def hashCode = - path.hashCode() - - override def toString = - pathAsString - - /** - * Zips this file (or directory) - * - * @param destination The destination file; Creates this if it does not exists - * @return The destination zip file - */ - def zipTo(destination: File, compressionLevel: Int = Deflater.DEFAULT_COMPRESSION)(implicit charset: Charset = defaultCharset): destination.type = { - val files = if (isDirectory) children else Iterator(this) - destination.zipIn(files, compressionLevel)(charset) - } - - /** - * zip to a temp directory - * - * @return the target directory - */ - def zip(compressionLevel: Int = Deflater.DEFAULT_COMPRESSION)(implicit charset: Charset = defaultCharset): File = - zipTo(destination = File.newTemporaryFile(name, ".zip"), compressionLevel)(charset) - - /** - * Unzips this zip file - * - * @param destination destination folder; Creates this if it does not exist - * @param zipFilter An optional param to reject or accept unzipping a file - * @return The destination where contents are unzipped - */ - def unzipTo(destination: File, zipFilter: ZipEntry => Boolean = _ => true)(implicit charset: Charset = defaultCharset): destination.type = { - for { - zipFile <- new ZipFile(toJava, charset).autoClosed - entry <- zipFile.entries().asScala if zipFilter(entry) - } entry.extractTo(destination, zipFile.getInputStream(entry)) - destination - } - - /** - * Streamed unzipping is slightly slower but supports larger files and more encodings - * @see https://github.com/pathikrit/better-files/issues/152 - * - * @param destinationDirectory destination folder; Creates this if it does not exist - * @return The destination where contents are unzipped - */ - def streamedUnzip(destinationDirectory: File = File.newTemporaryDirectory(name))(implicit charset: Charset = defaultCharset): destinationDirectory.type = { - for { - zipIn <- zipInputStream(charset) - } zipIn.mapEntries(_.extractTo(destinationDirectory, zipIn)).size - destinationDirectory - } - - def unGzipTo(destinationDirectory: File = File.newTemporaryDirectory())(implicit openOptions: File.OpenOptions = File.OpenOptions.default): destinationDirectory.type = { - for { - in <- inputStream(openOptions) - out <- destinationDirectory.outputStream(openOptions) - } in.buffered.pipeTo(out.buffered) - destinationDirectory - } - - /** - * Adds these files into this zip file - * Example usage: File("test.zip").zipIn(Seq(file"hello.txt", file"hello2.txt")) - * - * @param files - * @param compressionLevel - * @param charset - * @return this - */ - def zipIn(files: Files, compressionLevel: Int = Deflater.DEFAULT_COMPRESSION)(charset: Charset = defaultCharset): this.type = { - for { - output <- newZipOutputStream(File.OpenOptions.default, charset).withCompressionLevel(compressionLevel).autoClosed - input <- files - file <- input.walk() - name = input.parent relativize file - } output.add(file, name.toString) - this - } - - /** - * unzip to a temporary zip file - * - * @return the zip file - */ - def unzip(zipFilter: ZipEntry => Boolean = _ => true)(implicit charset: Charset = defaultCharset): File = - unzipTo(destination = File.newTemporaryDirectory(name), zipFilter)(charset) - - /** - * Java's temporary files/directories are not cleaned up by default. - * If we explicitly call `.deleteOnExit()`, it gets added to shutdown handler which is not ideal - * for long running systems with millions of temporary files as: - * a) it would slowdown shutdown and - * b) occupy unnecessary disk-space during app lifetime - * - * This util auto-deletes the resource when done using the ManagedResource facility - * - * Example usage: - * File.temporaryDirectory().foreach(tempDir => doSomething(tempDir) - * - * @return - */ - def toTemporary: ManagedResource[File] = - new ManagedResource(this)(Disposable.fileDisposer) - - //TODO: add features from https://github.com/sbt/io -} - -object File { - /** - * Get a file from a resource - * Note: Use resourceToFile instead as this may not actually always load the file - * See: http://stackoverflow.com/questions/676250/different-ways-of-loading-a-file-as-an-inputstream - * - * @param name - * @return - */ - def resource(name: String): File = - File(currentClassLoader().getResource(name)) - - /** - * Copies a resource into a file - * - * @param name - * @param destination File where resource is copied into, if not specified a temp file is created - * @return - */ - def copyResource(name: String)(destination: File = File.newTemporaryFile(prefix = name)): destination.type = { - for { - in <- resourceAsStream(name).autoClosed - out <- destination.outputStream - } in.pipeTo(out) - destination - } - - def newTemporaryDirectory(prefix: String = "", parent: Option[File] = None)(implicit attributes: Attributes = Attributes.default): File = { - parent match { - case Some(dir) => Files.createTempDirectory(dir.path, prefix, attributes: _*) - case _ => Files.createTempDirectory(prefix, attributes: _*) - } - } - - def temporaryDirectory(prefix: String = "", parent: Option[File] = None, attributes: Attributes = Attributes.default): ManagedResource[File] = - newTemporaryDirectory(prefix, parent)(attributes).toTemporary - - def usingTemporaryDirectory[U](prefix: String = "", parent: Option[File] = None, attributes: Attributes = Attributes.default)(f: File => U): Unit = - temporaryDirectory(prefix, parent, attributes).foreach(f) - - def newTemporaryFile(prefix: String = "", suffix: String = "", parent: Option[File] = None)(implicit attributes: Attributes = Attributes.default): File = { - parent match { - case Some(dir) => Files.createTempFile(dir.path, prefix, suffix, attributes: _*) - case _ => Files.createTempFile(prefix, suffix, attributes: _*) - } - } - - def temporaryFile[U](prefix: String = "", suffix: String = "", parent: Option[File] = None, attributes: Attributes = Attributes.default): ManagedResource[File] = - newTemporaryFile(prefix, suffix, parent)(attributes).toTemporary - - def usingTemporaryFile[U](prefix: String = "", suffix: String = "", parent: Option[File] = None, attributes: Attributes = Attributes.default)(f: File => U): Unit = - temporaryFile(prefix, suffix, parent, attributes).foreach(f) - - implicit def apply(path: Path): File = - new File(path.toAbsolutePath.normalize()) - - def apply(path: String, fragments: String*): File = - Paths.get(path, fragments: _*) - - /** - * Get File to path with help of reference anchor. - * - * Anchor is used as a reference in case that path is not absolute. - * Anchor could be path to directory or path to file. - * If anchor is file, then file's parent dir is used as an anchor. - * - * If anchor itself is relative, then anchor is used together with current working directory. - * - * NOTE: If anchor is non-existing path on filesystem, then it's always treated as file, - * e.g. it's last component is removed when it is used as an anchor. - * - * @param anchor path to be used as anchor - * @param path as string - * @param fragments optional path fragments - * @return absolute, normalize path - */ - def apply(anchor: File, path: String, fragments: String*): File = { - val p = Paths.get(path, fragments: _*) - if (p.isAbsolute) { - p - } else if (anchor.isDirectory) { - anchor / p.toString - } else { - anchor.parent / p.toString - } - } - - def apply(url: URL): File = - apply(url.toURI) - - def apply(uri: URI): File = - Paths.get(uri) - - def roots: Iterable[File] = - FileSystems.getDefault.getRootDirectories.asScala.map(File.apply) - - def root: File = - roots.head - - def home: File = - Properties.userHome.toFile - - def temp: File = - Properties.tmpDir.toFile - - def currentWorkingDirectory: File = - File("") - - type Attributes = Seq[FileAttribute[_]] - object Attributes { - val default : Attributes = Seq.empty - } - - type CopyOptions = Seq[CopyOption] - object CopyOptions { - def apply(overwrite: Boolean) : CopyOptions = (if (overwrite) Seq(StandardCopyOption.REPLACE_EXISTING) else default) ++ LinkOptions.default - val default : CopyOptions = Seq.empty //Seq(StandardCopyOption.COPY_ATTRIBUTES) - } - - type Events = Seq[WatchEvent.Kind[_]] - object Events { - val all : Events = Seq(StandardWatchEventKinds.ENTRY_CREATE, StandardWatchEventKinds.ENTRY_MODIFY, StandardWatchEventKinds.ENTRY_DELETE) - val default : Events = all - } - - type OpenOptions = Seq[OpenOption] - object OpenOptions { - val append : OpenOptions = Seq(StandardOpenOption.APPEND, StandardOpenOption.CREATE) - val default : OpenOptions = Seq.empty - } - - type LinkOptions = Seq[LinkOption] - object LinkOptions { - val follow : LinkOptions = Seq.empty - val noFollow : LinkOptions = Seq(LinkOption.NOFOLLOW_LINKS) - val default : LinkOptions = follow - } - - type VisitOptions = Seq[FileVisitOption] - object VisitOptions { - val follow : VisitOptions = Seq(FileVisitOption.FOLLOW_LINKS) - val default : VisitOptions = Seq.empty - } - - type Order = Ordering[File] - object Order { - val bySize : Order = Ordering.by(_.size) - val byName : Order = Ordering.by(_.name) - val byDepth : Order = Ordering.by(_.path.getNameCount) - val byModificationTime : Order = Ordering.by(_.lastModifiedTime) - val byDirectoriesLast : Order = Ordering.by(_.isDirectory) - val byDirectoriesFirst : Order = byDirectoriesLast.reverse - val default : Order = byDirectoriesFirst.andThenBy(byName) - } - - abstract class PathMatcherSyntax(name: String) { - - /** - * Return PathMatcher from this file - * - * @param file - * @param pattern - * @param includePath If this is true, no need to include path matchers - * e.g. instead of "**//*.txt" we can simply use *.txt - * @return - */ - def apply(file: File, pattern: String, includePath: Boolean): PathMatcher = { - val escapedPath = if (includePath) escapePath(file.path.toString + file.fileSystem.getSeparator) else "" - file.fileSystem.getPathMatcher(s"$name:$escapedPath$pattern") - } - - def escapePath(path: String): String - } - object PathMatcherSyntax { - val glob: PathMatcherSyntax = new PathMatcherSyntax("glob") { - override def escapePath(path: String) = path - .replaceAllLiterally("\\", "\\\\") - .replaceAllLiterally("*", "\\*") - .replaceAllLiterally("?", "\\?") - .replaceAllLiterally("{", "\\{") - .replaceAllLiterally("}", "\\}") - .replaceAllLiterally("[", "\\[") - .replaceAllLiterally("]", "\\]") - } - - val regex: PathMatcherSyntax = new PathMatcherSyntax("regex") { - override def escapePath(path: String) = Pattern.quote(path) - } - - val default: PathMatcherSyntax = glob - } - - class RandomAccessMode private(val value: String) - object RandomAccessMode { - val read = new RandomAccessMode("r") - val readWrite = new RandomAccessMode("rw") - val readWriteMetadataSynchronous = new RandomAccessMode("rws") - val readWriteContentSynchronous = new RandomAccessMode("rwd") - } - - def numberOfOpenFileDescriptors(): Long = { - java.lang.management.ManagementFactory - .getPlatformMBeanServer - .getAttribute(new javax.management.ObjectName("java.lang:type=OperatingSystem"), "OpenFileDescriptorCount") - .asInstanceOf[Long] - } - - /** - * Implement this interface to monitor the root file - */ - trait Monitor extends AutoCloseable { - val root: File - - /** - * Dispatch a StandardWatchEventKind to an appropriate callback - * Override this if you don't want to manually handle onDelete/onCreate/onModify separately - * - * @param eventType - * @param file - */ - def onEvent(eventType: WatchEvent.Kind[Path], file: File, count: Int): Unit = eventType match { - case StandardWatchEventKinds.ENTRY_CREATE => onCreate(file, count) - case StandardWatchEventKinds.ENTRY_MODIFY => onModify(file, count) - case StandardWatchEventKinds.ENTRY_DELETE => onDelete(file, count) - } - - def start()(implicit executionContext: ExecutionContext): Unit - - def onCreate(file: File, count: Int): Unit - - def onModify(file: File, count: Int): Unit - - def onDelete(file: File, count: Int): Unit - - def onUnknownEvent(event: WatchEvent[_], count: Int): Unit - - def onException(exception: Throwable): Unit - - def stop(): Unit = close() - } -} diff --git a/scalalib/src/test/resource/better-files/core/src/main/scala/better/files/FileMonitor.scala b/scalalib/src/test/resource/better-files/core/src/main/scala/better/files/FileMonitor.scala deleted file mode 100644 index f6f139f2..00000000 --- a/scalalib/src/test/resource/better-files/core/src/main/scala/better/files/FileMonitor.scala +++ /dev/null @@ -1,72 +0,0 @@ -package better.files - -import java.nio.file._ - -import scala.concurrent.ExecutionContext -import scala.util.Try -import scala.util.control.NonFatal - -/** - * Implementation of File.Monitor - * - * @param root - * @param maxDepth - */ -abstract class FileMonitor(val root: File, maxDepth: Int) extends File.Monitor { - protected[this] val service = root.newWatchService - - def this(root: File, recursive: Boolean = true) = this(root, if (recursive) Int.MaxValue else 0) - - /** - * If watching non-directory, don't react to siblings - * @param target - * @return - */ - protected[this] def reactTo(target: File) = root.isDirectory || root.isSamePathAs(target) - - protected[this] def process(key: WatchKey) = { - val path = key.watchable().asInstanceOf[Path] - - import scala.collection.JavaConverters._ - key.pollEvents().asScala foreach { - case event: WatchEvent[Path] @unchecked => - val target: File = path.resolve(event.context()) - if (reactTo(target)) { - if (event.kind() == StandardWatchEventKinds.ENTRY_CREATE) { - val depth = root.relativize(target).getNameCount - watch(target, (maxDepth - depth) max 0) // auto-watch new files in a directory - } - onEvent(event.kind(), target, event.count()) - } - case event => if (reactTo(path)) onUnknownEvent(event, event.count()) - } - key.reset() - } - - protected[this] def watch(file: File, depth: Int): Unit = { - def toWatch: Files = if (file.isDirectory) { - file.walk(depth).filter(f => f.isDirectory && f.exists) - } else { - when(file.exists)(file.parent).iterator // There is no way to watch a regular file; so watch its parent instead - } - try { - toWatch.foreach(f => Try[Unit](f.register(service)).recover(PartialFunction(onException)).get) - } catch { - case NonFatal(e) => onException(e) - } - } - - override def start()(implicit executionContext: ExecutionContext) = { - watch(root, maxDepth) - executionContext.execute(() => Iterator.continually(service.take()).foreach(process)) - } - - override def close() = service.close() - - // Although this class is abstract, we give provide implementations so user can choose to implement a subset of these - override def onCreate(file: File, count: Int) = {} - override def onModify(file: File, count: Int) = {} - override def onDelete(file: File, count: Int) = {} - override def onUnknownEvent(event: WatchEvent[_], count: Int) = {} - override def onException(exception: Throwable) = {} -} diff --git a/scalalib/src/test/resource/better-files/core/src/main/scala/better/files/Implicits.scala b/scalalib/src/test/resource/better-files/core/src/main/scala/better/files/Implicits.scala deleted file mode 100644 index 322b5f40..00000000 --- a/scalalib/src/test/resource/better-files/core/src/main/scala/better/files/Implicits.scala +++ /dev/null @@ -1,324 +0,0 @@ -package better.files - -import java.io.{File => JFile, _} -import java.nio.MappedByteBuffer -import java.nio.channels.FileChannel -import java.nio.charset.Charset -import java.nio.file.{Path, PathMatcher} -import java.security.MessageDigest -import java.util.StringTokenizer -import java.util.stream.{Stream => JStream} -import java.util.zip._ - -import scala.annotation.tailrec -import scala.collection.JavaConverters._ -import scala.util.Try - -/** - * Container for various implicits - */ -trait Implicits { - - //TODO: Rename all Ops to Extensions - - implicit class StringInterpolations(sc: StringContext) { - def file(args: Any*): File = - value(args).toFile - - private[this] def value(args: Seq[Any]) = - sc.s(args: _*) - } - - implicit class StringOps(str: String) { - def toFile: File = - File(str) - - def /(child: String): File = - toFile / child - } - - implicit class FileOps(file: JFile) { - def toScala: File = - File(file.getPath) - } - - implicit class SymbolExtensions(symbol: Symbol) { - def /(child: Symbol): File = - File(symbol.name) / child - } - - implicit class IteratorExtensions[A](it: Iterator[A]) { - def withHasNext(f: => Boolean): Iterator[A] = new Iterator[A] { - override def hasNext = f && it.hasNext - override def next() = it.next() - } - } - - implicit class InputStreamOps(in: InputStream) { - def pipeTo(out: OutputStream, bufferSize: Int = defaultBufferSize): out.type = - pipeTo(out, Array.ofDim[Byte](bufferSize)) - - /** - * Pipe an input stream to an output stream using a byte buffer - */ - @tailrec final def pipeTo(out: OutputStream, buffer: Array[Byte]): out.type = { - val n = in.read(buffer) - if (n > 0) { - out.write(buffer, 0, n) - pipeTo(out, buffer) - } else { - out - } - } - - def asString(closeStream: Boolean = true, bufferSize: Int = defaultBufferSize)(implicit charset: Charset = defaultCharset): String = { - try { - new ByteArrayOutputStream(bufferSize).autoClosed - .map(pipeTo(_, bufferSize = bufferSize).toString(charset.displayName())) - } finally { - if (closeStream) in.close() - } - } - - def buffered: BufferedInputStream = - new BufferedInputStream(in) - - def buffered(bufferSize: Int): BufferedInputStream = - new BufferedInputStream(in, bufferSize) - - def gzipped: GZIPInputStream = - new GZIPInputStream(in) - - /** - * If bufferSize is set to less than or equal to 0, we don't buffer - * @param bufferSize - * @return - */ - def asObjectInputStream(bufferSize: Int = defaultBufferSize): ObjectInputStream = - new ObjectInputStream(if (bufferSize <= 0) in else buffered(bufferSize)) - - /** - * @param bufferSize If bufferSize is set to less than or equal to 0, we don't buffer - * Code adapted from: - * https://github.com/apache/commons-io/blob/master/src/main/java/org/apache/commons/io/input/ClassLoaderObjectInputStream.java - * - * @return A special ObjectInputStream that loads a class based on a specified ClassLoader rather than the default - * This is useful in dynamic container environments. - */ - def asObjectInputStreamUsingClassLoader(classLoader: ClassLoader = getClass.getClassLoader, bufferSize: Int = defaultBufferSize): ObjectInputStream = - new ObjectInputStream(if (bufferSize <= 0) in else buffered(bufferSize)) { - override protected def resolveClass(objectStreamClass: ObjectStreamClass): Class[_] = - try { - Class.forName(objectStreamClass.getName, false, classLoader) - } catch { - case _: ClassNotFoundException ⇒ super.resolveClass(objectStreamClass) - } - - override protected def resolveProxyClass(interfaces: Array[String]): Class[_] = { - try { - java.lang.reflect.Proxy.getProxyClass( - classLoader, - interfaces.map(interface => Class.forName(interface, false, classLoader)) : _* - ) - } catch { - case _: ClassNotFoundException | _: IllegalArgumentException => super.resolveProxyClass(interfaces) - } - } - } - - def reader(implicit charset: Charset = defaultCharset): InputStreamReader = - new InputStreamReader(in, charset) - - def lines(implicit charset: Charset = defaultCharset): Iterator[String] = - reader(charset).buffered.lines().toAutoClosedIterator - - def bytes: Iterator[Byte] = - in.autoClosed.flatMap(res => eofReader(res.read()).map(_.toByte)) - } - - implicit class OutputStreamOps(val out: OutputStream) { - def buffered: BufferedOutputStream = - new BufferedOutputStream(out) - - def buffered(bufferSize: Int): BufferedOutputStream = - new BufferedOutputStream(out, bufferSize) - - def gzipped: GZIPOutputStream = - new GZIPOutputStream(out) - - def writer(implicit charset: Charset = defaultCharset): OutputStreamWriter = - new OutputStreamWriter(out, charset) - - def printWriter(autoFlush: Boolean = false): PrintWriter = - new PrintWriter(out, autoFlush) - - def write(bytes: Iterator[Byte], bufferSize: Int = defaultBufferSize): out.type = { - bytes.grouped(bufferSize).foreach(buffer => out.write(buffer.toArray)) - out.flush() - out - } - - def tee(out2: OutputStream): OutputStream = - new TeeOutputStream(out, out2) - - /** - * If bufferSize is set to less than or equal to 0, we don't buffer - * @param bufferSize - * @return - */ - def asObjectOutputStream(bufferSize: Int = defaultBufferSize): ObjectOutputStream = - new ObjectOutputStream(if (bufferSize <= 0) out else buffered(bufferSize)) - } - - implicit class ReaderOps(reader: Reader) { - def buffered: BufferedReader = - new BufferedReader(reader) - - def toInputStream(implicit charset: Charset = defaultCharset): InputStream = - new ReaderInputStream(reader)(charset) - } - - implicit class BufferedReaderOps(reader: BufferedReader) { - def chars: Iterator[Char] = - reader.autoClosed.flatMap(res => eofReader(res.read()).map(_.toChar)) - - def tokens(splitter: StringSplitter = StringSplitter.default): Iterator[String] = - reader.lines().toAutoClosedIterator.flatMap(splitter.split) - } - - implicit class WriterOps(writer: Writer) { - def buffered: BufferedWriter = - new BufferedWriter(writer) - - def outputstream(implicit charset: Charset = defaultCharset): OutputStream = - new WriterOutputStream(writer)(charset) - } - - implicit class FileChannelOps(fc: FileChannel) { - def toMappedByteBuffer: MappedByteBuffer = - fc.map(FileChannel.MapMode.READ_ONLY, 0, fc.size()) - } - - implicit class PathMatcherOps(matcher: PathMatcher) { - def matches(file: File)(implicit visitOptions: File.VisitOptions = File.VisitOptions.default) = - file.collectChildren(child => matcher.matches(child.path))(visitOptions) - } - - implicit class ObjectInputStreamOps(ois: ObjectInputStream) { - def deserialize[A]: A = - ois.readObject().asInstanceOf[A] - } - - implicit class ObjectOutputStreamOps(val oos: ObjectOutputStream) { - def serialize(obj: Serializable): oos.type = { - oos.writeObject(obj) - oos - } - } - - implicit class ZipOutputStreamOps(val out: ZipOutputStream) { - - /** - * Correctly set the compression level - * See: http://stackoverflow.com/questions/1206970/creating-zip-using-zip-utility - * - * @param level - * @return - */ - def withCompressionLevel(level: Int): out.type = { - out.setLevel(level) - if (level == Deflater.NO_COMPRESSION) out.setMethod(ZipOutputStream.DEFLATED) - out - } - - def add(file: File, name: String): out.type = { - val relativeName = name.stripSuffix(file.fileSystem.getSeparator) - val entryName = if (file.isDirectory) s"$relativeName/" else relativeName // make sure to end directories in ZipEntry with "/" - out.putNextEntry(new ZipEntry(entryName)) - if (file.isRegularFile) file.inputStream.foreach(_.pipeTo(out)) - out.closeEntry() - out - } - - def +=(file: File): out.type = - add(file, file.name) - } - - implicit class ZipInputStreamOps(val in: ZipInputStream) { - def mapEntries[A](f: ZipEntry => A): Iterator[A] = new Iterator[A] { - private[this] var entry = in.getNextEntry - - override def hasNext = entry != null - - override def next() = { - val result = Try(f(entry)) - Try(in.closeEntry()) - entry = in.getNextEntry - result.get - } - } - } - - implicit class ZipEntryOps(val entry: ZipEntry) { - /** - * Extract this ZipEntry under this rootDir - * - * @param rootDir directory under which this entry is extracted - * @param inputStream use this inputStream when this entry is a file - * @return the extracted file - */ - def extractTo(rootDir: File, inputStream: => InputStream): File = { - val child = rootDir.createChild(entry.getName, asDirectory = entry.isDirectory, createParents = true) - if (!entry.isDirectory) child.outputStream.foreach(inputStream.pipeTo(_)) - child - } - } - - implicit class CloseableOps[A <: AutoCloseable](resource: A) { - /** - * Lightweight automatic resource management - * Closes the resource when done e.g. - * <pre> - * for { - * in <- file.newInputStream.autoClosed - * } in.write(bytes) - * // in is closed now - * </pre> - * - * @return - */ - def autoClosed: ManagedResource[A] = - new ManagedResource(resource)(Disposable.closableDisposer) - } - - implicit class JStreamOps[A](stream: JStream[A]) { - /** - * Closes this stream when iteration is complete - * It will NOT close the stream if it is not depleted! - * - * @return - */ - def toAutoClosedIterator: Iterator[A] = - stream.autoClosed.flatMap(_.iterator().asScala) - } - - private[files] implicit class OrderingOps[A](order: Ordering[A]) { - def andThenBy(order2: Ordering[A]): Ordering[A] = - Ordering.comparatorToOrdering(order.thenComparing(order2)) - } - - implicit def stringToMessageDigest(algorithmName: String): MessageDigest = - MessageDigest.getInstance(algorithmName) - - implicit def stringToCharset(charsetName: String): Charset = - Charset.forName(charsetName) - - implicit def tokenizerToIterator(s: StringTokenizer): Iterator[String] = - Iterator.continually(s.nextToken()).withHasNext(s.hasMoreTokens) - - //implicit def posixPermissionToFileAttribute(perm: PosixFilePermission) = - // PosixFilePermissions.asFileAttribute(Set(perm)) - - private[files] implicit def pathStreamToFiles(files: JStream[Path]): Files = - files.toAutoClosedIterator.map(File.apply) -} diff --git a/scalalib/src/test/resource/better-files/core/src/main/scala/better/files/ManagedResource.scala b/scalalib/src/test/resource/better-files/core/src/main/scala/better/files/ManagedResource.scala deleted file mode 100644 index dad5ecb8..00000000 --- a/scalalib/src/test/resource/better-files/core/src/main/scala/better/files/ManagedResource.scala +++ /dev/null @@ -1,91 +0,0 @@ -package better.files - -import java.util.concurrent.atomic.AtomicBoolean - -import scala.util.Try -import scala.util.control.NonFatal - -/** - * A typeclass to denote a disposable resource - * @tparam A - */ -trait Disposable[-A] { - def dispose(resource: A): Unit - - def disposeSilently(resource: A): Unit = { - val _ = Try(dispose(resource)) - } -} - -object Disposable { - def apply[A](disposeMethod: A => Any): Disposable[A] = new Disposable[A] { - override def dispose(resource: A) = { - val _ = disposeMethod(resource) - } - } - - implicit val closableDisposer: Disposable[AutoCloseable] = - Disposable(_.close()) - - val fileDisposer: Disposable[File] = - Disposable(_.delete(swallowIOExceptions = true)) -} - -class ManagedResource[A](resource: A)(implicit disposer: Disposable[A]) { - private[this] val isDisposed = new AtomicBoolean(false) - private[this] def disposeOnce() = if (!isDisposed.getAndSet(true)) disposer.dispose(resource) - - // This is the Scala equivalent of how javac compiles try-with-resources, - // Except that fatal exceptions while disposing take precedence over exceptions thrown previously - private[this] def disposeOnceAndThrow(e1: Throwable) = { - try { - disposeOnce() - } catch { - case NonFatal(e2) => e1.addSuppressed(e2) - case e2: Throwable => - e2.addSuppressed(e1) - throw e2 - } - throw e1 - } - - def foreach[U](f: A => U): Unit = { - val _ = map(f) - } - - def map[B](f: A => B): B = { - try { - f(resource) - } catch { - case e1: Throwable => disposeOnceAndThrow(e1) - } finally { - disposeOnce() - } - } - - def withFilter(f: A => Boolean): this.type = { - if (!f(resource)) disposeOnce() - this - } - - /** - * This handles lazy operations (e.g. Iterators) - * for which resource needs to be disposed only after iteration is done - * - * @param f - * @tparam B - * @return - */ - def flatMap[B](f: A => Iterator[B]): Iterator[B] = { - val it = f(resource) - it withHasNext { - try { - val result = it.hasNext - if (!result) disposeOnce() - result - } catch { - case e1: Throwable => disposeOnceAndThrow(e1) - } - } - } -} diff --git a/scalalib/src/test/resource/better-files/core/src/main/scala/better/files/ReaderInputStream.scala b/scalalib/src/test/resource/better-files/core/src/main/scala/better/files/ReaderInputStream.scala deleted file mode 100644 index f9b792cc..00000000 --- a/scalalib/src/test/resource/better-files/core/src/main/scala/better/files/ReaderInputStream.scala +++ /dev/null @@ -1,83 +0,0 @@ -package better.files - -import java.io.{InputStream, Reader} -import java.nio.{ByteBuffer, CharBuffer} -import java.nio.charset.{Charset, CharsetEncoder, CoderResult, CodingErrorAction} - -import scala.annotation.tailrec - -/** - * Code ported from Java to Scala: - * https://github.com/apache/commons-io/blob/c0eb48f7e83987c5ed112b82f0d651aff5149ae4/src/main/java/org/apache/commons/io/input/ReaderInputStream.java - */ -class ReaderInputStream(reader: Reader, encoder: CharsetEncoder, bufferSize: Int) extends InputStream { - - def this(reader: Reader, bufferSize: Int = defaultBufferSize)(implicit charset: Charset = defaultCharset) = - this(reader = reader, encoder = charset.newEncoder.onMalformedInput(CodingErrorAction.REPLACE).onUnmappableCharacter(CodingErrorAction.REPLACE), bufferSize = bufferSize) - - /** - * CharBuffer used as input for the decoder. It should be reasonably - * large as we read data from the underlying Reader into this buffer. - */ - private[this] val encoderIn = CharBuffer.allocate(bufferSize).flip().asInstanceOf[CharBuffer] - - /** - * ByteBuffer used as output for the decoder. This buffer can be small - * as it is only used to transfer data from the decoder to the buffer provided by the caller. - */ - private[this] val encoderOut = ByteBuffer.allocate(bufferSize>>4).flip().asInstanceOf[ByteBuffer] - - private[this] var lastCoderResult = CoderResult.UNDERFLOW - private[this] var endOfInput = false - - private[this] def fillBuffer() = { - assert(!endOfInput) - if (lastCoderResult.isUnderflow) { - val position = encoderIn.compact().position - // We don't use Reader#read(CharBuffer) here because it is more efficient to write directly to the underlying char array - // since the default implementation copies data to a temporary char array anyway - reader.read(encoderIn.array, position, encoderIn.remaining) match { - case EOF => endOfInput = true - case c => encoderIn.position(position + c) - } - encoderIn.flip() - } - lastCoderResult = encoder.encode(encoderIn, encoderOut.compact(), endOfInput) - encoderOut.flip() - } - - override def read(b: Array[Byte], off: Int, len: Int) = { - if (len < 0 || off < 0 || (off + len) > b.length) throw new IndexOutOfBoundsException("Array Size=" + b.length + ", offset=" + off + ", length=" + len) - if (len == 0) { - 0 // Always return 0 if len == 0 - } else { - var read = 0 - @tailrec def loop(off: Int, len: Int): Unit = if (len > 0) { - if (encoderOut.hasRemaining) { - val c = encoderOut.remaining min len - encoderOut.get(b, off, c) - read += c - loop(off + c, len - c) - } else if (!endOfInput) { - fillBuffer() - loop(off, len) - } - } - loop(off, len) - if (read == 0 && endOfInput) EOF else read - } - } - - @tailrec final override def read() = { - if (encoderOut.hasRemaining) { - encoderOut.get & 0xFF - } else if (endOfInput) { - EOF - } else { - fillBuffer() - read() - } - } - - override def close() = reader.close() -} diff --git a/scalalib/src/test/resource/better-files/core/src/main/scala/better/files/Scanner.scala b/scalalib/src/test/resource/better-files/core/src/main/scala/better/files/Scanner.scala deleted file mode 100644 index be6ebb3f..00000000 --- a/scalalib/src/test/resource/better-files/core/src/main/scala/better/files/Scanner.scala +++ /dev/null @@ -1,183 +0,0 @@ -package better.files - -import java.io.{InputStream, LineNumberReader, Reader, StringReader} -import java.nio.charset.Charset -import java.time.format.DateTimeFormatter -import java.util.StringTokenizer - -trait Scanner extends Iterator[String] with AutoCloseable { - def lineNumber(): Int - - def next[A](implicit scan: Scannable[A]): A = scan(this) - - def nextLine(): String - - def lines: Iterator[String] = Iterator.continually(nextLine()).withHasNext(hasNext) -} - -/** - * Faster, safer and more idiomatic Scala replacement for java.util.Scanner - * See: http://codeforces.com/blog/entry/7018 - */ -object Scanner { - - def apply(str: String): Scanner = - Scanner(str, StringSplitter.default) - - def apply(str: String, splitter: StringSplitter): Scanner = - Scanner(new StringReader(str), splitter) - - def apply(reader: Reader): Scanner = - Scanner(reader, StringSplitter.default) - - def apply(reader: Reader, splitter: StringSplitter): Scanner = - Scanner(new LineNumberReader(reader.buffered), splitter) - - def apply(inputStream: InputStream)(implicit charset: Charset = defaultCharset): Scanner = - Scanner(inputStream, StringSplitter.default)(charset) - - def apply(inputStream: InputStream, splitter: StringSplitter)(implicit charset: Charset): Scanner = - Scanner(inputStream.reader(charset), splitter) - - def apply(reader: LineNumberReader, splitter: StringSplitter): Scanner = new Scanner { - private[this] val tokens = reader.tokens(splitter) - override def lineNumber() = reader.getLineNumber - override def nextLine() = reader.readLine() - override def next() = tokens.next() - override def hasNext = tokens.hasNext - override def close() = reader.close() - } - - val stdin: Scanner = Scanner(System.in) - - trait Read[A] { // TODO: Move to own subproject when this is fixed https://github.com/typelevel/cats/issues/932 - def apply(s: String): A - } - - object Read { - def apply[A](f: String => A): Read[A] = new Read[A] { - override def apply(s: String) = f(s) - } - implicit val string : Read[String] = Read(identity) - implicit val boolean : Read[Boolean] = Read(_.toBoolean) - implicit val byte : Read[Byte] = Read(_.toByte) //TODO: https://issues.scala-lang.org/browse/SI-9706 - implicit val short : Read[Short] = Read(_.toShort) - implicit val int : Read[Int] = Read(_.toInt) - implicit val long : Read[Long] = Read(_.toLong) - implicit val bigInt : Read[BigInt] = Read(BigInt(_)) - implicit val float : Read[Float] = Read(_.toFloat) - implicit val double : Read[Double] = Read(_.toDouble) - implicit val bigDecimal : Read[BigDecimal] = Read(BigDecimal(_)) - implicit def option[A: Read] : Read[Option[A]] = Read(s => when(s.nonEmpty)(implicitly[Read[A]].apply(s))) - - // Java's time readers - import java.time._ - import java.sql.{Date => SqlDate, Time => SqlTime, Timestamp => SqlTimestamp} - - implicit val duration : Read[Duration] = Read(Duration.parse(_)) - implicit val instant : Read[Instant] = Read(Instant.parse(_)) - implicit val localDateTime : Read[LocalDateTime] = Read(LocalDateTime.parse(_)) - implicit val localDate : Read[LocalDate] = Read(LocalDate.parse(_)) - implicit val monthDay : Read[MonthDay] = Read(MonthDay.parse(_)) - implicit val offsetDateTime : Read[OffsetDateTime] = Read(OffsetDateTime.parse(_)) - implicit val offsetTime : Read[OffsetTime] = Read(OffsetTime.parse(_)) - implicit val period : Read[Period] = Read(Period.parse(_)) - implicit val year : Read[Year] = Read(Year.parse(_)) - implicit val yearMonth : Read[YearMonth] = Read(YearMonth.parse(_)) - implicit val zonedDateTime : Read[ZonedDateTime] = Read(ZonedDateTime.parse(_)) - implicit val sqlDate : Read[SqlDate] = Read(SqlDate.valueOf) - implicit val sqlTime : Read[SqlTime] = Read(SqlTime.valueOf) - implicit val sqlTimestamp : Read[SqlTimestamp] = Read(SqlTimestamp.valueOf) - - /** - * Use this to create custom readers e.g. to read a LocalDate using some custom format - * val readLocalDate: Read[LocalDate] = Read.temporalQuery(format = myFormat, query = LocalDate.from) - * @param format - * @param query - * @tparam A - * @return - */ - def temporalQuery[A](format: DateTimeFormatter, query: temporal.TemporalQuery[A]): Read[A] = - Read(format.parse(_, query)) - } -} - -/** - * Implement this trait to make thing parsable - * In most cases, use Scanner.Read typeclass when you simply need access to one String token - * Use Scannable typeclass if you need access to the full scanner e.g. to detect encodings etc. - */ -trait Scannable[A] { - def apply(scanner: Scanner): A -} - -object Scannable { - def apply[A](f: Scanner => A): Scannable[A] = new Scannable[A] { - override def apply(scanner: Scanner) = f(scanner) - } - - implicit def fromRead[A](implicit read: Scanner.Read[A]): Scannable[A] = - Scannable(s => read(s.next())) - - implicit def tuple2[T1, T2](implicit t1: Scannable[T1], t2: Scannable[T2]): Scannable[(T1, T2)] = - Scannable(s => t1(s) -> t2(s)) - - implicit def iterator[A](implicit scanner: Scannable[A]): Scannable[Iterator[A]] = - Scannable(s => Iterator.continually(scanner(s)).withHasNext(s.hasNext)) -} - -trait StringSplitter { - def split(s: String): TraversableOnce[String] -} -object StringSplitter { - val default = StringSplitter.anyOf(" \t\t\n\r") - - /** - * Split string on this character - * This will return exactly 1 + n number of items where n is the number of occurence of delimiter in String s - * - * @param delimiter - * @return - */ - def on(delimiter: Char): StringSplitter = new StringSplitter { - override def split(s: String) = new Iterator[String] { - private[this] var i = 0 - private[this] var j = -1 - private[this] val c = delimiter.toInt - _next() - - private[this] def _next() = { - i = j + 1 - val k = s.indexOf(c, i) - j = if (k < 0) s.length else k - } - - override def hasNext = i <= s.length - - override def next() = { - val res = s.substring(i, j) - _next() - res - } - } - } - - /** - * Split this string using ANY of the characters from delimiters - * - * @param delimiters - * @param includeDelimiters - * @return - */ - def anyOf(delimiters: String, includeDelimiters: Boolean = false): StringSplitter = - s => new StringTokenizer(s, delimiters, includeDelimiters) - - /** - * Split string using a regex pattern - * - * @param pattern - * @return - */ - def regex(pattern: String): StringSplitter = - s => s.split(pattern, -1) -} diff --git a/scalalib/src/test/resource/better-files/core/src/main/scala/better/files/TeeOutputStream.scala b/scalalib/src/test/resource/better-files/core/src/main/scala/better/files/TeeOutputStream.scala deleted file mode 100644 index 1da25b09..00000000 --- a/scalalib/src/test/resource/better-files/core/src/main/scala/better/files/TeeOutputStream.scala +++ /dev/null @@ -1,23 +0,0 @@ -package better.files - -import java.io.OutputStream - -/** - * Write to multiple outputstreams at once - * If error happens on any one while doing an operation, only the last error is reported - * @param outs - */ -class TeeOutputStream(outs: OutputStream*) extends OutputStream { - override def write(b: Int) = tryAll(outs)(_.write(b)) - override def flush() = tryAll(outs)(_.flush()) - override def write(b: Array[Byte]) = tryAll(outs)(_.write(b)) - override def write(b: Array[Byte], off: Int, len: Int) = tryAll(outs)(_.write(b, off, len)) - override def close() = tryAll(outs)(_.close()) -} - -/** - * A sink outputstream similar to /dev/null - just consumes everything - */ -object NullOutputStream extends OutputStream { - override def write(b: Int) = {} -} diff --git a/scalalib/src/test/resource/better-files/core/src/main/scala/better/files/UnicodeCharset.scala b/scalalib/src/test/resource/better-files/core/src/main/scala/better/files/UnicodeCharset.scala deleted file mode 100644 index be81f628..00000000 --- a/scalalib/src/test/resource/better-files/core/src/main/scala/better/files/UnicodeCharset.scala +++ /dev/null @@ -1,100 +0,0 @@ -package better.files - -import java.nio.charset._ -import java.nio.{BufferOverflowException, ByteBuffer, CharBuffer} - -import scala.collection.JavaConverters._ - -/** - * A Unicode charset that handles byte-order markers - * - * @param underlyingCharset Use this charset if no known byte-order marker is detected; use this for encoding too - * @param writeByteOrderMarkers If set, write BOMs while encoding - */ -class UnicodeCharset(underlyingCharset: Charset, writeByteOrderMarkers: Boolean) - extends Charset(underlyingCharset.name(), underlyingCharset.aliases().asScala.toArray) { - override def newDecoder() = new UnicodeDecoder(underlyingCharset) - override def newEncoder() = if (writeByteOrderMarkers) new BomEncoder(underlyingCharset) else underlyingCharset.newEncoder() - override def contains(cs: Charset) = underlyingCharset.contains(cs) -} - -/** - * A Unicode decoder that uses the Unicode byte-order marker (BOM) to auto-detect the encoding - * (if none detected, falls back on the defaultCharset). This also gets around a bug in the JDK - * (http://bugs.java.com/bugdatabase/view_bug.do?bug_id=4508058) where BOM is not consumed for UTF-8. - * See: https://github.com/pathikrit/better-files/issues/107 - * - * @param defaultCharset Use this charset if no known byte-order marker is detected - */ -class UnicodeDecoder(defaultCharset: Charset) extends CharsetDecoder(defaultCharset, 1, 1) { - import UnicodeCharset.bomTable - - private[this] var inferredCharset: Option[Charset] = None - - @annotation.tailrec - private[this] def decode(in: ByteBuffer, out: CharBuffer, candidates: Set[Charset] = Set.empty): CoderResult = { - if (isCharsetDetected) { - detectedCharset().newDecoder().decode(in, out, true) - } else if (candidates.isEmpty || !in.hasRemaining) { - inferredCharset = Some(defaultCharset) - in.rewind() - decode(in, out) - } else if (candidates.forall(c => bomTable(c).length == in.position())) { - inferredCharset = candidates.headOption.ensuring(candidates.size == 1, "Ambiguous BOMs found") - decode(in, out) - } else { - val idx = in.position() - val byte = in.get() - def isPossible(charset: Charset) = bomTable(charset).lift(idx).contains(byte) - decode(in, out, candidates.filter(isPossible)) - } - } - - override def decodeLoop(in: ByteBuffer, out: CharBuffer) = decode(in = in, out = out, candidates = bomTable.keySet) - - override def isCharsetDetected = inferredCharset.isDefined - - override def isAutoDetecting = true - - override def implReset() = inferredCharset = None - - override def detectedCharset() = inferredCharset.getOrElse(throw new IllegalStateException("Insufficient bytes read to determine charset")) -} - -/** - * Encoder that writes the BOM for this charset - * @param charset - */ -class BomEncoder(charset: Charset) extends CharsetEncoder(charset, 1, 1) { - private[this] val bom = UnicodeCharset.bomTable.getOrElse(charset, throw new IllegalArgumentException(s"$charset does not support BOMs")).toArray - private[this] var isBomWritten = false - - override def encodeLoop(in: CharBuffer, out: ByteBuffer): CoderResult = { - if (!isBomWritten) { - try { - out.put(bom) - } catch { - case _: BufferOverflowException => return CoderResult.OVERFLOW - } finally { - isBomWritten = true - } - } - charset.newEncoder().encode(in, out, true) - } - - override def implReset() = isBomWritten = false -} - -object UnicodeCharset { - private[files] val bomTable: Map[Charset, IndexedSeq[Byte]] = Map( - "UTF-8" -> IndexedSeq(0xEF, 0xBB, 0xBF), - "UTF-16BE" -> IndexedSeq(0xFE, 0xFF), - "UTF-16LE" -> IndexedSeq(0xFF, 0xFE), - "UTF-32BE" -> IndexedSeq(0x00, 0x00, 0xFE, 0xFF), - "UTF-32LE" -> IndexedSeq(0xFF, 0xFE, 0x00, 0x00) - ).collect{case (charset, bytes) if Charset.isSupported(charset) => Charset.forName(charset) -> bytes.map(_.toByte)} - .ensuring(_.nonEmpty, "No unicode charset detected") - - def apply(charset: Charset, writeByteOrderMarkers: Boolean = false): Charset = - if (bomTable.contains(charset)) new UnicodeCharset(charset, writeByteOrderMarkers) else charset -} diff --git a/scalalib/src/test/resource/better-files/core/src/main/scala/better/files/WriterOutputStream.scala b/scalalib/src/test/resource/better-files/core/src/main/scala/better/files/WriterOutputStream.scala deleted file mode 100644 index 80cd5fc8..00000000 --- a/scalalib/src/test/resource/better-files/core/src/main/scala/better/files/WriterOutputStream.scala +++ /dev/null @@ -1,74 +0,0 @@ -package better.files - -import java.io.{OutputStream, Writer} -import java.nio.charset.{Charset, CharsetDecoder, CodingErrorAction} -import java.nio.{ByteBuffer, CharBuffer} - -import scala.annotation.tailrec - -/** - * Code ported from Java to Scala: - * https://github.com/apache/commons-io/blob/d357d9d563c4a34fa2ab3cdc68221c851a9de4f5/src/main/java/org/apache/commons/io/output/WriterOutputStream.java - */ -class WriterOutputStream(writer: Writer, decoder: CharsetDecoder, bufferSize: Int, flushImmediately: Boolean) extends OutputStream { - - /** - * CharBuffer used as output for the decoder - */ - private[this] val decoderOut = CharBuffer.allocate(bufferSize) - - /** - * ByteBuffer used as output for the decoder. This buffer can be small - * as it is only used to transfer data from the decoder to the buffer provided by the caller. - */ - private[this] val decoderIn = ByteBuffer.allocate(bufferSize>>4) - - def this(writer: Writer, bufferSize: Int = defaultBufferSize, flushImmediately: Boolean = false)(implicit charset: Charset = defaultCharset) = - this(writer = writer, decoder = charset.newDecoder.onMalformedInput(CodingErrorAction.REPLACE).onUnmappableCharacter(CodingErrorAction.REPLACE).replaceWith("?"), bufferSize = bufferSize, flushImmediately = flushImmediately) - - override def write(b: Array[Byte], off: Int, len: Int) = { - @tailrec def loop(off: Int, len: Int): Unit = if (len > 0) { - val c = decoderIn.remaining min len - decoderIn.put(b, off, c) - processInput(endOfInput = false) - loop(off + c, len - c) - } - loop(off, len) - if (flushImmediately) flushOutput() - } - - override def write(b: Int) = write(Array(b.toByte)) - - override def flush() = { - flushOutput() - writer.flush() - } - - override def close() = { - processInput(endOfInput = true) - flushOutput() - writer.close() - } - - private[this] def processInput(endOfInput: Boolean) = { - decoderIn.flip() - @tailrec def loop(): Unit = { - val coderResult = decoder.decode(decoderIn, decoderOut, endOfInput) - if (coderResult.isOverflow) { - flushOutput() - loop() - } else { - assert(coderResult.isUnderflow, "decoder is configured to replace malformed input and unmappable characters") - } - } - loop() - decoderIn.compact() - } - - private[this] def flushOutput(): Unit = { - if (decoderOut.position > 0) { - writer.write(decoderOut.array, 0, decoderOut.position) - val _ = decoderOut.rewind() - } - } -} diff --git a/scalalib/src/test/resource/better-files/core/src/main/scala/better/files/package.scala b/scalalib/src/test/resource/better-files/core/src/main/scala/better/files/package.scala deleted file mode 100644 index bef8c1ed..00000000 --- a/scalalib/src/test/resource/better-files/core/src/main/scala/better/files/package.scala +++ /dev/null @@ -1,66 +0,0 @@ -package better - -import java.io.{InputStream, StreamTokenizer} -import java.nio.charset.Charset - -import scala.collection.mutable -import scala.util.{Failure, Success, Try} - -package object files extends Implicits { - - /** - * Default array buffer size - * Seems like a good value used by JDK: (see: java.io.BufferedInputStream.DEFAULT_BUFFER_SIZE) - */ - val defaultBufferSize = 8192 - - /** - * The default charset used by better-files - * Note: It uses java.net.charset.Charset.defaultCharset() in general but if the default supports byte-order markers, - * it uses a more compliant version than the JDK one (see: https://github.com/pathikrit/better-files/issues/107) - */ - val defaultCharset: Charset = - UnicodeCharset(Charset.defaultCharset()) - - val EOF = StreamTokenizer.TT_EOF - - type Files = Iterator[File] - - /** - * If bufferSize is set to less than or equal to 0, we don't buffer - * @param bufferSize - * @return - */ - def resourceAsStream(name: String, bufferSize: Int = defaultBufferSize): InputStream = - currentClassLoader().getResourceAsStream(name).buffered(bufferSize) - - // Some utils: - private[files] def newMultiMap[A, B]: mutable.MultiMap[A, B] = new mutable.HashMap[A, mutable.Set[B]] with mutable.MultiMap[A, B] - - @inline private[files] def when[A](condition: Boolean)(f: => A): Option[A] = if (condition) Some(f) else None - - @inline private[files] def repeat[U](n: Int)(f: => U): Unit = (1 to n).foreach(_ => f) - - private[files] def currentClassLoader() = Thread.currentThread().getContextClassLoader - - private[files] def eofReader(read: => Int): Iterator[Int] = Iterator.continually(read).takeWhile(_ != EOF) - - /** - * Utility to apply f on all xs skipping over errors - * Throws the last error that happened - * * - * @param xs - * @param f - * @tparam A - */ - private[files] def tryAll[A](xs: Seq[A])(f: A => Unit): Unit = { - val res = xs.foldLeft(Option.empty[Throwable]) { - case (currError, a) => - Try(f(a)) match { - case Success(_) => currError - case Failure(e) => Some(e) - } - } - res.foreach(throwable => throw throwable) - } -} diff --git a/scalalib/src/test/resource/better-files/core/src/test/scala/better/files/CommonSpec.scala b/scalalib/src/test/resource/better-files/core/src/test/scala/better/files/CommonSpec.scala deleted file mode 100644 index 769cfbf9..00000000 --- a/scalalib/src/test/resource/better-files/core/src/test/scala/better/files/CommonSpec.scala +++ /dev/null @@ -1,15 +0,0 @@ -package better.files - -import org.scalatest.{BeforeAndAfterEach, FlatSpec, Matchers} - -import scala.concurrent.duration._ -import scala.language.postfixOps -import scala.util.Properties.{isLinux, isMac} - -trait CommonSpec extends FlatSpec with BeforeAndAfterEach with Matchers { - val isCI = sys.env.get("CI").exists(_.toBoolean) - - val isUnixOS = isLinux || isMac - - def sleep(t: FiniteDuration = 2 second) = Thread.sleep(t.toMillis) -} diff --git a/scalalib/src/test/resource/better-files/core/src/test/scala/better/files/FileMonitorSpec.scala b/scalalib/src/test/resource/better-files/core/src/test/scala/better/files/FileMonitorSpec.scala deleted file mode 100644 index 36379eec..00000000 --- a/scalalib/src/test/resource/better-files/core/src/test/scala/better/files/FileMonitorSpec.scala +++ /dev/null @@ -1,61 +0,0 @@ -package better.files - -import scala.concurrent.duration._ -import scala.concurrent.ExecutionContext.Implicits.global -import scala.language.postfixOps - -class FileMonitorSpec extends CommonSpec { - "file watcher" should "watch single files" in { - assume(isCI) - val file = File.newTemporaryFile(suffix = ".txt").writeText("Hello world") - - var log = List.empty[String] - def output(msg: String) = synchronized { - println(msg) - log = msg :: log - } - /***************************************************************************/ - val watcher = new FileMonitor(file) { - override def onCreate(file: File, count: Int) = output(s"$file got created $count time(s)") - override def onModify(file: File, count: Int) = output(s"$file got modified $count time(s)") - override def onDelete(file: File, count: Int) = output(s"$file got deleted $count time(s)") - } - watcher.start() - /***************************************************************************/ - sleep(5 seconds) - file.writeText("hello world"); sleep() - file.clear(); sleep() - file.writeText("howdy"); sleep() - file.delete(); sleep() - sleep(5 seconds) - val sibling = (file.parent / "t1.txt").createIfNotExists(); sleep() - sibling.writeText("hello world"); sleep() - sleep(20 seconds) - - log.size should be >= 2 - log.exists(_ contains sibling.name) shouldBe false - log.forall(_ contains file.name) shouldBe true - } - - ignore should "watch directories to configurable depth" in { - assume(isCI) - val dir = File.newTemporaryDirectory() - (dir/"a"/"b"/"c"/"d"/"e").createDirectories() - var log = List.empty[String] - def output(msg: String) = synchronized(log = msg :: log) - - val watcher = new FileMonitor(dir, maxDepth = 2) { - override def onCreate(file: File, count: Int) = output(s"Create happened on ${file.name} $count times") - } - watcher.start() - - sleep(5 seconds) - (dir/"a"/"b"/"t1").touch().writeText("hello world"); sleep() - (dir/"a"/"b"/"c"/"d"/"t1").touch().writeText("hello world"); sleep() - sleep(10 seconds) - - withClue(log) { - log.size shouldEqual 1 - } - } -} diff --git a/scalalib/src/test/resource/better-files/core/src/test/scala/better/files/FileSpec.scala b/scalalib/src/test/resource/better-files/core/src/test/scala/better/files/FileSpec.scala deleted file mode 100644 index f197575a..00000000 --- a/scalalib/src/test/resource/better-files/core/src/test/scala/better/files/FileSpec.scala +++ /dev/null @@ -1,549 +0,0 @@ -package better.files - -import java.nio.file.{FileAlreadyExistsException, FileSystems, Files => JFiles} - -import better.files.Dsl._ -import better.files.File.{home, root} - -import scala.language.postfixOps -import scala.util.Try - -class FileSpec extends CommonSpec { - - /** try to cope with windows, which will return e.g. c:\ as root */ - val rootStr = FileSystems.getDefault.getRootDirectories.iterator().next().toString - import java.io.File.{separator, separatorChar} - - /** - * Helper for unix -> windows path references (as strings). - * - * @param path as unix path - * @return path in native format - */ - def unixToNative(path: String): String = { - if (isUnixOS) { - path - } else { - path - .replaceFirst("^/", rootStr.replaceAllLiterally("\\", "\\\\")) // we must escape '\' in C:\ - .replaceAllLiterally("/", separator) - } - } - - var testRoot: File = _ //TODO: Get rid of mutable test vars - var fa: File = _ - var a1: File = _ - var a2: File = _ - var t1: File = _ - var t2: File = _ - var t3: File = _ - var fb: File = _ - var b1: File = _ - var b2: File = _ - - /** - * Setup the following directory structure under root - * /a - * /a1 - * /a2 - * a21.txt - * a22.txt - * /b - * b1/ --> ../a1 - * b2.txt --> ../a2/a22.txt - */ - - override def beforeEach() = { - testRoot = File.newTemporaryDirectory("better-files") - fa = testRoot/"a" - a1 = testRoot/"a"/"a1" - a2 = testRoot/"a"/"a2" - t1 = testRoot/"a"/"a1"/"t1.txt" - t2 = testRoot/"a"/"a1"/"t2.txt" - t3 = testRoot/"a"/"a1"/"t3.scala.txt" - fb = testRoot/"b" - b1 = testRoot/"b"/"b1" - b2 = testRoot/'b/"b2.txt" - Seq(a1, a2, fb) foreach mkdirs - Seq(t1, t2) foreach touch - } - - override def afterEach() = { - val _ = rm(testRoot) - } - - override def withFixture(test: NoArgTest) = { - //val before = File.numberOfOpenFileDescriptors() - val result = super.withFixture(test) - //val after = File.numberOfOpenFileDescriptors() - //assert(before == after, s"Resource leakage detected in $test") - result - } - - "files" can "be instantiated" in { - import java.io.{File => JFile} - - val f = File("/User/johndoe/Documents") // using constructor - val f1: File = file"/User/johndoe/Documents" // using string interpolator - val f2: File = "/User/johndoe/Documents".toFile // convert a string path to a file - val f3: File = new JFile("/User/johndoe/Documents").toScala // convert a Java file to Scala - val f4: File = root/"User"/"johndoe"/"Documents" // using root helper to start from root - //val f5: File = `~` / "Documents" // also equivalent to `home / "Documents"` - val f6: File = "/User"/"johndoe"/"Documents" // using file separator DSL - val f7: File = home/"Documents"/"presentations"/`..` // Use `..` to navigate up to parent - val f8: File = root/"User"/"johndoe"/"Documents"/ `.` - val f9: File = File(f.uri) - val f10: File = File("../a") // using a relative path - Seq(f, f1, f2, f3, f4,/* f5,*/ f6, f7, f8, f9, f10) foreach {f => - f.pathAsString should not include ".." - } - - root.toString shouldEqual rootStr - home.toString.count(_ == separatorChar) should be > 1 - (root/"usr"/"johndoe"/"docs").toString shouldEqual unixToNative("/usr/johndoe/docs") - Seq(f, f1, f2, f4, /*f5,*/ f6, f8, f9).map(_.toString).toSet shouldBe Set(f.toString) - } - - it can "be instantiated with anchor" in { - // testRoot / a / a1 / t1.txt - val basedir = a1 - File(basedir, "/abs/path/to/loc").toString should be(unixToNative("/abs/path/to/loc")) - File(basedir, "/abs", "path", "to", "loc").toString should be(unixToNative("/abs/path/to/loc")) - - File(basedir, "rel/path/to/loc").toString should be (unixToNative(basedir.toString + "/rel/path/to/loc")) - File(basedir, "../rel/path/to/loc").toString should be (unixToNative(fa.toString + "/rel/path/to/loc")) - File(basedir, "../", "rel", "path", "to", "loc").toString should be (unixToNative(fa.toString + "/rel/path/to/loc")) - - val baseref = t1 - File(baseref, "/abs/path/to/loc").toString should be (unixToNative("/abs/path/to/loc")) - File(baseref, "/abs", "path", "to", "loc").toString should be (unixToNative("/abs/path/to/loc")) - - File(baseref, "rel/path/to/loc").toString should be (unixToNative(a1.toString + "/rel/path/to/loc")) - File(baseref, "../rel/path/to/loc").toString should be (unixToNative(fa.toString + "/rel/path/to/loc")) - File(basedir, "../", "rel", "path", "to", "loc").toString should be (unixToNative(fa.toString + "/rel/path/to/loc")) - } - - it can "be instantiated with non-existing abs anchor" in { - val anchorStr = "/abs/to/nowhere" - val anchorStr_a = anchorStr + "/a" - val basedir = File(anchorStr_a + "/last") - - File(basedir, "/abs/path/to/loc").toString should be(unixToNative("/abs/path/to/loc")) - File(basedir, "/abs", "path", "to", "loc").toString should be(unixToNative("/abs/path/to/loc")) - - File(basedir, "rel/path/to/loc").toString should be (unixToNative(anchorStr_a + "/rel/path/to/loc")) - File(basedir, "../rel/path/to/loc").toString should be (unixToNative(anchorStr + "/rel/path/to/loc")) - File(basedir, "../", "rel", "path", "to", "loc").toString should be (unixToNative(anchorStr + "/rel/path/to/loc")) - } - - it can "be instantiated with non-existing relative anchor" in { - val relAnchor = File("rel/anc/b/last") - val basedir = relAnchor - - File(basedir, "/abs/path/to/loc").toString should be(unixToNative("/abs/path/to/loc")) - File(basedir, "/abs", "path", "to", "loc").toString should be(unixToNative("/abs/path/to/loc")) - - File(basedir, "rel/path/to/loc").toString should be (unixToNative(File("rel/anc/b").toString + "/rel/path/to/loc")) - File(basedir, "../rel/path/to/loc").toString should be (unixToNative(File("rel/anc").toString + "/rel/path/to/loc")) - File(basedir, "../", "rel", "path", "to", "loc").toString should be (unixToNative(File("rel/anc").toString + "/rel/path/to/loc")) - } - - it should "do basic I/O" in { - t1 < "hello" - t1.contentAsString shouldEqual "hello" - t1.appendLine() << "world" - (t1!) shouldEqual String.format("hello%nworld%n") - t1.chars.toStream should contain theSameElementsInOrderAs String.format("hello%nworld%n").toSeq - "foo" `>:` t1 - "bar" >>: t1 - t1.contentAsString shouldEqual String.format("foobar%n") - t1.appendLines("hello", "world") - t1.contentAsString shouldEqual String.format("foobar%nhello%nworld%n") - t2.writeText("hello").appendText("world").contentAsString shouldEqual "helloworld" - - (testRoot/"diary") - .createIfNotExists() - .appendLine() - .appendLines("My name is", "Inigo Montoya") - .printLines(Iterator("x", 1)) - .lines.toSeq should contain theSameElementsInOrderAs Seq("", "My name is", "Inigo Montoya", "x", "1") - } - - it should "handle BOM" in { - val lines = Seq("Line 1", "Line 2") - val expectedContent = lines.mkString(start = "", sep = "\n", end = "\n") - File.temporaryFile() foreach {file => - file.appendLines(lines: _*)(charset = UnicodeCharset("UTF-8", writeByteOrderMarkers = true)) - file.contentAsString(charset = "UTF-8") should not equal expectedContent - file.contentAsString shouldEqual expectedContent - } - } - -// TODO: Do not depend on self-referential tests -// it should "glob" in { -// assume(isCI) -// a1.glob("*.txt").map(_.name).toSeq.sorted shouldEqual Seq("t1.txt", "t2.txt") -// //a1.glob("*.txt").map(_.name).toSeq shouldEqual Seq("t1.txt", "t2.txt") -// testRoot.glob("**/*.txt").map(_.name).toSeq.sorted shouldEqual Seq("t1.txt", "t2.txt") -// val path = testRoot.path.toString.ensuring(testRoot.path.isAbsolute) -// File(path).glob("**/*.{txt}").map(_.name).toSeq.sorted shouldEqual Seq("t1.txt", "t2.txt") -// ("benchmarks"/"src").glob("**/*.{scala,java}").map(_.name).toSeq.sorted shouldEqual Seq("ArrayBufferScanner.java", "Benchmark.scala", "EncodingBenchmark.scala", "ScannerBenchmark.scala", "Scanners.scala") -// ("benchmarks"/"src").glob("**/*.{scala}").map(_.name).toSeq.sorted shouldEqual Seq( "Benchmark.scala", "EncodingBenchmark.scala", "ScannerBenchmark.scala", "Scanners.scala") -// ("benchmarks"/"src").glob("**/*.scala").map(_.name).toSeq.sorted shouldEqual Seq("Benchmark.scala", "EncodingBenchmark.scala", "ScannerBenchmark.scala", "Scanners.scala") -// ("benchmarks"/"src").listRecursively.filter(_.extension.contains(".scala")).map(_.name).toSeq.sorted shouldEqual Seq( "Benchmark.scala", "EncodingBenchmark.scala", "ScannerBenchmark.scala", "Scanners.scala") -// ls("core"/"src"/"test") should have length 1 -// ("core"/"src"/"test").walk(maxDepth = 1) should have length 2 -// ("core"/"src"/"test").walk(maxDepth = 0) should have length 1 -// ("core"/"src"/"test").walk() should have length (("core"/"src"/"test").listRecursively.length + 1L) -// ls_r("core"/"src"/"test") should have length 8 -// } - - it should "support names/extensions" in { - assume(isCI) - fa.extension shouldBe None - fa.nameWithoutExtension shouldBe fa.name - t1.extension shouldBe Some(".txt") - t1.extension(includeDot = false) shouldBe Some("txt") - t3.extension shouldBe Some(".txt") - t3.extension(includeAll = true) shouldBe Some(".scala.txt") - t3.extension(includeDot = false, includeAll = true) shouldBe Some("scala.txt") - t1.name shouldBe "t1.txt" - t1.nameWithoutExtension shouldBe "t1" - t1.changeExtensionTo(".md").name shouldBe "t1.md" - (t1 < "hello world").changeExtensionTo(".txt").name shouldBe "t1.txt" - t1.contentType shouldBe Some("text/plain") - ("src" / "test").toString should include ("better-files") - (t1 == t1.toString) shouldBe false - (t1.contentAsString == t1.toString) shouldBe false - (t1 == t1.contentAsString) shouldBe false - t1.root shouldEqual fa.root - file"/tmp/foo.scala.html".extension shouldBe Some(".html") - file"/tmp/foo.scala.html".nameWithoutExtension shouldBe "foo" - file"/tmp/foo.scala.html".nameWithoutExtension(includeAll = false) shouldBe "foo.scala" - root.name shouldBe "" - } - - it should "hide/unhide" in { - t1.isHidden shouldBe false - } - - it should "support parent/child" in { - fa isChildOf testRoot shouldBe true - testRoot isChildOf root shouldBe true - root isChildOf root shouldBe true - fa isChildOf fa shouldBe true - b2 isChildOf b2 shouldBe false - b2 isChildOf b2.parent shouldBe true - root.parent shouldBe null - } - - it should "support siblings" in { - (file"/tmp/foo.txt" sibling "bar.txt").pathAsString shouldBe unixToNative("/tmp/bar.txt") - fa.siblings.toList.map(_.name) shouldBe List("b") - fb isSiblingOf fa shouldBe true - } - - it should "support sorting" in { - testRoot.list.toSeq.sorted(File.Order.byName) should not be empty - testRoot.list.toSeq.max(File.Order.bySize).isEmpty shouldBe false - Seq(fa, fb).contains(testRoot.list.toSeq.min(File.Order.byDepth)) shouldBe true - sleep() - t2.appendLine("modified!") - a1.list.toSeq.min(File.Order.byModificationTime) shouldBe t1 - testRoot.list.toSeq.sorted(File.Order.byDirectoriesFirst) should not be empty - } - - it must "have .size" in { - fb.isEmpty shouldBe true - t1.size shouldBe 0 - t1.writeText("Hello World") - t1.size should be > 0L - testRoot.size should be > (t1.size + t2.size) - } - - it should "set/unset permissions" in { - assume(isCI) - import java.nio.file.attribute.PosixFilePermission - //an[UnsupportedOperationException] should be thrownBy t1.dosAttributes - t1.permissions()(PosixFilePermission.OWNER_EXECUTE) shouldBe false - - chmod_+(PosixFilePermission.OWNER_EXECUTE, t1) - t1.testPermission(PosixFilePermission.OWNER_EXECUTE) shouldBe true - t1.permissionsAsString shouldBe "rwxrw-r--" - - chmod_-(PosixFilePermission.OWNER_EXECUTE, t1) - t1.isOwnerExecutable shouldBe false - t1.permissionsAsString shouldBe "rw-rw-r--" - } - - it should "support equality" in { - fa shouldEqual (testRoot/"a") - fa shouldNot equal (testRoot/"b") - val c1 = fa.md5 - fa.md5 shouldEqual c1 - t1 < "hello" - t2 < "hello" - (t1 == t2) shouldBe false - (t1 === t2) shouldBe true - t2 < "hello world" - (t1 == t2) shouldBe false - (t1 === t2) shouldBe false - fa.md5 should not equal c1 - } - - it should "create if not exist directory structures" in { - File.usingTemporaryDirectory() {dir => - val file = dir / "a" / "b" / "c.txt" - assert(file.notExists) - assert(file.parent.notExists) - file.createIfNotExists(createParents = true) - assert(file.exists) - assert(file.parent.exists) - file.writeText("Hello world") - assert(file.contentAsString === "Hello world") - } - } - - it should "treat symlinks transparently in convenience methods" in { - File.usingTemporaryDirectory() {dir => - val realDir = dir / "a" - val dirSymlink = dir / "b" - realDir.createDirectory() - JFiles.createSymbolicLink(dirSymlink.path, realDir.path) - dirSymlink.createDirectories() - a[FileAlreadyExistsException] should be thrownBy dirSymlink.createDirectories()(linkOptions = File.LinkOptions.noFollow) - /*a[FileAlreadyExistsException] shouldNot be thrownBy*/ dirSymlink.createDirectories() - } - } - - it should "support chown/chgrp" in { - fa.ownerName should not be empty - fa.groupName should not be empty - a[java.nio.file.attribute.UserPrincipalNotFoundException] should be thrownBy chown("hitler", fa) - //a[java.nio.file.FileSystemException] should be thrownBy chown("root", fa) - a[java.nio.file.attribute.UserPrincipalNotFoundException] should be thrownBy chgrp("cool", fa) - //a[java.nio.file.FileSystemException] should be thrownBy chown("admin", fa) - //fa.chown("nobody").chgrp("nobody") - stat(t1) shouldBe a[java.nio.file.attribute.PosixFileAttributes] - } - - it should "detect file locks" in { - File.temporaryFile() foreach {file => - def lockInfo() = file.isReadLocked() -> file.isWriteLocked() - // TODO: Why is file.isReadLocked() should be false? - lockInfo() shouldBe (true -> false) - val channel = file.newRandomAccess(File.RandomAccessMode.readWrite).getChannel - val lock = channel.tryLock() - lockInfo() shouldBe (true -> true) - lock.release() - channel.close() - lockInfo() shouldBe (true -> false) - } - } - - it should "support ln/cp/mv" in { - val magicWord = "Hello World" - t1 writeText magicWord - // link - // to relative target - val b0 = b1.sibling("b0") - java.nio.file.Files.createSymbolicLink(b0.path, java.nio.file.Paths.get("b1")) - b0.symbolicLink should not be empty - b0.symbolicLink.get.path.isAbsolute shouldBe false - // to absolute target - b1.linkTo(a1, symbolic = true) - ln_s(b2, t2) - (b1 / "t1.txt").contentAsString shouldEqual magicWord - // copy - b2.contentAsString shouldBe empty - t1.md5 should not equal t2.md5 - a[java.nio.file.FileAlreadyExistsException] should be thrownBy (t1 copyTo t2) - t1.copyTo(t2, overwrite = true) - t1.exists shouldBe true - t1.md5 shouldEqual t2.md5 - b2.contentAsString shouldEqual magicWord - // rename - t2.name shouldBe "t2.txt" - t2.exists shouldBe true - val t3 = t2 renameTo "t3.txt" - t3.name shouldBe "t3.txt" - t2.exists shouldBe false - t3.exists shouldBe true - // move - t3 moveTo t2 - t2.exists shouldBe true - t3.exists shouldBe false - } - - it should "support creating hard links with ln" in { - assume(isUnixOS) - val magicWord = "Hello World" - t1 writeText magicWord - t1.linkTo(t3, symbolic = false) - (a1 / "t3.scala.txt").contentAsString shouldEqual magicWord - } - - it should "support custom charset" in { - import java.nio.charset.Charset - t1.writeText("你好世界")(charset = "UTF8") - t1.contentAsString(charset = "ISO-8859-1") should not equal "你好世界" - t1.contentAsString(charset = "UTF8") shouldEqual "你好世界" - val c1 = md5(t1) - val c2 = t1.overwrite("你好世界")(File.OpenOptions.default, Charset.forName("ISO-8859-1")).md5 - c1 should not equal c2 - c2 shouldEqual t1.checksum("md5") - } - - it should "support hashing algos" in { - implicit val charset = java.nio.charset.StandardCharsets.UTF_8 - t1.writeText("") - md5(t1) shouldEqual "D41D8CD98F00B204E9800998ECF8427E" - sha1(t1) shouldEqual "DA39A3EE5E6B4B0D3255BFEF95601890AFD80709" - sha256(t1) shouldEqual "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855" - sha512(t1) shouldEqual "CF83E1357EEFB8BDF1542850D66D8007D620E4050B5715DC83F4A921D36CE9CE47D0D13C5D85F2B0FF8318D2877EEC2F63B931BD47417A81A538327AF927DA3E" - } - - it should "compute correct checksum for non-zero length string" in { - implicit val charset = java.nio.charset.StandardCharsets.UTF_8 - t1.writeText("test") - md5(t1) shouldEqual "098F6BCD4621D373CADE4E832627B4F6" - sha1(t1) shouldEqual "A94A8FE5CCB19BA61C4C0873D391E987982FBBD3" - sha256(t1) shouldEqual "9F86D081884C7D659A2FEAA0C55AD015A3BF4F1B2B0B822CD15D6C15B0F00A08" - sha512(t1) shouldEqual "EE26B0DD4AF7E749AA1A8EE3C10AE9923F618980772E473F8819A5D4940E0DB27AC185F8A0E1D5F84F88BC887FD67B143732C304CC5FA9AD8E6F57F50028A8FF" - } - - it should "copy" in { - (fb / "t3" / "t4.txt").createIfNotExists(createParents = true).writeText("Hello World") - (fb / "t5" / "t5.txt").createIfNotExists(createParents = true).writeText("Scala Awesome") - (fb / "t5" / "t3").notExists shouldBe true - cp(fb / "t3", fb / "t5") - (fb / "t3").exists shouldBe true - (fb / "t5" / "t3").exists shouldBe true - (fb / "t5" / "t5.txt").contentAsString shouldEqual "Scala Awesome" - assert((fb / "t3") === (fb / "t5" / "t3")) - } - - it should "move" in { - (fb / "t3" / "t4.txt").createIfNotExists(createParents = true).writeText("Hello World") - mv(fb / "t3", fb / "t5") - (fb / "t5" / "t4.txt").contentAsString shouldEqual "Hello World" - (fb / "t3").notExists shouldBe true - } - - it should "delete" in { - fb.exists shouldBe true - fb.delete() - fb.exists shouldBe false - } - - it should "touch" in { - (fb / "z1").exists shouldBe false - (fb / "z1").isEmpty shouldBe true - (fb / "z1").touch() - (fb / "z1").exists shouldBe true - (fb / "z1").isEmpty shouldBe true - Thread.sleep(1000) - (fb / "z1").lastModifiedTime.getEpochSecond should be < (fb / "z1").touch().lastModifiedTime.getEpochSecond - } - - it should "md5" in { - val h1 = t1.hashCode - val actual = (t1 < "hello world").md5 - val h2 = t1.hashCode - h1 shouldEqual h2 - import scala.sys.process._ - val expected = Try(s"md5sum ${t1.path}" !!) getOrElse (s"md5 ${t1.path}" !!) - expected.toUpperCase should include (actual) - actual should not equal h1 - } - - it should "support file in/out" in { - t1 < "hello world" - for { - in <- t1.inputStream - out <- t2.outputStream - } in.pipeTo(out) - t2.contentAsString shouldEqual "hello world" - t2.newInputStream.asString() shouldEqual "hello world" - } - - it should "zip/unzip directories" in { - t1.writeText("hello world") - val zipFile = testRoot.zip() - zipFile.size should be > 100L - zipFile.name should endWith (".zip") - - def test(output: File) = { - (output/"a"/"a1"/"t1.txt").contentAsString shouldEqual "hello world" - output === testRoot shouldBe true - (output/"a"/"a1"/"t1.txt").overwrite("hello") - (output !== testRoot) shouldBe true - } - - test(zipFile.unzip()) - test(zipFile.streamedUnzip()) - } - - it should "zip/unzip single files" in { - t1.writeText("hello world") - val zipFile = t1.zip() - zipFile.size should be > 100L - zipFile.name should endWith (".zip") - val destination = unzip(zipFile)(File.newTemporaryDirectory()) - (destination/"t1.txt").contentAsString shouldEqual "hello world" - } - - it should "gzip" in { - for { - writer <- (testRoot / "test.gz").newOutputStream.buffered.gzipped.writer.buffered.autoClosed - } writer.write("Hello world") - - (testRoot / "test.gz").inputStream.map(_.buffered.gzipped.buffered.lines.toSeq) shouldEqual Seq("Hello world") - } - - it should "read bytebuffers" in { - t1.writeText("hello world") - for { - fileChannel <- t1.newFileChannel.autoClosed - } fileChannel.toMappedByteBuffer.remaining() shouldEqual t1.bytes.length - - (t2 writeBytes t1.bytes).contentAsString shouldEqual t1.contentAsString - } - - it should "convert readers to inputstreams and writers to outputstreams" in { - File.temporaryFile() foreach {f => - val text = List.fill(10000)("hello world") - for { - writer <- f.bufferedWriter - out <- writer.outputstream.autoClosed - } out.write(text.mkString("\n").getBytes) - val t = f.bufferedReader.flatMap(_.toInputStream.lines) - t.toList shouldEqual text - } - } - - it should "serialize/deserialize" in { - class Person(val name: String, val age: Int) extends Serializable - val p1 = new Person("Chris", 34) - - File.temporaryFile() foreach {f => //serialization round-trip test - assert(f.isEmpty) - f.writeSerialized(p1) - assert(f.nonEmpty) - val p2: Person = f.readDeserialized[Person] - assert(p1.name === p2.name) - assert(p1.age === p2.age) - - val p3 = f.inputStream.map(_.asObjectInputStreamUsingClassLoader().deserialize[Person]) - assert(p3.name === p2.name) - assert(p3.age === p2.age) - } - } - - it should "count number of open file descriptors" in { - val expected = java.lang.management.ManagementFactory.getOperatingSystemMXBean - .asInstanceOf[com.sun.management.UnixOperatingSystemMXBean] - .getOpenFileDescriptorCount - assert((File.numberOfOpenFileDescriptors() - expected).abs <= 10) - } -} diff --git a/scalalib/src/test/resource/better-files/core/src/test/scala/better/files/GlobSpec.scala b/scalalib/src/test/resource/better-files/core/src/test/scala/better/files/GlobSpec.scala deleted file mode 100644 index 1acf7d7b..00000000 --- a/scalalib/src/test/resource/better-files/core/src/test/scala/better/files/GlobSpec.scala +++ /dev/null @@ -1,360 +0,0 @@ -package better.files - -import better.files.Dsl._ - -import java.io.File.separator - -import org.scalatest.BeforeAndAfterAll - -class GlobSpec extends CommonSpec with BeforeAndAfterAll { - var testDir: File = _ - var globTree: File = _ - var specialTree: File = _ - - var regexWildcardPath: File = _ - var globWildcardPath: File = _ - // - // Test target for glob - // - // tests/ - // ├── globtree - // │ ├── a - // │ │ ├── a2 - // │ │ │ ├── a2.txt - // │ │ │ └── x.txt - // │ │ ├── a.not - // │ │ ├── a.txt - // │ │ └── x.txt - // │ ├── b - // │ │ ├── a - // │ │ │ └── ba.txt - // │ │ └── b.txt - // │ ├── c - // │ │ ├── c.txt - // │ │ └── x.txt - // │ ├── empty - // │ ├── link_to_a -> a - // │ ├── one.txt - // │ ├── readme.md - // │ ├── three.txt - // │ └── two.txt - // └── special - // ├── .* - // │ └── a - // │ └── a.txt - // └── ** - // └── a - // └── a.txt - // - override def beforeAll() = { - testDir = File.newTemporaryDirectory("glob-tests") - globTree = testDir / "globtree" - - mkdir(globTree) - val a = mkdir(globTree / "a" ) - mkdir(globTree / "a" / "a2") - touch(globTree / "a" / "a2" / "a2.txt") - touch(globTree / "a" / "a2" / "x.txt") - touch(globTree / "a" / "a.not") - touch(globTree / "a" / "a.txt") - touch(globTree / "a" / "x.txt") - - mkdir(globTree / "b" ) - mkdir(globTree / "b" / "a") - touch(globTree / "b" / "a" / "ba.txt") - touch(globTree / "b" / "b.txt") - - mkdir(globTree / "c" ) - touch(globTree / "c" / "c.txt") - touch(globTree / "c" / "x.txt") - - mkdir(globTree / "empty" ) - - if (isUnixOS) { - ln_s(globTree / "link_to_a", a) - } - - touch(globTree / "one.txt") - touch(globTree / "two.txt") - touch(globTree / "three.txt") - touch(globTree / "readme.md") - - // Special target with path name components as wildcards - specialTree = testDir / "special" - - // Windows does not support '*' in file names - if (isUnixOS) { - // regex - mkdir(specialTree) - regexWildcardPath = mkdir(specialTree / ".*") - mkdir(specialTree / ".*" / "a") - touch(specialTree / ".*" / "a" / "a.txt") - - // glob - globWildcardPath = mkdir(specialTree / "**") - mkdir(specialTree / "**" / "a") - touch(specialTree / "**" / "a" / "a.txt") - } - - () - } - - override def afterAll() = { - val _ = rm(testDir) - } - - /** - * Helper in case something goes wrong... - */ - private def debugPaths(files: Seq[File]): String = { - files - .sortBy(_.path) - .map(files => s"PATH: ${files.toString}") - .mkString(s"SIZE: ${files.size}\n", "\n", "\n") - } - - /** - * Verity if candidates are equal with references. - * Does not accept empty sets, use assert(paths.isEmpty) for that. - * - * @param pathsIt candidates - * @param refPaths references - * @param baseDir basedir to for creating full path of references - */ - private def verify(pathsIt: Files, refPaths: Seq[String], baseDir: File) = { - val paths = pathsIt.toSeq - val refs = refPaths - .map(refPath => baseDir/refPath) - .sortBy(_.path) - - withClue("Result: " + debugPaths(paths) + "Reference: " + debugPaths(refs)) { - assert(paths.length === refPaths.length) - assert(paths.nonEmpty) - paths.sortBy(_.path).zip(refs).foreach({case (path, refPath) => assert(path === refPath)}) - } - } - - "glob" should "match plain file (e.g. 'file.ext')" in { - val refPaths = Seq( - "one.txt" - ) - val paths = globTree.glob("one.txt") - verify(paths, refPaths, globTree) - } - it should "match path without glob (e.g. 'sub/dir/file.ext')" in { - val refPaths = Seq( - "a/a.txt" - ) - val paths = globTree.glob("a/a.txt") - verify(paths, refPaths, globTree) - } - - it should "match file-glob (e.g. '*.ext')" in { - val refPaths = Seq( - "one.txt", - "two.txt", - "three.txt" - ) - val paths = globTree.glob("*.txt") - verify(paths, refPaths, globTree) - assert(globTree.glob("*.txt", includePath = false)(File.PathMatcherSyntax.glob).isEmpty) - } - - it should "match fixed sub dir and file-glob (e.g. '**/subdir/*.ext')" in { - // TODO: DOC: why top level 'a' is not matched - val refPaths = List( - "b/a/ba.txt" - ) - val paths = globTree.glob("**/a/*.txt") - verify(paths, refPaths, globTree) - } - - it should "use parent dir for matching (e.g. plain 'subdir/*.ext')" in { - // e.g. check that b nor c are matched, nor b/a - val refPaths = Seq( - "a/a.txt", - "a/x.txt" - ) - val paths = globTree.glob("a/*.txt") - verify(paths, refPaths, globTree) - } - - it should "match sub-directory glob with plain file (e.g. 'subdir/*/file.ext')" in { - val refPaths = Seq( - "a/x.txt", - "c/x.txt" - ) - val paths = testDir.glob("globtree/*/x.txt") - verify(paths, refPaths, globTree) - } - - it should "match sub-directory glob with file-glob (e.g. 'subdir/*/*.ext')" in { - val refPaths = Seq( - "a/a.txt", - "a/x.txt", - "c/c.txt", - "c/x.txt", - "b/b.txt" - ) - val paths = testDir.glob("globtree/*/*.txt") - verify(paths, refPaths, globTree) - } - - it should "match deep sub-directory glob with plain file (e.g. 'subdir/**/file.ext')" in { - val refPaths = Seq( - "a/a2/x.txt", - "a/x.txt", - "c/x.txt" - ) - val p1s = globTree.glob("**/x.txt") - verify(p1s, refPaths, globTree) - - val p2s = testDir.glob("globtree/**/x.txt") - verify(p2s, refPaths, globTree) - } - - it should "match deep sub-directory glob with file-glob (e.g. 'subdir/**/*.ext')" in { - val refPaths = Seq( - "a/a.txt", - "a/x.txt", - "a/a2/x.txt", - "a/a2/a2.txt", - "c/x.txt", - "c/c.txt", - "b/b.txt", - "b/a/ba.txt" - ) - val p1s = globTree.glob("**/*.txt") - verify(p1s, refPaths, globTree) - - val p2s = testDir.glob("globtree/**/*.txt") - verify(p2s, refPaths, globTree) - } - - it should "match deep file-glob (e.g. 'subdir/**.ext')" in { - val refPaths = Seq( - "one.txt", - "two.txt", - "three.txt", - "a/a.txt", - "a/x.txt", - "a/a2/x.txt", - "a/a2/a2.txt", - "b/a/ba.txt", - "b/b.txt", - "c/x.txt", - "c/c.txt" - ) - val p1s = globTree.glob("**.txt") - verify(p1s, refPaths, globTree) - - val p2s = testDir.glob("globtree/**.txt") - verify(p2s, refPaths, globTree) - } - - it should "match everything (e.g. 'subdir/**')" in { - val refPaths = List( - "a", - "a/a.not", - "a/a.txt", - "a/a2", - "a/a2/a2.txt", - "a/a2/x.txt", - "a/x.txt", - "b", - "b/a", - "b/a/ba.txt", - "b/b.txt", - "c", - "c/c.txt", - "c/x.txt", - "empty", - "one.txt", - "readme.md", - "three.txt", - "two.txt") ++ - when(isUnixOS)("link_to_a") - - val paths = testDir.glob("globtree/**") - verify(paths, refPaths, globTree) - } - - it should "work with links (e.g. 'link_to_a/**.txt')" in { - assume(isUnixOS) - val refPaths = Seq( - "a/a.txt", - "a/x.txt", - "a/a2/x.txt", - "a/a2/a2.txt" - ) - - // TODO: DOC: File behaviour, links are resolved (abs + normalized path) - - val p1s = globTree.glob("link_to_a/**.txt")(visitOptions = File.VisitOptions.follow) - verify(p1s, refPaths, globTree) - - val p2s = globTree.glob("link_to_a/**.txt").toSeq - assert(p2s.isEmpty) - - val p3s = testDir.glob("globtree/link_to_a/**.txt")(visitOptions = File.VisitOptions.follow) - verify(p3s, refPaths, globTree) - - val p4s = testDir.glob("globtree/link_to_a/**.txt") - assert(p4s.isEmpty) - } - - it should "not use dir name as wildcard (e.g. dirname is **)" in { - assume(isUnixOS) - val d = globWildcardPath // "path" / "with" / "**" - val paths = d.glob("*.txt") - - assert(paths.isEmpty) - } - - "Regex" should "match all txt-files under sub-directory (e.g. '.*/.*\\\\.txt')" in { - val refPaths = Seq( - "a/a.txt", - "a/x.txt", - "a/a2/x.txt", - "a/a2/a2.txt", - "c/x.txt", - "c/c.txt", - "b/b.txt", - "b/a/ba.txt" - ) - val paths = globTree.glob(".*" + separator + ".*\\.txt")(File.PathMatcherSyntax.regex) - - verify(paths, refPaths, globTree) - } - - it should "match the same if `Regex` is used" in { - val pattern = (".*" + separator + ".*\\.txt").r - - val pathsGlob = globTree.glob(pattern.regex)(File.PathMatcherSyntax.regex) - val pathsRegex = globTree.globRegex(pattern) - - verify(pathsRegex, pathsGlob.toSeq.map(_.toString), globTree) - - } - - it should "use parent dir for matching (e.g. plain 'subdir/*.ext' instead of '**/subdir/*.ext)" in { - // e.g. check that b nor c are matched, nor b/a - val refPaths = Seq( - "a/a.txt", - "a/x.txt", - "a/a2/a2.txt", - "a/a2/x.txt" - ) - val paths = globTree.glob("a" + separator + ".*\\.txt")(File.PathMatcherSyntax.regex) - - verify(paths, refPaths, globTree) - assert(globTree.glob("a/.*\\.txt", includePath = false)(File.PathMatcherSyntax.regex).isEmpty) - } - - it should "not use dir name as wildcard (e.g. dirname is .*)" in { - assume(isUnixOS) - val d = regexWildcardPath // "path" / "with" / ".*" - val paths = d.glob("a\\.txt")(File.PathMatcherSyntax.regex) - assert(paths.isEmpty) - } -} diff --git a/scalalib/src/test/resource/better-files/core/src/test/scala/better/files/ManagedResourceSpec.scala b/scalalib/src/test/resource/better-files/core/src/test/scala/better/files/ManagedResourceSpec.scala deleted file mode 100644 index 554f5358..00000000 --- a/scalalib/src/test/resource/better-files/core/src/test/scala/better/files/ManagedResourceSpec.scala +++ /dev/null @@ -1,250 +0,0 @@ -package better.files - -import org.scalatest.matchers.{MatchResult, Matcher} - -import scala.reflect.ClassTag -import scala.util.control.ControlThrowable - -class ManagedResourceSpec extends CommonSpec { - // Test classes - - private class TestDisposable extends AutoCloseable { - var closeCount = 0 - - override def close(): Unit = - closeCount += 1 - } - - private class TestDisposableThatThrows extends TestDisposable { - override def close(): Unit = { - super.close() - throw new TestDisposeException - } - } - - private class TestDisposableThatThrowsFatal extends TestDisposable { - override def close(): Unit = { - super.close() - throw new TestDisposeFatalException - } - } - - private class TestEvalException extends Exception - private class TestDisposeException extends Exception - private class TestDisposeFatalException extends Exception with ControlThrowable - - // Custom matchers - - private class HaveSuppressedMatcher(classes: Class[_ <: Throwable]*) extends Matcher[Throwable] { - override def apply(left: Throwable): MatchResult = { - MatchResult( - (classes corresponds left.getSuppressed) { - (clazz, suppressed) => clazz isInstance suppressed - }, - s"had suppressed exceptions of types ${classes.map(_.getSimpleName).mkString(", ")}", - s"had not suppressed exceptions of types ${classes.map(_.getSimpleName).mkString(", ")}" - ) - } - } - - private def haveSuppressed[E <: Throwable](implicit ct: ClassTag[E]) = - new HaveSuppressedMatcher(ct.runtimeClass.asInstanceOf[Class[_ <: Throwable]]) - - // Test body - - behavior of "managed resources" - - it should "map correctly" in { - val t = new TestDisposable - - val result = for { - tc <- t.autoClosed - } yield { - t.closeCount shouldBe 0 - "hello" - } - - result shouldBe "hello" - t.closeCount shouldBe 1 - } - - it should "flatMap correctly" in { - val t = new TestDisposable - - val result = (for { - tc <- t.autoClosed - v <- Iterator("one", "two", "three") - } yield { - t.closeCount shouldBe 0 - v - }).toSeq - - result should contain inOrder ("one", "two", "three") - t.closeCount shouldBe 1 - } - - it should "handle exceptions correctly" in { - val t = new TestDisposable - - a [TestEvalException] should be thrownBy { - for { - tc <- t.autoClosed - } { - t.closeCount shouldBe 0 - throw new TestEvalException - } - } - t.closeCount shouldBe 1 - - var lastSeen = "" - a [TestEvalException] should be thrownBy { - for { - tc <- t.autoClosed - v <- Iterator("one", "two", "three") - } { - t.closeCount shouldBe 1 - lastSeen = v - if (v == "two") throw new TestEvalException - } - } - t.closeCount shouldBe 2 - lastSeen shouldBe "two" - } - - it should "handle disposal exceptions correctly" in { - // For some mysterious reason, thrownBy doesn't work here, in this specific test case. No clue why, despite spending an entire day trying to figure it out, - // including repeatedly stepping through the innards of ScalaTest in a debugger. Catching the exception manually does work, though. - val messageNoException = "no exception was thrown" - def messageWrongException(e: Throwable): String = - s"an exception was thrown, but not a TestDisposeException; instead it's a ${e.getClass.getName}" - - val t = new TestDisposableThatThrows - - val e1 = - try { - for { - tc <- t.autoClosed - } { - t.closeCount shouldBe 0 - } - None - } - catch { - case e: TestDisposeException => - Some(e) - } - assert(e1.nonEmpty, messageNoException) - e1 foreach { e1c => assert(e1c.isInstanceOf[TestDisposeException], messageWrongException(e1c)) } - t.closeCount shouldBe 1 - - var lastSeen = "" - val e2 = - try { - val i = for { - tc <- t.autoClosed - v <- Iterator("one", "two", "three") - } yield { - t.closeCount shouldBe 1 - lastSeen = v - v - } - while (i.hasNext) i.next() - None - } - catch { - case e: TestDisposeException => - Some(e) - } - lastSeen shouldBe "three" - assert(e2.nonEmpty, messageNoException) - e2 foreach { e2c => assert(e2c.isInstanceOf[TestDisposeException], messageWrongException(e2c)) } - t.closeCount shouldBe 2 - } - - it should "handle non-local returns correctly" in { - val t = new TestDisposable - - def doTheThing(): String = { - throw the [ControlThrowable] thrownBy { - for { - tc <- t.autoClosed - } { - t.closeCount shouldBe 0 - return "hello" - } - } - } - doTheThing() shouldBe "hello" - t.closeCount shouldBe 1 - - def doTheThings(): String = { - throw the [ControlThrowable] thrownBy { - for { - tc <- t.autoClosed - v <- Iterator("one", "two", "three") - } { - t.closeCount shouldBe 1 - if (v == "two") return v - } - } - } - doTheThings() shouldBe "two" - t.closeCount shouldBe 2 - } - - it should "handle multiple exceptions correctly" in { - val t = new TestDisposableThatThrows - - the [TestEvalException] thrownBy { - for { - tc <- t.autoClosed - } { - t.closeCount shouldBe 0 - throw new TestEvalException - } - } should haveSuppressed [TestDisposeException] - t.closeCount shouldBe 1 - - var lastSeen = "" - the [TestEvalException] thrownBy { - for { - tc <- t.autoClosed - v <- Iterator("one", "two", "three") - } { - t.closeCount shouldBe 1 - lastSeen = v - if (v == "two") throw new TestEvalException - } - } should haveSuppressed [TestDisposeException] - lastSeen shouldBe "two" - t.closeCount shouldBe 2 - } - - it should "give fatal exceptions precedence" in { - val t = new TestDisposableThatThrowsFatal - - the [TestDisposeFatalException] thrownBy { - for { - tc <- t.autoClosed - } { - t.closeCount shouldBe 0 - throw new TestEvalException - } - } should haveSuppressed [TestEvalException] - t.closeCount shouldBe 1 - - var lastSeen = "" - the [TestDisposeFatalException] thrownBy { - for { - tc <- t.autoClosed - v <- Iterator("one", "two", "three") - } { - t.closeCount shouldBe 1 - lastSeen = v - if (v == "two") throw new TestEvalException - } - } should haveSuppressed [TestEvalException] - t.closeCount shouldBe 2 - lastSeen shouldBe "two" - } -} diff --git a/scalalib/src/test/resource/better-files/core/src/test/scala/better/files/ScannerSpec.scala b/scalalib/src/test/resource/better-files/core/src/test/scala/better/files/ScannerSpec.scala deleted file mode 100644 index 54f0a117..00000000 --- a/scalalib/src/test/resource/better-files/core/src/test/scala/better/files/ScannerSpec.scala +++ /dev/null @@ -1,79 +0,0 @@ -package better.files - -import Dsl._ - -import scala.language.existentials - -class ScannerSpec extends CommonSpec { - def t1 = File.newTemporaryFile() - - - "splitter" should "split" in { - val csvSplitter = StringSplitter.on(',') - def split(s: String) = csvSplitter.split(s).toList - - assert(split(",") === List("", "")) - assert(split("") === List("")) - assert(split("Hello World") === List("Hello World")) - assert(split("Hello,World") === List("Hello", "World")) - - assert(split(",,") === List("", "", "")) - assert(split(",Hello,World,") === List("", "Hello", "World", "")) - assert(split(",Hello,World") === List("", "Hello", "World")) - assert(split("Hello,World,") === List("Hello", "World", "")) - } - - "scanner" should "parse files" in { - val data = t1 << s""" - | Hello World - | 1 2 3 - | Ok 23 football - """.stripMargin - data.scanner() foreach {scanner => - assert(scanner.lineNumber() == 0) - assert(scanner.next[String] == "Hello") - assert(scanner.lineNumber() == 2) - assert(scanner.next[String] == "World") - assert(scanner.next[Int] == 1) - assert(scanner.next[Int] == 2) - assert(scanner.lineNumber() == 3) - assert(scanner.next[Int] == 3) - assert(scanner.nextLine() == " Ok 23 football") - assert(!scanner.hasNext) - a[NoSuchElementException] should be thrownBy scanner.next() - assert(!scanner.hasNext) - } - data.tokens().toSeq shouldEqual data.newScanner().toSeq - } - - it should "parse longs/booleans" in { - val data = for { - scanner <- Scanner("10 false").autoClosed - } yield scanner.next[(Long, Boolean)] - data shouldBe ((10L, false)) - } - - it should "parse custom parsers" in { - val file = t1 < """ - |Garfield - |Woofer - """.stripMargin - - sealed trait Animal - case class Dog(name: String) extends Animal - case class Cat(name: String) extends Animal - - implicit val animalParser: Scannable[Animal] = Scannable {scanner => - val name = scanner.next[String] - if (name == "Garfield") Cat(name) else Dog(name) - } - file.scanner() foreach {scanner => - Seq.fill(2)(scanner.next[Animal]) should contain theSameElementsInOrderAs Seq(Cat("Garfield"), Dog("Woofer")) - } - } - - it should "parse empty tokens" in { - val scanner = Scanner("hello||world", StringSplitter.on('|')) - List.fill(3)(scanner.next[Option[String]]) shouldEqual List(Some("hello"), None, Some("world")) - } -} diff --git a/scalalib/src/test/resource/better-files/project/Dependencies.scala b/scalalib/src/test/resource/better-files/project/Dependencies.scala deleted file mode 100644 index 5e0a037d..00000000 --- a/scalalib/src/test/resource/better-files/project/Dependencies.scala +++ /dev/null @@ -1,15 +0,0 @@ -import sbt._ - -object Dependencies { - val scalatest = "org.scalatest" %% "scalatest" % "3.0.4" % Test - - // Used in Akka file watcher - val akka = "com.typesafe.akka" %% "akka-actor" % "2.5.6" - - // For shapeless based Reader/Scanner - val shapeless = "com.chuusai" %% "shapeless" % "2.3.2" - - // Used in Benchmarks only - val commonsio = "commons-io" % "commons-io" % "2.5" - val fastjavaio = "fastjavaio" % "fastjavaio" % "1.0" from "https://github.com/williamfiset/FastJavaIO/releases/download/v1.0/fastjavaio.jar" -} diff --git a/scalalib/src/test/resource/better-files/project/build.properties b/scalalib/src/test/resource/better-files/project/build.properties deleted file mode 100644 index 74e2336b..00000000 --- a/scalalib/src/test/resource/better-files/project/build.properties +++ /dev/null @@ -1,2 +0,0 @@ -# This can only be upto version supported by CircleCI. See: https://circleci.com/docs/1.0/language-scala/ -sbt.version=0.13.9 diff --git a/scalalib/src/test/resource/better-files/project/plugins.sbt b/scalalib/src/test/resource/better-files/project/plugins.sbt deleted file mode 100644 index dba2a1da..00000000 --- a/scalalib/src/test/resource/better-files/project/plugins.sbt +++ /dev/null @@ -1,9 +0,0 @@ -addSbtPlugin("com.eed3si9n" % "sbt-unidoc" % "0.3.2") -addSbtPlugin("com.github.gseitz" % "sbt-release" % "1.0.0") -addSbtPlugin("com.jsuereth" % "sbt-pgp" % "1.0.0") -addSbtPlugin("org.scoverage" % "sbt-scoverage" % "1.5.0") -addSbtPlugin("com.timushev.sbt" % "sbt-updates" % "0.1.9") -addSbtPlugin("com.typesafe.sbt" % "sbt-ghpages" % "0.5.4") -addSbtPlugin("com.updateimpact" % "updateimpact-sbt-plugin" % "2.1.1") -addSbtPlugin("org.xerial.sbt" % "sbt-sonatype" % "0.5.1") -addSbtPlugin("com.codacy" % "sbt-codacy-coverage" % "1.3.8") diff --git a/scalalib/src/test/resource/better-files/shapeless/src/main/scala/better/files/ShapelessScanner.scala b/scalalib/src/test/resource/better-files/shapeless/src/main/scala/better/files/ShapelessScanner.scala deleted file mode 100644 index d60487d9..00000000 --- a/scalalib/src/test/resource/better-files/shapeless/src/main/scala/better/files/ShapelessScanner.scala +++ /dev/null @@ -1,24 +0,0 @@ -package better.files - -import better.files.Scanner.Read - -import shapeless._ - -import scala.util.Try - -object ShapelessScanner { - implicit val hNilScannable: Scannable[HNil] = - Scannable(_ => HNil) - - implicit def hListScannable[H, T <: HList](implicit h: Lazy[Scannable[H]], t: Scannable[T]): Scannable[H :: T] = - Scannable(s => h.value(s) :: t(s)) - - implicit def genericScannable[A, R](implicit gen: Generic.Aux[A, R], reprScannable: Lazy[Scannable[R]]): Scannable[A] = - Scannable(s => gen.from(reprScannable.value(s))) - - implicit val cnilReader: Read[CNil] = - Read(s => throw new RuntimeException(s"Could not read $s into this coproduct")) - - implicit def coproductReader[H, T <: Coproduct](implicit h: Read[H], t: Read[T]): Read[H :+: T] = - Read(s => Try(Inl(h(s))).getOrElse(Inr(t(s)))) -} diff --git a/scalalib/src/test/resource/better-files/shapeless/src/test/scala/better/files/ShapelessScannerSpec.scala b/scalalib/src/test/resource/better-files/shapeless/src/test/scala/better/files/ShapelessScannerSpec.scala deleted file mode 100644 index 34557261..00000000 --- a/scalalib/src/test/resource/better-files/shapeless/src/test/scala/better/files/ShapelessScannerSpec.scala +++ /dev/null @@ -1,32 +0,0 @@ -package better.files - -import shapeless._ - -class ShapelessScannerSpec extends CommonSpec { - import ShapelessScanner._ - - val text = """ - 12 Bob True - 13 Mary False - 26 Rick True - """ - - "Shapeless Scanner" should "parse HList" in { - val in = Scanner(text) - - type Row = Int :: String :: Boolean :: HNil - val out = Seq.fill(3)(in.next[Row]) - assert(out == Seq( - 12 :: "Bob" :: true :: HNil, - 13 :: "Mary" :: false :: HNil, - 26 :: "Rick" :: true :: HNil - )) - } - - "Shapeless Scanner" should "parse case class" in { - val in = Scanner(text) - - case class Person(id: Int, name: String, isMale: Boolean) - assert(in.next[Iterator[Person]].map(_.id).sum == 51) - } -} diff --git a/scalalib/src/test/resource/better-files/site/index.html b/scalalib/src/test/resource/better-files/site/index.html deleted file mode 100644 index 29931115..00000000 --- a/scalalib/src/test/resource/better-files/site/index.html +++ /dev/null @@ -1,16 +0,0 @@ -<!DOCTYPE html> -<html lang="en"> - <head> - <meta charset="UTF-8"> - <title>Better Files</title> - <script language="JavaScript"> - function doRedirect() { - window.location.replace("latest/api/better/files/File.html"); - } - doRedirect(); - </script> - </head> - <body> - <a href="latest/api/better/files/File.html">ScalaDoc</a> - </body> -</html> diff --git a/scalalib/src/test/resource/better-files/site/tech_talk_preview.png b/scalalib/src/test/resource/better-files/site/tech_talk_preview.png Binary files differdeleted file mode 100644 index 9f9f7599..00000000 --- a/scalalib/src/test/resource/better-files/site/tech_talk_preview.png +++ /dev/null diff --git a/scalalib/src/test/resource/better-files/version.sbt b/scalalib/src/test/resource/better-files/version.sbt deleted file mode 100644 index 0750fecd..00000000 --- a/scalalib/src/test/resource/better-files/version.sbt +++ /dev/null @@ -1 +0,0 @@ -version in ThisBuild := "3.2.1-SNAPSHOT"
\ No newline at end of file |