Version bump

- added test that asserts nonexistent filters are ignored

Liquid
  - Bill's mind blowing liquid patch to support filter separators (|) in quoted strings (svn r7516).
  - This is a consolidation effort based on newrelic's liquid fork commit 88a5b891d009054d56b994c9448725c74e2b1e13

.gitignore

@@ -1,2 +1,3 @@
 *.gem
+*.swp
 pkg

Rakefile

@@ -1,4 +1,6 @@
 #!/usr/bin/env ruby
+$:.unshift File.join(File.dirname(__FILE__), 'test') unless $:.include? File.join(File.dirname(__FILE__), 'test')
+
 require 'rubygems'
 require 'rake'
 require 'rake/testtask'
@@ -7,9 +9,8 @@ require 'rake/gempackagetask'
 task :default => 'test'
 
 Rake::TestTask.new(:test) do |t|
-  t.libs << "lib"
-  t.libs << "test"
-  t.pattern = 'test/*_test.rb'
+  t.libs << '.' << 'lib' << 'test'
+  t.pattern = 'test/lib/**/*_test.rb'
   t.verbose = false
 end
 
@@ -25,20 +26,18 @@ end
 
 namespace :profile do
 
-  
   task :default => [:run]
-  
+
   desc "Run the liquid profile/perforamce coverage"
   task :run do
-  
+
     ruby "performance/shopify.rb"
-  
+
   end
-  
-  desc "Run KCacheGrind" 
+
+  desc "Run KCacheGrind"
   task :grind => :run  do
     system "kcachegrind /tmp/liquid.rubyprof_calltreeprinter.txt"
   end
+
 end
-  
-  

lib/liquid.rb

@@ -38,7 +38,7 @@ module Liquid
   StrictQuotedFragment        = /"[^"]+"|'[^']+'|[^\s,\|,\:,\,]+/
   FirstFilterArgument         = /#{FilterArgumentSeparator}(?:#{StrictQuotedFragment})/
   OtherFilterArgument         = /#{ArgumentSeparator}(?:#{StrictQuotedFragment})/
-  SpacelessFilter             = /#{FilterSeparator}(?:#{StrictQuotedFragment})(?:#{FirstFilterArgument}(?:#{OtherFilterArgument})*)?/
+  SpacelessFilter             = /^(?:'[^']+'|"[^"]+"|[^'"])*#{FilterSeparator}(?:#{StrictQuotedFragment})(?:#{FirstFilterArgument}(?:#{OtherFilterArgument})*)?/
   Expression                  = /(?:#{QuotedFragment}(?:#{SpacelessFilter})*)/
   TagAttributes               = /(\w+)\s*\:\s*(#{QuotedFragment})/
   AnyStartingTag              = /\{\{|\{\%/

lib/liquid/context.rb

@@ -28,8 +28,9 @@ module Liquid
       @strainer ||= Strainer.create(self)
     end
 
-    # adds filters to this context.
-    # this does not register the filters with the main Template object. see <tt>Template.register_filter</tt>
+    # Adds filters to this context.
+    #
+    # Note that this does not register the filters with the main Template object. see <tt>Template.register_filter</tt>
     # for that
     def add_filters(filters)
       filters = [filters].flatten.compact
@@ -52,7 +53,6 @@ module Liquid
       end
     end
 
-
     def invoke(method, *args)
       if strainer.respond_to?(method)
         strainer.__send__(method, *args)
@@ -61,43 +61,44 @@ module Liquid
       end
     end
 
-    # push new local scope on the stack. use <tt>Context#stack</tt> instead
+    # Push new local scope on the stack. use <tt>Context#stack</tt> instead
     def push(new_scope={})
       raise StackLevelError, "Nesting too deep" if @scopes.length > 100
       @scopes.unshift(new_scope)
     end
 
-    # merge a hash of variables in the current local scope
+    # Merge a hash of variables in the current local scope
     def merge(new_scopes)
       @scopes[0].merge!(new_scopes)
     end
 
-    # pop from the stack. use <tt>Context#stack</tt> instead
+    # Pop from the stack. use <tt>Context#stack</tt> instead
     def pop
       raise ContextError if @scopes.size == 1
       @scopes.shift
     end
 
-    # pushes a new local scope on the stack, pops it at the end of the block
+    # Pushes a new local scope on the stack, pops it at the end of the block
     #
     # Example:
-    #
     #   context.stack do
     #      context['var'] = 'hi'
     #   end
-    #   context['var]  #=> nil
     #
+    #   context['var]  #=> nil
     def stack(new_scope={},&block)
       result = nil
       push(new_scope)
+
       begin
         result = yield
       ensure
         pop
       end
+
       result
     end
-    
+
     def clear_instance_assigns
       @scopes[0] = {}
     end
@@ -116,139 +117,133 @@ module Liquid
     end
 
     private
-
-    # Look up variable, either resolve directly after considering the name. We can directly handle
-    # Strings, digits, floats and booleans (true,false). If no match is made we lookup the variable in the current scope and
-    # later move up to the parent blocks to see if we can resolve the variable somewhere up the tree.
-    # Some special keywords return symbols. Those symbols are to be called on the rhs object in expressions
-    #
-    # Example:
-    #
-    #   products == empty #=> products.empty?
-    #
-    def resolve(key)
-      case key
-      when nil, 'nil', 'null', ''
-        nil
-      when 'true'
-        true
-      when 'false'
-        false
-      when 'blank'
-        :blank?
-      when 'empty'
-        :empty?
-      # Single quoted strings
-      when /^'(.*)'$/
-        $1.to_s
-      # Double quoted strings
-      when /^"(.*)"$/
-        $1.to_s
-      # Integer and floats
-      when /^(\d+)$/
-        $1.to_i
-      # Ranges
-      when /^\((\S+)\.\.(\S+)\)$/
-        (resolve($1).to_i..resolve($2).to_i)
-      # Floats
-      when /^(\d[\d\.]+)$/
-        $1.to_f
-      else
-        variable(key)
-      end
-    end
-
-    # fetches an object starting at the local scope and then moving up
-    # the hierachy
-    def find_variable(key)
-      scope = @scopes.find { |s| s.has_key?(key) }
-      if scope.nil?
-        @environments.each do |e|
-          if variable = lookup_and_evaluate(e, key)
-            scope = e
-            break
-          end
-        end
-      end
-      scope     ||= @environments.last || @scopes.last
-      variable  ||= lookup_and_evaluate(scope, key)
-      
-      variable = variable.to_liquid
-      variable.context = self if variable.respond_to?(:context=)
-      return variable
-    end
-
-    # resolves namespaced queries gracefully.
-    #
-    # Example
-    #
-    #  @context['hash'] = {"name" => 'tobi'}
-    #  assert_equal 'tobi', @context['hash.name']
-    #  assert_equal 'tobi', @context['hash["name"]']
-    #
-    def variable(markup)
-      parts = markup.scan(VariableParser)
-      square_bracketed = /^\[(.*)\]$/
-
-      first_part = parts.shift
-      if first_part =~ square_bracketed
-        first_part = resolve($1)
-      end
-
-      if object = find_variable(first_part)
-
-        parts.each do |part|
-          part = resolve($1) if part_resolved = (part =~ square_bracketed)
-
-          # If object is a hash- or array-like object we look for the
-          # presence of the key and if its available we return it
-          if object.respond_to?(:[]) and
-            ((object.respond_to?(:has_key?) and object.has_key?(part)) or
-             (object.respond_to?(:fetch) and part.is_a?(Integer)))
-
-            # if its a proc we will replace the entry with the proc
-            res = lookup_and_evaluate(object, part)
-            object = res.to_liquid
-
-          # Some special cases. If the part wasn't in square brackets and
-          # no key with the same name was found we interpret following calls
-          # as commands and call them on the current object
-          elsif !part_resolved and object.respond_to?(part) and ['size', 'first', 'last'].include?(part)
-
-            object = object.send(part.intern).to_liquid
-
-          # No key was present with the desired value and it wasn't one of the directly supported
-          # keywords either. The only thing we got left is to return nil
-          else
-            return nil
-          end
-
-          # If we are dealing with a drop here we have to
-          object.context = self if object.respond_to?(:context=)
+      # Look up variable, either resolve directly after considering the name. We can directly handle
+      # Strings, digits, floats and booleans (true,false).
+      # If no match is made we lookup the variable in the current scope and
+      # later move up to the parent blocks to see if we can resolve the variable somewhere up the tree.
+      # Some special keywords return symbols. Those symbols are to be called on the rhs object in expressions
+      #
+      # Example:
+      #   products == empty #=> products.empty?
+      def resolve(key)
+        case key
+        when nil, 'nil', 'null', ''
+          nil
+        when 'true'
+          true
+        when 'false'
+          false
+        when 'blank'
+          :blank?
+        when 'empty' # Single quoted strings
+          :empty?
+        when /^'(.*)'$/ # Double quoted strings
+          $1.to_s
+        when /^"(.*)"$/ # Integer and floats
+          $1.to_s
+        when /^(\d+)$/ # Ranges
+          $1.to_i
+        when /^\((\S+)\.\.(\S+)\)$/ # Floats
+          (resolve($1).to_i..resolve($2).to_i)
+        when /^(\d[\d\.]+)$/
+          $1.to_f
+        else
+          variable(key)
         end
       end
 
-      object
-    end
-    
-    def lookup_and_evaluate(obj, key)
-      if (value = obj[key]).is_a?(Proc) && obj.respond_to?(:[]=)
-        obj[key] = value.call(self)
-      else
-        value
-      end
-    end
-    
-    def squash_instance_assigns_with_environments
-      @scopes.last.each_key do |k|
-        @environments.each do |env|
-          if env.has_key?(k)
-            scopes.last[k] = lookup_and_evaluate(env, k)
-            break
+      # Fetches an object starting at the local scope and then moving up the hierachy
+      def find_variable(key)
+        scope = @scopes.find { |s| s.has_key?(key) }
+
+        if scope.nil?
+          @environments.each do |e|
+            if variable = lookup_and_evaluate(e, key)
+              scope = e
+              break
+            end
           end
         end
+
+        scope     ||= @environments.last || @scopes.last
+        variable  ||= lookup_and_evaluate(scope, key)
+
+        variable = variable.to_liquid
+        variable.context = self if variable.respond_to?(:context=)
+
+        return variable
       end
-    end
-    
-  end
-end
+
+      # Resolves namespaced queries gracefully.
+      #
+      # Example
+      #  @context['hash'] = {"name" => 'tobi'}
+      #  assert_equal 'tobi', @context['hash.name']
+      #  assert_equal 'tobi', @context['hash["name"]']
+      def variable(markup)
+        parts = markup.scan(VariableParser)
+        square_bracketed = /^\[(.*)\]$/
+
+        first_part = parts.shift
+
+        if first_part =~ square_bracketed
+          first_part = resolve($1)
+        end
+
+        if object = find_variable(first_part)
+
+          parts.each do |part|
+            part = resolve($1) if part_resolved = (part =~ square_bracketed)
+
+            # If object is a hash- or array-like object we look for the
+            # presence of the key and if its available we return it
+            if object.respond_to?(:[]) and
+              ((object.respond_to?(:has_key?) and object.has_key?(part)) or
+               (object.respond_to?(:fetch) and part.is_a?(Integer)))
+
+              # if its a proc we will replace the entry with the proc
+              res = lookup_and_evaluate(object, part)
+              object = res.to_liquid
+
+              # Some special cases. If the part wasn't in square brackets and
+              # no key with the same name was found we interpret following calls
+              # as commands and call them on the current object
+            elsif !part_resolved and object.respond_to?(part) and ['size', 'first', 'last'].include?(part)
+
+              object = object.send(part.intern).to_liquid
+
+              # No key was present with the desired value and it wasn't one of the directly supported
+              # keywords either. The only thing we got left is to return nil
+            else
+              return nil
+            end
+
+            # If we are dealing with a drop here we have to
+            object.context = self if object.respond_to?(:context=)
+          end
+        end
+
+        object
+      end # variable
+
+      def lookup_and_evaluate(obj, key)
+        if (value = obj[key]).is_a?(Proc) && obj.respond_to?(:[]=)
+          obj[key] = (value.arity == 0) ? value.call : value.call(self)
+        else
+          value
+        end
+      end # lookup_and_evaluate
+
+      def squash_instance_assigns_with_environments
+        @scopes.last.each_key do |k|
+          @environments.each do |env|
+            if env.has_key?(k)
+              scopes.last[k] = lookup_and_evaluate(env, k)
+              break
+            end
+          end
+        end
+      end # squash_instance_assigns_with_environments
+  end # Context
+
+end # Liquid

lib/liquid/standardfilters.rb

@@ -1,36 +1,40 @@
 require 'cgi'
 
 module Liquid
-  
+
   module StandardFilters
-    
+
     # Return the size of an array or of an string
     def size(input)
-      
+
       input.respond_to?(:size) ? input.size : 0
-    end         
-    
+    end
+
     # convert a input string to DOWNCASE
     def downcase(input)
       input.to_s.downcase
-    end         
+    end
 
     # convert a input string to UPCASE
     def upcase(input)
       input.to_s.upcase
     end
-    
+
     # capitalize words in the input centence
     def capitalize(input)
       input.to_s.capitalize
     end
-        
+
     def escape(input)
       CGI.escapeHTML(input) rescue input
     end
-    
+
+    def escape_once(input)
+      ActionView::Helpers::TagHelper.escape_once(input) rescue input
+    end
+
     alias_method :h, :escape
-    
+
     # Truncate a string down to x characters
     def truncate(input, length = 50, truncate_string = "...")
       if input.nil? then return end
@@ -44,19 +48,19 @@ module Liquid
       wordlist = input.to_s.split
       l = words.to_i - 1
       l = 0 if l < 0
-      wordlist.length > l ? wordlist[0..l].join(" ") + truncate_string : input 
+      wordlist.length > l ? wordlist[0..l].join(" ") + truncate_string : input
     end
-    
+
     def strip_html(input)
       input.to_s.gsub(/<script.*?<\/script>/, '').gsub(/<.*?>/, '')
-    end       
-    
-    # Remove all newlines from the string
-    def strip_newlines(input)        
-      input.to_s.gsub(/\n/, '')      
     end
-    
-    
+
+    # Remove all newlines from the string
+    def strip_newlines(input)
+      input.to_s.gsub(/\n/, '')
+    end
+
+
     # Join elements of the array with certain character between them
     def join(input, glue = ' ')
       [input].flatten.join(glue)
@@ -73,8 +77,8 @@ module Liquid
       elsif ary.first.respond_to?(property)
         ary.sort {|a,b| a.send(property) <=> b.send(property) }
       end
-    end               
-    
+    end
+
     # map/collect on a given property
     def map(input, property)
       ary = [input].flatten
@@ -84,42 +88,42 @@ module Liquid
         ary.map {|e| e.send(property) }
       end
     end
-            
+
     # Replace occurrences of a string with another
     def replace(input, string, replacement = '')
       input.to_s.gsub(string, replacement)
     end
-                                                 
+
     # Replace the first occurrences of a string with another
     def replace_first(input, string, replacement = '')
       input.to_s.sub(string, replacement)
-    end              
-                                                           
+    end
+
     # remove a substring
     def remove(input, string)
-      input.to_s.gsub(string, '')      
+      input.to_s.gsub(string, '')
     end
-                        
+
     # remove the first occurrences of a substring
     def remove_first(input, string)
-      input.to_s.sub(string, '')      
-    end             
-                              
+      input.to_s.sub(string, '')
+    end
+
     # add one string to another
     def append(input, string)
       input.to_s + string.to_s
     end
-                                
+
     # prepend a string to another
     def prepend(input, string)
       string.to_s + input.to_s
     end
-                                             
+
     # Add <br /> tags in front of all newlines in input string
-    def newline_to_br(input)        
-      input.to_s.gsub(/\n/, "<br />\n")      
+    def newline_to_br(input)
+      input.to_s.gsub(/\n/, "<br />\n")
     end
-    
+
     # Reformat a date
     #
     #   %a - The abbreviated weekday name (``Sun'')
@@ -149,74 +153,74 @@ module Liquid
     #   %Z - Time zone name
     #   %% - Literal ``%'' character
     def date(input, format)
-      
+
       if format.to_s.empty?
         return input.to_s
       end
-      
+
       date = input.is_a?(String) ? Time.parse(input) : input
-      
+
       if date.respond_to?(:strftime)
         date.strftime(format.to_s)
       else
         input
       end
-    rescue => e 
+    rescue => e
       input
     end
-    
-    # Get the first element of the passed in array 
-    # 
+
+    # Get the first element of the passed in array
+    #
     # Example:
     #    {{ product.images | first | to_img }}
-    #  
+    #
     def first(array)
       array.first if array.respond_to?(:first)
     end
 
-    # Get the last element of the passed in array 
-    # 
+    # Get the last element of the passed in array
+    #
     # Example:
     #    {{ product.images | last | to_img }}
-    #  
+    #
     def last(array)
       array.last if array.respond_to?(:last)
     end
-    
+
     # addition
     def plus(input, operand)
       to_number(input) + to_number(operand)
     end
-    
+
     # subtraction
     def minus(input, operand)
       to_number(input) - to_number(operand)
     end
-    
+
     # multiplication
     def times(input, operand)
       to_number(input) * to_number(operand)
     end
-    
+
     # division
     def divided_by(input, operand)
       to_number(input) / to_number(operand)
     end
-    
+
     private
-    
-    def to_number(obj)
-      case obj
-      when Numeric
-        obj
-      when String
-        (obj.strip =~ /^\d+\.\d+$/) ? obj.to_f : obj.to_i
-      else
-        0
+
+      def to_number(obj)
+        case obj
+        when Numeric
+          obj
+        when String
+          (obj.strip =~ /^\d+\.\d+$/) ? obj.to_f : obj.to_i
+        else
+          0
+        end
       end
-    end
-    
+
   end
-   
+
   Template.register_filter(StandardFilters)
 end

lib/liquid/strainer.rb

@@ -16,6 +16,9 @@ module Liquid
     INTERNAL_METHOD = /^__/
     @@required_methods = Set.new([:__id__, :__send__, :respond_to?, :extend, :methods, :class, :object_id])
 
+    # Ruby 1.9.2 introduces Object#respond_to_missing?, which is invoked by Object#respond_to?
+    @@required_methods << :respond_to_missing? if Object.respond_to? :respond_to_missing?
+
     @@filters = {}
 
     def initialize(context)

liquid.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = %q{liquid}
-  s.version = "2.1.3"
+  s.version = "2.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Tobias Luetke"]

test/assign_test.rb

@@ -1,11 +0,0 @@
-require File.dirname(__FILE__) + '/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
-
-end

test/helper.rb

@@ -1,20 +0,0 @@
-#!/usr/bin/env ruby
-$LOAD_PATH.unshift(File.dirname(__FILE__)+ '/extra')
-
-require 'test/unit'
-require 'test/unit/assertions'
-require 'caller'
-require 'breakpoint'
-require File.dirname(__FILE__) + '/../lib/liquid'
-
-
-module Test
-  module Unit
-    module Assertions
-        include Liquid
-        def assert_template_result(expected, template, assigns={}, message=nil)
-          assert_equal expected, Template.parse(template).render(assigns)
-        end 
-    end
-  end
-end

test/include_tag_test.rb

@@ -1,129 +0,0 @@
-require File.dirname(__FILE__) + '/helper'
-
-class TestFileSystem 
-  def read_template_file(template_path)
-    case template_path
-    when "product"
-      "Product: {{ product.title }} "
-
-    when "locale_variables"
-      "Locale: {{echo1}} {{echo2}}"
-
-    when "variant"
-      "Variant: {{ variant.title }}"
-      
-    when "nested_template"
-      "{% include 'header' %} {% include 'body' %} {% include 'footer' %}"
-      
-    when "body"
-      "body {% include 'body_detail' %}"
-      
-    when "nested_product_template"
-      "Product: {{ nested_product_template.title }} {%include 'details'%} "
-
-    when "recursively_nested_template"
-      "-{% include 'recursively_nested_template' %}"
-
-    when "pick_a_source"
-      "from TestFileSystem"
-      
-    else
-      template_path
-    end
-  end
-end
-
-class OtherFileSystem
-  def read_template_file(template_path)
-    'from OtherFileSystem'
-  end
-end
-
-class IncludeTagTest < Test::Unit::TestCase
-  include Liquid
-  
-  def setup
-    Liquid::Template.file_system = TestFileSystem.new    
-  end
-  
-  def test_include_tag_looks_for_file_system_in_registers_first
-    assert_equal 'from OtherFileSystem',
-                 Template.parse("{% include 'pick_a_source' %}").render({}, :registers => {:file_system => OtherFileSystem.new})
-  end
-  
-
-  def test_include_tag_with    
-    assert_equal "Product: Draft 151cm ", 
-                 Template.parse("{% include 'product' with products[0] %}").render( "products" => [ {'title' => 'Draft 151cm'}, {'title' => 'Element 155cm'} ]  )
-  end
-
-  def test_include_tag_with_default_name    
-    assert_equal "Product: Draft 151cm ", 
-                 Template.parse("{% include 'product' %}").render( "product" => {'title' => 'Draft 151cm'}  )
-  end
-
-  def test_include_tag_for
-    
-    assert_equal "Product: Draft 151cm Product: Element 155cm ", 
-                 Template.parse("{% include 'product' for products %}").render( "products" => [ {'title' => 'Draft 151cm'}, {'title' => 'Element 155cm'} ]  )
-  end
-
-  def test_include_tag_with_local_variables    
-    assert_equal "Locale: test123 ", 
-                 Template.parse("{% include 'locale_variables' echo1: 'test123' %}").render
-  end
-
-  def test_include_tag_with_multiple_local_variables    
-    assert_equal "Locale: test123 test321", 
-                 Template.parse("{% include 'locale_variables' echo1: 'test123', echo2: 'test321' %}").render
-  end
-
-  def test_include_tag_with_multiple_local_variables_from_context    
-    assert_equal "Locale: test123 test321", 
-                 Template.parse("{% include 'locale_variables' echo1: echo1, echo2: more_echos.echo2 %}").render('echo1' => 'test123', 'more_echos' => { "echo2" => 'test321'})
-  end
-
-  def test_nested_include_tag
-    assert_equal "body body_detail", 
-                 Template.parse("{% include 'body' %}").render
-
-    assert_equal "header body body_detail footer", 
-                 Template.parse("{% include 'nested_template' %}").render
-  end
-  
-  def test_nested_include_with_variable
-
-    assert_equal "Product: Draft 151cm details ", 
-                 Template.parse("{% include 'nested_product_template' with product %}").render("product" => {"title" => 'Draft 151cm'})
-
-    assert_equal "Product: Draft 151cm details Product: Element 155cm details ", 
-                 Template.parse("{% include 'nested_product_template' for products %}").render("products" => [{"title" => 'Draft 151cm'}, {"title" => 'Element 155cm'}])
-    
-  end
-  
-  def test_recursively_included_template_does_not_produce_endless_loop
-        
-    infinite_file_system = Class.new do  
-      def read_template_file(template_path)
-        "-{% include 'loop' %}"
-      end
-    end                   
-    
-    Liquid::Template.file_system = infinite_file_system.new
-                   
-    assert_raise(Liquid::StackLevelError) do
-      Template.parse("{% include 'loop' %}").render!
-    end
-    
-  end
-            
-  def test_dynamically_choosen_template
-
-    assert_equal "Test123", Template.parse("{% include template %}").render("template" => 'Test123')
-    assert_equal "Test321", Template.parse("{% include template %}").render("template" => 'Test321')
-
-    assert_equal "Product: Draft 151cm ", Template.parse("{% include template for product %}").render("template" => 'product', 'product' => { 'title' => 'Draft 151cm'})
-    
-  end
-  
-end

test/lib/liquid/assign_test.rb

@@ -0,0 +1,15 @@
+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
+end # AssignTest

test/lib/liquid/block_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/helper'
+require 'test_helper'
 
 class VariableTest < Test::Unit::TestCase
   include Liquid
@@ -33,26 +33,26 @@ class VariableTest < Test::Unit::TestCase
   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)
+    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 [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 
+
+  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
+    def block_types(nodelist)
+      nodelist.collect { |node| node.class }
+    end
+end # VariableTest

test/lib/liquid/capture_test.rb

@@ -1,41 +1,40 @@
-require File.dirname(__FILE__) + '/helper'
+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}}", {})    
+    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}}
+    {% 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 }}
+    {% 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
+end # CaptureTest

test/lib/liquid/condition_test.rb

@@ -1,8 +1,8 @@
-require File.dirname(__FILE__) + '/helper'
+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
@@ -47,7 +47,7 @@ class ConditionTest < Test::Unit::TestCase
   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'
@@ -55,61 +55,64 @@ class ConditionTest < Test::Unit::TestCase
     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  
+
+    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  
+  end
 
-  def test_or_condition     
+  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')  
-    
+    condition.or Condition.new('1', '==', '1')
+
     assert_equal true, condition.evaluate
   end
-  
-  def test_and_condition     
+
+  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')  
-    
+    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}}}
-    
+    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'
+
+    ensure
+      Condition.operators.delete 'starts_with'
   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}"
+      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}"
+      assert !Condition.new(left, op, right).evaluate(@context || Liquid::Context.new),
+             "Evaluated true: #{left} #{op} #{right}"
     end
-end
+end # ConditionTest

test/lib/liquid/context_test.rb

@@ -1,4 +1,5 @@
-require File.dirname(__FILE__) + '/helper'
+require 'test_helper'
+
 class HundredCentes
   def to_liquid
     100
@@ -62,7 +63,6 @@ class ArrayLike
   end
 end
 
-
 class ContextTest < Test::Unit::TestCase
   include Liquid
 
@@ -262,10 +262,10 @@ class ContextTest < Test::Unit::TestCase
 
   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]']
@@ -475,5 +475,4 @@ class ContextTest < Test::Unit::TestCase
     assert_kind_of CategoryDrop, @context['category']
     assert_equal @context, @context['category'].context
   end
-
-end
+end # ContextTest

test/lib/liquid/drop_test.rb

@@ -1,6 +1,4 @@
-
-#!/usr/bin/env ruby
-require File.dirname(__FILE__) + '/helper'
+require 'test_helper'
 
 class ContextDrop < Liquid::Drop
   def scopes
@@ -10,7 +8,7 @@ class ContextDrop < Liquid::Drop
   def scopes_as_array
     (1..@context.scopes.size).to_a
   end
-  
+
   def loop_pos
     @context['forloop.index']
   end
@@ -18,13 +16,12 @@ class ContextDrop < Liquid::Drop
   def break
     Breakpoint.breakpoint
   end
-  
+
   def before_method(method)
     return @context[method]
   end
 end
 
-
 class ProductDrop < Liquid::Drop
 
   class TextDrop < Liquid::Drop
@@ -50,42 +47,41 @@ class ProductDrop < Liquid::Drop
   def catchall
     CatchallDrop.new
   end
-  
+
   def context
     ContextDrop.new
   end
-  
+
   protected
     def callmenot
       "protected"
     end
-end                   
+end
+
+class EnumerableDrop < Liquid::Drop
 
-class EnumerableDrop < Liquid::Drop   
-  
   def size
     3
   end
-  
+
   def each
     yield 1
     yield 2
     yield 3
-  end          
+  end
 end
 
-
 class DropsTest < Test::Unit::TestCase
   include Liquid
-  
+
   def test_product_drop
-    
+
     assert_nothing_raised do
       tpl = Liquid::Template.parse( '  '  )
       tpl.render('product' => ProductDrop.new)
     end
   end
-  
+
   def test_text_drop
     output = Liquid::Template.parse( ' {{ product.texts.text }} '  ).render('product' => ProductDrop.new)
     assert_equal ' text1 ', output
@@ -102,61 +98,56 @@ class DropsTest < Test::Unit::TestCase
     output = Liquid::Template.parse( '{% for text in product.texts.array %} {{text}} {% endfor %}'  ).render('product' => ProductDrop.new)
     assert_equal ' text1  text2 ', output
   end
-  
+
   def test_context_drop
     output = Liquid::Template.parse( ' {{ context.bar }} '  ).render('context' => ContextDrop.new, 'bar' => "carrot")
     assert_equal ' carrot ', output
   end
-  
+
   def test_nested_context_drop
     output = Liquid::Template.parse( ' {{ product.context.foo }} '  ).render('product' => ProductDrop.new, 'foo' => "monkey")
     assert_equal ' monkey ', output
-  end  
+  end
 
   def test_protected
     output = Liquid::Template.parse( ' {{ product.callmenot }} '  ).render('product' => ProductDrop.new)
-    assert_equal '  ', output    
+    assert_equal '  ', output
   end
-  
+
   def test_scope
-    assert_equal '1', Liquid::Template.parse( '{{ context.scopes }}'  ).render('context' => ContextDrop.new)    
+    assert_equal '1', Liquid::Template.parse( '{{ context.scopes }}'  ).render('context' => ContextDrop.new)
     assert_equal '2', Liquid::Template.parse( '{%for i in dummy%}{{ context.scopes }}{%endfor%}'  ).render('context' => ContextDrop.new, 'dummy' => [1])
     assert_equal '3', Liquid::Template.parse( '{%for i in dummy%}{%for i in dummy%}{{ context.scopes }}{%endfor%}{%endfor%}'  ).render('context' => ContextDrop.new, 'dummy' => [1])
   end
-  
+
   def test_scope_though_proc
-    assert_equal '1', Liquid::Template.parse( '{{ s }}'  ).render('context' => ContextDrop.new, 's' => Proc.new{|c| c['context.scopes'] })    
+    assert_equal '1', Liquid::Template.parse( '{{ s }}'  ).render('context' => ContextDrop.new, 's' => Proc.new{|c| c['context.scopes'] })
     assert_equal '2', Liquid::Template.parse( '{%for i in dummy%}{{ s }}{%endfor%}'  ).render('context' => ContextDrop.new, 's' => Proc.new{|c| c['context.scopes'] }, 'dummy' => [1])
     assert_equal '3', Liquid::Template.parse( '{%for i in dummy%}{%for i in dummy%}{{ s }}{%endfor%}{%endfor%}'  ).render('context' => ContextDrop.new, 's' => Proc.new{|c| c['context.scopes'] }, 'dummy' => [1])
   end
-  
+
   def test_scope_with_assigns
-    assert_equal 'variable', Liquid::Template.parse( '{% assign a = "variable"%}{{a}}'  ).render('context' => ContextDrop.new)    
-    assert_equal 'variable', Liquid::Template.parse( '{% assign a = "variable"%}{%for i in dummy%}{{a}}{%endfor%}'  ).render('context' => ContextDrop.new, 'dummy' => [1])    
-    assert_equal 'test', Liquid::Template.parse( '{% assign header_gif = "test"%}{{header_gif}}'  ).render('context' => ContextDrop.new)    
-    assert_equal 'test', Liquid::Template.parse( "{% assign header_gif = 'test'%}{{header_gif}}"  ).render('context' => ContextDrop.new)    
+    assert_equal 'variable', Liquid::Template.parse( '{% assign a = "variable"%}{{a}}'  ).render('context' => ContextDrop.new)
+    assert_equal 'variable', Liquid::Template.parse( '{% assign a = "variable"%}{%for i in dummy%}{{a}}{%endfor%}'  ).render('context' => ContextDrop.new, 'dummy' => [1])
+    assert_equal 'test', Liquid::Template.parse( '{% assign header_gif = "test"%}{{header_gif}}'  ).render('context' => ContextDrop.new)
+    assert_equal 'test', Liquid::Template.parse( "{% assign header_gif = 'test'%}{{header_gif}}"  ).render('context' => ContextDrop.new)
   end
-    
+
   def test_scope_from_tags
-    assert_equal '1', Liquid::Template.parse( '{% for i in context.scopes_as_array %}{{i}}{% endfor %}'  ).render('context' => ContextDrop.new, 'dummy' => [1])    
-    assert_equal '12', Liquid::Template.parse( '{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}'  ).render('context' => ContextDrop.new, 'dummy' => [1])    
-    assert_equal '123', Liquid::Template.parse( '{%for a in dummy%}{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}{% endfor %}'  ).render('context' => ContextDrop.new, 'dummy' => [1])                
+    assert_equal '1', Liquid::Template.parse( '{% for i in context.scopes_as_array %}{{i}}{% endfor %}'  ).render('context' => ContextDrop.new, 'dummy' => [1])
+    assert_equal '12', Liquid::Template.parse( '{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}'  ).render('context' => ContextDrop.new, 'dummy' => [1])
+    assert_equal '123', Liquid::Template.parse( '{%for a in dummy%}{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}{% endfor %}'  ).render('context' => ContextDrop.new, 'dummy' => [1])
   end
-  
+
   def test_access_context_from_drop
-    assert_equal '123', Liquid::Template.parse( '{%for a in dummy%}{{ context.loop_pos }}{% endfor %}'  ).render('context' => ContextDrop.new, 'dummy' => [1,2,3])            
-  end             
-  
-  def test_enumerable_drop         
+    assert_equal '123', Liquid::Template.parse( '{%for a in dummy%}{{ context.loop_pos }}{% endfor %}'  ).render('context' => ContextDrop.new, 'dummy' => [1,2,3])
+  end
+
+  def test_enumerable_drop
     assert_equal '123', Liquid::Template.parse( '{% for c in collection %}{{c}}{% endfor %}').render('collection' => EnumerableDrop.new)
   end
 
-  def test_enumerable_drop_size         
+  def test_enumerable_drop_size
     assert_equal '3', Liquid::Template.parse( '{{collection.size}}').render('collection' => EnumerableDrop.new)
   end
-  
-  
-  
-end
-
-
+end # DropsTest

test/lib/liquid/error_handling_test.rb

@@ -1,89 +1,69 @@
-
-#!/usr/bin/env ruby
-require File.dirname(__FILE__) + '/helper'
+require 'test_helper'
 
 class ErrorDrop < Liquid::Drop
   def standard_error
     raise Liquid::StandardError, 'standard error'
-  end  
+  end
 
   def argument_error
     raise Liquid::ArgumentError, 'argument error'
-  end  
-  
+  end
+
   def syntax_error
     raise Liquid::SyntaxError, 'syntax error'
-  end  
-  
-end
+  end
 
+end
 
 class ErrorHandlingTest < Test::Unit::TestCase
   include Liquid
-  
+
   def test_standard_error
-    assert_nothing_raised do 
+    assert_nothing_raised do
       template = Liquid::Template.parse( ' {{ errors.standard_error }} '  )
       assert_equal ' Liquid error: standard error ', template.render('errors' => ErrorDrop.new)
-      
+
       assert_equal 1, template.errors.size
       assert_equal StandardError, template.errors.first.class
     end
   end
-  
-  def test_syntax    
 
-    assert_nothing_raised do 
-    
+  def test_syntax
+
+    assert_nothing_raised do
+
       template = Liquid::Template.parse( ' {{ errors.syntax_error }} '  )
       assert_equal ' Liquid syntax error: syntax error ', template.render('errors' => ErrorDrop.new)
-      
+
       assert_equal 1, template.errors.size
       assert_equal SyntaxError, template.errors.first.class
-      
-    end
-    
-  end
-  
-  def test_argument
 
-    assert_nothing_raised do 
-    
+    end
+  end
+
+  def test_argument
+    assert_nothing_raised do
+
       template = Liquid::Template.parse( ' {{ errors.argument_error }} '  )
       assert_equal ' Liquid error: argument error ', template.render('errors' => ErrorDrop.new)
-      
+
       assert_equal 1, template.errors.size
       assert_equal ArgumentError, template.errors.first.class
-      
     end
-    
-  end            
-  
-  def test_missing_endtag_parse_time_error
-    
-    assert_raise(Liquid::SyntaxError) do
-      
-      template = Liquid::Template.parse(' {% for a in b %} ... ')
-      
-    end
-    
   end
-  
-  
+
+  def test_missing_endtag_parse_time_error
+    assert_raise(Liquid::SyntaxError) do
+      template = Liquid::Template.parse(' {% for a in b %} ... ')
+    end
+  end
+
   def test_unrecognized_operator
-    
     assert_nothing_raised do
-      
       template = Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ')
       assert_equal ' Liquid error: Unknown operator =! ', template.render
-      
       assert_equal 1, template.errors.size
       assert_equal Liquid::ArgumentError, template.errors.first.class
-      
     end
-    
   end
-  
-end
-
-
+end # ErrorHandlingTest

test/lib/liquid/file_system_test.rb

@@ -1,18 +1,17 @@
-#!/usr/bin/env ruby
-require File.dirname(__FILE__) + '/helper'
+require 'test_helper'
 
 class FileSystemTest < Test::Unit::TestCase
   include Liquid
-  
+
   def test_default
     assert_raise(FileSystemError) do
       BlankFileSystem.new.read_template_file("dummy")
     end
   end
-  
+
   def test_local
     file_system = Liquid::LocalFileSystem.new("/some/path")
-    assert_equal "/some/path/_mypartial.liquid"    , file_system.full_path("mypartial")   
+    assert_equal "/some/path/_mypartial.liquid"    , file_system.full_path("mypartial")
     assert_equal "/some/path/dir/_mypartial.liquid", file_system.full_path("dir/mypartial")
 
     assert_raise(FileSystemError) do
@@ -20,11 +19,11 @@ class FileSystemTest < Test::Unit::TestCase
     end
 
     assert_raise(FileSystemError) do
-      file_system.full_path("/dir/../../dir/mypartial")      
+      file_system.full_path("/dir/../../dir/mypartial")
     end
 
     assert_raise(FileSystemError) do
       file_system.full_path("/etc/passwd")
     end
   end
-end
+end # FileSystemTest

test/lib/liquid/filter_test.rb

@@ -1,5 +1,4 @@
-#!/usr/bin/env ruby
-require File.dirname(__FILE__) + '/helper'
+require 'test_helper'
 
 module MoneyFilter
   def money(input)
@@ -27,6 +26,7 @@ class FiltersTest < Test::Unit::TestCase
   def test_local_filter
     @context['var'] = 1000
     @context.add_filters(MoneyFilter)
+
     assert_equal ' 1000$ ', Variable.new("var | money").render(@context)
   end
 
@@ -40,17 +40,20 @@ class FiltersTest < Test::Unit::TestCase
     @context['var'] = 1000
     @context.add_filters(MoneyFilter)
     @context.add_filters(CanadianMoneyFilter)
+
     assert_equal ' 1000$ CAD ', Variable.new("var | money").render(@context)
   end
 
   def test_size
     @context['var'] = 'abcd'
     @context.add_filters(MoneyFilter)
+
     assert_equal 4, Variable.new("var | size").render(@context)
   end
 
   def test_join
     @context['var'] = [1,2,3,4]
+
     assert_equal "1 2 3 4", Variable.new("var | join").render(@context)
   end
 
@@ -59,22 +62,30 @@ class FiltersTest < Test::Unit::TestCase
     @context['numbers'] = [2,1,4,3]
     @context['words'] = ['expected', 'as', 'alphabetic']
     @context['arrays'] = [['flattened'], ['are']]
+
     assert_equal [1,2,3,4], Variable.new("numbers | sort").render(@context)
-    assert_equal ['alphabetic', 'as', 'expected'],
-      Variable.new("words | sort").render(@context)
+    assert_equal ['alphabetic', 'as', 'expected'], Variable.new("words | sort").render(@context)
     assert_equal [3], Variable.new("value | sort").render(@context)
     assert_equal ['are', 'flattened'], Variable.new("arrays | sort").render(@context)
   end
 
   def test_strip_html
     @context['var'] = "<b>bla blub</a>"
+
     assert_equal "bla blub", Variable.new("var | strip_html").render(@context)
   end
 
   def test_capitalize
     @context['var'] = "blub"
+
     assert_equal "Blub", Variable.new("var | capitalize").render(@context)
   end
+
+  def test_nonexistent_filter_is_ignored
+    @context['var'] = 1000
+
+    assert_equal 1000, Variable.new("var | xyzzy").render(@context)
+  end
 end
 
 class FiltersInTemplate < Test::Unit::TestCase
@@ -92,4 +103,4 @@ class FiltersInTemplate < Test::Unit::TestCase
     assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render(nil, CanadianMoneyFilter)
     assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render(nil, [CanadianMoneyFilter])
   end
-end
+end # FiltersTest

test/lib/liquid/html_tag_test.rb

@@ -1,31 +1,29 @@
-require File.dirname(__FILE__) + '/helper'
+require 'test_helper'
 
 class HtmlTagTest < Test::Unit::TestCase
   include Liquid
-  
+
   def test_html_table
-    
+
     assert_template_result("<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td><td class=\"col3\"> 3 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 4 </td><td class=\"col2\"> 5 </td><td class=\"col3\"> 6 </td></tr>\n",
-                           '{% tablerow n in numbers cols:3%} {{n}} {% endtablerow %}', 
+                           '{% tablerow n in numbers cols:3%} {{n}} {% endtablerow %}',
                            'numbers' => [1,2,3,4,5,6])
 
     assert_template_result("<tr class=\"row1\">\n</tr>\n",
-                            '{% tablerow n in numbers cols:3%} {{n}} {% endtablerow %}', 
-                            'numbers' => [])
+                           '{% tablerow n in numbers cols:3%} {{n}} {% endtablerow %}',
+                           'numbers' => [])
   end
-  
+
   def test_html_table_with_different_cols
     assert_template_result("<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td><td class=\"col3\"> 3 </td><td class=\"col4\"> 4 </td><td class=\"col5\"> 5 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 6 </td></tr>\n",
-                           '{% tablerow n in numbers cols:5%} {{n}} {% endtablerow %}', 
+                           '{% tablerow n in numbers cols:5%} {{n}} {% endtablerow %}',
                            'numbers' => [1,2,3,4,5,6])
-    
+
   end
-  
+
   def test_html_col_counter
     assert_template_result("<tr class=\"row1\">\n<td class=\"col1\">1</td><td class=\"col2\">2</td></tr>\n<tr class=\"row2\"><td class=\"col1\">1</td><td class=\"col2\">2</td></tr>\n<tr class=\"row3\"><td class=\"col1\">1</td><td class=\"col2\">2</td></tr>\n",
-                           '{% tablerow n in numbers cols:2%}{{tablerowloop.col}}{% endtablerow %}', 
+                           '{% tablerow n in numbers cols:2%}{{tablerowloop.col}}{% endtablerow %}',
                            'numbers' => [1,2,3,4,5,6])
-    
   end
-  
-end
+end # HtmlTagTest

test/lib/liquid/include_tag_test.rb

@@ -0,0 +1,127 @@
+require 'test_helper'
+
+class TestFileSystem
+  def read_template_file(template_path)
+    case template_path
+    when "product"
+      "Product: {{ product.title }} "
+
+    when "locale_variables"
+      "Locale: {{echo1}} {{echo2}}"
+
+    when "variant"
+      "Variant: {{ variant.title }}"
+
+    when "nested_template"
+      "{% include 'header' %} {% include 'body' %} {% include 'footer' %}"
+
+    when "body"
+      "body {% include 'body_detail' %}"
+
+    when "nested_product_template"
+      "Product: {{ nested_product_template.title }} {%include 'details'%} "
+
+    when "recursively_nested_template"
+      "-{% include 'recursively_nested_template' %}"
+
+    when "pick_a_source"
+      "from TestFileSystem"
+
+    else
+      template_path
+    end
+  end
+end
+
+class OtherFileSystem
+  def read_template_file(template_path)
+    'from OtherFileSystem'
+  end
+end
+
+class IncludeTagTest < Test::Unit::TestCase
+  include Liquid
+
+  def setup
+    Liquid::Template.file_system = TestFileSystem.new
+  end
+
+  def test_include_tag_looks_for_file_system_in_registers_first
+    assert_equal 'from OtherFileSystem',
+      Template.parse("{% include 'pick_a_source' %}").render({}, :registers => {:file_system => OtherFileSystem.new})
+  end
+
+
+  def test_include_tag_with
+    assert_equal "Product: Draft 151cm ",
+      Template.parse("{% include 'product' with products[0] %}").render( "products" => [ {'title' => 'Draft 151cm'}, {'title' => 'Element 155cm'} ]  )
+  end
+
+  def test_include_tag_with_default_name
+    assert_equal "Product: Draft 151cm ",
+      Template.parse("{% include 'product' %}").render( "product" => {'title' => 'Draft 151cm'}  )
+  end
+
+  def test_include_tag_for
+
+    assert_equal "Product: Draft 151cm Product: Element 155cm ",
+      Template.parse("{% include 'product' for products %}").render( "products" => [ {'title' => 'Draft 151cm'}, {'title' => 'Element 155cm'} ]  )
+  end
+
+  def test_include_tag_with_local_variables
+    assert_equal "Locale: test123 ",
+      Template.parse("{% include 'locale_variables' echo1: 'test123' %}").render
+  end
+
+  def test_include_tag_with_multiple_local_variables
+    assert_equal "Locale: test123 test321",
+      Template.parse("{% include 'locale_variables' echo1: 'test123', echo2: 'test321' %}").render
+  end
+
+  def test_include_tag_with_multiple_local_variables_from_context
+    assert_equal "Locale: test123 test321",
+      Template.parse("{% include 'locale_variables' echo1: echo1, echo2: more_echos.echo2 %}").render('echo1' => 'test123', 'more_echos' => { "echo2" => 'test321'})
+  end
+
+  def test_nested_include_tag
+    assert_equal "body body_detail",
+      Template.parse("{% include 'body' %}").render
+
+    assert_equal "header body body_detail footer",
+      Template.parse("{% include 'nested_template' %}").render
+  end
+
+  def test_nested_include_with_variable
+
+    assert_equal "Product: Draft 151cm details ",
+      Template.parse("{% include 'nested_product_template' with product %}").render("product" => {"title" => 'Draft 151cm'})
+
+    assert_equal "Product: Draft 151cm details Product: Element 155cm details ",
+      Template.parse("{% include 'nested_product_template' for products %}").render("products" => [{"title" => 'Draft 151cm'}, {"title" => 'Element 155cm'}])
+
+  end
+
+  def test_recursively_included_template_does_not_produce_endless_loop
+
+    infinite_file_system = Class.new do
+      def read_template_file(template_path)
+        "-{% include 'loop' %}"
+      end
+    end
+
+    Liquid::Template.file_system = infinite_file_system.new
+
+    assert_raise(Liquid::StackLevelError) do
+      Template.parse("{% include 'loop' %}").render!
+    end
+
+  end
+
+  def test_dynamically_choosen_template
+
+    assert_equal "Test123", Template.parse("{% include template %}").render("template" => 'Test123')
+    assert_equal "Test321", Template.parse("{% include template %}").render("template" => 'Test321')
+
+    assert_equal "Product: Draft 151cm ", Template.parse("{% include template for product %}").render("template" => 'product', 'product' => { 'title' => 'Draft 151cm'})
+  end
+end # IncludeTagTest

test/lib/liquid/module_ex_test.rb

@@ -1,5 +1,4 @@
-#!/usr/bin/env ruby
-require File.dirname(__FILE__) + '/helper'
+require 'test_helper'
 
 class TestClassA
   liquid_methods :allowedA, :chainedB
@@ -39,31 +38,31 @@ end
 
 class ModuleExTest < Test::Unit::TestCase
   include Liquid
-  
+
   def setup
     @a = TestClassA.new
     @b = TestClassB.new
     @c = TestClassC.new
   end
-  
+
   def test_should_create_LiquidDropClass
     assert TestClassA::LiquidDropClass
     assert TestClassB::LiquidDropClass
     assert TestClassC::LiquidDropClass
   end
-  
+
   def test_should_respond_to_liquid
     assert @a.respond_to?(:to_liquid)
     assert @b.respond_to?(:to_liquid)
     assert @c.respond_to?(:to_liquid)
   end
-  
+
   def test_should_return_LiquidDropClass_object
     assert @a.to_liquid.is_a?(TestClassA::LiquidDropClass)
     assert @b.to_liquid.is_a?(TestClassB::LiquidDropClass)
     assert @c.to_liquid.is_a?(TestClassC::LiquidDropClass)
   end
-  
+
   def test_should_respond_to_liquid_methods
     assert @a.to_liquid.respond_to?(:allowedA)
     assert @a.to_liquid.respond_to?(:chainedB)
@@ -84,6 +83,5 @@ class ModuleExTest < Test::Unit::TestCase
     assert_equal 'another_allowedC', Liquid::Template.parse("{{ a.chainedB.chainedC.another_allowedC }}").render('a'=>@a)
     assert_equal '', Liquid::Template.parse("{{ a.restricted }}").render('a'=>@a)
     assert_equal '', Liquid::Template.parse("{{ a.unknown }}").render('a'=>@a)
- end
-
-end
+  end
+end # ModuleExTest

test/lib/liquid/output_test.rb

@@ -1,20 +1,18 @@
-#!/usr/bin/env ruby
-require File.dirname(__FILE__) + '/helper'
+require 'test_helper'
 
 module FunnyFilter
-  
   def make_funny(input)
-    'LOL'             
+    'LOL'
   end
 
   def cite_funny(input)
     "LOL: #{input}"
-  end             
+  end
 
   def add_smiley(input, smiley = ":-)")
     "#{input} #{smiley}"
   end
-  
+
   def add_tag(input, tag = "p", id = "foo")
     %|<#{tag} id="#{id}">#{input}</#{tag}>|
   end
@@ -22,25 +20,24 @@ module FunnyFilter
   def paragraph(input)
     "<p>#{input}</p>"
   end
-  
+
   def link_to(name, url)
     %|<a href="#{url}">#{name}</a>|
   end
-end                 
 
+end
 
 class OutputTest < Test::Unit::TestCase
   include Liquid
 
   def setup
-    @assigns = {     
+    @assigns = {
       'best_cars' => 'bmw',
       'car' => {'bmw' => 'good', 'gm' => 'bad'}
       }
-
   end
 
-  def test_variable  
+  def test_variable
     text = %| {{best_cars}} |
 
     expected = %| bmw |
@@ -53,35 +50,35 @@ class OutputTest < Test::Unit::TestCase
     expected = %| good bad good |
     assert_equal expected, Template.parse(text).render(@assigns)
   end               
-  
+
   def test_variable_piping
     text = %( {{ car.gm | make_funny }} )
-    expected = %| LOL |               
-    
+    expected = %| LOL |
+
     assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
   end
 
   def test_variable_piping_with_input
     text = %( {{ car.gm | cite_funny }} )
-    expected = %| LOL: bad |               
+    expected = %| LOL: bad |
 
     assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
   end
-  
+
   def test_variable_piping_with_args
     text = %! {{ car.gm | add_smiley : ':-(' }} !
     expected = %| bad :-( |
 
     assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
   end
-  
+
   def test_variable_piping_with_no_args
     text = %! {{ car.gm | add_smiley }} !
     expected = %| bad :-) |
 
     assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
   end
-  
+
   def test_multiple_variable_piping_with_args
     text = %! {{ car.gm | add_smiley : ':-(' | add_smiley : ':-('}} !
     expected = %| bad :-( :-( |
@@ -105,17 +102,15 @@ class OutputTest < Test::Unit::TestCase
 
   def test_multiple_pipings
     text = %( {{ best_cars | cite_funny | paragraph }} )
-    expected = %| <p>LOL: bmw</p> |               
+    expected = %| <p>LOL: bmw</p> |
 
     assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
   end
-  
+
   def test_link_to
     text = %( {{ 'Typo' | link_to: 'http://typo.leetsoft.com' }} )
-    expected = %| <a href="http://typo.leetsoft.com">Typo</a> |               
+    expected = %| <a href="http://typo.leetsoft.com">Typo</a> |
 
-    assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])    
+    assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
   end
-  
-
-end 
+end # OutputTest

test/lib/liquid/parsing_quirks_test.rb

@@ -1,5 +1,4 @@
-#!/usr/bin/env ruby
-require File.dirname(__FILE__) + '/helper'
+require 'test_helper'
 
 class ParsingQuirksTest < Test::Unit::TestCase
   include Liquid
@@ -7,48 +6,47 @@ class ParsingQuirksTest < Test::Unit::TestCase
   def test_error_with_css
     text = %| div { font-weight: bold; } |
     template = Template.parse(text)
-                                                    
+
     assert_equal text, template.render
     assert_equal [String], template.root.nodelist.collect {|i| i.class}
   end
-  
+
   def test_raise_on_single_close_bracet
     assert_raise(SyntaxError) do
-      Template.parse("text {{method} oh nos!")      
+      Template.parse("text {{method} oh nos!")
     end
   end
-  
+
   def test_raise_on_label_and_no_close_bracets
     assert_raise(SyntaxError) do
       Template.parse("TEST {{ ")
     end
-  end    
-  
+  end
+
   def test_raise_on_label_and_no_close_bracets_percent
     assert_raise(SyntaxError) do
       Template.parse("TEST {% ")
     end
   end
-  
+
   def test_error_on_empty_filter
     assert_nothing_raised do
-      Template.parse("{{test |a|b|}}")      
-      Template.parse("{{test}}")      
-      Template.parse("{{|test|}}")      
+      Template.parse("{{test |a|b|}}")
+      Template.parse("{{test}}")
+      Template.parse("{{|test|}}")
     end
   end
-  
+
   def test_meaningless_parens
     assigns = {'b' => 'bar', 'c' => 'baz'}
     markup = "a == 'foo' or (b == 'bar' and c == 'baz') or false"
     assert_template_result(' YES ',"{% if #{markup} %} YES {% endif %}", assigns)
   end
-  
+
   def test_unexpected_characters_silently_eat_logic
     markup = "true && false"
     assert_template_result(' YES ',"{% if #{markup} %} YES {% endif %}")
     markup = "false || true"
     assert_template_result('',"{% if #{markup} %} YES {% endif %}")
   end
-  
-end
+end # ParsingQuirksTest

test/lib/liquid/regexp_test.rb

@@ -1,20 +1,20 @@
-require File.dirname(__FILE__) + '/helper'
-   
+require 'test_helper'
+
 class RegexpTest < Test::Unit::TestCase
   include Liquid
 
   def test_empty
     assert_equal [], ''.scan(QuotedFragment)
   end
-  
+
   def test_quote
     assert_equal ['"arg 1"'], '"arg 1"'.scan(QuotedFragment)
   end
-  
+
   def test_words
     assert_equal ['arg1', 'arg2'], 'arg1 arg2'.scan(QuotedFragment)
   end
-  
+
   def test_tags
     assert_equal ['<tr>', '</tr>'], '<tr> </tr>'.scan(QuotedFragment)
     assert_equal ['<tr></tr>'], '<tr></tr>'.scan(QuotedFragment)
@@ -32,14 +32,13 @@ class RegexpTest < Test::Unit::TestCase
   def test_quoted_words_in_the_middle
     assert_equal ['arg1', 'arg2', '"arg 3"', 'arg4'], 'arg1 arg2 "arg 3" arg4   '.scan(QuotedFragment)
   end
-  
+
   def test_variable_parser
-    assert_equal ['var'],                 'var'.scan(VariableParser)
-    assert_equal ['var', 'method'],       'var.method'.scan(VariableParser)
-    assert_equal ['var', '[method]'],       'var[method]'.scan(VariableParser)
-    assert_equal ['var', '[method]', '[0]'],  'var[method][0]'.scan(VariableParser)
-    assert_equal ['var', '["method"]', '[0]'],  'var["method"][0]'.scan(VariableParser)
-    assert_equal ['var', '[method]', '[0]', 'method'],  'var[method][0].method'.scan(VariableParser)    
+    assert_equal ['var'],                               'var'.scan(VariableParser)
+    assert_equal ['var', 'method'],                     'var.method'.scan(VariableParser)
+    assert_equal ['var', '[method]'],                   'var[method]'.scan(VariableParser)
+    assert_equal ['var', '[method]', '[0]'],            'var[method][0]'.scan(VariableParser)
+    assert_equal ['var', '["method"]', '[0]'],          'var["method"][0]'.scan(VariableParser)
+    assert_equal ['var', '[method]', '[0]', 'method'],  'var[method][0].method'.scan(VariableParser)
   end
- 
-end
+end # RegexpTest

test/lib/liquid/security_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/helper'
+require 'test_helper'
 
 module SecurityFilter
   def add_one(input)
@@ -12,22 +12,22 @@ class SecurityTest < Test::Unit::TestCase
   def test_no_instance_eval
     text = %( {{ '1+1' | instance_eval }} )
     expected = %| 1+1 |
-        
+
     assert_equal expected, Template.parse(text).render(@assigns)
   end
-  
+
   def test_no_existing_instance_eval
     text = %( {{ '1+1' | __instance_eval__ }} )
     expected = %| 1+1 |
-        
+
     assert_equal expected, Template.parse(text).render(@assigns)
   end
-  
+
 
   def test_no_instance_eval_after_mixing_in_new_filter
     text = %( {{ '1+1' | instance_eval }} )
     expected = %| 1+1 |
-  
+
     assert_equal expected, Template.parse(text).render(@assigns)
   end
 
@@ -35,7 +35,7 @@ class SecurityTest < Test::Unit::TestCase
   def test_no_instance_eval_later_in_chain
     text = %( {{ '1+1' | add_one | instance_eval }} )
     expected = %| 1+1 + 1 |
-  
+
     assert_equal expected, Template.parse(text).render(@assigns, :filters => SecurityFilter)
   end
-end
+end # SecurityTest

test/lib/liquid/standard_filter_test.rb

@@ -1,175 +1,180 @@
-#!/usr/bin/env ruby
-require File.dirname(__FILE__) + '/helper'
-
+require 'test_helper'
 
 class Filters
   include Liquid::StandardFilters
 end
 
-
 class StandardFiltersTest < Test::Unit::TestCase
   include Liquid
-  
+
   def setup
     @filters = Filters.new
   end
-  
+
   def test_size
     assert_equal 3, @filters.size([1,2,3])
     assert_equal 0, @filters.size([])
     assert_equal 0, @filters.size(nil)
   end
-  
+
   def test_downcase
     assert_equal 'testing', @filters.downcase("Testing")
     assert_equal '', @filters.downcase(nil)
   end
-  
+
   def test_upcase
     assert_equal 'TESTING', @filters.upcase("Testing")
     assert_equal '', @filters.upcase(nil)
   end
-  
+
   def test_upcase
     assert_equal 'TESTING', @filters.upcase("Testing")
     assert_equal '', @filters.upcase(nil)
   end
-  
+
   def test_truncate
     assert_equal '1234...', @filters.truncate('1234567890', 7)
     assert_equal '1234567890', @filters.truncate('1234567890', 20)
     assert_equal '...', @filters.truncate('1234567890', 0)
     assert_equal '1234567890', @filters.truncate('1234567890')
   end
-  
+
   def test_escape
     assert_equal '&lt;strong&gt;', @filters.escape('<strong>')
-    assert_equal '&lt;strong&gt;', @filters.h('<strong>')    
+    assert_equal '&lt;strong&gt;', @filters.h('<strong>')
   end
-  
+
+  def test_escape_once
+    assert_equal '&lt;strong&gt;', @filters.escape_once(@filters.escape('<strong>'))
+  end
+
   def test_truncatewords
     assert_equal 'one two three', @filters.truncatewords('one two three', 4)
     assert_equal 'one two...', @filters.truncatewords('one two three', 2)
     assert_equal 'one two three', @filters.truncatewords('one two three')
-    assert_equal 'Two small (13&#8221; x 5.5&#8221; x 10&#8221; high) baskets fit inside one large basket (13&#8221;...', @filters.truncatewords('Two small (13&#8221; x 5.5&#8221; x 10&#8221; high) baskets fit inside one large basket (13&#8221; x 16&#8221; x 10.5&#8221; high) with cover.', 15)    
+    assert_equal 'Two small (13&#8221; x 5.5&#8221; x 10&#8221; high) baskets fit inside one large basket (13&#8221;...', @filters.truncatewords('Two small (13&#8221; x 5.5&#8221; x 10&#8221; high) baskets fit inside one large basket (13&#8221; x 16&#8221; x 10.5&#8221; high) with cover.', 15)
   end
-  
+
   def test_strip_html
-    assert_equal 'test', @filters.strip_html("<div>test</div>")    
-    assert_equal 'test', @filters.strip_html("<div id='test'>test</div>")    
-    assert_equal '', @filters.strip_html("<script type='text/javascript'>document.write('some stuff');</script>")    
-    assert_equal '', @filters.strip_html(nil)    
+    assert_equal 'test', @filters.strip_html("<div>test</div>")
+    assert_equal 'test', @filters.strip_html("<div id='test'>test</div>")
+    assert_equal '', @filters.strip_html("<script type='text/javascript'>document.write('some stuff');</script>")
+    assert_equal '', @filters.strip_html(nil)
   end
-  
+
   def test_join
-    assert_equal '1 2 3 4', @filters.join([1,2,3,4])    
-    assert_equal '1 - 2 - 3 - 4', @filters.join([1,2,3,4], ' - ')    
+    assert_equal '1 2 3 4', @filters.join([1,2,3,4])
+    assert_equal '1 - 2 - 3 - 4', @filters.join([1,2,3,4], ' - ')
   end
-  
+
   def test_sort
-    assert_equal [1,2,3,4], @filters.sort([4,3,2,1])    
+    assert_equal [1,2,3,4], @filters.sort([4,3,2,1])
     assert_equal [{"a" => 1}, {"a" => 2}, {"a" => 3}, {"a" => 4}], @filters.sort([{"a" => 4}, {"a" => 3}, {"a" => 1}, {"a" => 2}], "a")
   end
-  
+
   def test_map
     assert_equal [1,2,3,4], @filters.map([{"a" => 1}, {"a" => 2}, {"a" => 3}, {"a" => 4}], 'a')
     assert_template_result 'abc', "{{ ary | map:'foo' | map:'bar' }}",
       'ary' => [{'foo' => {'bar' => 'a'}}, {'foo' => {'bar' => 'b'}}, {'foo' => {'bar' => 'c'}}]
   end
-  
+
   def test_date
-    assert_equal 'May', @filters.date(Time.parse("2006-05-05 10:00:00"), "%B")    
-    assert_equal 'June', @filters.date(Time.parse("2006-06-05 10:00:00"), "%B")    
-    assert_equal 'July', @filters.date(Time.parse("2006-07-05 10:00:00"), "%B")    
+    assert_equal 'May', @filters.date(Time.parse("2006-05-05 10:00:00"), "%B")
+    assert_equal 'June', @filters.date(Time.parse("2006-06-05 10:00:00"), "%B")
+    assert_equal 'July', @filters.date(Time.parse("2006-07-05 10:00:00"), "%B")
 
-    assert_equal 'May', @filters.date("2006-05-05 10:00:00", "%B")    
-    assert_equal 'June', @filters.date("2006-06-05 10:00:00", "%B")    
-    assert_equal 'July', @filters.date("2006-07-05 10:00:00", "%B")    
+    assert_equal 'May', @filters.date("2006-05-05 10:00:00", "%B")
+    assert_equal 'June', @filters.date("2006-06-05 10:00:00", "%B")
+    assert_equal 'July', @filters.date("2006-07-05 10:00:00", "%B")
 
-    assert_equal '2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", "")    
-    assert_equal '2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", "")    
-    assert_equal '2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", "")    
-    assert_equal '2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", nil)    
+    assert_equal '2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", "")
+    assert_equal '2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", "")
+    assert_equal '2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", "")
+    assert_equal '2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", nil)
+
+    assert_equal '07/05/2006', @filters.date("2006-07-05 10:00:00", "%m/%d/%Y")
 
-    assert_equal '07/05/2006', @filters.date("2006-07-05 10:00:00", "%m/%d/%Y")    
-    
     assert_equal "07/16/2004", @filters.date("Fri Jul 16 01:00:00 2004", "%m/%d/%Y")
-    
-    assert_equal nil, @filters.date(nil, "%B")    
+
+    assert_equal nil, @filters.date(nil, "%B")
   end
-  
-  
+
+
   def test_first_last
-    assert_equal 1, @filters.first([1,2,3])    
-    assert_equal 3, @filters.last([1,2,3])    
-    assert_equal nil, @filters.first([])    
-    assert_equal nil, @filters.last([])    
+    assert_equal 1, @filters.first([1,2,3])
+    assert_equal 3, @filters.last([1,2,3])
+    assert_equal nil, @filters.first([])
+    assert_equal nil, @filters.last([])
   end
-  
+
   def test_replace
-    assert_equal 'b b b b', @filters.replace("a a a a", 'a', 'b')    
+    assert_equal 'b b b b', @filters.replace("a a a a", 'a', 'b')
     assert_equal 'b a a a', @filters.replace_first("a a a a", 'a', 'b')
-    assert_template_result 'b a a a', "{{ 'a a a a' | replace_first: 'a', 'b' }}"        
+    assert_template_result 'b a a a', "{{ 'a a a a' | replace_first: 'a', 'b' }}"
   end
-  
+
   def test_remove
-    assert_equal '   ', @filters.remove("a a a a", 'a')    
-    assert_equal 'a a a', @filters.remove_first("a a a a", 'a ')        
+    assert_equal '   ', @filters.remove("a a a a", 'a')
+    assert_equal 'a a a', @filters.remove_first("a a a a", 'a ')
     assert_template_result 'a a a', "{{ 'a a a a' | remove_first: 'a ' }}"
   end
-  
-  def test_pipes_in_string_arguments 
+
+  def test_pipes_in_string_arguments
     assert_template_result 'foobar', "{{ 'foo|bar' | remove: '|' }}"
   end
-                                                                                     
+
   def test_strip_newlines
     assert_template_result 'abc', "{{ source | strip_newlines }}", 'source' => "a\nb\nc"
   end
-  
+
   def test_newlines_to_br
     assert_template_result "a<br />\nb<br />\nc", "{{ source | newline_to_br }}", 'source' => "a\nb\nc"
   end
-  
+
   def test_plus
     assert_template_result "2", "{{ 1 | plus:1 }}"
     assert_template_result "2.0", "{{ '1' | plus:'1.0' }}"
   end
-  
+
   def test_minus
     assert_template_result "4", "{{ input | minus:operand }}", 'input' => 5, 'operand' => 1
     assert_template_result "2.3", "{{ '4.3' | minus:'2' }}"
   end
-  
+
   def test_times
     assert_template_result "12", "{{ 3 | times:4 }}"
     assert_template_result "0", "{{ 'foo' | times:4 }}"
-    assert_template_result "6.3", "{{ '2.1' | times:3 }}"
+
+    # Ruby v1.9.2-rc1, or higher, backwards compatible Float test
+    assert_match(/(6\.3)|(6\.(0{13})1)/, Template.parse("{{ '2.1' | times:3 }}").render)
+
     assert_template_result "6", "{{ '2.1' | times:3 | replace: '.','-' | plus:0}}"
-  end    
-  
+  end
+
   def test_divided_by
     assert_template_result "4", "{{ 12 | divided_by:3 }}"
     assert_template_result "4", "{{ 14 | divided_by:3 }}"
-    assert_template_result "4.66666666666667", "{{ 14 | divided_by:'3.0' }}"
+
+    # Ruby v1.9.2-rc1, or higher, backwards compatible Float test
+    assert_match(/4\.(6{13,14})7/, Template.parse("{{ 14 | divided_by:'3.0' }}").render)
+
     assert_template_result "5", "{{ 15 | divided_by:3 }}"
     assert_template_result "Liquid error: divided by 0", "{{ 5 | divided_by:0 }}"
   end
-  
+
   def test_append
     assigns = {'a' => 'bc', 'b' => 'd' }
-    assert_template_result('bcd',"{{ a | append: 'd'}}",assigns)        
-    assert_template_result('bcd',"{{ a | append: b}}",assigns)        
+    assert_template_result('bcd',"{{ a | append: 'd'}}",assigns)
+    assert_template_result('bcd',"{{ a | append: b}}",assigns)
   end
-  
+
   def test_prepend
     assigns = {'a' => 'bc', 'b' => 'a' }
-    assert_template_result('abc',"{{ a | prepend: 'a'}}",assigns)        
-    assert_template_result('abc',"{{ a | prepend: b}}",assigns)        
+    assert_template_result('abc',"{{ a | prepend: 'a'}}",assigns)
+    assert_template_result('abc',"{{ a | prepend: b}}",assigns)
   end
-  
+
   def test_cannot_access_private_methods
     assert_template_result('a',"{{ 'a' | to_number }}")
   end
-  
-end
-
+end # StandardFiltersTest

test/lib/liquid/strainer_test.rb

@@ -1,5 +1,4 @@
-#!/usr/bin/env ruby
-require File.dirname(__FILE__) + '/helper'
+require 'test_helper'
 
 class StrainerTest < Test::Unit::TestCase
   include Liquid
@@ -12,10 +11,15 @@ class StrainerTest < Test::Unit::TestCase
     assert_equal false, strainer.respond_to?('__send__')
     assert_equal true, strainer.respond_to?('size') # from the standard lib
   end
-  
+
   def test_should_respond_to_two_parameters
     strainer = Strainer.create(nil)
     assert_equal true, strainer.respond_to?('size', false)
   end
-  
-end
+
+  # Asserts that Object#respond_to_missing? is not being undefined in Ruby versions where it has been implemented
+  # Currently this method is only present in Ruby v1.9.2, or higher
+  def test_object_respond_to_missing
+    assert_equal Object.respond_to?(:respond_to_missing?), Strainer.create(nil).respond_to?(:respond_to_missing?)
+  end
+end # StrainerTest

test/lib/liquid/tags/if_else_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/helper'
+require 'test_helper'
 
 class IfElseTest < Test::Unit::TestCase
   include Liquid
@@ -6,7 +6,7 @@ class IfElseTest < Test::Unit::TestCase
   def test_if
     assert_template_result('  ',' {% if false %} this text should not go into the output {% endif %} ')
     assert_template_result('  this text should go into the output  ',
-              ' {% if true %} this text should go into the output {% endif %} ')
+                           ' {% if true %} this text should go into the output {% endif %} ')
     assert_template_result('  you rock ?','{% if false %} you suck {% endif %} {% if true %} you rock {% endif %}?')
   end
 
@@ -15,27 +15,27 @@ class IfElseTest < Test::Unit::TestCase
     assert_template_result(' YES ','{% if true %} YES {% else %} NO {% endif %}')
     assert_template_result(' YES ','{% if "foo" %} YES {% else %} NO {% endif %}')
   end
-  
-  def test_if_boolean
-    assert_template_result(' YES ','{% if var %} YES {% endif %}', 'var' => true)    
-  end        
-  
-  def test_if_or
-    assert_template_result(' YES ','{% if a or b %} YES {% endif %}', 'a' => true, 'b' => true)    
-    assert_template_result(' YES ','{% if a or b %} YES {% endif %}', 'a' => true, 'b' => false)    
-    assert_template_result(' YES ','{% if a or b %} YES {% endif %}', 'a' => false, 'b' => true)    
-    assert_template_result('',     '{% if a or b %} YES {% endif %}', 'a' => false, 'b' => false)        
 
-    assert_template_result(' YES ','{% if a or b or c %} YES {% endif %}', 'a' => false, 'b' => false, 'c' => true)    
-    assert_template_result('',     '{% if a or b or c %} YES {% endif %}', 'a' => false, 'b' => false, 'c' => false)        
+  def test_if_boolean
+    assert_template_result(' YES ','{% if var %} YES {% endif %}', 'var' => true)
   end
-  
+
+  def test_if_or
+    assert_template_result(' YES ','{% if a or b %} YES {% endif %}', 'a' => true, 'b' => true)
+    assert_template_result(' YES ','{% if a or b %} YES {% endif %}', 'a' => true, 'b' => false)
+    assert_template_result(' YES ','{% if a or b %} YES {% endif %}', 'a' => false, 'b' => true)
+    assert_template_result('',     '{% if a or b %} YES {% endif %}', 'a' => false, 'b' => false)
+
+    assert_template_result(' YES ','{% if a or b or c %} YES {% endif %}', 'a' => false, 'b' => false, 'c' => true)
+    assert_template_result('',     '{% if a or b or c %} YES {% endif %}', 'a' => false, 'b' => false, 'c' => false)
+  end
+
   def test_if_or_with_operators
-    assert_template_result(' YES ','{% if a == true or b == true %} YES {% endif %}', 'a' => true, 'b' => true)    
-    assert_template_result(' YES ','{% if a == true or b == false %} YES {% endif %}', 'a' => true, 'b' => true)    
-    assert_template_result('','{% if a == false or b == false %} YES {% endif %}', 'a' => true, 'b' => true)    
-  end     
-  
+    assert_template_result(' YES ','{% if a == true or b == true %} YES {% endif %}', 'a' => true, 'b' => true)
+    assert_template_result(' YES ','{% if a == true or b == false %} YES {% endif %}', 'a' => true, 'b' => true)
+    assert_template_result('','{% if a == false or b == false %} YES {% endif %}', 'a' => true, 'b' => true)
+  end
+
   def test_comparison_of_strings_containing_and_or_or
     assert_nothing_raised do
       awful_markup = "a == 'and' and b == 'or' and c == 'foo and bar' and d == 'bar or baz' and e == 'foo' and foo and bar"
@@ -43,7 +43,7 @@ class IfElseTest < Test::Unit::TestCase
       assert_template_result(' YES ',"{% if #{awful_markup} %} YES {% endif %}", assigns)
     end
   end
-  
+
   def test_comparison_of_expressions_starting_with_and_or_or
     assigns = {'order' => {'items_count' => 0}, 'android' => {'name' => 'Roy'}}
     assert_nothing_raised do
@@ -57,18 +57,18 @@ class IfElseTest < Test::Unit::TestCase
                               assigns)
     end
   end
-  
+
   def test_if_and
-    assert_template_result(' YES ','{% if true and true %} YES {% endif %}')    
-    assert_template_result('','{% if false and true %} YES {% endif %}')    
-    assert_template_result('','{% if false and true %} YES {% endif %}')    
+    assert_template_result(' YES ','{% if true and true %} YES {% endif %}')
+    assert_template_result('','{% if false and true %} YES {% endif %}')
+    assert_template_result('','{% if false and true %} YES {% endif %}')
   end
-  
-  
+
+
   def test_hash_miss_generates_false
     assert_template_result('','{% if foo.bar %} NO {% endif %}', 'foo' => {})
   end
-  
+
   def test_if_from_variable
     assert_template_result('','{% if var %} NO {% endif %}', 'var' => false)
     assert_template_result('','{% if var %} NO {% endif %}', 'var' => nil)
@@ -76,7 +76,7 @@ class IfElseTest < Test::Unit::TestCase
     assert_template_result('','{% if foo.bar %} NO {% endif %}', 'foo' => {})
     assert_template_result('','{% if foo.bar %} NO {% endif %}', 'foo' => nil)
     assert_template_result('','{% if foo.bar %} NO {% endif %}', 'foo' => true)
-    
+
     assert_template_result(' YES ','{% if var %} YES {% endif %}', 'var' => "text")
     assert_template_result(' YES ','{% if var %} YES {% endif %}', 'var' => true)
     assert_template_result(' YES ','{% if var %} YES {% endif %}', 'var' => 1)
@@ -88,12 +88,12 @@ class IfElseTest < Test::Unit::TestCase
     assert_template_result(' YES ','{% if foo.bar %} YES {% endif %}', 'foo' => {'bar' => 1 })
     assert_template_result(' YES ','{% if foo.bar %} YES {% endif %}', 'foo' => {'bar' => {} })
     assert_template_result(' YES ','{% if foo.bar %} YES {% endif %}', 'foo' => {'bar' => [] })
-    
+
     assert_template_result(' YES ','{% if var %} NO {% else %} YES {% endif %}', 'var' => false)
     assert_template_result(' YES ','{% if var %} NO {% else %} YES {% endif %}', 'var' => nil)
     assert_template_result(' YES ','{% if var %} YES {% else %} NO {% endif %}', 'var' => true)
     assert_template_result(' YES ','{% if "foo" %} YES {% else %} NO {% endif %}', 'var' => "text")
-    
+
     assert_template_result(' YES ','{% if foo.bar %} NO {% else %} YES {% endif %}', 'foo' => {'bar' => false})
     assert_template_result(' YES ','{% if foo.bar %} YES {% else %} NO {% endif %}', 'foo' => {'bar' => true})
     assert_template_result(' YES ','{% if foo.bar %} YES {% else %} NO {% endif %}', 'foo' => {'bar' => "text"})
@@ -101,19 +101,19 @@ class IfElseTest < Test::Unit::TestCase
     assert_template_result(' YES ','{% if foo.bar %} NO {% else %} YES {% endif %}', 'foo' => {})
     assert_template_result(' YES ','{% if foo.bar %} NO {% else %} YES {% endif %}', 'notfoo' => {'bar' => true})
   end
-  
+
   def test_nested_if
     assert_template_result('', '{% if false %}{% if false %} NO {% endif %}{% endif %}')
     assert_template_result('', '{% if false %}{% if true %} NO {% endif %}{% endif %}')
     assert_template_result('', '{% if true %}{% if false %} NO {% endif %}{% endif %}')
     assert_template_result(' YES ', '{% if true %}{% if true %} YES {% endif %}{% endif %}')
-    
+
     assert_template_result(' YES ', '{% if true %}{% if true %} YES {% else %} NO {% endif %}{% else %} NO {% endif %}')
     assert_template_result(' YES ', '{% if true %}{% if false %} NO {% else %} YES {% endif %}{% else %} NO {% endif %}')
     assert_template_result(' YES ', '{% if false %}{% if true %} NO {% else %} NONO {% endif %}{% else %} YES {% endif %}')
-    
+
   end
-  
+
   def test_comparisons_on_null
     assert_template_result('','{% if null < 10 %} NO {% endif %}')
     assert_template_result('','{% if null <= 10 %} NO {% endif %}')
@@ -125,29 +125,29 @@ class IfElseTest < Test::Unit::TestCase
     assert_template_result('','{% if 10 >= null %} NO {% endif %}')
     assert_template_result('','{% if 10 > null %} NO {% endif %}')
   end
-  
+
   def test_else_if
     assert_template_result('0','{% if 0 == 0 %}0{% elsif 1 == 1%}1{% else %}2{% endif %}')
     assert_template_result('1','{% if 0 != 0 %}0{% elsif 1 == 1%}1{% else %}2{% endif %}')
     assert_template_result('2','{% if 0 != 0 %}0{% elsif 1 != 1%}1{% else %}2{% endif %}')
-    
-    assert_template_result('elsif','{% if false %}if{% elsif true %}elsif{% endif %}')    
+
+    assert_template_result('elsif','{% if false %}if{% elsif true %}elsif{% endif %}')
   end
-  
+
   def test_syntax_error_no_variable
     assert_raise(SyntaxError){ assert_template_result('', '{% if jerry == 1 %}')}
   end
-  
+
   def test_syntax_error_no_expression
     assert_raise(SyntaxError) { assert_template_result('', '{% if %}') }
   end
-  
+
   def test_if_with_custom_condition
     Condition.operators['contains'] = :[]
-    
+
     assert_template_result('yes', %({% if 'bob' contains 'o' %}yes{% endif %}))
     assert_template_result('no', %({% if 'bob' contains 'f' %}yes{% else %}no{% endif %}))
   ensure
     Condition.operators.delete 'contains'
   end
-end
+end # IfElseTest

test/lib/liquid/tags/standard_tag_test.rb

@@ -1,10 +1,8 @@
-require File.dirname(__FILE__) + '/helper'
-
+require 'test_helper'
 
 class StandardTagTest < Test::Unit::TestCase
   include Liquid
 
-
   def test_tag
     tag = Tag.new('tag', [], [])
     assert_equal 'liquid::tag', tag.name
@@ -14,6 +12,7 @@ class StandardTagTest < Test::Unit::TestCase
   def test_no_transform
     assert_template_result('this text should come out of the template without change...',
                            'this text should come out of the template without change...')
+
     assert_template_result('blah','blah')
     assert_template_result('<blah>','<blah>')
     assert_template_result('|,.:','|,.:')
@@ -85,43 +84,48 @@ HERE
 
   def test_for_helpers
     assigns = {'array' => [1,2,3] }
-    assert_template_result(' 1/3  2/3  3/3 ','{%for item in array%} {{forloop.index}}/{{forloop.length}} {%endfor%}',assigns)
-    assert_template_result(' 1  2  3 ','{%for item in array%} {{forloop.index}} {%endfor%}',assigns)
-    assert_template_result(' 0  1  2 ','{%for item in array%} {{forloop.index0}} {%endfor%}',assigns)
-    assert_template_result(' 2  1  0 ','{%for item in array%} {{forloop.rindex0}} {%endfor%}',assigns)
-    assert_template_result(' 3  2  1 ','{%for item in array%} {{forloop.rindex}} {%endfor%}',assigns)
-    assert_template_result(' true  false  false ','{%for item in array%} {{forloop.first}} {%endfor%}',assigns)
-    assert_template_result(' false  false  true ','{%for item in array%} {{forloop.last}} {%endfor%}',assigns)
+    assert_template_result(' 1/3  2/3  3/3 ',
+                           '{%for item in array%} {{forloop.index}}/{{forloop.length}} {%endfor%}',
+                           assigns)
+    assert_template_result(' 1  2  3 ', '{%for item in array%} {{forloop.index}} {%endfor%}', assigns)
+    assert_template_result(' 0  1  2 ', '{%for item in array%} {{forloop.index0}} {%endfor%}', assigns)
+    assert_template_result(' 2  1  0 ', '{%for item in array%} {{forloop.rindex0}} {%endfor%}', assigns)
+    assert_template_result(' 3  2  1 ', '{%for item in array%} {{forloop.rindex}} {%endfor%}', assigns)
+    assert_template_result(' true  false  false ', '{%for item in array%} {{forloop.first}} {%endfor%}', assigns)
+    assert_template_result(' false  false  true ', '{%for item in array%} {{forloop.last}} {%endfor%}', assigns)
   end
 
   def test_for_and_if
     assigns = {'array' => [1,2,3] }
-    assert_template_result('+--', '{%for item in array%}{% if forloop.first %}+{% else %}-{% endif %}{%endfor%}', assigns)
+    assert_template_result('+--',
+                           '{%for item in array%}{% if forloop.first %}+{% else %}-{% endif %}{%endfor%}',
+                           assigns)
   end
 
   def test_limiting
     assigns = {'array' => [1,2,3,4,5,6,7,8,9,0]}
-    assert_template_result('12','{%for i in array limit:2 %}{{ i }}{%endfor%}',assigns)
-    assert_template_result('1234','{%for i in array limit:4 %}{{ i }}{%endfor%}',assigns)
-    assert_template_result('3456','{%for i in array limit:4 offset:2 %}{{ i }}{%endfor%}',assigns)
-    assert_template_result('3456','{%for i in array limit: 4 offset: 2 %}{{ i }}{%endfor%}',assigns)
+    assert_template_result('12', '{%for i in array limit:2 %}{{ i }}{%endfor%}', assigns)
+    assert_template_result('1234', '{%for i in array limit:4 %}{{ i }}{%endfor%}', assigns)
+    assert_template_result('3456', '{%for i in array limit:4 offset:2 %}{{ i }}{%endfor%}', assigns)
+    assert_template_result('3456', '{%for i in array limit: 4 offset: 2 %}{{ i }}{%endfor%}', assigns)
   end
 
   def test_dynamic_variable_limiting
     assigns = {'array' => [1,2,3,4,5,6,7,8,9,0]}
     assigns['limit'] = 2
     assigns['offset'] = 2
-    assert_template_result('34','{%for i in array limit: limit offset: offset %}{{ i }}{%endfor%}',assigns)
+
+    assert_template_result('34', '{%for i in array limit: limit offset: offset %}{{ i }}{%endfor%}', assigns)
   end
 
   def test_nested_for
     assigns = {'array' => [[1,2],[3,4],[5,6]] }
-    assert_template_result('123456','{%for item in array%}{%for i in item%}{{ i }}{%endfor%}{%endfor%}',assigns)
+    assert_template_result('123456', '{%for item in array%}{%for i in item%}{{ i }}{%endfor%}{%endfor%}', assigns)
   end
 
   def test_offset_only
     assigns = {'array' => [1,2,3,4,5,6,7,8,9,0]}
-    assert_template_result('890','{%for i in array offset:7 %}{{ i }}{%endfor%}',assigns)
+    assert_template_result('890', '{%for i in array offset:7 %}{{ i }}{%endfor%}', assigns)
   end
 
   def test_pause_resume
@@ -199,86 +203,131 @@ HERE
 
   def test_assign
     assigns = {'var' => 'content' }
-    assert_template_result('var2:  var2:content','var2:{{var2}} {%assign var2 = var%} var2:{{var2}}',assigns)
+    assert_template_result('var2:  var2:content', 'var2:{{var2}} {%assign var2 = var%} var2:{{var2}}', assigns)
 
   end
 
   def test_hyphenated_assign
     assigns = {'a-b' => '1' }
-    assert_template_result('a-b:1 a-b:2','a-b:{{a-b}} {%assign a-b = 2 %}a-b:{{a-b}}',assigns)
+    assert_template_result('a-b:1 a-b:2', 'a-b:{{a-b}} {%assign a-b = 2 %}a-b:{{a-b}}', assigns)
 
   end
 
   def test_assign_with_colon_and_spaces
     assigns = {'var' => {'a:b c' => {'paged' => '1' }}}
-    assert_template_result('var2: 1','{%assign var2 = var["a:b c"].paged %}var2: {{var2}}',assigns)
+    assert_template_result('var2: 1', '{%assign var2 = var["a:b c"].paged %}var2: {{var2}}', assigns)
   end
 
   def test_capture
     assigns = {'var' => 'content' }
-    assert_template_result('content foo content foo ','{{ var2 }}{% capture var2 %}{{ var }} foo {% endcapture %}{{ var2 }}{{ var2 }}', assigns)
+    assert_template_result('content foo content foo ',
+                           '{{ var2 }}{% capture var2 %}{{ var }} foo {% endcapture %}{{ var2 }}{{ var2 }}',
+                           assigns)
   end
 
   def test_capture_detects_bad_syntax
     assert_raise(SyntaxError) do
-      assert_template_result('content foo content foo ','{{ var2 }}{% capture %}{{ var }} foo {% endcapture %}{{ var2 }}{{ var2 }}', {'var' => 'content' })
+      assert_template_result('content foo content foo ',
+                             '{{ var2 }}{% capture %}{{ var }} foo {% endcapture %}{{ var2 }}{{ var2 }}',
+                             {'var' => 'content' })
     end
   end
 
   def test_case
     assigns = {'condition' => 2 }
-    assert_template_result(' its 2 ','{% case condition %}{% when 1 %} its 1 {% when 2 %} its 2 {% endcase %}', assigns)
+    assert_template_result(' its 2 ',
+                           '{% case condition %}{% when 1 %} its 1 {% when 2 %} its 2 {% endcase %}',
+                           assigns)
 
     assigns = {'condition' => 1 }
-    assert_template_result(' its 1 ','{% case condition %}{% when 1 %} its 1 {% when 2 %} its 2 {% endcase %}', assigns)
+    assert_template_result(' its 1 ',
+                           '{% case condition %}{% when 1 %} its 1 {% when 2 %} its 2 {% endcase %}',
+                           assigns)
 
     assigns = {'condition' => 3 }
-    assert_template_result('','{% case condition %}{% when 1 %} its 1 {% when 2 %} its 2 {% endcase %}', assigns)
+    assert_template_result('',
+                           '{% case condition %}{% when 1 %} its 1 {% when 2 %} its 2 {% endcase %}',
+                           assigns)
 
     assigns = {'condition' => "string here" }
-    assert_template_result(' hit ','{% case condition %}{% when "string here" %} hit {% endcase %}', assigns)
+    assert_template_result(' hit ',
+                           '{% case condition %}{% when "string here" %} hit {% endcase %}',
+                           assigns)
 
     assigns = {'condition' => "bad string here" }
-    assert_template_result('','{% case condition %}{% when "string here" %} hit {% endcase %}', assigns)
+    assert_template_result('',
+                           '{% case condition %}{% when "string here" %} hit {% endcase %}',\
+                           assigns)
   end
 
   def test_case_with_else
-
     assigns = {'condition' => 5 }
-    assert_template_result(' hit ','{% case condition %}{% when 5 %} hit {% else %} else {% endcase %}', assigns)
+    assert_template_result(' hit ',
+                           '{% case condition %}{% when 5 %} hit {% else %} else {% endcase %}',
+                           assigns)
 
     assigns = {'condition' => 6 }
-    assert_template_result(' else ','{% case condition %}{% when 5 %} hit {% else %} else {% endcase %}', assigns)
+    assert_template_result(' else ',
+                           '{% case condition %}{% when 5 %} hit {% else %} else {% endcase %}',
+                           assigns)
 
     assigns = {'condition' => 6 }
-    assert_template_result(' else ','{% case condition %} {% when 5 %} hit {% else %} else {% endcase %}', assigns)
-
-
+    assert_template_result(' else ',
+                           '{% case condition %} {% when 5 %} hit {% else %} else {% endcase %}',
+                           assigns)
   end
 
   def test_case_on_size
-    assert_template_result('',     '{% case a.size %}{% when 1 %}1{% when 2 %}2{% endcase %}', 'a' => [])
-    assert_template_result('1' ,   '{% case a.size %}{% when 1 %}1{% when 2 %}2{% endcase %}', 'a' => [1])
-    assert_template_result('2' ,   '{% case a.size %}{% when 1 %}1{% when 2 %}2{% endcase %}', 'a' => [1, 1])
-    assert_template_result('',     '{% case a.size %}{% when 1 %}1{% when 2 %}2{% endcase %}', 'a' => [1, 1, 1])
-    assert_template_result('',     '{% case a.size %}{% when 1 %}1{% when 2 %}2{% endcase %}', 'a' => [1, 1, 1, 1])
-    assert_template_result('',     '{% case a.size %}{% when 1 %}1{% when 2 %}2{% endcase %}', 'a' => [1, 1, 1, 1, 1])
+    assert_template_result('',  '{% case a.size %}{% when 1 %}1{% when 2 %}2{% endcase %}', 'a' => [])
+    assert_template_result('1', '{% case a.size %}{% when 1 %}1{% when 2 %}2{% endcase %}', 'a' => [1])
+    assert_template_result('2', '{% case a.size %}{% when 1 %}1{% when 2 %}2{% endcase %}', 'a' => [1, 1])
+    assert_template_result('',  '{% case a.size %}{% when 1 %}1{% when 2 %}2{% endcase %}', 'a' => [1, 1, 1])
+    assert_template_result('',  '{% case a.size %}{% when 1 %}1{% when 2 %}2{% endcase %}', 'a' => [1, 1, 1, 1])
+    assert_template_result('',  '{% case a.size %}{% when 1 %}1{% when 2 %}2{% endcase %}', 'a' => [1, 1, 1, 1, 1])
   end
 
   def test_case_on_size_with_else
-    assert_template_result('else', '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}', 'a' => [])
-    assert_template_result('1',    '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}', 'a' => [1])
-    assert_template_result('2',    '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}', 'a' => [1, 1])
-    assert_template_result('else', '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}', 'a' => [1, 1, 1])
-    assert_template_result('else', '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}', 'a' => [1, 1, 1, 1])
-    assert_template_result('else', '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}', 'a' => [1, 1, 1, 1, 1])
+    assert_template_result('else',
+                           '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
+                           'a' => [])
+
+    assert_template_result('1',
+                           '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
+                           'a' => [1])
+
+    assert_template_result('2',
+                           '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
+                           'a' => [1, 1])
+
+    assert_template_result('else',
+                           '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
+                           'a' => [1, 1, 1])
+
+    assert_template_result('else',
+                           '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
+                           'a' => [1, 1, 1, 1])
+
+    assert_template_result('else',
+                           '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
+                           'a' => [1, 1, 1, 1, 1])
   end
 
   def test_case_on_length_with_else
-    assert_template_result('else',  '{% case a.empty? %}{% when true %}true{% when false %}false{% else %}else{% endcase %}', {})
-    assert_template_result('false', '{% case false %}{% when true %}true{% when false %}false{% else %}else{% endcase %}', {})
-    assert_template_result('true',  '{% case true %}{% when true %}true{% when false %}false{% else %}else{% endcase %}', {})
-    assert_template_result('else',  '{% case NULL %}{% when true %}true{% when false %}false{% else %}else{% endcase %}', {})
+    assert_template_result('else',
+                           '{% case a.empty? %}{% when true %}true{% when false %}false{% else %}else{% endcase %}',
+                           {})
+
+    assert_template_result('false',
+                           '{% case false %}{% when true %}true{% when false %}false{% else %}else{% endcase %}',
+                           {})
+
+    assert_template_result('true',
+                           '{% case true %}{% when true %}true{% when false %}false{% else %}else{% endcase %}',
+                           {})
+
+    assert_template_result('else',
+                           '{% case NULL %}{% when true %}true{% when false %}false{% else %}else{% endcase %}',
+                           {})
   end
 
   def test_assign_from_case
@@ -331,7 +380,8 @@ HERE
   end
 
   def test_assign_is_global
-    assert_equal 'variable', Liquid::Template.parse( '{%for i in (1..2) %}{% assign a = "variable"%}{% endfor %}{{a}}'  ).render
+    assert_equal 'variable',
+                 Liquid::Template.parse( '{%for i in (1..2) %}{% assign a = "variable"%}{% endfor %}{{a}}'  ).render
   end
 
   def test_case_detects_bad_syntax
@@ -345,31 +395,31 @@ HERE
 
   end
 
-
-
   def test_cycle
-
     assert_template_result('one','{%cycle "one", "two"%}')
     assert_template_result('one two','{%cycle "one", "two"%} {%cycle "one", "two"%}')
     assert_template_result(' two','{%cycle "", "two"%} {%cycle "", "two"%}')
 
     assert_template_result('one two one','{%cycle "one", "two"%} {%cycle "one", "two"%} {%cycle "one", "two"%}')
 
-    assert_template_result('text-align: left text-align: right','{%cycle "text-align: left", "text-align: right" %} {%cycle "text-align: left", "text-align: right"%}')
-
+    assert_template_result('text-align: left text-align: right',
+      '{%cycle "text-align: left", "text-align: right" %} {%cycle "text-align: left", "text-align: right"%}')
   end
 
   def test_multiple_cycles
-    assert_template_result('1 2 1 1 2 3 1','{%cycle 1,2%} {%cycle 1,2%} {%cycle 1,2%} {%cycle 1,2,3%} {%cycle 1,2,3%} {%cycle 1,2,3%} {%cycle 1,2,3%}')
+    assert_template_result('1 2 1 1 2 3 1',
+      '{%cycle 1,2%} {%cycle 1,2%} {%cycle 1,2%} {%cycle 1,2,3%} {%cycle 1,2,3%} {%cycle 1,2,3%} {%cycle 1,2,3%}')
   end
 
   def test_multiple_named_cycles
-    assert_template_result('one one two two one one','{%cycle 1: "one", "two" %} {%cycle 2: "one", "two" %} {%cycle 1: "one", "two" %} {%cycle 2: "one", "two" %} {%cycle 1: "one", "two" %} {%cycle 2: "one", "two" %}')
+    assert_template_result('one one two two one one',
+      '{%cycle 1: "one", "two" %} {%cycle 2: "one", "two" %} {%cycle 1: "one", "two" %} {%cycle 2: "one", "two" %} {%cycle 1: "one", "two" %} {%cycle 2: "one", "two" %}')
   end
 
   def test_multiple_named_cycles_with_names_from_context
     assigns = {"var1" => 1, "var2" => 2 }
-    assert_template_result('one one two two one one','{%cycle var1: "one", "two" %} {%cycle var2: "one", "two" %} {%cycle var1: "one", "two" %} {%cycle var2: "one", "two" %} {%cycle var1: "one", "two" %} {%cycle var2: "one", "two" %}', assigns)
+    assert_template_result('one one two two one one',
+      '{%cycle var1: "one", "two" %} {%cycle var2: "one", "two" %} {%cycle var1: "one", "two" %} {%cycle var2: "one", "two" %} {%cycle var1: "one", "two" %} {%cycle var2: "one", "two" %}', assigns)
   end
 
   def test_size_of_array
@@ -383,10 +433,10 @@ HERE
   end
 
   def test_illegal_symbols
-    assert_template_result('',     '{% if true == empty %}?{% endif %}', {})
-    assert_template_result('',     '{% if true == null %}?{% endif %}', {})
-    assert_template_result('',     '{% if empty == true %}?{% endif %}', {})
-    assert_template_result('',     '{% if null == true %}?{% endif %}', {})
+    assert_template_result('', '{% if true == empty %}?{% endif %}', {})
+    assert_template_result('', '{% if true == null %}?{% endif %}', {})
+    assert_template_result('', '{% if empty == true %}?{% endif %}', {})
+    assert_template_result('', '{% if null == true %}?{% endif %}', {})
   end
 
   def test_for_reversed
@@ -402,4 +452,4 @@ HERE
     assigns = {'array' => [ 1, 1, 1, 1] }
     assert_template_result('1','{%for item in array%}{%ifchanged%}{{item}}{% endifchanged %}{%endfor%}',assigns)
   end
-end
+end # StandardTagTest

test/lib/liquid/tags/statements_test.rb

@@ -1,10 +1,8 @@
-#!/usr/bin/env ruby
-require File.dirname(__FILE__) + '/helper'
+require 'test_helper'
 
 class StatementsTest < Test::Unit::TestCase
   include Liquid
 
-
   def test_true_eql_true
     text = %| {% if true == true %} true {% else %} false {% endif %} |
     expected = %|  true  |
@@ -69,46 +67,46 @@ class StatementsTest < Test::Unit::TestCase
     expected = %|  false  |
     assert_equal expected, Template.parse(text).render
   end
-  
+
   def test_var_strings_equal
     text = %| {% if var == "hello there!" %} true {% else %} false {% endif %} |
     expected = %|  true  |
     assert_equal expected, Template.parse(text).render('var' => 'hello there!')
   end
-  
+
   def test_var_strings_are_not_equal
     text = %| {% if "hello there!" == var %} true {% else %} false {% endif %} |
     expected = %|  true  |
     assert_equal expected, Template.parse(text).render('var' => 'hello there!')
   end
-  
+
   def test_var_and_long_string_are_equal
     text = %| {% if var == 'hello there!' %} true {% else %} false {% endif %} |
     expected = %|  true  |
     assert_equal expected, Template.parse(text).render('var' => 'hello there!')
   end
-  
+
 
   def test_var_and_long_string_are_equal_backwards
     text = %| {% if 'hello there!' == var %} true {% else %} false {% endif %} |
     expected = %|  true  |
     assert_equal expected, Template.parse(text).render('var' => 'hello there!')
   end
-  
-  #def test_is_nil    
+
+  #def test_is_nil
   #  text = %| {% if var != nil %} true {% else %} false {% end %} |
   #  @template.assigns = { 'var' => 'hello there!'}
   #  expected = %|  true  |
   #  assert_equal expected, @template.parse(text)
   #end
-    
-  def test_is_collection_empty    
+
+  def test_is_collection_empty
     text = %| {% if array == empty %} true {% else %} false {% endif %} |
     expected = %|  true  |
     assert_equal expected, Template.parse(text).render('array' => [])
   end
 
-  def test_is_not_collection_empty    
+  def test_is_not_collection_empty
     text = %| {% if array == empty %} true {% else %} false {% endif %} |
     expected = %|  false  |
     assert_equal expected, Template.parse(text).render('array' => [1,2,3])
@@ -133,5 +131,4 @@ class StatementsTest < Test::Unit::TestCase
     expected = %|  true  |
     assert_equal expected, Template.parse(text).render('var' => 1 )
   end
-
-end
+end # StatementsTest

test/lib/liquid/tags/unless_else_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/helper'
+require 'test_helper'
 
 class UnlessElseTest < Test::Unit::TestCase
   include Liquid
@@ -6,7 +6,7 @@ class UnlessElseTest < Test::Unit::TestCase
   def test_unless
     assert_template_result('  ',' {% unless true %} this text should not go into the output {% endunless %} ')
     assert_template_result('  this text should go into the output  ',
-              ' {% unless false %} this text should go into the output {% endunless %} ')
+                           ' {% unless false %} this text should go into the output {% endunless %} ')
     assert_template_result('  you rock ?','{% unless true %} you suck {% endunless %} {% unless false %} you rock {% endunless %}?')
   end
 
@@ -23,5 +23,4 @@ class UnlessElseTest < Test::Unit::TestCase
   def test_unless_else_in_loop
     assert_template_result ' TRUE  2  3 ', '{% for i in choices %}{% unless i %} {{ forloop.index }} {% else %} TRUE {% endunless %}{% endfor %}', 'choices' => [1, nil, false]
   end
-
-end
+end # UnlessElseTest

test/lib/liquid/template_test.rb

@@ -1,52 +1,52 @@
-require File.dirname(__FILE__) + '/helper'
+require 'test_helper'
 
 class TemplateTest < Test::Unit::TestCase
   include Liquid
-  
+
   def test_tokenize_strings
     assert_equal [' '], Template.new.send(:tokenize, ' ')
     assert_equal ['hello world'], Template.new.send(:tokenize, 'hello world')
-  end                         
-  
+  end
+
   def test_tokenize_variables
     assert_equal ['{{funk}}'], Template.new.send(:tokenize, '{{funk}}')
     assert_equal [' ', '{{funk}}', ' '], Template.new.send(:tokenize, ' {{funk}} ')
     assert_equal [' ', '{{funk}}', ' ', '{{so}}', ' ', '{{brother}}', ' '], Template.new.send(:tokenize, ' {{funk}} {{so}} {{brother}} ')
     assert_equal [' ', '{{  funk  }}', ' '], Template.new.send(:tokenize, ' {{  funk  }} ')
-  end                             
-  
-  def test_tokenize_blocks    
+  end
+
+  def test_tokenize_blocks
     assert_equal ['{%comment%}'], Template.new.send(:tokenize, '{%comment%}')
     assert_equal [' ', '{%comment%}', ' '], Template.new.send(:tokenize, ' {%comment%} ')
-    
+
     assert_equal [' ', '{%comment%}', ' ', '{%endcomment%}', ' '], Template.new.send(:tokenize, ' {%comment%} {%endcomment%} ')
-    assert_equal ['  ', '{% comment %}', ' ', '{% endcomment %}', ' '], Template.new.send(:tokenize, "  {% comment %} {% endcomment %} ")    
-  end                                                          
-  
+    assert_equal ['  ', '{% comment %}', ' ', '{% endcomment %}', ' '], Template.new.send(:tokenize, "  {% comment %} {% endcomment %} ")
+  end
+
   def test_instance_assigns_persist_on_same_template_object_between_parses
     t = Template.new
     assert_equal 'from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render
     assert_equal 'from instance assigns', t.parse("{{ foo }}").render
   end
-  
+
   def test_instance_assigns_persist_on_same_template_parsing_between_renders
     t = Template.new.parse("{{ foo }}{% assign foo = 'foo' %}{{ foo }}")
     assert_equal 'foo', t.render
     assert_equal 'foofoo', t.render
   end
-  
+
   def test_custom_assigns_do_not_persist_on_same_template
     t = Template.new
     assert_equal 'from custom assigns', t.parse("{{ foo }}").render('foo' => 'from custom assigns')
     assert_equal '', t.parse("{{ foo }}").render
   end
-  
+
   def test_custom_assigns_squash_instance_assigns
     t = Template.new
     assert_equal 'from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render
     assert_equal 'from custom assigns', t.parse("{{ foo }}").render('foo' => 'from custom assigns')
   end
-  
+
   def test_persistent_assigns_squash_instance_assigns
     t = Template.new
     assert_equal 'from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render
@@ -71,5 +71,4 @@ class TemplateTest < Test::Unit::TestCase
     assert_equal '1', t.render(assigns)
     @global = nil
   end
-  
-end
+end # TemplateTest

test/lib/liquid/variable_test.rb

@@ -1,5 +1,4 @@
-#!/usr/bin/env ruby
-require File.dirname(__FILE__) + '/helper'
+require 'test_helper'
 
 class VariableTest < Test::Unit::TestCase
   include Liquid
@@ -131,7 +130,7 @@ class VariableResolutionTest < Test::Unit::TestCase
     template = Template.parse(%|{{ test.test }}|)
     assert_equal 'worked', template.render('test' => {'test' => 'worked'})
   end
-  
+
   def test_preset_assigns
     template = Template.parse(%|{{ test }}|)
     template.assigns['test'] = 'worked'
@@ -168,5 +167,4 @@ class VariableResolutionTest < Test::Unit::TestCase
     }
     assert_equal "Unknown variable 'test'", e.message
   end
-
-end
+end # VariableTest

test/test_helper.rb

@@ -1,20 +1,26 @@
 #!/usr/bin/env ruby
-$LOAD_PATH.unshift(File.dirname(__FILE__)+ '/extra')
+extras_path = File.join File.dirname(__FILE__), 'extra'
+$LOAD_PATH.unshift(extras_path) unless $LOAD_PATH.include? extras_path
 
 require 'test/unit'
 require 'test/unit/assertions'
 require 'caller'
 require 'breakpoint'
-require File.dirname(__FILE__) + '/../lib/liquid'
+require File.join File.dirname(__FILE__), '..', 'lib', 'liquid'
 
 
 module Test
+
   module Unit
+
     module Assertions
-        include Liquid
-        def assert_template_result(expected, template, assigns={}, message=nil)
-          assert_equal expected, Template.parse(template).render(assigns)
-        end 
-    end
-  end
-end
+      include Liquid
+
+      def assert_template_result(expected, template, assigns={}, message=nil)
+        assert_equal expected, Template.parse(template).render(assigns)
+      end
+    end # Assertions
+
+  end # Unit
+
+end # Test