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