activerecord_finder 0.1.2 → 0.1.4

data/README.md

@@ -29,7 +29,8 @@ so you can use ActiveRecord::Base#restrict with a block to construct your querie
 
 ## ActiveRecord's Finders
 
-Integrating with ActiveRecord, it is possible to use `restrict` to find records on a ActiveRecord object. The syntax is quite simple:
+Integrating with ActiveRecord, it is possible to use `restrict` to find records on a ActiveRecord object. The syntax is quite simple (Please note that because of operator precedence in Ruby, we must add a parenthesis over the comparission before using `&` or `|`):
+
 
 ```ruby
 User.restrict { |f| f.age > 18 }
@@ -73,7 +74,20 @@ User.restrict do
 end
 ```
 
-Plase note that because of operator precedence in Ruby, we must add a parenthesis over the comparission before using `&` or `|`.
+Please note that we can't use instance variables if we use the block syntax without a variable. This is a Ruby's limitation, not ActiveRecord Finder's one.
+
+```ruby
+class Foo
+  def initialize
+    @name = "Bar"
+  end
+  
+  def find_all
+    User.restrict { name == @name } #Doesn't work - @name is nil
+    User.restrict { |u| u.name == @name } #Works!
+  end
+end
+```
 
 ## Constructing Queries
 
@@ -90,6 +104,27 @@ end
 
 ### Using "joins"
 
-To be simple, the `Finder` simply has the attributes from the table that it was created. So, to be able to find a record using attributes from one of the joined tables, it is possible to use `ActiveRecord::Base#merge` 
+To be simple, the `Finder` simply has the attributes from the table that it was created. So, to be able to find a record using attributes from one of the joined tables, it is possible to use `ActiveRecord::Base#merge`. If it's absolutely necessary, we could use `restrict_with` or `new_finder_with` to construct queries that uses fields from another tables (or table aliases). For example, consider the following examples:
 
-##
+```ruby
+#Finding user's roles for specific users
+admins = User.admins #(or User.where(admin: true) or User.restrict { admin == true }
+roles = Role.restrict { name != "top secret administrative stuff" }
+admin_roles = roles.joins(:users).merge(admins)
+
+#Finding without "merge" (but you cannot use "scopes" in this case,
+#nor use the block syntax without variables)
+admin_roles = Role.joins(:users).restrict_with(:users) do |role, user| 
+  (role.name != "top secret administrative stuff") & (user.admin == true) 
+end
+
+#Finding using a "table alias" or some other thing
+table = User.where(name: "Foo").as('alias')
+User.from([User.arel_table, table]).restrict_with(:alias) do |user, table|
+  user.id == table.id
+end
+#Will produce the query:
+#SELECT `users`.* 
+#FROM `users`, (SELECT `users`.* FROM `users`  WHERE `users`.`name` = 'Foo') alias  
+#WHERE `users`.`id` = `alias`.`id`
+```

data/lib/activerecord_finder.rb

@@ -1,5 +1,7 @@
 require_relative "activerecord_finder/finder"
 require_relative "activerecord_finder/comparator"
 require_relative "activerecord_finder/where"
+require_relative "activerecord_finder/set_operations"
 
 ActiveRecord::Base.extend ActiveRecordFinder::Where
+ActiveRecord::Relation.send :include, ActiveRecordFinder::SetOperations

data/lib/activerecord_finder/comparator.rb

@@ -1,5 +1,7 @@
 module ActiveRecordFinder
   class Comparator
+    attr_reader :field
+
     def initialize(finder, field)
       @finder = finder
       @field = field
@@ -7,6 +9,7 @@ module ActiveRecordFinder
 
     def self.convert_to_arel(operation, arel_method)
       define_method(operation) do |other|
+        other = other.field if other.respond_to?(:field)
         arel_clause =  @field.send(arel_method, other)
         Finder.new(@finder.table, arel_clause)
       end
@@ -22,6 +25,25 @@ module ActiveRecordFinder
       Finder.new(@finder.table, arel_clause)
     end
 
+    def not_in?(other)
+      other = other.arel if other.respond_to?(:arel)
+      arel_clause =  @field.not_in(other)
+      Finder.new(@finder.table, arel_clause)
+    end
+
+    def size
+      Comparator.new(@finder, @field.count)
+    end
+    alias :count :size
+
+    def lower
+      Comparator.new(@finder, @field.lower)
+    end
+
+    def upper
+      Comparator.new(@finder, Arel::Nodes::NamedFunction.new("UPPER", [@field]))
+    end
+
     convert_to_arel :==, :eq
     convert_to_arel '!=', :not_eq
     convert_to_arel :>, :gt

data/lib/activerecord_finder/finder.rb

@@ -5,12 +5,16 @@ module ActiveRecordFinder
     def initialize(arel_table, operation=nil)
       @table = arel_table
       @arel = operation
-      @table.columns.each { |a| define_attribute_method a }
+      @table.columns.each { |a| define_attribute_method a } rescue nil
+    end
+
+    def [](attribute)
+      Comparator.new(self, @table[attribute])
     end
 
     def define_attribute_method(arel_attribute)
       singleton_class.send :define_method, arel_attribute.name do
-        Comparator.new(self, arel_attribute)
+        self[arel_attribute.name]
       end
     end
     private :define_attribute_method
@@ -30,5 +34,10 @@ module ActiveRecordFinder
     end
 
     undef_method :==
+
+    def method_missing(method, *args, &b)
+      super if args.size != 0 || b
+      self[method]
+    end
   end
 end

data/lib/activerecord_finder/set_operations.rb

@@ -0,0 +1,42 @@
+module ActiveRecordFinder
+  module SetOperations
+    def unite_with(other)
+      if arel_table.name != other.arel_table.name
+        raise ArgumentError, "can't operate on different tables"
+      elsif primary_key.nil?
+        raise ArgumentError, "must have a primary key"
+      end
+
+      first_subselect = unscoped.where(primary_key => other)
+      second_subselect = unscoped.where(primary_key => self)
+      unscoped.restrict(first_subselect.to_finder | second_subselect.to_finder)
+    end
+
+    def intersect_with(other, field_self=nil, field_other=nil)
+      field_other ||= field_self
+
+      if field_self.nil?
+        where(primary_key => other)
+      else
+        if field_other.is_a?(Symbol)
+          field_other = other.scoped.arel_table[field_other]
+        end
+        where(field_self => other.select(field_other))
+      end
+    end
+
+    def subtract(other, field_self=nil, field_other=nil)
+      field_other ||= field_self
+
+      if field_self.nil?
+        subselect = unscoped.where(primary_key => other)
+      else
+        if field_other.is_a?(Symbol)
+          field_other = other.scoped.arel_table[field_other]
+        end
+        subselect = unscoped.where(field_self => other.select(field_other))
+      end
+      restrict(!subselect.to_finder)
+    end
+  end
+end

data/lib/activerecord_finder/where.rb

@@ -10,22 +10,37 @@ module ActiveRecordFinder
     end
     alias :condition :restrict
 
+    def restrict_with(*tables, &block)
+      where(create_finder(*tables, &block).arel)
+    end
+
     def new_finder(&block)
+      new_finder_with(&block)
+    end
+    alias :to_finder :new_finder
+
+    def new_finder_with(*tables, &block)
       scoped_where = scoped.arel.where_clauses.map { |w| Arel.sql(w) }
       if block
-        finder = create_finder(&block)
+        finder = create_finder(*tables, &block)
         scoped_where << finder.arel
       end
       arel = Arel::Nodes::And.new(scoped_where)
       ActiveRecordFinder::Finder.new(arel_table, arel)
     end
+    alias :to_finder_with :new_finder_with
 
-    def create_finder(&block)
+
+    def create_finder(*tables, &block)
       activerecord_finder = ActiveRecordFinder::Finder.new(arel_table)
-      if block.arity == 1
-        block.call(activerecord_finder)
-      else
+      if tables.size == 0 && block.arity == 0
         activerecord_finder.instance_eval(&block)
+      else
+        additional_finders = tables.map do |table_name|
+          arel_table = Arel::Table.new(table_name)
+          ActiveRecordFinder::Finder.new(arel_table)
+        end
+        block.call(activerecord_finder, *additional_finders)
       end
     end
     private :create_finder

data/spec/activerecord_finder/comparator_spec.rb

@@ -32,6 +32,10 @@ describe ActiveRecordFinder::Comparator do
     subject.in?(['foo']).arel.should be_equivalent_to table[:name].in(['foo'])
   end
 
+  it 'finds with NOT IN' do
+    subject.not_in?(['foo']).arel.should be_equivalent_to table[:name].not_in(['foo'])
+  end
+
   it 'finds with subselects' do
     result = subject.in?(Person.where(age: 10))
     result.arel.to_sql.should match(/select/i)
@@ -41,4 +45,14 @@ describe ActiveRecordFinder::Comparator do
     (subject =~ 'foo').arel.should be_equivalent_to table[:name].matches('foo')
     (subject !~ 'foo').arel.should be_equivalent_to table[:name].does_not_match('foo')
   end
+
+  it 'is able to find with COUNT' do
+    (subject.size == 10).arel.should be_equivalent_to table[:name].count.eq(10)
+  end
+
+  it 'finds with LOWER or UPPER' do
+    (subject.lower == "foo").arel.should be_equivalent_to table[:name].lower.eq('foo')
+    (subject.upper == "foo").arel.should be_equivalent_to(
+      Arel::Nodes::NamedFunction.new("UPPER", [table[:name]]).eq('foo'))
+  end
 end

data/spec/activerecord_finder/finder_spec.rb

@@ -9,8 +9,8 @@ describe ActiveRecordFinder::Finder do
   end
 
   it 'should not calculate equality' do
-    proc { subject == subject }.should raise_error(NoMethodError)
-    proc { subject != subject }.should raise_error(NoMethodError)
+    -> { subject == subject }.should raise_error(NoMethodError)
+    -> { subject != subject }.should raise_error(NoMethodError)
   end
 
   it 'should be able to "or" two conditions' do
@@ -22,11 +22,16 @@ describe ActiveRecordFinder::Finder do
   it 'should be able to "and" two conditions' do
     c1 = table[:id].eq(1)
     c2 = table[:name].eq(2)
-    ((subject.id == 1) & (subject.name == 2)).arel.should be_equivalent_to c1.and(c2)
+    ((subject[:id] == 1) & (subject[:name] == 2)).arel.should be_equivalent_to c1.and(c2)
   end
 
   it 'should be able to negate the find' do
     result = subject.name == 'foo'
     (!result).arel.should be_equivalent_to Arel::Nodes::Not.new(table[:name].eq('foo'))
   end
+
+  it 'finds by custom attributes defined in SELECT clause' do
+    result = subject.custom == "Foo"
+    result.arel.should be_equivalent_to table[:custom].eq("Foo")
+  end
 end

data/spec/activerecord_finder/set_operations_spec.rb

@@ -0,0 +1,54 @@
+require_relative "../helper"
+
+describe ActiveRecordFinder::SetOperations do
+  let!(:seventeen) { Person.create! :name => 'Foo', :age => 17 }
+  let!(:eighteen) { Person.create! :name => 'Foo', :age => 18 }
+
+  it 'UNIONs two relations' do
+    relation1 = Person.where(age: 17)
+    relation2 = Person.where(age: 18)
+    relation1.unite_with(relation2).should include(seventeen, eighteen)
+  end
+
+  it 'UNIONs two relations with JOIN' do
+    seventeen_with_join = Person.create!(age: 17)
+    seventeen_with_join.addresses.create!
+    relation1 = Person.where(age: 17).joins(:addresses)
+    relation2 = Person.where(age: 18)
+
+    result = relation1.unite_with(relation2)
+    result.should include(seventeen_with_join, eighteen)
+    result.should_not include(seventeen)
+  end
+
+  it 'INTERSECTs two relations' do
+    bar = Person.create!(name: "Bar", age: 17)
+    relation1 = Person.where(age: 17)
+    relation2 = Person.where(name: "Foo")
+    relation1.intersect_with(relation2).should == [seventeen]
+  end
+
+  it 'INTERSECTs two relations using another fields and another tables' do
+    seventeen_bar = Person.create!(name: "Bar", age: 17)
+    relation1 = Person.where(age: 17)
+    relation2 = Person.where(name: "Foo")
+    relation1.intersect_with(relation2, :age).should include(seventeen_bar, seventeen)
+    relation1.intersect_with(relation2, :age).should_not include(eighteen)
+  end
+
+  it 'SUBTRACTs a relation from this one' do
+    relation1 = Person.where(name: "Foo")
+    relation2 = Person.where(age: 18)
+    relation1.subtract(relation2).should == [seventeen]
+  end
+
+  it 'SUBTRACTs a relation from this one, using another fields' do
+    bar = Person.create! name: "Bar", age: 17
+    Address.create! address: "Foo"
+
+    relation1 = Person.where(age: 17)
+    relation2 = Address.where(address: "Foo")
+
+    relation1.subtract(relation2, :name, :address).should == [bar]
+  end
+end

data/spec/activerecord_finder/where_spec.rb

@@ -39,4 +39,24 @@ describe ActiveRecordFinder::Where do
     new_finder = person.new_finder
     Person.restrict(new_finder).should == [bar]
   end
+
+  it 'finds using fields from other tables' do
+    seventeen.addresses.create! address: "Seventeen Road"
+    eighteen.addresses.create! address: "Eighteen Road"
+
+    result = Person.joins(:addresses).restrict(
+      Person.new_finder_with(:addresses) { |_, a| a.address =~ 'Eighteen%' })
+    result.should == [eighteen]
+
+    result = Person.joins(:addresses).restrict_with(:addresses) { |_, a| a.address =~ 'Seventeen%' }
+    result.should == [seventeen]
+  end
+
+  it 'finds by multiple tables or aliases' do
+    finder = Person.new_finder_with(:custom) { |p, c| p.id == c.id }
+
+    people_table = Arel::Table.new(:people)
+    custom_table = Arel::Table.new(:custom)
+    finder.arel.should be_equivalent_to(people_table[:id].eq(custom_table[:id]))
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord_finder
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-03 00:00:00.000000000 Z
+date: 2013-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -34,6 +34,7 @@ extensions: []
 extra_rdoc_files:
 - README.md
 files:
+- lib/activerecord_finder/set_operations.rb
 - lib/activerecord_finder/where.rb
 - lib/activerecord_finder/finder.rb
 - lib/activerecord_finder/comparator.rb
@@ -41,6 +42,7 @@ files:
 - README.md
 - spec/activerecord_finder/finder_spec.rb
 - spec/activerecord_finder/comparator_spec.rb
+- spec/activerecord_finder/set_operations_spec.rb
 - spec/activerecord_finder/where_spec.rb
 homepage: http://github.com/mauricioszabo/arel_operators
 licenses: []
@@ -69,5 +71,6 @@ summary: Better finder syntax (|, &, >=, <=) for ActiveRecord.
 test_files:
 - spec/activerecord_finder/finder_spec.rb
 - spec/activerecord_finder/comparator_spec.rb
+- spec/activerecord_finder/set_operations_spec.rb
 - spec/activerecord_finder/where_spec.rb
 has_rdoc: true