curlybars 0.9.13

data/spec/curlybars/method_whitelist_spec.rb

@@ -0,0 +1,168 @@
+describe Curlybars::MethodWhitelist do
+  let(:dummy_class) { Class.new { extend Curlybars::MethodWhitelist } }
+
+  describe "#allowed_methods" do
+    it "returns an empty array as default" do
+      expect(dummy_class.new.allowed_methods).to eq([])
+    end
+  end
+
+  describe ".allow_methods" do
+    before do
+      link_presenter = Class.new
+      article_presenter = Class.new
+
+      dummy_class.class_eval do
+        allow_methods :cook, link: link_presenter, article: article_presenter
+      end
+    end
+
+    it "sets the allowed methods" do
+      expect(dummy_class.new.allowed_methods).to eq([:cook, :link, :article])
+    end
+
+    it "raises when collection is not of presenters" do
+      expect do
+        dummy_class.class_eval { allow_methods :cook, links: ["foobar"] }
+      end.to raise_error(RuntimeError)
+    end
+
+    it "raises when collection cardinality is greater than one" do
+      stub_const("OnePresenter", Class.new { extend Curlybars::MethodWhitelist })
+      stub_const("OtherPresenter", Class.new { extend Curlybars::MethodWhitelist })
+
+      expect do
+        dummy_class.class_eval { allow_methods :cook, links: [OnePresenter, OtherPresenter] }
+      end.to raise_error(RuntimeError)
+    end
+  end
+
+  describe "inheritance and composition" do
+    let(:base_presenter) do
+      stub_const("LinkPresenter", Class.new)
+
+      Class.new do
+        extend Curlybars::MethodWhitelist
+        allow_methods :cook, link: LinkPresenter
+      end
+    end
+
+    let(:helpers) do
+      Module.new do
+        extend Curlybars::MethodWhitelist
+        allow_methods :form
+      end
+    end
+
+    let(:post_presenter) do
+      Class.new(base_presenter) do
+        extend Curlybars::MethodWhitelist
+        include Helpers
+        allow_methods :wave
+      end
+    end
+
+    before do
+      stub_const("Helpers", helpers)
+    end
+
+    it "allows methods from inheritance and composition" do
+      expect(post_presenter.new.allowed_methods).to eq([:cook, :link, :form, :wave])
+    end
+
+    it "returns a dependency_tree with inheritance and composition" do
+      expect(post_presenter.dependency_tree).
+        to eq(
+          cook: nil,
+          link: LinkPresenter,
+          form: nil,
+          wave: nil
+        )
+    end
+  end
+
+  describe ".methods_schema" do
+    it "setups a schema propagating nil" do
+      stub_const("LinkPresenter", Class.new { extend Curlybars::MethodWhitelist })
+      dummy_class.class_eval { allow_methods :cook }
+
+      expect(dummy_class.methods_schema).to eq(cook: nil)
+    end
+
+    it "setups a schema any random type" do
+      stub_const("LinkPresenter", Class.new { extend Curlybars::MethodWhitelist })
+      dummy_class.class_eval { allow_methods something: :foobar }
+
+      expect(dummy_class.methods_schema).to eq(something: :foobar)
+    end
+
+    it "setups a schema propagating the return type of the method" do
+      stub_const("ArticlePresenter", Class.new { extend Curlybars::MethodWhitelist })
+      dummy_class.class_eval { allow_methods article: ArticlePresenter }
+
+      expect(dummy_class.methods_schema).to eq(article: ArticlePresenter)
+    end
+
+    it "setups a schema propagating a collection" do
+      stub_const("LinkPresenter", Class.new { extend Curlybars::MethodWhitelist })
+      dummy_class.class_eval { allow_methods links: [LinkPresenter] }
+
+      expect(dummy_class.methods_schema).to eq(links: [LinkPresenter])
+    end
+
+    it "supports procs in schema" do
+      dummy_class.class_eval { allow_methods settings: ->() { { color_1: nil } } }
+
+      expect(dummy_class.methods_schema).to eq(settings: { color_1: nil })
+    end
+
+    it "supports procs with arguments in schema" do
+      dummy_class.class_eval { allow_methods settings: ->(name) { Hash[name, nil] } }
+
+      expect(dummy_class.methods_schema(:background_color)).to eq(settings: { background_color: nil })
+    end
+  end
+
+  describe ".dependency_tree" do
+    it "returns a dependencies tree" do
+      link_presenter = Class.new do
+        extend Curlybars::MethodWhitelist
+        allow_methods :url
+      end
+
+      article_presenter = Class.new do
+        extend Curlybars::MethodWhitelist
+        allow_methods :title, :body
+      end
+
+      stub_const("ArticlePresenter", article_presenter)
+      stub_const("LinkPresenter", link_presenter)
+
+      dummy_class.class_eval do
+        allow_methods links: [LinkPresenter], article: ArticlePresenter
+      end
+
+      expect(dummy_class.dependency_tree).
+        to eq(
+          links: [{ url: nil }],
+          article: {
+            title: nil,
+            body: nil
+          }
+        )
+    end
+
+    it "propagates arguments" do
+      dummy_class.class_eval do
+        allow_methods label: ->(label) { Hash[label, nil] }
+      end
+
+      expect(dummy_class.dependency_tree(:some_label)).
+        to eq(
+          label: {
+            some_label: nil
+          }
+        )
+    end
+  end
+end

data/spec/curlybars/processor/tilde_spec.rb

@@ -0,0 +1,60 @@
+describe Curlybars::Processor::Tilde do
+  let(:tilde_start_token) { double(:tilde_start, type: :TILDE_START, value: nil, position: nil) }
+  let(:tilde_end_token) { double(:tilde_end, type: :TILDE_END, value: nil, position: nil) }
+  let(:start_token) { double(:start, type: :START, value: nil, position: nil) }
+  let(:end_token) { double(:end, type: :END, value: nil, position: nil) }
+
+  describe ":TILDE_START" do
+    it "trims the previous text token" do
+      tokens = [
+        text_token("text \t\r\n"),
+        tilde_start_token
+      ]
+      Curlybars::Processor::Tilde.process!(tokens, 'identifier')
+
+      expect(tokens.first.value).to eq 'text'
+    end
+
+    it "doesn't trim the previous text token when not right before" do
+      tokens = [
+        text_token("text \t\r\n"),
+        start_token,
+        end_token,
+        tilde_start_token
+      ]
+      Curlybars::Processor::Tilde.process!(tokens, 'identifier')
+
+      expect(tokens.first.value).to eq "text \t\r\n"
+    end
+  end
+
+  describe ":TILDE_END" do
+    it "trims the following text token" do
+      tokens = [
+        tilde_end_token,
+        text_token("\t\r\n text")
+      ]
+      Curlybars::Processor::Tilde.process!(tokens, 'identifier')
+
+      expect(tokens.last.value).to eq 'text'
+    end
+
+    it "doesn't trim the following text token when not right after" do
+      tokens = [
+        tilde_end_token,
+        start_token,
+        end_token,
+        text_token("\t\r\n text")
+      ]
+      Curlybars::Processor::Tilde.process!(tokens, 'identifier')
+
+      expect(tokens.last.value).to eq "\t\r\n text"
+    end
+  end
+
+  private
+
+  def text_token(value)
+    double(:text, type: :TEXT, value: value, position: nil)
+  end
+end

data/spec/curlybars/rendering_support_spec.rb

@@ -0,0 +1,426 @@
+describe Curlybars::RenderingSupport do
+  let(:file_name) { '/app/views/template.hbs' }
+  let(:presenter) { double(:presenter, allows_method?: true, meth: :value) }
+  let(:contexts) { [presenter] }
+  let(:variables) { [{}] }
+  let(:rendering) { Curlybars::RenderingSupport.new(1.second, contexts, variables, file_name) }
+  let(:position) do
+    double(:position, file_name: 'template.hbs', line_number: 1, line_offset: 0)
+  end
+  let(:block) { -> {} }
+
+  describe "#check_timeout!" do
+    it "skips checking if timeout is nil" do
+      rendering = Curlybars::RenderingSupport.new(nil, contexts, variables, file_name)
+
+      sleep 0.1.seconds
+      expect { rendering.check_timeout! }.not_to raise_error
+    end
+
+    it "doesn't happen when rendering is < rendering_timeout" do
+      rendering = Curlybars::RenderingSupport.new(10.seconds, contexts, variables, file_name)
+      expect { rendering.check_timeout! }.not_to raise_error
+    end
+
+    it "happens and raises when rendering >= rendering_timeout" do
+      rendering = Curlybars::RenderingSupport.new(0.01.seconds, contexts, variables, file_name)
+
+      sleep 0.1.seconds
+      expect { rendering.check_timeout! }.to raise_error(Curlybars::Error::Render)
+    end
+  end
+
+  describe "#to_bool" do
+    describe "returns true" do
+      it "with `true`" do
+        expect(rendering.to_bool(true)).to be_truthy
+      end
+
+      it "with `[:non_empty]`" do
+        expect(rendering.to_bool([:non_empty])).to be_truthy
+      end
+
+      it "with `1`" do
+        expect(rendering.to_bool(1)).to be_truthy
+      end
+    end
+
+    describe "returns false" do
+      it "with `false`" do
+        expect(rendering.to_bool(false)).to be_falsey
+      end
+
+      it "with `[]`" do
+        expect(rendering.to_bool([])).to be_falsey
+      end
+
+      it "with `{}`" do
+        expect(rendering.to_bool({})).to be_falsey
+      end
+
+      it "with `0`" do
+        expect(rendering.to_bool(0)).to be_falsey
+      end
+
+      it "with `nil`" do
+        expect(rendering.to_bool(nil)).to be_falsey
+      end
+    end
+  end
+
+  describe "#path" do
+    it "returns the method in the current context" do
+      allow_all_methods(presenter)
+      allow(presenter).to receive(:method) { :method }
+
+      expect(rendering.path('method', rendering.position(0, 1))).to eq :method
+    end
+
+    it "returns the method in the current context" do
+      sub = double(:sub_presenter)
+      allow_all_methods(sub)
+      allow(sub).to receive(:method) { :method }
+
+      allow_all_methods(presenter)
+      allow(presenter).to receive(:sub) { sub }
+
+      expect(rendering.path('sub.method', rendering.position(0, 1))).to eq :method
+    end
+
+    it "returns the length of a collection, when `lenght` is the last step" do
+      allow_all_methods(presenter)
+      single_element_presenter = double(:single_element_presenter)
+      allow_all_methods(single_element_presenter)
+      collection = [single_element_presenter]
+      allow(presenter).to receive(:collection) { collection }
+
+      returned_method = rendering.path('collection.length', rendering.position(0, 1))
+      expect(returned_method.call).to eq collection.length
+    end
+
+    it "raises an exception when the method is not allowed" do
+      disallow_all_methods(presenter)
+      allow(presenter).to receive(:forbidden_method) { :forbidden_method }
+
+      expect do
+        rendering.path('forbidden_method', rendering.position(0, 1))
+      end.to raise_error(Curlybars::Error::Render)
+    end
+
+    it "exposes the unallowed method in the exception payload" do
+      disallow_all_methods(presenter)
+      allow(presenter).to receive(:forbidden_method) { :forbidden_method }
+
+      begin
+        rendering.path('forbidden_method', rendering.position(0, 1))
+      rescue Curlybars::Error::Render => e
+        expect(e.metadata).to eq(meth: :forbidden_method)
+      end
+    end
+
+    it "raises an exception when the context is not a presenter" do
+      sub = double(:not_presenter)
+      allow(presenter).to receive(:sub) { sub }
+
+      expect do
+        rendering.path('sub.method', rendering.position(0, 1))
+      end.to raise_error(Curlybars::Error::Render)
+    end
+
+    it "refers to the second to last presenter in the stack when using `../`" do
+      sub = double(:sub_presenter)
+      allow_all_methods(sub)
+      allow(sub).to receive(:method) { :sub_method }
+
+      allow_all_methods(presenter)
+      allow(presenter).to receive(:method) { :root_method }
+
+      contexts.push(sub)
+
+      expect(rendering.path('../method', rendering.position(0, 1))).to eq :root_method
+    end
+
+    it "refers to the third to last presenter in the stack when using `../../`" do
+      sub_sub = double(:sub_presenter)
+      allow_all_methods(sub_sub)
+      allow(sub_sub).to receive(:method) { :sub_sub_method }
+
+      sub = double(:sub_presenter)
+      allow_all_methods(sub)
+      allow(sub).to receive(:method) { :sub_method }
+
+      allow_all_methods(presenter)
+      allow(presenter).to receive(:method) { :root_method }
+
+      contexts.push(sub)
+      contexts.push(sub_sub)
+
+      expect(rendering.path('../../method', rendering.position(0, 1))).to eq :root_method
+    end
+
+    it "returns a method that returns nil, if nil is returned from any method in the chain (except the latter)" do
+      allow_all_methods(presenter)
+      allow(presenter).to receive(:returns_nil) { nil }
+
+      outcome = rendering.path('returns_nil.another_method', rendering.position(0, 1)).call
+      expect(outcome).to be_nil
+    end
+
+    it "returns a method that returns nil, if `../`` goes too deep in the stack" do
+      outcome = rendering.path('../too_deep', rendering.position(0, 1)).call
+      expect(outcome).to be_nil
+    end
+
+    it "raises an exception if tha path is too deep (> 10)" do
+      expect do
+        rendering.path('a.b.c.d.e.f.g.h.i.l', rendering.position(0, 1))
+      end.to raise_error(Curlybars::Error::Render)
+    end
+  end
+
+  describe "#cached_call" do
+    before do
+      class APresenter
+        def meth
+          :value
+        end
+      end
+    end
+
+    it "(cache miss) calls the method if not cached already" do
+      meth = presenter.method(:meth)
+      allow(meth).to receive(:call)
+
+      rendering.cached_call(meth)
+
+      expect(meth).to have_received(:call).once
+    end
+
+    it "(cache hit) avoids to call a method for more than one time" do
+      meth = presenter.method(:meth)
+      allow(meth).to receive(:call)
+
+      rendering.cached_call(meth)
+      rendering.cached_call(meth)
+
+      expect(meth).to have_received(:call).once
+    end
+
+    it "the returned cached value is the same as the uncached one" do
+      meth = presenter.method(:meth)
+
+      first_outcome = rendering.cached_call(meth)
+      second_outcome = rendering.cached_call(meth)
+
+      expect(second_outcome).to eq first_outcome
+    end
+  end
+
+  describe "#call" do
+    it "calls with no arguments a method with no parameters" do
+      method = ->() { :return }
+      arguments = []
+
+      output = rendering.call(method, "method", position, arguments, :options, &block)
+      expect(output).to eq :return
+    end
+
+    it "calls with one argument a method with no parameters, discarding the parameter" do
+      method = ->() { :return }
+      arguments = [:argument]
+
+      output = rendering.call(method, "method", position, arguments, :options, &block)
+      expect(output).to eq :return
+    end
+
+    it "calls a method with only one parameter can only receive the options" do
+      method = ->(parameter) { parameter }
+      arguments = []
+
+      output = rendering.call(method, "method", position, arguments, :options, &block)
+      expect(output).to eq :options
+    end
+
+    it "calls a method with only one parameter can only receive the options, even with some arguments" do
+      method = ->(parameter) { parameter }
+      arguments = [:argument]
+
+      output = rendering.call(method, "method", position, arguments, :options, &block)
+      expect(output).to eq :options
+    end
+
+    it "calls a method with two parameter can receive nil as first argument and the options" do
+      method = ->(parameter, options) { [parameter, options] }
+      arguments = []
+
+      output = rendering.call(method, "method", position, arguments, :options, &block)
+      expect(output).to eq [nil, :options]
+    end
+
+    it "calls a method with two parameter can receive an argument and the options" do
+      method = ->(parameter, options) { [parameter, options] }
+      arguments = [:argument]
+
+      output = rendering.call(method, "method", position, arguments, :options, &block)
+      expect(output).to eq [:argument, :options]
+    end
+
+    it "calls a method with three parameter can receive two arguments and the options" do
+      method = ->(first, second, options) { [first, second, options] }
+      arguments = [:first, :second]
+
+      output = rendering.call(method, "method", position, arguments, :options, &block)
+      expect(output).to eq [:first, :second, :options]
+    end
+
+    it "calls a method with three parameter can receive one argument, nil and the options" do
+      method = ->(first, second, options) { [first, second, options] }
+      arguments = [:first]
+
+      output = rendering.call(method, "method", position, arguments, :options, &block)
+      expect(output).to eq [:first, nil, :options]
+    end
+
+    it "calls a method with three parameter can receive nil, nil and the options" do
+      method = ->(first, second, options) { [first, second, options] }
+      arguments = []
+
+      output = rendering.call(method, "method", position, arguments, :options, &block)
+      expect(output).to eq [nil, nil, :options]
+    end
+
+    it "calls a method passing an array as argument" do
+      method = ->(parameter, _) { parameter }
+      array = [1, 2, 3]
+      arguments = [array]
+
+      output = rendering.call(method, "method", position, arguments, :options, &block)
+      expect(output).to eq arguments.first
+    end
+
+    it "raises Curlybars::Error::Render if the helper has at least an optional parameter" do
+      method = ->(one, two = :optional) {}
+      arguments = [:arg1]
+      options = { key: :value }
+
+      expect do
+        rendering.call(method, "method", position, arguments, options, &block)
+      end.to raise_error(Curlybars::Error::Render)
+    end
+
+    it "raises Curlybars::Error::Render if the helper has at least a keyword parameter" do
+      method = ->(keyword:) {}
+      arguments = [:arg1]
+      options = { key: :value }
+
+      expect do
+        rendering.call(method, "method", position, arguments, options, &block)
+      end.to raise_error(Curlybars::Error::Render)
+    end
+
+    it "raises Curlybars::Error::Render if the helper has at least an optional keyword parameter" do
+      method = ->(keyword: :optional) {}
+      arguments = [:arg1]
+      options = { key: :value }
+
+      expect do
+        rendering.call(method, "meth", position, arguments, options, &block)
+      end.to raise_error(Curlybars::Error::Render)
+    end
+  end
+
+  describe "#position" do
+    it "returns a position with file_name" do
+      position = rendering.position(0, 0)
+      expect(position.file_name).to eq file_name
+    end
+
+    it "returns a position with line_number" do
+      position = rendering.position(1, 0)
+      expect(position.line_number).to eq 1
+    end
+
+    it "returns a position with line_offset" do
+      position = rendering.position(0, 1)
+      expect(position.line_offset).to eq 1
+    end
+  end
+
+  describe "#check_context_is_hash_or_enum_of_presenters" do
+    it "doesn't raise an exception when argument is an empty enumerable" do
+      collection = []
+      rendering.check_context_is_hash_or_enum_of_presenters(collection, 'path', position)
+    end
+
+    it "doesn't raise an exception when argument is an empty hash" do
+      collection = {}
+      rendering.check_context_is_hash_or_enum_of_presenters(collection, nil, position)
+    end
+
+    it "doesn't raise an exception when argument is an enumerable of presenters" do
+      collection = [presenter]
+      rendering.check_context_is_hash_or_enum_of_presenters(collection, 'path', position)
+    end
+
+    it "doesn't raise an exception when argument is a hash of presenters" do
+      collection = { presenter: presenter }
+      rendering.check_context_is_hash_or_enum_of_presenters(collection, 'path', position)
+    end
+
+    it "raises when it is not an hash or an enumerable" do
+      expect do
+        rendering.check_context_is_hash_or_enum_of_presenters(:not_a_presenter, 'path', position)
+      end.to raise_error(Curlybars::Error::Render)
+    end
+
+    it "raises when it is not an hash or an enumerable of presenters" do
+      expect do
+        rendering.check_context_is_hash_or_enum_of_presenters([:not_a_presenter], 'path', position)
+      end.to raise_error(Curlybars::Error::Render)
+    end
+  end
+
+  describe "#check_context_is_presenter" do
+    it "doesn't raise an exception when argument is a presenter" do
+      rendering.check_context_is_presenter(presenter, 'path', position)
+    end
+
+    it "raises when it is not a presenter" do
+      expect do
+        rendering.check_context_is_presenter(:not_a_presenter, 'path', position)
+      end.to raise_error(Curlybars::Error::Render)
+    end
+  end
+
+  describe "#coerce_to_hash!" do
+    let(:a_presenter) { double(:a_presenter, allows_method?: true, meth: :value) }
+    let(:another_presenter) { double(:another_presenter, allows_method?: true, meth: :value) }
+
+    it "leaves hashes intacted" do
+      hash = { first: a_presenter }
+      expect(rendering.coerce_to_hash!(hash, 'path', position)).to be hash
+    end
+
+    it "transform an Array to a Hash" do
+      array = [a_presenter, another_presenter]
+      expected_hash = { 0 => a_presenter, 1 => another_presenter }
+      expect(rendering.coerce_to_hash!(array, 'path', position)).to eq expected_hash
+    end
+
+    it "raises when it is not a hash or an enumerable" do
+      expect do
+        rendering.coerce_to_hash!(:not_a_presenter, 'path', position)
+      end.to raise_error(Curlybars::Error::Render)
+    end
+  end
+
+  private
+
+  def allow_all_methods(presenter)
+    allow(presenter).to receive(:allows_method?) { true }
+  end
+
+  def disallow_all_methods(presenter)
+    allow(presenter).to receive(:allows_method?) { false }
+  end
+end