uboot: (firmwareOdroidC2/C4) don't invoke patch tool, use patches = [] instead

https://github.com/NixOS/nixpkgs/blob/master/pkgs/stdenv/generic/setup.sh#L948
this can do it nicely.

Signed-off-by: Anton Arapov <anton@deadbeef.mx>

pkgs/development/compilers/crystal/build-package.nix

@@ -0,0 +1,159 @@
+{ stdenv
+, lib
+, crystal
+, shards
+, git
+, pkg-config
+, which
+, linkFarm
+, fetchgit
+, fetchFromGitHub
+, installShellFiles
+, removeReferencesTo
+}:
+
+{
+  # Some projects do not include a lock file, so you can pass one
+  lockFile ? null
+  # Generate shards.nix with `nix-shell -p crystal2nix --run crystal2nix` in the projects root
+, shardsFile ? null
+  # We support different builders. To make things more straight forward, make it
+  # user selectable instead of trying to autodetect
+, format ? "make"
+, installManPages ? true
+  # Specify binaries to build in the form { foo.src = "src/foo.cr"; }
+  # The default `crystal build` options can be overridden with { foo.options = [ "--optionname" ]; }
+, crystalBinaries ? { }
+, enableParallelBuilding ? true
+, ...
+}@args:
+
+assert (builtins.elem format [ "make" "crystal" "shards" ]);
+let
+  mkDerivationArgs = builtins.removeAttrs args [
+    "format"
+    "installManPages"
+    "lockFile"
+    "shardsFile"
+    "crystalBinaries"
+  ];
+
+  crystalLib = linkFarm "crystal-lib" (lib.mapAttrsToList
+    (name: value: {
+      inherit name;
+      path =
+        if (builtins.hasAttr "url" value)
+        then fetchgit value
+        else fetchFromGitHub value;
+    })
+    (import shardsFile));
+
+  defaultOptions = [ "--release" "--progress" "--verbose" "--no-debug" ];
+
+  buildDirectly = shardsFile == null || crystalBinaries != { };
+
+  mkCrystalBuildArgs = bin: attrs:
+    lib.concatStringsSep " " ([
+      "crystal"
+      "build"
+    ] ++ lib.optionals enableParallelBuilding [
+      "--threads"
+      "$NIX_BUILD_CORES"
+    ] ++ [
+      "-o"
+      bin
+      (attrs.src or (throw "No source file for crystal binary ${bin} provided"))
+      (lib.concatStringsSep " " (attrs.options or defaultOptions))
+    ]);
+
+in
+stdenv.mkDerivation (mkDerivationArgs // {
+
+  configurePhase = args.configurePhase or lib.concatStringsSep "\n"
+    (
+      [
+        "runHook preConfigure"
+      ]
+      ++ lib.optional (lockFile != null) "cp ${lockFile} ./shard.lock"
+      ++ lib.optionals (shardsFile != null) [
+        "test -e lib || mkdir lib"
+        "for d in ${crystalLib}/*; do ln -s $d lib/; done"
+        "cp shard.lock lib/.shards.info"
+      ]
+      ++ [ "runHook postConfigure" ]
+    );
+
+  CRFLAGS = lib.concatStringsSep " " defaultOptions;
+
+  PREFIX = placeholder "out";
+
+  inherit enableParallelBuilding;
+  strictDeps = true;
+  buildInputs = args.buildInputs or [ ] ++ [ crystal ];
+
+  nativeBuildInputs = args.nativeBuildInputs or [ ] ++ [
+    crystal
+    git
+    installShellFiles
+    removeReferencesTo
+    pkg-config
+    which
+  ] ++ lib.optional (format != "crystal") shards;
+
+  buildPhase = args.buildPhase or (lib.concatStringsSep "\n" ([
+    "runHook preBuild"
+  ] ++ lib.optional (format == "make")
+    "make \${buildTargets:-build} $makeFlags"
+  ++ lib.optionals (format == "crystal") (lib.mapAttrsToList mkCrystalBuildArgs crystalBinaries)
+  ++ lib.optional (format == "shards")
+    "shards build --local --production ${lib.concatStringsSep " " (args.options or defaultOptions)}"
+  ++ [ "runHook postBuild" ]));
+
+  installPhase = args.installPhase or (lib.concatStringsSep "\n" ([
+    "runHook preInstall"
+  ] ++ lib.optional (format == "make")
+    "make \${installTargets:-install} $installFlags"
+  ++ lib.optionals (format == "crystal") (map
+    (bin: ''
+      install -Dm555 ${lib.escapeShellArgs [ bin "${placeholder "out"}/bin/${bin}" ]}
+    '')
+    (lib.attrNames crystalBinaries))
+  ++ lib.optional (format == "shards")
+    "install -Dm555 bin/* -t $out/bin"
+  ++ [
+    ''
+      for f in README* *.md LICENSE; do
+        test -f $f && install -Dm444 $f -t $out/share/doc/${args.pname}
+      done
+    ''
+  ] ++ (lib.optional installManPages ''
+    if [ -d man ]; then
+      installManPage man/*.?
+    fi
+  '') ++ [
+    "remove-references-to -t ${lib.getLib crystal} $out/bin/*"
+    "runHook postInstall"
+  ]));
+
+  doCheck = args.doCheck or true;
+
+  checkPhase = args.checkPhase or (lib.concatStringsSep "\n" ([
+    "runHook preCheck"
+  ] ++ lib.optional (format == "make")
+    "make \${checkTarget:-test} $checkFlags"
+  ++ lib.optional (format != "make")
+    "crystal \${checkTarget:-spec} $checkFlags"
+  ++ [ "runHook postCheck" ]));
+
+  doInstallCheck = args.doInstallCheck or true;
+
+  installCheckPhase = args.installCheckPhase or ''
+    for f in $out/bin/*; do
+      $f --help > /dev/null
+    done
+  '';
+
+  meta = args.meta or { } // {
+    platforms = args.meta.platforms or crystal.meta.platforms;
+  };
+})

pkgs/development/compilers/crystal/default.nix

@@ -0,0 +1,266 @@
+{ stdenv
+, callPackage
+, fetchFromGitHub
+, fetchurl
+, lib
+  # Dependencies
+, boehmgc
+, coreutils
+, git
+, gmp
+, hostname
+, libatomic_ops
+, libevent
+, libiconv
+, libxml2
+, libyaml
+, llvmPackages
+, makeWrapper
+, openssl
+, pcre
+, pkg-config
+, readline
+, tzdata
+, which
+, zlib
+}:
+
+# We need to keep around at least the latest version released with a stable
+# NixOS
+let
+  archs = {
+    x86_64-linux = "linux-x86_64";
+    i686-linux = "linux-i686";
+    x86_64-darwin = "darwin-x86_64";
+    aarch64-darwin = "darwin-universal";
+    aarch64-linux = "linux-aarch64";
+  };
+
+  arch = archs.${stdenv.system} or (throw "system ${stdenv.system} not supported");
+  isAarch64Darwin = stdenv.system == "aarch64-darwin";
+
+  checkInputs = [ git gmp openssl readline libxml2 libyaml ];
+
+  binaryUrl = version: rel:
+    if arch == archs.aarch64-linux then
+      "https://dev.alpinelinux.org/archive/crystal/crystal-${version}-aarch64-alpine-linux-musl.tar.gz"
+    else
+      "https://github.com/crystal-lang/crystal/releases/download/${version}/crystal-${version}-${toString rel}-${arch}.tar.gz";
+
+  genericBinary = { version, sha256s, rel ? 1 }:
+    stdenv.mkDerivation rec {
+      pname = "crystal-binary";
+      inherit version;
+
+      src = fetchurl {
+        url = binaryUrl version rel;
+        sha256 = sha256s.${stdenv.system};
+      };
+
+      buildCommand = ''
+        mkdir -p $out
+        tar --strip-components=1 -C $out -xf ${src}
+        patchShebangs $out/bin/crystal
+      '';
+
+      meta.broken = lib.versionOlder version "1.2.0" && isAarch64Darwin;
+    };
+
+  commonBuildInputs = extraBuildInputs: [
+    boehmgc
+    libatomic_ops
+    pcre
+    libevent
+    libyaml
+    zlib
+    libxml2
+    openssl
+  ] ++ extraBuildInputs
+  ++ lib.optionals stdenv.isDarwin [ libiconv ];
+
+  generic = (
+    { version
+    , sha256
+    , binary
+    , doCheck ? true
+    , extraBuildInputs ? [ ]
+    , buildFlags ? [ "all" "docs" ]
+    }:
+    lib.fix (compiler: stdenv.mkDerivation {
+      pname = "crystal";
+      inherit buildFlags doCheck version;
+
+      src = fetchFromGitHub {
+        owner = "crystal-lang";
+        repo = "crystal";
+        rev = version;
+        inherit sha256;
+      };
+
+      outputs = [ "out" "lib" "bin" ];
+
+      postPatch = ''
+        export TMP=$(mktemp -d)
+        export HOME=$TMP
+        mkdir -p $HOME/test
+
+        # Add dependency of crystal to docs to avoid issue on flag changes between releases
+        # https://github.com/crystal-lang/crystal/pull/8792#issuecomment-614004782
+        substituteInPlace Makefile \
+          --replace 'docs: ## Generate standard library documentation' 'docs: crystal ## Generate standard library documentation'
+
+        substituteInPlace src/crystal/system/unix/time.cr \
+          --replace /usr/share/zoneinfo ${tzdata}/share/zoneinfo
+
+        ln -sf spec/compiler spec/std
+
+        mkdir -p $TMP/crystal
+
+        substituteInPlace spec/std/file_spec.cr \
+          --replace '/bin/ls' '${coreutils}/bin/ls' \
+          --replace '/usr/share' "$TMP/crystal" \
+          --replace '/usr' "$TMP" \
+          --replace '/tmp' "$TMP"
+
+        substituteInPlace spec/std/process_spec.cr \
+          --replace '/bin/cat' '${coreutils}/bin/cat' \
+          --replace '/bin/ls' '${coreutils}/bin/ls' \
+          --replace '/usr/bin/env' '${coreutils}/bin/env' \
+          --replace '"env"' '"${coreutils}/bin/env"' \
+          --replace '/usr' "$TMP" \
+          --replace '/tmp' "$TMP"
+
+        substituteInPlace spec/std/system_spec.cr \
+          --replace '`hostname`' '`${hostname}/bin/hostname`'
+
+        # See https://github.com/crystal-lang/crystal/issues/8629
+        substituteInPlace spec/std/socket/udp_socket_spec.cr \
+          --replace 'it "joins and transmits to multicast groups"' 'pending "joins and transmits to multicast groups"'
+      '';
+
+      # Defaults are 4
+      preBuild = ''
+        export CRYSTAL_WORKERS=$NIX_BUILD_CORES
+        export threads=$NIX_BUILD_CORES
+        export CRYSTAL_CACHE_DIR=$TMP
+      '';
+
+
+      strictDeps = true;
+      nativeBuildInputs = [ binary makeWrapper which pkg-config llvmPackages.llvm ];
+      buildInputs = commonBuildInputs extraBuildInputs;
+
+      makeFlags = [
+        "CRYSTAL_CONFIG_VERSION=${version}"
+      ];
+
+      LLVM_CONFIG = "${llvmPackages.llvm.dev}/bin/llvm-config";
+
+      FLAGS = [
+        "--release"
+        "--single-module" # needed for deterministic builds
+      ];
+
+      # This makes sure we don't keep depending on the previous version of
+      # crystal used to build this one.
+      CRYSTAL_LIBRARY_PATH = "${placeholder "lib"}/crystal";
+
+      # We *have* to add `which` to the PATH or crystal is unable to build
+      # stuff later if which is not available.
+      installPhase = ''
+        runHook preInstall
+
+        install -Dm755 .build/crystal $bin/bin/crystal
+        wrapProgram $bin/bin/crystal \
+          --suffix PATH : ${lib.makeBinPath [ pkg-config llvmPackages.clang which ]} \
+          --suffix CRYSTAL_PATH : lib:$lib/crystal \
+          --suffix CRYSTAL_LIBRARY_PATH : ${
+            lib.makeLibraryPath (commonBuildInputs extraBuildInputs)
+          }
+        install -dm755 $lib/crystal
+        cp -r src/* $lib/crystal/
+
+        install -dm755 $out/share/doc/crystal/api
+        cp -r docs/* $out/share/doc/crystal/api/
+        cp -r samples $out/share/doc/crystal/
+
+        install -Dm644 etc/completion.bash $out/share/bash-completion/completions/crystal
+        install -Dm644 etc/completion.zsh $out/share/zsh/site-functions/_crystal
+
+        install -Dm644 man/crystal.1 $out/share/man/man1/crystal.1
+
+        install -Dm644 -t $out/share/licenses/crystal LICENSE README.md
+
+        mkdir -p $out
+        ln -s $bin/bin $out/bin
+        ln -s $lib $out/lib
+
+        runHook postInstall
+      '';
+
+      enableParallelBuilding = true;
+
+      dontStrip = true;
+
+      checkTarget = "compiler_spec";
+
+      preCheck = ''
+        export LIBRARY_PATH=${lib.makeLibraryPath checkInputs}:$LIBRARY_PATH
+        export PATH=${lib.makeBinPath checkInputs}:$PATH
+      '';
+
+      passthru.buildCrystalPackage = callPackage ./build-package.nix {
+        crystal = compiler;
+      };
+
+      meta = with lib; {
+        broken = stdenv.isDarwin;
+        description = "A compiled language with Ruby like syntax and type inference";
+        homepage = "https://crystal-lang.org/";
+        license = licenses.asl20;
+        maintainers = with maintainers; [ david50407 manveru peterhoeg ];
+        platforms = let archNames = builtins.attrNames archs; in
+          if (lib.versionOlder version "1.2.0") then remove "aarch64-darwin" archNames else archNames;
+      };
+    })
+  );
+
+in
+rec {
+  binaryCrystal_1_0 = genericBinary {
+    version = "1.0.0";
+    sha256s = {
+      x86_64-linux = "1949argajiyqyq09824yj3wjyv88gd8wbf20xh895saqfykiq880";
+      i686-linux = "0w0f4fwr2ijhx59i7ppicbh05hfmq7vffmgl7lal6im945m29vch";
+      x86_64-darwin = "01n0rf8zh551vv8wq3h0ifnsai0fz9a77yq87xx81y9dscl9h099";
+      aarch64-linux = "0sns7l4q3z82qi3dc2r4p63f4s8hvifqzgq56ykwyrvawynjhd53";
+    };
+  };
+
+  binaryCrystal_1_2 = genericBinary {
+    version = "1.2.0";
+    sha256s = {
+      aarch64-darwin = "1hrs8cpjxdkcf8mr9qgzilwbg6bakq87sd4yydfsk2f4pqd6g7nf";
+    };
+  };
+
+  crystal_1_0 = generic {
+    version = "1.0.0";
+    sha256 = "sha256-RI+a3w6Rr+uc5jRf7xw0tOenR+q6qii/ewWfID6dbQ8=";
+    binary = binaryCrystal_1_0;
+  };
+
+  crystal_1_1 = generic {
+    version = "1.1.1";
+    sha256 = "sha256-hhhT3reia8acZiPsflwfuD638Ll2JiXwMfES1TyGyNQ=";
+    binary = crystal_1_0;
+  };
+
+  crystal_1_2 = generic {
+    version = "1.2.2";
+    sha256 = "sha256-nyOXhsutVBRdtJlJHe2dALl//BUXD1JeeQPgHU4SwiU=";
+    binary = if isAarch64Darwin then binaryCrystal_1_2 else crystal_1_1;
+  };
+
+  crystal = crystal_1_2;
+}