aub-record_filter 0.1.2 → 0.1.4

data/VERSION.yml

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

data/lib/record_filter.rb

@@ -7,6 +7,7 @@ require 'active_record'
 end
 
 module RecordFilter
-  class AssociationNotFoundException < Exception; end
-  class ColumnNotFoundException < Exception; end
+  class AssociationNotFoundException < StandardError; end
+  class ColumnNotFoundException < StandardError; end
+  class InvalidJoinException < StandardError; end
 end

data/lib/record_filter/active_record.rb

@@ -7,6 +7,8 @@ module RecordFilter
       end
 
       def named_filter(name, &block)
+        return if named_filters.include?(name.to_sym)
+        named_filters << name.to_sym 
         DSL::DSL::subclass(self).module_eval do
           define_method(name, &block)
         end
@@ -17,6 +19,10 @@ module RecordFilter
           end
         end
       end
+
+      def named_filters
+        read_inheritable_attribute(:named_filters) || write_inheritable_attribute(:named_filters, [])
+      end
     end
   end
 end

data/lib/record_filter/conjunctions.rb

@@ -7,6 +7,8 @@ module RecordFilter
         result = case dsl_conjunction.type
           when :any_of then AnyOf.new(table)
           when :all_of then AllOf.new(table)
+          when :none_of then NoneOf.new(table)
+          when :not_all_of then NotAllOf.new(table)
         end
 
         dsl_conjunction.steps.each do |step|
@@ -18,6 +20,10 @@ module RecordFilter
           when DSL::Join
             join = result.add_join_on_association(step.association)
             result.add_conjunction(create_from(step.conjunction, join.right_table))
+          when DSL::ClassJoin
+            join = result.add_join_on_class(
+              step.join_class, step.join_type, step.table_alias, step.conditions)
+            result.add_conjunction(create_from(step.conjunction, join.right_table))
           when DSL::Limit
             result.add_limit_and_offset(step.limit, step.offset)
           when DSL::Order
@@ -38,7 +44,7 @@ module RecordFilter
 
       def add_restriction(column_name, operator, value, options={})
         check_column_exists!(column_name)
-        restriction_class = "RecordFilter::Restrictions::#{operator.to_s.camelize}".constantize
+        restriction_class = RecordFilter::Restrictions::Base.class_from_operator(operator)
         restriction = restriction_class.new("#{@table_name}.#{column_name}", value, options)
         self << restriction
         restriction
@@ -50,9 +56,19 @@ module RecordFilter
       end
 
       def add_join_on_association(association_name)
-        @table.join_association(association_name)
+        table = @table
+        while association_name.is_a?(Hash)
+          result = table.join_association(association_name.keys[0])
+          table = result.right_table
+          association_name = association_name.values[0]
+        end
+        table.join_association(association_name)
       end
       
+      def add_join_on_class(join_class, join_type, table_alias, conditions)
+        @table.join_class(join_class, join_type, table_alias, conditions)
+      end
+
       def add_order(column_name, direction)
         @table.order_column(column_name, direction)
       end
@@ -70,21 +86,25 @@ module RecordFilter
       end
 
       def to_conditions
-        if @restrictions.empty?
-          nil
-        elsif @restrictions.length == 1
-          @restrictions.first.to_conditions
-        else
-          @restrictions.map do |restriction|
-            conditions = restriction.to_conditions
-            conditions[0] = "(#{conditions[0]})"
-            conditions
-          end.inject do |conditions, new_conditions|
-            conditions.first << " #{conjunctor} #{new_conditions.shift}"
-            conditions.concat(new_conditions)
-            conditions
+        result = begin
+          if @restrictions.empty?
+            nil
+          elsif @restrictions.length == 1
+            @restrictions.first.to_conditions
+          else
+            @restrictions.map do |restriction|
+              conditions = restriction.to_conditions
+              conditions[0] = "(#{conditions[0]})"
+              conditions
+            end.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
       end
 
       protected
@@ -97,15 +117,23 @@ module RecordFilter
     end
 
     class AnyOf < Base
-      def conjunctor
-        'OR'
-      end
+      def conjunctor; 'OR'; end
+      def negated; false; end
     end
 
     class AllOf < Base
-      def conjunctor
-        'AND'
-      end
+      def conjunctor; 'AND'; end
+      def negated; false; end
+    end
+
+    class NoneOf < Base
+      def conjunctor; 'OR'; end
+      def negated; true; end
+    end
+
+    class NotAllOf < Base
+      def conjunctor; 'AND'; end
+      def negated; true; end
     end
   end
 end

data/lib/record_filter/dsl.rb

@@ -1,4 +1,4 @@
-%w(conjunction conjunction_dsl dsl group_by join 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 order restriction).each { |file| require File.join(File.dirname(__FILE__), 'dsl', file) }
 
 module RecordFilter
   module DSL

data/lib/record_filter/dsl/class_join.rb

@@ -0,0 +1,16 @@
+module RecordFilter
+  module DSL
+    class ClassJoin
+      attr_reader :join_class, :join_type, :table_alias, :conjunction
+
+      def initialize(join_class, join_type, table_alias, conjunction, join_conditions)
+        @join_class, @join_type, @table_alias, @conjunction, @join_conditions = 
+          join_class, join_type, table_alias, conjunction, join_conditions
+      end
+
+      def conditions
+        @join_conditions ? @join_conditions.map { |c| c.condition } : nil
+      end
+    end
+  end
+end

data/lib/record_filter/dsl/conjunction.rb

@@ -4,35 +4,33 @@ module RecordFilter
 
       attr_reader :type, :steps
 
-      DEFAULT_VALUE = Object.new
-
-      def initialize(type=:all_of)
-        @type, @steps = type, []
+      def initialize(model_class, type=:all_of)
+        @model_class, @type, @steps = model_class, type, []
       end
 
-      def add_restriction(column, value, negated)
-        @steps << (restriction = Restriction.new(column, negated))
-        if value == DEFAULT_VALUE
-          return restriction
-        elsif value.nil?
-          restriction.is_null
-        else
-          restriction.equal_to(value)
-        end
-        nil
+      def add_restriction(column, value)
+        @steps << (restriction = Restriction.new(column, value))
+        restriction 
       end
 
       def add_conjunction(type, &block)
-        dsl = ConjunctionDSL.new(Conjunction.new(type))
+        dsl = ConjunctionDSL.new(@model_class, Conjunction.new(@model_class, type))
         dsl.instance_eval(&block) if block
         @steps << dsl.conjunction
       end
 
       def add_join(association, &block)
-        dsl = ConjunctionDSL.new
+        dsl = ConjunctionDSL.new(@model_class, Conjunction.new(@model_class, :all_of))
+        dsl.instance_eval(&block) if block
+        @steps << Join.new(association, dsl.conjunction)
+        dsl
+      end
+
+      def add_class_join(clazz, join_type, table_alias, &block)
+        dsl = JoinDSL.new(@model_class, Conjunction.new(@model_class, :all_of))
         dsl.instance_eval(&block) if block
-        @steps << (join = Join.new(association, dsl.conjunction))
-        join
+        @steps << ClassJoin.new(clazz, join_type, table_alias, dsl.conjunction, dsl.conditions)
+        dsl
       end
 
       def add_limit(limit, offset)

data/lib/record_filter/dsl/conjunction_dsl.rb

@@ -4,18 +4,14 @@ module RecordFilter
 
       attr_reader :conjunction
 
-      def initialize(conjunction=Conjunction.new(:all_of))
+      def initialize(model_class, conjunction)
+        @model_class = model_class
         @conjunction = conjunction
       end
 
       # restriction
-      def with(column, value=Conjunction::DEFAULT_VALUE)
-        return @conjunction.add_restriction(column, value, false) # using return just to make it explicit
-      end
-
-      # restriction
-      def without(column, value=Conjunction::DEFAULT_VALUE)
-        return @conjunction.add_restriction(column, value, true) # using return just to make it explicit
+      def with(column, value=Restriction::DEFAULT_VALUE)
+        return @conjunction.add_restriction(column, value)
       end
 
       # conjunction
@@ -30,10 +26,27 @@ module RecordFilter
         nil
       end
 
+      def none_of(&block)
+        @conjunction.add_conjunction(:none_of, &block)
+        nil
+      end
+
+      def not_all_of(&block)
+        @conjunction.add_conjunction(:not_all_of, &block)
+        nil
+      end
+
       # join
       def having(association, &block)
-        join = @conjunction.add_join(association, &block)
-        ConjunctionDSL.new(join.conjunction)
+        @conjunction.add_join(association, &block)
+      end
+
+      def join(clazz, join_type, table_alias=nil, &block)
+        @conjunction.add_class_join(clazz, join_type, table_alias, &block)
+      end
+
+      def filter_class
+        @model_class
       end
     end
   end

data/lib/record_filter/dsl/dsl.rb

@@ -8,7 +8,7 @@ module RecordFilter
 
       class << self
         def create(clazz)
-          subclass(clazz).new
+          subclass(clazz).new(clazz, Conjunction.new(clazz, :all_of))
         end
 
         def subclass(clazz)

data/lib/record_filter/dsl/join_condition.rb

@@ -0,0 +1,21 @@
+module RecordFilter
+  module DSL
+    class JoinCondition
+
+      attr_reader :restriction
+
+      def initialize(column, value)
+        @column = column
+        if column.is_a?(Hash) && value == Restriction::DEFAULT_VALUE
+          @condition = column
+        else
+          @restriction = Restriction.new(column, value)
+        end
+      end
+
+      def condition
+        @condition || restriction
+      end
+    end
+  end
+end

data/lib/record_filter/dsl/join_dsl.rb

@@ -0,0 +1,14 @@
+module RecordFilter
+  module DSL
+    class JoinDSL < ConjunctionDSL
+
+      attr_reader :conditions
+
+      def on(column, value=Restriction::DEFAULT_VALUE)
+        @conditions ||= []
+        @conditions << (condition = JoinCondition.new(column, value))
+        return condition.restriction
+      end
+    end
+  end
+end

data/lib/record_filter/dsl/restriction.rb

@@ -4,11 +4,20 @@ module RecordFilter
 
       attr_reader :column, :negated, :operator, :value
 
-      def initialize(column, negated)
-        @column, @negated, @operator = column, negated, nil
+      DEFAULT_VALUE = Object.new
+
+      def initialize(column, value=DEFAULT_VALUE)
+        @column, @negated, @operator = column, false, nil
+        take_value(value)
+      end
+
+      def not(value=DEFAULT_VALUE)
+        @negated = true
+        take_value(value)
+        self
       end
 
-      [:equal_to, :is_null, :less_than, :less_than_or_equal_to, :greater_than, :greater_than_or_equal_to, :in, :between].each do |operator|
+      [:equal_to, :is_null, :less_than, :less_than_or_equal_to, :greater_than, :greater_than_or_equal_to, :in, :like].each do |operator|
         define_method(operator) do |*args|
           @value = args[0] 
           @operator = operator
@@ -16,12 +25,32 @@ module RecordFilter
         end
       end
 
+      # Between can take either a tuple of [start, finish], a range, or two values.
+      def between(start, finish=nil)
+        @operator = :between
+        if !finish.nil?
+          @value = [start, finish]
+        else
+          @value = start
+        end
+      end
+
       alias_method :gt, :greater_than
       alias_method :gte, :greater_than_or_equal_to
       alias_method :lt, :less_than
       alias_method :lte, :less_than_or_equal_to
       alias_method :null, :is_null
       alias_method :nil, :is_null
+
+      protected
+
+      def take_value(value)
+        if value.nil?
+          is_null
+        elsif value != DEFAULT_VALUE
+          equal_to(value)
+        end
+      end
     end
   end
 end

data/lib/record_filter/filter.rb

@@ -17,7 +17,7 @@ module RecordFilter
     end
 
     def method_missing(method, *args, &block)
-      if @clazz.respond_to?(method) # UGLY, we need to only pass through things that are named filters.
+      if @clazz.named_filters.include?(method)
         Filter.new(@clazz, method, @dsl.conjunction, *args)
       else
         loaded_data.send(method, *args, &block)

data/lib/record_filter/join.rb

@@ -2,16 +2,57 @@ module RecordFilter
   class Join
     attr_reader :left_table, :right_table
 
-    def initialize(left_table, right_table, join_predicate)
-      @left_table, @right_table, @join_predicate =
-        left_table, right_table, join_predicate
+    def initialize(left_table, right_table, join_conditions, join_type=:inner)
+      @left_table, @right_table, @join_conditions, @join_type =
+        left_table, right_table, join_conditions, join_type
     end
 
     def to_sql
-      predicate_sql = @join_predicate.map do |left_column, right_column|
-        "#{@left_table.table_alias}.#{left_column} = #{@right_table.table_alias}.#{right_column}"
+      if @join_conditions.blank?
+        raise InvalidJoinException.new("Conditions must be provided for explicit joins using the 'on' method");
+      end
+      if join_type_string.nil?
+        raise ArgumentError.new("The provided join type '#{@join_type}' is invalid.")
+      end
+      predicate_sql = @join_conditions.map do |condition|
+        condition_to_predicate_part(condition)
       end * ' AND '
-      "INNER JOIN #{@right_table.table_name} AS #{@right_table.table_alias} ON #{predicate_sql}"
+      "#{join_type_string} JOIN #{@right_table.table_name} AS #{@right_table.table_alias} ON #{predicate_sql}"
+    end
+
+    protected
+
+    def condition_to_predicate_part(condition)
+      if condition.is_a?(Hash)
+        "#{column_join_alias(@left_table, condition.keys[0])} = #{column_join_alias(@right_table, condition.values[0])}"
+      elsif condition.is_a?(RecordFilter::DSL::Restriction)
+        restriction_join_alias(condition)
+      end
+    end
+
+    def column_join_alias(table, column)
+      unless table.has_column(column)
+        raise ColumnNotFoundException.new("The column #{column} was not found in the table #{table.table_name}")
+      end
+      "#{table.table_alias}.#{column}"
+    end
+
+    def restriction_join_alias(dsl_restriction)
+      unless @right_table.has_column(dsl_restriction.column)
+        raise ColumnNotFoundException.new("The column #{dsl_restriction.column} was not found in the table #{@right_table.table_name}")
+      end
+      restriction_class = RecordFilter::Restrictions::Base.class_from_operator(dsl_restriction.operator)
+      restriction = restriction_class.new(
+        "#{@right_table.table_alias}.#{dsl_restriction.column}", dsl_restriction.value, :negated => dsl_restriction.negated)
+      @right_table.model_class.merge_conditions(restriction.to_conditions)
+    end
+
+    def join_type_string
+      @join_type_string ||= case(@join_type)
+        when :inner then 'INNER'
+        when :left then 'LEFT'
+        else nil
+      end
     end
   end
 end

data/lib/record_filter/restrictions.rb

@@ -3,6 +3,7 @@ module RecordFilter
     class Base
       def initialize(column_name, value, options={})
         @column_name, @value, @negated = column_name, value, !!options.delete(:negated)
+        @value = @value.id if @value.kind_of?(ActiveRecord::Base)
       end
 
       def to_conditions
@@ -16,6 +17,10 @@ module RecordFilter
       def to_negative_sql
         "!(#{to_positive_sql})"
       end
+
+      def self.class_from_operator(operator)
+        "RecordFilter::Restrictions::#{operator.to_s.camelize}".constantize
+      end
     end
 
     class EqualTo < Base
@@ -77,5 +82,15 @@ module RecordFilter
         ["#{@column_name} #{'NOT ' if @negated}BETWEEN ? AND ?", @value.first, @value.last]
       end
     end
+
+    class Like < Base
+      def to_positive_sql
+        "#{@column_name} LIKE ?"
+      end
+
+      def to_negative_sql
+        "#{@column_name} NOT LIKE ?"
+      end
+    end
   end
 end

data/lib/record_filter/table.rb

@@ -1,6 +1,6 @@
 module RecordFilter
   class Table
-    attr_reader :table_alias, :orders, :group_bys
+    attr_reader :table_alias, :orders, :group_bys, :model_class
 
     def initialize(model_class, table_alias = nil)
       @model_class = model_class
@@ -32,6 +32,15 @@ module RecordFilter
         end
     end
 
+    def join_class(clazz, join_type, table_alias, conditions)
+      @joins_cache[clazz] ||= 
+        begin
+          join_table = Table.new(clazz, table_alias || alias_for_class(clazz))
+          @joins << (join = Join.new(self, join_table, conditions, join_type))
+          join
+        end
+    end
+
     def all_joins
       @joins + @joins.inject([]) do |child_joins, join|
         child_joins.concat(join.right_table.all_joins)
@@ -57,9 +66,9 @@ module RecordFilter
       join_predicate =
         case association.macro
         when :belongs_to
-          { association.primary_key_name.to_sym => :id }
+          [{ association.primary_key_name.to_sym => :id }]
         when :has_many, :has_one
-          { :id => association.primary_key_name.to_sym }
+          [{ :id => association.primary_key_name.to_sym }]
         end
       join_table = Table.new(association.klass, alias_for_association(association))
       @joins << join = Join.new(self, join_table, join_predicate)
@@ -67,11 +76,11 @@ module RecordFilter
     end
 
     def compound_join(association)
-      pivot_join_predicate = { :id => association.primary_key_name.to_sym }
+      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, "__#{alias_for_association(association)}")
+      pivot_table = PivotTable.new(table_name, association, "__#{alias_for_association(association)}")
       pivot_join = Join.new(self, pivot_table, pivot_join_predicate)
-      join_predicate = { association.association_foreign_key => :id }
+      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)
       @joins << pivot_join
@@ -83,17 +92,25 @@ module RecordFilter
     def alias_for_association(association)
       "#{@aliased ? @table_alias.to_s : @model_class.table_name}__#{association.name}"
     end
+
+    alias_method :alias_for_class, :alias_for_association
   end
 
   class PivotTable < Table
     attr_reader :table_name, :joins
 
-    def initialize(table_name, table_alias = table_name)
+    def initialize(table_name, association, table_alias = table_name)
       @table_name, @table_alias = table_name, table_alias
       @joins_cache = {}
       @joins = []
       @orders = []
       @group_bys = []
+      @primary_key = association.primary_key_name.to_sym
+      @foreign_key = association.association_foreign_key.to_sym
+    end
+
+    def has_column(column_name)
+      [@primary_key, @foreign_key].include?(column_name.to_sym)
     end
   end
 end

data/spec/exception_spec.rb

@@ -23,10 +23,10 @@ describe 'raising exceptions' do
       }.should raise_error(RecordFilter::ColumnNotFoundException)
     end
 
-    it 'should get ColumnNotFoundException for without' do
+    it 'should get ColumnNotFoundException for with.not' do
       lambda {
         Post.filter do
-          without(:this_is_not_there, 2)
+          with(:this_is_not_there).not.equal_to(2)
         end.inspect
       }.should raise_error(RecordFilter::ColumnNotFoundException)
     end
@@ -46,5 +46,57 @@ describe 'raising exceptions' do
         end.inspect
       }.should raise_error(RecordFilter::AssociationNotFoundException)
     end
+
+    it 'should raise ColumnNotFoundException for explicit joins on bad column names for the right table' do
+      lambda {
+        Review.filter do
+          join(Feature, :left) do
+            on(:reviewable_id => :ftrable_id)
+            on(:reviewable_type => :ftrable_type)
+            with(:priority, 5)
+          end
+        end.inspect
+      }.should raise_error(RecordFilter::ColumnNotFoundException)
+    end
+
+    it 'should raise ColumnNotFoundException for explicit joins on bad column names for the left table' do
+      lambda {
+        Review.filter do
+          join(Feature, :inner) do
+            on(:rvwable_id => :featurable_id)
+            on(:rvwable_type => :featurable_type)
+            with(:priority, 5)
+          end
+        end.inspect
+      }.should raise_error(RecordFilter::ColumnNotFoundException)
+    end
+
+    it 'should raise ColumnNotFoundException for explicit joins on bad column names in conditions' do
+      lambda {
+        Review.filter do
+          join(Feature, :inner) do
+            on(:reviewable_id).gt(12)
+          end
+        end.inspect
+      }.should raise_error(RecordFilter::ColumnNotFoundException)
+    end
+
+    it 'should raise an ArgumentError if an invalid join type is specified' do
+      lambda {
+        Review.filter do
+          join(Feature, :crazy) do
+            on(:reviewable_type => :featurable_type)
+          end
+        end.inspect
+      }.should raise_error(ArgumentError)
+    end
+
+    it 'should raise an InvalidJoinException if no columns are specified for the join' do
+      lambda {
+        Review.filter do
+          join(Feature, :inner)
+        end.inspect
+      }.should raise_error(RecordFilter::InvalidJoinException)
+    end
   end
 end

data/spec/explicit_join_spec.rb

@@ -0,0 +1,79 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe 'explicit joins' do
+  before do
+    TestModel.extended_models.each { |model| model.last_find = {} }
+  end
+
+  describe 'specifying a simple join' do
+    before do
+      Post.filter do
+        join(Blog, :left, :posts_blogs) do
+          on(:blog_id => :id)
+          with(:name, 'Test Name')
+        end
+      end.inspect
+    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)
+    end
+
+    it 'should query against condition on join table' do
+      Post.last_find[:conditions].should == ['posts_blogs.name = ?', 'Test Name']
+    end
+  end
+
+  describe 'specifying a complex join through polymorphic associations' do
+    before do
+      Review.filter do
+        join(Feature, :left, :reviews_features) do
+          on(:reviewable_id => :featurable_id)
+          on(:reviewable_type => :featurable_type)
+          with(:priority, 5)
+        end
+      end.inspect
+    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)
+    end
+
+    it 'should query against condition on join table' do
+      Review.last_find[:conditions].should == ['reviews_features.priority = ?', 5]
+    end
+  end
+
+  describe 'should use values as join parameters instead of columns if given' do
+    before do
+      Review.filter do
+        join(Feature, :left) do
+          on(:reviewable_id => :featurable_id)
+          on(:reviewable_type => :featurable_type)
+          on(:featurable_type, 'SomeType')
+          with(:priority, 5)
+        end
+      end.inspect
+    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'))
+    end
+  end
+
+  describe 'using restrictions on join conditions' do
+    before do
+      Review.filter do
+        join(Feature, :left) do
+          on(:featurable_type, nil)
+          on(:featurable_id).gte(12)
+          on(:priority).not(6)
+        end
+      end.inspect
+    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))
+    end
+  end
+end

data/spec/implicit_join_spec.rb

@@ -93,6 +93,25 @@ describe 'implicit joins' do
     end
   end
 
+  describe 'with one having statement expressing multiple joins' do
+    before do
+      Blog.filter do
+        having(:posts => :comments) do
+          with :offensive, true
+        end
+      end.inspect
+    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)
+    end
+
+    it 'should query against both conditions' do
+      Blog.last_find[:conditions].should == [%q(blogs__posts__comments.offensive = ?), true] 
+    end
+  end
+
   describe 'on has_one' do
     before do
       Post.filter do
@@ -167,7 +186,7 @@ describe 'implicit joins' do
   describe 'with negated conditions' do
     before do
       Comment.filter do
-        without :offensive, false
+        with(:offensive).not(false)
       end.inspect
     end
 
@@ -179,7 +198,20 @@ describe 'implicit joins' do
   describe 'with negated nil conditions' do
     before do
       Comment.filter do
-        without :contents, nil
+        with(:contents).not(nil)
+        with :offensive, true
+      end.inspect
+    end
+
+    it 'should create the correct IS NOT NULL condition' do
+      Comment.last_find[:conditions].should == [%q(("comments".contents IS NOT NULL) AND ("comments".offensive = ?)), true]
+    end
+  end
+
+  describe 'with negated nil conditions using is_null' do
+    before do
+      Comment.filter do
+        with(:contents).not.is_null
         with :offensive, true
       end.inspect
     end

data/spec/models/feature.rb

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

data/spec/models/post.rb

@@ -5,4 +5,6 @@ class Post < ActiveRecord::Base
   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

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

data/spec/named_filter_spec.rb

@@ -54,8 +54,22 @@ describe 'named filters' do
     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|
+        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]
+    end
+  end
+
   describe 'using filters in subclasses' do
     before do
+      Comment.named_filter(:with_contents) do |*args|
+        with :contents, args[0]
+      end
       class NiceComment < Comment
         extend TestModel
 
@@ -63,9 +77,6 @@ describe 'named filters' do
           with :offensive, true
         end
       end
-      Comment.named_filter(:with_contents) do |*args|
-        with :contents, args[0]
-      end
     end
 
     it 'should execute the parent class filters correctly' do
@@ -81,17 +92,19 @@ describe 'named filters' do
       NiceComment.offensive.with_contents('something').inspect
       NiceComment.last_find[:conditions].should == [%q(("comments".offensive = ?) AND ("comments".contents = ?)), true, 'something']
     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]
+    end
   end
 
   describe 'using compound filters' do
-    before do
+    it 'should concatenate the filters correctly' do
+      pending 'nested chaining'
       Post.named_filter(:with_offensive_comments) do
         having(:comments).offensive(true)
       end
-    end
-
-    it 'should concatenate the filters correctly' do
-      pending 'nested chaining'
       Post.with_offensive_comments.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)

data/spec/restrictions_spec.rb

@@ -51,6 +51,40 @@ describe 'RecordFilter restrictions' do
     Post.last_find.should == { :conditions => [%q{"posts".created_at BETWEEN ? AND ?}, time1, time2] }
   end
 
+  it 'should filter for between with two arguments passed' do
+    Post.filter do
+      with(:id).between(1, 5)
+    end.inspect
+    Post.last_find.should == { :conditions => [%q("posts".id BETWEEN ? AND ?), 1, 5] }
+  end
+
+  it 'should filter for between with an array passed' do
+    Post.filter do
+      with(:id).between([2, 6])
+    end.inspect
+    Post.last_find.should == { :conditions => [%q("posts".id BETWEEN ? AND ?), 2, 6] }
+  end
+
+  it 'should filter by none_of' do
+    Post.filter do
+      none_of do
+        with(:blog_id, 1)
+        with(:permalink, 'eek')
+      end
+    end.inspect
+    Post.last_find.should == { :conditions => [%q{!(("posts".blog_id = ?) OR ("posts".permalink = ?))}, 1, 'eek'] }
+  end
+
+  it 'should filter by not_all_of' do
+    Post.filter do
+      not_all_of do
+        with(:blog_id, 1)
+        with(:permalink, 'eek')
+      end
+    end.inspect
+    Post.last_find.should == { :conditions => [%q{!(("posts".blog_id = ?) AND ("posts".permalink = ?))}, 1, 'eek'] }
+  end
+
   it 'should filter by disjunction' do
     Post.filter do
       any_of do
@@ -84,4 +118,25 @@ describe 'RecordFilter restrictions' do
       Post.last_find.should == { :conditions => [%q("posts".permalink IS NULL)] }
     end
   end
+
+  it 'should support like' do
+    Post.filter do
+      with(:permalink).like('%piglets%')
+    end.inspect
+    Post.last_find.should == { :conditions => [%q("posts".permalink LIKE ?), '%piglets%'] }
+  end
+
+  it 'should support NOT LIKE' do
+    Post.filter do
+      with(:permalink).not.like('%ostriches%')
+    end.inspect
+    Post.last_find.should == { :conditions => [%q("posts".permalink NOT LIKE ?), '%ostriches%'] }
+  end
+
+  it 'should provide access to the filter class in the filter' do
+    Post.filter do
+      with(:permalink).not.equal_to(filter_class.name)
+    end.inspect
+    Post.last_find.should == { :conditions => [%q("posts".permalink != ?), 'Post'] }
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: aub-record_filter
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors: 
 - Mat Brown
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-17 00:00:00 -07:00
+date: 2009-04-22 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -29,11 +29,14 @@ files:
 - lib/record_filter/active_record.rb
 - lib/record_filter/conjunctions.rb
 - lib/record_filter/dsl.rb
+- lib/record_filter/dsl/class_join.rb
 - lib/record_filter/dsl/conjunction.rb
 - lib/record_filter/dsl/conjunction_dsl.rb
 - lib/record_filter/dsl/dsl.rb
 - lib/record_filter/dsl/group_by.rb
 - lib/record_filter/dsl/join.rb
+- lib/record_filter/dsl/join_condition.rb
+- lib/record_filter/dsl/join_dsl.rb
 - lib/record_filter/dsl/limit.rb
 - lib/record_filter/dsl/order.rb
 - lib/record_filter/dsl/restriction.rb
@@ -46,12 +49,15 @@ files:
 - lib/record_filter/restrictions.rb
 - lib/record_filter/table.rb
 - spec/exception_spec.rb
+- 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/named_filter_spec.rb
 - spec/restrictions_spec.rb
@@ -85,12 +91,15 @@ specification_version: 3
 summary: Pure-ruby criteria API for building complex queries in ActiveRecord
 test_files: 
 - spec/exception_spec.rb
+- 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/named_filter_spec.rb
 - spec/restrictions_spec.rb