maksar-meta_where 1.0.4

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler'
+require 'rspec/core/rake_task'
+require 'rake/testtask'
+
+Bundler::GemHelper.install_tasks
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'test'
+end
+
+task :default => :test

data/lib/core_ext/hash.rb

@@ -0,0 +1,5 @@
+require 'meta_where/condition_operators'
+
+class Hash
+  include MetaWhere::ConditionOperators
+end

data/lib/core_ext/symbol.rb

@@ -0,0 +1,39 @@
+class Symbol
+  MetaWhere::PREDICATES.each do |predication|
+    define_method(predication) do
+      MetaWhere::Column.new(self, predication)
+    end
+  end
+
+  MetaWhere::METHOD_ALIASES.each_pair do |aliased, predication|
+    define_method(aliased) do
+      MetaWhere::Column.new(self, predication)
+    end
+  end
+
+  def mw_func(*args)
+    MetaWhere::Function.new(self, *args)
+  end
+
+  alias_method :func, :mw_func unless method_defined?(:func)
+
+  def inner
+    MetaWhere::JoinType.new(self, Arel::Nodes::InnerJoin)
+  end
+
+  def outer
+    MetaWhere::JoinType.new(self, Arel::Nodes::OuterJoin)
+  end
+
+  def type(klass)
+    MetaWhere::JoinType.new(self, Arel::Nodes::InnerJoin, klass)
+  end
+
+  def asc
+    MetaWhere::Column.new(self, :asc)
+  end
+
+  def desc
+    MetaWhere::Column.new(self, :desc)
+  end
+end

data/lib/core_ext/symbol_operators.rb

@@ -0,0 +1,48 @@
+class Symbol
+  def [](*values)
+    MetaWhere::Function.new(self, *values)
+  end
+
+  def >>(value)
+    MetaWhere::Condition.new(self, value, :eq)
+  end
+
+  def ^(value)
+    MetaWhere::Condition.new(self, value, :not_eq)
+  end
+
+  def +(value)
+    MetaWhere::Condition.new(self, value, :in)
+  end
+
+  def -(value)
+    MetaWhere::Condition.new(self, value, :not_in)
+  end
+
+  def =~(value)
+    MetaWhere::Condition.new(self, value, :matches)
+  end
+
+  # Won't work on Ruby 1.8.x so need to do this conditionally
+  if respond_to?('!~')
+    define_method('!~') do |value|
+      MetaWhere::Condition.new(self, value, :does_not_match)
+    end
+  end
+
+  def >(value)
+    MetaWhere::Condition.new(self, value, :gt)
+  end
+
+  def >=(value)
+    MetaWhere::Condition.new(self, value, :gteq)
+  end
+
+  def <(value)
+    MetaWhere::Condition.new(self, value, :lt)
+  end
+
+  def <=(value)
+    MetaWhere::Condition.new(self, value, :lteq)
+  end
+end

data/lib/meta_where.rb

@@ -0,0 +1,51 @@
+module MetaWhere
+  METHOD_ALIASES = {
+    'ne' => :not_eq,
+    'like' => :matches,
+    'not_matches' => :does_not_match,
+    'nlike' => :does_not_match,
+    'lte' => :lteq,
+    'gte' => :gteq,
+    'nin' => :not_in
+  }
+
+  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
+  ]
+
+  def self.operator_overload!
+    require 'core_ext/symbol_operators'
+  end
+end
+
+require 'arel'
+require 'active_record'
+require 'active_support'
+
+# TODO: Trim this down, as the individual files should be
+# handling their requires.
+require 'meta_where/column'
+require 'meta_where/condition'
+require 'meta_where/not'
+require 'meta_where/compound'
+require 'meta_where/function'
+require 'meta_where/join_type'
+require 'core_ext/symbol'
+require 'core_ext/hash'
+require 'meta_where/visitors/attribute'
+require 'meta_where/visitors/predicate'
+require 'meta_where/association_reflection'
+require 'meta_where/relation'
+require 'meta_where/join_dependency'
+ActiveRecord::Relation.send(:include, MetaWhere::Relation)
+ActiveRecord::Reflection::AssociationReflection.send(:include, MetaWhere::AssociationReflection)
+ActiveRecord::Associations::ClassMethods::JoinDependency.send(:include, MetaWhere::JoinDependency)

data/lib/meta_where/association_reflection.rb

@@ -0,0 +1,51 @@
+module MetaWhere
+  class MetaWhereInAssociationError < StandardError; end
+
+  module AssociationReflection
+
+    def initialize(macro, name, options, active_record)
+      super
+
+      if options.has_key?(:conditions)
+        ensure_no_metawhere_in_conditions(options[:conditions])
+      end
+    end
+
+    private
+
+    def ensure_no_metawhere_in_conditions(obj)
+      case obj
+      when Hash
+        if obj.keys.grep(MetaWhere::Column).any?
+          raise MetaWhereInAssociationError, <<END
+The :#{name} association has a MetaWhere::Column in its :conditions. \
+If you actually needed to access conditions other than equality, then you most \
+likely meant to set up a scope or method, instead. Associations only work with \
+standard equality conditions, since they can be used to create records as well.
+END
+        end
+
+        obj.values.each do |v|
+          case v
+          when MetaWhere::Condition, Array, Hash
+            ensure_no_metawhere_in_conditions(v)
+          end
+        end
+      when Array
+        obj.each do |v|
+          case v
+          when MetaWhere::Condition, Array, Hash
+            ensure_no_metawhere_in_conditions(v)
+          end
+        end
+      when MetaWhere::Condition
+        raise MetaWhereInAssociationError, <<END
+The :#{name} association has a MetaWhere::Condition in its :conditions. \
+If you actually needed to access conditions other than equality, then you most \
+likely meant to set up a scope or method, instead. Associations only work with \
+standard equality conditions, since they can be used to create records as well.
+END
+      end
+    end
+  end
+end

data/lib/meta_where/column.rb

@@ -0,0 +1,31 @@
+module MetaWhere
+  class Column
+    attr_reader :column, :method
+
+    def initialize(column, method)
+      @column = column
+      @method = method
+    end
+
+    def %(value)
+      MetaWhere::Condition.new(column, value, method)
+    end
+
+    def ==(other_column)
+      other_column.is_a?(Column)    &&
+      other_column.column == column &&
+      other_column.method == method
+    end
+
+    alias_method :eql?, :==
+
+    def hash
+      [column, method].hash
+    end
+
+    # Play nicely with expand_hash_conditions_for_aggregates
+    def to_sym
+      "#{column}.#{method}".to_sym
+    end
+  end
+end

data/lib/meta_where/compound.rb

@@ -0,0 +1,20 @@
+require 'meta_where/condition_operators'
+
+module MetaWhere
+  class Compound
+    include ConditionOperators
+
+    attr_reader :condition1, :condition2
+
+    def initialize(condition1, condition2)
+      @condition1 = condition1
+      @condition2 = condition2
+    end
+  end
+
+  class Or < Compound
+  end
+
+  class And < Compound
+  end
+end

data/lib/meta_where/condition.rb

@@ -0,0 +1,32 @@
+require 'meta_where/utility'
+require 'meta_where/condition_operators'
+
+module MetaWhere
+  class Condition
+    include ConditionOperators
+    include Utility
+
+    attr_reader :column, :value, :method
+
+    def initialize(column, value, method)
+      @column = column
+      @value = value
+      @method = (MetaWhere::METHOD_ALIASES[method.to_s] || method).to_s
+    end
+
+    def ==(other_condition)
+      other_condition.is_a?(Condition) &&
+      other_condition.column == column &&
+      other_condition.value == value    &&
+      other_condition.method == method
+    end
+
+    alias_method :eql?, :==
+
+    # Play "nicely" with expand_hash_conditions_for_aggregates
+    def to_sym
+      self
+    end
+  end
+
+end

data/lib/meta_where/condition_operators.rb

@@ -0,0 +1,19 @@
+module MetaWhere
+  module ConditionOperators
+    def |(other)
+      Or.new(self, other)
+    end
+
+    def &(other)
+      And.new(self, other)
+    end
+
+    def -(other)
+      And.new(self, Not.new(other))
+    end
+
+    def -@
+      Not.new(self)
+    end
+  end
+end

data/lib/meta_where/function.rb

@@ -0,0 +1,108 @@
+module MetaWhere
+  class Function
+    attr_reader :name, :args
+    attr_accessor :table, :alias
+
+    def initialize(name, *args)
+      @name = name
+      @args = args
+    end
+
+    def as(val)
+      self.alias = val
+      self
+    end
+
+    def to_sqlliteral
+      Arel.sql(
+        ("#{name}(#{(['%s'] * args.size).join(',')})" % contextualize_args) +
+        (self.alias ? " AS #{self.alias}" : '')
+      )
+    end
+
+    alias_method :to_sql, :to_sqlliteral
+
+    MetaWhere::PREDICATES.each do |predication|
+      define_method(predication) do
+        MetaWhere::Column.new(self, predication)
+      end
+    end
+
+    MetaWhere::METHOD_ALIASES.each_pair do |aliased, predication|
+      define_method(aliased) do
+        MetaWhere::Column.new(self, predication)
+      end
+    end
+
+    def >>(value)
+      MetaWhere::Condition.new(self, value, :eq)
+    end
+
+    def ^(value)
+      MetaWhere::Condition.new(self, value, :not_eq)
+    end
+
+    def +(value)
+      MetaWhere::Condition.new(self, value, :in)
+    end
+
+    def -(value)
+      MetaWhere::Condition.new(self, value, :not_in)
+    end
+
+    def =~(value)
+      MetaWhere::Condition.new(self, value, :matches)
+    end
+
+    # Won't work on Ruby 1.8.x so need to do this conditionally
+    if respond_to?('!~')
+      define_method('!~') do |value|
+        MetaWhere::Condition.new(self, value, :does_not_match)
+      end
+    end
+
+    def >(value)
+      MetaWhere::Condition.new(self, value, :gt)
+    end
+
+    def >=(value)
+      MetaWhere::Condition.new(self, value, :gteq)
+    end
+
+    def <(value)
+      MetaWhere::Condition.new(self, value, :lt)
+    end
+
+    def <=(value)
+      MetaWhere::Condition.new(self, value, :lteq)
+    end
+
+    # Play "nicely" with expand_hash_conditions_for_aggregates
+    def to_sym
+      self
+    end
+
+    private
+
+    def contextualize_args
+      args.map do |arg|
+        if arg.is_a? Symbol
+          self.table && self.table[arg] ? Arel::Visitors.for(ActiveRecord::Base).accept(table[arg]) : arg
+        else
+          arg.table = self.table if arg.is_a? MetaWhere::Function
+          Arel::Visitors.for(ActiveRecord::Base).accept(arg)
+        end
+      end
+    end
+  end
+end
+
+module Arel
+  module Visitors
+    class ToSql
+      def visit_MetaWhere_Function o
+        o.to_sqlliteral
+      end
+    end
+  end
+end

data/lib/meta_where/join_dependency.rb

@@ -0,0 +1,105 @@
+module MetaWhere
+  module JoinDependency
+
+    def self.included(base)
+      base.class_eval do
+        alias_method_chain :build, :metawhere
+        alias_method_chain :find_join_association, :metawhere
+      end
+    end
+
+    class BaseMismatchError < StandardError; end
+    class ConfigurationError < StandardError; end
+    class AssociationNotFoundError < StandardError; end
+
+    def build_with_metawhere(associations, parent = nil, join_type = Arel::InnerJoin)
+      parent ||= join_parts.last
+      if MetaWhere::JoinType === associations
+        klass = associations.klass
+        join_type = associations.join_type
+        associations = associations.name
+      end
+
+      case associations
+      when Symbol, String
+        reflection = parent.reflections[associations.to_s.intern] or
+          raise ConfigurationError, "Association named '#{ associations }' was not found; perhaps you misspelled it?"
+        unless (association = find_join_association(reflection, parent)) && (!klass || association.active_record == klass)
+          @reflections << reflection
+          if reflection.options[:polymorphic]
+            raise ArgumentError, "You can't create a polymorphic belongs_to join without specifying the polymorphic class!" unless klass
+            association = PolymorphicJoinAssociation.new(reflection, self, klass, parent)
+          else
+            association = build_join_association(reflection, parent)
+          end
+          association.join_type = join_type
+          @join_parts << association
+          cache_joined_association(association)
+        end
+        association
+      else
+        build_without_metawhere(associations, parent, join_type)
+      end
+    end
+
+    def find_join_association_with_metawhere(name_or_reflection, parent)
+      case name_or_reflection
+      when MetaWhere::JoinType
+        join_associations.detect do |j|
+          (j.reflection.name == name_or_reflection.name) &&
+          (j.reflection.klass == name_or_reflection.klass) &&
+          (j.parent == parent)
+        end
+      else
+        case name_or_reflection
+        when Symbol, String
+          join_associations.detect {|j| (j.reflection.name == name_or_reflection.to_s.intern) && (j.parent == parent)}
+        else
+          join_associations.detect {|j| (j.reflection == name_or_reflection) && (j.parent == parent)}
+        end
+        #find_join_association_without_metawhere(name_or_reflection, parent)
+      end
+    end
+  end
+
+  class PolymorphicJoinAssociation < ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation
+
+    def initialize(reflection, join_dependency, polymorphic_class, parent = nil)
+      reflection.check_validity!
+      @active_record = polymorphic_class
+      @cached_record = {}
+      @column_names_with_alias = nil
+      @reflection      = reflection.clone
+      @reflection.instance_variable_set :"@klass", polymorphic_class
+      @join_dependency = join_dependency
+      @parent          = parent
+      @join_type       = Arel::InnerJoin
+      @aliased_prefix  = "t#{ join_dependency.join_parts.size }"
+
+      allocate_aliases
+      @table = Arel::Table.new(
+        table_name, :as => aliased_table_name, :engine => arel_engine
+      )
+    end
+
+
+    def ==(other)
+      other.class == self.class &&
+      other.reflection == reflection &&
+      other.active_record == active_record &&
+      other.parent == parent
+    end
+
+    def join_belongs_to_to(relation)
+      foreign_key = options[:foreign_key] || reflection.foreign_key
+      foreign_type = options[:foreign_type] || reflection.foreign_type
+      primary_key = options[:primary_key] || reflection.klass.primary_key
+      join_target_table(
+        relation,
+        target_table[primary_key].eq(parent_table[foreign_key]).
+        and(parent_table[foreign_type].eq(active_record.name))
+      )
+    end
+
+  end
+end