arel_operators 0.0.2 → 0.1.0

data/README

@@ -1,12 +1,10 @@
-AR Operators
+= 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:
+For example, 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%'
@@ -20,38 +18,92 @@ Better. But why not:
 
 johns = Person.where(['name like ?', '%John%'])
 smiths = Person.where(['name like ?', '%Smith%'])
-underageds = Person.where('age < 18')
-(johns | smiths) - underageds
+underaged = Person.where('age < 18')
+(johns | smiths) - underaged
 
-ENTER AR Operators
+== 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
+  extend ArelOperators
 end
 
 And you're ready to go. Right now, the following operators are implemented:
-| (OR)
-& (AND)
+.or, |, + (OR)
+.and (AND)
 - (AND (NOT ...))
 -@ (negates the query. Use like: -Person.where(:name => 'foo'), to find all people where name is not 'foo')
 
+I cannot use & (amperstand operator) for AND, because this behaviour is already defined for ActiveRecord::Relation.
+
 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:
+== 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
+  include ArelOperators::Operators
 end
 
-Known issues:
+== Finders ==
+Ok, so we don't have to write tedious SQL operations by hand. What about trying a little further,
+and not write ANY SQL at all? After all, we have blocks in Ruby, so what about:
+
+Person.where { |p| p.name >= 10 }
+
+ArelOperators, right now, permits this kind of behaviour only for where clauses (no "having" support
+right now). The following operations are supported:
+== (Test for equality)
+!= (Test for inequality, Ruby 1.9 only)
+>, >= (Test for Greater or Greather or Equal)
+<, <= (Test for Lower, or Lower or equal)
+in? (SQL IN clause, "WHERE name IN(1, 2, 3)" )
+like?, matches?, =~ (SQL LIKE clause, "WHERE name LIKE 'something'")
+
+So, as an example:
+
+Person.where { |p| p.name.like?("F%") }
+Person.where { |p| p.name =~ "F%" } #Same as above
+Person.where { |p| p.age.in?([10, 20, 30]) } #SQL IN operator
+Person.where { |p| p.age.in?(0..17) } #SQL BETWEEN operator
+
+Furthermore, you can OR or AND your clauses with | and &. Ruby 1.9 "!" and  is also supported, and for
+Ruby 1.8, you can use the negative ("-@") operator. For example:
+
+Person.where { |p| (p.name != "Fred") | (p.age > 17) } #Ruby 1.9 version
+Person.where { |p| !(p.name == "Fred") | (p.age > 17) } #Another Ruby 1.9 version
+Person.where { |p| -(p.name == "Fred") | (p.age > 17) } #All ruby versions
+
+The block argument is optional, too, so:
+
+Person.where { name == "Foo" }
+Person.where { name.like "F%" }
+Person.where { (age <= 10) & (name =~ "F%) }
+
+Please notice, that as & and | operators have a high precedence, don't forget the parenthesis,
+otherwise undesired behaviours can occur.
+
+This kind of syntax can be combined with regular "where" expressions too. So, the following code:
+
+Person.where(:name => "Foo") { age > 10 }
+
+Is the same as:
+
+Person.where(:name => "Foo").where { age > 10 }
+
+(this will "AND" the two conditions)
+
+== NOTICE ==
+Regexp operations are NOT supported. Right now, I'm only delegating these operators
+to Arel, and Arel still has no support for regexp.
+
+== 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)
@@ -63,3 +115,10 @@ SELECT "people".* FROM "people"  WHERE ((("people"."name" = 'Foo') OR ("people".
 
 So, if you don't want to fall in undefined behaviours, please use:
 (p1 | p2).limit(20).order('name')
+
+Furthermore, beware of "OR" operator. Don't try this at home:
+p1 = Person.where(:name => "Foo")
+a1 = Address.where(:road => "Something")
+(p1 | a1) #This will generate something like: 
+SELECT     "people".* FROM       "people"  WHERE     ((("people"."name" = 'Foo') OR ("addresses"."road" = 'Something')))
+So, as with & operator, you must join relations so your query would be correct.

data/lib/arel_operators.rb

@@ -1,16 +1,32 @@
-require "active_record/operators"
+require "arel_operators/operators"
+require 'arel_operators/finder'
 module ArelOperators
-  def where(args, *opts)
+  def where(*args, &b)
+    if b
+      arel = arel_from_block &b
+      result = where(arel)
+      return result if args.empty?
+      return result.where(*args)
+    end
     include_operators_on super
   end
 
+  def arel_from_block(&b)
+    if b.arity == -1 || b.arity == 0
+      ArelOperators::Finder.new(arel_table).instance_eval(&b).arel
+    else
+      b.call(ArelOperators::Finder.new(arel_table)).arel
+    end
+  end
+  private :arel_from_block
+
   def scoped(*args)
     include_operators_on super(*args)
   end
 
   def include_operators_on(relation)
     metaclass = class << relation; self; end
-    metaclass.send :include, ActiveRecord::Operators
+    metaclass.send :include, ArelOperators::Operators
     return relation
   end
   private :include_operators_on

data/lib/arel_operators/finder.rb

@@ -0,0 +1,45 @@
+require "arel_operators/finder/comparators"
+module ArelOperators
+  class Finder
+    attr_reader :table, :arel
+
+    def initialize(arel_table, operation=nil)
+      @table = arel_table
+      @arel = operation
+      @table.attributes.each { |a| define_attribute_method a.name }
+    end
+
+    def define_attribute_method(attribute)
+      singleton_class.send :define_method, attribute do
+        ArelOperators::Finder::Comparators.new(self, @table[attribute])
+      end
+    end
+    private :define_attribute_method
+
+    def |(other)
+      other = other.arel if other.respond_to?(:arel)
+      Finder.new(table, arel.or(other))
+    end
+
+    def &(other)
+      other = other.arel if other.respond_to?(:arel)
+      Finder.new(table, arel.and(other))
+    end
+
+    if RUBY_VERSION >= '1.9.0'
+      eval '
+        def !@
+          -self
+        end
+      '
+    end
+
+    def -@
+      Finder.new(table, Arel::Predicates::Not.new(arel))
+    end
+
+    undef_method :==
+  end
+end
+
+__END__

data/lib/arel_operators/finder/comparators.rb

@@ -0,0 +1,32 @@
+module ArelOperators
+  class Finder
+    class Comparators
+      def initialize(finder, field)
+        @finder = finder
+        @field = finder.table[field]
+      end
+
+      def self.convert_to_arel(operation, arel_method)
+        define_method(operation) do |other|
+          arel_clause =  @field.send(arel_method, other)
+          ArelOperators::Finder.new(@finder.table, arel_clause)
+        end
+      end
+
+      def nil?
+        self == nil
+      end
+
+      convert_to_arel :==, :eq
+      convert_to_arel '!=', :not_eq
+      convert_to_arel :>, :gt
+      convert_to_arel :>=, :gteq
+      convert_to_arel :<, :lt
+      convert_to_arel :<=, :lteq
+      convert_to_arel :in?, :in
+      convert_to_arel :like?, :matches
+      alias :matches? :like?
+      alias :=~ :like? #TODO: Is this really a good idea?
+    end
+  end
+end

data/lib/arel_operators/operators.rb

@@ -0,0 +1,65 @@
+module ArelOperators
+  module Operators
+    def or(other)
+      build_arel_predicate(Arel::Predicates::Or, self, other)
+    end
+    alias :| :or
+    alias :+ :or
+
+    def and(other)
+      build_arel_predicate(Arel::Predicates::And, self, other)
+    end
+
+    def -(other)
+      self.and(-other)
+    end
+
+    def -@
+      build_arel_predicate(Arel::Predicates::Not, self)
+    end
+
+    def where(obj, *args)
+      return super unless obj.respond_to?(:build_where)
+      relation = obj.select(:id)
+      other = clone.tap do |c|
+        cond = build_where(Arel::Predicates::In.new(relation.primary_key, relation.arel))
+        c.where_values = Array.wrap(cond)
+      end
+      self.and(other)
+    end
+
+    private
+    def build_arel_predicate(predicate, *args)
+      clone.tap do |c|
+        condition = build_predicate(predicate, *args)
+        cond = build_where(condition)
+        c.where_values = Array.wrap(cond)
+        possible_joins = args.select { |x| x.object_id != object_id && x.respond_to?(:joins_values) }
+        c.joins_values += possible_joins.collect { |x| x.joins_values }
+        #possible_eager = args.select { |x| x.object_id != object_id }
+        #c.eager_load_values += possible_eager.collect { |x| x.eager_load_values }.flatten
+      end
+    end
+
+    def build_predicate(predicate, *relations)
+      values = relations.collect do |relation|
+        value = relation.is_a?(ActiveRecord::Relation) ? relation.where_values : relation
+        wrap_predicate_value(value)
+      end
+      predicate.new(*values)
+    end
+
+    def wrap_predicate_value(value)
+      value.collect do |v|
+        next v unless v.is_a?(String)
+        Arel::SqlLiteral.new(v)
+      end
+    end
+  end
+
+  class RelationMismatch < StandardError
+    def initialize(expected_class)
+      super("Invalid class for operation. Expected #{expected_class}")
+    end
+  end
+end

data/spec/arel_operators/finder/comparators_spec.rb

@@ -0,0 +1,48 @@
+require "spec/helper"
+
+describe ArelOperators::Finder::Comparators do
+  before do
+    @table = Person.arel_table
+    @finder = ArelOperators::Finder.new Person.arel_table
+    @comparator = ArelOperators::Finder::Comparators.new @finder, :name
+  end
+
+  it 'should be able to find by equality' do
+    (@comparator == 'foo').should be_a_kind_of(ArelOperators::Finder)
+    (@comparator == 'foo').arel.should ==
+      @table[:name].eq('foo')
+  end
+
+  it 'should be able to find by inequality (Ruby1.9 only)' do
+    next if RUBY_VERSION < '1.9.0'
+    (@comparator != 'foo').arel.should ==
+      @table[:name].not_eq('foo')
+  end
+
+  it 'should be able to verify if an attribute is nil' do
+    (@comparator.nil?).arel.should ==
+      @table[:name].eq(nil)
+  end
+
+  it 'should be able to find by greater than' do
+    (@comparator > 'foo').arel.should == @table[:name].gt('foo')
+    (@comparator >= 'foo').arel.should == @table[:name].gteq('foo')
+  end
+
+  it 'should be able to find by lower than' do
+    (@comparator < 'foo').arel.should == @table[:name].lt('foo')
+    (@comparator <= 'foo').arel.should == @table[:name].lteq('foo')
+  end
+
+  it 'should be able to find IN' do
+    @comparator.in?(['foo']).arel.should == @table[:name].in(['foo'])
+  end
+
+  it 'should be able to find with LIKE' do
+    @comparator.like?('foo').arel.should == @table[:name].matches('foo')
+    @comparator.matches?('foo').arel.should == @table[:name].matches('foo')
+    (@comparator =~ 'foo').arel.should == @table[:name].matches('foo')
+  end
+
+  #it 'should be able to find with Regex'
+end

data/spec/arel_operators/finder_spec.rb

@@ -0,0 +1,87 @@
+require "spec/helper"
+
+describe ArelOperators::Finder do
+  before do
+    @table = Person.arel_table
+    @finder = ArelOperators::Finder.new Person.arel_table
+  end
+
+  it 'should be able to convert to a arel' do
+    arel = mock("Arel")
+    @finder = ArelOperators::Finder.new Person.arel_table, arel
+    @finder.arel.should == arel
+  end
+
+  it 'should return a empty arel if not being able to convert' do
+    @finder.arel.should be_nil
+  end
+
+  it 'should not calculate equality' do
+    proc { @finder == @finder }.should raise_error(NoMethodError)
+    proc { @finder != @finder }.should raise_error(NoMethodError)
+  end
+
+  it 'should be able to expose the class attributes' do
+    @finder.name.should be_a_kind_of(ArelOperators::Finder::Comparators)
+    @finder.id.should be_a_kind_of(ArelOperators::Finder::Comparators)
+  end
+
+  it 'should be able to "or" two conditions' do
+    c1 = @table[:id].eq(1)
+    c2 = @table[:name].eq(2)
+    ((@finder.id == 1) | (@finder.name == 2)).arel.should == 
+      c1.or(c2)
+  end
+
+  it 'should be able to "and" two conditions' do
+    c1 = @table[:id].eq(1)
+    c2 = @table[:name].eq(2)
+    ((@finder.id == 1) & (@finder.name == 2)).arel.should == 
+      c1.and(c2)
+  end
+
+  it 'should be able to negate the find (in Ruby1.9)' do
+    next if RUBY_VERSION < '1.9.0'
+    @finder = ArelOperators::Finder.new Person.arel_table, @table[:name].eq('foo')
+    (!@finder).arel.should ==
+      Arel::Predicates::Not.new(@table[:name].eq('foo'))
+  end
+
+  it 'should be able to negate the find with -@' do
+    @finder = ArelOperators::Finder.new Person.arel_table, @table[:name].eq('foo')
+    (-@finder).arel.should ==
+      Arel::Predicates::Not.new(@table[:name].eq('foo'))
+  end
+
+  #it 'should be able to find in a subselect'
+  
+  context 'when finding using WHERE and a block' do
+    before do
+      @p1 = Person.create! :name => 'Foo', :age => 17
+      @p2 = Person.create! :name => 'Foo', :age => 18
+    end
+
+    after do
+      Person.delete_all
+    end
+
+    it 'should be able to find using a block with one parameter' do
+      result = Person.where { |p| (p.name == 'Foo') & (p.age > 17) }
+      result.should == [@p2]
+    end
+
+    it 'should be able to find using a block with no parameters' do
+      result = Person.where { (name == 'Foo') & (age > 17) }
+      result.should == [@p2]
+    end
+
+    it 'should be able to find using a condition too' do
+      result = Person.where(:age => 17) { name == 'Foo' }
+      result.should == [@p1]
+    end
+
+    it 'should be able to find on a HAVING condition' do
+      pending
+    end
+  end
+end

data/spec/arel_operators/joins_spec.rb

@@ -0,0 +1,38 @@
+require File.expand_path(File.dirname(__FILE__) + '/../helper')
+
+describe ArelOperators::Operators do
+  before do
+    @p1 = Person.create! :name => 'Foo'
+    @p2 = Person.create! :name => 'Bar'
+    @p3 = Person.create! :name => 'Baz'
+    Address.create! :address => "Avenue", :person_id => @p2.id
+    Address.create! :address => "Road", :person_id => @p3.id
+  end
+
+  after do
+    Person.delete_all; Address.delete_all
+  end
+
+  it 'should obey joins' do
+    Address.create! :address => "Village", :person_id => @p1.id
+    q1 = Person.where :name => 'Foo'
+    q2 = Person.joins(:addresses).where('addresses.address = ?', 'Road')
+    result = q2 | q1
+    result.to_sql.should match(/inner join/i)
+    result.should include(@p1)
+    result.should include(@p3)
+    result.should_not include(@p2)
+  end
+
+  it 'should obey left joins' do
+    pending 'Left Join in Rails?'
+    q1 = Person.where :name => 'Foo'
+    q2 = Person.eager_load(:addresses).where('addresses.address = ?', 'Road')
+    puts q2.to_sql
+    result = q1 | q2
+    result.to_sql.should match(/join/i)
+    result.should include(@p1)
+    result.should include(@p3)
+    result.should_not include(@p2)
+  end
+end

data/spec/{active_record → arel_operators}/operators_spec.rb

@@ -1,7 +1,6 @@
 require File.expand_path(File.dirname(__FILE__) + '/../helper')
-require "ruby_debug"
 
-describe ActiveRecord::Operators do
+describe ArelOperators::Operators do
   it 'Should "or" two conditions' do
     arel = Person.where(:id => 190) | Person.where(:id => 210)
     result = arel.to_sql
@@ -11,7 +10,7 @@ describe ActiveRecord::Operators do
   end
 
   it 'Should "and" two conditions' do
-    arel = Person.where(:id => 190) & Person.where(:id => 210)
+    arel = Person.where(:id => 190).and Person.where(:id => 210)
     result = arel.to_sql
     result.should match(/and/i)
     result.should match(/210/i)
@@ -28,6 +27,7 @@ describe ActiveRecord::Operators do
   it 'should subtract two conditions' do
     arel = Person.where(:id => 190) - Person.where(:id => 210)
     result = arel.to_sql
+    result.should have(1).select_clause
     result.should match(/and.*not/i)
     result.should match(/210/i)
     result.should match(/190/i)
@@ -43,7 +43,6 @@ describe ActiveRecord::Operators do
     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
+    result.to_sql.should have(2).select_clauses
   end
 end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
+  - 1
   - 0
-  - 2
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors: 
 - "Maur\xC3\xADcio Szabo"
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-01 00:00:00 -03:00
+date: 2010-09-19 00:00:00 -03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -42,9 +42,14 @@ extra_rdoc_files:
 - README
 files: 
 - lib/arel_operators.rb
-- lib/active_record/operators.rb
+- lib/arel_operators/finder.rb
+- lib/arel_operators/finder/comparators.rb
+- lib/arel_operators/operators.rb
 - README
-- spec/active_record/operators_spec.rb
+- spec/arel_operators/joins_spec.rb
+- spec/arel_operators/operators_spec.rb
+- spec/arel_operators/finder/comparators_spec.rb
+- spec/arel_operators/finder_spec.rb
 has_rdoc: true
 homepage: http://github.com/mauricioszabo/arel_operators
 licenses: []
@@ -78,4 +83,7 @@ signing_key:
 specification_version: 3
 summary: Operators (|, &, -) for ActiveRecord.
 test_files: 
-- spec/active_record/operators_spec.rb
+- spec/arel_operators/joins_spec.rb
+- spec/arel_operators/operators_spec.rb
+- spec/arel_operators/finder/comparators_spec.rb
+- spec/arel_operators/finder_spec.rb

data/lib/active_record/operators.rb

@@ -1,53 +0,0 @@
-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