merb_comatose 0.0.2

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 

data/lib/liquid/strainer.rb

@@ -0,0 +1,42 @@
+module Liquid
+
+  # Strainer is the parent class for the filters system. 
+  # New filters are mixed into the strainer class which is then instanciated for each liquid template render run. 
+  #
+  # One of the strainer's responsibilities is to keep malicious method calls out 
+  class Strainer
+    @@required_methods = ["__send__", "__id__", "respond_to?", "extend", "methods"]
+    
+    @@filters = []
+    
+    def initialize(context)
+      @context = context
+    end
+              
+    def self.global_filter(filter)
+      raise StandardError, "Passed filter is not a module" unless filter.is_a?(Module)      
+      @@filters << filter
+    end
+    
+    def self.create(context)
+      strainer = Strainer.new(context)
+      @@filters.each { |m| strainer.extend(m) }
+      strainer
+    end
+    
+    def respond_to?(method)
+      method_name = method.to_s
+      return false if method_name =~ /^__/ 
+      return false if @@required_methods.include?(method_name)
+      super
+    end
+    
+    # remove all standard methods from the bucket so circumvent security 
+    # problems 
+    instance_methods.each do |m| 
+      unless @@required_methods.include?(m) 
+        undef_method m 
+      end
+    end    
+  end
+end

data/lib/liquid/tag.rb

@@ -0,0 +1,25 @@
+module Liquid
+  
+  class Tag
+    attr_accessor :nodelist
+    
+    def initialize(markup, tokens)
+      @markup = markup
+      parse(tokens)
+    end
+    
+    def parse(tokens)
+    end
+    
+    def name
+      self.class.name.downcase
+    end
+    
+    def render(context)
+      ''
+    end    
+  end
+   
+
+end
+   

data/lib/liquid/template.rb

@@ -0,0 +1,88 @@
+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
+    
+    def self.file_system
+      @@file_system
+    end
+    
+    def self.file_system=(obj)
+      @@file_system = obj
+    end
+          
+    def self.register_tag(name, klass)      
+      tags[name.to_s] = klass
+    end                        
+    
+    def self.tags
+      @tags ||= {}
+    end
+        
+    # Pass a module with filter methods which should be available 
+    # to all liquid views. Good for registering the standard library
+    def self.register_filter(mod)      
+      Strainer.global_filter(mod)
+    end                        
+            
+    # creates a new <tt>Template</tt> object from liquid source code
+    def self.parse(source)
+      self.new(tokenize(source))
+    end                       
+    
+    # Uses the <tt>Liquid::TokenizationRegexp</tt> regexp to tokenize the passed source
+    def self.tokenize(source)      
+      return [] if source.to_s.empty?
+      tokens = source.split(TokenizationRegexp)
+
+      # removes the rogue empty element at the beginning of the array
+      tokens.shift if tokens[0] and tokens[0].empty? 
+
+      tokens
+    end        
+
+    # creates a new <tt>Template</tt> from an array of tokens. Use <tt>Template.parse</tt> instead
+    def initialize(tokens = [])
+      @root = Document.new(tokens)
+    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(assigns = {}, options = nil)
+      options = { :filters => options } unless options.is_a?(Hash)
+      context = Context.new(assigns, options[:registers])
+      
+      # Apply all filters 
+      [options[:filters]].flatten.each do |filter|         
+        context.add_filters(filter) 
+      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
+  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/lib/liquid.rb

@@ -0,0 +1,52 @@
+# 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 PURPOa AND
+# NONINFRINGEMENT. IN NO EVENT SaALL 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
+  FilterSperator              = /\|/
+  ArgumentSeparator           = ','
+  FilterArgumentSeparator     = ':'
+  VariableAttributeSeparator  = '.'
+  TagStart                    = /\{\%/
+  TagEnd                      = /\%\}/
+  VariableStart               = /\{\{/
+  VariableEnd                 = /\}\}/
+  AllowedVariableCharacters   = /[a-zA-Z_.-]/
+  QuotedFragment              = /"[^"]+"|'[^']+'|[^\s,|]+/
+  TagAttributes             = /(\w+)\s*\:\s*(#{QuotedFragment})/
+  TokenizationRegexp          = /(#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableEnd})/
+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/standardtags'
+require 'liquid/htmltags'
+require 'liquid/standardfilters'

data/lib/merb_comatose/merbtasks.rb

@@ -0,0 +1,6 @@
+namespace :merb_comatose do
+  desc "Do something for merb_comatose"
+  task :default do
+    puts "merb_comatose doesn't do anything"
+  end
+end

data/lib/merb_comatose.rb

@@ -0,0 +1,30 @@
+require 'redcloth' unless defined?(RedCloth)
+require 'liquid' unless defined?(Liquid)
+
+require 'support/class_options'
+require 'text_filters'
+
+require 'comatose/configuration'
+require 'comatose/comatose_drop'
+require 'comatose/processing_context'
+require 'comatose/page_wrapper'
+require 'comatose/version'
+
+# make sure we're running inside Merb
+if defined?(Merb::Plugins)
+
+  # Merb gives you a Merb::Plugins.config hash...feel free to put your stuff in your piece of it
+  Merb::Plugins.config[:merb_comatose] = {
+    :chickens => false
+  }
+  
+  Merb::BootLoader.before_app_loads do
+    # require code that must be loaded before the application
+  end
+  
+  Merb::BootLoader.after_app_loads do
+    # code that can be required after the application loads
+  end
+  
+  Merb::Plugins.add_rakefiles "merb_comatose/merbtasks"
+end