liquor 0.1.1 → 0.9.1

data/lib/extras/liquor_view.rb

@@ -1,51 +0,0 @@
-# LiquorView is a action view extension class. You can register it with rails
-# and use liquor as an template system for .liquor files
-#
-# Example
-#
-#   ActionView::Base::register_template_handler :liquor, LiquorView
-class LiquorView
-  PROTECTED_ASSIGNS = %w( template_root response _session template_class action_name request_origin session template
-                          _response url _request _cookies variables_added _flash params _headers request cookies
-                          ignore_missing_templates flash _params logger before_filter_chain_aborted headers )
-  PROTECTED_INSTANCE_VARIABLES = %w( @_request @controller @_first_render @_memoized__pick_template @view_paths 
-                                     @helpers @assigns_added @template @_render_stack @template_format @assigns )
-
-  def self.call(template)
-    "LiquorView.new(self).render(template, local_assigns)"
-  end
-
-  def initialize(view)
-    @view = view
-  end
-
-  def render(template, local_assigns = nil)
-    @view.controller.headers["Content-Type"] ||= 'text/html; charset=utf-8'
-
-    # Rails 2.2 Template has source, but not locals
-    if template.respond_to?(:source) && !template.respond_to?(:locals)
-      assigns = (@view.instance_variables - PROTECTED_INSTANCE_VARIABLES).inject({}) do |hash, ivar|
-                  hash[ivar[1..-1]] = @view.instance_variable_get(ivar)
-                  hash
-                end
-    else
-      assigns = @view.assigns.reject{ |k,v| PROTECTED_ASSIGNS.include?(k) }
-    end
-
-    source = template.respond_to?(:source) ? template.source : template
-    local_assigns = (template.respond_to?(:locals) ? template.locals : local_assigns) || {}
-
-    if content_for_layout = @view.instance_variable_get("@content_for_layout")
-      assigns['content_for_layout'] = content_for_layout
-    end
-    assigns.merge!(local_assigns.stringify_keys)
-
-    liquor = Liquor::Template.parse(source)
-    liquor.render(assigns, :filters => [@view.controller.master_helper_module], :registers => {:action_view => @view, :controller => @view.controller})
-  end
-
-  def compilable?
-    false
-  end
-
-end

data/lib/liquor/block.rb

@@ -1,101 +0,0 @@
-module Liquor
-
-  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/lib/liquor/condition.rb

@@ -1,120 +0,0 @@
-module Liquor
-  # Container for liquor 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/lib/liquor/document.rb

@@ -1,17 +0,0 @@
-module Liquor
-  class Document < Block
-    # we don't need markup to open this block
-    def initialize(tokens)
-      parse(tokens)
-    end
-
-    # There isn't a real delimter
-    def block_delimiter
-      []
-    end
-
-    # Document blocks don't need to be terminated since they are not actually opened
-    def assert_missing_delimitation!
-    end
-  end
-end

data/lib/liquor/drop.rb

@@ -1,256 +0,0 @@
-module Liquor
-
-  # A drop in liquor is a class which allows you to to export DOM like things to liquor
-  # Methods of drops are callable.
-  # The main use for liquor drops is the implement lazy loaded objects.
-  # If you would like to make data available to the web designers which you don't want loaded unless needed then
-  # a drop is a great way to do that
-  #
-  # Example:
-  #
-  # class ProductDrop < Liquor::Drop
-  #   def top_sales
-  #      Shop.current.products.find(:all, :order => 'sales', :limit => 10 )
-  #   end
-  # end
-  #
-  # tmpl = Liquor::Template.parse( ' {% for product in product.top_sales %} {{ product.name }} {%endfor%} '  )
-  # tmpl.render('product' => ProductDrop.new ) # will invoke top_sales query.
-  #
-  # Your drop can either implement the methods sans any parameters or implement the before_method(name) method which is a
-  # catch all
-  class Drop
-    attr_writer :context
-
-    class_attribute :liquor_attributes
-    self.liquor_attributes = []
-
-    class_attribute :liquor_scopes
-    self.liquor_scopes = []
-    attr_reader :source
-
-    class_attribute :has_manies
-    self.has_manies = []
-
-    def logger
-      Rails.logger
-    end
-
-    def self.allow_all_methods(allow = true)
-      if allow
-        class_eval <<-"END"
-          def before_method(method)
-            @source.send(method.to_sym)
-          end
-
-          def respond_to?(val)
-            return true if @source.respond_to?(val.to_sym)
-            return true if liquor_attributes.include? val.to_sym
-            super
-          end
-        END
-      end
-    end
-        
-    def self.has_one(name)
-      self.instance_eval do
-        define_method(name) do
-          (@source.send(name)).to_liquor
-        end
-      end  
-    end
-
-    def self.belongs_to(name)    
-      self.instance_eval do
-        define_method(name) do
-          (@source.send(name)).to_liquor
-        end
-      end
-    end
-    
-    def respond_to?(val)
-      return true if liquor_attributes.include? val.to_sym
-      super
-    end
-
-    def self.has_many(name, options={})
-      options = options.reverse_merge({ :class_name => name.to_s.classify + "Drop", :sort_scope => :recent, :source_class_name => name.to_s.classify })
-
-      klass = options[:class_name].constantize
-      source_klass = options[:source_class_name].constantize
-
-      self.class_eval do
-        self.has_manies << name
-
-        define_method name do
-          proxy = DropProxy.new(self, name, klass)
-          proxy = proxy.send(options[:with_scope]) if options[:with_scope].present? && source_klass.respond_to?(options[:with_scope])
-          proxy = proxy.send(options[:sort_scope]) if options[:sort_scope].present? && source_klass.respond_to?(options[:sort_scope])
-          proxy
-        end
-      end
-    end
-    
-    def initialize(source = nil)
-      @source = source
-      @liquor = liquor_attributes.inject({}) { |h, k| h.update k.to_s => @source.send(k) }
-    end
-    
-    def drop_name
-      self.class.name
-    end
-
-    def source_id
-     @source.id
-    end
-
-    def has_scope?(meth)
-      liquor_scopes.include?(meth.to_sym)
-    end
-
-    def has_many?(meth)
-      has_manies.include?(meth.to_sym)
-    end
-    
-    # Catch all for the method
-    def before_method(method)
-      @liquor[method.to_s]
-    end
-
-    def ==(comparison_object)
-      our_self = self.source ? self.source : source
-      our_self == (comparison_object.is_a?(self.class) ? comparison_object.source : comparison_object)
-    end
-
-    # called by liquor to invoke a drop
-    def invoke_drop(method)
-      # for backward compatibility with Ruby 1.8
-      methods = self.class.public_instance_methods.map { |m| m.to_s }
-      if methods.include?(method.to_s)
-        send(method.to_sym)
-      else
-        before_method(method)
-      end
-    end
-
-    def has_key?(name)
-      true
-    end
-
-    def to_liquor
-      self
-    end
-    
-    def as_json(options = {})
-      options = options.duplicable? ? options.dup : {}
-      
-      only = liquor_attributes
-
-      if options[:include].present?
-        klass_name = options[:include].to_s.singularize.classify + "Drop"
-        only += klass_name.constantize.liquor_attributes
-      end
-
-      options = options.reverse_merge(:only => only)
-      @source.as_json(options)
-    end
-
-    alias :[] :invoke_drop
-        
-    # converts an array of records to an array of liquor drops, and assigns the given context to each of them
-    def self.liquify(current_context, *records, &block)
-      i = -1
-      records = 
-        records.inject [] do |all, r|
-          i+=1
-          attrs = (block && block.arity == 1) ? [r] : [r, i]
-          all << (block ? block.call(*attrs) : r.to_liquor)
-          all.last.context = current_context if all.last.is_a?(Drop)
-          all
-        end
-      records.compact!
-      records
-    end
-
-    protected
-       def liquify(*records, &block)
-         self.class.liquify(@context, *records, &block)
-       end
-       
-    class DropProxy
-      attr_reader :current, :parent
-
-      def initialize(parent, name, klass)
-        @parent = parent
-        @klass = klass
-
-        if @parent.class == DropProxy
-          @current = @parent.current
-        elsif name.present?
-          @current = @parent.source.send name
-        end  
-      end
-
-      def liquify(*collection)
-        @parent.send :liquify, *collection
-      end
-
-      def self.liquor_scopes
-        @parent.class.liquor_scopes
-      end
-
-      #
-      # It is very important that we do not delegate the 'to_liquor' method and it returns 'self'.
-      NON_DELEGATE_METHODS = ['class', 'send', 'to_liquor', 'respond_to?']
-      [].methods.each do |m|
-        unless m =~ /^__/ || NON_DELEGATE_METHODS.include?(m.to_s)
-          delegate m, :to => :proxy_found
-        end
-      end
-
-      def to_liquor
-        self
-      end
-
-      def proxy_found
-        @collection ||= get_collection
-        @parent.send :liquify, *@collection
-      end
-
-      def has_scope?(meth)
-        @klass.liquor_scopes.include?(meth.to_sym)
-      end
-
-      private
-        def method_missing(meth, *args)
-          if has_scope?(meth)
-            converted_args = args.collect{|arg| 
-              if arg.is_a? DropProxy
-                arg.current
-              elsif arg.is_a?(Drop)
-                arg.source
-              else
-                if arg.is_a?(Array)
-                  arg = arg.collect{|x| x.source }
-                end
-                arg
-              end
-            }
-            @current = @current.send(meth, *converted_args)
-            DropProxy.new(self, meth, @klass)
-          else
-            super
-          end
-        end
-
-        def get_collection
-          @collection = @current
-        end
-
-         # HACK
-        def set_current(val)
-          @current = val
-        end
-    end
-  end
-end