RubyGems - curlybars - Versions diffs - 0.9.13 - Mend

curlybars 0.9.13

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (77) hide show

checksums.yaml +7 -0
data/lib/curlybars.rb +108 -0
data/lib/curlybars/configuration.rb +41 -0
data/lib/curlybars/dependency_tracker.rb +8 -0
data/lib/curlybars/error/base.rb +18 -0
data/lib/curlybars/error/compile.rb +11 -0
data/lib/curlybars/error/lex.rb +22 -0
data/lib/curlybars/error/parse.rb +41 -0
data/lib/curlybars/error/presenter/not_found.rb +23 -0
data/lib/curlybars/error/render.rb +11 -0
data/lib/curlybars/error/validate.rb +18 -0
data/lib/curlybars/lexer.rb +60 -0
data/lib/curlybars/method_whitelist.rb +69 -0
data/lib/curlybars/node/block_helper_else.rb +108 -0
data/lib/curlybars/node/boolean.rb +24 -0
data/lib/curlybars/node/each_else.rb +69 -0
data/lib/curlybars/node/if_else.rb +33 -0
data/lib/curlybars/node/item.rb +31 -0
data/lib/curlybars/node/literal.rb +28 -0
data/lib/curlybars/node/option.rb +25 -0
data/lib/curlybars/node/output.rb +24 -0
data/lib/curlybars/node/partial.rb +24 -0
data/lib/curlybars/node/path.rb +137 -0
data/lib/curlybars/node/root.rb +29 -0
data/lib/curlybars/node/string.rb +24 -0
data/lib/curlybars/node/template.rb +32 -0
data/lib/curlybars/node/text.rb +24 -0
data/lib/curlybars/node/unless_else.rb +33 -0
data/lib/curlybars/node/variable.rb +34 -0
data/lib/curlybars/node/with_else.rb +54 -0
data/lib/curlybars/parser.rb +183 -0
data/lib/curlybars/position.rb +7 -0
data/lib/curlybars/presenter.rb +288 -0
data/lib/curlybars/processor/tilde.rb +31 -0
data/lib/curlybars/processor/token_factory.rb +9 -0
data/lib/curlybars/railtie.rb +18 -0
data/lib/curlybars/rendering_support.rb +222 -0
data/lib/curlybars/safe_buffer.rb +11 -0
data/lib/curlybars/template_handler.rb +93 -0
data/lib/curlybars/version.rb +3 -0
data/spec/acceptance/application_layout_spec.rb +60 -0
data/spec/acceptance/collection_blocks_spec.rb +28 -0
data/spec/acceptance/global_helper_spec.rb +25 -0
data/spec/curlybars/configuration_spec.rb +57 -0
data/spec/curlybars/error/base_spec.rb +41 -0
data/spec/curlybars/error/compile_spec.rb +19 -0
data/spec/curlybars/error/lex_spec.rb +25 -0
data/spec/curlybars/error/parse_spec.rb +74 -0
data/spec/curlybars/error/render_spec.rb +19 -0
data/spec/curlybars/error/validate_spec.rb +19 -0
data/spec/curlybars/lexer_spec.rb +466 -0
data/spec/curlybars/method_whitelist_spec.rb +168 -0
data/spec/curlybars/processor/tilde_spec.rb +60 -0
data/spec/curlybars/rendering_support_spec.rb +426 -0
data/spec/curlybars/safe_buffer_spec.rb +46 -0
data/spec/curlybars/template_handler_spec.rb +222 -0
data/spec/integration/cache_spec.rb +124 -0
data/spec/integration/comment_spec.rb +60 -0
data/spec/integration/exception_spec.rb +31 -0
data/spec/integration/node/block_helper_else_spec.rb +422 -0
data/spec/integration/node/each_else_spec.rb +204 -0
data/spec/integration/node/each_spec.rb +291 -0
data/spec/integration/node/escape_spec.rb +27 -0
data/spec/integration/node/helper_spec.rb +176 -0
data/spec/integration/node/if_else_spec.rb +129 -0
data/spec/integration/node/if_spec.rb +143 -0
data/spec/integration/node/output_spec.rb +68 -0
data/spec/integration/node/partial_spec.rb +66 -0
data/spec/integration/node/path_spec.rb +286 -0
data/spec/integration/node/root_spec.rb +15 -0
data/spec/integration/node/template_spec.rb +86 -0
data/spec/integration/node/unless_else_spec.rb +129 -0
data/spec/integration/node/unless_spec.rb +130 -0
data/spec/integration/node/with_spec.rb +116 -0
data/spec/integration/processor/tilde_spec.rb +38 -0
data/spec/integration/processors_spec.rb +30 -0
metadata +358 -0

data/spec/acceptance/collection_blocks_spec.rb ADDED

@@ -0,0 +1,28 @@
+describe "Collection blocks", type: :request do
+  before do
+    Curlybars.configure do |config|
+      config.presenters_namespace = 'curlybars_presenters'
+    end
+  end
+  example "Rendering collections" do
+    get '/categories'
+    expect(body).to eq(<<-HTML.strip_heredoc)
+      <html>
+      <head>
+        <title>Dummy app</title>
+      </head>
+      <body>
+      <h1>This are the categories</h1>
+      <p>One</p>
+      <p>Two</p>
+      </body>
+      </html>
+    HTML
+  end
+end

data/spec/acceptance/global_helper_spec.rb ADDED

@@ -0,0 +1,25 @@
+describe "Collection blocks", type: :request do
+  before do
+    Curlybars.configure do |config|
+      config.presenters_namespace = 'curlybars_presenters'
+      config.global_helpers_provider_classes = [GlobalHelpers]
+    end
+  end
+  example "Render a global helper" do
+    get '/welcome'
+    expect(body).to eq(<<-HTML.strip_heredoc)
+      <html>
+      <head>
+        <title>Dummy app</title>
+      </head>
+      <body>
+      Login as: Admin
+      Account: Testing
+      </body>
+      </html>
+    HTML
+  end
+end

data/spec/curlybars/configuration_spec.rb ADDED

@@ -0,0 +1,57 @@
+describe Curlybars::Configuration do
+  after do
+    Curlybars.reset
+  end
+  describe "#presenters_namespace" do
+    it "defaults to an empty string" do
+      presenters_namespace = Curlybars::Configuration.new.presenters_namespace
+      expect(presenters_namespace).to eq('')
+    end
+  end
+  describe "#presenters_namespace=" do
+    it "can set value" do
+      config = Curlybars::Configuration.new
+      config.presenters_namespace = 'foo'
+      expect(config.presenters_namespace).to eq('foo')
+    end
+  end
+  describe "#custom_processors" do
+    it "can set value" do
+      config = Curlybars::Configuration.new
+      config.custom_processors = ['test']
+      expect(config.custom_processors).to eq(['test'])
+    end
+  end
+  describe ".configure" do
+    before do
+      Curlybars.configure do |config|
+        config.presenters_namespace = 'bar'
+      end
+    end
+    it "returns correct value for presenters_namespace" do
+      presenters_namespace = Curlybars.configuration.presenters_namespace
+      expect(presenters_namespace).to eq('bar')
+    end
+  end
+  describe ".reset" do
+    it "resets the configuration to default value" do
+      Curlybars.configure do |config|
+        config.presenters_namespace = 'foobarbaz'
+      end
+      Curlybars.reset
+      presenters_namespace = Curlybars.configuration.presenters_namespace
+      expect(presenters_namespace).to eq('')
+    end
+  end
+end

data/spec/curlybars/error/base_spec.rb ADDED

@@ -0,0 +1,41 @@
+describe Curlybars::Error::Base do
+  let(:position) do
+    OpenStruct.new(line_number: 1, line_offset: 0)
+  end
+  it "creates an exception with the given message" do
+    message = "message"
+    exception = Curlybars::Error::Base.new('id', message, position)
+    expect(exception.message).to be message
+  end
+  it "doesn't change the backtrace for nil position.file_name" do
+    exception = Curlybars::Error::Base.new('id', 'message', position)
+    expect(exception.backtrace).to be nil
+  end
+  it "sets the right backtrace for non-nil position.file_name" do
+    position.file_name = 'template.hbs'
+    exception = Curlybars::Error::Base.new('id', 'message', position)
+    expect(exception.backtrace).not_to be nil
+  end
+  it "sets the position as an instance varaible" do
+    exception = Curlybars::Error::Base.new('id', 'message', position)
+    expect(exception.position).to be position
+  end
+  it "sets the id as an instance varaible" do
+    id = 'id'
+    exception = Curlybars::Error::Base.new(id, 'message', position)
+    expect(exception.id).to be id
+  end
+end

data/spec/curlybars/error/compile_spec.rb ADDED

@@ -0,0 +1,19 @@
+describe Curlybars::Error::Compile do
+  let(:position) do
+    OpenStruct.new(
+      line_number: 2,
+      line_offset: 3,
+      stream_offset: 14,
+      length: 3,
+      file_name: 'template.hbs'
+    )
+  end
+  it "prefixes the id with `compile.`" do
+    id = 'id'
+    exception = Curlybars::Error::Compile.new(id, 'message', position)
+    expect(exception.id).to eq 'compile.%s' % id
+  end
+end

data/spec/curlybars/error/lex_spec.rb ADDED

@@ -0,0 +1,25 @@
+describe Curlybars::Error::Lex do
+  let(:file_name) { 'template.hbs' }
+  let(:source) { "first_line\n0123456789\nthird_line" }
+  let(:exception) do
+    OpenStruct.new(line_number: 2, line_offset: 2)
+  end
+  it "creates an exception with a meaningful message" do
+    message = ".. 01 `2` 3456789 .. is not permitted symbol in this context"
+    lex_exception = Curlybars::Error::Lex.new(source, file_name, exception)
+    expect(lex_exception.message).to eq message
+  end
+  it "figures out a position from the exception" do
+    backtrace = "%s:%d:%d" % [file_name, exception.line_number, exception.line_offset]
+    lex_exception = Curlybars::Error::Lex.new(source, file_name, exception)
+    expect(lex_exception.backtrace).to eq [backtrace]
+  end
+end

data/spec/curlybars/error/parse_spec.rb ADDED

@@ -0,0 +1,74 @@
+describe Curlybars::Error::Parse do
+  let(:source) { "first_line\n0123456789\nthird_line" }
+  describe "with current token not being EOS" do
+    let(:position) do
+      OpenStruct.new(
+        line_number: 2,
+        line_offset: 3,
+        length: 3,
+        file_name: 'template.hbs'
+      )
+    end
+    let(:exception) do
+      current = double(:current, position: position, type: :type)
+      double(:exception, current: current)
+    end
+    it "creates an exception with a meaningful message" do
+      message = ".. 012 `345` 6789 .. is not permitted in this context"
+      lex_exception = Curlybars::Error::Parse.new(source, exception)
+      expect(lex_exception.message).to eq message
+    end
+    it "figures out a position from the exception" do
+      backtrace = "%s:%d:%d" % [position.file_name, position.line_number, position.line_offset]
+      lex_exception = Curlybars::Error::Parse.new(source, exception)
+      expect(lex_exception.backtrace).to eq [backtrace]
+    end
+  end
+  describe "with current token being EOS" do
+    let(:exception) do
+      current = double(:current, position: nil, type: :EOS)
+      double(:exception, current: current)
+    end
+    it "creates an exception with a meaningful message" do
+      message = "A block helper hasn't been closed properly"
+      lex_exception = Curlybars::Error::Parse.new(source, exception)
+      expect(lex_exception.message).to eq message
+    end
+    it "creates an exception whose position contains the right line_number" do
+      lex_exception = Curlybars::Error::Parse.new(source, exception)
+      expect(lex_exception.position.line_number).to be 3
+    end
+    it "creates an exception whose position contains the right line_offset" do
+      lex_exception = Curlybars::Error::Parse.new(source, exception)
+      expect(lex_exception.position.line_offset).to be_zero
+    end
+    it "creates an exception whose position contains the right length" do
+      lex_exception = Curlybars::Error::Parse.new(source, exception)
+      expect(lex_exception.position.length).to be 'third_line'.length
+    end
+    it "creates an exception whose position contains a nil file_name" do
+      lex_exception = Curlybars::Error::Parse.new(source, exception)
+      expect(lex_exception.position.file_name).to be_nil
+    end
+  end
+end

data/spec/curlybars/error/render_spec.rb ADDED

@@ -0,0 +1,19 @@
+describe Curlybars::Error::Render do
+  let(:position) do
+    OpenStruct.new(
+      line_number: 2,
+      line_offset: 3,
+      stream_offset: 14,
+      length: 3,
+      file_name: 'template.hbs'
+    )
+  end
+  it "prefixes the id with `render.`" do
+    id = 'id'
+    exception = Curlybars::Error::Render.new(id, 'message', position)
+    expect(exception.id).to eq 'render.%s' % id
+  end
+end

data/spec/curlybars/error/validate_spec.rb ADDED

@@ -0,0 +1,19 @@
+describe Curlybars::Error::Validate do
+  let(:position) do
+    OpenStruct.new(
+      line_number: 2,
+      line_offset: 3,
+      stream_offset: 14,
+      length: 3,
+      file_name: 'template.hbs'
+    )
+  end
+  it "prefixes the id with `validate.`" do
+    id = 'id'
+    exception = Curlybars::Error::Validate.new(id, 'message', position)
+    expect(exception.id).to eq 'validate.%s' % id
+  end
+end

data/spec/curlybars/lexer_spec.rb ADDED

@@ -0,0 +1,466 @@
+# rubocop:disable Layout/AlignArray
+describe Curlybars::Lexer do
+  describe "{{!-- ... --}}" do
+    it "skips begin of block comment" do
+      expect(lex('{{!--')).to produce []
+    end
+    it "skips begin and end of block comment" do
+      expect(lex('{{!----}}')).to produce []
+    end
+    it "skips a comment block containing curlybar code" do
+      expect(lex('{{!--{{helper}}--}}')).to produce []
+    end
+    it "is resilient to whitespaces" do
+      expect(lex('{{!-- --}}')).to produce []
+    end
+    it "is resilient to newlines" do
+      expect(lex("{{!--\n--}}")).to produce []
+    end
+    it "is skipped when present in plain text" do
+      expect(lex('text {{!----}} text')).to produce [:TEXT, :TEXT]
+    end
+  end
+  describe "{{! ... }}" do
+    it "skips begin of block comment" do
+      expect(lex('{{!')).to produce []
+    end
+    it "skips begin and end of block comment" do
+      expect(lex('{{!}}')).to produce []
+    end
+    it "is resilient to whitespaces" do
+      expect(lex('{{! }}')).to produce []
+    end
+    it "is resilient to newlines" do
+      expect(lex("{{!\n}}")).to produce []
+    end
+    it "is lexed when present in plain text" do
+      expect(lex('text {{!}} text')).to produce [:TEXT, :TEXT]
+    end
+  end
+  describe "{{<integer>}}" do
+    it "is lexed as an integer" do
+      expect(lex("{{7}}")).to produce [:START, :LITERAL, :END]
+    end
+    it "returns the expressed integer" do
+      literal_token = lex("{{7}}").detect { |token| token.type == :LITERAL }
+      expect(literal_token.value).to eq 7
+    end
+  end
+  describe "{{<boolean>}}" do
+    it "{{true}} is lexed as boolean" do
+      expect(lex("{{true}}")).to produce [:START, :LITERAL, :END]
+    end
+    it "{{false}} is lexed as boolean" do
+      expect(lex("{{false}}")).to produce [:START, :LITERAL, :END]
+    end
+    it "returns the expressed boolean" do
+      literal_token = lex("{{true}}").detect { |token| token.type == :LITERAL }
+      expect(literal_token.value).to be_truthy
+    end
+  end
+  describe "{{''}}" do
+    it "is lexed as a literal" do
+      expect(lex("{{''}}")).to produce [:START, :LITERAL, :END]
+    end
+    it "returns the string between quotes" do
+      literal_token = lex("{{'string'}}").detect { |token| token.type == :LITERAL }
+      expect(literal_token.value).to eq '"string"'
+    end
+    it "is resilient to whitespaces" do
+      expect(lex("{{ '' }}")).to produce [:START, :LITERAL, :END]
+    end
+    it "is lexed when present in plain text" do
+      expect(lex("text {{''}} text")).to produce [:TEXT, :START, :LITERAL, :END, :TEXT]
+    end
+  end
+  describe '{{""}}' do
+    it "is lexed as a literal" do
+      expect(lex('{{""}}')).to produce [:START, :LITERAL, :END]
+    end
+    it "returns the string between quotes" do
+      literal_token = lex('{{"string"}}').detect { |token| token.type == :LITERAL }
+      expect(literal_token.value).to eq '"string"'
+    end
+    it "is resilient to whitespaces" do
+      expect(lex('{{ "" }}')).to produce [:START, :LITERAL, :END]
+    end
+    it "is lexed when present in plain text" do
+      expect(lex('text {{""}} text')).to produce [:TEXT, :START, :LITERAL, :END, :TEXT]
+    end
+  end
+  describe "{{@variable}}" do
+    it "is lexed as a varaible" do
+      expect(lex('{{@var}}')).to produce [:START, :VARIABLE, :END]
+    end
+    it "returns the identifier after `@`" do
+      variable_token = lex('{{@var}}').detect { |token| token.type == :VARIABLE }
+      expect(variable_token.value).to eq 'var'
+    end
+    it "returns the identifier after `@` also when using `../`" do
+      variable_token = lex('{{@../var}}').detect { |token| token.type == :VARIABLE }
+      expect(variable_token.value).to eq '../var'
+    end
+    it "is resilient to whitespaces" do
+      expect(lex('{{ @var }}')).to produce [:START, :VARIABLE, :END]
+    end
+    it "is lexed when present in plain text" do
+      expect(lex('text {{@var}} text')).to produce [:TEXT, :START, :VARIABLE, :END, :TEXT]
+    end
+  end
+  describe "{{path context options}}" do
+    it "is lexed with context and options" do
+      expect(lex('{{path context key=value}}')).to produce [:START, :PATH, :PATH, :KEY, :PATH, :END]
+    end
+    it "is lexed without context" do
+      expect(lex('{{path key=value}}')).to produce [:START, :PATH, :KEY, :PATH, :END]
+    end
+    it "is lexed without options" do
+      expect(lex('{{path context}}')).to produce [:START, :PATH, :PATH, :END]
+    end
+    it "is lexed without context and options" do
+      expect(lex('{{path}}')).to produce [:START, :PATH, :END]
+    end
+    it "is resilient to whitespaces" do
+      expect(lex('{{ path }}')).to produce [:START, :PATH, :END]
+    end
+    it "is lexed when present in plain text" do
+      expect(lex('text {{ path }} text')).to produce [:TEXT, :START, :PATH, :END, :TEXT]
+    end
+  end
+  describe "{{#if path}}...{{/if}}" do
+    it "is lexed" do
+      expect(lex('{{#if path}} text {{/if}}')).to produce(
+        [:START, :HASH, :IF, :PATH, :END, :TEXT, :START, :SLASH, :IF, :END]
+      )
+    end
+    it "is resilient to whitespaces" do
+      expect(lex('{{ # if path }} text {{/ if }}')).to produce(
+        [:START, :HASH, :IF, :PATH, :END, :TEXT, :START, :SLASH, :IF, :END]
+      )
+    end
+    it "is lexed when present in plain text" do
+      expect(lex('text {{#if path}} text {{/if}} text')).to produce(
+        [:TEXT, :START, :HASH, :IF, :PATH, :END, :TEXT, :START, :SLASH, :IF, :END, :TEXT]
+      )
+    end
+  end
+  describe "{{#if path}}...{{else}}...{{/if}}" do
+    it "is lexed" do
+      expect(lex('{{#if path}} text {{else}} text {{/if}}')).to produce(
+        [:START, :HASH, :IF, :PATH, :END,
+          :TEXT, :START, :ELSE, :END,
+          :TEXT, :START, :SLASH, :IF, :END]
+      )
+    end
+    it "is resilient to whitespaces" do
+      expect(lex('{{ # if path }} text {{ else }} text {{/ if }}')).to produce(
+        [:START, :HASH, :IF, :PATH, :END,
+          :TEXT, :START, :ELSE, :END,
+          :TEXT, :START, :SLASH, :IF, :END]
+      )
+    end
+    it "is lexed when present in plain text" do
+      expect(lex('text {{#if path}} text {{else}} text {{/if}} text')).to produce(
+        [:TEXT, :START, :HASH, :IF, :PATH, :END,
+          :TEXT, :START, :ELSE, :END,
+          :TEXT, :START, :SLASH, :IF, :END, :TEXT]
+      )
+    end
+  end
+  describe "{{#unless path}}...{{/unless}}" do
+    it "is lexed" do
+      expect(lex('{{#unless path}} text {{/unless}}')).to produce(
+        [:START, :HASH, :UNLESS, :PATH, :END, :TEXT, :START, :SLASH, :UNLESS, :END]
+      )
+    end
+    it "is resilient to whitespaces" do
+      expect(lex('{{ # unless path }} text {{/ unless }}')).to produce(
+        [:START, :HASH, :UNLESS, :PATH, :END, :TEXT, :START, :SLASH, :UNLESS, :END]
+      )
+    end
+    it "is lexed when present in plain text" do
+      expect(lex('text {{#unless path}} text {{/unless}} text')).to produce(
+        [:TEXT, :START, :HASH, :UNLESS, :PATH, :END, :TEXT, :START, :SLASH, :UNLESS, :END, :TEXT]
+      )
+    end
+  end
+  describe "{{#unless path}}...{{else}}...{{/unless}}" do
+    it "is lexed" do
+      expect(lex('{{#unless path}} text {{else}} text {{/unless}}')).to produce(
+        [:START, :HASH, :UNLESS, :PATH, :END,
+          :TEXT, :START, :ELSE, :END,
+          :TEXT, :START, :SLASH, :UNLESS, :END]
+      )
+    end
+    it "is resilient to whitespaces" do
+      expect(lex('{{ # unless path }} text {{ else }} text {{/ unless }}')).to produce(
+        [:START, :HASH, :UNLESS, :PATH, :END,
+          :TEXT, :START, :ELSE, :END,
+          :TEXT, :START, :SLASH, :UNLESS, :END]
+      )
+    end
+    it "is lexed when present in plain text" do
+      expect(lex('text {{#unless path}} text {{else}} text {{/unless}} text')).to produce(
+        [:TEXT, :START, :HASH, :UNLESS, :PATH, :END,
+          :TEXT, :START, :ELSE, :END,
+          :TEXT, :START, :SLASH, :UNLESS, :END, :TEXT]
+      )
+    end
+  end
+  describe "{{#each path}}...{{/each}}" do
+    it "is lexed" do
+      expect(lex('{{#each path}} text {{/each}}')).to produce(
+        [:START, :HASH, :EACH, :PATH, :END, :TEXT, :START, :SLASH, :EACH, :END]
+      )
+    end
+    it "is resilient to whitespaces" do
+      expect(lex('{{ # each path }} text {{/ each }}')).to produce(
+        [:START, :HASH, :EACH, :PATH, :END, :TEXT, :START, :SLASH, :EACH, :END]
+      )
+    end
+    it "is lexed when present in plain text" do
+      expect(lex('text {{#each path}} text {{/each}} text')).to produce(
+        [:TEXT, :START, :HASH, :EACH, :PATH, :END, :TEXT, :START, :SLASH, :EACH, :END, :TEXT]
+      )
+    end
+  end
+  describe "{{#each path}}...{{else}}...{{/each}}" do
+    it "is lexed" do
+      expect(lex('{{#each path}} text {{else}} text {{/each}}')).to produce(
+        [:START, :HASH, :EACH, :PATH, :END,
+          :TEXT, :START, :ELSE, :END,
+          :TEXT, :START, :SLASH, :EACH, :END]
+      )
+    end
+    it "is resilient to whitespaces" do
+      expect(lex('{{ # each path }} text {{ else }} text {{/ each }}')).to produce(
+        [:START, :HASH, :EACH, :PATH, :END,
+          :TEXT, :START, :ELSE, :END,
+          :TEXT, :START, :SLASH, :EACH, :END]
+      )
+    end
+    it "is lexed when present in plain text" do
+      expect(lex('text {{#each path}} text {{else}} text {{/each}} text')).to produce(
+        [:TEXT, :START, :HASH, :EACH, :PATH, :END,
+          :TEXT, :START, :ELSE, :END,
+          :TEXT, :START, :SLASH, :EACH, :END, :TEXT]
+      )
+    end
+  end
+  describe "{{#with path}}...{{/with}}" do
+    it "is lexed" do
+      expect(lex('{{#with path}} text {{/with}}')).to produce(
+        [:START, :HASH, :WITH, :PATH, :END, :TEXT, :START, :SLASH, :WITH, :END]
+      )
+    end
+    it "is resilient to whitespaces" do
+      expect(lex('{{ # with path }} text {{/ with }}')).to produce(
+        [:START, :HASH, :WITH, :PATH, :END, :TEXT, :START, :SLASH, :WITH, :END]
+      )
+    end
+    it "is lexed when present in plain text" do
+      expect(lex('text {{#with path}} text {{/with}} text')).to produce(
+        [:TEXT, :START, :HASH, :WITH, :PATH, :END, :TEXT, :START, :SLASH, :WITH, :END, :TEXT]
+      )
+    end
+  end
+  describe "{{#path path options}}...{{/path}}" do
+    it "is lexed with context and options" do
+      expect(lex('{{#path context key=value}} text {{/path}}')).to produce(
+        [:START, :HASH, :PATH, :PATH, :KEY, :PATH, :END, :TEXT, :START, :SLASH, :PATH, :END]
+      )
+    end
+    it "is lexed without options" do
+      expect(lex('{{#path context}} text {{/path}}')).to produce(
+        [:START, :HASH, :PATH, :PATH, :END, :TEXT, :START, :SLASH, :PATH, :END]
+      )
+    end
+    it "is resilient to whitespaces" do
+      expect(lex('{{ # path context key = value}} text {{/ path }}')).to produce(
+        [:START, :HASH, :PATH, :PATH, :KEY, :PATH, :END, :TEXT, :START, :SLASH, :PATH, :END]
+      )
+    end
+    it "is lexed when present in plain text" do
+      expect(lex('text {{#path context key=value}} text {{/path}} text')).to produce(
+        [:TEXT, :START, :HASH, :PATH, :PATH, :KEY, :PATH, :END, :TEXT, :START, :SLASH, :PATH, :END, :TEXT]
+      )
+    end
+  end
+  describe "{{>path}}" do
+    it "is lexed" do
+      expect(lex('{{>path}}')).to produce [:START, :GT, :PATH, :END]
+    end
+    it "is resilient to whitespaces" do
+      expect(lex('{{ > path }}')).to produce [:START, :GT, :PATH, :END]
+    end
+    it "is lexed when present in plain text" do
+      expect(lex('text {{>path}} text')).to produce [:TEXT, :START, :GT, :PATH, :END, :TEXT]
+    end
+  end
+  describe "when a leading backslash is present" do
+    it "`{` is lexed as plain text" do
+      expect(lex('\{')).to produce [:TEXT]
+    end
+    it "returns the original text" do
+      text_token = lex('\{').detect { |token| token.type == :TEXT }
+      expect(text_token.value).to eq '{'
+    end
+    it "is lexed when present in plain text" do
+      expect(lex('text \{ text')).to produce [:TEXT, :TEXT, :TEXT]
+    end
+  end
+  describe "can lex paths with or without leading `../`s" do
+    it "`path` is lexed as a path" do
+      expect(lex('{{path}}')).to produce [:START, :PATH, :END]
+    end
+    it "`../path` is lexed as a path" do
+      expect(lex('{{../path}}')).to produce [:START, :PATH, :END]
+    end
+    it "`../../path` is lexed as a path" do
+      expect(lex('{{../../path}}')).to produce [:START, :PATH, :END]
+    end
+    it "`path/../` raises an error" do
+      expect do
+        lex('{{path/../}}')
+      end.to raise_error(RLTK::LexingError)
+    end
+  end
+  describe "can lex paths with dashes" do
+    it "`surrounded by other valid chars" do
+      expect(lex('{{a-path}}')).to produce [:START, :PATH, :END]
+    end
+    it "at the beginning" do
+      expect(lex('{{-path}}')).to produce [:START, :PATH, :END]
+    end
+    it "at the end" do
+      expect(lex('{{path-}}')).to produce [:START, :PATH, :END]
+    end
+  end
+  describe "can lex paths with identifiers that are numebrs" do
+    it "`surrounded by other valid chars" do
+      expect(lex('{{path.123}}')).to produce [:START, :PATH, :END]
+    end
+  end
+  describe "outside a curlybar context" do
+    it "`--}}` is lexed as plain text" do
+      expect(lex('--}}')).to produce [:TEXT]
+    end
+    it "`}}` is lexed as plain text" do
+      expect(lex('}}')).to produce [:TEXT]
+    end
+    it "`#` is lexed as plain text" do
+      expect(lex('#')).to produce [:TEXT]
+    end
+    it "`/` is lexed as plain text" do
+      expect(lex('/')).to produce [:TEXT]
+    end
+    it "`>` is lexed as plain text" do
+      expect(lex('>')).to produce [:TEXT]
+    end
+    it "`if` is lexed as plain text" do
+      expect(lex('if')).to produce [:TEXT]
+    end
+    it "`unless` is lexed as plain text" do
+      expect(lex('unless')).to produce [:TEXT]
+    end
+    it "`each` is lexed as plain text" do
+      expect(lex('each')).to produce [:TEXT]
+    end
+    it "`with` is lexed as plain text" do
+      expect(lex('with')).to produce [:TEXT]
+    end
+    it "`else` is lexed as plain text" do
+      expect(lex('else')).to produce [:TEXT]
+    end
+    it "a path is lexed as plain text" do
+      expect(lex('this.is.a.path')).to produce [:TEXT]
+    end
+    it "an option is lexed as plain text" do
+      expect(lex('key=value')).to produce [:TEXT]
+    end
+  end
+end