curly-templates 1.0.1 → 2.0.0.beta1

data/lib/curly/compiler.rb

@@ -1,6 +1,8 @@
 require 'curly/scanner'
+require 'curly/component_compiler'
+require 'curly/component_parser'
 require 'curly/error'
-require 'curly/invalid_reference'
+require 'curly/invalid_component'
 require 'curly/incorrect_ending_error'
 require 'curly/incomplete_block_error'
 
@@ -9,7 +11,7 @@ module Curly
   # Compiles Curly templates into executable Ruby code.
   #
   # A template must be accompanied by a presenter class. This class defines the
-  # references that are valid within the template.
+  # components that are valid within the template.
   #
   class Compiler
     # Compiles a Curly template to Ruby code.
@@ -17,7 +19,7 @@ module Curly
     # template        - The template String that should be compiled.
     # presenter_class - The presenter Class.
     #
-    # Raises InvalidReference if the template contains a reference that is not
+    # Raises InvalidComponent if the template contains a component that is not
     #   allowed.
     # Raises IncorrectEndingError if a conditional block is not ended in the
     #   correct order - the most recent block must be ended first.
@@ -28,7 +30,7 @@ module Curly
     end
 
     # Whether the Curly template is valid. This includes whether all
-    # references are available on the presenter class.
+    # components are available on the presenter class.
     #
     # template        - The template String that should be validated.
     # presenter_class - The presenter Class.
@@ -42,10 +44,11 @@ module Curly
       false
     end
 
-    attr_reader :template, :presenter_class
+    attr_reader :template
 
     def initialize(template, presenter_class)
-      @template, @presenter_class = template, presenter_class
+      @template = template
+      @presenter_classes = [presenter_class]
     end
 
     def compile
@@ -67,6 +70,7 @@ module Curly
 
       <<-RUBY
         buffer = ActiveSupport::SafeBuffer.new
+        presenters = []
         #{parts.join("\n")}
         buffer
       RUBY
@@ -74,74 +78,100 @@ module Curly
 
     private
 
-    def compile_block_start(reference)
-      compile_conditional_block "if", reference
+    def presenter_class
+      @presenter_classes.last
     end
 
-    def compile_inverse_block_start(reference)
-      compile_conditional_block "unless", reference
+    def compile_conditional_block_start(component)
+      compile_conditional_block "if", component
     end
 
-    def compile_conditional_block(keyword, reference)
-      m = reference.match(/\A(.+?)(?:\.(.+))?\?\z/)
-      method, argument = "#{m[1]}?", m[2]
+    def compile_inverse_conditional_block_start(component)
+      compile_conditional_block "unless", component
+    end
 
-      @blocks.push reference
+    def compile_collection_block_start(component)
+      name, identifier, attributes = ComponentParser.parse(component)
+      method_call = ComponentCompiler.compile_component(presenter_class, name, identifier, attributes)
 
-      unless presenter_class.method_available?(method.to_sym)
-        raise Curly::InvalidReference.new(method.to_sym)
-      end
+      as = name.singularize
+      counter = "#{as}_counter"
 
-      if presenter_class.instance_method(method).arity == 1
-        <<-RUBY
-          #{keyword} presenter.#{method}(#{argument.inspect})
-        RUBY
-      else
-        <<-RUBY
-          #{keyword} presenter.#{method}
-        RUBY
+      begin
+        item_presenter_class = presenter_class.presenter_for_name(as)
+      rescue NameError
+        raise Curly::Error,
+          "cannot enumerate `#{component}`, could not find matching presenter class"
       end
+
+      push_block(name, identifier)
+      @presenter_classes.push(item_presenter_class)
+
+      <<-RUBY
+        presenters << presenter
+        items = Array(#{method_call})
+        items.each_with_index do |item, index|
+          item_options = options.merge(:#{as} => item, :#{counter} => index + 1)
+          presenter = #{item_presenter_class}.new(self, item_options)
+      RUBY
     end
 
-    def compile_block_end(reference)
-      last_block = @blocks.pop
+    def compile_conditional_block(keyword, component)
+      name, identifier, attributes = ComponentParser.parse(component)
+      method_call = ComponentCompiler.compile_conditional(presenter_class, name, identifier, attributes)
 
-      unless last_block == reference
-        raise Curly::IncorrectEndingError.new(reference, last_block)
-      end
+      push_block(name, identifier)
+
+      <<-RUBY
+        #{keyword} #{method_call}
+      RUBY
+    end
+
+    def compile_conditional_block_end(component)
+      validate_block_end(component)
 
       <<-RUBY
         end
       RUBY
     end
 
-    def compile_reference(reference)
-      method, argument = reference.split(".", 2)
+    def compile_collection_block_end(component)
+      @presenter_classes.pop
+      validate_block_end(component)
 
-      unless presenter_class.method_available?(method.to_sym)
-        raise Curly::InvalidReference.new(method.to_sym)
-      end
+      <<-RUBY
+        end
+        presenter = presenters.pop
+      RUBY
+    end
 
-      if presenter_class.instance_method(method).arity == 1
-        # The method accepts a single argument -- pass it in.
-        code = <<-RUBY
-          presenter.#{method}(#{argument.inspect}) {|*args| yield(*args) }
-        RUBY
-      else
-        code = <<-RUBY
-          presenter.#{method} {|*args| yield(*args) }
-        RUBY
-      end
+    def compile_component(component)
+      name, identifier, attributes = ComponentParser.parse(component)
+      method_call = ComponentCompiler.compile_component(presenter_class, name, identifier, attributes)
+      code = "#{method_call} {|*args| yield(*args) }"
 
-      'buffer.concat(%s.to_s)' % code.strip
+      "buffer.concat(#{code.strip}.to_s)"
     end
 
     def compile_text(text)
-      'buffer.safe_concat(%s)' % text.inspect
+      "buffer.safe_concat(#{text.inspect})"
     end
 
     def compile_comment(comment)
       "" # Replace the content with an empty string.
     end
+
+    def validate_block_end(component)
+      name, identifier, attributes = ComponentParser.parse(component)
+      last_block = @blocks.pop
+
+      unless last_block == [name, identifier]
+        raise Curly::IncorrectEndingError.new([name, identifier], last_block)
+      end
+    end
+
+    def push_block(name, identifier)
+      @blocks.push([name, identifier])
+    end
   end
 end

data/lib/curly/component_compiler.rb

@@ -0,0 +1,119 @@
+module Curly
+  class ComponentCompiler
+    attr_reader :presenter_class, :method
+
+    def initialize(presenter_class, method)
+      @presenter_class, @method = presenter_class, method
+    end
+
+    def self.compile_component(presenter_class, method, argument, attributes)
+      new(presenter_class, method).compile(argument, attributes)
+    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 = {})
+      unless presenter_class.component_available?(method)
+        raise Curly::InvalidComponent.new(method)
+      end
+
+      validate_attributes(attributes)
+
+      code = "presenter.#{method}("
+
+      append_positional_argument(code, argument)
+      append_keyword_arguments(code, argument, attributes)
+
+      code << ")"
+    end
+
+    private
+
+    def append_positional_argument(code, argument)
+      if required_identifier?
+        if argument.nil?
+          raise Curly::Error, "`#{method}` requires an identifier"
+        end
+
+        code << argument.inspect
+      elsif optional_identifier?
+        code << argument.inspect unless argument.nil?
+      elsif invalid_signature?
+        raise Curly::Error, "`#{method}` is not a valid component method"
+      elsif !argument.nil?
+        raise Curly::Error, "`#{method}` does not take an identifier"
+      end
+    end
+
+    def append_keyword_arguments(code, argument, attributes)
+      keyword_argument_string = build_keyword_argument_string(attributes)
+
+      unless keyword_argument_string.empty?
+        code << ", " unless argument.nil?
+        code << keyword_argument_string
+      end
+    end
+
+    def invalid_signature?
+      positional_params = param_types.select {|type| [:req, :opt].include?(type) }
+      positional_params.size > 1
+    end
+
+    def required_identifier?
+      param_types.include?(:req)
+    end
+
+    def optional_identifier?
+      param_types.include?(:opt)
+    end
+
+    def build_keyword_argument_string(kwargs)
+      kwargs.map {|name, value| "#{name}: #{value.inspect}" }.join(", ")
+    end
+
+    def validate_attributes(kwargs)
+      kwargs.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)
+          raise Curly::Error, "`#{method}` is missing the required attribute `#{key}`"
+        end
+      end
+    end
+
+    def params
+      @params ||= presenter_class.instance_method(method).parameters
+    end
+
+    def param_types
+      params.map(&:first)
+    end
+
+    def attribute_names
+      @attribute_names ||= params.
+        select {|type, name| [:key, :keyreq].include?(type) }.
+        map {|type, name| name.to_s }
+    end
+
+    def required_attribute_names
+      @required_attribute_names ||= params.
+        select {|type, name| type == :keyreq }.
+        map {|type, name| name.to_s }
+    end
+  end
+end

data/lib/curly/component_parser.rb

@@ -0,0 +1,13 @@
+require 'curly/attribute_parser'
+
+module Curly
+  class ComponentParser
+    def self.parse(component)
+      first, rest = component.split(/\s+/, 2)
+      name, identifier = first.split(".", 2)
+      attributes = AttributeParser.parse(rest)
+
+      [name, identifier, attributes]
+    end
+  end
+end

data/lib/curly/incomplete_block_error.rb

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

data/lib/curly/incorrect_ending_error.rb

@@ -1,11 +1,25 @@
 module Curly
   class IncorrectEndingError < Error
-    def initialize(reference, last_block)
-      @reference, @last_block = reference, last_block
+    def initialize(actual_block, expected_block)
+      @actual_block, @expected_block = actual_block, expected_block
     end
 
     def message
-      "error compiling `{{##{@last_block}}}`: expected `{{/#{@last_block}}}`, got `{{/#{@reference}}}`"
+      "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/invalid_component.rb

@@ -0,0 +1,13 @@
+module Curly
+  class InvalidComponent < Error
+    attr_reader :component
+
+    def initialize(component)
+      @component = component
+    end
+
+    def message
+      "invalid component `{{#{component}}}'"
+    end
+  end
+end

data/lib/curly/presenter.rb

@@ -6,7 +6,7 @@ module Curly
   # form of simple strings. Each public instance method on the presenter class
   # can be referenced in a template. When a template is evaluated with a
   # presenter, the referenced methods will be called with no arguments, and
-  # the returned strings inserted in place of the references in the template.
+  # the returned strings inserted in place of the components in the template.
   #
   # Note that strings that are not HTML safe will be escaped.
   #
@@ -47,7 +47,7 @@ module Curly
       self.class.presented_names.each do |name|
         value = options.fetch(name) do
           default_values.fetch(name) do
-            raise ArgumentError.new("required parameter `#{name}` missing")
+            raise ArgumentError.new("required identifier `#{name}` missing")
           end
         end
 
@@ -152,9 +152,28 @@ module Curly
         end
       end
 
-      # Whether a method is available to templates rendered with the presenter.
+      def presenter_for_name(name)
+        namespace = to_s.split("::")
+        class_name = name.camelcase << "Presenter"
+
+        # Because Rails' autoloading mechanism doesn't work properly with
+        # namespace we need to loop through the namespace ourselves. Ideally,
+        # `X::Y.const_get("Z")` would autoload `X::Z`, but only `X::Y::Z` is
+        # attempted by Rails. This sucks, and hopefully we can find a better
+        # solution in the future.
+        begin
+          full_name = namespace.join("::") << "::" << class_name
+          const_get(full_name)
+        rescue NameError
+          raise if namespace.empty?
+          namespace.pop
+          retry
+        end
+      end
+
+      # Whether a component is available to templates rendered with the presenter.
       #
-      # Templates can reference "variables", which are simply methods defined on
+      # Templates have components which correspond with methods defined on
       # the presenter. By default, only public instance methods can be
       # referenced, and any method defined on Curly::Presenter itself cannot be
       # referenced. This means that methods such as `#cache_key` and #inspect are
@@ -162,19 +181,20 @@ module Curly
       #
       # This policy can be changed by overriding this method in your presenters.
       #
-      # method - The Symbol name of the method.
+      # name - The String name of the component.
       #
       # Returns true if the method can be referenced by a template,
       #   false otherwise.
-      def method_available?(method)
-        available_methods.include?(method)
+      def component_available?(name)
+        available_components.include?(name)
       end
 
-      # A list of methods available to templates rendered with the presenter.
+      # A list of components available to templates rendered with the presenter.
       #
-      # Returns an Array of Symbol method names.
-      def available_methods
-        public_instance_methods - Curly::Presenter.public_instance_methods
+      # Returns an Array of String component names.
+      def available_components
+        methods = public_instance_methods - Curly::Presenter.public_instance_methods
+        methods.map(&:to_s)
       end
 
       # The set of view paths that the presenter depends on.