squeel 0.5.0

data/lib/squeel/nodes/nary.rb

@@ -0,0 +1,35 @@
+module Squeel
+  module Nodes
+    class Nary
+      include PredicateOperators
+
+      attr_reader :children
+
+      def initialize(children)
+        raise ArgumentError, '#{self.class} requires an array' unless Array === children
+        # We don't dup here, as incoming arrays should be created by the
+        # Operators#& method on other nodes. If you're creating And nodes
+        # manually, by sure that they're new arays.
+        @children = children
+      end
+
+      def &(other)
+        @children << other
+        self
+      end
+
+      def -(other)
+        @children << Not.new(other)
+        self
+      end
+
+      def eql?(other)
+        self.class     == other.class &&
+        self.children  == other.children
+      end
+
+      alias :== :eql?
+
+    end
+  end
+end

data/lib/squeel/nodes/not.rb

@@ -0,0 +1,8 @@
+require 'squeel/nodes/unary'
+
+module Squeel
+  module Nodes
+    class Not < Unary
+    end
+  end
+end

data/lib/squeel/nodes/operation.rb

@@ -0,0 +1,23 @@
+require 'squeel/nodes/function'
+
+module Squeel
+  module Nodes
+    class Operation < Function
+
+      def initialize(left, operator, right)
+        super(operator, [left, right])
+      end
+
+      alias :operator :name
+
+      def left
+        args[0]
+      end
+
+      def right
+        args[1]
+      end
+
+    end
+  end
+end

data/lib/squeel/nodes/operators.rb

@@ -0,0 +1,27 @@
+module Squeel
+  module Nodes
+    module Operators
+
+      def +(value)
+        Operation.new(self, :+, value)
+      end
+
+      def -(value)
+        Operation.new(self, :-, value)
+      end
+
+      def *(value)
+        Operation.new(self, :*, value)
+      end
+
+      def /(value)
+        Operation.new(self, :/, value)
+      end
+
+      def op(operator, value)
+        Operation.new(self, operator, value)
+      end
+
+    end
+  end
+end

data/lib/squeel/nodes/or.rb

@@ -0,0 +1,8 @@
+require 'squeel/nodes/binary'
+
+module Squeel
+  module Nodes
+    class Or < Binary
+    end
+  end
+end

data/lib/squeel/nodes/order.rb

@@ -0,0 +1,35 @@
+module Squeel
+  module Nodes
+    class Order
+      attr_reader :expr, :direction
+
+      def initialize(expr, direction = 1)
+        raise ArgumentError, "Direction #{direction} is not valid. Must be -1 or 1." unless [-1,1].include? direction
+        @expr, @direction = expr, direction
+      end
+
+      def asc
+        @direction = 1
+        self
+      end
+
+      def desc
+        @direction = -1
+        self
+      end
+
+      def ascending?
+        @direction == 1
+      end
+
+      def descending?
+        @direction == -1
+      end
+
+      def reverse!
+        @direction = - @direction
+        self
+      end
+    end
+  end
+end

data/lib/squeel/nodes/predicate.rb

@@ -0,0 +1,49 @@
+require 'squeel/predicate_methods'
+require 'squeel/nodes/predicate_operators'
+
+module Squeel
+  module Nodes
+    class Predicate
+
+      include PredicateMethods
+      include PredicateOperators
+
+      attr_accessor :value
+      attr_reader :expr, :method_name
+
+      def initialize(expr, method_name = :eq, value = :__undefined__)
+        @expr, @method_name, @value = expr, method_name, value
+      end
+
+      def eql?(other)
+        self.class.eql?(other.class) &&
+        self.expr.eql?(other.expr) &&
+        self.method_name.eql?(other.method_name) &&
+        self.value.eql?(other.value)
+      end
+
+      alias :== :eql?
+
+      def hash
+        [self.class, expr, method_name, value].hash
+      end
+
+      def value?
+        @value != :__undefined__
+      end
+
+      def %(val)
+        @value = val
+        self
+      end
+
+      # expand_hash_conditions_for_aggregates assumes our hash keys can be
+      # converted to symbols, so this has to be implemented, but it doesn't
+      # really have to do anything useful.
+      def to_sym
+        nil
+      end
+
+    end
+  end
+end

data/lib/squeel/nodes/predicate_operators.rb

@@ -0,0 +1,17 @@
+module Squeel
+  module Nodes
+    module PredicateOperators
+      def |(other)
+        Or.new(self, other)
+      end
+
+      def &(other)
+        And.new([self, other])
+      end
+
+      def -@
+        Not.new(self)
+      end
+    end
+  end
+end

data/lib/squeel/nodes/stub.rb

@@ -0,0 +1,113 @@
+require 'squeel/predicate_methods'
+require 'squeel/nodes/operators'
+
+module Squeel
+  module Nodes
+    class Stub
+
+      include PredicateMethods
+      include Operators
+
+      attr_reader :symbol
+
+      def initialize(symbol)
+        @symbol = symbol
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+        self.symbol == other.symbol
+      end
+
+      def hash
+        symbol.hash
+      end
+
+      def to_sym
+        symbol
+      end
+
+      def to_s
+        symbol.to_s
+      end
+
+      def method_missing(method_id, *args)
+        super if method_id == :to_ary
+        KeyPath.new(self.symbol, method_id)
+      end
+
+      def ==(value)
+        Predicate.new self.symbol, :eq, value
+      end
+
+      # Won't work on Ruby 1.8.x so need to do this conditionally
+      define_method('!=') do |value|
+        Predicate.new(self.symbol, :not_eq, value)
+      end if respond_to?('!=')
+
+      def ^(value)
+        Predicate.new self.symbol, :not_eq, value
+      end
+
+      def >>(value)
+        Predicate.new self.symbol, :in, value
+      end
+
+      def <<(value)
+        Predicate.new self.symbol, :not_in, value
+      end
+
+      def =~(value)
+        Predicate.new self.symbol, :matches, value
+      end
+
+      # Won't work on Ruby 1.8.x so need to do this conditionally
+      define_method('!~') do |value|
+        Predicate.new(self.symbol, :does_not_match, value)
+      end if respond_to?('!~')
+
+      def >(value)
+        Predicate.new self.symbol, :gt, value
+      end
+
+      def >=(value)
+        Predicate.new self.symbol, :gteq, value
+      end
+
+      def <(value)
+        Predicate.new self.symbol, :lt, value
+      end
+
+      def <=(value)
+        Predicate.new self.symbol, :lteq, value
+      end
+
+      def asc
+        Order.new self.symbol, 1
+      end
+
+      def desc
+        Order.new self.symbol, -1
+      end
+
+      def func(*args)
+        Function.new(self.symbol, args)
+      end
+
+      alias :[] :func
+
+      def inner
+        Join.new(self.symbol, Arel::InnerJoin)
+      end
+
+      def outer
+        Join.new(self.symbol, Arel::OuterJoin)
+      end
+
+      def of_class(klass)
+        Join.new(self.symbol, Arel::InnerJoin, klass)
+      end
+
+    end
+  end
+end

data/lib/squeel/nodes/unary.rb

@@ -0,0 +1,22 @@
+require 'squeel/nodes/predicate_operators'
+
+module Squeel
+  module Nodes
+    class Unary
+      include PredicateOperators
+
+      attr_reader :expr
+
+      def initialize(expr)
+        @expr = expr
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+        self.expr  == other.expr
+      end
+
+      alias :== :eql?
+    end
+  end
+end

data/lib/squeel/predicate_methods.rb

@@ -0,0 +1,22 @@
+require 'squeel/predicate_methods/symbol'
+require 'squeel/predicate_methods/stub'
+require 'squeel/predicate_methods/predicate'
+require 'squeel/predicate_methods/function'
+
+module Squeel
+  module PredicateMethods
+
+    def self.included(base)
+      base.send :include, const_get(base.name.split(/::/)[-1].to_sym)
+    end
+
+    Constants::PREDICATES.each do |method_name|
+      class_eval <<-RUBY
+        def #{method_name}(value = :__undefined__)
+          predicate :#{method_name}, value
+        end
+      RUBY
+    end
+
+  end
+end

data/lib/squeel/predicate_methods/function.rb

@@ -0,0 +1,9 @@
+module Squeel
+  module PredicateMethods
+    module Function
+      def predicate(method_name, value = :__undefined__)
+        Nodes::Predicate.new self, method_name, value
+      end
+    end
+  end
+end

data/lib/squeel/predicate_methods/predicate.rb

@@ -0,0 +1,11 @@
+module Squeel
+  module PredicateMethods
+    module Predicate
+      def predicate(method_name, value = :__undefined__)
+        @method_name = method_name
+        @value = value unless value == :__undefined__
+        self
+      end
+    end
+  end
+end

data/lib/squeel/predicate_methods/stub.rb

@@ -0,0 +1,9 @@
+module Squeel
+  module PredicateMethods
+    module Stub
+      def predicate(method_name, value = :__undefined__)
+        Nodes::Predicate.new self.symbol, method_name, value
+      end
+    end
+  end
+end

data/lib/squeel/predicate_methods/symbol.rb

@@ -0,0 +1,9 @@
+module Squeel
+  module PredicateMethods
+    module Symbol
+      def predicate(method_name, value = :__undefined__)
+        Nodes::Predicate.new self, method_name, value
+      end
+    end
+  end
+end

data/lib/squeel/version.rb

@@ -0,0 +1,3 @@
+module Squeel
+  VERSION = "0.5.0"
+end

data/lib/squeel/visitors.rb

@@ -0,0 +1,3 @@
+require 'squeel/visitors/predicate_visitor'
+require 'squeel/visitors/order_visitor'
+require 'squeel/visitors/select_visitor'

data/lib/squeel/visitors/base.rb

@@ -0,0 +1,46 @@
+require 'active_support/core_ext/module'
+require 'squeel/nodes'
+
+module Squeel
+  module Visitors
+    class Base
+      attr_accessor :context
+      delegate :contextualize, :find, :traverse, :sanitize_sql, :engine, :arel_visitor, :to => :context
+
+      def initialize(context = nil)
+        @context = context
+      end
+
+      def accept(object, parent = context.base)
+        visit(object, parent)
+      end
+
+      def can_accept?(object)
+        respond_to? DISPATCH[object.class]
+      end
+
+      def self.can_accept?(object)
+        method_defined? DISPATCH[object.class]
+      end
+
+      private
+
+      DISPATCH = Hash.new do |hash, klass|
+        hash[klass] = "visit_#{klass.name.gsub('::', '_')}"
+      end
+
+      def quoted?(object)
+        case object
+        when Arel::Nodes::SqlLiteral, Bignum, Fixnum
+          false
+        else
+          true
+        end
+      end
+
+      def visit(object, parent)
+        send(DISPATCH[object.class], object, parent)
+      end
+    end
+  end
+end