anchor.diff:  
   As you can see, you can have multiple `from()` declarations in a copy specification, each with its own configuration.
   
  +[[sec:unpacking_archives_example]]
   === Unpacking archives
   
   Archives are effectively self-contained file systems, so unpacking them is a case of copying the files from that file system into a directory (or even another archive). Gradle enables this by providing some wrapper functions that make archives available as hierarchical collections of files known as file trees (TODO: link to an in-depth discussion of file trees).
  
positive.code: </sample>
  ++++
  
  You can pass any object to the `file()` method, and it will attempt to convert the value to an absolute `File` object. Usually, you would pass it a `String`, `File` or `Path` instance. If this path is an absolute path, it is used to construct a `File` instance. Otherwise, a `File` instance is constructed by prepending the project directory path to the supplied path. The `file()` method also understands URLs, such as `file:/some/path.xml`.
  
  Using this method is a useful way to convert some user provided value into an absolute `File`. It is preferable to using `new File(somePath)`, as `file()` always evaluates the supplied path relative to the project directory, which is fixed, rather than the current working directory, which can change depending on how the user runs Gradle.
  
  [[sec:file_collections]]
  === File collections
  
  A _file collection_ is simply a set of files. It is represented by the api:org.gradle.api.file.FileCollection[] interface. Many objects in the Gradle API implement this interface. For example, <<sub:configurations,dependency configurations>> implement `FileCollection`.
  
  One way to obtain a `FileCollection` instance is to use the api:org.gradle.api.Project#files(java.lang.Object...)[] method. You can pass this method any number of objects, which are then converted into a set of `File` objects. The `files()` method accepts any type of object as its parameters. These are evaluated relative to the project directory, as per the `file()` method, described in <<sec:locating_files>>. You can also pass collections, iterables, maps and arrays to the `files()` method. These are flattened and the contents converted to `File` instances.
  
  ++++
  <sample id="fileCollections" dir="userguide/files/fileCollections" title="Creating a file collection">
  
negative.code: </sample>
  ++++
  
  You can also see at the end of the example _how to combine file collections_ using the `+` and `-` operators to merge and subtract them. An important feature of the resulting file collections is that they are _live_. In other words, when you combine file collections in this way, the result always reflects what's in the original file collections, even if they change during the build.
  
  For example, imagine `collection` in the above example gains an extra file or two after `union` is created. As long as you use `union` after those files are added to `collection`, `union` will also contain those additional files. The same goes for the `different` file collection.
  
  Live collections are also important when it comes to _filtering_. If you want to use a subset of a file collection, you can take advantage of the api:org.gradle.api.file.FileCollection#filter(org.gradle.api.specs.Spec)[] method to determine which files to "keep". In the following example, we create a new collection that consists of only the files that end with .txt in the source collection:
  
  ----
  FileCollection textFiles = collection.filter { File f ->
      f.name.endsWith(".txt")
  }
  ----
  
  If `collection` changes at any time, either by adding or removing files from itself, then `textFiles` will immediately reflect the change because it is also a live collection. Note that the closure you pass to `filter()` takes a `File` as an argument and should return a boolean.
  
  [[sec:file_trees]]
  ==== File trees
  
  A _file tree_ is a file collection that retains the directory structure of the files it contains and has the type api:org.gradle.api.file.FileTree[]. This means that all the paths in a file tree must have a shared parent directory. The following diagram highlights the distinction between file trees and file collections in the common case of copying files:
  
  ++++
  <figure>
      <title>The differences in how file trees and file collections behave when copying files</title>
      <imageobject>
          <imagedata fileref="img/file-collection-vs-file-tree.png" width="160mm"/>
      </imageobject>
  </figure>
  ++++
  
  NOTE: Although `FileTree` extends `FileCollection` (an is-a relationship), their behaviors do differ. In other words, you can use a file tree wherever a file collection is required, but remember: a file collection is a flat list/set of files, while a file tree is a file and directory hierarchy. To convert a file tree to a flat collection, use the api:org.gradle.api.file.FileTree#getFiles()[] property.
  
  The simplest way to create a file tree is to pass a file or directory path to the api:org.gradle.api.Project#fileTree(java.lang.Object)[] method. This will create a tree of all the files and directories in that base directory (but not the base directory itself). The following example demonstrates how to use the basic method and, in addition, how to filter the files and directories using Ant-style patterns:
  
  ++++
  <sample id="fileTrees" dir="userguide/files/fileTrees" title="Creating a file tree">
  