arel_operators 0.0.2

data/README

@@ -0,0 +1,65 @@
+AR Operators
+
+Don't let me wrong, it's not as I hate SQL. I just hate to create complex queries when ActiveRecord
+could do this for me, for free.
+
+Enter AR Operators.
+
+Imagine you're finding people. You want everybody named "John" OR "Smith", BUT don't want anyone who is underaged.
+So, in ActiveRecord, you could do something like:
+
+Person.all :conditions => [
+    '(name LIKE ? OR name LIKE ?) AND age >= 18', '%John%', '%Smith%'
+]
+
+But this is tedious. One of the great advantages of ActiveRecord 3 is use of scopes, so you could:
+
+Person.where(['(name LIKE ? OR name LIKE ?)', '%John%', '%Smith%']).where('age >= 18')
+
+Better. But why not:
+
+johns = Person.where(['name like ?', '%John%'])
+smiths = Person.where(['name like ?', '%Smith%'])
+underageds = Person.where('age < 18')
+(johns | smiths) - underageds
+
+ENTER AR Operators
+
+This library brings operators to ActiveRecord 3. So, all you have to do is:
+require 'ar_operators'
+class Person < ActiveRecord::Base
+  extend AROperators
+end
+
+And you're ready to go. Right now, the following operators are implemented:
+| (OR)
+& (AND)
+- (AND (NOT ...))
+-@ (negates the query. Use like: -Person.where(:name => 'foo'), to find all people where name is not 'foo')
+
+There is also the following constructions:
+p1 = Person.where :name => 'Foo'
+p2 = Person.where :age => 18
+p1.where(p2) #Generates something like: SELECT * FROM people WHERE ((name = 'Foo') AND (id in SELECT id FROM people WHERE age = 18))
+
+Design Decision:
+To not monkey patch ActiveRecord::Relation, I decided to include these operators only when you
+use "where" or "scoped" to find objects. If you decide that ALL ActiveRecord operations should
+have this kind of behaviour, you can:
+
+class ActiveRecord::Relation
+  include ActiveRecord::Operators
+end
+
+Known issues:
+As ActiveRecord::Relation doesn't only include "where" clauses, there can be a strange behaviour if trying
+to combinate more behaviours. For instance, this kind of query:
+p1 = Person.where(:name => 'Foo').limit(10)
+p2 = Person.where(:age => 18).order('name').limit(20)
+(p1 | p2).to_sql
+
+Will generate:
+SELECT "people".* FROM "people"  WHERE ((("people"."name" = 'Foo') OR ("people"."age" = 18))) LIMIT 10
+
+So, if you don't want to fall in undefined behaviours, please use:
+(p1 | p2).limit(20).order('name')

data/lib/active_record/operators.rb

@@ -0,0 +1,53 @@
+module ActiveRecord
+  module Operators
+    def |(other)
+      build_arel_conditions build_predicate(Arel::Predicates::Or, where_values, other.where_values)
+    end
+
+    def &(other)
+      build_arel_conditions build_predicate(Arel::Predicates::And, where_values, other.where_values)
+    end
+
+    def -(other)
+      self & (-other)
+    end
+
+    def -@
+      build_arel_conditions build_predicate(Arel::Predicates::Not, where_values)
+    end
+
+    def where(obj, *args)
+      if obj.respond_to?(:build_where)
+        relation = obj.select(:id)
+        self & build_arel_conditions(Arel::Predicates::In.new(relation.primary_key, relation.arel))
+      else
+        super
+      end
+    end
+
+    private
+    def build_arel_conditions(condition)
+      clone.tap do |c|
+        cond = build_where(condition)
+        c.where_values = Array.wrap(cond)
+      end
+    end
+
+    def build_predicate(predicate, *values)
+      values = values.collect do |v|
+        wrap_predicate_value(v)
+      end
+      predicate.new(*values)
+    end
+
+    def wrap_predicate_value(value)
+      value.collect do |v|
+        if v.is_a?(String)
+          Arel::SqlLiteral.new(v)
+        else
+          v
+        end
+      end
+    end
+  end
+end

data/lib/arel_operators.rb

@@ -0,0 +1,17 @@
+require "active_record/operators"
+module ArelOperators
+  def where(args, *opts)
+    include_operators_on super
+  end
+
+  def scoped(*args)
+    include_operators_on super(*args)
+  end
+
+  def include_operators_on(relation)
+    metaclass = class << relation; self; end
+    metaclass.send :include, ActiveRecord::Operators
+    return relation
+  end
+  private :include_operators_on
+end

data/spec/active_record/operators_spec.rb

@@ -0,0 +1,49 @@
+require File.expand_path(File.dirname(__FILE__) + '/../helper')
+require "ruby_debug"
+
+describe ActiveRecord::Operators do
+  it 'Should "or" two conditions' do
+    arel = Person.where(:id => 190) | Person.where(:id => 210)
+    result = arel.to_sql
+    result.should match(/or/i)
+    result.should match(/210/i)
+    result.should match(/190/i)
+  end
+
+  it 'Should "and" two conditions' do
+    arel = Person.where(:id => 190) & Person.where(:id => 210)
+    result = arel.to_sql
+    result.should match(/and/i)
+    result.should match(/210/i)
+    result.should match(/190/i)
+  end
+
+  it 'should negate the condition' do
+    arel = -Person.where(:id => 190)
+    result = arel.to_sql
+    result.should match(/not/i)
+    result.should match(/190/i)
+  end
+
+  it 'should subtract two conditions' do
+    arel = Person.where(:id => 190) - Person.where(:id => 210)
+    result = arel.to_sql
+    result.should match(/and.*not/i)
+    result.should match(/210/i)
+    result.should match(/190/i)
+  end
+
+  it 'should create subselects' do
+    foo = Person.create! :name => 'Foo'
+    bar = Person.create! :name => 'Bar'
+    baz = Person.create! :name => 'Baz'
+    select = Person.where :name => ['Foo', 'Baz']
+    subselect = Person.where :name => ['Baz', 'Bar']
+    result = select.where(subselect)
+    result.should include(baz)
+    result.should_not include(foo)
+    result.should_not include(bar)
+    sql = result.to_sql
+    sql.scan(/select/i).should have(2).matches
+  end
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+name: arel_operators
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- "Maur\xC3\xADcio Szabo"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-01 00:00:00 -03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id001
+description: 
+email: mauricio.szabo@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- lib/arel_operators.rb
+- lib/active_record/operators.rb
+- README
+- spec/active_record/operators_spec.rb
+has_rdoc: true
+homepage: http://github.com/mauricioszabo/arel_operators
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Operators (|, &, -) for ActiveRecord.
+test_files: 
+- spec/active_record/operators_spec.rb