curlybars 0.9.13

data/spec/integration/node/escape_spec.rb

@@ -0,0 +1,27 @@
+describe '`\` as an escaping character' do
+  let(:post) { double("post") }
+  let(:presenter) { IntegrationTest::Presenter.new(double("view_context"), post: post) }
+  let(:global_helpers_providers) { [] }
+
+  it "escapes `{`" do
+    template = Curlybars.compile(<<-HBS)
+      text \\{{! text
+    HBS
+
+    expect(eval(template)).to resemble('text {{! text')
+  end
+
+  it "escapes `\\`" do
+    template = Curlybars.compile(<<-HBS)
+      text \\ text
+    HBS
+
+    expect(eval(template)).to resemble('text \\ text')
+  end
+
+  it "escapes `\\` at the end of the string" do
+    template = Curlybars.compile('text \\')
+
+    expect(eval(template)).to resemble('text \\')
+  end
+end

data/spec/integration/node/helper_spec.rb

@@ -0,0 +1,176 @@
+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 "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
+    let(:presenter_class) { double(:presenter_class) }
+
+    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

@@ -0,0 +1,129 @@
+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) { true }
+      allow(presenter).to receive(:return_true) { 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) { true }
+      allow(presenter).to receive(:return_false) { 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) { true }
+      allow(presenter).to receive(:valid) { 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) { true }
+      allow(presenter).to receive(:valid) { 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) { true }
+      allow(presenter).to receive(:valid) { true }
+
+      template = Curlybars.compile(<<-HBS)
+        {{#if valid}}{{else}}{{/if}}
+      HBS
+
+      expect(eval(template)).to resemble("")
+    end
+  end
+
+  describe "#validate" do
+    let(:presenter_class) { double(:presenter_class) }
+
+    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
+  end
+end

data/spec/integration/node/if_spec.rb

@@ -0,0 +1,143 @@
+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) { true }
+      allow(presenter).to receive(:valid) { 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) { true }
+      allow(presenter).to receive(:valid) { 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) { true }
+      allow(presenter).to receive(:collection) { [] }
+
+      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) { true }
+      allow(presenter).to receive(:allows_method?).with(:visible) { true }
+      allow(presenter).to receive(:valid) { true }
+      allow(presenter).to receive(:visible) { 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) { true }
+      allow(presenter).to receive(:allows_method?).with(:visible) { true }
+      allow(presenter).to receive(:valid) { true }
+      allow(presenter).to receive(:visible) { 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) { true }
+      allow(presenter).to receive(:valid) { 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
+    let(:presenter_class) { double(:presenter_class) }
+
+    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
+  end
+end