DouKaku?

import    java.io.{File, BufferedInputStream, BufferedOutputStream, FileInputStream, FileOutputStream, InputStream, OutputStream}
import    java.util.zip.{ZipEntry, ZipInputStream, ZipOutputStream}
import    scala.collection.mutable.HashSet

object Zip {
    def compress(s:String, d:String):Unit =
        (new File(s)) match {
            case f if !f.exists => throw new IllegalArgumentException("no such file.")
            case f => {
                val    o:ZipOutputStream = new ZipOutputStream(new BufferedOutputStream(new FileOutputStream(d)))
                val    c:HashSet[File] = new HashSet
                val    b:Array[Byte] = new Array(2048)
                def output(i:InputStream):Unit = i.read(b) match {
                        case -1 => i.close
                        case l => {
                            o.write(b, 0, l)
                            output(i)
                        }
                    }
                def addEntry(p:String, w:Option[(InputStream)=>Unit]):Unit = {
                    o.putNextEntry(new ZipEntry(p))
                    if (w != None) (w.get)(new BufferedInputStream(new FileInputStream(p)))
                    o.closeEntry
                }
                def addDirectory(f:File):Unit =
                    if (f != null) {
                        addDirectory(f.getParentFile)
                        if (!c.contains(f)) {
                            c += f
                            addEntry(f.getPath.replaceAll("\\\\", "/").replaceFirst("/?$", "/"), None)
                        }
                    }
                def loop(f:File):Unit =
                    if (f.isFile)
                        addEntry(f.getPath.replaceAll("\\\\", "/"), Some(output _))
                    else {
                        addDirectory(f)
                        f.listFiles.foreach(loop _)
                    }
                if (f.isFile) addDirectory(f.getParentFile)
                loop(f)
                o.close
            }
        }
    def decompress(s:String):Unit =
        (new File(s)) match {
            case f if !f.exists => throw new IllegalArgumentException("no such file.")
            case f => {
                val    i:ZipInputStream = new ZipInputStream(new BufferedInputStream(new FileInputStream(f)))
                val    b:Array[Byte] = new Array(2048)
                def output(o:OutputStream):Unit = i.read(b) match {
                        case -1 => o.close
                        case l => {
                            o.write(b, 0, l)
                            output(o)
                        }
                    }
                def loop:Unit = {
                    val    e:ZipEntry = i.getNextEntry
                    if (e == null)
                        i.close
                    else {
                        if (e.isDirectory)
                            (new File(e.getName)).mkdirs
                        else {
                            val    f:File = new File(e.getName)
                            if (f.getParentFile != null && !f.exists) f.getParentFile.mkdirs
                            output(new BufferedOutputStream(new FileOutputStream(f)))
                        }
                        i.closeEntry
                        loop
                    }
                }
                loop
            }
        }
}

object Compress {
    import    Zip._
    def main(args:Array[String]):Unit =
        try {
            args.size match {
                case 2 => args.first match {
                        case "-d" => decompress(args.last)
                        case _ => compress(args.first, args.last)
                    }
                case _ => throw new IllegalArgumentException("invalid option.")
            }
        } catch {
            case e:IllegalArgumentException => println("usage: Compress {-d SOURCE | SOURCE DSTINATION}")
            case e => e.printStackTrace
        }
}