aub-record_filter 0.1.4 → 0.2.0

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:patch: 4
+:patch: 0
 :major: 0
-:minor: 1
+:minor: 2

data/lib/record_filter/active_record.rb

@@ -3,7 +3,7 @@ module RecordFilter
     module ClassMethods
 
       def filter(&block)
-        Filter.new(self, nil, nil, &block)
+        Filter.new(self, nil, &block)
       end
 
       def named_filter(name, &block)
@@ -15,7 +15,7 @@ module RecordFilter
 
         (class << self; self; end).instance_eval do
           define_method(name.to_s) do |*args|
-            Filter.new(self, name, nil, *args)
+            Filter.new(self, name, *args)
           end
         end
       end

data/lib/record_filter/conjunctions.rb

@@ -18,7 +18,7 @@ module RecordFilter
           when DSL::Conjunction 
             result.add_conjunction(create_from(step, table)) 
           when DSL::Join
-            join = result.add_join_on_association(step.association)
+            join = result.add_join_on_association(step.association, step.join_type)
             result.add_conjunction(create_from(step.conjunction, join.right_table))
           when DSL::ClassJoin
             join = result.add_join_on_class(
@@ -55,14 +55,14 @@ module RecordFilter
         conjunction
       end
 
-      def add_join_on_association(association_name)
+      def add_join_on_association(association_name, join_type)
         table = @table
         while association_name.is_a?(Hash)
-          result = table.join_association(association_name.keys[0])
+          result = table.join_association(association_name.keys[0], join_type)
           table = result.right_table
           association_name = association_name.values[0]
         end
-        table.join_association(association_name)
+        table.join_association(association_name, join_type)
       end
       
       def add_join_on_class(join_class, join_type, table_alias, conditions)
@@ -94,16 +94,20 @@ module RecordFilter
           else
             @restrictions.map do |restriction|
               conditions = restriction.to_conditions
-              conditions[0] = "(#{conditions[0]})"
-              conditions
-            end.inject do |conditions, new_conditions|
+              if conditions
+                conditions[0] = "(#{conditions[0]})"
+                conditions
+              else
+                nil
+              end
+            end.compact.inject do |conditions, new_conditions|
               conditions.first << " #{conjunctor} #{new_conditions.shift}"
               conditions.concat(new_conditions)
               conditions
             end
           end
         end
-        result[0] = "!(#{result[0]})" if (negated && !result.nil? && !result[0].nil?)
+        result[0] = "NOT (#{result[0]})" if (negated && !result.nil? && !result[0].nil?)
         result
       end
 

data/lib/record_filter/dsl/conjunction.rb

@@ -19,10 +19,10 @@ module RecordFilter
         @steps << dsl.conjunction
       end
 
-      def add_join(association, &block)
+      def add_join(association, join_type, &block)
         dsl = ConjunctionDSL.new(@model_class, Conjunction.new(@model_class, :all_of))
         dsl.instance_eval(&block) if block
-        @steps << Join.new(association, dsl.conjunction)
+        @steps << Join.new(association, join_type, dsl.conjunction)
         dsl
       end
 

data/lib/record_filter/dsl/conjunction_dsl.rb

@@ -37,8 +37,13 @@ module RecordFilter
       end
 
       # join
-      def having(association, &block)
-        @conjunction.add_join(association, &block)
+      def having(join_type_or_association, association=nil, &block)
+        if association.nil?
+          association, join_type = join_type_or_association, nil
+        else
+          join_type = join_type_or_association
+        end
+        @conjunction.add_join(association, join_type, &block)
       end
 
       def join(clazz, join_type, table_alias=nil, &block)

data/lib/record_filter/dsl/join.rb

@@ -2,10 +2,10 @@ module RecordFilter
   module DSL
     class Join
 
-      attr_reader :association, :conjunction
+      attr_reader :association, :join_type, :conjunction
 
-      def initialize(association, conjunction)
-        @association, @conjunction = association, conjunction
+      def initialize(association, join_type, conjunction)
+        @association, @join_type, @conjunction = association, join_type, conjunction
       end
     end
   end

data/lib/record_filter/filter.rb

@@ -1,35 +1,92 @@
 module RecordFilter
   class Filter
 
-    delegate :inspect, :to => :loaded_data
+    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, combine_conjunction, *args, &block)
+    def initialize(clazz, named_filter, *args, &block)
+      @current_scoped_methods = clazz.send(:current_scoped_methods)
       @clazz = clazz
 
       @dsl = dsl_for_named_filter(@clazz, named_filter)
       @dsl.instance_eval(&block) if block
       @dsl.send(named_filter, *args) if named_filter && @dsl.respond_to?(named_filter)
-      @dsl.conjunction.steps.unshift(combine_conjunction.steps).flatten! if combine_conjunction
+      @query = Query.new(@clazz, @dsl.conjunction)
+    end
+
+    def first(*args)
+      if args.first.kind_of?(Integer)
+        loaded_data.first(*args)
+      else
+        do_with_scope do
+          @clazz.find(:first, *args)
+        end
+      end
+    end
+
+    def last(*args)
+      if args.first.kind_of?(Integer)
+        loaded_data.last(*args)
+      else
+        do_with_scope do
+          @clazz.find(:last, *args)
+        end
+      end
+    end
+
+    def size
+      @loaded_data ? @loaded_data.length : count
+    end
+
+    def empty?
+      @loaded_data ? @loaded_data.empty? : count.zero?
+    end
+
+    def any?
+      if block_given?
+        loaded_data.any? { |*block_args| yield(*block_args) }
+      else
+        !empty?
+      end
     end
 
     def filter(&block)
-      Filter.new(@clazz, nil, @dsl.conjunction, &block)
+      do_with_scope do
+        Filter.new(@clazz, nil, &block)
+      end
     end
 
+    def proxy_options(count_query=false)
+      @query.to_find_params(count_query)
+    end
+
+    protected
+
     def method_missing(method, *args, &block)
       if @clazz.named_filters.include?(method)
-        Filter.new(@clazz, method, @dsl.conjunction, *args)
+        do_with_scope do
+          Filter.new(@clazz, method, *args)
+        end
       else
-        loaded_data.send(method, *args, &block)
+        do_with_scope(method == :count) do
+          @clazz.send(method, *args, &block)
+        end
       end
     end
 
-    protected
-
-    def loaded_data
-      @loaded_data ||= begin
-        query = Query.new(@clazz, @dsl.conjunction)
-        @clazz.scoped(query.to_find_params)
+    def do_with_scope(count_query=false, &block)
+      @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
+            block.call
+          end
+        else
+          block.call
+        end
       end
     end
 
@@ -42,5 +99,11 @@ module RecordFilter
       end
       nil
     end
+
+    def loaded_data
+      @loaded_data ||= do_with_scope do
+        @clazz.find(:all)
+      end
+    end
   end
 end

data/lib/record_filter/group_by.rb

@@ -17,7 +17,7 @@ module RecordFilter
         raise ColumnNotFoundException.new("The column #{column} was not found in #{table.table_name}.")
       end
 
-      "#{table.table_name}.#{column}"
+      "#{table.table_alias}.#{column}"
     end
   end
 end

data/lib/record_filter/join.rb

@@ -2,9 +2,10 @@ module RecordFilter
   class Join
     attr_reader :left_table, :right_table
 
-    def initialize(left_table, right_table, join_conditions, join_type=:inner)
+    def initialize(left_table, right_table, join_conditions, join_type=nil)
       @left_table, @right_table, @join_conditions, @join_type =
         left_table, right_table, join_conditions, join_type
+      @join_type ||= :inner
     end
 
     def to_sql
@@ -20,6 +21,10 @@ module RecordFilter
       "#{join_type_string} JOIN #{@right_table.table_name} AS #{@right_table.table_alias} ON #{predicate_sql}"
     end
 
+    def requires_distinct_select?
+      [:left, :outer, :left_outer].include?(@join_type)
+    end
+
     protected
 
     def condition_to_predicate_part(condition)
@@ -51,6 +56,8 @@ module RecordFilter
       @join_type_string ||= case(@join_type)
         when :inner then 'INNER'
         when :left then 'LEFT'
+        when :left_outer then 'LEFT OUTER'
+        when :outer then 'OUTER'
         else nil
       end
     end

data/lib/record_filter/order.rb

@@ -22,7 +22,7 @@ module RecordFilter
         raise ColumnNotFoundException.new("The column #{column} was not found in #{table.table_name}.")
       end
 
-      "#{table.table_name}.#{column} #{dir}"
+      "#{table.table_alias}.#{column} #{dir}"
     end
   end
 end

data/lib/record_filter/query.rb

@@ -6,10 +6,19 @@ module RecordFilter
       @conjunction = RecordFilter::Conjunctions::Base.create_from(dsl_conjunction, @table)
     end
 
-    def to_find_params
-      params = { :conditions => @conjunction.to_conditions }
+    def to_find_params(count_query=false)
+      params = {}
+      conditions = @conjunction.to_conditions
+      params = { :conditions => conditions } if conditions
       joins = @table.all_joins
       params[:joins] = joins.map { |join| join.to_sql } * ' ' unless joins.empty?
+      if (joins.any? { |j| j.requires_distinct_select? })
+        if count_query
+          params[:select] = "DISTINCT #{@table.model_class.quoted_table_name}.#{@table.model_class.primary_key}"
+        else
+          params[:select] = "DISTINCT #{@table.model_class.quoted_table_name}.*"
+        end
+      end
       orders = @table.orders
       params[:order] = orders.map { |order| order.to_sql } * ', ' unless orders.empty?
       group_bys = @table.group_bys

data/lib/record_filter/restrictions.rb

@@ -15,7 +15,7 @@ module RecordFilter
       end
 
       def to_negative_sql
-        "!(#{to_positive_sql})"
+        "NOT (#{to_positive_sql})"
       end
 
       def self.class_from_operator(operator)
@@ -29,7 +29,7 @@ module RecordFilter
       end
 
       def to_negative_sql
-        "#{@column_name} != ?"
+        "#{@column_name} <> ?"
       end
     end
 

data/lib/record_filter/table.rb

@@ -16,18 +16,25 @@ module RecordFilter
       @model_class.quoted_table_name
     end
 
-    def join_association(association_name)
+    def join_association(association_name, join_type=nil)
       @joins_cache[association_name] ||=
         begin
           association = @model_class.reflect_on_association(association_name)
           if association.nil?
             raise AssociationNotFoundException.new("The association #{association_name} was not found on #{@model_class.name}.")
           end
-          case association.macro
-          when :belongs_to, :has_many, :has_one
-            simple_join(association)
-          when :has_and_belongs_to_many
-            compound_join(association)
+
+          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.right_table.join_association(association_name, join_type)
+          else
+            case association.macro
+            when :belongs_to, :has_many, :has_one
+              simple_join(association, join_type)
+            when :has_and_belongs_to_many
+              compound_join(association, join_type)
+            end
           end
         end
     end
@@ -62,7 +69,7 @@ module RecordFilter
 
     private
 
-    def simple_join(association)
+    def simple_join(association, join_type)
       join_predicate =
         case association.macro
         when :belongs_to
@@ -70,19 +77,23 @@ module RecordFilter
         when :has_many, :has_one
           [{ :id => 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
       join_table = Table.new(association.klass, alias_for_association(association))
-      @joins << join = Join.new(self, join_table, join_predicate)
+      @joins << join = Join.new(self, join_table, join_predicate, join_type)
       join
     end
 
-    def compound_join(association)
+    def compound_join(association, join_type)
       pivot_join_predicate = [{ :id => 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)
+      pivot_join = Join.new(self, pivot_table, pivot_join_predicate, join_type)
       join_predicate = [{ association.association_foreign_key.to_sym => :id }]
       join_table = Table.new(association.klass, alias_for_association(association))
-      pivot_table.joins << join = Join.new(pivot_table, join_table, join_predicate)
+      pivot_table.joins << join = Join.new(pivot_table, join_table, join_predicate, join_type)
       @joins << pivot_join
       join
     end

data/spec/exception_spec.rb

@@ -1,7 +1,10 @@
 require File.join(File.dirname(__FILE__), 'spec_helper')
 
 describe 'raising exceptions' do
-  
+  before do
+    TestModel.extended_models.each { |model| model.last_find = {} }
+  end 
+
   describe 'on missing associations' do
     it 'should get AssociationNotFoundException' do
       lambda {

data/spec/explicit_join_spec.rb

@@ -73,7 +73,34 @@ describe 'explicit joins' do
     end
 
     it 'should add the correct join' do
-      Review.last_find[:joins].should == %q(LEFT JOIN "features" AS reviews__Feature ON (reviews__Feature.featurable_type IS NULL) AND (reviews__Feature.featurable_id >= 12) AND (reviews__Feature.priority != 6))
+      Review.last_find[:joins].should == %q(LEFT JOIN "features" AS reviews__Feature ON (reviews__Feature.featurable_type IS NULL) AND (reviews__Feature.featurable_id >= 12) AND (reviews__Feature.priority <> 6))
+    end
+  end
+
+  describe 'using implicit and explicit joins together with conditions' do
+    before do
+      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
+      Blog.somethings.inspect
+    end
+
+    it 'should produce the correct conditions' do
+      Blog.last_find[:conditions].should == [%q((blogs__ads.content IS NULL))]
+    end
+
+    it 'should produce the correct join' do
+      Blog.last_find[:joins].should == %q(INNER JOIN "ads" AS blogs__ads ON "blogs".id = blogs__ads.blog_id LEFT JOIN "posts" AS blogs__Post ON "blogs".id = blogs__Post.blog_id INNER JOIN "comments" AS blogs__Post__Comment ON blogs__Post.id = blogs__Post__Comment.post_id AND (blogs__Post__Comment.offensive = 't'))
     end
   end
 end

data/spec/implicit_join_spec.rb

@@ -191,7 +191,7 @@ describe 'implicit joins' do
     end
 
     it 'should create the correct condition' do
-      Comment.last_find[:conditions].should == [%q("comments".offensive != ?), false]
+      Comment.last_find[:conditions].should == [%q("comments".offensive <> ?), false]
     end
   end
 
@@ -220,4 +220,94 @@ describe 'implicit joins' do
       Comment.last_find[:conditions].should == [%q(("comments".contents IS NOT NULL) AND ("comments".offensive = ?)), true]
     end
   end
+
+  describe 'passing the join type to having' do
+    before do
+      Blog.filter do
+        having(:left_outer, :posts) do
+          with(:permalink, 'ack')
+        end
+      end.inspect
+    end
+
+    it 'should create the correct condition' do
+      Blog.last_find[:conditions].should == [%q(blogs__posts.permalink = ?), 'ack']
+    end
+
+    it 'should create the correct join' do
+      Blog.last_find[:joins].should == %q(LEFT OUTER JOIN "posts" AS blogs__posts ON "blogs".id = blogs__posts.blog_id)
+    end
+  end
+
+  describe 'passing the join type to having with multiple joins' do
+    before do
+      Blog.filter do
+        having(:left_outer, :posts => :comments) do
+          with(:offensive, true)
+        end
+      end.inspect
+    end
+
+    it 'should create the correct condition' do
+      Blog.last_find[:conditions].should == [%q(blogs__posts__comments.offensive = ?), true]
+    end
+
+    it 'should create the correct join' do
+      Blog.last_find[:joins].should == %q(LEFT OUTER JOIN "posts" AS blogs__posts ON "blogs".id = blogs__posts.blog_id LEFT OUTER JOIN "comments" AS blogs__posts__comments ON blogs__posts.id = blogs__posts__comments.post_id)
+    end
+  end
+
+  describe 'on polymorphic associations' do
+    before do
+      PublicPost.filter do
+        having(:reviews) do
+          with(:stars_count, 3)
+        end
+      end.inspect
+    end
+
+    it 'should create the correct condition' do
+      PublicPost.last_find[:conditions].should == [%q(posts__reviews.stars_count = ?), 3]
+    end
+
+    it 'should create the correct join' do
+      PublicPost.last_find[:joins].should == %q(INNER JOIN "reviews" AS posts__reviews ON "posts".id = posts__reviews.reviewable_id AND (posts__reviews.reviewable_type = 'Post'))
+    end
+  end
+
+  describe 'on has_many_through associations' do
+    before do
+      Blog.filter do
+        having(:comments) do
+          with(:offensive, true)
+        end
+      end.inspect
+    end
+
+    it 'should create the correct condition' do
+      Blog.last_find[:conditions].should == [%q(blogs__posts__comments.offensive = ?), true]
+    end
+
+    it 'should create the correct join' do
+      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__comments ON blogs__posts.id = blogs__posts__comments.post_id)
+    end
+  end
+
+  describe 'on has_one_through associations' do
+    before do
+      Post.filter do
+        having(:user) do
+          with(:first_name, 'Joe')
+        end
+      end.inspect
+    end
+
+    it 'should create the correct condition' do
+      Post.last_find[:conditions].should == [%q(posts__author__user.first_name = ?), 'Joe']
+    end
+
+    it 'should create the correct join' do
+      Post.last_find[:joins].should == %q(INNER JOIN "authors" AS posts__author ON "posts".id = posts__author.post_id INNER JOIN "users" AS posts__author__user ON posts__author.user_id = posts__author__user.id)
+    end
+  end
 end

data/spec/limits_and_ordering_spec.rb

@@ -21,7 +21,7 @@ describe 'filter qualifiers' do
 
     describe 'with multiple calls to limit' do
       before do
-        Post.filter do
+       Post.filter do
           limit 5
           with :published, true
           limit 6
@@ -115,7 +115,7 @@ describe 'filter qualifiers' do
       end
 
       it 'should add the limit to the parameters' do
-        Post.last_find[:order].should == %q("photos".path DESC, "posts".permalink ASC)
+        Post.last_find[:order].should == %q(posts__photo.path DESC, "posts".permalink ASC)
       end
     end
 
@@ -184,7 +184,7 @@ describe 'filter qualifiers' do
         group_by(:created_at)
         group_by(:photo => :format)
       end.inspect
-      Post.last_find[:group].should == %q("posts".created_at, "photos".format)
+      Post.last_find[:group].should == %q("posts".created_at, posts__photo.format)
     end
   end
 end

data/spec/models.rb

@@ -0,0 +1,70 @@
+class Ad < ActiveRecord::Base
+  extend TestModel
+  belongs_to :blog
+end
+
+
+class Author < ActiveRecord::Base
+  extend TestModel
+  belongs_to :user
+  belongs_to :post
+end
+
+
+class Blog < ActiveRecord::Base
+  extend TestModel
+  has_many :posts
+  has_many :comments, :through => :posts
+  has_many :ads
+end
+
+
+class Comment < ActiveRecord::Base
+  extend TestModel
+  belongs_to :post
+  belongs_to :user
+end
+
+
+class Feature < ActiveRecord::Base
+  extend TestModel
+  belongs_to :featurable, :polymorphic => true
+end
+
+
+class Photo < ActiveRecord::Base
+  belongs_to :post
+end
+
+
+class Post < ActiveRecord::Base
+  extend TestModel
+  belongs_to :blog
+  has_many :comments
+  has_one :photo
+  has_and_belongs_to_many :tags
+  has_many :features, :as => :featurable
+  has_many :reviews, :as => :reviewable
+  has_one :author
+  has_one :user, :through => :author
+end
+
+class PublicPost < Post
+end
+
+class Review < ActiveRecord::Base
+  extend TestModel
+  belongs_to :reviewable, :polymorphic => true
+end
+
+
+class Tag < ActiveRecord::Base
+  has_and_belongs_to_many :posts
+end
+
+
+class User < ActiveRecord::Base
+  extend TestModel
+  has_one :author
+  has_many :comments
+end

data/spec/named_filter_spec.rb

@@ -50,7 +50,8 @@ describe 'named filters' do
 
     it 'should call the filter passing all of the arguments' do
       Blog.with_name_and_post_with_permalink('booya', 'ftw').inspect
-      Blog.last_find[:conditions].should == [%q(("blogs".name = ?) AND (blogs__posts.permalink = ?)), 'booya', 'ftw'] 
+      Blog.last_find[:conditions].should == 
+        [%q(("blogs".name = ?) AND (blogs__posts.permalink = ?)), 'booya', 'ftw'] 
     end
   end
 
@@ -81,7 +82,8 @@ describe 'named filters' do
 
     it 'should execute the parent class filters correctly' do
       NiceComment.with_contents('test contents').inspect
-      NiceComment.last_find[:conditions].should == [%q("comments".contents = ?), 'test contents']
+      NiceComment.last_find[:conditions].should == 
+        [%q("comments".contents = ?), 'test contents']
     end
 
     it 'should not have the subclass filters in the parent class' do
@@ -90,7 +92,8 @@ describe 'named filters' do
 
     it 'should have parent class filters in the subclass' do
       NiceComment.offensive.with_contents('something').inspect
-      NiceComment.last_find[:conditions].should == [%q(("comments".offensive = ?) AND ("comments".contents = ?)), true, 'something']
+      NiceComment.last_find[:conditions].should == 
+        %q(("comments".contents = 'something') AND ("comments".offensive = 't'))
     end
 
     it 'should provide access to the named filters' do
@@ -126,25 +129,25 @@ describe 'named filters' do
 
     it 'should chain the filters into a single query' do
       Post.for_blog(1).with_offensive_comments.inspect
-      Post.last_find[:conditions].should == [%q((posts__blog.id = ?) AND (posts__comments.offensive = ?)), 1, true]
-      Post.last_find[:joins].should == %q(INNER JOIN "blogs" AS posts__blog ON "posts".blog_id = posts__blog.id INNER JOIN "comments" AS posts__comments ON "posts".id = posts__comments.post_id)
+      Post.last_find[:conditions].should == %q((posts__comments.offensive = 't') AND (posts__blog.id = 1))
+      Post.last_find[:joins].should == [%q(INNER JOIN "comments" AS posts__comments ON "posts".id = posts__comments.post_id), %q(INNER JOIN "blogs" AS posts__blog ON "posts".blog_id = posts__blog.id)]
     end
 
     it 'should remove duplicate joins' do
       Post.for_blog(1).with_offensive_comments.with_interesting_comments.inspect
-      Post.last_find[:joins].should == %q(INNER JOIN "blogs" AS posts__blog ON "posts".blog_id = posts__blog.id INNER JOIN "comments" AS posts__comments ON "posts".id = posts__comments.post_id)
+      Post.last_find[:joins].should == [%q(INNER JOIN "comments" AS posts__comments ON "posts".id = posts__comments.post_id), %q(INNER JOIN "blogs" AS posts__blog ON "posts".blog_id = posts__blog.id)]
     end
 
     it 'should allow for filtering a named_filter' do
       Post.for_blog(1).filter { having(:comments).with :offensive, true }.inspect
-      Post.last_find[:conditions].should == [%q((posts__blog.id = ?) AND (posts__comments.offensive = ?)), 1, true]
-      Post.last_find[:joins].should == %q(INNER JOIN "blogs" AS posts__blog ON "posts".blog_id = posts__blog.id INNER JOIN "comments" AS posts__comments ON "posts".id = posts__comments.post_id)
+      Post.last_find[:conditions].should == %q((posts__comments.offensive = 't') AND (posts__blog.id = 1))
+      Post.last_find[:joins].should == [%q(INNER JOIN "comments" AS posts__comments ON "posts".id = posts__comments.post_id), %q(INNER JOIN "blogs" AS posts__blog ON "posts".blog_id = posts__blog.id)] 
     end
 
     it 'should allow for applying a named filter to a filter' do
       Post.filter { having(:comments).with :offensive, false }.for_blog(1).inspect
-      Post.last_find[:conditions].should == [%q((posts__comments.offensive = ?) AND (posts__blog.id = ?)), false, 1]
-      Post.last_find[:joins].should == %q(INNER JOIN "comments" AS posts__comments ON "posts".id = posts__comments.post_id INNER JOIN "blogs" AS posts__blog ON "posts".blog_id = posts__blog.id)  
+      Post.last_find[:conditions].should == %q((posts__blog.id = 1) AND (posts__comments.offensive = 'f'))
+      Post.last_find[:joins].should == [%q(INNER JOIN "blogs" AS posts__blog ON "posts".blog_id = posts__blog.id), %q(INNER JOIN "comments" AS posts__comments ON "posts".id = posts__comments.post_id)]
     end
 
     it 'should not change the inner filter conditions when chaining filters' do
@@ -163,11 +166,74 @@ describe 'named filters' do
 
     it 'should not change an original filter when reusing it' do
       base = Post.for_blog(1)
-      level1 = base.with_offensive_comments
+      level1 = base.with_offensive_comments.inspect
       level2 = base.with_interesting_comments
-      level1.inspect
-      Post.last_find[:conditions].should == [%q((posts__blog.id = ?) AND (posts__comments.offensive = ?)), 1, true]
-      Post.last_find[:joins].should == %q(INNER JOIN "blogs" AS posts__blog ON "posts".blog_id = posts__blog.id INNER JOIN "comments" AS posts__comments ON "posts".id = posts__comments.post_id)
+      Post.last_find[:conditions].should == %q((posts__comments.offensive = 't') AND (posts__blog.id = 1))
+      Post.last_find[:joins].should == [%q(INNER JOIN "comments" AS posts__comments ON "posts".id = posts__comments.post_id), %q(INNER JOIN "blogs" AS posts__blog ON "posts".blog_id = posts__blog.id)]
+    end
+  end
+
+  describe 'chaining named filters with regular AR associations' do
+    before do
+      Post.named_filter(:published) do
+        with(:published, true)
+      end
+      @blog = Blog.create
+      @blog.posts.published.inspect
+    end
+
+    it 'should combine the conditions from the association with the named filter' do
+      Post.last_find[:conditions].should == "(\"posts\".published = 't') AND (\"posts\".blog_id = #{@blog.id})"
+    end
+  end
+
+  describe 'chaining named filters with AR associations that involve joins' do
+    before do
+      Comment.named_filter(:with_user_named) do |name|
+        having(:user).with(:first_name, name)
+      end
+      @blog = Blog.create
+      @blog.comments.with_user_named('Bob').inspect
+    end
+
+    it 'should combine the joins from the association with the named filter' do
+      Comment.last_find[:joins].should == [%q(INNER JOIN "users" AS comments__user ON "comments".user_id = comments__user.id), %q(INNER JOIN "posts" ON "comments".post_id = "posts".id)]
+    end
+
+    it 'should combine the conditions from the association with the named filter' do
+      Comment.last_find[:conditions].should == "(comments__user.first_name = 'Bob') AND ((\"posts\".blog_id = #{@blog.id}))"
+    end
+  end
+
+  describe 'chaining multiple named filters with an AR association' do
+    before do
+      Comment.named_filter(:offensive) { with(:offensive, true) }
+      Comment.named_filter(:with_fun_in_contents) { with(:contents).like('%fun%') }
+      @post = Post.create
+      @post.comments.offensive.with_fun_in_contents.inspect
+    end
+
+    it 'should combine the conditions correctly' do
+      Comment.last_find[:conditions].should == "(\"comments\".contents LIKE '%fun%') AND ((\"comments\".offensive = 't') AND (\"comments\".post_id = #{@post.id}))"
+    end
+  end
+
+  describe 'chaining multiple named filters with different joins' do
+    before do
+      Blog.named_filter(:with_offensive_comments) { having(:comments).with(:offensive, true) }
+      Blog.named_filter(:with_ads_with_content) { |content| having(:ads).with(:content, content) }
+    end
+
+    it 'compile the joins correctly' do
+      Blog.with_offensive_comments.with_ads_with_content('ack').inspect
+      Blog.last_find[:joins].should == [%q(INNER JOIN "ads" AS blogs__ads ON "blogs".id = blogs__ads.blog_id), %q(INNER JOIN "posts" AS blogs__posts ON "blogs".id = blogs__posts.blog_id INNER JOIN "comments" AS blogs__posts__comments ON blogs__posts.id = blogs__posts__comments.post_id)]
+    end
+  end
+
+  describe 'with named filters that only include orders' do
+    it 'should have an empty conditions hash' do
+      Blog.named_filter(:ordered_by_id) { order(:id, :desc) }
+      Blog.ordered_by_id.proxy_options.should == { :order => %q("blogs".id DESC) }
     end
   end
 end

data/spec/proxying_spec.rb

@@ -0,0 +1,49 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe 'proxying to the found data' do
+  before do
+    TestModel.extended_models.each { |model| model.last_find = {} }
+  end
+
+  describe 'calling first and last on a filter result' do
+    before do
+      Blog.all.each { |b| b.destroy }
+      Blog.named_filter(:by_name) do
+        order(:name)
+      end
+      @blog1 = Blog.create(:name => 'a')
+      @blog2 = Blog.create(:name => 'b')
+      @blog3 = Blog.create(:name => 'c')
+    end
+    
+    it 'should return the first element in the result correctly' do
+      Blog.by_name.first.should == @blog1
+    end
+
+    it 'should return the last element in the result correctly' do
+      Blog.by_name.last.should == @blog3
+    end
+
+    it 'should proxy arguments through' do
+      Blog.by_name.first(:conditions => ['name = ?', 'b']).should == @blog2
+    end
+  end
+
+  describe 'calling reject! on a filter result' do
+    before do
+      Blog.all.each { |blog| blog.destroy }
+      Blog.named_filter(:by_name) do
+        order(:name)
+      end
+      @blog1 = Blog.create
+      @blog2 = Blog.create
+    end
+
+    it 'should remove the rejected items from the list' do
+      items = Blog.by_name
+      items.size.should == 2
+      items.reject! { |i| true } # should reject them all
+      items.size.should == 0
+    end
+  end
+end

data/spec/restrictions_spec.rb

@@ -72,7 +72,7 @@ describe 'RecordFilter restrictions' do
         with(:permalink, 'eek')
       end
     end.inspect
-    Post.last_find.should == { :conditions => [%q{!(("posts".blog_id = ?) OR ("posts".permalink = ?))}, 1, 'eek'] }
+    Post.last_find.should == { :conditions => [%q{NOT (("posts".blog_id = ?) OR ("posts".permalink = ?))}, 1, 'eek'] }
   end
 
   it 'should filter by not_all_of' do
@@ -82,7 +82,7 @@ describe 'RecordFilter restrictions' do
         with(:permalink, 'eek')
       end
     end.inspect
-    Post.last_find.should == { :conditions => [%q{!(("posts".blog_id = ?) AND ("posts".permalink = ?))}, 1, 'eek'] }
+    Post.last_find.should == { :conditions => [%q{NOT (("posts".blog_id = ?) AND ("posts".permalink = ?))}, 1, 'eek'] }
   end
 
   it 'should filter by disjunction' do
@@ -137,6 +137,6 @@ describe 'RecordFilter restrictions' do
     Post.filter do
       with(:permalink).not.equal_to(filter_class.name)
     end.inspect
-    Post.last_find.should == { :conditions => [%q("posts".permalink != ?), 'Post'] }
+    Post.last_find.should == { :conditions => [%q("posts".permalink <> ?), 'Post'] }
   end
 end

data/spec/select_spec.rb

@@ -0,0 +1,58 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe 'with custom selects for cases where DISTINCT is required' do
+  before do
+    TestModel.extended_models.each { |model| model.last_find = {} }
+  end 
+
+  describe 'on a standard filter' do
+    it 'should put nothing in the select' do
+      Post.filter do
+        having(:comments).with(:offensive, true)
+      end.inspect
+      Post.last_find[:select].should be_nil
+    end
+  end
+
+  describe 'with join types that require distinct' do
+    it 'should put the distinct clause in the select' do
+      [:left, :outer, :left_outer].each do |join_type|
+        Post.filter do
+          having(join_type, :comments).with(:offensive, true)
+        end.inspect
+        Post.last_find[:select].should == %q(DISTINCT "posts".*)
+      end
+    end
+  end
+
+  describe 'with join types that do not require distinct' do
+    it 'should not put the distinct clause in the select' do
+      [:inner].each do |join_type|
+        Post.filter do
+          having(join_type, :comments).with(:offensive, true)
+        end.inspect
+        Post.last_find[:select].should be_nil
+      end
+    end
+  end
+
+  describe 'on a filter with nested joins that require distinct' do
+    it 'should put the distinct clause in the select' do
+      Blog.filter do
+        having(:posts) do
+          having(:left_outer, :comments).with(:offensive, true)
+        end
+      end.inspect
+      Blog.last_find[:select].should == %q(DISTINCT "blogs".*)
+    end
+  end
+
+  describe 'on a filter that requires distinct with a count call' do
+    it 'should put the distinct clause in the select' do
+      Post.filter do
+        having(:left_outer, :comments).with(:offensive, true)
+      end.count
+      Post.last_find[:select].should == %q(DISTINCT "posts".id)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -13,8 +13,14 @@ module TestModel
 
   attr_accessor :last_find
 
-  def scoped(params = {})
-    @last_find = params
+  def find(*args)
+    @last_find = current_scoped_methods[:find] if current_scoped_methods
+    super
+  end
+
+  def count(*args)
+    @last_find = current_scoped_methods[:find] if current_scoped_methods
+    super
   end
 
   def self.extended(base)
@@ -22,7 +28,7 @@ module TestModel
   end
 end
 
-Dir.glob(File.join(File.dirname(__FILE__), 'models', '*.rb')).each { |file| require file }
+require File.join(File.dirname(__FILE__), 'models')
 
 ActiveRecord::Base.establish_connection(
   :adapter => 'sqlite3',

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: aub-record_filter
 version: !ruby/object:Gem::Version 
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors: 
 - Mat Brown
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-22 00:00:00 -07:00
+date: 2009-04-27 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -52,15 +52,11 @@ files:
 - spec/explicit_join_spec.rb
 - spec/implicit_join_spec.rb
 - spec/limits_and_ordering_spec.rb
-- spec/models/blog.rb
-- spec/models/comment.rb
-- spec/models/feature.rb
-- spec/models/photo.rb
-- spec/models/post.rb
-- spec/models/review.rb
-- spec/models/tag.rb
+- spec/models.rb
 - spec/named_filter_spec.rb
+- spec/proxying_spec.rb
 - spec/restrictions_spec.rb
+- spec/select_spec.rb
 - spec/spec_helper.rb
 - spec/test.db
 has_rdoc: true
@@ -94,13 +90,9 @@ test_files:
 - spec/explicit_join_spec.rb
 - spec/implicit_join_spec.rb
 - spec/limits_and_ordering_spec.rb
-- spec/models/blog.rb
-- spec/models/comment.rb
-- spec/models/feature.rb
-- spec/models/photo.rb
-- spec/models/post.rb
-- spec/models/review.rb
-- spec/models/tag.rb
+- spec/models.rb
 - spec/named_filter_spec.rb
+- spec/proxying_spec.rb
 - spec/restrictions_spec.rb
+- spec/select_spec.rb
 - spec/spec_helper.rb

data/spec/models/blog.rb

@@ -1,5 +0,0 @@
-class Blog < ActiveRecord::Base
-  extend TestModel
-
-  has_many :posts
-end

data/spec/models/comment.rb

@@ -1,5 +0,0 @@
-class Comment < ActiveRecord::Base
-  extend TestModel
-
-  belongs_to :post
-end

data/spec/models/feature.rb

@@ -1,5 +0,0 @@
-class Feature < ActiveRecord::Base
-  extend TestModel
-
-  belongs_to :featurable, :polymorphic => true
-end

data/spec/models/photo.rb

@@ -1,3 +0,0 @@
-class Photo < ActiveRecord::Base
-  belongs_to :post
-end

data/spec/models/post.rb

@@ -1,10 +0,0 @@
-class Post < ActiveRecord::Base
-  extend TestModel
-
-  belongs_to :blog
-  has_many :comments
-  has_one :photo
-  has_and_belongs_to_many :tags
-  has_many :features, :as => :featurable
-  has_many :reviews, :as => :reviewable
-end

data/spec/models/review.rb

@@ -1,5 +0,0 @@
-class Review < ActiveRecord::Base
-  extend TestModel
-
-  belongs_to :reviewable, :polymorphic => true
-end

data/spec/models/tag.rb

@@ -1,3 +0,0 @@
-class Tag < ActiveRecord::Base
-  has_and_belongs_to_many :posts
-end