spinto-liquid 2.3.0.1

data/lib/liquid.rb

@@ -0,0 +1,66 @@
+# Copyright (c) 2005 Tobias Luetke
+#
+# 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.
+
+module Liquid
+  FilterSeparator             = /\|/
+  ArgumentSeparator           = ','
+  FilterArgumentSeparator     = ':'
+  VariableAttributeSeparator  = '.'
+  TagStart                    = /\{\%/
+  TagEnd                      = /\%\}/
+  VariableSignature           = /\(?[\w\-\.\[\]]\)?/
+  VariableSegment             = /[\w\-]/
+  VariableStart               = /\{\{/
+  VariableEnd                 = /\}\}/
+  VariableIncompleteEnd       = /\}\}?/
+  QuotedString                = /"[^"]*"|'[^']*'/
+  QuotedFragment              = /#{QuotedString}|(?:[^\s,\|'"]|#{QuotedString})+/
+  StrictQuotedFragment        = /"[^"]+"|'[^']+'|[^\s|:,]+/
+  FirstFilterArgument         = /#{FilterArgumentSeparator}(?:#{StrictQuotedFragment})/
+  OtherFilterArgument         = /#{ArgumentSeparator}(?:#{StrictQuotedFragment})/
+  SpacelessFilter             = /^(?:'[^']+'|"[^"]+"|[^'"])*#{FilterSeparator}(?:#{StrictQuotedFragment})(?:#{FirstFilterArgument}(?:#{OtherFilterArgument})*)?/
+  Expression                  = /(?:#{QuotedFragment}(?:#{SpacelessFilter})*)/
+  TagAttributes               = /(\w+)\s*\:\s*(#{QuotedFragment})/
+  AnyStartingTag              = /\{\{|\{\%/
+  PartialTemplateParser       = /#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableIncompleteEnd}/
+  TemplateParser              = /(#{PartialTemplateParser}|#{AnyStartingTag})/
+  VariableParser              = /\[[^\]]+\]|#{VariableSegment}+\??/
+end
+
+require 'liquid/drop'
+require 'liquid/extensions'
+require 'liquid/errors'
+require 'liquid/strainer'
+require 'liquid/context'
+require 'liquid/tag'
+require 'liquid/block'
+require 'liquid/document'
+require 'liquid/variable'
+require 'liquid/file_system'
+require 'liquid/template'
+require 'liquid/htmltags'
+require 'liquid/standardfilters'
+require 'liquid/condition'
+require 'liquid/module_ex'
+
+# Load all the tags of the standard library
+#
+Dir[File.dirname(__FILE__) + '/liquid/tags/*.rb'].each { |f| require f }

data/test/liquid/assign_test.rb

@@ -0,0 +1,21 @@
+require 'test_helper'
+
+class AssignTest < Test::Unit::TestCase
+  include Liquid
+
+  def test_assigned_variable
+    assert_template_result('.foo.',
+                           '{% assign foo = values %}.{{ foo[0] }}.',
+                           'values' => %w{foo bar baz})
+
+    assert_template_result('.bar.',
+                           '{% assign foo = values %}.{{ foo[1] }}.',
+                           'values' => %w{foo bar baz})
+  end
+  
+  def test_assign_with_filter
+    assert_template_result('.bar.',
+                           '{% assign foo = values | split: "," %}.{{ foo[1] }}.',
+                           'values' => "foo,bar,baz")
+  end
+end # AssignTest

data/test/liquid/block_test.rb

@@ -0,0 +1,58 @@
+require 'test_helper'
+
+class VariableTest < Test::Unit::TestCase
+  include Liquid
+
+  def test_blankspace
+    template = Liquid::Template.parse("  ")
+    assert_equal ["  "], template.root.nodelist
+  end
+
+  def test_variable_beginning
+    template = Liquid::Template.parse("{{funk}}  ")
+    assert_equal 2, template.root.nodelist.size
+    assert_equal Variable, template.root.nodelist[0].class
+    assert_equal String, template.root.nodelist[1].class
+  end
+
+  def test_variable_end
+    template = Liquid::Template.parse("  {{funk}}")
+    assert_equal 2, template.root.nodelist.size
+    assert_equal String, template.root.nodelist[0].class
+    assert_equal Variable, template.root.nodelist[1].class
+  end
+
+  def test_variable_middle
+    template = Liquid::Template.parse("  {{funk}}  ")
+    assert_equal 3, template.root.nodelist.size
+    assert_equal String, template.root.nodelist[0].class
+    assert_equal Variable, template.root.nodelist[1].class
+    assert_equal String, template.root.nodelist[2].class
+  end
+
+  def test_variable_many_embedded_fragments
+    template = Liquid::Template.parse("  {{funk}} {{so}} {{brother}} ")
+    assert_equal 7, template.root.nodelist.size
+    assert_equal [String, Variable, String, Variable, String, Variable, String],
+                 block_types(template.root.nodelist)
+  end
+
+  def test_with_block
+    template = Liquid::Template.parse("  {% comment %} {% endcomment %} ")
+    assert_equal [String, Comment, String], block_types(template.root.nodelist)
+    assert_equal 3, template.root.nodelist.size
+  end
+
+  def test_with_custom_tag
+    Liquid::Template.register_tag("testtag", Block)
+
+    assert_nothing_thrown do
+      template = Liquid::Template.parse( "{% testtag %} {% endtesttag %}")
+    end
+  end
+
+  private
+    def block_types(nodelist)
+      nodelist.collect { |node| node.class }
+    end
+end # VariableTest

data/test/liquid/capture_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+class CaptureTest < Test::Unit::TestCase
+  include Liquid
+
+  def test_captures_block_content_in_variable
+    assert_template_result("test string", "{% capture 'var' %}test string{% endcapture %}{{var}}", {})
+  end
+
+  def test_capture_to_variable_from_outer_scope_if_existing
+    template_source = <<-END_TEMPLATE
+    {% assign var = '' %}
+    {% if true %}
+    {% capture var %}first-block-string{% endcapture %}
+    {% endif %}
+    {% if true %}
+    {% capture var %}test-string{% endcapture %}
+    {% endif %}
+    {{var}}
+    END_TEMPLATE
+    template = Template.parse(template_source)
+    rendered = template.render
+    assert_equal "test-string", rendered.gsub(/\s/, '')
+  end
+
+  def test_assigning_from_capture
+    template_source = <<-END_TEMPLATE
+    {% assign first = '' %}
+    {% assign second = '' %}
+    {% for number in (1..3) %}
+    {% capture first %}{{number}}{% endcapture %}
+    {% assign second = first %}
+    {% endfor %}
+    {{ first }}-{{ second }}
+    END_TEMPLATE
+    template = Template.parse(template_source)
+    rendered = template.render
+    assert_equal "3-3", rendered.gsub(/\s/, '')
+  end
+end # CaptureTest

data/test/liquid/condition_test.rb

@@ -0,0 +1,127 @@
+require 'test_helper'
+
+class ConditionTest < Test::Unit::TestCase
+  include Liquid
+
+  def test_basic_condition
+    assert_equal false, Condition.new('1', '==', '2').evaluate
+    assert_equal true,  Condition.new('1', '==', '1').evaluate
+  end
+
+  def test_default_operators_evalute_true
+    assert_evalutes_true '1', '==', '1'
+    assert_evalutes_true '1', '!=', '2'
+    assert_evalutes_true '1', '<>', '2'
+    assert_evalutes_true '1', '<', '2'
+    assert_evalutes_true '2', '>', '1'
+    assert_evalutes_true '1', '>=', '1'
+    assert_evalutes_true '2', '>=', '1'
+    assert_evalutes_true '1', '<=', '2'
+    assert_evalutes_true '1', '<=', '1'
+    # negative numbers
+    assert_evalutes_true '1', '>', '-1'
+    assert_evalutes_true '-1', '<', '1'
+    assert_evalutes_true '1.0', '>', '-1.0'
+    assert_evalutes_true '-1.0', '<', '1.0'
+  end
+
+  def test_default_operators_evalute_false
+    assert_evalutes_false '1', '==', '2'
+    assert_evalutes_false '1', '!=', '1'
+    assert_evalutes_false '1', '<>', '1'
+    assert_evalutes_false '1', '<', '0'
+    assert_evalutes_false '2', '>', '4'
+    assert_evalutes_false '1', '>=', '3'
+    assert_evalutes_false '2', '>=', '4'
+    assert_evalutes_false '1', '<=', '0'
+    assert_evalutes_false '1', '<=', '0'
+  end
+
+  def test_contains_works_on_strings
+    assert_evalutes_true "'bob'", 'contains', "'o'"
+    assert_evalutes_true "'bob'", 'contains', "'b'"
+    assert_evalutes_true "'bob'", 'contains', "'bo'"
+    assert_evalutes_true "'bob'", 'contains', "'ob'"
+    assert_evalutes_true "'bob'", 'contains', "'bob'"
+
+    assert_evalutes_false "'bob'", 'contains', "'bob2'"
+    assert_evalutes_false "'bob'", 'contains', "'a'"
+    assert_evalutes_false "'bob'", 'contains', "'---'"
+  end
+
+  def test_contains_works_on_arrays
+    @context = Liquid::Context.new
+    @context['array'] = [1,2,3,4,5]
+
+    assert_evalutes_false "array",  'contains', '0'
+    assert_evalutes_true "array",   'contains', '1'
+    assert_evalutes_true "array",   'contains', '2'
+    assert_evalutes_true "array",   'contains', '3'
+    assert_evalutes_true "array",   'contains', '4'
+    assert_evalutes_true "array",   'contains', '5'
+    assert_evalutes_false "array",  'contains', '6'
+    assert_evalutes_false "array",  'contains', '"1"'
+  end
+
+  def test_contains_returns_false_for_nil_operands
+    @context = Liquid::Context.new
+    assert_evalutes_false "not_assigned", 'contains', '0'
+    assert_evalutes_false "0", 'contains', 'not_assigned'
+  end
+
+  def test_or_condition
+    condition = Condition.new('1', '==', '2')
+
+    assert_equal false, condition.evaluate
+
+    condition.or Condition.new('2', '==', '1')
+
+    assert_equal false, condition.evaluate
+
+    condition.or Condition.new('1', '==', '1')
+
+    assert_equal true, condition.evaluate
+  end
+
+  def test_and_condition
+    condition = Condition.new('1', '==', '1')
+
+    assert_equal true, condition.evaluate
+
+    condition.and Condition.new('2', '==', '2')
+
+    assert_equal true, condition.evaluate
+
+    condition.and Condition.new('2', '==', '1')
+
+    assert_equal false, condition.evaluate
+  end
+
+  def test_should_allow_custom_proc_operator
+    Condition.operators['starts_with'] = Proc.new { |cond, left, right| left =~ %r{^#{right}} }
+
+    assert_evalutes_true "'bob'",   'starts_with', "'b'"
+    assert_evalutes_false "'bob'",  'starts_with', "'o'"
+
+    ensure
+      Condition.operators.delete 'starts_with'
+  end
+
+  def test_left_or_right_may_contain_operators
+    @context = Liquid::Context.new
+    @context['one'] = @context['another'] = "gnomeslab-and-or-liquid"
+
+    assert_evalutes_true "one", '==', "another"
+  end
+
+  private
+    def assert_evalutes_true(left, op, right)
+      assert Condition.new(left, op, right).evaluate(@context || Liquid::Context.new),
+             "Evaluated false: #{left} #{op} #{right}"
+    end
+
+    def assert_evalutes_false(left, op, right)
+      assert !Condition.new(left, op, right).evaluate(@context || Liquid::Context.new),
+             "Evaluated true: #{left} #{op} #{right}"
+    end
+end # ConditionTest

data/test/liquid/context_test.rb

@@ -0,0 +1,478 @@
+require 'test_helper'
+
+class HundredCentes
+  def to_liquid
+    100
+  end
+end
+
+class CentsDrop < Liquid::Drop
+  def amount
+    HundredCentes.new
+  end
+
+  def non_zero?
+    true
+  end
+end
+
+class ContextSensitiveDrop < Liquid::Drop
+  def test
+    @context['test']
+  end
+end
+
+class Category < Liquid::Drop
+  attr_accessor :name
+
+  def initialize(name)
+    @name = name
+  end
+
+  def to_liquid
+    CategoryDrop.new(self)
+  end
+end
+
+class CategoryDrop
+  attr_accessor :category, :context
+  def initialize(category)
+    @category = category
+  end
+end
+
+class CounterDrop < Liquid::Drop
+  def count
+    @count ||= 0
+    @count += 1
+  end
+end
+
+class ArrayLike
+  def fetch(index)
+  end
+
+  def [](index)
+    @counts ||= []
+    @counts[index] ||= 0
+    @counts[index] += 1
+  end
+
+  def to_liquid
+    self
+  end
+end
+
+class ContextTest < Test::Unit::TestCase
+  include Liquid
+
+  def setup
+    @context = Liquid::Context.new
+  end
+
+  def test_variables
+    @context['string'] = 'string'
+    assert_equal 'string', @context['string']
+
+    @context['num'] = 5
+    assert_equal 5, @context['num']
+
+    @context['time'] = Time.parse('2006-06-06 12:00:00')
+    assert_equal Time.parse('2006-06-06 12:00:00'), @context['time']
+
+    @context['date'] = Date.today
+    assert_equal Date.today, @context['date']
+
+    now = DateTime.now
+    @context['datetime'] = now
+    assert_equal now, @context['datetime']
+
+    @context['bool'] = true
+    assert_equal true, @context['bool']
+
+    @context['bool'] = false
+    assert_equal false, @context['bool']
+
+    @context['nil'] = nil
+    assert_equal nil, @context['nil']
+    assert_equal nil, @context['nil']
+  end
+
+  def test_variables_not_existing
+    assert_equal nil, @context['does_not_exist']
+  end
+
+  def test_scoping
+    assert_nothing_raised do
+      @context.push
+      @context.pop
+    end
+
+    assert_raise(Liquid::ContextError) do
+      @context.pop
+    end
+
+    assert_raise(Liquid::ContextError) do
+      @context.push
+      @context.pop
+      @context.pop
+    end
+  end
+
+  def test_length_query
+
+    @context['numbers'] = [1,2,3,4]
+
+    assert_equal 4, @context['numbers.size']
+
+    @context['numbers'] = {1 => 1,2 => 2,3 => 3,4 => 4}
+
+    assert_equal 4, @context['numbers.size']
+
+    @context['numbers'] = {1 => 1,2 => 2,3 => 3,4 => 4, 'size' => 1000}
+
+    assert_equal 1000, @context['numbers.size']
+
+  end
+
+  def test_hyphenated_variable
+
+    @context['oh-my'] = 'godz'
+    assert_equal 'godz', @context['oh-my']
+
+  end
+
+  def test_add_filter
+
+    filter = Module.new do
+      def hi(output)
+        output + ' hi!'
+      end
+    end
+
+    context = Context.new
+    context.add_filters(filter)
+    assert_equal 'hi? hi!', context.invoke(:hi, 'hi?')
+
+    context = Context.new
+    assert_equal 'hi?', context.invoke(:hi, 'hi?')
+
+    context.add_filters(filter)
+    assert_equal 'hi? hi!', context.invoke(:hi, 'hi?')
+
+  end
+
+  def test_override_global_filter
+    global = Module.new do
+      def notice(output)
+        "Global #{output}"
+      end
+    end
+
+    local = Module.new do
+      def notice(output)
+        "Local #{output}"
+      end
+    end
+
+    Template.register_filter(global)
+    assert_equal 'Global test', Template.parse("{{'test' | notice }}").render
+    assert_equal 'Local test', Template.parse("{{'test' | notice }}").render({}, :filters => [local])
+  end
+
+  def test_only_intended_filters_make_it_there
+
+    filter = Module.new do
+      def hi(output)
+        output + ' hi!'
+      end
+    end
+
+    context = Context.new
+    methods_before = context.strainer.methods.map { |method| method.to_s }
+    context.add_filters(filter)
+    methods_after = context.strainer.methods.map { |method| method.to_s }
+    assert_equal (methods_before + ["hi"]).sort, methods_after.sort
+  end
+
+  def test_add_item_in_outer_scope
+    @context['test'] = 'test'
+    @context.push
+    assert_equal 'test', @context['test']
+    @context.pop
+    assert_equal 'test', @context['test']
+  end
+
+  def test_add_item_in_inner_scope
+    @context.push
+    @context['test'] = 'test'
+    assert_equal 'test', @context['test']
+    @context.pop
+    assert_equal nil, @context['test']
+  end
+
+  def test_hierachical_data
+    @context['hash'] = {"name" => 'tobi'}
+    assert_equal 'tobi', @context['hash.name']
+    assert_equal 'tobi', @context['hash["name"]']
+  end
+
+  def test_keywords
+    assert_equal true, @context['true']
+    assert_equal false, @context['false']
+  end
+
+  def test_digits
+    assert_equal 100, @context['100']
+    assert_equal 100.00, @context['100.00']
+  end
+
+  def test_strings
+    assert_equal "hello!", @context['"hello!"']
+    assert_equal "hello!", @context["'hello!'"]
+  end
+
+  def test_merge
+    @context.merge({ "test" => "test" })
+    assert_equal 'test', @context['test']
+    @context.merge({ "test" => "newvalue", "foo" => "bar" })
+    assert_equal 'newvalue', @context['test']
+    assert_equal 'bar', @context['foo']
+  end
+
+  def test_array_notation
+    @context['test'] = [1,2,3,4,5]
+
+    assert_equal 1, @context['test[0]']
+    assert_equal 2, @context['test[1]']
+    assert_equal 3, @context['test[2]']
+    assert_equal 4, @context['test[3]']
+    assert_equal 5, @context['test[4]']
+  end
+
+  def test_recoursive_array_notation
+    @context['test'] = {'test' => [1,2,3,4,5]}
+
+    assert_equal 1, @context['test.test[0]']
+
+    @context['test'] = [{'test' => 'worked'}]
+
+    assert_equal 'worked', @context['test[0].test']
+  end
+
+  def test_hash_to_array_transition
+    @context['colors'] = {
+      'Blue'    => ['003366','336699', '6699CC', '99CCFF'],
+      'Green'   => ['003300','336633', '669966', '99CC99'],
+      'Yellow'  => ['CC9900','FFCC00', 'FFFF99', 'FFFFCC'],
+      'Red'     => ['660000','993333', 'CC6666', 'FF9999']
+    }
+
+    assert_equal '003366', @context['colors.Blue[0]']
+    assert_equal 'FF9999', @context['colors.Red[3]']
+  end
+
+  def test_try_first
+    @context['test'] = [1,2,3,4,5]
+
+    assert_equal 1, @context['test.first']
+    assert_equal 5, @context['test.last']
+
+    @context['test'] = {'test' => [1,2,3,4,5]}
+
+    assert_equal 1, @context['test.test.first']
+    assert_equal 5, @context['test.test.last']
+
+    @context['test'] = [1]
+    assert_equal 1, @context['test.first']
+    assert_equal 1, @context['test.last']
+  end
+
+  def test_access_hashes_with_hash_notation
+    @context['products'] = {'count' => 5, 'tags' => ['deepsnow', 'freestyle'] }
+    @context['product'] = {'variants' => [ {'title' => 'draft151cm'}, {'title' => 'element151cm'}  ]}
+
+    assert_equal 5, @context['products["count"]']
+    assert_equal 'deepsnow', @context['products["tags"][0]']
+    assert_equal 'deepsnow', @context['products["tags"].first']
+    assert_equal 'draft151cm', @context['product["variants"][0]["title"]']
+    assert_equal 'element151cm', @context['product["variants"][1]["title"]']
+    assert_equal 'draft151cm', @context['product["variants"][0]["title"]']
+    assert_equal 'element151cm', @context['product["variants"].last["title"]']
+  end
+
+  def test_access_variable_with_hash_notation
+    @context['foo'] = 'baz'
+    @context['bar'] = 'foo'
+
+    assert_equal 'baz', @context['["foo"]']
+    assert_equal 'baz', @context['[bar]']
+  end
+
+  def test_access_hashes_with_hash_access_variables
+
+    @context['var'] = 'tags'
+    @context['nested'] = {'var' => 'tags'}
+    @context['products'] = {'count' => 5, 'tags' => ['deepsnow', 'freestyle'] }
+
+    assert_equal 'deepsnow', @context['products[var].first']
+    assert_equal 'freestyle', @context['products[nested.var].last']
+  end
+
+  def test_hash_notation_only_for_hash_access
+    @context['array'] = [1,2,3,4,5]
+    @context['hash'] = {'first' => 'Hello'}
+
+    assert_equal 1, @context['array.first']
+    assert_equal nil, @context['array["first"]']
+    assert_equal 'Hello', @context['hash["first"]']
+  end
+
+  def test_first_can_appear_in_middle_of_callchain
+
+    @context['product'] = {'variants' => [ {'title' => 'draft151cm'}, {'title' => 'element151cm'}  ]}
+
+    assert_equal 'draft151cm', @context['product.variants[0].title']
+    assert_equal 'element151cm', @context['product.variants[1].title']
+    assert_equal 'draft151cm', @context['product.variants.first.title']
+    assert_equal 'element151cm', @context['product.variants.last.title']
+
+  end
+
+  def test_cents
+    @context.merge( "cents" => HundredCentes.new )
+    assert_equal 100, @context['cents']
+  end
+
+  def test_nested_cents
+    @context.merge( "cents" => { 'amount' => HundredCentes.new} )
+    assert_equal 100, @context['cents.amount']
+
+    @context.merge( "cents" => { 'cents' => { 'amount' => HundredCentes.new} } )
+    assert_equal 100, @context['cents.cents.amount']
+  end
+
+  def test_cents_through_drop
+    @context.merge( "cents" => CentsDrop.new )
+    assert_equal 100, @context['cents.amount']
+  end
+
+  def test_nested_cents_through_drop
+    @context.merge( "vars" => {"cents" => CentsDrop.new} )
+    assert_equal 100, @context['vars.cents.amount']
+  end
+
+  def test_drop_methods_with_question_marks
+    @context.merge( "cents" => CentsDrop.new )
+    assert @context['cents.non_zero?']
+  end
+
+  def test_context_from_within_drop
+    @context.merge( "test" => '123', "vars" => ContextSensitiveDrop.new )
+    assert_equal '123', @context['vars.test']
+  end
+
+  def test_nested_context_from_within_drop
+    @context.merge( "test" => '123', "vars" => {"local" => ContextSensitiveDrop.new }  )
+    assert_equal '123', @context['vars.local.test']
+  end
+
+  def test_ranges
+    @context.merge( "test" => '5' )
+    assert_equal (1..5), @context['(1..5)']
+    assert_equal (1..5), @context['(1..test)']
+    assert_equal (5..5), @context['(test..test)']
+  end
+
+  def test_cents_through_drop_nestedly
+    @context.merge( "cents" => {"cents" => CentsDrop.new} )
+    assert_equal 100, @context['cents.cents.amount']
+
+    @context.merge( "cents" => { "cents" => {"cents" => CentsDrop.new}} )
+    assert_equal 100, @context['cents.cents.cents.amount']
+  end
+
+  def test_drop_with_variable_called_only_once
+    @context['counter'] = CounterDrop.new
+
+    assert_equal 1, @context['counter.count']
+    assert_equal 2, @context['counter.count']
+    assert_equal 3, @context['counter.count']
+  end
+
+  def test_drop_with_key_called_only_once
+    @context['counter'] = CounterDrop.new
+
+    assert_equal 1, @context['counter["count"]']
+    assert_equal 2, @context['counter["count"]']
+    assert_equal 3, @context['counter["count"]']
+  end
+
+  def test_proc_as_variable
+    @context['dynamic'] = Proc.new { 'Hello' }
+
+    assert_equal 'Hello', @context['dynamic']
+  end
+
+  def test_lambda_as_variable
+    @context['dynamic'] = proc { 'Hello' }
+
+    assert_equal 'Hello', @context['dynamic']
+  end
+
+  def test_nested_lambda_as_variable
+    @context['dynamic'] = { "lambda" => proc { 'Hello' } }
+
+    assert_equal 'Hello', @context['dynamic.lambda']
+  end
+
+  def test_array_containing_lambda_as_variable
+    @context['dynamic'] = [1,2, proc { 'Hello' } ,4,5]
+
+    assert_equal 'Hello', @context['dynamic[2]']
+  end
+
+  def test_lambda_is_called_once
+    @context['callcount'] = proc { @global ||= 0; @global += 1; @global.to_s }
+
+    assert_equal '1', @context['callcount']
+    assert_equal '1', @context['callcount']
+    assert_equal '1', @context['callcount']
+
+    @global = nil
+  end
+
+  def test_nested_lambda_is_called_once
+    @context['callcount'] = { "lambda" => proc { @global ||= 0; @global += 1; @global.to_s } }
+
+    assert_equal '1', @context['callcount.lambda']
+    assert_equal '1', @context['callcount.lambda']
+    assert_equal '1', @context['callcount.lambda']
+
+    @global = nil
+  end
+
+  def test_lambda_in_array_is_called_once
+    @context['callcount'] = [1,2, proc { @global ||= 0; @global += 1; @global.to_s } ,4,5]
+
+    assert_equal '1', @context['callcount[2]']
+    assert_equal '1', @context['callcount[2]']
+    assert_equal '1', @context['callcount[2]']
+
+    @global = nil
+  end
+
+  def test_access_to_context_from_proc
+    @context.registers[:magic] = 345392
+
+    @context['magic'] = proc { @context.registers[:magic] }
+
+    assert_equal 345392, @context['magic']
+  end
+
+  def test_to_liquid_and_context_at_first_level
+    @context['category'] = Category.new("foobar")
+    assert_kind_of CategoryDrop, @context['category']
+    assert_equal @context, @context['category'].context
+  end
+end # ContextTest