curlybars 1.8.0 → 1.9.0

data/spec/integration/cache_spec.rb

@@ -1,126 +0,0 @@
-describe "caching" do
-  let(:dummy_cache) do
-    Class.new do
-      attr_reader :reads, :hits
-
-      def initialize
-        @store = {}
-        @reads = 0
-        @hits = 0
-      end
-
-      def fetch(key)
-        @reads += 1
-        if @store.key?(key)
-          @hits += 1
-          @store[key]
-        else
-          value = yield
-          @store[key] = value
-          value
-        end
-      end
-    end
-  end
-
-  let(:global_helpers_providers) { [] }
-  let(:presenter) { IntegrationTest::Presenter.new(double("view_context")) }
-  let(:cache) { dummy_cache.new }
-
-  before do
-    Curlybars.configure do |config|
-      config.cache = cache.method(:fetch)
-    end
-  end
-
-  after do
-    Curlybars.reset
-  end
-
-  describe "{{#each}}" do
-    it "invokes cache if presenter responds to #cache_key" do
-      template = Curlybars.compile(<<-HBS)
-        {{#each array_of_users}}{{/each}}
-      HBS
-
-      eval(template)
-
-      expect(cache.reads).to eq(1)
-      expect(cache.hits).to eq(0)
-    end
-
-    it "reuses cached values" do
-      template = Curlybars.compile(<<-HBS)
-        {{#each array_of_users}}
-          a
-        {{/each}}
-
-        {{#each array_of_users}}
-          a
-        {{/each}}
-      HBS
-
-      eval(template)
-
-      expect(cache.reads).to eq(2)
-      expect(cache.hits).to eq(1)
-    end
-
-    it "generates unique cache keys per template" do
-      template = Curlybars.compile(<<-HBS)
-        {{#each array_of_users}}
-          a
-        {{/each}}
-
-        {{#each array_of_users}}
-          b
-        {{/each}}
-      HBS
-
-      eval(template)
-
-      expect(cache.reads).to eq(2)
-      expect(cache.hits).to eq(0)
-    end
-
-    it "produces correct output from cached presenters" do
-      template = Curlybars.compile(<<-HBS)
-        {{#each array_of_users}}
-          - {{first_name}}
-        {{/each}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        - Libo
-      HTML
-    end
-
-    it "works for empty templates" do
-      template = Curlybars.compile(<<-HBS)
-        before
-        {{#each array_of_users}}{{/each}}
-        {{#each array_of_users}}{{/each}}
-        after
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        before
-        after
-      HTML
-    end
-
-    it "leaves variables and contexts in correct state after a cache hit" do
-      template = Curlybars.compile(<<-HBS)
-        {{#each array_of_users}}a{{/each}}
-        {{#each array_of_users}}a{{/each}}
-        {{context}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        a
-        a
-        root_context
-      HTML
-    end
-  end
-end

data/spec/integration/comment_spec.rb

@@ -1,60 +0,0 @@
-describe "{{!-- --}} and {{! }}" do
-  let(:post) { double("post") }
-  let(:presenter) { IntegrationTest::Presenter.new(double("view_context"), post: post) }
-  let(:global_helpers_providers) { [] }
-
-  it "ignores one line comment" do
-    template = Curlybars.compile(<<-HBS)
-      before{{! This is a comment }}after
-    HBS
-
-    expect(eval(template)).to resemble(<<-HTML)
-      before after
-    HTML
-  end
-
-  it "ignores multi line comment" do
-    template = Curlybars.compile(<<-HBS)
-      before
-      {{! 2 lines
-        lines }}
-      after
-    HBS
-
-    expect(eval(template)).to resemble(<<-HTML)
-      before after
-    HTML
-  end
-
-  it "ignores multi lines with curly inside comment" do
-    template = Curlybars.compile(<<-HBS)
-      before
-      {{!
-        And another one
-        in
-        3 lines
-        }
-      }}
-      after
-    HBS
-
-    expect(eval(template)).to resemble(<<-HTML)
-      before after
-    HTML
-  end
-
-  it "ignores multi line comment with {{!-- --}}" do
-    template = Curlybars.compile(<<-HBS)
-      before
-      {{!--
-        And this is the {{ test }} other style
-        }}
-      --}}
-      after
-    HBS
-
-    expect(eval(template)).to resemble(<<-HTML)
-      before after
-    HTML
-  end
-end

data/spec/integration/exception_spec.rb

@@ -1,31 +0,0 @@
-describe "Exception reporting" do
-  let(:post) { double("post") }
-  let(:presenter) { IntegrationTest::Presenter.new(double("view_context"), post: post) }
-  let(:global_helpers_providers) { [] }
-
-  it "Throw Curlybars::Error::Lex in case of a lex error occurs" do
-    expect do
-      Curlybars.compile('{{{')
-    end.to raise_error(Curlybars::Error::Lex)
-  end
-
-  it "Throw Curlybars::Error::Parse in case of a lex error occurs" do
-    expect do
-      Curlybars.compile('{{#with "notallowed"}} ... {{/with}}')
-    end.to raise_error(Curlybars::Error::Parse)
-  end
-
-  it "Throw Curlybars::Error::Compile in case of a lex error occurs" do
-    expect do
-      Curlybars.compile('{{#form new_comment_form}} ... {{/different_closing}}')
-    end.to raise_error(Curlybars::Error::Compile)
-  end
-
-  it "Throw Curlybars::Error::Render in case of a rendering error occurs" do
-    compiled = Curlybars.compile('{{#form not_allowed_path}} ... {{/form}}')
-
-    expect do
-      eval(compiled)
-    end.to raise_error(Curlybars::Error::Render)
-  end
-end

data/spec/integration/node/block_helper_else_spec.rb

@@ -1,420 +0,0 @@
-describe "{{#helper arg1 arg2 ... key=value ...}}...<{{else}}>...{{/helper}}" do
-  let(:global_helpers_providers) { [IntegrationTest::GlobalHelperProvider.new] }
-
-  describe "#compile" do
-    let(:post) { double("post") }
-    let(:presenter) { IntegrationTest::Presenter.new(double("view_context"), post: post) }
-
-    it "can be a global helper" do
-      template = Curlybars.compile(<<-HBS)
-        {{global_helper 'argument' option='value'}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        argument - option:value
-      HTML
-    end
-
-    it "accepts no arguments at all" do
-      template = Curlybars.compile(<<-HBS)
-        {{#just_yield}}
-          template
-        {{/just_yield}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        template
-      HTML
-    end
-
-    it "passes two arguments" do
-      template = Curlybars.compile(<<-HBS)
-        {{#print_args_and_options 'first' 'second'}}
-        {{/print_args_and_options}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        first, second, key=
-      HTML
-    end
-
-    it "passes two arguments and options" do
-      template = Curlybars.compile(<<-HBS)
-        {{#print_args_and_options 'first' 'second' key='value'}}
-        {{/print_args_and_options}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        first, second, key=value
-      HTML
-    end
-
-    it "renders the inverse block" do
-      template = Curlybars.compile(<<-HBS)
-        {{#render_inverse}}
-          fn
-        {{else}}
-          inverse
-        {{/render_inverse}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        inverse
-      HTML
-    end
-
-    it "renders the fn block" do
-      template = Curlybars.compile(<<-HBS)
-        {{#render_fn}}
-          fn
-        {{else}}
-          inverse
-        {{/render_fn}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        fn
-      HTML
-    end
-
-    it "block helpers can access the current context" do
-      template = Curlybars.compile(<<-HBS)
-        {{#print_current_context}} {{/print_current_context}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        root_context
-      HTML
-    end
-
-    it "renders a block helper without options" do
-      template = Curlybars.compile(<<-HBS)
-        {{#beautify}}
-          template
-        {{/beautify}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        bold template italic
-      HTML
-    end
-
-    it "renders a block helper with custom variables" do
-      template = Curlybars.compile(<<-HBS)
-        {{#yield_custom_variable}}
-          {{!--
-            `@custom1` and `@custom2` are variables yielded
-            by the block helper implementation.
-          --}}
-
-          {{@custom1}} {{@custom2}}
-        {{/yield_custom_variable}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        custom variable1
-        custom variable2
-      HTML
-    end
-
-    it "renders a block helper with custom variables that can be used in conditionals" do
-      template = Curlybars.compile(<<-HBS)
-        {{#yield_custom_variable}}
-          {{!--
-            `@cond` is a boolean variable yielded
-            by the block helper implementation.
-          --}}
-
-          {{#if @cond}}
-            Cond is true
-          {{/if}}
-        {{/yield_custom_variable}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        Cond is true
-      HTML
-    end
-
-    it "renders a block helper with custom variables that can be seen by nested contexts" do
-      template = Curlybars.compile(<<-HBS)
-        {{#yield_custom_variable}}
-          {{!--
-            `@custom1` and `@custom2` are variables yielded
-            by the block helper implementation.
-          --}}
-          {{#with this}}
-            {{@custom1}} {{@custom2}}
-          {{/with}}
-        {{/yield_custom_variable}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        custom variable1
-        custom variable2
-      HTML
-    end
-
-    it "renders a block helper with options and presenter" do
-      template = Curlybars.compile(<<-HBS)
-        {{#form new_comment_form class="red" foo="bar"}}
-          {{new_comment_form.button_label}}
-        {{/form}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        beauty class:red foo:bar submit
-      HTML
-    end
-
-    it "allow empty template" do
-      template = Curlybars.compile(<<-HBS)
-        {{#form new_comment_form class="red" foo="bar"}}{{/form}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        beauty class:red foo:bar
-      HTML
-    end
-
-    it "renders correctly a return type of integer" do
-      template = Curlybars.compile(<<-HBS)
-        {{#integer new_comment_form}} text {{/integer}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        0
-      HTML
-    end
-
-    it "renders correctly a return type of boolean" do
-      template = Curlybars.compile(<<-HBS)
-        {{#boolean new_comment_form}} text {{/boolean}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        true
-      HTML
-    end
-
-    it "accepts a nil context" do
-      template = Curlybars.compile(<<-HBS)
-        {{#this_method_yields return_nil}}
-        {{/this_method_yields}}
-      HBS
-
-      expect(eval(template)).to resemble("")
-    end
-
-    it "yield tolerated nil as pushed context" do
-      template = Curlybars.compile(<<-HBS)
-        {{#this_method_yields return_nil}}
-          text
-        {{/this_method_yields}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        text
-      HTML
-    end
-
-    it "raises an exception if the context is not a presenter-like object" do
-      template = Curlybars.compile(<<-HBS)
-        {{#boolean post}} text {{/boolean}}
-      HBS
-
-      expect do
-        eval(template)
-      end.to raise_error(Curlybars::Error::Render)
-    end
-  end
-
-  describe "#validate" do
-    it "without errors when global helper" do
-      allow(Curlybars.configuration).to receive(:global_helpers_provider_classes).and_return([IntegrationTest::GlobalHelperProvider])
-
-      dependency_tree = {}
-
-      source = <<-HBS
-        {{global_helper}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).to be_empty
-    end
-
-    it "without errors when invoking a leaf" do
-      dependency_tree = { name: nil }
-
-      source = <<-HBS
-        {{name}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).to be_empty
-    end
-
-    it "without errors if argument is a leaf" do
-      dependency_tree = { block_helper: :helper, argument: nil }
-
-      source = <<-HBS
-        {{#block_helper argument}} ... {{/block_helper}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).to be_empty
-    end
-
-    it "without errors if argument is a literal" do
-      dependency_tree = { block_helper: :helper }
-
-      source = <<-HBS
-        {{#block_helper 'argument'}} ... {{/block_helper}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).to be_empty
-    end
-
-    it "without errors if argument is a variable" do
-      dependency_tree = { block_helper: :helper }
-
-      source = <<-HBS
-        {{#block_helper @var}} ... {{/block_helper}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).to be_empty
-    end
-
-    it "without errors if option is a leaf" do
-      dependency_tree = { block_helper: :helper, argument: nil }
-
-      source = <<-HBS
-        {{#block_helper option=argument}} ... {{/block_helper}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).to be_empty
-    end
-
-    it "without errors if option is a literal" do
-      dependency_tree = { block_helper: :helper }
-
-      source = <<-HBS
-        {{#block_helper option='argument'}} ... {{/block_helper}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).to be_empty
-    end
-
-    it "without errors if option is a variable" do
-      dependency_tree = { block_helper: :helper }
-
-      source = <<-HBS
-        {{#block_helper option=@var}} ... {{/block_helper}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).to be_empty
-    end
-
-    it "without errors in block_helper" do
-      dependency_tree = { block_helper: :helper, context: nil }
-
-      source = <<-HBS
-        {{#block_helper context}} ... {{/block_helper}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).to be_empty
-    end
-
-    it "with errors when invoking a leaf with arguments" do
-      dependency_tree = { name: nil }
-
-      source = <<-HBS
-        {{name 'argument'}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).not_to be_empty
-    end
-
-    it "with errors when invoking a leaf with options" do
-      dependency_tree = { name: nil }
-
-      source = <<-HBS
-        {{name option='value'}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).not_to be_empty
-    end
-
-    it "with errors if argument is not a value" do
-      dependency_tree = { block_helper: :helper, not_a_value: {} }
-
-      source = <<-HBS
-        {{#block_helper not_a_value}} ... {{/block_helper}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).not_to be_empty
-    end
-
-    it "with errors if option is not a value" do
-      dependency_tree = { block_helper: :helper, not_a_value: {} }
-
-      source = <<-HBS
-        {{#block_helper option=not_a_value}} ... {{/block_helper}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).not_to be_empty
-    end
-
-    it "with errors in fn block" do
-      dependency_tree = { context: {}, block_helper: :helper }
-
-      source = <<-HBS
-        {{#block_helper context}}
-          {{invalid}}
-        {{/block_helper}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).not_to be_empty
-    end
-
-    it "with errors in inverse block" do
-      dependency_tree = { context: {}, block_helper: :helper }
-
-      source = <<-HBS
-        {{#block_helper context}}
-        {{else}}
-          {{invalid}}
-        {{/block_helper}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).not_to be_empty
-    end
-  end
-end