relax the grammar of partial names to allow relative paths ../foo

Author: gasche

bin/test/errors/parsing-errors.t

@@ -62,7 +62,7 @@ Delimiter problems:
   $ echo "{{>" > $PROBLEM
   $ mustache foo.json $PROBLEM
   Template parse error:
-  File "eof-before-partial.mustache", line 2, character 0: ident expected.
+  File "eof-before-partial.mustache", line 2, character 0: '}}' expected.
   [3]
 
   $ PROBLEM=eof-in-comment.mustache

bin/test/partials.t/run.t

@@ -3,3 +3,18 @@ Simple test:
   $ mustache data.json foo.mustache
   Inside the include is "Foo Bar !"
 
+Include in child or parent directory:
+  $ mkdir subdir
+  $ echo "Test from {{src}}" > subdir/test.mustache
+  $ echo "{{> subdir/test }}" > from_parent.mustache
+  $ echo '{ "src": "parent" }' > from_parent.json
+  $ mustache from_parent.json from_parent.mustache
+  Test from parent
+  
+
+  $ mkdir subdir/child
+  $ echo "{{> ../test }}" > subdir/child/from_child.mustache
+  $ echo '{ "src": "child" }' > subdir/child/from_child.json
+  $ (cd subdir/child; mustache from_child.json from_child.mustache)
+  Test from child
+  

lib/mustache_lexer.mll

@@ -55,6 +55,25 @@ let raw = [^ '{' '}' '\n']*
 let id = ['a'-'z' 'A'-'Z' '-' '_' '/'] ['a'-'z' 'A'-'Z' '0'-'9' '-' '_' '/']*
 let ident = ('.' | id ('.' id)*)
 
+(* The grammar of partials is very relaxed compared to normal
+   identifiers: we want to allow dots anywhere to express relative
+   paths such as ../foo (this is consistent with other implementations
+   such as the 'mustache' binary provided by the Ruby implementation),
+   and in general we don't know what is going to be used, given that
+   partials are controlled programmatically.
+
+   We forbid spaces, to ensure that the behavior of trimming spaces
+   around the partial name is consistent with the other tag, and we
+   forbid newlines and mustaches to avoid simple delimiter mistakes
+   ({{> foo } ... {{bar}}) being parsed as valid partial names.
+
+   (Note: if one wishes to interpret partials using lambdas placed
+   within the data (foo.bar interpreted as looking up 'foo' then 'bar'
+   in the input data and hoping to find a user-decided representation
+   of a function, it is of course possible to restrict the valid names
+   and split on dots on the user side.) *)
+let partial_name = [^ ' ' '\t' '\n' '{' '}']*
+
 rule space = parse
   | blank newline { new_line lexbuf; space lexbuf }
   | blank { () }
@@ -63,6 +82,9 @@ and ident = parse
   | ident { lexeme lexbuf }
   | ""    { raise (Error "ident expected") }
 
+and partial_name = parse
+  | partial_name { lexeme lexbuf }
+
 and end_on expected = parse
   | ("}}" | "}}}" | "") as lexed { check_mustaches ~expected ~lexed }
 
@@ -80,7 +102,7 @@ and mustache = parse
   | "{{#"        { OPEN_SECTION (lex_tag lexbuf space ident (end_on "}}") |> split_ident) }
   | "{{^"        { OPEN_INVERTED_SECTION (lex_tag lexbuf space ident (end_on "}}") |> split_ident) }
   | "{{/"        { CLOSE_SECTION (lex_tag lexbuf space ident (end_on "}}") |> split_ident) }
-  | "{{>"        { PARTIAL (0, lex_tag lexbuf space ident (end_on "}}")) }
+  | "{{>"        { PARTIAL (0, lex_tag lexbuf space partial_name (end_on "}}")) }
   | "{{!"        { COMMENT (tok_arg lexbuf (comment [])) }
   | raw newline  { new_line lexbuf; RAW (lexeme lexbuf) }
   | raw          { RAW (lexeme lexbuf) }