mvz-ruby-handlebars 0.0.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 37eaf9cc26d1c38afea06c4b57b024e15d38f1a1da9233176494bb39cd9e3331
+  data.tar.gz: 2c9adca712168ab377a64586db9e8b06610cb63f6cd6d888dfd66aab2452c28f
+SHA512:
+  metadata.gz: e6286672304cddb4bc9aeac034dacd8ce7a01e0a4d4622780b0c2251cd50c85808855f3365ca0e4cd16fa9fefcccc3ae30d68d88fdae63270d8181f5ef1ced15
+  data.tar.gz: 5c09f90b840bfd76e650ac8c322f6bf13ec5dfe4a306a6e23a14ab864ecbdf0792aac09604f644ab9c2b0543d918c01c563ca81a9109a48770e6146d48b156ac

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Vincent
+Copyright (c) 2018-2019 Matijs van Zuijlen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,115 @@
+ruby-handlebars
+===============
+
+[![Build Status](https://travis-ci.org/mvz/ruby-handlebars.svg?branch=master)](https://travis-ci.org/mvz/ruby-handlebars)
+
+Pure Ruby library for [Handlebars](http://handlebarsjs.com/) template system.
+This should become an alternative for using the Handlebars javascript library via
+[handlebars.rb](https://github.com/cowboyd/handlebars.rb).
+
+Installing
+----------
+
+Simply run:
+
+```shell
+gem install mvz-ruby-handlebars
+```
+
+No need for libv8, ruby-racer or any JS related tool.
+
+Using
+-----
+
+A very simple case:
+
+```ruby
+
+require 'ruby-handlebars'
+
+hbs = Handlebars::Handlebars.new
+hbs.compile("Hello {{name}}").call({name: 'world'})
+# Gives: "Hello world", how original ...
+```
+
+You can also use partials:
+
+```ruby
+hbs.register_partial('full_name', "{{person.first_name}} {{person.last_name}}")
+hbs.compile("Hello {{> full_name}}").call({person: {first_name: 'Pinkie', last_name: 'Pie'}})
+# Gives: "Hello Pinkie Pie"
+```
+
+You can also register inline helpers:
+
+```ruby
+hbs.register_helper('strip') {|context, value| value.strip}
+hbs.compile("Hello {{strip name}}").call({name: '                       world     '})
+# Will give (again ....): "Hello world"
+```
+
+or block helpers:
+
+```ruby
+hbs.register_helper('comment') do |context, commenter, block|
+  block.fn(context).split("\n").map do |line|
+    "#{commenter} #{line}"
+  end.join("\n")
+end
+
+hbs.compile("{{#comment '//'}}My comment{{/comment}}").call
+# Will give: "// My comment"
+```
+
+Note that in any block helper you can use an ``else`` block:
+
+```ruby
+hbs.register_helper('markdown') do |context, block, else_block|
+  html = md_to_html(block.fn(context))
+  html.nil? : else_block.fn(context) : html
+end
+
+template = [
+  "{{#markdown}}",
+  "  {{ description }}",
+  "{{else}}",
+  "  Description is not valid markdown, no preview available",
+  "{{/markdown}}"
+].join("\n")
+
+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.
+
+```ruby
+template = [
+  "{{#each items}}",
+  "  {{{ this }}}",
+  "{{else}}",
+  "  No items",
+  "{{/each}}",
+  "",
+  "{{#if my_condition}}",
+  "  It's ok",
+  "{{else}}",
+  "  or maybe not",
+  "{{/if}}",
+].join("\n")
+```
+
+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.

data/Rakefile

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+require 'rake/clean'
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+
+task default: :spec

data/lib/ruby-handlebars.rb

@@ -0,0 +1,85 @@
+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'
+
+module Handlebars
+  class Handlebars
+    def initialize
+      @helpers = {}
+      @partials = {}
+
+      register_default_helpers
+    end
+
+    def compile(template)
+      Template.new(self, template_to_ast(template))
+    end
+
+    def register_helper(name, &fn)
+      @helpers[name.to_s] = Helper.new(self, fn)
+    end
+
+    def get_helper(name)
+      @helpers[name.to_s]
+    end
+
+    def register_partial(name, content)
+      @partials[name.to_s] = Template.new(self, template_to_ast(content))
+    end
+
+    def get_partial(name)
+      @partials[name.to_s]
+    end
+
+    private
+
+    PARSER = Parser.new
+    TRANSFORM = Transform.new
+
+    def template_to_ast(content)
+      TRANSFORM.apply(PARSER.parse(content))
+    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
+    end
+  end
+end

data/lib/ruby-handlebars/context.rb

@@ -0,0 +1,55 @@
+module Handlebars
+  class Context
+    def initialize(hbs, data)
+      @hbs = hbs
+      @locals = {}
+      @data = data
+    end
+
+    def get(path)
+      items = path.split('.'.freeze)
+
+      if @locals.key? items.first.to_sym
+        current = @locals
+      else
+        current = @data
+      end
+      until items.empty?
+        current = get_attribute(current, items.shift)
+      end
+
+      current
+    end
+
+    def get_helper(name)
+      @hbs.get_helper(name)
+    end
+
+    def get_partial(name)
+      @hbs.get_partial(name)
+    end
+
+    def add_item(key, value)
+      @locals[key.to_sym] = value
+    end
+
+    private
+
+    def get_attribute(item, attribute)
+      sym_attr = attribute.to_sym
+      str_attr = attribute.to_s
+
+      if item.respond_to?(:[]) && item.respond_to?(:has_key?)
+        if item.has_key?(sym_attr)
+          return item[sym_attr]
+        elsif item.has_key?(str_attr)
+          return item[str_attr]
+        end
+      end
+
+      if item.respond_to?(sym_attr)
+        return item.send(sym_attr)
+      end
+    end
+  end
+end

data/lib/ruby-handlebars/helper.rb

@@ -0,0 +1,41 @@
+require_relative 'tree'
+
+module Handlebars
+  class Helper
+    def initialize(hbs, fn)
+      @hbs = hbs
+      @fn = fn
+    end
+
+    def apply(context, arguments = [], block = [])
+      arguments = [arguments] unless arguments.is_a? Array
+      args = [context] + arguments.map {|arg| arg.eval(context)} + split_block(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
+
+      block.each do |item|
+        if item.is_a?(Tree::Helper) && item.is_else?
+          receiver = inverse_block
+          else_found = true
+          next
+        end
+
+        receiver.add_item(item)
+      end
+
+      if else_found
+        return [helper_block, inverse_block]
+      else
+        return [helper_block]
+      end
+    end
+  end
+end

data/lib/ruby-handlebars/parser.rb

@@ -0,0 +1,70 @@
+require 'parslet'
+
+module Handlebars
+  class Parser < Parslet::Parser
+    rule(:space)       { match('\s').repeat(1) }
+    rule(:space?)      { space.maybe }
+    rule(:dot)         { str('.') }
+    rule(:gt)          { str('>')}
+    rule(:hash)        { str('#')}
+    rule(:slash)       { str('/')}
+    rule(:ocurly)      { str('{')}
+    rule(:ccurly)      { str('}')}
+
+    rule(:docurly)     { ocurly >> ocurly }
+    rule(:dccurly)     { ccurly >> ccurly }
+
+    rule(:identifier)  { match['a-zA-Z0-9_\?'].repeat(1) }
+    rule(:path)        { identifier >> (dot >> identifier).repeat }
+
+    rule(:nocurly)     { match('[^{}]') }
+    rule(:eof)         { any.absent? }
+    rule(:template_content) {
+      (
+        nocurly.repeat(1) | # A sequence of non-curlies
+        ocurly >> nocurly | # Opening curly that doesn't start a {{}}
+        ccurly            | # Closing curly that is not inside a {{}}
+        ocurly >> eof       # Opening curly that doesn't start a {{}} because it's the end
+      ).repeat(1).as(:template_content) }
+
+    rule(:sq_string)   { match("'") >> match("[^']").repeat.maybe.as(:str_content) >> match("'") }
+    rule(:dq_string)   { match('"') >> match('[^"]').repeat.maybe.as(:str_content) >> match('"') }
+    rule(:string)      { sq_string | dq_string }
+
+    rule(:parameter)   { (path | string).as(:parameter_name) }
+    rule(:parameters)  { parameter >> (space >> parameter).repeat }
+
+    rule(:unsafe_helper) { docurly >> space? >> path.as(:helper_name) >> (space? >> parameters.as(:parameters)).maybe >> space? >> dccurly}
+    rule(:safe_helper) { ocurly >> helper >> ccurly }
+
+    rule(:helper) { unsafe_helper | safe_helper }
+
+    rule(:block_helper) {
+      docurly >>
+      hash >>
+      identifier.capture(:helper_name).as(:helper_name) >>
+      (space >> parameters.as(:parameters)).maybe >>
+      space? >>
+      dccurly >>
+      scope {
+        block
+      } >>
+      dynamic { |src, scope|
+        docurly >> slash >> str(scope.captures[:helper_name]) >> dccurly
+      }
+    }
+
+    rule(:partial) {
+      docurly >>
+      gt >>
+      space? >>
+      identifier.as(:partial_name) >>
+      space? >>
+      dccurly
+    }
+
+    rule(:block) { (template_content | helper | partial | block_helper ).repeat.as(:block_items) }
+
+    root :block
+  end
+end

data/lib/ruby-handlebars/template.rb

@@ -0,0 +1,20 @@
+require_relative 'context'
+
+module Handlebars
+  class Template
+    def initialize(hbs, ast)
+      @hbs = hbs
+      @ast = ast
+    end
+
+    def call(args = nil)
+      ctx = Context.new(@hbs, args)
+
+      @ast.eval(ctx)
+    end
+
+    def call_with_context(ctx)
+      @ast.eval(ctx)
+    end
+  end
+end

data/lib/ruby-handlebars/tree.rb

@@ -0,0 +1,101 @@
+require 'parslet'
+
+module Handlebars
+  module Tree
+    class TreeItem < Struct
+      def eval(context)
+        _eval(context)
+      end
+    end
+
+    class TemplateContent < TreeItem.new(:content)
+      def _eval(context)
+        return content
+      end
+    end
+
+    class String < TreeItem.new(:content)
+      def _eval(context)
+        return content
+      end
+    end
+
+    class Parameter < TreeItem.new(:name)
+      def _eval(context)
+        if name.is_a?(Parslet::Slice)
+          context.get(name.to_s)
+        else
+          name._eval(context)
+        end
+      end
+    end
+
+    class Helper < TreeItem.new(:name, :parameters, :block)
+      def _eval(context)
+        if context.get_helper(name.to_s).nil?
+          context.get(name.to_s)
+        else
+          context.get_helper(name.to_s).apply(context, parameters, block)
+        end
+      end
+
+      def is_else?
+        name.to_s == 'else'
+      end
+    end
+
+    class Partial < TreeItem.new(:partial_name)
+      def _eval(context)
+        context.get_partial(partial_name.to_s).call_with_context(context)
+      end
+    end
+
+    class Block < TreeItem.new(:items)
+      def _eval(context)
+        items.map {|item| item._eval(context)}.join()
+      end
+      alias :fn :_eval
+
+      def add_item(i)
+        items << i
+      end
+    end
+  end
+
+  class Transform < Parslet::Transform
+    rule(template_content: simple(:content)) {Tree::TemplateContent.new(content)}
+    rule(str_content: simple(:content)) {Tree::String.new(content)}
+    rule(parameter_name: simple(:name)) {Tree::Parameter.new(name)}
+
+    rule(
+      helper_name: simple(:name)
+    ) {
+      Tree::Helper.new(name, [])
+    }
+
+    rule(
+      helper_name: simple(:name),
+      parameters: subtree(:parameters)
+    ) {
+      Tree::Helper.new(name, parameters)
+    }
+
+    rule(
+      helper_name: simple(:name),
+      block_items: subtree(:block_items)
+    ) {
+      Tree::Helper.new(name, [], block_items)
+    }
+
+    rule(
+      helper_name: simple(:name),
+      parameters: subtree(:parameters),
+      block_items: subtree(:block_items)
+    ) {
+      Tree::Helper.new(name, parameters, block_items)
+    }
+
+    rule(partial_name: simple(:partial_name)) {Tree::Partial.new(partial_name)}
+    rule(block_items: subtree(:block_items)) {Tree::Block.new(block_items)}
+  end
+end