;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2019 Nicolò Balzarotti <nicolo@nixo.xyz>
;;;
;;; 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 (gnu packages julia-xyz)
  #:use-module (guix build-system julia)
  #:use-module (guix git-download)
  #:use-module ((guix licenses) #:prefix license:)
  #:use-module (guix packages)
  #:use-module (gnu packages compression)
  #:use-module (gnu packages xml)
  #:use-module (gnu packages tls))

(define-public julia-uriparser
  (package
    (name "julia-uriparser")
    (version "0.4.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaWeb/URIParser.jl")
             (commit (string-append "v" version))))
       (file-name "URIParser")
       (sha256
        (base32 "1i45wza6jh9k7x8jrqiil6k2yb81hdzm3s0zqhzy3y2sby66p44p"))))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaWeb/URIParser.jl")
    (synopsis "Provides URI parsing according to RFC 3986")
    (description "@code{URIParser} is a julia package that provides URI
parsing according to RFC 3986.")
    (license license:expat)))

(define-public julia-inifile
  (package
    (name "julia-inifile")
    (version "0.5.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaIO/IniFile.jl")
             (commit (string-append "v" version))))
       (file-name "IniFile")
       (sha256
        (base32 "19cn41w04hikrqdzlxhrgf21rfqhkvj9x1zvwh3yz9hqbf350xs9"))))
    (arguments
     `(#:phases
       (modify-phases %standard-phases
         (add-before 'precompile 'fix-toml
           (lambda* (#:key outputs source #:allow-other-keys)
             (julia-create-package-toml
              outputs source
              "IniFile" "83e8ac13-25f8-5344-8a64-a9f2b223428f" "0.5.0"
              '())
             #t)))))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaIO/IniFile.jl")
    (synopsis "Reading Windows-style INI files")
    (description "@code{julia-inifile} is a julia package that defines an
Inifile type that allows to interface with @file{.ini} files.")
    (license license:expat)))

(define-public julia-compat
  (package
    (name "julia-compat")
    (version "2.2.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaLang/Compat.jl")
             (commit (string-append "v" version))))
       (file-name "Compat")
       (sha256
        (base32 "024gqvhabranf398hwhb4m2w3a42kdg9zqj8s4pmjvaal14grw70"))))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaLang/Compat.jl")
    (synopsis "Compatibility across Julia versions")
    (description "The Compat package is designed to ease interoperability
between older and newer versions of the Julia language.  The Compat package
provides a macro that lets you use the latest syntax in a backwards-compatible
way.")
    (license license:expat)))

(define-public julia-sha
  (package
    (name "julia-sha")
    (version "0.5.7")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/staticfloat/SHA.jl")
             (commit (string-append "v" version))))
       (file-name "SHA")
       (sha256
        (base32 "10a09kg9z0m8rvwmlgsna6p342kyvizx2axdqc6pzyhraddr8jrp"))))
    (propagated-inputs `(("julia-compat" ,julia-compat)))
    (build-system julia-build-system)
    (home-page "https://github.com/staticfloat/SHA.jl")
    (synopsis "Performant, 100% native-julia SHA1, SHA2, and SHA3
implementation")
    (description "Julia package implementing SHA algorithms.  Each exported
function takes in either an Array{UInt8}, a ByteString or an IO object.")
    (license license:expat)))

(define-public julia-binaryprovider
  (package
    (name "julia-binaryprovider")
    (version "0.5.5")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaPackaging/BinaryProvider.jl")
             (commit (string-append "v" version))))
       (file-name "BinaryProvider")
       (sha256
        (base32 "1papsz5ki5iwv1v3ac1ddybjxak93nydh7dqc3231zm0fzd918ys"))))
    (propagated-inputs `(("julia-sha" ,julia-sha)))
    (arguments
     `(#:phases
       ;; wants to download things with curl/wget
       (modify-phases %standard-phases (delete 'precompile))))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaPackaging/BinaryProvider.jl.git")
    (synopsis "A reliable binary provider for Julia")
    (description "Install binary packages with Julia.")
    (license license:expat)))

(define-public julia-mbedtls
  (package
    (name "julia-mbedtls")
    (version "0.7.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaWeb/MbedTLS.jl")
             (commit (string-append "v" version))))
       (file-name "MbedTLS")
       (sha256
        (base32 "1a8snw9gi21lm6r3kh6ly7ngi99s9k5shqkfiizj3g9li20q23h2"))))
    (propagated-inputs `(("julia-binaryprovider" ,julia-binaryprovider)
                         ("mbedtls-apache" ,mbedtls-apache)))
    (arguments
     `(#:phases
       (modify-phases %standard-phases
         (add-before 'precompile 'build-deps
           (lambda* (#:key outputs source inputs #:allow-other-keys)
             (let ((f (open-file
                       (string-append
                        (assoc-ref outputs "out")
                        "/share/julia/packages/"
                        (string-append
                         (strip-store-file-name source) "/deps/deps.jl"))
                       "w")))
               (display (string-append "const libmbedcrypto = \""
                                       (assoc-ref inputs "mbedtls-apache")
                                       "/lib/libmbedcrypto.so\"\n") f)
               (display (string-append "const libmbedtls = \""
                                       (assoc-ref inputs "mbedtls-apache")
                                       "/lib/libmbedtls.so\"\n") f)
               (display (string-append "const libmbedx509 = \""
                                       (assoc-ref inputs "mbedtls-apache")
                                       "/lib/libmbedx509.so\"\n") f)
               (close-port f))
             #t)))))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaWeb/MbedTLS.jl")
    (synopsis "Wrapper around the mbed TLS and cryptography C libary")
    (description "@code{julia-mbedtls} is a julia wrapper around mbed TLS.")
    (license license:expat)))

(define-public julia-bindeps
  (package
    (name "julia-bindeps")
    (version "0.8.10")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaPackaging/BinDeps.jl")
             (commit (string-append "v" version))))
       (file-name "BinDeps")
       (sha256
        (base32 "1da7z4ii78gaqnjal7c4d1xvicyshiil4ls6xhi9id4q8plmfa2m"))))
    (propagated-inputs `(("julia-uriparser" ,julia-uriparser)
                         ("julia-sha" ,julia-sha)
                         ("julia-compat" ,julia-compat)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaPackaging/BinDeps.jl")
    (synopsis "Easily build binary dependencies for Julia packages")
    (description "@code{BinDeps} is a package that provides a collection of
tools to build binary dependencies for Julia packages.")
    (license license:expat)))

(define-public julia-parsers
  (package
    (name "julia-parsers")
    (version "0.3.7")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaData/Parsers.jl")
             (commit (string-append "v" version))))
       (file-name "Parsers")
       (sha256
        (base32 "01j8cpnhxpxzybqzbvv3h5v0ksysqxmh5fmls6hpza2p3gjg4yrv"))))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaData/Parsers.jl")
    (synopsis "Fast parsing machinery for basic types in Julia")
    (description "@code{Parsers} is a collection of type parsers and utilities
for Julia")
    (license license:expat)))

(define-public julia-json
  (package
    (name "julia-json")
    (version "0.21.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaIO/JSON.jl")
             (commit (string-append "v" version))))
       (file-name "JSON")
       (sha256
        (base32 "0knmfjhchd3ggy86dsfyb7l4v3fv5dcr207cgp54mj7rj96caqsm"))))
    (propagated-inputs `(("julia-parsers" ,julia-parsers)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaIO/JSON.jl")
    (synopsis "JSON parsing and printing")
    (description "Parsing and printing JSON in pure Julia.")
    (license license:expat)))

(define-public julia-bufferedstreams
  (package
    (name "julia-bufferedstreams")
    (version "1.0.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/BioJulia/BufferedStreams.jl")
             (commit (string-append "v" version))))
       (file-name "BufferedStreams")
       (sha256
        (base32 "0sf4sxbq55mg2pwxyxf0c839z1lk0yxg8nmb7617bfbvw31cp88z"))))
    (propagated-inputs `(("julia-compat" ,julia-compat)))
    (build-system julia-build-system)
    (home-page "https://github.com/BioJulia/BufferedStreams.jl")
    (synopsis "Fast composable IO streams")
    (description "@code{BufferedStreams} provides buffering for IO
operations.  It can wrap any IO type automatically making incremental reading
and writing faster.")
    (license license:expat)))

(define-public julia-transcodingstreams
  (package
    (name "julia-transcodingstreams")
    (version "0.9.5")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/bicycle1885/TranscodingStreams.jl")
             (commit (string-append "v" version))))
       (file-name "TranscodingStreams")
       (sha256
        (base32 "0zfr4g4yv08iy96vshn7zn4lh2z5rwd4k1ybvyinp3srl69hxlk9"))))
    (propagated-inputs `(("julia-compat" ,julia-compat)))
    (build-system julia-build-system)
    (home-page "https://github.com/bicycle1885/TranscodingStreams.jl")
    (synopsis "Simple, consistent interfaces for any codec")
    (description " @code{TranscodingStreams.jl} is a package for transcoding
data streams, which is:
@enumerate
@item fast: small overhead and specialized
methods,
@item consistent: basic I/O operations you already know will work as
you expect,
@item generic: support any I/O objects like files, buffers, pipes,
@item extensible: you can define a new codec to transcode data
@end enumerate")
    (license license:expat)))

(define-public julia-codeczlib
  (package
    (name "julia-codeczlib")
    (version "0.6.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/bicycle1885/CodecZlib.jl")
             (commit (string-append "v" version))))
       (file-name "CodecZlib")
       (sha256
        (base32 "18j5lhcsgln4ng5ik0y1s194q1a8h4828wwp4ws5vqc9i2spn8mb"))))
    (propagated-inputs `(("julia-transcodingstreams" ,julia-transcodingstreams)
                         ("julia-binaryprovider" ,julia-binaryprovider)
                         ("zlib" ,zlib)))
    (arguments
     `(#:phases
       (modify-phases %standard-phases
         (delete 'reset-gzip-timestamps)
         (add-before 'precompile 'build-deps
           (lambda* (#:key outputs source inputs #:allow-other-keys)
             (let ((f (open-file
                       (string-append
                        (assoc-ref outputs "out")
                        "/share/julia/packages/"
                        (string-append
                         (strip-store-file-name source) "/deps/deps.jl"))
                       "w")))
               (display (string-append "const libz = \""
                                       (assoc-ref inputs "zlib")
                                       "/lib/libz.so\"\n") f)
               (display "check_deps() = true\n" f)
               (close-port f))
             #t)))))
    (build-system julia-build-system)
    (home-page "https://github.com/bicycle1885/CodecZlib.jl")
    (synopsis "@code{Zlib} codecs for @code{TranscodingStreams}")
    (description "@code{CodecZlib} provides Zlib bindings for the
@code{TranscodingStreams} interface.")
    (license license:expat)))

(define-public julia-http
  (package
    (name "julia-http")
    (version "0.8.6")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaWeb/HTTP.jl")
             (commit (string-append "v" version))))
       (file-name "HTTP")
       (sha256
        (base32 "01s9nszgdinpa3pyra646w2yi4qx0d6hcngsrxx291vr5gnhr7lj"))))
    (propagated-inputs `(("julia-inifile" ,julia-inifile)
                         ("julia-mbedtls" ,julia-mbedtls)
                         ("julia-compat" ,julia-compat)))
    (build-system julia-build-system)
    (home-page "https://juliaweb.github.io/HTTP.jl/")
    (synopsis "HTTP for Julia")
    (description "HTTP client and server functionality for Julia.")
    (license license:expat)))

(define-public julia-libexpat
  (package
    (name "julia-libexpat")
    ;; 0.6.0 requires julia 1.3+
    (version "0.5.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaIO/LibExpat.jl")
             (commit (string-append "v" version))))
       (file-name "LibExpat")
       (sha256
        (base32 "1iny18z76bkf3yi6cvpfia7z1j7kn789iy0nwigsj2sb9mfi5x8b"))))
    (arguments
     `(#:phases
       (modify-phases %standard-phases
         (add-before 'precompile 'build-deps
           (lambda*
               (#:key outputs source inputs #:allow-other-keys)
             (substitute*
                 (string-append
                  (assoc-ref outputs "out") "/share/julia/packages/"
                  (strip-store-file-name source) "/src/LibExpat.jl")
               (("const libexpat = \"libexpat\"")
                (string-append "const libexpat = \""
                               (assoc-ref inputs "expat")
                               "/lib/libexpat.so\"")))
             #t)))))
    (propagated-inputs `(("julia-compat" ,julia-compat)
                         ("expat" ,expat)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaIO/LibExpat.jl")
    (synopsis "Julia interface to the Expat XML parser library")
    (description "Run XPath queries on fully parsed XML tree.")
    (license license:expat)))