Merge pull request #42669 from obsidiansystems/upstream-plist

Upstream PLIST handling

lib/generators.nix

···
                        fna);
       in if fna == {}    then "<λ>"
                          else "<λ:{${showFnas}}>"
-    else abort "toPretty: should never happen (v = ${v})";
+    else abort "generators.toPretty: should never happen (v = ${v})";
+
+  # PLIST handling
+  toPlist = {}: v: let
+    expr = ind: x: with builtins;
+      if isNull x then "" else
+      if isBool x then bool ind x else
+      if isInt x then int ind x else
+      if isString x then str ind x else
+      if isList x then list ind x else
+      if isAttrs x then attrs ind x else
+      abort "generators.toPlist: should never happen (v = ${v})";
+
+    literal = ind: x: ind + x;
+
+    bool = ind: x: literal ind  (if x then "<true/>" else "<false/>");
+    int = ind: x: literal ind "<integer>${toString x}</integer>";
+    str = ind: x: literal ind "<string>${x}</string>";
+    key = ind: x: literal ind "<key>${x}</key>";
+
+    indent = ind: expr "\t${ind}";
+
+    item = ind: libStr.concatMapStringsSep "\n" (indent ind);
+
+    list = ind: x: libStr.concatStringsSep "\n" [
+      (literal ind "<array>")
+      (item ind x)
+      (literal ind "</array>")
+    ];
+
+    attrs = ind: x: libStr.concatStringsSep "\n" [
+      (literal ind "<dict>")
+      (attr ind x)
+      (literal ind "</dict>")
+    ];
+
+    attr = let attrFilter = name: value: name != "_module" && value != null;
+    in ind: x: libStr.concatStringsSep "\n" (lib.flatten (lib.mapAttrsToList
+      (name: value: lib.optional (attrFilter name value) [
+      (key "\t${ind}" name)
+      (expr "\t${ind}" value)
+    ]) x));
+
+  in ''<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+${expr "" v}
+</plist>'';
 
 }

pkgs/applications/networking/syncthing-gtk/default.nix

···
-{ stdenv, fetchFromGitHub, fetchpatch, libnotify, librsvg, darwin, psmisc, gtk3, libappindicator-gtk3, substituteAll, syncthing, wrapGAppsHook, gnome3, buildPythonApplication, dateutil, pyinotify, pygobject3, bcrypt, gobjectIntrospection }:
+{ stdenv, fetchFromGitHub, fetchpatch, libnotify, librsvg, killall
+, gtk3, libappindicator-gtk3, substituteAll, syncthing, wrapGAppsHook
+, gnome3, buildPythonApplication, dateutil, pyinotify, pygobject3
+, bcrypt, gobjectIntrospection }:
 
 buildPythonApplication rec {
   version = "0.9.4";
···
     })
     (substituteAll {
       src = ./paths.patch;
-      killall = "${if stdenv.isDarwin then darwin.shell_cmds else psmisc}/bin/killall";
+      killall = "${killall}/bin/killall";
       syncthing = "${syncthing}/bin/syncthing";
     })
   ];

pkgs/development/tools/xcbuild/default.nix

···
-{ stdenv, cmake, fetchFromGitHub, zlib, libxml2, libpng, CoreServices, CoreGraphics, ImageIO, ninja }:
+{ stdenv, cmake, fetchFromGitHub, zlib, libxml2, libpng
+, CoreServices, CoreGraphics, ImageIO, ninja }:
 
 let
   googletest = fetchFromGitHub {
···
 in stdenv.mkDerivation rec {
   name    = "xcbuild-${version}";
 
-  # Once a version is released that includes https://github.com/facebook/xcbuild/commit/183c087a6484ceaae860c6f7300caf50aea0d710,
+  # Once a version is released that includes
+  # https://github.com/facebook/xcbuild/commit/183c087a6484ceaae860c6f7300caf50aea0d710,
   # we can stop doing this -pre thing.
   version = "0.1.2-pre";
 

pkgs/development/tools/xcbuild/platform.nix

···
-{ stdenv, sdk, writeText, platformName, xcbuild }:
+{ runCommand, lib, sdk, platformName, writeText }:
 
 let
+
+  inherit (lib.generators) toPlist;
 
   Info = {
     CFBundleIdentifier = platformName;
···
 
 in
 
-stdenv.mkDerivation {
-  name = "MacOSX.platform";
-  buildInputs = [ xcbuild ];
-  buildCommand = ''
-    mkdir -p $out/
-    cd $out/
-
-    plutil -convert xml1 -o Info.plist ${writeText "Info.plist" (builtins.toJSON Info)}
-    plutil -convert xml1 -o version.plist ${writeText "version.plist" (builtins.toJSON Version)}
-
-    mkdir -p $out/Developer/Library/Xcode/Specifications/
-    cd $out/Developer/Library/Xcode/Specifications/
-    plutil -convert xml1 -o Architectures.xcspec ${writeText "Architectures.xcspec" (builtins.toJSON Architectures)}
-    plutil -convert xml1 -o PackageTypes.xcspec ${writeText "PackageTypes.xcspec" (builtins.toJSON PackageTypes)}
-    plutil -convert xml1 -o ProductTypes.xcspec ${writeText "ProductTypes.xcspec" (builtins.toJSON ProductTypes)}
+runCommand "MacOSX.platform" {} ''
+  install -D ${writeText "Info.plist" (toPlist {} Info)} $out/Info.plist
+  install -D ${writeText "version.plist" (toPlist {} Version)} $out/version.plist
+  install -D ${writeText "Architectures.xcspec" (toPlist {} Architectures)} $out/Developer/Library/Xcode/Specifications/Architectures.xcspec
+  install -D ${writeText "PackageTypes.xcspec" (toPlist {} PackageTypes)} $out/Developer/Library/Xcode/Specifications/PackageTypes.xcspec
+  install -D ${writeText "ProductTypes.xcspec" (toPlist {} ProductTypes)} $out/Developer/Library/Xcode/Specifications/ProductTypes.xcspec
 
-    mkdir -p $out/Developer/SDKs/
-    cd $out/Developer/SDKs/
-    cp -r ${sdk} ${sdk.name}
-  '';
-}
+  mkdir -p $out/Developer/SDKs/
+  cd $out/Developer/SDKs/
+  cp -r ${sdk} ${sdk.name}
+''

pkgs/development/tools/xcbuild/sdk.nix

···
-{ stdenv, writeText, toolchainName, sdkName, xcbuild }:
+{ runCommand, lib, toolchainName, sdkName, writeText }:
 
 let
+  inherit (lib.generators) toPlist;
+
   # TODO: expose MACOSX_DEPLOYMENT_TARGET in nix so we can use it here.
   version = "10.10";
 
···
   };
 in
 
-stdenv.mkDerivation {
-  name = "MacOSX${version}.sdk";
+runCommand "MacOSX${version}.sdk" {
   inherit version;
-
-  buildInputs = [ xcbuild ];
-
-  buildCommand = ''
-    mkdir -p $out/
-    plutil -convert xml1 -o $out/SDKSettings.plist ${writeText "SDKSettings.json" (builtins.toJSON SDKSettings)}
-
-    mkdir -p $out/System/Library/CoreServices/
-    plutil -convert xml1 -o $out/System/Library/CoreServices/SystemVersion.plist ${writeText "SystemVersion.plist" (builtins.toJSON SystemVersion)}
-  '';
-}
+} ''
+  install -D ${writeText "SDKSettings.plist" (toPlist {} SDKSettings)} $out/SDKSettings.plist
+  install -D ${writeText "SystemVersion.plist" (toPlist {} SystemVersion)} $out/System/Library/CoreServices/SystemVersion.plist
+''

pkgs/development/tools/xcbuild/toolchain.nix

···
-{stdenv, writeText, toolchainName, xcbuild, fetchurl
-, llvm, cctools, gcc, bootstrap_cmds, binutils
-, yacc, flex, m4, unifdef, gperf, indent, ctags, makeWrapper
-, xib2nib}:
+{ runCommand, toolchainName, fetchurl, makeWrapper, stdenv
+, buildPackages, lib, writeText }:
 
 let
+
+  inherit (lib) getBin optionalString;
+  inherit (lib.generators) toPlist;
 
   ToolchainInfo = {
     Identifier = toolchainName;
   };
 
-  # We could pull this out of developer_cmds but it adds an annoying loop if we want to bootstrap and
-  # this is just a tiny script so I'm not going to bother
+  # We could pull this out of developer_cmds but it adds an annoying
+  # loop if we want to bootstrap and this is just a tiny script so I'm
+  # not going to bother.
   mkdep-darwin-src = fetchurl {
     url        = "https://opensource.apple.com/source/developer_cmds/developer_cmds-63/mkdep/mkdep.sh";
     sha256     = "0n4wpqfslfjs5zbys5yri8pfi2awyhlmknsf6laa5jzqbzq9x541";
···
   };
 in
 
-stdenv.mkDerivation {
-  name = "nixpkgs.xctoolchain";
-  buildInputs = [ xcbuild makeWrapper ];
-
-  ## cctools should build on Linux but it doesn't currently
-
-  buildCommand = ''
-    mkdir -p $out
-    plutil -convert xml1 -o $out/ToolchainInfo.plist ${writeText "ToolchainInfo.plist" (builtins.toJSON ToolchainInfo)}
-
-    mkdir -p $out/usr/include
-    mkdir -p $out/usr/lib
-    mkdir -p $out/usr/libexec
-    mkdir -p $out/usr/share
-
-    mkdir -p $out/usr/bin
-    cd $out/usr/bin
-    ln -s ${stdenv.cc}/bin/cpp
-    ln -s ${stdenv.cc}/bin/c++
-    ln -s ${stdenv.cc}/bin/cc
-    ln -s c++ clang++
-    ln -s cc clang
-
-    ln -s ${llvm}/bin/llvm-cov
-    ln -s ${llvm}/bin/llvm-dsymutil
-    ln -s ${llvm}/bin/llvm-dwarfdump
-    ln -s ${llvm}/bin/llvm-nm
-    ln -s ${llvm}/bin/llvm-objdump
-    ln -s ${llvm}/bin/llvm-otool
-    ln -s ${llvm}/bin/llvm-profdata
-    ln -s ${llvm}/bin/llvm-size
-
-    ln -s ${yacc}/bin/yacc
-    ln -s ${yacc}/bin/bison
-    ln -s ${flex}/bin/flex
-    ln -s ${flex}/bin/flex++
-
-    ln -s flex lex
-
-    ln -s ${m4}/bin/m4
-    ln -s m4 gm4
+runCommand "nixpkgs.xctoolchain" {
+  nativeBuildInputs = [ makeWrapper ];
+} (''
+  mkdir -p $out
+  install -D ${writeText "ToolchainInfo.plist" (toPlist {} ToolchainInfo)} $out/ToolchainInfo.plist
 
-    ln -s ${unifdef}/bin/unifdef
-    ln -s ${unifdef}/bin/unifdefall
+  mkdir -p $out/usr/include
+  mkdir -p $out/usr/lib
+  mkdir -p $out/usr/libexec
+  mkdir -p $out/usr/share
+  mkdir -p $out/usr/bin
 
-    ln -s ${gperf}/bin/gperf
-    ln -s ${indent}/bin/indent
-    ln -s ${ctags}/bin/ctags
-  '' + stdenv.lib.optionalString stdenv.isDarwin ''
-    ln -s ${bootstrap_cmds}/bin/mig
-    ln -s ${binutils}/bin/lipo
+  for bin in ${getBin stdenv.cc}/bin/*; do
+    ln -s $bin $out/usr/bin
+  done
 
-    ln -s ${cctools}/bin/ar
-    ln -s ${cctools}/bin/as
-    ln -s ${cctools}/bin/nm
-    ln -s ${cctools}/bin/nmedit
-    ln -s ${cctools}/bin/ld
-    ln -s ${cctools}/bin/libtool
-    ln -s ${cctools}/bin/strings
-    ln -s ${cctools}/bin/strip
-    ln -s ${cctools}/bin/install_name_tool
-    ln -s ${cctools}/bin/bitcode_strip
-    ln -s ${cctools}/bin/codesign_allocate
-    ln -s ${cctools}/bin/dsymutil
-    ln -s ${cctools}/bin/dyldinfo
-    ln -s ${cctools}/bin/otool
-    ln -s ${cctools}/bin/unwinddump
-    ln -s ${cctools}/bin/size
-    ln -s ${cctools}/bin/segedit
-    ln -s ${cctools}/bin/pagestuff
-    ln -s ${cctools}/bin/ranlib
-    ln -s ${cctools}/bin/redo_prebinding
+  for bin in ${getBin stdenv.cc.bintools.bintools}/bin/*; do
+    if ! [ -e "$out/usr/bin/$(basename $bin)" ]; then
+      ln -s $bin $out/usr/bin
+    fi
+  done
 
-    ln -s ${xib2nib}/bin/ibtool
-  '' +
-    # No point including the entire gcc closure if we don't already have it
-    (if stdenv.cc.isClang then ''
-      ln -s ${stdenv.cc.cc.llvm}/bin/llvm-cov gcov
-      ln -s ${mkdep-darwin-src}               mkdep
-    '' else ''
-      ln -s ${gcc}/bin/gcov
-      ln -s ${gcc}/bin/mkdep
-    '');
-}
+  ln -s ${buildPackages.yacc}/bin/yacc $out/usr/bin/yacc
+  ln -s ${buildPackages.yacc}/bin/bison $out/usr/bin/bison
+  ln -s ${buildPackages.flex}/bin/flex $out/usr/bin/flex
+  ln -s ${buildPackages.flex}/bin/flex++ $out/usr/bin/flex++
+  ln -s $out/bin/flex $out/usr/bin/lex
 
-# other commands in /bin/
-#   asa
-#   cmpdylib (in cctools)
-#   ctf_insert (in cctools)
-#   dwarfdump
-#   lorder
-#   rebase
-#   rpcgen (in developer_cmds)
-#   what
+  ln -s ${buildPackages.m4}/bin/m4 $out/usr/bin/m4
+  ln -s $out/usr/bin/m4 $out/usr/bin/gm4
 
+  ln -s ${buildPackages.unifdef}/bin/unifdef $out/usr/bin/unifdef
+  ln -s ${buildPackages.unifdef}/bin/unifdefall $out/usr/bin/unifdefall
 
-# swift: see #11463
-#   swift
-#   swift-compress
-#   swift-demangle
-#   swift-stdlib-tool
-#   swift-update
-#   swiftc
+  ln -s ${buildPackages.gperf}/bin/gperf $out/usr/bin/gperf
+  ln -s ${buildPackages.indent}/bin/indent $out/usr/bin/indent
+  ln -s ${buildPackages.ctags}/bin/ctags $out/usr/bin/ctags
+'' + optionalString stdenv.isDarwin ''
+  ln -s ${buildPackages.darwin.bootstrap_cmds}/bin/mig $out/usr/bin
+  ln -s ${mkdep-darwin-src} $out/usr/bin/mkdep
+'')

pkgs/development/tools/xcbuild/wrapper.nix

···
-{ stdenv, callPackage, makeWrapper, writeText, CoreServices, ImageIO, CoreGraphics
-, cctools, bootstrap_cmds, binutils}:
+{ stdenv, buildPackages, makeWrapper, writeText, runCommand
+, CoreServices, ImageIO, CoreGraphics }:
 
 let
 
···
   platformName = "com.apple.platform.macosx";
   sdkName = "macosx10.10";
 
-  xcbuild = callPackage ./default.nix {
+  xcbuild = buildPackages.callPackage ./default.nix {
     inherit CoreServices ImageIO CoreGraphics;
   };
 
-  toolchain = callPackage ./toolchain.nix {
-    inherit cctools bootstrap_cmds toolchainName xcbuild binutils stdenv;
+  toolchain = buildPackages.callPackage ./toolchain.nix {
+    inherit toolchainName;
   };
 
-  sdk = callPackage ./sdk.nix {
-    inherit toolchainName sdkName xcbuild;
+  sdk = buildPackages.callPackage ./sdk.nix {
+    inherit toolchainName sdkName;
   };
 
-  platform = callPackage ./platform.nix {
-    inherit sdk platformName xcbuild;
+  platform = buildPackages.callPackage ./platform.nix {
+    inherit sdk platformName;
   };
 
   xcconfig = writeText "nix.xcconfig" ''
···
 stdenv.mkDerivation {
   name = "xcbuild-wrapper-${xcbuild.version}";
 
-  buildInputs = [ xcbuild makeWrapper ];
+  nativeBuildInputs = [ makeWrapper ];
 
   setupHook = ./setup-hook.sh;
 
···
 
   installPhase = ''
     mkdir -p $out/bin
-    cd $out/bin/
 
     for file in ${xcbuild}/bin/*; do
-      ln -s $file
+      ln -s $file $out/bin
     done
 
-    mkdir $out/usr
+    mkdir -p $out/usr
     ln -s $out/bin $out/usr/bin
 
-    mkdir -p $out/Library/Xcode/
+    mkdir -p $out/Library/Xcode
     ln -s ${xcbuild}/Library/Xcode/Specifications $out/Library/Xcode/Specifications
 
-    mkdir -p $out/Platforms/
+    mkdir -p $out/Platforms
     ln -s ${platform} $out/Platforms/nixpkgs.platform
 
-    mkdir -p $out/Toolchains/
+    mkdir -p $out/Toolchains
     ln -s ${toolchain} $out/Toolchains/nixpkgs.xctoolchain
 
     wrapProgram $out/bin/xcodebuild \

pkgs/servers/http/myserver/default.nix

···
 { lib, fetchurl, stdenv, libgcrypt, libevent, libidn, gnutls
-, libxml2, zlib, guile, texinfo, cppunit, psmisc }:
+, libxml2, zlib, guile, texinfo, cppunit, killall }:
 
 let version = "0.11"; in
 
···
 
   # On GNU/Linux the `test_suite' process sometimes stays around, so
   # forcefully terminate it.
-  postCheck = lib.optionalString stdenv.isLinux "${psmisc}/bin/killall test_suite || true";
+  postCheck = "${killall}/bin/killall test_suite || true";
 
   meta = {
     description = "GNU MyServer, a powerful and easy to configure web server";

pkgs/tools/misc/xfstests/default.nix

···
-{ stdenv, acl, attr, autoconf, automake, bash, bc, coreutils, e2fsprogs, fetchgit, fio, gawk, keyutils
-, lib, libaio, libcap, libtool, libuuid, libxfs, lvm2, openssl, perl, procps, psmisc, quota, su
+{ stdenv, acl, attr, autoconf, automake, bash, bc, coreutils, e2fsprogs
+, fetchgit, fio, gawk, keyutils, killall, lib, libaio, libcap, libtool
+, libuuid, libxfs, lvm2, openssl, perl, procps, quota, su
 , time, utillinux, which, writeScript, xfsprogs }:
 
 stdenv.mkDerivation {
···
       ln -s @out@/lib/xfstests/$f $f
     done
 
-    export PATH=${lib.makeBinPath [acl attr bc e2fsprogs fio gawk keyutils libcap lvm2 perl procps psmisc quota utillinux which xfsprogs]}:$PATH
+    export PATH=${lib.makeBinPath [acl attr bc e2fsprogs fio gawk keyutils
+                                   libcap lvm2 perl procps killall quota
+                                   utillinux which xfsprogs]}:$PATH
     exec ./check "$@"
   '';
 

pkgs/top-level/all-packages.nix

···
 
   xcbuild  = callPackage ../development/tools/xcbuild/wrapper.nix {
     inherit (darwin.apple_sdk.frameworks) CoreServices CoreGraphics ImageIO;
-    inherit (darwin) cctools bootstrap_cmds binutils;
-    stdenv = clangStdenv;
+    stdenv = buildPackages.clangStdenv;
   };
 
   xmlindent = callPackage ../development/web/xmlindent {};
···
   unixtools = recurseIntoAttrs (callPackages ./unix-tools.nix { });
   inherit (unixtools) hexdump ps logger eject umount
                       mount wall hostname more sysctl getconf
-                      getent locale;
+                      getent locale killall;
 
   fts = if hostPlatform.isMusl then netbsd.fts else null;
 

pkgs/top-level/unix-tools.nix

···
       linux = pkgs.nettools;
       darwin = pkgs.darwin.network_cmds;
     };
+    killall = {
+      linux = pkgs.psmisc;
+      darwin = pkgs.darwin.shell_cmds;
+    };
     locale = {
       linux = pkgs.glibc;
       darwin = pkgs.netbsd.locale;