tests/controller_parser_test_data/collection_with_get.con tests/controller_parser_test_data/empty_collection_and_resource.con tests/controller_parser_test_data/empty_resource_and_collection.con tests/controller_parser_test_data/only_empty_collection.con tests/controller_parser_test_data/only_empty_resource.con tests/controller_parser_test_data/resource_with_get.con tests/ebin/.empty_file_for_git @@ -5,14 +5,18 @@ all: subdirs subdirs: @for d in $(SUB_DIRECTORIES); do \ - (cd $$d; $(MAKE)); \ + ($(MAKE) -C $$d ); \ done clean: @for d in $(SUB_DIRECTORIES); do \ - (cd $$d; $(MAKE) clean); \ + ($(MAKE) clean -C $$d); \ done test: all - cd tests && $(MAKE) test - + $(MAKE) test -C tests + +retest: + $(MAKE) clean -C src + $(MAKE) clean -C tests + $(MAKE) test Makefile @@ -4,10 +4,10 @@ all: subdirs subdirs: @for d in $(SUB_DIRECTORIES); do \ - (cd $$d; $(MAKE)); \ + ($(MAKE) -C $$d); \ done clean: @for d in $(SUB_DIRECTORIES); do \ - (cd $$d; $(MAKE) clean); \ + ($(MAKE) clean -C $$d); \ done \ No newline at end of file lib/Makefile @@ -1,6 +1,194 @@ -module(controller_parser). -author('jeff@somethingsimilar.com'). --export([foobar/0]). +-export([ + parse_controller_file/1, collection/1, + resource/1, resource_methods/1, collection_methods/1 +]). -foobar() -> - true. \ No newline at end of file +%% Matches a line ending in only whitespace or a new line (with whitespace +%% optionally before it) or the beginning of a comment (also with whitespace +%% optionally before it). + +-define(EndOfLineRegex, "[\s\t]*(%|\n)?"). +-define(CollectionRegex, "^[\s\t]*collection[\s\t]*:?" ++ ?EndOfLineRegex). +-define(ResourceRegex, "^[\s\t]*resource[\s\t]*:?" ++ ?EndOfLineRegex). +-define(MethodRegex, "^[\s\t]*([a-z][a-zA-Z0-9])+:?" ++ ?EndOfLineRegex). +-define(EndRegex, "^[\s\t]*:::" ++ ?EndOfLineRegex). + +-import(regexp,[match/2]). +-import(file, [open/2]). + +parse_controller_file(ControllerFileName) -> + {ok, File} = file:open(ControllerFileName, [read]), + start_top_level(File). + +start_top_level(File) -> + parse_top_level(File, []). + +parse_top_level(File, ConHash) -> + Line = io:get_line(File, ''), + + case match_top_level_line(Line) of + start_collection -> + start_collection_group(File, ConHash); + + start_resource -> + start_resource_group(File, ConHash); + + end_found_outside_of_definition -> + throw(end_found_outside_of_definition); + eof -> + ConHash; + true -> parse_top_level(File, ConHash) + end. + +match_top_level_line(eof) -> eof; +match_top_level_line(Line) -> + CollStartLine = regexp:first_match(Line, ?CollectionRegex), + ResStartLine = regexp:first_match(Line, ?ResourceRegex), + EndLine = regexp:first_match(Line, ?EndRegex), + if + CollStartLine /= nomatch -> + start_collection; + + ResStartLine /= nomatch -> + start_resource; + + EndLine /= nomatch -> + end_found_outside_of_definition; + + true -> true + end. + +start_collection_group(File, ConHash) -> + parse_collection_group(File, ConHash, []). + +parse_collection_group(File, ConHash, Methods) -> + Line = io:get_line(File, ''), + + case match_line_in_collection_group(Line) of + end_found -> finish_collection_group(File, ConHash, Methods); + + {method, MethodName} -> + start_method_group(File, ConHash, collection, Methods, MethodName); + + %% eof's shouldn't be seen if we haven't finished with the collection + eof -> throw(unexpected_eof_in_collection); + + %% If it's not dangerous and hasn't been defined, just ignore it. + _ -> parse_collection_group(File, ConHash, Methods) + end. + +match_line_in_collection_group(eof) -> eof; +match_line_in_collection_group(Line) -> + MethodMatch = regexp:first_match(Line, ?MethodRegex), + + %% FIXME This line causes problems because we want to be greedy + EndLine = regexp:first_match(Line, ?EndRegex), + + if + EndLine /= nomatch -> + end_found; + + MethodMatch /= nomatch -> + {match, Start, Len} = MethodMatch, + {method, lists:sublist(Line, Start+1, Len)}; + + true -> true + end. + +finish_collection_group(File, ConHash, Methods) -> + %% We're done with the collection, so we pop back out to the top level + parse_top_level(File, [{collection, [{methods, Methods}]}|ConHash]). + +start_resource_group(File, ConHash) -> + parse_resource_group(File, ConHash, []). + +parse_resource_group(File, ConHash, Methods) -> + Line = io:get_line(File, ''), + + case match_line_in_resource_group(Line) of + end_found -> finish_resource_group(File, ConHash, Methods); + + {method, MethodName} -> + start_method_group(File, ConHash, resource, Methods, MethodName); + %% eof's shouldn't be seen if we haven't finished the resource + eof -> throw(unexpected_eof_in_resource); + + %% If it's not dangerous and hasn't been defined, just ignore it. + _ -> parse_resource_group(File, ConHash, Methods) + end. + + +match_line_in_resource_group(eof) -> eof; +match_line_in_resource_group(Line) -> + MethodMatch = regexp:first_match(Line, ?MethodRegex), + %% FIXME This line causes problems because we want to be greedy + EndMatch = regexp:first_match(Line, ?EndRegex), + + if + EndMatch /= nomatch -> + end_found; + + MethodMatch /= nomatch -> + {match, Start, Len} = MethodMatch, + {method, lists:sublist(Line, Start+1, Len)}; + + true -> true + end. + +finish_resource_group(File, ConHash, Methods) -> + %% TODO other nifty stuff + %% We're done with the resource, so we pop back out to the top level + parse_top_level(File, [{resource, [{methods, Methods}]}|ConHash]). + + +start_method_group(File, ConHash, GroupType, Methods, MethodName) -> + parse_method_group(File, ConHash, GroupType, Methods, MethodName, []). + +parse_method_group(File, ConHash, GroupType, Methods, MethodName, MethodBody) -> + Line = io:get_line(File, ''), + + case match_line_in_method_group(Line) of + end_found -> finish_method_group(File, ConHash, GroupType, Methods, MethodName, MethodBody); + eof -> throw(unexpected_eof_in_method_body); + _ -> parse_method_group(File, ConHash, GroupType, Methods, MethodName, [Line|MethodBody]) + end. + +match_line_in_method_group(eof) -> eof; +match_line_in_method_group(Line) -> + EndLine = regexp:first_match(Line, ?EndRegex), + + if + EndLine /= nomatch -> + end_found; + true -> true + end. + +finish_method_group(File, ConHash, GroupType, Methods, MethodName, MethodBody) -> + Method = {MethodName, lists:concat(lists:reverse(MethodBody))}, + + case GroupType of + resource -> parse_resource_group(File, ConHash, [Method|Methods]); + collection -> parse_collection_group(File, ConHash, [Method|Methods]); + _ -> throw(unsupported_group_type) + end. + +collection(ConHash) -> + {value, CollHash} = lists:keysearch(collection, 1, ConHash), + CollHash. + +resource(ConHash) -> + {value, ResHash} = lists:keysearch(resource, 1, ConHash), + ResHash. + +collection_methods(ConHash) -> + methods_from_group(collection(ConHash)). + +resource_methods(ConHash) -> + methods_from_group(resource(ConHash)). + +methods_from_group(ResOrCollHash) -> + {_, AttrList} = ResOrCollHash, + {value, {methods, Methods}} = lists:keysearch(methods, 1, AttrList), + Methods. \ No newline at end of file src/controller_parser.erl @@ -2,6 +2,7 @@ EMULATOR=beam EUNIT_EBIN=../lib/eunit/ebin EUNIT_INCLUDE=../lib/eunit/include EBIN=../ebin +TEST_EBIN=ebin SRC=../src ERL_COMPILE_FLAGS += -I$(EUNIT_INCLUDE) +warn_unused_vars +nowarn_shadow_vars +warn_unused_import @@ -9,15 +10,15 @@ SOURCES = \ test_runner.erl \ controller_parser_test.erl -OBJECTS=$(SOURCES:%.erl=$(EBIN)/%.$(EMULATOR)) +OBJECTS=$(SOURCES:%.erl=$(TEST_EBIN)/%.$(EMULATOR)) all: $(OBJECTS) -$(EBIN)/%.$(EMULATOR):%.erl - erlc -pa $(EUNIT_EBIN) -pa $(SRC) -W $(ERL_COMPILE_FLAGS) -o$(EBIN) $< +$(TEST_EBIN)/%.$(EMULATOR):%.erl + erlc -pa $(EUNIT_EBIN) -pa $(SRC) -pa $(EBIN)-W $(ERL_COMPILE_FLAGS) -o$(TEST_EBIN) $< clean: rm -f $(OBJECTS) test: all - cd $(EBIN) && erl -noshell -pa $(EUNIT_EBIN) -pa $(SRC) -s test_runner run_all \ No newline at end of file + cd $(TEST_EBIN) && erl -noshell -pa ../$(EUNIT_EBIN) -pa ../$(SRC) -pa ../$(EBIN) -s test_runner run_all \ No newline at end of file tests/Makefile @@ -4,6 +4,50 @@ %% installation directory. The Makefile does this. -include_lib("eunit/include/eunit.hrl"). -import(eunit). +-import(controller_parser). +-import(filename, [join/1, dirname/1]). -simple_test() -> - ?assert(1+1=2). +controller_filename(ControllerName) -> + ConFile = ControllerName ++ ".con", + filename:join([filename:dirname(?FILE), "..", "controller_parser_test_data", ConFile]). + +only_empty_collection_test() -> + ConHash = controller_parser:parse_controller_file(controller_filename("only_empty_collection")), + ?assertEqual(0, length(controller_parser:collection_methods(ConHash))), + ?assertNot(lists:keysearch(resource, 1, ConHash)). + +only_empty_resource_test() -> + ConHash = controller_parser:parse_controller_file(controller_filename("only_empty_resource")), + ?assertNot(lists:keysearch(collection, 1, ConHash)), + ?assertEqual(0, length(controller_parser:resource_methods(ConHash))). + +empty_resource_and_collection_test() -> + ConHash = controller_parser:parse_controller_file(controller_filename("empty_resource_and_collection")), + ?assertEqual(0, length(controller_parser:resource_methods(ConHash))), + ?assertEqual(0, length(controller_parser:collection_methods(ConHash))). + +empty_collection_and_resource_test() -> + ConHash = controller_parser:parse_controller_file(controller_filename("empty_collection_and_resource")), + ?assertEqual(length(controller_parser:resource_methods(ConHash)), 0), + ?assertEqual(length(controller_parser:collection_methods(ConHash)), 0). + +resource_with_one_method_test() -> + ConHash = controller_parser:parse_controller_file(controller_filename("resource_with_get")), + Methods = controller_parser:resource_methods(ConHash), + [{MethodName, MethodBody}] = Methods, + + ?assertEqual(1, length(Methods)), + ?assertEqual("get", MethodName), + ?assertEqual("\t\t1,\n\t\t2\n", MethodBody). + + +collection_with_one_method_test() -> + ConHash = controller_parser:parse_controller_file(controller_filename("collection_with_get")), + Methods = controller_parser:collection_methods(ConHash), + + [{MethodName, MethodBody}] = Methods, + ?assertEqual(1, length(Methods)), + ?assertEqual("get", MethodName), + ?assertEqual("\t\t\"Bar\"\n\t\t\"Baz\"\n", MethodBody). + + \ No newline at end of file tests/controller_parser_test.erl @@ -1,16 +1,21 @@ -module(test_runner). -import(smerl). --import(filename, [basename/2]). +-import(filename, [basename/2, absname/1]). -import(filelib, [wildcard/1]). - +-import(io, [format/2]). -export([run_all/0]). run_all() -> - Mods = gather_test_modules() + Mods = lists:map(fun modulize_beam_filename/1, filelib:wildcard("*_test.beam")), + lists:foreach(fun test_module/1, Mods), shutdown_clean(). -gather_test_modules() -> - lists:map(fun(Fn) -> filename:basename(Fn, ".erl") end, filelib:wildcard("*_test.erl")). +modulize_beam_filename(Fn) -> + list_to_atom(filename:basename(Fn, ".beam")). + +test_module(Mod) -> + io:format("Testing ~s. ~n", [Mod]), + Mod:test(). shutdown_clean() -> spawn(fun() -> init:stop() end), tests/test_runner.erl df784c02001a4ee4e3f75e0b44556d3e293b56c7 Jeff Hodges jeff@somethingsimilar.com http://github.com/jmhodges/recess/commit/f9cac286eb388493616a88878d596a2d95f94cbf f9cac286eb388493616a88878d596a2d95f94cbf 2008-04-27T03:13:44-07:00 2008-04-27T03:13:44-07:00 a basic controller parsing. handles methods for the collection and the resource. also, wrote the make retest call to make my life easier b7e501c3c45ac4a8feb7f2a378d1b739156a2698 Jeff Hodges jeff@somethingsimilar.com