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

;;; Copyright © 2017-2019 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 java)

  #: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 svn-download)

  #:use-module (guix cvs-download)

  #:use-module (guix hg-download)

  #:use-module (guix utils)

  #:use-module (guix gexp)

  #:use-module (guix build syscalls)

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

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

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

  #:use-module (gnu packages apr)

  #:use-module (gnu packages autotools)

  #:use-module (gnu packages base)

  #:use-module (gnu packages batik)

  #:use-module (gnu packages compression)

  #:use-module (gnu packages cups)

  #:use-module (gnu packages docbook)

  #:use-module (gnu packages elf)

  #:use-module (gnu packages fontutils)

  #:use-module (gnu packages gcc)

  #:use-module (gnu packages groovy)

  #:use-module (gnu packages icu4c)

  #:use-module (gnu packages java)

  #:use-module (gnu packages libffi)

  #:use-module (gnu packages linux)

  #:use-module (gnu packages maven)

  #:use-module (gnu packages perl)

  #:use-module (gnu packages protobuf)

  #:use-module (gnu packages tls)

  #:use-module (gnu packages version-control)

  #:use-module (gnu packages web)

  #:use-module (gnu packages xml)

  #:use-module (gnu packages xorg)

  #:use-module (more packages maven)

  #:use-module (more packages python)

  #:use-module (more packages tls)

  #:use-module (more packages web))

(define-public java-httpcomponents-httpasyncclient

  (package

    (name "java-httpcomponents-httpasyncclient")

    (version "4.1.4")

    (source (origin

              (method url-fetch)

              (uri (string-append "mirror://apache/httpcomponents/httpasyncclient/"

                                  "source/httpcomponents-asyncclient-"

                                  version "-src.tar.gz"))

              (sha256

               (base32

                "0xfc20zrwdym6g00sz5y38mdmcn4y2jikkmfgqyh9zm4nkyj7ci5"))))

    (build-system ant-build-system)

    (arguments

     `(#:jar-name "httpcomponents-httpasyncclient.jar"

       #:phases

       (modify-phases %standard-phases

         (add-after 'unpack 'chdir

           (lambda _ (chdir "httpasyncclient") #t)))))

    (inputs

     `(("java-commons-logging-minimal" ,java-commons-logging-minimal)

       ("java-commons-codec" ,java-commons-codec)

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

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

       ("java-httpcomponents-httpclient" ,java-httpcomponents-httpclient)

       ("java-httpcomponents-httpcore" ,java-httpcomponents-httpcore)

       ("java-httpcomponents-httpcore-nio" ,java-httpcomponents-httpcore-nio)

       ("java-mockito" ,java-mockito-1)

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

    (home-page "https://hc.apache.org/httpcomponents-asyncclient-ga/")

    (synopsis "HTTP client library for Java")

    (description "Although the @code{java.net} package provides basic

functionality for accessing resources via HTTP, it doesn't provide the full

flexibility or functionality needed by many applications.  @code{HttpAsyncClient}

seeks to fill this void by providing an efficient, up-to-date, and

feature-rich package implementing the client side of the most recent HTTP

standards and recommendations.")

    (license license:asl2.0)))

(define-public java-fastutil

  (package

    (name "java-fastutil")

    (version "8.2.2")

    (source (origin

              (method git-fetch)

              (uri (git-reference

                     (url "https://github.com/vigna/fastutil")

                     (commit version)))

              (file-name (git-file-name name version))

              (sha256

               (base32

                "1jn2c70lran9b2zkyvw4axynbsdb2qscz3drjd0jvs1fjmxiwzjh"))))

    (build-system ant-build-system)

    (arguments

     `(#:tests? #f; no tests

       #:phases

       (modify-phases %standard-phases

         (add-before 'build 'generate-sources

           (lambda _

             (invoke "make" "CC=gcc" "sources")

             #t))

         (add-after 'build 'generate-javadoc

           (lambda _

             (invoke "ant" "javadoc")

             #t))

         (replace 'install

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

    (home-page "http://fastutil.di.unimi.it/")

    (synopsis "")

    (description "")

    (license license:asl2.0)))

;; Maintained version of http-builder (groovyx.net.http)

(define-public java-http-builder-ng

  (package

    (name "java-http-builder-ng")

    (version "1.0.3")

    (source (origin

              (method url-fetch)

              (uri (string-append "https://github.com/http-builder-ng/"

                                  "http-builder-ng/archive/v" version ".tar.gz"))

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

              (sha256

               (base32

                "1acgdf5jnnsw32nbanwba5ax6m7y48c5zqdwrmpk3i2p9l5m30fd"))))

    (build-system ant-build-system)

    (arguments

     `(#:jar-name "http-builder-ng.jar"

       #:source-dir "http-builder-ng-core/src/main/java"

       #:test-dir "http-builder-ng-core/src/test"

       #:tests? #f)); TODO: com.stehno.ersatz

    (inputs

     `(("groovy" ,groovy)

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

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

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

       ("java-javax-mail" ,java-javax-mail)

       ("java-jsoup" ,java-jsoup)

       ("java-nekohtml" ,java-nekohtml)

       ("java-opencsv" ,java-opencsv)

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

       ("java-xerces" ,java-xerces)))

    (native-inputs

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

    (home-page "https://http-builder-ng.github.io/http-builder-ng")

    (synopsis "")

    (description "")

    (license license:asl2.0)))

(define-public java-commons-text

  (package

    (name "java-commons-text")

    ;; latest version is advertized to be 1.1.8

    (version "1.2")

    (source (origin

              (method url-fetch)

              (uri (string-append "mirror://apache/commons/text/source/"

                                  "commons-text-" version "-src.tar.gz"))

              (file-name (string-append name "-" version))

              (sha256

               (base32

                "0rzffm5al0nkxcbrbbjnnwvpky4y6mv8j1cfnhbkfvxq1zlr3aim"))))

    (build-system ant-build-system)

    (arguments

     `(#:jar-name "commons-text.jar"

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

    (inputs

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

    (native-inputs

     `(("java-assertj" ,java-assertj)

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

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

    (home-page "https://commons.apache.org/proper/commons-text")

    (synopsis "")

    (description "")

    (license license:asl2.0)))

(define-public java-opencsv

  (package

    (name "java-opencsv")

    ;; latest version is advertized to be 1.1.8

    (version "4.1")

    (source (origin

              (method git-fetch)

              (uri (git-reference

                     (url "https://git.code.sf.net/p/opencsv/source")

                     (commit "Release_4_1")))

              ;(uri (string-append "https://sourceforge.net/code-snapshots/git/"

              ;                    "o/op/opencsv/source.git/opencsv-source-"

              ;                    "1a8d01d569f81390a88299a5344f2685dc690127.zip"))

              ;(file-name (string-append name "-" version ".zip"))

              (file-name (string-append name "-" version))

              (sha256

               (base32

                "1dmhssidx81n0mc6ifzw7j1q0q7882iz2cjmwk8p3gissndjf5li"))))

    (build-system ant-build-system)

    (arguments

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

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

       #:phases

       (modify-phases %standard-phases

         (add-before 'build 'copy-resources

           (lambda _

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

             #t))

         (add-before 'build 'remove-failing-test

           (lambda _

             ;; This file fails to build

             (delete-file "src/test/java/com/opencsv/bean/StatefulBeanToCsvTest.java")

             #t)))))

    (inputs

     `(("java-commons-beanutils" ,java-commons-beanutils)

       ("java-commons-collections" ,java-commons-collections)

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

       ("java-commons-text" ,java-commons-text)))

    (native-inputs

     `(("java-asm" ,java-asm)

       ("java-cglib" ,java-cglib)

       ("java-commons-logging-minimal" ,java-commons-logging-minimal)

       ("java-junit" ,java-junit)

       ("java-mockito-1" ,java-mockito-1)

       ("java-objenesis" ,java-objenesis)))

    (home-page "https://github.com/sirthias/parboiled")

    (synopsis "")

    (description "")

    (license license:asl2.0)))

(define-public java-parboiled

  (package

    (name "java-parboiled")

    ;; latest version is advertized to be 1.1.8

    (version "1.1.7")

    (source (origin

              (method url-fetch)

              (uri (string-append "https://github.com/sirthias/parboiled/archive/"

                                  version ".tar.gz"))

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

              (sha256

               (base32

                "02akw95mqwnx5w1gag5ymilavgc0kr5dsiachpzbps282qmlssr2"))))

    (build-system ant-build-system)

    (arguments

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

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

       #:test-dir "parboiled-core/src/test"

       #:tests? #f)); requires scala

    (inputs

     `(("java-asm" ,java-asm)))

    (native-inputs

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

       ("java-testng" ,java-testng)))

    (home-page "https://github.com/sirthias/parboiled")

    (synopsis "")

    (description "")

    (license license:asl2.0)))

(define-public java-pegdown

  (package

    (name "java-pegdown")

    (version "1.6.0")

    (source (origin

              (method url-fetch)

              (uri (string-append "https://github.com/sirthias/pegdown/archive/"

                                  version ".tar.gz"))

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

              (sha256

               (base32

                "18y97gvsvpqc9i7wvrq5zs2ir8ycd7f1igz6qgibrhw14i118xmx"))))

    (build-system ant-build-system)

    (arguments

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

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

    (inputs

     `(("java-parboiled" ,java-parboiled)))

    (native-inputs

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

    (home-page "https://github.com/sirthias/pegdown")

    (synopsis "")

    (description "")

    (license license:asl2.0)))

(define-public java-nekohtml

  (package

    (name "java-nekohtml")

    (version "1.9.21")

    (source (origin

              (method url-fetch)

              (uri (string-append "http://downloads.sourceforge.net/nekohtml/"

                                  "nekohtml-" version ".tar.gz"))

              (sha256

               (base32

                "1dzdvm3wyl32ljbk3f5kvpg7h9fzps86q4hvfscr232d6xz6f18j"))

              (modules '((guix build utils)))

              (snippet

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

    (build-system ant-build-system)

    (arguments

     `(#:tests? #f; No tests

       #:phases

       (modify-phases %standard-phases

         (add-before 'build 'fix-classpath

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

             (substitute* "build.xml"

               (("\\$\\{lib.dir\\}/xerces-@\\{xercesVersion\\}")

                (string-append (assoc-ref inputs "java-xerces") "/share/java"))

               ;; We don't have older versions of xerces, so we don't need to

               ;; get the compatibility with those.

               (("<compileWith xercesVersion=\".*\" bridge=\"2_0\"/>")

                "")

               (("<compileWith xercesVersion=\".*\" bridge=\"2_1\"/>")

                "")

               (("<compileWith xercesVersion=\".*\" bridge=\"2_2\"/>")

                ""))

             #t))

         (replace 'install

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

    (inputs

     `(("java-xerces" ,java-xerces)))

    (home-page "")

    (synopsis "")

    (description "")

    (license license:asl2.0)))

(define-public java-jcifs

  (package

    (name "java-jcifs")

    (version "1.3.19")

    (source (origin

              (method url-fetch)

              (uri (string-append "https://jcifs.samba.org/src/jcifs-"

                                  version ".tgz"))

              (sha256

               (base32

                "19kzac3c19j0fyssibcj47868k8079wlj9azgsd7i6yqmdgqyk3y"))

              (modules '((guix build utils)))

              (snippet

                `(delete-file (string-append "jcifs-" ,version ".jar")))))

    (build-system ant-build-system)

    (arguments

     `(#:tests? #f; No tests

       #:phases

       (modify-phases %standard-phases

         (add-before 'build 'fix-compiler

           (lambda _

             ;; Expects to find the compiler in /usr/local

             (substitute* "build.xml"

               (("executable=.*") ""))

             #t))

         (replace 'install

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

    (inputs

     `(("java-classpathx-servletapi" ,java-classpathx-servletapi)))

    (home-page "")

    (synopsis "")

    (description "")

    (license license:asl2.0)))

(define-public java-airline

  (package

    (name "java-airline")

    (version "0.8")

    (source (origin

              (method url-fetch)

              (uri (string-append "https://github.com/airlift/airline/archive/"

                                  version ".tar.gz"))

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

              (sha256

               (base32

                "047ckxslpaw6j54zyfdf4b7sw71vcx7rqbwqa3lzz3pprhdfnm4x"))))

    (build-system ant-build-system)

    (arguments

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

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

       #:test-dir "src/test"

       #:phases

       (modify-phases %standard-phases

         (replace 'check

           (lambda _

             (system* "ant" "compile-tests")

             ;; This fails though

             (system* "java" "-cp" (string-append (getenv "CLASSPATH")

                                                         ":build/classes"

                                                         ":build/test-classes")

                             "org.testng.TestNG" "-verbose" "5" "-testclass"

                             "build/test-classes/io/airlift/airline/command/CommandTest.class")

             #t)))))

    (inputs

     `(("java-guava-23.5" ,java-guava-23.5)

       ("java-javax-inject" ,java-javax-inject)

       ("java-jsr305" ,java-jsr305)))

    (native-inputs

     `(("java-testng" ,java-testng)

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

    (home-page "")

    (synopsis "Command line parser")

    (description "Airline is a Java annotation-based framework for parsing Git

like command line structures.  Airline contains a fully automated help system,

which generates man-page-like documentation driven by the Java annotations.")

    (license license:asl2.0)))

(define-public java-japicmp

  (package

    (name "java-japicmp")

    (version "0.10.0")

    (source (origin

              (method url-fetch)

              (uri (string-append "https://github.com/siom79/japicmp/archive/"

                                  "japicmp-base-" version ".tar.gz"))

              (sha256

               (base32

                "0kb3ja3j6kliakbqp1ypva1y42qllwvyin38ky3kxqzlkzhzpy9j"))))

    (build-system ant-build-system)

    (arguments

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

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

       #:test-dir "japicmp/src/test"

       #:tests? #f; require org.junit.contrib

       #:phases

       (modify-phases %standard-phases

         (add-before 'build 'copy-resources

           (lambda _

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

             #t)))))

    (inputs

     `(("java-airline" ,java-airline)

       ("java-jboss-javassist" ,java-jboss-javassist)

       ("java-guava" ,java-guava)

       ("java-javax-inject" ,java-javax-inject)))

    (home-page "")

    (synopsis "Japicmp is a tool to compare two versions of a jar archive")

    (description "Japicmp is a tool to compare two versions of a jar archive.

It can also be used as a library.")

    (license license:asl2.0)))

(define-public java-jatl

  (package

    (name "java-jatl")

    (version "0.2.3")

    (source (origin

              (method url-fetch)

              (uri (string-append "https://github.com/agentgt/jatl/archive/jatl-"

                                  version ".tar.gz"))

              (sha256

               (base32

                "0z3s4zpq97rwwn2gcfkhf28sib60d1sczg682fskyq1nfdxnlvgb"))))

    (build-system ant-build-system)

    (arguments

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

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

    (native-inputs

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

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

    (home-page "")

    (synopsis "")

    (description "")

    (license license:asl2.0)))

(define-public java-javaparser-3.9

  (package

    (name "java-javaparser")

    (version "3.9.0")

    (source (origin

              (method git-fetch)

              (uri (git-reference

                     (url "https://github.com/javaparser/javaparser.git")

                     (commit "b7907a0dc39ff10388943dfffba01bec4bb116dc")))

              (file-name (git-file-name name version))

              (sha256

               (base32

                "172y8wbwqwwvqlhk65df0zilyicq7nagnsa9f4gav8s85p9ijxr8"))

              (modules '((guix build utils)))

              (snippet

               '(begin

                  (for-each delete-file

                            (find-files "." "\\.jar$"))

                  #t))))

    (build-system ant-build-system)

    (arguments

     `(#:phases

       (modify-phases %standard-phases

         (add-before 'build 'fill-template

           (lambda _

             (with-directory-excursion "javaparser-core/src/main"

               (copy-file "java-templates/com/github/javaparser/JavaParserBuild.java"

                          "java/com/github/javaparser/JavaParserBuild.java")

               (substitute* "java/com/github/javaparser/JavaParserBuild.java"

                 (("\\$\\{project.version\\}") ,version)

                 (("\\$\\{project.name\\}") "javaparser")

                 (("\\$\\{project.build.finalName\\}") "javaparser")

                 (("\\$\\{maven.version\\}") "fake")

                 (("\\$\\{maven.build.version\\}") "fake")

                 (("\\$\\{build.timestamp\\}") "0")

                 (("\\$\\{java.vendor\\}") "Guix")

                 (("\\$\\{java.vendor.url\\}") "https://gnu.org/software/guix")

                 (("\\$\\{java.version\\}") "1.8")

                 (("\\$\\{os.arch\\}") "any")

                 (("\\$\\{os.name\\}") "GuixSD")

                 (("\\$\\{os.version\\}") "not available")))

             #t))

         (add-before 'build 'generate-javacc

           (lambda _

             (with-directory-excursion "javaparser-core/src/main/java"

               (invoke "java" "javacc" "../javacc/java.jj"))

             #t))

         (add-before 'build 'copy-javacc-support

           (lambda _

             (with-directory-excursion "javaparser-core/src/main"

               (copy-recursively "javacc-support" "java"))

             #t))

         (add-before 'build 'fix-ambiguousity

           (lambda _

             (substitute* (find-files "javaparser-symbol-solver-core/src/main/java" ".*.java")

               (("TypeParameter node")

                "com.github.javaparser.ast.type.TypeParameter node"))

             (substitute* (find-files "javaparser-core-metamodel-generator/src/main/java" ".*.java")

               (("\\(TypeParameter.class")

                "(com.github.javaparser.ast.type.TypeParameter.class"))

             (substitute* (find-files "javaparser-core/src/main/java" ".*.java")

               (("final TypeParameter ")

                "final com.github.javaparser.ast.type.TypeParameter ")

               (("\\(TypeParameter.class")

                "(com.github.javaparser.ast.type.TypeParameter.class")

               (("new TypeParameter\\(")

                "new com.github.javaparser.ast.type.TypeParameter(")

               (("\\(TypeParameter\\)")

                "(com.github.javaparser.ast.type.TypeParameter)")

               (("TypeParameter r")

                "com.github.javaparser.ast.type.TypeParameter r")

               (("TypeParameter tp")

                "com.github.javaparser.ast.type.TypeParameter tp")

               (("\\{TypeParameter")

                "{com.github.javaparser.ast.type.TypeParameter")

               (("public TypeParameter ")

                "public com.github.javaparser.ast.type.TypeParameter ")

               (("visit\\(TypeParameter ")

                "visit(com.github.javaparser.ast.type.TypeParameter ")

               (("<TypeParameter>")

                "<com.github.javaparser.ast.type.TypeParameter>"))

             #t))

         (replace 'build

           (lambda _

             (define (build name)

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

               (delete-file-recursively "build/classes")

               (mkdir-p "build/classes")

               (apply invoke "javac"

                      "-cp" (string-append (getenv "CLASSPATH") ":"

                                           (string-join (find-files "build/jar" ".") ":"))

                      "-d" "build/classes"

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

                                  ".*.java"))

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

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

             (mkdir-p "build/classes")

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

             (mkdir-p "build/jar")

             (build "javaparser-core")

             (build "javaparser-core-serialization")

             (build "javaparser-core-generators")

             (build "javaparser-core-metamodel-generator")

             (build "javaparser-symbol-solver-model")

             (build "javaparser-symbol-solver-logic")

             (build "javaparser-symbol-solver-core")

             #t))

         (replace 'check

           (lambda _

             (define (test name)

               (format #t "Testing ~a~%" name)

               (delete-file-recursively "build/test-classes")

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

               (apply invoke "javac" "-d" "build/test-classes"

                      "-cp" (string-append (getenv "CLASSPATH") ":"

                                           (string-join (find-files "build/jar" ".") ":"))

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

                                  ".*.java"))

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

                                                   (string-join (find-files "build/jar" ".") ":")

                                                   ":build/test-classes")

                       "org.junit.runner.JUnitCore"

                       (map

                         (lambda (file)

                           (string-join

                             (string-split

                               (substring file 14 (- (string-length file) 5)) #\/)

                             "."))

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

                                     ".*Test.java"))))

             ;; We need junit5 that recursively depend on this package,

             ;; as well as jbehave.

             ;(test "javaparser-core-testing")

             ;(test "javaparser-symbol-solver-testing")

             #t))

         (replace 'install

           (install-jars "build/jar")))))

    (inputs

     `(("java-guava" ,java-guava)

       ("java-jboss-javassist" ,java-jboss-javassist)

       ("java-jsonp-api" ,java-jsonp-api)))

    (native-inputs

     `(("javacc" ,javacc)

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

       ("java-junit" ,java-junit)

       ("java-okhttp" ,java-okhttp)))

    (home-page "http://javaparser.org/")

    (synopsis "Parser for Java")

    (description

     "This project contains a set of libraries implementing a Java 1.0 - Java

11 Parser with advanced analysis functionalities.")

    (license license:lgpl2.0+)))

(define-public java-jul-to-slf4j

  (package

    (inherit java-slf4j-api)

    (name "java-jul-to-slf4j")

    (arguments

     `(#:jar-name "jul-to-slf4j.jar"

       #:source-dir "jul-to-slf4j/src/main/java"

       #:test-dir "jul-to-slf4j/src/test"

       #:tests? #f)); Depend on log4j-1.2 (not log4j-1.2-api)

    (inputs

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

;; Actually we need to build the native library too.

(define-public java-native-platform

  (package

    (name "java-native-platform")

    (version "0.14")

    (source (origin

              (method url-fetch)

              (uri (string-append "https://github.com/adammurdoch/"

                                  "native-platform/archive/" version ".tar.gz"))

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

              (sha256

               (base32

                "1if8h1lz8rh6gv6rrych63j2a03cfcqshb5c2973xsfs7jfrvbrr"))))

    (build-system ant-build-system)

    (arguments

     `(#:jar-name "native-platform.jar"

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

       #:tests? #f)); TODO: fix build.xml to run Groovy tests

    (home-page "https://github.com/EsotericSoftware/minlog")

    (synopsis "Java bindings for various native APIs")

    (description "Native-platform is a collection of cross-platform Java APIs

for various native APIs.  It currently supports OS X, Linux, Windows and

FreeBSD on Intel architectures")

    (license license:asl2.0)))

(define-public java-minlog

  (package

    (name "java-minlog")

    (version "1.3.0")

    (source (origin

              (method url-fetch)

              (uri (string-append "https://github.com/EsotericSoftware/minlog/"

                                  "archive/minlog-" version ".tar.gz"))

              (sha256

               (base32

                "1vciwr6zw6bky70fi13sa85jc27r5nk5bzii8kdkblfaakmy8ifb"))))

    (build-system ant-build-system)

    (arguments

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

       #:tests? #f)); No tests

    (home-page "https://github.com/EsotericSoftware/minlog")

    (synopsis "Logging library")

    (description "MinLog is a tiny Java logging library which features:

@itemize

@item Zero overhead: Logging statements below a given level can be

      automatically removed by javac at compile time.  This means applications

      can have detailed trace and debug logging without having any impact on

      the finished product.

@item Extremely lightweight: The entire project consists of a single Java file

      with ~100 non-comment lines of code.

@item Simple and efficient: The API is concise and the code is very efficient

      at runtime.

@end itemize")

    (license license:bsd-3)))

(define-public java-reflectasm

  (package

    (name "java-reflectasm")

    (version "1.11.5")

    (source (origin

              (method url-fetch)

              (uri (string-append "https://github.com/EsotericSoftware/"

                                  "reflectasm/archive/reflectasm-" version

                                  ".tar.gz"))

              (sha256

               (base32

                "1rcgr5rm2g0jl2z0qk1bddlq72mh16ywznyy8pra0ns8xk6hwa8g"))))

    (build-system ant-build-system)

    (arguments

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

       #:tests? #f; Tests are not in a java subdirectory

       #:phases

       (modify-phases %standard-phases

         (add-before 'build 'fix-asm

           (lambda _

             ;; asm has been renamed

             (substitute* '("src/com/esotericsoftware/reflectasm/ConstructorAccess.java"

                            "src/com/esotericsoftware/reflectasm/FieldAccess.java"

                            "src/com/esotericsoftware/reflectasm/MethodAccess.java")

               (("com.esotericsoftware.asm") "org.objectweb.asm"))

             #t)))))

    (inputs

     `(("java-asm" ,java-asm)))

    (home-page "https://github.com/EsotericSoftware/reflectasm")

    (synopsis "Reflection library for Java")

    (description "ReflectASM is a very small Java library that provides high

performance reflection by using code generation.  An access class is generated

to set/get fields, call methods, or create a new instance.  The access class

uses bytecode rather than Java's reflection, so it is much faster.  It can

also access primitive fields via bytecode to avoid boxing.")

    (license license:bsd-3)))

(define-public java-kryo

  (package

    (name "java-kryo")

    (version "4.0.1")

    (source (origin

              (method url-fetch)

              (uri (string-append "https://github.com/EsotericSoftware/kryo/"

                                  "archive/kryo-parent-" version ".tar.gz"))

              (sha256

               (base32

                "0l0mwxfym29ssvxxwawg8h6psnzbb1dbhqfzhhhxxbm7p79xzga5"))))

    (build-system ant-build-system)

    (arguments

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

       #:tests? #f)); No tests

    (inputs

     `(("java-minlog" ,java-minlog)

       ("java-objenesis" ,java-objenesis)

       ("java-reflectasm" ,java-reflectasm)))

    (home-page "https://github.com/EsotericSoftware/kryo")

    (synopsis "Object graph serialization framework")

    (description "Kryo is a fast and efficient object graph serialization

framework for Java.  The project is useful any time objects need to be

persisted, whether to a file, database, or over the network.")

    (license license:bsd-3)))

(define-public java-jformatstring

  (package

    (name "java-jformatstring")

    (version "3.0.0")

    (source (origin

              (method url-fetch)

              (uri (string-append "https://framagit.org/tyreunom/j-format-string/-/archive/"

                                  version "/j-format-string-" version ".tar.gz"))

              (sha256

               (base32

                "0ypqnchxif7rkq3n9vshj3j0d24kw3wr6k00yb5i14jm59m21r90"))

              (modules '((guix build utils)))

              (snippet

                '(begin

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

    (build-system ant-build-system)

    (arguments

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

       ; tests are not in a java directory

       #:tests? #f))

    (inputs

     `(("java-jsr305" ,java-jsr305)

       ("java-junit" ,java-junit)

       ("java-spotbugs-annotations" ,java-spotbugs-annotations)))

    (home-page "http://findbugs.sourceforge.net/")

    (synopsis "")

    (description "")

    ;; license: gpl2 only, with classpath exception

    (license license:gpl2)))

(define-public java-commons-bcel-5

  (package

    (inherit java-commons-bcel)

    (version "5.2")

    (source (origin

              (method url-fetch)

              (uri (string-append "https://archive.apache.org/dist/commons/"

                                  "bcel/source/bcel-" version "-src.tar.gz"))

              (sha256

               (base32

                "15djmay72mzk38v183j6fr3j7fj3dhkp5z53bsvdfyc3ldcrs0v8"))))

    (arguments

     `(#:jar-name "commons-bcel.jar"

       #:source-dir "src/java"

       #:tests? #f

       #:phases

       (modify-phases %standard-phases

         (add-before 'build 'use-iso8859

           (lambda _

             (substitute* "build.xml"

               (("<javac ") "<javac encoding=\"iso-8859-1\" "))

             #t)))))))

(define-public java-findbugs

  (package

    (name "java-findbugs")

    (version "3.0.1")

    (source (origin

              (method url-fetch)

              (uri (string-append "http://prdownloads.sourceforge.net/findbugs/"

                                  "findbugs-" version "-source.zip"))

              (sha256

               (base32

                "1zrkpmd87lcz62lk5dr0mpf5gbzrd1i8mmrv510fs6fla1jwd3mx"))

              (modules '((guix build utils)))

              (snippet

                '(begin

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

    (build-system ant-build-system)

    (arguments

     `(#:build-target "jars"

       #:test-target "test"

       #:make-flags (list "-Dgitrnum=0")

       #:jdk ,icedtea-7

       #:phases

       (modify-phases %standard-phases

         (add-before 'build 'add-formatstring

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

             (invoke "tar" "xf" (assoc-ref inputs "java-jformatstring"))

             (copy-recursively "j-format-string-3.0.0/src/java" "src/java")

             (copy-recursively "j-format-string-3.0.0/src/junit" "src/junit")

             #t))

         (add-before 'build 'fix-bcel-version

           (lambda _

             ;; Findbugs requires an older version of bcel. Fix it to support

             ;; newer bcel versions.

             (with-directory-excursion "src/java/edu/umd/cs/findbugs"

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

                 (substitute* '("visitclass/PreorderVisitor.java"

                                "StackMapAnalyzer.java"

                                "classfile/engine/ClassParserUsingASM.java")

                   ;; The two classes were merged in the latter

                   (("StackMapTable") "StackMap")

                   (("Constants") "Const")

                   (("Const2") "Constants2")

                   (("getByteCodeOffsetDelta") "getByteCodeOffset"))

                 (substitute* "detect/DumbMethods.java"

                   (("import org.apache.bcel.classfile.Attribute;")

                    "import org.apache.bcel.classfile.Attribute;

import org.apache.bcel.Const;")

                   (("MAJOR_1") "Const.MAJOR_1"))

                 (substitute* "ba/AbstractFrameModelingVisitor.java"

                   (("VisitorSupportsInvokeDynamic") "Visitor"))

                 (substitute* "xml/XMLUtil.java"

                   (("<T> List<T>") "List<Node>"))

                 (substitute* "visitclass/PreorderVisitor.java"

                   (("import org.apache.bcel.classfile.Attribute;")

                    "import org.apache.bcel.classfile.Attribute;

import org.apache.bcel.Const;

import org.apache.bcel.classfile.BootstrapMethods;

import org.apache.bcel.classfile.ConstantInvokeDynamic;

import org.apache.bcel.classfile.ConstantMethodHandle;

import org.apache.bcel.classfile.ConstantMethodType;

import org.apache.bcel.classfile.MethodParameters;

import org.apache.bcel.classfile.ParameterAnnotationEntry;")

                   (("^}")

                    "    @Override

    public void visitBootstrapMethods(BootstrapMethods arg0) {

        // TODO Auto-generated method stub

    }

    @Override

    public void visitConstantInvokeDynamic(ConstantInvokeDynamic arg0) {

        // TODO Auto-generated method stub

    }

    @Override

    public void visitConstantMethodHandle(ConstantMethodHandle arg0) {

        // TODO Auto-generated method stub

    }

    @Override

    public void visitConstantMethodType(ConstantMethodType arg0) {

        // TODO Auto-generated method stub

    }

    @Override

    public void visitMethodParameters(MethodParameters arg0) {

        // TODO Auto-generated method stub

    }

    @Override

    public void visitParameterAnnotationEntry(ParameterAnnotationEntry arg0) {

        // TODO Auto-generated method stub

    }

}"))))

             #t))

         (add-before 'build 'remove-osx

           (lambda _

             ;; Requires AppleJavaExtensions.jar (com.apple.eawt.*)

             (delete-file "src/gui/edu/umd/cs/findbugs/gui2/OSXAdapter.java")