released new gem

Add split example to example servlet

.gitignore

@@ -1,3 +1,6 @@
+*~
 *.gem
 *.swp
 pkg
+*.rbc
+.rvmrc

.travis.yml

@@ -0,0 +1,12 @@
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - ree
+  - jruby
+  - rbx
+  - rbx-2.0
+
+script: "rake test"
+
+notifications:
+  disable: true

History.md

@@ -1,37 +1,49 @@
-* Make context and assign work the same
+# Liquid Version History
 
-* Ruby 1.9.1 bugfixes
+## 2.3.0
 
-* Fix LiquidView for Rails 2.2. Fix local assigns for all versions of Rails
+* Several speed/memory improvements
+* Numerous bug fixes
+* Added support for MRI 1.9, Rubinius, and JRuby
+* Added support for integer drop parameters
+* Added epoch support to `date` filter
+* New `raw` tag that suppresses parsing
+* Added `else` option to `for` tag
+* New `increment` tag
+* New `split` filter
+
+
+## 2.2.1 / 2010-08-23
+
+* Added support for literal tags
+
+
+## 2.2.0 / 2010-08-22
+
+* Compatible with Ruby 1.8.7, 1.9.1 and 1.9.2-p0
+* Merged some changed made by the community
+
+
+## 1.9.0 / 2008-03-04
 
 * Fixed gem install rake task
 * Improve Error encapsulation in liquid by maintaining a own set of exceptions instead of relying on ruby build ins
 
+
+## Before 1.9.0
+
 * Added If with or / and expressions
-
 * Implemented .to_liquid for all objects which can be passed to liquid like Strings Arrays Hashes Numerics and Booleans. To export new objects to liquid just implement .to_liquid on them and return objects which themselves have .to_liquid methods.
-
 * Added more tags to standard library
-
 * Added include tag ( like partials in rails )
-
 * [...] Gazillion of detail improvements
-
 * Added strainers as filter hosts for better security [Tobias Luetke]
-
 * Fixed that rails integration would call filter with the wrong "self" [Michael Geary]
-
 * Fixed bad error reporting when a filter called a method which doesn't exist. Liquid told you that it couldn't find the filter which was obviously misleading [Tobias Luetke]
-
 * Removed count helper from standard lib. use size [Tobias Luetke]
-
 * Fixed bug with string filter parameters failing to tolerate commas in strings. [Paul Hammond]
-
 * Improved filter parameters. Filter parameters are now context sensitive; Types are resolved according to the rules of the context. Multiple parameters are now separated by the Liquid::ArgumentSeparator: , by default [Paul Hammond]
-
-  {{ 'Typo' | link_to: 'http://typo.leetsoft.com', 'Typo - a modern weblog engine' }}
-
-
+    {{ 'Typo' | link_to: 'http://typo.leetsoft.com', 'Typo - a modern weblog engine' }}
 * Added Liquid::Drop. A base class which you can use for exporting proxy objects to liquid which can acquire more data when used in liquid. [Tobias Luetke]
 
   class ProductDrop < Liquid::Drop
@@ -41,6 +53,4 @@
   end
   t = Liquid::Template.parse( ' {% for product in product.top_sales %} {{ product.name }} {% endfor %} '  )
   t.render('product' => ProductDrop.new )
-
-
 * Added filter parameters support. Example: {{ date | format_date: "%Y" }} [Paul Hammond]

History.txt

@@ -1,44 +0,0 @@
-1.9.0 / 2008-03-04
-
-* Fixed gem install rake task
-* Improve Error encapsulation in liquid by maintaining a own set of exceptions instead of relying on ruby build ins
-
-Before 1.9.0
-
-* Added If with or / and expressions
-
-* Implemented .to_liquid for all objects which can be passed to liquid like Strings Arrays Hashes Numerics and Booleans. To export new objects to liquid just implement .to_liquid on them and return objects which themselves have .to_liquid methods. 
-
-* Added more tags to standard library
-
-* Added include tag ( like partials in rails )
-
-* [...] Gazillion of detail improvements
-
-* Added strainers as filter hosts for better security [Tobias Luetke]
-
-* Fixed that rails integration would call filter with the wrong "self" [Michael Geary]
-
-* Fixed bad error reporting when a filter called a method which doesn't exist. Liquid told you that it couldn't find the filter which was obviously misleading [Tobias Luetke]
-
-* Removed count helper from standard lib. use size [Tobias Luetke]
-
-* Fixed bug with string filter parameters failing to tolerate commas in strings. [Paul Hammond]
-
-* Improved filter parameters. Filter parameters are now context sensitive; Types are resolved according to the rules of the context. Multiple parameters are now separated by the Liquid::ArgumentSeparator: , by default [Paul Hammond]
-	
-	{{ 'Typo' | link_to: 'http://typo.leetsoft.com', 'Typo - a modern weblog engine' }}
-	
-
-* Added Liquid::Drop. A base class which you can use for exporting proxy objects to liquid which can acquire more data when used in liquid. [Tobias Luetke] 
-
-  class ProductDrop < Liquid::Drop
-    def top_sales
-       Shop.current.products.find(:all, :order => 'sales', :limit => 10 )
-    end
-  end   
-  t = Liquid::Template.parse( ' {% for product in product.top_sales %} {{ product.name }} {% endfor %} '  )
-  t.render('product' => ProductDrop.new )
-
-
-* Added filter parameters support. Example: {{ date | format_date: "%Y" }} [Paul Hammond]

Manifest.txt

@@ -1,34 +0,0 @@
-CHANGELOG
-History.txt
-MIT-LICENSE
-Manifest.txt
-README.txt
-Rakefile
-init.rb
-lib/extras/liquid_view.rb
-lib/liquid.rb
-lib/liquid/block.rb
-lib/liquid/condition.rb
-lib/liquid/context.rb
-lib/liquid/document.rb
-lib/liquid/drop.rb
-lib/liquid/errors.rb
-lib/liquid/extensions.rb
-lib/liquid/file_system.rb
-lib/liquid/htmltags.rb
-lib/liquid/module_ex.rb
-lib/liquid/standardfilters.rb
-lib/liquid/strainer.rb
-lib/liquid/tag.rb
-lib/liquid/tags/assign.rb
-lib/liquid/tags/capture.rb
-lib/liquid/tags/case.rb
-lib/liquid/tags/comment.rb
-lib/liquid/tags/cycle.rb
-lib/liquid/tags/for.rb
-lib/liquid/tags/if.rb
-lib/liquid/tags/ifchanged.rb
-lib/liquid/tags/include.rb
-lib/liquid/tags/unless.rb
-lib/liquid/template.rb
-lib/liquid/variable.rb

README.md

@@ -0,0 +1,44 @@
+# Liquid template engine
+
+## Introduction
+
+Liquid is a template engine which was written with very specific requirements:
+
+* It has to have beautiful and simple markup. Template engines which don't produce good looking markup are no fun to use.
+* It needs to be non evaling and secure. Liquid templates are made so that users can edit them. You don't want to run code on your server which your users wrote.
+* It has to be stateless. Compile and render steps have to be seperate so that the expensive parsing and compiling can be done once and later on you can just render it passing in a hash with local variables and objects.
+
+## Why you should use Liquid
+
+* You want to allow your users to edit the appearance of your application but don't want them to run **insecure code on your server**.
+* You want to render templates directly from the database
+* You like smarty (PHP) style template engines
+* You need a template engine which does HTML just as well as emails
+* You don't like the markup of your current templating engine
+
+## What does it look like?
+
+```html
+<ul id="products">
+  {% for product in products %}
+    <li>
+      <h2>{{ product.name }}</h2>
+      Only {{ product.price | price }}
+
+      {{ product.description | prettyprint | paragraph }}
+    </li>
+  {% endfor %}
+</ul>
+```
+
+## Howto use Liquid
+
+Liquid supports a very simple API based around the Liquid::Template class.
+For standard use you can just pass it the content of a file and call render with a parameters hash.
+
+```ruby
+@template = Liquid::Template.parse("hi {{name}}") # Parses and compiles the template
+@template.render('name' => 'tobi')                # => "hi tobi"
+```
+
+[![Build Status](https://secure.travis-ci.org/Shopify/liquid.png)](http://travis-ci.org/Shopify/liquid)

README.txt

@@ -1,38 +0,0 @@
-= Liquid template engine
-
-Liquid is a template engine which I wrote for very specific requirements
-
-* It has to have beautiful and simple markup. 
-  Template engines which don't produce good looking markup are no fun to use. 
-* It needs to be non evaling and secure. Liquid templates are made so that users can edit them. You don't want to run code on your server which your users wrote. 
-* It has to be stateless. Compile and render steps have to be seperate so that the expensive parsing and compiling can be done once and later on you can 
-  just render it   passing in a hash with local variables and objects.
-
-== Why should i use Liquid
-
-* You want to allow your users to edit the appearance of your application but don't want them to run insecure code on your server.
-* You want to render templates directly from the database
-* You like smarty style template engines 
-* You need a template engine which does HTML just as well as Emails
-* You don't like the markup of your current one
-
-== What does it look like?
-
-	<ul id="products">  
-	  {% for product in products %}
-	    <li>
-	      <h2>{{product.name}}</h2>
-	      Only {{product.price | price }}
-  
-	      {{product.description | prettyprint | paragraph }}
- 	    </li>      
-	  {% endfor %}  
-	</ul>
-
-== Howto use Liquid
-
-Liquid supports a very simple API based around the Liquid::Template class.
-For standard use you can just pass it the content of a file and call render with a parameters hash. 
-
-	@template = Liquid::Template.parse("hi {{name}}") # Parses and compiles the template
-	@template.render( 'name' => 'tobi' )              # => "hi tobi" 

Rakefile

@@ -1,38 +1,43 @@
 #!/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'
-require 'rake/gempackagetask'
+require 'rubygems/package_task'
 
 task :default => 'test'
 
 Rake::TestTask.new(:test) do |t|
   t.libs << '.' << 'lib' << 'test'
-  t.pattern = 'test/lib/**/*_test.rb'
+  t.pattern = 'test/liquid/**/*_test.rb'
   t.verbose = false
 end
 
 gemspec = eval(File.read('liquid.gemspec'))
-Rake::GemPackageTask.new(gemspec) do |pkg|
+Gem::PackageTask.new(gemspec) do |pkg|
   pkg.gem_spec = gemspec
 end
 
-desc "build the gem and release it to rubygems.org"
+desc "Build the gem and release it to rubygems.org"
 task :release => :gem do
   sh "gem push pkg/liquid-#{gemspec.version}.gem"
 end
 
+namespace :benchmark do
+
+  desc "Run the liquid benchmark"
+  task :run do
+    ruby "performance/benchmark.rb"
+  end
+
+end
+
+
 namespace :profile do
 
-  task :default => [:run]
-
-  desc "Run the liquid profile/perforamce coverage"
+  desc "Run the liquid profile/performance coverage"
   task :run do
-
-    ruby "performance/shopify.rb"
-
+    ruby "performance/profile.rb"
   end
 
   desc "Run KCacheGrind"
@@ -41,3 +46,8 @@ namespace :profile do
   end
 
 end
+
+desc "Run example"
+task :example do
+  ruby "-w -d -Ilib example/server/server.rb"
+end

example/server/example_servlet.rb

@@ -25,7 +25,11 @@ class Servlet < LiquidServlet
   def products    
     { 'products' => products_list, 'section' => 'Snowboards', 'cool_products' => true}    
   end
-  
+
+  def description
+    "List of Products ~ This is a list of products with price and description."
+  end
+
   private
   
   def products_list
@@ -34,4 +38,4 @@ class Servlet < LiquidServlet
     {'name' => 'Arbor Diamond', 'price' => 59900, 'description' => 'the *arbor diamond* is a made up product because im obsessed with arbor and have no creativity'}]
   end
   
-end
+end

example/server/server.rb

@@ -1,12 +1,14 @@
 require 'webrick'
 require 'rexml/document'
 
-require File.dirname(__FILE__) + '/../../lib/liquid'
-require File.dirname(__FILE__) + '/liquid_servlet'
-require File.dirname(__FILE__) + '/example_servlet'
+DIR = File.expand_path(File.dirname(__FILE__))
+
+require DIR + '/../../lib/liquid'
+require DIR + '/liquid_servlet'
+require DIR + '/example_servlet'
 
 # Setup webrick
 server = WEBrick::HTTPServer.new( :Port => ARGV[1] || 3000 )
 server.mount('/', Servlet)
 trap("INT"){ server.shutdown }
-server.start
+server.start

example/server/templates/products.liquid

@@ -16,8 +16,12 @@
 	</head>
 	
 	<body>
-	  
-	  <h1>There are currently {{products | count}} products in the {{section}} catalog</h1>
+
+	  <h1>{{ description | split: '~' | first }}</h1>
+
+	  <h2>{{ description | split: '~' | last }}</h2>
+
+	  <h2>There are currently {{products | count}} products in the {{section}} catalog</h2>
 
     {% if cool_products %}
       Cool products :) 

lib/liquid.rb

@@ -19,8 +19,6 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-
 module Liquid
   FilterSeparator             = /\|/
   ArgumentSeparator           = ','
@@ -35,7 +33,7 @@ module Liquid
   VariableIncompleteEnd       = /\}\}?/
   QuotedString                = /"[^"]*"|'[^']*'/
   QuotedFragment              = /#{QuotedString}|(?:[^\s,\|'"]|#{QuotedString})+/
-  StrictQuotedFragment        = /"[^"]+"|'[^']+'|[^\s,\|,\:,\,]+/
+  StrictQuotedFragment        = /"[^"]+"|'[^']+'|[^\s|:,]+/
   FirstFilterArgument         = /#{FilterArgumentSeparator}(?:#{StrictQuotedFragment})/
   OtherFilterArgument         = /#{ArgumentSeparator}(?:#{StrictQuotedFragment})/
   SpacelessFilter             = /^(?:'[^']+'|"[^"]+"|[^'"])*#{FilterSeparator}(?:#{StrictQuotedFragment})(?:#{FirstFilterArgument}(?:#{OtherFilterArgument})*)?/

lib/liquid/block.rb

@@ -92,10 +92,10 @@ module Liquid
       list.collect do |token|
         begin
           token.respond_to?(:render) ? token.render(context) : token
-        rescue Exception => e
+        rescue ::StandardError => e
           context.handle_error(e)
         end
-      end
+      end.join
     end
   end
 end

lib/liquid/context.rb

@@ -63,8 +63,8 @@ module Liquid
 
     # 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)
+      raise StackLevelError, "Nesting too deep" if @scopes.length > 100
     end
 
     # Merge a hash of variables in the current local scope
@@ -86,17 +86,11 @@ module Liquid
     #   end
     #
     #   context['var]  #=> nil
-    def stack(new_scope={},&block)
-      result = nil
+    def stack(new_scope={})
       push(new_scope)
-
-      begin
-        result = yield
-      ensure
-        pop
-      end
-
-      result
+      yield
+    ensure
+      pop
     end
 
     def clear_instance_assigns
@@ -117,6 +111,14 @@ module Liquid
     end
 
     private
+      LITERALS = {
+        nil => nil, 'nil' => nil, 'null' => nil, '' => nil,
+        'true'  => true,
+        'false' => false,
+        'blank' => :blank?,
+        'empty' => :empty?
+      }
+
       # 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
@@ -126,29 +128,23 @@ module Liquid
       # 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
+        if LITERALS.key?(key)
+          LITERALS[key]
         else
-          variable(key)
+          case key
+          when /^'(.*)'$/ # Single quoted strings
+            $1
+          when /^"(.*)"$/ # Double quoted strings
+            $1
+          when /^(\d+)$/ # Integer and floats
+            $1.to_i
+          when /^\((\S+)\.\.(\S+)\)$/ # Ranges
+            (resolve($1).to_i..resolve($2).to_i)
+          when /^(\d[\d\.]+)$/ # Floats
+            $1.to_f
+          else
+            variable(key)
+          end
         end
       end
 

lib/liquid/drop.rb

@@ -1,6 +1,6 @@
 module Liquid
 
-  # A drop in liquid is a class which allows you to to export DOM like things to liquid
+  # A drop in liquid is a class which allows you to to export DOM like things to liquid.
   # Methods of drops are callable.
   # The main use for liquid drops is the implement lazy loaded objects.
   # If you would like to make data available to the web designers which you don't want loaded unless needed then
@@ -8,14 +8,14 @@ module Liquid
   #
   # Example:
   #
-  # class ProductDrop < Liquid::Drop
-  #   def top_sales
-  #      Shop.current.products.find(:all, :order => 'sales', :limit => 10 )
+  #   class ProductDrop < Liquid::Drop
+  #     def top_sales
+  #       Shop.current.products.find(:all, :order => 'sales', :limit => 10 )
+  #     end
   #   end
-  # end
   #
-  # tmpl = Liquid::Template.parse( ' {% for product in product.top_sales %} {{ product.name }} {%endfor%} '  )
-  # tmpl.render('product' => ProductDrop.new ) # will invoke top_sales query.
+  #   tmpl = Liquid::Template.parse( ' {% for product in product.top_sales %} {{ product.name }} {%endfor%} '  )
+  #   tmpl.render('product' => ProductDrop.new ) # will invoke top_sales query.
   #
   # Your drop can either implement the methods sans any parameters or implement the before_method(name) method which is a
   # catch all
@@ -28,13 +28,11 @@ module Liquid
     end
 
     # called by liquid to invoke a drop
-    def invoke_drop(method)
-      # for backward compatibility with Ruby 1.8
-      methods = self.class.public_instance_methods.map { |m| m.to_s }
-      if methods.include?(method.to_s)
-        send(method.to_sym)
+    def invoke_drop(method_or_key)
+      if method_or_key && method_or_key != '' && self.class.public_method_defined?(method_or_key.to_s.to_sym)
+        send(method_or_key.to_s.to_sym)
       else
-        before_method(method)
+        before_method(method_or_key)
       end
     end
 

lib/liquid/extensions.rb

@@ -43,14 +43,20 @@ class Date  # :nodoc:
   end
 end
 
-def true.to_liquid  # :nodoc:
-  self
+class TrueClass
+  def to_liquid  # :nodoc:
+    self
+  end
 end
 
-def false.to_liquid # :nodoc:
-  self
+class FalseClass
+  def to_liquid # :nodoc:
+    self
+  end
 end
 
-def nil.to_liquid # :nodoc:
-  self
-end
+class NilClass
+  def to_liquid # :nodoc:
+    self
+  end
+end

lib/liquid/file_system.rb

@@ -14,7 +14,7 @@ module Liquid
   # This will parse the template with a LocalFileSystem implementation rooted at 'template_path'.
   class BlankFileSystem
     # Called by Liquid to retrieve a template file
-    def read_template_file(template_path)
+    def read_template_file(template_path, context)
       raise FileSystemError, "This liquid context does not allow includes."
     end
   end
@@ -38,7 +38,7 @@ module Liquid
       @root = root
     end
     
-    def read_template_file(template_path)
+    def read_template_file(template_path, context)
       full_path = full_path(template_path)
       raise FileSystemError, "No such template '#{template_path}'" unless File.exists?(full_path)
       

lib/liquid/htmltags.rb

@@ -33,7 +33,7 @@ module Liquid
       row = 1
       col = 0
 
-      result = ["<tr class=\"row1\">\n"]
+      result = "<tr class=\"row1\">\n"
       context.stack do
 
         collection.each_with_index do |item, index|
@@ -56,17 +56,18 @@ module Liquid
 
           col += 1
 
-          result << ["<td class=\"col#{col}\">"] + render_all(@nodelist, context) + ['</td>']
+          result << "<td class=\"col#{col}\">" << render_all(@nodelist, context) << '</td>'
 
           if col == cols and not (index == length - 1)
             col  = 0
             row += 1
-            result << ["</tr>\n<tr class=\"row#{row}\">"]
+            result << "</tr>\n<tr class=\"row#{row}\">"
           end
 
         end
       end
-      result + ["</tr>\n"]
+      result << "</tr>\n"
+      result
     end
   end
 

lib/liquid/standardfilters.rb

@@ -30,7 +30,9 @@ module Liquid
     end
 
     def escape_once(input)
-      ActionView::Helpers::TagHelper.escape_once(input) rescue input
+      ActionView::Helpers::TagHelper.escape_once(input)
+    rescue NameError
+      input
     end
 
     alias_method :h, :escape
@@ -51,6 +53,11 @@ module Liquid
       wordlist.length > l ? wordlist[0..l].join(" ") + truncate_string : input
     end
 
+    # Split input string into an array of substrings separated by given pattern.
+    def split(input, pattern)
+      input.split(pattern)
+    end
+
     def strip_html(input)
       input.to_s.gsub(/<script.*?<\/script>/, '').gsub(/<.*?>/, '')
     end
@@ -158,6 +165,10 @@ module Liquid
         return input.to_s
       end
 
+      if ((input.is_a?(String) && !/^\d+$/.match(input.to_s).nil?) || input.is_a?(Integer)) && input.to_i > 0
+        input = Time.at(input.to_i)
+      end
+
       date = input.is_a?(String) ? Time.parse(input) : input
 
       if date.respond_to?(:strftime)

lib/liquid/strainer.rb

@@ -14,7 +14,7 @@ module Liquid
   # One of the strainer's responsibilities is to keep malicious method calls out
   class Strainer < parent_object #:nodoc:
     INTERNAL_METHOD = /^__/
-    @@required_methods = Set.new([:__id__, :__send__, :respond_to?, :extend, :methods, :class, :object_id])
+    @@required_methods = Set.new([:__id__, :__send__, :respond_to?, :kind_of?, :extend, :methods, :singleton_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?

lib/liquid/tag.rb

@@ -1,6 +1,7 @@
 module Liquid
 
   class Tag
+
     attr_accessor :nodelist
 
     def initialize(tag_name, markup, tokens)
@@ -19,8 +20,7 @@ module Liquid
     def render(context)
       ''
     end
-  end
 
+  end # Tag
 
-end
-
+end # Tag

lib/liquid/tags/capture.rb

@@ -26,7 +26,7 @@ module Liquid
 
     def render(context)
       output = super
-      context.scopes.last[@to] = output.join
+      context.scopes.last[@to] = output
       ''
     end
   end

lib/liquid/tags/case.rb

@@ -31,20 +31,16 @@ module Liquid
       context.stack do          
         execute_else_block = true
         
-        @blocks.inject([]) do |output, block|
-      
+        output = ''
+        @blocks.each do |block|
           if block.else? 
-            
             return render_all(block.attachment, context) if execute_else_block
-            
           elsif block.evaluate(context)
-            
             execute_else_block = false        
-            output += render_all(block.attachment, context)                    
+            output << render_all(block.attachment, context)
           end            
-      
-          output
         end
+        output
       end          
     end
     

lib/liquid/tags/comment.rb

@@ -1,9 +1,9 @@
 module Liquid
-  class Comment < Block                                             
+  class Comment < Block
     def render(context)
       ''
-    end    
+    end
   end
-  
-  Template.register_tag('comment', Comment)  
-end
+
+  Template.register_tag('comment', Comment)
+end

lib/liquid/tags/decrement.rb

@@ -0,0 +1,39 @@
+module Liquid
+  
+  # decrement is used in a place where one needs to insert a counter
+  #     into a template, and needs the counter to survive across
+  #     multiple instantiations of the template.
+  #     NOTE: decrement is a pre-decrement, --i,
+  #           while increment is post:      i++.
+  #
+  #     (To achieve the survival, the application must keep the context)
+  #
+  #     if the variable does not exist, it is created with value 0.
+
+  #   Hello: {% decrement variable %}
+  #
+  # gives you:
+  #
+  #    Hello: -1
+  #    Hello: -2
+  #    Hello: -3
+  #
+  class Decrement < Tag
+    def initialize(tag_name, markup, tokens)      
+      @variable = markup.strip
+
+      super    
+    end    
+  
+    def render(context)
+      value = context.environments.first[@variable] ||= 0
+      value = value - 1
+      context.environments.first[@variable] = value
+      value.to_s
+    end
+  
+    private
+  end
+  
+  Template.register_tag('decrement', Decrement)
+end

lib/liquid/tags/for.rb

@@ -13,6 +13,8 @@ module Liquid
   #      <div {% if forloop.first %}class="first"{% endif %}>
   #        Item {{ forloop.index }}: {{ item.name }}
   #      </div>
+  #    {% else %}
+  #      There is nothing in the collection.
   #    {% endfor %}
   #
   # You can also define a limit and offset much like SQL.  Remember
@@ -58,8 +60,14 @@ module Liquid
         raise SyntaxError.new("Syntax Error in 'for loop' - Valid syntax: for [item] in [collection]")
       end
 
+      @nodelist = @for_block = []
       super
     end
+
+    def unknown_tag(tag, markup, tokens)
+      return super unless tag == 'else'
+      @nodelist = @else_block = []
+    end
   
     def render(context)        
       context.registers[:for] ||= Hash.new(0)
@@ -67,7 +75,7 @@ module Liquid
       collection = context[@collection_name]
       collection = collection.to_a if collection.is_a?(Range)
     
-      return '' unless collection.respond_to?(:each) 
+      return render_else(context) unless collection.respond_to?(:each) 
                                                  
       from = if @attributes['offset'] == 'continue'
         context.registers[:for][@name].to_i
@@ -81,11 +89,11 @@ module Liquid
                        
       segment = slice_collection_using_each(collection, from, to)      
       
-      return '' if segment.empty?
+      return render_else(context) if segment.empty?
       
       segment.reverse! if @reversed
 
-      result = []
+      result = ''
         
       length = segment.length            
             
@@ -105,7 +113,7 @@ module Liquid
             'first'   => (index == 0),
             'last'    => (index == length - 1) }
 
-          result << render_all(@nodelist, context)
+          result << render_all(@for_block, context)
         end
       end
       result     
@@ -130,7 +138,14 @@ module Liquid
 
       segments
     end
+
+    private
+
+      def render_else(context)
+        return @else_block ? [render_all(@else_block, context)] : ''
+      end
+
   end
 
   Template.register_tag('for', For)
-end
+end

lib/liquid/tags/if.rb

@@ -14,17 +14,16 @@ module Liquid
   class If < Block
     SyntaxHelp = "Syntax Error in tag 'if' - Valid syntax: if [expression]"
     Syntax = /(#{QuotedFragment})\s*([=!<>a-z_]+)?\s*(#{QuotedFragment})?/
-    ExpressionsAndOperators = /(?:\b(?:and|or)\b|(?:\s*(?!\b(?:and|or)\b)(?:#{QuotedFragment}|\S+)\s*)+)/
-    
-    def initialize(tag_name, markup, tokens)    
-    
+    ExpressionsAndOperators = /(?:\b(?:\s?and\s?|\s?or\s?)\b|(?:\s*(?!\b(?:\s?and\s?|\s?or\s?)\b)(?:#{QuotedFragment}|\S+)\s*)+)/
+
+    def initialize(tag_name, markup, tokens)
       @blocks = []
-      
+
       push_block('if', markup)
-      
-      super      
+
+      super
     end
-    
+
     def unknown_tag(tag, markup, tokens)
       if ['elsif', 'else'].include?(tag)
         push_block(tag, markup)
@@ -32,49 +31,49 @@ module Liquid
         super
       end
     end
-    
+
     def render(context)
       context.stack do
         @blocks.each do |block|
-          if block.evaluate(context)            
-            return render_all(block.attachment, context)            
+          if block.evaluate(context)
+            return render_all(block.attachment, context)
           end
-        end 
+        end
         ''
       end
     end
-    
-    private
-    
-    def push_block(tag, markup)            
-      block = if tag == 'else'
-        ElseCondition.new
-      else        
-        
-        expressions = markup.scan(ExpressionsAndOperators).reverse
-        raise(SyntaxError, SyntaxHelp) unless expressions.shift =~ Syntax 
 
-        condition = Condition.new($1, $2, $3)               
-        
-        while not expressions.empty?
-          operator = expressions.shift 
-          
-          raise(SyntaxError, SyntaxHelp) unless expressions.shift.to_s =~ Syntax    
-          
-          new_condition = Condition.new($1, $2, $3)
-          new_condition.send(operator.to_sym, condition)     
-          condition = new_condition          
-        end                        
-                  
-        condition
+    private
+
+      def push_block(tag, markup)
+        block = if tag == 'else'
+          ElseCondition.new
+        else
+
+          expressions = markup.scan(ExpressionsAndOperators).reverse
+          raise(SyntaxError, SyntaxHelp) unless expressions.shift =~ Syntax
+
+          condition = Condition.new($1, $2, $3)
+
+          while not expressions.empty?
+            operator = (expressions.shift).to_s.strip
+
+            raise(SyntaxError, SyntaxHelp) unless expressions.shift.to_s =~ Syntax
+
+            new_condition = Condition.new($1, $2, $3)
+            new_condition.send(operator.to_sym, condition)
+            condition = new_condition
+          end
+
+          condition
+        end
+
+        @blocks.push(block)
+        @nodelist = block.attach(Array.new)
       end
-            
-      @blocks.push(block)      
-      @nodelist = block.attach(Array.new) 
-    end
-    
-    
+
+
   end
 
   Template.register_tag('if', If)
-end
+end

lib/liquid/tags/include.rb

@@ -20,14 +20,12 @@ module Liquid
       super
     end
   
-    def parse(tokens)      
+    def parse(tokens)
     end
-  
-    def render(context)      
-      file_system = context.registers[:file_system] || Liquid::Template.file_system
-      source  = file_system.read_template_file(context[@template_name])      
-      partial = Liquid::Template.parse(source)      
-      
+    
+    def render(context)
+      source = _read_template_from_file_system(context)
+      partial = Liquid::Template.parse(source)
       variable = context[@variable_name || @template_name[1..-2]]
       
       context.stack do
@@ -36,20 +34,31 @@ module Liquid
         end
 
         if variable.is_a?(Array)
-          
-          variable.collect do |variable|            
+          variable.collect do |variable|
             context[@template_name[1..-2]] = variable
             partial.render(context)
           end
-
         else
-                    
           context[@template_name[1..-2]] = variable
           partial.render(context)
-          
         end
       end
     end
+   
+    private
+      def _read_template_from_file_system(context)
+        file_system = context.registers[:file_system] || Liquid::Template.file_system
+      
+        # make read_template_file call backwards-compatible.
+        case file_system.method(:read_template_file).arity
+        when 1
+          file_system.read_template_file(context[@template_name])
+        when 2
+          file_system.read_template_file(context[@template_name], context)
+        else
+          raise ArgumentError, "file_system.read_template_file expects two parameters: (template_name, context)"
+        end
+      end
   end
 
   Template.register_tag('include', Include)  

lib/liquid/tags/increment.rb

@@ -0,0 +1,35 @@
+module Liquid
+  
+  # increment is used in a place where one needs to insert a counter
+  #     into a template, and needs the counter to survive across
+  #     multiple instantiations of the template.
+  #     (To achieve the survival, the application must keep the context)
+  #
+  #     if the variable does not exist, it is created with value 0.
+
+  #   Hello: {% increment variable %}
+  #
+  # gives you:
+  #
+  #    Hello: 0
+  #    Hello: 1
+  #    Hello: 2
+  #
+  class Increment < Tag
+    def initialize(tag_name, markup, tokens)      
+      @variable = markup.strip
+
+      super    
+    end    
+  
+    def render(context)
+      value = context.environments.first[@variable] ||= 0
+      context.environments.first[@variable] = value + 1
+      value.to_s
+    end
+  
+    private
+  end
+  
+  Template.register_tag('increment', Increment)
+end

lib/liquid/tags/raw.rb

@@ -0,0 +1,21 @@
+module Liquid
+  class Raw < Block
+    def parse(tokens)
+      @nodelist ||= []
+      @nodelist.clear
+
+      while token = tokens.shift
+        if token =~ FullToken
+          if block_delimiter == $1
+            end_tag
+            return
+          end
+        end
+        @nodelist << token if not token.empty?
+      end
+    end
+  end
+
+  Template.register_tag('raw', Raw)
+end
+

lib/liquid/tags/unless.rb

@@ -13,19 +13,19 @@ module Liquid
         # First condition is interpreted backwards ( if not )
         block = @blocks.first
         unless block.evaluate(context)
-          return render_all(block.attachment, context)            
+          return render_all(block.attachment, context)
         end
         
         # After the first condition unless works just like if
         @blocks[1..-1].each do |block|
-          if block.evaluate(context)            
-            return render_all(block.attachment, context)            
+          if block.evaluate(context)
+            return render_all(block.attachment, context)
           end
-        end 
+        end
         
         ''
       end
-    end    
+    end
   end
   
 

lib/liquid/template.rb

@@ -121,7 +121,8 @@ module Liquid
       begin
         # render the nodelist.
         # for performance reasons we get a array back here. join will make a string out of it
-        @root.render(context).join
+        result = @root.render(context)
+        result.respond_to?(:join) ? result.join : result
       ensure
         @errors = context.errors
       end

lib/liquid/variable.rb

@@ -37,7 +37,7 @@ module Liquid
       return '' if @name.nil?
       @filters.inject(context[@name]) do |output, filter|
         filterargs = filter[1].to_a.collect do |a|
-         context[a]
+          context[a]
         end
         begin
           output = context.invoke(filter[0], output, *filterargs)

liquid.gemspec

@@ -1,28 +1,21 @@
+# encoding: utf-8
+
 Gem::Specification.new do |s|
-  s.name = %q{liquid}
-  s.version = "2.2.0"
+  s.name        = "liquid"
+  s.version     = "2.3.0"
+  s.platform    = Gem::Platform::RUBY
+  s.summary     = "A secure, non-evaling end user template engine with aesthetic markup."
+  s.authors     = ["Tobias Luetke"]
+  s.email       = ["tobi@leetsoft.com"]
+  s.homepage    = "http://www.liquidmarkup.org"
+  #s.description = "A secure, non-evaling end user template engine with aesthetic markup."
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Tobias Luetke"]
-  s.description = %q{A secure, non-evaling end user template engine with aesthetic markup.}
-  s.email = %q{tobi@leetsoft.com}
-  s.extra_rdoc_files = ["History.txt", "Manifest.txt", "README.txt"]
-  s.files = ["CHANGELOG", "History.txt", "MIT-LICENSE", "Manifest.txt", "README.txt", "Rakefile", "lib/extras/liquid_view.rb", "lib/liquid.rb", "lib/liquid/block.rb", "lib/liquid/condition.rb", "lib/liquid/context.rb", "lib/liquid/document.rb", "lib/liquid/drop.rb", "lib/liquid/errors.rb", "lib/liquid/extensions.rb", "lib/liquid/file_system.rb", "lib/liquid/htmltags.rb", "lib/liquid/module_ex.rb", "lib/liquid/standardfilters.rb", "lib/liquid/strainer.rb", "lib/liquid/tag.rb", "lib/liquid/tags/assign.rb", "lib/liquid/tags/capture.rb", "lib/liquid/tags/case.rb", "lib/liquid/tags/comment.rb", "lib/liquid/tags/cycle.rb", "lib/liquid/tags/for.rb", "lib/liquid/tags/if.rb", "lib/liquid/tags/ifchanged.rb", "lib/liquid/tags/include.rb", "lib/liquid/tags/unless.rb", "lib/liquid/template.rb", "lib/liquid/variable.rb"]
-  s.has_rdoc = true
-  s.homepage = %q{http://www.liquidmarkup.org}
-  s.rdoc_options = ["--main", "README.txt"]
-  s.require_paths = ["lib"]
-  s.rubyforge_project = %q{liquid}
-  s.rubygems_version = %q{1.3.1}
-  s.summary = %q{A secure, non-evaling end user template engine with aesthetic markup.}
+  s.required_rubygems_version = ">= 1.3.7"
 
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 2
+  s.test_files  = Dir.glob("{test}/**/*")
+  s.files       = Dir.glob("{lib}/**/*") + %w(MIT-LICENSE README.md)
 
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-    else
-    end
-  else
-  end
+  s.extra_rdoc_files  = ["History.md", "README.md"]
+
+  s.require_path = "lib"
 end

performance/benchmark.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'benchmark'
+require File.dirname(__FILE__) + '/theme_runner'
+
+profiler = ThemeRunner.new
+
+Benchmark.bmbm do |x|
+  x.report("parse & run:")   { 10.times { profiler.run(false) } }
+end
+

performance/profile.rb

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'ruby-prof' rescue fail("install ruby-prof extension/gem")
+require File.dirname(__FILE__) + '/theme_runner'
+
+profiler = ThemeRunner.new
+
+puts 'Running profiler...'
+
+results  = profiler.run(true)
+
+puts 'Success'
+puts
+
+[RubyProf::FlatPrinter, RubyProf::GraphPrinter, RubyProf::GraphHtmlPrinter, RubyProf::CallTreePrinter].each do |klass|
+  filename = (ENV['TMP'] || '/tmp') + (klass.name.include?('Html') ? "/liquid.#{klass.name.downcase}.html" : "/liquid.#{klass.name.downcase}.txt")
+  filename.gsub!(/:+/, '_')
+  File.open(filename, "w+") { |fp| klass.new(results).print(fp) }
+  $stderr.puts "wrote #{klass.name} output to #{filename}"
+end

performance/shopify/liquid.rb

@@ -1,3 +1,4 @@
+$:.unshift File.dirname(__FILE__) + '/../../lib'
 require File.dirname(__FILE__) + '/../../lib/liquid'
 
 require File.dirname(__FILE__) + '/comment_form'

performance/shopify/paginate.rb

@@ -52,17 +52,17 @@ class Paginate < Liquid::Block
       hellip_break = false
       
       if page_count > 2
-        1.upto(page_count-1) do |page|          
+        1.upto(page_count-1) do |page|
         
           if current_page == page
-            pagination['parts'] << no_link(page)        
+            pagination['parts'] << no_link(page)
           elsif page == 1 
             pagination['parts'] << link(page, page)
           elsif page == page_count -1
             pagination['parts'] << link(page, page)
           elsif page <= current_page - @attributes['window_size'] or page >= current_page + @attributes['window_size']
             next if hellip_break
-            pagination['parts'] << no_link('&hellip;') 
+            pagination['parts'] << no_link('&hellip;')
             hellip_break = true
             next
           else
@@ -73,7 +73,7 @@ class Paginate < Liquid::Block
         end 
       end
       
-      render_all(@nodelist, context)      
+      render_all(@nodelist, context)
     end
   end
     

performance/theme_runner.rb

@@ -13,55 +13,62 @@ require 'digest/md5'
 require File.dirname(__FILE__) + '/shopify/liquid'
 require File.dirname(__FILE__) + '/shopify/database.rb'
 
-require "ruby-prof" rescue fail("install ruby-prof extension/gem")
+class ThemeRunner
 
-class ThemeProfiler
-  
   # Load all templates into memory, do this now so that 
   # we don't profile IO. 
   def initialize
     @tests = Dir[File.dirname(__FILE__) + '/tests/**/*.liquid'].collect do |test|
       next if File.basename(test) == 'theme.liquid'
-      
+
       theme_path = File.dirname(test) + '/theme.liquid'
-      
+
       [File.read(test), (File.file?(theme_path) ? File.read(theme_path) : nil), test]
     end.compact
   end  
-  
-  
-  def profile
-    RubyProf.measure_mode = RubyProf::WALL_TIME
-    
+
+
+  def run(profile = false)
+    RubyProf.measure_mode = RubyProf::WALL_TIME if profile
+
     # Dup assigns because will make some changes to them
     assigns = Database.tables.dup
-    
+
     @tests.each do |liquid, layout, template_name|
-      
+
       # Compute page_tempalte outside of profiler run, uninteresting to profiler
       html = nil
       page_template = File.basename(template_name, File.extname(template_name))
-      
+
       # Profile compiling and rendering both
-      RubyProf.resume { html = compile_and_render(liquid, layout, assigns, page_template) }
       
+      if profile
+
+        RubyProf.resume do 
+          html = compile_and_render(liquid, layout, assigns, page_template) 
+        end 
+
+      else
+        html = compile_and_render(liquid, layout, assigns, page_template) 
+      end
+
       # return the result and the MD5 of the content, this can be used to detect regressions between liquid version
-      $stdout.puts "* rendered template %s, content: %s" % [template_name, Digest::MD5.hexdigest(html)]
-      
+      $stdout.puts "* rendered template %s, content: %s" % [template_name, Digest::MD5.hexdigest(html)] if profile
+ 
       # Uncomment to dump html files to /tmp so that you can inspect for errors
       # File.open("/tmp/#{File.basename(template_name)}.html", "w+") { |fp| fp <<html}
     end
-  
-    RubyProf.stop    
+
+    RubyProf.stop if profile
   end
-  
+
   def compile_and_render(template, layout, assigns, page_template)    
     tmpl = Liquid::Template.new
     tmpl.assigns['page_title'] = 'Page title'
     tmpl.assigns['template'] = page_template
-    
+
     content_for_layout = tmpl.parse(template).render(assigns)
-    
+
     if layout
       assigns['content_for_layout'] = content_for_layout      
       tmpl.parse(layout).render(assigns)
@@ -72,21 +79,4 @@ class ThemeProfiler
 end
 
 
-  profiler = ThemeProfiler.new
-
-  puts 'Running profiler...'
-
-  results  = profiler.profile
-  
-  puts 'Success'
-  puts
-
-[RubyProf::FlatPrinter, RubyProf::GraphPrinter, RubyProf::GraphHtmlPrinter, RubyProf::CallTreePrinter].each do |klass|
-  filename = (ENV['TMP'] || '/tmp') + (klass.name.include?('Html') ? "/liquid.#{klass.name.downcase}.html" : "/liquid.#{klass.name.downcase}.txt")
-  filename.gsub!(/:+/, '_')
-  File.open(filename, "w+") { |fp| klass.new(results).print(fp) }
-  $stderr.puts "wrote #{klass.name} output to #{filename}"
-end
-
-
 

test/extra/breakpoint.rb

@@ -1,547 +0,0 @@
-# The Breakpoint library provides the convenience of
-# being able to inspect and modify state, diagnose
-# bugs all via IRB by simply setting breakpoints in
-# your applications by the call of a method.
-#
-# This library was written and is supported by me,
-# Florian Gross. I can be reached at flgr@ccan.de
-# and enjoy getting feedback about my libraries.
-#
-# The whole library (including breakpoint_client.rb
-# and binding_of_caller.rb) is licensed under the
-# same license that Ruby uses. (Which is currently
-# either the GNU General Public License or a custom
-# one that allows for commercial usage.) If you for
-# some good reason need to use this under another
-# license please contact me.
-
-require 'irb'
-require 'caller'
-require 'drb'
-require 'drb/acl'
-require 'thread'
-
-module Breakpoint
-  id = %q$Id: breakpoint.rb 52 2005-02-26 19:43:19Z flgr $
-  current_version = id.split(" ")[2]
-  unless defined?(Version)
-    # The Version of ruby-breakpoint you are using as String of the
-    # 1.2.3 form where the digits stand for release, major and minor
-    # version respectively.
-    Version = "0.5.0"
-  end
-
-  extend self
-
-  # This will pop up an interactive ruby session at a
-  # pre-defined break point in a Ruby application. In
-  # this session you can examine the environment of
-  # the break point.
-  #
-  # You can get a list of variables in the context using
-  # local_variables via +local_variables+. You can then
-  # examine their values by typing their names.
-  #
-  # You can have a look at the call stack via +caller+.
-  #
-  # The source code around the location where the breakpoint
-  # was executed can be examined via +source_lines+. Its
-  # argument specifies how much lines of context to display.
-  # The default amount of context is 5 lines. Note that
-  # the call to +source_lines+ can raise an exception when
-  # it isn't able to read in the source code.
-  #
-  # breakpoints can also return a value. They will execute
-  # a supplied block for getting a default return value.
-  # A custom value can be returned from the session by doing
-  # +throw(:debug_return, value)+.
-  #
-  # You can also give names to break points which will be
-  # used in the message that is displayed upon execution 
-  # of them.
-  #
-  # Here's a sample of how breakpoints should be placed:
-  #
-  #   class Person
-  #     def initialize(name, age)
-  #       @name, @age = name, age
-  #       breakpoint("Person#initialize")
-  #     end
-  #
-  #     attr_reader :age
-  #     def name
-  #       breakpoint("Person#name") { @name }
-  #     end
-  #   end
-  #
-  #   person = Person.new("Random Person", 23)
-  #   puts "Name: #{person.name}"
-  #
-  # And here is a sample debug session:
-  #
-  #   Executing break point "Person#initialize" at file.rb:4 in `initialize'
-  #   irb(#<Person:0x292fbe8>):001:0> local_variables
-  #   => ["name", "age", "_", "__"]
-  #   irb(#<Person:0x292fbe8>):002:0> [name, age]
-  #   => ["Random Person", 23]
-  #   irb(#<Person:0x292fbe8>):003:0> [@name, @age]
-  #   => ["Random Person", 23]
-  #   irb(#<Person:0x292fbe8>):004:0> self
-  #   => #<Person:0x292fbe8 @age=23, @name="Random Person">
-  #   irb(#<Person:0x292fbe8>):005:0> @age += 1; self
-  #   => #<Person:0x292fbe8 @age=24, @name="Random Person">
-  #   irb(#<Person:0x292fbe8>):006:0> exit
-  #   Executing break point "Person#name" at file.rb:9 in `name'
-  #   irb(#<Person:0x292fbe8>):001:0> throw(:debug_return, "Overriden name")
-  #   Name: Overriden name
-  #
-  # Breakpoint sessions will automatically have a few
-  # convenience methods available. See Breakpoint::CommandBundle
-  # for a list of them.
-  #
-  # Breakpoints can also be used remotely over sockets.
-  # This is implemented by running part of the IRB session
-  # in the application and part of it in a special client.
-  # You have to call Breakpoint.activate_drb to enable
-  # support for remote breakpoints and then run
-  # breakpoint_client.rb which is distributed with this
-  # library. See the documentation of Breakpoint.activate_drb
-  # for details.
-  def breakpoint(id = nil, context = nil, &block)
-    callstack = caller
-    callstack.slice!(0, 3) if callstack.first["breakpoint"]
-    file, line, method = *callstack.first.match(/^(.+?):(\d+)(?::in `(.*?)')?/).captures
-
-    message = "Executing break point " + (id ? "#{id.inspect} " : "") +
-              "at #{file}:#{line}" + (method ? " in `#{method}'" : "")
-
-    if context then
-      return handle_breakpoint(context, message, file, line, &block)
-    end
-
-    Binding.of_caller do |binding_context|
-      handle_breakpoint(binding_context, message, file, line, &block)
-    end
-  end
-
-  # These commands are automatically available in all breakpoint shells.
-  module CommandBundle
-    # Proxy to a Breakpoint client. Lets you directly execute code
-    # in the context of the client.
-    class Client
-      def initialize(eval_handler) # :nodoc:
-        eval_handler.untaint
-        @eval_handler = eval_handler
-      end
-
-      instance_methods.each do |method|
-        next if method[/^__.+__$/]
-        undef_method method
-      end
-
-      # Executes the specified code at the client.
-      def eval(code)
-        @eval_handler.call(code)
-      end
-
-      # Will execute the specified statement at the client.
-      def method_missing(method, *args, &block)
-        if args.empty? and not block
-          result = eval "#{method}"
-        else
-          # This is a bit ugly. The alternative would be using an
-          # eval context instead of an eval handler for executing
-          # the code at the client. The problem with that approach
-          # is that we would have to handle special expressions
-          # like "self", "nil" or constants ourself which is hard.
-          remote = eval %{
-            result = lambda { |block, *args| #{method}(*args, &block) }
-            def result.call_with_block(*args, &block)
-              call(block, *args)
-            end
-            result
-          }
-          remote.call_with_block(*args, &block)
-        end
-
-        return result
-      end
-    end
-
-    # Returns the source code surrounding the location where the
-    # breakpoint was issued.
-    def source_lines(context = 5, return_line_numbers = false)
-      lines = File.readlines(@__bp_file).map { |line| line.chomp }
-
-      break_line = @__bp_line
-      start_line = [break_line - context, 1].max
-      end_line = break_line + context
-
-      result = lines[(start_line - 1) .. (end_line - 1)]
-
-      if return_line_numbers then
-        return [start_line, break_line, result]
-      else
-        return result
-      end
-    end
-
-    # Lets an object that will forward method calls to the breakpoint
-    # client. This is useful for outputting longer things at the client
-    # and so on. You can for example do these things:
-    #
-    #   client.puts "Hello" # outputs "Hello" at client console
-    #   # outputs "Hello" into the file temp.txt at the client
-    #   client.File.open("temp.txt", "w") { |f| f.puts "Hello" } 
-    def client()
-      if Breakpoint.use_drb? then
-        sleep(0.5) until Breakpoint.drb_service.eval_handler
-        Client.new(Breakpoint.drb_service.eval_handler)
-      else
-        Client.new(lambda { |code| eval(code, TOPLEVEL_BINDING) })
-      end
-    end
-  end
-
-  def handle_breakpoint(context, message, file = "", line = "", &block) # :nodoc:
-    catch(:debug_return) do |value|
-      eval(%{
-        @__bp_file = #{file.inspect}
-        @__bp_line = #{line}
-        extend Breakpoint::CommandBundle
-        extend DRbUndumped if self
-      }, context) rescue nil
-
-      if not use_drb? then
-        puts message
-        IRB.start(nil, IRB::WorkSpace.new(context))
-      else
-        @drb_service.add_breakpoint(context, message)
-      end
-
-      block.call if block
-    end
-  end
-
-  # These exceptions will be raised on failed asserts
-  # if Breakpoint.asserts_cause_exceptions is set to
-  # true.
-  class FailedAssertError < RuntimeError
-  end
-
-  # This asserts that the block evaluates to true.
-  # If it doesn't evaluate to true a breakpoint will
-  # automatically be created at that execution point.
-  #
-  # You can disable assert checking in production
-  # code by setting Breakpoint.optimize_asserts to
-  # true. (It will still be enabled when Ruby is run
-  # via the -d argument.)
-  #
-  # Example:
-  #   person_name = "Foobar"
-  #   assert { not person_name.nil? }
-  #
-  # Note: If you want to use this method from an
-  # unit test, you will have to call it by its full
-  # name, Breakpoint.assert.
-  def assert(context = nil, &condition)
-    return if Breakpoint.optimize_asserts and not $DEBUG
-    return if yield
-
-    callstack = caller
-    callstack.slice!(0, 3) if callstack.first["assert"]
-    file, line, method = *callstack.first.match(/^(.+?):(\d+)(?::in `(.*?)')?/).captures
-
-    message = "Assert failed at #{file}:#{line}#{" in `#{method}'" if method}."
-
-    if Breakpoint.asserts_cause_exceptions and not $DEBUG then
-      raise(Breakpoint::FailedAssertError, message)
-    end
-
-    message += " Executing implicit breakpoint."
-
-    if context then
-      return handle_breakpoint(context, message, file, line)
-    end
-
-    Binding.of_caller do |context|
-      handle_breakpoint(context, message, file, line)
-    end
-  end
-
-  # Whether asserts should be ignored if not in debug mode.
-  # Debug mode can be enabled by running ruby with the -d
-  # switch or by setting $DEBUG to true.
-  attr_accessor :optimize_asserts
-  self.optimize_asserts = false
-
-  # Whether an Exception should be raised on failed asserts
-  # in non-$DEBUG code or not. By default this is disabled.
-  attr_accessor :asserts_cause_exceptions
-  self.asserts_cause_exceptions = false
-  @use_drb = false
-
-  attr_reader :drb_service # :nodoc:
-
-  class DRbService # :nodoc:
-    include DRbUndumped
-
-    def initialize
-      @handler = @eval_handler = @collision_handler = nil
-
-      IRB.instance_eval { @CONF[:RC] = true }
-      IRB.run_config
-    end
-
-    def collision
-      sleep(0.5) until @collision_handler
-
-      @collision_handler.untaint
-
-      @collision_handler.call
-    end
-
-    def ping() end
-
-    def add_breakpoint(context, message)
-      workspace = IRB::WorkSpace.new(context)
-      workspace.extend(DRbUndumped)
-
-      sleep(0.5) until @handler
-
-      @handler.untaint
-      @handler.call(workspace, message)
-    rescue Errno::ECONNREFUSED, DRb::DRbConnError
-      raise if Breakpoint.use_drb? 
-    end
-
-    attr_accessor :handler, :eval_handler, :collision_handler
-  end
-
-  # Will run Breakpoint in DRb mode. This will spawn a server
-  # that can be attached to via the breakpoint-client command
-  # whenever a breakpoint is executed. This is useful when you
-  # are debugging CGI applications or other applications where
-  # you can't access debug sessions via the standard input and
-  # output of your application.
-  #
-  # You can specify an URI where the DRb server will run at.
-  # This way you can specify the port the server runs on. The
-  # default URI is druby://localhost:42531.
-  #
-  # Please note that breakpoints will be skipped silently in
-  # case the DRb server can not spawned. (This can happen if
-  # the port is already used by another instance of your
-  # application on CGI or another application.)
-  #
-  # Also note that by default this will only allow access
-  # from localhost. You can however specify a list of
-  # allowed hosts or nil (to allow access from everywhere).
-  # But that will still not protect you from somebody
-  # reading the data as it goes through the net.
-  #
-  # A good approach for getting security and remote access
-  # is setting up an SSH tunnel between the DRb service
-  # and the client. This is usually done like this:
-  #
-  # $ ssh -L20000:127.0.0.1:20000 -R10000:127.0.0.1:10000 example.com
-  # (This will connect port 20000 at the client side to port
-  # 20000 at the server side, and port 10000 at the server
-  # side to port 10000 at the client side.)
-  #
-  # After that do this on the server side: (the code being debugged)
-  # Breakpoint.activate_drb("druby://127.0.0.1:20000", "localhost")
-  #
-  # And at the client side:
-  # ruby breakpoint_client.rb -c druby://127.0.0.1:10000 -s druby://127.0.0.1:20000
-  #
-  # Running through such a SSH proxy will also let you use 
-  # breakpoint.rb in case you are behind a firewall.
-  #
-  # Detailed information about running DRb through firewalls is
-  # available at http://www.rubygarden.org/ruby?DrbTutorial
-  #
-  # == Security considerations
-  # Usually you will be fine when using the default druby:// URI and the default
-  # access control list. However, if you are sitting on a machine where there are
-  # local users that you likely can not trust (this is the case for example on
-  # most web hosts which have multiple users sitting on the same physical machine)
-  # you will be better off by doing client/server communication through a unix
-  # socket. This can be accomplished by calling with a drbunix:/ style URI, e.g.
-  # <code>Breakpoint.activate_drb('drbunix:/tmp/breakpoint_server')</code>. This
-  # will only work on Unix based platforms.
-  def activate_drb(uri = nil, allowed_hosts = ['localhost', '127.0.0.1', '::1'],
-    ignore_collisions = false)
-
-    return false if @use_drb
-
-    uri ||= 'druby://localhost:42531'
-
-    if allowed_hosts then
-      acl = ["deny", "all"]
-
-      Array(allowed_hosts).each do |host|
-        acl += ["allow", host]
-      end
-
-      DRb.install_acl(ACL.new(acl))
-    end
-
-    @use_drb = true
-    @drb_service = DRbService.new
-    did_collision = false
-    begin
-      @service = DRb.start_service(uri, @drb_service)
-    rescue Errno::EADDRINUSE
-      if ignore_collisions then
-        nil
-      else
-        # The port is already occupied by another
-        # Breakpoint service. We will try to tell
-        # the old service that we want its port.
-        # It will then forward that request to the
-        # user and retry.
-        unless did_collision then
-          DRbObject.new(nil, uri).collision
-          did_collision = true
-        end
-        sleep(10)
-        retry
-      end
-    end
-
-    return true
-  end
-
-  # Deactivates a running Breakpoint service.
-  def deactivate_drb
-    Thread.exclusive do
-      @service.stop_service unless @service.nil?
-      @service = nil
-      @use_drb = false
-      @drb_service = nil
-    end
-  end
-
-  # Returns true when Breakpoints are used over DRb.
-  # Breakpoint.activate_drb causes this to be true.
-  def use_drb?
-    @use_drb == true
-  end
-end
-
-module IRB # :nodoc:
-  class << self; remove_method :start; end
-  def self.start(ap_path = nil, main_context = nil, workspace = nil)
-    $0 = File::basename(ap_path, ".rb") if ap_path
-
-    # suppress some warnings about redefined constants
-    old_verbose, $VERBOSE = $VERBOSE, nil
-    IRB.setup(ap_path)
-    $VERBOSE = old_verbose
-
-    if @CONF[:SCRIPT] then
-      irb = Irb.new(main_context, @CONF[:SCRIPT])
-    else
-      irb = Irb.new(main_context)
-    end
-
-    if workspace then
-      irb.context.workspace = workspace
-    end
-
-    @CONF[:IRB_RC].call(irb.context) if @CONF[:IRB_RC]
-    @CONF[:MAIN_CONTEXT] = irb.context
-
-    old_sigint = trap("SIGINT") do
-      begin
-        irb.signal_handle
-      rescue RubyLex::TerminateLineInput
-        # ignored
-      end
-    end
-    
-    catch(:IRB_EXIT) do
-      irb.eval_input
-    end
-  ensure
-    trap("SIGINT", old_sigint)
-  end
-
-  class << self
-    alias :old_CurrentContext :CurrentContext
-    remove_method :CurrentContext
-    remove_method :parse_opts
-  end
-
-  def IRB.CurrentContext
-    if old_CurrentContext.nil? and Breakpoint.use_drb? then
-      result = Object.new
-      def result.last_value; end
-      return result
-    else
-      old_CurrentContext
-    end
-  end
-  def IRB.parse_opts() end
-
-  class Context # :nodoc:
-    alias :old_evaluate :evaluate
-    def evaluate(line, line_no)
-      if line.chomp == "exit" then
-        exit
-      else
-        old_evaluate(line, line_no)
-      end
-    end
-  end
-
-  class WorkSpace # :nodoc:
-    alias :old_evaluate :evaluate
-
-    def evaluate(*args)
-      if Breakpoint.use_drb? then
-        result = old_evaluate(*args)
-        if args[0] != :no_proxy and
-          not [true, false, nil].include?(result)
-        then
-          result.extend(DRbUndumped) rescue nil
-        end
-        return result
-      else
-        old_evaluate(*args)
-      end
-    end
-  end
-
-  module InputCompletor # :nodoc:
-    def self.eval(code, context, *more)
-      # Big hack, this assumes that InputCompletor
-      # will only call eval() when it wants code
-      # to be executed in the IRB context.
-      IRB.conf[:MAIN_CONTEXT].workspace.evaluate(:no_proxy, code, *more)
-    end
-  end
-end
-
-module DRb # :nodoc:
-  class DRbObject # :nodoc:
-    undef :inspect if method_defined?(:inspect)
-    undef :clone if method_defined?(:clone)
-  end
-end
-
-# See Breakpoint.breakpoint
-def breakpoint(id = nil, &block)
-  Binding.of_caller do |context|
-    Breakpoint.breakpoint(id, context, &block)
-  end
-end
-
-# See Breakpoint.assert
-def assert(&block)
-  Binding.of_caller do |context|
-    Breakpoint.assert(context, &block)
-  end
-end

test/extra/caller.rb

@@ -1,80 +0,0 @@
-class Continuation # :nodoc:
-  def self.create(*args, &block) # :nodoc:
-    cc = nil; result = callcc {|c| cc = c; block.call(cc) if block and args.empty?}
-    result ||= args
-    return *[cc, *result]
-  end
-end
-
-class Binding; end # for RDoc
-# This method returns the binding of the method that called your
-# method. It will raise an Exception when you're not inside a method.
-#
-# It's used like this:
-#   def inc_counter(amount = 1)
-#     Binding.of_caller do |binding|
-#       # Create a lambda that will increase the variable 'counter'
-#       # in the caller of this method when called.
-#       inc = eval("lambda { |arg| counter += arg }", binding)
-#       # We can refer to amount from inside this block safely.
-#       inc.call(amount)
-#     end
-#     # No other statements can go here. Put them inside the block.
-#   end
-#   counter = 0
-#   2.times { inc_counter }
-#   counter # => 2
-#
-# Binding.of_caller must be the last statement in the method.
-# This means that you will have to put everything you want to
-# do after the call to Binding.of_caller into the block of it.
-# This should be no problem however, because Ruby has closures.
-# If you don't do this an Exception will be raised. Because of
-# the way that Binding.of_caller is implemented it has to be
-# done this way.
-def Binding.of_caller(&block)
-  old_critical = Thread.critical
-  Thread.critical = true
-  count = 0
-  cc, result, error, extra_data = Continuation.create(nil, nil)
-  error.call if error
-
-  tracer = lambda do |*args|
-    type, context, extra_data = args[0], args[4], args
-    if type == "return"
-      count += 1
-      # First this method and then calling one will return --
-      # the trace event of the second event gets the context
-      # of the method which called the method that called this
-      # method.
-      if count == 2
-        # It would be nice if we could restore the trace_func
-        # that was set before we swapped in our own one, but
-        # this is impossible without overloading set_trace_func
-        # in current Ruby.
-        set_trace_func(nil)
-        cc.call(eval("binding", context), nil, extra_data)
-      end
-    elsif type == "line" then
-      nil
-    elsif type == "c-return" and extra_data[3] == :set_trace_func then
-      nil
-    else
-      set_trace_func(nil)
-      error_msg = "Binding.of_caller used in non-method context or " +
-        "trailing statements of method using it aren't in the block."
-      cc.call(nil, lambda { raise(ArgumentError, error_msg) }, nil)
-    end
-  end
-
-  unless result
-    set_trace_func(tracer)
-    return nil
-  else
-    Thread.critical = old_critical
-    case block.arity
-      when 1 then yield(result)
-      else yield(result, extra_data)        
-    end
-  end
-end

test/liquid/condition_test.rb

@@ -48,16 +48,14 @@ class ConditionTest < Test::Unit::TestCase
     @context = Liquid::Context.new
     @context['array'] = [1,2,3,4,5]
 
-    assert_evalutes_false "array", 'contains', '0'
-    assert_evalutes_true "array", 'contains', '1'
-    assert_evalutes_true "array", 'contains', '2'
-    assert_evalutes_true "array", 'contains', '3'
-    assert_evalutes_true "array", 'contains', '4'
-    assert_evalutes_true "array", 'contains', '5'
-    assert_evalutes_false "array", 'contains', '6'
-
-    assert_evalutes_false "array", 'contains', '"1"'
-
+    assert_evalutes_false "array",  'contains', '0'
+    assert_evalutes_true "array",   'contains', '1'
+    assert_evalutes_true "array",   'contains', '2'
+    assert_evalutes_true "array",   'contains', '3'
+    assert_evalutes_true "array",   'contains', '4'
+    assert_evalutes_true "array",   'contains', '5'
+    assert_evalutes_false "array",  'contains', '6'
+    assert_evalutes_false "array",  'contains', '"1"'
   end
 
   def test_contains_returns_false_for_nil_operands
@@ -94,17 +92,23 @@ class ConditionTest < Test::Unit::TestCase
     assert_equal false, condition.evaluate
   end
 
-
   def test_should_allow_custom_proc_operator
     Condition.operators['starts_with'] = Proc.new { |cond, left, right| left =~ %r{^#{right}} }
 
-    assert_evalutes_true "'bob'", 'starts_with', "'b'"
-    assert_evalutes_false "'bob'", 'starts_with', "'o'"
+    assert_evalutes_true "'bob'",   'starts_with', "'b'"
+    assert_evalutes_false "'bob'",  'starts_with', "'o'"
 
     ensure
       Condition.operators.delete 'starts_with'
   end
 
+  def test_left_or_right_may_contain_operators
+    @context = Liquid::Context.new
+    @context['one'] = @context['another'] = "gnomeslab-and-or-liquid"
+
+    assert_evalutes_true "one", '==', "another"
+  end
+
   private
     def assert_evalutes_true(left, op, right)
       assert Condition.new(left, op, right).evaluate(@context || Liquid::Context.new),

test/liquid/drop_test.rb

@@ -13,10 +13,6 @@ class ContextDrop < Liquid::Drop
     @context['forloop.index']
   end
 
-  def break
-    Breakpoint.breakpoint
-  end
-
   def before_method(method)
     return @context[method]
   end
@@ -36,7 +32,7 @@ class ProductDrop < Liquid::Drop
 
   class CatchallDrop < Liquid::Drop
     def before_method(method)
-      return 'method: ' << method
+      return 'method: ' << method.to_s
     end
   end
 
@@ -88,12 +84,17 @@ class DropsTest < Test::Unit::TestCase
 
   end
 
-  def test_text_drop
+  def test_unknown_method
     output = Liquid::Template.parse( ' {{ product.catchall.unknown }} '  ).render('product' => ProductDrop.new)
     assert_equal ' method: unknown ', output
 
   end
 
+  def test_integer_argument_drop
+    output = Liquid::Template.parse( ' {{ product.catchall[8] }} '  ).render('product' => ProductDrop.new)
+    assert_equal ' method: 8 ', output
+  end
+
   def test_text_array_drop
     output = Liquid::Template.parse( '{% for text in product.texts.array %} {{text}} {% endfor %}'  ).render('product' => ProductDrop.new)
     assert_equal ' text1  text2 ', output
@@ -150,4 +151,12 @@ class DropsTest < Test::Unit::TestCase
   def test_enumerable_drop_size
     assert_equal '3', Liquid::Template.parse( '{{collection.size}}').render('collection' => EnumerableDrop.new)
   end
+
+  def test_empty_string_value_access
+    assert_equal '', Liquid::Template.parse('{{ product[value] }}').render('product' => ProductDrop.new, 'value' => '')
+  end
+
+  def test_nil_value_access
+    assert_equal '', Liquid::Template.parse('{{ product[value] }}').render('product' => ProductDrop.new, 'value' => nil)
+  end
 end # DropsTest

test/liquid/error_handling_test.rb

@@ -13,6 +13,10 @@ class ErrorDrop < Liquid::Drop
     raise Liquid::SyntaxError, 'syntax error'
   end
 
+  def exception
+    raise Exception, 'exception'
+  end
+
 end
 
 class ErrorHandlingTest < Test::Unit::TestCase
@@ -66,4 +70,12 @@ class ErrorHandlingTest < Test::Unit::TestCase
       assert_equal Liquid::ArgumentError, template.errors.first.class
     end
   end
+
+  # Liquid should not catch Exceptions that are not subclasses of StandardError, like Interrupt and NoMemoryError
+  def test_exceptions_propagate
+    assert_raise Exception do
+      template = Liquid::Template.parse( ' {{ errors.exception }} '  )
+      template.render('errors' => ErrorDrop.new)
+    end
+  end
 end # ErrorHandlingTest

test/liquid/file_system_test.rb

@@ -5,7 +5,7 @@ class FileSystemTest < Test::Unit::TestCase
 
   def test_default
     assert_raise(FileSystemError) do
-      BlankFileSystem.new.read_template_file("dummy")
+      BlankFileSystem.new.read_template_file("dummy", {'dummy'=>'smarty'})
     end
   end
 

test/liquid/standard_filter_test.rb

@@ -39,6 +39,14 @@ class StandardFiltersTest < Test::Unit::TestCase
     assert_equal '1234567890', @filters.truncate('1234567890')
   end
 
+  def test_strip
+    assert_equal ['12','34'], @filters.split('12~34', '~')
+    assert_equal ['A? ',' ,Z'], @filters.split('A? ~ ~ ~ ,Z', '~ ~ ~')
+    assert_equal ['A?Z'], @filters.split('A?Z', '~')
+    # Regexp works although Liquid does not support.
+    assert_equal ['A','Z'], @filters.split('AxZ', /x/)
+  end
+
   def test_escape
     assert_equal '&lt;strong&gt;', @filters.escape('<strong>')
     assert_equal '&lt;strong&gt;', @filters.h('<strong>')
@@ -97,6 +105,9 @@ class StandardFiltersTest < Test::Unit::TestCase
     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 "07/05/2006", @filters.date(1152098955, "%m/%d/%Y")
+    assert_equal "07/05/2006", @filters.date("1152098955", "%m/%d/%Y")
   end
 
 

test/liquid/tags/if_else_tag_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class IfElseTest < Test::Unit::TestCase
+class IfElseTagTest < Test::Unit::TestCase
   include Liquid
 
   def test_if
@@ -150,4 +150,11 @@ class IfElseTest < Test::Unit::TestCase
   ensure
     Condition.operators.delete 'contains'
   end
+
+  def test_operators_are_ignored_unless_isolated
+    Condition.operators['contains'] = :[]
+
+    assert_template_result('yes',
+                           %({% if 'gnomeslab-and-or-liquid' contains 'gnomeslab-and-or-liquid' %}yes{% endif %}))
+  end
 end # IfElseTest

test/liquid/tags/include_tag_test.rb

@@ -1,7 +1,7 @@
 require 'test_helper'
 
 class TestFileSystem
-  def read_template_file(template_path)
+  def read_template_file(template_path, context)
     case template_path
     when "product"
       "Product: {{ product.title }} "
@@ -34,7 +34,7 @@ class TestFileSystem
 end
 
 class OtherFileSystem
-  def read_template_file(template_path)
+  def read_template_file(template_path, context)
     'from OtherFileSystem'
   end
 end
@@ -104,7 +104,7 @@ class IncludeTagTest < Test::Unit::TestCase
   def test_recursively_included_template_does_not_produce_endless_loop
 
     infinite_file_system = Class.new do
-      def read_template_file(template_path)
+      def read_template_file(template_path, context)
         "-{% include 'loop' %}"
       end
     end
@@ -117,6 +117,18 @@ class IncludeTagTest < Test::Unit::TestCase
 
   end
 
+  def test_backwards_compatability_support_for_overridden_read_template_file
+    infinite_file_system = Class.new do
+      def read_template_file(template_path) # testing only one argument here.
+        "- hi mom"
+      end
+    end
+
+    Liquid::Template.file_system = infinite_file_system.new
+
+    Template.parse("{% include 'hi_mom' %}").render!
+  end
+
   def test_dynamically_choosen_template
 
     assert_equal "Test123", Template.parse("{% include template %}").render("template" => 'Test123')

test/liquid/tags/increment_tag_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+class IncrementTagTest < Test::Unit::TestCase
+  include Liquid
+
+  def test_inc
+    assert_template_result('0','{%increment port %}', {})
+    assert_template_result('0 1','{%increment port %} {%increment port%}', {})
+    assert_template_result('0 0 1 2 1',
+                           '{%increment port %} {%increment starboard%} ' +
+                           '{%increment port %} {%increment port%} ' +
+                           '{%increment starboard %}', {})
+  end
+
+  def test_dec
+    assert_template_result('9','{%decrement port %}', { 'port' => 10})
+    assert_template_result('-1 -2','{%decrement port %} {%decrement port%}', {})
+    assert_template_result('1 5 2 2 5',
+                           '{%increment port %} {%increment starboard%} ' +
+                           '{%increment port %} {%decrement port%} ' +
+                           '{%decrement starboard %}', { 'port' => 1, 'starboard' => 5 })
+  end
+
+end

test/liquid/tags/raw_tag_test.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+
+class RawTagTest < Test::Unit::TestCase
+  include Liquid
+
+  def test_tag_in_raw
+    assert_template_result '{% comment %} test {% endcomment %}',
+                           '{% raw %}{% comment %} test {% endcomment %}{% endraw %}'
+  end
+
+  def test_output_in_raw
+    assert_template_result '{{ test }}',
+                           '{% raw %}{{ test }}{% endraw %}'
+  end
+end

test/liquid/tags/standard_tag_test.rb

@@ -102,6 +102,12 @@ HERE
                            assigns)
   end
 
+  def test_for_else
+    assert_template_result('+++', '{%for item in array%}+{%else%}-{%endfor%}', 'array'=>[1,2,3])
+    assert_template_result('-',   '{%for item in array%}+{%else%}-{%endfor%}', 'array'=>[])
+    assert_template_result('-',   '{%for item in array%}+{%else%}-{%endfor%}', 'array'=>nil)
+  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)

test/liquid/tags/unless_else_tag_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class UnlessElseTest < Test::Unit::TestCase
+class UnlessElseTagTest < Test::Unit::TestCase
   include Liquid
 
   def test_unless

test/test_helper.rb

@@ -1,26 +1,29 @@
 #!/usr/bin/env ruby
-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.join File.dirname(__FILE__), '..', 'lib', 'liquid'
+begin
+  require 'ruby-debug'
+rescue LoadError
+  puts "Couldn't load ruby-debug. gem install ruby-debug if you need it."
+end
+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)
+      def assert_template_result(expected, template, assigns = {}, message = nil)
         assert_equal expected, Template.parse(template).render(assigns)
       end
+
+      def assert_template_result_matches(expected, template, assigns = {}, message = nil)
+        return assert_template_result(expected, template, assigns, message) unless expected.is_a? Regexp
+
+        assert_match expected, Template.parse(template).render(assigns)
+      end
     end # Assertions
-
   end # Unit
-
 end # Test