aub-record_filter 0.8.0 → 0.9.0

data/README.rdoc

@@ -14,176 +14,242 @@ record_filter has the following top-level features:
 
   gem install outoftime-record_filter --source=http://gems.github.com
 
-== Usage
+== Using Filters
 
-=== Ad-hoc filters
+Given a Blog model having a has_many relationship with a Post model, a simple 
+filter with conditions and joins might look like this.
 
-  Post.filter do
-    with(:permalink, 'blog-post')
-    having(:blog).with(:name, 'Blog')
+  Blog.filter do
+    with(:created_at).greater_than(1.day.ago)
+    having(:posts).with(:permalink, nil)
   end
 
 This could be expressed in ActiveRecord as:
 
-  Post.find(:all, :joins => :blog, :conditions => ['posts.permalink = ? AND blogs.name = ?', 'blog-post', 'Blog')
-
-and it returns the same result, a list of Post objects that are returned from the query.
+  Blog.find(
+    :all, 
+    :joins => :posts, 
+    :conditions => ['posts.permalink IS NULL AND blogs.created_at > ?', 'blog-post', 1.day.ago)
 
-=== Named filters
+and it returns the same result, a list of Blog objects that are returned from the query. This
+type of filter is designed to be created on the fly, but if you have a filter that you would like
+to use in more than one place, it can be added to a class as a named filter. The following example
+creates the same filter as above and executes it:
 
   class Post < ActiveRecord::Base
-    named_filter(:with_title) do |title|
-      with(:title, title)
+    named_filter(:new_with_nil_permalink) do
+      with(:created_at).greater_than(1.day.ago)
+      having(:posts).with(:permalink, nil)
     end
   end
 
-  Post.with_title('posted')
+  Post.new_with_nil_permalink
 
-This is the same as the following code using named scopes, and returns the same result:
+This returns the same result as the example above but with the advantages that it is
+easily reusable and that it can be combined with other named filters to produce a more
+complex query:
 
   class Post < ActiveRecord::Base
-    named_scope :with_title, lambda { |title| { :conditions => ['title = ?', title] }}
+    named_filter(:title_is_monkeys) { with(:title, 'monkeys') }
+    named_filter(:permalink_is_donkeys) { with(:title, 'donkeys') }
   end
-  
-  Post.with_title('scoped')
-
-=== Restrictions
-
-Restrictions are specified through the API using the 'with' function. The first argument to 'with' should be the
-name of the field that the restriction applies to. All restriction types can be negated by chaining the 'with'
-method with a call to 'not', as seen in some examples below.
 
-==== Equality
+  Post.title_is_monkeys.permalink_is_donkeys
 
-If a second argument is supplied, it is assumed that you are 
-expressing an equality condition and that argument is used as the value.
+This example will return all of the posts that meet both animal-related conditions. 
+There is no limit to the number of filters that can be combined, and because record_filter works 
+seamlessly with named scopes, they can also be combined in this way as well. 
 
-  with(:title, 'abc') # :conditions => ['title = ?', 'abc']
+Named filters can also be customized by taking any number of arguments. The example above can
+be replicated with the following filter:
 
-Which can be negated with:
-
-  with(:title, 'abc').not # :conditions => ['title <> ?', 'abc']
+  class Post < ActiveRecord::Base
+    named_filter(:with_title_and_permalink) do |title, permalink|
+      with(:title, title)
+      with(:permalink, permalink)
+    end
+  end
 
-For the more verbose among us, this can also be specified as:
+  Post.with_title_and_permalink('monkeys', 'donkeys')
 
-  with(:title).equal_to('abc') # :conditions => ['title = ?', 'abc']
+Named filters can also be called from other named filters and will be invoked on the correct
+model even if called from a join.
 
-Other types of restrictions are specified by omitting the second argument to 'with' and chaining it with one of the
-restriction methods.
+  class Comment < ActiveRecord::Base
+    named_filter(:offensive) { with(:offensive, true) }
+  end
 
-==== Comparison operators
+  class Post < ActiveRecord::Base
+    named_filter(:recursive_test) do
+      having(:comments) do
+        offensive
+      end
+    end
+  end
 
-  with(:price).greater_than(10) # :conditions => ['price > ?', 10]
+== Specifying Filters
 
-  with(:created_at).less_than(2.days.ago) # :conditions => ['created_at < ?', 2.days.ago]
+record_filter supports all of SQL query abstractions provided by ActiveRecord, specifically:
 
-These methods can also have _or_equal_to tagged onto the end, to obvious affect, and all of the comparison operators are aliased to
-their standard single-character variants:
+* Conditions
+* Boolean operations
+* Joins
+* Limits
+* Offsets
+* Ordering
+* Grouping
 
-  gt, gte, lt and lte
+The following example shows the use of each of these techniques:
 
-==== IS NULL
+  Post.filter do
+    any_of do
+      with(:permalink).is_null
+      having(:comments) do
+        with(:offensive, true)
+      end
+    end
+    limit(10, 100)
+    order(:created_at, :desc)
+    group_by(:comments => :offensive)
+  end
 
-  with(:price, nil) # :conditions => ['price IS NULL']
+=== Conditions
 
-This short form can also be made explicit by using the is_null, null, or nil functions on with:
+Conditions are specified using the 'with' function, which takes as its first argument
+the name of the column to restrict. If a second argument is given, it will automatically
+be used as the value in an equality condition. The 'with' function will return a Restriction
+object that has methods to specify a number of different conditions and to negate them:
 
-  with(:price).is_null # :conditions => ['price IS NULL']
+  with(:permalink, 'aardvarks')            # :conditions => ['permalink = ?', 'aardvarks']
+  with(:permalink).equal_to('sheep')       # :conditions => ['permalink = ?', 'sheep']
+  with(:permalink).not.equal_to('cats')    # :conditions => ['permailnk <> ?', 'cats']
 
-It can be negated either by chaining with the 'not' function or by using is_not_null:
+  with(:permalink, nil)                    # :conditions => ['permalink IS NULL']
+  with(:permalink).is_null                 # :conditions => ['permalink IS NULL']
+  with(:permalink, nil).not                # :conditions => ['permalink IS NOT NULL']
 
-  with(:price).is_not_null # :conditions => ['price IS NOT NULL']
-  with(:price).is_null.not # "
+The following condition types are supported through the Restriction API:
 
-==== IN
+* Equality
+* Comparisons (> >= < <=)
+* Between
+* In
+* Is null
+* Like
 
-  with(:id).in([1, 2, 3]) # :conditions => ['id IN (?)', [1, 2, 3]]
+=== Boolean Operations
 
-==== BETWEEN
+Conditions can be combined with boolean operators using the methods all_of, any_of, none_of
+and not_all_of. These methods take a block where any conditions they contain will be combined
+using AND, OR and NOT to create the correct condition. The block can also contain any number of
+joins or other boolean operations. The default operator is all_of.
 
-  with(:id).between(1, 5) # :conditions => ['id BETWEEN ? AND ?', 1, 5]
+  Post.filter do
+    with(:id, 4)
+    with(:permalink, 'ack')
+  end
 
-The argument to between can also be either a tuple or a range
+  :conditions => ['id = ? AND permalink = ?', 4, 'ack']
 
-  with(:created_at).between([Time.now, 3.days.ago]) # :conditions => ['created_at BETWEEN ? AND ?', Time.now, 3.days.ago]
+  Post.filter do
+    any_of
+      with(:id, 3)
+      with(:permalink, 'booya')
+    end
+  end
 
-  with(:price).between(1..5) # :conditions => ['price BETWEEN ? AND ?', 1, 5]
+  :conditions => ['id = ? OR permalink = ?', 3, 'booya']
 
-==== LIKE
+  Post.filter do
+    none_of
+      with(:id, 2)
+      with(:permalink, 'ouch')
+    end
+  end
 
-  with(:title).like('%help%') # :conditions => ['title LIKE ?', '%help%']
+  :conditions => ['NOT (id = ? OR permalink = ?', 2, 'ouch']
 
+=== Joins
 
-=== Implicit Joins
+Joins in record_filter come in two varieties. Using the information in ActiveRecord associations,
+it is possible to perform most joins easily using the 'having' method, which requires no specification
+of the columns to use for the join. In cases where an association does not apply, it is also possible
+to create an explicit join that can include both the columns to combine as well as restrictions on
+the columns in the join table.
 
-Implicit joins are specified using the 'having' function, which takes as its argument the name of an association to join on.
+In a filter for a Post model that has_many comments, the following two examples are equivalent:
 
-  having(:comments) # :joins => :comments
+  having(:comments)
 
-This function can be chained with calls to 'with' in order to specify conditions on the joined table:
+  join(Comment, :inner) do
+    on(:id => :post_id)
+  end
 
-  having(:comments).with(:created_at).gt(2.days.ago) # :joins => :comments, :conditions => ['comments.created_at > ?', 2.days.ago]
+With an explicit join, any number of columns can be matched in this way, and both join types
+accept a block in which any number of conditions, boolean operations, or other joins can be
+added. Explicit joins also allow conditions to be set on columns of the table being joined:
 
-It can also take a block that can have any number of conditions or other clauses (including other joins) in it:
+  having(:comments).with(:offensive, true)
 
   having(:comments) do
-    with(:created_at).gt(2.days.ago)
-    having(:author).with(:name, 'Bubba')
+    with(:created_at).greater_than(2.days.ago)
   end
 
-The 'having' function can also take :inner, :left or :right as its second argument in order to specify that a particular join type
-should be used.
+  join(Comment, :inner) do
+    on(:id => :commentable_id)
+    on(:commentable_type).equal_to('Post')
+  end
 
-=== Explicit joins
+With implicit joins, it is also possible to use a hash as the association name, in which case
+multiple joins can be created with one statement. If the comment model has_one Author, this 
+example will join both tables and add a condition on the author.
 
-In cases where there is no ActiveRecord association that can be used to specify an implicit join, explicit joins are also
-supported, using the 'join' function. Its arguments are the class to be joined against, the join type (:inner, left or :right) and
-an optional alias for the join table. A block should also be supplied in order to specify the columns to use for the join using the
-'on' method.
+  having(:comments => :author).with(:name, 'Bob')
 
-  Post.filter do
-    join(Comment, :inner, :posts__comments_alias) do
-      on(:id => :commentable_id)
-      on(:commentable_type, 'Post')
-    end
-  end
+=== Limits and Offsets
 
-=== Conjunctions
+These are specified using the 'limit' method, which takes two arguments, the offset and the
+limit. If only one argument is given, it is assumed to be the limit.
 
-The following conjunction types are supported:
+  limit(10, 100)   # :offset => 10, :limit => 100
+  limit(100)       # :offset => 0, :limit => 100
 
-* any_of
-* all_of
-* none_of
-* not_all_of
+=== Ordering
 
-Each takes a block that can contain conditions or joins and will apply the expected boolean logic to the combination.
+Ordering is done through the 'order' method, which accepts arguments for the column and direction.
+The column can either be passed as the name of a column in the class that is being filtered or as
+a hash that represents a path through the joined associations to the correct column. The direction argument
+should be either :asc or :desc and defaults to :asc if not given. Multiple calls to 'order' are
+allowed and will be applied in the order in which they were given.
 
-  any_of
-    with(:price, 2)
-    with(:price).gt(100)
+  Post.filter do
+    having(:comments).with(:offensive, true)
+    order(:created_at, :desc)
+    order(:comments => :id)
   end
 
-  # :conditions => ['price = ? OR price > ?', 2, 100]
-
-=== Limits and ordering
+  # :order => "'posts'.created_at DESC posts__comments.id ASC"
 
-  limit(20)
+=== Grouping
 
-  order(:id, :desc)
+Grouping is specified with the 'group_by' method, which accepts either the name of a column in the
+class that is being filtered or a hash that represents a path through the joined associations. If
+there are multiple calls to 'group_by' they will be combined in the final result, maintaining the
+order in which they were given.
 
-Multiple order clauses can be specified, and they will be applied in the order in which they are specified.
-When joins are used, order can also take a hash as the first argument that leads to the column to order on through the joins:
-
-  having(:comments).with(:offensive, true)
-  order(:comments => :id, :desc)
+  Post.filter do
+    having(:comments).with(:created_at).greater_than(1.hour.ago)
+    group_by(:permalink)
+    group_by(:comments => :offensive)
+  end
 
+  # :group => "'posts'.permalink, posts__comments.offensive'
 
 == LICENSE:
 
 (The MIT License)
 
-Copyright (c) 2008 Mat Brown
+Copyright (c) 2008 Mat Brown, Aubrey Holland
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :major: 0
-:minor: 8
+:minor: 9
 :patch: 0

data/lib/record_filter/dsl/conjunction_dsl.rb

@@ -159,7 +159,7 @@ module RecordFilter
 
       # Create an implicit join using an association as the target. This method allows you to
       # easily specify a join without specifying the columns to use by taking any needed data
-      # from the specified ActiveRecord association. If given, the block will be evaluated in
+      # from the given ActiveRecord association. If provided, the block will be evaluated in
       # the context of the table that has been joined, so any restrictions or other joins will
       # be performed using its columns and associations. For example, if a Post has_many comments
       # then the following code will join to the comments table and restrict the comments based
@@ -169,12 +169,13 @@ module RecordFilter
       #       with(:created_at).greater_than(3.days.ago)
       #     end
       #   end
-      # If one argument is given, it is assumed to be a symbol representing the name of the association
-      # that will be used for the join and a join type of :inner will be used. If two arguments are 
-      # provided, the first one is assumed to be the join type, which can be one of :inner, :left or 
+      # If one argument is given, it is assumed to represent the name of the association
+      # that will be used for the join and a join type of :inner will be used by default. If two arguments
+      # are provided, the first one is assumed to be the join type, which can be one of :inner, :left or 
       # :right and the second one is the association name. An alias will automatically be created
       # for the joined table named "#{left_table}__#{association_name}", so in the above example, the
-      # alias would be posts__comments.
+      # alias would be posts__comments. It is also possible to provide a hash as the association
+      # name, in which case a trail of associations can be joined in one statment.
       #
       # ==== Parameters
       # join_type<Symbol>::

data/lib/record_filter/dsl/dsl.rb

@@ -53,7 +53,7 @@ module RecordFilter
       #   a column in the class that is being filtered. With a hash argument, it is possible
       #   to specify a path to a column in one of the joined tables, as seen above.
       # direction<Symbol>::
-      #   Specifies the direction of the join. Should be either :asc or :desc.
+      #   Specifies the direction of the join. Should be either :asc or :desc and defaults to :asc.
       #
       # ==== Returns
       # nil

data/lib/record_filter/dsl/restriction.rb

@@ -201,6 +201,21 @@ module RecordFilter
         self
       end
 
+      # Create a negated IN restriction of the form ['column NOT IN (?)', value]
+      #
+      # ==== Parameters
+      # value::
+      #   Either a single item or an array of values to form the inclusion test.
+      #
+      # ==== Returns
+      # Restriction:: self
+      #
+      # @public
+      def not_in(value)
+        @value, @operator, @negated = value, :in, true
+        self
+      end
+
       # Create a LIKE restriction of the form ['column LIKE ?', value]
       #
       # ==== Parameters

data/lib/record_filter/filter.rb

@@ -2,7 +2,7 @@ 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?)
+    NON_DELEGATE_METHODS = %w(debugger 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)

data/lib/record_filter/query.rb

@@ -21,7 +21,7 @@ module RecordFilter
         conditions = @conjunction.to_conditions
         params = { :conditions => conditions } if conditions
         joins = @table.all_joins
-        params[:joins] = joins.map { |join| join.to_sql } * ' ' unless joins.empty?
+        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}"

data/lib/record_filter/table.rb

@@ -17,6 +17,7 @@ module RecordFilter
     end
 
     def join_association(association_name, join_type=nil, options={})
+      association_name = association_name.to_sym
       @joins_cache[association_name] ||=
         begin
           association = @model_class.reflect_on_association(association_name)
@@ -115,7 +116,7 @@ module RecordFilter
     protected
 
     def alias_for_association(association)
-      "#{@aliased ? @table_alias.to_s : @model_class.table_name}__#{association.name}"
+      "#{@aliased ? @table_alias.to_s : @model_class.table_name}__#{association.name.to_s.downcase}"
     end
 
     alias_method :alias_for_class, :alias_for_association

data/spec/active_record_spec.rb

@@ -18,7 +18,7 @@ describe 'active record options' do
       end
 
       it 'should create the correct join' do
-        Blog.last_find[:joins].should == %q(INNER JOIN "news_stories" AS blogs__stories ON "blogs".id = blogs__stories.blog_id)
+        Blog.last_find[:joins].should == [%q(INNER JOIN "news_stories" AS blogs__stories ON "blogs".id = blogs__stories.blog_id)]
       end
     end
 
@@ -34,7 +34,7 @@ describe 'active record options' do
       end
 
       it 'should create the correct join' do
-        Blog.last_find[:joins].should == %q(INNER JOIN "posts" AS blogs__special_posts ON "blogs".id = blogs__special_posts.special_blog_id)
+        Blog.last_find[:joins].should == [%q(INNER JOIN "posts" AS blogs__special_posts ON "blogs".id = blogs__special_posts.special_blog_id)]
       end
     end
 
@@ -50,7 +50,7 @@ describe 'active record options' do
       end
 
       it 'should create the correct join' do
-        Blog.last_find[:joins].should == %q(INNER JOIN "posts" AS blogs__special_public_posts ON "blogs".special_id = blogs__special_public_posts.blog_id)
+        Blog.last_find[:joins].should == [%q(INNER JOIN "posts" AS blogs__special_public_posts ON "blogs".special_id = blogs__special_public_posts.blog_id)]
       end
     end
 
@@ -66,7 +66,7 @@ describe 'active record options' do
       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__bad_comments ON blogs__posts.id = blogs__posts__bad_comments.post_id)
+        Blog.last_find[:joins].should == [%q(INNER JOIN "posts" AS blogs__posts ON "blogs".id = blogs__posts.blog_id), %q(INNER JOIN "comments" AS blogs__posts__bad_comments ON blogs__posts.id = blogs__posts__bad_comments.post_id)]
       end
     end
 
@@ -82,22 +82,9 @@ describe 'active record options' do
       end
 
       it 'should create the correct join' do
-        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
-    # :having
-    # :limit
-    # :offset
-    # :select
-    # :uniq
-    # :readonly
-    # :order
-    # :conditions
+        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')), %q(INNER JOIN "posts" AS blogs__features__featurable ON blogs__features.featurable_id = blogs__features__featurable.id)]
+      end
+    end
   end
 
   describe 'for belongs_to' do
@@ -114,7 +101,7 @@ describe 'active record options' do
       end
 
       it 'should create the correct join' do
-        Post.last_find[:joins].should == %q(INNER JOIN "blogs" AS posts__publication ON "posts".blog_id = posts__publication.id)
+        Post.last_find[:joins].should == [%q(INNER JOIN "blogs" AS posts__publication ON "posts".blog_id = posts__publication.id)]
       end
     end
 
@@ -130,15 +117,81 @@ describe 'active record options' do
       end
 
       it 'should create the correct join' do
-        Post.last_find[:joins].should == %q(INNER JOIN "blogs" AS posts__special_blog ON "posts".special_blog_id = posts__special_blog.id)
+        Post.last_find[:joins].should == [%q(INNER JOIN "blogs" AS posts__special_blog ON "posts".special_blog_id = posts__special_blog.id)]
       end
     end
+  end
+
+  describe 'working with named scopes' do
+    before do
+      @blog = Class.new(Blog)
+      @blog.named_scope :with_high_id, { :conditions => ['id > 100'] }
+      @blog.named_filter(:published) { with(:published, true) }
+    end
+    
+    it 'should concatenate the filter with the scope correctly' do
+      @blog.with_high_id.published.inspect
+      @blog.last_find[:conditions].should == %q(("blogs".published = 't') AND (id > 100))
+    end
+
+    it 'should concatenate correctly when called in the other order' do
+      @blog.published.with_high_id.inspect
+      @blog.last_find[:conditions].should == %q((id > 100) AND ("blogs".published = 't'))
+    end
+  end
+
+  describe 'working with named scopes when there are a number of joins' do
+    before do
+      @blog = Class.new(Blog)
+      @blog.named_scope :ads_with_sale, { :joins => :ads, :conditions => ["'ads'.content LIKE ?", '%sale%'] }
+      @blog.named_filter(:with_permalinked_posts) { having(:posts).with(:permalink).is_not_null }
+      @blog.named_filter(:with_offensive_comments) { having(:comments).with(:offensive, true) }
+      @blog.with_permalinked_posts.ads_with_sale.with_offensive_comments.inspect
+    end
+
+    it 'should concatenate the conditions correctly' do
+      @blog.last_find[:conditions].should == %q((blogs__posts__comments.offensive = 't') AND (('ads'.content LIKE '%sale%') AND (blogs__posts.permalink IS NOT NULL)))
+    end
+
+    it 'should concatenate the joins correctly and not throw away my joins like AR usually does' do
+      @blog.last_find[:joins].should == [%q(INNER JOIN "posts" AS blogs__posts ON "blogs".id = blogs__posts.blog_id), %q(INNER JOIN "comments" AS blogs__posts__comments ON blogs__posts.id = blogs__posts__comments.post_id), %q(INNER JOIN "ads" ON ads.blog_id = blogs.id)]
+    end
+  end
 
-    # :include
-    # :conditions
-    # :select
-    # :foreign_key
-    # :polymorphic
-    # :readonly
+  describe 'working with named scopes that join to the same table' do
+    before do
+      @blog = Class.new(Blog)
+      @blog.named_scope :with_crazy_post_permalinks, { :joins => :posts, :conditions => ["'posts'.permalink = ?", 'crazy'] }
+      @blog.named_filter(:with_empty_permalinks) { having(:posts).with(:permalink, nil) } 
+    end
+
+    it 'should concatenate the conditions correctly' do
+      @blog.with_crazy_post_permalinks.with_empty_permalinks.inspect 
+      @blog.last_find[:conditions].should == %q((blogs__posts.permalink IS NULL) AND ('posts'.permalink = 'crazy'))
+    end
+
+    it 'should concatenate the joins correctly' do
+      @blog.with_crazy_post_permalinks.with_empty_permalinks.inspect
+      @blog.last_find[:joins].should == [%q(INNER JOIN "posts" AS blogs__posts ON "blogs".id = blogs__posts.blog_id), %q(INNER JOIN "posts" ON posts.blog_id = blogs.id)]
+    end
+  end
+
+  describe 'working with default scopes' do
+    describe 'with a simple filter' do
+      before do
+        Article.filter do
+          with(:contents, 'something')
+        end.inspect
+      end
+
+      it 'should use the correct order' do
+        Article.last_find[:order].should == %q(created_at DESC)
+      end
+
+      it 'should use the correct conditions' do
+        pending 'currently the IS NULL condition is added twice.'
+        Article.last_find[:conditions].should == %q((("articles"."created_at" IS NULL) AND ("articles".contents = 'something')))
+      end
+    end
   end
 end

data/spec/explicit_join_spec.rb

@@ -16,7 +16,7 @@ describe 'explicit joins' do
     end
 
     it 'should add correct join' do
-      Post.last_find[:joins].should == %q(LEFT OUTER JOIN "blogs" AS posts_blogs ON "posts".blog_id = posts_blogs.id)
+      Post.last_find[:joins].should == [%q(LEFT OUTER JOIN "blogs" AS posts_blogs ON "posts".blog_id = posts_blogs.id)]
     end
 
     it 'should query against condition on join table' do
@@ -36,7 +36,7 @@ describe 'explicit joins' do
     end
 
     it 'should add correct join' do
-      Review.last_find[:joins].should == %q(LEFT OUTER JOIN "features" AS reviews_features ON "reviews".reviewable_id = reviews_features.featurable_id AND "reviews".reviewable_type = reviews_features.featurable_type)
+      Review.last_find[:joins].should == [%q(LEFT OUTER JOIN "features" AS reviews_features ON "reviews".reviewable_id = reviews_features.featurable_id AND "reviews".reviewable_type = reviews_features.featurable_type)]
     end
 
     it 'should query against condition on join table' do
@@ -57,7 +57,7 @@ describe 'explicit joins' do
     end
 
     it 'should add correct join' do
-      Review.last_find[:joins].should == %q(LEFT OUTER JOIN "features" AS reviews__Feature ON "reviews".reviewable_id = reviews__Feature.featurable_id AND "reviews".reviewable_type = reviews__Feature.featurable_type AND (reviews__Feature.featurable_type = 'SomeType'))
+      Review.last_find[:joins].should == [%q(LEFT OUTER JOIN "features" AS reviews__feature ON "reviews".reviewable_id = reviews__feature.featurable_id AND "reviews".reviewable_type = reviews__feature.featurable_type AND (reviews__feature.featurable_type = 'SomeType'))]
     end
   end
 
@@ -73,7 +73,7 @@ describe 'explicit joins' do
     end
 
     it 'should add the correct join' do
-      Review.last_find[:joins].should == %q(LEFT OUTER 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 OUTER 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
 
@@ -101,7 +101,7 @@ describe 'explicit joins' do
     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 OUTER 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'))
+      @blog.last_find[:joins].should == [%q(INNER JOIN "ads" AS blogs__ads ON "blogs".id = blogs__ads.blog_id), %q(LEFT OUTER JOIN "posts" AS blogs__post ON "blogs".id = blogs__post.blog_id), %q(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

@@ -14,7 +14,7 @@ describe 'implicit joins' do
       end
 
       it 'should add correct join' do
-        Post.last_find[:joins].should == %q(INNER JOIN "blogs" AS posts__blog ON "posts".blog_id = posts__blog.id)
+        Post.last_find[:joins].should == [%q(INNER JOIN "blogs" AS posts__blog ON "posts".blog_id = posts__blog.id)]
       end
 
       it 'should query against condition on join table' do
@@ -24,7 +24,7 @@ describe 'implicit joins' do
 
     shared_examples_for 'multiple conditions on single join' do
       it 'should add join once' do
-        Post.last_find[:joins].should == %q(INNER JOIN "blogs" AS posts__blog ON "posts".blog_id = posts__blog.id)
+        Post.last_find[:joins].should == [%q(INNER JOIN "blogs" AS posts__blog ON "posts".blog_id = posts__blog.id)]
       end
 
       it 'should query against conditions on join table' do
@@ -65,7 +65,7 @@ describe 'implicit joins' do
     end
 
     it 'should add correct join' do
-      Blog.last_find[:joins].should == %q(INNER JOIN "posts" AS blogs__posts ON "blogs".id = blogs__posts.blog_id)
+      Blog.last_find[:joins].should == [%q(INNER JOIN "posts" AS blogs__posts ON "blogs".id = blogs__posts.blog_id)]
     end
 
     it 'should query against condition on join table' do
@@ -84,8 +84,8 @@ describe 'implicit joins' do
     end
 
     it 'should add both joins' do
-      Blog.last_find[:joins].should == %q(INNER JOIN "posts" AS blogs__posts ON "blogs".id = blogs__posts.blog_id ) +
-                                       %q(INNER JOIN "comments" AS blogs__posts__comments ON blogs__posts.id = blogs__posts__comments.post_id)
+      Blog.last_find[:joins].should == [%q(INNER JOIN "posts" AS blogs__posts ON "blogs".id = blogs__posts.blog_id),
+                                        %q(INNER JOIN "comments" AS blogs__posts__comments ON blogs__posts.id = blogs__posts__comments.post_id)]
     end
 
     it 'should query against both conditions' do
@@ -103,8 +103,8 @@ describe 'implicit joins' do
     end
 
     it 'should add both joins' do
-      Blog.last_find[:joins].should == %q(INNER JOIN "posts" AS blogs__posts ON "blogs".id = blogs__posts.blog_id ) +
-                                       %q(INNER JOIN "comments" AS blogs__posts__comments ON blogs__posts.id = blogs__posts__comments.post_id)
+      Blog.last_find[:joins].should == [%q(INNER JOIN "posts" AS blogs__posts ON "blogs".id = blogs__posts.blog_id),
+                                        %q(INNER JOIN "comments" AS blogs__posts__comments ON blogs__posts.id = blogs__posts__comments.post_id)]
     end
 
     it 'should query against both conditions' do
@@ -120,7 +120,7 @@ describe 'implicit joins' do
     end
 
     it 'should add correct join' do
-      Post.last_find[:joins].should == %q(INNER JOIN "photos" AS posts__photo ON "posts".id = posts__photo.post_id)
+      Post.last_find[:joins].should == [%q(INNER JOIN "photos" AS posts__photo ON "posts".id = posts__photo.post_id)]
     end
 
     it 'should query against condition on join table' do
@@ -136,8 +136,8 @@ describe 'implicit joins' do
     end
 
     it 'should add correct join' do
-      Blog.last_find[:joins].should == %q(INNER JOIN "posts" AS blogs__posts ON "blogs".id = blogs__posts.blog_id ) +
-                                       %q(INNER JOIN "photos" AS blogs__posts__photo ON blogs__posts.id = blogs__posts__photo.post_id)
+      Blog.last_find[:joins].should == [%q(INNER JOIN "posts" AS blogs__posts ON "blogs".id = blogs__posts.blog_id),
+                                        %q(INNER JOIN "photos" AS blogs__posts__photo ON blogs__posts.id = blogs__posts__photo.post_id)]
     end
 
     it 'should query against condition on join table' do
@@ -153,8 +153,8 @@ describe 'implicit joins' do
     end
 
     it 'should add correct join' do
-      Post.last_find[:joins].should == %q(INNER JOIN "posts_tags" AS __posts__tags ON "posts".id = __posts__tags.post_id ) +
-                                       %q(INNER JOIN "tags" AS posts__tags ON __posts__tags.tag_id = posts__tags.id)
+      Post.last_find[:joins].should == [%q(INNER JOIN "posts_tags" AS __posts__tags ON "posts".id = __posts__tags.post_id),
+                                        %q(INNER JOIN "tags" AS posts__tags ON __posts__tags.tag_id = posts__tags.id)]
     end
   end
 
@@ -235,7 +235,7 @@ describe 'implicit joins' do
     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)
+      Blog.last_find[:joins].should == [%q(LEFT OUTER JOIN "posts" AS blogs__posts ON "blogs".id = blogs__posts.blog_id)]
     end
   end
 
@@ -253,7 +253,7 @@ describe 'implicit joins' do
     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)
+      Blog.last_find[:joins].should == [%q(LEFT OUTER JOIN "posts" AS blogs__posts ON "blogs".id = blogs__posts.blog_id), %q(LEFT OUTER JOIN "comments" AS blogs__posts__comments ON blogs__posts.id = blogs__posts__comments.post_id)]
     end
   end
 
@@ -271,7 +271,7 @@ describe 'implicit joins' do
     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'))
+      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
 
@@ -289,7 +289,7 @@ describe 'implicit joins' do
     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)
+      Blog.last_find[:joins].should == [%q(INNER JOIN "posts" AS blogs__posts ON "blogs".id = blogs__posts.blog_id), %q(INNER JOIN "comments" AS blogs__posts__comments ON blogs__posts.id = blogs__posts__comments.post_id)]
     end
   end
 
@@ -307,7 +307,26 @@ describe 'implicit joins' do
     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)
+      Post.last_find[:joins].should == [%q(INNER JOIN "authors" AS posts__author ON "posts".id = posts__author.post_id), %q(INNER JOIN "users" AS posts__author__user ON posts__author.user_id = posts__author__user.id)]
+    end
+  end
+
+  describe 'passing strings instead of symbols' do
+    before do
+      Post.filter do
+        having('comments') do
+          with('offensive', true)
+        end
+        with('id').gte(12)
+      end.inspect
+    end
+
+    it 'should create the correct condition' do
+      Post.last_find[:conditions].should == [%q((posts__comments.offensive = ?) AND ("posts".id >= ?)), true, 12]
+    end
+
+    it 'should create the correct join' do
+      Post.last_find[:joins].should == [%q(INNER JOIN "comments" AS posts__comments ON "posts".id = posts__comments.post_id)]
     end
   end
 end

data/spec/models.rb

@@ -4,6 +4,12 @@ class Ad < ActiveRecord::Base
 end
 
 
+class Article < ActiveRecord::Base
+  extend TestModel
+  default_scope :order => 'created_at DESC', :conditions => { :created_at => nil }
+end
+
+
 class Author < ActiveRecord::Base
   extend TestModel
   belongs_to :user
@@ -24,6 +30,7 @@ class Blog < ActiveRecord::Base
   has_many :features
   has_many :featured_posts, :through => :features, :source => :featurable, :source_type => 'Post'
   has_many :posts_with_comments, :class_name => 'Post', :include => :comments
+  has_many :articles
 end
 
 

data/spec/named_filter_spec.rb

@@ -119,7 +119,7 @@ describe 'named filters' do
         having(:comments).offensive_or_not(true)
       end.inspect
       Post.last_find[:conditions].should == [%q(posts__comments.offensive = ?), true] 
-      Post.last_find[:joins].should == %q(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)]
     end
 
     it 'should work correctly with the named filter called within the having block' do
@@ -129,7 +129,7 @@ describe 'named filters' do
         end
       end.inspect
       Post.last_find[:conditions].should == [%q(posts__comments.offensive = ?), false] 
-      Post.last_find[:joins].should == %q(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)]
     end
   end
 
@@ -181,7 +181,7 @@ describe 'named filters' do
       base = @post.for_blog(1)
       base.with_offensive_comments
       base.inspect
-      @post.last_find[:joins].should == %q(INNER JOIN "blogs" AS posts__blog ON "posts".blog_id = posts__blog.id)
+      @post.last_find[:joins].should == [%q(INNER JOIN "blogs" AS posts__blog ON "posts".blog_id = posts__blog.id)]
     end
 
     it 'should not change an original filter when reusing it' do
@@ -250,7 +250,7 @@ describe 'named filters' do
 
     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)]
+      @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), %q(INNER JOIN "comments" AS blogs__posts__comments ON blogs__posts.id = blogs__posts__comments.post_id)]
     end
   end
 

data/spec/restrictions_spec.rb

@@ -61,6 +61,13 @@ describe 'RecordFilter restrictions' do
     Post.last_find.should == { :conditions => [%q{"posts".blog_id NOT IN (?)}, [1, 3, 5]] }
   end
 
+  it 'should work correctly for NOT IN' do
+    Post.filter do
+      with(:blog_id).not_in [1, 3, 5]
+    end.inspect
+    Post.last_find.should == { :conditions => [%q{"posts".blog_id NOT IN (?)}, [1, 3, 5]] }
+  end
+
   it 'should do the right thing for IN filters with empty arrays' do
     Post.filter do
       with(:blog_id).in([])

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: aub-record_filter
 version: !ruby/object:Gem::Version 
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors: 
 - Mat Brown
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-04 00:00:00 -07:00
+date: 2009-05-06 00:00:00 -07:00
 default_executable: 
 dependencies: []