Ruby 1.9.1 bugfixes

Signed-off-by: Tobias Lütke <[email protected]>

lib/liquid/condition.rb

@@ -3,7 +3,7 @@ module Liquid
   #
   # Example:
   #
-  #   c = Condition.new('1', '==', '1') 
+  #   c = Condition.new('1', '==', '1')
   #   c.evaluate #=> true
   #
   class Condition #:nodoc:
@@ -17,33 +17,33 @@ module Liquid
       '<=' => :<=,
       'contains' => lambda { |cond, left, right| left.include?(right) },
     }
-    
+
     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)        
-      
+      result = interpret_condition(left, right, operator, context)
+
       case @child_relation
-      when :or 
+      when :or
         result || @child_condition.evaluate(context)
-      when :and 
+      when :and
         result && @child_condition.evaluate(context)
       else
         result
-      end      
-    end                    
-    
+      end
+    end
+
     def or(condition)
       @child_relation, @child_condition = :or, condition
     end
@@ -51,25 +51,25 @@ module Liquid
     def and(condition)
       @child_relation, @child_condition = :and, condition
     end
-  
+
     def attach(attachment)
       @attachment = attachment
     end
-  
+
     def else?
       false
-    end                          
-    
+    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) 
+          return right.send(left.to_s)
         else
           return nil
         end
@@ -77,47 +77,44 @@ module Liquid
 
       if right.is_a?(Symbol)
         if left.respond_to?(right)
-          return left.send(right.to_s) 
+          return left.send(right.to_s)
         else
           return nil
         end
       end
 
-      left == right      
-    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 
+      # 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      
+      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)        
+      elsif left.respond_to?(operation) and right.respond_to?(operation)
         left.send(operation, right)
       else
         nil
       end
-    end    
-  end           
+    end
+  end
 
 
   class ElseCondition < Condition
-      
-    def else? 
+    def else?
       true
     end
-  
+
     def evaluate(context)
       true
     end
   end
 
-end
+end

lib/liquid/context.rb

@@ -224,7 +224,7 @@ module Liquid
 
       object
     end
-    
+
     def filtered_variable(markup)
       Variable.new(markup).render(self)
     end

lib/liquid/drop.rb

@@ -1,9 +1,9 @@
 module Liquid
-  
+
   # A drop in liquid is a class which allows you to to export DOM like things to liquid
-  # Methods of drops are callable. 
-  # The main use for liquid 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 
+  # Methods of drops are callable.
+  # The main use for liquid 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:
@@ -13,38 +13,39 @@ module Liquid
   #      Shop.current.products.find(:all, :order => 'sales', :limit => 10 )
   #   end
   # end
-  #  
-  # tmpl = Liquid::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 
+  # tmpl = Liquid::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
 
-    # Catch all for the method 
+    # Catch all for the method
     def before_method(method)
       nil
     end
-    
+
     # called by liquid to invoke a drop
-    def invoke_drop(method)          
-      if self.class.public_instance_methods.include?(method.to_s)
-        send(method.to_sym) 
-      else        
+    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_liquid
       self
     end
 
     alias :[] :invoke_drop
   end
-  
 end