first pass at building better-files using Mill

41 files changed, 6014 insertions, 0 deletions

diff --git a/scalaplugin/src/test/resource/better-files/.gitignore b/scalaplugin/src/test/resource/better-files/.gitignore
new file mode 100644
index 00000000..6f460f93
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/.gitignore
@@ -0,0 +1,206 @@
+# 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/scalaplugin/src/test/resource/better-files/CHANGES.md b/scalaplugin/src/test/resource/better-files/CHANGES.md
new file mode 100644
index 00000000..4103ef04
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/CHANGES.md
@@ -0,0 +1,73 @@
+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/scalaplugin/src/test/resource/better-files/LICENSE b/scalaplugin/src/test/resource/better-files/LICENSE
new file mode 100644
index 00000000..a63964f8
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/LICENSE
@@ -0,0 +1,21 @@
+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/scalaplugin/src/test/resource/better-files/README.md b/scalaplugin/src/test/resource/better-files/README.md
new file mode 100644
index 00000000..9877c3bc
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/README.md
@@ -0,0 +1,637 @@
+# 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/scalaplugin/src/test/resource/better-files/akka/README.md b/scalaplugin/src/test/resource/better-files/akka/README.md
new file mode 100644
index 00000000..391cec2e
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/akka/README.md
@@ -0,0 +1,394 @@
+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/scalaplugin/src/test/resource/better-files/akka/src/main/scala/better/files/FileWatcher.scala b/scalaplugin/src/test/resource/better-files/akka/src/main/scala/better/files/FileWatcher.scala
new file mode 100644
index 00000000..66594d20
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/akka/src/main/scala/better/files/FileWatcher.scala
@@ -0,0 +1,67 @@
+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/scalaplugin/src/test/resource/better-files/akka/src/test/scala/better/files/FileWatcherSpec.scala b/scalaplugin/src/test/resource/better-files/akka/src/test/scala/better/files/FileWatcherSpec.scala
new file mode 100644
index 00000000..014373cd
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/akka/src/test/scala/better/files/FileWatcherSpec.scala
@@ -0,0 +1,101 @@
+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/scalaplugin/src/test/resource/better-files/benchmarks/README.md b/scalaplugin/src/test/resource/better-files/benchmarks/README.md
new file mode 100644
index 00000000..ed092ece
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/benchmarks/README.md
@@ -0,0 +1,24 @@
+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/scalaplugin/src/test/resource/better-files/benchmarks/src/main/java/better/files/ArrayBufferScanner.java b/scalaplugin/src/test/resource/better-files/benchmarks/src/main/java/better/files/ArrayBufferScanner.java
new file mode 100644
index 00000000..50550704
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/benchmarks/src/main/java/better/files/ArrayBufferScanner.java
@@ -0,0 +1,78 @@
+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/scalaplugin/src/test/resource/better-files/benchmarks/src/main/scala/better/files/Scanners.scala b/scalaplugin/src/test/resource/better-files/benchmarks/src/main/scala/better/files/Scanners.scala
new file mode 100644
index 00000000..791e6039
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/benchmarks/src/main/scala/better/files/Scanners.scala
@@ -0,0 +1,158 @@
+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/scalaplugin/src/test/resource/better-files/benchmarks/src/test/scala/better/files/Benchmark.scala b/scalaplugin/src/test/resource/better-files/benchmarks/src/test/scala/better/files/Benchmark.scala
new file mode 100644
index 00000000..68b734e1
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/benchmarks/src/test/scala/better/files/Benchmark.scala
@@ -0,0 +1,10 @@
+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/scalaplugin/src/test/resource/better-files/benchmarks/src/test/scala/better/files/EncodingBenchmark.scala b/scalaplugin/src/test/resource/better-files/benchmarks/src/test/scala/better/files/EncodingBenchmark.scala
new file mode 100644
index 00000000..aa09bc77
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/benchmarks/src/test/scala/better/files/EncodingBenchmark.scala
@@ -0,0 +1,39 @@
+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/scalaplugin/src/test/resource/better-files/benchmarks/src/test/scala/better/files/ScannerBenchmark.scala b/scalaplugin/src/test/resource/better-files/benchmarks/src/test/scala/better/files/ScannerBenchmark.scala
new file mode 100644
index 00000000..83082b9a
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/benchmarks/src/test/scala/better/files/ScannerBenchmark.scala
@@ -0,0 +1,66 @@
+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/scalaplugin/src/test/resource/better-files/build.sbt b/scalaplugin/src/test/resource/better-files/build.sbt
new file mode 100644
index 00000000..a3ae7a81
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/build.sbt
@@ -0,0 +1,163 @@
+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/scalaplugin/src/test/resource/better-files/circle.yml b/scalaplugin/src/test/resource/better-files/circle.yml
new file mode 100644
index 00000000..0ca8d9b9
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/circle.yml
@@ -0,0 +1,21 @@
+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/scalaplugin/src/test/resource/better-files/core/src/main/scala/better/files/Dsl.scala b/scalaplugin/src/test/resource/better-files/core/src/main/scala/better/files/Dsl.scala
new file mode 100644
index 00000000..3bacd91d
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/core/src/main/scala/better/files/Dsl.scala
@@ -0,0 +1,155 @@
+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/scalaplugin/src/test/resource/better-files/core/src/main/scala/better/files/File.scala b/scalaplugin/src/test/resource/better-files/core/src/main/scala/better/files/File.scala
new file mode 100644
index 00000000..eb11cd93
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/core/src/main/scala/better/files/File.scala
@@ -0,0 +1,1257 @@
+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/scalaplugin/src/test/resource/better-files/core/src/main/scala/better/files/FileMonitor.scala b/scalaplugin/src/test/resource/better-files/core/src/main/scala/better/files/FileMonitor.scala
new file mode 100644
index 00000000..f6f139f2
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/core/src/main/scala/better/files/FileMonitor.scala
@@ -0,0 +1,72 @@
+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/scalaplugin/src/test/resource/better-files/core/src/main/scala/better/files/Implicits.scala b/scalaplugin/src/test/resource/better-files/core/src/main/scala/better/files/Implicits.scala
new file mode 100644
index 00000000..322b5f40
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/core/src/main/scala/better/files/Implicits.scala
@@ -0,0 +1,324 @@
+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/scalaplugin/src/test/resource/better-files/core/src/main/scala/better/files/ManagedResource.scala b/scalaplugin/src/test/resource/better-files/core/src/main/scala/better/files/ManagedResource.scala
new file mode 100644
index 00000000..dad5ecb8
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/core/src/main/scala/better/files/ManagedResource.scala
@@ -0,0 +1,91 @@
+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/scalaplugin/src/test/resource/better-files/core/src/main/scala/better/files/ReaderInputStream.scala b/scalaplugin/src/test/resource/better-files/core/src/main/scala/better/files/ReaderInputStream.scala
new file mode 100644
index 00000000..f9b792cc
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/core/src/main/scala/better/files/ReaderInputStream.scala
@@ -0,0 +1,83 @@
+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/scalaplugin/src/test/resource/better-files/core/src/main/scala/better/files/Scanner.scala b/scalaplugin/src/test/resource/better-files/core/src/main/scala/better/files/Scanner.scala
new file mode 100644
index 00000000..be6ebb3f
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/core/src/main/scala/better/files/Scanner.scala
@@ -0,0 +1,183 @@
+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/scalaplugin/src/test/resource/better-files/core/src/main/scala/better/files/TeeOutputStream.scala b/scalaplugin/src/test/resource/better-files/core/src/main/scala/better/files/TeeOutputStream.scala
new file mode 100644
index 00000000..1da25b09
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/core/src/main/scala/better/files/TeeOutputStream.scala
@@ -0,0 +1,23 @@
+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/scalaplugin/src/test/resource/better-files/core/src/main/scala/better/files/UnicodeCharset.scala b/scalaplugin/src/test/resource/better-files/core/src/main/scala/better/files/UnicodeCharset.scala
new file mode 100644
index 00000000..be81f628
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/core/src/main/scala/better/files/UnicodeCharset.scala
@@ -0,0 +1,100 @@
+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/scalaplugin/src/test/resource/better-files/core/src/main/scala/better/files/WriterOutputStream.scala b/scalaplugin/src/test/resource/better-files/core/src/main/scala/better/files/WriterOutputStream.scala
new file mode 100644
index 00000000..80cd5fc8
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/core/src/main/scala/better/files/WriterOutputStream.scala
@@ -0,0 +1,74 @@
+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/scalaplugin/src/test/resource/better-files/core/src/main/scala/better/files/package.scala b/scalaplugin/src/test/resource/better-files/core/src/main/scala/better/files/package.scala
new file mode 100644
index 00000000..bef8c1ed
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/core/src/main/scala/better/files/package.scala
@@ -0,0 +1,66 @@
+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/scalaplugin/src/test/resource/better-files/core/src/test/scala/better/files/CommonSpec.scala b/scalaplugin/src/test/resource/better-files/core/src/test/scala/better/files/CommonSpec.scala
new file mode 100644
index 00000000..769cfbf9
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/core/src/test/scala/better/files/CommonSpec.scala
@@ -0,0 +1,15 @@
+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/scalaplugin/src/test/resource/better-files/core/src/test/scala/better/files/FileMonitorSpec.scala b/scalaplugin/src/test/resource/better-files/core/src/test/scala/better/files/FileMonitorSpec.scala
new file mode 100644
index 00000000..36379eec
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/core/src/test/scala/better/files/FileMonitorSpec.scala
@@ -0,0 +1,61 @@
+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/scalaplugin/src/test/resource/better-files/core/src/test/scala/better/files/FileSpec.scala b/scalaplugin/src/test/resource/better-files/core/src/test/scala/better/files/FileSpec.scala
new file mode 100644
index 00000000..f197575a
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/core/src/test/scala/better/files/FileSpec.scala
@@ -0,0 +1,549 @@
+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/scalaplugin/src/test/resource/better-files/core/src/test/scala/better/files/GlobSpec.scala b/scalaplugin/src/test/resource/better-files/core/src/test/scala/better/files/GlobSpec.scala
new file mode 100644
index 00000000..1acf7d7b
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/core/src/test/scala/better/files/GlobSpec.scala
@@ -0,0 +1,360 @@
+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/scalaplugin/src/test/resource/better-files/core/src/test/scala/better/files/ManagedResourceSpec.scala b/scalaplugin/src/test/resource/better-files/core/src/test/scala/better/files/ManagedResourceSpec.scala
new file mode 100644
index 00000000..554f5358
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/core/src/test/scala/better/files/ManagedResourceSpec.scala
@@ -0,0 +1,250 @@
+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/scalaplugin/src/test/resource/better-files/core/src/test/scala/better/files/ScannerSpec.scala b/scalaplugin/src/test/resource/better-files/core/src/test/scala/better/files/ScannerSpec.scala
new file mode 100644
index 00000000..54f0a117
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/core/src/test/scala/better/files/ScannerSpec.scala
@@ -0,0 +1,79 @@
+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/scalaplugin/src/test/resource/better-files/project/Dependencies.scala b/scalaplugin/src/test/resource/better-files/project/Dependencies.scala
new file mode 100644
index 00000000..5e0a037d
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/project/Dependencies.scala
@@ -0,0 +1,15 @@
+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/scalaplugin/src/test/resource/better-files/project/build.properties b/scalaplugin/src/test/resource/better-files/project/build.properties
new file mode 100644
index 00000000..74e2336b
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/project/build.properties
@@ -0,0 +1,2 @@
+# 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/scalaplugin/src/test/resource/better-files/project/plugins.sbt b/scalaplugin/src/test/resource/better-files/project/plugins.sbt
new file mode 100644
index 00000000..dba2a1da
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/project/plugins.sbt
@@ -0,0 +1,9 @@
+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/scalaplugin/src/test/resource/better-files/shapeless/src/main/scala/better/files/ShapelessScanner.scala b/scalaplugin/src/test/resource/better-files/shapeless/src/main/scala/better/files/ShapelessScanner.scala
new file mode 100644
index 00000000..d60487d9
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/shapeless/src/main/scala/better/files/ShapelessScanner.scala
@@ -0,0 +1,24 @@
+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/scalaplugin/src/test/resource/better-files/shapeless/src/test/scala/better/files/ShapelessScannerSpec.scala b/scalaplugin/src/test/resource/better-files/shapeless/src/test/scala/better/files/ShapelessScannerSpec.scala
new file mode 100644
index 00000000..34557261
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/shapeless/src/test/scala/better/files/ShapelessScannerSpec.scala
@@ -0,0 +1,32 @@
+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/scalaplugin/src/test/resource/better-files/site/index.html b/scalaplugin/src/test/resource/better-files/site/index.html
new file mode 100644
index 00000000..29931115
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/site/index.html
@@ -0,0 +1,16 @@
+<!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/scalaplugin/src/test/resource/better-files/site/tech_talk_preview.png b/scalaplugin/src/test/resource/better-files/site/tech_talk_preview.png
new file mode 100644
index 00000000..9f9f7599
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/site/tech_talk_preview.png
diff --git a/scalaplugin/src/test/resource/better-files/version.sbt b/scalaplugin/src/test/resource/better-files/version.sbt
new file mode 100644
index 00000000..0750fecd
--- /dev/null
+++ b/scalaplugin/src/test/resource/better-files/version.sbt
@@ -0,0 +1 @@
+version in ThisBuild := "3.2.1-SNAPSHOT"
\ No newline at end of file
diff --git a/scalaplugin/src/test/scala/mill/scalaplugin/BetterFilesTests.scala b/scalaplugin/src/test/scala/mill/scalaplugin/BetterFilesTests.scala
new file mode 100644
index 00000000..f2f3a832
--- /dev/null
+++ b/scalaplugin/src/test/scala/mill/scalaplugin/BetterFilesTests.scala
@@ -0,0 +1,115 @@
+package mill.scalaplugin
+
+import ammonite.ops.ImplicitWd._
+import ammonite.ops._
+import mill.define.{Cross,Task}
+import mill.discover.Discovered
+import mill.eval.Result
+import utest._
+import mill.util.JsonFormatters._
+
+object BetterFilesBuild{
+  trait BetterFilesModule extends ScalaModule{ outer =>
+    def scalaVersion = "2.12.4"
+    override def sources = basePath/'src/'main/'scala
+    override def 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.
+    )
+    override def javacOptions = Seq("-source", "1.8", "-target", "1.8", "-Xlint")
+    object test extends this.Tests{
+      override def projectDeps =
+        if (this == Core.test) Seq(Core)
+        else Seq(outer, Core.test)
+      def basePath = outer.basePath
+      override def ivyDeps = Seq(Dep("org.scalatest", "scalatest", "3.0.4"))
+      override def sources = basePath/'src/'test/'scala
+      def testFramework = "org.scalatest.tools.Framework"
+    }
+  }
+  object Core extends BetterFilesModule{
+    def basePath = BetterFilesTests.srcPath/"core"
+  }
+  object Akka extends BetterFilesModule{
+    override def projectDeps = Seq(Core)
+    def basePath = BetterFilesTests.srcPath/"akka"
+    override def ivyDeps = Seq(Dep("com.typesafe.akka", "akka-actor", "2.5.6"))
+  }
+  object ShapelessScanner extends BetterFilesModule{
+    override def projectDeps = Seq(Core)
+    def basePath = BetterFilesTests.srcPath/"shapeless"
+    override def ivyDeps = Seq(Dep("com.chuusai", "shapeless", "2.3.2"))
+  }
+  object Benchmarks extends BetterFilesModule{
+    override def projectDeps = Seq(Core)
+    def basePath = BetterFilesTests.srcPath/"benchmarks"
+    override def ivyDeps = Seq(
+      Dep.Java("commons-io", "commons-io", "2.5")
+      // "fastjavaio" % "fastjavaio" % "1.0" from "https://github.com/williamfiset/FastJavaIO/releases/download/v1.0/fastjavaio.jar"
+    )
+  }
+}
+object BetterFilesTests extends TestSuite{
+  val workspacePath = pwd / 'target / 'workspace / "better-files"
+  val srcPath = pwd / 'scalaplugin / 'src / 'test / 'resource / "better-files"
+  val tests = Tests{
+    rm(workspacePath)
+    mkdir(workspacePath/up)
+    cp(srcPath, workspacePath)
+    val mapping = Discovered.mapping(BetterFilesBuild)
+    def eval[T](t: Task[T]) = TestEvaluator.eval(mapping, workspacePath)(t)
+
+    'test - {
+
+      val Right(_) = eval(BetterFilesBuild.Core.test.test())
+      val Right(_) = eval(BetterFilesBuild.Akka.test.test())
+      val Right(_) = eval(BetterFilesBuild.ShapelessScanner.test.test())
+      // Doesn't work yet, need to support curling down a jar and caching it
+      val Left(_) = eval(BetterFilesBuild.Benchmarks.test.test())
+    }
+
+  }
+}