mvz-ruby-handlebars 0.0.8 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f21f04865d286b910b694ff3508df456632310bb99aa38b22f9e24d68032bff6
-  data.tar.gz: d05c3566c291638e663295f8a0f425c09f961257e738d8ef1235f3a1b326fb66
+  metadata.gz: c677856bd3e74f5198f64f3b10b9348530b95024889ff1cf6db380c1165c771f
+  data.tar.gz: 1ff2e3bba711f257d9412ef9aa074fad8ca87429ab5b2ad0033187b289c586e0
 SHA512:
-  metadata.gz: 2554ca12e855afd1777dc31de33d125ff0fb7fd9cc657af834231cdf2e67674bbe7e37d21a0480a382127e12d8477e800f2afc43e5a120b27ed54380c18c07e1
-  data.tar.gz: 6fcfb339dadb0924ba02d6a1f4f139459a8f01da7b5137978edb13d4121f1e9122f211ef99b09ec8d9f49d03e5bcebf23de8d75c4dcfa6249a518296aff619c4
+  metadata.gz: 00be980edd23a6f537a5c7e6354f592826651a795f4a4b7055f26db4d31778c90c7e8a9367e9450578bf0b8c74d690409c52137c337017074edd6163c8148ff2
+  data.tar.gz: 2d89f9b244cad437e7ee33b75562197071dac7d0ccb66be0b83d183f86b9774b16c79178f467fa8f72201b9ef563bbc8b7bc7c2288b81462718f0a7aff5b1b07

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+mvz-ruby-handlebars changelog
+=============================
+
+0.0.9 (2021-01-04)
+------------------
+
+ - Pull in upstream master. See
+   https://github.com/SmartBear/ruby-handlebars/blob/master/CHANGELOG.md for
+   included changes.
+ - Prefer variable over helper when processing a replacement if the helper has the wrong arity

data/README.md

@@ -40,6 +40,13 @@ hbs.compile("Hello {{> full_name}}").call({person: {first_name: 'Pinkie', last_n
 # Gives: "Hello Pinkie Pie"
 ```
 
+Partials support parameters:
+```ruby
+hbs.register_partial('full_name', "{{fname}} {{lname}}")
+hbs.compile("Hello {{> full_name fname='jon' lname='doe'}}")
+# Gives: "Hello jon doe"
+```
+
 You can also register inline helpers:
 
 ```ruby
@@ -81,22 +88,59 @@ hbs.compile(template).call({description: my_description})
 # Output will depend on the validity of the 'my_description' variable
 ```
 
-Two default helpers are provided: ``each`` and ``if``. It is not yet possible to name the current item in an each loop and ``this`` must be used to reference it.
+Default helpers:
+----------------
+
+Three default helpers are provided: ``each``, ``if`` and ``unless``.
+
+The each helper let you walk through a list. You can either use the basic notation and referencing the current item as ``this``:
+
+```
+  {{#each items}}
+    {{{ this }}}
+  {{else}}
+    No items
+  {{/each}}
+```
+
+or the "as |name|" notation:
+
+```
+  {{#each items as |item| }}
+    {{{ item }}}
+  {{else}}
+    No items
+  {{/each}}
+```
+
+The ``if`` helper can be used to write conditionnal templates:
+
+```
+  {{#if my_condition}}
+    It's ok
+  {{else}}
+    or maybe not
+  {{/if}}
+```
+
+The ``unless`` helper works the opposite way to ``if``:
+
+```
+  {{#unless my_condition}}
+    It's not ok
+  {{else}}
+    or maybe it is
+  {{/unless}}
+```
+
+Currently, if you call an unknown helper, it will raise an exception. You can override that by registering your own version of the ``helperMissing`` helper. Note that only the name of the missing helper will be provided.
+
+For example:
 
 ```ruby
-template = [
-  "{{#each items}}",
-  "  {{{ this }}}",
-  "{{else}}",
-  "  No items",
-  "{{/each}}",
-  "",
-  "{{#if my_condition}}",
-  "  It's ok",
-  "{{else}}",
-  "  or maybe not",
-  "{{/if}}",
-].join("\n")
+hbs.register_helper('helperMissing') do |context, name|
+  puts "No helper found with name #{name}"
+end
 ```
 
 Limitations and roadmap
@@ -104,12 +148,10 @@ Limitations and roadmap
 
 This gem does not reuse the real Handlebars code (the JS one) and not everything is handled yet (but it will be someday ;) ):
 
- - there is no escaping, all strings are considered as safe (so ``{{{ my_var }}}`` and ``{{ my_var }}``) will output the same thing
  - the parser is not fully tested yet, it may complain with spaces ...
- - curly bracket are __not__ usable in the template content yet. one workaround is to create simple helpers to generate them
  - parsing errors are, well, not helpful at all
 
 Aknowledgements
 ---------------
 
-This is a fork of the [ruby-handlebars]("https://github.com/vincent-psarga/ruby-handlebars") gem, which sadly seems unmaintained.
+This is a fork of the [ruby-handlebars]("https://github.com/vincent-psarga/ruby-handlebars") gem. Eventually I hope to have all my changes accepted upstream so I can abandon this fork.

data/lib/ruby-handlebars.rb

@@ -1,17 +1,23 @@
 require_relative 'ruby-handlebars/version'
-require_relative 'ruby-handlebars/helper'
 require_relative 'ruby-handlebars/context'
 require_relative 'ruby-handlebars/parser'
-require_relative 'ruby-handlebars/template'
 require_relative 'ruby-handlebars/tree'
+require_relative 'ruby-handlebars/template'
+require_relative 'ruby-handlebars/helper'
+require_relative 'ruby-handlebars/helpers/register_default_helpers'
+require_relative 'ruby-handlebars/escapers/html_escaper'
 
 module Handlebars
   class Handlebars
+    attr_reader :escaper
+
     def initialize
+      @as_helpers = {}
       @helpers = {}
       @partials = {}
 
       register_default_helpers
+      set_escaper
     end
 
     def compile(template)
@@ -22,10 +28,18 @@ module Handlebars
       @helpers[name.to_s] = Helper.new(self, fn)
     end
 
+    def register_as_helper(name, &fn)
+      @as_helpers[name.to_s] = Helper.new(self, fn)
+    end
+
     def get_helper(name)
       @helpers[name.to_s]
     end
 
+    def get_as_helper(name)
+      @as_helpers[name.to_s]
+    end
+
     def register_partial(name, content)
       @partials[name.to_s] = Template.new(self, template_to_ast(content))
     end
@@ -34,6 +48,10 @@ module Handlebars
       @partials[name.to_s]
     end
 
+    def set_escaper(escaper = nil)
+      @escaper = escaper || Escapers::HTMLEscaper
+    end
+
     private
 
     PARSER = Parser.new
@@ -44,42 +62,7 @@ module Handlebars
     end
 
     def register_default_helpers
-      register_if_helper
-      register_each_helper
-    end
-
-    def register_if_helper
-      register_helper('if') do |context, condition, block, else_block|
-        condition = !condition.empty? if condition.respond_to?(:empty?)
-
-        if condition
-          block.fn(context)
-        elsif else_block
-          else_block.fn(context)
-        else
-          ""
-        end
-      end
-    end
-
-    def register_each_helper
-      register_helper('each') do |context, items, block, else_block|
-        current_this = context.get('this')
-
-        if (items.nil? || items.empty?)
-          if else_block
-            result = else_block.fn(context)
-          end
-        else
-          result = items.map do |item|
-            context.add_item(:this, item)
-            block.fn(context)
-          end.join('')
-        end
-
-        context.add_item(:this, current_this)
-        result
-      end
+      Helpers.register_default_helpers(self)
     end
   end
 end

data/lib/ruby-handlebars/context.rb

@@ -8,12 +8,12 @@ module Handlebars
 
     def get(path)
       items = path.split('.'.freeze)
-
-      if @locals.key? items.first.to_sym
-        current = @locals
+      if locals.key? items.first.to_sym
+        current = locals
       else
         current = @data
       end
+
       until items.empty?
         current = get_attribute(current, items.shift)
       end
@@ -21,20 +21,46 @@ module Handlebars
       current
     end
 
+    def escaper
+      @hbs.escaper
+    end
+
     def get_helper(name)
       @hbs.get_helper(name)
     end
 
+    def get_as_helper(name)
+      @hbs.get_as_helper(name)
+    end
+
     def get_partial(name)
       @hbs.get_partial(name)
     end
 
     def add_item(key, value)
-      @locals[key.to_sym] = value
+      locals[key.to_sym] = value
+    end
+
+    def add_items(hash)
+      hash.map { |k, v| add_item(k, v) }
+    end
+
+    def with_temporary_context(args = {})
+      saved = args.keys.collect { |key| [key, get(key.to_s)] }.to_h
+
+      add_items(args)
+      block_result = yield
+      locals.merge!(saved)
+
+      block_result
     end
 
     private
 
+    def locals
+      @locals ||= {}
+    end
+
     def get_attribute(item, attribute)
       sym_attr = attribute.to_sym
       str_attr = attribute.to_s

data/lib/ruby-handlebars/escapers/dummy_escaper.rb

@@ -0,0 +1,9 @@
+module Handlebars
+  module Escapers
+    class DummyEscaper
+      def self.escape(value)
+        value
+      end
+    end
+  end
+end

data/lib/ruby-handlebars/escapers/html_escaper.rb

@@ -0,0 +1,9 @@
+module Handlebars
+  module Escapers
+    class HTMLEscaper
+      def self.escape(value)
+        CGI::escapeHTML(value)
+      end
+    end
+  end
+end

data/lib/ruby-handlebars/helper.rb

@@ -7,35 +7,39 @@ module Handlebars
       @fn = fn
     end
 
-    def apply(context, arguments = [], block = [])
+    def arity
+      @fn.arity
+    end
+
+    def apply(context, arguments = [], block = [], else_block = [])
       arguments = [arguments] unless arguments.is_a? Array
-      args = [context] + arguments.map {|arg| arg.eval(context)} + split_block(block || [])
+      args = [context] + arguments.map {|arg| arg.eval(context)} + split_block(block, else_block)
 
       @fn.call(*args)
     end
 
-    def split_block(block)
-      helper_block = Tree::Block.new([])
-      inverse_block = Tree::Block.new([])
-
-      receiver = helper_block
-      else_found = false
+    def apply_as(context, arguments = [], as_arguments = [], block = [], else_block = [])
+      arguments = [arguments] unless arguments.is_a? Array
+      as_arguments = [as_arguments] unless as_arguments.is_a? Array
+      args = [context] + arguments.map {|arg| arg.eval(context)} + as_arguments.map(&:name) + split_block(block, else_block)
 
-      block.each do |item|
-        if item.is_a?(Tree::Helper) && item.is_else?
-          receiver = inverse_block
-          else_found = true
-          next
-        end
+      @fn.call(*args)
+    end
 
-        receiver.add_item(item)
-      end
+    private
 
-      if else_found
-        return [helper_block, inverse_block]
+    def split_block(block, else_block)
+      if else_block
+        [ensure_block(block), ensure_block(else_block)]
       else
-        return [helper_block]
+        [ensure_block(block)]
       end
     end
+
+    def ensure_block(block)
+      new_block = Tree::Block.new([])
+      block.each {|item| new_block.add_item(item) } unless block.nil?
+      new_block
+    end
   end
 end

data/lib/ruby-handlebars/helpers/default_helper.rb

@@ -0,0 +1,28 @@
+module Handlebars
+  module Helpers
+    class DefaultHelper
+      def self.register(hbs)
+        hbs.register_helper(self.registry_name) do |context, parameters, block, else_block|
+          self.apply(context, parameters, block, else_block)
+        end if self.respond_to?(:apply)
+
+        hbs.register_as_helper(self.registry_name) do |context, parameters, as_names, block, else_block|
+          self.apply_as(context, parameters, as_names, block, else_block)
+        end if self.respond_to?(:apply_as)
+      end
+
+      # Should be implemented by sub-classes
+      # def self.registry_name
+      #   'myHelperName'
+      # end
+
+      # def self.apply(context, parameters, block, else_block)
+      #   # Do things and stuff
+      # end
+
+      # def self.apply_as(context, parameters, as_names, block, else_block)
+      #   # Do things and stuffa, but with 'as |param| notation'
+      # end
+    end
+  end
+end

data/lib/ruby-handlebars/helpers/each_helper.rb

@@ -0,0 +1,31 @@
+require_relative 'default_helper'
+
+module Handlebars
+  module Helpers
+    class EachHelper < DefaultHelper
+      def self.registry_name
+        'each'
+      end
+
+      def self.apply(context, items, block, else_block)
+        self.apply_as(context, items, :this, block, else_block)
+      end
+
+      def self.apply_as(context, items, name, block, else_block)
+        if (items.nil? || items.empty?)
+          if else_block
+            result = else_block.fn(context)
+          end
+        else
+          context.with_temporary_context(name => nil, :@index => 0, :@first => false, :@last => false) do
+            result = items.each_with_index.map do |item, index|
+              context.add_items(name => item, :@index => index, :@first => (index == 0), :@last => (index == items.length - 1))
+              block.fn(context)
+            end.join('')
+          end
+        end
+        result
+      end
+    end
+  end
+end

data/lib/ruby-handlebars/helpers/helper_missing_helper.rb

@@ -0,0 +1,18 @@
+require_relative 'default_helper'
+
+module Handlebars
+  class UnknownHelper < StandardError
+  end
+
+  module Helpers
+    class HelperMissingHelper < DefaultHelper
+      def self.registry_name
+        'helperMissing'
+      end
+
+      def self.apply(context, name, block, else_block)
+        raise(::Handlebars::UnknownHelper, "Helper \"#{name}\" does not exist" )
+      end
+    end
+  end
+end