stopping point

cli/src/gsc_cli.erl

@@ -47,6 +47,8 @@ do(["list", "tests"]) ->
     do_tlist();
 do(["test"]) ->
     do_tests();
+do(["test" | Tests]) ->
+    do_tests(Tests);
 do(["tests"]) ->
     do_tests();
 do(["run", "tests"]) ->
@@ -106,14 +108,48 @@ less_file(Less, FilePath) ->
     end.
 
 do_tests() ->
-    io:format("TestModules = ~p~n", [known_modules_with_prefix("ts")]),
+    io:format("TestModules = ~p~n", [test_mods()]),
     do_runall_tests().
 
 do_runall_tests() ->
     lists:foreach(fun run_mod_main/1, test_mods()).
 
+
+do_tests(List) ->
+    lists:foreach(fun run_test/1, List).
+
+% n
+run_test(TestName) ->
+    % we have two candidate atoms
+    C1 = list_to_atom(TestName),
+    C2 = list_to_atom("gsc_test_" ++ TestName),
+    KnownMods = test_mods(),
+    IsC1 = lists:member(C1, KnownMods),
+    IsC2 = lists:member(C2, KnownMods),
+    if
+        IsC1 -> rmm(C1);
+        IsC2 -> rmm(C2);
+        true -> error({no_such_test, TestName})
+    end.
+
+
+rmm(X) -> run_mod_main(X).
+
+% KnownTests = test_mods(),
+% TestMods = ensure_all_known([], List, KnownTests),
+% lists:foreach(fun run_mod_main/1, TestMods).
+
+
+%ensure_all_known(Acc, [], _) ->
+%    lists:sort(Acc);
+%ensure_all_known(Acc, [T | Ts], Knowns) ->
+%    case lists:member(T, Knowns) of
+%
+%    end.
+
+
 test_mods() ->
-    known_modules_with_prefix("gs_test").
+    known_modules_with_prefix("gsc_test").
 
 known_modules_with_prefix(Pfx) ->
     ModsZipBeamsZipLoaded = code:all_available(),

cli/src/gsc_test_ntree.erl

@@ -0,0 +1,109 @@
+-module(gsc_test_ntree).
+
+-export([
+    main/0
+]).
+
+-include("$gsc_include/gsc.hrl").
+
+
+main() ->
+    x00(),
+    ok.
+
+% x00 = example00
+x00() ->
+    io:format("Example 00:~n", []),
+    io:format("  SrcStr = ~p~n", [x00_src()]),
+    io:format("  Tokens = ~p~n", [x00_tks()]),
+    io:format("  Signal = ~p~n", [x00_sgl()]),
+    io:format("  Tree0  = ~p~n", [x00_tree0()]),
+    ok.
+
+% sample type expr, tokens, signal
+x00_src()   -> "foo => bar * baz".
+x00_tks()   -> gsc:unsafe_tokens_from_string(x00_src()).
+x00_sgl()   -> gsc:filter_signal(x00_tks()).
+x00_tree0() -> mktree(x00_sgl()).
+
+% records copypasta for now
+-record(ns, {val :: any(), kids :: list(any())}).
+-record(nl, {val :: any()}).
+
+-type ntree(X, Y) :: gsc_ntree:ntree(X, Y).
+-type ntree()     :: gsc_ntree:ntree().
+
+-type ast_stem_t() :: vtokens
+                    | {op, tk()}
+                    .
+
+-type ast() :: ntree(ast_stem_t(), tk()).
+
+
+-spec mktree(Signal) -> Tree when
+        Signal  :: gsc:signal(),
+        Tree    :: gsc_ntree:ntree().
+
+% @doc make into a tree
+mktree(Sig) ->
+    Tree0 = gsc_ntree:nstem(vtokens, Sig),
+    Tree1 = rerootl_tkstr("=>", Tree0),
+    Tree2 = rerootl_tkstr("*", Tree1),
+    Tree2.
+
+
+rerootl_tkstr(S, Tree0 = #ns{val = Root0}) ->
+    Kids0 = gsc_ntree:deleaf0(Tree0),
+    IsntS = fun(Tk) -> isnt_str(S, Tk) end,
+    case lists:splitwith(IsntS, Kids0) of
+        % found
+        % input:
+        %   *s Root0
+        %   |
+        %   +-- .l Foo
+        %   +-- .l "=>"
+        %   +-- .l Bar
+        % output:
+        %   *s "=>"
+        %   |
+        %   +-- *s Root0 -- .l Foo
+        %   +-- *s Root0 -- .l Bar
+        {LHS1, [Tk0 | RHS1]} ->
+            Root1    = Root0,
+            LTree1   = gsc_ntree:releaf0(Root1, LHS1),
+            RTree1   = rerootl_tkstr(S, gsc_ntree:releaf0(Root1, RHS1)),
+            NewRoot0 = {op, Tk0},
+            NewKids0 = [LTree1, RTree1],
+            NewTree  = gsc_ntree:releaf0(NewRoot0, NewKids0),
+            NewTree;
+        % not found, nothing to do
+        {Kids0, []} ->
+            Tree0
+    end.
+
+
+%reroot_mapsto(Tree0 = #ns{val = Root0}) ->
+%    Kids0 = gsc_ntree:deleaf0(Tree0),
+%    IsntMapsto = fun(DL) -> isnt_str("=>", Tk) end,
+%    case lists:splitwith(IsntMapsto, Kids0) of
+%        % found
+%        {LHS1, [Tk0 | RHS1]} ->
+%            Root1    = Root0,
+%            LTree1   = gsc_ntree:releaf0(Root1, LHS1),
+%            RTree1   = reroot_mapsto(gsc_ntree:releaf0(Root1, RHS1)),
+%            NewRoot0 = {op, Tk0},
+%            NewKids0 = [LTree1, RTree1],
+%            NewTree  = gsc_ntree:releaf0(NewRoot0, NewKids0),
+%            NewTree;
+%        % nothing to do
+%        {Kids0, []} ->
+%            Tree0
+%    end.
+
+
+
+isnt_str(X, Y) ->
+    not is_str(X, Y).
+
+is_str(S, #tk{str = S}) -> true;
+is_str(_, _)            -> false.

cli/src/gsc_test_tokens.erl

@@ -1,5 +1,5 @@
 % gsc tokenizer tests
--module(gs_test_tokens).
+-module(gsc_test_tokens).
 
 -export([
     main/0, ct_dir/0

cli/src/ts_utils.erl

@@ -0,0 +1,25 @@
+% testing utilities
+-module(ts_utils).
+
+-export([
+    ct_dir/0,
+    ct_file/1
+]).
+
+
+-spec ct_dir() -> string().
+
+% directory containing the tests for the tokenizer
+ct_dir() ->
+    zx_daemon:get_home() ++ "/ct".
+
+
+
+-spec ct_file(Name) -> AbsPath when
+        Name :: string(),
+        AbsPath :: string().
+% @doc
+% ct_file("foo.aes") -> "/path/to/ct/foo.aes"
+
+ct_file(Name) ->
+    ct_dir() ++ "/" ++ Name.