aub-record_filter 0.9.7 → 0.9.8

data/CHANGELOG

@@ -1,3 +1,23 @@
+= 0.9.8
+
+* BREAKING CHANGE: changed the 'limit' method so that the limit is always the
+first argument, with an optional offset as the second argument. This makes the
+functionality much clearer by avoiding obnoxious argument swapping.
+
+* BREAKING CHANGE: changed the arguments to the 'join' method so that it
+takes a class and an options hash. The options hash can contain a :join_type
+and an :alias, allowing only the arguments that the client wants to use to be
+specified. This will break existing code where the join type was passed as
+the second argument.
+
+* BREAKING CHANGE: changed the arguments to the 'having' method so that it
+takes an association name and an options hash. The options hash takes
+:join_type and :alias. This will break existing code where the join_type was
+passed as the first argument to the method. The alias is a new option that
+allows you to alias joins, which lets you join in the same association twice.
+
+* Added a distinct method to force queries to be distinct.
+
 = 0.9.7
 
 * Fix a bug where explicit joins would not honor different aliases if joining

data/README.rdoc

@@ -122,7 +122,7 @@ The following example shows the use of each of these techniques:
         with(:offensive, true)
       end
     end
-    limit(10, 100)
+    limit(100, 10)
     order(:created_at, :desc)
     group_by(:comments => :offensive)
   end
@@ -234,7 +234,7 @@ In a filter for a Post model that has_many comments, the following two examples
 
   having(:comments)
 
-  join(Comment, :inner) do
+  join(Comment, :join_type => :inner) do
     on(:id => :post_id)
   end
 
@@ -248,7 +248,7 @@ added. Explicit joins also allow conditions to be set on columns of the table be
     with(:created_at).greater_than(2.days.ago)
   end
 
-  join(Comment, :inner) do
+  join(Comment, :join_type => :inner) do
     on(:id => :commentable_id)
     on(:commentable_type).equal_to('Post')
     with(:created_at).less_than(1.year.ago)
@@ -260,13 +260,29 @@ example will join both tables and add a condition on the author.
 
   having(:comments => :author).with(:name, 'Bob')
 
+For both join types, an options hash can be provided as the second argument for passing the join
+type and/or an alias to use for the joined table. The join type defaults to :inner, and the alias
+defaults to a unique name for identifying the table. Using aliases allows you to join to a given table
+twice with two different names. How about a contrived example? Awesome.
+
+  Blog.filter do
+    having(:posts, :join_type => :left, :alias => 'posts_1').with(:title, 'a')
+    having(:posts, :alias => 'posts_2').with(:title, 'b')
+  end
+
+  # SELECT DISTINCT "blogs".* FROM "blogs" 
+  #   LEFT OUTER JOIN "posts" AS posts_1 ON "blogs".id = posts_1.blog_id 
+  #   INNER JOIN "posts" AS posts_2 ON "blogs".id = posts_2.blog_id 
+  #   WHERE ((posts_1.title = 'a') AND (posts_2.title = 'b'))
+
 === Limits and Offsets
 
-These are specified using the 'limit' method, which takes two arguments, the offset and the
-limit. If only one argument is given, it is assumed to be the limit.
+These are specified using the 'limit' method, which takes two arguments, the limit and the
+offset. The offset is optional. For specifying only offsets, the 'offset' method is also available.
 
-  limit(10, 100)   # :offset => 10, :limit => 100
-  limit(100)       # :offset => 0, :limit => 100
+  limit(100, 10)   # :limit => 100, :offset => 100
+  limit(100)       # :limit => 100
+  offset(10)       # :offset => 10
 
 === Ordering
 
@@ -299,6 +315,19 @@ order in which they were given.
 
   # :group => "'posts'.permalink, posts__comments.offensive'
 
+=== Distinct
+
+Filters that include outer joins are automatically made distinct by record_filter. For filters that
+use inner joins, use the 'distinct' method in the DSL to force the select to be distinct.
+
+  Blog.filter do
+    with(:created_at).greater_than(1.day.ago)
+    having(:posts).with(:permalink, nil)
+    distinct
+  end
+  
+  # :select => "DISTINCT 'blogs'.*"
+
 == LICENSE:
 
 (The MIT License)

data/TODO

@@ -0,0 +1,3 @@
+* Add ability to do custom selects.
+* Add hooks for custom SQL in general.
+

data/VERSION.yml

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

data/lib/record_filter/conjunctions.rb

@@ -1,7 +1,7 @@
 module RecordFilter
   module Conjunctions # :nodoc: all
     class Base
-      attr_reader :table_name, :limit, :offset
+      attr_reader :table_name, :limit, :offset, :distinct
 
       def self.create_from(dsl_conjunction, table)
         result = case dsl_conjunction.type
@@ -19,7 +19,7 @@ module RecordFilter
           when DSL::Conjunction 
             result.add_conjunction(create_from(step, table)) 
           when DSL::Join
-            join = result.add_join_on_association(step.association, step.join_type)
+            join = result.add_join_on_association(step.association, step.join_type, step.aliaz)
             result.add_conjunction(create_from(step.conjunction, join.right_table))
           when DSL::ClassJoin
             join = result.add_join_on_class(
@@ -36,6 +36,7 @@ module RecordFilter
           else raise InvalidFilterException.new('And invalid filter step was provided.')
           end
         end
+        result.set_distinct(dsl_conjunction.distinct)
         result
       end
 
@@ -44,6 +45,7 @@ module RecordFilter
         @table_name = table.table_alias
         @restrictions = restrictions || []
         @joins = joins || []
+        @distinct = false
       end
 
       def add_restriction(column_name, operator, value, options={})
@@ -57,13 +59,13 @@ module RecordFilter
         conjunction
       end
 
-      def add_join_on_association(association_name, join_type)
+      def add_join_on_association(association_name, join_type, aliaz)
         table = @table
         while association_name.is_a?(Hash)
-          table = table.join_association(association_name.keys[0], join_type).right_table
+          table = table.join_association(association_name.keys[0], { :join_type => join_type }).right_table
           association_name = association_name.values[0]
         end
-        table.join_association(association_name, join_type)
+        table.join_association(association_name, :join_type => join_type, :alias => aliaz)
       end
       
       def add_join_on_class(join_class, join_type, table_alias, conditions)
@@ -82,6 +84,10 @@ module RecordFilter
         @limit, @offset = limit, offset
       end
 
+      def set_distinct(value)
+        @distinct = value
+      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}")

data/lib/record_filter/dsl/conjunction.rb

@@ -2,10 +2,10 @@ module RecordFilter
   module DSL
     class Conjunction # :nodoc: all
 
-      attr_reader :type, :steps
+      attr_reader :type, :steps, :distinct
 
       def initialize(model_class, type=:all_of)
-        @model_class, @type, @steps = model_class, type, []
+        @model_class, @type, @steps, @distinct = model_class, type, [], false
       end
 
       def add_restriction(column, value)
@@ -19,10 +19,10 @@ module RecordFilter
         @steps << dsl.conjunction
       end
 
-      def add_join(association, join_type, &block)
+      def add_join(association, join_type, aliaz, &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)
+        @steps << Join.new(association, join_type, dsl.conjunction, aliaz)
         dsl
       end
 
@@ -45,6 +45,10 @@ module RecordFilter
         @steps << GroupBy.new(column)
       end
 
+      def set_distinct
+        @distinct = true
+      end
+
       def add_named_filter(method, *args)
         @steps << NamedFilter.new(method, *args)
       end

data/lib/record_filter/dsl/conjunction_dsl.rb

@@ -169,20 +169,28 @@ module RecordFilter
       #       with(:created_at).greater_than(3.days.ago)
       #     end
       #   end
-      # If one argument is given, it is assumed to represent the name of the association
-      # that will be used for the join and a join type of :inner will be used by default. If two arguments
-      # are provided, the first one is assumed to be the join type, which can be one of :inner, :left or 
-      # :right and the second one is the association name. An alias will automatically be created
+      # Options can be passed to provide a custom join type or table alias through the options
+      # hash. The :join_type option can be either :inner, :left or :right and will default to
+      # :inner if not provided. The :alias option allows you to provide an alias for use in joining
+      # the table. If the same association is joined twice with different aliases, it will be treated
+      # as two separate joins. By default an alias will automatically be created
       # for the joined table named "#{left_table}__#{association_name}", so in the above example, the
       # alias would be posts__comments. It is also possible to provide a hash as the association
       # name, in which case a trail of associations can be joined in one statment.
       #
       # ==== Parameters
-      # join_type<Symbol>::
-      #   Specifies the type of join to perform, and can be one of :inner, :left or :right. :left
-      #   and :right will create left and right outer joins, respectively.
       # association<Symbol>::
       #   The name of the association to use as a base for the join.
+      # options<Hash>::
+      #   An options hash (see below)
+      #
+      # ==== Options (options)
+      # :join_type<Symbol>::
+      #   The type of join to use. Available options are :inner, :left and :right. Defaults to :inner.
+      # :alias<String>::
+      #   An alias to use for the table name in the join. If provided, will create a unique name for
+      #   the join and allow the same association to be joined multiple times. By default, the alias
+      #   will be "#{left_table}__#{association_name}".
       #
       # ==== Returns
       # ConjunctionDSL::
@@ -193,30 +201,34 @@ module RecordFilter
       # be used as the association name.
       #
       # @public
-      def having(join_type, association=nil, &block)
-        if association.nil?
-          association, join_type = join_type, nil
-        end
-        @conjunction.add_join(association, join_type, &block)
+      def having(association, options={}, &block)
+        @conjunction.add_join(association, options[:join_type], options[:alias], &block)
       end
 
       # Create an explicit join on the table of the given class. This method allows more complex
       # joins to be speficied than can be created using having, including jump joins and ones that
       # include conditions on column values. The method accepts a block that can contain any sequence
       # of conjunctions, restrictions, or other joins, but it must also contain at least one call to
-      # JoinDSL.on to specify the conditions for the join.
+      # JoinDSL.on to specify the conditions for the join. The options hash accepts :join_type and
+      # :alias parameters. The :join_type parameter can be either :inner, :left or :right and defaults
+      # to :inner. The :alias parameter allows you to specify an alias for the table in the join and
+      # defaults to "#{left_table}__#{clazz.name}".
       #
       # ==== Parameters
       # clazz<Class>::
       #   The class that is being joined to.
-      # join_type<Symbol>::
+      # options<Hash>::
+      #   An options hash (see below)
+      # block<Proc>
+      #   The contents of the join block can contain any sequence of conjunctions, restrictions, or joins.
+      #
+      # ==== Options(options)
+      # :join_type<Symbol>::
       #   Indicates the type of join to use and must be one of :inner, :left or :right, where :left
       #   or :right will create a LEFT or RIGHT OUTER join respectively.
-      # table_alias<String, optional>::
+      # :alias<String>::
       #   If provided, will specify an alias to use in the SQL when referring to the joined table.
       #   If the argument is not given, the alias will be "#{left_table}__#{clazz.name}"
-      # block<Proc>
-      #   The contents of the join block can contain any sequence of conjunctions, restrictions, or joins.
       #
       # ==== Returns
       # JoinDSL::
@@ -224,8 +236,8 @@ module RecordFilter
       #   for constructions like: join(Comment, :inner).on(:id => :post_id)
       #
       # @public
-      def join(clazz, join_type, table_alias=nil, &block)
-        @conjunction.add_class_join(clazz, join_type, table_alias, &block)
+      def join(clazz, options={}, &block)
+        @conjunction.add_class_join(clazz, options[:join_type], options[:alias], &block)
       end
 
       # Access the class that the current filter is being applied to. This is necessary
@@ -285,7 +297,7 @@ module RecordFilter
       # Define these_methods here just so that we can throw exceptions when they are called. They should not
       # be callable in the scope of a conjunction_dsl.
       #
-      def limit(offset_or_limit, limit=nil) # :nodoc:
+      def limit(limit, offset=nil) # :nodoc:
         raise InvalidFilterException.new('Calls to limit can only be made in the outer block of a filter.')
       end
 

data/lib/record_filter/dsl/dsl.rb

@@ -8,25 +8,18 @@ module RecordFilter
       # last one will override any others.
       #
       # ==== Parameters
+      # limit<Integer>::
+      #   Used for the limit of the query.
       # offset<Integer>::
-      #   Used for the offset of the query.
-      # limit<Integer::
-      #   Used as the limit for the query.
+      #   Used as the offset for the query. This argument is optional, with the default
+      #   being no offset.
       #
       # ==== Returns
       # nil
       #
-      # ==== Alternatives
-      # If called with a single argument, it is assumed to represent the limit, and
-      # no offset will be specified.
-      #
       # @public
-      def limit(offset, limit=nil)
-        if limit
-          @conjunction.add_limit(limit, offset)
-        else
-          @conjunction.add_limit(offset, nil)
-        end
+      def limit(limit, offset=nil)
+        @conjunction.add_limit(limit, offset)
         nil
       end
 
@@ -129,6 +122,22 @@ module RecordFilter
         @conjunction.add_group_by(column)
         nil
       end
+
+      # Specify that the resulting query should select distinct results.  This method 
+      # can only be called in the outermost scope of a filter (i.e. not inside of a having 
+      # block, etc.).
+      #
+      # ==== Parameters
+      # none
+      #
+      # ==== Returns
+      # nil
+      #
+      # @public
+      def distinct
+        @conjunction.set_distinct
+        nil
+      end
     end
   end
 end

data/lib/record_filter/dsl/join.rb

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

data/lib/record_filter/query.rb

@@ -20,7 +20,9 @@ module RecordFilter
         params = {}
         conditions = @conjunction.to_conditions
         params = { :conditions => conditions } if conditions
-        add_joins(params, count_query)
+        joins = @table.all_joins
+        params[:joins] = joins.map { |join| join.to_sql } unless joins.empty?
+        set_select(params, count_query)
         orders = @table.orders
         params[:order] = orders.map { |order| order.to_sql } * ', ' unless orders.empty?
         group_bys = @table.group_bys
@@ -34,10 +36,8 @@ module RecordFilter
 
     protected
 
-    def add_joins(params, count_query)
-      joins = @table.all_joins
-      params[:joins] = joins.map { |join| join.to_sql } unless joins.empty?
-      if (joins.any? { |j| j.requires_distinct_select? })
+    def set_select(params, count_query)
+      if @conjunction.distinct || (@table.all_joins.any? { |j| j.requires_distinct_select? })
         if count_query
           params[:select] = "DISTINCT #{@table.table_name}.#{@table.model_class.primary_key}"
         else

data/lib/record_filter/table.rb

@@ -16,35 +16,39 @@ module RecordFilter
       @table_name ||= @model_class.quoted_table_name
     end
 
-    def join_association(association_name, join_type=nil, options={})
+    def join_association(association_name, options={})
       association_name = association_name.to_sym
-      @joins_cache[association_name] ||=
-        begin
-          association = @model_class.reflect_on_association(association_name)
-          if association.nil?
-            raise AssociationNotFoundException.new("The association #{association_name} was not found on #{@model_class.name}.")
-          end
-          if (association.options[:through])
-            through_association = @model_class.reflect_on_association(association.options[:through])
-
-            through_join = join_association(
-              association.options[:through], 
-              join_type, 
-              :type_restriction => association.options[:source_type], 
-              :source => association.options[:source])
-
-            through_join.right_table.join_association(
-              association.options[:source] || association_name, join_type, :join_class => association.options[:source_type])
-          else
-            case association.macro
-            when :belongs_to, :has_many, :has_one
-              simple_join(association, join_type, options)
-            when :has_and_belongs_to_many
-              compound_join(association, join_type)
-            else raise InvalidJoinException.new("I don't know how to join on an association of type #{association.macro}.")
-            end
+      join_type = options[:join_type] || :inner
+      cache_key = options[:alias] || association_name
+      @joins_cache[cache_key] ||= begin
+        association = @model_class.reflect_on_association(association_name)
+        if association.nil?
+          raise AssociationNotFoundException.new("The association #{association_name} was not found on #{@model_class.name}.")
+        end
+        if (association.options[:through])
+          through_association = @model_class.reflect_on_association(association.options[:through])
+
+          through_join = join_association(
+            association.options[:through], 
+            :join_type => join_type, 
+            :type_restriction => association.options[:source_type], 
+            :source => association.options[:source])
+
+          through_join.right_table.join_association(
+            association.options[:source] || association_name, 
+            :join_type => join_type,
+            :alias => options[:alias],
+            :join_class => association.options[:source_type])
+        else
+          case association.macro
+          when :belongs_to, :has_many, :has_one
+            simple_join(association, join_type, options)
+          when :has_and_belongs_to_many
+            compound_join(association, join_type, options)
+          else raise InvalidJoinException.new("I don't know how to join on an association of type #{association.macro}.")
           end
         end
+      end
     end
 
     def join_class(clazz, join_type, table_alias, conditions)
@@ -109,7 +113,7 @@ module RecordFilter
 
       clazz = options[:join_class].nil? ? association.klass : options[:join_class].constantize
 
-      join_table = Table.new(clazz, alias_for_association(association))
+      join_table = Table.new(clazz, options[:alias] || alias_for_association(association))
       @joins << join = Join.new(self, join_table, join_predicate, join_type)
       join
     end
@@ -125,13 +129,13 @@ module RecordFilter
         end
     end
 
-    def compound_join(association, join_type)
+    def compound_join(association, join_type, options)
       pivot_join_predicate = [{ @model_class.primary_key => association.primary_key_name.to_sym }]
       table_name = @model_class.connection.quote_table_name(association.options[:join_table])
-      pivot_table = PivotTable.new(table_name, association, "__#{alias_for_association(association)}")
+      pivot_table = PivotTable.new(table_name, association, "__#{options[:alias] || alias_for_association(association)}")
       pivot_join = Join.new(self, pivot_table, pivot_join_predicate, join_type)
       join_predicate = [{ association.association_foreign_key.to_sym => @model_class.primary_key }]
-      join_table = Table.new(association.klass, alias_for_association(association))
+      join_table = Table.new(association.klass, options[:alias] || alias_for_association(association))
       pivot_table.joins << join = Join.new(pivot_table, join_table, join_predicate, join_type)
       @joins << pivot_join
       join

data/record_filter.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{record_filter}
-  s.version = "0.9.7"
+  s.version = "0.9.8"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Aubrey Holland", "Mat Brown"]
-  s.date = %q{2009-06-03}
+  s.date = %q{2009-06-04}
   s.description = %q{RecordFilter is a Pure-ruby criteria API for building complex queries in ActiveRecord. It supports queries that are built on the fly as well as named filters that can be added to objects and chained to create complex queries. It also gets rid of the nasty hard-coded SQL that shows up in most ActiveRecord code with a clean API that makes queries simple and intuitive to build.}
   s.email = %q{aubreyholland@gmail.com}
   s.extra_rdoc_files = [
@@ -17,6 +17,7 @@ Gem::Specification.new do |s|
      "CHANGELOG",
      "README.rdoc",
      "Rakefile",
+     "TODO",
      "VERSION.yml",
      "config/roodi.yml",
      "lib/record_filter.rb",

data/spec/exception_spec.rb

@@ -61,7 +61,7 @@ describe 'raising exceptions' do
     it 'should raise ColumnNotFoundException for explicit joins on bad column names for the right table' do
       lambda {
         Review.filter do
-          join(Feature, :left) do
+          join(Feature, :join_type => :left) do
             on(:reviewable_id => :ftrable_id)
             on(:reviewable_type => :ftrable_type)
             with(:priority, 5)
@@ -73,7 +73,7 @@ describe 'raising exceptions' do
     it 'should raise ColumnNotFoundException for explicit joins on bad column names for the left table' do
       lambda {
         Review.filter do
-          join(Feature, :inner) do
+          join(Feature, :join_type => :inner) do
             on(:rvwable_id => :featurable_id)
             on(:rvwable_type => :featurable_type)
             with(:priority, 5)
@@ -85,7 +85,7 @@ describe 'raising exceptions' do
     it 'should raise ColumnNotFoundException for explicit joins on bad column names in conditions' do
       lambda {
         Review.filter do
-          join(Feature, :inner) do
+          join(Feature, :join_type => :inner) do
             on(:reviewable_id).gt(12)
           end
         end.inspect
@@ -95,7 +95,7 @@ describe 'raising exceptions' do
     it 'should raise an ArgumentError if an invalid join type is specified' do
       lambda {
         Review.filter do
-          join(Feature, :crazy) do
+          join(Feature, :join_type => :crazy) do
             on(:reviewable_type => :featurable_type)
           end
         end.inspect
@@ -105,7 +105,7 @@ describe 'raising exceptions' do
     it 'should raise an InvalidJoinException if no columns are specified for the join' do
       lambda {
         Review.filter do
-          join(Feature, :inner)
+          join(Feature, :join_type => :inner)
         end.inspect
       }.should raise_error(RecordFilter::InvalidJoinException)
     end

data/spec/explicit_join_spec.rb

@@ -8,7 +8,7 @@ describe 'explicit joins' do
   describe 'specifying a simple join' do
     before do
       Post.filter do
-        join(Blog, :left, :posts_blogs) do
+        join(Blog, :join_type => :left, :alias => :posts_blogs) do
           on(:blog_id => :id)
           with(:name, 'Test Name')
         end
@@ -27,7 +27,7 @@ describe 'explicit joins' do
   describe 'specifying a complex join through polymorphic associations' do
     before do
       Review.filter do
-        join(Feature, :left, :reviews_features) do
+        join(Feature, :join_type => :left, :alias => :reviews_features) do
           on(:reviewable_id => :featurable_id)
           on(:reviewable_type => :featurable_type)
           with(:priority, 5)
@@ -47,7 +47,7 @@ describe 'explicit joins' do
   describe 'should use values as join parameters instead of columns if given' do
     before do
       Review.filter do
-        join(Feature, :left) do
+        join(Feature, :join_type => :left) do
           on(:reviewable_id => :featurable_id)
           on(:reviewable_type => :featurable_type)
           on(:featurable_type, 'SomeType')
@@ -64,7 +64,7 @@ describe 'explicit joins' do
   describe 'using restrictions on join conditions' do
     before do
       Review.filter do
-        join(Feature, :left) do
+        join(Feature, :join_type => :left) do
           on(:featurable_type, nil)
           on(:featurable_id).gte(12)
           on(:priority).not(6)
@@ -84,9 +84,9 @@ describe 'explicit joins' do
         having(:ads) do
           with(:content, nil)
         end
-        join(Post, :left) do
+        join(Post, :join_type => :left) do
           on(:id => :blog_id)
-          join(Comment, :inner) do
+          join(Comment, :join_type => :inner) do
             on(:id => :post_id)
             on(:offensive, true)
           end
@@ -109,11 +109,11 @@ describe 'explicit joins' do
     before do
       @blog = Class.new(Blog)
       @blog.named_filter(:things) do
-        join(Post, :inner, 'blogs_posts_1') do
+        join(Post, :join_type => :inner, :alias => 'blogs_posts_1') do
           on(:id => :blog_id)
           with(:title, 'ack')
         end
-        join(Post, :inner, 'blogs_posts_2') do
+        join(Post, :join_type => :inner, :alias => 'blogs_posts_2') do
           on(:id => :blog_id)
           with(:title, 'hmm')
         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, :posts) do
+        having(:posts, :join_type => :left) 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, :posts => :comments) do
+        having({ :posts => :comments }, :join_type => :left) do
           with(:offensive, true)
         end
       end.inspect
@@ -329,4 +329,75 @@ describe 'implicit joins' do
       Post.last_find[:joins].should == [%q(INNER JOIN "comments" AS posts__comments ON "posts".id = posts__comments.post_id)]
     end
   end
+
+  describe 'using a table alias' do
+    before do
+      Post.filter do
+        having(:comments, :alias => 'arghs') do
+          with(:offensive, true)
+        end
+      end.inspect
+    end
+
+    it 'should create the correct condition' do
+      Post.last_find[:conditions].should == [%q(arghs.offensive = ?), true]
+    end
+
+    it 'should create the correct join' do
+      Post.last_find[:joins].should == [%q(INNER JOIN "comments" AS arghs ON "posts".id = arghs.post_id)]
+    end
+  end
+
+  describe 'using a table alias to do multiple joins on the same association' do
+    before do
+      Post.filter do
+        having(:comments, :alias => 'ooohs').with(:offensive, true)
+        having(:comments, :alias => 'aaahs').with(:offensive, false)
+      end.inspect
+    end
+
+    it 'should create the correct condition' do
+      Post.last_find[:conditions].should == [%q((ooohs.offensive = ?) AND (aaahs.offensive = ?)), true, false]
+    end
+
+    it 'should create the correct join' do
+      Post.last_find[:joins].should == [%q(INNER JOIN "comments" AS ooohs ON "posts".id = ooohs.post_id), %q(INNER JOIN "comments" AS aaahs ON "posts".id = aaahs.post_id)]
+    end
+  end
+
+  describe 'using a table alias with has_many :through associations' do
+    before do
+      Blog.filter do
+        having(:comments, :alias => 'arghs') do
+          with(:offensive, true)
+        end
+      end.inspect
+    end
+
+    it 'should create the correct condition' do
+      Blog.last_find[:conditions].should == [%q(arghs.offensive = ?), true]
+    end
+
+    it 'should create the correct join' do
+      Blog.last_find[:joins].should == [%q(INNER JOIN "posts" AS blogs__posts ON "blogs".id = blogs__posts.blog_id), %q(INNER JOIN "comments" AS arghs ON blogs__posts.id = arghs.post_id)]
+    end
+  end
+
+  describe 'using a table alias' do
+    before do
+      Post.filter do
+        having(:comments, :alias => 'arghs') do
+          with(:offensive, true)
+        end
+      end.inspect
+    end
+
+    it 'should create the correct condition' do
+      Post.last_find[:conditions].should == [%q(arghs.offensive = ?), true]
+    end
+
+    it 'should create the correct join' do
+      Post.last_find[:joins].should == [%q(INNER JOIN "comments" AS arghs ON "posts".id = arghs.post_id)]
+    end
+  end
 end

data/spec/limits_and_ordering_spec.rb

@@ -52,7 +52,7 @@ describe 'filter qualifiers' do
       before do
         Post.filter do
           with :published, true
-          limit(20, 10)
+          limit(10, 20)
         end.inspect
       end
 
@@ -168,7 +168,7 @@ describe 'filter qualifiers' do
       before do
         Post.filter do
           with(:published, false)
-          join(Comment, :inner) do
+          join(Comment, :join_type => :inner) do
             on(:id => :post_id)
           end
           order(Comment => :id)

data/spec/select_spec.rb

@@ -18,7 +18,7 @@ describe 'with custom selects for cases where DISTINCT is required' do
     it 'should put the distinct clause in the select' do
       [:left, :right].each do |join_type|
         Post.filter do
-          having(join_type, :comments).with(:offensive, true)
+          having(:comments, :join_type => join_type).with(:offensive, true)
         end.inspect rescue nil # required because sqlite doesn't support right joins
         Post.last_find[:select].should == %q(DISTINCT "posts".*)
       end
@@ -27,12 +27,10 @@ describe 'with custom selects for cases where DISTINCT is required' do
 
   describe 'with join types that do not require distinct' do
     it 'should not put the distinct clause in the select' do
-      [:inner].each do |join_type|
-        Post.filter do
-          having(join_type, :comments).with(:offensive, true)
-        end.inspect
-        Post.last_find[:select].should be_nil
-      end
+      Post.filter do
+        having(:comments, :join_type => :inner).with(:offensive, true)
+      end.inspect
+      Post.last_find[:select].should be_nil
     end
   end
 
@@ -40,7 +38,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, :comments).with(:offensive, true)
+          having(:comments, :join_type => :left).with(:offensive, true)
         end
       end.inspect
       Blog.last_find[:select].should == %q(DISTINCT "blogs".*)
@@ -50,9 +48,20 @@ 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, :comments).with(:offensive, true)
+        having(:comments, :join_type => :left).with(:offensive, true)
       end.count
       Post.last_find[:select].should == %q(DISTINCT "posts".id)
     end
   end
+
+  describe 'using the distinct method' do
+    it 'should always create a distinct query' do
+      Blog.filter do
+        with(:created_at).gt(1.day.ago)
+        having(:posts).with(:permalink, nil)
+        distinct
+      end.inspect
+      Blog.last_find[:select].should == %q(DISTINCT "blogs".*)
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: aub-record_filter
 version: !ruby/object:Gem::Version 
-  version: 0.9.7
+  version: 0.9.8
 platform: ruby
 authors: 
 - Aubrey Holland
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-03 00:00:00 -07:00
+date: 2009-06-04 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -27,6 +27,7 @@ files:
 - CHANGELOG
 - README.rdoc
 - Rakefile
+- TODO
 - VERSION.yml
 - config/roodi.yml
 - lib/record_filter.rb