activerecord 6.0.0

data/lib/active_record/integration.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/filters"
+
+module ActiveRecord
+  module Integration
+    extend ActiveSupport::Concern
+
+    included do
+      ##
+      # :singleton-method:
+      # Indicates the format used to generate the timestamp in the cache key, if
+      # versioning is off. Accepts any of the symbols in <tt>Time::DATE_FORMATS</tt>.
+      #
+      # This is +:usec+, by default.
+      class_attribute :cache_timestamp_format, instance_writer: false, default: :usec
+
+      ##
+      # :singleton-method:
+      # Indicates whether to use a stable #cache_key method that is accompanied
+      # by a changing version in the #cache_version method.
+      #
+      # This is +true+, by default on Rails 5.2 and above.
+      class_attribute :cache_versioning, instance_writer: false, default: false
+
+      ##
+      # :singleton-method:
+      # Indicates whether to use a stable #cache_key method that is accompanied
+      # by a changing version in the #cache_version method on collections.
+      #
+      # This is +false+, by default until Rails 6.1.
+      class_attribute :collection_cache_versioning, instance_writer: false, default: false
+    end
+
+    # Returns a +String+, which Action Pack uses for constructing a URL to this
+    # object. The default implementation returns this record's id as a +String+,
+    # or +nil+ if this record's unsaved.
+    #
+    # For example, suppose that you have a User model, and that you have a
+    # <tt>resources :users</tt> route. Normally, +user_path+ will
+    # construct a path with the user object's 'id' in it:
+    #
+    #   user = User.find_by(name: 'Phusion')
+    #   user_path(user)  # => "/users/1"
+    #
+    # You can override +to_param+ in your model to make +user_path+ construct
+    # a path using the user's name instead of the user's id:
+    #
+    #   class User < ActiveRecord::Base
+    #     def to_param  # overridden
+    #       name
+    #     end
+    #   end
+    #
+    #   user = User.find_by(name: 'Phusion')
+    #   user_path(user)  # => "/users/Phusion"
+    def to_param
+      # We can't use alias_method here, because method 'id' optimizes itself on the fly.
+      id && id.to_s # Be sure to stringify the id for routes
+    end
+
+    # Returns a stable cache key that can be used to identify this record.
+    #
+    #   Product.new.cache_key     # => "products/new"
+    #   Product.find(5).cache_key # => "products/5"
+    #
+    # If ActiveRecord::Base.cache_versioning is turned off, as it was in Rails 5.1 and earlier,
+    # the cache key will also include a version.
+    #
+    #   Product.cache_versioning = false
+    #   Product.find(5).cache_key  # => "products/5-20071224150000" (updated_at available)
+    def cache_key
+      if new_record?
+        "#{model_name.cache_key}/new"
+      else
+        if cache_version
+          "#{model_name.cache_key}/#{id}"
+        else
+          timestamp = max_updated_column_timestamp
+
+          if timestamp
+            timestamp = timestamp.utc.to_s(cache_timestamp_format)
+            "#{model_name.cache_key}/#{id}-#{timestamp}"
+          else
+            "#{model_name.cache_key}/#{id}"
+          end
+        end
+      end
+    end
+
+    # Returns a cache version that can be used together with the cache key to form
+    # a recyclable caching scheme. By default, the #updated_at column is used for the
+    # cache_version, but this method can be overwritten to return something else.
+    #
+    # Note, this method will return nil if ActiveRecord::Base.cache_versioning is set to
+    # +false+ (which it is by default until Rails 6.0).
+    def cache_version
+      return unless cache_versioning
+
+      if has_attribute?("updated_at")
+        timestamp = updated_at_before_type_cast
+        if can_use_fast_cache_version?(timestamp)
+          raw_timestamp_to_cache_version(timestamp)
+        elsif timestamp = updated_at
+          timestamp.utc.to_s(cache_timestamp_format)
+        end
+      else
+        if self.class.has_attribute?("updated_at")
+          raise ActiveModel::MissingAttributeError, "missing attribute: updated_at"
+        end
+      end
+    end
+
+    # Returns a cache key along with the version.
+    def cache_key_with_version
+      if version = cache_version
+        "#{cache_key}-#{version}"
+      else
+        cache_key
+      end
+    end
+
+    module ClassMethods
+      # Defines your model's +to_param+ method to generate "pretty" URLs
+      # using +method_name+, which can be any attribute or method that
+      # responds to +to_s+.
+      #
+      #   class User < ActiveRecord::Base
+      #     to_param :name
+      #   end
+      #
+      #   user = User.find_by(name: 'Fancy Pants')
+      #   user.id         # => 123
+      #   user_path(user) # => "/users/123-fancy-pants"
+      #
+      # Values longer than 20 characters will be truncated. The value
+      # is truncated word by word.
+      #
+      #   user = User.find_by(name: 'David Heinemeier Hansson')
+      #   user.id         # => 125
+      #   user_path(user) # => "/users/125-david-heinemeier"
+      #
+      # Because the generated param begins with the record's +id+, it is
+      # suitable for passing to +find+. In a controller, for example:
+      #
+      #   params[:id]               # => "123-fancy-pants"
+      #   User.find(params[:id]).id # => 123
+      def to_param(method_name = nil)
+        if method_name.nil?
+          super()
+        else
+          define_method :to_param do
+            if (default = super()) &&
+                 (result = send(method_name).to_s).present? &&
+                   (param = result.squish.parameterize.truncate(20, separator: /-/, omission: "")).present?
+              "#{default}-#{param}"
+            else
+              default
+            end
+          end
+        end
+      end
+
+      def collection_cache_key(collection = all, timestamp_column = :updated_at) # :nodoc:
+        collection.send(:compute_cache_key, timestamp_column)
+      end
+    end
+
+    private
+      # Detects if the value before type cast
+      # can be used to generate a cache_version.
+      #
+      # The fast cache version only works with a
+      # string value directly from the database.
+      #
+      # We also must check if the timestamp format has been changed
+      # or if the timezone is not set to UTC then
+      # we cannot apply our transformations correctly.
+      def can_use_fast_cache_version?(timestamp)
+        timestamp.is_a?(String) &&
+          cache_timestamp_format == :usec &&
+          default_timezone == :utc &&
+          !updated_at_came_from_user?
+      end
+
+      # Converts a raw database string to `:usec`
+      # format.
+      #
+      # Example:
+      #
+      #   timestamp = "2018-10-15 20:02:15.266505"
+      #   raw_timestamp_to_cache_version(timestamp)
+      #   # => "20181015200215266505"
+      #
+      # PostgreSQL truncates trailing zeros,
+      # https://github.com/postgres/postgres/commit/3e1beda2cde3495f41290e1ece5d544525810214
+      # to account for this we pad the output with zeros
+      def raw_timestamp_to_cache_version(timestamp)
+        key = timestamp.delete("- :.")
+        if key.length < 20
+          key.ljust(20, "0")
+        else
+          key
+        end
+      end
+  end
+end

data/lib/active_record/internal_metadata.rb

@@ -0,0 +1,53 @@
+# 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 _internal?
+        true
+      end
+
+      def primary_key
+        "key"
+      end
+
+      def table_name
+        "#{table_name_prefix}#{internal_metadata_table_name}#{table_name_suffix}"
+      end
+
+      def []=(key, value)
+        find_or_initialize_by(key: key).update!(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
+
+      def drop_table
+        connection.drop_table table_name, if_exists: true
+      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,197 @@
+# 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)
+          @_touch_attr_names << self.class.locking_column if locking_enabled?
+          super
+        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),
+              @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(
+            @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