meta_where 0.9.0

data/lib/meta_where/compound.rb

@@ -0,0 +1,30 @@
+module MetaWhere
+  class Compound
+    attr_reader :condition1, :condition2
+    
+    def initialize(condition1, condition2)
+      @condition1 = condition1
+      @condition2 = condition2
+    end
+    
+    def |(other)
+      Or.new(self, other)
+    end
+    
+    def &(other)
+      And.new(self, other)
+    end
+  end
+  
+  class Or < Compound
+    def to_predicate(builder, parent = nil)
+      condition1.to_predicate(builder, parent).or(condition2.to_predicate(builder, parent))
+    end
+  end
+  
+  class And < Compound
+    def to_predicate(builder, parent = nil)
+      condition1.to_predicate(builder, parent).and(condition2.to_predicate(builder, parent))
+    end
+  end
+end

data/lib/meta_where/condition.rb

@@ -0,0 +1,51 @@
+require 'meta_where/utility'
+
+module MetaWhere
+  class Condition
+    include MetaWhere::Utility
+    
+    attr_reader :column, :value, :method
+    
+    def initialize(column, value, method)
+      @column = column.to_s
+      @value = value
+      @method = (MetaWhere::METHOD_ALIASES[method.to_s] || method).to_s
+    end
+    
+    def to_predicate(builder, parent = nil)
+      table = builder.build_table(parent)
+      
+      unless attribute = table[column]
+        raise ::ActiveRecord::StatementInvalid, "No attribute named `#{column}` exists for table `#{table.name}`"
+      end
+
+      unless valid_comparison_method?(method)
+        raise ::ActiveRecord::StatementInvalid, "No comparison method named `#{method}` exists for column `#{column}`"
+      end
+      attribute.send(method, *args_for_predicate(method.to_s, value))
+    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?, :==
+    
+    def |(other)
+      Or.new(self, other)
+    end
+    
+    def &(other)
+      And.new(self, other)
+    end
+    
+    # Play "nicely" with expand_hash_conditions_for_aggregates
+    def to_sym
+      self
+    end
+  end
+  
+end

data/lib/meta_where/join_dependency.rb

@@ -0,0 +1,48 @@
+module MetaWhere
+  module JoinDependency
+
+    def self.included(base)
+      base.class_eval do
+        alias_method_chain :build, :metawhere
+      end
+    end
+
+    class BaseMismatchError < StandardError; end
+    class ConfigurationError < StandardError; end
+    class AssociationNotFoundError < StandardError; end
+
+    def build_with_metawhere(associations, parent = nil, join_class = Arel::InnerJoin)
+      parent ||= @joins.last
+      case associations
+      when Symbol, String
+        reflection = parent.reflections[associations.to_s.intern] or
+        raise AssociationNotFoundError, "Association named '#{ associations }' was not found; perhaps you misspelled it?"
+        unless association = find_join_association(reflection, parent)
+          @reflections << reflection
+          association = (@joins << build_join_association(reflection, parent).with_join_class(join_class)).last
+        end
+        association
+      when Array
+        associations.each do |association|
+          build(association, parent, join_class)
+        end
+      when Hash
+        associations.keys.sort{|a,b|a.to_s<=>b.to_s}.each do |name|
+          association = build(name, parent, join_class)
+          build(associations[name], association, join_class)
+        end
+      else
+        raise ConfigurationError, associations.inspect
+      end
+    end
+
+    def find_join_association(name_or_reflection, parent)
+      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
+    end
+  end
+end

data/lib/meta_where/relation.rb

@@ -0,0 +1,270 @@
+module MetaWhere
+  module Relation
+
+    def self.included(base)
+      base.class_eval do
+        alias_method_chain :reset, :metawhere
+        alias_method_chain :scope_for_create, :metawhere
+      end
+    end
+
+    def merge(r, association_name = nil)
+      if (r && (association_name || klass.name != r.klass.name)) # Merging relations with different base.
+        association_name ||= (default_association = reflect_on_all_associations.detect {|a| a.klass.name == r.klass.name}) ?
+                             default_association.name : r.table_name.to_sym
+        r = r.clone
+        r.where_values.map! {|w| w.respond_to?(:to_predicate) ? {association_name => w} : w}
+        r.joins_values.map! {|j| [Symbol, Hash].include?(j.class) ? {association_name => j} : j}
+        self.joins_values += [association_name]
+      end
+      super(r)
+    end
+
+    alias_method :&, :merge
+
+    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 || predicate_wheres.inject({}) do |hash, where|
+          if is_equality_predicate?(where)
+            hash[where.operand1.name] = where.operand2.respond_to?(:value) ? where.operand2.value : where.operand2
+          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 build_custom_joins(joins = [], arel = nil)
+      arel ||= table
+      joins.each do |join|
+        next if join.blank?
+
+        @implicit_readonly = true
+
+        case join
+        when ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation
+          arel = arel.join(join.relation, Arel::OuterJoin).on(*join.on)
+        when Hash, Array, Symbol
+          if array_of_strings?(join)
+            join_string = join.join(' ')
+            arel = arel.join(join_string)
+          end
+        else
+          arel = arel.join(join)
+        end
+      end
+
+      arel
+    end
+
+    def custom_join_sql(*joins)
+      arel = table
+      joins.each do |join|
+        next if join.blank?
+
+        @implicit_readonly = true
+
+        case join
+        when Hash, Array, Symbol
+          if array_of_strings?(join)
+            join_string = join.join(' ')
+            arel = arel.join(join_string)
+          end
+        else
+          arel = arel.join(join)
+        end
+      end
+      arel.joins(arel)
+    end unless defined?(:custom_join_sql)
+
+    def predicate_wheres
+      remove_conflicting_equality_predicates(flatten_predicates(@where_values, metawhere_builder))
+    end
+
+    # Very occasionally, we need to get a builder for another relation, so it makes sense to factor
+    # this out into a public method despite only being two lines long.
+    def metawhere_builder
+      join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(@klass, association_joins, custom_joins)
+      MetaWhere::Builder.new(join_dependency)
+    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 = ActiveRecord::Associations::ClassMethods::JoinDependency.new(@klass, including, nil)
+        construct_relation_for_association_find(join_dependency).to_sql
+      else
+        arel.to_sql
+      end
+    end
+
+    def construct_limited_ids_condition(relation)
+      builder = relation.metawhere_builder
+
+      relation.order_values.map! {|o| o.respond_to?(:to_attribute) ? o.to_attribute(builder).to_sql : o}
+
+      super
+    end
+
+    def build_arel
+      arel = table
+
+      builder = metawhere_builder
+
+      arel = build_intelligent_joins(arel, builder) if @joins_values.present?
+
+      predicate_wheres = remove_conflicting_equality_predicates(flatten_predicates(@where_values, builder))
+
+      predicate_wheres.each do |where|
+        next if where.blank?
+
+        case where
+        when Arel::SqlLiteral
+          arel = arel.where(where)
+        else
+          sql = where.is_a?(String) ? where : where.to_sql
+          arel = arel.where(Arel::SqlLiteral.new("(#{sql})"))
+        end
+      end
+
+      arel = arel.having(*@having_values.uniq.select{|h| h.present?}) if @having_values.present?
+
+      arel = arel.take(@limit_value) if @limit_value.present?
+      arel = arel.skip(@offset_value) if @offset_value.present?
+
+      arel = arel.group(*@group_values.uniq.select{|g| g.present?}) if @group_values.present?
+
+      arel = build_order(arel, builder, @order_values) if @order_values.present?
+
+      arel = build_select(arel, @select_values.uniq)
+
+      arel = arel.from(@from_value) if @from_value.present?
+
+      case @lock_value
+      when TrueClass
+        arel = arel.lock
+      when String
+        arel = arel.lock(@lock_value)
+      end if @lock_value.present?
+
+      arel
+    end
+
+    private
+
+    def is_equality_predicate?(predicate)
+      predicate.respond_to?(:operator) && predicate.operator == :==
+    end
+
+    def build_intelligent_joins(arel, builder)
+      joined_associations = []
+
+      builder.join_dependency.graft(*stashed_association_joins)
+
+      @implicit_readonly = true unless association_joins.empty? && stashed_association_joins.empty?
+
+      to_join = []
+
+      builder.join_dependency.join_associations.each do |association|
+        if (association_relation = association.relation).is_a?(Array)
+          to_join << [association_relation.first, association.join_class, association.association_join.first]
+          to_join << [association_relation.last, association.join_class, association.association_join.last]
+        else
+          to_join << [association_relation, association.join_class, association.association_join]
+        end
+      end
+
+      to_join.each do |tj|
+        unless joined_associations.detect {|ja| ja[0] == tj[0] && ja[1] == tj[1] && ja[2] == tj[2] }
+          joined_associations << tj
+          arel = arel.join(tj[0], tj[1]).on(*tj[2])
+        end
+      end
+
+      arel = arel.join(custom_joins)
+    end
+
+    def build_order(arel, builder, orders)
+      order_attributes = orders.map {|o|
+        o.respond_to?(:to_attribute) ? o.to_attribute(builder, builder.join_dependency.join_base) : o
+      }.flatten.uniq.select {|o| o.present?}
+      order_attributes.map! {|a| Arel::SqlLiteral.new(a.is_a?(String) ? a : a.to_sql)}
+      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 flatten_predicates(predicates, builder)
+      predicates.map {|p|
+        predicate = p.respond_to?(:to_predicate) ? p.to_predicate(builder) : p
+        if predicate.is_a?(Arel::Predicates::All)
+          flatten_predicates(predicate.predicates, builder)
+        else
+          predicate
+        end
+      }.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].include?(j.class) && !array_of_strings?(j)
+      }
+    end
+
+    def stashed_association_joins
+      @mw_stashed_association_joins ||= unique_joins.select {|j| j.is_a?(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_sql(*non_association_joins)
+    end
+  end
+end

data/lib/meta_where/utility.rb

@@ -0,0 +1,27 @@
+module MetaWhere
+  module Utility
+    private
+
+    def args_for_predicate(method, value)
+      value = [Array, ActiveRecord::Associations::AssociationCollection, ActiveRecord::Relation].include?(value.class) ? value.to_a : value
+      if method =~ /_(any|all)$/ && value.is_a?(Array)
+        value
+      else
+        [value]
+      end
+    end
+
+    def method_from_value(value)
+      case value
+      when Array, Range, ActiveRecord::Associations::AssociationCollection, ActiveRecord::Relation
+        :in
+      else
+        :eq
+      end
+    end
+
+    def valid_comparison_method?(method)
+      Arel::Attribute::PREDICATES.map(&:to_s).include?(method.to_s)
+    end
+  end
+end

data/lib/meta_where.rb

@@ -0,0 +1,27 @@
+module MetaWhere
+  METHOD_ALIASES = {
+    'ne' => :not_eq,
+    'like' => :matches,
+    'nlike' => :not_matches,
+    'lte' => :lteq,
+    'gte' => :gteq,
+    'nin' => :not_in
+  }
+
+  def self.operator_overload!
+    require 'core_ext/symbol_operators'
+  end
+end
+require 'arel'
+require 'active_record'
+require 'active_support'
+require 'meta_where/column'
+require 'meta_where/condition'
+require 'meta_where/compound'
+require 'core_ext/symbol'
+require 'core_ext/hash'
+require 'meta_where/builder'
+require 'meta_where/relation'
+require 'meta_where/join_dependency'
+ActiveRecord::Relation.send(:include, MetaWhere::Relation)
+ActiveRecord::Associations::ClassMethods::JoinDependency.send(:include, MetaWhere::JoinDependency)

data/meta_where.gemspec

@@ -0,0 +1,105 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{meta_where}
+  s.version = "0.9.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ernie Miller"]
+  s.date = %q{2010-08-24}
+  s.description = %q{
+      MetaWhere offers the ability to call any Arel predicate methods
+      (with a few convenient aliases) on your Model's attributes instead
+      of the ones normally offered by ActiveRecord's hash parameters. It also
+      adds convenient syntax for order clauses, smarter mapping of nested hash
+      conditions, and a debug_sql method to see the real SQL your code is
+      generating without running it against the database. If you like the new
+      AR 3.0 query interface, you'll love it with MetaWhere.
+    }
+  s.email = %q{ernie@metautonomo.us}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     ".gitmodules",
+     "CHANGELOG",
+     "Gemfile",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "lib/core_ext/hash.rb",
+     "lib/core_ext/symbol.rb",
+     "lib/core_ext/symbol_operators.rb",
+     "lib/meta_where.rb",
+     "lib/meta_where/builder.rb",
+     "lib/meta_where/column.rb",
+     "lib/meta_where/compound.rb",
+     "lib/meta_where/condition.rb",
+     "lib/meta_where/join_dependency.rb",
+     "lib/meta_where/relation.rb",
+     "lib/meta_where/utility.rb",
+     "meta_where.gemspec",
+     "test/fixtures/companies.yml",
+     "test/fixtures/company.rb",
+     "test/fixtures/data_type.rb",
+     "test/fixtures/data_types.yml",
+     "test/fixtures/developer.rb",
+     "test/fixtures/developers.yml",
+     "test/fixtures/developers_projects.yml",
+     "test/fixtures/note.rb",
+     "test/fixtures/notes.yml",
+     "test/fixtures/people.yml",
+     "test/fixtures/person.rb",
+     "test/fixtures/project.rb",
+     "test/fixtures/projects.yml",
+     "test/fixtures/schema.rb",
+     "test/helper.rb",
+     "test/test_relations.rb"
+  ]
+  s.homepage = %q{http://metautonomo.us/projects/metawhere/}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Add a dash of Arel awesomeness to your condition hashes.}
+  s.test_files = [
+    "test/fixtures/company.rb",
+     "test/fixtures/data_type.rb",
+     "test/fixtures/developer.rb",
+     "test/fixtures/note.rb",
+     "test/fixtures/person.rb",
+     "test/fixtures/project.rb",
+     "test/fixtures/schema.rb",
+     "test/helper.rb",
+     "test/test_relations.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_runtime_dependency(%q<activerecord>, ["~> 3.0.0.rc2"])
+      s.add_runtime_dependency(%q<activesupport>, ["~> 3.0.0.rc2"])
+      s.add_runtime_dependency(%q<arel>, ["~> 1.0.0.rc1"])
+    else
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<activerecord>, ["~> 3.0.0.rc2"])
+      s.add_dependency(%q<activesupport>, ["~> 3.0.0.rc2"])
+      s.add_dependency(%q<arel>, ["~> 1.0.0.rc1"])
+    end
+  else
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<activerecord>, ["~> 3.0.0.rc2"])
+    s.add_dependency(%q<activesupport>, ["~> 3.0.0.rc2"])
+    s.add_dependency(%q<arel>, ["~> 1.0.0.rc1"])
+  end
+end
+

data/test/fixtures/companies.yml

@@ -0,0 +1,17 @@
+initech:
+  name      : Initech
+  id        : 1
+  created_at: 1999-02-19 08:00
+  updated_at: 1999-02-19 08:00
+
+aos:
+  name: Advanced Optical Solutions
+  id  : 2
+  created_at: 2004-02-01 08:00
+  updated_at: 2004-02-01 08:00
+
+mission_data:
+  name: Mission Data
+  id  : 3
+  created_at: 1996-09-21 08:00
+  updated_at: 1996-09-21 08:00

data/test/fixtures/company.rb

@@ -0,0 +1,7 @@
+class Company < ActiveRecord::Base
+  has_many :developers
+  has_many :developer_notes, :through => :developers, :source => :notes
+  has_many :slackers, :class_name => "Developer", :conditions => {:slacker => true}
+  has_many :notes, :as => :notable
+  has_many :data_types
+end

data/test/fixtures/data_type.rb

@@ -0,0 +1,3 @@
+class DataType < ActiveRecord::Base
+  belongs_to :company
+end

data/test/fixtures/data_types.yml

@@ -0,0 +1,15 @@
+<% 1.upto(9) do |n| %>
+dt_<%= n %>:
+  company_id: <%= n % 3 + 1 %>
+  str       : This string has <%= n %> exclamation points<%= '!' * n %>
+  txt       : <%= 'This is some text that may or may not repeat based on the value of n.' * n %>
+  int       : <%= n ** 3 %>
+  flt       : <%= n.to_f / 2.0 %>
+  dec       : <%= n.to_f ** (n + 0.1) %>
+  dtm       : <%= (Time.utc(2009, 12, 24) + 86400 * n).to_s(:db) %>
+  tms       : <%= (Time.utc(2009, 12, 24) + 86400 * n).to_s(:db) %>
+  tim       : <%= Time.utc(2000, 01, 01, n+8, n).to_s(:db) %>
+  dat       : <%= (Date.new(2009, 12, 24) + n).strftime("%Y-%m-%d") %>
+  bin       : <%= "BLOB#{n}" * n %>
+  bln       : <%= n % 2 > 0 ? true : false %>
+<% end %>

data/test/fixtures/developer.rb

@@ -0,0 +1,5 @@
+class Developer < ActiveRecord::Base
+  belongs_to :company
+  has_and_belongs_to_many :projects
+  has_many :notes, :as => :notable
+end

data/test/fixtures/developers.yml

@@ -0,0 +1,55 @@
+peter:
+  id        : 1
+  company_id: 1
+  name      : Peter Gibbons
+  salary    : 100000
+  slacker   : true
+
+michael:
+  id        : 2
+  company_id: 1
+  name      : Michael Bolton
+  salary    : 70000
+  slacker   : false
+
+samir:
+  id        : 3
+  company_id: 1
+  name      : Samir Nagheenanajar
+  salary    : 65000
+  slacker   : false
+
+herb:
+  id        : 4
+  company_id: 2
+  name      : Herb Myers
+  salary    : 50000
+  slacker   : false
+
+dude:
+  id        : 5
+  company_id: 2
+  name      : Some Dude
+  salary    : 84000
+  slacker   : true
+
+ernie:
+  id        : 6
+  company_id: 3
+  name      : Ernie Miller
+  salary    : 45000
+  slacker   : true
+
+someone:
+  id        : 7
+  company_id: 3
+  name      : Someone Else
+  salary    : 70000
+  slacker   : true
+
+another:
+  id        : 8
+  company_id: 3
+  name      : Another Guy
+  salary    : 80000
+  slacker   : false

data/test/fixtures/developers_projects.yml

@@ -0,0 +1,25 @@
+<% 1.upto(3) do |d| %>
+y2k_<%= d %>:
+  developer_id: <%= d %>
+  project_id  : 1
+<% end %>
+
+virus:
+  developer_id: 2
+  project_id  : 2
+  
+<% 1.upto(8) do |d| %>
+awesome_<%= d %>:
+  developer_id: <%= d %>
+  project_id  : 3
+<% end %>
+
+metasearch:
+  developer_id: 6
+  project_id  : 4
+
+<% 4.upto(8) do |d| %>
+another_<%= d %>:
+  developer_id: <%= d %>
+  project_id  : 5
+<% end %>