Update history log

Improve Rakefile
Conflicts:
	Rakefile

.gitignore

@@ -5,8 +5,3 @@ pkg
 *.rbc
 .rvmrc
 .ruby-version
-Gemfile.lock
-/ext/liquid/Makefile
-*.o
-*.bundle
-/tmp

.travis.yml

@@ -1,14 +1,11 @@
 rvm:
+  - 1.8.7
   - 1.9.3
-  - 2.0.0
+  - ree
-  - 2.1.0
+  - jruby-18mode
   - jruby-19mode
-  - jruby-head
+  - rbx-18mode
   - rbx-19mode
-matrix:
-  allow_failures:
-    - rvm: rbx-19mode
-    - rvm: jruby-head
 
 script: "rake test"
 

Gemfile

@@ -1,3 +0,0 @@
-source 'https://rubygems.org'
-
-gemspec

History.md

@@ -1,36 +1,11 @@
 # Liquid Version History
 
-## 3.0.0 / not yet released / branch "master"
-
-* ...
-* Freeze lots of string literals for new Ruby 2.1 optimization, see #297 [Florian Weingarten, fw42]
-* Allow newlines in tags and variables, see #324 [Dylan Thacker-Smith, dylanahsmith]
-* Tag#parse is called after initialize, which now takes options instead of tokens as the 3rd argument. See #321 [Dylan Thacker-Smith, dylanahsmith]
-* Raise `Liquid::ArgumentError` instead of `::ArgumentError` when filter has wrong number of arguments #309 [Bogdan Gusiev, bogdan]
-* Add a to_s default for liquid drops, see #306 [Adam Doeler, releod]
-* Add strip, lstrip, and rstrip to standard filters [Florian Weingarten, fw42]
-* Make if, for & case tags return complete and consistent nodelists, see #250 [Nick Jones, dntj]
-* Prevent arbitrary method invocation on condition objects, see #274 [Dylan Thacker-Smith, dylanahsmith]
-* Don't call to_sym when creating conditions for security reasons, see #273 [Bouke van der Bijl, bouk]
-* Fix resource counting bug with respond_to?(:length), see #263 [Florian Weingarten, fw42]
-* Allow specifying custom patterns for template filenames, see #284 [Andrei Gladkyi, agladkyi]
-* Allow drops to optimize loading a slice of elements, see #282 [Tom Burns, boourns]
-* Support for passing variables to snippets in subdirs, see #271 [Joost Hietbrink, joost]
-* Add a class cache to avoid runtime extend calls, see #249 [James Tucker, raggi]
-* Remove some legacy Ruby 1.8 compatibility code, see #276 [Florian Weingarten, fw42]
-* Add default filter to standard filters, see #267 [Derrick Reimer, djreimer]
-* Add optional strict parsing and warn parsing, see #235 [Tristan Hume, trishume]
-* Add I18n syntax error translation, see #241 [Simon Hørup Eskildsen, Sirupsen]
-* Make sort filter work on enumerable drops, see #239 [Florian Weingarten, fw42]
-* Fix clashing method names in enumerable drops, see #238 [Florian Weingarten, fw42]
-* Make map filter work on enumerable drops, see #233 [Florian Weingarten, fw42]
-* Improved whitespace stripping for blank blocks, related to #216 [Florian Weingarten, fw42]
-
-## 2.6.0 / 2013-11-25 / branch "2.6-stable"
-
 IMPORTANT: Liquid 2.6 is going to be the last version of Liquid which maintains explicit Ruby 1.8 compatability.
 The following releases will only be tested against Ruby 1.9 and Ruby 2.0 and are likely to break on Ruby 1.8.
 
+## 2.6.0 / 2013-11-25 / branch "2.6-stable"
+
+* ...
 * Bugfix for #106: fix example servlet [gnowoel]
 * Bugfix for #97: strip_html filter supports multi-line tags [Jo Liss, joliss]
 * Bugfix for #114: strip_html filter supports style tags [James Allardice, jamesallardice]

README.md

@@ -1,10 +1,9 @@
-[![Build Status](https://secure.travis-ci.org/Shopify/liquid.png?branch=master)](http://travis-ci.org/Shopify/liquid)
 # Liquid template engine
 
 * [Contributing guidelines](CONTRIBUTING.md)
 * [Version history](History.md)
 * [Liquid documentation from Shopify](http://docs.shopify.com/themes/liquid-basics)
-* [Liquid Wiki at GitHub](https://github.com/Shopify/liquid/wiki)
+* [Liquid Wiki from Shopify](http://wiki.shopify.com/Liquid)
 * [Website](http://liquidmarkup.org/)
 
 ## Introduction
@@ -48,26 +47,4 @@ For standard use you can just pass it the content of a file and call render with
 @template.render('name' => 'tobi')                # => "hi tobi"
 ```
 
-### Error Modes
+[![Build Status](https://secure.travis-ci.org/Shopify/liquid.png)](http://travis-ci.org/Shopify/liquid)
-
-Setting the error mode of Liquid lets you specify how strictly you want your templates to be interpreted.
-Normally the parser is very lax and will accept almost anything without error. Unfortunately this can make
-it very hard to debug and can lead to unexpected behaviour. 
-
-Liquid also comes with a stricter parser that can be used when editing templates to give better error messages
-when templates are invalid. You can enable this new parser like this:
-
-```ruby
-Liquid::Template.error_mode = :strict # Raises a SyntaxError when invalid syntax is used
-Liquid::Template.error_mode = :warn # Adds errors to template.errors but continues as normal
-Liquid::Template.error_mode = :lax # The default mode, accepts almost anything.
-```
-
-If you want to set the error mode only on specific templates you can pass `:error_mode` as an option to `parse`:
-```ruby
-Liquid::Template.parse(source, :error_mode => :strict)
-```
-This is useful for doing things like enabling strict mode only in the theme editor.
-
-It is recommended that you enable `:strict` or `:warn` mode on new apps to stop invalid templates from being created.
-It is also recommended that you use it in the template editors of existing apps to give editors better error messages.

Rakefile

@@ -5,28 +5,12 @@ require "liquid/version"
 
 task :default => 'test'
 
-desc 'run test suite with default parser'
+Rake::TestTask.new(:test) do |t|
-Rake::TestTask.new(:base_test) do |t|
   t.libs << '.' << 'lib' << 'test'
   t.test_files = FileList['test/liquid/**/*_test.rb']
   t.verbose = false
 end
 
-desc 'run test suite with warn error mode'
-task :warn_test do
-  ENV['LIQUID_PARSER_MODE'] = 'warn'
-  Rake::Task['base_test'].invoke
-end
-
-desc 'runs test suite with both strict and lax parsers'
-task :test do
-  ENV['LIQUID_PARSER_MODE'] = 'lax'
-  Rake::Task['base_test'].invoke
-  ENV['LIQUID_PARSER_MODE'] = 'strict'
-  Rake::Task['base_test'].reenable
-  Rake::Task['base_test'].invoke
-end
-
 task :gem => :build
 task :build do
   system "gem build liquid.gemspec"
@@ -45,15 +29,11 @@ end
 
 namespace :benchmark do
 
-  desc "Run the liquid benchmark with lax parsing"
+  desc "Run the liquid benchmark"
   task :run do
-    ruby "./performance/benchmark.rb lax"
+    ruby "./performance/benchmark.rb"
   end
 
-  desc "Run the liquid benchmark with strict parsing"
-  task :strict do
-    ruby "./performance/benchmark.rb strict"
-  end
 end
 
 
@@ -64,9 +44,9 @@ namespace :profile do
     ruby "./performance/profile.rb"
   end
 
-  desc "Run the liquid profile/performance coverage with strict parsing"
+  desc "Run KCacheGrind"
-  task :strict do
+  task :grind => :run  do
-    ruby "./performance/profile.rb strict"
+    system "qcachegrind /tmp/liquid.rubyprof_calltreeprinter.txt"
   end
 
 end
@@ -75,11 +55,3 @@ desc "Run example"
 task :example do
   ruby "-w -d -Ilib example/server/server.rb"
 end
-
-if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'ruby'
-  require 'rake/extensiontask'
-  Rake::ExtensionTask.new "liquid" do |ext|
-    ext.lib_dir = "lib/liquid"
-  end
-  Rake::Task[:test].prerequisites << :compile
-end

example/server/liquid_servlet.rb

@@ -13,7 +13,7 @@ class LiquidServlet < WEBrick::HTTPServlet::AbstractServlet
   def handle(type, req, res)
     @request, @response = req, res
 
-    @request.path_info =~ /(\w+)\z/
+    @request.path_info =~ /(\w+)$/
     @action = $1 || 'index'
     @assigns = send(@action) if respond_to?(@action)
 

ext/liquid/extconf.rb

@@ -1,4 +0,0 @@
-require 'mkmf'
-$CFLAGS << ' -Wall -Werror'
-$warnflags.gsub!(/-Wdeclaration-after-statement/, "")
-create_makefile("liquid/liquid")

ext/liquid/liquid.c

@@ -1,9 +0,0 @@
-#include "liquid.h"
-
-VALUE mLiquid;
-
-void Init_liquid(void)
-{
-    mLiquid = rb_define_module("Liquid");
-    init_liquid_tokenizer();
-}

ext/liquid/liquid.h

@@ -1,11 +0,0 @@
-#ifndef LIQUID_H
-#define LIQUID_H
-
-#include <ruby.h>
-#include <stdbool.h>
-
-#include "tokenizer.h"
-
-extern VALUE mLiquid;
-
-#endif

ext/liquid/tokenizer.c

@@ -1,137 +0,0 @@
-#include "liquid.h"
-
-VALUE cLiquidTokenizer;
-
-static void tokenizer_mark(void *ptr) {
-    tokenizer_t *tokenizer = ptr;
-    rb_gc_mark(tokenizer->source);
-}
-
-static void tokenizer_free(void *ptr)
-{
-    tokenizer_t *tokenizer = ptr;
-    xfree(tokenizer);
-}
-
-static size_t tokenizer_memsize(const void *ptr)
-{
-    return ptr ? sizeof(tokenizer_t) : 0;
-}
-
-const rb_data_type_t tokenizer_data_type = {
-    "liquid_tokenizer",
-    {tokenizer_mark, tokenizer_free, tokenizer_memsize,},
-#ifdef RUBY_TYPED_FREE_IMMEDIATELY
-    NULL, NULL, RUBY_TYPED_FREE_IMMEDIATELY
-#endif
-};
-
-static VALUE tokenizer_allocate(VALUE klass)
-{
-    VALUE obj;
-    tokenizer_t *tokenizer;
-
-    obj = TypedData_Make_Struct(klass, tokenizer_t, &tokenizer_data_type, tokenizer);
-    tokenizer->source = Qnil;
-    return obj;
-}
-
-static VALUE tokenizer_initialize_method(VALUE self, VALUE source)
-{
-    tokenizer_t *tokenizer;
-
-    Check_Type(source, T_STRING);
-    Tokenizer_Get_Struct(self, tokenizer);
-    source = rb_str_dup_frozen(source);
-    tokenizer->source = source;
-    tokenizer->cursor = RSTRING_PTR(source);
-    tokenizer->length = RSTRING_LEN(source);
-    return Qnil;
-}
-
-void tokenizer_next(tokenizer_t *tokenizer, token_t *token)
-{
-    if (tokenizer->length <= 0) {
-        memset(token, 0, sizeof(*token));
-        return;
-    }
-
-    const char *cursor = tokenizer->cursor;
-    const char *last = cursor + tokenizer->length - 1;
-
-    token->str = cursor;
-    token->type = TOKEN_STRING;
-
-    while (cursor < last) {
-        if (*cursor++ != '{')
-            continue;
-
-        char c = *cursor++;
-        if (c != '%' && c != '{')
-            continue;
-        if (cursor - tokenizer->cursor > 2) {
-            token->type = TOKEN_STRING;
-            cursor -= 2;
-            goto found;
-        }
-        token->type = TOKEN_INVALID;
-        if (c == '%') {
-            while (cursor < last) {
-                if (*cursor++ != '%')
-                    continue;
-                c = *cursor++;
-                while (c == '%' && cursor <= last)
-                    c = *cursor++;
-                if (c != '}')
-                    continue;
-                token->type = TOKEN_TAG;
-                goto found;
-            }
-            // unterminated tag
-            cursor = tokenizer->cursor + 2;
-            goto found;
-        } else {
-            while (cursor < last) {
-                if (*cursor++ != '}')
-                    continue;
-                if (*cursor++ != '}') {
-                    // variable incomplete end, used to end raw tags
-                    cursor--;
-                    goto found;
-                }
-                token->type = TOKEN_VARIABLE;
-                goto found;
-            }
-            // unterminated variable
-            cursor = tokenizer->cursor + 2;
-            goto found;
-        }
-    }
-    cursor = last + 1;
-found:
-    token->length = cursor - tokenizer->cursor;
-    tokenizer->cursor += token->length;
-    tokenizer->length -= token->length;
-}
-
-static VALUE tokenizer_next_method(VALUE self)
-{
-    tokenizer_t *tokenizer;
-    Tokenizer_Get_Struct(self, tokenizer);
-
-    token_t token;
-    tokenizer_next(tokenizer, &token);
-    if (token.type == TOKEN_NONE)
-        return Qnil;
-
-    return rb_str_new(token.str, token.length);
-}
-
-void init_liquid_tokenizer()
-{
-    cLiquidTokenizer = rb_define_class_under(mLiquid, "Tokenizer", rb_cObject);
-    rb_define_alloc_func(cLiquidTokenizer, tokenizer_allocate);
-    rb_define_method(cLiquidTokenizer, "initialize", tokenizer_initialize_method, 1);
-    rb_define_method(cLiquidTokenizer, "next", tokenizer_next_method, 0);
-    rb_define_alias(cLiquidTokenizer, "shift", "next");
-}

ext/liquid/tokenizer.h

@@ -1,31 +0,0 @@
-#ifndef LIQUID_TOKENIZER_H
-#define LIQUID_TOKENIZER_H
-
-enum token_type {
-    TOKEN_NONE,
-    TOKEN_INVALID,
-    TOKEN_STRING,
-    TOKEN_TAG,
-    TOKEN_VARIABLE
-};
-
-typedef struct token {
-    enum token_type type;
-    const char *str;
-    long length;
-} token_t;
-
-typedef struct tokenizer {
-    VALUE source;
-    const char *cursor;
-    long length;
-} tokenizer_t;
-
-extern VALUE cLiquidTokenizer;
-extern const rb_data_type_t tokenizer_data_type;
-#define Tokenizer_Get_Struct(obj, sval) TypedData_Get_Struct(obj, tokenizer_t, &tokenizer_data_type, sval)
-
-void init_liquid_tokenizer();
-void tokenizer_next(tokenizer_t *tokenizer, token_t *token);
-
-#endif

lib/liquid.rb

@@ -21,25 +21,31 @@
 
 module Liquid
   FilterSeparator             = /\|/
-  ArgumentSeparator           = ','.freeze
+  ArgumentSeparator           = ','
-  FilterArgumentSeparator     = ':'.freeze
+  FilterArgumentSeparator     = ':'
-  VariableAttributeSeparator  = '.'.freeze
+  VariableAttributeSeparator  = '.'
   TagStart                    = /\{\%/
   TagEnd                      = /\%\}/
   VariableSignature           = /\(?[\w\-\.\[\]]\)?/
   VariableSegment             = /[\w\-]/
   VariableStart               = /\{\{/
   VariableEnd                 = /\}\}/
+  VariableIncompleteEnd       = /\}\}?/
   QuotedString                = /"[^"]*"|'[^']*'/
   QuotedFragment              = /#{QuotedString}|(?:[^\s,\|'"]|#{QuotedString})+/o
+  StrictQuotedFragment        = /"[^"]+"|'[^']+'|[^\s|:,]+/
+  FirstFilterArgument         = /#{FilterArgumentSeparator}(?:#{StrictQuotedFragment})/o
+  OtherFilterArgument         = /#{ArgumentSeparator}(?:#{StrictQuotedFragment})/o
+  SpacelessFilter             = /^(?:'[^']+'|"[^"]+"|[^'"])*#{FilterSeparator}(?:#{StrictQuotedFragment})(?:#{FirstFilterArgument}(?:#{OtherFilterArgument})*)?/o
+  Expression                  = /(?:#{QuotedFragment}(?:#{SpacelessFilter})*)/o
   TagAttributes               = /(\w+)\s*\:\s*(#{QuotedFragment})/o
+  AnyStartingTag              = /\{\{|\{\%/
+  PartialTemplateParser       = /#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableIncompleteEnd}/o
+  TemplateParser              = /(#{PartialTemplateParser}|#{AnyStartingTag})/o
   VariableParser              = /\[[^\]]+\]|#{VariableSegment}+\??/o
 end
 
 require "liquid/version"
-require 'liquid/lexer'
-require 'liquid/parser'
-require 'liquid/i18n'
 require 'liquid/drop'
 require 'liquid/extensions'
 require 'liquid/errors'
@@ -52,6 +58,7 @@ require 'liquid/document'
 require 'liquid/variable'
 require 'liquid/file_system'
 require 'liquid/template'
+require 'liquid/htmltags'
 require 'liquid/standardfilters'
 require 'liquid/condition'
 require 'liquid/module_ex'
@@ -60,9 +67,3 @@ require 'liquid/utils'
 # Load all the tags of the standard library
 #
 Dir[File.dirname(__FILE__) + '/liquid/tags/*.rb'].each { |f| require f }
-
-if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'ruby'
-  require 'liquid/liquid'
-else
-  require 'liquid/tokenizer'
-end

lib/liquid/block.rb

@@ -1,23 +1,17 @@
 module Liquid
-  class Block < Tag
-    IsTag             = /\A#{TagStart}/o
-    IsVariable        = /\A#{VariableStart}/o
-    FullToken         = /\A#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/om
-    ContentOfVariable = /\A#{VariableStart}(.*)#{VariableEnd}\z/om
 
-    def blank?
+  class Block < Tag
-      @blank || false
+    IsTag             = /^#{TagStart}/o
-    end
+    IsVariable        = /^#{VariableStart}/o
+    FullToken         = /^#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}$/o
+    ContentOfVariable = /^#{VariableStart}(.*)#{VariableEnd}$/o
 
     def parse(tokens)
-      @blank = true
       @nodelist ||= []
       @nodelist.clear
 
-      # All child tags of the current block.
-      @children = []
-
       while token = tokens.shift
+
         case token
         when IsTag
           if token =~ FullToken
@@ -31,28 +25,21 @@ module Liquid
 
             # fetch the tag from registered blocks
             if tag = Template.tags[$1]
-              new_tag = tag.parse($1, $2, tokens, @options)
+              @nodelist << tag.new($1, $2, tokens)
-              @blank &&= new_tag.blank?
-              @nodelist << new_tag
-              @children << new_tag
             else
               # this tag is not registered with the system
               # pass it to the current block for special handling or error reporting
               unknown_tag($1, $2, tokens)
             end
           else
-            raise SyntaxError.new(options[:locale].t("errors.syntax.tag_termination".freeze, :token => token, :tag_end => TagEnd.inspect))
+            raise SyntaxError, "Tag '#{token}' was not properly terminated with regexp: #{TagEnd.inspect} "
           end
         when IsVariable
-          new_var = create_variable(token)
+          @nodelist << create_variable(token)
-          @nodelist << new_var
+        when ''
-          @children << new_var
-          @blank = false
-        when ''.freeze
           # pass
         else
           @nodelist << token
-          @blank &&= (token =~ /\A\s*\z/)
         end
       end
 
@@ -62,32 +49,17 @@ module Liquid
       assert_missing_delimitation!
     end
 
-    # warnings of this block and all sub-tags
-    def warnings
-      all_warnings = []
-      all_warnings.concat(@warnings) if @warnings
-
-      (@children || []).each do |node|
-        all_warnings.concat(node.warnings || [])
-      end
-
-      all_warnings
-    end
-
     def end_tag
     end
 
     def unknown_tag(tag, params, tokens)
       case tag
-      when 'else'.freeze
+      when 'else'
-        raise SyntaxError.new(options[:locale].t("errors.syntax.unexpected_else".freeze,
+        raise SyntaxError, "#{block_name} tag does not expect else tag"
-                                                 :block_name => block_name))
+      when 'end'
-      when 'end'.freeze
+        raise SyntaxError, "'end' is not a valid delimiter for #{block_name} tags. use #{block_delimiter}"
-        raise SyntaxError.new(options[:locale].t("errors.syntax.invalid_delimiter".freeze,
-                                                 :block_name => block_name,
-                                                 :block_delimiter => block_delimiter))
       else
-        raise SyntaxError.new(options[:locale].t("errors.syntax.unknown_tag".freeze, :tag => tag))
+        raise SyntaxError, "Unknown tag '#{tag}'"
       end
     end
 
@@ -101,9 +73,9 @@ module Liquid
 
     def create_variable(token)
       token.scan(ContentOfVariable) do |content|
-        return Variable.new(content.first, @options)
+        return Variable.new(content.first)
       end
-      raise SyntaxError.new(options[:locale].t("errors.syntax.variable_termination".freeze, :token => token, :tag_end => VariableEnd.inspect))
+      raise SyntaxError.new("Variable '#{token}' was not properly terminated with regexp: #{VariableEnd.inspect} ")
     end
 
     def render(context)
@@ -113,7 +85,7 @@ module Liquid
     protected
 
     def assert_missing_delimitation!
-      raise SyntaxError.new(options[:locale].t("errors.syntax.tag_never_closed".freeze, :block_name => block_name))
+      raise SyntaxError.new("#{block_name} tag was never closed")
     end
 
     def render_all(list, context)
@@ -135,14 +107,12 @@ module Liquid
           end
 
           token_output = (token.respond_to?(:render) ? token.render(context) : token)
-          context.increment_used_resources(:render_length_current, token_output)
+          context.resource_limits[:render_length_current] += (token_output.respond_to?(:length) ? token_output.length : 1)
           if context.resource_limits_reached?
             context.resource_limits[:reached] = true
-            raise MemoryError.new("Memory limits exceeded".freeze)
+            raise MemoryError.new("Memory limits exceeded")
-          end
-          unless token.is_a?(Block) && token.blank?
-            output << token_output
           end
+          output << token_output
         rescue MemoryError => e
           raise e
         rescue ::StandardError => e

lib/liquid/condition.rb

@@ -8,14 +8,14 @@ module Liquid
   #
   class Condition #:nodoc:
     @@operators = {
-      '=='.freeze => lambda { |cond, left, right|  cond.send(:equal_variables, left, right) },
+      '==' => lambda { |cond, left, right|  cond.send(:equal_variables, left, right) },
-      '!='.freeze => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
+      '!=' => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
-      '<>'.freeze => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
+      '<>' => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
-      '<'.freeze  => :<,
+      '<'  => :<,
-      '>'.freeze  => :>,
+      '>'  => :>,
-      '>='.freeze => :>=,
+      '>=' => :>=,
-      '<='.freeze => :<=,
+      '<=' => :<=,
-      'contains'.freeze => lambda { |cond, left, right| left && right ? left.include?(right) : false }
+      'contains' => lambda { |cond, left, right| left && right ? left.include?(right) : false }
     }
 
     def self.operators
@@ -61,7 +61,7 @@ module Liquid
     end
 
     def inspect
-      "#<Condition #{[@left, @operator, @right].compact.join(' '.freeze)}>"
+      "#<Condition #{[@left, @operator, @right].compact.join(' ')}>"
     end
 
     private

lib/liquid/context.rb

@@ -25,15 +25,6 @@ module Liquid
       squash_instance_assigns_with_environments
 
       @interrupts = []
-      @filters = []
-    end
-
-    def increment_used_resources(key, obj)
-      @resource_limits[key] += if obj.kind_of?(String) || obj.kind_of?(Array) || obj.kind_of?(Hash)
-        obj.length
-      else
-        1
-      end
     end
 
     def resource_limits_reached?
@@ -43,7 +34,7 @@ module Liquid
     end
 
     def strainer
-      @strainer ||= Strainer.create(self, @filters)
+      @strainer ||= Strainer.create(self)
     end
 
     # Adds filters to this context.
@@ -52,20 +43,11 @@ module Liquid
     # for that
     def add_filters(filters)
       filters = [filters].flatten.compact
+
       filters.each do |f|
         raise ArgumentError, "Expected module but got: #{f.class}" unless f.is_a?(Module)
         Strainer.add_known_filter(f)
-      end
+        strainer.extend(f)
-
-      # If strainer is already setup then there's no choice but to use a runtime
-      # extend call. If strainer is not yet created, we can utilize strainers
-      # cached class based API, which avoids busting the method cache.
-      if @strainer
-        filters.each do |f|
-          strainer.extend(f)
-        end
-      else
-        @filters.concat filters
       end
     end
 
@@ -103,7 +85,7 @@ module Liquid
     # Push new local scope on the stack. use <tt>Context#stack</tt> instead
     def push(new_scope={})
       @scopes.unshift(new_scope)
-      raise StackLevelError, "Nesting too deep".freeze if @scopes.length > 100
+      raise StackLevelError, "Nesting too deep" if @scopes.length > 100
     end
 
     # Merge a hash of variables in the current local scope
@@ -151,11 +133,11 @@ module Liquid
 
     private
       LITERALS = {
-        nil => nil, 'nil'.freeze => nil, 'null'.freeze => nil, ''.freeze => nil,
+        nil => nil, 'nil' => nil, 'null' => nil, '' => nil,
-        'true'.freeze  => true,
+        'true'  => true,
-        'false'.freeze => false,
+        'false' => false,
-        'blank'.freeze => :blank?,
+        'blank' => :blank?,
-        'empty'.freeze => :empty?
+        'empty' => :empty?
       }
 
       # Look up variable, either resolve directly after considering the name. We can directly handle
@@ -171,15 +153,15 @@ module Liquid
           LITERALS[key]
         else
           case key
-          when /\A'(.*)'\z/m # Single quoted strings
+          when /^'(.*)'$/ # Single quoted strings
             $1
-          when /\A"(.*)"\z/m # Double quoted strings
+          when /^"(.*)"$/ # Double quoted strings
             $1
-          when /\A(-?\d+)\z/ # Integer and floats
+          when /^(-?\d+)$/ # Integer and floats
             $1.to_i
-          when /\A\((\S+)\.\.(\S+)\)\z/ # Ranges
+          when /^\((\S+)\.\.(\S+)\)$/ # Ranges
             (resolve($1).to_i..resolve($2).to_i)
-          when /\A(-?\d[\d\.]+)\z/ # Floats
+          when /^(-?\d[\d\.]+)$/ # Floats
             $1.to_f
           else
             variable(key)
@@ -218,7 +200,7 @@ module Liquid
       #  assert_equal 'tobi', @context['hash["name"]']
       def variable(markup)
         parts = markup.scan(VariableParser)
-        square_bracketed = /\A\[(.*)\]\z/m
+        square_bracketed = /^\[(.*)\]$/
 
         first_part = parts.shift
 
@@ -244,7 +226,7 @@ module 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'.freeze, 'first'.freeze, 'last'.freeze].include?(part)
+            elsif !part_resolved and object.respond_to?(part) and ['size', 'first', 'last'].include?(part)
 
               object = object.send(part.intern).to_liquid
 

lib/liquid/document.rb

@@ -1,8 +1,8 @@
 module Liquid
   class Document < Block
-    def self.parse(tokens, options={})
+    # we don't need markup to open this block
-      # we don't need markup to open this block
+    def initialize(tokens)
-      super(nil, nil, tokens, options)
+      parse(tokens)
     end
 
     # There isn't a real delimiter

lib/liquid/drop.rb

@@ -44,33 +44,17 @@ module Liquid
       true
     end
 
-    def inspect
-      self.class.to_s
-    end
-
     def to_liquid
       self
     end
 
-    def to_s
-      self.class.name
-    end
-
     alias :[] :invoke_drop
 
     private
 
     # Check for method existence without invoking respond_to?, which creates symbols
     def self.invokable?(method_name)
-      unless @invokable_methods
+      @invokable_methods ||= Set.new(["to_liquid"] + (public_instance_methods - Liquid::Drop.public_instance_methods).map(&:to_s))
-        blacklist = Liquid::Drop.public_instance_methods + [:each]
-        if include?(Enumerable)
-          blacklist += Enumerable.public_instance_methods
-          blacklist -= [:sort, :count, :first, :min, :max, :include?]
-        end
-        whitelist = [:to_liquid] + (public_instance_methods - blacklist)
-        @invokable_methods = Set.new(whitelist.map(&:to_s))
-      end
       @invokable_methods.include?(method_name.to_s)
     end
   end

lib/liquid/file_system.rb

@@ -31,22 +31,11 @@ module Liquid
   # file_system.full_path("mypartial")       # => "/some/path/_mypartial.liquid"
   # file_system.full_path("dir/mypartial")   # => "/some/path/dir/_mypartial.liquid"
   #
-  # Optionally in the second argument you can specify a custom pattern for template filenames.
-  # The Kernel::sprintf format specification is used.
-  # Default pattern is "_%s.liquid".
-  #
-  # Example:
-  #
-  # file_system = Liquid::LocalFileSystem.new("/some/path", "%s.html")
-  #
-  # file_system.full_path("index") # => "/some/path/index.html"
-  #
   class LocalFileSystem
     attr_accessor :root
 
-    def initialize(root, pattern = "_%s.liquid".freeze)
+    def initialize(root)
       @root = root
-      @pattern = pattern
     end
 
     def read_template_file(template_path, context)
@@ -57,15 +46,15 @@ module Liquid
     end
 
     def full_path(template_path)
-      raise FileSystemError, "Illegal template name '#{template_path}'" unless template_path =~ /\A[^.\/][a-zA-Z0-9_\/]+\z/
+      raise FileSystemError, "Illegal template name '#{template_path}'" unless template_path =~ /^[^.\/][a-zA-Z0-9_\/]+$/
 
-      full_path = if template_path.include?('/'.freeze)
+      full_path = if template_path.include?('/')
-        File.join(root, File.dirname(template_path), @pattern % File.basename(template_path))
+        File.join(root, File.dirname(template_path), "_#{File.basename(template_path)}.liquid")
       else
-        File.join(root, @pattern % template_path)
+        File.join(root, "_#{template_path}.liquid")
       end
 
-      raise FileSystemError, "Illegal template path '#{File.expand_path(full_path)}'" unless File.expand_path(full_path) =~ /\A#{File.expand_path(root)}/
+      raise FileSystemError, "Illegal template path '#{File.expand_path(full_path)}'" unless File.expand_path(full_path) =~ /^#{File.expand_path(root)}/
 
       full_path
     end

lib/liquid/htmltags.rb

@@ -0,0 +1,74 @@
+module Liquid
+  class TableRow < Block
+    Syntax = /(\w+)\s+in\s+(#{QuotedFragment}+)/o
+
+    def initialize(tag_name, markup, tokens)
+      if markup =~ Syntax
+        @variable_name = $1
+        @collection_name = $2
+        @attributes = {}
+        markup.scan(TagAttributes) do |key, value|
+          @attributes[key] = value
+        end
+      else
+        raise SyntaxError.new("Syntax Error in 'table_row loop' - Valid syntax: table_row [item] in [collection] cols=3")
+      end
+
+      super
+    end
+
+    def render(context)
+      collection = context[@collection_name] or return ''
+
+      from = @attributes['offset'] ? context[@attributes['offset']].to_i : 0
+      to = @attributes['limit'] ? from + context[@attributes['limit']].to_i : nil
+
+      collection = Utils.slice_collection_using_each(collection, from, to)
+
+      length = collection.length
+
+      cols = context[@attributes['cols']].to_i
+
+      row = 1
+      col = 0
+
+      result = "<tr class=\"row1\">\n"
+      context.stack do
+
+        collection.each_with_index do |item, index|
+          context[@variable_name] = item
+          context['tablerowloop'] = {
+            'length'  => length,
+            'index'   => index + 1,
+            'index0'  => index,
+            'col'     => col + 1,
+            'col0'    => col,
+            'index0'  => index,
+            'rindex'  => length - index,
+            'rindex0' => length - index - 1,
+            'first'   => (index == 0),
+            'last'    => (index == length - 1),
+            'col_first' => (col == 0),
+            'col_last'  => (col == cols - 1)
+          }
+
+
+          col += 1
+
+          result << "<td class=\"col#{col}\">" << render_all(@nodelist, context) << '</td>'
+
+          if col == cols and (index != length - 1)
+            col  = 0
+            row += 1
+            result << "</tr>\n<tr class=\"row#{row}\">"
+          end
+
+        end
+      end
+      result << "</tr>\n"
+      result
+    end
+  end
+
+  Template.register_tag('tablerow', TableRow)
+end

lib/liquid/i18n.rb

@@ -1,39 +0,0 @@
-require 'yaml'
-
-module Liquid
-  class I18n
-    DEFAULT_LOCALE = File.join(File.expand_path(File.dirname(__FILE__)), "locales", "en.yml")
-
-    class TranslationError < StandardError
-    end
-
-    attr_reader :path
-
-    def initialize(path = DEFAULT_LOCALE)
-      @path = path
-    end
-
-    def translate(name, vars = {})
-      interpolate(deep_fetch_translation(name), vars)
-    end
-    alias_method :t, :translate
-
-    def locale
-      @locale ||= YAML.load_file(@path)
-    end
-
-    private
-    def interpolate(name, vars)
-      name.gsub(/%\{(\w+)\}/) {
-        # raise TranslationError, "Undefined key #{$1} for interpolation in translation #{name}"  unless vars[$1.to_sym]
-        "#{vars[$1.to_sym]}"
-      }
-    end
-
-    def deep_fetch_translation(name)
-      name.split('.'.freeze).reduce(locale) do |level, cur|
-        level[cur] or raise TranslationError, "Translation for #{name} does not exist in locale #{path}"
-      end
-    end
-  end
-end

lib/liquid/interrupts.rb

@@ -5,7 +5,7 @@ module Liquid
     attr_reader :message
 
     def initialize(message=nil)
-      @message = message || "interrupt".freeze
+      @message = message || "interrupt"
     end
   end
 

lib/liquid/lexer.rb

@@ -1,51 +0,0 @@
-require "strscan"
-module Liquid
-  class Lexer
-    SPECIALS = {
-      '|'.freeze => :pipe,
-      '.'.freeze => :dot,
-      ':'.freeze => :colon,
-      ','.freeze => :comma,
-      '['.freeze => :open_square,
-      ']'.freeze => :close_square,
-      '('.freeze => :open_round,
-      ')'.freeze => :close_round
-    }
-    IDENTIFIER = /[\w\-?!]+/
-    SINGLE_STRING_LITERAL = /'[^\']*'/
-    DOUBLE_STRING_LITERAL = /"[^\"]*"/
-    NUMBER_LITERAL = /-?\d+(\.\d+)?/
-    DOTDOT = /\.\./
-    COMPARISON_OPERATOR = /==|!=|<>|<=?|>=?|contains/
-
-    def initialize(input)
-      @ss = StringScanner.new(input.rstrip)
-    end
-
-    def tokenize
-      @output = []
-
-      while !@ss.eos?
-        @ss.skip(/\s*/)
-        tok = case
-        when t = @ss.scan(COMPARISON_OPERATOR) then [:comparison, t]
-        when t = @ss.scan(SINGLE_STRING_LITERAL) then [:string, t]
-        when t = @ss.scan(DOUBLE_STRING_LITERAL) then [:string, t]
-        when t = @ss.scan(NUMBER_LITERAL) then [:number, t]
-        when t = @ss.scan(IDENTIFIER) then [:id, t]
-        when t = @ss.scan(DOTDOT) then [:dotdot, t]
-        else
-          c = @ss.getch
-          if s = SPECIALS[c]
-            [s,c]
-          else
-            raise SyntaxError, "Unexpected character #{c}"
-          end
-        end
-        @output << tok
-      end
-
-      @output << [:end_of_string]
-    end
-  end
-end

lib/liquid/locales/en.yml

@@ -1,22 +0,0 @@
----
-  errors:
-    syntax:
-      assign: "Syntax Error in 'assign' - Valid syntax: assign [var] = [source]"
-      capture: "Syntax Error in 'capture' - Valid syntax: capture [var]"
-      case: "Syntax Error in 'case' - Valid syntax: case [condition]"
-      case_invalid_when: "Syntax Error in tag 'case' - Valid when condition: {% when [condition] [or condition2...] %}"
-      case_invalid_else: "Syntax Error in tag 'case' - Valid else condition: {% else %} (no parameters) "
-      cycle: "Syntax Error in 'cycle' - Valid syntax: cycle [name :] var [, var2, var3 ...]"
-      for: "Syntax Error in 'for loop' - Valid syntax: for [item] in [collection]"
-      for_invalid_in: "For loops require an 'in' clause"
-      for_invalid_attribute: "Invalid attribute in for loop. Valid attributes are limit and offset"
-      if: "Syntax Error in tag 'if' - Valid syntax: if [expression]"
-      include: "Error in tag 'include' - Valid syntax: include '[template]' (with|for) [object|collection]"
-      unknown_tag: "Unknown tag '%{tag}'"
-      invalid_delimiter: "'end' is not a valid delimiter for %{block_name} tags. use %{block_delimiter}"
-      unexpected_else: "%{block_name} tag does not expect else tag"
-      tag_termination: "Tag '%{token}' was not properly terminated with regexp: %{tag_end}"
-      variable_termination: "Variable '%{token}' was not properly terminated with regexp: %{tag_end}"
-      tag_never_closed: "'%{block_name}' tag was never closed"
-      meta_syntax_error: "Liquid syntax error: #{e.message}"
-      table_row: "Syntax Error in 'table_row loop' - Valid syntax: table_row [item] in [collection] cols=3"

lib/liquid/parser.rb

@@ -1,90 +0,0 @@
-module Liquid
-  class Parser
-    def initialize(input)
-      l = Lexer.new(input)
-      @tokens = l.tokenize
-      @p = 0 # pointer to current location
-    end
-
-    def jump(point)
-      @p = point
-    end
-
-    def consume(type = nil)
-      token = @tokens[@p]
-      if type && token[0] != type
-        raise SyntaxError, "Expected #{type} but found #{@tokens[@p].first}"
-      end
-      @p += 1
-      token[1]
-    end
-
-    # Only consumes the token if it matches the type
-    # Returns the token's contents if it was consumed
-    # or false otherwise.
-    def consume?(type)
-      token = @tokens[@p]
-      return false unless token && token[0] == type
-      @p += 1
-      token[1]
-    end
-
-    # Like consume? Except for an :id token of a certain name
-    def id?(str)
-      token = @tokens[@p]
-      return false unless token && token[0] == :id
-      return false unless token[1] == str
-      @p += 1
-      token[1]
-    end
-
-    def look(type, ahead = 0)
-      tok = @tokens[@p + ahead]
-      return false unless tok
-      tok[0] == type
-    end
-
-    def expression
-      token = @tokens[@p]
-      if token[0] == :id
-        variable_signature
-      elsif [:string, :number].include? token[0]
-        consume
-      elsif token.first == :open_round
-        consume
-        first = expression
-        consume(:dotdot)
-        last = expression
-        consume(:close_round)
-        "(#{first}..#{last})"
-      else
-        raise SyntaxError, "#{token} is not a valid expression"
-      end
-    end
-
-    def argument
-      str = ""
-      # might be a keyword argument (identifier: expression)
-      if look(:id) && look(:colon, 1)
-        str << consume << consume << ' '.freeze
-      end
-
-      str << expression
-      str
-    end
-
-    def variable_signature
-      str = consume(:id)
-      if look(:open_square)
-        str << consume
-        str << expression
-        str << consume(:close_square)
-      end
-      if look(:dot)
-        str << consume
-        str << variable_signature
-      end
-      str
-    end
-  end
-end

lib/liquid/standardfilters.rb

@@ -4,17 +4,10 @@ require 'bigdecimal'
 module Liquid
 
   module StandardFilters
-    HTML_ESCAPE = {
-      '&'.freeze => '&'.freeze,
-      '>'.freeze => '>'.freeze,
-      '<'.freeze => '&lt;'.freeze,
-      '"'.freeze => '&quot;'.freeze,
-      "'".freeze => '&#39;'.freeze
-    }
-    HTML_ESCAPE_ONCE_REGEXP = /["><']|&(?!([a-zA-Z]+|(#\d+));)/
 
     # Return the size of an array or of an string
     def size(input)
+
       input.respond_to?(:size) ? input.size : 0
     end
 
@@ -38,25 +31,28 @@ module Liquid
     end
 
     def escape_once(input)
-      input.to_s.gsub(HTML_ESCAPE_ONCE_REGEXP, HTML_ESCAPE)
+      ActionView::Helpers::TagHelper.escape_once(input)
+    rescue NameError
+      input
     end
 
     alias_method :h, :escape
 
     # Truncate a string down to x characters
-    def truncate(input, length = 50, truncate_string = "...".freeze)
+    def truncate(input, length = 50, truncate_string = "...")
       if input.nil? then return end
       l = length.to_i - truncate_string.length
       l = 0 if l < 0
-      input.length > length.to_i ? input[0...l] + truncate_string : input
+      truncated = RUBY_VERSION[0,3] == "1.8" ? input.scan(/./mu)[0...l].to_s : input[0...l]
+      input.length > length.to_i ? truncated + truncate_string : input
     end
 
-    def truncatewords(input, words = 15, truncate_string = "...".freeze)
+    def truncatewords(input, words = 15, truncate_string = "...")
       if input.nil? then return end
       wordlist = input.to_s.split
       l = words.to_i - 1
       l = 0 if l < 0
-      wordlist.length > l ? wordlist[0..l].join(" ".freeze) + truncate_string : input
+      wordlist.length > l ? wordlist[0..l].join(" ") + truncate_string : input
     end
 
     # Split input string into an array of substrings separated by given pattern.
@@ -68,40 +64,27 @@ module Liquid
       input.split(pattern)
     end
 
-    def strip(input)
-      input.to_s.strip
-    end
-
-    def lstrip(input)
-      input.to_s.lstrip
-    end
-
-    def rstrip(input)
-      input.to_s.rstrip
-    end
-
     def strip_html(input)
-      empty = ''.freeze
+      input.to_s.gsub(/<script.*?<\/script>/m, '').gsub(/<!--.*?-->/m, '').gsub(/<style.*?<\/style>/m, '').gsub(/<.*?>/m, '')
-      input.to_s.gsub(/<script.*?<\/script>/m, empty).gsub(/<!--.*?-->/m, empty).gsub(/<style.*?<\/style>/m, empty).gsub(/<.*?>/m, empty)
     end
 
     # Remove all newlines from the string
     def strip_newlines(input)
-      input.to_s.gsub(/\r?\n/, ''.freeze)
+      input.to_s.gsub(/\r?\n/, '')
     end
 
     # Join elements of the array with certain character between them
-    def join(input, glue = ' '.freeze)
+    def join(input, glue = ' ')
       [input].flatten.join(glue)
     end
 
     # Sort elements of the array
     # provide optional property with which to sort an array of hashes or drops
     def sort(input, property = nil)
-      ary = flatten_if_necessary(input)
+      ary = [input].flatten
       if property.nil?
         ary.sort
-      elsif ary.first.respond_to?('[]'.freeze) and !ary.first[property].nil?
+      elsif ary.first.respond_to?('[]') and !ary.first[property].nil?
         ary.sort {|a,b| a[property] <=> b[property] }
       elsif ary.first.respond_to?(property)
         ary.sort {|a,b| a.send(property) <=> b.send(property) }
@@ -116,10 +99,12 @@ module Liquid
 
     # map/collect on a given property
     def map(input, property)
-      flatten_if_necessary(input).map do |e|
+      ary = [input].flatten
+      ary.map do |e|
         e = e.call if e.is_a?(Proc)
+        e = e.to_liquid if e.respond_to?(:to_liquid)
 
-        if property == "to_liquid".freeze
+        if property == "to_liquid"
           e
         elsif e.respond_to?(:[])
           e[property]
@@ -128,23 +113,23 @@ module Liquid
     end
 
     # Replace occurrences of a string with another
-    def replace(input, string, replacement = ''.freeze)
+    def replace(input, string, replacement = '')
       input.to_s.gsub(string, replacement.to_s)
     end
 
     # Replace the first occurrences of a string with another
-    def replace_first(input, string, replacement = ''.freeze)
+    def replace_first(input, string, replacement = '')
       input.to_s.sub(string, replacement.to_s)
     end
 
     # remove a substring
     def remove(input, string)
-      input.to_s.gsub(string, ''.freeze)
+      input.to_s.gsub(string, '')
     end
 
     # remove the first occurrences of a substring
     def remove_first(input, string)
-      input.to_s.sub(string, ''.freeze)
+      input.to_s.sub(string, '')
     end
 
     # add one string to another
@@ -159,7 +144,7 @@ module Liquid
 
     # Add <br /> tags in front of all newlines in input string
     def newline_to_br(input)
-      input.to_s.gsub(/\n/, "<br />\n".freeze)
+      input.to_s.gsub(/\n/, "<br />\n")
     end
 
     # Reformat a date
@@ -196,13 +181,13 @@ module Liquid
         return input.to_s
       end
 
-      if ((input.is_a?(String) && !/\A\d+\z/.match(input.to_s).nil?) || input.is_a?(Integer)) && input.to_i > 0
+      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 = if input.is_a?(String)
         case input.downcase
-        when 'now'.freeze, 'today'.freeze
+        when 'now', 'today'
           Time.now
         else
           Time.parse(input)
@@ -262,24 +247,8 @@ module Liquid
       apply_operation(input, operand, :%)
     end
 
-    def default(input, default_value = "".freeze)
-      is_blank = input.respond_to?(:empty?) ? input.empty? : !input
-      is_blank ? default_value : input
-    end
-
     private
 
-    def flatten_if_necessary(input)
-      ary = if input.is_a?(Array)
-        input.flatten
-      elsif input.is_a?(Enumerable) && !input.is_a?(Hash)
-        input
-      else
-        [input].flatten
-      end
-      ary.map{ |e| e.respond_to?(:to_liquid) ? e.to_liquid : e }
-    end
-
     def to_number(obj)
       case obj
       when Float
@@ -287,7 +256,7 @@ module Liquid
       when Numeric
         obj
       when String
-        (obj.strip =~ /\A\d+\.\d+\z/) ? BigDecimal.new(obj) : obj.to_i
+        (obj.strip =~ /^\d+\.\d+$/) ? BigDecimal.new(obj) : obj.to_i
       else
         0
       end

lib/liquid/strainer.rb

@@ -11,11 +11,6 @@ module Liquid
     @@filters = []
     @@known_filters = Set.new
     @@known_methods = Set.new
-    @@strainer_class_cache = Hash.new do |hash, filters|
-      hash[filters] = Class.new(Strainer) do
-        filters.each { |f| include f }
-      end
-    end
 
     def initialize(context)
       @context = context
@@ -37,13 +32,10 @@ module Liquid
       end
     end
 
-    def self.strainer_class_cache
+    def self.create(context)
-      @@strainer_class_cache
+      strainer = Strainer.new(context)
-    end
+      @@filters.each { |m| strainer.extend(m) }
-
+      strainer
-    def self.create(context, filters = [])
-      filters = @@filters + filters
-      strainer_class_cache[filters].new(context)
     end
 
     def invoke(method, *args)
@@ -52,8 +44,6 @@ module Liquid
       else
         args.first
       end
-    rescue ::ArgumentError => e
-      raise Liquid::ArgumentError.new(e.message)
     end
 
     def invokable?(method)

lib/liquid/tag.rb

@@ -1,22 +1,13 @@
 module Liquid
+
   class Tag
-    attr_accessor :options
-    attr_reader :nodelist, :warnings
 
-    class << self
+    attr_accessor :nodelist
-      def parse(tag_name, markup, tokens, options)
-        tag = new(tag_name, markup, options)
-        tag.parse(tokens)
-        tag
-      end
 
-      private :new
+    def initialize(tag_name, markup, tokens)
-    end
-
-    def initialize(tag_name, markup, options)
       @tag_name   = tag_name
       @markup     = markup
-      @options    = options
+      parse(tokens)
     end
 
     def parse(tokens)
@@ -27,34 +18,9 @@ module Liquid
     end
 
     def render(context)
-      ''.freeze
+      ''
     end
 
-    def blank?
-      @blank || false
-    end
-
-    def parse_with_selected_parser(markup)
-      case @options[:error_mode] || Template.error_mode
-      when :strict then strict_parse_with_error_context(markup)
-      when :lax    then lax_parse(markup)
-      when :warn
-        begin
-          return strict_parse_with_error_context(markup)
-        rescue SyntaxError => e
-          @warnings ||= []
-          @warnings << e
-          return lax_parse(markup)
-        end
-      end
-    end
-
-    private
-    def strict_parse_with_error_context(markup)
-      strict_parse(markup)
-    rescue SyntaxError => e
-      e.message << " in \"#{markup.strip}\"" 
-      raise e
-    end
   end # Tag
+
 end # Liquid

lib/liquid/tags/assign.rb

@@ -9,29 +9,27 @@ module Liquid
   #  {{ foo }}
   #
   class Assign < Tag
-    Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/om
+    Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/o
 
-    def initialize(tag_name, markup, options)
+    def initialize(tag_name, markup, tokens)
-      super
       if markup =~ Syntax
         @to = $1
         @from = Variable.new($2)
       else
-        raise SyntaxError.new options[:locale].t("errors.syntax.assign".freeze)
+        raise SyntaxError.new("Syntax Error in 'assign' - Valid syntax: assign [var] = [source]")
       end
+
+      super
     end
 
     def render(context)
       val = @from.render(context)
       context.scopes.last[@to] = val
-      context.increment_used_resources(:assign_score_current, val)
+      context.resource_limits[:assign_score_current] += (val.respond_to?(:length) ? val.length : 1)
-      ''.freeze
+      ''
     end
 
-    def blank?
-      true
-    end
   end
 
-  Template.register_tag('assign'.freeze, Assign)
+  Template.register_tag('assign', Assign)
 end

lib/liquid/tags/break.rb

@@ -17,5 +17,5 @@ module Liquid
 
   end
 
-  Template.register_tag('break'.freeze, Break)
+  Template.register_tag('break', Break)
 end

lib/liquid/tags/capture.rb

@@ -14,26 +14,23 @@ module Liquid
   class Capture < Block
     Syntax = /(\w+)/
 
-    def initialize(tag_name, markup, options)
+    def initialize(tag_name, markup, tokens)
-      super
       if markup =~ Syntax
         @to = $1
       else
-        raise SyntaxError.new(options[:locale].t("errors.syntax.capture"))
+        raise SyntaxError.new("Syntax Error in 'capture' - Valid syntax: capture [var]")
       end
+
+      super
     end
 
     def render(context)
       output = super
       context.scopes.last[@to] = output
-      context.increment_used_resources(:assign_score_current, output)
+      context.resource_limits[:assign_score_current] += (output.respond_to?(:length) ? output.length : 1)
-      ''.freeze
+      ''
-    end
-
-    def blank?
-      true
     end
   end
 
-  Template.register_tag('capture'.freeze, Capture)
+  Template.register_tag('capture', Capture)
 end

lib/liquid/tags/case.rb

@@ -1,29 +1,26 @@
 module Liquid
   class Case < Block
     Syntax     = /(#{QuotedFragment})/o
-    WhenSyntax = /(#{QuotedFragment})(?:(?:\s+or\s+|\s*\,\s*)(#{QuotedFragment}.*))?/om
+    WhenSyntax = /(#{QuotedFragment})(?:(?:\s+or\s+|\s*\,\s*)(#{QuotedFragment}.*))?/o
 
-    def initialize(tag_name, markup, options)
+    def initialize(tag_name, markup, tokens)
-      super
       @blocks = []
 
       if markup =~ Syntax
         @left = $1
       else
-        raise SyntaxError.new(options[:locale].t("errors.syntax.case".freeze))
+        raise SyntaxError.new("Syntax Error in tag 'case' - Valid syntax: case [condition]")
       end
-    end
 
-    def nodelist
+      super
-      @blocks.map(&:attachment).flatten
     end
 
     def unknown_tag(tag, markup, tokens)
       @nodelist = []
       case tag
-      when 'when'.freeze
+      when 'when'
         record_when_condition(markup)
-      when 'else'.freeze
+      when 'else'
         record_else_condition(markup)
       else
         super
@@ -53,27 +50,30 @@ module Liquid
       while markup
         # Create a new nodelist and assign it to the new block
         if not markup =~ WhenSyntax
-          raise SyntaxError.new(options[:locale].t("errors.syntax.case_invalid_when".freeze))
+          raise SyntaxError.new("Syntax Error in tag 'case' - Valid when condition: {% when [condition] [or condition2...] %} ")
         end
 
         markup = $2
 
-        block = Condition.new(@left, '=='.freeze, $1)
+        block = Condition.new(@left, '==', $1)
         block.attach(@nodelist)
         @blocks.push(block)
       end
     end
 
     def record_else_condition(markup)
+
       if not markup.strip.empty?
-        raise SyntaxError.new(options[:locale].t("errors.syntax.case_invalid_else".freeze))
+        raise SyntaxError.new("Syntax Error in tag 'case' - Valid else condition: {% else %} (no parameters) ")
       end
 
       block = ElseCondition.new
       block.attach(@nodelist)
       @blocks << block
     end
+
+
   end
 
-  Template.register_tag('case'.freeze, Case)
+  Template.register_tag('case', Case)
 end

lib/liquid/tags/comment.rb

@@ -1,16 +1,9 @@
 module Liquid
   class Comment < Block
     def render(context)
-      ''.freeze
+      ''
-    end
-
-    def unknown_tag(tag, markup, tokens)
-    end
-
-    def blank?
-      true
     end
   end
 
-  Template.register_tag('comment'.freeze, Comment)
+  Template.register_tag('comment', Comment)
 end

lib/liquid/tags/continue.rb

@@ -1,4 +1,5 @@
 module Liquid
+
   # Continue tag to be used to break out of a for loop.
   #
   # == Basic Usage:
@@ -9,10 +10,12 @@ module Liquid
   #    {% endfor %}
   #
   class Continue < Tag
+
     def interrupt
       ContinueInterrupt.new
     end
+
   end
 
-  Template.register_tag('continue'.freeze, Continue)
+  Template.register_tag('continue', Continue)
 end

lib/liquid/tags/cycle.rb

@@ -1,4 +1,5 @@
 module Liquid
+
   # Cycle is usually used within a loop to alternate between values, like colors or DOM classes.
   #
   #   {% for item in items %}
@@ -12,11 +13,10 @@ module Liquid
   #    <div class="green"> Item five</div>
   #
   class Cycle < Tag
-    SimpleSyntax = /\A#{QuotedFragment}+/o
+    SimpleSyntax = /^#{QuotedFragment}+/o
-    NamedSyntax  = /\A(#{QuotedFragment})\s*\:\s*(.*)/om
+    NamedSyntax  = /^(#{QuotedFragment})\s*\:\s*(.*)/o
 
-    def initialize(tag_name, markup, options)
+    def initialize(tag_name, markup, tokens)
-      super
       case markup
       when NamedSyntax
         @variables = variables_from_string($2)
@@ -25,8 +25,9 @@ module Liquid
         @variables = variables_from_string(markup)
         @name = "'#{@variables.to_s}'"
       else
-        raise SyntaxError.new(options[:locale].t("errors.syntax.cycle".freeze))
+        raise SyntaxError.new("Syntax Error in 'cycle' - Valid syntax: cycle [name :] var [, var2, var3 ...]")
       end
+      super
     end
 
     def render(context)
@@ -43,17 +44,15 @@ module Liquid
       end
     end
 
-    def blank?
-      false
-    end
-
     private
+
     def variables_from_string(markup)
       markup.split(',').collect do |var|
         var =~ /\s*(#{QuotedFragment})\s*/o
         $1 ? $1 : nil
       end.compact
     end
+
   end
 
   Template.register_tag('cycle', Cycle)

lib/liquid/tags/decrement.rb

@@ -19,9 +19,10 @@ module Liquid
   #    Hello: -3
   #
   class Decrement < Tag
-    def initialize(tag_name, markup, options)
+    def initialize(tag_name, markup, tokens)
-      super
       @variable = markup.strip
+
+      super
     end
 
     def render(context)
@@ -34,5 +35,5 @@ module Liquid
     private
   end
 
-  Template.register_tag('decrement'.freeze, Decrement)
+  Template.register_tag('decrement', Decrement)
 end

lib/liquid/tags/for.rb

@@ -44,24 +44,28 @@ module Liquid
   # forloop.last:: Returns true if the item is the last item.
   #
   class For < Block
-    Syntax = /\A(#{VariableSegment}+)\s+in\s+(#{QuotedFragment}+)\s*(reversed)?/o
+    Syntax = /\A(\w+)\s+in\s+(#{QuotedFragment}+)\s*(reversed)?/o
 
-    def initialize(tag_name, markup, options)
+    def initialize(tag_name, markup, tokens)
-      super
+      if markup =~ Syntax
-      parse_with_selected_parser(markup)
+        @variable_name = $1
-      @nodelist = @for_block = []
+        @collection_name = $2
-    end
+        @name = "#{$1}-#{$2}"
-
+        @reversed = $3
-    def nodelist
+        @attributes = {}
-      if @else_block
+        markup.scan(TagAttributes) do |key, value|
-        @for_block + @else_block
+          @attributes[key] = value
+        end
       else
-        @for_block
+        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'.freeze
+      return super unless tag == 'else'
       @nodelist = @else_block = []
     end
 
@@ -74,16 +78,17 @@ module Liquid
       # Maintains Ruby 1.8.7 String#each behaviour on 1.9
       return render_else(context) unless iterable?(collection)
 
-      from = if @attributes['offset'.freeze] == 'continue'.freeze
+      from = if @attributes['offset'] == 'continue'
         context.registers[:for][@name].to_i
       else
-        context[@attributes['offset'.freeze]].to_i
+        context[@attributes['offset']].to_i
       end
 
-      limit = context[@attributes['limit'.freeze]]
+      limit = context[@attributes['limit']]
       to    = limit ? limit.to_i + from : nil
 
-      segment = Utils.slice_collection(collection, from, to)
+
+      segment = Utils.slice_collection_using_each(collection, from, to)
 
       return render_else(context) if segment.empty?
 
@@ -99,16 +104,15 @@ module Liquid
       context.stack do
         segment.each_with_index do |item, index|
           context[@variable_name] = item
-          context['forloop'.freeze] = {
+          context['forloop'] = {
-            'name'.freeze    => @name,
+            'name'    => @name,
-            'length'.freeze  => length,
+            'length'  => length,
-            'index'.freeze   => index + 1,
+            'index'   => index + 1,
-            'index0'.freeze  => index,
+            'index0'  => index,
-            'rindex'.freeze  => length - index,
+            'rindex'  => length - index,
-            'rindex0'.freeze => length - index - 1,
+            'rindex0' => length - index - 1,
-            'first'.freeze   => (index == 0),
+            'first'   => (index == 0),
-            'last'.freeze    => (index == length - 1)
+          'last'    => (index == length - 1) }
-          }
 
           result << render_all(@for_block, context)
 
@@ -123,53 +127,16 @@ module Liquid
       result
     end
 
-    protected
-
-    def lax_parse(markup)
-      if markup =~ Syntax
-        @variable_name = $1
-        @collection_name = $2
-        @name = "#{$1}-#{$2}"
-        @reversed = $3
-        @attributes = {}
-        markup.scan(TagAttributes) do |key, value|
-          @attributes[key] = value
-        end
-      else
-        raise SyntaxError.new(options[:locale].t("errors.syntax.for".freeze))
-      end
-    end
-
-    def strict_parse(markup)
-      p = Parser.new(markup)
-      @variable_name = p.consume(:id)
-      raise SyntaxError.new(options[:locale].t("errors.syntax.for_invalid_in".freeze))  unless p.id?('in'.freeze)
-      @collection_name = p.expression
-      @name = "#{@variable_name}-#{@collection_name}"
-      @reversed = p.id?('reversed'.freeze)
-
-      @attributes = {}
-      while p.look(:id) && p.look(:colon, 1)
-        unless attribute = p.id?('limit'.freeze) || p.id?('offset'.freeze)
-          raise SyntaxError.new(options[:locale].t("errors.syntax.for_invalid_attribute".freeze))
-        end
-        p.consume
-        val = p.expression
-        @attributes[attribute] = val
-      end
-      p.consume(:end_of_string)
-    end
-
     private
 
-    def render_else(context)
+      def render_else(context)
-      return @else_block ? [render_all(@else_block, context)] : ''.freeze
+        return @else_block ? [render_all(@else_block, context)] : ''
-    end
+      end
 
-    def iterable?(collection)
+      def iterable?(collection)
-      collection.respond_to?(:each) || Utils.non_blank_string?(collection)
+        collection.respond_to?(:each) || Utils.non_blank_string?(collection)
-    end
+      end
   end
 
-  Template.register_tag('for'.freeze, For)
+  Template.register_tag('for', For)
 end

lib/liquid/tags/if.rb

@@ -1,4 +1,5 @@
 module Liquid
+
   # If is the conditional block
   #
   #   {% if user.admin %}
@@ -9,23 +10,22 @@ module Liquid
   #
   #    There are {% if count < 5 %} less {% else %} more {% endif %} items than you need.
   #
+  #
   class If < Block
+    SyntaxHelp = "Syntax Error in tag 'if' - Valid syntax: if [expression]"
     Syntax = /(#{QuotedFragment})\s*([=!<>a-z_]+)?\s*(#{QuotedFragment})?/o
     ExpressionsAndOperators = /(?:\b(?:\s?and\s?|\s?or\s?)\b|(?:\s*(?!\b(?:\s?and\s?|\s?or\s?)\b)(?:#{QuotedFragment}|\S+)\s*)+)/o
-    BOOLEAN_OPERATORS = %w(and or)
 
-    def initialize(tag_name, markup, options)
+    def initialize(tag_name, markup, tokens)
-      super
       @blocks = []
-      push_block('if'.freeze, markup)
-    end
 
-    def nodelist
+      push_block('if', markup)
-      @blocks.map(&:attachment).flatten
+
+      super
     end
 
     def unknown_tag(tag, markup, tokens)
-      if ['elsif'.freeze, 'else'.freeze].include?(tag)
+      if ['elsif', 'else'].include?(tag)
         push_block(tag, markup)
       else
         super
@@ -39,68 +39,41 @@ module Liquid
             return render_all(block.attachment, context)
           end
         end
-        ''.freeze
+        ''
       end
     end
 
     private
 
       def push_block(tag, markup)
-        block = if tag == 'else'.freeze
+        block = if tag == 'else'
           ElseCondition.new
         else
-          parse_with_selected_parser(markup)
+
+          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
 
-      def lax_parse(markup)
-        expressions = markup.scan(ExpressionsAndOperators).reverse
-        raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.shift =~ Syntax
 
-        condition = Condition.new($1, $2, $3)
-
-        while not expressions.empty?
-          operator = (expressions.shift).to_s.strip
-
-          raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.shift.to_s =~ Syntax
-
-          new_condition = Condition.new($1, $2, $3)
-          raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless BOOLEAN_OPERATORS.include?(operator)
-          new_condition.send(operator, condition)
-          condition = new_condition
-        end
-
-        condition
-      end
-
-      def strict_parse(markup)
-        p = Parser.new(markup)
-
-        condition = parse_comparison(p)
-
-        while op = (p.id?('and'.freeze) || p.id?('or'.freeze))
-          new_cond = parse_comparison(p)
-          new_cond.send(op, condition)
-          condition = new_cond
-        end
-        p.consume(:end_of_string)
-
-        condition
-      end
-
-      def parse_comparison(p)
-        a = p.expression
-        if op = p.consume?(:comparison)
-          b = p.expression
-          Condition.new(a, op, b)
-        else
-          Condition.new(a)
-        end
-      end
   end
 
-  Template.register_tag('if'.freeze, If)
+  Template.register_tag('if', If)
 end

lib/liquid/tags/ifchanged.rb

@@ -10,11 +10,11 @@ module Liquid
           context.registers[:ifchanged] = output
           output
         else
-          ''.freeze
+          ''
         end
       end
     end
   end
 
-  Template.register_tag('ifchanged'.freeze, Ifchanged)
+  Template.register_tag('ifchanged', Ifchanged)
 end

lib/liquid/tags/include.rb

@@ -17,9 +17,7 @@ module Liquid
   class Include < Tag
     Syntax = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?/o
 
-    def initialize(tag_name, markup, options)
+    def initialize(tag_name, markup, tokens)
-      super
-
       if markup =~ Syntax
 
         @template_name = $1
@@ -31,17 +29,15 @@ module Liquid
         end
 
       else
-        raise SyntaxError.new(options[:locale].t("errors.syntax.include".freeze))
+        raise SyntaxError.new("Error in tag 'include' - Valid syntax: include '[template]' (with|for) [object|collection]")
       end
+
+      super
     end
 
     def parse(tokens)
     end
 
-    def blank?
-      false
-    end
-
     def render(context)
       partial = load_cached_partial(context)
       variable = context[@variable_name || @template_name[1..-2]]
@@ -51,14 +47,13 @@ module Liquid
           context[key] = context[value]
         end
 
-        context_variable_name = @template_name[1..-2].split('/'.freeze).last
         if variable.is_a?(Array)
           variable.collect do |var|
-            context[context_variable_name] = var
+            context[@template_name[1..-2]] = var
             partial.render(context)
           end
         else
-          context[context_variable_name] = variable
+          context[@template_name[1..-2]] = variable
           partial.render(context)
         end
       end
@@ -94,5 +89,5 @@ module Liquid
       end
   end
 
-  Template.register_tag('include'.freeze, Include)
+  Template.register_tag('include', Include)
 end

lib/liquid/tags/increment.rb

@@ -1,11 +1,12 @@
 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:
@@ -15,9 +16,10 @@ module Liquid
   #    Hello: 2
   #
   class Increment < Tag
-    def initialize(tag_name, markup, options)
+    def initialize(tag_name, markup, tokens)
-      super
       @variable = markup.strip
+
+      super
     end
 
     def render(context)
@@ -26,10 +28,8 @@ module Liquid
       value.to_s
     end
 
-    def blank?
+    private
-      false
-    end
   end
 
-  Template.register_tag('increment'.freeze, Increment)
+  Template.register_tag('increment', Increment)
 end

lib/liquid/tags/raw.rb

@@ -1,13 +1,13 @@
 module Liquid
   class Raw < Block
-    FullTokenPossiblyInvalid = /\A(.*)#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/om
+    FullTokenPossiblyInvalid = /^(.*)#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}$/o
 
     def parse(tokens)
       @nodelist ||= []
       @nodelist.clear
       while token = tokens.shift
         if token =~ FullTokenPossiblyInvalid
-          @nodelist << $1 if $1 != "".freeze
+          @nodelist << $1 if $1 != ""
           if block_delimiter == $2
             end_tag
             return
@@ -18,5 +18,5 @@ module Liquid
     end
   end
 
-  Template.register_tag('raw'.freeze, Raw)
+  Template.register_tag('raw', Raw)
 end

lib/liquid/tags/table_row.rb

@@ -1,73 +0,0 @@
-module Liquid
-  class TableRow < Block
-    Syntax = /(\w+)\s+in\s+(#{QuotedFragment}+)/o
-
-    def initialize(tag_name, markup, options)
-      super
-      if markup =~ Syntax
-        @variable_name = $1
-        @collection_name = $2
-        @attributes = {}
-        markup.scan(TagAttributes) do |key, value|
-          @attributes[key] = value
-        end
-      else
-        raise SyntaxError.new(options[:locale].t("errors.syntax.table_row".freeze))
-      end
-    end
-
-    def render(context)
-      collection = context[@collection_name] or return ''.freeze
-
-      from = @attributes['offset'.freeze] ? context[@attributes['offset'.freeze]].to_i : 0
-      to = @attributes['limit'.freeze] ? from + context[@attributes['limit'.freeze]].to_i : nil
-
-      collection = Utils.slice_collection(collection, from, to)
-
-      length = collection.length
-
-      cols = context[@attributes['cols'.freeze]].to_i
-
-      row = 1
-      col = 0
-
-      result = "<tr class=\"row1\">\n"
-      context.stack do
-
-        collection.each_with_index do |item, index|
-          context[@variable_name] = item
-          context['tablerowloop'.freeze] = {
-            'length'.freeze    => length,
-            'index'.freeze     => index + 1,
-            'index0'.freeze    => index,
-            'col'.freeze       => col + 1,
-            'col0'.freeze      => col,
-            'index0'.freeze    => index,
-            'rindex'.freeze    => length - index,
-            'rindex0'.freeze   => length - index - 1,
-            'first'.freeze     => (index == 0),
-            'last'.freeze      => (index == length - 1),
-            'col_first'.freeze => (col == 0),
-            'col_last'.freeze  => (col == cols - 1)
-          }
-
-
-          col += 1
-
-          result << "<td class=\"col#{col}\">" << render_all(@nodelist, context) << '</td>'
-
-          if col == cols and (index != length - 1)
-            col  = 0
-            row += 1
-            result << "</tr>\n<tr class=\"row#{row}\">"
-          end
-
-        end
-      end
-      result << "</tr>\n"
-      result
-    end
-  end
-
-  Template.register_tag('tablerow'.freeze, TableRow)
-end

lib/liquid/tags/unless.rb

@@ -1,6 +1,7 @@
 require File.dirname(__FILE__) + '/if'
 
 module Liquid
+
   # Unless is a conditional just like 'if' but works on the inverse logic.
   #
   #   {% unless x < 0 %} x is greater than zero {% end %}
@@ -22,10 +23,11 @@ module Liquid
           end
         end
 
-        ''.freeze
+        ''
       end
     end
   end
 
-  Template.register_tag('unless'.freeze, Unless)
+
+  Template.register_tag('unless', Unless)
 end

lib/liquid/template.rb

@@ -14,10 +14,6 @@ module Liquid
   #   template.render('user_name' => 'bob')
   #
   class Template
-    DEFAULT_OPTIONS = {
-      :locale => I18n.new
-    }
-
     attr_accessor :root, :resource_limits
     @@file_system = BlankFileSystem.new
 
@@ -38,18 +34,6 @@ module Liquid
         @tags ||= {}
       end
 
-      # Sets how strict the parser should be.
-      # :lax acts like liquid 2.5 and silently ignores malformed tags in most cases.
-      # :warn is the default and will give deprecation warnings when invalid syntax is used.
-      # :strict will enforce correct syntax.
-      def error_mode=(mode)
-        @error_mode = mode
-      end
-
-      def error_mode
-        @error_mode || :lax
-      end
-
       # Pass a module with filter methods which should be available
       # to all liquid views. Good for registering the standard library
       def register_filter(mod)
@@ -57,9 +41,9 @@ module Liquid
       end
 
       # creates a new <tt>Template</tt> object from liquid source code
-      def parse(source, options = {})
+      def parse(source)
         template = Template.new
-        template.parse(source, options)
+        template.parse(source)
         template
       end
     end
@@ -71,17 +55,11 @@ module Liquid
 
     # Parse source code.
     # Returns self for easy chaining
-    def parse(source, options = {})
+    def parse(source)
-      @root = Document.parse(tokenize(source), DEFAULT_OPTIONS.merge(options))
+      @root = Document.new(tokenize(source))
-      @warnings = nil
       self
     end
 
-    def warnings
-      return [] unless @root
-      @warnings ||= @root.warnings
-    end
-
     def registers
       @registers ||= {}
     end
@@ -110,7 +88,7 @@ module Liquid
     #    filters and tags and might be useful to integrate liquid more with its host application
     #
     def render(*args)
-      return ''.freeze if @root.nil?
+      return '' if @root.nil?
 
       context = case args.first
       when Liquid::Context
@@ -123,7 +101,7 @@ module Liquid
       when nil
         Context.new(assigns, instance_assigns, registers, @rethrow_errors, @resource_limits)
       else
-        raise ArgumentError, "Expected Hash or Liquid::Context as parameter"
+        raise ArgumentError, "Expect Hash or Liquid::Context as parameter"
       end
 
       case args.last
@@ -162,9 +140,16 @@ module Liquid
 
     private
 
+    # Uses the <tt>Liquid::TemplateParser</tt> regexp to tokenize the passed source
     def tokenize(source)
       source = source.source if source.respond_to?(:source)
-      Tokenizer.new(source.to_s)
+      return [] if source.to_s.empty?
+      tokens = source.split(TemplateParser)
+
+      # removes the rogue empty element at the beginning of the array
+      tokens.shift if tokens[0] and tokens[0].empty?
+
+      tokens
     end
 
   end

lib/liquid/tokenizer.rb

@@ -1,20 +0,0 @@
-module Liquid
-  class Tokenizer
-    VariableIncompleteEnd = /\}\}?/
-    AnyStartingTag        = /\{\{|\{\%/
-    PartialTemplateParser = /#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableIncompleteEnd}/om
-    TemplateParser        = /(#{PartialTemplateParser}|#{AnyStartingTag})/om
-
-    def initialize(source)
-      @tokens = source.split(TemplateParser)
-
-      # removes the rogue empty element at the beginning of the array
-      @tokens.shift if @tokens[0] && @tokens[0].empty?
-    end
-
-    def next
-      @tokens.shift
-    end
-    alias_method :shift, :next
-  end
-end

lib/liquid/utils.rb

@@ -1,18 +1,5 @@
 module Liquid
   module Utils
-
-    def self.slice_collection(collection, from, to)
-      if (from != 0 || to != nil) && collection.respond_to?(:load_slice)
-        collection.load_slice(from, to)
-      else
-        slice_collection_using_each(collection, from, to)
-      end
-    end
-
-    def self.non_blank_string?(collection)
-      collection.is_a?(String) && collection != ''.freeze
-    end
-
     def self.slice_collection_using_each(collection, from, to)
       segments = []
       index = 0
@@ -35,5 +22,9 @@ module Liquid
 
       segments
     end
+
+    def self.non_blank_string?(collection)
+      collection.is_a?(String) && collection != ''
+    end
   end
 end

lib/liquid/variable.rb

@@ -12,33 +12,15 @@ module Liquid
   #
   class Variable
     FilterParser = /(?:#{FilterSeparator}|(?:\s*(?:#{QuotedFragment}|#{ArgumentSeparator})\s*)+)/o
-    EasyParse = /\A *(\w+(?:\.\w+)*) *\z/
+    attr_accessor :filters, :name
-    attr_accessor :filters, :name, :warnings
 
-    def initialize(markup, options = {})
+    def initialize(markup)
       @markup  = markup
       @name    = nil
-      @options = options || {}
-
-      case @options[:error_mode] || Template.error_mode
-      when :strict then strict_parse(markup)
-      when :lax    then lax_parse(markup)
-      when :warn
-        begin
-          strict_parse(markup)
-        rescue SyntaxError => e
-          @warnings ||= []
-          @warnings << e
-          lax_parse(markup)
-        end
-      end
-    end
-
-    def lax_parse(markup)
       @filters = []
-      if match = markup.match(/\s*(#{QuotedFragment})(.*)/om)
+      if match = markup.match(/\s*(#{QuotedFragment})(.*)/o)
         @name = match[1]
-        if match[2].match(/#{FilterSeparator}\s*(.*)/om)
+        if match[2].match(/#{FilterSeparator}\s*(.*)/o)
           filters = Regexp.last_match(1).scan(FilterParser)
           filters.each do |f|
             if matches = f.match(/\s*(\w+)/)
@@ -51,41 +33,8 @@ module Liquid
       end
     end
 
-    def strict_parse(markup)
-      # Very simple valid cases
-      if markup =~ EasyParse
-        @name = $1
-        @filters = []
-        return
-      end
-
-      @filters = []
-      p = Parser.new(markup)
-      # Could be just filters with no input
-      @name = p.look(:pipe) ? ''.freeze : p.expression
-      while p.consume?(:pipe)
-        filtername = p.consume(:id)
-        filterargs = p.consume?(:colon) ? parse_filterargs(p) : []
-        @filters << [filtername, filterargs]
-      end
-      p.consume(:end_of_string)
-    rescue SyntaxError => e
-      e.message << " in \"{{#{markup}}}\""
-      raise e
-    end
-
-    def parse_filterargs(p)
-      # first argument
-      filterargs = [p.argument]
-      # followed by comma separated others
-      while p.consume?(:comma)
-        filterargs << p.argument
-      end
-      filterargs
-    end
-
     def render(context)
-      return ''.freeze if @name.nil?
+      return '' if @name.nil?
       @filters.inject(context[@name]) do |output, filter|
         filterargs = []
         keyword_args = {}

lib/liquid/version.rb

@@ -1,4 +1,4 @@
 # encoding: utf-8
 module Liquid
-  VERSION = "3.0.0".freeze
+  VERSION = "2.6.0"
 end

liquid.gemspec

@@ -12,23 +12,14 @@ Gem::Specification.new do |s|
   s.authors     = ["Tobias Luetke"]
   s.email       = ["tobi@leetsoft.com"]
   s.homepage    = "http://www.liquidmarkup.org"
-  s.license     = "MIT"
   #s.description = "A secure, non-evaling end user template engine with aesthetic markup."
 
   s.required_rubygems_version = ">= 1.3.7"
 
   s.test_files  = Dir.glob("{test}/**/*")
-  s.files       = Dir.glob("{lib,ext}/**/*") + %w(MIT-LICENSE README.md)
+  s.files       = Dir.glob("{lib}/**/*") + %w(MIT-LICENSE README.md)
 
   s.extra_rdoc_files  = ["History.md", "README.md"]
 
   s.require_path = "lib"
-
-  s.add_development_dependency 'rake'
-  s.add_development_dependency 'activesupport'
-  if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'ruby'
-    s.extensions  = ['ext/liquid/extconf.rb']
-    s.add_development_dependency 'rake-compiler'
-    s.add_development_dependency 'stackprof' if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.1.0")
-  end
 end

performance/benchmark.rb

@@ -2,7 +2,6 @@ require 'rubygems'
 require 'benchmark'
 require File.dirname(__FILE__) + '/theme_runner'
 
-Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
 profiler = ThemeRunner.new
 
 Benchmark.bmbm do |x|

performance/profile.rb

@@ -1,13 +1,19 @@
-require 'stackprof' rescue fail("install stackprof extension/gem")
+require 'rubygems'
+require 'ruby-prof' rescue fail("install ruby-prof extension/gem")
 require File.dirname(__FILE__) + '/theme_runner'
 
-Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
 profiler = ThemeRunner.new
-profiler.run
+
-results = StackProf.run(mode: :cpu) do
+puts 'Running profiler...'
-  100.times do
+
-    profiler.run
+results  = profiler.run
-  end
+
+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" : "/callgrind.liquid.#{klass.name.downcase}.txt")
+  filename.gsub!(/:+/, '_')
+  File.open(filename, "w+") { |fp| klass.new(results).print(fp, :print_file => true) }
+  $stderr.puts "wrote #{klass.name} output to #{filename}"
 end
-StackProf::Report.new(results).print_text(false, 20)
-File.write(ENV['FILENAME'], Marshal.dump(results)) if ENV['FILENAME']

performance/shopify/comment_form.rb

@@ -1,15 +1,15 @@
 class CommentForm < Liquid::Block
   Syntax = /(#{Liquid::VariableSignature}+)/
 
-  def initialize(tag_name, markup, options)
+  def initialize(tag_name, markup, tokens)
-    super
-
     if markup =~ Syntax
       @variable_name = $1
       @attributes = {}
     else
       raise SyntaxError.new("Syntax Error in 'comment_form' - Valid syntax: comment_form [article]")
     end
+
+    super
   end
 
   def render(context)

performance/shopify/paginate.rb

@@ -1,9 +1,7 @@
 class Paginate < Liquid::Block
   Syntax     = /(#{Liquid::QuotedFragment})\s*(by\s*(\d+))?/
 
-  def initialize(tag_name, markup, options)
+  def initialize(tag_name, markup, tokens)
-    super
-
     @nodelist = []
 
     if markup =~ Syntax
@@ -21,6 +19,8 @@ class Paginate < Liquid::Block
     else
       raise SyntaxError.new("Syntax Error in tag 'paginate' - Valid syntax: paginate [collection] by number")
     end
+
+    super
   end
 
   def render(context)

performance/shopify/shop_filter.rb

@@ -45,16 +45,16 @@ module ShopFilter
   end
 
   def url_for_vendor(vendor_title)
-    "/collections/#{to_handle(vendor_title)}"
+    "/collections/#{vendor_title.to_handle}"
   end
 
   def url_for_type(type_title)
-    "/collections/#{to_handle(type_title)}"
+    "/collections/#{type_title.to_handle}"
   end
 
   def product_img_url(url, style = 'small')
 
-    unless url =~ /\Aproducts\/([\w\-\_]+)\.(\w{2,4})/
+    unless url =~ /^products\/([\w\-\_]+)\.(\w{2,4})/
       raise ArgumentError, 'filter "size" can only be called on product images'
     end
 
@@ -95,16 +95,4 @@ module ShopFilter
     input == 1 ? singular : plural
   end
 
-  private
-
-  def to_handle(str)
-    result = str.dup
-    result.downcase!
-    result.delete!("'\"()[]")
-    result.gsub!(/\W+/, '-')
-    result.gsub!(/-+\z/, '') if result[-1] == '-'
-    result.gsub!(/\A-+/, '') if result[0] == '-'
-    result
-  end
-
 end

performance/tests/dropify/index.liquid

@@ -28,7 +28,7 @@
   {% else %}
     <div class="article-body textile">
     In <em>Admin &gt; Blogs &amp; Pages</em>, create a page with the handle <strong><code>frontpage</code></strong> and it will show up here.<br />
-    {{ "Learn more about handles" | link_to: "http://wiki.shopify.com/Handle" }}
+    {{ "Learn more about handles" | link_to "http://wiki.shopify.com/Handle" }}
     </div>
   {% endif %}
 

performance/tests/ripen/index.liquid

@@ -26,7 +26,7 @@
       {{ article.content }}
     {% else %}
       In <em>Admin &gt; Blogs &amp; Pages</em>, create a page with the handle <strong><code>frontpage</code></strong> and it will show up here.<br />
-      {{ "Learn more about handles" | link_to: "http://wiki.shopify.com/Handle" }}
+      {{ "Learn more about handles" | link_to "http://wiki.shopify.com/Handle" }}
     {% endif %}
   </div>
 </div>

performance/tests/vogue/index.liquid

@@ -5,7 +5,7 @@
       {{ article.content }}
     {% else %}
       In <em>Admin &gt; Blogs &amp; Pages</em>, create a page with the handle <strong><code>frontpage</code></strong> and it will show up here.<br />
-      {{ "Learn more about handles" | link_to: "http://wiki.shopify.com/Handle" }}
+      {{ "Learn more about handles" | link_to "http://wiki.shopify.com/Handle" }}
     {% endif %}
   </div>
 

performance/theme_runner.rb

@@ -8,7 +8,6 @@
 
 require 'rubygems'
 require 'active_support'
-require 'active_support/json'
 require 'yaml'
 require 'digest/md5'
 require File.dirname(__FILE__) + '/shopify/liquid'
@@ -65,17 +64,52 @@ class ThemeRunner
   end
 
 
+  def run_profile
+    RubyProf.measure_mode = RubyProf::WALL_TIME
+
+    # 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))
+
+      unless @started
+        RubyProf.start
+        RubyProf.pause
+        @started = true
+      end
+
+      html = nil
+
+      RubyProf.resume
+      html = compile_and_render(liquid, layout, assigns, page_template, template_name)
+      RubyProf.pause
+
+
+      # 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)]
+
+      # 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
+  end
+
   def compile_and_render(template, layout, assigns, page_template, template_file)
     tmpl = Liquid::Template.new
     tmpl.assigns['page_title'] = 'Page title'
     tmpl.assigns['template'] = page_template
     tmpl.registers[:file_system] = ThemeRunner::FileSystem.new(File.dirname(template_file))
 
-    content_for_layout = tmpl.parse(template).render!(assigns)
+    content_for_layout = tmpl.parse(template).render(assigns)
 
     if layout
       assigns['content_for_layout'] = content_for_layout
-      tmpl.parse(layout).render!(assigns)
+      tmpl.parse(layout).render(assigns)
     else
       content_for_layout
     end

test/fixtures/en_locale.yml

@@ -1,9 +0,0 @@
----
-  simple: "less is more"
-  whatever: "something %{something}"
-  errors:
-    i18n:
-      undefined_interpolation: "undefined key %{key}"
-      unknown_translation: "translation '%{name}' wasn't found"
-    syntax:
-      oops: "something wasn't right"

test/liquid/assign_test.rb

@@ -18,10 +18,4 @@ class AssignTest < Test::Unit::TestCase
                            '{% assign foo = values | split: "," %}.{{ foo[1] }}.',
                            'values' => "foo,bar,baz")
   end
-
-  def test_assign_syntax_error
-    assert_match_syntax_error(/assign/,
-                       '{% assign foo not values %}.',
-                       'values' => "foo,bar,baz")
-  end
 end # AssignTest

test/liquid/blank_test.rb

@@ -1,106 +0,0 @@
-require 'test_helper'
-
-class FoobarTag < Liquid::Tag
-  def render(*args)
-    " "
-  end
-
-  Liquid::Template.register_tag('foobar', FoobarTag)
-end
-
-class BlankTestFileSystem
-  def read_template_file(template_path, context)
-    template_path
-  end
-end
-
-class BlankTest < Test::Unit::TestCase
-  include Liquid
-  N = 10
-
-  def wrap_in_for(body)
-    "{% for i in (1..#{N}) %}#{body}{% endfor %}"
-  end
-
-  def wrap_in_if(body)
-    "{% if true %}#{body}{% endif %}"
-  end
-
-  def wrap(body)
-    wrap_in_for(body) + wrap_in_if(body)
-  end
-
-  def test_new_tags_are_not_blank_by_default
-    assert_template_result(" "*N, wrap_in_for("{% foobar %}"))
-  end
-
-  def test_loops_are_blank
-    assert_template_result("", wrap_in_for(" "))
-  end
-
-  def test_if_else_are_blank
-    assert_template_result("", "{% if true %} {% elsif false %} {% else %} {% endif %}")
-  end
-
-  def test_unless_is_blank
-    assert_template_result("", wrap("{% unless true %} {% endunless %}"))
-  end
-
-  def test_mark_as_blank_only_during_parsing
-    assert_template_result(" "*(N+1), wrap(" {% if false %} this never happens, but still, this block is not blank {% endif %}"))
-  end
-
-  def test_comments_are_blank
-    assert_template_result("", wrap(" {% comment %} whatever {% endcomment %} "))
-  end
-
-  def test_captures_are_blank
-    assert_template_result("", wrap(" {% capture foo %} whatever {% endcapture %} "))
-  end
-
-  def test_nested_blocks_are_blank_but_only_if_all_children_are
-    assert_template_result("", wrap(wrap(" ")))
-    assert_template_result("\n       but this is not "*(N+1),
-      wrap(%q{{% if true %} {% comment %} this is blank {% endcomment %} {% endif %}
-      {% if true %} but this is not {% endif %}}))
-  end
-
-  def test_assigns_are_blank
-    assert_template_result("", wrap(' {% assign foo = "bar" %} '))
-  end
-
-  def test_whitespace_is_blank
-    assert_template_result("", wrap(" "))
-    assert_template_result("", wrap("\t"))
-  end
-
-  def test_whitespace_is_not_blank_if_other_stuff_is_present
-    body = "     x "
-    assert_template_result(body*(N+1), wrap(body))
-  end
-
-  def test_increment_is_not_blank
-    assert_template_result(" 0"*2*(N+1), wrap("{% assign foo = 0 %} {% increment foo %} {% decrement foo %}"))
-  end
-
-  def test_cycle_is_not_blank
-    assert_template_result("  "*((N+1)/2)+" ", wrap("{% cycle ' ', ' ' %}"))
-  end
-
-  def test_raw_is_not_blank
-    assert_template_result("  "*(N+1), wrap(" {% raw %} {% endraw %}"))
-  end
-
-  def test_include_is_blank
-    Liquid::Template.file_system = BlankTestFileSystem.new
-    assert_template_result "foobar"*(N+1), wrap("{% include 'foobar' %}")
-    assert_template_result " foobar "*(N+1), wrap("{% include ' foobar ' %}")
-    assert_template_result "   "*(N+1), wrap(" {% include ' ' %} ")
-  end
-
-  def test_case_is_blank
-    assert_template_result("", wrap(" {% assign foo = 'bar' %} {% case foo %} {% when 'bar' %} {% when 'whatever' %} {% else %} {% endcase %} "))
-    assert_template_result("", wrap(" {% assign foo = 'else' %} {% case foo %} {% when 'bar' %} {% when 'whatever' %} {% else %} {% endcase %} "))
-    assert_template_result("   x  "*(N+1), wrap(" {% assign foo = 'else' %} {% case foo %} {% when 'bar' %} {% when 'whatever' %} {% else %} x {% endcase %} "))
-  end
-end

test/liquid/capture_test.rb

@@ -19,7 +19,7 @@ class CaptureTest < Test::Unit::TestCase
     {{var}}
     END_TEMPLATE
     template = Template.parse(template_source)
-    rendered = template.render!
+    rendered = template.render
     assert_equal "test-string", rendered.gsub(/\s/, '')
   end
 
@@ -34,7 +34,7 @@ class CaptureTest < Test::Unit::TestCase
     {{ first }}-{{ second }}
     END_TEMPLATE
     template = Template.parse(template_source)
-    rendered = template.render!
+    rendered = template.render
     assert_equal "3-3", rendered.gsub(/\s/, '')
   end
 end # CaptureTest

test/liquid/context_test.rb

@@ -176,8 +176,8 @@ class ContextTest < Test::Unit::TestCase
     end
 
     Template.register_filter(global)
-    assert_equal 'Global test', Template.parse("{{'test' | notice }}").render!
+    assert_equal 'Global test', Template.parse("{{'test' | notice }}").render
-    assert_equal 'Local test', Template.parse("{{'test' | notice }}").render!({}, :filters => [local])
+    assert_equal 'Local test', Template.parse("{{'test' | notice }}").render({}, :filters => [local])
   end
 
   def test_only_intended_filters_make_it_there

test/liquid/drop_test.rb

@@ -55,44 +55,11 @@ class ProductDrop < Liquid::Drop
 end
 
 class EnumerableDrop < Liquid::Drop
-  def before_method(method)
-    method
-  end
 
   def size
     3
   end
 
-  def first
-    1
-  end
-
-  def count
-    3
-  end
-
-  def min
-    1
-  end
-
-  def max
-    3
-  end
-
-  def each
-    yield 1
-    yield 2
-    yield 3
-  end
-end
-
-class RealEnumerableDrop < Liquid::Drop
-  include Enumerable
-
-  def before_method(method)
-    method
-  end
-
   def each
     yield 1
     yield 2
@@ -106,140 +73,108 @@ class DropsTest < Test::Unit::TestCase
   def test_product_drop
     assert_nothing_raised do
       tpl = Liquid::Template.parse( '  '  )
-      tpl.render!('product' => ProductDrop.new)
+      tpl.render('product' => ProductDrop.new)
     end
   end
 
   def test_drop_does_only_respond_to_whitelisted_methods
-    assert_equal "", Liquid::Template.parse("{{ product.inspect }}").render!('product' => ProductDrop.new)
+    assert_equal "", Liquid::Template.parse("{{ product.inspect }}").render('product' => ProductDrop.new)
-    assert_equal "", Liquid::Template.parse("{{ product.pretty_inspect }}").render!('product' => ProductDrop.new)
+    assert_equal "", Liquid::Template.parse("{{ product.pretty_inspect }}").render('product' => ProductDrop.new)
-    assert_equal "", Liquid::Template.parse("{{ product.whatever }}").render!('product' => ProductDrop.new)
+    assert_equal "", Liquid::Template.parse("{{ product.whatever }}").render('product' => ProductDrop.new)
-    assert_equal "", Liquid::Template.parse('{{ product | map: "inspect" }}').render!('product' => ProductDrop.new)
+    assert_equal "", Liquid::Template.parse('{{ product | map: "inspect" }}').render('product' => ProductDrop.new)
-    assert_equal "", Liquid::Template.parse('{{ product | map: "pretty_inspect" }}').render!('product' => ProductDrop.new)
+    assert_equal "", Liquid::Template.parse('{{ product | map: "pretty_inspect" }}').render('product' => ProductDrop.new)
-    assert_equal "", Liquid::Template.parse('{{ product | map: "whatever" }}').render!('product' => ProductDrop.new)
+    assert_equal "", Liquid::Template.parse('{{ product | map: "whatever" }}').render('product' => ProductDrop.new)
   end
 
   def test_drops_respond_to_to_liquid
-    assert_equal "text1", Liquid::Template.parse("{{ product.to_liquid.texts.text }}").render!('product' => ProductDrop.new)
+    assert_equal "text1", Liquid::Template.parse("{{ product.to_liquid.texts.text }}").render('product' => ProductDrop.new)
-    assert_equal "text1", Liquid::Template.parse('{{ product | map: "to_liquid" | map: "texts" | map: "text" }}').render!('product' => ProductDrop.new)
+    assert_equal "text1", Liquid::Template.parse('{{ product | map: "to_liquid" | map: "texts" | map: "text" }}').render('product' => ProductDrop.new)
   end
 
   def test_text_drop
-    output = Liquid::Template.parse( ' {{ product.texts.text }} '  ).render!('product' => ProductDrop.new)
+    output = Liquid::Template.parse( ' {{ product.texts.text }} '  ).render('product' => ProductDrop.new)
     assert_equal ' text1 ', output
   end
 
   def test_unknown_method
-    output = Liquid::Template.parse( ' {{ product.catchall.unknown }} '  ).render!('product' => ProductDrop.new)
+    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)
+    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)
+    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")
+    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")
+    output = Liquid::Template.parse( ' {{ product.context.foo }} '  ).render('product' => ProductDrop.new, 'foo' => "monkey")
     assert_equal ' monkey ', output
   end
 
   def test_protected
-    output = Liquid::Template.parse( ' {{ product.callmenot }} '  ).render!('product' => ProductDrop.new)
+    output = Liquid::Template.parse( ' {{ product.callmenot }} '  ).render('product' => ProductDrop.new)
     assert_equal '  ', output
   end
 
   def test_object_methods_not_allowed
     [:dup, :clone, :singleton_class, :eval, :class_eval, :inspect].each do |method|
-      output = Liquid::Template.parse(" {{ product.#{method} }} ").render!('product' => ProductDrop.new)
+      output = Liquid::Template.parse(" {{ product.#{method} }} ").render('product' => ProductDrop.new)
       assert_equal '  ', output
     end
   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 '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])
+    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 '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])
+    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"%}{{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 '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 '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 '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 '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 '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])
+    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)
+    assert_equal '123', Liquid::Template.parse( '{% for c in collection %}{{c}}{% endfor %}').render('collection' => EnumerableDrop.new)
   end
 
   def test_enumerable_drop_size
-    assert_equal '3', Liquid::Template.parse( '{{collection.size}}').render!('collection' => EnumerableDrop.new)
+    assert_equal '3', Liquid::Template.parse( '{{collection.size}}').render('collection' => EnumerableDrop.new)
-  end
-
-  def test_enumerable_drop_will_invoke_before_method_for_clashing_method_names
-    ["select", "each", "map", "cycle"].each do |method|
-      assert_equal method.to_s, Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new)
-      assert_equal method.to_s, Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new)
-      assert_equal method.to_s, Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new)
-      assert_equal method.to_s, Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new)
-    end
-  end
-
-  def test_some_enumerable_methods_still_get_invoked
-    [ :count, :max ].each do |method|
-      assert_equal "3", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new)
-      assert_equal "3", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new)
-      assert_equal "3", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new)
-      assert_equal "3", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new)
-    end
-
-    assert_equal "yes", Liquid::Template.parse("{% if collection contains 3 %}yes{% endif %}").render!('collection' => RealEnumerableDrop.new)
-
-    [ :min, :first ].each do |method|
-      assert_equal "1", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new)
-      assert_equal "1", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new)
-      assert_equal "1", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new)
-      assert_equal "1", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new)
-    end
   end
 
   def test_empty_string_value_access
-    assert_equal '', Liquid::Template.parse('{{ product[value] }}').render!('product' => ProductDrop.new, 'value' => '')
+    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)
+    assert_equal '', Liquid::Template.parse('{{ product[value] }}').render('product' => ProductDrop.new, 'value' => nil)
-  end
-
-  def test_default_to_s_on_drops
-    assert_equal 'ProductDrop', Liquid::Template.parse("{{ product }}").render!('product' => ProductDrop.new)
-    assert_equal 'EnumerableDrop', Liquid::Template.parse('{{ collection }}').render!('collection' => EnumerableDrop.new)
   end
 end # DropsTest

test/liquid/error_handling_test.rb

@@ -58,48 +58,19 @@ class ErrorHandlingTest < Test::Unit::TestCase
 
   def test_missing_endtag_parse_time_error
     assert_raise(Liquid::SyntaxError) do
-      Liquid::Template.parse(' {% for a in b %} ... ')
+      template = Liquid::Template.parse(' {% for a in b %} ... ')
     end
   end
 
   def test_unrecognized_operator
-    with_error_mode(:strict) do
-      assert_raise(SyntaxError) do
-        Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ')
-      end
-    end
-  end
-  
-  def test_lax_unrecognized_operator
     assert_nothing_raised do
-      template = Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', :error_mode => :lax)
+      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
 
-  def test_strict_error_messages
-    err = assert_raise(SyntaxError) do
-      Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', :error_mode => :strict)
-    end
-    assert_equal 'Unexpected character = in "1 =! 2"', err.message
-
-    err = assert_raise(SyntaxError) do
-      Liquid::Template.parse('{{%%%}}', :error_mode => :strict)
-    end
-    assert_equal 'Unexpected character % in "{{%%%}}"', err.message
-  end
-
-  def test_warnings
-    template = Liquid::Template.parse('{% if ~~~ %}{{%%%}}{% else %}{{ hello. }}{% endif %}', :error_mode => :warn)
-    assert_equal 3, template.warnings.size
-    assert_equal 'Unexpected character ~ in "~~~"', template.warnings[0].message
-    assert_equal 'Unexpected character % in "{{%%%}}"', template.warnings[1].message
-    assert_equal 'Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].message
-    assert_equal '', template.render
-  end
-
   # Liquid should not catch Exceptions that are not subclasses of StandardError, like Interrupt and NoMemoryError
   def test_exceptions_propagate
     assert_raise Exception do

test/liquid/file_system_test.rb

@@ -26,10 +26,4 @@ class FileSystemTest < Test::Unit::TestCase
       file_system.full_path("/etc/passwd")
     end
   end
-
-  def test_custom_template_filename_patterns
-    file_system = Liquid::LocalFileSystem.new("/some/path", "%s.html")
-    assert_equal "/some/path/mypartial.html"    , file_system.full_path("mypartial")
-    assert_equal "/some/path/dir/mypartial.html", file_system.full_path("dir/mypartial")
-  end
 end # FileSystemTest

test/liquid/filter_test.rb

@@ -113,13 +113,13 @@ class FiltersInTemplate < Test::Unit::TestCase
   def test_local_global
     Template.register_filter(MoneyFilter)
 
-    assert_equal " 1000$ ", Template.parse("{{1000 | money}}").render!(nil, nil)
+    assert_equal " 1000$ ", Template.parse("{{1000 | money}}").render(nil, nil)
-    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, :filters => CanadianMoneyFilter)
+    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render(nil, :filters => CanadianMoneyFilter)
-    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, :filters => [CanadianMoneyFilter])
+    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render(nil, :filters => [CanadianMoneyFilter])
   end
 
   def test_local_filter_with_deprecated_syntax
-    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, CanadianMoneyFilter)
+    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render(nil, CanadianMoneyFilter)
-    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, [CanadianMoneyFilter])
+    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render(nil, [CanadianMoneyFilter])
   end
 end # FiltersTest

test/liquid/i18n_test.rb

@@ -1,37 +0,0 @@
-require 'test_helper'
-
-class I18nTest < Test::Unit::TestCase
-  include Liquid
-
-  def setup
-    @i18n = I18n.new(fixture("en_locale.yml"))
-  end
-
-  def test_simple_translate_string
-    assert_equal "less is more", @i18n.translate("simple")
-  end
-
-  def test_nested_translate_string
-    assert_equal "something wasn't right", @i18n.translate("errors.syntax.oops")
-  end
-
-  def test_single_string_interpolation
-    assert_equal "something different", @i18n.translate("whatever", :something => "different")
-  end
-
-  # def test_raises_translation_error_on_undefined_interpolation_key
-  #   assert_raise I18n::TranslationError do
-  #     @i18n.translate("whatever", :oopstypos => "yes")
-  #   end
-  # end
-  
-  def test_raises_unknown_translation
-    assert_raise I18n::TranslationError do
-      @i18n.translate("doesnt_exist")
-    end
-  end
-
-  def test_sets_default_path_to_en
-    assert_equal I18n::DEFAULT_LOCALE, I18n.new.path
-  end
-end

test/liquid/lexer_test.rb

@@ -1,48 +0,0 @@
-require 'test_helper'
-
-class LexerTest < Test::Unit::TestCase
-  include Liquid
-
-  def test_strings
-    tokens = Lexer.new(%! 'this is a test""' "wat 'lol'"!).tokenize
-    assert_equal [[:string,%!'this is a test""'!], [:string, %!"wat 'lol'"!], [:end_of_string]], tokens
-  end
-
-  def test_integer
-    tokens = Lexer.new('hi 50').tokenize
-    assert_equal [[:id,'hi'], [:number, '50'], [:end_of_string]], tokens
-  end
-
-  def test_float
-    tokens = Lexer.new('hi 5.0').tokenize
-    assert_equal [[:id,'hi'], [:number, '5.0'], [:end_of_string]], tokens
-  end
-
-  def test_comparison
-    tokens = Lexer.new('== <> contains').tokenize
-    assert_equal [[:comparison,'=='], [:comparison, '<>'], [:comparison, 'contains'], [:end_of_string]], tokens
-  end
-
-  def test_specials
-    tokens = Lexer.new('| .:').tokenize
-    assert_equal [[:pipe, '|'], [:dot, '.'], [:colon, ':'], [:end_of_string]], tokens
-    tokens = Lexer.new('[,]').tokenize
-    assert_equal [[:open_square, '['], [:comma, ','], [:close_square, ']'], [:end_of_string]], tokens
-  end
-
-  def test_fancy_identifiers
-    tokens = Lexer.new('hi! five?').tokenize
-    assert_equal [[:id,'hi!'], [:id, 'five?'], [:end_of_string]], tokens
-  end
-
-  def test_whitespace
-    tokens = Lexer.new("five|\n\t ==").tokenize
-    assert_equal [[:id,'five'], [:pipe, '|'], [:comparison, '=='], [:end_of_string]], tokens
-  end
-
-  def test_unexpected_character
-    assert_raises(SyntaxError) do
-      Lexer.new("%").tokenize
-    end
-  end
-end

test/liquid/module_ex_test.rb

@@ -77,11 +77,11 @@ class ModuleExTest < Test::Unit::TestCase
   end
 
   def test_should_use_regular_objects_as_drops
-    assert_template_result 'allowedA', "{{ a.allowedA }}", 'a'=>@a
+    assert_equal 'allowedA', Liquid::Template.parse("{{ a.allowedA }}").render('a'=>@a)
-    assert_template_result 'allowedB', "{{ a.chainedB.allowedB }}", 'a'=>@a
+    assert_equal 'allowedB', Liquid::Template.parse("{{ a.chainedB.allowedB }}").render('a'=>@a)
-    assert_template_result 'allowedC', "{{ a.chainedB.chainedC.allowedC }}", 'a'=>@a
+    assert_equal 'allowedC', Liquid::Template.parse("{{ a.chainedB.chainedC.allowedC }}").render('a'=>@a)
-    assert_template_result 'another_allowedC', "{{ a.chainedB.chainedC.another_allowedC }}", 'a'=>@a
+    assert_equal 'another_allowedC', Liquid::Template.parse("{{ a.chainedB.chainedC.another_allowedC }}").render('a'=>@a)
-    assert_template_result '', "{{ a.restricted }}", 'a'=>@a
+    assert_equal '', Liquid::Template.parse("{{ a.restricted }}").render('a'=>@a)
-    assert_template_result '', "{{ a.unknown }}", 'a'=>@a
+    assert_equal '', Liquid::Template.parse("{{ a.unknown }}").render('a'=>@a)
   end
 end # ModuleExTest

test/liquid/output_test.rb

@@ -41,76 +41,76 @@ class OutputTest < Test::Unit::TestCase
     text = %| {{best_cars}} |
 
     expected = %| bmw |
-    assert_equal expected, Template.parse(text).render!(@assigns)
+    assert_equal expected, Template.parse(text).render(@assigns)
   end
 
   def test_variable_traversing
     text = %| {{car.bmw}} {{car.gm}} {{car.bmw}} |
 
     expected = %| good bad good |
-    assert_equal expected, Template.parse(text).render!(@assigns)
+    assert_equal expected, Template.parse(text).render(@assigns)
   end
 
   def test_variable_piping
     text = %( {{ car.gm | make_funny }} )
     expected = %| LOL |
 
-    assert_equal expected, Template.parse(text).render!(@assigns, :filters => [FunnyFilter])
+    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 |
 
-    assert_equal expected, Template.parse(text).render!(@assigns, :filters => [FunnyFilter])
+    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])
+    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])
+    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 :-( :-( |
 
-    assert_equal expected, Template.parse(text).render!(@assigns, :filters => [FunnyFilter])
+    assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
   end
 
-  def test_variable_piping_with_multiple_args
+  def test_variable_piping_with_args
     text = %! {{ car.gm | add_tag : 'span', 'bar'}} !
     expected = %| <span id="bar">bad</span> |
 
-    assert_equal expected, Template.parse(text).render!(@assigns, :filters => [FunnyFilter])
+    assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
   end
 
   def test_variable_piping_with_variable_args
     text = %! {{ car.gm | add_tag : 'span', car.bmw}} !
     expected = %| <span id="good">bad</span> |
 
-    assert_equal expected, Template.parse(text).render!(@assigns, :filters => [FunnyFilter])
+    assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
   end
 
   def test_multiple_pipings
     text = %( {{ best_cars | cite_funny | paragraph }} )
     expected = %| <p>LOL: bmw</p> |
 
-    assert_equal expected, Template.parse(text).render!(@assigns, :filters => [FunnyFilter])
+    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> |
 
-    assert_equal expected, Template.parse(text).render!(@assigns, :filters => [FunnyFilter])
+    assert_equal expected, Template.parse(text).render(@assigns, :filters => [FunnyFilter])
   end
 end # OutputTest

test/liquid/parser_test.rb

@@ -1,82 +0,0 @@
-require 'test_helper'
-
-class ParserTest < Test::Unit::TestCase
-  include Liquid
-
-  def test_consume
-    p = Parser.new("wat: 7")
-    assert_equal 'wat', p.consume(:id)
-    assert_equal ':', p.consume(:colon)
-    assert_equal '7', p.consume(:number)
-  end
-
-  def test_jump
-    p = Parser.new("wat: 7")
-    p.jump(2)
-    assert_equal '7', p.consume(:number)
-  end
-
-  def test_consume?
-    p = Parser.new("wat: 7")
-    assert_equal 'wat', p.consume?(:id)
-    assert_equal false, p.consume?(:dot)
-    assert_equal ':', p.consume(:colon)
-    assert_equal '7', p.consume?(:number)
-  end
-
-  def test_id?
-    p = Parser.new("wat 6 Peter Hegemon")
-    assert_equal 'wat', p.id?('wat')
-    assert_equal false, p.id?('endgame')
-    assert_equal '6', p.consume(:number)
-    assert_equal 'Peter', p.id?('Peter')
-    assert_equal false, p.id?('Achilles')
-  end
-
-  def test_look
-    p = Parser.new("wat 6 Peter Hegemon")
-    assert_equal true, p.look(:id)
-    assert_equal 'wat', p.consume(:id)
-    assert_equal false, p.look(:comparison)
-    assert_equal true, p.look(:number)
-    assert_equal true, p.look(:id, 1)
-    assert_equal false, p.look(:number, 1)
-  end
-
-  def test_expressions
-    p = Parser.new("hi.there hi[5].! hi.there.bob")
-    assert_equal 'hi.there', p.expression
-    assert_equal 'hi[5].!', p.expression
-    assert_equal 'hi.there.bob', p.expression
-
-    p = Parser.new("567 6.0 'lol' \"wut\"")
-    assert_equal '567', p.expression
-    assert_equal '6.0', p.expression
-    assert_equal "'lol'", p.expression
-    assert_equal '"wut"', p.expression
-  end
-
-  def test_ranges
-    p = Parser.new("(5..7) (1.5..9.6) (young..old) (hi[5].wat..old)")
-    assert_equal '(5..7)', p.expression
-    assert_equal '(1.5..9.6)', p.expression
-    assert_equal '(young..old)', p.expression
-    assert_equal '(hi[5].wat..old)', p.expression
-  end
-
-  def test_arguments
-    p = Parser.new("filter: hi.there[5], keyarg: 7")
-    assert_equal 'filter', p.consume(:id)
-    assert_equal ':', p.consume(:colon)
-    assert_equal 'hi.there[5]', p.argument
-    assert_equal ',', p.consume(:comma)
-    assert_equal 'keyarg: 7', p.argument
-  end
-
-  def test_invalid_expression
-    assert_raises(SyntaxError) do
-      p = Parser.new("==")
-      p.expression
-    end
-  end
-end

test/liquid/parsing_quirks_test.rb

@@ -7,7 +7,7 @@ class ParsingQuirksTest < Test::Unit::TestCase
     text = %| div { font-weight: bold; } |
     template = Template.parse(text)
 
-    assert_equal text, template.render!
+    assert_equal text, template.render
     assert_equal [String], template.root.nodelist.collect {|i| i.class}
   end
 
@@ -31,60 +31,22 @@ class ParsingQuirksTest < Test::Unit::TestCase
 
   def test_error_on_empty_filter
     assert_nothing_raised do
+      Template.parse("{{test |a|b|}}")
       Template.parse("{{test}}")
-      Template.parse("{{|test}}")
+      Template.parse("{{|test|}}")
-    end
-    with_error_mode(:strict) do
-      assert_raise(SyntaxError) do
-        Template.parse("{{test |a|b|}}")
-      end
     end
   end
 
-  def test_meaningless_parens_error
+  def test_meaningless_parens
-    with_error_mode(:strict) do
+    assigns = {'b' => 'bar', 'c' => 'baz'}
-      assert_raise(SyntaxError) do
+    markup = "a == 'foo' or (b == 'bar' and c == 'baz') or false"
-        markup = "a == 'foo' or (b == 'bar' and c == 'baz') or false"
+    assert_template_result(' YES ',"{% if #{markup} %} YES {% endif %}", assigns)
-        Template.parse("{% if #{markup} %} YES {% endif %}")
-      end
-    end
   end
 
-  def test_unexpected_characters_syntax_error
+  def test_unexpected_characters_silently_eat_logic
-    with_error_mode(:strict) do
+    markup = "true && false"
-      assert_raise(SyntaxError) do
+    assert_template_result(' YES ',"{% if #{markup} %} YES {% endif %}")
-        markup = "true && false"
+    markup = "false || true"
-        Template.parse("{% if #{markup} %} YES {% endif %}")
+    assert_template_result('',"{% if #{markup} %} YES {% endif %}")
-      end
-      assert_raise(SyntaxError) do
-        markup = "false || true"
-        Template.parse("{% if #{markup} %} YES {% endif %}")
-      end
-    end
-  end
-
-  def test_no_error_on_lax_empty_filter
-    assert_nothing_raised do
-      Template.parse("{{test |a|b|}}", :error_mode => :lax)
-      Template.parse("{{test}}", :error_mode => :lax)
-      Template.parse("{{|test|}}", :error_mode => :lax)
-    end
-  end
-
-  def test_meaningless_parens_lax
-    with_error_mode(:lax) do
-      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
-  end
-
-  def test_unexpected_characters_silently_eat_logic_lax
-    with_error_mode(:lax) do
-      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/liquid/regexp_test.rb

@@ -21,11 +21,11 @@ class RegexpTest < Test::Unit::TestCase
     assert_equal ['<style', 'class="hello">', '</style>'], %|<style class="hello">' </style>|.scan(QuotedFragment)
   end
 
-  def test_double_quoted_words
+  def test_quoted_words
     assert_equal ['arg1', 'arg2', '"arg 3"'], 'arg1 arg2 "arg 3"'.scan(QuotedFragment)
   end
 
-  def test_single_quoted_words
+  def test_quoted_words
     assert_equal ['arg1', 'arg2', "'arg 3'"], 'arg1 arg2 \'arg 3\''.scan(QuotedFragment)
   end
 

test/liquid/security_test.rb

@@ -13,14 +13,14 @@ class SecurityTest < Test::Unit::TestCase
     text = %( {{ '1+1' | instance_eval }} )
     expected = %| 1+1 |
 
-    assert_equal expected, Template.parse(text).render!(@assigns)
+    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)
+    assert_equal expected, Template.parse(text).render(@assigns)
   end
 
 
@@ -28,7 +28,7 @@ class SecurityTest < Test::Unit::TestCase
     text = %( {{ '1+1' | instance_eval }} )
     expected = %| 1+1 |
 
-    assert_equal expected, Template.parse(text).render!(@assigns)
+    assert_equal expected, Template.parse(text).render(@assigns)
   end
 
 
@@ -36,7 +36,7 @@ class SecurityTest < Test::Unit::TestCase
     text = %( {{ '1+1' | add_one | instance_eval }} )
     expected = %| 1+1 + 1 |
 
-    assert_equal expected, Template.parse(text).render!(@assigns, :filters => SecurityFilter)
+    assert_equal expected, Template.parse(text).render(@assigns, :filters => SecurityFilter)
   end
 
   def test_does_not_add_filters_to_symbol_table
@@ -47,7 +47,7 @@ class SecurityTest < Test::Unit::TestCase
     template = Template.parse(test)
     assert_equal [], (Symbol.all_symbols - current_symbols)
 
-    template.render!
+    template.render
     assert_equal [], (Symbol.all_symbols - current_symbols)
   end
 

test/liquid/standard_filter_test.rb

@@ -15,10 +15,6 @@ class TestThing
     "woot: #{@foo}"
   end
 
-  def [](whatever)
-    to_s
-  end
-
   def to_liquid
     @foo += 1
     self
@@ -31,14 +27,6 @@ class TestDrop < Liquid::Drop
   end
 end
 
-class TestEnumerable < Liquid::Drop
-  include Enumerable
-
-  def each(&block)
-    [ { "foo" => 1, "bar" => 2 }, { "foo" => 2, "bar" => 1 }, { "foo" => 3, "bar" => 3 } ].each(&block)
-  end
-end
-
 class StandardFiltersTest < Test::Unit::TestCase
   include Liquid
 
@@ -62,6 +50,11 @@ class StandardFiltersTest < Test::Unit::TestCase
     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)
@@ -70,7 +63,7 @@ class StandardFiltersTest < Test::Unit::TestCase
     assert_equal "测试...", @filters.truncate("测试测试测试测试", 5)
   end
 
-  def test_split
+  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', '~')
@@ -84,7 +77,7 @@ class StandardFiltersTest < Test::Unit::TestCase
   end
 
   def test_escape_once
-    assert_equal '&lt;strong&gt;Hulk&lt;/strong&gt;', @filters.escape_once('&lt;strong&gt;Hulk</strong>')
+    assert_equal '&lt;strong&gt;', @filters.escape_once(@filters.escape('<strong>'))
   end
 
   def test_truncatewords
@@ -126,38 +119,20 @@ class StandardFiltersTest < Test::Unit::TestCase
   end
 
   def test_map_doesnt_call_arbitrary_stuff
-    assert_template_result "", '{{ "foo" | map: "__id__" }}'
+    assert_equal "", Liquid::Template.parse('{{ "foo" | map: "__id__" }}').render
-    assert_template_result "", '{{ "foo" | map: "inspect" }}'
+    assert_equal "", Liquid::Template.parse('{{ "foo" | map: "inspect" }}').render
   end
 
   def test_map_calls_to_liquid
     t = TestThing.new
-    assert_template_result "woot: 1", '{{ foo | map: "whatever" }}', "foo" => [t]
+    assert_equal "woot: 1", Liquid::Template.parse('{{ foo }}').render("foo" => t)
-  end
-
-  def test_map_on_hashes
-    assert_template_result "4217", '{{ thing | map: "foo" | map: "bar" }}',
-      "thing" => { "foo" => [ { "bar" => 42 }, { "bar" => 17 } ] }
-  end
-
-  def test_sort_calls_to_liquid
-    t = TestThing.new
-    assert_template_result "woot: 1", '{{ foo | sort: "whatever" }}', "foo" => [t]
   end
 
   def test_map_over_proc
     drop = TestDrop.new
     p = Proc.new{ drop }
     templ = '{{ procs | map: "test" }}'
-    assert_template_result "testfoo", templ, "procs" => [p]
+    assert_equal "testfoo", Liquid::Template.parse(templ).render("procs" => [p])
-  end
-
-  def test_map_works_on_enumerables
-    assert_template_result "123", '{{ foo | map: "foo" }}', "foo" => TestEnumerable.new
-  end
-
-  def test_sort_works_on_enumerables
-    assert_template_result "213", '{{ foo | sort: "bar" | map: "foo" }}', "foo" => TestEnumerable.new
   end
 
   def test_date
@@ -210,21 +185,6 @@ class StandardFiltersTest < Test::Unit::TestCase
     assert_template_result 'foobar', "{{ 'foo|bar' | remove: '|' }}"
   end
 
-  def test_strip
-    assert_template_result 'ab c', "{{ source | strip }}", 'source' => " ab c  "
-    assert_template_result 'ab c', "{{ source | strip }}", 'source' => " \tab c  \n \t"
-  end
-
-  def test_lstrip
-    assert_template_result 'ab c  ', "{{ source | lstrip }}", 'source' => " ab c  "
-    assert_template_result "ab c  \n \t", "{{ source | lstrip }}", 'source' => " \tab c  \n \t"
-  end
-
-  def test_rstrip
-    assert_template_result " ab c", "{{ source | rstrip }}", 'source' => " ab c  "
-    assert_template_result " \tab c", "{{ source | rstrip }}", 'source' => " \tab c  \n \t"
-  end
-
   def test_strip_newlines
     assert_template_result 'abc', "{{ source | strip_newlines }}", 'source' => "a\nb\nc"
     assert_template_result 'abc', "{{ source | strip_newlines }}", 'source' => "a\r\nb\nc"
@@ -248,6 +208,9 @@ class StandardFiltersTest < Test::Unit::TestCase
     assert_template_result "12", "{{ 3 | times:4 }}"
     assert_template_result "0", "{{ 'foo' | times:4 }}"
 
+    # 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}}"
 
     assert_template_result "7.25", "{{ 0.0725 | times:100 }}"
@@ -257,8 +220,11 @@ class StandardFiltersTest < Test::Unit::TestCase
     assert_template_result "4", "{{ 12 | divided_by:3 }}"
     assert_template_result "4", "{{ 14 | divided_by:3 }}"
 
+    # 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_equal "Liquid error: divided by 0", Template.parse("{{ 5 | divided_by:0 }}").render
+    assert_template_result "Liquid error: divided by 0", "{{ 5 | divided_by:0 }}"
 
     assert_template_result "0.5", "{{ 2.0 | divided_by:4 }}"
   end
@@ -279,15 +245,6 @@ class StandardFiltersTest < Test::Unit::TestCase
     assert_template_result('abc',"{{ a | prepend: b}}",assigns)
   end
 
-  def test_default
-    assert_equal "foo", @filters.default("foo", "bar")
-    assert_equal "bar", @filters.default(nil, "bar")
-    assert_equal "bar", @filters.default("", "bar")
-    assert_equal "bar", @filters.default(false, "bar")
-    assert_equal "bar", @filters.default([], "bar")
-    assert_equal "bar", @filters.default({}, "bar")
-  end
-
   def test_cannot_access_private_methods
     assert_template_result('a',"{{ 'a' | to_number }}")
   end

test/liquid/strainer_test.rb

@@ -22,13 +22,6 @@ class StrainerTest < Test::Unit::TestCase
     assert_equal "public", strainer.invoke("public_filter")
   end
 
-  def test_stainer_raises_argument_error
-    strainer = Strainer.create(nil)
-    assert_raises(Liquid::ArgumentError) do
-      strainer.invoke("public_filter", 1)
-    end
-  end
-
   def test_strainer_only_invokes_public_filter_methods
     strainer = Strainer.create(nil)
     assert_equal false, strainer.invokable?('__test__')
@@ -56,15 +49,4 @@ class StrainerTest < Test::Unit::TestCase
     assert_equal "has_method?", strainer.invoke("invoke", "has_method?", "invoke")
   end
 
-  def test_strainer_uses_a_class_cache_to_avoid_method_cache_invalidation
-    a, b = Module.new, Module.new
-    strainer = Strainer.create(nil, [a,b])
-    assert_kind_of Strainer, strainer
-    assert_kind_of a, strainer
-    assert_kind_of b, strainer
-    Strainer.class_variable_get(:@@filters).each do |m|
-      assert_kind_of m, strainer
-    end
-  end
-
 end # StrainerTest

test/liquid/tags/case_tag_test.rb

@@ -1,10 +0,0 @@
-require 'test_helper'
-
-class CaseTagTest < Test::Unit::TestCase
-  include Liquid
-
-  def test_case_nodelist
-    template = Liquid::Template.parse('{% case var %}{% when true %}WHEN{% else %}ELSE{% endcase %}')
-    assert_equal ['WHEN', 'ELSE'], template.root.nodelist[0].nodelist
-  end
-end # CaseTest

test/liquid/tags/for_tag_test.rb

@@ -294,72 +294,4 @@ HERE
     assigns  = {'items' => [1,2,3,4,5]}
     assert_template_result(expected, template, assigns)
   end
-
-  def test_for_nodelist
-    template = Liquid::Template.parse('{% for item in items %}FOR{% endfor %}')
-    assert_equal ['FOR'], template.root.nodelist[0].nodelist
-  end
-
-  def test_for_else_nodelist
-    template = Liquid::Template.parse('{% for item in items %}FOR{% else %}ELSE{% endfor %}')
-    assert_equal ['FOR', 'ELSE'], template.root.nodelist[0].nodelist
-  end
-
-  class LoaderDrop < Liquid::Drop
-    attr_accessor :each_called, :load_slice_called
-
-    def initialize(data)
-      @data = data
-    end
-
-    def each
-      @each_called = true
-      @data.each { |el| yield el }
-    end
-
-    def load_slice(from, to)
-      @load_slice_called = true
-      @data[(from..to-1)]
-    end
-  end
-
-  def test_iterate_with_each_when_no_limit_applied
-    loader = LoaderDrop.new([1,2,3,4,5])
-    assigns = {'items' => loader}
-    expected = '12345'
-    template = '{% for item in items %}{{item}}{% endfor %}'
-    assert_template_result(expected, template, assigns)
-    assert loader.each_called
-    assert !loader.load_slice_called
-  end
-
-  def test_iterate_with_load_slice_when_limit_applied
-    loader = LoaderDrop.new([1,2,3,4,5])
-    assigns = {'items' => loader}
-    expected = '1'
-    template = '{% for item in items limit:1 %}{{item}}{% endfor %}'
-    assert_template_result(expected, template, assigns)
-    assert !loader.each_called
-    assert loader.load_slice_called
-  end
-
-  def test_iterate_with_load_slice_when_limit_and_offset_applied
-    loader = LoaderDrop.new([1,2,3,4,5])
-    assigns = {'items' => loader}
-    expected = '34'
-    template = '{% for item in items offset:2 limit:2 %}{{item}}{% endfor %}'
-    assert_template_result(expected, template, assigns)
-    assert !loader.each_called
-    assert loader.load_slice_called
-  end
-
-  def test_iterate_with_load_slice_returns_same_results_as_without
-    loader = LoaderDrop.new([1,2,3,4,5])
-    loader_assigns = {'items' => loader}
-    array_assigns = {'items' => [1,2,3,4,5]}
-    expected = '34'
-    template = '{% for item in items offset:2 limit:2 %}{{item}}{% endfor %}'
-    assert_template_result(expected, template, loader_assigns)
-    assert_template_result(expected, template, array_assigns)
-  end
 end

test/liquid/tags/html_tag_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class TableRowTest < Test::Unit::TestCase
+class HtmlTagTest < Test::Unit::TestCase
   include Liquid
 
   class ArrayDrop < Liquid::Drop
@@ -15,7 +15,7 @@ class TableRowTest < Test::Unit::TestCase
     end
   end
 
-  def test_table_row
+  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 %}',
@@ -26,14 +26,14 @@ class TableRowTest < Test::Unit::TestCase
                            'numbers' => [])
   end
 
-  def test_table_row_with_different_cols
+  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 %}',
                            'numbers' => [1,2,3,4,5,6])
 
   end
 
-  def test_table_col_counter
+  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 %}',
                            'numbers' => [1,2,3,4,5,6])
@@ -60,4 +60,4 @@ class TableRowTest < Test::Unit::TestCase
                            '{% tablerow n in numbers cols:3 offset:1 limit:6%} {{n}} {% endtablerow %}',
                            'numbers' => [0,1,2,3,4,5,6,7])
   end
-end
+end # HtmlTagTest

test/liquid/tags/if_else_tag_test.rb

@@ -157,15 +157,4 @@ class IfElseTagTest < Test::Unit::TestCase
     assert_template_result('yes',
                            %({% if 'gnomeslab-and-or-liquid' contains 'gnomeslab-and-or-liquid' %}yes{% endif %}))
   end
-
-  def test_if_nodelist
-    template = Liquid::Template.parse('{% if true %}IF{% else %}ELSE{% endif %}')
-    assert_equal ['IF', 'ELSE'], template.root.nodelist[0].nodelist
-  end
-
-  def test_operators_are_whitelisted
-    assert_raise(SyntaxError) do
-      assert_template_result('', %({% if 1 or throw or or 1 %}yes{% endif %}))
-    end
-  end
 end # IfElseTest

test/liquid/tags/include_tag_test.rb

@@ -48,27 +48,6 @@ class CountingFileSystem
   end
 end
 
-class CustomInclude < Liquid::Tag
-  Syntax = /(#{Liquid::QuotedFragment}+)(\s+(?:with|for)\s+(#{Liquid::QuotedFragment}+))?/o
-
-  def initialize(tag_name, markup, tokens)
-    markup =~ Syntax
-    @template_name = $1
-    super
-  end
-
-  def parse(tokens)
-  end
-
-  def blank?
-    false
-  end
-
-  def render(context)
-    @template_name[1..-2]
-  end
-end
-
 class IncludeTagTest < Test::Unit::TestCase
   include Liquid
 
@@ -78,52 +57,57 @@ class IncludeTagTest < Test::Unit::TestCase
 
   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})
+      Template.parse("{% include 'pick_a_source' %}").render({}, :registers => {:file_system => OtherFileSystem.new})
   end
 
 
   def test_include_tag_with
-    assert_template_result "Product: Draft 151cm ",
+    assert_equal "Product: Draft 151cm ",
-      "{% include 'product' with products[0] %}", "products" => [ {'title' => 'Draft 151cm'}, {'title' => 'Element 155cm'} ]
+      Template.parse("{% include 'product' with products[0] %}").render( "products" => [ {'title' => 'Draft 151cm'}, {'title' => 'Element 155cm'} ]  )
   end
 
   def test_include_tag_with_default_name
-    assert_template_result "Product: Draft 151cm ",
+    assert_equal "Product: Draft 151cm ",
-      "{% include 'product' %}", "product" => {'title' => 'Draft 151cm'}
+      Template.parse("{% include 'product' %}").render( "product" => {'title' => 'Draft 151cm'}  )
   end
 
   def test_include_tag_for
-    assert_template_result "Product: Draft 151cm Product: Element 155cm ",
+
-      "{% include 'product' for products %}", "products" => [ {'title' => 'Draft 151cm'}, {'title' => 'Element 155cm'} ]
+    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_template_result "Locale: test123 ", "{% include 'locale_variables' echo1: 'test123' %}"
+    assert_equal "Locale: test123 ",
+      Template.parse("{% include 'locale_variables' echo1: 'test123' %}").render
   end
 
   def test_include_tag_with_multiple_local_variables
-    assert_template_result "Locale: test123 test321",
+    assert_equal "Locale: test123 test321",
-      "{% include 'locale_variables' echo1: 'test123', echo2: 'test321' %}"
+      Template.parse("{% include 'locale_variables' echo1: 'test123', echo2: 'test321' %}").render
   end
 
   def test_include_tag_with_multiple_local_variables_from_context
-    assert_template_result "Locale: test123 test321",
+    assert_equal "Locale: test123 test321",
-      "{% include 'locale_variables' echo1: echo1, echo2: more_echos.echo2 %}",
+      Template.parse("{% include 'locale_variables' echo1: echo1, echo2: more_echos.echo2 %}").render('echo1' => 'test123', 'more_echos' => { "echo2" => 'test321'})
-      'echo1' => 'test123', 'more_echos' => { "echo2" => 'test321'}
   end
 
   def test_nested_include_tag
-    assert_template_result "body body_detail", "{% include 'body' %}"
+    assert_equal "body body_detail",
+      Template.parse("{% include 'body' %}").render
 
-    assert_template_result "header body body_detail footer", "{% include 'nested_template' %}"
+    assert_equal "header body body_detail footer",
+      Template.parse("{% include 'nested_template' %}").render
   end
 
   def test_nested_include_with_variable
-    assert_template_result "Product: Draft 151cm details ",
-      "{% include 'nested_product_template' with product %}", "product" => {"title" => 'Draft 151cm'}
 
-    assert_template_result "Product: Draft 151cm details Product: Element 155cm details ",
+    assert_equal "Product: Draft 151cm details ",
-      "{% include 'nested_product_template' for products %}", "products" => [{"title" => 'Draft 151cm'}, {"title" => 'Element 155cm'}]
+      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
@@ -155,54 +139,28 @@ class IncludeTagTest < Test::Unit::TestCase
   end
 
   def test_dynamically_choosen_template
-    assert_template_result "Test123", "{% include template %}", "template" => 'Test123'
-    assert_template_result "Test321", "{% include template %}", "template" => 'Test321'
 
-    assert_template_result "Product: Draft 151cm ", "{% include template for product %}",
+    assert_equal "Test123", Template.parse("{% include template %}").render("template" => 'Test123')
-      "template" => 'product', 'product' => { 'title' => 'Draft 151cm'}
+    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
 
   def test_include_tag_caches_second_read_of_same_partial
     file_system = CountingFileSystem.new
     assert_equal 'from CountingFileSystemfrom CountingFileSystem',
-      Template.parse("{% include 'pick_a_source' %}{% include 'pick_a_source' %}").render!({}, :registers => {:file_system => file_system})
+      Template.parse("{% include 'pick_a_source' %}{% include 'pick_a_source' %}").render({}, :registers => {:file_system => file_system})
     assert_equal 1, file_system.count
   end
 
   def test_include_tag_doesnt_cache_partials_across_renders
     file_system = CountingFileSystem.new
     assert_equal 'from CountingFileSystem',
-      Template.parse("{% include 'pick_a_source' %}").render!({}, :registers => {:file_system => file_system})
+      Template.parse("{% include 'pick_a_source' %}").render({}, :registers => {:file_system => file_system})
     assert_equal 1, file_system.count
 
     assert_equal 'from CountingFileSystem',
-      Template.parse("{% include 'pick_a_source' %}").render!({}, :registers => {:file_system => file_system})
+      Template.parse("{% include 'pick_a_source' %}").render({}, :registers => {:file_system => file_system})
     assert_equal 2, file_system.count
   end
-
-  def test_include_tag_within_if_statement
-    assert_template_result "foo_if_true", "{% if true %}{% include 'foo_if_true' %}{% endif %}"
-  end
-
-  def test_custom_include_tag
-    original_tag = Liquid::Template.tags['include']
-    Liquid::Template.tags['include'] = CustomInclude
-    begin
-      assert_equal "custom_foo",
-        Template.parse("{% include 'custom_foo' %}").render!
-    ensure
-      Liquid::Template.tags['include'] = original_tag
-    end
-  end
-
-  def test_custom_include_tag_within_if_statement
-    original_tag = Liquid::Template.tags['include']
-    Liquid::Template.tags['include'] = CustomInclude
-    begin
-      assert_equal "custom_foo_if_true",
-        Template.parse("{% if true %}{% include 'custom_foo_if_true' %}{% endif %}").render!
-    ensure
-      Liquid::Template.tags['include'] = original_tag
-    end
-  end
 end # IncludeTagTest

test/liquid/tags/raw_tag_test.rb

@@ -20,6 +20,5 @@ class RawTagTest < Test::Unit::TestCase
     assert_template_result ' Foobar {% invalid {% {% endraw ', '{% raw %} Foobar {% invalid {% {% endraw {% endraw %}'
     assert_template_result ' Foobar {% {% {% ', '{% raw %} Foobar {% {% {% {% endraw %}'
     assert_template_result ' test {% raw %} {% endraw %}', '{% raw %} test {% raw %} {% {% endraw %}endraw %}'
-    assert_template_result ' Foobar {{ invalid 1', '{% raw %} Foobar {{ invalid {% endraw %}{{ 1 }}'
   end
 end

test/liquid/tags/standard_tag_test.rb

@@ -4,7 +4,7 @@ class StandardTagTest < Test::Unit::TestCase
   include Liquid
 
   def test_tag
-    tag = Tag.parse('tag', [], [], {})
+    tag = Tag.new('tag', [], [])
     assert_equal 'liquid::tag', tag.name
     assert_equal '', tag.render(Context.new)
   end
@@ -33,13 +33,6 @@ class StandardTagTest < Test::Unit::TestCase
     assert_template_result('','{% comment %}{% endcomment %}')
     assert_template_result('','{%comment%}comment{%endcomment%}')
     assert_template_result('','{% comment %}comment{% endcomment %}')
-    assert_template_result('','{% comment %} 1 {% comment %} 2 {% endcomment %} 3 {% endcomment %}')
-
-    assert_template_result('','{%comment%}{%blabla%}{%endcomment%}')
-    assert_template_result('','{% comment %}{% blabla %}{% endcomment %}')
-    assert_template_result('','{%comment%}{% endif %}{%endcomment%}')
-    assert_template_result('','{% comment %}{% endwhatever %}{% endcomment %}')
-    assert_template_result('','{% comment %}{% raw %} {{%%%%}}  }} { {% endcomment %} {% comment {% endraw %} {% endcomment %}')
 
     assert_template_result('foobar','foo{%comment%}comment{%endcomment%}bar')
     assert_template_result('foobar','foo{% comment %}comment{% endcomment %}bar')
@@ -54,9 +47,16 @@ class StandardTagTest < Test::Unit::TestCase
                                      {%endcomment%}bar')
   end
 
+  def test_assign
+    assigns = {'var' => 'content' }
+    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)
+
   end
 
   def test_assign_with_colon_and_spaces
@@ -180,11 +180,11 @@ class StandardTagTest < Test::Unit::TestCase
     # Example from the shopify forums
     code = %q({% case collection.handle %}{% when 'menswear-jackets' %}{% assign ptitle = 'menswear' %}{% when 'menswear-t-shirts' %}{% assign ptitle = 'menswear' %}{% else %}{% assign ptitle = 'womenswear' %}{% endcase %}{{ ptitle }})
     template = Liquid::Template.parse(code)
-    assert_equal "menswear",   template.render!("collection" => {'handle' => 'menswear-jackets'})
+    assert_equal "menswear",   template.render("collection" => {'handle' => 'menswear-jackets'})
-    assert_equal "menswear",   template.render!("collection" => {'handle' => 'menswear-t-shirts'})
+    assert_equal "menswear",   template.render("collection" => {'handle' => 'menswear-t-shirts'})
-    assert_equal "womenswear", template.render!("collection" => {'handle' => 'x'})
+    assert_equal "womenswear", template.render("collection" => {'handle' => 'x'})
-    assert_equal "womenswear", template.render!("collection" => {'handle' => 'y'})
+    assert_equal "womenswear", template.render("collection" => {'handle' => 'y'})
-    assert_equal "womenswear", template.render!("collection" => {'handle' => 'z'})
+    assert_equal "womenswear", template.render("collection" => {'handle' => 'z'})
   end
 
   def test_case_when_or
@@ -218,20 +218,16 @@ class StandardTagTest < Test::Unit::TestCase
   end
 
   def test_assign
-    assert_template_result 'variable', '{% assign a = "variable"%}{{a}}'
+    assert_equal 'variable', Liquid::Template.parse( '{% assign a = "variable"%}{{a}}'  ).render
-  end
-
-  def test_assign_unassigned
-    assigns = { 'var' => 'content' }
-    assert_template_result('var2:  var2:content', 'var2:{{var2}} {%assign var2 = var%} var2:{{var2}}', assigns)
   end
 
   def test_assign_an_empty_string
-    assert_template_result '', '{% assign a = ""%}{{a}}'
+    assert_equal '', Liquid::Template.parse( '{% assign a = ""%}{{a}}'  ).render
   end
 
   def test_assign_is_global
-    assert_template_result 'variable', '{%for i in (1..2) %}{% assign a = "variable"%}{% endfor %}{{a}}'
+    assert_equal 'variable',
+                 Liquid::Template.parse( '{%for i in (1..2) %}{% assign a = "variable"%}{% endfor %}{{a}}'  ).render
   end
 
   def test_case_detects_bad_syntax
@@ -296,8 +292,4 @@ class StandardTagTest < Test::Unit::TestCase
     assigns = {'array' => [ 1, 1, 1, 1] }
     assert_template_result('1','{%for item in array%}{%ifchanged%}{{item}}{% endifchanged %}{%endfor%}',assigns)
   end
-
-  def test_multiline_tag
-    assert_template_result '0 1 2 3', "0{%\nfor i in (1..3)\n%} {{\ni\n}}{%\nendfor\n%}"
-  end
 end # StandardTagTest

test/liquid/tags/statements_test.rb

@@ -4,78 +4,93 @@ class StatementsTest < Test::Unit::TestCase
   include Liquid
 
   def test_true_eql_true
-    text = ' {% if true == true %} true {% else %} false {% endif %} '
+    text = %| {% if true == true %} true {% else %} false {% endif %} |
-    assert_template_result '  true  ', text
+    expected = %|  true  |
+    assert_equal expected, Template.parse(text).render
   end
 
   def test_true_not_eql_true
-    text = ' {% if true != true %} true {% else %} false {% endif %} '
+    text = %| {% if true != true %} true {% else %} false {% endif %} |
-    assert_template_result '  false  ', text
+    expected = %|  false  |
+    assert_equal expected, Template.parse(text).render
   end
 
   def test_true_lq_true
-    text = ' {% if 0 > 0 %} true {% else %} false {% endif %} '
+    text = %| {% if 0 > 0 %} true {% else %} false {% endif %} |
-    assert_template_result '  false  ', text
+    expected = %|  false  |
+    assert_equal expected, Template.parse(text).render
   end
 
   def test_one_lq_zero
-    text = ' {% if 1 > 0 %} true {% else %} false {% endif %} '
+    text = %| {% if 1 > 0 %} true {% else %} false {% endif %} |
-    assert_template_result '  true  ', text
+    expected = %|  true  |
+    assert_equal expected, Template.parse(text).render
   end
 
   def test_zero_lq_one
-    text = ' {% if 0 < 1 %} true {% else %} false {% endif %} '
+    text = %| {% if 0 < 1 %} true {% else %} false {% endif %} |
-    assert_template_result '  true  ', text
+    expected = %|  true  |
+    assert_equal expected, Template.parse(text).render
   end
 
   def test_zero_lq_or_equal_one
-    text = ' {% if 0 <= 0 %} true {% else %} false {% endif %} '
+    text = %| {% if 0 <= 0 %} true {% else %} false {% endif %} |
-    assert_template_result '  true  ', text
+    expected = %|  true  |
+    assert_equal expected, Template.parse(text).render
   end
 
   def test_zero_lq_or_equal_one_involving_nil
-    text = ' {% if null <= 0 %} true {% else %} false {% endif %} '
+    text = %| {% if null <= 0 %} true {% else %} false {% endif %} |
-    assert_template_result '  false  ', text
+    expected = %|  false  |
+    assert_equal expected, Template.parse(text).render
 
 
-    text = ' {% if 0 <= null %} true {% else %} false {% endif %} '
+    text = %| {% if 0 <= null %} true {% else %} false {% endif %} |
-    assert_template_result '  false  ', text
+    expected = %|  false  |
+    assert_equal expected, Template.parse(text).render
   end
 
   def test_zero_lqq_or_equal_one
-    text = ' {% if 0 >= 0 %} true {% else %} false {% endif %} '
+    text = %| {% if 0 >= 0 %} true {% else %} false {% endif %} |
-    assert_template_result '  true  ', text
+    expected = %|  true  |
+    assert_equal expected, Template.parse(text).render
   end
 
   def test_strings
-    text = " {% if 'test' == 'test' %} true {% else %} false {% endif %} "
+    text = %| {% if 'test' == 'test' %} true {% else %} false {% endif %} |
-    assert_template_result '  true  ', text
+    expected = %|  true  |
+    assert_equal expected, Template.parse(text).render
   end
 
   def test_strings_not_equal
-    text = " {% if 'test' != 'test' %} true {% else %} false {% endif %} "
+    text = %| {% if 'test' != 'test' %} true {% else %} false {% endif %} |
-    assert_template_result '  false  ', text
+    expected = %|  false  |
+    assert_equal expected, Template.parse(text).render
   end
 
   def test_var_strings_equal
-    text = ' {% if var == "hello there!" %} true {% else %} false {% endif %} '
+    text = %| {% if var == "hello there!" %} true {% else %} false {% endif %} |
-    assert_template_result '  true  ', text, 'var' => 'hello there!'
+    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 %} '
+    text = %| {% if "hello there!" == var %} true {% else %} false {% endif %} |
-    assert_template_result '  true  ', text, 'var' => 'hello there!'
+    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 %} "
+    text = %| {% if var == 'hello there!' %} true {% else %} false {% endif %} |
-    assert_template_result '  true  ', text, 'var' => 'hello there!'
+    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 %} "
+    text = %| {% if 'hello there!' == var %} true {% else %} false {% endif %} |
-    assert_template_result '  true  ', text, 'var' => 'hello there!'
+    expected = %|  true  |
+    assert_equal expected, Template.parse(text).render('var' => 'hello there!')
   end
 
   #def test_is_nil
@@ -86,28 +101,34 @@ class StatementsTest < Test::Unit::TestCase
   #end
 
   def test_is_collection_empty
-    text = ' {% if array == empty %} true {% else %} false {% endif %} '
+    text = %| {% if array == empty %} true {% else %} false {% endif %} |
-    assert_template_result '  true  ', text, 'array' => []
+    expected = %|  true  |
+    assert_equal expected, Template.parse(text).render('array' => [])
   end
 
   def test_is_not_collection_empty
-    text = ' {% if array == empty %} true {% else %} false {% endif %} '
+    text = %| {% if array == empty %} true {% else %} false {% endif %} |
-    assert_template_result '  false  ', text, 'array' => [1,2,3]
+    expected = %|  false  |
+    assert_equal expected, Template.parse(text).render('array' => [1,2,3])
   end
 
   def test_nil
-    text = ' {% if var == nil %} true {% else %} false {% endif %} '
+    text = %| {% if var == nil %} true {% else %} false {% endif %} |
-    assert_template_result '  true  ', text, 'var' => nil
+    expected = %|  true  |
+    assert_equal expected, Template.parse(text).render('var' => nil)
 
-    text = ' {% if var == null %} true {% else %} false {% endif %} '
+    text = %| {% if var == null %} true {% else %} false {% endif %} |
-    assert_template_result '  true  ', text, 'var' => nil
+    expected = %|  true  |
+    assert_equal expected, Template.parse(text).render('var' => nil)
   end
 
   def test_not_nil
-    text = ' {% if var != nil %} true {% else %} false {% endif %} '
+    text = %| {% if var != nil %} true {% else %} false {% endif %} |
-    assert_template_result '  true  ', text, 'var' => 1
+    expected = %|  true  |
+    assert_equal expected, Template.parse(text).render('var' => 1 )
 
-    text = ' {% if var != null %} true {% else %} false {% endif %} '
+    text = %| {% if var != null %} true {% else %} false {% endif %} |
-    assert_template_result '  true  ', text, 'var' => 1
+    expected = %|  true  |
+    assert_equal expected, Template.parse(text).render('var' => 1 )
   end
 end # StatementsTest

test/liquid/template_test.rb

@@ -14,79 +14,85 @@ class TemplateContextDrop < Liquid::Drop
   end
 end
 
-class SomethingWithLength
-  def length
-    nil
-  end
-
-  liquid_methods :length
-end
-
 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
+
+  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
+    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
+
   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("{% assign foo = 'from instance assigns' %}{{ foo }}").render
-    assert_equal 'from instance assigns', t.parse("{{ 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 'foo', t.render
-    assert_equal 'foofoo', 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 'from custom assigns', t.parse("{{ foo }}").render('foo' => 'from custom assigns')
-    assert_equal '', t.parse("{{ foo }}").render!
+    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 instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render
-    assert_equal 'from custom assigns', t.parse("{{ foo }}").render!('foo' => 'from custom assigns')
+    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!
+    assert_equal 'from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render
     t.assigns['foo'] = 'from persistent assigns'
-    assert_equal 'from persistent assigns', t.parse("{{ foo }}").render!
+    assert_equal 'from persistent assigns', t.parse("{{ foo }}").render
   end
 
   def test_lambda_is_called_once_from_persistent_assigns_over_multiple_parses_and_renders
     t = Template.new
     t.assigns['number'] = lambda { @global ||= 0; @global += 1 }
-    assert_equal '1', t.parse("{{number}}").render!
+    assert_equal '1', t.parse("{{number}}").render
-    assert_equal '1', t.parse("{{number}}").render!
+    assert_equal '1', t.parse("{{number}}").render
-    assert_equal '1', t.render!
+    assert_equal '1', t.render
     @global = nil
   end
 
   def test_lambda_is_called_once_from_custom_assigns_over_multiple_parses_and_renders
     t = Template.new
     assigns = {'number' => lambda { @global ||= 0; @global += 1 }}
-    assert_equal '1', t.parse("{{number}}").render!(assigns)
+    assert_equal '1', t.parse("{{number}}").render(assigns)
-    assert_equal '1', t.parse("{{number}}").render!(assigns)
+    assert_equal '1', t.parse("{{number}}").render(assigns)
-    assert_equal '1', t.render!(assigns)
+    assert_equal '1', t.render(assigns)
     @global = nil
   end
 
-  def test_resource_limits_works_with_custom_length_method
-    t = Template.parse("{% assign foo = bar %}")
-    t.resource_limits = { :render_length_limit => 42 }
-    assert_equal "", t.render!("bar" => SomethingWithLength.new)
-  end
-
   def test_resource_limits_render_length
     t = Template.parse("0123456789")
     t.resource_limits = { :render_length_limit => 5 }
     assert_equal "Liquid error: Memory limits exceeded", t.render()
     assert t.resource_limits[:reached]
     t.resource_limits = { :render_length_limit => 10 }
-    assert_equal "0123456789", t.render!()
+    assert_equal "0123456789", t.render()
     assert_not_nil t.resource_limits[:render_length_current]
   end
 
@@ -100,7 +106,7 @@ class TemplateTest < Test::Unit::TestCase
     assert_equal "Liquid error: Memory limits exceeded", t.render()
     assert t.resource_limits[:reached]
     t.resource_limits = { :render_score_limit => 200 }
-    assert_equal (" foo " * 100), t.render!()
+    assert_equal (" foo " * 100), t.render()
     assert_not_nil t.resource_limits[:render_score_current]
   end
 
@@ -110,7 +116,7 @@ class TemplateTest < Test::Unit::TestCase
     assert_equal "Liquid error: Memory limits exceeded", t.render()
     assert t.resource_limits[:reached]
     t.resource_limits = { :assign_score_limit => 2 }
-    assert_equal "", t.render!()
+    assert_equal "", t.render()
     assert_not_nil t.resource_limits[:assign_score_current]
   end
 
@@ -123,7 +129,7 @@ class TemplateTest < Test::Unit::TestCase
 
   def test_resource_limits_hash_in_template_gets_updated_even_if_no_limits_are_set
     t = Template.parse("{% for a in (1..100) %} {% assign foo = 1 %} {% endfor %}")
-    t.render!()
+    t.render()
     assert t.resource_limits[:assign_score_current] > 0
     assert t.resource_limits[:render_score_current] > 0
     assert t.resource_limits[:render_length_current] > 0
@@ -133,22 +139,8 @@ class TemplateTest < Test::Unit::TestCase
     t = Template.new
     t.registers['lulz'] = 'haha'
     drop = TemplateContextDrop.new
-    assert_equal 'fizzbuzz', t.parse('{{foo}}').render!(drop)
+    assert_equal 'fizzbuzz', t.parse('{{foo}}').render(drop)
-    assert_equal 'bar', t.parse('{{bar}}').render!(drop)
+    assert_equal 'bar', t.parse('{{bar}}').render(drop)
-    assert_equal 'haha', t.parse("{{baz}}").render!(drop)
+    assert_equal 'haha', t.parse("{{baz}}").render(drop)
   end
-
+end # TemplateTest
-  def test_sets_default_localization_in_document
-    t = Template.new
-    t.parse('')
-    assert_instance_of I18n, t.root.options[:locale]
-  end
-
-  def test_sets_default_localization_in_context_with_quick_initialization
-    t = Template.new
-    t.parse('{{foo}}', :locale => I18n.new(fixture("en_locale.yml")))
-
-    assert_instance_of I18n, t.root.options[:locale]
-    assert_equal fixture("en_locale.yml"), t.root.options[:locale].path
-  end
-end

test/liquid/tokenizer_test.rb

@@ -1,34 +0,0 @@
-require 'test_helper'
-
-class TokenizerTest < Test::Unit::TestCase
-  def test_tokenize_strings
-    assert_equal [' '], tokenize(' ')
-    assert_equal ['hello world'], tokenize('hello world')
-  end
-
-  def test_tokenize_variables
-    assert_equal ['{{funk}}'], tokenize('{{funk}}')
-    assert_equal [' ', '{{funk}}', ' '], tokenize(' {{funk}} ')
-    assert_equal [' ', '{{funk}}', ' ', '{{so}}', ' ', '{{brother}}', ' '], tokenize(' {{funk}} {{so}} {{brother}} ')
-    assert_equal [' ', '{{  funk  }}', ' '], tokenize(' {{  funk  }} ')
-  end
-
-  def test_tokenize_blocks
-    assert_equal ['{%comment%}'], tokenize('{%comment%}')
-    assert_equal [' ', '{%comment%}', ' '], tokenize(' {%comment%} ')
-
-    assert_equal [' ', '{%comment%}', ' ', '{%endcomment%}', ' '], tokenize(' {%comment%} {%endcomment%} ')
-    assert_equal ['  ', '{% comment %}', ' ', '{% endcomment %}', ' '], tokenize("  {% comment %} {% endcomment %} ")
-  end
-
-  private
-
-  def tokenize(source)
-    tokenizer = Liquid::Tokenizer.new(source)
-    tokens = []
-    while token = tokenizer.next
-      tokens << token
-    end
-    tokens
-  end
-end

test/liquid/variable_test.rb

@@ -73,14 +73,8 @@ class VariableTest < Test::Unit::TestCase
   end
 
   def test_symbol
-    var = Variable.new("http://disney.com/logo.gif | image: 'med' ", :error_mode => :lax)
+    var = Variable.new("http://disney.com/logo.gif | image: 'med' ")
-    assert_equal "http://disney.com/logo.gif", var.name
+    assert_equal 'http://disney.com/logo.gif', var.name
-    assert_equal [["image",["'med'"]]], var.filters
-  end
-
-  def test_string_to_filter
-    var = Variable.new("'http://disney.com/logo.gif' | image: 'med' ")
-    assert_equal "'http://disney.com/logo.gif'", var.name
     assert_equal [["image",["'med'"]]], var.filters
   end
 
@@ -121,18 +115,10 @@ class VariableTest < Test::Unit::TestCase
   end
 
   def test_lax_filter_argument_parsing
-    var = Variable.new(%! number_of_comments | pluralize: 'comment': 'comments' !, :error_mode => :lax)
+    var = Variable.new(%! number_of_comments | pluralize: 'comment': 'comments' !)
     assert_equal 'number_of_comments', var.name
     assert_equal [['pluralize',["'comment'","'comments'"]]], var.filters
   end
-
-  def test_strict_filter_argument_parsing
-    with_error_mode(:strict) do
-      assert_raises(SyntaxError) do
-        Variable.new(%! number_of_comments | pluralize: 'comment': 'comments' !)
-      end
-    end
-  end
 end
 
 
@@ -141,49 +127,49 @@ class VariableResolutionTest < Test::Unit::TestCase
 
   def test_simple_variable
     template = Template.parse(%|{{test}}|)
-    assert_equal 'worked', template.render!('test' => 'worked')
+    assert_equal 'worked', template.render('test' => 'worked')
-    assert_equal 'worked wonderfully', template.render!('test' => 'worked wonderfully')
+    assert_equal 'worked wonderfully', template.render('test' => 'worked wonderfully')
   end
 
   def test_simple_with_whitespaces
     template = Template.parse(%|  {{ test }}  |)
-    assert_equal '  worked  ', template.render!('test' => 'worked')
+    assert_equal '  worked  ', template.render('test' => 'worked')
-    assert_equal '  worked wonderfully  ', template.render!('test' => 'worked wonderfully')
+    assert_equal '  worked wonderfully  ', template.render('test' => 'worked wonderfully')
   end
 
   def test_ignore_unknown
     template = Template.parse(%|{{ test }}|)
-    assert_equal '', template.render!
+    assert_equal '', template.render
   end
 
   def test_hash_scoping
     template = Template.parse(%|{{ test.test }}|)
-    assert_equal 'worked', template.render!('test' => {'test' => 'worked'})
+    assert_equal 'worked', template.render('test' => {'test' => 'worked'})
   end
 
   def test_preset_assigns
     template = Template.parse(%|{{ test }}|)
     template.assigns['test'] = 'worked'
-    assert_equal 'worked', template.render!
+    assert_equal 'worked', template.render
   end
 
   def test_reuse_parsed_template
     template = Template.parse(%|{{ greeting }} {{ name }}|)
     template.assigns['greeting'] = 'Goodbye'
-    assert_equal 'Hello Tobi', template.render!('greeting' => 'Hello', 'name' => 'Tobi')
+    assert_equal 'Hello Tobi', template.render('greeting' => 'Hello', 'name' => 'Tobi')
-    assert_equal 'Hello ', template.render!('greeting' => 'Hello', 'unknown' => 'Tobi')
+    assert_equal 'Hello ', template.render('greeting' => 'Hello', 'unknown' => 'Tobi')
-    assert_equal 'Hello Brian', template.render!('greeting' => 'Hello', 'name' => 'Brian')
+    assert_equal 'Hello Brian', template.render('greeting' => 'Hello', 'name' => 'Brian')
-    assert_equal 'Goodbye Brian', template.render!('name' => 'Brian')
+    assert_equal 'Goodbye Brian', template.render('name' => 'Brian')
     assert_equal({'greeting'=>'Goodbye'}, template.assigns)
   end
 
   def test_assigns_not_polluted_from_template
     template = Template.parse(%|{{ test }}{% assign test = 'bar' %}{{ test }}|)
     template.assigns['test'] = 'baz'
-    assert_equal 'bazbar', template.render!
+    assert_equal 'bazbar', template.render
-    assert_equal 'bazbar', template.render!
+    assert_equal 'bazbar', template.render
-    assert_equal 'foobar', template.render!('test' => 'foo')
+    assert_equal 'foobar', template.render('test' => 'foo')
-    assert_equal 'bazbar', template.render!
+    assert_equal 'bazbar', template.render
   end
 
   def test_hash_with_default_proc
@@ -197,8 +183,4 @@ class VariableResolutionTest < Test::Unit::TestCase
     }
     assert_equal "Unknown variable 'test'", e.message
   end
-
-  def test_multiline_variable
-    assert_equal 'worked', Template.parse("{{\ntest\n}}").render!('test' => 'worked')
-  end
 end # VariableTest

test/test_helper.rb

@@ -2,51 +2,27 @@
 
 require 'test/unit'
 require 'test/unit/assertions'
-
+begin
-$:.unshift(File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib'))
+  require 'ruby-debug'
-require 'liquid.rb'
+rescue LoadError
-
+  puts "Couldn't load ruby-debug. gem install ruby-debug if you need it."
-mode = :strict
-if env_mode = ENV['LIQUID_PARSER_MODE']
-  puts "-- #{env_mode.upcase} ERROR MODE"
-  mode = env_mode.to_sym
 end
-Liquid::Template.error_mode = mode
+require File.join(File.dirname(__FILE__), '..', 'lib', 'liquid')
 
 
 module Test
   module Unit
-    class TestCase
-      def fixture(name)
-        File.join(File.expand_path(File.dirname(__FILE__)), "fixtures", name)
-      end
-    end
-
     module Assertions
       include Liquid
 
       def assert_template_result(expected, template, assigns = {}, message = nil)
-        assert_equal expected, Template.parse(template).render!(assigns)
+        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)
+        assert_match expected, Template.parse(template).render(assigns)
-      end
-
-      def assert_match_syntax_error(match, template, registers = {})
-        exception = assert_raise(Liquid::SyntaxError) {
-          Template.parse(template).render(assigns)
-        }
-        assert_match match, exception.message
-      end
-
-      def with_error_mode(mode)
-        old_mode = Liquid::Template.error_mode
-        Liquid::Template.error_mode = mode
-        yield
-        Liquid::Template.error_mode = old_mode
       end
     end # Assertions
   end # Unit