From 252757c753e9ec5c5247a86eb635aee385d05ee1 Mon Sep 17 00:00:00 2001 From: Tuncer Ayaz Date: Sat, 14 Jul 2012 23:44:47 +0200 Subject: [PATCH] Do not use application:set_env --- ebin/rebar.app | 3 - src/rebar.erl | 193 ++++++++++++++++++++---------------- src/rebar_app_utils.erl | 18 ++-- src/rebar_appups.erl | 7 +- src/rebar_base_compiler.erl | 2 +- src/rebar_config.erl | 59 ++++++----- src/rebar_core.erl | 19 ++-- src/rebar_ct.erl | 26 ++--- src/rebar_deps.erl | 80 +++++++-------- src/rebar_eunit.erl | 21 ++-- src/rebar_log.erl | 17 +--- src/rebar_port_compiler.erl | 7 +- src/rebar_rel_utils.erl | 24 ++--- src/rebar_reltool.erl | 36 +++---- src/rebar_templater.erl | 63 ++++++------ src/rebar_upgrade.erl | 19 ++-- src/rebar_utils.erl | 16 +-- src/rebar_xref.erl | 2 +- 18 files changed, 320 insertions(+), 292 deletions(-) diff --git a/ebin/rebar.app b/ebin/rebar.app index d74e81c..b5e1be3 100644 --- a/ebin/rebar.app +++ b/ebin/rebar.app @@ -50,9 +50,6 @@ %% Default log level {log_level, error}, - %% Default parallel jobs - {jobs, 3}, - %% any_dir processing modules {any_dir_modules, [ rebar_require_vsn, diff --git a/src/rebar.erl b/src/rebar.erl index 5812170..21e662b 100644 --- a/src/rebar.erl +++ b/src/rebar.erl @@ -29,7 +29,8 @@ -export([main/1, help/0, parse_args/1, - version/0]). + version/0, + get_jobs/1]). -include("rebar.hrl"). @@ -45,6 +46,8 @@ -define(OTP_INFO, "undefined"). -endif. +-define(DEFAULT_JOBS, 3). + %% ==================================================================== %% Public API %% ==================================================================== @@ -66,55 +69,39 @@ main(Args) -> %% Internal functions %% ==================================================================== +run(["help"]) -> + help(); +run(["version"]) -> + ok = load_rebar_app(), + %% Display vsn and build time info + version(); run(RawArgs) -> - %% Pre-load the rebar app so that we get default configuration - ok = application:load(rebar), + ok = load_rebar_app(), %% Parse out command line arguments -- what's left is a list of commands to %% run -- and start running commands Args = parse_args(RawArgs), + BaseConfig = init_config(Args), + {BaseConfig1, Cmds} = save_options(BaseConfig, Args), - case rebar_config:get_global(enable_profiling, false) of + case rebar_config:get_xconf(BaseConfig1, enable_profiling, false) of true -> io:format("Profiling!\n"), try - fprof:apply(fun(A) -> run_aux(A) end, [Args]) + fprof:apply(fun([C, A]) -> run_aux(C, A) end, + [BaseConfig1, Cmds]) after fprof:profile(), fprof:analyse([{dest, "fprof.analysis"}]) end; - _ -> - run_aux(Args) + false -> + run_aux(BaseConfig1, Cmds) end. -run_aux(["help"]) -> - help(), - ok; -run_aux(["version"]) -> - %% Display vsn and build time info - version(), - ok; -run_aux(Commands) -> - %% Make sure crypto is running - case crypto:start() of - ok -> ok; - {error,{already_started,crypto}} -> ok - end, - - %% Initialize logging system - rebar_log:init(), - - %% Convert command strings to atoms - CommandAtoms = [list_to_atom(C) || C <- Commands], - - %% Determine the location of the rebar executable; important for pulling - %% resources out of the escript - rebar_config:set_global(escript, filename:absname(escript:script_name())), - ?DEBUG("Rebar location: ~p\n", - [rebar_config:get_global(escript, undefined)]), - - %% Note the top-level directory for reference - rebar_config:set_global(base_dir, filename:absname(rebar_utils:get_cwd())), +load_rebar_app() -> + %% Pre-load the rebar app so that we get default configuration + ok = application:load(rebar). +init_config({Options, _NonOptArgs}) -> %% If $HOME/.rebar/config exists load and use as global config GlobalConfigFile = filename:join([os:getenv("HOME"), ".rebar", "config"]), GlobalConfig = case filelib:is_regular(GlobalConfigFile) of @@ -125,12 +112,45 @@ run_aux(Commands) -> false -> rebar_config:new() end, - BaseConfig = rebar_config:base_config(GlobalConfig), + + %% Set the rebar config to use + GlobalConfig1 = case proplists:get_value(config, Options) of + undefined -> + GlobalConfig; + Conf -> + rebar_config:set_global(GlobalConfig, config, Conf) + end, + + GlobalConfig2 = set_log_level(GlobalConfig1, Options), + %% Initialize logging system + ok = rebar_log:init(GlobalConfig2), + + BaseConfig = rebar_config:base_config(GlobalConfig2), %% Keep track of how many operations we do, so we can detect bad commands BaseConfig1 = rebar_config:set_xconf(BaseConfig, operations, 0), %% Initialize vsn cache - BaseConfig2 = rebar_config:set_xconf(BaseConfig1, vsn_cache, dict:new()), + rebar_config:set_xconf(BaseConfig1, vsn_cache, dict:new()). + +run_aux(BaseConfig, Commands) -> + %% Make sure crypto is running + case crypto:start() of + ok -> ok; + {error,{already_started,crypto}} -> ok + end, + + %% Convert command strings to atoms + CommandAtoms = [list_to_atom(C) || C <- Commands], + + %% Determine the location of the rebar executable; important for pulling + %% resources out of the escript + ScriptName = filename:absname(escript:script_name()), + BaseConfig1 = rebar_config:set_xconf(BaseConfig, escript, ScriptName), + ?DEBUG("Rebar location: ~p\n", [ScriptName]), + + %% Note the top-level directory for reference + AbsCwd = filename:absname(rebar_utils:get_cwd()), + BaseConfig2 = rebar_config:set_xconf(BaseConfig1, base_dir, AbsCwd), %% Process each command, resetting any state between each one rebar_core:process_commands(CommandAtoms, BaseConfig2). @@ -149,63 +169,59 @@ help() -> %% Parse command line arguments using getopt and also filtering out any %% key=value pairs. What's left is the list of commands to run %% -parse_args(Args) -> +parse_args(RawArgs) -> %% Parse getopt options OptSpecList = option_spec_list(), - case getopt:parse(OptSpecList, Args) of - {ok, {Options, NonOptArgs}} -> - %% Check options and maybe halt execution - ok = show_info_maybe_halt(Options, NonOptArgs), - - GlobalDefines = proplists:get_all_values(defines, Options), - rebar_config:set_global(defines, GlobalDefines), - - %% Setup profiling flag - rebar_config:set_global(enable_profiling, - proplists:get_bool(profile, Options)), - - %% Setup flag to keep running after a single command fails - rebar_config:set_global(keep_going, - proplists:get_bool(keep_going, Options)), - - %% Set global variables based on getopt options - set_log_level(Options), - set_global_flag(Options, force), - DefJobs = rebar_config:get_jobs(), - case proplists:get_value(jobs, Options, DefJobs) of - DefJobs -> - ok; - Jobs -> - rebar_config:set_global(jobs, Jobs) - end, - - %% Set the rebar config to use - case proplists:get_value(config, Options) of - undefined -> ok; - Conf -> rebar_config:set_global(config, Conf) - end, - - %% Filter all the flags (i.e. strings of form key=value) from the - %% command line arguments. What's left will be the commands to run. - unabbreviate_command_names(filter_flags(NonOptArgs, [])); - + case getopt:parse(OptSpecList, RawArgs) of + {ok, Args} -> + Args; {error, {Reason, Data}} -> ?ERROR("~s ~p~n~n", [Reason, Data]), help(), rebar_utils:delayed_halt(1) end. +save_options(Config, {Options, NonOptArgs}) -> + %% Check options and maybe halt execution + ok = show_info_maybe_halt(Options, NonOptArgs), + + GlobalDefines = proplists:get_all_values(defines, Options), + + Config1 = rebar_config:set_xconf(Config, defines, GlobalDefines), + + %% Setup profiling flag + Config2 = rebar_config:set_xconf(Config1, enable_profiling, + proplists:get_bool(profile, Options)), + + %% Setup flag to keep running after a single command fails + Config3 = rebar_config:set_xconf(Config2, keep_going, + proplists:get_bool(keep_going, Options)), + + %% Set global variables based on getopt options + Config4 = set_global_flag(Config3, Options, force), + Config5 = case proplists:get_value(jobs, Options, ?DEFAULT_JOBS) of + ?DEFAULT_JOBS -> + Config4; + Jobs -> + rebar_config:set_global(Config4, jobs, Jobs) + end, + + %% Filter all the flags (i.e. strings of form key=value) from the + %% command line arguments. What's left will be the commands to run. + {Config6, RawCmds} = filter_flags(Config5, NonOptArgs, []), + {Config6, unabbreviate_command_names(RawCmds)}. + %% %% set log level based on getopt option %% -set_log_level(Options) -> +set_log_level(Config, Options) -> LogLevel = case proplists:get_all_values(verbose, Options) of [] -> rebar_log:default_level(); Verbosities -> lists:last(Verbosities) end, - rebar_config:set_global(verbose, LogLevel). + rebar_config:set_global(Config, verbose, LogLevel). %% %% show version information and halt @@ -219,14 +235,14 @@ version() -> %% %% set global flag based on getopt option boolean value %% -set_global_flag(Options, Flag) -> +set_global_flag(Config, Options, Flag) -> Value = case proplists:get_bool(Flag, Options) of true -> "1"; false -> "0" end, - rebar_config:set_global(Flag, Value). + rebar_config:set_global(Config, Flag, Value). %% %% show info and maybe halt execution @@ -291,11 +307,14 @@ version Show version information ">>, io:put_chars(S). +get_jobs(Config) -> + rebar_config:get_global(Config, jobs, ?DEFAULT_JOBS). + %% %% options accepted via getopt %% option_spec_list() -> - Jobs = rebar_config:get_jobs(), + Jobs = ?DEFAULT_JOBS, JobsHelp = io_lib:format( "Number of concurrent workers a command may use. Default: ~B", [Jobs]), @@ -319,12 +338,12 @@ option_spec_list() -> %% Seperate all commands (single-words) from flags (key=value) and store %% values into the rebar_config global storage. %% -filter_flags([], Commands) -> - lists:reverse(Commands); -filter_flags([Item | Rest], Commands) -> +filter_flags(Config, [], Commands) -> + {Config, lists:reverse(Commands)}; +filter_flags(Config, [Item | Rest], Commands) -> case string:tokens(Item, "=") of [Command] -> - filter_flags(Rest, [Command | Commands]); + filter_flags(Config, Rest, [Command | Commands]); [KeyStr, RawValue] -> Key = list_to_atom(KeyStr), Value = case Key of @@ -333,11 +352,11 @@ filter_flags([Item | Rest], Commands) -> _ -> RawValue end, - rebar_config:set_global(Key, Value), - filter_flags(Rest, Commands); + Config1 = rebar_config:set_global(Config, Key, Value), + filter_flags(Config1, Rest, Commands); Other -> ?CONSOLE("Ignoring command line argument: ~p\n", [Other]), - filter_flags(Rest, Commands) + filter_flags(Config, Rest, Commands) end. command_names() -> diff --git a/src/rebar_app_utils.erl b/src/rebar_app_utils.erl index 1d2583a..d21d9cb 100644 --- a/src/rebar_app_utils.erl +++ b/src/rebar_app_utils.erl @@ -111,10 +111,10 @@ is_skipped_app(Config, AppFile) -> %% Check for apps global parameter; this is a comma-delimited list %% of apps on which we want to run commands Skipped = - case get_apps() of + case get_apps(Config) of undefined -> %% No apps parameter specified, check the skip_apps list.. - case get_skip_apps() of + case get_skip_apps(Config) of undefined -> %% No skip_apps list, run everything.. false; @@ -136,8 +136,8 @@ is_skipped_app(Config, AppFile) -> load_app_file(Config, Filename) -> AppFile = {app_file, Filename}, - case rebar_config:get_xconf(Config, {appfile, AppFile}) of - error -> + case rebar_config:get_xconf(Config, {appfile, AppFile}, undefined) of + undefined -> case file:consult(Filename) of {ok, [{application, AppName, AppData}]} -> Config1 = rebar_config:set_xconf(Config, @@ -149,7 +149,7 @@ load_app_file(Config, Filename) -> Other -> {error, {unexpected_terms, Other}} end; - {ok, {AppName, AppData}} -> + {AppName, AppData} -> {ok, Config, AppName, AppData} end. @@ -179,8 +179,8 @@ is_skipped(ThisApp, TargetApps) -> {true, ThisApp} end. -get_apps() -> - rebar_utils:get_deprecated_global(app, apps, "soon"). +get_apps(Config) -> + rebar_utils:get_deprecated_global(Config, app, apps, "soon"). -get_skip_apps() -> - rebar_utils:get_deprecated_global(skip_app, skip_apps, "soon"). +get_skip_apps(Config) -> + rebar_utils:get_deprecated_global(Config, skip_app, skip_apps, "soon"). diff --git a/src/rebar_appups.erl b/src/rebar_appups.erl index 88cf8d9..0aeccb6 100644 --- a/src/rebar_appups.erl +++ b/src/rebar_appups.erl @@ -41,10 +41,11 @@ 'generate-appups'(Config, ReltoolFile) -> %% Get the old release path {Config1, ReltoolConfig} = rebar_rel_utils:load_config(Config, ReltoolFile), - TargetParentDir = rebar_rel_utils:get_target_parent_dir(ReltoolConfig), + TargetParentDir = rebar_rel_utils:get_target_parent_dir(Config, + ReltoolConfig), - OldVerPath = filename:join([TargetParentDir, - rebar_rel_utils:get_previous_release_path()]), + PrevRelPath = rebar_rel_utils:get_previous_release_path(Config), + OldVerPath = filename:join([TargetParentDir, PrevRelPath]), %% Get the new and old release name and versions {Name, _Ver} = rebar_rel_utils:get_reltool_release_info(ReltoolConfig), diff --git a/src/rebar_base_compiler.erl b/src/rebar_base_compiler.erl index 7d1fb22..89aab07 100644 --- a/src/rebar_base_compiler.erl +++ b/src/rebar_base_compiler.erl @@ -47,7 +47,7 @@ run(Config, FirstFiles, RestFiles, CompileFn) -> _ -> Self = self(), F = fun() -> compile_worker(Self, Config, CompileFn) end, - Jobs = rebar_config:get_jobs(), + Jobs = rebar:get_jobs(Config), ?DEBUG("Starting ~B compile worker(s)~n", [Jobs]), Pids = [spawn_monitor(F) || _I <- lists:seq(1,Jobs)], compile_queue(Pids, RestFiles) diff --git a/src/rebar_config.erl b/src/rebar_config.erl index 5008533..8b856ab 100644 --- a/src/rebar_config.erl +++ b/src/rebar_config.erl @@ -30,17 +30,18 @@ get/3, get_local/3, get_list/3, get_all/2, set/3, - set_global/2, get_global/2, - is_verbose/0, get_jobs/0, + set_global/3, get_global/3, + is_verbose/1, set_env/3, get_env/2, reset_env/1, set_skip_dir/2, is_skip_dir/2, reset_skip_dirs/1, clean_config/2, - set_xconf/3, get_xconf/2, erase_xconf/2, reset_xconf/1]). + set_xconf/3, get_xconf/2, get_xconf/3, erase_xconf/2]). -include("rebar.hrl"). -record(config, { dir :: file:filename(), opts = [] :: list(), + globals = new_globals() :: dict(), %% TODO: consider storing envs in xconf envs = new_env() :: dict(), %% cross-directory config @@ -60,7 +61,7 @@ %% =================================================================== base_config(GlobalConfig) -> - ConfName = rebar_config:get_global(config, ?DEFAULT_NAME), + ConfName = rebar_config:get_global(GlobalConfig, config, ?DEFAULT_NAME), new(GlobalConfig, ConfName). new() -> @@ -74,8 +75,10 @@ new(ConfigFile) when is_list(ConfigFile) -> Other -> ?ABORT("Failed to load ~s: ~p~n", [ConfigFile, Other]) end; -new(_ParentConfig=#config{opts=Opts0, skip_dirs=SkipDirs, xconf=Xconf})-> - new(#config{opts=Opts0, skip_dirs=SkipDirs, xconf=Xconf}, ?DEFAULT_NAME). +new(_ParentConfig=#config{opts=Opts0, globals=Globals, skip_dirs=SkipDirs, + xconf=Xconf}) -> + new(#config{opts=Opts0, globals=Globals, skip_dirs=SkipDirs, xconf=Xconf}, + ?DEFAULT_NAME). get(Config, Key, Default) -> proplists:get_value(Key, Config#config.opts, Default). @@ -93,27 +96,26 @@ set(Config, Key, Value) -> Opts = proplists:delete(Key, Config#config.opts), Config#config { opts = [{Key, Value} | Opts] }. -set_global(jobs=Key, Value) when is_list(Value) -> - set_global(Key, list_to_integer(Value)); -set_global(jobs=Key, Value) when is_integer(Value) -> - application:set_env(rebar_global, Key, erlang:max(1, Value)); -set_global(Key, Value) -> - application:set_env(rebar_global, Key, Value). +set_global(Config, jobs=Key, Value) when is_list(Value) -> + set_global(Config, Key, list_to_integer(Value)); +set_global(Config, jobs=Key, Value) when is_integer(Value) -> + NewGlobals = dict:store(Key, erlang:max(1, Value), Config#config.globals), + Config#config{globals = NewGlobals}; +set_global(Config, Key, Value) -> + NewGlobals = dict:store(Key, Value, Config#config.globals), + Config#config{globals = NewGlobals}. -get_global(Key, Default) -> - case application:get_env(rebar_global, Key) of - undefined -> +get_global(Config, Key, Default) -> + case dict:find(Key, Config#config.globals) of + error -> Default; {ok, Value} -> Value end. -is_verbose() -> +is_verbose(Config) -> DefaulLevel = rebar_log:default_level(), - get_global(verbose, DefaulLevel) > DefaulLevel. - -get_jobs() -> - get_global(jobs, 3). + get_global(Config, verbose, DefaulLevel) > DefaulLevel. consult_file(File) -> case filename:extension(File) of @@ -162,15 +164,21 @@ set_xconf(Config, Key, Value) -> Config#config{xconf=NewXconf}. get_xconf(Config, Key) -> - dict:find(Key, Config#config.xconf). + {ok, Value} = dict:find(Key, Config#config.xconf), + Value. + +get_xconf(Config, Key, Default) -> + case dict:find(Key, Config#config.xconf) of + error -> + Default; + {ok, Value} -> + Value + end. erase_xconf(Config, Key) -> NewXconf = dict:erase(Key, Config#config.xconf), Config#config{xconf = NewXconf}. -reset_xconf(Config) -> - Config#config{xconf = new_xconf()}. - %% TODO: reconsider after config inheritance removal/redesign clean_config(Old, New) -> New#config{opts=Old#config.opts}. @@ -208,7 +216,6 @@ consult_and_eval(File, Script) -> ConfigData = try_consult(File), file:script(Script, bs([{'CONFIG', ConfigData}, {'SCRIPT', Script}])). - remove_script_ext(F) -> "tpircs." ++ Rev = lists:reverse(F), lists:reverse(Rev). @@ -236,6 +243,8 @@ local_opts([local | _Rest], Acc) -> local_opts([Item | Rest], Acc) -> local_opts(Rest, [Item | Acc]). +new_globals() -> dict:new(). + new_env() -> dict:new(). new_skip_dirs() -> dict:new(). diff --git a/src/rebar_core.erl b/src/rebar_core.erl index 493d256..a56ba1a 100644 --- a/src/rebar_core.erl +++ b/src/rebar_core.erl @@ -35,7 +35,7 @@ %% =================================================================== process_commands([], ParentConfig) -> - AbortTrapped = rebar_config:get_global(abort_trapped, false), + AbortTrapped = rebar_config:get_xconf(ParentConfig, abort_trapped, false), case {get_operations(ParentConfig), AbortTrapped} of {0, _} -> %% None of the commands had any effect @@ -49,7 +49,7 @@ process_commands([], ParentConfig) -> process_commands([Command | Rest], ParentConfig) -> %% Reset skip dirs ParentConfig1 = rebar_config:reset_skip_dirs(ParentConfig), - Operations = rebar_config:get_xconf(ParentConfig1, operations), + Operations = get_operations(ParentConfig1), ParentConfig4 = try @@ -75,13 +75,13 @@ process_commands([Command | Rest], ParentConfig) -> rebar_config:set_xconf(ParentConfig3, vsn_cache, dict:new()) catch throw:rebar_abort -> - case rebar_config:get_global(keep_going, false) of + case rebar_config:get_xconf(ParentConfig1, keep_going, false) of false -> ?ABORT; true -> ?WARN("Continuing on after abort: ~p\n", [Rest]), - rebar_config:set_global(abort_trapped, true), - ParentConfig1 + rebar_config:set_xconf(ParentConfig1, + abort_trapped, true) end end, process_commands(Rest, ParentConfig4). @@ -242,15 +242,15 @@ remember_cwd_subdir(Cwd, Subdirs) -> maybe_load_local_config(Dir, ParentConfig) -> %% We need to ensure we don't overwrite custom %% config when we are dealing with base_dir. - case processing_base_dir(Dir) of + case processing_base_dir(ParentConfig, Dir) of true -> ParentConfig; false -> rebar_config:new(ParentConfig) end. -processing_base_dir(Dir) -> - Dir == rebar_config:get_global(base_dir, undefined). +processing_base_dir(Config, Dir) -> + Dir == rebar_config:get_xconf(Config, base_dir). %% %% Given a list of directories and a set of previously processed directories, @@ -357,8 +357,7 @@ increment_operations(Config) -> rebar_config:set_xconf(Config, operations, Operations + 1). get_operations(Config) -> - {ok, Operations} = rebar_config:get_xconf(Config, operations), - Operations. + rebar_config:get_xconf(Config, operations). update_code_path(Config) -> case rebar_config:get_local(Config, lib_dirs, []) of diff --git a/src/rebar_ct.erl b/src/rebar_ct.erl index 57f038a..089d6cf 100644 --- a/src/rebar_ct.erl +++ b/src/rebar_ct.erl @@ -64,7 +64,7 @@ run_test_if_present(TestDir, Config, File) -> run_test(TestDir, Config, _File) -> {Cmd, RawLog} = make_cmd(TestDir, Config), clear_log(RawLog), - case rebar_config:is_verbose() of + case rebar_config:is_verbose(Config) of false -> Output = " >> " ++ RawLog ++ " 2>&1"; true -> @@ -72,7 +72,7 @@ run_test(TestDir, Config, _File) -> end, rebar_utils:sh(Cmd ++ Output, [{env,[{"TESTDIR", TestDir}]}]), - check_log(RawLog). + check_log(Config, RawLog). clear_log(RawLog) -> @@ -88,7 +88,7 @@ clear_log(RawLog) -> %% calling ct with erl does not return non-zero on failure - have to check %% log results -check_log(RawLog) -> +check_log(Config, RawLog) -> {ok, Msg} = rebar_utils:sh("grep -e 'TEST COMPLETE' -e '{error,make_failed}' " ++ RawLog, [{use_stdout, false}]), @@ -96,12 +96,12 @@ check_log(RawLog) -> RunFailed = string:str(Msg, ", 0 failed") =:= 0, if MakeFailed -> - show_log(RawLog), + show_log(Config, RawLog), ?ERROR("Building tests failed\n",[]), ?ABORT; RunFailed -> - show_log(RawLog), + show_log(Config, RawLog), ?ERROR("One or more tests failed\n",[]), ?ABORT; @@ -110,9 +110,9 @@ check_log(RawLog) -> end. %% Show the log if it hasn't already been shown because verbose was on -show_log(RawLog) -> +show_log(Config, RawLog) -> ?CONSOLE("Showing log\n", []), - case rebar_config:is_verbose() of + case rebar_config:is_verbose(Config) of false -> {ok, Contents} = file:read_file(RawLog), ?CONSOLE("~s", [Contents]); @@ -159,8 +159,8 @@ make_cmd(TestDir, Config) -> get_cover_config(Config, Cwd) ++ get_ct_config_file(TestDir) ++ get_config_file(TestDir) ++ - get_suites(TestDir) ++ - get_case(); + get_suites(Config, TestDir) ++ + get_case(Config); SpecFlags -> ?FMT("erl " % should we expand ERL_PATH? " -noshell -pa ~s ~s" @@ -248,8 +248,8 @@ get_config_file(TestDir) -> " -config " ++ Config end. -get_suites(TestDir) -> - case rebar_utils:get_deprecated_global(suite, suites, "soon") of +get_suites(Config, TestDir) -> + case rebar_utils:get_deprecated_global(Config, suite, suites, "soon") of undefined -> " -dir " ++ TestDir; Suites -> @@ -268,8 +268,8 @@ find_suite_path(Suite, TestDir) -> Path end. -get_case() -> - case rebar_config:get_global('case', undefined) of +get_case(Config) -> + case rebar_config:get_global(Config, 'case', undefined) of undefined -> ""; Case -> diff --git a/src/rebar_deps.erl b/src/rebar_deps.erl index 1abdce7..72c7769 100644 --- a/src/rebar_deps.erl +++ b/src/rebar_deps.erl @@ -52,40 +52,41 @@ preprocess(Config, _) -> %% Side effect to set deps_dir globally for all dependencies from %% top level down. Means the root deps_dir is honoured or the default %% used globally since it will be set on the first time through here - set_global_deps_dir(Config, rebar_config:get_global(deps_dir, [])), + DepsDir = rebar_config:get_global(Config, deps_dir, []), + Config1 = set_global_deps_dir(Config, DepsDir), %% Get the list of deps for the current working directory and identify those %% deps that are available/present. - Deps = rebar_config:get_local(Config, deps, []), - {Config1, {AvailableDeps, MissingDeps}} = find_deps(Config, find, Deps), + Deps = rebar_config:get_local(Config1, deps, []), + {Config2, {AvailableDeps, MissingDeps}} = find_deps(Config1, find, Deps), ?DEBUG("Available deps: ~p\n", [AvailableDeps]), ?DEBUG("Missing deps : ~p\n", [MissingDeps]), %% Add available deps to code path - Config2 = update_deps_code_path(Config1, AvailableDeps), + Config3 = update_deps_code_path(Config2, AvailableDeps), %% If skip_deps=true, mark each dep dir as a skip_dir w/ the core so that %% the current command doesn't run on the dep dir. However, pre/postprocess %% WILL run (and we want it to) for transitivity purposes. - NewConfig = case rebar_config:get_global(skip_deps, false) of + NewConfig = case rebar_config:get_global(Config3, skip_deps, false) of "true" -> lists:foldl( fun(#dep{dir = Dir}, C) -> rebar_config:set_skip_dir(C, Dir) - end, Config2, AvailableDeps); + end, Config3, AvailableDeps); _ -> - Config2 + Config3 end, %% Return all the available dep directories for process {ok, NewConfig, dep_dirs(AvailableDeps)}. postprocess(Config, _) -> - case rebar_config:get_xconf(Config, ?MODULE) of - error -> + case rebar_config:get_xconf(Config, ?MODULE, undefined) of + undefined -> {ok, []}; - {ok, Dirs} -> + Dirs -> NewConfig = rebar_config:erase_xconf(Config, ?MODULE), {ok, NewConfig, Dirs} end. @@ -94,8 +95,8 @@ compile(Config, AppFile) -> 'check-deps'(Config, AppFile). %% set REBAR_DEPS_DIR and ERL_LIBS environment variables -setup_env(_Config) -> - {true, DepsDir} = get_deps_dir(), +setup_env(Config) -> + {true, DepsDir} = get_deps_dir(Config), %% include rebar's DepsDir in ERL_LIBS Separator = case os:type() of {win32, nt} -> @@ -149,7 +150,8 @@ setup_env(_Config) -> {Config1, Deps} = find_deps(Config, read, RawDeps), %% Update each dep - UpdatedDeps = [update_source(D) || D <- Deps, D#dep.source =/= undefined], + UpdatedDeps = [update_source(Config1, D) + || D <- Deps, D#dep.source =/= undefined], %% Add each updated dep to our list of dirs for post-processing. This yields %% the necessary transitivity of the deps @@ -157,7 +159,7 @@ setup_env(_Config) -> 'delete-deps'(Config, _) -> %% Delete all the available deps in our deps/ directory, if any - {true, DepsDir} = get_deps_dir(), + {true, DepsDir} = get_deps_dir(Config), Deps = rebar_config:get_local(Config, deps, []), {Config1, {AvailableDeps, _}} = find_deps(Config, find, Deps), _ = [delete_dep(D) @@ -183,17 +185,17 @@ setup_env(_Config) -> %% need all deps in same dir and should be the one set by the root rebar.config %% Sets a default if root config has no deps_dir set set_global_deps_dir(Config, []) -> - rebar_config:set_global(deps_dir, + rebar_config:set_global(Config, deps_dir, rebar_config:get_local(Config, deps_dir, "deps")); -set_global_deps_dir(_Config, _DepsDir) -> - ok. +set_global_deps_dir(Config, _DepsDir) -> + Config. -get_deps_dir() -> - get_deps_dir(""). +get_deps_dir(Config) -> + get_deps_dir(Config, ""). -get_deps_dir(App) -> - BaseDir = rebar_config:get_global(base_dir, []), - DepsDir = rebar_config:get_global(deps_dir, "deps"), +get_deps_dir(Config, App) -> + BaseDir = rebar_config:get_xconf(Config, base_dir, []), + DepsDir = rebar_config:get_global(Config, deps_dir, "deps"), {true, filename:join([BaseDir, DepsDir, App])}. dep_dirs(Deps) -> @@ -262,7 +264,7 @@ find_dep(Config, Dep) -> find_dep(Config, Dep, undefined) -> %% 'source' is undefined. If Dep is not satisfied locally, %% go ahead and find it amongst the lib_dir's. - case find_dep_in_dir(Config, Dep, get_deps_dir(Dep#dep.app)) of + case find_dep_in_dir(Config, Dep, get_deps_dir(Config, Dep#dep.app)) of {_Config1, {avail, _Dir}} = Avail -> Avail; {Config1, {missing, _}} -> @@ -272,7 +274,7 @@ find_dep(Config, Dep, _Source) -> %% _Source is defined. Regardless of what it is, we must find it %% locally satisfied or fetch it from the original source %% into the project's deps - find_dep_in_dir(Config, Dep, get_deps_dir(Dep#dep.app)). + find_dep_in_dir(Config, Dep, get_deps_dir(Config, Dep#dep.app)). find_dep_in_dir(Config, _Dep, {false, Dir}) -> {Config, {missing, Dir}}; @@ -365,7 +367,7 @@ use_source(Config, Dep, Count) -> false -> ?CONSOLE("Pulling ~p from ~p\n", [Dep#dep.app, Dep#dep.source]), require_source_engine(Dep#dep.source), - {true, TargetDir} = get_deps_dir(Dep#dep.app), + {true, TargetDir} = get_deps_dir(Config, Dep#dep.app), download_source(TargetDir, Dep#dep.source), use_source(Config, Dep#dep { dir = TargetDir }, Count-1) end. @@ -408,17 +410,17 @@ download_source(AppDir, {rsync, Url}) -> ok = filelib:ensure_dir(AppDir), rebar_utils:sh(?FMT("rsync -az --delete ~s/ ~s", [Url, AppDir]), []). -update_source(Dep) -> +update_source(Config, Dep) -> %% It's possible when updating a source, that a given dep does not have a %% VCS directory, such as when a source archive is built of a project, with %% all deps already downloaded/included. So, verify that the necessary VCS %% directory exists before attempting to do the update. - {true, AppDir} = get_deps_dir(Dep#dep.app), + {true, AppDir} = get_deps_dir(Config, Dep#dep.app), case has_vcs_dir(element(1, Dep#dep.source), AppDir) of true -> ?CONSOLE("Updating ~p from ~p\n", [Dep#dep.app, Dep#dep.source]), require_source_engine(Dep#dep.source), - update_source(AppDir, Dep#dep.source), + update_source1(AppDir, Dep#dep.source), Dep; false -> ?WARN("Skipping update for ~p: " @@ -426,29 +428,29 @@ update_source(Dep) -> Dep end. -update_source(AppDir, {git, Url}) -> - update_source(AppDir, {git, Url, {branch, "HEAD"}}); -update_source(AppDir, {git, Url, ""}) -> - update_source(AppDir, {git, Url, {branch, "HEAD"}}); -update_source(AppDir, {git, _Url, {branch, Branch}}) -> +update_source1(AppDir, {git, Url}) -> + update_source1(AppDir, {git, Url, {branch, "HEAD"}}); +update_source1(AppDir, {git, Url, ""}) -> + update_source1(AppDir, {git, Url, {branch, "HEAD"}}); +update_source1(AppDir, {git, _Url, {branch, Branch}}) -> ShOpts = [{cd, AppDir}], rebar_utils:sh("git fetch origin", ShOpts), rebar_utils:sh(?FMT("git checkout -q origin/~s", [Branch]), ShOpts); -update_source(AppDir, {git, _Url, {tag, Tag}}) -> +update_source1(AppDir, {git, _Url, {tag, Tag}}) -> ShOpts = [{cd, AppDir}], rebar_utils:sh("git fetch --tags origin", ShOpts), rebar_utils:sh(?FMT("git checkout -q ~s", [Tag]), ShOpts); -update_source(AppDir, {git, _Url, Refspec}) -> +update_source1(AppDir, {git, _Url, Refspec}) -> ShOpts = [{cd, AppDir}], rebar_utils:sh("git fetch origin", ShOpts), rebar_utils:sh(?FMT("git checkout -q ~s", [Refspec]), ShOpts); -update_source(AppDir, {svn, _Url, Rev}) -> +update_source1(AppDir, {svn, _Url, Rev}) -> rebar_utils:sh(?FMT("svn up -r ~s", [Rev]), [{cd, AppDir}]); -update_source(AppDir, {hg, _Url, Rev}) -> +update_source1(AppDir, {hg, _Url, Rev}) -> rebar_utils:sh(?FMT("hg pull -u -r ~s", [Rev]), [{cd, AppDir}]); -update_source(AppDir, {bzr, _Url, Rev}) -> +update_source1(AppDir, {bzr, _Url, Rev}) -> rebar_utils:sh(?FMT("bzr update -r ~s", [Rev]), [{cd, AppDir}]); -update_source(AppDir, {rsync, Url}) -> +update_source1(AppDir, {rsync, Url}) -> rebar_utils:sh(?FMT("rsync -az --delete ~s/ ~s",[Url,AppDir]),[]). %% =================================================================== diff --git a/src/rebar_eunit.erl b/src/rebar_eunit.erl index 2fc4e23..32b39c1 100644 --- a/src/rebar_eunit.erl +++ b/src/rebar_eunit.erl @@ -139,7 +139,7 @@ eunit(Config, _AppFile) -> ModuleBeamFiles = BeamFiles ++ OtherBeamFiles, Modules = [rebar_utils:beam_to_mod(?EUNIT_DIR, N) || N <- ModuleBeamFiles], SrcModules = [rebar_utils:erl_to_mod(M) || M <- SrcErls], - FilteredModules = filter_modules(Modules), + FilteredModules = filter_modules(Config, Modules), {ok, CoverLog} = cover_init(Config, ModuleBeamFiles), @@ -181,14 +181,15 @@ eunit_dir() -> ebin_dir() -> filename:join(rebar_utils:get_cwd(), "ebin"). -filter_modules(Modules) -> - RawSuites = rebar_utils:get_deprecated_global(suite, suites, [], "soon"), +filter_modules(Config, Modules) -> + RawSuites = rebar_utils:get_deprecated_global(Config, suite, suites, + [], "soon"), Suites = [list_to_atom(Suite) || Suite <- string:tokens(RawSuites, ",")], - filter_modules(Modules, Suites). + filter_modules1(Modules, Suites). -filter_modules(Modules, []) -> +filter_modules1(Modules, []) -> Modules; -filter_modules(Modules, Suites) -> +filter_modules1(Modules, Suites) -> [M || M <- Modules, lists:member(M, Suites)]. perform_eunit(Config, FilteredModules) -> @@ -208,7 +209,7 @@ perform_eunit(Config, FilteredModules) -> get_eunit_opts(Config) -> %% Enable verbose in eunit if so requested.. - BaseOpts = case rebar_config:is_verbose() of + BaseOpts = case rebar_config:is_verbose(Config) of true -> [verbose]; false -> @@ -247,8 +248,8 @@ define_if(Def, true) -> [{d, Def}]; define_if(_Def, false) -> []. is_lib_avail(Config, DictKey, Mod, Hrl, Name) -> - case rebar_config:get_xconf(Config, DictKey) of - error -> + case rebar_config:get_xconf(Config, DictKey, undefined) of + undefined -> IsAvail = case code:lib_dir(Mod, include) of {error, bad_name} -> false; @@ -258,7 +259,7 @@ is_lib_avail(Config, DictKey, Mod, Hrl, Name) -> NewConfig = rebar_config:set_xconf(Config, DictKey, IsAvail), ?DEBUG("~s availability: ~p\n", [Name, IsAvail]), {NewConfig, IsAvail}; - {ok, IsAvail} -> + IsAvail -> {Config, IsAvail} end. diff --git a/src/rebar_log.erl b/src/rebar_log.erl index b7529a9..4108c9c 100644 --- a/src/rebar_log.erl +++ b/src/rebar_log.erl @@ -26,16 +26,17 @@ %% ------------------------------------------------------------------- -module(rebar_log). --export([init/0, - set_level/1, get_level/0, default_level/0, +-export([init/1, + set_level/1, default_level/0, log/3]). %% =================================================================== %% Public API %% =================================================================== -init() -> - case valid_level(rebar_config:get_global(verbose, error_level())) of +init(Config) -> + Verbosity = rebar_config:get_global(Config, verbose, default_level()), + case valid_level(Verbosity) of 0 -> set_level(error); 1 -> set_level(warn); 2 -> set_level(info); @@ -45,14 +46,6 @@ init() -> set_level(Level) -> ok = application:set_env(rebar, log_level, Level). -get_level() -> - case application:get_env(rebar, log_level) of - undefined -> - error; - {ok, Value} -> - Value - end. - log(Level, Str, Args) -> {ok, LogLevel} = application:get_env(rebar, log_level), case should_log(LogLevel, Level) of diff --git a/src/rebar_port_compiler.erl b/src/rebar_port_compiler.erl index 8f38cd2..5ea0a1d 100644 --- a/src/rebar_port_compiler.erl +++ b/src/rebar_port_compiler.erl @@ -179,12 +179,13 @@ setup_env(Config, ExtraEnv) -> %% max flexibility for users. DefaultEnv = filter_env(default_env(), []), PortEnv = filter_env(port_env(Config), []), - OverrideEnv = global_defines() ++ PortEnv ++ filter_env(ExtraEnv, []), + GlobalDefines = global_defines(Config), + OverrideEnv = GlobalDefines ++ PortEnv ++ filter_env(ExtraEnv, []), RawEnv = apply_defaults(os_env(), DefaultEnv) ++ OverrideEnv, expand_vars_loop(merge_each_var(RawEnv, [])). -global_defines() -> - Defines = rebar_config:get_global(defines, []), +global_defines(Config) -> + Defines = rebar_config:get_global(Config, defines, []), Flags = string:join(["-D" ++ D || D <- Defines], " "), [{"ERL_CFLAGS", "$ERL_CFLAGS " ++ Flags}]. diff --git a/src/rebar_rel_utils.erl b/src/rebar_rel_utils.erl index 3c94d97..e749c55 100644 --- a/src/rebar_rel_utils.erl +++ b/src/rebar_rel_utils.erl @@ -33,13 +33,13 @@ get_rel_release_info/2, get_rel_apps/1, get_rel_apps/2, - get_previous_release_path/0, + get_previous_release_path/1, get_rel_file_path/2, load_config/2, get_sys_tuple/1, - get_target_dir/1, - get_root_dir/1, - get_target_parent_dir/1]). + get_target_dir/2, + get_root_dir/2, + get_target_parent_dir/2]). -include("rebar.hrl"). @@ -111,8 +111,8 @@ get_rel_file_path(Name, Path) -> filename:join([binary_to_list(BinDir), Name ++ ".rel"]). %% Get the previous release path from a global variable -get_previous_release_path() -> - case rebar_config:get_global(previous_release, false) of +get_previous_release_path(Config) -> + case rebar_config:get_global(Config, previous_release, false) of false -> ?ABORT("previous_release=PATH is required to " "create upgrade package~n", []); @@ -148,8 +148,8 @@ get_sys_tuple(ReltoolConfig) -> %% Look for {target_dir, TargetDir} in the reltool config file; if none is %% found, use the name of the release as the default target directory. %% -get_target_dir(ReltoolConfig) -> - case rebar_config:get_global(target_dir, undefined) of +get_target_dir(Config, ReltoolConfig) -> + case rebar_config:get_global(Config, target_dir, undefined) of undefined -> case lists:keyfind(target_dir, 1, ReltoolConfig) of {target_dir, TargetDir} -> @@ -167,8 +167,8 @@ get_target_dir(ReltoolConfig) -> filename:absname(TargetDir) end. -get_target_parent_dir(ReltoolConfig) -> - TargetDir = get_target_dir(ReltoolConfig), +get_target_parent_dir(Config, ReltoolConfig) -> + TargetDir = get_target_dir(Config, ReltoolConfig), case lists:reverse(tl(lists:reverse(filename:split(TargetDir)))) of [] -> "."; Components -> filename:join(Components) @@ -178,10 +178,10 @@ get_target_parent_dir(ReltoolConfig) -> %% Look for root_dir in sys tuple and command line; fall back to %% code:root_dir(). %% -get_root_dir(ReltoolConfig) -> +get_root_dir(Config, ReltoolConfig) -> {sys, SysInfo} = get_sys_tuple(ReltoolConfig), SysRootDirTuple = lists:keyfind(root_dir, 1, SysInfo), - CmdRootDir = rebar_config:get_global(root_dir, undefined), + CmdRootDir = rebar_config:get_global(Config, root_dir, undefined), case {SysRootDirTuple, CmdRootDir} of %% root_dir in sys typle and no root_dir on cmd-line {{root_dir, SysRootDir}, undefined} -> diff --git a/src/rebar_reltool.erl b/src/rebar_reltool.erl index 79b2a2a..93aec3e 100644 --- a/src/rebar_reltool.erl +++ b/src/rebar_reltool.erl @@ -67,11 +67,11 @@ generate(Config0, ReltoolFile) -> overlay(Config, ReltoolFile) -> %% Load the reltool configuration from the file {Config1, ReltoolConfig} = rebar_rel_utils:load_config(Config, ReltoolFile), - {Config1, process_overlay(ReltoolConfig)}. + {Config1, process_overlay(Config, ReltoolConfig)}. clean(Config, ReltoolFile) -> {Config1, ReltoolConfig} = rebar_rel_utils:load_config(Config, ReltoolFile), - TargetDir = rebar_rel_utils:get_target_dir(ReltoolConfig), + TargetDir = rebar_rel_utils:get_target_dir(Config, ReltoolConfig), rebar_file_utils:rm_rf(TargetDir), rebar_file_utils:delete_each(["reltool.spec"]), {ok, Config1}. @@ -98,8 +98,8 @@ check_vsn() -> end end. -process_overlay(ReltoolConfig) -> - TargetDir = rebar_rel_utils:get_target_dir(ReltoolConfig), +process_overlay(Config, ReltoolConfig) -> + TargetDir = rebar_rel_utils:get_target_dir(Config, ReltoolConfig), {_BootRelName, BootRelVsn} = rebar_rel_utils:get_reltool_release_info(ReltoolConfig), @@ -112,7 +112,7 @@ process_overlay(ReltoolConfig) -> {target_dir, TargetDir}]), %% Load up any variables specified by overlay_vars - OverlayVars1 = overlay_vars(OverlayVars0, ReltoolConfig), + OverlayVars1 = overlay_vars(Config, OverlayVars0, ReltoolConfig), OverlayVars = rebar_templater:resolve_variables(dict:to_list(OverlayVars1), OverlayVars1), @@ -135,9 +135,11 @@ process_overlay(ReltoolConfig) -> %% variable in the file from reltool.config and then override that value by %% providing an additional file on the command-line. %% -overlay_vars(Vars0, ReltoolConfig) -> +overlay_vars(Config, Vars0, ReltoolConfig) -> BaseVars = load_vars_file(proplists:get_value(overlay_vars, ReltoolConfig)), - OverrideVars = load_vars_file(rebar_config:get_global(overlay_vars, undefined)), + OverrideVars = load_vars_file(rebar_config:get_global(Config, + overlay_vars, + undefined)), M = fun(_Key, _Base, Override) -> Override end, dict:merge(M, dict:merge(M, Vars0, BaseVars), OverrideVars). @@ -189,18 +191,18 @@ app_exists(AppTuple, Server) when is_tuple(AppTuple) -> app_exists(element(1, AppTuple), Server). -run_reltool(Server, _Config, ReltoolConfig) -> +run_reltool(Server, Config, ReltoolConfig) -> case reltool:get_target_spec(Server) of {ok, Spec} -> %% Pull the target dir and make sure it exists - TargetDir = rebar_rel_utils:get_target_dir(ReltoolConfig), - mk_target_dir(TargetDir), + TargetDir = rebar_rel_utils:get_target_dir(Config, ReltoolConfig), + mk_target_dir(Config, TargetDir), %% Determine the otp root dir to use - RootDir = rebar_rel_utils:get_root_dir(ReltoolConfig), + RootDir = rebar_rel_utils:get_root_dir(Config, ReltoolConfig), %% Dump the spec, if necessary - dump_spec(Spec), + dump_spec(Config, Spec), %% Have reltool actually run case reltool:eval_target_spec(Spec, RootDir, TargetDir) of @@ -216,20 +218,20 @@ run_reltool(Server, _Config, ReltoolConfig) -> ok = create_RELEASES(TargetDir, BootRelName, BootRelVsn), - process_overlay(ReltoolConfig); + process_overlay(Config, ReltoolConfig); {error, Reason} -> ?ABORT("Unable to generate spec: ~s\n", [Reason]) end. -mk_target_dir(TargetDir) -> +mk_target_dir(Config, TargetDir) -> case filelib:ensure_dir(filename:join(TargetDir, "dummy")) of ok -> ok; {error, eexist} -> %% Output directory already exists; if force=1, wipe it out - case rebar_config:get_global(force, "0") of + case rebar_config:get_global(Config, force, "0") of "1" -> rebar_file_utils:rm_rf(TargetDir), ok = file:make_dir(TargetDir); @@ -245,8 +247,8 @@ mk_target_dir(TargetDir) -> end. -dump_spec(Spec) -> - case rebar_config:get_global(dump_spec, "0") of +dump_spec(Config, Spec) -> + case rebar_config:get_global(Config, dump_spec, "0") of "1" -> SpecBin = list_to_binary(io_lib:print(Spec, 1, 120, -1)), ok = file:write_file("reltool.spec", SpecBin); diff --git a/src/rebar_templater.erl b/src/rebar_templater.erl index 3273196..0e1eef1 100644 --- a/src/rebar_templater.erl +++ b/src/rebar_templater.erl @@ -43,16 +43,16 @@ %% Public API %% =================================================================== -'create-app'(_Config, _File) -> +'create-app'(Config, _File) -> %% Alias for create w/ template=simpleapp - create("simpleapp"). + create1(Config, "simpleapp"). -'create-node'(_Config, _File) -> +'create-node'(Config, _File) -> %% Alias for create w/ template=simplenode - create("simplenode"). + create1(Config, "simplenode"). -'list-templates'(_Config, _File) -> - {AvailTemplates, Files} = find_templates(), +'list-templates'(Config, _File) -> + {AvailTemplates, Files} = find_templates(Config), ?DEBUG("Available templates: ~p\n", [AvailTemplates]), lists:foreach( @@ -68,9 +68,9 @@ end, AvailTemplates), ok. -create(_Config, _) -> - TemplateId = template_id(), - create(TemplateId). +create(Config, _) -> + TemplateId = template_id(Config), + create1(Config, TemplateId). %% %% Given a list of key value pairs, for each string value attempt to @@ -98,8 +98,8 @@ render(Bin, Context) -> %% Internal functions %% =================================================================== -create(TemplateId) -> - {AvailTemplates, Files} = find_templates(), +create1(Config, TemplateId) -> + {AvailTemplates, Files} = find_templates(Config), ?DEBUG("Available templates: ~p\n", [AvailTemplates]), %% Using the specified template id, find the matching template file/type. @@ -130,7 +130,7 @@ create(TemplateId) -> end, %% Load variables from disk file, if provided - Context1 = case rebar_config:get_global(template_vars, undefined) of + Context1 = case rebar_config:get_global(Config, template_vars, undefined) of undefined -> Context0; File -> @@ -147,7 +147,7 @@ create(TemplateId) -> %% For each variable, see if it's defined in global vars -- if it is, %% prefer that value over the defaults - Context2 = update_vars(dict:fetch_keys(Context1), Context1), + Context2 = update_vars(Config, dict:fetch_keys(Context1), Context1), ?DEBUG("Template ~p context: ~p\n", [TemplateId, dict:to_list(Context1)]), %% Handle variables that possibly include other variables in their @@ -163,33 +163,34 @@ create(TemplateId) -> ?DEBUG("Final template def ~p: ~p\n", [TemplateId, FinalTemplate]), %% Execute the instructions in the finalized template - Force = rebar_config:get_global(force, "0"), + Force = rebar_config:get_global(Config, force, "0"), execute_template(Files, FinalTemplate, Type, Template, Context, Force, []). -find_templates() -> +find_templates(Config) -> %% Load a list of all the files in the escript -- cache them since %% we'll potentially need to walk it several times over the course of %% a run. - Files = cache_escript_files(), + Files = cache_escript_files(Config), %% Build a list of available templates - AvailTemplates = find_disk_templates() ++ find_escript_templates(Files), + AvailTemplates = find_disk_templates(Config) + ++ find_escript_templates(Files), {AvailTemplates, Files}. %% %% Scan the current escript for available files %% -cache_escript_files() -> +cache_escript_files(Config) -> {ok, Files} = rebar_utils:escript_foldl( fun(Name, _, GetBin, Acc) -> [{Name, GetBin()} | Acc] end, - [], rebar_config:get_global(escript, undefined)), + [], rebar_config:get_xconf(Config, escript)), Files. -template_id() -> - case rebar_config:get_global(template, undefined) of +template_id(Config) -> + case rebar_config:get_global(Config, template, undefined) of undefined -> ?ABORT("No template specified.\n", []); TemplateId -> @@ -201,16 +202,16 @@ find_escript_templates(Files) -> || {Name, _Bin} <- Files, re:run(Name, ?TEMPLATE_RE, [{capture, none}]) == match]. -find_disk_templates() -> - OtherTemplates = find_other_templates(), +find_disk_templates(Config) -> + OtherTemplates = find_other_templates(Config), HomeFiles = rebar_utils:find_files(filename:join([os:getenv("HOME"), ".rebar", "templates"]), ?TEMPLATE_RE), LocalFiles = rebar_utils:find_files(".", ?TEMPLATE_RE), [{file, F} || F <- OtherTemplates ++ HomeFiles ++ LocalFiles]. -find_other_templates() -> - case rebar_config:get_global(template_dir, undefined) of +find_other_templates(Config) -> + case rebar_config:get_global(Config, template_dir, undefined) of undefined -> []; TemplateDir -> @@ -253,11 +254,11 @@ parse_vars(Other, _Dict) -> %% Given a list of keys in Dict, see if there is a corresponding value defined %% in the global config; if there is, update the key in Dict with it %% -update_vars([], Dict) -> +update_vars(_Config, [], Dict) -> Dict; -update_vars([Key | Rest], Dict) -> - Value = rebar_config:get_global(Key, dict:fetch(Key, Dict)), - update_vars(Rest, dict:store(Key, Value, Dict)). +update_vars(Config, [Key | Rest], Dict) -> + Value = rebar_config:get_global(Config, Key, dict:fetch(Key, Dict)), + update_vars(Config, Rest, dict:store(Key, Value, Dict)). %% @@ -324,8 +325,8 @@ execute_template(_Files, [], _TemplateType, _TemplateName, _ -> Msg = lists:flatten([io_lib:format("\t* ~p~n", [F]) || F <- lists:reverse(ExistingFiles)]), - Help = - "To force overwriting, specify force=1 on the command line.\n", + Help = "To force overwriting, specify -f/--force/force=1" + " on the command line.\n", ?ERROR("One or more files already exist on disk and " "were not generated:~n~s~s", [Msg , Help]) end; diff --git a/src/rebar_upgrade.erl b/src/rebar_upgrade.erl index 3f7de03..14ea758 100644 --- a/src/rebar_upgrade.erl +++ b/src/rebar_upgrade.erl @@ -41,14 +41,16 @@ 'generate-upgrade'(Config0, ReltoolFile) -> %% Get the old release path {Config, ReltoolConfig} = rebar_rel_utils:load_config(Config0, ReltoolFile), - TargetParentDir = rebar_rel_utils:get_target_parent_dir(ReltoolConfig), - TargetDir = rebar_rel_utils:get_target_dir(ReltoolConfig), + TargetParentDir = rebar_rel_utils:get_target_parent_dir(Config, + ReltoolConfig), + TargetDir = rebar_rel_utils:get_target_dir(Config, ReltoolConfig), - OldVerPath = filename:join([TargetParentDir, - rebar_rel_utils:get_previous_release_path()]), + PrevRelPath = rebar_rel_utils:get_previous_release_path(Config), + OldVerPath = filename:join([TargetParentDir, PrevRelPath]), %% Run checks to make sure that building a package is possible - {NewVerPath, NewName, NewVer} = run_checks(OldVerPath, ReltoolConfig), + {NewVerPath, NewName, NewVer} = run_checks(Config, OldVerPath, + ReltoolConfig), NameVer = NewName ++ "_" ++ NewVer, %% Save the code path prior to doing anything @@ -78,7 +80,7 @@ %% Internal functions %% ================================================================== -run_checks(OldVerPath, ReltoolConfig) -> +run_checks(Config, OldVerPath, ReltoolConfig) -> true = rebar_utils:prop_check(filelib:is_dir(OldVerPath), "Release directory doesn't exist (~p)~n", [OldVerPath]), @@ -86,8 +88,9 @@ run_checks(OldVerPath, ReltoolConfig) -> {Name, Ver} = rebar_rel_utils:get_reltool_release_info(ReltoolConfig), NewVerPath = - filename:join([rebar_rel_utils:get_target_parent_dir(ReltoolConfig), - Name]), + filename:join( + [rebar_rel_utils:get_target_parent_dir(Config, ReltoolConfig), + Name]), true = rebar_utils:prop_check(filelib:is_dir(NewVerPath), "Release directory doesn't exist (~p)~n", [NewVerPath]), diff --git a/src/rebar_utils.erl b/src/rebar_utils.erl index be69acc..d608ee1 100644 --- a/src/rebar_utils.erl +++ b/src/rebar_utils.erl @@ -44,7 +44,7 @@ expand_env_variable/3, vcs_vsn/3, deprecated/3, deprecated/4, - get_deprecated_global/3, get_deprecated_global/4, + get_deprecated_global/4, get_deprecated_global/5, get_deprecated_list/4, get_deprecated_list/5, get_deprecated_local/4, get_deprecated_local/5, delayed_halt/1, @@ -200,7 +200,7 @@ expand_env_variable(InStr, VarName, RawVarValue) -> vcs_vsn(Config, Vcs, Dir) -> Key = {Vcs, Dir}, - {ok, Cache} = rebar_config:get_xconf(Config, vsn_cache), + Cache = rebar_config:get_xconf(Config, vsn_cache), case dict:find(Key, Cache) of error -> VsnString = vcs_vsn_1(Vcs, Dir), @@ -211,13 +211,13 @@ vcs_vsn(Config, Vcs, Dir) -> {Config, VsnString} end. -get_deprecated_global(OldOpt, NewOpt, When) -> - get_deprecated_global(OldOpt, NewOpt, undefined, When). +get_deprecated_global(Config, OldOpt, NewOpt, When) -> + get_deprecated_global(Config, OldOpt, NewOpt, undefined, When). -get_deprecated_global(OldOpt, NewOpt, Default, When) -> - case rebar_config:get_global(NewOpt, Default) of +get_deprecated_global(Config, OldOpt, NewOpt, Default, When) -> + case rebar_config:get_global(Config, NewOpt, Default) of Default -> - case rebar_config:get_global(OldOpt, Default) of + case rebar_config:get_global(Config, OldOpt, Default) of Default -> Default; Old -> @@ -291,7 +291,7 @@ delayed_halt(Code) -> erl_opts(Config) -> RawErlOpts = filter_defines(rebar_config:get(Config, erl_opts, []), []), GlobalDefines = [{d, list_to_atom(D)} || - D <- rebar_config:get_global(defines, [])], + D <- rebar_config:get_global(Config, defines, [])], Opts = GlobalDefines ++ RawErlOpts, case proplists:is_defined(no_debug_info, Opts) of true -> diff --git a/src/rebar_xref.erl b/src/rebar_xref.erl index 73afdf9..aa595f8 100644 --- a/src/rebar_xref.erl +++ b/src/rebar_xref.erl @@ -47,7 +47,7 @@ xref(Config, _) -> xref:set_default(xref, [{warnings, rebar_config:get(Config, xref_warnings, false)}, - {verbose, rebar_config:is_verbose()}]), + {verbose, rebar_config:is_verbose(Config)}]), {ok, _} = xref:add_directory(xref, "ebin"),