s3_website_monadic 0.0.31 → 0.0.32

data/src/main/scala/s3/website/model/push.scala

@@ -2,19 +2,15 @@ package s3.website.model
 
 import com.amazonaws.services.s3.model.S3ObjectSummary
 import java.io._
-import scala.util.Try
-import s3.website.model.Encoding._
 import org.apache.commons.codec.digest.DigestUtils
 import java.util.zip.GZIPOutputStream
-import org.apache.commons.io.IOUtils
 import org.apache.tika.Tika
 import s3.website.Ruby._
 import s3.website._
-import s3.website.model.Encoding.Gzip
-import scala.util.Failure
-import scala.Some
-import scala.util.Success
-import s3.website.model.Encoding.Zopfli
+import s3.website.model.LocalFileFromDisk.tika
+import s3.website.model.Encoding.encodingOnS3
+import java.io.File.createTempFile
+import org.apache.commons.io.IOUtils.copy
 
 object Encoding {
 
@@ -23,104 +19,52 @@ object Encoding {
   case class Gzip()
   case class Zopfli()
 
-  def encodingOnS3(path: String)(implicit site: Site): Option[Either[Gzip, Zopfli]] =
-    site.config.gzip.flatMap { (gzipSetting: Either[Boolean, Seq[String]]) =>
+  def encodingOnS3(s3Key: String)(implicit config: Config): Option[Either[Gzip, Zopfli]] =
+    config.gzip.flatMap { (gzipSetting: Either[Boolean, Seq[String]]) =>
       val shouldZipThisFile = gzipSetting.fold(
-        shouldGzip => defaultGzipExtensions exists path.endsWith,
-        fileExtensions => fileExtensions exists path.endsWith
+        shouldGzip => defaultGzipExtensions exists s3Key.endsWith,
+        fileExtensions => fileExtensions exists s3Key.endsWith
       )
-      if (shouldZipThisFile && site.config.gzip_zopfli.isDefined)
+      if (shouldZipThisFile && config.gzip_zopfli.isDefined)
         Some(Right(Zopfli()))
       else if (shouldZipThisFile)
         Some(Left(Gzip()))
       else
         None
     }
-
-  type MD5 = String
-}
-
-sealed trait S3KeyProvider {
-  def s3Key: String
-}
-
-trait UploadTypeResolved {
-  def uploadType: UploadType
 }
 
 sealed trait UploadType // Sealed, so that we can avoid inexhaustive pattern matches more easily
 
 case object NewFile extends UploadType
-case object Update extends UploadType
+case object FileUpdate extends UploadType
+case object RedirectFile extends UploadType
+
+case class LocalFileFromDisk(originalFile: File, uploadType: UploadType)(implicit site: Site) {
+  lazy val s3Key = site.resolveS3Key(originalFile)
 
-case class LocalFile(
-  s3Key: String,
-  originalFile: File,
-  encodingOnS3: Option[Either[Gzip, Zopfli]]
-) extends S3KeyProvider {
+  lazy val encodingOnS3 = Encoding.encodingOnS3(s3Key)
 
-  // May throw an exception, so remember to call this in a Try or Future monad
-  lazy val length = uploadFile.length()
+  lazy val lastModified = originalFile.lastModified
 
   /**
    * This is the file we should upload, because it contains the potentially gzipped contents of the original file.
    *
    * May throw an exception, so remember to call this in a Try or Future monad
    */
-  lazy val uploadFile: File = encodingOnS3
-    .fold(originalFile)(algorithm => {
-    val tempFile = File.createTempFile(originalFile.getName, "gzip")
-    tempFile.deleteOnExit()
-    using(new GZIPOutputStream(new FileOutputStream(tempFile))) { stream =>
-      IOUtils.copy(fis(originalFile), stream)
-    }
-    tempFile
-  })
-
-  /**
-   * May throw an exception, so remember to call this in a Try or Future monad
-   */
-  lazy val md5 = using(fis(uploadFile)) { inputStream =>
-    DigestUtils.md5Hex(inputStream)
-  }
+  lazy val uploadFile: File = LocalFileFromDisk uploadFile originalFile
 
-  private[this] def fis(file: File): InputStream = new FileInputStream(file)
-  private[this] def using[T <: Closeable, R](cl: T)(f: (T) => R): R = try f(cl) finally cl.close()
-}
-
-object LocalFile {
-  def toUpload(localFile: LocalFile)(implicit config: Config): Either[ErrorReport, Upload] = Try {
-    Upload(
-      s3Key = localFile.s3Key,
-      essence = Right(
-        UploadBody(
-          md5 = localFile.md5,
-          contentEncoding = localFile.encodingOnS3.map(_ => "gzip"),
-          contentLength = localFile.length,
-          maxAge = resolveMaxAge(localFile),
-          contentType = resolveContentType(localFile.originalFile),
-          openInputStream = () => new FileInputStream(localFile.uploadFile)
-        )
-      )
-    )
-  } match {
-    case Success(upload) => Right(upload)
-    case Failure(error) => Left(IOError(error))
-  }
-
-  lazy val tika = new Tika()
-
-  def resolveContentType(file: File) = {
-    val mimeType = tika.detect(file)
+  lazy val contentType = {
+    val mimeType = tika.detect(originalFile)
     if (mimeType.startsWith("text/") || mimeType == "application/json")
       mimeType + "; charset=utf-8"
     else
       mimeType
   }
 
-  def resolveMaxAge(localFile: LocalFile)(implicit config: Config): Option[Int] = {
+  lazy val maxAge: Option[Int] = {
     type GlobsMap = Map[String, Int]
-    config.max_age.flatMap { (intOrGlobs: Either[Int, GlobsMap]) =>
+    site.config.max_age.flatMap { (intOrGlobs: Either[Int, GlobsMap]) =>
       type GlobsSeq = Seq[(String, Int)]
       def respectMostSpecific(globs: GlobsMap): GlobsSeq = globs.toSeq.sortBy(_._1.length).reverse
       intOrGlobs
@@ -129,7 +73,7 @@ object LocalFile {
           (seconds: Int) => Some(seconds),
           (globs: GlobsSeq) =>
             globs.find { globAndInt =>
-              (rubyRuntime evalScriptlet s"File.fnmatch('${globAndInt._1}', '${localFile.s3Key}')")
+              (rubyRuntime evalScriptlet s"File.fnmatch('${globAndInt._1}', '$s3Key')")
                 .toJava(classOf[Boolean])
                 .asInstanceOf[Boolean]
             } map (_._2)
@@ -137,83 +81,71 @@ object LocalFile {
     }
   }
 
-  def resolveLocalFiles(implicit site: Site, logger: Logger): Either[ErrorReport, Seq[LocalFile]] = Try {
-    val files = recursiveListFiles(new File(site.rootDirectory)).filterNot(_.isDirectory)
-    files map { file =>
-      val s3Key = site.resolveS3Key(file)
-      LocalFile(s3Key, file, encodingOnS3(s3Key))
-    } filterNot { file =>
-      val excludeFile = site.config.exclude_from_upload exists { _.fold(
-        // For backward compatibility, use Ruby regex matching
-        (exclusionRegex: String) => rubyRegexMatches(file.s3Key, exclusionRegex),
-        (exclusionRegexes: Seq[String]) => exclusionRegexes exists (rubyRegexMatches(file.s3Key, _))
-      ) }
-      if (excludeFile) logger.debug(s"Excluded ${file.s3Key} from upload")
-      excludeFile
-    } filterNot { _.originalFile.getName == "s3_website.yml" } // For security reasons, the s3_website.yml should never be pushed
-  } match {
-    case Success(localFiles) =>
-      Right(
-        // Sort by key, because this will improve the performance when pushing existing sites.
-        // The lazy-loading diff take advantage of this arrangement.
-        localFiles sortBy (_.s3Key)
-      )
-    case Failure(error) =>
-      Left(IOError(error))
-  }
+  /**
+   * May throw an exception, so remember to call this in a Try or Future monad
+   */
+  lazy val md5 = LocalFileFromDisk md5 originalFile
+}
+
+object LocalFileFromDisk {
+  lazy val tika = new Tika()
+
+  def md5(originalFile: File)(implicit site: Site) = using(fis { uploadFile(originalFile) }) { DigestUtils.md5Hex }
+
+  def uploadFile(originalFile: File)(implicit site: Site): File =
+    encodingOnS3(site resolveS3Key originalFile)
+      .fold(originalFile)(algorithm => {
+        val tempFile = createTempFile(originalFile.getName, "gzip")
+        tempFile.deleteOnExit()
+        using(new GZIPOutputStream(new FileOutputStream(tempFile))) { stream =>
+          copy(fis(originalFile), stream)
+        }
+        tempFile
+      })
+
+  private[this] def fis(file: File): InputStream = new FileInputStream(file)
+  private[this] def using[T <: Closeable, R](cl: T)(f: (T) => R): R = try f(cl) finally cl.close()
+}
 
+object Files {
   def recursiveListFiles(f: File): Seq[File] = {
     val these = f.listFiles
     these ++ these.filter(_.isDirectory).flatMap(recursiveListFiles)
   }
-}
-
-case class Redirect(key: String, redirectTarget: String)
 
-object Redirect extends UploadType {
-  def resolveRedirects(implicit config: Config): Seq[Upload with UploadTypeResolved] = {
-    val redirects = config.redirects.fold(Nil: Seq[Redirect]) {
-      sourcesToTargets =>
-        sourcesToTargets.foldLeft(Seq(): Seq[Redirect]) {
-          (redirects, sourceToTarget) =>
-            redirects :+ Redirect(sourceToTarget._1, sourceToTarget._2)
-        }
-    }
-    redirects.map { redirect =>
-      Upload.apply(redirect)
+  def listSiteFiles(implicit site: Site, logger: Logger) = {
+    def excludeFromUpload(s3Key: String) = {
+      val excludeByConfig = site.config.exclude_from_upload exists {
+        _.fold(
+          // For backward compatibility, use Ruby regex matching
+          (exclusionRegex: String) => rubyRegexMatches(s3Key, exclusionRegex),
+          (exclusionRegexes: Seq[String]) => exclusionRegexes exists (rubyRegexMatches(s3Key, _))
+        )
+      }
+      val doNotUpload = excludeByConfig || s3Key == "s3_website.yml"
+      if (doNotUpload) logger.debug(s"Excluded $s3Key from upload")
+      doNotUpload
     }
+    recursiveListFiles(new File(site.rootDirectory))
+      .filterNot(_.isDirectory)
+      .filterNot(f => excludeFromUpload(site.resolveS3Key(f)))
   }
 }
 
-case class Upload(
-  s3Key: String,
-  essence: Either[Redirect, UploadBody]
-) extends S3KeyProvider {
-
-  def withUploadType(ut: UploadType) =
-    new Upload(s3Key, essence) with UploadTypeResolved {
-      def uploadType = ut
-    }
+case class Redirect(s3Key: String, redirectTarget: String) {
+  def uploadType = RedirectFile
 }
 
-object Upload {
-  def apply(redirect: Redirect): Upload with UploadTypeResolved = new Upload(redirect.key, Left(redirect)) with UploadTypeResolved {
-    def uploadType = Redirect
+object Redirect {
+  def resolveRedirects(implicit config: Config): Seq[Redirect] =
+    config.redirects.fold(Nil: Seq[Redirect]) { sourcesToTargets =>
+      sourcesToTargets.foldLeft(Seq(): Seq[Redirect]) {
+        (redirects, sourceToTarget) =>
+          redirects :+ Redirect(sourceToTarget._1, sourceToTarget._2)
+      }
   }
 }
 
-/**
- * Represents a bunch of data that should be stored into an S3 objects body.
- */
-case class UploadBody(
-  md5: MD5,
-  contentLength: Long,
-  contentEncoding: Option[String],
-  maxAge: Option[Int],
-  contentType: String,
-  openInputStream: () => InputStream // It's in the caller's responsibility to close this stream
-)
-
 case class S3File(s3Key: String, md5: MD5)
 
 object S3File {

data/src/main/scala/s3/website/model/ssg.scala

@@ -19,7 +19,7 @@ object Ssg {
     }
 
   def findSiteDirectory(workingDirectory: File): ErrorOrFile =
-    LocalFile.recursiveListFiles(workingDirectory).find { file =>
+    Files.recursiveListFiles(workingDirectory).find { file =>
       file.isDirectory && automaticallySupportedSiteGenerators.exists(_.outputDirectory == file.getName)
     }.fold(Left(notFoundErrorReport): ErrorOrFile)(Right(_))
 }

data/src/main/scala/s3/website/package.scala

@@ -2,7 +2,6 @@ package s3
 
 import scala.concurrent.{ExecutionContextExecutor, Future}
 import scala.concurrent.duration.{TimeUnit, Duration}
-import s3.website.Utils._
 import s3.website.S3.{PushSuccessReport, PushFailureReport}
 import com.amazonaws.AmazonServiceException
 import s3.website.model.{Config, Site}
@@ -18,6 +17,23 @@ package object website {
 
   trait ErrorReport extends Report
 
+  object ErrorReport {
+    def apply(t: Throwable)(implicit logger: Logger) = new ErrorReport {
+      override def reportMessage = {
+        val extendedReport =
+          if (logger.verboseOutput)
+            Some(t.getStackTrace take 5)
+          else
+            None
+        s"${t.getMessage}${extendedReport.fold("")(stackTraceElems => "\n" + stackTraceElems.mkString("\n"))}"
+      }
+    }
+
+    def apply(msg: String) = new ErrorReport {
+      override def reportMessage = msg
+    }
+  }
+
   trait RetrySetting {
     def retryTimeUnit: TimeUnit
   }
@@ -26,6 +42,8 @@ package object website {
     def dryRun: Boolean
   }
 
+  type S3Key = String
+
   trait PushAction {
     def actionName = getClass.getSimpleName.replace("$", "") // case object class names contain the '$' char
 
@@ -61,6 +79,8 @@ package object website {
 
   type Attempt = Int
 
+  type MD5 = String
+
   def retry[L <: Report, R](attempt: Attempt)
                            (createFailureReport: (Throwable) => L, retryAction: (Attempt) => Future[Either[L, R]])
                            (implicit retrySetting: RetrySetting, ec: ExecutionContextExecutor, logger: Logger):
@@ -98,4 +118,6 @@ package object website {
   implicit def site2Config(implicit site: Site): Config = site.config
 
   type ErrorOrFile = Either[ErrorReport, File]
+
+  lazy val fibs: Stream[Int] = 0 #:: 1 #:: fibs.zip(fibs.tail).map { n => n._1 + n._2 }
 }

data/src/test/scala/s3/website/S3WebsiteSpec.scala

@@ -14,7 +14,7 @@ import scala.concurrent.duration._
 import s3.website.S3.S3Setting
 import scala.collection.JavaConversions._
 import com.amazonaws.AmazonServiceException
-import org.apache.commons.codec.digest.DigestUtils.md5Hex
+import org.apache.commons.codec.digest.DigestUtils._
 import s3.website.CloudFront.CloudFrontSetting
 import com.amazonaws.services.cloudfront.AmazonCloudFront
 import com.amazonaws.services.cloudfront.model.{CreateInvalidationResult, CreateInvalidationRequest, TooManyInvalidationsInProgressException}
@@ -24,6 +24,9 @@ import java.util.concurrent.atomic.AtomicInteger
 import org.apache.commons.io.FileUtils.{forceDelete, forceMkdir, write}
 import scala.collection.mutable
 import s3.website.Push.{push, CliArgs}
+import s3.website.CloudFront.CloudFrontSetting
+import s3.website.S3.S3Setting
+import org.apache.commons.codec.digest.DigestUtils
 
 class S3WebsiteSpec extends Specification {
 
@@ -517,6 +520,48 @@ class S3WebsiteSpec extends Specification {
     }
   }
 
+  // Because of the local database, the first and second run are implemented differently.
+  "pushing files for the second time" should {
+    "delete the S3 objects that no longer exist on the local site" in new AllInSameDirectory with EmptySite with MockAWS with DefaultRunMode {
+      push
+      setS3Files(S3File("obsolete.txt", ""))
+      push
+      sentDelete must equalTo("obsolete.txt")
+    }
+
+    "push new files to the bucket" in new AllInSameDirectory with EmptySite with MockAWS with DefaultRunMode {
+      push
+      setLocalFile("newfile.txt")
+      push
+      sentPutObjectRequest.getKey must equalTo("newfile.txt")
+    }
+
+    "push locally changed files" in new AllInSameDirectory with EmptySite with MockAWS with DefaultRunMode {
+      setLocalFileWithContent(("file.txt", "first run"))
+      push
+      setLocalFileWithContent(("file.txt", "second run"))
+      push
+      sentPutObjectRequests.length must equalTo(2)
+    }
+
+    "push locally changed files only once" in new AllInSameDirectory with EmptySite with MockAWS with DefaultRunMode {
+      setLocalFileWithContent(("file.txt", "first run"))
+      push
+      setS3Files(S3File("file.txt", md5Hex("first run")))
+      setLocalFileWithContent(("file.txt", "second run"))
+      push
+      sentPutObjectRequests.length must equalTo(2)
+    }
+
+    "detect files that someone else has changed on the S3 bucket" in new AllInSameDirectory with EmptySite with MockAWS with DefaultRunMode {
+      setLocalFileWithContent(("file.txt", "first run"))
+      push
+      setOutdatedS3Keys("file.txt")
+      push
+      sentPutObjectRequests.length must equalTo(2)
+    }
+  }
+
   "Jekyll site" should {
     "be detected automatically" in new JekyllSite with EmptySite with MockAWS with DefaultRunMode {
       setLocalFile("index.html")
@@ -637,12 +682,6 @@ class S3WebsiteSpec extends Specification {
         .listObjects(Matchers.any(classOf[ListObjectsRequest]))
     }
 
-    def asSeenByS3Client(upload: Upload)(implicit config: Config, logger: Logger): PutObjectRequest = {
-      val req = ArgumentCaptor.forClass(classOf[PutObjectRequest])
-      verify(amazonS3Client).putObject(req.capture())
-      req.getValue
-    }
-
     def sentPutObjectRequests: Seq[PutObjectRequest] = {
       val req = ArgumentCaptor.forClass(classOf[PutObjectRequest])
       verify(amazonS3Client, Mockito.atLeast(1)).putObject(req.capture())
@@ -688,15 +727,14 @@ class S3WebsiteSpec extends Specification {
     implicit final val workingDirectory: File = new File(FileUtils.getTempDirectory, "s3_website_dir" + Random.nextLong())
     val siteDirectory: File // Represents the --site=X option
     val configDirectory: File = workingDirectory // Represents the --config-dir=X option
-
-    lazy val allDirectories = workingDirectory :: siteDirectory :: configDirectory :: Nil
+    lazy val localDatabase: File = new File(FileUtils.getTempDirectory, "s3_website_local_db_" + sha256Hex(siteDirectory.getPath))
 
     def before {
-      allDirectories foreach forceMkdir
+      workingDirectory :: siteDirectory :: configDirectory :: Nil foreach forceMkdir
     }
 
     def after {
-      allDirectories foreach { dir =>
+      (workingDirectory :: siteDirectory :: configDirectory :: localDatabase :: Nil) foreach { dir =>
         if (dir.exists) forceDelete(dir)
       }
     }
@@ -720,7 +758,7 @@ class S3WebsiteSpec extends Specification {
   trait EmptySite extends Directories {
     type LocalFileWithContent = (String, String)
 
-    val localFilesWithContent: mutable.Buffer[LocalFileWithContent] = mutable.Buffer()
+    val localFilesWithContent: mutable.Set[LocalFileWithContent] = mutable.Set()
     def setLocalFile(fileName: String) = setLocalFileWithContent((fileName, ""))
     def setLocalFiles(fileNames: String*) = fileNames foreach setLocalFile
     def setLocalFileWithContent(fileNameAndContent: LocalFileWithContent) = localFilesWithContent += fileNameAndContent
@@ -733,10 +771,22 @@ class S3WebsiteSpec extends Specification {
       |s3_bucket: bucket
     """.stripMargin
 
-    implicit lazy val cliArgs: CliArgs = siteWithFilesAndContent(config, localFilesWithContent)
+    implicit def cliArgs: CliArgs = siteWithFilesAndContent(config, localFilesWithContent)
     def pushMode: PushMode // Represents the --dry-run switch
 
-    def buildSite(
+    private def siteWithFilesAndContent(config: String = "", localFilesWithContent: mutable.Set[LocalFileWithContent]): CliArgs = {
+      localFilesWithContent.foreach {
+        case (filePath, content) =>
+          val file = new File(siteDirectory, filePath)
+          forceMkdir(file.getParentFile)
+          file.createNewFile()
+          write(file, content)
+          localFilesWithContent remove(filePath, content) // Remove the file from the set once we've persisted it on the disk.
+      }
+      buildCliArgs(config)
+    }
+
+    private def buildCliArgs(
                     config: String = "",
                     baseConfig: String =
                       """
@@ -762,16 +812,5 @@ class S3WebsiteSpec extends Specification {
         override def configDir = configDirectory.getAbsolutePath
       }
     }
-
-    def siteWithFilesAndContent(config: String = "", localFilesWithContent: Seq[LocalFileWithContent]): CliArgs = {
-      localFilesWithContent.foreach {
-        case (filePath, content) =>
-          val file = new File(siteDirectory, filePath)
-          forceMkdir(file.getParentFile)
-          file.createNewFile()
-          write(file, content)
-      }
-      buildSite(config)
-    }
   }
 }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: s3_website_monadic
 version: !ruby/object:Gem::Version
-  version: 0.0.31
+  version: 0.0.32
 platform: ruby
 authors:
 - Lauri Lehmijoki
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-14 00:00:00.000000000 Z
+date: 2014-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -113,14 +113,13 @@ files:
 - src/main/java/s3/website/ByteHelper.java
 - src/main/scala/s3/website/CloudFront.scala
 - src/main/scala/s3/website/Diff.scala
+- src/main/scala/s3/website/Logger.scala
 - src/main/scala/s3/website/Push.scala
 - src/main/scala/s3/website/Ruby.scala
 - src/main/scala/s3/website/S3.scala
-- src/main/scala/s3/website/Utils.scala
 - src/main/scala/s3/website/model/Config.scala
 - src/main/scala/s3/website/model/S3Endpoint.scala
 - src/main/scala/s3/website/model/Site.scala
-- src/main/scala/s3/website/model/errors.scala
 - src/main/scala/s3/website/model/push.scala
 - src/main/scala/s3/website/model/ssg.scala
 - src/main/scala/s3/website/package.scala

data/src/main/scala/s3/website/Utils.scala

@@ -1,108 +0,0 @@
-package s3.website
-
-import s3.website.model.Config
-import scala.collection.parallel.{ForkJoinTaskSupport, ParSeq}
-import scala.concurrent.forkjoin.ForkJoinPool
-
-class Utils(implicit config: Config) {
-  def toParSeq[T](seq: Seq[T]): ParSeq[T] = {
-    val parallelSeq: ParSeq[T] = seq.par
-    parallelSeq.tasksupport_=(new ForkJoinTaskSupport(new ForkJoinPool(config.concurrency_level)))
-    parallelSeq
-  }
-}
-
-object Utils {
-  lazy val fibs: Stream[Int] = 0 #:: 1 #:: fibs.zip(fibs.tail).map { n => n._1 + n._2 }
-}
-
-class Logger(val verboseOutput: Boolean, logMessage: (String) => Unit = println) {
-  import Rainbow._
-  def debug(msg: String) = if (verboseOutput) log(Debug, msg)
-  def info(msg: String) = log(Info, msg)
-  def fail(msg: String) = log(Failure, msg)
-
-  def info(report: SuccessReport) = log(Success, report.reportMessage)
-  def info(report: FailureReport) = fail(report.reportMessage)
-
-  def pending(msg: String) = log(Wait, msg)
-
-  private def log(logType: LogType, msgRaw: String) {
-    val msg = msgRaw.replaceAll("\\n", "\n       ") // Indent new lines, so that they arrange nicely with other log lines
-    logMessage(s"[$logType] $msg")
-  }
-
-  sealed trait LogType {
-    val prefix: String
-    override def toString = prefix
-  }
-  case object Debug extends LogType {
-    val prefix = "debg".cyan
-  }
-  case object Info extends LogType {
-    val prefix = "info".blue
-  }
-  case object Success extends LogType {
-    val prefix = "succ".green
-  }
-  case object Failure extends LogType {
-    val prefix = "fail".red
-  }
-  case object Wait extends LogType {
-    val prefix = "wait".yellow
-  }
-}
-
-/**
- * Idea copied from https://github.com/ktoso/scala-rainbow.
- */
-object Rainbow {
-  implicit class RainbowString(val s: String) extends AnyVal {
-    import Console._
-
-    /** Colorize the given string foreground to ANSI black */
-    def black = BLACK + s + RESET
-    /** Colorize the given string foreground to ANSI red */
-    def red = RED + s + RESET
-    /** Colorize the given string foreground to ANSI red */
-    def green = GREEN + s + RESET
-    /** Colorize the given string foreground to ANSI red */
-    def yellow = YELLOW + s + RESET
-    /** Colorize the given string foreground to ANSI red */
-    def blue = BLUE + s + RESET
-    /** Colorize the given string foreground to ANSI red */
-    def magenta = MAGENTA + s + RESET
-    /** Colorize the given string foreground to ANSI red */
-    def cyan = CYAN + s + RESET
-    /** Colorize the given string foreground to ANSI red */
-    def white = WHITE + s + RESET
-
-    /** Colorize the given string background to ANSI red */
-    def onBlack = BLACK_B + s + RESET
-    /** Colorize the given string background to ANSI red */
-    def onRed = RED_B+ s + RESET
-    /** Colorize the given string background to ANSI red */
-    def onGreen = GREEN_B+ s + RESET
-    /** Colorize the given string background to ANSI red */
-    def onYellow = YELLOW_B + s + RESET
-    /** Colorize the given string background to ANSI red */
-    def onBlue = BLUE_B+ s + RESET
-    /** Colorize the given string background to ANSI red */
-    def onMagenta = MAGENTA_B + s + RESET
-    /** Colorize the given string background to ANSI red */
-    def onCyan = CYAN_B+ s + RESET
-    /** Colorize the given string background to ANSI red */
-    def onWhite = WHITE_B+ s + RESET
-
-    /** Make the given string bold */
-    def bold = BOLD + s + RESET
-    /** Underline the given string */
-    def underlined = UNDERLINED + s + RESET
-    /** Make the given string blink (some terminals may turn this off) */
-    def blink = BLINK + s + RESET
-    /** Reverse the ANSI colors of the given string */
-    def reversed = REVERSED + s + RESET
-    /** Make the given string invisible using ANSI color codes */
-    def invisible = INVISIBLE + s + RESET
-  }
-}

data/src/main/scala/s3/website/model/errors.scala

@@ -1,9 +0,0 @@
-package s3.website.model
-
-import s3.website.ErrorReport
-
-case class ClientError(reportMessage: String) extends ErrorReport
-
-case class IOError(exception: Throwable) extends ErrorReport {
-  def reportMessage = exception.getMessage
-}