activerecord 3.2.22.5 → 5.2.8

data/lib/active_record/schema_dumper.rb

@@ -1,5 +1,6 @@
-require 'stringio'
-require 'active_support/core_ext/big_decimal'
+# frozen_string_literal: true
+
+require "stringio"
 
 module ActiveRecord
   # = Active Record Schema Dumper
@@ -12,18 +13,28 @@ module ActiveRecord
     ##
     # :singleton-method:
     # A list of tables which should not be dumped to the schema.
-    # Acceptable values are strings as well as regexp.
-    # This setting is only used if ActiveRecord::Base.schema_format == :ruby
-    cattr_accessor :ignore_tables
-    @@ignore_tables = []
+    # Acceptable values are strings as well as regexp if ActiveRecord::Base.schema_format == :ruby.
+    # Only strings are accepted if ActiveRecord::Base.schema_format == :sql.
+    cattr_accessor :ignore_tables, default: []
 
-    def self.dump(connection=ActiveRecord::Base.connection, stream=STDOUT)
-      new(connection).dump(stream)
-      stream
+    class << self
+      def dump(connection = ActiveRecord::Base.connection, stream = STDOUT, config = ActiveRecord::Base)
+        connection.create_schema_dumper(generate_options(config)).dump(stream)
+        stream
+      end
+
+      private
+        def generate_options(config)
+          {
+            table_name_prefix: config.table_name_prefix,
+            table_name_suffix: config.table_name_suffix
+          }
+        end
     end
 
     def dump(stream)
       header(stream)
+      extensions(stream)
       tables(stream)
       trailer(stream)
       stream
@@ -31,19 +42,24 @@ module ActiveRecord
 
     private
 
-      def initialize(connection)
+      def initialize(connection, options = {})
         @connection = connection
-        @types = @connection.native_database_types
-        @version = Migrator::current_version rescue nil
+        @version = connection.migration_context.current_version rescue nil
+        @options = options
       end
 
-      def header(stream)
-        define_params = @version ? ":version => #{@version}" : ""
+      # turns 20170404131909 into "2017_04_04_131909"
+      def formatted_version
+        stringified = @version.to_s
+        return stringified unless stringified.length == 14
+        stringified.insert(4, "_").insert(7, "_").insert(10, "_")
+      end
 
-        if stream.respond_to?(:external_encoding) && stream.external_encoding
-          stream.puts "# encoding: #{stream.external_encoding.name}"
-        end
+      def define_params
+        @version ? "version: #{formatted_version}" : ""
+      end
 
+      def header(stream)
         stream.puts <<HEADER
 # This file is auto-generated from the current state of the database. Instead
 # of editing this file, please use the migrations feature of Active Record to
@@ -55,7 +71,7 @@ module ActiveRecord
 # from scratch. The latter is a flawed and unsustainable approach (the more migrations
 # you'll amass, the slower it'll run and the greater likelihood for issues).
 #
-# It's strongly recommended to check this file into your version control system.
+# It's strongly recommended that you check this file into your version control system.
 
 ActiveRecord::Schema.define(#{define_params}) do
 
@@ -66,17 +82,22 @@ HEADER
         stream.puts "end"
       end
 
+      # extensions are only supported by PostgreSQL
+      def extensions(stream)
+      end
+
       def tables(stream)
-        @connection.tables.sort.each do |tbl|
-          next if ['schema_migrations', ignore_tables].flatten.any? do |ignored|
-            case ignored
-            when String; remove_prefix_and_suffix(tbl) == ignored
-            when Regexp; remove_prefix_and_suffix(tbl) =~ ignored
-            else
-              raise StandardError, 'ActiveRecord::SchemaDumper.ignore_tables accepts an array of String and / or Regexp values.'
-            end
+        sorted_tables = @connection.tables.sort
+
+        sorted_tables.each do |table_name|
+          table(table_name, stream) unless ignored?(table_name)
+        end
+
+        # dump foreign keys at the end to make sure all dependent tables exist.
+        if @connection.supports_foreign_keys?
+          sorted_tables.each do |tbl|
+            foreign_keys(tbl, stream) unless ignored?(tbl)
           end
-          table(tbl, stream)
         end
       end
 
@@ -86,75 +107,46 @@ HEADER
           tbl = StringIO.new
 
           # first dump primary key column
-          if @connection.respond_to?(:pk_and_sequence_for)
-            pk, _ = @connection.pk_and_sequence_for(table)
-          elsif @connection.respond_to?(:primary_key)
-            pk = @connection.primary_key(table)
-          end
+          pk = @connection.primary_key(table)
 
           tbl.print "  create_table #{remove_prefix_and_suffix(table).inspect}"
-          if columns.detect { |c| c.name == pk }
-            if pk != 'id'
-              tbl.print %Q(, :primary_key => "#{pk}")
+
+          case pk
+          when String
+            tbl.print ", primary_key: #{pk.inspect}" unless pk == "id"
+            pkcol = columns.detect { |c| c.name == pk }
+            pkcolspec = column_spec_for_primary_key(pkcol)
+            if pkcolspec.present?
+              tbl.print ", #{format_colspec(pkcolspec)}"
             end
+          when Array
+            tbl.print ", primary_key: #{pk.inspect}"
           else
-            tbl.print ", :id => false"
+            tbl.print ", id: false"
           end
-          tbl.print ", :force => true"
-          tbl.puts " do |t|"
+
+          table_options = @connection.table_options(table)
+          if table_options.present?
+            tbl.print ", #{format_options(table_options)}"
+          end
+
+          tbl.puts ", force: :cascade do |t|"
 
           # then dump all non-primary key columns
-          column_specs = columns.map do |column|
-            raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" if @types[column.type].nil?
+          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
-            spec = {}
-            spec[:name]      = column.name.inspect
-
-            # AR has an optimization which handles zero-scale decimals as integers. This
-            # code ensures that the dumper still dumps the column as a decimal.
-            spec[:type]      = if column.type == :integer && [/^numeric/, /^decimal/].any? { |e| e.match(column.sql_type) }
-                                 'decimal'
-                               else
-                                 column.type.to_s
-                               end
-            spec[:limit]     = column.limit.inspect if column.limit != @types[column.type][:limit] && spec[:type] != 'decimal'
-            spec[:precision] = column.precision.inspect if column.precision
-            spec[:scale]     = column.scale.inspect if column.scale
-            spec[:null]      = 'false' unless column.null
-            spec[:default]   = default_string(column.default) if column.has_default?
-            (spec.keys - [:name, :type]).each{ |k| spec[k].insert(0, "#{k.inspect} => ")}
-            spec
-          end.compact
-
-          # find all migration keys used in this table
-          keys = [:name, :limit, :precision, :scale, :default, :null] & column_specs.map{ |k| k.keys }.flatten
-
-          # 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 = column_spec(column)
+            tbl.print "    t.#{type} #{column.name.inspect}"
+            tbl.print ", #{format_colspec(colspec)}" if colspec.present?
             tbl.puts
           end
 
+          indexes_in_create(table, tbl)
+
           tbl.puts "  end"
           tbl.puts
 
-          indexes(table, tbl)
-
           tbl.rewind
           stream.print tbl.read
         rescue => e
@@ -162,47 +154,102 @@ HEADER
           stream.puts "#   #{e.message}"
           stream.puts
         end
-
-        stream
       end
 
-      def default_string(value)
-        case value
-        when BigDecimal
-          value.to_s
-        when Date, DateTime, Time
-          "'" + value.to_s(:db) + "'"
-        else
-          value.inspect
+      # Keep it for indexing materialized views
+      def indexes(table, stream)
+        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(', ')}"
+          end
+
+          stream.puts add_index_statements.sort.join("\n")
+          stream.puts
         end
       end
 
-      def indexes(table, stream)
+      def indexes_in_create(table, stream)
         if (indexes = @connection.indexes(table)).any?
-          add_index_statements = indexes.map do |index|
-            statement_parts = [
-              ('add_index ' + remove_prefix_and_suffix(index.table).inspect),
-              index.columns.inspect,
-              (':name => ' + index.name.inspect),
+          index_statements = indexes.map do |index|
+            "    t.index #{index_parts(index).join(', ')}"
+          end
+          stream.puts index_statements.sort.join("\n")
+        end
+      end
+
+      def index_parts(index)
+        index_parts = [
+          index.columns.inspect,
+          "name: #{index.name.inspect}",
+        ]
+        index_parts << "unique: true" if index.unique
+        index_parts << "length: #{format_index_parts(index.lengths)}" if index.lengths.present?
+        index_parts << "order: #{format_index_parts(index.orders)}" if index.orders.present?
+        index_parts << "opclass: #{format_index_parts(index.opclasses)}" if index.opclasses.present?
+        index_parts << "where: #{index.where.inspect}" if index.where
+        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
+      end
+
+      def foreign_keys(table, stream)
+        if (foreign_keys = @connection.foreign_keys(table)).any?
+          add_foreign_key_statements = foreign_keys.map do |foreign_key|
+            parts = [
+              "add_foreign_key #{remove_prefix_and_suffix(foreign_key.from_table).inspect}",
+              remove_prefix_and_suffix(foreign_key.to_table).inspect,
             ]
-            statement_parts << ':unique => true' if index.unique
 
-            index_lengths = (index.lengths || []).compact
-            statement_parts << (':length => ' + Hash[index.columns.zip(index.lengths)].inspect) unless index_lengths.empty?
+            if foreign_key.column != @connection.foreign_key_column_for(foreign_key.to_table)
+              parts << "column: #{foreign_key.column.inspect}"
+            end
+
+            if foreign_key.custom_primary_key?
+              parts << "primary_key: #{foreign_key.primary_key.inspect}"
+            end
+
+            if foreign_key.name !~ /^fk_rails_[0-9a-f]{10}$/
+              parts << "name: #{foreign_key.name.inspect}"
+            end
 
-            index_orders = (index.orders || {})
-            statement_parts << (':order => ' + index.orders.inspect) unless index_orders.empty?
+            parts << "on_update: #{foreign_key.on_update.inspect}" if foreign_key.on_update
+            parts << "on_delete: #{foreign_key.on_delete.inspect}" if foreign_key.on_delete
 
-            '  ' + statement_parts.join(', ')
+            "  #{parts.join(', ')}"
           end
 
-          stream.puts add_index_statements.sort.join("\n")
-          stream.puts
+          stream.puts add_foreign_key_statements.sort.join("\n")
+        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
+
+      def format_index_parts(options)
+        if options.is_a?(Hash)
+          "{ #{format_options(options)} }"
+        else
+          options.inspect
         end
       end
 
       def remove_prefix_and_suffix(table)
-        table.gsub(/^(#{ActiveRecord::Base.table_name_prefix})(.+)(#{ActiveRecord::Base.table_name_suffix})$/,  "\\2")
+        prefix = Regexp.escape(@options[:table_name_prefix].to_s)
+        suffix = Regexp.escape(@options[:table_name_suffix].to_s)
+        table.sub(/\A#{prefix}(.+)#{suffix}\z/, "\\1")
+      end
+
+      def ignored?(table_name)
+        [ActiveRecord::Base.schema_migrations_table_name, ActiveRecord::Base.internal_metadata_table_name, ignore_tables].flatten.any? do |ignored|
+          ignored === remove_prefix_and_suffix(table_name)
+        end
       end
   end
 end

data/lib/active_record/schema_migration.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+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
+  # have been applied to a given database. When a migration is run, its schema
+  # number is inserted in to the `SchemaMigration.table_name` so it doesn't need
+  # to be executed the next time.
+  class SchemaMigration < ActiveRecord::Base # :nodoc:
+    class << self
+      def primary_key
+        "version"
+      end
+
+      def table_name
+        "#{table_name_prefix}#{ActiveRecord::Base.schema_migrations_table_name}#{table_name_suffix}"
+      end
+
+      def table_exists?
+        connection.table_exists?(table_name)
+      end
+
+      def create_table
+        unless table_exists?
+          version_options = connection.internal_string_options_for_primary_key
+
+          connection.create_table(table_name, id: false) do |t|
+            t.string :version, version_options
+          end
+        end
+      end
+
+      def drop_table
+        connection.drop_table table_name, if_exists: true
+      end
+
+      def normalize_migration_number(number)
+        "%.3d" % number.to_i
+      end
+
+      def normalized_versions
+        all_versions.map { |v| normalize_migration_number v }
+      end
+
+      def all_versions
+        order(:version).pluck(:version)
+      end
+    end
+
+    def version
+      super.to_i
+    end
+  end
+end

data/lib/active_record/scoping/default.rb

@@ -1,4 +1,4 @@
-require 'active_support/concern'
+# frozen_string_literal: true
 
 module ActiveRecord
   module Scoping
@@ -6,136 +6,146 @@ module ActiveRecord
       extend ActiveSupport::Concern
 
       included do
-        # Stores the default scope for the class
-        class_attribute :default_scopes, :instance_writer => false
-        self.default_scopes = []
+        # Stores the default scope for the class.
+        class_attribute :default_scopes, instance_writer: false, instance_predicate: false, default: []
+        class_attribute :default_scope_override, instance_writer: false, instance_predicate: false, default: nil
       end
 
       module ClassMethods
-        # Returns a scope for the model without the default_scope.
+        # Returns a scope for the model without the previously set scopes.
         #
         #   class Post < ActiveRecord::Base
         #     def self.default_scope
-        #       where :published => true
+        #       where(published: true)
         #     end
         #   end
         #
-        #   Post.all          # Fires "SELECT * FROM posts WHERE published = true"
-        #   Post.unscoped.all # Fires "SELECT * FROM posts"
+        #   Post.all                                  # Fires "SELECT * FROM posts WHERE published = true"
+        #   Post.unscoped.all                         # Fires "SELECT * FROM posts"
+        #   Post.where(published: false).unscoped.all # Fires "SELECT * FROM posts"
         #
         # This method also accepts a block. All queries inside the block will
-        # not use the default_scope:
+        # not use the previously set scopes.
         #
         #   Post.unscoped {
         #     Post.limit(10) # Fires "SELECT * FROM posts LIMIT 10"
         #   }
-        #
-        # It is recommended to use the block form of unscoped because chaining
-        # unscoped with <tt>scope</tt> does not work.  Assuming that
-        # <tt>published</tt> is a <tt>scope</tt>, the following two statements
-        # are equal: the default_scope is applied on both.
-        #
-        #   Post.unscoped.published
-        #   Post.published
-        def unscoped #:nodoc:
+        def unscoped
           block_given? ? relation.scoping { yield } : relation
         end
 
+        # Are there attributes associated with this scope?
+        def scope_attributes? # :nodoc:
+          super || default_scopes.any? || respond_to?(:default_scope)
+        end
+
         def before_remove_const #:nodoc:
           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 <tt>default_scope</tt> 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 use <tt>default_scope</tt> with a block, in order to have it lazily evaluated:
-        #
-        #   class Article < ActiveRecord::Base
-        #     default_scope { where(:published_at => Time.now - 1.week) }
-        #   end
-        #
-        # (You can also pass any object which responds to <tt>call</tt> to the <tt>default_scope</tt>
-        # macro, and it will be called when building the default scope.)
-        #
-        # If you use multiple <tt>default_scope</tt> 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 <tt>default_scope</tt> 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 = {})
-          scope = Proc.new if block_given?
-          self.default_scopes = default_scopes + [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, &block) # :doc:
+            scope = block 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
+
+            self.default_scopes += [scope]
+          end
+
+          def build_default_scope(base_rel = nil)
+            return if abstract_class?
+
+            if default_scope_override.nil?
+              self.default_scope_override = !Base.is_a?(method(:default_scope).owner)
+            end
 
-        def build_default_scope #:nodoc:
-          if method(:default_scope).owner != ActiveRecord::Scoping::Default::ClassMethods
-            evaluate_default_scope { default_scope }
-          elsif default_scopes.any?
-            evaluate_default_scope do
-              default_scopes.inject(relation) do |default_scope, scope|
-                if scope.is_a?(Hash)
-                  default_scope.apply_finder_options(scope)
-                elsif !scope.is_a?(Relation) && scope.respond_to?(:call)
-                  default_scope.merge(scope.call)
-                else
-                  default_scope.merge(scope)
+            if 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
+              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))
                 end
               end
             end
           end
-        end
 
-        def ignore_default_scope? #:nodoc:
-          Thread.current["#{self}_ignore_default_scope"]
-        end
+          def ignore_default_scope?
+            ScopeRegistry.value_for(:ignore_default_scope, base_class)
+          end
 
-        def ignore_default_scope=(ignore) #:nodoc:
-          Thread.current["#{self}_ignore_default_scope"] = 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
-          return if ignore_default_scope?
+          # 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
+            begin
+              self.ignore_default_scope = true
+              yield
+            ensure
+              self.ignore_default_scope = false
+            end
           end
-        end
-
       end
     end
   end