curly-templates 0.6.1 → 0.7.0

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           = '0.6.1'
-  s.date              = '2013-04-29'
+  s.version           = '0.7.0'
+  s.date              = '2013-05-03'
 
   s.summary     = "Free your views!"
   s.description = "A view layer for your Rails apps that separates structure and logic."
@@ -34,14 +34,16 @@ Gem::Specification.new do |s|
     curly-templates.gemspec
     lib/curly-templates.rb
     lib/curly.rb
+    lib/curly/compiler.rb
     lib/curly/dependency_tracker.rb
+    lib/curly/invalid_reference.rb
     lib/curly/presenter.rb
     lib/curly/railtie.rb
     lib/curly/template_handler.rb
     lib/generators/curly/controller/controller_generator.rb
     lib/generators/curly/controller/templates/presenter.rb.erb
     lib/generators/curly/controller/templates/view.html.curly.erb
-    spec/curly_spec.rb
+    spec/compiler_spec.rb
     spec/generators/controller_generator_spec.rb
     spec/presenter_spec.rb
     spec/spec_helper.rb

data/lib/curly.rb

@@ -26,82 +26,30 @@
 # See Curly::Presenter for more information on presenters.
 #
 module Curly
-  VERSION = "0.6.1"
-
-  REFERENCE_REGEX = %r(\{\{([\w\.]+)\}\})
-
-  class InvalidReference < StandardError
-    attr_reader :reference
-
-    def initialize(reference)
-      @reference = reference
-    end
-
-    def message
-      "invalid reference `{{#{reference}}}'"
-    end
+  VERSION = "0.7.0"
+
+  # Compiles a Curly template to Ruby code.
+  #
+  # template - The template String that should be compiled.
+  #
+  # Returns a String containing the Ruby code.
+  def self.compile(template, presenter_class)
+    Compiler.compile(template, presenter_class)
   end
 
-  class << self
-
-    # Compiles a Curly template to Ruby code.
-    #
-    # template - The template String that should be compiled.
-    #
-    # Returns a String containing the Ruby code.
-    def compile(template, presenter_class)
-      source = template.inspect
-      source.gsub!(REFERENCE_REGEX) { compile_reference($1, presenter_class) }
-
-      source
-    end
-
-    # Whether the Curly template is valid. This includes whether all
-    # references are available on the presenter class.
-    #
-    # template        - The template String that should be validated.
-    # presenter_class - The presenter Class.
-    #
-    # Returns true if the template is valid, false otherwise.
-    def valid?(template, presenter_class)
-      references = extract_references(template)
-      methods = presenter_class.available_methods.map(&:to_s)
-      references & methods == references
-    end
-
-    private
-
-    def compile_reference(reference, presenter_class)
-      method, argument = reference.split(".", 2)
-
-      unless presenter_class.method_available?(method.to_sym)
-        raise Curly::InvalidReference.new(method.to_sym)
-      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
-
-      %(\#{
-        result = #{code}
-        ERB::Util.html_escape(result)
-      })
-    end
-
-    def extract_references(template)
-      template.scan(REFERENCE_REGEX).flatten
-    end
-
+  # Whether the Curly template is valid. This includes whether all
+  # references are available on the presenter class.
+  #
+  # template        - The template String that should be validated.
+  # presenter_class - The presenter Class.
+  #
+  # Returns true if the template is valid, false otherwise.
+  def self.valid?(template, presenter_class)
+    Compiler.valid?(template, presenter_class)
   end
 end
 
+require 'curly/compiler'
 require 'curly/presenter'
 require 'curly/template_handler'
 require 'curly/railtie' if defined?(Rails)

data/lib/curly/compiler.rb

@@ -0,0 +1,60 @@
+require 'curly/invalid_reference'
+
+module Curly
+  class Compiler
+    REFERENCE_REGEX = %r(\{\{([\w\.]+)\}\})
+
+    class << self
+
+      # Compiles a Curly template to Ruby code.
+      #
+      # template - The template String that should be compiled.
+      #
+      # Returns a String containing the Ruby code.
+      def compile(template, presenter_class)
+        source = template.inspect
+        source.gsub!(REFERENCE_REGEX) { compile_reference($1, presenter_class) }
+
+        source
+      end
+
+      # Whether the Curly template is valid. This includes whether all
+      # references are available on the presenter class.
+      #
+      # template        - The template String that should be validated.
+      # presenter_class - The presenter Class.
+      #
+      # Returns true if the template is valid, false otherwise.
+      def valid?(template, presenter_class)
+        compile(template, presenter_class)
+
+        true
+      rescue InvalidReference
+        false
+      end
+
+      private
+
+      def compile_reference(reference, presenter_class)
+        method, argument = reference.split(".", 2)
+
+        unless presenter_class.method_available?(method.to_sym)
+          raise Curly::InvalidReference.new(method.to_sym)
+        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
+
+        '#{ERB::Util.html_escape(%s)}' % code.strip
+      end
+    end
+  end
+end

data/lib/curly/invalid_reference.rb

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

data/lib/curly/template_handler.rb

@@ -3,60 +3,75 @@ require 'action_view'
 require 'curly'
 
 class Curly::TemplateHandler
+  class << self
 
-  # Handles a Curly template, compiling it to Ruby code. The code will be
-  # evaluated in the context of an ActionView::Base instance, having access
-  # to a number of variables.
-  #
-  # template - The ActionView::Template template that should be compiled.
-  #
-  # Returns a String containing the Ruby code representing the template.
-  def self.call(template)
-    path = template.virtual_path
-    presenter_class = Curly::Presenter.presenter_for_path(path)
-
-    source = Curly.compile(template.source, presenter_class)
-    template_digest = Digest::MD5.hexdigest(template.source)
-
-    # Template is empty, so there's no need to initialize a presenter.
-    return %("") if template.source.empty?
-
-    <<-RUBY
-    if local_assigns.empty?
-      options = assigns
-    else
-      options = local_assigns
+    # Handles a Curly template, compiling it to Ruby code. The code will be
+    # evaluated in the context of an ActionView::Base instance, having access
+    # to a number of variables.
+    #
+    # template - The ActionView::Template template that should be compiled.
+    #
+    # Returns a String containing the Ruby code representing the template.
+    def call(template)
+      instrument(template) do
+        compile(template)
+      end
     end
 
-    presenter = #{presenter_class}.new(self, options.with_indifferent_access)
+    private
 
-    view_function = lambda do
-      #{source}
-    end
+    def compile(template)
+      # Template is empty, so there's no need to initialize a presenter.
+      return %("") if template.source.empty?
 
-    if key = presenter.cache_key
-      @output_buffer = ActiveSupport::SafeBuffer.new
+      path = template.virtual_path
+      presenter_class = Curly::Presenter.presenter_for_path(path)
 
-      template_digest = #{template_digest.inspect}
+      source = Curly.compile(template.source, presenter_class)
+      template_digest = Digest::MD5.hexdigest(template.source)
 
-      if #{presenter_class}.respond_to?(:cache_key)
-        presenter_key = #{presenter_class}.cache_key
+      <<-RUBY
+      if local_assigns.empty?
+        options = assigns
       else
-        presenter_key = nil
+        options = local_assigns
       end
 
-      options = {
-        expires_in: presenter.cache_duration
-      }
+      presenter = #{presenter_class}.new(self, options.with_indifferent_access)
 
-      cache([template_digest, key, presenter_key].compact, options) do
-        safe_concat(view_function.call)
+      view_function = lambda do
+        #{source}
       end
 
-      @output_buffer
-    else
-      view_function.call.html_safe
+      if key = presenter.cache_key
+        @output_buffer = ActiveSupport::SafeBuffer.new
+
+        template_digest = #{template_digest.inspect}
+
+        if #{presenter_class}.respond_to?(:cache_key)
+          presenter_key = #{presenter_class}.cache_key
+        else
+          presenter_key = nil
+        end
+
+        options = {
+          expires_in: presenter.cache_duration
+        }
+
+        cache([template_digest, key, presenter_key].compact, options) do
+          safe_concat(view_function.call)
+        end
+
+        @output_buffer
+      else
+        view_function.call.html_safe
+      end
+      RUBY
+    end
+
+    def instrument(template, &block)
+      payload = { path: template.virtual_path }
+      ActiveSupport::Notifications.instrument("compile.curly", payload, &block)
     end
-    RUBY
   end
 end

data/spec/compiler_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+describe Curly::Compiler do
+  let :presenter_class do
+    Class.new do
+      def foo
+        "FOO"
+      end
+
+      def high_yield
+        "#{yield}, motherfucker!"
+      end
+
+      def yield_value
+        "#{yield :foo}, please?"
+      end
+
+      def unicorns
+        "UNICORN"
+      end
+
+      def dirty
+        nil
+      end
+
+      def parameterized(value)
+        value
+      end
+
+      def self.method_available?(method)
+        [:foo, :parameterized, :high_yield, :yield_value, :dirty].include?(method)
+      end
+
+      def self.available_methods
+        public_instance_methods
+      end
+
+      private
+
+      def method_missing(*args)
+        "BAR"
+      end
+    end
+  end
+
+  let(:presenter) { presenter_class.new }
+
+  describe ".compile" do
+    it "compiles Curly templates to Ruby code" 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 "makes sure only public methods are called on the presenter object" do
+      expect { evaluate("{{bar}}") }.to raise_exception(Curly::InvalidReference)
+    end
+
+    it "includes the invalid reference when failing to compile" do
+      begin
+        evaluate("{{bar}}")
+        fail
+      rescue Curly::InvalidReference => e
+        e.reference.should == :bar
+      end
+    end
+
+    it "propagates yields to the caller" do
+      evaluate("{{high_yield}}") { "$$$" }.should == "$$$, motherfucker!"
+    end
+
+    it "sends along arguments passed to yield" do
+      evaluate("{{yield_value}}") {|v| v.upcase }.should == "FOO, please?"
+    end
+
+    it "escapes non HTML safe strings returned from the presenter" do
+      presenter.stub(:dirty) { "<p>dirty</p>" }
+      evaluate("{{dirty}}").should == "&lt;p&gt;dirty&lt;/p&gt;"
+    end
+
+    it "does not escape HTML safe strings returned from the presenter" do
+      presenter.stub(:dirty) { "<p>dirty</p>".html_safe }
+      evaluate("{{dirty}}").should == "<p>dirty</p>"
+    end
+  end
+
+  describe ".valid?" do
+    it "returns true if only available methods are referenced" do
+      validate("Hello, {{foo}}!").should == true
+    end
+
+    it "returns false if a missing method is referenced" do
+      validate("Hello, {{i_am_missing}}").should == false
+    end
+
+    it "returns false if an unavailable method is referenced" do
+      presenter_class.stub(:available_methods) { [:foo] }
+      validate("Hello, {{inspect}}").should == false
+    end
+
+    def validate(template)
+      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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: curly-templates
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.7.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-29 00:00:00.000000000 Z
+date: 2013-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -115,14 +115,16 @@ files:
 - curly-templates.gemspec
 - lib/curly-templates.rb
 - lib/curly.rb
+- lib/curly/compiler.rb
 - lib/curly/dependency_tracker.rb
+- lib/curly/invalid_reference.rb
 - lib/curly/presenter.rb
 - lib/curly/railtie.rb
 - lib/curly/template_handler.rb
 - lib/generators/curly/controller/controller_generator.rb
 - lib/generators/curly/controller/templates/presenter.rb.erb
 - lib/generators/curly/controller/templates/view.html.curly.erb
-- spec/curly_spec.rb
+- spec/compiler_spec.rb
 - spec/generators/controller_generator_spec.rb
 - spec/presenter_spec.rb
 - spec/spec_helper.rb
@@ -143,7 +145,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3185475346795496979
+      hash: -1185334728510665354
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -157,7 +159,7 @@ signing_key:
 specification_version: 2
 summary: Free your views!
 test_files:
-- spec/curly_spec.rb
+- spec/compiler_spec.rb
 - spec/generators/controller_generator_spec.rb
 - spec/presenter_spec.rb
 - spec/template_handler_spec.rb

data/spec/curly_spec.rb

@@ -1,123 +0,0 @@
-require 'spec_helper'
-require 'curly'
-
-describe Curly do
-  let :presenter_class do
-    Class.new do
-      def foo
-        "FOO"
-      end
-
-      def high_yield
-        "#{yield}, motherfucker!"
-      end
-
-      def yield_value
-        "#{yield :foo}, please?"
-      end
-
-      def unicorns
-        "UNICORN"
-      end
-
-      def dirty
-        nil
-      end
-
-      def parameterized(value)
-        value
-      end
-
-      def self.method_available?(method)
-        [:foo, :parameterized, :high_yield, :yield_value, :dirty].include?(method)
-      end
-
-      def self.available_methods
-        public_instance_methods
-      end
-
-      private
-
-      def method_missing(*args)
-        "BAR"
-      end
-    end
-  end
-
-  let(:presenter) { presenter_class.new }
-
-  it "compiles Curly templates to Ruby code" 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 "makes sure only public methods are called on the presenter object" do
-    expect { evaluate("{{bar}}") }.to raise_exception(Curly::InvalidReference)
-  end
-
-  it "includes the invalid reference when failing to compile" do
-    begin
-      evaluate("{{bar}}")
-      fail
-    rescue Curly::InvalidReference => e
-      e.reference.should == :bar
-    end
-  end
-
-  it "propagates yields to the caller" do
-    evaluate("{{high_yield}}") { "$$$" }.should == "$$$, motherfucker!"
-  end
-
-  it "sends along arguments passed to yield" do
-    evaluate("{{yield_value}}") {|v| v.upcase }.should == "FOO, please?"
-  end
-
-  it "escapes non HTML safe strings returned from the presenter" do
-    presenter.stub(:dirty) { "<p>dirty</p>" }
-    evaluate("{{dirty}}").should == "&lt;p&gt;dirty&lt;/p&gt;"
-  end
-
-  it "does not escape HTML safe strings returned from the presenter" do
-    presenter.stub(:dirty) { "<p>dirty</p>".html_safe }
-    evaluate("{{dirty}}").should == "<p>dirty</p>"
-  end
-
-  describe ".valid?" do
-    it "returns true if only available methods are referenced" do
-      validate("Hello, {{foo}}!").should == true
-    end
-
-    it "returns false if a missing method is referenced" do
-      validate("Hello, {{i_am_missing}}").should == false
-    end
-
-    it "returns false if an unavailable method is referenced" do
-      presenter_class.stub(:available_methods) { [:foo] }
-      validate("Hello, {{inspect}}").should == false
-    end
-
-    def validate(template)
-      Curly.valid?(template, presenter_class)
-    end
-  end
-
-  def evaluate(template, &block)
-    code = Curly.compile(template, presenter_class)
-    context = double("context", presenter: presenter)
-
-    context.instance_eval(<<-RUBY)
-      def self.render
-        #{code}
-      end
-    RUBY
-
-    context.render(&block)
-  end
-end