aub-record_filter 0.2.0 → 0.6.0

data/README.rdoc

@@ -0,0 +1,205 @@
+= record_filter
+
+record_filter is a DSL for specifying criteria for ActiveRecord queries in pure Ruby.
+It has support for filters created on the fly and for named filters that are associated with object types.
+record_filter has the following top-level features:
+
+* Pure ruby API eliminates the need for hard-coded SQL in most cases.
+* Works seamlessly with existing ActiveRecord APIs, including named scopes.
+* Supports creation of ad-hoc filters as well as named filters that can be associated with object types.
+* Allows chaining of filters with each other and with named scopes to create complex queries.
+* Takes advantage of the associations in your ActiveRecord objects for a clean implicit join API.
+
+== Installation
+
+gem install outoftime-record_filter --source=http://gems.github.com
+
+== Usage
+
+=== Ad-hoc filters
+
+  Post.filter do
+    with(:permalink, 'blog-post')
+    having(:blog).with(:name, 'Blog')
+  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.
+
+=== Named filters
+
+  class Post < ActiveRecord::Base
+    named_filter(:with_title) do |title|
+      with(:title, title)
+    end
+  end
+
+  Post.with_title('posted')
+
+This is the same as the following code using named scopes, and returns the same result:
+
+  class Post < ActiveRecord::Base
+    named_scope :with_title, lambda { |title| { :conditions => ['title = ?', title] }}
+  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
+
+If a second argument is supplied, it is assumed that you are 
+expressing an equality condition and that argument is used as the value.
+
+  with(:title, 'abc') # :conditions => ['title = ?', 'abc']
+
+Which can be negated with:
+
+  with(:title, 'abc').not # :conditions => ['title <> ?', 'abc']
+
+For the more verbose among us, this can also be specified as:
+
+  with(:title).equal_to('abc') # :conditions => ['title = ?', 'abc']
+
+Other types of restrictions are specified by omitting the second argument to 'with' and chaining it with one of the
+restriction methods.
+
+==== Comparison operators
+
+  with(:price).greater_than(10) # :conditions => ['price > ?', 10]
+
+  with(:created_at).less_than(2.days.ago) # :conditions => ['created_at < ?', 2.days.ago]
+
+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:
+
+  gt, gte, lt and lte
+
+==== IS NULL
+
+  with(:price, nil) # :conditions => ['price IS NULL']
+
+This short form can also be made explicit by using the is_null, null, or nil functions on with:
+
+  with(:price).is_null # :conditions => ['price IS NULL']
+
+It can be negated either by chaining with the 'not' function or by using is_not_null:
+
+  with(:price).is_not_null # :conditions => ['price IS NOT NULL']
+  with(:price).is_null.not # "
+
+==== IN
+
+  with(:id).in([1, 2, 3]) # :conditions => ['id IN (?)', [1, 2, 3]]
+
+==== BETWEEN
+
+  with(:id).between(1, 5) # :conditions => ['id BETWEEN ? AND ?', 1, 5]
+
+The argument to between can also be either a tuple or a range
+
+  with(:created_at).between([Time.now, 3.days.ago]) # :conditions => ['created_at BETWEEN ? AND ?', Time.now, 3.days.ago]
+
+  with(:price).between(1..5) # :conditions => ['price BETWEEN ? AND ?', 1, 5]
+
+==== LIKE
+
+  with(:title).like('%help%') # :conditions => ['title LIKE ?', '%help%']
+
+
+=== Implicit Joins
+
+Implicit joins are specified using the 'having' function, which takes as its argument the name of an association to join on.
+
+  having(:comments) # :joins => :comments
+
+This function can be chained with calls to 'with' in order to specify conditions on the joined table:
+
+  having(:comments).with(:created_at).gt(2.days.ago) # :joins => :comments, :conditions => ['comments.created_at > ?', 2.days.ago]
+
+It can also take a block that can have any number of conditions or other clauses (including other joins) in it:
+
+  having(:comments) do
+    with(:created_at).gt(2.days.ago)
+    having(:author).with(:name, 'Bubba')
+  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.
+
+=== Explicit joins
+
+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.
+
+  Post.filter do
+    join(Comment, :inner, :posts__comments_alias) do
+      on(:id => :commentable_id)
+      on(:commentable_type, 'Post')
+    end
+  end
+
+=== Conjunctions
+
+The following conjunction types are supported:
+
+* any_of
+* all_of
+* none_of
+* not_all_of
+
+Each takes a block that can contain conditions or joins and will apply the expected boolean logic to the combination.
+
+  any_of
+    with(:price, 2)
+    with(:price).gt(100)
+  end
+
+  # :conditions => ['price = ? OR price > ?', 2, 100]
+
+=== Limits and ordering
+
+  limit(20)
+
+  order(:id, :desc)
+
+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)
+
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 Mat Brown
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/VERSION.yml

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

data/lib/record_filter.rb

@@ -7,7 +7,9 @@ require 'active_record'
 end
 
 module RecordFilter
-  class AssociationNotFoundException < StandardError; end
-  class ColumnNotFoundException < StandardError; end
-  class InvalidJoinException < StandardError; end
+  AssociationNotFoundException = Class.new(StandardError)
+  ColumnNotFoundException = Class.new(StandardError)
+  InvalidFilterException = Class.new(StandardError)
+  InvalidJoinException = Class.new(StandardError)
+  NamedFilterNotFoundException = Class.new(StandardError)
 end

data/lib/record_filter/active_record.rb

@@ -1,14 +1,33 @@
 module RecordFilter
+  # The ActiveRecordExtension module is mixed in to ActiveRecord::Base to form the
+  # top-level API for interacting with record_filter. It adds public methods for
+  # executing ad-hoc filters as well as for creating and querying named filters.
   module ActiveRecordExtension
     module ClassMethods
 
+      # Execute an ad-hoc filter  
+      #
+      # ==== Parameters
+      # block::
+      #   A block that specifies the contents of the filter.
+      #
+      # ==== Returns
+      # Filter:: The Filter object resulting from the query, which can be
+      #   treated as an array of the results.
+      #
+      # ==== Example
+      # Blog.filter do
+      #   having(:posts).with(:name, nil)
+      # end
+      #—
+      # @public
       def filter(&block)
         Filter.new(self, nil, &block)
       end
 
       def named_filter(name, &block)
         return if named_filters.include?(name.to_sym)
-        named_filters << name.to_sym 
+        local_named_filters << name.to_sym 
         DSL::DSL::subclass(self).module_eval do
           define_method(name, &block)
         end
@@ -21,10 +40,19 @@ module RecordFilter
       end
 
       def named_filters
-        read_inheritable_attribute(:named_filters) || write_inheritable_attribute(:named_filters, [])
+        result = local_named_filters.dup
+        result.concat(superclass.named_filters) if (superclass && superclass.respond_to?(:named_filters))
+        result
+      end
+
+      protected
+
+      def local_named_filters
+        @local_named_filters ||= []
       end
     end
   end
 end
 
 ActiveRecord::Base.send(:extend, RecordFilter::ActiveRecordExtension::ClassMethods)
+

data/lib/record_filter/conjunctions.rb

@@ -30,6 +30,8 @@ module RecordFilter
             result.add_order(step.column, step.direction)
           when DSL::GroupBy
             result.add_group_by(step.column)
+          when DSL::NamedFilter
+            result.add_named_filter(step.name, step.args)
           end
         end
         result
@@ -81,6 +83,14 @@ module RecordFilter
         @limit, @offset = limit, offset
       end
 
+      def add_named_filter(name, args)
+        unless @table.model_class.named_filters.include?(name.to_sym)
+          raise NamedFilterNotFoundException.new("The named filter #{name} was not found in #{@table.model_class}")
+        end
+        query = Query.new(@table.model_class, name, *args)
+        self << self.class.create_from(query.dsl_conjunction, @table)
+      end
+
       def <<(restriction)
         @restrictions << restriction
       end

data/lib/record_filter/dsl.rb

@@ -1,4 +1,4 @@
-%w(class_join conjunction conjunction_dsl dsl group_by join join_dsl join_condition limit order restriction).each { |file| require File.join(File.dirname(__FILE__), 'dsl', file) }
+%w(class_join conjunction conjunction_dsl dsl group_by join join_dsl join_condition limit named_filter order restriction).each { |file| require File.join(File.dirname(__FILE__), 'dsl', file) }
 
 module RecordFilter
   module DSL

data/lib/record_filter/dsl/conjunction.rb

@@ -44,6 +44,10 @@ module RecordFilter
       def add_group_by(column)
         @steps << GroupBy.new(column)
       end
+
+      def add_named_filter(method, *args)
+        @steps << NamedFilter.new(method, *args)
+      end
     end
   end
 end

data/lib/record_filter/dsl/conjunction_dsl.rb

@@ -53,6 +53,26 @@ module RecordFilter
       def filter_class
         @model_class
       end
+
+      def limit(offset_or_limit, limit=nil)
+        raise InvalidFilterException.new('Calls to limit can only be made in the outer block of a filter.')
+      end
+
+      def order(column, direction=:asc)
+        raise InvalidFilterException.new('Calls to order can only be made in the outer block of a filter.')
+      end
+
+      def group_by(column)
+        raise InvalidFilterException.new('Calls to group_by can only be made in the outer block of a filter.')
+      end
+
+      def on(column, value=Restriction::DEFAULT_VALUE)
+        raise InvalidFilterException.new('Calls to on can only be made in the block of a call to join.')
+      end
+
+      def method_missing(method, *args)
+        @conjunction.add_named_filter(method, *args)
+      end
     end
   end
 end

data/lib/record_filter/dsl/dsl.rb

@@ -12,7 +12,7 @@ module RecordFilter
         end
 
         def subclass(clazz)
-          SUBCLASSES[clazz.name.to_sym]
+          SUBCLASSES[clazz.object_id]
         end
       end
 

data/lib/record_filter/dsl/named_filter.rb

@@ -0,0 +1,12 @@
+module RecordFilter
+  module DSL
+    class NamedFilter
+
+      attr_reader :name, :args
+
+      def initialize(name, *args)
+        @name, @args = name, args
+      end
+    end
+  end
+end

data/lib/record_filter/dsl/restriction.rb

@@ -35,6 +35,11 @@ module RecordFilter
         end
       end
 
+      def is_not_null
+        @operator = :is_null
+        @negated = true
+      end
+
       alias_method :gt, :greater_than
       alias_method :gte, :greater_than_or_equal_to
       alias_method :lt, :less_than

data/lib/record_filter/filter.rb

@@ -12,10 +12,7 @@ module RecordFilter
       @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)
-      @query = Query.new(@clazz, @dsl.conjunction)
+      @query = Query.new(@clazz, named_filter, *args, &block)
     end
 
     def first(*args)
@@ -90,16 +87,6 @@ module RecordFilter
       end
     end
 
-    def dsl_for_named_filter(clazz, named_filter)
-      return DSL::DSL.create(clazz) if named_filter.blank?
-      while (clazz)
-        dsl = DSL::DSL::SUBCLASSES.has_key?(clazz.name.to_sym) ? DSL::DSL::SUBCLASSES[clazz.name.to_sym] : nil
-        return DSL::DSL.create(clazz) if dsl && dsl.instance_methods(false).include?(named_filter.to_s)
-        clazz = clazz.superclass
-      end
-      nil
-    end
-
     def loaded_data
       @loaded_data ||= do_with_scope do
         @clazz.find(:all)

data/lib/record_filter/join.rb

@@ -22,7 +22,7 @@ module RecordFilter
     end
 
     def requires_distinct_select?
-      [:left, :outer, :left_outer].include?(@join_type)
+      [:right, :left].include?(@join_type)
     end
 
     protected
@@ -55,9 +55,8 @@ module RecordFilter
     def join_type_string
       @join_type_string ||= case(@join_type)
         when :inner then 'INNER'
-        when :left then 'LEFT'
-        when :left_outer then 'LEFT OUTER'
-        when :outer then 'OUTER'
+        when :left then 'LEFT OUTER'
+        when :right then 'RIGHT OUTER'
         else nil
       end
     end

data/lib/record_filter/query.rb

@@ -1,31 +1,54 @@
 module RecordFilter
   class Query
 
-    def initialize(clazz, dsl_conjunction)
+    attr_reader :dsl_conjunction
+    attr_reader :conjunction
+
+    def initialize(clazz, named_filter, *args, &block)
+      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)
+
       @table = RecordFilter::Table.new(clazz)
-      @conjunction = RecordFilter::Conjunctions::Base.create_from(dsl_conjunction, @table)
+      @dsl_conjunction = dsl.conjunction
+      @conjunction = RecordFilter::Conjunctions::Base.create_from(@dsl_conjunction, @table)
     end
 
     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}.*"
+      @params_cache ||= {}
+      @params_cache[count_query] ||= begin
+        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
+        params[:group] = group_bys.map { |group_by| group_by.to_sql } * ', ' unless group_bys.empty?
+        params[:limit] = @conjunction.limit if @conjunction.limit
+        params[:offset] = @conjunction.offset if @conjunction.offset
+        params
+      end
+    end
+
+    protected
+
+    def dsl_for_named_filter(clazz, named_filter)
+      return DSL::DSL.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)
+        clazz = clazz.superclass
       end
-      orders = @table.orders
-      params[:order] = orders.map { |order| order.to_sql } * ', ' unless orders.empty?
-      group_bys = @table.group_bys
-      params[:group] = group_bys.map { |group_by| group_by.to_sql } * ', ' unless group_bys.empty?
-      params[:limit] = @conjunction.limit if @conjunction.limit
-      params[:offset] = @conjunction.offset if @conjunction.offset
-      params
+      nil
     end
   end
 end

data/lib/record_filter/restrictions.rb

@@ -75,6 +75,11 @@ module RecordFilter
       def to_negative_sql
         "#{@column_name} NOT IN (?)"
       end
+
+      def to_conditions
+        # Need to put in the value even if it's null in this case.
+        [to_sql, @value]
+      end
     end
 
     class Between < Base

data/spec/exception_spec.rb

@@ -102,4 +102,66 @@ describe 'raising exceptions' do
       }.should raise_error(RecordFilter::InvalidJoinException)
     end
   end
+
+  describe 'limiting methods within joins and conjunctions' do
+    it 'should not allow calls to limit within joins' do
+      lambda {
+        Post.filter do
+          having(:photo) do
+            limit 2
+          end
+        end
+      }.should raise_error(RecordFilter::InvalidFilterException)
+    end
+
+    it 'should not allow calls to order within joins' do
+      lambda {
+        Post.filter do
+          having(:photo) do
+            order :id
+          end
+        end
+      }.should raise_error(RecordFilter::InvalidFilterException)
+    end
+
+    it 'should not allow calls to limit within conjunctions' do
+      lambda {
+        Post.filter do
+          all_of do
+            limit 2
+          end
+        end
+      }.should raise_error(RecordFilter::InvalidFilterException)
+    end
+
+    it 'should not allow calls to order within joins' do
+      lambda {
+        Post.filter do
+          all_of do
+            order :id
+          end
+        end
+      }.should raise_error(RecordFilter::InvalidFilterException)
+    end
+  end
+
+  describe 'limiting calls to on' do
+    it 'should not allow calls to on in the outer scope' do
+      lambda  {
+        Post.filter do
+          on(:a => :b)
+        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 {
+        Post.filter do
+          having(:comments).does_not_exist
+        end
+      }.should raise_error(RecordFilter::NamedFilterNotFoundException)
+    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 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 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 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 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
 
@@ -100,7 +100,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 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 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'))
     end
   end
 end

data/spec/implicit_join_spec.rb

@@ -224,7 +224,7 @@ describe 'implicit joins' do
   describe 'passing the join type to having' do
     before do
       Blog.filter do
-        having(:left_outer, :posts) do
+        having(:left, :posts) do
           with(:permalink, 'ack')
         end
       end.inspect
@@ -242,7 +242,7 @@ describe 'implicit joins' do
   describe 'passing the join type to having with multiple joins' do
     before do
       Blog.filter do
-        having(:left_outer, :posts => :comments) do
+        having(:left, :posts => :comments) do
           with(:offensive, true)
         end
       end.inspect

data/spec/limits_and_ordering_spec.rb

@@ -118,48 +118,6 @@ describe 'filter qualifiers' do
         Post.last_find[:order].should == %q(posts__photo.path DESC, "posts".permalink ASC)
       end
     end
-
-    describe 'limiting methods within joins and conjunctions' do
-      it 'should not allow calls to limit within joins' do
-        lambda {
-          Post.filter do
-            having(:photo) do
-              limit 2
-            end
-          end
-        }.should raise_error(NoMethodError)
-      end
-
-      it 'should not allow calls to order within joins' do
-        lambda {
-          Post.filter do
-            having(:photo) do
-              order :id
-            end
-          end
-        }.should raise_error(NoMethodError)
-      end
-
-      it 'should not allow calls to limit within conjunctions' do
-        lambda {
-          Post.filter do
-            all_of do
-              limit 2
-            end
-          end
-        }.should raise_error(NoMethodError)
-      end
-
-      it 'should not allow calls to order within joins' do
-        lambda {
-          Post.filter do
-            all_of do
-              order :id
-            end
-          end
-        }.should raise_error(NoMethodError)
-      end
-    end
   end
 
   describe 'group_by' do

data/spec/named_filter_spec.rb

@@ -7,40 +7,43 @@ describe 'named filters' do
 
   describe 'defining a simple filter' do
     before do
-      Blog.named_filter(:with_test_name) do
+      @blog = Class.new(Blog)
+      @blog.named_filter(:with_test_name) do
         with :name, 'Test Name'
       end
     end
 
     it 'should call the filter through the filter method' do
-      Blog.with_test_name.inspect
-      Blog.last_find[:conditions].should == [%q("blogs".name = ?), 'Test Name']
+      @blog.with_test_name.inspect
+      @blog.last_find[:conditions].should == [%q("blogs".name = ?), 'Test Name']
     end
 
     it 'should call the filter within the block' do
-      Blog.filter do
+      @blog.filter do
         with_test_name
       end.inspect
-      Blog.last_find[:conditions].should == [%q("blogs".name = ?), 'Test Name']
+      @blog.last_find[:conditions].should == [%q("blogs".name = ?), 'Test Name']
     end
   end
 
   describe 'defining a filter with arguments' do
     before do
-      Blog.named_filter(:with_name) do |name|
+      @blog = Class.new(Blog)
+      @blog.named_filter(:with_name) do |name|
         with :name, name
       end
     end
 
     it 'should call the filter with the passed argument' do
-      Blog.with_name('nice name').inspect
-      Blog.last_find[:conditions].should == [%q("blogs".name = ?), 'nice name']
+      @blog.with_name('nice name').inspect
+      @blog.last_find[:conditions].should == [%q("blogs".name = ?), 'nice name']
     end
   end
 
   describe 'defining a filter that passes arguments down several levels' do
     before do
-      Blog.named_filter(:with_name_and_post_with_permalink) do |name, permalink|
+      @blog = Class.new(Blog)
+      @blog.named_filter(:with_name_and_post_with_permalink) do |name, permalink|
         with :name, name
         having :posts do
           with :permalink, permalink
@@ -49,29 +52,31 @@ describe 'named filters' do
     end
 
     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 == 
+      @blog.with_name_and_post_with_permalink('booya', 'ftw').inspect
+      @blog.last_find[:conditions].should == 
         [%q(("blogs".name = ?) AND (blogs__posts.permalink = ?)), 'booya', 'ftw'] 
     end
   end
 
   describe 'taking active_record objects as arguments' do
     it 'should use the id of the object as the actual parameter' do
-      Post.named_filter(:with_ar_arg) do |blog|
+      post = Class.new(Post)
+      post.named_filter(:with_ar_arg) do |blog|
         with(:blog_id, blog)
       end
       blog = Blog.create
-      Post.with_ar_arg(blog).inspect
-      Post.last_find[:conditions].should == [%q("posts".blog_id = ?), blog.id]
+      post.with_ar_arg(blog).inspect
+      post.last_find[:conditions].should == [%q("posts".blog_id = ?), blog.id]
     end
   end
 
   describe 'using filters in subclasses' do
     before do
-      Comment.named_filter(:with_contents) do |*args|
+      @comment = Class.new(Comment)
+      @comment.named_filter(:with_contents) do |*args|
         with :contents, args[0]
       end
-      class NiceComment < Comment
+      @nice_comment = Class.new(@comment) do
         extend TestModel
 
         named_filter(:offensive) do
@@ -81,95 +86,110 @@ describe 'named filters' do
     end
 
     it 'should execute the parent class filters correctly' do
-      NiceComment.with_contents('test contents').inspect
-      NiceComment.last_find[:conditions].should == 
+      @nice_comment.with_contents('test contents').inspect
+      @nice_comment.last_find[:conditions].should == 
         [%q("comments".contents = ?), 'test contents']
     end
 
     it 'should not have the subclass filters in the parent class' do
-      Comment.respond_to?(:offensive).should == false
+      @comment.respond_to?(:offensive).should == false
     end
 
     it 'should have parent class filters in the subclass' do
-      NiceComment.offensive.with_contents('something').inspect
-      NiceComment.last_find[:conditions].should == 
+      @nice_comment.offensive.with_contents('something').inspect
+      @nice_comment.last_find[:conditions].should == 
         %q(("comments".contents = 'something') AND ("comments".offensive = 't'))
     end
 
     it 'should provide access to the named filters' do
-      Comment.named_filters.should == [:with_contents]
-      NiceComment.named_filters.sort_by { |i| i.to_s }.should == [:offensive, :with_contents]
+      @comment.named_filters.should == [:with_contents]
+      @nice_comment.named_filters.sort_by { |i| i.to_s }.should == [:offensive, :with_contents]
     end
   end
 
   describe 'using compound filters' do
-    it 'should concatenate the filters correctly' do
-      pending 'nested chaining'
-      Post.named_filter(:with_offensive_comments) do
-        having(:comments).offensive(true)
+    before do
+      Comment.named_filter(:offensive_or_not) do |state|
+        with(:offensive, state)
       end
-      Post.with_offensive_comments.inspect
+    end
+
+    it 'should concatenate the filters correctly' do
+      Post.filter 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 "comments".post_id = posts__blog.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
+      Post.filter do
+        having(:comments) do
+          offensive_or_not(false)
+        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)
     end
   end
 
   describe 'chaining filters' do
     before do
-      Post.named_filter(:for_blog) do |*args|
+      @post = Class.new(Post)
+      @post.named_filter(:for_blog) do |*args|
         having(:blog).with :id, args[0]
       end
-      Post.named_filter(:with_offensive_comments) do
+      @post.named_filter(:with_offensive_comments) do
         having(:comments).with :offensive, true
       end
-      Post.named_filter(:with_interesting_comments) do
+      @post.named_filter(:with_interesting_comments) do
         having(:comments).with :offensive, false
       end
     end
 
     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__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)]
+      @post.for_blog(1).with_offensive_comments.inspect
+      @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 "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)]
+      @post.for_blog(1).with_offensive_comments.with_interesting_comments.inspect
+      @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__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)] 
+      @post.for_blog(1).filter { having(:comments).with :offensive, true }.inspect
+      @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__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)]
+      @post.filter { having(:comments).with :offensive, false }.for_blog(1).inspect
+      @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
-      base = Post.for_blog(1)
+      base = @post.for_blog(1)
       base.with_offensive_comments
       base.inspect
-      Post.last_find[:conditions].should == [%q(posts__blog.id = ?), 1]
+      @post.last_find[:conditions].should == [%q(posts__blog.id = ?), 1]
     end
 
     it 'should not change the inner filter joins when chaining filters' do
-      base = Post.for_blog(1)
+      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
-      base = Post.for_blog(1)
+      base = @post.for_blog(1)
       level1 = base.with_offensive_comments.inspect
       level2 = base.with_interesting_comments
-      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)]
+      @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
 
@@ -220,20 +240,22 @@ describe 'named filters' do
 
   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) }
+      @blog = Class.new(Blog)
+      @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)]
+      @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) }
+      blog = Class.new(Blog)
+      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/restrictions_spec.rb

@@ -42,6 +42,20 @@ describe 'RecordFilter restrictions' do
     Post.last_find.should == { :conditions => [%q{"posts".blog_id 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([])
+    end.inspect
+    Post.last_find.should == { :conditions => [%q("posts".blog_id IN (?)), []] }
+  end
+
+  it 'should do the right thing for IN filters with nil' do
+    Post.filter do
+      with(:blog_id).in(nil)
+    end.inspect
+    Post.last_find.should == { :conditions => [%q("posts".blog_id IN (?)), nil] }
+  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')
@@ -119,6 +133,13 @@ describe 'RecordFilter restrictions' do
     end
   end
 
+  it 'should filter for is_not_null' do
+    Post.filter do
+      with(:permalink).is_not_null
+    end.inspect
+    Post.last_find.should == { :conditions => [%q("posts".permalink IS NOT NULL)] }
+  end
+
   it 'should support like' do
     Post.filter do
       with(:permalink).like('%piglets%')

data/spec/select_spec.rb

@@ -16,10 +16,10 @@ describe 'with custom selects for cases where DISTINCT is required' do
 
   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|
+      [:left, :right].each do |join_type|
         Post.filter do
           having(join_type, :comments).with(:offensive, true)
-        end.inspect
+        end.inspect rescue nil # required because sqlite doesn't support right joins
         Post.last_find[:select].should == %q(DISTINCT "posts".*)
       end
     end
@@ -40,7 +40,7 @@ describe 'with custom selects for cases where DISTINCT is required' do
     it 'should put the distinct clause in the select' do
       Blog.filter do
         having(:posts) do
-          having(:left_outer, :comments).with(:offensive, true)
+          having(:left, :comments).with(:offensive, true)
         end
       end.inspect
       Blog.last_find[:select].should == %q(DISTINCT "blogs".*)
@@ -50,7 +50,7 @@ describe 'with custom selects for cases where DISTINCT is required' do
   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)
+        having(:left, :comments).with(:offensive, true)
       end.count
       Post.last_find[:select].should == %q(DISTINCT "posts".id)
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: aub-record_filter
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.6.0
 platform: ruby
 authors: 
 - Mat Brown
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-27 00:00:00 -07:00
+date: 2009-05-01 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -20,9 +20,10 @@ executables: []
 
 extensions: []
 
-extra_rdoc_files: []
-
+extra_rdoc_files: 
+- README.rdoc
 files: 
+- README.rdoc
 - Rakefile
 - VERSION.yml
 - lib/record_filter.rb
@@ -38,6 +39,7 @@ files:
 - lib/record_filter/dsl/join_condition.rb
 - lib/record_filter/dsl/join_dsl.rb
 - lib/record_filter/dsl/limit.rb
+- lib/record_filter/dsl/named_filter.rb
 - lib/record_filter/dsl/order.rb
 - lib/record_filter/dsl/restriction.rb
 - lib/record_filter/filter.rb