;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2016 David Craven <david@craven.ch>
;;; Copyright © 2016 Eric Le Bihan <eric.le.bihan.dev@free.fr>
;;; Copyright © 2016, 2017 ng0 <ng0@libertad.pw>
;;;
;;; 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 rust)
  #:use-module (gnu packages base)
  #:use-module (gnu packages bootstrap)
  #:use-module (gnu packages cmake)
  #:use-module (gnu packages compression)
  #:use-module (gnu packages elf)
  #:use-module (gnu packages gcc)
  #:use-module (gnu packages jemalloc)
  #:use-module (gnu packages llvm)
  #:use-module (gnu packages python)
  #:use-module (gnu packages qt)
  #:use-module (gnu packages version-control)
  #:use-module (guix build-system gnu)
  #:use-module (guix build-system trivial)
  #:use-module (guix build-system cargo)
  #:use-module (guix download)
  #:use-module ((guix licenses) #:prefix license:)
  #:use-module (guix packages)
  #:use-module (ice-9 match)
  #:use-module (srfi srfi-26))

;; Should be one less than the current released version.
(define %rust-bootstrap-binaries-version "1.13.0")

(define %rust-bootstrap-binaries
  (origin
    (method url-fetch)
    (uri (string-append
          "https://static.rust-lang.org/dist/"
          "rust-" %rust-bootstrap-binaries-version
          "-i686-unknown-linux-gnu.tar.gz"))
    (sha256
     (base32
      "0fcl7xgm2m21sjv1f27i3v692aa91lk8r867hl8d6l377w8k95r3"))))

(define (increment-rust-version rust-version major patch)
  (match (string-split rust-version #\.)
    (("1" minor _)
     (string-append (number->string major) "."
                    (number->string (+ (string->number minor) 1)) "."
                    (number->string patch)))))

(define* (cargo-version rustc-version #:optional (patch 0))
  ;; Computes the cargo version that matches the rustc version.
  ;; https://github.com/rust-lang/cargo#Releases
  (increment-rust-version rustc-version 0 patch))

(define* (rustc-version bootstrap-version #:optional (patch 0))
  ;; Computes the rustc version that can be compiled from a given
  ;; other rustc version. The patch argument is for selecting
  ;; a stability or security fix. 1.11.0 -> 1.12.1 -> 1.13.0
  (increment-rust-version bootstrap-version 1 patch))

(define rustc-bootstrap
  (package
    (name "rustc-bootstrap")
    (version %rust-bootstrap-binaries-version)
    (source %rust-bootstrap-binaries)
    (build-system gnu-build-system)
    (native-inputs
     `(("patchelf" ,patchelf)))
    (inputs
     `(("gcc:lib" ,(canonical-package gcc) "lib")
       ("zlib" ,zlib)))
    (arguments
     `(#:tests? #f
       #:strip-binaries? #f
       #:system "i686-linux"
       #:phases
       (modify-phases %standard-phases
         (delete 'configure)
         (delete 'build)
         (replace 'install
           (lambda* (#:key inputs outputs #:allow-other-keys)
             (let* ((out (assoc-ref outputs "out"))
                    (gcc:lib (assoc-ref inputs "gcc:lib"))
                    (libc (assoc-ref inputs "libc"))
                    (zlib (assoc-ref inputs "zlib"))
                    (ld-so (string-append libc
                                          ,(glibc-dynamic-linker "i686-linux")))
                    (rpath (string-append out "/lib:" zlib "/lib:"
                                          libc "/lib:" gcc:lib "/lib"))
                    (rustc (string-append out "/bin/rustc"))
                    (rustdoc (string-append out "/bin/rustdoc")))
               (system* "bash" "install.sh"
                        (string-append "--prefix=" out)
                        (string-append "--components=rustc,"
                                       "rust-std-i686-unknown-linux-gnu"))
               (for-each (lambda (file)
                           (system* "patchelf" "--set-rpath" rpath file))
                         (cons* rustc rustdoc (find-files out "\\.so$")))
               (for-each (lambda (file)
                           (system* "patchelf" "--set-interpreter" ld-so file))
                         (list rustc rustdoc))))))))
    (supported-systems '("i686-linux" "x86_64-linux"))
    (home-page "https://www.rust-lang.org")
    (synopsis "Prebuilt rust compiler")
    (description "This package provides a pre-built @command{rustc} compiler,
which can in turn be used to build the final Rust compiler.")
    (license license:asl2.0)))

;; FIXME: Make private once cargo is packaged. Is currently used by the
;; cargo-build-system.
(define-public cargo-bootstrap
  (package
    (name "cargo-bootstrap")
    (version (cargo-version %rust-bootstrap-binaries-version))
    (source %rust-bootstrap-binaries)
    (build-system gnu-build-system)
    (native-inputs
     `(("patchelf" ,patchelf)))
    (inputs
     `(("gcc:lib" ,(canonical-package gcc) "lib")))
    (arguments
     `(#:tests? #f
       #:strip-binaries? #f
       #:system "i686-linux"
       #:phases
       (modify-phases %standard-phases
         (delete 'configure)
         (delete 'build)
         (replace 'install
           (lambda* (#:key inputs outputs #:allow-other-keys)
             (let* ((out (assoc-ref outputs "out"))
                    (gcc:lib (assoc-ref inputs "gcc:lib"))
                    (libc (assoc-ref inputs "libc"))
                    (ld-so (string-append libc
                                          ,(glibc-dynamic-linker "i686-linux")))
                    (rpath (string-append out "/lib:" libc "/lib:"
                                          gcc:lib "/lib"))
                    (cargo (string-append out "/bin/cargo")))
               (system* "bash" "install.sh"
                        (string-append "--prefix=" out)
                        "--components=cargo")
               (system* "patchelf"
                        "--set-interpreter" ld-so
                        "--set-rpath" rpath
                        cargo)))))))
    (supported-systems '("i686-linux" "x86_64-linux"))
    (home-page "https://www.rust-lang.org")
    (synopsis "Prebuilt cargo package manager")
    (description "This package provides a pre-built @command{cargo} package
manager, which is required to build itself.")
    (license license:asl2.0)))

(define rust-bootstrap
  (package
    (name "rust-bootstrap")
    (version %rust-bootstrap-binaries-version)
    (source #f)
    (build-system trivial-build-system)
    (propagated-inputs
     `(("rustc-bootstrap" ,rustc-bootstrap)
       ("cargo-bootstrap" ,cargo-bootstrap)
       ("gcc" ,(canonical-package gcc))))
    (arguments
     `(#:modules ((guix build utils))
       #:builder
       (begin
         (use-modules (guix build utils))
         (let ((out (assoc-ref %outputs "out"))
               (gcc (assoc-ref %build-inputs "gcc")))
           (mkdir-p (string-append out "/bin"))
           ;; Rust requires a C toolchain for linking. The prebuilt
           ;; binaries expect a compiler called cc. Thus symlink gcc
           ;; to cc.
           (symlink (string-append gcc "/bin/gcc")
                    (string-append out "/bin/cc"))))))
    (home-page "https://www.rust-lang.org")
    (synopsis "Rust bootstrapping meta package")
    (description "Meta package for a rust environment. Provides pre-compiled
rustc-bootstrap and cargo-bootstrap packages.")
    (license license:asl2.0)))

(define-public rustc
  (package
    (name "rustc")
    (version (rustc-version %rust-bootstrap-binaries-version))
    (source (origin
              (method url-fetch)
              (uri (string-append
                    "https://static.rust-lang.org/dist/"
                    "rustc-" version "-src.tar.gz"))
              (sha256
               (base32
                "0srvmhhdbbcl21nzg9m9zni7k10h88lsy8k1ljz03g8mx79fv467"))))
    (build-system gnu-build-system)
    (native-inputs
     `(("cmake" ,cmake)
       ("git" ,git)
       ("python-2" ,python-2)
       ("rust-bootstrap" ,rust-bootstrap)
       ("which" ,which)))
    (inputs
     `(("jemalloc" ,jemalloc)
       ("llvm" ,llvm)))
    (arguments
     ;; FIXME: Test failure with llvm 3.8; Update llvm.
     ;; https://github.com/rust-lang/rust/issues/36835
     `(#:tests? #f
       #:phases
       (modify-phases %standard-phases
         (add-after 'unpack 'patch-configure
           (lambda _
             ;; Detect target CPU correctly.
             (substitute* "configure"
               (("/usr/bin/env") (which "env")))
             ;; Avoid curl as a build dependency.
             (substitute* "configure"
               (("probe_need CFG_CURL curl") ""))))
         (add-after 'unpack 'set-env
           (lambda _
             (setenv "SHELL" (which "sh"))
             (setenv "CONFIG_SHELL" (which "sh"))))
         (add-after 'unpack 'patch-lockfile-test
           (lambda _
             (substitute* "src/tools/tidy/src/main.rs"
               (("^.*cargo.*::check.*$") ""))))
         (replace 'configure
           (lambda* (#:key inputs outputs #:allow-other-keys)
             (let* ((out (assoc-ref outputs "out"))
                    (gcc (assoc-ref inputs "gcc"))
                    (python (assoc-ref inputs "python-2"))
                    (rustc (assoc-ref inputs "rustc-bootstrap"))
                    (llvm (assoc-ref inputs "llvm"))
                    (jemalloc (assoc-ref inputs "jemalloc"))
                    (flags (list
                            (string-append "--prefix=" out)
                            (string-append "--datadir=" out "/share")
                            (string-append "--infodir=" out "/share/info")
                            (string-append "--default-linker=" gcc "/bin/gcc")
                            (string-append "--default-ar=" gcc "/bin/ar")
                            (string-append "--python=" python "/bin/python2")
                            (string-append "--local-rust-root=" rustc)
                            (string-append "--llvm-root=" llvm)
                            (string-append "--jemalloc-root=" jemalloc "/lib")
                            "--release-channel=stable"
                            "--enable-rpath"
                            "--enable-local-rust"
                            ;;"--enable-rustbuild"
                            "--disable-manage-submodules")))
               ;; Rust uses a custom configure script (no autoconf).
               (zero? (apply system* "./configure" flags))))))))
    (synopsis "Compiler for the Rust progamming language")
    (description "Rust is a systems programming language that provides memory
safety and thread safety guarantees.")
    (home-page "https://www.rust-lang.org")
    ;; Dual licensed.
    (license (list license:asl2.0 license:expat))))

(define-public rust-libc
  (package
    (name "rust-libc")
    (version "0.2.18")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "libc" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "0w5cghr0wx3hi2sclk8r9iyzlbxsakil87ada40q2ykyhky24655"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/rust-lang/libc")
    (synopsis "Raw bindings to platform APIs for Rust")
    (description
     "Libc provides a library for types and bindings to native
C functions often found in libc or other common platform libraries.")
    (license (list license:expat license:asl2.0))))

(define-public rust-spin
  (package
    (name "rust-spin")
    (version "0.4.5")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "spin" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "0lvyyxg646wl67b41655p2z25s725sw1rsfvpnm8d7vq5dpa45hx"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/mvdnes/spin-rs.git")
    (synopsis "Spin is a library which implements a simple spinlock")
    (description
     "Synchronization primitives based on spinning.  They may contain
data, they are usable without `std` and static initializers are
available.")
    (license license:expat)))

(define-public rust-lazy-static
  (package
    (name "rust-lazy-static")
    (version "0.2.2")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "lazy_static" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "16z1h7w702sxnscak38jykxlhxq0b5ip4mndlb46pkaqwzi0xgka"))))
    (build-system cargo-build-system)
    (inputs `(("rust-spin" ,rust-spin "src")))
    (home-page "https://github.com/rust-lang-nursery/lazy-static.rs")
    (synopsis "Macro for declaring lazily evaluated statics")
    (description
     "Lazy-static provides a macro for declaring lazily
evaluated statics in Rust.")
    (license license:expat)))

(define-public rust-qml
  (package
    (name "rust-qml")
    (version "0.0.9")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "qml" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "1inbzzd7rg5fvypl927hmy0qdc899mbjp7x5b0wmk6869ril2nsy"))))
    (build-system cargo-build-system)
    (inputs
     `(("rust-lazy-static" ,rust-lazy-static "src")
       ("rust-libc" ,rust-libc "src")))
    (propagated-inputs
     ;; Rust has no concept for outside packages, but DOtherSide is
     ;; a dependency according to the github page.
     `(("dotherside" ,dotherside)))
    (home-page "https://github.com/White-Oak/qml-rust")
    (synopsis "QML (Qt Quick) bindings for Rust language")
    (description
     "QML-rust provides bindings for Qt Quick.  The bindings are based
on @code{DOtherSide} C bindings for QML Library.  It is mostly
feature-compliant with other bindings based on the library.")
    (license license:expat)))

(define-public rust-log
  (package
    (name "rust-log")
    (version "0.3.6")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "log" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "0m40hgs3cg57dd5kk1mabfk6gk8z6l1cihar8akx4kmzz1xlk0xb"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/rust-lang/log")
    (synopsis "Logging implementation for Rust")
    (description
     "Log provides a logging facade.  Libraries can use the provided
logging API, and the consumer of those libraries can choose the logging
implementation that is most suitable for its use case.")
    (license (list license:expat license:asl2.0))))

(define-public rust-futures
  (package
    (name "rust-futures")
    (version "0.1.7")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "futures" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "087yvc0baprw507nlr6lwkzd57a99gjj8zz95h12irfp3nk84yhp"))))
    (build-system cargo-build-system)
    (inputs `(("rust-log" ,rust-log "src")))
    (home-page "https://github.com/alexcrichton/futures-rs")
    (synopsis "Zero-cost futures and streams implementation")
    (description
     "Futures is a library implementation of futures and streams
featuring zero allocations, composability, and iterator-like interfaces.")
    (license (list license:expat license:asl2.0))))

(define-public rust-rand
  (package
    (name "rust-rand")
    (version "0.3.15")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "rand" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "178qgglinqawwsw6l8imgnplxkmxcj404jqm92pds695xhv0cbh2"))))
    (build-system cargo-build-system)
    (native-inputs `(("rust-log" ,rust-log "src")))
    (inputs `(("rust-libc" ,rust-libc "src")))
    (home-page "https://github.com/rust-lang/rand")
    (synopsis "Random number generators and other randomness")
    (description
     "Library for random number generators and other randomness functionality.")
    (license (list license:expat license:asl2.0))))

(define-public rust-nix-test
  (package
    (name "rust-nix-test")
    (version "0.0.1")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "nix-test" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "1g7i9p3lizipyg99swdmkg0jyxm0i3wm2jkf7hrbrkk3k3rbhp9y"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/carllerche/nix-rust")
    (synopsis "Bindings to *nix APIs")
    (description
     "Nix-test provides the testing helpers for nix.  Nix seeks to
provide bindings to various *nix platform APIs.
The goal is to not provide a 100% unified interface, but to
unify what can be while still providing platform specific APIs.

For many system APIs, Nix provides a safe alternative to the unsafe API
exposed by the libc crate.  This is done by wrapping the libc
functionality with types/abstractions that enforce legal/safe usage.")
    (license license:expat)))

(define-public rust-void
  (package
    (name "rust-void")
    (version "1.0.2")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "void" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "0zc8f0ksxvmhvgx4fdg0zyn6vdnbxd2xv9hfx4nhzg6kbs4f80ka"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/reem/rust-void.git")
    (synopsis "Uninhabited void type for use in statically impossible cases")
    (description
     "The uninhabited type, @code{enum Void { }} is useful in dealing
with cases you know to be impossible.  If you are implementing a trait
which allows for error checking, but your case always succeeds, you can
mark the error case or type as Void, signaling to the compiler it can
never happen.
This crate also comes packed with a few traits offering extension
methods to @code{Result<T, Void>} and @code{Result<Void, T>}.")
    (license license:expat)))

(define-public rust-slab
  (package
    (name "rust-slab")
    (version "0.3.0")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "slab" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "08xw8w61zdfn1094qkq1d554vh5wmm9bqdys8gqqxc4sv2pgrd0p"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/carllerche/slab")
    (synopsis "Simple slab allocator")
    (description
     "Slab Allocator for Rust.  Preallocate memory for values
of a given type.")
    (license license:expat)))

(define-public rust-winapi-build
  (package
    (name "rust-winapi-build")
    (version "0.1.1")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "winapi-build" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "1g4rqsgjky0a7530qajn2bbfcrl2v0zb39idgdws9b1l7gp5wc9d"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/retep998/winapi-rs")
    (synopsis "Common code for build.rs in WinAPI -sys crates.")
    (description
     "Common code for build.rs in WinAPI -sys crates.")
    (license license:expat)))

(define-public rust-tempdir
  (package
    (name "rust-tempdir")
    (version "0.3.5")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "tempdir" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "1mij45kgzflkja0h8q9avrik76h5a0b60m9hfd6k9yqxbiplm5w7"))))
    (build-system cargo-build-system)
    (inputs `(("rust-rand" ,rust-rand "src")))
    (home-page "https://github.com/rust-lang/tempdir")
    (synopsis "Library for managing a temporary directory")
    (description
     "Tempdir provides a library for managing a temporary directory and
deleting all contents when it's dropped.")
    (license (list license:expat license:asl2.0))))