squeel 0.5.0

data/lib/squeel/configuration.rb

@@ -0,0 +1,25 @@
+require 'squeel/constants'
+require 'squeel/predicate_methods'
+
+module Squeel
+  module Configuration
+
+    def configure
+      yield self
+    end
+
+    def load_core_extensions(*exts)
+      exts.each do |ext|
+        require "core_ext/#{ext}"
+      end
+    end
+
+    def alias_predicate(new_name, existing_name)
+      raise ArgumentError, 'the existing name should be the base name, not an _any/_all variation' if existing_name.to_s =~ /(_any|_all)$/
+      ['', '_any', '_all'].each do |suffix|
+        PredicateMethods.class_eval "alias :#{new_name}#{suffix} :#{existing_name}#{suffix} unless defined?(#{new_name}#{suffix})"
+      end
+    end
+
+  end
+end

data/lib/squeel/constants.rb

@@ -0,0 +1,23 @@
+module Squeel
+  module Constants
+    PREDICATES = [
+       :eq, :eq_any, :eq_all,
+       :not_eq, :not_eq_any, :not_eq_all,
+       :matches, :matches_any, :matches_all,
+       :does_not_match, :does_not_match_any, :does_not_match_all,
+       :lt, :lt_any, :lt_all,
+       :lteq, :lteq_any, :lteq_all,
+       :gt, :gt_any, :gt_all,
+       :gteq, :gteq_any, :gteq_all,
+       :in, :in_any, :in_all,
+       :not_in, :not_in_any, :not_in_all
+     ].freeze
+
+     PREDICATE_ALIASES = {
+       :matches        => [:like],
+       :does_not_match => [:not_like],
+       :lteq           => [:lte],
+       :gteq           => [:gte]
+     }.freeze
+  end
+end

data/lib/squeel/contexts/join_dependency_context.rb

@@ -0,0 +1,74 @@
+require 'active_record'
+
+module Squeel
+  # Because the AR::Associations namespace is insane
+  JoinPart = ActiveRecord::Associations::JoinDependency::JoinPart
+
+  module Contexts
+    class JoinDependencyContext
+      attr_reader :base, :engine, :arel_visitor
+
+      def initialize(join_dependency)
+        @join_dependency = join_dependency
+        @base = join_dependency.join_base
+        @engine = @base.arel_engine
+        @arel_visitor = Arel::Visitors.visitor_for @engine
+        @default_table = Arel::Table.new(@base.table_name, :as => @base.aliased_table_name, :engine => @engine)
+        @tables = Hash.new {|hash, key| hash[key] = get_table(key)}
+      end
+
+      def find(object, parent = @base)
+        if JoinPart === parent
+          object = object.to_sym if String === object
+          case object
+          when Symbol, Nodes::Stub
+            @join_dependency.join_associations.detect { |j|
+              j.reflection.name == object.to_sym && j.parent == parent
+            }
+          when Nodes::Join
+            @join_dependency.join_associations.detect { |j|
+              j.reflection.name == object.name && j.parent == parent &&
+              (object.polymorphic? ? j.reflection.klass == object.klass : true)
+            }
+          else
+            @join_dependency.join_associations.detect { |j|
+              j.reflection == object && j.parent == parent
+            }
+          end
+        else
+          nil
+        end
+      end
+
+      def traverse(keypath, parent = @base, include_endpoint = false)
+        parent = @base if keypath.absolute?
+        keypath.path.each do |key|
+          parent = find(key, parent)
+        end
+        parent = find(keypath.endpoint, parent) if include_endpoint
+
+        parent
+      end
+
+      def contextualize(object)
+        @tables[object]
+      end
+
+      def sanitize_sql(conditions, parent)
+        parent.active_record.send(:sanitize_sql, conditions, parent.aliased_table_name)
+      end
+
+      private
+
+      def get_table(object)
+        if [Symbol, Nodes::Stub].include?(object.class)
+          Arel::Table.new(object.to_sym, :engine => @engine)
+        elsif object.respond_to?(:aliased_table_name)
+          Arel::Table.new(object.table_name, :as => object.aliased_table_name, :engine => @engine)
+        else
+          @default_table
+        end
+      end
+    end
+  end
+end

data/lib/squeel/dsl.rb

@@ -0,0 +1,31 @@
+module Squeel
+  class DSL
+
+    Squeel.evil_things do
+      (instance_methods + private_instance_methods).each do |method|
+        unless method.to_s =~ /^(__|instance_eval)/
+          undef_method method
+        end
+      end
+    end
+
+    def self.evaluate(&block)
+      if block.arity > 0
+        yield self.new
+      else
+        self.new.instance_eval(&block)
+      end
+    end
+
+    def method_missing(method_id, *args)
+      if args.empty?
+        Nodes::Stub.new method_id
+      elsif (args.size == 1) && (Class === args[0])
+        Nodes::Join.new(method_id, Arel::InnerJoin, args[0])
+      else
+        Nodes::Function.new method_id, args
+      end
+    end
+
+  end
+end

data/lib/squeel/nodes.rb

@@ -0,0 +1,10 @@
+require 'squeel/nodes/stub'
+require 'squeel/nodes/key_path'
+require 'squeel/nodes/predicate'
+require 'squeel/nodes/function'
+require 'squeel/nodes/operation'
+require 'squeel/nodes/order'
+require 'squeel/nodes/and'
+require 'squeel/nodes/or'
+require 'squeel/nodes/not'
+require 'squeel/nodes/join'

data/lib/squeel/nodes/and.rb

@@ -0,0 +1,8 @@
+require 'squeel/nodes/nary'
+
+module Squeel
+  module Nodes
+    class And < Nary
+    end
+  end
+end

data/lib/squeel/nodes/binary.rb

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

data/lib/squeel/nodes/function.rb

@@ -0,0 +1,84 @@
+require 'squeel/predicate_methods'
+
+module Squeel
+  module Nodes
+    class Function
+
+      include PredicateMethods
+      include Operators
+
+      attr_reader :name, :args, :alias
+
+      def initialize(name, args)
+        @name, @args = name, args
+      end
+
+      def as(alias_name)
+        @alias = alias_name.to_s
+        self
+      end
+
+      def ==(value)
+        Predicate.new self, :eq, value
+      end
+
+      def asc
+        Order.new self, 1
+      end
+
+      def desc
+        Order.new self, -1
+      end
+
+      # Won't work on Ruby 1.8.x so need to do this conditionally
+      define_method('!=') do |value|
+        Predicate.new(self, :not_eq, value)
+      end if respond_to?('!=')
+
+      def ^(value)
+        Predicate.new self, :not_eq, value
+      end
+
+      def >>(value)
+        Predicate.new self, :in, value
+      end
+
+      def <<(value)
+        Predicate.new self, :not_in, value
+      end
+
+      def =~(value)
+        Predicate.new self, :matches, value
+      end
+
+      # Won't work on Ruby 1.8.x so need to do this conditionally
+      define_method('!~') do |value|
+        Predicate.new(self, :does_not_match, value)
+      end if respond_to?('!~')
+
+      def >(value)
+        Predicate.new self, :gt, value
+      end
+
+      def >=(value)
+        Predicate.new self, :gteq, value
+      end
+
+      def <(value)
+        Predicate.new self, :lt, value
+      end
+
+      def <=(value)
+        Predicate.new self, :lteq, value
+      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/join.rb

@@ -0,0 +1,51 @@
+module Squeel
+  module Nodes
+    class Join
+      attr_reader :name, :type, :klass
+
+      def initialize(name, type = Arel::InnerJoin, klass = nil)
+        @name, @type = name, type
+        @klass = convert_to_class(klass) if klass
+      end
+
+      def inner
+        @type = Arel::InnerJoin
+        self
+      end
+
+      def outer
+        @type = Arel::OuterJoin
+        self
+      end
+
+      def klass=(class_or_class_name)
+        @klass = convert_to_class(class_or_class_name)
+      end
+
+      def polymorphic?
+        @klass
+      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
+
+      private
+
+      def convert_to_class(value)
+        case value
+        when String, Symbol
+          Kernel.const_get(value)
+        when Class
+          value
+        else
+          raise ArgumentError, "#{value} cannot be converted to a Class"
+        end
+      end
+
+    end
+  end
+end

data/lib/squeel/nodes/key_path.rb

@@ -0,0 +1,127 @@
+require 'squeel/nodes/operators'
+require 'squeel/nodes/predicate_operators'
+
+module Squeel
+  module Nodes
+    class KeyPath
+      include PredicateOperators
+      include Operators
+
+      attr_reader :path, :endpoint
+
+      def initialize(path, endpoint, absolute = false)
+        @path, @endpoint = path, endpoint
+        @path = [@path] unless Array === @path
+        @endpoint = Stub.new(@endpoint) if Symbol === @endpoint
+        @absolute = absolute
+      end
+
+      def absolute?
+        @absolute
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+        self.path == other.path &&
+        self.endpoint.eql?(other.endpoint) &&
+        self.absolute? == other.absolute?
+      end
+
+      def |(other)
+        endpoint.respond_to?(:|) ? super : no_method_error(:|)
+      end
+
+      def &(other)
+        endpoint.respond_to?(:&) ? super : no_method_error(:&)
+      end
+
+      def -@
+        endpoint.respond_to?(:-@) ? super : no_method_error(:-@)
+      end
+
+      def +(other)
+        endpoint.respond_to?(:+) ? super : no_method_error(:+)
+      end
+
+      def -(other)
+        endpoint.respond_to?(:-) ? super : no_method_error(:-)
+      end
+
+      def *(other)
+        endpoint.respond_to?(:*) ? super : no_method_error(:*)
+      end
+
+      def /(other)
+        endpoint.respond_to?(:/) ? super : no_method_error(:/)
+      end
+
+      def op(operator, other)
+        endpoint.respond_to?(:op) ? super : no_method_error(:/)
+      end
+
+      def ~
+        @absolute = true
+        self
+      end
+
+      # To let these fall through to the endpoint via method_missing
+      instance_methods.grep(/^(==|=~|!~)$/) do |operator|
+        undef_method operator
+      end
+
+      def hash
+        [self.class, endpoint, *path].hash
+      end
+
+      def to_sym
+        nil
+      end
+
+      def %(val)
+        case endpoint
+        when Stub, Function
+          eq(val)
+          self
+        else
+          endpoint % val
+          self
+        end
+      end
+
+      def path_with_endpoint
+        path + [endpoint]
+      end
+
+      def to_s
+        path.map(&:to_s).join('.') << ".#{endpoint}"
+      end
+
+      def method_missing(method_id, *args)
+        super if method_id == :to_ary
+        if endpoint.respond_to? method_id
+          @endpoint = @endpoint.send(method_id, *args)
+          self
+        elsif Stub === endpoint
+          @path << endpoint.symbol
+          if args.empty?
+            @endpoint = Stub.new(method_id)
+          elsif (args.size == 1) && (Class === args[0])
+            @endpoint = Join.new(method_id, Arel::InnerJoin, args[0])
+          else
+            @endpoint = Nodes::Function.new method_id, args
+          end
+          self
+        else
+          super
+        end
+      end
+
+      private
+
+      def no_method_error(method_id)
+        raise NoMethodError, "undefined method `#{method_id}' for #{self}:#{self.class}"
+      end
+
+    end
+  end
+end