curlybars 1.3.1 → 1.7.0

data/lib/curlybars/node/unless_else.rb

@@ -15,7 +15,7 @@ module Curlybars
 
       def validate(branches)
         [
-          expression.validate(branches, check_type: :not_helper),
+          expression.validate(branches),
           unless_template.validate(branches),
           else_template.validate(branches)
         ]

data/lib/curlybars/node/with_else.rb

@@ -9,7 +9,7 @@ module Curlybars
 
           if rendering.to_bool(compiled_path)
             position = rendering.position(#{position.line_number}, #{position.line_offset})
-            rendering.check_context_is_presenter(compiled_path, #{path.path.inspect}, position)
+            rendering.check_context_is_presenter(compiled_path, #{presenter_path.path.inspect}, position)
 
             contexts.push(compiled_path)
             begin
@@ -24,7 +24,7 @@ module Curlybars
       end
 
       def validate(branches)
-        sub_tree = path.resolve_and_check!(branches, check_type: :presenter)
+        sub_tree = path.resolve_and_check!(branches, check_type: :presenterlike)
         with_template_errors = begin
           branches.push(sub_tree)
           with_template.validate(branches)
@@ -42,6 +42,10 @@ module Curlybars
         path_error
       end
 
+      def presenter_path
+        path.subexpression? ? path.helper : path
+      end
+
       def cache_key
         [
           path,

data/lib/curlybars/parser.rb

@@ -15,6 +15,7 @@ require 'curlybars/node/block_helper_else'
 require 'curlybars/node/option'
 require 'curlybars/node/partial'
 require 'curlybars/node/output'
+require 'curlybars/node/sub_expression'
 
 module Curlybars
   class Parser < RLTK::Parser
@@ -111,6 +112,12 @@ module Curlybars
         Node::EachElse.new(path, each_template || VOID, VOID, pos(0))
       end
 
+      clause('START HASH EACH .subexpression END
+              .template?
+            START SLASH EACH END') do |subexpression, each_template|
+        Node::EachElse.new(subexpression, each_template || VOID, VOID, pos(0))
+      end
+
       clause('START HASH EACH .path END
                .template?
              START ELSE END
@@ -119,12 +126,26 @@ module Curlybars
         Node::EachElse.new(path, each_template || VOID, else_template || VOID, pos(0))
       end
 
+      clause('START HASH EACH .subexpression END
+               .template?
+             START ELSE END
+               .template?
+             START SLASH EACH END') do |subexpression, each_template, else_template|
+        Node::EachElse.new(subexpression, each_template || VOID, else_template || VOID, pos(0))
+      end
+
       clause('START HASH WITH .path END
                .template?
              START SLASH WITH END') do |path, with_template|
         Node::WithElse.new(path, with_template || VOID, VOID, pos(0))
       end
 
+      clause('START HASH WITH .subexpression END
+              .template?
+            START SLASH WITH END') do |subexpression, with_template|
+        Node::WithElse.new(subexpression, with_template || VOID, VOID, pos(0))
+      end
+
       clause('START HASH WITH .path END
                .template?
              START ELSE END
@@ -133,6 +154,14 @@ module Curlybars
         Node::WithElse.new(path, with_template || VOID, else_template || VOID, pos(0))
       end
 
+      clause('START HASH WITH .subexpression END
+              .template?
+            START ELSE END
+              .template?
+            START SLASH WITH END') do |subexpression, with_template, else_template|
+        Node::WithElse.new(subexpression, with_template || VOID, else_template || VOID, pos(0))
+      end
+
       clause('START GT .path END') do |path|
         Node::Partial.new(path)
       end
@@ -155,6 +184,7 @@ module Curlybars
     production(:expression) do
       clause('value') { |value| value }
       clause('path') { |path| path }
+      clause('subexpression') { |subexpression| subexpression }
     end
 
     production(:value) do
@@ -164,6 +194,15 @@ module Curlybars
 
     production(:path, 'PATH') { |path| Node::Path.new(path, pos(0)) }
 
+    production(:subexpression, 'LPAREN .path .expressions? .options? RPAREN') do |helper, arguments, options|
+      Node::SubExpression.new(
+        helper,
+        arguments || [],
+        options || [],
+        pos(0)
+      )
+    end
+
     finalize
 
     VOID = Class.new do

data/lib/curlybars/processor/tilde.rb

@@ -10,10 +10,12 @@ module Curlybars
             when :TILDE_START
               tokens[index] = create_token(:START, token.value, token.position)
               next if index == 0
+
               strip_token_if_text(tokens, index - 1, :rstrip)
             when :TILDE_END
               tokens[index] = create_token(:END, token.value, token.position)
               next if index == (tokens.length - 1)
+
               strip_token_if_text(tokens, index + 1, :lstrip)
             end
           end
@@ -22,6 +24,7 @@ module Curlybars
         def strip_token_if_text(tokens, index, strip_method)
           token = tokens[index]
           return if token.type != :TEXT
+
           stripped_value = token.value.public_send(strip_method)
           tokens[index] = create_token(token.type, stripped_value, token.position)
         end

data/lib/curlybars/rendering_support.rb

@@ -23,12 +23,14 @@ module Curlybars
     def check_timeout!
       return unless timeout.present?
       return unless (Time.now - start_time) > timeout
+
       message = "Rendering took too long (> #{timeout} seconds)"
       raise ::Curlybars::Error::Render.new('timeout', message, nil)
     end
 
     def check_context_is_presenter(context, path, position)
       return if presenter?(context)
+
       message = "`#{path}` is not a context type object"
       raise Curlybars::Error::Render.new('context_is_not_a_presenter', message, position)
     end
@@ -83,9 +85,11 @@ module Curlybars
       resolved = chain.inject(base_context) do |context, meth|
         next context if meth == 'this'
         next context.count if meth == 'length' && presenter_collection?(context)
+
         raise_if_not_traversable(context, meth, position)
         outcome = instrument(context.method(meth)) { context.public_send(meth) }
         return -> {} if outcome.nil?
+
         outcome
       end
 
@@ -101,7 +105,8 @@ module Curlybars
 
     def cached_call(meth)
       return cached_calls[meth] if cached_calls.key? meth
-      instrument(meth) { cached_calls[meth] = meth.call }
+
+      instrument(meth) { cached_calls[meth] = meth.call(*arguments_for_signature(meth, [], {})) }
     end
 
     def call(helper, helper_path, helper_position, arguments, options, &block)
@@ -202,6 +207,7 @@ module Curlybars
 
     def check_context_allows_method(context, meth, position)
       return if context.allows_method?(meth.to_sym)
+
       message = "`#{meth}` is not available - "
       message += "add `allow_methods :#{meth}` to #{context.class} to allow this path"
       raise Curlybars::Error::Render.new('unallowed_path', message, position, meth: meth.to_sym)
@@ -209,12 +215,14 @@ module Curlybars
 
     def check_context_has_method(context, meth, position)
       return if context.respond_to?(meth.to_sym)
+
       message = "`#{meth}` is not available in #{context.class}"
       raise Curlybars::Error::Render.new('unallowed_path', message, position)
     end
 
     def check_traverse_not_too_deep(traverse, position)
       return unless traverse.count('.') > Curlybars.configuration.traversing_limit
+
       message = "`#{traverse}` too deep"
       raise Curlybars::Error::Render.new('traverse_too_deep', message, position)
     end

data/lib/curlybars/template_handler.rb

@@ -13,9 +13,17 @@ module Curlybars
       # 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)
+      if ActionView::VERSION::MAJOR < 6
+        def call(template)
+          instrument(template) do
+            compile_for_actionview5(template)
+          end
+        end
+      else
+        def call(template, source)
+          instrument(template) do
+            compile(template, source)
+          end
         end
       end
 
@@ -43,9 +51,13 @@ module Curlybars
 
       private
 
-      def compile(template)
+      def compile_for_actionview5(template)
+        compile(template, template.source)
+      end
+
+      def compile(template, source)
         # Template is empty, so there's no need to initialize a presenter.
-        return %("") if template.source.empty?
+        return %("") if source.empty?
 
         path = template.virtual_path
         presenter_class = Curlybars::Presenter.presenter_for_path(path)
@@ -55,7 +67,7 @@ module Curlybars
         # For security reason, we strip the encoding directive in order to avoid
         # potential issues when rendering the template in another character
         # encoding.
-        safe_source = template.source.gsub(/\A#{ActionView::ENCODING_FLAG}/, '')
+        safe_source = source.gsub(/\A#{ActionView::ENCODING_FLAG}/, '')
 
         source = Curlybars.compile(safe_source, template.identifier)
 

data/lib/curlybars/version.rb

@@ -1,3 +1,3 @@
 module Curlybars
-  VERSION = '1.3.1'.freeze
+  VERSION = '1.7.0'.freeze
 end

data/lib/curlybars/visitor.rb

@@ -75,6 +75,12 @@ module Curlybars
     def visit_string(_node)
     end
 
+    def visit_sub_expression(node)
+      visit(node.helper)
+      node.arguments.each { |argument| visit(argument) }
+      node.options.each { |option| visit(option) }
+    end
+
     def visit_template(node)
       node.items.each { |item| visit(item) }
     end

data/spec/acceptance/application_layout_spec.rb

@@ -2,7 +2,7 @@ describe "Using Curlybars for the application layout", type: :request do
   example "A simple layout view in Curlybars" do
     get '/'
 
-    expect(body).to eq(<<-HTML.strip_heredoc)
+    expect(body).to eq(<<~HTML)
       <html>
       <head>
         <title>Dummy app</title>
@@ -31,7 +31,7 @@ describe "Using Curlybars for the application layout", type: :request do
     example "A simple layout view in Curlybars with html safe logic" do
       get '/articles/1'
 
-      expect(body).to eq(<<-HTML.strip_heredoc)
+      expect(body).to eq(<<~HTML)
         <html>
         <head>
           <title>Dummy app</title>

data/spec/acceptance/collection_blocks_spec.rb

@@ -8,7 +8,7 @@ describe "Collection blocks", type: :request do
   example "Rendering collections" do
     get '/categories'
 
-    expect(body).to eq(<<-HTML.strip_heredoc)
+    expect(body).to eq(<<~HTML)
       <html>
       <head>
         <title>Dummy app</title>

data/spec/acceptance/global_helper_spec.rb

@@ -9,7 +9,7 @@ describe "Collection blocks", type: :request do
   example "Render a global helper" do
     get '/welcome'
 
-    expect(body).to eq(<<-HTML.strip_heredoc)
+    expect(body).to eq(<<~HTML)
       <html>
       <head>
         <title>Dummy app</title>

data/spec/curlybars/lexer_spec.rb

@@ -37,6 +37,7 @@ describe Curlybars::Lexer do
     it "is resilient to whitespaces" do
       expect(lex('{{! }}')).to produce []
     end
+
     it "is resilient to newlines" do
       expect(lex("{{!\n}}")).to produce []
     end
@@ -160,6 +161,28 @@ describe Curlybars::Lexer do
     end
   end
 
+  describe "{{path (path context options)}}" do
+    it "is lexed with path, context and options" do
+      expect(lex('{{path (path context key=value)}}')).to produce [:START, :PATH, :LPAREN, :PATH, :PATH, :KEY, :PATH, :RPAREN, :END]
+    end
+
+    it "is lexed without options" do
+      expect(lex('{{path (path context)}}')).to produce [:START, :PATH, :LPAREN, :PATH, :PATH, :RPAREN, :END]
+    end
+
+    it "is lexed without context" do
+      expect(lex('{{path (path key=value)}}')).to produce [:START, :PATH, :LPAREN, :PATH, :KEY, :PATH, :RPAREN, :END]
+    end
+
+    it "is lexed without context and options" do
+      expect(lex('{{path (path)}}')).to produce [:START, :PATH, :LPAREN, :PATH, :RPAREN, :END]
+    end
+
+    it "is lexed with a nested subexpression" do
+      expect(lex('{{path (path (path context key=value) key=value)}}')).to produce [:START, :PATH, :LPAREN, :PATH, :LPAREN, :PATH, :PATH, :KEY, :PATH, :RPAREN, :KEY, :PATH, :RPAREN, :END]
+    end
+  end
+
   describe "{{#if path}}...{{/if}}" do
     it "is lexed" do
       expect(lex('{{#if path}} text {{/if}}')).to produce(
@@ -180,7 +203,7 @@ describe Curlybars::Lexer do
     end
   end
 
-  # rubocop:disable Layout/AlignArray
+  # rubocop:disable Layout/ArrayAlignment
   describe "{{#if path}}...{{else}}...{{/if}}" do
     it "is lexed" do
       expect(lex('{{#if path}} text {{else}} text {{/if}}')).to produce(
@@ -298,7 +321,7 @@ describe Curlybars::Lexer do
       )
     end
   end
-  # rubocop:enable Layout/AlignArray
+  # rubocop:enable Layout/ArrayAlignment
 
   describe "{{#with path}}...{{/with}}" do
     it "is lexed" do

data/spec/curlybars/method_whitelist_spec.rb

@@ -36,16 +36,20 @@ describe Curlybars::MethodWhitelist do
 
   describe ".allow_methods" do
     before do
-      link_presenter = Class.new
-      article_presenter = Class.new
+      link_presenter = Class.new { extend Curlybars::MethodWhitelist }
+      article_presenter = Class.new { extend Curlybars::MethodWhitelist }
 
       dummy_class.class_eval do
-        allow_methods :cook, link: link_presenter, article: article_presenter
+        allow_methods :cook, link: link_presenter, article: article_presenter,
+                      translate_article: [:helper, article_presenter],
+                      reverse_articles: [:helper, [article_presenter]],
+                      translate: [:helper, Curlybars::Generic],
+                      slice: [:helper, [Curlybars::Generic]]
       end
     end
 
     it "sets the allowed methods" do
-      expect(dummy_class.new.allowed_methods).to eq([:cook, :link, :article])
+      expect(dummy_class.new.allowed_methods).to eq([:cook, :link, :article, :translate_article, :reverse_articles, :translate, :slice])
     end
 
     it "supports adding more methods for validation" do

data/spec/curlybars/rendering_support_spec.rb

@@ -1,3 +1,4 @@
+# rubocop:disable RSpec/MultipleMemoizedHelpers
 describe Curlybars::RenderingSupport do
   let(:file_name) { '/app/views/template.hbs' }
   let(:presenter) { double(:presenter, allows_method?: true, meth: :value) }
@@ -7,7 +8,6 @@ describe Curlybars::RenderingSupport do
   let(:position) do
     double(:position, file_name: 'template.hbs', line_number: 1, line_offset: 0)
   end
-  let(:block) { -> {} }
 
   describe "#check_timeout!" do
     it "skips checking if timeout is nil" do
@@ -179,14 +179,6 @@ describe Curlybars::RenderingSupport do
   end
 
   describe "#cached_call" do
-    before do
-      class APresenter
-        def meth
-          :value
-        end
-      end
-    end
-
     it "(cache miss) calls the method if not cached already" do
       meth = presenter.method(:meth)
       allow(meth).to receive(:call)
@@ -217,6 +209,8 @@ describe Curlybars::RenderingSupport do
   end
 
   describe "#call" do
+    let(:block) { -> {} }
+
     it "calls with no arguments a method with no parameters" do
       method = -> { :return }
       arguments = []
@@ -424,3 +418,4 @@ describe Curlybars::RenderingSupport do
     allow(presenter).to receive(:allows_method?).and_return(false)
   end
 end
+# rubocop:enable RSpec/MultipleMemoizedHelpers

data/spec/curlybars/template_handler_spec.rb

@@ -100,13 +100,11 @@ describe Curlybars::TemplateHandler do
   end
 
   it "strips the `# encoding: *` directive away from the template" do
-    allow(template).to receive(:source) do
-      <<-TEMPLATE.strip_heredoc
-        # encoding: utf-8"
-        first line
-      TEMPLATE
-    end
-    expect(output).to eq(<<-TEMPLATE.strip_heredoc)
+    output = render(<<~TEMPLATE)
+      # encoding: utf-8"
+      first line
+    TEMPLATE
+    expect(output).to eq(<<~TEMPLATE)
 
       first line
     TEMPLATE
@@ -114,55 +112,54 @@ describe Curlybars::TemplateHandler do
 
   it "passes in the presenter context to the presenter class" do
     allow(context).to receive(:bar).and_return("BAR")
-    allow(template).to receive(:source).and_return("{{bar}}")
+    output = render("{{bar}}")
     expect(output).to eq("BAR")
   end
 
   it "fails if there's no matching presenter class" do
     allow(template).to receive(:virtual_path).and_return("missing")
-    allow(template).to receive(:source).and_return(" FOO ")
-    expect { output }.to raise_exception(Curlybars::Error::Presenter::NotFound)
+    expect { render(" FOO ") }.to raise_exception(Curlybars::Error::Presenter::NotFound)
   end
 
   it "allows calling public methods on the presenter" do
-    allow(template).to receive(:source).and_return("{{foo}}")
+    output = render("{{foo}}")
     expect(output).to eq("FOO")
   end
 
   it "marks its output as HTML safe" do
-    allow(template).to receive(:source).and_return("{{foo}}")
+    output = render("{{foo}}")
     expect(output).to be_html_safe
   end
 
   it "calls the #setup! method before rendering the view" do
-    allow(template).to receive(:source).and_return("{{foo}}")
-    output
+    render("{{foo}}")
     expect(context.content_for(:foo)).to eq("bar")
   end
 
   describe "caching" do
     before do
-      allow(template).to receive(:source).and_return("{{bar}}")
       allow(context).to receive(:bar).and_return("BAR")
     end
 
+    let(:output) { -> { render("{{bar}}") } }
+
     it "caches the result with the #cache_key from the presenter" do
       context.assigns[:cache_key] = "x"
-      expect(output).to eq("BAR")
+      expect(output.call).to eq("BAR")
 
       allow(context).to receive(:bar).and_return("BAZ")
-      expect(output).to eq("BAR")
+      expect(output.call).to eq("BAR")
 
       context.assigns[:cache_key] = "y"
-      expect(output).to eq("BAZ")
+      expect(output.call).to eq("BAZ")
     end
 
     it "doesn't cache when the cache key is nil" do
       context.assigns[:cache_key] = nil
-      expect(output).to eq("BAR")
+      expect(output.call).to eq("BAR")
 
       allow(context).to receive(:bar).and_return("BAZ")
-      expect(output).to eq("BAZ")
+      expect(output.call).to eq("BAZ")
     end
 
     it "adds the presenter class' cache key to the instance's cache key" do
@@ -171,51 +168,57 @@ describe Curlybars::TemplateHandler do
 
       allow(presenter_class).to receive(:cache_key).and_return("foo")
 
-      expect(output).to eq("BAR")
+      expect(output.call).to eq("BAR")
 
       allow(presenter_class).to receive(:cache_key).and_return("bar")
 
       allow(context).to receive(:bar).and_return("FOOBAR")
-      expect(output).to eq("FOOBAR")
+      expect(output.call).to eq("FOOBAR")
     end
 
     it "expires the cache keys after #cache_duration" do
       context.assigns[:cache_key] = "x"
       context.assigns[:cache_duration] = 42
 
-      expect(output).to eq("BAR")
+      expect(output.call).to eq("BAR")
 
       allow(context).to receive(:bar).and_return("FOO")
 
       # Cached fragment has not yet expired.
       context.advance_clock(41)
-      expect(output).to eq("BAR")
+      expect(output.call).to eq("BAR")
 
       # Now it has! Huzzah!
       context.advance_clock(1)
-      expect(output).to eq("FOO")
+      expect(output.call).to eq("FOO")
     end
 
     it "passes #cache_options to the cache backend" do
       context.assigns[:cache_key] = "x"
       context.assigns[:cache_options] = { expires_in: 42 }
 
-      expect(output).to eq("BAR")
+      expect(output.call).to eq("BAR")
 
       allow(context).to receive(:bar).and_return("FOO")
 
       # Cached fragment has not yet expired.
       context.advance_clock(41)
-      expect(output).to eq("BAR")
+      expect(output.call).to eq("BAR")
 
       # Now it has! Huzzah!
       context.advance_clock(1)
-      expect(output).to eq("FOO")
+      expect(output.call).to eq("FOO")
     end
   end
 
-  def output
-    code = Curlybars::TemplateHandler.call(template)
+  def render(source)
+    if ActionView::VERSION::MAJOR < 6
+      allow(template).to receive(:source).and_return(source)
+      code = Curlybars::TemplateHandler.call(template)
+    else
+      code = Curlybars::TemplateHandler.call(template, source)
+    end
+
     context.reset!
     context.instance_eval(code)
   end