Makefile.stable.toml

[config]
init_task = "init"
end_task = "end"
skip_core_tasks = false
default_to_workspace = true
additional_profiles = []

[env]
RUST_BACKTRACE = "full"
CARGO_MAKE_KCOV_VERSION = "36"
CARGO_MAKE_KCOV_EXCLUDE_LINE = "kcov-ignore"
CARGO_MAKE_KCOV_EXCLUDE_REGION = "kcov-ignore-start:kcov-ignore-end"
CARGO_MAKE_KCOV_DOWNLOAD_DIRECTORY = "./target/kcov"
CARGO_MAKE_TEST_COVERAGE_DEFAULT_BINARY_FILTER = "${CARGO_MAKE_CRATE_FS_NAME}-[a-z0-9]*$\\|test_[_a-z0-9]*-[a-z0-9]*$\\|[a-z0-9]*_test-[_a-z0-9]*$"
CARGO_MAKE_TEST_COVERAGE_BINARY_FILTER = "${CARGO_MAKE_TEST_COVERAGE_DEFAULT_BINARY_FILTER}"
CARGO_MAKE_CARGO_ALL_FEATURES = "--all-features"
CARGO_MAKE_CARGO_PROFILE = { source = "${CARGO_MAKE_PROFILE}", mapping = {"development" = "dev", "ci" = "test" } }
CARGO_MAKE_CARGO_BUILD_TEST_FLAGS = "${CARGO_MAKE_CARGO_ALL_FEATURES}"
CARGO_MAKE_CARGO_PUBLISH_NO_ARGS = ""
CARGO_MAKE_CARGO_PUBLISH_ALLOW_DIRTY = "--allow-dirty"
CARGO_MAKE_CARGO_PUBLISH_FLAGS = "${CARGO_MAKE_CARGO_PUBLISH_NO_ARGS}"
CARGO_MAKE_CARGO_PUBLISH_DELETE_LOCK_FILE = false
CARGO_MAKE_CLIPPY_ALL_FEATURES_WARN = "${CARGO_MAKE_CARGO_ALL_FEATURES} -- -D warnings"
CARGO_MAKE_CLIPPY_NO_ARGS = ""
CARGO_MAKE_CLIPPY_ARGS = "${CARGO_MAKE_CLIPPY_NO_ARGS}"
CARGO_MAKE_RUST_SCRIPT_PROVIDER = "cargo-script"

[env.none-thread-safe-tests]
RUST_TEST_THREADS = "1"

[env.publish-allow-dirty]
CARGO_MAKE_CARGO_PUBLISH_FLAGS = "${CARGO_MAKE_CARGO_PUBLISH_ALLOW_DIRTY}"

[env.publish-pre-cleanup]
CARGO_MAKE_CARGO_PUBLISH_DELETE_LOCK_FILE = true

[env.ci-coverage-tasks]
CARGO_MAKE_RUN_CODECOV = true

[env.ci-static-code-analysis-tasks]
CARGO_MAKE_RUN_CHECK_FORMAT = true
CARGO_MAKE_RUN_CLIPPY = true

[env.ci-all-build-tasks]
CARGO_MAKE_BUILD_BENCH = true
CARGO_MAKE_BUILD_EXAMPLES = true
CARGO_MAKE_CHECK_OUTDATED = true

[tasks.empty]
description = "Empty Task"
category = "Tools"

[tasks.default]
description = "Default task points to the development testing flow"
category = "Development"
alias = "dev-test-flow"

[tasks.ci-flow]
description = "CI task will run cargo build and cargo test with verbose output"
category = "CI"
dependencies = [
    "pre-ci-flow",
    "pre-build",
    "conditioned-check-format",
    "conditioned-clippy",
    "build-verbose",
    "post-build",
    "pre-test",
    "test-verbose",
    "post-test",
    "examples-ci-flow",
    "bench-ci-flow",
    "outdated-ci-flow",
    "ci-coverage-flow",
    "post-ci-flow"
]

[tasks.workspace-ci-flow]
description = "CI task will run CI flow for each member and merge coverage reports"
category = "CI"
workspace = false
dependencies = [
    "pre-workspace-ci-flow",
    "workspace-members-ci",
    "workspace-coverage-pack",
    "post-workspace-ci-flow"
]

[tasks.dev-test-flow]
description = "Development testing flow will first format the code, and than run cargo build and test"
category = "Development"
dependencies = [
    "format-flow",
    "pre-build",
    "build",
    "post-build",
    "test-flow"
]

[tasks.dev-watch-flow]
description = "Alias for default flow"
category = "Development"
alias = "test-flow"

[tasks.watch-flow]
description = "Watches for any file change and if any change is detected, it will invoke the default flow."
category = "Development"
watch = true

[tasks.pre-publish-delete-lock]
description = "Deletes lock file before publishing"
category = "Publish"
condition = { env_true = [ "CARGO_MAKE_CARGO_PUBLISH_DELETE_LOCK_FILE" ] }
run_task = "delete-lock"

[tasks.pre-publish-clean-flow]
description = "Clears old artifactes before publishing"
category = "Publish"
dependencies = [
    "pre-clean",
    "clean",
    "post-clean"
]

[tasks.pre-publish-conditioned-clean-flow]
description = "Clears old artifactes before publishing"
category = "Publish"
condition = { env_not_set = [ "CARGO_MAKE_SKIP_PREPUBLISH_CLEAN" ] }
run_task = "pre-publish-clean-flow"

[tasks.publish-flow]
description = "Publish flow - First clean the target directory of any old leftovers, package and publish"
category = "Publish"
dependencies = [
    "pre-publish-conditioned-clean-flow",
    "pre-publish-delete-lock",
    "pre-publish",
    "publish",
    "post-publish"
]

[tasks.build-flow]
# This is the full sanity testing flow which includes:
# cleanup of old build
# generating docs and moving them to the docs folder
# running cargo build and test
# running cargo plugins such as security and dependency validations
description = "Full sanity testing flow."
category = "Build"
dependencies = [
    "init-build-flow",
    "pre-clean",
    "clean-apidocs",
    "clean",
    "post-clean",
    "format-flow",
    "pre-build",
    "build",
    "post-build",
    "test-flow",
    "examples-ci-flow",
    "bench-ci-flow",
    "pre-verify-project",
    "verify-project",
    "post-verify-project",
    "pre-audit",
    "audit",
    "post-audit",
    "outdated-flow",
    "pre-docs",
    "docs",
    "post-docs",
    "copy-apidocs",
    "end-build-flow"
]

[tasks.init]
description = "By default this task is invoked at the start of every cargo-make run."
category = "Hooks"

[tasks.end]
description = "By default this task is invoked at the end of every cargo-make run."
category = "Hooks"

[tasks.init-build-flow]
category = "Build"

[tasks.pre-clean]
category = "Cleanup"

[tasks.clean-apidocs]
description = "Delete API docs."
category = "Documentation"
command = "rm"
args = ["-Rf", "./docs/api"]

[tasks.clean]
description = "Runs the cargo clean command."
category = "Cleanup"
command = "cargo"
args = ["clean"]

[tasks.post-clean]
category = "Cleanup"

[tasks.delete-lock]
description = "Deletes the Cargo.lock file."
category = "Cleanup"
script_runner = "@shell"
script = [
    "rm -f ./Cargo.lock"
]

[tasks.upgrade-dependencies]
description = "Rebuilds the crate with most updated dependencies."
category = "Development"
dependencies = [
    "delete-lock",
    "dev-test-flow"
]

[tasks.pre-format]
category = "Development"

[tasks.format]
description = "Runs the cargo rustfmt plugin."
category = "Development"
install_crate = { crate_name = "rustfmt-nightly", rustup_component_name = "rustfmt", binary = "rustfmt", test_arg = "--help" }
command = "cargo"
args = ["fmt"]

[tasks.check-format]
description = "Runs cargo fmt to check appropriate code format."
category = "Test"
install_crate = { crate_name = "rustfmt-nightly", rustup_component_name = "rustfmt", binary = "rustfmt", test_arg = "--help" }
command = "cargo"
args = ["fmt", "--", "--check"]

[tasks.conditioned-check-format]
description = "Runs cargo fmt --check if conditions are met."
category = "Test"
condition = { env_set = [ "CARGO_MAKE_RUN_CHECK_FORMAT" ] }
run_task = "check-format"

[tasks.post-format]
category = "Development"

[tasks.format-flow]
description = "Runs the cargo rustfmt plugin as part of a flow."
category = "Development"
dependencies = [
    "pre-format",
    "format",
    "post-format"
]

[tasks.pre-docs]
category = "Documentation"

[tasks.docs]
description = "Generate rust documentation."
category = "Documentation"
command = "cargo"
args = ["doc", "--no-deps"]

[tasks.post-docs]
category = "Documentation"

[tasks.pre-build]
category = "Build"

[tasks.build]
description = "Runs the rust compiler."
category = "Build"
command = "cargo"
args = ["build", "@@split(CARGO_MAKE_CARGO_BUILD_TEST_FLAGS, )"]

[tasks.build-verbose]
description = "Runs the rust compiler with verbose output."
category = "Build"
command = "cargo"
args = ["build", "--verbose", "@@split(CARGO_MAKE_CARGO_BUILD_TEST_FLAGS, )"]

[tasks.build-release]
description = "Runs release build."
category = "Build"
command = "cargo"
args = ["build", "--release", "@@split(CARGO_MAKE_CARGO_BUILD_TEST_FLAGS, )"]

[tasks.post-build]
category = "Build"

[tasks.pre-test]
category = "Test"

[tasks.test]
description = "Runs all available tests."
category = "Test"
command = "cargo"
args = ["test", "@@split(CARGO_MAKE_CARGO_BUILD_TEST_FLAGS, )"]

[tasks.test-flow]
description = "Runs pre/post hooks and cargo test."
category = "Test"
dependencies = [
    "pre-test",
    "test",
    "post-test"
]

[tasks.test-verbose]
description = "Runs all available tests with verbose output."
category = "Test"
command = "cargo"
args = ["test", "--verbose", "@@split(CARGO_MAKE_CARGO_BUILD_TEST_FLAGS, )"]

[tasks.test-with-args]
description = "Runs cargo test with command line arguments."
category = "Test"
command = "cargo"
args = ["test", "${@}"]

[tasks.post-test]
category = "Test"

[tasks.pre-bench]
category = "Test"

[tasks.bench]
description = "Runs all available bench files."
category = "Test"
command = "cargo"
args = ["bench", "@@split(CARGO_MAKE_CARGO_BUILD_TEST_FLAGS, )"]

[tasks.post-bench]
category = "Test"

[tasks.bench-flow]
description = "Runs a bench flow."
category = "Test"
dependencies = [
    "pre-bench",
    "bench",
    "post-bench"
]

[tasks.bench-conditioned-flow]
description = "Runs the bench flow if conditions are met."
category = "Test"
condition = { env_set = [ "CARGO_MAKE_RUN_BENCH" ], channels = [ "nightly" ] }
run_task = "bench-flow"

[tasks.bench-compile]
description = "Compiles all available bench files."
category = "Test"
command = "cargo"
args = ["build", "--benches", "@@split(CARGO_MAKE_CARGO_BUILD_TEST_FLAGS, )"]

[tasks.bench-conditioned-compile]
description = "Compiles all available bench files if conditions are met."
category = "Test"
condition = { env_set = [ "CARGO_MAKE_BUILD_BENCH" ], channels = [ "nightly" ] }
run_task = "bench-compile"

[tasks.bench-ci-flow]
description = "Runs/Compiles the benches if conditions are met."
category = "CI"
dependencies = [
    "bench-conditioned-compile",
    "bench-conditioned-flow"
]

[tasks.pre-check]
category = "Test"

[tasks.check]
description = "Runs cargo check."
category = "Test"
command = "cargo"
args = ["check"]

[tasks.post-check]
category = "Test"

[tasks.check-flow]
description = "Runs cargo check flow."
category = "Test"
dependencies = [
    "pre-check",
    "check",
    "post-check"
]

[tasks.check-tests]
description = "Runs cargo check for project tests."
category = "Test"
command = "cargo"
args = ["check", "--tests"]

[tasks.check-examples]
description = "Runs cargo check for project examples."
category = "Test"
command = "cargo"
args = ["check", "--examples"]

[tasks.examples-compile]
description = "Runs cargo build for project examples."
category = "Test"
command = "cargo"
args = ["build", "--examples"]

[tasks.examples-conditioned-compile]
description = "Runs cargo build for project examples if conditions are met."
category = "Test"
condition = { env_set = [ "CARGO_MAKE_BUILD_EXAMPLES" ] }
run_task = "examples-compile"

[tasks.examples-ci-flow]
description = "Compiles the examples if conditions are met."
category = "CI"
dependencies = [
    "examples-conditioned-compile"
]

[tasks.pre-verify-project]
category = "CI"

[tasks.verify-project]
description = "Runs verify-project cargo plugin."
category = "CI"
command = "cargo"
args = ["verify-project"]

[tasks.post-verify-project]
category = "CI"

[tasks.pre-audit]
category = "CI"

[tasks.audit]
description = "Runs audit cargo plugin."
category = "CI"
condition = { env_true = [ "CARGO_MAKE_CRATE_HAS_DEPENDENCIES", "CARGO_MAKE_CRATE_LOCK_FILE_EXISTS" ] }
command = "cargo"
args = ["audit"]

[tasks.post-audit]
category = "CI"

[tasks.pre-outdated]
category = "CI"

[tasks.outdated]
description = "Runs cargo-outdated cargo plugin."
category = "CI"
condition = { env_true = [ "CARGO_MAKE_CRATE_HAS_DEPENDENCIES" ] }
command = "cargo"
args = ["outdated", "--root-deps-only", "--exit-code", "1"]

[tasks.post-outdated]
category = "CI"

[tasks.outdated-flow]
description = "Runs outdated cargo flow."
category = "CI"
dependencies = [
    "pre-outdated",
    "outdated",
    "post-outdated"
]

[tasks.outdated-ci-flow]
description = "Runs outdated cargo conditioned CI flow."
category = "CI"
condition = { env_set = [ "CARGO_MAKE_CHECK_OUTDATED" ], env_true = [ "CARGO_MAKE_CRATE_HAS_DEPENDENCIES" ], env_false = [ "CARGO_MAKE_PR" ], channels = [ "nightly" ], platforms = [ "linux" ] }
run_task = "outdated-flow"

[tasks.unused-dependencies-flow]
description = "Checks for unused dependencies."
category = "CI"
condition = { env_true = [ "CARGO_MAKE_CRATE_HAS_DEPENDENCIES" ] }
dependencies = [
    "pre-unused-dependencies",
    "unused-dependencies",
    "post-unused-dependencies"
]

[tasks.pre-unused-dependencies]
category = "CI"

[tasks.unused-dependencies]
description = "Checks for unused dependencies."
category = "CI"
condition = { channels = ["nightly"], env_true = [ "CARGO_MAKE_CRATE_HAS_DEPENDENCIES" ] }
command = "cargo"
args = ["udeps"]

[tasks.post-unused-dependencies]
category = "CI"

[tasks.install-clippy-any]
description = "Installs the latest clippy code linter via cargo install via rustup or directly from github."
category = "Test"
install_crate = { crate_name = "clippy", rustup_component_name = "clippy", binary = "cargo-clippy", test_arg = "--help" }
install_crate_args = ["--git", "https://github.com/rust-lang/rust-clippy/", "clippy"]
args = [ "clippy", "--help" ]

[tasks.install-clippy-rustup]
description = "Installs the clippy code linter via rustup."
category = "Test"
install_crate = { rustup_component_name = "clippy", binary = "cargo-clippy", test_arg = "--help" }

[tasks.install-clippy]
description = "Installs the clippy code linter."
category = "Test"
run_task = [
    { name = "install-clippy-any", condition = { channels = ["nightly"] } },
    { name = "install-clippy-rustup" }
]

[tasks.clippy]
description = "Runs clippy code linter."
category = "Test"
dependencies = [
    "install-clippy"
]
command = "cargo"
args = ["clippy", "@@split(CARGO_MAKE_CLIPPY_ARGS, )"]

[tasks.conditioned-clippy]
description = "Runs clippy code linter if conditions are met."
category = "Test"
condition = { env_set = [ "CARGO_MAKE_RUN_CLIPPY" ] }
run_task = "clippy"

[tasks.copy-apidocs]
description = "Copies the generated documentation to the docs/api directory."
category = "Documentation"
script_runner = "@shell"
script = [
    "mkdir -p ./docs/api",
    "mv ./target/doc/* ./docs/api"
]

[tasks.end-build-flow]
category = "Build"

[tasks.pre-package]
category = "Publish"

[tasks.package]
description = "Runs the cargo package command."
category = "Publish"
command = "cargo"
args = ["package"]

[tasks.post-package]
category = "Publish"

[tasks.pre-publish]
category = "Publish"

[tasks.publish]
description = "Runs the cargo publish command."
category = "Publish"
command = "cargo"
args = ["publish", "@@split(CARGO_MAKE_CARGO_PUBLISH_FLAGS, )"]

[tasks.post-publish]
category = "Publish"

[tasks.pre-git-add]
category = "Git"

[tasks.git-add]
description = "Runs the cargo add command."
category = "Git"
command = "git"
args = ["add", "."]

[tasks.post-git-add]
category = "Git"

[tasks.pre-git-status]
category = "Git"

[tasks.git-status]
description = "Runs git status command."
category = "Git"
command = "git"
args = ["status"]

[tasks.post-git-status]
category = "Git"

[tasks.pre-git-commit]
category = "Git"

[tasks.git-commit]
description = "Runs git commit command."
category = "Git"
command = "git"
args = ["commit"]

[tasks.git-commit-message]
description = "Runs git commit command with the message defined in the COMMIT_MSG environment variable."
category = "Git"
script_runner = "@shell"
script = [
    "git commit -m \"${COMMIT_MSG}\""
]

[tasks.post-git-commit]
category = "Git"

[tasks.pre-git-push]
category = "Git"

[tasks.git-push]
description = "Runs git push command."
category = "Git"
command = "git"
args = ["push"]

[tasks.post-git-push]
category = "Git"

[tasks.git-pull]
description = "Runs git pull command."
category = "Git"
command = "git"
args = ["pull"]

[tasks.git-delete-merged-branches]
description = "Deletes any merged git branches"
category = "Git"
ignore_errors = true
script = [
'''
git branch --merged | egrep -v "(^\*|master|dev)" | xargs git branch -d
'''
]

[tasks.pre-ci-flow]
category = "CI"

[tasks.post-ci-flow]
category = "CI"

[tasks.do-on-members]
description = "Runs the requested task for every workspace member."
category = "Tools"
condition = { env_set = [ "CARGO_MAKE_MEMBER_TASK" ] }
script_runner = "@shell"
script = [
'''
#prevent codecov publish in member builds
export CARGO_MAKE_SKIP_CODECOV="true"

export CARGO_MAKE_WORKSPACE_TARGET_DIRECTORY="${CARGO_MAKE_WORKING_DIRECTORY}/target"

#output coverage data goes into workspace level
export CARGO_MAKE_COVERAGE_REPORT_DIRECTORY="${CARGO_MAKE_WORKSPACE_TARGET_DIRECTORY}/coverage"

cargo make --loglevel=${CARGO_MAKE_LOG_LEVEL} --profile="${CARGO_MAKE_PROFILE}" ${CARGO_MAKE_MEMBER_TASK}

unset CARGO_MAKE_COVERAGE_REPORT_DIRECTORY
unset CARGO_MAKE_WORKSPACE_TARGET_DIRECTORY
unset CARGO_MAKE_SKIP_CODECOV
'''
]

[tasks.do-on-members.windows]
clear = true
script = [
'''
cargo make --loglevel=%CARGO_MAKE_LOG_LEVEL% --profile="%CARGO_MAKE_PROFILE%" %CARGO_MAKE_MEMBER_TASK%
if %errorlevel% neq 0 exit /b %errorlevel%
'''
]

[tasks.pre-workspace-ci-flow]
category = "CI"

[tasks.post-workspace-ci-flow]
category = "CI"

[tasks.workspace-members-ci]
description = "Runs the ci-flow for every workspace member."
category = "CI"
env = { "CARGO_MAKE_MEMBER_TASK" = "${CARGO_MAKE_CORE_TASK_NAMESPACE_PREFIX}ci-flow" }
run_task = "do-on-members"

[tasks.workspace-members-coverage]
description = "Runs the ci-flow for every workspace member."
category = "Test"
env = { "CARGO_MAKE_MEMBER_TASK" = "${CARGO_MAKE_CORE_TASK_NAMESPACE_PREFIX}coverage" }
run_task = "do-on-members"

[tasks.workspace-coverage]
description = "Runs coverage task for all members and packages all of them (by default the codecov flow)."
category = "Test"
dependencies = [
    "workspace-members-coverage",
    "workspace-coverage-pack"
]

[tasks.workspace-coverage-pack]
description = "Publishes all member coverage reports."
category = "Test"
linux_alias = "codecov"

[tasks.pre-coverage]
category = "Test"

[tasks.coverage]
description = "Runs coverage (by default using kcov)."
category = "Test"
env = { "RUSTFLAGS" = "-C link-dead-code" }
run_task = [
    { name = "coverage-tarpaulin", condition = { platforms = ["linux"], env = { "CARGO_MAKE_COVERAGE_PROVIDER" = "tarpaulin" } } },
    { name = "coverage-kcov", condition = { platforms = ["linux"] } },
]

[tasks.coverage-kcov]
description = "Installs (if missing) and runs coverage using kcov (not supported on windows)"
category = "Test"
windows_alias = "empty"
condition = { env_set = [ "CARGO_MAKE_KCOV_VERSION" ] }
script_runner = "bash"
env = { "CARGO_MAKE_KCOV_INCLUDE_PATTERN" = "${CARGO_MAKE_WORKING_DIRECTORY}/src/" }
install_script = [
'''
KCOV_INSTALLATION_DIRECTORY=""
KCOV_BINARY_DIRECTORY=""
if [ -n "${CARGO_MAKE_KCOV_INSTALLATION_DIRECTORY}" ]; then
    mkdir -p ${CARGO_MAKE_KCOV_INSTALLATION_DIRECTORY}
    cd ${CARGO_MAKE_KCOV_INSTALLATION_DIRECTORY}
    KCOV_INSTALLATION_DIRECTORY="$(pwd)/"
    cd -
    echo "Kcov Installation Directory: ${KCOV_INSTALLATION_DIRECTORY}"
    KCOV_BINARY_DIRECTORY="${KCOV_INSTALLATION_DIRECTORY}/build/src/"
    echo "Kcov Binary Directory: ${KCOV_BINARY_DIRECTORY}"
fi

# get help info to fetch all supported command line arguments
KCOV_HELP_INFO=`${KCOV_BINARY_DIRECTORY}kcov --help` || true

# check needed arguments are supported, else install
if [[ $KCOV_HELP_INFO != *"--include-pattern"* ]] || [[ $KCOV_HELP_INFO != *"--exclude-line"* ]] || [[ $KCOV_HELP_INFO != *"--exclude-region"* ]]; then
    # check we are on a supported platform
    if [ "$(grep -Ei 'debian|buntu|mint' /etc/*release)" ]; then
        echo "Installing/Upgrading kcov..."
        sudo apt-get update || true
        sudo apt-get install -y libcurl4-openssl-dev libelf-dev libdw-dev cmake gcc binutils-dev

        mkdir -p ${CARGO_MAKE_KCOV_DOWNLOAD_DIRECTORY}
        cd ${CARGO_MAKE_KCOV_DOWNLOAD_DIRECTORY}
        KCOV_DOWNLOAD_DIRECTORY=$(pwd)

        wget https://github.com/SimonKagstrom/kcov/archive/v${CARGO_MAKE_KCOV_VERSION}.zip
        unzip v${CARGO_MAKE_KCOV_VERSION}.zip
        cd kcov-${CARGO_MAKE_KCOV_VERSION}
        mkdir -p build
        cd ./build
        cmake ..
        make

        # if custom installation directory, leave kcov as local
        if [ -n "${CARGO_MAKE_KCOV_INSTALLATION_DIRECTORY}" ]; then
            cd ${KCOV_DOWNLOAD_DIRECTORY}/kcov-${CARGO_MAKE_KCOV_VERSION}
            mv ./* ${KCOV_INSTALLATION_DIRECTORY}
        else
            sudo make install
            cd ../..
            rm -rf kcov-${CARGO_MAKE_KCOV_VERSION}
        fi
    fi
fi
'''
]
script = [
'''
echo "Working Directory: ${CARGO_MAKE_WORKING_DIRECTORY}"

KCOV_BINARY_DIRECTORY=""
if [ -n "${CARGO_MAKE_KCOV_INSTALLATION_DIRECTORY}" ]; then
    cd ${CARGO_MAKE_KCOV_INSTALLATION_DIRECTORY}
    KCOV_INSTALLATION_DIRECTORY="$(pwd)/"
    cd -
    echo "Kcov Installation Directory: ${KCOV_INSTALLATION_DIRECTORY}"
    KCOV_BINARY_DIRECTORY="${KCOV_INSTALLATION_DIRECTORY}/build/src/"
    echo "Kcov Binary Directory: ${KCOV_BINARY_DIRECTORY}"
fi

TARGET_DIRECTORY="target/coverage"
if [ -n "$CARGO_MAKE_COVERAGE_REPORT_DIRECTORY" ]; then
    TARGET_DIRECTORY="$CARGO_MAKE_COVERAGE_REPORT_DIRECTORY"
    mkdir -p ${TARGET_DIRECTORY}
else
    mkdir -p ./target/coverage
fi

BINARY_DIRECTORY=target/debug
if [ -n "$CARGO_MAKE_WORKSPACE_TARGET_DIRECTORY" ]; then
    BINARY_DIRECTORY="${CARGO_MAKE_WORKSPACE_TARGET_DIRECTORY}/debug"
fi

KCOV_EXCLUDE_LINE_ARG=""
if [ -n "$CARGO_MAKE_KCOV_EXCLUDE_LINE" ]; then
    KCOV_EXCLUDE_LINE_ARG="--exclude-line=${CARGO_MAKE_KCOV_EXCLUDE_LINE}"
fi

KCOV_EXCLUDE_REGION_ARG=""
if [ -n "$CARGO_MAKE_KCOV_EXCLUDE_REGION" ]; then
    KCOV_EXCLUDE_REGION_ARG="--exclude-region=${CARGO_MAKE_KCOV_EXCLUDE_REGION}"
fi

echo "Running tests from directory: ${BINARY_DIRECTORY}"

# Evaluate variables that may be in the expression
# This allows us to do double expansion on a non-variable second expansion
CARGO_MAKE_TEST_COVERAGE_BINARY_FILTER_REGEX="$(sh -c "echo \"${CARGO_MAKE_TEST_COVERAGE_BINARY_FILTER}\"")"
echo "Test binary filter regex: ${CARGO_MAKE_TEST_COVERAGE_BINARY_FILTER_REGEX}"

for file in $(find "${BINARY_DIRECTORY}" -maxdepth 1 -type f | grep -e "${CARGO_MAKE_TEST_COVERAGE_BINARY_FILTER_REGEX}")
do
    echo "Running coverage for file: $file"
    ${KCOV_BINARY_DIRECTORY}kcov --include-pattern=${CARGO_MAKE_KCOV_INCLUDE_PATTERN} ${KCOV_EXCLUDE_LINE_ARG} ${KCOV_EXCLUDE_REGION_ARG} "$TARGET_DIRECTORY" "$file" || true
done
'''
]

[tasks.coverage-tarpaulin]
description = "Runs coverage using tarpaulin rust crate (linux only)"
category = "Test"

[tasks.coverage-tarpaulin.linux]
command = "cargo"
args = ["tarpaulin", "--out", "Xml"]

[tasks.post-coverage]
category = "Test"

[tasks.coverage-flow]
description = "Runs the full coverage flow."
category = "Test"
dependencies = [
    "pre-coverage",
    "coverage",
    "post-coverage"
]

[tasks.codecov]
description = "Runs codecov script to upload coverage results to codecov."
category = "Test"
windows_alias = "empty"
script_runner = "bash"
condition = { env_not_set = [ "CARGO_MAKE_SKIP_CODECOV" ] }
script = [
    "#!/usr/bin/env bash",
    "bash <(curl -s https://codecov.io/bash)"
]

[tasks.codecov-flow]
description = "Runs the full coverage flow and uploads the results to codecov."
category = "Test"
windows_alias = "empty"
dependencies = [
    "coverage-flow",
    "codecov"
]

[tasks.ci-coverage-flow]
description = "Runs the coverage flow and uploads the results to codecov."
category = "CI"
condition = { platforms = ["linux"], env_true = [ "CARGO_MAKE_CI", "CARGO_MAKE_RUN_CODECOV" ] }
run_task = "codecov-flow"

[tasks.upload-artifacts]
description = "Uploads the binary artifact from the cargo package/publish output."
category = "Publish"
alias = "bintray-upload"

[tasks.bintray-upload]
description = "Uploads the binary artifact from the cargo package/publish output to bintray."
category = "Publish"

[tasks.bintray-upload.linux]
condition = { env_set = [ "BINTRAY_API_KEY", "BINTRAY_OWNER_NAME", "BINTRAY_PACKAGE_NAME" ] }
script = [
    "curl -T \"./target/package/${CARGO_MAKE_CRATE_NAME}-${CARGO_MAKE_CRATE_VERSION}/target/debug/${CARGO_MAKE_CRATE_NAME}\" -u${BINTRAY_OWNER_NAME}:${BINTRAY_API_KEY} -H \"X-Bintray-Package:${BINTRAY_PACKAGE_NAME}\" -H \"X-Bintray-Version:v${CARGO_MAKE_CRATE_VERSION}\" https://api.bintray.com/content/${BINTRAY_OWNER_NAME}/${CARGO_MAKE_CRATE_NAME}/${CARGO_MAKE_CRATE_NAME}_v${CARGO_MAKE_CRATE_VERSION}?override=1",
    "curl -X POST -u${BINTRAY_OWNER_NAME}:${BINTRAY_API_KEY} https://api.bintray.com/content/${BINTRAY_OWNER_NAME}/${CARGO_MAKE_CRATE_NAME}/${BINTRAY_PACKAGE_NAME}/v${CARGO_MAKE_CRATE_VERSION}/publish"
]

[tasks.github-publish]
# Creates a new github release.
# Set the GITHUB_API_TOKEN environment variables to automatically authenticate.
description = "Creates a new github release."
category = "Publish"
command = "cargo"
args = ["hublish"]

[tasks.github-publish-custom-name]
# Creates a new github release.
# Set the GITHUB_API_TOKEN environment variables to automatically authenticate.
description = "Creates a new github release."
category = "Publish"
run_task = [
    { name = "github-publish-curl", condition = { platforms = ["linux", "mac"], env_set = [ "GITHUB_API_TOKEN", "GITHUB_REPO_NAME" ] } },
    { name = "github-publish-hublish", condition = { env_set = [ "GITHUB_REPO_NAME" ] } },
]

[tasks.github-publish-hublish]
# Creates a new github release.
# Set the GITHUB_API_TOKEN environment variables to automatically authenticate.
description = "Creates a new github release using cargo-hublish."
category = "Publish"
condition = { env_set = [ "GITHUB_REPO_NAME" ] }
install_crate = "cargo-hublish"
args = ["hublish"]
script_runner = "@shell"
script = [
    "cargo hublish --url \"https://api.github.com/repos/${GITHUB_REPO_NAME}/releases\""
]

[tasks.github-publish-curl]
# Creates a new github release.
description = "Creates a new github release using curl."
category = "Publish"
condition = { platforms = ["linux", "mac"], env_set = [ "GITHUB_API_TOKEN", "GITHUB_REPO_NAME" ] }
script = [
'''
    API_JSON=$(printf '{"tag_name": "%s","target_commitish": "master","name": "%s v%s","body": "release","draft": false,"prerelease": false}' ${CARGO_MAKE_CRATE_VERSION} ${CARGO_MAKE_CRATE_NAME} ${CARGO_MAKE_CRATE_VERSION})
    curl --data "$API_JSON" https://api.github.com/repos/${GITHUB_REPO_NAME}/releases?access_token=${GITHUB_API_TOKEN}
'''
]

[tasks.build-publish-flow]
description = "Runs full sanity, generates github release and publishes the crate."
category = "Publish"
condition = { env_set = [ "COMMIT_MSG", "GITHUB_API_TOKEN", "GITHUB_REPO_NAME" ] }
env = { "CARGO_MAKE_SKIP_PREPUBLISH_CLEAN" = true }
run_task = "build-publish-flow-no-validation"

[tasks.build-publish-flow-no-validation]
private = true
dependencies = [
    "delete-lock",
    "build-flow",
    "git-add",
    "git-status",
    "git-commit-message",
    "git-push",
    "git-delete-merged-branches",
    "github-publish-custom-name",
    "publish-flow",
    "upload-artifacts",
    "git-pull"
]

[tasks.diff-files]
description = "Run diff on two provided files."
category = "Tools"
alias = "git-diff-files"

[tasks.git-diff-files]
description = "Run diff on two provided files."
category = "Tools"
ignore_errors = true
condition = { env_set = [ "CARGO_MAKE_DIFF_FILE1", "CARGO_MAKE_DIFF_FILE2" ] }
command = "git"
args = [
    "diff",
    "--no-index",
    "${CARGO_MAKE_DIFF_FILE1}",
    "${CARGO_MAKE_DIFF_FILE2}"
]

[tasks.install-rust-src]
category = "Tools"
install_crate = { rustup_component_name = "rust-src" }

[tasks.install-rls]
category = "Tools"
install_crate = { rustup_component_name = "rls-preview", binary = "rls", test_arg = "--help" }