liquid 2.0.0 → 2.1.0

data/lib/liquid/tags/for.rb

@@ -42,7 +42,7 @@ module Liquid
   # forloop.last:: Returns true if the item is the last item.
   #
   class For < Block                                             
-    Syntax = /(\w+)\s+in\s+(#{Expression}+)\s*(reversed)?/   
+    Syntax = /(\w+)\s+in\s+(#{QuotedFragment}+)\s*(reversed)?/   
   
     def initialize(tag_name, markup, tokens)
       if markup =~ Syntax

data/lib/liquid/tags/if.rb

@@ -13,7 +13,8 @@ module Liquid
   #
   class If < Block
     SyntaxHelp = "Syntax Error in tag 'if' - Valid syntax: if [expression]"
-    Syntax = /(#{Expression})\s*([=!<>a-z_]+)?\s*(#{Expression})?/
+    Syntax = /(#{QuotedFragment})\s*([=!<>a-z_]+)?\s*(#{QuotedFragment})?/
+    ExpressionsAndOperators = /(?:and|or|(?:\s*(?!\b(?:and|or)\b)(?:#{QuotedFragment}|\S+)\s*)+)/
     
     def initialize(tag_name, markup, tokens)    
     
@@ -50,7 +51,7 @@ module Liquid
         ElseCondition.new
       else        
         
-        expressions = markup.split(/\b(and|or)\b/).reverse
+        expressions = markup.scan(ExpressionsAndOperators).reverse
         raise(SyntaxError, SyntaxHelp) unless expressions.shift =~ Syntax 
 
         condition = Condition.new($1, $2, $3)               

data/lib/liquid/tags/include.rb

@@ -24,7 +24,8 @@ module Liquid
     end
   
     def render(context)      
-      source  = Liquid::Template.file_system.read_template_file(context[@template_name])      
+      file_system = context.registers[:file_system] || Liquid::Template.file_system
+      source  = file_system.read_template_file(context[@template_name])      
       partial = Liquid::Template.parse(source)      
       
       variable = context[@variable_name || @template_name[1..-2]]

data/lib/liquid/template.rb

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

data/lib/liquid/variable.rb

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

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: liquid
 version: !ruby/object:Gem::Version 
-  version: 2.0.0
+  hash: 11
+  prerelease: false
+  segments: 
+  - 2
+  - 1
+  - 0
+  version: 2.1.0
 platform: ruby
 authors: 
 - Tobias Luetke
@@ -9,20 +15,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-10 00:00:00 -04:00
+date: 2009-04-13 00:00:00 -04:00
 default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: hoe
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 1.8.2
-    version: 
-description: A secure non evaling end user template engine with aesthetic markup.
+dependencies: []
+
+description: A secure, non-evaling end user template engine with aesthetic markup.
 email: tobi@leetsoft.com
 executables: []
 
@@ -39,7 +36,6 @@ files:
 - Manifest.txt
 - README.txt
 - Rakefile
-- init.rb
 - lib/extras/liquid_view.rb
 - lib/liquid.rb
 - lib/liquid/block.rb
@@ -69,6 +65,8 @@ files:
 - lib/liquid/variable.rb
 has_rdoc: true
 homepage: http://www.liquidmarkup.org
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - --main
@@ -76,23 +74,29 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: liquid
-rubygems_version: 1.3.1
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 2
-summary: A secure non evaling end user template engine with aesthetic markup.
-test_files: 
-- test/test_helper.rb
+summary: A secure, non-evaling end user template engine with aesthetic markup.
+test_files: []
+

data/init.rb

@@ -1,8 +0,0 @@
-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/test/test_helper.rb

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