activerecord 6.1.6 → 7.1.2

data/lib/active_record/model_schema.rb

@@ -6,6 +6,13 @@ module ActiveRecord
   module ModelSchema
     extend ActiveSupport::Concern
 
+    ##
+    # :method: id_value
+    # :call-seq: id_value
+    #
+    # Returns the underlying column value for a column named "id". Useful when defining
+    # a composite primary key including an "id" column so that the value is readable.
+
     ##
     # :singleton-method: primary_key_prefix_type
     # :call-seq: primary_key_prefix_type
@@ -126,9 +133,29 @@ module ActiveRecord
     # +:immutable_string+. This setting does not affect the behavior of
     # <tt>attribute :foo, :string</tt>. Defaults to false.
 
-    included do
-      mattr_accessor :primary_key_prefix_type, instance_writer: false
+    ##
+    # :singleton-method: inheritance_column
+    # :call-seq: inheritance_column
+    #
+    # The name of the table column which stores the class name on single-table
+    # inheritance situations.
+    #
+    # The default inheritance column name is +type+, which means it's a
+    # reserved word inside Active Record. To be able to use single-table
+    # inheritance with another column name, or to use the column +type+ in
+    # your own model for something else, you can set +inheritance_column+:
+    #
+    #     self.inheritance_column = 'zoink'
+
+    ##
+    # :singleton-method: inheritance_column=
+    # :call-seq: inheritance_column=(column)
+    #
+    # Defines the name of the table column which will store the class name on single-table
+    # inheritance situations.
 
+    included do
+      class_attribute :primary_key_prefix_type, instance_writer: false
       class_attribute :table_name_prefix, instance_writer: false, default: ""
       class_attribute :table_name_suffix, instance_writer: false, default: ""
       class_attribute :schema_migrations_table_name, instance_accessor: false, default: "schema_migrations"
@@ -137,8 +164,15 @@ module ActiveRecord
       class_attribute :implicit_order_column, instance_accessor: false
       class_attribute :immutable_strings_by_default, instance_accessor: false
 
+      class_attribute :inheritance_column, instance_accessor: false, default: "type"
+      singleton_class.class_eval do
+        alias_method :_inheritance_column=, :inheritance_column=
+        private :_inheritance_column=
+        alias_method :inheritance_column=, :real_inheritance_column=
+      end
+
       self.protected_environments = ["production"]
-      self.inheritance_column = "type"
+
       self.ignored_columns = [].freeze
 
       delegate :type_for_attribute, :column_for_attribute, to: :class
@@ -153,8 +187,9 @@ module ActiveRecord
     #   artists, records => artists_records
     #   records, artists => artists_records
     #   music_artists, music_records => music_artists_records
+    #   music.artists, music.records => music.artists_records
     def self.derive_join_table_name(first_table, second_table) # :nodoc:
-      [first_table.to_s, second_table.to_s].sort.join("\0").gsub(/^(.*_)(.+)\0\1(.+)/, '\1\2_\3').tr("\0", "_")
+      [first_table.to_s, second_table.to_s].sort.join("\0").gsub(/^(.*[_.])(.+)\0\1(.+)/, '\1\2_\3').tr("\0", "_")
     end
 
     module ClassMethods
@@ -197,6 +232,21 @@ module ActiveRecord
       # the table name guess for an Invoice class becomes "myapp_invoices".
       # Invoice::Lineitem becomes "myapp_invoice_lineitems".
       #
+      # Active Model Naming's +model_name+ is the base name used to guess the
+      # table name. In case a custom Active Model Name is defined, it will be
+      # used for the table name as well:
+      #
+      #   class PostRecord < ActiveRecord::Base
+      #     class << self
+      #       def model_name
+      #         ActiveModel::Name.new(self, nil, "Post")
+      #       end
+      #     end
+      #   end
+      #
+      #   PostRecord.table_name
+      #   # => "posts"
+      #
       # You can also set your own table name explicitly:
       #
       #   class Mouse < ActiveRecord::Base
@@ -233,9 +283,11 @@ module ActiveRecord
       end
 
       # Computes the table name, (re)sets it internally, and returns it.
-      def reset_table_name #:nodoc:
-        self.table_name = if abstract_class?
-          superclass == Base ? nil : superclass.table_name
+      def reset_table_name # :nodoc:
+        self.table_name = if self == Base
+          nil
+        elsif abstract_class?
+          superclass.table_name
         elsif superclass.abstract_class?
           superclass.table_name || compute_table_name
         else
@@ -243,11 +295,11 @@ module ActiveRecord
         end
       end
 
-      def full_table_name_prefix #:nodoc:
+      def full_table_name_prefix # :nodoc:
         (module_parents.detect { |p| p.respond_to?(:table_name_prefix) } || self).table_name_prefix
       end
 
-      def full_table_name_suffix #:nodoc:
+      def full_table_name_suffix # :nodoc:
         (module_parents.detect { |p| p.respond_to?(:table_name_suffix) } || self).table_name_suffix
       end
 
@@ -266,33 +318,14 @@ module ActiveRecord
         @protected_environments = environments.map(&:to_s)
       end
 
-      # Defines the name of the table column which will store the class name on single-table
-      # inheritance situations.
-      #
-      # The default inheritance column name is +type+, which means it's a
-      # reserved word inside Active Record. To be able to use single-table
-      # inheritance with another column name, or to use the column +type+ in
-      # your own model for something else, you can set +inheritance_column+:
-      #
-      #     self.inheritance_column = 'zoink'
-      def inheritance_column
-        (@inheritance_column ||= nil) || superclass.inheritance_column
-      end
-
-      # Sets the value of inheritance_column
-      def inheritance_column=(value)
-        @inheritance_column = value.to_s
-        @explicit_inheritance_column = true
+      def real_inheritance_column=(value) # :nodoc:
+        self._inheritance_column = value.to_s
       end
 
       # The list of columns names the model should ignore. Ignored columns won't have attribute
       # accessors defined, and won't be referenced in SQL queries.
       def ignored_columns
-        if defined?(@ignored_columns)
-          @ignored_columns
-        else
-          superclass.ignored_columns
-        end
+        @ignored_columns || superclass.ignored_columns
       end
 
       # Sets the columns names the model should ignore. Ignored columns won't have attribute
@@ -313,7 +346,7 @@ module ActiveRecord
       #     #   name       :string, limit: 255
       #     #   category   :string, limit: 255
       #
-      #     self.ignored_columns = [:category]
+      #     self.ignored_columns += [:category]
       #   end
       #
       # The schema still contains "category", but now the model omits it, so any meta-driven code or
@@ -339,7 +372,7 @@ module ActiveRecord
         end
       end
 
-      def reset_sequence_name #:nodoc:
+      def reset_sequence_name # :nodoc:
         @explicit_sequence_name = false
         @sequence_name          = connection.default_sequence_name(table_name, primary_key)
       end
@@ -398,6 +431,12 @@ module ActiveRecord
         @columns ||= columns_hash.values.freeze
       end
 
+      def _returning_columns_for_insert # :nodoc:
+        @_returning_columns_for_insert ||= columns.filter_map do |c|
+          c.name if connection.return_value_after_insert?(c)
+        end
+      end
+
       def attribute_types # :nodoc:
         load_schema
         @attribute_types ||= Hash.new(Type.default_value)
@@ -430,7 +469,7 @@ module ActiveRecord
       end
 
       # Returns the column object for the named attribute.
-      # Returns an +ActiveRecord::ConnectionAdapters::NullColumn+ if the
+      # Returns an ActiveRecord::ConnectionAdapters::NullColumn if the
       # named attribute does not exist.
       #
       #   class Person < ActiveRecord::Base
@@ -486,9 +525,9 @@ module ActiveRecord
       #
       # The most common usage pattern for this method is probably in a migration,
       # when just after creating a table you want to populate it with some default
-      # values, eg:
+      # values, e.g.:
       #
-      #  class CreateJobLevels < ActiveRecord::Migration[6.0]
+      #  class CreateJobLevels < ActiveRecord::Migration[7.1]
       #    def up
       #      create_table :job_levels do |t|
       #        t.integer :id
@@ -516,35 +555,61 @@ module ActiveRecord
         initialize_find_by_cache
       end
 
+      def load_schema # :nodoc:
+        return if schema_loaded?
+        @load_schema_monitor.synchronize do
+          return if @columns_hash
+
+          load_schema!
+
+          @schema_loaded = true
+        rescue
+          reload_schema_from_cache # If the schema loading failed half way through, we must reset the state.
+          raise
+        end
+      end
+
       protected
         def initialize_load_schema_monitor
           @load_schema_monitor = Monitor.new
         end
 
+        def reload_schema_from_cache(recursive = true)
+          @_returning_columns_for_insert = nil
+          @arel_table = nil
+          @column_names = nil
+          @symbol_column_to_string_name_hash = nil
+          @attribute_types = nil
+          @content_columns = nil
+          @default_attributes = nil
+          @column_defaults = nil
+          @attributes_builder = nil
+          @columns = nil
+          @columns_hash = nil
+          @schema_loaded = false
+          @attribute_names = nil
+          @yaml_encoder = nil
+          if recursive
+            subclasses.each do |descendant|
+              descendant.send(:reload_schema_from_cache)
+            end
+          end
+        end
+
       private
         def inherited(child_class)
           super
           child_class.initialize_load_schema_monitor
+          child_class.reload_schema_from_cache(false)
+          child_class.class_eval do
+            @ignored_columns = nil
+          end
         end
 
         def schema_loaded?
           defined?(@schema_loaded) && @schema_loaded
         end
 
-        def load_schema
-          return if schema_loaded?
-          @load_schema_monitor.synchronize do
-            return if defined?(@columns_hash) && @columns_hash
-
-            load_schema!
-
-            @schema_loaded = true
-          rescue
-            reload_schema_from_cache # If the schema loading failed half way through, we must reset the state.
-            raise
-          end
-        end
-
         def load_schema!
           unless table_name
             raise ActiveRecord::TableNotSpecified, "#{self} has no table configured. Set one with #{self}.table_name="
@@ -556,39 +621,19 @@ module ActiveRecord
           @columns_hash.each do |name, column|
             type = connection.lookup_cast_type_from_column(column)
             type = _convert_type_from_options(type)
-            warn_if_deprecated_type(column)
             define_attribute(
               name,
               type,
               default: column.default,
               user_provided_default: false
             )
-          end
-        end
-
-        def reload_schema_from_cache
-          @arel_table = nil
-          @column_names = nil
-          @symbol_column_to_string_name_hash = nil
-          @attribute_types = nil
-          @content_columns = nil
-          @default_attributes = nil
-          @column_defaults = nil
-          @inheritance_column = nil unless defined?(@explicit_inheritance_column) && @explicit_inheritance_column
-          @attributes_builder = nil
-          @columns = nil
-          @columns_hash = nil
-          @schema_loaded = false
-          @attribute_names = nil
-          @yaml_encoder = nil
-          direct_descendants.each do |descendant|
-            descendant.send(:reload_schema_from_cache)
+            alias_attribute :id_value, :id if name == "id"
           end
         end
 
         # Guesses the table name, but does not decorate it with prefix and suffix information.
-        def undecorated_table_name(class_name = base_class.name)
-          table_name = class_name.to_s.demodulize.underscore
+        def undecorated_table_name(model_name)
+          table_name = model_name.to_s.demodulize.underscore
           pluralize_table_names ? table_name.pluralize : table_name
         end
 
@@ -602,9 +647,9 @@ module ActiveRecord
               contained += "_"
             end
 
-            "#{full_table_name_prefix}#{contained}#{undecorated_table_name(name)}#{full_table_name_suffix}"
+            "#{full_table_name_prefix}#{contained}#{undecorated_table_name(model_name)}#{full_table_name_suffix}"
           else
-            # STI subclasses always use their superclass' table.
+            # STI subclasses always use their superclass's table.
             base_class.table_name
           end
         end
@@ -616,32 +661,6 @@ module ActiveRecord
             type
           end
         end
-
-        def warn_if_deprecated_type(column)
-          return if attributes_to_define_after_schema_loads.key?(column.name)
-          return unless column.respond_to?(:oid)
-
-          if column.array?
-            array_arguments = ", array: true"
-          else
-            array_arguments = ""
-          end
-
-          if column.sql_type.start_with?("interval")
-            precision_arguments = column.precision.presence && ", precision: #{column.precision}"
-            ActiveSupport::Deprecation.warn(<<~WARNING)
-              The behavior of the `:interval` type will be changing in Rails 7.0
-              to return an `ActiveSupport::Duration` object. If you'd like to keep
-              the old behavior, you can add this line to #{self.name} model:
-
-                attribute :#{column.name}, :string#{precision_arguments}#{array_arguments}
-
-              If you'd like the new behavior today, you can add this line:
-
-                attribute :#{column.name}, :interval#{precision_arguments}#{array_arguments}
-            WARNING
-          end
-        end
     end
   end
 end

data/lib/active_record/nested_attributes.rb

@@ -5,7 +5,7 @@ require "active_support/core_ext/module/redefine_method"
 require "active_support/core_ext/hash/indifferent_access"
 
 module ActiveRecord
-  module NestedAttributes #:nodoc:
+  module NestedAttributes # :nodoc:
     class TooManyRecords < ActiveRecordError
     end
 
@@ -15,7 +15,7 @@ module ActiveRecord
       class_attribute :nested_attributes_options, instance_writer: false, default: {}
     end
 
-    # = Active Record Nested Attributes
+    # = Active Record Nested \Attributes
     #
     # Nested attributes allow you to save attributes on associated records
     # through the parent. By default nested attribute updating is turned off
@@ -180,7 +180,7 @@ module ActiveRecord
     #   member.posts.second.title # => '[UPDATED] other post'
     #
     # However, the above applies if the parent model is being updated as well.
-    # For example, If you wanted to create a +member+ named _joe_ and wanted to
+    # For example, if you wanted to create a +member+ named _joe_ and wanted to
     # update the +posts+ at the same time, that would give an
     # ActiveRecord::RecordNotFound error.
     #
@@ -245,18 +245,19 @@ module ActiveRecord
     #
     # === Validating the presence of a parent model
     #
-    # If you want to validate that a child record is associated with a parent
-    # record, you can use the +validates_presence_of+ method and the +:inverse_of+
-    # key as this example illustrates:
+    # The +belongs_to+ association validates the presence of the parent model
+    # by default. You can disable this behavior by specifying <code>optional: true</code>.
+    # This can be used, for example, when conditionally validating the presence
+    # of the parent model:
     #
-    #   class Member < ActiveRecord::Base
-    #     has_many :posts, inverse_of: :member
-    #     accepts_nested_attributes_for :posts
+    #   class Veterinarian < ActiveRecord::Base
+    #     has_many :patients, inverse_of: :veterinarian
+    #     accepts_nested_attributes_for :patients
     #   end
     #
-    #   class Post < ActiveRecord::Base
-    #     belongs_to :member, inverse_of: :posts
-    #     validates_presence_of :member
+    #   class Patient < ActiveRecord::Base
+    #     belongs_to :veterinarian, inverse_of: :patients, optional: true
+    #     validates :veterinarian, presence: true, unless: -> { awaiting_intake }
     #   end
     #
     # Note that if you do not specify the +:inverse_of+ option, then
@@ -279,6 +280,24 @@ module ActiveRecord
     #   member = Member.new
     #   member.avatar_attributes = {icon: 'sad'}
     #   member.avatar.width # => 200
+    #
+    # === Creating forms with nested attributes
+    #
+    # Use ActionView::Helpers::FormHelper#fields_for to create form elements for
+    # nested attributes.
+    #
+    # Integration test params should reflect the structure of the form. For
+    # example:
+    #
+    #   post members_path, params: {
+    #     member: {
+    #       name: 'joe',
+    #       posts_attributes: {
+    #         '0' => { title: 'Foo' },
+    #         '1' => { title: 'Bar' }
+    #       }
+    #     }
+    #   }
     module ClassMethods
       REJECT_ALL_BLANK_PROC = proc { |attributes| attributes.all? { |key, value| key == "_destroy" || value.blank? } }
 
@@ -288,7 +307,7 @@ module ActiveRecord
       # [:allow_destroy]
       #   If true, destroys any members from the attributes hash with a
       #   <tt>_destroy</tt> key and a value that evaluates to +true+
-      #   (e.g. 1, '1', true, or 'true'). This option is off by default.
+      #   (e.g. 1, '1', true, or 'true'). This option is false by default.
       # [:reject_if]
       #   Allows you to specify a Proc or a Symbol pointing to a method
       #   that checks whether a record should be built for a certain attribute
@@ -313,11 +332,11 @@ module ActiveRecord
       #   nested attributes are going to be used when an associated record already
       #   exists. In general, an existing record may either be updated with the
       #   new set of attribute values or be replaced by a wholly new record
-      #   containing those values. By default the +:update_only+ option is +false+
+      #   containing those values. By default the +:update_only+ option is false
       #   and the nested attributes are used to update the existing record only
       #   if they include the record's <tt>:id</tt> value. Otherwise a new
       #   record will be instantiated and used to replace the existing one.
-      #   However if the +:update_only+ option is +true+, the nested attributes
+      #   However if the +:update_only+ option is true, the nested attributes
       #   are used to update the record's attributes always, regardless of
       #   whether the <tt>:id</tt> is present. The option is ignored for collection
       #   associations.
@@ -374,11 +393,11 @@ module ActiveRecord
         end
     end
 
-    # Returns ActiveRecord::AutosaveAssociation::marked_for_destruction? It's
+    # Returns ActiveRecord::AutosaveAssociation#marked_for_destruction? It's
     # used in conjunction with fields_for to build a form element for the
     # destruction of this association.
     #
-    # See ActionView::Helpers::FormHelper::fields_for for more info.
+    # See ActionView::Helpers::FormHelper#fields_for for more info.
     def _destroy
       marked_for_destruction?
     end
@@ -486,7 +505,7 @@ module ActiveRecord
         existing_records = if association.loaded?
           association.target
         else
-          attribute_ids = attributes_collection.map { |a| a["id"] || a[:id] }.compact
+          attribute_ids = attributes_collection.filter_map { |a| a["id"] || a[:id] }
           attribute_ids.empty? ? [] : association.scope.where(association.klass.primary_key => attribute_ids)
         end
 

data/lib/active_record/no_touching.rb

@@ -26,20 +26,20 @@ module ActiveRecord
     end
 
     class << self
-      def apply_to(klass) #:nodoc:
+      def apply_to(klass) # :nodoc:
         klasses.push(klass)
         yield
       ensure
         klasses.pop
       end
 
-      def applied_to?(klass) #:nodoc:
+      def applied_to?(klass) # :nodoc:
         klasses.any? { |k| k >= klass }
       end
 
       private
         def klasses
-          Thread.current[:no_touching_classes] ||= []
+          ActiveSupport::IsolatedExecutionState[:active_record_no_touching_classes] ||= []
         end
     end
 

data/lib/active_record/normalization.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module ActiveRecord # :nodoc:
+  module Normalization
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :normalized_attributes, default: Set.new
+
+      before_validation :normalize_changed_in_place_attributes
+    end
+
+    # Normalizes a specified attribute using its declared normalizations.
+    #
+    # ==== Examples
+    #
+    #   class User < ActiveRecord::Base
+    #     normalizes :email, with: -> email { email.strip.downcase }
+    #   end
+    #
+    #   legacy_user = User.find(1)
+    #   legacy_user.email # => " CRUISE-CONTROL@EXAMPLE.COM\n"
+    #   legacy_user.normalize_attribute(:email)
+    #   legacy_user.email # => "cruise-control@example.com"
+    #   legacy_user.save
+    def normalize_attribute(name)
+      # Treat the value as a new, unnormalized value.
+      self[name] = self[name]
+    end
+
+    module ClassMethods
+      # Declares a normalization for one or more attributes. The normalization
+      # is applied when the attribute is assigned or updated, and the normalized
+      # value will be persisted to the database. The normalization is also
+      # applied to the corresponding keyword argument of query methods. This
+      # allows a record to be created and later queried using unnormalized
+      # values.
+      #
+      # However, to prevent confusion, the normalization will not be applied
+      # when the attribute is fetched from the database. This means that if a
+      # record was persisted before the normalization was declared, the record's
+      # attribute will not be normalized until either it is assigned a new
+      # value, or it is explicitly migrated via Normalization#normalize_attribute.
+      #
+      # Because the normalization may be applied multiple times, it should be
+      # _idempotent_. In other words, applying the normalization more than once
+      # should have the same result as applying it only once.
+      #
+      # By default, the normalization will not be applied to +nil+ values. This
+      # behavior can be changed with the +:apply_to_nil+ option.
+      #
+      # Be aware that if your app was created before Rails 7.1, and your app
+      # marshals instances of the targeted model (for example, when caching),
+      # then you should set ActiveRecord.marshalling_format_version to +7.1+ or
+      # higher via either <tt>config.load_defaults 7.1</tt> or
+      # <tt>config.active_record.marshalling_format_version = 7.1</tt>.
+      # Otherwise, +Marshal+ may attempt to serialize the normalization +Proc+
+      # and raise +TypeError+.
+      #
+      # ==== Options
+      #
+      # * +:with+ - Any callable object that accepts the attribute's value as
+      #   its sole argument, and returns it normalized.
+      # * +:apply_to_nil+ - Whether to apply the normalization to +nil+ values.
+      #   Defaults to +false+.
+      #
+      # ==== Examples
+      #
+      #   class User < ActiveRecord::Base
+      #     normalizes :email, with: -> email { email.strip.downcase }
+      #     normalizes :phone, with: -> phone { phone.delete("^0-9").delete_prefix("1") }
+      #   end
+      #
+      #   user = User.create(email: " CRUISE-CONTROL@EXAMPLE.COM\n")
+      #   user.email                  # => "cruise-control@example.com"
+      #
+      #   user = User.find_by(email: "\tCRUISE-CONTROL@EXAMPLE.COM ")
+      #   user.email                  # => "cruise-control@example.com"
+      #   user.email_before_type_cast # => "cruise-control@example.com"
+      #
+      #   User.where(email: "\tCRUISE-CONTROL@EXAMPLE.COM ").count         # => 1
+      #   User.where(["email = ?", "\tCRUISE-CONTROL@EXAMPLE.COM "]).count # => 0
+      #
+      #   User.exists?(email: "\tCRUISE-CONTROL@EXAMPLE.COM ")         # => true
+      #   User.exists?(["email = ?", "\tCRUISE-CONTROL@EXAMPLE.COM "]) # => false
+      #
+      #   User.normalize_value_for(:phone, "+1 (555) 867-5309") # => "5558675309"
+      def normalizes(*names, with:, apply_to_nil: false)
+        names.each do |name|
+          attribute(name) do |cast_type|
+            NormalizedValueType.new(cast_type: cast_type, normalizer: with, normalize_nil: apply_to_nil)
+          end
+        end
+
+        self.normalized_attributes += names.map(&:to_sym)
+      end
+
+      # Normalizes a given +value+ using normalizations declared for +name+.
+      #
+      # ==== Examples
+      #
+      #   class User < ActiveRecord::Base
+      #     normalizes :email, with: -> email { email.strip.downcase }
+      #   end
+      #
+      #   User.normalize_value_for(:email, " CRUISE-CONTROL@EXAMPLE.COM\n")
+      #   # => "cruise-control@example.com"
+      def normalize_value_for(name, value)
+        type_for_attribute(name).cast(value)
+      end
+    end
+
+    private
+      def normalize_changed_in_place_attributes
+        self.class.normalized_attributes.each do |name|
+          normalize_attribute(name) if attribute_changed_in_place?(name)
+        end
+      end
+
+      class NormalizedValueType < DelegateClass(ActiveModel::Type::Value) # :nodoc:
+        include ActiveModel::Type::SerializeCastValue
+
+        attr_reader :cast_type, :normalizer, :normalize_nil
+        alias :normalize_nil? :normalize_nil
+
+        def initialize(cast_type:, normalizer:, normalize_nil:)
+          @cast_type = cast_type
+          @normalizer = normalizer
+          @normalize_nil = normalize_nil
+          super(cast_type)
+        end
+
+        def cast(value)
+          normalize(super(value))
+        end
+
+        def serialize(value)
+          serialize_cast_value(cast(value))
+        end
+
+        def serialize_cast_value(value)
+          ActiveModel::Type::SerializeCastValue.serialize(cast_type, value)
+        end
+
+        def ==(other)
+          self.class == other.class &&
+            normalize_nil? == other.normalize_nil? &&
+            normalizer == other.normalizer &&
+            cast_type == other.cast_type
+        end
+        alias eql? ==
+
+        def hash
+          [self.class, cast_type, normalizer, normalize_nil?].hash
+        end
+
+        def inspect
+          Kernel.instance_method(:inspect).bind_call(self)
+        end
+
+        private
+          def normalize(value)
+            normalizer.call(value) unless value.nil? && !normalize_nil?
+          end
+      end
+  end
+end