liquid 2.6.1 → 4.0.3

data/test/integration/variable_test.rb

@@ -0,0 +1,96 @@
+require 'test_helper'
+
+class VariableTest < Minitest::Test
+  include Liquid
+
+  def test_simple_variable
+    template = Template.parse(%({{test}}))
+    assert_equal 'worked', template.render!('test' => 'worked')
+    assert_equal 'worked wonderfully', template.render!('test' => 'worked wonderfully')
+  end
+
+  def test_variable_render_calls_to_liquid
+    assert_template_result 'foobar', '{{ foo }}', 'foo' => ThingWithToLiquid.new
+  end
+
+  def test_simple_with_whitespaces
+    template = Template.parse(%(  {{ test }}  ))
+    assert_equal '  worked  ', template.render!('test' => 'worked')
+    assert_equal '  worked wonderfully  ', template.render!('test' => 'worked wonderfully')
+  end
+
+  def test_ignore_unknown
+    template = Template.parse(%({{ test }}))
+    assert_equal '', template.render!
+  end
+
+  def test_using_blank_as_variable_name
+    template = Template.parse("{% assign foo = blank %}{{ foo }}")
+    assert_equal '', template.render!
+  end
+
+  def test_using_empty_as_variable_name
+    template = Template.parse("{% assign foo = empty %}{{ foo }}")
+    assert_equal '', template.render!
+  end
+
+  def test_hash_scoping
+    template = Template.parse(%({{ test.test }}))
+    assert_equal 'worked', template.render!('test' => { 'test' => 'worked' })
+  end
+
+  def test_false_renders_as_false
+    assert_equal 'false', Template.parse("{{ foo }}").render!('foo' => false)
+    assert_equal 'false', Template.parse("{{ false }}").render!
+  end
+
+  def test_nil_renders_as_empty_string
+    assert_equal '', Template.parse("{{ nil }}").render!
+    assert_equal 'cat', Template.parse("{{ nil | append: 'cat' }}").render!
+  end
+
+  def test_preset_assigns
+    template = Template.parse(%({{ test }}))
+    template.assigns['test'] = 'worked'
+    assert_equal 'worked', template.render!
+  end
+
+  def test_reuse_parsed_template
+    template = Template.parse(%({{ greeting }} {{ name }}))
+    template.assigns['greeting'] = 'Goodbye'
+    assert_equal 'Hello Tobi', template.render!('greeting' => 'Hello', 'name' => 'Tobi')
+    assert_equal 'Hello ', template.render!('greeting' => 'Hello', 'unknown' => 'Tobi')
+    assert_equal 'Hello Brian', template.render!('greeting' => 'Hello', 'name' => 'Brian')
+    assert_equal 'Goodbye Brian', template.render!('name' => 'Brian')
+    assert_equal({ 'greeting' => 'Goodbye' }, template.assigns)
+  end
+
+  def test_assigns_not_polluted_from_template
+    template = Template.parse(%({{ test }}{% assign test = 'bar' %}{{ test }}))
+    template.assigns['test'] = 'baz'
+    assert_equal 'bazbar', template.render!
+    assert_equal 'bazbar', template.render!
+    assert_equal 'foobar', template.render!('test' => 'foo')
+    assert_equal 'bazbar', template.render!
+  end
+
+  def test_hash_with_default_proc
+    template = Template.parse(%(Hello {{ test }}))
+    assigns = Hash.new { |h, k| raise "Unknown variable '#{k}'" }
+    assigns['test'] = 'Tobi'
+    assert_equal 'Hello Tobi', template.render!(assigns)
+    assigns.delete('test')
+    e = assert_raises(RuntimeError) do
+      template.render!(assigns)
+    end
+    assert_equal "Unknown variable 'test'", e.message
+  end
+
+  def test_multiline_variable
+    assert_equal 'worked', Template.parse("{{\ntest\n}}").render!('test' => 'worked')
+  end
+
+  def test_render_symbol
+    assert_template_result 'bar', '{{ foo }}', 'foo' => :bar
+  end
+end

data/test/test_helper.rb

@@ -1,29 +1,116 @@
 #!/usr/bin/env ruby
 
-require 'test/unit'
-require 'test/unit/assertions'
-begin
-  require 'ruby-debug'
-rescue LoadError
-  puts "Couldn't load ruby-debug. gem install ruby-debug if you need it."
+ENV["MT_NO_EXPECTATIONS"] = "1"
+require 'minitest/autorun'
+
+$LOAD_PATH.unshift(File.join(File.expand_path(__dir__), '..', 'lib'))
+require 'liquid.rb'
+require 'liquid/profiler'
+
+mode = :strict
+if env_mode = ENV['LIQUID_PARSER_MODE']
+  puts "-- #{env_mode.upcase} ERROR MODE"
+  mode = env_mode.to_sym
+end
+Liquid::Template.error_mode = mode
+
+if ENV['LIQUID-C'] == '1'
+  puts "-- LIQUID C"
+  require 'liquid/c'
+end
+
+if Minitest.const_defined?('Test')
+  # We're on Minitest 5+. Nothing to do here.
+else
+  # Minitest 4 doesn't have Minitest::Test yet.
+  Minitest::Test = MiniTest::Unit::TestCase
 end
-require File.join(File.dirname(__FILE__), '..', 'lib', 'liquid')
 
+module Minitest
+  class Test
+    def fixture(name)
+      File.join(File.expand_path(__dir__), "fixtures", name)
+    end
+  end
+
+  module Assertions
+    include Liquid
+
+    def assert_template_result(expected, template, assigns = {}, message = nil)
+      assert_equal expected, Template.parse(template).render!(assigns), message
+    end
 
-module Test
-  module Unit
-    module Assertions
-      include Liquid
+    def assert_template_result_matches(expected, template, assigns = {}, message = nil)
+      return assert_template_result(expected, template, assigns, message) unless expected.is_a? Regexp
 
-      def assert_template_result(expected, template, assigns = {}, message = nil)
-        assert_equal expected, Template.parse(template).render(assigns)
+      assert_match expected, Template.parse(template).render!(assigns), message
+    end
+
+    def assert_match_syntax_error(match, template, assigns = {})
+      exception = assert_raises(Liquid::SyntaxError) do
+        Template.parse(template).render(assigns)
       end
+      assert_match match, exception.message
+    end
 
-      def assert_template_result_matches(expected, template, assigns = {}, message = nil)
-        return assert_template_result(expected, template, assigns, message) unless expected.is_a? Regexp
+    def with_global_filter(*globals)
+      original_global_strainer = Liquid::Strainer.class_variable_get(:@@global_strainer)
+      Liquid::Strainer.class_variable_set(:@@global_strainer, Class.new(Liquid::Strainer) do
+        @filter_methods = Set.new
+      end)
+      Liquid::Strainer.class_variable_get(:@@strainer_class_cache).clear
 
-        assert_match expected, Template.parse(template).render(assigns)
+      globals.each do |global|
+        Liquid::Template.register_filter(global)
       end
-    end # Assertions
-  end # Unit
-end # Test
+      yield
+    ensure
+      Liquid::Strainer.class_variable_get(:@@strainer_class_cache).clear
+      Liquid::Strainer.class_variable_set(:@@global_strainer, original_global_strainer)
+    end
+
+    def with_taint_mode(mode)
+      old_mode = Liquid::Template.taint_mode
+      Liquid::Template.taint_mode = mode
+      yield
+    ensure
+      Liquid::Template.taint_mode = old_mode
+    end
+
+    def with_error_mode(mode)
+      old_mode = Liquid::Template.error_mode
+      Liquid::Template.error_mode = mode
+      yield
+    ensure
+      Liquid::Template.error_mode = old_mode
+    end
+  end
+end
+
+class ThingWithToLiquid
+  def to_liquid
+    'foobar'
+  end
+end
+
+class ErrorDrop < Liquid::Drop
+  def standard_error
+    raise Liquid::StandardError, 'standard error'
+  end
+
+  def argument_error
+    raise Liquid::ArgumentError, 'argument error'
+  end
+
+  def syntax_error
+    raise Liquid::SyntaxError, 'syntax error'
+  end
+
+  def runtime_error
+    raise 'runtime error'
+  end
+
+  def exception
+    raise Exception, 'exception'
+  end
+end

data/test/truffle/truffle_test.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+
+class TruffleTest < Minitest::Test
+  include Liquid
+
+  def test_truffle_works
+
+  end
+end

data/test/{liquid/block_test.rb → unit/block_unit_test.rb}

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class BlockTest < Test::Unit::TestCase
+class BlockUnitTest < Minitest::Test
   include Liquid
 
   def test_blankspace
@@ -34,7 +34,7 @@ class BlockTest < Test::Unit::TestCase
     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)
+      block_types(template.root.nodelist)
   end
 
   def test_with_block
@@ -45,14 +45,14 @@ class BlockTest < Test::Unit::TestCase
 
   def test_with_custom_tag
     Liquid::Template.register_tag("testtag", Block)
-
-    assert_nothing_thrown do
-      template = Liquid::Template.parse( "{% testtag %} {% endtesttag %}")
-    end
+    assert Liquid::Template.parse("{% testtag %} {% endtesttag %}")
+  ensure
+    Liquid::Template.tags.delete('testtag')
   end
 
   private
-    def block_types(nodelist)
-      nodelist.collect { |node| node.class }
-    end
+
+  def block_types(nodelist)
+    nodelist.collect(&:class)
+  end
 end # VariableTest

data/test/unit/condition_unit_test.rb

@@ -0,0 +1,166 @@
+require 'test_helper'
+
+class ConditionUnitTest < Minitest::Test
+  include Liquid
+
+  def setup
+    @context = Liquid::Context.new
+  end
+
+  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_evaluates_true 1, '==', 1
+    assert_evaluates_true 1, '!=', 2
+    assert_evaluates_true 1, '<>', 2
+    assert_evaluates_true 1, '<', 2
+    assert_evaluates_true 2, '>', 1
+    assert_evaluates_true 1, '>=', 1
+    assert_evaluates_true 2, '>=', 1
+    assert_evaluates_true 1, '<=', 2
+    assert_evaluates_true 1, '<=', 1
+    # negative numbers
+    assert_evaluates_true 1, '>', -1
+    assert_evaluates_true -1, '<', 1
+    assert_evaluates_true 1.0, '>', -1.0
+    assert_evaluates_true -1.0, '<', 1.0
+  end
+
+  def test_default_operators_evalute_false
+    assert_evaluates_false 1, '==', 2
+    assert_evaluates_false 1, '!=', 1
+    assert_evaluates_false 1, '<>', 1
+    assert_evaluates_false 1, '<', 0
+    assert_evaluates_false 2, '>', 4
+    assert_evaluates_false 1, '>=', 3
+    assert_evaluates_false 2, '>=', 4
+    assert_evaluates_false 1, '<=', 0
+    assert_evaluates_false 1, '<=', 0
+  end
+
+  def test_contains_works_on_strings
+    assert_evaluates_true 'bob', 'contains', 'o'
+    assert_evaluates_true 'bob', 'contains', 'b'
+    assert_evaluates_true 'bob', 'contains', 'bo'
+    assert_evaluates_true 'bob', 'contains', 'ob'
+    assert_evaluates_true 'bob', 'contains', 'bob'
+
+    assert_evaluates_false 'bob', 'contains', 'bob2'
+    assert_evaluates_false 'bob', 'contains', 'a'
+    assert_evaluates_false 'bob', 'contains', '---'
+  end
+
+  def test_invalid_comparation_operator
+    assert_evaluates_argument_error 1, '~~', 0
+  end
+
+  def test_comparation_of_int_and_str
+    assert_evaluates_argument_error '1', '>', 0
+    assert_evaluates_argument_error '1', '<', 0
+    assert_evaluates_argument_error '1', '>=', 0
+    assert_evaluates_argument_error '1', '<=', 0
+  end
+
+  def test_hash_compare_backwards_compatibility
+    assert_nil Condition.new({}, '>', 2).evaluate
+    assert_nil Condition.new(2, '>', {}).evaluate
+    assert_equal false, Condition.new({}, '==', 2).evaluate
+    assert_equal true, Condition.new({ 'a' => 1 }, '==', { 'a' => 1 }).evaluate
+    assert_equal true, Condition.new({ 'a' => 2 }, 'contains', 'a').evaluate
+  end
+
+  def test_contains_works_on_arrays
+    @context = Liquid::Context.new
+    @context['array'] = [1, 2, 3, 4, 5]
+    array_expr = VariableLookup.new("array")
+
+    assert_evaluates_false array_expr, 'contains', 0
+    assert_evaluates_true array_expr, 'contains', 1
+    assert_evaluates_true array_expr, 'contains', 2
+    assert_evaluates_true array_expr, 'contains', 3
+    assert_evaluates_true array_expr, 'contains', 4
+    assert_evaluates_true array_expr, 'contains', 5
+    assert_evaluates_false array_expr, 'contains', 6
+    assert_evaluates_false array_expr, 'contains', "1"
+  end
+
+  def test_contains_returns_false_for_nil_operands
+    @context = Liquid::Context.new
+    assert_evaluates_false VariableLookup.new('not_assigned'), 'contains', '0'
+    assert_evaluates_false 0, 'contains', VariableLookup.new('not_assigned')
+  end
+
+  def test_contains_return_false_on_wrong_data_type
+    assert_evaluates_false 1, 'contains', 0
+  end
+
+  def test_contains_with_string_left_operand_coerces_right_operand_to_string
+    assert_evaluates_true ' 1 ', 'contains', 1
+    assert_evaluates_false ' 1 ', 'contains', 2
+  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 { |cond, left, right| left =~ %r{^#{right}} }
+
+    assert_evaluates_true 'bob', 'starts_with', 'b'
+    assert_evaluates_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_evaluates_true VariableLookup.new("one"), '==', VariableLookup.new("another")
+  end
+
+  private
+
+  def assert_evaluates_true(left, op, right)
+    assert Condition.new(left, op, right).evaluate(@context),
+      "Evaluated false: #{left} #{op} #{right}"
+  end
+
+  def assert_evaluates_false(left, op, right)
+    assert !Condition.new(left, op, right).evaluate(@context),
+      "Evaluated true: #{left} #{op} #{right}"
+  end
+
+  def assert_evaluates_argument_error(left, op, right)
+    assert_raises(Liquid::ArgumentError) do
+      Condition.new(left, op, right).evaluate(@context)
+    end
+  end
+end # ConditionTest

data/test/{liquid/context_test.rb → unit/context_unit_test.rb}

@@ -63,7 +63,7 @@ class ArrayLike
   end
 end
 
-class ContextTest < Test::Unit::TestCase
+class ContextUnitTest < Minitest::Test
   include Liquid
 
   def setup
@@ -94,25 +94,23 @@ class ContextTest < Test::Unit::TestCase
     assert_equal false, @context['bool']
 
     @context['nil'] = nil
-    assert_equal nil, @context['nil']
-    assert_equal nil, @context['nil']
+    assert_nil @context['nil']
+    assert_nil @context['nil']
   end
 
   def test_variables_not_existing
-    assert_equal nil, @context['does_not_exist']
+    assert_nil @context['does_not_exist']
   end
 
   def test_scoping
-    assert_nothing_raised do
-      @context.push
-      @context.pop
-    end
+    @context.push
+    @context.pop
 
-    assert_raise(Liquid::ContextError) do
+    assert_raises(Liquid::ContextError) do
       @context.pop
     end
 
-    assert_raise(Liquid::ContextError) do
+    assert_raises(Liquid::ContextError) do
       @context.push
       @context.pop
       @context.pop
@@ -120,30 +118,25 @@ class ContextTest < Test::Unit::TestCase
   end
 
   def test_length_query
-
-    @context['numbers'] = [1,2,3,4]
+    @context['numbers'] = [1, 2, 3, 4]
 
     assert_equal 4, @context['numbers.size']
 
-    @context['numbers'] = {1 => 1,2 => 2,3 => 3,4 => 4}
+    @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}
+    @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!'
@@ -159,29 +152,9 @@ class ContextTest < Test::Unit::TestCase
 
     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!'
@@ -208,11 +181,11 @@ class ContextTest < Test::Unit::TestCase
     @context['test'] = 'test'
     assert_equal 'test', @context['test']
     @context.pop
-    assert_equal nil, @context['test']
+    assert_nil @context['test']
   end
 
   def test_hierachical_data
-    @context['hash'] = {"name" => 'tobi'}
+    @context['hash'] = { "name" => 'tobi' }
     assert_equal 'tobi', @context['hash.name']
     assert_equal 'tobi', @context['hash["name"]']
   end
@@ -241,7 +214,7 @@ class ContextTest < Test::Unit::TestCase
   end
 
   def test_array_notation
-    @context['test'] = [1,2,3,4,5]
+    @context['test'] = [1, 2, 3, 4, 5]
 
     assert_equal 1, @context['test[0]']
     assert_equal 2, @context['test[1]']
@@ -251,21 +224,21 @@ class ContextTest < Test::Unit::TestCase
   end
 
   def test_recoursive_array_notation
-    @context['test'] = {'test' => [1,2,3,4,5]}
+    @context['test'] = { 'test' => [1, 2, 3, 4, 5] }
 
     assert_equal 1, @context['test.test[0]']
 
-    @context['test'] = [{'test' => 'worked'}]
+    @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']
+      '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]']
@@ -273,12 +246,12 @@ class ContextTest < Test::Unit::TestCase
   end
 
   def test_try_first
-    @context['test'] = [1,2,3,4,5]
+    @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]}
+    @context['test'] = { 'test' => [1, 2, 3, 4, 5] }
 
     assert_equal 1, @context['test.test.first']
     assert_equal 5, @context['test.test.last']
@@ -289,8 +262,8 @@ class ContextTest < Test::Unit::TestCase
   end
 
   def test_access_hashes_with_hash_notation
-    @context['products'] = {'count' => 5, 'tags' => ['deepsnow', 'freestyle'] }
-    @context['product'] = {'variants' => [ {'title' => 'draft151cm'}, {'title' => 'element151cm'}  ]}
+    @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]']
@@ -310,85 +283,82 @@ class ContextTest < Test::Unit::TestCase
   end
 
   def test_access_hashes_with_hash_access_variables
-
     @context['var'] = 'tags'
-    @context['nested'] = {'var' => 'tags'}
-    @context['products'] = {'count' => 5, 'tags' => ['deepsnow', 'freestyle'] }
+    @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'}
+    @context['array'] = [1, 2, 3, 4, 5]
+    @context['hash'] = { 'first' => 'Hello' }
 
     assert_equal 1, @context['array.first']
-    assert_equal nil, @context['array["first"]']
+    assert_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'}  ]}
+    @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 )
+    @context.merge("cents" => HundredCentes.new)
     assert_equal 100, @context['cents']
   end
 
   def test_nested_cents
-    @context.merge( "cents" => { 'amount' => HundredCentes.new} )
+    @context.merge("cents" => { 'amount' => HundredCentes.new })
     assert_equal 100, @context['cents.amount']
 
-    @context.merge( "cents" => { 'cents' => { 'amount' => HundredCentes.new} } )
+    @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 )
+    @context.merge("cents" => CentsDrop.new)
     assert_equal 100, @context['cents.amount']
   end
 
   def test_nested_cents_through_drop
-    @context.merge( "vars" => {"cents" => CentsDrop.new} )
+    @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 )
+    @context.merge("cents" => CentsDrop.new)
     assert @context['cents.non_zero?']
   end
 
   def test_context_from_within_drop
-    @context.merge( "test" => '123', "vars" => ContextSensitiveDrop.new )
+    @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 }  )
+    @context.merge("test" => '123', "vars" => { "local" => ContextSensitiveDrop.new })
     assert_equal '123', @context['vars.local.test']
   end
 
   def test_ranges
-    @context.merge( "test" => '5' )
+    @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} )
+    @context.merge("cents" => { "cents" => CentsDrop.new })
     assert_equal 100, @context['cents.cents.amount']
 
-    @context.merge( "cents" => { "cents" => {"cents" => CentsDrop.new}} )
+    @context.merge("cents" => { "cents" => { "cents" => CentsDrop.new } })
     assert_equal 100, @context['cents.cents.cents.amount']
   end
 
@@ -409,7 +379,7 @@ class ContextTest < Test::Unit::TestCase
   end
 
   def test_proc_as_variable
-    @context['dynamic'] = Proc.new { 'Hello' }
+    @context['dynamic'] = proc { 'Hello' }
 
     assert_equal 'Hello', @context['dynamic']
   end
@@ -427,7 +397,7 @@ class ContextTest < Test::Unit::TestCase
   end
 
   def test_array_containing_lambda_as_variable
-    @context['dynamic'] = [1,2, proc { 'Hello' } ,4,5]
+    @context['dynamic'] = [1, 2, proc { 'Hello' }, 4, 5]
 
     assert_equal 'Hello', @context['dynamic[2]']
   end
@@ -453,7 +423,7 @@ class ContextTest < Test::Unit::TestCase
   end
 
   def test_lambda_in_array_is_called_once
-    @context['callcount'] = [1,2, proc { @global ||= 0; @global += 1; @global.to_s } ,4,5]
+    @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]']
@@ -475,4 +445,45 @@ class ContextTest < Test::Unit::TestCase
     assert_kind_of CategoryDrop, @context['category']
     assert_equal @context, @context['category'].context
   end
+
+  def test_interrupt_avoids_object_allocations
+    assert_no_object_allocations do
+      @context.interrupt?
+    end
+  end
+
+  def test_context_initialization_with_a_proc_in_environment
+    contx = Context.new([test: ->(c) { c['poutine'] }], { test: :foo })
+
+    assert contx
+    assert_nil contx['poutine']
+  end
+
+  def test_apply_global_filter
+    global_filter_proc = ->(output) { "#{output} filtered" }
+
+    context = Context.new
+    context.global_filter = global_filter_proc
+
+    assert_equal 'hi filtered', context.apply_global_filter('hi')
+  end
+
+  def test_apply_global_filter_when_no_global_filter_exist
+    context = Context.new
+    assert_equal 'hi', context.apply_global_filter('hi')
+  end
+
+  private
+
+  def assert_no_object_allocations
+    unless RUBY_ENGINE == 'ruby'
+      skip "stackprof needed to count object allocations"
+    end
+    require 'stackprof'
+
+    profile = StackProf.run(mode: :object) do
+      yield
+    end
+    assert_equal 0, profile[:samples]
+  end
 end # ContextTest