diff options
Diffstat (limited to 'third_party/bazel/rules_haskell/haskell/nixpkgs.bzl')
| -rw-r--r-- | third_party/bazel/rules_haskell/haskell/nixpkgs.bzl | 354 |
1 files changed, 0 insertions, 354 deletions
diff --git a/third_party/bazel/rules_haskell/haskell/nixpkgs.bzl b/third_party/bazel/rules_haskell/haskell/nixpkgs.bzl deleted file mode 100644 index 20d77f72193a..000000000000 --- a/third_party/bazel/rules_haskell/haskell/nixpkgs.bzl +++ /dev/null @@ -1,354 +0,0 @@ -"""Workspace rules (Nixpkgs)""" - -load("@bazel_skylib//lib:dicts.bzl", "dicts") -load( - "@io_tweag_rules_nixpkgs//nixpkgs:nixpkgs.bzl", - "nixpkgs_package", -) - -def haskell_nixpkgs_package( - name, - attribute_path, - nix_file_deps = [], - repositories = {}, - build_file_content = None, - build_file = None, - **kwargs): - """Load a single haskell package. - The package is expected to be in the form of the packages generated by - `genBazelBuild.nix` - """ - repositories = dicts.add( - {"bazel_haskell_wrapper": "@io_tweag_rules_haskell//haskell:nix/default.nix"}, - repositories, - ) - - nixpkgs_args = dict( - name = name, - attribute_path = attribute_path, - build_file_content = build_file_content, - nix_file_deps = nix_file_deps + ["@io_tweag_rules_haskell//haskell:nix/default.nix"], - repositories = repositories, - **kwargs - ) - - if build_file_content: - nixpkgs_args["build_file_content"] = build_file_content - elif build_file: - nixpkgs_args["build_file"] = build_file - else: - nixpkgs_args["build_file_content"] = """ -package(default_visibility = ["//visibility:public"]) -load("@io_tweag_rules_haskell//haskell:import.bzl", haskell_import_new = "haskell_import") - -load(":BUILD.bzl", "targets") -targets() -""" - - nixpkgs_package( - **nixpkgs_args - ) - -def _bundle_impl(repository_ctx): - build_file_content = """ -package(default_visibility = ["//visibility:public"]) - """ - for package in repository_ctx.attr.packages: - build_file_content += """ -alias( - name = "{package}", - actual = "@{base_repo}-{package}//:pkg", -) - """.format( - package = package, - base_repo = repository_ctx.attr.base_repository, - ) - repository_ctx.file("BUILD", build_file_content) - -_bundle = repository_rule( - attrs = { - "packages": attr.string_list(), - "base_repository": attr.string(), - }, - implementation = _bundle_impl, -) -""" -Generate an alias from `@base_repo//:package` to `@base_repo-package//:pkg` for -each one of the input package -""" - -def haskell_nixpkgs_packages(name, base_attribute_path, packages, **kwargs): - """Import a set of haskell packages from nixpkgs. - - This takes as input the same arguments as - [nixpkgs_package](https://github.com/tweag/rules_nixpkgs#nixpkgs_package), - expecting the `attribute_path` to resolve to a set of haskell packages - (such as `haskellPackages` or `haskell.packages.ghc822`) preprocessed by - the `genBazelBuild` function. It also takes as input a list of packages to - import (which can be generated by the `gen_packages_list` function). - """ - for package in packages: - haskell_nixpkgs_package( - name = name + "-" + package, - attribute_path = base_attribute_path + "." + package, - **kwargs - ) - _bundle( - name = name, - packages = packages, - base_repository = name, - ) - -def _is_nix_platform(repository_ctx): - return repository_ctx.which("nix-build") != None - -def _gen_imports_impl(repository_ctx): - repository_ctx.file("BUILD", "") - extra_args_raw = "" - for foo, bar in repository_ctx.attr.extra_args.items(): - extra_args_raw += foo + " = " + bar + ", " - bzl_file_content = """ -load("{repo_name}", "packages") -load("@io_tweag_rules_haskell//haskell:nixpkgs.bzl", "haskell_nixpkgs_packages") - -def import_packages(name): - haskell_nixpkgs_packages( - name = name, - packages = packages, - {extra_args_raw} - ) - """.format( - repo_name = repository_ctx.attr.packages_list_file, - extra_args_raw = extra_args_raw, - ) - - # A dummy 'packages.bzl' file with a no-op 'import_packages()' on unsupported platforms - bzl_file_content_unsupported_platform = """ -def import_packages(name): - return - """ - if _is_nix_platform(repository_ctx): - repository_ctx.file("packages.bzl", bzl_file_content) - else: - repository_ctx.file("packages.bzl", bzl_file_content_unsupported_platform) - -_gen_imports_str = repository_rule( - implementation = _gen_imports_impl, - attrs = dict( - packages_list_file = attr.label(doc = "A list containing the list of packages to import"), - # We pass the extra arguments to `haskell_nixpkgs_packages` as strings - # since we can't forward arbitrary arguments in a rule and they will be - # converted to strings anyways. - extra_args = attr.string_dict(doc = "Extra arguments for `haskell_nixpkgs_packages`"), - ), -) -""" -Generate a repository containing a file `packages.bzl` which imports the given -packages list. -""" - -def _gen_imports(name, packages_list_file, extra_args): - """ - A wrapper around `_gen_imports_str` which allows passing an arbitrary set of - `extra_args` instead of a set of strings - """ - extra_args_str = {label: repr(value) for (label, value) in extra_args.items()} - _gen_imports_str( - name = name, - packages_list_file = packages_list_file, - extra_args = extra_args_str, - ) - -def haskell_nixpkgs_packageset(name, base_attribute_path, repositories = {}, **kwargs): - """Import all the available haskell packages. - The arguments are the same as the arguments of ``nixpkgs_package``, except - for the ``base_attribute_path`` which should point to an `haskellPackages` - set in the nix expression - - Example: - - In `haskellPackages.nix`: - - ```nix - with import <nixpkgs> {}; - - let wrapPackages = callPackage <bazel_haskell_wrapper> { }; in - { haskellPackages = wrapPackages haskell.packages.ghc822; } - ``` - - In your `WORKSPACE` - - ```bazel - # Define a nix repository to fetch the packages from - load("@io_tweag_rules_nixpkgs//nixpkgs:nixpkgs.bzl", - "nixpkgs_git_repository") - nixpkgs_git_repository( - name = "nixpkgs", - revision = "9a787af6bc75a19ac9f02077ade58ddc248e674a", - ) - - load("@io_tweag_rules_haskell//haskell:nixpkgs.bzl", - "haskell_nixpkgs_packageset", - - # Generate a list of all the available haskell packages - haskell_nixpkgs_packageset( - name = "hackage-packages", - repositories = {"@nixpkgs": "nixpkgs"}, - nix_file = "//haskellPackages.nix", - base_attribute_path = "haskellPackages", - ) - load("@hackage-packages//:packages.bzl", "import_packages") - import_packages(name = "hackage") - ``` - - Then in your `BUILD` files, you can access to the whole of hackage as - `@hackage//:{your-package-name}` - """ - - repositories = dicts.add( - {"bazel_haskell_wrapper": "@io_tweag_rules_haskell//haskell:nix/default.nix"}, - repositories, - ) - - nixpkgs_package( - name = name + "-packages-list", - attribute_path = base_attribute_path + ".packageNames", - repositories = repositories, - build_file_content = """ -exports_files(["all-haskell-packages.bzl"]) - """, - fail_not_supported = False, - **kwargs - ) - _gen_imports( - name = name, - packages_list_file = "@" + name + "-packages-list//:all-haskell-packages.bzl", - extra_args = dict( - repositories = repositories, - base_attribute_path = base_attribute_path, - **kwargs - ), - ) - -def _ghc_nixpkgs_toolchain_impl(repository_ctx): - # These constraints might look tautological, because they always - # match the host platform if it is the same as the target - # platform. But they are important to state because Bazel - # toolchain resolution prefers other toolchains with more specific - # constraints otherwise. - target_constraints = ["@bazel_tools//platforms:x86_64"] - if repository_ctx.os.name == "linux": - target_constraints.append("@bazel_tools//platforms:linux") - elif repository_ctx.os.name == "mac os x": - target_constraints.append("@bazel_tools//platforms:osx") - exec_constraints = list(target_constraints) - exec_constraints.append("@io_tweag_rules_haskell//haskell/platforms:nixpkgs") - - compiler_flags_select = repository_ctx.attr.compiler_flags_select or {"//conditions:default": []} - locale_archive = repr(repository_ctx.attr.locale_archive or None) - - repository_ctx.file( - "BUILD", - executable = False, - content = """ -load("@io_tweag_rules_haskell//haskell:toolchain.bzl", "haskell_toolchain") - -haskell_toolchain( - name = "toolchain", - tools = ["{tools}"], - version = "{version}", - compiler_flags = {compiler_flags} + {compiler_flags_select}, - haddock_flags = {haddock_flags}, - repl_ghci_args = {repl_ghci_args}, - # On Darwin we don't need a locale archive. It's a Linux-specific - # hack in Nixpkgs. - locale_archive = {locale_archive}, - exec_compatible_with = {exec_constraints}, - target_compatible_with = {target_constraints}, -) - """.format( - tools = "@io_tweag_rules_haskell_ghc-nixpkgs//:bin", - version = repository_ctx.attr.version, - compiler_flags = repository_ctx.attr.compiler_flags, - compiler_flags_select = "select({})".format(compiler_flags_select), - haddock_flags = repository_ctx.attr.haddock_flags, - repl_ghci_args = repository_ctx.attr.repl_ghci_args, - locale_archive = locale_archive, - exec_constraints = exec_constraints, - target_constraints = target_constraints, - ), - ) - -_ghc_nixpkgs_toolchain = repository_rule( - _ghc_nixpkgs_toolchain_impl, - local = False, - attrs = { - # These attributes just forward to haskell_toolchain. - # They are documented there. - "version": attr.string(), - "compiler_flags": attr.string_list(), - "compiler_flags_select": attr.string_list_dict(), - "haddock_flags": attr.string_list(), - "repl_ghci_args": attr.string_list(), - "locale_archive": attr.string(), - }, -) - -def haskell_register_ghc_nixpkgs( - version, - build_file = None, - compiler_flags = None, - compiler_flags_select = None, - haddock_flags = None, - repl_ghci_args = None, - locale_archive = None, - attribute_path = "haskellPackages.ghc", - nix_file = None, - nix_file_deps = [], - repositories = {}): - """Register a package from Nixpkgs as a toolchain. - - Toolchains can be used to compile Haskell code. To have this - toolchain selected during [toolchain - resolution][toolchain-resolution], set a host platform that - includes the `@io_tweag_rules_haskell//haskell/platforms:nixpkgs` - constraint value. - - [toolchain-resolution]: https://docs.bazel.build/versions/master/toolchains.html#toolchain-resolution - - Example: - - ``` - haskell_register_ghc_nixpkgs( - locale_archive = "@glibc_locales//:locale-archive", - atttribute_path = "haskellPackages.ghc", - version = "1.2.3", # The version of GHC - ) - ``` - - Setting the host platform can be done on the command-line like - in the following: - - ``` - --host_platform=@io_tweag_rules_haskell//haskell/platforms:linux_x86_64_nixpkgs - ``` - - """ - haskell_nixpkgs_package( - name = "io_tweag_rules_haskell_ghc-nixpkgs", - attribute_path = attribute_path, - build_file = build_file or "@io_tweag_rules_haskell//haskell:ghc.BUILD", - nix_file = nix_file, - nix_file_deps = nix_file_deps, - repositories = repositories, - ) - _ghc_nixpkgs_toolchain( - name = "io_tweag_rules_haskell_ghc-nixpkgs-toolchain", - version = version, - compiler_flags = compiler_flags, - compiler_flags_select = compiler_flags_select, - haddock_flags = haddock_flags, - repl_ghci_args = repl_ghci_args, - locale_archive = locale_archive, - ) - native.register_toolchains("@io_tweag_rules_haskell_ghc-nixpkgs-toolchain//:toolchain") |