Members removed from scala.reflect.io.

Mostly hailing from a long-ago day when I imagined I was
writing a general purpose library. We dodged that bullet.

9 files changed, 20 insertions, 189 deletions

diff --git a/src/reflect/scala/reflect/io/AbstractFile.scala b/src/reflect/scala/reflect/io/AbstractFile.scala
index fa7298c726..1a8d1c4f5e 100644
--- a/src/reflect/scala/reflect/io/AbstractFile.scala
+++ b/src/reflect/scala/reflect/io/AbstractFile.scala
@@ -14,9 +14,9 @@ import scala.collection.mutable.ArrayBuffer
 
 /**
  * An abstraction over files for use in the reflection/compiler libraries.
- * 
+ *
  * ''Note:  This library is considered experimental and should not be used unless you know what you are doing.''
- *  
+ *
  * @author Philippe Altherr
  * @version 1.0, 23/03/2004
  */
@@ -79,7 +79,7 @@ object AbstractFile {
  *   all other cases, the class `SourceFile` is used, which honors
  *   `global.settings.encoding.value`.
  * </p>
- * 
+ *
  * ''Note:  This library is considered experimental and should not be used unless you know what you are doing.''
  */
 abstract class AbstractFile extends Iterable[AbstractFile] {
@@ -180,19 +180,6 @@ abstract class AbstractFile extends Iterable[AbstractFile] {
    */
   def lookupNameUnchecked(name: String, directory: Boolean): AbstractFile
 
-  /** Returns the abstract file in this abstract directory with the specified
-   *  path relative to it, If there is no such file, returns null. The argument
-   *  <code>directory</code> tells whether to look for a directory or a regular
-   *  file.
-   *
-   *  @param path      ...
-   *  @param directory ...
-   *  @return          ...
-   */
-  def lookupPath(path: String, directory: Boolean): AbstractFile = {
-    lookup((f, p, dir) => f.lookupName(p, dir), path, directory)
-  }
-
   /** Return an abstract file that does not check that `path` denotes
    *  an existing file.
    */
diff --git a/src/reflect/scala/reflect/io/Directory.scala b/src/reflect/scala/reflect/io/Directory.scala
index c040d1eac5..4bf9ed8a36 100644
--- a/src/reflect/scala/reflect/io/Directory.scala
+++ b/src/reflect/scala/reflect/io/Directory.scala
@@ -14,12 +14,10 @@ import java.io.{ File => JFile }
  * ''Note:  This library is considered experimental and should not be used unless you know what you are doing.''
  */
 object Directory {
-  import scala.util.Properties.{ tmpDir, userHome, userDir }
+  import scala.util.Properties.{ userHome, userDir }
 
   private def normalizePath(s: String) = Some(apply(Path(s).normalize))
   def Current: Option[Directory]  = if (userDir == "") None else normalizePath(userDir)
-  def Home: Option[Directory]     = if (userHome == "") None else normalizePath(userHome)
-  def TmpDir: Option[Directory]   = if (tmpDir == "") None else normalizePath(tmpDir)
 
   def apply(path: Path): Directory = path.toDirectory
 
@@ -30,20 +28,18 @@ object Directory {
     path.createDirectory()
   }
 }
-import Path._
 
 /** An abstraction for directories.
  *
  *  @author  Paul Phillips
  *  @since   2.8
- *  
+ *
  *  ''Note:  This is library is considered experimental and should not be used unless you know what you are doing.''
  */
 class Directory(jfile: JFile) extends Path(jfile) {
   override def toAbsolute: Directory = if (isAbsolute) this else super.toAbsolute.toDirectory
   override def toDirectory: Directory = this
   override def toFile: File = new File(jfile)
-  override def isValid = jfile.isDirectory() || !jfile.exists()
   override def normalize: Directory = super.normalize.toDirectory
 
   /** An iterator over the contents of this directory.
@@ -60,7 +56,6 @@ class Directory(jfile: JFile) extends Path(jfile) {
   override def walkFilter(cond: Path => Boolean): Iterator[Path] =
     list filter cond flatMap (_ walkFilter cond)
 
-  def deepDirs: Iterator[Directory] = Path.onlyDirs(deepList())
   def deepFiles: Iterator[File] = Path.onlyFiles(deepList())
 
   /** If optional depth argument is not given, will recurse
@@ -70,10 +65,4 @@ class Directory(jfile: JFile) extends Path(jfile) {
     if (depth < 0) list ++ (dirs flatMap (_ deepList (depth)))
     else if (depth == 0) Iterator.empty
     else list ++ (dirs flatMap (_ deepList (depth - 1)))
-
-  /** An iterator over the directories underneath this directory,
-   *  to the (optionally) given depth.
-   */
-  def subdirs(depth: Int = 1): Iterator[Directory] =
-    deepList(depth) collect { case x: Directory => x }
 }
diff --git a/src/reflect/scala/reflect/io/File.scala b/src/reflect/scala/reflect/io/File.scala
index 736ba5d51e..c74dc06501 100644
--- a/src/reflect/scala/reflect/io/File.scala
+++ b/src/reflect/scala/reflect/io/File.scala
@@ -22,8 +22,7 @@ import scala.language.{reflectiveCalls, implicitConversions}
  */
 object File {
   def pathSeparator = java.io.File.pathSeparator
-  def separator = java.io.File.separator
-
+  def separator     = java.io.File.separator
   def apply(path: Path)(implicit codec: Codec) = new File(path.jfile)(codec)
 
   // Create a temporary file, which will be deleted upon jvm exit.
@@ -32,41 +31,7 @@ object File {
     jfile.deleteOnExit()
     apply(jfile)
   }
-
-  type HasClose = { def close(): Unit }
-
-  def closeQuietly(target: HasClose) {
-    try target.close() catch { case e: IOException => }
-  }
-  def closeQuietly(target: JCloseable) {
-    try target.close() catch { case e: IOException => }
-  }
-
-  // this is a workaround for http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6503430
-  // we are using a static initializer to statically initialize a java class so we don't
-  // trigger java.lang.InternalErrors later when using it concurrently.  We ignore all
-  // the exceptions so as not to cause spurious failures when no write access is available,
-  // e.g. google app engine.
-  //
-  // XXX need to put this behind a setting.
-  //
-  // try {
-  //   import Streamable.closing
-  //   val tmp = java.io.File.createTempFile("bug6503430", null, null)
-  //   try closing(new FileInputStream(tmp)) { in =>
-  //     val inc = in.getChannel()
-  //     closing(new FileOutputStream(tmp, true)) { out =>
-  //       out.getChannel().transferFrom(inc, 0, 0)
-  //     }
-  //   }
-  //   finally tmp.delete()
-  // }
-  // catch {
-  //   case _: IllegalArgumentException | _: IllegalStateException | _: IOException | _: SecurityException => ()
-  // }
 }
-import File._
-import Path._
 
 /** An abstraction for files.  For character data, a Codec
  *  can be supplied at either creation time or when a method
@@ -76,19 +41,17 @@ import Path._
  *
  *  @author  Paul Phillips
  *  @since   2.8
- *  
+ *
  *  ''Note:  This is library is considered experimental and should not be used unless you know what you are doing.''
  */
 class File(jfile: JFile)(implicit constructorCodec: Codec) extends Path(jfile) with Streamable.Chars {
   override val creationCodec = constructorCodec
-  def withCodec(codec: Codec): File = new File(jfile)(codec)
 
   override def addExtension(ext: String): File = super.addExtension(ext).toFile
   override def toAbsolute: File = if (isAbsolute) this else super.toAbsolute.toFile
   override def toDirectory: Directory = new Directory(jfile)
   override def toFile: File = this
   override def normalize: File = super.normalize.toFile
-  override def isValid = jfile.isFile() || !jfile.exists()
   override def length = super[Path].length
   override def walkFilter(cond: Path => Boolean): Iterator[Path] =
     if (cond(this)) Iterator.single(this) else Iterator.empty
@@ -99,14 +62,11 @@ class File(jfile: JFile)(implicit constructorCodec: Codec) extends Path(jfile) w
   /** Obtains a OutputStream. */
   def outputStream(append: Boolean = false) = new FileOutputStream(jfile, append)
   def bufferedOutput(append: Boolean = false) = new BufferedOutputStream(outputStream(append))
-  def printStream(append: Boolean = false) = new PrintStream(outputStream(append), true)
 
   /** Obtains an OutputStreamWriter wrapped around a FileOutputStream.
    *  This should behave like a less broken version of java.io.FileWriter,
    *  in that unlike the java version you can specify the encoding.
    */
-  def writer(): OutputStreamWriter = writer(false)
-  def writer(append: Boolean): OutputStreamWriter = writer(append, creationCodec)
   def writer(append: Boolean, codec: Codec): OutputStreamWriter =
     new OutputStreamWriter(outputStream(append), codec.charSet)
 
@@ -118,7 +78,6 @@ class File(jfile: JFile)(implicit constructorCodec: Codec) extends Path(jfile) w
     new BufferedWriter(writer(append, codec))
 
   def printWriter(): PrintWriter = new PrintWriter(bufferedWriter(), true)
-  def printWriter(append: Boolean): PrintWriter = new PrintWriter(bufferedWriter(append), true)
 
   /** Creates a new file and writes all the Strings to it. */
   def writeAll(strings: String*): Unit = {
@@ -127,12 +86,6 @@ class File(jfile: JFile)(implicit constructorCodec: Codec) extends Path(jfile) w
     finally out.close()
   }
 
-  def writeBytes(bytes: Array[Byte]): Unit = {
-    val out = bufferedOutput()
-    try out write bytes
-    finally out.close()
-  }
-
   def appendAll(strings: String*): Unit = {
     val out = bufferedWriter(append = true)
     try strings foreach (out write _)
@@ -150,39 +103,6 @@ class File(jfile: JFile)(implicit constructorCodec: Codec) extends Path(jfile) w
     try Some(slurp())
     catch { case _: IOException => None }
 
-  def copyTo(destPath: Path, preserveFileDate: Boolean = false): Boolean = {
-    val CHUNK = 1024 * 1024 * 16  // 16 MB
-    val dest = destPath.toFile
-    if (!isValid) fail("Source %s is not a valid file." format name)
-    if (this.normalize == dest.normalize) fail("Source and destination are the same.")
-    if (!dest.parent.exists) fail("Destination cannot be created.")
-    if (dest.exists && !dest.canWrite) fail("Destination exists but is not writable.")
-    if (dest.isDirectory) fail("Destination exists but is a directory.")
-
-    lazy val in_s = inputStream()
-    lazy val out_s = dest.outputStream()
-    lazy val in = in_s.getChannel()
-    lazy val out = out_s.getChannel()
-
-    try {
-      val size = in.size()
-      var pos, count = 0L
-      while (pos < size) {
-        count = (size - pos) min CHUNK
-        pos += out.transferFrom(in, pos, count)
-      }
-    }
-    finally List[HasClose](out, out_s, in, in_s) foreach closeQuietly
-
-    if (this.length != dest.length)
-      fail("Failed to completely copy %s to %s".format(name, dest.name))
-
-    if (preserveFileDate)
-      dest.lastModified = this.lastModified
-
-    true
-  }
-
   /** Reflection since we're into the java 6+ API.
    */
   def setExecutable(executable: Boolean, ownerOnly: Boolean = true): Boolean = {
diff --git a/src/reflect/scala/reflect/io/Path.scala b/src/reflect/scala/reflect/io/Path.scala
index 36fdc04db4..3b5d3079cd 100644
--- a/src/reflect/scala/reflect/io/Path.scala
+++ b/src/reflect/scala/reflect/io/Path.scala
@@ -27,7 +27,7 @@ import scala.language.implicitConversions
  *
  *  @author  Paul Phillips
  *  @since   2.8
- *  
+ *
  *  ''Note:  This library is considered experimental and should not be used unless you know what you are doing.''
  */
 object Path {
@@ -49,27 +49,12 @@ object Path {
   implicit def string2path(s: String): Path = apply(s)
   implicit def jfile2path(jfile: JFile): Path = apply(jfile)
 
-  // java 7 style, we don't use it yet
-  // object AccessMode extends Enumeration {
-  //   val EXECUTE, READ, WRITE = Value
-  // }
-  // def checkAccess(modes: AccessMode*): Boolean = {
-  //   modes foreach {
-  //     case EXECUTE  => throw new Exception("Unsupported") // can't check in java 5
-  //     case READ     => if (!jfile.canRead()) return false
-  //     case WRITE    => if (!jfile.canWrite()) return false
-  //   }
-  //   true
-  // }
-
   def onlyDirs(xs: Iterator[Path]): Iterator[Directory] = xs filter (_.isDirectory) map (_.toDirectory)
   def onlyDirs(xs: List[Path]): List[Directory] = xs filter (_.isDirectory) map (_.toDirectory)
   def onlyFiles(xs: Iterator[Path]): Iterator[File] = xs filter (_.isFile) map (_.toFile)
-  def onlyFiles(xs: List[Path]): List[File] = xs filter (_.isFile) map (_.toFile)
 
   def roots: List[Path] = java.io.File.listRoots().toList map Path.apply
 
-  def apply(segments: Seq[String]): Path = apply(segments mkString java.io.File.separator)
   def apply(path: String): Path = apply(new JFile(path))
   def apply(jfile: JFile): Path =
     if (jfile.isFile) new File(jfile)
@@ -84,19 +69,13 @@ import Path._
 
 /** The Path constructor is private so we can enforce some
  *  semantics regarding how a Path might relate to the world.
- *  
+ *
  *  ''Note:  This library is considered experimental and should not be used unless you know what you are doing.''
  */
 class Path private[io] (val jfile: JFile) {
   val separator = java.io.File.separatorChar
   val separatorStr = java.io.File.separator
 
-  // Validation: this verifies that the type of this object and the
-  // contents of the filesystem are in agreement.  All objects are
-  // valid except File objects whose path points to a directory and
-  // Directory objects whose path points to a file.
-  def isValid: Boolean = true
-
   // conversions
   def toFile: File = new File(jfile)
   def toDirectory: Directory = new Directory(jfile)
@@ -104,6 +83,7 @@ class Path private[io] (val jfile: JFile) {
   def toCanonical: Path = Path(jfile.getCanonicalPath())
   def toURI: URI = jfile.toURI()
   def toURL: URL = toURI.toURL()
+
   /** If this path is absolute, returns it: otherwise, returns an absolute
    *  path made up of root / this.
    */
@@ -136,7 +116,6 @@ class Path private[io] (val jfile: JFile) {
   def name: String = jfile.getName()
   def path: String = jfile.getPath()
   def normalize: Path = Path(jfile.getAbsolutePath())
-  def isRootPath: Boolean = roots exists (_ isSame this)
 
   def resolve(other: Path) = if (other.isAbsolute || isEmpty) other else /(other)
   def relativize(other: Path) = {
@@ -152,9 +131,8 @@ class Path private[io] (val jfile: JFile) {
     Path(createRelativePath(segments, other.segments))
   }
 
-  // derived from identity
-  def root: Option[Path] = roots find (this startsWith _)
   def segments: List[String] = (path split separator).toList filterNot (_.length == 0)
+
   /**
    * @return The path of the parent directory, or root if path is already root
    */
@@ -185,10 +163,6 @@ class Path private[io] (val jfile: JFile) {
     if (i < 0) ""
     else name.substring(i + 1)
   }
-  // def extension: String = (name lastIndexOf '.') match {
-  //   case -1   => ""
-  //   case idx  => name drop (idx + 1)
-  // }
   // compares against extensions in a CASE INSENSITIVE way.
   def hasExtension(ext: String, exts: String*) = {
     val lower = extension.toLowerCase
@@ -213,22 +187,18 @@ class Path private[io] (val jfile: JFile) {
   def canRead = jfile.canRead()
   def canWrite = jfile.canWrite()
   def exists = jfile.exists()
-  def notExists = try !jfile.exists() catch { case ex: SecurityException => false }
 
   def isFile = jfile.isFile()
   def isDirectory = jfile.isDirectory()
   def isAbsolute = jfile.isAbsolute()
-  def isHidden = jfile.isHidden()
   def isEmpty = path.length == 0
 
   // Information
   def lastModified = jfile.lastModified()
-  def lastModified_=(time: Long) = jfile setLastModified time // should use setXXX function?
   def length = jfile.length()
 
   // Boolean path comparisons
   def endsWith(other: Path) = segments endsWith other.segments
-  def startsWith(other: Path) = segments startsWith other.segments
   def isSame(other: Path) = toCanonical == other.toCanonical
   def isFresher(other: Path) = lastModified > other.lastModified
 
@@ -248,7 +218,6 @@ class Path private[io] (val jfile: JFile) {
 
   // deletions
   def delete() = jfile.delete()
-  def deleteIfExists() = if (jfile.exists()) delete() else false
 
   /** Deletes the path recursively. Returns false on failure.
    *  Use with caution!
@@ -270,16 +239,6 @@ class Path private[io] (val jfile: JFile) {
       length == 0
     }
 
-  def touch(modTime: Long = System.currentTimeMillis) = {
-    createFile()
-    if (isFile)
-      lastModified = modTime
-  }
-
-  // todo
-  // def copyTo(target: Path, options ...): Boolean
-  // def moveTo(target: Path, options ...): Boolean
-
   override def toString() = path
   override def equals(other: Any) = other match {
     case x: Path  => path == x.path
diff --git a/src/reflect/scala/reflect/io/PlainFile.scala b/src/reflect/scala/reflect/io/PlainFile.scala
index 82b0568657..0d4d55bdec 100644
--- a/src/reflect/scala/reflect/io/PlainFile.scala
+++ b/src/reflect/scala/reflect/io/PlainFile.scala
@@ -3,23 +3,11 @@
  * @author  Martin Odersky
  */
 
-
 package scala.reflect
 package io
 
 import java.io.{ FileInputStream, FileOutputStream, IOException }
-import PartialFunction._
-/** ''Note:  This library is considered experimental and should not be used unless you know what you are doing.'' */
-object PlainFile {
-  /**
-   * If the specified File exists, returns an abstract file backed
-   * by it. Otherwise, returns null.
-   */
-  def fromPath(file: Path): PlainFile =
-    if (file.isDirectory) new PlainDirectory(file.toDirectory)
-    else if (file.isFile) new PlainFile(file)
-    else null
-}
+
 /** ''Note:  This library is considered experimental and should not be used unless you know what you are doing.'' */
 class PlainDirectory(givenPath: Directory) extends PlainFile(givenPath) {
   override def isDirectory = true
@@ -28,7 +16,7 @@ class PlainDirectory(givenPath: Directory) extends PlainFile(givenPath) {
 }
 
 /** This class implements an abstract file backed by a File.
- * 
+ *
  * ''Note:  This library is considered experimental and should not be used unless you know what you are doing.''
  */
 class PlainFile(val givenPath: Path) extends AbstractFile {
@@ -77,10 +65,6 @@ class PlainFile(val givenPath: Path) extends AbstractFile {
    * specified name. If there is no such file, returns null. The
    * argument "directory" tells whether to look for a directory or
    * or a regular file.
-   *
-   * @param name      ...
-   * @param directory ...
-   * @return          ...
    */
   def lookupName(name: String, directory: Boolean): AbstractFile = {
     val child = givenPath / name
diff --git a/src/reflect/scala/reflect/io/Streamable.scala b/src/reflect/scala/reflect/io/Streamable.scala
index 61ec8a4c23..b45cffb150 100644
--- a/src/reflect/scala/reflect/io/Streamable.scala
+++ b/src/reflect/scala/reflect/io/Streamable.scala
@@ -17,14 +17,14 @@ import Path.fail
  *
  *  @author Paul Phillips
  *  @since  2.8
- *  
+ *
  *  ''Note:  This library is considered experimental and should not be used unless you know what you are doing.''
  */
 object Streamable {
   /** Traits which can be viewed as a sequence of bytes.  Source types
    *  which know their length should override def length: Long for more
    *  efficient method implementations.
-   *  
+   *
    *  ''Note:  This library is considered experimental and should not be used unless you know what you are doing.''
    */
   trait Bytes {
@@ -69,7 +69,7 @@ object Streamable {
   }
 
   /** For objects which can be viewed as Chars.
-   * 
+   *
    * ''Note:  This library is considered experimental and should not be used unless you know what you are doing.''
    */
   trait Chars extends Bytes {
@@ -81,7 +81,6 @@ object Streamable {
      */
     def creationCodec: Codec = implicitly[Codec]
 
-    def chars(): BufferedSource = chars(creationCodec)
     def chars(codec: Codec): BufferedSource = Source.fromInputStream(inputStream())(codec)
 
     def lines(): Iterator[String] = lines(creationCodec)
@@ -89,7 +88,6 @@ object Streamable {
 
     /** Obtains an InputStreamReader wrapped around a FileInputStream.
      */
-    def reader(): InputStreamReader = reader(creationCodec)
     def reader(codec: Codec): InputStreamReader = new InputStreamReader(inputStream, codec.charSet)
 
     /** Wraps a BufferedReader around the result of reader().
diff --git a/src/reflect/scala/reflect/io/VirtualDirectory.scala b/src/reflect/scala/reflect/io/VirtualDirectory.scala
index 78713c2ae0..94cb52e9b5 100644
--- a/src/reflect/scala/reflect/io/VirtualDirectory.scala
+++ b/src/reflect/scala/reflect/io/VirtualDirectory.scala
@@ -11,7 +11,7 @@ import scala.collection.mutable
  * An in-memory directory.
  *
  * @author Lex Spoon
- * 
+ *
  * ''Note:  This library is considered experimental and should not be used unless you know what you are doing.''
  */
 class VirtualDirectory(val name: String, maybeContainer: Option[VirtualDirectory])
@@ -26,7 +26,7 @@ extends AbstractFile {
 
   def container = maybeContainer.get
   def isDirectory = true
-  var lastModified: Long = System.currentTimeMillis
+  val lastModified: Long = System.currentTimeMillis
 
   override def file = null
   override def input = sys.error("directories cannot be read")
diff --git a/src/reflect/scala/reflect/io/VirtualFile.scala b/src/reflect/scala/reflect/io/VirtualFile.scala
index eea81da290..09b977bd45 100644
--- a/src/reflect/scala/reflect/io/VirtualFile.scala
+++ b/src/reflect/scala/reflect/io/VirtualFile.scala
@@ -13,7 +13,7 @@ import java.io.{ File => JFile }
  *
  *  @author  Philippe Altherr
  *  @version 1.0, 23/03/2004
- *  
+ *
  *  ''Note:  This library is considered experimental and should not be used unless you know what you are doing.''
  */
 class VirtualFile(val name: String, override val path: String) extends AbstractFile {
@@ -60,7 +60,6 @@ class VirtualFile(val name: String, override val path: String) extends AbstractF
   /** Returns the time that this abstract file was last modified. */
   private var _lastModified: Long = 0
   def lastModified: Long = _lastModified
-  def lastModified_=(x: Long) = _lastModified = x
 
   /** Returns all abstract subfiles of this abstract directory. */
   def iterator: Iterator[AbstractFile] = {
diff --git a/src/reflect/scala/reflect/io/ZipArchive.scala b/src/reflect/scala/reflect/io/ZipArchive.scala
index 3b57721e89..097d3cb71c 100644
--- a/src/reflect/scala/reflect/io/ZipArchive.scala
+++ b/src/reflect/scala/reflect/io/ZipArchive.scala
@@ -20,13 +20,10 @@ import scala.annotation.tailrec
  *  @author  Philippe Altherr (original version)
  *  @author  Paul Phillips (this one)
  *  @version 2.0,
- *  
+ *
  *  ''Note:  This library is considered experimental and should not be used unless you know what you are doing.''
  */
 object ZipArchive {
-  def fromPath(path: String): FileZipArchive = fromFile(new JFile(path))
-  def fromPath(path: Path): FileZipArchive = fromFile(path.toFile)
-
   /**
    * @param   file  a File
    * @return  A ZipArchive if `file` is a readable zip file, otherwise null.
@@ -41,7 +38,6 @@ object ZipArchive {
    * @return  A ZipArchive backed by the given url.
    */
   def fromURL(url: URL): URLZipArchive = new URLZipArchive(url)
-  def fromURL(url: String): URLZipArchive = fromURL(new URL(url))
 
   private def dirName(path: String)  = splitPath(path, true)
   private def baseName(path: String) = splitPath(path, false)
@@ -79,7 +75,6 @@ abstract class ZipArchive(override val file: JFile) extends AbstractFile with Eq
       else Iterator(f)
     }
   }
-  def deepIterator = walkIterator(iterator)
   /** ''Note:  This library is considered experimental and should not be used unless you know what you are doing.'' */
   sealed abstract class Entry(path: String) extends VirtualFile(baseName(path), path) {
     // have to keep this name for compat with sbt's compiler-interface