start

#!/usr/bin/env sh
#
# Checks the version of Bazel found in the PATH, and then initializes
# a new Bazel workspace with dummy Haskell build targets.

set -eu

# If the environment variable `GHC_VERSION` is not set yet,
# we use the default version (currently "9.4.6").
GHC_VERSION=${GHC_VERSION:="9.4.6"}

NIXPKGS_REVISION=${NIXPKGS_REVISION:-nixos-24.05}

readonly MIN_BAZEL_MAJOR=6
readonly MIN_BAZEL_MINOR=0

readonly MAX_BAZEL_MAJOR=6
readonly MAX_BAZEL_MINOR=5

stderr () {
  >&2 echo "$*"
}

usage () {
    exit_code="$1"

    cat >&2 <<-"EOF"
	start [--use-bindists|--use-nix|--help|--with-bzlmod=true|false]

	Set up a minimal rules_haskell bazel configuration.

	--use-bindists: The project is set up to provision GHC from binary distributions. This does not require nix to build.
	--use-nix: The project is set up to provision GHC from nixpkgs. This requires nix to build.

	--with-bzlmod=true|false:
	    If enabled, use a MODULE.bazel file and enable bzlmod to fetch rules_haskell.
	    (only supported in bindist mode)

	If no argument is given, `--use-bindists` is assumed
	and a helpful message is printed that `--use-nix` also exists.

	For more information visit https://haskell.build/
	EOF

    exit "${exit_code}"
}

# either bindists or nix
MODE="bindists"
PRINT_NIX_USAGE=
BZLMOD=false

parse_args () {
    # Defaults, if no arguments provided
    if [ "$#" -eq 0 ]; then
        PRINT_NIX_USAGE=1
        return
    fi

    for arg; do
        case "$arg" in
            "--help")              usage 0 ;;
            "--use-bindists")      MODE="bindists" ;;
            "--use-nix")           MODE="nix" ;;
            "--with-bzlmod=true")  BZLMOD=true ;;
            "--with-bzlmod=false") BZLMOD=false ;;
            *)                     usage 1 ;;
        esac
    done

    if $BZLMOD && [ $MODE != bindists ]; then
        stderr "error: --with-bzlmod is only supported with --use-bindists"
        exit 1
    fi
}

check_dir () {
    path="$1"

    # we can't write a file when a directory of that name exists
    if [ -d "${path}" ]; then
        stderr "STOP: There's a directory named ${path} but we want to write a file with the same name. Please delete or rename the ${path} directory."
        exit 1
    fi
}

check_alt () {
    path="$1"
    alternative="$2"

    check_dir "${alternative}"
    if [ -f "${path}" ]; then
        stderr "STOP: There's a ${path} file but we intend to write a ${alternative} file. When both exist, bazel will pick the one with the .bazel extension, ignoring the other one. Please delete the ${path} file."
        exit 1
    fi
}

check_clash () {
    path="$1"

    check_dir "${path}"
    if [ -e "${path}" ]; then
        stderr "STOP: The current directory already has a ${path} file and we don't want to overwrite it."
        exit 1
    fi
}

check_files_dont_exist () {
    # A BUILD.bazel file takes precedence over a BUILD file and likewise
    # a WORKSPACE.bazel file takes precedence over a WORKSPACE file. We write
    # BUILD.bazel and WORKSPACE files.
    # Some Bazel tooling may fail on WORKSPACE.bazel files,
    # e.g. https://github.com/bazelbuild/bazel-gazelle/issues/678
    check_alt WORKSPACE.bazel WORKSPACE
    check_alt BUILD BUILD.bazel

    for clash in .bazelrc WORKSPACE BUILD.bazel MODULE.bazel zlib.BUILD.bazel Example.hs non_module_deps.bzl; do
        check_clash "${clash}"
    done
}

have () {
    command -v "$1" > /dev/null 2>&1
}

check_bazel_version () {
    if ! have bazel; then
        # shellcheck disable=SC2016
        stderr 'Warning: cannot find `bazel` executable in $PATH (skipping version check)'
        return
    fi
    if ! actual_raw=$(bazel version | grep -E '^Build label:' | grep -Eo '[0-9.]+'); then
        stderr 'Warning: cannot determine bazel version (skipping version check)'
        return
    fi

    # shellcheck disable=SC2034
    if ! IFS=. read -r actual_major actual_minor actual_patch <<-EOF
	${actual_raw}
	EOF
    then
        stderr "Warning: cannot parse version from bazel output (skipping version check)"
        return
    fi

    expected_min="${MIN_BAZEL_MAJOR}.${MIN_BAZEL_MINOR}.0"
    expected_max="${MAX_BAZEL_MAJOR}.${MAX_BAZEL_MINOR}.x"

    if [ "${actual_major}" -gt "${MAX_BAZEL_MAJOR}" ] || \
       { [ "${actual_major}" -eq "${MAX_BAZEL_MAJOR}" ] && [ "${actual_minor}" -gt "${MAX_BAZEL_MINOR}" ]; }
    then
        stderr "Warning: a too new version of Bazel detected: v${actual_raw}."
        stderr "         Recommended versions are from v${expected_min} to v${expected_max}."

    elif [ "${actual_major}" -lt "${MIN_BAZEL_MAJOR}" ] || \
         { [ "${actual_major}" -eq "${MIN_BAZEL_MAJOR}" ] && [ "${actual_minor}" -lt "${MIN_BAZEL_MINOR}" ]; }
    then
        stderr "Error: Need at least Bazel v${expected_min} but v${actual_raw} detected."
        exit 1
    fi
}

## Parse Arguments and Preflight Checks ################################

parse_args "$@"

if [ "${PRINT_NIX_USAGE}" ]; then
    # shellcheck disable=SC2016
    stderr 'INFO: Creating a WORKSPACE file based on GHC bindists. If you want to use a nix-based setup (e.g. on NixOS), call with `--use-nix`. See `--help` for more info.'
fi

check_files_dont_exist
check_bazel_version

## Write zlib Build File ###############################################

readonly ZLIB_BUILD_FILE="zlib.BUILD.bazel"

stderr "Creating ${ZLIB_BUILD_FILE}"

case "${MODE}" in
    "bindists") cat <<-EOF
		load("@rules_cc//cc:defs.bzl", "cc_library")

		cc_library(
		    name = "zlib",
		    # Import ':z' as 'srcs' to enforce the library name 'libz.so'. Otherwise,
		    # Bazel would mangle the library name and e.g. Cabal wouldn't recognize it.
		    srcs = [":z"],
		    hdrs = glob(["*.h"]),
		    includes = ["."],
		    visibility = ["//visibility:public"],
		)
		cc_library(
		    name = "z",
		    srcs = glob(["*.c"]),
		    hdrs = glob(["*.h"]),
		    copts = ["-Wno-implicit-function-declaration"],
		)
		EOF
        ;;

    "nix") cat <<-EOF
		load("@rules_cc//cc:defs.bzl", "cc_library")

		filegroup(
		    name = "include",
		    srcs = glob(["include/*.h"]),
		    visibility = ["//visibility:public"],
		)
		cc_library(
		    name = "zlib",
		    srcs = ["@nixpkgs_zlib//:lib"],
		    hdrs = [":include"],
		    strip_include_prefix = "include",
		    visibility = ["//visibility:public"],
		)
		EOF
        ;;
esac > "${ZLIB_BUILD_FILE}"

WITH_HADDOCK=True

case "$GHC_VERSION" in
    8.10.*)
        SNAPSHOT=lts-18.28
        ;;
    9.0.*)
        SNAPSHOT=lts-19.33
        ;;
    9.2.*)
        SNAPSHOT=lts-20.26
        ;;
    9.4.*)
        SNAPSHOT=lts-21.5
        ;;
    9.6.*)
        SNAPSHOT=lts-22.22
        ;;
    *)
        # zlib >= 0.7.1.0 depends on zlib-clib on Windows (unless using pkg-config), since zlib-clib is
        # a C only cabal library that does not produce any haddock this results in an error.
        # See https://github.com/tweag/rules_haskell/issues/2200
        case "$( uname )" in
            WindowsNT | MINGW* | MSYS* ) WITH_HADDOCK=False ;;
        esac
        SNAPSHOT=nightly-2024-05-24
        stderr "warning: unsupported GHC version: ${GHC_VERSION}, using stack resolver ${SNAPSHOT}"
esac


## Write WORKSPACE File ################################################

stderr "Creating WORKSPACE"

if $BZLMOD; then
    touch WORKSPACE
else
    cat > WORKSPACE <<EOF
# Give your project a name. :)
workspace(name = "YOUR_PROJECT_NAME_HERE")

# Load the repository rule to download an http archive.
load(
    "@bazel_tools//tools/build_defs/repo:http.bzl",
    "http_archive"
)

# Download rules_haskell and make it accessible as "@rules_haskell".
http_archive(
    name = "rules_haskell",
    sha256 = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
    strip_prefix = "rules_haskell-M.NN",
    url = "https://github.com/tweag/rules_haskell/releases/download/vM.NN/rules_haskell-M.NN.tar.gz",
)

load(
    "@rules_haskell//haskell:repositories.bzl",
    "rules_haskell_dependencies",
)

# Setup all Bazel dependencies required by rules_haskell.
rules_haskell_dependencies()

load(
    "@rules_haskell//haskell:toolchain.bzl",
    "rules_haskell_toolchains",
)

load(
    "@rules_haskell//haskell:cabal.bzl",
    "stack_snapshot"
)

stack_snapshot(
    name = "stackage",
    extra_deps = {"zlib": ["@zlib.dev//:zlib"]},
    packages = ["zlib"],

    # disable calling pkg-config
    flags = {"zlib": ["-pkg-config"]},
    haddock = $WITH_HADDOCK,

    # LTS snapshot published for ghc-${GHC_VERSION} (default version used by rules_haskell)
    snapshot = "$SNAPSHOT",

    # This uses an unpinned version of stack_snapshot, meaning that stack is invoked on every build.
    # To switch to pinned stackage dependencies, run \`bazel run @stackage-unpinned//:pin\` and
    # uncomment the following line.
    # stack_snapshot_json = "//:stackage_snapshot.json",
)

EOF

    # Append toolchain and zlib rules
    case "${MODE}" in
        "bindists") cat <<-EOF
		# Download a GHC binary distribution from haskell.org and register it as a toolchain.
		rules_haskell_toolchains(
		    version = "${GHC_VERSION}",
		)

		http_archive(
		    name = "zlib.dev",
		    build_file = "//:${ZLIB_BUILD_FILE}",
		    sha256 = "9a93b2b7dfdac77ceba5a558a580e74667dd6fede4585b91eefb60f03b72df23",
		    strip_prefix = "zlib-1.3.1",
		    urls = ["https://github.com/madler/zlib/releases/download/v1.3.1/zlib-1.3.1.tar.gz"],
		)
		EOF
        ;;

        "nix") cat <<-EOF
		# Load nixpkgs_git_repository from rules_nixpkgs,
		# which was already initialized by rules_haskell_dependencies above.
		load(
		    "@io_tweag_rules_nixpkgs//nixpkgs:nixpkgs.bzl",
		    "nixpkgs_cc_configure",
		    "nixpkgs_git_repository",
		    "nixpkgs_package",
		    "nixpkgs_python_configure",
		)

		# Fetch a version of nixpkgs from GitHub.
		# For more information see the documentation of rules_nixpkgs at
		# https://github.com/tweag/rules_nixpkgs/blob/master/README.md
		nixpkgs_git_repository(
		    name = "nixpkgs",
		    revision = "${NIXPKGS_REVISION}",${NIXPKGS_HASH:+
		    integrity = \"$NIXPKGS_HASH\",}
		)

		nixpkgs_cc_configure(
		    repository = "@nixpkgs",
		)

		nixpkgs_python_configure(
		    repository = "@nixpkgs",
		)

		load(
		    "@rules_haskell//haskell:nixpkgs.bzl",
		    "haskell_register_ghc_nixpkgs",
		)

		# Fetch a GHC binary distribution from nixpkgs and register it as a toolchain.
		# For more information:
		# https://api.haskell.build/haskell/nixpkgs.html#haskell_register_ghc_nixpkgs
		haskell_register_ghc_nixpkgs(
		    repository = "@nixpkgs",
		    attribute_path = "haskell.compiler.ghc$( echo "$GHC_VERSION" | tr -d . )",
		    version = "${GHC_VERSION}",
		)

		# For ${ZLIB_BUILD_FILE}
		nixpkgs_package(
		    name = "nixpkgs_zlib",
		    attribute_path = "zlib",
		    repository = "@nixpkgs",
		)

		nixpkgs_package(
		    name = "zlib.dev",
		    build_file = "//:${ZLIB_BUILD_FILE}",
		    repository = "@nixpkgs",
		)
		EOF
        ;;
    esac >> WORKSPACE
fi

if $BZLMOD; then
    stderr "Creating MODULE.bazel"

    cat >MODULE.bazel <<EOF
module(name = "your_project_name_here", version = "0.1")

bazel_dep(name = "rules_haskell", version = "0.0")
bazel_dep(name = "rules_cc", version = "0.0.9")

haskell_toolchains = use_extension(
    "@rules_haskell//extensions:haskell_toolchains.bzl",
    "haskell_toolchains",
)

haskell_toolchains.bindists(version = "$GHC_VERSION")

non_module_deps = use_extension(
    "//:non_module_deps.bzl",
    "non_module_deps",
)

use_repo(
    non_module_deps,
    "zlib.dev",
)

stack = use_extension(
    "@rules_haskell//extensions:stack_snapshot.bzl",
    "stack_snapshot",
)

use_repo(
    stack,
    "stackage",
    "stackage-exe",
    "stackage-unpinned",
)

stack.package(
    name = "zlib",
    extra_deps = ["@zlib.dev//:zlib"],
)

# LTS snapshot published for ghc-${GHC_VERSION} (default version used by rules_haskell)
stack.snapshot(name = "$SNAPSHOT")

# This uses an unpinned version of stack_snapshot, meaning that stack is invoked on every build.
# To switch to pinned stackage dependencies, run \`bazel run @stackage-unpinned//:pin\` and
# uncomment the following line.
#stack.stack_snapshot_json(label = "//:stackage_snapshot.json")

EOF

    stderr "Creating non_module_deps.bzl"

    cat >non_module_deps.bzl <<-EOF
			load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")

			def _non_module_deps_impl(_mctx):
			    http_archive(
			        name = "zlib.dev",
			        build_file = "//:${ZLIB_BUILD_FILE}",
			        sha256 = "b5b06d60ce49c8ba700e0ba517fa07de80b5d4628a037f4be8ad16955be7a7c0",
			        strip_prefix = "zlib-1.3",
			        urls = ["https://github.com/madler/zlib/archive/v1.3.tar.gz"],
			    )

			non_module_deps = module_extension(implementation = _non_module_deps_impl)
		EOF
fi

## Write .bazelrc File #################################################

stderr "Creating .bazelrc"

cat > .bazelrc <<EOF
build:ci --loading_phase_threads=1
build:ci --jobs=2
build:ci --verbose_failures
common:ci --color=no
test:ci --test_output=errors

common --enable_bzlmod=$BZLMOD

# Should become the default in bazel 7
build --incompatible_enable_cc_toolchain_resolution

# Enable automatic OS-specific config (e.g. build:linux, build:macos, build:windows).
common --enable_platform_specific_config

# MacOS Configuration
# -------------------
# do not use Xcode on macOS
common:macos --repo_env=BAZEL_USE_CPP_ONLY_TOOLCHAIN=1

# Windows Configuration
# ---------------------
# prevent auto-detection of system compilers on Windows
common:windows --repo_env=BAZEL_DO_NOT_DETECT_CPP_TOOLCHAIN=1

EOF

if [ "${MODE}" = "nix" ]; then
    cat >> .bazelrc <<-EOF
	# This project uses a GHC provisioned via nix.
	# We need to use the rules_haskell nix toolchain accordingly:
	build --host_platform=@rules_nixpkgs_core//platforms:host
	run --host_platform=@rules_nixpkgs_core//platforms:host

	EOF
fi

cat >> .bazelrc <<EOF
# test environment does not propagate locales by default
# some tests reads files written in UTF8, we need to propagate the correct
# environment variables, such as LOCALE_ARCHIVE
# We also need to setup an utf8 locale
test --test_env=LANG=en_US.utf8 --test_env=LOCALE_ARCHIVE

try-import .bazelrc.local
EOF

## Write BUILD.bazel File ##############################################

stderr "Creating BUILD.bazel"

cat > BUILD.bazel <<EOF
# Set all target’s visibility in this package to "public".
package(default_visibility = ["//visibility:public"])

# Load rules_haskell rules.
load(
    "@rules_haskell//haskell:defs.bzl",
    "haskell_toolchain_library",
    "haskell_library",
    "haskell_binary",
)

# haskell_toolchain_library can access builtin GHC packages
# and assign them a bazel target name, so that they
# can be referenced as dependencies.
haskell_toolchain_library(name = "base")

# You can add your own libraries with haskell_library.
# haskell_library(
#     name = "MY_LIBRARY_NAME",
#     src_strip_prefix = "src",
#     srcs = glob(['src/**/*.hs']),
#     deps = [
#         "base_pkg"
#     ],
# )

# An example binary using the Prelude module from the
# GHC base package, and zlib from stackage, to print the hello world.
haskell_binary(
    name = "example",
    srcs = [":Example.hs"],
    deps = [":base", "@stackage//:zlib"],
)
EOF

## Write Example.hs File ###############################################

stderr "Creating Example.hs"

cat > Example.hs <<EOF
module Main where

import Codec.Compression.Zlib (compress, decompress)
import Prelude ((.), putStrLn)

main = putStrLn "Hello from rules_haskell!"

slowId = decompress . compress
EOF

## Finish Up ###########################################################

cat >&2 <<EOF
WORKSPACE and initial BUILD files created. To run Bazel and build the example:

    $ bazel run //:example
EOF