liquor 0.1.1 → 0.9.1

data/lib/liquor/tags/if.rb

@@ -1,80 +0,0 @@
-module Liquor
-
-  # If is the conditional block
-  #
-  #   {% if user.admin %}
-  #     Admin user!
-  #   {% else %}
-  #     Not admin user
-  #   {% endif %}
-  #
-  #    There are {% if count < 5 %} less {% else %} more {% endif %} items than you need.
-  #
-  #
-  class If < Block
-    SyntaxHelp = "Syntax Error in tag 'if' - Valid syntax: if [expression]"
-    Syntax = /(#{Expression})\s*([=!<>a-z_]+)?\s*(#{Expression})?/
-    ExpressionsAndOperators = /(?:and|or|(?:\s*(?!\b(?:and|or)\b)(?:#{Expression}|\S+)\s*)+)/
-    
-    def initialize(tag_name, 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
-      else        
-        
-        expressions = markup.scan(ExpressionsAndOperators).reverse
-        raise(SyntaxError, SyntaxHelp) unless expressions.shift =~ Syntax 
-
-        condition = Condition.new($1, $2, $3)               
-        
-        while not expressions.empty?
-          operator = expressions.shift 
-          
-          raise(SyntaxError, SyntaxHelp) unless expressions.shift.to_s =~ Syntax    
-          
-          new_condition = Condition.new($1, $2, $3)
-          new_condition.send(operator.to_sym, condition)     
-          condition = new_condition          
-        end                        
-                  
-        condition
-      end
-            
-      @blocks.push(block)      
-      @nodelist = block.attach(Array.new) 
-    end
-    
-    
-  end
-
-  Template.register_tag('if', If)
-end

data/lib/liquor/tags/ifchanged.rb

@@ -1,20 +0,0 @@
-module Liquor
-  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/liquor/tags/include.rb

@@ -1,56 +0,0 @@
-module Liquor
-  class Include < Tag
-    Syntax = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?/
-  
-    def initialize(tag_name, 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)      
-      file_system = context.registers[:file_system] || Liquor::Template.file_system
-      source  = file_system.read_template_file(context[@template_name])      
-      partial = Liquor::Template.parse(source)      
-      
-      variable = context[@variable_name || @template_name[1..-2]]
-      
-      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/liquor/tags/unless.rb

@@ -1,33 +0,0 @@
-require File.dirname(__FILE__) + '/if'
-
-module Liquor
-
-  # Unless is a conditional just like 'if' but works on the inverse logic.
-  #
-  #   {% unless x < 0 %} x is greater than zero {% end %}
-  #
-  class Unless < If
-    def render(context)
-      context.stack do
-        
-        # First condition is interpreted backwards ( if not )
-        block = @blocks.first
-        unless block.evaluate(context)
-          return render_all(block.attachment, context)            
-        end
-        
-        # After the first condition unless works just like if
-        @blocks[1..-1].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/liquor/tags/yield.rb

@@ -1,49 +0,0 @@
-module Liquor
-
-  # Within the context of a layout, yield identifies a section where content from the view should be inserted. 
-  # The simplest way to use this is to have a single yield, into which the entire contents of the view currently 
-  # being rendered is inserted.
-  #
-  # 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 Yield < Tag
-    Syntax = /(#{VariableSignature}+){0,1}/   
-  
-    def initialize(tag_name, markup, tokens)          
-      if markup =~ Syntax
-        @what = $1
-        @what = "_rendered_template_" if @what.blank?        
-      else
-        raise SyntaxError.new("Syntax Error in 'yield' - Valid syntax: yield [name]")
-      end
-      
-      super      
-    end
-  
-    def render(context)
-      res = context["content_for"][@what]
-      if res.present? && res.is_a?(Array)
-        res = res.first
-      elsif res.blank?
-        res = ''
-      end
-       
-      res
-    end 
-  
-  end  
-  
-  Template.register_tag('yield', Yield)  
-end

data/lib/liquor/template.rb

@@ -1,181 +0,0 @@
-module Liquor
-
-  # Templates are central to liquor.
-  # 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 = Liquor::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 liquor views. Good for registering the standard library
-      def register_filter(mod)
-        Strainer.global_filter(mod)
-      end
-
-      def get_filters
-        Strainer.get_filters
-      end
-
-      # creates a new <tt>Template</tt> object from liquor 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 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
-    # 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 liquor more with its host application
-    #  * <tt>layout</tt>: Liquor::Template object which describes layout for this template
-    #
-    
-    def render(*args)   
-      return '' if @root.nil?       
-      
-      context = case args.first
-      when Liquor::Context
-        args.first
-      when Hash
-        Context.new([args.first, assigns], instance_assigns, registers, @rethrow_errors)
-      when nil
-        Context.new(assigns, instance_assigns, registers, @rethrow_errors)
-      else
-        raise ArgumentError, "Expect Hash or Liquor::Context as parameter"
-      end
-            
-      options = nil
-      case args.last
-      when Hash
-        options = args.last
-        
-        if options[:registers].is_a?(Hash)
-          self.registers.merge!(options[:registers])  
-        end
-
-        if options[:filters]
-          context.add_filters(options[:filters])
-        end
-        
-        if options[:layout]
-          raise ArgumentError, "Expected Liquor::Template as layout argument" unless options[:layout].is_a? Liquor::Template
-        end                   
-                
-      when Module
-        context.add_filters(args.last)    
-      when Array
-        context.add_filters(args.last)            
-      end
-                                                            
-      begin 
-        # render the nodelist.
-        # for performance reasons we get a array back here. join will make a string out of it
-        res = @root.render(context).join
-                
-        if options && options[:layout]
-          content_for_assigns = (context.has_key?("content_for") ? context["content_for"] : {})
-          content_for_assigns = content_for_assigns.merge({ "_rendered_template_" => res })
-          
-          case args.first
-          when Liquor::Context
-            args.first["content_for"] = content_for_assigns
-          when Hash
-            args.first.merge!({ "content_for" => content_for_assigns })
-          end 
-          
-          layout_template = args.last.delete(:layout)
-          
-          # Here we execute render method of the Liquor::Template object (we execute _this_ method)
-          # It is not the @root.render method. It is a result of the @root.render(context).join
-          # so we don't need to call join here.
-          res = layout_template.render(*args)
-        end
-        
-        res
-      ensure
-        @errors = context.errors
-      end
-    end
-
-    def render!(*args)
-      @rethrow_errors = true; render(*args)
-    end
-
-    private
-
-    # Uses the <tt>Liquor::TemplateParser</tt> regexp to tokenize the passed source
-    def tokenize(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
-    end
-
-  end
-end

data/lib/liquor/variable.rb

@@ -1,52 +0,0 @@
-module Liquor
-
-  # Holds variables. Variables are only loaded "just in time"
-  # and are not evaluated as part of the render stage
-  #
-  #   {{ monkey }}
-  #   {{ user.name }}
-  #
-  # Variables can be combined with filters:
-  #
-  #   {{ user | link }}
-  #
-  class Variable
-    FilterParser = /(?:#{FilterSeparator}|(?:\s*(?!(?:#{FilterSeparator}))(?:(?:#{StrictQuotedFragment})(?:#{FirstFilterArgument}(?:#{OtherFilterArgument})*)?|\S+)\s*)+)/
-    attr_accessor :filters, :name
-
-    def initialize(markup)
-      @markup  = markup
-      @name    = nil
-      @filters = []
-      if match = markup.match(/\s*(#{QuotedFragment})(.*)/)
-        @name = match[1]
-        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
-              @filters << [filtername.to_sym, filterargs]
-            end
-          end
-        end
-      end
-    end
-
-    def render(context)
-      return '' if @name.nil?
-      @filters.inject(context[@name]) do |output, filter|
-        filterargs = filter[1].to_a.collect do |a|
-          context[a]
-        end
-        begin
-          context.invoke(filter[0], output, *filterargs)
-        rescue FilterNotFound
-          raise FilterNotFound, "Error - filter '#{filter[0]}' in '#{@markup.strip}' could not be found."
-        end
-      end
-    end
-
-
-  end
-end