staugaard-comatose 2.0.2

data/lib/liquid/document.rb

@@ -0,0 +1,17 @@
+module Liquid
+  class Document < Block                                                             
+    # we don't need markup to open this block
+    def initialize(tokens)
+      parse(tokens)
+    end                                                                        
+  
+    # There isn't a real delimter   
+    def block_delimiter
+      []
+    end
+  
+    # Document blocks don't need to be terminated since they are not actually opened
+    def assert_missing_delimitation!
+    end    
+  end
+end

data/lib/liquid/drop.rb

@@ -0,0 +1,48 @@
+module Liquid
+  
+  # A drop in liquid is a class which allows you to to export DOM like things to liquid
+  # Methods of drops are callable. 
+  # The main use for liquid drops is the implement lazy loaded objects. 
+  # If you would like to make data available to the web designers which you don't want loaded unless needed then 
+  # a drop is a great way to do that
+  #
+  # Example:
+  #
+  # class ProductDrop < Liquid::Drop
+  #   def top_sales
+  #      Shop.current.products.find(:all, :order => 'sales', :limit => 10 )
+  #   end
+  # end
+  #  
+  # tmpl = Liquid::Template.parse( ' {% for product in product.top_sales %} {{ product.name }} {%endfor%} '  )
+  # tmpl.render('product' => ProductDrop.new ) # will invoke top_sales query. 
+  #
+  # Your drop can either implement the methods sans any parameters or implement the before_method(name) method which is a 
+  # catch all
+  class Drop
+    attr_writer :context
+
+    # Catch all for the method 
+    def before_method(method)
+      nil
+    end
+    
+    # called by liquid to invoke a drop
+    def invoke_drop(method)      
+      result = before_method(method)
+      result ||= send(method.to_sym) if self.class.public_instance_methods.include?(method.to_s)
+      result
+    end
+    
+    def has_key?(name)
+      true
+    end
+    
+    def to_liquid
+      self
+    end
+
+    alias :[] :invoke_drop
+  end
+  
+end

data/lib/liquid/errors.rb

@@ -0,0 +1,7 @@
+module Liquid
+  class FilterNotFound < StandardError
+  end
+
+  class FileSystemError < StandardError
+  end
+end

data/lib/liquid/extensions.rb

@@ -0,0 +1,53 @@
+class String
+  def to_liquid
+    self
+  end
+end
+
+class Array 
+  def to_liquid
+    self
+  end
+end
+
+class Hash 
+  def to_liquid
+    self
+  end
+end
+
+class Numeric
+  def to_liquid
+    self
+  end
+end
+
+class Time
+  def to_liquid
+    self
+  end
+end
+
+class DateTime
+  def to_liquid
+    self
+  end
+end
+
+class Date
+  def to_liquid
+    self
+  end
+end
+
+def true.to_liquid
+  self
+end
+
+def false.to_liquid
+  self
+end
+
+def nil.to_liquid
+  self
+end

data/lib/liquid/file_system.rb

@@ -0,0 +1,62 @@
+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 
+  # 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.
+  #
+  # Example:
+  #
+  # Liquid::Template.file_system = Liquid::LocalFileSystem.new(template_path)
+  # liquid = Liquid::Template.parse(template)
+  #
+  # This will parse the template with a LocalFileSystem implementation rooted at 'template_path'.
+  class BlankFileSystem
+    # Called by Liquid to retrieve a template file
+    def read_template_file(template_path)
+      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.
+  #
+  # For security reasons, template paths are only allowed to contain letters, numbers, and underscore.
+  #
+  # 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
+end

data/lib/liquid/htmltags.rb

@@ -0,0 +1,64 @@
+module Liquid
+  class TableRow < Block                                             
+    Syntax = /(\w+)\s+in\s+(#{AllowedVariableCharacters}+)/   
+    
+    def initialize(markup, tokens)
+      super
+
+      if markup =~ Syntax
+        @variable_name = $1
+        @collection_name = $2
+        @attributes = {}
+        markup.scan(TagAttributes) do |key, value|
+          @attributes[key] = value
+        end
+      else
+        raise SyntaxError.new("Syntax Error in 'table_row loop' - Valid syntax: table_row [item] in [collection] cols=3")
+      end
+    end
+    
+    def render(context)        
+      collection = context[@collection_name] or return ''
+      
+      if @attributes['limit'] or @attributes['offset']
+        limit = context[@attributes['limit']] || -1
+        offset = context[@attributes['offset']] || 0
+        collection = collection[offset.to_i..(limit.to_i + offset.to_i - 1)]
+      end
+            
+      length = collection.length
+      
+      cols = context[@attributes['cols']].to_i
+
+      row = 1
+      col = 0
+
+      result = ["<tr class=\"row1\">\n"]
+      context.stack do 
+
+        collection.each_with_index do |item, index|
+          context[@variable_name] = item
+          context['tablerowloop'] = {
+            'length'  => length,
+            'index'   => index + 1, 
+            'index0'  => index, 
+            'rindex'  => length - index,
+            'rindex0' => length - index -1,
+            'first'   => (index == 0),
+            'last'    => (index == length - 1) }
+                                
+          result << ["<td class=\"col#{col += 1}\">"] + render_all(@nodelist, context) + ['</td>']
+
+          if col == cols and not (index == length - 1)            
+            col  = 0
+            result << ["</tr>\n<tr class=\"row#{row += 1}\">"] 
+          end
+          
+        end
+      end
+      result + ["</tr>\n"]
+    end    
+  end
+  
+  Template.register_tag('tablerow', TableRow)  
+end

data/lib/liquid/standardfilters.rb

@@ -0,0 +1,111 @@
+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         
+    
+    # convert a input string to DOWNCASE
+    def downcase(input)
+      input.downcase rescue input
+    end         
+
+    # convert a input string to UPCASE
+    def upcase(input)
+      input.upcase rescue input
+    end
+    
+    # Truncate a string down to x characters
+    def truncate(input, characters = 100)    
+      if input.to_s.size > characters.to_i
+        input.to_s[0..characters.to_i] + '…'
+      else
+        input
+      end
+    end  
+
+    # Truncate string down to x words
+    def truncatewords(input, words = 15)    
+      wordlist = [input.to_s.split].flatten
+      if wordlist.size > words.to_i
+        wordlist[0..words.to_i].join(' ') + '…'
+      else
+        input
+      end
+    end  
+    
+    def strip_html(input)
+      input.to_s.gsub(/<.*?>/, '')
+    end
+    
+    # Join elements of the array with certain character between them
+    def join(input, glue = ' ')
+      [input].flatten.join(glue)
+    end
+
+    # Sort elements of the array
+    def sort(input)
+      [input].flatten.sort
+    end
+    
+    # Reformat a date
+    #
+    #   %a - The abbreviated weekday name (``Sun'')
+    #   %A - The  full  weekday  name (``Sunday'')
+    #   %b - The abbreviated month name (``Jan'')
+    #   %B - The  full  month  name (``January'')
+    #   %c - The preferred local date and time representation
+    #   %d - Day of the month (01..31)
+    #   %H - Hour of the day, 24-hour clock (00..23)
+    #   %I - Hour of the day, 12-hour clock (01..12)
+    #   %j - Day of the year (001..366)
+    #   %m - Month of the year (01..12)
+    #   %M - Minute of the hour (00..59)
+    #   %p - Meridian indicator (``AM''  or  ``PM'')
+    #   %S - Second of the minute (00..60)
+    #   %U - Week  number  of the current year,
+    #           starting with the first Sunday as the first
+    #           day of the first week (00..53)
+    #   %W - Week  number  of the current year,
+    #           starting with the first Monday as the first
+    #           day of the first week (00..53)
+    #   %w - Day of the week (Sunday is 0, 0..6)
+    #   %x - Preferred representation for the date alone, no time
+    #   %X - Preferred representation for the time alone, no date
+    #   %y - Year without a century (00..99)
+    #   %Y - Year with century
+    #   %Z - Time zone name
+    #   %% - Literal ``%'' character
+    def date(input, format)
+      date = input
+      date = Time.parse(input) if input.is_a?(String)
+      date.strftime(format)      
+    rescue => e 
+      input
+    end
+    
+    # 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 
+    # 
+    # Example:
+    #    {{ product.images | last | to_img }}
+    #  
+    def last(array)
+      array.last if array.respond_to?(:last)
+    end
+    
+  end
+   
+  Template.register_filter(StandardFilters)
+end

data/lib/liquid/standardtags.rb

@@ -0,0 +1,399 @@
+module Liquid 
+  
+  class Assign < Tag
+    Syntax = /(\w+)\s*=\s*(#{AllowedVariableCharacters}+)/   
+    
+    def initialize(markup, tokens)
+      if markup =~ Syntax
+        @to = $1
+        @from = $2
+      else
+        raise SyntaxError.new("Syntax Error in 'assign' - Valid syntax: assign [var] = [source]")
+      end
+    end
+    
+    def render(context)
+       context[@to] = context[@from]
+       ''       
+    end 
+    
+  end  
+  
+  class Capture < Block
+    Syntax = /(\w+)/
+
+    def initialize(markup, tokens)
+      if markup =~ Syntax
+        @to = $1
+        super 
+      else
+        raise SyntaxError.new("Syntax Error in 'capture' - Valid syntax: capture [var]")
+      end
+    end
+
+    def render(context)
+      output = super
+      context[@to] = output.to_s
+      ''
+    end
+  end
+ 
+  class Cycle < Tag
+    SimpleSyntax = /#{QuotedFragment}/        
+    NamedSyntax = /(#{QuotedFragment})\s*\:\s*(.*)/
+    
+    def initialize(markup, tokens)
+      case markup
+      when NamedSyntax
+      	@variables = variables_from_string($2)
+      	@name = $1
+      when SimpleSyntax
+        @variables = variables_from_string(markup)
+      	@name = "'#{@variables.to_s}'"
+      else
+        raise SyntaxError.new("Syntax Error in 'cycle' - Valid syntax: cycle [name :] var [, var2, var3 ...]")
+      end
+      
+    end    
+    
+    def render(context)
+      context.registers[:cycle] ||= Hash.new(0)
+      
+      context.stack do
+        key = context[@name]	
+        iteration = context.registers[:cycle][key]
+        result = context[@variables[iteration]]
+        iteration += 1    
+        iteration   = 0  if iteration >= @variables.size 
+        context.registers[:cycle][key] = iteration
+        result 
+      end
+    end
+    
+    private
+    
+    def variables_from_string(markup)
+      markup.split(',').collect do |var|
+    	  var =~ /\s*(#{QuotedFragment})\s*/
+    	  $1 ? $1 : nil
+    	end.compact
+    end
+    
+  end
+  
+  class Comment < Block                                             
+    def render(context)
+      ''
+    end    
+  end
+
+  class For < Block                                             
+    Syntax = /(\w+)\s+in\s+(#{AllowedVariableCharacters}+)/   
+    
+    def initialize(markup, tokens)
+      super
+
+      if markup =~ Syntax
+        @variable_name = $1
+        @collection_name = $2
+        @name = "#{$1}-#{$2}"
+        @attributes = {}
+        markup.scan(TagAttributes) do |key, value|
+          @attributes[key] = value
+        end        
+      else
+        raise SyntaxError.new("Syntax Error in 'for loop' - Valid syntax: for [item] in [collection]")
+      end
+    end
+    
+    def render(context)        
+      context.registers[:for] ||= Hash.new(0)
+      
+      collection = context[@collection_name]
+      
+      return '' if collection.nil? or collection.empty?
+      
+      range = (0..collection.length)
+      
+      if @attributes['limit'] or @attributes['offset']
+        
+        
+        offset = 0
+        if @attributes['offset'] == 'continue'
+          offset = context.registers[:for][@name] 
+        else          
+          offset = context[@attributes['offset']] || 0
+        end
+        
+        limit  = context[@attributes['limit']]
+
+        range_end = limit ? offset + limit : collection.length
+        
+        range = (offset..range_end-1)
+        
+        # Save the range end in the registers so that future calls to 
+        # offset:continue have something to pick up
+        context.registers[:for][@name] = range_end
+      end
+              
+      result = []
+      segment = collection[range]
+      return '' if segment.nil?        
+
+      context.stack do 
+        length = segment.length
+        
+        segment.each_with_index do |item, index|
+          context[@variable_name] = item
+          context['forloop'] = {
+            'name'    => @name,
+            'length'  => length,
+            'index'   => index + 1, 
+            'index0'  => index, 
+            'rindex'  => length - index,
+            'rindex0' => length - index -1,
+            'first'   => (index == 0),
+            'last'    => (index == length - 1) }
+          
+          result << render_all(@nodelist, context)
+        end
+      end
+      
+      # Store position of last element we rendered. This allows us to do 
+      
+      result 
+    end           
+  end
+  
+   
+  class DecisionBlock < Block
+    def equal_variables(right, left)
+      if left.is_a?(Symbol)
+        if right.respond_to?(left.to_s)
+          return right.send(left.to_s) 
+        else
+          raise ArgumentError.new("Error in tag '#{name}' - Cannot call method #{left} on type #{right.class}}")
+        end
+      end
+
+      if right.is_a?(Symbol)
+        if left.respond_to?(right.to_s)
+          return left.send(right.to_s) 
+        else
+          raise ArgumentError.new("Error in tag '#{name}' - Cannot call method #{right} on type #{left.class}}")
+        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 = case op
+      when '==' then return equal_variables(left, right)
+      when '!=' then return !equal_variables(left, right)
+      when '>'  then :>
+      when '<'  then :<
+      when '>=' then :>=
+      when '<=' then :<=
+      else
+        raise ArgumentError.new("Error in tag '#{name}' - Unknown operator #{op}")        
+      end
+      
+      if left.respond_to?(operation) and right.respond_to?(operation)
+        left.send(operation, right)      
+      else
+        nil
+      end
+    end    
+  end
+  
+  
+  class Case < DecisionBlock
+    Syntax     = /(#{QuotedFragment})/
+    WhenSyntax = /(#{QuotedFragment})/
+
+    def initialize(markup, tokens)
+      @nodelists = []
+      @else_nodelist = []
+      
+      super
+
+      if markup =~ Syntax
+        @left = $1
+      else
+        raise SyntaxError.new("Syntax Error in tag 'case' - Valid syntax: case [condition]")
+      end
+    end
+    
+    def end_tag
+      push_nodelist
+    end
+
+    def unknown_tag(tag, params, tokens)
+      case tag 
+      when 'when'
+        if params =~ WhenSyntax          
+          push_nodelist
+          @right = $1
+          @nodelist = [] 
+        else
+          raise SyntaxError.new("Syntax Error in tag 'case' - Valid when condition: when [condition] ")
+        end
+      when 'else'
+        push_nodelist
+        @right = nil
+        @else_nodelist = @nodelist = [] 
+      else
+        super
+      end
+    end
+    
+    def push_nodelist
+      if @right
+        # only push the nodelist if there was actually a when condition stated before. 
+        # we discard all tokens between the case and the first when condition this way...
+        @nodelists << [@right, @nodelist] 
+      end
+    end
+
+    def render(context)
+      output = []
+      run_else_block = true
+      
+      @nodelists.each do |right, nodelist|
+        if equal_variables(context[@left], context[right])
+          run_else_block = false
+          context.stack do          
+            output += render_all(nodelist, context)
+          end
+        end
+      end            
+      
+      if run_else_block
+        context.stack do          
+          output += render_all(@else_nodelist, context)       
+        end
+      end
+      
+      output.to_s
+    end    
+  end  
+  
+  class If < DecisionBlock
+    Syntax = /(#{QuotedFragment})\s*([=!<>]+)?\s*(#{QuotedFragment})?/
+    
+    def initialize(markup, tokens)
+      @nodelist_true = @nodelist = []
+      @nodelist_false = []
+
+      super
+                       
+      if markup =~ Syntax
+        @left = $1
+        @operator = $2 
+        @right = $3
+      else
+        raise SyntaxError.new("Syntax Error in tag 'if' - Valid syntax: if [condition]")
+      end
+      
+    end
+    
+    def unknown_tag(tag, params, tokens)
+      if tag == 'else'
+        @nodelist = @nodelist_false = []
+      else
+        super
+      end
+    end
+    
+    def render(context)
+      context.stack do       
+        if interpret_condition(@left, @right, @operator, context)
+          render_all(@nodelist_true, context)
+        else
+          render_all(@nodelist_false, context)
+        end
+      end
+    end
+  end
+  
+  class Unless < If
+    def render(context)
+      context.stack do       
+        if interpret_condition(@left, @right, @operator, context)
+          render_all(@nodelist_false, context)
+        else
+          render_all(@nodelist_true, context)
+        end
+      end
+    end
+  end
+  
+  class Include < Tag
+    Syntax = /("[^"]+"|'[^']+')(\s+(with|for)\s+(#{QuotedFragment}+))?/
+    
+    def initialize(markup, tokens)
+      if markup =~ Syntax
+        @template_name = $1[1...-1]
+        if $2
+          @collection = ($3 == "for")
+          @variable = $4
+        end
+        @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)      
+      source = Liquid::Template.file_system.read_template_file(@template_name)
+      tokens = Liquid::Template.tokenize(source)
+      @document = Document.new(tokens)
+    end
+    
+    def render(context)
+      result = ''
+      variable = context[@variable]
+      context.stack do
+        @attributes.each do |key, value|
+          context[key] = context[value]
+        end
+        if @collection 
+          variable.each do |item|
+            context[@template_name] = item
+            result << @document.render(context).to_s
+          end
+        else 
+          if @variable          
+            context[@template_name] = variable
+          end
+          result << @document.render(context).to_s
+        end
+      end
+      result
+    end
+  end
+  
+  Template.register_tag('assign', Assign)
+  Template.register_tag('capture', Capture)
+  Template.register_tag('comment', Comment)
+  Template.register_tag('for', For)
+  Template.register_tag('if', If)
+  Template.register_tag('unless', Unless)
+  Template.register_tag('case', Case)
+  Template.register_tag('cycle', Cycle)
+  Template.register_tag('include', Include)  
+end