activerecord 5.0.7.2 → 5.1.0.beta1

data/lib/active_record/schema.rb

@@ -40,7 +40,7 @@ module ActiveRecord
     #   ActiveRecord::Schema.define(version: 20380119000001) do
     #     ...
     #   end
-    def self.define(info={}, &block)
+    def self.define(info = {}, &block)
       new.define(info, &block)
     end
 
@@ -48,7 +48,7 @@ module ActiveRecord
       instance_eval(&block)
 
       if info[:version].present?
-        initialize_schema_migrations_table
+        ActiveRecord::SchemaMigration.create_table
         connection.assume_migrated_upto_version(info[:version], migrations_paths)
       end
 
@@ -61,7 +61,7 @@ module ActiveRecord
       #
       #   ActiveRecord::Schema.new.migrations_paths
       #   # => ["db/migrate"] # Rails migration path by default.
-      def migrations_paths # :nodoc:
+      def migrations_paths
         ActiveRecord::Migrator.migrations_paths
       end
   end

data/lib/active_record/schema_dumper.rb

@@ -1,4 +1,4 @@
-require 'stringio'
+require "stringio"
 
 module ActiveRecord
   # = Active Record Schema Dumper
@@ -17,7 +17,7 @@ module ActiveRecord
     @@ignore_tables = []
 
     class << self
-      def dump(connection=ActiveRecord::Base.connection, stream=STDOUT, config = ActiveRecord::Base)
+      def dump(connection = ActiveRecord::Base.connection, stream = STDOUT, config = ActiveRecord::Base)
         new(connection, generate_options(config)).dump(stream)
         stream
       end
@@ -111,13 +111,11 @@ HEADER
 
           case pk
           when String
-            tbl.print ", primary_key: #{pk.inspect}" unless pk == 'id'
+            tbl.print ", primary_key: #{pk.inspect}" unless pk == "id"
             pkcol = columns.detect { |c| c.name == pk }
             pkcolspec = @connection.column_spec_for_primary_key(pkcol)
             if pkcolspec.present?
-              pkcolspec.each do |key, value|
-                tbl.print ", #{key}: #{value}"
-              end
+              tbl.print ", #{format_colspec(pkcolspec)}"
             end
           when Array
             tbl.print ", primary_key: #{pk.inspect}"
@@ -134,37 +132,12 @@ HEADER
           tbl.puts " do |t|"
 
           # then dump all non-primary key columns
-          column_specs = columns.map do |column|
+          columns.each do |column|
             raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" unless @connection.valid_type?(column.type)
             next if column.name == pk
-            @connection.column_spec(column)
-          end.compact
-
-          # find all migration keys used in this table
-          keys = @connection.migration_keys
-
-          # figure out the lengths for each column based on above keys
-          lengths = keys.map { |key|
-            column_specs.map { |spec|
-              spec[key] ? spec[key].length + 2 : 0
-            }.max
-          }
-
-          # the string we're going to sprintf our values against, with standardized column widths
-          format_string = lengths.map{ |len| "%-#{len}s" }
-
-          # find the max length for the 'type' column, which is special
-          type_length = column_specs.map{ |column| column[:type].length }.max
-
-          # add column type definition to our format string
-          format_string.unshift "    t.%-#{type_length}s "
-
-          format_string *= ''
-
-          column_specs.each do |colspec|
-            values = keys.zip(lengths).map{ |key, len| colspec.key?(key) ? colspec[key] + ", " : " " * len }
-            values.unshift colspec[:type]
-            tbl.print((format_string % values).gsub(/,\s*$/, ''))
+            type, colspec = @connection.column_spec(column)
+            tbl.print "    t.#{type} #{column.name.inspect}"
+            tbl.print ", #{format_colspec(colspec)}" if colspec.present?
             tbl.puts
           end
 
@@ -189,7 +162,7 @@ HEADER
         if (indexes = @connection.indexes(table)).any?
           add_index_statements = indexes.map do |index|
             table_name = remove_prefix_and_suffix(index.table).inspect
-            "  add_index #{([table_name]+index_parts(index)).join(', ')}"
+            "  add_index #{([table_name] + index_parts(index)).join(', ')}"
           end
 
           stream.puts add_index_statements.sort.join("\n")
@@ -215,7 +188,7 @@ HEADER
         index_parts << "length: { #{format_options(index.lengths)} }" if index.lengths.present?
         index_parts << "order: { #{format_options(index.orders)} }" if index.orders.present?
         index_parts << "where: #{index.where.inspect}" if index.where
-        index_parts << "using: #{index.using.inspect}" if index.using
+        index_parts << "using: #{index.using.inspect}" if !@connection.default_index_type?(index)
         index_parts << "type: #{index.type.inspect}" if index.type
         index_parts << "comment: #{index.comment.inspect}" if index.comment
         index_parts
@@ -251,6 +224,10 @@ HEADER
         end
       end
 
+      def format_colspec(colspec)
+        colspec.map { |key, value| "#{key}: #{value}" }.join(", ")
+      end
+
       def format_options(options)
         options.map { |key, value| "#{key}: #{value.inspect}" }.join(", ")
       end

data/lib/active_record/schema_migration.rb

@@ -1,5 +1,5 @@
-require 'active_record/scoping/default'
-require 'active_record/scoping/named'
+require "active_record/scoping/default"
+require "active_record/scoping/named"
 
 module ActiveRecord
   # This class is used to create a table that keeps track of which migrations
@@ -17,7 +17,7 @@ module ActiveRecord
       end
 
       def table_exists?
-        ActiveSupport::Deprecation.silence { connection.table_exists?(table_name) }
+        connection.table_exists?(table_name)
       end
 
       def create_table

data/lib/active_record/scoping.rb

@@ -1,4 +1,4 @@
-require 'active_support/per_thread_registry'
+require "active_support/per_thread_registry"
 
 module ActiveRecord
   module Scoping
@@ -10,8 +10,8 @@ module ActiveRecord
     end
 
     module ClassMethods
-      def current_scope(skip_inherited_scope = false) # :nodoc:
-        ScopeRegistry.value_for(:current_scope, self, skip_inherited_scope)
+      def current_scope #:nodoc:
+        ScopeRegistry.value_for(:current_scope, self)
       end
 
       def current_scope=(scope) #:nodoc:
@@ -33,7 +33,7 @@ module ActiveRecord
     def populate_with_current_scope_attributes # :nodoc:
       return unless self.class.scope_attributes?
 
-      self.class.scope_attributes.each do |att,value|
+      self.class.scope_attributes.each do |att, value|
         send("#{att}=", value) if respond_to?("#{att}=")
       end
     end
@@ -75,9 +75,8 @@ module ActiveRecord
       end
 
       # Obtains the value for a given +scope_type+ and +model+.
-      def value_for(scope_type, model, skip_inherited_scope = false)
+      def value_for(scope_type, model)
         raise_invalid_scope_type!(scope_type)
-        return @registry[scope_type][model.name] if skip_inherited_scope
         klass = model
         base = model.base_class
         while klass <= base
@@ -95,11 +94,11 @@ module ActiveRecord
 
       private
 
-      def raise_invalid_scope_type!(scope_type)
-        if !VALID_SCOPE_TYPES.include?(scope_type)
-          raise ArgumentError, "Invalid scope type '#{scope_type}' sent to the registry. Scope types must be included in VALID_SCOPE_TYPES"
+        def raise_invalid_scope_type!(scope_type)
+          if !VALID_SCOPE_TYPES.include?(scope_type)
+            raise ArgumentError, "Invalid scope type '#{scope_type}' sent to the registry. Scope types must be included in VALID_SCOPE_TYPES"
+          end
         end
-      end
     end
   end
 end

data/lib/active_record/scoping/default.rb

@@ -44,109 +44,105 @@ module ActiveRecord
           self.current_scope = nil
         end
 
-        protected
+        private
+
+          # Use this macro in your model to set a default scope for all operations on
+          # the model.
+          #
+          #   class Article < ActiveRecord::Base
+          #     default_scope { where(published: true) }
+          #   end
+          #
+          #   Article.all # => SELECT * FROM articles WHERE published = true
+          #
+          # The #default_scope is also applied while creating/building a record.
+          # It is not applied while updating a record.
+          #
+          #   Article.new.published    # => true
+          #   Article.create.published # => true
+          #
+          # (You can also pass any object which responds to +call+ to the
+          # +default_scope+ macro, and it will be called when building the
+          # default scope.)
+          #
+          # If you use multiple #default_scope declarations in your model then
+          # they will be merged together:
+          #
+          #   class Article < ActiveRecord::Base
+          #     default_scope { where(published: true) }
+          #     default_scope { where(rating: 'G') }
+          #   end
+          #
+          #   Article.all # => SELECT * FROM articles WHERE published = true AND rating = 'G'
+          #
+          # This is also the case with inheritance and module includes where the
+          # parent or module defines a #default_scope and the child or including
+          # class defines a second one.
+          #
+          # If you need to do more complex things with a default scope, you can
+          # alternatively define it as a class method:
+          #
+          #   class Article < ActiveRecord::Base
+          #     def self.default_scope
+          #       # Should return a scope, you can call 'super' here etc.
+          #     end
+          #   end
+          def default_scope(scope = nil) # :doc:
+            scope = Proc.new if block_given?
+
+            if scope.is_a?(Relation) || !scope.respond_to?(:call)
+              raise ArgumentError,
+                "Support for calling #default_scope without a block is removed. For example instead " \
+                "of `default_scope where(color: 'red')`, please use " \
+                "`default_scope { where(color: 'red') }`. (Alternatively you can just redefine " \
+                "self.default_scope.)"
+            end
 
-        # Use this macro in your model to set a default scope for all operations on
-        # the model.
-        #
-        #   class Article < ActiveRecord::Base
-        #     default_scope { where(published: true) }
-        #   end
-        #
-        #   Article.all # => SELECT * FROM articles WHERE published = true
-        #
-        # The #default_scope is also applied while creating/building a record.
-        # It is not applied while updating a record.
-        #
-        #   Article.new.published    # => true
-        #   Article.create.published # => true
-        #
-        # (You can also pass any object which responds to +call+ to the
-        # +default_scope+ macro, and it will be called when building the
-        # default scope.)
-        #
-        # If you use multiple #default_scope declarations in your model then
-        # they will be merged together:
-        #
-        #   class Article < ActiveRecord::Base
-        #     default_scope { where(published: true) }
-        #     default_scope { where(rating: 'G') }
-        #   end
-        #
-        #   Article.all # => SELECT * FROM articles WHERE published = true AND rating = 'G'
-        #
-        # This is also the case with inheritance and module includes where the
-        # parent or module defines a #default_scope and the child or including
-        # class defines a second one.
-        #
-        # If you need to do more complex things with a default scope, you can
-        # alternatively define it as a class method:
-        #
-        #   class Article < ActiveRecord::Base
-        #     def self.default_scope
-        #       # Should return a scope, you can call 'super' here etc.
-        #     end
-        #   end
-        def default_scope(scope = nil)
-          scope = Proc.new if block_given?
-
-          if scope.is_a?(Relation) || !scope.respond_to?(:call)
-            raise ArgumentError,
-              "Support for calling #default_scope without a block is removed. For example instead " \
-              "of `default_scope where(color: 'red')`, please use " \
-              "`default_scope { where(color: 'red') }`. (Alternatively you can just redefine " \
-              "self.default_scope.)"
+            self.default_scopes += [scope]
           end
 
-          self.default_scopes += [scope]
-        end
-
-        def build_default_scope(base_rel = nil) # :nodoc:
-          return if abstract_class?
+          def build_default_scope(base_rel = nil)
+            return if abstract_class?
 
-          if self.default_scope_override.nil?
-            self.default_scope_override = !Base.is_a?(method(:default_scope).owner)
-          end
-
-          if self.default_scope_override
-            # The user has defined their own default scope method, so call that
-            evaluate_default_scope do
-              if scope = default_scope
-                (base_rel ||= relation).merge(scope)
-              end
+            if default_scope_override.nil?
+              self.default_scope_override = !Base.is_a?(method(:default_scope).owner)
             end
-          elsif default_scopes.any?
-            base_rel ||= relation
-            evaluate_default_scope do
-              default_scopes.inject(base_rel) do |default_scope, scope|
-                scope = scope.respond_to?(:to_proc) ? scope : scope.method(:call)
-                default_scope.merge(base_rel.instance_exec(&scope))
+
+            if default_scope_override
+              # The user has defined their own default scope method, so call that
+              evaluate_default_scope { default_scope }
+            elsif default_scopes.any?
+              base_rel ||= relation
+              evaluate_default_scope do
+                default_scopes.inject(base_rel) do |default_scope, scope|
+                  scope = scope.respond_to?(:to_proc) ? scope : scope.method(:call)
+                  default_scope.merge(base_rel.instance_exec(&scope))
+                end
               end
             end
           end
-        end
 
-        def ignore_default_scope? # :nodoc:
-          ScopeRegistry.value_for(:ignore_default_scope, base_class)
-        end
+          def ignore_default_scope?
+            ScopeRegistry.value_for(:ignore_default_scope, base_class)
+          end
 
-        def ignore_default_scope=(ignore) # :nodoc:
-          ScopeRegistry.set_value_for(:ignore_default_scope, base_class, ignore)
-        end
+          def ignore_default_scope=(ignore)
+            ScopeRegistry.set_value_for(:ignore_default_scope, base_class, ignore)
+          end
 
-        # The ignore_default_scope flag is used to prevent an infinite recursion
-        # situation where a default scope references a scope which has a default
-        # scope which references a scope...
-        def evaluate_default_scope # :nodoc:
-          return if ignore_default_scope?
-
-          begin
-            self.ignore_default_scope = true
-            yield
-          ensure
-            self.ignore_default_scope = false
+          # The ignore_default_scope flag is used to prevent an infinite recursion
+          # situation where a default scope references a scope which has a default
+          # scope which references a scope...
+          def evaluate_default_scope
+            return if ignore_default_scope?
+
+            begin
+              self.ignore_default_scope = true
+              yield
+            ensure
+              self.ignore_default_scope = false
+            end
           end
-        end
       end
     end
   end

data/lib/active_record/scoping/named.rb

@@ -1,6 +1,6 @@
-require 'active_support/core_ext/array'
-require 'active_support/core_ext/hash/except'
-require 'active_support/core_ext/kernel/singleton_class'
+require "active_support/core_ext/array"
+require "active_support/core_ext/hash/except"
+require "active_support/core_ext/kernel/singleton_class"
 
 module ActiveRecord
   # = Active Record \Named \Scopes
@@ -29,32 +29,20 @@ module ActiveRecord
           end
         end
 
-        def scope_for_association(scope = relation) # :nodoc:
-          current_scope = self.current_scope
+        def default_scoped # :nodoc:
+          scope = build_default_scope
 
-          if current_scope && current_scope.empty_scope?
-            scope
+          if scope
+            relation.spawn.merge!(scope)
           else
-            default_scoped(scope)
-          end
-        end
-
-        def default_scoped(scope = relation) # :nodoc:
-          build_default_scope(scope) || scope
-        end
-
-        def default_extensions # :nodoc:
-          if scope = current_scope || build_default_scope
-            scope.extensions
-          else
-            []
+            relation
           end
         end
 
         # Adds a class method for retrieving and querying objects.
         # The method is intended to return an ActiveRecord::Relation
         # object, which is composable with other scopes.
-        # If it returns nil or false, an
+        # If it returns +nil+ or +false+, an
         # {all}[rdoc-ref:Scoping::Named::ClassMethods#all] scope is returned instead.
         #
         # A \scope represents a narrowing of a database query, such as
@@ -154,7 +142,7 @@ module ActiveRecord
         #   Article.featured.titles
         def scope(name, body, &block)
           unless body.respond_to?(:call)
-            raise ArgumentError, 'The scope body needs to be callable.'
+            raise ArgumentError, "The scope body needs to be callable."
           end
 
           if dangerous_class_method?(name)
@@ -183,14 +171,14 @@ module ActiveRecord
           end
         end
 
-      protected
+        private
 
-        def valid_scope_name?(name)
-          if respond_to?(name, true) && logger
-            logger.warn "Creating scope :#{name}. " \
-                        "Overwriting existing method #{self.name}.#{name}."
+          def valid_scope_name?(name)
+            if respond_to?(name, true) && logger
+              logger.warn "Creating scope :#{name}. " \
+                "Overwriting existing method #{self.name}.#{name}."
+            end
           end
-        end
       end
     end
   end