curlybars 0.9.13

data/spec/curlybars/safe_buffer_spec.rb

@@ -0,0 +1,46 @@
+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) { 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) { 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) { 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

@@ -0,0 +1,222 @@
+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
+    allow(template).to receive(:source) do
+      <<-TEMPLATE.strip_heredoc
+        # encoding: utf-8"
+        first line
+      TEMPLATE
+    end
+    expect(output).to eq(<<-TEMPLATE.strip_heredoc)
+
+      first line
+    TEMPLATE
+  end
+
+  it "passes in the presenter context to the presenter class" do
+    allow(context).to receive(:bar) { "BAR" }
+    allow(template).to receive(:source) { "{{bar}}" }
+    expect(output).to eq("BAR")
+  end
+
+  it "fails if there's no matching presenter class" do
+    allow(template).to receive(:virtual_path) { "missing" }
+    allow(template).to receive(:source) { " FOO " }
+    expect { output }.to raise_exception(Curlybars::Error::Presenter::NotFound)
+  end
+
+  it "allows calling public methods on the presenter" do
+    allow(template).to receive(:source) { "{{foo}}" }
+    expect(output).to eq("FOO")
+  end
+
+  it "marks its output as HTML safe" do
+    allow(template).to receive(:source) { "{{foo}}" }
+    expect(output).to be_html_safe
+  end
+
+  it "calls the #setup! method before rendering the view" do
+    allow(template).to receive(:source) { "{{foo}}" }
+    output
+    expect(context.content_for(:foo)).to eq("bar")
+  end
+
+  context "caching" do
+    before do
+      allow(template).to receive(:source) { "{{bar}}" }
+      allow(context).to receive(:bar) { "BAR" }
+    end
+
+    it "caches the result with the #cache_key from the presenter" do
+      context.assigns[:cache_key] = "x"
+      expect(output).to eq("BAR")
+
+      allow(context).to receive(:bar) { "BAZ" }
+      expect(output).to eq("BAR")
+
+      context.assigns[:cache_key] = "y"
+      expect(output).to eq("BAZ")
+    end
+
+    it "doesn't cache when the cache key is nil" do
+      context.assigns[:cache_key] = nil
+      expect(output).to eq("BAR")
+
+      allow(context).to receive(:bar) { "BAZ" }
+      expect(output).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) { "foo" }
+
+      expect(output).to eq("BAR")
+
+      allow(presenter_class).to receive(:cache_key) { "bar" }
+
+      allow(context).to receive(:bar) { "FOOBAR" }
+      expect(output).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).to eq("BAR")
+
+      allow(context).to receive(:bar) { "FOO" }
+
+      # Cached fragment has not yet expired.
+      context.advance_clock(41)
+      expect(output).to eq("BAR")
+
+      # Now it has! Huzzah!
+      context.advance_clock(1)
+      expect(output).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).to eq("BAR")
+
+      allow(context).to receive(:bar) { "FOO" }
+
+      # Cached fragment has not yet expired.
+      context.advance_clock(41)
+      expect(output).to eq("BAR")
+
+      # Now it has! Huzzah!
+      context.advance_clock(1)
+      expect(output).to eq("FOO")
+    end
+  end
+
+  def output
+    code = Curlybars::TemplateHandler.call(template)
+    context.reset!
+    context.instance_eval(code)
+  end
+end

data/spec/integration/cache_spec.rb

@@ -0,0 +1,124 @@
+describe "caching" do
+  class DummyCache
+    attr_reader :reads, :hits
+
+    def initialize
+      @store = {}
+      @reads = 0
+      @hits = 0
+    end
+
+    def fetch(key)
+      @reads += 1
+      if @store.key?(key)
+        @hits += 1
+        @store[key]
+      else
+        value = yield
+        @store[key] = value
+        value
+      end
+    end
+  end
+
+  let(:global_helpers_providers) { [] }
+  let(:presenter) { IntegrationTest::Presenter.new(double("view_context")) }
+  let(:cache) { DummyCache.new }
+
+  before do
+    Curlybars.configure do |config|
+      config.cache = cache.method(:fetch)
+    end
+  end
+
+  after do
+    Curlybars.reset
+  end
+
+  describe "{{#each}}" do
+    it "invokes cache if presenter responds to #cache_key" do
+      template = Curlybars.compile(<<-HBS)
+        {{#each array_of_users}}{{/each}}
+      HBS
+
+      eval(template)
+
+      expect(cache.reads).to eq(1)
+      expect(cache.hits).to eq(0)
+    end
+
+    it "reuses cached values" do
+      template = Curlybars.compile(<<-HBS)
+        {{#each array_of_users}}
+          a
+        {{/each}}
+
+        {{#each array_of_users}}
+          a
+        {{/each}}
+      HBS
+
+      eval(template)
+
+      expect(cache.reads).to eq(2)
+      expect(cache.hits).to eq(1)
+    end
+
+    it "generates unique cache keys per template" do
+      template = Curlybars.compile(<<-HBS)
+        {{#each array_of_users}}
+          a
+        {{/each}}
+
+        {{#each array_of_users}}
+          b
+        {{/each}}
+      HBS
+
+      eval(template)
+
+      expect(cache.reads).to eq(2)
+      expect(cache.hits).to eq(0)
+    end
+
+    it "produces correct output from cached presenters" do
+      template = Curlybars.compile(<<-HBS)
+        {{#each array_of_users}}
+          - {{first_name}}
+        {{/each}}
+      HBS
+
+      expect(eval(template)).to resemble(<<-HTML)
+        - Libo
+      HTML
+    end
+
+    it "works for empty templates" do
+      template = Curlybars.compile(<<-HBS)
+        before
+        {{#each array_of_users}}{{/each}}
+        {{#each array_of_users}}{{/each}}
+        after
+      HBS
+
+      expect(eval(template)).to resemble(<<-HTML)
+        before
+        after
+      HTML
+    end
+
+    it "leaves variables and contexts in correct state after a cache hit" do
+      template = Curlybars.compile(<<-HBS)
+        {{#each array_of_users}}a{{/each}}
+        {{#each array_of_users}}a{{/each}}
+        {{context}}
+      HBS
+
+      expect(eval(template)).to resemble(<<-HTML)
+        a
+        a
+        root_context
+      HTML
+    end
+  end
+end

data/spec/integration/comment_spec.rb

@@ -0,0 +1,60 @@
+describe "{{!-- --}} and {{! }}" do
+  let(:post) { double("post") }
+  let(:presenter) { IntegrationTest::Presenter.new(double("view_context"), post: post) }
+  let(:global_helpers_providers) { [] }
+
+  it "ignores one line comment" do
+    template = Curlybars.compile(<<-HBS)
+      before{{! This is a comment }}after
+    HBS
+
+    expect(eval(template)).to resemble(<<-HTML)
+      before after
+    HTML
+  end
+
+  it "ignores multi line comment" do
+    template = Curlybars.compile(<<-HBS)
+      before
+      {{! 2 lines
+        lines }}
+      after
+    HBS
+
+    expect(eval(template)).to resemble(<<-HTML)
+      before after
+    HTML
+  end
+
+  it "ignores multi lines with curly inside comment" do
+    template = Curlybars.compile(<<-HBS)
+      before
+      {{!
+        And another one
+        in
+        3 lines
+        }
+      }}
+      after
+    HBS
+
+    expect(eval(template)).to resemble(<<-HTML)
+      before after
+    HTML
+  end
+
+  it "ignores multi line comment with {{!-- --}}" do
+    template = Curlybars.compile(<<-HBS)
+      before
+      {{!--
+        And this is the {{ test }} other style
+        }}
+      --}}
+      after
+    HBS
+
+    expect(eval(template)).to resemble(<<-HTML)
+      before after
+    HTML
+  end
+end