arel-compat 0.4.0

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

@@ -0,0 +1,21 @@
+module Arel
+  module Attributes
+    class Boolean < Attribute
+      def type_cast(value)
+        case value
+        when true, false then value
+        # when nil            then options[:allow_nil] ? nil : false
+        when nil         then false
+        when 1           then true
+        when 0           then false
+        else
+          case value.to_s.downcase.strip
+          when 'true'  then true
+          when 'false' then false
+          else         raise typecast_error(value)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Arel
+  module Attributes
+    class Decimal < Attribute
+      def type_cast(val)
+        type_cast_to_numeric(val, :to_d)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Arel
+  module Attributes
+    class Float < Attribute
+      def type_cast(val)
+        type_cast_to_numeric(val, :to_f)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+module Arel
+  module Attributes
+    class Integer < Attribute
+      def type_cast(val)
+        type_cast_to_numeric(val, :to_i)
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,10 @@
+module Arel
+  module Attributes
+    class String < Attribute
+      def type_cast(value)
+        return unless value
+        value.to_s
+      end
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+module Arel
+  module Attributes
+    class Time < Attribute
+    end
+  end
+end

data/lib/arel/algebra/core_extensions.rb

@@ -0,0 +1,4 @@
+require 'arel/algebra/core_extensions/object'
+require 'arel/algebra/core_extensions/class'
+require 'arel/algebra/core_extensions/symbol'
+require 'arel/algebra/core_extensions/hash'

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

@@ -0,0 +1,32 @@
+module Arel
+  module ClassExtensions
+    def attributes(*attrs)
+      @attributes = attrs
+      attr_reader(*attrs)
+    end
+
+    def deriving(*methods)
+      methods.each { |m| derive m }
+    end
+
+    def derive(method_name)
+      methods = {
+        :initialize => "
+          def #{method_name}(#{@attributes.join(',')})
+            #{@attributes.collect { |a| "@#{a} = #{a}" }.join("\n")}
+          end
+        ",
+        :== => "
+          def ==(other)
+            #{name} === other &&
+            #{@attributes.collect { |a| "@#{a} == other.#{a}" }.join(" &&\n")}
+          end
+        "
+      }
+      class_eval methods[method_name], __FILE__, __LINE__
+    end
+
+    Class.send(:include, self)
+  end
+end
+

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

@@ -0,0 +1,11 @@
+module Arel
+  module HashExtensions
+    def bind(relation)
+      inject({}) do |bound, (key, value)|
+        bound.merge(key.bind(relation) => value.bind(relation))
+      end
+    end
+
+    Hash.send(:include, self)
+  end
+end

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

@@ -0,0 +1,30 @@
+module Arel
+  module ObjectExtensions
+    def bind(relation)
+      Arel::Value.new(self, relation)
+    end
+
+    def find_correlate_in(relation)
+      bind(relation)
+    end
+
+    def let
+      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/core_extensions/symbol.rb

@@ -0,0 +1,9 @@
+module Arel
+  module SymbolExtensions
+    def to_attribute(relation)
+      Arel::Attribute.new(relation, self)
+    end
+
+    Symbol.send(:include, self)
+  end
+end

data/lib/arel/algebra/expression.rb

@@ -0,0 +1,43 @@
+module Arel
+  class Expression < Attribute
+    attributes :attribute, :alias, :ancestor
+    deriving :==
+    delegate :relation, :to => :attribute
+    alias_method :name, :alias
+
+    def initialize(attribute, aliaz = nil, ancestor = nil)
+      @attribute, @alias, @ancestor = attribute, aliaz, ancestor
+    end
+
+    def aggregation?
+      true
+    end
+
+    def inspect
+      "<#{self.class.name} #{attribute.inspect}>"
+    end
+
+    module Transformations
+      def as(aliaz)
+        self.class.new(attribute, aliaz, self)
+      end
+
+      def bind(new_relation)
+        new_relation == relation ? self : self.class.new(attribute.bind(new_relation), @alias, self)
+      end
+
+      def to_attribute(relation)
+        Attribute.new(relation, @alias, :ancestor => self)
+      end
+    end
+    include Transformations
+  end
+
+  class Count    < Expression; end
+  class Distinct < Expression; end
+  class Sum      < Expression; end
+  class Maximum  < Expression; end
+  class Minimum  < Expression; end
+  class Average  < Expression; 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/ordering.rb

@@ -0,0 +1,23 @@
+module Arel
+  class Ordering
+    delegate :relation, :to => :attribute
+
+    def bind(relation)
+      self.class.new(attribute.bind(relation))
+    end
+
+    def to_ordering
+      self
+    end
+  end
+
+  class Ascending  < Ordering
+    attributes :attribute
+    deriving :initialize, :==
+  end
+
+  class Descending < Ordering
+    attributes :attribute
+    deriving :initialize, :==
+  end
+end

data/lib/arel/algebra/predicates.rb

@@ -0,0 +1,190 @@
+module Arel
+  module Predicates
+    class Predicate
+      def or(other_predicate)
+        Or.new(self, other_predicate)
+      end
+
+      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
+      attributes :operand1, :operand2
+      deriving :initialize
+
+      def ==(other)
+        self.class === other          and
+        @operand1  ==  other.operand1 and
+        @operand2  ==  other.operand2
+      end
+
+      def bind(relation)
+        self.class.new(operand1.find_correlate_in(relation), operand2.find_correlate_in(relation))
+      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 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