wb-cache 0.1.0

[env]
    __MAKE_CHANGELOG__ = { value = "${CARGO_MAKE_WORKSPACE_WORKING_DIRECTORY}/CHANGELOG.md", condition = { env_not_set = [
        "__MAKE_CHANGELOG__",
    ] } }
    __MAKE_DEFAULT_TOOLCHAIN__ = { value = "nightly", condition = { env_not_set = ["__MAKE_DEFAULT_TOOLCHAIN__"] } }
    # Template file for the readme.
    __MAKE_README_TPL__ = { value = "${CARGO_MAKE_WORKSPACE_WORKING_DIRECTORY}/build-tools/README.tpl", condition = { env_not_set = [
        "__MAKE_README_TPL__",
    ] } }
    __MAKE_README__ = { value = "${CARGO_MAKE_WORKSPACE_WORKING_DIRECTORY}/README.md", condition = { env_not_set = [
        "__MAKE_README__",
    ] } }
    # If this file is found then use it to generate CHANGELOG.md "Release Notes" section.
    __MAKE_RELEASE_NOTES__ = { value = ".release-notes.md", condition = { env_not_set = ["__MAKE_RELEASE_NOTES__"] } }
    # Features that are to be used with all tests.
    __MAKE_TEST_FIXED_FEATURES__ = { value = "", condition = { env_not_set = ["__MAKE_TEST_FIXED_FEATURES__"] } }
    # List of test tasks to be run by default.
    __MAKE_TEST_TASKS__ = { value = "test-default", condition = { env_not_set = ["__MAKE_TEST_TASKS__"] } }
    # Task that must run tests for different Rust versions.
    __MAKE_TEST_VERSION_TASK__ = { value = "test", condition = { env_not_set = ["__MAKE_TEST_VERSION_TASK__"] } }
    # File where the last commit that was tested for release is stored.
    __PREV_RELEASE_TESTING__ = { value = "${CARGO_MAKE_WORKSPACE_WORKING_DIRECTORY}/.release-tested", condition = { env_not_set = [
        "__PREV_RELEASE_TESTING__",
    ] } }
    __RELEASE_TOML__ = { value = "${CARGO_MAKE_WORKSPACE_WORKING_DIRECTORY}/build-tools/release.toml", condition = { env_not_set = [
        "__RELEASE_TOML__",
    ] } }

[tasks.test]
    category = "Test"
    clear = true
    cwd = "${CARGO_MAKE_WORKSPACE_WORKING_DIRECTORY}"
    description = "Extensive testing"
    script = '''
test_tasks = array %{__MAKE_TEST_TASKS__}

for task in ${test_tasks}
    cm_run_task ${task}
end
'''
    script_runner = "@duckscript"

[tasks.test-versions]
    condition = { env_set = ["__MAKE_TEST_VERSION_TASK__"] }
    cwd = "${CARGO_MAKE_WORKSPACE_WORKING_DIRECTORY}"
    description = "Testing supported Rust versions"
    script = '''
!include_files build-tools/makefile.ds
require_vars "__MAKE_TOOLCHAINS__ __MAKE_TEST_VERSION_TASK__"

set_env RUSTFLAGS "-D warnings"

toolchain_list = array %{__MAKE_TOOLCHAINS__}

for toolchain in ${toolchain_list}
    echo "Testing toolchain '${toolchain}'"
    set_env __MAKE_DEFAULT_TOOLCHAIN__ ${toolchain}
    rm Cargo.lock
    cm_run_task ${__MAKE_TEST_VERSION_TASK__}
end

# When successfully done then record the last commit
commit = exec git describe HEAD
writefile ${__PREV_RELEASE_TESTING__} ${commit.stdout}
'''
    script_runner = "@duckscript"

[tasks.test-default]
    args        = ["test", "--workspace", "--features", "${__MAKE_TEST_FIXED_FEATURES__}"]
    category    = "Test"
    command     = "cargo"
    description = "Test with only the default features"
    toolchain   = "${__MAKE_DEFAULT_TOOLCHAIN__}"

[tasks.test-combinations]
    category = "Test"
    condition = { env_set = ["__MAKE_TEST_FEATURES__"] }
    description = "Test all possible combinations of features"
    script = '''
!include_files build-tools/makefile.ds

features = array %{__MAKE_TEST_FEATURES__}
feature_sets = generate_power_set ${features}

for fs in ${feature_sets}
    fs = array_join ${fs} ","
    echo "Testing feature set '${fs}'"
    set_env __MAKE_FEATURE_SET__ ${fs}
    cm_run_task test-features
end
'''
    script_runner = "@duckscript"
    toolchain = "${__MAKE_DEFAULT_TOOLCHAIN__}"

[tasks.test-features]
    args        = ["test", "--features", "${__MAKE_FEATURE_SET__}", "--features", "${__MAKE_TEST_FIXED_FEATURES__}"]
    category    = "Test"
    command     = "cargo"
    description = "Test with '${__MAKE_FEATURE_SET__}' features"
    toolchain   = "${__MAKE_DEFAULT_TOOLCHAIN__}"

[tasks.test-docs-rs]
    script = '''
if is_empty "${__MAKE_DOCS_RS_PACKAGES__}"
    cm_run_task test-docs-rs-package
else
    packages = array %{__MAKE_DOCS_RS_PACKAGES__}
    for package in ${packages}
        echo "Testing package '${package}' for docs.rs"
        set_env __MAKE_DOCS_RS_ARGS__ "-p${package}"
        cm_run_task test-docs-rs-package
    end
end
'''
    script_runner = "@duckscript"

[tasks.test-docs-rs-package]
    args      = ["docs-rs", "@@split(__MAKE_DOCS_RS_ARGS__, )"]
    category  = "Test"
    command   = "cargo"
    env       = { RUSTDOCFLAGS = "-Dwarnings" }
    toolchain = "nightly"

[tasks.depends]
    description = "Install necessary dependencies and tools"
    script = '''
echo "Installing dependencies"
exec cargo install cargo-readme
exec cargo install git-cliff
exec cargo install cargo-get
'''
    script_runner = "@duckscript"

[tasks.docs]
    args        = ["doc", "--workspace", "--all-features", "--no-deps"]
    command     = "cargo"
    description = "Generate documentation"

[tasks.readme]
    clear = true
    cwd = "${CARGO_MAKE_WORKSPACE_WORKING_DIRECTORY}"
    description = "Build documentation"
    script = '''
!include_files build-tools/makefile.ds
require_vars "__MAKE_README__ __MAKE_README_TPL__ __MAKE_README_CRATE_ROOT__"

readme_content = exec --fail-on-error cargo readme -r ${__MAKE_README_CRATE_ROOT__} --template ${__MAKE_README_TPL__}
writefile ${__MAKE_README__} ${readme_content.stdout}
'''
    script_runner = "@duckscript"

[tasks.changelog]
    clear = true
    cwd = "${CARGO_MAKE_WORKSPACE_WORKING_DIRECTORY}"
    description = "Produce CHANGELOG.md"
    script = """
!include_files build-tools/makefile.ds
require_vars "__MAKE_CHANGELOG__ __MAKE_README_CRATE_ROOT__"

version_out = exec --fail-on-error cargo get package.version --entry ${__MAKE_README_CRATE_ROOT__} --pretty
version = trim ${version_out.stdout}
if is_empty ${version}
    stderr = set ""
    if not is_empty ${version_out.stderr}
        stderr = set "\\n${version_out.stderr}"
    end
    assert_error "Can't find out ${__MAKE_README_CRATE_ROOT__} version.${stderr}"
end

if is_path_exists ${__MAKE_RELEASE_NOTES__}
    release_notes = readfile ${__MAKE_RELEASE_NOTES__}
    exec --fail-on-error git cliff -o ${__MAKE_CHANGELOG__} --tag ${version} --with-tag-message "${release_notes}"
else
    exec --fail-on-error git cliff -o ${__MAKE_CHANGELOG__} --tag ${version}
end
"""
    script_runner = "@duckscript"

[tasks.is-clean]
    category = "Check"
    cwd = "${CARGO_MAKE_WORKSPACE_WORKING_DIRECTORY}"
    description = "Repository is clean"
    script = '''
is_clean = exec git diff-index --exit-code --stat HEAD

if not eq ${is_clean.code} 0
    print -bgc red -c yellow "!!!"
    println -c bright_red " Repository is not clean."
    echo ${is_clean.stdout}
    exit 1
end
'''
    script_runner = "@duckscript"

[tasks.release-testing]
    clear = true
    condition = { fail_message = "No release testing is needed, has been done for this commit already" }
    condition_script = ['''
if is_path_exists ${__PREV_RELEASE_TESTING__}
    prev = readfile ${__PREV_RELEASE_TESTING__}
    prev = trim ${prev}
    out = exec git describe HEAD
    now = trim ${out.stdout}
    if eq ${prev} ${now}
        exit 1
    end
end
''']
    cwd = "${CARGO_MAKE_WORKSPACE_WORKING_DIRECTORY}"
    run_task = "test-versions"
    script_runner = "@duckscript"

[tasks.version-patch-bump]
    clear = true
    cwd = "${CARGO_MAKE_WORKSPACE_WORKING_DIRECTORY}"
    description = "Bump release version"
    script = '''
!include_files build-tools/makefile.ds

reply = ask_user "Do you want to bump release version patch?"
reply = lowercase ${reply}

if eq ${reply} "y"
    exec --fail-on-error cargo release version patch --config ${__RELEASE_TOML__}
    reply = ask_user "Does this look good for you?"
    reply = lowercase ${reply}
    if eq ${reply} "y"
        echo "Bumping the patch."
        exec --fail-on-error cargo release version patch --config ${__RELEASE_TOML__} --execute --no-confirm
        exec --fail-on-error git add Cargo.toml */Cargo.toml
        exec --fail-on-error git commit -m "minor: version bump"
    end
end
'''
    script_runner = "@duckscript"

[tasks.post-docs]
    cwd = "${CARGO_MAKE_WORKSPACE_WORKING_DIRECTORY}"
    description = "Post-doc commit"
    script = '''
exec --fail-on-error git add README.md CHANGELOG.md
diffed = exec git diff-index --exit-code --cached HEAD
if not eq ${diffed.code} 0
    echo "Docs need committing."
    exec --fail-on-error git commit -m "minor: Pre-release docs update"
    exec --fail-on-error git push
end
'''
    script_runner = "@duckscript"

[tasks.beta]
    args        = ["release", "version", "beta", "--config", "${__RELEASE_TOML__}", "--execute"]
    command     = "cargo"
    description = "Produce beta version"

[tasks.pre-release]
    clear        = true
    dependencies = ["is-clean", "release-testing", "version-patch-bump", "readme", "changelog", "post-docs"]
    description  = "Pre-release tasks"

[tasks.publish]
    clear = true
    cwd = "${CARGO_MAKE_WORKSPACE_WORKING_DIRECTORY}"
    dependencies = ["pre-release"]
    description = "Publish on crates.io"
    script = '''
!include_files build-tools/makefile.ds

reply = ask_user "Do you want to publish the crates?"
reply = lowercase ${reply}

if eq ${reply} "y"
    if ${DRY_RUN}
        exec --fail-on-error cargo release --config ${__RELEASE_TOML__} --no-confirm
    else
        exec --fail-on-error cargo release --config ${__RELEASE_TOML__} -x --no-confirm
    end

    # Only now when we finished publishing we can remove the release notes file
    if is_path_exists ${__MAKE_RELEASE_NOTES__}
        rm ${__MAKE_RELEASE_NOTES__}
    end
else
    echo "Won't publish."
end
'''
    script_runner = "@duckscript"