locomotive_liquid 2.1.3 → 2.2.2

data/History.txt

@@ -1,3 +1,16 @@
+2.2.2
+
+* Added support for template inheritance {% extends %}
+
+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
@@ -7,7 +20,7 @@ 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
 
@@ -26,17 +39,17 @@ Before 1.9.0
 * 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 )
 

data/README.md

@@ -0,0 +1,39 @@
+# Liquid template engine
+
+## Introduction
+
+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 (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?
+
+    <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

@@ -1,26 +1,37 @@
 #!/usr/bin/env ruby
 require 'rubygems'
+
+require "bundler"
+Bundler.setup
+
 require 'rake'
-require 'rake/testtask'
 require 'rake/gempackagetask'
 
-task :default => 'test'
+require "rspec"
+require "rspec/core/rake_task"
+
+Rspec::Core::RakeTask.new("spec") do |spec|
+  spec.pattern = "spec/**/*_spec.rb"
+end
 
-Rake::TestTask.new(:test) do |t|
-  t.libs << "lib"
-  t.libs << "test"
-  t.pattern = 'test/*_test.rb'
-  t.verbose = false
+desc "Run the Integration Specs (rendering)"
+Rspec::Core::RakeTask.new("spec:integration") do |spec|
+  spec.pattern = "spec/unit/*_spec.rb"
 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
+desc "Run the Unit Specs"
+Rspec::Core::RakeTask.new("spec:unit") do |spec|
+  spec.pattern = "spec/unit/*_spec.rb"
 end
 
+desc "Run all the specs without all the verbose spec output"
+Rspec::Core::RakeTask.new('spec:progress') do |spec|
+  spec.rspec_opts = %w(--format progress)
+  spec.pattern = "spec/**/*_spec.rb"
+end
+
+task :default => :spec
+
 gemspec = eval(File.read('locomotive_liquid.gemspec'))
 Rake::GemPackageTask.new(gemspec) do |pkg|
   pkg.gem_spec = gemspec
@@ -28,7 +39,13 @@ end
 
 desc "build the gem and release it to rubygems.org"
 task :release => :gem do
-  sh "gem push pkg/locomotive_liquid-#{gemspec.version}.gem"
+  puts "Tagging #{gemspec.version}..."
+  require 'ruby-debug';debugger
+  system "git tag -a #{gemspec.version} -m 'Tagging #{gemspec.version}'"
+  puts "Pushing to Github..."
+  system "git push --tags"
+  puts "Pushing to rubygems.org..."
+  system "gem push pkg/locomotive_liquid-#{gemspec.version}.gem"
 end
 
 namespace :profile do

data/lib/extras/liquid_view.rb

@@ -2,15 +2,15 @@
 # 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 
+  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
@@ -18,10 +18,10 @@ class LiquidView
   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|
@@ -31,15 +31,15 @@ class LiquidView
     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

data/lib/liquid.rb

@@ -38,13 +38,14 @@ module Liquid
   StrictQuotedFragment        = /"[^"]+"|'[^']+'|[^\s,\|,\:,\,]+/
   FirstFilterArgument         = /#{FilterArgumentSeparator}(?:#{StrictQuotedFragment})/
   OtherFilterArgument         = /#{ArgumentSeparator}(?:#{StrictQuotedFragment})/
-  SpacelessFilter             = /#{FilterSeparator}(?:#{StrictQuotedFragment})(?:#{FirstFilterArgument}(?:#{OtherFilterArgument})*)?/
+  SpacelessFilter             = /^(?:'[^']+'|"[^"]+"|[^'"])*#{FilterSeparator}(?:#{StrictQuotedFragment})(?:#{FirstFilterArgument}(?:#{OtherFilterArgument})*)?/
   Expression                  = /(?:#{QuotedFragment}(?:#{SpacelessFilter})*)/
   TagAttributes               = /(\w+)\s*\:\s*(#{QuotedFragment})/
   AnyStartingTag              = /\{\{|\{\%/
   PartialTemplateParser       = /#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableIncompleteEnd}/
   TemplateParser              = /(#{PartialTemplateParser}|#{AnyStartingTag})/
   VariableParser              = /\[[^\]]+\]|#{VariableSegment}+\??/
+  LiteralShorthand            = /^(?:\{\{\{\s?)(.*?)(?:\s*\}\}\})$/
 end
 
 require 'liquid/drop'

data/lib/liquid/context.rb

@@ -28,8 +28,9 @@ module Liquid
       @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
@@ -52,7 +53,6 @@ module Liquid
       end
     end
 
-
     def invoke(method, *args)
       if strainer.respond_to?(method)
         strainer.__send__(method, *args)
@@ -61,43 +61,44 @@ module Liquid
       end
     end
 
-    # push new local scope on the stack. use <tt>Context#stack</tt> instead
+    # Push new local scope on the stack. use <tt>Context#stack</tt> instead
     def push(new_scope={})
       raise StackLevelError, "Nesting too deep" if @scopes.length > 100
       @scopes.unshift(new_scope)
     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
     #
+    #   context['var]  #=> nil
     def stack(new_scope={},&block)
       result = nil
       push(new_scope)
+
       begin
         result = yield
       ensure
         pop
       end
+
       result
     end
-    
+
     def clear_instance_assigns
       @scopes[0] = {}
     end
@@ -116,139 +117,133 @@ module Liquid
     end
 
     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?
-      # 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)
+      # 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' # Single quoted strings
+          :empty?
+        when /^'(.*)'$/ # Double quoted strings
+          $1.to_s
+        when /^"(.*)"$/ # Integer and floats
+          $1.to_s
+        when /^(\d+)$/ # Ranges
+          $1.to_i
+        when /^\((\S+)\.\.(\S+)\)$/ # Floats
+          (resolve($1).to_i..resolve($2).to_i)
+        when /^(\d[\d\.]+)$/
+          $1.to_f
+        else
+          variable(key)
+        end
       end
-    end
 
-    # fetches an object starting at the local scope and then moving up
-    # the hierachy
-    def find_variable(key)
-      scope = @scopes.find { |s| s.has_key?(key) }
-      if scope.nil?
-        @environments.each do |e|
-          if variable = lookup_and_evaluate(e, key)
-            scope = e
-            break
+      # Fetches an object starting at the local scope and then moving up the hierachy
+      def find_variable(key)
+        scope = @scopes.find { |s| s.has_key?(key) }
+
+        if scope.nil?
+          @environments.each do |e|
+            if variable = lookup_and_evaluate(e, key)
+              scope = e
+              break
+            end
           end
         end
-      end
-      scope     ||= @environments.last || @scopes.last
-      variable  ||= lookup_and_evaluate(scope, key)
-      
-      variable = variable.to_liquid
-      variable.context = self if variable.respond_to?(:context=)
-      return variable
-    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 = /^\[(.*)\]$/
+        scope     ||= @environments.last || @scopes.last
+        variable  ||= lookup_and_evaluate(scope, key)
+
+        variable = variable.to_liquid
+        variable.context = self if variable.respond_to?(:context=)
 
-      first_part = parts.shift
-      if first_part =~ square_bracketed
-        first_part = resolve($1)
+        return variable
       end
 
-      if object = find_variable(first_part)
+      # 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 = /^\[(.*)\]$/
 
-        parts.each do |part|
-          part = resolve($1) if part_resolved = (part =~ square_bracketed)
+        first_part = parts.shift
 
-          # 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 first_part =~ square_bracketed
+          first_part = resolve($1)
+        end
 
-            # if its a proc we will replace the entry with the proc
-            res = lookup_and_evaluate(object, part)
-            object = res.to_liquid
+        if object = find_variable(first_part)
 
-          # 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)
+          parts.each do |part|
+            part = resolve($1) if part_resolved = (part =~ square_bracketed)
 
-            object = object.send(part.intern).to_liquid
+            # 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)))
 
-          # 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
-          end
+              # if its a proc we will replace the entry with the proc
+              res = lookup_and_evaluate(object, part)
+              object = res.to_liquid
 
-          # If we are dealing with a drop here we have to
-          object.context = self if object.respond_to?(:context=)
+              # 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
+            end
+
+            # If we are dealing with a drop here we have to
+            object.context = self if object.respond_to?(:context=)
+          end
         end
-      end
 
-      object
-    end
-    
-    def lookup_and_evaluate(obj, key)
-      if (value = obj[key]).is_a?(Proc) && obj.respond_to?(:[]=)
-        obj[key] = value.call(self)
-      else
-        value
-      end
-    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
+        object
+      end # variable
+
+      def lookup_and_evaluate(obj, key)
+        if (value = obj[key]).is_a?(Proc) && obj.respond_to?(:[]=)
+          obj[key] = (value.arity == 0) ? value.call : value.call(self)
+        else
+          value
+        end
+      end # lookup_and_evaluate
+
+      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
-    end
-    
-  end
-end
+      end # squash_instance_assigns_with_environments
+  end # Context
+
+end # Liquid

data/lib/liquid/errors.rb

@@ -1,6 +1,6 @@
 module Liquid
   class Error < ::StandardError; end
-  
+
   class ArgumentError < Error; end
   class ContextError < Error; end
   class FilterNotFound < Error; end

data/lib/liquid/file_system.rb

@@ -1,7 +1,7 @@
 module Liquid
   # A Liquid file system is way to let your templates retrieve other templates for use with the include tag.
   #
-  # You can implement subclasses that retrieve templates from the database, from the file system using a different 
+  # You can implement subclasses that retrieve templates from the database, from the file system using a different
   # path structure, you can provide them as hard-coded inline strings, or any manner that you see fit.
   #
   # You can add additional instance variables, arguments, or methods as needed.
@@ -18,7 +18,7 @@ module Liquid
       raise FileSystemError, "This liquid context does not allow includes."
     end
   end
-  
+
   # This implements an abstract file system which retrieves template files named in a manner similar to Rails partials,
   # ie. with the template name prefixed with an underscore. The extension ".liquid" is also added.
   #
@@ -27,35 +27,35 @@ module Liquid
   # Example:
   #
   # file_system = Liquid::LocalFileSystem.new("/some/path")
-  # 
+  #
   # file_system.full_path("mypartial")       # => "/some/path/_mypartial.liquid"
   # file_system.full_path("dir/mypartial")   # => "/some/path/dir/_mypartial.liquid"
   #
   class LocalFileSystem
     attr_accessor :root
-    
+
     def initialize(root)
       @root = root
     end
-    
+
     def read_template_file(template_path)
       full_path = full_path(template_path)
       raise FileSystemError, "No such template '#{template_path}'" unless File.exists?(full_path)
-      
+
       File.read(full_path)
     end
-    
+
     def full_path(template_path)
       raise FileSystemError, "Illegal template name '#{template_path}'" unless template_path =~ /^[^.\/][a-zA-Z0-9_\/]+$/
-      
+
       full_path = if template_path.include?('/')
         File.join(root, File.dirname(template_path), "_#{File.basename(template_path)}.liquid")
       else
         File.join(root, "_#{template_path}.liquid")
       end
-      
+
       raise FileSystemError, "Illegal template path '#{File.expand_path(full_path)}'" unless File.expand_path(full_path) =~ /^#{File.expand_path(root)}/
-      
+
       full_path
     end
   end

data/lib/liquid/standardfilters.rb

@@ -1,36 +1,36 @@
 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
-    
+
     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,22 +44,26 @@ 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
-    
+
     def strip_html(input)
       input.to_s.gsub(/<script.*?<\/script>/, '').gsub(/<.*?>/, '')
-    end       
-    
+    end
+
     # Remove all newlines from the string
-    def strip_newlines(input)        
-      input.to_s.gsub(/\n/, '')      
+    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)
+    def join(input, array_glue = ' ', hash_glue = nil)
+      hash_glue ||= array_glue
+
+      # translate from hash to array if needed
+      input = input.map{|k,v| "#{k}#{hash_glue}#{v}" } if input.is_a?(Hash)
+
+      [input].flatten.join(array_glue)
     end
 
     # Sort elements of the array
@@ -73,8 +77,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 +88,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,62 +153,62 @@ module Liquid
     #   %Z - Time zone name
     #   %% - Literal ``%'' character
     def date(input, format)
-      
+
       if format.to_s.empty?
         return input.to_s
       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)
       to_number(input) + to_number(operand)
     end
-    
+
     # subtraction
     def minus(input, operand)
       to_number(input) - to_number(operand)
     end
-    
+
     # multiplication
     def times(input, operand)
       to_number(input) * to_number(operand)
     end
-    
+
     # division
     def divided_by(input, operand)
       to_number(input) / to_number(operand)
     end
-    
+
     private
-    
+
     def to_number(obj)
       case obj
       when Numeric
@@ -215,8 +219,8 @@ module Liquid
         0
       end
     end
-    
+
   end
-   
+
   Template.register_filter(StandardFilters)
 end

data/lib/liquid/strainer.rb

@@ -16,6 +16,9 @@ module Liquid
     INTERNAL_METHOD = /^__/
     @@required_methods = Set.new([:__id__, :__send__, :respond_to?, :extend, :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)

data/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)  
+
+  Template.register_tag('comment', Comment)
 end

data/lib/liquid/tags/if.rb

@@ -14,7 +14,7 @@ module Liquid
   class If < Block
     SyntaxHelp = "Syntax Error in tag 'if' - Valid syntax: if [expression]"
     Syntax = /(#{QuotedFragment})\s*([=!<>a-z_]+)?\s*(#{QuotedFragment})?/
-    ExpressionsAndOperators = /(?:\b(?:and|or)\b|(?:\s*(?!\b(?:and|or)\b)(?:#{QuotedFragment}|\S+)\s*)+)/
+    ExpressionsAndOperators = /(?:\b(?:\s?and\s?|\s?or\s?)\b|(?:\s*(?!\b(?:\s?and\s?|\s?or\s?)\b)(?:#{QuotedFragment}|\S+)\s*)+)/
 
     def initialize(tag_name, markup, tokens, context)
 
@@ -57,7 +57,7 @@ module Liquid
         condition = Condition.new($1, $2, $3)
 
         while not expressions.empty?
-          operator = expressions.shift
+          operator = (expressions.shift).to_s.strip
 
           raise(SyntaxError, SyntaxHelp) unless expressions.shift.to_s =~ Syntax
 

data/lib/liquid/tags/ifchanged.rb

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

data/lib/liquid/tags/literal.rb

@@ -0,0 +1,42 @@
+module Liquid
+
+  class Literal < Block
+
+    # Class methods
+
+    # Converts a shorthand Liquid literal into its long representation.
+    #
+    # Currently the Template parser only knows how to handle the long version.
+    # So, it always checks if it is in the presence of a literal, in which case it gets converted through this method.
+    #
+    # Example:
+    #   Liquid::Literal "{{{ hello world }}}" #=> "{% literal %} hello world {% endliteral %}"
+    def self.from_shorthand(literal)
+      literal =~ LiteralShorthand ? "{% literal %}#{$1}{% endliteral %}" : literal
+    end
+
+    # Public instance methods
+
+    def parse(tokens) # :nodoc:
+      @nodelist ||= []
+      @nodelist.clear
+
+      while token = tokens.shift
+        if token =~ FullToken && block_delimiter == $1
+          end_tag
+          return
+        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 # parse
+
+  end
+
+  Template.register_tag('literal', Literal)
+end

data/lib/liquid/tags/unless.rb

@@ -9,25 +9,25 @@ module Liquid
   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)            
+          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
-  
+
 
   Template.register_tag('unless', Unless)
 end

data/lib/liquid/template.rb

@@ -55,7 +55,7 @@ module Liquid
     # Parse source code.
     # Returns self for easy chaining
     def parse(source, context = {})
-      @root = Document.new(tokenize(source), context.merge!(:template => self))
+      @root = Document.new(tokenize(Liquid::Literal.from_shorthand(source)), context.merge!(:template => self))
       self
     end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: locomotive_liquid
 version: !ruby/object:Gem::Version 
-  hash: 13
+  hash: 3
   prerelease: false
   segments: 
   - 2
-  - 1
-  - 3
-  version: 2.1.3
+  - 2
+  - 2
+  version: 2.2.2
 platform: ruby
 authors: 
 - Tobias Luetke
@@ -17,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-27 00:00:00 -07:00
+date: 2010-10-01 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -32,12 +32,12 @@ extensions: []
 
 extra_rdoc_files: 
 - History.txt
-- README.txt
+- README.md
 files: 
 - CHANGELOG
 - History.txt
 - MIT-LICENSE
-- README.txt
+- README.md
 - Rakefile
 - init.rb
 - lib/extras/liquid_view.rb
@@ -65,6 +65,7 @@ files:
 - lib/liquid/tags/ifchanged.rb
 - lib/liquid/tags/include.rb
 - lib/liquid/tags/inherited_block.rb
+- lib/liquid/tags/literal.rb
 - lib/liquid/tags/unless.rb
 - lib/liquid/template.rb
 - lib/liquid/variable.rb
@@ -77,7 +78,7 @@ licenses: []
 post_install_message: 
 rdoc_options: 
 - --main
-- README.txt
+- README.md
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -105,7 +106,7 @@ requirements: []
 rubyforge_project: locomotive_liquid
 rubygems_version: 1.3.7
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: A secure, non-evaling end user template engine with aesthetic markup.
 test_files: []
 

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