curlybars 1.8.0 → 1.9.0

data/spec/curlybars/rendering_support_spec.rb

@@ -1,421 +0,0 @@
-# rubocop:disable RSpec/MultipleMemoizedHelpers
-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
-
-  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).and_return(:method)
-
-      expect(rendering.path('method', rendering.position(0, 1))).to eq :method
-    end
-
-    it "returns the sub presenter method in the current context" do
-      sub = double(:sub_presenter)
-      allow_all_methods(sub)
-      allow(sub).to receive(:method).and_return(: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).and_return(: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).and_return(: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).and_return(:sub_method)
-
-      allow_all_methods(presenter)
-      allow(presenter).to receive(:method).and_return(: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).and_return(:sub_sub_method)
-
-      sub = double(:sub_presenter)
-      allow_all_methods(sub)
-      allow(sub).to receive(:method).and_return(:sub_method)
-
-      allow_all_methods(presenter)
-      allow(presenter).to receive(:method).and_return(: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).and_return(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
-    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
-    let(:block) { -> {} }
-
-    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?).and_return(true)
-  end
-
-  def disallow_all_methods(presenter)
-    allow(presenter).to receive(:allows_method?).and_return(false)
-  end
-end
-# rubocop:enable RSpec/MultipleMemoizedHelpers

data/spec/curlybars/safe_buffer_spec.rb

@@ -1,46 +0,0 @@
-describe Curlybars::SafeBuffer do
-  let(:configuration) { double(:configuration) }
-
-  before do
-    allow(Curlybars).to receive(:configuration) { configuration }
-  end
-
-  describe '#is_a?' do
-    it "is a String" do
-      expect(Curlybars::SafeBuffer.new).to be_a(String)
-    end
-
-    it "is a ActiveSupport::SafeBuffer" do
-      expect(Curlybars::SafeBuffer.new).to be_a(ActiveSupport::SafeBuffer)
-    end
-  end
-
-  describe "#concat" do
-    it "accepts when (buffer length + the existing output lenght) <= output_limit" do
-      allow(configuration).to receive(:output_limit).and_return(10)
-
-      buffer = Curlybars::SafeBuffer.new('*' * 5)
-
-      expect do
-        buffer.concat('*' * 5)
-      end.not_to raise_error
-    end
-
-    it "raises when (buffer length + the existing output lenght) > output_limit" do
-      allow(configuration).to receive(:output_limit).and_return(10)
-      buffer = Curlybars::SafeBuffer.new('*' * 10)
-
-      expect do
-        buffer.concat('*')
-      end.to raise_error(Curlybars::Error::Render)
-    end
-
-    it "raises when buffer length > output_limit" do
-      allow(configuration).to receive(:output_limit).and_return(10)
-
-      expect do
-        Curlybars::SafeBuffer.new.concat('*' * 11)
-      end.to raise_error(Curlybars::Error::Render)
-    end
-  end
-end

data/spec/curlybars/template_handler_spec.rb

@@ -1,225 +0,0 @@
-describe Curlybars::TemplateHandler do
-  let :presenter_class do
-    Class.new do
-      def initialize(context, options = {})
-        @context = context
-        @cache_key = options.fetch(:cache_key, nil)
-        @cache_duration = options.fetch(:cache_duration, nil)
-        @cache_options = options.fetch(:cache_options, {})
-      end
-
-      def setup!
-        @context.content_for(:foo, "bar")
-      end
-
-      def foo
-        "FOO"
-      end
-
-      def bar
-        @context.bar
-      end
-
-      def cache_key
-        @cache_key
-      end
-
-      def cache_duration
-        @cache_duration
-      end
-
-      def cache_options
-        @cache_options
-      end
-
-      def allows_method?(method)
-        true
-      end
-    end
-  end
-
-  let :context_class do
-    Class.new do
-      attr_reader :output_buffer
-      attr_reader :local_assigns, :assigns
-
-      def initialize
-        @cache = Hash.new
-        @local_assigns = Hash.new
-        @assigns = Hash.new
-        @clock = 0
-      end
-
-      def reset!
-        @output_buffer = ActiveSupport::SafeBuffer.new
-      end
-
-      def advance_clock(duration)
-        @clock += duration
-      end
-
-      def content_for(key, value = nil)
-        @contents ||= {}
-        @contents[key] = value if value.present?
-        @contents[key]
-      end
-
-      def cache(key, options = {})
-        fragment, expired_at = @cache[key]
-
-        if fragment.nil? || @clock >= expired_at
-          old_buffer = @output_buffer
-          @output_buffer = ActiveSupport::SafeBuffer.new
-
-          yield
-
-          fragment = @output_buffer.to_s
-          duration = options[:expires_in] || Float::INFINITY
-
-          @cache[key] = [fragment, @clock + duration]
-
-          @output_buffer = old_buffer
-        end
-
-        safe_concat(fragment)
-
-        nil
-      end
-
-      def safe_concat(str)
-        @output_buffer.safe_concat(str)
-      end
-    end
-  end
-
-  let(:template) { double("template", virtual_path: "test", identifier: "test.hbs") }
-  let(:context) { context_class.new }
-
-  before do
-    stub_const("TestPresenter", presenter_class)
-  end
-
-  it "strips the `# encoding: *` directive away from the template" do
-    output = render(<<~TEMPLATE)
-      # encoding: utf-8"
-      first line
-    TEMPLATE
-    expect(output).to eq(<<~TEMPLATE)
-
-      first line
-    TEMPLATE
-  end
-
-  it "passes in the presenter context to the presenter class" do
-    allow(context).to receive(:bar).and_return("BAR")
-    output = render("{{bar}}")
-    expect(output).to eq("BAR")
-  end
-
-  it "fails if there's no matching presenter class" do
-    allow(template).to receive(:virtual_path).and_return("missing")
-    expect { render(" FOO ") }.to raise_exception(Curlybars::Error::Presenter::NotFound)
-  end
-
-  it "allows calling public methods on the presenter" do
-    output = render("{{foo}}")
-    expect(output).to eq("FOO")
-  end
-
-  it "marks its output as HTML safe" do
-    output = render("{{foo}}")
-    expect(output).to be_html_safe
-  end
-
-  it "calls the #setup! method before rendering the view" do
-    render("{{foo}}")
-    expect(context.content_for(:foo)).to eq("bar")
-  end
-
-  describe "caching" do
-    before do
-      allow(context).to receive(:bar).and_return("BAR")
-    end
-
-    let(:output) { -> { render("{{bar}}") } }
-
-    it "caches the result with the #cache_key from the presenter" do
-      context.assigns[:cache_key] = "x"
-      expect(output.call).to eq("BAR")
-
-      allow(context).to receive(:bar).and_return("BAZ")
-      expect(output.call).to eq("BAR")
-
-      context.assigns[:cache_key] = "y"
-      expect(output.call).to eq("BAZ")
-    end
-
-    it "doesn't cache when the cache key is nil" do
-      context.assigns[:cache_key] = nil
-      expect(output.call).to eq("BAR")
-
-      allow(context).to receive(:bar).and_return("BAZ")
-      expect(output.call).to eq("BAZ")
-    end
-
-    it "adds the presenter class' cache key to the instance's cache key" do
-      # Make sure caching is enabled
-      context.assigns[:cache_key] = "x"
-
-      allow(presenter_class).to receive(:cache_key).and_return("foo")
-
-      expect(output.call).to eq("BAR")
-
-      allow(presenter_class).to receive(:cache_key).and_return("bar")
-
-      allow(context).to receive(:bar).and_return("FOOBAR")
-      expect(output.call).to eq("FOOBAR")
-    end
-
-    it "expires the cache keys after #cache_duration" do
-      context.assigns[:cache_key] = "x"
-      context.assigns[:cache_duration] = 42
-
-      expect(output.call).to eq("BAR")
-
-      allow(context).to receive(:bar).and_return("FOO")
-
-      # Cached fragment has not yet expired.
-      context.advance_clock(41)
-      expect(output.call).to eq("BAR")
-
-      # Now it has! Huzzah!
-      context.advance_clock(1)
-      expect(output.call).to eq("FOO")
-    end
-
-    it "passes #cache_options to the cache backend" do
-      context.assigns[:cache_key] = "x"
-      context.assigns[:cache_options] = { expires_in: 42 }
-
-      expect(output.call).to eq("BAR")
-
-      allow(context).to receive(:bar).and_return("FOO")
-
-      # Cached fragment has not yet expired.
-      context.advance_clock(41)
-      expect(output.call).to eq("BAR")
-
-      # Now it has! Huzzah!
-      context.advance_clock(1)
-      expect(output.call).to eq("FOO")
-    end
-  end
-
-  def render(source)
-    if ActionView::VERSION::MAJOR < 6
-      allow(template).to receive(:source).and_return(source)
-      code = Curlybars::TemplateHandler.call(template)
-    else
-      code = Curlybars::TemplateHandler.call(template, source)
-    end
-
-    context.reset!
-    context.instance_eval(code)
-  end
-end