Request 2210 (accepted)

erlang-rebar.spec Changed

0002-Unbundle-mustache.patch Changed

0003-Unbundle-getopt.patch Changed

0004-Allow-discarding-building-ports.patch Changed

0005-Check-system-wide-libdir-in-case-of-source-based-dep.patch Changed

0006-Remove-any-traces-of-long-time-obsolete-escript-fold.patch Changed

0007-Remove-abnfc-compiler-support-n-a-in-Fedora-EPEL.patch Changed

debian.changelog Changed

erlang-rebar.dsc Changed

rebar-2.6.1.tar.gz/.travis.yml -> rebar-2.6.4.tar.gz/.travis.yml Changed

rebar-2.6.1.tar.gz/README.md -> rebar-2.6.4.tar.gz/README.md Changed

rebar-2.6.1.tar.gz/RELEASE-NOTES.md -> rebar-2.6.4.tar.gz/RELEASE-NOTES.md Changed

@@ -1,3 +1,46 @@
+# 2.6.4
+
+* rebar/619: [Fix cdb processing when a file is skipped](https://github.com/rebar/rebar/pull/619)
+
+# 2.6.3
+
+* rebar/610: [qc: lift experimental notice](https://github.com/rebar/rebar/pull/610)
+* rebar/611: [port_compiler: consistently format default_env/0](https://github.com/rebar/rebar/pull/611)
+* rebar/612: [Introduce and use compat random number module](https://github.com/rebar/rebar/pull/612)
+* rebar/614: [Add an additional check for the existence of a 'rebar.beam' file](https://github.com/rebar/rebar/pull/614)
+* rebar/615: [port_compiler: generate clang compilation db](https://github.com/rebar/rebar/pull/615)
+* rebar/616: [port_compiler: clean up compile_each()](https://github.com/rebar/rebar/pull/616)
+* rebar/617: [port_compiler: auto-select C++ specific link template](https://github.com/rebar/rebar/pull/617)
+
+# 2.6.2
+
+* rebar/532: [Automatically clean neotoma-generated erl files, regression test](https://github.com/rebar/rebar/pull/532)
+* rebar/549: [Add Windows continuous integration through AppVeyor](https://github.com/rebar/rebar/pull/549)
+* rebar/551: [fprof: document Cachegrind support](https://github.com/rebar/rebar/pull/551)
+* rebar/556: [fprof: further document Cachegrind support](https://github.com/rebar/rebar/pull/556)
+* rebar/557: [Fix windows eunit tests](https://github.com/rebar/rebar/pull/557)
+* rebar/558: [Add qualified name tests docs (see pr #119)](https://github.com/rebar/rebar/pull/558)
+* rebar/560: [Lock retest dependency](https://github.com/rebar/rebar/pull/560)
+* rebar/562: [Add support for Windows integration testing](https://github.com/rebar/rebar/pull/562)
+* rebar/567: [Allow windows release to use etc conf dir](https://github.com/rebar/rebar/pull/567)
+* rebar/570: [xref: fix dialyzer warning introduced in 69802f63120](https://github.com/rebar/rebar/pull/570)
+* rebar/573: [Provide additional debug logging on relup generation](https://github.com/rebar/rebar/pull/573)
+* rebar/578: [Add the latest OTP 18 version to the Travis build](https://github.com/rebar/rebar/pull/578)
+* rebar/580: [Additional Common Test regression tests](https://github.com/rebar/rebar/pull/580)
+* rebar/581: [Update retest dependency url](https://github.com/rebar/rebar/pull/581)
+* rebar/586: [Ensure ebin created for dia compiler](https://github.com/rebar/rebar/pull/586)
+* rebar/587: [rebar_require_vsn: Update regexp to account for newer OTP versions](https://github.com/rebar/rebar/pull/587)
+* rebar/588: [Look for ct .spec files in the ct_dir that was specified](https://github.com/rebar/rebar/pull/588)
+* rebar/589: [Introduce REBAR_DEPS_PREFER_LIBS env variable to alter search behaviour](https://github.com/rebar/rebar/pull/589)
+* rebar/590: [Treat port env vars as expandable only if they self reference](https://github.com/rebar/rebar/pull/590)
+* rebar/591: [Fix/eunit tests surefire crash](https://github.com/rebar/rebar/pull/591)
+* rebar/594: [Introduce REBAR_VSN_CACHE_FILE env variable to load/save vsn cache](https://github.com/rebar/rebar/pull/594)
+* rebar/599: [Fix bug when running gcc in cross_sizeof](https://github.com/rebar/rebar/pull/599)
+* rebar/602: [Support full-source rebar3-style deps (deps without Version Regexes)](https://github.com/rebar/rebar/pull/602)
+* rebar/603: [add deprecated message](https://github.com/rebar/rebar/pull/603)
+* rebar/605: [Add necessary OSX flags for port driver linking](https://github.com/rebar/rebar/pull/605)
+* rebar/606: [Revert 'Treat port env vars as expandable only if they self reference'](https://github.com/rebar/rebar/pull/606)
+
 # 2.6.1
 
 * rebar/514: [Add license to relnotes tool per reviewer request](https://github.com/rebar/rebar/pull/514)

rebar-2.6.1.tar.gz/THANKS -> rebar-2.6.4.tar.gz/THANKS Changed

rebar-2.6.4.tar.gz/appveyor.yml Added

rebar-2.6.1.tar.gz/bootstrap -> rebar-2.6.4.tar.gz/bootstrap Changed

rebar-2.6.1.tar.gz/ebin/rebar.app -> rebar-2.6.4.tar.gz/ebin/rebar.app Changed

rebar-2.6.1.tar.gz/inttest/app_src/app_src_rt.erl -> rebar-2.6.4.tar.gz/inttest/app_src/app_src_rt.erl Changed

rebar-2.6.1.tar.gz/inttest/app_src_script/app_src_script_rt.erl -> rebar-2.6.4.tar.gz/inttest/app_src_script/app_src_script_rt.erl Changed

rebar-2.6.1.tar.gz/inttest/app_src_script_2/app_src_script_2_rt.erl -> rebar-2.6.4.tar.gz/inttest/app_src_script_2/app_src_script_2_rt.erl Changed

rebar-2.6.1.tar.gz/inttest/appup_src/appup_src_rt.erl -> rebar-2.6.4.tar.gz/inttest/appup_src/appup_src_rt.erl Changed

rebar-2.6.1.tar.gz/inttest/appup_src_2/appup_src_2_rt.erl -> rebar-2.6.4.tar.gz/inttest/appup_src_2/appup_src_2_rt.erl Changed

rebar-2.6.1.tar.gz/inttest/appup_src_2/appup_src_rt_2.erl -> rebar-2.6.4.tar.gz/inttest/appup_src_2/appup_src_rt_2.erl Changed

rebar-2.6.1.tar.gz/inttest/appup_src_script/appup_src_script_rt.erl -> rebar-2.6.4.tar.gz/inttest/appup_src_script/appup_src_script_rt.erl Changed

rebar-2.6.1.tar.gz/inttest/bug_5_rt.erl -> rebar-2.6.4.tar.gz/inttest/bug_5_rt.erl Changed

rebar-2.6.1.tar.gz/inttest/code_path_no_recurse/code_path_no_recurse_rt.erl -> rebar-2.6.4.tar.gz/inttest/code_path_no_recurse/code_path_no_recurse_rt.erl Changed

rebar-2.6.1.tar.gz/inttest/cover/cover_rt.erl -> rebar-2.6.4.tar.gz/inttest/cover/cover_rt.erl Changed

rebar-2.6.4.tar.gz/inttest/cross1 Added

rebar-2.6.4.tar.gz/inttest/cross1/c_src Added

rebar-2.6.4.tar.gz/inttest/cross1/c_src/test1.c Added

rebar-2.6.4.tar.gz/inttest/cross1/c_src/test1.h Added

rebar-2.6.4.tar.gz/inttest/cross1/cross1_rt.erl Added

@@ -0,0 +1,66 @@
+%% -*- erlang-indent-level: 4;indent-tabs-mode: nil -*-
+%% ex: ts=4 sw=4 et
+%% -------------------------------------------------------------------
+%%
+%% rebar: Erlang Build Tools
+%%
+%% Copyright (c) 2016 Luis Rascao
+%%
+%% Permission is hereby granted, free of charge, to any person obtaining a copy
+%% of this software and associated documentation files (the "Software"), to deal
+%% in the Software without restriction, including without limitation the rights
+%% to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+%% copies of the Software, and to permit persons to whom the Software is
+%% furnished to do so, subject to the following conditions:
+%%
+%% The above copyright notice and this permission notice shall be included in
+%% all copies or substantial portions of the Software.
+%%
+%% THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+%% IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+%% FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+%% AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+%% LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+%% OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+%% THE SOFTWARE.
+%% -------------------------------------------------------------------
+
+-module(cross1_rt).
+-export([files/0,
+         run/1]).
+
+-include_lib("eunit/include/eunit.hrl").
+
+setup([Target]) ->
+  retest_utils:load_module(filename:join(Target, "inttest_utils.erl")),
+  ok.
+
+files() ->
+    [
+     {copy, "c_src", "c_src"},
+     {create, "ebin/foo.app", app(foo, [])}
+    ] ++ inttest_utils:rebar_setup().
+
+run(_Dir) ->
+    %% we will now determine where gcc is located
+    %% create a symlink to it in the cwd and change the
+    %% rebar arch so that rebar is fooled into believing
+    %% it's doing cross compilation.
+    {ok, [_, GccLocation]} = retest_sh:run("which gcc", []),
+    {ok, _} = retest_sh:run(io_lib:format("ln -s ~s unknown-unknown-linux-gnu-gcc", [GccLocation]),
+                            []),
+    ?assertMatch({ok, _}, retest_sh:run("./rebar compile -vvv",
+                                        [{env, [{"PATH", "./:" ++ os:getenv("PATH")},
+                                                {"REBAR_TARGET_ARCH", "unknown-unknown-linux-gnu"}]}])).
+
+%%
+%% Generate the contents of a simple .app file
+%%
+app(Name, Modules) ->
+    App = {application, Name,
+           [{description, atom_to_list(Name)},
+            {vsn, "1"},
+            {modules, Modules},
+            {registered, []},
+            {applications, [kernel, stdlib]}]},
+    io_lib:format("~p.\n", [App]).

rebar-2.6.1.tar.gz/inttest/ct1/ct1_rt.erl -> rebar-2.6.4.tar.gz/inttest/ct1/ct1_rt.erl Changed

rebar-2.6.1.tar.gz/inttest/ct2/ct2_rt.erl -> rebar-2.6.4.tar.gz/inttest/ct2/ct2_rt.erl Changed

rebar-2.6.1.tar.gz/inttest/ct3/ct3_rt.erl -> rebar-2.6.4.tar.gz/inttest/ct3/ct3_rt.erl Changed

rebar-2.6.4.tar.gz/inttest/ct4 Added

rebar-2.6.4.tar.gz/inttest/ct4/ct4_rt.erl Added

@@ -0,0 +1,44 @@
+%% -*- erlang-indent-level: 4;indent-tabs-mode: nil -*-
+%% ex: ts=4 sw=4 et
+-module(ct4_rt).
+
+-compile(export_all).
+
+setup([Target]) ->
+  retest_utils:load_module(filename:join(Target, "inttest_utils.erl")),
+  ok.
+
+files() ->
+    [
+     {create, "ebin/foo.app", app(foo)},
+     {copy, "rebar.config", "rebar.config"},
+     {copy, "foo.test.spec", "test/foo.test.spec"},
+     {copy, "deps/bar.test.spec", "deps/bar.test.spec"},
+     {copy, "deps/bar.test.spec", "baz.test.spec"},
+     {copy, "foo_SUITE.erl", "test/foo_SUITE.erl"}
+    ] ++ inttest_utils:rebar_setup().
+
+run(_Dir) ->
+    Ref = retest:sh("./rebar compile ct -vvv", [async]),
+    {ok, [[CTRunCmd]]} = retest:sh_expect(Ref, "^\"ct_run.*",
+                                  [global, {capture, first, binary}]),
+    {match, _} = re:run(CTRunCmd, "foo.test.spec", [global]),
+    %% deps/bar.test.spec should be ignored by rebar_ct:collect_glob/3
+    nomatch = re:run(CTRunCmd, "bar.test.spec", [global]),
+    %% baz.test.spec should be also ignored by rebar_ct:collect_glob/3
+    %% since we specified in rebar.config that we want to search for
+    %% ct specs from the test dir
+    nomatch = re:run(CTRunCmd, "baz.test.spec", [global]),
+    ok.
+
+%%
+%% Generate the contents of a simple .app file
+%%
+app(Name) ->
+    App = {application, Name,
+           [{description, atom_to_list(Name)},
+            {vsn, "1"},
+            {modules, []},
+            {registered, []},
+            {applications, [kernel, stdlib]}]},
+    io_lib:format("~p.\n", [App]).

rebar-2.6.4.tar.gz/inttest/ct4/deps Added

rebar-2.6.4.tar.gz/inttest/ct4/deps/bar.test.spec Added

rebar-2.6.4.tar.gz/inttest/ct4/foo.test.spec Added

rebar-2.6.4.tar.gz/inttest/ct4/foo_SUITE.erl Added

rebar-2.6.4.tar.gz/inttest/ct4/rebar.config Added

rebar-2.6.1.tar.gz/inttest/ct_cover/ct_cover_rt.erl -> rebar-2.6.4.tar.gz/inttest/ct_cover/ct_cover_rt.erl Changed

rebar-2.6.4.tar.gz/inttest/ct_make_fails Added

rebar-2.6.4.tar.gz/inttest/ct_make_fails/app.config Added

rebar-2.6.4.tar.gz/inttest/ct_make_fails/ct_make_fails_rt.erl Added

rebar-2.6.4.tar.gz/inttest/ct_make_fails/rebar.config Added

rebar-2.6.4.tar.gz/inttest/ct_make_fails/test_SUITE.erl Added

rebar-2.6.4.tar.gz/inttest/ct_test_fails Added

rebar-2.6.4.tar.gz/inttest/ct_test_fails/app.config Added

rebar-2.6.4.tar.gz/inttest/ct_test_fails/ct_test_fails.test.spec Added

rebar-2.6.4.tar.gz/inttest/ct_test_fails/ct_test_fails_rt.erl Added

@@ -0,0 +1,33 @@
+%% -*- erlang-indent-level: 4;indent-tabs-mode: nil -*-
+%% ex: ts=4 sw=4 et
+-module(ct_test_fails_rt).
+
+-compile(export_all).
+
+
+files() ->
+    [{create, "ebin/a1.app", app(a1)},
+     {copy, "../../rebar", "rebar"},
+     {copy, "rebar.config", "rebar.config"},
+     {copy, "app.config", "app.config"},
+     {copy, "ct_test_fails.test.spec", "itest/ct_test_fails.test.spec"},
+     {copy, "test_SUITE.erl", "itest/test_SUITE.erl"},
+     {copy, "test2_SUITE.erl", "itest/test2_SUITE.erl"}].
+
+run(Dir) ->
+    ok = case catch retest:sh("./rebar compile ct -v 3") of
+                {error, {stopped, _}} -> ok;
+                _ -> expected_to_fail
+              end.
+
+%%
+%% Generate the contents of a simple .app file
+%%
+app(Name) ->
+    App = {application, Name,
+           [{description, atom_to_list(Name)},
+            {vsn, "1"},
+            {modules, []},
+            {registered, []},
+            {applications, [kernel, stdlib]}]},
+    io_lib:format("~p.\n", [App]).

rebar-2.6.4.tar.gz/inttest/ct_test_fails/rebar.config Added

rebar-2.6.4.tar.gz/inttest/ct_test_fails/test2_SUITE.erl Added

rebar-2.6.4.tar.gz/inttest/ct_test_fails/test_SUITE.erl Added

rebar-2.6.1.tar.gz/inttest/depplugins/depplugins_rt.erl -> rebar-2.6.4.tar.gz/inttest/depplugins/depplugins_rt.erl Changed

rebar-2.6.1.tar.gz/inttest/erlc/erlc_rt.erl -> rebar-2.6.4.tar.gz/inttest/erlc/erlc_rt.erl Changed

rebar-2.6.1.tar.gz/inttest/erlc_dep_graph/erlc_dep_graph_rt.erl -> rebar-2.6.4.tar.gz/inttest/erlc_dep_graph/erlc_dep_graph_rt.erl Changed

@@ -30,39 +30,57 @@
 
 -include_lib("eunit/include/eunit.hrl").
 
+setup([Target]) ->
+  retest_utils:load_module(filename:join(Target, "inttest_utils.erl")),
+  ok.
+
 files() ->
-    [{copy, "../../rebar", "rebar"},
+    [
      {copy, "rebar.config", "rebar.config"},
      {copy, "src", "src"},
      {copy, "include", "include"},
-     {copy, "extra_include", "extra_include"}].
+     {copy, "extra_include", "extra_include"}
+    ] ++ inttest_utils:rebar_setup().
 
 run(_Dir) ->
+    retest_log:log(debug, "compiling all...\n\n", []),
     compile_all(ok, ""),
+    retest_log:log(debug, "checking beams integrity...\n\n", []),
     check_beams_ok(),
     check_beams_untouched(filelib:wildcard("ebin/*.beam")),
+    retest_log:log(debug, "modifying lisp.erl and recompiling...\n\n", []),
     modify_and_recompile_ok("src/lisp.erl", "ebin/lisp.beam"),
 
+    retest_log:log(debug, "cleaning all...\n\n", []),
     clean_all_ok(),
+    retest_log:log(debug, "compiling all (expect fail)...\n\n", []),
     compile_all(error, "-C rebar.config.non-existing"),
+    retest_log:log(debug, "compiling all...\n\n", []),
     compile_all(ok, ""),
+    retest_log:log(debug, "modifying extra_include/extra.hrl and recompiling...\n\n", []),
     modify_and_recompile_ok("extra_include/extra.hrl", "ebin/java.beam"),
 
+    retest_log:log(debug, "rewriting src/java.erl...\n\n", []),
     Java = "src/java.erl",
     {ok, OrigContent} = file:read_file(Java),
     %% Remove header file inclusion
     {ok, _} = file:copy("src/java.erl.no_extra", Java),
     %% Ensure recompilation
     touch([Java]),
+    retest_log:log(debug, "compiling all...\n\n", []),
     compile_all(ok, ""),
     %% Modify that header file
+    retest_log:log(debug, "again modifying extra_include/extra.hrl and recompiling...\n\n", []),
     touch(["extra_include/extra.hrl"]),
     %% Ensure we don't have to recompile anything
+    retest_log:log(debug, "ensure ebin/java.beam was untouched...\n\n", []),
     check_beams_untouched(["ebin/java.beam"]),
     %% Clean up
+    retest_log:log(debug, "modifying src/java.erl...\n\n", []),
     ok = file:write_file(Java, OrigContent),
 
     %% Check that changes propagate deeply through the dependency tree
+    retest_log:log(debug, "modifying include/lambda.hrl...\n\n", []),
     modify_and_recompile_ok("include/lambda.hrl", "ebin/perl.beam"),
 
     ok.
@@ -82,7 +100,9 @@
     BeamsModifiedBefore = mtime_ns(Beams),
     compile_all(ok, ""),
     BeamsModifiedAfter = mtime_ns(Beams),
-    lists:zipwith(fun(Before, After) -> ?assert(Cmp(Before, After)) end,
+    lists:zipwith(fun(Before, After) ->
+                    ?assert(Cmp(Before, After))
+                  end,
                   BeamsModifiedBefore, BeamsModifiedAfter).
 
 with_erl_beams(F) ->
@@ -95,13 +115,13 @@
         filelib:wildcard("src/*.erl")).
 
 mtime_ns(Files) ->
-    [os:cmd("stat -c%y " ++ File) || File <- Files].
+    [calendar:datetime_to_gregorian_seconds(filelib:last_modified(File)) || File <- Files].
 
 touch(Files) ->
     %% Sleep one second so that filelib:last_modified/1 is guaranteed to notice
     %% that files have changed.
     ok = timer:sleep(1000),
-    [os:cmd("touch " ++ File) || File <- Files].
+    [file:change_time(File, calendar:local_time()) || File <- Files].
 
 compile_all(Result, Opts) ->
     ?assertMatch({Result, _},

rebar-2.6.1.tar.gz/inttest/eunit/eunit_rt.erl -> rebar-2.6.4.tar.gz/inttest/eunit/eunit_rt.erl Changed

rebar-2.6.4.tar.gz/inttest/eunit_surefire Added

rebar-2.6.4.tar.gz/inttest/eunit_surefire/eunit_src Added

rebar-2.6.4.tar.gz/inttest/eunit_surefire/eunit_src/bar.erl Added

rebar-2.6.4.tar.gz/inttest/eunit_surefire/eunit_surefire_rt.erl Added

@@ -0,0 +1,40 @@
+%% -*- erlang-indent-level: 4;indent-tabs-mode: nil -*-
+%% ex: ts=4 sw=4 et
+-module(eunit_surefire_rt).
+-export([files/0, run/1]).
+
+-include_lib("eunit/include/eunit.hrl").
+
+setup([Target]) ->
+  retest_utils:load_module(filename:join(Target, "inttest_utils.erl")),
+  ok.
+
+files() ->
+    [
+     {create, "ebin/foo.app", app(foo)},
+     {copy, "src", "src"},
+     {copy, "eunit_src", "eunit_src"},
+     {copy, "rebar.config"}
+    ] ++ inttest_utils:rebar_setup().
+
+run(_Dir) ->
+    {ok, Output} = retest:sh("./rebar -v eunit tests=bar"),
+    ?assert(check_output(Output, "bar_test")),
+    ok.
+
+check_output(Output, Target) ->
+    lists:any(fun(Line) ->
+                      string:str(Line, Target) > 0
+              end, Output).
+
+%%
+%% Generate the contents of a simple .app file
+%%
+app(Name) ->
+    App = {application, Name,
+           [{description, atom_to_list(Name)},
+            {vsn, "1"},
+            {modules, []},
+            {registered, []},
+            {applications, [kernel, stdlib]}]},
+    io_lib:format("~p.\n", [App]).

rebar-2.6.4.tar.gz/inttest/eunit_surefire/rebar.config Added

rebar-2.6.4.tar.gz/inttest/eunit_surefire/src Added

rebar-2.6.4.tar.gz/inttest/eunit_surefire/src/foo.erl Added

rebar-2.6.4.tar.gz/inttest/inttest_utils.erl Added

rebar-2.6.1.tar.gz/inttest/logging/logging_rt.erl -> rebar-2.6.4.tar.gz/inttest/logging/logging_rt.erl Changed

rebar-2.6.4.tar.gz/inttest/neotoma1 Added

rebar-2.6.4.tar.gz/inttest/neotoma1/mock Added

rebar-2.6.4.tar.gz/inttest/neotoma1/mock/neotoma Added

rebar-2.6.4.tar.gz/inttest/neotoma1/mock/neotoma/priv Added

rebar-2.6.4.tar.gz/inttest/neotoma1/mock/neotoma/priv/peg_includes.hrl Added

@@ -0,0 +1,253 @@
+-file("peg_includes.hrl", 1).
+-type index() :: {{line, pos_integer()}, {column, pos_integer()}}.
+-type input() :: binary().
+-type parse_failure() :: {fail, term()}.
+-type parse_success() :: {term(), input(), index()}.
+-type parse_result() :: parse_failure() | parse_success().
+-type parse_fun() :: fun((input(), index()) -> parse_result()).
+-type xform_fun() :: fun((input(), index()) -> term()).
+
+-spec p(input(), index(), atom(), parse_fun(), xform_fun()) -> parse_result().
+p(Inp, StartIndex, Name, ParseFun, TransformFun) ->
+  case get_memo(StartIndex, Name) of      % See if the current reduction is memoized
+    {ok, Memo} -> %Memo;                     % If it is, return the stored result
+      Memo;
+    _ ->                                        % If not, attempt to parse
+      Result = case ParseFun(Inp, StartIndex) of
+        {fail,_} = Failure ->                       % If it fails, memoize the failure
+          Failure;
+        {Match, InpRem, NewIndex} ->               % If it passes, transform and memoize the result.
+          Transformed = TransformFun(Match, StartIndex),
+          {Transformed, InpRem, NewIndex}
+      end,
+      memoize(StartIndex, Name, Result),
+      Result
+  end.
+
+-spec setup_memo() -> ets:tid().
+setup_memo() ->
+  put({parse_memo_table, ?MODULE}, ets:new(?MODULE, [set])).
+
+-spec release_memo() -> true.
+release_memo() ->
+  ets:delete(memo_table_name()).
+
+-spec memoize(index(), atom(), parse_result()) -> true.
+memoize(Index, Name, Result) ->
+  Memo = case ets:lookup(memo_table_name(), Index) of
+              [] -> [];
+              [{Index, Plist}] -> Plist
+         end,
+  ets:insert(memo_table_name(), {Index, [{Name, Result}|Memo]}).
+
+-spec get_memo(index(), atom()) -> {ok, term()} | {error, not_found}.
+get_memo(Index, Name) ->
+  case ets:lookup(memo_table_name(), Index) of
+    [] -> {error, not_found};
+    [{Index, Plist}] ->
+      case proplists:lookup(Name, Plist) of
+        {Name, Result}  -> {ok, Result};
+        _  -> {error, not_found}
+      end
+    end.
+
+-spec memo_table_name() -> ets:tid().
+memo_table_name() ->
+    get({parse_memo_table, ?MODULE}).
+
+-ifdef(p_eof).
+-spec p_eof() -> parse_fun().
+p_eof() ->
+  fun(<<>>, Index) -> {eof, [], Index};
+     (_, Index) -> {fail, {expected, eof, Index}} end.
+-endif.
+
+-ifdef(p_optional).
+-spec p_optional(parse_fun()) -> parse_fun().
+p_optional(P) ->
+  fun(Input, Index) ->
+      case P(Input, Index) of
+        {fail,_} -> {[], Input, Index};
+        {_, _, _} = Success -> Success
+      end
+  end.
+-endif.
+
+-ifdef(p_not).
+-spec p_not(parse_fun()) -> parse_fun().
+p_not(P) ->
+  fun(Input, Index)->
+      case P(Input,Index) of
+        {fail,_} ->
+          {[], Input, Index};
+        {Result, _, _} -> {fail, {expected, {no_match, Result},Index}}
+      end
+  end.
+-endif.
+
+-ifdef(p_assert).
+-spec p_assert(parse_fun()) -> parse_fun().
+p_assert(P) ->
+  fun(Input,Index) ->
+      case P(Input,Index) of
+        {fail,_} = Failure-> Failure;
+        _ -> {[], Input, Index}
+      end
+  end.
+-endif.
+
+-ifdef(p_seq).
+-spec p_seq([parse_fun()]) -> parse_fun().
+p_seq(P) ->
+  fun(Input, Index) ->
+      p_all(P, Input, Index, [])
+  end.
+
+-spec p_all([parse_fun()], input(), index(), [term()]) -> parse_result().
+p_all([], Inp, Index, Accum ) -> {lists:reverse( Accum ), Inp, Index};
+p_all([P|Parsers], Inp, Index, Accum) ->
+  case P(Inp, Index) of
+    {fail, _} = Failure -> Failure;
+    {Result, InpRem, NewIndex} -> p_all(Parsers, InpRem, NewIndex, [Result|Accum])
+  end.
+-endif.
+
+-ifdef(p_choose).
+-spec p_choose([parse_fun()]) -> parse_fun().
+p_choose(Parsers) ->
+  fun(Input, Index) ->
+      p_attempt(Parsers, Input, Index, none)
+  end.
+
+-spec p_attempt([parse_fun()], input(), index(), none | parse_failure()) -> parse_result().
+p_attempt([], _Input, _Index, Failure) -> Failure;
+p_attempt([P|Parsers], Input, Index, FirstFailure)->
+  case P(Input, Index) of
+    {fail, _} = Failure ->
+      case FirstFailure of
+        none -> p_attempt(Parsers, Input, Index, Failure);
+        _ -> p_attempt(Parsers, Input, Index, FirstFailure)
+      end;
+    Result -> Result
+  end.
+-endif.
+
+-ifdef(p_zero_or_more).
+-spec p_zero_or_more(parse_fun()) -> parse_fun().
+p_zero_or_more(P) ->
+  fun(Input, Index) ->
+      p_scan(P, Input, Index, [])
+  end.
+-endif.
+
+-ifdef(p_one_or_more).
+-spec p_one_or_more(parse_fun()) -> parse_fun().
+p_one_or_more(P) ->
+  fun(Input, Index)->
+      Result = p_scan(P, Input, Index, []),
+      case Result of
+        {[_|_], _, _} ->
+          Result;
+        _ ->
+          {fail, {expected, Failure, _}} = P(Input,Index),
+          {fail, {expected, {at_least_one, Failure}, Index}}
+      end
+  end.
+-endif.
+
+-ifdef(p_label).
+-spec p_label(atom(), parse_fun()) -> parse_fun().
+p_label(Tag, P) ->
+  fun(Input, Index) ->
+      case P(Input, Index) of
+        {fail,_} = Failure ->
+           Failure;
+        {Result, InpRem, NewIndex} ->
+          {{Tag, Result}, InpRem, NewIndex}
+      end
+  end.
+-endif.
+
+-ifdef(p_scan).
+-spec p_scan(parse_fun(), input(), index(), [term()]) -> {[term()], input(), index()}.
+p_scan(_, <<>>, Index, Accum) -> {lists:reverse(Accum), <<>>, Index};
+p_scan(P, Inp, Index, Accum) ->
+  case P(Inp, Index) of
+    {fail,_} -> {lists:reverse(Accum), Inp, Index};
+    {Result, InpRem, NewIndex} -> p_scan(P, InpRem, NewIndex, [Result | Accum])
+  end.
+-endif.
+
+-ifdef(p_string).
+-spec p_string(binary()) -> parse_fun().
+p_string(S) ->
+    Length = erlang:byte_size(S),
+    fun(Input, Index) ->
+      try
+          <<S:Length/binary, Rest/binary>> = Input,
+          {S, Rest, p_advance_index(S, Index)}
+      catch
+          error:{badmatch,_} -> {fail, {expected, {string, S}, Index}}
+      end
+    end.
+-endif.
+
+-ifdef(p_anything).
+-spec p_anything() -> parse_fun().
+p_anything() ->
+  fun(<<>>, Index) -> {fail, {expected, any_character, Index}};
+     (Input, Index) when is_binary(Input) ->
+          <<C/utf8, Rest/binary>> = Input,
+          {<<C/utf8>>, Rest, p_advance_index(<<C/utf8>>, Index)}
+  end.
+-endif.
+
+-ifdef(p_charclass).
+-spec p_charclass(string() | binary()) -> parse_fun().
+p_charclass(Class) ->
+    {ok, RE} = re:compile(Class, [unicode, dotall]),
+    fun(Inp, Index) ->
+            case re:run(Inp, RE, [anchored]) of
+                {match, [{0, Length}|_]} ->
+                    {Head, Tail} = erlang:split_binary(Inp, Length),
+                    {Head, Tail, p_advance_index(Head, Index)};
+                _ -> {fail, {expected, {character_class, binary_to_list(Class)}, Index}}
+            end
+    end.
+-endif.
+
+-ifdef(p_regexp).
+-spec p_regexp(binary()) -> parse_fun().
+p_regexp(Regexp) ->
+    {ok, RE} = re:compile(Regexp, [unicode, dotall, anchored]),
+    fun(Inp, Index) ->
+        case re:run(Inp, RE) of
+            {match, [{0, Length}|_]} ->
+                {Head, Tail} = erlang:split_binary(Inp, Length),
+                {Head, Tail, p_advance_index(Head, Index)};
+            _ -> {fail, {expected, {regexp, binary_to_list(Regexp)}, Index}}
+        end
+    end.
+-endif.
+
+-ifdef(line).
+-spec line(index() | term()) -> pos_integer() | undefined.
+line({{line,L},_}) -> L;
+line(_) -> undefined.
+-endif.
+
+-ifdef(column).
+-spec column(index() | term()) -> pos_integer() | undefined.
+column({_,{column,C}}) -> C;
+column(_) -> undefined.
+-endif.
+
+-spec p_advance_index(input() | unicode:charlist() | pos_integer(), index()) -> index().
+p_advance_index(MatchedInput, Index) when is_list(MatchedInput) orelse is_binary(MatchedInput)-> % strings
+  lists:foldl(fun p_advance_index/2, Index, unicode:characters_to_list(MatchedInput));
+p_advance_index(MatchedInput, Index) when is_integer(MatchedInput) -> % single characters
+  {{line, Line}, {column, Col}} = Index,
+  case MatchedInput of
+    $\n -> {{line, Line+1}, {column, 1}};
+    _ -> {{line, Line}, {column, Col+1}}
+  end.

rebar-2.6.4.tar.gz/inttest/neotoma1/mock/neotoma/src Added

rebar-2.6.4.tar.gz/inttest/neotoma1/mock/neotoma/src/neotoma.app.src Added

rebar-2.6.4.tar.gz/inttest/neotoma1/mock/neotoma/src/neotoma.erl Added

@@ -0,0 +1,145 @@
+-module(neotoma).
+-author("Sean Cribbs <seancribbs@gmail.com>").
+-export([file/1, file/2, bootstrap/0]).
+-export([main/1]).
+
+-define(ALL_COMBINATORS, [p_eof, p_optional, p_not, p_assert, p_seq,
+        p_choose, p_zero_or_more, p_one_or_more, p_label, p_scan,
+        p_string, p_anything, p_charclass, p_regexp, line, column]).
+
+-type option() :: {module, atom()} | {output, file:filename()} |  {transform_module, atom()} |
+                  {neotoma_priv_dir, file:filename()}.
+
+%% @doc Handler function for escript.
+-spec main(list()) -> ok | no_return().
+main([]) ->
+    io:format("Usage: neotoma filename [-module output_module] [-output output_dir] [-transform_module transform_module]\n");
+main([Filename | Args]) ->
+    %% code:priv_dir is unreliable when called in escript context, but
+    %% escript:script_name does what we want.
+    PrivDir = filename:join([filename:dirname(escript:script_name()), "priv"]),
+    file(Filename, [{neotoma_priv_dir, PrivDir} | parse_options(Args)]).
+
+%% @doc Generates a parser from the specified file.
+%% @equiv file(Filename, [])
+-spec file(file:filename()) -> ok | {error, atom()}.
+file(InputGrammar) ->
+    file(InputGrammar, []).
+
+%% @doc Generates a parser from the specified file with the given options.
+-spec file(file:filename(), [option()]) -> ok | {error, atom()}.
+file(InputGrammar, Options) ->
+    Basename = filename:basename(InputGrammar, ".peg"),
+    InputDir = filename:dirname(InputGrammar),
+    ModuleName = proplists:get_value(module, Options, list_to_atom(Basename)),
+    OutputDir = proplists:get_value(output, Options, InputDir),
+    OutputFilename = filename:join(OutputDir, atom_to_list(ModuleName) ++ ".erl"),
+    TransformModule = proplists:get_value(transform_module, Options, false),
+    validate_params(filename:absname(InputGrammar),
+                    ModuleName,
+                    TransformModule,
+                    filename:absname(OutputFilename)),
+    Parsed = parse_grammar(InputGrammar),
+    Rules = proplists:get_value(rules, Parsed),
+    Root = proplists:get_value(root, Parsed),
+    Code = proplists:get_value(code, Parsed),
+    GenTransform = proplists:get_value(transform, Parsed),
+    Combinators = proplists:get_value(combinators, Parsed, ?ALL_COMBINATORS),
+    ModuleAttrs = generate_module_attrs(ModuleName, Combinators),
+    EntryFuns = generate_entry_functions(Root),
+    TransformFun = create_transform(TransformModule, OutputDir, GenTransform),
+    PrivDir = proplists:get_value(neotoma_priv_dir, Options, code:priv_dir(neotoma)),
+    {ok, PegIncludes} = file:read_file(filename:join([PrivDir, "peg_includes.hrl"])),
+    file:write_file(OutputFilename, [ModuleAttrs, "\n", Code, "\n", EntryFuns, "\n", Rules, "\n", TransformFun, "\n", PegIncludes]).
+
+-spec validate_params(file:filename(),atom(),atom(),file:filename()) -> 'ok'.
+validate_params(InputGrammar, _, _, OutputFile) when InputGrammar =:= OutputFile ->
+    throw({badarg, "Input and output file are the same!"});
+validate_params(_,_, false, _) -> ok;
+validate_params(_,_, TransformModule, _) when not is_atom(TransformModule) ->
+    throw({badarg, "transform_module option must be an atom"});
+validate_params(_,Basename, TransformModule, _) when Basename =:= TransformModule ->
+    throw({badarg, "Transform module named same as parser module!"});
+validate_params(_,_, TransformModule, OutputFile) ->
+    OutMod = list_to_atom(filename:basename(OutputFile, ".erl")),
+    case OutMod of
+        TransformModule -> throw({badarg, "Transform module file same as parser output file!"});
+        _ -> ok
+    end.
+
+-spec generate_module_attrs(atom(), [atom()]) -> iolist().
+generate_module_attrs(ModName, Combinators) ->
+    ["-module(", atom_to_list(ModName) ,").\n",
+     "-export([parse/1,file/1]).\n",
+     [ generate_combinator_macro(C) || Combinators /= undefined, C <- Combinators ],
+     "\n"
+     ].
+
+generate_combinator_macro(C) ->
+    ["-define(", atom_to_list(C), ",true).\n"].
+
+-spec generate_entry_functions({iodata(),_}) -> iolist().
+generate_entry_functions(Root) ->
+    {RootRule,_} = Root,
+     ["-spec file(file:name()) -> any().\n",
+     "file(Filename) -> case file:read_file(Filename) of {ok,Bin} -> parse(Bin); Err -> Err end.\n\n",
+     "-spec parse(binary() | list()) -> any().\n",
+     "parse(List) when is_list(List) -> parse(unicode:characters_to_binary(List));\n",
+     "parse(Input) when is_binary(Input) ->\n",
+     "  _ = setup_memo(),\n",
+     "  Result = case '",RootRule,"'(Input,{{line,1},{column,1}}) of\n",
+     "             {AST, <<>>, _Index} -> AST;\n",
+     "             Any -> Any\n"
+     "           end,\n",
+     "  release_memo(), Result.\n"].
+
+-spec parse_grammar(file:filename()) -> any().
+parse_grammar(InputFile) ->
+    case neotoma_parse:file(InputFile) of
+        {fail, Index} ->
+            throw({grammar_error, {fail, Index}});
+        {Parsed, Remainder, Index} ->
+            io:format("WARNING: Grammar parse ended unexpectedly at ~p, generated parser may be incorrect.~nRemainder:~n~p",
+                      [Index, Remainder]),
+            Parsed;
+        L when is_list(L) -> L;
+        _ -> throw({error, {unknown, grammar, InputFile}})
+    end.
+
+-spec create_transform(atom() | boolean(),file:filename(),_) -> iolist().
+create_transform(_,_,[]) -> [];
+create_transform(false,_,_) ->
+    "transform(_,Node,_Index) -> Node.";
+create_transform(ModName,Dir,_) when is_atom(ModName) ->
+    XfFile = filename:join(Dir, atom_to_list(ModName) ++ ".erl"),
+    case filelib:is_regular(XfFile) of
+        true -> io:format("'~s' already exists, skipping generation.~n", [XfFile]);
+        false -> generate_transform_stub(XfFile, ModName)
+    end,
+    ["transform(Symbol,Node,Index) -> ",atom_to_list(ModName),":transform(Symbol, Node, Index)."].
+
+-spec generate_transform_stub(file:filename(), atom()) -> 'ok' | {'error',atom()}.
+generate_transform_stub(XfFile,ModName) ->
+    Data = ["-module(",atom_to_list(ModName),").\n",
+            "-export([transform/3]).\n\n",
+            "%% Add clauses to this function to transform syntax nodes\n",
+            "%% from the parser into semantic output.\n",
+            "transform(Symbol, Node, _Index) when is_atom(Symbol) ->\n  Node."],
+    file:write_file(XfFile, Data).
+
+%% @doc Bootstraps the neotoma metagrammar.  Intended only for internal development!
+%% @equiv file("src/neotoma_parse.peg")
+-spec bootstrap() -> 'ok'.
+bootstrap() ->
+    file("priv/neotoma_parse.peg", [{output, "src/"}, {neotoma_priv_dir, "priv"}]).
+
+%% @doc Parses arguments passed to escript
+-spec parse_options(list()) -> list().
+parse_options(["-module", ModName | Rest]) ->
+    [{module, list_to_atom(ModName)} | parse_options(Rest)];
+parse_options(["-output", Dir | Rest]) ->
+    [{output, Dir} | parse_options(Rest)];
+parse_options(["-transform_module", ModName | Rest]) ->
+    [{transform_module, list_to_atom(ModName)} | parse_options(Rest)];
+parse_options([]) ->
+    [].

rebar-2.6.4.tar.gz/inttest/neotoma1/mock/neotoma/src/neotoma_parse.erl Added

@@ -0,0 +1,625 @@
+-module(neotoma_parse).
+-export([parse/1,file/1]).
+-define(p_anything,true).
+-define(p_charclass,true).
+-define(p_choose,true).
+-define(p_label,true).
+-define(p_not,true).
+-define(p_one_or_more,true).
+-define(p_optional,true).
+-define(p_scan,true).
+-define(p_seq,true).
+-define(p_string,true).
+-define(p_zero_or_more,true).
+
+
+
+% insert escapes into a string
+-spec escape_string(string()) -> string().
+escape_string(String) -> escape_string(String, []).
+
+-spec escape_string(string(), string()) -> string().
+escape_string([], Output) ->
+  lists:reverse(Output);
+escape_string([H|T], Output) ->
+  escape_string(T,
+    case H of
+        $/  -> [$/,$\\|Output];
+        $\" -> [$\",$\\|Output];     % " comment inserted to help some editors with highlighting the generated parser
+        $\' -> [$\',$\\|Output];     % ' comment inserted to help some editors with highlighting the generated parser
+        $\b -> [$b,$\\|Output];
+        $\d -> [$d,$\\|Output];
+        $\e -> [$e,$\\|Output];
+        $\f -> [$f,$\\|Output];
+        $\n -> [$n,$\\|Output];
+        $\r -> [$r,$\\|Output];
+        $\s -> [$s,$\\|Output];
+        $\t -> [$t,$\\|Output];
+        $\v -> [$v,$\\|Output];
+        _   -> [H|Output]
+    end).
+
+-spec add_lhs(binary(), index()) -> true.
+add_lhs(Symbol, Index) ->
+  case ets:lookup(memo_table_name(), lhs) of
+    [] ->
+      ets:insert(memo_table_name(), {lhs, [{Symbol,Index}]});
+    [{lhs, L}] when is_list(L) ->
+      ets:insert(memo_table_name(), {lhs, [{Symbol,Index}|L]})
+  end.
+
+-spec add_nt(binary(), index()) -> true | ok.
+add_nt(Symbol, Index) ->
+  case ets:lookup(memo_table_name(), nts) of
+    [] ->
+      ets:insert(memo_table_name(), {nts, [{Symbol,Index}]});
+    [{nts, L}] when is_list(L) ->
+      case proplists:is_defined(Symbol, L) of
+        true ->
+          ok;
+        _ ->
+          ets:insert(memo_table_name(), {nts, [{Symbol,Index}|L]})
+      end
+  end.
+
+-spec verify_rules() -> ok | no_return().
+verify_rules() ->
+  [{lhs, LHS}] = ets:lookup(memo_table_name(), lhs),
+  [{nts, NTs}] = ets:lookup(memo_table_name(), nts),
+  [Root|NonRoots] = lists:reverse(LHS),
+  lists:foreach(fun({Sym,Idx}) ->
+                    case proplists:is_defined(Sym, NTs) of
+                      true ->
+                        ok;
+                      _ ->
+                        io:format("neotoma warning: rule '~s' is unused. ~p~n", [Sym,Idx])
+                    end
+                end, NonRoots),
+  lists:foreach(fun({S,I}) ->
+                    case proplists:is_defined(S, LHS) of
+                      true ->
+                        ok;
+                      _ ->
+                        io:format("neotoma error: nonterminal '~s' has no reduction. (found at ~p) No parser will be generated!~n", [S,I]),
+                        exit({neotoma, {no_reduction, list_to_atom(binary_to_list(S))}})
+                    end
+                end, NTs),
+    Root.
+
+-spec used_combinator(atom()) -> true.
+used_combinator(C) ->
+    case ets:lookup(memo_table_name(), combinators) of
+        [] ->
+            ets:insert(memo_table_name(), {combinators, ordsets:from_list([C])});
+        [{combinators, Cs}] ->
+            ets:insert(memo_table_name(), {combinators, ordsets:add_element(C, Cs)})
+    end.
+
+-spec used_transform_variables(binary()) -> [ 'Node' | 'Idx' ].
+used_transform_variables(Transform) ->
+  Code = unicode:characters_to_list(Transform),
+  {ok, Tokens, _} = erl_scan:string(Code),
+  used_transform_variables(Tokens, []).
+
+used_transform_variables([{var, _, Name}|Tokens], Acc) ->
+  used_transform_variables(Tokens, case Name of
+                                    'Node' -> [Name | Acc];
+                                    'Idx'  -> [Name | Acc];
+                                    _      -> Acc
+                                  end);
+used_transform_variables([_|Tokens], Acc) ->
+  used_transform_variables(Tokens, Acc);
+used_transform_variables([], Acc) ->
+  lists:usort(Acc).
+
+-spec file(file:name()) -> any().
+file(Filename) -> case file:read_file(Filename) of {ok,Bin} -> parse(Bin); Err -> Err end.
+
+-spec parse(binary() | list()) -> any().
+parse(List) when is_list(List) -> parse(unicode:characters_to_binary(List));
+parse(Input) when is_binary(Input) ->
+  _ = setup_memo(),
+  Result = case 'rules'(Input,{{line,1},{column,1}}) of
+             {AST, <<>>, _Index} -> AST;
+             Any -> Any
+           end,
+  release_memo(), Result.
+
+-spec 'rules'(input(), index()) -> parse_result().
+'rules'(Input, Index) ->
+  p(Input, Index, 'rules', fun(I,D) -> (p_seq([p_optional(fun 'space'/2), fun 'declaration_sequence'/2, p_optional(fun 'space'/2), p_optional(fun 'code_block'/2), p_optional(fun 'space'/2)]))(I,D) end, fun(Node, _Idx) ->
+  RootRule = verify_rules(),
+  Rules = unicode:characters_to_binary(lists:map(fun(R) -> [R, "\n\n"] end, lists:nth(2, Node))),
+  Code = case lists:nth(4, Node) of
+             {code, Block} -> Block;
+             _ -> []
+         end,
+  [{rules, Rules},
+   {code, Code},
+   {root, RootRule},
+   {transform, ets:lookup(memo_table_name(),gen_transform)},
+   {combinators, ets:lookup_element(memo_table_name(), combinators, 2)}]
+
+ end).
+
+-spec 'declaration_sequence'(input(), index()) -> parse_result().
+'declaration_sequence'(Input, Index) ->
+  p(Input, Index, 'declaration_sequence', fun(I,D) -> (p_seq([p_label('head', fun 'declaration'/2), p_label('tail', p_zero_or_more(p_seq([fun 'space'/2, fun 'declaration'/2])))]))(I,D) end, fun(Node, _Idx) ->
+  FirstRule = proplists:get_value(head, Node),
+  OtherRules =  [I || [_,I] <- proplists:get_value(tail, Node, [])],
+  [FirstRule|OtherRules]
+ end).
+
+-spec 'declaration'(input(), index()) -> parse_result().
+'declaration'(Input, Index) ->
+  p(Input, Index, 'declaration', fun(I,D) -> (p_seq([fun 'nonterminal'/2, p_zero_or_more(fun 'space'/2), p_string(<<"<-">>), p_zero_or_more(fun 'space'/2), fun 'parsing_expression'/2, p_optional(fun 'space'/2), p_optional(fun 'code_block'/2), p_optional(fun 'space'/2), p_string(<<";">>)]))(I,D) end, fun(Node, _Idx) ->
+  [{nonterminal,Symbol}|Tail] = Node,
+  add_lhs(Symbol, Index),
+  Transform = case lists:nth(6,Tail) of
+                  {code, CodeBlock} -> CodeBlock;
+                  _ ->
+                      ets:insert_new(memo_table_name(),{gen_transform, true}),
+                      ["transform('",Symbol,"', Node, Idx)"]
+                  end,
+  TransformArgs = case used_transform_variables(Transform) of
+    []              -> "_Node, _Idx";
+    ['Idx']         -> "_Node, Idx";
+    ['Node']        -> "Node, _Idx";
+    ['Idx', 'Node'] -> "Node, Idx"
+  end,
+  ["-spec '", Symbol, "'(input(), index()) -> parse_result().\n",
+   "'",Symbol,"'","(Input, Index) ->\n  ",
+        "p(Input, Index, '",Symbol,"', fun(I,D) -> (",
+        lists:nth(4, Tail),
+        ")(I,D) end, fun(", TransformArgs, ") ->",Transform," end)."]
+ end).
+
+-spec 'parsing_expression'(input(), index()) -> parse_result().
+'parsing_expression'(Input, Index) ->
+  p(Input, Index, 'parsing_expression', fun(I,D) -> (p_choose([fun 'choice'/2, fun 'sequence'/2, fun 'primary'/2]))(I,D) end, fun(Node, _Idx) ->Node end).
+
+-spec 'choice'(input(), index()) -> parse_result().
+'choice'(Input, Index) ->
+  p(Input, Index, 'choice', fun(I,D) -> (p_seq([p_label('head', fun 'alternative'/2), p_label('tail', p_one_or_more(p_seq([fun 'space'/2, p_string(<<"\/">>), fun 'space'/2, fun 'alternative'/2])))]))(I,D) end, fun(Node, _Idx) ->
+  Tail = [lists:last(S) || S <- proplists:get_value(tail, Node)],
+  Head = proplists:get_value(head, Node),
+  Statements = [[", ", TS] ||  TS <- Tail],
+  used_combinator(p_choose),
+  ["p_choose([", Head, Statements, "])"]
+ end).
+
+-spec 'alternative'(input(), index()) -> parse_result().
+'alternative'(Input, Index) ->
+  p(Input, Index, 'alternative', fun(I,D) -> (p_choose([fun 'sequence'/2, fun 'labeled_primary'/2]))(I,D) end, fun(Node, _Idx) ->Node end).
+
+-spec 'primary'(input(), index()) -> parse_result().
+'primary'(Input, Index) ->
+  p(Input, Index, 'primary', fun(I,D) -> (p_choose([p_seq([fun 'prefix'/2, fun 'atomic'/2]), p_seq([fun 'atomic'/2, fun 'suffix'/2]), fun 'atomic'/2]))(I,D) end, fun(Node, _Idx) ->
+case Node of
+  [Atomic, one_or_more] ->
+        used_combinator(p_one_or_more),
+        used_combinator(p_scan),
+        ["p_one_or_more(", Atomic, ")"];
+  [Atomic, zero_or_more] ->
+        used_combinator(p_zero_or_more),
+        used_combinator(p_scan),
+        ["p_zero_or_more(", Atomic, ")"];
+  [Atomic, optional] ->
+        used_combinator(p_optional),
+        ["p_optional(", Atomic, ")"];
+  [assert, Atomic] ->
+        used_combinator(p_assert),
+        ["p_assert(", Atomic, ")"];
+  [not_, Atomic] ->
+        used_combinator(p_not),
+        ["p_not(", Atomic, ")"];
+  _ -> Node
+end
+ end).
+
+-spec 'sequence'(input(), index()) -> parse_result().
+'sequence'(Input, Index) ->
+  p(Input, Index, 'sequence', fun(I,D) -> (p_seq([p_label('head', fun 'labeled_primary'/2), p_label('tail', p_one_or_more(p_seq([fun 'space'/2, fun 'labeled_primary'/2])))]))(I,D) end, fun(Node, _Idx) ->
+  Tail = [lists:nth(2, S) || S <- proplists:get_value(tail, Node)],
+  Head = proplists:get_value(head, Node),
+  Statements = [[", ", TS] || TS <- Tail],
+  used_combinator(p_seq),
+  ["p_seq([", Head, Statements, "])"]
+ end).
+
+-spec 'labeled_primary'(input(), index()) -> parse_result().
+'labeled_primary'(Input, Index) ->
+  p(Input, Index, 'labeled_primary', fun(I,D) -> (p_seq([p_optional(fun 'label'/2), fun 'primary'/2]))(I,D) end, fun(Node, _Idx) ->
+  case hd(Node) of
+    [] -> lists:nth(2, Node);
+    Label ->
+          used_combinator(p_label),
+          ["p_label('",  Label, "', ", lists:nth(2, Node), ")"]
+  end
+ end).
+
+-spec 'label'(input(), index()) -> parse_result().
+'label'(Input, Index) ->
+  p(Input, Index, 'label', fun(I,D) -> (p_seq([fun 'alpha_char'/2, p_zero_or_more(fun 'alphanumeric_char'/2), p_string(<<":">>)]))(I,D) end, fun(Node, _Idx) ->
+  lists:sublist(Node, length(Node)-1)
+ end).
+
+-spec 'suffix'(input(), index()) -> parse_result().
+'suffix'(Input, Index) ->
+  p(Input, Index, 'suffix', fun(I,D) -> (p_choose([fun 'repetition_suffix'/2, fun 'optional_suffix'/2]))(I,D) end, fun(Node, _Idx) ->
+  case Node of
+    <<"*">> -> zero_or_more;
+    <<"+">> -> one_or_more;
+    <<"?">> -> optional
+  end
+ end).
+
+-spec 'optional_suffix'(input(), index()) -> parse_result().
+'optional_suffix'(Input, Index) ->
+  p(Input, Index, 'optional_suffix', fun(I,D) -> (p_string(<<"?">>))(I,D) end, fun(Node, _Idx) ->Node end).
+
+-spec 'repetition_suffix'(input(), index()) -> parse_result().
+'repetition_suffix'(Input, Index) ->
+  p(Input, Index, 'repetition_suffix', fun(I,D) -> (p_choose([p_string(<<"+">>), p_string(<<"*">>)]))(I,D) end, fun(Node, _Idx) ->Node end).
+
+-spec 'prefix'(input(), index()) -> parse_result().
+'prefix'(Input, Index) ->
+  p(Input, Index, 'prefix', fun(I,D) -> (p_choose([p_string(<<"&">>), p_string(<<"!">>)]))(I,D) end, fun(Node, _Idx) ->
+  case Node of
+    <<"&">> -> assert;
+    <<"!">> -> not_
+  end
+ end).
+
+-spec 'atomic'(input(), index()) -> parse_result().
+'atomic'(Input, Index) ->
+  p(Input, Index, 'atomic', fun(I,D) -> (p_choose([fun 'terminal'/2, fun 'nonterminal'/2, fun 'parenthesized_expression'/2]))(I,D) end, fun(Node, _Idx) ->
+case Node of
+  {nonterminal, Symbol} ->
+                [<<"fun '">>, Symbol, <<"'/2">>];
+  _ -> Node
+end
+ end).
+
+-spec 'parenthesized_expression'(input(), index()) -> parse_result().
+'parenthesized_expression'(Input, Index) ->
+  p(Input, Index, 'parenthesized_expression', fun(I,D) -> (p_seq([p_string(<<"(">>), p_optional(fun 'space'/2), fun 'parsing_expression'/2, p_optional(fun 'space'/2), p_string(<<")">>)]))(I,D) end, fun(Node, _Idx) ->lists:nth(3, Node) end).
+
+-spec 'nonterminal'(input(), index()) -> parse_result().
+'nonterminal'(Input, Index) ->
+  p(Input, Index, 'nonterminal', fun(I,D) -> (p_seq([fun 'alpha_char'/2, p_zero_or_more(fun 'alphanumeric_char'/2)]))(I,D) end, fun(Node, Idx) ->
+  Symbol = unicode:characters_to_binary(Node),
+  add_nt(Symbol, Idx),
+  {nonterminal, Symbol}
+ end).
+
+-spec 'terminal'(input(), index()) -> parse_result().
+'terminal'(Input, Index) ->
+  p(Input, Index, 'terminal', fun(I,D) -> (p_choose([fun 'regexp_string'/2, fun 'quoted_string'/2, fun 'character_class'/2, fun 'anything_symbol'/2]))(I,D) end, fun(Node, _Idx) ->Node end).
+
+-spec 'regexp_string'(input(), index()) -> parse_result().
+'regexp_string'(Input, Index) ->
+  p(Input, Index, 'regexp_string', fun(I,D) -> (p_seq([p_string(<<"#">>), p_label('string', p_one_or_more(p_seq([p_not(p_string(<<"#">>)), p_choose([p_string(<<"\\#">>), p_anything()])]))), p_string(<<"#">>)]))(I,D) end, fun(Node, _Idx) ->
+  used_combinator(p_regexp),
+  ["p_regexp(<<\"",
+	% Escape \ and " as they are used in erlang string. Other sumbol stay as is.
+	%  \ -> \\
+	%  " -> \"
+   re:replace(proplists:get_value(string, Node), "\"|\\\\", "\\\\&", [{return, binary}, global]),
+   "\">>)"]
+ end).
+
+-spec 'quoted_string'(input(), index()) -> parse_result().
+'quoted_string'(Input, Index) ->
+  p(Input, Index, 'quoted_string', fun(I,D) -> (p_choose([fun 'single_quoted_string'/2, fun 'double_quoted_string'/2]))(I,D) end, fun(Node, _Idx) ->
+  used_combinator(p_string),
+  lists:flatten(["p_string(<<\"",
+   escape_string(unicode:characters_to_list(proplists:get_value(string, Node))),
+   "\">>)"])
+ end).
+
+-spec 'double_quoted_string'(input(), index()) -> parse_result().
+'double_quoted_string'(Input, Index) ->
+  p(Input, Index, 'double_quoted_string', fun(I,D) -> (p_seq([p_string(<<"\"">>), p_label('string', p_zero_or_more(p_seq([p_not(p_string(<<"\"">>)), p_choose([p_string(<<"\\\\">>), p_string(<<"\\\"">>), p_anything()])]))), p_string(<<"\"">>)]))(I,D) end, fun(Node, _Idx) ->Node end).
+
+-spec 'single_quoted_string'(input(), index()) -> parse_result().
+'single_quoted_string'(Input, Index) ->
+  p(Input, Index, 'single_quoted_string', fun(I,D) -> (p_seq([p_string(<<"\'">>), p_label('string', p_zero_or_more(p_seq([p_not(p_string(<<"\'">>)), p_choose([p_string(<<"\\\\">>), p_string(<<"\\\'">>), p_anything()])]))), p_string(<<"\'">>)]))(I,D) end, fun(Node, _Idx) ->Node end).
+
+-spec 'character_class'(input(), index()) -> parse_result().
+'character_class'(Input, Index) ->
+  p(Input, Index, 'character_class', fun(I,D) -> (p_seq([p_string(<<"[">>), p_label('characters', p_one_or_more(p_seq([p_not(p_string(<<"]">>)), p_choose([p_seq([p_string(<<"\\\\">>), p_anything()]), p_seq([p_not(p_string(<<"\\\\">>)), p_anything()])])]))), p_string(<<"]">>)]))(I,D) end, fun(Node, _Idx) ->
+  used_combinator(p_charclass),
+  ["p_charclass(<<\"[",
+   escape_string(unicode:characters_to_list(proplists:get_value(characters, Node))),
+   "]\">>)"]
+ end).
+
+-spec 'anything_symbol'(input(), index()) -> parse_result().
+'anything_symbol'(Input, Index) ->
+  p(Input, Index, 'anything_symbol', fun(I,D) -> (p_string(<<".">>))(I,D) end, fun(_Node, _Idx) -> used_combinator(p_anything), <<"p_anything()">>  end).
+
+-spec 'alpha_char'(input(), index()) -> parse_result().
+'alpha_char'(Input, Index) ->
+  p(Input, Index, 'alpha_char', fun(I,D) -> (p_charclass(<<"[A-Za-z_]">>))(I,D) end, fun(Node, _Idx) ->Node end).
+
+-spec 'alphanumeric_char'(input(), index()) -> parse_result().
+'alphanumeric_char'(Input, Index) ->
+  p(Input, Index, 'alphanumeric_char', fun(I,D) -> (p_choose([fun 'alpha_char'/2, p_charclass(<<"[0-9]">>)]))(I,D) end, fun(Node, _Idx) ->Node end).
+
+-spec 'space'(input(), index()) -> parse_result().
+'space'(Input, Index) ->
+  p(Input, Index, 'space', fun(I,D) -> (p_one_or_more(p_choose([fun 'white'/2, fun 'comment_to_eol'/2])))(I,D) end, fun(Node, _Idx) ->Node end).
+
+-spec 'comment_to_eol'(input(), index()) -> parse_result().
+'comment_to_eol'(Input, Index) ->
+  p(Input, Index, 'comment_to_eol', fun(I,D) -> (p_seq([p_not(p_string(<<"%{">>)), p_string(<<"%">>), p_zero_or_more(p_seq([p_not(p_string(<<"\n">>)), p_anything()]))]))(I,D) end, fun(Node, _Idx) ->Node end).
+
+-spec 'white'(input(), index()) -> parse_result().
+'white'(Input, Index) ->
+  p(Input, Index, 'white', fun(I,D) -> (p_charclass(<<"[\s\t\n\r]">>))(I,D) end, fun(Node, _Idx) ->Node end).
+
+-spec 'code_block'(input(), index()) -> parse_result().
+'code_block'(Input, Index) ->
+  p(Input, Index, 'code_block', fun(I,D) -> (p_choose([p_seq([p_string(<<"%{">>), p_label('code', p_one_or_more(p_choose([p_string(<<"\\%">>), p_string(<<"$%">>), p_seq([p_not(p_string(<<"%}">>)), p_anything()])]))), p_string(<<"%}">>)]), p_seq([p_string(<<"`">>), p_label('code', p_one_or_more(p_choose([p_string(<<"\\`">>), p_string(<<"$`">>), p_seq([p_not(p_string(<<"`">>)), p_anything()])]))), p_string(<<"`">>)]), p_string(<<"~">>)]))(I,D) end, fun(Node, _Idx) ->
+   case Node of
+       <<"~">> -> {code, <<"Node">>};
+       _   -> {code, proplists:get_value('code', Node)}
+   end
+ end).
+
+
+
+-file("peg_includes.hrl", 1).
+-type index() :: {{line, pos_integer()}, {column, pos_integer()}}.
+-type input() :: binary().
+-type parse_failure() :: {fail, term()}.
+-type parse_success() :: {term(), input(), index()}.
+-type parse_result() :: parse_failure() | parse_success().
+-type parse_fun() :: fun((input(), index()) -> parse_result()).
+-type xform_fun() :: fun((input(), index()) -> term()).
+
+-spec p(input(), index(), atom(), parse_fun(), xform_fun()) -> parse_result().
+p(Inp, StartIndex, Name, ParseFun, TransformFun) ->
+  case get_memo(StartIndex, Name) of      % See if the current reduction is memoized
+    {ok, Memo} -> %Memo;                     % If it is, return the stored result
+      Memo;
+    _ ->                                        % If not, attempt to parse
+      Result = case ParseFun(Inp, StartIndex) of
+        {fail,_} = Failure ->                       % If it fails, memoize the failure
+          Failure;
+        {Match, InpRem, NewIndex} ->               % If it passes, transform and memoize the result.
+          Transformed = TransformFun(Match, StartIndex),
+          {Transformed, InpRem, NewIndex}
+      end,
+      memoize(StartIndex, Name, Result),
+      Result
+  end.
+
+-spec setup_memo() -> ets:tid().
+setup_memo() ->
+  put({parse_memo_table, ?MODULE}, ets:new(?MODULE, [set])).
+
+-spec release_memo() -> true.
+release_memo() ->
+  ets:delete(memo_table_name()).
+
+-spec memoize(index(), atom(), parse_result()) -> true.
+memoize(Index, Name, Result) ->
+  Memo = case ets:lookup(memo_table_name(), Index) of
+              [] -> [];
+              [{Index, Plist}] -> Plist
+         end,
+  ets:insert(memo_table_name(), {Index, [{Name, Result}|Memo]}).
+
+-spec get_memo(index(), atom()) -> {ok, term()} | {error, not_found}.
+get_memo(Index, Name) ->
+  case ets:lookup(memo_table_name(), Index) of
+    [] -> {error, not_found};
+    [{Index, Plist}] ->
+      case proplists:lookup(Name, Plist) of
+        {Name, Result}  -> {ok, Result};
+        _  -> {error, not_found}
+      end
+    end.
+
+-spec memo_table_name() -> ets:tid().
+memo_table_name() ->
+    get({parse_memo_table, ?MODULE}).
+
+-ifdef(p_eof).
+-spec p_eof() -> parse_fun().
+p_eof() ->
+  fun(<<>>, Index) -> {eof, [], Index};
+     (_, Index) -> {fail, {expected, eof, Index}} end.
+-endif.
+
+-ifdef(p_optional).
+-spec p_optional(parse_fun()) -> parse_fun().
+p_optional(P) ->
+  fun(Input, Index) ->
+      case P(Input, Index) of
+        {fail,_} -> {[], Input, Index};
+        {_, _, _} = Success -> Success
+      end
+  end.
+-endif.
+
+-ifdef(p_not).
+-spec p_not(parse_fun()) -> parse_fun().
+p_not(P) ->
+  fun(Input, Index)->
+      case P(Input,Index) of
+        {fail,_} ->
+          {[], Input, Index};
+        {Result, _, _} -> {fail, {expected, {no_match, Result},Index}}
+      end
+  end.
+-endif.
+
+-ifdef(p_assert).
+-spec p_assert(parse_fun()) -> parse_fun().
+p_assert(P) ->
+  fun(Input,Index) ->
+      case P(Input,Index) of
+        {fail,_} = Failure-> Failure;
+        _ -> {[], Input, Index}
+      end
+  end.
+-endif.
+
+-ifdef(p_seq).
+-spec p_seq([parse_fun()]) -> parse_fun().
+p_seq(P) ->
+  fun(Input, Index) ->
+      p_all(P, Input, Index, [])
+  end.
+
+-spec p_all([parse_fun()], input(), index(), [term()]) -> parse_result().
+p_all([], Inp, Index, Accum ) -> {lists:reverse( Accum ), Inp, Index};
+p_all([P|Parsers], Inp, Index, Accum) ->
+  case P(Inp, Index) of
+    {fail, _} = Failure -> Failure;
+    {Result, InpRem, NewIndex} -> p_all(Parsers, InpRem, NewIndex, [Result|Accum])
+  end.
+-endif.
+
+-ifdef(p_choose).
+-spec p_choose([parse_fun()]) -> parse_fun().
+p_choose(Parsers) ->
+  fun(Input, Index) ->
+      p_attempt(Parsers, Input, Index, none)
+  end.
+
+-spec p_attempt([parse_fun()], input(), index(), none | parse_failure()) -> parse_result().
+p_attempt([], _Input, _Index, Failure) -> Failure;
+p_attempt([P|Parsers], Input, Index, FirstFailure)->
+  case P(Input, Index) of
+    {fail, _} = Failure ->
+      case FirstFailure of
+        none -> p_attempt(Parsers, Input, Index, Failure);
+        _ -> p_attempt(Parsers, Input, Index, FirstFailure)
+      end;
+    Result -> Result
+  end.
+-endif.
+
+-ifdef(p_zero_or_more).
+-spec p_zero_or_more(parse_fun()) -> parse_fun().
+p_zero_or_more(P) ->
+  fun(Input, Index) ->
+      p_scan(P, Input, Index, [])
+  end.
+-endif.
+
+-ifdef(p_one_or_more).
+-spec p_one_or_more(parse_fun()) -> parse_fun().
+p_one_or_more(P) ->
+  fun(Input, Index)->
+      Result = p_scan(P, Input, Index, []),
+      case Result of
+        {[_|_], _, _} ->
+          Result;
+        _ ->
+          {fail, {expected, Failure, _}} = P(Input,Index),
+          {fail, {expected, {at_least_one, Failure}, Index}}
+      end
+  end.
+-endif.
+
+-ifdef(p_label).
+-spec p_label(atom(), parse_fun()) -> parse_fun().
+p_label(Tag, P) ->
+  fun(Input, Index) ->
+      case P(Input, Index) of
+        {fail,_} = Failure ->
+           Failure;
+        {Result, InpRem, NewIndex} ->
+          {{Tag, Result}, InpRem, NewIndex}
+      end
+  end.
+-endif.
+
+-ifdef(p_scan).
+-spec p_scan(parse_fun(), input(), index(), [term()]) -> {[term()], input(), index()}.
+p_scan(_, <<>>, Index, Accum) -> {lists:reverse(Accum), <<>>, Index};
+p_scan(P, Inp, Index, Accum) ->
+  case P(Inp, Index) of
+    {fail,_} -> {lists:reverse(Accum), Inp, Index};
+    {Result, InpRem, NewIndex} -> p_scan(P, InpRem, NewIndex, [Result | Accum])
+  end.
+-endif.
+
+-ifdef(p_string).
+-spec p_string(binary()) -> parse_fun().
+p_string(S) ->
+    Length = erlang:byte_size(S),
+    fun(Input, Index) ->
+      try
+          <<S:Length/binary, Rest/binary>> = Input,
+          {S, Rest, p_advance_index(S, Index)}
+      catch
+          error:{badmatch,_} -> {fail, {expected, {string, S}, Index}}
+      end
+    end.
+-endif.
+
+-ifdef(p_anything).
+-spec p_anything() -> parse_fun().
+p_anything() ->
+  fun(<<>>, Index) -> {fail, {expected, any_character, Index}};
+     (Input, Index) when is_binary(Input) ->
+          <<C/utf8, Rest/binary>> = Input,
+          {<<C/utf8>>, Rest, p_advance_index(<<C/utf8>>, Index)}
+  end.
+-endif.
+
+-ifdef(p_charclass).
+-spec p_charclass(string() | binary()) -> parse_fun().
+p_charclass(Class) ->
+    {ok, RE} = re:compile(Class, [unicode, dotall]),
+    fun(Inp, Index) ->
+            case re:run(Inp, RE, [anchored]) of
+                {match, [{0, Length}|_]} ->
+                    {Head, Tail} = erlang:split_binary(Inp, Length),
+                    {Head, Tail, p_advance_index(Head, Index)};
+                _ -> {fail, {expected, {character_class, binary_to_list(Class)}, Index}}
+            end
+    end.
+-endif.
+
+-ifdef(p_regexp).
+-spec p_regexp(binary()) -> parse_fun().
+p_regexp(Regexp) ->
+    {ok, RE} = re:compile(Regexp, [unicode, dotall, anchored]),
+    fun(Inp, Index) ->
+        case re:run(Inp, RE) of
+            {match, [{0, Length}|_]} ->
+                {Head, Tail} = erlang:split_binary(Inp, Length),
+                {Head, Tail, p_advance_index(Head, Index)};
+            _ -> {fail, {expected, {regexp, binary_to_list(Regexp)}, Index}}
+        end
+    end.
+-endif.
+
+-ifdef(line).
+-spec line(index() | term()) -> pos_integer() | undefined.
+line({{line,L},_}) -> L;
+line(_) -> undefined.
+-endif.
+
+-ifdef(column).
+-spec column(index() | term()) -> pos_integer() | undefined.
+column({_,{column,C}}) -> C;
+column(_) -> undefined.
+-endif.
+
+-spec p_advance_index(input() | unicode:charlist() | pos_integer(), index()) -> index().
+p_advance_index(MatchedInput, Index) when is_list(MatchedInput) orelse is_binary(MatchedInput)-> % strings
+  lists:foldl(fun p_advance_index/2, Index, unicode:characters_to_list(MatchedInput));
+p_advance_index(MatchedInput, Index) when is_integer(MatchedInput) -> % single characters
+  {{line, Line}, {column, Col}} = Index,
+  case MatchedInput of
+    $\n -> {{line, Line+1}, {column, 1}};
+    _ -> {{line, Line}, {column, Col+1}}
+  end.

rebar-2.6.4.tar.gz/inttest/neotoma1/neotoma_src_rt.erl Added

@@ -0,0 +1,81 @@
+%% -*- erlang-indent-level: 4;indent-tabs-mode: nil -*-
+%% ex: ts=4 sw=4 et
+%% -------------------------------------------------------------------
+%%
+%% rebar: Erlang Build Tools
+%%
+%% Copyright (c) 2015 Luis Rascao (luis.rascao@gmail.com)
+%%
+%% Permission is hereby granted, free of charge, to any person obtaining a copy
+%% of this software and associated documentation files (the "Software"), to deal
+%% in the Software without restriction, including without limitation the rights
+%% to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+%% copies of the Software, and to permit persons to whom the Software is
+%% furnished to do so, subject to the following conditions:
+%%
+%% The above copyright notice and this permission notice shall be included in
+%% all copies or substantial portions of the Software.
+%%
+%% THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+%% IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+%% FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+%% AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+%% LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+%% OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+%% THE SOFTWARE.
+%% -------------------------------------------------------------------
+-module(neotoma_src_rt).
+
+-compile(export_all).
+
+-include_lib("eunit/include/eunit.hrl").
+-include_lib("deps/retest/include/retest.hrl").
+
+-define(GENERATED_MODULES,
+        [csv_peg]).
+
+files() ->
+    [{copy, "../../rebar", "rebar"},
+     {copy, "rebar.config", "rebar.config"},
+     {copy, "mock", "deps"},
+     {copy, "src", "src"}].
+
+run(Dir) ->
+    retest_log:log(debug, "Running in Dir: ~s~n", [Dir]),
+    ?assertMatch({ok, _}, retest:sh("./rebar compile",
+                                    [{async, false}])),
+
+    ok = check_files_generated(),
+
+    retest_log:log(debug, "Verify cleanup~n", []),
+    ?assertMatch({ok, _}, retest_sh:run("./rebar clean",
+                                        [])),
+    ok = check_files_deleted(),
+    ok.
+
+check_files_generated() ->
+    check(fun filelib:is_regular/1,
+          generated_erl_files()).
+
+check_files_deleted() ->
+    check(fun file_does_not_exist/1,
+          generated_erl_files()).
+
+generated_erl_files() ->
+    add_dir("src", add_ext(?GENERATED_MODULES, ".erl")).
+
+add_ext(Modules, Ext) ->
+    [lists:concat([Module, Ext]) || Module <- Modules].
+
+add_dir(Dir, Files) ->
+    [filename:join(Dir, File) || File <- Files].
+
+file_does_not_exist(F) ->
+    not filelib:is_regular(F).
+
+check(Check, Files) ->
+    lists:foreach(
+      fun(F) ->
+              ?assertMatch({true, _}, {Check(F), F})
+      end,
+      Files).

rebar-2.6.4.tar.gz/inttest/neotoma1/rebar.config Added

rebar-2.6.4.tar.gz/inttest/neotoma1/src Added

rebar-2.6.4.tar.gz/inttest/neotoma1/src/csv.peg Added

rebar-2.6.4.tar.gz/inttest/neotoma1/src/neotoma1.app.src Added

rebar-2.6.1.tar.gz/inttest/port/port_rt.erl -> rebar-2.6.4.tar.gz/inttest/port/port_rt.erl Changed

@@ -31,13 +31,16 @@
 
 -include_lib("eunit/include/eunit.hrl").
 
+setup([Target]) ->
+  retest_utils:load_module(filename:join(Target, "inttest_utils.erl")),
+  ok.
+
 files() ->
     [
-     {copy, "../../rebar", "rebar"},
      {copy, "rebar.config", "rebar.config"},
      {copy, "c_src", "c_src"},
      {create, "ebin/foo.app", app(foo, [])}
-    ].
+    ] ++ inttest_utils:rebar_setup().
 
 run(_Dir) ->
     %% wait a bit for new files to have different timestamps
@@ -45,48 +48,77 @@
     %% test.so is created during first compile
     ?assertEqual(0, filelib:last_modified("priv/test.so")),
     ?assertMatch({ok, _}, retest_sh:run("./rebar compile", [])),
-    TestSo1 = filelib:last_modified("priv/test.so"),
+    ?assertMatch(true, filelib:is_regular("compile_commands.json")),
+    TestSo1 = filelib:last_modified("priv/test" ++
+                                    shared_library_file_extension(os:type())),
     ?assert(TestSo1 > 0),
     wait(),
     %% nothing happens during second compile
     ?assertMatch({ok, _}, retest_sh:run("./rebar compile", [])),
-    TestSo2 = filelib:last_modified("priv/test.so"),
-    Test1o2 = filelib:last_modified("c_src/test1.o"),
-    Test2o2 = filelib:last_modified("c_src/test2.o"),
+    TestSo2 = filelib:last_modified("priv/test" ++
+                                    shared_library_file_extension(os:type())),
+    Test1o2 = filelib:last_modified("c_src/test1" ++
+                                    object_file_extension(os:type())),
+    Test2o2 = filelib:last_modified("c_src/test2" ++
+                                    object_file_extension(os:type())),
     ?assertEqual(TestSo1, TestSo2),
     ?assert(TestSo1 >= Test1o2),
     ?assert(TestSo1 >= Test2o2),
     wait(),
     %% when test2.c changes, at least test2.o and test.so are rebuilt
-    ?assertMatch({ok, _}, retest_sh:run("touch c_src/test2.c", [])),
+    ?assertMatch({ok, _}, retest:run({touch, "c_src/test2.c"}, [{dir, "."}])),
     ?assertMatch({ok, _}, retest_sh:run("./rebar compile", [])),
-    TestSo3 = filelib:last_modified("priv/test.so"),
-    Test2o3 = filelib:last_modified("c_src/test2.o"),
+    TestSo3 = filelib:last_modified("priv/test" ++
+                                    shared_library_file_extension(os:type())),
+    Test2o3 = filelib:last_modified("c_src/test2" ++
+                                    object_file_extension(os:type())),
     ?assert(TestSo3 > TestSo2),
     ?assert(Test2o3 > TestSo2),
-    wait(),
-    %% when test2.h changes, at least test2.o and test.so are rebuilt
-    ?assertMatch({ok, _}, retest_sh:run("touch c_src/test2.h", [])),
-    ?assertMatch({ok, _}, retest_sh:run("./rebar compile", [])),
-    TestSo4 = filelib:last_modified("priv/test.so"),
-    Test2o4 = filelib:last_modified("c_src/test2.o"),
-    ?assert(TestSo4 > TestSo3),
-    ?assert(Test2o4 > TestSo3),
-    wait(),
-    %% when test1.h changes, everything is rebuilt
-    ?assertMatch({ok, _}, retest_sh:run("touch c_src/test1.h", [])),
-    ?assertMatch({ok, _}, retest_sh:run("./rebar compile", [])),
-    TestSo5 = filelib:last_modified("priv/test.so"),
-    Test1o5 = filelib:last_modified("c_src/test1.o"),
-    Test2o5 = filelib:last_modified("c_src/test2.o"),
-    ?assert(TestSo5 > TestSo4),
-    ?assert(Test1o5 > TestSo4),
-    ?assert(Test2o5 > TestSo4),
-    ok.
+    %% detecting the a full recompile is needed when changing a .h file is a feature attained
+    %% by using the -MMD gcc flag which sadly is not available in Windows, so this part of the
+    %% test is only executed in Unix
+    case os:type() of
+        {win32, _} -> ok;
+        _ ->
+            wait(),
+            %% when test2.h changes, at least test2.o and test.so are rebuilt
+            ?assertMatch({ok, _},
+                retest:run({touch, "c_src/test2.h"}, [{dir, "."}])),
+            ?assertMatch({ok, _},
+                retest_sh:run("./rebar compile", [])),
+            TestSo4 = filelib:last_modified("priv/test" ++
+                                            shared_library_file_extension(os:type())),
+            Test2o4 = filelib:last_modified("c_src/test2" ++
+                                            object_file_extension(os:type())),
+            ?assert(TestSo4 > TestSo3),
+            ?assert(Test2o4 > TestSo3),
+            wait(),
+            %% when test1.h changes, everything is rebuilt
+            ?assertMatch({ok, _},
+                retest:run({touch, "c_src/test1.h"}, [{dir, "."}])),
+            ?assertMatch({ok, _},
+                retest_sh:run("./rebar compile", [])),
+            TestSo5 = filelib:last_modified("priv/test" ++
+                                            shared_library_file_extension(os:type())),
+            Test1o5 = filelib:last_modified("c_src/test1" ++
+                                            object_file_extension(os:type())),
+            Test2o5 = filelib:last_modified("c_src/test2" ++
+                                            object_file_extension(os:type())),
+            ?assert(TestSo5 > TestSo4),
+            ?assert(Test1o5 > TestSo4),
+            ?assert(Test2o5 > TestSo4),
+            ok
+    end.
 
 wait() ->
     timer:sleep(1000).
 
+object_file_extension({win32, nt}) -> ".o";
+object_file_extension(_) -> ".o".
+
+shared_library_file_extension({win32, nt}) -> ".dll";
+shared_library_file_extension(_) -> ".so".
+
 %%
 %% Generate the contents of a simple .app file
 %%

rebar-2.6.1.tar.gz/inttest/port/rebar.config -> rebar-2.6.4.tar.gz/inttest/port/rebar.config Changed

rebar-2.6.4.tar.gz/inttest/port2 Added

rebar-2.6.4.tar.gz/inttest/port2/c_src Added

rebar-2.6.4.tar.gz/inttest/port2/c_src/test1.c Added

rebar-2.6.4.tar.gz/inttest/port2/c_src/test1.h Added

rebar-2.6.4.tar.gz/inttest/port2/port2_rt.erl Added

@@ -0,0 +1,75 @@
+%% -*- erlang-indent-level: 4;indent-tabs-mode: nil -*-
+%% ex: ts=4 sw=4 et
+%% -------------------------------------------------------------------
+%%
+%% rebar: Erlang Build Tools
+%%
+%% Copyright (c) 2016 Luis Rascao
+%%
+%% Permission is hereby granted, free of charge, to any person obtaining a copy
+%% of this software and associated documentation files (the "Software"), to deal
+%% in the Software without restriction, including without limitation the rights
+%% to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+%% copies of the Software, and to permit persons to whom the Software is
+%% furnished to do so, subject to the following conditions:
+%%
+%% The above copyright notice and this permission notice shall be included in
+%% all copies or substantial portions of the Software.
+%%
+%% THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+%% IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+%% FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+%% AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+%% LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+%% OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+%% THE SOFTWARE.
+%% -------------------------------------------------------------------
+
+-module(port2_rt).
+-export([files/0,
+         run/1]).
+
+-include_lib("eunit/include/eunit.hrl").
+
+setup([Target]) ->
+  retest_utils:load_module(filename:join(Target, "inttest_utils.erl")),
+  ok.
+
+files() ->
+    [
+     {copy, "rebar.config", "rebar.config"},
+     {copy, "c_src", "c_src"},
+     {create, "ebin/foo.app", app(foo, [])}
+    ] ++ inttest_utils:rebar_setup().
+
+run(_Dir) ->
+    %% wait a bit for new files to have different timestamps
+    wait(),
+    %% test.so is created during first compile
+    ?assertEqual(0, filelib:last_modified("priv/test.so")),
+    ?assertMatch({ok, _}, retest_sh:run("./rebar compile",
+                                        [{env, [{"ERL_CFLAGS", "-DTEST3=test3"}]}])),
+    TestSo1 = filelib:last_modified("priv/test" ++
+                                    shared_library_file_extension(os:type())),
+    ?assert(TestSo1 > 0).
+
+wait() ->
+    timer:sleep(1000).
+
+object_file_extension({win32, nt}) -> ".o";
+object_file_extension(_) -> ".o".
+
+shared_library_file_extension({win32, nt}) -> ".dll";
+shared_library_file_extension(_) -> ".so".
+
+%%
+%% Generate the contents of a simple .app file
+%%
+app(Name, Modules) ->
+    App = {application, Name,
+           [{description, atom_to_list(Name)},
+            {vsn, "1"},
+            {modules, Modules},
+            {registered, []},
+            {applications, [kernel, stdlib]}]},
+    io_lib:format("~p.\n", [App]).

rebar-2.6.4.tar.gz/inttest/port2/rebar.config Added

rebar-2.6.1.tar.gz/inttest/profile/profile_rt.erl -> rebar-2.6.4.tar.gz/inttest/profile/profile_rt.erl Changed

rebar-2.6.1.tar.gz/inttest/proto_gpb/proto_gpb_rt.erl -> rebar-2.6.4.tar.gz/inttest/proto_gpb/proto_gpb_rt.erl Changed

@@ -30,7 +30,6 @@
 
 -include_lib("eunit/include/eunit.hrl").
 -include_lib("kernel/include/file.hrl").
--include_lib("deps/retest/include/retest.hrl").
 
 -define(MODULES,
         [foo,
@@ -51,9 +50,12 @@
          "c/test4.proto",
          "c/d/test5.proto"]).
 
+setup([Target]) ->
+  retest_utils:load_module(filename:join(Target, "inttest_utils.erl")),
+  ok.
+
 files() ->
     [
-     {copy, "../../rebar", "rebar"},
      {copy, "rebar.config", "rebar.config"},
      {copy, "rebar2.config", "rebar2.config"},
      {copy, "rebar.bad.config", "rebar.bad.config"},
@@ -63,7 +65,7 @@
      {copy, "proto.bad", "proto.bad"},
      {copy, "mock", "deps"},
      {create, "ebin/foo.app", app(foo, ?MODULES ++ ?GENERATED_MODULES)}
-    ].
+    ] ++ inttest_utils:rebar_setup().
 
 run(_Dir) ->
     % perform test obtaining the .proto files from src dir
@@ -99,7 +101,7 @@
     %% the .hrl file was generated before foo was compiled.
     ok = check_beams_generated(),
 
-    ?DEBUG("Verifying recompilation~n", []),
+    retest_log:log(debug, "Verifying recompilation~n", []),
     TestErl = hd(generated_erl_files()),
     TestProto = hd(source_proto_files(ProtoDir)),
     make_proto_newer_than_erl(TestProto, TestErl),
@@ -111,7 +113,7 @@
     TestMTime2 = read_mtime(TestErl),
     ?assert(TestMTime2 > TestMTime1),
 
-    ?DEBUG("Verifying recompilation with no changes~n", []),
+    retest_log:log(debug, "Verifying recompilation with no changes~n", []),
     TestMTime3 = read_mtime(TestErl),
     ?assertMatch({ok, _}, retest_sh:run("./rebar --config "
                                         ++ ConfigFile
@@ -120,7 +122,7 @@
     TestMTime4 = read_mtime(TestErl),
     ?assert(TestMTime3 =:= TestMTime4),
 
-    ?DEBUG("Verify cleanup~n", []),
+    retest_log:log(debug, "Verify cleanup~n", []),
     ?assertMatch({ok, _}, retest_sh:run("./rebar --config "
                                         ++ ConfigFile
                                         ++ " clean",

rebar-2.6.1.tar.gz/inttest/proto_protobuffs/proto_protobuffs_rt.erl -> rebar-2.6.4.tar.gz/inttest/proto_protobuffs/proto_protobuffs_rt.erl Changed

rebar-2.6.4.tar.gz/inttest/rebar3_deps1 Added

rebar-2.6.4.tar.gz/inttest/rebar3_deps1/a.erl Added

rebar-2.6.4.tar.gz/inttest/rebar3_deps1/a.rebar.config Added

rebar-2.6.4.tar.gz/inttest/rebar3_deps1/b.hrl Added

rebar-2.6.4.tar.gz/inttest/rebar3_deps1/c.txt Added

rebar-2.6.4.tar.gz/inttest/rebar3_deps1/rebar3_deps1_rt.erl Added

@@ -0,0 +1,63 @@
+%% -*- erlang-indent-level: 4;indent-tabs-mode: nil -*-
+%% ex: ts=4 sw=4 et
+-module(rebar3_deps1_rt).
+
+-compile(export_all).
+
+setup([Target]) ->
+  retest_utils:load_module(filename:join(Target, "inttest_utils.erl")),
+  ok.
+
+%% Test deps with rebar3-type dependencies (that is, dependencies without Regexes)
+%% Example: {git, {appname, "git://something/something", {branch, master}}}
+files() ->
+    [
+     %% A application
+     {create, "ebin/a.app", app(a, [a])},
+     {copy, "a.rebar.config", "rebar.config"},
+     {copy, "a.erl", "src/a.erl"},
+
+     %% B application
+     {create, "repo/b/ebin/b.app", app(b, [])},
+     {copy, "b.hrl", "repo/b/include/b.hrl"},
+
+     {copy, "c.txt", "repo/c/c.txt"}
+
+    ] ++ inttest_utils:rebar_setup().
+
+apply_cmds([], _Params) ->
+    ok;
+apply_cmds([Cmd | Rest], Params) ->
+    io:format("Running: ~s (~p)\n", [Cmd, Params]),
+    {ok, _} = retest_sh:run(Cmd, Params),
+    apply_cmds(Rest, Params).
+
+run(_Dir) ->
+    %% Initialize the dep app as git repos so that dependencies pull
+    %% properly
+    GitCmds = ["git init",
+               "git add -A",
+               "git config user.email 'tdeps@example.com'",
+               "git config user.name 'tdeps'",
+               "git commit -a -m \"Initial Commit\""],
+    apply_cmds(GitCmds, [{dir, "repo/b"}]),
+    apply_cmds(GitCmds, [{dir, "repo/c"}]),
+
+    {ok, _} = retest_sh:run("./rebar get-deps", []),
+    {ok, _} = retest_sh:run("./rebar compile", []),
+
+    true = filelib:is_regular("ebin/a.beam"),
+    true = filelib:is_regular("deps/c/c.txt"),
+    ok.
+
+%%
+%% Generate the contents of a simple .app file
+%%
+app(Name, Modules) ->
+    App = {application, Name,
+           [{description, atom_to_list(Name)},
+            {vsn, "1"},
+            {modules, Modules},
+            {registered, []},
+            {applications, [kernel, stdlib]}]},
+    io_lib:format("~p.\n", [App]).

rebar-2.6.1.tar.gz/inttest/require_vsn/require_vsn_rt.erl -> rebar-2.6.4.tar.gz/inttest/require_vsn/require_vsn_rt.erl Changed

rebar-2.6.1.tar.gz/inttest/rgen1/retest.config -> rebar-2.6.4.tar.gz/inttest/rgen1/retest.config Changed

rebar-2.6.1.tar.gz/inttest/rgen1/rgen1_rt.erl -> rebar-2.6.4.tar.gz/inttest/rgen1/rgen1_rt.erl Changed

rebar-2.6.1.tar.gz/inttest/t_custom_config/t_custom_config_rt.erl -> rebar-2.6.4.tar.gz/inttest/t_custom_config/t_custom_config_rt.erl Changed

rebar-2.6.1.tar.gz/inttest/tdeps1/tdeps1_rt.erl -> rebar-2.6.4.tar.gz/inttest/tdeps1/tdeps1_rt.erl Changed

@@ -4,16 +4,18 @@
 
 -compile(export_all).
 
+setup([Target]) ->
+  retest_utils:load_module(filename:join(Target, "inttest_utils.erl")),
+  ok.
+
 %% Exercise transitive dependencies
 %% A -> B -> C, where A includes a .hrl from B which includes .hrl from C
-
 files() ->
     [
      %% A application
      {create, "ebin/a.app", app(a, [a])},
      {copy, "a.rebar.config", "rebar.config"},
      {copy, "a.erl", "src/a.erl"},
-     {copy, "../../rebar", "rebar"},
 
      %% B application
      {create, "repo/b/ebin/b.app", app(b, [])},
@@ -23,7 +25,7 @@
      %% C application
      {create, "repo/c/ebin/c.app", app(c, [])},
      {copy, "c.hrl", "repo/c/include/c.hrl"}
-    ].
+    ] ++ inttest_utils:rebar_setup().
 
 apply_cmds([], _Params) ->
     ok;
@@ -39,7 +41,7 @@
                "git add -A",
                "git config user.email 'tdeps@example.com'",
                "git config user.name 'tdeps'",
-               "git commit -a -m 'Initial Commit'"],
+               "git commit -a -m \"Initial Commit\""],
     apply_cmds(GitCmds, [{dir, "repo/b"}]),
     apply_cmds(GitCmds, [{dir, "repo/c"}]),

rebar-2.6.1.tar.gz/inttest/tdeps2/tdeps2_rt.erl -> rebar-2.6.4.tar.gz/inttest/tdeps2/tdeps2_rt.erl Changed

@@ -4,10 +4,13 @@
 
 -compile(export_all).
 
+setup([Target]) ->
+  retest_utils:load_module(filename:join(Target, "inttest_utils.erl")),
+  ok.
+
 %% Exercise transitive dependencies where there are multiple files
 %% depending on the same set of deps
 %% [A1, A2] -> B -> C ; A1 and A2 includes B.hrl which includes C.hrl
-
 files() ->
     [
      %% A1 application
@@ -21,7 +24,6 @@
      {template, "a.erl", "apps/a2/src/a2.erl", dict:from_list([{module, a2}])},
 
      {copy, "root.rebar.config", "rebar.config"},
-     {copy, "../../rebar", "rebar"},
 
      %% B application
      {create, "repo/b/ebin/b.app", app(b, [])},
@@ -31,7 +33,7 @@
      %% C application
      {create, "repo/c/ebin/c.app", app(c, [])},
      {copy, "c.hrl", "repo/c/include/c.hrl"}
-    ].
+    ] ++ inttest_utils:rebar_setup().
 
 apply_cmds([], _Params) ->
     ok;
@@ -47,7 +49,7 @@
                "git add -A",
                "git config user.email 'tdeps@example.com'",
                "git config user.name 'tdeps'",
-               "git commit -a -m 'Initial Commit'"],
+               "git commit -a -m \"Initial Commit\""],
     ok = apply_cmds(GitCmds, [{dir, "repo/b"}]),
     ok = apply_cmds(GitCmds, [{dir, "repo/c"}]),

rebar-2.6.1.tar.gz/inttest/tdeps3/tdeps3_rt.erl -> rebar-2.6.4.tar.gz/inttest/tdeps3/tdeps3_rt.erl Changed

@@ -4,12 +4,15 @@
 
 -compile(export_all).
 
+setup([Target]) ->
+  retest_utils:load_module(filename:join(Target, "inttest_utils.erl")),
+  ok.
+
 %% Exercise transitive dependencies where there are multiple files
 %% depending on the same set of deps as well as lib_dir directives
 %% A -> B -> C -> D -> E
 %%      |--> G(via lib_dir)
 %% |--> F -> D -> E
-
 files() ->
     [
      %% A1 application
@@ -17,7 +20,6 @@
      {template, "a.erl", "src/a.erl", dict:from_list([{module, a}, {dep, b}])},
 
      {copy, "a.rebar.config", "rebar.config"},
-     {copy, "../../rebar", "rebar"},
 
      %% B application
      {create, "repo/b/ebin/b.app", app(b, [b])},
@@ -52,7 +54,7 @@
      {create, "repo/b/apps/g/ebin/g.app", app(g, [])},
      {copy, "e.hrl", "repo/b/apps/g/include/g.hrl"}
 
-    ].
+    ] ++ inttest_utils:rebar_setup().
 
 apply_cmds([], _Params) ->
     ok;
@@ -68,7 +70,7 @@
                "git add -A",
                "git config user.email 'tdeps@example.com'",
                "git config user.name 'tdeps'",
-               "git commit -a -m 'Initial Commit'"],
+               "git commit -a -m \"Initial Commit\""],
     ok = apply_cmds(GitCmds, [{dir, "repo/b"}]),
     ok = apply_cmds(GitCmds, [{dir, "repo/c"}]),
     ok = apply_cmds(GitCmds, [{dir, "repo/d"}]),

rebar-2.6.4.tar.gz/inttest/tdeps_prefer Added

rebar-2.6.4.tar.gz/inttest/tdeps_prefer/a.erl Added

rebar-2.6.4.tar.gz/inttest/tdeps_prefer/a.rebar.config Added

rebar-2.6.4.tar.gz/inttest/tdeps_prefer/b.hrl Added

rebar-2.6.4.tar.gz/inttest/tdeps_prefer/c.hrl Added

rebar-2.6.4.tar.gz/inttest/tdeps_prefer/root.rebar.config Added

rebar-2.6.4.tar.gz/inttest/tdeps_prefer/tdeps_prefer_rt.erl Added

@@ -0,0 +1,68 @@
+%% -*- erlang-indent-level: 4;indent-tabs-mode: nil -*-
+%% ex: ts=4 sw=4 et
+-module(tdeps_prefer_rt).
+
+-compile(export_all).
+
+setup([Target]) ->
+    retest_utils:load_module(filename:join(Target, "inttest_utils.erl")),
+    ok.
+
+%% Test REBAR_DEPS_FORCE_LIB
+%% A -> [B, C]
+%% where B should be found globally and C should be found locally
+files() ->
+    [
+    %% A application
+    {create, "apps/a/ebin/a.app", app(a, [a])},
+    {copy, "a.rebar.config", "apps/a/rebar.config"},
+    {template, "a.erl", "apps/a/src/a.erl", dict:from_list([{module, a}])},
+
+    %% B application
+    {create, "libs/b-1/ebin/b.app", app(b, [])},
+    {copy, "b.hrl", "libs/b-1/include/b.hrl"},
+
+    %% C application
+    {create, "repo/c/ebin/c.app", app(c, [])},
+    {copy, "c.hrl", "repo/c/include/c.hrl"},
+
+    {copy, "root.rebar.config", "rebar.config"}
+    ] ++ inttest_utils:rebar_setup().
+
+apply_cmds([], _Params) ->
+    ok;
+apply_cmds([Cmd | Rest], Params) ->
+    io:format("Running: ~s (~p)\n", [Cmd, Params]),
+    {ok, _} = retest_sh:run(Cmd, Params),
+    apply_cmds(Rest, Params).
+
+run(Dir) ->
+    %% Initialize the c apps as git repos so that dependencies pull
+    %% properly
+    GitCmds = ["git init",
+               "git add -A",
+               "git config user.email 'tdeps@example.com'",
+               "git config user.name 'tdeps'",
+               "git commit -a -m \"Initial Commit\""],
+    ErlLibs = filename:join(Dir, "libs"),
+    ok = apply_cmds(GitCmds, [{dir, "repo/c"}]),
+    Env = [
+        {"REBAR_DEPS_PREFER_LIBS", "1"},
+        {"ERL_LIBS", ErlLibs}
+    ],
+
+    {ok, _} = retest_sh:run("./rebar -v get-deps", [{env, Env}]),
+    {ok, _} = retest_sh:run("./rebar -v compile", [{env, Env}]),
+    ok.
+
+%%
+%% Generate the contents of a simple .app file
+%%
+app(Name, Modules) ->
+    App = {application, Name,
+           [{description, atom_to_list(Name)},
+            {vsn, "1"},
+            {modules, Modules},
+            {registered, []},
+            {applications, [kernel, stdlib]}]},
+    io_lib:format("~p.\n", [App]).

rebar-2.6.1.tar.gz/inttest/tdeps_update/tdeps_update_rt.erl -> rebar-2.6.4.tar.gz/inttest/tdeps_update/tdeps_update_rt.erl Changed

@@ -4,6 +4,10 @@
 
 -compile(export_all).
 
+setup([Target]) ->
+  retest_utils:load_module(filename:join(Target, "inttest_utils.erl")),
+  ok.
+
 %% Exercises update deps, with recursive dependency updates.
 %% Initially:
 %%     A(v0.5) -> B(v0.2.3) -> C(v1.0)
@@ -25,7 +29,6 @@
      {template, "a.erl", "apps/a1/src/a1.erl", dict:from_list([{module, a1}])},
 
      {copy, "root.rebar.config", "rebar.config"},
-     {copy, "../../rebar", "rebar"},
 
      %% B application
      {create, "repo/b/ebin/b.app", app(b, [], "0.2.3")},
@@ -64,57 +67,62 @@
      {copy, "c.rebar.config", "c.rebar.config"},
      {copy, "c2.rebar.config", "c2.rebar.config"},
      {copy, "c3.rebar.config", "c3.rebar.config"}
-    ].
+    ] ++ inttest_utils:rebar_setup().
 
 apply_cmds([], _Params) ->
     ok;
 apply_cmds([Cmd | Rest], Params) ->
-    io:format("Running: ~s (~p)\n", [Cmd, Params]),
-    {ok, _} = retest_sh:run(Cmd, Params),
+    io:format("Running: ~p (~p)\n", [Cmd, Params]),
+    {ok, _} = retest:run(Cmd, Params),
     apply_cmds(Rest, Params).
 
-run(_Dir) ->
+run(Dir) ->
     %% Initialize the b/c/d apps as git repos so that dependencies pull
     %% properly
     GitCmds = ["git init",
                "git add -A",
-               "git config user.email 'tdeps@example.com'",
-               "git config user.name 'tdeps'",
-               "git commit -a -m 'Initial Commit'"],
+               "git config user.email \"tdeps@example.com\"",
+               "git config user.name \"tdeps\"",
+               "git commit -a -m \"Initial Commit\""],
     BCmds = ["git tag 0.2.3",
-             "cp ../../b2.rebar.config rebar.config",
-             "cp ../../b2.app ebin/b.app",
-             "git commit -a -m 'update to 0.2.4'",
+             {copy, "../../b2.rebar.config", "rebar.config"},
+             {copy, "../../b2.app", "ebin/b.app"},
+             {touch, "ebin/b.app"},
+             "git commit -a -m \"update to 0.2.4\"",
              "git tag 0.2.4",
-             "cp ../../b3.rebar.config rebar.config",
-             "cp ../../b3.app ebin/b.app",
-             "git commit -a -m 'update to 0.2.5'",
+             {copy, "../../b3.rebar.config", "rebar.config"},
+             {copy, "../../b3.app", "ebin/b.app"},
+             {touch, "ebin/b.app"},
+             "git commit -a -m \"update to 0.2.5\"",
              "git tag 0.2.5",
-             "cp ../../b4.rebar.config rebar.config",
-             "cp ../../b4.app ebin/b.app",
-             "git commit -a -m 'update to 0.2.6'",
+             {copy, "../../b4.rebar.config", "rebar.config"},
+             {copy, "../../b4.app", "ebin/b.app"},
+             {touch, "ebin/b.app"},
+             "git commit -a -m \"update to 0.2.6\"",
              "git tag 0.2.6"],
              %"git checkout 0.2.3"],
     CCmds = ["git tag 1.0",
-             "cp ../../c2.hrl include/c.hrl",
-             "cp ../../c2.app ebin/c.app",
-             "cp ../../c.rebar.config rebar.config",
+             {copy, "../../c2.hrl", "include/c.hrl"},
+             {copy, "../../c2.app", "ebin/c.app"},
+             {copy, "../../c.rebar.config", "rebar.config"},
              "git add rebar.config",
-             "git commit -a -m 'update to 1.1'",
+             "git commit -a -m \"update to 1.1\"",
              "git tag 1.1",
-             "cp ../../c3.app ebin/c.app",
-             "cp ../../c2.rebar.config rebar.config",
-             "git commit -a -m 'update to 1.2'",
+             {copy, "../../c3.app", "ebin/c.app"},
+             {copy, "../../c2.rebar.config", "rebar.config"},
+             "git commit -a -m \"update to 1.2\"",
              "git tag 1.2",
-             "cp ../../c4.app ebin/c.app",
-             "cp ../../c3.rebar.config rebar.config",
-             "git commit -a -m 'update to 1.3'",
+             {copy, "../../c4.app", "ebin/c.app"},
+             {copy, "../../c3.rebar.config", "rebar.config"},
+             {touch, "rebar.config"},
+             "git commit -a -m \"update to 1.3\"",
              "git tag 1.3"],
              %"git checkout 1.0"],
     DCmds = ["git tag 0.7"],
     ECmds = ["git tag 2.0",
-             "cp ../../e2.app ebin/e.app",
-             "git commit -a -m 'update to 2.1'",
+             {copy, "../../e2.app", "ebin/e.app"},
+             {touch, "ebin/e.app"},
+             "git commit -a -m \"update to 2.1\"",
              "git tag 2.1"],
     FCmds = ["git tag 0.1"],
 
@@ -126,13 +134,16 @@
 
     {ok, _} = retest_sh:run("./rebar -v get-deps", []),
     {ok, _} = retest_sh:run("./rebar -v compile", []),
-    os:cmd("cp a2.rebar.config apps/a1/rebar.config"),
+    retest:run({copy, "a2.rebar.config", "apps/a1/rebar.config"},
+               [{dir, Dir}]),
     {ok, _} = retest_sh:run("./rebar -v update-deps", []),
     {ok, _} = retest_sh:run("./rebar -v compile", []),
-    os:cmd("cp a3.rebar.config apps/a1/rebar.config"),
+    retest:run({copy, "a3.rebar.config", "apps/a1/rebar.config"},
+               [{dir, Dir}]),
     {ok, _} = retest_sh:run("./rebar -v update-deps", []),
     {ok, _} = retest_sh:run("./rebar -v compile", []),
-    os:cmd("cp a4.rebar.config apps/a1/rebar.config"),
+    retest:run({copy, "a4.rebar.config", "apps/a1/rebar.config"},
+               [{dir, Dir}]),
     {ok, _} = retest_sh:run("./rebar -v update-deps", []),
     {ok, _} = retest_sh:run("./rebar -v compile", []),
     ok.

rebar-2.6.1.tar.gz/inttest/thooks/thooks_rt.erl -> rebar-2.6.4.tar.gz/inttest/thooks/thooks_rt.erl Changed

@@ -5,14 +5,17 @@
 -include_lib("eunit/include/eunit.hrl").
 -compile(export_all).
 
+setup([Target]) ->
+  retest_utils:load_module(filename:join(Target, "inttest_utils.erl")),
+  ok.
+
 files() ->
     [
      %% dummy lfe files
-     {copy, "../../rebar", "rebar"},
      {copy, "rebar.config", "rebar.config"},
      {copy, "fish.erl", "src/fish.erl"},
      {create, "ebin/fish.app", app(fish, [fish])}
-    ].
+    ] ++ inttest_utils:rebar_setup().
 
 run(_Dir) ->
     ?assertMatch({ok, _}, retest_sh:run("./rebar -v clean compile", [])),
@@ -27,7 +30,13 @@
     ?assert(filelib:is_regular(File)),
     %% ensure that this command only ran once (not for each module)
     {ok, Content} = file:read_file(File),
-    ?assertEqual(Command ++ "\n", binary_to_list(Content)).
+    %% echo behaves differently in windows and unix
+    case os:type() of
+        {win32, nt} ->
+            ?assertEqual(Command ++ " \r\n", binary_to_list(Content));
+        _ ->
+            ?assertEqual(Command ++ "\n", binary_to_list(Content))
+    end.
 
 %%
 %% Generate the contents of a simple .app file

rebar-2.6.1.tar.gz/inttest/tplugins/tplugins_rt.erl -> rebar-2.6.4.tar.gz/inttest/tplugins/tplugins_rt.erl Changed

rebar-2.6.4.tar.gz/inttest/vsn_cache Added

rebar-2.6.4.tar.gz/inttest/vsn_cache/main.erl Added

rebar-2.6.4.tar.gz/inttest/vsn_cache/vsn_cache_rt.erl Added

@@ -0,0 +1,90 @@
+%% -*- erlang-indent-level: 4;indent-tabs-mode: nil -*-
+%% ex: ts=4 sw=4 et
+-module(vsn_cache_rt).
+
+-compile(export_all).
+
+setup([Target]) ->
+    retest_utils:load_module(filename:join(Target, "inttest_utils.erl")),
+    ok.
+
+files() ->
+    [
+    %% Cache save check
+    {create, "save/src/save.app.src", app(save, [main])},
+    {create, "save/vsn_cache_file", ""},
+    {copy, "main.erl", "save/src/main.erl"},
+
+    %% Cache load check
+    {create, "load/src/load.app.src", app(load, [main])},
+    {copy, "main.erl", "load/src/main.erl"}
+    ] ++ inttest_utils:rebar_setup().
+
+apply_cmds([], _Params) ->
+    ok;
+apply_cmds([Cmd | Rest], Params) ->
+    io:format("Running: ~s (~p)\n", [Cmd, Params]),
+    {ok, _} = retest_sh:run(Cmd, Params),
+    apply_cmds(Rest, Params).
+
+run_save(Dir) ->
+    GitCmds = ["git init",
+               "git add -A",
+               "git config user.email 'vsn_cache@example.com'",
+               "git config user.name 'vsn_cache'",
+               "git commit -a -m \"Initial Commit\""],
+    AppDir = filename:join(Dir, "save"),
+    EbinDir = filename:join(AppDir, "ebin"),
+    AppFile = filename:join(EbinDir, "save.app"),
+    VsnCacheFile = filename:join(AppDir, "vsn_cache_file"),
+    Env = [{"REBAR_VSN_CACHE_FILE", VsnCacheFile}],
+
+    %% Initialize test git repository 
+    ok = apply_cmds(GitCmds, [{dir, AppDir}]),
+    %% Compile test project with vsn cache enabled
+    {ok, _} = retest_sh:run("../rebar -v compile", [{env, Env}, {dir, AppDir}]),
+    %% Vsn cache file has an entry
+    {ok, [{{git, AppDir}, Hash}]} = file:consult(VsnCacheFile),
+    %% This vsn entry must coincide with entry from ebin/save.app
+    {ok, [{application, save, PropList}]} = file:consult(AppFile),
+    Hash = proplists:get_value(vsn, PropList),
+    ok.
+
+run_load(Dir) ->
+    AppDir = filename:join(Dir, "load"),
+    EbinDir = filename:join(AppDir, "ebin"),
+    AppFile = filename:join(EbinDir, "load.app"),
+    VsnCacheFile = filename:join(AppDir, "vsn_cache_file"),
+    Hash = "deadbeef",
+    CacheEntries = [{{git, AppDir}, Hash}],
+    Env = [{"REBAR_VSN_CACHE_FILE", VsnCacheFile}],
+
+    %% Initialize dummy vsn cache file
+    vsn_cache_file(VsnCacheFile, CacheEntries),
+    %% Compile test project with vsn cache enabled
+    {ok, _} = retest_sh:run("../rebar -v compile", [{env, Env}, {dir, AppDir}]),
+    %% This vsn entry in cache file must coincide with entry in ebin/load.app
+    {ok, [{application, load, PropList}]} = file:consult(AppFile),
+    Hash = proplists:get_value(vsn, PropList),
+    ok.
+
+run(Dir) ->
+    run_save(Dir),
+    run_load(Dir),
+    ok.
+
+%%
+%% Generate the contents of a simple .app file
+%%
+app(Name, Modules) ->
+    App = {application, Name,
+           [{description, atom_to_list(Name)},
+            {vsn, git},
+            {modules, Modules},
+            {registered, []},
+            {applications, [kernel, stdlib]}]},
+    io_lib:format("~p.\n", [App]).
+
+vsn_cache_file(Name, Entries) ->
+    file:write_file(Name,
+        [io_lib:format("~p.~n", [X]) || X <- Entries]).

rebar-2.6.1.tar.gz/inttest/xref_behavior/xref_behavior_rt.erl -> rebar-2.6.4.tar.gz/inttest/xref_behavior/xref_behavior_rt.erl Changed

rebar-2.6.1.tar.gz/priv/templates/simplenode.windows.runner.cmd -> rebar-2.6.4.tar.gz/priv/templates/simplenode.windows.runner.cmd Changed

rebar-2.6.1.tar.gz/rebar.config -> rebar-2.6.4.tar.gz/rebar.config Changed

rebar-2.6.1.tar.gz/rebar.config.sample -> rebar-2.6.4.tar.gz/rebar.config.sample Changed

rebar-2.6.1.tar.gz/rebar.config.script -> rebar-2.6.4.tar.gz/rebar.config.script Changed

rebar-2.6.1.tar.gz/src/rebar.erl -> rebar-2.6.4.tar.gz/src/rebar.erl Changed

@@ -143,7 +143,7 @@
     %% 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
-    rebar_config:set_xconf(BaseConfig1, vsn_cache, dict:new()).
+    rebar_utils:init_vsn_cache(BaseConfig1).
 
 init_config1(BaseConfig) ->
     %% Determine the location of the rebar executable; important for pulling
@@ -220,6 +220,9 @@
         {error, {already_started, _}} -> ok
     end,
 
+    %% Make sure rebar_rnd module is generated, compiled, and loaded
+    {ok, rebar_rnd} = rebar_rand_compat:init("rebar_rnd"),
+
     %% Convert command strings to atoms
     CommandAtoms = [list_to_atom(C) || C <- Commands],
 
@@ -284,7 +287,12 @@
                       {"freebsd", compile, "c_src/freebsd_tweaks.sh"},
                       {eunit, "touch file2.out"},
                       {compile, "touch postcompile.out"}]}
-       ]).
+       ]),
+    ?CONSOLE(
+       "Environment variables:~n"
+       "  REBAR_DEPS_PREFER_LIBS to look for dependecies in system libs prior fetching.~n"
+       "  REBAR_VSN_CACHE_FILE to load vsn cache from and save to specified file.~n"
+       "~n", []).
 
 %%
 %% Parse command line arguments using getopt and also filtering out any
@@ -501,7 +509,9 @@
      {profile,  $p, "profile",  undefined,
       "Profile this run of rebar. Via profiler= you can optionally select "
       "either fprof (default) or eflame. The result can be found in "
-      "fprof.analysis or eflame.svg."},
+      "fprof.analysis or eflame.svg. Additionally, in fprof mode, if "
+      "erlgrind can be found in $PATH, a Cachegrind file (fprof.cgrind) "
+      "will be generated as well."},
      {keep_going, $k, "keep-going", undefined,
       "Keep running after a command fails"},
      {recursive, $r, "recursive", boolean,

rebar-2.6.1.tar.gz/src/rebar_core.erl -> rebar-2.6.4.tar.gz/src/rebar_core.erl Changed

rebar-2.6.1.tar.gz/src/rebar_ct.erl -> rebar-2.6.4.tar.gz/src/rebar_ct.erl Changed

@@ -66,6 +66,7 @@
        "  ~p~n"
        "  ~p~n"
        "  ~p~n"
+       "  ~p~n"
        "Valid command line options:~n"
        "  suites=Suite1,Suite2,...,SuiteN~n"
        "      - run Suite1_SUITE, Suite2_SUITE, ..., SuiteN_SUITE~n"
@@ -81,7 +82,8 @@
         {ct_dir, "itest"},
         {ct_log_dir, "test/logs"},
         {ct_extra_params, "-boot start_sasl -s myapp"},
-        {ct_use_short_names, true}
+        {ct_use_short_names, true},
+        {ct_search_specs_from_test_dir, false}
        ]).
 
 run_test_if_present(TestDir, LogDir, Config, File) ->
@@ -113,7 +115,12 @@
                  false ->
                      " >> " ++ RawLog ++ " 2>&1";
                  true ->
+                 case os:type() of
+                   {win32, nt} ->
+                     " >> " ++ RawLog ++ " 2>&1";
+                   _ ->
                      " 2>&1 | tee -a " ++ RawLog
+                 end
              end,
 
     ShOpts = [{env,[{"TESTDIR", TestDir}]}, return_on_error],
@@ -155,14 +162,27 @@
 check_fail_log(Config, RawLog, Command, Result) ->
     check_log(Config, RawLog, failure_logger(Command, Result)).
 
-check_log(Config,RawLog,Fun) ->
-    {ok, Msg} =
-        rebar_utils:sh("grep -e \"TEST COMPLETE\" -e \"{error,make_failed}\" "
-                       ++ RawLog, [{use_stdout, false}]),
-    MakeFailed = string:str(Msg, "{error,make_failed}") =/= 0,
-    RunFailed = string:str(Msg, ", 0 failed") =:= 0,
+check_log(Config,RawLogFilename,Fun) ->
+    %% read the file and split into a list separated by newlines
+    {ok, RawLog} = file:read_file(RawLogFilename),
+    Msg = string:tokens(binary_to_list(RawLog), "\n"),
+    %% now filter out all the list entries that do not have test
+    %% completion strings
+    CompleteRuns = lists:filter(fun(M) ->
+                                  string:str(M, "TEST COMPLETE") =/= 0
+                                end, Msg),
+    MakeFailed = lists:filter(fun(M) ->
+                                  string:str(M, "{error,make_failed}") =/= 0
+                              end, Msg),
+    %% the run has failed if at least one of the tests failed
+    RunFailed = lists:foldl(fun(M, Acc) ->
+                              %% the "0 failed" string must be present for
+                              %% the test to be considered successful
+                              TestFailed = string:str(M, "0 failed") =:= 0,
+                              TestFailed orelse Acc
+                            end, false, CompleteRuns),
     if
-        MakeFailed ->
+        MakeFailed =/= [] ->
             show_log(Config, RawLog),
             ?ERROR("Building tests failed\n",[]),
             ?FAIL;
@@ -182,8 +202,7 @@
     ?CONSOLE("Showing log\n", []),
     case rebar_log:is_verbose(Config) of
         false ->
-            {ok, Contents} = file:read_file(RawLog),
-            ?CONSOLE("~s", [Contents]);
+            ?CONSOLE("~s", [RawLog]);
         true ->
             ok
     end.
@@ -218,7 +237,7 @@
     CodeDirs = [io_lib:format("\"~s\"", [Dir]) ||
                    Dir <- [EbinDir|NonLibCodeDirs]],
     CodePathString = string:join(CodeDirs, " "),
-    Cmd = case get_ct_specs(Config, Cwd) of
+    Cmd = case get_ct_specs(Config, search_ct_specs_from(Cwd, TestDir, Config)) of
               undefined ->
                   ?FMT("~s"
                        " -pa ~s"
@@ -259,10 +278,20 @@
     RawLog = filename:join(LogDir, "raw.log"),
     {Cmd, RawLog}.
 
+search_ct_specs_from(Cwd, TestDir, Config) ->
+    case rebar_config:get_local(Config, ct_search_specs_from_test_dir, false) of
+        true -> filename:join(Cwd, TestDir);
+        false ->
+          Cwd
+    end.
+
 build_name(Config) ->
+    %% generate a unique name for our test node, we want
+    %% to make sure the odds of name clashing are low
+    Random = integer_to_list(crypto:rand_uniform(0, 10000)),
     case rebar_config:get_local(Config, ct_use_short_names, false) of
-        true -> "-sname test";
-        false -> " -name test@" ++ net_adm:localhost()
+        true -> "-sname test" ++ Random;
+        false -> " -name test" ++ Random ++ "@" ++ net_adm:localhost()
     end.
 
 get_extra_params(Config) ->

rebar-2.6.1.tar.gz/src/rebar_deps.erl -> rebar-2.6.4.tar.gz/src/rebar_deps.erl Changed

@@ -58,16 +58,19 @@
     %% used globally since it will be set on the first time through here
     Config1 = set_shared_deps_dir(Config, get_shared_deps_dir(Config, [])),
 
+    %% Check whether user forced deps resolution via system wide libs
+    Config2 = set_deps_prefer_libs(Config1, get_deps_prefer_libs(Config1, undefined)),
+
     %% Get the list of deps for the current working directory and identify those
     %% deps that are available/present.
-    Deps = rebar_config:get_local(Config1, deps, []),
-    {Config2, {AvailableDeps, MissingDeps}} = find_deps(Config1, find, Deps),
+    Deps = rebar_config:get_local(Config2, deps, []),
+    {Config3, {AvailableDeps, MissingDeps}} = find_deps(Config2, find, Deps),
 
     ?DEBUG("Available deps: ~p\n", [AvailableDeps]),
     ?DEBUG("Missing deps  : ~p\n", [MissingDeps]),
 
     %% Add available deps to code path
-    Config3 = update_deps_code_path(Config2, AvailableDeps),
+    Config4 = update_deps_code_path(Config3, AvailableDeps),
 
     %% Filtering out 'raw' dependencies so that no commands other than
     %% deps-related can be executed on their directories.
@@ -83,8 +86,8 @@
                           fun(D, Acc) ->
                                   rebar_config:set_skip_dir(Acc, D#dep.dir)
                           end,
-                          Config3,
-                          collect_deps(rebar_utils:get_cwd(), Config3)),
+                          Config4,
+                          collect_deps(rebar_utils:get_cwd(), Config4)),
             %% Return the empty list, as we don't want anything processed before
             %% us.
             {ok, NewConfig, []};
@@ -97,12 +100,12 @@
             %% Also, if skip_deps=comma,separated,app,list, then only the given
             %% dependencies are skipped.
             NewConfig =
-                case rebar_config:get_global(Config3, skip_deps, false) of
+                case rebar_config:get_global(Config4, skip_deps, false) of
                     "true" ->
                         lists:foldl(
                           fun(#dep{dir = Dir}, C) ->
                                   rebar_config:set_skip_dir(C, Dir)
-                          end, Config3, AvailableDeps);
+                          end, Config4, AvailableDeps);
                     Apps when is_list(Apps) ->
                         SkipApps = [list_to_atom(App) ||
                                        App <- string:tokens(Apps, ",")],
@@ -112,9 +115,9 @@
                                       true -> rebar_config:set_skip_dir(C, Dir);
                                       false -> C
                                   end
-                          end, Config3, AvailableDeps);
+                          end, Config4, AvailableDeps);
                     _ ->
-                        Config3
+                        Config4
                 end,
 
             %% Return all the available dep directories for process
@@ -254,7 +257,9 @@
        "  ~p~n"
        "  ~p~n"
        "Valid command line options:~n"
-       "  deps_dir=\"deps\" (override default or rebar.config deps_dir)~n",
+       "  deps_dir=\"deps\" (override default or rebar.config deps_dir)~n"
+       "Environment variables:~n"
+       "  REBAR_DEPS_PREFER_LIBS to look for dependecies in system libs prior fetching.~n",
        [
         Description,
         {deps_dir, "deps"},
@@ -263,15 +268,24 @@
           {rebar, "1.0.*"},
           {rebar, ".*",
            {git, "git://github.com/rebar/rebar.git"}},
+          {rebar,
+           {git, "git://github.com/rebar/rebar.git"}},
           {rebar, ".*",
            {git, "git://github.com/rebar/rebar.git", "Rev"}},
+          {rebar,
+           {git, "git://github.com/rebar/rebar.git", "Rev"}},
           {rebar, "1.0.*",
            {git, "git://github.com/rebar/rebar.git", {branch, "master"}}},
+          {rebar,
+           {git, "git://github.com/rebar/rebar.git", {branch, "master"}}},
           {rebar, "1.0.0",
            {git, "git://github.com/rebar/rebar.git", {tag, "1.0.0"}}},
           {rebar, "",
            {git, "git://github.com/rebar/rebar.git", {branch, "master"}},
            [raw]},
+          {rebar,
+           {git, "git://github.com/rebar/rebar.git", {branch, "master"}},
+           [raw]},
           {app_name, ".*", {hg, "https://www.example.org/url"}},
           {app_name, ".*", {rsync, "Url"}},
           {app_name, ".*", {svn, "https://www.example.org/url"}},
@@ -302,6 +316,18 @@
 get_shared_deps_dir(Config, Default) ->
     rebar_config:get_xconf(Config, deps_dir, Default).
 
+set_deps_prefer_libs(Config, undefined) ->
+    DepsPreferLibs = case os:getenv("REBAR_DEPS_PREFER_LIBS") of
+        false -> false;
+        _ -> true
+    end,
+    rebar_config:set_xconf(Config, deps_prefer_libs, DepsPreferLibs);
+set_deps_prefer_libs(Config, _DepsPreferLibs) ->
+    Config.
+
+get_deps_prefer_libs(Config, Default) ->
+    rebar_config:get_xconf(Config, deps_prefer_libs, Default).
+
 get_deps_dir(Config) ->
     get_deps_dir(Config, "").
 
@@ -354,8 +380,12 @@
     {Config, lists:reverse(Deps)};
 find_deps(Config, Mode, [App | Rest], Acc) when is_atom(App) ->
     find_deps(Config, Mode, [{App, ".*", undefined} | Rest], Acc);
+find_deps(Config, Mode, [{App, Source} | Rest], Acc) when is_tuple(Source) ->
+    find_deps(Config, Mode, [{App, ".*", Source} | Rest], Acc);
 find_deps(Config, Mode, [{App, VsnRegex} | Rest], Acc) when is_atom(App) ->
     find_deps(Config, Mode, [{App, VsnRegex, undefined} | Rest], Acc);
+find_deps(Config, Mode, [{App, Source, Opts} | Rest], Acc) when is_tuple(Source) ->
+    find_deps(Config, Mode, [{App, ".*", Source, Opts} | Rest], Acc);
 find_deps(Config, Mode, [{App, VsnRegex, Source} | Rest], Acc) ->
     find_deps(Config, Mode, [{App, VsnRegex, Source, []} | Rest], Acc);
 find_deps(Config, Mode, [{App, VsnRegex, Source, Opts} | Rest], Acc)
@@ -378,9 +408,15 @@
     %% e.g. {git, "https://github.com/mochi/mochiweb.git", "HEAD"}
     %% Deps with a source must be found (or fetched) locally.
     %% Those without a source may be satisfied from lib dir (get_lib_dir).
-    find_dep(Config, Dep, Dep#dep.source).
-
-find_dep(Config, Dep, undefined) ->
+    DepsPreferLibs = get_deps_prefer_libs(Config, false),
+    Mode = case {Dep#dep.source, DepsPreferLibs} of
+        {undefined, _DepsPreferLibs} -> maybe_in_lib;
+        {_DepSource, true} -> maybe_in_lib;
+        {_DepSource, false} -> local_only
+    end,
+    find_dep(Config, Dep, Mode).
+
+find_dep(Config, Dep, maybe_in_lib) ->
     %% '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(Config, Dep#dep.app)) of
@@ -389,7 +425,7 @@
         {Config1, {missing, _}} ->
             find_dep_in_dir(Config1, Dep, get_lib_dir(Dep#dep.app))
     end;
-find_dep(Config, Dep, _Source) ->
+find_dep(Config, Dep, local_only) ->
     %% _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

rebar-2.6.1.tar.gz/src/rebar_dia_compiler.erl -> rebar-2.6.4.tar.gz/src/rebar_dia_compiler.erl Changed

rebar-2.6.1.tar.gz/src/rebar_eunit.erl -> rebar-2.6.4.tar.gz/src/rebar_eunit.erl Changed

@@ -128,6 +128,7 @@
        "               name starts with bar and, if no such test exists,~n"
        "               run the test whose name starts with bar in the~n"
        "               suite's _tests module)~n"
+       "  test[s]=\"foo:bar_test\" (Run bar_test located in module foo)~n"
        "  random_suite_order=true (Run tests in random order)~n"
        "  random_suite_order=Seed (Run tests in random order,~n"
        "                           with the PRNG seeded with Seed)~n"
@@ -292,9 +293,9 @@
     end.
 
 randomize_suites1(Modules, Seed) ->
-    _ = random:seed(35, Seed, 1337),
+    _ = rebar_rnd:seed({35, Seed, 1337}),
     ?CONSOLE("Randomizing suite order with seed ~b~n", [Seed]),
-    [X||{_,X} <- lists:sort([{random:uniform(), M} || M <- Modules])].
+    [X||{_,X} <- lists:sort([{rebar_rnd:uniform(), M} || M <- Modules])].
 
 %%
 %% == get matching tests ==
@@ -460,7 +461,7 @@
                             %% Generator
                             MakePrimitive(generator, M, F2)
                     end,
-                [NewFunction|Acc]
+                [eunit_module_suite(M, NewFunction)|Acc]
         end,
     lists:foldl(F, [], RawTests).
 
@@ -472,6 +473,11 @@
 pre15b02_eunit_primitive(generator, M, F) ->
     {generator, eunit_test:function_wrapper(M, F)}.
 
+% Add a test group for eunit_surefire to be able to deduce the testsuite.
+% Calling eunit:test({module, M}) does exactly this as well.
+eunit_module_suite(M, X) ->
+    {"module '" ++ atom_to_list(M) ++ "'", X}.
+
 %%
 %% == run tests ==
 %%

rebar-2.6.1.tar.gz/src/rebar_file_utils.erl -> rebar-2.6.4.tar.gz/src/rebar_file_utils.erl Changed

@@ -88,7 +88,7 @@
                         ?FMT("move /y \"~s\" \"~s\" 1> nul",
                              [filename:nativename(Source),
                               filename:nativename(Dest)]),
-                        [{use_stdout, false}, return_on_error]),
+                        [{use_stdout, false}, abort_on_error]),
             case R of
                 [] ->
                     ok;
@@ -131,14 +131,14 @@
 delete_each_dir_win32([Dir | Rest]) ->
     {ok, []} = rebar_utils:sh(?FMT("rd /q /s \"~s\"",
                                    [filename:nativename(Dir)]),
-                              [{use_stdout, false}, return_on_error]),
+                              [{use_stdout, false}, abort_on_error]),
     delete_each_dir_win32(Rest).
 
 xcopy_win32(Source,Dest)->
     {ok, R} = rebar_utils:sh(
                 ?FMT("xcopy \"~s\" \"~s\" /q /y /e 2> nul",
                      [filename:nativename(Source), filename:nativename(Dest)]),
-                [{use_stdout, false}, return_on_error]),
+                [{use_stdout, false}, abort_on_error]),
     case length(R) > 0 of
         %% when xcopy fails, stdout is empty and and error message is printed
         %% to stderr (which is redirected to nul)
@@ -162,8 +162,10 @@
     cp_r_win32(S, {false, filename:join(DestDir, filename:basename(Source))});
 cp_r_win32({false, Source},{false, Dest}) ->
     %% from file to file
-    {ok,_} = file:copy(Source, Dest),
-    ok;
+    case file:copy(Source, Dest) of
+        {ok,_} -> ok;
+        _ -> throw(rebar_abort)
+    end;
 cp_r_win32({true, SourceDir}, {false, DestDir}) ->
     case filelib:is_regular(DestDir) of
         true ->

rebar-2.6.1.tar.gz/src/rebar_neotoma_compiler.erl -> rebar-2.6.4.tar.gz/src/rebar_neotoma_compiler.erl Changed

@@ -40,7 +40,7 @@
 %% source_ext: extension of peg source files
 -module(rebar_neotoma_compiler).
 
--export([compile/2]).
+-export([compile/2, clean/2]).
 
 %% for internal use only
 -export([info/2]).
@@ -59,6 +59,20 @@
                             option(module_ext, NeoOpts) ++ ".erl",
                             fun compile_neo/3, [{check_last_mod, true}]).
 
+-spec clean(rebar_config:config(), file:filename()) -> 'ok'.
+clean(Config, _AppFile) ->
+    NeoOpts = neotoma_opts(Config),
+    GeneratedFiles = neotoma_generated_files(
+                       option(out_dir, NeoOpts),
+                       option(module_ext, NeoOpts),
+                       neotoma_source_files(
+                         option(doc_root, NeoOpts),
+                         option(source_ext, NeoOpts)
+                        )
+                      ),
+    ok = rebar_file_utils:delete_each(GeneratedFiles),
+    ok.
+
 %% ============================================================================
 %% Internal functions
 %% ============================================================================
@@ -161,3 +175,20 @@
         _ -> referenced_pegs1(sets:to_list(New), Config,
                               sets:union(New, Seen))
     end.
+
+neotoma_source_files(SrcDir, Ext) ->
+    lists:map(
+      fun filename:basename/1,
+      filelib:wildcard(filename:join([SrcDir, "*" ++ Ext]))
+     ).
+
+
+neotoma_generated_files(OutDir, ModExt, SourceFiles) ->
+    lists:map(
+      fun(PegFile) ->
+              Base = filename:rootname(PegFile),
+              NewName = Base ++ ModExt ++ ".erl",
+              filename:join(OutDir, NewName)
+      end,
+      SourceFiles
+     ).

rebar-2.6.1.tar.gz/src/rebar_port_compiler.erl -> rebar-2.6.4.tar.gz/src/rebar_port_compiler.erl Changed

@@ -36,10 +36,11 @@
 -include("rebar.hrl").
 
 -record(spec, {type::'drv' | 'exe',
+               link_lang::'cc' | 'cxx',
                target::file:filename(),
                sources = [] :: [file:filename(), ...],
                objects = [] :: [file:filename(), ...],
-               opts = [] ::list() | []}).
+               opts = [] :: list() | []}).
 
 %% ===================================================================
 %% Public API
@@ -65,13 +66,15 @@
             %% Only relink if necessary, given the Target
             %% and list of new binaries
             lists:foreach(
-              fun(#spec{target=Target, objects=Bins, opts=Opts}) ->
+              fun(#spec{target=Target, objects=Bins, opts=Opts,
+                        link_lang=LinkLang}) ->
                       AllBins = [sets:from_list(Bins),
                                  sets:from_list(NewBins)],
                       Intersection = sets:intersection(AllBins),
                       case needs_link(Target, sets:to_list(Intersection)) of
                           true ->
-                              LinkTemplate = select_link_template(Target),
+                              LinkTemplate = select_link_template(LinkLang,
+                                                                  Target),
                               Env = proplists:get_value(env, Opts, SharedEnv),
                               Cmd = expand_command(LinkTemplate, Env,
                                                    string:join(Bins, " "),
@@ -140,12 +143,14 @@
        "           EXE_CFLAGS  - flags that will be used for compiling~n"
        "           EXE_LDFLAGS - flags that will be used for linking~n"
        "           ERL_EI_LIBDIR - ei library directory~n"
-       "           DRV_CXX_TEMPLATE  - C++ command template~n"
-       "           DRV_CC_TEMPLATE   - C command template~n"
-       "           DRV_LINK_TEMPLATE - Linker command template~n"
-       "           EXE_CXX_TEMPLATE  - C++ command template~n"
-       "           EXE_CC_TEMPLATE   - C command template~n"
-       "           EXE_LINK_TEMPLATE - Linker command template~n"
+       "           DRV_CXX_TEMPLATE      - C++ command template~n"
+       "           DRV_CC_TEMPLATE       - C command template~n"
+       "           DRV_LINK_TEMPLATE     - C Linker command template~n"
+       "           DRV_LINK_CXX_TEMPLATE - C++ Linker command template~n"
+       "           EXE_CXX_TEMPLATE      - C++ command template~n"
+       "           EXE_CC_TEMPLATE       - C command template~n"
+       "           EXE_LINK_TEMPLATE     - C Linker command template~n"
+       "           EXE_LINK_CXX_TEMPLATE - C++ Linker command template~n"
        "~n"
        "           Note that if you wish to extend (vs. replace) these variables,~n"
        "           you MUST include a shell-style reference in your definition.~n"
@@ -211,29 +216,72 @@
 %%
 
 compile_sources(Config, Specs, SharedEnv) ->
-    lists:foldl(
-      fun(#spec{sources=Sources, type=Type, opts=Opts}, NewBins) ->
-              Env = proplists:get_value(env, Opts, SharedEnv),
-              compile_each(Config, Sources, Type, Env, NewBins)
-      end, [], Specs).
-
-compile_each(_Config, [], _Type, _Env, NewBins) ->
-    lists:reverse(NewBins);
-compile_each(Config, [Source | Rest], Type, Env, NewBins) ->
+    {NewBins, Db} =
+        lists:foldl(
+          fun(#spec{sources=Sources, type=Type, opts=Opts}, Acc) ->
+                  Env = proplists:get_value(env, Opts, SharedEnv),
+                  compile_each(Config, Sources, Type, Env, Acc)
+          end, {[], []}, Specs),
+    %% Rewrite clang compile commands database file only if something
+    %% was compiled.
+    case NewBins of
+        [] ->
+            ok;
+        _ ->
+            {ok, ClangDbFile} = file:open("compile_commands.json", [write]),
+            ok = io:fwrite(ClangDbFile, "[~n", []),
+            lists:foreach(fun(E) -> ok = io:fwrite(ClangDbFile, E, []) end, Db),
+            ok = io:fwrite(ClangDbFile, "]~n", []),
+            ok = file:close(ClangDbFile)
+    end,
+    NewBins.
+
+compile_each(_Config, [], _Type, _Env, {NewBins, CDB}) ->
+    {lists:reverse(NewBins), lists:reverse(CDB)};
+compile_each(Config, [Source | Rest], Type, Env, {NewBins, CDB}) ->
     Ext = filename:extension(Source),
     Bin = replace_extension(Source, Ext, ".o"),
+    Template = select_compile_template(Type, compiler(Ext)),
+    Cmd = expand_command(Template, Env, Source, Bin),
+    CDBEnt = cdb_entry(Source, Cmd, Rest),
+    NewCDB = [CDBEnt | CDB],
     case needs_compile(Source, Bin) of
         true ->
-            Template = select_compile_template(Type, compiler(Ext)),
-            Cmd = expand_command(Template, Env, Source, Bin),
             ShOpts = [{env, Env}, return_on_error, {use_stdout, false}],
             exec_compiler(Config, Source, Cmd, ShOpts),
-            compile_each(Config, Rest, Type, Env, [Bin | NewBins]);
+            compile_each(Config, Rest, Type, Env,
+                         {[Bin | NewBins], NewCDB});
         false ->
             ?INFO("Skipping ~s\n", [Source]),
-            compile_each(Config, Rest, Type, Env, NewBins)
+            compile_each(Config, Rest, Type, Env, {NewBins, NewCDB})
     end.
 
+%% Generate a clang compilation db entry for Src and Cmd
+cdb_entry(Src, Cmd, SrcRest) ->
+    %% Omit all variables from cmd, and use that as cmd in
+    %% CDB, because otherwise clang-* will complain about it.
+    CDBCmd = string:join(
+               lists:filter(
+                 fun("$"++_) -> false;
+                    (_)      -> true
+                 end,
+                 string:tokens(Cmd, " ")),
+               " "),
+
+    Cwd = rebar_utils:get_cwd(),
+    %% If there are more source files, make sure we end the CDB entry
+    %% with a comma.
+    Sep = case SrcRest of
+              [] -> "~n";
+              _  -> ",~n"
+          end,
+    %% CDB entry
+    ?FMT("{ \"file\"      : ~p~n"
+         ", \"directory\" : ~p~n"
+         ", \"command\"   : ~p~n"
+         "}~s",
+         [Src, Cwd, CDBCmd, Sep]).
+
 exec_compiler(Config, Source, Cmd, ShOpts) ->
     case rebar_utils:sh(Cmd, ShOpts) of
         {error, {_RC, RawError}} ->
@@ -323,6 +371,7 @@
     Sources = port_sources(rebar_config:get_list(Config, port_sources,
                                                  ["c_src/*.c"])),
     #spec { type = target_type(Target),
+            link_lang = cc,
             target = maybe_switch_extension(os:type(), Target),
             sources = Sources,
             objects = port_objects(Sources) }.
@@ -343,9 +392,18 @@
     get_port_spec(Config, OsType, {Arch, Target, Sources, []});
 get_port_spec(Config, OsType, {_Arch, Target, Sources, Opts}) ->
     SourceFiles = port_sources(Sources),
+    LinkLang =
+        case lists:any(
+               fun(Src) -> compiler(filename:extension(Src)) == "$CXX" end,
+               SourceFiles)
+        of
+            true  -> cxx;
+            false -> cc
+        end,
     ObjectFiles = port_objects(SourceFiles),
     #spec{type=target_type(Target),
           target=maybe_switch_extension(OsType, Target),
+          link_lang=LinkLang,
           sources=SourceFiles,
           objects=ObjectFiles,
           opts=port_opts(Config, Opts)}.
@@ -548,10 +606,12 @@
 select_compile_exe_template("$CC")  -> "EXE_CC_TEMPLATE";
 select_compile_exe_template("$CXX") -> "EXE_CXX_TEMPLATE".
 
-select_link_template(Target) ->
-    case target_type(Target) of
-        drv -> "DRV_LINK_TEMPLATE";
-        exe -> "EXE_LINK_TEMPLATE"
+select_link_template(LinkLang, Target) ->
+    case {LinkLang, target_type(Target)} of
+        {cc,  drv} -> "DRV_LINK_TEMPLATE";
+        {cxx, drv} -> "DRV_LINK_CXX_TEMPLATE";
+        {cc,  exe} -> "EXE_LINK_TEMPLATE";
+        {cxx, exe} -> "EXE_LINK_CXX_TEMPLATE"
     end.
 
 target_type(Target) -> target_type1(filename:extension(Target)).
@@ -573,8 +633,8 @@
     Arch = os:getenv("REBAR_TARGET_ARCH"),
     Vsn = os:getenv("REBAR_TARGET_ARCH_VSN"),
     [
-     {"CC", get_tool(Arch, Vsn,"gcc", "cc")},
-     {"CXX", get_tool(Arch, Vsn,"g++", "c++")},
+     {"CC", get_tool(Arch, Vsn, "gcc", "cc")},
+     {"CXX", get_tool(Arch, Vsn, "g++", "c++")},
      {"AR", get_tool(Arch, "ar", "ar")},
      {"AS", get_tool(Arch, "as", "as")},
      {"CPP", get_tool(Arch, Vsn, "cpp", "cpp")},
@@ -591,12 +651,16 @@
       "$CC -c $CFLAGS $DRV_CFLAGS $PORT_IN_FILES -o $PORT_OUT_FILE"},
      {"DRV_LINK_TEMPLATE",
       "$CC $PORT_IN_FILES $LDFLAGS $DRV_LDFLAGS -o $PORT_OUT_FILE"},
+     {"DRV_LINK_CXX_TEMPLATE",
+      "$CXX $PORT_IN_FILES $LDFLAGS $DRV_LDFLAGS -o $PORT_OUT_FILE"},
      {"EXE_CXX_TEMPLATE",
       "$CXX -c $CXXFLAGS $EXE_CFLAGS $PORT_IN_FILES -o $PORT_OUT_FILE"},
      {"EXE_CC_TEMPLATE",
       "$CC -c $CFLAGS $EXE_CFLAGS $PORT_IN_FILES -o $PORT_OUT_FILE"},
      {"EXE_LINK_TEMPLATE",
       "$CC $PORT_IN_FILES $LDFLAGS $EXE_LDFLAGS -o $PORT_OUT_FILE"},
+     {"EXE_LINK_CXX_TEMPLATE",
+      "$CXX $PORT_IN_FILES $LDFLAGS $EXE_LDFLAGS -o $PORT_OUT_FILE"},
      {"DRV_CFLAGS" , "-g -Wall -fPIC -MMD $ERL_CFLAGS"},
      {"DRV_LDFLAGS", "-shared $ERL_LDFLAGS"},
      {"EXE_CFLAGS" , "-g -Wall -fPIC -MMD $ERL_CFLAGS"},
@@ -624,12 +688,17 @@
      %% OS X Leopard flags for 64-bit
      {"darwin9.*-64$", "CFLAGS", "-m64 $CFLAGS"},
      {"darwin9.*-64$", "CXXFLAGS", "-m64 $CXXFLAGS"},
-     {"darwin9.*-64$", "LDFLAGS", "-arch x86_64 $LDFLAGS"},
+     {"darwin9.*-64$", "LDFLAGS", "-arch x86_64 -flat_namespace -undefined suppress $LDFLAGS"},
+
+     %% OS X Lion onwards flags for 64-bit
+     {"darwin1[0-4].*-64$", "CFLAGS", "-m64 $CFLAGS"},
+     {"darwin1[0-4].*-64$", "CXXFLAGS", "-m64 $CXXFLAGS"},
+     {"darwin1[0-4].*-64$", "LDFLAGS", "-arch x86_64 -flat_namespace -undefined suppress $LDFLAGS"},
 
      %% OS X Snow Leopard, Lion, and Mountain Lion flags for 32-bit
      {"darwin1[0-2].*-32", "CFLAGS", "-m32 $CFLAGS"},
      {"darwin1[0-2].*-32", "CXXFLAGS", "-m32 $CXXFLAGS"},
-     {"darwin1[0-2].*-32", "LDFLAGS", "-arch i386 $LDFLAGS"},
+     {"darwin1[0-2].*-32", "LDFLAGS", "-arch i386 -flat_namespace -undefined suppress $LDFLAGS"},
 
      %% Windows specific flags
      %% add MS Visual C++ support to rebar on Windows

rebar-2.6.1.tar.gz/src/rebar_qc.erl -> rebar-2.6.4.tar.gz/src/rebar_qc.erl Changed

rebar-2.6.4.tar.gz/src/rebar_rand_compat.erl Added

@@ -0,0 +1,178 @@
+%%% -*- erlang-indent-level: 4;indent-tabs-mode: nil -*-
+%%% ex: ts=4 sw=4 et
+%%%
+%%% Copyright (c) 2016 Tuncer Ayaz
+%%%
+%%% Permission to use, copy, modify, and/or distribute this software
+%%% for any purpose with or without fee is hereby granted, provided
+%%% that the above copyright notice and this permission notice appear
+%%% in all copies.
+%%%
+%%% THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+%%% WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+%%% WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+%%% AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR
+%%% CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+%%% LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+%%% NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+%%% CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+-module(rebar_rand_compat).
+
+%% API
+-export([ init/0
+        , init/1
+        ]).
+
+-define(DEFAULT_MODNAME, "rnd").
+
+%%%===================================================================
+%%% API
+%%%===================================================================
+
+%%--------------------------------------------------------------------
+%% @doc
+%% Generate, compile and load rnd module.
+%% @end
+%%--------------------------------------------------------------------
+-spec init() -> {'ok', module()}.
+init() ->
+    init(?DEFAULT_MODNAME).
+
+%%--------------------------------------------------------------------
+%% @doc
+%% Generate, compile and load ModName module.
+%% @end
+%%--------------------------------------------------------------------
+-spec init(string()) -> {'ok', module()}.
+init(ModName) ->
+    %% First, select the right module, then generate the appropriate code as a
+    %% string, and finally compile and load it as ModName.
+    Src = select(ModName),
+    {ok, Mod, Bin, []} = compile(Src),
+    {module, Mod} = code:load_binary(Mod, ModName++".erl", Bin),
+    {ok, Mod}.
+
+%%%===================================================================
+%%% Internal functions
+%%%===================================================================
+
+%% Select right rand module and return wrapper module's source as string
+-spec select(string()) -> string().
+select(ModName) ->
+    case code:which(rand) of
+        non_existing ->
+            src(ModName, fun funs_random/0);
+        _ ->
+            src(ModName, fun funs_rand/0)
+    end.
+
+%% Return module's implementation as a string.
+-spec src(string(), fun(() -> binary())) -> string().
+src(ModName, GenFuns) ->
+    lists:flatten(
+      io_lib:format(
+        <<"
+-module(~s).
+-export([ seed/0
+        , seed/1
+        , uniform/0
+        , uniform/1
+        , uniform_s/1
+        , uniform_s/2
+        ]).
+
+%% Functions
+~s
+">>
+, [ModName, GenFuns()])).
+
+%% random.beam wrapper
+funs_random() ->
+    <<"
+seed()           -> random:seed().
+seed(Exp)        -> random:seed(Exp).
+uniform()        -> random:uniform().
+uniform(N)       -> random:uniform(N).
+uniform_s(St)    -> random:uniform_s(St).
+uniform_s(N, St) -> random:uniform_s(N, St).
+">>.
+
+%% rand.beam wrapper
+funs_rand() ->
+    <<"
+seed()           -> rand:seed(exsplus).
+seed(Exp)        -> rand:seed(exsplus, Exp).
+uniform()        -> rand:uniform().
+uniform(N)       -> rand:uniform(N).
+uniform_s(St)    -> rand:uniform_s(St).
+uniform_s(N, St) -> rand:uniform_s(N, St).
+">>.
+
+compile(String) ->
+    Forms = convert(String ++ eof, []),
+    compile:forms(Forms, [return]).
+
+%% Parse string into forms for compiler.
+convert({done, {eof, _EndLocation}, _LeftOverChars}, Acc)->
+    %% Finished
+    lists:reverse(Acc);
+convert({done, {error, ErrorInfo, _EndLocation}, _LeftOverChars}, _Acc)->
+    ErrorInfo;
+convert({done, {ok, Tokens, _EndLocation}, LeftOverChars}, Acc)->
+    case erl_parse:parse_form(Tokens) of
+        {ok, AbsForm} ->
+            convert(LeftOverChars, [AbsForm|Acc]);
+        {error, AbsForm} ->
+            convert(LeftOverChars, AbsForm)
+    end;
+convert({more, Continuation}, Acc)->
+    convert(erl_scan:tokens(Continuation, [], 1), Acc);
+convert(String, Acc) ->
+    convert(erl_scan:tokens([], String, 1), Acc).
+
+%%%===================================================================
+%%% Tests
+%%%===================================================================
+
+-ifdef(TEST).
+-include_lib("eunit/include/eunit.hrl").
+
+init_test() ->
+    DefMod = list_to_atom(?DEFAULT_MODNAME),
+    ok = unload(DefMod),
+    ?assertMatch(false, code:is_loaded(DefMod)),
+    ?assertMatch({ok, DefMod}, init()),
+    ?assertMatch({file, _}, code:is_loaded(DefMod)),
+    check_api(DefMod),
+    CustomMod = foornd,
+    CustomName = "foornd",
+    ok = unload(CustomMod),
+    ?assertMatch(false, code:is_loaded(CustomMod)),
+    ?assertMatch({ok, CustomMod}, init(CustomName)),
+    ?assertMatch({file, _}, code:is_loaded(CustomMod)),
+    check_api(CustomMod).
+
+unload(Mod) ->
+    case code:is_loaded(Mod) of
+        false ->
+            ok;
+        {file, _} ->
+            code:delete(Mod),
+            code:purge(Mod),
+            ok
+    end.
+
+check_api(Mod) ->
+    Exports = [ {seed, 0}
+              , {seed, 1}
+              , {uniform, 0}
+              , {uniform, 1}
+              , {uniform_s, 1}
+              , {uniform_s, 2}
+              , {module_info, 0}
+              , {module_info, 1}
+              ],
+    ?assertMatch(Exports, Mod:module_info(exports)).
+
+-endif.

rebar-2.6.1.tar.gz/src/rebar_require_vsn.erl -> rebar-2.6.4.tar.gz/src/rebar_require_vsn.erl Changed

@@ -31,7 +31,8 @@
 -include("rebar.hrl").
 
 -export([compile/2,
-         eunit/2]).
+         eunit/2,
+         version_tuple/1]).
 
 %% for internal use only
 -export([info/2,
@@ -103,12 +104,12 @@
     case rebar_config:get(Config, require_min_otp_vsn, undefined) of
         undefined -> ?DEBUG("Min OTP version unconfigured~n", []);
         MinOtpVsn ->
-            {MinMaj, MinMin} = version_tuple(ShouldAbort, MinOtpVsn,
+            {MinMaj, MinMin, MinPatch} = version_tuple(ShouldAbort, MinOtpVsn,
                                              "configured"),
-            {OtpMaj, OtpMin} = version_tuple(ShouldAbort,
+            {OtpMaj, OtpMin, OtpPatch} = version_tuple(ShouldAbort,
                                              erlang:system_info(otp_release),
                                              "OTP Release"),
-            case {OtpMaj, OtpMin} >= {MinMaj, MinMin} of
+            case {OtpMaj, OtpMin, OtpPatch} >= {MinMaj, MinMin, MinPatch} of
                 true ->
                     ?DEBUG("~s satisfies the requirement for vsn ~s~n",
                            [erlang:system_info(otp_release),
@@ -122,12 +123,17 @@
             end
     end.
 
+version_tuple(OtpRelease) ->
+    version_tuple(keep_going, OtpRelease, "").
+
 version_tuple(ShouldAbort, OtpRelease, Type) ->
-    case re:run(OtpRelease, "R?(\\d+)B?-?(\\d+)?", [{capture, all, list}]) of
+    case re:run(OtpRelease, "R?(\\d+)B?\.?(\\d+)?\.?-?(\\d+)?", [{capture, all, list}]) of
+        {match, [_Full, Maj, Min, Patch]} ->
+            {list_to_integer(Maj), list_to_integer(Min), list_to_integer(Patch)};
         {match, [_Full, Maj, Min]} ->
-            {list_to_integer(Maj), list_to_integer(Min)};
+            {list_to_integer(Maj), list_to_integer(Min), 0};
         {match, [_Full, Maj]} ->
-            {list_to_integer(Maj), 0};
+            {list_to_integer(Maj), 0, 0};
         nomatch ->
             maybe_abort(ShouldAbort,
                         "Cannot parse ~s version string: ~s~n",

rebar-2.6.1.tar.gz/src/rebar_upgrade.erl -> rebar-2.6.4.tar.gz/src/rebar_upgrade.erl Changed

@@ -44,18 +44,24 @@
 'generate-upgrade'(Config0, ReltoolFile) ->
     %% Get the old release path
     {Config, ReltoolConfig} = rebar_rel_utils:load_config(Config0, ReltoolFile),
+    ?DEBUG("reltool.config: ~p~n", [ReltoolConfig]),
     TargetParentDir = rebar_rel_utils:get_target_parent_dir(Config,
                                                             ReltoolConfig),
     TargetDir = rebar_rel_utils:get_target_dir(Config, ReltoolConfig),
+    ?DEBUG("target dir: ~p~n", [TargetDir]),
 
     PrevRelPath = rebar_rel_utils:get_previous_release_path(Config),
     OldVerPath = filename:join([TargetParentDir, PrevRelPath]),
+    ?DEBUG("old version path: ~p~n", [OldVerPath]),
 
     %% Run checks to make sure that building a package is possible
     {NewVerPath, NewName, NewVer, OldVer} = run_checks(Config, OldVerPath,
                                                        ReltoolConfig),
+    ?DEBUG("old version: ~p~n", [OldVer]),
     NameVer = NewName ++ "_" ++ NewVer,
     OldRelName = get_old_rel_name(OldVerPath, OldVer, NewName),
+    ?DEBUG("new version path: ~p~n", [NewVerPath]),
+    ?DEBUG("old version: ~p~n", [NewVer]),
 
     %% Save the code path prior to doing anything
     OrigPath = code:get_path(),

rebar-2.6.1.tar.gz/src/rebar_utils.erl -> rebar-2.6.4.tar.gz/src/rebar_utils.erl Changed

@@ -67,7 +67,9 @@
          processing_base_dir/1,
          processing_base_dir/2,
          patch_env/2,
-         cleanup_code_path/1
+         cleanup_code_path/1,
+         init_vsn_cache/1,
+         save_vsn_cache/1
         ]).
 
 %% for internal use only
@@ -92,6 +94,7 @@
         nomatch ->
             false
     end.
+
 %%
 %% REBAR_TARGET_ARCH, if used, should be set to the "standard"
 %% target string. That is a prefix for binutils tools.
@@ -268,6 +271,23 @@
             re:replace(InStr, RegEx, [VarValue, "\\2"], ReOpts)
     end.
 
+init_vsn_cache(Config) ->
+    init_vsn_cache(Config, os:getenv("REBAR_VSN_CACHE_FILE")).
+init_vsn_cache(Config, false) ->
+    rebar_config:set_xconf(Config, vsn_cache, dict:new());
+init_vsn_cache(Config, CacheFile) ->
+    {ok, CacheList} = file:consult(CacheFile),
+    CacheDict = dict:from_list(CacheList),
+    rebar_config:set_xconf(Config, vsn_cache, CacheDict).
+
+save_vsn_cache(Config) ->
+    save_vsn_cache(Config, os:getenv("REBAR_VSN_CACHE_FILE")).
+save_vsn_cache(_Config, false) ->
+    ok;
+save_vsn_cache(Config, CacheFile) ->
+    file:write_file(CacheFile,
+        [io_lib:format("~p.~n", [X]) || X <- dict:to_list(rebar_config:get_xconf(Config, vsn_cache))]).
+
 vcs_vsn(Config, Vsn, Dir) ->
     Key = {Vsn, Dir},
     Cache = rebar_config:get_xconf(Config, vsn_cache),
@@ -276,6 +296,7 @@
             VsnString = vcs_vsn_1(Vsn, Dir),
             Cache1 = dict:store(Key, VsnString, Cache),
             Config1 = rebar_config:set_xconf(Config, vsn_cache, Cache1),
+            save_vsn_cache(Config1),
             {Config1, VsnString};
         {ok, VsnString} ->
             {Config, VsnString}
@@ -760,7 +781,7 @@
                          >>),
     Cmd = Compiler ++ " -DTYPE=\""++Type++"\" " ++ TempFile,
     ShOpts = [{use_stdout, false}, return_on_error],
-    {ok, Res} = sh(Cmd, ShOpts),
+    {error, {_,Res}} = sh(Cmd, ShOpts),
     ok = file:delete(TempFile),
     case string:tokens(Res, ":") of
         [_, Ln | _] ->

rebar-2.6.1.tar.gz/src/rebar_xref.erl -> rebar-2.6.4.tar.gz/src/rebar_xref.erl Changed

rebar-2.6.1.tar.gz/test/rebar_compiler_tests.erl -> rebar-2.6.4.tar.gz/test/rebar_compiler_tests.erl Changed

rebar-2.6.4.tar.gz/test/rebar_dia_tests.erl Added

@@ -0,0 +1,116 @@
+%% -*- erlang-indent-level: 4;indent-tabs-mode: nil -*-
+%% ex: ts=4 sw=4 et
+-module(rebar_dia_tests).
+
+-compile([export_all]).
+
+-include_lib("eunit/include/eunit.hrl").
+
+-define(REBAR_SCRIPT, "../rebar").
+
+-define(TMP_DIR, "dia_project/").
+
+dia_test_() ->
+    case supported_otp_version() of
+        true -> 
+            {"Test the dia compiler",
+             setup, fun() -> setup_project(), rebar("compile") end,
+             fun teardown/1,
+             fun(RebarOut) ->
+                 [{"Check ebin is created",
+                   ?_assert(filelib:is_dir("ebin") =:= true)},
+
+                  {"Check include is created",
+                   ?_assert(filelib:is_dir("include") =:= true)},
+                  
+                  {"Check dia/a.dia is compiled",
+                   ?_assert(string:str(RebarOut, "Compiled dia/a.dia") /= 0)},
+
+                  {"Check dia/b.dia is compiled",
+                   ?_assert(string:str(RebarOut, "Compiled dia/b.dia") /= 0)}
+                 ]
+             end};
+        false -> {setup, fun() -> ok end, []}
+    end.
+
+
+%% ====================================================================
+%% Setup and Teardown
+%% ====================================================================
+
+-define(myapp_dia_a,
+        ["@id     0\n",
+         "@name   a\n",
+         "@vendor 1 ABC\n",
+         "@avp_types\n",
+         "   IMSI 1 UTF8String V"
+        ]).
+
+-define(myapp_dia_b,
+        ["@id     2\n",
+         "@name   b\n",
+         "@vendor 2 ABC\n",
+         "@inherits a\n",
+         "@avp_types\n",
+         "   IMEIV 900 OctetString MV"
+        ]).
+
+-define(myapp_rebarconfig,
+        ["{dia_first_files, [\"dia/a.dia\"]}.\n",
+         "{dia_opts, []}.\n"
+        ]).
+
+supported_otp_version() ->
+    Min = rebar_require_vsn:version_tuple(keep_going, "15", "configured"),
+    Otp = rebar_require_vsn:version_tuple(keep_going, 
+                                          erlang:system_info(otp_release),
+                                          "OTP Release"),
+    Otp >= Min.
+
+
+setup_environment() ->
+    ok = file:make_dir(?TMP_DIR),
+    prepare_rebar_script(),
+    ok = file:set_cwd(?TMP_DIR).
+
+prepare_project() ->
+    setup_environment(),
+    rebar("create-app appid=myapp").
+
+
+setup_project() ->
+    prepare_project(),
+    ok = file:make_dir("dia"),
+    ok = file:write_file("dia/a.dia", ?myapp_dia_a),
+    ok = file:write_file("dia/b.dia", ?myapp_dia_b),
+    ok = file:write_file("rebar.config", ?myapp_rebarconfig).
+
+
+teardown(_) ->
+    ok = file:set_cwd(".."),
+    ok = remove_tmp_dir().
+
+remove_tmp_dir() ->
+    ok = rebar_file_utils:rm_rf(?TMP_DIR).
+
+%% ====================================================================
+%% Helper Functions
+%% ====================================================================
+
+prepare_rebar_script() ->
+    Rebar = ?TMP_DIR ++ "rebar",
+    {ok, _} = file:copy(?REBAR_SCRIPT, Rebar),
+    case os:type() of
+        {unix, _} ->
+            [] = os:cmd("chmod u+x " ++ Rebar);
+        {win32, _} ->
+            {ok, _} = file:copy(?REBAR_SCRIPT ++ ".cmd",
+                                ?TMP_DIR ++ "rebar.cmd")
+    end.
+
+rebar() ->
+    rebar([]).
+
+rebar(Args) when is_list(Args) ->
+    Out = os:cmd(filename:nativename("./rebar") ++ " " ++ Args),
+    Out.

rebar-2.6.1.tar.gz/test/rebar_eunit_tests.erl -> rebar-2.6.4.tar.gz/test/rebar_eunit_tests.erl Changed

@@ -56,7 +56,7 @@
                ?_assert(string:str(RebarOut, "myapp_mymod:") =/= 0)},
 
               {"Tests are only run once",
-               ?_assert(string:str(RebarOut, "All 2 tests passed") =/= 0)}]
+               ?_assert(string:str(RebarOut, "2 tests passed") =/= 0)}]
      end}.
 
 eunit_with_suites_and_tests_test_() ->
@@ -80,7 +80,7 @@
                 ?_assert(string:str(RebarOut, "myapp_mymod:") =:= 0)},
 
                {"Selected suite tests are only run once",
-                ?_assert(string:str(RebarOut, "All 4 tests passed") =/= 0)}]
+                ?_assert(string:str(RebarOut, "4 tests passed") =/= 0)}]
       end},
      {"Ensure EUnit runs selected _tests suites",
       setup, fun() ->
@@ -102,7 +102,7 @@
                 ?_assert(string:str(RebarOut, "myapp_mymod:") =:= 0)},
 
                {"Selected suite tests are only run once",
-                ?_assert(string:str(RebarOut, "All 2 tests passed") =/= 0)}]
+                ?_assert(string:str(RebarOut, "2 tests passed") =/= 0)}]
       end},
      {"Ensure EUnit runs a specific test defined in a selected suite",
       setup, fun() ->
@@ -154,7 +154,7 @@
                                "myapp_mymod2_tests:myfunc2_test/0") =/= 0)]},
 
                {"Selected suite tests are run once",
-                ?_assert(string:str(RebarOut, "All 3 tests passed") =/= 0)}]
+                ?_assert(string:str(RebarOut, "3 tests passed") =/= 0)}]
       end},
      {"Ensure EUnit runs specific test in a _tests suite",
       setup,
@@ -190,7 +190,7 @@
                           =/= 0)]},
 
                {"Selected suite tests is run once",
-                ?_assert(string:str(RebarOut, "All 2 tests passed") =/= 0)}]
+                ?_assert(string:str(RebarOut, "2 tests passed") =/= 0)}]
       end},
      {"Ensure EUnit runs a specific test by qualified function name",
       setup,
@@ -325,7 +325,11 @@
 
 assert_rebar_runs() ->
     prepare_rebar_script(),
-    ?assert(string:str(os:cmd(filename:nativename("./" ++ ?TMP_DIR ++ "rebar")),
+    {ok, Cwd} = file:get_cwd(),
+    ok = file:set_cwd(?TMP_DIR),
+    RebarOut = os:cmd(filename:nativename("./rebar")),
+    ok = file:set_cwd(Cwd),
+    ?assert(string:str(RebarOut,
                        "No command to run specified!") =/= 0).
 
 basic_setup_test_() ->

rebar-2.6.1.tar.gz/test/rebar_file_utils_tests.erl -> rebar-2.6.4.tar.gz/test/rebar_file_utils_tests.erl Changed

rebar-2.6.1.tar.gz/test/rebar_require_vsn_tests.erl -> rebar-2.6.4.tar.gz/test/rebar_require_vsn_tests.erl Changed

@@ -8,17 +8,32 @@
 
 version_tuple_test_() ->
     [%% typical cases
-     ?_assert(check("R15B", "eunit") =:= {15, 0}),
-     ?_assert(check("R15B01", "eunit") =:= {15, 1}),
-     ?_assert(check("R15B02", "eunit") =:= {15, 2}),
-     ?_assert(check("R15B03-1", "eunit") =:= {15, 3}),
-     ?_assert(check("R15B03", "eunit") =:= {15, 3}),
-     ?_assert(check("R16B", "eunit") =:= {16, 0}),
-     ?_assert(check("R16B01", "eunit") =:= {16, 1}),
-     ?_assert(check("R16B02", "eunit") =:= {16, 2}),
-     ?_assert(check("R16B03", "eunit") =:= {16, 3}),
-     ?_assert(check("R16B03-1", "eunit") =:= {16, 3}),
-     ?_assert(check("17", "eunit") =:= {17, 0}),
+     ?_assert(check("R14A", "eunit") =:= {14, 0, 0}),
+     ?_assert(check("R14B", "eunit") =:= {14, 0, 0}),
+     ?_assert(check("R14B01", "eunit") =:= {14, 1, 0}),
+     ?_assert(check("R14B02", "eunit") =:= {14, 2, 0}),
+     ?_assert(check("R14B03", "eunit") =:= {14, 3, 0}),
+     ?_assert(check("R14B04", "eunit") =:= {14, 4, 0}),
+     ?_assert(check("R15B", "eunit") =:= {15, 0, 0}),
+     ?_assert(check("R15B01", "eunit") =:= {15, 1, 0}),
+     ?_assert(check("R15B02", "eunit") =:= {15, 2, 0}),
+     ?_assert(check("R15B03-1", "eunit") =:= {15, 3, 1}),
+     ?_assert(check("R15B03", "eunit") =:= {15, 3, 0}),
+     ?_assert(check("R16B", "eunit") =:= {16, 0, 0}),
+     ?_assert(check("R16B01", "eunit") =:= {16, 1, 0}),
+     ?_assert(check("R16B02", "eunit") =:= {16, 2, 0}),
+     ?_assert(check("R16B03", "eunit") =:= {16, 3, 0}),
+     ?_assert(check("R16B03-1", "eunit") =:= {16, 3, 1}),
+     ?_assert(check("17", "eunit") =:= {17, 0, 0}),
+     ?_assert(check("17.0", "eunit") =:= {17, 0, 0}),
+     ?_assert(check("17.1", "eunit") =:= {17, 1, 0}),
+     ?_assert(check("17.3", "eunit") =:= {17, 3, 0}),
+     ?_assert(check("17.4", "eunit") =:= {17, 4, 0}),
+     ?_assert(check("17.5", "eunit") =:= {17, 5, 0}),
+     ?_assert(check("18.0", "eunit") =:= {18, 0, 0}),
+     ?_assert(check("18.1", "eunit") =:= {18, 1, 0}),
+     ?_assert(check("18.2", "eunit") =:= {18, 2, 0}),
+     ?_assert(check("18.2.1", "eunit") =:= {18, 2, 1}),
      %% error cases
      ?_assertException(throw, rebar_abort, check("", "eunit")),
      ?_assertException(throw, rebar_abort, check("abc", "eunit"))

rebar-2.6.1.tar.gz/test/rebar_xref_eunit.erl -> rebar-2.6.4.tar.gz/test/rebar_xref_eunit.erl Changed

Overview

Request 2210 (accepted)

Request History