SisMaker
/
rebar3
1
0
Forka 0
Codice Problemi 0 Pull Requests 0 Projects 0 Rilasci 62 Wiki Attività
Sfoglia il codice sorgente

Merge pull request #83 from tsloughter/master 

overrides working except for transitive dep inheritance with lock file
pull/86/merge
Tristan Sloughter 10 anni fa
parent
038fb668e1 37a2025906
commit
1d38dcf4fe
5 ha cambiato i file con 182 aggiunte e 73 eliminazioni
Visualizzazione separata
Opzioni Diff
Mostra statistiche Scarica il file Patch Scarica il file Diff
  1. +4
    -1
      src/rebar3.erl
  2. +11
    -0
      src/rebar_app_info.erl
  3. +7
    -2
      src/rebar_prv_compile.erl
  4. +119
    -69
      src/rebar_prv_install_deps.erl
  5. +41
    -1
      src/rebar_state.erl

+ 4
- 1
src/rebar3.erl Vedi File

@ -142,7 +142,10 @@ init_config() ->
Config1 = case rebar_config:consult_file(?LOCK_FILE) of
[D] ->
[{locks, D}, {{deps, default}, D} | Config];
%% We want the top level deps only from the lock file.
%% This ensures deterministic overrides for configs.
Deps = [X || X <- D, element(3, X) =:= 0],
[{{locks, default}, D}, {{deps, default}, Deps} | Config];
_ ->
Config
end,

+ 11
- 0
src/rebar_app_info.erl Vedi File

@ -30,6 +30,8 @@
dir/2,
source/1,
source/2,
state/1,
state/2,
valid/1,
valid/2]).
@ -47,6 +49,7 @@
dep_level=0 :: integer(),
dir :: file:name(),
source :: string() | tuple() | undefined,
state :: rebar_state:t() | undefined,
valid :: boolean()}).
%%============================================================================
@ -211,6 +214,14 @@ source(AppInfo=#app_info_t{}, Source) ->
source(#app_info_t{source=Source}) ->
Source.
-spec state(t(), rebar_state:t() | undefined) -> t().
state(AppInfo=#app_info_t{}, State) ->
AppInfo#app_info_t{state=State}.
-spec state(t()) -> rebar_state:t() | undefined.
state(#app_info_t{state=State}) ->
State.
-spec valid(t()) -> boolean().
valid(AppInfo=#app_info_t{valid=undefined}) ->
rebar_app_discover:validate_application_info(AppInfo);

+ 7
- 2
src/rebar_prv_compile.erl Vedi File

@ -67,8 +67,13 @@ format_error(Reason) ->
build_apps(State, Apps) ->
lists:foreach(fun(AppInfo) ->
AppDir = rebar_app_info:dir(AppInfo),
C = rebar_config:consult(AppDir),
S = rebar_state:new(State, C, AppDir),
S = case rebar_app_info:state(AppInfo) of
undefined ->
C = rebar_config:consult(AppDir),
rebar_state:new(State, C, AppDir);
AppState ->
AppState
end,
%% Legacy hook support
rebar_hooks:run_compile_hooks(AppDir, pre_hooks, compile, S),

+ 119
- 69
src/rebar_prv_install_deps.erl Vedi File

@ -36,7 +36,8 @@
-include_lib("providers/include/providers.hrl").
-export([handle_deps/3,
handle_deps/4]).
handle_deps/4,
handle_deps/5]).
-export_type([dep/0]).
@ -74,10 +75,12 @@ do(State) ->
{SrcApps, State1} =
lists:foldl(fun(Profile, {SrcAppsAcc, StateAcc}) ->
Locks = rebar_state:get(StateAcc, {locks, Profile}, []),
{ok, NewSrcApps, NewState} =
handle_deps(Profile
,StateAcc
,rebar_state:get(StateAcc, {deps, Profile}, [])),
,rebar_state:get(StateAcc, {deps, Profile}, [])
,Locks),
{NewSrcApps++SrcAppsAcc, NewState}
end, {[], State}, lists:reverse(Profiles)),
@ -123,22 +126,29 @@ format_error(Reason) ->
-spec handle_deps(atom(), rebar_state:t(), list()) ->
{ok, [rebar_app_info:t()], rebar_state:t()} | {error, string()}.
handle_deps(Profile, State, Deps) ->
handle_deps(Profile, State, Deps, false).
handle_deps(Profile, State, Deps, false, []).
-spec handle_deps(atom(), rebar_state:t(), list(), boolean() | {true, binary(), integer()})
-spec handle_deps(atom(), rebar_state:t(), list(), list() | boolean()) ->
{ok, [rebar_app_info:t()], rebar_state:t()} | {error, string()}.
handle_deps(Profile, State, Deps, Update) when is_boolean(Update) ->
handle_deps(Profile, State, Deps, Update, []);
handle_deps(Profile, State, Deps, Locks) when is_list(Locks) ->
handle_deps(Profile, State, Deps, false, Locks).
-spec handle_deps(atom(), rebar_state:t(), list(), boolean() | {true, binary(), integer()}, list())
-> {ok, [rebar_app_info:t()], rebar_state:t()} | {error, string()}.
handle_deps(_Profile, State, [], _) ->
handle_deps(_Profile, State, [], _, _) ->
{ok, [], State};
handle_deps(Profile, State, Deps, Update) ->
handle_deps(Profile, State, Deps, Update, Locks) ->
%% Read in package index and dep graph
{Packages, Graph} = rebar_packages:get_packages(State),
%% Split source deps from pkg deps, needed to keep backwards compatibility
DepsDir = rebar_dir:deps_dir(State),
{SrcDeps, PkgDeps} = parse_deps(DepsDir, Deps),
{SrcDeps, PkgDeps} = parse_deps(DepsDir, Deps, State, Locks, 0),
%% Fetch transitive src deps
{State1, SrcApps, PkgDeps1, Seen} =
update_src_deps(Profile, 0, SrcDeps, PkgDeps, [], State, Update, sets:new()),
update_src_deps(Profile, 0, SrcDeps, PkgDeps, [], State, Update, sets:new(), Locks),
{Solved, State2} = case PkgDeps1 of
[] -> %% No pkg deps
@ -156,6 +166,7 @@ handle_deps(Profile, State, Deps, Update) ->
end,
update_pkg_deps(Profile, S, Packages, Update, Seen, State1)
end,
AllDeps = lists:ukeymerge(2
,lists:ukeysort(2, SrcApps)
,lists:ukeysort(2, Solved)),
@ -176,7 +187,7 @@ update_pkg_deps(Profile, Pkgs, Packages, Update, Seen, State) ->
AppInfo = package_to_app(DepsDir
,Packages
,Pkg),
{SeenAcc1, StateAcc1} = maybe_lock(Profile, AppInfo, SeenAcc, StateAcc),
{SeenAcc1, StateAcc1} = maybe_lock(Profile, AppInfo, SeenAcc, StateAcc, 0),
case maybe_fetch(AppInfo, Update, SeenAcc1) of
true ->
{[AppInfo | Acc], SeenAcc1, StateAcc1};
@ -186,14 +197,14 @@ update_pkg_deps(Profile, Pkgs, Packages, Update, Seen, State) ->
end, {[], Seen, State}, Pkgs),
{Solved, State1}.
maybe_lock(Profile, AppInfo, Seen, State) ->
maybe_lock(Profile, AppInfo, Seen, State, Level) ->
Name = rebar_app_info:name(AppInfo),
case Profile of
default ->
case sets:is_element(Name, Seen) of
false ->
{sets:add_element(Name, Seen),
rebar_state:lock(State, AppInfo)};
rebar_state:lock(State, rebar_app_info:dep_level(AppInfo, Level))};
true ->
{Seen, State}
end;
@ -215,17 +226,17 @@ package_to_app(DepsDir, Packages, {Name, Vsn}) ->
rebar_app_info:source(AppInfo2, {pkg, Name, Vsn, Link})
end.
-spec update_src_deps(atom(), non_neg_integer(), list(), list(), list(), rebar_state:t(), boolean(), sets:set(binary())) -> {rebar_state:t(), list(), list(), sets:set(binary())}.
update_src_deps(Profile, Level, SrcDeps, PkgDeps, SrcApps, State, Update, Seen) ->
case lists:foldl(fun(AppInfo, {SrcDepsAcc, PkgDepsAcc, SrcAppsAcc, StateAcc, SeenAcc}) ->
-spec update_src_deps(atom(), non_neg_integer(), list(), list(), list(), rebar_state:t(), boolean(), sets:set(binary()), list()) -> {rebar_state:t(), list(), list(), sets:set(binary())}.
update_src_deps(Profile, Level, SrcDeps, PkgDeps, SrcApps, State, Update, Seen, Locks) ->
case lists:foldl(fun(AppInfo, {SrcDepsAcc, PkgDepsAcc, SrcAppsAcc, StateAcc, SeenAcc, LocksAcc}) ->
%% If not seen, add to list of locks to write out
case sets:is_element(rebar_app_info:name(AppInfo), SeenAcc) of
true ->
warn_skip_deps(AppInfo),
{SrcDepsAcc, PkgDepsAcc, SrcAppsAcc, StateAcc, SeenAcc};
{SrcDepsAcc, PkgDepsAcc, SrcAppsAcc, StateAcc, SeenAcc, LocksAcc};
false ->
{SeenAcc1, StateAcc1} = maybe_lock(Profile, AppInfo, SeenAcc, StateAcc),
{SrcDepsAcc1, PkgDepsAcc1, SrcAppsAcc1, StateAcc2} =
{SeenAcc1, StateAcc1} = maybe_lock(Profile, AppInfo, SeenAcc, StateAcc, Level),
{SrcDepsAcc1, PkgDepsAcc1, SrcAppsAcc1, StateAcc2, LocksAcc1} =
case Update of
{true, UpdateName, UpdateLevel} ->
handle_update(AppInfo
@ -235,7 +246,8 @@ update_src_deps(Profile, Level, SrcDeps, PkgDeps, SrcApps, State, Update, Seen)
,PkgDepsAcc
,SrcAppsAcc
,Level
,StateAcc1);
,StateAcc1
,LocksAcc);
_ ->
maybe_fetch(AppInfo, false, SeenAcc1),
handle_dep(AppInfo
@ -243,22 +255,22 @@ update_src_deps(Profile, Level, SrcDeps, PkgDeps, SrcApps, State, Update, Seen)
,PkgDepsAcc
,SrcAppsAcc
,Level
,StateAcc1)
,StateAcc1
,LocksAcc)
end,
{SrcDepsAcc1, PkgDepsAcc1, SrcAppsAcc1, StateAcc2, SeenAcc1}
{SrcDepsAcc1, PkgDepsAcc1, SrcAppsAcc1, StateAcc2, SeenAcc1, LocksAcc1}
end
end,
{[], PkgDeps, SrcApps, State, Seen},
{[], PkgDeps, SrcApps, State, Seen, Locks},
lists:sort(SrcDeps)) of
{[], NewPkgDeps, NewSrcApps, State1, Seen1} ->
{[], NewPkgDeps, NewSrcApps, State1, Seen1, _NewLocks} ->
{State1, NewSrcApps, NewPkgDeps, Seen1};
{NewSrcDeps, NewPkgDeps, NewSrcApps, State1, Seen1} ->
update_src_deps(Profile, Level+1, NewSrcDeps, NewPkgDeps, NewSrcApps, State1, Update, Seen1)
{NewSrcDeps, NewPkgDeps, NewSrcApps, State1, Seen1, NewLocks} ->
update_src_deps(Profile, Level+1, NewSrcDeps, NewPkgDeps, NewSrcApps, State1, Update, Seen1, NewLocks)
end.
handle_update(AppInfo, UpdateName, UpdateLevel, SrcDeps, PkgDeps, SrcApps, Level, State) ->
handle_update(AppInfo, UpdateName, UpdateLevel, SrcDeps, PkgDeps, SrcApps, Level, State, Locks) ->
Name = rebar_app_info:name(AppInfo),
Locks = rebar_state:get(State, locks, []),
{_, _, _, DepLevel} = lists:keyfind(Name, 1, Locks),
case UpdateLevel < DepLevel
orelse Name =:= UpdateName of
@ -270,39 +282,52 @@ handle_update(AppInfo, UpdateName, UpdateLevel, SrcDeps, PkgDeps, SrcApps, Level
,PkgDeps
,SrcApps
,Level
,State);
,State
,Locks);
false ->
{SrcDeps, PkgDeps, SrcApps, State}
{SrcDeps, PkgDeps, SrcApps, State, Locks}
end;
false ->
{SrcDeps, PkgDeps, SrcApps, State}
{SrcDeps, PkgDeps, SrcApps, State, Locks}
end.
handle_dep(AppInfo, SrcDeps, PkgDeps, SrcApps, Level, State) ->
handle_dep(AppInfo, SrcDeps, PkgDeps, SrcApps, Level, State, Locks) ->
DepsDir = rebar_dir:deps_dir(State),
{AppInfo1, NewSrcDeps, NewPkgDeps} =
handle_dep(State, DepsDir, AppInfo),
{AppInfo1, NewSrcDeps, NewPkgDeps, NewLocks} =
handle_dep(State, DepsDir, AppInfo, Locks, Level),
AppInfo2 = rebar_app_info:dep_level(AppInfo1, Level),
{NewSrcDeps ++ SrcDeps
,NewPkgDeps++PkgDeps
,[AppInfo2 | SrcApps]
,State}.
,State
,NewLocks}.
-spec handle_dep(rebar_state:t(), file:filename_all(), rebar_app_info:t()) ->
-spec handle_dep(rebar_state:t(), file:filename_all(), rebar_app_info:t(), list(), integer()) ->
{rebar_app_info:t(), [rebar_app_info:t()], [pkg_dep()]}.
handle_dep(State, DepsDir, AppInfo) ->
handle_dep(State, DepsDir, AppInfo, Locks, Level) ->
Profiles = rebar_state:current_profiles(State),
Name = rebar_app_info:name(AppInfo),
C = rebar_config:consult(rebar_app_info:dir(AppInfo)),
S = rebar_state:new(rebar_state:new(), C, rebar_app_info:dir(AppInfo)),
S1 = rebar_state:apply_profiles(S, Profiles),
Deps = rebar_state:get(S1, deps, []),
AppInfo1 = rebar_app_info:deps(AppInfo, rebar_state:deps_names(Deps)),
{SrcDeps, PkgDeps} = parse_deps(DepsDir, Deps),
{AppInfo1, SrcDeps, PkgDeps}.
S = rebar_app_info:state(AppInfo),
S1 = rebar_state:new(S, C, rebar_app_info:dir(AppInfo)),
S2 = rebar_state:apply_profiles(S1, Profiles),
S3 = rebar_state:apply_overrides(S2, Name),
AppInfo1 = rebar_app_info:state(AppInfo, S3),
Deps = rebar_state:get(S3, deps, []),
%% Update lock level to be the level the dep will have in this dep tree
NewLocks = [{DepName, Source, LockLevel+Level} ||
{DepName, Source, LockLevel} <- rebar_state:get(S3, {locks, default}, [])],
AppInfo2 = rebar_app_info:deps(AppInfo1, rebar_state:deps_names(Deps)),
{SrcDeps, PkgDeps} = parse_deps(DepsDir, Deps, S3, Locks, Level),
{AppInfo2, SrcDeps, PkgDeps, Locks++NewLocks}.
-spec maybe_fetch(rebar_app_info:t(), boolean() | {true, binary(), integer()},
sets:set(binary())) -> boolean().
sets:set(binary())) -> boolean().
maybe_fetch(AppInfo, Update, Seen) ->
AppDir = ec_cnv:to_list(rebar_app_info:dir(AppInfo)),
Apps = rebar_app_discover:find_apps(["_checkouts"], all),
@ -355,39 +380,64 @@ maybe_fetch(AppInfo, Update, Seen) ->
end
end.
-spec parse_deps(binary(), list()) -> {[rebar_app_info:t()], [pkg_dep()]}.
parse_deps(DepsDir, Deps) ->
lists:foldl(fun({Name, Vsn}, {SrcDepsAcc, PkgDepsAcc}) when is_list(Vsn) ->
{SrcDepsAcc, [parse_goal(ec_cnv:to_binary(Name)
,ec_cnv:to_binary(Vsn)) | PkgDepsAcc]};
(Name, {SrcDepsAcc, PkgDepsAcc}) when is_atom(Name) ->
{SrcDepsAcc, [ec_cnv:to_binary(Name) | PkgDepsAcc]};
({Name, Source}, {SrcDepsAcc, PkgDepsAcc}) when is_tuple (Source) ->
Dep = new_dep(DepsDir, Name, [], Source),
{[Dep | SrcDepsAcc], PkgDepsAcc};
({Name, Source}, {SrcDepsAcc, PkgDepsAcc}) when is_tuple (Source) ->
Dep = new_dep(DepsDir, Name, [], Source),
{[Dep | SrcDepsAcc], PkgDepsAcc};
({Name, _Vsn, Source}, {SrcDepsAcc, PkgDepsAcc}) when is_tuple (Source) ->
Dep = new_dep(DepsDir, Name, [], Source),
{[Dep | SrcDepsAcc], PkgDepsAcc};
({Name, Source, Level}, {SrcDepsAcc, PkgDepsAcc}) when is_tuple (Source)
, is_integer(Level) ->
Dep = new_dep(DepsDir, Name, [], Source),
{[Dep | SrcDepsAcc], PkgDepsAcc}
-spec parse_deps(binary(), list(), list(), list(), integer()) -> {[rebar_app_info:t()], [pkg_dep()]}.
parse_deps(DepsDir, Deps, State, Locks, Level) ->
lists:foldl(fun(Dep, Acc) ->
Name = case Dep of
Dep when is_tuple(Dep) ->
element(1, Dep);
Dep ->
Dep
end,
case lists:keyfind(ec_cnv:to_binary(Name), 1, Locks) of
false ->
parse_dep(Dep, Acc, DepsDir, State);
LockedDep ->
LockedLevel = element(3, LockedDep),
case LockedLevel > Level of
true ->
parse_dep(Dep, Acc, DepsDir, State);
false ->
parse_dep(LockedDep, Acc, DepsDir, State)
end
end
end, {[], []}, Deps).
new_dep(DepsDir, Name, Vsn, Source) ->
Dirs = [ec_cnv:to_list(filename:join(DepsDir, Name))],
{ok, Dep} = case ec_lists:search(fun(Dir) ->
rebar_app_info:discover(Dir)
end, Dirs) of
{ok, App, _} ->
parse_dep({Name, Vsn}, {SrcDepsAcc, PkgDepsAcc}, _DepsDir, _State) when is_list(Vsn) ->
{SrcDepsAcc, [parse_goal(ec_cnv:to_binary(Name)
,ec_cnv:to_binary(Vsn)) | PkgDepsAcc]};
parse_dep(Name, {SrcDepsAcc, PkgDepsAcc}, _DepsDir, _State) when is_atom(Name) ->
{SrcDepsAcc, [ec_cnv:to_binary(Name) | PkgDepsAcc]};
parse_dep({Name, Source}, {SrcDepsAcc, PkgDepsAcc}, DepsDir, State) when is_tuple(Source) ->
Dep = new_dep(DepsDir, Name, [], Source, State),
{[Dep | SrcDepsAcc], PkgDepsAcc};
parse_dep({Name, Source}, {SrcDepsAcc, PkgDepsAcc}, DepsDir, State) when is_tuple(Source) ->
Dep = new_dep(DepsDir, Name, [], Source, State),
{[Dep | SrcDepsAcc], PkgDepsAcc};
parse_dep({Name, _Vsn, Source}, {SrcDepsAcc, PkgDepsAcc}, DepsDir, State) when is_tuple(Source) ->
Dep = new_dep(DepsDir, Name, [], Source, State),
{[Dep | SrcDepsAcc], PkgDepsAcc};
parse_dep({Name, Source, Level}, {SrcDepsAcc, PkgDepsAcc}, DepsDir, State) when is_tuple(Source)
, is_integer(Level) ->
Dep = new_dep(DepsDir, Name, [], Source, State),
{[Dep | SrcDepsAcc], PkgDepsAcc}.
new_dep(DepsDir, Name, Vsn, Source, State) ->
Dir = ec_cnv:to_list(filename:join(DepsDir, Name)),
{ok, Dep} = case rebar_app_info:discover(Dir) of
{ok, App} ->
{ok, App};
not_found ->
rebar_app_info:new(Name, Vsn, ec_cnv:to_list(filename:join(DepsDir, Name)))
end,
rebar_app_info:source(Dep, Source).
C = rebar_config:consult(rebar_app_info:dir(Dep)),
S = rebar_state:new(rebar_state:new(), C, rebar_app_info:dir(Dep)),
Overrides = rebar_state:get(State, overrides, []),
ParentOverrides = rebar_state:overrides(State),
Dep1 = rebar_app_info:state(Dep,
rebar_state:overrides(S, ParentOverrides++Overrides)),
rebar_app_info:source(Dep1, Source).
-spec parse_goal(binary(), binary()) -> pkg_dep().
parse_goal(Name, Constraint) ->

+ 41
- 1
src/rebar_state.erl Vedi File

@ -27,6 +27,9 @@
deps_names/1,
overrides/1, overrides/2,
apply_overrides/2,
prepend_hook/3, append_hook/3, hooks/2,
providers/1, providers/2, add_provider/2]).
@ -49,6 +52,7 @@
deps_to_build = [] :: [rebar_app_into:t()],
all_deps = [] :: [rebar_app_into:t()],
overrides = [],
providers = []}).
-export_type([t/0]).
@ -86,7 +90,8 @@ new(ParentState, Config, Dir) ->
Opts = ParentState#state_t.opts,
LocalOpts = case rebar_config:consult_file(filename:join(Dir, ?LOCK_FILE)) of
[D] ->
dict:from_list([{locks, D}, {{deps, default}, D} | Config]);
LockedDeps = [X || X <- D, element(3, X) =:= 0],
dict:from_list([{{locks, default}, LockedDeps}, {{deps, default}, D} | Config]);
_ ->
D = proplists:get_value(deps, Config, []),
dict:from_list([{{deps, default}, D} | Config])
@ -150,6 +155,35 @@ command_parsed_args(#state_t{command_parsed_args=CmdArgs}) ->
command_parsed_args(State, CmdArgs) ->
State#state_t{command_parsed_args=CmdArgs}.
apply_overrides(State=#state_t{overrides=Overrides}, AppName) ->
Name = binary_to_atom(AppName, utf8),
%% Inefficient. We want the order we get here though.
State1 = lists:foldl(fun({override, O}, StateAcc) ->
lists:foldl(fun({Key, Value}, StateAcc1) ->
rebar_state:set(StateAcc1, Key, Value)
end, StateAcc, O);
(_, StateAcc) ->
StateAcc
end, State, Overrides),
State2 = lists:foldl(fun({override, N, O}, StateAcc) when N =:= Name ->
lists:foldl(fun({Key, Value}, StateAcc1) ->
rebar_state:set(StateAcc1, Key, Value)
end, StateAcc, O);
(_, StateAcc) ->
StateAcc
end, State1, Overrides),
lists:foldl(fun({add, N, O}, StateAcc) when N =:= Name ->
lists:foldl(fun({Key, Value}, StateAcc1) ->
OldValue = rebar_state:get(StateAcc1, Key, []),
rebar_state:set(StateAcc1, Key, Value++OldValue)
end, StateAcc, O);
(_, StateAcc) ->
StateAcc
end, State2, Overrides).
apply_profiles(State, Profile) when not is_list(Profile) ->
apply_profiles(State, [Profile]);
apply_profiles(State, [default]) ->
@ -200,6 +234,12 @@ deps_names(State) ->
Deps = rebar_state:get(State, deps, []),
deps_names(Deps).
overrides(#state_t{overrides=Overrides}) ->
Overrides.
overrides(State=#state_t{}, Overrides) ->
State#state_t{overrides=Overrides}.
project_apps(#state_t{project_apps=Apps}) ->
Apps.

Scrivi Anteprima
Caricamento…
Annulla
Salva