simple_templates 0.8.7

data/test/simple_templates/parser/node_parser_test.rb

@@ -0,0 +1,38 @@
+require_relative "../../test_helper"
+
+module SimpleTemplates
+  class Parser
+    class TestNodeParserImpl < NodeParser
+      STARTING_TOKENS = [:text]
+    end
+  end
+end
+
+describe SimpleTemplates::Parser::NodeParser do
+  let(:target)  {SimpleTemplates::Parser::NodeParser}
+  let(:impl)    {SimpleTemplates::Parser::TestNodeParserImpl}
+  let(:example) {SimpleTemplates::Lexer::Token.new(:text, 'a', 0)}
+
+  describe "#initialize" do
+    it 'raises an error if the input is not valid' do
+      -> {
+      impl.new( SimpleTemplates::Unescapes.new('<'),
+                [SimpleTemplates::Lexer::Token.new(:ph_start, '<', 0)],
+                ['name'])
+      }.must_raise ArgumentError
+    end
+  end
+
+  describe "#applicable?" do
+    it "ignores missing" do
+      impl.applicable?([]).must_equal false
+    end
+    it "can be applied" do
+      impl.applicable?([example]).must_equal true
+    end
+    it "can't be applied" do
+      target.applicable?([example]).must_equal false
+    end
+  end
+
+end

data/test/simple_templates/parser/placeholder_test.rb

@@ -0,0 +1,105 @@
+require_relative '../../test_helper'
+
+describe SimpleTemplates::Parser::Placeholder do
+  describe '#parse' do
+    let(:delimiter) { SimpleTemplates::Delimiter.new(/\\</, /\\>/, /\</, /\>/) }
+    let(:unescapes) { SimpleTemplates::Unescapes.new('<', '>') }
+    let(:target) { SimpleTemplates::Parser::Placeholder }
+    let(:ast_ph) { SimpleTemplates::AST::Placeholder }
+    let(:lexer_token) { SimpleTemplates::Lexer::Token }
+    let(:parse_error) { SimpleTemplates::Parser::Error }
+    let(:valid_phs) { ['name'] }
+    let (:ph_tokens) do
+      [
+        lexer_token.new(:ph_start, '<', 0),
+        lexer_token.new(:ph_name, 'name', 1),
+        lexer_token.new(:ph_end, '>', 9),
+      ]
+    end
+
+    describe 'with a placeholder as the first part of the input' do
+      let(:tokens) { ph_tokens << lexer_token.new(:text, ' some text', 10) }
+
+      it 'returns no errors' do
+        _, errors, _ = target.new(unescapes, tokens, valid_phs).parse
+        errors.must_be_empty
+      end
+
+      it 'returns the remaining tokens after the placeholder' do
+        _, _, remaining_tokens = target.new(unescapes, tokens, valid_phs).parse
+        remaining_tokens.must_equal [lexer_token.new(:text, ' some text', 10)]
+      end
+
+      it 'returns a AST placeholder' do
+        placeholder_ast, _, _ = target.new(unescapes, tokens, valid_phs).parse
+        placeholder_ast.must_equal [ast_ph.new('name', 0, true)]
+      end
+    end
+
+    describe 'with no placeholder as the first part of the input' do
+      let(:tokens) { ph_tokens.unshift(lexer_token.new(:text, 'hello ', 0)) }
+
+      it 'raises an error' do
+        -> {
+          target.new(unescapes, tokens, valid_phs)
+        }.must_raise ArgumentError
+      end
+    end
+
+    describe 'with an empty placeholder' do
+      let(:tokens) do
+        [
+          lexer_token.new(:ph_start, '<', 0),
+          lexer_token.new(:ph_end, '>', 1),
+          lexer_token.new(:text,  ' some text', 2)
+        ]
+      end
+
+      it 'returns an error about not finding the placeholder' do
+        _, errors, _ = target.new(unescapes, tokens, valid_phs).parse
+        errors.must_equal [
+          parse_error.new('Expected placeholder name token at character position 1, but found a placeholder end token instead.')
+        ]
+      end
+
+      it 'returns an empty Array as the remaining tokens' do
+        _, _, remaining_tokens = target.new(unescapes, tokens, valid_phs).parse
+        remaining_tokens.must_be_empty
+      end
+
+      it 'returns an empty list of AST placeholders' do
+        placeholder_ast, _, _ = target.new(unescapes, tokens, valid_phs).parse
+        placeholder_ast.must_be_empty
+      end
+    end
+
+    describe 'with an invalid placeholder name' do
+      let(:tokens) do
+        [
+          lexer_token.new(:ph_start, '<', 0),
+          lexer_token.new(:ph_name, 'name', 1),
+          lexer_token.new(:text, '-', 5),
+          lexer_token.new(:ph_end, '>', 6),
+          lexer_token.new(:text, ' some text', 7),
+        ]
+      end
+
+      it 'returns an error about not finding the placeholder' do
+        _, errors, _ = target.new(unescapes, tokens, valid_phs).parse
+        errors.must_equal [
+          parse_error.new('Expected placeholder end token at character position 5, but found a text token instead.')
+        ]
+      end
+
+      it 'returns an empty Array of remaining tokens' do
+        _, _, remaining_tokens = target.new(unescapes, tokens, valid_phs).parse
+        remaining_tokens.must_be_empty
+      end
+
+      it 'returns an empty Array of AST placeholders' do
+        placeholder_ast, _, _ = target.new(unescapes, tokens, valid_phs).parse
+        placeholder_ast.must_be_empty
+      end
+    end
+  end
+end

data/test/simple_templates/parser/text_test.rb

@@ -0,0 +1,118 @@
+require_relative '../../test_helper'
+
+describe SimpleTemplates::Parser::Text do
+  describe '#parse' do
+    let(:delimiter) { SimpleTemplates::Delimiter.new(/\\</, /\\>/, /\</, /\>/) }
+    let(:unescapes) { SimpleTemplates::Unescapes.new('<', '>') }
+    let(:ast_text) { SimpleTemplates::AST::Text }
+    let(:lexer_token) { SimpleTemplates::Lexer::Token }
+    let(:target) { SimpleTemplates::Parser::Text }
+    let(:valid_phs) { ['name'] }
+    let(:ph_tokens) do
+      [
+        lexer_token.new(:ph_start, '<', 6),
+        lexer_token.new(:ph_name, 'name', 7),
+        lexer_token.new(:ph_end, '>', 15)
+      ]
+    end
+
+  describe 'with a valid input' do
+      let(:tokens) { [lexer_token.new(:text, 'hello ', 0)].concat(ph_tokens) }
+
+      it 'returns a list with only the text before the placeholder' do
+        txt_nodes, _, _ = target.new(unescapes, tokens, valid_phs).parse
+        txt_nodes.must_equal [ast_text.new('hello ', 0, true)]
+      end
+
+      it 'returns no errors' do
+        _, errors_list, _ = target.new(unescapes, tokens, valid_phs).parse
+        errors_list.must_be_empty
+      end
+
+      it 'returns the remaining tokens containing only the placeholder part' do
+        _, _, remaining_tokens = target.new(unescapes, tokens, valid_phs).parse
+        remaining_tokens.must_equal ph_tokens
+      end
+    end
+
+    describe 'with a new line in the placeholder name' do
+      let(:other_tokens) do
+        [
+          lexer_token.new(:ph_start, '<', 6),
+          lexer_token.new(:ph_name, 'na', 7),
+          lexer_token.new(:text, "\nme", 9),
+          lexer_token.new(:ph_end, '>', 12)
+        ]
+      end
+      let(:tokens) { [lexer_token.new(:text, 'hello ', 0)].concat(other_tokens) }
+
+      it 'returns the remainin tokens with a new line as text in the placeholder' do
+        _, _, remaining_tokens = target.new(unescapes, tokens, valid_phs).parse
+        remaining_tokens.must_equal other_tokens
+      end
+
+      it 'returns no errors' do
+        _, errors_list, _ = target.new(unescapes, tokens, valid_phs).parse
+        errors_list.must_be_empty
+      end
+
+      it 'returns the text nodes' do
+        txt_nodes, _, _ = target.new(unescapes, tokens, valid_phs).parse
+        txt_nodes.must_equal [ast_text.new('hello ', 0, true)]
+      end
+    end
+
+    describe 'with leading and trailing whitespaces' do
+      let(:tokens) { [lexer_token.new(:text, 'hello ', 0)].concat(ph_tokens) }
+
+      it 'returns the remaining tokens with no placeholder name' do
+        _, _, remaining_tokens = target.new(unescapes, tokens, valid_phs ).parse
+        remaining_tokens.must_equal ph_tokens
+      end
+
+      it 'returns the text nodes' do
+        txt_nodes, _, _ = target.new(unescapes, tokens, valid_phs ).parse
+        txt_nodes.must_equal [ast_text.new('hello ', 0, true)]
+      end
+    end
+
+    describe 'with a newline after the placeholder' do
+      let(:other_tokens) { ph_tokens << lexer_token.new(:text, "\n world", 12) }
+      let(:tokens) { [lexer_token.new(:text, 'hello ', 0)].concat(other_tokens) }
+      
+      it 'returns a list with remaining tokens with the placeholder and followed by text' do
+        _, _, remaining_tokens = target.new(unescapes, tokens, valid_phs ).parse
+        remaining_tokens.must_equal other_tokens
+      end
+
+      it 'returns no errors' do
+        _, errors_list, _ = target.new(unescapes, tokens, valid_phs).parse
+        errors_list.must_be_empty
+      end
+
+      it 'returns the text nodes' do
+        txt_nodes, _, _ = target.new(unescapes, tokens, valid_phs ).parse
+        txt_nodes.must_equal [ast_text.new('hello ', 0, true)]
+      end
+    end
+
+    describe 'with a new line character before the placeholder' do
+      let(:tokens) { [lexer_token.new(:text, "hello \n", 0)].concat(ph_tokens) }
+
+      it 'returns remaining tokens with the placeholder' do
+        _, _, remaining_tokens = target.new(unescapes, tokens, valid_phs ).parse
+        remaining_tokens.must_equal ph_tokens
+      end
+
+      it 'returns no errors' do
+        _, errors_list, _ = target.new(unescapes, tokens, valid_phs).parse
+        errors_list.must_be_empty
+      end
+
+      it 'returns the text nodes' do
+        txt_nodes, _, _ = target.new(unescapes, tokens, valid_phs ).parse
+        txt_nodes.must_equal [ast_text.new("hello \n", 0, true)]
+      end
+    end
+  end
+end

data/test/simple_templates/parser_test.rb

@@ -0,0 +1,184 @@
+require_relative "../test_helper"
+
+require 'set'
+
+describe SimpleTemplates::Parser do
+  describe "#parse" do
+    it "parses a simple valid template" do
+      pholder = SimpleTemplates::AST::Placeholder.new('bar', 4, true)
+
+      SimpleTemplates.parse('foo <bar>', ['bar']).must_equal SimpleTemplates::Template.new(
+        [SimpleTemplates::AST::Text.new('foo ', 0, true), pholder],
+        [],
+        []
+      )
+    end
+
+    it "parses a two-byte unicode character" do
+      SimpleTemplates.parse('Ford® Flex').must_equal SimpleTemplates::Template.new(
+        [SimpleTemplates::AST::Text.new('Ford® Flex', 0, true)],
+        [],
+        []
+      )
+    end
+
+    it "marks all nodes as allowed and returns no errors if the allowed_placeholders is nil" do
+      pholder = SimpleTemplates::AST::Placeholder.new('bar', 4, true)
+
+      SimpleTemplates.parse('foo <bar>', nil).must_equal SimpleTemplates::Template.new(
+        [SimpleTemplates::AST::Text.new('foo ', 0, true), pholder],
+        [],
+        []
+      )
+    end
+
+    it "marks all nodes as disallowed and returns errors if the allowed_placeholders is empty" do
+      pholder = SimpleTemplates::AST::Placeholder.new('bar', 4, false)
+
+      SimpleTemplates.parse('foo <bar>', []).must_equal SimpleTemplates::Template.new(
+        [SimpleTemplates::AST::Text.new('foo ', 0, true), pholder],
+        [SimpleTemplates::Parser::Error.new("Invalid Placeholder with contents, 'bar' found starting at position 4.")],
+        []
+      )
+    end
+
+    it "compresses adjacent text nodes after unescaping" do
+      pholder = SimpleTemplates::AST::Placeholder.new('bar', 7, true)
+
+      SimpleTemplates.parse('foo \< <bar>', ['bar']).ast.must_equal [
+        SimpleTemplates::AST::Text.new('foo < ', 0, true), pholder
+      ]
+    end
+
+    it "allows text after placeholders" do
+      pholder  = SimpleTemplates::AST::Placeholder.new('bar', 7, true)
+      pholder2 = SimpleTemplates::AST::Placeholder.new('baz', 13, true)
+
+      SimpleTemplates.parse('foo \< <bar> <baz>', [:bar, :baz]).
+        must_equal SimpleTemplates::Template.new(
+          [
+            SimpleTemplates::AST::Text.new('foo < ', 0, true),
+            pholder,
+            SimpleTemplates::AST::Text.new(' ', 12, true),
+            pholder2
+          ],
+          [],
+          []
+      )
+    end
+
+    it "allows templates starting with placeholders" do
+      pholder = SimpleTemplates::AST::Placeholder.new('foo', 0, true)
+
+      SimpleTemplates.parse('<foo> bar', ['foo']).ast.must_equal [
+        pholder,
+        SimpleTemplates::AST::Text.new(' bar', 5, true)
+      ]
+    end
+
+    it "allows templates with placeholders that contain underscores" do
+      pholder = SimpleTemplates::AST::Placeholder.new('some_name', 0, true)
+
+      SimpleTemplates.parse('<some_name> bar', [:some_name]).ast.must_equal [
+        pholder,
+        SimpleTemplates::AST::Text.new(' bar', 11, true)
+      ]
+    end
+
+    it "parses other placeholder types by changing the delimiter Struct" do
+      pholder = SimpleTemplates::AST::Placeholder.new('foo', 0, true)
+
+      delim = SimpleTemplates::Delimiter.new(/\\\[\\\[/, /\\\]\\\]/, /\[\[/, /\]\]/)
+
+      ast, errors, remaining_tokens =
+      SimpleTemplates::Template.new(
+        *SimpleTemplates::Parser.new(
+          SimpleTemplates::Unescapes.new('[[', ']]'),
+          SimpleTemplates::Lexer.new(delim, '[[foo]] \[\[ bar').tokenize,
+          ['foo']
+        ).parse
+      )
+
+      ast.ast.must_equal [
+        pholder,
+        SimpleTemplates::AST::Text.new(' [[ bar', 7, true)
+      ]
+    end
+
+    it "returns an error when an opening bracket is found without a closing bracket" do
+      SimpleTemplates.parse('foo < <bar>', [:bar]).errors.must_equal [
+        SimpleTemplates::Parser::Error.new("Expected placeholder name token at character position 5, but found a text token instead.")
+      ]
+    end
+
+    it "returns an error when a closing bracket is found before an opening bracket" do
+      SimpleTemplates.parse('foo > <bar>', [:bar]).errors.must_equal [
+        SimpleTemplates::Parser::Error.new('Encountered unexpected token in stream (placeholder end), but expected to see one of the following types: placeholder start, quoted placeholder start, quoted placeholder end, text.')
+      ]
+    end
+
+    it "returns errors about invalid placeholders encountered before a syntactical error" do
+      SimpleTemplates.parse('foo <baz> >', []).errors.must_equal [
+        SimpleTemplates::Parser::Error.new('Encountered unexpected token in stream (placeholder end), but expected to see one of the following types: placeholder start, quoted placeholder start, quoted placeholder end, text.'),
+        SimpleTemplates::Parser::Error.new('Invalid Placeholder with contents, \'baz\' found starting at position 4.')
+      ]
+    end
+
+    it "returns an error when an invalid placeholder name is found" do
+      SimpleTemplates.parse('foo <baz>', [:bar]).errors.must_equal [
+        SimpleTemplates::Parser::Error.
+          new("Invalid Placeholder with contents, 'baz' found starting at position 4.")]
+    end
+
+    it "returns an error when a placeholder with newlines is found" do
+      SimpleTemplates.parse("foo <ba\nr>", ["ba\nr"]).errors.must_equal [
+        SimpleTemplates::Parser::Error.new("Expected placeholder end token at character position 7, but found a text token instead.")]
+    end
+
+    it "returns an error when a placeholder with spaces is found" do
+      SimpleTemplates.parse("foo <ba r>", ['ba r']).errors.must_equal [
+        SimpleTemplates::Parser::Error.
+        new("Expected placeholder end token at character position 7, but found a text token instead.")]
+    end
+
+    it "returns an error when a placeholder with tabs is found" do
+      SimpleTemplates.parse("foo <ba\tr>", ["ba\tr"]).errors.must_equal [
+        SimpleTemplates::Parser::Error.new("Expected placeholder end token at character position 7, but found a text token instead.")]
+    end
+
+    it "returns an error when a placeholder with other characters is found" do
+      SimpleTemplates.parse("foo <ba-r>", ['ba-r']).errors.must_equal [
+        SimpleTemplates::Parser::Error.new("Expected placeholder end token at character position 7, but found a text token instead.")]
+    end
+
+
+    it "returns an multiple errors when there are multiple non-whitelisted placeholders" do
+      SimpleTemplates.parse('foo <baz> <buz>', []).errors.must_equal [
+        SimpleTemplates::Parser::Error.new("Invalid Placeholder with contents, 'baz' found starting at position 4."),
+        SimpleTemplates::Parser::Error.new("Invalid Placeholder with contents, 'buz' found starting at position 10.")
+      ]
+    end
+
+    it "returns an error when multiple opening brackets are found" do
+      SimpleTemplates.parse('foo <<baz>', ['bar']).errors.must_equal [
+        SimpleTemplates::Parser::Error.new("Expected placeholder name token at character position 5, but found a placeholder start token instead.")]
+    end
+
+    it "returns an error when empty placeholder is found" do
+      SimpleTemplates.parse('foo <>', ['bar']).errors.must_equal [
+        SimpleTemplates::Parser::Error.new("Expected placeholder name token at character position 5, but found a placeholder end token instead.")]
+    end
+
+    it "returns an error when a closing tag is expected, but an opening tag is found" do
+      SimpleTemplates.parse('foo <bar<>', ['bar']).errors.must_equal [
+        SimpleTemplates::Parser::Error.new("Expected placeholder end token at character position 8, but found a placeholder start token instead.")
+      ]
+    end
+
+    it "returns an error when a tag is not closed before the end of the input" do
+      SimpleTemplates.parse('foo <bar', ['bar']).errors.must_equal [
+        SimpleTemplates::Parser::Error.new("Expected placeholder end token, but reached end of input.")
+      ]
+    end
+  end
+end

data/test/simple_templates/template_test.rb

@@ -0,0 +1,58 @@
+require_relative "../test_helper"
+
+require 'set'
+
+describe SimpleTemplates::Template do
+  describe "#placeholder_names" do
+    it "should return a set of the placeholder names in the template" do
+      SimpleTemplates.parse('foo <bar> <baz>', [:bar, :baz]).
+        placeholder_names.must_equal ['bar', 'baz'].to_set
+    end
+  end
+
+  describe "#render" do
+    it "processes an empty template" do
+      SimpleTemplates.parse('', []).render(
+        {bar: 'baz'}
+      ).must_equal ''
+    end
+
+    it "interpolates a simple, valid template" do
+      SimpleTemplates.parse('foo <bar>', [:bar]).render(
+        {bar: 'baz'}
+      ).must_equal 'foo baz'
+    end
+
+    it "interpolates a template containing an escaped '>'" do
+      SimpleTemplates.parse("foo <bar> \\>", [:bar]).render(
+        {bar: 'baz'}
+      ).must_equal "foo baz \>"
+    end
+
+    it "interpolates a template containing an escaped '<'" do
+      SimpleTemplates.parse("foo <bar> \\<", [:bar]).render(
+        {bar: 'baz'}
+      ).must_equal "foo baz \<"
+    end
+
+    it "interpolates a template containing an escaped escape character" do
+      SimpleTemplates.parse("foo <bar> \\", [:bar]).render(
+        {bar: 'baz'}
+      ).must_equal "foo baz \\"
+    end
+  end
+
+  describe "#==" do
+    it "compares the ast" do
+      SimpleTemplates::Template.new([:ast_a], [], []).wont_equal SimpleTemplates::Template.new([:ast_b], [], [])
+    end
+
+    it "compares the errors" do
+      SimpleTemplates::Template.new([], [:error_a], []).wont_equal SimpleTemplates::Template.new([], [:error_b], [])
+    end
+
+    it "compares the remaining tokens" do
+      SimpleTemplates::Template.new([], [], [:remaining_tokens_a]).wont_equal SimpleTemplates::Template.new([], [], [:remaining_tokens_b])
+    end
+  end
+end