curly-templates 2.5.0 → 2.6.0

data/spec/presenter_spec.rb

@@ -1,247 +0,0 @@
-describe Curly::Presenter do
-  class CircusPresenter < Curly::Presenter
-    module MonkeyComponents
-      def monkey
-      end
-    end
-
-    exposes_helper :foo
-
-    include MonkeyComponents
-
-    presents :midget, :clown, default: nil
-    presents :elephant, default: "Dumbo"
-    presents :puma, default: -> { 'block' }
-    presents(:lion) { @elephant.upcase }
-    presents(:something) { self }
-
-    attr_reader :midget, :clown, :elephant, :puma, :lion, :something
-  end
-
-  class FrenchCircusPresenter < CircusPresenter
-    presents :elephant, default: "Babar"
-  end
-
-  class FancyCircusPresenter < CircusPresenter
-    presents :champagne
-  end
-
-  class CircusPresenter::MonkeyPresenter < Curly::Presenter
-  end
-
-  describe "#initialize" do
-    let(:context) { double("context") }
-
-    it "sets the presented identifiers as instance variables" do
-      presenter = CircusPresenter.new(context,
-        midget: "Meek Harolson",
-        clown: "Bubbles"
-      )
-
-      presenter.midget.should == "Meek Harolson"
-      presenter.clown.should == "Bubbles"
-    end
-
-    it "raises an exception if a required identifier is not specified" do
-      expect {
-        FancyCircusPresenter.new(context, {})
-      }.to raise_exception(ArgumentError, "required identifier `champagne` missing")
-    end
-
-    it "allows specifying default values for identifiers" do
-      # Make sure subclasses can change default values.
-      french_presenter = FrenchCircusPresenter.new(context)
-      french_presenter.elephant.should == "Babar"
-      french_presenter.lion.should == 'BABAR'
-      french_presenter.puma.should be_a Proc
-
-      # The subclass shouldn't change the superclass' defaults, though.
-      presenter = CircusPresenter.new(context)
-      presenter.elephant.should == "Dumbo"
-      presenter.lion.should == 'DUMBO'
-      presenter.puma.should be_a Proc
-    end
-
-    it "doesn't call a block if given as a value for identifiers" do
-      lion = proc { 'Simba' }
-      presenter = CircusPresenter.new(context, lion: lion)
-      presenter.lion.should be lion
-    end
-
-    it "calls default blocks in the instance of the presenter" do
-      presenter = CircusPresenter.new(context)
-      presenter.something.should be presenter
-    end
-  end
-
-  describe "#method_missing" do
-    let(:context) { double("context") }
-    subject {
-      CircusPresenter.new(context,
-        midget: "Meek Harolson",
-        clown: "Bubbles")
-    }
-
-    it "delegates calls to the context" do
-      context.should receive(:undefined).once
-      subject.undefined
-    end
-
-    it "allows method calls on context-defined methods" do
-      context.should receive(:respond_to?).
-        with(:undefined, false).once.and_return(true)
-      subject.method(:undefined)
-    end
-  end
-
-  describe ".exposes_helper" do
-    let(:context) { double("context") }
-    subject {
-      CircusPresenter.new(context,
-        midget: "Meek Harolson",
-        clown: "Bubbles")
-    }
-
-    it "allows a method as a component" do
-      CircusPresenter.component_available?(:foo)
-    end
-
-    it "delegates the call to the context" do
-      context.should receive(:foo).once
-      subject.should_not receive(:method_missing)
-      subject.foo
-    end
-
-    it "doesn't delegate other calls to the context" do
-      expect { subject.bar }.to raise_error
-    end
-  end
-
-  describe ".presenter_for_path" do
-    it "returns the presenter class for the given path" do
-      presenter = double("presenter")
-      stub_const("Foo::BarPresenter", presenter)
-
-      Curly::Presenter.presenter_for_path("foo/bar").should == presenter
-    end
-
-    it "returns nil if there is no presenter for the given path" do
-      Curly::Presenter.presenter_for_path("foo/bar").should be_nil
-    end
-
-    it "does not swallow exceptions" do
-      error = NameError.new("omg!", :baz)
-      String.any_instance.stub(:constantize).and_raise(error)
-
-      expect do
-        Curly::Presenter.presenter_for_path("foo/bar")
-      end.to raise_error(NameError)
-    end
-  end
-
-  describe ".presenter_for_name" do
-    it "returns the presenter class for the given name" do
-      CircusPresenter.presenter_for_name("monkey").should == CircusPresenter::MonkeyPresenter
-    end
-
-    it "looks in the namespace" do
-      CircusPresenter.presenter_for_name("french_circus").should == FrenchCircusPresenter
-    end
-
-    it "returns NameError if the presenter class doesn't exist" do
-      expect { CircusPresenter.presenter_for_name("clown") }.to raise_exception(NameError)
-    end
-  end
-
-  describe ".available_components" do
-    it "includes the methods on the presenter" do
-      CircusPresenter.available_components.should include("midget")
-    end
-
-    it "does not include methods on the Curly::Presenter base class" do
-      CircusPresenter.available_components.should_not include("cache_key")
-    end
-  end
-
-  describe ".component_available?" do
-    it "returns true if the method is available" do
-      CircusPresenter.component_available?("midget").should == true
-    end
-
-    it "returns false if the method is not available" do
-      CircusPresenter.component_available?("bear").should == false
-    end
-  end
-
-  describe ".version" do
-    it "sets the version of the presenter" do
-      presenter1 = Class.new(Curly::Presenter) do
-        version 42
-      end
-
-      presenter2 = Class.new(Curly::Presenter) do
-        version 1337
-      end
-
-      presenter1.version.should == 42
-      presenter2.version.should == 1337
-    end
-
-    it "returns 0 if no version has been set" do
-      presenter = Class.new(Curly::Presenter)
-      presenter.version.should == 0
-    end
-  end
-
-  describe ".cache_key" do
-    it "includes the presenter's class name and version" do
-      presenter = Class.new(Curly::Presenter) { version 42 }
-      stub_const("Foo::BarPresenter", presenter)
-
-      Foo::BarPresenter.cache_key.should == "Foo::BarPresenter/42"
-    end
-
-    it "includes the cache keys of presenters in the dependency list" do
-      presenter = Class.new(Curly::Presenter) do
-        version 42
-        depends_on 'foo/bum'
-      end
-
-      dependency = Class.new(Curly::Presenter) do
-        version 1337
-      end
-
-      stub_const("Foo::BarPresenter", presenter)
-      stub_const("Foo::BumPresenter", dependency)
-
-      cache_key = Foo::BarPresenter.cache_key
-      cache_key.should == "Foo::BarPresenter/42/Foo::BumPresenter/1337"
-    end
-
-    it "uses the view path of a dependency if there is no presenter for it" do
-      presenter = Class.new(Curly::Presenter) do
-        version 42
-        depends_on 'foo/bum'
-      end
-
-      stub_const("Foo::BarPresenter", presenter)
-
-      cache_key = Foo::BarPresenter.cache_key
-      cache_key.should == "Foo::BarPresenter/42/foo/bum"
-    end
-  end
-
-  describe ".dependencies" do
-    it "returns the dependencies defined for the presenter" do
-      presenter = Class.new(Curly::Presenter) { depends_on 'foo' }
-      presenter.dependencies.to_a.should == ['foo']
-    end
-
-    it "includes the dependencies defined for parent classes" do
-      Curly::Presenter.dependencies
-      parent = Class.new(Curly::Presenter) { depends_on 'foo' }
-      presenter = Class.new(parent) { depends_on 'bar' }
-      presenter.dependencies.to_a.should =~ ['foo', 'bar']
-    end
-  end
-end

data/spec/scanner_spec.rb

@@ -1,124 +0,0 @@
-describe Curly::Scanner, ".scan" do
-  it "returns the tokens in the source" do
-    scan("foo {{bar}} baz").should == [
-      [:text, "foo "],
-      [:component, "bar", nil, {}, []],
-      [:text, " baz"]
-    ]
-  end
-
-  it "scans components with identifiers" do
-    scan("{{foo.bar}}").should == [
-      [:component, "foo", "bar", {}, []]
-    ]
-  end
-
-  it "scans comments in the source" do
-    scan("foo {{!bar}} baz").should == [
-      [:text, "foo "],
-      [:comment, "bar"],
-      [:text, " baz"]
-    ]
-  end
-
-  it "allows newlines in comments" do
-    scan("{{!\nfoo\n}}").should == [
-      [:comment, "\nfoo\n"]
-    ]
-  end
-
-  it "scans to the end of the source" do
-    scan("foo\n").should == [
-      [:text, "foo\n"]
-    ]
-  end
-
-  it "allows escaping Curly quotes" do
-    scan('foo {{{ bar').should == [
-      [:text, "foo "],
-      [:text, "{{"],
-      [:text, " bar"]
-    ]
-
-    scan('foo }} bar').should == [
-      [:text, "foo }} bar"]
-    ]
-
-    scan('foo {{{ lala! }} bar').should == [
-      [:text, "foo "],
-      [:text, "{{"],
-      [:text, " lala! }} bar"]
-    ]
-  end
-
-  it "scans context block tags" do
-    scan('{{@search_form}}{{query_field}}{{/search_form}}').should == [
-      [:context_block_start, "search_form", nil, {}, []],
-      [:component, "query_field", nil, {}, []],
-      [:block_end, "search_form", nil, {}, []]
-    ]
-  end
-
-  it "scans conditional block tags" do
-    scan('foo {{#bar?}} hello {{/bar?}}').should == [
-      [:text, "foo "],
-      [:conditional_block_start, "bar?", nil, {}, []],
-      [:text, " hello "],
-      [:block_end, "bar?", nil, {}, []]
-    ]
-  end
-
-  it "scans conditional block tags with parameters and attributes" do
-    scan('{{#active.test? name="test"}}yo{{/active.test?}}').should == [
-      [:conditional_block_start, "active?", "test", { "name" => "test" }, []],
-      [:text, "yo"],
-      [:block_end, "active?", "test", {}, []]
-    ]
-  end
-
-  it "scans inverse block tags" do
-    scan('foo {{^bar?}} hello {{/bar?}}').should == [
-      [:text, "foo "],
-      [:inverse_conditional_block_start, "bar?", nil, {}, []],
-      [:text, " hello "],
-      [:block_end, "bar?", nil, {}, []]
-    ]
-  end
-
-  it "scans collection block tags" do
-    scan('foo {{*bar}} hello {{/bar}}').should == [
-      [:text, "foo "],
-      [:collection_block_start, "bar", nil, {}, []],
-      [:text, " hello "],
-      [:block_end, "bar", nil, {}, []]
-    ]
-  end
-
-  it "treats quotes as text" do
-    scan('"').should == [
-      [:text, '"']
-    ]
-  end
-
-  it "treats Ruby interpolation as text" do
-    scan('#{foo}').should == [
-      [:text, '#{foo}']
-    ]
-  end
-
-  it "raises Curly::SyntaxError on unclosed components" do
-    ["{{", "{{yolo"].each do |template|
-      expect { scan(template) }.to raise_error(Curly::SyntaxError)
-    end
-  end
-
-  it "raises Curly::SyntaxError on unclosed comments" do
-    ["{{!", "{{! foo bar"].each do |template|
-      expect { scan(template) }.to raise_error(Curly::SyntaxError)
-    end
-  end
-
-  def scan(source)
-    Curly::Scanner.scan(source)
-  end
-end

data/spec/spec_helper.rb

@@ -1,45 +0,0 @@
-ENV["RAILS_ENV"] = "test"
-
-require 'dummy/config/environment'
-require 'rspec/rails'
-
-RSpec.configure do |config|
-  config.infer_spec_type_from_file_location!
-end
-
-module CompilationSupport
-  def define_presenter(name = "ShowPresenter", &block)
-    presenter_class = Class.new(Curly::Presenter, &block)
-    stub_const(name, presenter_class)
-    presenter_class
-  end
-
-  def render(source, options = {}, &block)
-    presenter = options.fetch(:presenter) do
-      define_presenter("ShowPresenter") unless defined?(ShowPresenter)
-      "ShowPresenter"
-    end.constantize
-
-    virtual_path = options.fetch(:virtual_path) do
-      presenter.name.underscore.gsub(/_presenter\z/, "")
-    end
-
-    identifier = options.fetch(:identifier) do
-      defined?(Rails.root) ? "#{Rails.root}/#{virtual_path}.html.curly" : virtual_path
-    end
-
-    details = { virtual_path: virtual_path }
-    details.merge! options.fetch(:details, {})
-
-    handler = Curly::TemplateHandler
-    template = ActionView::Template.new(source, identifier, handler, details)
-    view = ActionView::Base.new
-    view.lookup_context.stub(:find_template) { source }
-
-    begin
-      template.render(view, options.fetch(:locals, {}), &block)
-    rescue ActionView::Template::Error => e
-      raise e.original_exception
-    end
-  end
-end

data/spec/syntax_error_spec.rb

@@ -1,12 +0,0 @@
-describe Curly::SyntaxError, "#message" do
-  it "includes the context of the error in the message" do
-    source = "I am a very bad error that has snuck in"
-    error = Curly::SyntaxError.new(13, source)
-
-    error.message.should == <<-MESSAGE.strip_heredoc
-      invalid syntax near `a very bad error` on line 1 in template:
-
-      I am a very bad error that has snuck in
-    MESSAGE
-  end
-end

data/spec/template_handler_spec.rb

@@ -1,209 +0,0 @@
-describe Curly::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 self.component_available?(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") }
-  let(:context) { context_class.new }
-
-  before do
-    stub_const("TestPresenter", presenter_class)
-  end
-
-  it "passes in the presenter context to the presenter class" do
-    context.stub(:bar) { "BAR" }
-    template.stub(:source) { "{{bar}}" }
-    output.should == "BAR"
-  end
-
-  it "should fail if there's no matching presenter class" do
-    template.stub(:virtual_path) { "missing" }
-    template.stub(:source) { " FOO " }
-    expect { output }.to raise_exception(Curly::PresenterNotFound)
-  end
-
-  it "allows calling public methods on the presenter" do
-    template.stub(:source) { "{{foo}}" }
-    output.should == "FOO"
-  end
-
-  it "marks its output as HTML safe" do
-    template.stub(:source) { "{{foo}}" }
-    output.should be_html_safe
-  end
-
-  it "calls the #setup! method before rendering the view" do
-    template.stub(:source) { "{{foo}}" }
-    output
-    context.content_for(:foo).should == "bar"
-  end
-
-  context "caching" do
-    before do
-      template.stub(:source) { "{{bar}}" }
-      context.stub(:bar) { "BAR" }
-    end
-
-    it "caches the result with the #cache_key from the presenter" do
-      context.assigns[:cache_key] = "x"
-      output.should == "BAR"
-
-      context.stub(:bar) { "BAZ" }
-      output.should == "BAR"
-
-      context.assigns[:cache_key] = "y"
-      output.should == "BAZ"
-    end
-
-    it "doesn't cache when the cache key is nil" do
-      context.assigns[:cache_key] = nil
-      output.should == "BAR"
-
-      context.stub(:bar) { "BAZ" }
-      output.should == "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"
-
-      presenter_class.stub(:cache_key) { "foo" }
-
-      output.should == "BAR"
-
-      presenter_class.stub(:cache_key) { "bar" }
-
-      context.stub(:bar) { "FOOBAR" }
-      output.should == "FOOBAR"
-    end
-
-    it "expires the cache keys after #cache_duration" do
-      context.assigns[:cache_key] = "x"
-      context.assigns[:cache_duration] = 42
-
-      output.should == "BAR"
-
-      context.stub(:bar) { "FOO" }
-
-      # Cached fragment has not yet expired.
-      context.advance_clock(41)
-      output.should == "BAR"
-
-      # Now it has! Huzzah!
-      context.advance_clock(1)
-      output.should == "FOO"
-    end
-
-    it "passes #cache_options to the cache backend" do
-      context.assigns[:cache_key] = "x"
-      context.assigns[:cache_options] = { expires_in: 42 }
-
-      output.should == "BAR"
-
-      context.stub(:bar) { "FOO" }
-
-      # Cached fragment has not yet expired.
-      context.advance_clock(41)
-      output.should == "BAR"
-
-      # Now it has! Huzzah!
-      context.advance_clock(1)
-      output.should == "FOO"
-    end
-  end
-
-  def output
-    code = Curly::TemplateHandler.call(template)
-    context.reset!
-    context.instance_eval(code)
-  end
-end