curlybars 1.7.0 → 1.9.0

data/spec/integration/node/unless_spec.rb

@@ -1,128 +0,0 @@
-describe "{{#unless}}...{{/unless}}" do
-  let(:global_helpers_providers) { [] }
-
-  describe "#compile" do
-    let(:post) { double("post") }
-    let(:presenter) { IntegrationTest::Presenter.new(double("view_context"), post: post) }
-
-    it "returns unless_template when condition is false" do
-      allow(presenter).to receive(:allows_method?).with(:condition).and_return(true)
-      allow(presenter).to receive(:condition).and_return(false)
-
-      template = Curlybars.compile(<<-HBS)
-        {{#unless condition}}
-          unless_template
-        {{/unless}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        unless_template
-      HTML
-    end
-
-    it "doesn't return unless_template when condition is true" do
-      allow(presenter).to receive(:allows_method?).with(:condition).and_return(true)
-      allow(presenter).to receive(:condition).and_return(true)
-
-      template = Curlybars.compile(<<-HBS)
-        {{#unless condition}}
-          unless_template
-        {{/unless}}
-      HBS
-
-      expect(eval(template)).to resemble("")
-    end
-
-    it "works with nested unless blocks (double negative)" do
-      allow(presenter).to receive(:allows_method?).with(:first_condition).and_return(true)
-      allow(presenter).to receive(:allows_method?).with(:second_condition).and_return(true)
-      allow(presenter).to receive(:first_condition).and_return(false)
-      allow(presenter).to receive(:second_condition).and_return(false)
-
-      template = Curlybars.compile(<<-HBS)
-        {{#unless first_condition}}
-          {{#unless second_condition}}
-            inner_unless_template
-          {{/unless}}
-            outer_unless_template
-        {{/unless}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        inner_unless_template
-        outer_unless_template
-      HTML
-    end
-
-    it "allows empty unless_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)
-        {{#unless valid}}{{/unless}}
-      HBS
-
-      expect(eval(template)).to resemble("")
-    end
-
-    it "works with nested unless blocks (negative and positive)" do
-      allow(presenter).to receive(:allows_method?).with(:first_condition).and_return(true)
-      allow(presenter).to receive(:allows_method?).with(:second_condition).and_return(true)
-      allow(presenter).to receive(:first_condition).and_return(false)
-      allow(presenter).to receive(:second_condition).and_return(true)
-
-      template = Curlybars.compile(<<-HBS)
-        {{#unless first_condition}}
-          {{#unless second_condition}}
-            inner_unless_template
-          {{/unless}}
-          outer_unless_template
-        {{/unless}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        outer_unless_template
-      HTML
-    end
-
-    it "allows usage of variables in condition" do
-      template = Curlybars.compile(<<-HBS)
-        {{#each two_elements}}
-          {{#unless @first}}I am the second!{{/unless}}
-        {{/each}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        I am the second!
-      HTML
-    end
-  end
-
-  describe "#validate" do
-    it "validates with errors the condition" do
-      dependency_tree = {}
-
-      source = <<-HBS
-        {{#unless condition}}{{/unless}}
-      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
-        {{#unless condition}}
-          {{unallowed_method}}
-        {{/unless}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).not_to be_empty
-    end
-  end
-end

data/spec/integration/node/with_spec.rb

@@ -1,178 +0,0 @@
-describe "{{#with presenter}}...{{/with}}" 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 "works scopes one level" do
-      template = Curlybars.compile(<<-HBS)
-        {{#with user}}
-          {{avatar.url}}
-        {{/with}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        http://example.com/foo.png
-      HTML
-    end
-
-    it "scopes two levels" do
-      template = Curlybars.compile(<<-HBS)
-        {{#with user}}
-          {{#with avatar}}
-            {{url}}
-          {{/with}}
-        {{/with}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        http://example.com/foo.png
-      HTML
-    end
-
-    it "allows subexpressions" do
-      template = Curlybars.compile(<<-HBS)
-        {{#with (translate user "sk-SK")}}
-          {{avatar.url}}
-        {{/with}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        http://example.com/foo.png?locale=sk-SK
-      HTML
-    end
-
-    it "allows empty with_template" do
-      template = Curlybars.compile(<<-HBS)
-        {{#with user}}{{/with}}
-      HBS
-
-      expect(eval(template)).to resemble("")
-    end
-
-    it "renders the else template if the context is nil" do
-      template = Curlybars.compile(<<-HBS)
-        {{#with return_nil}}
-          text
-        {{else}}
-          else
-        {{/with}}
-      HBS
-
-      expect(eval(template)).to resemble(<<-HTML)
-        else
-      HTML
-    end
-
-    it "renders nothing if the context is nil and no else block is specified" do
-      template = Curlybars.compile(<<-HBS)
-        {{#with return_nil}}
-          text
-        {{/with}}
-      HBS
-
-      expect(eval(template)).to resemble("")
-    end
-
-    it "raises an exception if the parameter is not a context type object" do
-      template = Curlybars.compile(<<-HBS)
-        {{#with return_true}}{{/with}}
-      HBS
-
-      expect do
-        eval(template)
-      end.to raise_error(Curlybars::Error::Render)
-    end
-  end
-
-  describe "#validate" do
-    it "without errors" do
-      dependency_tree = { a_presenter: {} }
-
-      source = <<-HBS
-        {{#with a_presenter}}{{/with}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).to be_empty
-    end
-
-    it "without errors when a presenter helper is used" do
-      dependency_tree = { translate_article: [:helper, { title: nil }] }
-
-      source = <<-HBS
-        {{#with (translate_article 12345 "en-US")}}
-          {{title}}
-        {{/with}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).to be_empty
-    end
-
-    it "without errors when a generic presenter helper is used" do
-      dependency_tree = { article: { title: nil }, translate: [:helper, {}] }
-
-      source = <<-HBS
-        {{#with (translate article "en-US")}}
-          {{title}}
-        {{/with}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).to be_empty
-    end
-
-    it "with errors due to a leaf" do
-      dependency_tree = { not_a_presenter: nil }
-
-      source = <<-HBS
-        {{#with not_a_presenter}}{{/with}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).not_to be_empty
-    end
-
-    it "with errors due unallowed method" do
-      dependency_tree = {}
-
-      source = <<-HBS
-        {{#with unallowed}}{{/with}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).not_to be_empty
-    end
-
-    it "with errors due collection helpers" do
-      dependency_tree = { reverse_articles: [:helper, [{ title: nil }]] }
-
-      source = <<-HBS
-        {{#with (reverse_articles)}}{{/with}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).not_to be_empty
-    end
-
-    it "with errors due generic collection helpers" do
-      dependency_tree = { articles: [{ title: nil }], slice: [:helper, [{}]] }
-
-      source = <<-HBS
-        {{#with (slice articles 0 4)}}{{/with}}
-      HBS
-
-      errors = Curlybars.validate(dependency_tree, source)
-
-      expect(errors).not_to be_empty
-    end
-  end
-end

data/spec/integration/processor/tilde_spec.rb

@@ -1,38 +0,0 @@
-describe "tilde operator" do
-  let(:global_helpers_providers) { [] }
-
-  describe "compilation" do
-    let(:post) { double("post") }
-    let(:presenter) { IntegrationTest::Presenter.new(double("view_context"), post: post) }
-
-    it "{{~ ... }} removes trailing whitespaces and newlines from the previous :TEXT" do
-      template = Curlybars.compile("before \r\t\n{{~'curlybars'}}\n\t\r after")
-
-      expect(eval(template)).to resemble("beforecurlybars\n\t\r after")
-    end
-
-    it "{{ ... ~}} removes trailing whitespaces and newlines from the next :TEXT" do
-      template = Curlybars.compile("before \r\t\n{{'curlybars'~}}\n\t\r after")
-
-      expect(eval(template)).to resemble("before \r\t\ncurlybarsafter")
-    end
-
-    it "{{~ ... ~}} does not remove trailing whitespaces and newlines from the next :TEXT" do
-      template = Curlybars.compile("before \r\t\n{{~'curlybars'~}}\n\t\r after")
-
-      expect(eval(template)).to resemble("beforecurlybarsafter")
-    end
-  end
-
-  describe "validation" do
-    let(:presenter) { double(:presenter, dependency_tree: { curlybars: nil }) }
-
-    it "runs even when 'run_processors' flag is set to false" do
-      allow(Curlybars::Processor::Tilde).to receive(:process!)
-
-      Curlybars.validate(presenter.dependency_tree, "source", run_processors: false)
-
-      expect(Curlybars::Processor::Tilde).to have_received(:process!)
-    end
-  end
-end

data/spec/integration/processors_spec.rb

@@ -1,29 +0,0 @@
-describe "processors" do
-  let(:presenter) { double(:presenter, dependency_tree: { curlybars: nil }) }
-  let(:processor) { double(:processor) }
-
-  before do
-    allow(Curlybars.configuration).to receive(:custom_processors).and_return([processor])
-    allow(processor).to receive(:process!)
-  end
-
-  describe "validation" do
-    it "are run by default" do
-      Curlybars.validate(presenter.dependency_tree, "source")
-
-      expect(processor).to have_received(:process!)
-    end
-
-    it "are run when run_processors is true" do
-      Curlybars.validate(presenter.dependency_tree, "source", run_processors: true)
-
-      expect(processor).to have_received(:process!)
-    end
-
-    it "are not run when run_processors is false" do
-      Curlybars.validate(presenter.dependency_tree, "source", run_processors: false)
-
-      expect(processor).not_to have_received(:process!)
-    end
-  end
-end

data/spec/integration/visitor_spec.rb

@@ -1,154 +0,0 @@
-describe "visitor" do
-  let(:source) do
-    <<-HBS
-      {{#print_args_and_options 'first' 'second' key='value'}}
-      {{/print_args_and_options}}
-
-      {{calc (calc 1 "+" 2) "*" 3}}
-
-      {{#render_inverse}}
-        fn
-      {{else}}
-        inverse
-        {{@variable}}
-      {{/render_inverse}}
-
-      {{#each foo}}
-        top
-        {{#each bar}}
-          middle
-          {{#each baz}}
-            inner
-          {{else}}
-            inner inverse
-          {{/each}}
-        {{/each}}
-      {{/each}}
-
-      {{#if valid}}
-        if_template
-        {{#if bar}}
-          foo
-        {{else}}
-          qux
-        {{/if}}
-      {{/if}}
-
-      {{#if baz}}
-        qux
-      {{/if}}
-
-      {{> partial}}
-
-      {{user.avatar.url}}
-      {{#with this}}
-        {{user.avatar.url}}
-      {{/with}}
-
-      {{#unless things}}
-        hi
-      {{/unless}}
-    HBS
-  end
-
-  describe ".visit" do
-    it "visits BlockHelperElse nodes" do
-      visitor = counting_visitor_for(Curlybars::Node::BlockHelperElse)
-      output = Curlybars.visit(visitor, source)
-      expect(output).to eq(5)
-    end
-
-    it "visits EachElse nodes" do
-      visitor = counting_visitor_for(Curlybars::Node::EachElse)
-      output = Curlybars.visit(visitor, source)
-      expect(output).to eq(3)
-    end
-
-    it "visits IfElse nodes" do
-      visitor = counting_visitor_for(Curlybars::Node::IfElse)
-      output = Curlybars.visit(visitor, source)
-      expect(output).to eq(3)
-    end
-
-    it "visits Item nodes" do
-      visitor = counting_visitor_for(Curlybars::Node::Item)
-      output = Curlybars.visit(visitor, source)
-      expect(output).to eq(44)
-    end
-
-    it "visits Literal nodes" do
-      visitor = counting_visitor_for(Curlybars::Node::Literal)
-      output = Curlybars.visit(visitor, source)
-      expect(output).to eq(8)
-    end
-
-    it "visits Option nodes" do
-      visitor = counting_visitor_for(Curlybars::Node::Option)
-      output = Curlybars.visit(visitor, source)
-      expect(output).to eq(1)
-    end
-
-    it "visits Partial nodes" do
-      visitor = counting_visitor_for(Curlybars::Node::Partial)
-      output = Curlybars.visit(visitor, source)
-      expect(output).to eq(1)
-    end
-
-    it "visits Path nodes" do
-      visitor = counting_visitor_for(Curlybars::Node::Path)
-      output = Curlybars.visit(visitor, source)
-      expect(output).to eq(15)
-    end
-
-    it "visits Root nodes" do
-      visitor = counting_visitor_for(Curlybars::Node::Root)
-      output = Curlybars.visit(visitor, source)
-      expect(output).to eq(1)
-    end
-
-    it "visits SubExpression nodes" do
-      visitor = counting_visitor_for(Curlybars::Node::SubExpression)
-      output = Curlybars.visit(visitor, source)
-      expect(output).to eq(1)
-    end
-
-    it "visits Template nodes" do
-      visitor = counting_visitor_for(Curlybars::Node::Template)
-      output = Curlybars.visit(visitor, source)
-      expect(output).to eq(14)
-    end
-
-    it "visits Text nodes" do
-      visitor = counting_visitor_for(Curlybars::Node::Text)
-      output = Curlybars.visit(visitor, source)
-      expect(output).to eq(29)
-    end
-
-    it "visits UnlessElse nodes" do
-      visitor = counting_visitor_for(Curlybars::Node::UnlessElse)
-      output = Curlybars.visit(visitor, source)
-      expect(output).to eq(1)
-    end
-
-    it "visits Variable nodes" do
-      visitor = counting_visitor_for(Curlybars::Node::Variable)
-      output = Curlybars.visit(visitor, source)
-      expect(output).to eq(1)
-    end
-
-    it "visits WithElse nodes" do
-      visitor = counting_visitor_for(Curlybars::Node::WithElse)
-      output = Curlybars.visit(visitor, source)
-      expect(output).to eq(1)
-    end
-  end
-
-  def counting_visitor_for(klass)
-    Class.new(Curlybars::Visitor) do
-      define_method "visit_#{klass.name.demodulize.underscore}" do |node|
-        self.context += 1
-        super(node)
-      end
-    end.new(0)
-  end
-end