liquid 1.7.0

data/lib/liquid/tags/if.rb

@@ -0,0 +1,51 @@
+module Liquid
+  class If < Block
+    Syntax = /(#{QuotedFragment})\s*([=!<>]+)?\s*(#{QuotedFragment})?/
+    
+    def initialize(markup, tokens)    
+      @blocks = []
+      
+      push_block('if', markup)
+      
+      super      
+    end
+    
+    def unknown_tag(tag, markup, tokens)
+      if ['elsif', 'else'].include?(tag)
+        push_block(tag, markup)
+      else
+        super
+      end
+    end
+    
+    def render(context)
+      context.stack do
+        @blocks.each do |block|
+          if block.evaluate(context)            
+            return render_all(block.attachment, context)            
+          end
+        end 
+        ''
+      end
+    end
+    
+    private
+    
+    def push_block(tag, markup)            
+      
+      block = if tag == 'else'
+        ElseCondition.new
+      elsif markup =~ Syntax
+        Condition.new($1, $2, $3)        
+      else
+        raise SyntaxError.new("Syntax Error in tag '#{tag}' - Valid syntax: #{tag} [condition]") 
+      end
+            
+      @blocks.push(block)      
+      @nodelist = block.attach(Array.new) 
+    end
+    
+  end
+
+  Template.register_tag('if', If)
+end

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,56 @@
+module Liquid
+  class Include < Tag
+    Syntax = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?/
+  
+    def initialize(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]
+      
+      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,29 @@
+require File.dirname(__FILE__) + '/if'
+
+module Liquid
+
+  class Unless < If
+    def render(context)
+      context.stack do
+        
+        # First condition is interpreted backwards ( if not )
+        block = @blocks.shift
+        unless block.evaluate(context)
+          return render_all(block.attachment, context)            
+        end
+        
+        # After the first condition unless works just like if
+        @blocks.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,150 @@
+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
+    
+    def handle_error(e)
+      errors.push(e)
+      raise if @rethrow_errors
+      
+      case e
+      when SyntaxError        
+        "Liquid syntax error: #{e.message}"        
+      else
+        "Liquid error: #{e.message}"
+      end      
+    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
+        self.assigns.merge!(args.shift)        
+        Context.new(self)
+      when nil
+        Context.new(self)
+      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
+                                    
+      # render the nodelist.
+      # for performance reasons we get a array back here. to_s will make a string out of it
+      @root.render(context).to_s
+    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)      
+      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,39 @@
+module Liquid
+  
+  # Hols variables. Variables are only loaded "just in time"
+  # they are not evaluated as part of the render stage
+  class Variable    
+    attr_accessor :filters, :name
+    
+    def initialize(markup)
+      @markup = markup                            
+      @name = markup.match(/\s*(#{QuotedFragment})/)[1]
+      if markup.match(/#{FilterSperator}\s*(.*)/)
+        filters = Regexp.last_match(1).split(/#{FilterSperator}/)
+        
+        @filters = filters.collect do |f|          
+          filtername = f.match(/\s*(\w+)/)[1]
+          filterargs = f.scan(/(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*(#{QuotedFragment})/).flatten            
+          [filtername.to_sym, filterargs]
+        end
+      else
+        @filters = []
+      end
+    end                        
+
+    def render(context)      
+      output = context[@name]
+      @filters.inject(output) 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  
+      output
+    end
+  end
+end

data/test/block_test.rb

@@ -0,0 +1,50 @@
+require File.dirname(__FILE__) + '/helper'
+
+class VariableTest < Test::Unit::TestCase
+  include Liquid
+
+  def test_blankspace
+    template = Liquid::Template.parse("  ")
+    assert_equal ["  "], template.root.nodelist
+  end
+
+  def test_variable_beginning
+    template = Liquid::Template.parse("{{funk}}  ")
+    assert_equal 2, template.root.nodelist.size
+    assert_equal Variable, template.root.nodelist[0].class
+    assert_equal String, template.root.nodelist[1].class
+  end
+
+  def test_variable_end
+    template = Liquid::Template.parse("  {{funk}}")
+    assert_equal 2, template.root.nodelist.size
+    assert_equal String, template.root.nodelist[0].class
+    assert_equal Variable, template.root.nodelist[1].class
+  end
+
+  def test_variable_middle
+    template = Liquid::Template.parse("  {{funk}}  ")
+    assert_equal 3, template.root.nodelist.size
+    assert_equal String, template.root.nodelist[0].class
+    assert_equal Variable, template.root.nodelist[1].class
+    assert_equal String, template.root.nodelist[2].class
+  end
+
+  def test_variable_many_embedded_fragments
+    template = Liquid::Template.parse("  {{funk}} {{so}} {{brother}} ")
+    assert_equal 7, template.root.nodelist.size
+    assert_equal [String, Variable, String, Variable, String, Variable, String], block_types(template.root.nodelist)
+  end
+  
+  def test_with_block
+    template = Liquid::Template.parse("  {% comment %} {% endcomment %} ")
+    assert_equal [String, Comment, String], block_types(template.root.nodelist)    
+    assert_equal 3, template.root.nodelist.size
+  end
+  
+  private
+  
+  def block_types(nodelist)
+    nodelist.collect { |node| node.class }
+  end
+end

data/test/context_test.rb

@@ -0,0 +1,340 @@
+require File.dirname(__FILE__) + '/helper'
+class HundredCentes
+  def to_liquid
+    100
+  end
+end
+
+class CentsDrop < Liquid::Drop
+  def amount
+    HundredCentes.new
+  end
+end
+
+class ContextSensitiveDrop < Liquid::Drop
+  def test
+    @context['test']
+  end
+end
+
+
+class ContextTest < Test::Unit::TestCase
+  include Liquid
+
+  def setup
+    @template = Liquid::Template.new
+    @context = Liquid::Context.new(@template)
+  end
+
+  def test_variables
+    @context['string'] = 'string'
+    assert_equal 'string', @context['string']
+    
+    @context['num'] = 5
+    assert_equal 5, @context['num']
+    
+    @context['time'] = Time.parse('2006-06-06 12:00:00')
+    assert_equal Time.parse('2006-06-06 12:00:00'), @context['time']
+    
+    @context['date'] = Date.today
+    assert_equal Date.today, @context['date']
+    
+    now = DateTime.now
+    @context['datetime'] = now
+    assert_equal now, @context['datetime']    
+    
+    @context['bool'] = true
+    assert_equal true, @context['bool']    
+    
+    @context['bool'] = false
+    assert_equal false, @context['bool']
+    
+    @context['nil'] = nil
+    assert_equal nil, @context['nil']
+    assert_equal nil, @context['nil']    
+  end
+
+  def test_variables_not_existing
+    assert_equal nil, @context['does_not_exist']
+  end
+  
+  def test_scoping
+    assert_nothing_raised do
+      @context.push
+      @context.pop
+    end
+    
+    assert_raise(Liquid::ContextError) do
+      @context.pop
+    end
+
+    assert_raise(Liquid::ContextError) do
+      @context.push
+      @context.pop
+      @context.pop
+    end
+  end
+  
+  def test_length_query
+    
+    @context['numbers'] = [1,2,3,4]
+    
+    assert_equal 4, @context['numbers.size']
+
+    @context['numbers'] = {1 => 1,2 => 2,3 => 3,4 => 4}
+
+    assert_equal 4, @context['numbers.size']
+    
+    @context['numbers'] = {1 => 1,2 => 2,3 => 3,4 => 4, 'size' => 1000}
+
+    assert_equal 1000, @context['numbers.size']
+    
+  end
+  
+  def test_add_filter
+    
+    filter = Module.new do 
+      def hi(output)
+        output + ' hi!'
+      end
+    end
+    
+    context = Context.new(@template)
+    context.add_filters(filter)
+    assert_equal 'hi? hi!', context.invoke(:hi, 'hi?')
+    
+    context = Context.new(@template)
+    assert_equal 'hi?', context.invoke(:hi, 'hi?')
+
+    context.add_filters(filter)
+    assert_equal 'hi? hi!', context.invoke(:hi, 'hi?')
+        
+  end
+  
+  def test_override_global_filter
+    global = Module.new do 
+      def notice(output)
+        "Global #{output}"
+      end
+    end
+    
+    local = Module.new do 
+      def notice(output)
+        "Local #{output}"
+      end
+    end
+        
+    Template.register_filter(global)    
+    assert_equal 'Global test', Template.parse("{{'test' | notice }}").render
+    assert_equal 'Local test', Template.parse("{{'test' | notice }}").render({}, :filters => [local])
+  end
+    
+  def test_only_intended_filters_make_it_there
+
+    filter = Module.new do 
+      def hi(output)
+        output + ' hi!'
+      end
+    end
+
+    context = Context.new(@template)
+    methods = context.strainer.methods
+    context.add_filters(filter)
+    assert_equal (methods + ['hi']).sort, context.strainer.methods.sort
+  end
+  
+  def test_add_item_in_outer_scope
+    @context['test'] = 'test'
+    @context.push
+    assert_equal 'test', @context['test']
+    @context.pop    
+    assert_equal 'test', @context['test']    
+  end
+
+  def test_add_item_in_inner_scope
+    @context.push
+    @context['test'] = 'test'
+    assert_equal 'test', @context['test']
+    @context.pop    
+    assert_equal nil, @context['test']    
+  end
+  
+  def test_hierachical_data
+    @context['hash'] = {"name" => 'tobi'}
+    assert_equal 'tobi', @context['hash.name']
+  end
+  
+  def test_keywords
+    assert_equal true, @context['true']
+    assert_equal false, @context['false']
+  end
+
+  def test_digits
+    assert_equal 100, @context['100']
+    assert_equal 100.00, @context['100.00']
+  end
+  
+  def test_strings
+    assert_equal "hello!", @context['"hello!"']
+    assert_equal "hello!", @context["'hello!'"]
+  end  
+  
+  def test_merge
+    @context.merge({ "test" => "test" })
+    assert_equal 'test', @context['test']
+    @context.merge({ "test" => "newvalue", "foo" => "bar" })
+    assert_equal 'newvalue', @context['test']
+    assert_equal 'bar', @context['foo']    
+  end
+  
+  def test_array_notation
+    @context['test'] = [1,2,3,4,5]
+
+    assert_equal 1, @context['test[0]']
+    assert_equal 2, @context['test[1]']
+    assert_equal 3, @context['test[2]']
+    assert_equal 4, @context['test[3]']
+    assert_equal 5, @context['test[4]']    
+  end
+  
+  def test_recoursive_array_notation
+    @context['test'] = {'test' => [1,2,3,4,5]}
+
+    assert_equal 1, @context['test.test[0]']
+   
+    @context['test'] = [{'test' => 'worked'}]
+
+    assert_equal 'worked', @context['test[0].test']    
+  end
+  
+  def test_try_first
+    @context['test'] = [1,2,3,4,5]
+
+    assert_equal 1, @context['test.first']
+    assert_equal 5, @context['test.last']
+    
+    @context['test'] = {'test' => [1,2,3,4,5]}
+        
+    assert_equal 1, @context['test.test.first']
+    assert_equal 5, @context['test.test.last']    
+    
+    @context['test'] = [1]
+    assert_equal 1, @context['test.first']
+    assert_equal 1, @context['test.last']        
+  end
+
+  def test_access_hashes_with_hash_notation
+    
+    @context['products'] = {'count' => 5, 'tags' => ['deepsnow', 'freestyle'] }
+    @context['product'] = {'variants' => [ {'title' => 'draft151cm'}, {'title' => 'element151cm'}  ]}
+
+
+    assert_equal 5, @context['products[count]']
+    assert_equal 'deepsnow', @context['products[tags][0]']
+    assert_equal 'deepsnow', @context['products[tags].first']
+    assert_equal 'draft151cm', @context['product[variants][0][title]']
+    assert_equal 'element151cm', @context['product[variants][1][title]']
+    assert_equal 'draft151cm', @context['product[variants][0][title]']
+    assert_equal 'element151cm', @context['product[variants][last][title]']
+  end
+  
+
+  def test_first_can_appear_in_middle_of_callchain
+
+    @context['product'] = {'variants' => [ {'title' => 'draft151cm'}, {'title' => 'element151cm'}  ]}
+
+    assert_equal 'draft151cm', @context['product.variants[0].title']
+    assert_equal 'element151cm', @context['product.variants[1].title']
+    assert_equal 'draft151cm', @context['product.variants.first.title']
+    assert_equal 'element151cm', @context['product.variants.last.title']
+    
+  end
+  
+  def test_cents
+    @context.merge( "cents" => HundredCentes.new )
+    assert_equal 100, @context['cents']
+  end
+
+  def test_nested_cents
+    @context.merge( "cents" => { 'amount' => HundredCentes.new} )
+    assert_equal 100, @context['cents.amount']    
+
+    @context.merge( "cents" => { 'cents' => { 'amount' => HundredCentes.new} } )
+    assert_equal 100, @context['cents.cents.amount']    
+  end
+  
+  def test_cents_through_drop
+    @context.merge( "cents" => CentsDrop.new )
+    assert_equal 100, @context['cents.amount']     
+  end
+
+  def test_nested_cents_through_drop
+    @context.merge( "vars" => {"cents" => CentsDrop.new} )
+    assert_equal 100, @context['vars.cents.amount']     
+  end
+  
+  def test_context_from_within_drop
+    @context.merge( "test" => '123', "vars" => ContextSensitiveDrop.new )
+    assert_equal '123', @context['vars.test']     
+  end
+
+  def test_nested_context_from_within_drop
+    @context.merge( "test" => '123', "vars" => {"local" => ContextSensitiveDrop.new }  )
+    assert_equal '123', @context['vars.local.test']     
+  end
+
+  def test_cents_through_drop_nestedly
+    @context.merge( "cents" => {"cents" => CentsDrop.new} )
+    assert_equal 100, @context['cents.cents.amount']     
+
+    @context.merge( "cents" => { "cents" => {"cents" => CentsDrop.new}} )
+    assert_equal 100, @context['cents.cents.cents.amount']     
+  end
+  
+  def test_proc_as_variable
+    @context['dynamic'] = Proc.new { 'Hello' }
+    
+    assert_equal 'Hello', @context['dynamic']
+  end
+
+  def test_lambda_as_variable
+    @context['dynamic'] = lambda { 'Hello' }
+    
+    assert_equal 'Hello', @context['dynamic']
+  end
+
+  def test_nested_lambda_as_variable
+    @context['dynamic'] = { "lambda" => lambda { 'Hello' } }
+    
+    assert_equal 'Hello', @context['dynamic.lambda']
+  end
+  
+  def test_lambda_is_called_once
+    @context['callcount'] = lambda { @global ||= 0; @global += 1; @global.to_s }
+    
+    assert_equal '1', @context['callcount']
+    assert_equal '1', @context['callcount']
+    assert_equal '1', @context['callcount']    
+    
+    @global = nil
+  end
+
+  def test_nested_lambda_is_called_once
+    @context['callcount'] = { "lambda" => lambda { @global ||= 0; @global += 1; @global.to_s } }
+    
+    assert_equal '1', @context['callcount.lambda']
+    assert_equal '1', @context['callcount.lambda']
+    assert_equal '1', @context['callcount.lambda']    
+
+    @global = nil
+  end
+  
+  def test_access_to_context_from_proc
+    @context.registers[:magic] = 345392
+    
+    @context['magic'] = lambda { @context.registers[:magic] }
+    
+    assert_equal 345392, @context['magic']    
+  end
+  
+end