Changeset 94

Timestamp:

03/03/10 18:13:46 (2 years ago)

Author:

dom

Message:

Start work on include files

Location:

trunk

Files:

• doc/TODO (modified) (1 diff)
• src/compiler.erl (modified) (5 diffs)
• src/compiler_test.erl (modified) (3 diffs)
• src/tester_test.erl (modified) (2 diffs)

trunk/doc/TODO

@@ -4 +4 @@
 ------------
 
+- a removed source file does not get removed from tester!!!
+
 Check for possible bugs:
 -----------------------
-
-- does a removed source file get removed from tester?
 
 Features?
 ---------
 
-- detect -include dependencies and recompile all when .hrl changes
+- detect -include dependencies and recompile (all? includers?) when .hrl changes
+- tests that never end (e.g. infinite loop)
 - run tests in parallel
 - run a single (specific) test

trunk/src/compiler.erl

@@ -6 +6 @@
 -export ([init/2]).
 -export ([init/3]).
+-export ([reset_includes/2]).
 
 init (Notify, Dir) ->
@@ -13 +14 @@
     Args = [Dir, notify_me ()],
     Watcher = spawn_link (directory_watcher, init_recursive, Args),
-    State = {dict: new (), [], [], Options},
+    State = {dict: new (), dict: new (), [], [], [{i, Dir} | Options]},
     loop (Notify, Watcher, State).
 
@@ -20 +21 @@
         check ->
             Watcher ! check,
-            {Modules, Binaries, Removed, Options} = State,
-            case receive_files (Watcher, Modules) of
-                Modules ->
-                    loop (Notify, Watcher, State);
-                Changed ->
-                    New_state = {Changed, Binaries, Removed, Options},
-                    compile (Notify, Watcher, New_state)
-            end;
+            {Modules, Includes, Binaries, Removed, Options} = State,
+            Received = receive_files (Watcher, Modules, Includes),
+            {New_modules, New_includes} = Received,
+            New_options = reset_includes (New_includes, Options),
+            New_state = {New_modules, New_includes, Binaries, Removed, New_options},
+            Last_state =
+                if
+                    New_modules /= Modules ->
+                        compile (Notify, New_state);
+                    true ->
+                        New_state
+                end,
+            loop (Notify, Watcher, Last_state);
         {Pid, stop} ->
             Pid ! {self (), bye}
     end.
 
-receive_files (Watcher, Modules) ->
+receive_files (Watcher, Modules, Includes) ->
+%%          Includes = sets: from_list ([D || {i, D} <- Options]),
     receive
         {Watcher, {{file, ".erl"}, File, Event}} ->
-            receive_files (Watcher, dict: store (File, Event, Modules));
+            receive_files (Watcher, dict: store (File, Event, Modules), Includes);
+        {Watcher, {{file, ".hrl"}, File, Event}} ->
+            receive_files (Watcher, Modules, dict: store (File, Event, Includes));
         {Watcher, _} ->
-            receive_files (Watcher, Modules)
+            receive_files (Watcher, Modules, Includes)
     after 500 ->
-            Modules
+            {Modules, Includes}
     end.
 
-compile (Notify, Watcher, State) ->
-    {Modules, _, _, _} = State,
+compile (Notify, State) ->
+    {Modules, _, _, _, _} = State,
     Notify (totals (Modules)),
     Process = process_fun (Notify),
     Processed = dict: fold (Process, State, Modules),
-    Notified = notify_end (Notify, Processed),
-    loop (Notify, Watcher, Notified).
+    notify_end (Notify, Processed).
+
+reset_includes (Dict, Options) ->
+    dict: fold (fun reset_includes/3, Options, Dict).
+
+reset_includes (File, found, Options) ->
+    Is_include = fun ({i, _}) -> true; (_) -> false end,
+    {Includes, Other} = lists: partition (Is_include, Options),
+    Dirs = sets: from_list ([D || {i, D} <- Includes]),
+    Dir = filename: dirname (File),
+    New_dirs = sets: add_element (Dir, Dirs),
+    New_includes = [{i, D} || D <- sets: to_list (New_dirs)],
+    Other ++ New_includes;
+reset_includes (_, _, Options) ->
+    Options.
 
 process_fun (Notify) ->
     fun (File, Event, Acc) when Event == found; Event == changed ->
-            {Modules, Binaries, Removed, Options} = Acc,
+            {Modules, Includes, Binaries, Removed, Options} = Acc,
             Result = modules: compile (File, Options),
             notify_result (Result, Notify),
@@ -58 +80 @@
             Notify (totals (New_modules)),
             New_binaries = binaries (Result, Binaries),
-            {New_modules, New_binaries, Removed, Options};
+            {New_modules, Includes, New_binaries, Removed, Options};
         (File, Event, Acc) when Event == lost ->
-            {Modules, Binaries, Removed, Options} = Acc,
+            {Modules, Includes, Binaries, Removed, Options} = Acc,
             New_modules = dict: erase (File, Modules),
             New_removed = [modules: module_name (File) | Removed],
-            {New_modules, Binaries, New_removed, Options};
+            {New_modules, Includes, Binaries, New_removed, Options};
         (_, _, Acc) ->
             Acc
@@ -97 +119 @@
 
 notify_end (Notify, State) ->
-    {Modules, _, _, _} = State,
+    {Modules, _,  _, _, _} = State,
     notify_end (Notify, totals (Modules), State).
 
-notify_end (Notify, {N, N, N}, {Modules, Binaries, Removed, Options}) ->
+notify_end (Notify, {N, N, N}, {Modules, Includes, Binaries, Removed, Options}) ->
     Notify ({{binaries, Binaries}, {removed, Removed}}),
-    {Modules, [], [], Options};
+    {Modules, Includes, [], [], Options};
 notify_end (_, _, State) ->
     State.

trunk/src/compiler_test.erl

@@ -14 +14 @@
 -export ([provides_all_binaries_not_just_latest_when_all_compiled/0]).
 -export ([can_be_given_include_directories/0]).
+-export ([discovers_hrl_files_and_includes_their_path/0]).
+-export ([adds_root_to_include_path/0]).
+-export ([reset_includes_none/0]).
+-export ([reset_includes_found/0]).
 -include_lib("stdlib/include/ms_transform.hrl").
 
@@ -71 +75 @@
     ok = fixtures: use_tree (Tree, fun include_no_directory/2),
     ok = fixtures: use_tree (Tree, fun include_with_directory/2).
+
+adds_root_to_include_path () ->
+    Tree =
+        [{directory, "include",
+          [{file, "eg_include.hrl", "-define(eg_macro,ok)."}]},
+         {directory, "src",
+          [{file, "eg_code_with_include.erl",
+            ["-module (eg_code_with_include).",
+             "-test (ok).",
+             "-export ([ok/0]).",
+             "-include (\"include/eg_include.hrl\").",
+             "ok () ->",
+             "    ok = ?eg_macro."]}]}],
+    ok = fixtures: use_tree (Tree, fun adds_root_to_include_path/2).    
+
+adds_root_to_include_path (Root, _) ->
+    Compiler = spawn_link (compiler, init, [notify_me (), Root]),
+    Compiler ! check,
+    Ms = receive_all (),
+    Compiler ! stop,
+    [{1, 0, 0}, {1, 1, 1}, {{binaries, _}, _}] = Ms,
+    ok.
+
+discovers_hrl_files_and_includes_their_path () ->
+    Tree =
+        [{directory, "include",
+          [{file, "eg_include.hrl", "-define(eg_macro,ok)."}]},
+         {directory, "src",
+          [{file, "eg_code_with_include.erl",
+            ["-module (eg_code_with_include).",
+             "-test (ok).",
+             "-export ([ok/0]).",
+             "-include (\"eg_include.hrl\").",
+             "ok () ->",
+             "    ok = ?eg_macro."]}]}],
+    ok = fixtures: use_tree (Tree, fun discovers_hrl/2).    
+
+discovers_hrl (Root, _) ->
+    Compiler = spawn_link (compiler, init, [notify_me (), Root]),
+    Compiler ! check,
+    Ms = receive_all (),
+    Compiler ! stop,
+    [{1, 0, 0}, {1, 1, 1}, _] = Ms,
+    ok.
 
 provides_binaries_when_all_compiled (Root, _) ->
@@ -205 +253 @@
     after 2000 -> lists: reverse ([timeout | Ms])
     end.
+
+reset_includes_none () ->
+    [debug, bla] = compiler: reset_includes (dict: new (), [debug, bla]).
+
+reset_includes_found () ->
+    Found = [{"/dir/file.hrl", found}, {"/dir/subdir/file2.hrl", found}],
+    New = dict: from_list (Found),
+    Options = [debug, bla],
+    Expected = [debug, bla, {i, "/dir/subdir"}, {i, "/dir"}],
+    Expected = compiler: reset_includes (New, Options).

trunk/src/tester_test.erl

@@ -138 +138 @@
     [{1, 0, 0}, {1, 1, 1}] = Results,
     ok = receive {Tester, bye} -> ok after 100 -> timeout end.
-                 
+
 receive_all (Ms) ->
     receive
@@ -203 +203 @@
     ].
 
-%%% Test to be added:
-%%% tests that never end (e.g. infinite loop)
-%%% Code loading and re-running all tests when one of many is refreshed