alunizaje/StartGamedev-160604-osx/tools/zbstudio.app/Contents/ZeroBraneStudio/lualibs/luadist.lua

#!/usr/bin/env lua

-- Command line interface to LuaDist-git.

local dist = require "dist"
local utils = require "dist.utils"
local depends = require "dist.depends"
local package = require "dist.package"
local mf = require "dist.manifest"
local cfg = require "dist.config"
local sys = require "dist.sys"

-- CLI commands of Luadist.
local commands
commands = {

    -- Print help for this command line interface.
    ["help"] = {
        help = [[
Usage: luadist [DEPLOYMENT_DIRECTORY] <COMMAND> [ARGUMENTS...] [-VARIABLES...]

    Commands:

        help      - print this help
        install   - install modules
        remove    - remove modules
        refresh   - update information about modules in repositories
        list      - list installed modules
        info      - show information about modules
        search    - search repositories for modules
        fetch     - download modules
        make      - manually deploy modules from local paths
        upload    - upload installed modules to their repositories
        tree      - print dependency tree of a module
        selftest  - run the selftest of LuaDist

    To get help on specific command, run:

        luadist help <COMMAND>
        ]],
        run = function (deploy_dir, help_item)
            deploy_dir = deploy_dir or dist.get_deploy_dir()
            help_item = help_item or {}
            assert(type(deploy_dir) == "string", "luadist.help: Argument 'deploy_dir' is not a string.")
            assert(type(help_item) == "table", "luadist.help: Argument 'help_item' is not a table.")
            deploy_dir = sys.abs_path(deploy_dir)

            if not help_item or not commands[help_item[1]] then
                help_item = "help"
            else
                help_item = help_item[1]
            end

            print_info()
            print(commands[help_item].help)
            return 0
        end
    },

    -- Install modules.
    ["install"] = {
        help = [[
Usage: luadist [DEPLOYMENT_DIRECTORY] install MODULES... [-VARIABLES...]

    The 'install' command will install specified MODULES to
    DEPLOYMENT_DIRECTORY. LuaDist will also automatically resolve, download
    and install all dependencies.

    If DEPLOYMENT_DIRECTORY is not specified, the deployment directory
    of LuaDist is used.

    You can use * (an asterisk sign) in the name of the module as a wildcard
    with the meaning 'any symbols' (in most shells, the module name then must
    be quoted to prevent the expansion of asterisk by the shell itself).

    Optional CMake VARIABLES in -D format (e.g. -Dvariable=value) or LuaDist
    configuration VARIABLES (e.g. -variable=value) can be specified.

    The -simulate configuration option makes LuaDist only to simulate the
    installation of modules (no modules will be really installed).
        ]],

        run = function (deploy_dir, modules, cmake_variables)
            deploy_dir = deploy_dir or dist.get_deploy_dir()
            if type(modules) == "string" then modules = {modules} end
            cmake_variables = cmake_variables or {}
            assert(type(deploy_dir) == "string", "luadist.install: Argument 'deploy_dir' is not a string.")
            assert(type(modules) == "table", "luadist.install: Argument 'modules' is not a string or table.")
            assert(type(cmake_variables) == "table", "luadist.install: Argument 'cmake_variables' is not a table.")
            deploy_dir = sys.abs_path(deploy_dir)

            if cfg.simulate then
                print("NOTE: this is just simulation.")
            end

            if #modules == 0 then
                print("No modules to install specified.")
                return 0
            end

            local ok, err = dist.install(modules, deploy_dir, cmake_variables)
            if not ok then
                print(err)
                os.exit(1)
            else
               print((cfg.simulate and "Simulated installation" or "Installation") .. " successful.")
               return 0
            end
        end
    },

    -- Remove modules.
    ["remove"] = {
        help = [[
Usage: luadist [DEPLOYMENT_DIRECTORY] remove MODULES... [-VARIABLES...]

    The 'remove' command will remove specified MODULES from
    DEPLOYMENT_DIRECTORY. If no module is specified, all modules
    will be removed.

    If DEPLOYMENT_DIRECTORY is not specified, the deployment directory
    of LuaDist is used. If no MODULES are specified, all installed modules
    will be removed.

    You can use * (an asterisk sign) in the name of the module as a wildcard
    with the meaning 'any symbols' (in most shells, the module name then must
    be quoted to prevent the expansion of asterisk by the shell itself).

    Optional LuaDist configuration VARIABLES (e.g. -variable=value) can be
    specified.

    WARNING: dependencies between modules are NOT taken into account when
    removing modules!
        ]],

        run = function (deploy_dir, modules)
            deploy_dir = deploy_dir or dist.get_deploy_dir()
            if type(modules) == "string" then modules = {modules} end
            assert(type(deploy_dir) == "string", "luadist.remove: Argument 'deploy_dir' is not a string.")
            assert(type(modules) == "table", "luadist.remove: Argument 'modules' is not a string or table.")
            deploy_dir = sys.abs_path(deploy_dir)

            local num, err = dist.remove(modules, deploy_dir)
            if not num then
                print(err)
                os.exit(1)
            else
               print("Removed modules: " .. num)
               return 0
            end
        end
    },

    -- Update repositories.
    ["refresh"] = {
        help = [[
Usage: luadist [DEPLOYMENT_DIRECTORY] refresh [-VARIABLES...]

    The 'refresh' command will update information about modules in all software
    repositories of specified DEPLOYMENT_DIRECTORY. Also, the cached dependency
    manifest, built from previous installations or invocations of 'tree'
    functionality will be deleted.

    If DEPLOYMENT_DIRECTORY is not specified, the deployment directory
    of LuaDist is used.

    Optional LuaDist configuration VARIABLES (e.g. -variable=value) can be
    specified.
        ]],

        run = function (deploy_dir)
            deploy_dir = deploy_dir or dist.get_deploy_dir()
            assert(type(deploy_dir) == "string", "luadist.refresh: Argument 'deploy_dir' is not a string.")
            deploy_dir = sys.abs_path(deploy_dir)

            -- TODO: should be deleting the dep_manifest decoupled from refreshing the repository info?
            -- delete cached dependency manifest
            local dep_manifest_file = sys.abs_path(sys.make_path(deploy_dir, cfg.dep_cache_file))
            local dep_mf_deleted = false
            if sys.exists(dep_manifest_file) then
                sys.delete(dep_manifest_file)
                dep_mf_deleted = true
            end

            -- refresh repository information
            local ok, err = dist.update_manifest(deploy_dir)
            if not ok then
                print(err)
                os.exit(1)
            else
               print("Repositories successfuly updated" .. (dep_mf_deleted and " and dependency cache deleted" or "") .. ".")
               return 0
            end
        end
    },

    -- Manually deploy modules.
    ["make"] = {
        help = [[
Usage: luadist [DEPLOYMENT_DIRECTORY] make MODULE_PATHS... [-VARIABLES...]

    The 'make' command will manually deploy modules from specified local
    MODULE_PATHS into the DEPLOYMENT_DIRECTORY.

    The MODULE_PATHS will be preserved. If DEPLOYMENT_DIRECTORY is not
    specified, the deployment directory of LuaDist is used.

    Optional CMake VARIABLES in -D format (e.g. -Dvariable=value) or LuaDist
    configuration VARIABLES (e.g. -variable=value) can be specified.

    The -simulate configuration option makes LuaDist only to simulate the
    deployment of modules (no modules will be really deployed).

    WARNING: this command does NOT check whether the dependencies of deployed
    modules are satisfied or not!
        ]],

        run = function (deploy_dir, module_paths, cmake_variables)
            deploy_dir = deploy_dir or dist.get_deploy_dir()
            module_paths = module_paths or {}
            cmake_variables = cmake_variables or {}
            assert(type(deploy_dir) == "string", "luadist.make: Argument 'deploy_dir' is not a string.")
            assert(type(module_paths) == "table", "luadist.make: Argument 'module_paths' is not a table.")
            assert(type(cmake_variables) == "table", "luadist.make: Argument 'cmake_variables' is not a table.")
            deploy_dir = sys.abs_path(deploy_dir)

            if cfg.simulate then
                print("NOTE: this is just simulation.")
            end

            if #module_paths == 0 then
                print("No module paths to deploy specified.")
                return 0
            end

            local ok, err = dist.make(deploy_dir, module_paths, cmake_variables)
            if not ok then
                print(err)
                os.exit(1)
            end
            print((cfg.simulate and "Simulated deployment" or "Deployment") .. " successful.")
            return 0
        end
    },

    -- Download modules.
    ["fetch"] = {
        help = [[
Usage: luadist [FETCH_DIRECTORY] fetch MODULES... [-VARIABLES...]

    The 'fetch' command will download specified MODULES to the FETCH_DIRECTORY.

    If no FETCH_DIRECTORY is specified, the temporary directory of LuaDist
    deployment directory (i.e. ']] .. cfg.temp_dir .. [[') is used.
    If the version is not specified in module name, the most recent version
    available will be downloaded.

    Optional LuaDist configuration VARIABLES (e.g. -variable=value) can be
    specified.
        ]],

        run = function (fetch_dir, modules)
            fetch_dir = fetch_dir or dist.get_deploy_dir()
            modules = modules or {}
            assert(type(fetch_dir) == "string", "luadist.fetch: Argument 'fetch_dir' is not a string.")
            assert(type(modules) == "table", "luadist.fetch: Argument 'modules' is not a table.")
            fetch_dir = sys.abs_path(fetch_dir)

            -- if the default parameter (i.e. deploy_dir) is passed, use the default temp_dir
            if fetch_dir == dist.get_deploy_dir() then
                fetch_dir = sys.make_path(fetch_dir, cfg.temp_dir)
            end

            if #modules == 0 then
                print("No modules to download specified.")
                return 0
            end

            local ok, err = dist.fetch(modules, fetch_dir)
            if not ok then
                print(err)
                os.exit(1)
            else
                print("Modules successfuly downloaded to '" .. fetch_dir .. "'.")
                return 0
            end
        end
    },

    -- Upload modules.
    ["upload"] = {
        help = [[
Usage: luadist [DEPLOYMENT_DIRECTORY] upload MODULES... [-VARIABLES...]

    The 'upload' command will upload the binary versions of specified MODULES,
    installed in the DEPLOYMENT_DIRECTORY, to their LuaDist repositories.

    Base url of repositories is given by configuration variable 'upload_url'
    (by default ']] .. cfg.upload_url .. [[') which you can change.
    E.g.: Binary version of module 'lua', installed in DEPLOYMENT_DIRECTORY,
    will now be uploaded to repository ']] .. cfg.upload_url .. [[lua.git'.

    Organization of uploaded modules and their repositories is subject
    to the conventions described in more detail in the source code
    of the 'dist.upload_modules()' function (file 'dist/init.lua').

    If DEPLOYMENT_DIRECTORY is not specified, the deployment directory
    of LuaDist is used. If no MODULES are specified, all installed modules
    will be uploaded.

    You can use * (an asterisk sign) in the name of the module as a wildcard
    with the meaning 'any symbols' (in most shells, the module name then must
    be quoted to prevent the expansion of asterisk by the shell itself).

    Optional LuaDist configuration VARIABLES (e.g. -variable=value) can be
    specified.
        ]],

        run = function (deploy_dir, modules)
            -- check if we have git
            local ok = utils.system_dependency_available("git", "git --version")
            if not ok then os.exit(1) end

            deploy_dir = deploy_dir or dist.get_deploy_dir()
            if type(modules) == "string" then modules = {modules} end
            assert(type(deploy_dir) == "string", "luadist.upload: Argument 'deploy_dir' is not a string.")
            assert(type(modules) == "table", "luadist.upload: Argument 'modules' is not a string or table.")
            deploy_dir = sys.abs_path(deploy_dir)

            local num, err = dist.upload_modules(deploy_dir, modules, cfg.upload_url)
            if not num then
                print(err)
                os.exit(1)
            else
               print("Uploaded modules: " .. num)
               return 0
            end
        end
    },

    -- List installed modules.
    ["list"] = {
        help = [[
Usage: luadist [DEPLOYMENT_DIRECTORY] list [STRINGS...] [-VARIABLES...]

    The 'list' command will list all modules installed in specified
    DEPLOYMENT_DIRECTORY, which contain one or more optional STRINGS.

    If DEPLOYMENT_DIRECTORY is not specified, the deployment directory
    of LuaDist is used. If STRINGS are not specified, all installed modules
    are listed.

    Optional LuaDist configuration VARIABLES (e.g. -variable=value) can be
    specified.
        ]],

        run = function (deploy_dir, strings)
            deploy_dir = deploy_dir or dist.get_deploy_dir()
            strings = strings or {}
            assert(type(deploy_dir) == "string", "luadist.list: Argument 'deploy_dir' is not a string.")
            assert(type(strings) == "table", "luadist.list: Argument 'strings' is not a table.")
            deploy_dir = sys.abs_path(deploy_dir)

            local deployed = dist.get_deployed(deploy_dir)
            deployed  = depends.filter_packages_by_strings(deployed, strings)

            print("\nInstalled modules:")
            print("==================\n")
            for _, pkg in pairs(deployed) do
                print("  " .. pkg.name .. "-" .. pkg.version .. "\t(" .. pkg.arch .. "-" .. pkg.type .. ")" .. (pkg.provided_by and "\t [provided by " .. pkg.provided_by .. "]" or ""))
            end
            print()
            return 0
        end
    },

    -- Search for modules in repositories.
    ["search"] = {
        help = [[
Usage: luadist [DEPLOYMENT_DIRECTORY] search [STRINGS...] [-VARIABLES...]

    The 'search' command will list all modules from repositories, which contain
    one or more STRINGS.

    If no STRINGS are specified, all available modules are listed.

    Optional LuaDist configuration VARIABLES (e.g. -variable=value) can be
    specified.
        ]],

        run = function (deploy_dir, strings)
            deploy_dir = deploy_dir or dist.get_deploy_dir()
            strings = strings or {}
            assert(type(deploy_dir) == "string", "luadist.search: Argument 'deploy_dir' is not a string.")
            assert(type(strings) == "table", "luadist.search: Argument 'strings' is not a table.")
            deploy_dir = sys.abs_path(deploy_dir)

            local available, err = mf.get_manifest()
            if not available then
                print(err)
                os.exit(1)
            end

            available = depends.filter_packages_by_strings(available, strings)
            available = depends.sort_by_names(available)

            print("\nModules found:")
            print("==============\n")
            for _, pkg in pairs(available) do
                print("  " .. pkg.name)
            end
            print()
            return 0
        end
    },

    -- Show information about modules.
    ["info"] = {
        help = [[
Usage: luadist [DEPLOYMENT_DIRECTORY] info [MODULES...] [-VARIABLES...]

    The 'info' command shows information about specified modules from
    repositories. This command also shows whether modules are installed
    in DEPLOYMENT_DIRECTORY.

    If no MODULES are specified, all available modules are shown.
    If DEPLOYMENT_DIRECTORY is not specified, the deployment directory
    of LuaDist is used.

    Optional LuaDist configuration VARIABLES (e.g. -variable=value) can be
    specified.
        ]],

        run = function (deploy_dir, modules)
            deploy_dir = deploy_dir or dist.get_deploy_dir()
            modules = modules or {}
            assert(type(deploy_dir) == "string", "luadist.info: Argument 'deploy_dir' is not a string.")
            assert(type(modules) == "table", "luadist.info: Argument 'modules' is not a table.")
            deploy_dir = sys.abs_path(deploy_dir)

            local manifest, err = mf.get_manifest()
            if not manifest then
                print(err)
                os.exit(1)
            end

            -- if no packages specified explicitly, show just info from .gitmodules for all packages available
            if #modules == 0 then

                modules = manifest
                modules = depends.sort_by_names(modules)
                local deployed = dist.get_deployed(deploy_dir)

                print("")
                for _, pkg in pairs(modules) do
                    print("  " .. pkg.name)
                    print("  Repository url: " .. (pkg.path or "N/A"))
                    print()
                end
                return 0

            -- if some packages explicitly specified, retrieve and show detailed info about them
            else

                if #modules > 5 then
                    print("NOTE: More than 5 modules specified - operation may take a longer time.")
                end

                local deployed = dist.get_deployed(deploy_dir)

                for _, module in pairs(modules) do
                    manifest, err = package.get_versions_info(module, manifest, deploy_dir, deployed)
                    if not manifest then
                        print(err)
                        os.exit(1)
                    end
                end

                modules = depends.find_packages(modules, manifest)
                modules = depends.sort_by_names(modules)

                print("")
                for _, pkg in pairs(modules) do
                    print("  " .. pkg.name .. "-" .. pkg.version .. "  (" .. pkg.arch .. "-" .. pkg.type ..")" .. (pkg.from_installed and "  [info taken from installed version]" or ""))
                    print("  Description: " .. (pkg.desc or "N/A"))
                    print("  Author: " .. (pkg.author or "N/A"))
                    print("  Homepage: " .. (pkg.url or "N/A"))
                    print("  License: " .. (pkg.license or "N/A"))
                    print("  Repository url: " .. (pkg.path or "N/A"))
                    print("  Maintainer: " .. (pkg.maintainer or "N/A"))
                    if pkg.provides then print("  Provides: " .. utils.table_tostring(pkg.provides)) end
                    if pkg.depends then print("  Depends: " .. utils.table_tostring(pkg.depends)) end
                    if pkg.conflicts then print("  Conflicts: " .. utils.table_tostring(pkg.conflicts)) end
                    print("  State: " .. (depends.is_installed(pkg.name, deployed, pkg.version) and "installed" or "not installed"))
                    print()
                end
                return 0
            end

        end
    },

    -- Print dependency tree.
    ["tree"] = {
        help = [[
Usage: luadist [DEPLOYMENT_DIRECTORY] tree [MODULES...] [-VARIABLES...]

    The 'tree' command prints dependency tree for specified modules.

    If no MODULES are specified, trees for all available modules are printed.
    This information about modules is being cached in dependency manifest.

    Optional LuaDist configuration VARIABLES (e.g. -variable=value) can be
    specified.
        ]],

        run = function (deploy_dir, modules)
            deploy_dir = deploy_dir or dist.get_deploy_dir()
            modules = modules or {}
            assert(type(deploy_dir) == "string", "luadist.info: Argument 'deploy_dir' is not a string.")
            assert(type(modules) == "table", "luadist.info: Argument 'modules' is not a table.")
            deploy_dir = sys.abs_path(deploy_dir)

            local manifest, err = mf.get_manifest()
            if not manifest then
                print(err)
                os.exit(1)
            end

            -- if no modules specified explicitly, assume all modules
            if #modules == 0 then modules = depends.sort_by_names(manifest) end
            print("Getting dependency information... (this may take a lot of time)")

            for _, module in pairs(modules) do

                -- if all modules are being queried, extract the name
                if type(module) == "table" then module = module.name end

                local dep_manifest, err = dist.dependency_info(module, deploy_dir)
                if not dep_manifest then
                    print(err)
                    os.exit(1)
                else

                    -- print the dependency tree
                    local heading = "Dependency tree for '" .. module .. "' (on " .. cfg.arch .. "-" .. cfg.type .. "):"
                    print("\n" .. heading .. "")
                    print(string.rep("=", #heading) .. "\n")

                    for _, pkg in pairs(dep_manifest) do

                        local pkg_version, pkg_tag = pkg.version, pkg.version
                        if pkg.was_scm_version then
                            pkg_version, pkg_tag = "scm", "HEAD"
                        end
                        print("  " .. pkg.name .. "-" .. pkg_version .. " (" .. pkg.path .. ", " .. pkg_tag .. ")")
                        if pkg.depends then
                            for _, dep in pairs(pkg.depends) do
                                if type(dep) ~= "table" then
                                    local found = depends.sort_by_versions(depends.find_packages(dep, dep_manifest))[1]
                                    if not found then
                                        print("Could not find the dependency '" .. dep .. "' in the dependency manifest.")
                                        os.exit(1)
                                    end
                                    print("    * " .. found.name .. "-" .. found.version .. " (" .. found.path .. ", " .. found.version .. ")")
                                end
                            end
                        end
                        print()
                    end

                end
            end
            return 0

        end
    },

    -- Selftest of LuaDist.
    ["selftest"] = {
        help = [[
Usage: luadist [TEST_DIRECTORY] selftest [-VARIABLES...]

    The 'selftest' command runs tests of LuaDist, located in TEST_DIRECTORY and
    displays the results.

    If no TEST_DIRECTORY is specified, the default test directory of LuaDist
    deployment directory (i.e. ']] .. cfg.test_dir .. [[') is used.

    Optional LuaDist configuration VARIABLES (e.g. -variable=value) can be
    specified.
        ]],

        run = function (test_dir)
            test_dir = test_dir or dist.get_deploy_dir()
            assert(type(test_dir) == "string", "luadist.selftest: Argument 'deploy_dir' is not a string.")
            test_dir = sys.abs_path(test_dir)

            -- if the default parameter (i.e. deploy_dir) is passed, use the default test_dir
            if test_dir == dist.get_deploy_dir() then
                test_dir = sys.make_path(test_dir, cfg.test_dir)
            end

            -- try to get an iterator over test files and check it
            local test_iterator, err = sys.get_directory(test_dir)
            if not test_iterator then
                print("Running tests from '" .. test_dir .. "' failed: " .. err)
                os.exit(1)
            end

            -- run the tests
            print("\nRunning tests:")
            print("==============")
            for test_file in sys.get_directory(test_dir) do
                test_file = sys.make_path(test_dir, test_file)
                if sys.is_file(test_file) then
                    print()
                    print(sys.extract_name(test_file) .. ":")
                    dofile(test_file)
                end
            end
            print()
            return 0
        end
    },
}

-- Run the functionality of LuaDist 'command' in the 'deploy_dir' with other items
-- or settings/variables starting at 'other_idx' index of special variable 'arg'.
local function run_command(deploy_dir, command, other_idx)
    deploy_dir = deploy_dir or dist.get_deploy_dir()
    assert(type(deploy_dir) == "string", "luadist.run_command: Argument 'deploy_dir' is not a string.")
    assert(type(command) == "string", "luadist.run_command: Argument 'command' is not a string.")
    assert(not other_idx or type(other_idx) == "number", "luadist.run_command: Argument 'other_idx' is not a number.")
    deploy_dir = sys.abs_path(deploy_dir)

    local items = {}
    local cmake_variables = {}

    -- parse items after the command (and LuaDist or CMake variables)
    if other_idx then
        for i = other_idx, #arg do

            -- CMake variable
            if arg[i]:match("^%-D(.-)=(.*)$") then
                local variable, value = arg[i]:match("^%-D(.-)=(.*)$")
                cmake_variables[variable] = value

            -- LuaDist variable
            elseif arg[i]:match("^%-(.-)=(.*)$") then
                local variable, value = arg[i]:match("^%-(.-)=(.*)$")
                apply_settings(variable, value)

            -- LuaDist boolean variable with implicit 'true' value
            elseif arg[i]:match("^%-(.-)$") then
                local variable, value = arg[i]:match("^%-(.-)$")
                apply_settings(variable, "true")

            -- not a LuaDist or CMake variable
            else
                table.insert(items, arg[i])
            end
        end
    end

    -- run the required LuaDist functionality
    return commands[command].run(sys.abs_path(deploy_dir), items, cmake_variables)
end

-- Print information about Luadist (version, license, etc.).
function print_info()
    print([[
LuaDist-git ]].. cfg.version .. [[ - Lua package manager for the LuaDist deployment system.
Released under the MIT License. See https://github.com/luadist/luadist-git
          ]])
    return 0
end

-- Convenience function for printing the main luadist help.
function print_help()
    return run_command(nil, "help")
end

-- Set the LuaDist 'variable' to the 'value'.
-- See available settings in 'dist.config' module.
function apply_settings(variable, value)
    assert(type(variable) == "string", "luadist.apply_settings: Argument 'variable' is not a string.")
    assert(type(value) == "string", "luadist.apply_settings: Argument 'value' is not a string.")

    -- check whether the settings variable exists
    if cfg[variable] == nil then
        print("Unknown LuaDist configuration option: '" .. variable .. "'.")
        os.exit(1)

    -- ensure the right type

    elseif type(cfg[variable]) == "boolean" then
        value = value:lower()
        if value == "true" or value == "yes" or value == "on" or value == "1" then
            value = true
        elseif value == "false" or value == "no" or value == "off" or value == "0" then
            value = false
        else
            print("Value of LuaDist option '" .. variable .. "' must be a boolean.")
            os.exit(1)
        end

    elseif type(cfg[variable]) == "number" then
        value = tonumber(value)
        if not value then
            print("Value of LuaDist option '" .. variable .. "' must be a number.")
            os.exit(1)
        end

    elseif type(cfg[variable]) == "table" then
        local err
        value, err = utils.make_table(value, ",")
        if not value then
            print("Error when parsing the LuaDist variable '" .. variable .. "': " .. err)
            os.exit(1)
        end
    end

    -- set the LuaDist variable
    cfg[variable] = value

end

-- Parse command line input and run the required command.
if pcall(debug.getlocal, 4, 1) then
    return commands -- return commands when used as module
elseif not commands[arg[1]] and commands[arg[2]] then
    -- deploy_dir specified
    return run_command(arg[1], arg[2], 3)
elseif commands[arg[1]] then
    -- deploy_dir not specified
    return run_command(dist.get_deploy_dir(), arg[1], 2)
else
    -- unknown command
    if arg[1] then
        print("Unknown command '" .. arg[1] .. "'. Printing help...\n")
        print_help()
        os.exit(1)
    end
    return print_help()
end