Also dump object distribution

Removed context from read_template_file, fixed tests to match new arity

.gitignore

@@ -4,3 +4,5 @@
 pkg
 *.rbc
 .rvmrc
+.ruby-version
+Gemfile.lock

.travis.yml

@@ -1,11 +1,18 @@
+language: ruby
+
 rvm:
-  - 1.8.7
+  - 2.0
-  - 1.9.3
+  - 2.1
-  - ree
+  - 2.2
-  - jruby-18mode
+  - ruby-head
-  - jruby-19mode
+  - jruby-head
-  - rbx-18mode
+  - rbx-2
-  - rbx-19mode
+
+sudo: false
+
+matrix:
+  allow_failures:
+    - rvm: jruby-head
 
 script: "rake test"
 

CONTRIBUTING.md

@@ -0,0 +1,26 @@
+# How to contribute
+
+## Things we will merge
+
+* Bugfixes
+* Performance improvements
+* Features which are likely to be useful to the majority of Liquid users
+
+## Things we won't merge
+
+* Code which introduces considerable performance degrations
+* Code which touches performance critical parts of Liquid and comes without benchmarks
+* Features which are not important for most people (we want to keep the core Liquid code small and tidy)
+* Features which can easily be implemented on top of Liquid (for example as a custom filter or custom filesystem)
+* Code which comes without tests
+* Code which breaks existing tests
+
+## Workflow
+
+* Fork the Liquid repository
+* Create a new branch in your fork
+* If it makes sense, add tests for your code and run a performance benchmark
+* Make sure all tests pass
+* Create a pull request
+* In the description, ping one of [@boourns](https://github.com/boourns), [@fw42](https://github.com/fw42), [@camilo](https://github.com/camilo), [@dylanahsmith](https://github.com/dylanahsmith), or [@arthurnn](https://github.com/arthurnn) and ask for a code review.
+

Gemfile

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

History.md

@@ -1,4 +1,115 @@
-# Liquid Version History
+# Liquid Change Log
+
+## 4.0.0 / not yet released / branch "master"
+### Changed
+* 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]
+
+### Fixed
+* 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 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]
+* Improved whitespace stripping for blank blocks, related to #216 [Florian Weingarten, fw42]
+
+## 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
+
+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.
+
+* Bugfix for #106: fix example servlet [gnowoel]
+* Bugfix for #97: strip_html filter supports multi-line tags [Jo Liss, joliss]
+* Bugfix for #114: strip_html filter supports style tags [James Allardice, jamesallardice]
+* Bugfix for #117: 'now' support for date filter in Ruby 1.9 [Notre Dame Webgroup, ndwebgroup]
+* Bugfix for #166: truncate filter on UTF-8 strings with Ruby 1.8 [Florian Weingarten, fw42]
+* Bugfix for #204: 'raw' parsing bug [Florian Weingarten, fw42]
+* Bugfix for #150: 'for' parsing bug [Peter Schröder, phoet]
+* Bugfix for #126: Strip CRLF in strip_newline [Peter Schröder, phoet]
+* Bugfix for #174, "can't convert Fixnum into String" for "replace" [wǒ_is神仙, jsw0528]
+* Allow a Liquid::Drop to be passed into Template#render [Daniel Huckstep, darkhelmet]
+* Resource limits [Florian Weingarten, fw42]
+* Add reverse filter [Jay Strybis, unreal]
+* Add utf-8 support
+* Use array instead of Hash to keep the registered filters [Tasos Stathopoulos, astathopoulos]
+* Cache tokenized partial templates [Tom Burns, boourns]
+* Avoid warnings in Ruby 1.9.3 [Marcus Stollsteimer, stomar]
+* 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"
+
+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]
+
+## 2.5.3 / 2013-10-09
+
+* #232, #234, #237: Fix map filter bugs [Florian Weingarten, fw42]
+
+## 2.5.2 / 2013-09-03 / deleted
+
+Yanked from rubygems, as it contained too many changes that broke compatibility. Those changes will be on following major releases.
+
+## 2.5.1 / 2013-07-24
+
+* #230: Fix security issue with map filter, Use invoke_drop in map filter [Florian Weingarten, fw42]
 
 ## 2.5.0 / 2013-03-06
 
@@ -8,6 +119,7 @@
 * Fix filter parser for args without space separators
 * Add support for filter keyword arguments
 
+
 ## 2.4.0 / 2012-08-03
 
 * Performance improvements

README.md

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

Rakefile

@@ -1,35 +1,59 @@
-#!/usr/bin/env ruby
-
-require 'rubygems'
 require 'rake'
 require 'rake/testtask'
-require 'rubygems/package_task'
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+require "liquid/version"
 
 task :default => 'test'
 
-Rake::TestTask.new(:test) do |t|
+desc 'run test suite with default parser'
+Rake::TestTask.new(:base_test) do |t|
   t.libs << '.' << 'lib' << 'test'
-  t.test_files = FileList['test/liquid/**/*_test.rb']
+  t.test_files = FileList['test/{integration,unit}/**/*_test.rb']
   t.verbose = false
 end
 
-gemspec = eval(File.read('liquid.gemspec'))
+desc 'run test suite with warn error mode'
-Gem::PackageTask.new(gemspec) do |pkg|
+task :warn_test do
-  pkg.gem_spec = gemspec
+  ENV['LIQUID_PARSER_MODE'] = 'warn'
+  Rake::Task['base_test'].invoke
 end
 
-desc "Build the gem and release it to rubygems.org"
+desc 'runs test suite with both strict and lax parsers'
-task :release => :gem do
+task :test do
-  sh "gem push pkg/liquid-#{gemspec.version}.gem"
+  ENV['LIQUID_PARSER_MODE'] = 'lax'
+  Rake::Task['base_test'].invoke
+  ENV['LIQUID_PARSER_MODE'] = 'strict'
+  Rake::Task['base_test'].reenable
+  Rake::Task['base_test'].invoke
+end
+
+task :gem => :build
+task :build do
+  system "gem build liquid.gemspec"
+end
+
+task :install => :build do
+  system "gem install liquid-#{Liquid::VERSION}.gem"
+end
+
+task :release => :build do
+  system "git tag -a v#{Liquid::VERSION} -m 'Tagging #{Liquid::VERSION}'"
+  system "git push --tags"
+  system "gem push liquid-#{Liquid::VERSION}.gem"
+  system "rm liquid-#{Liquid::VERSION}.gem"
 end
 
 namespace :benchmark do
 
-  desc "Run the liquid benchmark"
+  desc "Run the liquid benchmark with lax parsing"
   task :run do
-    ruby "./performance/benchmark.rb"
+    ruby "./performance/benchmark.rb lax"
   end
 
+  desc "Run the liquid benchmark with strict parsing"
+  task :strict do
+    ruby "./performance/benchmark.rb strict"
+  end
 end
 
 
@@ -40,9 +64,23 @@ namespace :profile do
     ruby "./performance/profile.rb"
   end
 
-  desc "Run KCacheGrind"
+  desc "Run the liquid profile/performance coverage with strict parsing"
-  task :grind => :run  do
+  task :strict do
-    system "qcachegrind /tmp/liquid.rubyprof_calltreeprinter.txt"
+    ruby "./performance/profile.rb strict"
+  end
+
+end
+
+namespace :memory do
+
+  desc "Run the liquid memory tracer"
+  task :run do
+    ruby "./performance/memory.rb"
+  end
+
+  desc "Run the liquid memory tracer with strict parsing"
+  task :strict do
+    ruby "./performance/memory.rb strict"
   end
 
 end

example/server/example_servlet.rb

@@ -23,11 +23,7 @@ class Servlet < LiquidServlet
   end
 
   def products
-    { 'products' => products_list, 'section' => 'Snowboards', 'cool_products' => true}    
+    { 'products' => products_list, 'more_products' => more_products_list, 'description' => description, 'section' => 'Snowboards', 'cool_products' => true}
-  end
-
-  def description
-    "List of Products ~ This is a list of products with price and description."
   end
 
   private
@@ -38,4 +34,13 @@ 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
+
 end

example/server/liquid_servlet.rb

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

example/server/templates/index.liquid

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

example/server/templates/products.liquid

@@ -1,27 +1,27 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
-	"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-	<head>
+  <head>
-		<meta http-equiv="Content-type" content="text/html; charset=utf-8" />
+    <meta http-equiv="Content-type" content="text/html; charset=utf-8" />
-		<meta http-equiv="Content-Language" content="en-us" />
+    <meta http-equiv="Content-Language" content="en-us" />
 
-		<title>products</title>
+    <title>products</title>
 
-		<meta name="ROBOTS" content="ALL" />
+    <meta name="ROBOTS" content="ALL" />
-		<meta http-equiv="imagetoolbar" content="no" />
+    <meta http-equiv="imagetoolbar" content="no" />
-		<meta name="MSSmartTagsPreventParsing" content="true" />
+    <meta name="MSSmartTagsPreventParsing" content="true" />
-		<meta name="Copyright" content="(c) 2005 Copyright content:  Copyright design: Tobias Luetke" />
+    <meta name="Copyright" content="(c) 2005 Copyright content:  Copyright design: Tobias Luetke" />
-		<!-- (c) Copyright 2005 by Tobias Luetke All Rights Reserved. -->
+    <!-- (c) Copyright 2005 by Tobias Luetke All Rights Reserved. -->
-	</head>
+  </head>
 
-	<body>
+  <body>
+    {% assign all_products = products | concat: more_products  %}
+    <h1>{{ description | split: '~' | first }}</h1>
 
-	  <h1>{{ description | split: '~' | first }}</h1>
+    <h2>{{ description | split: '~' | last }}</h2>
 
-	  <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 products %}
+      {% for product in all_products %}
         <li>
           <h2>{{product.name}}</h2>
           Only {{product.price | price }}
@@ -45,5 +45,5 @@
 
     </ul>
 
-	</body>
+  </body>
 </html>

init.rb

@@ -1,8 +0,0 @@
-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

@@ -1,51 +0,0 @@
-# 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,9 +21,9 @@
 
 module Liquid
   FilterSeparator             = /\|/
-  ArgumentSeparator           = ','
+  ArgumentSeparator           = ','.freeze
-  FilterArgumentSeparator     = ':'
+  FilterArgumentSeparator     = ':'.freeze
-  VariableAttributeSeparator  = '.'
+  VariableAttributeSeparator  = '.'.freeze
   TagStart                    = /\{\%/
   TagEnd                      = /\%\}/
   VariableSignature           = /\(?[\w\-\.\[\]]\)?/
@@ -33,35 +33,43 @@ module Liquid
   VariableIncompleteEnd       = /\}\}?/
   QuotedString                = /"[^"]*"|'[^']*'/
   QuotedFragment              = /#{QuotedString}|(?:[^\s,\|'"]|#{QuotedString})+/o
-  StrictQuotedFragment        = /"[^"]+"|'[^']+'|[^\s|:,]+/
-  FirstFilterArgument         = /#{FilterArgumentSeparator}(?:#{StrictQuotedFragment})/o
-  OtherFilterArgument         = /#{ArgumentSeparator}(?:#{StrictQuotedFragment})/o
-  SpacelessFilter             = /^(?:'[^']+'|"[^"]+"|[^'"])*#{FilterSeparator}(?:#{StrictQuotedFragment})(?:#{FirstFilterArgument}(?:#{OtherFilterArgument})*)?/o
-  Expression                  = /(?:#{QuotedFragment}(?:#{SpacelessFilter})*)/o
   TagAttributes               = /(\w+)\s*\:\s*(#{QuotedFragment})/o
   AnyStartingTag              = /\{\{|\{\%/
-  PartialTemplateParser       = /#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableIncompleteEnd}/o
+  PartialTemplateParser       = /#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableIncompleteEnd}/om
-  TemplateParser              = /(#{PartialTemplateParser}|#{AnyStartingTag})/o
+  TemplateParser              = /(#{PartialTemplateParser}|#{AnyStartingTag})/om
   VariableParser              = /\[[^\]]+\]|#{VariableSegment}+\??/o
+
+  singleton_class.send(:attr_accessor, :cache_classes)
+  self.cache_classes = true
 end
 
+require "liquid/version"
+require 'liquid/lexer'
+require 'liquid/parser'
+require 'liquid/i18n'
 require 'liquid/drop'
 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,115 +1,79 @@
 module Liquid
-
   class Block < Tag
-    IsTag             = /^#{TagStart}/o
+    def initialize(tag_name, markup, options)
-    IsVariable        = /^#{VariableStart}/o
+      super
-    FullToken         = /^#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}$/o
+      @blank = true
-    ContentOfVariable = /^#{VariableStart}(.*)#{VariableEnd}$/o
-
-    def parse(tokens)
-      @nodelist ||= []
-      @nodelist.clear
-
-      while token = tokens.shift
-
-        case token
-        when IsTag
-          if token =~ FullToken
-
-            # if we found the proper block delimitor just end parsing here and let the outer block
-            # proceed
-            if block_delimiter == $1
-              end_tag
-              return
-            end
-
-            # fetch the tag from registered blocks
-            if tag = Template.tags[$1]
-              @nodelist << tag.new($1, $2, tokens)
-            else
-              # this tag is not registered with the system
-              # pass it to the current block for special handling or error reporting
-              unknown_tag($1, $2, tokens)
-            end
-          else
-            raise SyntaxError, "Tag '#{token}' was not properly terminated with regexp: #{TagEnd.inspect} "
-          end
-        when IsVariable
-          @nodelist << create_variable(token)
-        when ''
-          # pass
-        else
-          @nodelist << token
-        end
-      end
-
-      # Make sure that its ok to end parsing in the current block.
-      # Effectively this method will throw and exception unless the current block is
-      # of type Document
-      assert_missing_delimitation!
     end
 
-    def end_tag
+    def parse(tokens)
+      @body = BlockBody.new
+      while more = parse_body(@body, tokens)
+      end
+    end
+
+    def render(context)
+      @body.render(context)
+    end
+
+    def blank?
+      @blank
+    end
+
+    def nodelist
+      @body.nodelist
+    end
+
+    # warnings of this block and all sub-tags
+    def warnings
+      all_warnings = []
+      all_warnings.concat(@warnings) if @warnings
+
+      (nodelist || []).each do |node|
+        all_warnings.concat(node.warnings || []) if node.respond_to?(:warnings)
+      end
+
+      all_warnings
     end
 
     def unknown_tag(tag, params, tokens)
       case tag
-      when 'else'
+      when 'else'.freeze
-        raise SyntaxError, "#{block_name} tag does not expect else tag"
+        raise SyntaxError.new(options[:locale].t("errors.syntax.unexpected_else".freeze,
-      when 'end'
+                                                 :block_name => block_name))
-        raise SyntaxError, "'end' is not a valid delimiter for #{block_name} tags. use #{block_delimiter}"
+      when 'end'.freeze
+        raise SyntaxError.new(options[:locale].t("errors.syntax.invalid_delimiter".freeze,
+                                                 :block_name => block_name,
+                                                 :block_delimiter => block_delimiter))
       else
-        raise SyntaxError, "Unknown tag '#{tag}'"
+        raise SyntaxError.new(options[:locale].t("errors.syntax.unknown_tag".freeze, :tag => tag))
       end
     end
 
-    def block_delimiter
-      "end#{block_name}"
-    end
-
     def block_name
       @tag_name
     end
 
-    def create_variable(token)
+    def block_delimiter
-      token.scan(ContentOfVariable) do |content|
+      @block_delimiter ||= "end#{block_name}"
-        return Variable.new(content.first)
-      end
-      raise SyntaxError.new("Variable '#{token}' was not properly terminated with regexp: #{VariableEnd.inspect} ")
-    end
-
-    def render(context)
-      render_all(@nodelist, context)
     end
 
     protected
 
-    def assert_missing_delimitation!
+    def parse_body(body, tokens)
-      raise SyntaxError.new("#{block_name} tag was never closed")
+      body.parse(tokens, options) do |end_tag_name, end_tag_params|
-    end
+        @blank &&= body.blank?
 
-    def render_all(list, context)
+        return false if end_tag_name == block_delimiter
-      output = []
+        unless end_tag_name
-      list.each do |token|
+          raise SyntaxError.new(@options[:locale].t("errors.syntax.tag_never_closed".freeze, :block_name => block_name))
-        # 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
-
-          output << (token.respond_to?(:render) ? token.render(context) : token)
-        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
 
-      output.join
+      true
     end
   end
 end

lib/liquid/block_body.rb

@@ -0,0 +1,132 @@
+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 ||= []
+      @output.clear
+      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
+
+    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,19 +3,21 @@ module Liquid
   #
   # Example:
   #
-  #   c = Condition.new('1', '==', '1')
+  #   c = Condition.new(1, '==', 1)
   #   c.evaluate #=> true
   #
   class Condition #:nodoc:
     @@operators = {
-      '==' => lambda { |cond, left, right|  cond.send(:equal_variables, left, right) },
+      '=='.freeze => lambda { |cond, left, right|  cond.send(:equal_variables, left, right) },
-      '!=' => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
+      '!='.freeze => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
-      '<>' => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
+      '<>'.freeze => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
-      '<'  => :<,
+      '<'.freeze  => :<,
-      '>'  => :>,
+      '>'.freeze  => :>,
-      '>=' => :>=,
+      '>='.freeze => :>=,
-      '<=' => :<=,
+      '<='.freeze => :<=,
-      'contains' => lambda { |cond, left, right| left && right ? left.include?(right) : false }
+      'contains'.freeze => lambda { |cond, left, right|
+        left && right && left.respond_to?(:include?) ? left.include?(right) : false
+      }
     }
 
     def self.operators
@@ -26,7 +28,9 @@ module Liquid
     attr_accessor :left, :operator, :right
 
     def initialize(left = nil, operator = nil, right = nil)
-      @left, @operator, @right = left, operator, right
+      @left = left
+      @operator = operator
+      @right = right
       @child_relation  = nil
       @child_condition = nil
     end
@@ -45,11 +49,13 @@ module Liquid
     end
 
     def or(condition)
-      @child_relation, @child_condition = :or, condition
+      @child_relation = :or
+      @child_condition = condition
     end
 
     def and(condition)
-      @child_relation, @child_condition = :and, condition
+      @child_relation = :and
+      @child_condition = condition
     end
 
     def attach(attachment)
@@ -61,7 +67,7 @@ module Liquid
     end
 
     def inspect
-      "#<Condition #{[@left, @operator, @right].compact.join(' ')}>"
+      "#<Condition #{[@left, @operator, @right].compact.join(' '.freeze)}>"
     end
 
     private
@@ -90,16 +96,21 @@ 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[left] if op == nil
+      return context.evaluate(left) if op == nil
 
-      left, right = context[left], context[right]
+      left = context.evaluate(left)
+      right = context.evaluate(right)
 
-      operation = self.class.operators[op] || raise(ArgumentError.new("Unknown operator #{op}"))
+      operation = self.class.operators[op] || raise(Liquid::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)
-        left.send(operation, right)
+        begin
+          left.send(operation, right)
+        rescue ::ArgumentError => e
+          raise Liquid::ArgumentError.new(e.message)
+        end
       else
         nil
       end

lib/liquid/context.rb

@@ -13,21 +13,32 @@ module Liquid
   #
   #   context['bob']  #=> nil  class Context
   class Context
-    attr_reader :scopes, :errors, :registers, :environments
+    attr_reader :scopes, :registers, :environments, :resource_limits
+    attr_accessor :exception_handler
 
-    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false)
+    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil)
-      @environments   = [environments].flatten
+      @environments     = [environments].flatten
-      @scopes         = [(outer_scope || {})]
+      @scopes           = [(outer_scope || {})]
-      @registers      = registers
+      @registers        = registers
-      @errors         = []
+      @resource_limits  = resource_limits || ResourceLimits.new(Template.default_resource_limits)
-      @rethrow_errors = rethrow_errors
       squash_instance_assigns_with_environments
 
-      @interrupts = []
+      @this_stack_used = false
+
+      if rethrow_errors
+        self.exception_handler = ->(e) { true }
+      end
+
+      @interrupts = nil
+      @filters = []
+    end
+
+    def errors
+      @errors ||= []
     end
 
     def strainer
-      @strainer ||= Strainer.create(self)
+      @strainer ||= Strainer.create(self, @filters)
     end
 
     # Adds filters to this context.
@@ -36,49 +47,44 @@ module Liquid
     # for that
     def add_filters(filters)
       filters = [filters].flatten.compact
-
+      @filters += filters
-      filters.each do |f|
+      @strainer = nil
-        raise ArgumentError, "Expected module but got: #{f.class}" unless f.is_a?(Module)
-        Strainer.add_known_filter(f)
-        strainer.extend(f)
-      end
     end
 
     # are there any not handled interrupts?
     def has_interrupt?
-      !@interrupts.empty?
+      @interrupts && !@interrupts.empty?
     end
 
     # push an interrupt to the stack. this interrupt is considered not handled.
     def push_interrupt(e)
-      @interrupts.push(e)
+      (@interrupts ||= []).push(e)
     end
 
     # pop an interrupt from the stack
     def pop_interrupt
-      @interrupts.pop
+      @interrupts.pop if @interrupts
     end
 
-    def handle_error(e)
-      errors.push(e)
-      raise if @rethrow_errors
 
-      case e
+    def handle_error(e, token=nil)
-      when SyntaxError
+      if e.is_a?(Liquid::Error)
-        "Liquid syntax error: #{e.message}"
+        e.set_line_number_from_token(token)
-      else
-        "Liquid error: #{e.message}"
       end
+
+      errors.push(e)
+      raise if exception_handler && exception_handler.call(e)
+      Liquid::Error.render(e)
     end
 
     def invoke(method, *args)
-      strainer.invoke(method, *args)
+      strainer.invoke(method, *args).to_liquid
     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" if @scopes.length > 100
+      raise StackLevelError, "Nesting too deep".freeze if @scopes.length > 100
     end
 
     # Merge a hash of variables in the current local scope
@@ -100,11 +106,19 @@ module Liquid
     #   end
     #
     #   context['var]  #=> nil
-    def stack(new_scope={})
+    def stack(new_scope=nil)
-      push(new_scope)
+      old_stack_used = @this_stack_used
+      if new_scope
+        push(new_scope)
+        @this_stack_used = true
+      else
+        @this_stack_used = false
+      end
+
       yield
     ensure
-      pop
+      pop if @this_stack_used
+      @this_stack_used = old_stack_used
     end
 
     def clear_instance_assigns
@@ -113,137 +127,71 @@ 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
 
-    def [](key)
+    # Look up variable, either resolve directly after considering the name. We can directly handle
-      resolve(key)
+    # 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))
     end
 
     def has_key?(key)
-      resolve(key) != nil
+      self[key] != nil
+    end
+
+    def evaluate(object)
+      object.respond_to?(:evaluate) ? object.evaluate(self) : object
+    end
+
+    # 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
+          end
+        end
+      end
+
+      scope     ||= @environments.last || @scopes.last
+      variable  ||= lookup_and_evaluate(scope, key)
+
+      variable = variable.to_liquid
+      variable.context = self if variable.respond_to?(:context=)
+
+      return variable
+    end
+
+    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
 
     private
-      LITERALS = {
-        nil => nil, 'nil' => nil, 'null' => nil, '' => nil,
-        'true'  => true,
-        'false' => false,
-        'blank' => :blank?,
-        'empty' => :empty?
-      }
-
-      # Look up variable, either resolve directly after considering the name. We can directly handle
-      # Strings, digits, floats and booleans (true,false).
-      # If no match is made we lookup the variable in the current scope and
-      # 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 /^'(.*)'$/ # Single quoted strings
-            $1
-          when /^"(.*)"$/ # Double quoted strings
-            $1
-          when /^(-?\d+)$/ # Integer and floats
-            $1.to_i
-          when /^\((\S+)\.\.(\S+)\)$/ # Ranges
-            (resolve($1).to_i..resolve($2).to_i)
-          when /^(-?\d[\d\.]+)$/ # Floats
-            $1.to_f
-          else
-            variable(key)
-          end
-        end
-      end
-
-      # Fetches an object starting at the local scope and then moving up the hierachy
-      def find_variable(key)
-        scope = @scopes.find { |s| s.has_key?(key) }
-
-        if scope.nil?
-          @environments.each do |e|
-            if variable = lookup_and_evaluate(e, key)
-              scope = e
-              break
-            end
-          end
-        end
-
-        scope     ||= @environments.last || @scopes.last
-        variable  ||= lookup_and_evaluate(scope, key)
-
-        variable = variable.to_liquid
-        variable.context = self if variable.respond_to?(:context=)
-
-        return variable
-      end
-
-      # Resolves namespaced queries gracefully.
-      #
-      # Example
-      #  @context['hash'] = {"name" => 'tobi'}
-      #  assert_equal 'tobi', @context['hash.name']
-      #  assert_equal 'tobi', @context['hash["name"]']
-      def variable(markup)
-        parts = markup.scan(VariableParser)
-        square_bracketed = /^\[(.*)\]$/
-
-        first_part = parts.shift
-
-        if first_part =~ square_bracketed
-          first_part = resolve($1)
-        end
-
-        if object = find_variable(first_part)
-
-          parts.each do |part|
-            part = resolve($1) if part_resolved = (part =~ square_bracketed)
-
-            # If object is a hash- or array-like object we look for the
-            # presence of the key and if its available we return it
-            if object.respond_to?(:[]) and
-              ((object.respond_to?(:has_key?) and object.has_key?(part)) or
-               (object.respond_to?(:fetch) and part.is_a?(Integer)))
-
-              # if its a proc we will replace the entry with the proc
-              res = lookup_and_evaluate(object, part)
-              object = res.to_liquid
-
-              # Some special cases. If the part wasn't in square brackets and
-              # no key with the same name was found we interpret following calls
-              # as commands and call them on the current object
-            elsif !part_resolved and object.respond_to?(part) and ['size', 'first', 'last'].include?(part)
-
-              object = object.send(part.intern).to_liquid
-
-              # No key was present with the desired value and it wasn't one of the directly supported
-              # keywords either. The only thing we got left is to return nil
-            else
-              return nil
-            end
-
-            # If we are dealing with a drop here we have to
-            object.context = self if object.respond_to?(:context=)
-          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|
@@ -255,5 +203,4 @@ module Liquid
         end
       end # squash_instance_assigns_with_environments
   end # Context
-
 end # Liquid

lib/liquid/document.rb

@@ -1,17 +1,24 @@
 module Liquid
-  class Document < Block
+  class Document < BlockBody
-    # we don't need markup to open this block
+    def self.parse(tokens, options)
-    def initialize(tokens)
+      doc = new
-      parse(tokens)
+      doc.parse(tokens, options)
+      doc
     end
 
-    # There isn't a real delimter
+    def parse(tokens, options)
-    def block_delimiter
+      super do |end_tag_name, end_tag_params|
-      []
+        unknown_tag(end_tag_name, options) if end_tag_name
+      end
     end
 
-    # Document blocks don't need to be terminated since they are not actually opened
+    def unknown_tag(tag, options)
-    def assert_missing_delimitation!
+      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
     end
   end
 end

lib/liquid/drop.rb

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

lib/liquid/errors.rb

@@ -1,11 +1,60 @@
 module Liquid
-  class Error < ::StandardError; end
+  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 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

@@ -0,0 +1,33 @@
+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?
+    }
+
+    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
+
+  end
+end

lib/liquid/file_system.rb

@@ -1,5 +1,5 @@
 module Liquid
-  # A Liquid file system is way to let your templates retrieve other templates for use with the include tag.
+  # A Liquid file system is a way to let your templates retrieve other templates for use with the include tag.
   #
   # You can implement subclasses that retrieve templates from the database, from the file system using a different
   # path structure, you can provide them as hard-coded inline strings, or any manner that you see fit.
@@ -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, context)
+    def read_template_file(template_path)
       raise FileSystemError, "This liquid context does not allow includes."
     end
   end
@@ -31,14 +31,25 @@ module Liquid
   # file_system.full_path("mypartial")       # => "/some/path/_mypartial.liquid"
   # file_system.full_path("dir/mypartial")   # => "/some/path/dir/_mypartial.liquid"
   #
+  # Optionally in the second argument you can specify a custom pattern for template filenames.
+  # The Kernel::sprintf format specification is used.
+  # Default pattern is "_%s.liquid".
+  #
+  # Example:
+  #
+  # file_system = Liquid::LocalFileSystem.new("/some/path", "%s.html")
+  #
+  # file_system.full_path("index") # => "/some/path/index.html"
+  #
   class LocalFileSystem
     attr_accessor :root
 
-    def initialize(root)
+    def initialize(root, pattern = "_%s.liquid".freeze)
       @root = root
+      @pattern = pattern
     end
 
-    def read_template_file(template_path, context)
+    def read_template_file(template_path)
       full_path = full_path(template_path)
       raise FileSystemError, "No such template '#{template_path}'" unless File.exists?(full_path)
 
@@ -46,15 +57,15 @@ module Liquid
     end
 
     def full_path(template_path)
-      raise FileSystemError, "Illegal template name '#{template_path}'" unless template_path =~ /^[^.\/][a-zA-Z0-9_\/]+$/
+      raise FileSystemError, "Illegal template name '#{template_path}'" unless template_path =~ /\A[^.\/][a-zA-Z0-9_\/]+\z/
 
-      full_path = if template_path.include?('/')
+      full_path = if template_path.include?('/'.freeze)
-        File.join(root, File.dirname(template_path), "_#{File.basename(template_path)}.liquid")
+        File.join(root, File.dirname(template_path), @pattern % File.basename(template_path))
       else
-        File.join(root, "_#{template_path}.liquid")
+        File.join(root, @pattern % template_path)
       end
 
-      raise FileSystemError, "Illegal template path '#{File.expand_path(full_path)}'" unless File.expand_path(full_path) =~ /^#{File.expand_path(root)}/
+      raise FileSystemError, "Illegal template path '#{File.expand_path(full_path)}'" unless File.expand_path(full_path) =~ /\A#{File.expand_path(root)}/
 
       full_path
     end

lib/liquid/htmltags.rb

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

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

lib/liquid/interrupts.rb

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

lib/liquid/lexer.rb

@@ -0,0 +1,53 @@
+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
+    }
+    IDENTIFIER = /[a-zA-Z_][\w-]*\??/
+    SINGLE_STRING_LITERAL = /'[^\']*'/
+    DOUBLE_STRING_LITERAL = /"[^\"]*"/
+    NUMBER_LITERAL = /-?\d+(\.\d+)?/
+    DOTDOT = /\.\./
+    COMPARISON_OPERATOR = /==|!=|<>|<=?|>=?|contains/
+
+    def initialize(input)
+      @ss = StringScanner.new(input.rstrip)
+    end
+
+    def tokenize
+      @output = []
+
+      while !@ss.eos?
+        @ss.skip(/\s*/)
+        tok = case
+        when t = @ss.scan(COMPARISON_OPERATOR) then [:comparison, t]
+        when t = @ss.scan(SINGLE_STRING_LITERAL) then [:string, t]
+        when t = @ss.scan(DOUBLE_STRING_LITERAL) then [:string, t]
+        when t = @ss.scan(NUMBER_LITERAL) then [:number, t]
+        when t = @ss.scan(IDENTIFIER) then [:id, t]
+        when t = @ss.scan(DOTDOT) then [:dotdot, t]
+        else
+          c = @ss.getch
+          if s = SPECIALS[c]
+            [s,c]
+          else
+            raise SyntaxError, "Unexpected character #{c}"
+          end
+        end
+        @output << tok
+      end
+
+      @output << [:end_of_string]
+    end
+  end
+end

lib/liquid/locales/en.yml

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

lib/liquid/module_ex.rb

@@ -2,21 +2,22 @@
 # This library is free software. It may be used, redistributed and/or modified
 # under the same terms as Ruby itself
 #
-# This extension is usesd in order to expose the object of the implementing class
+# This extension is used in order to expose the object of the implementing class
 # to liquid as it were a Drop. It also limits the liquid-callable methods of the instance
 # to the allowed method passed with the liquid_methods call
 # Example:
 #
-# class SomeClass
+#   class SomeClass
-#   liquid_methods :an_allowed_method
+#     liquid_methods :an_allowed_method
 #
-#   def an_allowed_method
+#     def an_allowed_method
-#     'this comes from an allowed method'
+#       'this comes from an allowed method'
+#     end
+#
+#     def unallowed_method
+#       'this will never be an output'
+#     end
 #   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
@@ -26,31 +27,33 @@
 #       '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
@@ -58,5 +61,4 @@ class Module
       end
     end
   end
-
 end

lib/liquid/parser.rb

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

lib/liquid/parser_switching.rb

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,162 @@
+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

@@ -0,0 +1,23 @@
+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).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

@@ -0,0 +1,22 @@
+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
+  end
+end

lib/liquid/resource_limits.rb

@@ -0,0 +1,23 @@
+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

@@ -1,21 +1,29 @@
 require 'cgi'
+require 'bigdecimal'
 
 module Liquid
 
   module StandardFilters
+    HTML_ESCAPE = {
+      '&'.freeze => '&'.freeze,
+      '>'.freeze => '>'.freeze,
+      '<'.freeze => '&lt;'.freeze,
+      '"'.freeze => '&quot;'.freeze,
+      "'".freeze => '&#39;'.freeze
+    }
+    HTML_ESCAPE_ONCE_REGEXP = /["><']|&(?!([a-zA-Z]+|(#\d+));)/
 
     # Return the size of an array or of an string
     def size(input)
-
       input.respond_to?(:size) ? input.size : 0
     end
 
-    # convert a input string to DOWNCASE
+    # convert an input string to DOWNCASE
     def downcase(input)
       input.to_s.downcase
     end
 
-    # convert a input string to UPCASE
+    # convert an input string to UPCASE
     def upcase(input)
       input.to_s.upcase
     end
@@ -26,31 +34,43 @@ module Liquid
     end
 
     def escape(input)
-      CGI.escapeHTML(input) rescue input
+      CGI.escapeHTML(input).untaint rescue input
     end
-
-    def escape_once(input)
-      ActionView::Helpers::TagHelper.escape_once(input)
-    rescue NameError
-      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
+
     # Truncate a string down to x characters
-    def truncate(input, length = 50, truncate_string = "...")
+    def truncate(input, length = 50, truncate_string = "...".freeze)
       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 = "...")
+    def truncatewords(input, words = 15, truncate_string = "...".freeze)
       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(" ") + truncate_string : input
+      wordlist.length > l ? wordlist[0..l].join(" ".freeze) + truncate_string : input
     end
 
     # Split input string into an array of substrings separated by given pattern.
@@ -59,65 +79,97 @@ module Liquid
     #   <div class="summary">{{ post | split '//' | first }}</div>
     #
     def split(input, pattern)
-      input.split(pattern)
+      input.to_s.split(pattern)
+    end
+
+    def strip(input)
+      input.to_s.strip
+    end
+
+    def lstrip(input)
+      input.to_s.lstrip
+    end
+
+    def rstrip(input)
+      input.to_s.rstrip
     end
 
     def strip_html(input)
-      input.to_s.gsub(/<script.*?<\/script>/, '').gsub(/<!--.*?-->/, '').gsub(/<.*?>/, '')
+      empty = ''.freeze
+      input.to_s.gsub(/<script.*?<\/script>/m, empty).gsub(/<!--.*?-->/m, empty).gsub(/<style.*?<\/style>/m, empty).gsub(/<.*?>/m, empty)
     end
 
     # Remove all newlines from the string
     def strip_newlines(input)
-      input.to_s.gsub(/\n/, '')
+      input.to_s.gsub(/\r?\n/, ''.freeze)
     end
 
-
     # Join elements of the array with certain character between them
-    def join(input, glue = ' ')
+    def join(input, glue = ' '.freeze)
-      [input].flatten.join(glue)
+      InputIterator.new(input).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 = [input].flatten
+      ary = InputIterator.new(input)
       if property.nil?
         ary.sort
-      elsif ary.first.respond_to?('[]') and !ary.first[property].nil?
+      elsif ary.first.respond_to?(:[]) && !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
 
+    # 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.reverse
+    end
+
     # map/collect on a given property
     def map(input, property)
-      ary = [input].flatten
+      InputIterator.new(input).map do |e|
-      if ary.first.respond_to?('[]') and !ary.first[property].nil?
+        e = e.call if e.is_a?(Proc)
-        ary.map {|e| e[property] }
+
-      elsif ary.first.respond_to?(property)
+        if property == "to_liquid".freeze
-        ary.map {|e| e.send(property) }
+          e
+        elsif e.respond_to?(:[])
+          e[property]
+        end
       end
     end
 
     # Replace occurrences of a string with another
-    def replace(input, string, replacement = '')
+    def replace(input, string, replacement = ''.freeze)
-      input.to_s.gsub(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 = '')
+    def replace_first(input, string, replacement = ''.freeze)
-      input.to_s.sub(string, replacement)
+      input.to_s.sub(string, replacement.to_s)
     end
 
     # remove a substring
     def remove(input, string)
-      input.to_s.gsub(string, '')
+      input.to_s.gsub(string, ''.freeze)
     end
 
     # remove the first occurrences of a substring
     def remove_first(input, string)
-      input.to_s.sub(string, '')
+      input.to_s.sub(string, ''.freeze)
     end
 
     # add one string to another
@@ -125,6 +177,10 @@ 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
@@ -132,10 +188,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")
+      input.to_s.gsub(/\n/, "<br />\n".freeze)
     end
 
-    # Reformat a date
+    # Reformat a date using Ruby's core Time#strftime( string ) -> string
     #
     #   %a - The abbreviated weekday name (``Sun'')
     #   %A - The  full  weekday  name (``Sunday'')
@@ -149,6 +205,7 @@ 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
@@ -163,25 +220,14 @@ 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?
 
-      if format.to_s.empty?
+      return input unless date = to_date(input)
-        return input.to_s
-      end
 
-      if ((input.is_a?(String) && !/^\d+$/.match(input.to_s).nil?) || input.is_a?(Integer)) && input.to_i > 0
+      date.strftime(format.to_s)
-        input = Time.at(input.to_i)
-      end
-
-      date = input.is_a?(String) ? Time.parse(input) : input
-
-      if date.respond_to?(:strftime)
-        date.strftime(format.to_s)
-      else
-        input
-      end
-    rescue => e
-      input
     end
 
     # Get the first element of the passed in array
@@ -204,41 +250,120 @@ module Liquid
 
     # addition
     def plus(input, operand)
-      to_number(input) + to_number(operand)
+      apply_operation(input, operand, :+)
     end
 
     # subtraction
     def minus(input, operand)
-      to_number(input) - to_number(operand)
+      apply_operation(input, operand, :-)
     end
 
     # multiplication
     def times(input, operand)
-      to_number(input) * to_number(operand)
+      apply_operation(input, operand, :*)
     end
 
     # division
     def divided_by(input, operand)
-      to_number(input) / to_number(operand)
+      apply_operation(input, operand, :/)
     end
 
     def modulo(input, operand)
-      to_number(input) % to_number(operand)
+      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)
+      is_blank = input.respond_to?(:empty?) ? input.empty? : !input
+      is_blank ? default_value : input
     end
 
     private
 
-      def to_number(obj)
+    def to_number(obj)
-        case obj
+      case obj
-        when Numeric
+      when Float
-          obj
+        BigDecimal.new(obj.to_s)
-        when String
+      when Numeric
-          (obj.strip =~ /^\d+\.\d+$/) ? obj.to_f : obj.to_i
+        obj
+      when String
+        (obj.strip =~ /\A\d+\.\d+\z/) ? BigDecimal.new(obj) : obj.to_i
+      else
+        0
+      end
+    end
+
+    def to_date(obj)
+      return obj if obj.respond_to?(:strftime)
+
+      obj = obj.downcase if obj.is_a?(String)
+
+      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
-          0
+          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,46 +8,52 @@ 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:
-    @@filters = {}
+    @@global_strainer = Class.new(Strainer) do
-    @@known_filters = Set.new
+      @filter_methods = Set.new
-    @@known_methods = Set.new
+    end
+    @@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) }
+      end
+    end
 
     def initialize(context)
       @context = context
     end
 
-    def self.global_filter(filter)
+    def self.filter_methods
-      raise ArgumentError, "Passed filter is not a module" unless filter.is_a?(Module)
+      @filter_methods
-      add_known_filter(filter)
-      @@filters[filter.name] = filter
     end
 
-    def self.add_known_filter(filter)
+    def self.add_filter(filter)
-      unless @@known_filters.include?(filter)
+      raise ArgumentError, "Expected module but got: #{f.class}" unless filter.is_a?(Module)
-        @@method_blacklist ||= Set.new(Strainer.instance_methods.map(&:to_s))
+      unless self.class.include?(filter)
-        new_methods = filter.instance_methods.map(&:to_s)
+        self.send(:include, filter)
-        new_methods.reject!{ |m| @@method_blacklist.include?(m) }
+        @filter_methods.merge(filter.public_instance_methods.map(&:to_s))
-        @@known_methods.merge(new_methods)
-        @@known_filters.add(filter)
       end
     end
 
-    def self.create(context)
+    def self.global_filter(filter)
-      strainer = Strainer.new(context)
+      @@global_strainer.add_filter(filter)
-      @@filters.each { |k,m| strainer.extend(m) }
+    end
-      strainer
+
+    def self.invokable?(method)
+      @filter_methods.include?(method.to_s)
+    end
+
+    def self.create(context, filters = [])
+      @@strainer_class_cache[filters].new(context)
     end
 
     def invoke(method, *args)
-      if invokable?(method)
+      if self.class.invokable?(method)
         send(method, *args)
       else
         args.first
       end
-    end
+    rescue ::ArgumentError => e
-
+      raise Liquid::ArgumentError.new(e.message)
-    def invokable?(method)
-      @@known_methods.include?(method.to_s) && respond_to?(method)
     end
   end
 end

lib/liquid/tag.rb

@@ -1,26 +1,42 @@
 module Liquid
-
   class Tag
+    attr_accessor :options, :line_number
+    attr_reader :nodelist, :warnings
+    include ParserSwitching
 
-    attr_accessor :nodelist
+    class << self
+      def parse(tag_name, markup, tokens, options)
+        tag = new(tag_name, markup, options)
+        tag.parse(tokens)
+        tag
+      end
 
-    def initialize(tag_name, markup, tokens)
+      private :new
+    end
+
+    def initialize(tag_name, markup, options)
       @tag_name   = tag_name
       @markup     = markup
-      parse(tokens)
+      @options    = options
     end
 
     def parse(tokens)
     end
 
+    def raw
+      "#{@tag_name} #{@markup}"
+    end
+
     def name
       self.class.name.downcase
     end
 
     def render(context)
-      ''
+      ''.freeze
     end
 
-  end # Tag
+    def blank?
-
+      false
-end # Tag
+    end
+  end
+end

lib/liquid/tags/assign.rb

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

lib/liquid/tags/break.rb

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

lib/liquid/tags/capture.rb

@@ -1,5 +1,4 @@
 module Liquid
-
   # Capture stores the result of a block into a variable without rendering it inplace.
   #
   #   {% capture heading %}
@@ -12,24 +11,28 @@ module Liquid
   # in a sidebar or footer.
   #
   class Capture < Block
-    Syntax = /(\w+)/
+    Syntax = /(#{VariableSignature}+)/o
 
-    def initialize(tag_name, markup, tokens)
+    def initialize(tag_name, markup, options)
+      super
       if markup =~ Syntax
         @to = $1
       else
-        raise SyntaxError.new("Syntax Error in 'capture' - Valid syntax: capture [var]")
+        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
+    end
+
+    def blank?
+      true
     end
   end
 
-  Template.register_tag('capture', Capture)
+  Template.register_tag('capture'.freeze, Capture)
 end

lib/liquid/tags/case.rb

@@ -1,26 +1,35 @@
 module Liquid
   class Case < Block
     Syntax     = /(#{QuotedFragment})/o
-    WhenSyntax = /(#{QuotedFragment})(?:(?:\s+or\s+|\s*\,\s*)(#{QuotedFragment}.*))?/o
+    WhenSyntax = /(#{QuotedFragment})(?:(?:\s+or\s+|\s*\,\s*)(#{QuotedFragment}.*))?/om
 
-    def initialize(tag_name, markup, tokens)      
+    def initialize(tag_name, markup, options)
+      super
       @blocks = []
 
       if markup =~ Syntax
-        @left = $1
+        @left = Expression.parse($1)
       else
-        raise SyntaxError.new("Syntax Error in tag 'case' - Valid syntax: case [condition]")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.case".freeze))
       end
+    end
 
-      super
+    def parse(tokens)
+      body = BlockBody.new
+      while more = parse_body(body, tokens)
+        body = @blocks.last.attachment
+      end
+    end
+
+    def nodelist
+      @blocks.map(&:attachment)
     end
 
     def unknown_tag(tag, markup, tokens)
-      @nodelist = []
       case tag
-      when 'when'
+      when 'when'.freeze
         record_when_condition(markup)
-      when 'else'
+      when 'else'.freeze
         record_else_condition(markup)
       else
         super
@@ -34,10 +43,10 @@ module Liquid
         output = ''
         @blocks.each do |block|
           if block.else?
-            return render_all(block.attachment, context) if execute_else_block
+            return block.attachment.render(context) if execute_else_block
           elsif block.evaluate(context)
             execute_else_block = false
-            output << render_all(block.attachment, context)
+            output << block.attachment.render(context)
           end
         end
         output
@@ -47,33 +56,31 @@ module Liquid
     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
-      	if not markup =~ WhenSyntax
+          raise SyntaxError.new(options[:locale].t("errors.syntax.case_invalid_when".freeze))
-      	  raise SyntaxError.new("Syntax Error in tag 'case' - Valid when condition: {% when [condition] [or condition2...] %} ")
+        end
-      	end
 
-      	markup = $2
+        markup = $2
 
-      	block = Condition.new(@left, '==', $1)        
+        block = Condition.new(@left, '=='.freeze, Expression.parse($1))
-      	block.attach(@nodelist)
+        block.attach(body)
-      	@blocks.push(block)
+        @blocks << block
       end
     end
 
     def record_else_condition(markup)
-
       if not markup.strip.empty?
-        raise SyntaxError.new("Syntax Error in tag 'case' - Valid else condition: {% else %} (no parameters) ")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.case_invalid_else".freeze))
       end
 
       block = ElseCondition.new
-      block.attach(@nodelist)
+      block.attach(BlockBody.new)
       @blocks << block
     end
-    
-        
   end
 
-  Template.register_tag('case', Case)
+  Template.register_tag('case'.freeze, Case)
 end

lib/liquid/tags/comment.rb

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

lib/liquid/tags/continue.rb

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

lib/liquid/tags/cycle.rb

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

lib/liquid/tags/decrement.rb

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

lib/liquid/tags/for.rb

@@ -42,53 +42,51 @@ 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 = /(\w+)\s+in\s+(#{QuotedFragment}+)\s*(reversed)?/o
+    Syntax = /\A(#{VariableSegment}+)\s+in\s+(#{QuotedFragment}+)\s*(reversed)?/o
 
-    def initialize(tag_name, markup, tokens)
+    def initialize(tag_name, markup, options)
-      if markup =~ Syntax
-        @variable_name = $1
-        @collection_name = $2
-        @name = "#{$1}-#{$2}"           
-        @reversed = $3             
-        @attributes = {}
-        markup.scan(TagAttributes) do |key, value|
-          @attributes[key] = value
-        end        
-      else
-        raise SyntaxError.new("Syntax Error in 'for loop' - Valid syntax: for [item] in [collection]")
-      end
-
-      @nodelist = @for_block = []
       super
+      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
+    end
+
+    def nodelist
+      @else_block ? [@for_block, @else_block] : [@for_block]
     end
 
     def unknown_tag(tag, markup, tokens)
-      return super unless tag == 'else'
+      return super unless tag == 'else'.freeze
-      @nodelist = @else_block = []
+      @else_block = BlockBody.new
     end
 
     def render(context)
       context.registers[:for] ||= Hash.new(0)
 
-      collection = context[@collection_name]
+      collection = context.evaluate(@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 @attributes['offset'] == 'continue'
+      from = if @from == :continue
         context.registers[:for][@name].to_i
       else
-        context[@attributes['offset']].to_i
+        context.evaluate(@from).to_i
       end
 
-      limit = context[@attributes['limit']]
+      limit = context.evaluate(@limit)
       to    = limit ? limit.to_i + from : nil
 
-
+      segment = Utils.slice_collection(collection, from, to)
-      segment = Utils.slice_collection_using_each(collection, from, to)
 
       return render_else(context) if segment.empty?
 
@@ -101,20 +99,24 @@ 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'] = {
+          context['forloop'.freeze] = {
-            'name'    => @name,
+            'name'.freeze       => @name,
-            'length'  => length,
+            'length'.freeze     => length,
-            'index'   => index + 1, 
+            'index'.freeze      => index + 1,
-            'index0'  => index, 
+            'index0'.freeze     => index,
-            'rindex'  => length - index,
+            'rindex'.freeze     => length - index,
-            'rindex0' => length - index - 1,
+            'rindex0'.freeze    => length - index - 1,
-            'first'   => (index == 0),
+            'first'.freeze      => (index == 0),
-            'last'    => (index == length - 1) }
+            'last'.freeze       => (index == length - 1),
+            'parentloop'.freeze => parent_loop
+          }
 
-          result << render_all(@for_block, context)
+          result << @for_block.render(context)
 
           # Handle any interrupts if they exist.
           if context.has_interrupt?
@@ -127,16 +129,65 @@ module Liquid
       result
     end
 
+    protected
+
+    def lax_parse(markup)
+      if markup =~ Syntax
+        @variable_name = $1
+        collection_name = $2
+        @reversed = $3
+        @name = "#{@variable_name}-#{collection_name}"
+        @collection_name = Expression.parse(collection_name)
+        markup.scan(TagAttributes) do |key, value|
+          set_attribute(key, value)
+        end
+      else
+        raise SyntaxError.new(options[:locale].t("errors.syntax.for".freeze))
+      end
+    end
+
+    def strict_parse(markup)
+      p = Parser.new(markup)
+      @variable_name = p.consume(:id)
+      raise SyntaxError.new(options[:locale].t("errors.syntax.for_invalid_in".freeze))  unless p.id?('in'.freeze)
+      collection_name = p.expression
+      @name = "#{@variable_name}-#{collection_name}"
+      @collection_name = Expression.parse(collection_name)
+      @reversed = p.id?('reversed'.freeze)
+
+      while p.look(:id) && p.look(:colon, 1)
+        unless attribute = p.id?('limit'.freeze) || p.id?('offset'.freeze)
+          raise SyntaxError.new(options[:locale].t("errors.syntax.for_invalid_attribute".freeze))
+        end
+        p.consume
+        set_attribute(attribute, p.expression)
+      end
+      p.consume(:end_of_string)
+    end
+
     private
 
-      def render_else(context)
+    def set_attribute(key, expr)
-        return @else_block ? [render_all(@else_block, context)] : ''
+      case key
+      when 'offset'.freeze
+        @from = if expr == 'continue'.freeze
+          :continue
+        else
+          Expression.parse(expr)
+        end
+      when 'limit'.freeze
+        @limit = Expression.parse(expr)
       end
+    end
 
-      def iterable?(collection)
+    def render_else(context)
-        collection.respond_to?(:each) || Utils.non_blank_string?(collection)
+      @else_block ? @else_block.render(context) : ''.freeze
-      end
+    end
+
+    def iterable?(collection)
+      collection.respond_to?(:each) || Utils.non_blank_string?(collection)
+    end
   end
 
-  Template.register_tag('for', For)
+  Template.register_tag('for'.freeze, For)
 end

lib/liquid/tags/if.rb

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

lib/liquid/tags/ifchanged.rb

@@ -4,17 +4,17 @@ module Liquid
     def render(context)
       context.stack do
 
-        output = render_all(@nodelist, context)
+        output = super
 
         if output != context.registers[:ifchanged]
           context.registers[:ifchanged] = output
           output
         else
-          ''
+          ''.freeze
         end
       end
     end
   end
 
-  Template.register_tag('ifchanged', Ifchanged)  
+  Template.register_tag('ifchanged'.freeze, Ifchanged)
 end

lib/liquid/tags/include.rb

@@ -1,65 +1,99 @@
 module Liquid
+
+  # Include allows templates to relate with other templates
+  #
+  # Simply include another template:
+  #
+  #   {% include 'product' %}
+  #
+  # Include a template with a local variable:
+  #
+  #   {% include 'product' with products[0] %}
+  #
+  # Include a template for a collection:
+  #
+  #   {% include 'product' for products %}
+  #
   class Include < Tag
     Syntax = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?/o
 
-    def initialize(tag_name, markup, tokens)      
+    def initialize(tag_name, markup, options)
+      super
+
       if markup =~ Syntax
 
-        @template_name = $1        
+        template_name = $1
-        @variable_name = $3
+        variable_name = $3
+
+        @variable_name = Expression.parse(variable_name || template_name[1..-2])
+        @context_variable_name = template_name[1..-2].split('/'.freeze).last
+        @template_name = Expression.parse(template_name)
         @attributes    = {}
 
         markup.scan(TagAttributes) do |key, value|
-          @attributes[key] = value
+          @attributes[key] = Expression.parse(value)
         end
 
       else
-        raise SyntaxError.new("Error in tag 'include' - Valid syntax: include '[template]' (with|for) [object|collection]")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.include".freeze))
       end
-
-      super
     end
 
     def parse(tokens)
     end
 
     def render(context)
-      source = _read_template_from_file_system(context)
+      partial = load_cached_partial(context)
-      partial = Liquid::Template.parse(source)
+      variable = context.evaluate(@variable_name)
-      variable = context[@variable_name || @template_name[1..-2]]
 
       context.stack do
         @attributes.each do |key, value|
-          context[key] = context[value]
+          context[key] = context.evaluate(value)
         end
 
         if variable.is_a?(Array)
-          variable.collect do |variable|
+          variable.collect do |var|
-            context[@template_name[1..-2]] = variable
+            context[@context_variable_name] = var
             partial.render(context)
           end
         else
-          context[@template_name[1..-2]] = variable
+          context[@context_variable_name] = variable
           partial.render(context)
         end
       end
     end
 
     private
-      def _read_template_from_file_system(context)
+      def load_cached_partial(context)
+        cached_partials = context.registers[:cached_partials] || {}
+        template_name = context.evaluate(@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)
+        cached_partials[template_name] = partial
+        context.registers[:cached_partials] = cached_partials
+        partial
+      end
+
+      def read_template_from_file_system(context)
         file_system = context.registers[:file_system] || Liquid::Template.file_system
 
-        # make read_template_file call backwards-compatible.
+        file_system.read_template_file(context.evaluate(@template_name))
-        case file_system.method(:read_template_file).arity
+      end
-        when 1
+
-          file_system.read_template_file(context[@template_name])
+      def pass_options
-        when 2
+        dont_pass = @options[:include_options_blacklist]
-          file_system.read_template_file(context[@template_name], context)
+        return {locale: @options[:locale]} if dont_pass == true
-        else
+        opts = @options.merge(included: true, include_options_blacklist: false)
-          raise ArgumentError, "file_system.read_template_file expects two parameters: (template_name, context)"
+        if dont_pass.is_a?(Array)
+          dont_pass.each {|o| opts.delete(o)}
         end
+        opts
       end
   end
 
-  Template.register_tag('include', Include)  
+  Template.register_tag('include'.freeze, Include)
 end

lib/liquid/tags/increment.rb

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

lib/liquid/tags/raw.rb

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

lib/liquid/tags/table_row.rb

@@ -0,0 +1,72 @@
+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
+  end
+
+  Template.register_tag('tablerow'.freeze, TableRow)
+end

lib/liquid/tags/unless.rb

@@ -1,33 +1,31 @@
 require File.dirname(__FILE__) + '/if'
 
 module Liquid
-
   # Unless is a conditional just like 'if' but works on the inverse logic.
   #
-  #   {% unless x < 0 %} x is greater than zero {% end %}
+  #   {% unless x < 0 %} x is greater than zero {% endunless %}
   #
   class Unless < If
     def render(context)
       context.stack do
 
         # First condition is interpreted backwards ( if not )
-        block = @blocks.first
+        first_block = @blocks.first
-        unless block.evaluate(context)
+        unless first_block.evaluate(context)
-          return render_all(block.attachment, context)
+          return first_block.attachment.render(context)
         end
 
         # After the first condition unless works just like if
         @blocks[1..-1].each do |block|
           if block.evaluate(context)
-            return render_all(block.attachment, context)
+            return block.attachment.render(context)
           end
         end
 
-        ''
+        ''.freeze
       end
     end
   end
 
-
+  Template.register_tag('unless'.freeze, Unless)
-  Template.register_tag('unless', Unless)
 end

lib/liquid/template.rb

@@ -14,10 +14,60 @@ module Liquid
   #   template.render('user_name' => 'bob')
   #
   class Template
+    DEFAULT_OPTIONS = {
+      :locale => I18n.new
+    }
+
     attr_accessor :root
+    attr_reader :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
@@ -31,7 +81,15 @@ module Liquid
       end
 
       def tags
-        @tags ||= {}
+        @tags ||= TagRegistry.new
+      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
@@ -40,25 +98,39 @@ module Liquid
         Strainer.global_filter(mod)
       end
 
+      def default_resource_limits
+        @default_resource_limits ||= {}
+      end
+
       # creates a new <tt>Template</tt> object from liquid source code
-      def parse(source)
+      # 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)
+        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)
     end
 
     # Parse source code.
     # Returns self for easy chaining
-    def parse(source)
+    def parse(source, options = {})
-      @root = Document.new(tokenize(source))
+      @options = options
+      @profiling = options[:profile]
+      @line_numbers = options[:line_numbers] || @profiling
+      @root = Document.parse(tokenize(source), DEFAULT_OPTIONS.merge(options))
+      @warnings = nil
       self
     end
 
+    def warnings
+      return [] unless @root
+      @warnings ||= @root.warnings
+    end
+
     def registers
       @registers ||= {}
     end
@@ -80,6 +152,9 @@ 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
@@ -87,17 +162,26 @@ module Liquid
     #    filters and tags and might be useful to integrate liquid more with its host application
     #
     def render(*args)
-      return '' if @root.nil?
+      return ''.freeze if @root.nil?
 
       context = case args.first
       when Liquid::Context
-        args.shift
+        c = args.shift
+
+        if @rethrow_errors
+          c.exception_handler = ->(e) { true }
+        end
+
+        c
+      when Liquid::Drop
+        drop = args.shift
+        drop.context = Context.new([drop, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits)
       when Hash
-        Context.new([args.shift, assigns], instance_assigns, registers, @rethrow_errors)
+        Context.new([args.shift, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits)
       when nil
-        Context.new(assigns, instance_assigns, registers, @rethrow_errors)
+        Context.new(assigns, instance_assigns, registers, @rethrow_errors, @resource_limits)
       else
-        raise ArgumentError, "Expect Hash or Liquid::Context as parameter"
+        raise ArgumentError, "Expected Hash or Liquid::Context as parameter"
       end
 
       case args.last
@@ -112,24 +196,35 @@ 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 a array back here. join will make a string out of it
+        # for performance reasons we get an array back here. join will make a string out of it.
-        result = @root.render(context)
+        result = with_profiling do
+          @root.render(context)
+        end
         result.respond_to?(:join) ? result.join : result
+      rescue Liquid::MemoryError => e
+        context.handle_error(e)
       ensure
         @errors = context.errors
       end
     end
 
     def render!(*args)
-      @rethrow_errors = true; render(*args)
+      @rethrow_errors = true
+      render(*args)
     end
 
     private
@@ -138,7 +233,8 @@ module Liquid
     def tokenize(source)
       source = source.source if source.respond_to?(:source)
       return [] if source.to_s.empty?
-      tokens = source.split(TemplateParser)
+
+      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?
@@ -146,5 +242,32 @@ module Liquid
       tokens
     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

@@ -0,0 +1,18 @@
+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

@@ -1,9 +1,21 @@
 module Liquid
   module Utils
+
+    def self.slice_collection(collection, from, to)
+      if (from != 0 || to != nil) && collection.respond_to?(:load_slice)
+        collection.load_slice(from, to)
+      else
+        slice_collection_using_each(collection, from, to)
+      end
+    end
+
+    def self.non_blank_string?(collection)
+      collection.is_a?(String) && collection != ''.freeze
+    end
+
     def self.slice_collection_using_each(collection, from, to)
       segments = []
       index = 0
-      yielded = 0
 
       # Maintains Ruby 1.8.7 String#each behaviour on 1.9
       return [collection] if non_blank_string?(collection)
@@ -23,9 +35,5 @@ module Liquid
 
       segments
     end
-
-    def self.non_blank_string?(collection)
-      collection.is_a?(String) && collection != ''
-    end
   end
 end

lib/liquid/variable.rb

@@ -11,45 +11,117 @@ module Liquid
   #   {{ user | link }}
   #
   class Variable
-    FilterParser = /(?:#{FilterSeparator}|(?:\s*(?:#{QuotedFragment}|#{ArgumentSeparator})\s*)+)/o
+    FilterParser = /(?:\s+|#{QuotedFragment}|#{ArgumentSeparator})+/o
-    attr_accessor :filters, :name
+    attr_accessor :filters, :name, :warnings
+    attr_accessor :line_number
+    include ParserSwitching
 
-    def initialize(markup)
+    def initialize(markup, options = {})
       @markup  = markup
       @name    = nil
-      @filters = []
+      @options = options || {}
-      if match = markup.match(/\s*(#{QuotedFragment})(.*)/o)
+
-        @name = match[1]
+      parse_with_selected_parser(markup)
-        if match[2].match(/#{FilterSeparator}\s*(.*)/o)
+    end
-          filters = Regexp.last_match(1).scan(FilterParser)
+
+    def raw
+      @markup
+    end
+
+    def markup_context(markup)
+      "in \"{{#{markup}}}\""
+    end
+
+    def lax_parse(markup)
+      @filters ||= []
+      @filters.clear
+      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)
           filters.each do |f|
-            if matches = f.match(/\s*(\w+)(?:\s*#{FilterArgumentSeparator}(.*))?/)
+            if f =~ /\w+/
-              filtername = matches[1]
+              filtername = Regexp.last_match(0)
-              filterargs = matches[2].to_s.scan(/(?:\A|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o).flatten
+              filterargs = f.scan(/(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o).flatten
-              @filters << [filtername, filterargs]
+              @filters << parse_filter_expressions(filtername, filterargs)
             end
           end
         end
       end
     end
 
+    def strict_parse(markup)
+      @filters ||= []
+      @filters.clear
+      p = Parser.new(markup)
+
+      @name = Expression.parse(p.expression)
+      while p.consume?(:pipe)
+        filtername = p.consume(:id)
+        filterargs = p.consume?(:colon) ? parse_filterargs(p) : []
+        @filters << parse_filter_expressions(filtername, filterargs)
+      end
+      p.consume(:end_of_string)
+    end
+
+    def parse_filterargs(p)
+      # first argument
+      filterargs = [p.argument]
+      # followed by comma separated others
+      while p.consume?(:comma)
+        filterargs << p.argument
+      end
+      filterargs
+    end
+
     def render(context)
-      return '' if @name.nil?
+      @filters.inject(context.evaluate(@name)) do |output, (filter_name, filter_args, filter_kwargs)|
-      @filters.inject(context[@name]) do |output, filter|
+        filter_args = evaluate_filter_expressions(context, filter_args, filter_kwargs)
-        filterargs = []
+        output = context.invoke(filter_name, output, *filter_args)
-        keyword_args = {}
+      end.tap{ |obj| taint_check(obj) }
-        filter[1].to_a.each do |a|
+    end
-          if matches = a.match(/\A#{TagAttributes}\z/o)
+
-            keyword_args[matches[1]] = context[matches[2]]
+    private
-          else
+
-            filterargs << context[a]
+    def parse_filter_expressions(filter_name, unparsed_args)
-          end
+      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)
         end
-        filterargs << keyword_args unless keyword_args.empty?
+      end
-        begin
+      result = [filter_name, filter_args]
-          output = context.invoke(filter[0], output, *filterargs)
+      result << keyword_args unless keyword_args.empty?
-        rescue FilterNotFound
+      result
-          raise FilterNotFound, "Error - filter '#{filter[0]}' in '#{@markup.strip}' could not be found."
+    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"
         end
       end
     end

lib/liquid/variable_lookup.rb

@@ -0,0 +1,79 @@
+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.parse($1)
+      end
+      @name = name
+
+      @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
+
+    protected
+
+    def state
+      [@name, @lookups, @command_flags]
+    end
+  end
+end

lib/liquid/version.rb

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

liquid.gemspec

@@ -1,13 +1,18 @@
 # encoding: utf-8
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require "liquid/version"
 
 Gem::Specification.new do |s|
   s.name        = "liquid"
-  s.version     = "2.5.0"
+  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 Luetke"]
+  s.authors     = ["Tobias Lütke"]
   s.email       = ["tobi@leetsoft.com"]
   s.homepage    = "http://www.liquidmarkup.org"
+  s.license     = "MIT"
   #s.description = "A secure, non-evaling end user template engine with aesthetic markup."
 
   s.required_rubygems_version = ">= 1.3.7"
@@ -18,4 +23,7 @@ Gem::Specification.new do |s|
   s.extra_rdoc_files  = ["History.md", "README.md"]
 
   s.require_path = "lib"
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'minitest'
 end

performance/benchmark.rb

@@ -1,11 +1,17 @@
-require 'rubygems'
+require 'benchmark/ips'
-require 'benchmark'
 require File.dirname(__FILE__) + '/theme_runner'
 
+Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
 profiler = ThemeRunner.new
 
-Benchmark.bmbm do |x|
+Benchmark.ips do |x|
-  x.report("parse:")   { 100.times { profiler.compile } }
+  x.time = 60
-  x.report("parse & run:")   { 100.times { profiler.run } }
+  x.warmup = 5
-end
 
+  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 }
+end

performance/memory.rb

@@ -0,0 +1,19 @@
+at_exit do
+  p 'Objects distribution:'
+  require 'pp'
+  pp ObjectSpace.count_objects
+end
+
+require 'allocation_tracer' rescue fail("install allocation_tracer extension/gem")
+require File.dirname(__FILE__) + '/theme_runner'
+
+Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
+profiler = ThemeRunner.new
+
+require 'allocation_tracer/trace'
+
+puts "Profiling memory usage..."
+
+200.times do
+  profiler.run
+end

performance/profile.rb

@@ -1,19 +1,24 @@
-require 'rubygems'
+require 'stackprof' rescue fail("install stackprof extension/gem")
-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
 
-puts 'Running profiler...'
+[: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
 
-results  = profiler.run
+  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
 
-puts 'Success'
+  StackProf::Report.new(results).print_text(false, 20)
-puts
+  File.write(ENV['FILENAME'] + "." + profile_type.to_s, Marshal.dump(results)) if ENV['FILENAME']
-
-[RubyProf::FlatPrinter, RubyProf::GraphPrinter, RubyProf::GraphHtmlPrinter, RubyProf::CallTreePrinter].each do |klass|
-  filename = (ENV['TMP'] || '/tmp') + (klass.name.include?('Html') ? "/liquid.#{klass.name.downcase}.html" : "/callgrind.liquid.#{klass.name.downcase}.txt")
-  filename.gsub!(/:+/, '_')
-  File.open(filename, "w+") { |fp| klass.new(results).print(fp, :print_file => true) }
-  $stderr.puts "wrote #{klass.name} output to #{filename}"
 end

performance/shopify/comment_form.rb

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

performance/shopify/database.rb

@@ -1,6 +1,6 @@
 require 'yaml'
-module Database
 
+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,7 +1,9 @@
+require 'json'
+
 module JsonFilter
 
   def json(object)
-    object.reject {|k,v| k == "collections" }.to_json
+    JSON.dump(object.reject {|k,v| k == "collections" })
   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, tokens)
+  def initialize(tag_name, markup, options)
-    @nodelist = []
+    super
 
     if markup =~ Syntax
       @collection_name = $1
@@ -19,8 +19,6 @@ 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)
@@ -73,7 +71,7 @@ class Paginate < Liquid::Block
         end
       end
 
-      render_all(@nodelist, context)
+      super
     end
   end
 

performance/shopify/shop_filter.rb

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

performance/tests/dropify/article.liquid

@@ -17,14 +17,14 @@
   <ul id="comment-list">
   {% for comment in article.comments %}
     <li>
-  	  <div class="comment-details">
+      <div class="comment-details">
-  		  <span class="comment-author">{{ comment.author }}</span> said on <span class="comment-date">{{ comment.created_at | date: "%B %d, %Y" }}</span>:
+        <span class="comment-author">{{ comment.author }}</span> said on <span class="comment-date">{{ comment.created_at | date: "%B %d, %Y" }}</span>:
       </div>
 
       <div class="comment">
         {{ comment.content }}
       </div>
-  	</li>
+    </li>
   {% endfor %}
   </ul>
 

performance/tests/dropify/blog.liquid

@@ -10,7 +10,7 @@
       <h3 class="title">
         <a href="{{article.url}}">{{ article.title }}</a>
       </h3>
-  		<h4 class="date">Posted on {{ article.created_at | date: "%B %d, '%y" }} by {{ article.author }}.</h4>
+      <h4 class="date">Posted on {{ article.created_at | date: "%B %d, '%y" }} by {{ article.author }}.</h4>
       </div>
 
       <div class="article-body textile">

performance/tests/dropify/cart.liquid

@@ -20,17 +20,17 @@
       {% for item in cart.items %}
       <li id="item-{{item.id}}" class="clearfix">
         <div class="thumb">
-				  <div class="prodimage">
+          <div class="prodimage">
           <a href="{{item.product.url}}" title="View {{item.title}} Page"><img src="{{item.product.featured_image | product_img_url: 'thumb' }}" alt="{{item.title | escape }}" /></a>
         </div></div>
         <h3 style="padding-right: 150px">
-			<a href="{{item.product.url}}" title="View {{item.title | escape }} Page">
+      <a href="{{item.product.url}}" title="View {{item.title | escape }} Page">
-				{{ item.title }}
+        {{ item.title }}
-				{% if item.variant.available == true %}
+        {% if item.variant.available == true %}
-				   ({{item.variant.title}})
+           ({{item.variant.title}})
-				{% endif %}
+        {% endif %}
-			</a>	
+      </a>
-		</h3>
+    </h3>
         <small class="itemcost">Costs {{ item.price | money }} each, <span class="money">{{item.line_price | money }}</span> total.</small>
         <p class="right">
           <label for="updates">How many? </label>
@@ -49,10 +49,10 @@
   </div>
 
     <div class="info">
-		<input type="image" value="Checkout!" name="checkout" src="{{ 'checkout.gif' | asset_url }}" />
+    <input type="image" value="Checkout!" name="checkout" src="{{ 'checkout.gif' | asset_url }}" />
     </div>
 
-  	{% if additional_checkout_buttons %}
+    {% if additional_checkout_buttons %}
     <div class="additional-checkout-buttons">
       <p>- or -</p>
       {{ content_for_additional_checkout_buttons }}

performance/tests/dropify/collection.liquid

@@ -9,7 +9,7 @@
       <div class="description">
         <h3><a href="{{product.url}}">{{product.title}}</a></h3>
         <p>{{ product.description | strip_html | truncatewords: 35 }}</p>
-  	  <p class="money">{{ product.price_min | money }}{% if product.price_varies %} - {{ product.price_max | money }}{% endif %}</p>
+      <p class="money">{{ product.price_min | money }}{% if product.price_varies %} - {{ product.price_max | money }}{% endif %}</p>
      </div>
     </li>
     {% endfor %}

performance/tests/dropify/index.liquid

@@ -5,7 +5,7 @@
    <a href="{{ product.url }}"><img src="{{ product.featured_image | product_img_url: 'small' }}" alt="{{ product.title | escape }}" /></a>
    <h3><a href="{{ product.url }}">{{ product.title }}</a></h3>
    <div class="description">{{ product.description | strip_html | truncatewords: 18 }}</div>
-	<p class="money">{{ product.price_min | money }}</p>
+  <p class="money">{{ product.price_min | money }}</p>
   </div>
 {% endfor %}
 {% for product in collections.frontpage.products offset:1 %}
@@ -18,30 +18,30 @@
 </div></div></div>
 
 <div id="mainarticle">
-	{% assign article = pages.frontpage %}
+  {% assign article = pages.frontpage %}
 
   {% if article.content != "" %}
-	  <h2>{{ article.title }}</h2>
+    <h2>{{ article.title }}</h2>
     <div class="article-body textile">
-		  {{ article.content }}
+      {{ article.content }}
-		</div>
-	{% else %}
-    <div class="article-body textile">
-	  In <em>Admin &gt; Blogs &amp; Pages</em>, create a page with the handle <strong><code>frontpage</code></strong> and it will show up here.<br />
-	  {{ "Learn more about handles" | link_to "http://wiki.shopify.com/Handle" }}
     </div>
-	{% endif %}
+  {% else %}
+    <div class="article-body textile">
+    In <em>Admin &gt; Blogs &amp; Pages</em>, create a page with the handle <strong><code>frontpage</code></strong> and it will show up here.<br />
+    {{ "Learn more about handles" | link_to: "http://wiki.shopify.com/Handle" }}
+    </div>
+  {% endif %}
 
 </div>
 <br style="clear: both;" />
 <div id="articles">
   {% for article in blogs.news.articles offset:1  %}
     <div class="article">
-		<h2>{{ article.title }}</h2>
+    <h2>{{ article.title }}</h2>
-		<div class="article-body textile">
+    <div class="article-body textile">
-		  {{ article.content }}
+      {{ article.content }}
-		</div>    
+    </div>
-	</div>
+  </div>
   {% endfor %}
 </div>
 

performance/tests/dropify/product.liquid

@@ -1,18 +1,18 @@
 <div id="productpage">
 
-	<div id="productimages"><div id="productimages-top"><div id="productimages-bottom">
+  <div id="productimages"><div id="productimages-top"><div id="productimages-bottom">
-		{% for image in product.images %}
+    {% for image in product.images %}
-			{% if forloop.first %}
+      {% if forloop.first %}
-				<a href="{{ image | product_img_url: 'large' }}" class="productimage" rel="lightbox">
+        <a href="{{ image | product_img_url: 'large' }}" class="productimage" rel="lightbox">
-				  <img src="{{ image | product_img_url: 'medium'}}" alt="{{product.title | escape }}" />
+          <img src="{{ image | product_img_url: 'medium'}}" alt="{{product.title | escape }}" />
-				</a>
+        </a>
-			{% else %}
+      {% else %}
-				<a href="{{ image | product_img_url: 'large' }}" class="productimage-small" rel="lightbox">
+        <a href="{{ image | product_img_url: 'large' }}" class="productimage-small" rel="lightbox">
-				  <img src="{{ image | product_img_url: 'small'}}" alt="{{product.title | escape }}" />
+          <img src="{{ image | product_img_url: 'small'}}" alt="{{product.title | escape }}" />
-				</a>
+        </a>
-			{% endif %}
+      {% endif %}
-		{% endfor %}
+    {% endfor %}
-	</div></div></div>
+  </div></div></div>
 
   <h2>{{ product.title }}</h2>
 
@@ -26,15 +26,15 @@
   <div id="variant-add">
     <form action="/cart/add" method="post">
 
-			<select id="variant-select" name="id" class="product-info-options">
+      <select id="variant-select" name="id" class="product-info-options">
         {% for variant in product.variants %}
           <option value="{{ variant.id }}">{{ variant.title }} - {{ variant.price | money }}</option>
         {% endfor %}
-			</select>
+      </select>
 
-			<div id="price-field" class="price"></div>
+      <div id="price-field" class="price"></div>
 
-		<div style="text-align:center;"><input type="image" name="add" value="Add to Cart" id="add" src="{{ 'addtocart.gif' | asset_url }}" /></div>
+    <div style="text-align:center;"><input type="image" name="add" value="Add to Cart" id="add" src="{{ 'addtocart.gif' | asset_url }}" /></div>
     </form>
   </div>
 

performance/tests/dropify/theme.liquid

@@ -1,67 +1,67 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-	"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
-	<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+  <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
-	<title>{{shop.name}} - {{page_title}}</title>
+  <title>{{shop.name}} - {{page_title}}</title>
 
-	{{ 'textile.css'  | global_asset_url | stylesheet_tag }}
+  {{ 'textile.css'  | global_asset_url | stylesheet_tag }}
   {{ 'lightbox/v204/lightbox.css' | global_asset_url | stylesheet_tag }}
 
-	{{ 'prototype/1.6/prototype.js' | global_asset_url  | script_tag }}
+  {{ 'prototype/1.6/prototype.js' | global_asset_url  | script_tag }}
   {{ 'scriptaculous/1.8.2/scriptaculous.js' | global_asset_url  | script_tag }}
   {{ 'lightbox/v204/lightbox.js'  | global_asset_url  | script_tag }}
   {{ 'option_selection.js'        | shopify_asset_url | script_tag }}
 
-	{{ 'layout.css'   | asset_url | stylesheet_tag }}
+  {{ 'layout.css'   | asset_url | stylesheet_tag }}
-	{{ 'shop.js'      | asset_url | script_tag }}
+  {{ 'shop.js'      | asset_url | script_tag }}
 
-	{{ content_for_header }}
+  {{ content_for_header }}
 </head>
 
 <body id="page-{{template}}">
 
-	<p class="hide"><a href="#rightsiders">Skip to navigation.</a></p>
+  <p class="hide"><a href="#rightsiders">Skip to navigation.</a></p>
-		<!-- mini cart -->
+    <!-- mini cart -->
         {% if cart.item_count > 0 %}
-			<div id="minicart" style="display:none;"><div id="minicart-inner">
+      <div id="minicart" style="display:none;"><div id="minicart-inner">
-			<div id="minicart-items">
+      <div id="minicart-items">
-			<h2>There {{ cart.item_count | pluralize: 'is', 'are' }} {{ cart.item_count }} {{ cart.item_count | pluralize: 'item', 'items' }} in <a href="/cart" title="View your cart">your cart</a>!</h2><h4 style="font-size: 16px; margin: 0 0 10px 0; padding: 0;">Your subtotal is {{ cart.total_price | money }}.</h4>
+      <h2>There {{ cart.item_count | pluralize: 'is', 'are' }} {{ cart.item_count }} {{ cart.item_count | pluralize: 'item', 'items' }} in <a href="/cart" title="View your cart">your cart</a>!</h2><h4 style="font-size: 16px; margin: 0 0 10px 0; padding: 0;">Your subtotal is {{ cart.total_price | money }}.</h4>
-			  {% for item in cart.items %}
+        {% for item in cart.items %}
-				<div class="thumb">
+        <div class="thumb">
-				  <div class="prodimage"><a href="{{item.product.url}}" onMouseover="tooltip('{{ item.quantity }} x {{ item.title }} ({{ item.variant.title }})', 200)"; onMouseout="hidetooltip()"><img src="{{ item.product.featured_image | product_img_url: 'thumb' }}" /></a></div>
+          <div class="prodimage"><a href="{{item.product.url}}" onMouseover="tooltip('{{ item.quantity }} x {{ item.title }} ({{ item.variant.title }})', 200)"; onMouseout="hidetooltip()"><img src="{{ item.product.featured_image | product_img_url: 'thumb' }}" /></a></div>
-				</div>
+        </div>
-			  {% endfor %}
+        {% endfor %}
-			  </div>
+        </div>
-			 <br style="clear:both;" />
+       <br style="clear:both;" />
-			</div></div>
+      </div></div>
         {% endif %}
 
   <div id="container">
-  	<div id="header">
+    <div id="header">
-  	  <!-- Begin Header -->
+      <!-- Begin Header -->
         <h1 id="logo"><a href="/" title="Go Home">{{shop.name}}</a></h1>
       <div id="cartlinks">
         {% if cart.item_count > 0 %}
           <h2 id="cartcount"><a href="/cart" onMouseover="tooltip('There {{ cart.item_count | pluralize: 'is', 'are' }} {{ cart.item_count }} {{ cart.item_count | pluralize: 'item', 'items' }} in your cart!', 200)"; onMouseout="hidetooltip()">{{ cart.item_count }} {{ cart.item_count | pluralize: 'thing', 'things' }}!</a></h2>
-		  <a href="/cart" id="minicartswitch" onclick="superSwitch(this, 'minicart', 'Close Mini Cart'); return false;" id="cartswitch">View Mini Cart ({{ cart.total_price | money }})</a>
+      <a href="/cart" id="minicartswitch" onclick="superSwitch(this, 'minicart', 'Close Mini Cart'); return false;" id="cartswitch">View Mini Cart ({{ cart.total_price | money }})</a>
         {% endif %}
       </div>
       <!-- End Header -->
 
-  	</div>
+    </div>
-	<hr />
+  <hr />
 <div id="main">
 
-  	<div id="content">
+    <div id="content">
-		<div id="innercontent">
+    <div id="innercontent">
-		  {{ content_for_layout }}
+      {{ content_for_layout }}
-	  	</div>
+      </div>
-  	</div>
+    </div>
 
-	<hr />
+  <hr />
-  	<div id="rightsiders">
+    <div id="rightsiders">
 
       <ul class="rightlinks">
         {% for link in linklists.main-menu.links %}
@@ -83,18 +83,18 @@
         {% endfor %}
       </ul>
 
-  	</div>
+    </div>
 
-	<hr /><br style="clear:both;" />
+  <hr /><br style="clear:both;" />
 
-	  <div id="footer">
+    <div id="footer">
-	  	<div class="footerinner">
+      <div class="footerinner">
-			All prices are in {{ shop.currency }}. 
+      All prices are in {{ shop.currency }}.
-			Powered by <a href="http://www.shopify.com" title="Shopify, Hosted E-Commerce">Shopify</a>.
+      Powered by <a href="http://www.shopify.com" title="Shopify, Hosted E-Commerce">Shopify</a>.
-		</div>
+    </div>
-	  </div>
+    </div>
 
-	</div>
+  </div>
 </div>
 
 <div id="tooltip"></div>

performance/tests/ripen/article.liquid

@@ -21,10 +21,10 @@
         {{ comment.content }}
       </div>
 
-  	  <div class="comment-details">
+      <div class="comment-details">
-  		  Posted by {{ comment.author }} on {{ comment.created_at | date: "%B %d, %Y" }}
+        Posted by {{ comment.author }} on {{ comment.created_at | date: "%B %d, %Y" }}
       </div>
-  	</li>
+    </li>
   {% endfor %}
   </ul>
 

performance/tests/ripen/cart.liquid

@@ -9,7 +9,7 @@
 
   {% if cart.item_count == 0 %}
     <p>Your shopping cart is empty...</p>
-	<p><a href="/"><img src="{{ 'continue_shopping_icon.gif' | asset_url }}" alt="Continue shopping"/></a><p>
+  <p><a href="/"><img src="{{ 'continue_shopping_icon.gif' | asset_url }}" alt="Continue shopping"/></a><p>
   {% else %}
 
   <form action="/cart" method="post" id="cart">
@@ -26,21 +26,21 @@
       {% for item in cart.items %}
       <tr class="{% cycle 'odd', 'even' %}">
         <td class="short">{{ item.product.featured_image |  product_img_url: 'thumb' | img_tag }}</td>
-		<td><a href="{{item.product.url}}">{{ item.title }}</a></td>
+    <td><a href="{{item.product.url}}">{{ item.title }}</a></td>
         <td class="short"><input type="text" class="quantity" name="updates[{{item.variant.id}}]" id="updates_{{item.variant.id}}" value="{{item.quantity}}" onfocus="this.select();"/></td>
         <td class="cart-price">{{ item.price | money }}</td>
         <td class="cart-price">{{item.line_price | money }}</td>
         <td class="short"><a href="#" onclick="remove_item({{item.variant.id}}); return false;" class="remove"><img src="{{ 'cancel_icon.gif' | asset_url }}" alt="Remove" /></a></td>
       </tr>
       {% endfor %}
-  	</table>  
+    </table>
-		<p class="updatebtn"><input type="image" value="Update Cart" name="update" src="{{ 'update_icon.gif' | asset_url }}" alt="Update" /></p>
+    <p class="updatebtn"><input type="image" value="Update Cart" name="update" src="{{ 'update_icon.gif' | asset_url }}" alt="Update" /></p>
-		<p class="subtotal">
+    <p class="subtotal">
-		<strong>Subtotal:</strong> {{cart.total_price | money_with_currency }}
+    <strong>Subtotal:</strong> {{cart.total_price | money_with_currency }}
-		</p>
+    </p>
     <p class="checkout"><input type="image" src="{{ 'checkout_icon.gif' | asset_url }}" alt="Proceed to Checkout" value="Proceed to Checkout" name="checkout"  /></p>
 
-		{% if additional_checkout_buttons %}
+    {% if additional_checkout_buttons %}
     <div class="additional-checkout-buttons">
       <p>- or -</p>
       {{ content_for_additional_checkout_buttons }}

performance/tests/ripen/collection.liquid

@@ -15,7 +15,7 @@
       <div class="prod-list-description">
         <h3><a href="{{product.url}}">{{product.title}}</a></h3>
         <p>{{ product.description | strip_html | truncatewords: 35 }}</p>
-  	  <p class="prd-price">{{ product.price_min | money }}{% if product.price_varies %} - {{ product.price_max | money }}{% endif %}</p>
+      <p class="prd-price">{{ product.price_min | money }}{% if product.price_varies %} - {{ product.price_max | money }}{% endif %}</p>
      </div>
     </li>
     {% endfor %}

performance/tests/ripen/index.liquid

@@ -1,32 +1,32 @@
 <div id="home-page">
-	<h3 class="heading-shaded">Featured products...</h3>
+  <h3 class="heading-shaded">Featured products...</h3>
-	<div class="featured-prod-row clearfix">
+  <div class="featured-prod-row clearfix">
-		{% for product in collections.frontpage.products %}
+    {% for product in collections.frontpage.products %}
-			<div class="featured-prod-item">
+      <div class="featured-prod-item">
-			    <p>
+          <p>
-				<a href="{{product.url}}"><img src="{{ product.featured_image | product_img_url: 'small' }}" alt="{{ product.title | escape }}"/></a>	
+        <a href="{{product.url}}"><img src="{{ product.featured_image | product_img_url: 'small' }}" alt="{{ product.title | escape }}"/></a>
-				</p>
+        </p>
-				<h4><a href="{{product.url}}">{{product.title}}</a></h4>
+        <h4><a href="{{product.url}}">{{product.title}}</a></h4>
-				{% if product.compare_at_price %} 
+        {% if product.compare_at_price %}
-					{% if product.price_min != product.compare_at_price %}
+          {% if product.price_min != product.compare_at_price %}
-						<p class="prd-price">Was:<del>{{product.compare_at_price | money}}</del></p>
+            <p class="prd-price">Was:<del>{{product.compare_at_price | money}}</del></p>
-						<p class="prd-price"><ins>Now: {{product.price_min | money}}</ins></p>
+            <p class="prd-price"><ins>Now: {{product.price_min | money}}</ins></p>
-					{% endif %}
+          {% endif %}
-				{% else %}
+        {% else %}
-					<p class="prd-price"><ins>{{product.price_min | money}}</ins></p>
+          <p class="prd-price"><ins>{{product.price_min | money}}</ins></p>
-				{% endif %}
+        {% endif %}
-			</div>
+      </div>
-		{% endfor %}
+    {% endfor %}
-	</div>
+  </div>
 
-	<div id="articles">
+  <div id="articles">
-  	{% assign article = pages.frontpage %}
+    {% assign article = pages.frontpage %}
     {% if article.content != "" %}
-		  <h3>{{ article.title }}</h3>
+      <h3>{{ article.title }}</h3>
-  		{{ article.content }}
+      {{ article.content }}
-  	{% else %}
+    {% else %}
-  	  In <em>Admin &gt; Blogs &amp; Pages</em>, create a page with the handle <strong><code>frontpage</code></strong> and it will show up here.<br />
+      In <em>Admin &gt; Blogs &amp; Pages</em>, create a page with the handle <strong><code>frontpage</code></strong> and it will show up here.<br />
-  	  {{ "Learn more about handles" | link_to "http://wiki.shopify.com/Handle" }}
+      {{ "Learn more about handles" | link_to: "http://wiki.shopify.com/Handle" }}
-  	{% endif %}
+    {% endif %}
-	</div>
+  </div>
 </div>

performance/tests/ripen/product.liquid

@@ -1,31 +1,31 @@
 <div id="product-page">
-	<h2 class="heading-shaded">{{ product.title }}</h2>
+  <h2 class="heading-shaded">{{ product.title }}</h2>
-	<div id="product-details">
+  <div id="product-details">
-	<div id="product-images">
+  <div id="product-images">
-		{% for image in product.images %}
+    {% for image in product.images %}
-			{% if forloop.first %}
+      {% if forloop.first %}
-				<a href="{{ image | product_img_url: 'large' }}" class="product-image" rel="lightbox[ product]" title="">
+        <a href="{{ image | product_img_url: 'large' }}" class="product-image" rel="lightbox[ product]" title="">
-				  <img src="{{ image | product_img_url: 'medium'}}" alt="{{product.title | escape }}" />
+          <img src="{{ image | product_img_url: 'medium'}}" alt="{{product.title | escape }}" />
-				</a>
+        </a>
-			{% else %}
+      {% else %}
-				<a href="{{ image | product_img_url: 'large' }}" class="product-image-small" rel="lightbox[ product]" title="">
+        <a href="{{ image | product_img_url: 'large' }}" class="product-image-small" rel="lightbox[ product]" title="">
-				  <img src="{{ image | product_img_url: 'small'}}" alt="{{product.title | escape }}" />
+          <img src="{{ image | product_img_url: 'small'}}" alt="{{product.title | escape }}" />
-				</a>
+        </a>
-			{% endif %}
+      {% endif %}
-		{% endfor %}
+    {% endfor %}
-	</div>
+  </div>
 
-	<ul id="product-info">
+  <ul id="product-info">
-		<li>Vendor: {{ product.vendor | link_to_vendor }}</li>
+    <li>Vendor: {{ product.vendor | link_to_vendor }}</li>
-		<li>Type: {{ product.type | link_to_type }}</li>
+    <li>Type: {{ product.type | link_to_type }}</li>
-	  </ul>
+    </ul>
 
-	  <small>{{ product.price_min | money }}{% if product.price_varies %} - {{ product.price_max | money }}{% endif %}</small>
+    <small>{{ product.price_min | money }}{% if product.price_varies %} - {{ product.price_max | money }}{% endif %}</small>
 
-	  <div id="product-options">
+    <div id="product-options">
               {% if product.available %}
 
-		<form action="/cart/add" method="post">
+    <form action="/cart/add" method="post">
 
       <select id="product-select" name='id'>
         {% for variant in product.variants %}
@@ -35,16 +35,16 @@
 
       <div id="price-field"></div>
 
-			<div class="add-to-cart"><input type="image" name="add" value="Add to Cart" id="add" src="{{ 'add-to-cart.gif' | asset_url }}" /></div>
+      <div class="add-to-cart"><input type="image" name="add" value="Add to Cart" id="add" src="{{ 'add-to-cart.gif' | asset_url }}" /></div>
-		</form>
+    </form>
               {% else %}
                   <span>Sold Out!</span>
               {% endif %}
-	  </div>
+    </div>
 
-	  <div class="product-description">
+    <div class="product-description">
-		{{ product.description }}
+    {{ product.description }}
-	  </div>
+    </div>
   </div>
 </div>
 

performance/tests/ripen/theme.liquid

@@ -2,15 +2,15 @@
 <html xmlns="http://www.w3.org/1999/xhtml" lang="en">
 <head>
   <title>{{shop.name}} - {{page_title}}</title>
-	<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
 
   {{ 'main.css'     | asset_url | stylesheet_tag }}
-	{{ 'shop.js'      | asset_url | script_tag }}
+  {{ 'shop.js'      | asset_url | script_tag }}
 
-	{{ 'mootools.js'         | asset_url         | script_tag }}
+  {{ 'mootools.js'         | asset_url         | script_tag }}
-	{{ 'slimbox.js'          | asset_url         | script_tag }}
+  {{ 'slimbox.js'          | asset_url         | script_tag }}
   {{ 'option_selection.js' | shopify_asset_url | script_tag }}
-	{{ 'slimbox.css'         | asset_url         | stylesheet_tag }}
+  {{ 'slimbox.css'         | asset_url         | stylesheet_tag }}
 
   {{ content_for_header }}
  </head>
@@ -18,67 +18,67 @@
 <body id="page-{{template}}">
 <p class="hide"><a href="#navigation">Skip to navigation.</a></p>
 <div id="wrapper">
-	<div class="content clearfix">	
+  <div class="content clearfix">
-		<div id="header">
+    <div id="header">
-			<h2><a href="/">{{shop.name}}</a></h2>
+      <h2><a href="/">{{shop.name}}</a></h2>
-		</div>
+    </div>
-		<div id="left-col">
+    <div id="left-col">
-			{{ content_for_layout }} 
+      {{ content_for_layout }}
-		</div>
+    </div>
-		<div id="right-col">
+    <div id="right-col">
-			{% if template != 'cart' %}
+      {% if template != 'cart' %}
-			    <div id="cart-right-col">
+          <div id="cart-right-col">
-					<dl id="cart-right-col-info">
+          <dl id="cart-right-col-info">
-						<dt>Shopping Cart</dt>
+            <dt>Shopping Cart</dt>
-						<dd>
+            <dd>
-						{% if cart.item_count != 0 %}
+            {% if cart.item_count != 0 %}
-							<a href="/cart">{{ cart.item_count }} {{ cart.item_count | pluralize: 'item', 'items' }}</a> in your cart
+              <a href="/cart">{{ cart.item_count }} {{ cart.item_count | pluralize: 'item', 'items' }}</a> in your cart
-						{% else %}
+            {% else %}
-							Your cart is empty
+              Your cart is empty
-						{% endif %}
+            {% endif %}
-						</dd>
+            </dd>
-					</dl>
+          </dl>
-				</div>
+        </div>
-			{% endif %}
+      {% endif %}
-			<div id="search">
+      <div id="search">
-				<dl id="searchbox">
+        <dl id="searchbox">
-				<dt>Search</dt>
+        <dt>Search</dt>
-				<dd>
+        <dd>
-				<form action="/search" method="get">
+        <form action="/search" method="get">
-				<fieldset>
+        <fieldset>
-				<input class="search-input" type="text" onclick="this.select()" value="Search this shop..." name="q" />
+        <input class="search-input" type="text" onclick="this.select()" value="Search this shop..." name="q" />
-				</fieldset>
+        </fieldset>
-				</form>
+        </form>
-				</dd>
+        </dd>
-				</dl>
+        </dl>
-			</div>
+      </div>
-			<div id="navigation">
+      <div id="navigation">
-				<dl class="navbar">
+        <dl class="navbar">
-				<dt>Navigation</dt>
+        <dt>Navigation</dt>
-				{% for link in linklists.main-menu.links %}
+        {% for link in linklists.main-menu.links %}
-					<dd>{{ link.title | link_to: link.url }}</dd>
+          <dd>{{ link.title | link_to: link.url }}</dd>
-				{% endfor %}
+        {% endfor %}
-				</dl>
+        </dl>
 
-				{% if tags %}
+        {% if tags %}
-				<dl class="navbar">
+        <dl class="navbar">
-				<dt>Tags</dt>
+        <dt>Tags</dt>
-  				{% for tag in collection.tags %} 
+          {% for tag in collection.tags %}
-					<dd>{{ tag | highlight_active_tag | link_to_tag: tag }}</dd>
+          <dd>{{ tag | highlight_active_tag | link_to_tag: tag }}</dd>
-  				{% endfor %}
+          {% endfor %}
-  				</dl>
+          </dl>
-				{% endif %}
+        {% endif %}
-			</div>
+      </div>
-		</div>
+    </div>
 
-	</div>
+  </div>
     <div id="content-padding"></div>
 </div>
 
 <div id="footer">
-	{% for link in linklists.footer.links %}
+  {% for link in linklists.footer.links %}
-	{{ link.title | link_to: link.url }} {% if forloop.rindex != 1 %} | {% endif %}
+  {{ link.title | link_to: link.url }} {% if forloop.rindex != 1 %} | {% endif %}
-	{% endfor %}
+  {% endfor %}
 </div>
 
 </body>

performance/tests/tribble/404.liquid

@@ -1,56 +1,56 @@
-	<div id="page" class="innerpage clearfix">
+  <div id="page" class="innerpage clearfix">
 
-		<div id="text-page">			
+    <div id="text-page">
-			<div class="entry">
+      <div class="entry">
-				<h1>Oh no!</h1>
+        <h1>Oh no!</h1>
-				<div class="entry-post">
+        <div class="entry-post">
-					Seems like you are looking for something that just isn't here. <a href="/">Try heading back to our main page</a>. Or you can checkout some of our featured products below.
+          Seems like you are looking for something that just isn't here. <a href="/">Try heading back to our main page</a>. Or you can checkout some of our featured products below.
-				</div>
+        </div>
-			</div>
+      </div>
-		</div>
+    </div>
 
 
-		<h1>Featured Products</h1>	
+    <h1>Featured Products</h1>
-		<ul class="item-list clearfix">
+    <ul class="item-list clearfix">
 
-			{% for product in collections.frontpage.products %}
+      {% for product in collections.frontpage.products %}
-			<li>
+      <li>
-				<form action="/cart/add" method="post">
+        <form action="/cart/add" method="post">
-				<div class="item-list-item">					
+        <div class="item-list-item">
-					<div class="ili-top clearfix">
+          <div class="ili-top clearfix">
-						<div class="ili-top-content">
+            <div class="ili-top-content">
-							<h2><a href="{{product.url}}">{{product.title}}</a></h2>
+              <h2><a href="{{product.url}}">{{product.title}}</a></h2>
-							<p>{{ product.description | truncatewords: 15 }}</p>
+              <p>{{ product.description | truncatewords: 15 }}</p>
-						</div>						
+            </div>
-						<a href="{{product.url}}" class="ili-top-image"><img src="{{ product.featured_image | product_img_url: 'small' }}" alt="{{ product.title | escape }}"/></a>	
+            <a href="{{product.url}}" class="ili-top-image"><img src="{{ product.featured_image | product_img_url: 'small' }}" alt="{{ product.title | escape }}"/></a>
-					</div>
+          </div>
 
-					<div class="ili-bottom clearfix">
+          <div class="ili-bottom clearfix">
-						<p class="hiddenvariants" style="display: none">{% for variant in product.variants %}<span><input type="radio" name="id" value="{{variant.id}}" id="radio_{{variant.id}}" style="vertical-align: middle;" {%if forloop.first%} checked="checked" {%endif%} /><label for="radio_{{variant.id}}">{{ variant.price | money_with_currency }} - {{ variant.title }}</label></span>{% endfor %}</p>
+            <p class="hiddenvariants" style="display: none">{% for variant in product.variants %}<span><input type="radio" name="id" value="{{variant.id}}" id="radio_{{variant.id}}" style="vertical-align: middle;" {%if forloop.first%} checked="checked" {%endif%} /><label for="radio_{{variant.id}}">{{ variant.price | money_with_currency }} - {{ variant.title }}</label></span>{% endfor %}</p>
-						<input type="submit" class="" value="Add to Basket" />
+            <input type="submit" class="" value="Add to Basket" />
-						<p>
+            <p>
-							<a href="{{product.url}}">View Details</a>	
+              <a href="{{product.url}}">View Details</a>
 
-							<span>
+              <span>
-								{% if product.compare_at_price %} 			  
+                {% if product.compare_at_price %}
-									{% if product.price_min != product.compare_at_price %}			    
+                  {% if product.price_min != product.compare_at_price %}
-										{{product.compare_at_price | money}} -
+                    {{product.compare_at_price | money}} -
-			  						{% endif %}
+                    {% endif %}
-								{% endif %}
+                {% endif %}
-								<strong>
+                <strong>
-									{{product.price_min | money}}
+                  {{product.price_min | money}}
-								</strong>
+                </strong>
-							</span>
+              </span>
-						</p>
+            </p>
-					</div>
+          </div>
-				</div>
+        </div>
-				</form>
+        </form>
-			</li>
+      </li>
-			{% endfor %}
+      {% endfor %}
 
-		</ul>
+    </ul>
-	</div>
+  </div>
-	<!-- end page -->
+  <!-- end page -->
 
 
 

performance/tests/tribble/article.liquid

@@ -1,15 +1,15 @@
 
-	<div id="page" class="innerpage clearfix">
+  <div id="page" class="innerpage clearfix">
-		<div id="text-page">
+    <div id="text-page">
 
-					<div class="entry">
+          <div class="entry">
-						<h1><span>{{article.title}}</span></h1>
+            <h1><span>{{article.title}}</span></h1>
-						<div class="entry-post">
+            <div class="entry-post">
-							<div class="meta">{{ article.created_at | date: "%b %d" }}</div>
+              <div class="meta">{{ article.created_at | date: "%b %d" }}</div>
-							{{ article.content }}
+              {{ article.content }}
-						</div>
+            </div>
 
-	<!-- Comments -->
+  <!-- Comments -->
 {% if blog.comments_enabled? %}
 <div id="comments">
   <h2>Comments</h2>
@@ -22,10 +22,10 @@
         {{ comment.content }}
       </div>
 
-  	  <div class="comment-details">
+      <div class="comment-details">
-  		  Posted by <span class="comment-author">{{ comment.author }}</span> on <span class="comment-date">{{ comment.created_at | date: "%B %d, %Y" }}</span>
+        Posted by <span class="comment-author">{{ comment.author }}</span> on <span class="comment-date">{{ comment.created_at | date: "%B %d, %Y" }}</span>
       </div>
-  	</li>
+    </li>
   {% endfor %}
   </ul>
 
@@ -75,24 +75,24 @@
 <!-- END Comments -->
 
 
-					</div>
+          </div>
-		</div>
+    </div>
 
-		<div id="three-reasons" class="clearfix">
+    <div id="three-reasons" class="clearfix">
-			<h3>Why Shop With Us?</h3>
+      <h3>Why Shop With Us?</h3>
-			<ul>
+      <ul>
-				<li class="two-a">
+        <li class="two-a">
-					<h4>24 Hours</h4>
+          <h4>24 Hours</h4>
-					<p>We're always here to help.</p>
+          <p>We're always here to help.</p>
-				</li>
+        </li>
-				<li class="two-c">
+        <li class="two-c">
-					<h4>No Spam</h4>
+          <h4>No Spam</h4>
-					<p>We'll never share your info.</p>
+          <p>We'll never share your info.</p>
-				</li>
+        </li>
-				<li class="two-d">
+        <li class="two-d">
-					<h4>Secure Servers</h4>
+          <h4>Secure Servers</h4>
-					<p>Checkout is 256bit encrypted.</p>
+          <p>Checkout is 256bit encrypted.</p>
-				</li>
+        </li>
-			</ul>
+      </ul>
-		</div>
+    </div>
-	</div>
+  </div>

performance/tests/tribble/blog.liquid

@@ -1,41 +1,41 @@
-	<div id="page" class="innerpage clearfix">
+  <div id="page" class="innerpage clearfix">
-		<div id="text-page">
+    <div id="text-page">
-			<h1>Post from our blog...</h1>
+      <h1>Post from our blog...</h1>
-			{% paginate blog.articles by 20 %}
+      {% paginate blog.articles by 20 %}
-  				{% for article in blog.articles  %}
+          {% for article in blog.articles  %}
 
-					<div class="entry">
+          <div class="entry">
-						<h1><span><a href="{{ article.url }}">{{ article.title }}</a></span></h1>
+            <h1><span><a href="{{ article.url }}">{{ article.title }}</a></span></h1>
-						<div class="entry-post">
+            <div class="entry-post">
-							<div class="meta">{{ article.created_at | date: "%b %d" }}</div>
+              <div class="meta">{{ article.created_at | date: "%b %d" }}</div>
-							{{ article.content }}
+              {{ article.content }}
-						</div>
+            </div>
-					</div>
+          </div>
 
-				{% endfor %}
+        {% endfor %}
 
-				<div class="paginate clearfix">
+        <div class="paginate clearfix">
-  					{{ paginate | default_pagination }}
+            {{ paginate | default_pagination }}
-				</div>
+        </div>
 
-			{% endpaginate %}
+      {% endpaginate %}
-		</div>
+    </div>
 
-		<div id="three-reasons" class="clearfix">
+    <div id="three-reasons" class="clearfix">
-			<h3>Why Shop With Us?</h3>
+      <h3>Why Shop With Us?</h3>
-			<ul>
+      <ul>
-				<li class="two-a">
+        <li class="two-a">
-					<h4>24 Hours</h4>
+          <h4>24 Hours</h4>
-					<p>We're always here to help.</p>
+          <p>We're always here to help.</p>
-				</li>
+        </li>
-				<li class="two-c">
+        <li class="two-c">
-					<h4>No Spam</h4>
+          <h4>No Spam</h4>
-					<p>We'll never share your info.</p>
+          <p>We'll never share your info.</p>
-				</li>
+        </li>
-				<li class="two-d">
+        <li class="two-d">
-					<h4>Secure Servers</h4>
+          <h4>Secure Servers</h4>
-					<p>Checkout is 256bit encrypted.</p>
+          <p>Checkout is 256bit encrypted.</p>
-				</li>
+        </li>
-			</ul>
+      </ul>
-		</div>
+    </div>
-	</div>
+  </div>

performance/tests/tribble/cart.liquid

@@ -5,55 +5,55 @@
   }
 </script>
 
-	<div id="page" class="innerpage clearfix">.
+  <div id="page" class="innerpage clearfix">.
-		{% if cart.item_count == 0 %} 
+    {% if cart.item_count == 0 %}
-   			<h1>Your cart is currently empty.</h1>
+         <h1>Your cart is currently empty.</h1>
-  		{% else %}
+      {% else %}
 
-		<h1>Your Cart <span>({{ cart.item_count }} {{ cart.item_count | pluralize: 'item', 'items' }}, {{cart.total_price | money_with_currency }} total)</span></h1>		
+    <h1>Your Cart <span>({{ cart.item_count }} {{ cart.item_count | pluralize: 'item', 'items' }}, {{cart.total_price | money_with_currency }} total)</span></h1>
 
-		<form action="/cart" method="post" id="cart-form">
+    <form action="/cart" method="post" id="cart-form">
 
-		<div id="cart-wrap">
+    <div id="cart-wrap">
-			<table width="100%" border="0" cellspacing="0" cellpadding="0">
+      <table width="100%" border="0" cellspacing="0" cellpadding="0">
-				<tr>
+        <tr>
-					<th scope="col" class="td-image"><label>Image</label></th>
+          <th scope="col" class="td-image"><label>Image</label></th>
-					<th scope="col" class="td-title"><label>Product Title</label></th>
+          <th scope="col" class="td-title"><label>Product Title</label></th>
-					<th scope="col" class="td-count"><label>Count</label></th>
+          <th scope="col" class="td-count"><label>Count</label></th>
-					<th scope="col" class="td-price"><label>Cost</label></th>
+          <th scope="col" class="td-price"><label>Cost</label></th>
-					<th scope="col" class="td-delete"><label>Remove</label></th>
+          <th scope="col" class="td-delete"><label>Remove</label></th>
-				</tr>      
+        </tr>
 
-				{% for item in cart.items %}
+        {% for item in cart.items %}
-				<tr class="{% cycle 'reg', 'alt' %}">
+        <tr class="{% cycle 'reg', 'alt' %}">
-					<td colspan="5">
+          <td colspan="5">
-						<table width="100%" border="0" cellspacing="0" cellpadding="0">
+            <table width="100%" border="0" cellspacing="0" cellpadding="0">
-							<tr>
+              <tr>
-								<td class="td-image"><a href="{{item.product.url}}">{{ item.product.featured_image |  product_img_url: 'thumb' | img_tag }}</a></td>
+                <td class="td-image"><a href="{{item.product.url}}">{{ item.product.featured_image |  product_img_url: 'thumb' | img_tag }}</a></td>
-								<td class="td-title"><p>{{ item.title }}</p></td>
+                <td class="td-title"><p>{{ item.title }}</p></td>
-								<td class="td-count"><label>Count:</label> <input type="text" class="quantity item-count" name="updates[{{item.variant.id}}]" id="updates_{{item.variant.id}}" value="{{item.quantity}}" onfocus="this.select();"/></td>
+                <td class="td-count"><label>Count:</label> <input type="text" class="quantity item-count" name="updates[{{item.variant.id}}]" id="updates_{{item.variant.id}}" value="{{item.quantity}}" onfocus="this.select();"/></td>
-								<td class="td-price">{{item.line_price | money }}</td>
+                <td class="td-price">{{item.line_price | money }}</td>
-								<td class="td-delete"><a href="#" onclick="remove_item({{item.variant.id}}); return false;">Remove</a></td>
+                <td class="td-delete"><a href="#" onclick="remove_item({{item.variant.id}}); return false;">Remove</a></td>
-							</tr>
+              </tr>
-						</table>
+            </table>
-					</td>
+          </td>
-				</tr>
+        </tr>
-				{% endfor %}
+        {% endfor %}
-			</table>		
+      </table>
 
-			<div id="finish-up"> 
+      <div id="finish-up">
 
-				<div class="latest-news-box">
+        <div class="latest-news-box">
-					{{ pages.shopping-cart.content }}
+          {{ pages.shopping-cart.content }}
-				</div>				
+        </div>
 
-				<p class="order-total">
+        <p class="order-total">
-					<span><strong>Order Total:</strong> {{cart.total_price | money_with_currency }}</span>
+          <span><strong>Order Total:</strong> {{cart.total_price | money_with_currency }}</span>
-				</p>
+        </p>
 
-				<p class="update-cart"><input type="submit" value="Refresh Cart" name="update" /></p>
+        <p class="update-cart"><input type="submit" value="Refresh Cart" name="update" /></p>
 
- 	 			<p class="go-checkout"><input type="submit" value="Proceed to Checkout" name="checkout"  /></p>
+          <p class="go-checkout"><input type="submit" value="Proceed to Checkout" name="checkout"  /></p>
 
         {% if additional_checkout_buttons %}
         <div class="additional-checkout-buttons">
@@ -62,73 +62,73 @@
         </div>
         {% endif %}
 
-			</div>			
+      </div>
 
-		</div>
+    </div>
 
-		</form>
+    </form>
 
-		{% endif %}
+    {% endif %}
 
 
 
-		<h1 class="other-products"><span>Other Products You Might Enjoy</span></h1>
+    <h1 class="other-products"><span>Other Products You Might Enjoy</span></h1>
-		<ul class="item-list clearfix">
+    <ul class="item-list clearfix">
 
-			{% for product in collections.frontpage.products limit:2 %}
+      {% for product in collections.frontpage.products limit:2 %}
-			<li>
+      <li>
-				<form action="/cart/add" method="post">
+        <form action="/cart/add" method="post">
-				<div class="item-list-item">					
+        <div class="item-list-item">
-					<div class="ili-top clearfix">
+          <div class="ili-top clearfix">
-						<div class="ili-top-content">
+            <div class="ili-top-content">
-							<h2><a href="{{product.url}}">{{product.title}}</a></h2>
+              <h2><a href="{{product.url}}">{{product.title}}</a></h2>
-							<p>{{ product.description | truncatewords: 15 }}</p>
+              <p>{{ product.description | truncatewords: 15 }}</p>
-						</div>						
+            </div>
-						<a href="{{product.url}}" class="ili-top-image"><img src="{{ product.featured_image | product_img_url: 'small' }}" alt="{{ product.title | escape }}"/></a>	
+            <a href="{{product.url}}" class="ili-top-image"><img src="{{ product.featured_image | product_img_url: 'small' }}" alt="{{ product.title | escape }}"/></a>
-					</div>
+          </div>
 
-					<div class="ili-bottom clearfix">
+          <div class="ili-bottom clearfix">
-						<p class="hiddenvariants" style="display: none">{% for variant in product.variants %}<span><input type="radio" name="id" value="{{variant.id}}" id="radio_{{variant.id}}" style="vertical-align: middle;" {%if forloop.first%} checked="checked" {%endif%} /><label for="radio_{{variant.id}}">{{ variant.price | money_with_currency }} - {{ variant.title }}</label></span>{% endfor %}</p>
+            <p class="hiddenvariants" style="display: none">{% for variant in product.variants %}<span><input type="radio" name="id" value="{{variant.id}}" id="radio_{{variant.id}}" style="vertical-align: middle;" {%if forloop.first%} checked="checked" {%endif%} /><label for="radio_{{variant.id}}">{{ variant.price | money_with_currency }} - {{ variant.title }}</label></span>{% endfor %}</p>
-						<input type="submit" class="" value="Add to Basket" />
+            <input type="submit" class="" value="Add to Basket" />
-						<p>
+            <p>
-							<a href="{{product.url}}">View Details</a>	
+              <a href="{{product.url}}">View Details</a>
 
-							<span>
+              <span>
-								{% if product.compare_at_price %} 			  
+                {% if product.compare_at_price %}
-									{% if product.price_min != product.compare_at_price %}			    
+                  {% if product.price_min != product.compare_at_price %}
-										{{product.compare_at_price | money}} -
+                    {{product.compare_at_price | money}} -
-			  						{% endif %}
+                    {% endif %}
-								{% endif %}
+                {% endif %}
-								<strong>
+                <strong>
-									{{product.price_min | money}}
+                  {{product.price_min | money}}
-								</strong>
+                </strong>
-							</span>
+              </span>
-						</p>
+            </p>
-					</div>
+          </div>
-				</div>
+        </div>
-				</form>
+        </form>
-			</li>
+      </li>
-			{% endfor %}
+      {% endfor %}
 
-		</ul>
+    </ul>
 
-		<div id="three-reasons" class="clearfix">
+    <div id="three-reasons" class="clearfix">
-			<h3>Why Shop With Us?</h3>
+      <h3>Why Shop With Us?</h3>
-			<ul>
+      <ul>
-				<li class="two-a">
+        <li class="two-a">
-					<h4>24 Hours</h4>
+          <h4>24 Hours</h4>
-					<p>We're always here to help.</p>
+          <p>We're always here to help.</p>
-				</li>
+        </li>
-				<li class="two-c">
+        <li class="two-c">
-					<h4>No Spam</h4>
+          <h4>No Spam</h4>
-					<p>We'll never share your info.</p>
+          <p>We'll never share your info.</p>
-				</li>
+        </li>
-				<li class="two-d">
+        <li class="two-d">
-					<h4>Secure Servers</h4>
+          <h4>Secure Servers</h4>
-					<p>Checkout is 256bit encrypted.</p>
+          <p>Checkout is 256bit encrypted.</p>
-				</li>
+        </li>
-			</ul>
+      </ul>
-		</div>
+    </div>
 
-	</div>
+  </div>
-	<!-- end page -->
+  <!-- end page -->

performance/tests/tribble/collection.liquid

@@ -1,70 +1,70 @@
-	<div id="page" class="innerpage clearfix">
+  <div id="page" class="innerpage clearfix">
-		<h1>{{ collection.title }}</h1>
+    <h1>{{ collection.title }}</h1>
-		{% if collection.description.size > 0 %}
+    {% if collection.description.size > 0 %}
-			<div class="latest-news">{{ collection.description }}</div>
+      <div class="latest-news">{{ collection.description }}</div>
-		{% endif %}
+    {% endif %}
 
-		{% paginate collection.products by 8 %}
+    {% paginate collection.products by 8 %}
 
-		<ul class="item-list clearfix">
+    <ul class="item-list clearfix">
-		{% for product in collection.products  %}
+    {% for product in collection.products  %}
-			<li>
+      <li>
-				<form action="/cart/add" method="post">
+        <form action="/cart/add" method="post">
-				<div class="item-list-item">					
+        <div class="item-list-item">
-					<div class="ili-top clearfix">
+          <div class="ili-top clearfix">
-						<div class="ili-top-content">
+            <div class="ili-top-content">
-							<h2><a href="{{product.url}}">{{product.title}}</a></h2>
+              <h2><a href="{{product.url}}">{{product.title}}</a></h2>
-							<p>{{ product.description | truncatewords: 15 }}</p>
+              <p>{{ product.description | truncatewords: 15 }}</p>
-						</div>						
+            </div>
-						<a href="{{product.url}}" class="ili-top-image"><img src="{{ product.featured_image | product_img_url: 'small' }}" alt="{{ product.title | escape }}"/></a>	
+            <a href="{{product.url}}" class="ili-top-image"><img src="{{ product.featured_image | product_img_url: 'small' }}" alt="{{ product.title | escape }}"/></a>
-					</div>
+          </div>
 
-					<div class="ili-bottom clearfix">
+          <div class="ili-bottom clearfix">
-						<p class="hiddenvariants" style="display: none">{% for variant in product.variants %}<span><input type="radio" name="id" value="{{variant.id}}" id="radio_{{variant.id}}" style="vertical-align: middle;" {%if forloop.first%} checked="checked" {%endif%} /><label for="radio_{{variant.id}}">{{ variant.price | money_with_currency }} - {{ variant.title }}</label></span>{% endfor %}</p>
+            <p class="hiddenvariants" style="display: none">{% for variant in product.variants %}<span><input type="radio" name="id" value="{{variant.id}}" id="radio_{{variant.id}}" style="vertical-align: middle;" {%if forloop.first%} checked="checked" {%endif%} /><label for="radio_{{variant.id}}">{{ variant.price | money_with_currency }} - {{ variant.title }}</label></span>{% endfor %}</p>
-						<input type="submit" class="" value="Add to Basket" />
+            <input type="submit" class="" value="Add to Basket" />
-						<p>
+            <p>
-							<a href="{{product.url}}">View Details</a>	
+              <a href="{{product.url}}">View Details</a>
 
-							<span>
+              <span>
-								{% if product.compare_at_price %} 			  
+                {% if product.compare_at_price %}
-									{% if product.price_min != product.compare_at_price %}			    
+                  {% if product.price_min != product.compare_at_price %}
-										{{product.compare_at_price | money}} -
+                    {{product.compare_at_price | money}} -
-			  						{% endif %}
+                    {% endif %}
-								{% endif %}
+                {% endif %}
-								<strong>
+                <strong>
-									{{product.price_min | money}}
+                  {{product.price_min | money}}
-								</strong>
+                </strong>
-							</span>
+              </span>
-						</p>
+            </p>
-					</div>
+          </div>
-				</div>
+        </div>
-				</form>
+        </form>
-			</li>
+      </li>
-		{% endfor %}
+    {% endfor %}
-		</ul>
+    </ul>
 
-		<div class="paginate clearfix">
+    <div class="paginate clearfix">
-			{{ paginate | default_pagination }}
+      {{ paginate | default_pagination }}
-		</div>
+    </div>
 
 
-		<div id="three-reasons" class="clearfix">
+    <div id="three-reasons" class="clearfix">
-			<h3>Why Shop With Us?</h3>
+      <h3>Why Shop With Us?</h3>
-			<ul>
+      <ul>
-				<li class="two-a">
+        <li class="two-a">
-					<h4>24 Hours</h4>
+          <h4>24 Hours</h4>
-					<p>We're always here to help.</p>
+          <p>We're always here to help.</p>
-				</li>
+        </li>
-				<li class="two-c">
+        <li class="two-c">
-					<h4>No Spam</h4>
+          <h4>No Spam</h4>
-					<p>We'll never share your info.</p>
+          <p>We'll never share your info.</p>
-				</li>
+        </li>
-				<li class="two-d">
+        <li class="two-d">
-					<h4>Secure Servers</h4>
+          <h4>Secure Servers</h4>
-					<p>Checkout is 256bit encrypted.</p>
+          <p>Checkout is 256bit encrypted.</p>
-				</li>
+        </li>
-			</ul>
+      </ul>
-		</div>
+    </div>
-	</div>
+  </div>
 
 {% endpaginate %}

performance/tests/tribble/index.liquid

@@ -1,94 +1,94 @@
-	<div id="gwrap">
+  <div id="gwrap">
-		<div id="gbox">
+    <div id="gbox">
-			<h1>Three Great Reasons You Should Shop With Us...</h1>
+      <h1>Three Great Reasons You Should Shop With Us...</h1>
-			<ul>
+      <ul>
-				<li class="gbox1">
+        <li class="gbox1">
-					<h2>Free Shipping</h2>
+          <h2>Free Shipping</h2>
-					<p>On all orders over $25</p>
+          <p>On all orders over $25</p>
-				</li>
+        </li>
-				<li class="gbox2">
+        <li class="gbox2">
-					<h2>Top Quality</h2>
+          <h2>Top Quality</h2>
-					<p>Hand made in our shop</p>
+          <p>Hand made in our shop</p>
-				</li>
+        </li>
-				<li class="gbox3">
+        <li class="gbox3">
-					<h2>100% Guarantee</h2>
+          <h2>100% Guarantee</h2>
-					<p>Any time, any reason</p>
+          <p>Any time, any reason</p>
-				</li>
+        </li>
-			</ul>
+      </ul>
-		</div>
+    </div>
-	</div>
+  </div>
 
-	<div id="page" class="clearfix">
+  <div id="page" class="clearfix">
 
-		<div class="latest-news">{{pages.alert.content}}</div>
+    <div class="latest-news">{{pages.alert.content}}</div>
 
-		<ul class="item-list clearfix">
+    <ul class="item-list clearfix">
 
-			{% for product in collections.frontpage.products %}
+      {% for product in collections.frontpage.products %}
-			<li>
+      <li>
-				<form action="/cart/add" method="post">
+        <form action="/cart/add" method="post">
-				<div class="item-list-item">					
+        <div class="item-list-item">
-					<div class="ili-top clearfix">
+          <div class="ili-top clearfix">
-						<div class="ili-top-content">
+            <div class="ili-top-content">
-							<h2><a href="{{product.url}}">{{product.title}}</a></h2>
+              <h2><a href="{{product.url}}">{{product.title}}</a></h2>
-							{{ product.description | truncatewords: 15 }}</p> <!-- extra cloding <p> tag for truncation -->
+              {{ product.description | truncatewords: 15 }}</p> <!-- extra cloding <p> tag for truncation -->
-						</div>						
+            </div>
-						<a href="{{product.url}}" class="ili-top-image"><img src="{{ product.featured_image | product_img_url: 'small' }}" alt="{{ product.title | escape }}"/></a>	
+            <a href="{{product.url}}" class="ili-top-image"><img src="{{ product.featured_image | product_img_url: 'small' }}" alt="{{ product.title | escape }}"/></a>
-					</div>
+          </div>
 
-					<div class="ili-bottom clearfix">
+          <div class="ili-bottom clearfix">
-						<p class="hiddenvariants" style="display: none">{% for variant in product.variants %}<span><input type="radio" name="id" value="{{variant.id}}" id="radio_{{variant.id}}" style="vertical-align: middle;" {%if forloop.first%} checked="checked" {%endif%} /><label for="radio_{{variant.id}}">{{ variant.price | money_with_currency }} - {{ variant.title }}</label></span>{% endfor %}</p>
+            <p class="hiddenvariants" style="display: none">{% for variant in product.variants %}<span><input type="radio" name="id" value="{{variant.id}}" id="radio_{{variant.id}}" style="vertical-align: middle;" {%if forloop.first%} checked="checked" {%endif%} /><label for="radio_{{variant.id}}">{{ variant.price | money_with_currency }} - {{ variant.title }}</label></span>{% endfor %}</p>
-						<input type="submit" class="" value="Add to Basket" />
+            <input type="submit" class="" value="Add to Basket" />
-						<p>
+            <p>
-							<a href="{{product.url}}">View Details</a>	
+              <a href="{{product.url}}">View Details</a>
 
-							<span>
+              <span>
-								{% if product.compare_at_price %} 			  
+                {% if product.compare_at_price %}
-									{% if product.price_min != product.compare_at_price %}			    
+                  {% if product.price_min != product.compare_at_price %}
-										{{product.compare_at_price | money}} -
+                    {{product.compare_at_price | money}} -
-			  						{% endif %}
+                    {% endif %}
-								{% endif %}
+                {% endif %}
-								<strong>
+                <strong>
-									{{product.price_min | money}}
+                  {{product.price_min | money}}
-								</strong>
+                </strong>
-							</span>
+              </span>
-						</p>
+            </p>
-					</div>
+          </div>
-				</div>
+        </div>
-				</form>
+        </form>
-			</li>
+      </li>
-			{% endfor %}
+      {% endfor %}
 
-		</ul>
+    </ul>
 
-		<div id="one-two">
+    <div id="one-two">
-			<div id="two">
+      <div id="two">
-				<h3>Why Shop With Us?</h3>
+        <h3>Why Shop With Us?</h3>
-				<ul>
+        <ul>
-					<li class="two-a">
+          <li class="two-a">
-						<h4>24 Hours</h4>
+            <h4>24 Hours</h4>
-						<p>We're always here to help.</p>
+            <p>We're always here to help.</p>
-					</li>
+          </li>
-					<li class="two-c">
+          <li class="two-c">
-						<h4>No Spam</h4>
+            <h4>No Spam</h4>
-						<p>We'll never share your info.</p>
+            <p>We'll never share your info.</p>
-					</li>
+          </li>
-					<li class="two-b">
+          <li class="two-b">
-						<h4>Save Energy</h4>
+            <h4>Save Energy</h4>
-						<p>We're green, all the way.</p>
+            <p>We're green, all the way.</p>
-					</li>
+          </li>
-					<li class="two-d">
+          <li class="two-d">
-						<h4>Secure Servers</h4>
+            <h4>Secure Servers</h4>
-						<p>Checkout is 256bits encrypted.</p>
+            <p>Checkout is 256bits encrypted.</p>
-					</li>
+          </li>
-				</ul>
+        </ul>
-			</div>
+      </div>
 
-			<div id="one">
+      <div id="one">
-				<h3>Our Company</h3>
+        <h3>Our Company</h3>
-				{{pages.about-us.content | truncatewords: 49}} <a href="/pages/about-us">read more</a></p>
+        {{pages.about-us.content | truncatewords: 49}} <a href="/pages/about-us">read more</a></p>
-			</div>
+      </div>
-		</div>
+    </div>
 
-	</div>
+  </div>
-	<!-- end page -->
+  <!-- end page -->

performance/tests/tribble/page.liquid

@@ -1,56 +1,56 @@
-	<div id="page" class="innerpage clearfix">
+  <div id="page" class="innerpage clearfix">
 
-		<div id="text-page">			
+    <div id="text-page">
-			<div class="entry">
+      <div class="entry">
-				<h1>{{page.title}}</h1>
+        <h1>{{page.title}}</h1>
-				<div class="entry-post">
+        <div class="entry-post">
-					{{page.content}}
+          {{page.content}}
-				</div>
+        </div>
-			</div>
+      </div>
-		</div>
+    </div>
 
 
-		<h1>Featured Products</h1>	
+    <h1>Featured Products</h1>
-		<ul class="item-list clearfix">
+    <ul class="item-list clearfix">
 
-			{% for product in collections.frontpage.products %}
+      {% for product in collections.frontpage.products %}
-			<li>
+      <li>
-				<form action="/cart/add" method="post">
+        <form action="/cart/add" method="post">
-				<div class="item-list-item">					
+        <div class="item-list-item">
-					<div class="ili-top clearfix">
+          <div class="ili-top clearfix">
-						<div class="ili-top-content">
+            <div class="ili-top-content">
-							<h2><a href="{{product.url}}">{{product.title}}</a></h2>
+              <h2><a href="{{product.url}}">{{product.title}}</a></h2>
-							<p>{{ product.description | truncatewords: 15 }}</p>
+              <p>{{ product.description | truncatewords: 15 }}</p>
-						</div>						
+            </div>
-						<a href="{{product.url}}" class="ili-top-image"><img src="{{ product.featured_image | product_img_url: 'small' }}" alt="{{ product.title | escape }}"/></a>	
+            <a href="{{product.url}}" class="ili-top-image"><img src="{{ product.featured_image | product_img_url: 'small' }}" alt="{{ product.title | escape }}"/></a>
-					</div>
+          </div>
 
-					<div class="ili-bottom clearfix">
+          <div class="ili-bottom clearfix">
-						<p class="hiddenvariants" style="display: none">{% for variant in product.variants %}<span><input type="radio" name="id" value="{{variant.id}}" id="radio_{{variant.id}}" style="vertical-align: middle;" {%if forloop.first%} checked="checked" {%endif%} /><label for="radio_{{variant.id}}">{{ variant.price | money_with_currency }} - {{ variant.title }}</label></span>{% endfor %}</p>
+            <p class="hiddenvariants" style="display: none">{% for variant in product.variants %}<span><input type="radio" name="id" value="{{variant.id}}" id="radio_{{variant.id}}" style="vertical-align: middle;" {%if forloop.first%} checked="checked" {%endif%} /><label for="radio_{{variant.id}}">{{ variant.price | money_with_currency }} - {{ variant.title }}</label></span>{% endfor %}</p>
-						<input type="submit" class="" value="Add to Basket" />
+            <input type="submit" class="" value="Add to Basket" />
-						<p>
+            <p>
-							<a href="{{product.url}}">View Details</a>	
+              <a href="{{product.url}}">View Details</a>
 
-							<span>
+              <span>
-								{% if product.compare_at_price %} 			  
+                {% if product.compare_at_price %}
-									{% if product.price_min != product.compare_at_price %}			    
+                  {% if product.price_min != product.compare_at_price %}
-										{{product.compare_at_price | money}} -
+                    {{product.compare_at_price | money}} -
-			  						{% endif %}
+                    {% endif %}
-								{% endif %}
+                {% endif %}
-								<strong>
+                <strong>
-									{{product.price_min | money}}
+                  {{product.price_min | money}}
-								</strong>
+                </strong>
-							</span>
+              </span>
-						</p>
+            </p>
-					</div>
+          </div>
-				</div>
+        </div>
-				</form>
+        </form>
-			</li>
+      </li>
-			{% endfor %}
+      {% endfor %}
 
-		</ul>
+    </ul>
-	</div>
+  </div>
-	<!-- end page -->
+  <!-- end page -->
 
 
 

performance/tests/tribble/product.liquid

@@ -1,90 +1,90 @@
 <div id="page" class="innerpage clearfix">
-	<h1>{{ collection.title }} {{ product.title }}</h1>
+  <h1>{{ collection.title }} {{ product.title }}</h1>
 
 
-	<p class="latest-news"><strong>Product Tags: </strong>
+  <p class="latest-news"><strong>Product Tags: </strong>
-		{% for tag in product.tags %} 
+    {% for tag in product.tags %}
-          	<a href="/collections/all/{{ tag }}">{{ tag }}</a> | 
+            <a href="/collections/all/{{ tag }}">{{ tag }}</a> |
           {% endfor %}
-	</p>
+  </p>
 
-	<div class="product clearfix">
+  <div class="product clearfix">
-		<div class="product-info">
+    <div class="product-info">
-			<h1>{{ product.title }}</h1>
+      <h1>{{ product.title }}</h1>
-			<div class="product-info-description">
+      <div class="product-info-description">
-				<p>{{ product.description }}	</p>
+        <p>{{ product.description }}  </p>
-			</div>
+      </div>
 
-			{% if product.available %}
+      {% if product.available %}
-			<form action="/cart/add" method="post">
+      <form action="/cart/add" method="post">
 
-			<h2>Product Options:</h2>
+      <h2>Product Options:</h2>
 
-			<select id="product-info-options" name="id" class="product-info-options">
+      <select id="product-info-options" name="id" class="product-info-options">
         {% for variant in product.variants %}
           <option value="{{ variant.id }}">{{ variant.title }} - {{ variant.price | money }}</option>
         {% endfor %}
-			</select>
+      </select>
 
-			<div id="price-field"></div>
+      <div id="price-field"></div>
 
-			<div class="product-purchase-btn">
+      <div class="product-purchase-btn">
-				<input type="submit" class="add-this-to-cart" id="add-this-to-cart" value="Add to Basket" />
+        <input type="submit" class="add-this-to-cart" id="add-this-to-cart" value="Add to Basket" />
-			</div>
+      </div>
 
-			</form>
+      </form>
-			{% else %}
+      {% else %}
               <h2>Sold out!</h2>
               <p>Sorry, we're all out of this product. Check back often and order when it returns</p>
-            	{% endif %}
+              {% endif %}
-		</div>			
+    </div>
 
-		<div class="product-images clearfix">
+    <div class="product-images clearfix">
-			{% for image in product.images %}
+      {% for image in product.images %}
 
-			{% if forloop.first %}
+      {% if forloop.first %}
-			<div class="product-image-large">
+      <div class="product-image-large">
-				<img src="{{ image | product_img_url: 'medium'}}" alt="{{product.title | escape }}" />
+        <img src="{{ image | product_img_url: 'medium'}}" alt="{{product.title | escape }}" />
-			</div>			
+      </div>
-			{% else %}
+      {% else %}
-			{% endif %}				
+      {% endif %}
-			{% endfor %}
+      {% endfor %}
 
-			<ul class="product-thumbs clearfix">
+      <ul class="product-thumbs clearfix">
-			{% for image in product.images %}				
+      {% for image in product.images %}
-			{% if forloop.first %}		
+      {% if forloop.first %}
-			{% else %}
+      {% else %}
 
-			<li>
+      <li>
-			<a href="{{ image | product_img_url: 'large' }}" class="product-thumbs" rel="lightbox[product]" title="">
+      <a href="{{ image | product_img_url: 'large' }}" class="product-thumbs" rel="lightbox[product]" title="">
-			  <img src="{{ image | product_img_url: 'small'}}" alt="{{product.title | escape }}" />
+        <img src="{{ image | product_img_url: 'small'}}" alt="{{product.title | escape }}" />
-			</a>
+      </a>
-			</li>
+      </li>
-			{% endif %}				
+      {% endif %}
-			{% endfor %}
+      {% endfor %}
-			</ul>
+      </ul>
-		</div>
+    </div>
-	</div>
+  </div>
 
 
 
-	<div id="three-reasons" class="clearfix">
+  <div id="three-reasons" class="clearfix">
-		<h3>Why Shop With Us?</h3>
+    <h3>Why Shop With Us?</h3>
-		<ul>
+    <ul>
-			<li class="two-a">
+      <li class="two-a">
-				<h4>24 Hours</h4>
+        <h4>24 Hours</h4>
-				<p>We're always here to help.</p>
+        <p>We're always here to help.</p>
-			</li>
+      </li>
-			<li class="two-c">
+      <li class="two-c">
-				<h4>No Spam</h4>
+        <h4>No Spam</h4>
-				<p>We'll never share your info.</p>
+        <p>We'll never share your info.</p>
-			</li>
+      </li>
-			<li class="two-d">
+      <li class="two-d">
-				<h4>Secure Servers</h4>
+        <h4>Secure Servers</h4>
-				<p>Checkout is 256bit encrypted.</p>
+        <p>Checkout is 256bit encrypted.</p>
-			</li>
+      </li>
-		</ul>
+    </ul>
-	</div>
+  </div>
 
 </div>
 <!-- end page -->

performance/tests/tribble/search.liquid

@@ -2,50 +2,50 @@
 
 
 
-		<div id="page" class="innerpage clearfix">
+    <div id="page" class="innerpage clearfix">
-		<h1>Search Results</h1>
+    <h1>Search Results</h1>
-		{% if search.performed %}
+    {% if search.performed %}
 
-		 {% paginate search.results by 10 %}
+     {% paginate search.results by 10 %}
 
-		 {% if search.results == empty %}  
+     {% if search.results == empty %}
-			<div class="latest-news">Your search for "{{search.terms | escape}}" did not yield any results</div>
+      <div class="latest-news">Your search for "{{search.terms | escape}}" did not yield any results</div>
-   		 {% else %}  
+        {% else %}
 
 
-		<ul class="search-list clearfix">
+    <ul class="search-list clearfix">
-		 {% for item in search.results %} 
+     {% for item in search.results %}
-			<li>					
+      <li>
-					<h3 class="stitle">{{ item.title | link_to: item.url }}</h3>
+          <h3 class="stitle">{{ item.title | link_to: item.url }}</h3>
-					<p class="sinfo">{{ item.content | strip_html | truncatewords: 65 | highlight: search.terms }} ... <a href="{{item.url}}" title="">view this item</a></p>		
+          <p class="sinfo">{{ item.content | strip_html | truncatewords: 65 | highlight: search.terms }} ... <a href="{{item.url}}" title="">view this item</a></p>
-			</li>
+      </li>
-		{% endfor %}
+    {% endfor %}
-		</ul>
+    </ul>
-		 {% endif %}
+     {% endif %}
 
-		<div class="paginate clearfix">
+    <div class="paginate clearfix">
-			{{ paginate | default_pagination }}
+      {{ paginate | default_pagination }}
-		</div>
+    </div>
 
 
-		<div id="three-reasons" class="clearfix">
+    <div id="three-reasons" class="clearfix">
-			<h3>Why Shop With Us?</h3>
+      <h3>Why Shop With Us?</h3>
-			<ul>
+      <ul>
-				<li class="two-a">
+        <li class="two-a">
-					<h4>24 Hours</h4>
+          <h4>24 Hours</h4>
-					<p>We're always here to help.</p>
+          <p>We're always here to help.</p>
-				</li>
+        </li>
-				<li class="two-c">
+        <li class="two-c">
-					<h4>No Spam</h4>
+          <h4>No Spam</h4>
-					<p>We'll never share your info.</p>
+          <p>We'll never share your info.</p>
-				</li>
+        </li>
-				<li class="two-d">
+        <li class="two-d">
-					<h4>Secure Servers</h4>
+          <h4>Secure Servers</h4>
-					<p>Checkout is 256bit encrypted.</p>
+          <p>Checkout is 256bit encrypted.</p>
-				</li>
+        </li>
-			</ul>
+      </ul>
-		</div>
+    </div>
-	</div>
+  </div>
 
 {% endpaginate %}
 {% endif %}

performance/tests/tribble/theme.liquid

@@ -2,15 +2,15 @@
 <html xmlns="http://www.w3.org/1999/xhtml">
 <head>
   <title>{{shop.name}} - {{page_title}}</title>
-	<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+  <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
 
-	{{ 'reset.css'     | asset_url | stylesheet_tag }}
+  {{ 'reset.css'     | asset_url | stylesheet_tag }}
-	{{ 'style.css'     | asset_url | stylesheet_tag }}
+  {{ 'style.css'     | asset_url | stylesheet_tag }}
 
-	{{ 'lightbox.css'                         | asset_url | stylesheet_tag }}
+  {{ 'lightbox.css'                         | asset_url | stylesheet_tag }}
   {{ 'prototype/1.6/prototype.js'           | global_asset_url  | script_tag }}
   {{ 'scriptaculous/1.8.2/scriptaculous.js' | global_asset_url  | script_tag }}
-	{{ 'lightbox.js'                          | asset_url | script_tag }}
+  {{ 'lightbox.js'                          | asset_url | script_tag }}
   {{ 'option_selection.js'                  | shopify_asset_url | script_tag }}
 
   {{ content_for_header }}
@@ -19,70 +19,70 @@
 
 <div id="wrap">
 
-	<div id="top">
+  <div id="top">
-		<div id="cart">
+    <div id="cart">
-			<h3>Shopping Cart</h3>
+      <h3>Shopping Cart</h3>
-			<p class="cart-count">
+      <p class="cart-count">
-				{% if cart.item_count == 0 %}
+        {% if cart.item_count == 0 %}
-					Your cart is currently empty
+          Your cart is currently empty
-				{% else %}
+        {% else %}
-					{{ cart.item_count }} {{ cart.item_count | pluralize: 'item', 'items' }} <span>-</span> Total: {{cart.total_price | money_with_currency }} <span>-</span> <a href="/cart">View Cart</a>
+          {{ cart.item_count }} {{ cart.item_count | pluralize: 'item', 'items' }} <span>-</span> Total: {{cart.total_price | money_with_currency }} <span>-</span> <a href="/cart">View Cart</a>
-				{% endif %}			
+        {% endif %}
-			</p>
+      </p>
-		</div>	
+    </div>
 
-		<div id="site-title">
+    <div id="site-title">
-			<h3><a href="/">{{shop.name}}</a></h3>
+      <h3><a href="/">{{shop.name}}</a></h3>
-			<h4><span>Tribble: A Shopify Theme</span></h4>
+      <h4><span>Tribble: A Shopify Theme</span></h4>
 
-		</div>	
+    </div>
-	</div>
+  </div>
 
-	<ul id="nav">
+  <ul id="nav">
-		{% for link in linklists.main-menu.links %}
+    {% for link in linklists.main-menu.links %}
-		 <li>{{ link.title | link_to: link.url }}</li>
+     <li>{{ link.title | link_to: link.url }}</li>
-		{% endfor %}
+    {% endfor %}
-	</ul>
+  </ul>
 
-	{{ content_for_layout }}
+  {{ content_for_layout }}
 
-	<div id="foot" class="clearfix">
+  <div id="foot" class="clearfix">
-		<div class="quick-links">
+    <div class="quick-links">
-			<h4>Quick Navigation</h4>
+      <h4>Quick Navigation</h4>
-			<ul class="clearfix">
+      <ul class="clearfix">
-				<li><a href="/">Home</a></li>
+        <li><a href="/">Home</a></li>
-				<li><a href="#top">Back to top</a></li>
+        <li><a href="#top">Back to top</a></li>
-				{% for link in linklists.main-menu.links %}
+        {% for link in linklists.main-menu.links %}
-		 		<li>{{ link.title | link_to: link.url }}</li>
+         <li>{{ link.title | link_to: link.url }}</li>
-				{% endfor %}
+        {% endfor %}
-			</ul>
+      </ul>
-		</div>
+    </div>
 
-		<div class="quick-contact">
+    <div class="quick-contact">
-			<h4>Quick Contact</h4>
+      <h4>Quick Contact</h4>
-			<div class="vcard">
+      <div class="vcard">
 
-  				<div class="org fn">
+          <div class="org fn">
-   					<div class="organization-name">Really Great Widget Co.</div>
+             <div class="organization-name">Really Great Widget Co.</div>
-  				</div>
+          </div>
-				<div class="adr">
+        <div class="adr">
-  					<span class="street-address">2531 Barrington Court</span>
+            <span class="street-address">2531 Barrington Court</span>
-  					<span class="locality">Hayward</span>, 
+            <span class="locality">Hayward</span>,
-					<abbr title="California" class="region">CA</abbr>
+          <abbr title="California" class="region">CA</abbr>
-	  				<span class="postal-code">94545</span>
+            <span class="postal-code">94545</span>
- 				</div>
+         </div>
-				<a class="email" href="mailto:email@myshopifysite.com">
+        <a class="email" href="mailto:email@myshopifysite.com">
-					email@myshopifysite.com
+          email@myshopifysite.com
-				</a>
+        </a>
-				<div class="tel">
+        <div class="tel">
-					<span class="type">Support:</span> <span class="value">800-555-9954</span>
+          <span class="type">Support:</span> <span class="value">800-555-9954</span>
-				</div>
+        </div>
-			</div>
+      </div>
 
-		</div>
+    </div>
 
-		<p><a href="http://shopify.com" class="we-made">Powered by Shopify</a> &copy; Copyright {{ "now" | date: "%Y" }} {{ shop.name }}, All Rights Reserved.  <a href="/blogs/news.xml" id="foot-rss">RSS Feed</a></p>
+    <p><a href="http://shopify.com" class="we-made">Powered by Shopify</a> &copy; Copyright {{ "now" | date: "%Y" }} {{ shop.name }}, All Rights Reserved.  <a href="/blogs/news.xml" id="foot-rss">RSS Feed</a></p>
-	</div>
+  </div>
 
 </div>
 

performance/tests/vogue/article.liquid

@@ -18,10 +18,10 @@
         {{ comment.content }}
       </div>
 
-  	  <div class="comment-details">
+      <div class="comment-details">
-  		  Posted by {{ comment.author }} on {{ comment.created_at | date: "%B %d, %Y" }}
+        Posted by {{ comment.author }} on {{ comment.created_at | date: "%B %d, %Y" }}
       </div>
-  	</li>
+    </li>
   {% endfor %}
   </ul>
 

performance/tests/vogue/cart.liquid

@@ -1,17 +1,17 @@
 <h1>Shopping Cart</h1>
 {% if cart.item_count == 0 %}
-	<p><strong>Your shopping basket is empty.</strong> Perhaps a featured item below is of interest...</p>
+  <p><strong>Your shopping basket is empty.</strong> Perhaps a featured item below is of interest...</p>
-	<table id="gallery">
+  <table id="gallery">
-	{% tablerow product in collections.frontpage.products cols: 3 limit: 12 %}
+  {% tablerow product in collections.frontpage.products cols: 3 limit: 12 %}
-		<div class="gallery-image">
+    <div class="gallery-image">
-			<a href="{{ product.url | within: collections.frontpage }}" title="{{ product.title | escape }} &mdash; {{ product.description | strip_html | truncate: 50 | escape }}"><img src="{{ product.images.first | product_img_url: 'medium' }}" alt="{{ product.title | escape }}" /></a>
+      <a href="{{ product.url | within: collections.frontpage }}" title="{{ product.title | escape }} &mdash; {{ product.description | strip_html | truncate: 50 | escape }}"><img src="{{ product.images.first | product_img_url: 'medium' }}" alt="{{ product.title | escape }}" /></a>
-		</div>
+    </div>
-		<div class="gallery-info">
+    <div class="gallery-info">
-			<a href="{{ product.url | within: collections.frontpage }}">{{ product.title | truncate: 30 }}</a><br />
+      <a href="{{ product.url | within: collections.frontpage }}">{{ product.title | truncate: 30 }}</a><br />
-			<small>{{ product.price | money }}{% if product.compare_at_price_max > product.price %} <del>{{ product.compare_at_price_max | money }}</del>{% endif %}</small>
+      <small>{{ product.price | money }}{% if product.compare_at_price_max > product.price %} <del>{{ product.compare_at_price_max | money }}</del>{% endif %}</small>
-		</div>
+    </div>
-	{% endtablerow %}
+  {% endtablerow %}
-	</table>
+  </table>
 {% else %}
 <script type="text/javascript">
   function remove_item(id) {
@@ -20,39 +20,39 @@
   }
 </script>
 <form action="/cart" method="post" id="cartform">
-	<table id="basket">
+  <table id="basket">
-		<tr>
+    <tr>
-			<th>Item Description</th>
+      <th>Item Description</th>
-			<th>Price</th>
+      <th>Price</th>
-			<th>Qty</th>
+      <th>Qty</th>
-			<th>Delete</th>
+      <th>Delete</th>
-			<th>Total</th>
+      <th>Total</th>
-		</tr>{% for item in cart.items %}
+    </tr>{% for item in cart.items %}
-		<tr class="basket-{% cycle 'odd', 'even' %}">
+    <tr class="basket-{% cycle 'odd', 'even' %}">
-			<td class="basket-column-one">
+      <td class="basket-column-one">
-				<div class="basket-images">
+        <div class="basket-images">
-					<a href="{{ item.product.url }}" title="{{ item.title | escape }} &mdash; {{ item.product.description | strip_html | truncate: 50 | escape }}"><img src="{{ item.product.images.first | product_img_url: 'thumb' }}" alt="{{ item.title | escape }}" /></a>
+          <a href="{{ item.product.url }}" title="{{ item.title | escape }} &mdash; {{ item.product.description | strip_html | truncate: 50 | escape }}"><img src="{{ item.product.images.first | product_img_url: 'thumb' }}" alt="{{ item.title | escape }}" /></a>
-				</div>
+        </div>
-				<div class="basket-desc">
+        <div class="basket-desc">
-					<p><a href="{{ item.product.url }}">{{ item.title }}</a></p>
+          <p><a href="{{ item.product.url }}">{{ item.title }}</a></p>
-					{{ item.product.description | strip_html | truncate: 120 }}
+          {{ item.product.description | strip_html | truncate: 120 }}
-				</div>
+        </div>
-			</td>
+      </td>
-			<td class="basket-column">{{ item.price | money }}{% if item.variant.compare_at_price > item.price %}<br /><del>{{ item.variant.compare_at_price | money }}</del>{% endif %}</td>
+      <td class="basket-column">{{ item.price | money }}{% if item.variant.compare_at_price > item.price %}<br /><del>{{ item.variant.compare_at_price | money }}</del>{% endif %}</td>
-			<td class="basket-column"><input type="text" size="4" name="updates[{{item.variant.id}}]" id="updates_{{ item.variant.id }}" value="{{ item.quantity }}" onfocus="this.select();"/></td>
+      <td class="basket-column"><input type="text" size="4" name="updates[{{item.variant.id}}]" id="updates_{{ item.variant.id }}" value="{{ item.quantity }}" onfocus="this.select();"/></td>
-			<td class="basket-column"><a href="#" onclick="remove_item({{ item.variant.id }}); return false;">Remove</a></td>
+      <td class="basket-column"><a href="#" onclick="remove_item({{ item.variant.id }}); return false;">Remove</a></td>
-			<td class="basket-column">{{ item.line_price | money }}</td>
+      <td class="basket-column">{{ item.line_price | money }}</td>
-		</tr>{% endfor %}
+    </tr>{% endfor %}
-	</table>
+  </table>
-	<div id="basket-right">
+  <div id="basket-right">
-		<h3>Subtotal {{ cart.total_price | money }}</h3>
+    <h3>Subtotal {{ cart.total_price | money }}</h3>
-		<input type="image" src="{{ 'update.png' | asset_url }}" id="update-cart" name="update" value="Update" />
+    <input type="image" src="{{ 'update.png' | asset_url }}" id="update-cart" name="update" value="Update" />
-		<input type="image" src="{{ 'checkout.png' | asset_url }}" name="checkout" value="Checkout" />
+    <input type="image" src="{{ 'checkout.png' | asset_url }}" name="checkout" value="Checkout" />
-		{% if additional_checkout_buttons %}
+    {% if additional_checkout_buttons %}
     <div class="additional-checkout-buttons">
       <p>- or -</p>
       {{ content_for_additional_checkout_buttons }}
     </div>
     {% endif %}
-	</div>
+  </div>
 </form>{% endif %}

performance/tests/vogue/collection.liquid

@@ -1,19 +1,19 @@
 {% paginate collection.products by 12 %}{% if collection.products.size == 0 %}
-	<strong>No products found in this collection.</strong>{% else %}
+  <strong>No products found in this collection.</strong>{% else %}
-	<h1>{{ collection.title }}</h1>
+  <h1>{{ collection.title }}</h1>
-	{{ collection.description }}
+  {{ collection.description }}
-	<table id="gallery">
+  <table id="gallery">
-	{% tablerow product in collection.products cols: 3 %}
+  {% tablerow product in collection.products cols: 3 %}
-		<div class="gallery-image">
+    <div class="gallery-image">
-			<a href="{{ product.url | within: collection }}" title="{{ product.title | escape }} &mdash; {{ product.description | strip_html | truncate: 50 | escape }}"><img src="{{ product.images.first | product_img_url: 'small' }}" alt="{{ product.title | escape }}" /></a>
+      <a href="{{ product.url | within: collection }}" title="{{ product.title | escape }} &mdash; {{ product.description | strip_html | truncate: 50 | escape }}"><img src="{{ product.images.first | product_img_url: 'small' }}" alt="{{ product.title | escape }}" /></a>
-		</div>
+    </div>
-		<div class="gallery-info">
+    <div class="gallery-info">
-			<a href="{{ product.url | within: collection }}">{{ product.title | truncate: 30 }}</a><br />
+      <a href="{{ product.url | within: collection }}">{{ product.title | truncate: 30 }}</a><br />
-			<small>{{ product.price | money }}{% if product.compare_at_price_max > product.price %} <del>{{ product.compare_at_price_max | money }}</del>{% endif %}</small>
+      <small>{{ product.price | money }}{% if product.compare_at_price_max > product.price %} <del>{{ product.compare_at_price_max | money }}</del>{% endif %}</small>
-		</div>
+    </div>
-	{% endtablerow %}
+  {% endtablerow %}
-	</table>{% if paginate.pages > 1 %}
+  </table>{% if paginate.pages > 1 %}
-	<div id="paginate">
+  <div id="paginate">
-		{{ paginate | default_pagination }}
+    {{ paginate | default_pagination }}
-	</div>{% endif %}{% endif %}
+  </div>{% endif %}{% endif %}
 {% endpaginate %}

performance/tests/vogue/index.liquid

@@ -1,22 +1,22 @@
-	<div id="about-excerpt">
+  <div id="about-excerpt">
-  	{% assign article = pages.frontpage %}
+    {% assign article = pages.frontpage %}
     {% if article.content != "" %}
-		  <h2>{{ article.title }}</h2>
+      <h2>{{ article.title }}</h2>
-  		{{ article.content }}
+      {{ article.content }}
-  	{% else %}
+    {% else %}
-  	  In <em>Admin &gt; Blogs &amp; Pages</em>, create a page with the handle <strong><code>frontpage</code></strong> and it will show up here.<br />
+      In <em>Admin &gt; Blogs &amp; Pages</em>, create a page with the handle <strong><code>frontpage</code></strong> and it will show up here.<br />
-  	  {{ "Learn more about handles" | link_to "http://wiki.shopify.com/Handle" }}
+      {{ "Learn more about handles" | link_to: "http://wiki.shopify.com/Handle" }}
-  	{% endif %}
+    {% endif %}
-	</div>
+  </div>
 
-	<table id="gallery">
+  <table id="gallery">
-	{% tablerow product in collections.frontpage.products cols: 3 limit: 12 %}
+  {% tablerow product in collections.frontpage.products cols: 3 limit: 12 %}
-		<div class="gallery-image">
+    <div class="gallery-image">
-			<a href="{{ product.url | within: collections.frontpage }}" title="{{ product.title | escape }} &mdash; {{ product.description | strip_html | truncate: 50 | escape }}"><img src="{{ product.images.first | product_img_url: 'small' }}" alt="{{ product.title | escape }}" /></a>
+      <a href="{{ product.url | within: collections.frontpage }}" title="{{ product.title | escape }} &mdash; {{ product.description | strip_html | truncate: 50 | escape }}"><img src="{{ product.images.first | product_img_url: 'small' }}" alt="{{ product.title | escape }}" /></a>
-		</div>
+    </div>
-		<div class="gallery-info">
+    <div class="gallery-info">
-			<a href="{{ product.url | within: collections.frontpage }}">{{ product.title | truncate: 30 }}</a><br />
+      <a href="{{ product.url | within: collections.frontpage }}">{{ product.title | truncate: 30 }}</a><br />
-			<small>{{ product.price | money }}{% if product.compare_at_price_max > product.price %} <del>{{ product.compare_at_price_max | money }}</del>{% endif %}</small>
+      <small>{{ product.price | money }}{% if product.compare_at_price_max > product.price %} <del>{{ product.compare_at_price_max | money }}</del>{% endif %}</small>
-		</div>
+    </div>
-	{% endtablerow %}
+  {% endtablerow %}
-	</table>
+  </table>

performance/tests/vogue/page.liquid

@@ -1,3 +1,3 @@
-	<h1>{{ page.title }}</h1>
+  <h1>{{ page.title }}</h1>
-	{{ page.content }}
+  {{ page.content }}
 

performance/tests/vogue/product.liquid

@@ -1,19 +1,19 @@
 <div id="product-left">
-	{% for image in product.images %}{% if forloop.first %}<div id="product-image">
+  {% for image in product.images %}{% if forloop.first %}<div id="product-image">
-		<a href="{{ image | product_img_url: 'large' }}" rel="lightbox[images]" title="{{ product.title | escape }}"><img src="{{ image | product_img_url: 'medium' }}" alt="{{ product.title | escape }}" /></a>
+    <a href="{{ image | product_img_url: 'large' }}" rel="lightbox[images]" title="{{ product.title | escape }}"><img src="{{ image | product_img_url: 'medium' }}" alt="{{ product.title | escape }}" /></a>
-	</div>{% else %}
+  </div>{% else %}
-	<div class="product-images">
+  <div class="product-images">
-		<a href="{{ image | product_img_url: 'large' }}" rel="lightbox[images]" title="{{ product.title | escape }}"><img src="{{ image | product_img_url: 'small' }}" alt="{{ product.title | escape }}" /></a>
+    <a href="{{ image | product_img_url: 'large' }}" rel="lightbox[images]" title="{{ product.title | escape }}"><img src="{{ image | product_img_url: 'small' }}" alt="{{ product.title | escape }}" /></a>
-	</div>{% endif %}{% endfor %}
+  </div>{% endif %}{% endfor %}
 </div>
 <div id="product-right">
-	<h1>{{ product.title }}</h1>
+  <h1>{{ product.title }}</h1>
-	{{ product.description }}
+  {{ product.description }}
 
-	{% if product.available %}
+  {% if product.available %}
-	<form action="/cart/add" method="post">
+  <form action="/cart/add" method="post">
 
-	  <div id="product-variants">
+    <div id="product-variants">
       <div id="price-field"></div>
 
       <select id="product-select" name='id'>
@@ -21,18 +21,18 @@
           <option value="{{ variant.id }}">{{ variant.title }} - {{ variant.price | money }}</option>
         {% endfor %}
       </select>
-		</div>
+    </div>
 
     <input type="image" src="{{ 'purchase.png' | asset_url }}" name="add" value="Purchase" id="purchase" />
-	</form>
+  </form>
-	{% else %}
+  {% else %}
-	  <p class="bold-red">This product is temporarily unavailable</p>
+    <p class="bold-red">This product is temporarily unavailable</p>
-	{% endif %}
+  {% endif %}
 
-	<div id="product-details">
+  <div id="product-details">
-		<strong>Continue Shopping</strong><br />
+    <strong>Continue Shopping</strong><br />
-		Browse more {{ product.type | link_to_type }} or additional {{ product.vendor | link_to_vendor }} products.
+    Browse more {{ product.type | link_to_type }} or additional {{ product.vendor | link_to_vendor }} products.
-	</div>
+  </div>
 </div>
 
 

performance/tests/vogue/theme.liquid

@@ -22,100 +22,100 @@
 <body id="page-{{ template }}">
 
 <div id="header">
-	<div class="container">
+  <div class="container">
-		<div id="logo">
+    <div id="logo">
-			<h1><a href="/" title="{{ shop.name }}">{{ shop.name }}</a></h1>
+      <h1><a href="/" title="{{ shop.name }}">{{ shop.name }}</a></h1>
-		</div>
+    </div>
-		<div id="navigation">
+    <div id="navigation">
-			<ul id="navigate">
+      <ul id="navigate">
-				<li><a href="/cart">View Cart</a></li>
+        <li><a href="/cart">View Cart</a></li>
-			  {% for link in linklists.main-menu.links reversed %}
+        {% for link in linklists.main-menu.links reversed %}
-				  <li><a href="{{ link.url }}">{{ link.title }}</a></li>
+          <li><a href="{{ link.url }}">{{ link.title }}</a></li>
-				{% endfor %}
+        {% endfor %}
-			</ul>
+      </ul>
-		</div>
+    </div>
-	</div>
+  </div>
 </div>
 
 <div id="mini-header">
-	<div class="container">
+  <div class="container">
-		<div id="shopping-cart">
+    <div id="shopping-cart">
-			<a href="/cart">Your shopping cart contains {{ cart.item_count }} {{ cart.item_count | pluralize: 'item', 'items' }}</a>
+      <a href="/cart">Your shopping cart contains {{ cart.item_count }} {{ cart.item_count | pluralize: 'item', 'items' }}</a>
-		</div>
+    </div>
-		<div id="search-box">
+    <div id="search-box">
-			<form action="/search" method="get">
+      <form action="/search" method="get">
-				<input type="text" name="q" id="q" />
+        <input type="text" name="q" id="q" />
-				<input type="image" src="{{ 'seek.png' | asset_url }}" value="Seek" onclick="this.parentNode.submit(); return false;" id="seek" />
+        <input type="image" src="{{ 'seek.png' | asset_url }}" value="Seek" onclick="this.parentNode.submit(); return false;" id="seek" />
-			</form>
+      </form>
-		</div>
+    </div>
-	</div>
+  </div>
 </div>
 
 <div id="layout">
-	<div class="container">
+  <div class="container">
-		<div id="layout-left" {% if template != "cart" %}{% if template != "product" %}style="width:619px"{% endif %}{% endif %}>{% if template == "search" %}
+    <div id="layout-left" {% if template != "cart" %}{% if template != "product" %}style="width:619px"{% endif %}{% endif %}>{% if template == "search" %}
-			<h1>Search Results</h1>{% endif %}
+      <h1>Search Results</h1>{% endif %}
-			{{ content_for_layout }}
+      {{ content_for_layout }}
-		</div>{% if template != "cart" %}{% if template != "product" %}
+    </div>{% if template != "cart" %}{% if template != "product" %}
 
-		<div id="layout-right">
+    <div id="layout-right">
-			{% if template == "index" %}
+      {% if template == "index" %}
-			{% if blogs.news.articles.size > 1 %}
+      {% if blogs.news.articles.size > 1 %}
-    	<a href="{{ shop.url }}/blogs/news.xml"><img src="{{ 'feed.png' | asset_url }}" alt="Subscribe" class="feed" /></a>
+      <a href="{{ shop.url }}/blogs/news.xml"><img src="{{ 'feed.png' | asset_url }}" alt="Subscribe" class="feed" /></a>
-    	<h3><a href="/blogs/news">More news</a></h3>
+      <h3><a href="/blogs/news">More news</a></h3>
-    	<ul id="blogs">{% for article in blogs.news.articles limit: 6 offset: 1 %}
+      <ul id="blogs">{% for article in blogs.news.articles limit: 6 offset: 1 %}
-    		<li><a href="{{ article.url }}">{{ article.title | strip_html | truncate: 30 }}</a><br />
+        <li><a href="{{ article.url }}">{{ article.title | strip_html | truncate: 30 }}</a><br />
-    			<small>{{ article.content | strip_html | truncatewords: 12 }}</small>
+          <small>{{ article.content | strip_html | truncatewords: 12 }}</small>
-    		</li>{% endfor %}
+        </li>{% endfor %}
-    	</ul>
+      </ul>
-    	{% endif %}
+      {% endif %}
-    	{% endif %}
+      {% endif %}
 
-    	{% if template == "collection" %}
+      {% if template == "collection" %}
-    	<h3>Collection Tags</h3>
+      <h3>Collection Tags</h3>
-    	<div id="tags">{% if collection.tags.size == 0 %}
+      <div id="tags">{% if collection.tags.size == 0 %}
-    		No tags found.{% else %}
+        No tags found.{% else %}
-    		<span class="tags">{% for tag in collection.tags %}{% if current_tags contains tag %} {{ tag | highlight_active_tag | link_to_remove_tag: tag }}{% else %} {{ tag | highlight_active_tag | link_to_add_tag: tag }}{% endif %}{% unless forloop.last %}, {% endunless %}{% endfor %}</span>{% endif %}
+        <span class="tags">{% for tag in collection.tags %}{% if current_tags contains tag %} {{ tag | highlight_active_tag | link_to_remove_tag: tag }}{% else %} {{ tag | highlight_active_tag | link_to_add_tag: tag }}{% endif %}{% unless forloop.last %}, {% endunless %}{% endfor %}</span>{% endif %}
-    	</div>
+      </div>
-    	{% endif %}
+      {% endif %}
 
       <h3>Navigation</h3>
       <ul id="links">
       {% for link in linklists.main-menu.links %}
-				<li><a href="{{ link.url }}">{{ link.title }}</a></li>
+        <li><a href="{{ link.url }}">{{ link.title }}</a></li>
-			{% endfor %}
+      {% endfor %}
-		  </ul>
+      </ul>
 
-		  {% if template != "page" %}
+      {% if template != "page" %}
-			<h3>Featured Products</h3>
+      <h3>Featured Products</h3>
-			<ul id="featuring">{% for product in collections.frontpage.products limit: 6 %}
+      <ul id="featuring">{% for product in collections.frontpage.products limit: 6 %}
-				<li class="featuring-list">
+        <li class="featuring-list">
-				  <div class="featuring-image">
+          <div class="featuring-image">
-						<a href="{{ product.url | within: collections.frontpage }}" title="{{ product.title | escape }} &mdash; {{ product.description | strip_html | truncate: 50 }}"><img src="{{ product.images.first | product_img_url: 'icon' }}" alt="{{ product.title | escape }}" /></a>
+            <a href="{{ product.url | within: collections.frontpage }}" title="{{ product.title | escape }} &mdash; {{ product.description | strip_html | truncate: 50 }}"><img src="{{ product.images.first | product_img_url: 'icon' }}" alt="{{ product.title | escape }}" /></a>
-					</div>
+          </div>
-					<div class="featuring-info">
+          <div class="featuring-info">
-						<a href="{{ product.url | within: collections.frontpage }}">{{ product.title | strip_html | truncate: 28 }}</a><br />
+            <a href="{{ product.url | within: collections.frontpage }}">{{ product.title | strip_html | truncate: 28 }}</a><br />
-						<small><span class="light">from</span> {{ product.price | money }}</small>
+            <small><span class="light">from</span> {{ product.price | money }}</small>
-					</div>
+          </div>
-				</li>{% endfor %}
+        </li>{% endfor %}
-			</ul>
+      </ul>
-			{% endif %}
+      {% endif %}
-		</div>{% endif %}{% endif %}
+    </div>{% endif %}{% endif %}
-	</div>
+  </div>
 </div>
 
 <div id="footer">
-	<div id="footer-fader">
+  <div id="footer-fader">
-		<div class="container">
+    <div class="container">
-			<div id="footer-right">{% for link in linklists.footer.links %}
+      <div id="footer-right">{% for link in linklists.footer.links %}
-				{{ link.title | link_to: link.url }} {% unless forloop.last %}&#124;{% endunless %}{% endfor %}
+        {{ link.title | link_to: link.url }} {% unless forloop.last %}&#124;{% endunless %}{% endfor %}
-			</div>
+      </div>
-			<span id="footer-left">
+      <span id="footer-left">
-				Copyright &copy; {{ "now" | date: "%Y" }} <a href="/">{{ shop.name }}</a>. All Rights Reserved. All prices {{ shop.currency }}.<br />
+        Copyright &copy; {{ "now" | date: "%Y" }} <a href="/">{{ shop.name }}</a>. All Rights Reserved. All prices {{ shop.currency }}.<br />
-				This website is powered by <a href="http://www.shopify.com">Shopify</a>.
+        This website is powered by <a href="http://www.shopify.com">Shopify</a>.
-			</span>
+      </span>
-		</div>
+    </div>
-	</div>
+  </div>
 </div>
 
 </body>

performance/theme_runner.rb

@@ -6,14 +6,21 @@
 # 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'
 
 class ThemeRunner
+  class FileSystem
+
+    def initialize(path)
+      @path = path
+    end
+
+    # Called by Liquid to retrieve a template file
+    def read_template_file(template_path)
+      File.read(@path + '/' + template_path + '.liquid')
+    end
+  end
 
   # Load all templates into memory, do this now so that
   # we don't profile IO.
@@ -47,62 +54,25 @@ class ThemeRunner
 
       # Compute page_tempalte outside of profiler run, uninteresting to profiler
       page_template = File.basename(template_name, File.extname(template_name))
-      compile_and_render(liquid, layout, assigns, page_template) 
+      compile_and_render(liquid, layout, assigns, page_template, template_name)
 
     end
   end
 
 
-  def run_profile
+  def compile_and_render(template, layout, assigns, page_template, template_file)
-    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) 
-      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)    
     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
-
-
-