activerecord 5.0.0.beta1.1 → 5.0.0.beta2

data/lib/active_record/connection_adapters/postgresql/oid/range.rb

@@ -6,6 +6,7 @@ module ActiveRecord
       module OID # :nodoc:
         class Range < Type::Value # :nodoc:
           attr_reader :subtype, :type
+          delegate :user_input_in_time_zone, to: :subtype
 
           def initialize(subtype, type = :range)
             @subtype = subtype
@@ -18,7 +19,7 @@ module ActiveRecord
 
           def cast_value(value)
             return if value == 'empty'
-            return value if value.is_a?(::Range)
+            return value unless value.is_a?(::String)
 
             extracted = extract_bounds(value)
             from = type_cast_single extracted[:from]
@@ -46,6 +47,12 @@ module ActiveRecord
               other.type == type
           end
 
+          def map(value) # :nodoc:
+            new_begin = yield(value.begin)
+            new_end = yield(value.end)
+            ::Range.new(new_begin, new_end, value.exclude_end?)
+          end
+
           private
 
           def type_cast_single(value)

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

@@ -55,10 +55,11 @@ module ActiveRecord
           end
         end
 
-        # Does not quote function default values for UUID columns
-        def quote_default_expression(value, column) #:nodoc:
-          if column.type == :uuid && value =~ /\(\)/
-            value
+        def quote_default_expression(value, column) # :nodoc:
+          if value.is_a?(Proc)
+            value.call
+          elsif column.type == :uuid && value =~ /\(\)/
+            value # Does not quote function default values for UUID columns
           elsif column.respond_to?(:array?)
             value = type_cast_from_column(column, value)
             quote(value)

data/lib/active_record/connection_adapters/postgresql/schema_dumper.rb

@@ -9,7 +9,7 @@ module ActiveRecord
             spec[:id] = ':bigserial'
           elsif column.type == :uuid
             spec[:id] = ':uuid'
-            spec[:default] = column.default_function.inspect
+            spec[:default] = schema_default(column) || 'nil'
           else
             spec[:id] = column.type.inspect
             spec.merge!(prepare_column_options(column).delete_if { |key, _| [:name, :type, :null].include?(key) })
@@ -41,12 +41,8 @@ module ActiveRecord
           end
         end
 
-        def schema_default(column)
-          if column.default_function
-            column.default_function.inspect unless column.serial?
-          else
-            super
-          end
+        def schema_expression(column)
+          super unless column.serial?
         end
       end
     end

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -5,6 +5,7 @@ require 'pg'
 require "active_record/connection_adapters/abstract_adapter"
 require "active_record/connection_adapters/postgresql/column"
 require "active_record/connection_adapters/postgresql/database_statements"
+require "active_record/connection_adapters/postgresql/explain_pretty_printer"
 require "active_record/connection_adapters/postgresql/oid"
 require "active_record/connection_adapters/postgresql/quoting"
 require "active_record/connection_adapters/postgresql/referential_integrity"
@@ -390,12 +391,12 @@ module ActiveRecord
         "average" => "avg",
       }
 
-      protected
+      # Returns the version of the connected PostgreSQL server.
+      def postgresql_version
+        @connection.server_version
+      end
 
-        # Returns the version of the connected PostgreSQL server.
-        def postgresql_version
-          @connection.server_version
-        end
+      protected
 
         # See http://www.postgresql.org/docs/current/static/errcodes-appendix.html
         FOREIGN_KEY_VIOLATION = "23503"
@@ -512,8 +513,13 @@ module ActiveRecord
         def extract_value_from_default(default) # :nodoc:
           case default
             # Quoted types
-            when /\A[\(B]?'(.*)'::/m
-              $1.gsub("''".freeze, "'".freeze)
+            when /\A[\(B]?'(.*)'.*::"?([\w. ]+)"?(?:\[\])?\z/m
+              # The default 'now'::date is CURRENT_DATE
+              if $1 == "now".freeze && $2 == "date".freeze
+                nil
+              else
+                $1.gsub("''".freeze, "'".freeze)
+              end
             # Boolean types
             when 'true'.freeze, 'false'.freeze
               default
@@ -535,7 +541,7 @@ module ActiveRecord
         end
 
         def has_default_function?(default_value, default) # :nodoc:
-          !default_value && (%r{\w+\(.*\)} === default)
+          !default_value && (%r{\w+\(.*\)|\(.*\)::\w+} === default)
         end
 
         def load_additional_types(type_map, oids = nil) # :nodoc:
@@ -640,12 +646,6 @@ module ActiveRecord
         # connected server's characteristics.
         def connect
           @connection = PGconn.connect(@connection_parameters)
-
-          # Money type has a fixed precision of 10 in PostgreSQL 8.2 and below, and as of
-          # PostgreSQL 8.3 it has a fixed precision of 19. PostgreSQLColumn.extract_precision
-          # should know about this but can't detect it there, so deal with it here.
-          OID::Money.precision = (postgresql_version >= 80300) ? 19 : 10
-
           configure_connection
         rescue ::PG::Error => error
           if error.message.include?("does not exist")
@@ -690,15 +690,7 @@ module ActiveRecord
         end
 
         # Returns the current ID of a table's sequence.
-        def last_insert_id(sequence_name) #:nodoc:
-          Integer(last_insert_id_value(sequence_name))
-        end
-
-        def last_insert_id_value(sequence_name)
-          last_insert_id_result(sequence_name).rows.first.first
-        end
-
-        def last_insert_id_result(sequence_name) #:nodoc:
+        def last_insert_id_result(sequence_name) # :nodoc:
           exec_query("SELECT currval('#{sequence_name}')", 'SQL')
         end
 

data/lib/active_record/connection_adapters/sqlite3/explain_pretty_printer.rb

@@ -0,0 +1,19 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLite3
+      class ExplainPrettyPrinter # :nodoc:
+        # Pretty prints the result of an EXPLAIN QUERY PLAN in a way that resembles
+        # the output of the SQLite shell:
+        #
+        #   0|0|0|SEARCH TABLE users USING INTEGER PRIMARY KEY (rowid=?) (~1 rows)
+        #   0|1|1|SCAN TABLE posts (~100000 rows)
+        #
+        def pp(result)
+          result.rows.map do |row|
+            row.join('|')
+          end.join("\n") + "\n"
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/sqlite3_adapter.rb

@@ -1,5 +1,6 @@
 require 'active_record/connection_adapters/abstract_adapter'
 require 'active_record/connection_adapters/statement_pool'
+require 'active_record/connection_adapters/sqlite3/explain_pretty_printer'
 require 'active_record/connection_adapters/sqlite3/schema_creation'
 
 gem 'sqlite3', '~> 1.3.6'
@@ -218,21 +219,7 @@ module ActiveRecord
 
       def explain(arel, binds = [])
         sql = "EXPLAIN QUERY PLAN #{to_sql(arel, binds)}"
-        ExplainPrettyPrinter.new.pp(exec_query(sql, 'EXPLAIN', []))
-      end
-
-      class ExplainPrettyPrinter
-        # Pretty prints the result of an EXPLAIN QUERY PLAN in a way that resembles
-        # the output of the SQLite shell:
-        #
-        #   0|0|0|SEARCH TABLE users USING INTEGER PRIMARY KEY (rowid=?) (~1 rows)
-        #   0|1|1|SCAN TABLE posts (~100000 rows)
-        #
-        def pp(result) # :nodoc:
-          result.rows.map do |row|
-            row.join('|')
-          end.join("\n") + "\n"
-        end
+        SQLite3::ExplainPrettyPrinter.new.pp(exec_query(sql, 'EXPLAIN', []))
       end
 
       def exec_query(sql, name = nil, binds = [], prepare: false)
@@ -280,22 +267,6 @@ module ActiveRecord
         log(sql, name) { @connection.execute(sql) }
       end
 
-      def update_sql(sql, name = nil) #:nodoc:
-        super
-        @connection.changes
-      end
-
-      def delete_sql(sql, name = nil) #:nodoc:
-        sql += " WHERE 1=1" unless sql =~ /WHERE/i
-        super sql, name
-      end
-
-      def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
-        super
-        id_value || @connection.last_insert_row_id
-      end
-      alias :create :insert_sql
-
       def select_rows(sql, name = nil, binds = [])
         exec_query(sql, name, binds).rows
       end

data/lib/active_record/connection_handling.rb

@@ -8,7 +8,7 @@ module ActiveRecord
     # example for regular databases (MySQL, PostgreSQL, etc):
     #
     #   ActiveRecord::Base.establish_connection(
-    #     adapter:  "mysql",
+    #     adapter:  "mysql2",
     #     host:     "localhost",
     #     username: "myuser",
     #     password: "mypass",

data/lib/active_record/core.rb

@@ -275,7 +275,7 @@ module ActiveRecord
       def relation # :nodoc:
         relation = Relation.create(self, arel_table, predicate_builder)
 
-        if finder_needs_type_condition?
+        if finder_needs_type_condition? && !ignore_default_scope?
           relation.where(type_condition).create_with(inheritance_column.to_sym => sti_name)
         else
           relation

data/lib/active_record/counter_cache.rb

@@ -97,8 +97,8 @@ module ActiveRecord
       #
       # ==== Examples
       #
-      #   # Increment the post_count column for the record with an id of 5
-      #   DiscussionBoard.increment_counter(:post_count, 5)
+      #   # Increment the posts_count column for the record with an id of 5
+      #   DiscussionBoard.increment_counter(:posts_count, 5)
       def increment_counter(counter_name, id)
         update_counters(id, counter_name => 1)
       end
@@ -115,8 +115,8 @@ module ActiveRecord
       #
       # ==== Examples
       #
-      #   # Decrement the post_count column for the record with an id of 5
-      #   DiscussionBoard.decrement_counter(:post_count, 5)
+      #   # Decrement the posts_count column for the record with an id of 5
+      #   DiscussionBoard.decrement_counter(:posts_count, 5)
       def decrement_counter(counter_name, id)
         update_counters(id, counter_name => -1)
       end

data/lib/active_record/enum.rb

@@ -105,9 +105,10 @@ module ActiveRecord
     end
 
     class EnumType < Type::Value # :nodoc:
-      def initialize(name, mapping)
+      def initialize(name, mapping, subtype)
         @name = name
         @mapping = mapping
+        @subtype = subtype
       end
 
       def cast(value)
@@ -124,7 +125,7 @@ module ActiveRecord
 
       def deserialize(value)
         return if value.nil?
-        mapping.key(value.to_i)
+        mapping.key(subtype.deserialize(value))
       end
 
       def serialize(value)
@@ -139,7 +140,7 @@ module ActiveRecord
 
       protected
 
-      attr_reader :name, :mapping
+      attr_reader :name, :mapping, :subtype
     end
 
     def enum(definitions)
@@ -158,7 +159,9 @@ module ActiveRecord
         detect_enum_conflict!(name, name)
         detect_enum_conflict!(name, "#{name}=")
 
-        attribute name, EnumType.new(name, enum_values)
+        decorate_attribute_type(name, :enum) do |subtype|
+          EnumType.new(name, enum_values, subtype)
+        end
 
         _enum_methods_module.module_eval do
           pairs = values.respond_to?(:each_pair) ? values.each_pair : values.each_with_index
@@ -187,7 +190,7 @@ module ActiveRecord
 
             # scope :active, -> { where status: 0 }
             klass.send(:detect_enum_conflict!, name, value_method_name, true)
-            klass.scope value_method_name, -> { klass.where name => value }
+            klass.scope value_method_name, -> { where(name => value) }
           end
         end
         defined_enums[name.to_s] = enum_values

data/lib/active_record/errors.rb

@@ -272,7 +272,12 @@ module ActiveRecord
   # * You are joining an existing open transaction
   # * You are creating a nested (savepoint) transaction
   #
-  # The mysql, mysql2 and postgresql adapters support setting the transaction isolation level.
+  # The mysql2 and postgresql adapters support setting the transaction isolation level.
   class TransactionIsolationError < ActiveRecordError
   end
+
+  # IrreversibleOrderError is raised when a relation's order is too complex for
+  # +reverse_order+ to automatically reverse.
+  class IrreversibleOrderError < ActiveRecordError
+  end
 end

data/lib/active_record/gem_version.rb

@@ -8,7 +8,7 @@ module ActiveRecord
     MAJOR = 5
     MINOR = 0
     TINY  = 0
-    PRE   = "beta1.1"
+    PRE   = "beta2"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_record/inheritance.rb

@@ -52,7 +52,11 @@ module ActiveRecord
 
         attrs = args.first
         if has_attribute?(inheritance_column)
-          subclass = subclass_from_attributes(attrs) || subclass_from_attributes(column_defaults)
+          subclass = subclass_from_attributes(attrs)
+
+          if subclass.nil? && base_class == self
+            subclass = subclass_from_attributes(column_defaults)
+          end
         end
 
         if subclass && subclass != self
@@ -167,6 +171,7 @@ module ActiveRecord
       end
 
       def find_sti_class(type_name)
+        type_name = base_class.type_for_attribute(inheritance_column).cast(type_name)
         subclass = begin
           if store_full_sti_class
             ActiveSupport::Dependencies.constantize(type_name)

data/lib/active_record/internal_metadata.rb

@@ -0,0 +1,56 @@
+require 'active_record/scoping/default'
+require 'active_record/scoping/named'
+
+module ActiveRecord
+  # This class is used to create a table that keeps track of values and keys such
+  # as which environment migrations were run in.
+  class InternalMetadata < ActiveRecord::Base # :nodoc:
+    class << self
+      def primary_key
+        "key"
+      end
+
+      def table_name
+        "#{table_name_prefix}#{ActiveRecord::Base.internal_metadata_table_name}#{table_name_suffix}"
+      end
+
+      def original_table_name
+        "#{table_name_prefix}active_record_internal_metadatas#{table_name_suffix}"
+      end
+
+      def []=(key, value)
+        first_or_initialize(key: key).update_attributes!(value: value)
+      end
+
+      def [](key)
+        where(key: key).pluck(:value).first
+      end
+
+      def table_exists?
+        ActiveSupport::Deprecation.silence { connection.table_exists?(table_name) }
+      end
+
+      def original_table_exists?
+        # This method will be removed in Rails 5.1
+        # Since it is only necessary when `active_record_internal_metadatas` could exist
+        ActiveSupport::Deprecation.silence { connection.table_exists?(original_table_name) }
+      end
+
+      # Creates an internal metadata table with columns +key+ and +value+
+      def create_table
+        if original_table_exists?
+          connection.rename_table(original_table_name, table_name)
+        end
+        unless table_exists?
+          key_options = connection.internal_string_options_for_primary_key
+
+          connection.create_table(table_name, id: false) do |t|
+            t.string :key, key_options
+            t.string :value
+            t.timestamps
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/migration.rb

@@ -126,9 +126,9 @@ module ActiveRecord
   class PendingMigrationError < MigrationError#:nodoc:
     def initialize(message = nil)
       if !message && defined?(Rails.env)
-        super("Migrations are pending. To resolve this issue, run:\n\n\tbin/rails db:migrate RAILS_ENV=#{::Rails.env}.")
+        super("Migrations are pending. To resolve this issue, run:\n\n\tbin/rails db:migrate RAILS_ENV=#{::Rails.env}")
       elsif !message
-        super("Migrations are pending. To resolve this issue, run:\n\n\tbin/rails db:migrate.")
+        super("Migrations are pending. To resolve this issue, run:\n\n\tbin/rails db:migrate")
       else
         super
       end
@@ -143,6 +143,40 @@ module ActiveRecord
     end
   end
 
+  class NoEnvironmentInSchemaError < MigrationError #:nodoc:
+    def initialize
+      msg = "Environment data not found in the schema. To resolve this issue, run: \n\n\tbin/rails db:environment:set"
+      if defined?(Rails.env)
+        super("#{msg} RAILS_ENV=#{::Rails.env}")
+      else
+        super(msg)
+      end
+    end
+  end
+
+  class ProtectedEnvironmentError < ActiveRecordError #:nodoc:
+    def initialize(env = "production")
+      msg = "You are attempting to run a destructive action against your '#{env}' database\n"
+      msg << "If you are sure you want to continue, run the same command with the environment variable\n"
+      msg << "DISABLE_DATABASE_ENVIRONMENT_CHECK=1"
+      super(msg)
+    end
+  end
+
+  class EnvironmentMismatchError < ActiveRecordError
+    def initialize(current: nil, stored: nil)
+      msg =  "You are attempting to modify a database that was last run in `#{ stored }` environment.\n"
+      msg << "You are running in `#{ current }` environment."
+      msg << "If you are sure you want to continue, first set the environment using:\n\n"
+      msg << "\tbin/rails db:environment:set"
+      if defined?(Rails.env)
+        super("#{msg} RAILS_ENV=#{::Rails.env}")
+      else
+        super(msg)
+      end
+    end
+  end
+
   # = Active Record Migrations
   #
   # Migrations can manage the evolution of a schema used by several physical
@@ -1078,6 +1112,7 @@ module ActiveRecord
       validate(@migrations)
 
       Base.connection.initialize_schema_migrations_table
+      Base.connection.initialize_internal_metadata_table
     end
 
     def current_version
@@ -1135,45 +1170,58 @@ module ActiveRecord
 
     private
 
+    # Used for running a specific migration.
     def run_without_lock
       migration = migrations.detect { |m| m.version == @target_version }
       raise UnknownMigrationVersionError.new(@target_version) if migration.nil?
-      unless (up? && migrated.include?(migration.version.to_i)) || (down? && !migrated.include?(migration.version.to_i))
-        begin
-          execute_migration_in_transaction(migration, @direction)
-        rescue => e
-          canceled_msg = use_transaction?(migration) ? ", this migration was canceled" : ""
-          raise StandardError, "An error has occurred#{canceled_msg}:\n\n#{e}", e.backtrace
-        end
-      end
+      execute_migration_in_transaction(migration, @direction)
+
+      record_environment
     end
 
+    # Used for running multiple migrations up to or down to a certain value.
     def migrate_without_lock
-      if !target && @target_version && @target_version > 0
+      if invalid_target?
         raise UnknownMigrationVersionError.new(@target_version)
       end
 
       runnable.each do |migration|
-        Base.logger.info "Migrating to #{migration.name} (#{migration.version})" if Base.logger
-
-        begin
-          execute_migration_in_transaction(migration, @direction)
-        rescue => e
-          canceled_msg = use_transaction?(migration) ? "this and " : ""
-          raise StandardError, "An error has occurred, #{canceled_msg}all later migrations canceled:\n\n#{e}", e.backtrace
-        end
+        execute_migration_in_transaction(migration, @direction)
       end
+
+      record_environment
+    end
+
+    # Stores the current environment in the database.
+    def record_environment
+      return if down?
+      ActiveRecord::InternalMetadata[:environment] = ActiveRecord::Migrator.current_environment
     end
 
     def ran?(migration)
       migrated.include?(migration.version.to_i)
     end
 
+    # Return true if a valid version is not provided.
+    def invalid_target?
+      !target && @target_version && @target_version > 0
+    end
+
     def execute_migration_in_transaction(migration, direction)
+      return if down? && !migrated.include?(migration.version.to_i)
+      return if up?   &&  migrated.include?(migration.version.to_i)
+
+      Base.logger.info "Migrating to #{migration.name} (#{migration.version})" if Base.logger
+
       ddl_transaction(migration) do
         migration.migrate(direction)
         record_version_state_after_migrating(migration.version)
       end
+    rescue => e
+      msg = "An error has occurred, "
+      msg << "this and " if use_transaction?(migration)
+      msg << "all later migrations canceled:\n\n#{e}"
+      raise StandardError, msg, e.backtrace
     end
 
     def target
@@ -1202,10 +1250,27 @@ module ActiveRecord
         ActiveRecord::SchemaMigration.where(:version => version.to_s).delete_all
       else
         migrated << version
-        ActiveRecord::SchemaMigration.create!(:version => version.to_s)
+        ActiveRecord::SchemaMigration.create!(version: version.to_s)
       end
     end
 
+    def self.last_stored_environment
+      return nil if current_version == 0
+      raise NoEnvironmentInSchemaError unless ActiveRecord::InternalMetadata.table_exists?
+
+      environment = ActiveRecord::InternalMetadata[:environment]
+      raise NoEnvironmentInSchemaError unless environment
+      environment
+    end
+
+    def self.current_environment
+      ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
+    end
+
+    def self.protected_environment?
+      ActiveRecord::Base.protected_environments.include?(last_stored_environment) if last_stored_environment
+    end
+
     def up?
       @direction == :up
     end