wordify_liquid 2.5.1

data/lib/liquid/tags/if.rb

@@ -0,0 +1,79 @@
+module Liquid
+
+  # 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 = /(#{QuotedFragment})\s*([=!<>a-z_]+)?\s*(#{QuotedFragment})?/o
+    ExpressionsAndOperators = /(?:\b(?:\s?and\s?|\s?or\s?)\b|(?:\s*(?!\b(?:\s?and\s?|\s?or\s?)\b)(?:#{QuotedFragment}|\S+)\s*)+)/o
+
+    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).to_s.strip
+
+            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/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,65 @@
+module Liquid
+  class Include < Tag
+    Syntax = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?/o
+  
+    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)
+      source = _read_template_from_file_system(context)
+      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
+   
+    private
+      def _read_template_from_file_system(context)
+        file_system = context.registers[:file_system] || Liquid::Template.file_system
+      
+        # make read_template_file call backwards-compatible.
+        case file_system.method(:read_template_file).arity
+        when 1
+          file_system.read_template_file(context[@template_name])
+        when 2
+          file_system.read_template_file(context[@template_name], context)
+        else
+          raise ArgumentError, "file_system.read_template_file expects two parameters: (template_name, context)"
+        end
+      end
+  end
+
+  Template.register_tag('include', Include)  
+end

data/lib/liquid/tags/increment.rb

@@ -0,0 +1,35 @@
+module Liquid
+  
+  # increment is used in a place where one needs to insert a counter
+  #     into a template, and needs the counter to survive across
+  #     multiple instantiations of the template.
+  #     (To achieve the survival, the application must keep the context)
+  #
+  #     if the variable does not exist, it is created with value 0.
+
+  #   Hello: {% increment variable %}
+  #
+  # gives you:
+  #
+  #    Hello: 0
+  #    Hello: 1
+  #    Hello: 2
+  #
+  class Increment < Tag
+    def initialize(tag_name, markup, tokens)      
+      @variable = markup.strip
+
+      super    
+    end    
+  
+    def render(context)
+      value = context.environments.first[@variable] ||= 0
+      context.environments.first[@variable] = value + 1
+      value.to_s
+    end
+  
+    private
+  end
+  
+  Template.register_tag('increment', Increment)
+end

data/lib/liquid/tags/raw.rb

@@ -0,0 +1,21 @@
+module Liquid
+  class Raw < Block
+    def parse(tokens)
+      @nodelist ||= []
+      @nodelist.clear
+
+      while token = tokens.shift
+        if token =~ FullToken
+          if block_delimiter == $1
+            end_tag
+            return
+          end
+        end
+        @nodelist << token if not token.empty?
+      end
+    end
+  end
+
+  Template.register_tag('raw', Raw)
+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,150 @@
+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)
+        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 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
+        result = @root.render(context)
+        result.respond_to?(:join) ? result.join : result
+      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/utils.rb

@@ -0,0 +1,31 @@
+module Liquid
+  module Utils
+    def self.slice_collection_using_each(collection, from, to)
+      segments = []
+      index = 0
+      yielded = 0
+
+      # Maintains Ruby 1.8.7 String#each behaviour on 1.9
+      return [collection] if non_blank_string?(collection)
+
+      collection.each do |item|
+
+        if to && to <= index
+          break
+        end
+
+        if from <= index
+          segments << item
+        end
+
+        index += 1
+      end
+
+      segments
+    end
+
+    def self.non_blank_string?(collection)
+      collection.is_a?(String) && collection != ''
+    end
+  end
+end

data/lib/liquid/variable.rb

@@ -0,0 +1,57 @@
+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*(?:#{QuotedFragment}|#{ArgumentSeparator})\s*)+)/o
+    attr_accessor :filters, :name
+
+    def initialize(markup)
+      @markup  = markup
+      @name    = nil
+      @filters = []
+      if match = markup.match(/\s*(#{QuotedFragment})(.*)/o)
+        @name = match[1]
+        if match[2].match(/#{FilterSeparator}\s*(.*)/o)
+          filters = Regexp.last_match(1).scan(FilterParser)
+          filters.each do |f|
+            if matches = f.match(/\s*(\w+)(?:\s*#{FilterArgumentSeparator}(.*))?/)
+              filtername = matches[1]
+              filterargs = matches[2].to_s.scan(/(?:\A|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o).flatten
+              @filters << [filtername, filterargs]
+            end
+          end
+        end
+      end
+    end
+
+    def render(context)
+      return '' if @name.nil?
+      @filters.inject(context[@name]) do |output, filter|
+        filterargs = []
+        keyword_args = {}
+        filter[1].to_a.each do |a|
+          if matches = a.match(/\A#{TagAttributes}\z/o)
+            keyword_args[matches[1]] = context[matches[2]]
+          else
+            filterargs << context[a]
+          end
+        end
+        filterargs << keyword_args unless keyword_args.empty?
+        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