RubyGems - curlybars - Versions diffs - 0.9.13 - Mend

curlybars 0.9.13

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