maksar-meta_where 1.0.4

data/lib/meta_where/join_type.rb

@@ -0,0 +1,43 @@
+module MetaWhere
+  class JoinType
+    attr_reader :name, :join_type, :klass
+
+    def initialize(name, join_type = Arel::Nodes::InnerJoin, klass = nil)
+      @name = name
+      @join_type = join_type
+      @klass = klass
+    end
+
+    def ==(other)
+      self.class == other.class &&
+      name == other.name &&
+      join_type == other.join_type &&
+      klass == other.klass
+    end
+
+    alias_method :eql?, :==
+
+    def hash
+      [name, join_type, klass].hash
+    end
+
+    def outer
+      @join_type = Arel::Nodes::OuterJoin
+      self
+    end
+
+    def inner
+      @join_type = Arel::Nodes::InnerJoin
+      self
+    end
+
+    def type(klass)
+      @klass = klass
+      self
+    end
+
+    def to_sym
+      self
+    end
+  end
+end

data/lib/meta_where/not.rb

@@ -0,0 +1,13 @@
+require 'meta_where/condition_operators'
+
+module MetaWhere
+  class Not
+    include ConditionOperators
+
+    attr_reader :expr
+
+    def initialize(expr)
+      @expr = expr
+    end
+  end
+end

data/lib/meta_where/relation.rb

@@ -0,0 +1,290 @@
+module MetaWhere
+  module Relation
+
+    JoinAssociation = ::ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation
+    JoinDependency = ::ActiveRecord::Associations::ClassMethods::JoinDependency
+
+    attr_writer :join_dependency
+    private :join_dependency=
+
+    def self.included(base)
+      base.class_eval do
+        alias_method_chain :reset, :metawhere
+        alias_method_chain :scope_for_create, :metawhere
+      end
+
+      # We have to do this on the singleton to work with Ruby 1.8.7. Not sure why.
+      base.instance_eval do
+        alias_method :&, :merge
+      end
+    end
+
+    def join_dependency
+      @join_dependency ||= (build_join_dependency(table.from(table), @joins_values) && @join_dependency)
+    end
+
+    def merge(r, association_name = nil)
+      if (r && (association_name || base_class.name != r.klass.base_class.name)) # Merging relations with different base.
+        association_name ||= (default_association = reflect_on_all_associations.detect {|a| a.class_name == r.klass.name}) ?
+                             default_association.name : r.table_name.to_sym
+        r = r.clone
+        r.where_values.map! {|w| MetaWhere::Visitors::Predicate.visitables.include?(w.class) ? {association_name => w} : w}
+        r.joins_values.map! {|j| [Symbol, Hash, MetaWhere::JoinType].include?(j.class) ? {association_name => j} : j}
+        self.joins_values += [association_name] if reflect_on_association(association_name)
+      end
+
+      super(r)
+    end
+
+    def reset_with_metawhere
+      @mw_unique_joins = @mw_association_joins = @mw_non_association_joins =
+        @mw_stashed_association_joins = @mw_custom_joins = nil
+      reset_without_metawhere
+    end
+
+    def scope_for_create_with_metawhere
+      @scope_for_create ||= begin
+        @create_with_value || predicates_without_conflicting_equality.inject({}) do |hash, where|
+          if is_equality_predicate?(where)
+            hash[where.left.name] = where.right.respond_to?(:value) ? where.right.value : where.right
+          end
+
+          hash
+        end
+      end
+    end
+
+    def build_where(opts, other = [])
+      if opts.is_a?(String)
+        [@klass.send(:sanitize_sql, other.empty? ? opts : ([opts] + other))]
+      else
+        predicates = []
+        [opts, *other].each do |arg|
+          predicates += Array.wrap(
+            case arg
+            when Array
+              @klass.send(:sanitize_sql, arg)
+            when Hash
+              @klass.send(:expand_hash_conditions_for_aggregates, arg)
+            else
+              arg
+            end
+          )
+        end
+        predicates
+      end
+    end
+
+    def predicates_without_conflicting_equality
+      remove_conflicting_equality_predicates(flatten_predicates(@where_values, predicate_visitor))
+    end
+
+    # Very occasionally, we need to get a visitor for another relation, so it makes sense to factor
+    # these out into a public method despite only being two lines long.
+    def predicate_visitor
+      @predicate_visitor ||= begin
+        visitor = MetaWhere::Visitors::Predicate.new
+        visitor.join_dependency = join_dependency
+        visitor
+      end
+    end
+
+    def attribute_visitor
+      @attribute_visitor ||= begin
+        visitor = MetaWhere::Visitors::Attribute.new
+        visitor.join_dependency = join_dependency
+        visitor
+      end
+    end
+
+    # Simulate the logic that occurs in ActiveRecord::Relation.to_a
+    #
+    # @records = eager_loading? ? find_with_associations : @klass.find_by_sql(arel.to_sql)
+    #
+    # This will let us get a dump of the SQL that will be run against the DB for debug
+    # purposes without actually running the query.
+    def debug_sql
+      if eager_loading?
+        including = (@eager_load_values + @includes_values).uniq
+        join_dependency = JoinDependency.new(@klass, including, [])
+        construct_relation_for_association_find(join_dependency).to_sql
+      else
+        arel.to_sql
+      end
+    end
+
+    def construct_limited_ids_condition(relation)
+      visitor = relation.attribute_visitor
+
+      relation.order_values.map! {|o| visitor.can_accept?(o) ? visitor.accept(o).to_sql : o}
+
+      super
+    end
+
+    def build_arel
+      arel = table.from table
+
+      build_join_dependency(arel, @joins_values) unless @joins_values.empty?
+
+      visitor = predicate_visitor
+
+      predicate_wheres = flatten_predicates(@where_values.uniq, visitor)
+
+      collapse_wheres(arel, (predicate_wheres - ['']).uniq)
+
+      arel.having(*flatten_predicates(@having_values, visitor).reject {|h| h.blank?}) unless @having_values.empty?
+
+      arel.take(@limit_value) if @limit_value
+      arel.skip(@offset_value) if @offset_value
+
+      arel.group(*@group_values.uniq.reject{|g| g.blank?}) unless @group_values.empty?
+
+      build_order(arel, attribute_visitor, @order_values) unless @order_values.empty?
+
+      build_select(arel, @select_values.uniq)
+
+      arel.from(@from_value) if @from_value
+      arel.lock(@lock_value) if @lock_value
+
+      arel
+    end
+
+    def select(value = Proc.new)
+      if MetaWhere::Function === value
+        value.table = self.arel_table
+      end
+
+      super
+    end
+
+    private
+
+    def is_equality_predicate?(predicate)
+      predicate.class == Arel::Nodes::Equality
+    end
+
+    def build_join_dependency(manager, joins)
+      buckets = joins.group_by do |join|
+        case join
+        when String
+          'string_join'
+        when Hash, Symbol, Array, MetaWhere::JoinType
+          'association_join'
+        when JoinAssociation
+          'stashed_join'
+        when Arel::Nodes::Join
+          'join_node'
+        else
+          raise 'unknown class: %s' % join.class.name
+        end
+      end
+
+      association_joins         = buckets['association_join'] || []
+      stashed_association_joins = buckets['stashed_join'] || []
+      join_nodes                = buckets['join_node'] || []
+      string_joins              = (buckets['string_join'] || []).map { |x|
+        x.strip
+      }.uniq
+
+      join_list = custom_join_ast(manager, string_joins)
+
+      # All of this duplication just to add
+      self.join_dependency = JoinDependency.new(
+        @klass,
+        association_joins,
+        join_list
+      )
+
+      join_nodes.each do |join|
+        join_dependency.table_aliases[join.left.name.downcase] = 1
+      end
+
+      join_dependency.graft(*stashed_association_joins)
+
+      @implicit_readonly = true unless association_joins.empty? && stashed_association_joins.empty?
+
+      # FIXME: refactor this to build an AST
+      join_dependency.join_associations.each do |association|
+        association.join_to(manager)
+      end
+
+      manager.join_sources.concat join_nodes.uniq
+      manager.join_sources.concat join_list
+
+      manager
+    end
+
+    def build_order(arel, visitor, orders)
+      order_attributes = orders.map {|o|
+        visitor.can_accept?(o) ? visitor.accept(o, visitor.join_dependency.join_base) : o
+      }.flatten.uniq.reject {|o| o.blank?}
+      order_attributes.present? ? arel.order(*order_attributes) : arel
+    end
+
+    def remove_conflicting_equality_predicates(predicates)
+      predicates.reverse.inject([]) { |ary, w|
+        unless is_equality_predicate?(w) && ary.any? {|p| is_equality_predicate?(p) && p.operand1.name == w.operand1.name}
+          ary << w
+        end
+        ary
+      }.reverse
+    end
+
+    def collapse_wheres(arel, wheres)
+      binaries = wheres.grep(Arel::Nodes::Binary)
+
+      groups = binaries.group_by do |binary|
+        [binary.class, binary.left]
+      end
+
+      groups.each do |_, bins|
+        test = bins.inject(bins.shift) do |memo, expr|
+          memo.or(expr)
+        end
+        arel = arel.where(test)
+      end
+
+      (wheres - binaries).each do |where|
+        where = Arel.sql(where) if String === where
+        arel = arel.where(Arel::Nodes::Grouping.new(where))
+      end
+      arel
+    end
+
+    def flatten_predicates(predicates, visitor)
+      predicates.map {|p|
+        visitor.can_accept?(p) ? visitor.accept(p) : p
+      }.flatten.uniq
+    end
+    #
+    # def unique_joins
+    #   @mw_unique_joins ||= @joins_values.map {|j| j.respond_to?(:strip) ? j.strip : j}.uniq
+    # end
+    #
+    # def association_joins
+    #   @mw_association_joins ||= unique_joins.select{|j|
+    #     [Hash, Array, Symbol, MetaWhere::JoinType].include?(j.class) && !array_of_strings?(j)
+    #   }
+    # end
+    #
+    # def string_joins
+    #   @mw_string_joins ||= unique_joins.select { |j| j.is_a? String }
+    # end
+    #
+    # def join_nodes
+    #   @mw_join_nodes ||= unique_joins.select { |j| j.is_a? Arel::Nodes::Join }
+    # end
+    #
+    # def stashed_association_joins
+    #   @mw_stashed_association_joins ||= unique_joins.grep(ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation)
+    # end
+    #
+    # def non_association_joins
+    #   @mw_non_association_joins ||= (unique_joins - association_joins - stashed_association_joins).reject {|j| j.blank?}
+    # end
+    #
+    # def custom_joins
+    #   @mw_custom_joins ||= custom_join_ast(@klass.arel_table, non_association_joins)
+    # end
+  end
+end

data/lib/meta_where/utility.rb

@@ -0,0 +1,51 @@
+module MetaWhere
+  module Utility
+    private
+
+    def array_of_activerecords(val)
+      val.is_a?(Array) && !val.empty? && val.all? {|v| v.is_a?(ActiveRecord::Base)}
+    end
+
+    def association_from_parent_and_column(parent, column)
+      parent.is_a?(Symbol) ? nil : @join_dependency.send(:find_join_association, column, parent)
+    end
+
+    def attribute_from_column_and_table(column, table)
+      case column
+      when String, Symbol
+        table[column]
+      when MetaWhere::Function
+        column.table = table
+        column.to_sqlliteral
+      else
+        nil
+      end
+    end
+
+    def args_for_predicate(value)
+      case value
+      when Array, ActiveRecord::Associations::AssociationCollection, ActiveRecord::Relation
+        value.to_a.map { |x|
+          x.respond_to?(:quoted_id) ? x.quoted_id : x
+        }
+      when ActiveRecord::Base
+        value.quoted_id
+      else
+        value
+      end
+    end
+
+    def method_from_value(value)
+      case value
+      when Array, Range, ActiveRecord::Associations::AssociationCollection, ActiveRecord::Relation, Arel::Relation
+        :in
+      else
+        :eq
+      end
+    end
+
+    def valid_comparison_method?(method)
+      MetaWhere::PREDICATES.map(&:to_s).include?(method.to_s)
+    end
+  end
+end

data/lib/meta_where/version.rb

@@ -0,0 +1,3 @@
+module MetaWhere
+  VERSION = "1.0.4"
+end

data/lib/meta_where/visitors/attribute.rb

@@ -0,0 +1,58 @@
+require 'meta_where/visitors/visitor'
+
+module MetaWhere
+  module Visitors
+    class Attribute < Visitor
+
+      def self.visitables
+        [Hash, Symbol, MetaWhere::Column]
+      end
+
+      def visit_Hash(o, parent)
+        parent = parent.name if parent.is_a? MetaWhere::JoinType
+        table = tables[parent]
+        built_attributes = o.map do |column, value|
+          if value.is_a?(Hash)
+            association = association_from_parent_and_column(parent, column)
+            accept(value, association || column)
+          elsif value.is_a?(Array) && value.all? {|v| can_accept?(v)}
+            association = association_from_parent_and_column(parent, column)
+            value.map {|val| self.accept(val, association || column)}
+          else
+            association = association_from_parent_and_column(parent, column)
+            can_accept?(value) ? self.accept(value, association || column) : value
+          end
+        end
+
+        built_attributes.flatten
+      end
+
+      def visit_Symbol(o, parent)
+        table = tables[parent]
+
+        unless attribute = table[o]
+          raise ::ActiveRecord::StatementInvalid, "No attribute named `#{o}` exists for table `#{table.name}`"
+        end
+
+        attribute
+      end
+
+      def visit_MetaWhere_Column(o, parent)
+        column_name = o.column.to_s
+        if column_name.include?('.')
+          table_name, column_name = column_name.split('.', 2)
+          table = Arel::Table.new(table_name, :engine => parent.arel_engine)
+        else
+          table = tables[parent]
+        end
+
+        unless attribute = table[column_name]
+          raise ::ActiveRecord::StatementInvalid, "No attribute named `#{column_name}` exists for table `#{table.name}`"
+        end
+
+        attribute.send(o.method)
+      end
+
+    end
+  end
+end