cleanup, deleted some old stuff

src/erlydtl/erlydtl_base.erl

@@ -1,333 +0,0 @@
-%%%-------------------------------------------------------------------
-%%% File:      erlydtl_base.erl
-%%% @author    Roberto Saccon <rsaccon@gmail.com> [http://rsaccon.com]
-%%% @author    Evan Miller <emmiller@gmail.com>
-%%% @copyright 2008 Roberto Saccon, Evan Miller
-%%% @doc  
-%%% ErlyDTL AST tools (tree builder and parse transformations)
-%%% @end  
-%%%
-%%% The MIT License
-%%%
-%%% Copyright (c) 2007 Roberto Saccon, Evan Miller
-%%%
-%%% 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.
-%%%
-%%% @since 2007-11-17 by Roberto Saccon, Evan Miller
-%%%-------------------------------------------------------------------
--module(erlydtl_base).
--author('rsaccon@gmail.com').
--author('emmiller@gmail.com').
-
--record(dtl, {
-    buffer = [], 
-    args = [], 
-    doc_root = [], 
-    ext = [], 
-    var = [], 
-    props = [],
-    preset = []}).
-	
-%% API
--export([parse/1, 
-    build_tree/4, 
-    build_tree/5, 
-    build_tree/6,  
-    parse_transform/1, 
-    parse_transform/2, 
-    rel_dir/2, 
-    new_var/2,
-    binary_string/1]).
-
-
-build_tree(H, T, Ext, Preset) ->
-    Dtl = #dtl{ext = Ext, preset = Preset},
-    build_tree2(H, T, Dtl).
-    
-build_tree(H, T, DocRoot, Ext, Preset) ->
-    Dtl = #dtl{doc_root = DocRoot, ext = Ext, preset = Preset},
-    build_tree2(H, T, Dtl).
-    
-build_tree(H, T, Args, Ext, Var, Preset) ->
-    Dtl = #dtl{args = Args, ext = Ext, var = Var, preset = Preset},
-    build_tree2(H, T, Dtl).
-    
-
-%%====================================================================
-%% API
-%%====================================================================
-parse(File) ->
-    case file:read_file(File) of
-        {ok, B} ->
-            case erlydtl_scanner:scan(binary_to_list(B)) of
-                {ok, Tokens} ->
-                    erlydtl_parser:parse(Tokens);
-                Err ->
-                    Err
-            end;
-        _ ->
-            {error, "reading " ++ File ++ " failed"} 
-    end.
-
-                                              
-parse_transform({block, _Line , _Name, [nil, T]}) ->
-	parse_transform(T); 
-parse_transform(Other) ->   
-    Other.   	
-
-parse_transform({tree, variable, _, Var}, Args) ->
-    Key = list_to_atom(tl(atom_to_list(Var))),
-    binary_string(proplists:get_value(Key, Args));      
-parse_transform(Other, _) ->    
-    Other.
-     
-        
-rel_dir(Dir, DocRoot) when Dir =:= DocRoot ->
-    DocRoot;
-rel_dir(Dir, DocRoot) ->
-    RelFile = string:substr(Dir, length(DocRoot)+2),
-    filename:join([DocRoot, RelFile]).
-
-
-new_var(List, Acc) ->
-    Var = list_to_atom(lists:concat(["A", Acc])),
-    case lists:member(Var, List) of
-        false ->
-            Var;
-        _ ->
-            new_var(List, Acc + 1)
-    end.
-
-
-binary_string(String) ->
-    erl_syntax:binary([erl_syntax:binary_field(erl_syntax:integer(X)) || X <- String]).
-    % erl_syntax:string(String).  %% less verbose for debugging    
-
-
-%%====================================================================
-%% Internal functions
-%%====================================================================
-build_tree2(nil, [{extends, Line, Name}], Dtl) ->
-    #dtl{buffer = Buffer, doc_root = DocRoot, ext = Ext, preset = Preset} = Dtl,
-    case parse(filename:join([DocRoot, Name])) of
-        {ok, [AstH | AstT]} ->
-			{_, BaseBuffer, BaseArgs, _} = build_tree(AstH, AstT, DocRoot, Ext, Preset),			 
-			Out = lists:foldl(fun(X, {AccBuffer, AccArgs, Status}) ->   
-                    case X of
-                        {block, Line1, BlockName, _} ->
-                            case lists:keysearch(BlockName, 3, Buffer) of
-                        		{value, {block, _, BlockName, [H | T]}} ->
-                        		    {_, Buffer2, Args2, _} = build_tree(H, T, Ext, Preset),
-                        		    Buffer3 = [lists:reverse(Buffer2), AccBuffer],
-                        		    Args3 = [Args2, AccArgs],
-                        		    {lists:flatten(Buffer3), lists:flatten(Args3), Status};
-                        		_ ->
-                            	    {AccBuffer, AccArgs, {block, Line1, Name}}                        		     
-                            end;
-                        _ ->
-                            {[X | AccBuffer], AccArgs, Status}
-                    end
-                end, 
-                {[], BaseArgs, ok}, 
-                BaseBuffer),   
-            case Out of
-                {Buffer1, Args1, ok} ->       		   
-		            Buffer2 = lists:reverse(lists:flatten([Buffer1])),
-		            {inherited, Buffer2, lists:flatten(Args1), []};
-		        {_, _, Err} ->
-		            {error, Err}
-		    end;
-	    {error, _} ->
-		     {error, {extends, Line, "file not found"}}		
-    end;
-    
-build_tree2(nil, [{var, _, Var}], #dtl{var = Var} = Dtl) ->    
-    #dtl{buffer = Buffer, args = Args, props = Props} = Dtl,  
-    {regular, [erl_syntax:variable(Var) | Buffer], Args, Props};
-
-build_tree2(nil, [{var, _, Ns, Var}], #dtl{var = Ns} = Dtl) ->
-    #dtl{buffer = Buffer, args = Args, props = Props} = Dtl,     
-    Var1 = lists:concat([Ns, ".", Var]),
-    Props1 = [list_to_atom(Var1) | Props],
-    {regular, [erl_syntax:variable(Var1) | Buffer], Args, Props1};
-  
-    
-build_tree2(nil, [{var, _, Var}], Dtl) ->
-    #dtl{buffer = Buffer, args = Args, props = Props, preset = Preset} = Dtl,       	
-    case lists:member(Var, Args) of
-        true ->
-            {regular, [erl_syntax:variable(Var) | Buffer], Args, Props};
-        _ ->
-            Key = list_to_atom(tl(atom_to_list(Var))),
-            case proplists:get_value(Key, Preset) of
-                undefined ->
-                    {regular, [erl_syntax:variable(Var) | Buffer], [Var | Args], Props};
-                Val ->
-                    {regular, [binary_string(Val) | Buffer], Args, Props}
-            end
-    end;     
- 
-build_tree2(nil, [{tag, Line, TagName, TagArgs}], Dtl) ->
-    #dtl{buffer = Buffer, args = Args, ext = Ext, props = Props, preset = Preset} = Dtl,
-    case handle_tag(TagName, Line, TagArgs, Buffer, Ext, Preset) of
-        {ok, Buffer1} ->
-            {regular, lists:flatten([Buffer1, Buffer]), Args, Props};
-        Err ->
-            Err
-    end;
-    
-build_tree2(nil, [{for, _, It, Var, [HFor | TFor]}], Dtl) ->
-    #dtl{buffer = Buffer, props = Props} = Dtl,
-    {Buffer1, Args1} = handle_for(It, Var, HFor, TFor, Dtl), 
-    {regular, lists:flatten([Buffer1, Buffer]), Args1, Props};     
-
-build_tree2(nil, [Token], #dtl{buffer = Buffer, args = Args, props = Props}) ->
-    {regular, [Token | Buffer], Args, Props}; 
-  
-build_tree2([H | T], [{var, _, Var}], #dtl{var = Var} = Dtl) ->
-    #dtl{buffer = Buffer} = Dtl,
-    build_tree2(H, T, Dtl#dtl{buffer = [erl_syntax:variable(Var) | Buffer]});
- 
-build_tree2([H | T], [{var, _, Ns, Var}], #dtl{var = Ns} = Dtl) ->
-    #dtl{buffer = Buffer, props = Props} = Dtl,
-    Var1 = lists:concat([Ns, ".", Var]),
-    Dtl1 = Dtl#dtl{
-        buffer = [erl_syntax:variable(Var1) | Buffer], 
-        props = [list_to_atom(Var1) | Props]},
-    build_tree2(H, T, Dtl1);
-
-
-build_tree2([H | T], [{var, _, Var}], Dtl) ->
-    #dtl{buffer = Buffer, args = Args, preset = Preset} = Dtl,           		
-    Dtl1 = case lists:member(Var, Args) of
-        true ->
-            Dtl#dtl{buffer = [erl_syntax:variable(Var) | Buffer]};
-        _ ->
-            Key = list_to_atom(tl(atom_to_list(Var))),
-            case proplists:get_value(Key, Preset) of
-                undefined ->
-                    Dtl#dtl{
-                        buffer = [erl_syntax:variable(Var) | Buffer],
-                        args = [Var | Args]};
-                Val ->
-                    Dtl#dtl{buffer = [binary_string(Val) | Buffer]}
-            end
-    end,
-    build_tree2(H, T, Dtl1);
-        
-    
-build_tree2([H | T], [{tag, Line, TagName, TagArgs}], Dtl) ->
-    #dtl{buffer = Buffer, ext = Ext, preset = Preset} = Dtl,
-    case handle_tag(TagName, Line, TagArgs, Buffer, Ext, Preset) of
-        {ok, Buffer1} ->          
-            build_tree2(H, T, Dtl#dtl{buffer = Buffer1});
-        Err ->
-            Err
-    end;
- 
-build_tree2([H | T], [{for, _, It, Var, [HFor | TFor]}], #dtl{buffer = Buffer} = Dtl) ->
-    {Buffer1, Args1} = handle_for(It, Var, HFor, TFor, Dtl),
-    build_tree2(H, T, Dtl#dtl{buffer = lists:flatten([Buffer1, Buffer]), args = Args1});
-        	
-build_tree2([H | T], [Token], #dtl{buffer = Buffer} = Dtl) ->
-    build_tree2(H, T, Dtl#dtl{buffer = [Token | Buffer]}).
-    
-
-handle_for(It, Var, HFor, TFor, Dtl) ->
-    #dtl{args = Args, ext = Ext, preset = Preset} = Dtl,
-    {_, List1, Args1, Props1} = build_tree(HFor, TFor, Args, Ext, It, Preset),    
-	ItAST = erl_syntax:variable(It),
-	Key = list_to_atom(tl(atom_to_list(Var))),
-    case Props1 of
-        [] ->
-            case proplists:get_value(Key, Preset) of
-                undefined ->
-                    BodyAST = erl_syntax:generator(ItAST, erl_syntax:variable(Var)),  
-                    List2 = erl_syntax:list_comp(erl_syntax:list(List1), [BodyAST]),
-                    case lists:member(Var, Args1) of
-                        true ->
-                            {List2, Args1};
-                        _ ->
-                            {List2, [Var | Args1]}
-                	end;                   
-                Vals ->
-                    List2 = lists:map(fun (X) -> 
-                            lists:map(fun ({tree, variable, _, It1}) when It1 =:= It ->
-                                    binary_string(X);
-                                (Other) ->
-                                    Other
-                                end, List1)
-                        end, Vals),
-                    {lists:flatten(List2), Args1}
-            end;
-        _ ->
-            case proplists:get_value(Key, Preset) of
-                undefined ->
-                    FunBodyAST = lists:foldl(fun(X, Acc) -> 
-                            [_,Prop] = string:tokens(tl(atom_to_list(X)), "."),
-                            A = erl_syntax:variable(X),
-                            B = erl_syntax:application(erl_syntax:atom(proplists), 
-                                erl_syntax:atom(get_value), [erl_syntax:atom(Prop), ItAST]),
-                            [erl_syntax:match_expr(A, B) | Acc]
-                         end,
-                         [erl_syntax:list(List1)],
-                         Props1),
-                    FunClauseAST = erl_syntax:clause([ItAST], none, FunBodyAST),
-                    List2 = erl_syntax:application(erl_syntax:atom(lists), 
-                        erl_syntax:atom(map),
-                        [erl_syntax:fun_expr([FunClauseAST]), erl_syntax:variable(Var)]),
-                    case lists:member(Var, Args1) of
-                        true ->
-                            {List2, Args1};
-                        _ ->
-                            {List2, [Var | Args1]}
-                    end;
-                Vals ->                    
-                    Ns = tl(atom_to_list(It)),
-                    List2 = lists:map(fun (X) -> 
-                            lists:map(fun ({tree, variable, _, It1} = Node) ->
-                                    case string:tokens(tl(atom_to_list(It1)), ".") of
-                                        [Ns, Key1 | _] ->
-                                            binary_string(proplists:get_value(list_to_atom(Key1), X));
-                                        _ ->
-                                            Node
-                                    end;
-                                (Other) ->
-                                    Other
-                                end, List1)
-                        end, Vals),
-                    {lists:flatten(List2), Args1}
-            end
-    end.
-     
-           	        	
-handle_tag(TagName, Line, TagArgs, Acc0, Ext, Preset) ->
-    case parse(filename:join([erlydtl_deps:get_base_dir(), "priv", "tags", atom_to_list(TagName) ++ Ext])) of
-        {ok, ParentAst} ->
-		    [H|T]=ParentAst,
-			{_, List, _, _} = build_tree(H, T, Ext, Preset),
-			List1 = lists:foldl(fun(X, Acc) -> 
-			        [parse_transform(X, TagArgs) | Acc]			        
-			    end, 
-			    Acc0,
-			    lists:reverse(List)),
-			{ok, List1};
-		_ ->
-    	    {error, {TagName, Line, "loading tag source template failed"}}
-    end.

src/erlydtl/erlydtl_parser.yrl

@@ -165,90 +165,4 @@ Filter -> identifier : ['$1'].
 Filter -> identifier colon Literal : ['$1', '$3'].
 
 Literal -> string_literal : '$1'.
-Literal -> number_literal : '$1'.
-
-
-
-
-%% initial, now deprecated version by below:
-
-%% Nonterminals 
-%%     Elements
-%%     Element.
-%% 
-%% Terminals 
-%%     string
-%%     var
-%%     extends
-%%     block
-%%     endblock
-%%     tag
-%%     for
-%%     endfor.
-%% 
-%% Rootsymbol    
-%%     Elements. 
-%% 
-%% 
-%% %% -------------------------------------------------------------------
-%% %% Rules
-%% %% -------------------------------------------------------------------
-%% 
-%% Elements -> '$empty' : nil.
-%% Elements -> Elements Element : ['$1', '$2'].
-%% 
-%% Element -> string : string('$1').
-%% Element -> var : var('$1').
-%% Element -> extends : extends('$1').
-%% Element -> block Elements endblock : block('$1', '$2').
-%% Element -> tag : tag('$1').
-%% Element -> for Elements endfor : for('$1', '$2').
-%% 
-%% 
-%% Erlang code.
-%% 
-%% string({_, String}) ->
-%%     erl_syntax:binary([erl_syntax:binary_field(erl_syntax:integer(X)) || X <- String]).
-%%     %erl_syntax:string(String).  %% less verbose for debugging 
-%%     
-%% 
-%% var({_, Line, Var}) ->
-%%     case string:tokens(Var, ".") of
-%%         [Namespace, Var1] ->
-%%             {var, Line, list_to_atom("A" ++ Namespace), list_to_atom(Var1)};
-%%         _ ->
-%%             {var, Line, list_to_atom("A" ++ Var)}
-%%     end.
-%% 
-%% 
-%% extends({_, Line, [Name]}) ->
-%%     %% TODO: check if string (enclosed with  "") or variable. 
-%%     %% for now we handle it (even not enclosed with "") as string
-%%     {extends, Line, string:strip(Name, both, $")}.
-%% 
-%% 
-%% block({_, Line, [Name]}, Content) ->
-%%     {block, Line, list_to_atom(Name), Content}.
-%% 
-%% 
-%% tag({_, Line, [TagName | Args]}) ->
-%%     %% TODO: check if string (enclosed with  "") or variable. 
-%%     %% for now we handle it (even not enclosed with "") as string
-%%  Args2 = lists:foldl(fun(X, Acc) ->
-%%          case string:chr(X, $=) of
-%%              0 ->
-%%                  Acc;
-%%              Pos ->
-%%                  Var = list_to_atom(string:sub_string(X, 1, Pos-1)),
-%%                  Val = string:sub_string(X, Pos+1),
-%%                  Val2 = string:strip(Val, both, $"),
-%%                  [{Var, Val2}| Acc]
-%%          end
-%%      end,
-%%      [],
-%%      Args),
-%%     {tag, Line, TagName, Args2}.
-%% 
-%% 
-%% for({_, Line, [Iterator, _, Var]}, Content) ->
-%%     {for, Line, list_to_atom("A" ++ Iterator), list_to_atom("A" ++ Var), Content}.
+Literal -> number_literal : '$1'.

src/erlydtl/erlydtl_scanner.erl

@@ -223,203 +223,4 @@ char_type(Char) ->
             digit;
         _ ->
             undefined
-    end.
-
-
-
-%% -module(erlydtl_scanner).
-%% -author('rsaccon@gmail.com').
-%% 
-%% %% API
-%% -export([scan/1]).  
-%% 
-%% %%====================================================================
-%% %% API
-%% %%====================================================================
-%% %%--------------------------------------------------------------------
-%% %% @spec scan(T::template()) -> {ok, S::tokens()} | {error, Reason}
-%% %% @type template() = string() | binary(). Template to parse
-%% %% @type tokens() = [tuple()].
-%% %% @doc Scan the template string T and return the a token list or
-%% %% an error.
-%% %% @end
-%% %%--------------------------------------------------------------------
-%% 
-%% scan(Template) ->
-%%     scan(Template, [], 1).
-%% 
-%% scan([], Scanned, _Line) ->
-%%     Tokens = fold_strings(lists:reverse(Scanned), [], []),
-%%     {ok, Tokens};
-%% 
-%% scan([$<, $\!, $-, $-, ${, ${ | T], Scanned, Line) ->
-%%   Rules = [until(fun is_var_end/1), 
-%%            until(fun is_html_comment_end/1)],
-%%   Scan = scan2(Rules),
-%%   case Scan(T) of
-%%       {ok, Token, LinesScanned, Rest} ->
-%%           scan(Rest, [{var, Line, Token} | Scanned], Line + LinesScanned);
-%%       {error, Reason} -> 
-%%           {error, {var, Line, Reason}}
-%%   end;             
-%% 
-%% scan([${, ${ | T], Scanned, Line) ->
-%%   Rules = [until(fun is_var_end/1)],
-%%   Scan = scan2(Rules),
-%%   case Scan(T) of
-%%       {ok, Token, LinesScanned, Rest} ->
-%%           scan(Rest, [{var, Line, Token} | Scanned], Line + LinesScanned);
-%%       {error, Reason} -> 
-%%           {error, {var, Line, Reason}}
-%%   end;
-%% 
-%% scan([$<, $\!, $-, $-, ${, $\% | T], Scanned, Line) ->
-%%   Rules = [until(fun is_tag_end/1), 
-%%            until(fun is_html_comment_end/1)],
-%%   Scan = scan2(Rules),
-%%   case Scan(T) of
-%%       {ok, Token, LinesScanned, Rest} ->
-%%           scan(Rest, [{tag, Line, Token} | Scanned], Line + LinesScanned);
-%%       {error, Reason} -> 
-%%           {error, {tag, Line, Reason}}
-%%   end;
-%% 
-%% scan([${, $\% | T], Scanned, Line) ->
-%%   Rules = [until(fun is_tag_end/1)],
-%%   Scan = scan2(Rules),
-%%   case Scan(T) of
-%%       {ok, Token, LinesScanned, Rest} ->
-%%           scan(Rest, [{tag, Line, Token} | Scanned], Line + LinesScanned);
-%%       {error, Reason} -> 
-%%           {error, {tag, Line, Reason}}
-%%   end;
-%% 
-%% scan([${, $# | T], Scanned, Line) ->
-%%   Rules = [until(fun is_comment_end/1)],
-%%   Scan = scan2(Rules), 
-%%   case Scan(T) of
-%%       {ok, _Token, LinesScanned, Rest} ->
-%%           scan(Rest, Scanned, Line + LinesScanned);
-%%       {error, Reason} -> 
-%%           {error, {var, Line, Reason}}
-%%   end;
-%% 
-%% scan([H | T], Scanned, Line) when [H] == "\r" andalso hd(T) == "\n" ->
-%%     scan(tl(T), ["\r\n" | Scanned], Line+1);
-%% 
-%% scan([H | T], Scanned, Line) when [H] == "\r" orelse [H] == "\n" ->
-%%     scan(T, [H | Scanned], Line+1);
-%% 
-%% scan([H | T], Scanned, Line) ->
-%%     scan(T, [H | Scanned], Line).
-%% 
-%% 
-%% %%--------------------------------------------------------------------
-%% %% Internal Functions
-%% %%--------------------------------------------------------------------   
-%% 
-%% scan2(Rules) ->
-%%     fun(Tmpl) ->
-%%      scan2(Rules, Tmpl, [], 0)
-%%     end.
-%% 
-%% 
-%% scan2([], Tmpl, SoFar, Line) ->
-%%     {ok, lists:reverse(SoFar), Line, Tmpl};
-%% 
-%% scan2([Rule | T], Tmpl, SoFar, Line) ->
-%%     case Rule(Tmpl) of
-%%  {error, Reason} ->
-%%      {error, Reason};
-%%  {ok, Rest, LinesScanned} ->
-%%      scan2(T, Rest, SoFar, Line + LinesScanned);
-%%  {ok, Tok, LinesScanned, Rest} ->
-%%      scan2(T, Rest, [Tok | SoFar], Line + LinesScanned)
-%%     end.
-%% 
-%% fold_strings([], Folded, []) ->
-%%     lists:reverse(Folded);
-%% 
-%% fold_strings([], Folded, Acc) ->
-%%     S = {string, lists:reverse(Acc)},
-%%     lists:reverse([S | Folded]);
-%% 
-%% fold_strings([H | T], Folded, []) when is_tuple(H) ->
-%%     fold_strings(T, [translate_token(H) | Folded], []);
-%% 
-%% fold_strings([H | T], Folded, Acc) when is_tuple(H) ->
-%%     S = {string, lists:reverse(Acc)},
-%%     fold_strings(T, [translate_token(H), S | Folded], []);
-%% 
-%% fold_strings([H | T], Folded, Acc) ->
-%%     fold_strings(T, Folded, [H | Acc]).
-%% 
-%% 
-%% translate_token({var, Line, [[S] | _]}) ->
-%%     {var, Line, S};
-%% 
-%% translate_token({tag, Line, [[H | T] | _]}) ->
-%%     translate_tag(H, T, Line) ;
-%% 
-%% translate_token(Token) ->
-%%     io:format("TRACE ~p:~p unrecognized token: ~p~n",[?MODULE, ?LINE, Token]),
-%%     Token.
-%% 
-%% translate_tag("extends" = H, T, Line) ->
-%%     {list_to_atom(H), Line, T};
-%%     
-%% translate_tag("block" = H, T, Line) ->
-%%     {list_to_atom(H), Line, T};   
-%%     
-%% translate_tag("endblock" = H, T, Line) ->
-%%     {list_to_atom(H), Line, T};    
-%%     
-%% translate_tag("for" = H, T, Line) ->
-%%     {list_to_atom(H), Line, T};   
-%% 
-%% translate_tag("endfor" = H, T, Line) ->
-%%     {list_to_atom(H), Line, T};    
-%%          
-%% translate_tag(H, T, Line) ->
-%%     {tag, Line, [list_to_atom(H) | T]}.
-%% 
-%% 
-%% until(P) ->
-%%     fun (Tmpl) -> 
-%%             until(P, Tmpl, 0, []) 
-%%     end.
-%% 
-%% until(_P, [], _Line, _Scanned) ->    
-%%     {error, end_not_found};
-%% 
-%% until(P, [H|T], Line, Scanned) when [H]=="\r" andalso hd(T)=="\n" ->
-%%     until(P, tl(T), Line+1, Scanned);
-%% 
-%% until(P, [H|T], Line, Scanned) when [H]=="\n" orelse [H]== "\r" ->
-%%     until(P, T, Line+1, Scanned);
-%% 
-%% until(P, [H|T]=Tmpl, Line, Scanned) ->
-%%     case P(Tmpl) of
-%%  {true, R} ->
-%%             Scanned1 = string:strip(lists:reverse(Scanned)),
-%%             Scanned2 = string:tokens(Scanned1, " "),
-%%      {ok, Scanned2, Line, R};
-%%  _ ->
-%%      until(P, T, Line, [H | Scanned])
-%%     end.
-%% 
-%% 
-%% is_var_end([$}, $} | T]) -> {true, T};
-%% is_var_end(_) -> false.
-%%    
-%% 
-%% is_tag_end([$\%, $} | T]) -> {true, T};
-%% is_tag_end(_) -> false.
-%% 
-%% 
-%% is_comment_end([$#, $} | T]) -> {true, T};
-%% is_comment_end(_) -> false.
-%% 
-%% 
-%% is_html_comment_end([$-, $-, $> | T]) -> {true, T};
-%% is_html_comment_end(_) -> false.
+    end.

src/erlydtl/erlydtl_server.erl

@@ -133,14 +133,7 @@ init([]) ->
 %% @end 
 %%--------------------------------------------------------------------
 handle_call({compile, File, DocRoot, Mod, Func, Vars}, _From, State) ->
-    Reply = case erlydtl_base:parse(File) of
-        {ok, Ast} ->
-		    DocRoot2 = erlydtl_base:rel_dir(filename:dirname(File), DocRoot),
-		    Ext = filename:extension(File),
-		    compile(Ast, Mod, Func, DocRoot2, Ext, Vars, State#state.reload);
-        Err ->
-            Err
-    end,
+    Reply = not_implemented,
     {reply, Reply, State};       
 
 handle_call(_Request, _From, State) ->
@@ -189,73 +182,4 @@ code_change(_OldVsn, State, _Extra) ->
 
 %%====================================================================
 %% Internal functions
-%%====================================================================
-compile([H | T], Module, FuncName, DocRoot, Ext, Vars, Reload) ->
-    case erlydtl_base:build_tree(H, T, DocRoot, Ext, Vars) of
-        {regular, Out, Args, _} ->
-            Out1 = [erlydtl_base:parse_transform(X) ||  X <- Out],
-            create_module(Out1, Args, Module, FuncName, Reload);
-        {inherited, Out, Args, _} ->
-            create_module(Out, Args, Module, FuncName, Reload);
-        {error, Reason} ->
-            {error, Reason}
-    end.   
-       
-    
-create_module(List, Args, Module, FuncName, Reload) ->
-    case Args of 
-        []  ->
-            Body = erl_syntax:tuple([
-                erl_syntax:atom(ok), 
-                erl_syntax:list(List),
-                erl_syntax:list([])]),
-            create_module2([Body], [], Module, FuncName, Reload);
-        _ ->            
-            Warnings = erl_syntax:list([]), %% TODO: add warnings for unused variables
-            Ret = erl_syntax:tuple([erl_syntax:atom(ok), erl_syntax:list(List), Warnings]),
-            Var = erl_syntax:variable(erlydtl_base:new_var(Args, 0)),
-            Body = lists:foldl(fun(X, Acc) -> 
-                    X2 = list_to_atom(tl(atom_to_list(X))),
-                    A = erl_syntax:variable(X),
-                    B = erl_syntax:application(erl_syntax:atom(proplists), 
-                        erl_syntax:atom(get_value), [erl_syntax:atom(X2), Var]),
-                    ClauseOk = erl_syntax:clause([erl_syntax:variable('_')], none, [B]),                 
-                    Err = erlydtl_base:binary_string("{{ undefined }}"), %% TDOD: return list of errors instead of rendereing  "undefined"                     
-                    ClauseErr = erl_syntax:clause([erl_syntax:atom(undefined)], none, [Err]),                 
-                    C = erl_syntax:case_expr(B, [ClauseErr, ClauseOk]),                
-                    D = erl_syntax:match_expr(A, C),
-                    [D | Acc]
-                end,
-                [Ret],
-                Args), 
-            create_module2(Body, [Var], Module, FuncName, Reload)
-    end.
-    
-    
-create_module2(Body, Args, Module, FuncName, Reload) ->
-    Clause = erl_syntax:clause(Args, none, Body),
-    Func = erl_syntax:function(erl_syntax:atom(FuncName), [Clause]),
-    [AttrMod, AttrExp] = [erl_syntax:attribute(erl_syntax:atom(X), [erl_syntax:atom(Y)]) ||
-        {X, Y} <- [{"module", Module}, {"compile", "export_all"}]],
-    Forms = [erl_syntax:revert(X) || X <- [AttrMod, AttrExp, Func]],
-    case compile:forms(Forms) of
-        {ok, Module1, Bin} ->
-            case erlydtl:write_beam(Module1, Bin, "ebin") of
-                ok ->
-                    case Reload of
-                        true ->
-                            case erlydtl:reload(Module1, Bin) of
-                                ok ->
-                                    ok;
-                                _ ->
-                                    {error, "code reload failed"}
-                            end;
-                        _ ->
-                            ok
-                    end;
-                _ ->
-                    {error, "beam generation failed"}
-            end;
-        _ ->
-            {error, "compilation failed"}
-    end.
+%%====================================================================