curly-templates 2.3.2 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d5d6cde1c07741229dc8ea78114e54af3f8203c1
-  data.tar.gz: c06295601f10d2b265334ef2e3a67255fd00b3f6
+  metadata.gz: 8f4fe4c21493bebaaa569720e2a43f78e2d80438
+  data.tar.gz: 24606b4dc84bf910492ae70e9264c4887c463b6e
 SHA512:
-  metadata.gz: bff53c1b1165f5fbbf2882a172ac47b274bae2b9a635c757870b226e0087ebaeab035b856c55c33cde288d74999d9d5d5dd034d272faecaba8eb0b5319a2b30c
-  data.tar.gz: 3907be2a2506af3b65c0d2cdb787b83472f2b35d60f3dcef649fb1234585d9eca08714875b7ab975c9bacd16ec17f7aabf80a1e795b57e75626d0b511d2ed0a6
+  metadata.gz: 0213f00bcaf7842aa05ef052dd6ceb74b7b4c03b7ee7cfe546df3ba4e77cc73d57b2c5c5d46a89544567e6ec5fcfe98d2b9297953ffed8eb0a0abceb64aba96b
+  data.tar.gz: 231542411d1447d7b2139f4637f1d40014e14ee19b1313bf2f05c65ff17608faf658f26750024373ff03d3cae179d57989c9716480dd43b836e36dca41652187

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 ### Unreleased
 
+### Curly 2.4.0 (February 24, 2015)
+
+* Add an `exposes_helper` class methods to Curly::Presenter. This allows exposing
+  helper methods as components.
+
+  *Jeremy Rodi*
+
+* Add a shorthand syntax for using components within a context. This allows you
+  to write `{{author:name}}` rather than `{{@author}}{{name}}{{/author}}`.
+
+  *Daniel Schierbeck*
+
 ### Curly 2.3.2 (January 13, 2015)
 
 * Fix an issue that caused presenter parameters to get mixed up.

data/README.md

@@ -11,16 +11,17 @@ to a presenter class.
 1. [Installing](#installing)
 2. [How to use Curly](#how-to-use-curly)
     1. [Identifiers](#identifiers)
-    1. [Attributes](#attributes)
-    1. [Conditional blocks](#conditional-blocks)
-    1. [Collection blocks](#collection-blocks)
-    1. [Context blocks](#context-blocks)
-    1. [Setting up state](#setting-up-state)
-    2. [Escaping Curly syntax](#escaping-curly-syntax)
-    2. [Comments](#comments)
+    2. [Attributes](#attributes)
+    3. [Conditional blocks](#conditional-blocks)
+    4. [Collection blocks](#collection-blocks)
+    5. [Context blocks](#context-blocks)
+    6. [Setting up state](#setting-up-state)
+    7. [Escaping Curly syntax](#escaping-curly-syntax)
+    8. [Comments](#comments)
 3. [Presenters](#presenters)
-    1. [Layouts and Content Blocks](#layouts-and-content-blocks)
-    2. [Examples](#examples)
+    1. [Layouts and content blocks](#layouts-and-content-blocks)
+    2. [Rails helper methods](#rails-helper-methods)
+    3. [Examples](#examples)
 4. [Caching](#caching)
 
 
@@ -327,6 +328,22 @@ def author(&block)
 end
 ```
 
+#### Context shorthand syntax
+
+If you find yourself opening a context block just in order to use a single component,
+e.g. `{{@author}}{{name}}{{/author}}`, you can use the _shorthand syntax_ instead:
+`{{author:name}}`. This works for all component types, e.g.
+
+```html
+{{#author:admin?}}
+  <p>The author is an admin!</p>
+{{/author:admin?}}
+```
+
+The syntax works for nested contexts as well, e.g. `{{comment:author:name}}`. Any
+identifier and attributes are passed to the target component, which in this example
+would be `{{name}}`.
+
 
 ### Setting up state
 
@@ -439,7 +456,7 @@ have any side effects, though, as an important part of Curly is the idempotence
 templates.
 
 
-### Layouts and Content Blocks
+### Layouts and content blocks
 
 Both layouts and content blocks (see [`content_for`](http://api.rubyonrails.org/classes/ActionView/Helpers/CaptureHelper.html#method-i-content_for))
 use `yield` to signal that content can be inserted. Curly works just like ERB, so calling
@@ -478,6 +495,19 @@ end
 ```
 
 
+### Rails helper methods
+
+In order to make a Rails helper method available as a component in your template,
+use the `exposes_helper` method:
+
+```ruby
+class Layouts::ApplicationPresenter < Curly::Presenter
+  # The components {{sign_in_path}} and {{root_path}} are made available.
+  exposes_helper :sign_in_path, :root_path
+end
+```
+
+
 ### Examples
 
 Here is a simple Curly template – it will be looked up by Rails automatically.
@@ -667,6 +697,7 @@ Thanks to [Zendesk](http://zendesk.com/) for sponsoring the work on Curly.
 - Jeremy Rodi ([@redjazz96](https://github.com/redjazz96))
 - Alisson Cavalcante Agiani ([@thelinuxlich](https://github.com/thelinuxlich))
 - Łukasz Niemier ([@hauleth](https://github.com/hauleth))
+- Cristian Planas ([@Gawyn](https://github.com/Gawyn))
 
 
 Build Status

data/curly-templates.gemspec

@@ -4,8 +4,8 @@ Gem::Specification.new do |s|
   s.rubygems_version = '1.3.5'
 
   s.name              = 'curly-templates'
-  s.version           = '2.3.2'
-  s.date              = '2015-01-13'
+  s.version           = '2.4.0'
+  s.date              = '2015-02-24'
 
   s.summary     = "Free your views!"
   s.description = "A view layer for your Rails apps that separates structure and logic."

data/lib/curly.rb

@@ -25,7 +25,7 @@
 #
 # See Curly::Presenter for more information on presenters.
 module Curly
-  VERSION = "2.3.2"
+  VERSION = "2.4.0"
 
   # Compiles a Curly template to Ruby code.
   #

data/lib/curly/compiler.rb

@@ -107,7 +107,7 @@ module Curly
         items = Array(#{method_call})
         items.each_with_index do |item, index|
           options = options.merge("#{name}" => item, "#{counter}" => index + 1)
-          presenter = #{item_presenter_class}.new(self, options)
+          presenter = ::#{item_presenter_class}.new(self, options)
       RUBY
 
       @presenter_classes.push(item_presenter_class)
@@ -160,7 +160,7 @@ module Curly
         buffer << #{method_call} do |item|
           options = options.merge("#{name}" => item)
           buffer = ActiveSupport::SafeBuffer.new
-          presenter = #{item_presenter_class}.new(self, options)
+          presenter = ::#{item_presenter_class}.new(self, options)
       RUBY
 
       @presenter_classes.push(item_presenter_class)

data/lib/curly/component_scanner.rb

@@ -4,7 +4,10 @@ module Curly
   class ComponentScanner
     def self.scan(component)
       first, rest = component.strip.split(/\s+/, 2)
-      name, identifier = first.split(".", 2)
+      contexts = first.split(":")
+      name_and_identifier = contexts.pop
+
+      name, identifier = name_and_identifier.split(".", 2)
 
       if identifier && identifier.end_with?("?")
         name += "?"
@@ -13,7 +16,7 @@ module Curly
 
       attributes = AttributeScanner.scan(rest)
 
-      [name, identifier, attributes]
+      [name, identifier, attributes, contexts]
     end
   end
 end

data/lib/curly/parser.rb

@@ -3,20 +3,21 @@ require 'curly/incorrect_ending_error'
 
 class Curly::Parser
   class Component
-    attr_reader :name, :identifier, :attributes
+    attr_reader :name, :identifier, :attributes, :contexts
 
-    def initialize(name, identifier = nil, attributes = {})
-      @name, @identifier, @attributes = name, identifier, attributes
+    def initialize(name, identifier = nil, attributes = {}, contexts = [])
+      @name, @identifier, @attributes, @contexts = name, identifier, attributes, contexts
     end
 
     def to_s
-      [name, identifier].compact.join(".")
+      contexts.map {|c| c + ":" }.join << [name, identifier].compact.join(".")
     end
 
     def ==(other)
       other.name == name &&
         other.identifier == identifier &&
-        other.attributes == attributes
+        other.attributes == attributes &&
+        other.contexts == contexts
     end
 
     def type
@@ -77,7 +78,8 @@ class Curly::Parser
 
     def closed_by?(component)
       self.component.name == component.name &&
-        self.component.identifier == component.identifier
+        self.component.identifier == component.identifier &&
+        self.component.contexts == component.contexts
     end
 
     def to_s
@@ -125,7 +127,20 @@ class Curly::Parser
   end
 
   def parse_component(*args)
-    tree << Component.new(*args)
+    component = Component.new(*args)
+
+    # If the component is namespaced by a list of context names, open a context
+    # block for each.
+    component.contexts.each do |context|
+      parse_context_block_start(context)
+    end
+
+    tree << component
+
+    # Close each context block in the namespace.
+    component.contexts.reverse.each do |context|
+      parse_block_end(context)
+    end
   end
 
   def parse_conditional_block_start(*args)
@@ -146,6 +161,11 @@ class Curly::Parser
 
   def parse_block(type, *args)
     component = Component.new(*args)
+
+    component.contexts.each do |context|
+      parse_context_block_start(context)
+    end
+
     block = Block.new(type, component)
     tree << block
     @stack.push(block)
@@ -159,6 +179,10 @@ class Curly::Parser
       raise Curly::IncorrectEndingError,
         "block `#{block}` cannot be closed by `#{component}`"
     end
+
+    component.contexts.reverse.each do |context|
+      parse_block_end(context)
+    end
   end
 
   def parse_comment(comment)

data/lib/curly/presenter.rb

@@ -292,6 +292,16 @@ module Curly
           self.default_values = self.default_values.merge(default_values)
         end
       end
+
+      def exposes_helper(*methods)
+        methods.each do |method_name|
+          define_method(method_name) do |*args|
+            @_context.public_send(method_name, *args)
+          end
+        end
+      end
+
+      alias_method :exposes_helpers, :exposes_helper
     end
 
     private

data/lib/curly/scanner.rb

@@ -95,45 +95,45 @@ module Curly
 
     def scan_conditional_block_start
       if value = scan_until_end_of_curly
-        name, identifier, attributes = ComponentScanner.scan(value)
+        name, identifier, attributes, contexts = ComponentScanner.scan(value)
 
-        [:conditional_block_start, name, identifier, attributes]
+        [:conditional_block_start, name, identifier, attributes, contexts]
       end
     end
 
     def scan_context_block_start
       if value = scan_until_end_of_curly
-        name, identifier, attributes = ComponentScanner.scan(value)
+        name, identifier, attributes, contexts = ComponentScanner.scan(value)
 
-        [:context_block_start, name, identifier, attributes]
+        [:context_block_start, name, identifier, attributes, contexts]
       end
     end
 
     def scan_collection_block_start
       if value = scan_until_end_of_curly
-        name, identifier, attributes = ComponentScanner.scan(value)
-        [:collection_block_start, name, identifier, attributes]
+        name, identifier, attributes, contexts = ComponentScanner.scan(value)
+        [:collection_block_start, name, identifier, attributes, contexts]
       end
     end
 
     def scan_inverse_block_start
       if value = scan_until_end_of_curly
-        name, identifier, attributes = ComponentScanner.scan(value)
-        [:inverse_conditional_block_start, name, identifier, attributes]
+        name, identifier, attributes, contexts = ComponentScanner.scan(value)
+        [:inverse_conditional_block_start, name, identifier, attributes, contexts]
       end
     end
 
     def scan_block_end
       if value = scan_until_end_of_curly
-        name, identifier, attributes = ComponentScanner.scan(value)
-        [:block_end, name, identifier]
+        name, identifier, attributes, contexts = ComponentScanner.scan(value)
+        [:block_end, name, identifier, {}, contexts]
       end
     end
 
     def scan_component
       if value = scan_until_end_of_curly
-        name, identifier, attributes = ComponentScanner.scan(value)
-        [:component, name, identifier, attributes]
+        name, identifier, attributes, contexts = ComponentScanner.scan(value)
+        [:component, name, identifier, attributes, contexts]
       end
     end
 

data/spec/compiler/collections_spec.rb

@@ -19,7 +19,8 @@ describe Curly::Compiler do
       item2 = double("item2", name: "bar")
 
       template = "<ul>{{*items}}<li>{{name}}</li>{{/items}}</ul>"
-      expect(render(template, items: [item1, item2])).to eql "<ul><li>foo</li><li>bar</li></ul>"
+      expect(render(template, locals: { items: [item1, item2] })).
+        to eql "<ul><li>foo</li><li>bar</li></ul>"
     end
 
     it "allows attributes on collection blocks" do
@@ -39,7 +40,8 @@ describe Curly::Compiler do
       item2 = double("item2", name: "bar", status: "inactive")
 
       template = "<ul>{{*items status=active}}<li>{{name}}</li>{{/items}}</ul>"
-      expect(render(template, items: [item1, item2])).to eql "<ul><li>foo</li></ul>"
+      expect(render(template, locals: { items: [item1, item2] })).
+        to eql "<ul><li>foo</li></ul>"
     end
 
     it "fails if the component doesn't support enumeration" do
@@ -84,7 +86,8 @@ describe Curly::Compiler do
       item2 = double("item2")
 
       template = "<ul>{{*items}}<li>{{index}}</li>{{/items}}</ul>"
-      expect(render(template, items: [item1, item2])).to eql "<ul><li>1</li><li>2</li></ul>"
+      expect(render(template, locals: { items: [item1, item2] })).
+        to eql "<ul><li>1</li><li>2</li></ul>"
     end
 
     it "restores the previous scope after exiting the collection block" do
@@ -111,7 +114,8 @@ describe Curly::Compiler do
       item = double("item", name: "foo", parts: [part])
 
       template = "{{*items}}{{*parts}}{{identifier}}{{/parts}}{{name}}{{/items}}{{title}}"
-      expect(render(template, items: [item])).to eql "XfooInventory"
+      expect(render(template, locals: { items: [item] })).
+        to eql "XfooInventory"
     end
 
     it "passes the parent presenter's options to the nested presenter" do
@@ -130,7 +134,8 @@ describe Curly::Compiler do
       item2 = double(name: "bar")
 
       template = "{{*items}}{{prefix}}: {{name}}; {{/items}}"
-      expect(render(template, prefix: "SKU", items: [item1, item2])).to eql "SKU: foo; SKU: bar; "
+      expect(render(template, locals: { prefix: "SKU", items: [item1, item2] })).
+        to eql "SKU: foo; SKU: bar; "
     end
 
     it "compiles nested collection blocks" do
@@ -153,7 +158,8 @@ describe Curly::Compiler do
       item2 = double("item2", name: "item2", parts: [double(identifier: "C"), double(identifier: "D")])
 
       template = "{{*items}}{{name}}: {{*parts}}{{identifier}}{{/parts}}; {{/items}}"
-      expect(render(template, items: [item1, item2])).to eql "item1: AB; item2: CD; "
+      expect(render(template, locals: { items: [item1, item2] })).
+        to eql "item1: AB; item2: CD; "
     end
   end
 
@@ -169,7 +175,7 @@ describe Curly::Compiler do
         end
 
         def comment(&block)
-          block.call("viagra!")
+          block.call("foo!")
         end
 
         def form(&block)
@@ -190,13 +196,35 @@ describe Curly::Compiler do
     it "allows re-using assign names in collection blocks" do
       options = { "comment" => "first post!" }
       template = "{{*comments}}{{/comments}}{{@form}}{{comment}}{{/form}}"
-      expect(render(template, options)).to eql "first post!"
+      expect(render(template, locals: options)).to eql "first post!"
     end
 
     it "allows re-using assign names in context blocks" do
       options = { "comment" => "first post!" }
       template = "{{@comment}}{{/comment}}{{@form}}{{comment}}{{/form}}"
-      expect(render(template, options)).to eql "first post!"
+      expect(render(template, locals: options)).to eql "first post!"
+    end
+  end
+
+  context "using namespaced names" do
+    before do
+      define_presenter "Layouts::ShowPresenter" do
+        def comments
+          ["hello", "world"]
+        end
+      end
+
+      define_presenter "Layouts::ShowPresenter::CommentPresenter" do
+        presents :comment
+
+        attr_reader :comment
+      end
+    end
+
+    it "renders correctly" do
+      template = "{{*comments}}{{comment}} {{/comments}}"
+      expect(render(template, presenter: "Layouts::ShowPresenter")).
+        to eql "hello world "
     end
   end
 end

data/spec/compiler/context_blocks_spec.rb

@@ -22,11 +22,34 @@ describe Curly::Compiler do
       def field
         %(<input type="text" value="#{@text_field.upcase}">).html_safe
       end
+
+      def value?
+        true
+      end
     end
 
     render('{{@form}}{{@text_field}}{{field}}{{/text_field}}{{/form}}').should == '<form><input type="text" value="YO"></form>'
   end
 
+  it "compiles using the right presenter" do
+    define_presenter "Layouts::SomePresenter" do
+
+      def contents(&block)
+        block.call("hello, world")
+      end
+    end
+
+    define_presenter "Layouts::SomePresenter::ContentsPresenter" do
+      presents :contents
+
+      def contents
+        @contents
+      end
+    end
+
+    render("foo: {{@contents}}{{contents}}{{/contents}}", presenter: "Layouts::SomePresenter").should == 'foo: hello, world'
+  end
+
   it "fails if the component is not a context block" do
     define_presenter do
       def form
@@ -48,4 +71,36 @@ describe Curly::Compiler do
       render('{{@dust}}{{/dust}}')
     }.to raise_exception(Curly::Error)
   end
+
+  it "fails if the component is not a context block" do
+    expect { render('{{@invalid}}yo{{/invalid}}') }.to raise_exception(Curly::Error)
+  end
+
+  it "compiles shorthand context components" do
+    define_presenter do
+      def tree(&block)
+        yield
+      end
+    end
+
+    define_presenter "TreePresenter" do
+      def branch(&block)
+        yield
+      end
+    end
+
+    define_presenter "BranchPresenter" do
+      def leaf
+        "leaf"
+      end
+    end
+
+    render('{{tree:branch:leaf}}').should == "leaf"
+  end
+
+  it "requires shorthand blocks to be closed with the same set of namespaces" do
+    expect do
+      render('{{#tree:branch}}{{/branch}}{{/tree}}')
+    end.to raise_exception(Curly::IncorrectEndingError)
+  end
 end

data/spec/component_scanner_spec.rb

@@ -3,19 +3,30 @@ describe Curly::ComponentScanner do
     scan('hello.world weather="sunny"').should == [
       "hello",
       "world",
-      { "weather" => "sunny" }
+      { "weather" => "sunny" },
+      []
+    ]
+  end
+
+  it "allows context namespaces" do
+    scan('island:beach:hello.world').should == [
+      "hello",
+      "world",
+      {},
+      ["island", "beach"]
     ]
   end
 
   it "allows a question mark after the identifier" do
-    scan('hello.world?').should == ["hello?", "world", {}]
+    scan('hello.world?').should == ["hello?", "world", {}, []]
   end
 
   it 'allows spaces before and after component' do
     scan('  hello.world weather="sunny"   ').should == [
       "hello",
       "world",
-      { "weather" => "sunny" }
+      { "weather" => "sunny" },
+      []
     ]
   end
 

data/spec/dummy/app/presenters/layouts/application_presenter.rb

@@ -6,4 +6,16 @@ class Layouts::ApplicationPresenter < Curly::Presenter
   def content
     yield
   end
+
+  def header(&block)
+    block.call
+  end
+
+  class HeaderPresenter < Curly::Presenter
+
+    def title
+      "Dummy app"
+    end
+  end
+
 end

data/spec/dummy/app/views/layouts/application.html.curly

@@ -3,6 +3,9 @@
   <title>{{title}}</title>
 </head>
 <body>
+{{@header}}<header>
+  <h1>{{title}}</h1>
+</header>{{/header}}
 {{content}}
 </body>
 </html>

data/spec/integration/application_layout_spec.rb

@@ -8,6 +8,9 @@ describe "Using Curly for the application layout", type: :request do
         <title>Dummy app</title>
       </head>
       <body>
+      <header>
+        <h1>Dummy app</h1>
+      </header>
       <h1>Dashboard</h1>
       <p>Hello, World!</p>
       <p>Welcome!</p>

data/spec/integration/collection_blocks_spec.rb

@@ -8,6 +8,9 @@ describe "Collection blocks", type: :request do
         <title>Dummy app</title>
       </head>
       <body>
+      <header>
+        <h1>Dummy app</h1>
+      </header>
       <ul>
 
         <li>uno</li>

data/spec/integration/context_blocks_spec.rb

@@ -10,6 +10,9 @@ describe "Context blocks", type: :request do
         <title>Dummy app</title>
       </head>
       <body>
+      <header>
+        <h1>Dummy app</h1>
+      </header>
       <form accept-charset="UTF-8" action="/new" method="post"><input name="utf8" type="hidden" value="&#x2713;" />
         <div class="field">
           <b>Name</b> <input id="dashboard_name" name="dashboard[name]" type="text" value="test" />

data/spec/integration/partials_spec.rb

@@ -8,6 +8,9 @@ describe "Using Curly for Rails partials", type: :request do
         <title>Dummy app</title>
       </head>
       <body>
+      <header>
+        <h1>Dummy app</h1>
+      </header>
       <ul>
         <li>One (yo)</li>
         <li>Two (yo)</li>

data/spec/presenter_spec.rb

@@ -5,6 +5,8 @@ describe Curly::Presenter do
       end
     end
 
+    exposes_helper :foo
+
     include MonkeyComponents
 
     presents :midget, :clown, default: nil
@@ -74,6 +76,29 @@ describe Curly::Presenter do
     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")

data/spec/scanner_spec.rb

@@ -2,14 +2,14 @@ describe Curly::Scanner, ".scan" do
   it "returns the tokens in the source" do
     scan("foo {{bar}} baz").should == [
       [:text, "foo "],
-      [:component, "bar", nil, {}],
+      [:component, "bar", nil, {}, []],
       [:text, " baz"]
     ]
   end
 
   it "scans components with identifiers" do
     scan("{{foo.bar}}").should == [
-      [:component, "foo", "bar", {}]
+      [:component, "foo", "bar", {}, []]
     ]
   end
 
@@ -53,44 +53,44 @@ describe Curly::Scanner, ".scan" do
 
   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]
+      [: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, {}],
+      [:conditional_block_start, "bar?", nil, {}, []],
       [:text, " hello "],
-      [:block_end, "bar?", nil]
+      [: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" }],
+      [:conditional_block_start, "active?", "test", { "name" => "test" }, []],
       [:text, "yo"],
-      [:block_end, "active?", "test"]
+      [: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, {}],
+      [:inverse_conditional_block_start, "bar?", nil, {}, []],
       [:text, " hello "],
-      [:block_end, "bar?", nil]
+      [:block_end, "bar?", nil, {}, []]
     ]
   end
 
   it "scans collection block tags" do
     scan('foo {{*bar}} hello {{/bar}}').should == [
       [:text, "foo "],
-      [:collection_block_start, "bar", nil, {}],
+      [:collection_block_start, "bar", nil, {}, []],
       [:text, " hello "],
-      [:block_end, "bar", nil]
+      [:block_end, "bar", nil, {}, []]
     ]
   end
 

data/spec/spec_helper.rb

@@ -14,23 +14,30 @@ module CompilationSupport
     presenter_class
   end
 
-  def render(source, locals = {}, presenter_class = nil, &block)
-    if presenter_class.nil?
-      unless defined?(ShowPresenter)
-        define_presenter("ShowPresenter")
-      end
+  def render(source, options = {}, &block)
+    presenter = options.fetch(:presenter) do
+      define_presenter("ShowPresenter") unless defined?(ShowPresenter)
+      "ShowPresenter"
+    end.constantize
 
-      presenter_class = ShowPresenter
+    virtual_path = options.fetch(:virtual_path) do
+      presenter.name.underscore.gsub(/_presenter\z/, "")
     end
 
-    identifier = "show"
+    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
-    details = { virtual_path: 'show' }
     template = ActionView::Template.new(source, identifier, handler, details)
     view = ActionView::Base.new
+    view.lookup_context.stub(:find_template) { source }
 
     begin
-      template.render(view, locals, &block)
+      template.render(view, options.fetch(:locals, {}), &block)
     rescue ActionView::Template::Error => e
       raise e.original_exception
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: curly-templates
 version: !ruby/object:Gem::Version
-  version: 2.3.2
+  version: 2.4.0
 platform: ruby
 authors:
 - Daniel Schierbeck
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-13 00:00:00.000000000 Z
+date: 2015-02-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack