;; This class depends on javarebel, a non-free package

    (home-page "")

             (for-each

               (lambda (proto)

                 (invoke "protoc" "--java_out=java/core/src/main/java" "-Isrc"

                         (string-append "src/google/protobuf/" proto ".proto")))

                 '("any" "api" "descriptor" "duration" "empty" "field_mask"

                   "source_context" "struct" "timestamp" "type" "wrappers"))

                     "src/google/protobuf/compiler/plugin.proto")

(define-public java-picocli

  (package

    (name "java-picocli")

    (version "3.8.2")

    (source (origin

              (method url-fetch)

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

                                  version ".tar.gz"))

              (sha256

               (base32

                "0rbk4kccy8qd2gnrfk9455rp48ign82h9a5n98ry4ac1i1x2ffax"))))

    (build-system ant-build-system)

    (arguments

     `(#:jar-name "picocli.jar"

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

       ;; Require org.junit.contrib.java.lang.system.*

       #:tests? #f

       #:phases

       (modify-phases %standard-phases

         (add-before 'build 'remove-groovy-dependency

           (lambda _

	     ;; Groovy depends on picocli, so remove a cyclic dependency here

	     (delete-file-recursively "src/main/java/picocli/groovy")

	     #t)))))

    (native-inputs

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

    (home-page "")

    (synopsis "")

    (description "")

    (license license:asl2.0)))

(define-public java-protoc-jar

  (package

    (name "java-protoc-jar")

    (version "3.6.0.1")

    (source (origin

              (method url-fetch)

              (uri (string-append "https://github.com/os72/protoc-jar/archive/v"

                                  version ".tar.gz"))

              (sha256

               (base32

                "13q9cvplsbv9jxx5myiir4hdlhclgr9ka6c9x9f022hcn0lzgjpw"))

              (modules '((guix build utils)))

              (snippet

               `(delete-file-recursively "bin"))))

    (build-system ant-build-system)

    (arguments

     `(#:jar-name "protoc-jar.jar"

       #:tests? #f; require network

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

       #:phases

       (modify-phases %standard-phases

         (add-before 'build 'embed-protoc

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

             (let* ((dir (string-append "build/classes/bin/" ,(package-version protobuf)))

                    (file (string-append dir "/protoc-" ,(package-version protobuf)

                                         "-linux-" (string-drop-right system 6) ".exe")))

               (mkdir-p dir)

               (copy-file (string-append (assoc-ref inputs "protobuf") "/bin/protoc") file))

             #t)))))

    (inputs

     `(("protobuf" ,protobuf)))

    (native-inputs

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

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

    (home-page "")

    (synopsis "")

    (description "")

    (license license:asl2.0)))

(define-public java-fmpp

  (package

    (name "java-fmpp")

    (version "0.9.16")

    (source (origin

              (method url-fetch)

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

                                  version ".tar.gz"))

              (sha256

               (base32

                "0k66qq8mss165mqbn3gs537xgqx74rch6zx335d415vd4h9d83va"))

              (patches

                (search-patches "java-fmpp-remove-imageinfo.patch"))

              (modules '((guix build utils)))

              (snippet

               ;; NOTE: the bin/ directory only contain scripts

               `(begin

                  (delete-file-recursively "lib")

                  #t))))

    (build-system ant-build-system)

    (arguments

     `(#:test-target "test"

       #:phases

       (modify-phases %standard-phases

         (add-before 'build 'set-modification-time

           (lambda _

             ;; This software assumes that a modification date of 0 means

             ;; that it failed to get the modification time. Guix sets

             ;; a modification time of 0, which leads to test failures.

             (for-each (lambda (file) (utime file 1 1)) (find-files "src" "."))

             #t))

         (add-before 'build 'create-lib

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

             (mkdir-p "lib")

             (copy-file (string-append (assoc-ref inputs "java-apache-freemarker")

                                       "/share/java/java-apache-freemarker.jar")

                        "lib/freemarker.jar")

             (copy-file (string-append (assoc-ref inputs "ant") "/lib/ant.jar")

                        "lib/ant.jar")

             (copy-file (string-append (assoc-ref inputs "java-junit")

                                       "/share/java/junit.jar")

                        "lib/junit.jar")

             (copy-file (string-append (assoc-ref inputs "java-hamcrest-all")

                                       "/share/java/hamcrest-all.jar")

                        "lib/hamcrest-generator-nodeps.jar")

             (copy-file (car (find-files (string-append (assoc-ref inputs "java-bsh")

                                                        "/share/java/")

                                         ".*.jar$"))

                        "lib/bsh.jar")

             (copy-file (car (find-files (string-append

                                           (assoc-ref

                                             inputs

                                             "java-apache-xml-commons-resolver")

                                           "/share/java/")

                                         ".*.jar$"))

                        "lib/resolver.jar")

             #t))

         (add-before 'build 'fix-class-path

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

             ;; The result otherwise requires its dependencies alongside it.

             (with-fluids ((%default-port-encoding "ISO-8859-1"))

               (substitute* "build.xml"

                 ;; Also fix embedded timestamp

                 (("\\$\\{timeStamp\\}") "1970-01-01T00:00:00Z")

                 ((" imageinfo.jar") "")

                 (("freemarker.jar ")

                  (string-append

                    ;; In java8, we can only refer to jar files relatively to

                    ;; the current jar...

                    "../../../../../../../../../../"

                    (car (find-files

                           (assoc-ref inputs "java-apache-freemarker")

                           "freemarker.jar"))

                    " "))

                 (("bsh.jar ")

                  (string-append

                    "../../../../../../../../../../"

                    (car (find-files (assoc-ref inputs "java-bsh") ".*.jar$"))

                    " "))

                 ((" resolver.jar")

                  (string-append

                    " ../../../../../../../../../../"

                    (car (find-files

                           (assoc-ref inputs "java-apache-xml-commons-resolver")

                           ".*.jar$"))))))

             #t))

         (replace 'install

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

             (let* ((out (assoc-ref outputs "out"))

                    (java (string-append out "/lib"))

                    (bin (string-append out "/bin")))

               (install-file "lib/fmpp.jar" java)

               (substitute* "bin/fmpp"

                 (("#!.*")

                  (string-append "#!" (which "sh") "\n"

                                 "JAVA_HOME=" (assoc-ref inputs "jdk"))))

               (install-file "bin/fmpp" bin)

               (chmod (string-append bin "/fmpp") #o755))

             #t)))))

    (inputs

     `(("java-apache-freemarker" ,java-apache-freemarker)

       ("java-apache-xml-commons-resolver" ,java-apache-xml-commons-resolver)

       ("java-bsh" ,java-bsh)))

    (native-inputs

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

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

    (home-page "")

    (synopsis "")

    (description "")

    (license license:asl2.0)))

  #:use-module (gnu packages protobuf)

    (version "2.12.8")

          "18w0vdbsp0q5rxglgalwlgkggld926bqi1fxc598rn4gh46a03j4"))))

                     (copy-recursively "scala-2.12.8" output)

;; TODO: put it in guix/build/java-utils.scm

;; TODO: remove contraband-* directories and regenerate them from contraband/

(define (sbt-building-phase subprojects)

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

     (define (build-subproject prefix name)

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

             (jar-name (string-append

                         (if (> (string-length prefix) 0)

                           (string-replace prefix "-" (- (string-length prefix) 1))

                           "")

                         name ".jar"))

             (java-files

                (append

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

                              ".*.java$")

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

                              ".*.java$")))

             (scala-files

                (append

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

                              ".*.scala$")

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

                              ".*.scala$"))))

         (mkdir-p build-directory)

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

         (unless (eq? scala-files '())

           (apply invoke "scalac" "-classpath"

                  (string-append

                    (getenv "CLASSPATH") ":"

                    ;; Add any top-level directory in build that may contain

                    ;; .class files, but don't actually add build/ iteself or

                    ;; any individual class file.

                    (string-join

                      (filter (lambda (s) (eq? (string-count s #\/) 1))

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

                      ":"))

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

                  (append scala-files java-files)))

         (unless (eq? java-files '())

           (apply invoke "javac" "-classpath"

                  (string-append

                    (getenv "CLASSPATH") ":"

                    (string-join

                      (filter (lambda (s) (eq? (string-count s #\/) 1))

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

                      ":"))

                  "-d" build-directory java-files))

         (invoke "jar" "cf" (string-append "build/jar/" jar-name)

                 "-C" build-directory ".")))

     (mkdir-p "build/jar")

     (for-each (lambda (project)

                   (build-subproject (car project) (cadr project)))

       '(,@subprojects))

     #t))

    (version "0.9.9")

                "125amrhy7ri0z4bk2jzghg7341fm88a0p6gw3qg5diminlpaida3"))))

     `(#:phases

(define-public sbt-util

    (name "sbt-util")

    (version "1.2.4")

          "04ss1q4rl272ryxys05zmd4j2gm3aanaiqn6dmqbh6jii934pyxg"))))

         (add-before 'build 'fix-sjsonnew

           (lambda _

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

               (("sjsonnew.shaded.") ""))

         (replace 'build

           ,(sbt-building-phase

              '(("internal/" "util-position")

                ("internal/" "util-control")

                ("internal/" "util-interface")

                ("internal/" "util-logging")

                ("internal/" "util-relation")

                ("internal/" "util-scripted")

                ("" "util-cache")

                ("" "util-tracking"))))

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

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

       ("sbt-io" ,sbt-io)

       ("scala-jawn" ,scala-jawn)

       ("scala-scalajson" ,scala-scalajson)

       ("scala-sjsonnew" ,scala-sjsonnew)

       ("scala-sjsonnew-support-murmurhash" ,scala-sjsonnew-support-murmurhash)

       ("scala-sjsonnew-support-scalajson" ,scala-sjsonnew-support-scalajson)))

    (native-inputs

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

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

;; TODO: Update to 2.0.6?

     `(#:tests? #f; no tests

    (version "1.2.2")

          "0f9yjrrcr15kx2fn7w8f8swpx2dsx5zn95yg744l9gi2ri2qpyj5"))))

    (version "0.3.7")

                "0sg477705flhcdnhjyl8v9jkhx1xfsnc73md8iva1agylpj5546f"))))

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

       ("java-okhttp" ,java-okhttp)

       ("java-okio" ,java-okio)

(define-public sbt-launcher

  (package

    (name "sbt-launcher")

    (version "1.0.4")

    (source (origin

              (method url-fetch)

              (uri (string-append "https://github.com/sbt/launcher/archive/v" version ".tar.gz"))

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

              (sha256

               (base32

                "1a9dfqm47fn2nbqvjl723s0h16jf71cgnilg1i7gz6h4a7i0snak"))))

    (build-system ant-build-system)

    (arguments

     `(#:tests? #f

       #:phases

       (modify-phases %standard-phases

         (replace 'build

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

             (substitute* "launcher-implementation/src/main/input_sources/CrossVersionUtil.scala"

               (("\\$\\{\\{cross.package0\\}\\}") "xsbt")

               (("\\$\\{\\{cross.package1\\}\\}") "boot"))

             (mkdir-p "build/classes")

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

                    "-d" "build/classes"

                    (append

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

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

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

             (apply invoke "javac" "-cp" (string-append (getenv "CLASSPATH") ":build/classes")

                    "-d" "build/classes"

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

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

             #t))

         (replace 'install

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

    (inputs

     `(("java-apache-ivy" ,java-apache-ivy)))

    (native-inputs

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

    (home-page "")

    (synopsis "")

    (description "")

    (license license:bsd-3)))

    (version "1.2.4")

                "0g37agv3xkq1fjl9a25ybcdk4d5aq1m81rz5d2a8zvny135m73gl"))

              (modules '((guix build utils)))

              (snippet

                `(for-each delete-file (find-files "." ".*.jar")))))

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

     `(("sbt-launcher" ,sbt-launcher)

       ("sbt-util" ,sbt-util)

;; LICENSE?

(define-public scala-protoc-bridge

  (package

    (name "scala-protoc-bridge")

    (version "0.7.3")

    (source

      (origin

        (method url-fetch)

        (uri (string-append "https://github.com/scalapb/protoc-bridge/archive/v"

                            version ".tar.gz"))

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

        (sha256

         (base32

          "17xjsa70h0w80rhps00kj42fmghk98c789aaa19g4bii2j1ckry8"))))

    (build-system ant-build-system)

    (arguments

     `(#:phases

       (modify-phases %standard-phases

         (add-before 'build 'fix-script

           (lambda _

             (substitute* "src/main/scala/protocbridge/frontend/PosixPluginFrontend.scala"

               (("/usr/bin/env sh") (which "sh")))

             #t))

         (replace 'build

           (lambda _

             (mkdir-p "build/classes")

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

                    "-d" "build/classes"

                    (append

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

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

             (apply invoke "javac" "-cp" (string-append (getenv "CLASSPATH") ":build/classes")

                    "-d" "build/classes"

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

             (mkdir-p "build/jar")

             (invoke "jar" "-cf" "build/jar/protoc-bridge.jar"

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

             #t))

         (replace 'check

           (lambda _

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

             ;(apply invoke "scalac" "-classpath" (string-append (getenv "CLASSPATH")

             ;                                                   ":build/classes")

             ;       "-d" "build/test-classes"

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

             ;; TODO: actually run the tests

             #t))

         (replace 'install

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

    (native-inputs

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

    (home-page "")

    (synopsis "")

    (description "")

    (license license:bsd-3)))

(define-public scala-sourcecode

  (package

    (name "scala-sourcecode")

    (version "0.1.5")

    (source (origin

              (method url-fetch)

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

                                  version ".tar.gz"))

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

              (sha256

               (base32

                "1cq15cxsv0j6xdrl566ywmab5il3239ja4cbgm39ihyn0yw2q1q4"))))

    (build-system ant-build-system)

    (arguments

     `(#:tests? #f; in sourcecode/shared/src/test

       #:phases

       (modify-phases %standard-phases

         (add-before 'build 'copy-compat

           (lambda _

             (with-directory-excursion "sourcecode/shared/src/main"

               (copy-file "scala-2.11/sourcecode/Compat.scala"

                          "scala/sourcecode/Compat.scala"))

             #t))

         (replace 'build

           (lambda _

             (mkdir-p "build/classes")

             (mkdir-p "build/jar")

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

                    "-d" "build/classes"

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

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

             #t))

         (replace 'install

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

    (native-inputs

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

    (home-page "")

    (synopsis "")

    (description "")

    (license license:expat)))

(define-public scala-acyclic

  (package

    (name "scala-acyclic")

    (version "0.1.8")

    (source (origin

              (method url-fetch)

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

                                  version ".tar.gz"))

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

              (sha256

               (base32

                "0c26qnjfhihn06sf17bxskacjcr51s03ygcmj8fp5vdzgcyfh7dl"))))

    (build-system ant-build-system)

    (arguments

     `(#:tests? #f; in sourcecode/shared/src/test

       #:phases

       (modify-phases %standard-phases

         (add-before 'build 'copy-compat

           (lambda _

             (with-directory-excursion "src/main"

               (copy-file "scala-2.10_2.12/acyclic/plugin/Compat.scala"

                          "scala/acyclic/plugin/Compat.scala"))

             #t))

         (replace 'build

           (lambda _

             (mkdir-p "build/classes")

             (mkdir-p "build/jar")

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

                    "-d" "build/classes"

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

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

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

             #t))

         (replace 'install

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

    (native-inputs

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

    (home-page "")

    (synopsis "")

    (description "")

    (license license:expat)))

(define-public scala-fastparse

  (package

    (name "scala-fastparse")

    (version "2.1.0")

    (source (origin

              (method url-fetch)

              (uri (string-append "https://github.com/lihaoyi/fastparse/archive/"

                                  version ".tar.gz"))

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

              (sha256

               (base32

                "1h8s3izykv3x2g7klihk03mbnjcp23f2613827y62kdk6x9q6yjs"))))

    (build-system ant-build-system)

    (arguments

     `(#:tests? #f; in fastpares/test/src

       #:modules

       ((guix build ant-build-system)

        (guix build java-utils)

        (guix build utils)

        (srfi srfi-1))

       #:imported-modules

       ((srfi srfi-1) ; for iota

        ,@%ant-build-system-modules)

       #:phases

       (modify-phases %standard-phases

         (add-before 'build 'generate-sources

           (lambda _

             (define (tuple num)

               (let* ((ts (map (lambda (n) (string-append "T" (number->string n)))

                               (iota num 1)))

                      (chunks (map (lambda (n)

                                     (string-append "t._" (number->string n)))

                                   (iota num 1)))

                      (chunkss (string-join chunks ", "))

                      (tsD (string-join (reverse (cons "D" (reverse ts))) ","))

                      (anys (string-join (map (const "Any") ts) ", "))

                      (tss (string-join ts ", ")))

                 (format #t "

val BaseSequencer~a: Sequencer[(~a), Any, (~a, Any)] =

  Sequencer0((t, d) => (~a, d))

implicit def Sequencer~a[~a]: Sequencer[(~a), D, (~a)] =

  BaseSequencer~a.asInstanceOf[Sequencer[(~a), D, (~a)]]

" num anys anys chunkss num tsD tss tsD num tss tsD)))

             (with-output-to-file "fastparse/src/fastparse/SequencerGen.scala"

               (lambda _

                 (format #t "package fastparse

trait SequencerGen[Sequencer[_, _, _]] extends LowestPriSequencer[Sequencer]{

  protected[this] def Sequencer0[A, B, C](f: (A, B) => C): Sequencer[A, B, C]

")

                 (for-each tuple (iota 20 2))

                 (format #t "}

trait LowestPriSequencer[Sequencer[_, _, _]]{

  protected[this] def Sequencer0[A, B, C](f: (A, B) => C): Sequencer[A, B, C]

  implicit def Sequencer1[T1, T2]: Sequencer[T1, T2, (T1, T2)] = Sequencer0{case (t1, t2) => (t1, t2)}

}

")))

             #t))

         (replace 'build

           (lambda _

             (mkdir-p "build/classes")

             (mkdir-p "build/jar")

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

                    "-d" "build/classes"

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

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

             #t))

         (replace 'install

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

    (inputs

     `(("scala-sourcecode" ,scala-sourcecode)))

    (native-inputs

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

    (home-page "")

    (synopsis "")

    (description "")

    (license license:expat)))

(define-public scala-fastparse1

  (package

    (inherit scala-fastparse)

    (version "1.0.0")

    (source (origin

              (method url-fetch)

              (uri (string-append "https://github.com/lihaoyi/fastparse/archive/"

                                  version ".tar.gz"))

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

              (sha256

               (base32

                "14d44f23hl6ypfwlvnzkzcvv52a0xipm5wkp2glr184aik7w5pnb"))))

    (arguments

     `(#:tests? #f; in fastpares/test/src

       #:modules

       ((guix build ant-build-system)

        (guix build java-utils)

        (guix build utils)

        (srfi srfi-1))

       #:imported-modules

       ((srfi srfi-1) ; for iota

        ,@%ant-build-system-modules)

       #:phases

       (modify-phases %standard-phases

         (add-before 'build 'copy-compat

           (lambda _

             (with-directory-excursion "utils/shared/src/main"

               (copy-file "scala-2.11/fastparse/utils/Compat.scala"

                          "scala/fastparse/utils/Compat.scala"))

             #t))

         (add-before 'build 'generate-sources

           (lambda _

             (define (tuple num)

               (let* ((ts (map (lambda (n) (string-append "T" (number->string n)))

                               (iota num 1)))

                      (chunks (map (lambda (n)

                                     (string-append "t._" (number->string n)))

                                   (iota num 1)))

                      (chunkss (string-join chunks ", "))

                      (tsD (string-join (reverse (cons "D" (reverse ts))) ","))

                      (anys (string-join (map (const "Any") ts) ", "))

                      (tss (string-join ts ", ")))

                 (format #t "

val BaseSequencer~a: Sequencer[(~a), Any, (~a, Any)] =

  Sequencer0((t, d) => (~a, d))

implicit def Sequencer~a[~a]: Sequencer[(~a), D, (~a)] =

  BaseSequencer~a.asInstanceOf[Sequencer[(~a), D, (~a)]]

" num anys anys chunkss num tsD tss tsD num tss tsD)))

             (with-output-to-file

               "fastparse/shared/src/main/scala/fastparse/core/SequencerGen.scala"

               (lambda _

                 (format #t "package fastparse.core

trait SequencerGen[Sequencer[_, _, _]] extends LowestPriSequencer[Sequencer]{

  protected[this] def Sequencer0[A, B, C](f: (A, B) => C): Sequencer[A, B, C]

")

                 (for-each tuple (iota 20 2))

                 (format #t "}

trait LowestPriSequencer[Sequencer[_, _, _]]{

  protected[this] def Sequencer0[A, B, C](f: (A, B) => C): Sequencer[A, B, C]

  implicit def Sequencer1[T1, T2]: Sequencer[T1, T2, (T1, T2)] = Sequencer0{case (t1, t2) => (t1, t2)}

}

")))

             #t))

         (replace 'build

           (lambda _

             (mkdir-p "build/classes")

             (mkdir-p "build/jar")

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

                    "-d" "build/classes"

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

             (apply invoke "scalac" "-classpath"

                    (string-append (getenv "CLASSPATH") ":build/classes")

                    "-d" "build/classes"

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

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

             #t))

         (replace 'install

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

    (inputs

     `(("scala-acyclic" ,scala-acyclic)

       ("scala-sourcecode" ,scala-sourcecode)))))

;; LICENSE?

(define-public scala-protobuf

  (package

    (name "scala-protobuf")

    (version "0.8.3")

    (source (origin

              (method url-fetch)

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

                                  version ".tar.gz"))

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

              (sha256

               (base32

                "0x6mfpyhzxh54dxh1pj3x952gyvp05m7vkj0c3p8ssx214r327kj"))

              (modules '((guix build utils)))

              (snippet

                `(delete-file-recursively "third_party"))))

    (build-system ant-build-system)

    (arguments

     `(#:tests? #f; TODO

       #:phases

       (modify-phases %standard-phases

         (add-before 'build 'generate-sources

           (lambda _

             (with-output-to-file "compiler-plugin/src/main/scala/scalapb/compiler/Version.scala"

               (lambda _

                 (format #t "package scalapb.compiler

object Version {

  val scalapbVersion = \"~a\"

  val protobufVersion = \"~a\"

  val grpcJavaVersion = \"~a\"

}" ,version ,(package-version protobuf) "TODO")))

             (mkdir-p "compiler-plugin/src/main/scala/scalapb/compiler/internal")

             (copy-file

               "scalapb-runtime/shared/src/main/scala/scalapb/Encoding.scala"

               "compiler-plugin/src/main/scala/scalapb/compiler/internal/Encoding.scala")

             (substitute* "compiler-plugin/src/main/scala/scalapb/compiler/internal/Encoding.scala"

               (("package scalapb") "package scalapb.internal"))

             #t))

         (add-before 'build 'merge-runtime

           (lambda _

             (copy-recursively "scalapb-runtime/shared/src" "scalapb-runtime/src")

             (copy-recursively "scalapb-runtime/jvm/src" "scalapb-runtime/src")

             #t))

         (add-before 'build 'copy-compat

           (lambda _

             (with-directory-excursion "scalapb-runtime/src/main"

               (copy-file "scala-2.11/scalapb/textformat/ParserCompat.scala"

                          "scala/scalapb/textformat/ParserCompat.scala"))

             #t))

         (replace 'build

           ,(sbt-building-phase

              '(("lenses/" "shared")

                ("" "scalapb-runtime")

                ("" "compiler-plugin")

                ("" "scalapbc"))))

         (replace 'install

           (install-jars "build"))

         (add-after 'install 'install-bin

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

             (let ((bin (string-append (assoc-ref outputs "out") "/bin")))

               (mkdir-p bin)

               (with-output-to-file (string-append bin "/scalapbc")

                 (lambda _

                   (format #t "#!~a

java -cp ~a scalapb.ScalaPBC $@\n" (which "bash")

                           (string-join

                             (append

                               (find-files (assoc-ref outputs "out") ".*.jar")

                               (find-files (assoc-ref inputs "java-protobuf") ".*.jar")

                               (find-files (assoc-ref inputs "java-protoc-jar") ".*.jar")

                               (find-files (assoc-ref inputs "scala-fastparse1") ".*.jar")

                               (find-files (assoc-ref inputs "scala-protoc-bridge") ".*.jar")

                               (find-files (assoc-ref inputs "scala-sourcecode") ".*.jar")

                               (find-files (assoc-ref inputs "scala") ".*.jar"))

                             ":"))))

               (chmod (string-append bin "/scalapbc") #o755))

             #t)))))

    (inputs

     `(("java-protobuf" ,java-protobuf)

       ("java-protoc-jar" ,java-protoc-jar)

       ("scala-fastparse1" ,scala-fastparse1)

       ("scala-protoc-bridge" ,scala-protoc-bridge)

       ("scala-sourcecode" ,scala-sourcecode)))

    (native-inputs

     `(("protobuf" ,protobuf)

       ("scala" ,scala-official)))

    (home-page "")

    (synopsis "")

    (description "")

    (license license:bsd-3)))

(define-public sbt-sbinary

  (package

    (name "sbt-sbinary")

    (version "0.5.0")

    (source

      (origin

        (method url-fetch)

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

                            version ".tar.gz"))

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

        (sha256

         (base32

          "12mcny4flfc6zbgncjwqljrsg6qw7azagkackyqcp4gmv9ssw99f"))))

    (build-system ant-build-system)

    (arguments

     `(#:tests? #f

       #:phases

       (modify-phases %standard-phases

         (add-before 'build 'generate-fmpp

           (lambda _

             (invoke "fmpp" "-U" "all" "-S" "core/src/main/fmpp" "-O"

                     "core/src/main/scala")

             #t))

         (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 "core/src/main/scala-2.13-" ".*.scala$")

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

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

             #t))

         (replace 'install

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

    (native-inputs

     `(("java-fmpp" ,java-fmpp)

       ("scala" ,scala-official)))

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

    (synopsis "")

    (description "")

    (license license:bsd-3)))

(define-public sbt-zinc

  (package

    (name "sbt-zinc")

    (version "1.2.5")

    (source

      (origin

        (method url-fetch)

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

                            version ".tar.gz"))

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

        (sha256

         (base32

          "1b01nv3dk3g7jx59jnzp2m2va5brhmds4bpgp824fnmp2fdjzgl0"))))

    (build-system ant-build-system)

    (arguments

     `(#:tests? #f

       #:phases

       (modify-phases %standard-phases

         (add-before 'build 'generate-protobuf

           (lambda _

             (invoke "scalapbc"

                     (string-append

                       "-v"

                       (string-delete #\. ,(package-version protobuf)))

                     "--scala_out=internal/zinc-persist/src/main/scala"

                     "internal/zinc-persist/src/main/protobuf/schema.proto")

             #t))

         (replace 'build

           ,(sbt-building-phase

              '(("internal/" "compiler-interface")

                ("internal/" "zinc-classpath")

                ("internal/" "zinc-classfile")

                ("internal/" "zinc-apiinfo")

                ("internal/" "zinc-core")

                ("internal/" "zinc-persist")

                ("internal/" "zinc-compile-core")

                ("" "zinc"))))

         (replace 'install

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

    (inputs

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

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

       ("java-protobuf" ,java-protobuf)

       ("sbt-io" ,sbt-io)

       ("sbt-launcher" ,sbt-launcher)

       ("sbt-librarymanagement" ,sbt-librarymanagement)

       ("sbt-sbinary" ,sbt-sbinary)

       ("sbt-util" ,sbt-util)

       ("scala-protoc-bridge" ,scala-protoc-bridge)

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

    (native-inputs

     `(("scala-protobuf" ,scala-protobuf)

       ("scala" ,scala-official)))

    (home-page "")

    (synopsis "")

    (description "")

    (license license:bsd-3)))

    (version "1.2.8")

          "0fpm9jcd84xjxlfdfh2iwz7544ksgqik6591i7nrzlamygmbfadr"))))

             (build-subproject "" "protocol")

             (build-subproject "" "main-command")

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

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

       ("scala" ,scala-official)

       ("sbt-launcher" ,sbt-launcher)

       ("sbt-util" ,sbt-util)

       ("sbt-zinc" ,sbt-zinc)))