curly-templates 2.0.1 → 2.1.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e826dc5149782e2edd2cb773a52640b9e57c65eb
-  data.tar.gz: 1c3672b608b4954d81e1385070c850a22a95d8f7
+  metadata.gz: 6cfdffc4b7505394d372817977a7ac58c3eae42d
+  data.tar.gz: 55c4eb68a070f354e165c26895fa8168b9d2e28b
 SHA512:
-  metadata.gz: bbc93550fccfd6bb3767f2e908db58a9b8386adfb21f0b53d2438fde2d1edb4d6d7034abb6514b38af4158718bdef4f25cb6f8dfb25d044ebb7f533d78c7eae1
-  data.tar.gz: 87694f0ffd409ca5a60bdc1411234ee7d0d1aec9b596cd45efe1ee6c830a52dbbefdd5dd1c4c073a4d0f3a9302d7d87a420bd0fbacfb7724363b8413bc8f7430
+  metadata.gz: 755ce7ead9b1a2330e7416fb770c343bca17b877fcf582d5d38634ff2a83f7c87f6acfef8ad7bfada134d29a4eb49c4411d058d502c0ef2530325670ff9982b0
+  data.tar.gz: d947e0a11699021badcd38e870a9bb2b59ae0364011e61b87623db3f747c606f1e898052bc51eec6a5fe1129e3b6196db370abf26330dd689ac06516f456b343

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ### Unreleased
 
+### Curly 2.1.0
+
+* Add support for [context blocks](https://github.com/zendesk/curly#context-blocks).
+
+  *Daniel Schierbeck*
+
 ### Curly 2.0.1 (September 9, 2014)
 
 * Fixed an issue when using Curly with Rails 4.1.

data/Gemfile

@@ -8,4 +8,6 @@ platform :ruby do
   gem 'redcarpet'
   gem 'github-markup'
   gem 'coveralls', require: false
+  gem 'rails', '~> 4.1.0', require: false
+  gem 'rspec-rails', require: false
 end

data/README.md

@@ -28,6 +28,7 @@ or [Handlebars](http://handlebarsjs.com/), Curly is different in some key ways:
     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)
@@ -263,6 +264,84 @@ Collection blocks are an alternative to splitting out a separate template and re
 that from the presenter – which solution is best depends on your use case.
 
 
+### Context blocks
+
+While collection blocks allow you to define the template that should be used to render
+items in a collection right within the parent template, **context blocks** allow you
+to define the template for an arbitrary context. This is very powerful, and can be used
+to define widget-style components and helpers, and provide an easy way to work with
+structured data. Let's say you have a comment form on your page, and you'd rather keep
+the template inline. A simple template could look like:
+
+```html
+<!-- post.html.curly -->
+<h1>{{title}}</h1>
+{{body}}
+
+{{@comment_form}}
+  <b>Name: </b> {{name_field}}<br>
+  <b>E-mail: </b> {{email_field}}<br>
+  {{comment_field}}
+  
+  {{submit_button}}
+{{/comment_form}}
+```
+
+Note that an `@` character is used to denote a context block. Like with
+[collection blocks](#collection-blocks), a separate presenter class is used within the
+block, and a simple convention is used to find it. The name of the context component
+(in this case, `comment_form`) will be camel cased, and the current presenter's namespace
+will be searched:
+
+```ruby
+class PostPresenter < Curly::Presenter
+  presents :post
+  def title; @post.title; end
+  def body; markdown(@post.body); end
+  
+  # A context block method *must* take a block argument. The return value
+  # of the method will be used when rendering. Calling the block argument will
+  # render the nested template. If you pass a value when calling the block
+  # argument it will be passed to the presenter.
+  def comment_form(&block)
+    form_for(Comment.new, &block)
+  end
+  
+  # The presenter name is automatically deduced.
+  class CommentFormPresenter < Curly::Presenter
+    # The value passed to the block argument will be passed in a parameter named
+    # after the component.
+    presents :comment_form
+
+    # Any parameters passed to the parent presenter will be forwarded to this
+    # presenter as well.
+    presents :post
+
+    def name_field
+      @comment_form.text_field :name
+    end
+
+    # ...
+  end
+end
+```
+
+Context blocks were designed to work well with Rails' helper methods such as `form_for`
+and `content_tag`, but you can also work directly with the block. For instance, if you
+want to directly control the value that is passed to the nested presenter, you can call
+the `call` method on the block yourself:
+
+```ruby
+def author(&block)
+  content_tag :div, class: "author" do
+    # The return value of `call` will be the result of rendering the nested template
+    # with the argument. You can post-process the string if you want.
+    block.call(@post.author)
+  end
+end
+```
+
+
 ### Setting up state
 
 Although most code in Curly presenters should be free of side effects, sometimes side
@@ -525,7 +604,7 @@ end
 Static caching will only be enabled for presenters that define a non-nil `#cache_key`
 method (see [Dynamic Caching.](#dynamic-caching))
 
-In order to make a deploy expire the cache for a specific view, set the version of the
+In order to make a deploy expire the cache for a specific view, set the `version` of the
 view to something new, usually by incrementing by one:
 
 ```ruby
@@ -559,7 +638,6 @@ end
 
 class Posts::CommentPresenter < Curly::Presenter
   version 4
-  depends_on 'posts/comment'
 
   def cache_key
     # Some objects
@@ -567,11 +645,13 @@ class Posts::CommentPresenter < Curly::Presenter
 end
 ```
 
-Now, if the version of `Posts::CommentPresenter` is bumped, the cache keys for both
+Now, if the `version` of `Posts::CommentPresenter` is bumped, the cache keys for both
 presenters would change. You can register any number of view paths with `depends_on`.
 
-If you use [Cache Digests](https://github.com/rails/cache_digests), Curly will
-automatically provide a list of dependencies. This will allow you to deploy changes
+Curly integrates well with the
+[caching mechanism](http://guides.rubyonrails.org/caching_with_rails.html) in Rails 4 (or
+[Cache Digests](https://github.com/rails/cache_digests) in Rails 3), so the dependencies
+defined with `depends_on` will be tracked by Rails. This will allow you to deploy changes
 to your templates and have the relevant caches automatically expire.
 
 

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.0.1'
-  s.date              = '2014-09-09'
+  s.version           = '2.1.0.beta1'
+  s.date              = '2014-11-03'
 
   s.summary     = "Free your views!"
   s.description = "A view layer for your Rails apps that separates structure and logic."
@@ -36,15 +36,16 @@ Gem::Specification.new do |s|
     curly-templates.gemspec
     lib/curly-templates.rb
     lib/curly.rb
-    lib/curly/attribute_parser.rb
+    lib/curly/attribute_scanner.rb
     lib/curly/compiler.rb
     lib/curly/component_compiler.rb
-    lib/curly/component_parser.rb
+    lib/curly/component_scanner.rb
     lib/curly/dependency_tracker.rb
     lib/curly/error.rb
     lib/curly/incomplete_block_error.rb
     lib/curly/incorrect_ending_error.rb
     lib/curly/invalid_component.rb
+    lib/curly/parser.rb
     lib/curly/presenter.rb
     lib/curly/presenter_not_found.rb
     lib/curly/railtie.rb
@@ -55,15 +56,43 @@ Gem::Specification.new do |s|
     lib/generators/curly/controller/templates/presenter.rb.erb
     lib/generators/curly/controller/templates/view.html.curly.erb
     lib/rails/projections.json
-    spec/attribute_parser_spec.rb
+    spec/attribute_scanner_spec.rb
+    spec/collection_blocks_spec.rb
     spec/compiler/collections_spec.rb
+    spec/compiler/context_blocks_spec.rb
     spec/compiler_spec.rb
     spec/component_compiler_spec.rb
+    spec/component_scanner_spec.rb
+    spec/components_spec.rb
+    spec/conditional_blocks_spec.rb
+    spec/dummy/.gitignore
+    spec/dummy/app/controllers/application_controller.rb
+    spec/dummy/app/controllers/dashboards_controller.rb
+    spec/dummy/app/helpers/application_helper.rb
+    spec/dummy/app/presenters/dashboards/collection_presenter.rb
+    spec/dummy/app/presenters/dashboards/item_presenter.rb
+    spec/dummy/app/presenters/dashboards/new_presenter.rb
+    spec/dummy/app/presenters/dashboards/partials_presenter.rb
+    spec/dummy/app/presenters/dashboards/show_presenter.rb
+    spec/dummy/app/presenters/layouts/application_presenter.rb
+    spec/dummy/app/views/dashboards/_item.html.curly
+    spec/dummy/app/views/dashboards/collection.html.curly
+    spec/dummy/app/views/dashboards/new.html.curly
+    spec/dummy/app/views/dashboards/partials.html.curly
+    spec/dummy/app/views/dashboards/show.html.curly
+    spec/dummy/app/views/layouts/application.html.curly
+    spec/dummy/config.ru
+    spec/dummy/config/application.rb
+    spec/dummy/config/boot.rb
+    spec/dummy/config/environment.rb
+    spec/dummy/config/environments/test.rb
+    spec/dummy/config/routes.rb
     spec/generators/controller_generator_spec.rb
-    spec/incorrect_ending_error_spec.rb
+    spec/integration/application_layout_spec.rb
     spec/integration/collection_blocks_spec.rb
-    spec/integration/components_spec.rb
-    spec/integration/conditional_blocks_spec.rb
+    spec/integration/context_blocks_spec.rb
+    spec/integration/partials_spec.rb
+    spec/parser_spec.rb
     spec/presenter_spec.rb
     spec/scanner_spec.rb
     spec/spec_helper.rb

data/lib/curly.rb

@@ -26,7 +26,7 @@
 # See Curly::Presenter for more information on presenters.
 #
 module Curly
-  VERSION = "2.0.1"
+  VERSION = "2.1.0.beta1"
 
   # Compiles a Curly template to Ruby code.
   #

data/lib/curly/{attribute_parser.rb → attribute_scanner.rb}

@@ -1,17 +1,19 @@
+require 'curly/error'
+
 module Curly
   AttributeError = Class.new(Curly::Error)
 
-  class AttributeParser
-    def self.parse(string)
+  class AttributeScanner
+    def self.scan(string)
       return {} if string.nil?
-      new(string).parse
+      new(string).scan
     end
 
     def initialize(string)
       @scanner = StringScanner.new(string)
     end
 
-    def parse
+    def scan
       attributes = scan_attributes
       Hash[attributes]
     end

data/lib/curly/compiler.rb

@@ -1,10 +1,8 @@
 require 'curly/scanner'
+require 'curly/parser'
 require 'curly/component_compiler'
-require 'curly/component_parser'
 require 'curly/error'
 require 'curly/invalid_component'
-require 'curly/incorrect_ending_error'
-require 'curly/incomplete_block_error'
 
 module Curly
 
@@ -26,7 +24,16 @@ module Curly
     # Raises IncompleteBlockError if a block is not completed.
     # Returns a String containing the Ruby code.
     def self.compile(template, presenter_class)
-      new(template, presenter_class).compile
+      if presenter_class.nil?
+        raise ArgumentError, "presenter class cannot be nil"
+      end
+
+      tokens = Scanner.scan(template)
+      nodes = Parser.parse(tokens)
+
+      compiler = new(presenter_class)
+      compiler.compile(nodes)
+      compiler.code
     end
 
     # Whether the Curly template is valid. This includes whether all
@@ -44,34 +51,22 @@ module Curly
       false
     end
 
-    attr_reader :template
-
-    def initialize(template, presenter_class)
-      @template = template
+    def initialize(presenter_class)
       @presenter_classes = [presenter_class]
+      @parts = []
     end
 
-    def compile
-      if presenter_class.nil?
-        raise ArgumentError, "presenter class cannot be nil"
-      end
-
-      tokens = Scanner.scan(template)
-
-      @blocks = []
-
-      parts = tokens.map do |type, value|
-        send("compile_#{type}", value)
-      end
-
-      if @blocks.any?
-        raise IncompleteBlockError.new(@blocks.pop)
+    def compile(nodes)
+      nodes.each do |node|
+        send("compile_#{node.type}", node)
       end
+    end
 
+    def code
       <<-RUBY
         buffer = ActiveSupport::SafeBuffer.new
         presenters = []
-        #{parts.join("\n")}
+        #{@parts.join("\n")}
         buffer
       RUBY
     end
@@ -82,100 +77,114 @@ module Curly
       @presenter_classes.last
     end
 
-    def compile_conditional_block_start(component)
-      compile_conditional_block "if", component
+    def compile_conditional(block)
+      compile_conditional_block("if", block)
     end
 
-    def compile_inverse_conditional_block_start(component)
-      compile_conditional_block "unless", component
+    def compile_inverse_conditional(block)
+      compile_conditional_block("unless", block)
     end
 
-    def compile_collection_block_start(component)
-      name, identifier, attributes = ComponentParser.parse(component)
-      method_call = ComponentCompiler.compile_component(presenter_class, name, identifier, attributes)
+    def compile_collection(block)
+      component = block.component
+      method_call = ComponentCompiler.compile(presenter_class, component)
 
-      as = name.singularize
-      counter = "#{as}_counter"
+      name = component.name.singularize
+      counter = "#{name}_counter"
 
       begin
-        item_presenter_class = presenter_class.presenter_for_name(as)
+        item_presenter_class = presenter_class.presenter_for_name(name)
       rescue NameError
         raise Curly::Error,
-          "cannot enumerate `#{component}`, could not find matching presenter class"
+          "cannot enumerate `#{name}`, could not find matching presenter class"
       end
 
-      push_block(name, identifier)
-      @presenter_classes.push(item_presenter_class)
-
-      <<-RUBY
+      output <<-RUBY
         presenters << presenter
         items = Array(#{method_call})
         items.each_with_index do |item, index|
-          item_options = options.merge(:#{as} => item, :#{counter} => index + 1)
+          item_options = options.merge(:#{name} => item, :#{counter} => index + 1)
           presenter = #{item_presenter_class}.new(self, item_options)
       RUBY
+
+      @presenter_classes.push(item_presenter_class)
+      compile(block.nodes)
+      @presenter_classes.pop
+
+      output <<-RUBY
+        end
+        presenter = presenters.pop
+      RUBY
     end
 
-    def compile_conditional_block(keyword, component)
-      name, identifier, attributes = ComponentParser.parse(component)
-      method_call = ComponentCompiler.compile_conditional(presenter_class, name, identifier, attributes)
+    def compile_conditional_block(keyword, block)
+      component = block.component
+      method_call = ComponentCompiler.compile(presenter_class, component)
 
-      push_block(name, identifier)
+      unless component.name.end_with?("?")
+        raise Curly::Error, "conditional components must end with `?`"
+      end
 
-      <<-RUBY
+      output <<-RUBY
         #{keyword} #{method_call}
       RUBY
-    end
 
-    def compile_conditional_block_end(component)
-      validate_block_end(component)
+      compile(block.nodes)
 
-      <<-RUBY
+      output <<-RUBY
         end
       RUBY
     end
 
-    def compile_collection_block_end(component)
+    def compile_context(block)
+      component = block.component
+      method_call = ComponentCompiler.compile(presenter_class, component, type: block.type)
+
+      name = component.name
+
+      begin
+        item_presenter_class = presenter_class.presenter_for_name(name)
+      rescue NameError
+        raise Curly::Error,
+          "cannot use context `#{name}`, could not find matching presenter class"
+      end
+
+      output <<-RUBY
+        presenters << presenter
+        old_buffer, buffer = buffer, ActiveSupport::SafeBuffer.new
+        old_buffer << #{method_call} do |item|
+          item_options = options.merge(:#{name} => item)
+          presenter = #{item_presenter_class}.new(self, item_options.with_indifferent_access)
+      RUBY
+
+      @presenter_classes.push(item_presenter_class)
+      compile(block.nodes)
       @presenter_classes.pop
-      validate_block_end(component)
 
-      <<-RUBY
+      output <<-RUBY
         end
+        buffer = old_buffer
         presenter = presenters.pop
       RUBY
     end
 
     def compile_component(component)
-      name, identifier, attributes = ComponentParser.parse(component)
-      method_call = ComponentCompiler.compile_component(presenter_class, name, identifier, attributes)
+      method_call = ComponentCompiler.compile(presenter_class, component)
       code = "#{method_call} {|*args| yield(*args) }"
 
-      "buffer.concat(#{code.strip}.to_s)"
+      output "buffer.concat(#{code.strip}.to_s)"
     end
 
     def compile_text(text)
-      "buffer.safe_concat(#{text.inspect})"
+      output "buffer.safe_concat(#{text.value.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
-
-      if last_block.nil?
-        raise Curly::Error, "block ending not expected"
-      end
-
-      unless last_block == [name, identifier]
-        raise Curly::IncorrectEndingError.new([name, identifier], last_block)
-      end
+      # Do nothing.
     end
 
-    def push_block(name, identifier)
-      @blocks.push([name, identifier])
+    def output(code)
+      @parts << code
     end
   end
 end