Add extension to gemspec

Ragel doesn't allow us to recurse so we simply
reinvoke the parser for each step.

.gitignore

@@ -4,6 +4,8 @@
 pkg
 *.rbc
 .rvmrc
-.ruby-version
+*.o
-Gemfile.lock
+*.bundle
-.bundle
+ext/liquid/Makefile
+ext/liquid/liquid_context.c
+

.rubocop.yml

@@ -1,125 +0,0 @@
-inherit_from: ./.rubocop_todo.yml
-
-AllCops:
-  Exclude:
-    - 'performance/shopify/*'
-    - 'pkg/**'
-
-Metrics/BlockNesting:
-  Max: 3
-  Exclude:
-    - 'lib/liquid/block_body.rb'
-
-Metrics/ModuleLength:
-  Enabled: false
-
-Metrics/ClassLength:
-  Enabled: false
-
-Lint/AssignmentInCondition:
-  Enabled: false
-
-Lint/AmbiguousOperator:
-  Enabled: false
-
-Lint/AmbiguousRegexpLiteral:
-  Enabled: false
-
-Lint/ParenthesesAsGroupedExpression:
-  Enabled: false
-
-Lint/UnusedBlockArgument:
-  Enabled: false
-
-Lint/EndAlignment:
-  AlignWith: variable
-
-Lint/UnusedMethodArgument:
-  Enabled: false
-
-Style/SingleLineBlockParams:
-  Enabled: false
-
-Style/DoubleNegation:
-  Enabled: false
-
-Style/StringLiteralsInInterpolation:
-  Enabled: false
-
-Style/AndOr:
-  Enabled: false
-
-Style/SignalException:
-  Enabled: false
-
-Style/StringLiterals:
-  Enabled: false
-
-Style/BracesAroundHashParameters:
-  Enabled: false
-
-Style/NumericLiterals:
-  Enabled: false
-
-Style/SpaceInsideBrackets:
-  Enabled: false
-
-Style/SpaceBeforeBlockBraces:
-  Enabled: false
-
-Style/Documentation:
-  Enabled: false
-
-Style/ClassAndModuleChildren:
-  Enabled: false
-
-Style/TrailingComma:
-  Enabled: false
-
-Style/IndentHash:
-  EnforcedStyle: consistent
-
-Style/FormatString:
-  Enabled: false
-
-Style/AlignParameters:
-  EnforcedStyle: with_fixed_indentation
-
-Style/MultilineOperationIndentation:
-  EnforcedStyle: indented
-
-Style/IfUnlessModifier:
-  Enabled: false
-
-Style/RaiseArgs:
-  Enabled: false
-
-Style/DeprecatedHashMethods:
-  Enabled: false
-
-Style/RegexpLiteral:
-  Enabled: false
-
-Style/SymbolLiteral:
-  Enabled: false
-
-Performance/Count:
-  Enabled: false
-
-Style/ConstantName:
-  Enabled: false
-
-Style/CaseIndentation:
-  Enabled: false
-
-Style/ClassVars:
-  Enabled: false
-
-Style/PerlBackrefs:
-  Enabled: false
-
-Style/TrivialAccessors:
-  AllowPredicates: true
-
-Style/WordArray:
-  Enabled: false

.rubocop_todo.yml

@@ -1,72 +0,0 @@
-# This configuration was generated by `rubocop --auto-gen-config`
-# on 2015-06-08 18:16:16 +0000 using RuboCop version 0.32.0.
-# The point is for the user to remove these configuration records
-# one by one as the offenses are removed from the code base.
-# Note that changes in the inspected code, or installation of new
-# versions of RuboCop, may require this file to be generated again.
-
-# Offense count: 5
-Lint/NestedMethodDefinition:
-  Enabled: false
-
-# Offense count: 53
-Metrics/AbcSize:
-  Max: 58
-
-# Offense count: 12
-Metrics/CyclomaticComplexity:
-  Max: 15
-
-# Offense count: 553
-# Configuration parameters: AllowURI, URISchemes.
-Metrics/LineLength:
-  Max: 294
-
-# Offense count: 77
-# Configuration parameters: CountComments.
-Metrics/MethodLength:
-  Max: 46
-
-# Offense count: 6
-Metrics/PerceivedComplexity:
-  Max: 13
-
-# Offense count: 1
-Style/AccessorMethodName:
-  Enabled: false
-
-# Offense count: 1
-# Cop supports --auto-correct.
-Style/ClosingParenthesisIndentation:
-  Enabled: false
-
-# Offense count: 3
-# Configuration parameters: MinBodyLength.
-Style/GuardClause:
-  Enabled: false
-
-# Offense count: 4
-# Configuration parameters: EnforcedStyle, SupportedStyles.
-Style/MethodName:
-  Enabled: false
-
-# Offense count: 1
-Style/MultilineBlockChain:
-  Enabled: false
-
-# Offense count: 2
-# Configuration parameters: EnforcedStyle, MinBodyLength, SupportedStyles.
-Style/Next:
-  Enabled: false
-
-# Offense count: 7
-# Cop supports --auto-correct.
-# Configuration parameters: AllowAsExpressionSeparator.
-Style/Semicolon:
-  Enabled: false
-
-# Offense count: 1
-# Cop supports --auto-correct.
-# Configuration parameters: MaxLineLength.
-Style/WhileUntilModifier:
-  Enabled: false

.travis.yml

@@ -1,29 +1,13 @@
-language: ruby
-
 rvm:
-  - 2.1
+  - 1.8.7
-  - 2.2
+  - 1.9.3
-  - 2.3.3
+  - ree
-  - ruby-head
+  - jruby-18mode
-  - jruby-head
+  - jruby-19mode
-#  - rbx-2
+  - rbx-18mode
+  - rbx-19mode
 
-sudo: false
+script: "rake test"
-
-addons:
-  apt:
-    packages:
-    - libgmp3-dev
-
-matrix:
-  allow_failures:
-    - rvm: jruby-head
-
-install:
-  - gem install rainbow -v 2.2.1
-  - bundle install
-
-script: "bundle exec rake"
 
 notifications:
   disable: true

CONTRIBUTING.md

@@ -1,25 +0,0 @@
-# How to contribute
-
-## Things we will merge
-
-* Bugfixes
-* Performance improvements
-* Features that are likely to be useful to the majority of Liquid users
-
-## Things we won't merge
-
-* Code that introduces considerable performance degrations
-* Code that touches performance-critical parts of Liquid and comes without benchmarks
-* Features that are not important for most people (we want to keep the core Liquid code small and tidy)
-* Features that can easily be implemented on top of Liquid (for example as a custom filter or custom filesystem)
-* Code that does not include tests
-* Code that 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/or run a performance benchmark
-* Make sure all tests pass (`bundle exec rake`)
-* Create a pull request
-

Gemfile

@@ -1,17 +0,0 @@
-source 'https://rubygems.org'
-
-gemspec
-gem 'stackprof', platforms: :mri_21
-
-group :benchmark, :test do
-  gem 'benchmark-ips'
-end
-
-group :test do
-  gem 'spy', '0.4.1'
-  gem 'rubocop', '0.34.2'
-
-  platform :mri do
-    gem 'liquid-c', github: 'Shopify/liquid-c', ref: 'bd53db95de3d44d631e7c5a267c3d934e66107dd'
-  end
-end

History.md

@@ -1,163 +1,4 @@
-# Liquid Change Log
+# Liquid Version History
-
-## 4.0.0 / 2016-12-14 / branch "4-0-stable"
-
-### Changed
-* Render an opaque internal error by default for non-Liquid::Error (#835) [Dylan Thacker-Smith]
-* Ruby 2.0 support dropped (#832) [Dylan Thacker-Smith]
-* Add to_number Drop method to allow custom drops to work with number filters (#731)
-* Add strict_variables and strict_filters options to detect undefined references (#691)
-* Improve loop performance (#681) [Florian Weingarten]
-* Rename Drop method `before_method` to `liquid_method_missing` (#661) [Thierry Joyal]
-* Add url_decode filter to invert url_encode (#645) [Larry Archer]
-* Add global_filter to apply a filter to all output (#610) [Loren Hale]
-* Add compact filter (#600) [Carson Reinke]
-* Rename deprecated "has_key?" and "has_interrupt?" methods (#593) [Florian Weingarten]
-* Include template name with line numbers in render errors (574) [Dylan Thacker-Smith]
-* Add sort_natural filter (#554) [Martin Hanzel]
-* Add forloop.parentloop as a reference to the parent loop (#520) [Justin Li]
-* Block parsing moved to BlockBody class (#458) [Dylan Thacker-Smith]
-* Add concat filter to concatenate arrays (#429) [Diogo Beato]
-* Ruby 1.9 support dropped (#491) [Justin Li]
-* Liquid::Template.file_system's read_template_file method is no longer passed the context. (#441) [James Reid-Smith]
-* Remove `liquid_methods` (See https://github.com/Shopify/liquid/pull/568 for replacement)
-* Liquid::Template.register_filter raises when the module overrides registered public methods as private or protected (#705) [Gaurav Chande]
-
-### Fixed
-
-* Fix variable names being detected as an operator when starting with contains (#788) [Michael Angell]
-* Fix include tag used with strict_variables (#828) [QuickPay]
-* Fix map filter when value is a Proc (#672) [Guillaume Malette]
-* Fix truncate filter when value is not a string (#672) [Guillaume Malette]
-* Fix behaviour of escape filter when input is nil (#665) [Tanel Jakobsoo]
-* Fix sort filter behaviour with empty array input (#652) [Marcel Cary]
-* Fix test failure under certain timezones (#631) [Dylan Thacker-Smith]
-* Fix bug in uniq filter (#595) [Florian Weingarten]
-* Fix bug when "blank" and "empty" are used as variable names (#592) [Florian Weingarten]
-* Fix condition parse order in strict mode (#569) [Justin Li]
-* Fix naming of the "context variable" when dynamically including a template (#559) [Justin Li]
-* Gracefully accept empty strings in the date filter (#555) [Loren Hale]
-* Fix capturing into variables with a hyphen in the name (#505) [Florian Weingarten]
-* Fix case sensitivity regression in date standard filter (#499) [Kelley Reynolds]
-* Disallow filters with no variable in strict mode (#475) [Justin Li]
-* Disallow variable names in the strict parser that are not valid in the lax parser (#463) [Justin Li]
-* Fix BlockBody#warnings taking exponential time to compute (#486) [Justin Li]
-
-## 3.0.5 / 2015-07-23 / branch "3-0-stable"
-
-* Fix test failure under certain timezones [Dylan Thacker-Smith]
-
-## 3.0.4 / 2015-07-17
-
-* Fix chained access to multi-dimensional hashes [Florian Weingarten]
-
-## 3.0.3 / 2015-05-28
-
-* Fix condition parse order in strict mode (#569) [Justin Li]
-
-## 3.0.2 / 2015-04-24
-
-* Expose VariableLookup private members (#551) [Justin Li]
-* 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]
-* Fixed condition with wrong data types (#423) [Bogdan Gusiev]
-* Add url_encode to standard filters (#421) [Derrick Reimer]
-* Add uniq to standard filters [Florian Weingarten]
-* Add exception_handler feature (#397) and #254 [Bogdan Gusiev, Florian Weingarten]
-* Optimize variable parsing to avoid repeated regex evaluation during template rendering #383 [Jason Hiltz-Laforge]
-* Optimize checking for block interrupts to reduce object allocation #380 [Jason Hiltz-Laforge]
-* Properly set context rethrow_errors on render! #349 [Thierry Joyal]
-* Fix broken rendering of variables which are equal to false (#345) [Florian Weingarten]
-* Remove ActionView template handler [Dylan Thacker-Smith]
-* Freeze lots of string literals for new Ruby 2.1 optimization (#297) [Florian Weingarten]
-* Allow newlines in tags and variables (#324) [Dylan Thacker-Smith]
-* Tag#parse is called after initialize, which now takes options instead of tokens as the 3rd argument. See #321 [Dylan Thacker-Smith]
-* Raise `Liquid::ArgumentError` instead of `::ArgumentError` when filter has wrong number of arguments #309 [Bogdan Gusiev]
-* Add a to_s default for liquid drops (#306) [Adam Doeler]
-* Add strip, lstrip, and rstrip to standard filters [Florian Weingarten]
-* Make if, for & case tags return complete and consistent nodelists (#250) [Nick Jones]
-* Prevent arbitrary method invocation on condition objects (#274) [Dylan Thacker-Smith]
-* Don't call to_sym when creating conditions for security reasons (#273) [Bouke van der Bijl]
-* Fix resource counting bug with respond_to?(:length) (#263) [Florian Weingarten]
-* Allow specifying custom patterns for template filenames (#284) [Andrei Gladkyi]
-* Allow drops to optimize loading a slice of elements (#282) [Tom Burns]
-* Support for passing variables to snippets in subdirs (#271) [Joost Hietbrink]
-* Add a class cache to avoid runtime extend calls (#249) [James Tucker]
-* Remove some legacy Ruby 1.8 compatibility code (#276) [Florian Weingarten]
-* Add default filter to standard filters (#267) [Derrick Reimer]
-* Add optional strict parsing and warn parsing (#235) [Tristan Hume]
-* Add I18n syntax error translation (#241) [Simon Hørup Eskildsen, Sirupsen]
-* Make sort filter work on enumerable drops (#239) [Florian Weingarten]
-* Fix clashing method names in enumerable drops (#238) [Florian Weingarten]
-* Make map filter work on enumerable drops (#233) [Florian Weingarten]
-* Improved whitespace stripping for blank blocks, related to #216 [Florian Weingarten]
-
-## 2.6.3 / 2015-07-23 / branch "2-6-stable"
-
-* Fix test failure under certain timezones [Dylan Thacker-Smith]
-
-## 2.6.2 / 2015-01-23
-
-* Remove duplicate hash key [Parker Moore]
-
-## 2.6.1 / 2014-01-10
-
-Security fix, cherry-picked from master (4e14a65):
-* Don't call to_sym when creating conditions for security reasons (#273) [Bouke van der Bijl]
-* Prevent arbitrary method invocation on condition objects (#274) [Dylan Thacker-Smith]
-
-## 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]
-* Bugfix for #114: strip_html filter supports style tags [James Allardice]
-* Bugfix for #117: 'now' support for date filter in Ruby 1.9 [Notre Dame Webgroup]
-* Bugfix for #166: truncate filter on UTF-8 strings with Ruby 1.8 [Florian Weingarten]
-* Bugfix for #204: 'raw' parsing bug [Florian Weingarten]
-* Bugfix for #150: 'for' parsing bug [Peter Schröder]
-* Bugfix for #126: Strip CRLF in strip_newline [Peter Schröder]
-* Bugfix for #174, "can't convert Fixnum into String" for "replace" [jsw0528]
-* Allow a Liquid::Drop to be passed into Template#render [Daniel Huckstep]
-* Resource limits [Florian Weingarten]
-* Add reverse filter [Jay Strybis]
-* Add utf-8 support
-* Use array instead of Hash to keep the registered filters [Tasos Stathopoulos]
-* Cache tokenized partial templates [Tom Burns]
-* Avoid warnings in Ruby 1.9.3 [Marcus Stollsteimer]
-* Better documentation for 'include' tag (closes #163) [Peter Schröder]
-* Use of BigDecimal on filters to have better precision (closes #155) [Arthur Nogueira Neves]
-
-## 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]
-* Prevent arbitrary method invocation on condition objects (#274) [Dylan Thacker-Smith]
-
-## 2.5.4 / 2013-11-11
-
-* Fix "can't convert Fixnum into String" for "replace" (#173), [jsw0528]
-
-## 2.5.3 / 2013-10-09
-
-* #232, #234, #237: Fix map filter bugs [Florian Weingarten]
-
-## 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]
 
 ## 2.5.0 / 2013-03-06
 
@@ -167,7 +8,6 @@ Yanked from rubygems, as it contained too many changes that broke compatibility.
 * 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,14 +1,5 @@
-[![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:
@@ -50,57 +41,4 @@ For standard use you can just pass it the content of a file and call render with
 @template.render('name' => 'tobi')                # => "hi tobi"
 ```
 
-### Error Modes
+[![Build Status](https://secure.travis-ci.org/Shopify/liquid.png)](http://travis-ci.org/Shopify/liquid)
-
-Setting the error mode of Liquid lets you specify how strictly you want your templates to be interpreted.
-Normally the parser is very lax and will accept almost anything without error. Unfortunately this can make
-it very hard to debug and can lead to unexpected behaviour. 
-
-Liquid also comes with a stricter parser that can be used when editing templates to give better error messages
-when templates are invalid. You can enable this new parser like this:
-
-```ruby
-Liquid::Template.error_mode = :strict # Raises a SyntaxError when invalid syntax is used
-Liquid::Template.error_mode = :warn # Adds errors to template.errors but continues as normal
-Liquid::Template.error_mode = :lax # The default mode, accepts almost anything.
-```
-
-If you want to set the error mode only on specific templates you can pass `:error_mode` as an option to `parse`:
-```ruby
-Liquid::Template.parse(source, :error_mode => :strict)
-```
-This is useful for doing things like enabling strict mode only in the theme editor.
-
-It is recommended that you enable `:strict` or `:warn` mode on new apps to stop invalid templates from being created.
-It is also recommended that you use it in the template editors of existing apps to give editors better error messages.
-
-### Undefined variables and filters
-
-By default, the renderer doesn't raise or in any other way notify you if some variables or filters are missing, i.e. not passed to the `render` method.
-You can improve this situation by passing `strict_variables: true` and/or `strict_filters: true` options to the `render` method.
-When one of these options is set to true, all errors about undefined variables and undefined filters will be stored in `errors` array of a `Liquid::Template` instance.
-Here are some examples:
-
-```ruby
-template = Liquid::Template.parse("{{x}} {{y}} {{z.a}} {{z.b}}")
-template.render({ 'x' => 1, 'z' => { 'a' => 2 } }, { strict_variables: true })
-#=> '1  2 ' # when a variable is undefined, it's rendered as nil
-template.errors
-#=> [#<Liquid::UndefinedVariable: Liquid error: undefined variable y>, #<Liquid::UndefinedVariable: Liquid error: undefined variable b>]
-```
-
-```ruby
-template = Liquid::Template.parse("{{x | filter1 | upcase}}")
-template.render({ 'x' => 'foo' }, { strict_filters: true })
-#=> '' # when at least one filter in the filter chain is undefined, a whole expression is rendered as nil
-template.errors
-#=> [#<Liquid::UndefinedFilter: Liquid error: undefined filter filter1>]
-```
-
-If you want to raise on a first exception instead of pushing all of them in `errors`, you can use `render!` method:
-
-```ruby
-template = Liquid::Template.parse("{{x}} {{y}}")
-template.render!({ 'x' => 1}, { strict_variables: true })
-#=> Liquid::UndefinedVariable: Liquid error: undefined variable y
-```

Rakefile

@@ -1,95 +1,91 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
 require 'rake'
+require 'rake/clean'
+require 'fileutils'
 require 'rake/testtask'
-$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+require 'rubygems/package_task'
-require "liquid/version"
 
-task default: [:rubocop, :test]
+task :default => [:compile, :test]
 
-desc 'run test suite with default parser'
+task :gen do
-Rake::TestTask.new(:base_test) do |t|
+  sh "leg -oext/liquid/liquid_context.c ext/liquid/liquid_context.leg"
+end
+
+task :compile => [:gen, :liquid_ext]
+
+extension = "liquid_ext"
+ext = "ext/liquid"
+ext_so = "#{ext}/#{extension}.#{RbConfig::CONFIG['DLEXT']}"
+ext_files = FileList[
+  "#{ext}/*.c",
+  "#{ext}/*.h",
+  "#{ext}/*.leg",
+  "#{ext}/extconf.rb",
+  "#{ext}/Makefile",
+  "lib"
+]
+
+task "lib" do
+  directory "lib"
+end
+
+desc "Builds just the #{extension} extension"
+task extension.to_sym => [:gen, "#{ext}/Makefile", ext_so ]
+
+file "#{ext}/Makefile" => ["#{ext}/extconf.rb"] do
+  Dir.chdir(ext) do ruby "extconf.rb" end
+end
+
+file ext_so => ext_files do
+  Dir.chdir(ext) do
+    sh "make"
+  end
+  cp ext_so, "lib"
+end
+
+Rake::TestTask.new(:test => [:gen, 'liquid_ext']) do |t|
   t.libs << '.' << 'lib' << 'test'
-  t.test_files = FileList['test/{integration,unit}/**/*_test.rb']
+  t.test_files = FileList['test/liquid/**/*_test.rb']
   t.verbose = false
 end
 
-desc 'run test suite with warn error mode'
+gemspec = eval(File.read('liquid.gemspec'))
-task :warn_test do
+Gem::PackageTask.new(gemspec) do |pkg|
-  ENV['LIQUID_PARSER_MODE'] = 'warn'
+  pkg.gem_spec = gemspec
-  Rake::Task['base_test'].invoke
 end
 
-task :rubocop do
+desc "Build the gem and release it to rubygems.org"
-  require 'rubocop/rake_task'
+task :release => :gem do
-  RuboCop::RakeTask.new
+  sh "gem push pkg/liquid-#{gemspec.version}.gem"
-end
-
-desc 'runs test suite with both strict and lax parsers'
-task :test do
-  ENV['LIQUID_PARSER_MODE'] = 'lax'
-  Rake::Task['base_test'].invoke
-
-  ENV['LIQUID_PARSER_MODE'] = 'strict'
-  Rake::Task['base_test'].reenable
-  Rake::Task['base_test'].invoke
-
-  if RUBY_ENGINE == 'ruby'
-    ENV['LIQUID-C'] = '1'
-
-    ENV['LIQUID_PARSER_MODE'] = 'lax'
-    Rake::Task['base_test'].reenable
-    Rake::Task['base_test'].invoke
-
-    ENV['LIQUID_PARSER_MODE'] = 'strict'
-    Rake::Task['base_test'].reenable
-    Rake::Task['base_test'].invoke
-  end
-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 with lax parsing"
+
+  desc "Run the liquid benchmark"
   task :run do
-    ruby "./performance/benchmark.rb lax"
+    ruby "./performance/benchmark.rb"
   end
 
-  desc "Run the liquid benchmark with strict parsing"
-  task :strict do
-    ruby "./performance/benchmark.rb strict"
-  end
 end
 
+
 namespace :profile do
+
   desc "Run the liquid profile/performance coverage"
   task :run do
     ruby "./performance/profile.rb"
   end
 
-  desc "Run the liquid profile/performance coverage with strict parsing"
+  desc "Run KCacheGrind"
-  task :strict do
+  task :grind => :run  do
-    ruby "./performance/profile.rb strict"
+    system "qcachegrind /tmp//callgrind.liquid.txt"
   end
+
 end
 
 desc "Run example"
 task :example do
   ruby "-w -d -Ilib example/server/server.rb"
 end
-
-task :console do
-  exec 'irb -I lib -r liquid'
-end

circle.yml

@@ -1,3 +0,0 @@
-machine:
-  ruby:
-    version: ruby-2.1

example/server/example_servlet.rb

@@ -4,7 +4,7 @@ module ProductsFilter
   end
   
   def prettyprint(text)
-    text.gsub(/\*(.*)\*/, '<b>\1</b>')
+    text.gsub( /\*(.*)\*/, '<b>\1</b>' )
   end
   
   def count(array)
@@ -17,28 +17,25 @@ module ProductsFilter
 end
 
 class Servlet < LiquidServlet
+  
   def index
     { 'date' => Time.now }
   end
   
   def products    
-    { 'products' => products_list, 'more_products' => more_products_list, 'description' => description, 'section' => 'Snowboards', 'cool_products' => true }
+    { 'products' => products_list, 'section' => 'Snowboards', 'cool_products' => true}    
-  end
-
-  private
-
-  def products_list
-    [{ 'name' => 'Arbor Draft', 'price' => 39900, 'description' => 'the *arbor draft* is a excellent product' },
-     { 'name' => 'Arbor Element', 'price' => 40000, 'description' => 'the *arbor element* rocks for freestyling' },
-     { '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
+
+  private
+  
+  def products_list
+    [{'name' => 'Arbor Draft', 'price' => 39900, 'description' => 'the *arbor draft* is a excellent product' },
+    {'name' => 'Arbor Element', 'price' => 40000, 'description' => 'the *arbor element* rocks for freestyling'},
+    {'name' => 'Arbor Diamond', 'price' => 59900, 'description' => 'the *arbor diamond* is a made up product because im obsessed with arbor and have no creativity'}]
+  end
+  
 end

example/server/liquid_servlet.rb

@@ -1,4 +1,5 @@
 class LiquidServlet < WEBrick::HTTPServlet::AbstractServlet
+
   def do_GET(req, res)
     handle(:get, req, res)
   end
@@ -10,19 +11,18 @@ class LiquidServlet < WEBrick::HTTPServlet::AbstractServlet
   private
   
   def handle(type, req, res)
-    @request = req
+    @request, @response = req, res
-    @response = res
     
-    @request.path_info =~ /(\w+)\z/
+    @request.path_info =~ /(\w+)$/
     @action = $1 || 'index'    
     @assigns = send(@action) if respond_to?(@action)    
 
     @response['Content-Type'] = "text/html"
     @response.status = 200
-    @response.body = Liquid::Template.parse(read_template).render(@assigns, filters: [ProductsFilter])
+    @response.body = Liquid::Template.parse(read_template).render(@assigns, :filters => [ProductsFilter])      
   end
   
   def read_template(filename = @action)
-    File.read("#{__dir__}/templates/#{filename}.liquid")
+    File.read( File.dirname(__FILE__) + "/templates/#{filename}.liquid" )
   end
 end

example/server/server.rb

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

example/server/templates/index.liquid

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

example/server/templates/products.liquid

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

ext/liquid/extconf.rb

@@ -0,0 +1,6 @@
+require 'mkmf'
+
+dir_config("liquid_ext")
+have_library("c", "main")
+
+create_makefile("liquid_ext")

ext/liquid/liquid_context.leg

@@ -0,0 +1,98 @@
+
+%{ 
+//uncomment to get more debug instrumentation
+//
+//#define YY_DEBUG 
+
+#include <ruby.h>
+
+#define EMIT(sym, data) \
+  rb_ary_push(ctx->rb_tokens, rb_ary_new3(2, ID2SYM(rb_intern(sym)), data)); 
+
+#define yy_rb_str rb_str_new(yytext, yyleng)
+
+#define YYSTYPE VALUE
+#define YY_CTX_LOCAL
+#define YY_CTX_MEMBERS VALUE rb_tokens; char *p; int p_len;
+
+#define YY_INPUT(buf, result, max_size) { \
+    result = ctx->p_len;  \
+    if (result>0 || EOF == ctx->p[0]) { \
+      if (max_size < result) { result = max_size; } \
+      strncpy(buf, ctx->p, result); \
+      buf[result] = '\0'; \
+      yyprintf((stderr, "\nREFILLING %d chars now:<%s>", result, buf));      \
+      ctx->p += result; ctx->p_len -= result; \
+      yyprintf((stderr, "\nREFILLING DONE size left: %d <%s>", ctx->p_len, ctx->p));      \
+    } \
+  }
+%}
+
+grammar  = primary
+         | entity
+         | range
+         | hash { EMIT("lookup", Qnil); }
+         ; 
+
+hash     = '[' (primary|entity) ']';
+
+primary  = var:const     { EMIT("id", var); }
+         | var:string    { EMIT("id", var); } 
+         | var:numeric   { EMIT("id", var); } 
+         ;
+
+accessors = hash         { EMIT("call", Qnil); }
+          | '.first'     { EMIT("buildin", rb_str_new2("first")); }
+          | '.last'      { EMIT("buildin", rb_str_new2("last")); }
+          | '.size'      { EMIT("buildin", rb_str_new2("size")); }          
+          | '.' <identifier>   { EMIT("id", yy_rb_str); EMIT("call", Qnil); } 
+          ;
+
+entity  = <identifier>   { EMIT("id", yy_rb_str); EMIT("lookup", Qnil); } 
+          accessors* 
+        ;
+
+rangelet = var:integer   { EMIT("id", var); }
+         | entity 
+         ;
+
+range    = '(' rangelet '..' rangelet ')' { EMIT("range", Qnil); } 
+
+
+string = ['] < ( !['] .  )* > [']  { $$ = yy_rb_str; }
+       | ["] < ( !["] .  )* > ["]  { $$ = yy_rb_str; }
+       ;
+
+numeric = float
+        | integer
+        ;
+
+float = <'-'? digit+'.'digit+>     { $$ = rb_funcall(rb_cObject, rb_intern("Float"), 1, yy_rb_str); }
+integer = <'-'? digit+>           { $$ = rb_funcall(rb_cObject, rb_intern("Integer"), 1, yy_rb_str); }
+
+
+const   = "true"    { $$ = Qtrue; }
+        | 'false'   { $$ = Qfalse; }
+        | 'nil'     { $$ = Qnil; }
+        | 'null'    { $$ = Qnil; }
+        ;
+
+digit = [0-9];
+identifier = [a-zA-Z][a-zA-Z0-9_\-]*[?!]?;
+
+%% 
+
+VALUE liquid_context_parse_impl(VALUE self, VALUE text) {
+  char *p; 
+  int len; 
+  yycontext ctx;  
+
+  memset(&ctx, 0, sizeof(yycontext));
+  ctx.p = RSTRING_PTR(text);  
+  ctx.p_len = (int) RSTRING_LEN(text);
+  ctx.rb_tokens = rb_ary_new();
+ 
+  yyparse(&ctx);
+
+  return ctx.rb_tokens;
+}

ext/liquid/liquid_ext.c

@@ -0,0 +1,13 @@
+#include <ruby.h>
+
+static VALUE rb_Liquid;
+static VALUE rb_Parser;
+
+VALUE liquid_context_parse_impl(VALUE text);
+
+void Init_liquid_ext()
+{
+  rb_Liquid = rb_define_module("Liquid");
+  rb_Parser = rb_define_class_under(rb_Liquid, "Parser", rb_cObject);
+  rb_define_singleton_method(rb_Parser, "parse", liquid_context_parse_impl, 1);  
+}

init.rb

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

lib/extras/liquid_view.rb

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

lib/liquid.rb

@@ -21,10 +21,9 @@
 
 module Liquid
   FilterSeparator             = /\|/
-  ArgumentSeparator           = ','.freeze
+  ArgumentSeparator           = ','
-  FilterArgumentSeparator     = ':'.freeze
+  FilterArgumentSeparator     = ':'
-  VariableAttributeSeparator  = '.'.freeze
+  VariableAttributeSeparator  = '.'
-  WhitespaceControl           = '-'.freeze
   TagStart                    = /\{\%/
   TagEnd                      = /\%\}/
   VariableSignature           = /\(?[\w\-\.\[\]]\)?/
@@ -34,46 +33,37 @@ 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              = /#{TagStart}|#{VariableStart}/o
+  AnyStartingTag              = /\{\{|\{\%/
-  PartialTemplateParser       = /#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableIncompleteEnd}/om
+  PartialTemplateParser       = /#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableIncompleteEnd}/o
-  TemplateParser              = /(#{PartialTemplateParser}|#{AnyStartingTag})/om
+  TemplateParser              = /(#{PartialTemplateParser}|#{AnyStartingTag})/o
   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/tablerowloop_drop'
-require 'liquid/forloop_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/tokenizer'
+require 'liquid_ext'
-require 'liquid/parse_context'
 
 # Load all the tags of the standard library
 #
-Dir["#{__dir__}/liquid/tags/*.rb"].each { |f| require f }
+Dir[File.dirname(__FILE__) + '/liquid/tags/*.rb'].each { |f| require f }

lib/liquid/block.rb

@@ -1,67 +1,115 @@
 module Liquid
+
   class Block < Tag
-    def initialize(tag_name, markup, options)
+    IsTag             = /^#{TagStart}/o
-      super
+    IsVariable        = /^#{VariableStart}/o
-      @blank = true
+    FullToken         = /^#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}$/o
-    end
+    ContentOfVariable = /^#{VariableStart}(.*)#{VariableEnd}$/o
 
     def parse(tokens)
-      @body = BlockBody.new
+      @nodelist ||= []
-      while parse_body(@body, tokens)
+      @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 render(context)
+    def end_tag
-      @body.render(context)
     end
 
-    def blank?
+    def unknown_tag(tag, params, tokens)
-      @blank
-    end
-
-    def nodelist
-      @body.nodelist
-    end
-
-    def unknown_tag(tag, _params, _tokens)
       case tag
-      when 'else'.freeze
+      when 'else'
-        raise SyntaxError.new(parse_context.locale.t("errors.syntax.unexpected_else".freeze,
+        raise SyntaxError, "#{block_name} tag does not expect else tag"
-          block_name: block_name))
+      when 'end'
-      when 'end'.freeze
+        raise SyntaxError, "'end' is not a valid delimiter for #{block_name} tags. use #{block_delimiter}"
-        raise SyntaxError.new(parse_context.locale.t("errors.syntax.invalid_delimiter".freeze,
-          block_name: block_name,
-          block_delimiter: block_delimiter))
       else
-        raise SyntaxError.new(parse_context.locale.t("errors.syntax.unknown_tag".freeze, tag: tag))
+        raise SyntaxError, "Unknown tag '#{tag}'"
       end
     end
 
+    def block_delimiter
+      "end#{block_name}"
+    end
+
     def block_name
       @tag_name
     end
 
-    def block_delimiter
+    def create_variable(token)
-      @block_delimiter ||= "end#{block_name}"
+      token.scan(ContentOfVariable) do |content|
+        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 parse_body(body, tokens)
+    def assert_missing_delimitation!
-      body.parse(tokens, parse_context) do |end_tag_name, end_tag_params|
+      raise SyntaxError.new("#{block_name} tag was never closed")
-        @blank &&= body.blank?
+    end
 
-        return false if end_tag_name == block_delimiter
+    def render_all(list, context)
-        unless end_tag_name
+      output = []
-          raise SyntaxError.new(parse_context.locale.t("errors.syntax.tag_never_closed".freeze, block_name: block_name))
+      list.each do |token|
+        # Break out if we have any unhanded interrupts.
+        break if context.has_interrupt?
+
+        begin
+          # If we get an Interrupt that means the block must stop processing. An
+          # Interrupt is any command that stops block execution such as {% break %} 
+          # or {% continue %}
+          if token.is_a? Continue or token.is_a? Break
+            context.push_interrupt(token.interrupt)
+            break
+          end
+
+          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
 
-      true
+      output
     end
   end
 end

lib/liquid/block_body.rb

@@ -1,140 +0,0 @@
-module Liquid
-  class BlockBody
-    FullToken = /\A#{TagStart}#{WhitespaceControl}?\s*(\w+)\s*(.*?)#{WhitespaceControl}?#{TagEnd}\z/om
-    ContentOfVariable = /\A#{VariableStart}#{WhitespaceControl}?(.*?)#{WhitespaceControl}?#{VariableEnd}\z/om
-    TAGSTART = "{%".freeze
-    VARSTART = "{{".freeze
-
-    attr_reader :nodelist
-
-    def initialize
-      @nodelist = []
-      @blank = true
-    end
-
-    def parse(tokenizer, parse_context)
-      parse_context.line_number = tokenizer.line_number
-      while token = tokenizer.shift
-        unless token.empty?
-          case
-          when token.start_with?(TAGSTART)
-            whitespace_handler(token, parse_context)
-            if token =~ FullToken
-              tag_name = $1
-              markup = $2
-              # fetch the tag from registered blocks
-              if tag = registered_tags[tag_name]
-                new_tag = tag.parse(tag_name, markup, tokenizer, parse_context)
-                @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, parse_context)
-            end
-          when token.start_with?(VARSTART)
-            whitespace_handler(token, parse_context)
-            @nodelist << create_variable(token, parse_context)
-            @blank = false
-          else
-            if parse_context.trim_whitespace
-              token.lstrip!
-            end
-            parse_context.trim_whitespace = false
-            @nodelist << token
-            @blank &&= !!(token =~ /\A\s*\z/)
-          end
-        end
-        parse_context.line_number = tokenizer.line_number
-      end
-
-      yield nil, nil
-    end
-
-    def whitespace_handler(token, parse_context)
-      if token[2] == WhitespaceControl
-        previous_token = @nodelist.last
-        if previous_token.is_a? String
-          previous_token.rstrip!
-        end
-      end
-      parse_context.trim_whitespace = (token[-3] == WhitespaceControl)
-    end
-
-    def blank?
-      @blank
-    end
-
-    def render(context)
-      output = []
-      context.resource_limits.render_score += @nodelist.length
-
-      @nodelist.each do |token|
-        # Break out if we have any unhanded interrupts.
-        break if context.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) || token.is_a?(Break)
-            context.push_interrupt(token.interrupt)
-            break
-          end
-
-          node_output = render_node(token, context)
-
-          unless token.is_a?(Block) && token.blank?
-            output << node_output
-          end
-        rescue MemoryError => e
-          raise e
-        rescue UndefinedVariable, UndefinedDropMethod, UndefinedFilter => e
-          context.handle_error(e, token.line_number)
-          output << nil
-        rescue ::StandardError => e
-          line_number = token.is_a?(String) ? nil : token.line_number
-          output << context.handle_error(e, line_number)
-        end
-      end
-
-      output.join
-    end
-
-    private
-
-    def render_node(node, context)
-      node_output = node.is_a?(String) ? node : node.render(context)
-      node_output = node_output.is_a?(Array) ? node_output.join : node_output.to_s
-
-      context.resource_limits.render_length += node_output.length
-      if context.resource_limits.reached?
-        raise MemoryError.new("Memory limits exceeded".freeze)
-      end
-      node_output
-    end
-
-    def create_variable(token, parse_context)
-      token.scan(ContentOfVariable) do |content|
-        markup = content.first
-        return Variable.new(markup, parse_context)
-      end
-      raise_missing_variable_terminator(token, parse_context)
-    end
-
-    def raise_missing_tag_terminator(token, parse_context)
-      raise SyntaxError.new(parse_context.locale.t("errors.syntax.tag_termination".freeze, token: token, tag_end: TagEnd.inspect))
-    end
-
-    def raise_missing_variable_terminator(token, parse_context)
-      raise SyntaxError.new(parse_context.locale.t("errors.syntax.variable_termination".freeze, token: token, tag_end: VariableEnd.inspect))
-    end
-
-    def registered_tags
-      Template.tags
-    end
-  end
-end

lib/liquid/condition.rb

@@ -3,27 +3,19 @@ module Liquid
   #
   # Example:
   #
-  #   c = Condition.new(1, '==', 1)
+  #   c = Condition.new('1', '==', '1')
   #   c.evaluate #=> true
   #
   class Condition #:nodoc:
-    @@depth = 0
     @@operators = {
-      '=='.freeze => ->(cond, left, right) {  cond.send(:equal_variables, left, right) },
+      '==' => lambda { |cond, left, right|  cond.send(:equal_variables, left, right) },
-      '!='.freeze => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
+      '!=' => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
-      '<>'.freeze => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
+      '<>' => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
-      '<'.freeze  => :<,
+      '<'  => :<,
-      '>'.freeze  => :>,
+      '>'  => :>,
-      '>='.freeze => :>=,
+      '>=' => :>=,
-      '<='.freeze => :<=,
+      '<=' => :<=,
-      'contains'.freeze => lambda do |cond, left, right|
+      'contains' => lambda { |cond, left, right| left && right ? left.include?(right) : false }
-        if left && right && left.respond_to?(:include?)
-          right = right.to_s if left.is_a?(String)
-          left.include?(right)
-        else
-          false
-        end
-      end
     }
 
     def self.operators
@@ -34,9 +26,7 @@ module Liquid
     attr_accessor :left, :operator, :right
 
     def initialize(left = nil, operator = nil, right = nil)
-      @left = left
+      @left, @operator, @right = left, operator, right
-      @operator = operator
-      @right = right
       @child_relation  = nil
       @child_condition = nil
     end
@@ -48,11 +38,6 @@ module Liquid
       when :or
         result || @child_condition.evaluate(context)
       when :and
-        @@depth += 1
-        if @@depth >= 500
-          @@depth = 0
-          raise StackLevelError, "Nesting too deep".freeze
-        end
         result && @child_condition.evaluate(context)
       else
         result
@@ -60,13 +45,11 @@ module Liquid
     end
 
     def or(condition)
-      @child_relation = :or
+      @child_relation, @child_condition = :or, condition
-      @child_condition = condition
     end
 
     def and(condition)
-      @child_relation = :and
+      @child_relation, @child_condition = :and, condition
-      @child_condition = condition
     end
 
     def attach(attachment)
@@ -78,23 +61,23 @@ module Liquid
     end
 
     def inspect
-      "#<Condition #{[@left, @operator, @right].compact.join(' '.freeze)}>"
+      "#<Condition #{[@left, @operator, @right].compact.join(' ')}>"
     end
 
     private
 
     def equal_variables(left, right)
-      if left.is_a?(Liquid::Expression::MethodLiteral)
+      if left.is_a?(Symbol)
-        if right.respond_to?(left.method_name)
+        if right.respond_to?(left)
-          return right.send(left.method_name)
+          return right.send(left.to_s)
         else
           return nil
         end
       end
 
-      if right.is_a?(Liquid::Expression::MethodLiteral)
+      if right.is_a?(Symbol)
-        if left.respond_to?(right.method_name)
+        if left.respond_to?(right)
-          return left.send(right.method_name)
+          return left.send(right.to_s)
         else
           return nil
         end
@@ -107,32 +90,31 @@ module Liquid
       # If the operator is empty this means that the decision statement is just
       # a single variable. We can just poll this variable from the context and
       # return this as the result.
-      return context.evaluate(left) if op.nil?
+      return context[left] if op == nil
 
-      left = context.evaluate(left)
+      left, right = context[left], context[right]
-      right = context.evaluate(right)
 
-      operation = self.class.operators[op] || raise(Liquid::ArgumentError.new("Unknown operator #{op}"))
+      operation = self.class.operators[op] || raise(ArgumentError.new("Unknown operator #{op}"))
 
       if operation.respond_to?(:call)
         operation.call(self, left, right)
-      elsif left.respond_to?(operation) && right.respond_to?(operation) && !left.is_a?(Hash) && !right.is_a?(Hash)
+      elsif left.respond_to?(operation) and right.respond_to?(operation)
-        begin
+        left.send(operation, right)
-          left.send(operation, right)
+      else
-        rescue ::ArgumentError => e
+        nil
-          raise Liquid::ArgumentError.new(e.message)
-        end
       end
     end
   end
 
+
   class ElseCondition < Condition
     def else?
       true
     end
 
-    def evaluate(_context)
+    def evaluate(context)
       true
     end
   end
+
 end

lib/liquid/context.rb

@@ -1,4 +1,6 @@
 module Liquid
+
+  
   # Context keeps the variable stack and resolves variables, as well as keywords
   #
   #   context['variable'] = 'testing'
@@ -12,37 +14,21 @@ module Liquid
   #
   #   context['bob']  #=> nil  class Context
   class Context
-    attr_reader :scopes, :errors, :registers, :environments, :resource_limits
+    attr_reader :scopes, :errors, :registers, :environments
-    attr_accessor :exception_renderer, :template_name, :partial, :global_filter, :strict_variables, :strict_filters
 
-    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil)
+    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false)
-      @environments     = [environments].flatten
+      @environments   = [environments].flatten
-      @scopes           = [(outer_scope || {})]
+      @scopes         = [(outer_scope || {})]
-      @registers        = registers
+      @registers      = registers
-      @errors           = []
+      @errors         = []
-      @partial          = false
+      @rethrow_errors = rethrow_errors
-      @strict_variables = false
-      @resource_limits  = resource_limits || ResourceLimits.new(Template.default_resource_limits)
       squash_instance_assigns_with_environments
 
-      @this_stack_used = false
-
-      self.exception_renderer = Template.default_exception_renderer
-      if rethrow_errors
-        self.exception_renderer = ->(e) { raise }
-      end
-
       @interrupts = []
-      @filters = []
-      @global_filter = nil
-    end
-
-    def warnings
-      @warnings ||= []
     end
 
     def strainer
-      @strainer ||= Strainer.create(self, @filters)
+      @strainer ||= Strainer.create(self)
     end
 
     # Adds filters to this context.
@@ -51,16 +37,16 @@ module Liquid
     # for that
     def add_filters(filters)
       filters = [filters].flatten.compact
-      @filters += filters
-      @strainer = nil
-    end
 
-    def apply_global_filter(obj)
+      filters.each do |f|
-      global_filter.nil? ? obj : global_filter.call(obj)
+        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 interrupt?
+    def has_interrupt?
       !@interrupts.empty?
     end
 
@@ -74,22 +60,26 @@ module Liquid
       @interrupts.pop
     end
 
-    def handle_error(e, line_number = nil)
+    def handle_error(e)
-      e = internal_error unless e.is_a?(Liquid::Error)
-      e.template_name ||= template_name
-      e.line_number ||= line_number
       errors.push(e)
-      exception_renderer.call(e).to_s
+      raise if @rethrow_errors
+
+      case e
+      when SyntaxError
+        "Liquid syntax error: #{e.message}"
+      else
+        "Liquid error: #{e.message}"
+      end
     end
 
     def invoke(method, *args)
-      strainer.invoke(method, *args).to_liquid
+      strainer.invoke(method, *args)
     end
 
     # Push new local scope on the stack. use <tt>Context#stack</tt> instead
-    def push(new_scope = {})
+    def push(new_scope={})
       @scopes.unshift(new_scope)
-      raise StackLevelError, "Nesting too deep".freeze if @scopes.length > 100
+      raise StackLevelError, "Nesting too deep" if @scopes.length > 100
     end
 
     # Merge a hash of variables in the current local scope
@@ -111,33 +101,17 @@ module Liquid
     #   end
     #
     #   context['var]  #=> nil
-    def stack(new_scope = nil)
+    def stack(new_scope={})
-      old_stack_used = @this_stack_used
+      push(new_scope)
-      if new_scope
-        push(new_scope)
-        @this_stack_used = true
-      else
-        @this_stack_used = false
-      end
-
       yield
     ensure
-      pop if @this_stack_used
+      pop
-      @this_stack_used = old_stack_used
     end
 
     def clear_instance_assigns
       @scopes[0] = {}
     end
 
-    # Only allow String, Numeric, Hash, Array, Proc, Boolean or <tt>Liquid::Drop</tt>
-    def []=(key, value)
-      unless @this_stack_used
-        @this_stack_used = true
-        push({})
-      end
-      @scopes[0][key] = value
-    end
 
     # Look up variable, either resolve directly after considering the name. We can directly handle
     # Strings, digits, floats and booleans (true,false).
@@ -147,78 +121,139 @@ module Liquid
     #
     # Example:
     #   products == empty #=> products.empty?
-    def [](expression)
+    def resolve(key)        
-      evaluate(Expression.parse(expression))
+      case key
-    end
+      when nil, ""
+        return nil
+      when "blank"
+        return :blank?
+      when "empty"
+        return :empty?
+      end
       
-    def key?(key)
+      result = Parser.parse(key)   
-      self[key] != nil
+      stack = []
-    end
 
-    def evaluate(object)
+      result.each do |(sym, value)|          
-      object.respond_to?(:evaluate) ? object.evaluate(self) : object
-    end
 
-    # Fetches an object starting at the local scope and then moving up the hierachy
+        case sym
-    def find_variable(key, raise_on_not_found: true)
+        when :id
-      # This was changed from find() to find_index() because this is a very hot
+          stack.push value
-      # path and find_index() is optimized in MRI to reduce object allocation
+        when :lookup
-      index = @scopes.find_index { |s| s.key?(key) }
+          left = stack.pop
-      scope = @scopes[index] if index
+          value = find_variable(left)
           
-      variable = nil
+          stack.push(harden(value))
+        when :range
+          right = stack.pop.to_i
+          left  = stack.pop.to_i
           
-      if scope.nil?
+          stack.push (left..right)
-        @environments.each do |e|
+        when :buildin
-          variable = lookup_and_evaluate(e, key, raise_on_not_found: raise_on_not_found)
+          left = stack.pop
-          unless variable.nil?
+          value = invoke_buildin(left, value)
-            scope = e
+          
-            break
+          stack.push(harden(value))
-          end
+        when :call
+          left = stack.pop
+          right = stack.pop
+          value = lookup_and_evaluate(right, left)
+
+          stack.push(harden(value))
+        else 
+          raise "unknown #{sym}"
         end
       end
 
-      scope ||= @environments.last || @scopes.last
+      return stack.first
-      variable ||= lookup_and_evaluate(scope, key, raise_on_not_found: raise_on_not_found)
-
-      variable = variable.to_liquid
-      variable.context = self if variable.respond_to?(:context=)
-
-      variable
     end
 
-    def lookup_and_evaluate(obj, key, raise_on_not_found: true)
-      if @strict_variables && raise_on_not_found && obj.respond_to?(:key?) && !obj.key?(key)
-        raise Liquid::UndefinedVariable, "undefined variable #{key}"
-      end
 
-      value = obj[key]
+    # Only allow String, Numeric, Hash, Array, Proc, Boolean or <tt>Liquid::Drop</tt>
-
+    def []=(key, value)
-      if value.is_a?(Proc) && obj.respond_to?(:[]=)
+      @scopes[0][key] = value
-        obj[key] = (value.arity == 0) ? value.call : value.call(self)
-      else
-        value
-      end
     end
 
+    def has_key?(key)
+      resolve(key) != nil
+    end
+
+    alias_method :[], :resolve
+
     private
 
-    def internal_error
+      def invoke_buildin(obj, key)
-      # raise and catch to set backtrace and cause on exception
+        # as weird as this is, liquid unit tests demand that we prioritize hash lookups 
-      raise Liquid::InternalError, 'internal'
+        # to buildins. So if we got a hash and it has a :first element we need to call that 
-    rescue Liquid::InternalError => exc
+        # instead of sending the first message...
-      exc
-    end
 
-    def squash_instance_assigns_with_environments
+        if obj.respond_to?(:has_key?) && obj.has_key?(key)
-      @scopes.last.each_key do |k|
+          return lookup_and_evaluate(obj, key)
-        @environments.each do |env|
+        end
-          if env.key?(k)
+
-            scopes.last[k] = lookup_and_evaluate(env, k)
+        if obj.respond_to?(key) 
-            break
+          return obj.send(key)
-          end
+        else
+          return nil    
         end
       end
-    end # squash_instance_assigns_with_environments
+
+      # 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)
+
+        return variable
+      end
+
+      def lookup_and_evaluate(obj, key)
+        return nil unless obj.respond_to?(:[])
+        
+        if obj.is_a?(Array)
+          return nil unless key.is_a?(Integer)
+        end
+
+        value = obj[key]
+
+        if value.is_a?(Proc)      
+          # call the proc
+          value = (value.arity == 0) ? value.call : value.call(self)
+
+          # memozie if possible
+          obj[key] = value if obj.respond_to?(:[]=)
+        end
+
+        value
+      end
+
+      def harden(value)
+        value = value.to_liquid
+        value.context = self if value.respond_to?(:context=)
+        return value
+      end
+
+      def squash_instance_assigns_with_environments
+        @scopes.last.each_key do |k|
+          @environments.each do |env|
+            if env.has_key?(k)
+              scopes.last[k] = lookup_and_evaluate(env, k)
+              break
+            end
+          end
+        end
+      end # squash_instance_assigns_with_environments
+
   end # Context
+
 end # Liquid

lib/liquid/document.rb

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

lib/liquid/drop.rb

@@ -1,6 +1,7 @@
 require 'set'
 
 module Liquid
+
   # A drop in liquid is a class which allows you to export DOM like things to liquid.
   # Methods of drops are callable.
   # The main use for liquid drops is to implement lazy loaded objects.
@@ -18,61 +19,43 @@ module Liquid
   #   tmpl = Liquid::Template.parse( ' {% for product in product.top_sales %} {{ product.name }} {%endfor%} '  )
   #   tmpl.render('product' => ProductDrop.new ) # will invoke top_sales query.
   #
-  # Your drop can either implement the methods sans any parameters
+  # Your drop can either implement the methods sans any parameters or implement the before_method(name) method which is a
-  # or implement the liquid_method_missing(name) method which is a catch all.
+  # catch all.
   class Drop
     attr_writer :context
 
+    EMPTY_STRING = ''.freeze
+
     # Catch all for the method
-    def liquid_method_missing(method)
+    def before_method(method)
-      return nil unless @context && @context.strict_variables
+      nil
-      raise Liquid::UndefinedDropMethod, "undefined method #{method}"
     end
 
     # called by liquid to invoke a drop
     def invoke_drop(method_or_key)
-      if self.class.invokable?(method_or_key)
+      if method_or_key && method_or_key != EMPTY_STRING && self.class.invokable?(method_or_key)
         send(method_or_key)
       else
-        liquid_method_missing(method_or_key)
+        before_method(method_or_key)
       end
     end
 
-    def key?(_name)
+    def has_key?(name)
       true
     end
 
-    def inspect
-      self.class.to_s
-    end
-
     def to_liquid
       self
     end
 
-    def to_s
+    alias :[] :invoke_drop
-      self.class.name
-    end
 
-    alias_method :[], :invoke_drop
+    private
 
     # Check for method existence without invoking respond_to?, which creates symbols
     def self.invokable?(method_name)
-      invokable_methods.include?(method_name.to_s)
+      @invokable_methods ||= Set.new((public_instance_methods - Liquid::Drop.public_instance_methods).map(&:to_s))
-    end
+      @invokable_methods.include?(method_name.to_s)
-
-    def self.invokable_methods
-      @invokable_methods ||= begin
-        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)
-        Set.new(whitelist.map(&:to_s))
-      end
     end
   end
 end

lib/liquid/errors.rb

@@ -1,56 +1,11 @@
 module Liquid
-  class Error < ::StandardError
+  class Error < ::StandardError; end
-    attr_accessor :line_number
-    attr_accessor :template_name
-    attr_accessor :markup_context
   
-    def to_s(with_prefix = true)
+  class ArgumentError < Error; end
-      str = ""
+  class ContextError < Error; end
-      str << message_prefix if with_prefix
+  class FilterNotFound < Error; end
-      str << super()
+  class FileSystemError < Error; end
-
+  class StandardError < Error; end
-      if markup_context
+  class SyntaxError < Error; end
-        str << " "
+  class StackLevelError < Error; end
-        str << markup_context
-      end
-
-      str
-    end
-
-    private
-
-    def message_prefix
-      str = ""
-      if is_a?(SyntaxError)
-        str << "Liquid syntax error"
-      else
-        str << "Liquid error"
-      end
-
-      if line_number
-        str << " ("
-        str << template_name << " " if template_name
-        str << "line " << line_number.to_s << ")"
-      end
-
-      str << ": "
-      str
-    end
-  end
-
-  ArgumentError = Class.new(Error)
-  ContextError = Class.new(Error)
-  FileSystemError = Class.new(Error)
-  StandardError = Class.new(Error)
-  SyntaxError = Class.new(Error)
-  StackLevelError = Class.new(Error)
-  TaintedError = Class.new(Error)
-  MemoryError = Class.new(Error)
-  ZeroDivisionError = Class.new(Error)
-  FloatDomainError = Class.new(Error)
-  UndefinedVariable = Class.new(Error)
-  UndefinedDropMethod = Class.new(Error)
-  UndefinedFilter = Class.new(Error)
-  MethodOverrideError = Class.new(Error)
-  InternalError = Class.new(Error)
 end

lib/liquid/expression.rb

@@ -1,45 +0,0 @@
-module Liquid
-  class Expression
-    class MethodLiteral
-      attr_reader :method_name, :to_s
-
-      def initialize(method_name, to_s)
-        @method_name = method_name
-        @to_s = to_s
-      end
-
-      def to_liquid
-        to_s
-      end
-    end
-
-    LITERALS = {
-      nil => nil, 'nil'.freeze => nil, 'null'.freeze => nil, ''.freeze => nil,
-      'true'.freeze  => true,
-      'false'.freeze => false,
-      'blank'.freeze => MethodLiteral.new(:blank?, '').freeze,
-      'empty'.freeze => MethodLiteral.new(:empty?, '').freeze
-    }
-
-    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/extensions.rb

@@ -7,50 +7,44 @@ class String # :nodoc:
   end
 end
 
-class Array # :nodoc:
+class Array  # :nodoc:
   def to_liquid
     self
   end
 end
 
-class Hash # :nodoc:
+class Hash  # :nodoc:
   def to_liquid
     self
   end
 end
 
-class Numeric # :nodoc:
+class Numeric  # :nodoc:
   def to_liquid
     self
   end
 end
 
-class Range # :nodoc:
+class Time  # :nodoc:
   def to_liquid
     self
   end
 end
 
-class Time # :nodoc:
+class DateTime < Date  # :nodoc:
   def to_liquid
     self
   end
 end
 
-class DateTime < Date # :nodoc:
+class Date  # :nodoc:
-  def to_liquid
-    self
-  end
-end
-
-class Date # :nodoc:
   def to_liquid
     self
   end
 end
 
 class TrueClass
-  def to_liquid # :nodoc:
+  def to_liquid  # :nodoc:
     self
   end
 end

lib/liquid/file_system.rb

@@ -1,5 +1,5 @@
 module Liquid
-  # A Liquid file system is a way to let your templates retrieve other templates for use with the include tag.
+  # A Liquid file system is 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.
@@ -8,13 +8,13 @@ module Liquid
   #
   # Example:
   #
-  #   Liquid::Template.file_system = Liquid::LocalFileSystem.new(template_path)
+  # Liquid::Template.file_system = Liquid::LocalFileSystem.new(template_path)
-  #   liquid = Liquid::Template.parse(template)
+  # liquid = Liquid::Template.parse(template)
   #
   # This will parse the template with a LocalFileSystem implementation rooted at 'template_path'.
   class BlankFileSystem
     # Called by Liquid to retrieve a template file
-    def read_template_file(_template_path)
+    def read_template_file(template_path, context)
       raise FileSystemError, "This liquid context does not allow includes."
     end
   end
@@ -26,46 +26,35 @@ module Liquid
   #
   # Example:
   #
-  #   file_system = Liquid::LocalFileSystem.new("/some/path")
+  # file_system = Liquid::LocalFileSystem.new("/some/path")
   # 
-  #   file_system.full_path("mypartial")       # => "/some/path/_mypartial.liquid"
+  # file_system.full_path("mypartial")       # => "/some/path/_mypartial.liquid"
-  #   file_system.full_path("dir/mypartial")   # => "/some/path/dir/_mypartial.liquid"
+  # file_system.full_path("dir/mypartial")   # => "/some/path/dir/_mypartial.liquid"
-  #
-  # Optionally in the second argument you can specify a custom pattern for template filenames.
-  # The Kernel::sprintf format specification is used.
-  # Default pattern is "_%s.liquid".
-  #
-  # Example:
-  #
-  #   file_system = Liquid::LocalFileSystem.new("/some/path", "%s.html")
-  #
-  #   file_system.full_path("index") # => "/some/path/index.html"
   #
   class LocalFileSystem
     attr_accessor :root
     
-    def initialize(root, pattern = "_%s.liquid".freeze)
+    def initialize(root)
       @root = root
-      @pattern = pattern
     end
     
-    def read_template_file(template_path)
+    def read_template_file(template_path, context)
       full_path = full_path(template_path)
-      raise FileSystemError, "No such template '#{template_path}'" unless File.exist?(full_path)
+      raise FileSystemError, "No such template '#{template_path}'" unless File.exists?(full_path)
       
       File.read(full_path)
     end
     
     def full_path(template_path)
-      raise FileSystemError, "Illegal template name '#{template_path}'" unless template_path =~ /\A[^.\/][a-zA-Z0-9_\/]+\z/
+      raise FileSystemError, "Illegal template name '#{template_path}'" unless template_path =~ /^[^.\/][a-zA-Z0-9_\/]+$/
       
-      full_path = if template_path.include?('/'.freeze)
+      full_path = if template_path.include?('/')
-        File.join(root, File.dirname(template_path), @pattern % File.basename(template_path))
+        File.join(root, File.dirname(template_path), "_#{File.basename(template_path)}.liquid")
       else
-        File.join(root, @pattern % template_path)
+        File.join(root, "_#{template_path}.liquid")
       end
       
-      raise FileSystemError, "Illegal template path '#{File.expand_path(full_path)}'" unless File.expand_path(full_path).start_with?(File.expand_path(root))
+      raise FileSystemError, "Illegal template path '#{File.expand_path(full_path)}'" unless File.expand_path(full_path) =~ /^#{File.expand_path(root)}/
       
       full_path
     end

lib/liquid/forloop_drop.rb

@@ -1,42 +0,0 @@
-module Liquid
-  class ForloopDrop < Drop
-    def initialize(name, length, parentloop)
-      @name = name
-      @length = length
-      @parentloop = parentloop
-      @index = 0
-    end
-
-    attr_reader :name, :length, :parentloop
-
-    def index
-      @index + 1
-    end
-
-    def index0
-      @index
-    end
-
-    def rindex
-      @length - @index
-    end
-
-    def rindex0
-      @length - @index - 1
-    end
-
-    def first
-      @index == 0
-    end
-
-    def last
-      @index == @length - 1
-    end
-
-    protected
-
-    def increment!
-      @index += 1
-    end
-  end
-end

lib/liquid/htmltags.rb

@@ -0,0 +1,119 @@
+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
+        @idx_i = "#{$1}-#{$2}-i"
+        @idx_col = "#{$1}-#{$2}-c"
+        @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)
+      context.registers[:tablerowloop] ||= Hash.new(0)
+
+      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
+
+        context.registers[:tablerowloop][@idx]
+        context['tablerowloop'] = lambda { Tablerowloop.new(@idx_i, @idx_col, length) }
+        collection.each_with_index do |item, index|
+          context.registers[:tablerowloop][@idx_i] = index
+          context.registers[:tablerowloop][@idx_col] = col
+          context[@variable_name] = item          
+
+          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
+
+
+
+    private
+
+      class Tablerowloop < Liquid::Drop
+        attr_accessor :length
+
+        def initialize(idx_i, idx_col, length)
+          @idx_i, @idx_col, @length = idx_i, idx_col, length
+        end
+
+        def index
+          @context.registers[:tablerowloop][@idx_i] + 1
+        end
+
+        def index0
+          @context.registers[:tablerowloop][@idx_i]
+        end
+
+        def rindex
+          length - @context.registers[:tablerowloop][@idx_i]
+        end
+
+        def rindex0
+          length - @context.registers[:tablerowloop][@idx_i] - 1
+        end
+
+        def first
+          (@context.registers[:tablerowloop][@idx_i] == 0)
+        end
+
+        def last
+          (@context.registers[:tablerowloop][@idx_i] == length - 1)
+        end
+
+        def col
+          @context.registers[:tablerowloop][@idx_col] + 1
+        end
+
+        def col0
+          @context.registers[:tablerowloop][@idx_col]
+        end
+
+        def col_first
+          (@context.registers[:tablerowloop][@idx_col] == 0)
+        end
+
+        def col_last
+          (@context.registers[:tablerowloop][@idx_col] == cols - 1)
+        end
+      end
+  end
+
+  Template.register_tag('tablerow', TableRow)
+end

lib/liquid/i18n.rb

@@ -1,39 +0,0 @@
-require 'yaml'
-
-module Liquid
-  class I18n
-    DEFAULT_LOCALE = File.join(File.expand_path(__dir__), "locales", "en.yml")
-
-    TranslationError = Class.new(StandardError)
-
-    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+)\}/) do
-        # raise TranslationError, "Undefined key #{$1} for interpolation in translation #{name}"  unless vars[$1.to_sym]
-        "#{vars[$1.to_sym]}"
-      end
-    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

@@ -1,10 +1,11 @@
 module Liquid
+
   # An interrupt is any command that breaks processing of a block (ex: a for loop).
   class Interrupt
     attr_reader :message
 
-    def initialize(message = nil)
+    def initialize(message=nil)
-      @message = message || "interrupt".freeze
+      @message = message || "interrupt"
     end
   end
 

lib/liquid/lexer.rb

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

lib/liquid/locales/en.yml

@@ -1,26 +0,0 @@
----
-  errors:
-    syntax:
-      tag_unexpected_args: "Syntax Error in '%{tag}' - Valid syntax: %{tag}"
-      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"
-    argument:
-      include: "Argument error in tag 'include' - Illegal template name"

lib/liquid/module_ex.rb

@@ -0,0 +1,62 @@
+# Copyright 2007 by Domizio Demichelis
+# 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
+# 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
+#   liquid_methods :an_allowed_method
+#
+#   def an_allowed_method
+#     'this comes from an allowed method'
+#   end
+#   def unallowed_method
+#     'this will never be an output'
+#   end
+# end
+#
+# if you want to extend the drop to other methods you can defines more methods
+# in the class <YourClass>::LiquidDropClass
+#
+#   class SomeClass::LiquidDropClass
+#     def another_allowed_method
+#       'and this from another allowed method'
+#     end
+#   end
+# end
+#
+# usage:
+# @something = SomeClass.new
+#
+# template:
+# {{something.an_allowed_method}}{{something.unallowed_method}} {{something.another_allowed_method}}
+#
+# output:
+# '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
+        end
+      end
+    end
+  end
+
+end

lib/liquid/parse_context.rb

@@ -1,37 +0,0 @@
-module Liquid
-  class ParseContext
-    attr_accessor :locale, :line_number, :trim_whitespace
-    attr_reader :partial, :warnings, :error_mode
-
-    def initialize(options = {})
-      @template_options = options ? options.dup : {}
-      @locale = @template_options[:locale] ||= I18n.new
-      @warnings = []
-      self.partial = false
-    end
-
-    def [](option_key)
-      @options[option_key]
-    end
-
-    def partial=(value)
-      @partial = value
-      @options = value ? partial_options : @template_options
-      @error_mode = @options[:error_mode] || Template.error_mode
-      value
-    end
-
-    def partial_options
-      @partial_options ||= begin
-        dont_pass = @template_options[:include_options_blacklist]
-        if dont_pass == true
-          { locale: locale }
-        elsif dont_pass.is_a?(Array)
-          @template_options.reject { |k, v| dont_pass.include?(k) }
-        else
-          @template_options
-        end
-      end
-    end
-  end
-end

lib/liquid/parser.rb

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

@@ -1,31 +0,0 @@
-module Liquid
-  module ParserSwitching
-    def parse_with_selected_parser(markup)
-      case parse_context.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
-          parse_context.warnings << e
-          return lax_parse(markup)
-        end
-      end
-    end
-
-    private
-
-    def strict_parse_with_error_context(markup)
-      strict_parse(markup)
-    rescue SyntaxError => e
-      e.line_number = line_number
-      e.markup_context = markup_context(markup)
-      raise e
-    end
-
-    def markup_context(markup)
-      "in \"#{markup.strip}\""
-    end
-  end
-end

lib/liquid/profiler.rb

@@ -1,158 +0,0 @@
-require 'liquid/profiler/hooks'
-
-module Liquid
-  # Profiler enables support for profiling template rendering to help track down performance issues.
-  #
-  # To enable profiling, first require 'liquid/profiler'.
-  # Then, to profile a parse/render cycle, pass the <tt>profile: true</tt> option to <tt>Liquid::Template.parse</tt>.
-  # After <tt>Liquid::Template#render</tt> is called, the template object makes available an instance of this
-  # class via the <tt>Liquid::Template#profiler</tt> method.
-  #
-  #   template = Liquid::Template.parse(template_content, profile: true)
-  #   output  = template.render
-  #   profile = template.profiler
-  #
-  # This object contains all profiling information, containing information on what tags were rendered,
-  # where in the templates these tags live, and how long each tag took to render.
-  #
-  # This is a tree structure that is Enumerable all the way down, and keeps track of tags and rendering times
-  # inside of <tt>{% include %}</tt> tags.
-  #
-  #   profile.each do |node|
-  #     # Access to the node 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(node, partial)
-        @code        = node.respond_to?(:raw) ? node.raw : node
-        @partial     = partial
-        @line_number = node.respond_to?(:line_number) ? node.line_number : nil
-        @children    = []
-      end
-
-      def self.start(node, partial)
-        new(node, partial).tap(&:start)
-      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_node_render(node)
-      if Profiler.current_profile && node.respond_to?(:render)
-        Profiler.current_profile.start_node(node)
-        output = yield
-        Profiler.current_profile.end_node(node)
-        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_node(node)
-      @timing_stack.push(Timing.start(node, current_partial))
-    end
-
-    def end_node(_node)
-      timing = @timing_stack.pop
-      timing.finish
-
-      @timing_stack.last.children << timing
-    end
-
-    def current_partial
-      @partial_stack.last
-    end
-
-    def push_partial(partial_name)
-      @partial_stack.push(partial_name)
-    end
-
-    def pop_partial
-      @partial_stack.pop
-    end
-  end
-end

lib/liquid/profiler/hooks.rb

@@ -1,23 +0,0 @@
-module Liquid
-  class BlockBody
-    def render_node_with_profiling(node, context)
-      Profiler.profile_node_render(node) do
-        render_node_without_profiling(node, context)
-      end
-    end
-
-    alias_method :render_node_without_profiling, :render_node
-    alias_method :render_node, :render_node_with_profiling
-  end
-
-  class Include < Tag
-    def render_with_profiling(context)
-      Profiler.profile_children(context.evaluate(@template_name_expr).to_s) do
-        render_without_profiling(context)
-      end
-    end
-
-    alias_method :render_without_profiling, :render
-    alias_method :render, :render_with_profiling
-  end
-end

lib/liquid/range_lookup.rb

@@ -1,37 +0,0 @@
-module Liquid
-  class RangeLookup
-    def self.parse(start_markup, end_markup)
-      start_obj = Expression.parse(start_markup)
-      end_obj = Expression.parse(end_markup)
-      if start_obj.respond_to?(:evaluate) || end_obj.respond_to?(:evaluate)
-        new(start_obj, end_obj)
-      else
-        start_obj.to_i..end_obj.to_i
-      end
-    end
-
-    def initialize(start_obj, end_obj)
-      @start_obj = start_obj
-      @end_obj = end_obj
-    end
-
-    def evaluate(context)
-      start_int = to_integer(context.evaluate(@start_obj))
-      end_int = to_integer(context.evaluate(@end_obj))
-      start_int..end_int
-    end
-
-    private
-
-    def to_integer(input)
-      case input
-      when Integer
-        input
-      when NilClass, String
-        input.to_i
-      else
-        Utils.to_integer(input)
-      end
-    end
-  end
-end

lib/liquid/resource_limits.rb

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

lib/liquid/standardfilters.rb

@@ -1,28 +1,21 @@
 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 an input string to DOWNCASE
+    # convert a input string to DOWNCASE
     def downcase(input)
       input.to_s.downcase
     end
 
-    # convert an input string to UPCASE
+    # convert a input string to UPCASE
     def upcase(input)
       input.to_s.upcase
     end
@@ -33,51 +26,31 @@ module Liquid
     end
 
     def escape(input)
-      CGI.escapeHTML(input).untaint unless input.nil?
+      CGI.escapeHTML(input) rescue input
     end
-    alias_method :h, :escape
 
     def escape_once(input)
-      input.to_s.gsub(HTML_ESCAPE_ONCE_REGEXP, HTML_ESCAPE)
+      ActionView::Helpers::TagHelper.escape_once(input)
+    rescue NameError
+      input
     end
 
-    def url_encode(input)
+    alias_method :h, :escape
-      CGI.escape(input) unless input.nil?
-    end
-
-    def url_decode(input)
-      CGI.unescape(input) unless input.nil?
-    end
-
-    def slice(input, offset, length = nil)
-      offset = Utils.to_integer(offset)
-      length = length ? Utils.to_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 = "...".freeze)
+    def truncate(input, length = 50, truncate_string = "...")
-      return if input.nil?
+      if input.nil? then return end
-      input_str = input.to_s
+      l = length.to_i - truncate_string.length
-      length = Utils.to_integer(length)
-      truncate_string_str = truncate_string.to_s
-      l = length - truncate_string_str.length
       l = 0 if l < 0
-      input_str.length > length ? input_str[0...l] + truncate_string_str : input_str
+      input.length > length.to_i ? input[0...l] + truncate_string : input
     end
 
-    def truncatewords(input, words = 15, truncate_string = "...".freeze)
+    def truncatewords(input, words = 15, truncate_string = "...")
-      return if input.nil?
+      if input.nil? then return end
       wordlist = input.to_s.split
-      words = Utils.to_integer(words)
+      l = words.to_i - 1
-      l = words - 1
       l = 0 if l < 0
-      wordlist.length > l ? wordlist[0..l].join(" ".freeze) + truncate_string.to_s : input
+      wordlist.length > l ? wordlist[0..l].join(" ") + truncate_string : input
     end
 
     # Split input string into an array of substrings separated by given pattern.
@@ -86,137 +59,65 @@ module Liquid
     #   <div class="summary">{{ post | split '//' | first }}</div>
     #
     def split(input, pattern)
-      input.to_s.split(pattern.to_s)
+      input.split(pattern)
-    end
-
-    def strip(input)
-      input.to_s.strip
-    end
-
-    def lstrip(input)
-      input.to_s.lstrip
-    end
-
-    def rstrip(input)
-      input.to_s.rstrip
     end
 
     def strip_html(input)
-      empty = ''.freeze
+      input.to_s.gsub(/<script.*?<\/script>/, '').gsub(/<!--.*?-->/, '').gsub(/<.*?>/, '')
-      input.to_s.gsub(/<script.*?<\/script>/m, empty).gsub(/<!--.*?-->/m, empty).gsub(/<style.*?<\/style>/m, empty).gsub(/<.*?>/m, empty)
     end
 
     # Remove all newlines from the string
     def strip_newlines(input)
-      input.to_s.gsub(/\r?\n/, ''.freeze)
+      input.to_s.gsub(/\n/, '')
     end
 
+
     # Join elements of the array with certain character between them
-    def join(input, glue = ' '.freeze)
+    def join(input, glue = ' ')
-      InputIterator.new(input).join(glue)
+      [input].flatten.join(glue)
     end
 
     # Sort elements of the array
     # provide optional property with which to sort an array of hashes or drops
     def sort(input, property = nil)
-      ary = InputIterator.new(input)
+      ary = [input].flatten
       if property.nil?
         ary.sort
-      elsif ary.empty? # The next two cases assume a non-empty array.
+      elsif ary.first.respond_to?('[]') and !ary.first[property].nil?
-        []
+        ary.sort {|a,b| a[property] <=> b[property] }
-      elsif ary.first.respond_to?(:[]) && !ary.first[property].nil?
+      elsif ary.first.respond_to?(property)
-        ary.sort do |a, b|
+        ary.sort {|a,b| a.send(property) <=> b.send(property) }
-          a = a[property]
-          b = b[property]
-          if a && b
-            a <=> b
-          else
-            a ? -1 : 1
-          end
-        end
       end
     end
 
-    # Sort elements of an array ignoring case if strings
-    # provide optional property with which to sort an array of hashes or drops
-    def sort_natural(input, property = nil)
-      ary = InputIterator.new(input)
-
-      if property.nil?
-        ary.sort { |a, b| a.casecmp(b) }
-      elsif ary.empty? # The next two cases assume a non-empty array.
-        []
-      elsif ary.first.respond_to?(:[]) && !ary.first[property].nil?
-        ary.sort { |a, b| a[property].casecmp(b[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?
-        ary.uniq
-      elsif ary.empty? # The next two cases assume a non-empty array.
-        []
-      elsif ary.first.respond_to?(:[])
-        ary.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)
-      InputIterator.new(input).map do |e|
+      ary = [input].flatten
-        e = e.call if e.is_a?(Proc)
+      if ary.first.respond_to?('[]') and !ary.first[property].nil?
-
+        ary.map {|e| e[property] }
-        if property == "to_liquid".freeze
+      elsif ary.first.respond_to?(property)
-          e
+        ary.map {|e| e.send(property) }
-        elsif e.respond_to?(:[])
-          r = e[property]
-          r.is_a?(Proc) ? r.call : r
-        end
-      end
-    end
-
-    # Remove nils within an array
-    # provide optional property with which to check for nil
-    def compact(input, property = nil)
-      ary = InputIterator.new(input)
-
-      if property.nil?
-        ary.compact
-      elsif ary.empty? # The next two cases assume a non-empty array.
-        []
-      elsif ary.first.respond_to?(:[])
-        ary.reject{ |a| a[property].nil? }
       end
     end
 
     # Replace occurrences of a string with another
-    def replace(input, string, replacement = ''.freeze)
+    def replace(input, string, replacement = '')
-      input.to_s.gsub(string.to_s, replacement.to_s)
+      input.to_s.gsub(string, replacement)
     end
 
     # Replace the first occurrences of a string with another
-    def replace_first(input, string, replacement = ''.freeze)
+    def replace_first(input, string, replacement = '')
-      input.to_s.sub(string.to_s, replacement.to_s)
+      input.to_s.sub(string, replacement)
     end
 
     # remove a substring
     def remove(input, string)
-      input.to_s.gsub(string.to_s, ''.freeze)
+      input.to_s.gsub(string, '')
     end
 
     # remove the first occurrences of a substring
     def remove_first(input, string)
-      input.to_s.sub(string.to_s, ''.freeze)
+      input.to_s.sub(string, '')
     end
 
     # add one string to another
@@ -224,13 +125,6 @@ module Liquid
       input.to_s + string.to_s
     end
 
-    def concat(input, array)
-      unless array.respond_to?(:to_ary)
-        raise ArgumentError.new("concat filter requires an array argument")
-      end
-      InputIterator.new(input).concat(array)
-    end
-
     # prepend a string to another
     def prepend(input, string)
       string.to_s + input.to_s
@@ -238,10 +132,10 @@ module Liquid
 
     # Add <br /> tags in front of all newlines in input string
     def newline_to_br(input)
-      input.to_s.gsub(/\n/, "<br />\n".freeze)
+      input.to_s.gsub(/\n/, "<br />\n")
     end
 
-    # Reformat a date using Ruby's core Time#strftime( string ) -> string
+    # Reformat a date
     #
     #   %a - The abbreviated weekday name (``Sun'')
     #   %A - The  full  weekday  name (``Sunday'')
@@ -255,7 +149,6 @@ module Liquid
     #   %m - Month of the year (01..12)
     #   %M - Minute of the hour (00..59)
     #   %p - Meridian indicator (``AM''  or  ``PM'')
-    #   %s - Number of seconds since 1970-01-01 00:00:00 UTC.
     #   %S - Second of the minute (00..60)
     #   %U - Week  number  of the current year,
     #           starting with the first Sunday as the first
@@ -270,14 +163,25 @@ module Liquid
     #   %Y - Year with century
     #   %Z - Time zone name
     #   %% - Literal ``%'' character
-    #
-    #   See also: http://www.ruby-doc.org/core/Time.html#method-i-strftime
     def date(input, format)
-      return input if format.to_s.empty?
 
-      return input unless date = Utils.to_date(input)
+      if format.to_s.empty?
+        return input.to_s
+      end
 
-      date.strftime(format.to_s)
+      if ((input.is_a?(String) && !/^\d+$/.match(input.to_s).nil?) || input.is_a?(Integer)) && input.to_i > 0
+        input = Time.at(input.to_i)
+      end
+
+      date = input.is_a?(String) ? Time.parse(input) : input
+
+      if date.respond_to?(:strftime)
+        date.strftime(format.to_s)
+      else
+        input
+      end
+    rescue => e
+      input
     end
 
     # Get the first element of the passed in array
@@ -298,122 +202,43 @@ module Liquid
       array.last if array.respond_to?(:last)
     end
 
-    # absolute value
-    def abs(input)
-      result = Utils.to_number(input).abs
-      result.is_a?(BigDecimal) ? result.to_f : result
-    end
-
     # addition
     def plus(input, operand)
-      apply_operation(input, operand, :+)
+      to_number(input) + to_number(operand)
     end
 
     # subtraction
     def minus(input, operand)
-      apply_operation(input, operand, :-)
+      to_number(input) - to_number(operand)
     end
 
     # multiplication
     def times(input, operand)
-      apply_operation(input, operand, :*)
+      to_number(input) * to_number(operand)
     end
 
     # division
     def divided_by(input, operand)
-      apply_operation(input, operand, :/)
+      to_number(input) / to_number(operand)
-    rescue ::ZeroDivisionError => e
-      raise Liquid::ZeroDivisionError, e.message
     end
 
     def modulo(input, operand)
-      apply_operation(input, operand, :%)
+      to_number(input) % to_number(operand)
-    rescue ::ZeroDivisionError => e
-      raise Liquid::ZeroDivisionError, e.message
-    end
-
-    def round(input, n = 0)
-      result = Utils.to_number(input).round(Utils.to_number(n))
-      result = result.to_f if result.is_a?(BigDecimal)
-      result = result.to_i if n == 0
-      result
-    rescue ::FloatDomainError => e
-      raise Liquid::FloatDomainError, e.message
-    end
-
-    def ceil(input)
-      Utils.to_number(input).ceil.to_i
-    rescue ::FloatDomainError => e
-      raise Liquid::FloatDomainError, e.message
-    end
-
-    def floor(input)
-      Utils.to_number(input).floor.to_i
-    rescue ::FloatDomainError => e
-      raise Liquid::FloatDomainError, e.message
-    end
-
-    def default(input, default_value = ''.freeze)
-      if !input || input.respond_to?(:empty?) && input.empty?
-        default_value
-      else
-        input
-      end
     end
 
     private
 
-    def apply_operation(input, operand, operation)
+      def to_number(obj)
-      result = Utils.to_number(input).send(operation, Utils.to_number(operand))
+        case obj
-      result.is_a?(BigDecimal) ? result.to_f : result
+        when Numeric
-    end
+          obj
-
+        when String
-    class InputIterator
+          (obj.strip =~ /^\d+\.\d+$/) ? obj.to_f : obj.to_i
-      include Enumerable
-
-      def initialize(input)
-        @input = if input.is_a?(Array)
-          input.flatten
-        elsif input.is_a?(Hash)
-          [input]
-        elsif input.is_a?(Enumerable)
-          input
         else
-          Array(input)
+          0
         end
       end
 
-      def join(glue)
-        to_a.join(glue.to_s)
-      end
-
-      def concat(args)
-        to_a.concat(args)
-      end
-
-      def reverse
-        reverse_each.to_a
-      end
-
-      def uniq(&block)
-        to_a.uniq(&block)
-      end
-
-      def compact
-        to_a.compact
-      end
-
-      def empty?
-        @input.each { return false }
-        true
-      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

@@ -1,66 +1,53 @@
 require 'set'
 
 module Liquid
+
   # Strainer is the parent class for the filters system.
   # New filters are mixed into the strainer class which is then instantiated for each liquid template render run.
   #
   # The Strainer only allows method calls defined in filters given to it via Strainer.global_filter,
   # Context#add_filters or Template.register_filter
   class Strainer #:nodoc:
-    @@global_strainer = Class.new(Strainer) do
+    @@filters = {}
-      @filter_methods = Set.new
+    @@known_filters = Set.new
-    end
+    @@known_methods = Set.new
-    @@strainer_class_cache = Hash.new do |hash, filters|
-      hash[filters] = Class.new(@@global_strainer) do
-        @filter_methods = @@global_strainer.filter_methods.dup
-        filters.each { |f| add_filter(f) }
-      end
-    end
 
     def initialize(context)
       @context = context
     end
 
-    class << self
+    def self.global_filter(filter)
-      attr_reader :filter_methods
+      raise ArgumentError, "Passed filter is not a module" unless filter.is_a?(Module)
+      add_known_filter(filter)
+      @@filters[filter.name] = filter
     end
 
-    def self.add_filter(filter)
+    def self.add_known_filter(filter)
-      raise ArgumentError, "Expected module but got: #{filter.class}" unless filter.is_a?(Module)
+      unless @@known_filters.include?(filter)
-      unless self.include?(filter)
+        @@method_blacklist ||= Set.new(Strainer.instance_methods.map(&:to_s))
-        invokable_non_public_methods = (filter.private_instance_methods + filter.protected_instance_methods).select { |m| invokable?(m) }
+        new_methods = filter.instance_methods.map(&:to_s)
-        if invokable_non_public_methods.any?
+        new_methods.reject!{ |m| @@method_blacklist.include?(m) }
-          raise MethodOverrideError, "Filter overrides registered public methods as non public: #{invokable_non_public_methods.join(', ')}"
+        @@known_methods.merge(new_methods)
-        else
+        @@known_filters.add(filter)
-          send(:include, filter)
-          @filter_methods.merge(filter.public_instance_methods.map(&:to_s))
-        end
       end
     end
 
-    def self.global_filter(filter)
+    def self.create(context)
-      @@strainer_class_cache.clear
+      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 self.class.invokable?(method)
+      if invokable?(method)
         send(method, *args)
-      elsif @context && @context.strict_filters
-        raise Liquid::UndefinedFilter, "undefined filter #{method}"
       else
         args.first
       end
-    rescue ::ArgumentError => e
+    end
-      raise Liquid::ArgumentError, e.message, e.backtrace
+
+    def invokable?(method)
+      @@known_methods.include?(method.to_s) && respond_to?(method)
     end
   end
 end

lib/liquid/tablerowloop_drop.rb

@@ -1,62 +0,0 @@
-module Liquid
-  class TablerowloopDrop < Drop
-    def initialize(length, cols)
-      @length = length
-      @row = 1
-      @col = 1
-      @cols = cols
-      @index = 0
-    end
-
-    attr_reader :length, :col, :row
-
-    def index
-      @index + 1
-    end
-
-    def index0
-      @index
-    end
-
-    def col0
-      @col - 1
-    end
-
-    def rindex
-      @length - @index
-    end
-
-    def rindex0
-      @length - @index - 1
-    end
-
-    def first
-      @index == 0
-    end
-
-    def last
-      @index == @length - 1
-    end
-
-    def col_first
-      @col == 1
-    end
-
-    def col_last
-      @col == @cols
-    end
-
-    protected
-
-    def increment!
-      @index += 1
-
-      if @col == @cols
-        @col = 1
-        @row += 1
-      else
-        @col += 1
-      end
-    end
-  end
-end

lib/liquid/tag.rb

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

lib/liquid/tags/assign.rb

@@ -1,4 +1,5 @@
 module Liquid
+
   # Assign sets a variable in your template.
   #
   #   {% assign foo = 'monkey' %}
@@ -8,44 +9,25 @@ module Liquid
   #  {{ foo }}
   #
   class Assign < Tag
-    Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/om
+    Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/o
   
-    def initialize(tag_name, markup, options)
+    def initialize(tag_name, markup, tokens)          
-      super
       if markup =~ Syntax
         @to = $1
-        @from = Variable.new($2, options)
+        @from = Variable.new($2)
       else
-        raise SyntaxError.new options[:locale].t("errors.syntax.assign".freeze)
+        raise SyntaxError.new("Syntax Error in 'assign' - Valid syntax: assign [var] = [source]")
       end
+      
+      super      
     end
   
     def render(context)
-      val = @from.render(context)
+       context.scopes.last[@to] = @from.render(context)
-      context.scopes.last[@to] = val
+       ''
-      context.resource_limits.assign_score += assign_score_of(val)
-      ''.freeze
     end 
   
-    def blank?
-      true
-    end
-
-    private
-
-    def assign_score_of(val)
-      if val.instance_of?(String)
-        val.length
-      elsif val.instance_of?(Array) || val.instance_of?(Hash)
-        sum = 1
-        # Uses #each to avoid extra allocations.
-        val.each { |child| sum += assign_score_of(child) }
-        sum
-      else
-        1
-      end
-    end
   end  
   
-  Template.register_tag('assign'.freeze, Assign)
+  Template.register_tag('assign', Assign)  
 end

lib/liquid/tags/break.rb

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

lib/liquid/tags/capture.rb

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

lib/liquid/tags/case.rb

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

lib/liquid/tags/comment.rb

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

lib/liquid/tags/continue.rb

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

lib/liquid/tags/cycle.rb

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

lib/liquid/tags/decrement.rb

@@ -1,4 +1,5 @@
 module Liquid
+  
   # decrement is used in a place where one needs to insert a counter
   #     into a template, and needs the counter to survive across
   #     multiple instantiations of the template.
@@ -18,18 +19,21 @@ module Liquid
   #    Hello: -3
   #
   class Decrement < Tag
-    def initialize(tag_name, markup, options)
+    def initialize(tag_name, markup, tokens)      
-      super
       @variable = markup.strip
+
+      super    
     end    
   
     def render(context)
       value = context.environments.first[@variable] ||= 0
-      value -= 1
+      value = value - 1
       context.environments.first[@variable] = value
       value.to_s
     end
+  
+    private
   end
   
-  Template.register_tag('decrement'.freeze, Decrement)
+  Template.register_tag('decrement', Decrement)
 end

lib/liquid/tags/for.rb

@@ -1,4 +1,5 @@
 module Liquid
+
   # "For" iterates over an array or collection. 
   # Several useful variables are available to you within the loop.
   #
@@ -23,7 +24,7 @@ module Liquid
   #      {{ item.name }}
   #    {% end %}             
   #
-  #  To reverse the for loop simply use {% for item in collection reversed %} (note that the flag's spelling is different to the filter `reverse`)
+  #  To reverse the for loop simply use {% for item in collection reversed %}
   #
   # == Available variables:
   #
@@ -41,155 +42,127 @@ module Liquid
   #                   where 0 is the last item.
   # forloop.first:: Returns true if the item is the first item.
   # forloop.last:: Returns true if the item is the last item.
-  # forloop.parentloop:: Provides access to the parent loop, if present.
   #
   class For < Block                                             
-    Syntax = /\A(#{VariableSegment}+)\s+in\s+(#{QuotedFragment}+)\s*(reversed)?/o
+    Syntax = /(\w+)\s+in\s+(#{QuotedFragment}+)\s*(reversed)?/o
   
-    def initialize(tag_name, markup, options)
+    def initialize(tag_name, markup, tokens)
+      if markup =~ Syntax
+        @variable_name = $1
+        @collection_name = $2
+        @name = "#{$1}-#{$2}"         
+        @idx = "#{@name}-i"
+        @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
-      @from = @limit = nil
-      parse_with_selected_parser(markup)
-      @for_block = BlockBody.new
-      @else_block = nil
-    end
-
-    def parse(tokens)
-      return unless parse_body(@for_block, tokens)
-      parse_body(@else_block, tokens)
-    end
-
-    def nodelist
-      @else_block ? [@for_block, @else_block] : [@for_block]
     end
 
     def unknown_tag(tag, markup, tokens)
-      return super unless tag == 'else'.freeze
+      return super unless tag == 'else'
-      @else_block = BlockBody.new
+      @nodelist = @else_block = []
     end
   
     def render(context)       
-      segment = collection_segment(context)
+      context.registers[:for] ||= Hash.new(0)
     
-      if segment.empty?
+      collection = context[@collection_name]
-        render_else(context)
+      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'
+        context.registers[:for][@name].to_i
       else
-        render_segment(context, segment)
+        context[@attributes['offset']].to_i
       end
-    end
         
-    protected
+      limit = context[@attributes['limit']]
+      to    = limit ? limit.to_i + from : nil  
 
-    def lax_parse(markup)
+      segment = Utils.slice_collection_using_each(collection, from, to)
-      if markup =~ Syntax
+
-        @variable_name = $1
+      return render_else(context) if segment.empty?
-        collection_name = $2
+      
-        @reversed = !!$3
+      segment.reverse! if @reversed
-        @name = "#{@variable_name}-#{collection_name}"
+
-        @collection_name = Expression.parse(collection_name)
+      result = []
-        markup.scan(TagAttributes) do |key, value|
+        
-          set_attribute(key, value)
+      length = segment.length            
+            
+      # Store our progress through the collection for the continue flag
+      context.registers[:for][@name] = from + segment.length
+              
+      context.stack do
+        context['forloop'] = lambda { Forloop.new(@name, @idx, length) }
+        segment.each_with_index do |item, index|
+          context.registers[:for][@idx] = index
+          context[@variable_name] = item
+
+          result << render_all(@for_block, context)
+
+          # Handle any interrupts if they exist.
+          if context.has_interrupt?
+            interrupt = context.pop_interrupt
+            break if interrupt.is_a? BreakInterrupt
+            next if interrupt.is_a? ContinueInterrupt
+          end
         end
-      else
-        raise SyntaxError.new(options[:locale].t("errors.syntax.for".freeze))
       end
-    end
+      result     
-
-    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 collection_segment(context)
+      class Forloop < Liquid::Drop
-      offsets = context.registers[:for] ||= Hash.new(0)
+        attr_accessor :name, :length
 
-      from = if @from == :continue
+        def initialize(name, idx, length)
-        offsets[@name].to_i
+          @name, @idx, @length = name, idx, length
-      else
+        end
-        context.evaluate(@from).to_i
-      end
 
-      collection = context.evaluate(@collection_name)
+        def index
-      collection = collection.to_a if collection.is_a?(Range)
+          @context.registers[:for][@idx] + 1
+        end
 
-      limit = context.evaluate(@limit)
+        def index0
-      to = limit ? limit.to_i + from : nil
+          @context.registers[:for][@idx]
+        end
 
-      segment = Utils.slice_collection(collection, from, to)
+        def rindex
-      segment.reverse! if @reversed
+          length - @context.registers[:for][@idx]
+        end
 
-      offsets[@name] = from + segment.length
+        def rindex0
+          length - @context.registers[:for][@idx] - 1
+        end
 
-      segment
+        def first
-    end
+          (@context.registers[:for][@idx] == 0)
+        end
 
-    def render_segment(context, segment)
+        def last
-      for_stack = context.registers[:for_stack] ||= []
+          (@context.registers[:for][@idx] == length - 1)
-      length = segment.length
-
-      result = ''
-
-      context.stack do
-        loop_vars = Liquid::ForloopDrop.new(@name, length, for_stack[-1])
-
-        for_stack.push(loop_vars)
-
-        begin
-          context['forloop'.freeze] = loop_vars
-
-          segment.each_with_index do |item, index|
-            context[@variable_name] = item
-            result << @for_block.render(context)
-            loop_vars.send(:increment!)
-
-            # Handle any interrupts if they exist.
-            if context.interrupt?
-              interrupt = context.pop_interrupt
-              break if interrupt.is_a? BreakInterrupt
-              next if interrupt.is_a? ContinueInterrupt
-            end
-          end
-        ensure
-          for_stack.pop
         end
       end
 
-      result
-    end
 
-    def set_attribute(key, expr)
+      def render_else(context)
-      case key
+        return @else_block ? [render_all(@else_block, context)] : ''
-      when 'offset'.freeze
-        @from = if expr == 'continue'.freeze
-          :continue
-        else
-          Expression.parse(expr)
-        end
-      when 'limit'.freeze
-        @limit = Expression.parse(expr)
       end
-    end
 
-    def render_else(context)
+      def iterable?(collection)
-      @else_block ? @else_block.render(context) : ''.freeze
+        collection.respond_to?(:each) || Utils.non_blank_string?(collection)
-    end
+      end
   end
 
-  Template.register_tag('for'.freeze, For)
+  Template.register_tag('for', For)
 end

lib/liquid/tags/if.rb

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

lib/liquid/tags/ifchanged.rb

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

lib/liquid/tags/include.rb

@@ -1,113 +1,65 @@
 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, options)
+    def initialize(tag_name, markup, tokens)      
-      super
-
       if markup =~ Syntax
 
-        template_name = $1
+        @template_name = $1        
-        variable_name = $3
+        @variable_name = $3
-
+        @attributes    = {}
-        @variable_name_expr = variable_name ? Expression.parse(variable_name) : nil
-        @template_name_expr = Expression.parse(template_name)
-        @attributes = {}
 
         markup.scan(TagAttributes) do |key, value|
-          @attributes[key] = Expression.parse(value)
+          @attributes[key] = value
         end
 
       else
-        raise SyntaxError.new(options[:locale].t("errors.syntax.include".freeze))
+        raise SyntaxError.new("Error in tag 'include' - Valid syntax: include '[template]' (with|for) [object|collection]")
       end
+
+      super
     end
   
-    def parse(_tokens)
+    def parse(tokens)
     end
     
     def render(context)
-      template_name = context.evaluate(@template_name_expr)
+      source = _read_template_from_file_system(context)
-      raise ArgumentError.new(options[:locale].t("errors.argument.include")) unless template_name
+      partial = Liquid::Template.parse(source)
+      variable = context[@variable_name || @template_name[1..-2]]
       
-      partial = load_cached_partial(template_name, context)
+      context.stack do
-      context_variable_name = template_name.split('/'.freeze).last
+        @attributes.each do |key, value|
+          context[key] = context[value]
+        end
 
-      variable = if @variable_name_expr
+        if variable.is_a?(Array)
-        context.evaluate(@variable_name_expr)
+          variable.collect do |variable|
-      else
+            context[@template_name[1..-2]] = variable
-        context.find_variable(template_name, raise_on_not_found: false)
-      end
-
-      old_template_name = context.template_name
-      old_partial = context.partial
-      begin
-        context.template_name = template_name
-        context.partial = true
-        context.stack do
-          @attributes.each do |key, value|
-            context[key] = context.evaluate(value)
-          end
-
-          if variable.is_a?(Array)
-            variable.collect do |var|
-              context[context_variable_name] = var
-              partial.render(context)
-            end
-          else
-            context[context_variable_name] = variable
             partial.render(context)
           end
+        else
+          context[@template_name[1..-2]] = variable
+          partial.render(context)
         end
-      ensure
-        context.template_name = old_template_name
-        context.partial = old_partial
       end
     end
    
     private
+      def _read_template_from_file_system(context)
+        file_system = context.registers[:file_system] || Liquid::Template.file_system
       
-    alias_method :parse_context, :options
+        # make read_template_file call backwards-compatible.
-    private :parse_context
+        case file_system.method(:read_template_file).arity
-
+        when 1
-    def load_cached_partial(template_name, context)
+          file_system.read_template_file(context[@template_name])
-      cached_partials = context.registers[:cached_partials] || {}
+        when 2
-
+          file_system.read_template_file(context[@template_name], context)
-      if cached = cached_partials[template_name]
+        else
-        return cached
+          raise ArgumentError, "file_system.read_template_file expects two parameters: (template_name, context)"
+        end
       end
-      source = read_template_from_file_system(context)
-      begin
-        parse_context.partial = true
-        partial = Liquid::Template.parse(source, parse_context)
-      ensure
-        parse_context.partial = false
-      end
-      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
-
-      file_system.read_template_file(context.evaluate(@template_name_expr))
-    end
   end
 
-  Template.register_tag('include'.freeze, Include)
+  Template.register_tag('include', Include)  
 end

lib/liquid/tags/increment.rb

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

lib/liquid/tags/raw.rb

@@ -1,47 +1,21 @@
 module Liquid
   class Raw < Block
-    Syntax = /\A\s*\z/
-    FullTokenPossiblyInvalid = /\A(.*)#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/om
-
-    def initialize(tag_name, markup, parse_context)
-      super
-
-      ensure_valid_markup(tag_name, markup, parse_context)
-    end
-
     def parse(tokens)
-      @body = ''
+      @nodelist ||= []
+      @nodelist.clear
+
       while token = tokens.shift
-        if token =~ FullTokenPossiblyInvalid
+        if token =~ FullToken
-          @body << $1 if $1 != "".freeze
+          if block_delimiter == $1
-          return if block_delimiter == $2
+            end_tag
+            return
+          end
         end
-        @body << token unless token.empty?
+        @nodelist << token if not token.empty?
-      end
-
-      raise SyntaxError.new(parse_context.locale.t("errors.syntax.tag_never_closed".freeze, block_name: block_name))
-    end
-
-    def render(_context)
-      @body
-    end
-
-    def nodelist
-      [@body]
-    end
-
-    def blank?
-      @body.empty?
-    end
-
-    protected
-
-    def ensure_valid_markup(tag_name, markup, parse_context)
-      unless markup =~ Syntax
-        raise SyntaxError.new(parse_context.locale.t("errors.syntax.tag_unexpected_args".freeze, tag: tag_name))
       end
     end
   end
 
-  Template.register_tag('raw'.freeze, Raw)
+  Template.register_tag('raw', Raw)
 end
+

lib/liquid/tags/table_row.rb

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

lib/liquid/tags/unless.rb

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

lib/liquid/template.rb

@@ -1,4 +1,5 @@
 module Liquid
+
   # Templates are central to liquid.
   # Interpretating templates is a two step process. First you compile the
   # source code you got. During compile time some extensive error checking is performed.
@@ -14,66 +15,9 @@ module Liquid
   #
   class Template
     attr_accessor :root
-    attr_reader :resource_limits, :warnings
-
     @@file_system = BlankFileSystem.new
 
-    class TagRegistry
-      include Enumerable
-
-      def initialize
-        @tags = {}
-        @cache = {}
-      end
-
-      def [](tag_name)
-        return nil unless @tags.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
-
-      def each(&block)
-        @tags.each(&block)
-      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
-
-      attr_accessor :default_exception_renderer
-      Template.default_exception_renderer = lambda do |exception|
-        exception
-      end
-
       def file_system
         @@file_system
       end
@@ -87,15 +31,7 @@ module Liquid
       end
 
       def tags
-        @tags ||= TagRegistry.new
+        @tags ||= {}
-      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
@@ -104,33 +40,22 @@ 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
-      # To enable profiling, pass in <tt>profile: true</tt> as an option.
+      def parse(source)
-      # See Liquid::Profiler for more information
-      def parse(source, options = {})
         template = Template.new
-        template.parse(source, options)
+        template.parse(source)
+        template
       end
     end
 
+    # creates a new <tt>Template</tt> from an array of tokens. Use <tt>Template.parse</tt> instead
     def initialize
-      @rethrow_errors = false
-      @resource_limits = ResourceLimits.new(self.class.default_resource_limits)
     end
 
     # Parse source code.
     # Returns self for easy chaining
-    def parse(source, options = {})
+    def parse(source)
-      @options = options
+      @root = Document.new(tokenize(source))
-      @profiling = options[:profile]
-      @line_numbers = options[:line_numbers] || @profiling
-      parse_context = options.is_a?(ParseContext) ? options : ParseContext.new(options)
-      @root = Document.parse(tokenize(source), parse_context)
-      @warnings = parse_context.warnings
       self
     end
 
@@ -155,9 +80,6 @@ module Liquid
     # if you use the same filters over and over again consider registering them globally
     # with <tt>Template.register_filter</tt>
     #
-    # if profiling was enabled in <tt>Template#parse</tt> then the resulting profiling information
-    # will be available via <tt>Template#profiler</tt>
-    #
     # Following options can be passed:
     #
     #  * <tt>filters</tt> : array with local filters
@@ -165,90 +87,63 @@ module Liquid
     #    filters and tags and might be useful to integrate liquid more with its host application
     #
     def render(*args)
-      return ''.freeze if @root.nil?
+      return '' if @root.nil?
       
       context = case args.first
       when Liquid::Context
-        c = args.shift
+        args.shift
-
-        if @rethrow_errors
-          c.exception_renderer = ->(e) { raise }
-        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, @resource_limits)
+        Context.new([args.shift, assigns], instance_assigns, registers, @rethrow_errors)
       when nil
-        Context.new(assigns, instance_assigns, registers, @rethrow_errors, @resource_limits)
+        Context.new(assigns, instance_assigns, registers, @rethrow_errors)
       else
-        raise ArgumentError, "Expected Hash or Liquid::Context as parameter"
+        raise ArgumentError, "Expect Hash or Liquid::Context as parameter"
       end
 
       case args.last
       when Hash
         options = args.pop
 
-        registers.merge!(options[:registers]) if options[:registers].is_a?(Hash)
+        if options[:registers].is_a?(Hash)
+          self.registers.merge!(options[:registers])
+        end
 
-        apply_options_to_context(context, options)
+        if options[:filters]
-      when Module, Array
+          context.add_filters(options[:filters])
+        end
+
+      when Module
+        context.add_filters(args.pop)
+      when Array
         context.add_filters(args.pop)
       end
 
-      # Retrying a render resets resource usage
-      context.resource_limits.reset
-
       begin
         # render the nodelist.
-        # for performance reasons we get an array back here. join will make a string out of it.
+        # for performance reasons we get a array back here. join will make a string out of it
-        result = with_profiling(context) do
+        @root.render(context).join        
-          @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
+      @rethrow_errors = true; render(*args)
-      render(*args)
     end
 
     private
 
+    # Uses the <tt>Liquid::TemplateParser</tt> regexp to tokenize the passed source
     def tokenize(source)
-      Tokenizer.new(source, @line_numbers)
+      source = source.source if source.respond_to?(:source)
+      return [] if source.to_s.empty?
+      tokens = source.split(TemplateParser)
+
+      # removes the rogue empty element at the beginning of the array
+      tokens.shift if tokens[0] and tokens[0].empty?
+
+      tokens
     end
 
-    def with_profiling(context)
-      if @profiling && !context.partial
-        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
-
-    def apply_options_to_context(context, options)
-      context.add_filters(options[:filters]) if options[:filters]
-      context.global_filter = options[:global_filter] if options[:global_filter]
-      context.exception_renderer = options[:exception_renderer] if options[:exception_renderer]
-      context.strict_variables = options[:strict_variables] if options[:strict_variables]
-      context.strict_filters = options[:strict_filters] if options[:strict_filters]
-    end
   end
 end

lib/liquid/tokenizer.rb

@@ -1,31 +0,0 @@
-module Liquid
-  class Tokenizer
-    attr_reader :line_number
-
-    def initialize(source, line_numbers = false)
-      @source = source
-      @line_number = line_numbers ? 1 : nil
-      @tokens = tokenize
-    end
-
-    def shift
-      token = @tokens.shift
-      @line_number += token.count("\n") if @line_number && token
-      token
-    end
-
-    private
-
-    def tokenize
-      @source = @source.source if @source.respond_to?(:source)
-      return [] if @source.to_s.empty?
-
-      tokens = @source.split(TemplateParser)
-
-      # removes the rogue empty element at the beginning of the array
-      tokens.shift if tokens[0] && tokens[0].empty?
-
-      tokens
-    end
-  end
-end

lib/liquid/utils.rb

@@ -1,24 +1,15 @@
 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.slice_collection_using_each(collection, from, to)
       segments = []
       index = 0
+      yielded = 0
 
       # Maintains Ruby 1.8.7 String#each behaviour on 1.9
-      if collection.is_a?(String)
+      return [collection] if non_blank_string?(collection)
-        return collection.empty? ? [] : [collection]
-      end
-      return [] unless collection.respond_to?(:each)
 
       collection.each do |item|
+
         if to && to <= index
           break
         end
@@ -33,51 +24,8 @@ module Liquid
       segments
     end
 
-    def self.to_integer(num)
+    def self.non_blank_string?(collection)
-      return num if num.is_a?(Integer)
+      collection.is_a?(String) && collection != ''
-      num = num.to_s
-      begin
-        Integer(num)
-      rescue ::ArgumentError
-        raise Liquid::ArgumentError, "invalid integer"
-      end
-    end
-
-    def self.to_number(obj)
-      case obj
-      when Float
-        BigDecimal.new(obj.to_s)
-      when Numeric
-        obj
-      when String
-        (obj.strip =~ /\A-?\d+\.\d+\z/) ? BigDecimal.new(obj) : obj.to_i
-      else
-        if obj.respond_to?(:to_number)
-          obj.to_number
-        else
-          0
-        end
-      end
-    end
-
-    def self.to_date(obj)
-      return obj if obj.respond_to?(:strftime)
-
-      if obj.is_a?(String)
-        return nil if obj.empty?
-        obj = obj.downcase
-      end
-
-      case obj
-      when 'now'.freeze, 'today'.freeze
-        Time.now
-      when /\A\d+\z/, Integer
-        Time.at(obj.to_i)
-      when String
-        Time.parse(obj)
-      end
-    rescue ::ArgumentError
-      nil
     end
   end
 end

lib/liquid/variable.rb

@@ -1,4 +1,5 @@
 module Liquid
+
   # Holds variables. Variables are only loaded "just in time"
   # and are not evaluated as part of the render stage
   #
@@ -10,126 +11,46 @@ module Liquid
   #   {{ user | link }}
   #
   class Variable
-    FilterParser = /(?:\s+|#{QuotedFragment}|#{ArgumentSeparator})+/o
+    FilterParser = /(?:#{FilterSeparator}|(?:\s*(?:#{QuotedFragment}|#{ArgumentSeparator})\s*)+)/o
-    attr_accessor :filters, :name, :line_number
+    attr_accessor :filters, :name
-    attr_reader :parse_context
-    alias_method :options, :parse_context
-    include ParserSwitching
 
-    def initialize(markup, parse_context)
+    def initialize(markup)
       @markup  = markup
       @name    = nil
-      @parse_context = parse_context
-      @line_number = parse_context.line_number
-
-      parse_with_selected_parser(markup)
-    end
-
-    def raw
-      @markup
-    end
-
-    def markup_context(markup)
-      "in \"{{#{markup}}}\""
-    end
-
-    def lax_parse(markup)
       @filters = []
-      return unless markup =~ /(#{QuotedFragment})(.*)/om
+      if match = markup.match(/\s*(#{QuotedFragment})(.*)/o)
-
+        @name = match[1]
-      name_markup = $1
+        if match[2].match(/#{FilterSeparator}\s*(.*)/o)
-      filter_markup = $2
+          filters = Regexp.last_match(1).scan(FilterParser)
-      @name = Expression.parse(name_markup)
+          filters.each do |f|
-      if filter_markup =~ /#{FilterSeparator}\s*(.*)/om
+            if matches = f.match(/\s*(\w+)(?:\s*#{FilterArgumentSeparator}(.*))?/)
-        filters = $1.scan(FilterParser)
+              filtername = matches[1]
-        filters.each do |f|
+              filterargs = matches[2].to_s.scan(/(?:\A|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o).flatten
-          next unless f =~ /\w+/
+              @filters << [filtername, filterargs]
-          filtername = Regexp.last_match(0)
+            end
-          filterargs = f.scan(/(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o).flatten
+          end
-          @filters << parse_filter_expressions(filtername, filterargs)
         end
       end
     end
 
-    def strict_parse(markup)
-      @filters = []
-      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
-      filterargs << p.argument while p.consume?(:comma)
-      filterargs
-    end
-
     def render(context)
-      obj = @filters.inject(context.evaluate(@name)) do |output, (filter_name, filter_args, filter_kwargs)|
+      return '' if @name.nil?
-        filter_args = evaluate_filter_expressions(context, filter_args, filter_kwargs)
+      @filters.inject(context[@name]) do |output, filter|
-        context.invoke(filter_name, output, *filter_args)
+        filterargs = []
-      end
+        keyword_args = {}
-
+        filter[1].to_a.each do |a|
-      obj = context.apply_global_filter(obj)
+          if matches = a.match(/\A#{TagAttributes}\z/o)
-
+            keyword_args[matches[1]] = context[matches[2]]
-      taint_check(context, obj)
+          else
-
+            filterargs << context[a]
-      obj
+          end
-    end
-
-    private
-
-    def parse_filter_expressions(filter_name, unparsed_args)
-      filter_args = []
-      keyword_args = {}
-      unparsed_args.each do |a|
-        if matches = a.match(/\A#{TagAttributes}\z/o)
-          keyword_args[matches[1]] = Expression.parse(matches[2])
-        else
-          filter_args << Expression.parse(a)
         end
-      end
+        filterargs << keyword_args unless keyword_args.empty?
-      result = [filter_name, filter_args]
+        begin
-      result << keyword_args unless keyword_args.empty?
+          output = context.invoke(filter[0], output, *filterargs)
-      result
+        rescue FilterNotFound
-    end
+          raise FilterNotFound, "Error - filter '#{filter[0]}' in '#{@markup.strip}' could not be found."
-
-    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(context, obj)
-      return unless obj.tainted?
-      return if Template.taint_mode == :lax
-
-      @markup =~ QuotedFragment
-      name = Regexp.last_match(0)
-
-      error = TaintedError.new("variable '#{name}' is tainted and was not escaped")
-      error.line_number = line_number
-      error.template_name = context.template_name
-
-      case Template.taint_mode
-      when :warn
-        context.warnings << error
-      when :error
-        raise error
       end
     end
   end

lib/liquid/variable_lookup.rb

@@ -1,82 +0,0 @@
-module Liquid
-  class VariableLookup
-    SQUARE_BRACKETED = /\A\[(.*)\]\z/m
-    COMMAND_METHODS = ['size'.freeze, 'first'.freeze, 'last'.freeze]
-
-    attr_reader :name, :lookups
-
-    def self.parse(markup)
-      new(markup)
-    end
-
-    def initialize(markup)
-      lookups = markup.scan(VariableParser)
-
-      name = lookups.shift
-      if name =~ SQUARE_BRACKETED
-        name = Expression.parse($1)
-      end
-      @name = name
-
-      @lookups = lookups
-      @command_flags = 0
-
-      @lookups.each_index do |i|
-        lookup = lookups[i]
-        if lookup =~ SQUARE_BRACKETED
-          lookups[i] = Expression.parse($1)
-        elsif COMMAND_METHODS.include?(lookup)
-          @command_flags |= 1 << i
-        end
-      end
-    end
-
-    def evaluate(context)
-      name = context.evaluate(@name)
-      object = context.find_variable(name)
-
-      @lookups.each_index do |i|
-        key = context.evaluate(@lookups[i])
-
-        # If object is a hash- or array-like object we look for the
-        # presence of the key and if its available we return it
-        if object.respond_to?(:[]) &&
-            ((object.respond_to?(:key?) && object.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 or
-          # raise an exception if `strict_variables` option is set to true
-        else
-          return nil unless context.strict_variables
-          raise Liquid::UndefinedVariable, "undefined variable #{key}"
-        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 && state == other.state
-    end
-
-    protected
-
-    def state
-      [@name, @lookups, @command_flags]
-    end
-  end
-end

lib/liquid/version.rb

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

liquid.gemspec

@@ -1,30 +1,24 @@
 # encoding: utf-8
-lib = File.expand_path('../lib/', __FILE__)
-$LOAD_PATH.unshift lib unless $LOAD_PATH.include?(lib)
-
-require "liquid/version"
 
 Gem::Specification.new do |s|
   s.name        = "liquid"
-  s.version     = Liquid::VERSION
+  s.version     = "2.5.0"
   s.platform    = Gem::Platform::RUBY
   s.summary     = "A secure, non-evaling end user template engine with aesthetic markup."
-  s.authors     = ["Tobias Lütke"]
+  s.authors     = ["Tobias Luetke"]
   s.email       = ["tobi@leetsoft.com"]
   s.homepage    = "http://www.liquidmarkup.org"
-  s.license     = "MIT"
+  #s.description = "A secure, non-evaling end user template engine with aesthetic markup."
-  # s.description = "A secure, non-evaling end user template engine with aesthetic markup."
 
-  s.required_ruby_version     = ">= 2.1.0"
   s.required_rubygems_version = ">= 1.3.7"
 
   s.test_files  = Dir.glob("{test}/**/*")
-  s.files       = Dir.glob("{lib}/**/*") + %w(LICENSE README.md)
+  s.files       = Dir.glob("{lib}/**/*") +
+                  Dir.glob("{ext}/**/*") + %w(MIT-LICENSE README.md)
 
-  s.extra_rdoc_files = ["History.md", "README.md"]
+  s.extensions = ['ext/liquid/extconf.rb']
 
-  s.require_path = "lib"
+  s.extra_rdoc_files  = ["History.md", "README.md"]
 
-  s.add_development_dependency 'rake', '~> 11.3'
+  s.require_paths = ["lib", "ext"]
-  s.add_development_dependency 'minitest'
 end

performance/benchmark.rb

@@ -1,18 +1,11 @@
-require 'benchmark/ips'
+require 'rubygems'
-require_relative 'theme_runner'
+require 'benchmark'
+require File.dirname(__FILE__) + '/theme_runner'
 
-Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
 profiler = ThemeRunner.new
 
-Benchmark.ips do |x|
+Benchmark.bm do |x|
-  x.time = 10
+#  x.report("parse:")   { 100.times { profiler.compile } }
-  x.warmup = 5
+  x.report("parse & run:")   { 100.times { profiler.run } }
-
-  puts
-  puts "Running benchmark for #{x.time} seconds (with #{x.warmup} seconds warmup)."
-  puts
-
-  x.report("parse:") { profiler.compile }
-  x.report("render:") { profiler.render }
-  x.report("parse & render:") { profiler.run }
 end
+

performance/profile.rb

@@ -1,24 +1,17 @@
-require 'stackprof'
+require 'rubygems'
-require_relative 'theme_runner'
+require 'ruby-prof' rescue fail("install ruby-prof extension/gem")
+require File.dirname(__FILE__) + '/theme_runner'
 
-Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
 profiler = ThemeRunner.new
-profiler.run
 
-[:cpu, :object].each do |profile_type|
+puts 'Running profiler...'
-  puts "Profiling in #{profile_type} mode..."
-  results = StackProf.run(mode: profile_type) do
-    200.times do
-      profiler.run
-    end
-  end
 
-  if profile_type == :cpu && graph_filename = ENV['GRAPH_FILENAME']
+results  = profiler.run_profile
-    File.open(graph_filename, 'w') do |f|
-      StackProf::Report.new(results).print_graphviz(nil, f)
-    end
-  end
 
-  StackProf::Report.new(results).print_text(false, 20)
+puts 'Success'
-  File.write(ENV['FILENAME'] + "." + profile_type.to_s, Marshal.dump(results)) if ENV['FILENAME']
+
+filename = (ENV['TMP'] || '/tmp') + "/callgrind.liquid.txt"
+File.open(filename, "w+") do |fp| 
+  RubyProf::CallTreePrinter.new(results).print(fp, :print_file => true) 
 end
+$stderr.puts "wrote RubyProf::CallTreePrinter output to #{filename}"

performance/shopify/comment_form.rb

@@ -1,15 +1,15 @@
 class CommentForm < Liquid::Block                                             
   Syntax = /(#{Liquid::VariableSignature}+)/   
 
-  def initialize(tag_name, markup, options)
+  def initialize(tag_name, markup, tokens)
-    super
-
     if markup =~ Syntax
       @variable_name = $1
       @attributes = {}
     else
       raise SyntaxError.new("Syntax Error in 'comment_form' - Valid syntax: comment_form [article]")
     end
+    
+    super
   end
 
   def render(context)          
@@ -28,6 +28,6 @@ class CommentForm < Liquid::Block
   end          
     
   def wrap_in_form(article, input)    
-    %(<form id="article-#{article.id}-comment-form" class="comment-form" method="post" action="">\n#{input}\n</form>)
+    %Q{<form id="article-#{article.id}-comment-form" class="comment-form" method="post" action="">\n#{input}\n</form>}    
   end
 end

performance/shopify/database.rb

@@ -1,11 +1,11 @@
 require 'yaml'
-
 module Database
+  
   # Load the standard vision toolkit database and re-arrage it to be simply exportable 
   # to liquid as assigns. All this is based on Shopify
   def self.tables
     @tables ||= begin      
-      db = YAML.load_file("#{__dir__}/vision.database.yml")
+      db = YAML.load_file(File.dirname(__FILE__) + '/vision.database.yml')
 
       # From vision source      
       db['products'].each do |product|
@@ -39,7 +39,7 @@ module Database
   end
 end
 
-if __FILE__ == $PROGRAM_NAME
+if __FILE__ == $0
   p Database.tables['collections']['frontpage'].keys
-  # p Database.tables['blog']['articles']
+  #p Database.tables['blog']['articles']
 end

performance/shopify/json_filter.rb

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

performance/shopify/liquid.rb

@@ -1,13 +1,13 @@
-$:.unshift __dir__ + '/../../lib'
+$:.unshift File.dirname(__FILE__) + '/../../lib'
-require_relative '../../lib/liquid'
+require File.dirname(__FILE__) + '/../../lib/liquid'
 
-require_relative 'comment_form'
+require File.dirname(__FILE__) + '/comment_form'
-require_relative 'paginate'
+require File.dirname(__FILE__) + '/paginate'
-require_relative 'json_filter'
+require File.dirname(__FILE__) + '/json_filter'
-require_relative 'money_filter'
+require File.dirname(__FILE__) + '/money_filter'
-require_relative 'shop_filter'
+require File.dirname(__FILE__) + '/shop_filter'
-require_relative 'tag_filter'
+require File.dirname(__FILE__) + '/tag_filter'
-require_relative 'weight_filter'
+require File.dirname(__FILE__) + '/weight_filter'
 
 Liquid::Template.register_tag 'paginate', Paginate
 Liquid::Template.register_tag 'form', CommentForm

performance/shopify/money_filter.rb

@@ -1,12 +1,13 @@
 module MoneyFilter
+  
   def money_with_currency(money)
     return '' if money.nil?
-    sprintf("$ %.2f USD", money / 100.0)
+    sprintf("$ %.2f USD", money/100.0)
   end
 
   def money(money)
     return '' if money.nil?
-    sprintf("$ %.2f", money / 100.0)
+    sprintf("$ %.2f", money/100.0)
   end
   
   private 

performance/shopify/paginate.rb

@@ -1,8 +1,8 @@
 class Paginate < Liquid::Block
   Syntax     = /(#{Liquid::QuotedFragment})\s*(by\s*(\d+))?/
 
-  def initialize(tag_name, markup, options)
+  def initialize(tag_name, markup, tokens)
-    super
+    @nodelist = []
     
     if markup =~ Syntax
       @collection_name = $1
@@ -19,6 +19,8 @@ class Paginate < Liquid::Block
     else
       raise SyntaxError.new("Syntax Error in tag 'paginate' - Valid syntax: paginate [collection] by number")
     end
+  
+    super
   end
 
   def render(context)
@@ -42,22 +44,23 @@ class Paginate < Liquid::Block
       page_count = (collection_size.to_f / @page_size.to_f).to_f.ceil + 1 
 
       pagination['items']      = collection_size
-      pagination['pages']      = page_count - 1
+      pagination['pages']      = page_count -1
-      pagination['previous']   = link('&laquo; Previous', current_page - 1)  unless 1 >= current_page
+      pagination['previous']   = link('&laquo; Previous', current_page-1 )  unless 1 >= current_page
-      pagination['next']       = link('Next &raquo;', current_page + 1)      unless page_count <= current_page + 1
+      pagination['next']       = link('Next &raquo;', current_page+1 )      unless page_count <= current_page+1
       pagination['parts']      = []
       
       hellip_break = false
       
       if page_count > 2
-        1.upto(page_count - 1) do |page|
+        1.upto(page_count-1) do |page|
+        
           if current_page == page
             pagination['parts'] << no_link(page)
           elsif page == 1 
             pagination['parts'] << link(page, page)
-          elsif page == page_count - 1
+          elsif page == page_count -1
             pagination['parts'] << link(page, page)
-          elsif page <= current_page - @attributes['window_size'] || page >= current_page + @attributes['window_size']
+          elsif page <= current_page - @attributes['window_size'] or page >= current_page + @attributes['window_size']
             next if hellip_break
             pagination['parts'] << no_link('&hellip;')
             hellip_break = true
@@ -70,18 +73,18 @@ class Paginate < Liquid::Block
         end 
       end
       
-      super
+      render_all(@nodelist, context)
     end
   end
     
   private
   
   def no_link(title)
-    { 'title' => title, 'is_link' => false }
+    { 'title' => title, 'is_link' => false}
   end
   
   def link(title, page)
-    { 'title' => title, 'url' => current_url + "?page=#{page}", 'is_link' => true }
+    { 'title' => title, 'url' => current_url + "?page=#{page}", 'is_link' => true}
   end
   
   def current_url

performance/shopify/shop_filter.rb

@@ -1,4 +1,5 @@
 module ShopFilter
+      
   def asset_url(input)
     "/files/1/[shop_id]/[shop_id]/assets/#{input}"
   end
@@ -15,16 +16,16 @@ module ShopFilter
     %(<script src="#{url}" type="text/javascript"></script>)
   end
 
-  def stylesheet_tag(url, media = "all")
+  def stylesheet_tag(url, media="all")
     %(<link href="#{url}" rel="stylesheet" type="text/css"  media="#{media}"  />)
   end
        
-  def link_to(link, url, title = "")
+  def link_to(link, url, title="")
-    %(<a href="#{url}" title="#{title}">#{link}</a>)
+    %|<a href="#{url}" title="#{title}">#{link}</a>|
   end
   
-  def img_tag(url, alt = "")
+  def img_tag(url, alt="")
-    %(<img src="#{url}" alt="#{alt}" />)
+    %|<img src="#{url}" alt="#{alt}" />|  
   end  
   
   def link_to_vendor(vendor)
@@ -44,15 +45,16 @@ module ShopFilter
   end
   
   def url_for_vendor(vendor_title)
-    "/collections/#{to_handle(vendor_title)}"
+    "/collections/#{vendor_title.to_handle}"
   end
   
   def url_for_type(type_title)
-    "/collections/#{to_handle(type_title)}"
+    "/collections/#{type_title.to_handle}"
   end
   
   def product_img_url(url, style = 'small')
-    unless url =~ /\Aproducts\/([\w\-\_]+)\.(\w{2,4})/
+    
+    unless url =~ /^products\/([\w\-\_]+)\.(\w{2,4})/
       raise ArgumentError, 'filter "size" can only be called on product images'
     end
     
@@ -67,6 +69,7 @@ module ShopFilter
   end
   
   def default_pagination(paginate)
+    
     html = []    
     html << %(<span class="prev">#{link_to(paginate['previous']['title'], paginate['previous']['url'])}</span>) if paginate['previous']
 
@@ -92,15 +95,4 @@ module ShopFilter
     input == 1 ? singular : plural
   end
       
-  private
-
-  def to_handle(str)
-    result = str.dup
-    result.downcase!
-    result.delete!("'\"()[]")
-    result.gsub!(/\W+/, '-')
-    result.gsub!(/-+\z/, '') if result[-1] == '-'
-    result.gsub!(/\A-+/, '') if result[0] == '-'
-    result
-  end
 end

performance/shopify/tag_filter.rb

@@ -1,9 +1,10 @@
 module TagFilter
+    
   def link_to_tag(label, tag)    
     "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tag}\">#{label}</a>"
   end
   
-  def highlight_active_tag(tag, css_class = 'active')
+  def highlight_active_tag(tag, css_class='active')
     if @context['current_tags'].include?(tag)
       "<span class=\"#{css_class}\">#{tag}</span>"
     else
@@ -20,4 +21,5 @@ module TagFilter
     tags = (@context['current_tags'] - [tag]).uniq
     "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tags.join("+")}\">#{label}</a>"
   end
+  
 end

performance/shopify/weight_filter.rb

@@ -1,4 +1,5 @@
 module WeightFilter
+
   def weight(grams)
     sprintf("%.2f", grams / 1000)
   end
@@ -6,4 +7,5 @@ module WeightFilter
   def weight_with_unit(grams)
     "#{weight(grams)} kg"
   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>
+		</div>
-  {% else %}
+	{% 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 />
+	  In <em>Admin &gt; Blogs &amp; Pages</em>, create a page with the handle <strong><code>frontpage</code></strong> and it will show up here.<br />
-    {{ "Learn more about handles" | link_to: "http://wiki.shopify.com/Handle" }}
+	  {{ "Learn more about handles" | link_to "http://wiki.shopify.com/Handle" }}
     </div>
-  {% endif %}
+	{% 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>