liquidprof 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+examples/
+test/liquid/lib
+test/liquid/test/liquid
+test/liquid/test/liquid_test_helper.rb

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+script: bundle exec rake
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - ruby-head
+  - rbx-19mode
+  - jruby-19mode
+matrix:
+  allow_failures:
+    - rvm: ruby-head

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,21 @@
+PATH
+  remote: .
+  specs:
+    liquidprof (0.0.1)
+      liquid (~> 2.5)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    liquid (2.5.0)
+    minitest (5.0.6)
+    rake (10.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  liquidprof!
+  minitest (~> 5.0)
+  rake

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Florian Weingarten
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,94 @@
+LiquidProf
+==========
+
+LiquidProf is a simple profiler for the [Liquid](https://github.com/Shopify/liquid)
+templating language, inspired by [rblineprof](https://github.com/tmm1/rblineprof).
+
+This is work in progress and not really ready to use!
+
+Installation
+------------
+* ```gem install liquidprof``` (https://rubygems.org/gems/liquidprof)
+
+Profiling
+---------
+
+Wrapping your ```parse()``` and ```render()``` calls in a
+```LiquidProf::Profiler.profile``` block will profile the containing
+templates and return a Profiler object which encapsulates the profiling
+results of each of the templates.
+
+```ruby
+prof = LiquidProf::Profiler.profile(10) do
+  template1 = Liquid::Template.parse(str1)
+  output1 = template1.render()
+
+  template2 = Liquid::Template.new
+  template2.parse(str2)
+  output2 = template2.render()
+end
+```
+
+A bit more explicit:
+
+```ruby
+prof = LiquidProf::Profiler.start
+template = Liquid::Template.parse(str)
+prof.profile(template, 10)
+LiquidProf::Profiler.stop
+```
+
+Reporting
+---------
+```ruby
+puts LiquidProf::AsciiReporter.report(prof, template)
+```
+
+will generate a report like this:
+
+```
+    +----------------------+
+ 1  |      1x, 0.05ms, 0B  |  {% assign user = "flo" %}
+ 2  |                      |
+ 3  |      1x, 0.05ms, 3B  |  Hello {{ user }},
+ 4  |                      |
+ 5  |                      |  this is an example Liquid template.
+ 6  |                      |
+ 7  |      1x, 0.00ms, 0B  |  {% comment %}
+ 8  |      0x, 0.00ms, 0B  |  {% assign user = "florian" %}
+ 9  |                      |  {% endcomment %}
+10  |                      |
+11  |      1x, 4.97ms, 0B  |  {% capture test %}
+12  |      1x, 0.02ms, 0B  |    {% assign c = 0 %}
+13  |   1x, 4.92ms, 1.53K  |    {% for i in (1..10) %}
+14  |    10x, 0.16ms, 60B  |      {% if i % 2 == 0 %} even {% endif %}
+15  |  10x, 4.45ms, 1.34K  |      {% for j in (i..10) %}
+16  |   55x, 0.09ms, 100B  |        {% increment c %}: {{ i }} + {{ j }} = {{ i + j }}
+    |    55x, 0.55ms, 56B  |
+    |    55x, 0.51ms, 65B  |
+    |    55x, 0.52ms, 56B  |
+17  |                      |      {% endfor %}
+18  |                      |    {% endfor %}
+19  |                      |  {% endcapture %}
+20  |                      |
+21  |      1x, 0.01ms, 1B  |  {{ c }}: {{ test }}
+    |   1x, 0.01ms, 1.54K  |
+22  |                      |
+23  |      1x, 0.01ms, 3B  |  Bye {{ user }}.
+    +----------------------+
+            5.19ms, 1.60K
+```
+
+TODO
+----
+* Fancy HTML reporter, possibly using [highlight.js](http://softwaremaniacs.org/soft/highlight/en/description/)
+
+Tests
+-----
+* Run ```./add_liquid_tests.sh <path_to_liquid_git_repo>```
+* Run ```rake test``` to run LiquidProf tests
+* Run ```rake test_liquid``` to run Liquid tests with LiquidProf profiling enabled
+
+Bugs
+----
+* LiquidProf is not thread-safe in some situations. Enabling/disabling the profiler in one thread will do so for all other threads as well.

data/Rakefile

@@ -0,0 +1,24 @@
+require 'rake/testtask'
+require 'rubygems/package_task'
+
+gemspec = eval(File.read('liquidprof.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/liquidprof-#{gemspec.version}.gem"
+end
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+end
+
+Rake::TestTask.new(:test_liquid) do |t|
+  t.test_files = FileList['test/liquid/test/liquid/*_test.rb']
+  t.libs << 'test/liquid/test'
+end
+
+desc "Run tests"
+task :default => :test

data/TODO

@@ -0,0 +1,13 @@
+* Tests
+  * All tags are counted correctly
+    * n times in loops
+    * 0 times in anevaluated branches
+    * 0 times in comment and raw
+    * inherited tags are counted correctly
+  * output byte length is correct and adds up
+  * min < average < max always holds
+  * stddev correct?
+
+* Package as gem
+  * Travis CI
+  * Rubygems

data/add_liquid_tests.sh

@@ -0,0 +1,10 @@
+#!/bin/sh
+if [ "$#" -ne 1 ] || ! [ -d "$1" ]; then
+  echo "Usage: $0 <directory to liquid source tree>" >&2
+  exit 1
+fi
+
+LIQUID=$(readlink -e $1)
+ln -s $LIQUID/lib test/liquid/lib
+ln -s $LIQUID/test/liquid test/liquid/test/liquid
+ln -s $LIQUID/test/test_helper.rb test/liquid/test/liquid_test_helper.rb

data/cli.rb

@@ -0,0 +1,8 @@
+require "liquidprof"
+
+prof = LiquidProf::Profiler.profile(1) do
+  input = STDIN.read
+  Liquid::Template.parse(input).render
+end
+
+puts LiquidProf::AsciiReporter.report(prof)

data/lib/liquidprof.rb

@@ -0,0 +1,5 @@
+require "liquid"
+require "liquidprof/version"
+require "liquidprof/profiler"
+require "liquidprof/reporter"
+require "liquidprof/ascii_reporter"

data/lib/liquidprof/ascii_reporter.rb

@@ -0,0 +1,73 @@
+module LiquidProf
+  class AsciiReporter < Reporter
+    def format_node_stats(stats, skip_times=false)
+      [
+        skip_times ? nil : ("%dx" % stats[:calls][:avg]),
+        "%.2fms" % (1000.0 * stats[:times][:avg]),
+        format_bytes(stats[:lengths][:avg])
+      ].compact.join(", ")
+    end
+
+    def self.report(prof)
+      AsciiReporter.new(prof).report()
+    end
+
+    def report
+      output = ""
+      @prof.templates.each do |template|
+        output << report_template(template)
+        output << "\n"
+        output << "\n" if @prof.templates.length > 1
+      end
+      output
+    end
+
+    def report_template(template)
+      summarize_stats(template)
+      sidenotes = Hash.new{ Array.new }
+      res = render_source(template) do |node, line|
+        sidenotes[line] += [ @prof.stats[node] ]
+        node.raw_markup
+      end
+      sidenotes = sidenotes.inject(Array.new) do |a,(k,v)|
+        a[k] = v.map{ |stats| format_node_stats(stats) }
+        a
+      end
+
+      output = []
+      res.each_with_index do |line, i|
+        (sidenotes[i] || [""]).each_with_index do |note, j|
+          output << ((j == 0) ? [ (i+1).to_s, note, line] : [ "", note, "" ])
+        end
+      end
+
+      output << [ "", format_node_stats(@prof.stats[template.root], true), "" ]
+      format_table(output)
+    end
+
+    def format_table(lines)
+      max_width = []
+
+      lines.each do |line|
+        line.each_with_index do |column, i|
+          next if i == line.length-1
+          max_width[i] = [ max_width[i], column.length ].compact.max
+        end
+      end
+
+      lines.each do |line|
+        line.each_with_index do |column, i|
+          next if i == line.length-1
+          line[i] = column.rjust(max_width[i])
+        end
+      end
+
+      table = ""
+      table << [ " " * (max_width[0]+2), "-" * (max_width[1]+4), "" ].join("+") + "\n"
+      table << lines[0..-2].map{ |line| line.join("  |  ") }.join("\n") + "\n"
+      table << [ " " * (max_width[0]+2), "-" * (max_width[1]+4), "" ].join("+") + "\n"
+      table << lines.last.join("     ").rjust(max_width[1])
+      table
+    end
+  end
+end

data/lib/liquidprof/profiler.rb

@@ -0,0 +1,193 @@
+module LiquidProf
+  class Profiler
+    attr_accessor :stats, :templates
+
+    def stats_init(root)
+      if root.class == Liquid::Template
+        return stats_init(root.root)
+      end
+
+      Profiler.dfs(root) do |node, pos|
+        next unless pos == :pre
+        next if node.class == String
+        stats_init_node(node)
+      end
+    end
+
+    def profile(template, iterations=1, *args)
+      output = ""
+      @templates << template
+      iterations.times do
+        stats_init(template)
+        output = template.render!(*args)
+      end
+      output
+    end
+
+    def remove_raw_markup
+      Profiler.unhook(:create_variable, Liquid::Block)
+      Profiler.unhook(:initialize, Liquid::Tag)
+      Profiler.unhook(:end_tag, Liquid::Block)
+    end
+
+    def add_raw_markup
+      Profiler.hook(:create_variable, Liquid::Block) do |node, method, args|
+        var = method.(*args)
+        var.instance_variable_set :@raw_markup, args.first
+        var.class.class_eval { attr_reader :raw_markup }
+        var
+      end
+
+      Profiler.hook(:initialize, Liquid::Tag) do |node, method, args|
+        method.(*args)
+        node.instance_variable_set :@raw_markup, "{% " + (args[0].strip + " " + args[1].strip).strip + " %}"
+        node.class.class_eval { attr_reader :raw_markup }
+      end
+
+      Profiler.hook(:end_tag, Liquid::Block) do |node, method, args|
+        node.instance_variable_set :@raw_markup_end, "{% #{node.block_delimiter} %}"
+        node.class.class_eval { attr_reader :raw_markup_end }
+        method.(*args)
+      end
+    end
+
+    def remove_profiling(tags)
+      Profiler.unhook(:render, tags)
+    end
+
+    def add_profiling(tags)
+      Profiler.hook(:render, tags) do |node, method, args|
+        output = nil
+        start = Time.now
+        output = method.(*args)
+        time = Time.now - start
+        stats_inc(node, time, output.to_s.length)
+        output
+      end
+    end
+
+    private
+
+    def initialize(tags)
+      @stats = {}
+      @templates = []
+      add_profiling(tags)
+      add_raw_markup()
+    end
+
+    def stats_init_node(node)
+      @stats[node] ||= {}
+      [:calls, :times, :lengths].each do |field|
+        @stats[node][field] ||= {}
+        @stats[node][field][:raw] ||= []
+        @stats[node][field][:raw] << 0
+      end
+    end
+
+    def stats_inc(node, time, length)
+      return unless @stats[node]
+      @stats[node][:calls][:raw][-1] += 1
+      @stats[node][:times][:raw][-1] += time
+      @stats[node][:lengths][:raw][-1] += length
+    end
+
+    class << self
+      def profiler
+        @@profiler
+      end
+
+      def start
+        @@profiler ||= Profiler.new(Profiler.all_tags() + [Liquid::Variable])
+      end
+
+      def stop
+        return unless @@profiler
+        tags = Profiler.all_tags() + [Liquid::Variable]
+        @@profiler.remove_profiling(tags)
+        @@profiler.remove_raw_markup()
+        prof = @@profiler
+        @@profiler = nil
+        prof
+      end
+
+      def profile(iterations=1, &block)
+        prof = Profiler.start
+
+        hook(:parse, Liquid::Template) do |template, method, args|
+          method.(*args)
+        end
+
+        hook(:render, Liquid::Template) do |template, method, args|
+          output = ""
+          prof.templates << template
+          iterations.times do
+            prof.stats_init(template)
+            output = method.(*args)
+          end
+          output
+        end
+
+        yield
+
+        unhook(:parse, Liquid::Template)
+        unhook(:render, Liquid::Template)
+        Profiler.stop
+      end
+
+      def all_tags
+        ObjectSpace.each_object(Class).select { |klass| klass <= Liquid::Tag }
+      end
+
+      def dfs(root, &block)
+        block.yield(root, :pre)
+        if root.respond_to?(:nodelist) && root.nodelist
+          root.nodelist.each do |child|
+            dfs(child, &block)
+          end
+        end
+        block.yield(root, :post)
+      end
+
+      def hook(method_name, tags, &block)
+        [tags].flatten.each do |tag|
+          tag.class_exec(block, tag) do |block, tag|
+            hooked_name = LiquidProf::Profiler.hooked(method_name, tag)
+            unhooked_name = LiquidProf::Profiler.unhooked(method_name, tag)
+
+            define_method(hooked_name) do |*args|
+              owner = self.class.instance_method(method_name).owner
+              if method_name != :render || (self.class == owner && owner == tag)
+                block.yield(self, method(unhooked_name), args)
+              else
+                send(unhooked_name, *args)
+              end
+            end
+
+            alias_method unhooked_name, method_name
+            alias_method method_name, hooked_name
+          end
+        end
+      end
+
+      def unhook(method_name, tags)
+        [tags].flatten.each do |tag|
+          tag.class_eval do |tag|
+            if method_defined?(LiquidProf::Profiler.hooked(method_name, tag))
+              alias_method method_name, LiquidProf::Profiler.unhooked(method_name, tag)
+              remove_method LiquidProf::Profiler.hooked(method_name, tag)
+              remove_method LiquidProf::Profiler.unhooked(method_name, tag)
+            end
+          end
+        end
+      end
+
+      def hooked(method_name, tag)
+        "#{method_name}_#{tag}_hooked"
+      end
+
+      def unhooked(method_name, tag)
+        "#{method_name}_#{tag}_unhooked"
+      end
+    end
+  end
+end

data/lib/liquidprof/reporter.rb

@@ -0,0 +1,73 @@
+module LiquidProf
+  class Reporter
+    attr_reader :prof
+
+    def initialize(prof)
+      @prof = prof
+    end
+
+    def summarize_stats(template)
+      Profiler.dfs(template.root) do |node, pos|
+        next unless pos == :pre
+        next unless prof.stats.key?(node)
+        node_summarize_stats(prof.stats[node])
+      end
+      self
+    end
+
+    def format_bytes(bytes)
+      units = ["B", "K", "M"]
+
+      if bytes.to_i < 1024
+        exponent = 0
+      else
+        exponent = (Math.log(bytes)/Math.log(1024)).to_i
+        bytes /= 1024 ** [exponent, units.size].min
+      end
+
+      if exponent == 0
+        "#{bytes.to_i}#{units[exponent]}"
+      else
+        "%.2f%s" % [ bytes, units[exponent] ]
+      end
+    end
+
+    private
+
+    def node_summarize_stats(stats)
+      [:calls, :times, :lengths].each do |field|
+        raw = stats[field][:raw]
+        stats[field][:avg] = mu = avg(raw)
+        stats[field][:max] = raw.max || 0
+        stats[field][:min] = raw.min || 0
+        stats[field][:dev] = raw.length == 1 ? 0.0 : Math.sqrt(raw.inject(0){ |s,i| s + (i - mu)**2 } / (raw.length-1).to_f)
+      end
+    end
+
+    def avg(array)
+      array.length > 0 ? (array.inject(0){ |s,i| s + i }.to_f / array.length.to_f) : 0.0
+    end
+
+    def render_source(template)
+      res = ""
+      line = 0
+      Profiler.dfs(template.root) do |node, pos|
+        next if node.class == Liquid::Document
+        if pos == :pre
+          res << if node.class == String
+            line += node.scan(/\r?\n/).length
+            node
+          else
+            yield(node, line)
+          end
+        else
+          if node.respond_to?(:raw_markup_end)
+            res << node.raw_markup_end
+            next
+          end
+        end
+      end
+      res.split(/\r?\n/)
+    end
+  end
+end

data/lib/liquidprof/version.rb

@@ -0,0 +1,3 @@
+module LiquidProf
+  VERSION = "0.0.1"
+end

data/liquidprof.gemspec

@@ -0,0 +1,24 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'liquidprof/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "liquidprof"
+  spec.version       = LiquidProf::VERSION
+  spec.authors       = ["Florian Weingarten"]
+  spec.email         = ["flo@hackvalue.de"]
+  spec.description   = %q{Liquid profiler}
+  spec.summary       = %q{Performance profiler for the Liquid templating language}
+  spec.homepage      = "https://github.com/fw42/liquidprof"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "liquid", "~> 2.5"
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest", "~> 5.0"
+end

data/test/liquid/test/test_helper.rb

@@ -0,0 +1,6 @@
+$LOAD_PATH.unshift File.expand_path('../lib', File.dirname(__FILE__))
+
+require "liquidprof"
+LiquidProf::Profiler.start
+
+require File.expand_path("liquid_test_helper.rb", File.dirname(__FILE__))

data/test/test.rb

@@ -0,0 +1,60 @@
+require "test_helper.rb"
+
+class SomeTestClass
+  def foo(*args)
+    return *args
+  end
+end
+
+class LiquidProfTest < Minitest::Test
+  def test_hooking_and_unhooking_works
+    called = false
+    LiquidProf::Profiler.hook(:foo, SomeTestClass) do |node, method, args|
+      called = true
+      args.reverse!
+      method.(*args)
+    end
+    obj = SomeTestClass.new
+    assert_equal [3,2,1], obj.foo(1,2,3)
+    assert called
+    LiquidProf::Profiler.unhook(:foo, SomeTestClass)
+    assert_equal [1,2,3], obj.foo(1,2,3)
+  end
+
+  EXAMPLES = [
+    [ Liquid::Variable, "{{ 'foo' }}", 3 ],
+    [ Liquid::Assign, "{% assign foo = 'bar' %}", 0 ],
+    [ Liquid::Variable, "{% assign foo = 'bar' %} {{ foo }}", 3 ],
+    [ Liquid::Assign, "{% assign foo = 'bar' %} {{ foo }}", 0 ],
+    [ Liquid::Raw, "{% raw %} {{ 'foo' }} {% endraw %}", 13 ],
+    [ Liquid::Variable, "{% raw %} {{ 'foo' }} {% endraw %}", 0, false ],
+  ]
+
+  EXAMPLES.each_with_index do |example, index|
+    define_method "test_#{example[0]}_#{index}_stats_are_sound" do
+      prof = profile(example[1])
+      stats = get_stats_for_tag(prof, example[0])
+      assert example[3] == false ? 0 : 1, stats.length
+      assert_stats 1, 1, example[2], stats
+    end
+  end
+
+  private
+
+  def get_stats_for_tag(prof, tag)
+    stats = []
+    LiquidProf::Profiler.dfs(prof.templates.first.root) do |node, pos|
+      if node.class == tag
+        stats << node
+      end
+    end
+    stats.uniq.map{ |node| prof.stats[node] }
+  end
+
+  def assert_stats(nodes, calls, length, stats)
+    stats.each do |stat|
+      assert_equal calls, stat[:calls][:raw][0]
+      assert_equal length, stat[:lengths][:raw][0]
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,122 @@
+require 'bundler/setup'
+require 'minitest/autorun'
+require 'minitest/unit'
+require 'minitest/pride'
+
+$LOAD_PATH.unshift File.expand_path('../../lib', File.dirname(__FILE__))
+require "liquidprof"
+
+def assert_profile_result(expected, template_str)
+  assert_equal expected, profile(template_str)
+end
+
+def profile(template_str)
+  profs = [*1..5].map do |i|
+    assert_profile_syntax_doesnt_matter(template_str, i)
+  end
+  assert_profile_iterations_dont_matter(*profs)
+  assert_raw_markup_present(profs.first.templates.first.root)
+  profs.first
+end
+
+def assert_raw_markup_present(root)
+  if root.class != Liquid::Document && (root.is_a?(Liquid::Tag) || root.is_a?(Liquid::Variable))
+    assert root.instance_variable_defined?(:@raw_markup)
+  end
+
+  if root.class != Liquid::Document && root.is_a?(Liquid::Block)
+    assert root.instance_variable_defined?(:@raw_markup_end)
+  end
+
+  if root.respond_to?(:nodelist) && root.nodelist
+    root.nodelist.each do |child|
+      assert_raw_markup_present(child)
+    end
+  end
+end
+
+def assert_stats_equal(prof1, prof2)
+  assert_equal prof1.stats.length, prof2.stats.length
+  keys1 = prof1.stats.keys.sort_by{ |node| node.class.to_s }
+  keys2 = prof2.stats.keys.sort_by{ |node| node.class.to_s }
+  assert_equal keys1.map(&:class).map(&:to_s), keys2.map(&:class).map(&:to_s)
+
+  keys1.each_index do |i|
+    k1, k2 = keys1[i], keys2[i]
+    assert_equal prof1.stats[k1][:times][:raw].length, prof2.stats[k2][:times][:raw].length
+    assert_equal prof1.stats[k1][:calls], prof2.stats[k2][:calls]
+    assert_equal prof1.stats[k1][:lengths], prof2.stats[k2][:lengths]
+  end
+end
+
+def assert_profile_iterations_dont_matter(*profs)
+  profs.each_index do |i|
+    profs[i] = profs[i].stats.values.sort_by{ |h| h.to_s }
+  end
+
+  profs.first.each_index do |i|
+    0.upto(profs.length-2) do |j|
+      (j+1).upto(profs.length-1) do |k|
+        [ :avg, :min, :max ].each do |field|
+          assert_equal profs[j][i][:calls][field], profs[k][i][:calls][field]
+          assert_equal profs[j][i][:lengths][field], profs[k][i][:lengths][field]
+        end
+      end
+    end
+  end
+end
+
+def assert_profile_syntax_doesnt_matter(template_str, iterations=1, template_iterations=2)
+  profs = []
+  templates = []
+  outputs = []
+
+  profs << LiquidProf::Profiler.start
+  template_iterations.times do
+    templates << Liquid::Template.new
+    templates.last.parse(template_str)
+    outputs << profs.last.profile(templates.last, iterations)
+  end
+  LiquidProf::Profiler.stop
+
+  profs << LiquidProf::Profiler.start
+  template_iterations.times do
+    templates << Liquid::Template.parse(template_str)
+    outputs << profs.last.profile(templates.last, iterations)
+  end
+  LiquidProf::Profiler.stop
+
+  profs << LiquidProf::Profiler.profile(iterations) do
+    template_iterations.times do
+      templates << Liquid::Template.new
+      templates.last.parse(template_str)
+      outputs << templates.last.render
+    end
+  end
+
+  profs << LiquidProf::Profiler.profile(iterations) do
+    template_iterations.times do
+      templates << Liquid::Template.parse(template_str)
+      outputs << templates.last.render
+    end
+  end
+
+  assert_equal 1, outputs.uniq.length
+  assert_equal profs.length * template_iterations, outputs.length
+  profs.each do |prof|
+    assert_equal template_iterations, prof.templates.length
+    assert_equal template_iterations, prof.stats.keys.select{ |key|
+      key.class == Liquid::Document
+    }.length
+  end
+
+  assert_equal profs, profs.compact
+  0.upto(profs.length-2) do |i|
+    (i+1).upto(profs.length-1) do |j|
+      assert profs[i].__id__ != profs[j].__id__
+      assert_stats_equal(profs[i], profs[j])
+    end
+  end
+
+  return profs.first
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: liquidprof
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Florian Weingarten
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: liquid
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.5'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: Liquid profiler
+email:
+- flo@hackvalue.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- TODO
+- add_liquid_tests.sh
+- cli.rb
+- lib/liquidprof.rb
+- lib/liquidprof/ascii_reporter.rb
+- lib/liquidprof/profiler.rb
+- lib/liquidprof/reporter.rb
+- lib/liquidprof/version.rb
+- liquidprof.gemspec
+- test/liquid/test/test_helper.rb
+- test/test.rb
+- test/test_helper.rb
+homepage: https://github.com/fw42/liquidprof
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Performance profiler for the Liquid templating language
+test_files:
+- test/liquid/test/test_helper.rb
+- test/test.rb
+- test/test_helper.rb