outoftime-record_filter 0.1.3 → 0.1.4

data/VERSION.yml

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

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/conjunctions.rb

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

data/lib/record_filter/dsl.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
+      def add_join(association, join_type, &block)
+        dsl = ConjunctionDSL.new(@model_class, Conjunction.new(@model_class, :all_of))
+        dsl.instance_eval(&block) if block
+        @steps << Join.new(association, join_type, 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
@@ -41,9 +37,21 @@ module RecordFilter
       end
 
       # join
-      def having(association, &block)
-        join = @conjunction.add_join(association, &block)
-        ConjunctionDSL.new(join.conjunction)
+      def having(join_type_or_association, association=nil, &block)
+        if association.nil?
+          association, join_type = join_type_or_association, nil
+        else
+          join_type = join_type_or_association
+        end
+        @conjunction.add_join(association, join_type, &block)
+      end
+
+      def join(clazz, join_type, table_alias=nil, &block)
+        @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.rb

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

data/lib/record_filter/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,8 +4,17 @@ 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, :like].each do |operator|
@@ -32,6 +41,16 @@ module RecordFilter
       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

@@ -19,6 +19,8 @@ module RecordFilter
     def method_missing(method, *args, &block)
       if @clazz.named_filters.include?(method)
         Filter.new(@clazz, method, @dsl.conjunction, *args)
+      elsif [:size, :count, :length].include?(method)
+        loaded_count_data.send(method, *args, &block)
       else
         loaded_data.send(method, *args, &block)
       end
@@ -33,6 +35,13 @@ module RecordFilter
       end
     end
 
+    def loaded_count_data
+      @loaded_count_data ||= begin
+        query = Query.new(@clazz, @dsl.conjunction)
+        @clazz.scoped(query.to_find_params(true))
+      end
+    end
+
     def dsl_for_named_filter(clazz, named_filter)
       return DSL::DSL.create(clazz) if named_filter.blank?
       while (clazz)

data/lib/record_filter/group_by.rb

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

data/lib/record_filter/join.rb

@@ -2,16 +2,64 @@ 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=nil)
+      @left_table, @right_table, @join_conditions, @join_type =
+        left_table, right_table, join_conditions, join_type
+      @join_type ||= :inner
     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
+
+    def requires_distinct_select?
+      [:left, :outer, :left_outer].include?(@join_type)
+    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'
+        when :left_outer then 'LEFT OUTER'
+        when :outer then 'OUTER'
+        else nil
+      end
     end
   end
 end

data/lib/record_filter/order.rb

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

data/lib/record_filter/query.rb

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

data/lib/record_filter/restrictions.rb

@@ -15,7 +15,11 @@ module RecordFilter
       end
 
       def to_negative_sql
-        "!(#{to_positive_sql})"
+        "NOT (#{to_positive_sql})"
+      end
+
+      def self.class_from_operator(operator)
+        "RecordFilter::Restrictions::#{operator.to_s.camelize}".constantize
       end
     end
 
@@ -25,7 +29,7 @@ module RecordFilter
       end
 
       def to_negative_sql
-        "#{@column_name} != ?"
+        "#{@column_name} <> ?"
       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
@@ -16,7 +16,7 @@ module RecordFilter
       @model_class.quoted_table_name
     end
 
-    def join_association(association_name)
+    def join_association(association_name, join_type=nil)
       @joins_cache[association_name] ||=
         begin
           association = @model_class.reflect_on_association(association_name)
@@ -25,13 +25,22 @@ module RecordFilter
           end
           case association.macro
           when :belongs_to, :has_many, :has_one
-            simple_join(association)
+            simple_join(association, join_type)
           when :has_and_belongs_to_many
-            compound_join(association)
+            compound_join(association, join_type)
           end
         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)
@@ -53,27 +62,31 @@ module RecordFilter
 
     private
 
-    def simple_join(association)
+    def simple_join(association, join_type)
       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
+
+      if association.options[:as]
+        join_predicate << DSL::Restriction.new(association.options[:as].to_s + '_type').equal_to(@model_class.name)
+      end
       join_table = Table.new(association.klass, alias_for_association(association))
-      @joins << join = Join.new(self, join_table, join_predicate)
+      @joins << join = Join.new(self, join_table, join_predicate, join_type)
       join
     end
 
-    def compound_join(association)
-      pivot_join_predicate = { :id => association.primary_key_name.to_sym }
+    def compound_join(association, join_type)
+      pivot_join_predicate = [{ :id => association.primary_key_name.to_sym }]
       table_name = @model_class.connection.quote_table_name(association.options[:join_table])
-      pivot_table = PivotTable.new(table_name, "__#{alias_for_association(association)}")
-      pivot_join = Join.new(self, pivot_table, pivot_join_predicate)
-      join_predicate = { association.association_foreign_key => :id }
+      pivot_table = PivotTable.new(table_name, association, "__#{alias_for_association(association)}")
+      pivot_join = Join.new(self, pivot_table, pivot_join_predicate, join_type)
+      join_predicate = [{ association.association_foreign_key.to_sym => :id }]
       join_table = Table.new(association.klass, alias_for_association(association))
-      pivot_table.joins << join = Join.new(pivot_table, join_table, join_predicate)
+      pivot_table.joins << join = Join.new(pivot_table, join_table, join_predicate, join_type)
       @joins << pivot_join
       join
     end
@@ -83,17 +96,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,106 @@
+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
+
+  describe 'using implicit and explicit joins together with conditions' do
+    before do
+      Blog.named_filter :somethings do
+        having(:ads) do
+          with(:content, nil)
+        end
+        join(Post, :left) do
+          on(:id => :blog_id)
+          join(Comment, :inner) do
+            on(:id => :post_id)
+            on(:offensive, true)
+          end
+        end
+        group_by(:id)
+      end
+      Blog.somethings.inspect
+    end
+
+    it 'should produce the correct conditions' do
+      Blog.last_find[:conditions].should == [%q((blogs__ads.content IS NULL))]
+    end
+
+    it 'should produce the correct join' do
+      Blog.last_find[:joins].should == %q(INNER JOIN "ads" AS blogs__ads ON "blogs".id = blogs__ads.blog_id LEFT JOIN "posts" AS blogs__Post ON "blogs".id = blogs__Post.blog_id INNER JOIN "comments" AS blogs__Post__Comment ON blogs__Post.id = blogs__Post__Comment.post_id AND (blogs__Post__Comment.offensive = 't'))
+    end
+  end
+end

data/spec/implicit_join_spec.rb

@@ -186,19 +186,19 @@ describe 'implicit joins' do
   describe 'with negated conditions' do
     before do
       Comment.filter do
-        without :offensive, false
+        with(:offensive).not(false)
       end.inspect
     end
 
     it 'should create the correct condition' do
-      Comment.last_find[:conditions].should == [%q("comments".offensive != ?), false]
+      Comment.last_find[:conditions].should == [%q("comments".offensive <> ?), false]
     end
   end
 
   describe 'with negated nil conditions' do
     before do
       Comment.filter do
-        without :contents, nil
+        with(:contents).not(nil)
         with :offensive, true
       end.inspect
     end
@@ -207,4 +207,71 @@ describe 'implicit joins' 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
+
+    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 'passing the join type to having' do
+    before do
+      Blog.filter do
+        having(:left_outer, :posts) do
+          with(:permalink, 'ack')
+        end
+      end.inspect
+    end
+
+    it 'should create the correct condition' do
+      Blog.last_find[:conditions].should == [%q(blogs__posts.permalink = ?), 'ack']
+    end
+
+    it 'should create the correct join' do
+      Blog.last_find[:joins].should == %q(LEFT OUTER JOIN "posts" AS blogs__posts ON "blogs".id = blogs__posts.blog_id)
+    end
+  end
+
+  describe 'passing the join type to having with multiple joins' do
+    before do
+      Blog.filter do
+        having(:left_outer, :posts => :comments) do
+          with(:offensive, true)
+        end
+      end.inspect
+    end
+
+    it 'should create the correct condition' do
+      Blog.last_find[:conditions].should == [%q(blogs__posts__comments.offensive = ?), true]
+    end
+
+    it 'should create the correct join' do
+      Blog.last_find[:joins].should == %q(LEFT OUTER JOIN "posts" AS blogs__posts ON "blogs".id = blogs__posts.blog_id LEFT OUTER JOIN "comments" AS blogs__posts__comments ON blogs__posts.id = blogs__posts__comments.post_id)
+    end
+  end
+
+  describe 'on polymorphic associations' do
+    before do
+      Post.filter do
+        having(:reviews) do
+          with(:stars_count, 3)
+        end
+      end.inspect
+    end
+
+    it 'should create the correct condition' do
+      Post.last_find[:conditions].should == [%q(posts__reviews.stars_count = ?), 3]
+    end
+
+    it 'should create the correct join' do
+      Post.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
 end

data/spec/limits_and_ordering_spec.rb

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

data/spec/models/blog.rb

@@ -2,4 +2,5 @@ class Blog < ActiveRecord::Base
   extend TestModel
 
   has_many :posts
+  has_many :ads
 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/restrictions_spec.rb

@@ -72,7 +72,7 @@ describe 'RecordFilter restrictions' do
         with(:permalink, 'eek')
       end
     end.inspect
-    Post.last_find.should == { :conditions => [%q{!(("posts".blog_id = ?) OR ("posts".permalink = ?))}, 1, 'eek'] }
+    Post.last_find.should == { :conditions => [%q{NOT (("posts".blog_id = ?) OR ("posts".permalink = ?))}, 1, 'eek'] }
   end
 
   it 'should filter by not_all_of' do
@@ -82,7 +82,7 @@ describe 'RecordFilter restrictions' do
         with(:permalink, 'eek')
       end
     end.inspect
-    Post.last_find.should == { :conditions => [%q{!(("posts".blog_id = ?) AND ("posts".permalink = ?))}, 1, 'eek'] }
+    Post.last_find.should == { :conditions => [%q{NOT (("posts".blog_id = ?) AND ("posts".permalink = ?))}, 1, 'eek'] }
   end
 
   it 'should filter by disjunction' do
@@ -128,8 +128,15 @@ describe 'RecordFilter restrictions' do
 
   it 'should support NOT LIKE' do
     Post.filter do
-      without(:permalink).like('%ostriches%')
+      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

data/spec/spec_helper.rb

@@ -15,6 +15,7 @@ module TestModel
 
   def scoped(params = {})
     @last_find = params
+    super
   end
 
   def self.extended(base)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: outoftime-record_filter
 version: !ruby/object:Gem::Version 
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors: 
 - Mat Brown
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-20 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