activerecord 1.14.0 → 1.14.1

data/CHANGELOG

@@ -1,3 +1,58 @@
+*1.14.1* (April 6th, 2005)
+
+* Fix type_name_with_module to handle type names that begin with '::'. Closes #4614. [Nicholas Seckar]
+
+* Fixed that that multiparameter assignment doesn't work with aggregations (closes #4620) [Lars Pind]
+
+* Enable Limit/Offset in Calculations (closes #4558) [lmarlow@yahoo.com]
+
+* Fixed that loading including associations returns all results if Load IDs For Limited Eager Loading returns none (closes #4528) [Rick]
+
+* Fixed HasManyAssociation#find bugs when :finder_sql is set #4600 [lagroue@free.fr]
+
+* Allow AR::Base#respond_to? to behave when @attributes is nil [zenspider]
+
+* Support eager includes when going through a polymorphic has_many association. [Rick]
+
+* Added support for eagerly including polymorphic has_one associations. (closes #4525) [Rick]
+
+    class Post < ActiveRecord::Base
+      has_one :tagging, :as => :taggable
+    end
+    
+    Post.find :all, :include => :tagging
+
+* Added descriptive error messages for invalid has_many :through associations: going through :has_one or :has_and_belongs_to_many [Rick]
+
+* Added support for going through a polymorphic has_many association: (closes #4401) [Rick]
+
+    class PhotoCollection < ActiveRecord::Base
+      has_many :photos, :as => :photographic
+      belongs_to :firm
+    end
+     
+    class Firm < ActiveRecord::Base
+      has_many :photo_collections
+      has_many :photos, :through => :photo_collections
+    end
+
+* Multiple fixes and optimizations in PostgreSQL adapter, allowing ruby-postgres gem to work properly. [ruben.nine@gmail.com]
+
+* Fixed that AssociationCollection#delete_all should work even if the records of the association are not loaded yet. [Florian Weber]
+
+* Changed those private ActiveRecord methods to take optional third argument :auto instead of nil for performance optimizations.  (closes #4456) [Stefan]
+
+* Private ActiveRecord methods add_limit!, add_joins!, and add_conditions! take an OPTIONAL third argument 'scope' (closes #4456) [Rick]
+
+* DEPRECATED: Using additional attributes on has_and_belongs_to_many associations. Instead upgrade your association to be a real join model [DHH]
+
+* Fixed that records returned from has_and_belongs_to_many associations with additional attributes should be marked as read only (fixes #4512) [DHH]
+
+* Do not implicitly mark recordss of has_many :through as readonly but do mark habtm records as readonly (eventually only on join tables without rich attributes). [Marcel Mollina Jr.]
+
+* Fixed broken OCIAdapter #4457 [schoenm@earthlink.net]
+
+
 *1.14.0* (March 27th, 2005)
 
 * Replace 'rescue Object' with a finer grained rescue. Closes #4431. [Nicholas Seckar]
@@ -177,7 +232,7 @@
   
   ...and you can configure with:
   
-    topic.to_xml(:skip_instruct => true, :skip_attributes => [ :id, bonus_time, :written_on, replies_count ])
+    topic.to_xml(:skip_instruct => true, :except => [ :id, bonus_time, :written_on, replies_count ])
   
   ...that'll return:
   

data/lib/active_record/associations.rb

@@ -44,6 +44,18 @@ module ActiveRecord
     end
   end
 
+  class HasManyThroughSourceAssociationMacroError < ActiveRecordError #:nodoc
+    def initialize(reflection)
+      @reflection         = reflection
+      @through_reflection = reflection.through_reflection
+      @source_reflection  = reflection.source_reflection
+    end
+    
+    def message
+      "Invalid source reflection macro :#{@source_reflection.macro}#{" :through" if @source_reflection.options[:through]} for has_many #{@reflection.name.inspect}, :through => #{@through_reflection.name.inspect}.  Use :source to specify the source reflection."
+    end
+  end
+
   class EagerLoadPolymorphicError < ActiveRecordError #:nodoc:
     def initialize(reflection)
       @reflection = reflection
@@ -623,7 +635,7 @@ module ActiveRecord
       #   is used on the associate class (such as a Post class). You can also specify a custom counter cache column by given that
       #   name instead of a true/false value to this option (e.g., <tt>:counter_cache => :my_custom_counter</tt>.)
       # * <tt>:include</tt>  - specify second-order associations that should be eager loaded when this object is loaded.
-      # # <tt>:polymorphic</tt> - specify this association is a polymorphic association by passing true.
+      # * <tt>:polymorphic</tt> - specify this association is a polymorphic association by passing true.
       #
       # Option examples:
       #   belongs_to :firm, :foreign_key => "client_of"
@@ -698,11 +710,10 @@ module ActiveRecord
       # an option, it is guessed using the lexical order of the class names. So a join between Developer and Project
       # will give the default join table name of "developers_projects" because "D" outranks "P".
       #
-      # Any additional fields added to the join table will be placed as attributes when pulling records out through
-      # has_and_belongs_to_many associations. This is helpful when have information about the association itself
-      # that you want available on retrieval. Note that any fields in the join table will override matching field names
-      # in the two joined tables. As a consequence, having an "id" field in the join table usually has the undesirable
-      # result of clobbering the "id" fields in either of the other two tables.
+      # Deprecated: Any additional fields added to the join table will be placed as attributes when pulling records out through
+      # has_and_belongs_to_many associations. Records returned from join tables with additional attributes will be marked as
+      # ReadOnly (because we can't save changes to the additional attrbutes). It's strongly recommended that you upgrade any
+      # associations with attributes to a real join model (see introduction).
       #
       # Adds the following methods for retrieval and query.
       # +collection+ is replaced with the symbol passed as the first argument, so 
@@ -714,7 +725,7 @@ module ActiveRecord
       # * <tt>collection.push_with_attributes(object, join_attributes)</tt> - adds one to the collection by creating an association in the join table that
       #   also holds the attributes from <tt>join_attributes</tt> (should be a hash with the column names as keys). This can be used to have additional
       #   attributes on the join, which will be injected into the associated objects when they are retrieved through the collection.
-      #   (collection.concat_with_attributes is an alias to this method).
+      #   (collection.concat_with_attributes is an alias to this method). This method is now deprecated.
       # * <tt>collection.delete(object, ...)</tt> - removes one or more objects from the collection by removing their associations from the join table.  
       #   This does not destroy the objects.
       # * <tt>collection=objects</tt> - replaces the collections content by deleting and adding objects as appropriate.
@@ -951,14 +962,20 @@ module ActiveRecord
         end
         
         def count_with_associations(options = {})
-          join_dependency = JoinDependency.new(self, merge_includes(scope(:find, :include), options[:include]), options[:joins])
-          return count_by_sql(construct_counter_sql_with_included_associations(options, join_dependency))
+          catch :invalid_query do
+            join_dependency = JoinDependency.new(self, merge_includes(scope(:find, :include), options[:include]), options[:joins])
+            return count_by_sql(construct_counter_sql_with_included_associations(options, join_dependency))
+          end
+          0
         end
 
         def find_with_associations(options = {})
-          join_dependency = JoinDependency.new(self, merge_includes(scope(:find, :include), options[:include]), options[:joins])
-          rows = select_all_rows(options, join_dependency)
-          return join_dependency.instantiate(rows)
+          catch :invalid_query do
+            join_dependency = JoinDependency.new(self, merge_includes(scope(:find, :include), options[:include]), options[:joins])
+            rows = select_all_rows(options, join_dependency)
+            return join_dependency.instantiate(rows)
+          end
+          []
         end
 
         def configure_dependency_for_has_many(reflection)
@@ -1140,6 +1157,8 @@ module ActiveRecord
         def add_limited_ids_condition!(sql, options, join_dependency)
           unless (id_list = select_limited_ids_list(options, join_dependency)).empty?
             sql << "#{condition_word(sql)} #{table_name}.#{primary_key} IN (#{id_list}) "
+          else
+            throw :invalid_query
           end
         end
  
@@ -1381,7 +1400,7 @@ module ActiveRecord
               @aliased_prefix     = "t#{ join_dependency.joins.size }"
               @aliased_table_name = table_name # start with the table name
               @parent_table_name  = parent.active_record.table_name
-              
+
               if !parent.table_joins.blank? && parent.table_joins.to_s.downcase =~ %r{join(\s+\w+)?\s+#{aliased_table_name.downcase}\son}
                 join_dependency.table_aliases[aliased_table_name] += 1
               end
@@ -1434,24 +1453,38 @@ module ActiveRecord
                           aliased_table_name, primary_key, aliased_join_table_name, options[:foreign_key] || reflection.klass.to_s.classify.foreign_key
                         ]
                       else
-                        case source_reflection.macro
-                          when :belongs_to
-                            first_key  = primary_key
-                            second_key = options[:foreign_key] || klass.to_s.classify.foreign_key
-                          when :has_many
-                            first_key  = through_reflection.klass.to_s.classify.foreign_key
-                            second_key = options[:foreign_key] || primary_key
+                        if source_reflection.macro == :has_many && source_reflection.options[:as]
+                          " LEFT OUTER JOIN %s ON %s.%s = %s.%s "  % [
+                            table_alias_for(through_reflection.klass.table_name, aliased_join_table_name), aliased_join_table_name,
+                            through_reflection.primary_key_name,
+                            parent.aliased_table_name, parent.primary_key] +
+                          " LEFT OUTER JOIN %s ON %s.%s = %s.%s AND %s.%s = %s " % [
+                            table_name_and_alias,
+                            aliased_table_name, "#{source_reflection.options[:as]}_id", 
+                            aliased_join_table_name, options[:foreign_key] || primary_key,
+                            aliased_table_name, "#{source_reflection.options[:as]}_type", 
+                            klass.quote(source_reflection.active_record.base_class.name)
+                          ]
+                        else
+                          case source_reflection.macro
+                            when :belongs_to
+                              first_key  = primary_key
+                              second_key = options[:foreign_key] || klass.to_s.classify.foreign_key
+                            when :has_many
+                              first_key  = through_reflection.klass.to_s.classify.foreign_key
+                              second_key = options[:foreign_key] || primary_key
+                          end
+                          
+                          " LEFT OUTER JOIN %s ON %s.%s = %s.%s "  % [
+                            table_alias_for(through_reflection.klass.table_name, aliased_join_table_name), aliased_join_table_name,
+                            through_reflection.primary_key_name,
+                            parent.aliased_table_name, parent.primary_key] +
+                          " LEFT OUTER JOIN %s ON %s.%s = %s.%s " % [
+                            table_name_and_alias,
+                            aliased_table_name, first_key, 
+                            aliased_join_table_name, second_key
+                          ]
                         end
-
-                        " LEFT OUTER JOIN %s ON %s.%s = %s.%s "  % [
-                          table_alias_for(through_reflection.klass.table_name, aliased_join_table_name), aliased_join_table_name,
-                          through_reflection.primary_key_name,
-                          parent.aliased_table_name, parent.primary_key] +
-                        " LEFT OUTER JOIN %s ON %s.%s = %s.%s " % [
-                          table_name_and_alias,
-                          aliased_table_name, first_key, 
-                          aliased_join_table_name, second_key
-                        ]
                       end
                     
                     when reflection.macro == :has_many && reflection.options[:as]
@@ -1462,12 +1495,16 @@ module ActiveRecord
                         aliased_table_name, "#{reflection.options[:as]}_type",
                         klass.quote(parent.active_record.base_class.name)
                       ]
-                      
+                    when reflection.macro == :has_one && reflection.options[:as]
+                      " LEFT OUTER JOIN %s ON %s.%s = %s.%s AND %s.%s = %s " % [
+                        table_name_and_alias,
+                        aliased_table_name, "#{reflection.options[:as]}_id",
+                        parent.aliased_table_name, parent.primary_key,
+                        aliased_table_name, "#{reflection.options[:as]}_type",
+                        klass.quote(reflection.active_record.base_class.name)
+                      ]
                     else
-                      foreign_key = options[:foreign_key] || case reflection.macro
-                        when :has_many then reflection.active_record.to_s.classify
-                        when :has_one  then reflection.active_record.to_s
-                      end.foreign_key
+                      foreign_key = options[:foreign_key] || reflection.active_record.name.foreign_key
                       " LEFT OUTER JOIN %s ON %s.%s = %s.%s " % [
                         table_name_and_alias,
                         aliased_table_name, foreign_key,

data/lib/active_record/associations/association_collection.rb

@@ -37,6 +37,7 @@ module ActiveRecord
                       
       # Remove all records from this association
       def delete_all
+        load_target
         delete(@target)
         @target = []
       end

data/lib/active_record/associations/has_and_belongs_to_many_association.rb

@@ -40,8 +40,8 @@ module ActiveRecord
           end
 
           options[:conditions] = conditions
-          options[:joins] = @join_sql
-          options[:readonly] ||= false
+          options[:joins]      = @join_sql
+          options[:readonly]   = finding_with_ambigious_select?(options[:select])
 
           if options[:order] && @reflection.options[:order]
             options[:order] = "#{options[:order]}, #{@reflection.options[:order]}"
@@ -157,7 +157,13 @@ module ActiveRecord
 
           @join_sql = "INNER JOIN #{@reflection.options[:join_table]} ON #{@reflection.klass.table_name}.#{@reflection.klass.primary_key} = #{@reflection.options[:join_table]}.#{@reflection.association_foreign_key}"
         end
-        
+
+        # Join tables with additional columns on top of the two foreign keys must be considered ambigious unless a select
+        # clause has been explicitly defined. Otherwise you can get broken records back, if, say, the join column also has
+        # and id column, which will then overwrite the id column of the records coming back.
+        def finding_with_ambigious_select?(select_clause)
+          !select_clause && @owner.connection.columns(@reflection.options[:join_table], "Join Table Columns").size != 2
+        end
     end
   end
 end

data/lib/active_record/associations/has_many_association.rb

@@ -59,7 +59,7 @@ module ActiveRecord
           if ids.size == 1
             id = ids.first
             record = load_target.detect { |record| id == record.id }
-            expects_array? ? [record] : record
+            expects_array ? [ record ] : record
           else
             load_target.select { |record| ids.include?(record.id) }
           end

data/lib/active_record/associations/has_many_through_association.rb

@@ -63,17 +63,12 @@ module ActiveRecord
           )
         end
 
-        def construct_conditions          
+        def construct_conditions
           conditions = if @reflection.through_reflection.options[:as]
               "#{@reflection.through_reflection.table_name}.#{@reflection.through_reflection.options[:as]}_id = #{@owner.quoted_id} " + 
               "AND #{@reflection.through_reflection.table_name}.#{@reflection.through_reflection.options[:as]}_type = #{@owner.class.quote @owner.class.base_class.name.to_s}"
           else
-            case @reflection.source_reflection.macro
-              when :belongs_to, :has_many
-                "#{@reflection.through_reflection.table_name}.#{@reflection.through_reflection.primary_key_name} = #{@owner.quoted_id}"
-              else
-                raise ActiveRecordError, "Invalid source reflection macro :#{@reflection.source_reflection.macro} for has_many #{@reflection.name}, :through => #{@reflection.through_reflection.name}.  Use :source to specify the source reflection."
-            end
+            "#{@reflection.through_reflection.table_name}.#{@reflection.through_reflection.primary_key_name} = #{@owner.quoted_id}"
           end
           conditions << " AND (#{sql_conditions})" if sql_conditions
           
@@ -88,19 +83,27 @@ module ActiveRecord
           selected = custom_select || @reflection.options[:select] || "#{@reflection.table_name}.*"          
         end
         
-        def construct_joins(custom_joins = nil)
+        def construct_joins(custom_joins = nil)          
+          polymorphic_join = nil
           if @reflection.through_reflection.options[:as] || @reflection.source_reflection.macro == :belongs_to
             reflection_primary_key = @reflection.klass.primary_key
             source_primary_key     = @reflection.source_reflection.primary_key_name
           else
             reflection_primary_key = @reflection.source_reflection.primary_key_name
             source_primary_key     = @reflection.klass.primary_key
+            if @reflection.source_reflection.options[:as]
+              polymorphic_join = "AND %s.%s = %s" % [
+                @reflection.table_name, "#{@reflection.source_reflection.options[:as]}_type",
+                @owner.class.quote(@reflection.through_reflection.klass.name)
+              ]
+            end
           end
 
-          "INNER JOIN %s ON %s.%s = %s.%s #{@reflection.options[:joins]} #{custom_joins}" % [
+          "INNER JOIN %s ON %s.%s = %s.%s %s #{@reflection.options[:joins]} #{custom_joins}" % [
             @reflection.through_reflection.table_name,
             @reflection.table_name, reflection_primary_key,
-            @reflection.through_reflection.table_name, source_primary_key
+            @reflection.through_reflection.table_name, source_primary_key,
+            polymorphic_join
           ]
         end
         

data/lib/active_record/base.rb

@@ -850,7 +850,7 @@ module ActiveRecord #:nodoc:
                   (hash[method].keys + params.keys).uniq.each do |key|
                     merge = hash[method][key] && params[key] # merge if both scopes have the same key
                     if key == :conditions && merge
-                      hash[method][key] = [params[key], hash[method][key]].collect{|sql| "( %s )" % sanitize_sql(sql)}.join(" AND ")
+                      hash[method][key] = [params[key], hash[method][key]].collect{ |sql| "( %s )" % sanitize_sql(sql) }.join(" AND ")
                     elsif key == :include && merge
                       hash[method][key] = merge_includes(hash[method][key], params[key]).uniq
                     else
@@ -871,7 +871,7 @@ module ActiveRecord #:nodoc:
 
         begin
           yield
-        ensure 
+        ensure
           self.scoped_methods.pop
         end
       end
@@ -947,7 +947,7 @@ module ActiveRecord #:nodoc:
       
         def find_one(id, options)
           conditions = " AND (#{sanitize_sql(options[:conditions])})" if options[:conditions]
-          options    = options.merge :conditions => "#{table_name}.#{primary_key} = #{sanitize(id)}#{conditions}"
+          options.update :conditions => "#{table_name}.#{primary_key} = #{sanitize(id)}#{conditions}"
 
           if result = find_initial(options)
             result
@@ -959,7 +959,7 @@ module ActiveRecord #:nodoc:
         def find_some(ids, options)
           conditions = " AND (#{sanitize_sql(options[:conditions])})" if options[:conditions]
           ids_list   = ids.map { |id| sanitize(id) }.join(',')
-          options    = options.merge :conditions => "#{table_name}.#{primary_key} IN (#{ids_list})#{conditions}"
+          options.update :conditions => "#{table_name}.#{primary_key} IN (#{ids_list})#{conditions}"
 
           result = find_every(options)
 
@@ -1000,7 +1000,7 @@ module ActiveRecord #:nodoc:
         # Nest the type name in the same module as this class.
         # Bar is "MyApp::Business::Bar" relative to MyApp::Business::Foo
         def type_name_with_module(type_name)
-          "#{self.name.sub(/(::)?[^:]+$/, '')}#{$1}#{type_name}"
+          (/^::/ =~ type_name) ? type_name : "#{parent.name}::#{type_name}"
         end
 
         def construct_finder_sql(options)
@@ -1036,7 +1036,9 @@ module ActiveRecord #:nodoc:
           end
         end
 
-        def add_limit!(sql, options, scope)
+        # The optional scope argument is for the current :find scope.
+        def add_limit!(sql, options, scope = :auto)
+          scope = scope(:find) if :auto == scope
           if scope
             options[:limit]  ||= scope[:limit]
             options[:offset] ||= scope[:offset]
@@ -1044,13 +1046,17 @@ module ActiveRecord #:nodoc:
           connection.add_limit_offset!(sql, options)
         end
 
-        def add_joins!(sql, options, scope)
+        # The optional scope argument is for the current :find scope.
+        def add_joins!(sql, options, scope = :auto)
+          scope = scope(:find) if :auto == scope
           join = (scope && scope[:joins]) || options[:joins]
           sql << " #{join} " if join
         end
 
         # Adds a sanitized version of +conditions+ to the +sql+ string. Note that the passed-in +sql+ string is changed.
-        def add_conditions!(sql, conditions, scope)
+        # The optional scope argument is for the current :find scope.
+        def add_conditions!(sql, conditions, scope = :auto)
+          scope = scope(:find) if :auto == scope
           segments = []
           segments << sanitize_sql(scope[:conditions]) if scope && scope[:conditions]
           segments << sanitize_sql(conditions) unless conditions.nil?
@@ -1237,8 +1243,6 @@ module ActiveRecord #:nodoc:
           begin
             instance_eval(modularized_name)
           rescue NameError => e
-            first_module = modularized_name.split("::").first
-            raise unless e.to_s.include? first_module
             instance_eval(type_name)
           end
         end
@@ -1325,7 +1329,7 @@ module ActiveRecord #:nodoc:
           unless options.has_key?(:readonly)
             if scoped?(:find, :readonly)
               options[:readonly] = scope(:find, :readonly)
-            elsif !options[:joins].blank?
+            elsif !options[:joins].blank? && !options[:select]
               options[:readonly] = true
             end
           end
@@ -1583,7 +1587,9 @@ module ActiveRecord #:nodoc:
       # A Person object with a name attribute can ask person.respond_to?("name"), person.respond_to?("name="), and
       # person.respond_to?("name?") which will all return true.
       def respond_to?(method, include_priv = false)
-        if attr_name = self.class.column_methods_hash[method.to_sym]
+        if @attributes.nil?
+          return super 
+        elsif attr_name = self.class.column_methods_hash[method.to_sym]
           return true if @attributes.include?(attr_name) || attr_name == self.class.primary_key
           return false if self.class.read_methods.include?(attr_name)
         elsif @attributes.include?(method_name = method.to_s)
@@ -1636,10 +1642,10 @@ module ActiveRecord #:nodoc:
       #     <last-read type="date">2004-04-15</last-read>
       #   </topic>
       #
-      # This behaviour can be controlled with :skip_attributes and :skip_instruct 
+      # This behaviour can be controlled with :only, :except, and :skip_instruct 
       # for instance:
       #
-      #   topic.to_xml(:skip_instruct => true, :skip_attributes => [ :id, bonus_time, :written_on, replies_count ])
+      #   topic.to_xml(:skip_instruct => true, :except => [ :id, bonus_time, :written_on, replies_count ])
       #
       #   <topic>
       #     <title>The First Topic</title>
@@ -1982,7 +1988,7 @@ module ActiveRecord #:nodoc:
       def execute_callstack_for_multiparameter_attributes(callstack)
         errors = []
         callstack.each do |name, values|
-          klass = (self.class.reflect_on_aggregation(name) || column_for_attribute(name)).klass
+          klass = (self.class.reflect_on_aggregation(name.to_sym) || column_for_attribute(name)).klass
           if values.empty?
             send(name + "=", nil)
           else
@@ -2064,4 +2070,4 @@ module ActiveRecord #:nodoc:
         value
       end
   end
-end
+end

data/lib/active_record/calculations.rb

@@ -1,6 +1,6 @@
 module ActiveRecord
   module Calculations #:nodoc:
-    CALCULATIONS_OPTIONS = [:conditions, :joins, :order, :select, :group, :having, :distinct]
+    CALCULATIONS_OPTIONS = [:conditions, :joins, :order, :select, :group, :having, :distinct, :limit, :offset]
     def self.included(base)
       base.extend(ClassMethods)
     end
@@ -153,6 +153,7 @@ module ActiveRecord
           sql << " GROUP BY #{options[:group_field]}" if options[:group]
           sql << " HAVING #{options[:having]}" if options[:group] && options[:having]
           sql << " ORDER BY #{options[:order]}" if options[:order]
+          add_limit!(sql, options)
           sql.join
         end
 

data/lib/active_record/connection_adapters/oracle_adapter.rb

@@ -44,15 +44,11 @@ begin
       # Enable the id column to be bound into the sql later, by the adapter's insert method.
       # This is preferable to inserting the hard-coded value here, because the insert method
       # needs to know the id value explicitly.
-      def attributes_with_quotes_pre_oracle #:nodoc:
-        attributes_with_quotes
-      end
-        
-
-      def attributes_with_quotes(creating = true) #:nodoc:
-        aq = attributes_with_quotes_pre_oracle creating
+      alias :attributes_with_quotes_pre_oracle :attributes_with_quotes
+      def attributes_with_quotes(include_primary_key = true) #:nodoc:
+        aq = attributes_with_quotes_pre_oracle(include_primary_key)
         if connection.class == ConnectionAdapters::OracleAdapter
-          aq[self.class.primary_key] = ":id" if creating && aq[self.class.primary_key].nil?
+          aq[self.class.primary_key] = ":id" if include_primary_key && aq[self.class.primary_key].nil?
         end
         aq
       end
@@ -214,15 +210,17 @@ begin
         end
 
         def quote(value, column = nil) #:nodoc:
-          if column && column.type == :binary then %Q{empty_#{ column.sql_type }()}
-          else case value
-            when String       then %Q{'#{quote_string(value)}'}
-            when NilClass     then 'null'
-            when TrueClass    then '1'
-            when FalseClass   then '0'
-            when Numeric      then value.to_s
-            when Date, Time   then %Q{'#{value.strftime("%Y-%m-%d %H:%M:%S")}'}
-            else                   %Q{'#{quote_string(value.to_yaml)}'}
+          if column && column.type == :binary
+            %Q{empty_#{ column.sql_type rescue 'blob' }()}
+          else
+            case value
+            when String     : %Q{'#{quote_string(value)}'}
+            when NilClass   : 'null'
+            when TrueClass  : '1'
+            when FalseClass : '0'
+            when Numeric    : value.to_s
+            when Date, Time : %Q{'#{value.strftime("%Y-%m-%d %H:%M:%S")}'}
+            else              %Q{'#{quote_string(value.to_yaml)}'}
             end
           end
         end
@@ -360,7 +358,7 @@ begin
         end
 
         def columns(table_name, name = nil) #:nodoc:
-          table_info = @connection.object_info(table_name)
+          (owner, table_name) = @connection.describe(table_name)
 
           table_cols = %Q{
             select column_name, data_type, data_default, nullable,
@@ -369,13 +367,16 @@ begin
                                       null) as length,
                    decode(data_type, 'NUMBER', data_scale, null) as scale
               from all_tab_columns
-             where owner      = '#{table_info.schema}'
-               and table_name = '#{table_info.name}'
+             where owner      = '#{owner}'
+               and table_name = '#{table_name}'
              order by column_id
           }
 
           select_all(table_cols, name).map do |row|
-            row['data_default'].sub!(/^'(.*)'\s*$/, '\1') if row['data_default']
+            if row['data_default']
+              row['data_default'].sub!(/^(.*?)\s*$/, '\1')
+              row['data_default'].sub!(/^'(.*)'$/, '\1')
+            end
             OracleColumn.new(
               oracle_downcase(row['column_name']),
               row['data_default'],
@@ -389,7 +390,7 @@ begin
 
         def create_table(name, options = {}) #:nodoc:
           super(name, options)
-          execute "CREATE SEQUENCE #{name}_seq" unless options[:id] == false
+          execute "CREATE SEQUENCE #{name}_seq START WITH 10000" unless options[:id] == false
         end
 
         def rename_table(name, new_name) #:nodoc:
@@ -469,7 +470,7 @@ begin
         private
 
         def select(sql, name = nil)
-          cursor = log(sql, name) { @connection.exec sql }
+          cursor = execute(sql, name)
           cols = cursor.get_col_names.map { |x| oracle_downcase(x) }
           rows = []
 
@@ -535,30 +536,27 @@ begin
     # missing constant from oci8 < 0.1.14
     OCI_PTYPE_UNK = 0 unless defined?(OCI_PTYPE_UNK)
 
-    def object_info(name)
-      OraObject.new describe(name.to_s, OCI_PTYPE_UNK)
-    end
-
-    def describe(name, type)
+    # Uses the describeAny OCI call to find the target owner and table_name
+    # indicated by +name+, parsing through synonynms as necessary. Returns
+    # an array of [owner, table_name].
+    def describe(name)
       @desc ||= @@env.alloc(OCIDescribe)
       @desc.attrSet(OCI_ATTR_DESC_PUBLIC, -1) if VERSION >= '0.1.14'
-      @desc.describeAny(@svc, name, type)
-      @desc.attrGet(OCI_ATTR_PARAM)
-    end
-
-    class OraObject #:nodoc:
-      attr_reader :schema, :name
-      def initialize(info)
-        case info.attrGet(OCI_ATTR_PTYPE)
-        when OCI_PTYPE_TABLE, OCI_PTYPE_VIEW
-          @schema = info.attrGet(OCI_ATTR_OBJ_SCHEMA)
-          @name   = info.attrGet(OCI_ATTR_OBJ_NAME)
-        when OCI_PTYPE_SYN
-          @schema = info.attrGet(OCI_ATTR_SCHEMA_NAME)
-          @name   = info.attrGet(OCI_ATTR_NAME)
-        end
+      @desc.describeAny(@svc, name.to_s, OCI_PTYPE_UNK)
+      info = @desc.attrGet(OCI_ATTR_PARAM)
+
+      case info.attrGet(OCI_ATTR_PTYPE)
+      when OCI_PTYPE_TABLE, OCI_PTYPE_VIEW
+        owner      = info.attrGet(OCI_ATTR_OBJ_SCHEMA)
+        table_name = info.attrGet(OCI_ATTR_OBJ_NAME)
+        [owner, table_name]
+      when OCI_PTYPE_SYN
+        schema = info.attrGet(OCI_ATTR_SCHEMA_NAME)
+        name   = info.attrGet(OCI_ATTR_NAME)
+        describe(schema + '.' + name)
       end
     end
+
   end
 
 

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -24,6 +24,8 @@ module ActiveRecord
         PGconn.connect(host, port, "", "", database, username, password), logger, config
       )
 
+      PGconn.translate_results = false if PGconn.respond_to? :translate_results=
+
       pga.schema_search_path = config[:schema_search_path] || config[:schema_order]
 
       pga
@@ -63,8 +65,9 @@ module ActiveRecord
           @connection.query 'SELECT 1'
           true
         end
-      rescue PGError
-        false
+      # postgres-pr raises a NoMethodError when querying if no conn is available
+      rescue PGError, NoMethodError
+        false      
       end
 
       # Close then reopen the connection.
@@ -339,6 +342,8 @@ module ActiveRecord
 
       private
         BYTEA_COLUMN_TYPE_OID = 17
+        TIMESTAMPOID = 1114
+        TIMESTAMPTZOID = 1184
 
         def configure_connection
           if @config[:encoding]
@@ -355,7 +360,7 @@ module ActiveRecord
 
         def select(sql, name = nil)
           res = execute(sql, name)
-          results = res.result           
+          results = res.result
           rows = []
           if results.length > 0
             fields = res.fields
@@ -363,9 +368,14 @@ module ActiveRecord
               hashed_row = {}
               row.each_index do |cel_index|
                 column = row[cel_index]
-                if res.type(cel_index) == BYTEA_COLUMN_TYPE_OID
-                  column = unescape_bytea(column)
+                
+                case res.type(cel_index)
+                  when BYTEA_COLUMN_TYPE_OID
+                    column = unescape_bytea(column)
+                  when TIMESTAMPTZOID, TIMESTAMPOID
+                    column = cast_to_time(column)
                 end
+
                 hashed_row[fields[cel_index]] = column
               end
               rows << hashed_row
@@ -472,8 +482,8 @@ module ActiveRecord
           return "t" if value =~ /true/i
           return "f" if value =~ /false/i
           
-          # Char/String type values
-          return $1 if value =~ /^'(.*)'::(bpchar|text|character varying)$/
+          # Char/String/Bytea type values
+          return $1 if value =~ /^'(.*)'::(bpchar|text|character varying|bytea)$/
           
           # Numeric values
           return value if value =~ /^-?[0-9]+(\.[0-9]*)?/
@@ -485,6 +495,14 @@ module ActiveRecord
           # and we can't know the value of that, so return nil.
           return nil
         end
+
+        # Only needed for DateTime instances
+        def cast_to_time(value)
+          return value unless value.class == DateTime
+          v = value
+          time_array = [v.year, v.month, v.day, v.hour, v.min, v.sec]
+          Time.send(Base.default_timezone, *time_array) rescue nil
+        end
     end
   end
 end

data/lib/active_record/migration.rb

@@ -61,6 +61,7 @@ module ActiveRecord
   #   that can then add columns to it, following the same format as add_column. See example above. The options hash is for
   #   fragments like "DEFAULT CHARSET=UTF-8" that are appended to the create table definition.
   # * <tt>drop_table(name)</tt>: Drops the table called +name+.
+  # * <tt>rename_table(old_name, new_name)</tt>: Renames the table called +old_name+ to +new_name+.
   # * <tt>add_column(table_name, column_name, type, options)</tt>: Adds a new column to the table called +table_name+
   #   named +column_name+ specified to be one of the following types:
   #   :string, :text, :integer, :float, :datetime, :timestamp, :time, :date, :binary, :boolean. A default value can be specified

data/lib/active_record/reflection.rb

@@ -97,7 +97,7 @@ module ActiveRecord
     # Holds all the meta-data about an aggregation as it was specified in the Active Record class.
     class AggregateReflection < MacroReflection #:nodoc:
       def klass
-        @klass ||= Object.const_get(class_name)
+        @klass ||= Object.const_get(options[:class_name] || class_name)
       end
 
       private
@@ -174,7 +174,11 @@ module ActiveRecord
           end
           
           if source_reflection.options[:polymorphic]
-            raise HasManyThroughAssociationPolymorphicError.new(class_name, @reflection, source_reflection)
+            raise HasManyThroughAssociationPolymorphicError.new(class_name, self, source_reflection)
+          end
+          
+          unless [:belongs_to, :has_many].include?(source_reflection.macro) && source_reflection.options[:through].nil?
+            raise HasManyThroughSourceAssociationMacroError.new(self)
           end
         end
       end

data/lib/active_record/validations.rb

@@ -277,8 +277,8 @@ module ActiveRecord
       # Validates each attribute against a block.
       #
       #   class Person < ActiveRecord::Base
-      #     validates_each :first_name, :last_name do |record, attr|
-      #       record.errors.add attr, 'starts with z.' if attr[0] == ?z
+      #     validates_each :first_name, :last_name do |record, attr, value|
+      #       record.errors.add attr, 'starts with z.' if value[0] == ?z
       #     end
       #   end
       #

data/lib/active_record/version.rb

@@ -2,7 +2,7 @@ module ActiveRecord
   module VERSION #:nodoc:
     MAJOR = 1
     MINOR = 14
-    TINY  = 0
+    TINY  = 1
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/rakefile

@@ -106,7 +106,7 @@ spec = Gem::Specification.new do |s|
     s.files = s.files + Dir.glob( "#{dir}/**/*" ).delete_if { |item| item.include?( "\.svn" ) }
   end
   
-  s.add_dependency('activesupport', '= 1.3.0' + PKG_BUILD)
+  s.add_dependency('activesupport', '= 1.3.1' + PKG_BUILD)
 
   s.files.delete "test/fixtures/fixture_database.sqlite"
   s.files.delete "test/fixtures/fixture_database_2.sqlite"

data/test/adapter_test.rb

@@ -42,7 +42,7 @@ class AdapterTest < Test::Unit::TestCase
   
   def test_current_database
     if @connection.respond_to?(:current_database)
-      assert_equal "activerecord_unittest", @connection.current_database
+      assert_equal ENV['ARUNIT_DB_NAME'] || "activerecord_unittest", @connection.current_database
     end
   end
 

data/test/associations_go_eager_test.rb

@@ -138,6 +138,16 @@ class EagerAssociationTest < Test::Unit::TestCase
     assert_equal count, posts.size
   end
 
+  def test_eager_with_has_many_and_limit_ond_high_offset
+    posts = Post.find(:all, :include => [ :author, :comments ], :limit => 2, :offset => 10, :conditions => [ "authors.name = ?", 'David' ])
+    assert_equal 0, posts.size
+  end
+
+  def test_count_eager_with_has_many_and_limit_ond_high_offset
+    posts = Post.count(:all, :include => [ :author, :comments ], :limit => 2, :offset => 10, :conditions => [ "authors.name = ?", 'David' ])
+    assert_equal 0, posts
+  end
+
   def test_eager_with_has_many_and_limit_with_no_results
     posts = Post.find(:all, :include => [ :author, :comments ], :limit => 2, :conditions => "posts.title = 'magic forest'")
     assert_equal 0, posts.size

data/test/associations_join_model_test.rb

@@ -208,6 +208,14 @@ class AssociationsJoinModelTest < Test::Unit::TestCase
     end
   end
 
+  def test_include_polymorphic_has_one
+    post    = Post.find_by_id(posts(:welcome).id, :include => :tagging)
+    tagging = taggings(:welcome_general)
+    assert_no_queries do
+      assert_equal tagging, post.tagging
+    end
+  end
+
   def test_include_polymorphic_has_many_through
     posts           = Post.find(:all, :order => 'posts.id')
     posts_with_tags = Post.find(:all, :include => :tags, :order => 'posts.id')
@@ -295,6 +303,30 @@ class AssociationsJoinModelTest < Test::Unit::TestCase
     assert_equal comments(:more_greetings), authors(:david).comments.find(2)
   end
 
+  def test_has_many_through_polymorphic_has_one
+    assert_raise(ActiveRecord::HasManyThroughSourceAssociationMacroError) { authors(:david).tagging }
+  end
+
+  def test_has_many_through_polymorphic_has_many
+    assert_equal [taggings(:welcome_general), taggings(:thinking_general)], authors(:david).taggings.uniq.sort_by { |t| t.id }
+  end
+
+  def test_include_has_many_through_polymorphic_has_many
+    author            = Author.find_by_id(authors(:david).id, :include => :taggings)
+    expected_taggings = [taggings(:welcome_general), taggings(:thinking_general)]
+    assert_no_queries do
+      assert_equal expected_taggings, author.taggings.uniq.sort_by { |t| t.id }
+    end
+  end
+
+  def test_has_many_through_has_many_through
+    assert_raise(ActiveRecord::HasManyThroughSourceAssociationMacroError) { authors(:david).tags }
+  end
+
+  def test_has_many_through_habtm
+    assert_raise(ActiveRecord::HasManyThroughSourceAssociationMacroError) { authors(:david).post_categories }
+  end
+
   def test_eager_load_has_many_through_has_many
     author = Author.find :first, :conditions => ['name = ?', 'David'], :include => :comments, :order => 'comments.id'
     SpecialComment.new; VerySpecialComment.new

data/test/associations_test.rb

@@ -7,6 +7,7 @@ require 'fixtures/reply'
 require 'fixtures/computer'
 require 'fixtures/customer'
 require 'fixtures/order'
+require 'fixtures/category'
 require 'fixtures/post'
 require 'fixtures/author'
 
@@ -549,6 +550,25 @@ class HasManyAssociationsTest < Test::Unit::TestCase
     assert_equal 0, companies(:first_firm).clients_of_firm.size
     assert_equal 0, companies(:first_firm).clients_of_firm(true).size
   end
+  
+  def test_delete_all
+    force_signal37_to_load_all_clients_of_firm
+    companies(:first_firm).clients_of_firm.create("name" => "Another Client")
+    assert_equal 2, companies(:first_firm).clients_of_firm.size
+    companies(:first_firm).clients_of_firm.delete_all
+    assert_equal 0, companies(:first_firm).clients_of_firm.size
+    assert_equal 0, companies(:first_firm).clients_of_firm(true).size
+  end
+
+  def test_delete_all_with_not_yet_loaded_association_collection
+    force_signal37_to_load_all_clients_of_firm
+    companies(:first_firm).clients_of_firm.create("name" => "Another Client")
+    assert_equal 2, companies(:first_firm).clients_of_firm.size
+    companies(:first_firm).clients_of_firm.reset
+    companies(:first_firm).clients_of_firm.delete_all
+    assert_equal 0, companies(:first_firm).clients_of_firm.size
+    assert_equal 0, companies(:first_firm).clients_of_firm(true).size
+  end
 
   def test_clearing_an_association_collection
     firm = companies(:first_firm)
@@ -1080,7 +1100,7 @@ end
 
 
 class HasAndBelongsToManyAssociationsTest < Test::Unit::TestCase
-  fixtures :accounts, :companies, :developers, :projects, :developers_projects
+  fixtures :accounts, :companies, :categories, :posts, :categories_posts, :developers, :projects, :developers_projects
   
   def test_has_and_belongs_to_many
     david = Developer.find(1)
@@ -1469,6 +1489,25 @@ class HasAndBelongsToManyAssociationsTest < Test::Unit::TestCase
       AND developer_id = #{developer.id}
     end_sql
   end
+  
+  def test_updating_attributes_on_non_rich_associations
+    welcome = categories(:technology).posts.first
+    welcome.title = "Something else"
+    assert welcome.save!
+  end
+  
+  def test_updating_attributes_on_rich_associations
+    david = projects(:action_controller).developers.first
+    david.name = "DHH"
+    assert_raises(ActiveRecord::ReadOnlyRecord) { david.save! }
+  end
+
+  
+  def test_updating_attributes_on_rich_associations_with_limited_find
+    david = projects(:action_controller).developers.find(:all, :select => "developers.*").first
+    david.name = "DHH"
+    assert david.save!
+  end
 
   def test_join_table_alias
     assert_equal 3, Developer.find(:all, :include => {:projects => :developers}, :conditions => 'developers_projects_join.joined_on IS NOT NULL').size

data/test/base_test.rb

@@ -2,6 +2,7 @@ require 'abstract_unit'
 require 'fixtures/topic'
 require 'fixtures/reply'
 require 'fixtures/company'
+require 'fixtures/customer'
 require 'fixtures/developer'
 require 'fixtures/project'
 require 'fixtures/default'
@@ -721,6 +722,14 @@ class BasicsTest < Test::Unit::TestCase
     task.attributes = attributes
     assert_equal time, task.starting
   end
+  
+  def test_multiparameter_assignment_of_aggregation
+    customer = Customer.new
+    address = Address.new("The Street", "The City", "The Country")
+    attributes = { "address(1)" => address.street, "address(2)" => address.city, "address(3)" => address.country }
+    customer.attributes = attributes
+    assert_equal address, customer.address
+  end
 
   def test_attributes_on_dummy_time
     # Oracle and SQL Server do not have a TIME datatype.
@@ -1257,6 +1266,11 @@ class BasicsTest < Test::Unit::TestCase
     assert_equal(%w( title ), topics(:first).attributes(:only => :title).keys)
     assert_equal(%w( title author_name type id approved ), topics(:first).attributes(:only => [ :title, :id, :type, :approved, :author_name ]).keys)
   end
+  
+  def test_type_name_with_module_should_handle_beginning
+    assert_equal 'ActiveRecord::Person', ActiveRecord::Base.send(:type_name_with_module, 'Person')
+    assert_equal '::Person', ActiveRecord::Base.send(:type_name_with_module, '::Person')
+  end
 
   # FIXME: this test ought to run, but it needs to run sandboxed so that it
   # doesn't b0rk the current test environment by undefing everything.

data/test/calculations_test.rb

@@ -48,6 +48,18 @@ class CalculationsTest < Test::Unit::TestCase
     assert_equal [6, 2, 1], c.keys.compact
   end
 
+  def test_should_limit_calculation
+    c = Account.sum(:credit_limit, :conditions => "firm_id IS NOT NULL",
+                    :group => :firm_id, :order => "firm_id", :limit => 2)
+    assert_equal [1, 2], c.keys.compact
+  end
+
+  def test_should_limit_calculation_with_offset
+    c = Account.sum(:credit_limit, :conditions => "firm_id IS NOT NULL",
+                    :group => :firm_id, :order => "firm_id", :limit => 2, :offset => 1)
+    assert_equal [2, 6], c.keys.compact
+  end
+
   def test_should_group_by_summed_field_having_condition
     c = Account.sum(:credit_limit, :group => :firm_id, 
                                    :having => 'sum(credit_limit) > 50')

data/test/connections/native_oracle/connection.rb

@@ -6,7 +6,7 @@ ActiveRecord::Base.logger = Logger.new STDOUT
 ActiveRecord::Base.logger.level = Logger::WARN
 
 # Set these to your database connection strings
-db = 'activerecord_unit_tests'
+db = ENV['ARUNIT_DB'] || 'activerecord_unittest'
 
 ActiveRecord::Base.establish_connection(
   :adapter  => 'oracle',

data/test/fixtures/author.rb

@@ -31,6 +31,11 @@ class Author < ActiveRecord::Base
   has_many :author_favorites
   has_many :favorite_authors, :through => :author_favorites, :order => 'name'
 
+  has_many :tagging,  :through => :posts # through polymorphic has_one
+  has_many :taggings, :through => :posts, :source => :taggings # through polymorphic has_many
+  has_many :tags,     :through => :posts # through has_many :through
+  has_many :post_categories, :through => :posts, :source => :categories
+
   belongs_to :author_address
 
   attr_accessor :post_log

data/test/fixtures/customer.rb

@@ -14,6 +14,10 @@ class Address
   def close_to?(other_address)
     city == other_address.city && country == other_address.country
   end
+
+  def ==(other)
+    other.is_a?(self.class) && other.street == street && other.city == city && other.country == country
+  end  
 end
 
 class Money

data/test/fixtures/tag.rb

@@ -1,5 +1,5 @@
 class Tag < ActiveRecord::Base
-  has_many :taggings,  :as => :taggable
+  has_many :taggings
   has_many :taggables, :through => :taggings
-  has_one  :tagging,   :as => :taggable
+  has_one  :tagging
 end

data/test/migration_test.rb

@@ -257,8 +257,8 @@ if ActiveRecord::Base.connection.supports_migrations?
 
         assert_nothing_raised do
           if current_adapter?(:OracleAdapter)
-            # Oracle requires the explicit sequence for the pk
-            ActiveRecord::Base.connection.execute "INSERT INTO octopi (id, url) VALUES (octopi_seq.nextval, 'http://www.foreverflying.com/octopus-black7.jpg')"
+            # Oracle requires the explicit sequence value for the pk
+            ActiveRecord::Base.connection.execute "INSERT INTO octopi (id, url) VALUES (1, 'http://www.foreverflying.com/octopus-black7.jpg')"
           else
             ActiveRecord::Base.connection.execute "INSERT INTO octopi (url) VALUES ('http://www.foreverflying.com/octopus-black7.jpg')"
           end
@@ -466,9 +466,13 @@ if ActiveRecord::Base.connection.supports_migrations?
       
       columns = Person.connection.columns(:binary_testings)
       data_column = columns.detect { |c| c.name == "data" }
-      
-      assert_equal "", data_column.default
-      
+
+      if current_adapter?(:OracleAdapter)
+        assert_equal "empty_blob()", data_column.default
+      else
+        assert_equal "", data_column.default
+      end
+
       Person.connection.drop_table :binary_testings rescue nil
     end
 

data/test/readonly_test.rb

@@ -3,6 +3,8 @@ require 'fixtures/post'
 require 'fixtures/comment'
 require 'fixtures/developer'
 require 'fixtures/project'
+require 'fixtures/reader'
+require 'fixtures/person'
 
 # Dummy class methods to test implicit association scoping.
 def Comment.foo() find :first end
@@ -50,19 +52,23 @@ class ReadOnlyTest < Test::Unit::TestCase
   def test_habtm_find_readonly
     dev = Developer.find(1)
     assert !dev.projects.empty?
-    dev.projects.each { |p| assert !p.readonly? }
-    dev.projects.find(:all) { |p| assert !p.readonly? }
-    dev.projects.find(:all, :readonly => true) { |p| assert p.readonly? }
+    assert dev.projects.all?(&:readonly?)
+    assert dev.projects.find(:all).all?(&:readonly?)
+    assert dev.projects.find(:all, :readonly => true).all?(&:readonly?)
   end
 
   def test_has_many_find_readonly
     post = Post.find(1)
     assert !post.comments.empty?
-    post.comments.each { |r| assert !r.readonly? }
-    post.comments.find(:all) { |r| assert !r.readonly? }
-    post.comments.find(:all, :readonly => true) { |r| assert r.readonly? }
+    assert !post.comments.any?(&:readonly?)
+    assert !post.comments.find(:all).any?(&:readonly?)
+    assert post.comments.find(:all, :readonly => true).all?(&:readonly?)
   end
 
+  def test_has_many_with_through_is_not_implicitly_marked_readonly
+    assert people = Post.find(1).people
+    assert !people.any?(&:readonly?)
+  end
 
   def test_readonly_scoping
     Post.with_scope(:find => { :conditions => '1=1' }) do 

data/test/reflection_test.rb

@@ -74,6 +74,8 @@ class ReflectionTest < Test::Unit::TestCase
     assert_equal reflection_for_address, Customer.reflect_on_aggregation(:address)
 
     assert_equal Address, Customer.reflect_on_aggregation(:address).klass
+    
+    assert_equal Money, Customer.reflect_on_aggregation(:balance).klass
   end
 
   def test_has_many_reflection

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: activerecord
 version: !ruby/object:Gem::Version 
-  version: 1.14.0
-date: 2006-03-27 00:00:00 -06:00
+  version: 1.14.1
+date: 2006-04-06 00:00:00 -05:00
 summary: Implements the ActiveRecord pattern for ORM.
 require_paths: 
 - lib
@@ -196,6 +196,9 @@ files:
 - test/fixtures/developers_projects.yml
 - test/fixtures/entrant.rb
 - test/fixtures/entrants.yml
+- test/fixtures/fixture_database.sqlite
+- test/fixtures/fixture_database.sqlite3
+- test/fixtures/fixture_database_2.sqlite
 - test/fixtures/fk_test_has_fk.yml
 - test/fixtures/fk_test_has_pk.yml
 - test/fixtures/flowers.jpg
@@ -320,5 +323,5 @@ dependencies:
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        version: 1.3.0
+        version: 1.3.1
     version: