;;; GNU Guix --- Functional package management for GNU

;;; Copyright © 2018 Julien Lepiller <julien@lepiller.eu>

;;;

;;; This file is part of GNU Guix.

;;;

;;; GNU Guix is free software; you can redistribute it and/or modify it

;;; under the terms of the GNU General Public License as published by

;;; the Free Software Foundation; either version 3 of the License, or (at

;;; your option) any later version.

;;;

;;; GNU Guix is distributed in the hope that it will be useful, but

;;; WITHOUT ANY WARRANTY; without even the implied warranty of

;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

;;; GNU General Public License for more details.

;;;

;;; You should have received a copy of the GNU General Public License

;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.

(define-module (more packages scala)

  #:use-module ((guix licenses) #:prefix license:)

  #:use-module (gnu packages)

  #:use-module (guix packages)

  #:use-module (guix download)

  #:use-module (guix git-download)

  #:use-module (guix utils)

  #:use-module (guix build-system ant)

  #:use-module (guix build-system trivial)

  #:use-module (gnu packages base)

  #:use-module (gnu packages bash)

  #:use-module (gnu packages compression)

  #:use-module (gnu packages java))

;; This package downloads the so-called official version of scala, a pre-built

;; binary by the scala developers.

;; This binary should never be made part of Guix itself, because we have

;; ways to bootstrap it properly. The bootstrap project of scala takes time,

;; so in the meantime... here you are :(

(define-public scala-official

  (package

    (name "scala-official")

    (version "2.12.6")

    (source

      (origin

        (method url-fetch)

        (uri (string-append "https://downloads.lightbend.com/scala/"

                            version "/scala-" version ".tgz"))

        (sha256

         (base32

          "05ili2959yrshqi44wpmwy0dyfm4kvp6i8mlbnj1xvc5b9649iqs"))))

    (build-system trivial-build-system)

    (arguments

     `(#:modules ((guix build utils))

       #:builder (begin

                   (use-modules (guix build utils))

                   (let* ((source (assoc-ref %build-inputs "source"))

                          (java (assoc-ref %build-inputs "icedtea-8"))

                          (bash (assoc-ref %build-inputs "bash"))

                          (tar (string-append

                                 (assoc-ref %build-inputs "tar")

                                 "/bin/tar"))

                          (gzip (assoc-ref %build-inputs "gzip"))

                          (output (assoc-ref %outputs "out"))

                          (bindir (string-append output "/bin")))

                     (mkdir-p output)

                     (setenv "PATH" (string-append (getenv "PATH") ":" gzip "/bin"))

                     (invoke tar "xf" source)

                     (copy-recursively "scala-2.12.6" output)

                     (chdir output)

                     (for-each delete-file (find-files "bin" "bat$"))

                     (substitute* (find-files "bin" ".*")

                       (("^#!.*")

                        (string-append "#!" bash "/bin/bash\n" "JAVA_HOME=" java)))))))

    (inputs

     `(("bash" ,bash)

       ("gzip" ,gzip)

       ("icedtea-8" ,icedtea-8)

       ("tar" ,tar)))

    (home-page "https://scala-lang.org/")

    (synopsis "")

    (description "")

    (license license:bsd-3)))

(define-public sbt-boilerplate-standalone

  (package

    (name "sbt-boilerplate-standalone")

    (version "0.6.1")

    (source (origin

              (method url-fetch)

              (uri (string-append "https://github.com/sbt/sbt-boilerplate/archive/v"

                                  version ".tar.gz"))

              (file-name (string-append name "-" version ".tar.gz"))

              (sha256

               (base32

                "1xzh7qrsl2nmnbyzlmrshzfsf8b4qgf6yaqm1hn3qnzk6761p2jy"))))

    (build-system ant-build-system)

    (arguments

     `(#:tests? #f

       #:jdk ,icedtea-8

       #:phases

       (modify-phases %standard-phases

         (add-before 'build 'add-standalone

           (lambda _

             (substitute* "src/main/scala/spray/boilerplate/Generator.scala"

               (("object Generator \\{")

                "object Generator {

def main(args: Array[String]): Unit = {

    val num = args(2).toInt

    val file = scala.io.Source.fromFile(args(0))

    val content = file.mkString

    val result = new java.io.PrintWriter(new java.io.File(args(1)))

    file.close

    result.write(generateFromTemplate(content, num))

    result.close()

}"))

             #t))

         (replace 'build

           (lambda _

             (mkdir-p "build/classes")

             (mkdir-p "build/jar")

             (invoke "scalac" "-classpath" (getenv "CLASSPATH")

                     "-d" "build/classes"

                     "src/main/scala/spray/boilerplate/Generator.scala"

                     "src/main/scala/spray/boilerplate/TemplateParser.scala")

             (invoke "jar" "-cf" "build/jar/boilerplate.jar"

                     "-C" "build/classes" ".")

             #t))

         (replace 'install

           (install-jars "build")))))

    (native-inputs

     `(("scala" ,scala-official)))

    (home-page "https://github.com/sbt/sbt-boilerplate")

    (synopsis "")

    (description "")

    (license license:bsd-2)))

(define-public scala-sjsonnew

  (package

    (name "scala-sjsonnew")

    (version "0.8.2")

    (source

      (origin

        (method url-fetch)

        (uri (string-append "https://github.com/eed3si9n/sjson-new/archive/v"

                            version ".tar.gz"))

        (file-name (string-append name "-" version ".tar.gz"))

        (sha256

         (base32

          "1rv0c50af5kn27x51g650wl2ig94z52fhs0rn8ykahpz4jhg1p7p"))))

    (arguments

     `(#:tests? #f

       #:jdk ,icedtea-8

       #:phases

       (modify-phases %standard-phases

         (add-before 'build 'generate-boilerplate

           (lambda _

             ; CaseClassFormats.scala.template  FlatUnionFormats.scala.template  TupleFormats.scala.template  UnionFormats.scala.template

             (invoke "java" "-cp" (getenv "CLASSPATH") "spray.boilerplate.Generator"

                     "core/src/main/boilerplate/sjsonnew/CaseClassFormats.scala.template"

                     "core/src/main/scala/sjsonnew/CaseClassFormats.scala" "22")

             (invoke "java" "-cp" (getenv "CLASSPATH") "spray.boilerplate.Generator"

                     "core/src/main/boilerplate/sjsonnew/FlatUnionFormats.scala.template"

                     "core/src/main/scala/sjsonnew/FlatUnionFormats.scala" "22")

             (invoke "java" "-cp" (getenv "CLASSPATH") "spray.boilerplate.Generator"

                     "core/src/main/boilerplate/sjsonnew/TupleFormats.scala.template"

                     "core/src/main/scala/sjsonnew/TupleFormats.scala" "22")

             (invoke "java" "-cp" (getenv "CLASSPATH") "spray.boilerplate.Generator"

                     "core/src/main/boilerplate/sjsonnew/UnionFormats.scala.template"

                     "core/src/main/scala/sjsonnew/UnionFormats.scala" "22")

             #t))

         (replace 'build

           (lambda _

             (mkdir-p "build/classes")

             (apply invoke "scalac" "-classpath" (getenv "CLASSPATH")

                    "-d" "build/classes"

                    (find-files "core/src/main/scala" ".*.scala$"))

             (mkdir-p "build/jar")

             (invoke "jar" "-cf" "build/jar/sjsonnew.jar"

                     "-C" "build/classes" ".")

             #t))

         (replace 'install

           (install-jars "build")))))

    (build-system ant-build-system)

    (native-inputs

     `(("scala" ,scala-official)

       ("sbt-boilerplate-standalone" ,sbt-boilerplate-standalone)))

    (home-page "")

    (synopsis "")

    (description "")

    (license license:asl2.0)))

(define-public scala-kind-projector

  (package

    (name "scala-kind-projector")

    (version "0.9.7")

    (source (origin

              (method url-fetch)

              (uri (string-append "https://github.com/non/kind-projector/archive/v"

                                  version ".tar.gz"))

              (file-name (string-append name "-" version ".tar.gz"))

              (sha256

               (base32

                "176g2d7ix2asp94ch39mza84k6z8by308hzglxs8933j8byramff"))))

    (build-system ant-build-system)

    (arguments

     `(#:jdk ,icedtea-8

       #:phases

       (modify-phases %standard-phases

         (replace 'build

           (lambda _

             (mkdir-p "build/classes")

             (mkdir-p "build/jar")

             (copy-recursively "src/main/resources" "build/classes")

             (apply invoke "scalac" "-classpath" (getenv "CLASSPATH")

                    "-d" "build/classes"

                    (find-files "src/main/scala" ".*.scala$"))

             (invoke "jar" "-cf" "build/jar/kind-projector.jar"

                     "-C" "build/classes" ".")

             #t))

         (replace 'check

           (lambda _

             (mkdir-p "build/test-classes")

             (copy-recursively "src/test/resources" "build/test-classes")

             (apply invoke "scalac" "-classpath" (getenv "CLASSPATH")

                    "-Xplugin:build/jar/kind-projector.jar"

                    "-d" "build/test-classes"

                    (find-files "src/test/scala" ".*.scala$"))

             ;; TODO: actually run the tests... :D

             #t))

         (replace 'install

           (install-jars "build")))))

    (native-inputs

     `(("scala-official" ,scala-official)

       ("java-junit" ,java-junit)))

    (home-page "https://github.com/non/kind-projector")

    (synopsis "Scala compiler plugin for type lambda")

    (description "Kind projector is a Scala compiler plugin for making type

lambdas (type projections) easier to write.")

    (license license:expat)))

(define-public sbt-util-position

  (package

    (name "sbt-util-position")

    (version "1.2.2")

    (source

      (origin

        (method url-fetch)

        (uri (string-append "https://github.com/sbt/util/archive/v"

                            version ".tar.gz"))

        (file-name (string-append "sbt-util-" version ".tar.gz"))

        (sha256

         (base32

          "1mj6ny62crq1d8850lkj00g3wsjhflaxrqiiv72b02fb8hn671dh"))))

    (build-system ant-build-system)

    (arguments

     `(#:tests? #f

       #:jdk ,icedtea-8

       #:phases

       (modify-phases %standard-phases

         (replace 'build

           (lambda* (#:key inputs #:allow-other-keys)

             (define (build-subproject prefix name)

               (let ((build-directory (string-append "build/" name))

                     (jar-name (string-append name ".jar")))

                 (mkdir-p build-directory)

                 (format #t "Building project ~a...~%" name)

                 (apply invoke "scalac" "-classpath"

                        (string-append (getenv "CLASSPATH") ":build/util-interface")

                        "-d" build-directory "-language:experimental.macros"

                        (find-files (string-append prefix name "/src/main/scala")

                                    ".*.scala$"))

                 (invoke "jar" "cf" jar-name "-C" build-directory ".")))

             (build-subproject "internal/" "util-position")

             #t))

         (replace 'install

           (install-jars ".")))))

    (inputs

     `(("java-log4j-api" ,java-log4j-api)

       ("java-log4j-core" ,java-log4j-core)

       ("scala" ,scala-official)

       ("scala-sjsonnew" ,scala-sjsonnew)))

    (home-page "https://www.scala-sbt.org/")

    (synopsis "")

    (description "")

    (license license:bsd-3)))

(define-public sbt-util-control

  (package

    (inherit sbt-util-position)

    (name "sbt-util-control")

    (arguments

     `(#:tests? #f

       #:jdk ,icedtea-8

       #:phases

       (modify-phases %standard-phases

         (replace 'build

           (lambda* (#:key inputs #:allow-other-keys)

             (define (build-subproject prefix name)

               (let ((build-directory (string-append "build/" name))

                     (jar-name (string-append name ".jar")))

                 (mkdir-p build-directory)

                 (format #t "Building project ~a...~%" name)

                 (apply invoke "scalac" "-classpath"

                        (string-append (getenv "CLASSPATH") ":build/util-interface")

                        "-d" build-directory "-language:experimental.macros"

                        (find-files (string-append prefix name "/src/main/scala")

                                    ".*.scala$"))

                 (invoke "jar" "cf" jar-name "-C" build-directory ".")))

             (build-subproject "internal/" "util-control")

             #t))

         (replace 'install

           (install-jars ".")))))))

(define-public sbt-util-interface

  (package

    (inherit sbt-util-position)

    (name "sbt-util-interface")

    (arguments

     `(#:tests? #f

       #:jdk ,icedtea-8

       #:source-dir "internal/util-interface/src/main/java"

       #:jar-name "util-interface.jar"))))

(define-public java-log4j-api-for-sbt

  (package

    (inherit java-log4j-api)

    (version "2.8.1")

    (source (origin

              (method url-fetch)

              (uri (string-append "mirror://apache/logging/log4j/" version

                                  "/apache-log4j-" version "-src.tar.gz"))

              (sha256

               (base32

                "0x5gksgh0jkvd7k70rqrs2hy3glms0pkj6lhl26m6f83x1b6kvdm"))))))

;; More dependencies needed

(define-public java-log4j-core-for-sbt

  (package

    (inherit java-log4j-api-for-sbt)

    (name "java-log4j-core")

    (inputs

     `(("java-osgi-core" ,java-osgi-core)

       ("java-hamcrest-core" ,java-hamcrest-core)

       ("java-log4j-api" ,java-log4j-api-for-sbt)

       ("java-mail" ,java-mail)

       ("java-jboss-jms-api-spec" ,java-jboss-jms-api-spec)

       ("java-lmax-disruptor" ,java-lmax-disruptor)

       ("java-kafka" ,java-kafka-clients)

       ("java-datanucleus-javax-persistence" ,java-datanucleus-javax-persistence)

       ("java-fasterxml-jackson-annotations" ,java-fasterxml-jackson-annotations)

       ("java-fasterxml-jackson-core" ,java-fasterxml-jackson-core)

       ("java-fasterxml-jackson-databind" ,java-fasterxml-jackson-databind)

       ("java-fasterxml-jackson-dataformat-xml" ,java-fasterxml-jackson-dataformat-xml)

       ("java-fasterxml-jackson-dataformat-yaml" ,java-fasterxml-jackson-dataformat-yaml)

       ("java-commons-compress" ,java-commons-compress)

       ("java-commons-csv" ,java-commons-csv)

       ("java-jeromq" ,java-jeromq)

       ("java-junit" ,java-junit)))

    (native-inputs

     `(("hamcrest" ,java-hamcrest-all)

       ("java-commons-io" ,java-commons-io)

       ("java-commons-lang3" ,java-commons-lang3)

       ("slf4j" ,java-slf4j-api)))

    (arguments

     `(#:tests? #f ; tests require more dependencies

       #:test-dir "src/test"

       #:source-dir "src/main/java"

       #:jar-name "log4j-core.jar"

       #:jdk ,icedtea-8

       #:make-flags

       (list (string-append "-Ddist.dir=" (assoc-ref %outputs "out")

                            "/share/java"))

       #:phases

       (modify-phases %standard-phases

         (add-after 'unpack 'enter-dir

           (lambda _ (chdir "log4j-core") #t)))))

    (synopsis "Core component of the Log4j framework")

    (description "This package provides the core component of the Log4j

logging framework for Java.")))

(define-public sbt-util-logging

  (package

    (inherit sbt-util-position)

    (name "sbt-util-logging")

    (arguments

     `(#:tests? #f

       #:jdk ,icedtea-8

       #:phases

       (modify-phases %standard-phases

         (replace 'build

           (lambda* (#:key inputs #:allow-other-keys)

             (define (build-subproject prefix name)

               (let ((build-directory (string-append "build/" name))

                     (jar-name (string-append name ".jar")))

                 (mkdir-p build-directory)

                 (format #t "Building project ~a...~%" name)

                 (apply invoke "scalac" "-classpath"

                        (string-append (getenv "CLASSPATH") ":build/util-interface")

                        "-d" build-directory "-language:experimental.macros"

                        (append

                          (find-files (string-append prefix name "/src/main/contraband-scala")

                                      ".*.scala$")

                          (find-files (string-append prefix name "/src/main/scala")

                                      ".*.scala$")))

                 (invoke "jar" "cf" jar-name "-C" build-directory ".")))

             (build-subproject "internal/" "util-logging")

             #t))

         (replace 'install

           (install-jars ".")))))

    (inputs

     `(("java-log4j-api" ,java-log4j-api-for-sbt)

       ;("java-log4j-core" ,java-log4j-core)

       ("sbt-util-interface" ,sbt-util-interface)

       ("scala-")))

    (native-inputs

     `(("scala-official" ,scala-official)))))

(define-public java-swoval-apple-file-events

  (package

    (name "java-swoval-apple-file-events")

    (version "1.3.2")

    (source (origin

              (method url-fetch)

              (uri (string-append "https://github.com/swoval/swoval/archive/v"

                                  version ".tar.gz"))

              (file-name (string-append "scala-swoval-" version ".tar.gz"))

              (sha256

               (base32

                "0ivrc4lcali84xp8frkjb2zi1l3lw8pim9xbkfah5iyj120gw6mq"))))

    (build-system ant-build-system)

    (arguments

     `(#:jdk ,icedtea-8

       #:tests? #f; no tests

       #:jar-name "apple-file-events.jar"

       #:source-dir "apple-file-events/jvm/src/main/java"))

    (home-page "")

    (synopsis "")

    (description "")

    (license license:expat)))

(define-public sbt-io

  (package

    (name "sbt-io")

    (version "1.2.1")

    (source

      (origin

        (method url-fetch)

        (uri (string-append "https://github.com/sbt/io/archive/v"

                            version ".tar.gz"))

        (file-name (string-append name "-" version ".tar.gz"))

        (sha256

         (base32

          "0cgk3y3w8yjpivi910px529bz8bil49lrnib6wbwmvq8lw8mgrwq"))))

    (build-system ant-build-system)

    (arguments

     `(#:tests? #f

       #:jdk ,icedtea-8

       #:phases

       (modify-phases %standard-phases

         (replace 'build

           (lambda* (#:key inputs #:allow-other-keys)

             (mkdir-p "build/classes")

             (apply invoke "scalac" "-classpath"

                    (string-append (getenv "CLASSPATH") ":build/util-interface")

                    "-d" "build/classes"

                    (append

                      (find-files "io/src/main/java" ".*.java$")

                      (find-files "io/src/main/scala" ".*.scala$")

                      (find-files "io/src/main/contraband-scala" ".*.scala$")))

             (invoke "jar" "cf" "sbt-io.jar" "-C" "build/classes" ".")

             #t))

         (replace 'install

           (install-jars ".")))))

    (inputs

     `(("java-native-access" ,java-native-access)

       ("java-native-access-platform" ,java-native-access-platform)

       ("java-swoval-apple-file-events" ,java-swoval-apple-file-events)

       ("scala" ,scala-official)))

    (home-page "https://www.scala-sbt.org/")

    (synopsis "")

    (description "")

    (license license:bsd-3)))

(define-public sbt

  (package

    (name "sbt")

    (version "1.2.1")

    (source

      (origin

        (method url-fetch)

        (uri (string-append "https://github.com/sbt/sbt/archive/v"

                            version ".tar.gz"))

        (file-name (string-append name "-" version ".tar.gz"))

        (sha256

         (base32

          "15i8fd7zgairaaikscrva8d1klz0w9nh7fc0896x1n8nrs578vmy"))))

    (build-system ant-build-system)

    (arguments

     `(#:tests? #f

       #:jdk ,icedtea-8

       #:phases

       (modify-phases %standard-phases

         (add-before 'build 'copy-resources

           (lambda _

             (copy-recursively "sbt/src/main/resources" "build/classes")

             #t))

         (add-before 'build 'generate-scalakeywords.scala

           (lambda _

             (with-output-to-file "project/WriteKeywords.scala"

               (lambda _

                 (format #t "package project

object WriteKeywords {

  def main(arg: Array[String]): Unit = {

    val g = new scala.tools.nsc.Global(new scala.tools.nsc.Settings)

    val keywords = g.nme.keywords.map(_.toString)

    val init = keywords.map(tn => '\"' + tn + '\"').mkString(\"Set(\", \", \", \")\")

    val ObjectName = \"ScalaKeywords\"

    val PackageName = \"sbt.internal.util\"

    val keywordsSrc = s\"\"\"

      |package $PackageName

      |object $ObjectName {

      |  val values = $init

      |}

    \"\"\".trim.stripMargin

    val base = \"internal/util-collection/src/main/scala\"

    val out = base + \"/\" + PackageName.replace('.', '/') + \"/\" + s\"$ObjectName.scala\"

    val result = new java.io.PrintWriter(new java.io.File(out))

    result.write(keywordsSrc)

    result.close()

  }

}")))

             (invoke "scalac" "-classpath" (getenv "CLASSPATH") "project/WriteKeywords.scala")

             (invoke "java" "-cp" (string-append (getenv "CLASSPATH") ":.")

                     "project.WriteKeywords")

             #t))

         (replace 'build

           (lambda* (#:key inputs #:allow-other-keys)

             (define (build-subproject prefix name)

               (let ((build-directory (string-append "build/" name))

                     (jar-name (string-append name ".jar"))

                     (kind-projector (assoc-ref inputs "scala-kind-projector")))

                 (mkdir-p build-directory)

                 (format #t "Building project ~a...~%" name)

                 (apply invoke "scalac" "-classpath"

                        ;; 13:36 < snape> roptat: I think you could use 'readdir', as in 'files-in-directory' from guix/build/union.scm

                        (apply string-append (getenv "CLASSPATH")

                               (map (lambda (file) (string-append ":" file))

                                    (find-files "build" "." #:directories? #t)))

                        "-d" build-directory

                        (string-append "-Xplugin:" kind-projector

                                       "/share/java/kind-projector.jar")

                        (find-files (string-append prefix name "/src/main/scala")

                                    ".*.scala$"))

                 (invoke "jar" "cf" jar-name "-C" build-directory ".")))

             (build-subproject "internal/" "util-collection")

             (build-subproject "internal/" "util-complete")

             (build-subproject "" "core-macros")

             (build-subproject "" "tasks")

             (build-subproject "" "tasks-standard")

             (build-subproject "" "main-settings")

             (build-subproject "" "sbt")

             #t))

         (replace 'install

           (install-jars ".")))))

    (inputs

     `(("scala" ,scala-official)

       ("scala-sjsonnew" ,scala-sjsonnew)

       ("sbt-io" ,sbt-io)

       ("sbt-util-control" ,sbt-util-control)

       ("sbt-util-interface" ,sbt-util-interface)

       ("sbt-util-logging" ,sbt-util-logging)

       ("sbt-util-position" ,sbt-util-position)))

    (native-inputs

     `(("scala-kind-projector" ,scala-kind-projector)))

    (home-page "https://www.scala-sbt.org/")

    (synopsis "")

    (description "")

    (license license:bsd-3)))