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>
  ++++
  
  A file collection is iterable, and can be converted to a number of other types using the `as` operator. You can also add 2 file collections together using the `+` operator, or subtract one file collection from another using the `-` operator. Here are some examples of what you can do with a file collection.
  
  ++++
  <sample id="fileCollections" dir="userguide/files/fileCollections" title="Using a file collection">
  
negative.code: </sample>
  ++++
  
  You can see more examples of supported patterns in the API docs for api:org.gradle.api.tasks.util.PatternFilterable[]. Also, see the API documentation for `fileTree()` to see what types you can pass as the base directory.
  
  [NOTE]
  ====
  By default, the `FileTree` instance `fileTree()` returns will apply some Ant-style default exclude patterns for convenience. For the complete default exclusion list, see http://ant.apache.org/manual/dirtasks.html#defaultexcludes[Default Excludes].
  ====
  
  You can do many of the same things with file trees that you can with file collections:
  
   * iterate over them (depth first)
   * filter them (using api:org.gradle.api.file.FileTree#matching(org.gradle.api.Action)[] and Ant-style patterns)
   * merge them
  
  You can also traverse file trees using the api:org.gradle.api.file.FileTree#visit(org.gradle.api.Action)[] method. All of these techniques are demonstrated in the following example: 
  
  ++++
  <sample id="fileTrees" dir="userguide/files/fileTrees" title="Using a file tree">
      <sourcefile file="build.gradle" snippet="use"/>
  </sample>
  ++++
  
  We've discussed how to create your own file trees and file collections, but it's also worth bearing in mind that many Gradle plugins provide their own instances of file trees, such as <<sec:java_source_sets,Java's source sets>>. These can be used and manipulated in exactly the same way as the file trees you create yourself.
  
  Another specific type of file tree that users commonly need is the archive, i.e. ZIP files, TAR files, etc. We look at those next.
  
  [[sec:archive_contents]]
  ==== Using archives as file trees
  
  An archive is a directory and file hierarchy packed into a single file. In other words, it's a special case of a file tree, and that's exactly how Gradle treats archives. Instead of using the `fileTree()` method, which only works on normal file systems, you use the api:org.gradle.api.Project#zipTree[] and api:org.gradle.api.Project#tarTree(java.lang.Object)[] methods to wrap archive files of the corresponding type (note that JAR, WAR and EAR files are ZIPs). Both methods return `FileTree` instances that you can then use in the same way as normal file trees. For example, you can extract some or all of the files of an archive by copying its contents to some directory on the file system. Or you can merge one archive into another.
  
  Here are some simple examples of creating archive-based file trees:
  
  ++++
  <sample id="fileTrees" dir="userguide/files/fileTrees" title="Using an archive as a file tree">
  