locomotive_liquid 2.1.3

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(tag_name, markup, tokens, context)
+      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] || Liquid::Template.file_system
+      source  = file_system.read_template_file(context[@template_name])
+      partial = Liquid::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/liquid/tags/inherited_block.rb

@@ -0,0 +1,93 @@
+module Liquid
+
+  # Blocks are used with the Extends tag to define
+  # the content of blocks. Nested blocks are allowed.
+  #
+  #   {% extends home %}
+  #   {% block content }Hello world{% endblock %}
+  #
+  class InheritedBlock < Block
+    Syntax = /(#{QuotedFragment}+)/
+
+    attr_accessor :parent
+    attr_reader :name
+
+    def initialize(tag_name, markup, tokens, context)
+      if markup =~ Syntax
+        @name = $1
+      else
+        raise SyntaxError.new("Error in tag 'block' - Valid syntax: block [name]")
+      end
+
+      (context[:block_stack] ||= []).push(self)
+      context[:current_block] = self
+
+      super if tokens
+    end
+
+    def render(context)
+      context.stack do
+        context['block'] = InheritedBlockDrop.new(self)
+        render_all(@nodelist, context)
+      end
+    end
+
+    def end_tag
+      self.register_current_block
+
+      @context[:block_stack].pop
+      @context[:current_block] = @context[:block_stack].last
+    end
+
+    def call_super(context)
+      if parent
+        parent.render(context)
+      else
+        ''
+      end
+    end
+
+    def self.clone_block(block)
+      new_block = self.new(block.send(:instance_variable_get, :"@tag_name"), block.name, nil, {})
+      new_block.parent = block.parent
+      new_block.nodelist = block.nodelist
+      new_block
+    end
+
+    protected
+
+    def register_current_block
+      @context[:blocks] ||= {}
+
+      block = @context[:blocks][@name]
+
+      if block
+        # copy the existing block in order to make it a parent of the parsed block
+        new_block = self.class.clone_block(block)
+
+        # replace the up-to-date version of the block in the parent template
+        block.parent = new_block
+        block.nodelist = @nodelist
+      end
+    end
+
+  end
+
+  class InheritedBlockDrop < Drop
+
+    def initialize(block)
+      @block = block
+    end
+
+    def name
+      @block.name
+    end
+
+    def super
+      @block.call_super(@context)
+    end
+
+  end
+
+  Template.register_tag('block', InheritedBlock)
+end

data/lib/liquid/tags/unless.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/if'
+
+module Liquid
+
+  # 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/liquid/template.rb

@@ -0,0 +1,149 @@
+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, context = {})
+        template = Template.new
+        template.parse(source, context)
+        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, context = {})
+      @root = Document.new(tokenize(source), context.merge!(:template => self))
+      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 liquid more with its host application
+    #
+    def render(*args)
+      return '' if @root.nil?
+
+      context = case args.first
+      when Liquid::Context
+        args.shift
+      when Hash
+        Context.new([args.shift, assigns], instance_assigns, registers, @rethrow_errors)
+      when nil
+        Context.new(assigns, instance_assigns, registers, @rethrow_errors)
+      else
+        raise ArgumentError, "Expect Hash or Liquid::Context as parameter"
+      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
+
+      begin
+        # render the nodelist.
+        # for performance reasons we get a array back here. join will make a string out of it
+        @root.render(context).join
+      ensure
+        @errors = context.errors
+      end
+    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)
+      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/liquid/variable.rb

@@ -0,0 +1,50 @@
+module Liquid
+
+  # 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}))(?:#{QuotedFragment}|\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
+          output = 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

data/lib/locomotive_liquid.rb

@@ -0,0 +1 @@
+require 'liquid'

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification 
+name: locomotive_liquid
+version: !ruby/object:Gem::Version 
+  hash: 13
+  prerelease: false
+  segments: 
+  - 2
+  - 1
+  - 3
+  version: 2.1.3
+platform: ruby
+authors: 
+- Tobias Luetke
+- Didier Lafforgue
+- Jacques Crocker
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-27 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: A secure, non-evaling end user template engine with aesthetic markup. Extended with liquid template inheritance for use in LocomotiveCMS
+email: 
+- tobi@leetsoft.com
+- didier@nocoffee.fr
+- railsjedi@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- README.txt
+files: 
+- CHANGELOG
+- History.txt
+- MIT-LICENSE
+- README.txt
+- Rakefile
+- init.rb
+- lib/extras/liquid_view.rb
+- lib/liquid/block.rb
+- lib/liquid/condition.rb
+- lib/liquid/context.rb
+- lib/liquid/document.rb
+- lib/liquid/drop.rb
+- lib/liquid/errors.rb
+- lib/liquid/extensions.rb
+- lib/liquid/file_system.rb
+- lib/liquid/htmltags.rb
+- lib/liquid/module_ex.rb
+- lib/liquid/standardfilters.rb
+- lib/liquid/strainer.rb
+- lib/liquid/tag.rb
+- lib/liquid/tags/assign.rb
+- lib/liquid/tags/capture.rb
+- lib/liquid/tags/case.rb
+- lib/liquid/tags/comment.rb
+- lib/liquid/tags/cycle.rb
+- lib/liquid/tags/extends.rb
+- lib/liquid/tags/for.rb
+- lib/liquid/tags/if.rb
+- lib/liquid/tags/ifchanged.rb
+- lib/liquid/tags/include.rb
+- lib/liquid/tags/inherited_block.rb
+- lib/liquid/tags/unless.rb
+- lib/liquid/template.rb
+- lib/liquid/variable.rb
+- lib/liquid.rb
+- lib/locomotive_liquid.rb
+has_rdoc: true
+homepage: http://www.locomotiveapp.org
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: locomotive_liquid
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 2
+summary: A secure, non-evaling end user template engine with aesthetic markup.
+test_files: []
+