Allow floats > 9

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

.gitignore

@@ -1 +1,10 @@
-*.gem
+*~
+*.gem
+*.swp
+pkg
+*.rbc
+.rvmrc
+*.o
+*.bundle
+ext/liquid/Makefile
+

.travis.yml

@@ -0,0 +1,13 @@
+rvm:
+  - 1.8.7
+  - 1.9.3
+  - ree
+  - jruby-18mode
+  - jruby-19mode
+  - rbx-18mode
+  - rbx-19mode
+
+script: "rake test"
+
+notifications:
+  disable: true

CHANGELOG

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

History.md

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

Manifest.txt

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

README.md

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

README.txt

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

Rakefile

@@ -1,24 +1,91 @@
 #!/usr/bin/env ruby
+
 require 'rubygems'
 require 'rake'
-require 'hoe'
+require 'rake/clean'
+require 'fileutils'
+require 'rake/testtask'
+require 'rubygems/package_task'
 
-PKG_VERSION = "2.0.0"
-PKG_NAME    = "liquid"
-PKG_DESC    = "A secure non evaling end user template engine with aesthetic markup."
+task :default => [:compile, :test]
 
-Rake::TestTask.new(:test) do |t|
-  t.libs << "lib"
-  t.libs << "test"
-  t.pattern = 'test/*_test.rb'
+task :gen do
+  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/liquid/**/*_test.rb']
   t.verbose = false
 end
 
-Hoe.new(PKG_NAME, PKG_VERSION) do |p|
-  p.rubyforge_name = PKG_NAME
-  p.summary        = PKG_DESC
-  p.description    = PKG_DESC
-  p.author         = "Tobias Luetke"
-  p.email          = "tobi@leetsoft.com"
-  p.url            = "http://www.liquidmarkup.org"    
-end
+gemspec = eval(File.read('liquid.gemspec'))
+Gem::PackageTask.new(gemspec) do |pkg|
+  pkg.gem_spec = gemspec
+end
+
+desc "Build the gem and release it to rubygems.org"
+task :release => :gem do
+  sh "gem push pkg/liquid-#{gemspec.version}.gem"
+end
+
+namespace :benchmark do
+
+  desc "Run the liquid benchmark"
+  task :run do
+    ruby "./performance/benchmark.rb"
+  end
+
+end
+
+
+namespace :profile do
+
+  desc "Run the liquid profile/performance coverage"
+  task :run do
+    ruby "./performance/profile.rb"
+  end
+
+  desc "Run KCacheGrind"
+  task :grind => :run  do
+    system "qcachegrind /tmp//callgrind.liquid.txt"
+  end
+
+end
+
+desc "Run example"
+task :example do
+  ruby "-w -d -Ilib example/server/server.rb"
+end

example/server/example_servlet.rb

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

example/server/server.rb

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

example/server/templates/products.liquid

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

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.c

@@ -0,0 +1,764 @@
+/* A recursive-descent parser generated by peg 0.1.9 */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#define YYRULECOUNT 14
+ 
+//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));      \
+    } \
+  }
+
+#ifndef YY_LOCAL
+#define YY_LOCAL(T)	static T
+#endif
+#ifndef YY_ACTION
+#define YY_ACTION(T)	static T
+#endif
+#ifndef YY_RULE
+#define YY_RULE(T)	static T
+#endif
+#ifndef YY_PARSE
+#define YY_PARSE(T)	T
+#endif
+#ifndef YYPARSE
+#define YYPARSE		yyparse
+#endif
+#ifndef YYPARSEFROM
+#define YYPARSEFROM	yyparsefrom
+#endif
+#ifndef YY_INPUT
+#define YY_INPUT(buf, result, max_size)			\
+  {							\
+    int yyc= getchar();					\
+    result= (EOF == yyc) ? 0 : (*(buf)= yyc, 1);	\
+    yyprintf((stderr, "<%c>", yyc));			\
+  }
+#endif
+#ifndef YY_BEGIN
+#define YY_BEGIN	( ctx->begin= ctx->pos, 1)
+#endif
+#ifndef YY_END
+#define YY_END		( ctx->end= ctx->pos, 1)
+#endif
+#ifdef YY_DEBUG
+# define yyprintf(args)	fprintf args
+#else
+# define yyprintf(args)
+#endif
+#ifndef YYSTYPE
+#define YYSTYPE	int
+#endif
+
+#ifndef YY_PART
+
+typedef struct _yycontext yycontext;
+typedef void (*yyaction)(yycontext *ctx, char *yytext, int yyleng);
+typedef struct _yythunk { int begin, end;  yyaction  action;  struct _yythunk *next; } yythunk;
+
+struct _yycontext {
+  char     *buf;
+  int       buflen;
+  int       pos;
+  int       limit;
+  char     *text;
+  int       textlen;
+  int       begin;
+  int       end;
+  int       textmax;
+  yythunk  *thunks;
+  int       thunkslen;
+  int       thunkpos;
+  YYSTYPE   yy;
+  YYSTYPE  *val;
+  YYSTYPE  *vals;
+  int       valslen;
+#ifdef YY_CTX_MEMBERS
+  YY_CTX_MEMBERS
+#endif
+};
+
+#ifdef YY_CTX_LOCAL
+#define YY_CTX_PARAM_	yycontext *yyctx,
+#define YY_CTX_PARAM	yycontext *yyctx
+#define YY_CTX_ARG_	yyctx,
+#define YY_CTX_ARG	yyctx
+#else
+#define YY_CTX_PARAM_
+#define YY_CTX_PARAM
+#define YY_CTX_ARG_
+#define YY_CTX_ARG
+yycontext yyctx0;
+yycontext *yyctx= &yyctx0;
+#endif
+
+YY_LOCAL(int) yyrefill(yycontext *ctx)
+{
+  int yyn;
+  while (ctx->buflen - ctx->pos < 512)
+    {
+      ctx->buflen *= 2;
+      ctx->buf= (char *)realloc(ctx->buf, ctx->buflen);
+    }
+  YY_INPUT((ctx->buf + ctx->pos), yyn, (ctx->buflen - ctx->pos));
+  if (!yyn) return 0;
+  ctx->limit += yyn;
+  return 1;
+}
+
+YY_LOCAL(int) yymatchDot(yycontext *ctx)
+{
+  if (ctx->pos >= ctx->limit && !yyrefill(ctx)) return 0;
+  ++ctx->pos;
+  return 1;
+}
+
+YY_LOCAL(int) yymatchChar(yycontext *ctx, int c)
+{
+  if (ctx->pos >= ctx->limit && !yyrefill(ctx)) return 0;
+  if ((unsigned char)ctx->buf[ctx->pos] == c)
+    {
+      ++ctx->pos;
+      yyprintf((stderr, "  ok   yymatchChar(ctx, %c) @ %s\n", c, ctx->buf+ctx->pos));
+      return 1;
+    }
+  yyprintf((stderr, "  fail yymatchChar(ctx, %c) @ %s\n", c, ctx->buf+ctx->pos));
+  return 0;
+}
+
+YY_LOCAL(int) yymatchString(yycontext *ctx, char *s)
+{
+  int yysav= ctx->pos;
+  while (*s)
+    {
+      if (ctx->pos >= ctx->limit && !yyrefill(ctx)) return 0;
+      if (ctx->buf[ctx->pos] != *s)
+        {
+          ctx->pos= yysav;
+          return 0;
+        }
+      ++s;
+      ++ctx->pos;
+    }
+  return 1;
+}
+
+YY_LOCAL(int) yymatchClass(yycontext *ctx, unsigned char *bits)
+{
+  int c;
+  if (ctx->pos >= ctx->limit && !yyrefill(ctx)) return 0;
+  c= (unsigned char)ctx->buf[ctx->pos];
+  if (bits[c >> 3] & (1 << (c & 7)))
+    {
+      ++ctx->pos;
+      yyprintf((stderr, "  ok   yymatchClass @ %s\n", ctx->buf+ctx->pos));
+      return 1;
+    }
+  yyprintf((stderr, "  fail yymatchClass @ %s\n", ctx->buf+ctx->pos));
+  return 0;
+}
+
+YY_LOCAL(void) yyDo(yycontext *ctx, yyaction action, int begin, int end)
+{
+  while (ctx->thunkpos >= ctx->thunkslen)
+    {
+      ctx->thunkslen *= 2;
+      ctx->thunks= (yythunk *)realloc(ctx->thunks, sizeof(yythunk) * ctx->thunkslen);
+    }
+  ctx->thunks[ctx->thunkpos].begin=  begin;
+  ctx->thunks[ctx->thunkpos].end=    end;
+  ctx->thunks[ctx->thunkpos].action= action;
+  ++ctx->thunkpos;
+}
+
+YY_LOCAL(int) yyText(yycontext *ctx, int begin, int end)
+{
+  int yyleng= end - begin;
+  if (yyleng <= 0)
+    yyleng= 0;
+  else
+    {
+      while (ctx->textlen < (yyleng + 1))
+	{
+	  ctx->textlen *= 2;
+	  ctx->text= (char *)realloc(ctx->text, ctx->textlen);
+	}
+      memcpy(ctx->text, ctx->buf + begin, yyleng);
+    }
+  ctx->text[yyleng]= '\0';
+  return yyleng;
+}
+
+YY_LOCAL(void) yyDone(yycontext *ctx)
+{
+  int pos;
+  for (pos= 0;  pos < ctx->thunkpos;  ++pos)
+    {
+      yythunk *thunk= &ctx->thunks[pos];
+      int yyleng= thunk->end ? yyText(ctx, thunk->begin, thunk->end) : thunk->begin;
+      yyprintf((stderr, "DO [%d] %p %s\n", pos, thunk->action, ctx->text));
+      thunk->action(ctx, ctx->text, yyleng);
+    }
+  ctx->thunkpos= 0;
+}
+
+YY_LOCAL(void) yyCommit(yycontext *ctx)
+{
+  if ((ctx->limit -= ctx->pos))
+    {
+      memmove(ctx->buf, ctx->buf + ctx->pos, ctx->limit);
+    }
+  ctx->begin -= ctx->pos;
+  ctx->end -= ctx->pos;
+  ctx->pos= ctx->thunkpos= 0;
+}
+
+YY_LOCAL(int) yyAccept(yycontext *ctx, int tp0)
+{
+  if (tp0)
+    {
+      fprintf(stderr, "accept denied at %d\n", tp0);
+      return 0;
+    }
+  else
+    {
+      yyDone(ctx);
+      yyCommit(ctx);
+    }
+  return 1;
+}
+
+YY_LOCAL(void) yyPush(yycontext *ctx, char *text, int count)  { ctx->val += count; }
+YY_LOCAL(void) yyPop(yycontext *ctx, char *text, int count)   { ctx->val -= count; }
+YY_LOCAL(void) yySet(yycontext *ctx, char *text, int count)   { ctx->val[count]= ctx->yy; }
+
+#endif /* YY_PART */
+
+#define	YYACCEPT	yyAccept(ctx, yythunkpos0)
+
+YY_RULE(int) yy_digit(yycontext *ctx); /* 14 */
+YY_RULE(int) yy_float(yycontext *ctx); /* 13 */
+YY_RULE(int) yy_integer(yycontext *ctx); /* 12 */
+YY_RULE(int) yy_rangelet(yycontext *ctx); /* 11 */
+YY_RULE(int) yy_identifier(yycontext *ctx); /* 10 */
+YY_RULE(int) yy_accessors(yycontext *ctx); /* 9 */
+YY_RULE(int) yy_numeric(yycontext *ctx); /* 8 */
+YY_RULE(int) yy_string(yycontext *ctx); /* 7 */
+YY_RULE(int) yy_const(yycontext *ctx); /* 6 */
+YY_RULE(int) yy_hash(yycontext *ctx); /* 5 */
+YY_RULE(int) yy_range(yycontext *ctx); /* 4 */
+YY_RULE(int) yy_entity(yycontext *ctx); /* 3 */
+YY_RULE(int) yy_primary(yycontext *ctx); /* 2 */
+YY_RULE(int) yy_grammar(yycontext *ctx); /* 1 */
+
+YY_ACTION(void) yy_4_const(yycontext *ctx, char *yytext, int yyleng)
+{
+#define yy ctx->yy
+#define yypos ctx->pos
+#define yythunkpos ctx->thunkpos
+  yyprintf((stderr, "do yy_4_const\n"));
+   yy = Qnil; ;
+#undef yythunkpos
+#undef yypos
+#undef yy
+}
+YY_ACTION(void) yy_3_const(yycontext *ctx, char *yytext, int yyleng)
+{
+#define yy ctx->yy
+#define yypos ctx->pos
+#define yythunkpos ctx->thunkpos
+  yyprintf((stderr, "do yy_3_const\n"));
+   yy = Qnil; ;
+#undef yythunkpos
+#undef yypos
+#undef yy
+}
+YY_ACTION(void) yy_2_const(yycontext *ctx, char *yytext, int yyleng)
+{
+#define yy ctx->yy
+#define yypos ctx->pos
+#define yythunkpos ctx->thunkpos
+  yyprintf((stderr, "do yy_2_const\n"));
+   yy = Qfalse; ;
+#undef yythunkpos
+#undef yypos
+#undef yy
+}
+YY_ACTION(void) yy_1_const(yycontext *ctx, char *yytext, int yyleng)
+{
+#define yy ctx->yy
+#define yypos ctx->pos
+#define yythunkpos ctx->thunkpos
+  yyprintf((stderr, "do yy_1_const\n"));
+   yy = Qtrue; ;
+#undef yythunkpos
+#undef yypos
+#undef yy
+}
+YY_ACTION(void) yy_1_integer(yycontext *ctx, char *yytext, int yyleng)
+{
+#define yy ctx->yy
+#define yypos ctx->pos
+#define yythunkpos ctx->thunkpos
+  yyprintf((stderr, "do yy_1_integer\n"));
+   yy = rb_funcall(rb_cObject, rb_intern("Integer"), 1, yy_rb_str); ;
+#undef yythunkpos
+#undef yypos
+#undef yy
+}
+YY_ACTION(void) yy_1_float(yycontext *ctx, char *yytext, int yyleng)
+{
+#define yy ctx->yy
+#define yypos ctx->pos
+#define yythunkpos ctx->thunkpos
+  yyprintf((stderr, "do yy_1_float\n"));
+   yy = rb_funcall(rb_cObject, rb_intern("Float"), 1, yy_rb_str); ;
+#undef yythunkpos
+#undef yypos
+#undef yy
+}
+YY_ACTION(void) yy_2_string(yycontext *ctx, char *yytext, int yyleng)
+{
+#define yy ctx->yy
+#define yypos ctx->pos
+#define yythunkpos ctx->thunkpos
+  yyprintf((stderr, "do yy_2_string\n"));
+   yy = yy_rb_str; ;
+#undef yythunkpos
+#undef yypos
+#undef yy
+}
+YY_ACTION(void) yy_1_string(yycontext *ctx, char *yytext, int yyleng)
+{
+#define yy ctx->yy
+#define yypos ctx->pos
+#define yythunkpos ctx->thunkpos
+  yyprintf((stderr, "do yy_1_string\n"));
+   yy = yy_rb_str; ;
+#undef yythunkpos
+#undef yypos
+#undef yy
+}
+YY_ACTION(void) yy_1_range(yycontext *ctx, char *yytext, int yyleng)
+{
+#define yy ctx->yy
+#define yypos ctx->pos
+#define yythunkpos ctx->thunkpos
+  yyprintf((stderr, "do yy_1_range\n"));
+   EMIT("range", Qnil); ;
+#undef yythunkpos
+#undef yypos
+#undef yy
+}
+YY_ACTION(void) yy_1_rangelet(yycontext *ctx, char *yytext, int yyleng)
+{
+#define var ctx->val[-1]
+#define yy ctx->yy
+#define yypos ctx->pos
+#define yythunkpos ctx->thunkpos
+  yyprintf((stderr, "do yy_1_rangelet\n"));
+   EMIT("id", var); ;
+#undef yythunkpos
+#undef yypos
+#undef yy
+#undef var
+}
+YY_ACTION(void) yy_1_entity(yycontext *ctx, char *yytext, int yyleng)
+{
+#define yy ctx->yy
+#define yypos ctx->pos
+#define yythunkpos ctx->thunkpos
+  yyprintf((stderr, "do yy_1_entity\n"));
+   EMIT("id", yy_rb_str); EMIT("lookup", Qnil); ;
+#undef yythunkpos
+#undef yypos
+#undef yy
+}
+YY_ACTION(void) yy_5_accessors(yycontext *ctx, char *yytext, int yyleng)
+{
+#define yy ctx->yy
+#define yypos ctx->pos
+#define yythunkpos ctx->thunkpos
+  yyprintf((stderr, "do yy_5_accessors\n"));
+   EMIT("id", yy_rb_str); EMIT("call", Qnil); ;
+#undef yythunkpos
+#undef yypos
+#undef yy
+}
+YY_ACTION(void) yy_4_accessors(yycontext *ctx, char *yytext, int yyleng)
+{
+#define yy ctx->yy
+#define yypos ctx->pos
+#define yythunkpos ctx->thunkpos
+  yyprintf((stderr, "do yy_4_accessors\n"));
+   EMIT("buildin", rb_str_new2("size")); ;
+#undef yythunkpos
+#undef yypos
+#undef yy
+}
+YY_ACTION(void) yy_3_accessors(yycontext *ctx, char *yytext, int yyleng)
+{
+#define yy ctx->yy
+#define yypos ctx->pos
+#define yythunkpos ctx->thunkpos
+  yyprintf((stderr, "do yy_3_accessors\n"));
+   EMIT("buildin", rb_str_new2("last")); ;
+#undef yythunkpos
+#undef yypos
+#undef yy
+}
+YY_ACTION(void) yy_2_accessors(yycontext *ctx, char *yytext, int yyleng)
+{
+#define yy ctx->yy
+#define yypos ctx->pos
+#define yythunkpos ctx->thunkpos
+  yyprintf((stderr, "do yy_2_accessors\n"));
+   EMIT("buildin", rb_str_new2("first")); ;
+#undef yythunkpos
+#undef yypos
+#undef yy
+}
+YY_ACTION(void) yy_1_accessors(yycontext *ctx, char *yytext, int yyleng)
+{
+#define yy ctx->yy
+#define yypos ctx->pos
+#define yythunkpos ctx->thunkpos
+  yyprintf((stderr, "do yy_1_accessors\n"));
+   EMIT("call", Qnil); ;
+#undef yythunkpos
+#undef yypos
+#undef yy
+}
+YY_ACTION(void) yy_3_primary(yycontext *ctx, char *yytext, int yyleng)
+{
+#define var ctx->val[-1]
+#define yy ctx->yy
+#define yypos ctx->pos
+#define yythunkpos ctx->thunkpos
+  yyprintf((stderr, "do yy_3_primary\n"));
+   EMIT("id", var); ;
+#undef yythunkpos
+#undef yypos
+#undef yy
+#undef var
+}
+YY_ACTION(void) yy_2_primary(yycontext *ctx, char *yytext, int yyleng)
+{
+#define var ctx->val[-1]
+#define yy ctx->yy
+#define yypos ctx->pos
+#define yythunkpos ctx->thunkpos
+  yyprintf((stderr, "do yy_2_primary\n"));
+   EMIT("id", var); ;
+#undef yythunkpos
+#undef yypos
+#undef yy
+#undef var
+}
+YY_ACTION(void) yy_1_primary(yycontext *ctx, char *yytext, int yyleng)
+{
+#define var ctx->val[-1]
+#define yy ctx->yy
+#define yypos ctx->pos
+#define yythunkpos ctx->thunkpos
+  yyprintf((stderr, "do yy_1_primary\n"));
+   EMIT("id", var); ;
+#undef yythunkpos
+#undef yypos
+#undef yy
+#undef var
+}
+YY_ACTION(void) yy_1_grammar(yycontext *ctx, char *yytext, int yyleng)
+{
+#define yy ctx->yy
+#define yypos ctx->pos
+#define yythunkpos ctx->thunkpos
+  yyprintf((stderr, "do yy_1_grammar\n"));
+   EMIT("lookup", Qnil); ;
+#undef yythunkpos
+#undef yypos
+#undef yy
+}
+
+YY_RULE(int) yy_digit(yycontext *ctx)
+{  int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos;
+  yyprintf((stderr, "%s\n", "digit"));  if (!yymatchClass(ctx, (unsigned char *)"\000\000\000\000\000\000\377\003\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l1;
+  yyprintf((stderr, "  ok   %s @ %s\n", "digit", ctx->buf+ctx->pos));
+  return 1;
+  l1:;	  ctx->pos= yypos0; ctx->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "digit", ctx->buf+ctx->pos));
+  return 0;
+}
+YY_RULE(int) yy_float(yycontext *ctx)
+{  int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos;
+  yyprintf((stderr, "%s\n", "float"));  yyText(ctx, ctx->begin, ctx->end);  if (!(YY_BEGIN)) goto l2;
+  {  int yypos3= ctx->pos, yythunkpos3= ctx->thunkpos;  if (!yymatchChar(ctx, '-')) goto l3;  goto l4;
+  l3:;	  ctx->pos= yypos3; ctx->thunkpos= yythunkpos3;
+  }
+  l4:;	  if (!yy_digit(ctx)) goto l2;  if (!yymatchChar(ctx, '.')) goto l2;  if (!yy_digit(ctx)) goto l2;
+  l5:;	
+  {  int yypos6= ctx->pos, yythunkpos6= ctx->thunkpos;  if (!yy_digit(ctx)) goto l6;  goto l5;
+  l6:;	  ctx->pos= yypos6; ctx->thunkpos= yythunkpos6;
+  }  yyText(ctx, ctx->begin, ctx->end);  if (!(YY_END)) goto l2;  yyDo(ctx, yy_1_float, ctx->begin, ctx->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "float", ctx->buf+ctx->pos));
+  return 1;
+  l2:;	  ctx->pos= yypos0; ctx->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "float", ctx->buf+ctx->pos));
+  return 0;
+}
+YY_RULE(int) yy_integer(yycontext *ctx)
+{  int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos;
+  yyprintf((stderr, "%s\n", "integer"));  yyText(ctx, ctx->begin, ctx->end);  if (!(YY_BEGIN)) goto l7;
+  {  int yypos8= ctx->pos, yythunkpos8= ctx->thunkpos;  if (!yymatchChar(ctx, '-')) goto l8;  goto l9;
+  l8:;	  ctx->pos= yypos8; ctx->thunkpos= yythunkpos8;
+  }
+  l9:;	  if (!yy_digit(ctx)) goto l7;
+  l10:;	
+  {  int yypos11= ctx->pos, yythunkpos11= ctx->thunkpos;  if (!yy_digit(ctx)) goto l11;  goto l10;
+  l11:;	  ctx->pos= yypos11; ctx->thunkpos= yythunkpos11;
+  }  yyText(ctx, ctx->begin, ctx->end);  if (!(YY_END)) goto l7;  yyDo(ctx, yy_1_integer, ctx->begin, ctx->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "integer", ctx->buf+ctx->pos));
+  return 1;
+  l7:;	  ctx->pos= yypos0; ctx->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "integer", ctx->buf+ctx->pos));
+  return 0;
+}
+YY_RULE(int) yy_rangelet(yycontext *ctx)
+{  int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos;  yyDo(ctx, yyPush, 1, 0);
+  yyprintf((stderr, "%s\n", "rangelet"));
+  {  int yypos13= ctx->pos, yythunkpos13= ctx->thunkpos;  if (!yy_integer(ctx)) goto l14;  yyDo(ctx, yySet, -1, 0);  yyDo(ctx, yy_1_rangelet, ctx->begin, ctx->end);  goto l13;
+  l14:;	  ctx->pos= yypos13; ctx->thunkpos= yythunkpos13;  if (!yy_entity(ctx)) goto l12;
+  }
+  l13:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "rangelet", ctx->buf+ctx->pos));  yyDo(ctx, yyPop, 1, 0);
+  return 1;
+  l12:;	  ctx->pos= yypos0; ctx->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "rangelet", ctx->buf+ctx->pos));
+  return 0;
+}
+YY_RULE(int) yy_identifier(yycontext *ctx)
+{  int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos;
+  yyprintf((stderr, "%s\n", "identifier"));  if (!yymatchClass(ctx, (unsigned char *)"\000\000\000\000\000\000\000\000\376\377\377\007\376\377\377\007\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l15;
+  l16:;	
+  {  int yypos17= ctx->pos, yythunkpos17= ctx->thunkpos;  if (!yymatchClass(ctx, (unsigned char *)"\000\000\000\000\000\040\377\003\376\377\377\207\376\377\377\007\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l17;  goto l16;
+  l17:;	  ctx->pos= yypos17; ctx->thunkpos= yythunkpos17;
+  }
+  {  int yypos18= ctx->pos, yythunkpos18= ctx->thunkpos;  if (!yymatchClass(ctx, (unsigned char *)"\000\000\000\000\002\000\000\200\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l18;  goto l19;
+  l18:;	  ctx->pos= yypos18; ctx->thunkpos= yythunkpos18;
+  }
+  l19:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "identifier", ctx->buf+ctx->pos));
+  return 1;
+  l15:;	  ctx->pos= yypos0; ctx->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "identifier", ctx->buf+ctx->pos));
+  return 0;
+}
+YY_RULE(int) yy_accessors(yycontext *ctx)
+{  int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos;
+  yyprintf((stderr, "%s\n", "accessors"));
+  {  int yypos21= ctx->pos, yythunkpos21= ctx->thunkpos;  if (!yy_hash(ctx)) goto l22;  yyDo(ctx, yy_1_accessors, ctx->begin, ctx->end);  goto l21;
+  l22:;	  ctx->pos= yypos21; ctx->thunkpos= yythunkpos21;  if (!yymatchString(ctx, ".first")) goto l23;  yyDo(ctx, yy_2_accessors, ctx->begin, ctx->end);  goto l21;
+  l23:;	  ctx->pos= yypos21; ctx->thunkpos= yythunkpos21;  if (!yymatchString(ctx, ".last")) goto l24;  yyDo(ctx, yy_3_accessors, ctx->begin, ctx->end);  goto l21;
+  l24:;	  ctx->pos= yypos21; ctx->thunkpos= yythunkpos21;  if (!yymatchString(ctx, ".size")) goto l25;  yyDo(ctx, yy_4_accessors, ctx->begin, ctx->end);  goto l21;
+  l25:;	  ctx->pos= yypos21; ctx->thunkpos= yythunkpos21;  if (!yymatchChar(ctx, '.')) goto l20;  yyText(ctx, ctx->begin, ctx->end);  if (!(YY_BEGIN)) goto l20;  if (!yy_identifier(ctx)) goto l20;  yyText(ctx, ctx->begin, ctx->end);  if (!(YY_END)) goto l20;  yyDo(ctx, yy_5_accessors, ctx->begin, ctx->end);
+  }
+  l21:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "accessors", ctx->buf+ctx->pos));
+  return 1;
+  l20:;	  ctx->pos= yypos0; ctx->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "accessors", ctx->buf+ctx->pos));
+  return 0;
+}
+YY_RULE(int) yy_numeric(yycontext *ctx)
+{  int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos;
+  yyprintf((stderr, "%s\n", "numeric"));
+  {  int yypos27= ctx->pos, yythunkpos27= ctx->thunkpos;  if (!yy_float(ctx)) goto l28;  goto l27;
+  l28:;	  ctx->pos= yypos27; ctx->thunkpos= yythunkpos27;  if (!yy_integer(ctx)) goto l26;
+  }
+  l27:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "numeric", ctx->buf+ctx->pos));
+  return 1;
+  l26:;	  ctx->pos= yypos0; ctx->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "numeric", ctx->buf+ctx->pos));
+  return 0;
+}
+YY_RULE(int) yy_string(yycontext *ctx)
+{  int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos;
+  yyprintf((stderr, "%s\n", "string"));
+  {  int yypos30= ctx->pos, yythunkpos30= ctx->thunkpos;  if (!yymatchClass(ctx, (unsigned char *)"\000\000\000\000\200\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l31;  yyText(ctx, ctx->begin, ctx->end);  if (!(YY_BEGIN)) goto l31;
+  l32:;	
+  {  int yypos33= ctx->pos, yythunkpos33= ctx->thunkpos;
+  {  int yypos34= ctx->pos, yythunkpos34= ctx->thunkpos;  if (!yymatchClass(ctx, (unsigned char *)"\000\000\000\000\200\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l34;  goto l33;
+  l34:;	  ctx->pos= yypos34; ctx->thunkpos= yythunkpos34;
+  }  if (!yymatchDot(ctx)) goto l33;  goto l32;
+  l33:;	  ctx->pos= yypos33; ctx->thunkpos= yythunkpos33;
+  }  yyText(ctx, ctx->begin, ctx->end);  if (!(YY_END)) goto l31;  if (!yymatchClass(ctx, (unsigned char *)"\000\000\000\000\200\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l31;  yyDo(ctx, yy_1_string, ctx->begin, ctx->end);  goto l30;
+  l31:;	  ctx->pos= yypos30; ctx->thunkpos= yythunkpos30;  if (!yymatchClass(ctx, (unsigned char *)"\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l29;  yyText(ctx, ctx->begin, ctx->end);  if (!(YY_BEGIN)) goto l29;
+  l35:;	
+  {  int yypos36= ctx->pos, yythunkpos36= ctx->thunkpos;
+  {  int yypos37= ctx->pos, yythunkpos37= ctx->thunkpos;  if (!yymatchClass(ctx, (unsigned char *)"\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l37;  goto l36;
+  l37:;	  ctx->pos= yypos37; ctx->thunkpos= yythunkpos37;
+  }  if (!yymatchDot(ctx)) goto l36;  goto l35;
+  l36:;	  ctx->pos= yypos36; ctx->thunkpos= yythunkpos36;
+  }  yyText(ctx, ctx->begin, ctx->end);  if (!(YY_END)) goto l29;  if (!yymatchClass(ctx, (unsigned char *)"\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")) goto l29;  yyDo(ctx, yy_2_string, ctx->begin, ctx->end);
+  }
+  l30:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "string", ctx->buf+ctx->pos));
+  return 1;
+  l29:;	  ctx->pos= yypos0; ctx->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "string", ctx->buf+ctx->pos));
+  return 0;
+}
+YY_RULE(int) yy_const(yycontext *ctx)
+{  int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos;
+  yyprintf((stderr, "%s\n", "const"));
+  {  int yypos39= ctx->pos, yythunkpos39= ctx->thunkpos;  if (!yymatchString(ctx, "true")) goto l40;  yyDo(ctx, yy_1_const, ctx->begin, ctx->end);  goto l39;
+  l40:;	  ctx->pos= yypos39; ctx->thunkpos= yythunkpos39;  if (!yymatchString(ctx, "false")) goto l41;  yyDo(ctx, yy_2_const, ctx->begin, ctx->end);  goto l39;
+  l41:;	  ctx->pos= yypos39; ctx->thunkpos= yythunkpos39;  if (!yymatchString(ctx, "nil")) goto l42;  yyDo(ctx, yy_3_const, ctx->begin, ctx->end);  goto l39;
+  l42:;	  ctx->pos= yypos39; ctx->thunkpos= yythunkpos39;  if (!yymatchString(ctx, "null")) goto l38;  yyDo(ctx, yy_4_const, ctx->begin, ctx->end);
+  }
+  l39:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "const", ctx->buf+ctx->pos));
+  return 1;
+  l38:;	  ctx->pos= yypos0; ctx->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "const", ctx->buf+ctx->pos));
+  return 0;
+}
+YY_RULE(int) yy_hash(yycontext *ctx)
+{  int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos;
+  yyprintf((stderr, "%s\n", "hash"));  if (!yymatchChar(ctx, '[')) goto l43;
+  {  int yypos44= ctx->pos, yythunkpos44= ctx->thunkpos;  if (!yy_primary(ctx)) goto l45;  goto l44;
+  l45:;	  ctx->pos= yypos44; ctx->thunkpos= yythunkpos44;  if (!yy_entity(ctx)) goto l43;
+  }
+  l44:;	  if (!yymatchChar(ctx, ']')) goto l43;
+  yyprintf((stderr, "  ok   %s @ %s\n", "hash", ctx->buf+ctx->pos));
+  return 1;
+  l43:;	  ctx->pos= yypos0; ctx->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "hash", ctx->buf+ctx->pos));
+  return 0;
+}
+YY_RULE(int) yy_range(yycontext *ctx)
+{  int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos;
+  yyprintf((stderr, "%s\n", "range"));  if (!yymatchChar(ctx, '(')) goto l46;  if (!yy_rangelet(ctx)) goto l46;  if (!yymatchString(ctx, "..")) goto l46;  if (!yy_rangelet(ctx)) goto l46;  if (!yymatchChar(ctx, ')')) goto l46;  yyDo(ctx, yy_1_range, ctx->begin, ctx->end);
+  yyprintf((stderr, "  ok   %s @ %s\n", "range", ctx->buf+ctx->pos));
+  return 1;
+  l46:;	  ctx->pos= yypos0; ctx->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "range", ctx->buf+ctx->pos));
+  return 0;
+}
+YY_RULE(int) yy_entity(yycontext *ctx)
+{  int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos;
+  yyprintf((stderr, "%s\n", "entity"));  yyText(ctx, ctx->begin, ctx->end);  if (!(YY_BEGIN)) goto l47;  if (!yy_identifier(ctx)) goto l47;  yyText(ctx, ctx->begin, ctx->end);  if (!(YY_END)) goto l47;  yyDo(ctx, yy_1_entity, ctx->begin, ctx->end);
+  l48:;	
+  {  int yypos49= ctx->pos, yythunkpos49= ctx->thunkpos;  if (!yy_accessors(ctx)) goto l49;  goto l48;
+  l49:;	  ctx->pos= yypos49; ctx->thunkpos= yythunkpos49;
+  }
+  yyprintf((stderr, "  ok   %s @ %s\n", "entity", ctx->buf+ctx->pos));
+  return 1;
+  l47:;	  ctx->pos= yypos0; ctx->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "entity", ctx->buf+ctx->pos));
+  return 0;
+}
+YY_RULE(int) yy_primary(yycontext *ctx)
+{  int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos;  yyDo(ctx, yyPush, 1, 0);
+  yyprintf((stderr, "%s\n", "primary"));
+  {  int yypos51= ctx->pos, yythunkpos51= ctx->thunkpos;  if (!yy_const(ctx)) goto l52;  yyDo(ctx, yySet, -1, 0);  yyDo(ctx, yy_1_primary, ctx->begin, ctx->end);  goto l51;
+  l52:;	  ctx->pos= yypos51; ctx->thunkpos= yythunkpos51;  if (!yy_string(ctx)) goto l53;  yyDo(ctx, yySet, -1, 0);  yyDo(ctx, yy_2_primary, ctx->begin, ctx->end);  goto l51;
+  l53:;	  ctx->pos= yypos51; ctx->thunkpos= yythunkpos51;  if (!yy_numeric(ctx)) goto l50;  yyDo(ctx, yySet, -1, 0);  yyDo(ctx, yy_3_primary, ctx->begin, ctx->end);
+  }
+  l51:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "primary", ctx->buf+ctx->pos));  yyDo(ctx, yyPop, 1, 0);
+  return 1;
+  l50:;	  ctx->pos= yypos0; ctx->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "primary", ctx->buf+ctx->pos));
+  return 0;
+}
+YY_RULE(int) yy_grammar(yycontext *ctx)
+{  int yypos0= ctx->pos, yythunkpos0= ctx->thunkpos;
+  yyprintf((stderr, "%s\n", "grammar"));
+  {  int yypos55= ctx->pos, yythunkpos55= ctx->thunkpos;  if (!yy_primary(ctx)) goto l56;  goto l55;
+  l56:;	  ctx->pos= yypos55; ctx->thunkpos= yythunkpos55;  if (!yy_entity(ctx)) goto l57;  goto l55;
+  l57:;	  ctx->pos= yypos55; ctx->thunkpos= yythunkpos55;  if (!yy_range(ctx)) goto l58;  goto l55;
+  l58:;	  ctx->pos= yypos55; ctx->thunkpos= yythunkpos55;  if (!yy_hash(ctx)) goto l54;  yyDo(ctx, yy_1_grammar, ctx->begin, ctx->end);
+  }
+  l55:;	
+  yyprintf((stderr, "  ok   %s @ %s\n", "grammar", ctx->buf+ctx->pos));
+  return 1;
+  l54:;	  ctx->pos= yypos0; ctx->thunkpos= yythunkpos0;
+  yyprintf((stderr, "  fail %s @ %s\n", "grammar", ctx->buf+ctx->pos));
+  return 0;
+}
+
+#ifndef YY_PART
+
+typedef int (*yyrule)(yycontext *ctx);
+
+YY_PARSE(int) YYPARSEFROM(YY_CTX_PARAM_ yyrule yystart)
+{
+  int yyok;
+  if (!yyctx->buflen)
+    {
+      yyctx->buflen= 1024;
+      yyctx->buf= (char *)malloc(yyctx->buflen);
+      yyctx->textlen= 1024;
+      yyctx->text= (char *)malloc(yyctx->textlen);
+      yyctx->thunkslen= 32;
+      yyctx->thunks= (yythunk *)malloc(sizeof(yythunk) * yyctx->thunkslen);
+      yyctx->valslen= 32;
+      yyctx->vals= (YYSTYPE *)malloc(sizeof(YYSTYPE) * yyctx->valslen);
+      yyctx->begin= yyctx->end= yyctx->pos= yyctx->limit= yyctx->thunkpos= 0;
+    }
+  yyctx->begin= yyctx->end= yyctx->pos;
+  yyctx->thunkpos= 0;
+  yyctx->val= yyctx->vals;
+  yyok= yystart(yyctx);
+  if (yyok) yyDone(yyctx);
+  yyCommit(yyctx);
+  return yyok;
+}
+
+YY_PARSE(int) YYPARSE(YY_CTX_PARAM)
+{
+  return YYPARSEFROM(YY_CTX_ARG_ yy_grammar);
+}
+
+#endif
+ 
+
+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_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);  
+}

lib/extras/liquid_view.rb

@@ -5,32 +5,43 @@
 # 
 #   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(action_view)
-    @action_view = action_view
+  def initialize(view)
+    @view = view
   end
   
-
-  def render(template, local_assigns_for_rails_less_than_2_1_0 = nil)
-    @action_view.controller.headers["Content-Type"] ||= 'text/html; charset=utf-8'
-    assigns = @action_view.assigns.dup
+  def render(template, local_assigns = nil)
+    @view.controller.headers["Content-Type"] ||= 'text/html; charset=utf-8'
     
-    # template is a Template object in Rails >=2.1.0, a source string previously.
-    if template.respond_to? :source
-      source = template.source
-      local_assigns = template.locals
+    # 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
-      source = template
-      local_assigns = local_assigns_for_rails_less_than_2_1_0
+      assigns = @view.assigns.reject{ |k,v| PROTECTED_ASSIGNS.include?(k) }
     end
-
-    if content_for_layout = @action_view.instance_variable_get("@content_for_layout")
+    
+    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)
+    assigns.merge!(local_assigns.stringify_keys)
     
     liquid = Liquid::Template.parse(source)
-    liquid.render(assigns, :filters => [@action_view.controller.master_helper_module], :registers => {:action_view => @action_view, :controller => @action_view.controller})
+    liquid.render(assigns, :filters => [@view.controller.master_helper_module], :registers => {:action_view => @view, :controller => @view.controller})
   end
 
   def compilable?

lib/liquid.rb

@@ -19,8 +19,6 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-
 module Liquid
   FilterSeparator             = /\|/
   ArgumentSeparator           = ','
@@ -29,27 +27,28 @@ module Liquid
   TagStart                    = /\{\%/
   TagEnd                      = /\%\}/
   VariableSignature           = /\(?[\w\-\.\[\]]\)?/
-  VariableSegment             = /[\w\-]\??/
+  VariableSegment             = /[\w\-]/
   VariableStart               = /\{\{/
   VariableEnd                 = /\}\}/
   VariableIncompleteEnd       = /\}\}?/
-  QuotedString                = /"[^"]+"|'[^']+'/
-  QuotedFragment              = /#{QuotedString}|(?:[^\s,\|'"]|#{QuotedString})+/
-  StrictQuotedFragment        = /"[^"]+"|'[^']+'|[^\s,\|,\:,\,]+/
-  FirstFilterArgument         = /#{FilterArgumentSeparator}(?:#{StrictQuotedFragment})/
-  OtherFilterArgument         = /#{ArgumentSeparator}(?:#{StrictQuotedFragment})/
-  SpacelessFilter             = /#{FilterSeparator}(?:#{StrictQuotedFragment})(?:#{FirstFilterArgument}(?:#{OtherFilterArgument})*)?/
-  Expression                  = /(?:#{QuotedFragment}(?:#{SpacelessFilter})*)/
-  TagAttributes               = /(\w+)\s*\:\s*(#{QuotedFragment})/
+  QuotedString                = /"[^"]*"|'[^']*'/
+  QuotedFragment              = /#{QuotedString}|(?:[^\s,\|'"]|#{QuotedString})+/o
+  StrictQuotedFragment        = /"[^"]+"|'[^']+'|[^\s|:,]+/
+  FirstFilterArgument         = /#{FilterArgumentSeparator}(?:#{StrictQuotedFragment})/o
+  OtherFilterArgument         = /#{ArgumentSeparator}(?:#{StrictQuotedFragment})/o
+  SpacelessFilter             = /^(?:'[^']+'|"[^"]+"|[^'"])*#{FilterSeparator}(?:#{StrictQuotedFragment})(?:#{FirstFilterArgument}(?:#{OtherFilterArgument})*)?/o
+  Expression                  = /(?:#{QuotedFragment}(?:#{SpacelessFilter})*)/o
+  TagAttributes               = /(\w+)\s*\:\s*(#{QuotedFragment})/o
   AnyStartingTag              = /\{\{|\{\%/
-  PartialTemplateParser       = /#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableIncompleteEnd}/
-  TemplateParser              = /(#{PartialTemplateParser}|#{AnyStartingTag})/
-  VariableParser              = /\[[^\]]+\]|#{VariableSegment}+/
+  PartialTemplateParser       = /#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableIncompleteEnd}/o
+  TemplateParser              = /(#{PartialTemplateParser}|#{AnyStartingTag})/o
+  VariableParser              = /\[[^\]]+\]|#{VariableSegment}+\??/o
 end
 
 require 'liquid/drop'
 require 'liquid/extensions'
 require 'liquid/errors'
+require 'liquid/interrupts'
 require 'liquid/strainer'
 require 'liquid/context'
 require 'liquid/tag'
@@ -62,6 +61,8 @@ require 'liquid/htmltags'
 require 'liquid/standardfilters'
 require 'liquid/condition'
 require 'liquid/module_ex'
+require 'liquid/utils'
+require 'liquid_ext'
 
 # Load all the tags of the standard library
 #

lib/liquid/block.rb

@@ -1,19 +1,23 @@
 module Liquid
-  
+
   class Block < Tag
+    IsTag             = /^#{TagStart}/o
+    IsVariable        = /^#{VariableStart}/o
+    FullToken         = /^#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}$/o
+    ContentOfVariable = /^#{VariableStart}(.*)#{VariableEnd}$/o
 
     def parse(tokens)
       @nodelist ||= []
       @nodelist.clear
 
-      while token = tokens.shift 
+      while token = tokens.shift
 
         case token
-        when /^#{TagStart}/                   
-          if token =~ /^#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}$/
+        when IsTag
+          if token =~ FullToken
 
             # if we found the proper block delimitor just end parsing here and let the outer block
-            # proceed                               
+            # proceed
             if block_delimiter == $1
               end_tag
               return
@@ -23,33 +27,33 @@ module Liquid
             if tag = Template.tags[$1]
               @nodelist << tag.new($1, $2, tokens)
             else
-              # this tag is not registered with the system 
+              # 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              
+            end
           else
             raise SyntaxError, "Tag '#{token}' was not properly terminated with regexp: #{TagEnd.inspect} "
           end
-        when /^#{VariableStart}/
+        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 
+      end
+
+      # Make sure that its ok to end parsing in the current block.
+      # Effectively this method will throw and exception unless the current block is
+      # of type Document
       assert_missing_delimitation!
-    end                     
-    
-    def end_tag      
+    end
+
+    def end_tag
     end
 
     def unknown_tag(tag, params, tokens)
-      case tag 
+      case tag
       when 'else'
         raise SyntaxError, "#{block_name} tag does not expect else tag"
       when 'end'
@@ -61,14 +65,14 @@ module Liquid
 
     def block_delimiter
       "end#{block_name}"
-    end                           
+    end
 
     def block_name
       @tag_name
     end
 
     def create_variable(token)
-      token.scan(/^#{VariableStart}(.*)#{VariableEnd}$/) do |content|
+      token.scan(ContentOfVariable) do |content|
         return Variable.new(content.first)
       end
       raise SyntaxError.new("Variable '#{token}' was not properly terminated with regexp: #{VariableEnd.inspect} ")
@@ -77,7 +81,7 @@ module Liquid
     def render(context)
       render_all(@nodelist, context)
     end
-    
+
     protected
 
     def assert_missing_delimitation!
@@ -85,13 +89,27 @@ module Liquid
     end
 
     def render_all(list, context)
-      list.collect do |token|
-        begin        
-          token.respond_to?(:render) ? token.render(context) : token
-        rescue Exception => e          
-          context.handle_error(e)
-        end          
-      end      
+      output = []
+      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
+      end
+
+      output
     end
-  end  
-end
+  end
+end

lib/liquid/condition.rb

@@ -3,7 +3,7 @@ module Liquid
   #
   # Example:
   #
-  #   c = Condition.new('1', '==', '1') 
+  #   c = Condition.new('1', '==', '1')
   #   c.evaluate #=> true
   #
   class Condition #:nodoc:
@@ -15,35 +15,35 @@ module Liquid
       '>'  => :>,
       '>=' => :>=,
       '<=' => :<=,
-      'contains' => lambda { |cond, left, right| left.include?(right) },
+      'contains' => lambda { |cond, left, right| left && right ? left.include?(right) : false }
     }
-    
+
     def self.operators
       @@operators
     end
 
     attr_reader :attachment
     attr_accessor :left, :operator, :right
-  
+
     def initialize(left = nil, operator = nil, right = nil)
       @left, @operator, @right = left, operator, right
       @child_relation  = nil
       @child_condition = nil
     end
-    
+
     def evaluate(context = Context.new)
-      result = interpret_condition(left, right, operator, context)        
-      
+      result = interpret_condition(left, right, operator, context)
+
       case @child_relation
-      when :or 
+      when :or
         result || @child_condition.evaluate(context)
-      when :and 
+      when :and
         result && @child_condition.evaluate(context)
       else
         result
-      end      
-    end                    
-    
+      end
+    end
+
     def or(condition)
       @child_relation, @child_condition = :or, condition
     end
@@ -51,25 +51,25 @@ module Liquid
     def and(condition)
       @child_relation, @child_condition = :and, condition
     end
-  
+
     def attach(attachment)
       @attachment = attachment
     end
-  
+
     def else?
       false
-    end                          
-    
+    end
+
     def inspect
       "#<Condition #{[@left, @operator, @right].compact.join(' ')}>"
     end
-    
+
     private
-  
+
     def equal_variables(left, right)
       if left.is_a?(Symbol)
         if right.respond_to?(left)
-          return right.send(left.to_s) 
+          return right.send(left.to_s)
         else
           return nil
         end
@@ -77,47 +77,44 @@ module Liquid
 
       if right.is_a?(Symbol)
         if left.respond_to?(right)
-          return left.send(right.to_s) 
+          return left.send(right.to_s)
         else
           return nil
         end
       end
 
-      left == right      
-    end    
+      left == right
+    end
 
     def interpret_condition(left, right, op, context)
-
-      # 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 
+      # If the operator is empty this means that the decision statement is just
+      # a single variable. We can just poll this variable from the context and
       # return this as the result.
-      return context[left] if op == nil      
+      return context[left] if op == nil
 
       left, right = context[left], context[right]
-            
 
       operation = self.class.operators[op] || raise(ArgumentError.new("Unknown operator #{op}"))
 
       if operation.respond_to?(:call)
         operation.call(self, left, right)
-      elsif left.respond_to?(operation) and right.respond_to?(operation)        
+      elsif left.respond_to?(operation) and right.respond_to?(operation)
         left.send(operation, right)
       else
         nil
       end
-    end    
-  end           
+    end
+  end
 
 
   class ElseCondition < Condition
-      
-    def else? 
+    def else?
       true
     end
-  
+
     def evaluate(context)
       true
     end
   end
 
-end
+end

lib/liquid/context.rb

@@ -1,5 +1,6 @@
 module Liquid
 
+  
   # Context keeps the variable stack and resolves variables, as well as keywords
   #
   #   context['variable'] = 'testing'
@@ -13,22 +14,26 @@ module Liquid
   #
   #   context['bob']  #=> nil  class Context
   class Context
-    attr_reader :scopes
-    attr_reader :errors, :registers
+    attr_reader :scopes, :errors, :registers, :environments
 
-    def initialize(assigns = {}, registers = {}, rethrow_errors = false)
-      @scopes     = [(assigns || {})]
-      @registers  = registers
-      @errors     = []
+    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false)
+      @environments   = [environments].flatten
+      @scopes         = [(outer_scope || {})]
+      @registers      = registers
+      @errors         = []
       @rethrow_errors = rethrow_errors
+      squash_instance_assigns_with_environments
+
+      @interrupts = []
     end
 
     def strainer
       @strainer ||= Strainer.create(self)
     end
 
-    # adds filters to this context.
-    # this does not register the filters with the main Template object. see <tt>Template.register_filter</tt>
+    # Adds filters to this context.
+    #
+    # Note that this does not register the filters with the main Template object. see <tt>Template.register_filter</tt>
     # for that
     def add_filters(filters)
       filters = [filters].flatten.compact
@@ -39,6 +44,21 @@ module Liquid
       end
     end
 
+    # are there any not handled interrupts?
+    def has_interrupt?
+      !@interrupts.empty?
+    end
+
+    # push an interrupt to the stack. this interrupt is considered not handled.
+    def push_interrupt(e)
+      @interrupts.push(e)
+    end
+
+    # pop an interrupt from the stack
+    def pop_interrupt
+      @interrupts.pop
+    end
+
     def handle_error(e)
       errors.push(e)
       raise if @rethrow_errors
@@ -51,7 +71,6 @@ module Liquid
       end
     end
 
-
     def invoke(method, *args)
       if strainer.respond_to?(method)
         strainer.__send__(method, *args)
@@ -60,173 +79,184 @@ module Liquid
       end
     end
 
-    # push new local scope on the stack. use <tt>Context#stack</tt> instead
-    def push
+    # Push new local scope on the stack. use <tt>Context#stack</tt> instead
+    def push(new_scope={})
+      @scopes.unshift(new_scope)
       raise StackLevelError, "Nesting too deep" if @scopes.length > 100
-      @scopes.unshift({})
     end
 
-    # merge a hash of variables in the current local scope
+    # Merge a hash of variables in the current local scope
     def merge(new_scopes)
       @scopes[0].merge!(new_scopes)
     end
 
-    # pop from the stack. use <tt>Context#stack</tt> instead
+    # Pop from the stack. use <tt>Context#stack</tt> instead
     def pop
       raise ContextError if @scopes.size == 1
       @scopes.shift
     end
 
-    # pushes a new local scope on the stack, pops it at the end of the block
+    # Pushes a new local scope on the stack, pops it at the end of the block
     #
     # Example:
-    #
     #   context.stack do
     #      context['var'] = 'hi'
     #   end
-    #   context['var]  #=> nil
     #
-    def stack(&block)
-      result = nil
-      push
-      begin
-        result = yield
-      ensure
-        pop
-      end
-      result
+    #   context['var]  #=> nil
+    def stack(new_scope={})
+      push(new_scope)
+      yield
+    ensure
+      pop
     end
 
+    def clear_instance_assigns
+      @scopes[0] = {}
+    end
+
+
+    # Look up variable, either resolve directly after considering the name. We can directly handle
+    # Strings, digits, floats and booleans (true,false).
+    # If no match is made we lookup the variable in the current scope and
+    # later move up to the parent blocks to see if we can resolve the variable somewhere up the tree.
+    # Some special keywords return symbols. Those symbols are to be called on the rhs object in expressions
+    #
+    # Example:
+    #   products == empty #=> products.empty?
+    def resolve(key)        
+      case key
+      when nil, ""
+        return nil
+      when "blank"
+        return :blank?
+      when "empty"
+        return :empty?
+      end
+      
+      result = Parser.parse(key)   
+      stack = []
+
+      result.each do |(sym, value)|          
+
+        case sym
+        when :id
+          stack.push value
+        when :lookup
+          left = stack.pop
+          value = find_variable(left)
+          
+          stack.push(harden(value))
+        when :range
+          right = stack.pop.to_i
+          left  = stack.pop.to_i
+          
+          stack.push (left..right)
+        when :buildin
+          left = stack.pop
+          value = invoke_buildin(left, value)
+          
+          stack.push(harden(value))
+        when :call
+          left = stack.pop
+          right = stack.pop
+          value = lookup_and_evaluate(right, left)
+
+          stack.push(harden(value))
+        else 
+          raise "unknown #{sym}"
+        end
+      end
+
+      return stack.first
+    end
+
+
     # Only allow String, Numeric, Hash, Array, Proc, Boolean or <tt>Liquid::Drop</tt>
     def []=(key, value)
       @scopes[0][key] = value
     end
 
-    def [](key)
-      resolve(key)
-    end
-
     def has_key?(key)
       resolve(key) != nil
     end
 
+    alias_method :[], :resolve
+
     private
 
-    # Look up variable, either resolve directly after considering the name. We can directly handle
-    # Strings, digits, floats and booleans (true,false). If no match is made we lookup the variable in the current scope and
-    # later move up to the parent blocks to see if we can resolve the variable somewhere up the tree.
-    # Some special keywords return symbols. Those symbols are to be called on the rhs object in expressions
-    #
-    # Example:
-    #
-    #   products == empty #=> products.empty?
-    #
-    def resolve(key)
-      case key
-      when nil, 'nil', 'null', ''
-        nil
-      when 'true'
-        true
-      when 'false'
-        false
-      when 'blank'
-        :blank?
-      when 'empty'
-        :empty?
-      # filtered variables
-      when SpacelessFilter
-        filtered_variable(key)
-      # Single quoted strings
-      when /^'(.*)'$/
-        $1.to_s
-      # Double quoted strings
-      when /^"(.*)"$/
-        $1.to_s
-      # Integer and floats
-      when /^(\d+)$/
-        $1.to_i
-      # Ranges
-      when /^\((\S+)\.\.(\S+)\)$/
-        (resolve($1).to_i..resolve($2).to_i)
-      # Floats
-      when /^(\d[\d\.]+)$/
-        $1.to_f
-      else
-        variable(key)
-      end
-    end
+      def invoke_buildin(obj, key)
+        # as weird as this is, liquid unit tests demand that we prioritize hash lookups 
+        # to buildins. So if we got a hash and it has a :first element we need to call that 
+        # instead of sending the first message...
 
-    # fetches an object starting at the local scope and then moving up
-    # the hierachy
-    def find_variable(key)
-      @scopes.each do |scope|
-        if scope.has_key?(key)
-          variable = scope[key]
-          variable = scope[key] = variable.call(self) if variable.is_a?(Proc)
-          variable = variable.to_liquid
-          variable.context = self if variable.respond_to?(:context=)
-          return variable
+        if obj.respond_to?(:has_key?) && obj.has_key?(key)
+          return lookup_and_evaluate(obj, key)
+        end
+
+        if obj.respond_to?(key) 
+          return obj.send(key)
+        else
+          return nil    
         end
       end
-      nil
-    end
 
-    # resolves namespaced queries gracefully.
-    #
-    # Example
-    #
-    #  @context['hash'] = {"name" => 'tobi'}
-    #  assert_equal 'tobi', @context['hash.name']
-    #  assert_equal 'tobi', @context['hash["name"]']
-    #
-    def variable(markup)
-      parts = markup.scan(VariableParser)
-      square_bracketed = /^\[(.*)\]$/
+      # 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) }
 
-      first_part = parts.shift
-      if first_part =~ square_bracketed
-        first_part = resolve($1)
-      end
-
-      if object = find_variable(first_part)
-
-        parts.each do |part|
-          part = resolve($1) if part_resolved = (part =~ square_bracketed)
-
-          # If object is a hash- or array-like object we look for the
-          # presence of the key and if its available we return it
-          if object.respond_to?(:[]) and
-            ((object.respond_to?(:has_key?) and object.has_key?(part)) or
-             (object.respond_to?(:fetch) and part.is_a?(Integer)))
-
-            # if its a proc we will replace the entry with the proc
-            res = object[part]
-            res = object[part] = res.call(self) if res.is_a?(Proc) and object.respond_to?(:[]=)
-            object = res.to_liquid
-
-          # Some special cases. If the part wasn't in square brackets and
-          # no key with the same name was found we interpret following calls
-          # as commands and call them on the current object
-          elsif !part_resolved and object.respond_to?(part) and ['size', 'first', 'last'].include?(part)
-
-            object = object.send(part.intern).to_liquid
-
-          # No key was present with the desired value and it wasn't one of the directly supported
-          # keywords either. The only thing we got left is to return nil
-          else
-            return nil
+        if scope.nil?
+          @environments.each do |e|
+            if variable = lookup_and_evaluate(e, key)
+              scope = e
+              break
+            end
           end
-
-          # If we are dealing with a drop here we have to
-          object.context = self if object.respond_to?(:context=)
         end
+
+        scope     ||= @environments.last || @scopes.last
+        variable  ||= lookup_and_evaluate(scope, key)
+
+        return variable
       end
 
-      object
-    end
-    
-    def filtered_variable(markup)
-      Variable.new(markup).render(self)
-    end
-  end
-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,17 +1,17 @@
 module Liquid
-  class Document < Block                                                             
+  class Document < Block
     # we don't need markup to open this block
     def initialize(tokens)
       parse(tokens)
-    end                                                                        
-  
-    # There isn't a real delimter   
+    end
+
+    # There isn't a real delimter
     def block_delimiter
       []
     end
-  
+
     # Document blocks don't need to be terminated since they are not actually opened
     def assert_missing_delimitation!
-    end    
+    end
   end
-end
+end

lib/liquid/drop.rb

@@ -1,50 +1,51 @@
 module Liquid
-  
-  # A drop in liquid is a class which allows you to to export DOM like things to liquid
-  # Methods of drops are callable. 
-  # The main use for liquid drops is the implement lazy loaded objects. 
-  # If you would like to make data available to the web designers which you don't want loaded unless needed then 
-  # a drop is a great way to do that
+
+  # 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.
+  # If you would like to make data available to the web designers which you don't want loaded unless needed then
+  # a drop is a great way to do that.
   #
   # Example:
   #
-  # class ProductDrop < Liquid::Drop
-  #   def top_sales
-  #      Shop.current.products.find(:all, :order => 'sales', :limit => 10 )
+  #   class ProductDrop < Liquid::Drop
+  #     def top_sales
+  #       Shop.current.products.find(:all, :order => 'sales', :limit => 10 )
+  #     end
   #   end
-  # end
-  #  
-  # tmpl = Liquid::Template.parse( ' {% for product in product.top_sales %} {{ product.name }} {%endfor%} '  )
-  # tmpl.render('product' => ProductDrop.new ) # will invoke top_sales query. 
   #
-  # Your drop can either implement the methods sans any parameters or implement the before_method(name) method which is a 
-  # catch all
+  #   tmpl = Liquid::Template.parse( ' {% for product in product.top_sales %} {{ product.name }} {%endfor%} '  )
+  #   tmpl.render('product' => ProductDrop.new ) # will invoke top_sales query.
+  #
+  # Your drop can either implement the methods sans any parameters or implement the before_method(name) method which is a
+  # catch all.
   class Drop
     attr_writer :context
 
-    # Catch all for the method 
+    EMPTY_STRING = ''.freeze
+
+    # Catch all for the method
     def before_method(method)
       nil
     end
-    
+
     # called by liquid to invoke a drop
-    def invoke_drop(method)          
-      if self.class.public_instance_methods.include?(method.to_s)
-        send(method.to_sym) 
-      else        
-        before_method(method)
+    def invoke_drop(method_or_key)
+      if method_or_key && method_or_key != EMPTY_STRING && self.class.public_method_defined?(method_or_key.to_s.to_sym)
+        send(method_or_key.to_s.to_sym)
+      else
+        before_method(method_or_key)
       end
     end
-    
+
     def has_key?(name)
       true
     end
-    
+
     def to_liquid
       self
     end
 
     alias :[] :invoke_drop
   end
-  
 end

lib/liquid/errors.rb

@@ -8,4 +8,4 @@ module Liquid
   class StandardError < Error; end
   class SyntaxError < Error; end
   class StackLevelError < Error; end
-end
+end

lib/liquid/extensions.rb

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

lib/liquid/file_system.rb

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

lib/liquid/htmltags.rb

@@ -1,11 +1,13 @@
 module Liquid
-  class TableRow < Block                                             
-    Syntax = /(\w+)\s+in\s+(#{VariableSignature}+)/   
-    
+  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
@@ -13,62 +15,105 @@ module Liquid
       else
         raise SyntaxError.new("Syntax Error in 'table_row loop' - Valid syntax: table_row [item] in [collection] cols=3")
       end
-      
-      super      
+
+      super
     end
-    
-    def render(context)        
+
+    def render(context)
+      context.registers[:tablerowloop] ||= Hash.new(0)
+
       collection = context[@collection_name] or return ''
-      
-      if @attributes['limit'] or @attributes['offset']
-        limit = context[@attributes['limit']] || -1
-        offset = context[@attributes['offset']] || 0
-        collection = collection[offset.to_i..(limit.to_i + offset.to_i - 1)]
-      end
-            
+
+      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.stack do
 
+        context.registers[:tablerowloop][@idx]
+        context['tablerowloop'] = lambda { Tablerowloop.new(@idx_i, @idx_col, length) }
         collection.each_with_index do |item, index|
-          context[@variable_name] = item
-          context['tablerowloop'] = {
-            'length'  => length,
-            'index'   => index + 1, 
-            'index0'  => index, 
-            'col'     => col + 1, 
-            'col0'    => col, 
-            'index0'  => index, 
-            'rindex'  => length - index,
-            'rindex0' => length - index -1,
-            'first'   => (index == 0),
-            'last'    => (index == length - 1),
-            'col_first' => (col == 0),
-            'col_last'  => (col == cols - 1)
-          }  
-          
-            
-          col += 1
-                                
-          result << ["<td class=\"col#{col}\">"] + render_all(@nodelist, context) + ['</td>']
+          context.registers[:tablerowloop][@idx_i] = index
+          context.registers[:tablerowloop][@idx_col] = col
+          context[@variable_name] = item          
 
-          if col == cols and not (index == length - 1)                        
+          col += 1
+
+          result << "<td class=\"col#{col}\">" << render_all(@nodelist, context) << '</td>'
+
+          if col == cols and not (index == length - 1)
             col  = 0
             row += 1
-            result << ["</tr>\n<tr class=\"row#{row}\">"] 
+            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
-      result + ["</tr>\n"]
-    end    
   end
-  
-  Template.register_tag('tablerow', TableRow)  
-end
+
+  Template.register_tag('tablerow', TableRow)
+end

lib/liquid/interrupts.rb

@@ -0,0 +1,17 @@
+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)
+      @message = message || "interrupt"
+    end
+  end
+
+  # Interrupt that is thrown whenever a {% break %} is called.
+  class BreakInterrupt < Interrupt; end
+
+  # Interrupt that is thrown whenever a {% continue %} is called.
+  class ContinueInterrupt < Interrupt; end
+end

lib/liquid/module_ex.rb

@@ -18,7 +18,7 @@
 #   end
 # end
 #
-# if you want to extend the drop to other methods you can defines more methods 
+# if you want to extend the drop to other methods you can defines more methods
 # in the class <YourClass>::LiquidDropClass
 #
 #   class SomeClass::LiquidDropClass
@@ -37,11 +37,11 @@
 # 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 
+# 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
@@ -58,5 +58,5 @@ class Module
       end
     end
   end
-  
+
 end

lib/liquid/standardfilters.rb

@@ -1,36 +1,42 @@
 require 'cgi'
 
 module Liquid
-  
+
   module StandardFilters
-    
+
     # Return the size of an array or of an string
     def size(input)
-      
+
       input.respond_to?(:size) ? input.size : 0
-    end         
-    
+    end
+
     # convert a input string to DOWNCASE
     def downcase(input)
       input.to_s.downcase
-    end         
+    end
 
     # convert a input string to UPCASE
     def upcase(input)
       input.to_s.upcase
     end
-    
+
     # capitalize words in the input centence
     def capitalize(input)
       input.to_s.capitalize
     end
-        
+
     def escape(input)
       CGI.escapeHTML(input) rescue input
     end
-    
+
+    def escape_once(input)
+      ActionView::Helpers::TagHelper.escape_once(input)
+    rescue NameError
+      input
+    end
+
     alias_method :h, :escape
-    
+
     # Truncate a string down to x characters
     def truncate(input, length = 50, truncate_string = "...")
       if input.nil? then return end
@@ -44,19 +50,28 @@ module Liquid
       wordlist = input.to_s.split
       l = words.to_i - 1
       l = 0 if l < 0
-      wordlist.length > l ? wordlist[0..l].join(" ") + truncate_string : input 
+      wordlist.length > l ? wordlist[0..l].join(" ") + truncate_string : input
     end
-    
+
+    # Split input string into an array of substrings separated by given pattern.
+    #
+    # Example:
+    #   <div class="summary">{{ post | split '//' | first }}</div>
+    #
+    def split(input, pattern)
+      input.split(pattern)
+    end
+
     def strip_html(input)
-      input.to_s.gsub(/<.*?>/, '')
-    end       
-    
-    # Remove all newlines from the string
-    def strip_newlines(input)        
-      input.to_s.gsub(/\n/, '')      
+      input.to_s.gsub(/<script.*?<\/script>/, '').gsub(/<!--.*?-->/, '').gsub(/<.*?>/, '')
     end
-    
-    
+
+    # Remove all newlines from the string
+    def strip_newlines(input)
+      input.to_s.gsub(/\n/, '')
+    end
+
+
     # Join elements of the array with certain character between them
     def join(input, glue = ' ')
       [input].flatten.join(glue)
@@ -73,8 +88,8 @@ module Liquid
       elsif ary.first.respond_to?(property)
         ary.sort {|a,b| a.send(property) <=> b.send(property) }
       end
-    end               
-    
+    end
+
     # map/collect on a given property
     def map(input, property)
       ary = [input].flatten
@@ -84,42 +99,42 @@ module Liquid
         ary.map {|e| e.send(property) }
       end
     end
-            
+
     # Replace occurrences of a string with another
     def replace(input, string, replacement = '')
       input.to_s.gsub(string, replacement)
     end
-                                                 
+
     # Replace the first occurrences of a string with another
     def replace_first(input, string, replacement = '')
       input.to_s.sub(string, replacement)
-    end              
-                                                           
+    end
+
     # remove a substring
     def remove(input, string)
-      input.to_s.gsub(string, '')      
+      input.to_s.gsub(string, '')
     end
-                        
+
     # remove the first occurrences of a substring
     def remove_first(input, string)
-      input.to_s.sub(string, '')      
-    end             
-                              
+      input.to_s.sub(string, '')
+    end
+
     # add one string to another
     def append(input, string)
       input.to_s + string.to_s
     end
-                                
+
     # prepend a string to another
     def prepend(input, string)
       string.to_s + input.to_s
     end
-                                             
+
     # Add <br /> tags in front of all newlines in input string
-    def newline_to_br(input)        
-      input.to_s.gsub(/\n/, "<br />\n")      
+    def newline_to_br(input)
+      input.to_s.gsub(/\n/, "<br />\n")
     end
-    
+
     # Reformat a date
     #
     #   %a - The abbreviated weekday name (``Sun'')
@@ -149,61 +164,82 @@ module Liquid
     #   %Z - Time zone name
     #   %% - Literal ``%'' character
     def date(input, format)
-      
+
       if format.to_s.empty?
         return input.to_s
       end
-      
+
+      if ((input.is_a?(String) && !/^\d+$/.match(input.to_s).nil?) || input.is_a?(Integer)) && input.to_i > 0
+        input = Time.at(input.to_i)
+      end
+
       date = input.is_a?(String) ? Time.parse(input) : input
-      
+
       if date.respond_to?(:strftime)
         date.strftime(format.to_s)
       else
         input
       end
-    rescue => e 
+    rescue => e
       input
     end
-    
-    # Get the first element of the passed in array 
-    # 
+
+    # Get the first element of the passed in array
+    #
     # Example:
     #    {{ product.images | first | to_img }}
-    #  
+    #
     def first(array)
       array.first if array.respond_to?(:first)
     end
 
-    # Get the last element of the passed in array 
-    # 
+    # Get the last element of the passed in array
+    #
     # Example:
     #    {{ product.images | last | to_img }}
-    #  
+    #
     def last(array)
       array.last if array.respond_to?(:last)
     end
-    
+
     # addition
     def plus(input, operand)
-      input + operand if input.respond_to?('+')
+      to_number(input) + to_number(operand)
     end
-    
+
     # subtraction
     def minus(input, operand)
-      input - operand if input.respond_to?('-')
+      to_number(input) - to_number(operand)
     end
-    
+
     # multiplication
     def times(input, operand)
-      input * operand if input.respond_to?('*')
+      to_number(input) * to_number(operand)
     end
-    
+
     # division
     def divided_by(input, operand)
-      input / operand if input.respond_to?('/')
+      to_number(input) / to_number(operand)
     end
-    
+
+    def modulo(input, operand)
+      to_number(input) % to_number(operand)
+    end
+
+    private
+
+      def to_number(obj)
+        case obj
+        when Numeric
+          obj
+        when String
+          (obj.strip =~ /^\d+\.\d+$/) ? obj.to_f : obj.to_i
+        else
+          0
+        end
+      end
+
   end
-   
+
   Template.register_filter(StandardFilters)
 end

lib/liquid/strainer.rb

@@ -1,52 +1,54 @@
 require 'set'
 
 module Liquid
-  
-  
+
   parent_object = if defined? BlankObject
     BlankObject
   else
     Object
   end
 
-  # Strainer is the parent class for the filters system. 
-  # New filters are mixed into the strainer class which is then instanciated for each liquid template render run. 
+  # Strainer is the parent class for the filters system.
+  # New filters are mixed into the strainer class which is then instanciated for each liquid template render run.
   #
-  # One of the strainer's responsibilities is to keep malicious method calls out 
+  # One of the strainer's responsibilities is to keep malicious method calls out
   class Strainer < parent_object #:nodoc:
-    INTERNAL_METHOD = /^__/ 
-    @@required_methods = Set.new([:__send__, :__id__, :respond_to?, :extend, :methods, :class])
-    
+    INTERNAL_METHOD = /^__/
+    @@required_methods = Set.new([:__id__, :__send__, :respond_to?, :kind_of?, :extend, :methods, :singleton_methods, :class, :object_id])
+
+    # Ruby 1.9.2 introduces Object#respond_to_missing?, which is invoked by Object#respond_to?
+    @@required_methods << :respond_to_missing? if Object.respond_to? :respond_to_missing?
+
     @@filters = {}
-    
+
     def initialize(context)
       @context = context
     end
-              
+
     def self.global_filter(filter)
       raise ArgumentError, "Passed filter is not a module" unless filter.is_a?(Module)
       @@filters[filter.name] = filter
     end
-    
+
     def self.create(context)
       strainer = Strainer.new(context)
       @@filters.each { |k,m| strainer.extend(m) }
       strainer
     end
-    
+
     def respond_to?(method, include_private = false)
       method_name = method.to_s
       return false if method_name =~ INTERNAL_METHOD
       return false if @@required_methods.include?(method_name)
       super
     end
-    
-    # remove all standard methods from the bucket so circumvent security 
-    # problems 
-    instance_methods.each do |m| 
-      unless @@required_methods.include?(m.to_sym) 
+
+    # remove all standard methods from the bucket so circumvent security
+    # problems
+    instance_methods.each do |m|
+      unless @@required_methods.include?(m.to_sym)
         undef_method m
       end
-    end    
+    end
   end
 end

lib/liquid/tag.rb

@@ -1,26 +1,26 @@
 module Liquid
-  
+
   class Tag
+
     attr_accessor :nodelist
-    
+
     def initialize(tag_name, markup, tokens)
       @tag_name   = tag_name
       @markup     = markup
       parse(tokens)
     end
-    
+
     def parse(tokens)
     end
-    
+
     def name
       self.class.name.downcase
     end
-        
+
     def render(context)
       ''
-    end    
-  end
-   
+    end
 
-end
-   
+  end # Tag
+
+end # Tag

lib/liquid/tags/assign.rb

@@ -6,15 +6,15 @@ module Liquid
   #
   # You can then use the variable later in the page.
   #
-  #  {{ monkey }}
+  #  {{ foo }}
   #
   class Assign < Tag
-    Syntax = /(#{VariableSignature}+)\s*=\s*(#{Expression}+)/   
+    Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/o
   
     def initialize(tag_name, markup, tokens)          
       if markup =~ Syntax
         @to = $1
-        @from = $2
+        @from = Variable.new($2)
       else
         raise SyntaxError.new("Syntax Error in 'assign' - Valid syntax: assign [var] = [source]")
       end
@@ -23,11 +23,11 @@ module Liquid
     end
   
     def render(context)
-       context.scopes.last[@to.to_s] = context[@from]
+       context.scopes.last[@to] = @from.render(context)
        ''
     end 
   
   end  
   
   Template.register_tag('assign', Assign)  
-end
+end

lib/liquid/tags/break.rb

@@ -0,0 +1,21 @@
+module Liquid
+
+  # Break tag to be used to break out of a for loop.
+  #
+  # == Basic Usage:
+  #    {% for item in collection %}
+  #      {% if item.condition %}
+  #        {% break %}
+  #      {% endif %}
+  #    {% endfor %}
+  # 
+  class Break < Tag 
+
+    def interrupt
+      BreakInterrupt.new
+    end
+
+  end
+
+  Template.register_tag('break', Break)
+end

lib/liquid/tags/capture.rb

@@ -1,35 +1,35 @@
 module Liquid
-  
+
   # Capture stores the result of a block into a variable without rendering it inplace.
   #
   #   {% capture heading %}
   #     Monkeys!
   #   {% endcapture %}
   #   ...
-  #   <h1>{{ monkeys }}</h1>
+  #   <h1>{{ heading }}</h1>
   #
-  # Capture is useful for saving content for use later in your template, such as 
+  # Capture is useful for saving content for use later in your template, such as
   # in a sidebar or footer.
   #
   class Capture < Block
     Syntax = /(\w+)/
 
-    def initialize(tag_name, markup, tokens)      
+    def initialize(tag_name, markup, tokens)
       if markup =~ Syntax
         @to = $1
       else
         raise SyntaxError.new("Syntax Error in 'capture' - Valid syntax: capture [var]")
       end
-      
-      super       
+
+      super
     end
 
     def render(context)
       output = super
-      context[@to] = output.to_s
+      context.scopes.last[@to] = output
       ''
     end
-  end  
-  
+  end
+
   Template.register_tag('capture', Capture)
-end
+end

lib/liquid/tags/case.rb

@@ -1,7 +1,7 @@
 module Liquid
   class Case < Block
-    Syntax     = /(#{Expression})/
-    WhenSyntax = /(#{Expression})(?:(?:\s+or\s+|\s*\,\s*)(#{Expression}.*))?/
+    Syntax     = /(#{QuotedFragment})/o
+    WhenSyntax = /(#{QuotedFragment})(?:(?:\s+or\s+|\s*\,\s*)(#{QuotedFragment}.*))?/o
 
     def initialize(tag_name, markup, tokens)      
       @blocks = []
@@ -31,20 +31,16 @@ module Liquid
       context.stack do          
         execute_else_block = true
         
-        @blocks.inject([]) do |output, block|
-      
+        output = []
+        @blocks.each do |block|
           if block.else? 
-            
             return render_all(block.attachment, context) if execute_else_block
-            
           elsif block.evaluate(context)
-            
             execute_else_block = false        
-            output += render_all(block.attachment, context)                    
+            output << render_all(block.attachment, context)
           end            
-      
-          output
         end
+        output
       end          
     end
     

lib/liquid/tags/comment.rb

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

lib/liquid/tags/continue.rb

@@ -0,0 +1,21 @@
+module Liquid
+
+  # Continue tag to be used to break out of a for loop.
+  #
+  # == Basic Usage:
+  #    {% for item in collection %}
+  #      {% if item.condition %}
+  #        {% continue %}
+  #      {% endif %}
+  #    {% endfor %}
+  # 
+  class Continue < Tag
+
+    def interrupt
+      ContinueInterrupt.new
+    end
+
+  end
+
+  Template.register_tag('continue', Continue)
+end

lib/liquid/tags/cycle.rb

@@ -13,8 +13,8 @@ module Liquid
   #    <div class="green"> Item five</div>
   #
   class Cycle < Tag
-    SimpleSyntax = /^#{Expression}/        
-    NamedSyntax  = /^(#{Expression})\s*\:\s*(.*)/
+    SimpleSyntax = /^#{QuotedFragment}+/o
+    NamedSyntax  = /^(#{QuotedFragment})\s*\:\s*(.*)/o
   
     def initialize(tag_name, markup, tokens)      
       case markup
@@ -48,7 +48,7 @@ module Liquid
   
     def variables_from_string(markup)
       markup.split(',').collect do |var|
-    	  var =~ /\s*(#{Expression})\s*/
+    	  var =~ /\s*(#{QuotedFragment})\s*/o
     	  $1 ? $1 : nil
     	end.compact
     end
@@ -56,4 +56,4 @@ module Liquid
   end
   
   Template.register_tag('cycle', Cycle)
-end
+end

lib/liquid/tags/decrement.rb

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

lib/liquid/tags/for.rb

@@ -13,6 +13,8 @@ module Liquid
   #      <div {% if forloop.first %}class="first"{% endif %}>
   #        Item {{ forloop.index }}: {{ item.name }}
   #      </div>
+  #    {% else %}
+  #      There is nothing in the collection.
   #    {% endfor %}
   #
   # You can also define a limit and offset much like SQL.  Remember
@@ -42,13 +44,14 @@ module Liquid
   # forloop.last:: Returns true if the item is the last item.
   #
   class For < Block                                             
-    Syntax = /(\w+)\s+in\s+(#{Expression}+)\s*(reversed)?/   
+    Syntax = /(\w+)\s+in\s+(#{QuotedFragment}+)\s*(reversed)?/o
   
     def initialize(tag_name, markup, tokens)
       if markup =~ Syntax
         @variable_name = $1
         @collection_name = $2
-        @name = "#{$1}-#{$2}"           
+        @name = "#{$1}-#{$2}"         
+        @idx = "#{@name}-i"
         @reversed = $3             
         @attributes = {}
         markup.scan(TagAttributes) do |key, value|
@@ -58,16 +61,23 @@ module Liquid
         raise SyntaxError.new("Syntax Error in 'for loop' - Valid syntax: for [item] in [collection]")
       end
 
+      @nodelist = @for_block = []
       super
     end
+
+    def unknown_tag(tag, markup, tokens)
+      return super unless tag == 'else'
+      @nodelist = @else_block = []
+    end
   
-    def render(context)        
+    def render(context)       
       context.registers[:for] ||= Hash.new(0)
     
       collection = context[@collection_name]
       collection = collection.to_a if collection.is_a?(Range)
     
-      return '' unless collection.respond_to?(:each) 
+      # 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
@@ -77,11 +87,10 @@ module Liquid
         
       limit = context[@attributes['limit']]
       to    = limit ? limit.to_i + from : nil  
-          
-                       
-      segment = slice_collection_using_each(collection, from, to)      
-      
-      return '' if segment.empty?
+
+      segment = Utils.slice_collection_using_each(collection, from, to)
+
+      return render_else(context) if segment.empty?
       
       segment.reverse! if @reversed
 
@@ -92,45 +101,68 @@ module Liquid
       # Store our progress through the collection for the continue flag
       context.registers[:for][@name] = from + segment.length
               
-      context.stack do 
-        segment.each_with_index do |item, index|     
+      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
-          context['forloop'] = {
-            'name'    => @name,
-            'length'  => length,
-            'index'   => index + 1, 
-            'index0'  => index, 
-            'rindex'  => length - index,
-            'rindex0' => length - index -1,
-            'first'   => (index == 0),
-            'last'    => (index == length - 1) }
 
-          result << render_all(@nodelist, context)
+          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
       end
       result     
     end          
-        
-    def slice_collection_using_each(collection, from, to)       
-      segments = []      
-      index = 0      
-      yielded = 0
-      collection.each do |item|         
-                
-        if to && to <= index
-          break
-        end
-        
-        if from <= index                               
-          segments << item
-        end                    
-                
-        index += 1
-      end    
 
-      segments
-    end
+    private
+
+      class Forloop < Liquid::Drop
+        attr_accessor :name, :length
+
+        def initialize(name, idx, length)
+          @name, @idx, @length = name, idx, length
+        end
+
+        def index
+          @context.registers[:for][@idx] + 1
+        end
+
+        def index0
+          @context.registers[:for][@idx]
+        end
+
+        def rindex
+          length - @context.registers[:for][@idx]
+        end
+
+        def rindex0
+          length - @context.registers[:for][@idx] - 1
+        end
+
+        def first
+          (@context.registers[:for][@idx] == 0)
+        end
+
+        def last
+          (@context.registers[:for][@idx] == length - 1)
+        end
+      end
+
+
+      def render_else(context)
+        return @else_block ? [render_all(@else_block, context)] : ''
+      end
+
+      def iterable?(collection)
+        collection.respond_to?(:each) || Utils.non_blank_string?(collection)
+      end
   end
 
   Template.register_tag('for', For)
-end
+end

lib/liquid/tags/if.rb

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

lib/liquid/tags/include.rb

@@ -1,6 +1,6 @@
 module Liquid
   class Include < Tag
-    Syntax = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?/
+    Syntax = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?/o
   
     def initialize(tag_name, markup, tokens)      
       if markup =~ Syntax
@@ -20,13 +20,12 @@ module Liquid
       super
     end
   
-    def parse(tokens)      
+    def parse(tokens)
     end
-  
-    def render(context)      
-      source  = Liquid::Template.file_system.read_template_file(context[@template_name])      
-      partial = Liquid::Template.parse(source)      
-      
+    
+    def render(context)
+      source = _read_template_from_file_system(context)
+      partial = Liquid::Template.parse(source)
       variable = context[@variable_name || @template_name[1..-2]]
       
       context.stack do
@@ -35,21 +34,32 @@ module Liquid
         end
 
         if variable.is_a?(Array)
-          
-          variable.collect do |variable|            
+          variable.collect do |variable|
             context[@template_name[1..-2]] = variable
             partial.render(context)
           end
-
         else
-                    
           context[@template_name[1..-2]] = variable
           partial.render(context)
-          
         end
       end
     end
+   
+    private
+      def _read_template_from_file_system(context)
+        file_system = context.registers[:file_system] || Liquid::Template.file_system
+      
+        # make read_template_file call backwards-compatible.
+        case file_system.method(:read_template_file).arity
+        when 1
+          file_system.read_template_file(context[@template_name])
+        when 2
+          file_system.read_template_file(context[@template_name], context)
+        else
+          raise ArgumentError, "file_system.read_template_file expects two parameters: (template_name, context)"
+        end
+      end
   end
 
   Template.register_tag('include', Include)  
-end
+end

lib/liquid/tags/increment.rb

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

lib/liquid/tags/raw.rb

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

lib/liquid/tags/unless.rb

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

lib/liquid/template.rb

@@ -1,146 +1,149 @@
 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. 
-  # your code should expect to get some SyntaxErrors. 
+  # 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.
+  # your code should expect to get some SyntaxErrors.
   #
-  # After you have a compiled template you can then <tt>render</tt> it. 
-  # You can use a compiled template over and over again and keep it cached. 
+  # After you have a compiled template you can then <tt>render</tt> it.
+  # You can use a compiled template over and over again and keep it cached.
+  #
+  # Example:
   #
-  # Example: 
-  #   
   #   template = Liquid::Template.parse(source)
   #   template.render('user_name' => 'bob')
   #
   class Template
     attr_accessor :root
     @@file_system = BlankFileSystem.new
-    
-    class <<self
+
+    class << self
       def file_system
         @@file_system
       end
-    
+
       def file_system=(obj)
         @@file_system = obj
       end
-          
-      def register_tag(name, klass)      
+
+      def register_tag(name, klass)
         tags[name.to_s] = klass
-      end                        
-    
+      end
+
       def tags
         @tags ||= {}
       end
-        
-      # Pass a module with filter methods which should be available 
+
+      # Pass a module with filter methods which should be available
       # to all liquid views. Good for registering the standard library
-      def register_filter(mod)      
+      def register_filter(mod)
         Strainer.global_filter(mod)
-      end                        
-            
+      end
+
       # creates a new <tt>Template</tt> object from liquid source code
       def parse(source)
         template = Template.new
         template.parse(source)
         template
-      end                           
+      end
     end
 
     # creates a new <tt>Template</tt> from an array of tokens. Use <tt>Template.parse</tt> instead
     def initialize
     end
-    
-    # Parse source code. 
-    # Returns self for easy chaining    
+
+    # Parse source code.
+    # Returns self for easy chaining
     def parse(source)
       @root = Document.new(tokenize(source))
       self
     end
-    
-    def registers 
+
+    def registers
       @registers ||= {}
     end
-    
+
     def assigns
       @assigns ||= {}
     end
-    
+
+    def instance_assigns
+      @instance_assigns ||= {}
+    end
+
     def errors
       @errors ||= []
     end
-        
+
     # Render takes a hash with local variables.
     #
-    # if you use the same filters over and over again consider registering them globally 
+    # if you use the same filters over and over again consider registering them globally
     # with <tt>Template.register_filter</tt>
-    # 
+    #
     # Following options can be passed:
-    #  
+    #
     #  * <tt>filters</tt> : array with local filters
-    #  * <tt>registers</tt> : hash with register variables. Those can be accessed from 
-    #    filters and tags and might be useful to integrate liquid more with its host application  
+    #  * <tt>registers</tt> : hash with register variables. Those can be accessed from
+    #    filters and tags and might be useful to integrate liquid more with its host application
     #
     def render(*args)
-      return '' if @root.nil?                          
-
+      return '' if @root.nil?
+      
       context = case args.first
       when Liquid::Context
         args.shift
       when Hash
-        self.assigns.merge!(args.shift)        
-        Context.new(assigns, registers, @rethrow_errors)
+        Context.new([args.shift, assigns], instance_assigns, registers, @rethrow_errors)
       when nil
-        Context.new(assigns, registers, @rethrow_errors)
+        Context.new(assigns, instance_assigns, registers, @rethrow_errors)
       else
         raise ArgumentError, "Expect Hash or Liquid::Context as parameter"
       end
-      
+
       case args.last
       when Hash
         options = args.pop
-        
+
         if options[:registers].is_a?(Hash)
-          self.registers.merge!(options[:registers])  
+          self.registers.merge!(options[:registers])
         end
 
         if options[:filters]
           context.add_filters(options[:filters])
-        end                         
-        
+        end
+
       when Module
-        context.add_filters(args.pop)    
+        context.add_filters(args.pop)
       when Array
-        context.add_filters(args.pop)            
+        context.add_filters(args.pop)
       end
-                                                            
+
       begin
         # render the nodelist.
         # for performance reasons we get a array back here. join will make a string out of it
-        @root.render(context).join
+        @root.render(context).join        
       ensure
         @errors = context.errors
       end
     end
-    
+
     def render!(*args)
       @rethrow_errors = true; render(*args)
     end
-       
+
     private
-    
+
     # Uses the <tt>Liquid::TemplateParser</tt> regexp to tokenize the passed source
     def tokenize(source)
-      source = source.source if source.respond_to?(:source)      
+      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.shift if tokens[0] and tokens[0].empty?
 
       tokens
     end
-     
-  end  
+
+  end
 end

lib/liquid/utils.rb

@@ -0,0 +1,31 @@
+module Liquid
+  module Utils
+    def self.slice_collection_using_each(collection, from, to)
+      segments = []
+      index = 0
+      yielded = 0
+
+      # Maintains Ruby 1.8.7 String#each behaviour on 1.9
+      return [collection] if non_blank_string?(collection)
+
+      collection.each do |item|
+
+        if to && to <= index
+          break
+        end
+
+        if from <= index
+          segments << item
+        end
+
+        index += 1
+      end
+
+      segments
+    end
+
+    def self.non_blank_string?(collection)
+      collection.is_a?(String) && collection != ''
+    end
+  end
+end

lib/liquid/variable.rb

@@ -11,20 +11,21 @@ module Liquid
   #   {{ user | link }}
   #
   class Variable
+    FilterParser = /(?:#{FilterSeparator}|(?:\s*(?!(?:#{FilterSeparator}))(?:#{QuotedFragment}|\S+)\s*)+)/o
     attr_accessor :filters, :name
 
     def initialize(markup)
       @markup  = markup
       @name    = nil
       @filters = []
-      if match = markup.match(/\s*(#{QuotedFragment})/)
+      if match = markup.match(/\s*(#{QuotedFragment})(.*)/o)
         @name = match[1]
-        if markup.match(/#{FilterSeparator}\s*(.*)/)
-          filters = Regexp.last_match(1).split(/#{FilterSeparator}/)
-          filters.each do |f|    
+        if match[2].match(/#{FilterSeparator}\s*(.*)/o)
+          filters = Regexp.last_match(1).scan(FilterParser)
+          filters.each do |f|
             if matches = f.match(/\s*(\w+)/)
               filtername = matches[1]
-              filterargs = f.scan(/(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*(#{QuotedFragment})/).flatten
+              filterargs = f.scan(/(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*(#{QuotedFragment})/o).flatten
               @filters << [filtername.to_sym, filterargs]
             end
           end
@@ -34,10 +35,9 @@ module Liquid
 
     def render(context)
       return '' if @name.nil?
-      output = context[@name]
-      @filters.inject(output) do |output, filter|
+      @filters.inject(context[@name]) do |output, filter|
         filterargs = filter[1].to_a.collect do |a|
-         context[a]
+          context[a]
         end
         begin
           output = context.invoke(filter[0], output, *filterargs)
@@ -45,7 +45,6 @@ module Liquid
           raise FilterNotFound, "Error - filter '#{filter[0]}' in '#{@markup.strip}' could not be found."
         end
       end
-      output
     end
   end
-end
+end

liquid.gemspec

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

performance/benchmark.rb

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

performance/profile.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'ruby-prof' rescue fail("install ruby-prof extension/gem")
+require File.dirname(__FILE__) + '/theme_runner'
+
+profiler = ThemeRunner.new
+
+puts 'Running profiler...'
+
+results  = profiler.run_profile
+
+puts 'Success'
+
+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

@@ -0,0 +1,33 @@
+class CommentForm < Liquid::Block                                             
+  Syntax = /(#{Liquid::VariableSignature}+)/   
+
+  def initialize(tag_name, markup, tokens)
+    if markup =~ Syntax
+      @variable_name = $1
+      @attributes = {}
+    else
+      raise SyntaxError.new("Syntax Error in 'comment_form' - Valid syntax: comment_form [article]")
+    end
+    
+    super
+  end
+
+  def render(context)          
+    article = context[@variable_name]
+              
+    context.stack do       
+      context['form'] = {
+        'posted_successfully?' => context.registers[:posted_successfully],
+        'errors' => context['comment.errors'],
+        'author' => context['comment.author'],
+        'email'  => context['comment.email'],
+        'body'   => context['comment.body']
+      }
+      wrap_in_form(article, render_all(@nodelist, context))
+    end
+  end          
+    
+  def wrap_in_form(article, input)    
+    %Q{<form id="article-#{article.id}-comment-form" class="comment-form" method="post" action="">\n#{input}\n</form>}    
+  end
+end

performance/shopify/database.rb

@@ -0,0 +1,45 @@
+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(File.dirname(__FILE__) + '/vision.database.yml')
+
+      # From vision source      
+      db['products'].each do |product|
+        collections = db['collections'].find_all do |collection|
+          collection['products'].any? { |p| p['id'].to_i == product['id'].to_i }
+        end      
+        product['collections'] = collections      
+      end
+
+      # key the tables by handles, as this is how liquid expects it.      
+      db = db.inject({}) do |assigns, (key, values)|
+        assigns[key] = values.inject({}) { |h, v| h[v['handle']] = v; h; }
+        assigns
+      end  
+      
+      # Some standard direct accessors so that the specialized templates 
+      # render correctly
+      db['collection'] = db['collections'].values.first
+      db['product']    = db['products'].values.first
+      db['blog']       = db['blogs'].values.first
+      db['article']    = db['blog']['articles'].first
+            
+      db['cart']       = { 
+        'total_price' => db['line_items'].values.inject(0) { |sum, item| sum += item['line_price'] * item['quantity'] },
+        'item_count'  => db['line_items'].values.inject(0) { |sum, item| sum += item['quantity'] },
+        'items'       => db['line_items'].values
+      }
+            
+      db
+    end    
+  end
+end
+
+if __FILE__ == $0
+  p Database.tables['collections']['frontpage'].keys
+  #p Database.tables['blog']['articles']
+end

performance/shopify/json_filter.rb

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

performance/shopify/liquid.rb

@@ -0,0 +1,19 @@
+$:.unshift File.dirname(__FILE__) + '/../../lib'
+require File.dirname(__FILE__) + '/../../lib/liquid'
+
+require File.dirname(__FILE__) + '/comment_form'
+require File.dirname(__FILE__) + '/paginate'
+require File.dirname(__FILE__) + '/json_filter'
+require File.dirname(__FILE__) + '/money_filter'
+require File.dirname(__FILE__) + '/shop_filter'
+require File.dirname(__FILE__) + '/tag_filter'
+require File.dirname(__FILE__) + '/weight_filter'
+
+Liquid::Template.register_tag 'paginate', Paginate
+Liquid::Template.register_tag 'form', CommentForm
+
+Liquid::Template.register_filter JsonFilter
+Liquid::Template.register_filter MoneyFilter
+Liquid::Template.register_filter WeightFilter
+Liquid::Template.register_filter ShopFilter
+Liquid::Template.register_filter TagFilter

performance/shopify/money_filter.rb

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

performance/shopify/paginate.rb

@@ -0,0 +1,93 @@
+class Paginate < Liquid::Block
+  Syntax     = /(#{Liquid::QuotedFragment})\s*(by\s*(\d+))?/
+
+  def initialize(tag_name, markup, tokens)
+    @nodelist = []
+    
+    if markup =~ Syntax
+      @collection_name = $1
+      @page_size = if $2
+        $3.to_i
+      else
+        20
+      end
+      
+      @attributes = { 'window_size' => 3 }
+      markup.scan(Liquid::TagAttributes) do |key, value|
+        @attributes[key] = value
+      end        
+    else
+      raise SyntaxError.new("Syntax Error in tag 'paginate' - Valid syntax: paginate [collection] by number")
+    end
+  
+    super
+  end
+
+  def render(context)
+    @context = context
+
+    context.stack do                      
+      current_page  = context['current_page'].to_i
+
+      pagination = {
+        'page_size'      => @page_size,
+        'current_page'   => 5,
+        'current_offset' => @page_size * 5
+      }
+      
+      context['paginate'] = pagination      
+      
+      collection_size  = context[@collection_name].size      
+
+      raise ArgumentError.new("Cannot paginate array '#{@collection_name}'. Not found.") if collection_size.nil?
+    
+      page_count = (collection_size.to_f / @page_size.to_f).to_f.ceil + 1 
+
+      pagination['items']      = collection_size
+      pagination['pages']      = page_count -1
+      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['parts']      = []
+      
+      hellip_break = false
+      
+      if page_count > 2
+        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
+            pagination['parts'] << link(page, page)
+          elsif page <= current_page - @attributes['window_size'] or page >= current_page + @attributes['window_size']
+            next if hellip_break
+            pagination['parts'] << no_link('&hellip;')
+            hellip_break = true
+            next
+          else
+            pagination['parts'] << link(page, page)
+          end
+        
+          hellip_break = false
+        end 
+      end
+      
+      render_all(@nodelist, context)
+    end
+  end
+    
+  private
+  
+  def no_link(title)
+    { 'title' => title, 'is_link' => false}
+  end
+  
+  def link(title, page)
+    { 'title' => title, 'url' => current_url + "?page=#{page}", 'is_link' => true}
+  end
+  
+  def current_url
+    "/collections/frontpage"
+  end
+end    

performance/shopify/shop_filter.rb

@@ -0,0 +1,98 @@
+module ShopFilter
+      
+  def asset_url(input)
+    "/files/1/[shop_id]/[shop_id]/assets/#{input}"
+  end
+
+  def global_asset_url(input)
+    "/global/#{input}"
+  end
+  
+  def shopify_asset_url(input)
+    "/shopify/#{input}"
+  end
+  
+  def script_tag(url)
+    %(<script src="#{url}" type="text/javascript"></script>)
+  end
+
+  def stylesheet_tag(url, media="all")
+    %(<link href="#{url}" rel="stylesheet" type="text/css"  media="#{media}"  />)
+  end
+       
+  def link_to(link, url, title="")
+    %|<a href="#{url}" title="#{title}">#{link}</a>|
+  end
+  
+  def img_tag(url, alt="")
+    %|<img src="#{url}" alt="#{alt}" />|  
+  end  
+  
+  def link_to_vendor(vendor)
+    if vendor
+      link_to vendor, url_for_vendor(vendor), vendor
+    else
+      'Unknown Vendor'
+    end
+  end
+  
+  def link_to_type(type)
+    if type
+      link_to type, url_for_type(type), type
+    else
+      'Unknown Vendor'
+    end
+  end
+  
+  def url_for_vendor(vendor_title)
+    "/collections/#{vendor_title.to_handle}"
+  end
+  
+  def url_for_type(type_title)
+    "/collections/#{type_title.to_handle}"
+  end
+  
+  def product_img_url(url, style = 'small')
+    
+    unless url =~ /^products\/([\w\-\_]+)\.(\w{2,4})/
+      raise ArgumentError, 'filter "size" can only be called on product images'
+    end
+    
+    case style
+    when 'original'
+      return '/files/shops/random_number/' + url 
+    when 'grande', 'large', 'medium', 'compact', 'small', 'thumb', 'icon'
+      "/files/shops/random_number/products/#{$1}_#{style}.#{$2}"              
+    else
+      raise ArgumentError, 'valid parameters for filter "size" are: original, grande, large, medium, compact, small, thumb and icon '      
+    end
+  end
+  
+  def default_pagination(paginate)
+    
+    html = []    
+    html << %(<span class="prev">#{link_to(paginate['previous']['title'], paginate['previous']['url'])}</span>) if paginate['previous']
+
+    for part in paginate['parts']
+
+      if part['is_link']
+        html << %(<span class="page">#{link_to(part['title'], part['url'])}</span>)        
+      elsif part['title'].to_i == paginate['current_page'].to_i
+        html << %(<span class="page current">#{part['title']}</span>)        
+      else
+        html << %(<span class="deco">#{part['title']}</span>)                
+      end
+      
+    end
+
+    html << %(<span class="next">#{link_to(paginate['next']['title'], paginate['next']['url'])}</span>) if paginate['next']
+    html.join(' ')
+  end
+  
+  # Accepts a number, and two words - one for singular, one for plural
+  # Returns the singular word if input equals 1, otherwise plural
+  def pluralize(input, singular, plural)
+    input == 1 ? singular : plural
+  end
+      
+end

performance/shopify/tag_filter.rb

@@ -0,0 +1,25 @@
+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')
+    if @context['current_tags'].include?(tag)
+      "<span class=\"#{css_class}\">#{tag}</span>"
+    else
+      tag
+    end
+  end
+
+  def link_to_add_tag(label, tag)    
+    tags = (@context['current_tags'] + [tag]).uniq
+    "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tags.join("+")}\">#{label}</a>"
+  end
+  
+  def link_to_remove_tag(label, tag)    
+    tags = (@context['current_tags'] - [tag]).uniq
+    "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tags.join("+")}\">#{label}</a>"
+  end
+  
+end

performance/shopify/vision.database.yml

@@ -0,0 +1,945 @@
+# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+#   Variants
+# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+product_variants: 
+  - &product-1-var-1
+    id: 1
+    title: 151cm / Normal
+    price: 19900
+    weight: 1000
+    compare_at_price: 49900
+    available: true
+    inventory_quantity: 5
+    option1: 151cm
+    option2: Normal
+    option3: 
+  - &product-1-var-2
+    id: 2
+    title: 155cm / Normal
+    price: 31900
+    weight: 1000
+    compare_at_price: 50900
+    available: true
+    inventory_quantity: 2
+    option1: 155cm
+    option2: Normal
+    option3: 
+  - &product-2-var-1
+    id: 3
+    title: 162cm
+    price: 29900
+    weight: 1000
+    compare_at_price: 52900
+    available: true
+    inventory_quantity: 3
+    option1: 162cm
+    option2: 
+    option3: 
+  - &product-3-var-1
+    id: 4
+    title: 159cm
+    price: 19900
+    weight: 1000
+    compare_at_price: 
+    available: true
+    inventory_quantity: 4
+    option1: 159cm
+    option2: 
+    option3: 
+  - &product-4-var-1
+    id: 5
+    title: 159cm
+    price: 19900
+    weight: 1000
+    compare_at_price: 32900
+    available: true
+    inventory_quantity: 6
+    option1: 159cm
+    option2: 
+    option3: 
+  - &product-1-var-3
+    id: 6
+    title: 158cm / Wide
+    price: 23900
+    weight: 1000
+    compare_at_price: 99900
+    available: false
+    inventory_quantity: 0
+    option1: 158cm
+    option2: Wide
+    option3:
+  - &product-3-var-2
+    id: 7
+    title: 162cm
+    price: 19900
+    weight: 1000
+    compare_at_price: 
+    available: false
+    inventory_quantity: 0
+    option1: 162cm
+    option2: 
+    option3: 
+  - &product-3-var-3
+    id: 8
+    title: 165cm
+    price: 22900
+    weight: 1000
+    compare_at_price:
+    available: true
+    inventory_quantity: 4
+    option1: 165cm
+    option2: 
+    option3: 
+  - &product-5-var-1
+    id: 9
+    title: black / 42
+    price: 11900
+    weight: 500
+    compare_at_price: 22900
+    available: true
+    inventory_quantity: 1
+    option1: black
+    option2: 42
+    option3:
+  - &product-5-var-2
+    id: 10
+    title: beige / 42
+    price: 11900
+    weight: 500
+    compare_at_price: 22900
+    available: true
+    inventory_quantity: 3
+    option1: beige
+    option2: 42
+    option3:
+  - &product-5-var-3
+    id: 11
+    title: white / 42
+    price: 13900
+    weight: 500
+    compare_at_price: 24900
+    available: true
+    inventory_quantity: 1
+    option1: white
+    option2: 42
+    option3:
+  - &product-5-var-4
+    id: 12
+    title: black / 44
+    price: 11900
+    weight: 500
+    compare_at_price: 22900
+    available: true
+    inventory_quantity: 2
+    option1: black
+    option2: 44
+    option3:
+  - &product-5-var-5
+    id: 13
+    title: beige / 44
+    price: 11900
+    weight: 500
+    compare_at_price: 22900
+    available: false
+    inventory_quantity: 0
+    option1: beige
+    option2: 44
+    option3:
+  - &product-5-var-6
+    id: 14
+    title: white / 44
+    price: 13900
+    weight: 500
+    compare_at_price: 24900
+    available: false
+    inventory_quantity: 0
+    option1: white
+    option2: 44
+    option3:
+  - &product-6-var-1
+    id: 15
+    title: red
+    price: 2179500
+    weight: 200000
+    compare_at_price:
+    available: true
+    inventory_quantity: 0
+    option1: red
+    option2:
+    option3:
+  - &product-7-var-1
+    id: 16
+    title: black / small
+    price: 1900
+    weight: 200
+    compare_at_price:
+    available: true
+    inventory_quantity: 20
+    option1: black
+    option2: small
+    option3:
+  - &product-7-var-2
+    id: 17
+    title: black / medium
+    price: 1900
+    weight: 200
+    compare_at_price:
+    available: false
+    inventory_quantity: 0
+    option1: black
+    option2: medium
+    option3:
+  - &product-7-var-3
+    id: 18
+    title: black / large
+    price: 1900
+    weight: 200
+    compare_at_price:
+    available: true
+    inventory_quantity: 10
+    option1: black
+    option2: large
+    option3:
+  - &product-7-var-4
+    id: 19
+    title: black / extra large
+    price: 1900
+    weight: 200
+    compare_at_price:
+    available: false
+    inventory_quantity: 0
+    option1: black
+    option2: extra large
+    option3:
+  - &product-8-var-1
+    id: 20
+    title: brown / small
+    price: 5900
+    weight: 400
+    compare_at_price: 6900
+    available: true
+    inventory_quantity: 5
+    option1: brown
+    option2: small
+    option3:
+  - &product-8-var-2
+    id: 21
+    title: brown / medium
+    price: 5900
+    weight: 400
+    compare_at_price: 6900
+    available: false
+    inventory_quantity: 0
+    option1: brown
+    option2: medium
+    option3:       
+  - &product-8-var-3
+    id: 22
+    title: brown / large
+    price: 5900
+    weight: 400
+    compare_at_price: 6900
+    available: true
+    inventory_quantity: 10
+    option1: brown
+    option2: large
+    option3:
+  - &product-8-var-4
+    id: 23
+    title: black / small
+    price: 5900
+    weight: 400
+    compare_at_price: 6900
+    available: true
+    inventory_quantity: 10
+    option1: black
+    option2: small
+    option3:
+  - &product-8-var-5
+    id: 24
+    title: black / medium
+    price: 5900
+    weight: 400
+    compare_at_price: 6900
+    available: true
+    inventory_quantity: 10
+    option1: black
+    option2: medium
+    option3:
+  - &product-8-var-6
+    id: 25
+    title: black / large
+    price: 5900
+    weight: 400
+    compare_at_price: 6900
+    available: false
+    inventory_quantity: 0
+    option1: black
+    option2: large
+    option3:
+  - &product-9-var-1
+    id: 26
+    title: Body Only
+    price: 499995
+    weight: 2000
+    compare_at_price:
+    available: true
+    inventory_quantity: 3
+    option1: Body Only
+    option2:
+    option3:
+  - &product-9-var-2
+    id: 27
+    title: Kit with 18-55mm VR lens
+    price: 523995
+    weight: 2000
+    compare_at_price:
+    available: true
+    inventory_quantity: 2
+    option1: Kit with 18-55mm VR lens
+    option2:
+    option3:
+  - &product-9-var-3
+    id: 28
+    title: Kit with 18-200 VR lens
+    price: 552500
+    weight: 2000
+    compare_at_price:
+    available: true
+    inventory_quantity: 3
+    option1: Kit with 18-200 VR lens
+    option2:
+    option3:
+
+# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+#   Products
+# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+  
+products:
+  - &product-1
+    id: 1
+    title: Arbor Draft
+    handle: arbor-draft
+    type: Snowboards
+    vendor: Arbor
+    price: 23900
+    price_max: 31900
+    price_min: 23900
+    price_varies: true
+    available: true    
+    tags: 
+      - season2005
+      - pro
+      - intermediate
+      - wooden      
+      - freestyle
+    options: 
+      - Length
+      - Style           
+    compare_at_price: 49900
+    compare_at_price_max: 50900
+    compare_at_price_min: 49900
+    compare_at_price_varies: true
+    url: /products/arbor-draft
+    featured_image: products/arbor_draft.jpg
+    images: 
+      - products/arbor_draft.jpg
+    description: 
+      The Arbor Draft snowboard wouldn't exist if Polynesians hadn't figured out how to surf hundreds of years ago. But the Draft does exist, and it's here to bring your urban and park riding to a new level. The board's freaky Tiki design pays homage to culture that inspired snowboarding. It's designed to spin with ease, land smoothly, lock hook-free onto rails, and take the abuse of a pavement pounding or twelve. The Draft will pop off kickers with authority and carve solidly across the pipe. The Draft features targeted Koa wood die cuts inlayed into the deck that enhance the flex pattern. Now bow down to riding's ancestors.
+    variants: 
+      - *product-1-var-1
+      - *product-1-var-2
+      - *product-1-var-3
+  - &product-2
+    id: 2
+    title: Arbor Element
+    handle: arbor-element
+    type: Snowboards
+    vendor: Arbor
+    price: 29900
+    price_max: 29900
+    price_min: 29900
+    price_varies: false
+    available: true    
+    tags: 
+      - season2005
+      - pro
+      - wooden          
+      - freestyle
+    options:
+      - Length 
+    compare_at_price: 52900
+    compare_at_price_max: 52900
+    compare_at_price_min: 52900
+    compare_at_price_varies: false
+    url: /products/arbor-element
+    featured_image: products/element58.jpg
+    images:
+      - products/element58.jpg
+    description:
+      The Element is a technically advanced all-mountain board for riders who readily transition from one terrain, snow condition, or riding style to another. Its balanced design provides the versatility needed for the true ride-it-all experience. The Element is exceedingly lively, freely initiates, and holds a tight edge at speed. Its structural real-wood topsheet is made with book-matched Koa.
+    variants: 
+      - *product-2-var-1
+    
+  - &product-3
+    id: 3
+    title: Comic ~ Pastel 
+    handle: comic-pastel
+    type: Snowboards
+    vendor: Technine
+    price: 19900
+    price_max: 22900
+    price_min: 19900
+    tags: 
+      - season2006
+      - beginner
+      - intermediate
+      - freestyle      
+      - purple
+    options:
+      - Length
+    price_varies: true
+    available: true    
+    compare_at_price: 
+    compare_at_price_max: 0
+    compare_at_price_min: 0
+    compare_at_price_varies: false
+    url: /products/comic-pastel
+    featured_image: products/technine1.jpg
+    images:
+      - products/technine1.jpg
+      - products/technine2.jpg
+      - products/technine_detail.jpg
+    description:
+      2005 Technine Comic Series Description The Comic series was developed to be the ultimate progressive freestyle board in the Technine line. Dependable edge control and a perfect flex pattern for jumping in the park or out of bounds. Landins and progression will come easy with this board and it will help your riding progress to the next level. Street rails, park jibs, backcountry booters and park jumps, this board will do it all.
+    variants: 
+      - *product-3-var-1
+      - *product-3-var-2
+      - *product-3-var-3
+
+  - &product-4
+    id: 4
+    title: Comic ~ Orange
+    handle: comic-orange
+    type: Snowboards
+    vendor: Technine
+    price: 19900
+    price_max: 19900
+    price_min: 19900
+    price_varies: false
+    available: true    
+    tags: 
+      - season2006
+      - beginner
+      - intermediate
+      - freestyle   
+      - orange
+    options:
+      - Length
+    compare_at_price: 32900
+    compare_at_price_max: 32900
+    compare_at_price_min: 32900
+    compare_at_price_varies: false
+    url: /products/comic-orange
+    featured_image: products/technine3.jpg
+    images:
+      - products/technine3.jpg
+      - products/technine4.jpg
+    description:
+      2005 Technine Comic Series Description The Comic series was developed to be the ultimate progressive freestyle board in the Technine line. Dependable edge control and a perfect flex pattern for jumping in the park or out of bounds. Landins and progression will come easy with this board and it will help your riding progress to the next level. Street rails, park jibs, backcountry booters and park jumps, this board will do it all.
+    variants: 
+      - *product-4-var-1
+      
+  - &product-5
+    id: 5
+    title: Burton Boots
+    handle: burton-boots
+    type: Boots
+    vendor: Burton
+    price: 11900
+    price_max: 11900
+    price_min: 11900
+    price_varies: false
+    available: true        
+    tags: 
+      - season2006
+      - beginner
+      - intermediate   
+      - boots
+    options:
+      - Color
+      - Shoe Size
+    compare_at_price: 22900
+    compare_at_price_max: 22900
+    compare_at_price_min: 22900
+    compare_at_price_varies: false
+    url: /products/burton-boots
+    featured_image: products/burton.jpg
+    images:
+      - products/burton.jpg
+    description:
+      The Burton boots are particularly well on snowboards. The very best thing about them is that the according picture is cubic. This makes testing in a Vision testing environment very easy.
+    variants: 
+      - *product-5-var-1
+      - *product-5-var-2
+      - *product-5-var-3
+      - *product-5-var-4
+      - *product-5-var-5
+      - *product-5-var-6                        
+
+  - &product-6
+    id: 6
+    title: Superbike 1198 S
+    handle: superbike
+    type: Superbike
+    vendor: Ducati
+    price: 2179500
+    price_max: 2179500
+    price_min: 2179500
+    price_varies: false
+    available: true    
+    tags: 
+      - ducati
+      - superbike
+      - bike   
+      - street
+      - racing
+      - performance      
+    options:
+      - Color
+    compare_at_price: 
+    compare_at_price_max: 0
+    compare_at_price_min: 0
+    compare_at_price_varies: false
+    url: /products/superbike
+    featured_image: products/ducati.jpg
+    images:
+      - products/ducati.jpg
+    description:
+      <h3>‘S’ PERFORMANCE</h3>
+      <p>Producing 170hp (125kW) and with a dry weight of just 169kg (372.6lb), the new 1198 S now incorporates more World Superbike technology than ever before by taking the 1198 motor and adding top-of-the-range suspension, lightweight chassis components and a true racing-style traction control system designed for road use.</p>
+      <p>The high performance, fully adjustable 43mm Öhlins forks, which sport low friction titanium nitride-treated fork sliders, respond effortlessly to every imperfection in the tarmac. Beyond their advanced engineering solutions, one of the most important characteristics of Öhlins forks is their ability to communicate the condition and quality of the tyre-to-road contact patch, a feature that puts every rider in superior control. The suspension set-up at the rear is complemented with a fully adjustable Öhlins rear shock equipped with a ride enhancing top-out spring and mounted to a single-sided swingarm for outstanding drive and traction. The front-to-rear Öhlins package is completed with a control-enhancing adjustable steering damper.</p>
+    variants: 
+      - *product-6-var-1
+
+  - &product-7
+    id: 7
+    title: Shopify Shirt
+    handle: shopify-shirt
+    type: Shirt
+    vendor: Shopify
+    price: 1900
+    price_max: 1900
+    price_min: 1900
+    price_varies: false
+    available: true    
+    tags: 
+      - shopify
+      - shirt
+      - apparel  
+      - tshirt
+      - clothing
+    options:
+      - Color
+      - Size
+    compare_at_price: 
+    compare_at_price_max: 0
+    compare_at_price_min: 0
+    compare_at_price_varies: false
+    url: /products/shopify-shirt
+    featured_image: products/shopify_shirt.png
+    images:
+      - products/shopify_shirt.png
+    description:
+      <p>High Quality Shopify Shirt. Wear your e-commerce solution with pride and attract attention anywhere you go.</p>
+      <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.</p>
+    variants: 
+      - *product-7-var-1
+      - *product-7-var-2
+      - *product-7-var-3
+      - *product-7-var-4            
+
+  - &product-8
+    id: 8
+    title: Hooded Sweater
+    handle: hooded-sweater
+    type: Sweater
+    vendor: Stormtech
+    price: 5900
+    price_max: 5900
+    price_min: 5900
+    price_varies: false
+    available: true    
+    tags: 
+      - sweater
+      - hooded
+      - apparel  
+      - clothing
+    options:
+      - Color
+      - Size
+    compare_at_price: 6900
+    compare_at_price_max: 6900
+    compare_at_price_min: 6900
+    compare_at_price_varies: false
+    url: /products/hooded-sweater
+    featured_image: products/hooded-sweater.jpg
+    images:
+      - products/hooded-sweater.jpg
+      - products/hooded-sweater-b.jpg
+    description:
+      <p>Extra comfortable zip up sweater. Durable quality, ideal for any outdoor activities.</p>
+      <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.</p>
+    variants: 
+      - *product-8-var-1
+      - *product-8-var-2
+      - *product-8-var-3
+      - *product-8-var-4            
+      - *product-8-var-5
+      - *product-8-var-6
+
+  - &product-9
+    id: 9
+    title: D3 Digital SLR Camera
+    handle: d3
+    type: SLR
+    vendor: Nikon
+    price: 499995
+    price_max: 552500
+    price_min: 499995
+    price_varies: true
+    available: true    
+    tags: 
+      - camera
+      - slr
+      - nikon  
+      - professional
+    options:
+      - Bundle
+    compare_at_price:
+    compare_at_price_max: 0
+    compare_at_price_min: 0
+    compare_at_price_varies: false
+    url: /products/d3
+    featured_image: products/d3.jpg
+    images:
+      - products/d3.jpg
+      - products/d3_2.jpg
+      - products/d3_3.jpg      
+    description:
+      <p>Flagship pro D-SLR with a 12.1-MP FX-format CMOS sensor, blazing 9 fps shooting at full FX resolution and low-noise performance up to 6400 ISO.</p>
+      <p><strong>Nikon's original 12.1-megapixel FX-format (23.9 x 36mm) CMOS sensor:</strong> Couple Nikon's exclusive digital image processing system with the 12.1-megapixel FX-format and you'll get breathtakingly rich images while also reducing noise to unprecedented levels with even higher ISOs.</p>
+      <p><strong>Continuous shooting at up to 9 frames per second:</strong> At full FX resolution and up to 11fps in the DX crop mode, the D3 offers uncompromised shooting speeds for fast-action and sports photography.</p>
+    variants: 
+      - *product-9-var-1
+      - *product-9-var-2
+      - *product-9-var-3
+
+      
+# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+#   Line Items
+# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+      
+line_items:
+  - &line_item-1
+    id: 1
+    title: 'Arbor Draft'
+    subtitle: '151cm'
+    price: 29900
+    line_price: 29900
+    quantity: 1
+    variant: *product-1-var-1
+    product: *product-1
+
+  - &line_item-2
+    id: 2
+    title: 'Comic ~ Orange'
+    subtitle: '159cm'
+    price: 19900
+    line_price: 39800
+    quantity: 2
+    variant: *product-4-var-1
+    product: *product-4
+    
+# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+#   Link Lists
+# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+links:
+  - &link-1
+    id: 1
+    title: Our Sale
+    url: /collections/sale
+  - &link-2
+    id: 2
+    title: Arbor Stuff
+    url: /collections/arbor
+  - &link-3
+    id: 3
+    title: All our Snowboards
+    url: /collections/snowboards
+  - &link-4
+    id: 4
+    title: Powered by Shopify
+    url: 'http://shopify.com'
+  - &link-5
+    id: 5
+    title: About Us
+    url: /pages/about-us
+  - &link-6
+    id: 6
+    title: Policies
+    url: /pages/shipping
+  - &link-7
+    id: 7
+    title: Contact Us
+    url: /pages/contact
+  - &link-8
+    id: 8
+    title: Our blog
+    url: /blogs/bigcheese-blog
+  - &link-9
+    id: 9
+    title: New Boots
+    url: /products/burton-boots
+  - &link-10
+    id: 10
+    title: Paginated Sale
+    url: /collections/paginated-sale
+  - &link-11
+    id: 11
+    title: Our Paginated blog
+    url: /blogs/paginated-blog
+  - &link-12
+    id: 12
+    title: Catalog
+    url: /collections/all
+
+    
+
+# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+#   Link Lists
+# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+link_lists:
+  - &link-list-1
+    id: 1
+    title: 'Main Menu'
+    handle: 'main-menu'
+    links:
+      - *link-12      
+      - *link-5
+      - *link-7
+      - *link-8
+  - &link-list-2
+    id: 1
+    title: 'Footer Menu'
+    handle: 'footer'
+    links:
+      - *link-5
+      - *link-6
+      
+# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+#   Collections
+# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+collections:
+  - &collection-1
+    id: 1
+    title: Frontpage
+    handle: frontpage
+    url: /collections/frontpage
+    products:
+      - *product-7
+      - *product-8
+      - *product-9
+
+  - &collection-2
+    id: 2
+    title: Arbor
+    handle: arbor
+    url: /collections/arbor
+    products: 
+      - *product-1
+      - *product-2
+
+  - &collection-3
+    id: 3
+    title: Snowboards
+    handle: snowboards
+    url: /collections/snowboards
+    description:
+      <p>This is a description for my <strong>Snowboards</strong> collection.</p>
+    products: 
+      - *product-1
+      - *product-2
+      - *product-3
+      - *product-4
+  
+  - &collection-4
+    id: 4
+    title: Items On Sale
+    handle: sale
+    url: /collections/sale
+    products: 
+      - *product-1
+      
+  - &collection-5
+    id: 5
+    title: Paginated Sale
+    handle: 'paginated-sale'
+    url: '/collections/paginated-sale'
+    products: 
+      - *product-1
+      - *product-2
+      - *product-3
+      - *product-4
+    products_count: 210
+
+  - &collection-6
+    id: 6
+    title: All products
+    handle: 'all'
+    url: '/collections/all'
+    products: 
+      - *product-7
+      - *product-8
+      - *product-9
+      - *product-6
+      - *product-1
+      - *product-2
+      - *product-3
+      - *product-4
+      - *product-5
+
+          
+# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+#   Pages and Blogs
+# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+pages:
+  - &page-2
+    id: 1
+    title: Contact Us
+    handle: contact
+    url: /pages/contact
+    author: Tobi
+    content:
+      "<p>You can contact us via phone under (555) 567-2222.</p>
+      <p>Our retail store is located at <em>Rue d'Avignon 32, Avignon (Provence)</em>.</p>
+      <p><strong>Opening Hours:</strong><br />Monday through Friday: 9am - 6pm<br />Saturday: 10am - 3pm<br />Sunday: closed</p>"
+    created_at: 2005-04-04 12:00
+    
+  - &page-3
+    id: 2
+    title: About Us
+    handle: about-us
+    url: /pages/about-us   
+    author: Tobi
+    content:
+      "<p>Our company was founded in 1894 and we are since operating out of Avignon from the beautiful Provence.</p>
+      <p>We offer the highest quality products and are proud to serve our customers to their heart's content.</p>"
+    created_at: 2005-04-04 12:00
+
+  - &page-4
+    id: 3
+    title: Shopping Cart
+    handle: shopping-cart
+    url: /pages/shopping-cart
+    author: Tobi
+    content: "<ul><li>Your order is safe with us. Our checkout uses industry standard security to protect your information.</li><li>Your order will be billed immediately upon checkout.</li><li><b>ALL SALES ARE FINAL:</b> Defective or damaged product will be exchanged</li><li>All orders are processed expediently: usually in under 24 hours.</li></ul>"
+    created_at: 2005-04-04 12:00
+    
+  - &page-5
+    id: 4
+    title: Shipping and Handling
+    handle: shipping
+    url: /pages/shipping    
+    author: Tobi
+    content: <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.</p>
+    created_at: 2005-04-04 12:00
+
+  - &page-6
+    id: 5
+    title: Frontpage
+    handle: frontpage
+    url: /pages/frontpage    
+    author: Tobi
+    content: <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.</p>
+    created_at: 2005-04-04 12:00
+
+blogs:
+  - id: 1
+    handle: news
+    title: News
+    url: /blogs/news
+    articles: 
+      - id: 3
+        title: 'Welcome to the new Foo Shop'
+        author: Daniel
+        content: <p><strong>Welcome to your Shopify store! The jaded Pixel crew is really glad you decided to take Shopify for a spin.</strong></p><p>To help you get you started with Shopify, here are a couple of tips regarding what you see on this page.</p><p>The text you see here is an article. To edit this article, create new articles or create new pages you can go to the <a href="/admin/pages">Blogs &amp; Pages</a> tab of the administration menu.</p><p>The Shopify t-shirt above is a product and selling products is what Shopify is all about. To edit this product, or create new products you can go to the <a href="/admin/products">Products Tab</a> in of the administration menu.</p><p>While you're looking around be sure to check out the <a href="/admin/collections">Collections</a> and <a href="/admin/links">Navigations</a> tabs and soon you will be well on your way to populating your site.</p><p>And of course don't forget to browse the <a href="admin/design/appearance/themes">theme gallery</a> to pick a new look for your shop!</p><p><strong>Shopify is in beta</strong><br />If you would like to make comments or suggestions please visit us in the <a href="http://forums.shopify.com/community">Shopify Forums</a> or drop us an <a href="mailto:feedback@shopify.com">email</a>.</p>  
+        created_at: 2005-04-04 16:00
+      - id: 4
+        title: 'Breaking News: Restock on all sales products'
+        author: Tobi
+        content: Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+        created_at: 2005-04-04 12:00
+    articles_count: 2
+         
+  - id: 2
+    handle: bigcheese-blog
+    title: Bigcheese blog
+    url: /blogs/bigcheese-blog
+    articles:
+      - id: 1
+        title: 'One thing you probably did not know yet...'
+        author: Justin
+        content: Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+        created_at: 2005-04-04 16:00
+        comments:
+          - 
+            id: 1
+            author: John Smith
+            email: john@smith.com
+            content: Wow...great article man.
+            status: published
+            created_at: 2009-01-01 12:00
+            updated_at: 2009-02-01 12:00
+            url: ""
+          - 
+            id: 2
+            author: John Jones
+            email: john@jones.com
+            content: I really enjoyed this article. And I love your shop! It's awesome. Shopify rocks!
+            status: published
+            created_at: 2009-03-01 12:00
+            updated_at: 2009-02-01 12:00
+            url: "http://somesite.com/"
+      - id: 2
+        title: Fascinating
+        author: Tobi
+        content: Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+        created_at: 2005-04-06 12:00
+        comments:
+    articles_count: 2
+    comments_enabled?: true 
+    comment_post_url: ""
+    comments_count: 2
+    moderated?: true 
+
+  - id: 3
+    handle: paginated-blog
+    title: Paginated blog
+    url: /blogs/paginated-blog
+    articles: 
+      - id: 6
+        title: 'One thing you probably did not know yet...'
+        author: Justin
+        content: Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+        created_at: 2005-04-04 16:00
+    
+      - id: 7
+        title: Fascinating
+        author: Tobi
+        content: Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+        created_at: 2005-04-06 12:00
+    articles_count: 200

performance/shopify/weight_filter.rb

@@ -0,0 +1,11 @@
+module WeightFilter
+
+  def weight(grams)
+    sprintf("%.2f", grams / 1000)
+  end
+  
+  def weight_with_unit(grams)
+    "#{weight(grams)} kg"
+  end  
+  
+end

performance/tests/dropify/article.liquid

@@ -0,0 +1,74 @@
+<div class="article">
+  <h2 class="article-title">{{ article.title }}</h2>
+  <p class="article-details">posted <span class="article-time">{{ article.created_at | date: "%Y %h" }}</span> by <span class="article-author">{{ article.author }}</span></p>
+
+  <div class="article-body textile">
+    {{ article.content }}
+  </div>    
+
+</div>
+
+<!-- Comments -->
+{% if blog.comments_enabled? %}
+<div id="comments">
+  <h3>Comments</h3>
+  
+  <!-- List all comments -->
+  <ul id="comment-list">
+  {% for comment in article.comments %}
+    <li>
+  	  <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>:
+      </div>
+
+      <div class="comment">
+        {{ comment.content }}
+      </div>      
+  	</li>
+  {% endfor %}
+  </ul>
+  
+  <!-- Comment Form -->
+  <div id="comment-form">
+  {% form article %}
+    <h3>Leave a comment</h3>
+    
+    <!-- Check if a comment has been submitted in the last request, and if yes display an appropriate message -->
+    {% if form.posted_successfully? %}
+      {% if blog.moderated? %}
+        <div class="notice">
+          Successfully posted your comment.<br />
+          It will have to be approved by the blog owner first before showing up.
+        </div>
+      {% else %}
+        <div class="notice">Successfully posted your comment.</div>
+      {% endif %}
+    {% endif %}
+    
+    {% if form.errors %}
+      <div class="notice error">Not all the fields have been filled out correctly!</div>
+    {% endif %}
+    
+    <dl>
+      <dt class="{% if form.errors contains 'author' %}error{% endif %}"><label for="comment_author">Your name</label></dt>
+      <dd><input type="text" id="comment_author" name="comment[author]" size="40" value="{{form.author}}" class="{% if form.errors contains 'author' %}input-error{% endif %}" /></dd>
+
+      <dt class="{% if form.errors contains 'email' %}error{% endif %}"><label for="comment_email">Your email</label></dt>
+      <dd><input type="text" id="comment_email" name="comment[email]" size="40" value="{{form.email}}" class="{% if form.errors contains 'email' %}input-error{% endif %}" /></dd>
+
+      <dt class="{% if form.errors contains 'body' %}error{% endif %}"><label for="comment_body">Your comment</label></dt>
+      <dd><textarea id="comment_body" name="comment[body]" cols="40" rows="5" class="{% if form.errors contains 'body' %}input-error{% endif %}">{{form.body}}</textarea></dd>
+    </dl>
+    
+    {% if blog.moderated? %}
+      <p class="hint">comments have to be approved before showing up</p>
+    {% endif %}    
+
+    <input type="submit" value="Post comment" id="comment-submit" />
+  {% endform %}
+  </div>
+  <!-- END Comment Form -->
+  
+</div>
+{% endif %}
+<!-- END Comments -->

performance/tests/dropify/blog.liquid

@@ -0,0 +1,33 @@
+<div id="page">
+  <h2>{{page.title}}</h2>
+
+  {% paginate blog.articles by 20 %}
+
+    {% for article in blog.articles  %}
+
+    <div class="article">
+      <div class="headline">
+      <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>
+      </div>
+    
+      <div class="article-body textile">
+        {{ article.content | strip_html | truncate: 250 }}
+      </div>
+      
+      {% if blog.comments_enabled? %}
+        <p style="text-align: right"><a href="{{article.url}}#comments">{{ article.comments_count }} comments</a></p>
+      {% endif %}    
+    </div>
+  
+    {% endfor %}
+    
+    <div id="pagination">
+      {{ paginate | default_pagination }}
+    </div>
+
+  {% endpaginate %}
+  
+</div>

performance/tests/dropify/cart.liquid

@@ -0,0 +1,66 @@
+<script type="text/javascript">
+  function remove_item(id) {
+      document.getElementById('updates_'+id).value = 0;
+      document.getElementById('cartform').submit();
+  }
+</script>
+
+<div>
+
+  {% if cart.item_count == 0 %} 
+    <h4>Your shopping cart is looking rather empty...</h4>
+  {% else %}
+  <form action="/cart" method="post" id="cartform">
+
+  <div id="cart">
+  
+  <h3>You have {{ cart.item_count }} {{ cart.item_count | pluralize: 'product', 'products' }} in here!</h3>
+
+    <ul id="line-items">
+      {% for item in cart.items %}
+      <li id="item-{{item.id}}" class="clearfix">
+        <div class="thumb">
+				  <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">
+				{{ item.title }}
+				{% if item.variant.available == true %}
+				   ({{item.variant.title}})
+				{% endif %}
+			</a>	
+		</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> 
+          <input type="text" size="4" name="updates[{{item.variant.id}}]" id="updates_{{item.variant.id}}" value="{{item.quantity}}" onfocus="this.select();"/><br />
+          <a href="#" onclick="remove_item({{item.variant.id}}); return false;" class="remove"><img style="padding:15px 0 0 0;margin:0;" src="{{ 'delete.gif' | asset_url }}" /></a>
+        </p>
+      </li>
+      {% endfor %}
+      <li id="total">
+        <input type="image" id="update-cart" name="update" value="Update My Cart" src="{{ 'update.gif' | asset_url }}" />
+        Subtotal: 
+        <span class="money">{{ cart.total_price | money_with_currency }}</span>
+      </li>
+    </ul>
+
+  </div>
+  
+    <div class="info">
+		<input type="image" value="Checkout!" name="checkout" src="{{ 'checkout.gif' | asset_url }}" />
+    </div>
+  
+  	{% if additional_checkout_buttons %}
+    <div class="additional-checkout-buttons">
+      <p>- or -</p>
+      {{ content_for_additional_checkout_buttons }}
+    </div>
+    {% endif %}
+  
+  </form>
+
+  {% endif %}
+
+</div>

performance/tests/dropify/collection.liquid

@@ -0,0 +1,22 @@
+{% paginate collection.products by 20 %}
+
+<ul id="product-collection">
+    {% for product in collection.products %}
+    <li class="singleproduct clearfix">
+      <div class="small">
+        <div class="prodimage"><a href="{{product.url}}"><img src="{{ product.featured_image | product_img_url: 'small' }}" /></a></div>
+      </div>
+      <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>
+     </div>
+    </li>
+    {% endfor %}
+</ul>
+  
+<div id="pagination">
+  {{ paginate | default_pagination }}
+</div>
+
+{% endpaginate %}

performance/tests/dropify/index.liquid

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

performance/tests/dropify/page.liquid

@@ -0,0 +1,8 @@
+<div id="page">
+  <h2>{{page.title}}</h2>
+
+  <div class="article textile">
+    {{page.content}}
+  </div>
+
+</div>

performance/tests/dropify/product.liquid

@@ -0,0 +1,68 @@
+<div id="productpage">
+
+	<div id="productimages"><div id="productimages-top"><div id="productimages-bottom">
+		{% for image in product.images %}
+			{% if forloop.first %}
+				<a href="{{ image | product_img_url: 'large' }}" class="productimage" rel="lightbox">
+				  <img src="{{ image | product_img_url: 'medium'}}" alt="{{product.title | escape }}" />
+				</a>
+			{% else %}
+				<a href="{{ image | product_img_url: 'large' }}" class="productimage-small" rel="lightbox">
+				  <img src="{{ image | product_img_url: 'small'}}" alt="{{product.title | escape }}" />
+				</a>
+			{% endif %}
+		{% endfor %}
+	</div></div></div>
+
+  <h2>{{ product.title }}</h2>
+  
+  <ul id="details" class="hlist">
+    <li>Vendor: {{ product.vendor | link_to_vendor }}</li>
+    <li>Type: {{ product.type | link_to_type }}</li>
+  </ul>
+  
+  <small>{{ product.price_min | money }}{% if product.price_varies %} - {{ product.price_max | money }}{% endif %}</small>
+    
+  <div id="variant-add">
+    <form action="/cart/add" method="post">
+      	  
+			<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>
+
+			<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>
+    </form>
+  </div>
+  
+  <div class="description textile">
+    {{ product.description }}
+  </div>
+</div>
+
+<script type="text/javascript">
+<!--
+  // prototype callback for multi variants dropdown selector
+  var selectCallback = function(variant, selector) {
+    if (variant && variant.available == true) {
+      // selected a valid variant
+      $('add').removeClassName('disabled'); // remove unavailable class from add-to-cart button
+      $('add').disabled = false;           // reenable add-to-cart button
+      $('price-field').innerHTML = Shopify.formatMoney(variant.price, "{{shop.money_with_currency_format}}");  // update price field
+    } else {
+      // variant doesn't exist
+      $('add').addClassName('disabled');      // set add-to-cart button to unavailable class
+      $('add').disabled = true;              // disable add-to-cart button      
+      $('price-field').innerHTML = (variant) ? "Sold Out" : "Unavailable"; // update price-field message
+    }
+  };
+
+  // initialize multi selector for product
+  Event.observe(document, 'dom:loaded', function() {
+    new Shopify.OptionSelectors("variant-select", { product: {{ product | json }}, onVariantSelected: selectCallback }); 
+  });
+-->
+</script>

performance/tests/dropify/theme.liquid

@@ -0,0 +1,105 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+	"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"/>
+	<title>{{shop.name}} - {{page_title}}</title>
+
+	{{ '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 }}
+  {{ '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 }}
+	{{ 'shop.js'      | asset_url | script_tag }}
+
+	{{ content_for_header }}
+</head>
+
+<body id="page-{{template}}">
+    
+	<p class="hide"><a href="#rightsiders">Skip to navigation.</a></p>
+		<!-- mini cart -->
+        {% if cart.item_count > 0 %}
+			<div id="minicart" style="display:none;"><div id="minicart-inner">
+			<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>
+			  {% for item in cart.items %}
+				<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>
+			  {% endfor %}
+			  </div>
+			 <br style="clear:both;" />
+			</div></div>
+        {% endif %}		
+		
+  <div id="container">
+  	<div id="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>
+        {% endif %}		
+      </div>
+      <!-- End Header -->
+  	  
+  	</div>
+	<hr />
+<div id="main">
+
+  	<div id="content">
+		<div id="innercontent">
+		  {{ content_for_layout }}
+	  	</div>
+  	</div>
+    
+	<hr />
+  	<div id="rightsiders">
+  	  
+      <ul class="rightlinks">
+        {% for link in linklists.main-menu.links %}
+           <li>{{ link.title | link_to: link.url }}</li>
+        {% endfor %}
+      </ul>
+      
+        {% if tags %}
+        <ul class="rightlinks">
+          {% for tag in collection.tags %}  
+            <li><span class="add-link">{{ '+' | link_to_add_tag: tag }}</span>{{ tag | highlight_active_tag | link_to_tag: tag }}</li>
+          {% endfor %}
+        </ul>
+        {% endif %}
+  
+      <ul class="rightlinks">
+        {% for link in linklists.footer.links %}
+           <li>{{ link.title | link_to: link.url }}</li>
+        {% endfor %}
+      </ul>
+      
+  	</div>
+
+	<hr /><br style="clear:both;" />
+	
+	  <div id="footer">
+	  	<div class="footerinner">
+			All prices are in {{ shop.currency }}. 
+			Powered by <a href="http://www.shopify.com" title="Shopify, Hosted E-Commerce">Shopify</a>.
+		</div>
+	  </div>
+	  
+	</div>
+</div>
+
+<div id="tooltip"></div>
+<img id="pointer" src="{{ 'arrow2.gif' | asset_url }}" />
+
+</body>
+</html>
+

performance/tests/ripen/article.liquid

@@ -0,0 +1,74 @@
+<div class="article">
+  <h2 class="article-title">{{ article.title }}</h2>
+  <p class="article-details">posted <span class="article-time">{{ article.created_at | date: "%Y %h" }}</span> by <span class="article-author">{{ article.author }}</span></p>
+
+  <div class="article-body textile">
+    {{ article.content }}
+  </div>    
+
+</div>
+
+<!-- Comments -->
+{% if blog.comments_enabled? %}
+<div id="comments">
+  <h3>Comments</h3>
+  
+  <!-- List all comments -->
+  <ul id="comment-list">
+  {% for comment in article.comments %}
+    <li>
+      <div class="comment">
+        {{ comment.content }}
+      </div>
+      
+  	  <div class="comment-details">
+  		  Posted by {{ comment.author }} on {{ comment.created_at | date: "%B %d, %Y" }}
+      </div>
+  	</li>
+  {% endfor %}
+  </ul>
+  
+  <!-- Comment Form -->
+  <div id="comment-form">
+  {% form article %}
+    <h3>Leave a comment</h3>
+    
+    <!-- Check if a comment has been submitted in the last request, and if yes display an appropriate message -->
+    {% if form.posted_successfully? %}
+      {% if blog.moderated? %}
+        <div class="notice">
+          Successfully posted your comment.<br />
+          It will have to be approved by the blog owner first before showing up.
+        </div>
+      {% else %}
+        <div class="notice">Successfully posted your comment.</div>
+      {% endif %}
+    {% endif %}
+    
+    {% if form.errors %}
+      <div class="notice error">Not all the fields have been filled out correctly!</div>
+    {% endif %}
+    
+    <dl>
+      <dt class="{% if form.errors contains 'author' %}error{% endif %}"><label for="comment_author">Your name</label></dt>
+      <dd><input type="text" id="comment_author" name="comment[author]" size="40" value="{{form.author}}" class="{% if form.errors contains 'author' %}input-error{% endif %}" /></dd>
+
+      <dt class="{% if form.errors contains 'email' %}error{% endif %}"><label for="comment_email">Your email</label></dt>
+      <dd><input type="text" id="comment_email" name="comment[email]" size="40" value="{{form.email}}" class="{% if form.errors contains 'email' %}input-error{% endif %}" /></dd>
+
+      <dt class="{% if form.errors contains 'body' %}error{% endif %}"><label for="comment_body">Your comment</label></dt>
+      <dd><textarea id="comment_body" name="comment[body]" cols="40" rows="5" class="{% if form.errors contains 'body' %}input-error{% endif %}">{{form.body}}</textarea></dd>
+    </dl>
+    
+    {% if blog.moderated? %}
+      <p class="hint">comments have to be approved before showing up</p>
+    {% endif %}    
+
+    <input type="submit" value="Post comment" id="comment-submit" />
+  {% endform %}
+  </div>
+  <!-- END Comment Form -->
+  
+</div>
+{% endif %}
+<!-- END Comments -->

performance/tests/ripen/blog.liquid

@@ -0,0 +1,13 @@
+<div id="blog-page">
+  <h2 class="heading-shaded">{{page.title}}</h2>
+   {% for article in blog.articles  %}
+      <h4>
+        {{ article.created_at | date: '%d %b' }}
+        <a href="{{article.url}}">{{ article.title }}</a>
+      </h4>
+      {{ article.content }}
+      {% if blog.comments_enabled? %}
+        <p><a href="{{article.url}}#comments">{{ article.comments_count }} comments</a></p>
+      {% endif %}
+  {% endfor %}
+</div>

performance/tests/ripen/cart.liquid

@@ -0,0 +1,54 @@
+<script type="text/javascript">
+  function remove_item(id) {
+      document.getElementById('updates_'+id).value = 0;
+      document.getElementById('cart').submit();
+  }
+</script>
+
+<div id="cart-page">
+
+  {% 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>
+  {% else %}
+
+  <form action="/cart" method="post" id="cart">
+
+  <table class="cart">
+      <tr>
+        <th colspan="2">Product</th>
+        <th class="short">Qty</th>
+        <th>Price</th>
+        <th>Total</th>
+        <th class="short">Remove</th>
+      </tr>
+
+      {% 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 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>  
+		<p class="updatebtn"><input type="image" value="Update Cart" name="update" src="{{ 'update_icon.gif' | asset_url }}" alt="Update" /></p>
+		<p class="subtotal">
+		<strong>Subtotal:</strong> {{cart.total_price | money_with_currency }}
+		</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 %}
+    <div class="additional-checkout-buttons">
+      <p>- or -</p>
+      {{ content_for_additional_checkout_buttons }}
+    </div>
+    {% endif %}
+
+  </form>
+	
+  {% endif %}
+
+</div>

performance/tests/ripen/collection.liquid

@@ -0,0 +1,29 @@
+<div id="collection-page">
+
+{% if collection.description %}
+  <div id="collection-description" class="textile">{{ collection.description }}</div>
+{% endif %}
+
+{% paginate collection.products by 20 %}
+
+<ul id="product-collection">
+    {% for product in collection.products %}
+    <li class="single-product clearfix">
+      <div class="small">
+        <div class="prod-image"><a href="{{product.url}}"><img src="{{ product.featured_image | product_img_url: 'small' }}" alt="{{ product.title | escape }}" /></a></div>
+      </div>
+      <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>
+     </div>
+    </li>
+    {% endfor %}
+</ul>
+  
+<div id="pagination">
+  {{ paginate | default_pagination }}
+</div>
+
+{% endpaginate %}
+</div>

performance/tests/ripen/index.liquid

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

performance/tests/ripen/page.liquid

@@ -0,0 +1,4 @@
+<div id="single-page">
+<h2 class="heading-shaded">{{page.title}}</h2>
+  {{ page.content }}
+</div>

performance/tests/ripen/product.liquid

@@ -0,0 +1,75 @@
+<div id="product-page">
+	<h2 class="heading-shaded">{{ product.title }}</h2>
+	<div id="product-details">
+	<div id="product-images">
+		{% for image in product.images %}
+			{% if forloop.first %}
+				<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 }}" />
+				</a>
+			{% else %}
+				<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 }}" />
+				</a>
+			{% endif %}
+		{% endfor %}
+	</div>
+	
+	<ul id="product-info">
+		<li>Vendor: {{ product.vendor | link_to_vendor }}</li>
+		<li>Type: {{ product.type | link_to_type }}</li>
+	  </ul>
+	  
+	  <small>{{ product.price_min | money }}{% if product.price_varies %} - {{ product.price_max | money }}{% endif %}</small>
+		
+	  <div id="product-options">
+              {% if product.available %}
+
+		<form action="/cart/add" method="post">
+
+      <select id="product-select" name='id'>
+        {% for variant in product.variants %}
+          <option value="{{ variant.id }}">{{ variant.title }} - {{ variant.price | money }}</option>
+        {% endfor %}
+      </select>
+		
+      <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>
+		</form>
+              {% else %}
+                  <span>Sold Out!</span>
+              {% endif %}
+	  </div>
+	  
+	  <div class="product-description">
+		{{ product.description }}
+	  </div>
+  </div>
+</div>
+
+
+<script type="text/javascript">
+<!--
+  // mootools callback for multi variants dropdown selector
+  var selectCallback = function(variant, selector) {
+    if (variant && variant.available == true) {
+      // selected a valid variant
+      $('add').removeClass('disabled'); // remove unavailable class from add-to-cart button
+      $('add').disabled = false;           // reenable add-to-cart button
+      $('price-field').innerHTML = Shopify.formatMoney(variant.price, "{{shop.money_with_currency_format}}");  // update price field
+    } else {
+      // variant doesn't exist
+      $('add').addClass('disabled');      // set add-to-cart button to unavailable class
+      $('add').disabled = true;              // disable add-to-cart button      
+      $('price-field').innerHTML = (variant) ? "Sold Out" : "Unavailable"; // update price-field message
+    }
+  };
+
+  // initialize multi selector for product
+  window.addEvent('domready', function() {
+    new Shopify.OptionSelectors("product-select", { product: {{ product | json }}, onVariantSelected: selectCallback }); 
+  });
+-->
+</script>
+

performance/tests/ripen/theme.liquid

@@ -0,0 +1,85 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<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" />
+
+  {{ 'main.css'     | asset_url | stylesheet_tag }}
+	{{ 'shop.js'      | asset_url | script_tag }}
+	
+	{{ 'mootools.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 }}
+
+  {{ content_for_header }}
+ </head>
+ 
+<body id="page-{{template}}">
+<p class="hide"><a href="#navigation">Skip to navigation.</a></p>
+<div id="wrapper">
+	<div class="content clearfix">	
+		<div id="header">
+			<h2><a href="/">{{shop.name}}</a></h2>
+		</div>
+		<div id="left-col">
+			{{ content_for_layout }} 
+		</div>
+		<div id="right-col">
+			{% if template != 'cart' %}
+			    <div id="cart-right-col">
+					<dl id="cart-right-col-info">
+						<dt>Shopping Cart</dt>
+						<dd>
+						{% if cart.item_count != 0 %}
+							<a href="/cart">{{ cart.item_count }} {{ cart.item_count | pluralize: 'item', 'items' }}</a> in your cart
+						{% else %}
+							Your cart is empty
+						{% endif %}
+						</dd>
+					</dl>
+				</div>
+			{% endif %}
+			<div id="search">
+				<dl id="searchbox">
+				<dt>Search</dt>
+				<dd>
+				<form action="/search" method="get">
+				<fieldset>
+				<input class="search-input" type="text" onclick="this.select()" value="Search this shop..." name="q" />
+				</fieldset>
+				</form>
+				</dd>
+				</dl>
+			</div>
+			<div id="navigation">
+				<dl class="navbar">
+				<dt>Navigation</dt>
+				{% for link in linklists.main-menu.links %}
+					<dd>{{ link.title | link_to: link.url }}</dd>
+				{% endfor %}
+				</dl>
+				
+				{% if tags %}
+				<dl class="navbar">
+				<dt>Tags</dt>
+  				{% for tag in collection.tags %} 
+					<dd>{{ tag | highlight_active_tag | link_to_tag: tag }}</dd>
+  				{% endfor %}
+  				</dl>
+				{% endif %}
+			</div>
+		</div>
+		
+	</div>
+    <div id="content-padding"></div>
+</div>
+
+<div id="footer">
+	{% for link in linklists.footer.links %}
+	{{ link.title | link_to: link.url }} {% if forloop.rindex != 1 %} | {% endif %}
+	{% endfor %}
+</div>
+
+</body>
+</html>

performance/tests/tribble/404.liquid

@@ -0,0 +1,56 @@
+	<div id="page" class="innerpage clearfix">
+		
+		<div id="text-page">			
+			<div class="entry">
+				<h1>Oh no!</h1>
+				<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.
+				</div>
+			</div>
+		</div>
+
+		
+		<h1>Featured Products</h1>	
+		<ul class="item-list clearfix">
+		
+			{% for product in collections.frontpage.products %}
+			<li>
+				<form action="/cart/add" method="post">
+				<div class="item-list-item">					
+					<div class="ili-top clearfix">
+						<div class="ili-top-content">
+							<h2><a href="{{product.url}}">{{product.title}}</a></h2>
+							<p>{{ product.description | truncatewords: 15 }}</p>
+						</div>						
+						<a href="{{product.url}}" class="ili-top-image"><img src="{{ product.featured_image | product_img_url: 'small' }}" alt="{{ product.title | escape }}"/></a>	
+					</div>
+					
+					<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>
+						<input type="submit" class="" value="Add to Basket" />
+						<p>
+							<a href="{{product.url}}">View Details</a>	
+							
+							<span>
+								{% if product.compare_at_price %} 			  
+									{% if product.price_min != product.compare_at_price %}			    
+										{{product.compare_at_price | money}} -
+			  						{% endif %}
+								{% endif %}
+								<strong>
+									{{product.price_min | money}}
+								</strong>
+							</span>
+						</p>
+					</div>
+				</div>
+				</form>
+			</li>
+			{% endfor %}
+
+		</ul>
+	</div>
+	<!-- end page -->
+
+
+

performance/tests/tribble/article.liquid

@@ -0,0 +1,98 @@
+
+	<div id="page" class="innerpage clearfix">
+		<div id="text-page">
+
+					<div class="entry">
+						<h1><span>{{article.title}}</span></h1>
+						<div class="entry-post">
+							<div class="meta">{{ article.created_at | date: "%b %d" }}</div>
+							{{ article.content }}
+						</div>
+						
+	<!-- Comments -->
+{% if blog.comments_enabled? %}
+<div id="comments">
+  <h2>Comments</h2>
+  
+  <!-- List all comments -->
+  <ul id="comment-list">
+  {% for comment in article.comments %}
+    <li>
+      <div class="comment">
+        {{ comment.content }}
+      </div>
+      
+  	  <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>
+      </div>
+  	</li>
+  {% endfor %}
+  </ul>
+  
+  <!-- Comment Form -->
+  <div id="comment-form">
+  {% form article %}
+    <h2>Leave a comment</h2>
+    
+    <!-- Check if a comment has been submitted in the last request, and if yes display an appropriate message -->
+    {% if form.posted_successfully? %}
+      {% if blog.moderated? %}
+        <div class="notice">
+          Successfully posted your comment.<br />
+          It will have to be approved by the blog owner first before showing up.
+        </div>
+      {% else %}
+        <div class="notice">Successfully posted your comment.</div>
+      {% endif %}
+    {% endif %}
+    
+    {% if form.errors %}
+      <div class="notice error">Not all the fields have been filled out correctly!</div>
+    {% endif %}
+    
+    <dl>
+      <dt class="{% if form.errors contains 'author' %}error{% endif %}"><label for="comment_author">Your name</label></dt>
+      <dd><input type="text" id="comment_author" name="comment[author]" size="40" value="{{form.author}}" class="{% if form.errors contains 'author' %}input-error{% endif %}" /></dd>
+
+      <dt class="{% if form.errors contains 'email' %}error{% endif %}"><label for="comment_email">Your email</label></dt>
+      <dd><input type="text" id="comment_email" name="comment[email]" size="40" value="{{form.email}}" class="{% if form.errors contains 'email' %}input-error{% endif %}" /></dd>
+
+      <dt class="{% if form.errors contains 'body' %}error{% endif %}"><label for="comment_body">Your comment</label></dt>
+      <dd><textarea id="comment_body" name="comment[body]" cols="40" rows="5" class="{% if form.errors contains 'body' %}input-error{% endif %}">{{form.body}}</textarea></dd>
+    </dl>
+    
+    {% if blog.moderated? %}
+      <p class="hint">comments have to be approved before showing up</p>
+    {% endif %}    
+
+    <input type="submit" value="Post comment" id="comment-submit" />
+  {% endform %}
+  </div>
+  <!-- END Comment Form -->
+  
+</div>
+{% endif %}
+<!-- END Comments -->					
+						
+						
+					</div>
+		</div>
+		
+		<div id="three-reasons" class="clearfix">
+			<h3>Why Shop With Us?</h3>
+			<ul>
+				<li class="two-a">
+					<h4>24 Hours</h4>
+					<p>We're always here to help.</p>
+				</li>
+				<li class="two-c">
+					<h4>No Spam</h4>
+					<p>We'll never share your info.</p>
+				</li>
+				<li class="two-d">
+					<h4>Secure Servers</h4>
+					<p>Checkout is 256bit encrypted.</p>
+				</li>
+			</ul>
+		</div>
+	</div>

performance/tests/tribble/blog.liquid

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

performance/tests/tribble/cart.liquid

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

performance/tests/tribble/collection.liquid

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

performance/tests/tribble/index.liquid

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

performance/tests/tribble/page.liquid

@@ -0,0 +1,56 @@
+	<div id="page" class="innerpage clearfix">
+		
+		<div id="text-page">			
+			<div class="entry">
+				<h1>{{page.title}}</h1>
+				<div class="entry-post">
+					{{page.content}}
+				</div>
+			</div>
+		</div>
+
+		
+		<h1>Featured Products</h1>	
+		<ul class="item-list clearfix">
+		
+			{% for product in collections.frontpage.products %}
+			<li>
+				<form action="/cart/add" method="post">
+				<div class="item-list-item">					
+					<div class="ili-top clearfix">
+						<div class="ili-top-content">
+							<h2><a href="{{product.url}}">{{product.title}}</a></h2>
+							<p>{{ product.description | truncatewords: 15 }}</p>
+						</div>						
+						<a href="{{product.url}}" class="ili-top-image"><img src="{{ product.featured_image | product_img_url: 'small' }}" alt="{{ product.title | escape }}"/></a>	
+					</div>
+					
+					<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>
+						<input type="submit" class="" value="Add to Basket" />
+						<p>
+							<a href="{{product.url}}">View Details</a>	
+							
+							<span>
+								{% if product.compare_at_price %} 			  
+									{% if product.price_min != product.compare_at_price %}			    
+										{{product.compare_at_price | money}} -
+			  						{% endif %}
+								{% endif %}
+								<strong>
+									{{product.price_min | money}}
+								</strong>
+							</span>
+						</p>
+					</div>
+				</div>
+				</form>
+			</li>
+			{% endfor %}
+
+		</ul>
+	</div>
+	<!-- end page -->
+
+
+

performance/tests/tribble/product.liquid

@@ -0,0 +1,116 @@
+<div id="page" class="innerpage clearfix">
+	<h1>{{ collection.title }} {{ product.title }}</h1>
+      
+      
+	<p class="latest-news"><strong>Product Tags: </strong>
+		{% for tag in product.tags %} 
+          	<a href="/collections/all/{{ tag }}">{{ tag }}</a> | 
+          {% endfor %}
+	</p>
+	
+	<div class="product clearfix">
+		<div class="product-info">
+			<h1>{{ product.title }}</h1>
+			<div class="product-info-description">
+				<p>{{ product.description }}	</p>
+			</div>
+			
+			{% if product.available %}
+			<form action="/cart/add" method="post">
+			
+			<h2>Product Options:</h2>
+			
+			<select id="product-info-options" name="id" class="product-info-options">
+        {% for variant in product.variants %}
+          <option value="{{ variant.id }}">{{ variant.title }} - {{ variant.price | money }}</option>
+        {% endfor %}
+			</select>
+			
+			<div id="price-field"></div>
+			
+			<div class="product-purchase-btn">
+				<input type="submit" class="add-this-to-cart" id="add-this-to-cart" value="Add to Basket" />
+			</div>
+			
+			</form>
+			{% else %}
+              <h2>Sold out!</h2>
+              <p>Sorry, we're all out of this product. Check back often and order when it returns</p>
+            	{% endif %}
+		</div>			
+		
+		<div class="product-images clearfix">
+			{% for image in product.images %}
+			
+			{% if forloop.first %}
+			<div class="product-image-large">
+				<img src="{{ image | product_img_url: 'medium'}}" alt="{{product.title | escape }}" />
+			</div>			
+			{% else %}
+			{% endif %}				
+			{% endfor %}
+			
+			<ul class="product-thumbs clearfix">
+			{% for image in product.images %}				
+			{% if forloop.first %}		
+			{% else %}
+			
+			<li>
+			<a href="{{ image | product_img_url: 'large' }}" class="product-thumbs" rel="lightbox[product]" title="">
+			  <img src="{{ image | product_img_url: 'small'}}" alt="{{product.title | escape }}" />
+			</a>
+			</li>
+			{% endif %}				
+			{% endfor %}
+			</ul>
+		</div>
+	</div>
+	
+	
+	
+	<div id="three-reasons" class="clearfix">
+		<h3>Why Shop With Us?</h3>
+		<ul>
+			<li class="two-a">
+				<h4>24 Hours</h4>
+				<p>We're always here to help.</p>
+			</li>
+			<li class="two-c">
+				<h4>No Spam</h4>
+				<p>We'll never share your info.</p>
+			</li>
+			<li class="two-d">
+				<h4>Secure Servers</h4>
+				<p>Checkout is 256bit encrypted.</p>
+			</li>
+		</ul>
+	</div>
+	
+</div>
+<!-- end page -->
+
+<script type="text/javascript">
+<!--
+  // prototype callback for multi variants dropdown selector
+  var selectCallback = function(variant, selector) {
+    if (variant && variant.available == true) {
+      // selected a valid variant
+      $('add-this-to-cart').removeClassName('disabled'); // remove unavailable class from add-to-cart button
+      $('add-this-to-cart').disabled = false;           // reenable add-to-cart button
+      $('price-field').innerHTML = Shopify.formatMoney(variant.price, "{{shop.money_with_currency_format}}");  // update price field
+    } else {
+      // variant doesn't exist
+      $('add-this-to-cart').addClassName('disabled');      // set add-to-cart button to unavailable class
+      $('add-this-to-cart').disabled = true;              // disable add-to-cart button      
+      $('price-field').innerHTML = (variant) ? "Sold Out" : "Unavailable"; // update price-field message
+    }
+  };
+
+  // initialize multi selector for product
+  Event.observe(document, 'dom:loaded', function() {
+    new Shopify.OptionSelectors("product-info-options", { product: {{ product | json }}, onVariantSelected: selectCallback }); 
+  });
+-->
+</script>
+
+		

performance/tests/tribble/search.liquid

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

performance/tests/tribble/theme.liquid

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

performance/tests/vogue/article.liquid

@@ -0,0 +1,66 @@
+<div class="article">
+  <h3 class="article-head-title">{{ article.title }}</h3>
+  <p> posted {{ article.created_at | date: "%Y %h" }} by {{ article.author }}</p>
+  <div class="article-body textile">
+    {{ article.content }}
+  </div>    
+</div>
+
+{% if blog.comments_enabled? %}
+<div id="comments">
+  <h3>Comments</h3>
+  <!-- List all comments -->
+
+  <ul>
+  {% for comment in article.comments %}
+    <li>
+      <div class="comment">
+        {{ comment.content }}
+      </div>
+      
+  	  <div class="comment-details">
+  		  Posted by {{ comment.author }} on {{ comment.created_at | date: "%B %d, %Y" }}
+      </div>
+  	</li>
+  {% endfor %}
+  </ul>
+  
+  <!-- Comment Form -->
+  {% form article %}
+    <h3>Leave a comment</h3>
+    
+    <!-- Check if a comment has been submitted in the last request, and if yes display an appropriate message -->
+    {% if form.posted_successfully? %}
+      {% if blog.moderated? %}
+        <div class="notice">
+          Successfully posted your comment.<br />
+          It will have to be approved by the blog owner first before showing up.
+        </div>
+      {% else %}
+        <div class="notice">Successfully posted your comment.</div>
+      {% endif %}
+    {% endif %}
+    
+    {% if form.errors %}
+      <div class="notice error">Not all the fields have been filled out correctly!</div>
+    {% endif %}
+    
+    <dl>
+      <dt class="{% if form.errors contains 'author' %}error{% endif %}"><label for="comment_author">Your name</label></dt>
+      <dd><input type="text" id="comment_author" name="comment[author]" size="40" value="{{form.author}}" class="{% if form.errors contains 'author' %}input-error{% endif %}" /></dd>
+
+      <dt class="{% if form.errors contains 'email' %}error{% endif %}"><label for="comment_email">Your email</label></dt>
+      <dd><input type="text" id="comment_email" name="comment[email]" size="40" value="{{form.email}}" class="{% if form.errors contains 'email' %}input-error{% endif %}" /></dd>
+
+      <dt class="{% if form.errors contains 'body' %}error{% endif %}"><label for="comment_body">Your comment</label></dt>
+      <dd><textarea id="comment_body" name="comment[body]" cols="40" rows="5" class="{% if form.errors contains 'body' %}input-error{% endif %}">{{form.body}}</textarea></dd>
+    </dl>
+    
+    {% if blog.moderated? %}
+      <p class="hint">comments have to be approved before showing up</p>
+    {% endif %}    
+
+    <input type="submit" value="Post comment" />
+  {% endform %}
+</div>
+{% endif %}

performance/tests/vogue/blog.liquid

@@ -0,0 +1,32 @@
+<div id="shop-id-label_about">
+<h3 class="article-head-title">{{page.title}}</h3>
+
+{% paginate blog.articles by 20 %}
+
+  {% for article in blog.articles  %}
+    <div class="article">
+      <h3 class="article-head-title">
+        <a href="{{article.url}}">{{ article.title }}</a>
+      </h3>
+      
+      <p>
+      {% if blog.comments_enabled? %}
+        <a href="{{article.url}}#comments">{{ article.comments_count }} comments</a>
+        &mdash; 
+      {% endif %}
+      posted {{ article.created_at | date: "%Y %h" }} by {{ article.author }}</p>
+      <div class="article-body textile">
+        {{ article.content }}
+      </div>    
+    </div>
+  {% endfor %}
+
+  <div id="pagination">
+    {{ paginate | default_pagination }}
+  </div>
+
+{% endpaginate %}
+
+
+</div>
+<div class="clear-me"></div>

performance/tests/vogue/cart.liquid

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

performance/tests/vogue/collection.liquid

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

performance/tests/vogue/index.liquid

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

performance/tests/vogue/page.liquid

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

performance/tests/vogue/product.liquid

@@ -0,0 +1,62 @@
+<div id="product-left">
+	{% for image in product.images %}{% if forloop.first %}<div id="product-image">
+		<a href="{{ image | product_img_url: 'large' }}" rel="lightbox[images]" title="{{ product.title | escape }}"><img src="{{ image | product_img_url: 'medium' }}" alt="{{ product.title | escape }}" /></a>
+	</div>{% else %}
+	<div class="product-images">
+		<a href="{{ image | product_img_url: 'large' }}" rel="lightbox[images]" title="{{ product.title | escape }}"><img src="{{ image | product_img_url: 'small' }}" alt="{{ product.title | escape }}" /></a>
+	</div>{% endif %}{% endfor %}
+</div>
+<div id="product-right">
+	<h1>{{ product.title }}</h1>
+	{{ product.description }}
+	
+	{% if product.available %}
+	<form action="/cart/add" method="post">
+
+	  <div id="product-variants">
+      <div id="price-field"></div>
+
+      <select id="product-select" name='id'>
+        {% for variant in product.variants %}
+          <option value="{{ variant.id }}">{{ variant.title }} - {{ variant.price | money }}</option>
+        {% endfor %}
+      </select>
+		</div>
+
+    <input type="image" src="{{ 'purchase.png' | asset_url }}" name="add" value="Purchase" id="purchase" />
+	</form>
+	{% else %}
+	  <p class="bold-red">This product is temporarily unavailable</p>
+	{% endif %}
+
+	<div id="product-details">
+		<strong>Continue Shopping</strong><br />
+		Browse more {{ product.type | link_to_type }} or additional {{ product.vendor | link_to_vendor }} products.
+	</div>
+</div>
+
+
+<script type="text/javascript">
+<!--
+  // mootools callback for multi variants dropdown selector
+  var selectCallback = function(variant, selector) {
+    if (variant && variant.available == true) {
+      // selected a valid variant
+      $('purchase').removeClass('disabled'); // remove unavailable class from add-to-cart button
+      $('purchase').disabled = false;           // reenable add-to-cart button
+      $('price-field').innerHTML = Shopify.formatMoney(variant.price, "{{shop.money_with_currency_format}}");  // update price field
+    } else {
+      // variant doesn't exist
+      $('purchase').addClass('disabled');      // set add-to-cart button to unavailable class
+      $('purchase').disabled = true;              // disable add-to-cart button      
+      $('price-field').innerHTML = (variant) ? "Sold Out" : "Unavailable"; // update price-field message
+    }
+  };
+
+  // initialize multi selector for product
+  window.addEvent('domready', function() {
+    new Shopify.OptionSelectors("product-select", { product: {{ product | json }}, onVariantSelected: selectCallback }); 
+  });
+-->
+</script>
+

performance/tests/vogue/theme.liquid

@@ -0,0 +1,122 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+
+<head>
+<title>{{ shop.name }} &mdash; {{ page_title }}</title>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+
+{{ 'stylesheet.css' | asset_url | stylesheet_tag }}
+
+<!-- Additional colour schemes for this theme. If you want to use them, just replace the above line with one of these
+{{ 'caramel.css' | asset_url | stylesheet_tag }}
+{{ 'sea.css' | asset_url | stylesheet_tag }}
+-->
+
+{{ 'mootools.js'        | global_asset_url  | script_tag }}
+{{ 'slimbox.js'         | global_asset_url  | script_tag }}
+{{ 'option_selection.js' | shopify_asset_url | script_tag }}
+
+{{ content_for_header }}
+</head>
+
+<body id="page-{{ template }}">
+
+<div id="header">
+	<div class="container">
+		<div id="logo">
+			<h1><a href="/" title="{{ shop.name }}">{{ shop.name }}</a></h1>
+		</div>
+		<div id="navigation">
+			<ul id="navigate">
+				<li><a href="/cart">View Cart</a></li>
+			  {% for link in linklists.main-menu.links reversed %}
+				  <li><a href="{{ link.url }}">{{ link.title }}</a></li>
+				{% endfor %}
+			</ul>
+		</div>
+	</div>
+</div>
+
+<div id="mini-header">
+	<div class="container">
+		<div id="shopping-cart">
+			<a href="/cart">Your shopping cart contains {{ cart.item_count }} {{ cart.item_count | pluralize: 'item', 'items' }}</a>
+		</div>
+		<div id="search-box">
+			<form action="/search" method="get">
+				<input type="text" name="q" id="q" />
+				<input type="image" src="{{ 'seek.png' | asset_url }}" value="Seek" onclick="this.parentNode.submit(); return false;" id="seek" />
+			</form>
+		</div>
+	</div>
+</div>
+
+<div id="layout">
+	<div class="container">
+		<div id="layout-left" {% if template != "cart" %}{% if template != "product" %}style="width:619px"{% endif %}{% endif %}>{% if template == "search" %}
+			<h1>Search Results</h1>{% endif %}
+			{{ content_for_layout }}
+		</div>{% if template != "cart" %}{% if template != "product" %}
+
+		<div id="layout-right">
+			{% if template == "index" %}
+			{% if blogs.news.articles.size > 1 %}
+    	<a href="{{ shop.url }}/blogs/news.xml"><img src="{{ 'feed.png' | asset_url }}" alt="Subscribe" class="feed" /></a>
+    	<h3><a href="/blogs/news">More news</a></h3>
+    	<ul id="blogs">{% for article in blogs.news.articles limit: 6 offset: 1 %}
+    		<li><a href="{{ article.url }}">{{ article.title | strip_html | truncate: 30 }}</a><br />
+    			<small>{{ article.content | strip_html | truncatewords: 12 }}</small>
+    		</li>{% endfor %}
+    	</ul>
+    	{% endif %}
+    	{% endif %}
+    	
+    	{% if template == "collection" %}
+    	<h3>Collection Tags</h3>
+    	<div id="tags">{% if collection.tags.size == 0 %}
+    		No tags found.{% else %}
+    		<span class="tags">{% for tag in collection.tags %}{% if current_tags contains tag %} {{ tag | highlight_active_tag | link_to_remove_tag: tag }}{% else %} {{ tag | highlight_active_tag | link_to_add_tag: tag }}{% endif %}{% unless forloop.last %}, {% endunless %}{% endfor %}</span>{% endif %}
+    	</div>
+    	{% endif %}
+
+      <h3>Navigation</h3>
+      <ul id="links">
+      {% for link in linklists.main-menu.links %}
+				<li><a href="{{ link.url }}">{{ link.title }}</a></li>
+			{% endfor %}
+		  </ul>
+    	
+		  {% if template != "page" %}
+			<h3>Featured Products</h3>
+			<ul id="featuring">{% for product in collections.frontpage.products limit: 6 %}
+				<li class="featuring-list">
+				  <div class="featuring-image">
+						<a href="{{ product.url | within: collections.frontpage }}" title="{{ product.title | escape }} &mdash; {{ product.description | strip_html | truncate: 50 }}"><img src="{{ product.images.first | product_img_url: 'icon' }}" alt="{{ product.title | escape }}" /></a>
+					</div>
+					<div class="featuring-info">
+						<a href="{{ product.url | within: collections.frontpage }}">{{ product.title | strip_html | truncate: 28 }}</a><br />
+						<small><span class="light">from</span> {{ product.price | money }}</small>
+					</div>
+				</li>{% endfor %}
+			</ul>
+			{% endif %}
+		</div>{% endif %}{% endif %}
+	</div>
+</div>
+
+<div id="footer">
+	<div id="footer-fader">
+		<div class="container">
+			<div id="footer-right">{% for link in linklists.footer.links %}
+				{{ link.title | link_to: link.url }} {% unless forloop.last %}&#124;{% endunless %}{% endfor %}
+			</div>
+			<span id="footer-left">
+				Copyright &copy; {{ "now" | date: "%Y" }} <a href="/">{{ shop.name }}</a>. All Rights Reserved. All prices {{ shop.currency }}.<br />
+				This website is powered by <a href="http://www.shopify.com">Shopify</a>.
+			</span>
+		</div>
+	</div>
+</div>
+	
+</body>
+</html>

performance/theme_runner.rb

@@ -0,0 +1,107 @@
+# This profiler run simulates Shopify.
+# We are looking in the tests directory for liquid files and render them within the designated layout file.
+# We will also export a substantial database to liquid which the templates can render values of. 
+# All this is to make the benchmark as non syntetic as possible. All templates and tests are lifted from
+# direct real-world usage and the profiler measures code that looks very similar to the way it looks in 
+# Shopify which is likely the biggest user of liquid in the world which something to the tune of several 
+# million Template#render calls a day. 
+
+require 'rubygems'
+require 'active_support'
+require 'yaml'
+require 'digest/md5'
+require File.dirname(__FILE__) + '/shopify/liquid'
+require File.dirname(__FILE__) + '/shopify/database.rb'
+
+class ThemeRunner
+
+  # Load all templates into memory, do this now so that 
+  # we don't profile IO. 
+  def initialize
+    @tests = Dir[File.dirname(__FILE__) + '/tests/**/*.liquid'].collect do |test|
+      next if File.basename(test) == 'theme.liquid'
+
+      theme_path = File.dirname(test) + '/theme.liquid'
+
+      [File.read(test), (File.file?(theme_path) ? File.read(theme_path) : nil), test]
+    end.compact
+  end  
+
+  def compile
+    # Dup assigns because will make some changes to them
+
+    @tests.each do |liquid, layout, template_name|
+      tmpl = Liquid::Template.new
+      tmpl.parse(liquid)
+      tmpl = Liquid::Template.new
+      tmpl.parse(layout)
+    end
+  end
+
+   def run
+    # Dup assigns because will make some changes to them
+    assigns = Database.tables.dup
+
+    @tests.each do |liquid, layout, template_name|
+
+      # Compute page_tempalte outside of profiler run, uninteresting to profiler
+      page_template = File.basename(template_name, File.extname(template_name))
+      compile_and_render(liquid, layout, assigns, page_template) 
+       
+    end
+  end
+
+
+  def run_profile
+    RubyProf.measure_mode = RubyProf::PROCESS_TIME
+
+    # Dup assigns because will make some changes to them
+    assigns = Database.tables.dup
+
+    @tests.each do |liquid, layout, template_name|
+
+      # Compute page_tempalte outside of profiler run, uninteresting to profiler
+      html = nil
+      page_template = File.basename(template_name, File.extname(template_name))
+
+      unless @started
+        RubyProf.start
+        RubyProf.pause
+        @started = true
+      end
+
+      html = nil
+
+      RubyProf.resume
+      html = compile_and_render(liquid, layout, assigns, page_template) 
+      RubyProf.pause
+      
+
+      # return the result and the MD5 of the content, this can be used to detect regressions between liquid version
+      $stdout.puts "* rendered template %s, content: %s" % [template_name, Digest::MD5.hexdigest(html)]
+ 
+      # Uncomment to dump html files to /tmp so that you can inspect for errors
+      # File.open("/tmp/#{File.basename(template_name)}.html", "w+") { |fp| fp <<html}
+    end
+
+    RubyProf.stop
+  end
+
+  def compile_and_render(template, layout, assigns, page_template)    
+    tmpl = Liquid::Template.new
+    tmpl.assigns['page_title'] = 'Page title'
+    tmpl.assigns['template'] = page_template
+
+    content_for_layout = tmpl.parse(template).render(assigns)
+
+    if layout
+      assigns['content_for_layout'] = content_for_layout      
+      tmpl.parse(layout).render(assigns)
+    else
+      content_for_layout
+    end    
+  end
+end
+
+
+

test/assign_test.rb

@@ -1,11 +0,0 @@
-require File.dirname(__FILE__) + '/helper'
-
-class IfElseTest < Test::Unit::TestCase
-  include Liquid
-  
-  def test_with_filtered_expressions
-    assert_template_result('foo','{% assign foo = values|sort|last %}{{ foo }}', 'values' => %w{foo bar baz})
-    assert_template_result('foo','{% assign sorted = values|sort %}{{ sorted | last }}', 'values' => %w{foo bar baz})
-  end
-
-end

test/extra/breakpoint.rb

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

test/extra/caller.rb

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

test/helper.rb

@@ -1,20 +0,0 @@
-#!/usr/bin/env ruby
-$LOAD_PATH.unshift(File.dirname(__FILE__)+ '/extra')
-
-require 'test/unit'
-require 'test/unit/assertions'
-require 'caller'
-require 'breakpoint'
-require File.dirname(__FILE__) + '/../lib/liquid'
-
-
-module Test
-  module Unit
-    module Assertions
-        include Liquid
-        def assert_template_result(expected, template, assigns={}, message=nil)
-          assert_equal expected, Template.parse(template).render(assigns)
-        end 
-    end
-  end
-end