Module rebar_state

Data Types

rebar_dict()

rebar_dict() = dict:dict()

t()

t() = #state_t{dir = file:name(), opts = rebar_dict(), code_paths = rebar_dict(), default = rebar_dict(), escript_path = undefined | file:filename_all(), lock = any(), current_profiles = [atom()], namespace = atom(), command_args = any(), command_parsed_args = any(), current_app = undefined | rebar_app_info:t(), project_apps = [rebar_app_info:t()], deps_to_build = [rebar_app_info:t()], all_plugin_deps = [rebar_app_info:t()], all_deps = [rebar_app_info:t()], compilers = [module()], project_builders = [{rebar_app_info:project_type(), module()}], resources = any(), providers = any(), allow_provider_overrides = boolean()}

Function Index

add_project_builder/3
add_provider/2
add_resource/2
add_to_profile/3
all_checkout_deps/1
all_deps/1
all_deps/2
all_plugin_deps/1
all_plugin_deps/2
allow_provider_overrides/1
allow_provider_overrides/2
append_compilers/2register compiler modules.
apply_profiles/2
code_paths/2
code_paths/3
command_args/1
command_args/2
command_parsed_args/1
command_parsed_args/2
compilers/1get a list of all registered compiler modules, which should implement the rebar_compiler behaviour.
create_logic_providers/2
create_resources/2
current_app/1
current_app/2
current_profiles/1
current_profiles/2
default/1
default/2
default_hex_repo_url_override/1
deps_names/1
deps_to_build/1
deps_to_build/2
dir/1
dir/2
escript_path/1
escript_path/2
format_error/1
get/2
get/3
has_all_artifacts/1
lock/1
lock/2
merge_all_deps/2
namespace/1
namespace/2
new/0
new/1
new/2
new/3
opts/1
opts/2
prepend_compilers/2register compiler modules prior to the existing ones.
project_apps/1
project_apps/2
project_builders/1
providers/1
providers/2
resources/1
resources/2
set/3
set_resources/2
to_list/1
update_all_deps/2
update_all_plugin_deps/2
update_code_paths/3

Function Details

add_project_builder/3

add_project_builder(State, Type, Module) -> any()

add_provider/2

add_provider(State::t(), Provider::providers:t()) -> t()

add_resource/2

add_resource(State::t(), X2::{rebar_resource_v2:type(), module()}) -> t()

add_to_profile/3

add_to_profile(State, Profile, KVs) -> any()

all_checkout_deps/1

all_checkout_deps(State_t) -> any()

all_deps/1

all_deps(State_t) -> any()

all_deps/2

all_deps(State, NewApps) -> any()

all_plugin_deps/1

all_plugin_deps(State_t) -> any()

all_plugin_deps/2

all_plugin_deps(State, NewApps) -> any()

allow_provider_overrides/1

allow_provider_overrides(State_t) -> any()

allow_provider_overrides/2

allow_provider_overrides(State, Allow) -> any()

append_compilers/2

append_compilers(State::t(), NewCompilers::[module()]) -> t()

register compiler modules. Each compiler module should implement the rebar_compiler behaviour. Use this when your custom compiler generates binary artifacts and does not have a particular need to run before any other compiler.

apply_profiles/2

apply_profiles(State, Profile) -> any()

code_paths/2

code_paths(State_t::#state_t{dir = file:name(), opts = rebar_dict(), code_paths = rebar_dict(), default = rebar_dict(), escript_path = undefined | file:filename_all(), lock = any(), current_profiles = [atom()], namespace = atom(), command_args = any(), command_parsed_args = any(), current_app = undefined | rebar_app_info:t(), project_apps = [rebar_app_info:t()], deps_to_build = [rebar_app_info:t()], all_plugin_deps = [rebar_app_info:t()], all_deps = [rebar_app_info:t()], compilers = [module()], project_builders = [{rebar_app_info:project_type(), module()}], resources = any(), providers = any(), allow_provider_overrides = boolean()}, Key::atom()) -> [file:filename()]

code_paths/3

code_paths(State_t::#state_t{dir = file:name(), opts = rebar_dict(), code_paths = rebar_dict(), default = rebar_dict(), escript_path = undefined | file:filename_all(), lock = any(), current_profiles = [atom()], namespace = atom(), command_args = any(), command_parsed_args = any(), current_app = undefined | rebar_app_info:t(), project_apps = [rebar_app_info:t()], deps_to_build = [rebar_app_info:t()], all_plugin_deps = [rebar_app_info:t()], all_deps = [rebar_app_info:t()], compilers = [module()], project_builders = [{rebar_app_info:project_type(), module()}], resources = any(), providers = any(), allow_provider_overrides = boolean()}, Key::atom(), CodePath::[file:filename()]) -> #state_t{dir = file:name(), opts = rebar_dict(), code_paths = rebar_dict(), default = rebar_dict(), escript_path = undefined | file:filename_all(), lock = any(), current_profiles = [atom()], namespace = atom(), command_args = any(), command_parsed_args = any(), current_app = undefined | rebar_app_info:t(), project_apps = [rebar_app_info:t()], deps_to_build = [rebar_app_info:t()], all_plugin_deps = [rebar_app_info:t()], all_deps = [rebar_app_info:t()], compilers = [module()], project_builders = [{rebar_app_info:project_type(), module()}], resources = any(), providers = any(), allow_provider_overrides = boolean()}

command_args/1

command_args(State_t) -> any()

command_args/2

command_args(State, CmdArgs) -> any()

command_parsed_args/1

command_parsed_args(State_t) -> any()

command_parsed_args/2

command_parsed_args(State, CmdArgs) -> any()

compilers/1

compilers(State_t::t()) -> [module()]

get a list of all registered compiler modules, which should implement the rebar_compiler behaviour

create_logic_providers/2

create_logic_providers(ProviderModules, State0) -> any()

create_resources/2

create_resources(Resources, State) -> any()

current_app/1

current_app(State_t) -> any()

current_app/2

current_app(State, CurrentApp) -> any()

current_profiles/1

current_profiles(State_t) -> any()

current_profiles/2

current_profiles(State, Profiles) -> any()

default/1

default(State_t) -> any()

default/2

default(State, Opts) -> any()

default_hex_repo_url_override/1

default_hex_repo_url_override(State::t()) -> binary()

deps_names/1

deps_names(Deps) -> any()

deps_to_build/1

deps_to_build(State_t) -> any()

deps_to_build/2

deps_to_build(State, NewApps) -> any()

dir/1

dir(State_t) -> any()

dir/2

dir(State, Dir) -> any()

escript_path/1

escript_path(State_t) -> any()

escript_path/2

escript_path(State, EscriptPath) -> any()

format_error/1

format_error(X1) -> any()

get/2

get(State, Key) -> any()

get/3

get(State, Key, Default) -> any()

has_all_artifacts/1

has_all_artifacts(State_t::#state_t{dir = file:name(), opts = rebar_dict(), code_paths = rebar_dict(), default = rebar_dict(), escript_path = undefined | file:filename_all(), lock = any(), current_profiles = [atom()], namespace = atom(), command_args = any(), command_parsed_args = any(), current_app = undefined | rebar_app_info:t(), project_apps = [rebar_app_info:t()], deps_to_build = [rebar_app_info:t()], all_plugin_deps = [rebar_app_info:t()], all_deps = [rebar_app_info:t()], compilers = [module()], project_builders = [{rebar_app_info:project_type(), module()}], resources = any(), providers = any(), allow_provider_overrides = boolean()}) -> true | {false, file:filename()}

lock/1

lock(State_t) -> any()

lock/2

lock(State, Apps) -> any()

merge_all_deps/2

merge_all_deps(State, UpdatedApps) -> any()

namespace/1

namespace(State_t) -> any()

namespace/2

namespace(State, Namespace) -> any()

new/0

new() -> t()

new/1

new(Config::list()) -> t()

new/2

new(Profile::t() | atom(), Config::list()) -> t()

new/3

new(ParentState::t(), Config::list(), Dir::file:filename_all()) -> t()

opts/1

opts(State_t) -> any()

opts/2

opts(State, Opts) -> any()

prepend_compilers/2

prepend_compilers(State::t(), NewCompilers::[module()]) -> t()

register compiler modules prior to the existing ones. Each compiler module should implement the rebar_compiler behaviour. Use this when your custom compiler generates .erl files (or files of another type) and that should run before other compiler modules.

project_apps/1

project_apps(State_t) -> any()

project_apps/2

project_apps(State, NewApps) -> any()

project_builders/1

project_builders(State_t) -> any()

providers/1

providers(State_t) -> any()

providers/2

providers(State, NewProviders) -> any()

resources/1

resources(State_t::t()) -> [{rebar_resource_v2:type(), module()}]

resources/2

resources(State::t(), NewResources::[{rebar_resource_v2:type(), module()}]) -> t()

set/3

set(State::t(), Key::any(), Value::any()) -> t()

set_resources/2

set_resources(State::t(), Resources::[{rebar_resource_v2:type(), module()}]) -> t()

to_list/1

to_list(State_t) -> any()

update_all_deps/2

update_all_deps(State, NewApps) -> any()

update_all_plugin_deps/2

update_all_plugin_deps(State, NewApps) -> any()

update_code_paths/3

update_code_paths(State_t::#state_t{dir = file:name(), opts = rebar_dict(), code_paths = rebar_dict(), default = rebar_dict(), escript_path = undefined | file:filename_all(), lock = any(), current_profiles = [atom()], namespace = atom(), command_args = any(), command_parsed_args = any(), current_app = undefined | rebar_app_info:t(), project_apps = [rebar_app_info:t()], deps_to_build = [rebar_app_info:t()], all_plugin_deps = [rebar_app_info:t()], all_deps = [rebar_app_info:t()], compilers = [module()], project_builders = [{rebar_app_info:project_type(), module()}], resources = any(), providers = any(), allow_provider_overrides = boolean()}, Key::atom(), CodePath::[file:filename()]) -> #state_t{dir = file:name(), opts = rebar_dict(), code_paths = rebar_dict(), default = rebar_dict(), escript_path = undefined | file:filename_all(), lock = any(), current_profiles = [atom()], namespace = atom(), command_args = any(), command_parsed_args = any(), current_app = undefined | rebar_app_info:t(), project_apps = [rebar_app_info:t()], deps_to_build = [rebar_app_info:t()], all_plugin_deps = [rebar_app_info:t()], all_deps = [rebar_app_info:t()], compilers = [module()], project_builders = [{rebar_app_info:project_type(), module()}], resources = any(), providers = any(), allow_provider_overrides = boolean()}


Generated by EDoc