arel 0.3.3 → 0.4.0

data/lib/arel/algebra.rb

@@ -1,6 +1,7 @@
 require 'arel/algebra/core_extensions'
 
 require 'arel/algebra/attributes'
+require 'arel/algebra/header'
 require 'arel/algebra/expression'
 require 'arel/algebra/ordering'
 require 'arel/algebra/predicates'

data/lib/arel/algebra/attributes.rb

@@ -4,4 +4,4 @@ require "arel/algebra/attributes/decimal"
 require "arel/algebra/attributes/float"
 require "arel/algebra/attributes/integer"
 require "arel/algebra/attributes/string"
-require "arel/algebra/attributes/time"
+require "arel/algebra/attributes/time"

data/lib/arel/algebra/attributes/attribute.rb

@@ -29,7 +29,7 @@ module Arel
       end
 
       def hash
-        @hash ||= history.size + name.hash + relation.hash
+        @hash ||= name.hash + root.relation.hash
       end
 
       def as(aliaz = nil)
@@ -86,32 +86,120 @@ module Arel
         Predicates::Equality.new(self, other)
       end
 
-      def not(other)
-        Predicates::Not.new(self, other)
+      def eq_any(*others)
+        Predicates::Any.build(Predicates::Equality, self, *others)
+      end
+
+      def eq_all(*others)
+        Predicates::All.build(Predicates::Equality, self, *others)
+      end
+
+      def not_eq(other)
+        Predicates::Inequality.new(self, other)
+      end
+
+      def not_eq_any(*others)
+        Predicates::Any.build(Predicates::Inequality, self, *others)
+      end
+
+      def not_eq_all(*others)
+        Predicates::All.build(Predicates::Inequality, self, *others)
       end
 
       def lt(other)
         Predicates::LessThan.new(self, other)
       end
 
+      def lt_any(*others)
+        Predicates::Any.build(Predicates::LessThan, self, *others)
+      end
+
+      def lt_all(*others)
+        Predicates::All.build(Predicates::LessThan, self, *others)
+      end
+
       def lteq(other)
         Predicates::LessThanOrEqualTo.new(self, other)
       end
 
+      def lteq_any(*others)
+        Predicates::Any.build(Predicates::LessThanOrEqualTo, self, *others)
+      end
+
+      def lteq_all(*others)
+        Predicates::All.build(Predicates::LessThanOrEqualTo, self, *others)
+      end
+
       def gt(other)
         Predicates::GreaterThan.new(self, other)
       end
 
+      def gt_any(*others)
+        Predicates::Any.build(Predicates::GreaterThan, self, *others)
+      end
+
+      def gt_all(*others)
+        Predicates::All.build(Predicates::GreaterThan, self, *others)
+      end
+
       def gteq(other)
         Predicates::GreaterThanOrEqualTo.new(self, other)
       end
 
-      def matches(regexp)
-        Predicates::Match.new(self, regexp)
+      def gteq_any(*others)
+        Predicates::Any.build(Predicates::GreaterThanOrEqualTo, self, *others)
+      end
+
+      def gteq_all(*others)
+        Predicates::All.build(Predicates::GreaterThanOrEqualTo, self, *others)
+      end
+
+      def matches(other)
+        Predicates::Match.new(self, other)
+      end
+
+      def matches_any(*others)
+        Predicates::Any.build(Predicates::Match, self, *others)
+      end
+
+      def matches_all(*others)
+        Predicates::All.build(Predicates::Match, self, *others)
+      end
+
+      def not_matches(other)
+        Predicates::NotMatch.new(self, other)
+      end
+
+      def not_matches_any(*others)
+        Predicates::Any.build(Predicates::NotMatch, self, *others)
+      end
+
+      def not_matches_all(*others)
+        Predicates::All.build(Predicates::NotMatch, self, *others)
+      end
+
+      def in(other)
+        Predicates::In.new(self, other)
+      end
+
+      def in_any(*others)
+        Predicates::Any.build(Predicates::In, self, *others)
+      end
+
+      def in_all(*others)
+        Predicates::All.build(Predicates::In, self, *others)
+      end
+
+      def not_in(other)
+        Predicates::NotIn.new(self, other)
+      end
+
+      def not_in_any(*others)
+        Predicates::Any.build(Predicates::NotIn, self, *others)
       end
 
-      def in(array)
-        Predicates::In.new(self, array)
+      def not_in_all(*others)
+        Predicates::All.build(Predicates::NotIn, self, *others)
       end
     end
     include Predications

data/lib/arel/algebra/attributes/integer.rb

@@ -7,4 +7,4 @@ module Arel
     end
   end
 end
-    
+

data/lib/arel/algebra/core_extensions/object.rb

@@ -12,19 +12,6 @@ module Arel
       yield(self)
     end
 
-    # TODO remove this when ActiveSupport beta1 is out.
-    # Returns the object's singleton class.
-    def singleton_class
-      class << self
-        self
-      end
-    end unless respond_to?(:singleton_class)
-
-    # class_eval on an object acts like singleton_class_eval.
-    def class_eval(*args, &block)
-      singleton_class.class_eval(*args, &block)
-    end
-
     Object.send(:include, self)
   end
 end

data/lib/arel/algebra/header.rb

@@ -0,0 +1,67 @@
+module Arel
+  class Header
+    include Enumerable
+
+    def initialize(attrs = [])
+      @attributes = attrs.to_ary
+      @names = Hash.new do |h,k|
+        h[k] = @attributes.detect { |a| a.named?(k) }
+      end
+    end
+
+    def each(&block)
+      to_ary.each(&block)
+      self
+    end
+
+    def [](key)
+      case key
+      when String, Symbol then find_by_name(key)
+      when Attribute      then find_by_attribute(key)
+      end
+    end
+
+    def ==(other)
+      to_set == other.to_set
+    end
+
+    def union(other)
+      new(to_ary | other)
+    end
+
+    alias | union
+
+    def to_ary
+      @attributes
+    end
+
+    def bind(relation)
+      Header.new(map { |a| a.bind(relation) })
+    end
+
+    # TMP
+    def index(i)
+      to_ary.index(i)
+    end
+
+  private
+
+    def new(attrs)
+      self.class.new(attrs)
+    end
+
+    def matching(attribute)
+      select { |a| !a.is_a?(Value) && a.root == attribute.root }
+    end
+
+    def find_by_name(name)
+      @names[name.to_sym]
+    end
+
+    def find_by_attribute(attr)
+      matching(attr).max do |a, b|
+        (a.original_attribute / attr) <=> (b.original_attribute / attr)
+      end
+    end
+  end
+end

data/lib/arel/algebra/predicates.rb

@@ -8,6 +8,82 @@ module Arel
       def and(other_predicate)
         And.new(self, other_predicate)
       end
+
+      def complement
+        Not.new(self)
+      end
+
+      def not
+        self.complement
+      end
+    end
+
+    class Polyadic < Predicate
+      attributes :predicates
+
+      def initialize(*predicates)
+        @predicates = predicates
+      end
+
+      # Build a Polyadic predicate based on:
+      # * <tt>operator</tt> - The Predicate subclass that defines the type of operation
+      #   (LessThan, Equality, etc)
+      # * <tt>operand1</tt> - The left-hand operand (normally an Arel::Attribute)
+      # * <tt>additional_operands</tt> - All possible right-hand operands
+      def self.build(operator, operand1, *additional_operands)
+        new(
+          *additional_operands.uniq.inject([]) do |predicates, operand|
+            predicates << operator.new(operand1, operand)
+          end
+        )
+      end
+
+      def ==(other)
+        same_elements?(@predicates, other.predicates)
+      end
+
+      def bind(relation)
+        self.class.new(
+          *predicates.map {|p| p.find_correlate_in(relation)}
+        )
+      end
+
+      private
+
+      def same_elements?(a1, a2)
+        [:select, :inject, :size].each do |m|
+          return false unless [a1, a2].each {|a| a.respond_to?(m) }
+        end
+        a1.inject({}) { |h,e| h[e] = a1.select { |i| i == e }.size; h } ==
+        a2.inject({}) { |h,e| h[e] = a2.select { |i| i == e }.size; h }
+      end
+    end
+
+    class Any < Polyadic
+      def complement
+        All.new(*predicates.map {|p| p.complement})
+      end
+    end
+
+    class All < Polyadic
+      def complement
+        Any.new(*predicates.map {|p| p.complement})
+      end
+    end
+
+    class Unary < Predicate
+      attributes :operand
+      deriving :initialize, :==
+
+      def bind(relation)
+        self.class.new(operand.find_correlate_in(relation))
+      end
+    end
+
+    class Not < Unary
+      def complement
+        operand
+      end
     end
 
     class Binary < Predicate
@@ -25,20 +101,90 @@ module Arel
       end
     end
 
+    class CompoundPredicate < Binary; end
+
+    class And < CompoundPredicate
+      def complement
+        Or.new(operand1.complement, operand2.complement)
+      end
+    end
+
+    class Or < CompoundPredicate
+      def complement
+        And.new(operand1.complement, operand2.complement)
+      end
+    end
+
     class Equality < Binary
       def ==(other)
         Equality === other and
           ((operand1 == other.operand1 and operand2 == other.operand2) or
            (operand1 == other.operand2 and operand2 == other.operand1))
       end
+
+      def complement
+        Inequality.new(operand1, operand2)
+      end
     end
 
-    class Not                   < Binary; end
-    class GreaterThanOrEqualTo  < Binary; end
-    class GreaterThan           < Binary; end
-    class LessThanOrEqualTo     < Binary; end
-    class LessThan              < Binary; end
-    class Match                 < Binary; end
-    class In                    < Binary; end
+    class Inequality  < Binary
+      def ==(other)
+        Equality === other and
+          ((operand1 == other.operand1 and operand2 == other.operand2) or
+           (operand1 == other.operand2 and operand2 == other.operand1))
+      end
+
+      def complement
+        Equality.new(operand1, operand2)
+      end
+    end
+
+    class GreaterThanOrEqualTo < Binary
+      def complement
+        LessThan.new(operand1, operand2)
+      end
+    end
+
+    class GreaterThan < Binary
+      def complement
+        LessThanOrEqualTo.new(operand1, operand2)
+      end
+    end
+
+    class LessThanOrEqualTo < Binary
+      def complement
+        GreaterThan.new(operand1, operand2)
+      end
+    end
+
+    class LessThan < Binary
+      def complement
+        GreaterThanOrEqualTo.new(operand1, operand2)
+      end
+    end
+
+    class Match < Binary
+      def complement
+        NotMatch.new(operand1, operand2)
+      end
+    end
+
+    class NotMatch < Binary
+      def complement
+        Match.new(operand1, operand2)
+      end
+    end
+
+    class In < Binary
+      def complement
+        NotIn.new(operand1, operand2)
+      end
+    end
+
+    class NotIn < Binary
+      def complement
+        In.new(operand1, operand2)
+      end
+    end
   end
 end

data/lib/arel/algebra/relations/operations/having.rb

@@ -1,13 +1,17 @@
 module Arel
   class Having < Compound
-    attributes :relation, :havings
-    deriving :==
+    attributes :relation, :predicates
+    deriving   :==
+    requires   :restricting
 
-    def initialize(relation, *havings, &block)
-      @relation = relation
-      @havings = (havings + arguments_from_block(relation, &block)) \
-        .collect { |g| g.bind(relation) }
+    def initialize(relation, *predicates, &block)
+      predicates = [yield(relation)] + predicates if block_given?
+      @predicates = predicates.map { |p| p.bind(relation) }
+      @relation   = relation
+    end
+
+    def havings
+      @havings ||= relation.havings + predicates
     end
   end
 end
-