activerecord 6.0.0

data/lib/active_record/secure_token.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module SecureToken
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Example using #has_secure_token
+      #
+      #   # Schema: User(token:string, auth_token:string)
+      #   class User < ActiveRecord::Base
+      #     has_secure_token
+      #     has_secure_token :auth_token
+      #   end
+      #
+      #   user = User.new
+      #   user.save
+      #   user.token # => "pX27zsMN2ViQKta1bGfLmVJE"
+      #   user.auth_token # => "77TMHrHJFvFDwodq8w7Ev2m7"
+      #   user.regenerate_token # => true
+      #   user.regenerate_auth_token # => true
+      #
+      # <tt>SecureRandom::base58</tt> is used to generate the 24-character unique token, so collisions are highly unlikely.
+      #
+      # Note that it's still possible to generate a race condition in the database in the same way that
+      # {validates_uniqueness_of}[rdoc-ref:Validations::ClassMethods#validates_uniqueness_of] can.
+      # You're encouraged to add a unique index in the database to deal with this even more unlikely scenario.
+      def has_secure_token(attribute = :token)
+        # Load securerandom only when has_secure_token is used.
+        require "active_support/core_ext/securerandom"
+        define_method("regenerate_#{attribute}") { update! attribute => self.class.generate_unique_secure_token }
+        before_create { send("#{attribute}=", self.class.generate_unique_secure_token) unless send("#{attribute}?") }
+      end
+
+      def generate_unique_secure_token
+        SecureRandom.base58(24)
+      end
+    end
+  end
+end

data/lib/active_record/serialization.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ActiveRecord #:nodoc:
+  # = Active Record \Serialization
+  module Serialization
+    extend ActiveSupport::Concern
+    include ActiveModel::Serializers::JSON
+
+    included do
+      self.include_root_in_json = false
+    end
+
+    def serializable_hash(options = nil)
+      options = options.try(:dup) || {}
+
+      options[:except] = Array(options[:except]).map(&:to_s)
+      options[:except] |= Array(self.class.inheritance_column)
+
+      super(options)
+    end
+  end
+end

data/lib/active_record/statement_cache.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  # Statement cache is used to cache a single statement in order to avoid creating the AST again.
+  # Initializing the cache is done by passing the statement in the create block:
+  #
+  #   cache = StatementCache.create(Book.connection) do |params|
+  #     Book.where(name: "my book").where("author_id > 3")
+  #   end
+  #
+  # The cached statement is executed by using the
+  # {connection.execute}[rdoc-ref:ConnectionAdapters::DatabaseStatements#execute] method:
+  #
+  #   cache.execute([], Book.connection)
+  #
+  # The relation returned by the block is cached, and for each
+  # {execute}[rdoc-ref:ConnectionAdapters::DatabaseStatements#execute]
+  # call the cached relation gets duped. Database is queried when +to_a+ is called on the relation.
+  #
+  # If you want to cache the statement without the values you can use the +bind+ method of the
+  # block parameter.
+  #
+  #   cache = StatementCache.create(Book.connection) do |params|
+  #     Book.where(name: params.bind)
+  #   end
+  #
+  # And pass the bind values as the first argument of +execute+ call.
+  #
+  #   cache.execute(["my book"], Book.connection)
+  class StatementCache # :nodoc:
+    class Substitute; end # :nodoc:
+
+    class Query # :nodoc:
+      def initialize(sql)
+        @sql = sql
+      end
+
+      def sql_for(binds, connection)
+        @sql
+      end
+    end
+
+    class PartialQuery < Query # :nodoc:
+      def initialize(values)
+        @values = values
+        @indexes = values.each_with_index.find_all { |thing, i|
+          Substitute === thing
+        }.map(&:last)
+      end
+
+      def sql_for(binds, connection)
+        val = @values.dup
+        casted_binds = binds.map(&:value_for_database)
+        @indexes.each { |i| val[i] = connection.quote(casted_binds.shift) }
+        val.join
+      end
+    end
+
+    class PartialQueryCollector
+      def initialize
+        @parts = []
+        @binds = []
+      end
+
+      def <<(str)
+        @parts << str
+        self
+      end
+
+      def add_bind(obj)
+        @binds << obj
+        @parts << Substitute.new
+        self
+      end
+
+      def value
+        [@parts, @binds]
+      end
+    end
+
+    def self.query(sql)
+      Query.new(sql)
+    end
+
+    def self.partial_query(values)
+      PartialQuery.new(values)
+    end
+
+    def self.partial_query_collector
+      PartialQueryCollector.new
+    end
+
+    class Params # :nodoc:
+      def bind; Substitute.new; end
+    end
+
+    class BindMap # :nodoc:
+      def initialize(bound_attributes)
+        @indexes = []
+        @bound_attributes = bound_attributes
+
+        bound_attributes.each_with_index do |attr, i|
+          if Substitute === attr.value
+            @indexes << i
+          end
+        end
+      end
+
+      def bind(values)
+        bas = @bound_attributes.dup
+        @indexes.each_with_index { |offset, i| bas[offset] = bas[offset].with_cast_value(values[i]) }
+        bas
+      end
+    end
+
+    def self.create(connection, callable = nil, &block)
+      relation = (callable || block).call Params.new
+      query_builder, binds = connection.cacheable_query(self, relation.arel)
+      bind_map = BindMap.new(binds)
+      new(query_builder, bind_map, relation.klass)
+    end
+
+    def initialize(query_builder, bind_map, klass)
+      @query_builder = query_builder
+      @bind_map = bind_map
+      @klass = klass
+    end
+
+    def execute(params, connection, &block)
+      bind_values = bind_map.bind params
+
+      sql = query_builder.sql_for bind_values, connection
+
+      klass.find_by_sql(sql, bind_values, preparable: true, &block)
+    rescue ::RangeError
+      nil
+    end
+
+    def self.unsupported_value?(value)
+      case value
+      when NilClass, Array, Range, Hash, Relation, Base then true
+      end
+    end
+
+    private
+      attr_reader :query_builder, :bind_map, :klass
+  end
+end

data/lib/active_record/store.rb

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/indifferent_access"
+
+module ActiveRecord
+  # Store gives you a thin wrapper around serialize for the purpose of storing hashes in a single column.
+  # It's like a simple key/value store baked into your record when you don't care about being able to
+  # query that store outside the context of a single record.
+  #
+  # You can then declare accessors to this store that are then accessible just like any other attribute
+  # of the model. This is very helpful for easily exposing store keys to a form or elsewhere that's
+  # already built around just accessing attributes on the model.
+  #
+  # Every accessor comes with dirty tracking methods (+key_changed?+, +key_was+ and +key_change+) and
+  # methods to access the changes made during the last save (+saved_change_to_key?+, +saved_change_to_key+ and
+  # +key_before_last_save+).
+  #
+  # NOTE: There is no +key_will_change!+ method for accessors, use +store_will_change!+ instead.
+  #
+  # Make sure that you declare the database column used for the serialized store as a text, so there's
+  # plenty of room.
+  #
+  # You can set custom coder to encode/decode your serialized attributes to/from different formats.
+  # JSON, YAML, Marshal are supported out of the box. Generally it can be any wrapper that provides +load+ and +dump+.
+  #
+  # NOTE: If you are using structured database data types (eg. PostgreSQL +hstore+/+json+, or MySQL 5.7+
+  # +json+) there is no need for the serialization provided by {.store}[rdoc-ref:rdoc-ref:ClassMethods#store].
+  # Simply use {.store_accessor}[rdoc-ref:ClassMethods#store_accessor] instead to generate
+  # the accessor methods. Be aware that these columns use a string keyed hash and do not allow access
+  # using a symbol.
+  #
+  # NOTE: The default validations with the exception of +uniqueness+ will work.
+  # For example, if you want to check for +uniqueness+ with +hstore+ you will
+  # need to use a custom validation to handle it.
+  #
+  # Examples:
+  #
+  #   class User < ActiveRecord::Base
+  #     store :settings, accessors: [ :color, :homepage ], coder: JSON
+  #     store :parent, accessors: [ :name ], coder: JSON, prefix: true
+  #     store :spouse, accessors: [ :name ], coder: JSON, prefix: :partner
+  #     store :settings, accessors: [ :two_factor_auth ], suffix: true
+  #     store :settings, accessors: [ :login_retry ], suffix: :config
+  #   end
+  #
+  #   u = User.new(color: 'black', homepage: '37signals.com', parent_name: 'Mary', partner_name: 'Lily')
+  #   u.color                          # Accessor stored attribute
+  #   u.parent_name                    # Accessor stored attribute with prefix
+  #   u.partner_name                   # Accessor stored attribute with custom prefix
+  #   u.two_factor_auth_settings       # Accessor stored attribute with suffix
+  #   u.login_retry_config             # Accessor stored attribute with custom suffix
+  #   u.settings[:country] = 'Denmark' # Any attribute, even if not specified with an accessor
+  #
+  #   # There is no difference between strings and symbols for accessing custom attributes
+  #   u.settings[:country]  # => 'Denmark'
+  #   u.settings['country'] # => 'Denmark'
+  #
+  #   # Dirty tracking
+  #   u.color = 'green'
+  #   u.color_changed? # => true
+  #   u.color_was # => 'black'
+  #   u.color_change # => ['black', 'red']
+  #
+  #   # Add additional accessors to an existing store through store_accessor
+  #   class SuperUser < User
+  #     store_accessor :settings, :privileges, :servants
+  #     store_accessor :parent, :birthday, prefix: true
+  #     store_accessor :settings, :secret_question, suffix: :config
+  #   end
+  #
+  # The stored attribute names can be retrieved using {.stored_attributes}[rdoc-ref:rdoc-ref:ClassMethods#stored_attributes].
+  #
+  #   User.stored_attributes[:settings] # [:color, :homepage, :two_factor_auth, :login_retry]
+  #
+  # == Overwriting default accessors
+  #
+  # All stored values are automatically available through accessors on the Active Record
+  # object, but sometimes you want to specialize this behavior. This can be done by overwriting
+  # the default accessors (using the same name as the attribute) and calling <tt>super</tt>
+  # to actually change things.
+  #
+  #   class Song < ActiveRecord::Base
+  #     # Uses a stored integer to hold the volume adjustment of the song
+  #     store :settings, accessors: [:volume_adjustment]
+  #
+  #     def volume_adjustment=(decibels)
+  #       super(decibels.to_i)
+  #     end
+  #
+  #     def volume_adjustment
+  #       super.to_i
+  #     end
+  #   end
+  module Store
+    extend ActiveSupport::Concern
+
+    included do
+      class << self
+        attr_accessor :local_stored_attributes
+      end
+    end
+
+    module ClassMethods
+      def store(store_attribute, options = {})
+        serialize store_attribute, IndifferentCoder.new(store_attribute, options[:coder])
+        store_accessor(store_attribute, options[:accessors], options.slice(:prefix, :suffix)) if options.has_key? :accessors
+      end
+
+      def store_accessor(store_attribute, *keys, prefix: nil, suffix: nil)
+        keys = keys.flatten
+
+        accessor_prefix =
+          case prefix
+          when String, Symbol
+            "#{prefix}_"
+          when TrueClass
+            "#{store_attribute}_"
+          else
+            ""
+          end
+        accessor_suffix =
+          case suffix
+          when String, Symbol
+            "_#{suffix}"
+          when TrueClass
+            "_#{store_attribute}"
+          else
+            ""
+          end
+
+        _store_accessors_module.module_eval do
+          keys.each do |key|
+            accessor_key = "#{accessor_prefix}#{key}#{accessor_suffix}"
+
+            define_method("#{accessor_key}=") do |value|
+              write_store_attribute(store_attribute, key, value)
+            end
+
+            define_method(accessor_key) do
+              read_store_attribute(store_attribute, key)
+            end
+
+            define_method("#{accessor_key}_changed?") do
+              return false unless attribute_changed?(store_attribute)
+              prev_store, new_store = changes[store_attribute]
+              prev_store&.dig(key) != new_store&.dig(key)
+            end
+
+            define_method("#{accessor_key}_change") do
+              return unless attribute_changed?(store_attribute)
+              prev_store, new_store = changes[store_attribute]
+              [prev_store&.dig(key), new_store&.dig(key)]
+            end
+
+            define_method("#{accessor_key}_was") do
+              return unless attribute_changed?(store_attribute)
+              prev_store, _new_store = changes[store_attribute]
+              prev_store&.dig(key)
+            end
+
+            define_method("saved_change_to_#{accessor_key}?") do
+              return false unless saved_change_to_attribute?(store_attribute)
+              prev_store, new_store = saved_change_to_attribute(store_attribute)
+              prev_store&.dig(key) != new_store&.dig(key)
+            end
+
+            define_method("saved_change_to_#{accessor_key}") do
+              return unless saved_change_to_attribute?(store_attribute)
+              prev_store, new_store = saved_change_to_attribute(store_attribute)
+              [prev_store&.dig(key), new_store&.dig(key)]
+            end
+
+            define_method("#{accessor_key}_before_last_save") do
+              return unless saved_change_to_attribute?(store_attribute)
+              prev_store, _new_store = saved_change_to_attribute(store_attribute)
+              prev_store&.dig(key)
+            end
+          end
+        end
+
+        # assign new store attribute and create new hash to ensure that each class in the hierarchy
+        # has its own hash of stored attributes.
+        self.local_stored_attributes ||= {}
+        self.local_stored_attributes[store_attribute] ||= []
+        self.local_stored_attributes[store_attribute] |= keys
+      end
+
+      def _store_accessors_module # :nodoc:
+        @_store_accessors_module ||= begin
+          mod = Module.new
+          include mod
+          mod
+        end
+      end
+
+      def stored_attributes
+        parent = superclass.respond_to?(:stored_attributes) ? superclass.stored_attributes : {}
+        if local_stored_attributes
+          parent.merge!(local_stored_attributes) { |k, a, b| a | b }
+        end
+        parent
+      end
+    end
+
+    private
+      def read_store_attribute(store_attribute, key) # :doc:
+        accessor = store_accessor_for(store_attribute)
+        accessor.read(self, store_attribute, key)
+      end
+
+      def write_store_attribute(store_attribute, key, value) # :doc:
+        accessor = store_accessor_for(store_attribute)
+        accessor.write(self, store_attribute, key, value)
+      end
+
+      def store_accessor_for(store_attribute)
+        type_for_attribute(store_attribute).accessor
+      end
+
+      class HashAccessor # :nodoc:
+        def self.read(object, attribute, key)
+          prepare(object, attribute)
+          object.public_send(attribute)[key]
+        end
+
+        def self.write(object, attribute, key, value)
+          prepare(object, attribute)
+          if value != read(object, attribute, key)
+            object.public_send :"#{attribute}_will_change!"
+            object.public_send(attribute)[key] = value
+          end
+        end
+
+        def self.prepare(object, attribute)
+          object.public_send :"#{attribute}=", {} unless object.send(attribute)
+        end
+      end
+
+      class StringKeyedHashAccessor < HashAccessor # :nodoc:
+        def self.read(object, attribute, key)
+          super object, attribute, key.to_s
+        end
+
+        def self.write(object, attribute, key, value)
+          super object, attribute, key.to_s, value
+        end
+      end
+
+      class IndifferentHashAccessor < ActiveRecord::Store::HashAccessor # :nodoc:
+        def self.prepare(object, store_attribute)
+          attribute = object.send(store_attribute)
+          unless attribute.is_a?(ActiveSupport::HashWithIndifferentAccess)
+            attribute = IndifferentCoder.as_indifferent_hash(attribute)
+            object.send :"#{store_attribute}=", attribute
+          end
+          attribute
+        end
+      end
+
+      class IndifferentCoder # :nodoc:
+        def initialize(attr_name, coder_or_class_name)
+          @coder =
+            if coder_or_class_name.respond_to?(:load) && coder_or_class_name.respond_to?(:dump)
+              coder_or_class_name
+            else
+              ActiveRecord::Coders::YAMLColumn.new(attr_name, coder_or_class_name || Object)
+            end
+        end
+
+        def dump(obj)
+          @coder.dump self.class.as_indifferent_hash(obj)
+        end
+
+        def load(yaml)
+          self.class.as_indifferent_hash(@coder.load(yaml || ""))
+        end
+
+        def self.as_indifferent_hash(obj)
+          case obj
+          when ActiveSupport::HashWithIndifferentAccess
+            obj
+          when Hash
+            obj.with_indifferent_access
+          else
+            ActiveSupport::HashWithIndifferentAccess.new
+          end
+        end
+      end
+  end
+end