curly-templates 2.0.1 → 2.1.0.beta1

data/lib/curly/component_compiler.rb

@@ -1,46 +1,46 @@
 module Curly
   class ComponentCompiler
-    attr_reader :presenter_class, :method
+    attr_reader :presenter_class, :component, :type
 
-    def initialize(presenter_class, method)
-      @presenter_class, @method = presenter_class, method
+    def self.compile(presenter_class, component, type: nil)
+      new(presenter_class, component, type: type).compile
     end
 
-    def self.compile_component(presenter_class, method, argument, attributes)
-      new(presenter_class, method).compile(argument, attributes)
+    def initialize(presenter_class, component, type: nil)
+      @presenter_class, @component, @type = presenter_class, component, type
     end
 
-    def self.compile_conditional(presenter_class, method, argument, attributes)
-      if argument && argument.end_with?("?")
-        method += "?"
-        argument = argument[0..-2]
-      end
-
-      unless method.end_with?("?")
-        raise Curly::Error, "conditional components must end with `?`"
-      end
-
-      new(presenter_class, method).compile(argument, attributes)
-    end
-
-    def compile(argument, attributes = {})
+    def compile
       unless presenter_class.component_available?(method)
         raise Curly::InvalidComponent.new(method)
       end
 
-      validate_attributes(attributes)
+      validate_block_argument!
+      validate_attributes!
 
       code = "presenter.#{method}("
 
-      append_positional_argument(code, argument)
-      append_keyword_arguments(code, argument, attributes)
+      append_positional_argument(code)
+      append_keyword_arguments(code)
 
       code << ")"
     end
 
     private
 
-    def append_positional_argument(code, argument)
+    def method
+      component.name
+    end
+
+    def argument
+      component.identifier
+    end
+
+    def attributes
+      component.attributes
+    end
+
+    def append_positional_argument(code)
       if required_identifier?
         if argument.nil?
           raise Curly::Error, "`#{method}` requires an identifier"
@@ -56,9 +56,7 @@ module Curly
       end
     end
 
-    def append_keyword_arguments(code, argument, attributes)
-      keyword_argument_string = build_keyword_argument_string(attributes)
-
+    def append_keyword_arguments(code)
       unless keyword_argument_string.empty?
         code << ", " unless argument.nil?
         code << keyword_argument_string
@@ -78,19 +76,27 @@ module Curly
       param_types.include?(:opt)
     end
 
-    def build_keyword_argument_string(kwargs)
-      kwargs.map {|name, value| "#{name}: #{value.inspect}" }.join(", ")
+    def keyword_argument_string
+      @keyword_argument_string ||= attributes.map {|name, value|
+        "#{name}: #{value.inspect}"
+      }.join(", ")
+    end
+
+    def validate_block_argument!
+      if type == :context && !param_types.include?(:block)
+        raise Curly::Error, "`#{method}` cannot be used as a context block"
+      end
     end
 
-    def validate_attributes(kwargs)
-      kwargs.keys.each do |key|
+    def validate_attributes!
+      attributes.keys.each do |key|
         unless attribute_names.include?(key)
           raise Curly::Error, "`#{method}` does not allow attribute `#{key}`"
         end
       end
 
       required_attribute_names.each do |key|
-        unless kwargs.key?(key)
+        unless attributes.key?(key)
           raise Curly::Error, "`#{method}` is missing the required attribute `#{key}`"
         end
       end

data/lib/curly/component_scanner.rb

@@ -0,0 +1,19 @@
+require 'curly/attribute_scanner'
+
+module Curly
+  class ComponentScanner
+    def self.scan(component)
+      first, rest = component.split(/\s+/, 2)
+      name, identifier = first.split(".", 2)
+
+      if identifier && identifier.end_with?("?")
+        name += "?"
+        identifier = identifier[0..-2]
+      end
+
+      attributes = AttributeScanner.scan(rest)
+
+      [name, identifier, attributes]
+    end
+  end
+end

data/lib/curly/incomplete_block_error.rb

@@ -1,11 +1,4 @@
 module Curly
   class IncompleteBlockError < Error
-    def initialize(component)
-      @component = component
-    end
-
-    def message
-      "error compiling `{{##{@component}}}`: conditional block must be terminated with `{{/#{@component}}}}`"
-    end
   end
 end

data/lib/curly/incorrect_ending_error.rb

@@ -1,25 +1,4 @@
 module Curly
   class IncorrectEndingError < Error
-    def initialize(actual_block, expected_block)
-      @actual_block, @expected_block = actual_block, expected_block
-    end
-
-    def message
-      "compilation error: expected `{{/#{expected_block}}}`, got `{{/#{actual_block}}}`"
-    end
-
-    private
-
-    def actual_block
-      present_block(@actual_block)
-    end
-
-    def expected_block
-      present_block(@expected_block)
-    end
-
-    def present_block(block)
-      block.compact.join(".")
-    end
   end
 end

data/lib/curly/parser.rb

@@ -0,0 +1,171 @@
+require 'curly/incomplete_block_error'
+require 'curly/incorrect_ending_error'
+
+class Curly::Parser
+  class Component
+    attr_reader :name, :identifier, :attributes
+
+    def initialize(name, identifier = nil, attributes = {})
+      @name, @identifier, @attributes = name, identifier, attributes
+    end
+
+    def to_s
+      [name, identifier].compact.join(".")
+    end
+
+    def ==(other)
+      other.name == name &&
+        other.identifier == identifier &&
+        other.attributes == attributes
+    end
+
+    def type
+      :component
+    end
+  end
+
+  class Text
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+    end
+
+    def type
+      :text
+    end
+  end
+
+  class Comment
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+    end
+
+    def type
+      :comment
+    end
+  end
+
+  class Root
+    attr_reader :nodes
+
+    def initialize
+      @nodes = []
+    end
+
+    def <<(node)
+      @nodes << node
+    end
+
+    def to_s
+      "<root>"
+    end
+
+    def closed_by?(component)
+      false
+    end
+  end
+  
+  class Block
+    attr_reader :type, :component, :nodes
+
+    def initialize(type, component, nodes = [])
+      @type, @component, @nodes = type, component, nodes
+    end
+
+    def closed_by?(component)
+      self.component.name == component.name &&
+        self.component.identifier == component.identifier
+    end
+
+    def to_s
+      component.to_s
+    end
+
+    def <<(node)
+      @nodes << node
+    end
+
+    def ==(other)
+      other.type == type &&
+        other.component == component &&
+        other.nodes == nodes
+    end
+  end
+
+  def self.parse(tokens)
+    new(tokens).parse
+  end
+
+  def initialize(tokens)
+    @tokens = tokens
+    @root = Root.new
+    @stack = [@root]
+  end
+
+  def parse
+    @tokens.each do |token, *args|
+      send("parse_#{token}", *args)
+    end
+
+    unless @stack.size == 1
+      raise Curly::IncompleteBlockError,
+        "block `#{@stack.last}` is not closed"
+    end
+
+    @root.nodes
+  end
+
+  private
+
+  def parse_text(value)
+    tree << Text.new(value)
+  end
+
+  def parse_component(*args)
+    tree << Component.new(*args)
+  end
+
+  def parse_conditional_block_start(*args)
+    parse_block(:conditional, *args)
+  end
+
+  def parse_inverse_conditional_block_start(*args)
+    parse_block(:inverse_conditional, *args)
+  end
+
+  def parse_collection_block_start(*args)
+    parse_block(:collection, *args)
+  end
+
+  def parse_context_block_start(*args)
+    parse_block(:context, *args)
+  end
+
+  def parse_block(type, *args)
+    component = Component.new(*args)
+    block = Block.new(type, component)
+    tree << block
+    @stack.push(block)
+  end
+
+  def parse_block_end(*args)
+    component = Component.new(*args)
+    block = @stack.pop
+
+    unless block.closed_by?(component)
+      raise Curly::IncorrectEndingError,
+        "block `#{block}` cannot be closed by `#{component}`"
+    end
+  end
+
+  def parse_comment(comment)
+    tree << Comment.new(comment)
+  end
+
+  def tree
+    @stack.last
+  end
+end

data/lib/curly/presenter.rb

@@ -86,7 +86,7 @@ module Curly
     #
     # - is a String,
     # - responds to #cache_key itself, or
-    # - is an Array of a Hash whose items themselves fit either of these
+    # - is an Array or a Hash whose items themselves fit either of these
     #   criteria.
     #
     # Returns the cache key Object or nil if no caching should be performed.

data/lib/curly/scanner.rb

@@ -1,4 +1,5 @@
 require 'strscan'
+require 'curly/component_scanner'
 require 'curly/syntax_error'
 
 module Curly
@@ -15,6 +16,7 @@ module Curly
     ESCAPED_CURLY_START = /\{\{\{/
 
     COMMENT_MARKER = /!/
+    CONTEXT_BLOCK_MARKER = /@/
     CONDITIONAL_BLOCK_MARKER = /#/
     INVERSE_BLOCK_MARKER = /\^/
     COLLECTION_BLOCK_MARKER = /\*/
@@ -73,6 +75,8 @@ module Curly
         scan_comment
       elsif @scanner.scan(CONDITIONAL_BLOCK_MARKER)
         scan_conditional_block_start
+      elsif @scanner.scan(CONTEXT_BLOCK_MARKER)
+        scan_context_block_start
       elsif @scanner.scan(INVERSE_BLOCK_MARKER)
         scan_inverse_block_start
       elsif @scanner.scan(COLLECTION_BLOCK_MARKER)
@@ -92,35 +96,45 @@ module Curly
 
     def scan_conditional_block_start
       if value = scan_until_end_of_curly
-        [:conditional_block_start, value]
+        name, identifier, attributes = ComponentScanner.scan(value)
+
+        [:conditional_block_start, name, identifier, attributes]
+      end
+    end
+
+    def scan_context_block_start
+      if value = scan_until_end_of_curly
+        name, identifier, attributes = ComponentScanner.scan(value)
+
+        [:context_block_start, name, identifier, attributes]
       end
     end
 
     def scan_collection_block_start
       if value = scan_until_end_of_curly
-        [:collection_block_start, value]
+        name, identifier, attributes = ComponentScanner.scan(value)
+        [:collection_block_start, name, identifier, attributes]
       end
     end
 
     def scan_inverse_block_start
       if value = scan_until_end_of_curly
-        [:inverse_conditional_block_start, value]
+        name, identifier, attributes = ComponentScanner.scan(value)
+        [:inverse_conditional_block_start, name, identifier, attributes]
       end
     end
 
     def scan_block_end
       if value = scan_until_end_of_curly
-        if value.end_with?("?")
-          [:conditional_block_end, value]
-        else
-          [:collection_block_end, value]
-        end
+        name, identifier, attributes = ComponentScanner.scan(value)
+        [:block_end, name, identifier]
       end
     end
 
     def scan_component
       if value = scan_until_end_of_curly
-        [:component, value]
+        name, identifier, attributes = ComponentScanner.scan(value)
+        [:component, name, identifier, attributes]
       end
     end
 

data/spec/attribute_scanner_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Curly::AttributeScanner do
+  it "scans attributes" do
+    scan("width=10px height=20px").should == {
+      "width" => "10px",
+      "height" => "20px"
+    }
+  end
+
+  it "scans single quoted values" do
+    scan("title='hello world'").should == { "title" => "hello world" }
+  end
+
+  it "scans double quoted values" do
+    scan('title="hello world"').should == { "title" => "hello world" }
+  end
+
+  it "scans mixed quotes" do
+    scan(%[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
+    scan(" size=big  ").should == { "size" => "big" }
+  end
+
+  it "scans empty attribute lists" do
+    scan(nil).should == {}
+    scan("").should == {}
+    scan(" ").should == {}
+  end
+
+  it "fails when an invalid attribute list is passed" do
+    expect { scan("foo") }.to raise_exception(Curly::AttributeError)
+    expect { scan("foo=") }.to raise_exception(Curly::AttributeError)
+  end
+
+  def scan(str)
+    described_class.scan(str)
+  end
+end