anchor.diff:  
   As with filtering, you can also apply renaming to a subset of files to copy by configuring it on a `from()` instead of at the task level.
   
  +[[sec:deleting_files_example]]
  +=== Deleting files and directories
  +
  +You can easily delete files and directories using either the api:org.gradle.api.tasks.Delete[] task or the api:org.gradle.api.Project#delete(org.gradle.api.Action)[] method. In both cases, you specify which files and directories to delete in a way supported by the api:org.gradle.api.Project#files(java.lang.Object...)[] method.
  +
  +For example, the following task deletes the entire contents of a build's output directory:
  +
  +----
  +task myClean(type: Delete) {
  +    delete buildDir
  +}
  +----
  +
  +If you want more control over which files are deleted, you can't use inclusions and exclusions in the same way as for copying files. Instead, you have to use the builtin filtering mechanisms of `files()` and `fileTree()`. The following example does just that to clear out temporary files from a source directory:
  +
  +----
  +task cleanTempFiles(type: Delete) {
  +    delete fileTree("src").matching {
  +        include "**/*.tmp"
  +    }
  +}
  +----
  +
  +
  +You'll learn more about file collections and file trees in the next section.
  +
   [[sec:locating_files]]
   === File paths in depth
   
  
positive.code: }
  ----
  
  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).
  
  The two functions of interest are api:org.gradle.api.Project#zipTree[] and api:org.gradle.api.Project#tarTree[], which produce a api:org.gradle.api.file.FileTree[] from a corresponding archive file. That file tree can then be used in a `from()` specification, like so:
  
  
negative.code: }
  ----
  
  Although hard-coded paths make for simple examples, they also make the build brittle. It's better to use a reliable, single source of truth, such as a task or shared project property. In the following modified example, we use a report task defined elsewhere that has the report's location stored in its `outputFile` property:
  
  ----
  task copyReport(type: Copy) {
      from myReportTask.outputFile
      into archiveReportsTask.dirToArchive
  }
  ----
  
  We have also assumed that the reports will be archived by `archiveReportsTask`, which provides us with the directory that will be archived and hence where we want to put the copies of the reports.
  
  [[sec:copying_multiple_files_example]]
  === Copying multiple files
  
  You can extend the previous examples to multiple files very easily by providing multiple arguments to `from()`:
  