zellij/Makefile.toml

# Global Settings
[env]
CARGO_MAKE_EXTEND_WORKSPACE_MAKEFILE = true
CARGO_TARGET_DIR = "${CARGO_MAKE_WORKSPACE_WORKING_DIRECTORY}/target"
SKIP_TEST = false
ZELLIJ_EXAMPLE_DIR = "${CARGO_MAKE_WORKSPACE_WORKING_DIRECTORY}/example"
ZELLIJ_ASSETS_DIR = "${CARGO_MAKE_WORKSPACE_WORKING_DIRECTORY}/zellij-utils/assets"

# Add clippy to the default flow
[tasks.dev-test-flow]
dependencies = [
    "format-flow",
    "format-toml-conditioned-flow",
    "pre-build",
    "build",
    "post-build",
    "test-flow",
    "clippy",
]

# Patching the default flows to skip testing of wasm32-wasi targets
[tasks.pre-test]
condition = { env = { "CARGO_MAKE_CRATE_TARGET_TRIPLE" = "wasm32-wasi" } }
env = { "SKIP_TEST" = true }

[tasks.test]
condition = { env_false = ["SKIP_TEST"] }
dependencies = ["pre-test"]
args = ["test", "--", "@@split(CARGO_MAKE_TASK_ARGS,;)"]

[tasks.post-test]
env = { "SKIP_TEST" = false }

# Running Zellij using the development data directory
[tasks.run]
workspace = false
dependencies = ["build-workspace", "build-dev-data-dir"]
run_task = "launch"

[tasks.build-workspace]
run_task = { name = "build", fork = true }

[tasks.build]
args = ["build"]

[tasks.build-release]
args = ["build", "--release"]

[tasks.build-dev-data-dir]
dependencies = ["build-plugins"]
script_runner = "@duckscript"
script = '''
target_dir = set ${CARGO_TARGET_DIR}
data_dir = set ${target_dir}/dev-data
rm -r ${data_dir}
plugins = glob_array ${target_dir}/wasm32-wasi/debug/*.wasm
mkdir ${data_dir}
mkdir ${data_dir}/plugins
for plugin in ${plugins}
    plugin_name = basename ${plugin}
    cp ${plugin} ${data_dir}/plugins/${plugin_name}
end
writefile ${data_dir}/VERSION ${CARGO_MAKE_CRATE_VERSION}
'''

[tasks.build-e2e-data-dir]
dependencies = ["build-plugins-release"]
script_runner = "@duckscript"
script = '''
target_dir = set ${CARGO_TARGET_DIR}
data_dir = set ${target_dir}/e2e-data
rm -r ${data_dir}
plugins = glob_array ${target_dir}/wasm32-wasi/release/*.wasm
mkdir ${data_dir}
mkdir ${data_dir}/plugins
for plugin in ${plugins}
    plugin_name = basename ${plugin}
    cp ${plugin} ${data_dir}/plugins/${plugin_name}
end
writefile ${data_dir}/VERSION ${CARGO_MAKE_CRATE_VERSION}
'''

[tasks.launch]
command = "cargo"
args = [
    "run",
    "--",
    "--data-dir",
    "${CARGO_TARGET_DIR}/dev-data/",
    "@@split(CARGO_MAKE_TASK_ARGS,;)",
]

# Simple clippy tweak
[tasks.clippy]
args = ["clippy", "--all-targets", "--", "@@split(CARGO_MAKE_TASK_ARGS,;)"]

# Release building and installing Zellij
[tasks.install]
workspace = false
dependencies = ["wasm-opt-plugins", "build-release", "manpage"]
script_runner = "@duckscript"
script = '''
if is_dir ${CARGO_MAKE_TASK_ARGS}
    trigger_error "You need to specify a full path for the binary, not just a directory!"
else
    cp ${CARGO_TARGET_DIR}/release/${CARGO_MAKE_CRATE_NAME} ${CARGO_MAKE_TASK_ARGS}
end
'''

[tasks.build-plugins-release]
env = { "CARGO_MAKE_WORKSPACE_INCLUDE_MEMBERS" = [
    "default-plugins/status-bar",
    "default-plugins/strider",
    "default-plugins/tab-bar",
] }
run_task = { name = "build-release", fork = true }

[tasks.build-plugins]
env = { "CARGO_MAKE_WORKSPACE_INCLUDE_MEMBERS" = [
    "default-plugins/status-bar",
    "default-plugins/strider",
    "default-plugins/tab-bar",
] }
run_task = { name = "build", fork = true }

[tasks.wasm-opt-plugins]
dependencies = ["build-plugins-release"]
script_runner = "@duckscript"
script = '''
plugins = glob_array ${CARGO_TARGET_DIR}/wasm32-wasi/release/*.wasm

for plugin in ${plugins}
    mkdir ${CARGO_MAKE_WORKSPACE_WORKING_DIRECTORY}/assets/plugins/
    plugin_name = basename ${plugin}
    plugin_out = set ${CARGO_MAKE_WORKSPACE_WORKING_DIRECTORY}/assets/plugins/${plugin_name}
    if is_path_newer ${plugin} ${plugin_out} or not is_path_exists ${plugin_out}
        exec wasm-opt -O ${plugin} -o ${plugin_out}
    end
end
'''

[tasks.manpage]
workspace = false
description = "Use mandown crate to create or update man entry from docs/MANPAGES.md"
script = '''
root_dir=${CARGO_MAKE_WORKSPACE_WORKING_DIRECTORY}
mkdir -p ${root_dir}/assets/man
mandown ${root_dir}/docs/MANPAGE.md ZELLIJ 1 > ${root_dir}/assets/man/zellij.1
'''
dependencies = ["install-mandown"]

[tasks.install-mandown]
command = "cargo"
args = ["install", "mandown"]


# copy the example default config from assets directory to a more user facing one
[tasks.update-default-config]
workspace = false
dependencies = []
script_runner = "@duckscript"
script = '''
cp ${ZELLIJ_ASSETS_DIR}/config/default.yaml ${ZELLIJ_EXAMPLE_DIR}/default.yaml
'''

# CI Releasing Zellij
[tasks.ci-build-release]
workspace = false
dependencies = [
    "setup-cross-compilation",
    "build-plugins-release",
    "wasm-opt-plugins",
    "manpage",
]
command = "cross"
args = [
    "build",
    "--verbose",
    "--release",
    "--target",
    "${CARGO_MAKE_TASK_ARGS}",
]

# Build e2e asset
[tasks.build-e2e]
workspace = false
dependencies = ["build-plugins-release", "build-e2e-data-dir"]
command = "cargo"
args = [
    "build",
    "--verbose",
    "--release",
    "--target",
    "x86_64-unknown-linux-musl",
]

# Run e2e tests - we mark the e2e tests as "ignored" so they will not be run with the normal ones
[tasks.e2e-test]
workspace = false
dependencies = ["build-e2e"]
command = "cargo"
args = [
    "test",
    "--",
    "--ignored",
    "--nocapture",
    "--test-threads",
    "1",
    "@@split(CARGO_MAKE_TASK_ARGS,;)",
]

[tasks.setup-cross-compilation]
command = "cargo"
args = ["install", "cross"]

# Publishing Zellij
[tasks.publish]
clear = true
workspace = false
dependencies = [
    "update-default-config",
    "build-plugins-release",
    "wasm-opt-plugins",
    "release-commit",
]
run_task = "publish-zellij"

[tasks.release-commit]
dependencies = ["commit-all", "tag-release"]
command = "git"
args = ["push", "--atomic", "origin", "main", "v${CARGO_MAKE_CRATE_VERSION}"]

[tasks.commit-all]
ignore_errors = true
command = "git"
args = ["commit", "-aem", "chore(release): v${CARGO_MAKE_CRATE_VERSION}"]

[tasks.tag-release]
command = "git"
args = ["tag", "v${CARGO_MAKE_CRATE_VERSION}"]

[tasks.publish-zellij-tile]
ignore_errors = true
cwd = "zellij-tile"
script = "cargo publish && sleep 15"

[tasks.publish-zellij-client]
ignore_errors = true
dependencies = ["publish-zellij-utils"]
cwd = "zellij-client"
script = "cargo publish && sleep 15"

[tasks.publish-zellij-server]
ignore_errors = true
dependencies = ["publish-zellij-utils"]
cwd = "zellij-server"
script = "cargo publish && sleep 15"

[tasks.publish-zellij-utils]
ignore_errors = true
dependencies = ["publish-zellij-tile"]
cwd = "zellij-utils"
script = "cargo publish && sleep 15"

[tasks.publish-zellij-tile-utils]
ignore_errors = true
cwd = "zellij-tile-utils"
script = "cargo publish && sleep 15"

[tasks.publish-zellij]
dependencies = [
    "publish-zellij-client",
    "publish-zellij-server",
    "publish-zellij-utils",
]
command = "cargo"
args = ["publish"]