curly-templates 1.0.1 → 2.0.0.beta1

data/lib/curly/scanner.rb

@@ -15,8 +15,9 @@ module Curly
     ESCAPED_CURLY_START = /\{\{\{/
 
     COMMENT_MARKER = /!/
-    BLOCK_MARKER = /#/
+    CONDITIONAL_BLOCK_MARKER = /#/
     INVERSE_BLOCK_MARKER = /\^/
+    COLLECTION_BLOCK_MARKER = /\*/
     END_BLOCK_MARKER = /\//
 
 
@@ -27,7 +28,7 @@ module Curly
     # Example
     #
     #   Curly::Scanner.scan("hello {{name}}!")
-    #   #=> [[:text, "hello "], [:reference, "name"], [:text, "!"]]
+    #   #=> [[:text, "hello "], [:component, "name"], [:text, "!"]]
     #
     # Returns an Array of type/value pairs representing the tokens in the
     #   template.
@@ -70,14 +71,16 @@ module Curly
     def scan_tag
       if @scanner.scan(COMMENT_MARKER)
         scan_comment
-      elsif @scanner.scan(BLOCK_MARKER)
-        scan_block_start
+      elsif @scanner.scan(CONDITIONAL_BLOCK_MARKER)
+        scan_conditional_block_start
       elsif @scanner.scan(INVERSE_BLOCK_MARKER)
         scan_inverse_block_start
+      elsif @scanner.scan(COLLECTION_BLOCK_MARKER)
+        scan_collection_block_start
       elsif @scanner.scan(END_BLOCK_MARKER)
         scan_block_end
       else
-        scan_reference
+        scan_component
       end
     end
 
@@ -87,27 +90,37 @@ module Curly
       end
     end
 
-    def scan_block_start
+    def scan_conditional_block_start
       if value = scan_until_end_of_curly
-        [:block_start, value]
+        [:conditional_block_start, value]
+      end
+    end
+
+    def scan_collection_block_start
+      if value = scan_until_end_of_curly
+        [:collection_block_start, value]
       end
     end
 
     def scan_inverse_block_start
       if value = scan_until_end_of_curly
-        [:inverse_block_start, value]
+        [:inverse_conditional_block_start, value]
       end
     end
 
     def scan_block_end
       if value = scan_until_end_of_curly
-        [:block_end, value]
+        if value.end_with?("?")
+          [:conditional_block_end, value]
+        else
+          [:collection_block_end, value]
+        end
       end
     end
 
-    def scan_reference
+    def scan_component
       if value = scan_until_end_of_curly
-        [:reference, value]
+        [:component, value]
       end
     end
 

data/spec/attribute_parser_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Curly::AttributeParser do
+  it "parses attributes" do
+    parse("width=10px height=20px").should == {
+      "width" => "10px",
+      "height" => "20px"
+    }
+  end
+
+  it "parses single quoted values" do
+    parse("title='hello world'").should == { "title" => "hello world" }
+  end
+
+  it "parses double quoted values" do
+    parse('title="hello world"').should == { "title" => "hello world" }
+  end
+
+  it "parses mixed quotes" do
+    parse(%[x=y q="foo's bar" v='bim " bum' t="foo ' bar"]).should == {
+      "x" => "y",
+      "q" => "foo's bar",
+      "t" => "foo ' bar",
+      "v" => 'bim " bum'
+    }
+  end
+
+  it "deals with weird whitespace" do
+    parse(" size=big  ").should == { "size" => "big" }
+  end
+
+  it "parses empty attribute lists" do
+    parse(nil).should == {}
+    parse("").should == {}
+    parse(" ").should == {}
+  end
+
+  it "fails when an invalid attribute list is passed" do
+    expect { parse("foo") }.to raise_exception(Curly::AttributeError)
+    expect { parse("foo=") }.to raise_exception(Curly::AttributeError)
+  end
+
+  def parse(str)
+    described_class.parse(str)
+  end
+end

data/spec/compiler/collections_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+
+describe Curly::Compiler do
+  include CompilationSupport
+
+  let(:presenter_class) do
+    Class.new(Curly::Presenter) do
+      presents :list
+
+      def title
+        @list.title
+      end
+
+      def items(status: nil)
+        if status
+          @list.items.select {|item| item.status == status }
+        else
+          @list.items
+        end
+      end
+
+      def companies
+        "Nike, Adidas"
+      end
+
+      def numbers
+        "one, two, three"
+      end
+    end
+  end
+
+  let(:simple_presenter_class) do
+    Class.new(Curly::Presenter) do
+      presents :company
+
+      def name
+        @company
+      end
+    end
+  end
+
+  let(:inner_presenter_class) do
+    Class.new(Curly::Presenter) do
+      presents :item, :item_counter
+      presents :list, default: nil
+
+      attr_reader :item_counter
+
+      def name
+        @item.name
+      end
+
+      def list_title
+        @list.title
+      end
+
+      def parts
+        @item.parts
+      end
+    end
+  end
+
+  let(:inner_inner_presenter_class) do
+    Class.new(Curly::Presenter) do
+      presents :part
+
+      def identifier
+        @part.identifier
+      end
+    end
+  end
+
+  let(:list) { double("list", title: "Inventory") }
+  let(:context) { double("context") }
+  let(:presenter) { presenter_class.new(context, list: list) }
+
+  before do
+    stub_const("ItemPresenter", inner_presenter_class)
+    stub_const("PartPresenter", inner_inner_presenter_class)
+  end
+
+  it "compiles collection blocks" do
+    item1 = double("item1", name: "foo")
+    item2 = double("item2", name: "bar")
+
+    list.stub(:items) { [item1, item2] }
+
+    template = "<ul>{{*items}}<li>{{name}}</li>{{/items}}</ul>"
+    expect(evaluate(template)).to eql "<ul><li>foo</li><li>bar</li></ul>"
+  end
+
+  it "allows attributes on collection blocks" do
+    item1 = double("item1", name: "foo", status: "active")
+    item2 = double("item2", name: "bar", status: "inactive")
+
+    list.stub(:items) { [item1, item2] }
+
+    template = "<ul>{{*items status=active}}<li>{{name}}</li>{{/items}}</ul>"
+    expect(evaluate(template)).to eql "<ul><li>foo</li></ul>"
+  end
+
+  it "fails if the component isn't available" do
+    template = "<ul>{{*doodads}}<li>{{name}}</li>{{/doodads}}</ul>"
+    expect { evaluate(template) }.to raise_exception(Curly::Error)
+  end
+
+  it "fails if the component doesn't support enumeration" do
+    template = "<ul>{{*numbers}}<li>{{name}}</li>{{/numbers}}</ul>"
+    expect { evaluate(template) }.to raise_exception(Curly::Error)
+  end
+
+  it "works even if the component method doesn't return an Array" do
+    stub_const("CompanyPresenter", simple_presenter_class)
+    template = "<ul>{{*companies}}<li>{{name}}</li>{{/companies}}</ul>"
+    expect(evaluate(template)).to eql "<ul><li>Nike, Adidas</li></ul>"
+  end
+
+  it "passes the index of the current item to the nested presenter" do
+    item1 = double("item1")
+    item2 = double("item2")
+
+    list.stub(:items) { [item1, item2] }
+
+    template = "<ul>{{*items}}<li>{{item_counter}}</li>{{/items}}</ul>"
+    expect(evaluate(template)).to eql "<ul><li>1</li><li>2</li></ul>"
+  end
+
+  it "restores the previous scope after exiting the collection block" do
+    part = double("part", identifier: "X")
+    item = double("item", name: "foo", parts: [part])
+    list.stub(:items) { [item] }
+
+    template = "{{*items}}{{*parts}}{{identifier}}{{/parts}}{{name}}{{/items}}{{title}}"
+    expect(evaluate(template)).to eql "XfooInventory"
+  end
+
+  it "passes the parent presenter's options to the nested presenter" do
+    list.stub(:items) { [double(name: "foo"), double(name: "bar")] }
+
+    template = "{{*items}}{{list_title}}: {{name}}. {{/items}}"
+    expect(evaluate(template, list: list)).to eql "Inventory: foo. Inventory: bar. "
+  end
+
+  it "compiles nested collection blocks" do
+    item1 = double("item1", name: "item1", parts: [double(identifier: "A"), double(identifier: "B")])
+    item2 = double("item2", name: "item2", parts: [double(identifier: "C"), double(identifier: "D")])
+
+    list.stub(:items) { [item1, item2] }
+
+    template = "{{title}}: {{*items}}{{name}} - {{*parts}}{{identifier}}{{/parts}}. {{/items}}"
+    expect(evaluate(template)).to eql "Inventory: item1 - AB. item2 - CD. "
+  end
+end

data/spec/compiler_spec.rb

@@ -1,6 +1,8 @@
 require 'spec_helper'
 
 describe Curly::Compiler do
+  include CompilationSupport
+
   let :presenter_class do
     Class.new do
       def foo
@@ -27,6 +29,10 @@ describe Curly::Compiler do
         nil
       end
 
+      def square?(width:, height:)
+        width.to_i == height.to_i
+      end
+
       def false?
         false
       end
@@ -35,16 +41,11 @@ describe Curly::Compiler do
         true
       end
 
-      def parameterized(value)
-        value
-      end
-
-      def self.method_available?(method)
-        [:foo, :parameterized, :high_yield, :yield_value, :dirty,
-          :false?, :true?, :hello?].include?(method)
+      def self.component_available?(method)
+        %w[foo high_yield yield_value dirty false? true? hello? square?].include?(method)
       end
 
-      def self.available_methods
+      def self.available_components
         public_instance_methods
       end
 
@@ -63,14 +64,6 @@ describe Curly::Compiler do
       evaluate("{{foo}}").should == "FOO"
     end
 
-    it "passes on an optional reference parameter to the presenter method" do
-      evaluate("{{parameterized.foo.bar}}").should == "foo.bar"
-    end
-
-    it "passes an empty string to methods that take a parameter when none is provided" do
-      evaluate("{{parameterized}}").should == ""
-    end
-
     it "raises ArgumentError if the presenter class is nil" do
       expect do
         Curly::Compiler.compile("foo", nil)
@@ -78,15 +71,15 @@ describe Curly::Compiler do
     end
 
     it "makes sure only public methods are called on the presenter object" do
-      expect { evaluate("{{bar}}") }.to raise_exception(Curly::InvalidReference)
+      expect { evaluate("{{bar}}") }.to raise_exception(Curly::InvalidComponent)
     end
 
-    it "includes the invalid reference when failing to compile" do
+    it "includes the invalid component when failing to compile" do
       begin
         evaluate("{{bar}}")
         fail
-      rescue Curly::InvalidReference => e
-        e.reference.should == :bar
+      rescue Curly::InvalidComponent => e
+        e.component.should == "bar"
       end
     end
 
@@ -141,6 +134,10 @@ describe Curly::Compiler do
       evaluate("{{#hello.world?}}foo{{/hello.world?}}{{#hello.foo?}}bar{{/hello.foo?}}").should == "foo"
     end
 
+    it "passes attributes to blocks" do
+      evaluate("{{#square? width=2 height=2}}yeah!{{/square?}}").should == "yeah!"
+    end
+
     it "gives an error on mismatching blocks" do
       expect do
         evaluate("test{{#false?}}bar{{/true?}}")
@@ -174,7 +171,7 @@ describe Curly::Compiler do
     end
 
     it "returns false if an unavailable method is referenced" do
-      presenter_class.stub(:available_methods) { [:foo] }
+      presenter_class.stub(:available_components) { [:foo] }
       validate("Hello, {{inspect}}").should == false
     end
 
@@ -190,17 +187,4 @@ describe Curly::Compiler do
       Curly.valid?(template, presenter_class)
     end
   end
-
-  def evaluate(template, &block)
-    code = Curly::Compiler.compile(template, presenter_class)
-    context = double("context", presenter: presenter)
-
-    context.instance_eval(<<-RUBY)
-      def self.render
-        #{code}
-      end
-    RUBY
-
-    context.render(&block)
-  end
 end

data/spec/component_compiler_spec.rb

@@ -0,0 +1,160 @@
+require 'spec_helper'
+
+describe Curly::ComponentCompiler do
+  describe ".compile_conditional" do
+    let(:presenter_class) do
+      Class.new do
+        def monday?
+          true
+        end
+
+        def tuesday?
+          false
+        end
+
+        def day?(name)
+          name == "monday"
+        end
+
+        def season?(name:)
+          name == "summer"
+        end
+
+        def hello
+          "hello"
+        end
+
+        def self.component_available?(name)
+          true
+        end
+      end
+    end
+
+    it "compiles simple components" do
+      evaluate("monday?").should == true
+      evaluate("tuesday?").should == false
+    end
+
+    it "compiles components with an identifier" do
+      evaluate("day.monday?").should == true
+      evaluate("day.tuesday?").should == false
+    end
+
+    it "compiles components with attributes" do
+      evaluate("season? name=summer").should == true
+      evaluate("season? name=winter").should == false
+    end
+
+    it "fails if the component is missing a question mark" do
+      expect { evaluate("hello") }.to raise_exception(Curly::Error)
+    end
+
+    def evaluate(component, &block)
+      method, argument, attributes = Curly::ComponentParser.parse(component)
+      code = Curly::ComponentCompiler.compile_conditional(presenter_class, method, argument, attributes)
+      presenter = presenter_class.new
+      context = double("context", presenter: presenter)
+
+      context.instance_eval(<<-RUBY)
+        def self.render
+          #{code}
+        end
+      RUBY
+
+      context.render(&block)
+    end
+  end
+
+  describe ".compile_component" do
+    let(:presenter_class) do
+      Class.new do
+        def title
+          "Welcome!"
+        end
+
+        def i18n(key, fallback: nil)
+          case key
+          when "home.welcome" then "Welcome to our lovely place!"
+          else fallback
+          end
+        end
+
+        def summary(length = "long")
+          case length
+          when "long" then "This is a long summary"
+          when "short" then "This is a short summary"
+          end
+        end
+
+        def invalid(x, y)
+        end
+
+        def widget(size:, color: nil)
+          s = "Widget (#{size})"
+          s << " - #{color}" if color
+          s
+        end
+
+        def self.component_available?(name)
+          true
+        end
+      end
+    end
+
+    it "compiles components with identifiers" do
+      evaluate("i18n.home.welcome").should == "Welcome to our lovely place!"
+    end
+
+    it "compiles components with optional identifiers" do
+      evaluate("summary").should == "This is a long summary"
+      evaluate("summary.short").should == "This is a short summary"
+    end
+
+    it "compiles components with attributes" do
+      evaluate("widget size=100px").should == "Widget (100px)"
+    end
+
+    it "compiles components with optional attributes" do
+      evaluate("widget color=blue size=50px").should == "Widget (50px) - blue"
+    end
+
+    it "allows both identifier and attributes" do
+      evaluate("i18n.hello fallback=yolo").should == "yolo"
+    end
+
+    it "fails when an invalid attribute is used" do
+      expect { evaluate("i18n.foo extreme=true") }.to raise_exception(Curly::Error)
+    end
+
+    it "fails when a component is missing a required identifier" do
+      expect { evaluate("i18n") }.to raise_exception(Curly::Error)
+    end
+
+    it "fails when a component is missing a required attribute" do
+      expect { evaluate("widget") }.to raise_exception(Curly::Error)
+    end
+
+    it "fails when an identifier is specified for a component that doesn't support one" do
+      expect { evaluate("title.rugby") }.to raise_exception(Curly::Error)
+    end
+
+    it "fails when the method takes more than one argument" do
+      expect { evaluate("invalid") }.to raise_exception(Curly::Error)
+    end
+
+    def evaluate(component, &block)
+      method, argument, attributes = Curly::ComponentParser.parse(component)
+      code = Curly::ComponentCompiler.compile_component(presenter_class, method, argument, attributes)
+      presenter = presenter_class.new
+      context = double("context", presenter: presenter)
+
+      context.instance_eval(<<-RUBY)
+        def self.render
+          #{code}
+        end
+      RUBY
+
+      context.render(&block)
+    end
+  end
+end