mvz-ruby-handlebars 0.0.8 → 0.0.9

data/spec/parser_spec.rb

@@ -16,22 +16,43 @@ describe Handlebars::Parser do
     it 'simple replacements' do
       expect(parser.parse('{{plic}}')).to eq({
         block_items: [
-          {helper_name: 'plic'}
+          {replaced_unsafe_item: 'plic'}
         ]
       })
+
       expect(parser.parse('{{ plic}}')).to eq({
         block_items: [
-          {helper_name: 'plic'}
+          {replaced_unsafe_item: 'plic'}
         ]
       })
+
       expect(parser.parse('{{plic }}')).to eq({
         block_items: [
-          {helper_name: 'plic'}
+          {replaced_unsafe_item: 'plic'}
         ]
       })
+
       expect(parser.parse('{{ plic }}')).to eq({
         block_items: [
-          {helper_name: 'plic'}
+          {replaced_unsafe_item: 'plic'}
+        ]
+      })
+    end
+
+    it 'special variables' do
+      expect(parser.parse('{{@first}}')).to eq({
+        block_items: [
+          {replaced_unsafe_item: '@first'}
+        ]
+      })
+      expect(parser.parse('{{@last}}')).to eq({
+        block_items: [
+          {replaced_unsafe_item: '@last'}
+        ]
+      })
+      expect(parser.parse('{{@index}}')).to eq({
+        block_items: [
+          {replaced_unsafe_item: '@index'}
         ]
       })
     end
@@ -39,25 +60,25 @@ describe Handlebars::Parser do
     it 'safe strings' do
       expect(parser.parse('{{{plic}}}')).to eq({
         block_items: [
-          {helper_name: 'plic'}
+          {replaced_safe_item: 'plic'}
         ]
       })
 
       expect(parser.parse('{{{ plic}}}')).to eq({
         block_items: [
-          {helper_name: 'plic'}
+          {replaced_safe_item: 'plic'}
         ]
       })
 
       expect(parser.parse('{{{plic }}}')).to eq({
         block_items: [
-          {helper_name: 'plic'}
+          {replaced_safe_item: 'plic'}
         ]
       })
 
       expect(parser.parse('{{{ plic }}}')).to eq({
         block_items: [
-          {helper_name: 'plic'}
+          {replaced_safe_item: 'plic'}
         ]
       })
 
@@ -68,7 +89,7 @@ describe Handlebars::Parser do
         expect(parser.parse('{{ capitalize plic }}')).to eq({
           block_items: [
             {
-              helper_name: 'capitalize',
+              unsafe_helper_name: 'capitalize',
               parameters: {parameter_name: 'plic'}
             }
           ]
@@ -79,7 +100,7 @@ describe Handlebars::Parser do
         expect(parser.parse("{{ capitalize 'hi'}}")).to eq({
           block_items: [
             {
-              helper_name: 'capitalize',
+              unsafe_helper_name: 'capitalize',
               parameters: {parameter_name: {str_content: 'hi'}},
             }
           ]
@@ -90,7 +111,7 @@ describe Handlebars::Parser do
         expect(parser.parse("{{ capitalize ''}}")).to eq({
           block_items: [
             {
-              helper_name: 'capitalize',
+              unsafe_helper_name: 'capitalize',
               parameters: {parameter_name: {str_content: ''}},
             }
           ]
@@ -101,7 +122,7 @@ describe Handlebars::Parser do
         expect(parser.parse('{{ capitalize "hi"}}')).to eq({
           block_items: [
             {
-              helper_name: 'capitalize',
+              unsafe_helper_name: 'capitalize',
               parameters: {parameter_name: {str_content: 'hi'}},
             }
           ]
@@ -112,7 +133,7 @@ describe Handlebars::Parser do
         expect(parser.parse('{{ capitalize ""}}')).to eq({
           block_items: [
             {
-              helper_name: 'capitalize',
+              unsafe_helper_name: 'capitalize',
               parameters: {parameter_name: {str_content: ''}},
             }
           ]
@@ -123,7 +144,7 @@ describe Handlebars::Parser do
         expect(parser.parse('{{ concat plic ploc plouf }}')).to eq({
           block_items: [
             {
-              helper_name: 'concat',
+              unsafe_helper_name: 'concat',
               parameters: [
                 {parameter_name: 'plic'},
                 {parameter_name: 'ploc'},
@@ -179,6 +200,82 @@ describe Handlebars::Parser do
           ]
         })
       end
+
+      it 'helpers as arguments' do
+        expect(parser.parse('{{foo (bar baz)}}')).to eq({
+          block_items: [
+            {
+              unsafe_helper_name: 'foo',
+              parameters: {
+                safe_helper_name: 'bar',
+                parameters: {parameter_name: 'baz'}
+              }
+            }
+          ]
+        })
+      end
+    end
+
+    context 'as helpers' do
+      it 'recognizes the "as |...|" writing' do
+        expect(parser.parse('{{#each items as |item|}}plic{{/each}}')).to eq({
+          block_items: [
+            {
+              helper_name: 'each',
+              parameters: {parameter_name: 'items'},
+              as_parameters: {parameter_name: 'item'},
+              block_items: [
+                {template_content: 'plic'}
+              ]
+            }
+          ]
+        })
+      end
+
+      it 'supports the "else" statement' do
+        expect(parser.parse('{{#each items as |item|}}plic{{else}}Hummm, empty{{/each}}')).to eq({
+          block_items: [
+            {
+              helper_name: 'each',
+              parameters: {parameter_name: 'items'},
+              as_parameters: {parameter_name: 'item'},
+              block_items: [
+                {template_content: 'plic'}
+              ],
+              else_block_items: [
+                {template_content: 'Hummm, empty'}
+              ]
+            }
+          ]
+        })
+      end
+
+      it 'can be imbricated' do
+        expect(parser.parse('{{#each items as |item|}}{{#each item as |char index|}}show item{{/each}}{{else}}Hummm, empty{{/each}}')).to eq({
+          block_items: [
+            {
+              helper_name: 'each',
+              parameters: {parameter_name: 'items'},
+              as_parameters: {parameter_name: 'item'},
+              block_items: [
+                {
+                  helper_name: 'each',
+                  parameters: {parameter_name: 'item'},
+                  as_parameters: [
+                    {parameter_name: 'char'},
+                    {parameter_name: 'index'}],
+                  block_items: [
+                    {template_content: 'show item'}
+                  ]
+                }
+              ],
+              else_block_items: [
+                {template_content: 'Hummm, empty'}
+              ]
+            }
+          ]
+        })
+      end
     end
 
     context 'if block' do
@@ -203,8 +300,9 @@ describe Handlebars::Parser do
               helper_name: 'if',
               parameters: {parameter_name: 'something'},
               block_items: [
-                {template_content: 'Ok'},
-                {helper_name: 'else'},
+                {template_content: 'Ok'}
+              ],
+              else_block_items: [
                 {template_content: 'not ok'}
               ]
             }
@@ -232,6 +330,49 @@ describe Handlebars::Parser do
           ]
         })
       end
+
+      it 'imbricated block with elses' do
+        expect(parser.parse('{{#if something}}{{#if another_thing}}Case 1{{else}}Case 2{{/if}}{{else}}{{#if another_thing}}Case 3{{else}}Case 4{{/if}}{{/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:"Case 1"
+                    }
+                  ],
+                  else_block_items: [
+                    {
+                      template_content: "Case 2"
+                    }
+                  ]
+                }
+              ],
+              else_block_items: [
+                {
+                  helper_name: "if",
+                  parameters: {parameter_name: "another_thing"},
+                  block_items:[
+                    {
+                      template_content:"Case 3"
+                    }
+                  ],
+                  else_block_items: [
+                    {
+                      template_content: "Case 4"
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        })
+      end
     end
 
     context 'each block' do
@@ -243,7 +384,7 @@ describe Handlebars::Parser do
               parameters: {parameter_name: 'people'},
               block_items: [
                 {template_content: ' '},
-                {helper_name: 'this.name'},
+                {replaced_unsafe_item: 'this.name'},
                 {template_content: ' '}
               ]
             }
@@ -259,14 +400,14 @@ describe Handlebars::Parser do
               parameters: {parameter_name: 'people'},
               block_items: [
                 {template_content: ' '},
-                {helper_name: 'this.name'},
+                {replaced_unsafe_item: 'this.name'},
                 {template_content: ' <ul> '},
                 {
                   helper_name: 'each',
                   parameters: {parameter_name: 'this.contact'},
                   block_items: [
                     {template_content: ' <li>'},
-                    {helper_name: 'this'},
+                    {replaced_unsafe_item: 'this'},
                     {template_content: '</li> '}
                   ]
                 },
@@ -299,7 +440,7 @@ describe Handlebars::Parser do
         expect(parser.parse('Hi }{{ hey }}')).to eq({
           block_items: [
             {template_content: 'Hi }'},
-            {helper_name: 'hey'}
+            {replaced_unsafe_item: 'hey'}
           ]
         })
       end
@@ -308,7 +449,7 @@ describe Handlebars::Parser do
         expect(parser.parse('}{{ hey }}')).to eq({
           block_items: [
             {template_content: '}'},
-            {helper_name: 'hey'}
+            {replaced_unsafe_item: 'hey'}
           ]
         })
       end

data/spec/ruby-handlebars/context_spec.rb

@@ -0,0 +1,145 @@
+require_relative '../spec_helper'
+require_relative '../../lib/ruby-handlebars/context'
+
+describe Handlebars::Context do
+  let(:ctx) { described_class.new(nil, data) }
+
+  context 'get' do
+    let(:data) { {
+      key_data: 'Some value'
+    } }
+
+    before do
+      ctx.add_item(:key_locals, 'Some other value')
+      ctx.add_item(:a_list, ['a', 'b', 'c'])
+      ctx.add_item(:a_hash, {key: 'A third value'})
+    end
+
+    it 'fetches data stored in the context' do
+      expect(ctx.get('key_data')).to eq('Some value')
+      expect(ctx.get('key_locals')).to eq('Some other value')
+    end
+
+    it 'uses data from @locals before @data' do
+      ctx.add_item(:key_data, 'Now stored in @locals')
+
+      expect(ctx.get('key_data')).to eq('Now stored in @locals')
+    end
+
+    context 'when digging inside data' do
+      it 'uses keys separated by dots' do
+        expect(ctx.get('a_hash.key')).to eq('A third value')
+      end
+
+      it 'can also use methods' do
+        expect(ctx.get('a_list.first')).to eq('a')
+        expect(ctx.get('a_list.last')).to eq('c')
+      end
+    end
+  end
+
+  context 'add_item' do
+    let(:data) { {} }
+
+    it 'adds a new key to the stored data' do
+      expect(ctx.get('my_key')).to be nil
+      ctx.add_item('my_key', 'With some value')
+      expect(ctx.get('my_key')).to eq('With some value')
+    end
+
+    it 'overrides existing values' do
+      ctx.add_item('a', 12)
+      ctx.add_item('a', 25)
+
+      expect(ctx.get('a')).to eq(25)
+    end
+
+    it 'does not make differences between string and sym keys' do
+      ctx.add_item('a', 12)
+      ctx.add_item(:a, 25)
+
+      expect(ctx.get('a')).to eq(25)
+    end
+  end
+
+  context 'add_items' do
+    let(:data) { {} }
+
+    it 'is basically a wrapper around add_item to add multiple items' do
+      allow(ctx).to receive(:add_item)
+
+      ctx.add_items(a: 'One key', b: 'A second key', c: 'A third key')
+      expect(ctx).to have_received(:add_item).at_most(3).times
+      expect(ctx).to have_received(:add_item).once.with(:a, 'One key')
+      expect(ctx).to have_received(:add_item).once.with(:b, 'A second key')
+      expect(ctx).to have_received(:add_item).once.with(:c, 'A third key')
+    end
+  end
+
+  context 'with_temporary_context' do
+    let(:data) { {} }
+
+    before do
+      ctx.add_items(
+        key: 'some key',
+        value: 'some value'
+      )
+    end
+
+    it 'allows creating temporary variables' do
+      expect(ctx.get('unknown_key')).to be nil
+
+      ctx.with_temporary_context(unknown_key: 42) do
+        expect(ctx.get('unknown_key')).to eq(42)
+      end
+    end
+
+    it 'can override an existing variable' do
+      ctx.with_temporary_context(value: 'A completelly new value') do
+        expect(ctx.get('value')).to eq('A completelly new value')
+      end
+    end
+
+    it 'provides mutable variables (well, variables ...)' do
+      ctx.with_temporary_context(unknown_key: 42) do
+        expect(ctx.get('unknown_key')).to eq(42)
+        ctx.add_item('unknown_key', 56)
+        expect(ctx.get('unknown_key')).to eq(56)
+      end
+    end
+
+    it 'after the block, existing variables are restored' do
+      ctx.with_temporary_context(value: 'A completelly new value') do
+        expect(ctx.get('value')).to eq('A completelly new value')
+      end
+
+      expect(ctx.get('value')).to eq('some value')
+    end
+
+    it 'after the block, the declared variables are not available anymore' do
+      ctx.with_temporary_context(unknown_key: 42) do
+        expect(ctx.get('unknown_key')).to eq(42)
+      end
+
+      expect(ctx.get('unknown_key')).to be nil
+    end
+
+    it 'returns the data executed by the block' do
+      expect( ctx.with_temporary_context(value: 'A completelly new value') { 12 } ).to eq(12)
+    end
+
+    context 'when data are stored in @data' do
+      let(:data) { {my_key: "With some value"} }
+
+      it 'let them available after the block is executed' do
+        expect(ctx.get('my_key')).to eq('With some value')
+
+        ctx.with_temporary_context(my_key: 12) do
+          expect(ctx.get('my_key')).to eq(12)
+        end
+
+        expect(ctx.get('my_key')).to eq('With some value')
+      end
+    end
+  end
+end