mvz-ruby-handlebars 0.0.7

data/lib/ruby-handlebars/version.rb

@@ -0,0 +1,3 @@
+module Handlebars
+  VERSION = "0.0.7"
+end

data/spec/handlebars_spec.rb

@@ -0,0 +1,327 @@
+require_relative 'spec_helper'
+require_relative '../lib/ruby-handlebars'
+
+describe Handlebars::Handlebars do
+  let(:hbs) {Handlebars::Handlebars.new}
+
+  def evaluate(template, args = {})
+    hbs.compile(template).call(args)
+  end
+
+  context 'evaluating' do
+    it 'a dummy template' do
+      expect(evaluate('My simple template')).to eq('My simple template')
+    end
+
+    it 'a simple replacement' do
+      expect(evaluate('Hello {{name}}', {name: 'world'})).to eq('Hello world')
+    end
+
+    it 'allows values specified by methods' do
+      expect(evaluate('Hello {{name}}', double(name: 'world'))).to eq('Hello world')
+    end
+
+    it 'prefers hash value over method value' do
+      expect(evaluate('Hello {{name}}', double(name: 'world', '[]': 'dog', has_key?: true))).to eq('Hello dog')
+    end
+
+    it 'handles object that implement #[] but not #has_key?' do
+      expect(evaluate('Hello {{name}}', double(name: 'world', '[]': 'dog'))).to eq('Hello world')
+    end
+
+    it 'a replacement with a path' do
+      expect(evaluate('My simple template: {{person.name}}', {person: {name: 'Another name'}})).to eq('My simple template: Another name')
+    end
+
+    context 'partials' do
+      it 'simple' do
+        hbs.register_partial('plic', "Plic")
+        expect(evaluate("Hello {{> plic}}")).to eq("Hello Plic")
+      end
+
+      it 'using context' do
+        hbs.register_partial('brackets', "[{{name}}]")
+        expect(evaluate("Hello {{> brackets}}", {name: 'world'})).to eq("Hello [world]")
+      end
+    end
+
+    context 'helpers' do
+      it 'without any argument' do
+        hbs.register_helper('rainbow') {|context| "-"}
+        expect(evaluate("{{rainbow}}")).to eq("-")
+      end
+
+      it 'with a single argument' do
+        hbs.register_helper('noah') {|context, value| value.gsub(/a/, '')}
+
+        expect(evaluate("{{noah country}}", {country: 'Canada'})).to eq("Cnd")
+      end
+
+      it 'with multiple arguments, including strings' do
+        hbs.register_helper('add') {|context, left, op, right| "#{left} #{op} #{right}"}
+
+        expect(evaluate("{{add left '&' right}}", {left: 'Law', right: 'Order'})).to eq("Law & Order")
+      end
+
+      it 'with an empty string argument' do
+        hbs.register_helper('noah') {|context, value| value.to_s.gsub(/a/, '')}
+
+        expect(evaluate("hey{{noah ''}}there", {})).to eq("heythere")
+      end
+
+      it 'block' do
+        hbs.register_helper('comment') do |context, commenter, block|
+          block.fn(context).split("\n").map do |line|
+            "#{commenter} #{line}"
+        end.join("\n")
+
+        expect(evaluate([
+          "{{comment '//'}}",
+          "Author: {{author.name}}, {{author.company}}",
+          "Date: {{commit_date}}",
+          "{{/comment}}"
+        ].join("\n"), {author: {name: 'Vincent', company: 'Hiptest'}, commit_date: 'today'})).to eq([
+          "// Author: Vincent, Hiptest",
+          "// Date: today"
+        ].join("\n"))
+        end
+      end
+
+      it 'block without arguments' do
+        template = [
+          "<tr>{{#indent}}",
+          "{{#each items}}<td>{{{ this }}}</td>",
+          "{{/each}}",
+          "{{/indent}}",
+          "</tr>"
+        ].join("\n")
+
+        hbs.register_helper('indent') do |context, block|
+          block.fn(context).split("\n").map do |line|
+            "  #{line}"
+          end.join("\n")
+        end
+
+        expect(evaluate(template, {items: ['a', 'b', 'c']})).to eq([
+          "<tr>  ",
+          "  <td>a</td>",
+          "  <td>b</td>",
+          "  <td>c</td>",
+          "</tr>"
+        ].join("\n"))
+      end
+
+      it 'block parameters can be paths' do
+        data = {company: {people: ['a', 'b', 'c']}}
+        expect(evaluate("{{#each company.people}}{{{this}}}{{/each}}", data)).to eq('abc')
+      end
+    end
+
+    context 'default helpers' do
+      context 'if' do
+        it 'without else' do
+          template = [
+            "{{#if condition}}",
+            "  Show something",
+            "{{/if}}"
+          ].join("\n")
+          expect(evaluate(template, {condition: true})).to eq("\n  Show something\n")
+          expect(evaluate(template, {condition: false})).to eq("")
+        end
+
+        it 'with an else' do
+          template = [
+            "{{#if condition}}",
+            "  Show something",
+            "{{ else }}",
+            "  Do not show something",
+            "{{/if}}"
+          ].join("\n")
+          expect(evaluate(template, {condition: true})).to eq("\n  Show something\n")
+          expect(evaluate(template, {condition: false})).to eq("\n  Do not show something\n")
+        end
+
+        it 'imbricated ifs' do
+          template = [
+            "{{#if first_condition}}",
+            "  {{#if second_condition}}",
+            "    Case 1",
+            "  {{else}}",
+            "    Case 2",
+            "  {{/if}}",
+            "{{else}}",
+            "  {{#if second_condition}}",
+            "    Case 3",
+            "  {{else}}",
+            "    Case 4",
+            "  {{/if}}",
+            "{{/if}}"
+          ].join("\n")
+
+          expect(evaluate(template, {first_condition: true, second_condition: true}).strip).to eq("Case 1")
+          expect(evaluate(template, {first_condition: true, second_condition: false}).strip).to eq("Case 2")
+          expect(evaluate(template, {first_condition: false, second_condition: true}).strip).to eq("Case 3")
+          expect(evaluate(template, {first_condition: false, second_condition: false}).strip).to eq("Case 4")
+        end
+      end
+
+      context 'each' do
+        let(:ducks) {[{name: 'Huey'}, {name: 'Dewey'}, {name: 'Louis'}]}
+
+        it 'simple case' do
+          template = [
+            "<ul>",
+            "{{#each items}}  <li>{{this.name}}</li>",
+            "{{/each}}</ul>"
+          ].join("\n")
+
+          data = {items: ducks}
+          expect(evaluate(template, data)).to eq([
+            "<ul>",
+            "  <li>Huey</li>",
+            "  <li>Dewey</li>",
+            "  <li>Louis</li>",
+            "</ul>"
+          ].join("\n"))
+
+          data = {items: []}
+          expect(evaluate(template, data)).to eq([
+            "<ul>",
+            "</ul>"
+          ].join("\n"))
+        end
+
+        it 'considers not found items as an empty list and does not raise an error' do
+          template = [
+            "<ul>",
+            "{{#each stuff}}  <li>{{this.name}}</li>",
+            "{{/each}}</ul>"
+          ].join("\n")
+
+          expect(evaluate(template, {})).to eq([
+            "<ul>",
+            "</ul>"
+          ].join("\n"))
+        end
+
+        it 'considers not found items as an empty list and uses else block if provided' do
+          template = [
+            "<ul>",
+            "{{#each stuff}}  <li>{{this.name}}</li>",
+            "{{else}}  <li>No stuff found....</li>",
+            "{{/each}}</ul>"
+          ].join("\n")
+
+          expect(evaluate(template, {})).to eq([
+            "<ul>",
+            "  <li>No stuff found....</li>",
+            "</ul>"
+          ].join("\n"))
+        end
+
+        it 'works with non-hash data' do
+          template = [
+            "<ul>",
+            "{{#each items}}  <li>{{this.name}}</li>",
+            "{{/each}}</ul>"
+          ].join("\n")
+
+          data = double(items: ducks)
+          expect(evaluate(template, data)).to eq([
+            "<ul>",
+            "  <li>Huey</li>",
+            "  <li>Dewey</li>",
+            "  <li>Louis</li>",
+            "</ul>"
+          ].join("\n"))
+
+          data = {items: []}
+          expect(evaluate(template, data)).to eq([
+            "<ul>",
+            "</ul>"
+          ].join("\n"))
+        end
+
+        it 'using an else statement' do
+          template = [
+            "<ul>",
+            "{{#each items}}  <li>{{this.name}}</li>",
+            "{{else}}  <li>No ducks to display</li>",
+            "{{/each}}</ul>"
+          ].join("\n")
+
+          data = {items: ducks}
+          expect(evaluate(template, data)).to eq([
+            "<ul>",
+            "  <li>Huey</li>",
+            "  <li>Dewey</li>",
+            "  <li>Louis</li>",
+            "</ul>"
+          ].join("\n"))
+
+          data = {items: []}
+          expect(evaluate(template, data)).to eq([
+            "<ul>",
+            "  <li>No ducks to display</li>",
+            "</ul>"
+          ].join("\n"))
+        end
+
+        it 'imbricated' do
+          data = {people: [
+            {
+              name: 'Huey',
+              email: 'huey@junior-woodchucks.example.com',
+              phones: ['1234', '5678'],
+            },
+            {
+              name: 'Dewey',
+              email: 'dewey@junior-woodchucks.example.com',
+              phones: ['4321'],
+            }
+          ]}
+
+          template = [
+            "People:",
+            "<ul>",
+            "  {{#each people}}",
+            "  <li>",
+            "    <ul>",
+            "      <li>Name: {{this.name}}</li>",
+            "      <li>Phones: {{#each this.phones}} {{this}} {{/each}}</li>",
+            "      <li>email: {{this.email}}</li>",
+            "    </ul>",
+            "  </li>",
+            "  {{else}}",
+            "  <li>No one to display</li>",
+            "  {{/each}}",
+            "</ul>"
+          ].join("\n")
+
+          expect(evaluate(template, data)).to eq([
+            "People:",
+            "<ul>",
+            "  ",
+            "  <li>",
+            "    <ul>",
+            "      <li>Name: Huey</li>",
+            "      <li>Phones:  1234  5678 </li>",
+            "      <li>email: huey@junior-woodchucks.example.com</li>",
+            "    </ul>",
+            "  </li>",
+            "  ",
+            "  <li>",
+            "    <ul>",
+            "      <li>Name: Dewey</li>",
+            "      <li>Phones:  4321 </li>",
+            "      <li>email: dewey@junior-woodchucks.example.com</li>",
+            "    </ul>",
+            "  </li>",
+            "  ",
+            "</ul>"
+          ].join("\n"))
+        end
+      end
+    end
+  end
+end

data/spec/parser_spec.rb

@@ -0,0 +1,317 @@
+require_relative 'spec_helper'
+require_relative '../lib/ruby-handlebars/parser'
+
+describe Handlebars::Parser do
+  let(:parser) {Handlebars::Parser.new}
+
+  context 'recognizes' do
+    it 'simple templates' do
+      expect(parser.parse('Ho hi !')).to eq({
+        block_items: [
+          {template_content: 'Ho hi !'}
+        ]
+      })
+    end
+
+    it 'simple replacements' do
+      expect(parser.parse('{{plic}}')).to eq({
+        block_items: [
+          {helper_name: 'plic'}
+        ]
+      })
+      expect(parser.parse('{{ plic}}')).to eq({
+        block_items: [
+          {helper_name: 'plic'}
+        ]
+      })
+      expect(parser.parse('{{plic }}')).to eq({
+        block_items: [
+          {helper_name: 'plic'}
+        ]
+      })
+      expect(parser.parse('{{ plic }}')).to eq({
+        block_items: [
+          {helper_name: 'plic'}
+        ]
+      })
+    end
+
+    it 'safe strings' do
+      expect(parser.parse('{{{plic}}}')).to eq({
+        block_items: [
+          {helper_name: 'plic'}
+        ]
+      })
+
+      expect(parser.parse('{{{ plic}}}')).to eq({
+        block_items: [
+          {helper_name: 'plic'}
+        ]
+      })
+
+      expect(parser.parse('{{{plic }}}')).to eq({
+        block_items: [
+          {helper_name: 'plic'}
+        ]
+      })
+
+      expect(parser.parse('{{{ plic }}}')).to eq({
+        block_items: [
+          {helper_name: 'plic'}
+        ]
+      })
+
+    end
+
+    context 'helpers' do
+      it 'simple' do
+        expect(parser.parse('{{ capitalize plic }}')).to eq({
+          block_items: [
+            {
+              helper_name: 'capitalize',
+              parameters: {parameter_name: 'plic'}
+            }
+          ]
+        })
+      end
+
+      it 'with single-quoted string parameter' do
+        expect(parser.parse("{{ capitalize 'hi'}}")).to eq({
+          block_items: [
+            {
+              helper_name: 'capitalize',
+              parameters: {parameter_name: {str_content: 'hi'}},
+            }
+          ]
+        })
+      end
+
+      it 'with single-quoted empty string parameter' do
+        expect(parser.parse("{{ capitalize ''}}")).to eq({
+          block_items: [
+            {
+              helper_name: 'capitalize',
+              parameters: {parameter_name: {str_content: ''}},
+            }
+          ]
+        })
+      end
+
+      it 'with double-quoted string parameter' do
+        expect(parser.parse('{{ capitalize "hi"}}')).to eq({
+          block_items: [
+            {
+              helper_name: 'capitalize',
+              parameters: {parameter_name: {str_content: 'hi'}},
+            }
+          ]
+        })
+      end
+
+      it 'with double-quoted empty string parameter' do
+        expect(parser.parse('{{ capitalize ""}}')).to eq({
+          block_items: [
+            {
+              helper_name: 'capitalize',
+              parameters: {parameter_name: {str_content: ''}},
+            }
+          ]
+        })
+      end
+
+      it 'with multiple parameters' do
+        expect(parser.parse('{{ concat plic ploc plouf }}')).to eq({
+          block_items: [
+            {
+              helper_name: 'concat',
+              parameters: [
+                {parameter_name: 'plic'},
+                {parameter_name: 'ploc'},
+                {parameter_name: 'plouf'}
+              ]
+            }
+          ]
+        })
+      end
+
+      it 'block' do
+        expect(parser.parse('{{#capitalize}}plic{{/capitalize}}')).to eq({
+          block_items: [
+            {
+              helper_name: 'capitalize',
+              block_items: [
+                {template_content: 'plic'}
+              ]
+            }
+          ]
+        })
+      end
+
+      it 'block with parameters' do
+        expect(parser.parse('{{#comment "#"}}plic{{/comment}}')).to eq({
+          block_items: [
+            {
+              helper_name: 'comment',
+              parameters: {parameter_name: {str_content: '#'}},
+              block_items: [
+                {template_content: 'plic'}
+              ]
+            }
+          ]
+        })
+      end
+
+      it 'imbricated blocks' do
+        expect(parser.parse('{{#comment "#"}}plic {{#capitalize}}ploc{{/capitalize}} plouc{{/comment}}')).to eq({
+          block_items: [
+            {
+              helper_name: 'comment',
+              parameters: {parameter_name: {str_content: '#'}},
+              block_items: [
+                {template_content: 'plic '},
+                {
+                  helper_name: 'capitalize',
+                  block_items: [{template_content: 'ploc'}]
+                },
+                {template_content: ' plouc'},
+              ]
+            }
+          ]
+        })
+      end
+    end
+
+    context 'if block' do
+      it 'simple' do
+        expect(parser.parse('{{#if something}}show something else{{/if}}')).to eq({
+          block_items: [
+            {
+              helper_name: 'if',
+              parameters: {parameter_name: 'something'},
+              block_items: [
+                {template_content: 'show something else'}
+              ]
+            }
+          ]
+        })
+      end
+
+      it 'with an else statement' do
+        expect(parser.parse('{{#if something}}Ok{{else}}not ok{{/if}}')).to eq({
+          block_items: [
+            {
+              helper_name: 'if',
+              parameters: {parameter_name: 'something'},
+              block_items: [
+                {template_content: 'Ok'},
+                {helper_name: 'else'},
+                {template_content: 'not ok'}
+              ]
+            }
+          ]
+        })
+      end
+
+      it 'imbricated' do
+        expect(parser.parse('{{#if something}}{{#if another_thing}}Plic{{/if}}ploc{{/if}}')).to eq({
+          block_items: [
+            {
+              helper_name: 'if',
+              parameters: {parameter_name: 'something'},
+              block_items: [
+                {
+                  helper_name: 'if',
+                  parameters: {parameter_name: 'another_thing'},
+                  block_items: [
+                    {template_content: 'Plic'}
+                  ]
+                },
+                {template_content: 'ploc'}
+              ]
+            }
+          ]
+        })
+      end
+    end
+
+    context 'each block' do
+      it 'simple' do
+        expect(parser.parse('{{#each people}} {{this.name}} {{/each}}')).to eq({
+          block_items: [
+            {
+              helper_name: 'each',
+              parameters: {parameter_name: 'people'},
+              block_items: [
+                {template_content: ' '},
+                {helper_name: 'this.name'},
+                {template_content: ' '}
+              ]
+            }
+          ]
+        })
+      end
+
+      it 'imbricated' do
+        expect(parser.parse('{{#each people}} {{this.name}} <ul> {{#each this.contact}} <li>{{this}}</li> {{/each}}</ul>{{/each}}')).to eq({
+          block_items: [
+            {
+              helper_name: 'each',
+              parameters: {parameter_name: 'people'},
+              block_items: [
+                {template_content: ' '},
+                {helper_name: 'this.name'},
+                {template_content: ' <ul> '},
+                {
+                  helper_name: 'each',
+                  parameters: {parameter_name: 'this.contact'},
+                  block_items: [
+                    {template_content: ' <li>'},
+                    {helper_name: 'this'},
+                    {template_content: '</li> '}
+                  ]
+                },
+                {template_content: '</ul>'}
+              ]
+            }
+          ]
+        })
+      end
+    end
+
+    context 'templates with single curlies' do
+      it 'works with loose curlies' do
+        expect(parser.parse('} Hi { hey } {')).to eq({
+          block_items: [
+            {template_content: '} Hi { hey } {'}
+          ]
+        })
+      end
+
+      it 'works with groups of curlies' do
+        expect(parser.parse('{ Hi }{ hey }')).to eq({
+          block_items: [
+            {template_content: '{ Hi }{ hey }'}
+          ]
+        })
+      end
+
+      it 'works with closing curly before value' do
+        expect(parser.parse('Hi }{{ hey }}')).to eq({
+          block_items: [
+            {template_content: 'Hi }'},
+            {helper_name: 'hey'}
+          ]
+        })
+      end
+
+      it 'works with closing curly before value at the start' do
+        expect(parser.parse('}{{ hey }}')).to eq({
+          block_items: [
+            {template_content: '}'},
+            {helper_name: 'hey'}
+          ]
+        })
+      end
+    end
+  end
+end