activerecord 5.1.0.beta1 → 5.1.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bd07c0f82a72c8cbf4c63768b7dbe9616b603c33
-  data.tar.gz: 4ad0f6c9b287b3a286f9c6663fd95d73592c33bf
+  metadata.gz: 56124430c2b0a3ea8b0d63b972a18f7818d5f044
+  data.tar.gz: 2b59776ce9564b180d0107fd7acd2155519d3058
 SHA512:
-  metadata.gz: 2fa5d70bb93030107254cf60cafa091b242b721517306afb16c4168cee02a989419a75fc84c774ab1ca8aaa01f639daf12d9e4137bcc3edc4fa48a9120fd373b
-  data.tar.gz: 912c2dfb632f8d0488c9cf3f06cf0b9f5d2a8dee2a0b26416b60c06016112383bf248a5ad1d2bdda082f3a3365ebd944b80e1484761b1d415814aba11e8b6b39
+  metadata.gz: 06e06443ed8dc3bfb78b8685ac892b032f065d06712570ba8c318f670f2b489efc2b2c2500fb68eea55d661077a1b626aa6135413b84d1e7ee18909dadbbc3d3
+  data.tar.gz: d37ce0bce1c266f7b5c283d203fc3466478a572067b104dd239d528c33cc50929ed8b7bee61365e00eb0e051081741ff014f1ead3983fbe1d26a40321a861d53

data/CHANGELOG.md

@@ -1,3 +1,95 @@
+## Rails 5.1.0.rc1 (March 20, 2017) ##
+
+*   Remove comments from structure.sql when using postgresql adapter to avoid
+    version-specific parts of the file.
+
+    Fixes #28153.
+
+    *Ari Pollak*
+
+*   Add `:default` option to `belongs_to`.
+
+    Use it to specify that an association should be initialized with a particular
+    record before validation. For example:
+
+        # Before
+        belongs_to :account
+        before_validation -> { self.account ||= Current.account }
+
+        # After
+        belongs_to :account, default: -> { Current.account }
+
+    *George Claghorn*
+
+*   Deprecate `Migrator.schema_migrations_table_name`.
+
+    *Ryuta Kamizono*
+
+*   Fix select with block doesn't return newly built records in has_many association.
+
+    Fixes #28348.
+
+    *Ryuta Kamizono*
+
+*   Check whether `Rails.application` defined before calling it
+
+    In #27674 we changed the migration generator to generate migrations at the
+    path defined in `Rails.application.config.paths` however the code checked
+    for the presence of the `Rails` constant but not the `Rails.application`
+    method which caused problems when using Active Record and generators outside
+    of the context of a Rails application.
+
+    Fixes #28325.
+
+    *Andrew White*
+
+*   Fix `deserialize` with JSON array.
+
+    Fixes #28285.
+
+    *Ryuta Kamizono*
+
+*   Fix `rake db:schema:load` with subdirectories.
+
+    *Ryuta Kamizono*
+
+*   Fix `rake db:migrate:status` with subdirectories.
+
+    *Ryuta Kamizono*
+
+*   Don't share options between reference id and type columns
+
+    When using a polymorphic reference column in a migration, sharing options
+    between the two columns doesn't make sense since they are different types.
+    The `reference_id` column is usually an integer and the `reference_type`
+    column a string so options like `unsigned: true` will result in an invalid
+    table definition.
+
+    *Ryuta Kamizono*
+
+*   Use `max_identifier_length` for `index_name_length` in PostgreSQL adapter.
+
+    *Ryuta Kamizono*
+
+*   Deprecate `supports_migrations?` on connection adapters.
+
+    *Ryuta Kamizono*
+
+*   Fix regression of #1969 with SELECT aliases in HAVING clause.
+
+    *Eugene Kenny*
+
+*   Deprecate using `#quoted_id` in quoting.
+
+    *Ryuta Kamizono*
+
+*   Fix `wait_timeout` to configurable for mysql2 adapter.
+
+    Fixes #26556.
+
+    *Ryuta Kamizono*
+
+
 ## Rails 5.1.0.beta1 (February 23, 2017) ##
 
 *   Correctly dump native timestamp types for MySQL.
@@ -426,11 +518,6 @@
 
     *Prathamesh Sonpatki*
 
-*   Optimistic locking: Added ability to update `locking_column` value.
-    Ignore optimistic locking if trying to update with new `locking_column` value.
-
-    *bogdanvlviv*
-
 *   Fixed: Optimistic locking does not work well with `null` in the database.
 
     Fixes #26024.
@@ -664,7 +751,7 @@
 
     *Johannes Opper*
 
-*   Introduce `ActiveRecord::TransactionSerializationError` for catching
+*   Introduce new Active Record transaction error classes for catching
     transaction serialization failures or deadlocks.
 
     *Erol Fornoles*

data/lib/active_record/associations.rb

@@ -1647,6 +1647,9 @@ module ActiveRecord
         #   +:inverse_of+ to avoid an extra query during validation.
         #   NOTE: <tt>required</tt> is set to <tt>true</tt> by default and is deprecated. If
         #   you don't want to have association presence validated, use <tt>optional: true</tt>.
+        # [:default]
+        #   Provide a callable (i.e. proc or lambda) to specify that the association should
+        #   be initialized with a particular record before validation. 
         #
         # Option examples:
         #   belongs_to :firm, foreign_key: "client_of"
@@ -1660,6 +1663,7 @@ module ActiveRecord
         #   belongs_to :comment, touch: true
         #   belongs_to :company, touch: :employees_last_updated_at
         #   belongs_to :user, optional: true
+        #   belongs_to :account, default: -> { company.account }
         def belongs_to(name, scope = nil, options = {})
           reflection = Builder::BelongsTo.build(self, name, scope, options)
           Reflection.add_reflection self, name, reflection

data/lib/active_record/associations/association_scope.rb

@@ -25,7 +25,7 @@ module ActiveRecord
         chain_head, chain_tail = get_chain(reflection, association, alias_tracker)
 
         scope.extending! Array(reflection.options[:extend])
-        add_constraints(scope, owner, klass, reflection, chain_head, chain_tail)
+        add_constraints(scope, owner, reflection, chain_head, chain_tail)
       end
 
       def join_type
@@ -60,8 +60,8 @@ module ActiveRecord
           table.create_join(table, table.create_on(constraint), join_type)
         end
 
-        def last_chain_scope(scope, table, reflection, owner, association_klass)
-          join_keys = reflection.join_keys(association_klass)
+        def last_chain_scope(scope, table, reflection, owner)
+          join_keys = reflection.join_keys
           key = join_keys.key
           foreign_key = join_keys.foreign_key
 
@@ -80,8 +80,8 @@ module ActiveRecord
           value_transformation.call(value)
         end
 
-        def next_chain_scope(scope, table, reflection, association_klass, foreign_table, next_reflection)
-          join_keys = reflection.join_keys(association_klass)
+        def next_chain_scope(scope, table, reflection, foreign_table, next_reflection)
+          join_keys = reflection.join_keys
           key = join_keys.key
           foreign_key = join_keys.foreign_key
 
@@ -120,10 +120,10 @@ module ActiveRecord
           [runtime_reflection, previous_reflection]
         end
 
-        def add_constraints(scope, owner, association_klass, refl, chain_head, chain_tail)
+        def add_constraints(scope, owner, refl, chain_head, chain_tail)
           owner_reflection = chain_tail
           table = owner_reflection.alias_name
-          scope = last_chain_scope(scope, table, owner_reflection, owner, association_klass)
+          scope = last_chain_scope(scope, table, owner_reflection, owner)
 
           reflection = chain_head
           while reflection
@@ -132,7 +132,7 @@ module ActiveRecord
 
             unless reflection == chain_tail
               foreign_table = next_reflection.alias_name
-              scope = next_chain_scope(scope, table, reflection, association_klass, foreign_table, next_reflection)
+              scope = next_chain_scope(scope, table, reflection, foreign_table, next_reflection)
             end
 
             # Exclude the scope of the association itself, because that

data/lib/active_record/associations/belongs_to_association.rb

@@ -21,6 +21,10 @@ module ActiveRecord
         self.target = record
       end
 
+      def default(&block)
+        writer(instance_exec(&block)) if reader.nil?
+      end
+
       def reset
         super
         @updated = false

data/lib/active_record/associations/builder/belongs_to.rb

@@ -5,7 +5,7 @@ module ActiveRecord::Associations::Builder # :nodoc:
     end
 
     def self.valid_options(options)
-      super + [:polymorphic, :touch, :counter_cache, :optional]
+      super + [:polymorphic, :touch, :counter_cache, :optional, :default]
     end
 
     def self.valid_dependent_options
@@ -16,6 +16,7 @@ module ActiveRecord::Associations::Builder # :nodoc:
       super
       add_counter_cache_callbacks(model, reflection) if reflection.options[:counter_cache]
       add_touch_callbacks(model, reflection)         if reflection.options[:touch]
+      add_default_callbacks(model, reflection)       if reflection.options[:default]
     end
 
     def self.define_accessors(mixin, reflection)
@@ -118,6 +119,12 @@ module ActiveRecord::Associations::Builder # :nodoc:
       model.after_destroy callback.(:changes_to_save)
     end
 
+    def self.add_default_callbacks(model, reflection)
+      model.before_validation lambda { |o|
+        o.association(reflection.name).default(&reflection.options[:default])
+      }
+    end
+
     def self.add_destroy_callbacks(model, reflection)
       model.after_destroy lambda { |o| o.association(reflection.name).handle_dependency }
     end

data/lib/active_record/associations/collection_proxy.rb

@@ -78,7 +78,7 @@ module ActiveRecord
       #   #      #<Pet id: nil, name: "Choo-Choo">
       #   #    ]
       #
-      #   person.pets.select(:id, :name )
+      #   person.pets.select(:id, :name)
       #   # => [
       #   #      #<Pet id: 1, name: "Fancy-Fancy">,
       #   #      #<Pet id: 2, name: "Spook">,
@@ -1121,7 +1121,7 @@ module ActiveRecord
         SpawnMethods,
       ].flat_map { |klass|
         klass.public_instance_methods(false)
-      } - self.public_instance_methods(false) + [:scoping]
+      } - self.public_instance_methods(false) - [:select] + [:scoping]
 
       delegate(*delegate_methods, to: :scope)
 
@@ -1154,8 +1154,9 @@ module ActiveRecord
         end
 
         def method_missing(method, *args, &block)
-          if scope.respond_to?(method)
-            scope.public_send(method, *args, &block)
+          if scope.respond_to?(method) && scope.extending_values.any?
+            extend(*scope.extending_values)
+            public_send(method, *args, &block)
           else
             super
           end

data/lib/active_record/associations/join_dependency.rb

@@ -171,7 +171,7 @@ module ActiveRecord
           chain         = child.reflection.chain
           foreign_table = parent.table
           foreign_klass = parent.base_klass
-          child.join_constraints(foreign_table, foreign_klass, child, join_type, tables, chain)
+          child.join_constraints(foreign_table, foreign_klass, join_type, tables, chain)
         end
 
         def make_outer_joins(parent, child)

data/lib/active_record/associations/join_dependency/join_association.rb

@@ -23,7 +23,7 @@ module ActiveRecord
 
         JoinInformation = Struct.new :joins, :binds
 
-        def join_constraints(foreign_table, foreign_klass, node, join_type, tables, chain)
+        def join_constraints(foreign_table, foreign_klass, join_type, tables, chain)
           joins         = []
           binds         = []
           tables        = tables.reverse
@@ -34,35 +34,16 @@ module ActiveRecord
             table = tables.shift
             klass = reflection.klass
 
-            join_keys   = reflection.join_keys(klass)
+            join_keys   = reflection.join_keys
             key         = join_keys.key
             foreign_key = join_keys.foreign_key
 
             constraint = build_constraint(klass, table, key, foreign_table, foreign_key)
 
             predicate_builder = PredicateBuilder.new(TableMetadata.new(klass, table))
-            scope_chain_items = reflection.scopes.map do |item|
-              if item.is_a?(Relation)
-                item
-              else
-                ActiveRecord::Relation.create(klass, table, predicate_builder)
-                  .instance_exec(node, &item)
-              end
-            end
+            scope_chain_items = reflection.join_scopes(table, predicate_builder)
+            klass_scope       = reflection.klass_join_scope(table, predicate_builder)
 
-            klass_scope =
-              if klass.current_scope
-                klass.current_scope.clone.tap { |scope|
-                  scope.joins_values = []
-                }
-              else
-                relation = ActiveRecord::Relation.create(
-                  klass,
-                  table,
-                  predicate_builder,
-                )
-                klass.send(:build_default_scope, relation)
-              end
             scope_chain_items.concat [klass_scope].compact
 
             rel = scope_chain_items.inject(scope_chain_items.shift) do |left, right|

data/lib/active_record/attribute_methods/dirty.rb

@@ -50,7 +50,7 @@ module ActiveRecord
         super.tap do
           @previous_mutation_tracker = nil
           clear_mutation_trackers
-          @changed_attributes = HashWithIndifferentAccess.new
+          @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
         end
       end
 
@@ -70,13 +70,13 @@ module ActiveRecord
 
       def changes_applied
         @previous_mutation_tracker = mutation_tracker
-        @changed_attributes = HashWithIndifferentAccess.new
+        @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
         clear_mutation_trackers
       end
 
       def clear_changes_information
         @previous_mutation_tracker = nil
-        @changed_attributes = HashWithIndifferentAccess.new
+        @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
         forget_attribute_assignments
         clear_mutation_trackers
       end

data/lib/active_record/connection_adapters/abstract/quoting.rb

@@ -7,8 +7,13 @@ module ActiveRecord
       # Quotes the column value to help prevent
       # {SQL injection attacks}[http://en.wikipedia.org/wiki/SQL_injection].
       def quote(value)
-        # records are quoted as their primary key
-        return value.quoted_id if value.respond_to?(:quoted_id)
+        value = id_value_for_database(value) if value.is_a?(Base)
+
+        if value.respond_to?(:quoted_id)
+          ActiveSupport::Deprecation.warn \
+            "Using #quoted_id is deprecated and will be removed in Rails 5.2."
+          return value.quoted_id
+        end
 
         _quote(value)
       end
@@ -17,6 +22,8 @@ module ActiveRecord
       # SQLite does not understand dates, so this method will convert a Date
       # to a String.
       def type_cast(value, column = nil)
+        value = id_value_for_database(value) if value.is_a?(Base)
+
         if value.respond_to?(:quoted_id) && value.respond_to?(:id)
           return value.id
         end
@@ -148,7 +155,17 @@ module ActiveRecord
       private
 
         def type_casted_binds(binds)
-          binds.map { |attr| type_cast(attr.value_for_database) }
+          if binds.first.is_a?(Array)
+            binds.map { |column, value| type_cast(value, column) }
+          else
+            binds.map { |attr| type_cast(attr.value_for_database) }
+          end
+        end
+
+        def id_value_for_database(value)
+          if primary_key = value.class.primary_key
+            value.instance_variable_get(:@attributes)[primary_key].value_for_database
+          end
         end
 
         def types_which_need_no_typecasting

data/lib/active_record/connection_adapters/abstract/schema_definitions.rb

@@ -116,16 +116,12 @@ module ActiveRecord
 
       private
 
-        def as_options(value, default = {})
-          if value.is_a?(Hash)
-            value
-          else
-            default
-          end
+        def as_options(value)
+          value.is_a?(Hash) ? value : {}
         end
 
         def polymorphic_options
-          as_options(polymorphic, options)
+          as_options(polymorphic)
         end
 
         def index_options

data/lib/active_record/connection_adapters/abstract/schema_statements.rb

@@ -31,6 +31,8 @@ module ActiveRecord
       # Returns the relation names useable to back Active Record models.
       # For most adapters this means all #tables and #views.
       def data_sources
+        select_values(data_source_sql, "SCHEMA")
+      rescue NotImplementedError
         tables | views
       end
 
@@ -39,12 +41,14 @@ module ActiveRecord
       #   data_source_exists?(:ebooks)
       #
       def data_source_exists?(name)
+        select_values(data_source_sql(name), "SCHEMA").any? if name.present?
+      rescue NotImplementedError
         data_sources.include?(name.to_s)
       end
 
       # Returns an array of table names defined in the database.
       def tables
-        raise NotImplementedError, "#tables is not implemented"
+        select_values(data_source_sql(type: "BASE TABLE"), "SCHEMA")
       end
 
       # Checks to see if the table +table_name+ exists on the database.
@@ -52,12 +56,14 @@ module ActiveRecord
       #   table_exists?(:developers)
       #
       def table_exists?(table_name)
+        select_values(data_source_sql(table_name, type: "BASE TABLE"), "SCHEMA").any? if table_name.present?
+      rescue NotImplementedError
         tables.include?(table_name.to_s)
       end
 
       # Returns an array of view names defined in the database.
       def views
-        raise NotImplementedError, "#views is not implemented"
+        select_values(data_source_sql(type: "VIEW"), "SCHEMA")
       end
 
       # Checks to see if the view +view_name+ exists on the database.
@@ -65,6 +71,8 @@ module ActiveRecord
       #   view_exists?(:ebooks)
       #
       def view_exists?(view_name)
+        select_values(data_source_sql(view_name, type: "VIEW"), "SCHEMA").any? if view_name.present?
+      rescue NotImplementedError
         views.include?(view_name.to_s)
       end
 
@@ -334,18 +342,16 @@ module ActiveRecord
       #     part_id int NOT NULL,
       #   ) ENGINE=InnoDB DEFAULT CHARSET=utf8
       #
-      def create_join_table(table_1, table_2, options = {})
+      def create_join_table(table_1, table_2, column_options: {}, **options)
         join_table_name = find_join_table_name(table_1, table_2, options)
 
-        column_options = options.delete(:column_options) || {}
-        column_options.reverse_merge!(null: false)
-        type = column_options.delete(:type) || :integer
+        column_options.reverse_merge!(null: false, index: false)
 
-        t1_column, t2_column = [table_1, table_2].map { |t| t.to_s.singularize.foreign_key }
+        t1_ref, t2_ref = [table_1, table_2].map { |t| t.to_s.singularize }
 
         create_table(join_table_name, options.merge!(id: false)) do |td|
-          td.send type, t1_column, column_options
-          td.send type, t2_column, column_options
+          td.references t1_ref, column_options
+          td.references t2_ref, column_options
           yield td if block_given?
         end
       end
@@ -857,6 +863,7 @@ module ActiveRecord
           else
             foreign_key_options = { to_table: reference_name }
           end
+          foreign_key_options[:column] ||= "#{ref_name}_id"
           remove_foreign_key(table_name, **foreign_key_options)
         end
 
@@ -992,12 +999,12 @@ module ActiveRecord
       end
 
       def dump_schema_information #:nodoc:
-        versions = ActiveRecord::SchemaMigration.order("version").pluck(:version)
+        versions = ActiveRecord::SchemaMigration.all_versions
         insert_versions_sql(versions)
       end
 
       def insert_versions_sql(versions) # :nodoc:
-        sm_table = quote_table_name(ActiveRecord::Migrator.schema_migrations_table_name)
+        sm_table = quote_table_name(ActiveRecord::SchemaMigration.table_name)
 
         if versions.is_a?(Array)
           sql = "INSERT INTO #{sm_table} (version) VALUES\n"
@@ -1026,12 +1033,11 @@ module ActiveRecord
       def assume_migrated_upto_version(version, migrations_paths)
         migrations_paths = Array(migrations_paths)
         version = version.to_i
-        sm_table = quote_table_name(ActiveRecord::Migrator.schema_migrations_table_name)
+        sm_table = quote_table_name(ActiveRecord::SchemaMigration.table_name)
 
-        migrated = select_values("SELECT version FROM #{sm_table}").map(&:to_i)
-        paths = migrations_paths.map { |p| "#{p}/[0-9]*_*.rb" }
-        versions = Dir[*paths].map do |filename|
-          filename.split("/").last.split("_").first.to_i
+        migrated = ActiveRecord::SchemaMigration.all_versions.map(&:to_i)
+        versions = ActiveRecord::Migrator.migration_files(migrations_paths).map do |file|
+          ActiveRecord::Migrator.parse_migration_filename(file).first.to_i
         end
 
         unless migrated.include?(version)
@@ -1306,6 +1312,14 @@ module ActiveRecord
         def can_remove_index_by_name?(options)
           options.is_a?(Hash) && options.key?(:name) && options.except(:name, :algorithm).empty?
         end
+
+        def data_source_sql(name = nil, type: nil)
+          raise NotImplementedError
+        end
+
+        def quoted_scope(name = nil, type: nil)
+          raise NotImplementedError
+        end
     end
   end
 end