activerecord 5.2.3

data/lib/active_record/internal_metadata.rb

@@ -0,0 +1,45 @@
+# 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 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 []=(key, value)
+        find_or_initialize_by(key: key).update_attributes!(value: value)
+      end
+
+      def [](key)
+        where(key: key).pluck(:value).first
+      end
+
+      def table_exists?
+        connection.table_exists?(table_name)
+      end
+
+      # Creates an internal metadata table with columns +key+ and +value+
+      def create_table
+        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/legacy_yaml_adapter.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module LegacyYamlAdapter
+    def self.convert(klass, coder)
+      return coder unless coder.is_a?(Psych::Coder)
+
+      case coder["active_record_yaml_version"]
+      when 1, 2 then coder
+      else
+        if coder["attributes"].is_a?(ActiveModel::AttributeSet)
+          Rails420.convert(klass, coder)
+        else
+          Rails41.convert(klass, coder)
+        end
+      end
+    end
+
+    module Rails420
+      def self.convert(klass, coder)
+        attribute_set = coder["attributes"]
+
+        klass.attribute_names.each do |attr_name|
+          attribute = attribute_set[attr_name]
+          if attribute.type.is_a?(Delegator)
+            type_from_klass = klass.type_for_attribute(attr_name)
+            attribute_set[attr_name] = attribute.with_type(type_from_klass)
+          end
+        end
+
+        coder
+      end
+    end
+
+    module Rails41
+      def self.convert(klass, coder)
+        attributes = klass.attributes_builder
+          .build_from_database(coder["attributes"])
+        new_record = coder["attributes"][klass.primary_key].blank?
+
+        {
+          "attributes" => attributes,
+          "new_record" => new_record,
+        }
+      end
+    end
+  end
+end

data/lib/active_record/locale/en.yml

@@ -0,0 +1,48 @@
+en:
+  # Attributes names common to most models
+  #attributes:
+    #created_at: "Created at"
+    #updated_at: "Updated at"
+
+  # Default error messages
+  errors:
+    messages:
+      required: "must exist"
+      taken: "has already been taken"
+
+  # Active Record models configuration
+  activerecord:
+    errors:
+      messages:
+        record_invalid: "Validation failed: %{errors}"
+        restrict_dependent_destroy:
+          has_one: "Cannot delete record because a dependent %{record} exists"
+          has_many: "Cannot delete record because dependent %{record} exist"
+        # Append your own errors here or at the model/attributes scope.
+
+      # You can define own errors for models or model attributes.
+      # The values :model, :attribute and :value are always available for interpolation.
+      #
+      # For example,
+      #   models:
+      #     user:
+      #       blank: "This is a custom blank message for %{model}: %{attribute}"
+      #       attributes:
+      #         login:
+      #           blank: "This is a custom blank message for User login"
+      # Will define custom blank validation message for User model and
+      # custom blank validation message for login attribute of User model.
+      #models:
+
+    # Translate model names. Used in Model.human_name().
+    #models:
+      # For example,
+      #   user: "Dude"
+      # will translate User model name to "Dude"
+
+    # Translate model attribute names. Used in Model.human_attribute_name(attribute).
+    #attributes:
+      # For example,
+      #   user:
+      #     login: "Handle"
+      # will translate User attribute "login" as "Handle"

data/lib/active_record/locking/optimistic.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Locking
+    # == What is Optimistic Locking
+    #
+    # Optimistic locking allows multiple users to access the same record for edits, and assumes a minimum of
+    # conflicts with the data. It does this by checking whether another process has made changes to a record since
+    # it was opened, an <tt>ActiveRecord::StaleObjectError</tt> exception is thrown if that has occurred
+    # and the update is ignored.
+    #
+    # Check out <tt>ActiveRecord::Locking::Pessimistic</tt> for an alternative.
+    #
+    # == Usage
+    #
+    # Active Record supports optimistic locking if the +lock_version+ field is present. Each update to the
+    # record increments the +lock_version+ column and the locking facilities ensure that records instantiated twice
+    # will let the last one saved raise a +StaleObjectError+ if the first was also updated. Example:
+    #
+    #   p1 = Person.find(1)
+    #   p2 = Person.find(1)
+    #
+    #   p1.first_name = "Michael"
+    #   p1.save
+    #
+    #   p2.first_name = "should fail"
+    #   p2.save # Raises an ActiveRecord::StaleObjectError
+    #
+    # Optimistic locking will also check for stale data when objects are destroyed. Example:
+    #
+    #   p1 = Person.find(1)
+    #   p2 = Person.find(1)
+    #
+    #   p1.first_name = "Michael"
+    #   p1.save
+    #
+    #   p2.destroy # Raises an ActiveRecord::StaleObjectError
+    #
+    # You're then responsible for dealing with the conflict by rescuing the exception and either rolling back, merging,
+    # or otherwise apply the business logic needed to resolve the conflict.
+    #
+    # This locking mechanism will function inside a single Ruby process. To make it work across all
+    # web requests, the recommended approach is to add +lock_version+ as a hidden field to your form.
+    #
+    # This behavior can be turned off by setting <tt>ActiveRecord::Base.lock_optimistically = false</tt>.
+    # To override the name of the +lock_version+ column, set the <tt>locking_column</tt> class attribute:
+    #
+    #   class Person < ActiveRecord::Base
+    #     self.locking_column = :lock_person
+    #   end
+    #
+    module Optimistic
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :lock_optimistically, instance_writer: false, default: true
+      end
+
+      def locking_enabled? #:nodoc:
+        self.class.locking_enabled?
+      end
+
+      private
+        def _create_record(attribute_names = self.attribute_names, *)
+          if locking_enabled?
+            # We always want to persist the locking version, even if we don't detect
+            # a change from the default, since the database might have no default
+            attribute_names |= [self.class.locking_column]
+          end
+          super
+        end
+
+        def _touch_row(attribute_names, time)
+          super
+        ensure
+          clear_attribute_change(self.class.locking_column) if locking_enabled?
+        end
+
+        def _update_row(attribute_names, attempted_action = "update")
+          return super unless locking_enabled?
+
+          begin
+            locking_column = self.class.locking_column
+            previous_lock_value = read_attribute_before_type_cast(locking_column)
+            attribute_names << locking_column
+
+            self[locking_column] += 1
+
+            affected_rows = self.class._update_record(
+              attributes_with_values(attribute_names),
+              self.class.primary_key => id_in_database,
+              locking_column => previous_lock_value
+            )
+
+            if affected_rows != 1
+              raise ActiveRecord::StaleObjectError.new(self, attempted_action)
+            end
+
+            affected_rows
+
+          # If something went wrong, revert the locking_column value.
+          rescue Exception
+            self[locking_column] = previous_lock_value.to_i
+            raise
+          end
+        end
+
+        def destroy_row
+          return super unless locking_enabled?
+
+          locking_column = self.class.locking_column
+
+          affected_rows = self.class._delete_record(
+            self.class.primary_key => id_in_database,
+            locking_column => read_attribute_before_type_cast(locking_column)
+          )
+
+          if affected_rows != 1
+            raise ActiveRecord::StaleObjectError.new(self, "destroy")
+          end
+
+          affected_rows
+        end
+
+        module ClassMethods
+          DEFAULT_LOCKING_COLUMN = "lock_version"
+
+          # Returns true if the +lock_optimistically+ flag is set to true
+          # (which it is, by default) and the table includes the
+          # +locking_column+ column (defaults to +lock_version+).
+          def locking_enabled?
+            lock_optimistically && columns_hash[locking_column]
+          end
+
+          # Set the column to use for optimistic locking. Defaults to +lock_version+.
+          def locking_column=(value)
+            reload_schema_from_cache
+            @locking_column = value.to_s
+          end
+
+          # The version column used for optimistic locking. Defaults to +lock_version+.
+          def locking_column
+            @locking_column = DEFAULT_LOCKING_COLUMN unless defined?(@locking_column)
+            @locking_column
+          end
+
+          # Reset the column used for optimistic locking back to the +lock_version+ default.
+          def reset_locking_column
+            self.locking_column = DEFAULT_LOCKING_COLUMN
+          end
+
+          # Make sure the lock version column gets updated when counters are
+          # updated.
+          def update_counters(id, counters)
+            counters = counters.merge(locking_column => 1) if locking_enabled?
+            super
+          end
+
+          private
+
+            # We need to apply this decorator here, rather than on module inclusion. The closure
+            # created by the matcher would otherwise evaluate for `ActiveRecord::Base`, not the
+            # sub class being decorated. As such, changes to `lock_optimistically`, or
+            # `locking_column` would not be picked up.
+            def inherited(subclass)
+              subclass.class_eval do
+                is_lock_column = ->(name, _) { lock_optimistically && name == locking_column }
+                decorate_matching_attribute_types(is_lock_column, :_optimistic_locking) do |type|
+                  LockingType.new(type)
+                end
+              end
+              super
+            end
+        end
+    end
+
+    # In de/serialize we change `nil` to 0, so that we can allow passing
+    # `nil` values to `lock_version`, and not result in `ActiveRecord::StaleObjectError`
+    # during update record.
+    class LockingType < DelegateClass(Type::Value) # :nodoc:
+      def deserialize(value)
+        super.to_i
+      end
+
+      def serialize(value)
+        super.to_i
+      end
+
+      def init_with(coder)
+        __setobj__(coder["subtype"])
+      end
+
+      def encode_with(coder)
+        coder["subtype"] = __getobj__
+      end
+    end
+  end
+end

data/lib/active_record/locking/pessimistic.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Locking
+    # Locking::Pessimistic provides support for row-level locking using
+    # SELECT ... FOR UPDATE and other lock types.
+    #
+    # Chain <tt>ActiveRecord::Base#find</tt> to <tt>ActiveRecord::QueryMethods#lock</tt> to obtain an exclusive
+    # lock on the selected rows:
+    #   # select * from accounts where id=1 for update
+    #   Account.lock.find(1)
+    #
+    # Call <tt>lock('some locking clause')</tt> to use a database-specific locking clause
+    # of your own such as 'LOCK IN SHARE MODE' or 'FOR UPDATE NOWAIT'. Example:
+    #
+    #   Account.transaction do
+    #     # select * from accounts where name = 'shugo' limit 1 for update
+    #     shugo = Account.where("name = 'shugo'").lock(true).first
+    #     yuko = Account.where("name = 'yuko'").lock(true).first
+    #     shugo.balance -= 100
+    #     shugo.save!
+    #     yuko.balance += 100
+    #     yuko.save!
+    #   end
+    #
+    # You can also use <tt>ActiveRecord::Base#lock!</tt> method to lock one record by id.
+    # This may be better if you don't need to lock every row. Example:
+    #
+    #   Account.transaction do
+    #     # select * from accounts where ...
+    #     accounts = Account.where(...)
+    #     account1 = accounts.detect { |account| ... }
+    #     account2 = accounts.detect { |account| ... }
+    #     # select * from accounts where id=? for update
+    #     account1.lock!
+    #     account2.lock!
+    #     account1.balance -= 100
+    #     account1.save!
+    #     account2.balance += 100
+    #     account2.save!
+    #   end
+    #
+    # You can start a transaction and acquire the lock in one go by calling
+    # <tt>with_lock</tt> with a block. The block is called from within
+    # a transaction, the object is already locked. Example:
+    #
+    #   account = Account.first
+    #   account.with_lock do
+    #     # This block is called within a transaction,
+    #     # account is already locked.
+    #     account.balance -= 100
+    #     account.save!
+    #   end
+    #
+    # Database-specific information on row locking:
+    #   MySQL: https://dev.mysql.com/doc/refman/5.7/en/innodb-locking-reads.html
+    #   PostgreSQL: https://www.postgresql.org/docs/current/interactive/sql-select.html#SQL-FOR-UPDATE-SHARE
+    module Pessimistic
+      # Obtain a row lock on this record. Reloads the record to obtain the requested
+      # lock. Pass an SQL locking clause to append the end of the SELECT statement
+      # or pass true for "FOR UPDATE" (the default, an exclusive row lock). Returns
+      # the locked record.
+      def lock!(lock = true)
+        if persisted?
+          if has_changes_to_save?
+            raise(<<-MSG.squish)
+              Locking a record with unpersisted changes is not supported. Use
+              `save` to persist the changes, or `reload` to discard them
+              explicitly.
+            MSG
+          end
+
+          reload(lock: lock)
+        end
+        self
+      end
+
+      # Wraps the passed block in a transaction, locking the object
+      # before yielding. You can pass the SQL locking clause
+      # as argument (see <tt>lock!</tt>).
+      def with_lock(lock = true)
+        transaction do
+          lock!(lock)
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/active_record/log_subscriber.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    IGNORE_PAYLOAD_NAMES = ["SCHEMA", "EXPLAIN"]
+
+    def self.runtime=(value)
+      ActiveRecord::RuntimeRegistry.sql_runtime = value
+    end
+
+    def self.runtime
+      ActiveRecord::RuntimeRegistry.sql_runtime ||= 0
+    end
+
+    def self.reset_runtime
+      rt, self.runtime = runtime, 0
+      rt
+    end
+
+    def sql(event)
+      self.class.runtime += event.duration
+      return unless logger.debug?
+
+      payload = event.payload
+
+      return if IGNORE_PAYLOAD_NAMES.include?(payload[:name])
+
+      name  = "#{payload[:name]} (#{event.duration.round(1)}ms)"
+      name  = "CACHE #{name}" if payload[:cached]
+      sql   = payload[:sql]
+      binds = nil
+
+      unless (payload[:binds] || []).empty?
+        casted_params = type_casted_binds(payload[:type_casted_binds])
+        binds = "  " + payload[:binds].zip(casted_params).map { |attr, value|
+          render_bind(attr, value)
+        }.inspect
+      end
+
+      name = colorize_payload_name(name, payload[:name])
+      sql  = color(sql, sql_color(sql), true)
+
+      debug "  #{name}  #{sql}#{binds}"
+    end
+
+    private
+      def type_casted_binds(casted_binds)
+        casted_binds.respond_to?(:call) ? casted_binds.call : casted_binds
+      end
+
+      def render_bind(attr, value)
+        if attr.is_a?(Array)
+          attr = attr.first
+        elsif attr.type.binary? && attr.value
+          value = "<#{attr.value_for_database.to_s.bytesize} bytes of binary data>"
+        end
+
+        [attr && attr.name, value]
+      end
+
+      def colorize_payload_name(name, payload_name)
+        if payload_name.blank? || payload_name == "SQL" # SQL vs Model Load/Exists
+          color(name, MAGENTA, true)
+        else
+          color(name, CYAN, true)
+        end
+      end
+
+      def sql_color(sql)
+        case sql
+        when /\A\s*rollback/mi
+          RED
+        when /select .*for update/mi, /\A\s*lock/mi
+          WHITE
+        when /\A\s*select/i
+          BLUE
+        when /\A\s*insert/i
+          GREEN
+        when /\A\s*update/i
+          YELLOW
+        when /\A\s*delete/i
+          RED
+        when /transaction\s*\Z/i
+          CYAN
+        else
+          MAGENTA
+        end
+      end
+
+      def logger
+        ActiveRecord::Base.logger
+      end
+
+      def debug(progname = nil, &block)
+        return unless super
+
+        if ActiveRecord::Base.verbose_query_logs
+          log_query_source
+        end
+      end
+
+      def log_query_source
+        source_line, line_number = extract_callstack(caller_locations)
+
+        if source_line
+          if defined?(::Rails.root)
+            app_root = "#{::Rails.root.to_s}/".freeze
+            source_line = source_line.sub(app_root, "")
+          end
+
+          logger.debug("  ↳ #{ source_line }:#{ line_number }")
+        end
+      end
+
+      def extract_callstack(callstack)
+        line = callstack.find do |frame|
+          frame.absolute_path && !ignored_callstack(frame.absolute_path)
+        end
+
+        offending_line = line || callstack.first
+
+        [
+          offending_line.path,
+          offending_line.lineno
+        ]
+      end
+
+      RAILS_GEM_ROOT = File.expand_path("../../..", __dir__) + "/"
+
+      def ignored_callstack(path)
+        path.start_with?(RAILS_GEM_ROOT) ||
+        path.start_with?(RbConfig::CONFIG["rubylibdir"])
+      end
+  end
+end
+
+ActiveRecord::LogSubscriber.attach_to :active_record