arel 1.0.1 → 2.0.0

data/lib/arel/algebra/header.rb

@@ -1,66 +0,0 @@
-module Arel
-  class Header
-    include Enumerable
-
-    def initialize(attrs = [])
-      @attributes = attrs.to_ary
-      @names      = {}
-    end
-
-    def each
-      to_ary.each { |e| yield e }
-      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)
-      k = name.to_sym
-      @names[k] ||= @attributes.detect { |a| a.named?(k) }
-    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

@@ -1,31 +0,0 @@
-module Arel
-  class Ordering < Struct.new(:attribute)
-    delegate :relation, :to => :attribute
-
-    def bind(relation)
-      self.class.new(attribute.bind(relation))
-    end
-
-    def to_ordering
-      self
-    end
-
-    def eval(row1, row2)
-      (attribute.eval(row1) <=> attribute.eval(row2)) * direction
-    end
-
-    def to_sql(formatter = Sql::OrderClause.new(relation))
-      formatter.ordering self
-    end
-  end
-
-  class Ascending  < Ordering
-    def direction; 1 end
-    def direction_sql; 'ASC' end
-  end
-
-  class Descending < Ordering
-    def direction_sql; 'DESC' end
-    def direction; -1 end
-  end
-end

data/lib/arel/algebra/predicates.rb

@@ -1,306 +0,0 @@
-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
-      attr_reader :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.map do |operand|
-            operator.new(operand1, operand)
-          end
-        )
-      end
-
-      def ==(other)
-        super || predicates == other.predicates
-      end
-
-      def bind(relation)
-        self.class.new(
-          *predicates.map {|p| p.find_correlate_in(relation)}
-        )
-      end
-
-      def eval(row)
-        predicates.send(compounder) do |operation|
-          operation.eval(row)
-        end
-      end
-
-      def to_sql(formatter = nil)
-        "(" +
-          predicates.map {|p| p.to_sql(formatter)}.join(" #{predicate_sql} ") +
-        ")"
-      end
-    end
-
-    class Any < Polyadic
-      def complement
-        All.new(*predicates.map {|p| p.complement})
-      end
-
-      def compounder; :any? end
-
-      def predicate_sql; "OR" end
-    end
-
-    class All < Polyadic
-      def complement
-        Any.new(*predicates.map {|p| p.complement})
-      end
-
-      def compounder; :all? end
-
-      def predicate_sql; "AND" end
-    end
-
-    class Unary < Predicate
-      attr_reader :operand
-
-      def initialize operand
-        @operand = operand
-      end
-
-      def bind(relation)
-        self.class.new(operand.find_correlate_in(relation))
-      end
-
-      def == other
-        super || self.class === other && operand == other.operand
-      end
-
-      def eval(row)
-        operand.eval(row).send(operator)
-      end
-
-      def to_sql(formatter = nil)
-        "#{predicate_sql} (#{operand.to_sql(formatter)})"
-      end
-    end
-
-    class Not < Unary
-      def complement
-        operand
-      end
-
-      def eval(row)
-        !operand.eval(row)
-      end
-
-      def predicate_sql; "NOT" end
-    end
-
-    class Binary < Unary
-      attr_reader :operand2
-      alias :operand1 :operand
-
-      def initialize left, right
-        super(left)
-        @operand2 = right
-      end
-
-      def ==(other)
-        super && @operand2 == other.operand2
-      end
-
-      def bind(relation)
-        self.class.new(operand1.find_correlate_in(relation), operand2.find_correlate_in(relation))
-      end
-
-      def eval(row)
-        operand1.eval(row).send(operator, operand2.eval(row))
-      end
-
-      def to_sql(formatter = nil)
-        "#{operand1.to_sql} #{predicate_sql} #{operand1.format(operand2)}"
-      end
-      alias :value :to_sql
-    end
-
-    class CompoundPredicate < Binary
-      def eval(row)
-        eval "operand1.eval(row) #{operator} operand2.eval(row)"
-      end
-
-      def to_sql(formatter = nil)
-        "(#{operand1.to_sql(formatter)} #{predicate_sql} #{operand2.to_sql(formatter)})"
-      end
-    end
-
-    class And < CompoundPredicate
-      def complement
-        Or.new(operand1.complement, operand2.complement)
-      end
-
-      def operator; :and end
-
-      def predicate_sql; "AND" end
-    end
-
-    class Or < CompoundPredicate
-      def complement
-        And.new(operand1.complement, operand2.complement)
-      end
-
-      def operator; :or end
-
-      def predicate_sql; "OR" end
-    end
-
-    class Equality < Binary
-      def ==(other)
-        self.class === 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
-
-      def operator; :== end
-
-      def predicate_sql
-        operand2.equality_predicate_sql
-      end
-    end
-
-    class Inequality < Equality
-      def complement
-        Equality.new(operand1, operand2)
-      end
-
-      def operator; :"!=" end
-      def eval(row)
-        operand1.eval(row) != operand2.eval(row)
-      end
-
-      def predicate_sql
-        operand2.inequality_predicate_sql
-      end
-    end
-
-    class GreaterThanOrEqualTo < Binary
-      def complement
-        LessThan.new(operand1, operand2)
-      end
-
-      def operator; :>= end
-
-      def predicate_sql; '>=' end
-    end
-
-    class GreaterThan < Binary
-      def complement
-        LessThanOrEqualTo.new(operand1, operand2)
-      end
-
-      def operator; :> end
-
-      def predicate_sql; '>' end
-    end
-
-    class LessThanOrEqualTo < Binary
-      def complement
-        GreaterThan.new(operand1, operand2)
-      end
-
-      def operator; :<= end
-
-      def predicate_sql; '<=' end
-    end
-
-    class LessThan < Binary
-      def complement
-        GreaterThanOrEqualTo.new(operand1, operand2)
-      end
-
-      def operator; :< end
-
-      def predicate_sql; '<' end
-    end
-
-    class Match < Binary
-      def complement
-        NotMatch.new(operand1, operand2)
-      end
-
-      def operator; :=~ end
-
-      def predicate_sql; 'LIKE' end
-    end
-
-    class NotMatch < Binary
-      def complement
-        Match.new(operand1, operand2)
-      end
-
-      def eval(row)
-        operand1.eval(row) !~ operand2.eval(row)
-      end
-
-      def predicate_sql; 'NOT LIKE' end
-    end
-
-    class In < Binary
-      def complement
-        NotIn.new(operand1, operand2)
-      end
-
-      def eval(row)
-        operand2.eval(row).include?(operand1.eval(row))
-      end
-
-      def to_sql(formatter = nil)
-        if operand2.is_a?(Range) && operand2.exclude_end?
-          GreaterThanOrEqualTo.new(operand1, operand2.begin).and(
-            LessThan.new(operand1, operand2.end)
-          ).to_sql(formatter)
-        else
-          super
-        end
-      end
-
-      def predicate_sql; operand2.inclusion_predicate_sql end
-    end
-
-    class NotIn < Binary
-      def complement
-        In.new(operand1, operand2)
-      end
-
-      def eval(row)
-        !(operand2.eval(row).include?(operand1.eval(row)))
-      end
-
-      def predicate_sql; operand2.exclusion_predicate_sql end
-    end
-  end
-end

data/lib/arel/algebra/relations.rb

@@ -1,16 +0,0 @@
-require 'arel/algebra/relations/relation'
-require 'arel/algebra/relations/utilities/compound'
-require 'arel/algebra/relations/utilities/nil'
-require 'arel/algebra/relations/utilities/externalization'
-require 'arel/algebra/relations/row'
-require 'arel/algebra/relations/writes'
-require 'arel/algebra/relations/operations/from'
-require 'arel/algebra/relations/operations/group'
-require 'arel/algebra/relations/operations/having'
-require 'arel/algebra/relations/operations/join'
-require 'arel/algebra/relations/operations/order'
-require 'arel/algebra/relations/operations/project'
-require 'arel/algebra/relations/operations/where'
-require 'arel/algebra/relations/operations/skip'
-require 'arel/algebra/relations/operations/take'
-require 'arel/algebra/relations/operations/lock'

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

@@ -1,14 +0,0 @@
-module Arel
-  class From < Compound
-    attr_reader :sources
-
-    def initialize relation, sources
-      super(relation)
-      @sources = sources
-    end
-
-    def eval
-      unoperated_rows[sources..-1]
-    end
-  end
-end

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

@@ -1,14 +0,0 @@
-module Arel
-  class Group < Compound
-    attr_reader :groupings
-
-    def initialize(relation, groupings)
-      super(relation)
-      @groupings = groupings.collect { |g| g.bind(relation) }
-    end
-
-    def eval
-      raise NotImplementedError
-    end
-  end
-end