;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2013, 2014, 2015, 2016 Ludovic Courtès <ludo@gnu.org>
;;; Copyright © 2013 Andreas Enge <andreas@enge.fr>
;;; Copyright © 2013 Nikita Karetnikov <nikita@karetnikov.org>
;;; Copyright © 2016 David Craven <david@craven.ch>
;;; Copyright © 2019 Ivan Petkov <ivanppetkov@gmail.com>
;;;
;;; 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 (guix build-system cargo)
  #:use-module (guix search-paths)
  #:use-module (guix store)
  #:use-module (guix utils)
  #:use-module (guix derivations)
  #:use-module (guix packages)
  #:use-module (guix build-system)
  #:use-module (guix build-system gnu)
  #:use-module (ice-9 match)
  #:use-module (srfi srfi-26)
  #:export (%cargo-build-system-modules
            %cargo-utils-modules
            cargo-build-system
            crate-url
            crate-url?
            crate-uri))

(define crate-url "https://crates.io/api/v1/crates/")
(define crate-url? (cut string-prefix? crate-url <>))

(define (crate-uri name version)
  "Return a URI string for the crate package hosted at crates.io corresponding
to NAME and VERSION."
  (string-append crate-url name "/" version "/download"))

(define (default-rust)
  "Return the default Rust package."
  ;; Lazily resolve the binding to avoid a circular dependency.
  (let ((rust (resolve-interface '(gnu packages rust))))
    (module-ref rust 'rust)))

(define %cargo-utils-modules
  ;; Build-side modules imported by default.
  `((guix build cargo-utils)
    ,@%gnu-build-system-modules))

(define %cargo-build-system-modules
  ;; Build-side modules imported by default.
  `((guix build cargo-build-system)
    (json parser)
    ,@%cargo-utils-modules))

(define* (cargo-build store name inputs
                      #:key
                      (tests? #t)
                      (test-target #f)
                      (vendor-dir "guix-vendor")
                      (cargo-build-flags ''("--release"))
                      (cargo-test-flags ''("--release"))
                      (skip-build? #f)
                      (phases '(@ (guix build cargo-build-system)
                                  %standard-phases))
                      (outputs '("out"))
                      (search-paths '())
                      (system (%current-system))
                      (guile #f)
                      (imported-modules %cargo-build-system-modules)
                      (modules '((guix build cargo-build-system)
                                 (guix build utils))))
  "Build SOURCE using CARGO, and with INPUTS."

  (define builder
    `(begin
       (use-modules ,@modules)
       (cargo-build #:name ,name
                    #:source ,(match (assoc-ref inputs "source")
                                (((? derivation? source))
                                 (derivation->output-path source))
                                ((source)
                                 source)
                                (source
                                 source))
                    #:system ,system
                    #:test-target ,test-target
                    #:vendor-dir ,vendor-dir
                    #:cargo-build-flags ,cargo-build-flags
                    #:cargo-test-flags ,cargo-test-flags
                    #:skip-build? ,skip-build?
                    #:tests? ,(and tests? (not skip-build?))
                    #:phases ,phases
                    #:outputs %outputs
                    #:search-paths ',(map search-path-specification->sexp
                                          search-paths)
                    #:inputs %build-inputs)))

  (define guile-for-build
    (match guile
      ((? package?)
       (package-derivation store guile system #:graft? #f))
      (#f                                         ; the default
       (let* ((distro (resolve-interface '(gnu packages commencement)))
              (guile  (module-ref distro 'guile-final)))
         (package-derivation store guile system #:graft? #f)))))

  (build-expression->derivation store name builder
                                #:inputs inputs
                                #:system system
                                #:modules imported-modules
                                #:outputs (cons "src" outputs)
                                #:guile-for-build guile-for-build))

(define package-target-inputs
  (lambda (pkg)
    (append (package-inputs pkg)
            (package-propagated-inputs pkg))))

(define* (expand-inputs inputs)
  "Return the transitive target inputs for each package in INPUTS.

Cargo requires all transitive crate dependencies to be available in its index,
even if they are optional (this is so it can generate deterministic
Cargo.lock files regardless of the target platform or enabled features).

Rather than burden the package definition to expand these, we'll automate
that process in the build system."
  (package-transitive-dependencies inputs package-target-inputs))

(define* (expand-native-inputs native-inputs)
  "Return the transitive target inputs for each package in NATIVE-INPUTS.

We need all transitive crate dependencies for any cargo dev-dependencies,
but this is only needed when building/testing a crate directly
(i.e. we will never need transitive dev-dependencies for any dependency
crates).

In addition, we need to modify any native-inputs to avoid any apparent
cycles. Cargo does not permit cyclic dependencies between crates, however,
it permits cycles to occur via dev-dependencies. For example, if crate X
depends on crate Y, crate Y's tests could pull in crate X to to verify
everything builds properly (this is a rare scenario, but it it happens for
example with the `proc-macro2` and `quote` crates). This is allowed by cargo
because tests are built as a pseudo-crate which happens to depend on the
X and Y crates, forming an acyclic graph.

Cargo ultimately needs only the crate sources available when doing a build.
Ultimately, if a cycle is detected, we can break it by replacing the current
crate we're trying to build with a no-op build which only packages the crate
source; cargo will then find the source available in its index and build things
properly."
  (map
    (lambda (dep)
      (match dep
       ((name input rest ...)
        ;; TODO: Starting out real simple by ensuring no native-inputs are
        ;; actually built so we don't accidentally hit a cycle. We can revisit
        ;; this later and more intelligently replace any dependency on the cycle
        ;; root with a version of the root with #:skip-build? enabled.
        ;;
        ;; Right now this means that if a package shows up in both input
        ;; and native-input closures, we'll try to build it's src output twice.
        ;;
        ;; This also means that we're potentially setting the #:skip-build?
        ;; flag on non cargo-build-system packages, but this should be okay
        ;; for now.
        (let* ((translated-input (package
                                   (inherit input)
                                   (inputs '())
                                   (propagated-inputs '())
                                   (native-inputs '())
                                   (arguments '(#:skip-build? #t)))))
          `(,name ,translated-input ,@rest)))))
   (package-transitive-dependencies native-inputs package-target-inputs)))

(define* (lower name
                #:key source inputs native-inputs outputs system target
                (rust (default-rust))
                #:allow-other-keys
                #:rest arguments)
  "Return a bag for NAME."

  (define private-keywords
    '(#:source #:target #:rust #:inputs #:native-inputs #:outputs))

  (and (not target) ;; TODO: support cross-compilation
       (bag
         (name name)
         (system system)
         (target target)
         (host-inputs `(,@(if source
                              `(("source" ,source))
                              '())
                        ,@(expand-inputs inputs)

                        ;; Keep the standard inputs of 'gnu-build-system'
                        ,@(standard-packages)))
         (build-inputs `(("cargo" ,rust "cargo")
                         ("rustc" ,rust)
                         ,@(expand-native-inputs native-inputs)))
         (outputs outputs)
         (build cargo-build)
         (arguments (strip-keyword-arguments private-keywords arguments)))))

(define cargo-build-system
  (build-system
    (name 'cargo)
    (description
     "Cargo build system, to build Rust crates")
    (lower lower)))