outoftime-record_filter 0.6.0 → 0.8.0

data/lib/record_filter/filter.rb

@@ -1,41 +1,43 @@
 module RecordFilter
+  # This class is the value that is returned from the execution of a filter.
   class Filter
 
     NON_DELEGATE_METHODS = %w(nil? send object_id class extend find size count sum average maximum minimum paginate first last empty? any? respond_to?)
+
     [].methods.each do |m|
       unless m =~ /^__/ || NON_DELEGATE_METHODS.include?(m.to_s)
         delegate m, :to => :loaded_data
       end
     end
 
-    def initialize(clazz, named_filter, *args, &block)
+    def initialize(clazz, named_filter, *args, &block) # :nodoc:
       @current_scoped_methods = clazz.send(:current_scoped_methods)
       @clazz = clazz
 
       @query = Query.new(@clazz, named_filter, *args, &block)
     end
 
-    def first(*args)
+    def first(*args) # :nodoc:
       do_with_scope do
         @clazz.find(:first, *args)
       end
     end
 
-    def last(*args)
+    def last(*args) # :nodoc:
       do_with_scope do
         @clazz.find(:last, *args)
       end
     end
 
-    def size
+    def size # :nodoc:
       @loaded_data ? @loaded_data.length : count
     end
 
-    def empty?
+    def empty? # :nodoc:
       @loaded_data ? @loaded_data.empty? : count.zero?
     end
 
-    def any?
+    def any? # :nodoc:
       if block_given?
         loaded_data.any? { |*block_args| yield(*block_args) }
       else
@@ -55,7 +57,7 @@ module RecordFilter
 
     protected
 
-    def method_missing(method, *args, &block)
+    def method_missing(method, *args, &block) # :nodoc:
       if @clazz.named_filters.include?(method)
         do_with_scope do
           Filter.new(@clazz, method, *args)
@@ -67,7 +69,7 @@ module RecordFilter
       end
     end
 
-    def do_with_scope(count_query=false, &block)
+    def do_with_scope(count_query=false, &block) # :nodoc:
       @clazz.send(:with_scope, { :find => proxy_options(count_query), :create => proxy_options(count_query) }, :reverse_merge) do
         if @current_scoped_methods
           @clazz.send(:with_scope, @current_scoped_methods) do
@@ -79,7 +81,7 @@ module RecordFilter
       end
     end
 
-    def loaded_data
+    def loaded_data # :nodoc:
       @loaded_data ||= do_with_scope do
         @clazz.find(:all)
       end

data/lib/record_filter/group_by.rb

@@ -1,5 +1,5 @@
 module RecordFilter
-  class GroupBy
+  class GroupBy # :nodoc: all
     attr_reader :column, :table
 
     def initialize(column, table)

data/lib/record_filter/join.rb

@@ -1,5 +1,5 @@
 module RecordFilter
-  class Join
+  class Join # :nodoc: all
     attr_reader :left_table, :right_table
 
     def initialize(left_table, right_table, join_conditions, join_type=nil)

data/lib/record_filter/order.rb

@@ -1,5 +1,5 @@
 module RecordFilter
-  class Order
+  class Order # :nodoc: all
     attr_reader :column, :direction, :table
 
     def initialize(column, direction, table)

data/lib/record_filter/query.rb

@@ -1,5 +1,5 @@
 module RecordFilter
-  class Query
+  class Query # :nodoc: all
 
     attr_reader :dsl_conjunction
     attr_reader :conjunction
@@ -42,10 +42,10 @@ module RecordFilter
     protected
 
     def dsl_for_named_filter(clazz, named_filter)
-      return DSL::DSL.create(clazz) if named_filter.blank?
+      return DSL::DSLFactory.create(clazz) if named_filter.blank?
       while (clazz)
-        dsl = DSL::DSL.subclass(clazz)
-        return DSL::DSL.create(clazz) if dsl && dsl.instance_methods(false).include?(named_filter.to_s)
+        dsl = DSL::DSLFactory.subclass(clazz)
+        return DSL::DSLFactory.create(clazz) if dsl && dsl.instance_methods(false).include?(named_filter.to_s)
         clazz = clazz.superclass
       end
     end

data/lib/record_filter/restrictions.rb

@@ -1,5 +1,5 @@
 module RecordFilter
-  module Restrictions
+  module Restrictions # :nodoc: all
     class Base
       def initialize(column_name, value, options={})
         @column_name, @value, @negated = column_name, value, !!options.delete(:negated)

data/lib/record_filter/table.rb

@@ -1,5 +1,5 @@
 module RecordFilter
-  class Table
+  class Table # :nodoc: all
     attr_reader :table_alias, :orders, :group_bys, :model_class
 
     def initialize(model_class, table_alias = nil)
@@ -16,7 +16,7 @@ module RecordFilter
       @model_class.quoted_table_name
     end
 
-    def join_association(association_name, join_type=nil, source_type=nil)
+    def join_association(association_name, join_type=nil, options={})
       @joins_cache[association_name] ||=
         begin
           association = @model_class.reflect_on_association(association_name)
@@ -25,13 +25,19 @@ module RecordFilter
           end
           if (association.options[:through])
             through_association = @model_class.reflect_on_association(association.options[:through])
-            through_join = join_association(association.options[:through], join_type)
+
+            through_join = join_association(
+              association.options[:through], 
+              join_type, 
+              :type_restriction => association.options[:source_type], 
+              :source => association.options[:source])
+
             through_join.right_table.join_association(
-              association.options[:source] || association_name, join_type, association.options[:source_type])
+              association.options[:source] || association_name, join_type, :join_class => association.options[:source_type])
           else
             case association.macro
             when :belongs_to, :has_many, :has_one
-              simple_join(association, join_type, source_type)
+              simple_join(association, join_type, options)
             when :has_and_belongs_to_many
               compound_join(association, join_type)
             end
@@ -69,20 +75,25 @@ module RecordFilter
 
     private
 
-    def simple_join(association, join_type, source_type)
+    def simple_join(association, join_type, options)
       join_predicate =
         case association.macro
         when :belongs_to
-          [{ association.options[:foreign_key] || association.association_foreign_key.to_sym => :id }]
+          [{ association.options[:foreign_key] || association.association_foreign_key.to_sym => @model_class.primary_key }]
         when :has_many, :has_one
-          [{ association.options[:primary_key] || :id => association.primary_key_name.to_sym }]
+          [{ association.options[:primary_key] || @model_class.primary_key => association.primary_key_name.to_sym }]
         end
 
       if association.options[:as]
         join_predicate << DSL::Restriction.new(association.options[:as].to_s + '_type').equal_to(association.active_record.base_class.name)
       end
 
-      clazz = source_type.nil? ? association.klass : source_type.constantize
+      if options[:type_restriction] && options[:source]
+        foreign_type = association.klass.reflect_on_association(options[:source]).options[:foreign_type]
+        join_predicate << DSL::Restriction.new(foreign_type).equal_to(options[:type_restriction])
+      end
+
+      clazz = options[:join_class].nil? ? association.klass : options[:join_class].constantize
 
       join_table = Table.new(clazz, alias_for_association(association))
       @joins << join = Join.new(self, join_table, join_predicate, join_type)
@@ -90,11 +101,11 @@ module RecordFilter
     end
 
     def compound_join(association, join_type)
-      pivot_join_predicate = [{ :id => association.primary_key_name.to_sym }]
+      pivot_join_predicate = [{ @model_class.primary_key => association.primary_key_name.to_sym }]
       table_name = @model_class.connection.quote_table_name(association.options[:join_table])
       pivot_table = PivotTable.new(table_name, association, "__#{alias_for_association(association)}")
       pivot_join = Join.new(self, pivot_table, pivot_join_predicate, join_type)
-      join_predicate = [{ association.association_foreign_key.to_sym => :id }]
+      join_predicate = [{ association.association_foreign_key.to_sym => @model_class.primary_key }]
       join_table = Table.new(association.klass, alias_for_association(association))
       pivot_table.joins << join = Join.new(pivot_table, join_table, join_predicate, join_type)
       @joins << pivot_join
@@ -110,7 +121,7 @@ module RecordFilter
     alias_method :alias_for_class, :alias_for_association
   end
 
-  class PivotTable < Table
+  class PivotTable < Table # :nodoc: all
     attr_reader :table_name, :joins
 
     def initialize(table_name, association, table_alias = table_name)

data/spec/active_record_spec.rb

@@ -78,34 +78,15 @@ describe 'active record options' do
       end
 
       it 'should create the correct condition' do
-        pending 'using source type'
-        Blog.last_find[:conditions].should == [%q(blogs__posts__bad_comments.contents = ?), 'blammo']
+        Blog.last_find[:conditions].should == [%q(blogs__features__featurable.permalink = ?), 'slam dunk']
       end
 
       it 'should create the correct join' do
-        pending 'using source type'
-        Blog.last_find[:joins].should == %q(INNER JOIN "posts" AS blogs__posts ON "blogs".id = blogs__posts.blog_id INNER JOIN "comments" AS blogs__posts__bad_comments ON blogs__posts.id = blogs__posts__bad_comments.post_id)
-      end
-    end
-
-    describe 'using include' do
-      before do
-        Blog.filter do
-          having(:posts_with_comments).with(:permalink, 'home run')
-        end.inspect
-      end
-
-      it 'should create the correct condition' do
-        pending 'using include'
-        Blog.last_find[:conditions].should == 'ack'
-      end
-
-      it 'should create the correct join' do
-        pending 'using include'
-        Blog.last_find[:joins].should == 'ack'
+        Blog.last_find[:joins].should == %q(INNER JOIN "features" AS blogs__features ON "blogs".id = blogs__features.blog_id AND (blogs__features.featurable_type = 'Post') INNER JOIN "posts" AS blogs__features__featurable ON blogs__features.featurable_id = blogs__features__featurable.id)
       end
     end
 
+    # :include
     # :finder_sql
     # :counter_sql
     # :group
@@ -153,11 +134,11 @@ describe 'active record options' do
       end
     end
 
-    #include
-    #conditions
-    #select
-    #foreign_key
-    #polymorphic
-    #readonly
+    # :include
+    # :conditions
+    # :select
+    # :foreign_key
+    # :polymorphic
+    # :readonly
   end
 end

data/spec/exception_spec.rb

@@ -173,6 +173,16 @@ describe 'raising exceptions' do
     end
   end
 
+  describe 'calling order with an invalid direction' do
+    it 'should raise an InvalidFilterException' do
+      lambda {
+        Post.filter do
+          order(:id, :oops)
+        end
+      }.should raise_error(RecordFilter::InvalidFilterException)
+    end
+  end
+
   describe 'calling named filters within filters' do
     it 'should raise an excpetion if the named filter does not exist' do
       lambda {
@@ -182,4 +192,17 @@ describe 'raising exceptions' do
       }.should raise_error(RecordFilter::NamedFilterNotFoundException)
     end
   end
+
+  describe 'creating named filters with the same name as an existing one' do
+    it 'should raise an InvalidFilterNameException' do
+      Post.named_filter(:original) do
+        with(:permalink, 'abc')
+      end
+      lambda {
+        Post.named_filter(:original) do
+          with(:permalink, 'def')
+        end
+      }.should raise_error(RecordFilter::InvalidFilterNameException)
+    end
+  end
 end

data/spec/named_filter_spec.rb

@@ -108,7 +108,7 @@ describe 'named filters' do
   end
 
   describe 'using compound filters' do
-    before do
+    before(:all) do
       Comment.named_filter(:offensive_or_not) do |state|
         with(:offensive, state)
       end
@@ -208,10 +208,13 @@ describe 'named filters' do
   end
 
   describe 'chaining named filters with AR associations that involve joins' do
-    before do
+    before(:all) do
       Comment.named_filter(:with_user_named) do |name|
         having(:user).with(:first_name, name)
       end
+    end
+
+    before(:each) do
       @blog = Blog.create
       @blog.comments.with_user_named('Bob').inspect
     end

data/spec/restrictions_spec.rb

@@ -40,6 +40,13 @@ describe 'RecordFilter restrictions' do
      end
   end
 
+  it 'should create an IS NULL restriction when passing nil as the value to equal_to' do
+    Post.filter do
+      with(:blog_id).equal_to(nil)
+    end.inspect
+    Post.last_find.should == { :conditions => [%q("posts".blog_id IS NULL)] }
+  end
+
   it 'should filter for in' do
     Post.filter do
       with(:blog_id).in [1, 3, 5]
@@ -61,6 +68,13 @@ describe 'RecordFilter restrictions' do
     Post.last_find.should == { :conditions => [%q("posts".blog_id IN (?)), []] }
   end
 
+  it 'should do the right thing for IN filters with single values' do
+    Post.filter do
+      with(:blog_id).in(1)
+    end.inspect
+    Post.last_find.should == { :conditions => [%q("posts".blog_id IN (?)), 1] }
+  end
+
   it 'should do the right thing for IN filters with nil' do
     Post.filter do
       with(:blog_id).in(nil)
@@ -68,6 +82,20 @@ describe 'RecordFilter restrictions' do
     Post.last_find.should == { :conditions => [%q("posts".blog_id IN (?)), nil] }
   end
 
+  it 'should negate is_not_null conditions correctly' do
+    Post.filter do
+      with(:blog_id).is_not_null.not
+    end.inspect
+    Post.last_find.should == { :conditions => [%q("posts".blog_id IS NULL)] }
+  end 
+  
+  it 'should double-negate correctly' do
+    Post.filter do
+      with(:blog_id, 3).not.not
+    end.inspect
+    Post.last_find.should == { :conditions => [%q("posts".blog_id = ?), 3] }
+  end
+
   it 'should filter for between' do
     time1 = Time.parse('2008-01-03 23:23:00')
     time2 = Time.parse('2008-01-03 23:36:00')

data/test/performance_test.rb

@@ -0,0 +1,36 @@
+require 'rubygems'
+gem 'sqlite3-ruby'
+
+require 'ruby-debug'
+
+require File.join(File.dirname(__FILE__), '..', 'lib', 'record_filter')
+
+module TestModel
+end
+
+require File.join(File.dirname(__FILE__), '..', 'spec', 'models')
+
+ActiveRecord::Base.establish_connection(
+  :adapter => 'sqlite3',
+  :database => File.join(File.dirname(__FILE__), '..', 'spec', 'test.db')
+)
+
+@blog = Class.new(Blog)
+@blog.named_filter :somethings do
+  having(:ads) do
+    with(:content, nil)
+  end
+  join(Post, :left) do
+    on(:id => :blog_id)
+    join(Comment, :inner) do
+      on(:id => :post_id)
+      on(:offensive, true)
+    end
+  end
+  group_by(:id)
+end
+
+10000.times do
+  @blog.somethings
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: outoftime-record_filter
 version: !ruby/object:Gem::Version 
-  version: 0.6.0
+  version: 0.8.0
 platform: ruby
 authors: 
 - Mat Brown
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-01 00:00:00 -07:00
+date: 2009-05-04 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -34,6 +34,7 @@ files:
 - lib/record_filter/dsl/conjunction.rb
 - lib/record_filter/dsl/conjunction_dsl.rb
 - lib/record_filter/dsl/dsl.rb
+- lib/record_filter/dsl/dsl_factory.rb
 - lib/record_filter/dsl/group_by.rb
 - lib/record_filter/dsl/join.rb
 - lib/record_filter/dsl/join_condition.rb
@@ -45,7 +46,6 @@ files:
 - lib/record_filter/filter.rb
 - lib/record_filter/group_by.rb
 - lib/record_filter/join.rb
-- lib/record_filter/join_table.rb
 - lib/record_filter/order.rb
 - lib/record_filter/query.rb
 - lib/record_filter/restrictions.rb
@@ -62,6 +62,8 @@ files:
 - spec/select_spec.rb
 - spec/spec_helper.rb
 - spec/test.db
+- test/performance_test.rb
+- test/test.db
 has_rdoc: true
 homepage: http://github.com/outoftime/record_filter/tree/master
 post_install_message: 
@@ -100,3 +102,4 @@ test_files:
 - spec/restrictions_spec.rb
 - spec/select_spec.rb
 - spec/spec_helper.rb
+- test/performance_test.rb