diff --git a/make-install-plan/default.nix b/make-install-plan/default.nix new file mode 100644 index 0000000000..162f7934e1 --- /dev/null +++ b/make-install-plan/default.nix @@ -0,0 +1,6 @@ +{ callPackage }: + +let + project = callPackage ./project.nix {}; +in +project.getComponent "make-install-plan:exe:make-install-plan" diff --git a/make-install-plan/flake.lock b/make-install-plan/flake.lock new file mode 100644 index 0000000000..cadce731d6 --- /dev/null +++ b/make-install-plan/flake.lock @@ -0,0 +1,597 @@ +{ + "nodes": { + "HTTP": { + "flake": false, + "locked": { + "lastModified": 1451647621, + "narHash": "sha256-oHIyw3x0iKBexEo49YeUDV1k74ZtyYKGR2gNJXXRxts=", + "owner": "phadej", + "repo": "HTTP", + "rev": "9bc0996d412fef1787449d841277ef663ad9a915", + "type": "github" + }, + "original": { + "owner": "phadej", + "repo": "HTTP", + "type": "github" + } + }, + "cabal-32": { + "flake": false, + "locked": { + "lastModified": 1603716527, + "narHash": "sha256-X0TFfdD4KZpwl0Zr6x+PLxUt/VyKQfX7ylXHdmZIL+w=", + "owner": "haskell", + "repo": "cabal", + "rev": "48bf10787e27364730dd37a42b603cee8d6af7ee", + "type": "github" + }, + "original": { + "owner": "haskell", + "ref": "3.2", + "repo": "cabal", + "type": "github" + } + }, + "cabal-34": { + "flake": false, + "locked": { + "lastModified": 1645834128, + "narHash": "sha256-wG3d+dOt14z8+ydz4SL7pwGfe7SiimxcD/LOuPCV6xM=", + "owner": "haskell", + "repo": "cabal", + "rev": "5ff598c67f53f7c4f48e31d722ba37172230c462", + "type": "github" + }, + "original": { + "owner": "haskell", + "ref": "3.4", + "repo": "cabal", + "type": "github" + } + }, + "cabal-36": { + "flake": false, + "locked": { + "lastModified": 1669081697, + "narHash": "sha256-I5or+V7LZvMxfbYgZATU4awzkicBwwok4mVoje+sGmU=", + "owner": "haskell", + "repo": "cabal", + "rev": "8fd619e33d34924a94e691c5fea2c42f0fc7f144", + "type": "github" + }, + "original": { + "owner": "haskell", + "ref": "3.6", + "repo": "cabal", + "type": "github" + } + }, + "cardano-shell": { + "flake": false, + "locked": { + "lastModified": 1608537748, + "narHash": "sha256-PulY1GfiMgKVnBci3ex4ptk2UNYMXqGjJOxcPy2KYT4=", + "owner": "input-output-hk", + "repo": "cardano-shell", + "rev": "9392c75087cb9a3d453998f4230930dea3a95725", + "type": "github" + }, + "original": { + "owner": "input-output-hk", + "repo": "cardano-shell", + "type": "github" + } + }, + "flake-compat": { + "flake": false, + "locked": { + "lastModified": 1672831974, + "narHash": "sha256-z9k3MfslLjWQfnjBtEtJZdq3H7kyi2kQtUThfTgdRk0=", + "owner": "input-output-hk", + "repo": "flake-compat", + "rev": "45f2638735f8cdc40fe302742b79f248d23eb368", + "type": "github" + }, + "original": { + "owner": "input-output-hk", + "ref": "hkm/gitlab-fix", + "repo": "flake-compat", + "type": "github" + } + }, + "ghc-8.6.5-iohk": { + "flake": false, + "locked": { + "lastModified": 1600920045, + "narHash": "sha256-DO6kxJz248djebZLpSzTGD6s8WRpNI9BTwUeOf5RwY8=", + "owner": "input-output-hk", + "repo": "ghc", + "rev": "95713a6ecce4551240da7c96b6176f980af75cae", + "type": "github" + }, + "original": { + "owner": "input-output-hk", + "ref": "release/8.6.5-iohk", + "repo": "ghc", + "type": "github" + } + }, + "hackage": { + "flake": false, + "locked": { + "lastModified": 1738542530, + "narHash": "sha256-VrC1wzbz8rQkC0sPSp6KmCtuXmsA0s1iQS9q8wocA20=", + "owner": "input-output-hk", + "repo": "hackage.nix", + "rev": "0afc55d0ed373a656a08f91a0ecc0fce3cea3019", + "type": "github" + }, + "original": { + "owner": "input-output-hk", + "repo": "hackage.nix", + "type": "github" + } + }, + "haskellNix": { + "inputs": { + "HTTP": "HTTP", + "cabal-32": "cabal-32", + "cabal-34": "cabal-34", + "cabal-36": "cabal-36", + "cardano-shell": "cardano-shell", + "flake-compat": "flake-compat", + "ghc-8.6.5-iohk": "ghc-8.6.5-iohk", + "hackage": "hackage", + "hls-1.10": "hls-1.10", + "hls-2.0": "hls-2.0", + "hls-2.2": "hls-2.2", + "hls-2.3": "hls-2.3", + "hls-2.4": "hls-2.4", + "hls-2.5": "hls-2.5", + "hls-2.6": "hls-2.6", + "hls-2.7": "hls-2.7", + "hls-2.8": "hls-2.8", + "hls-2.9": "hls-2.9", + "hpc-coveralls": "hpc-coveralls", + "iserv-proxy": "iserv-proxy", + "nixpkgs": [ + "haskellNix", + "nixpkgs-unstable" + ], + "nixpkgs-2003": "nixpkgs-2003", + "nixpkgs-2105": "nixpkgs-2105", + "nixpkgs-2111": "nixpkgs-2111", + "nixpkgs-2205": "nixpkgs-2205", + "nixpkgs-2211": "nixpkgs-2211", + "nixpkgs-2305": "nixpkgs-2305", + "nixpkgs-2311": "nixpkgs-2311", + "nixpkgs-2405": "nixpkgs-2405", + "nixpkgs-2411": "nixpkgs-2411", + "nixpkgs-unstable": "nixpkgs-unstable", + "old-ghc-nix": "old-ghc-nix", + "stackage": "stackage" + }, + "locked": { + "lastModified": 1738544076, + "narHash": "sha256-u+oQ6Dc2LKJJfFu/vGYOEPJDE+3iINm4mer5HnwxoQ8=", + "owner": "input-output-hk", + "repo": "haskell.nix", + "rev": "7a6dc9d12ff18c6d96e0f63a7ebf1610aa274d46", + "type": "github" + }, + "original": { + "owner": "input-output-hk", + "repo": "haskell.nix", + "type": "github" + } + }, + "hls-1.10": { + "flake": false, + "locked": { + "lastModified": 1680000865, + "narHash": "sha256-rc7iiUAcrHxwRM/s0ErEsSPxOR3u8t7DvFeWlMycWgo=", + "owner": "haskell", + "repo": "haskell-language-server", + "rev": "b08691db779f7a35ff322b71e72a12f6e3376fd9", + "type": "github" + }, + "original": { + "owner": "haskell", + "ref": "1.10.0.0", + "repo": "haskell-language-server", + "type": "github" + } + }, + "hls-2.0": { + "flake": false, + "locked": { + "lastModified": 1687698105, + "narHash": "sha256-OHXlgRzs/kuJH8q7Sxh507H+0Rb8b7VOiPAjcY9sM1k=", + "owner": "haskell", + "repo": "haskell-language-server", + "rev": "783905f211ac63edf982dd1889c671653327e441", + "type": "github" + }, + "original": { + "owner": "haskell", + "ref": "2.0.0.1", + "repo": "haskell-language-server", + "type": "github" + } + }, + "hls-2.2": { + "flake": false, + "locked": { + "lastModified": 1693064058, + "narHash": "sha256-8DGIyz5GjuCFmohY6Fa79hHA/p1iIqubfJUTGQElbNk=", + "owner": "haskell", + "repo": "haskell-language-server", + "rev": "b30f4b6cf5822f3112c35d14a0cba51f3fe23b85", + "type": "github" + }, + "original": { + "owner": "haskell", + "ref": "2.2.0.0", + "repo": "haskell-language-server", + "type": "github" + } + }, + "hls-2.3": { + "flake": false, + "locked": { + "lastModified": 1695910642, + "narHash": "sha256-tR58doOs3DncFehHwCLczJgntyG/zlsSd7DgDgMPOkI=", + "owner": "haskell", + "repo": "haskell-language-server", + "rev": "458ccdb55c9ea22cd5d13ec3051aaefb295321be", + "type": "github" + }, + "original": { + "owner": "haskell", + "ref": "2.3.0.0", + "repo": "haskell-language-server", + "type": "github" + } + }, + "hls-2.4": { + "flake": false, + "locked": { + "lastModified": 1699862708, + "narHash": "sha256-YHXSkdz53zd0fYGIYOgLt6HrA0eaRJi9mXVqDgmvrjk=", + "owner": "haskell", + "repo": "haskell-language-server", + "rev": "54507ef7e85fa8e9d0eb9a669832a3287ffccd57", + "type": "github" + }, + "original": { + "owner": "haskell", + "ref": "2.4.0.1", + "repo": "haskell-language-server", + "type": "github" + } + }, + "hls-2.5": { + "flake": false, + "locked": { + "lastModified": 1701080174, + "narHash": "sha256-fyiR9TaHGJIIR0UmcCb73Xv9TJq3ht2ioxQ2mT7kVdc=", + "owner": "haskell", + "repo": "haskell-language-server", + "rev": "27f8c3d3892e38edaef5bea3870161815c4d014c", + "type": "github" + }, + "original": { + "owner": "haskell", + "ref": "2.5.0.0", + "repo": "haskell-language-server", + "type": "github" + } + }, + "hls-2.6": { + "flake": false, + "locked": { + "lastModified": 1705325287, + "narHash": "sha256-+P87oLdlPyMw8Mgoul7HMWdEvWP/fNlo8jyNtwME8E8=", + "owner": "haskell", + "repo": "haskell-language-server", + "rev": "6e0b342fa0327e628610f2711f8c3e4eaaa08b1e", + "type": "github" + }, + "original": { + "owner": "haskell", + "ref": "2.6.0.0", + "repo": "haskell-language-server", + "type": "github" + } + }, + "hls-2.7": { + "flake": false, + "locked": { + "lastModified": 1708965829, + "narHash": "sha256-LfJ+TBcBFq/XKoiNI7pc4VoHg4WmuzsFxYJ3Fu+Jf+M=", + "owner": "haskell", + "repo": "haskell-language-server", + "rev": "50322b0a4aefb27adc5ec42f5055aaa8f8e38001", + "type": "github" + }, + "original": { + "owner": "haskell", + "ref": "2.7.0.0", + "repo": "haskell-language-server", + "type": "github" + } + }, + "hls-2.8": { + "flake": false, + "locked": { + "lastModified": 1715153580, + "narHash": "sha256-Vi/iUt2pWyUJlo9VrYgTcbRviWE0cFO6rmGi9rmALw0=", + "owner": "haskell", + "repo": "haskell-language-server", + "rev": "dd1be1beb16700de59e0d6801957290bcf956a0a", + "type": "github" + }, + "original": { + "owner": "haskell", + "ref": "2.8.0.0", + "repo": "haskell-language-server", + "type": "github" + } + }, + "hls-2.9": { + "flake": false, + "locked": { + "lastModified": 1720003792, + "narHash": "sha256-qnDx8Pk0UxtoPr7BimEsAZh9g2WuTuMB/kGqnmdryKs=", + "owner": "haskell", + "repo": "haskell-language-server", + "rev": "0c1817cb2babef0765e4e72dd297c013e8e3d12b", + "type": "github" + }, + "original": { + "owner": "haskell", + "ref": "2.9.0.1", + "repo": "haskell-language-server", + "type": "github" + } + }, + "hpc-coveralls": { + "flake": false, + "locked": { + "lastModified": 1607498076, + "narHash": "sha256-8uqsEtivphgZWYeUo5RDUhp6bO9j2vaaProQxHBltQk=", + "owner": "sevanspowell", + "repo": "hpc-coveralls", + "rev": "14df0f7d229f4cd2e79f8eabb1a740097fdfa430", + "type": "github" + }, + "original": { + "owner": "sevanspowell", + "repo": "hpc-coveralls", + "type": "github" + } + }, + "iserv-proxy": { + "flake": false, + "locked": { + "lastModified": 1717479972, + "narHash": "sha256-7vE3RQycHI1YT9LHJ1/fUaeln2vIpYm6Mmn8FTpYeVo=", + "owner": "stable-haskell", + "repo": "iserv-proxy", + "rev": "2ed34002247213fc435d0062350b91bab920626e", + "type": "github" + }, + "original": { + "owner": "stable-haskell", + "ref": "iserv-syms", + "repo": "iserv-proxy", + "type": "github" + } + }, + "nixpkgs-2003": { + "locked": { + "lastModified": 1620055814, + "narHash": "sha256-8LEHoYSJiL901bTMVatq+rf8y7QtWuZhwwpKE2fyaRY=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "1db42b7fe3878f3f5f7a4f2dc210772fd080e205", + "type": "github" + }, + "original": { + "owner": "NixOS", + "ref": "nixpkgs-20.03-darwin", + "repo": "nixpkgs", + "type": "github" + } + }, + "nixpkgs-2105": { + "locked": { + "lastModified": 1659914493, + "narHash": "sha256-lkA5X3VNMKirvA+SUzvEhfA7XquWLci+CGi505YFAIs=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "022caabb5f2265ad4006c1fa5b1ebe69fb0c3faf", + "type": "github" + }, + "original": { + "owner": "NixOS", + "ref": "nixpkgs-21.05-darwin", + "repo": "nixpkgs", + "type": "github" + } + }, + "nixpkgs-2111": { + "locked": { + "lastModified": 1659446231, + "narHash": "sha256-hekabNdTdgR/iLsgce5TGWmfIDZ86qjPhxDg/8TlzhE=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "eabc38219184cc3e04a974fe31857d8e0eac098d", + "type": "github" + }, + "original": { + "owner": "NixOS", + "ref": "nixpkgs-21.11-darwin", + "repo": "nixpkgs", + "type": "github" + } + }, + "nixpkgs-2205": { + "locked": { + "lastModified": 1685573264, + "narHash": "sha256-Zffu01pONhs/pqH07cjlF10NnMDLok8ix5Uk4rhOnZQ=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "380be19fbd2d9079f677978361792cb25e8a3635", + "type": "github" + }, + "original": { + "owner": "NixOS", + "ref": "nixpkgs-22.05-darwin", + "repo": "nixpkgs", + "type": "github" + } + }, + "nixpkgs-2211": { + "locked": { + "lastModified": 1688392541, + "narHash": "sha256-lHrKvEkCPTUO+7tPfjIcb7Trk6k31rz18vkyqmkeJfY=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "ea4c80b39be4c09702b0cb3b42eab59e2ba4f24b", + "type": "github" + }, + "original": { + "owner": "NixOS", + "ref": "nixpkgs-22.11-darwin", + "repo": "nixpkgs", + "type": "github" + } + }, + "nixpkgs-2305": { + "locked": { + "lastModified": 1705033721, + "narHash": "sha256-K5eJHmL1/kev6WuqyqqbS1cdNnSidIZ3jeqJ7GbrYnQ=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "a1982c92d8980a0114372973cbdfe0a307f1bdea", + "type": "github" + }, + "original": { + "owner": "NixOS", + "ref": "nixpkgs-23.05-darwin", + "repo": "nixpkgs", + "type": "github" + } + }, + "nixpkgs-2311": { + "locked": { + "lastModified": 1719957072, + "narHash": "sha256-gvFhEf5nszouwLAkT9nWsDzocUTqLWHuL++dvNjMp9I=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "7144d6241f02d171d25fba3edeaf15e0f2592105", + "type": "github" + }, + "original": { + "owner": "NixOS", + "ref": "nixpkgs-23.11-darwin", + "repo": "nixpkgs", + "type": "github" + } + }, + "nixpkgs-2405": { + "locked": { + "lastModified": 1735564410, + "narHash": "sha256-HB/FA0+1gpSs8+/boEavrGJH+Eq08/R2wWNph1sM1Dg=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "1e7a8f391f1a490460760065fa0630b5520f9cf8", + "type": "github" + }, + "original": { + "owner": "NixOS", + "ref": "nixpkgs-24.05-darwin", + "repo": "nixpkgs", + "type": "github" + } + }, + "nixpkgs-2411": { + "locked": { + "lastModified": 1737255904, + "narHash": "sha256-r3fxHvh+M/mBgCZXOACzRFPsJdix2QSsKazb7VCXXo0=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "eacdab35066b0bb1c9413c96898e326b76398a81", + "type": "github" + }, + "original": { + "owner": "NixOS", + "ref": "nixpkgs-24.11-darwin", + "repo": "nixpkgs", + "type": "github" + } + }, + "nixpkgs-unstable": { + "locked": { + "lastModified": 1737110817, + "narHash": "sha256-DSenga8XjPaUV5KUFW/i3rNkN7jm9XmguW+qQ1ZJTR4=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "041c867bad68dfe34b78b2813028a2e2ea70a23c", + "type": "github" + }, + "original": { + "owner": "NixOS", + "ref": "nixpkgs-unstable", + "repo": "nixpkgs", + "type": "github" + } + }, + "old-ghc-nix": { + "flake": false, + "locked": { + "lastModified": 1631092763, + "narHash": "sha256-sIKgO+z7tj4lw3u6oBZxqIhDrzSkvpHtv0Kki+lh9Fg=", + "owner": "angerman", + "repo": "old-ghc-nix", + "rev": "af48a7a7353e418119b6dfe3cd1463a657f342b8", + "type": "github" + }, + "original": { + "owner": "angerman", + "ref": "master", + "repo": "old-ghc-nix", + "type": "github" + } + }, + "root": { + "inputs": { + "haskellNix": "haskellNix", + "nixpkgs": [ + "haskellNix", + "nixpkgs" + ] + } + }, + "stackage": { + "flake": false, + "locked": { + "lastModified": 1738541497, + "narHash": "sha256-Z0p9bCUqx8JqNuY3TCJm042EXlS08eFJSFOGe9yQeOU=", + "owner": "input-output-hk", + "repo": "stackage.nix", + "rev": "fcd13472a2ace9ea666b7c3fb5d00e2e07fadc5b", + "type": "github" + }, + "original": { + "owner": "input-output-hk", + "repo": "stackage.nix", + "type": "github" + } + } + }, + "root": "root", + "version": 7 +} diff --git a/make-install-plan/flake.nix b/make-install-plan/flake.nix new file mode 100644 index 0000000000..e78e1664da --- /dev/null +++ b/make-install-plan/flake.nix @@ -0,0 +1,43 @@ +{ + inputs = { + nixpkgs.follows = "haskellNix/nixpkgs"; + haskellNix.url = "github:input-output-hk/haskell.nix"; + }; + + outputs = { self, nixpkgs, haskellNix, ... }: + let + systems = [ + "x86_64-linux" + "x86_64-darwin" + "aarch64-linux" + "aarch64-darwin" + ]; + + inherit (nixpkgs) lib; + forAllSystems = f: lib.genAttrs systems (system: f (haskellNix.legacyPackages.${system})); + + in + { + project = forAllSystems (pkgs: pkgs.callPackage ./project.nix { }); + + packages = forAllSystems (pkgs: { make-install-plan = pkgs.callPackage ./default.nix {}; }); + + checks = lib.mapAttrs (_arch: project: project.flake'.checks) self.project; + + devShells = lib.mapAttrs (_arch: project: { default = project.shell; }) self.project; + + hydraJobs = lib.mapAttrs (_arch: project: project.flake'.hydraJobs) self.project; + }; + + nixConfig = { + extra-substituters = [ + "https://cache.iog.io" + "https://cache.zw3rk.com" + ]; + extra-trusted-public-keys = [ + "hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ=" + "loony-tools:pr9m4BkM/5/eSTZlkQyRt57Jz7OMBxNSUiMC4FkcNfk=" + ]; + allow-import-from-derivation = "true"; + }; +} diff --git a/make-install-plan/make-install-plan/cabal.project b/make-install-plan/make-install-plan/cabal.project new file mode 100644 index 0000000000..87a542bf1f --- /dev/null +++ b/make-install-plan/make-install-plan/cabal.project @@ -0,0 +1,15 @@ +index-state: 2025-02-01T00:00:00Z + +with-compiler: ghc-9.8 + +packages: . + +ghc-options: -Wall + +test-show-details: direct + +source-repository-package + type: git + location: https://github.com/andreabedini/Cabal-syntax-json.git + tag: 7a80221047fb5dd66a091f4a7248e0afa3bcc248 + --sha256: sha256-R55nljZMnc6s+Apc4uaZal9ExDauxYq/pV7RxQHwzVc= diff --git a/make-install-plan/make-install-plan/make-install-plan.cabal b/make-install-plan/make-install-plan/make-install-plan.cabal new file mode 100644 index 0000000000..71042fc761 --- /dev/null +++ b/make-install-plan/make-install-plan/make-install-plan.cabal @@ -0,0 +1,21 @@ +cabal-version: 3.8 +name: make-install-plan +version: 0.1.0.0 +synopsis: Creates an install plan for a cabal project +license: BSD-3-Clause +author: Andrea Bedini +maintainer: andrea@andreabedini.com +category: Distribution +build-type: Simple + +executable make-install-plan + main-is: Main.hs + other-modules: Json + build-depends: base + , Cabal ^>=3.12 + , Cabal-syntax ^>=3.12 + , cabal-install ^>=3.12 + , cabal-install-solver ^>=3.12 + , bytestring + hs-source-dirs: src + default-language: Haskell2010 diff --git a/make-install-plan/make-install-plan/src/Json.hs b/make-install-plan/make-install-plan/src/Json.hs new file mode 100644 index 0000000000..ad1876a5f6 --- /dev/null +++ b/make-install-plan/make-install-plan/src/Json.hs @@ -0,0 +1,81 @@ +{-# LANGUAGE DerivingVia #-} +{-# LANGUAGE RankNTypes #-} +{-# OPTIONS_GHC -Wall #-} + +module Json ( + boolJ, + pairJ, + stringJ, + listJ, + dictJ, + objectJ, + nonEmptyJ, + showJ, + prettyShowJ, + J.Json, + Encoding, + Series, + (.=), + (?=), +) +where + +import qualified Data.List.NonEmpty as NE +import Distribution.Pretty (Pretty, prettyShow) +import qualified Distribution.Utils.Json as J + +-- +-- JSON utilities +-- + +type Encoding = J.Json +type Pair = (String, J.Json) + +newtype Series = Series {runSeries :: [Pair]} + deriving (Semigroup, Monoid) via [Pair] + +class IsSeries a where + fromSeries :: a -> [Pair] + fromSeriesList :: [a] -> [Pair] + fromSeriesList = concatMap fromSeries + +instance IsSeries a => IsSeries [a] where + fromSeries = fromSeriesList + +instance IsSeries Series where + fromSeries = runSeries + +boolJ :: Bool -> J.Json +boolJ = J.JsonBool + +listJ :: (a -> J.Json) -> [a] -> J.Json +listJ f = J.JsonArray . map f + +stringJ :: String -> J.Json +stringJ = J.JsonString + +dictJ :: (k -> String) -> (v -> J.Json) -> (forall a. (k -> v -> a -> a) -> a -> m -> a) -> m -> J.Json +dictJ encodeKey encodeValue foldrMapWithKey = objectJ . foldrMapWithKey go mempty + where + go k v c = encodeKey k .= encodeValue v <> c + +(.=) :: String -> J.Json -> Series +(.=) = pairJ + +(?=) :: String -> Maybe J.Json -> Series +k ?= mv = maybe mempty (k .=) mv + +pairJ :: String -> J.Json -> Series +pairJ k v = Series [(k, v)] + +objectJ :: IsSeries a => a -> J.Json +objectJ = J.JsonObject . fromSeries + +nonEmptyJ :: (a -> J.Json) -> [a] -> Maybe J.Json +nonEmptyJ f = fmap (listJ f . NE.toList) . NE.nonEmpty + +showJ :: Show a => a -> J.Json +showJ = stringJ . show + +prettyShowJ :: Pretty a => a -> J.Json +prettyShowJ = stringJ . prettyShow diff --git a/make-install-plan/make-install-plan/src/Main.hs b/make-install-plan/make-install-plan/src/Main.hs new file mode 100644 index 0000000000..cd48993a3b --- /dev/null +++ b/make-install-plan/make-install-plan/src/Main.hs @@ -0,0 +1,290 @@ +{-# LANGUAGE DerivingVia #-} +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE ImportQualifiedPost #-} +{-# LANGUAGE NamedFieldPuns #-} +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RankNTypes #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# OPTIONS_GHC -Wall #-} + +import System.Environment (getArgs) + +import Data.ByteString.Lazy qualified as BSL + +import Distribution.Compat.Graph (IsNode (..)) +import Distribution.InstalledPackageInfo (InstalledPackageInfo (..)) +import Distribution.PackageDescription ( + PkgconfigName, + PkgconfigVersion, + buildType, + ) +import Distribution.Pretty (prettyShow) +import Distribution.Simple ( + packageName, + packageVersion, + showCompilerId, + ) +import Distribution.Simple.Command ( + CommandParse (..), + CommandUI (..), + commandParseArgs, + commandShowOptions, + ) +import Distribution.Simple.Flag (fromFlagOrDefault) +import Distribution.Simple.Program.Db (defaultProgramDb) +import Distribution.Simple.Setup (configureCommand) +import Distribution.Simple.Utils (fromUTF8LBS) +import Distribution.System (Platform (..)) +import Distribution.Types.Flag ( + FlagAssignment, + unFlagAssignment, + unFlagName, + ) +import Distribution.Types.LocalBuildConfig ( + BuildOptions (..), + buildOptionsConfigFlags, + ) +import Distribution.Utils.Json qualified as J +import Distribution.Verbosity qualified as V + +import Distribution.Client.GlobalFlags (defaultGlobalFlags) +import Distribution.Client.HashValue ( + HashValue, + hashValue, + showHashValue, + ) +import Distribution.Client.InstallPlan qualified as InstallPlan +import Distribution.Client.NixStyleOptions ( + NixStyleFlags (..), + defaultNixStyleFlags, + nixStyleOptions, + ) +import Distribution.Client.ProjectConfig ( + ProjectConfig, + commandLineFlagsToProjectConfig, + ) +import Distribution.Client.ProjectOrchestration ( + CurrentCommand (..), + ProjectBaseContext (..), + establishProjectBaseContext, + ) +import Distribution.Client.ProjectPlanning ( + BuildStyle (..), + ElaboratedConfiguredPackage (..), + ElaboratedInstallPlan, + ElaboratedPlanPackage, + ElaboratedSharedConfig (..), + rebuildInstallPlan, + ) +import Distribution.Client.ProjectPlanning.Types ( + ElaboratedComponent (..), + ElaboratedPackage (..), + ElaboratedPackageOrComponent (..), + MemoryOrDisk (..), + ) +import Distribution.Client.Setup (ConfigFlags (..)) +import Distribution.Client.Types.ConfiguredId (ConfiguredId (..)) +import Distribution.Client.Types.PackageLocation (PackageLocation (..)) +import Distribution.Client.Types.Repo ( + LocalRepo (..), + RemoteRepo (..), + Repo (..), + ) +import Distribution.Client.Types.SourceRepo (SourceRepositoryPackage (..)) + +import Distribution.Solver.Types.ComponentDeps qualified as CD + +import Json + +main :: IO () +main = do + args <- getArgs + case commandParseArgs cmdUI True args of + CommandHelp help -> putStrLn (help "make-install-plan") + CommandList opts -> putStrLn ("commandList" ++ show opts) + CommandErrors errs -> putStrLn ("commandErrors: " ++ show errs) + CommandReadyToGo (mkflags, _commandParse) -> + let globalFlags = defaultGlobalFlags + flags@NixStyleFlags{configFlags} = mkflags (commandDefaultFlags cmdUI) + verbosity = fromFlagOrDefault V.silent (configVerbosity configFlags) + cliConfig = commandLineFlagsToProjectConfig globalFlags flags mempty + in installPlanAction verbosity cliConfig + +cmdUI :: CommandUI (NixStyleFlags ()) +cmdUI = + CommandUI + { commandName = "" + , commandSynopsis = "Makes an install-plan" + , commandUsage = ("Usage: " ++) + , commandDescription = Nothing + , commandNotes = Nothing + , commandDefaultFlags = defaultNixStyleFlags () + , commandOptions = nixStyleOptions (const []) + } + +installPlanAction :: V.Verbosity -> ProjectConfig -> IO () +installPlanAction verbosity cliConfig = do + ProjectBaseContext{distDirLayout, cabalDirLayout, projectConfig, localPackages} <- + establishProjectBaseContext verbosity cliConfig OtherCommand + + (_improvedPlan, elaboratedPlan, elaboratedSharedConfig, _totalIndexState, _activeRepos) <- + rebuildInstallPlan verbosity distDirLayout cabalDirLayout projectConfig localPackages Nothing + + let ElaboratedSharedConfig{pkgConfigPlatform, pkgConfigCompiler} = elaboratedSharedConfig + Platform arch os = pkgConfigPlatform + + BSL.putStr . J.renderJson $ + objectJ + [ "platform" .= prettyShowJ pkgConfigPlatform + , "os" .= prettyShowJ os + , "arch" .= prettyShowJ arch + , "compiler" .= stringJ (showCompilerId pkgConfigCompiler) + , "install-plan" .= installPlanJ elaboratedPlan + ] + +installPlanJ :: ElaboratedInstallPlan -> Json +installPlanJ elabPlan = + dictJ + prettyShow + (objectJ . planPackageJ) + (\f -> foldr (\n -> f (nodeKey n) n)) + (InstallPlan.toGraph elabPlan) + +planPackageJ :: ElaboratedPlanPackage -> Series +planPackageJ (InstallPlan.PreExisting pkg) = + "type" .= stringJ "pre-existing" <> installedPackageInfoJ pkg +planPackageJ (InstallPlan.Configured pkg) = + "type" .= stringJ "configured" <> configuredPackageJ pkg +planPackageJ (InstallPlan.Installed pkg) = + "type" .= stringJ "installed" <> configuredPackageJ pkg + +installedPackageInfoJ :: InstalledPackageInfo -> Series +installedPackageInfoJ InstalledPackageInfo{..} = + "name" .= prettyShowJ (packageName sourcePackageId) + <> "version" .= prettyShowJ (packageVersion sourcePackageId) + <> "depends" .= listJ prettyShowJ depends + +configuredPackageJ :: ElaboratedConfiguredPackage -> Series +configuredPackageJ ElaboratedConfiguredPackage{..} = + "pkg-name" .= prettyShowJ (packageName elabPkgSourceId) + <> "pkg-version" .= prettyShowJ (packageVersion elabPkgSourceId) + <> "pkg-source" .= pkgSrcJ elabPkgSourceLocation elabPkgSourceHash + <> "pkg-description" ?= fmap packageDescriptionOverrideJ elabPkgDescriptionOverride + <> "build-type" .= prettyShowJ (buildType elabPkgDescription) + <> "style" .= styleJ elabLocalToProject elabBuildStyle + <> "flags" .= flagAssignmentJ elabFlagAssignment + <> "build-options" .= buildOptionsJ elabBuildOptions + <> "configure-flags" .= listJ stringJ configFlags + <> "configure-args" .= listJ stringJ elabConfigureScriptArgs + <> componentsJ elabPkgOrComp + where + configFlags = + commandShowOptions (configureCommand defaultProgramDb) (buildOptionsConfigFlags elabBuildOptions) + +styleJ :: Bool -> BuildStyle -> J.Json +styleJ True _ = stringJ "local" +styleJ False (BuildInplaceOnly OnDisk) = stringJ "inplace" +styleJ False (BuildInplaceOnly InMemory) = stringJ "interactive" +styleJ False BuildAndInstall = stringJ "global" + +componentsJ :: ElaboratedPackageOrComponent -> Series +componentsJ (ElabPackage ElaboratedPackage{..}) = + let components = + objectJ $ + [ prettyShow comp + .= objectJ + [ "exe-depends" ?= nonEmptyJ (prettyShowJ . confInstId) edeps + , "lib-depends" ?= nonEmptyJ (prettyShowJ . confInstId . fst) ldeps + ] + | let deps = CD.zip pkgExeDependencies pkgLibDependencies + , (comp, (edeps, ldeps)) <- CD.toList deps + ] + in "components" .= components + -- these are not per component + <> "pkgconfig-depends" ?= nonEmptyJ (uncurry pkgConfigDependJ) pkgPkgConfigDependencies +componentsJ (ElabComponent ElaboratedComponent{..}) = + "components" + .= objectJ + [ prettyShow compSolverName + .= objectJ + [ "exe-depends" ?= nonEmptyJ (prettyShowJ . confInstId) compExeDependencies + , "lib-depends" ?= nonEmptyJ (prettyShowJ . confInstId . fst) compLibDependencies + , "pkgconfig-depends" ?= nonEmptyJ (uncurry pkgConfigDependJ) compPkgConfigDependencies + ] + ] + +packageDescriptionOverrideJ :: BSL.ByteString -> J.Json +packageDescriptionOverrideJ desc = + objectJ + [ "text" .= stringJ (fromUTF8LBS desc) + , "hash" .= stringJ (showHashValue $ hashValue desc) + ] + +pkgSrcJ :: PackageLocation loc -> Maybe HashValue -> J.Json +pkgSrcJ pkgSrcLoc mPkgSrcHash = + objectJ [packageLocationJ pkgSrcLoc, hash] + where + hash = "hash" ?= fmap (stringJ . showHashValue) mPkgSrcHash + +packageLocationJ :: PackageLocation local -> Series +packageLocationJ (LocalUnpackedPackage path) = + "local" .= stringJ path +packageLocationJ (LocalTarballPackage path) = + "local-tar" .= stringJ path +packageLocationJ (RemoteTarballPackage uri _local) = + "remote-tar" .= objectJ ["uri" .= showJ uri] +packageLocationJ (RepoTarballPackage repo _packageId _local) = + case repo of + (RepoLocalNoIndex lr _repoLocalDir) -> + "local-repo-no-index" .= objectJ ["path" .= showJ (localRepoPath lr)] + (RepoRemote rr _repoLocalDir) -> + "remote-repo" .= objectJ ["uri" .= showJ (remoteRepoURI rr)] + (RepoSecure rr _repoLocalDir) -> + "secure-repo" .= objectJ ["uri" .= showJ (remoteRepoURI rr)] +packageLocationJ (RemoteSourceRepoPackage srp _local) = + "source-repo" + .= objectJ + [ "type" .= prettyShowJ (srpType srp) + , "location" .= stringJ (srpLocation srp) + , "tag" ?= fmap stringJ (srpTag srp) + , "branch" ?= fmap stringJ (srpBranch srp) + , "subdir" ?= fmap stringJ (srpSubdir srp) + , "commands" ?= nonEmptyJ stringJ (srpCommand srp) + ] + +flagAssignmentJ :: FlagAssignment -> J.Json +flagAssignmentJ = dictJ unFlagName boolJ (foldr . uncurry) . unFlagAssignment + +buildOptionsJ :: BuildOptions -> J.Json +buildOptionsJ bo = + objectJ + [ "with-vanilla-lib" .= showJ (withVanillaLib bo) + , "with-prof-lib" .= showJ (withProfLib bo) + , -- FIXME: this needs a more recent cabal + -- "with-prof-lib-shared" .= showJ (withProfLibShared bo) + "with-shared-lib" .= showJ (withSharedLib bo) + , "with-static-lib" .= showJ (withStaticLib bo) + , "with-dyn-exe" .= showJ (withDynExe bo) + , "with-fully-static-exe" .= showJ (withFullyStaticExe bo) + , "with-prof-exe" .= showJ (withProfExe bo) + , "with-prof-lib-detail" .= showJ (withProfLibDetail bo) + , "with-prof-exe-detail" .= showJ (withProfExeDetail bo) + , "with-optimization" .= showJ (withOptimization bo) + , "with-debug-info" .= showJ (withDebugInfo bo) + , "with-ghci-lib" .= showJ (withGHCiLib bo) + , "split-sections" .= showJ (splitSections bo) + , "split-objs" .= showJ (splitObjs bo) + , "strip-exes" .= showJ (stripExes bo) + , "strip-libs" .= showJ (stripLibs bo) + , "exe-coverage" .= showJ (exeCoverage bo) + , "lib-coverage" .= showJ (libCoverage bo) + , "relocatable" .= showJ (relocatable bo) + ] + +pkgConfigDependJ :: PkgconfigName -> Maybe PkgconfigVersion -> J.Json +pkgConfigDependJ n v = + objectJ + [ "name" .= prettyShowJ n + , "version" ?= fmap prettyShowJ v + ] diff --git a/make-install-plan/make-install-plan/tests/Tests.hs b/make-install-plan/make-install-plan/tests/Tests.hs new file mode 100644 index 0000000000..d46a72e935 --- /dev/null +++ b/make-install-plan/make-install-plan/tests/Tests.hs @@ -0,0 +1,85 @@ +import Control.Monad (when) +import qualified Data.ByteString as BS +import Data.Maybe (isNothing) +import System.Directory (copyFile, createDirectoryIfMissing, removeDirectoryRecursive, withCurrentDirectory) +import System.Directory.Extra (findExecutable, listFiles) +import System.Environment (setEnv) +import System.FilePath (replaceExtension, takeBaseName, takeExtensions, ()) +import System.IO.Extra (newTempDir) +import System.Process (callCommand) +import Test.Tasty (defaultMain, testGroup, withResource) +import Test.Tasty.Golden.Advanced (goldenTest2) +import Test.Tasty.Providers + +main :: IO () +main = goldenTests >>= defaultMain + +goldenTests :: IO TestTree +goldenTests = do + -- Use a temporary CABAL_DIR + checkRequiredProgram "make-install-plan" + checkRequiredProgram "plan-to-nix" + + -- NOTE: we want these paths to be like "tests/golden/test1.project" + projectFiles <- findFilesWithExtension ".project" "tests/golden" + return $ + withHackageIndex $ + testGroup "Tests" (map testProject projectFiles) + where + withHackageIndex t = + withResource + ( do + (cabalDir, cleanup) <- newTempDir + setEnv "CABAL_DIR" cabalDir + callCommand "cabal update -v" + return cleanup + ) + id + (const t) + +testProject :: FilePath -> TestTree +testProject projectFile = test + where + goldenPlanJsonFile = replaceExtension projectFile ".plan.json" + goldenPackagesFile = replaceExtension projectFile ".pkgs.nix" + + testName = takeBaseName projectFile + testWorkDir = replaceExtension projectFile ".workdir" + + testPlanJsonFile = testWorkDir "dist-newstyle/cache/plan.json" + testPackagesFile = testWorkDir "plan-nix/pkgs.nix" + + test = goldenTest2 testName readExpected getActual compareResult updateExpected delete + where + readExpected = do + plan <- BS.readFile goldenPlanJsonFile + pkgs <- BS.readFile goldenPackagesFile + return (plan, pkgs) + + updateExpected (plan, pkgs) = do + BS.writeFile goldenPlanJsonFile plan + BS.writeFile goldenPackagesFile pkgs + + getActual = do + createDirectoryIfMissing True testWorkDir + copyFile projectFile (testWorkDir "cabal.project") + withCurrentDirectory testWorkDir $ do + callCommand "make-install-plan" + createDirectoryIfMissing True "plan-nix" + callCommand "plan-to-nix --output plan-nix" + plan <- BS.readFile testPlanJsonFile + pkgs <- BS.readFile testPackagesFile + return (plan, pkgs) + + delete = removeDirectoryRecursive testWorkDir + + compareResult a b = return $ if a == b then Nothing else Just "" + +findFilesWithExtension :: String -> FilePath -> IO [FilePath] +findFilesWithExtension ext dir = + filter ((== ext) . takeExtensions) <$> listFiles dir + +checkRequiredProgram :: String -> IO () +checkRequiredProgram prg = + findExecutable prg >>= \mpath -> + when (isNothing mpath) $ fail (prg ++ " is missing") diff --git a/make-install-plan/make-install-plan/tests/golden/test1.pkgs.nix b/make-install-plan/make-install-plan/tests/golden/test1.pkgs.nix new file mode 100644 index 0000000000..782e1b9189 --- /dev/null +++ b/make-install-plan/make-install-plan/tests/golden/test1.pkgs.nix @@ -0,0 +1,202 @@ +{ + pkgs = hackage: + { + packages = { + bytestring.revision = (((hackage.bytestring)."0.11.4.0").revisions).default; + exceptions.revision = (((hackage.exceptions)."0.10.5").revisions).default; + vector-stream.revision = import ./cabal-files/vector-stream.nix; + filepath.revision = (((hackage.filepath)."1.4.2.2").revisions).default; + mtl.revision = (((hackage.mtl)."2.2.2").revisions).default; + ghc-bignum.revision = (((hackage.ghc-bignum)."1.3").revisions).default; + adjunctions.revision = import ./cabal-files/adjunctions.nix; + tagged.revision = import ./cabal-files/tagged.nix; + tagged.flags.deepseq = true; + tagged.flags.transformers = true; + ghc-prim.revision = (((hackage.ghc-prim)."0.9.0").revisions).default; + transformers-base.revision = import ./cabal-files/transformers-base.nix; + transformers-base.flags.orphaninstances = true; + lens.revision = import ./cabal-files/lens.nix; + lens.flags.test-templates = true; + lens.flags.benchmark-uniplate = false; + lens.flags.test-properties = true; + lens.flags.j = false; + lens.flags.trustworthy = true; + lens.flags.test-hunit = true; + lens.flags.dump-splices = false; + lens.flags.inlining = true; + bifunctors.revision = import ./cabal-files/bifunctors.nix; + bifunctors.flags.tagged = true; + strict.revision = import ./cabal-files/strict.nix; + foldable1-classes-compat.revision = import ./cabal-files/foldable1-classes-compat.nix; + foldable1-classes-compat.flags.tagged = true; + assoc.revision = import ./cabal-files/assoc.nix; + assoc.flags.tagged = true; + containers.revision = (((hackage.containers)."0.6.7").revisions).default; + call-stack.revision = import ./cabal-files/call-stack.nix; + stm.revision = (((hackage.stm)."2.5.1.0").revisions).default; + semigroups.revision = import ./cabal-files/semigroups.nix; + semigroups.flags.bytestring = true; + semigroups.flags.bytestring-builder = false; + semigroups.flags.tagged = true; + semigroups.flags.containers = true; + semigroups.flags.deepseq = true; + semigroups.flags.template-haskell = true; + semigroups.flags.binary = true; + semigroups.flags.transformers = true; + semigroups.flags.unordered-containers = true; + semigroups.flags.text = true; + semigroups.flags.hashable = true; + OneTuple.revision = import ./cabal-files/OneTuple.nix; + base.revision = (((hackage.base)."4.17.1.0").revisions).default; + th-abstraction.revision = import ./cabal-files/th-abstraction.nix; + semigroupoids.revision = import ./cabal-files/semigroupoids.nix; + semigroupoids.flags.tagged = true; + semigroupoids.flags.containers = true; + semigroupoids.flags.distributive = true; + semigroupoids.flags.unordered-containers = true; + semigroupoids.flags.contravariant = true; + semigroupoids.flags.comonad = true; + free.revision = import ./cabal-files/free.nix; + profunctors.revision = import ./cabal-files/profunctors.nix; + void.revision = import ./cabal-files/void.nix; + void.flags.safe = false; + base-orphans.revision = import ./cabal-files/base-orphans.nix; + kan-extensions.revision = import ./cabal-files/kan-extensions.nix; + reflection.revision = import ./cabal-files/reflection.nix; + reflection.flags.slow = false; + reflection.flags.template-haskell = true; + primitive.revision = import ./cabal-files/primitive.nix; + deepseq.revision = (((hackage.deepseq)."1.4.8.0").revisions).default; + distributive.revision = import ./cabal-files/distributive.nix; + distributive.flags.tagged = true; + distributive.flags.semigroups = true; + rts.revision = (((hackage.rts)."1.0.2").revisions).default; + template-haskell.revision = (((hackage.template-haskell)."2.19.0.0").revisions).default; + binary.revision = (((hackage.binary)."0.8.9.1").revisions).default; + indexed-traversable-instances.revision = import ./cabal-files/indexed-traversable-instances.nix; + invariant.revision = import ./cabal-files/invariant.nix; + transformers-compat.revision = import ./cabal-files/transformers-compat.nix; + transformers-compat.flags.two = false; + transformers-compat.flags.mtl = true; + transformers-compat.flags.four = false; + transformers-compat.flags.five = false; + transformers-compat.flags.five-three = true; + transformers-compat.flags.three = false; + transformers-compat.flags.generic-deriving = true; + parallel.revision = import ./cabal-files/parallel.nix; + transformers.revision = (((hackage.transformers)."0.5.6.2").revisions).default; + indexed-traversable.revision = import ./cabal-files/indexed-traversable.nix; + these.revision = import ./cabal-files/these.nix; + unordered-containers.revision = import ./cabal-files/unordered-containers.nix; + unordered-containers.flags.debug = false; + contravariant.revision = import ./cabal-files/contravariant.nix; + contravariant.flags.tagged = true; + contravariant.flags.semigroups = true; + contravariant.flags.statevar = true; + text.revision = (((hackage.text)."2.0.2").revisions).default; + StateVar.revision = import ./cabal-files/StateVar.nix; + array.revision = (((hackage.array)."0.5.4.0").revisions).default; + ghc-boot-th.revision = (((hackage.ghc-boot-th)."9.4.5").revisions).default; + vector.revision = import ./cabal-files/vector.nix; + vector.flags.internalchecks = false; + vector.flags.wall = false; + vector.flags.boundschecks = true; + vector.flags.unsafechecks = false; + comonad.revision = import ./cabal-files/comonad.nix; + comonad.flags.containers = true; + comonad.flags.distributive = true; + comonad.flags.indexed-traversable = true; + pretty.revision = (((hackage.pretty)."1.1.3.6").revisions).default; + hashable.revision = import ./cabal-files/hashable.nix; + hashable.flags.random-initial-seed = false; + hashable.flags.integer-gmp = true; + }; + compiler = { + version = "9.4.5"; + nix-name = "ghc945"; + packages = { + "pretty" = "1.1.3.6"; + "text" = "2.0.2"; + "array" = "0.5.4.0"; + "mtl" = "2.2.2"; + "bytestring" = "0.11.4.0"; + "filepath" = "1.4.2.2"; + "stm" = "2.5.1.0"; + "ghc-prim" = "0.9.0"; + "ghc-boot-th" = "9.4.5"; + "base" = "4.17.1.0"; + "ghc-bignum" = "1.3"; + "exceptions" = "0.10.5"; + "rts" = "1.0.2"; + "transformers" = "0.5.6.2"; + "template-haskell" = "2.19.0.0"; + "deepseq" = "1.4.8.0"; + "binary" = "0.8.9.1"; + "containers" = "0.6.7"; + }; + }; + }; + extras = _hackage: + { packages = { }; }; + modules = [ + ({ lib, ... }: + { packages = { }; }) + ({ lib, ... }: + { + packages = { + "invariant".components.library.planned = lib.mkOverride 900 true; + "transformers-base".components.library.planned = lib.mkOverride 900 true; + "base-orphans".components.library.planned = lib.mkOverride 900 true; + "these".components.library.planned = lib.mkOverride 900 true; + "filepath".components.library.planned = lib.mkOverride 900 true; + "distributive".components.library.planned = lib.mkOverride 900 true; + "pretty".components.library.planned = lib.mkOverride 900 true; + "reflection".components.library.planned = lib.mkOverride 900 true; + "bytestring".components.library.planned = lib.mkOverride 900 true; + "strict".components.library.planned = lib.mkOverride 900 true; + "comonad".components.library.planned = lib.mkOverride 900 true; + "profunctors".components.library.planned = lib.mkOverride 900 true; + "exceptions".components.library.planned = lib.mkOverride 900 true; + "call-stack".components.library.planned = lib.mkOverride 900 true; + "ghc-prim".components.library.planned = lib.mkOverride 900 true; + "array".components.library.planned = lib.mkOverride 900 true; + "binary".components.library.planned = lib.mkOverride 900 true; + "ghc-boot-th".components.library.planned = lib.mkOverride 900 true; + "rts".components.library.planned = lib.mkOverride 900 true; + "tagged".components.library.planned = lib.mkOverride 900 true; + "vector".components.library.planned = lib.mkOverride 900 true; + "indexed-traversable-instances".components.library.planned = lib.mkOverride 900 true; + "adjunctions".components.library.planned = lib.mkOverride 900 true; + "parallel".components.library.planned = lib.mkOverride 900 true; + "StateVar".components.library.planned = lib.mkOverride 900 true; + "free".components.library.planned = lib.mkOverride 900 true; + "ghc-bignum".components.library.planned = lib.mkOverride 900 true; + "indexed-traversable".components.library.planned = lib.mkOverride 900 true; + "contravariant".components.library.planned = lib.mkOverride 900 true; + "assoc".components.library.planned = lib.mkOverride 900 true; + "template-haskell".components.library.planned = lib.mkOverride 900 true; + "stm".components.library.planned = lib.mkOverride 900 true; + "lens".components.library.planned = lib.mkOverride 900 true; + "semigroupoids".components.library.planned = lib.mkOverride 900 true; + "foldable1-classes-compat".components.library.planned = lib.mkOverride 900 true; + "mtl".components.library.planned = lib.mkOverride 900 true; + "th-abstraction".components.library.planned = lib.mkOverride 900 true; + "transformers".components.library.planned = lib.mkOverride 900 true; + "OneTuple".components.library.planned = lib.mkOverride 900 true; + "deepseq".components.library.planned = lib.mkOverride 900 true; + "primitive".components.library.planned = lib.mkOverride 900 true; + "text".components.library.planned = lib.mkOverride 900 true; + "bifunctors".components.library.planned = lib.mkOverride 900 true; + "unordered-containers".components.library.planned = lib.mkOverride 900 true; + "base".components.library.planned = lib.mkOverride 900 true; + "vector-stream".components.library.planned = lib.mkOverride 900 true; + "kan-extensions".components.library.planned = lib.mkOverride 900 true; + "transformers-compat".components.library.planned = lib.mkOverride 900 true; + "containers".components.library.planned = lib.mkOverride 900 true; + "hashable".components.library.planned = lib.mkOverride 900 true; + "semigroups".components.library.planned = lib.mkOverride 900 true; + "void".components.library.planned = lib.mkOverride 900 true; + }; + }) + ]; +} diff --git a/make-install-plan/make-install-plan/tests/golden/test1.plan.json b/make-install-plan/make-install-plan/tests/golden/test1.plan.json new file mode 100644 index 0000000000..565c088bea --- /dev/null +++ b/make-install-plan/make-install-plan/tests/golden/test1.plan.json @@ -0,0 +1 @@ +{"cabal-version":"3.10.1.0","cabal-lib-version":"3.10.1.0","compiler-id":"ghc-9.4.5","os":"linux","arch":"x86_64","install-plan":[{"type":"configured","id":"OneTuple-0.4.1.1-e1611e67a77ed62be2ec0bb0e4f2f5591d45e517529330fc726f5ab10a4576cd","pkg-name":"OneTuple","pkg-version":"0.4.1.1","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"be0324c77a0eaf1d48b771b7e86f2b19d53a9f5ecc6ab2c914dab7dad309c671","pkg-src-sha256":"c9e764d4ee1e57cad8341bd5d0de33ba3a52b6793fc1309679f2bf60c030bb2b","depends":["base-4.17.1.0","ghc-prim-0.9.0","template-haskell-2.19.0.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"StateVar-1.2.2-e0abef6e7ef0a228327f8aa5d0d3fe191a15e630c0f4428125cd32906ec2c874","pkg-name":"StateVar","pkg-version":"1.2.2","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"3c022c00485fe165e3080d5da6b3ca9c9b02f62c5deebc584d1b3d1309ce673e","pkg-src-sha256":"5e4b39da395656a59827b0280508aafdc70335798b50e5d6fd52596026251825","depends":["base-4.17.1.0","stm-2.5.1.0","transformers-0.5.6.2"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"adjunctions-4.4.2-30a6f9da87d975a77df57b633b0a855c714d36b9b991ad99aaccf3b9dca24a77","pkg-name":"adjunctions","pkg-version":"4.4.2","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"f77a007099851b948f6c98acc49753f4ec19ec234471acfce50386ec50402846","pkg-src-sha256":"147b5f8db810bca0ea8952ef974982ffc447cecd21f01e1ea1121df77e276518","depends":["array-0.5.4.0","base-4.17.1.0","comonad-5.0.8-6cb3f4448654fd71897be46d3465d8c7fa1a39af537933846a813a454f544e6f","containers-0.6.7","contravariant-1.5.5-4a01031fa32aeaaafb5a993ff12c5aae49a7048b53def00d8ffbce8626a29402","distributive-0.6.2.1-b88884e9ae4366d59a031348fcf2960a9ce1d18b0fcf6c7e0e8d8f4364ba47a1","free-5.2-4855bcd0ad7e82603c31deaf13e527f08d2291f59b45a174f004b9436ceecf29","mtl-2.2.2","profunctors-5.6.2-22f8d7e5445308599ec94352609ee7ee883ddfc20451986e1e4ec597ddad2588","semigroupoids-6.0.0.1-936f7665e7c03d49c6dda30ae1cef86cd16e99eb2fadcfbd4bdbe7f71cda5c34","semigroups-0.20-4d7ca4412bb6d4e28787e3e5a5adfb2334f52bd1ca711fae9ce125ecd840f480","tagged-0.8.7-30f24ec195f41e232935b2add088b2ba51bf77bd036ec5c97bd4bcdd8a4771a9","transformers-0.5.6.2","transformers-compat-0.7.2-b05be8a17a5850cb38f647c8dc32411c3f929013531c7a0210e21be2a6a1aa43","void-0.7.3-6933fdfcf89282f201310830a9efb2d5d15560c3de835cede7634c9a229f713c"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"array-0.5.4.0","pkg-name":"array","pkg-version":"0.5.4.0","depends":["base-4.17.1.0"]},{"type":"configured","id":"assoc-1.1-e0a28437f030ebcca571cb67a5dc888f5f778b291929d1933ae056097706ae94","pkg-name":"assoc","pkg-version":"1.1","flags":{"tagged":true},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"ac83c915110288bca295386daf834936b9fd16d654bea8d8898bf091626c5c82","pkg-src-sha256":"7aa2e6548b3d9d49a286ac20639479aaf6c47a1446113ed784d98737c5f60df4","depends":["base-4.17.1.0","tagged-0.8.7-30f24ec195f41e232935b2add088b2ba51bf77bd036ec5c97bd4bcdd8a4771a9"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"base-4.17.1.0","pkg-name":"base","pkg-version":"4.17.1.0","depends":["ghc-bignum-1.3","ghc-prim-0.9.0","rts-1.0.2"]},{"type":"configured","id":"base-orphans-0.9.0-b39f938d7dd25ca7d52a209bd3c194f8bc168ba8e9db3200b86e2791633b3579","pkg-name":"base-orphans","pkg-version":"0.9.0","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"0bdd3486d3a1bcbed0513b46af4a13ca74b395313fa5b6e0068d6b7413b76a04","pkg-src-sha256":"613ed4d8241ed5a648a59ae6569a6962990bb545711d020d49fb83fa12d16e62","depends":["base-4.17.1.0","ghc-prim-0.9.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"bifunctors-5.6.1-f39ba530857f17a3821a11258df076ea674a2ae495e80753da9c39900391078b","pkg-name":"bifunctors","pkg-version":"5.6.1","flags":{"tagged":true},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"686c0163a64c136226c1f6c58df7711af7f374c78c475e4b645f6e6b7ae39a38","pkg-src-sha256":"06381471b5be16516a1b2c4b21a5101a3d991038bface8e0cad144c0044d57fc","depends":["assoc-1.1-e0a28437f030ebcca571cb67a5dc888f5f778b291929d1933ae056097706ae94","base-4.17.1.0","comonad-5.0.8-6cb3f4448654fd71897be46d3465d8c7fa1a39af537933846a813a454f544e6f","containers-0.6.7","foldable1-classes-compat-0.1-f7b1f8b66a445e642c21fd035c2e456080f8053e8f8c15bdf7b87c90a82b63e9","tagged-0.8.7-30f24ec195f41e232935b2add088b2ba51bf77bd036ec5c97bd4bcdd8a4771a9","template-haskell-2.19.0.0","th-abstraction-0.5.0.0-f4fb842f96457f32b9235a70384287c415a088c2eefbf55836906825d12b718e","transformers-0.5.6.2"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"binary-0.8.9.1","pkg-name":"binary","pkg-version":"0.8.9.1","depends":["array-0.5.4.0","base-4.17.1.0","bytestring-0.11.4.0","containers-0.6.7"]},{"type":"pre-existing","id":"bytestring-0.11.4.0","pkg-name":"bytestring","pkg-version":"0.11.4.0","depends":["base-4.17.1.0","deepseq-1.4.8.0","ghc-prim-0.9.0","template-haskell-2.19.0.0"]},{"type":"configured","id":"call-stack-0.4.0-d268f078fa82b87c10ebc4a58289fa9f270b5dc9b81af27d4cacdfd573427a28","pkg-name":"call-stack","pkg-version":"0.4.0","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"ac44d2c00931dc20b01750da8c92ec443eb63a7231e8550188cb2ac2385f7feb","pkg-src-sha256":"430bcf8a3404f7e55319573c0b807b1356946f0c8f289bb3d9afb279c636b87b","depends":["base-4.17.1.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"comonad-5.0.8-6cb3f4448654fd71897be46d3465d8c7fa1a39af537933846a813a454f544e6f","pkg-name":"comonad","pkg-version":"5.0.8","flags":{"containers":true,"distributive":true,"indexed-traversable":true},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"1f1aabd73ec7f80f20cf078a748a60cd48d8e57277802fdf6a9ab3601a9b8f7e","pkg-src-sha256":"ef6cdf2cc292cc43ee6aa96c581b235fdea8ab44a0bffb24dc79ae2b2ef33d13","depends":["base-4.17.1.0","containers-0.6.7","distributive-0.6.2.1-b88884e9ae4366d59a031348fcf2960a9ce1d18b0fcf6c7e0e8d8f4364ba47a1","indexed-traversable-0.1.2.1-0505391f249b00d3d49b7c397ce20702cb416ce0667632bc3d065696e2a95ddb","tagged-0.8.7-30f24ec195f41e232935b2add088b2ba51bf77bd036ec5c97bd4bcdd8a4771a9","transformers-0.5.6.2","transformers-compat-0.7.2-b05be8a17a5850cb38f647c8dc32411c3f929013531c7a0210e21be2a6a1aa43"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"containers-0.6.7","pkg-name":"containers","pkg-version":"0.6.7","depends":["array-0.5.4.0","base-4.17.1.0","deepseq-1.4.8.0","template-haskell-2.19.0.0"]},{"type":"configured","id":"contravariant-1.5.5-4a01031fa32aeaaafb5a993ff12c5aae49a7048b53def00d8ffbce8626a29402","pkg-name":"contravariant","pkg-version":"1.5.5","flags":{"semigroups":true,"statevar":true,"tagged":true},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"470ed0e040e879e2da4af1b2c8f94e199f6135852a8107858d5ae0a95365835f","pkg-src-sha256":"062fd66580d7aad0b5ba93e644ffa7feee69276ef50f20d4ed9f1deb7642dffa","depends":["StateVar-1.2.2-e0abef6e7ef0a228327f8aa5d0d3fe191a15e630c0f4428125cd32906ec2c874","base-4.17.1.0","transformers-0.5.6.2"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"deepseq-1.4.8.0","pkg-name":"deepseq","pkg-version":"1.4.8.0","depends":["array-0.5.4.0","base-4.17.1.0","ghc-prim-0.9.0"]},{"type":"configured","id":"distributive-0.6.2.1-b88884e9ae4366d59a031348fcf2960a9ce1d18b0fcf6c7e0e8d8f4364ba47a1","pkg-name":"distributive","pkg-version":"0.6.2.1","flags":{"semigroups":true,"tagged":true},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"0f99f5541cca04acf89b64432b03422b6408e830a8dff30e6c4334ef1a48680c","pkg-src-sha256":"d7351392e078f58caa46630a4b9c643e1e2e9dddee45848c5c8358e7b1316b91","depends":["base-4.17.1.0","base-orphans-0.9.0-b39f938d7dd25ca7d52a209bd3c194f8bc168ba8e9db3200b86e2791633b3579","tagged-0.8.7-30f24ec195f41e232935b2add088b2ba51bf77bd036ec5c97bd4bcdd8a4771a9","transformers-0.5.6.2"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"exceptions-0.10.5","pkg-name":"exceptions","pkg-version":"0.10.5","depends":["base-4.17.1.0","mtl-2.2.2","stm-2.5.1.0","template-haskell-2.19.0.0","transformers-0.5.6.2"]},{"type":"pre-existing","id":"filepath-1.4.2.2","pkg-name":"filepath","pkg-version":"1.4.2.2","depends":["base-4.17.1.0"]},{"type":"configured","id":"foldable1-classes-compat-0.1-f7b1f8b66a445e642c21fd035c2e456080f8053e8f8c15bdf7b87c90a82b63e9","pkg-name":"foldable1-classes-compat","pkg-version":"0.1","flags":{"tagged":true},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"851225c0d4ccf6ca5e4df17347490945c9928548e431f15e7e7d80c240bc4d17","pkg-src-sha256":"d057c3f358e1a6b72c73519bc64ba6aa959f066c08fed69f73258555ef95ff12","depends":["base-4.17.1.0","containers-0.6.7","ghc-prim-0.9.0","tagged-0.8.7-30f24ec195f41e232935b2add088b2ba51bf77bd036ec5c97bd4bcdd8a4771a9","transformers-0.5.6.2"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"free-5.2-4855bcd0ad7e82603c31deaf13e527f08d2291f59b45a174f004b9436ceecf29","pkg-name":"free","pkg-version":"5.2","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"132b5fa680fffaed45603be3291549b65390dc6fec900839f322f87f8d35fc3e","pkg-src-sha256":"72867f7c89173263765736e8d395e94291f1aaea626ecb1d673d72ce90b94f89","depends":["base-4.17.1.0","comonad-5.0.8-6cb3f4448654fd71897be46d3465d8c7fa1a39af537933846a813a454f544e6f","containers-0.6.7","distributive-0.6.2.1-b88884e9ae4366d59a031348fcf2960a9ce1d18b0fcf6c7e0e8d8f4364ba47a1","exceptions-0.10.5","indexed-traversable-0.1.2.1-0505391f249b00d3d49b7c397ce20702cb416ce0667632bc3d065696e2a95ddb","mtl-2.2.2","profunctors-5.6.2-22f8d7e5445308599ec94352609ee7ee883ddfc20451986e1e4ec597ddad2588","semigroupoids-6.0.0.1-936f7665e7c03d49c6dda30ae1cef86cd16e99eb2fadcfbd4bdbe7f71cda5c34","template-haskell-2.19.0.0","th-abstraction-0.5.0.0-f4fb842f96457f32b9235a70384287c415a088c2eefbf55836906825d12b718e","transformers-0.5.6.2","transformers-base-0.4.6-9108948c73fb13b2b2323b51e541ea784201d4bd92ecef7e1c722ae378b96567"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"ghc-bignum-1.3","pkg-name":"ghc-bignum","pkg-version":"1.3","depends":["ghc-prim-0.9.0"]},{"type":"pre-existing","id":"ghc-boot-th-9.4.5","pkg-name":"ghc-boot-th","pkg-version":"9.4.5","depends":["base-4.17.1.0"]},{"type":"pre-existing","id":"ghc-prim-0.9.0","pkg-name":"ghc-prim","pkg-version":"0.9.0","depends":["rts-1.0.2"]},{"type":"configured","id":"hashable-1.4.3.0-37fea282e73b3a240cd260ae4ff2fe7516b32c564382d860d19fdf55e0d414c2","pkg-name":"hashable","pkg-version":"1.4.3.0","flags":{"integer-gmp":true,"random-initial-seed":false},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"a52a511968a4b7a73bb54d78a8d999d6fe71f433cbe1788bbfae71b5fe02150c","pkg-src-sha256":"32efb16c2891786209b7cbe5c39df9b3a9ae51e836f1a54f646bc4602b7ab0f5","depends":["base-4.17.1.0","bytestring-0.11.4.0","containers-0.6.7","deepseq-1.4.8.0","filepath-1.4.2.2","ghc-bignum-1.3","ghc-prim-0.9.0","text-2.0.2"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"indexed-traversable-0.1.2.1-0505391f249b00d3d49b7c397ce20702cb416ce0667632bc3d065696e2a95ddb","pkg-name":"indexed-traversable","pkg-version":"0.1.2.1","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"154b4649199a602dea948a93cb34a6c4be71576c4f78410733dd9f6bc79b6e0b","pkg-src-sha256":"fe854c10285debc7d6fe3e09da0928a740ebc091ad2911ae695bb007e6f746a4","depends":["array-0.5.4.0","base-4.17.1.0","containers-0.6.7","transformers-0.5.6.2"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"indexed-traversable-instances-0.1.1.2-59ef8216657bca744ef2fe65b592fb1995efe5af8f9ee654c2edbd238d45606f","pkg-name":"indexed-traversable-instances","pkg-version":"0.1.1.2","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"b493ed83623a7cba498d31a9d36beec233406f20377f1be3bb51d4ce3bd2ceef","pkg-src-sha256":"0f9b4e895ccc819f74d15f913c93613cc74cab74dbb05d7e305aa387bdbe374a","depends":["OneTuple-0.4.1.1-e1611e67a77ed62be2ec0bb0e4f2f5591d45e517529330fc726f5ab10a4576cd","base-4.17.1.0","indexed-traversable-0.1.2.1-0505391f249b00d3d49b7c397ce20702cb416ce0667632bc3d065696e2a95ddb","tagged-0.8.7-30f24ec195f41e232935b2add088b2ba51bf77bd036ec5c97bd4bcdd8a4771a9","unordered-containers-0.2.19.1-d24c37c689def916e86aa83074dbfab953e97becf1c2afe78f57aef91465933c","vector-0.13.0.0-45717532419dd6453c543dc13f2ef915f0749d24bb0e507a450dae190d54b958"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"invariant-0.6.1-63e0db956995ea3ea001293e64ecd56ba6da512d254d0328f9cb057e8f91a3ee","pkg-name":"invariant","pkg-version":"0.6.1","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"e70c2a1df4b676d6bfe38f32b46826bce3d62334a577a161f94fd3d9711cc5c4","pkg-src-sha256":"fb7294ade6554e9c6e77020f065f3acb63f78e62019e4830ea509c36c8b0d4f0","depends":["StateVar-1.2.2-e0abef6e7ef0a228327f8aa5d0d3fe191a15e630c0f4428125cd32906ec2c874","array-0.5.4.0","base-4.17.1.0","bifunctors-5.6.1-f39ba530857f17a3821a11258df076ea674a2ae495e80753da9c39900391078b","comonad-5.0.8-6cb3f4448654fd71897be46d3465d8c7fa1a39af537933846a813a454f544e6f","containers-0.6.7","contravariant-1.5.5-4a01031fa32aeaaafb5a993ff12c5aae49a7048b53def00d8ffbce8626a29402","ghc-prim-0.9.0","profunctors-5.6.2-22f8d7e5445308599ec94352609ee7ee883ddfc20451986e1e4ec597ddad2588","stm-2.5.1.0","tagged-0.8.7-30f24ec195f41e232935b2add088b2ba51bf77bd036ec5c97bd4bcdd8a4771a9","template-haskell-2.19.0.0","th-abstraction-0.5.0.0-f4fb842f96457f32b9235a70384287c415a088c2eefbf55836906825d12b718e","transformers-0.5.6.2","transformers-compat-0.7.2-b05be8a17a5850cb38f647c8dc32411c3f929013531c7a0210e21be2a6a1aa43","unordered-containers-0.2.19.1-d24c37c689def916e86aa83074dbfab953e97becf1c2afe78f57aef91465933c"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"kan-extensions-5.2.5-84e226dc6d09f4cc6f3b591b505c44f2a0c8687e35cc3557af66eb484ebbbde4","pkg-name":"kan-extensions","pkg-version":"5.2.5","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"22e283da87daaafd3caa5de9cf0661f01971cebcb35d93c4d8241c3edfae6ce5","pkg-src-sha256":"b914dccc040caf1d8764b99df1028dad3e4fdf46c262192e54b59c9da66ead22","depends":["adjunctions-4.4.2-30a6f9da87d975a77df57b633b0a855c714d36b9b991ad99aaccf3b9dca24a77","array-0.5.4.0","base-4.17.1.0","comonad-5.0.8-6cb3f4448654fd71897be46d3465d8c7fa1a39af537933846a813a454f544e6f","containers-0.6.7","contravariant-1.5.5-4a01031fa32aeaaafb5a993ff12c5aae49a7048b53def00d8ffbce8626a29402","distributive-0.6.2.1-b88884e9ae4366d59a031348fcf2960a9ce1d18b0fcf6c7e0e8d8f4364ba47a1","free-5.2-4855bcd0ad7e82603c31deaf13e527f08d2291f59b45a174f004b9436ceecf29","invariant-0.6.1-63e0db956995ea3ea001293e64ecd56ba6da512d254d0328f9cb057e8f91a3ee","mtl-2.2.2","profunctors-5.6.2-22f8d7e5445308599ec94352609ee7ee883ddfc20451986e1e4ec597ddad2588","semigroupoids-6.0.0.1-936f7665e7c03d49c6dda30ae1cef86cd16e99eb2fadcfbd4bdbe7f71cda5c34","tagged-0.8.7-30f24ec195f41e232935b2add088b2ba51bf77bd036ec5c97bd4bcdd8a4771a9","transformers-0.5.6.2","transformers-compat-0.7.2-b05be8a17a5850cb38f647c8dc32411c3f929013531c7a0210e21be2a6a1aa43"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"lens-5.2.2-e9a2fe364ce9692d9e1e090f2038b5a7ce31fb07e83d3032d61b61625e2c4e12","pkg-name":"lens","pkg-version":"5.2.2","flags":{"benchmark-uniplate":false,"dump-splices":false,"inlining":true,"j":false,"test-hunit":true,"test-properties":true,"test-templates":true,"trustworthy":true},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"e01d5732173645b80f23a189a0f7e1f5cd0b2286de0ce20baf941cbf5c3b8435","pkg-src-sha256":"855c58c51935bd86e61c5886862fb36cb2dc4c63240d96d93c538e8f54ff76e3","depends":["array-0.5.4.0","assoc-1.1-e0a28437f030ebcca571cb67a5dc888f5f778b291929d1933ae056097706ae94","base-4.17.1.0","base-orphans-0.9.0-b39f938d7dd25ca7d52a209bd3c194f8bc168ba8e9db3200b86e2791633b3579","bifunctors-5.6.1-f39ba530857f17a3821a11258df076ea674a2ae495e80753da9c39900391078b","bytestring-0.11.4.0","call-stack-0.4.0-d268f078fa82b87c10ebc4a58289fa9f270b5dc9b81af27d4cacdfd573427a28","comonad-5.0.8-6cb3f4448654fd71897be46d3465d8c7fa1a39af537933846a813a454f544e6f","containers-0.6.7","contravariant-1.5.5-4a01031fa32aeaaafb5a993ff12c5aae49a7048b53def00d8ffbce8626a29402","distributive-0.6.2.1-b88884e9ae4366d59a031348fcf2960a9ce1d18b0fcf6c7e0e8d8f4364ba47a1","exceptions-0.10.5","filepath-1.4.2.2","free-5.2-4855bcd0ad7e82603c31deaf13e527f08d2291f59b45a174f004b9436ceecf29","ghc-prim-0.9.0","hashable-1.4.3.0-37fea282e73b3a240cd260ae4ff2fe7516b32c564382d860d19fdf55e0d414c2","indexed-traversable-0.1.2.1-0505391f249b00d3d49b7c397ce20702cb416ce0667632bc3d065696e2a95ddb","indexed-traversable-instances-0.1.1.2-59ef8216657bca744ef2fe65b592fb1995efe5af8f9ee654c2edbd238d45606f","kan-extensions-5.2.5-84e226dc6d09f4cc6f3b591b505c44f2a0c8687e35cc3557af66eb484ebbbde4","mtl-2.2.2","parallel-3.2.2.0-bb78cdbe37d8c2037ac850d0df5f79b5d1c8d67e1e6f1c9e89ea84f5be601261","profunctors-5.6.2-22f8d7e5445308599ec94352609ee7ee883ddfc20451986e1e4ec597ddad2588","reflection-2.1.7-5655f67bbf29baad3aba514446e1c5c836ac3b2faed1ba268af13d8c37f11ca6","semigroupoids-6.0.0.1-936f7665e7c03d49c6dda30ae1cef86cd16e99eb2fadcfbd4bdbe7f71cda5c34","strict-0.5-6623a0efcb1ed8de5ce2daacc5e007f0e92b4487d6b3cd4ddf612d1341787754","tagged-0.8.7-30f24ec195f41e232935b2add088b2ba51bf77bd036ec5c97bd4bcdd8a4771a9","template-haskell-2.19.0.0","text-2.0.2","th-abstraction-0.5.0.0-f4fb842f96457f32b9235a70384287c415a088c2eefbf55836906825d12b718e","these-1.2-6d6d75df4a25d8997293cba7608910df36e9976130672e22c85d9d675cc7f5f3","transformers-0.5.6.2","transformers-compat-0.7.2-b05be8a17a5850cb38f647c8dc32411c3f929013531c7a0210e21be2a6a1aa43","unordered-containers-0.2.19.1-d24c37c689def916e86aa83074dbfab953e97becf1c2afe78f57aef91465933c","vector-0.13.0.0-45717532419dd6453c543dc13f2ef915f0749d24bb0e507a450dae190d54b958"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"mtl-2.2.2","pkg-name":"mtl","pkg-version":"2.2.2","depends":["base-4.17.1.0","transformers-0.5.6.2"]},{"type":"configured","id":"parallel-3.2.2.0-bb78cdbe37d8c2037ac850d0df5f79b5d1c8d67e1e6f1c9e89ea84f5be601261","pkg-name":"parallel","pkg-version":"3.2.2.0","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"c652c3c6e927ba461f40ee374f80e2e1ecfe833e950654d4303a3b15597624b8","pkg-src-sha256":"170453a71a2a8b31cca63125533f7771d7debeb639700bdabdd779c34d8a6ef6","depends":["array-0.5.4.0","base-4.17.1.0","containers-0.6.7","deepseq-1.4.8.0","ghc-prim-0.9.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"pretty-1.1.3.6","pkg-name":"pretty","pkg-version":"1.1.3.6","depends":["base-4.17.1.0","deepseq-1.4.8.0","ghc-prim-0.9.0"]},{"type":"configured","id":"primitive-0.8.0.0-211187599cff725317e299b747c780c346889529ec86d77458b3399dd533f17c","pkg-name":"primitive","pkg-version":"0.8.0.0","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"826bf2a702a26ef87532a135808abad69d74f70ead39f26c06d034b1f0537a19","pkg-src-sha256":"5553c21b4a789f9b591eed69e598cc58484c274af29250e517b5a8bcc62b995f","depends":["base-4.17.1.0","deepseq-1.4.8.0","template-haskell-2.19.0.0","transformers-0.5.6.2"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"profunctors-5.6.2-22f8d7e5445308599ec94352609ee7ee883ddfc20451986e1e4ec597ddad2588","pkg-name":"profunctors","pkg-version":"5.6.2","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"e178ba4468982326656626e2089e296f64485e68fdddc9f4476dcd5d612b4f78","pkg-src-sha256":"65955d7b50525a4a3bccdab1d982d2ae342897fd38140d5a94b5ef3800d8c92a","depends":["base-4.17.1.0","base-orphans-0.9.0-b39f938d7dd25ca7d52a209bd3c194f8bc168ba8e9db3200b86e2791633b3579","bifunctors-5.6.1-f39ba530857f17a3821a11258df076ea674a2ae495e80753da9c39900391078b","comonad-5.0.8-6cb3f4448654fd71897be46d3465d8c7fa1a39af537933846a813a454f544e6f","contravariant-1.5.5-4a01031fa32aeaaafb5a993ff12c5aae49a7048b53def00d8ffbce8626a29402","distributive-0.6.2.1-b88884e9ae4366d59a031348fcf2960a9ce1d18b0fcf6c7e0e8d8f4364ba47a1","tagged-0.8.7-30f24ec195f41e232935b2add088b2ba51bf77bd036ec5c97bd4bcdd8a4771a9","transformers-0.5.6.2"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"reflection-2.1.7-5655f67bbf29baad3aba514446e1c5c836ac3b2faed1ba268af13d8c37f11ca6","pkg-name":"reflection","pkg-version":"2.1.7","flags":{"slow":false,"template-haskell":true},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"3e6ff7b582e98d8c6f84387cb37627e94831646ddab0586786a9782fe799a5dc","pkg-src-sha256":"6cbb18a8b02871533bb8b641dc6f76813a097d94404e5808bb5d52b0f0e415fd","depends":["base-4.17.1.0","template-haskell-2.19.0.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"rts-1.0.2","pkg-name":"rts","pkg-version":"1.0.2","depends":[]},{"type":"configured","id":"semigroupoids-6.0.0.1-936f7665e7c03d49c6dda30ae1cef86cd16e99eb2fadcfbd4bdbe7f71cda5c34","pkg-name":"semigroupoids","pkg-version":"6.0.0.1","flags":{"comonad":true,"containers":true,"contravariant":true,"distributive":true,"tagged":true,"unordered-containers":true},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"3ca506912c2e1fe97930d1565a2eebb608de6bc7f49736119609d6a78058dc13","pkg-src-sha256":"7da38a9891bdf8205fd6522cdb712956b8c0bf5c52983da60295c8e057d77934","depends":["base-4.17.1.0","base-orphans-0.9.0-b39f938d7dd25ca7d52a209bd3c194f8bc168ba8e9db3200b86e2791633b3579","bifunctors-5.6.1-f39ba530857f17a3821a11258df076ea674a2ae495e80753da9c39900391078b","comonad-5.0.8-6cb3f4448654fd71897be46d3465d8c7fa1a39af537933846a813a454f544e6f","containers-0.6.7","contravariant-1.5.5-4a01031fa32aeaaafb5a993ff12c5aae49a7048b53def00d8ffbce8626a29402","distributive-0.6.2.1-b88884e9ae4366d59a031348fcf2960a9ce1d18b0fcf6c7e0e8d8f4364ba47a1","foldable1-classes-compat-0.1-f7b1f8b66a445e642c21fd035c2e456080f8053e8f8c15bdf7b87c90a82b63e9","hashable-1.4.3.0-37fea282e73b3a240cd260ae4ff2fe7516b32c564382d860d19fdf55e0d414c2","tagged-0.8.7-30f24ec195f41e232935b2add088b2ba51bf77bd036ec5c97bd4bcdd8a4771a9","template-haskell-2.19.0.0","transformers-0.5.6.2","transformers-compat-0.7.2-b05be8a17a5850cb38f647c8dc32411c3f929013531c7a0210e21be2a6a1aa43","unordered-containers-0.2.19.1-d24c37c689def916e86aa83074dbfab953e97becf1c2afe78f57aef91465933c"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"semigroups-0.20-4d7ca4412bb6d4e28787e3e5a5adfb2334f52bd1ca711fae9ce125ecd840f480","pkg-name":"semigroups","pkg-version":"0.20","flags":{"binary":true,"bytestring":true,"bytestring-builder":false,"containers":true,"deepseq":true,"hashable":true,"tagged":true,"template-haskell":true,"text":true,"transformers":true,"unordered-containers":true},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"925341e6f7eb104cb490bef06eab93bb7995c7c67c51ee938185a2ddefa7aaf2","pkg-src-sha256":"902d2e33c96b40a89de5957f2a9e097197afcc35e257e45b32ebe770993673e1","depends":["base-4.17.1.0"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"stm-2.5.1.0","pkg-name":"stm","pkg-version":"2.5.1.0","depends":["array-0.5.4.0","base-4.17.1.0"]},{"type":"configured","id":"strict-0.5-6623a0efcb1ed8de5ce2daacc5e007f0e92b4487d6b3cd4ddf612d1341787754","pkg-name":"strict","pkg-version":"0.5","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"76f07389001fa7a9036cbf13a1753c0f16556bde3b79c862a8bbe1201aac2326","pkg-src-sha256":"3f4f0995dec2d520d0e321542f71412dac023658fdab603db04364d75269a0fd","depends":["assoc-1.1-e0a28437f030ebcca571cb67a5dc888f5f778b291929d1933ae056097706ae94","base-4.17.1.0","binary-0.8.9.1","bytestring-0.11.4.0","deepseq-1.4.8.0","ghc-prim-0.9.0","hashable-1.4.3.0-37fea282e73b3a240cd260ae4ff2fe7516b32c564382d860d19fdf55e0d414c2","text-2.0.2","these-1.2-6d6d75df4a25d8997293cba7608910df36e9976130672e22c85d9d675cc7f5f3","transformers-0.5.6.2"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"tagged-0.8.7-30f24ec195f41e232935b2add088b2ba51bf77bd036ec5c97bd4bcdd8a4771a9","pkg-name":"tagged","pkg-version":"0.8.7","flags":{"deepseq":true,"transformers":true},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"9013e1491dc0d291cb37c2845973293a03c230374f44792bfc96e14fdfb426dc","pkg-src-sha256":"6414eeac27a1633f49e2f78199ced99ce8ce3d70b658cf6d55b1d81ff60cb961","depends":["base-4.17.1.0","deepseq-1.4.8.0","template-haskell-2.19.0.0","transformers-0.5.6.2"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"template-haskell-2.19.0.0","pkg-name":"template-haskell","pkg-version":"2.19.0.0","depends":["base-4.17.1.0","ghc-boot-th-9.4.5","ghc-prim-0.9.0","pretty-1.1.3.6"]},{"type":"pre-existing","id":"text-2.0.2","pkg-name":"text","pkg-version":"2.0.2","depends":["array-0.5.4.0","base-4.17.1.0","binary-0.8.9.1","bytestring-0.11.4.0","deepseq-1.4.8.0","ghc-prim-0.9.0","template-haskell-2.19.0.0"]},{"type":"configured","id":"th-abstraction-0.5.0.0-f4fb842f96457f32b9235a70384287c415a088c2eefbf55836906825d12b718e","pkg-name":"th-abstraction","pkg-version":"0.5.0.0","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"4351cadf6bf0ca80c90225bae0b12f4cfdd550f30c333b050186af5a8bc19457","pkg-src-sha256":"8258dc3ab7188af5826e2467032b52a931a3af4d8a93d4a094210e240a8a9964","depends":["base-4.17.1.0","containers-0.6.7","ghc-prim-0.9.0","template-haskell-2.19.0.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"these-1.2-6d6d75df4a25d8997293cba7608910df36e9976130672e22c85d9d675cc7f5f3","pkg-name":"these","pkg-version":"1.2","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"69206d92ed38c45da07a34a86b8fafbefc7cec511ca7003ba18736a61639d03b","pkg-src-sha256":"a8ed7174b7f790764360f48aab72fea382a6093ed369c7bc6881fae1abacd4b8","depends":["assoc-1.1-e0a28437f030ebcca571cb67a5dc888f5f778b291929d1933ae056097706ae94","base-4.17.1.0","binary-0.8.9.1","deepseq-1.4.8.0","foldable1-classes-compat-0.1-f7b1f8b66a445e642c21fd035c2e456080f8053e8f8c15bdf7b87c90a82b63e9","hashable-1.4.3.0-37fea282e73b3a240cd260ae4ff2fe7516b32c564382d860d19fdf55e0d414c2"],"exe-depends":[],"component-name":"lib"},{"type":"pre-existing","id":"transformers-0.5.6.2","pkg-name":"transformers","pkg-version":"0.5.6.2","depends":["base-4.17.1.0"]},{"type":"configured","id":"transformers-base-0.4.6-9108948c73fb13b2b2323b51e541ea784201d4bd92ecef7e1c722ae378b96567","pkg-name":"transformers-base","pkg-version":"0.4.6","flags":{"orphaninstances":true},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"6f18f320e371c8954c4b6b211e2fdd5d15a6d6310bd605b9d640f47ede408961","pkg-src-sha256":"323bf8689eb691b122661cffa41a25e00fea7a768433fe2dde35d3da7d32cf90","depends":["base-4.17.1.0","base-orphans-0.9.0-b39f938d7dd25ca7d52a209bd3c194f8bc168ba8e9db3200b86e2791633b3579","stm-2.5.1.0","transformers-0.5.6.2","transformers-compat-0.7.2-b05be8a17a5850cb38f647c8dc32411c3f929013531c7a0210e21be2a6a1aa43"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"transformers-compat-0.7.2-b05be8a17a5850cb38f647c8dc32411c3f929013531c7a0210e21be2a6a1aa43","pkg-name":"transformers-compat","pkg-version":"0.7.2","flags":{"five":false,"five-three":true,"four":false,"generic-deriving":true,"mtl":true,"three":false,"two":false},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"044fb9955f63ee138fcebedfdcbe54afe741f2d5892a2d0bdf3a8052bd342643","pkg-src-sha256":"b62c7304c9f3cbc9463d0739aa85cb9489f217ea092b9d625d417514fbcc9d6a","depends":["base-4.17.1.0","ghc-prim-0.9.0","transformers-0.5.6.2"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"unordered-containers-0.2.19.1-d24c37c689def916e86aa83074dbfab953e97becf1c2afe78f57aef91465933c","pkg-name":"unordered-containers","pkg-version":"0.2.19.1","flags":{"debug":false},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"9ad8972c2e913c37b1d4f0e1261517fd7a1b8c8a58077e057be69837e3dbaa00","pkg-src-sha256":"1b27bec5e0d522b27a6029ebf4c4a6d40acbc083c787008e32fb55c4b1d128d2","depends":["base-4.17.1.0","deepseq-1.4.8.0","hashable-1.4.3.0-37fea282e73b3a240cd260ae4ff2fe7516b32c564382d860d19fdf55e0d414c2","template-haskell-2.19.0.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"vector-0.13.0.0-45717532419dd6453c543dc13f2ef915f0749d24bb0e507a450dae190d54b958","pkg-name":"vector","pkg-version":"0.13.0.0","flags":{"boundschecks":true,"internalchecks":false,"unsafechecks":false,"wall":false},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"bec2ae6c64e4da27ab4b1b5c21d40314f13f71ec2c9be5eb22f3441796318aa4","pkg-src-sha256":"c5d3167d15e12f52e00879ddf304a591672a74e369cc47bc5c7fa1d5a8d15b4f","depends":["base-4.17.1.0","deepseq-1.4.8.0","primitive-0.8.0.0-211187599cff725317e299b747c780c346889529ec86d77458b3399dd533f17c","vector-stream-0.1.0.0-7089620515557d479f030f3001ed5d31f50b77755b47e76b47e9ded9cb711699"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"vector-stream-0.1.0.0-7089620515557d479f030f3001ed5d31f50b77755b47e76b47e9ded9cb711699","pkg-name":"vector-stream","pkg-version":"0.1.0.0","flags":{},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"f5d6d5291cd1b5f2f063403593f1f5c8127d692c888eedeb3e1eb40497a88dca","pkg-src-sha256":"a888210f6467f155090653734be5cc920406a07227e0d3adb59096716fdb806c","depends":["base-4.17.1.0","ghc-prim-0.9.0"],"exe-depends":[],"component-name":"lib"},{"type":"configured","id":"void-0.7.3-6933fdfcf89282f201310830a9efb2d5d15560c3de835cede7634c9a229f713c","pkg-name":"void","pkg-version":"0.7.3","flags":{"safe":false},"style":"global","pkg-src":{"type":"repo-tar","repo":{"type":"secure-repo","uri":"http://hackage.haskell.org/"}},"pkg-cabal-sha256":"13d30f62fcdf065e595d679d4ac8b4b0c1bb1a1b73db7b5b5a8f857cb5c8a546","pkg-src-sha256":"53af758ddc37dc63981671e503438d02c6f64a2d8744e9bec557a894431f7317","depends":["base-4.17.1.0"],"exe-depends":[],"component-name":"lib"}]} \ No newline at end of file diff --git a/make-install-plan/make-install-plan/tests/golden/test1.project b/make-install-plan/make-install-plan/tests/golden/test1.project new file mode 100644 index 0000000000..d57e79e044 --- /dev/null +++ b/make-install-plan/make-install-plan/tests/golden/test1.project @@ -0,0 +1,2 @@ +index-state: 2023-08-01T22:46:02Z +extra-packages: lens diff --git a/make-install-plan/project.nix b/make-install-plan/project.nix new file mode 100644 index 0000000000..e0fa09e112 --- /dev/null +++ b/make-install-plan/project.nix @@ -0,0 +1,20 @@ +{ + lib, + haskell-nix, +}: + +haskell-nix.cabalProject' { + name = "make-install-plan"; + src = ./make-install-plan; + + compiler-nix-name = lib.mkDefault "ghc984"; + + # tests need to fetch hackage + configureArgs = lib.mkDefault "--disable-tests"; + + # Tools to include in the development shell + shell.tools = { + cabal = "latest"; + haskell-language-server.src = "latest"; + }; +} diff --git a/overlays/haskell.nix b/overlays/haskell.nix index 1d3acd4dea..7c020b4119 100644 --- a/overlays/haskell.nix +++ b/overlays/haskell.nix @@ -1100,5 +1100,10 @@ final: prev: { # in haskell.nix itself. && !final.stdenv.hostPlatform.isGhcjs) final.haskell-nix.iserv-proxy-exes.${compiler-nix-name}); + + make-install-plan = final.callPackage ../make-install-plan {}; + make-install-plan-bootstrap = let + flake = builtins.getFlake (toString ../make-install-plan); + in flake.packages.${final.system}.make-install-plan; }; }