Use StringSlice.join on the rendered results.

If we are trying to get the struct from something other than self, then we
should make sure to check the class of the object.  This util functions
make this easier.

.gitignore

@@ -5,4 +5,6 @@ pkg
 *.rbc
 .rvmrc
 .ruby-version
+*.bundle
+/tmp
 Gemfile.lock

.travis.yml

@@ -1,17 +1,13 @@
-language: ruby
-
 rvm:
-  - 2.0
-  - 2.1
-  - 2.2
-  - ruby-head
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - jruby-19mode
   - jruby-head
-  - rbx-2
-
-sudo: false
-
+  - rbx-19mode
 matrix:
   allow_failures:
+    - rvm: rbx-19mode
     - rvm: jruby-head
 
 script: "rake test"

Gemfile

@@ -1,9 +1,3 @@
 source 'https://rubygems.org'
 
 gemspec
-gem 'stackprof', platforms: :mri_21
-
-group :test do
-  gem 'spy', '0.4.1'
-  gem 'benchmark-ips'
-end

History.md

@@ -1,74 +1,29 @@
-# Liquid Change Log
+# Liquid Version History
 
-## 4.0.0 / not yet released / branch "master"
-### Changed
-* Add sort_natural filter (#554) [Martin Hanzel, arthanzel]
-* Add forloop.parentloop as a reference to the parent loop (#520) [Justin Li, pushrax]
-* Block parsing moved to BlockBody class (#458) [Dylan Thacker-Smith, dylanahsmith]
-* Add concat filter to concatenate arrays (#429) [Diogo Beato, dvbeato]
-* Ruby 1.9 support dropped (#491) [Justin Li, pushrax]
-* Liquid::Template.file_system's read_template_file method is no longer passed the context. (#441) [James Reid-Smith, sunblaze]
+## 3.0.0 / not yet released / branch "master"
 
-### Fixed
-* Fix naming of the "context variable" when dynamically including a template (#559) [Justin Li, pushrax]
-* Gracefully accept empty strings in the date filter (#555) [Loren Hale, boobooninja]
-* Fix capturing into variables with a hyphen in the name (#505) [Florian Weingarten, fw42]
-* Fix case sensitivity regression in date standard filter (#499) [Kelley Reynolds, kreynolds]
-* Disallow filters with no variable in strict mode (#475) [Justin Li, pushrax]
-* Disallow variable names in the strict parser that are not valid in the lax parser (#463) [Justin Li, pushrax]
-* Fix BlockBody#warnings taking exponential time to compute (#486) [Justin Li, pushrax]
-
-## 3.0.2 / 2015-04-24 / branch "3-0-stable"
-
-* Expose VariableLookup private members (#551) [Justin Li, pushrax]
-* Documentation fixes
-
-## 3.0.1 / 2015-01-23
-
-* Remove duplicate `index0` key in TableRow tag (#502) [Alfred Xing]
-
-## 3.0.0 / 2014-11-12
-
-* Removed Block#end_tag. Instead, override parse with `super` followed by your code. See #446 [Dylan Thacker-Smith, dylanahsmith]
-* Fixed condition with wrong data types (#423) [Bogdan Gusiev]
-* Add url_encode to standard filters (#421) [Derrick Reimer, djreimer]
-* Add uniq to standard filters [Florian Weingarten, fw42]
-* Add exception_handler feature (#397) and #254 [Bogdan Gusiev, bogdan and Florian Weingarten, fw42]
-* Optimize variable parsing to avoid repeated regex evaluation during template rendering #383 [Jason Hiltz-Laforge, jasonhl]
-* Optimize checking for block interrupts to reduce object allocation #380 [Jason Hiltz-Laforge, jasonhl] 
-* Properly set context rethrow_errors on render! #349 [Thierry Joyal, tjoyal]
-* Fix broken rendering of variables which are equal to false (#345) [Florian Weingarten, fw42]
-* Remove ActionView template handler [Dylan Thacker-Smith, dylanahsmith]
-* Freeze lots of string literals for new Ruby 2.1 optimization (#297) [Florian Weingarten, fw42]
-* Allow newlines in tags and variables (#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 (#306) [Adam Doeler, releod]
+* ...
+* 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 (#250) [Nick Jones, dntj]
-* Prevent arbitrary method invocation on condition objects (#274) [Dylan Thacker-Smith, dylanahsmith]
-* Don't call to_sym when creating conditions for security reasons (#273) [Bouke van der Bijl, bouk]
-* Fix resource counting bug with respond_to?(:length) (#263) [Florian Weingarten, fw42]
-* Allow specifying custom patterns for template filenames (#284) [Andrei Gladkyi, agladkyi]
-* Allow drops to optimize loading a slice of elements (#282) [Tom Burns, boourns]
-* Support for passing variables to snippets in subdirs (#271) [Joost Hietbrink, joost]
-* Add a class cache to avoid runtime extend calls (#249) [James Tucker, raggi]
-* Remove some legacy Ruby 1.8 compatibility code (#276) [Florian Weingarten, fw42]
-* Add default filter to standard filters (#267) [Derrick Reimer, djreimer]
-* Add optional strict parsing and warn parsing (#235) [Tristan Hume, trishume]
-* Add I18n syntax error translation (#241) [Simon Hørup Eskildsen, Sirupsen]
-* Make sort filter work on enumerable drops (#239) [Florian Weingarten, fw42]
-* Fix clashing method names in enumerable drops (#238) [Florian Weingarten, fw42]
-* Make map filter work on enumerable drops (#233) [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]
+* Raise `Liquid::ArgumentError` instead of `::ArgumentError` when filter has wrong number of arguments #309 [Bogdan Gusiev, bogdan]
 
-## 2.6.1 / 2014-01-10 / branch "2-6-stable"
-
-Security fix, cherry-picked from master (4e14a65):
-* Don't call to_sym when creating conditions for security reasons (#273) [Bouke van der Bijl, bouk]
-* Prevent arbitrary method invocation on condition objects (#274) [Dylan Thacker-Smith, dylanahsmith]
-
-## 2.6.0 / 2013-11-25
+## 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.
@@ -92,15 +47,9 @@ The following releases will only be tested against Ruby 1.9 and Ruby 2.0 and are
 * Better documentation for 'include' tag (closes #163) [Peter Schröder, phoet]
 * Use of BigDecimal on filters to have better precision (closes #155) [Arthur Nogueira Neves, arthurnn]
 
-## 2.5.5 / 2014-01-10 / branch "2-5-stable"
+## 2.5.4 / 2013-11-11 / branch "2.5-stable"
 
-Security fix, cherry-picked from master (4e14a65):
-* Don't call to_sym when creating conditions for security reasons (#273) [Bouke van der Bijl, bouk]
-* Prevent arbitrary method invocation on condition objects (#274) [Dylan Thacker-Smith, dylanahsmith]
-
-## 2.5.4 / 2013-11-11
-
-* Fix "can't convert Fixnum into String" for "replace" (#173), [wǒ_is神仙, jsw0528]
+* Fix "can't convert Fixnum into String" for "replace", see #173, [wǒ_is神仙, jsw0528]
 
 ## 2.5.3 / 2013-10-09
 

README.md

@@ -1,6 +1,4 @@
-[![Build Status](https://api.travis-ci.org/Shopify/liquid.svg?branch=master)](http://travis-ci.org/Shopify/liquid)
-[![Inline docs](http://inch-ci.org/github/Shopify/liquid.svg?branch=master)](http://inch-ci.org/github/Shopify/liquid)
-
+[![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)

Rakefile

@@ -1,5 +1,6 @@
 require 'rake'
 require 'rake/testtask'
+require 'rake/extensiontask'
 $LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
 require "liquid/version"
 
@@ -8,7 +9,7 @@ task :default => 'test'
 desc 'run test suite with default parser'
 Rake::TestTask.new(:base_test) do |t|
   t.libs << '.' << 'lib' << 'test'
-  t.test_files = FileList['test/{integration,unit}/**/*_test.rb']
+  t.test_files = FileList['test/liquid/**/*_test.rb']
   t.verbose = false
 end
 
@@ -64,9 +65,13 @@ namespace :profile do
     ruby "./performance/profile.rb"
   end
 
-  desc "Run the liquid profile/performance coverage with strict parsing"
-  task :strict do
-    ruby "./performance/profile.rb strict"
+  task :stackprof do
+    ruby "./performance/stackprof.rb"
+  end
+
+  desc "Run KCacheGrind"
+  task :grind => :run  do
+    system "qcachegrind /tmp/liquid.rubyprof_calltreeprinter.txt"
   end
 
 end
@@ -75,3 +80,8 @@ desc "Run example"
 task :example do
   ruby "-w -d -Ilib example/server/server.rb"
 end
+
+Rake::ExtensionTask.new "liquid" do |ext|
+  ext.lib_dir = "lib/liquid"
+end
+Rake::Task[:test].prerequisites << :compile

example/server/example_servlet.rb

@@ -23,7 +23,7 @@ class Servlet < LiquidServlet
   end
 
   def products
-    { 'products' => products_list, 'more_products' => more_products_list, 'description' => description, 'section' => 'Snowboards', 'cool_products' => true}
+    { 'products' => products_list, 'description' => description, 'section' => 'Snowboards', 'cool_products' => true}
   end
 
   private
@@ -34,11 +34,6 @@ class Servlet < LiquidServlet
     {'name' => 'Arbor Diamond', 'price' => 59900, 'description' => 'the *arbor diamond* is a made up product because im obsessed with arbor and have no creativity'}]
   end
 
-  def more_products_list
-    [{'name' => 'Arbor Catalyst', 'price' => 39900, 'description' => 'the *arbor catalyst* is an advanced drop-through for freestyle and flatground performance and versatility' },
-    {'name' => 'Arbor Fish', 'price' => 40000, 'description' => 'the *arbor fish* is a compact pin that features an extended wheelbase and time-honored teardrop shape'}]
-  end
-
   def description
     "List of Products ~ This is a list of products with price and description."
   end

example/server/liquid_servlet.rb

@@ -11,8 +11,7 @@ class LiquidServlet < WEBrick::HTTPServlet::AbstractServlet
   private
 
   def handle(type, req, res)
-    @request = req
-    @response = res
+    @request, @response = req, res
 
     @request.path_info =~ /(\w+)\z/
     @action = $1 || 'index'

example/server/templates/index.liquid

@@ -3,4 +3,4 @@
 <p>It is {{date}}</p>
 
 
-<p>Check out the <a href="/products">Products</a> screen </p>
+<p>Check out the <a href="http://localhost:3000/products">Products</a> screen </p>

example/server/templates/products.liquid

@@ -16,12 +16,12 @@
   </head>
 
   <body>
-    {% assign all_products = products | concat: more_products  %}
+
     <h1>{{ description | split: '~' | first }}</h1>
 
     <h2>{{ description | split: '~' | last }}</h2>
 
-    <h2>There are currently {{all_products | count}} products in the {{section}} catalog</h2>
+    <h2>There are currently {{products | count}} products in the {{section}} catalog</h2>
 
     {% if cool_products %}
       Cool products :)
@@ -31,7 +31,7 @@
 
     <ul id="products">
 
-      {% for product in all_products %}
+      {% for product in products %}
         <li>
           <h2>{{product.name}}</h2>
           Only {{product.price | price }}

ext/liquid/block.c

@@ -0,0 +1,167 @@
+#include "liquid_ext.h"
+
+VALUE cLiquidBlock;
+ID intern_assert_missing_delimitation, intern_block_delimiter, intern_is_blank,
+   intern_new_with_options, intern_tags, intern_unknown_tag, intern_unterminated_tag,
+   intern_unterminated_variable;
+
+struct liquid_tag
+{
+    char *name, *markup;
+    long name_length, markup_length;
+};
+
+static bool parse_tag(struct liquid_tag *tag, char *token, long token_length)
+{
+    // Strip {{ and }} braces
+    token += 2;
+    token_length -= 4;
+
+    char *end = token + token_length;
+    while (token < end && isspace(*token))
+        token++;
+    tag->name = token;
+
+    char c = *token;
+    while (token < end && (isalnum(c) || c == '_'))
+        c = *(++token);
+    tag->name_length = token - tag->name;
+    if (!tag->name_length) {
+        memset(tag, 0, sizeof(*tag));
+        return false;
+    }
+
+    while (token < end && isspace(*token))
+        token++;
+    tag->markup = token;
+
+    char *last = end - 1;
+    while (token < last && isspace(*last))
+        last--;
+    end = last + 1;
+    tag->markup_length = end - token;
+    return true;
+}
+
+static VALUE rb_parse_body(VALUE self, VALUE tokenizerObj)
+{
+    struct liquid_tokenizer *tokenizer = LIQUID_TOKENIZER_GET_STRUCT(tokenizerObj);
+
+    bool blank = true;
+    VALUE nodelist = rb_iv_get(self, "@nodelist");
+    if (nodelist == Qnil) {
+        nodelist = rb_ary_new();
+        rb_iv_set(self, "@nodelist", nodelist);
+    } else {
+        rb_ary_clear(nodelist);
+    }
+
+    struct token token;
+    while (true) {
+        liquid_tokenizer_next(tokenizer, &token);
+        switch (token.type) {
+        case TOKEN_NONE:
+            /*
+             * Make sure that it's ok to end parsing in the current block.
+             * Effectively this method will throw an exception unless the current block is
+             * of type Document
+             */
+            rb_funcall(self, intern_assert_missing_delimitation, 0);
+            goto done;
+        case TOKEN_INVALID:
+        {
+            VALUE token_obj = rb_str_new(token.str, token.length);
+            if (token.str[1] == '%')
+                rb_funcall(self, intern_unterminated_tag, 1, token_obj);
+            else
+                rb_funcall(self, intern_unterminated_variable, 1, token_obj);
+            break;
+        }
+        case TOKEN_TAG:
+        {
+            struct liquid_tag tag;
+            if (!parse_tag(&tag, token.str, token.length)) {
+                // FIXME: provide more appropriate error message
+                rb_funcall(self, intern_unterminated_tag, 1, rb_str_new(token.str, token.length));
+            } else {
+                if (tag.name_length >= 3 && !memcmp(tag.name, "end", 3)) {
+                    VALUE block_delimiter = rb_funcall(self, intern_block_delimiter, 0);
+                    if (TYPE(block_delimiter) == T_STRING &&
+                        tag.name_length == RSTRING_LEN(block_delimiter) &&
+                        !memcmp(tag.name, RSTRING_PTR(block_delimiter), tag.name_length))
+                    {
+                        goto done;
+                    }
+                }
+
+                VALUE tags = rb_funcall(cLiquidTemplate, intern_tags, 0);
+                Check_Type(tags, T_HASH);
+                VALUE tag_name = rb_str_new(tag.name, tag.name_length);
+                VALUE tag_class = rb_hash_lookup(tags, tag_name);
+                VALUE markup = rb_str_new(tag.markup, tag.markup_length);
+                if (tag_class != Qnil) {
+                    VALUE options = rb_iv_get(self, "@options");
+                    if (options == Qnil)
+                        options = rb_hash_new();
+                    VALUE new_tag = rb_funcall(tag_class, intern_new_with_options, 4,
+                                               tag_name, markup, tokenizerObj, options);
+                    if (blank) {
+                        VALUE blank_block = rb_funcall(new_tag, intern_is_blank, 0);
+                        if (blank_block == Qnil || blank_block == Qfalse)
+                            blank = false;
+                    }
+                    rb_ary_push(nodelist, new_tag);
+                } else {
+                    rb_funcall(self, intern_unknown_tag, 3, tag_name, markup, tokenizerObj);
+                    /*
+                     * multi-block tags may store the nodelist in a block array on unknown_tag
+                     * then replace @nodelist with a new array. We need to use the new array
+                     * for the block following the tag token.
+                     */
+                    nodelist = rb_iv_get(self, "@nodelist");
+                }
+            }
+            break;
+        }
+        case TOKEN_VARIABLE:
+        {
+            VALUE markup = rb_str_new(token.str + 2, token.length - 4);
+            VALUE options = rb_iv_get(self, "@options");
+            VALUE new_var = rb_funcall(cLiquidVariable, intern_new, 2, markup, options);
+            rb_ary_push(nodelist, new_var);
+            blank = false;
+            break;
+        }
+        case TOKEN_STRING:
+            rb_ary_push(nodelist, liquid_string_slice_new(token.str, token.length));
+            if (blank) {
+                int i;
+                for (i = 0; i < token.length; i++) {
+                    if (!isspace(token.str[i])) {
+                        blank = false;
+                        break;
+                    }
+                }
+            }
+            break;
+        }
+    }
+done:
+    rb_iv_set(self, "@blank", blank ? Qtrue : Qfalse);
+    return Qnil;
+}
+
+void init_liquid_block()
+{
+    intern_assert_missing_delimitation = rb_intern("assert_missing_delimitation!");
+    intern_block_delimiter = rb_intern("block_delimiter");
+    intern_is_blank = rb_intern("blank?");
+    intern_new_with_options = rb_intern("new_with_options");
+    intern_tags = rb_intern("tags");
+    intern_unknown_tag = rb_intern("unknown_tag");
+    intern_unterminated_tag = rb_intern("unterminated_tag");
+    intern_unterminated_variable = rb_intern("unterminated_variable");
+
+    cLiquidBlock = rb_define_class_under(mLiquid, "Block", cLiquidTag);
+    rb_define_method(cLiquidBlock, "parse_body", rb_parse_body, 1);
+}

ext/liquid/block.h

@@ -0,0 +1,8 @@
+#ifndef LIQUID_BLOCK_H
+#define LIQUID_BLOCK_H
+
+void init_liquid_block();
+
+extern VALUE cLiquidBlock;
+
+#endif

ext/liquid/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+$CFLAGS << ' -Wall'
+create_makefile("liquid/liquid")

ext/liquid/liquid_ext.c

@@ -0,0 +1,18 @@
+#include "liquid_ext.h"
+
+VALUE mLiquid;
+VALUE cLiquidTemplate, cLiquidTag, cLiquidVariable;
+ID intern_new;
+
+void Init_liquid(void)
+{
+    intern_new = rb_intern("new");
+    mLiquid = rb_define_module("Liquid");
+    cLiquidTemplate = rb_define_class_under(mLiquid, "Template", rb_cObject);
+    cLiquidTag = rb_define_class_under(mLiquid, "Tag", rb_cObject);
+    cLiquidVariable = rb_define_class_under(mLiquid, "Variable", rb_cObject);
+
+    init_liquid_tokenizer();
+    init_liquid_block();
+    init_liquid_string_slice();
+}

ext/liquid/liquid_ext.h

@@ -0,0 +1,17 @@
+#ifndef LIQUID_EXT_H
+#define LIQUID_EXT_H
+
+#include <stdbool.h>
+#include <ctype.h>
+#include <ruby.h>
+
+#include "tokenizer.h"
+#include "block.h"
+#include "slice.h"
+#include "utils.h"
+
+extern ID intern_new;
+extern VALUE mLiquid;
+extern VALUE cLiquidTemplate, cLiquidTag, cLiquidVariable;
+
+#endif

ext/liquid/slice.c

@@ -0,0 +1,167 @@
+#include "liquid_ext.h"
+
+VALUE cLiquidStringSlice;
+
+static void mark_slice(void *ptr)
+{
+    if (!ptr)
+        return;
+    struct string_slice *slice = ptr;
+    rb_gc_mark(slice->source);
+}
+
+static void free_slice(void *ptr)
+{
+    struct string_slice *slice = ptr;
+    xfree(slice);
+}
+
+VALUE liquid_string_slice_new(const char *str, long length)
+{
+    return rb_funcall(cLiquidStringSlice, intern_new, 3, rb_str_new(str, length), INT2FIX(0), INT2FIX(length));
+}
+
+static VALUE rb_allocate(VALUE klass)
+{
+    struct string_slice *slice;
+    VALUE obj = Data_Make_Struct(klass, struct string_slice, mark_slice, free_slice, slice);
+    return obj;
+}
+
+static VALUE rb_initialize(VALUE self, VALUE source, VALUE offset_value, VALUE length_value)
+{
+    long offset = rb_fix2int(offset_value);
+    long length = rb_fix2int(length_value);
+    if (length < 0)
+        rb_raise(rb_eArgError, "negative string length");
+    if (offset < 0)
+        rb_raise(rb_eArgError, "negative string offset");
+
+    if (TYPE(source) == T_DATA && RBASIC_CLASS(source) == cLiquidStringSlice) {
+        struct string_slice *source_slice = DATA_PTR(source);
+        source = source_slice->source;
+        offset += source_slice->str - RSTRING_PTR(source);
+    } else {
+        source = rb_string_value(&source);
+        source = rb_str_dup_frozen(source);
+    }
+
+    struct string_slice *slice;
+    Data_Get_Struct(self, struct string_slice, slice);
+    slice->source = source;
+    slice->str = RSTRING_PTR(source) + offset;
+    slice->length = length;
+    if (length > RSTRING_LEN(source) - offset)
+        rb_raise(rb_eArgError, "slice bounds outside source string bounds");
+
+    return Qnil;
+}
+
+static VALUE rb_slice_to_str(VALUE self)
+{
+    struct string_slice *slice;
+    Data_Get_Struct(self, struct string_slice, slice);
+
+    VALUE source = slice->source;
+    if (slice->str == RSTRING_PTR(source) && slice->length == RSTRING_LEN(source))
+        return source;
+
+    source = rb_str_new(slice->str, slice->length);
+    slice->source = source;
+    slice->str = RSTRING_PTR(source);
+    return source;
+}
+
+static VALUE rb_slice_slice(VALUE self, VALUE offset, VALUE length)
+{
+    return rb_funcall(cLiquidStringSlice, intern_new, 3, self, offset, length);
+}
+
+static VALUE rb_slice_length(VALUE self)
+{
+    struct string_slice *slice;
+    Data_Get_Struct(self, struct string_slice, slice);
+    return INT2FIX(slice->length);
+}
+
+static VALUE rb_slice_equal(VALUE self, VALUE other)
+{
+    struct string_slice *this_slice;
+    Data_Get_Struct(self, struct string_slice, this_slice);
+
+    const char *other_str;
+    long other_length;
+    if (TYPE(other) == T_DATA && RBASIC_CLASS(other) == cLiquidStringSlice) {
+        struct string_slice *other_slice = DATA_PTR(other);
+        other_str = other_slice->str;
+        other_length = other_slice->length;
+    } else {
+        other = rb_string_value(&other);
+        other_length = RSTRING_LEN(other);
+        other_str = RSTRING_PTR(other);
+    }
+    bool equal = this_slice->length == other_length && !memcmp(this_slice->str, other_str, other_length);
+    return equal ? Qtrue : Qfalse;
+}
+
+static VALUE rb_slice_inspect(VALUE self)
+{
+    VALUE quoted = rb_str_inspect(rb_slice_to_str(self));
+    return rb_sprintf("#<Liquid::StringSlice: %.*s>", (int)RSTRING_LEN(quoted), RSTRING_PTR(quoted));
+}
+
+static VALUE rb_slice_join(VALUE klass, VALUE ary)
+{
+    ary = rb_ary_to_ary(ary);
+
+    long i;
+    long result_length = 0;
+    for (i = 0; i < RARRAY_LEN(ary); i++) {
+        VALUE element = RARRAY_AREF(ary, i);
+
+        if (TYPE(element) == T_DATA && RBASIC_CLASS(element) == cLiquidStringSlice) {
+            struct string_slice *slice = DATA_PTR(element);
+            result_length += slice->length;
+        } else if (TYPE(element) == T_STRING) {
+            result_length += RSTRING_LEN(element);
+        }
+    }
+
+    VALUE result = rb_str_buf_new(result_length);
+    for (i = 0; i < RARRAY_LEN(ary); i++) {
+        VALUE element = RARRAY_AREF(ary, i);
+
+        const char *element_string;
+        long element_length;
+        if (TYPE(element) == T_DATA && RBASIC_CLASS(element) == cLiquidStringSlice) {
+            struct string_slice *slice = DATA_PTR(element);
+            element_string = slice->str;
+            element_length = slice->length;
+        } else if (NIL_P(element)) {
+            continue;
+        } else {
+            element = rb_check_string_type(element);
+            if (NIL_P(element))
+                continue;
+            element_string = RSTRING_PTR(element);
+            element_length = RSTRING_LEN(element);
+        }
+        rb_str_buf_cat(result, element_string, element_length);
+    }
+    return result;
+}
+
+void init_liquid_string_slice()
+{
+    cLiquidStringSlice = rb_define_class_under(mLiquid, "StringSlice", rb_cObject);
+    rb_define_singleton_method(cLiquidStringSlice, "join", rb_slice_join, 1);
+    rb_define_alloc_func(cLiquidStringSlice, rb_allocate);
+    rb_define_method(cLiquidStringSlice, "initialize", rb_initialize, 3);
+    rb_define_method(cLiquidStringSlice, "==", rb_slice_equal, 1);
+    rb_define_method(cLiquidStringSlice, "length", rb_slice_length, 0);
+    rb_define_alias(cLiquidStringSlice,  "size", "length");
+    rb_define_method(cLiquidStringSlice, "slice", rb_slice_slice, 2);
+    rb_define_method(cLiquidStringSlice, "to_str", rb_slice_to_str, 0);
+    rb_define_alias(cLiquidStringSlice,  "to_s", "to_str");
+    rb_define_method(cLiquidStringSlice, "inspect", rb_slice_inspect, 0);
+}

ext/liquid/slice.h

@@ -0,0 +1,18 @@
+#ifndef LIQUID_SLICE_H
+#define LIQUID_SLICE_H
+
+extern VALUE cLiquidStringSlice;
+
+struct string_slice {
+    VALUE source;
+    const char *str;
+    long length;
+};
+
+VALUE liquid_string_slice_new(const char *str, long length);
+
+void init_liquid_string_slice();
+
+#define STRING_SLICE_GET_STRUCT(obj) ((struct string_slice *)obj_get_data_ptr(obj, cLiquidStringSlice))
+
+#endif

ext/liquid/tokenizer.c

@@ -0,0 +1,113 @@
+#include "liquid_ext.h"
+
+VALUE cLiquidTokenizer;
+
+static void free_tokenizer(void *ptr)
+{
+    struct liquid_tokenizer *tokenizer = ptr;
+    xfree(tokenizer);
+}
+
+static VALUE rb_allocate(VALUE klass)
+{
+    VALUE obj;
+    struct liquid_tokenizer *tokenizer;
+
+    obj = Data_Make_Struct(klass, struct liquid_tokenizer, NULL, free_tokenizer, tokenizer);
+    return obj;
+}
+
+static VALUE rb_initialize(VALUE self, VALUE source)
+{
+    struct liquid_tokenizer *tokenizer;
+
+    source = rb_string_value(&source);
+    Data_Get_Struct(self, struct liquid_tokenizer, tokenizer);
+    tokenizer->cursor = RSTRING_PTR(source);
+    tokenizer->length = RSTRING_LEN(source);
+    return Qnil;
+}
+
+void liquid_tokenizer_next(struct liquid_tokenizer *tokenizer, struct token *token)
+{
+    if (tokenizer->length <= 0) {
+        memset(token, 0, sizeof(*token));
+        return;
+    }
+    token->type = TOKEN_STRING;
+
+    char *cursor = tokenizer->cursor;
+    char *last = tokenizer->cursor + tokenizer->length - 1;
+
+    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;
+        }
+        char *incomplete_end = cursor;
+        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;
+            }
+            cursor = incomplete_end;
+            goto found;
+        } else {
+            while (cursor < last) {
+                if (*cursor++ != '}')
+                    continue;
+                if (*cursor++ != '}') {
+                    incomplete_end = cursor - 1;
+                    continue;
+                }
+                token->type = TOKEN_VARIABLE;
+                goto found;
+            }
+            cursor = incomplete_end;
+            goto found;
+        }
+    }
+    cursor = last + 1;
+found:
+    token->str = tokenizer->cursor;
+    token->length = cursor - tokenizer->cursor;
+    tokenizer->cursor += token->length;
+    tokenizer->length -= token->length;
+}
+
+static VALUE rb_next(VALUE self)
+{
+    struct liquid_tokenizer *tokenizer;
+    Data_Get_Struct(self, struct liquid_tokenizer, tokenizer);
+
+    struct token token;
+    liquid_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, rb_allocate);
+    rb_define_method(cLiquidTokenizer, "initialize", rb_initialize, 1);
+    rb_define_method(cLiquidTokenizer, "next", rb_next, 0);
+    rb_define_alias(cLiquidTokenizer, "shift", "next");
+}

ext/liquid/tokenizer.h

@@ -0,0 +1,30 @@
+#ifndef LIQUID_TOKENIZER_H
+#define LIQUID_TOKENIZER_H
+
+extern VALUE cLiquidTokenizer;
+
+enum token_type {
+    TOKEN_NONE,
+    TOKEN_INVALID,
+    TOKEN_STRING,
+    TOKEN_TAG,
+    TOKEN_VARIABLE
+};
+
+struct token {
+    enum token_type type;
+    char *str;
+    int length;
+};
+
+struct liquid_tokenizer {
+    char *cursor;
+    int length;
+};
+
+void init_liquid_tokenizer();
+void liquid_tokenizer_next(struct liquid_tokenizer *tokenizer, struct token *token);
+
+#define LIQUID_TOKENIZER_GET_STRUCT(obj) ((struct liquid_tokenizer *)obj_get_data_ptr(obj, cLiquidTokenizer))
+
+#endif

ext/liquid/utils.c

@@ -0,0 +1,21 @@
+#include <ruby.h>
+
+void raise_type_error(VALUE expected, VALUE got)
+{
+    rb_raise(rb_eTypeError, "wrong argument type %s (expected %s)",
+                             rb_class2name(got), rb_class2name(expected));
+}
+
+void check_class(VALUE obj, int type, VALUE klass)
+{
+    Check_Type(obj, type);
+    VALUE obj_klass = RBASIC_CLASS(obj);
+    if (obj_klass != klass)
+        raise_type_error(klass, obj_klass);
+}
+
+void *obj_get_data_ptr(VALUE obj, VALUE klass)
+{
+    check_class(obj, T_DATA, klass);
+    return DATA_PTR(obj);
+}

ext/liquid/utils.h

@@ -0,0 +1,8 @@
+#ifndef LIQUID_UTILS_H
+#define LIQUID_UTILS_H
+
+void raise_type_error(VALUE expected, VALUE got);
+void check_class(VALUE klass);
+void *obj_get_data_ptr(VALUE obj, VALUE klass);
+
+#endif

init.rb

@@ -0,0 +1,8 @@
+require 'liquid'
+require 'extras/liquid_view'
+
+if defined? ActionView::Template and ActionView::Template.respond_to? :register_template_handler
+  ActionView::Template
+else
+  ActionView::Base
+end.register_template_handler(:liquid, LiquidView)

lib/extras/liquid_view.rb

@@ -0,0 +1,51 @@
+# LiquidView is a action view extension class. You can register it with rails
+# and use liquid as an template system for .liquid files
+#
+# Example
+#
+#   ActionView::Base::register_template_handler :liquid, LiquidView
+class LiquidView
+  PROTECTED_ASSIGNS = %w( template_root response _session template_class action_name request_origin session template
+                          _response url _request _cookies variables_added _flash params _headers request cookies
+                          ignore_missing_templates flash _params logger before_filter_chain_aborted headers )
+  PROTECTED_INSTANCE_VARIABLES = %w( @_request @controller @_first_render @_memoized__pick_template @view_paths
+                                     @helpers @assigns_added @template @_render_stack @template_format @assigns )
+
+  def self.call(template)
+    "LiquidView.new(self).render(template, local_assigns)"
+  end
+
+  def initialize(view)
+    @view = view
+  end
+
+  def render(template, local_assigns = nil)
+    @view.controller.headers["Content-Type"] ||= 'text/html; charset=utf-8'
+
+    # Rails 2.2 Template has source, but not locals
+    if template.respond_to?(:source) && !template.respond_to?(:locals)
+      assigns = (@view.instance_variables - PROTECTED_INSTANCE_VARIABLES).inject({}) do |hash, ivar|
+                  hash[ivar[1..-1]] = @view.instance_variable_get(ivar)
+                  hash
+                end
+    else
+      assigns = @view.assigns.reject{ |k,v| PROTECTED_ASSIGNS.include?(k) }
+    end
+
+    source = template.respond_to?(:source) ? template.source : template
+    local_assigns = (template.respond_to?(:locals) ? template.locals : local_assigns) || {}
+
+    if content_for_layout = @view.instance_variable_get("@content_for_layout")
+      assigns['content_for_layout'] = content_for_layout
+    end
+    assigns.merge!(local_assigns.stringify_keys)
+
+    liquid = Liquid::Template.parse(source)
+    liquid.render(assigns, :filters => [@view.controller.master_helper_module], :registers => {:action_view => @view, :controller => @view.controller})
+  end
+
+  def compilable?
+    false
+  end
+
+end

lib/liquid.rb

@@ -21,28 +21,27 @@
 
 module Liquid
   FilterSeparator             = /\|/
-  ArgumentSeparator           = ','.freeze
-  FilterArgumentSeparator     = ':'.freeze
-  VariableAttributeSeparator  = '.'.freeze
+  ArgumentSeparator           = ','
+  FilterArgumentSeparator     = ':'
+  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             = /\A(?:'[^']+'|"[^"]+"|[^'"])*#{FilterSeparator}(?:#{StrictQuotedFragment})(?:#{FirstFilterArgument}(?:#{OtherFilterArgument})*)?/o
+  Expression                  = /(?:#{QuotedFragment}(?:#{SpacelessFilter})*)/o
   TagAttributes               = /(\w+)\s*\:\s*(#{QuotedFragment})/o
-  AnyStartingTag              = /\{\{|\{\%/
-  PartialTemplateParser       = /#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableIncompleteEnd}/om
-  TemplateParser              = /(#{PartialTemplateParser}|#{AnyStartingTag})/om
   VariableParser              = /\[[^\]]+\]|#{VariableSegment}+\??/o
-
-  singleton_class.send(:attr_accessor, :cache_classes)
-  self.cache_classes = true
 end
 
+require 'liquid/liquid'
 require "liquid/version"
 require 'liquid/lexer'
 require 'liquid/parser'
@@ -52,24 +51,18 @@ require 'liquid/extensions'
 require 'liquid/errors'
 require 'liquid/interrupts'
 require 'liquid/strainer'
-require 'liquid/expression'
 require 'liquid/context'
-require 'liquid/parser_switching'
 require 'liquid/tag'
 require 'liquid/block'
-require 'liquid/block_body'
 require 'liquid/document'
 require 'liquid/variable'
-require 'liquid/variable_lookup'
-require 'liquid/range_lookup'
 require 'liquid/file_system'
-require 'liquid/resource_limits'
 require 'liquid/template'
+require 'liquid/htmltags'
 require 'liquid/standardfilters'
 require 'liquid/condition'
 require 'liquid/module_ex'
 require 'liquid/utils'
-require 'liquid/token'
 
 # Load all the tags of the standard library
 #

lib/liquid/block.rb

@@ -1,26 +1,12 @@
 module Liquid
   class Block < Tag
-    def initialize(tag_name, markup, options)
+    def initialize(tag_name, markup, tokens)
       super
-      @blank = true
-    end
-
-    def parse(tokens)
-      @body = BlockBody.new
-      while more = parse_body(@body, tokens)
-      end
-    end
-
-    def render(context)
-      @body.render(context)
+      parse_body(tokens)
     end
 
     def blank?
-      @blank
-    end
-
-    def nodelist
-      @body.nodelist
+      @blank || false
     end
 
     # warnings of this block and all sub-tags
@@ -37,47 +23,79 @@ module Liquid
 
     def unknown_tag(tag, params, tokens)
       case tag
-      when 'else'.freeze
-        raise SyntaxError.new(options[:locale].t("errors.syntax.unexpected_else".freeze,
+      when 'else'
+        raise SyntaxError.new(options[:locale].t("errors.syntax.unexpected_else", 
                                                  :block_name => block_name))
-      when 'end'.freeze
-        raise SyntaxError.new(options[:locale].t("errors.syntax.invalid_delimiter".freeze,
-                                                 :block_name => block_name,
+      when 'end'
+        raise SyntaxError.new(options[:locale].t("errors.syntax.invalid_delimiter", 
+                                                 :block_name => block_name, 
                                                  :block_delimiter => block_delimiter))
       else
-        raise SyntaxError.new(options[:locale].t("errors.syntax.unknown_tag".freeze, :tag => tag))
+        raise SyntaxError.new(options[:locale].t("errors.syntax.unknown_tag", :tag => tag))
       end
     end
 
+    def block_delimiter
+      "end#{block_name}"
+    end
+
     def block_name
       @tag_name
     end
 
-    def block_delimiter
-      @block_delimiter ||= "end#{block_name}"
-    end
-
-    def format
-      "{% #{raw} %}#{@body.format}{% #{block_delimiter} %}"
+    def render(context)
+      render_all(@nodelist, context)
     end
 
     protected
 
-    def parse_body(body, tokens)
-      body.parse(tokens, options) do |end_tag_name, end_tag_params|
-        @blank &&= body.blank?
+    def unterminated_variable(token)
+      raise SyntaxError.new(options[:locale].t("errors.syntax.variable_termination", :token => token, :tag_end => VariableEnd.inspect))
+    end
 
-        return false if end_tag_name == block_delimiter
-        unless end_tag_name
-          raise SyntaxError.new(@options[:locale].t("errors.syntax.tag_never_closed".freeze, :block_name => block_name))
+    def unterminated_tag(token)
+      raise SyntaxError.new(options[:locale].t("errors.syntax.tag_termination", :token => token, :tag_end => TagEnd.inspect))
+    end
+
+    def assert_missing_delimitation!
+      raise SyntaxError.new(options[:locale].t("errors.syntax.tag_never_closed", :block_name => block_name))
+    end
+
+    def render_all(list, context)
+      output = []
+      context.resource_limits[:render_length_current] = 0
+      context.resource_limits[:render_score_current] += list.length
+
+      list.each do |token|
+        # Break out if we have any unhanded interrupts.
+        break if context.has_interrupt?
+
+        begin
+          # If we get an Interrupt that means the block must stop processing. An
+          # Interrupt is any command that stops block execution such as {% break %}
+          # or {% continue %}
+          if token.is_a? Continue or token.is_a? Break
+            context.push_interrupt(token.interrupt)
+            break
+          end
+
+          token_output = (token.respond_to?(:render) ? token.render(context) : token)
+          context.increment_used_resources(:render_length_current, token_output)
+          if context.resource_limits_reached?
+            context.resource_limits[:reached] = true
+            raise MemoryError.new("Memory limits exceeded")
+          end
+          unless token.is_a?(Block) && token.blank?
+            output << token_output
+          end
+        rescue MemoryError => e
+          raise e
+        rescue ::StandardError => e
+          output << (context.handle_error(e))
         end
-
-        # this tag is not registered with the system
-        # pass it to the current block for special handling or error reporting
-        unknown_tag(end_tag_name, end_tag_params, tokens)
       end
 
-      true
+      StringSlice.join(output)
     end
   end
 end

lib/liquid/block_body.rb

@@ -1,143 +0,0 @@
-module Liquid
-  class BlockBody
-    FullToken = /\A#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/om
-    ContentOfVariable = /\A#{VariableStart}(.*)#{VariableEnd}\z/om
-    TAGSTART = "{%".freeze
-    VARSTART = "{{".freeze
-
-    attr_reader :nodelist
-
-    def initialize
-      @nodelist = []
-      @blank = true
-    end
-
-    def parse(tokens, options)
-      while token = tokens.shift
-        begin
-          unless token.empty?
-            case
-            when token.start_with?(TAGSTART)
-              if token =~ FullToken
-                tag_name = $1
-                markup = $2
-                # fetch the tag from registered blocks
-                if tag = Template.tags[tag_name]
-                  markup = token.child(markup) if token.is_a?(Token)
-                  new_tag = tag.parse(tag_name, markup, tokens, options)
-                  new_tag.line_number = token.line_number if token.is_a?(Token)
-                  @blank &&= new_tag.blank?
-                  @nodelist << new_tag
-                else
-                  # end parsing if we reach an unknown tag and let the caller decide
-                  # determine how to proceed
-                  return yield tag_name, markup
-                end
-              else
-                raise_missing_tag_terminator(token, options)
-              end
-            when token.start_with?(VARSTART)
-              new_var = create_variable(token, options)
-              new_var.line_number = token.line_number if token.is_a?(Token)
-              @nodelist << new_var
-              @blank = false
-            else
-              @nodelist << token
-              @blank &&= !!(token =~ /\A\s*\z/)
-            end
-          end
-        rescue SyntaxError => e
-          e.set_line_number_from_token(token)
-          raise
-        end
-      end
-
-      yield nil, nil
-    end
-
-    def blank?
-      @blank
-    end
-
-    def warnings
-      all_warnings = []
-      nodelist.each do |node|
-        all_warnings.concat(node.warnings || []) if node.respond_to?(:warnings)
-      end
-      all_warnings
-    end
-
-    def render(context)
-      output = []
-      context.resource_limits.render_score += @nodelist.length
-
-      @nodelist.each do |token|
-        # Break out if we have any unhanded interrupts.
-        break if context.has_interrupt?
-
-        begin
-          # If we get an Interrupt that means the block must stop processing. An
-          # Interrupt is any command that stops block execution such as {% break %}
-          # or {% continue %}
-          if token.is_a?(Continue) or token.is_a?(Break)
-            context.push_interrupt(token.interrupt)
-            break
-          end
-
-          token_output = render_token(token, context)
-
-          unless token.is_a?(Block) && token.blank?
-            output << token_output
-          end
-        rescue MemoryError => e
-          raise e
-        rescue ::StandardError => e
-          output << context.handle_error(e, token)
-        end
-      end
-
-      output.join
-    end
-
-    def format
-      @nodelist.map do |node|
-        if node.is_a?(Variable)
-          "{{ #{node.format} }}"
-        elsif node.is_a?(Tag)
-          node.format
-        else
-          node
-        end
-      end.join
-    end
-
-    private
-
-    def render_token(token, context)
-      token_output = (token.respond_to?(:render) ? token.render(context) : token)
-      token_str = token_output.is_a?(Array) ? token_output.join : token_output.to_s
-
-      context.resource_limits.render_length += token_str.length
-      if context.resource_limits.reached?
-        raise MemoryError.new("Memory limits exceeded".freeze)
-      end
-      token_str
-    end
-
-    def create_variable(token, options)
-      token.scan(ContentOfVariable) do |content|
-        markup = token.is_a?(Token) ? token.child(content.first) : content.first
-        return Variable.new(markup, options)
-      end
-      raise_missing_variable_terminator(token, options)
-    end
-
-    def raise_missing_tag_terminator(token, options)
-      raise SyntaxError.new(options[:locale].t("errors.syntax.tag_termination".freeze, :token => token, :tag_end => TagEnd.inspect))
-    end
-
-    def raise_missing_variable_terminator(token, options)
-      raise SyntaxError.new(options[:locale].t("errors.syntax.variable_termination".freeze, :token => token, :tag_end => VariableEnd.inspect))
-    end
-  end
-end

lib/liquid/condition.rb

@@ -3,21 +3,19 @@ module Liquid
   #
   # Example:
   #
-  #   c = Condition.new(1, '==', 1)
+  #   c = Condition.new('1', '==', '1')
   #   c.evaluate #=> true
   #
   class Condition #:nodoc:
     @@operators = {
-      '=='.freeze => lambda { |cond, left, right|  cond.send(:equal_variables, left, right) },
-      '!='.freeze => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
-      '<>'.freeze => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
-      '<'.freeze  => :<,
-      '>'.freeze  => :>,
-      '>='.freeze => :>=,
-      '<='.freeze => :<=,
-      'contains'.freeze => lambda { |cond, left, right|
-        left && right && left.respond_to?(:include?) ? left.include?(right) : false
-      }
+      '==' => lambda { |cond, left, right|  cond.send(:equal_variables, left, right) },
+      '!=' => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
+      '<>' => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
+      '<'  => :<,
+      '>'  => :>,
+      '>=' => :>=,
+      '<=' => :<=,
+      'contains' => lambda { |cond, left, right| left && right ? left.include?(right) : false }
     }
 
     def self.operators
@@ -28,17 +26,9 @@ module Liquid
     attr_accessor :left, :operator, :right
 
     def initialize(left = nil, operator = nil, right = nil)
-      @left = left
-      @operator = operator
-      @right = right
+      @left, @operator, @right = left, operator, right
       @child_relation  = nil
       @child_condition = nil
-
-      if right && right.is_a?(VariableLookup) && right.name.nil?
-        # Strip blank variable lookups resulting from cases like:
-        # {% if foo && bar %}
-        @right = nil
-      end
     end
 
     def evaluate(context = Context.new)
@@ -55,13 +45,11 @@ module Liquid
     end
 
     def or(condition)
-      @child_relation = :or
-      @child_condition = condition
+      @child_relation, @child_condition = :or, condition
     end
 
     def and(condition)
-      @child_relation = :and
-      @child_condition = condition
+      @child_relation, @child_condition = :and, condition
     end
 
     def attach(attachment)
@@ -73,21 +61,7 @@ module Liquid
     end
 
     def inspect
-      "#<Condition #{[@left, @operator, @right].compact.join(' '.freeze)}>"
-    end
-
-    def format
-      out = if operator.nil?
-        Expression.format(left)
-      else
-        "#{Expression.format(left)} #{operator} #{Expression.format(right)}"
-      end
-
-      if @child_relation
-        "#{out} #{@child_relation.to_s} #{@child_condition.format}"
-      else
-        out
-      end
+      "#<Condition #{[@left, @operator, @right].compact.join(' ')}>"
     end
 
     private
@@ -116,21 +90,16 @@ module Liquid
       # If the operator is empty this means that the decision statement is just
       # a single variable. We can just poll this variable from the context and
       # return this as the result.
-      return context.evaluate(left) if op == nil
+      return context[left] if op == nil
 
-      left = context.evaluate(left)
-      right = context.evaluate(right)
+      left, right = context[left], context[right]
 
-      operation = self.class.operators[op] || raise(Liquid::ArgumentError.new("Unknown operator #{op}"))
+      operation = self.class.operators[op] || raise(ArgumentError.new("Unknown operator #{op}"))
 
       if operation.respond_to?(:call)
         operation.call(self, left, right)
       elsif left.respond_to?(operation) and right.respond_to?(operation)
-        begin
-          left.send(operation, right)
-        rescue ::ArgumentError => e
-          raise Liquid::ArgumentError.new(e.message)
-        end
+        left.send(operation, right)
       else
         nil
       end

lib/liquid/context.rb

@@ -14,26 +14,34 @@ module Liquid
   #   context['bob']  #=> nil  class Context
   class Context
     attr_reader :scopes, :errors, :registers, :environments, :resource_limits
-    attr_accessor :exception_handler
 
-    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil)
-      @environments     = [environments].flatten
-      @scopes           = [(outer_scope || {})]
-      @registers        = registers
-      @errors           = []
-      @resource_limits  = resource_limits || ResourceLimits.new(Template.default_resource_limits)
+    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = {})
+      @environments    = [environments].flatten
+      @scopes          = [(outer_scope || {})]
+      @registers       = registers
+      @errors          = []
+      @rethrow_errors  = rethrow_errors
+      @resource_limits = (resource_limits || {}).merge!({ :render_score_current => 0, :assign_score_current => 0 })
       squash_instance_assigns_with_environments
 
-      @this_stack_used = false
-
-      if rethrow_errors
-        self.exception_handler = ->(e) { true }
-      end
-
       @interrupts = []
       @filters = []
     end
 
+    def increment_used_resources(key, obj)
+      @resource_limits[key] += if obj.kind_of?(StringSlice) || obj.kind_of?(String) || obj.kind_of?(Array) || obj.kind_of?(Hash)
+        obj.length
+      else
+        1
+      end
+    end
+
+    def resource_limits_reached?
+      (@resource_limits[:render_length_limit] && @resource_limits[:render_length_current] > @resource_limits[:render_length_limit]) ||
+      (@resource_limits[:render_score_limit]  && @resource_limits[:render_score_current]  > @resource_limits[:render_score_limit] ) ||
+      (@resource_limits[:assign_score_limit]  && @resource_limits[:assign_score_current]  > @resource_limits[:assign_score_limit] )
+    end
+
     def strainer
       @strainer ||= Strainer.create(self, @filters)
     end
@@ -44,13 +52,26 @@ module Liquid
     # for that
     def add_filters(filters)
       filters = [filters].flatten.compact
-      @filters += filters
-      @strainer = nil
+      filters.each do |f|
+        raise ArgumentError, "Expected module but got: #{f.class}" unless f.is_a?(Module)
+        Strainer.add_known_filter(f)
+      end
+
+      # 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
 
     # are there any not handled interrupts?
     def has_interrupt?
-      !@interrupts.empty?
+      @interrupts.any?
     end
 
     # push an interrupt to the stack. this interrupt is considered not handled.
@@ -63,25 +84,26 @@ module Liquid
       @interrupts.pop
     end
 
-
-    def handle_error(e, token=nil)
-      if e.is_a?(Liquid::Error)
-        e.set_line_number_from_token(token)
-      end
-
+    def handle_error(e)
       errors.push(e)
-      raise if exception_handler && exception_handler.call(e)
-      Liquid::Error.render(e)
+      raise if @rethrow_errors
+
+      case e
+      when SyntaxError
+        "Liquid syntax error: #{e.message}"
+      else
+        "Liquid error: #{e.message}"
+      end
     end
 
     def invoke(method, *args)
-      strainer.invoke(method, *args).to_liquid
+      strainer.invoke(method, *args)
     end
 
     # 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
@@ -103,19 +125,11 @@ module Liquid
     #   end
     #
     #   context['var]  #=> nil
-    def stack(new_scope=nil)
-      old_stack_used = @this_stack_used
-      if new_scope
-        push(new_scope)
-        @this_stack_used = true
-      else
-        @this_stack_used = false
-      end
-
+    def stack(new_scope={})
+      push(new_scope)
       yield
     ensure
-      pop if @this_stack_used
-      @this_stack_used = old_stack_used
+      pop
     end
 
     def clear_instance_assigns
@@ -124,71 +138,138 @@ module Liquid
 
     # Only allow String, Numeric, Hash, Array, Proc, Boolean or <tt>Liquid::Drop</tt>
     def []=(key, value)
-      unless @this_stack_used
-        @this_stack_used = true
-        push({})
-      end
       @scopes[0][key] = value
     end
 
-    # Look up variable, either resolve directly after considering the name. We can directly handle
-    # Strings, digits, floats and booleans (true,false).
-    # If no match is made we lookup the variable in the current scope and
-    # later move up to the parent blocks to see if we can resolve the variable somewhere up the tree.
-    # Some special keywords return symbols. Those symbols are to be called on the rhs object in expressions
-    #
-    # Example:
-    #   products == empty #=> products.empty?
-    def [](expression)
-      evaluate(Expression.parse(expression))
+    def [](key)
+      resolve(key)
     end
 
     def has_key?(key)
-      self[key] != nil
+      resolve(key) != nil
     end
 
-    def evaluate(object)
-      object.respond_to?(:evaluate) ? object.evaluate(self) : object
-    end
+    private
+      LITERALS = {
+        nil => nil, 'nil' => nil, 'null' => nil, '' => nil,
+        'true'  => true,
+        'false' => false,
+        'blank' => :blank?,
+        'empty' => :empty?
+      }
 
-    # Fetches an object starting at the local scope and then moving up the hierachy
-    def find_variable(key)
-
-      # This was changed from find() to find_index() because this is a very hot
-      # path and find_index() is optimized in MRI to reduce object allocation
-      index = @scopes.find_index { |s| s.has_key?(key) }
-      scope = @scopes[index] if index
-
-      variable = nil
-
-      if scope.nil?
-        @environments.each do |e|
-          variable = lookup_and_evaluate(e, key)
-          unless variable.nil?
-            scope = e
-            break
+      # Look up variable, either resolve directly after considering the name. We can directly handle
+      # Strings, digits, floats and booleans (true,false).
+      # If no match is made we lookup the variable in the current scope and
+      # later move up to the parent blocks to see if we can resolve the variable somewhere up the tree.
+      # Some special keywords return symbols. Those symbols are to be called on the rhs object in expressions
+      #
+      # Example:
+      #   products == empty #=> products.empty?
+      def resolve(key)
+        if LITERALS.key?(key)
+          LITERALS[key]
+        else
+          case key
+          when /\A'(.*)'\z/ # Single quoted strings
+            $1
+          when /\A"(.*)"\z/ # Double quoted strings
+            $1
+          when /\A(-?\d+)\z/ # Integer and floats
+            $1.to_i
+          when /\A\((\S+)\.\.(\S+)\)\z/ # Ranges
+            (resolve($1).to_i..resolve($2).to_i)
+          when /\A(-?\d[\d\.]+)\z/ # Floats
+            $1.to_f
+          else
+            variable(key)
           end
         end
       end
 
-      scope     ||= @environments.last || @scopes.last
-      variable  ||= lookup_and_evaluate(scope, key)
+      # Fetches an object starting at the local scope and then moving up the hierachy
+      def find_variable(key)
+        scope = @scopes.find { |s| s.has_key?(key) }
+        variable = nil
 
-      variable = variable.to_liquid
-      variable.context = self if variable.respond_to?(:context=)
+        if scope.nil?
+          @environments.each do |e|
+            if variable = lookup_and_evaluate(e, key)
+              scope = e
+              break
+            end
+          end
+        end
 
-      return variable
-    end
+        scope     ||= @environments.last || @scopes.last
+        variable  ||= lookup_and_evaluate(scope, key)
 
-    def lookup_and_evaluate(obj, key)
-      if (value = obj[key]).is_a?(Proc) && obj.respond_to?(:[]=)
-        obj[key] = (value.arity == 0) ? value.call : value.call(self)
-      else
-        value
+        variable = variable.to_liquid
+        variable.context = self if variable.respond_to?(:context=)
+
+        return variable
       end
-    end
 
-    private
+      # Resolves namespaced queries gracefully.
+      #
+      # Example
+      #  @context['hash'] = {"name" => 'tobi'}
+      #  assert_equal 'tobi', @context['hash.name']
+      #  assert_equal 'tobi', @context['hash["name"]']
+      def variable(markup)
+        parts = markup.scan(VariableParser)
+        square_bracketed = /\A\[(.*)\]\z/
+
+        first_part = parts.shift
+
+        if first_part =~ square_bracketed
+          first_part = resolve($1)
+        end
+
+        if object = find_variable(first_part)
+
+          parts.each do |part|
+            part = resolve($1) if part_resolved = (part =~ square_bracketed)
+
+            # If object is a hash- or array-like object we look for the
+            # presence of the key and if its available we return it
+            if object.respond_to?(:[]) and
+              ((object.respond_to?(:has_key?) and object.has_key?(part)) or
+               (object.respond_to?(:fetch) and part.is_a?(Integer)))
+
+              # if its a proc we will replace the entry with the proc
+              res = lookup_and_evaluate(object, part)
+              object = res.to_liquid
+
+              # Some special cases. If the part wasn't in square brackets and
+              # no key with the same name was found we interpret following calls
+              # as commands and call them on the current object
+            elsif !part_resolved and object.respond_to?(part) and ['size', 'first', 'last'].include?(part)
+
+              object = object.send(part.intern).to_liquid
+
+              # No key was present with the desired value and it wasn't one of the directly supported
+              # keywords either. The only thing we got left is to return nil
+            else
+              return nil
+            end
+
+            # If we are dealing with a drop here we have to
+            object.context = self if object.respond_to?(:context=)
+          end
+        end
+
+        object
+      end # variable
+
+      def lookup_and_evaluate(obj, key)
+        if (value = obj[key]).is_a?(Proc) && obj.respond_to?(:[]=)
+          obj[key] = (value.arity == 0) ? value.call : value.call(self)
+        else
+          value
+        end
+      end # lookup_and_evaluate
+
       def squash_instance_assigns_with_environments
         @scopes.last.each_key do |k|
           @environments.each do |env|
@@ -200,4 +281,5 @@ module Liquid
         end
       end # squash_instance_assigns_with_environments
   end # Context
+
 end # Liquid

lib/liquid/document.rb

@@ -1,24 +1,18 @@
 module Liquid
-  class Document < BlockBody
-    def self.parse(tokens, options)
-      doc = new
-      doc.parse(tokens, options)
-      doc
+  class Document < Block
+    # we don't need markup to open this block
+    def initialize(tokens, options = {})
+      @options = options
+      parse_body(tokens)
     end
 
-    def parse(tokens, options)
-      super do |end_tag_name, end_tag_params|
-        unknown_tag(end_tag_name, options) if end_tag_name
-      end
+    # There isn't a real delimiter
+    def block_delimiter
+      nil
     end
 
-    def unknown_tag(tag, options)
-      case tag
-      when 'else'.freeze, 'end'.freeze
-        raise SyntaxError.new(options[:locale].t("errors.syntax.unexpected_outer_tag".freeze, :tag => tag))
-      else
-        raise SyntaxError.new(options[:locale].t("errors.syntax.unknown_tag".freeze, :tag => tag))
-      end
+    # Document blocks don't need to be terminated since they are not actually opened
+    def assert_missing_delimitation!
     end
   end
 end

lib/liquid/drop.rb

@@ -62,10 +62,6 @@ module Liquid
 
     # Check for method existence without invoking respond_to?, which creates symbols
     def self.invokable?(method_name)
-      self.invokable_methods.include?(method_name.to_s)
-    end
-
-    def self.invokable_methods
       unless @invokable_methods
         blacklist = Liquid::Drop.public_instance_methods + [:each]
         if include?(Enumerable)
@@ -75,7 +71,7 @@ module Liquid
         whitelist = [:to_liquid] + (public_instance_methods - blacklist)
         @invokable_methods = Set.new(whitelist.map(&:to_s))
       end
-      @invokable_methods
+      @invokable_methods.include?(method_name.to_s)
     end
   end
 end

lib/liquid/errors.rb

@@ -1,60 +1,12 @@
 module Liquid
-  class Error < ::StandardError
-    attr_accessor :line_number
-    attr_accessor :markup_context
-
-    def to_s(with_prefix=true)
-      str = ""
-      str << message_prefix if with_prefix
-      str << super()
-
-      if markup_context
-        str << " "
-        str << markup_context
-      end
-
-      str
-    end
-
-    def set_line_number_from_token(token)
-      return unless token.respond_to?(:line_number)
-      return if self.line_number
-      self.line_number = token.line_number
-    end
-
-    def self.render(e)
-      if e.is_a?(Liquid::Error)
-        e.to_s
-      else
-        "Liquid error: #{e.to_s}"
-      end
-    end
-
-    private
-
-    def message_prefix
-      str = ""
-      if is_a?(SyntaxError)
-        str << "Liquid syntax error"
-      else
-        str << "Liquid error"
-      end
-
-      if line_number
-        str << " (line #{line_number})"
-      end
-
-      str << ": "
-      str
-    end
-  end
+  class Error < ::StandardError; end
 
   class ArgumentError < Error; end
   class ContextError < Error; end
+  class FilterNotFound < Error; end
   class FileSystemError < Error; end
   class StandardError < Error; end
   class SyntaxError < Error; end
   class StackLevelError < Error; end
-  class TaintedError < Error; end
   class MemoryError < Error; end
 end

lib/liquid/expression.rb

@@ -1,48 +0,0 @@
-module Liquid
-  class Expression
-    LITERALS = {
-      nil => nil, 'nil'.freeze => nil, 'null'.freeze => nil, ''.freeze => nil,
-      'true'.freeze  => true,
-      'false'.freeze => false,
-      'blank'.freeze => :blank?,
-      'empty'.freeze => :empty?
-    }
-
-    INVERTED_LITERALS = LITERALS.invert
-
-    def self.parse(markup)
-      if LITERALS.key?(markup)
-        LITERALS[markup]
-      else
-        case markup
-        when /\A'(.*)'\z/m # Single quoted strings
-          $1
-        when /\A"(.*)"\z/m # Double quoted strings
-          $1
-        when /\A(-?\d+)\z/ # Integer and floats
-          $1.to_i
-        when /\A\((\S+)\.\.(\S+)\)\z/ # Ranges
-          RangeLookup.parse($1, $2)
-        when /\A(-?\d[\d\.]+)\z/ # Floats
-          $1.to_f
-        else
-          VariableLookup.parse(markup)
-        end
-      end
-    end
-
-    def self.format(value)
-      if INVERTED_LITERALS.key?(value)
-        INVERTED_LITERALS[value].dup
-      elsif value.is_a?(VariableLookup) || value.is_a?(RangeLookup)
-        value.format
-      elsif value.is_a?(String)
-        "\"#{value}\""
-      elsif value.is_a?(Range)
-        "(#{value.to_s})"
-      else
-        value.to_s
-      end
-    end
-  end
-end

lib/liquid/file_system.rb

@@ -14,7 +14,7 @@ module Liquid
   # This will parse the template with a LocalFileSystem implementation rooted at 'template_path'.
   class BlankFileSystem
     # Called by Liquid to retrieve a template file
-    def read_template_file(template_path)
+    def read_template_file(template_path, context)
       raise FileSystemError, "This liquid context does not allow includes."
     end
   end
@@ -44,12 +44,12 @@ module Liquid
   class LocalFileSystem
     attr_accessor :root
 
-    def initialize(root, pattern = "_%s.liquid".freeze)
+    def initialize(root, pattern = "_%s.liquid")
       @root = root
       @pattern = pattern
     end
 
-    def read_template_file(template_path)
+    def read_template_file(template_path, context)
       full_path = full_path(template_path)
       raise FileSystemError, "No such template '#{template_path}'" unless File.exists?(full_path)
 
@@ -59,7 +59,7 @@ module Liquid
     def full_path(template_path)
       raise FileSystemError, "Illegal template name '#{template_path}'" unless template_path =~ /\A[^.\/][a-zA-Z0-9_\/]+\z/
 
-      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))
       else
         File.join(root, @pattern % template_path)

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(options[:locale].t("errors.syntax.table_row"))
+      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(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}\">" << super << '</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

@@ -6,7 +6,7 @@ module Liquid
 
     class TranslationError < StandardError
     end
-
+    
     attr_reader :path
 
     def initialize(path = DEFAULT_LOCALE)
@@ -31,7 +31,7 @@ module Liquid
     end
 
     def deep_fetch_translation(name)
-      name.split('.'.freeze).reduce(locale) do |level, cur|
+      name.split('.').reduce(locale) do |level, cur|
         level[cur] or raise TranslationError, "Translation for #{name} does not exist in locale #{path}"
       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

@@ -2,18 +2,16 @@ 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,
-      '?'.freeze => :question,
-      '-'.freeze => :dash
+      '|' => :pipe,
+      '.' => :dot,
+      ':' => :colon,
+      ',' => :comma,
+      '[' => :open_square,
+      ']' => :close_square,
+      '(' => :open_round,
+      ')' => :close_round
     }
-    IDENTIFIER = /[a-zA-Z_][\w-]*\??/
+    IDENTIFIER = /[\w\-?!]+/
     SINGLE_STRING_LITERAL = /'[^\']*'/
     DOUBLE_STRING_LITERAL = /"[^\"]*"/
     NUMBER_LITERAL = /-?\d+(\.\d+)?/

lib/liquid/locales/en.yml

@@ -14,8 +14,7 @@
       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"
-      unexpected_outer_tag: "Unexpected outer '%{tag}' tag"
+      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"

lib/liquid/module_ex.rb

@@ -7,17 +7,16 @@
 # to the allowed method passed with the liquid_methods call
 # Example:
 #
-#   class SomeClass
-#     liquid_methods :an_allowed_method
+# class SomeClass
+#   liquid_methods :an_allowed_method
 #
-#     def an_allowed_method
-#       'this comes from an allowed method'
-#     end
-#
-#     def unallowed_method
-#       'this will never be an output'
-#     end
+#   def an_allowed_method
+#     'this comes from an allowed method'
 #   end
+#   def unallowed_method
+#     'this will never be an output'
+#   end
+# end
 #
 # if you want to extend the drop to other methods you can defines more methods
 # in the class <YourClass>::LiquidDropClass
@@ -27,33 +26,31 @@
 #       'and this from another allowed method'
 #     end
 #   end
-#
+# end
 #
 # usage:
-#   @something = SomeClass.new
+# @something = SomeClass.new
 #
 # template:
-#   {{something.an_allowed_method}}{{something.unallowed_method}} {{something.another_allowed_method}}
+# {{something.an_allowed_method}}{{something.unallowed_method}} {{something.another_allowed_method}}
 #
 # output:
-#   'this comes from an allowed method and this from another allowed method'
+# 'this comes from an allowed method and this from another allowed method'
 #
 # You can also chain associations, by adding the liquid_method call in the
 # association models.
 #
 class Module
+
   def liquid_methods(*allowed_methods)
     drop_class = eval "class #{self.to_s}::LiquidDropClass < Liquid::Drop; self; end"
-    
     define_method :to_liquid do
       drop_class.new(self)
     end
-    
     drop_class.class_eval do
       def initialize(object)
         @object = object
       end
-      
       allowed_methods.each do |sym|
         define_method sym do
           @object.send sym
@@ -61,4 +58,5 @@ class Module
       end
     end
   end
+
 end

lib/liquid/parser.rb

@@ -66,11 +66,10 @@ module Liquid
       str = ""
       # might be a keyword argument (identifier: expression)
       if look(:id) && look(:colon, 1)
-        str << consume << consume << ' '.freeze
+        str << consume << consume << ' '
       end
 
       str << expression
-      str
     end
 
     def variable_signature

lib/liquid/parser_switching.rb

@@ -1,31 +0,0 @@
-module Liquid
-  module ParserSwitching
-    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
-          e.set_line_number_from_token(markup)
-          @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.markup_context = markup_context(markup)
-      raise e
-    end
-
-    def markup_context(markup)
-      "in \"#{markup.strip}\""
-    end
-  end
-end

lib/liquid/profiler.rb

@@ -1,162 +0,0 @@
-require 'liquid/profiler/hooks'
-
-module Liquid
-
-  # Profiler enables support for profiling template rendering to help track down performance issues.
-  #
-  # To enable profiling, first require 'liquid/profiler'.
-  # Then, to profile a parse/render cycle, pass the <tt>profile: true</tt> option to <tt>Liquid::Template.parse</tt>.
-  # After <tt>Liquid::Template#render</tt> is called, the template object makes available an instance of this
-  # class via the <tt>Liquid::Template#profiler</tt> method.
-  #
-  #   template = Liquid::Template.parse(template_content, profile: true)
-  #   output  = template.render
-  #   profile = template.profiler
-  #
-  # This object contains all profiling information, containing information on what tags were rendered,
-  # where in the templates these tags live, and how long each tag took to render.
-  #
-  # This is a tree structure that is Enumerable all the way down, and keeps track of tags and rendering times
-  # inside of <tt>{% include %}</tt> tags.
-  #
-  #   profile.each do |node|
-  #     # Access to the token itself
-  #     node.code
-  #
-  #     # Which template and line number of this node.
-  #     # If top level, this will be "<root>".
-  #     node.partial
-  #     node.line_number
-  #
-  #     # Render time in seconds of this node
-  #     node.render_time
-  #
-  #     # If the template used {% include %}, this node will also have children.
-  #     node.children.each do |child2|
-  #       # ...
-  #     end
-  #   end
-  #
-  # Profiler also exposes the total time of the template's render in <tt>Liquid::Profiler#total_render_time</tt>.
-  #
-  # All render times are in seconds. There is a small performance hit when profiling is enabled.
-  #
-  class Profiler
-    include Enumerable
-
-    class Timing
-      attr_reader :code, :partial, :line_number, :children
-
-      def initialize(token, partial)
-        @code        = token.respond_to?(:raw) ? token.raw : token
-        @partial     = partial
-        @line_number = token.respond_to?(:line_number) ? token.line_number : nil
-        @children    = []
-      end
-
-      def self.start(token, partial)
-        new(token, partial).tap do |t|
-          t.start
-        end
-      end
-
-      def start
-        @start_time = Time.now
-      end
-
-      def finish
-        @end_time = Time.now
-      end
-
-      def render_time
-        @end_time - @start_time
-      end
-    end
-
-    def self.profile_token_render(token)
-      if Profiler.current_profile && token.respond_to?(:render)
-        Profiler.current_profile.start_token(token)
-        output = yield
-        Profiler.current_profile.end_token(token)
-        output
-      else
-        yield
-      end
-    end
-
-    def self.profile_children(template_name)
-      if Profiler.current_profile
-        Profiler.current_profile.push_partial(template_name)
-        output = yield
-        Profiler.current_profile.pop_partial
-        output
-      else
-        yield
-      end
-    end
-
-    def self.current_profile
-      Thread.current[:liquid_profiler]
-    end
-
-    def initialize
-      @partial_stack = ["<root>"]
-
-      @root_timing = Timing.new("", current_partial)
-      @timing_stack = [@root_timing]
-
-      @render_start_at = Time.now
-      @render_end_at = @render_start_at
-    end
-
-    def start
-      Thread.current[:liquid_profiler] = self
-      @render_start_at = Time.now
-    end
-
-    def stop
-      Thread.current[:liquid_profiler] = nil
-      @render_end_at = Time.now
-    end
-
-    def total_render_time
-      @render_end_at - @render_start_at
-    end
-
-    def each(&block)
-      @root_timing.children.each(&block)
-    end
-
-    def [](idx)
-      @root_timing.children[idx]
-    end
-
-    def length
-      @root_timing.children.length
-    end
-
-    def start_token(token)
-      @timing_stack.push(Timing.start(token, current_partial))
-    end
-
-    def end_token(token)
-      timing = @timing_stack.pop
-      timing.finish
-
-      @timing_stack.last.children << timing
-    end
-
-    def current_partial
-      @partial_stack.last
-    end
-
-    def push_partial(partial_name)
-      @partial_stack.push(partial_name)
-    end
-
-    def pop_partial
-      @partial_stack.pop
-    end
-
-  end
-end

lib/liquid/profiler/hooks.rb

@@ -1,23 +0,0 @@
-module Liquid
-  class BlockBody
-    def render_token_with_profiling(token, context)
-      Profiler.profile_token_render(token) do
-        render_token_without_profiling(token, context)
-      end
-    end
-
-    alias_method :render_token_without_profiling, :render_token
-    alias_method :render_token, :render_token_with_profiling
-  end
-
-  class Include < Tag
-    def render_with_profiling(context)
-      Profiler.profile_children(context.evaluate(@template_name_expr).to_s) do
-        render_without_profiling(context)
-      end
-    end
-
-    alias_method :render_without_profiling, :render
-    alias_method :render, :render_with_profiling
-  end
-end

lib/liquid/range_lookup.rb

@@ -1,26 +0,0 @@
-module Liquid
-  class RangeLookup
-    def self.parse(start_markup, end_markup)
-      start_obj = Expression.parse(start_markup)
-      end_obj = Expression.parse(end_markup)
-      if start_obj.respond_to?(:evaluate) || end_obj.respond_to?(:evaluate)
-        new(start_obj, end_obj)
-      else
-        start_obj.to_i..end_obj.to_i
-      end
-    end
-
-    def initialize(start_obj, end_obj)
-      @start_obj = start_obj
-      @end_obj = end_obj
-    end
-
-    def evaluate(context)
-      context.evaluate(@start_obj).to_i..context.evaluate(@end_obj).to_i
-    end
-
-    def format
-      "(#{Expression.format(@start_obj)}..#{Expression.format(@end_obj)})"
-    end
-  end
-end

lib/liquid/resource_limits.rb

@@ -1,23 +0,0 @@
-module Liquid
-  class ResourceLimits
-    attr_accessor :render_length, :render_score, :assign_score,
-                  :render_length_limit, :render_score_limit, :assign_score_limit
-
-    def initialize(limits)
-      @render_length_limit = limits[:render_length_limit]
-      @render_score_limit = limits[:render_score_limit]
-      @assign_score_limit = limits[:assign_score_limit]
-      reset
-    end
-
-    def reached?
-      (@render_length_limit && @render_length > @render_length_limit) ||
-      (@render_score_limit  && @render_score  > @render_score_limit ) ||
-      (@assign_score_limit  && @assign_score  > @assign_score_limit )
-    end
-
-    def reset
-      @render_length = @render_score = @assign_score = 0
-    end
-  end
-end

lib/liquid/standardfilters.rb

@@ -4,17 +4,12 @@ require 'bigdecimal'
 module Liquid
 
   module StandardFilters
-    HTML_ESCAPE = {
-      '&'.freeze => '&'.freeze,
-      '>'.freeze => '>'.freeze,
-      '<'.freeze => '&lt;'.freeze,
-      '"'.freeze => '&quot;'.freeze,
-      "'".freeze => '&#39;'.freeze
-    }
+    HTML_ESCAPE = { '&' => '&amp;',  '>' => '&gt;',   '<' => '&lt;', '"' => '&quot;', "'" => '&#39;' }
     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
 
@@ -34,43 +29,29 @@ module Liquid
     end
 
     def escape(input)
-      CGI.escapeHTML(input).untaint rescue input
+      CGI.escapeHTML(input) rescue input
     end
-    alias_method :h, :escape
 
     def escape_once(input)
       input.to_s.gsub(HTML_ESCAPE_ONCE_REGEXP, HTML_ESCAPE)
     end
 
-    def url_encode(input)
-      CGI.escape(input) rescue input
-    end
-
-    def slice(input, offset, length=nil)
-      offset = Integer(offset)
-      length = length ? Integer(length) : 1
-
-      if input.is_a?(Array)
-        input.slice(offset, length) || []
-      else
-        input.to_s.slice(offset, length) || ''
-      end
-    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
     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.
@@ -79,7 +60,7 @@ module Liquid
     #   <div class="summary">{{ post | split '//' | first }}</div>
     #
     def split(input, pattern)
-      input.to_s.split(pattern)
+      input.split(pattern)
     end
 
     def strip(input)
@@ -95,70 +76,44 @@ module Liquid
     end
 
     def strip_html(input)
-      empty = ''.freeze
-      input.to_s.gsub(/<script.*?<\/script>/m, empty).gsub(/<!--.*?-->/m, empty).gsub(/<style.*?<\/style>/m, empty).gsub(/<.*?>/m, empty)
+      input.to_s.gsub(/<script.*?<\/script>/m, '').gsub(/<!--.*?-->/m, '').gsub(/<style.*?<\/style>/m, '').gsub(/<.*?>/m, '')
     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)
-      InputIterator.new(input).join(glue)
+    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 = InputIterator.new(input)
+      ary = flatten_if_necessary(input)
       if property.nil?
         ary.sort
-      elsif ary.first.respond_to?(:[]) && !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) }
       end
     end
 
-    # Sort elements of an array ignoring case if strings
-    # provide optional property with which to sort an array of hashes or drops
-    def sort_natural(input, property = nil)
-      ary = InputIterator.new(input)
-
-      if property.nil?
-        ary.sort {|a,b| a.casecmp(b) }
-      elsif ary.first.respond_to?(:[]) && !ary.first[property].nil?
-        ary.sort {|a,b| a[property].casecmp(b[property]) }
-      elsif ary.first.respond_to?(property)
-        ary.sort {|a,b| a.send(property).casecmp(b.send(property)) }
-      end
-    end
-
-    # Remove duplicate elements from an array
-    # provide optional property with which to determine uniqueness
-    def uniq(input, property = nil)
-      ary = InputIterator.new(input)
-      if property.nil?
-        input.uniq
-      elsif input.first.respond_to?(:[])
-        input.uniq{ |a| a[property] }
-      end
-    end
-
     # Reverse the elements of an array
     def reverse(input)
-      ary = InputIterator.new(input)
+      ary = [input].flatten
       ary.reverse
     end
 
     # map/collect on a given property
     def map(input, property)
-      InputIterator.new(input).map do |e|
+      flatten_if_necessary(input).map do |e|
         e = e.call if e.is_a?(Proc)
 
-        if property == "to_liquid".freeze
+        if property == "to_liquid"
           e
         elsif e.respond_to?(:[])
           e[property]
@@ -167,23 +122,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
@@ -191,10 +146,6 @@ module Liquid
       input.to_s + string.to_s
     end
 
-    def concat(input, array)
-      InputIterator.new(input).concat(array)
-    end
-
     # prepend a string to another
     def prepend(input, string)
       string.to_s + input.to_s
@@ -202,10 +153,10 @@ 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 using Ruby's core Time#strftime( string ) -> string
+    # Reformat a date
     #
     #   %a - The abbreviated weekday name (``Sun'')
     #   %A - The  full  weekday  name (``Sunday'')
@@ -219,7 +170,6 @@ module Liquid
     #   %m - Month of the year (01..12)
     #   %M - Minute of the hour (00..59)
     #   %p - Meridian indicator (``AM''  or  ``PM'')
-    #   %s - Number of seconds since 1970-01-01 00:00:00 UTC.
     #   %S - Second of the minute (00..60)
     #   %U - Week  number  of the current year,
     #           starting with the first Sunday as the first
@@ -234,14 +184,34 @@ module Liquid
     #   %Y - Year with century
     #   %Z - Time zone name
     #   %% - Literal ``%'' character
-    #
-    #   See also: http://www.ruby-doc.org/core/Time.html#method-i-strftime
     def date(input, format)
-      return input if format.to_s.empty?
 
-      return input unless date = to_date(input)
+      if format.to_s.empty?
+        return input.to_s
+      end
 
-      date.strftime(format.to_s)
+      if ((input.is_a?(String) && !/\A\d+\z/.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', 'today'
+          Time.now
+        else
+          Time.parse(input)
+        end
+      else
+        input
+      end
+
+      if date.respond_to?(:strftime)
+        date.strftime(format.to_s)
+      else
+        input
+      end
+    rescue
+      input
     end
 
     # Get the first element of the passed in array
@@ -286,28 +256,24 @@ module Liquid
       apply_operation(input, operand, :%)
     end
 
-    def round(input, n = 0)
-      result = to_number(input).round(to_number(n))
-      result = result.to_f if result.is_a?(BigDecimal)
-      result = result.to_i if n == 0
-      result
-    end
-
-    def ceil(input)
-      to_number(input).ceil.to_i
-    end
-
-    def floor(input)
-      to_number(input).floor.to_i
-    end
-
-    def default(input, default_value = "".freeze)
+    def default(input, default_value = "")
       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
@@ -321,66 +287,10 @@ module Liquid
       end
     end
 
-    def to_date(obj)
-      return obj if obj.respond_to?(:strftime)
-
-      if obj.is_a?(String)
-        return nil if obj.empty?
-        obj = obj.downcase
-      end
-
-      case obj
-      when 'now'.freeze, 'today'.freeze
-        Time.now
-      when /\A\d+\z/, Integer
-        Time.at(obj.to_i)
-      when String
-        Time.parse(obj)
-      else
-        nil
-      end
-    rescue ArgumentError
-      nil
-    end
-
     def apply_operation(input, operand, operation)
       result = to_number(input).send(operation, to_number(operand))
       result.is_a?(BigDecimal) ? result.to_f : result
     end
-
-    class InputIterator
-      include Enumerable
-
-      def initialize(input)
-        @input = if input.is_a?(Array)
-          input.flatten
-        elsif input.is_a?(Hash)
-          [input]
-        elsif input.is_a?(Enumerable)
-          input
-        else
-          Array(input)
-        end
-      end
-
-      def join(glue)
-        to_a.join(glue)
-      end
-
-      def concat(args)
-        to_a.concat args
-      end
-
-      def reverse
-        reverse_each.to_a
-      end
-
-      def each
-        @input.each do |e|
-          yield(e.respond_to?(:to_liquid) ? e.to_liquid : e)
-        end
-      end
-    end
   end
 
   Template.register_filter(StandardFilters)

lib/liquid/strainer.rb

@@ -8,13 +8,12 @@ module Liquid
   # The Strainer only allows method calls defined in filters given to it via Strainer.global_filter,
   # Context#add_filters or Template.register_filter
   class Strainer #:nodoc:
-    @@global_strainer = Class.new(Strainer) do
-      @filter_methods = Set.new
-    end
+    @@filters = []
+    @@known_filters = Set.new
+    @@known_methods = Set.new
     @@strainer_class_cache = Hash.new do |hash, filters|
-      hash[filters] = Class.new(@@global_strainer) do
-        @filter_methods = @@global_strainer.filter_methods.dup
-        filters.each { |f| add_filter(f) }
+      hash[filters] = Class.new(Strainer) do
+        filters.each { |f| include f }
       end
     end
 
@@ -22,32 +21,33 @@ module Liquid
       @context = context
     end
 
-    def self.filter_methods
-      @filter_methods
+    def self.global_filter(filter)
+      raise ArgumentError, "Passed filter is not a module" unless filter.is_a?(Module)
+      add_known_filter(filter)
+      @@filters << filter unless @@filters.include?(filter)
     end
 
-    def self.add_filter(filter)
-      raise ArgumentError, "Expected module but got: #{f.class}" unless filter.is_a?(Module)
-      unless self.class.include?(filter)
-        self.send(:include, filter)
-        @filter_methods.merge(filter.public_instance_methods.map(&:to_s))
+    def self.add_known_filter(filter)
+      unless @@known_filters.include?(filter)
+        @@method_blacklist ||= Set.new(Strainer.instance_methods.map(&:to_s))
+        new_methods = filter.instance_methods.map(&:to_s)
+        new_methods.reject!{ |m| @@method_blacklist.include?(m) }
+        @@known_methods.merge(new_methods)
+        @@known_filters.add(filter)
       end
     end
 
-    def self.global_filter(filter)
-      @@global_strainer.add_filter(filter)
-    end
-
-    def self.invokable?(method)
-      @filter_methods.include?(method.to_s)
+    def self.strainer_class_cache
+      @@strainer_class_cache
     end
 
     def self.create(context, filters = [])
-      @@strainer_class_cache[filters].new(context)
+      filters = @@filters + filters
+      strainer_class_cache[filters].new(context)
     end
 
     def invoke(method, *args)
-      if self.class.invokable?(method)
+      if invokable?(method)
         send(method, *args)
       else
         args.first
@@ -55,5 +55,9 @@ module Liquid
     rescue ::ArgumentError => e
       raise Liquid::ArgumentError.new(e.message)
     end
+
+    def invokable?(method)
+      @@known_methods.include?(method.to_s) && respond_to?(method)
+    end
   end
 end

lib/liquid/tag.rb

@@ -1,33 +1,21 @@
 module Liquid
   class Tag
-    attr_accessor :options, :line_number
+    attr_accessor :options
     attr_reader :nodelist, :warnings
-    include ParserSwitching
 
-    class << self
-      def parse(tag_name, markup, tokens, options)
-        tag = new(tag_name, markup, options)
-        tag.parse(tokens)
-        tag
-      end
-
-      private :new
+    def self.new_with_options(tag_name, markup, tokens, options)
+      # Forgive me Matz for I have sinned. I know this code is weird
+      # but it was necessary to maintain API compatibility.
+      new_tag = self.allocate
+      new_tag.options = options
+      new_tag.send(:initialize, tag_name, markup, tokens)
+      new_tag
     end
 
-    def initialize(tag_name, markup, options)
+    def initialize(tag_name, markup, tokens)
       @tag_name   = tag_name
       @markup     = markup
-      @options    = options
-    end
-
-    def parse(tokens)
-    end
-
-    def raw
-      tag = @tag_name.strip
-      markup = @markup.strip
-      tag << " #{markup}" unless markup.empty?
-      tag
+      @options    ||= {} # needs || because might be set before initialize
     end
 
     def name
@@ -35,15 +23,34 @@ module Liquid
     end
 
     def render(context)
-      ''.freeze
+      ''
     end
 
     def blank?
-      false
+      @blank || false
     end
 
-    def format
-      "{% #{raw} %}"
+    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
-  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,37 +9,30 @@ module Liquid
   #  {{ foo }}
   #
   class Assign < Tag
-    Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/om
+    Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/o
 
-    def initialize(tag_name, markup, options)
-      super
+    def initialize(tag_name, markup, tokens)
       if markup =~ Syntax
         @to = $1
-        @from = Variable.new($2,options)
-        @from.line_number = line_number
+        @from = Variable.new($2)
       else
-        raise SyntaxError.new options[:locale].t("errors.syntax.assign".freeze)
+        raise SyntaxError.new options[:locale].t("errors.syntax.assign")
       end
+
+      super
     end
 
     def render(context)
       val = @from.render(context)
       context.scopes.last[@to] = val
-
-      inc = val.instance_of?(String) || val.instance_of?(Array) || val.instance_of?(Hash) ? val.length : 1
-      context.resource_limits.assign_score += inc
-
-      ''.freeze
+      context.increment_used_resources(:assign_score_current, val)
+      ''
     end
 
     def blank?
       true
     end
-
-    def format
-      "{% assign #{@to} = #{@from.format} %}"
-    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

@@ -1,4 +1,5 @@
 module Liquid
+
   # Capture stores the result of a block into a variable without rendering it inplace.
   #
   #   {% capture heading %}
@@ -11,32 +12,29 @@ module Liquid
   # in a sidebar or footer.
   #
   class Capture < Block
-    Syntax = /(#{VariableSignature}+)/o
+    Syntax = /(\w+)/
 
-    def initialize(tag_name, markup, options)
-      super
+    def initialize(tag_name, markup, tokens)
       if markup =~ Syntax
         @to = $1
       else
         raise SyntaxError.new(options[:locale].t("errors.syntax.capture"))
       end
+
+      super
     end
 
     def render(context)
       output = super
       context.scopes.last[@to] = output
-      context.resource_limits.assign_score += output.length
-      ''.freeze
+      context.increment_used_resources(:assign_score_current, output)
+      ''
     end
 
     def blank?
       true
     end
-
-    def format
-      "{% #{block_name} #{@to} %}#{@body.format}{% #{block_delimiter} %}"
-    end
   end
 
-  Template.register_tag('capture'.freeze, Capture)
+  Template.register_tag('capture', Capture)
 end

lib/liquid/tags/case.rb

@@ -1,35 +1,30 @@
 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)
-      super
+    def initialize(tag_name, markup, tokens)
       @blocks = []
 
       if markup =~ Syntax
-        @left = Expression.parse($1)
+        @left = $1
       else
-        raise SyntaxError.new(options[:locale].t("errors.syntax.case".freeze))
+        raise SyntaxError.new(options[:locale].t("errors.syntax.case"))
       end
-    end
 
-    def parse(tokens)
-      @initial_body = body = BlockBody.new
-      while more = parse_body(body, tokens)
-        body = @blocks.last.attachment
-      end
+      super
     end
 
     def nodelist
-      @blocks.map(&:attachment)
+      @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
@@ -43,59 +38,43 @@ module Liquid
         output = ''
         @blocks.each do |block|
           if block.else?
-            return block.attachment.render(context) if execute_else_block
+            return render_all(block.attachment, context) if execute_else_block
           elsif block.evaluate(context)
             execute_else_block = false
-            output << block.attachment.render(context)
+            output << render_all(block.attachment, context)
           end
         end
         output
       end
     end
 
-    def format
-      out = "{% case #{Expression.format(@left)} %}#{@initial_body.format}"
-
-      @blocks.each do |block|
-        if block.else?
-          out << "{% else %}"
-        else
-          out << "{% when #{Expression.format(block.right)} %}"
-        end
-        out << block.attachment.format
-      end
-
-      out + "{% endcase %}"
-    end
-
     private
 
     def record_when_condition(markup)
-      body = BlockBody.new
-
       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(options[:locale].t("errors.syntax.case_invalid_when"))
         end
 
         markup = $2
 
-        block = Condition.new(@left, '=='.freeze, Expression.parse($1))
-        block.attach(body)
-        @blocks << block
+        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(options[:locale].t("errors.syntax.case_invalid_else"))
       end
 
       block = ElseCondition.new
-      block.attach(BlockBody.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,7 +1,7 @@
 module Liquid
   class Comment < Block
     def render(context)
-      ''.freeze
+      ''
     end
 
     def unknown_tag(tag, markup, tokens)
@@ -12,5 +12,5 @@ module Liquid
     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

@@ -13,30 +13,29 @@ module Liquid
   #
   class Cycle < Tag
     SimpleSyntax = /\A#{QuotedFragment}+/o
-    NamedSyntax  = /\A(#{QuotedFragment})\s*\:\s*(.*)/om
+    NamedSyntax  = /\A(#{QuotedFragment})\s*\:\s*(.*)/o
 
-    def initialize(tag_name, markup, options)
-      super
+    def initialize(tag_name, markup, tokens)
       case markup
       when NamedSyntax
         @variables = variables_from_string($2)
-        @name = Expression.parse($1)
-        @named = true
+        @name = $1
       when SimpleSyntax
         @variables = variables_from_string(markup)
-        @name = @variables.to_s
+        @name = "'#{@variables.to_s}'"
       else
-        raise SyntaxError.new(options[:locale].t("errors.syntax.cycle".freeze))
+        raise SyntaxError.new(options[:locale].t("errors.syntax.cycle"))
       end
+      super
     end
 
     def render(context)
       context.registers[:cycle] ||= Hash.new(0)
 
       context.stack do
-        key = context.evaluate(@name)
+        key = context[@name]
         iteration = context.registers[:cycle][key]
-        result = context.evaluate(@variables[iteration])
+        result = context[@variables[iteration]]
         iteration += 1
         iteration  = 0  if iteration >= @variables.size
         context.registers[:cycle][key] = iteration
@@ -44,21 +43,15 @@ module Liquid
       end
     end
 
-    def format
-      formatted_vars = @variables.map { |v| Expression.format(v) }.join(', ')
-      if @named
-        "{% cycle #{Expression.format(@name)}: #{formatted_vars} %}"
-      else
-        "{% cycle #{formatted_vars} %}"
-      end
+    def blank?
+      false
     end
 
     private
-
     def variables_from_string(markup)
       markup.split(',').collect do |var|
         var =~ /\s*(#{QuotedFragment})\s*/o
-        $1 ? Expression.parse($1) : nil
+        $1 ? $1 : nil
       end.compact
     end
   end

lib/liquid/tags/decrement.rb

@@ -19,9 +19,10 @@ module Liquid
   #    Hello: -3
   #
   class Decrement < Tag
-    def initialize(tag_name, markup, options)
-      super
+    def initialize(tag_name, markup, tokens)
       @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

@@ -42,48 +42,45 @@ module Liquid
   #                   where 0 is the last item.
   # forloop.first:: Returns true if the item is the first item.
   # forloop.last:: Returns true if the item is the last item.
-  # forloop.parentloop:: Provides access to the parent loop, if present.
   #
   class For < Block
     Syntax = /\A(#{VariableSegment}+)\s+in\s+(#{QuotedFragment}+)\s*(reversed)?/o
 
-    def initialize(tag_name, markup, options)
-      super
+    def initialize(tag_name, markup, tokens)
       parse_with_selected_parser(markup)
-      @for_block = BlockBody.new
-    end
-
-    def parse(tokens)
-      if more = parse_body(@for_block, tokens)
-        parse_body(@else_block, tokens)
-      end
+      @nodelist = @for_block = []
+      super
     end
 
     def nodelist
-      @else_block ? [@for_block, @else_block] : [@for_block]
+      if @else_block
+        @for_block + @else_block
+      else
+        @for_block
+      end
     end
 
     def unknown_tag(tag, markup, tokens)
-      return super unless tag == 'else'.freeze
-      @else_block = BlockBody.new
+      return super unless tag == 'else'
+      @nodelist = @else_block = []
     end
 
     def render(context)
       context.registers[:for] ||= Hash.new(0)
 
-      collection = context.evaluate(@collection_name)
+      collection = context[@collection_name]
       collection = collection.to_a if collection.is_a?(Range)
 
       # Maintains Ruby 1.8.7 String#each behaviour on 1.9
       return render_else(context) unless iterable?(collection)
 
-      from = if @from == :continue
+      from = if @attributes['offset'] == 'continue'
         context.registers[:for][@name].to_i
       else
-        context.evaluate(@from).to_i
+        context[@attributes['offset']].to_i
       end
 
-      limit = context.evaluate(@limit)
+      limit = context[@attributes['limit']]
       to    = limit ? limit.to_i + from : nil
 
       segment = Utils.slice_collection(collection, from, to)
@@ -99,24 +96,20 @@ module Liquid
       # Store our progress through the collection for the continue flag
       context.registers[:for][@name] = from + segment.length
 
-      parent_loop = context['forloop'.freeze]
-
       context.stack do
         segment.each_with_index do |item, index|
           context[@variable_name] = item
-          context['forloop'.freeze] = {
-            'name'.freeze       => @name,
-            'length'.freeze     => length,
-            'index'.freeze      => index + 1,
-            'index0'.freeze     => index,
-            'rindex'.freeze     => length - index,
-            'rindex0'.freeze    => length - index - 1,
-            'first'.freeze      => (index == 0),
-            'last'.freeze       => (index == length - 1),
-            'parentloop'.freeze => parent_loop
-          }
+          context['forloop'] = {
+            'name'    => @name,
+            'length'  => length,
+            'index'   => index + 1,
+            'index0'  => index,
+            'rindex'  => length - index,
+            'rindex0' => length - index - 1,
+            'first'   => (index == 0),
+          'last'    => (index == length - 1) }
 
-          result << @for_block.render(context)
+          result << render_all(@for_block, context)
 
           # Handle any interrupts if they exist.
           if context.has_interrupt?
@@ -129,80 +122,53 @@ module Liquid
       result
     end
 
-    def format
-      args = [Expression.format(@collection_name)]
-      args << "reversed" if @reversed
-      args << "limit: #{Expression.format(@limit)}" if @limit
-      args << "offset: " << (@from == :continue ? 'continue' : Expression.format(@from)) if @from
-
-      out = "{% for #{@variable_name} in #{args.join(' ')} %}"
-      out << @for_block.format
-      if @else_block
-        out << "{% else %}"
-        out << @else_block.format
-      end
-      out + "{% endfor %}"
-    end
-
     protected
 
     def lax_parse(markup)
       if markup =~ Syntax
         @variable_name = $1
-        collection_name = $2
+        @collection_name = $2
+        @name = "#{$1}-#{$2}"
         @reversed = $3
-        @name = "#{@variable_name}-#{collection_name}"
-        @collection_name = Expression.parse(collection_name)
+        @attributes = {}
         markup.scan(TagAttributes) do |key, value|
-          set_attribute(key, value)
+          @attributes[key] = value
         end
       else
-        raise SyntaxError.new(options[:locale].t("errors.syntax.for".freeze))
+        raise SyntaxError.new(options[:locale].t("errors.syntax.for"))
       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}"
-      @collection_name = Expression.parse(collection_name)
-      @reversed = p.id?('reversed'.freeze)
+      raise SyntaxError.new(options[:locale].t("errors.syntax.for_invalid_in"))  unless p.id?('in')
+      @collection_name = p.expression
+      @name = "#{@variable_name}-#{@collection_name}"
+      @reversed = p.id?('reversed')
 
+      @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))
+        unless attribute = p.id?('limit') || p.id?('offset')
+          raise SyntaxError.new(options[:locale].t("errors.syntax.for_invalid_attribute"))
         end
         p.consume
-        set_attribute(attribute, p.expression)
+        val = p.expression
+        @attributes[attribute] = val
       end
       p.consume(:end_of_string)
     end
 
     private
 
-    def set_attribute(key, expr)
-      case key
-      when 'offset'.freeze
-        @from = if expr == 'continue'.freeze
-          :continue
-        else
-          Expression.parse(expr)
-        end
-      when 'limit'.freeze
-        @limit = Expression.parse(expr)
+      def render_else(context)
+        return @else_block ? [render_all(@else_block, context)] : ''
       end
-    end
 
-    def render_else(context)
-      @else_block ? @else_block.render(context) : ''.freeze
-    end
-
-    def iterable?(collection)
-      collection.respond_to?(:each) || Utils.non_blank_string?(collection)
-    end
+      def iterable?(collection)
+        collection.respond_to?(:each) || Utils.non_blank_string?(collection)
+      end
   end
 
-  Template.register_tag('for'.freeze, For)
+  Template.register_tag('for', For)
 end

lib/liquid/tags/if.rb

@@ -14,23 +14,18 @@ module Liquid
     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)
-      super
+    def initialize(tag_name, markup, tokens)
       @blocks = []
-      push_block('if'.freeze, markup)
-    end
-
-    def parse(tokens)
-      while more = parse_body(@blocks.last.attachment, tokens)
-      end
+      push_block('if', markup)
+      super
     end
 
     def nodelist
-      @blocks.map(&:attachment)
+      @blocks.map(&:attachment).flatten
     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
@@ -41,58 +36,39 @@ module Liquid
       context.stack do
         @blocks.each do |block|
           if block.evaluate(context)
-            return block.attachment.render(context)
+            return render_all(block.attachment, context)
           end
         end
-        ''.freeze
+        ''
       end
     end
 
-    def format
-      out = ""
-      first_condition = true
-
-      @blocks.each do |block|
-        if block.else?
-          out << "{% else %}"
-        elsif first_condition
-          out << "{% #{block_name} #{block.format} %}"
-          first_condition = false
-        else
-          out << "{% elsif #{block.format} %}"
-        end
-        out << block.attachment.format
-      end
-
-      out + "{% #{block_delimiter} %}"
-    end
-
     private
 
       def push_block(tag, markup)
-        block = if tag == 'else'.freeze
+        block = if tag == 'else'
           ElseCondition.new
         else
           parse_with_selected_parser(markup)
         end
 
         @blocks.push(block)
-        block.attach(BlockBody.new)
+        @nodelist = block.attach(Array.new)
       end
 
       def lax_parse(markup)
-        expressions = markup.scan(ExpressionsAndOperators)
-        raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.pop =~ Syntax
+        expressions = markup.scan(ExpressionsAndOperators).reverse
+        raise(SyntaxError.new(options[:locale].t("errors.syntax.if"))) unless expressions.shift =~ Syntax
 
-        condition = Condition.new(Expression.parse($1), $2, Expression.parse($3))
+        condition = Condition.new($1, $2, $3)
 
         while not expressions.empty?
-          operator = expressions.pop.to_s.strip
+          operator = (expressions.shift).to_s.strip
 
-          raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.pop.to_s =~ Syntax
+          raise(SyntaxError.new(options[:locale].t("errors.syntax.if"))) unless expressions.shift.to_s =~ Syntax
 
-          new_condition = Condition.new(Expression.parse($1), $2, Expression.parse($3))
-          raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless BOOLEAN_OPERATORS.include?(operator)
+          new_condition = Condition.new($1, $2, $3)
+          raise(SyntaxError.new(options[:locale].t("errors.syntax.if"))) unless BOOLEAN_OPERATORS.include?(operator)
           new_condition.send(operator, condition)
           condition = new_condition
         end
@@ -105,7 +81,7 @@ module Liquid
 
         condition = parse_comparison(p)
 
-        while op = (p.id?('and'.freeze) || p.id?('or'.freeze))
+        while op = (p.id?('and') || p.id?('or'))
           new_cond = parse_comparison(p)
           new_cond.send(op, condition)
           condition = new_cond
@@ -116,9 +92,9 @@ module Liquid
       end
 
       def parse_comparison(p)
-        a = Expression.parse(p.expression)
+        a = p.expression
         if op = p.consume?(:comparison)
-          b = Expression.parse(p.expression)
+          b = p.expression
           Condition.new(a, op, b)
         else
           Condition.new(a)
@@ -126,5 +102,5 @@ module Liquid
       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,47 +17,38 @@ module Liquid
   class Include < Tag
     Syntax = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?/o
 
-    def initialize(tag_name, markup, options)
-      super
-
+    def initialize(tag_name, markup, tokens)
       if markup =~ Syntax
 
-        template_name = $1
-        variable_name = $3
-
-        @variable_name_expr = variable_name ? Expression.parse(variable_name) : nil
-        @template_name_expr = Expression.parse(template_name)
-        @attributes = {}
+        @template_name = $1
+        @variable_name = $3
+        @attributes    = {}
 
         markup.scan(TagAttributes) do |key, value|
-          @attributes[key] = Expression.parse(value)
+          @attributes[key] = value
         end
 
       else
-        raise SyntaxError.new(options[:locale].t("errors.syntax.include".freeze))
+        raise SyntaxError.new(options[:locale].t("errors.syntax.include"))
       end
+
+      super
     end
 
-    def parse(tokens)
+    def blank?
+      false
     end
 
     def render(context)
       partial = load_cached_partial(context)
-
-      template_name = context.evaluate(@template_name_expr)
-      context_variable_name = template_name.split('/'.freeze).last
-
-      variable = if @variable_name_expr
-        context.evaluate(@variable_name_expr)
-      else
-        context.find_variable(template_name)
-      end
+      variable = context[@variable_name || @template_name[1..-2]]
 
       context.stack do
         @attributes.each do |key, value|
-          context[key] = context.evaluate(value)
+          context[key] = context[value]
         end
 
+        context_variable_name = @template_name[1..-2].split('/').last
         if variable.is_a?(Array)
           variable.collect do |var|
             context[context_variable_name] = var
@@ -70,31 +61,16 @@ module Liquid
       end
     end
 
-    def format
-      segments = [@tag_name, Expression.format(@template_name_expr)]
-
-      if @variable_name_expr
-        segments << "with"
-        segments << Expression.format(@variable_name_expr)
-      end
-
-      unless @attributes.empty?
-        segments << @attributes.map { |k, v| "#{k}: #{Expression.format(v)}" }.join(", ")
-      end
-
-      "{% #{segments.join(' ')} %}"
-    end
-
     private
       def load_cached_partial(context)
         cached_partials = context.registers[:cached_partials] || {}
-        template_name = context.evaluate(@template_name_expr)
+        template_name = context[@template_name]
 
         if cached = cached_partials[template_name]
           return cached
         end
         source = read_template_from_file_system(context)
-        partial = Liquid::Template.parse(source, pass_options)
+        partial = Liquid::Template.parse(source)
         cached_partials[template_name] = partial
         context.registers[:cached_partials] = cached_partials
         partial
@@ -103,19 +79,17 @@ module Liquid
       def read_template_from_file_system(context)
         file_system = context.registers[:file_system] || Liquid::Template.file_system
 
-        file_system.read_template_file(context.evaluate(@template_name_expr))
-      end
-
-      def pass_options
-        dont_pass = @options[:include_options_blacklist]
-        return {locale: @options[:locale]} if dont_pass == true
-        opts = @options.merge(included: true, include_options_blacklist: false)
-        if dont_pass.is_a?(Array)
-          dont_pass.each {|o| opts.delete(o)}
+        # make read_template_file call backwards-compatible.
+        case file_system.method(:read_template_file).arity
+        when 1
+          file_system.read_template_file(context[@template_name])
+        when 2
+          file_system.read_template_file(context[@template_name], context)
+        else
+          raise ArgumentError, "file_system.read_template_file expects two parameters: (template_name, context)"
         end
-        opts
       end
   end
 
-  Template.register_tag('include'.freeze, Include)
+  Template.register_tag('include', Include)
 end

lib/liquid/tags/increment.rb

@@ -15,9 +15,9 @@ module Liquid
   #    Hello: 2
   #
   class Increment < Tag
-    def initialize(tag_name, markup, options)
-      super
+    def initialize(tag_name, markup, tokens)
       @variable = markup.strip
+      super
     end
 
     def render(context)
@@ -25,7 +25,11 @@ module Liquid
       context.environments.first[@variable] = value + 1
       value.to_s
     end
+
+    def blank?
+      false
+    end
   end
 
-  Template.register_tag('increment'.freeze, Increment)
+  Template.register_tag('increment', Increment)
 end

lib/liquid/tags/raw.rb

@@ -1,34 +1,19 @@
 module Liquid
   class Raw < Block
-    FullTokenPossiblyInvalid = /\A(.*)#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/om
+    FullTokenPossiblyInvalid = /\A(.*)#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/o
 
-    def parse(tokens)
-      @body = ''
+    def parse_body(tokens)
+      @nodelist ||= []
+      @nodelist.clear
       while token = tokens.shift
         if token =~ FullTokenPossiblyInvalid
-          @body << $1 if $1 != "".freeze
+          @nodelist << $1 if $1 != ""
           return if block_delimiter == $2
         end
-        @body << token if not token.empty?
+        @nodelist << token if not token.empty?
       end
     end
-
-    def render(context)
-      @body
-    end
-
-    def nodelist
-      [@body]
-    end
-
-    def blank?
-      @body.empty?
-    end
-
-    def format
-      "{% #{block_name} %}#{@body}{% #{block_delimiter} %}"
-    end
   end
 
-  Template.register_tag('raw'.freeze, Raw)
+  Template.register_tag('raw', Raw)
 end

lib/liquid/tags/table_row.rb

@@ -1,78 +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 = Expression.parse($2)
-        @attributes = {}
-        markup.scan(TagAttributes) do |key, value|
-          @attributes[key] = Expression.parse(value)
-        end
-      else
-        raise SyntaxError.new(options[:locale].t("errors.syntax.table_row".freeze))
-      end
-    end
-
-    def render(context)
-      collection = context.evaluate(@collection_name) or return ''.freeze
-
-      from = @attributes.key?('offset'.freeze) ? context.evaluate(@attributes['offset'.freeze]).to_i : 0
-      to = @attributes.key?('limit'.freeze) ? from + context.evaluate(@attributes['limit'.freeze]).to_i : nil
-
-      collection = Utils.slice_collection(collection, from, to)
-
-      length = collection.length
-
-      cols = context.evaluate(@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,
-            '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}\">" << super << '</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
-
-    def format
-      tag_main = "#{block_name} #{@variable_name} in #{Expression.format(@collection_name)}"
-      args = @attributes.map { |k, v| "#{k}: #{Expression.format(v)}" }.join(", ")
-      "{% #{tag_main} #{args} %}#{@body.format}{% #{block_delimiter} %}"
-    end
-  end
-
-  Template.register_tag('tablerow'.freeze, TableRow)
-end

lib/liquid/tags/unless.rb

@@ -1,9 +1,10 @@
 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 {% endunless %}
+  #   {% unless x < 0 %} x is greater than zero {% end %}
   #
   class Unless < If
     def render(context)
@@ -12,20 +13,21 @@ module Liquid
         # First condition is interpreted backwards ( if not )
         first_block = @blocks.first
         unless first_block.evaluate(context)
-          return first_block.attachment.render(context)
+          return render_all(first_block.attachment, context)
         end
 
         # After the first condition unless works just like if
         @blocks[1..-1].each do |block|
           if block.evaluate(context)
-            return block.attachment.render(context)
+            return render_all(block.attachment, context)
           end
         end
 
-        ''.freeze
+        ''
       end
     end
   end
 
-  Template.register_tag('unless'.freeze, Unless)
+
+  Template.register_tag('unless', Unless)
 end

lib/liquid/template.rb

@@ -18,56 +18,10 @@ module Liquid
       :locale => I18n.new
     }
 
-    attr_accessor :root
-    attr_reader :resource_limits
-
+    attr_accessor :root, :resource_limits
     @@file_system = BlankFileSystem.new
 
-    class TagRegistry
-      def initialize
-        @tags  = {}
-        @cache = {}
-      end
-
-      def [](tag_name)
-        return nil unless @tags.has_key?(tag_name)
-        return @cache[tag_name] if Liquid.cache_classes
-
-        lookup_class(@tags[tag_name]).tap { |o| @cache[tag_name] = o }
-      end
-
-      def []=(tag_name, klass)
-        @tags[tag_name]  = klass.name
-        @cache[tag_name] = klass
-      end
-
-      def delete(tag_name)
-        @tags.delete(tag_name)
-        @cache.delete(tag_name)
-      end
-
-      private
-
-      def lookup_class(name)
-        name.split("::").reject(&:empty?).reduce(Object) { |scope, const| scope.const_get(const) }
-      end
-    end
-
-    attr_reader :profiler
-
     class << self
-      # 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.
-      attr_writer :error_mode
-
-      # Sets how strict the taint checker should be.
-      # :lax is the default, and ignores the taint flag completely
-      # :warn adds a warning, but does not interrupt the rendering
-      # :error raises an error when tainted output is used
-      attr_writer :taint_mode
-
       def file_system
         @@file_system
       end
@@ -81,47 +35,44 @@ module Liquid
       end
 
       def tags
-        @tags ||= TagRegistry.new
+        @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
 
-      def taint_mode
-        @taint_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)
         Strainer.global_filter(mod)
       end
 
-      def default_resource_limits
-        @default_resource_limits ||= {}
-      end
-
       # creates a new <tt>Template</tt> object from liquid source code
-      # To enable profiling, pass in <tt>profile: true</tt> as an option.
-      # See Liquid::Profiler for more information
       def parse(source, options = {})
         template = Template.new
         template.parse(source, options)
+        template
       end
     end
 
+    # creates a new <tt>Template</tt> from an array of tokens. Use <tt>Template.parse</tt> instead
     def initialize
-      @resource_limits = ResourceLimits.new(self.class.default_resource_limits)
+      @resource_limits = {}
     end
 
     # Parse source code.
     # Returns self for easy chaining
     def parse(source, options = {})
-      @options = options
-      @profiling = options[:profile]
-      @line_numbers = options[:line_numbers] || @profiling
-      @root = Document.parse(tokenize(source), DEFAULT_OPTIONS.merge(options))
+      @root = Document.new(tokenize(source), DEFAULT_OPTIONS.merge(options))
       @warnings = nil
       self
     end
@@ -152,9 +103,6 @@ module Liquid
     # if you use the same filters over and over again consider registering them globally
     # with <tt>Template.register_filter</tt>
     #
-    # if profiling was enabled in <tt>Template#parse</tt> then the resulting profiling information
-    # will be available via <tt>Template#profiler</tt>
-    #
     # Following options can be passed:
     #
     #  * <tt>filters</tt> : array with local filters
@@ -162,17 +110,11 @@ 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
-        c = args.shift
-
-        if @rethrow_errors
-          c.exception_handler = ->(e) { true }
-        end
-
-        c
+        args.shift
       when Liquid::Drop
         drop = args.shift
         drop.context = Context.new([drop, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits)
@@ -196,24 +138,16 @@ module Liquid
           context.add_filters(options[:filters])
         end
 
-        if options[:exception_handler]
-          context.exception_handler = options[:exception_handler]
-        end
       when Module
         context.add_filters(args.pop)
       when Array
         context.add_filters(args.pop)
       end
 
-      # Retrying a render resets resource usage
-      context.resource_limits.reset
-
       begin
         # render the nodelist.
         # for performance reasons we get an array back here. join will make a string out of it.
-        result = with_profiling do
-          @root.render(context)
-        end
+        result = @root.render(context)
         result.respond_to?(:join) ? result.join : result
       rescue Liquid::MemoryError => e
         context.handle_error(e)
@@ -223,51 +157,15 @@ module Liquid
     end
 
     def render!(*args)
-      @rethrow_errors = true
-      render(*args)
+      @rethrow_errors = true; render(*args)
     end
 
     private
 
-    # Uses the <tt>Liquid::TemplateParser</tt> regexp to tokenize the passed source
     def tokenize(source)
       source = source.source if source.respond_to?(:source)
-      return [] if source.to_s.empty?
-
-      tokens = calculate_line_numbers(source.split(TemplateParser))
-
-      # removes the rogue empty element at the beginning of the array
-      tokens.shift if tokens[0] and tokens[0].empty?
-
-      tokens
+      Tokenizer.new(source.to_s)
     end
 
-    def calculate_line_numbers(raw_tokens)
-      return raw_tokens unless @line_numbers
-
-      current_line = 1
-      raw_tokens.map do |token|
-        Token.new(token, current_line).tap do
-          current_line += token.count("\n")
-        end
-      end
-    end
-
-    def with_profiling
-      if @profiling && !@options[:included]
-        raise "Profiler not loaded, require 'liquid/profiler' first" unless defined?(Liquid::Profiler)
-
-        @profiler = Profiler.new
-        @profiler.start
-
-        begin
-          yield
-        ensure
-          @profiler.stop
-        end
-      else
-        yield
-      end
-    end
   end
 end

lib/liquid/token.rb

@@ -1,18 +0,0 @@
-module Liquid
-  class Token < String
-    attr_reader :line_number
-
-    def initialize(content, line_number)
-      super(content)
-      @line_number = line_number
-    end
-
-    def raw
-      "<raw>"
-    end
-
-    def child(string)
-      Token.new(string, @line_number)
-    end
-  end
-end

lib/liquid/utils.rb

@@ -10,7 +10,7 @@ module Liquid
     end
 
     def self.non_blank_string?(collection)
-      collection.is_a?(String) && collection != ''.freeze
+      collection.is_a?(String) && collection != ''
     end
 
     def self.slice_collection_using_each(collection, from, to)

lib/liquid/variable.rb

@@ -11,62 +11,41 @@ module Liquid
   #   {{ user | link }}
   #
   class Variable
-    FilterParser = /(?:\s+|#{QuotedFragment}|#{ArgumentSeparator})+/o
+    FilterParser = /(?:#{FilterSeparator}|(?:\s*(?:#{QuotedFragment}|#{ArgumentSeparator})\s*)+)/o
+    EasyParse = /\A *(\w+(?:\.\w+)*) *\z/
     attr_accessor :filters, :name, :warnings
-    attr_accessor :line_number
-    include ParserSwitching
 
     def initialize(markup, options = {})
       @markup  = markup
       @name    = nil
       @options = options || {}
+      
 
-      parse_with_selected_parser(markup)
-    end
-
-    def raw
-      @markup
-    end
-
-    def format
-      out = Expression.format(@name)
-
-      @filters.each do |filter|
-        out << " | "
-        out << filter[0]
-
-        args = filter[1].map { |arg| Expression.format(arg) }
-
-        if filter.size > 2
-          args += filter[2].map { |key, arg| "#{key}: #{Expression.format(arg)}" }
-        end
-
-        unless args.empty?
-          out << ": "
-          out << args.join(', ')
+      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
-
-      out
-    end
-
-    def markup_context(markup)
-      "in \"{{#{markup}}}\""
     end
 
     def lax_parse(markup)
       @filters = []
-      if markup =~ /(#{QuotedFragment})(.*)/om
-        name_markup = $1
-        filter_markup = $2
-        @name = Expression.parse(name_markup)
-        if filter_markup =~ /#{FilterSeparator}\s*(.*)/om
-          filters = $1.scan(FilterParser)
+      if match = markup.match(/\s*(#{QuotedFragment})(.*)/o)
+        @name = match[1]
+        if match[2].match(/#{FilterSeparator}\s*(.*)/o)
+          filters = Regexp.last_match(1).scan(FilterParser)
           filters.each do |f|
-            if f =~ /\w+/
-              filtername = Regexp.last_match(0)
+            if matches = f.match(/\s*(\w+)/)
+              filtername = matches[1]
               filterargs = f.scan(/(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o).flatten
-              @filters << parse_filter_expressions(filtername, filterargs)
+              @filters << [filtername, filterargs]
             end
           end
         end
@@ -74,16 +53,26 @@ module Liquid
     end
 
     def strict_parse(markup)
+      # Very simple valid cases
+      if markup =~ EasyParse
+        @name = $1
+        @filters = []
+        return
+      end
+
       @filters = []
       p = Parser.new(markup)
-
-      @name = Expression.parse(p.expression)
+      # Could be just filters with no input
+      @name = p.look(:pipe) ? '' : p.expression
       while p.consume?(:pipe)
         filtername = p.consume(:id)
         filterargs = p.consume?(:colon) ? parse_filterargs(p) : []
-        @filters << parse_filter_expressions(filtername, filterargs)
+        @filters << [filtername, filterargs]
       end
       p.consume(:end_of_string)
+    rescue SyntaxError => e
+      e.message << " in \"{{#{markup}}}\""
+      raise e
     end
 
     def parse_filterargs(p)
@@ -97,51 +86,22 @@ module Liquid
     end
 
     def render(context)
-      @filters.inject(context.evaluate(@name)) do |output, (filter_name, filter_args, filter_kwargs)|
-        filter_args = evaluate_filter_expressions(context, filter_args, filter_kwargs)
-        output = context.invoke(filter_name, output, *filter_args)
-      end.tap{ |obj| taint_check(obj) }
-    end
-
-    private
-
-    def parse_filter_expressions(filter_name, unparsed_args)
-      filter_args = []
-      keyword_args = {}
-      unparsed_args.each do |a|
-        if matches = a.match(/\A#{TagAttributes}\z/o)
-          keyword_args[matches[1]] = Expression.parse(matches[2])
-        else
-          filter_args << Expression.parse(a)
+      return '' if @name.nil?
+      @filters.inject(context[@name]) do |output, filter|
+        filterargs = []
+        keyword_args = {}
+        filter[1].to_a.each do |a|
+          if matches = a.match(/\A#{TagAttributes}\z/o)
+            keyword_args[matches[1]] = context[matches[2]]
+          else
+            filterargs << context[a]
+          end
         end
-      end
-      result = [filter_name, filter_args]
-      result << keyword_args unless keyword_args.empty?
-      result
-    end
-
-    def evaluate_filter_expressions(context, filter_args, filter_kwargs)
-      parsed_args = filter_args.map{ |expr| context.evaluate(expr) }
-      if filter_kwargs
-        parsed_kwargs = {}
-        filter_kwargs.each do |key, expr|
-          parsed_kwargs[key] = context.evaluate(expr)
-        end
-        parsed_args << parsed_kwargs
-      end
-      parsed_args
-    end
-
-    def taint_check(obj)
-      if obj.tainted?
-        @markup =~ QuotedFragment
-        name = Regexp.last_match(0)
-        case Template.taint_mode
-        when :warn
-          @warnings ||= []
-          @warnings << "variable '#{name}' is tainted and was not escaped"
-        when :error
-          raise TaintedError, "Error - variable '#{name}' is tainted and was not escaped"
+        filterargs << keyword_args unless keyword_args.empty?
+        begin
+          output = context.invoke(filter[0], output, *filterargs)
+        rescue FilterNotFound
+          raise FilterNotFound, "Error - filter '#{filter[0]}' in '#{@markup.strip}' could not be found."
         end
       end
     end

lib/liquid/variable_lookup.rb

@@ -1,95 +0,0 @@
-module Liquid
-  class VariableLookup
-    SQUARE_BRACKETED = /\A\[(.*)\]\z/m
-    COMMAND_METHODS = ['size'.freeze, 'first'.freeze, 'last'.freeze]
-
-    attr_reader :name, :lookups
-
-    def self.parse(markup)
-      new(markup)
-    end
-
-    def initialize(markup)
-      lookups = markup.scan(VariableParser)
-
-      name = lookups.shift
-      if name =~ SQUARE_BRACKETED
-        @name_expression = true
-        name = Expression.parse($1)
-      end
-      @name = name
-
-      @lookups = lookups
-      @command_flags = 0
-
-      @lookups.each_index do |i|
-        lookup = lookups[i]
-        if lookup =~ SQUARE_BRACKETED
-          lookups[i] = Expression.parse($1)
-        elsif COMMAND_METHODS.include?(lookup)
-          @command_flags |= 1 << i
-        end
-      end
-    end
-
-    def evaluate(context)
-      name = context.evaluate(@name)
-      object = context.find_variable(name)
-
-      @lookups.each_index do |i|
-        key = context.evaluate(@lookups[i])
-
-        # If object is a hash- or array-like object we look for the
-        # presence of the key and if its available we return it
-        if object.respond_to?(:[]) &&
-          ((object.respond_to?(:has_key?) && object.has_key?(key)) ||
-           (object.respond_to?(:fetch) && key.is_a?(Integer)))
-
-          # if its a proc we will replace the entry with the proc
-          res = context.lookup_and_evaluate(object, key)
-          object = res.to_liquid
-
-          # Some special cases. If the part wasn't in square brackets and
-          # no key with the same name was found we interpret following calls
-          # as commands and call them on the current object
-        elsif @command_flags & (1 << i) != 0 && object.respond_to?(key)
-          object = object.send(key).to_liquid
-
-          # No key was present with the desired value and it wasn't one of the directly supported
-          # keywords either. The only thing we got left is to return nil
-        else
-          return nil
-        end
-
-        # If we are dealing with a drop here we have to
-        object.context = context if object.respond_to?(:context=)
-      end
-
-      object
-    end
-
-    def ==(other)
-      self.class == other.class && self.state == other.state
-    end
-
-    def format
-      out = @name_expression ? Expression.format(@name) : @name.dup
-
-      @lookups.each do |lookup|
-        if lookup.is_a?(String) && lookup =~ /^#{VariableSegment}+$/
-          out << ".#{lookup}"
-        else
-          out << "[#{Expression.format(lookup)}]"
-        end
-      end
-
-      out
-    end
-
-    protected
-
-    def state
-      [@name, @lookups, @command_flags]
-    end
-  end
-end

lib/liquid/version.rb

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

liquid.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |s|
   s.version     = Liquid::VERSION
   s.platform    = Gem::Platform::RUBY
   s.summary     = "A secure, non-evaling end user template engine with aesthetic markup."
-  s.authors     = ["Tobias Lütke"]
+  s.authors     = ["Tobias Luetke"]
   s.email       = ["tobi@leetsoft.com"]
   s.homepage    = "http://www.liquidmarkup.org"
   s.license     = "MIT"
@@ -18,12 +18,15 @@ Gem::Specification.new do |s|
   s.required_rubygems_version = ">= 1.3.7"
 
   s.test_files  = Dir.glob("{test}/**/*")
-  s.files       = Dir.glob("{lib}/**/*") + %w(MIT-LICENSE README.md)
+  s.files       = Dir.glob("{lib,ext}/**/*") + %w(MIT-LICENSE README.md)
+  s.extensions  = ['ext/liquid/extconf.rb']
 
   s.extra_rdoc_files  = ["History.md", "README.md"]
 
   s.require_path = "lib"
 
+  s.add_development_dependency 'rake-compiler'
+  s.add_development_dependency 'stackprof'
   s.add_development_dependency 'rake'
-  s.add_development_dependency 'minitest'
+  s.add_development_dependency 'activesupport'
 end

performance/benchmark.rb

@@ -1,17 +1,12 @@
-require 'benchmark/ips'
+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.ips do |x|
-  x.time = 60
-  x.warmup = 5
-
-  puts
-  puts "Running benchmark for #{x.time} seconds (with #{x.warmup} seconds warmup)."
-  puts
-
-  x.report("parse:") { profiler.compile }
-  x.report("parse & run:") { profiler.run }
+Benchmark.bmbm do |x|
+  x.report("parse:")   { 100.times { profiler.compile } }
+  x.report("parse & run:")   { 100.times { profiler.run } }
 end
+

performance/profile.rb

@@ -1,24 +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
 
-[:cpu, :object].each do |profile_type|
-  puts "Profiling in #{profile_type.to_s} mode..."
-  results = StackProf.run(mode: profile_type) do
-    200.times do
-      profiler.run
-    end
-  end
+puts 'Running profiler...'
 
-  if profile_type == :cpu && graph_filename = ENV['GRAPH_FILENAME']
-    File.open(graph_filename, 'w') do |f|
-      StackProf::Report.new(results).print_graphviz(nil, f)
-    end
-  end
+results  = profiler.run_profile
 
-  StackProf::Report.new(results).print_text(false, 20)
-  File.write(ENV['FILENAME'] + "." + profile_type.to_s, Marshal.dump(results)) if ENV['FILENAME']
+puts 'Success'
+puts
+
+[RubyProf::FlatPrinter, RubyProf::GraphHtmlPrinter, RubyProf::CallTreePrinter, RubyProf::DotPrinter].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, :min_percent => 3) }
+  $stderr.puts "wrote #{klass.name} output to #{filename}"
 end

performance/shopify/comment_form.rb

@@ -1,15 +1,15 @@
 class CommentForm < Liquid::Block
   Syntax = /(#{Liquid::VariableSignature}+)/
 
-  def initialize(tag_name, markup, options)
-    super
-
+  def initialize(tag_name, markup, tokens)
     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/database.rb

@@ -1,6 +1,6 @@
 require 'yaml'
-
 module Database
+
   # Load the standard vision toolkit database and re-arrage it to be simply exportable
   # to liquid as assigns. All this is based on Shopify
   def self.tables

performance/shopify/json_filter.rb

@@ -1,9 +1,7 @@
-require 'json'
-
 module JsonFilter
 
   def json(object)
-    JSON.dump(object.reject {|k,v| k == "collections" })
+    object.reject {|k,v| k == "collections" }.to_json
   end
 
 end

performance/shopify/paginate.rb

@@ -1,8 +1,8 @@
 class Paginate < Liquid::Block
   Syntax     = /(#{Liquid::QuotedFragment})\s*(by\s*(\d+))?/
 
-  def initialize(tag_name, markup, options)
-    super
+  def initialize(tag_name, markup, tokens)
+    @nodelist = []
 
     if markup =~ Syntax
       @collection_name = $1
@@ -19,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)
@@ -71,7 +73,7 @@ class Paginate < Liquid::Block
         end
       end
 
-      super
+      render_all(@nodelist, context)
     end
   end
 

performance/shopify/shop_filter.rb

@@ -45,11 +45,11 @@ 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')
@@ -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/stackprof.rb

@@ -0,0 +1,15 @@
+require 'stackprof' rescue fail("install stackprof extension/gem")
+require File.dirname(__FILE__) + '/theme_runner'
+
+profiler = ThemeRunner.new
+profiler.run
+results = StackProf.run(mode: :cpu, out: ENV['FILENAME']) do
+  100.times do
+    profiler.run
+  end
+end
+if results.kind_of?(File)
+  puts "wrote stackprof dump to #{results.path}"
+else
+  StackProf::Report.new(results).print_text(false, 20)
+end

performance/theme_runner.rb

@@ -6,6 +6,10 @@
 # Shopify which is likely the biggest user of liquid in the world which something to the tune of several
 # million Template#render calls a day.
 
+require 'rubygems'
+require 'active_support'
+require 'yaml'
+require 'digest/md5'
 require File.dirname(__FILE__) + '/shopify/liquid'
 require File.dirname(__FILE__) + '/shopify/database.rb'
 
@@ -17,7 +21,7 @@ class ThemeRunner
     end
 
     # Called by Liquid to retrieve a template file
-    def read_template_file(template_path)
+    def read_template_file(template_path, context)
       File.read(@path + '/' + template_path + '.liquid')
     end
   end
@@ -60,19 +64,57 @@ 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
   end
 end
+
+
+

test/integration/context_test.rb

@@ -1,32 +0,0 @@
-require 'test_helper'
-
-class ContextTest < Minitest::Test
-  include Liquid
-
-  def test_override_global_filter
-    global = Module.new do
-      def notice(output)
-        "Global #{output}"
-      end
-    end
-
-    local = Module.new do
-      def notice(output)
-        "Local #{output}"
-      end
-    end
-
-    with_global_filter(global) do
-      assert_equal 'Global test', Template.parse("{{'test' | notice }}").render!
-      assert_equal 'Local test', Template.parse("{{'test' | notice }}").render!({}, :filters => [local])
-    end
-  end
-
-  def test_has_key_will_not_add_an_error_for_missing_keys
-    with_error_mode :strict do
-      context = Context.new
-      context.has_key?('unknown')
-      assert_empty context.errors
-    end
-  end
-end

test/integration/document_test.rb

@@ -1,19 +0,0 @@
-require 'test_helper'
-
-class DocumentTest < Minitest::Test
-  include Liquid
-
-  def test_unexpected_outer_tag
-    exc = assert_raises(SyntaxError) do
-      Template.parse("{% else %}")
-    end
-    assert_equal exc.message, "Liquid syntax error: Unexpected outer 'else' tag"
-  end
-
-  def test_unknown_tag
-    exc = assert_raises(SyntaxError) do
-      Template.parse("{% foo %}")
-    end
-    assert_equal exc.message, "Liquid syntax error: Unknown tag 'foo'"
-  end
-end

test/integration/error_handling_test.rb

@@ -1,207 +0,0 @@
-require 'test_helper'
-
-class ErrorDrop < Liquid::Drop
-  def standard_error
-    raise Liquid::StandardError, 'standard error'
-  end
-
-  def argument_error
-    raise Liquid::ArgumentError, 'argument error'
-  end
-
-  def syntax_error
-    raise Liquid::SyntaxError, 'syntax error'
-  end
-
-  def exception
-    raise Exception, 'exception'
-  end
-
-end
-
-class ErrorHandlingTest < Minitest::Test
-  include Liquid
-
-  def test_templates_parsed_with_line_numbers_renders_them_in_errors
-    template = <<-LIQUID
-      Hello,
-
-      {{ errors.standard_error }} will raise a standard error.
-
-      Bla bla test.
-
-      {{ errors.syntax_error }} will raise a syntax error.
-
-      This is an argument error: {{ errors.argument_error }}
-
-      Bla.
-    LIQUID
-
-    expected = <<-TEXT
-      Hello,
-
-      Liquid error (line 3): standard error will raise a standard error.
-
-      Bla bla test.
-
-      Liquid syntax error (line 7): syntax error will raise a syntax error.
-
-      This is an argument error: Liquid error (line 9): argument error
-
-      Bla.
-    TEXT
-
-    output = Liquid::Template.parse(template, line_numbers: true).render('errors' => ErrorDrop.new)
-    assert_equal expected, output
-  end
-
-  def test_standard_error
-    template = Liquid::Template.parse( ' {{ errors.standard_error }} '  )
-    assert_equal ' Liquid error: standard error ', template.render('errors' => ErrorDrop.new)
-
-    assert_equal 1, template.errors.size
-    assert_equal StandardError, template.errors.first.class
-  end
-
-  def test_syntax
-    template = Liquid::Template.parse( ' {{ errors.syntax_error }} '  )
-    assert_equal ' Liquid syntax error: syntax error ', template.render('errors' => ErrorDrop.new)
-
-    assert_equal 1, template.errors.size
-    assert_equal SyntaxError, template.errors.first.class
-  end
-
-  def test_argument
-    template = Liquid::Template.parse( ' {{ errors.argument_error }} '  )
-    assert_equal ' Liquid error: argument error ', template.render('errors' => ErrorDrop.new)
-
-    assert_equal 1, template.errors.size
-    assert_equal ArgumentError, template.errors.first.class
-  end
-
-  def test_missing_endtag_parse_time_error
-    assert_raises(Liquid::SyntaxError) do
-      Liquid::Template.parse(' {% for a in b %} ... ')
-    end
-  end
-
-  def test_unrecognized_operator
-    with_error_mode(:strict) do
-      assert_raises(SyntaxError) do
-        Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ')
-      end
-    end
-  end
-
-  def test_lax_unrecognized_operator
-    template = Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', :error_mode => :lax)
-    assert_equal ' Liquid error: Unknown operator =! ', template.render
-    assert_equal 1, template.errors.size
-    assert_equal Liquid::ArgumentError, template.errors.first.class
-  end
-
-  def test_with_line_numbers_adds_numbers_to_parser_errors
-    err = assert_raises(SyntaxError) do
-      template = Liquid::Template.parse(%q{
-          foobar
-
-          {% "cat" | foobar %}
-
-          bla
-        },
-        :line_numbers => true
-      )
-    end
-
-    assert_match /Liquid syntax error \(line 4\)/, err.message
-  end
-
-  def test_parsing_warn_with_line_numbers_adds_numbers_to_lexer_errors
-    template = Liquid::Template.parse(%q{
-        foobar
-
-        {% if 1 =! 2 %}ok{% endif %}
-
-        bla
-      },
-      :error_mode => :warn,
-      :line_numbers => true
-    )
-
-    assert_equal ['Liquid syntax error (line 4): Unexpected character = in "1 =! 2"'],
-      template.warnings.map(&:message)
-  end
-
-  def test_parsing_strict_with_line_numbers_adds_numbers_to_lexer_errors
-    err = assert_raises(SyntaxError) do
-      Liquid::Template.parse(%q{
-          foobar
-
-          {% if 1 =! 2 %}ok{% endif %}
-
-          bla
-        },
-        :error_mode => :strict,
-        :line_numbers => true
-      )
-    end
-
-    assert_equal 'Liquid syntax error (line 4): Unexpected character = in "1 =! 2"', err.message
-  end
-
-  def test_syntax_errors_in_nested_blocks_have_correct_line_number
-    err = assert_raises(SyntaxError) do
-      Liquid::Template.parse(%q{
-          foobar
-
-          {% if 1 != 2 %}
-            {% foo %}
-          {% endif %}
-
-          bla
-        },
-        :line_numbers => true
-      )
-    end
-
-    assert_equal "Liquid syntax error (line 5): Unknown tag 'foo'", err.message
-  end
-
-  def test_strict_error_messages
-    err = assert_raises(SyntaxError) do
-      Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', :error_mode => :strict)
-    end
-    assert_equal 'Liquid syntax error: Unexpected character = in "1 =! 2"', err.message
-
-    err = assert_raises(SyntaxError) do
-      Liquid::Template.parse('{{%%%}}', :error_mode => :strict)
-    end
-    assert_equal 'Liquid syntax error: 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].to_s(false)
-    assert_equal 'Unexpected character % in "{{%%%}}"', template.warnings[1].to_s(false)
-    assert_equal 'Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].to_s(false)
-    assert_equal '', template.render
-  end
-
-  def test_warning_line_numbers
-    template = Liquid::Template.parse("{% if ~~~ %}\n{{%%%}}{% else %}\n{{ hello. }}{% endif %}", :error_mode => :warn, :line_numbers => true)
-    assert_equal 'Liquid syntax error (line 1): Unexpected character ~ in "~~~"', template.warnings[0].message
-    assert_equal 'Liquid syntax error (line 2): Unexpected character % in "{{%%%}}"', template.warnings[1].message
-    assert_equal 'Liquid syntax error (line 3): Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].message
-    assert_equal 3, template.warnings.size
-    assert_equal [1,2,3], template.warnings.map(&:line_number)
-  end
-
-  # Liquid should not catch Exceptions that are not subclasses of StandardError, like Interrupt and NoMemoryError
-  def test_exceptions_propagate
-    assert_raises Exception do
-      template = Liquid::Template.parse('{{ errors.exception }}')
-      template.render('errors' => ErrorDrop.new)
-    end
-  end
-end

test/integration/formatter_test.rb

@@ -1,172 +0,0 @@
-require 'test_helper'
-
-class FormatterTest < Minitest::Test
-  def assert_format(expected, src)
-    with_error_mode(:lax) do
-      src_ast = Liquid::Template.parse(src).root
-      assert_equal expected, src_ast.format
-
-      fmt_ast = Liquid::Template.parse(src_ast.format).root
-      assert_equal expected, fmt_ast.format
-    end
-  end
-
-  def test_filters
-    assert_format '{{ a | b: foo, c: "foo" }}', '{{a|b:foo,c:"foo"}}'
-    assert_format '{{ page.attribs.title | downcase }}', "{{page.attribs['title' ]|   downcase}}"
-    assert_format '{{ page.attribs["t.i.t.l.e"] | downcase }}', "{{page.attribs['t.i.t.l.e']  | downcase }}"
-    assert_format '{{ page.attribs["t&tle"] | downcase }}', "{{page.attribs['t&tle']  | downcase }}"
-  end
-
-  def test_conditionals
-    src = <<-eof
-      {% if true && !!%}
-        cats
-      {% elsif a  or  (b and  c) && d%}
-        dogs
-      {% endif %}
-
-      {%unless  something%}
-        cats
-      {% endunless%}
-    eof
-
-    expected = <<-eof
-      {% if true %}
-        cats
-      {% elsif a or b and c %}
-        dogs
-      {% endif %}
-
-      {% unless something %}
-        cats
-      {% endunless %}
-    eof
-
-    assert_format expected, src
-
-    src = <<-eof
-      {%case  var asdf $$^$ %}
-      {% when true%}
-        w
-      {% else%}
-        e
-      {%endcase  %}
-    eof
-
-    expected = <<-eof
-      {% case var %}
-      {% when true %}
-        w
-      {% else %}
-        e
-      {% endcase %}
-    eof
-
-    assert_format expected, src
-  end
-
-  def test_comments
-    assert_format "{% comment %} hunter2 {% endcomment %}", "{%comment   %} hunter2 {%   endcomment ^ %}"
-  end
-
-  def test_assigns
-    assert_format '{% assign foo = "monkey" %}', "{%assign foo  ='monkey' ^ %}"
-  end
-
-  def test_looping
-    src = <<-eof
-      {% for i in (1..10) %}
-        cat
-        {%ifchanged%}{{i}}{% endifchanged  %}
-        {%  continue%}
-      {% else %}
-        dog
-        {%break  %}
-      {% endfor %}
-    eof
-
-    expected = <<-eof
-      {% for i in (1..10) %}
-        cat
-        {% ifchanged %}{{ i }}{% endifchanged %}
-        {% continue %}
-      {% else %}
-        dog
-        {% break %}
-      {% endfor %}
-    eof
-
-    assert_format expected, src
-
-    src = "{% tablerow n in numbers cols:3  offset : 1 limit:6%} {{n}} {% endtablerow %}"
-    expected = "{% tablerow n in numbers cols: 3, offset: 1, limit: 6 %} {{ n }} {% endtablerow %}"
-    assert_format expected, src
-  end
-
-  def test_capture
-    assert_format "{% capture foo %} foo {% endcapture %}", "{%capture  foo  %} foo {%endcapture%}"
-  end
-
-  def test_cycle
-    assert_format '{% cycle "red", 2.8, "green", 1 %}', "{% cycle 'red',2.8,'green',1 %}"
-  end
-
-  def test_augment
-    assert_format "{% decrement foo %}{% increment foo %}", "{%  decrement  foo%}{%increment  foo   %}"
-  end
-
-  def test_raw
-    assert_format "{% raw %} foo {% endraw %}", "{%raw !!%} foo {%endraw foo%}"
-  end
-
-  def test_include
-    src = <<-eof
-      {% include 'foo' %}
-      {% include 'foo' !!! why! %}
-      {% include 'foo' with bar %}
-      {% include 'foo' with bar baz: z  qux:f %}
-      {% include 'foo' baz: z  qux:f %}
-    eof
-
-    expected = <<-eof
-      {% include "foo" %}
-      {% include "foo" %}
-      {% include "foo" with bar %}
-      {% include "foo" with bar baz: z, qux: f %}
-      {% include "foo" baz: z, qux: f %}
-    eof
-
-    assert_format expected, src
-  end
-
-  def test_quirks
-    src = <<-eof
-      {% if a == 'foo' or (b == 'bar' and c == 'baz') or false %} YES {% endif %}
-      {% if true && false %} YES {% endif %}
-      {% if false || true %} YES {% endif %}
-      {{ 'hi there' | split$$$:' ' | first }}""
-      {{ 'X' | downcase) }}
-      {{ 'hi there' | split:"t"" | reverse | first}}
-      {{ 'hi there' | split:"t"" | remove:"i" | first}}
-      {% for i in (1...5) %}{{ i }}{% endfor %}
-      {{test |a|b|}}
-      {{|test|}}
-    eof
-
-    expected = <<-eof
-      {% if a == "foo" or b == "bar" and c == "baz" or false %} YES {% endif %}
-      {% if true %} YES {% endif %}
-      {% if false %} YES {% endif %}
-      {{ "hi there" | split: " " | first }}""
-      {{ "X" | downcase }}
-      {{ "hi there" | split: "t" | reverse | first }}
-      {{ "hi there" | split: "t" | first }}
-      {% for i in (1..5) %}{{ i }}{% endfor %}
-      {{ test | a | b }}
-      {{ test }}
-    eof
-
-    assert_format expected, src
-  end
-end

test/integration/hash_ordering_test.rb

@@ -1,23 +0,0 @@
-require 'test_helper'
-
-module MoneyFilter
-  def money(input)
-    sprintf(' %d$ ', input)
-  end
-end
-
-module CanadianMoneyFilter
-  def money(input)
-    sprintf(' %d$ CAD ', input)
-  end
-end
-
-class HashOrderingTest < Minitest::Test
-  include Liquid
-
-  def test_global_register_order
-    with_global_filter(MoneyFilter, CanadianMoneyFilter) do
-      assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render(nil, nil)
-    end
-  end
-end

test/integration/parsing_quirks_test.rb

@@ -1,119 +0,0 @@
-require 'test_helper'
-
-class ParsingQuirksTest < Minitest::Test
-  include Liquid
-
-  def test_parsing_css
-    text = " div { font-weight: bold; } "
-    assert_equal text, Template.parse(text).render!
-  end
-
-  def test_raise_on_single_close_bracet
-    assert_raises(SyntaxError) do
-      Template.parse("text {{method} oh nos!")
-    end
-  end
-
-  def test_raise_on_label_and_no_close_bracets
-    assert_raises(SyntaxError) do
-      Template.parse("TEST {{ ")
-    end
-  end
-
-  def test_raise_on_label_and_no_close_bracets_percent
-    assert_raises(SyntaxError) do
-      Template.parse("TEST {% ")
-    end
-  end
-
-  def test_error_on_empty_filter
-    assert Template.parse("{{test}}")
-
-    with_error_mode(:lax) do
-      assert Template.parse("{{|test}}")
-    end
-
-    with_error_mode(:strict) do
-      assert_raises(SyntaxError) { Template.parse("{{|test}}") }
-      assert_raises(SyntaxError) { Template.parse("{{test |a|b|}}") }
-    end
-  end
-
-  def test_meaningless_parens_error
-    with_error_mode(:strict) do
-      assert_raises(SyntaxError) do
-        markup = "a == 'foo' or (b == 'bar' and c == 'baz') or false"
-        Template.parse("{% if #{markup} %} YES {% endif %}")
-      end
-    end
-  end
-
-  def test_unexpected_characters_syntax_error
-    with_error_mode(:strict) do
-      assert_raises(SyntaxError) do
-        markup = "true && false"
-        Template.parse("{% if #{markup} %} YES {% endif %}")
-      end
-      assert_raises(SyntaxError) do
-        markup = "false || true"
-        Template.parse("{% if #{markup} %} YES {% endif %}")
-      end
-    end
-  end
-
-  def test_no_error_on_lax_empty_filter
-    assert Template.parse("{{test |a|b|}}", :error_mode => :lax)
-    assert Template.parse("{{test}}", :error_mode => :lax)
-    assert Template.parse("{{|test|}}", :error_mode => :lax)
-  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
-
-  def test_raise_on_invalid_tag_delimiter
-    assert_raises(Liquid::SyntaxError) do
-      Template.new.parse('{% end %}')
-    end
-  end
-
-  def test_unanchored_filter_arguments
-    with_error_mode(:lax) do
-      assert_template_result('hi',"{{ 'hi there' | split$$$:' ' | first }}")
-
-      assert_template_result('x', "{{ 'X' | downcase) }}")
-
-      # After the messed up quotes a filter without parameters (reverse) should work
-      # but one with parameters (remove) shouldn't be detected.
-      assert_template_result('here',  "{{ 'hi there' | split:\"t\"\" | reverse | first}}")
-      assert_template_result('hi ',  "{{ 'hi there' | split:\"t\"\" | remove:\"i\" | first}}")
-    end
-  end
-
-  def test_invalid_variables_work
-    with_error_mode(:lax) do
-      assert_template_result('bar', "{% assign 123foo = 'bar' %}{{ 123foo }}")
-      assert_template_result('123', "{% assign 123 = 'bar' %}{{ 123 }}")
-    end
-  end
-
-  def test_extra_dots_in_ranges
-    with_error_mode(:lax) do
-      assert_template_result('12345', "{% for i in (1...5) %}{{ i }}{% endfor %}")
-    end
-  end
-
-end # ParsingQuirksTest

test/integration/render_profiling_test.rb

@@ -1,154 +0,0 @@
-require 'test_helper'
-
-class RenderProfilingTest < Minitest::Test
-  include Liquid
-
-  class ProfilingFileSystem
-    def read_template_file(template_path)
-      "Rendering template {% assign template_name = '#{template_path}'%}\n{{ template_name }}"
-    end
-  end
-
-  def setup
-    Liquid::Template.file_system = ProfilingFileSystem.new
-  end
-
-  def test_template_allows_flagging_profiling
-    t = Template.parse("{{ 'a string' | upcase }}")
-    t.render!
-
-    assert_nil t.profiler
-  end
-
-  def test_parse_makes_available_simple_profiling
-    t = Template.parse("{{ 'a string' | upcase }}", :profile => true)
-    t.render!
-
-    assert_equal 1, t.profiler.length
-
-    node = t.profiler[0]
-    assert_equal " 'a string' | upcase ", node.code
-  end
-
-  def test_render_ignores_raw_strings_when_profiling
-    t = Template.parse("This is raw string\nstuff\nNewline", :profile => true)
-    t.render!
-
-    assert_equal 0, t.profiler.length
-  end
-
-  def test_profiling_includes_line_numbers_of_liquid_nodes
-    t = Template.parse("{{ 'a string' | upcase }}\n{% increment test %}", :profile => true)
-    t.render!
-    assert_equal 2, t.profiler.length
-
-    # {{ 'a string' | upcase }}
-    assert_equal 1, t.profiler[0].line_number
-    # {{ increment test }}
-    assert_equal 2, t.profiler[1].line_number
-  end
-
-  def test_profiling_includes_line_numbers_of_included_partials
-    t = Template.parse("{% include 'a_template' %}", :profile => true)
-    t.render!
-
-    included_children = t.profiler[0].children
-
-    # {% assign template_name = 'a_template' %}
-    assert_equal 1, included_children[0].line_number
-    # {{ template_name }}
-    assert_equal 2, included_children[1].line_number
-  end
-
-  def test_profiling_times_the_rendering_of_tokens
-    t = Template.parse("{% include 'a_template' %}", :profile => true)
-    t.render!
-
-    node = t.profiler[0]
-    refute_nil node.render_time
-  end
-
-  def test_profiling_times_the_entire_render
-    t = Template.parse("{% include 'a_template' %}", :profile => true)
-    t.render!
-
-    assert t.profiler.total_render_time >= 0, "Total render time was not calculated"
-  end
-
-  def test_profiling_uses_include_to_mark_children
-    t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}", :profile => true)
-    t.render!
-
-    include_node = t.profiler[1]
-    assert_equal 2, include_node.children.length
-  end
-
-  def test_profiling_marks_children_with_the_name_of_included_partial
-    t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}", :profile => true)
-    t.render!
-
-    include_node = t.profiler[1]
-    include_node.children.each do |child|
-      assert_equal "a_template", child.partial
-    end
-  end
-
-  def test_profiling_supports_multiple_templates
-    t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}\n{% include 'b_template' %}", :profile => true)
-    t.render!
-
-    a_template = t.profiler[1]
-    a_template.children.each do |child|
-      assert_equal "a_template", child.partial
-    end
-
-    b_template = t.profiler[2]
-    b_template.children.each do |child|
-      assert_equal "b_template", child.partial
-    end
-  end
-
-  def test_profiling_supports_rendering_the_same_partial_multiple_times
-    t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}\n{% include 'a_template' %}", :profile => true)
-    t.render!
-
-    a_template1 = t.profiler[1]
-    a_template1.children.each do |child|
-      assert_equal "a_template", child.partial
-    end
-
-    a_template2 = t.profiler[2]
-    a_template2.children.each do |child|
-      assert_equal "a_template", child.partial
-    end
-  end
-
-  def test_can_iterate_over_each_profiling_entry
-    t = Template.parse("{{ 'a string' | upcase }}\n{% increment test %}", :profile => true)
-    t.render!
-
-    timing_count = 0
-    t.profiler.each do |timing|
-      timing_count += 1
-    end
-
-    assert_equal 2, timing_count
-  end
-
-  def test_profiling_marks_children_of_if_blocks
-    t = Template.parse("{% if true %} {% increment test %} {{ test }} {% endif %}", :profile => true)
-    t.render!
-
-    assert_equal 1, t.profiler.length
-    assert_equal 2, t.profiler[0].children.length
-  end
-
-  def test_profiling_marks_children_of_for_blocks
-    t = Template.parse("{% for item in collection %} {{ item }} {% endfor %}", :profile => true)
-    t.render!({"collection" => ["one", "two"]})
-
-    assert_equal 1, t.profiler.length
-    # Will profile each invocation of the for block
-    assert_equal 2, t.profiler[0].children.length
-  end
-end

test/integration/tags/include_tag_test.rb

@@ -1,230 +0,0 @@
-require 'test_helper'
-
-class TestFileSystem
-  def read_template_file(template_path)
-    case template_path
-    when "product"
-      "Product: {{ product.title }} "
-
-    when "locale_variables"
-      "Locale: {{echo1}} {{echo2}}"
-
-    when "variant"
-      "Variant: {{ variant.title }}"
-
-    when "nested_template"
-      "{% include 'header' %} {% include 'body' %} {% include 'footer' %}"
-
-    when "body"
-      "body {% include 'body_detail' %}"
-
-    when "nested_product_template"
-      "Product: {{ nested_product_template.title }} {%include 'details'%} "
-
-    when "recursively_nested_template"
-      "-{% include 'recursively_nested_template' %}"
-
-    when "pick_a_source"
-      "from TestFileSystem"
-
-    when 'assignments'
-      "{% assign foo = 'bar' %}"
-
-    else
-      template_path
-    end
-  end
-end
-
-class OtherFileSystem
-  def read_template_file(template_path)
-    'from OtherFileSystem'
-  end
-end
-
-class CountingFileSystem
-  attr_reader :count
-  def read_template_file(template_path)
-    @count ||= 0
-    @count += 1
-    'from 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 render(context)
-    @template_name[1..-2]
-  end
-end
-
-class IncludeTagTest < Minitest::Test
-  include Liquid
-
-  def setup
-    Liquid::Template.file_system = TestFileSystem.new
-  end
-
-  def test_include_tag_looks_for_file_system_in_registers_first
-    assert_equal 'from OtherFileSystem',
-      Template.parse("{% include 'pick_a_source' %}").render!({}, :registers => {:file_system => OtherFileSystem.new})
-  end
-
-
-  def test_include_tag_with
-    assert_template_result "Product: Draft 151cm ",
-      "{% include 'product' with products[0] %}", "products" => [ {'title' => 'Draft 151cm'}, {'title' => 'Element 155cm'} ]
-  end
-
-  def test_include_tag_with_default_name
-    assert_template_result "Product: Draft 151cm ",
-      "{% include 'product' %}", "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'} ]
-  end
-
-  def test_include_tag_with_local_variables
-    assert_template_result "Locale: test123 ", "{% include 'locale_variables' echo1: 'test123' %}"
-  end
-
-  def test_include_tag_with_multiple_local_variables
-    assert_template_result "Locale: test123 test321",
-      "{% include 'locale_variables' echo1: 'test123', echo2: 'test321' %}"
-  end
-
-  def test_include_tag_with_multiple_local_variables_from_context
-    assert_template_result "Locale: test123 test321",
-      "{% include 'locale_variables' echo1: echo1, echo2: more_echos.echo2 %}",
-      'echo1' => 'test123', 'more_echos' => { "echo2" => 'test321'}
-  end
-
-  def test_included_templates_assigns_variables
-    assert_template_result "bar", "{% include 'assignments' %}{{ foo }}"
-  end
-
-  def test_nested_include_tag
-    assert_template_result "body body_detail", "{% include 'body' %}"
-
-    assert_template_result "header body body_detail footer", "{% include 'nested_template' %}"
-  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 ",
-      "{% include 'nested_product_template' for products %}", "products" => [{"title" => 'Draft 151cm'}, {"title" => 'Element 155cm'}]
-  end
-
-  def test_recursively_included_template_does_not_produce_endless_loop
-
-    infinite_file_system = Class.new do
-      def read_template_file(template_path)
-        "-{% include 'loop' %}"
-      end
-    end
-
-    Liquid::Template.file_system = infinite_file_system.new
-
-    assert_raises(Liquid::StackLevelError, SystemStackError) do
-      Template.parse("{% include 'loop' %}").render!
-    end
-
-  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 %}",
-      "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})
-    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})
-    assert_equal 1, file_system.count
-
-    assert_equal 'from CountingFileSystem',
-      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
-
-  def test_does_not_add_error_in_strict_mode_for_missing_variable
-    Liquid::Template.file_system = TestFileSystem.new
-
-    a = Liquid::Template.parse(' {% include "nested_template" %}')
-    a.render!
-    assert_empty a.errors
-  end
-
-  def test_passing_options_to_included_templates
-    assert_raises(Liquid::SyntaxError) do
-      Template.parse("{% include template %}", error_mode: :strict).render!("template" => '{{ "X" || downcase }}')
-    end
-    with_error_mode(:lax) do
-      assert_equal 'x', Template.parse("{% include template %}", error_mode: :strict, include_options_blacklist: true).render!("template" => '{{ "X" || downcase }}')
-    end
-    assert_raises(Liquid::SyntaxError) do
-      Template.parse("{% include template %}", error_mode: :strict, include_options_blacklist: [:locale]).render!("template" => '{{ "X" || downcase }}')
-    end
-    with_error_mode(:lax) do
-      assert_equal 'x', Template.parse("{% include template %}", error_mode: :strict, include_options_blacklist: [:error_mode]).render!("template" => '{{ "X" || downcase }}')
-    end
-  end
-
-  def test_including_via_variable_value
-    assert_template_result "from TestFileSystem", "{% assign page = 'pick_a_source' %}{% include page %}"
-
-    assert_template_result "Product: Draft 151cm ", "{% assign page = 'product' %}{% include page %}", "product" => {'title' => 'Draft 151cm'}
-
-    assert_template_result "Product: Draft 151cm ", "{% assign page = 'product' %}{% include page for foo %}", "foo" => {'title' => 'Draft 151cm'}
-  end
-end # IncludeTagTest

test/integration/tags/statements_test.rb

@@ -1,113 +0,0 @@
-require 'test_helper'
-
-class StatementsTest < Minitest::Test
-  include Liquid
-
-  def test_true_eql_true
-    text = ' {% if true == true %} true {% else %} false {% endif %} '
-    assert_template_result '  true  ', text
-  end
-
-  def test_true_not_eql_true
-    text = ' {% if true != true %} true {% else %} false {% endif %} '
-    assert_template_result '  false  ', text
-  end
-
-  def test_true_lq_true
-    text = ' {% if 0 > 0 %} true {% else %} false {% endif %} '
-    assert_template_result '  false  ', text
-  end
-
-  def test_one_lq_zero
-    text = ' {% if 1 > 0 %} true {% else %} false {% endif %} '
-    assert_template_result '  true  ', text
-  end
-
-  def test_zero_lq_one
-    text = ' {% if 0 < 1 %} true {% else %} false {% endif %} '
-    assert_template_result '  true  ', text
-  end
-
-  def test_zero_lq_or_equal_one
-    text = ' {% if 0 <= 0 %} true {% else %} false {% endif %} '
-    assert_template_result '  true  ', text
-  end
-
-  def test_zero_lq_or_equal_one_involving_nil
-    text = ' {% if null <= 0 %} true {% else %} false {% endif %} '
-    assert_template_result '  false  ', text
-
-
-    text = ' {% if 0 <= null %} true {% else %} false {% endif %} '
-    assert_template_result '  false  ', text
-  end
-
-  def test_zero_lqq_or_equal_one
-    text = ' {% if 0 >= 0 %} true {% else %} false {% endif %} '
-    assert_template_result '  true  ', text
-  end
-
-  def test_strings
-    text = " {% if 'test' == 'test' %} true {% else %} false {% endif %} "
-    assert_template_result '  true  ', text
-  end
-
-  def test_strings_not_equal
-    text = " {% if 'test' != 'test' %} true {% else %} false {% endif %} "
-    assert_template_result '  false  ', text
-  end
-
-  def test_var_strings_equal
-    text = ' {% if var == "hello there!" %} true {% else %} false {% endif %} '
-    assert_template_result '  true  ', text, 'var' => 'hello there!'
-  end
-
-  def test_var_strings_are_not_equal
-    text = ' {% if "hello there!" == var %} true {% else %} false {% endif %} '
-    assert_template_result '  true  ', text, 'var' => 'hello there!'
-  end
-
-  def test_var_and_long_string_are_equal
-    text = " {% if var == 'hello there!' %} true {% else %} false {% endif %} "
-    assert_template_result '  true  ', text, 'var' => 'hello there!'
-  end
-
-
-  def test_var_and_long_string_are_equal_backwards
-    text = " {% if 'hello there!' == var %} true {% else %} false {% endif %} "
-    assert_template_result '  true  ', text, 'var' => 'hello there!'
-  end
-
-  #def test_is_nil
-  #  text = %| {% if var != nil %} true {% else %} false {% end %} |
-  #  @template.assigns = { 'var' => 'hello there!'}
-  #  expected = %|  true  |
-  #  assert_equal expected, @template.parse(text)
-  #end
-
-  def test_is_collection_empty
-    text = ' {% if array == empty %} true {% else %} false {% endif %} '
-    assert_template_result '  true  ', text, 'array' => []
-  end
-
-  def test_is_not_collection_empty
-    text = ' {% if array == empty %} true {% else %} false {% endif %} '
-    assert_template_result '  false  ', text, 'array' => [1,2,3]
-  end
-
-  def test_nil
-    text = ' {% if var == nil %} true {% else %} false {% endif %} '
-    assert_template_result '  true  ', text, 'var' => nil
-
-    text = ' {% if var == null %} true {% else %} false {% endif %} '
-    assert_template_result '  true  ', text, 'var' => nil
-  end
-
-  def test_not_nil
-    text = ' {% if var != nil %} true {% else %} false {% endif %} '
-    assert_template_result '  true  ', text, 'var' => 1
-
-    text = ' {% if var != null %} true {% else %} false {% endif %} '
-    assert_template_result '  true  ', text, 'var' => 1
-  end
-end # StatementsTest

test/integration/template_test.rb

@@ -1,216 +0,0 @@
-require 'test_helper'
-require 'timeout'
-
-class TemplateContextDrop < Liquid::Drop
-  def before_method(method)
-    method
-  end
-
-  def foo
-    'fizzbuzz'
-  end
-
-  def baz
-    @context.registers['lulz']
-  end
-end
-
-class SomethingWithLength
-  def length
-    nil
-  end
-
-  liquid_methods :length
-end
-
-class ErroneousDrop < Liquid::Drop
-  def bad_method
-    raise 'ruby error in drop'
-  end
-end
-
-class TemplateTest < Minitest::Test
-  include Liquid
-
-  def test_instance_assigns_persist_on_same_template_object_between_parses
-    t = Template.new
-    assert_equal 'from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render!
-    assert_equal 'from instance assigns', t.parse("{{ foo }}").render!
-  end
-
-  def test_warnings_is_not_exponential_time
-    str = "false"
-    100.times do
-      str = "{% if true %}true{% else %}#{str}{% endif %}"
-    end
-
-    t = Template.parse(str)
-    assert_equal [], Timeout::timeout(1) { t.warnings }
-  end
-
-  def test_instance_assigns_persist_on_same_template_parsing_between_renders
-    t = Template.new.parse("{{ foo }}{% assign foo = 'foo' %}{{ foo }}")
-    assert_equal 'foo', t.render!
-    assert_equal 'foofoo', t.render!
-  end
-
-  def test_custom_assigns_do_not_persist_on_same_template
-    t = Template.new
-    assert_equal 'from custom assigns', t.parse("{{ foo }}").render!('foo' => 'from custom assigns')
-    assert_equal '', t.parse("{{ foo }}").render!
-  end
-
-  def test_custom_assigns_squash_instance_assigns
-    t = Template.new
-    assert_equal 'from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render!
-    assert_equal 'from custom assigns', t.parse("{{ foo }}").render!('foo' => 'from custom assigns')
-  end
-
-  def test_persistent_assigns_squash_instance_assigns
-    t = Template.new
-    assert_equal 'from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render!
-    t.assigns['foo'] = 'from persistent assigns'
-    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.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.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!()
-    refute_nil t.resource_limits.render_length
-  end
-
-  def test_resource_limits_render_score
-    t = Template.parse("{% for a in (1..10) %} {% for a in (1..10) %} foo {% endfor %} {% endfor %}")
-    t.resource_limits.render_score_limit = 50
-    assert_equal "Liquid error: Memory limits exceeded", t.render()
-    assert t.resource_limits.reached?
-
-    t = Template.parse("{% for a in (1..100) %} foo {% endfor %}")
-    t.resource_limits.render_score_limit = 50
-    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!()
-    refute_nil t.resource_limits.render_score
-  end
-
-  def test_resource_limits_assign_score
-    t = Template.parse("{% assign foo = 42 %}{% assign bar = 23 %}")
-    t.resource_limits.assign_score_limit = 1
-    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!()
-    refute_nil t.resource_limits.assign_score
-  end
-
-  def test_resource_limits_aborts_rendering_after_first_error
-    t = Template.parse("{% for a in (1..100) %} foo1 {% endfor %} bar {% for a in (1..100) %} foo2 {% endfor %}")
-    t.resource_limits.render_score_limit = 50
-    assert_equal "Liquid error: Memory limits exceeded", t.render()
-    assert t.resource_limits.reached?
-  end
-
-  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!()
-    assert t.resource_limits.assign_score > 0
-    assert t.resource_limits.render_score > 0
-    assert t.resource_limits.render_length > 0
-  end
-
-  def test_render_length_persists_between_blocks
-    t = Template.parse("{% if true %}aaaa{% endif %}")
-    t.resource_limits.render_length_limit = 7
-    assert_equal "Liquid error: Memory limits exceeded", t.render()
-    t.resource_limits.render_length_limit = 8
-    assert_equal "aaaa", t.render()
-
-    t = Template.parse("{% if true %}aaaa{% endif %}{% if true %}bbb{% endif %}")
-    t.resource_limits.render_length_limit = 13
-    assert_equal "Liquid error: Memory limits exceeded", t.render()
-    t.resource_limits.render_length_limit = 14
-    assert_equal "aaaabbb", t.render()
-
-    t = Template.parse("{% if true %}a{% endif %}{% if true %}b{% endif %}{% if true %}a{% endif %}{% if true %}b{% endif %}{% if true %}a{% endif %}{% if true %}b{% endif %}")
-    t.resource_limits.render_length_limit = 5
-    assert_equal "Liquid error: Memory limits exceeded", t.render()
-    t.resource_limits.render_length_limit = 11
-    assert_equal "Liquid error: Memory limits exceeded", t.render()
-    t.resource_limits.render_length_limit = 12
-    assert_equal "ababab", t.render()
-  end
-
-  def test_default_resource_limits_unaffected_by_render_with_context
-    context = Context.new
-    t = Template.parse("{% for a in (1..100) %} {% assign foo = 1 %} {% endfor %}")
-    t.render!(context)
-    assert context.resource_limits.assign_score > 0
-    assert context.resource_limits.render_score > 0
-    assert context.resource_limits.render_length > 0
-  end
-
-  def test_can_use_drop_as_context
-    t = Template.new
-    t.registers['lulz'] = 'haha'
-    drop = TemplateContextDrop.new
-    assert_equal 'fizzbuzz', t.parse('{{foo}}').render!(drop)
-    assert_equal 'bar', t.parse('{{bar}}').render!(drop)
-    assert_equal 'haha', t.parse("{{baz}}").render!(drop)
-  end
-
-  def test_render_bang_force_rethrow_errors_on_passed_context
-    context = Context.new({'drop' => ErroneousDrop.new})
-    t = Template.new.parse('{{ drop.bad_method }}')
-
-    e = assert_raises RuntimeError do
-      t.render!(context)
-    end
-    assert_equal 'ruby error in drop', e.message
-  end
-
-  def test_exception_handler_doesnt_reraise_if_it_returns_false
-    exception = nil
-    Template.parse("{{ 1 | divided_by: 0 }}").render({}, exception_handler: ->(e) { exception = e; false })
-    assert exception.is_a?(ZeroDivisionError)
-  end
-
-  def test_exception_handler_does_reraise_if_it_returns_true
-    exception = nil
-    assert_raises(ZeroDivisionError) do
-      Template.parse("{{ 1 | divided_by: 0 }}").render({}, exception_handler: ->(e) { exception = e; true })
-    end
-    assert exception.is_a?(ZeroDivisionError)
-  end
-end

test/integration/variable_test.rb

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

test/liquid/assign_test.rb

@@ -1,18 +1,8 @@
 require 'test_helper'
 
-class AssignTest < Minitest::Test
+class AssignTest < Test::Unit::TestCase
   include Liquid
 
-  def test_assign_with_hyphen_in_variable_name
-    template_source = <<-END_TEMPLATE
-    {% assign this-thing = 'Print this-thing' %}
-    {{ this-thing }}
-    END_TEMPLATE
-    template = Template.parse(template_source)
-    rendered = template.render!
-    assert_equal "Print this-thing", rendered.strip
-  end
-
   def test_assigned_variable
     assert_template_result('.foo.',
                            '{% assign foo = values %}.{{ foo[0] }}.',
@@ -34,15 +24,4 @@ class AssignTest < Minitest::Test
                        '{% assign foo not values %}.',
                        'values' => "foo,bar,baz")
   end
-
-  def test_assign_uses_error_mode
-    with_error_mode(:strict) do
-      assert_raises(SyntaxError) do
-        Template.parse("{% assign foo = ('X' | downcase) %}")
-      end
-    end
-    with_error_mode(:lax) do
-      assert Template.parse("{% assign foo = ('X' | downcase) %}")
-    end
-  end
 end # AssignTest

test/liquid/blank_test.rb

@@ -9,12 +9,12 @@ class FoobarTag < Liquid::Tag
 end
 
 class BlankTestFileSystem
-  def read_template_file(template_path)
+  def read_template_file(template_path, context)
     template_path
   end
 end
 
-class BlankTest < Minitest::Test
+class BlankTest < Test::Unit::TestCase
   include Liquid
   N = 10
 
@@ -93,9 +93,9 @@ class BlankTest < Minitest::Test
 
   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 ' ' %} ")
+    assert_equal "foobar"*(N+1), Template.parse(wrap("{% include 'foobar' %}")).render()
+    assert_equal " foobar "*(N+1), Template.parse(wrap("{% include ' foobar ' %}")).render()
+    assert_equal "   ", Template.parse(" {% include ' ' %} ").render()
   end
 
   def test_case_is_blank

test/liquid/block_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class BlockUnitTest < Minitest::Test
+class BlockTest < Test::Unit::TestCase
   include Liquid
 
   def test_blankspace
@@ -12,40 +12,43 @@ class BlockUnitTest < Minitest::Test
     template = Liquid::Template.parse("{{funk}}  ")
     assert_equal 2, template.root.nodelist.size
     assert_equal Variable, template.root.nodelist[0].class
-    assert_equal String, template.root.nodelist[1].class
+    assert_equal StringSlice, template.root.nodelist[1].class
   end
 
   def test_variable_end
     template = Liquid::Template.parse("  {{funk}}")
     assert_equal 2, template.root.nodelist.size
-    assert_equal String, template.root.nodelist[0].class
+    assert_equal StringSlice, template.root.nodelist[0].class
     assert_equal Variable, template.root.nodelist[1].class
   end
 
   def test_variable_middle
     template = Liquid::Template.parse("  {{funk}}  ")
     assert_equal 3, template.root.nodelist.size
-    assert_equal String, template.root.nodelist[0].class
+    assert_equal StringSlice, template.root.nodelist[0].class
     assert_equal Variable, template.root.nodelist[1].class
-    assert_equal String, template.root.nodelist[2].class
+    assert_equal StringSlice, template.root.nodelist[2].class
   end
 
   def test_variable_many_embedded_fragments
     template = Liquid::Template.parse("  {{funk}} {{so}} {{brother}} ")
     assert_equal 7, template.root.nodelist.size
-    assert_equal [String, Variable, String, Variable, String, Variable, String],
+    assert_equal [StringSlice, Variable, StringSlice, Variable, StringSlice, Variable, StringSlice],
                  block_types(template.root.nodelist)
   end
 
   def test_with_block
     template = Liquid::Template.parse("  {% comment %} {% endcomment %} ")
-    assert_equal [String, Comment, String], block_types(template.root.nodelist)
+    assert_equal [StringSlice, Comment, StringSlice], block_types(template.root.nodelist)
     assert_equal 3, template.root.nodelist.size
   end
 
   def test_with_custom_tag
     Liquid::Template.register_tag("testtag", Block)
-    assert Liquid::Template.parse( "{% testtag %} {% endtesttag %}")
+
+    assert_nothing_thrown do
+      template = Liquid::Template.parse( "{% testtag %} {% endtesttag %}")
+    end
   end
 
   private

test/liquid/capture_test.rb

@@ -1,22 +1,12 @@
 require 'test_helper'
 
-class CaptureTest < Minitest::Test
+class CaptureTest < Test::Unit::TestCase
   include Liquid
 
   def test_captures_block_content_in_variable
     assert_template_result("test string", "{% capture 'var' %}test string{% endcapture %}{{var}}", {})
   end
 
-  def test_capture_with_hyphen_in_variable_name
-    template_source = <<-END_TEMPLATE
-    {% capture this-thing %}Print this-thing{% endcapture %}
-    {{ this-thing }}
-    END_TEMPLATE
-    template = Template.parse(template_source)
-    rendered = template.render!
-    assert_equal "Print this-thing", rendered.strip
-  end
-
   def test_capture_to_variable_from_outer_scope_if_existing
     template_source = <<-END_TEMPLATE
     {% assign var = '' %}
@@ -29,7 +19,7 @@ class CaptureTest < Minitest::Test
     {{var}}
     END_TEMPLATE
     template = Template.parse(template_source)
-    rendered = template.render!
+    rendered = template.render
     assert_equal "test-string", rendered.gsub(/\s/, '')
   end
 
@@ -44,7 +34,7 @@ class CaptureTest < Minitest::Test
     {{ 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/condition_test.rb

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

test/liquid/context_test.rb

@@ -63,17 +63,13 @@ class ArrayLike
   end
 end
 
-class ContextUnitTest < Minitest::Test
+class ContextTest < Test::Unit::TestCase
   include Liquid
 
   def setup
     @context = Liquid::Context.new
   end
 
-  def teardown
-    Spy.teardown
-  end
-
   def test_variables
     @context['string'] = 'string'
     assert_equal 'string', @context['string']
@@ -107,14 +103,16 @@ class ContextUnitTest < Minitest::Test
   end
 
   def test_scoping
-    @context.push
-    @context.pop
-
-    assert_raises(Liquid::ContextError) do
+    assert_nothing_raised do
+      @context.push
       @context.pop
     end
 
-    assert_raises(Liquid::ContextError) do
+    assert_raise(Liquid::ContextError) do
+      @context.pop
+    end
+
+    assert_raise(Liquid::ContextError) do
       @context.push
       @context.pop
       @context.pop
@@ -164,6 +162,24 @@ class ContextUnitTest < Minitest::Test
 
   end
 
+  def test_override_global_filter
+    global = Module.new do
+      def notice(output)
+        "Global #{output}"
+      end
+    end
+
+    local = Module.new do
+      def notice(output)
+        "Local #{output}"
+      end
+    end
+
+    Template.register_filter(global)
+    assert_equal 'Global test', Template.parse("{{'test' | notice }}").render
+    assert_equal 'Local test', Template.parse("{{'test' | notice }}").render({}, :filters => [local])
+  end
+
   def test_only_intended_filters_make_it_there
 
     filter = Module.new do
@@ -459,24 +475,4 @@ class ContextUnitTest < Minitest::Test
     assert_kind_of CategoryDrop, @context['category']
     assert_equal @context, @context['category'].context
   end
-
-  def test_use_empty_instead_of_any_in_interrupt_handling_to_avoid_lots_of_unnecessary_object_allocations
-    mock_any = Spy.on_instance_method(Array, :any?)
-    mock_empty = Spy.on_instance_method(Array, :empty?)
-    mock_has_interrupt = Spy.on(@context, :has_interrupt?).and_call_through
-
-    @context.has_interrupt?
-
-    refute mock_any.has_been_called?
-    assert mock_empty.has_been_called?
-  end
-
-  def test_context_initialization_with_a_proc_in_environment
-    contx = Context.new([:test => lambda { |c| c['poutine']}], {:test => :foo})
-
-    assert contx
-    assert_nil contx['poutine']
-  end
-
-
 end # ContextTest

test/liquid/drop_test.rb

@@ -48,10 +48,6 @@ class ProductDrop < Liquid::Drop
     ContextDrop.new
   end
 
-  def user_input
-    "foo".taint
-  end
-
   protected
     def callmenot
       "protected"
@@ -104,168 +100,146 @@ class RealEnumerableDrop < Liquid::Drop
   end
 end
 
-class DropsTest < Minitest::Test
+class DropsTest < Test::Unit::TestCase
   include Liquid
 
   def test_product_drop
-    tpl = Liquid::Template.parse('  ')
-    assert_equal '  ', tpl.render!('product' => ProductDrop.new)
-  end
-
-  def test_rendering_raises_on_tainted_attr
-    with_taint_mode(:error) do
-      tpl = Liquid::Template.parse('{{ product.user_input }}')
-      assert_raises TaintedError do
-        tpl.render!('product' => ProductDrop.new)
-      end
-    end
-  end
-
-  def test_rendering_warns_on_tainted_attr
-    with_taint_mode(:warn) do
-      tpl = Liquid::Template.parse('{{ product.user_input }}')
-      tpl.render!('product' => ProductDrop.new)
-      assert_match /tainted/, tpl.warnings.first
-    end
-  end
-
-  def test_rendering_doesnt_raise_on_escaped_tainted_attr
-    with_taint_mode(:error) do
-      tpl = Liquid::Template.parse('{{ product.user_input | escape }}')
-      tpl.render!('product' => ProductDrop.new)
+    assert_nothing_raised do
+      tpl = Liquid::Template.parse( '  '  )
+      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.pretty_inspect }}").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: "pretty_inspect" }}').render!('product' => ProductDrop.new)
-    assert_equal "", Liquid::Template.parse('{{ product | map: "whatever" }}').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.whatever }}").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: "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 | map: "to_liquid" | map: "texts" | map: "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)
   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 '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 '1', Liquid::Template.parse( '{{ context.scopes }}'  ).render('context' => ContextDrop.new)
+    assert_equal '2', Liquid::Template.parse( '{%for i in dummy%}{{ context.scopes }}{%endfor%}'  ).render('context' => ContextDrop.new, 'dummy' => [1])
+    assert_equal '3', Liquid::Template.parse( '{%for i in dummy%}{%for i in dummy%}{{ context.scopes }}{%endfor%}{%endfor%}'  ).render('context' => ContextDrop.new, 'dummy' => [1])
   end
 
   def test_scope_though_proc
-    assert_equal '1', Liquid::Template.parse( '{{ s }}'  ).render!('context' => ContextDrop.new, 's' => Proc.new{|c| c['context.scopes'] })
-    assert_equal '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 '1', Liquid::Template.parse( '{{ s }}'  ).render('context' => ContextDrop.new, 's' => Proc.new{|c| c['context.scopes'] })
+    assert_equal '2', Liquid::Template.parse( '{%for i in dummy%}{{ s }}{%endfor%}'  ).render('context' => ContextDrop.new, 's' => Proc.new{|c| c['context.scopes'] }, 'dummy' => [1])
+    assert_equal '3', Liquid::Template.parse( '{%for i in dummy%}{%for i in dummy%}{{ s }}{%endfor%}{%endfor%}'  ).render('context' => ContextDrop.new, 's' => Proc.new{|c| c['context.scopes'] }, 'dummy' => [1])
   end
 
   def test_scope_with_assigns
-    assert_equal 'variable', Liquid::Template.parse( '{% assign a = "variable"%}{{a}}'  ).render!('context' => ContextDrop.new)
-    assert_equal 'variable', Liquid::Template.parse( '{% assign a = "variable"%}{%for i in dummy%}{{a}}{%endfor%}'  ).render!('context' => ContextDrop.new, 'dummy' => [1])
-    assert_equal 'test', Liquid::Template.parse( '{% assign header_gif = "test"%}{{header_gif}}'  ).render!('context' => ContextDrop.new)
-    assert_equal 'test', Liquid::Template.parse( "{% assign header_gif = 'test'%}{{header_gif}}"  ).render!('context' => ContextDrop.new)
+    assert_equal 'variable', Liquid::Template.parse( '{% assign a = "variable"%}{{a}}'  ).render('context' => ContextDrop.new)
+    assert_equal 'variable', Liquid::Template.parse( '{% assign a = "variable"%}{%for i in dummy%}{{a}}{%endfor%}'  ).render('context' => ContextDrop.new, 'dummy' => [1])
+    assert_equal 'test', Liquid::Template.parse( '{% assign header_gif = "test"%}{{header_gif}}'  ).render('context' => ContextDrop.new)
+    assert_equal 'test', Liquid::Template.parse( "{% assign header_gif = 'test'%}{{header_gif}}"  ).render('context' => ContextDrop.new)
   end
 
   def test_scope_from_tags
-    assert_equal '1', Liquid::Template.parse( '{% for i in context.scopes_as_array %}{{i}}{% endfor %}'  ).render!('context' => ContextDrop.new, 'dummy' => [1])
-    assert_equal '12', Liquid::Template.parse( '{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}'  ).render!('context' => ContextDrop.new, 'dummy' => [1])
-    assert_equal '123', Liquid::Template.parse( '{%for a in dummy%}{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}{% endfor %}'  ).render!('context' => ContextDrop.new, 'dummy' => [1])
+    assert_equal '1', Liquid::Template.parse( '{% for i in context.scopes_as_array %}{{i}}{% endfor %}'  ).render('context' => ContextDrop.new, 'dummy' => [1])
+    assert_equal '12', Liquid::Template.parse( '{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}'  ).render('context' => ContextDrop.new, 'dummy' => [1])
+    assert_equal '123', Liquid::Template.parse( '{%for a in dummy%}{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}{% endfor %}'  ).render('context' => ContextDrop.new, 'dummy' => [1])
   end
 
   def test_access_context_from_drop
-    assert_equal '123', Liquid::Template.parse( '{%for a in dummy%}{{ context.loop_pos }}{% endfor %}'  ).render!('context' => ContextDrop.new, 'dummy' => [1,2,3])
+    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)
+      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)
+      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)
+    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)
+      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)
+    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

@@ -0,0 +1,110 @@
+require 'test_helper'
+
+class ErrorDrop < Liquid::Drop
+  def standard_error
+    raise Liquid::StandardError, 'standard error'
+  end
+
+  def argument_error
+    raise Liquid::ArgumentError, 'argument error'
+  end
+
+  def syntax_error
+    raise Liquid::SyntaxError, 'syntax error'
+  end
+
+  def exception
+    raise Exception, 'exception'
+  end
+
+end
+
+class ErrorHandlingTest < Test::Unit::TestCase
+  include Liquid
+
+  def test_standard_error
+    assert_nothing_raised do
+      template = Liquid::Template.parse( ' {{ errors.standard_error }} '  )
+      assert_equal ' Liquid error: standard error ', template.render('errors' => ErrorDrop.new)
+
+      assert_equal 1, template.errors.size
+      assert_equal StandardError, template.errors.first.class
+    end
+  end
+
+  def test_syntax
+
+    assert_nothing_raised do
+
+      template = Liquid::Template.parse( ' {{ errors.syntax_error }} '  )
+      assert_equal ' Liquid syntax error: syntax error ', template.render('errors' => ErrorDrop.new)
+
+      assert_equal 1, template.errors.size
+      assert_equal SyntaxError, template.errors.first.class
+
+    end
+  end
+
+  def test_argument
+    assert_nothing_raised do
+
+      template = Liquid::Template.parse( ' {{ errors.argument_error }} '  )
+      assert_equal ' Liquid error: argument error ', template.render('errors' => ErrorDrop.new)
+
+      assert_equal 1, template.errors.size
+      assert_equal ArgumentError, template.errors.first.class
+    end
+  end
+
+  def test_missing_endtag_parse_time_error
+    assert_raise(Liquid::SyntaxError) do
+      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)
+      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
+      template = Liquid::Template.parse( ' {{ errors.exception }} '  )
+      template.render('errors' => ErrorDrop.new)
+    end
+  end
+end # ErrorHandlingTest

test/liquid/file_system_test.rb

@@ -1,11 +1,11 @@
 require 'test_helper'
 
-class FileSystemUnitTest < Minitest::Test
+class FileSystemTest < Test::Unit::TestCase
   include Liquid
 
   def test_default
-    assert_raises(FileSystemError) do
-      BlankFileSystem.new.read_template_file("dummy")
+    assert_raise(FileSystemError) do
+      BlankFileSystem.new.read_template_file("dummy", {'dummy'=>'smarty'})
     end
   end
 
@@ -14,15 +14,15 @@ class FileSystemUnitTest < Minitest::Test
     assert_equal "/some/path/_mypartial.liquid"    , file_system.full_path("mypartial")
     assert_equal "/some/path/dir/_mypartial.liquid", file_system.full_path("dir/mypartial")
 
-    assert_raises(FileSystemError) do
+    assert_raise(FileSystemError) do
       file_system.full_path("../dir/mypartial")
     end
 
-    assert_raises(FileSystemError) do
+    assert_raise(FileSystemError) do
       file_system.full_path("/dir/../../dir/mypartial")
     end
 
-    assert_raises(FileSystemError) do
+    assert_raise(FileSystemError) do
       file_system.full_path("/etc/passwd")
     end
   end