Improved parsing of flavor-specific tag 'include_relative'

* In Jekyll style, 'include_relative' was represented as token SimpleTag,
  instead of IncludeRelative, as expected since PR #288.
* As a consequence, filename components were parsed as separate parameters
  instead of token file_name_or_output. This behaviour got unnoticed only
  because all parameters were incorrectly concatenated into one string
  (to be fixed outside of this commit)
* In Liquid style, tag 'include_relative' is not defined (token InvalidTagId),
  but can be defined as a custom block (token SimpleBlock) or a tag (SimpleTag).
* To facilitate flavor-specific lexical analysis, flag isLiquidStyleInclude was
  was added to LiquidLexer; same code as in the LiquidParser since #196

src/main/antlr4/liquid/parser/v4/LiquidLexer.g4

@@ -1,23 +1,33 @@
 lexer grammar LiquidLexer;
 
 @lexer::members {
+  private boolean liquidStyleInclude = true;
   private boolean stripSpacesAroundTags = false;
   private boolean stripSingleLine = false;
   private java.util.LinkedList<Token> tokens = new java.util.LinkedList<>();
   private java.util.Set<String> blocks = new java.util.HashSet<String>();
   private java.util.Set<String> tags = new java.util.HashSet<String>();
   private java.util.Stack<String> customBlockState = new java.util.Stack<String>();
 
-  public LiquidLexer(CharStream charStream, boolean stripSpacesAroundTags, java.util.Set<String> blocks, java.util.Set<String> tags) {
-    this(charStream, stripSpacesAroundTags, false, blocks, tags);
+  private boolean isLiquidStyleInclude(){
+    return liquidStyleInclude;
   }
 
-  public LiquidLexer(CharStream charStream, boolean stripSpacesAroundTags) {
-    this(charStream, stripSpacesAroundTags, false, new java.util.HashSet<String>(), new java.util.HashSet<String>());
+  private boolean isJekyllStyleInclude(){
+    return !liquidStyleInclude;
   }
 
-  public LiquidLexer(CharStream charStream, boolean stripSpacesAroundTags, boolean stripSingleLine, java.util.Set<String> blocks, java.util.Set<String> tags) {
+  public LiquidLexer(CharStream charStream, boolean isLiquidStyleInclude, boolean stripSpacesAroundTags, java.util.Set<String> blocks, java.util.Set<String> tags) {
+    this(charStream, isLiquidStyleInclude, stripSpacesAroundTags, false, blocks, tags);
+  }
+
+  public LiquidLexer(CharStream charStream, boolean isLiquidStyleInclude, boolean stripSpacesAroundTags) {
+    this(charStream, isLiquidStyleInclude, stripSpacesAroundTags, false, new java.util.HashSet<String>(), new java.util.HashSet<String>());
+  }
+
+  public LiquidLexer(CharStream charStream, boolean isLiquidStyleInclude, boolean stripSpacesAroundTags, boolean stripSingleLine, java.util.Set<String> blocks, java.util.Set<String> tags) {
     this(charStream);
+    this.liquidStyleInclude = isLiquidStyleInclude;
     this.stripSpacesAroundTags = stripSpacesAroundTags;
     this.stripSingleLine = stripSingleLine;
     this.blocks = blocks;
@@ -206,14 +216,16 @@ mode IN_TAG_ID;
     // otherwise it is an invalid tag
     // BUT it also can be programed manually, so even if not supported flavour, we must respect
     // user-defined tags OR blocks
-    String text = getText();
-    if (blocks.contains(text)) {
-       setType(BlockId);
-       customBlockState.push(text);
-     } else if (tags.contains(text)) {
-       setType(SimpleTagId);
-     } else {
-       setType(InvalidTagId);
+    if (isLiquidStyleInclude()) {
+      String text = getText();
+      if (blocks.contains(text)) {
+         setType(BlockId);
+         customBlockState.push(text);
+       } else if (tags.contains(text)) {
+         setType(SimpleTagId);
+       } else {
+         setType(InvalidTagId);
+       }
      }
   } -> popMode;
 

src/main/java/liqp/Template.java

@@ -58,7 +58,7 @@ public class Template {
         Set<String> tagNames = this.templateParser.insertions.getTagNames();
 
         this.templateSize = stream.size();
-        LiquidLexer lexer = new LiquidLexer(stream, this.templateParser.isStripSpacesAroundTags(),
+        LiquidLexer lexer = new LiquidLexer(stream, this.templateParser.liquidStyleInclude, this.templateParser.isStripSpacesAroundTags(),
                 this.templateParser.isStripSingleLine(), blockNames, tagNames);
         this.sourceLocation = location;
         try {

src/test/java/liqp/TestUtils.java

@@ -34,7 +34,7 @@ public static LNode getNode(String source, String rule) throws Exception {
     public static LNode getNode(String source, String rule, TemplateParser templateParser)
         throws Exception {
 
-        LiquidLexer lexer = new LiquidLexer(CharStreams.fromString("{{ " + source + " }}"));
+        LiquidLexer lexer = new LiquidLexer(CharStreams.fromString("{{ " + source + " }}"), templateParser.liquidStyleInclude, templateParser.stripSpacesAroundTags);
         LiquidParser parser = new LiquidParser(new CommonTokenStream(lexer), templateParser.liquidStyleInclude, templateParser.evaluateInOutputTag, templateParser.errorMode);
 
         LiquidParser.OutputContext root = parser.output();

src/test/java/liqp/parser/v4/LiquidLexerTest.java

@@ -493,6 +493,23 @@ public void testInclude() {
         assertThat(tokenise("{%include").get(1).getType(), is(LiquidLexer.Include));
     }
 
+    // IncludeRelative : 'include_relative' { conditional };
+    @Test
+    public void testIncludeRelative() {
+        assertThat("tag 'include_relative' is defined only in Jekyll style",
+            tokenise("{%include_relative").get(1).getType(), is(LiquidLexer.InvalidTagId));
+    }
+
+    @Test
+    public void testIncludeRelativeCustomTag() {
+        HashSet<String> tags = new HashSet<>();
+        tags.add("include_relative");
+        List<Token> tokens = tokenise("{%include_relative%}", new HashSet<String>(), tags);
+
+        assertThat("Custom tag or block 'include_relative' can be defined in Liquid style",
+            tokens.get(1).getType(), is(LiquidLexer.SimpleTagId));
+    }
+
     //   With         : 'with';
     @Test
     public void testWith() {
@@ -598,13 +615,9 @@ private static List<Token> tokenise(String source, boolean stripSpacesAroundTags
         return tokens;
     }
 
-    static CommonTokenStream commonTokenStream(String source) {
-        return commonTokenStream(source, false);
-    }
-
     static CommonTokenStream commonTokenStream(String source, boolean stripSpacesAroundTags, Set<String> blocks, Set<String> tags) {
-
-        LiquidLexer lexer = new LiquidLexer(CharStreams.fromString(source), stripSpacesAroundTags, blocks, tags);
+        boolean isLiquidStyleInclude = true; // No tests for Jekyll style of includes, yet
+        LiquidLexer lexer = new LiquidLexer(CharStreams.fromString(source), isLiquidStyleInclude, stripSpacesAroundTags, blocks, tags);
 
         lexer.addErrorListener(new BaseErrorListener(){
             @Override
@@ -616,16 +629,4 @@ public void syntaxError(Recognizer<?, ?> recognizer, Object offendingSymbol, int
         return new CommonTokenStream(lexer);
     }
 
-    static CommonTokenStream commonTokenStream(String source, boolean stripSpacesAroundTags) {
-        LiquidLexer lexer = new LiquidLexer(CharStreams.fromString(source), stripSpacesAroundTags);
-
-        lexer.addErrorListener(new BaseErrorListener(){
-            @Override
-            public void syntaxError(Recognizer<?, ?> recognizer, Object offendingSymbol, int line, int charPositionInLine, String msg, RecognitionException e) {
-                throw new RuntimeException(e);
-            }
-        });
-
-        return new CommonTokenStream(lexer);
-    }
 }