drnic-liquid 2.1.0

data/lib/liquid/tags/ifchanged.rb

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

data/lib/liquid/tags/include.rb

@@ -0,0 +1,55 @@
+module Liquid
+  class Include < Tag
+    Syntax = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?/
+  
+    def initialize(tag_name, markup, tokens)      
+      if markup =~ Syntax
+
+        @template_name = $1        
+        @variable_name = $3
+        @attributes    = {}
+
+        markup.scan(TagAttributes) do |key, value|
+          @attributes[key] = value
+        end
+
+      else
+        raise SyntaxError.new("Error in tag 'include' - Valid syntax: include '[template]' (with|for) [object|collection]")
+      end
+
+      super
+    end
+  
+    def parse(tokens)      
+    end
+  
+    def render(context)      
+      source  = Liquid::Template.file_system.read_template_file(context[@template_name])      
+      partial = Liquid::Template.parse(source)      
+      
+      variable = context[@variable_name || @template_name[1..-2]]
+      
+      context.stack do
+        @attributes.each do |key, value|
+          context[key] = context[value]
+        end
+
+        if variable.is_a?(Array)
+          
+          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
+  end
+
+  Template.register_tag('include', Include)  
+end

data/lib/liquid/tags/unless.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/if'
+
+module Liquid
+
+  # Unless is a conditional just like 'if' but works on the inverse logic.
+  #
+  #   {% unless x < 0 %} x is greater than zero {% end %}
+  #
+  class Unless < If
+    def render(context)
+      context.stack do
+        
+        # First condition is interpreted backwards ( if not )
+        block = @blocks.first
+        unless block.evaluate(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)            
+          end
+        end 
+        
+        ''
+      end
+    end    
+  end
+  
+
+  Template.register_tag('unless', Unless)
+end

data/lib/liquid/template.rb

@@ -0,0 +1,147 @@
+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.
+  #
+  # 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:
+  #
+  #   template = Liquid::Template.parse(source)
+  #   template.render('user_name' => 'bob')
+  #
+  class Template
+    attr_accessor :root
+    @@file_system = BlankFileSystem.new
+
+    class << self
+      def file_system
+        @@file_system
+      end
+
+      def file_system=(obj)
+        @@file_system = obj
+      end
+
+      def register_tag(name, klass)
+        tags[name.to_s] = klass
+      end
+
+      def tags
+        @tags ||= {}
+      end
+
+      # Pass a module with filter methods which should be available
+      # to all liquid views. Good for registering the standard library
+      def register_filter(mod)
+        Strainer.global_filter(mod)
+      end
+
+      # creates a new <tt>Template</tt> object from liquid source code
+      def parse(source)
+        template = Template.new
+        template.parse(source)
+        template
+      end
+    end
+
+    # creates a new <tt>Template</tt> from an array of tokens. Use <tt>Template.parse</tt> instead
+    def initialize
+    end
+
+    # Parse source code.
+    # Returns self for easy chaining
+    def parse(source)
+      @root = Document.new(tokenize(source))
+      self
+    end
+
+    def registers
+      @registers ||= {}
+    end
+
+    def assigns
+      @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
+    # 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
+    #
+    def render(*args)
+      return '' if @root.nil?
+
+      context = case args.first
+      when Liquid::Context
+        args.shift
+      when Hash
+        a = args.shift
+        assigns.each { |k,v| a[k] = v unless a.has_key?(k) }
+        Context.new(a, registers, @rethrow_errors)
+      when nil
+        Context.new(assigns.dup, 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])
+        end
+
+        if options[:filters]
+          context.add_filters(options[:filters])
+        end
+
+      when Module
+        context.add_filters(args.pop)
+      when Array
+        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
+      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)
+      return [] if source.to_s.empty?
+      tokens = source.split(TemplateParser)
+
+      # removes the rogue empty element at the beginning of the array
+      tokens.shift if tokens[0] and tokens[0].empty?
+
+      tokens
+    end
+
+  end
+end

data/lib/liquid/variable.rb

@@ -0,0 +1,49 @@
+module Liquid
+
+  # Holds variables. Variables are only loaded "just in time"
+  # and are not evaluated as part of the render stage
+  #
+  #   {{ monkey }}
+  #   {{ user.name }}
+  #
+  # Variables can be combined with filters:
+  #
+  #   {{ user | link }}
+  #
+  class Variable
+    attr_accessor :filters, :name
+
+    def initialize(markup)
+      @markup  = markup
+      @name    = nil
+      @filters = []
+      if match = markup.match(/\s*(#{QuotedFragment})/)
+        @name = match[1]
+        if markup.match(/#{FilterSeparator}\s*(.*)/)
+          filters = Regexp.last_match(1).split(/#{FilterSeparator}/)
+          filters.each do |f|
+            if matches = f.match(/\s*(\w+)/)
+              filtername = matches[1]
+              filterargs = f.scan(/(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*(#{QuotedFragment})/).flatten
+              @filters << [filtername.to_sym, filterargs]
+            end
+          end
+        end
+      end
+    end
+
+    def render(context)
+      return '' if @name.nil?
+      @filters.inject(context[@name]) do |output, filter|
+        filterargs = filter[1].to_a.collect do |a|
+         context[a]
+        end
+        begin
+          output = context.invoke(filter[0], output, *filterargs)
+        rescue FilterNotFound
+          raise FilterNotFound, "Error - filter '#{filter[0]}' in '#{@markup.strip}' could not be found."
+        end
+      end
+    end
+  end
+end

data/liquid.gemspec

@@ -0,0 +1,40 @@
+Gem::Specification.new do |s|
+  s.name = %q{drnic-liquid}
+  s.version = "2.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Tobias Luetke"]
+  s.date = %q{2009-08-31}
+  s.description = %q{A secure non evaling end user template engine with aesthetic markup.
+
+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.}
+  s.email = ["tobi@leetsoft.com"]
+  s.extra_rdoc_files = ["History.txt", "Manifest.txt"]
+  s.files = ["CHANGELOG", "History.txt", "MIT-LICENSE", "Manifest.txt", "README.rdoc", "Rakefile", "example/server/example_servlet.rb", "example/server/liquid_servlet.rb", "example/server/server.rb", "example/server/templates/index.liquid", "example/server/templates/products.liquid", "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", "liquid.gemspec", "performance/shopify.rb", "performance/shopify/comment_form.rb", "performance/shopify/database.rb", "performance/shopify/json_filter.rb", "performance/shopify/liquid.rb", "performance/shopify/money_filter.rb", "performance/shopify/paginate.rb", "performance/shopify/shop_filter.rb", "performance/shopify/tag_filter.rb", "performance/shopify/vision.database.yml", "performance/shopify/weight_filter.rb", "performance/tests/dropify/article.liquid", "performance/tests/dropify/blog.liquid", "performance/tests/dropify/cart.liquid", "performance/tests/dropify/collection.liquid", "performance/tests/dropify/index.liquid", "performance/tests/dropify/page.liquid", "performance/tests/dropify/product.liquid", "performance/tests/dropify/theme.liquid", "performance/tests/ripen/article.liquid", "performance/tests/ripen/blog.liquid", "performance/tests/ripen/cart.liquid", "performance/tests/ripen/collection.liquid", "performance/tests/ripen/index.liquid", "performance/tests/ripen/page.liquid", "performance/tests/ripen/product.liquid", "performance/tests/ripen/theme.liquid", "performance/tests/tribble/404.liquid", "performance/tests/tribble/article.liquid", "performance/tests/tribble/blog.liquid", "performance/tests/tribble/cart.liquid", "performance/tests/tribble/collection.liquid", "performance/tests/tribble/index.liquid", "performance/tests/tribble/page.liquid", "performance/tests/tribble/product.liquid", "performance/tests/tribble/search.liquid", "performance/tests/tribble/theme.liquid", "performance/tests/vogue/article.liquid", "performance/tests/vogue/blog.liquid", "performance/tests/vogue/cart.liquid", "performance/tests/vogue/collection.liquid", "performance/tests/vogue/index.liquid", "performance/tests/vogue/page.liquid", "performance/tests/vogue/product.liquid", "performance/tests/vogue/theme.liquid", "test/assign_test.rb", "test/block_test.rb", "test/condition_test.rb", "test/context_test.rb", "test/drop_test.rb", "test/error_handling_test.rb", "test/extra/breakpoint.rb", "test/extra/caller.rb", "test/file_system_test.rb", "test/filter_test.rb", "test/helper.rb", "test/html_tag_test.rb", "test/if_else_test.rb", "test/include_tag_test.rb", "test/module_ex_test.rb", "test/output_test.rb", "test/parsing_quirks_test.rb", "test/regexp_test.rb", "test/security_test.rb", "test/standard_filter_test.rb", "test/standard_tag_test.rb", "test/statements_test.rb", "test/strainer_test.rb", "test/template_test.rb", "test/test_helper.rb", "test/unless_else_test.rb", "test/variable_test.rb"]
+  s.homepage = %q{http://www.liquidmarkup.org}
+  s.rdoc_options = ["--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{liquid}
+  s.rubygems_version = %q{1.3.4}
+  s.summary = %q{A secure non evaling end user template engine with aesthetic markup}
+  s.test_files = ["test/test_helper.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<hoe>, [">= 2.3.3"])
+    else
+      s.add_dependency(%q<hoe>, [">= 2.3.3"])
+    end
+  else
+    s.add_dependency(%q<hoe>, [">= 2.3.3"])
+  end
+end

data/performance/shopify.rb

@@ -0,0 +1,92 @@
+# 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'
+
+require "ruby-prof" rescue fail("install ruby-prof extension/gem")
+
+class ThemeProfiler
+  
+  # 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 profile
+    RubyProf.measure_mode = RubyProf::WALL_TIME
+    
+    # Dup assigns because will make some changes to them
+    assigns = Database.tables.dup
+    
+    @tests.each do |liquid, layout, template_name|
+      
+      # Compute page_tempalte outside of profiler run, uninteresting to profiler
+      html = nil
+      page_template = File.basename(template_name, File.extname(template_name))
+      
+      # Profile compiling and rendering both
+      RubyProf.resume { html = compile_and_render(liquid, layout, assigns, page_template) }
+      
+      # 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
+
+
+  profiler = ThemeProfiler.new
+
+  puts 'Running profiler...'
+
+  results  = profiler.profile
+  
+  puts 'Success'
+  puts
+
+[RubyProf::FlatPrinter, RubyProf::GraphPrinter, RubyProf::GraphHtmlPrinter, RubyProf::CallTreePrinter].each do |klass|
+  filename = (ENV['TMP'] || '/tmp') + (klass.name.include?('Html') ? "/liquid.#{klass.name.downcase}.html" : "/liquid.#{klass.name.downcase}.txt")
+  filename.gsub!(/:+/, '_')
+  File.open(filename, "w+") { |fp| klass.new(results).print(fp) }
+  $stderr.puts "wrote #{klass.name} output to #{filename}"
+end
+
+
+

data/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