From 9f64d69a4d7d8592abb001e52da513df0b0646d0 Mon Sep 17 00:00:00 2001 From: Maxim Treskin Date: Thu, 25 Apr 2013 14:14:03 +0700 Subject: [PATCH] Rename modules, add gr_ prefix --- src/{gre.erl => gr_e.erl} | 20 ++-- src/{glc.erl => gr_lc.erl} | 132 +++++++++++++-------------- src/{glc_code.erl => gr_lc_code.erl} | 18 ++-- src/{glc_lib.erl => gr_lc_lib.erl} | 106 ++++++++++----------- src/{glc_ops.erl => gr_lc_ops.erl} | 8 +- 5 files changed, 142 insertions(+), 142 deletions(-) rename src/{gre.erl => gr_e.erl} (81%) rename src/{glc.erl => gr_lc.erl} (75%) rename src/{glc_code.erl => gr_lc_code.erl} (95%) rename src/{glc_lib.erl => gr_lc_lib.erl} (76%) rename src/{glc_ops.erl => gr_lc_ops.erl} (93%) diff --git a/src/gre.erl b/src/gr_e.erl similarity index 81% rename from src/gre.erl rename to src/gr_e.erl index eca4e2c..0564229 100644 --- a/src/gre.erl +++ b/src/gr_e.erl @@ -13,7 +13,7 @@ %% OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. %% @doc Accessor function for goldrush event terms. --module(gre). +-module(gr_e). -export([ make/2, @@ -81,15 +81,15 @@ pairs({list, List}) -> -ifdef(TEST). -include_lib("eunit/include/eunit.hrl"). -gre_test_() -> - [?_assert(gre:has(a, gre:make([{a,1}], [list]))), - ?_assertNot(gre:has(b, gre:make([{a,1}], [list]))), - ?_assertEqual(1, gre:fetch(a, gre:make([{a,1}], [list]))), - ?_assertError(badarg, gre:fetch(a, gre:make([], [list]))), - ?_assertEqual([], gre:keys(gre:make([], [list]))), - ?_assertEqual([a], gre:keys(gre:make([{a,1}], [list]))), - ?_assertEqual([a,b], gre:keys(gre:make([{a,1},{b,2}], [list]))), - ?_assertEqual([{a,1},{b,2}], gre:pairs(gre:make([{b,2},{a,1}], [list]))) +gr_e_test_() -> + [?_assert(gr_e:has(a, gr_e:make([{a,1}], [list]))), + ?_assertNot(gr_e:has(b, gr_e:make([{a,1}], [list]))), + ?_assertEqual(1, gr_e:fetch(a, gr_e:make([{a,1}], [list]))), + ?_assertError(badarg, gr_e:fetch(a, gr_e:make([], [list]))), + ?_assertEqual([], gr_e:keys(gr_e:make([], [list]))), + ?_assertEqual([a], gr_e:keys(gr_e:make([{a,1}], [list]))), + ?_assertEqual([a,b], gr_e:keys(gr_e:make([{a,1},{b,2}], [list]))), + ?_assertEqual([{a,1},{b,2}], gr_e:pairs(gr_e:make([{b,2},{a,1}], [list]))) ]. -endif. diff --git a/src/glc.erl b/src/gr_lc.erl similarity index 75% rename from src/glc.erl rename to src/gr_lc.erl index ecca4b7..4c8c196 100644 --- a/src/glc.erl +++ b/src/gr_lc.erl @@ -24,27 +24,27 @@ %% %% === Examples of built in filters === %% ``` -%% %% Select all events where 'a' exists and is greater than 0. -%% glc:gt(a, 0). +%% %% Select all events where 'a' exists and is gr_eater than 0. +%% gr_lc:gt(a, 0). %% %% Select all events where 'a' exists and is equal to 0. -%% glc:eq(a, 0). +%% gr_lc:eq(a, 0). %% %% Select all events where 'a' exists and is less than 0. -%% glc:lt(a, 0). +%% gr_lc:lt(a, 0). %% %% Select all events where 'a' exists and is anything. -%% glc:wc(a). +%% gr_lc:wc(a). %% %% %% Select no input events. Used as black hole query. -%% glc:null(false). +%% gr_lc:null(false). %% %% Select all input events. Used as passthrough query. -%% glc:null(true). +%% gr_lc:null(true). %% ''' %% %% === Examples of combining filters === %% ``` -%% %% Select all events where both 'a' and 'b' exists and are greater than 0. -%% glc:all([glc:gt(a, 0), glc:gt(b, 0)]). -%% %% Select all events where 'a' or 'b' exists and are greater than 0. -%% glc:any([glc:get(a, 0), glc:gt(b, 0)]). +%% %% Select all events where both 'a' and 'b' exists and are gr_eater than 0. +%% gr_lc:all([gr_lc:gt(a, 0), gr_lc:gt(b, 0)]). +%% %% Select all events where 'a' or 'b' exists and are gr_eater than 0. +%% gr_lc:any([gr_lc:get(a, 0), gr_lc:gt(b, 0)]). %% ''' %% %% === Handling output events === @@ -55,11 +55,11 @@ %% %% ``` %% %% Write all input events as info reports to the error logger. -%% glc:with(glc:null(true), fun(E) -> -%% error_logger:info_report(gre:pairs(E)) end). +%% gr_lc:with(gr_lc:null(true), fun(E) -> +%% error_logger:info_report(gr_e:pairs(E)) end). %% ''' %% --module(glc). +-module(gr_lc). -export([ compile/2, @@ -91,21 +91,21 @@ qtree :: term() }). --spec lt(atom(), term()) -> glc_ops:op(). +-spec lt(atom(), term()) -> gr_lc_ops:op(). lt(Key, Term) -> - glc_ops:lt(Key, Term). + gr_lc_ops:lt(Key, Term). --spec eq(atom(), term()) -> glc_ops:op(). +-spec eq(atom(), term()) -> gr_lc_ops:op(). eq(Key, Term) -> - glc_ops:eq(Key, Term). + gr_lc_ops:eq(Key, Term). --spec gt(atom(), term()) -> glc_ops:op(). +-spec gt(atom(), term()) -> gr_lc_ops:op(). gt(Key, Term) -> - glc_ops:gt(Key, Term). + gr_lc_ops:gt(Key, Term). --spec wc(atom()) -> glc_ops:op(). +-spec wc(atom()) -> gr_lc_ops:op(). wc(Key) -> - glc_ops:wc(Key). + gr_lc_ops:wc(Key). %% @doc Filter the input using multiple filters. %% @@ -113,9 +113,9 @@ wc(Key) -> %% in the list must hold for the input event. The list is expected to %% be a non-empty list. If the list of filters is an empty list a `badarg' %% error will be thrown. --spec all([glc_ops:op()]) -> glc_ops:op(). +-spec all([gr_lc_ops:op()]) -> gr_lc_ops:op(). all(Filters) -> - glc_ops:all(Filters). + gr_lc_ops:all(Filters). %% @doc Filter the input using one of multiple filters. @@ -124,15 +124,15 @@ all(Filters) -> %% in the list must hold for the input event. The list is expected to be %% a non-empty list. If the list of filters is an empty list a `badarg' %% error will be thrown. --spec any([glc_ops:op()]) -> glc_ops:op(). +-spec any([gr_lc_ops:op()]) -> gr_lc_ops:op(). any(Filters) -> - glc_ops:any(Filters). + gr_lc_ops:any(Filters). %% @doc Always return `true' or `false'. --spec null(boolean()) -> glc_ops:op(). +-spec null(boolean()) -> gr_lc_ops:op(). null(Result) -> - glc_ops:null(Result). + gr_lc_ops:null(Result). %% @doc Apply a function to each output of a query. @@ -140,9 +140,9 @@ null(Result) -> %% Updating the output action of a query finalizes it. Attempting %% to use a finalized query to construct a new query will result %% in a `badarg' error. --spec with(glc_ops:op(), fun((gre:event()) -> term())) -> glc_ops:op(). +-spec with(gr_lc_ops:op(), fun((gr_e:event()) -> term())) -> gr_lc_ops:op(). with(Query, Action) -> - glc_ops:with(Query, Action). + gr_lc_ops:with(Query, Action). %% @doc Return a union of multiple queries. @@ -155,9 +155,9 @@ with(Query, Action) -> %% All queries are expected to be valid and have an output action other %% than the default which is `output'. If these expectations don't hold %% a `badarg' error will be thrown. --spec union([glc_ops:op()]) -> glc_ops:op(). +-spec union([gr_lc_ops:op()]) -> gr_lc_ops:op(). union(Queries) -> - glc_ops:union(Queries). + gr_lc_ops:union(Queries). %% @doc Compile a query to a module. @@ -168,15 +168,15 @@ union(Queries) -> -spec compile(atom(), list()) -> {ok, atom()}. compile(Module, Query) -> {ok, ModuleData} = module_data(Query), - case glc_code:compile(Module, ModuleData) of + case gr_lc_code:compile(Module, ModuleData) of {ok, Module} -> {ok, Module} end. %% @doc Handle an event using a compiled query. %% -%% The input event is expected to have been returned from {@link gre:make/2}. --spec handle(atom(), gre:event()) -> ok. +%% The input event is expected to have been returned from {@link gr_e:make/2}. +-spec handle(atom(), gr_e:event()) -> ok. handle(Module, Event) -> Module:handle(Event). @@ -206,7 +206,7 @@ module_data(Query) -> %% tables are referred to by name in the generated code. the table/1 %% function maps names to tids. Tables = [{params,Params}, {counters,Counters}], - Query2 = glc_lib:reduce(Query), + Query2 = gr_lc_lib:reduce(Query), {ok, #module{'query'=Query, tables=Tables, qtree=Query2}}. @@ -247,30 +247,30 @@ setup_query(Module, Query) -> {compiled, Module}. nullquery_compiles_test() -> - {compiled, Mod} = setup_query(testmod1, glc:null(false)), + {compiled, Mod} = setup_query(testmod1, gr_lc:null(false)), ?assertError(badarg, Mod:table(noexists)). params_table_exists_test() -> - {compiled, Mod} = setup_query(testmod2, glc:null(false)), + {compiled, Mod} = setup_query(testmod2, gr_lc:null(false)), ?assert(is_integer(Mod:table(params))), ?assertMatch([_|_], ets:info(Mod:table(params))). nullquery_exists_test() -> - {compiled, Mod} = setup_query(testmod3, glc:null(false)), + {compiled, Mod} = setup_query(testmod3, gr_lc:null(false)), ?assert(erlang:function_exported(Mod, info, 1)), ?assertError(badarg, Mod:info(invalid)), ?assertEqual({null, false}, Mod:info('query')). init_counters_test() -> - {compiled, Mod} = setup_query(testmod4, glc:null(false)), + {compiled, Mod} = setup_query(testmod4, gr_lc:null(false)), ?assertEqual(0, Mod:info(input)), ?assertEqual(0, Mod:info(filter)), ?assertEqual(0, Mod:info(output)). filtered_event_test() -> %% If no selection condition is specified no inputs can match. - {compiled, Mod} = setup_query(testmod5, glc:null(false)), - glc:handle(Mod, gre:make([], [list])), + {compiled, Mod} = setup_query(testmod5, gr_lc:null(false)), + gr_lc:handle(Mod, gr_e:make([], [list])), ?assertEqual(1, Mod:info(input)), ?assertEqual(1, Mod:info(filter)), ?assertEqual(0, Mod:info(output)). @@ -279,8 +279,8 @@ nomatch_event_test() -> %% If a selection condition but no body is specified the event %% is expected to count as filtered out if the condition does %% not hold. - {compiled, Mod} = setup_query(testmod6, glc:eq('$n', 'noexists@nohost')), - glc:handle(Mod, gre:make([{'$n', 'noexists2@nohost'}], [list])), + {compiled, Mod} = setup_query(testmod6, gr_lc:eq('$n', 'noexists@nohost')), + gr_lc:handle(Mod, gr_e:make([{'$n', 'noexists2@nohost'}], [list])), ?assertEqual(1, Mod:info(input)), ?assertEqual(1, Mod:info(filter)), ?assertEqual(0, Mod:info(output)). @@ -288,8 +288,8 @@ nomatch_event_test() -> opfilter_eq_test() -> %% If a selection condition but no body is specified the event %% counts as input to the query, but not as filtered out. - {compiled, Mod} = setup_query(testmod7, glc:eq('$n', 'noexists@nohost')), - glc:handle(Mod, gre:make([{'$n', 'noexists@nohost'}], [list])), + {compiled, Mod} = setup_query(testmod7, gr_lc:eq('$n', 'noexists@nohost')), + gr_lc:handle(Mod, gr_e:make([{'$n', 'noexists@nohost'}], [list])), ?assertEqual(1, Mod:info(input)), ?assertEqual(0, Mod:info(filter)), ?assertEqual(1, Mod:info(output)), @@ -297,23 +297,23 @@ opfilter_eq_test() -> opfilter_gt_test() -> - {compiled, Mod} = setup_query(testmod8, glc:gt(a, 1)), - glc:handle(Mod, gre:make([{'a', 2}], [list])), + {compiled, Mod} = setup_query(testmod8, gr_lc:gt(a, 1)), + gr_lc:handle(Mod, gr_e:make([{'a', 2}], [list])), ?assertEqual(1, Mod:info(input)), ?assertEqual(0, Mod:info(filter)), - glc:handle(Mod, gre:make([{'a', 0}], [list])), + gr_lc:handle(Mod, gr_e:make([{'a', 0}], [list])), ?assertEqual(2, Mod:info(input)), ?assertEqual(1, Mod:info(filter)), ?assertEqual(1, Mod:info(output)), done. opfilter_lt_test() -> - {compiled, Mod} = setup_query(testmod9, glc:lt(a, 1)), - glc:handle(Mod, gre:make([{'a', 0}], [list])), + {compiled, Mod} = setup_query(testmod9, gr_lc:lt(a, 1)), + gr_lc:handle(Mod, gr_e:make([{'a', 0}], [list])), ?assertEqual(1, Mod:info(input)), ?assertEqual(0, Mod:info(filter)), ?assertEqual(1, Mod:info(output)), - glc:handle(Mod, gre:make([{'a', 2}], [list])), + gr_lc:handle(Mod, gr_e:make([{'a', 2}], [list])), ?assertEqual(2, Mod:info(input)), ?assertEqual(1, Mod:info(filter)), ?assertEqual(1, Mod:info(output)), @@ -321,16 +321,16 @@ opfilter_lt_test() -> allholds_op_test() -> {compiled, Mod} = setup_query(testmod10, - glc:all([glc:eq(a, 1), glc:eq(b, 2)])), - glc:handle(Mod, gre:make([{'a', 1}], [list])), - glc:handle(Mod, gre:make([{'a', 2}], [list])), + gr_lc:all([gr_lc:eq(a, 1), gr_lc:eq(b, 2)])), + gr_lc:handle(Mod, gr_e:make([{'a', 1}], [list])), + gr_lc:handle(Mod, gr_e:make([{'a', 2}], [list])), ?assertEqual(2, Mod:info(input)), ?assertEqual(2, Mod:info(filter)), - glc:handle(Mod, gre:make([{'b', 1}], [list])), - glc:handle(Mod, gre:make([{'b', 2}], [list])), + gr_lc:handle(Mod, gr_e:make([{'b', 1}], [list])), + gr_lc:handle(Mod, gr_e:make([{'b', 2}], [list])), ?assertEqual(4, Mod:info(input)), ?assertEqual(4, Mod:info(filter)), - glc:handle(Mod, gre:make([{'a', 1},{'b', 2}], [list])), + gr_lc:handle(Mod, gr_e:make([{'a', 1},{'b', 2}], [list])), ?assertEqual(5, Mod:info(input)), ?assertEqual(4, Mod:info(filter)), ?assertEqual(1, Mod:info(output)), @@ -338,13 +338,13 @@ allholds_op_test() -> anyholds_op_test() -> {compiled, Mod} = setup_query(testmod11, - glc:any([glc:eq(a, 1), glc:eq(b, 2)])), - glc:handle(Mod, gre:make([{'a', 2}], [list])), - glc:handle(Mod, gre:make([{'b', 1}], [list])), + gr_lc:any([gr_lc:eq(a, 1), gr_lc:eq(b, 2)])), + gr_lc:handle(Mod, gr_e:make([{'a', 2}], [list])), + gr_lc:handle(Mod, gr_e:make([{'b', 1}], [list])), ?assertEqual(2, Mod:info(input)), ?assertEqual(2, Mod:info(filter)), - glc:handle(Mod, gre:make([{'a', 1}], [list])), - glc:handle(Mod, gre:make([{'b', 2}], [list])), + gr_lc:handle(Mod, gr_e:make([{'a', 1}], [list])), + gr_lc:handle(Mod, gr_e:make([{'b', 2}], [list])), ?assertEqual(4, Mod:info(input)), ?assertEqual(2, Mod:info(filter)), done. @@ -352,14 +352,14 @@ anyholds_op_test() -> with_function_test() -> Self = self(), {compiled, Mod} = setup_query(testmod12, - glc:with(glc:eq(a, 1), fun(Event) -> Self ! gre:fetch(a, Event) end)), - glc:handle(Mod, gre:make([{a,1}], [list])), + gr_lc:with(gr_lc:eq(a, 1), fun(Event) -> Self ! gr_e:fetch(a, Event) end)), + gr_lc:handle(Mod, gr_e:make([{a,1}], [list])), ?assertEqual(1, Mod:info(output)), ?assertEqual(1, receive Msg -> Msg after 0 -> notcalled end), done. union_error_test() -> - ?assertError(badarg, glc:union([glc:eq(a, 1)])), + ?assertError(badarg, gr_lc:union([gr_lc:eq(a, 1)])), done. -endif. diff --git a/src/glc_code.erl b/src/gr_lc_code.erl similarity index 95% rename from src/glc_code.erl rename to src/gr_lc_code.erl index 810ca3c..39edd7d 100644 --- a/src/glc_code.erl +++ b/src/gr_lc_code.erl @@ -1,5 +1,5 @@ %% @doc Code generation functions. --module(glc_code). +-module(gr_lc_code). -export([ compile/2 @@ -128,7 +128,7 @@ abstract_query(Query) -> %% @private Return a list of expressions to apply a filter. %% @todo Allow mulitple functions to be specified using `with/2'. --spec abstract_filter(glc_ops:op(), #state{}) -> [syntaxTree()]. +-spec abstract_filter(gr_lc_ops:op(), #state{}) -> [syntaxTree()]. abstract_filter({with, Cond, Fun}, State) -> abstract_filter_(Cond, _OnMatch=fun(State2) -> @@ -144,7 +144,7 @@ abstract_filter(Cond, State) -> %% to apply when the filter matches or fails to match. The state passed to the %% functions will be contain all variable bindings to previously accessed %% fields and parameters. --spec abstract_filter_(glc_ops:op(), nextFun(), nextFun(), #state{}) -> +-spec abstract_filter_(gr_lc_ops:op(), nextFun(), nextFun(), #state{}) -> syntaxTree(). abstract_filter_({null, true}, OnMatch, _OnNomatch, State) -> OnMatch(State); @@ -185,7 +185,7 @@ abstract_opfilter(Key, Opname, Value, OnMatch, OnNomatch, State) -> %% any of the conditions does not hold the evaluation is short circuted at that %% point. This means that the `OnNomatch' branch is executed once for each %% condition. The `OnMatch' branch is only executed once. --spec abstract_all([glc_ops:op()], nextFun(), nextFun(), #state{}) -> +-spec abstract_all([gr_lc_ops:op()], nextFun(), nextFun(), #state{}) -> [syntaxTree()]. abstract_all([H|T], OnMatch, OnNomatch, State) -> abstract_filter_(H, @@ -195,7 +195,7 @@ abstract_all([], OnMatch, _OnNomatch, State) -> OnMatch(State). %% @private --spec abstract_any([glc_ops:op()], nextFun(), nextFun(), #state{}) -> +-spec abstract_any([gr_lc_ops:op()], nextFun(), nextFun(), #state{}) -> [syntaxTree()]. abstract_any([H|T], OnMatch, OnNomatch, State) -> abstract_filter_(H, OnMatch, @@ -205,7 +205,7 @@ abstract_any([], _OnMatch, OnNomatch, State) -> OnNomatch(State). %% @private --spec abstract_with(fun((gre:event()) -> term()), #state{}) -> [syntaxTree()]. +-spec abstract_with(fun((gr_e:event()) -> term()), #state{}) -> [syntaxTree()]. abstract_with(Fun, State) when is_function(Fun, 1) -> abstract_getparam(Fun, fun(#state{event=Event, paramvars=Params}) -> {_, Fun2} = lists:keyfind(Fun, 1, Params), @@ -231,7 +231,7 @@ abstract_getkey(Key, OnMatch, OnNomatch, #state{fields=Fields}=State) -> abstract_getkey_(Key, OnMatch, OnNomatch, #state{ event=Event, fields=Fields}=State) -> [?erl:case_expr( - abstract_apply(gre, find, [?erl:atom(Key), Event]), + abstract_apply(gr_e, find, [?erl:atom(Key), Event]), [?erl:clause([ ?erl:tuple([ ?erl:atom(true), @@ -302,11 +302,11 @@ param_variable(Key) -> %% @private Generate a list of field variable names. %% Walk the query tree and generate a safe variable name string for each field %% that is accessed by the conditions in the query. Only allow alpha-numeric. -%%-spec field_variables(glc_ops:op()) -> [{atom(), string()}]. +%%-spec field_variables(gr_lc_ops:op()) -> [{atom(), string()}]. %%field_variables(Query) -> %% lists:usort(field_variables_(Query)). -%%-spec field_variables(glc_ops:op()) -> [{atom(), string()}]. +%%-spec field_variables(gr_lc_ops:op()) -> [{atom(), string()}]. %%field_variables_({Key, '=', _Term}) -> %% [{Key, field_variable(Key)}]. diff --git a/src/glc_lib.erl b/src/gr_lc_lib.erl similarity index 76% rename from src/glc_lib.erl rename to src/gr_lc_lib.erl index 427551f..376dc1d 100644 --- a/src/glc_lib.erl +++ b/src/gr_lc_lib.erl @@ -13,7 +13,7 @@ %% OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. %% @doc Query processing functions. --module(glc_lib). +-module(gr_lc_lib). -export([ reduce/1, @@ -56,22 +56,22 @@ matches({all, Conds}, Event) -> matches({null, Const}, _Event) -> Const; matches({Key, '<', Term}, Event) -> - case gre:find(Key, Event) of + case gr_e:find(Key, Event) of {true, Term2} -> Term2 < Term; false -> false end; matches({Key, '=', Term}, Event) -> - case gre:find(Key, Event) of + case gr_e:find(Key, Event) of {true, Term2} -> Term2 =:= Term; false -> false end; matches({Key, '>', Term}, Event) -> - case gre:find(Key, Event) of + case gr_e:find(Key, Event) of {true, Term2} -> Term2 > Term; false -> false end; matches({Key, '*'}, Event) -> - case gre:find(Key, Event) of + case gr_e:find(Key, Event) of {true, _} -> true; false -> false end. @@ -265,111 +265,111 @@ valid(Term) -> -include_lib("eunit/include/eunit.hrl"). all_one_test() -> - ?assertEqual(glc:eq(a, 1), - glc_lib:reduce(glc:all([glc:eq(a, 1)])) + ?assertEqual(gr_lc:eq(a, 1), + gr_lc_lib:reduce(gr_lc:all([gr_lc:eq(a, 1)])) ). all_sort_test() -> - ?assertEqual(glc:all([glc:eq(a, 1), glc:eq(b, 2)]), - glc_lib:reduce(glc:all([glc:eq(b, 2), glc:eq(a, 1)])) + ?assertEqual(gr_lc:all([gr_lc:eq(a, 1), gr_lc:eq(b, 2)]), + gr_lc_lib:reduce(gr_lc:all([gr_lc:eq(b, 2), gr_lc:eq(a, 1)])) ). any_one_test() -> - ?assertEqual(glc:eq(a, 1), - glc_lib:reduce(glc:any([glc:eq(a, 1)])) + ?assertEqual(gr_lc:eq(a, 1), + gr_lc_lib:reduce(gr_lc:any([gr_lc:eq(a, 1)])) ). any_sort_test() -> - ?assertEqual(glc:any([glc:eq(a, 1), glc:eq(b, 2)]), - glc_lib:reduce(glc:any([glc:eq(b, 2), glc:eq(a, 1)])) + ?assertEqual(gr_lc:any([gr_lc:eq(a, 1), gr_lc:eq(b, 2)]), + gr_lc_lib:reduce(gr_lc:any([gr_lc:eq(b, 2), gr_lc:eq(a, 1)])) ). all_nest_test() -> - ?assertEqual(glc:all([glc:eq(a, 1), glc:eq(b, 2)]), - glc_lib:reduce(glc:all([glc:eq(a, 1), glc:all([glc:eq(b, 2)])])) + ?assertEqual(gr_lc:all([gr_lc:eq(a, 1), gr_lc:eq(b, 2)]), + gr_lc_lib:reduce(gr_lc:all([gr_lc:eq(a, 1), gr_lc:all([gr_lc:eq(b, 2)])])) ), - ?assertEqual(glc:all([glc:eq(a, 1), glc:eq(b, 2), glc:eq(c, 3)]), - glc_lib:reduce(glc:all([glc:eq(c, 3), - glc:all([glc:eq(a, 1), - glc:all([glc:eq(b, 2)])])])) + ?assertEqual(gr_lc:all([gr_lc:eq(a, 1), gr_lc:eq(b, 2), gr_lc:eq(c, 3)]), + gr_lc_lib:reduce(gr_lc:all([gr_lc:eq(c, 3), + gr_lc:all([gr_lc:eq(a, 1), + gr_lc:all([gr_lc:eq(b, 2)])])])) ). any_nest_test() -> - ?assertEqual(glc:any([glc:eq(a, 1), glc:eq(b, 2)]), - glc_lib:reduce(glc:any([glc:eq(a, 1), glc:any([glc:eq(b, 2)])])) + ?assertEqual(gr_lc:any([gr_lc:eq(a, 1), gr_lc:eq(b, 2)]), + gr_lc_lib:reduce(gr_lc:any([gr_lc:eq(a, 1), gr_lc:any([gr_lc:eq(b, 2)])])) ), - ?assertEqual(glc:any([glc:eq(a, 1), glc:eq(b, 2), glc:eq(c, 3)]), - glc_lib:reduce(glc:any([glc:eq(c, 3), - glc:any([glc:eq(a, 1), - glc:any([glc:eq(b, 2)])])])) + ?assertEqual(gr_lc:any([gr_lc:eq(a, 1), gr_lc:eq(b, 2), gr_lc:eq(c, 3)]), + gr_lc_lib:reduce(gr_lc:any([gr_lc:eq(c, 3), + gr_lc:any([gr_lc:eq(a, 1), + gr_lc:any([gr_lc:eq(b, 2)])])])) ). all_equiv_test() -> - ?assertEqual(glc:eq(a, 1), - glc_lib:reduce(glc:all([glc:eq(a, 1), glc:eq(a, 1)])) + ?assertEqual(gr_lc:eq(a, 1), + gr_lc_lib:reduce(gr_lc:all([gr_lc:eq(a, 1), gr_lc:eq(a, 1)])) ). any_equiv_test() -> - ?assertEqual(glc:eq(a, 1), - glc_lib:reduce(glc:any([glc:eq(a, 1), glc:eq(a, 1)])) + ?assertEqual(gr_lc:eq(a, 1), + gr_lc_lib:reduce(gr_lc:any([gr_lc:eq(a, 1), gr_lc:eq(a, 1)])) ). any_required_test() -> ?assertEqual( - glc:all([ - glc:any([glc:eq(b, 2), glc:eq(c, 3)]), - glc:eq(a, 1) + gr_lc:all([ + gr_lc:any([gr_lc:eq(b, 2), gr_lc:eq(c, 3)]), + gr_lc:eq(a, 1) ]), - glc_lib:reduce( - glc:any([ - glc:all([glc:eq(a, 1), glc:eq(b, 2)]), - glc:all([glc:eq(a, 1), glc:eq(c, 3)])])) + gr_lc_lib:reduce( + gr_lc:any([ + gr_lc:all([gr_lc:eq(a, 1), gr_lc:eq(b, 2)]), + gr_lc:all([gr_lc:eq(a, 1), gr_lc:eq(c, 3)])])) ). all_common_test() -> ?assertEqual( - glc:all([glc:eq(a, 1), glc:eq(b, 2), glc:eq(c, 3)]), - glc_lib:reduce( - glc:all([ - glc:any([glc:eq(a, 1), glc:eq(b, 2)]), - glc:any([glc:eq(a, 1), glc:eq(c, 3)])])) + gr_lc:all([gr_lc:eq(a, 1), gr_lc:eq(b, 2), gr_lc:eq(c, 3)]), + gr_lc_lib:reduce( + gr_lc:all([ + gr_lc:any([gr_lc:eq(a, 1), gr_lc:eq(b, 2)]), + gr_lc:any([gr_lc:eq(a, 1), gr_lc:eq(c, 3)])])) ). delete_from_all_test() -> ?assertEqual( - glc:all([glc:eq(b,2)]), + gr_lc:all([gr_lc:eq(b,2)]), deleteall( - glc:all([glc:eq(a, 1),glc:eq(b,2)]), [glc:eq(a, 1)]) + gr_lc:all([gr_lc:eq(a, 1),gr_lc:eq(b,2)]), [gr_lc:eq(a, 1)]) ). delete_from_any_test() -> ?assertEqual( - glc:any([glc:eq(b,2)]), + gr_lc:any([gr_lc:eq(b,2)]), deleteall( - glc:any([glc:eq(a, 1),glc:eq(b,2)]), [glc:eq(a, 1)]) + gr_lc:any([gr_lc:eq(a, 1),gr_lc:eq(b,2)]), [gr_lc:eq(a, 1)]) ). default_is_output_test_() -> - [?_assertEqual(output, glc_lib:onoutput(glc:lt(a, 1))), - ?_assertEqual(output, glc_lib:onoutput(glc:eq(a, 1))), - ?_assertEqual(output, glc_lib:onoutput(glc:gt(a, 1))), - ?_assertEqual(output, glc_lib:onoutput(glc:wc(a))) + [?_assertEqual(output, gr_lc_lib:onoutput(gr_lc:lt(a, 1))), + ?_assertEqual(output, gr_lc_lib:onoutput(gr_lc:eq(a, 1))), + ?_assertEqual(output, gr_lc_lib:onoutput(gr_lc:gt(a, 1))), + ?_assertEqual(output, gr_lc_lib:onoutput(gr_lc:wc(a))) ]. -ifdef(PROPER). prop_reduce_returns() -> - ?FORALL(Query, glc_ops:op(), - returns(fun() -> glc_lib:reduce(Query) end)). + ?FORALL(Query, gr_lc_ops:op(), + returns(fun() -> gr_lc_lib:reduce(Query) end)). reduce_returns_test() -> ?assert(proper:quickcheck(prop_reduce_returns())). prop_matches_returns_boolean() -> - ?FORALL({Query, Event}, {glc_ops:op(), [{atom(), term()}]}, - is_boolean(glc_lib:matches(Query, gre:make(Event, [list])))). + ?FORALL({Query, Event}, {gr_lc_ops:op(), [{atom(), term()}]}, + is_boolean(gr_lc_lib:matches(Query, gr_e:make(Event, [list])))). matches_returns_boolean_test() -> ?assert(proper:quickcheck(prop_matches_returns_boolean())). diff --git a/src/glc_ops.erl b/src/gr_lc_ops.erl similarity index 93% rename from src/glc_ops.erl rename to src/gr_lc_ops.erl index 05067c4..c7c9262 100644 --- a/src/glc_ops.erl +++ b/src/gr_lc_ops.erl @@ -1,5 +1,5 @@ %% @doc Built in operators. --module(glc_ops). +-module(gr_lc_ops). -export([ lt/2, @@ -44,7 +44,7 @@ eq(Key, Term) when is_atom(Key) -> eq(Key, Term) -> erlang:error(badarg, [Key, Term]). -%% @doc Test that a field value is greater than a term. +%% @doc Test that a field value is gr_eater than a term. -spec gt(atom(), term()) -> op(). gt(Key, Term) when is_atom(Key) -> {Key, '>', Term}; @@ -95,7 +95,7 @@ null(Result) -> %% Updating the output action of a query finalizes it. Attempting %% to use a finalized query to construct a new query will result %% in a `badarg' error. --spec with(op(), fun((gre:event()) -> term())) -> op(). +-spec with(op(), fun((gr_e:event()) -> term())) -> op(). with(Query, Fun) when is_function(Fun, 1) -> {with, Query, Fun}; with(Query, Fun) -> @@ -113,7 +113,7 @@ with(Query, Fun) -> %% a `badarg' error will be thrown. -spec union([op()]) -> op(). union(Queries) -> - case [Query || Query <- Queries, glc_lib:onoutput(Query) =:= output] of + case [Query || Query <- Queries, gr_lc_lib:onoutput(Query) =:= output] of [] -> {union, Queries}; [_|_] -> erlang:error(badarg, [Queries]) end.