curlybars 1.8.0 → 1.10.0

data/spec/integration/node/helper_spec.rb

@@ -1,186 +0,0 @@
-describe "{{helper context key=value}}" do
-  let(:global_helpers_providers) { [] }
-
-  describe "#compile" do
-    let(:post) { double("post") }
-    let(:presenter) { IntegrationTest::Presenter.new(double("view_context"), post: post) }
-
-    it "passes two arguments" do
-      template = Curlybars.compile(<<-HBS)
-        {{print_args_and_options 'first' 'second'}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        first, second, key=
-      HTML
-    end
-
-    it "calls a helper without arguments in an if statement" do
-      template = Curlybars.compile(<<-HBS)
-        {{#if print_args_and_options}}
-          {{print_args_and_options 'first' 'second'}}
-        {{/if}}
-      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'}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        first, second, key=value
-      HTML
-    end
-
-    it "renders a helper with expression and options" do
-      template = Curlybars.compile(<<-HBS)
-        {{date user.created_at class='metadata'}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        <time datetime="2015-02-03T13:25:06Z" class="metadata">
-          February 3, 2015 13:25
-        </time>
-      HTML
-    end
-
-    it "renders a helper with only expression" do
-      template = Curlybars.compile(<<-HBS)
-        <script src="{{asset "jquery_plugin.js"}}"></script>
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        <script src="http://cdn.example.com/jquery_plugin.js"></script>
-      HTML
-    end
-
-    it "renders a helper with only options" do
-      template = Curlybars.compile(<<-HBS)
-        {{#with new_comment_form}}
-          {{input title class="form-control"}}
-        {{/with}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        <input name="community_post[title]"
-          id="community_post_title"
-          type="text"
-          class="form-control"
-          value="some value persisted in the DB">
-      HTML
-    end
-
-    it "renders correctly a return type of integer" do
-      template = Curlybars.compile(<<-HBS)
-        {{integer 'ignored'}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        0
-      HTML
-    end
-
-    it "renders correctly a return type of boolean" do
-      template = Curlybars.compile(<<-HBS)
-        {{boolean 'ignored'}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        true
-      HTML
-    end
-
-    it "handles correctly a method that invokes `yield`, returning empty string" do
-      template = Curlybars.compile(<<-HBS)
-        {{this_method_yields}}
-      HBS
-
-      expect(eval(template)).to resemble("")
-    end
-
-    it "doesn't render if the path returns a presenter" do
-      template = Curlybars.compile(<<-HBS)
-        {{user}}
-      HBS
-
-      expect(eval(template)).to resemble("")
-    end
-
-    it "doesn't render if the path returns a collection of presenters" do
-      template = Curlybars.compile(<<-HBS)
-        {{array_of_users}}
-      HBS
-
-      expect(eval(template)).to resemble("")
-    end
-  end
-
-  describe "#validate" do
-    it "with errors" do
-      dependency_tree = {}
-
-      source = <<-HBS
-        {{helper}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).not_to be_empty
-    end
-
-    it "raises when using a partial as an helper" do
-      dependency_tree = { partial: :partial }
-
-      source = <<-HBS
-        {{partial}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).not_to be_empty
-    end
-
-    it "without errors" do
-      dependency_tree = { helper: :helper }
-
-      source = <<-HBS
-        {{helper}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).to be_empty
-    end
-
-    it "validates {{helper.invoked_on_nil}} with errors" do
-      dependency_tree = { helper: :helper }
-
-      source = <<-HBS
-        {{helper.invoked_on_nil}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).not_to be_empty
-    end
-
-    describe "with context" do
-      it "without errors in block_helper" do
-        dependency_tree = { helper: :helper, context: nil }
-
-        source = <<-HBS
-          {{helper context}}
-        HBS
-
-        errors = Curlybars.validate(dependency_tree, source)
-
-        expect(errors).to be_empty
-      end
-    end
-  end
-end

data/spec/integration/node/if_else_spec.rb

@@ -1,170 +0,0 @@
-describe "{{#if}}...{{else}}...{{/if}}" do
-  let(:global_helpers_providers) { [] }
-
-  describe "#compile" do
-    let(:post) { double("post") }
-    let(:presenter) { IntegrationTest::Presenter.new(double("view_context"), post: post) }
-
-    it "renders the if_template" do
-      allow(IntegrationTest::Presenter).to receive(:allows_method?).with(:return_true).and_return(true)
-      allow(presenter).to receive(:return_true).and_return(true)
-
-      template = Curlybars.compile(<<-HBS)
-        {{#if return_true}}
-          if_template
-        {{else}}
-          else_template
-        {{/if}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        if_template
-      HTML
-    end
-
-    it "renders the else_template" do
-      allow(IntegrationTest::Presenter).to receive(:allows_method?).with(:return_false).and_return(true)
-      allow(presenter).to receive(:return_false).and_return(false)
-
-      template = Curlybars.compile(<<-HBS)
-        {{#if return_false}}
-          if_template
-        {{else}}
-          else_template
-        {{/if}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        else_template
-      HTML
-    end
-
-    it "allows empty if_template" do
-      allow(IntegrationTest::Presenter).to receive(:allows_method?).with(:valid).and_return(true)
-      allow(presenter).to receive(:valid).and_return(false)
-
-      template = Curlybars.compile(<<-HBS)
-      {{#if valid}}{{else}}
-        else_template
-      {{/if}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        else_template
-      HTML
-    end
-
-    it "allows empty else_template" do
-      allow(IntegrationTest::Presenter).to receive(:allows_method?).with(:valid).and_return(true)
-      allow(presenter).to receive(:valid).and_return(true)
-
-      template = Curlybars.compile(<<-HBS)
-        {{#if valid}}
-          if_template
-        {{else}}{{/if}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        if_template
-      HTML
-    end
-
-    it "allows empty if_template and else_template" do
-      allow(IntegrationTest::Presenter).to receive(:allows_method?).with(:valid).and_return(true)
-      allow(presenter).to receive(:valid).and_return(true)
-
-      template = Curlybars.compile(<<-HBS)
-        {{#if valid}}{{else}}{{/if}}
-      HBS
-
-      expect(eval(template)).to resemble("")
-    end
-  end
-
-  describe "#validate" do
-    it "validates without errors the literal condition" do
-      dependency_tree = {}
-
-      source = <<-HBS
-        {{#if 42}}{{else}}{{/if}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).to be_empty
-    end
-
-    it "validates with errors the condition" do
-      dependency_tree = {}
-
-      source = <<-HBS
-        {{#if condition}}{{else}}{{/if}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).not_to be_empty
-    end
-
-    it "validates with errors the nested if_template" do
-      dependency_tree = { condition: nil }
-
-      source = <<-HBS
-        {{#if condition}}
-          {{unallowed_method}}
-        {{else}}
-        {{/if}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).not_to be_empty
-    end
-
-    it "validates with errors the nested else_template" do
-      dependency_tree = { condition: nil }
-
-      source = <<-HBS
-        {{#if condition}}
-        {{else}}
-          {{unallowed_method}}
-        {{/if}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).not_to be_empty
-    end
-
-    it "validates errors the nested else_template when out of context" do
-      dependency_tree = { condition: nil }
-
-      source = <<-HBS
-        {{#if ../condition}}
-        {{else}}
-          {{unallowed_ELSE_method}}
-        {{/if}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors.count).to eq(2)
-    end
-
-    it "gives all possible errors found in validation" do
-      dependency_tree = { condition: nil }
-
-      source = <<-HBS
-        {{#if ../condition}}
-          {{unallowed_IF_method}}
-        {{else}}
-          {{unallowed_ELSE_method}}
-        {{/if}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors.count).to eq(3)
-    end
-  end
-end

data/spec/integration/node/if_spec.rb

@@ -1,153 +0,0 @@
-describe "{{#if}}...{{/if}}" do
-  let(:global_helpers_providers) { [] }
-
-  describe "#compile" do
-    let(:post) { double("post") }
-    let(:presenter) { IntegrationTest::Presenter.new(double("view_context"), post: post) }
-
-    it "returns positive branch when condition is true" do
-      allow(presenter).to receive(:allows_method?).with(:valid).and_return(true)
-      allow(presenter).to receive(:valid).and_return(true)
-
-      template = Curlybars.compile(<<-HBS)
-        {{#if valid}}
-          if_template
-        {{/if}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        if_template
-      HTML
-    end
-
-    it "doesn't return positive branch when condition is false" do
-      allow(presenter).to receive(:allows_method?).with(:valid).and_return(true)
-      allow(presenter).to receive(:valid).and_return(false)
-
-      template = Curlybars.compile(<<-HBS)
-        {{#if valid}}
-          if_template
-        {{/if}}
-      HBS
-
-      expect(eval(template)).to resemble("")
-    end
-
-    it "doesn't return positive branch when condition is empty array" do
-      allow(presenter).to receive(:allows_method?).with(:collection).and_return(true)
-      allow(presenter).to receive(:collection).and_return([])
-
-      template = Curlybars.compile(<<-HBS)
-        {{#if collection}}
-          if_template
-        {{/if}}
-      HBS
-
-      expect(eval(template)).to resemble("")
-    end
-
-    it "works with nested `if blocks` (double positive)" do
-      allow(presenter).to receive(:allows_method?).with(:valid).and_return(true)
-      allow(presenter).to receive(:allows_method?).with(:visible).and_return(true)
-      allow(presenter).to receive(:valid).and_return(true)
-      allow(presenter).to receive(:visible).and_return(true)
-
-      template = Curlybars.compile(<<-HBS)
-        {{#if valid}}
-          {{#if visible}}
-            inner_if_template
-          {{/if}}
-          outer_if_template
-        {{/if}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        inner_if_template
-        outer_if_template
-      HTML
-    end
-
-    it "works with nested `if blocks` (positive and negative)" do
-      allow(presenter).to receive(:allows_method?).with(:valid).and_return(true)
-      allow(presenter).to receive(:allows_method?).with(:visible).and_return(true)
-      allow(presenter).to receive(:valid).and_return(true)
-      allow(presenter).to receive(:visible).and_return(false)
-
-      template = Curlybars.compile(<<-HBS)
-        {{#if valid}}
-          {{#if visible}}
-            inner_if_template
-          {{/if}}
-          outer_if_template
-        {{/if}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        outer_if_template
-      HTML
-    end
-
-    it "allows empty if_template" do
-      allow(presenter).to receive(:allows_method?).with(:valid).and_return(true)
-      allow(presenter).to receive(:valid).and_return(true)
-
-      template = Curlybars.compile(<<-HBS)
-        {{#if valid}}{{/if}}
-      HBS
-
-      expect(eval(template)).to resemble("")
-    end
-
-    it "allows usage of variables in condition" do
-      template = Curlybars.compile(<<-HBS)
-        {{#each two_elements}}
-          {{#if @first}}I am the first!{{/if}}
-        {{/each}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        I am the first!
-      HTML
-    end
-  end
-
-  describe "#validate" do
-    it "validates with errors the condition" do
-      dependency_tree = {}
-
-      source = <<-HBS
-        {{#if condition}}{{/if}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).not_to be_empty
-    end
-
-    it "validates with errors the nested template" do
-      dependency_tree = { condition: nil }
-
-      source = <<-HBS
-        {{#if condition}}
-          {{unallowed_method}}
-        {{/if}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).not_to be_empty
-    end
-
-    it "validates without errors the helper as condition" do
-      dependency_tree = { helper: :helper }
-
-      source = <<-HBS
-        {{#if helper}}{{/if}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).to be_empty
-    end
-  end
-end

data/spec/integration/node/output_spec.rb

@@ -1,66 +0,0 @@
-describe '{{value}}' do
-  let(:global_helpers_providers) { [] }
-
-  describe "#compile" do
-    let(:post) { double("post") }
-    let(:presenter) { IntegrationTest::Presenter.new(double("view_context"), post: post) }
-
-    it "prints out a string" do
-      template = Curlybars.compile(<<-HBS)
-        {{'hello world!'}}
-      HBS
-
-      expect(eval(template)).to resemble('hello world!')
-    end
-
-    it "prints out a boolean" do
-      template = Curlybars.compile(<<-HBS)
-        {{true}}
-      HBS
-
-      expect(eval(template)).to resemble('true')
-    end
-
-    it "prints out an integer" do
-      template = Curlybars.compile(<<-HBS)
-        {{7}}
-      HBS
-
-      expect(eval(template)).to resemble('7')
-    end
-
-    it "prints out a variable" do
-      template = Curlybars.compile(<<-HBS)
-        {{#each two_elements}}
-          Index: {{@index}}
-          First: {{@first}}
-          Last: {{@last}}
-        {{/each}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        Index: 0
-        First: true
-        Last: false
-
-        Index: 1
-        First: false
-        Last: true
-      HTML
-    end
-  end
-
-  describe "#validate" do
-    it "validates the path with errors" do
-      dependency_tree = {}
-
-      source = <<-HBS
-        {{unallowed_path}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).not_to be_empty
-    end
-  end
-end

data/spec/integration/node/partial_spec.rb

@@ -1,64 +0,0 @@
-describe "{{> partial}}" do
-  let(:global_helpers_providers) { [] }
-
-  describe "#compile" do
-    let(:post) { double("post") }
-    let(:presenter) { IntegrationTest::Presenter.new(double("view_context"), post: post) }
-
-    it "evaluates the methods chain call" do
-      template = Curlybars.compile(<<-HBS)
-        {{> partial}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        partial
-      HTML
-    end
-
-    it "renders nothing when the partial returns `nil`" do
-      template = Curlybars.compile(<<-HBS)
-        {{> return_nil}}
-      HBS
-
-      expect(eval(template)).to resemble("")
-    end
-  end
-
-  describe "#validate" do
-    it "validates the path with errors" do
-      dependency_tree = {}
-
-      source = <<-HBS
-        {{> unallowed_partial}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).not_to be_empty
-    end
-
-    it "raises when using a helper as a partial" do
-      dependency_tree = { helper: nil }
-
-      source = <<-HBS
-        {{> helper}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).not_to be_empty
-    end
-
-    it "does not raise with a valid partial" do
-      dependency_tree = { partial: :partial }
-
-      source = <<-HBS
-        {{> partial}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).to be_empty
-    end
-  end
-end