locomotive_liquid 2.1.3

data/CHANGELOG

@@ -0,0 +1,46 @@
+* Make context and assign work the same
+
+* Ruby 1.9.1 bugfixes
+
+* Fix LiquidView for Rails 2.2. Fix local assigns for all versions of Rails
+
+* 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]

data/History.txt

@@ -0,0 +1,44 @@
+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
+
+* 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]

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2005, 2006 Tobias Luetke
+
+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.txt

@@ -0,0 +1,38 @@
+= 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" 

data/Rakefile

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/gempackagetask'
+
+task :default => 'test'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "lib"
+  t.libs << "test"
+  t.pattern = 'test/*_test.rb'
+  t.verbose = false
+end
+
+Rake::TestTask.new(:ti) do |t|
+  t.libs << "lib"
+  t.libs << "test"
+  t.test_files = ['test/test_helper.rb', 'test/extends_test.rb', 'test/inherited_block_test.rb']
+  # t.test_files = ['test/test_helper.rb', 'test/inherited_block_test.rb', 'test/inherited_block_test.rb']
+  t.verbose = false
+end
+
+gemspec = eval(File.read('locomotive_liquid.gemspec'))
+Rake::GemPackageTask.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/locomotive_liquid-#{gemspec.version}.gem"
+end
+
+namespace :profile do
+
+  task :default => [:run]
+
+  desc "Run the liquid profile/perforamce coverage"
+  task :run do
+
+    ruby "performance/shopify.rb"
+
+  end
+
+  desc "Run KCacheGrind"
+  task :grind => :run  do
+    system "kcachegrind /tmp/liquid.rubyprof_calltreeprinter.txt"
+  end
+end
+

data/init.rb

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

data/lib/extras/liquid_view.rb

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

data/lib/liquid.rb

@@ -0,0 +1,68 @@
+# Copyright (c) 2005 Tobias Luetke
+#
+# 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.
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+module Liquid
+  FilterSeparator             = /\|/
+  ArgumentSeparator           = ','
+  FilterArgumentSeparator     = ':'
+  VariableAttributeSeparator  = '.'
+  TagStart                    = /\{\%/
+  TagEnd                      = /\%\}/
+  VariableSignature           = /\(?[\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})/
+  AnyStartingTag              = /\{\{|\{\%/
+  PartialTemplateParser       = /#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableIncompleteEnd}/
+  TemplateParser              = /(#{PartialTemplateParser}|#{AnyStartingTag})/
+  VariableParser              = /\[[^\]]+\]|#{VariableSegment}+\??/
+end
+
+require 'liquid/drop'
+require 'liquid/extensions'
+require 'liquid/errors'
+require 'liquid/strainer'
+require 'liquid/context'
+require 'liquid/tag'
+require 'liquid/block'
+require 'liquid/document'
+require 'liquid/variable'
+require 'liquid/file_system'
+require 'liquid/template'
+require 'liquid/htmltags'
+require 'liquid/standardfilters'
+require 'liquid/condition'
+require 'liquid/module_ex'
+
+# Load all the tags of the standard library
+#
+Dir[File.dirname(__FILE__) + '/liquid/tags/*.rb'].each { |f| require f }

data/lib/liquid/block.rb

@@ -0,0 +1,101 @@
+module Liquid
+
+  class Block < Tag
+    IsTag             = /^#{TagStart}/
+    IsVariable        = /^#{VariableStart}/
+    FullToken         = /^#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}$/
+    ContentOfVariable = /^#{VariableStart}(.*)#{VariableEnd}$/
+
+    def parse(tokens)
+      @nodelist ||= []
+      @nodelist.clear
+
+      while token = tokens.shift
+
+        case token
+        when IsTag
+          if token =~ FullToken
+
+            # if we found the proper block delimitor just end parsing here and let the outer block
+            # proceed
+            if block_delimiter == $1
+              end_tag
+              return
+            end
+
+            # fetch the tag from registered blocks
+            if tag = Template.tags[$1]
+              @nodelist << tag.new($1, $2, tokens, @context)
+            else
+              # this tag is not registered with the system
+              # pass it to the current block for special handling or error reporting
+              unknown_tag($1, $2, tokens)
+            end
+          else
+            raise SyntaxError, "Tag '#{token}' was not properly terminated with regexp: #{TagEnd.inspect} "
+          end
+        when IsVariable
+          @nodelist << create_variable(token)
+        when ''
+          # pass
+        else
+          @nodelist << token
+        end
+      end
+
+      # Make sure that its ok to end parsing in the current block.
+      # Effectively this method will throw and exception unless the current block is
+      # of type Document
+      assert_missing_delimitation!
+    end
+
+    def end_tag
+    end
+
+    def unknown_tag(tag, params, tokens)
+      case tag
+      when 'else'
+        raise SyntaxError, "#{block_name} tag does not expect else tag"
+      when 'end'
+        raise SyntaxError, "'end' is not a valid delimiter for #{block_name} tags. use #{block_delimiter}"
+      else
+        raise SyntaxError, "Unknown tag '#{tag}'"
+      end
+    end
+
+    def block_delimiter
+      "end#{block_name}"
+    end
+
+    def block_name
+      @tag_name
+    end
+
+    def create_variable(token)
+      token.scan(ContentOfVariable) do |content|
+        return Variable.new(content.first)
+      end
+      raise SyntaxError.new("Variable '#{token}' was not properly terminated with regexp: #{VariableEnd.inspect} ")
+    end
+
+    def render(context)
+      render_all(@nodelist, context)
+    end
+
+    protected
+
+    def assert_missing_delimitation!
+      raise SyntaxError.new("#{block_name} tag was never closed")
+    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
+    end
+  end
+end

data/lib/liquid/condition.rb

@@ -0,0 +1,120 @@
+module Liquid
+  # Container for liquid nodes which conveniently wraps decision making logic
+  #
+  # Example:
+  #
+  #   c = Condition.new('1', '==', '1')
+  #   c.evaluate #=> true
+  #
+  class Condition #:nodoc:
+    @@operators = {
+      '==' => lambda { |cond, left, right|  cond.send(:equal_variables, left, right) },
+      '!=' => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
+      '<>' => lambda { |cond, left, right| !cond.send(:equal_variables, left, 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)
+
+      case @child_relation
+      when :or
+        result || @child_condition.evaluate(context)
+      when :and
+        result && @child_condition.evaluate(context)
+      else
+        result
+      end
+    end
+
+    def or(condition)
+      @child_relation, @child_condition = :or, condition
+    end
+
+    def and(condition)
+      @child_relation, @child_condition = :and, condition
+    end
+
+    def attach(attachment)
+      @attachment = attachment
+    end
+
+    def else?
+      false
+    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)
+        else
+          return nil
+        end
+      end
+
+      if right.is_a?(Symbol)
+        if left.respond_to?(right)
+          return left.send(right.to_s)
+        else
+          return nil
+        end
+      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
+      # return this as the result.
+      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)
+        left.send(operation, right)
+      else
+        nil
+      end
+    end
+  end
+
+
+  class ElseCondition < Condition
+    def else?
+      true
+    end
+
+    def evaluate(context)
+      true
+    end
+  end
+
+end