liquor 0.1.1 → 0.9.1

data/lib/liquor/strainer.rb

@@ -1,58 +0,0 @@
-require 'set'
-
-module Liquor
-
-  parent_object = if defined? BlankObject
-    BlankObject
-  else
-    Object
-  end
-
-  # Strainer is the parent class for the filters system.
-  # New filters are mixed into the strainer class which is then instanciated for each liquor template render run.
-  #
-  # One of the strainer's responsibilities is to keep malicious method calls out
-  class Strainer < parent_object #:nodoc:
-    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)
-      @context = context
-    end
-
-    def self.global_filter(filter)
-      raise ArgumentError, "Passed filter is not a module" unless filter.is_a?(Module)
-      @@filters[filter.name] = filter
-    end
-
-    def self.get_filters
-      @@filters
-    end
-
-    def self.create(context)
-      strainer = Strainer.new(context)
-      @@filters.each { |k,m| strainer.extend(m) }
-      strainer
-    end
-
-    def respond_to?(method, include_private = false)
-      method_name = method.to_s
-      return false if method_name =~ INTERNAL_METHOD
-      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.to_sym)
-        undef_method m
-      end
-    end
-  end
-end

data/lib/liquor/tags/assign.rb

@@ -1,33 +0,0 @@
-module Liquor
-
-  # Assign sets a variable in your template.
-  #
-  #   {% assign foo = 'monkey' %}
-  #
-  # You can then use the variable later in the page.
-  #
-  #  {{ monkey }}
-  #
-  class Assign < Tag
-    Syntax = /(#{VariableSignature}+)\s*=\s*(#{Expression}+)/   
-  
-    def initialize(tag_name, markup, tokens)          
-      if markup =~ Syntax
-        @to = $1
-        @from = $2
-      else
-        raise SyntaxError.new("Syntax Error in 'assign' - Valid syntax: assign [var] = [source]")
-      end
-      
-      super      
-    end
-  
-    def render(context)
-       context.scopes.last[@to] = context[@from]
-       ''
-    end 
-  
-  end  
-  
-  Template.register_tag('assign', Assign)  
-end

data/lib/liquor/tags/capture.rb

@@ -1,35 +0,0 @@
-module Liquor
-
-  # Capture stores the result of a block into a variable without rendering it inplace.
-  #
-  #   {% capture heading %}
-  #     Monkeys!
-  #   {% endcapture %}
-  #   ...
-  #   <h1>{{ monkeys }}</h1>
-  #
-  # Capture is useful for saving content for use later in your template, such as
-  # in a sidebar or footer.
-  #
-  class Capture < Block
-    Syntax = /(\w+)/
-
-    def initialize(tag_name, markup, tokens)
-      if markup =~ Syntax
-        @to = $1
-      else
-        raise SyntaxError.new("Syntax Error in 'capture' - Valid syntax: capture [var]")
-      end
-
-      super
-    end
-
-    def render(context)
-      output = super
-      context.scopes.last[@to.to_s] = output.join
-      ''
-    end
-  end
-
-  Template.register_tag('capture', Capture)
-end

data/lib/liquor/tags/case.rb

@@ -1,83 +0,0 @@
-module Liquor
-  class Case < Block
-    Syntax     = /(#{Expression})/
-    WhenSyntax = /(#{Expression})(?:(?:\s+or\s+|\s*\,\s*)(#{Expression}.*))?/
-
-    def initialize(tag_name, markup, tokens)      
-      @blocks = []
-      
-      if markup =~ Syntax
-        @left = $1
-      else
-        raise SyntaxError.new("Syntax Error in tag 'case' - Valid syntax: case [condition]")
-      end
-            
-      super
-    end
-
-    def unknown_tag(tag, markup, tokens)
-      @nodelist = []
-      case tag
-      when 'when'
-        record_when_condition(markup)
-      when 'else'
-        record_else_condition(markup)
-      else
-        super
-      end
-    end
-
-    def render(context)      
-      context.stack do          
-        execute_else_block = true
-        
-        @blocks.inject([]) do |output, block|
-      
-          if block.else? 
-            
-            return render_all(block.attachment, context) if execute_else_block
-            
-          elsif block.evaluate(context)
-            
-            execute_else_block = false        
-            output += render_all(block.attachment, context)                    
-          end            
-      
-          output
-        end
-      end          
-    end
-    
-    private
-    
-    def record_when_condition(markup)                
-      while markup
-      	# Create a new nodelist and assign it to the new block
-      	if not markup =~ WhenSyntax
-      	  raise SyntaxError.new("Syntax Error in tag 'case' - Valid when condition: {% when [condition] [or condition2...] %} ")
-      	end
-
-      	markup = $2
-
-      	block = Condition.new(@left, '==', $1)        
-      	block.attach(@nodelist)
-      	@blocks.push(block)
-      end
-    end
-
-    def record_else_condition(markup)            
-
-      if not markup.strip.empty?
-        raise SyntaxError.new("Syntax Error in tag 'case' - Valid else condition: {% else %} (no parameters) ")
-      end
-         
-      block = ElseCondition.new            
-      block.attach(@nodelist)
-      @blocks << block
-    end
-    
-        
-  end    
-  
-  Template.register_tag('case', Case)
-end

data/lib/liquor/tags/comment.rb

@@ -1,9 +0,0 @@
-module Liquor
-  class Comment < Block                                             
-    def render(context)
-      ''
-    end    
-  end
-  
-  Template.register_tag('comment', Comment)  
-end

data/lib/liquor/tags/content_for.rb

@@ -1,54 +0,0 @@
-module Liquor
-
-  # The content_for method allows you to insert content into a yield block in your layout. 
-  # You only use content_for to insert content in named yields. 
-  # 
-  # In your layout:
-  #  <title>{% yield title %}</title>
-  #  <body>{% yield %}</body>
-  #
-  # In the view:
-  #  {% content_for title %} The title {% end_content_for %}
-  #  The body    
-  #
-  #
-  # Will produce:
-  #  <title>The title</title>
-  #  <body>The body</body>
-  #
-  #
-  class ContentFor < Block
-    SyntaxHelp = "Syntax Error in tag 'content_for' - Valid syntax: content_for [name]"
-    Syntax = /(#{VariableSignature}+)/   
-    
-    def initialize(tag_name, markup, tokens)
-      if markup =~ Syntax
-        @name = $1
-      else
-        raise SyntaxError.new(SyntaxHelp)
-      end
-
-      super
-    end
-    
-    def render(context)      
-      result = ''
-      
-      context.stack do
-        result = render_all(@nodelist, context).join
-      end
-            
-      context['content_for'] = {} unless context.has_key? 'content_for'
-      context['content_for'][@name] = result
-      
-      ''
-    end
-    
-    def block_delimiter
-      "end_#{block_name}"
-    end
-    
-  end
-
-  Template.register_tag('content_for', ContentFor)
-end

data/lib/liquor/tags/cycle.rb

@@ -1,59 +0,0 @@
-module Liquor
-  
-  # Cycle is usually used within a loop to alternate between values, like colors or DOM classes.
-  #
-  #   {% for item in items %}
-  #     <div class="{% cycle 'red', 'green', 'blue' %}"> {{ item }} </div>
-  #   {% end %}
-  #
-  #    <div class="red"> Item one </div>
-  #    <div class="green"> Item two </div>
-  #    <div class="blue"> Item three </div>
-  #    <div class="red"> Item four </div>
-  #    <div class="green"> Item five</div>
-  #
-  class Cycle < Tag
-    SimpleSyntax = /^#{Expression}+/        
-    NamedSyntax  = /^(#{Expression})\s*\:\s*(.*)/
-  
-    def initialize(tag_name, 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
-      super    
-    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*(#{Expression})\s*/
-    	  $1 ? $1 : nil
-    	end.compact
-    end
-  
-  end
-  
-  Template.register_tag('cycle', Cycle)
-end

data/lib/liquor/tags/for.rb

@@ -1,136 +0,0 @@
-module Liquor
-
-  # "For" iterates over an array or collection. 
-  # Several useful variables are available to you within the loop.
-  #
-  # == Basic usage:
-  #    {% for item in collection %}
-  #      {{ forloop.index }}: {{ item.name }}
-  #    {% endfor %}
-  #
-  # == Advanced usage:
-  #    {% for item in collection %}
-  #      <div {% if forloop.first %}class="first"{% endif %}>
-  #        Item {{ forloop.index }}: {{ item.name }}
-  #      </div>
-  #    {% endfor %}
-  #
-  # You can also define a limit and offset much like SQL.  Remember
-  # that offset starts at 0 for the first item.
-  #
-  #    {% for item in collection limit:5 offset:10 %}
-  #      {{ item.name }}
-  #    {% end %}             
-  #
-  #  To reverse the for loop simply use {% for item in collection reversed %}
-  #
-  # == Available variables:
-  #
-  # forloop.name:: 'item-collection'
-  # forloop.length:: Length of the loop
-  # forloop.index:: The current item's position in the collection;
-  #                 forloop.index starts at 1. 
-  #                 This is helpful for non-programmers who start believe
-  #                 the first item in an array is 1, not 0.
-  # forloop.index0:: The current item's position in the collection
-  #                  where the first item is 0
-  # forloop.rindex:: Number of items remaining in the loop
-  #                  (length - index) where 1 is the last item.
-  # forloop.rindex0:: Number of items remaining in the loop
-  #                   where 0 is the last item.
-  # forloop.first:: Returns true if the item is the first item.
-  # forloop.last:: Returns true if the item is the last item.
-  #
-  class For < Block                                             
-    Syntax = /(\w+)\s+in\s+(#{Expression}+)\s*(reversed)?/   
-  
-    def initialize(tag_name, markup, tokens)
-      if markup =~ Syntax
-        @variable_name = $1
-        @collection_name = $2
-        @name = "#{$1}-#{$2}"           
-        @reversed = $3             
-        @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
-
-      super
-    end
-  
-    def render(context)        
-      context.registers[:for] ||= Hash.new(0)
-    
-      collection = context[@collection_name]
-      collection = collection.to_a if collection.is_a?(Range)
-    
-      return '' unless collection.respond_to?(:each) 
-                                                 
-      from = if @attributes['offset'] == 'continue'
-        context.registers[:for][@name].to_i
-      else
-        context[@attributes['offset']].to_i
-      end
-        
-      limit = context[@attributes['limit']]
-      to    = limit ? limit.to_i + from : nil  
-          
-                       
-      segment = slice_collection_using_each(collection, from, to)      
-      
-      return '' if segment.empty?
-      
-      segment.reverse! if @reversed
-
-      result = []
-        
-      length = segment.length            
-            
-      # Store our progress through the collection for the continue flag
-      context.registers[:for][@name] = from + segment.length
-              
-      context.stack do 
-        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
-      result     
-    end          
-        
-    def slice_collection_using_each(collection, from, to)       
-      segments = []      
-      index = 0      
-      yielded = 0
-      collection.each do |item|         
-                
-        if to && to <= index
-          break
-        end
-        
-        if from <= index                               
-          segments << item
-        end                    
-                
-        index += 1
-      end    
-
-      segments
-    end
-  end
-
-  Template.register_tag('for', For)
-end