clerezza-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From r...@apache.org
Subject [49/51] [partial] clerezza git commit: CLEREZZA-1012: reduced clerezza to core components, the rest stays in legacy-branch
Date Mon, 03 Oct 2016 15:50:15 GMT
http://git-wip-us.apache.org/repos/asf/clerezza/blob/14575ea3/bundledevtool/src/main/scala/sbt/io/IO.scala
----------------------------------------------------------------------
diff --git a/bundledevtool/src/main/scala/sbt/io/IO.scala b/bundledevtool/src/main/scala/sbt/io/IO.scala
deleted file mode 100644
index f4d8d73..0000000
--- a/bundledevtool/src/main/scala/sbt/io/IO.scala
+++ /dev/null
@@ -1,612 +0,0 @@
-/*
- *
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- *
-*/
-
-/* sbt -- Simple Build Tool
- * Copyright 2008, 2009, 2010 Mark Harrah, Viktor Klang, Ross McDonald
- */
-package sbt
-
-import Using._
-import ErrorHandling.translate
-
-import java.io.{BufferedReader, ByteArrayOutputStream, BufferedWriter, File, FileInputStream, InputStream, OutputStream}
-import java.net.{URI, URISyntaxException, URL}
-import java.nio.charset.Charset
-import java.util.Properties
-import java.util.jar.{Attributes, JarEntry, JarFile, JarInputStream, JarOutputStream, Manifest}
-import java.util.zip.{CRC32, GZIPOutputStream, ZipEntry, ZipFile, ZipInputStream, ZipOutputStream}
-import scala.collection.immutable.TreeSet
-import scala.collection.mutable.{HashMap,HashSet}
-import scala.reflect.{Manifest => SManifest}
-import Function.tupled
-
-object IO
-{
-  /** The maximum number of times a unique temporary filename is attempted to be created.*/
-  private val MaximumTries = 10
-  /** The producer of randomness for unique name generation.*/
-  private lazy val random = new java.util.Random
-  val temporaryDirectory = new File(System.getProperty("java.io.tmpdir"))
-  /** The size of the byte or char buffer used in various methods.*/
-  private val BufferSize = 8192
-  val Newline = System.getProperty("line.separator")
-
-  val utf8 = Charset.forName("UTF-8")
-
-  def classLocation(cl: Class[_]): URL =
-  {
-    val codeSource = cl.getProtectionDomain.getCodeSource
-    if(codeSource == null) error("No class location for " + cl)
-    else codeSource.getLocation
-  }
-  def classLocationFile(cl: Class[_]): File = toFile(classLocation(cl))
-  def classLocation[T](implicit mf: SManifest[T]): URL = classLocation(mf.erasure)
-  def classLocationFile[T](implicit mf: SManifest[T]): File = classLocationFile(mf.erasure)
-
-  def toFile(url: URL) =
-    try { new File(url.toURI) }
-    catch { case _: URISyntaxException => new File(url.getPath) }
-
-  /** Converts the given URL to a File.  If the URL is for an entry in a jar, the File for the jar is returned. */
-  def asFile(url: URL): File =
-  {
-    url.getProtocol match
-    {
-      case "file" => toFile(url)
-      case "jar" =>
-        val path = url.getPath
-        val end = path.indexOf('!')
-        new File(new URI(if(end == -1) path else path.substring(0, end)))
-      case _ => error("Invalid protocol " + url.getProtocol)
-    }
-  }
-  def assertDirectory(file: File) { assert(file.isDirectory, (if(file.exists) "Not a directory: " else "Directory not found: ") + file) }
-  def assertDirectories(file: File*) { file.foreach(assertDirectory) }
-
-  // "base.extension" -> (base, extension)
-  def split(name: String): (String, String) =
-  {
-    val lastDot = name.lastIndexOf('.')
-    if(lastDot >= 0)
-      (name.substring(0, lastDot), name.substring(lastDot+1))
-    else
-      (name, "")
-  }
-
-  def touch(files: Traversable[File]): Unit = files.foreach(touch)
-  /** Creates a file at the given location.*/
-  def touch(file: File)
-  {
-    createDirectory(file.getParentFile)
-    val created = translate("Could not create file " + file) { file.createNewFile() }
-    if(created || file.isDirectory)
-      ()
-    else if(!file.setLastModified(System.currentTimeMillis))
-      error("Could not update last modified time for file " + file)
-  }
-  def createDirectories(dirs: Traversable[File]): Unit =
-    dirs.foreach(createDirectory)
-  def createDirectory(dir: File): Unit =
-  {
-    def failBase = "Could not create directory " + dir
-    if(dir.isDirectory || dir.mkdirs())
-      ()
-    else if(dir.exists)
-      error(failBase + ": file exists and is not a directory.")
-    else
-      error(failBase)
-  }
-
-  /** Gzips the file 'in' and writes it to 'out'.  'in' cannot be the same file as 'out'. */
-  def gzip(in: File, out: File)
-  {
-    require(in != out, "Input file cannot be the same as the output file.")
-    Using.fileInputStream(in) { inputStream =>
-      Using.fileOutputStream()(out) { outputStream =>
-        gzip(inputStream, outputStream)
-      }
-    }
-  }
-  /** Gzips the InputStream 'in' and writes it to 'output'.  Neither stream is closed.*/
-  def gzip(input: InputStream, output: OutputStream): Unit =
-    gzipOutputStream(output) { gzStream => transfer(input, gzStream) }
-
-  /** Gunzips the file 'in' and writes it to 'out'.  'in' cannot be the same file as 'out'. */
-  def gunzip(in: File, out: File)
-  {
-    require(in != out, "Input file cannot be the same as the output file.")
-    Using.fileInputStream(in) { inputStream =>
-      Using.fileOutputStream()(out) { outputStream =>
-        gunzip(inputStream, outputStream)
-      }
-    }
-  }
-  /** Gunzips the InputStream 'input' and writes it to 'output'.  Neither stream is closed.*/
-  def gunzip(input: InputStream, output: OutputStream): Unit =
-    gzipInputStream(input) { gzStream => transfer(gzStream, output) }
-
-  def unzip(from: File, toDirectory: File, filter: NameFilter = AllPassFilter): Set[File] = fileInputStream(from)(in => unzipStream(in, toDirectory, filter))
-  def unzipURL(from: URL, toDirectory: File, filter: NameFilter = AllPassFilter): Set[File] = urlInputStream(from)(in => unzipStream(in, toDirectory, filter))
-  def unzipStream(from: InputStream, toDirectory: File, filter: NameFilter = AllPassFilter): Set[File] =
-  {
-    createDirectory(toDirectory)
-    zipInputStream(from) { zipInput => extract(zipInput, toDirectory, filter) }
-  }
-  private def extract(from: ZipInputStream, toDirectory: File, filter: NameFilter) =
-  {
-    val set = new HashSet[File]
-    def next()
-    {
-      val entry = from.getNextEntry
-      if(entry == null)
-        ()
-      else
-      {
-        val name = entry.getName
-        if(filter.accept(name))
-        {
-          val target = new File(toDirectory, name)
-          //log.debug("Extracting zip entry '" + name + "' to '" + target + "'")
-          if(entry.isDirectory)
-            createDirectory(target)
-          else
-          {
-            set += target
-            translate("Error extracting zip entry '" + name + "' to '" + target + "': ") {
-              fileOutputStream(false)(target) { out => transfer(from, out) }
-            }
-          }
-          //target.setLastModified(entry.getTime)
-        }
-        else
-        {
-          //log.debug("Ignoring zip entry '" + name + "'")
-        }
-        from.closeEntry()
-        next()
-      }
-    }
-    next()
-    Set() ++ set
-  }
-
-  /** Retrieves the content of the given URL and writes it to the given File. */
-  def download(url: URL, to: File) =
-    Using.urlInputStream(url) { inputStream =>
-      transfer(inputStream, to)
-    }
-
-  def transfer(in: File, out: File): Unit =
-    fileInputStream(in){ in => transfer(in, out) }
-
-  def transfer(in: File, out: OutputStream): Unit =
-    fileInputStream(in){ in => transfer(in, out) }
-
-  /** Copies all bytes from the given input stream to the given File.*/
-  def transfer(in: InputStream, to: File): Unit =
-    Using.fileOutputStream()(to) { outputStream =>
-      transfer(in, outputStream)
-    }
-
-  /** Copies all bytes from the given input stream to the given output stream.
-  * Neither stream is closed.*/
-  def transfer(in: InputStream, out: OutputStream): Unit = transferImpl(in, out, false)
-  /** Copies all bytes from the given input stream to the given output stream.  The
-  * input stream is closed after the method completes.*/
-  def transferAndClose(in: InputStream, out: OutputStream): Unit = transferImpl(in, out, true)
-  private def transferImpl(in: InputStream, out: OutputStream, close: Boolean)
-  {
-    try
-    {
-      val buffer = new Array[Byte](BufferSize)
-      def read()
-      {
-        val byteCount = in.read(buffer)
-        if(byteCount >= 0)
-        {
-          out.write(buffer, 0, byteCount)
-          read()
-        }
-      }
-      read()
-    }
-    finally { if(close) in.close }
-  }
-
-  /** Creates a temporary directory and provides its location to the given function.  The directory
-  * is deleted after the function returns.*/
-  def withTemporaryDirectory[T](action: File => T): T =
-  {
-    val dir = createTemporaryDirectory
-    try { action(dir) }
-    finally { delete(dir) }
-  }
-  def createTemporaryDirectory: File =
-  {
-    def create(tries: Int): File =
-    {
-      if(tries > MaximumTries)
-        error("Could not create temporary directory.")
-      else
-      {
-        val randomName = "sbt_" + java.lang.Integer.toHexString(random.nextInt)
-        val f = new File(temporaryDirectory, randomName)
-
-        try { createDirectory(f); f }
-        catch { case e: Exception => create(tries + 1) }
-      }
-    }
-    create(0)
-  }
-  def withTemporaryFile[T](prefix: String, postfix: String)(action: File => T): T =
-  {
-    val file = File.createTempFile(prefix, postfix)
-    try { action(file) }
-    finally { file.delete() }
-  }
-
-  private[sbt] def jars(dir: File): Iterable[File] = listFiles(dir, GlobFilter("*.jar"))
-
-  def deleteIfEmpty(dirs: collection.Set[File]): Unit =
-  {
-    val isEmpty = new HashMap[File, Boolean]
-    def visit(f: File): Boolean = isEmpty.getOrElseUpdate(f, dirs(f) && f.isDirectory && (f.listFiles forall visit) )
-
-    dirs foreach visit
-    for( (f, true) <- isEmpty) f.delete
-  }
-
-  def delete(files: Iterable[File]): Unit = files.foreach(delete)
-  def delete(file: File)
-  {
-    translate("Error deleting file " + file + ": ")
-    {
-      if(file.isDirectory)
-      {
-        delete(listFiles(file))
-        file.delete
-      }
-      else if(file.exists)
-        file.delete
-    }
-  }
-  def listFiles(filter: java.io.FileFilter)(dir: File): Array[File] = wrapNull(dir.listFiles(filter))
-  def listFiles(dir: File, filter: java.io.FileFilter): Array[File] = wrapNull(dir.listFiles(filter))
-  def listFiles(dir: File): Array[File] = wrapNull(dir.listFiles())
-  private[sbt] def wrapNull(a: Array[File]) =
-  {
-    if(a == null)
-      new Array[File](0)
-    else
-      a
-  }
-
-
-  /** Creates a jar file.
-  * @param sources The files to include in the jar file paired with the entry name in the jar.
-  * @param outputJar The file to write the jar to.
-  * @param manifest The manifest for the jar.*/
-  def jar(sources: Traversable[(File,String)], outputJar: File, manifest: Manifest): Unit =
-    archive(sources.toSeq, outputJar, Some(manifest))
-  /** Creates a zip file.
-  * @param sources The files to include in the zip file paired with the entry name in the zip.
-  * @param outputZip The file to write the zip to.*/
-  def zip(sources: Traversable[(File,String)], outputZip: File): Unit =
-    archive(sources.toSeq, outputZip, None)
-
-  private def archive(sources: Seq[(File,String)], outputFile: File, manifest: Option[Manifest])
-  {
-    if(outputFile.isDirectory)
-      error("Specified output file " + outputFile + " is a directory.")
-    else
-    {
-      val outputDir = outputFile.getParentFile
-      createDirectory(outputDir)
-      withZipOutput(outputFile, manifest)
-      { output =>
-        val createEntry: (String => ZipEntry) = if(manifest.isDefined) new JarEntry(_) else new ZipEntry(_)
-        writeZip(sources, output)(createEntry)
-      }
-    }
-  }
-  private def writeZip(sources: Seq[(File,String)], output: ZipOutputStream)(createEntry: String => ZipEntry)
-  {
-      import Path.{lazyPathFinder => pf}
-    val files = sources.collect { case (file,name) if file.isFile => (file, normalizeName(name)) }
-    val now = System.currentTimeMillis
-    // The CRC32 for an empty value, needed to store directories in zip files
-    val emptyCRC = new CRC32().getValue()
-
-    def addDirectoryEntry(name: String)
-    {
-      output putNextEntry makeDirectoryEntry(name)
-      output.closeEntry()
-    }
-
-    def makeDirectoryEntry(name: String) =
-    {
-//      log.debug("\tAdding directory " + relativePath + " ...")
-      val e = createEntry(name)
-      e setTime now
-      e setSize 0
-      e setMethod ZipEntry.STORED
-      e setCrc emptyCRC
-      e
-    }
-
-    def makeFileEntry(file: File, name: String) =
-    {
-//      log.debug("\tAdding " + file + " as " + name + " ...")
-      val e = createEntry(name)
-      e setTime file.lastModified
-      e
-    }
-    def addFileEntry(file: File, name: String)
-    {
-      output putNextEntry makeFileEntry(file, name)
-      transfer(file, output)
-      output.closeEntry()
-    }
-
-    //Calculate directories and add them to the generated Zip
-    allDirectoryPaths(files) foreach addDirectoryEntry
-
-    //Add all files to the generated Zip
-    files foreach { case (file, name) => addFileEntry(file, name) }
-  }
-
-  // map a path a/b/c to List("a", "b")
-  private def relativeComponents(path: String): List[String] =
-    path.split("/").toList.dropRight(1)
-
-  // map components List("a", "b", "c") to List("a/b/c/", "a/b/", "a/", "")
-  private def directories(path: List[String]): List[String] =
-    path.foldLeft(List(""))( (e,l) => (e.head + l + "/") :: e )
-
-  // map a path a/b/c to List("a/b/", "a/")
-  private def directoryPaths(path: String): List[String] =
-    directories(relativeComponents(path)).filter(_.length > 1)
-
-  // produce a sorted list of all the subdirectories of all provided files
-  private def allDirectoryPaths(files: Iterable[(File,String)]) =
-    TreeSet[String]() ++ (files flatMap { case (file, name) => directoryPaths(name) })
-
-  private def normalizeDirName(name: String) =
-  {
-    val norm1 = normalizeName(name)
-    if(norm1.endsWith("/")) norm1 else (norm1 + "/")
-  }
-  private def normalizeName(name: String) =
-  {
-    val sep = File.separatorChar
-    if(sep == '/') name else name.replace(sep, '/')
-  }
-
-  private def withZipOutput(file: File, manifest: Option[Manifest])(f: ZipOutputStream => Unit)
-  {
-    fileOutputStream(false)(file) { fileOut =>
-      val (zipOut, ext) =
-        manifest match
-        {
-          case Some(mf) =>
-          {
-            import Attributes.Name.MANIFEST_VERSION
-            val main = mf.getMainAttributes
-            if(!main.containsKey(MANIFEST_VERSION))
-              main.put(MANIFEST_VERSION, "1.0")
-            (new JarOutputStream(fileOut, mf), "jar")
-          }
-          case None => (new ZipOutputStream(fileOut), "zip")
-        }
-      try { f(zipOut) }
-      catch { case e: Exception => "Error writing " + ext + ": " + e.toString }
-      finally { zipOut.close }
-    }
-  }
-  def relativize(base: File, file: File): Option[String] =
-  {
-    val pathString = file.getAbsolutePath
-    baseFileString(base) flatMap
-    {
-      baseString =>
-      {
-        if(pathString.startsWith(baseString))
-          Some(pathString.substring(baseString.length))
-        else
-          None
-      }
-    }
-  }
-  private def baseFileString(baseFile: File): Option[String] =
-  {
-    if(baseFile.isDirectory)
-    {
-      val cp = baseFile.getAbsolutePath
-      assert(cp.length > 0)
-      val normalized = if(cp.charAt(cp.length - 1) == File.separatorChar) cp else cp + File.separatorChar
-      Some(normalized)
-    }
-    else
-      None
-  }
-  def copy(sources: Traversable[(File,File)], overwrite: Boolean = false, preserveLastModified: Boolean = false): Set[File] =
-    sources.map( tupled(copyImpl(overwrite, preserveLastModified)) ).toSet
-  private def copyImpl(overwrite: Boolean, preserveLastModified: Boolean)(from: File, to: File): File =
-  {
-    if(overwrite || !to.exists || from.lastModified > to.lastModified)
-    {
-      if(from.isDirectory)
-        createDirectory(to)
-      else
-      {
-        createDirectory(to.getParentFile)
-        copyFile(from, to, preserveLastModified)
-      }
-    }
-    to
-  }
-  def copyDirectory(source: File, target: File, overwrite: Boolean = false, preserveLastModified: Boolean = false): Unit =
-    copy( (Path.fromFile(source) ***) x Path.rebase(source, target), overwrite, preserveLastModified)
-
-  def copyFile(sourceFile: File, targetFile: File, preserveLastModified: Boolean = false)
-  {
-    require(sourceFile.exists, "Source file '" + sourceFile.getAbsolutePath + "' does not exist.")
-    require(!sourceFile.isDirectory, "Source file '" + sourceFile.getAbsolutePath + "' is a directory.")
-    fileInputChannel(sourceFile) { in =>
-      fileOutputChannel(targetFile) { out =>
-        val copied = out.transferFrom(in, 0, in.size)
-        if(copied != in.size)
-          error("Could not copy '" + sourceFile + "' to '" + targetFile + "' (" + copied + "/" + in.size + " bytes copied)")
-      }
-    }
-    if(preserveLastModified)
-      copyLastModified(sourceFile, targetFile)
-  }
-  def copyLastModified(sourceFile: File, targetFile: File) = targetFile.setLastModified( sourceFile.lastModified )
-  def defaultCharset = utf8
-
-  def write(file: File, content: String, charset: Charset = defaultCharset, append: Boolean = false): Unit =
-    writer(file, content, charset, append) { _.write(content)  }
-
-  def writer[T](file: File, content: String, charset: Charset, append: Boolean = false)(f: BufferedWriter => T): T =
-  {
-    if(charset.newEncoder.canEncode(content))
-      fileWriter(charset, append)(file) { f }
-    else
-      error("String cannot be encoded by charset " + charset.name)
-  }
-
-  def reader[T](file: File, charset: Charset = defaultCharset)(f: BufferedReader => T): T =
-    fileReader(charset)(file) { f }
-
-  def read(file: File, charset: Charset = defaultCharset): String =
-  {
-    val out = new ByteArrayOutputStream(file.length.toInt)
-    transfer(file, out)
-    out.toString(charset.name)
-  }
-  /** doesn't close the InputStream */
-  def readStream(in: InputStream, charset: Charset = defaultCharset): String =
-  {
-    val out = new ByteArrayOutputStream
-    transfer(in, out)
-    out.toString(charset.name)
-  }
-  def readBytes(file: File): Array[Byte] = fileInputStream(file)(readBytes)
-  /** doesn't close the InputStream */
-  def readBytes(in: InputStream): Array[Byte] =
-  {
-    val out = new ByteArrayOutputStream
-    transfer(in, out)
-    out.toByteArray
-  }
-
-  def append(file: File, content: String, charset: Charset = defaultCharset): Unit =
-    write(file, content, charset, true)
-  def append(file: File, bytes: Array[Byte]): Unit =
-    writeBytes(file, bytes, true)
-
-  def write(file: File, bytes: Array[Byte]): Unit =
-    writeBytes(file, bytes, false)
-  private def writeBytes(file: File, bytes: Array[Byte], append: Boolean): Unit =
-    fileOutputStream(append)(file) { _.write(bytes) }
-
-
-  // Not optimized for large files
-  def readLines(file: File, charset: Charset = defaultCharset): List[String] =
-    fileReader(charset)(file)(readLines)
-    
-  // Not optimized for large files
-  def readLines(in: BufferedReader): List[String] = 
-    foldLines[List[String]](in, Nil)( (accum, line) => line :: accum ).reverse
-  
-  def foreachLine(in: BufferedReader)(f: String => Unit): Unit =
-    foldLines(in, ())( (_, line) => f(line) )
-    
-  def foldLines[T](in: BufferedReader, init: T)(f: (T, String) => T): T =
-  {
-    def readLine(accum: T): T =
-    {
-      val line = in.readLine()
-      if(line eq null) accum else readLine(f(accum, line))
-    }
-    readLine(init)
-  }
-  
-  def writeLines(file: File, lines: Seq[String], charset: Charset = defaultCharset, append: Boolean = false): Unit =
-    writer(file, lines.headOption.getOrElse(""), charset, append) { w =>
-      lines.foreach { line => w.write(line); w.newLine() }
-    }
-    
-  def write(properties: Properties, label: String, to: File) =
-    fileOutputStream()(to) { output => properties.store(output, label) }
-  def load(properties: Properties, from: File): Unit =
-    if(from.exists)
-      fileInputStream(from){ input => properties.load(input) }
-
-  /** A pattern used to split a String by path separator characters.*/
-  private val PathSeparatorPattern = java.util.regex.Pattern.compile(File.pathSeparator)
-
-  /** Splits a String around path separator characters. */
-  def pathSplit(s: String) = PathSeparatorPattern.split(s)
-
-  /** Move the provided files to a temporary location.
-  *   If 'f' returns normally, delete the files.
-  *   If 'f' throws an Exception, return the files to their original location.*/
-  def stash[T](files: Set[File])(f: => T): T =
-    withTemporaryDirectory { dir =>
-      val stashed = stashLocations(dir, files.toArray)
-      move(stashed)
-
-      try { f } catch { case e: Exception =>
-        try { move(stashed.map(_.swap)); throw e }
-        catch { case _: Exception => throw e }
-      }
-    }
-
-  private def stashLocations(dir: File, files: Array[File]) =
-    for( (file, index) <- files.zipWithIndex) yield
-      (file, new File(dir, index.toHexString))
-
-  def move(files: Traversable[(File, File)]): Unit =
-    files.foreach(Function.tupled(move))
-    
-  def move(a: File, b: File): Unit =
-  {
-    if(b.exists)
-      delete(b)
-    if(!a.renameTo(b))
-    {
-      copyFile(a, b, true)
-      delete(a)
-    }
-  }
-
-  def gzipFileOut[T](file: File)(f: OutputStream => T): T =
-    Using.fileOutputStream()(file) { fout =>
-    Using.gzipOutputStream(fout) { outg =>
-    Using.bufferedOutputStream(outg)(f) }}
-
-  def gzipFileIn[T](file: File)(f: InputStream => T): T =
-    Using.fileInputStream(file) { fin =>
-    Using.gzipInputStream(fin) { ing =>
-    Using.bufferedInputStream(ing)(f) }}
-}

http://git-wip-us.apache.org/repos/asf/clerezza/blob/14575ea3/bundledevtool/src/main/scala/sbt/io/IPC.scala
----------------------------------------------------------------------
diff --git a/bundledevtool/src/main/scala/sbt/io/IPC.scala b/bundledevtool/src/main/scala/sbt/io/IPC.scala
deleted file mode 100644
index ddd09f7..0000000
--- a/bundledevtool/src/main/scala/sbt/io/IPC.scala
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
- *
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- *
-*/
-
-/* sbt -- Simple Build Tool
- * Copyright 2009 Mark Harrah
- */
-package xsbt
-
-import java.io.{BufferedReader, BufferedWriter, InputStream, InputStreamReader, OutputStreamWriter, OutputStream}
-import java.net.{InetAddress, ServerSocket, Socket}
-
-object IPC
-{
-  private val portMin = 1025
-  private val portMax = 65536
-  private val loopback = InetAddress.getByName(null) // loopback
-  
-  def client[T](port: Int)(f: IPC => T): T =
-    ipc(new Socket(loopback, port))(f)
-  
-  def pullServer[T](f: Server => T): T =
-  {
-    val server = makeServer
-    try { f(new Server(server)) } 
-    finally { server.close() }
-  }
-  def makeServer: ServerSocket =
-  {
-    val random = new java.util.Random
-    def nextPort = random.nextInt(portMax - portMin + 1) + portMin
-    def createServer(attempts: Int): ServerSocket =
-      if(attempts > 0)
-        try { new ServerSocket(nextPort, 1, loopback) }
-        catch { case _: Exception => createServer(attempts - 1) }
-      else
-        error("Could not connect to socket: maximum attempts exceeded")
-    createServer(10)
-  }
-  def server[T](f: IPC => Option[T]): T = serverImpl(makeServer, f)
-  def server[T](port: Int)(f: IPC => Option[T]): T =
-    serverImpl(new ServerSocket(port, 1, loopback), f)
-  private def serverImpl[T](server: ServerSocket, f: IPC => Option[T]): T =
-  {
-    def listen(): T =
-    {
-      ipc(server.accept())(f) match
-      {
-        case Some(done) => done
-        case None => listen()
-      }
-    }
-    
-    try { listen() }
-    finally { server.close() }
-  }
-  private def ipc[T](s: Socket)(f: IPC => T): T =
-    try { f(new IPC(s)) }
-    finally { s.close() }
-    
-  final class Server private[IPC](s: ServerSocket) extends NotNull
-  {
-    def port = s.getLocalPort
-    def close() = s.close()
-    def connection[T](f: IPC => T): T = IPC.ipc(s.accept())(f)
-  }
-}
-final class IPC private(s: Socket) extends NotNull
-{
-  def port = s.getLocalPort
-  private val in = new BufferedReader(new InputStreamReader(s.getInputStream))
-  private val out = new BufferedWriter(new OutputStreamWriter(s.getOutputStream))
-  
-  def send(s: String) = { out.write(s); out.newLine(); out.flush() }
-  def receive: String = in.readLine()
-}

http://git-wip-us.apache.org/repos/asf/clerezza/blob/14575ea3/bundledevtool/src/main/scala/sbt/io/NameFilter.scala
----------------------------------------------------------------------
diff --git a/bundledevtool/src/main/scala/sbt/io/NameFilter.scala b/bundledevtool/src/main/scala/sbt/io/NameFilter.scala
deleted file mode 100644
index 4bf5c68..0000000
--- a/bundledevtool/src/main/scala/sbt/io/NameFilter.scala
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
- *
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- *
-*/
-
-/* sbt -- Simple Build Tool
- * Copyright 2008, 2009  Mark Harrah
- */
-package sbt
-
-import java.io.File
-import java.util.regex.Pattern
-
-trait FileFilter extends java.io.FileFilter with NotNull
-{
-  def || (filter: FileFilter): FileFilter = new SimpleFileFilter( file => accept(file) || filter.accept(file) )
-  def && (filter: FileFilter): FileFilter = new SimpleFileFilter( file => accept(file) && filter.accept(file) )
-  def -- (filter: FileFilter): FileFilter = new SimpleFileFilter( file => accept(file) && !filter.accept(file) )
-  def unary_- : FileFilter = new SimpleFileFilter( file => !accept(file) )
-}
-trait NameFilter extends FileFilter with NotNull
-{
-  def accept(name: String): Boolean
-  final def accept(file: File): Boolean = accept(file.getName)
-  def | (filter: NameFilter): NameFilter = new SimpleFilter( name => accept(name) || filter.accept(name) )
-  def & (filter: NameFilter): NameFilter = new SimpleFilter( name => accept(name) && filter.accept(name) )
-  def - (filter: NameFilter): NameFilter = new SimpleFilter( name => accept(name) && !filter.accept(name) )
-  override def unary_- : NameFilter = new SimpleFilter( name => !accept(name) )
-}
-object HiddenFileFilter extends FileFilter {
-  def accept(file: File) = file.isHidden && file.getName != "."
-}
-object ExistsFileFilter extends FileFilter {
-  def accept(file: File) = file.exists
-}
-object DirectoryFilter extends FileFilter {
-  def accept(file: File) = file.isDirectory
-}
-class SimpleFileFilter(val acceptFunction: File => Boolean) extends FileFilter
-{
-  def accept(file: File) = acceptFunction(file)
-}
-class ExactFilter(val matchName: String) extends NameFilter
-{
-  def accept(name: String) = matchName == name
-}
-class SimpleFilter(val acceptFunction: String => Boolean) extends NameFilter
-{
-  def accept(name: String) = acceptFunction(name)
-}
-class PatternFilter(val pattern: Pattern) extends NameFilter
-{
-  def accept(name: String) = pattern.matcher(name).matches
-}
-object AllPassFilter extends NameFilter
-{
-  def accept(name: String) = true
-}
-object NothingFilter extends NameFilter
-{
-  def accept(name: String) = false
-}
-
-object GlobFilter
-{
-  implicit def apply(expression: String): NameFilter =
-  {
-    require(!expression.exists(java.lang.Character.isISOControl), "Control characters not allowed in filter expression.")
-    if(expression == "*")
-      AllPassFilter
-    else if(expression.indexOf('*') < 0) // includes case where expression is empty
-      new ExactFilter(expression)
-    else
-      new PatternFilter(Pattern.compile(expression.split("\\*", -1).map(quote).mkString(".*")))
-  }
-  private def quote(s: String) = if(s.isEmpty) "" else Pattern.quote(s.replaceAll("\n", """\n"""))
-}

http://git-wip-us.apache.org/repos/asf/clerezza/blob/14575ea3/bundledevtool/src/main/scala/sbt/io/Pack.scala
----------------------------------------------------------------------
diff --git a/bundledevtool/src/main/scala/sbt/io/Pack.scala b/bundledevtool/src/main/scala/sbt/io/Pack.scala
deleted file mode 100644
index c7dc287..0000000
--- a/bundledevtool/src/main/scala/sbt/io/Pack.scala
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- *
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- *
-*/
-
-/* sbt -- Simple Build Tool
- * Copyright 2009 Mark Harrah
- */
-package sbt
-
-import java.io.{File, FileOutputStream}
-import java.util.jar.{JarEntry, JarFile, JarOutputStream, Pack200}
-import IO._
-
-object Pack
-{
-  def pack(jarPath: File, out: File): Unit = pack(jarPath, out, defaultPackerOptions)
-  def pack(jarPath: File, out: File, options: Iterable[(String, String)])
-  {
-    val packer = Pack200.newPacker
-    import collection.JavaConversions._
-    packer.properties ++= options
-     
-    Using.jarFile(false)(jarPath) { f =>
-      Using.fileOutputStream()(out) { stream =>
-        packer.pack(f, stream)
-      }
-    }
-  }
-  def unpack(packedPath: File, toJarPath: File)
-  {
-    val unpacker = Pack200.newUnpacker
-    Using.fileOutputStream()(toJarPath) { fileStream =>
-      Using.jarOutputStream(fileStream) { jarOut =>
-        unpacker.unpack(packedPath, jarOut)
-      }
-    }
-  }
-  def defaultPackerOptions = scala.collection.immutable.Map()
-}
-
-import java.net.URL
-/** This is somewhat of a mess and is not entirely correct.  jarsigner doesn't work properly
-* on scalaz and it is difficult to determine whether a jar is both signed and valid.  */
-object SignJar
-{
-  final class SignOption private[SignJar](val toList: List[String], val signOnly: Boolean)
-  {
-    override def toString = toList.mkString(" ")
-  }
-  def keyStore(url: URL) = new SignOption("-keystore" :: url.toExternalForm :: Nil, true)
-  def signedJar(p: Path) = new SignOption("-signedjar" :: p.asFile.getAbsolutePath :: Nil, true)
-  def verbose = new SignOption("-verbose" :: Nil, false)
-  def sigFile(name: String) = new SignOption("-sigfile" :: name :: Nil, true)
-  def storeType(t: String) = new SignOption("-storetype" :: t :: Nil, false)
-  def provider(p: String) = new SignOption("-provider" :: p :: Nil, false)
-  def providerName(p: String) = new SignOption("-providerName" :: p :: Nil, false)
-  def storePassword(p: String) = new SignOption("-storepass" :: p :: Nil, true)
-  def keyPassword(p: String) = new SignOption("-keypass" :: p :: Nil, true)
-  
-  private def VerifyOption = "-verify"
-  
-  /** Uses jarsigner to sign the given jar.  */
-  def sign(jarPath: File, alias: String, options: Seq[SignOption])(fork: (String, List[String]) => Int)
-  {
-    require(!alias.trim.isEmpty, "Alias cannot be empty")
-    val arguments = options.toList.flatMap(_.toList) ::: jarPath.getAbsolutePath :: alias :: Nil
-    execute("signing", arguments)(fork)
-  }
-  /** Uses jarsigner to verify the given jar.*/
-  def verify(jarPath: File, options: Seq[SignOption])(fork: (String, List[String]) => Int)
-  {
-    val arguments = options.filter(!_.signOnly).toList.flatMap(_.toList) ::: VerifyOption :: jarPath.getAbsolutePath :: Nil
-    execute("verifying", arguments)(fork)
-  }
-  private def execute(action: String, arguments: List[String])(fork: (String, List[String]) => Int)
-  {
-    val exitCode = fork(CommandName, arguments)
-    if(exitCode != 0)
-      error("Error " + action + " jar (exit code was " + exitCode + ".)")
-  }
-  
-  private val CommandName = "jarsigner"
-}

http://git-wip-us.apache.org/repos/asf/clerezza/blob/14575ea3/bundledevtool/src/main/scala/sbt/io/Path.scala
----------------------------------------------------------------------
diff --git a/bundledevtool/src/main/scala/sbt/io/Path.scala b/bundledevtool/src/main/scala/sbt/io/Path.scala
deleted file mode 100644
index 44c8ae8..0000000
--- a/bundledevtool/src/main/scala/sbt/io/Path.scala
+++ /dev/null
@@ -1,441 +0,0 @@
-/*
- *
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- *
-*/
-
-/* sbt -- Simple Build Tool
- * Copyright 2008, 2009, 2010  Mark Harrah
- */
-package sbt
-
-import Path._
-import IO.{pathSplit, wrapNull}
-import java.io.File
-import java.net.URL
-import scala.collection.{generic, immutable, mutable, TraversableLike}
-
-/** A Path represents a file in a project.
-* @see sbt.PathFinder*/
-sealed abstract class Path extends PathFinder
-{
-  /** Creates a base directory for this path.  This is used by copy and zip functions
-  * to determine the relative path that should be used in the destination.  For example,
-  * if the following path is specified to be copied to directory 'd',
-  * 
-  * <code>((a / b) ###) / x / y</code>
-  *
-  * the copied path would be 
-  *
-  * <code>d / x / y</code>
-  *
-  * The <code>relativePath</code> method is used to return the relative path to the base directory. */
-  override def ### : Path = new BaseDirectory(this)
-  private[sbt] def addTo(pathSet: mutable.Set[Path])
-  {
-    if(asFile.exists)
-      pathSet += this
-  }
-  override def / (component: String): Path = if(component == ".") this else new RelativePath(this, component)
-  /** True if and only if the file represented by this path exists.*/
-  def exists = asFile.exists
-  /** True if and only if the file represented by this path is a directory.*/
-  def isDirectory = asFile.isDirectory
-  /** The last modified time of the file represented by this path.*/
-  def lastModified = asFile.lastModified
-  /* True if and only if file that this path represents exists and the file represented by the path 'p'
-  * does not exist or was modified before the file for this path.*/
-  def newerThan(p: Path): Boolean = exists && (!p.exists || lastModified > p.lastModified)
-  /* True if and only if file that this path represents does not exist or the file represented by the path 'p'
-  * exists and was modified after the file for this path.*/
-  def olderThan(p: Path): Boolean = p newerThan this
-  /** The file represented by this path.*/
-  def asFile: File
-  /** The file represented by this path converted to a <code>URL</code>.*/
-  def asURL = asFile.toURI.toURL
-  /** The string representation of this path relative to the base directory.  The project directory is the
-  * default base directory if one is not specified explicitly using the <code>###</code> operator.*/
-  lazy val relativePath: String = relativePathString(sep.toString)
-  def relativePathString(separator: String): String
-  final def projectRelativePath: String = projectRelativePathString(sep.toString)
-  def projectRelativePathString(separator: String): String
-  def absolutePath: String = asFile.getAbsolutePath
-  private[sbt] def prependTo(s: String): String
-  
-  /** The last component of this path.*/
-  def name = asFile.getName
-  /** The extension part of the name of this path.  This is the part of the name after the last period, or the empty string if there is no period.*/
-  def ext = baseAndExt._2
-  /** The base of the name of this path.  This is the part of the name before the last period, or the full name if there is no period.*/
-  def base = baseAndExt._1
-  def baseAndExt: (String, String) =
-  {
-    val nme = name
-    val dot = nme.lastIndexOf('.')
-    if(dot < 0) (nme, "") else (nme.substring(0, dot), nme.substring(dot+1))
-  }
-  
-  /** Equality of Paths is defined in terms of the underlying <code>File</code>.*/
-  override final def equals(other: Any) =
-    other match
-    {
-      case op: Path => asFile == op.asFile
-      case _ => false
-    }
-  /** The hash code of a Path is that of the underlying <code>File</code>.*/
-  override final def hashCode = asFile.hashCode
-}
-private final class BaseDirectory(private[sbt] val path: Path) extends Path
-{
-  override def ### : Path = this
-  override def toString = path.toString
-  def asFile = path.asFile
-  def relativePathString(separator: String) = ""
-  def projectRelativePathString(separator: String) = path.projectRelativePathString(separator)
-  private[sbt] def prependTo(s: String) = "." + sep + s
-}
-private[sbt] final class FilePath(file: File) extends Path
-{
-  lazy val asFile = absolute(file)
-  override def toString = absolutePath
-  def relativePathString(separator: String) = asFile.getName
-  def projectRelativePathString(separator: String) = relativePathString(separator)
-  private[sbt] def prependTo(s: String) = absolutePath + sep + s
-}
-// toRoot is the path between this and the root project path and is used for toString
-private[sbt] final class ProjectDirectory(file: File, toRoot: Option[Path]) extends Path
-{
-  def this(file: File) = this(file, None)
-  lazy val asFile = absolute(file)
-  override def toString = foldToRoot(_.toString, ".")
-  def relativePathString(separator: String) = ""
-  def projectRelativePathString(separator: String) = ""
-  private[sbt] def prependTo(s: String) = foldToRoot(_.prependTo(s), "." + sep + s)
-  private[sbt] def foldToRoot[T](f: Path => T, orElse: T) = toRoot.map(f).getOrElse(orElse)
-}
-private[sbt] final class RelativePath(val parentPath: Path, val component: String) extends Path
-{
-  checkComponent(component)
-  override def toString = parentPath prependTo component
-  lazy val asFile = new File(parentPath.asFile, component)
-  private[sbt] def prependTo(s: String) =  parentPath prependTo (component + sep + s)
-  def relativePathString(separator: String) = relative(parentPath.relativePathString(separator), separator)
-  def projectRelativePathString(separator: String) = relative(parentPath.projectRelativePathString(separator), separator)
-  private def relative(parentRelative: String, separator: String) =
-  {
-    if(parentRelative.isEmpty)
-      component
-    else
-      parentRelative + separator + component
-  }
-}
-  import java.io.File
-  import File.pathSeparator
-trait PathExtra extends Alternatives with Mapper
-{
-  implicit def fileToPath(file: File): Path = Path.fromFile(file)
-  implicit def pathToFile(path: Path): File = path.asFile
-  implicit def pathsToFiles[CC[X] <: TraversableLike[X,CC[X]]](cc: CC[Path])(implicit cb: generic.CanBuildFrom[CC[Path], File, CC[File]]): CC[File] =
-    cc.map(_.asFile)
-  implicit def filesToPaths[CC[X] <: TraversableLike[X,CC[X]]](cc: CC[File])(implicit cb: generic.CanBuildFrom[CC[File], Path, CC[Path]]): CC[Path] =
-    cc.map(fileToPath)
-  implicit def filesToFinder(cc: Traversable[File]): PathFinder = finder(cc)
-  implicit def pathsToFinder(cc: Traversable[Path]): PathFinder = lazyPathFinder(cc)
-}
-object Path extends PathExtra
-{
-  def fileProperty(name: String) = Path.fromFile(System.getProperty(name))
-  def userHome = fileProperty("user.home")
-  
-  def absolute(file: File) = new File(file.toURI.normalize).getAbsoluteFile
-  /** Constructs a String representation of <code>Path</code>s.  The absolute path String of each <code>Path</code> is
-  * separated by the platform's path separator.*/
-  def makeString(paths: Iterable[Path]): String = makeString(paths, pathSeparator)
-  /** Constructs a String representation of <code>Path</code>s.  The absolute path String of each <code>Path</code> is
-  * separated by the given separator String.*/
-  def makeString(paths: Iterable[Path], sep: String): String = paths.map(_.absolutePath).mkString(sep)
-
-  def makeString(paths: Seq[File]): String = makeString(paths, pathSeparator)
-  def makeString(paths: Seq[File], sep: String): String = paths.map(_.getAbsolutePath).mkString(sep)
-  
-  /** Constructs a String representation of <code>Path</code>s.  The relative path String of each <code>Path</code> is
-  * separated by the platform's path separator.*/
-  def makeRelativeString(paths: Iterable[Path]): String = paths.map(_.relativePathString(sep.toString)).mkString(pathSeparator)
-  
-  def splitString(projectPath: Path, value: String): Iterable[Path] =
-  {
-    for(pathString <- pathSplit(value) if pathString.length > 0) yield
-      Path.fromString(projectPath, pathString)
-  }
-  
-  /** A <code>PathFinder</code> that always produces the empty set of <code>Path</code>s.*/
-  def emptyPathFinder =
-    new PathFinder
-    {
-      private[sbt] def addTo(pathSet: mutable.Set[Path]) {}
-    }
-  /** A <code>PathFinder</code> that selects the paths provided by the <code>paths</code> argument, which is
-  * reevaluated on each call to the <code>PathFinder</code>'s <code>get</code> method.  */
-  def lazyPathFinder(paths: => Traversable[Path]): PathFinder =
-    new PathFinder
-    {
-      private[sbt] def addTo(pathSet: mutable.Set[Path]) = pathSet ++= paths
-    }
-  def finder(files: => Traversable[File]): PathFinder =  lazyPathFinder { fromFiles(files) }
-    
-  /** The separator character of the platform.*/
-  val sep = java.io.File.separatorChar
-  
-  /** Checks the string to verify that it is a legal path component.  The string must be non-empty,
-  * not a slash, and not '.' or '..'.*/
-  def checkComponent(c: String): String =
-  {
-    require(c.length > 0, "Path component must not be empty")
-    require(c.indexOf('/') == -1, "Path component '" + c + "' must not have forward slashes in it")
-    require(c.indexOf('\\') == -1, "Path component '" + c + "' must not have backslashes in it")
-    require(c != "..", "Path component cannot be '..'")
-    require(c != ".", "Path component cannot be '.'")
-    c
-  }
-  /** Converts a path string relative to the given base path to a <code>Path</code>. */
-  def fromString(basePath: Path, value: String): Path =
-  {
-    if(value.isEmpty)
-      basePath
-    else
-    {
-      val f = new File(value)
-      if(f.isAbsolute)
-        fromFile(f)
-      else
-      {
-        val components = value.split("""[/\\]""")
-        (basePath /: components)( (path, component) => path / component )
-      }
-    }
-  }
-  def baseAncestor(path: Path): Option[Path] =
-    path match
-    {
-      case pd: ProjectDirectory => None
-      case fp: FilePath => None
-      case rp: RelativePath => baseAncestor(rp.parentPath)
-      case b: BaseDirectory => Some(b.path)
-    }
-  
-  def relativize(basePath: Path, path: Path): Option[Path] = relativize(basePath, path.asFile)
-  def relativize(basePath: Path, file: File): Option[Path] =
-    basePathString(basePath) flatMap { baseString => relativize(basePath, baseString, file) }
-  def relativize(basePath: Path, basePathString: String, file: File): Option[Path] =
-  {
-    val pathString = file.getAbsolutePath
-    if(pathString.startsWith(basePathString))
-      Some(fromString(basePath, pathString.substring(basePathString.length)))
-    else
-      None
-  }
-  def relativizeFile(baseFile: File, file: File): Option[File] = relativize(baseFile, file).map { path => new File(path) }
-  private[sbt] def relativize(baseFile: File, file: File): Option[String] =
-  {
-    val pathString = file.getAbsolutePath
-    baseFileString(baseFile) flatMap
-    {
-      baseString =>
-      {
-        if(pathString.startsWith(baseString))
-          Some(pathString.substring(baseString.length))
-        else
-          None
-      }
-    }
-  }
-  private[sbt] def basePathString(basePath: Path): Option[String] = baseFileString(basePath.asFile)
-  private def baseFileString(baseFile: File): Option[String] =
-  {
-    if(baseFile.isDirectory)
-    {
-      val cp = baseFile.getAbsolutePath
-      assert(cp.length > 0)
-      if(cp.charAt(cp.length - 1) == File.separatorChar)
-        Some(cp)
-      else
-        Some(cp + File.separatorChar)
-    }
-    else
-      None
-  }
-  def fromFile(file: String): Path = fromFile(new File(file))
-  def fromFile(file: File): Path = new FilePath(file)
-  import collection.generic.{CanBuildFrom, FilterMonadic}
-  def fromFiles[Repr, That](files: FilterMonadic[File, Repr])(implicit bf: CanBuildFrom[Repr, Path, That]): That =  files.map(fromFile)
-
-  def getFiles(files: Traversable[Path]): immutable.Set[File] = files.map(_.asFile).toSet
-  def getURLs(files: Traversable[Path]): Array[URL] = files.map(_.asURL).toArray
-
-  def toURLs(files: Seq[File]): Array[URL] = files.map(_.toURI.toURL).toArray
-}
-
-/** A path finder constructs a set of paths.  The set is evaluated by a call to the <code>get</code>
-* method.  The set will be different for different calls to <code>get</code> if the underlying filesystem
-* has changed.*/
-sealed abstract class PathFinder extends NotNull
-{
-  /** The union of the paths found by this <code>PathFinder</code> with the paths found by 'paths'.*/
-  def +++(paths: PathFinder): PathFinder = new Paths(this, paths)
-  /** Excludes all paths from <code>excludePaths</code> from the paths selected by this <code>PathFinder</code>.*/
-  def ---(excludePaths: PathFinder): PathFinder = new ExcludePaths(this, excludePaths)
-  /** Constructs a new finder that selects all paths with a name that matches <code>filter</code> and are
-  * descendents of paths selected by this finder.*/
-  def **(filter: FileFilter): PathFinder = new DescendentOrSelfPathFinder(this, filter)
-  def *** : PathFinder = **(AllPassFilter)
-  /** Constructs a new finder that selects all paths with a name that matches <code>filter</code> and are
-  * immediate children of paths selected by this finder.*/
-  def *(filter: FileFilter): PathFinder = new ChildPathFinder(this, filter)
-  /** Constructs a new finder that selects all paths with name <code>literal</code> that are immediate children
-  * of paths selected by this finder.*/
-  def / (literal: String): PathFinder = new ChildPathFinder(this, new ExactFilter(literal))
-  /** Constructs a new finder that selects all paths with name <code>literal</code> that are immediate children
-  * of paths selected by this finder.*/
-  final def \ (literal: String): PathFinder = this / literal
-
-  /** Makes the paths selected by this finder into base directories.
-  * @see Path.###
-  */
-  def ### : PathFinder = new BasePathFinder(this)
-
-  def x_![T](mapper: File => Option[T]): Traversable[(File,T)] = x(mapper, false)
-  /** Applies `mapper` to each path selected by this PathFinder and returns the path paired with the non-empty result.
-  * If the result is empty (None) and `errorIfNone` is true, an exception is thrown.
-  * If `errorIfNone` is false, the path is dropped from the returned Traversable.*/
-  def x[T](mapper: File => Option[T], errorIfNone: Boolean = true): Traversable[(File,T)] =
-  {
-    val apply = if(errorIfNone) mapper | fail else mapper
-    for(file <- getFiles; mapped <- apply(file)) yield (file, mapped)
-  }
-  /** Pairs each path selected by this PathFinder with its relativePath.*/
-  def xx: Traversable[(File, String)] = get.map(path => (path.asFile, path.relativePath))
-
-  /** Selects all descendent paths with a name that matches <code>include</code> and do not have an intermediate
-  * path with a name that matches <code>intermediateExclude</code>.  Typical usage is:
-  *
-  * <code>descendentsExcept("*.jar", ".svn")</code>*/
-  def descendentsExcept(include: FileFilter, intermediateExclude: FileFilter): PathFinder =
-    (this ** include) --- (this ** intermediateExclude ** include)
-  
-  /** Evaluates this finder.  The set returned by this method will reflect the underlying filesystem at the
-  * time of calling.  If the filesystem changes, two calls to this method might be different.*/
-  final def get: immutable.Set[Path] =
-  {
-    val pathSet = new mutable.HashSet[Path]
-    addTo(pathSet)
-    pathSet.toSet
-  }
-  /** Only keeps paths for which `f` returns true.  It is non-strict, so it is not evaluated until the returned finder is evaluated.*/
-  final def filter(f: Path => Boolean): PathFinder = Path.lazyPathFinder(get.filter(f))
-  /* Non-strict flatMap: no evaluation occurs until the returned finder is evaluated.*/
-  final def flatMap(f: Path => PathFinder): PathFinder = Path.lazyPathFinder(get.flatMap(p => f(p).get))
-  /** Evaluates this finder and converts the results to an `Array` of `URL`s..*/
-  final def getURLs: Array[URL] = Path.getURLs(get)
-  /** Evaluates this finder and converts the results to a `Set` of `File`s.*/
-  final def getFiles: immutable.Set[File] = Path.getFiles(get)
-  /** Evaluates this finder and converts the results to a `Set` of absolute path strings.*/
-  final def getPaths: immutable.Set[String] = strictMap(_.absolutePath)
-  /** Evaluates this finder and converts the results to a `Set` of relative path strings.*/
-  final def getRelativePaths: immutable.Set[String] = strictMap(_.relativePath)
-  final def strictMap[T](f: Path => T): immutable.Set[T] = get.map(f).toSet
-  private[sbt] def addTo(pathSet: mutable.Set[Path])
-
-  /** Create a PathFinder from this one where each path has a unique name.
-  * A single path is arbitrarily selected from the set of paths with the same name.*/
-  def distinct: PathFinder = Path.lazyPathFinder((Map() ++ get.map(p => (p.asFile.getName, p))) .values.toList )
-
-  /** Constructs a string by evaluating this finder, converting the resulting Paths to absolute path strings, and joining them with the platform path separator.*/
-  final def absString = Path.makeString(get)
-  /** Constructs a string by evaluating this finder, converting the resulting Paths to relative path strings, and joining them with the platform path separator.*/
-  final def relativeString = Path.makeRelativeString(get)
-  /** Constructs a debugging string for this finder by evaluating it and separating paths by newlines.*/
-  override def toString = get.mkString("\n   ", "\n   ","")
-}
-private class BasePathFinder(base: PathFinder) extends PathFinder
-{
-  private[sbt] def addTo(pathSet: mutable.Set[Path])
-  {
-    for(path <- base.get)
-      pathSet += (path ###)
-  }
-}
-private abstract class FilterPath extends PathFinder with FileFilter
-{
-  def parent: PathFinder
-  def filter: FileFilter
-  final def accept(file: File) = filter.accept(file)
-  
-  protected def handlePath(path: Path, pathSet: mutable.Set[Path])
-  {
-    for(matchedFile <- wrapNull(path.asFile.listFiles(this)))
-      pathSet += path / matchedFile.getName
-  }
-}
-private class DescendentOrSelfPathFinder(val parent: PathFinder, val filter: FileFilter) extends FilterPath
-{
-  private[sbt] def addTo(pathSet: mutable.Set[Path])
-  {
-    for(path <- parent.get)
-    {
-      if(accept(path.asFile))
-        pathSet += path
-      handlePathDescendent(path, pathSet)
-    }
-  }
-  private def handlePathDescendent(path: Path, pathSet: mutable.Set[Path])
-  {
-    handlePath(path, pathSet)
-    for(childDirectory <- wrapNull(path.asFile.listFiles(DirectoryFilter)))
-      handlePathDescendent(path / childDirectory.getName, pathSet)
-  }
-}
-private class ChildPathFinder(val parent: PathFinder, val filter: FileFilter) extends FilterPath
-{
-  private[sbt] def addTo(pathSet: mutable.Set[Path])
-  {
-    for(path <- parent.get)
-      handlePath(path, pathSet)
-  }
-}
-private class Paths(a: PathFinder, b: PathFinder) extends PathFinder
-{
-  private[sbt] def addTo(pathSet: mutable.Set[Path])
-  {
-    a.addTo(pathSet)
-    b.addTo(pathSet)
-  }
-}
-private class ExcludePaths(include: PathFinder, exclude: PathFinder) extends PathFinder
-{
-  private[sbt] def addTo(pathSet: mutable.Set[Path])
-  {
-    val includeSet = new mutable.HashSet[Path]
-    include.addTo(includeSet)
-    
-    val excludeSet = new mutable.HashSet[Path]
-    exclude.addTo(excludeSet)
-    
-    includeSet --= excludeSet
-    pathSet ++= includeSet
-  }
-}

http://git-wip-us.apache.org/repos/asf/clerezza/blob/14575ea3/bundledevtool/src/main/scala/sbt/io/PathMapper.scala
----------------------------------------------------------------------
diff --git a/bundledevtool/src/main/scala/sbt/io/PathMapper.scala b/bundledevtool/src/main/scala/sbt/io/PathMapper.scala
deleted file mode 100644
index 3a48360..0000000
--- a/bundledevtool/src/main/scala/sbt/io/PathMapper.scala
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
- *
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- *
-*/
-
-/* sbt -- Simple Build Tool
- * Copyright 2008, 2009  Mark Harrah
- */
-package sbt
-
-  import java.io.File
-
-trait Mapper
-{
-  type PathMap = File => Option[String]
-  type FileMap = File => Option[File]
-
-  val basic: PathMap = f => Some(f.getPath)
-  def relativeTo(base: File): PathMap = IO.relativize(base, _)
-  def rebase(oldBase: File, newBase0: String): PathMap =
-  {
-    val newBase = normalizeBase(newBase0)
-    (file: File) =>
-      if(file == oldBase)
-        Some( if(newBase.isEmpty) "." else newBase )
-      else
-        IO.relativize(oldBase, file).map(newBase + _)
-  }
-  def fail: Any => Nothing = f => error("No mapping for " + f)
-  val flat: PathMap = f => Some(f.getName)
-  def flatRebase(newBase0: String): PathMap =
-  {
-    val newBase = normalizeBase(newBase0)
-    f => Some(newBase + f.getName)
-  }
-  def some[A,B](f: A => B): A => Some[B] = x => Some(f(x))
-
-  def normalizeBase(base: String) = if(!base.isEmpty && !base.endsWith("/"))  base + "/" else base
-
-  def abs: FileMap = f => Some(f.getAbsoluteFile)
-  def resolve(newDirectory: File): FileMap = file => Some(new File(newDirectory, file.getPath))
-  def rebase(oldBase: File, newBase: File): FileMap =
-    file =>
-      if(file == oldBase)
-        Some(newBase)
-      else
-        IO.relativize(oldBase, file) map { r => new File(newBase, r) }
-
-  def flat(newDirectory: File): FileMap = file => Some(new File(newDirectory, file.getName))
-}
-
-trait Alternative[A,B] { def | (g: A => Option[B]): A => Option[B] }
-trait Alternatives
-{
-  implicit def alternative[A,B](f:A => Option[B]): Alternative[A,B] =
-    new Alternative[A,B] { def | (g: A => Option[B]) =
-      (a: A) => f(a) orElse g(a)
-    }
-  final def alternatives[A,B](alts: Seq[A => Option[B]]): A => Option[B] =
-    alts match
-    {
-      case Seq(f, fs @ _*) => f | alternatives(fs)
-      case Seq() => a => None
-    }
-}

http://git-wip-us.apache.org/repos/asf/clerezza/blob/14575ea3/bundledevtool/src/main/scala/sbt/io/Resources.scala
----------------------------------------------------------------------
diff --git a/bundledevtool/src/main/scala/sbt/io/Resources.scala b/bundledevtool/src/main/scala/sbt/io/Resources.scala
deleted file mode 100644
index d8fb52f..0000000
--- a/bundledevtool/src/main/scala/sbt/io/Resources.scala
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
- *
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- *
-*/
-
-/* sbt -- Simple Build Tool
- * Copyright 2008, 2009  Mark Harrah
- */
-package sbt
-
-import java.io.File
-import IO._
-import Resources.error
-
-object Resources
-{
-  def apply(basePath: String) =
-  {
-    require(basePath.startsWith("/"))
-    val resource = getClass.getResource(basePath)
-    if(resource == null)
-      error("Resource base directory '" + basePath + "' not on classpath.")
-    else
-    {
-      val file = toFile(resource)
-      if(file.exists)
-        new Resources(file)
-      else
-        error("Resource base directory '" + basePath + "' does not exist.")
-    }
-  }
-  def error(msg: String) = throw new ResourcesException(msg)
-  private val LoadErrorPrefix = "Error loading initial project: "
-}
-class ResourcesException(msg: String) extends Exception(msg)
-
-class Resources(val baseDirectory: File)
-{
-  import Resources._
-  // The returned directory is not actually read-only, but it should be treated that way
-  def readOnlyResourceDirectory(group: String, name: String): File =
-  {
-    val groupDirectory = new File(baseDirectory, group)
-    if(groupDirectory.isDirectory)
-    {
-      val resourceDirectory = new File(groupDirectory, name)
-      if(resourceDirectory.isDirectory)
-        resourceDirectory
-      else
-        error("Resource directory '" + name + "' in group '" + group + "' not found.")
-    }
-    else
-      error("Group '" + group + "' not found.")
-  }
-  def readWriteResourceDirectory[T](group: String, name: String)(withDirectory: File => T): T =
-  {
-    val file = readOnlyResourceDirectory(group, name)
-    readWriteResourceDirectory(file)(withDirectory)
-  }
-
-  def readWriteResourceDirectory[T](readOnly: File)(withDirectory: File => T): T =
-  {
-    require(readOnly.isDirectory)
-    def readWrite(readOnly: File)(temporary: File): T =
-    {
-      val readWriteDirectory = new File(temporary, readOnly.getName)
-      copyDirectory(readOnly, readWriteDirectory)
-      withDirectory(readWriteDirectory)
-    }
-    withTemporaryDirectory(readWrite(readOnly))
-  }
-}

http://git-wip-us.apache.org/repos/asf/clerezza/blob/14575ea3/bundledevtool/src/main/scala/sbt/io/SourceModificationWatch.scala
----------------------------------------------------------------------
diff --git a/bundledevtool/src/main/scala/sbt/io/SourceModificationWatch.scala b/bundledevtool/src/main/scala/sbt/io/SourceModificationWatch.scala
deleted file mode 100644
index bd22211..0000000
--- a/bundledevtool/src/main/scala/sbt/io/SourceModificationWatch.scala
+++ /dev/null
@@ -1,69 +0,0 @@
-/*
- *
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- *
-*/
-
-/* sbt -- Simple Build Tool
- * Copyright 2009, 2010  Mikko Peltonen, Stuart Roebuck, Mark Harrah
- */
-package sbt
-
-  import annotation.tailrec
-
-object SourceModificationWatch
-{
-  @tailrec def watch(sourcesFinder: PathFinder, pollDelaySec: Int, state: WatchState)(terminationCondition: => Boolean): (Boolean, WatchState) =
-  {
-      import state._
-
-    def sourceFiles: Iterable[java.io.File] = sourcesFinder.getFiles
-    val (lastModifiedTime, fileCount) =
-      ( (0L, 0) /: sourceFiles) {(acc, file) => /*println("processing "+file);*/ (math.max(acc._1, file.lastModified), acc._2 + 1)}
-
-    //println("lastModifiedTime:"+new java.util.Date(lastModifiedTime))
-    //println("lastModifiedTime - lastCallbackCallTime"+(lastModifiedTime - lastCallbackCallTime))
-    val sourcesModified =
-      lastModifiedTime > lastCallbackCallTime ||
-      previousFileCount != fileCount
-
-    val (triggered, newCallbackCallTime) =
-      if (sourcesModified) {
-        (false, System.currentTimeMillis)
-      }
-      else
-        (awaitingQuietPeriod, lastCallbackCallTime)
-
-    val newState = new WatchState(newCallbackCallTime, fileCount, sourcesModified, if(triggered) count + 1 else count)
-    if(triggered)
-      (true, newState)
-    else
-    {
-      Thread.sleep(pollDelaySec * 1000)
-      if(terminationCondition)
-        (false, newState)
-      else
-        watch(sourcesFinder, pollDelaySec, newState)(terminationCondition)
-    }
-  }
-}
-final class WatchState(val lastCallbackCallTime: Long, val previousFileCount: Int, val awaitingQuietPeriod:Boolean, val count: Int)
-object WatchState
-{
-  def empty = new WatchState(0L, 0, false, 0)
-}

http://git-wip-us.apache.org/repos/asf/clerezza/blob/14575ea3/bundledevtool/src/main/scala/sbt/io/Using.scala
----------------------------------------------------------------------
diff --git a/bundledevtool/src/main/scala/sbt/io/Using.scala b/bundledevtool/src/main/scala/sbt/io/Using.scala
deleted file mode 100644
index 0b1698c..0000000
--- a/bundledevtool/src/main/scala/sbt/io/Using.scala
+++ /dev/null
@@ -1,119 +0,0 @@
-/*
- *
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- *
-*/
-
-/* sbt -- Simple Build Tool
- * Copyright 2008, 2009 Mark Harrah
- */
-package sbt
-
-import java.io.{Closeable, File, FileInputStream, FileOutputStream, InputStream, OutputStream}
-import java.io.{BufferedInputStream, BufferedOutputStream, ByteArrayOutputStream, InputStreamReader, OutputStreamWriter}
-import java.io.{BufferedReader, BufferedWriter, FileReader, FileWriter, Reader, Writer}
-import java.util.zip.{GZIPInputStream, GZIPOutputStream}
-import java.net.{URL, URISyntaxException}
-import java.nio.charset.{Charset, CharsetDecoder, CharsetEncoder}
-import java.nio.channels.FileChannel
-import java.util.jar.{Attributes, JarEntry, JarFile, JarInputStream, JarOutputStream, Manifest}
-import java.util.zip.{GZIPOutputStream, ZipEntry, ZipFile, ZipInputStream, ZipOutputStream}
-
-import ErrorHandling.translate
-import Using._
-
-abstract class Using[Source, T]
-{
-  protected def open(src: Source): T
-  def apply[R](src: Source)(f: T => R): R =
-  {
-    val resource = open(src)
-    try { f(resource) }
-    finally { close(resource) }
-  }
-  protected def close(out: T): Unit
-}
-import scala.reflect.{Manifest => SManifest}
-abstract class WrapUsing[Source, T](implicit srcMf: SManifest[Source], targetMf: SManifest[T]) extends Using[Source, T]
-{
-  protected def label[S](m: SManifest[S]) = m.erasure.getSimpleName
-  protected def openImpl(source: Source): T
-  protected final def open(source: Source): T =
-    translate("Error wrapping " + label(srcMf) + " in " + label(targetMf) + ": ") { openImpl(source) }
-}
-trait OpenFile[T] extends Using[File, T]
-{
-  protected def openImpl(file: File): T
-  protected final def open(file: File): T =
-  {
-    val parent = file.getParentFile
-    if(parent != null)
-      IO.createDirectory(parent)
-    openImpl(file)
-  }
-}
-object Using
-{
-  def wrap[Source, T<: Closeable](openF: Source => T)(implicit srcMf: SManifest[Source], targetMf: SManifest[T]): Using[Source,T] =
-    wrap(openF, closeCloseable)
-  def wrap[Source, T](openF: Source => T, closeF: T => Unit)(implicit srcMf: SManifest[Source], targetMf: SManifest[T]): Using[Source,T] =
-    new WrapUsing[Source, T]
-    {
-      def openImpl(source: Source) = openF(source)
-      def close(t: T) = closeF(t)
-    }
-
-  def resource[Source, T <: Closeable](openF: Source => T): Using[Source,T] =
-    resource(openF, closeCloseable)
-  def resource[Source, T](openF: Source => T, closeF: T => Unit): Using[Source,T] =
-    new Using[Source,T]
-    {
-      def open(s: Source) = openF(s)
-      def close(s: T) = closeF(s)
-    }
-  def file[T <: Closeable](openF: File => T): OpenFile[T] = file(openF, closeCloseable)
-  def file[T](openF: File => T, closeF: T => Unit): OpenFile[T] =
-    new OpenFile[T]
-    {
-      def openImpl(file: File) = openF(file)
-      def close(t: T) = closeF(t)
-    }
-  private def closeCloseable[T <: Closeable]: T => Unit = _.close()
-
-  def bufferedOutputStream = wrap( (out: OutputStream) => new BufferedOutputStream(out) )
-  def bufferedInputStream = wrap( (in: InputStream) => new BufferedInputStream(in) )
-  def fileOutputStream(append: Boolean = false) = file(f => new BufferedOutputStream(new FileOutputStream(f, append)))
-  def fileInputStream = file(f => new BufferedInputStream(new FileInputStream(f)))
-  def urlInputStream = resource( (u: URL) => translate("Error opening " + u + ": ")(u.openStream))
-  def fileOutputChannel = file(f => new FileOutputStream(f).getChannel)
-  def fileInputChannel = file(f => new FileInputStream(f).getChannel)
-  def fileWriter(charset: Charset = IO.utf8, append: Boolean = false) =
-    file(f => new BufferedWriter(new OutputStreamWriter(new FileOutputStream(f, append), charset)) )
-  def fileReader(charset: Charset) = file(f => new BufferedReader(new InputStreamReader(new FileInputStream(f), charset)) )
-  def jarFile(verify: Boolean) = file(f => new JarFile(f, verify), (_: JarFile).close())
-  def zipFile = file(f => new ZipFile(f), (_: ZipFile).close())
-  def streamReader = wrap{ (_: (InputStream, Charset)) match { case (in, charset) => new InputStreamReader(in, charset) } }
-  def gzipInputStream = wrap( (in: InputStream) => new GZIPInputStream(in, 8192) )
-  def zipInputStream = wrap( (in: InputStream) => new ZipInputStream(in))
-  def zipOutputStream = wrap( (out: OutputStream) => new ZipOutputStream(out))
-  def gzipOutputStream = wrap((out: OutputStream) => new GZIPOutputStream(out, 8192), (_: GZIPOutputStream).finish())
-  def jarOutputStream = wrap( (out: OutputStream) => new JarOutputStream(out))
-  def jarInputStream = wrap( (in: InputStream) => new JarInputStream(in))
-  def zipEntry(zip: ZipFile) = resource( (entry: ZipEntry) =>
-    translate("Error opening " + entry.getName + " in " + zip + ": ") { zip.getInputStream(entry) } )
-}

http://git-wip-us.apache.org/repos/asf/clerezza/blob/14575ea3/clerezza-jar-resource-bundle/pom.xml
----------------------------------------------------------------------
diff --git a/clerezza-jar-resource-bundle/pom.xml b/clerezza-jar-resource-bundle/pom.xml
deleted file mode 100644
index 12ef5cb..0000000
--- a/clerezza-jar-resource-bundle/pom.xml
+++ /dev/null
@@ -1,64 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?><!--
-   Licensed to the Apache Software Foundation (ASF) under one
-   or more contributor license agreements.  See the NOTICE file
-   distributed with this work for additional information
-   regarding copyright ownership.  The ASF licenses this file
-   to you under the Apache License, Version 2.0 (the
-   "License"); you may not use this file except in compliance
-   with the License.  You may obtain a copy of the License at
-
-     http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing,
-   software distributed under the License is distributed on an
-   "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-   KIND, either express or implied.  See the License for the
-   specific language governing permissions and limitations
-   under the License.    
---><project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-  <modelVersion>4.0.0</modelVersion>
-  <parent>
-      <artifactId>clerezza</artifactId>
-        <groupId>org.apache.clerezza</groupId>
-        <version>0.5</version>
-        <relativePath>../parent</relativePath>
-      </parent>  
-  <artifactId>clerezza-jar-resource-bundle</artifactId>
-  <version>3-SNAPSHOT</version>
-  <name>Clerezza Jar shared resources</name>
-  <description>An archive which contains templates for generating 
-    the necessary license files and notices for all Apache releases.
-    Include via remote-resources plugin, to have the LICENSE,
-    NOTICE and DEPENDENCIES files added to the META-INF. This is a modified 
-    version of uima-jar-resource-bundle</description>
-  
-  
-  <!-- <properties>
-    <uimaScmRoot>build</uimaScmRoot>
-    <uimaScmProject>${project.artifactId}</uimaScmProject>
-  </properties> -->
-
-  <build>
-    <plugins>
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-remote-resources-plugin</artifactId>
-        <executions>      
-          <execution>
-            <goals><goal>bundle</goal></goals>
-          </execution>
-        </executions>
-      </plugin>
-      <plugin>
-        <groupId>org.apache.felix</groupId>
-        <artifactId>maven-scr-plugin</artifactId>
-        <executions>
-           <execution>
-              <id>generate-scr-scrdescriptor</id>
-              <phase>none</phase>
-           </execution>
-        </executions>
-     </plugin>
-    </plugins>
-  </build>
-</project>

http://git-wip-us.apache.org/repos/asf/clerezza/blob/14575ea3/clerezza-jar-resource-bundle/src/main/resources/META-INF/DEPENDENCIES.vm
----------------------------------------------------------------------
diff --git a/clerezza-jar-resource-bundle/src/main/resources/META-INF/DEPENDENCIES.vm b/clerezza-jar-resource-bundle/src/main/resources/META-INF/DEPENDENCIES.vm
deleted file mode 100644
index 76b5c00..0000000
--- a/clerezza-jar-resource-bundle/src/main/resources/META-INF/DEPENDENCIES.vm
+++ /dev/null
@@ -1,51 +0,0 @@
-##
-## Licensed to the Apache Software Foundation (ASF) under one
-## or more contributor license agreements.  See the NOTICE file
-## distributed with this work for additional information
-## regarding copyright ownership.  The ASF licenses this file
-## to you under the Apache License, Version 2.0 (the
-## "License"); you may not use this file except in compliance
-## with the License.  You may obtain a copy of the License at
-##
-##  http://www.apache.org/licenses/LICENSE-2.0
-##
-## Unless required by applicable law or agreed to in writing,
-## software distributed under the License is distributed on an
-## "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-## KIND, either express or implied.  See the License for the
-## specific language governing permissions and limitations
-## under the License.
-##
-## $Date: 2008-03-09 23:17:06 -0700 (Sun, 09 Mar 2008) $ $Rev: 635446 $
-##
-#if($preDepListText)
-$preDepListText
-#else
-// ------------------------------------------------------------------
-// Transitive dependencies of this project determined from the
-// maven pom organized by organization.
-// ------------------------------------------------------------------
-
-#if ($projectName)$projectName#else${project.name}#end
-
-#end
-
-
-#foreach ( $organizationName in $projectsSortedByOrganization.keySet() )
-From: '$organizationName.name'#if($organizationName.url) ($organizationName.url)#end
-
-#foreach ( $project in $projectsSortedByOrganization.get( $organizationName ) )
-  - $project.name #if ($project.url)($project.url)#end $project.artifact
-#foreach ( $license in $project.licenses)
-    License: $license.name #if ($license.url) ($license.url)#end
-#end
-
-#end
-
-#end
-
-
-#if($postDepListText)
-$postDepListText
-#end
-

http://git-wip-us.apache.org/repos/asf/clerezza/blob/14575ea3/clerezza-jar-resource-bundle/src/main/resources/META-INF/LICENSE.vm
----------------------------------------------------------------------
diff --git a/clerezza-jar-resource-bundle/src/main/resources/META-INF/LICENSE.vm b/clerezza-jar-resource-bundle/src/main/resources/META-INF/LICENSE.vm
deleted file mode 100644
index 2d74e0e..0000000
--- a/clerezza-jar-resource-bundle/src/main/resources/META-INF/LICENSE.vm
+++ /dev/null
@@ -1,222 +0,0 @@
-##
-## Licensed to the Apache Software Foundation (ASF) under one
-## or more contributor license agreements.  See the NOTICE file
-## distributed with this work for additional information
-## regarding copyright ownership.  The ASF licenses this file
-## to you under the Apache License, Version 2.0 (the
-## "License"); you may not use this file except in compliance
-## with the License.  You may obtain a copy of the License at
-##
-##  http://www.apache.org/licenses/LICENSE-2.0
-##
-## Unless required by applicable law or agreed to in writing,
-## software distributed under the License is distributed on an
-## "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-## KIND, either express or implied.  See the License for the
-## specific language governing permissions and limitations
-## under the License.
-##
-## $Date: 2007-12-11 14:18:43 -0800 (Tue, 11 Dec 2007) $ $Rev: 603385 $
-##
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.


Mime
View raw message