Create base classpath factory and an implementation for the flat cp

The part of the functionality of a ClassPathContext has been moved
to the base trait ClassPathFactory so it can be reused by the newly
created FlatClassPathFactory. This new implementation works in
similar manner as the ClassPathContext with this difference that it
just creates instances of flat classpath.

This change doesn't modify the behaviour of the compiler as the
interface and the way ClassPathContext works didn't change. Moreover
FlatClassPathFactory is currently unused.

3 files changed, 96 insertions, 0 deletions

diff --git a/src/compiler/scala/tools/nsc/classpath/ClassPathFactory.scala b/src/compiler/scala/tools/nsc/classpath/ClassPathFactory.scala
new file mode 100644
index 0000000000..9bf4e3f779
--- /dev/null
+++ b/src/compiler/scala/tools/nsc/classpath/ClassPathFactory.scala
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2014 Contributor. All rights reserved.
+ */
+package scala.tools.nsc.classpath
+
+import scala.reflect.io.AbstractFile
+import scala.tools.nsc.util.ClassPath
+
+/**
+ * A trait that contains factory methods for classpath elements of type T.
+ *
+ * The logic has been abstracted from ClassPath#ClassPathContext so it's possible
+ * to have common trait that supports both recursive and flat classpath representations.
+ *
+ * Therefore, we expect that T will be either ClassPath[U] or FlatClassPath.
+ */
+trait ClassPathFactory[T] {
+
+  /**
+   * Create a new classpath based on the abstract file.
+   */
+  def newClassPath(file: AbstractFile): T
+
+  /**
+   * Creators for sub classpaths which preserve this context.
+   */
+  def sourcesInPath(path: String): List[T]
+
+  def expandPath(path: String, expandStar: Boolean = true): List[String] = ClassPath.expandPath(path, expandStar)
+
+  def expandDir(extdir: String): List[String] = ClassPath.expandDir(extdir)
+
+  def contentsOfDirsInPath(path: String): List[T] =
+    for {
+      dir <- expandPath(path, expandStar = false)
+      name <- expandDir(dir)
+      entry <- Option(AbstractFile.getDirectory(name))
+    } yield newClassPath(entry)
+
+  def classesInExpandedPath(path: String): IndexedSeq[T] =
+    classesInPathImpl(path, expand = true).toIndexedSeq
+
+  def classesInPath(path: String) = classesInPathImpl(path, expand = false)
+
+  def classesInManifest(useManifestClassPath: Boolean) =
+    if (useManifestClassPath) ClassPath.manifests.map(url => newClassPath(AbstractFile getResources url))
+    else Nil
+
+  // Internal
+  protected def classesInPathImpl(path: String, expand: Boolean) =
+    for {
+      file <- expandPath(path, expand)
+      dir <- Option(AbstractFile.getDirectory(file))
+    } yield newClassPath(dir)
+}
diff --git a/src/compiler/scala/tools/nsc/classpath/FileUtils.scala b/src/compiler/scala/tools/nsc/classpath/FileUtils.scala
index cce16957f1..ee2528e15c 100644
--- a/src/compiler/scala/tools/nsc/classpath/FileUtils.scala
+++ b/src/compiler/scala/tools/nsc/classpath/FileUtils.scala
@@ -19,6 +19,9 @@ object FileUtils {
 
     def isScalaOrJavaSource: Boolean = !file.isDirectory && (file.hasExtension("scala") || file.hasExtension("java"))
 
+    // TODO do we need to check also other files using ZipMagicNumber like in scala.tools.nsc.io.Jar.isJarOrZip?
+    def isJarOrZip: Boolean = file.hasExtension("jar") || file.hasExtension("zip")
+
     /**
      * Safe method returning a sequence containing one URL representing this file, when underlying file exists,
      * and returning given default value in other case
diff --git a/src/compiler/scala/tools/nsc/classpath/FlatClassPathFactory.scala b/src/compiler/scala/tools/nsc/classpath/FlatClassPathFactory.scala
new file mode 100644
index 0000000000..7f67381d4d
--- /dev/null
+++ b/src/compiler/scala/tools/nsc/classpath/FlatClassPathFactory.scala
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2014 Contributor. All rights reserved.
+ */
+package scala.tools.nsc.classpath
+
+import scala.tools.nsc.Settings
+import scala.tools.nsc.io.AbstractFile
+import scala.tools.nsc.util.ClassPath
+import FileUtils.AbstractFileOps
+
+/**
+ * Provides factory methods for flat classpath. When creating classpath instances for a given path,
+ * it uses proper type of classpath depending on a types of particular files containing sources or classes.
+ */
+class FlatClassPathFactory(settings: Settings) extends ClassPathFactory[FlatClassPath] {
+
+  override def newClassPath(file: AbstractFile): FlatClassPath =
+    if (file.isJarOrZip)
+      ZipAndJarFlatClassPathFactory.create(file, settings)
+    else if (file.isDirectory)
+      new DirectoryFlatClassPath(file.file)
+    else
+      sys.error(s"Unsupported classpath element: $file")
+
+  override def sourcesInPath(path: String): List[FlatClassPath] =
+    for {
+      file <- expandPath(path, expandStar = false)
+      dir <- Option(AbstractFile getDirectory file)
+    } yield createSourcePath(dir)
+
+  private def createSourcePath(file: AbstractFile): FlatClassPath =
+    if (file.isJarOrZip)
+      ZipAndJarFlatSourcePathFactory.create(file, settings)
+    else if (file.isDirectory)
+      new DirectoryFlatSourcePath(file.file)
+    else
+      sys.error(s"Unsupported sourcepath element: $file")
+}