liquid_cms 0.2.0

data/generators/liquid_cms/templates/vendor/plugins/cms_plugins/liquid/lib/liquid/block.rb

@@ -0,0 +1,101 @@
+module Liquid
+
+  class Block < Tag
+    IsTag             = /^#{TagStart}/
+    IsVariable        = /^#{VariableStart}/
+    FullToken         = /^#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}$/
+    ContentOfVariable = /^#{VariableStart}(.*)#{VariableEnd}$/
+
+    def parse(tokens)
+      @nodelist ||= []
+      @nodelist.clear
+
+      while token = tokens.shift
+
+        case token
+        when IsTag
+          if token =~ FullToken
+
+            # if we found the proper block delimitor just end parsing here and let the outer block
+            # proceed
+            if block_delimiter == $1
+              end_tag
+              return
+            end
+
+            # fetch the tag from registered blocks
+            if tag = Template.tags[$1]
+              @nodelist << tag.new($1, $2, tokens)
+            else
+              # this tag is not registered with the system
+              # pass it to the current block for special handling or error reporting
+              unknown_tag($1, $2, tokens)
+            end
+          else
+            raise SyntaxError, "Tag '#{token}' was not properly terminated with regexp: #{TagEnd.inspect} "
+          end
+        when IsVariable
+          @nodelist << create_variable(token)
+        when ''
+          # pass
+        else
+          @nodelist << token
+        end
+      end
+
+      # Make sure that its ok to end parsing in the current block.
+      # Effectively this method will throw and exception unless the current block is
+      # of type Document
+      assert_missing_delimitation!
+    end
+
+    def end_tag
+    end
+
+    def unknown_tag(tag, params, tokens)
+      case tag
+      when 'else'
+        raise SyntaxError, "#{block_name} tag does not expect else tag"
+      when 'end'
+        raise SyntaxError, "'end' is not a valid delimiter for #{block_name} tags. use #{block_delimiter}"
+      else
+        raise SyntaxError, "Unknown tag '#{tag}'"
+      end
+    end
+
+    def block_delimiter
+      "end#{block_name}"
+    end
+
+    def block_name
+      @tag_name
+    end
+
+    def create_variable(token)
+      token.scan(ContentOfVariable) do |content|
+        return Variable.new(content.first)
+      end
+      raise SyntaxError.new("Variable '#{token}' was not properly terminated with regexp: #{VariableEnd.inspect} ")
+    end
+
+    def render(context)
+      render_all(@nodelist, context)
+    end
+
+    protected
+
+    def assert_missing_delimitation!
+      raise SyntaxError.new("#{block_name} tag was never closed")
+    end
+
+    def render_all(list, context)
+      list.collect do |token|
+        begin
+          token.respond_to?(:render) ? token.render(context) : token
+        rescue Exception => e
+          context.handle_error(e)
+        end
+      end
+    end
+  end
+end

data/generators/liquid_cms/templates/vendor/plugins/cms_plugins/liquid/lib/liquid/condition.rb

@@ -0,0 +1,120 @@
+module Liquid
+  # Container for liquid nodes which conveniently wraps decision making logic
+  #
+  # Example:
+  #
+  #   c = Condition.new('1', '==', '1')
+  #   c.evaluate #=> true
+  #
+  class Condition #:nodoc:
+    @@operators = {
+      '==' => lambda { |cond, left, right|  cond.send(:equal_variables, left, right) },
+      '!=' => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
+      '<>' => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
+      '<'  => :<,
+      '>'  => :>,
+      '>=' => :>=,
+      '<=' => :<=,
+      'contains' => lambda { |cond, left, right| left && right ? left.include?(right) : false }
+    }
+
+    def self.operators
+      @@operators
+    end
+
+    attr_reader :attachment
+    attr_accessor :left, :operator, :right
+
+    def initialize(left = nil, operator = nil, right = nil)
+      @left, @operator, @right = left, operator, right
+      @child_relation  = nil
+      @child_condition = nil
+    end
+
+    def evaluate(context = Context.new)
+      result = interpret_condition(left, right, operator, context)
+
+      case @child_relation
+      when :or
+        result || @child_condition.evaluate(context)
+      when :and
+        result && @child_condition.evaluate(context)
+      else
+        result
+      end
+    end
+
+    def or(condition)
+      @child_relation, @child_condition = :or, condition
+    end
+
+    def and(condition)
+      @child_relation, @child_condition = :and, condition
+    end
+
+    def attach(attachment)
+      @attachment = attachment
+    end
+
+    def else?
+      false
+    end
+
+    def inspect
+      "#<Condition #{[@left, @operator, @right].compact.join(' ')}>"
+    end
+
+    private
+
+    def equal_variables(left, right)
+      if left.is_a?(Symbol)
+        if right.respond_to?(left)
+          return right.send(left.to_s)
+        else
+          return nil
+        end
+      end
+
+      if right.is_a?(Symbol)
+        if left.respond_to?(right)
+          return left.send(right.to_s)
+        else
+          return nil
+        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 = self.class.operators[op] || raise(ArgumentError.new("Unknown operator #{op}"))
+
+      if operation.respond_to?(:call)
+        operation.call(self, left, right)
+      elsif left.respond_to?(operation) and right.respond_to?(operation)
+        left.send(operation, right)
+      else
+        nil
+      end
+    end
+  end
+
+
+  class ElseCondition < Condition
+    def else?
+      true
+    end
+
+    def evaluate(context)
+      true
+    end
+  end
+
+end

data/generators/liquid_cms/templates/vendor/plugins/cms_plugins/liquid/lib/liquid/context.rb

@@ -0,0 +1,249 @@
+module Liquid
+
+  # Context keeps the variable stack and resolves variables, as well as keywords
+  #
+  #   context['variable'] = 'testing'
+  #   context['variable'] #=> 'testing'
+  #   context['true']     #=> true
+  #   context['10.2232']  #=> 10.2232
+  #
+  #   context.stack do
+  #      context['bob'] = 'bobsen'
+  #   end
+  #
+  #   context['bob']  #=> nil  class Context
+  class Context
+    attr_reader :scopes, :errors, :registers, :environments
+
+    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false)
+      @environments   = [environments].flatten
+      @scopes         = [(outer_scope || {})]
+      @registers      = registers
+      @errors         = []
+      @rethrow_errors = rethrow_errors
+      squash_instance_assigns_with_environments
+    end
+
+    def strainer
+      @strainer ||= Strainer.create(self)
+    end
+
+    # Adds filters to this context.
+    #
+    # Note that this does not register the filters with the main Template object. see <tt>Template.register_filter</tt>
+    # for that
+    def add_filters(filters)
+      filters = [filters].flatten.compact
+
+      filters.each do |f|
+        raise ArgumentError, "Expected module but got: #{f.class}" unless f.is_a?(Module)
+        strainer.extend(f)
+      end
+    end
+
+    def handle_error(e)
+      errors.push(e)
+      raise if @rethrow_errors || !e.is_a?(Liquid::Error)
+
+      case e
+      when SyntaxError
+        "Liquid syntax error: #{e.message}"
+      else
+        "Liquid error: #{e.message}"
+      end
+    end
+
+    def invoke(method, *args)
+      if strainer.respond_to?(method)
+        strainer.__send__(method, *args)
+      else
+        args.first
+      end
+    end
+
+    # Push new local scope on the stack. use <tt>Context#stack</tt> instead
+    def push(new_scope={})
+      raise StackLevelError, "Nesting too deep" if @scopes.length > 100
+      @scopes.unshift(new_scope)
+    end
+
+    # Merge a hash of variables in the current local scope
+    def merge(new_scopes)
+      @scopes[0].merge!(new_scopes)
+    end
+
+    # Pop from the stack. use <tt>Context#stack</tt> instead
+    def pop
+      raise ContextError if @scopes.size == 1
+      @scopes.shift
+    end
+
+    # Pushes a new local scope on the stack, pops it at the end of the block
+    #
+    # Example:
+    #   context.stack do
+    #      context['var'] = 'hi'
+    #   end
+    #
+    #   context['var]  #=> nil
+    def stack(new_scope={},&block)
+      result = nil
+      push(new_scope)
+
+      begin
+        result = yield
+      ensure
+        pop
+      end
+
+      result
+    end
+
+    def clear_instance_assigns
+      @scopes[0] = {}
+    end
+
+    # Only allow String, Numeric, Hash, Array, Proc, Boolean or <tt>Liquid::Drop</tt>
+    def []=(key, value)
+      @scopes[0][key] = value
+    end
+
+    def [](key)
+      resolve(key)
+    end
+
+    def has_key?(key)
+      resolve(key) != nil
+    end
+
+    private
+      # Look up variable, either resolve directly after considering the name. We can directly handle
+      # Strings, digits, floats and booleans (true,false).
+      # If no match is made we lookup the variable in the current scope and
+      # later move up to the parent blocks to see if we can resolve the variable somewhere up the tree.
+      # Some special keywords return symbols. Those symbols are to be called on the rhs object in expressions
+      #
+      # Example:
+      #   products == empty #=> products.empty?
+      def resolve(key)
+        case key
+        when nil, 'nil', 'null', ''
+          nil
+        when 'true'
+          true
+        when 'false'
+          false
+        when 'blank'
+          :blank?
+        when 'empty' # Single quoted strings
+          :empty?
+        when /^'(.*)'$/ # Double quoted strings
+          $1.to_s
+        when /^"(.*)"$/ # Integer and floats
+          $1.to_s
+        when /^(\d+)$/ # Ranges
+          $1.to_i
+        when /^\((\S+)\.\.(\S+)\)$/ # Floats
+          (resolve($1).to_i..resolve($2).to_i)
+        when /^(\d[\d\.]+)$/
+          $1.to_f
+        else
+          variable(key)
+        end
+      end
+
+      # Fetches an object starting at the local scope and then moving up the hierachy
+      def find_variable(key)
+        scope = @scopes.find { |s| s.has_key?(key) }
+
+        if scope.nil?
+          @environments.each do |e|
+            if variable = lookup_and_evaluate(e, key)
+              scope = e
+              break
+            end
+          end
+        end
+
+        scope     ||= @environments.last || @scopes.last
+        variable  ||= lookup_and_evaluate(scope, key)
+
+        variable = variable.to_liquid
+        variable.context = self if variable.respond_to?(:context=)
+
+        return variable
+      end
+
+      # Resolves namespaced queries gracefully.
+      #
+      # Example
+      #  @context['hash'] = {"name" => 'tobi'}
+      #  assert_equal 'tobi', @context['hash.name']
+      #  assert_equal 'tobi', @context['hash["name"]']
+      def variable(markup)
+        parts = markup.scan(VariableParser)
+        square_bracketed = /^\[(.*)\]$/
+
+        first_part = parts.shift
+
+        if first_part =~ square_bracketed
+          first_part = resolve($1)
+        end
+
+        if object = find_variable(first_part)
+
+          parts.each do |part|
+            part = resolve($1) if part_resolved = (part =~ square_bracketed)
+
+            # If object is a hash- or array-like object we look for the
+            # presence of the key and if its available we return it
+            if object.respond_to?(:[]) and
+              ((object.respond_to?(:has_key?) and object.has_key?(part)) or
+               (object.respond_to?(:fetch) and part.is_a?(Integer)))
+
+              # if its a proc we will replace the entry with the proc
+              res = lookup_and_evaluate(object, part)
+              object = res.to_liquid
+
+              # Some special cases. If the part wasn't in square brackets and
+              # no key with the same name was found we interpret following calls
+              # as commands and call them on the current object
+            elsif !part_resolved and object.respond_to?(part) and ['size', 'first', 'last'].include?(part)
+
+              object = object.send(part.intern).to_liquid
+
+              # No key was present with the desired value and it wasn't one of the directly supported
+              # keywords either. The only thing we got left is to return nil
+            else
+              return nil
+            end
+
+            # If we are dealing with a drop here we have to
+            object.context = self if object.respond_to?(:context=)
+          end
+        end
+
+        object
+      end # variable
+
+      def lookup_and_evaluate(obj, key)
+        if (value = obj[key]).is_a?(Proc) && obj.respond_to?(:[]=)
+          obj[key] = (value.arity == 0) ? value.call : value.call(self)
+        else
+          value
+        end
+      end # lookup_and_evaluate
+
+      def squash_instance_assigns_with_environments
+        @scopes.last.each_key do |k|
+          @environments.each do |env|
+            if env.has_key?(k)
+              scopes.last[k] = lookup_and_evaluate(env, k)
+              break
+            end
+          end
+        end
+      end # squash_instance_assigns_with_environments
+  end # Context
+
+end # Liquid