arel 1.0.1 → 2.0.0

data/lib/arel/algebra.rb

@@ -1,10 +0,0 @@
-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'
-require 'arel/algebra/relations'
-require 'arel/algebra/value'
-

data/lib/arel/algebra/attributes.rb

@@ -1,7 +0,0 @@
-require "arel/algebra/attributes/attribute"
-require "arel/algebra/attributes/boolean"
-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"

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

@@ -1,304 +0,0 @@
-require 'set'
-
-module Arel
-  class TypecastError < StandardError ; end
-  class Attribute
-    attr_reader :relation, :name, :alias, :ancestor, :hash
-    attr_reader :history
-
-    def initialize(relation, name, options = {})
-      @relation = relation # this is actually a table (I think)
-      @name     = name
-      @alias    = options[:alias]
-      @ancestor = options[:ancestor]
-      @history  = [self] + (@ancestor ? @ancestor.history : [])
-      @root = @history.last
-      @original_relation = nil
-      @original_attribute = nil
-
-      # FIXME: I think we can remove this eventually
-      @hash     = name.hash + root.relation.class.hash
-    end
-
-    def engine
-      @relation.engine
-    end
-
-    def christener
-      @relation.christener
-    end
-
-    def == other
-      super ||
-        Attribute === other &&
-        @name      == other.name &&
-        @alias     == other.alias &&
-        @ancestor  == other.ancestor &&
-        @relation  == other.relation
-    end
-
-    alias :eql? :==
-
-    def named?(hypothetical_name)
-      (@alias || name).to_s == hypothetical_name.to_s
-    end
-
-    def aggregation?
-      false
-    end
-
-    def eval(row)
-      row[self]
-    end
-
-    def as(aliaz = nil)
-      Attribute.new(relation, name, :alias => aliaz, :ancestor => self)
-    end
-
-    def bind(new_relation)
-      relation == new_relation ? self : Attribute.new(new_relation, name, :alias => @alias, :ancestor => self)
-    end
-
-    def to_attribute(relation)
-      bind(relation)
-    end
-
-    def join?
-      relation.join?
-    end
-
-    def root
-      history.last
-    end
-
-    def original_relation
-      @original_relation ||= original_attribute.relation
-    end
-
-    def original_attribute
-      @original_attribute ||= history.detect { |a| !a.join? }
-    end
-
-    def find_correlate_in(relation)
-      relation[self] || self
-    end
-
-    def descends_from?(other)
-      history.include?(other)
-    end
-
-    def /(other)
-      other ? (history & other.history).size : 0
-    end
-
-    PREDICATES = [
-      :eq, :eq_any, :eq_all, :not_eq, :not_eq_any, :not_eq_all, :lt, :lt_any,
-      :lt_all, :lteq, :lteq_any, :lteq_all, :gt, :gt_any, :gt_all, :gteq,
-      :gteq_any, :gteq_all, :matches, :matches_any, :matches_all, :not_matches,
-      :not_matches_any, :not_matches_all, :in, :in_any, :in_all, :not_in,
-      :not_in_any, :not_in_all
-    ]
-
-    Predications = Class.new do
-      def self.instance_methods *args
-        warn "this module is deprecated, please use the PREDICATES constant"
-        PREDICATES
-      end
-    end
-
-    def eq(other)
-      Predicates::Equality.new(self, other)
-    end
-
-    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 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 not_in_all(*others)
-      Predicates::All.build(Predicates::NotIn, self, *others)
-    end
-
-    module Expressions
-      def count(distinct = false)
-        distinct ?  Distinct.new(self).count :  Count.new(self)
-      end
-
-      def sum
-        Sum.new(self)
-      end
-
-      def maximum
-        Maximum.new(self)
-      end
-
-      def minimum
-        Minimum.new(self)
-      end
-
-      def average
-        Average.new(self)
-      end
-    end
-    include Expressions
-
-    module Orderings
-      def asc
-        Ascending.new(self)
-      end
-
-      def desc
-        Descending.new(self)
-      end
-
-      alias_method :to_ordering, :asc
-    end
-    include Orderings
-
-    module Types
-      def type_cast(value)
-        if root == self
-          raise NotImplementedError, "#type_cast should be implemented in a subclass."
-        else
-          root.type_cast(value)
-        end
-      end
-
-      def type_cast_to_numeric(value, method)
-        return unless value
-        if value.respond_to?(:to_str)
-          str = value.to_str.strip
-          return if str.empty?
-          return $1.send(method) if str =~ /\A(-?(?:0|[1-9]\d*)(?:\.\d+)?|(?:\.\d+))\z/
-        elsif value.respond_to?(method)
-          return value.send(method)
-        end
-        raise typecast_error(value)
-      end
-
-      def typecast_error(value)
-        raise TypecastError, "could not typecast #{value.inspect} to #{self.class.name.split('::').last}"
-      end
-    end
-    include Types
-
-    def column
-      original_relation.column_for(self)
-    end
-
-    def format(object)
-      object.to_sql(Sql::Attribute.new(self))
-    end
-
-    def to_sql(formatter = Sql::WhereCondition.new(relation))
-      formatter.attribute self
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

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

data/lib/arel/algebra/core_extensions.rb

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

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

@@ -1,7 +0,0 @@
-class Hash
-  def bind(relation)
-    Hash[map { |key, value|
-      [key.bind(relation), value.bind(relation)]
-    }]
-  end
-end

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

@@ -1,13 +0,0 @@
-module Arel
-  module ObjectExtensions
-    def bind(relation)
-      Arel::Value.new(self, relation)
-    end
-
-    def find_correlate_in(relation)
-      bind(relation)
-    end
-
-    Object.send(:include, self)
-  end
-end

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

@@ -1,9 +0,0 @@
-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

@@ -1,56 +0,0 @@
-module Arel
-  class Expression < Attribute
-    attr_reader :attribute
-    alias :name :alias
-
-    def initialize(attribute, aliaz = nil, ancestor = nil)
-      super(attribute.relation, aliaz, :alias => aliaz, :ancestor => ancestor)
-      @attribute = attribute
-    end
-
-    def aggregation?
-      true
-    end
-
-    def to_sql(formatter = Sql::SelectClause.new(relation))
-      formatter.expression self
-    end
-
-    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
-
-  class Count < Expression
-    def function_sql; 'COUNT' end
-  end
-
-  class Distinct < Expression
-    def function_sql; 'DISTINCT' end
-  end
-
-  class Sum < Expression
-    def function_sql; 'SUM' end
-  end
-
-  class Maximum < Expression
-    def function_sql; 'MAX' end
-  end
-
-  class Minimum < Expression
-    def function_sql; 'MIN' end
-  end
-
-  class Average < Expression
-    def function_sql; 'AVG' end
-  end
-end
-