activemodel 7.0.7 → 7.1.3.4

data/lib/active_model/attribute_methods.rb

@@ -11,17 +11,17 @@ module ActiveModel
   #
   #   user = User.first
   #   user.pets.select(:id).first.user_id
-  #   # => ActiveModel::MissingAttributeError: missing attribute: user_id
+  #   # => ActiveModel::MissingAttributeError: missing attribute 'user_id' for Pet
   class MissingAttributeError < NoMethodError
   end
 
-  # == Active \Model \Attribute \Methods
+  # = Active \Model \Attribute \Methods
   #
   # Provides a way to add prefixes and suffixes to your methods as
-  # well as handling the creation of <tt>ActiveRecord::Base</tt>-like
+  # well as handling the creation of ActiveRecord::Base - like
   # class methods such as +table_name+.
   #
-  # The requirements to implement <tt>ActiveModel::AttributeMethods</tt> are to:
+  # The requirements to implement +ActiveModel::AttributeMethods+ are to:
   #
   # * <tt>include ActiveModel::AttributeMethods</tt> in your class.
   # * Call each of its methods you want to add, such as +attribute_method_suffix+
@@ -70,7 +70,7 @@ module ActiveModel
 
     included do
       class_attribute :attribute_aliases, instance_writer: false, default: {}
-      class_attribute :attribute_method_matchers, instance_writer: false, default: [ ClassMethods::AttributeMethodMatcher.new ]
+      class_attribute :attribute_method_patterns, instance_writer: false, default: [ ClassMethods::AttributeMethodPattern.new ]
     end
 
     module ClassMethods
@@ -105,7 +105,7 @@ module ActiveModel
       #   person.clear_name
       #   person.name          # => nil
       def attribute_method_prefix(*prefixes, parameters: nil)
-        self.attribute_method_matchers += prefixes.map! { |prefix| AttributeMethodMatcher.new(prefix: prefix, parameters: parameters) }
+        self.attribute_method_patterns += prefixes.map! { |prefix| AttributeMethodPattern.new(prefix: prefix, parameters: parameters) }
         undefine_attribute_methods
       end
 
@@ -139,7 +139,7 @@ module ActiveModel
       #   person.name          # => "Bob"
       #   person.name_short?   # => true
       def attribute_method_suffix(*suffixes, parameters: nil)
-        self.attribute_method_matchers += suffixes.map! { |suffix| AttributeMethodMatcher.new(suffix: suffix, parameters: parameters) }
+        self.attribute_method_patterns += suffixes.map! { |suffix| AttributeMethodPattern.new(suffix: suffix, parameters: parameters) }
         undefine_attribute_methods
       end
 
@@ -174,7 +174,7 @@ module ActiveModel
       #   person.reset_name_to_default!
       #   person.name                         # => 'Default Name'
       def attribute_method_affix(*affixes)
-        self.attribute_method_matchers += affixes.map! { |affix| AttributeMethodMatcher.new(**affix) }
+        self.attribute_method_patterns += affixes.map! { |affix| AttributeMethodPattern.new(**affix) }
         undefine_attribute_methods
       end
 
@@ -202,35 +202,50 @@ module ActiveModel
       #   person.name_short?     # => true
       #   person.nickname_short? # => true
       def alias_attribute(new_name, old_name)
-        self.attribute_aliases = attribute_aliases.merge(new_name.to_s => old_name.to_s)
-        ActiveSupport::CodeGenerator.batch(self, __FILE__, __LINE__) do |code_generator|
-          attribute_method_matchers.each do |matcher|
-            method_name = matcher.method_name(new_name).to_s
-            target_name = matcher.method_name(old_name).to_s
-            parameters = matcher.parameters
-
-            mangled_name = target_name
-            unless NAME_COMPILABLE_REGEXP.match?(target_name)
-              mangled_name = "__temp__#{target_name.unpack1("h*")}"
-            end
+        old_name = old_name.to_s
+        new_name = new_name.to_s
+        self.attribute_aliases = attribute_aliases.merge(new_name => old_name)
+        aliases_by_attribute_name[old_name] << new_name
+        eagerly_generate_alias_attribute_methods(new_name, old_name)
+      end
 
-            code_generator.define_cached_method(method_name, as: mangled_name, namespace: :alias_attribute) do |batch|
-              body = if CALL_COMPILABLE_REGEXP.match?(target_name)
-                "self.#{target_name}(#{parameters || ''})"
-              else
-                call_args = [":'#{target_name}'"]
-                call_args << parameters if parameters
-                "send(#{call_args.join(", ")})"
-              end
+      def eagerly_generate_alias_attribute_methods(new_name, old_name) # :nodoc:
+        ActiveSupport::CodeGenerator.batch(generated_attribute_methods, __FILE__, __LINE__) do |code_generator|
+          generate_alias_attribute_methods(code_generator, new_name, old_name)
+        end
+      end
 
-              modifier = matcher.parameters == FORWARD_PARAMETERS ? "ruby2_keywords " : ""
+      def generate_alias_attribute_methods(code_generator, new_name, old_name)
+        attribute_method_patterns.each do |pattern|
+          alias_attribute_method_definition(code_generator, pattern, new_name, old_name)
+        end
+      end
 
-              batch <<
-                "#{modifier}def #{mangled_name}(#{parameters || ''})" <<
-                body <<
-                "end"
-            end
+      def alias_attribute_method_definition(code_generator, pattern, new_name, old_name) # :nodoc:
+        method_name = pattern.method_name(new_name).to_s
+        target_name = pattern.method_name(old_name).to_s
+        parameters = pattern.parameters
+        mangled_name = target_name
+
+        unless NAME_COMPILABLE_REGEXP.match?(target_name)
+          mangled_name = "__temp__#{target_name.unpack1("h*")}"
+        end
+
+        code_generator.define_cached_method(method_name, as: mangled_name, namespace: :alias_attribute) do |batch|
+          body = if CALL_COMPILABLE_REGEXP.match?(target_name)
+            "self.#{target_name}(#{parameters || ''})"
+          else
+            call_args = [":'#{target_name}'"]
+            call_args << parameters if parameters
+            "send(#{call_args.join(", ")})"
           end
+
+          modifier = parameters == FORWARD_PARAMETERS ? "ruby2_keywords " : ""
+
+          batch <<
+            "#{modifier}def #{mangled_name}(#{parameters || ''})" <<
+            body <<
+            "end"
         end
       end
 
@@ -245,7 +260,7 @@ module ActiveModel
       end
 
       # Declares the attributes that should be prefixed and suffixed by
-      # <tt>ActiveModel::AttributeMethods</tt>.
+      # +ActiveModel::AttributeMethods+.
       #
       # To use, pass attribute names (as strings or symbols). Be sure to declare
       # +define_attribute_methods+ after you define any prefix, suffix, or affix
@@ -269,12 +284,17 @@ module ActiveModel
       #   end
       def define_attribute_methods(*attr_names)
         ActiveSupport::CodeGenerator.batch(generated_attribute_methods, __FILE__, __LINE__) do |owner|
-          attr_names.flatten.each { |attr_name| define_attribute_method(attr_name, _owner: owner) }
+          attr_names.flatten.each do |attr_name|
+            define_attribute_method(attr_name, _owner: owner)
+            aliases_by_attribute_name[attr_name.to_s].each do |aliased_name|
+              generate_alias_attribute_methods owner, aliased_name, attr_name
+            end
+          end
         end
       end
 
       # Declares an attribute that should be prefixed and suffixed by
-      # <tt>ActiveModel::AttributeMethods</tt>.
+      # +ActiveModel::AttributeMethods+.
       #
       # To use, pass an attribute name (as string or symbol). Be sure to declare
       # +define_attribute_method+ after you define any prefix, suffix or affix
@@ -303,24 +323,24 @@ module ActiveModel
       #   person.name_short? # => true
       def define_attribute_method(attr_name, _owner: generated_attribute_methods)
         ActiveSupport::CodeGenerator.batch(_owner, __FILE__, __LINE__) do |owner|
-          attribute_method_matchers.each do |matcher|
-            method_name = matcher.method_name(attr_name)
+          attribute_method_patterns.each do |pattern|
+            method_name = pattern.method_name(attr_name)
 
             unless instance_method_already_implemented?(method_name)
-              generate_method = "define_method_#{matcher.target}"
+              generate_method = "define_method_#{pattern.proxy_target}"
 
               if respond_to?(generate_method, true)
                 send(generate_method, attr_name.to_s, owner: owner)
               else
-                define_proxy_call(owner, method_name, matcher.target, matcher.parameters, attr_name.to_s, namespace: :active_model_proxy)
+                define_proxy_call(owner, method_name, pattern.proxy_target, pattern.parameters, attr_name.to_s, namespace: :active_model_proxy)
               end
             end
           end
-          attribute_method_matchers_cache.clear
+          attribute_method_patterns_cache.clear
         end
       end
 
-      # Removes all the previously dynamically defined methods from the class.
+      # Removes all the previously dynamically defined methods from the class, including alias attribute methods.
       #
       #   class Person
       #     include ActiveModel::AttributeMethods
@@ -328,6 +348,7 @@ module ActiveModel
       #     attr_accessor :name
       #     attribute_method_suffix '_short?'
       #     define_attribute_method :name
+      #     alias_attribute :first_name, :name
       #
       #     private
       #       def attribute_short?(attr)
@@ -337,19 +358,36 @@ module ActiveModel
       #
       #   person = Person.new
       #   person.name = 'Bob'
+      #   person.first_name  # => "Bob"
       #   person.name_short? # => true
       #
       #   Person.undefine_attribute_methods
       #
       #   person.name_short? # => NoMethodError
+      #   person.first_name  # => NoMethodError
       def undefine_attribute_methods
         generated_attribute_methods.module_eval do
           undef_method(*instance_methods)
         end
-        attribute_method_matchers_cache.clear
+        attribute_method_patterns_cache.clear
+      end
+
+      def aliases_by_attribute_name # :nodoc:
+        @aliases_by_attribute_name ||= Hash.new { |h, k| h[k] = [] }
       end
 
       private
+        def inherited(base) # :nodoc:
+          super
+          base.class_eval do
+            @attribute_method_patterns_cache = nil
+          end
+        end
+
+        def resolve_attribute_name(name)
+          attribute_aliases.fetch(super, &:itself)
+        end
+
         def generated_attribute_methods
           @generated_attribute_methods ||= Module.new.tap { |mod| include mod }
         end
@@ -367,33 +405,34 @@ module ActiveModel
         # used to alleviate the GC, which ultimately also speeds up the app
         # significantly (in our case our test suite finishes 10% faster with
         # this cache).
-        def attribute_method_matchers_cache
-          @attribute_method_matchers_cache ||= Concurrent::Map.new(initial_capacity: 4)
+        def attribute_method_patterns_cache
+          @attribute_method_patterns_cache ||= Concurrent::Map.new(initial_capacity: 4)
         end
 
-        def attribute_method_matchers_matching(method_name)
-          attribute_method_matchers_cache.compute_if_absent(method_name) do
-            attribute_method_matchers.filter_map { |matcher| matcher.match(method_name) }
+        def attribute_method_patterns_matching(method_name)
+          attribute_method_patterns_cache.compute_if_absent(method_name) do
+            attribute_method_patterns.filter_map { |pattern| pattern.match(method_name) }
           end
         end
 
         # Define a method `name` in `mod` that dispatches to `send`
         # using the given `extra` args. This falls back on `send`
         # if the called name cannot be compiled.
-        def define_proxy_call(code_generator, name, target, parameters, *call_args, namespace:)
+        def define_proxy_call(code_generator, name, proxy_target, parameters, *call_args, namespace:)
           mangled_name = name
           unless NAME_COMPILABLE_REGEXP.match?(name)
             mangled_name = "__temp__#{name.unpack1("h*")}"
           end
 
-          code_generator.define_cached_method(name, as: mangled_name, namespace: :"#{namespace}_#{target}") do |batch|
-            call_args.map!(&:inspect)
-            call_args << parameters if parameters
+          call_args.map!(&:inspect)
+          call_args << parameters if parameters
+          namespace = :"#{namespace}_#{proxy_target}_#{call_args.join("_")}}"
 
-            body = if CALL_COMPILABLE_REGEXP.match?(target)
-              "self.#{target}(#{call_args.join(", ")})"
+          code_generator.define_cached_method(name, as: mangled_name, namespace: namespace) do |batch|
+            body = if CALL_COMPILABLE_REGEXP.match?(proxy_target)
+              "self.#{proxy_target}(#{call_args.join(", ")})"
             else
-              call_args.unshift(":'#{target}'")
+              call_args.unshift(":'#{proxy_target}'")
               "send(#{call_args.join(", ")})"
             end
 
@@ -406,23 +445,23 @@ module ActiveModel
           end
         end
 
-        class AttributeMethodMatcher # :nodoc:
-          attr_reader :prefix, :suffix, :target, :parameters
+        class AttributeMethodPattern # :nodoc:
+          attr_reader :prefix, :suffix, :proxy_target, :parameters
 
-          AttributeMethodMatch = Struct.new(:target, :attr_name)
+          AttributeMethod = Struct.new(:proxy_target, :attr_name)
 
           def initialize(prefix: "", suffix: "", parameters: nil)
             @prefix = prefix
             @suffix = suffix
             @parameters = parameters.nil? ? FORWARD_PARAMETERS : parameters
             @regex = /\A(?:#{Regexp.escape(@prefix)})(.*)(?:#{Regexp.escape(@suffix)})\z/
-            @target = "#{@prefix}attribute#{@suffix}"
+            @proxy_target = "#{@prefix}attribute#{@suffix}"
             @method_name = "#{prefix}%s#{suffix}"
           end
 
           def match(method_name)
             if @regex =~ method_name
-              AttributeMethodMatch.new(target, $1)
+              AttributeMethod.new(proxy_target, $1)
             end
           end
 
@@ -457,7 +496,7 @@ module ActiveModel
     # attribute method. If so, we tell +attribute_missing+ to dispatch the
     # attribute. This method can be overloaded to customize the behavior.
     def attribute_missing(match, *args, &block)
-      __send__(match.target, match.attr_name, *args, &block)
+      __send__(match.proxy_target, match.attr_name, *args, &block)
     end
     ruby2_keywords(:attribute_missing)
 
@@ -485,12 +524,12 @@ module ActiveModel
       # Returns a struct representing the matching attribute method.
       # The struct's attributes are prefix, base and suffix.
       def matched_attribute_method(method_name)
-        matches = self.class.send(:attribute_method_matchers_matching, method_name)
+        matches = self.class.send(:attribute_method_patterns_matching, method_name)
         matches.detect { |match| attribute_method?(match.attr_name) }
       end
 
       def missing_attribute(attr_name, stack)
-        raise ActiveModel::MissingAttributeError, "missing attribute: #{attr_name}", stack
+        raise ActiveModel::MissingAttributeError, "missing attribute '#{attr_name}' for #{self.class}", stack
       end
 
       def _read_attribute(attr)

data/lib/active_model/attribute_registration.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/class/subclasses"
+require "active_model/attribute_set"
+require "active_model/attribute/user_provided_default"
+
+module ActiveModel
+  module AttributeRegistration # :nodoc:
+    extend ActiveSupport::Concern
+
+    module ClassMethods # :nodoc:
+      def attribute(name, type = nil, default: (no_default = true), **options)
+        type = resolve_type_name(type, **options) if type.is_a?(Symbol)
+
+        pending = pending_attribute(name)
+        pending.type = type if type
+        pending.default = default unless no_default
+
+        reset_default_attributes
+      end
+
+      def _default_attributes # :nodoc:
+        @default_attributes ||= build_default_attributes
+      end
+
+      def attribute_types # :nodoc:
+        @attribute_types ||= _default_attributes.cast_types.tap do |hash|
+          hash.default = Type.default_value
+        end
+      end
+
+      private
+        class PendingAttribute # :nodoc:
+          attr_accessor :type, :default
+
+          def apply_to(attribute)
+            attribute = attribute.with_type(type || attribute.type)
+            attribute = attribute.with_user_default(default) if defined?(@default)
+            attribute
+          end
+        end
+
+        def pending_attribute(name)
+          @pending_attributes ||= {}
+          @pending_attributes[resolve_attribute_name(name)] ||= PendingAttribute.new
+        end
+
+        def apply_pending_attributes(attribute_set)
+          superclass.send(__method__, attribute_set) if superclass.respond_to?(__method__, true)
+
+          defined?(@pending_attributes) && @pending_attributes.each do |name, pending|
+            attribute_set[name] = pending.apply_to(attribute_set[name])
+          end
+
+          attribute_set
+        end
+
+        def build_default_attributes
+          apply_pending_attributes(AttributeSet.new({}))
+        end
+
+        def reset_default_attributes
+          @default_attributes = nil
+          @attribute_types = nil
+          subclasses.each { |subclass| subclass.send(__method__) }
+        end
+
+        def resolve_attribute_name(name)
+          name.to_s
+        end
+
+        def resolve_type_name(name, **options)
+          Type.lookup(name, **options)
+        end
+    end
+  end
+end

data/lib/active_model/attribute_set.rb

@@ -21,6 +21,10 @@ module ActiveModel
       @attributes[name] = value
     end
 
+    def cast_types
+      attributes.transform_values(&:type)
+    end
+
     def values_before_type_cast
       attributes.transform_values(&:value_before_type_cast)
     end
@@ -37,6 +41,7 @@ module ActiveModel
     def key?(name)
       attributes.key?(name) && self[name].initialized?
     end
+    alias :include? :key?
 
     def keys
       attributes.each_key.select { |name| self[name].initialized? }
@@ -94,8 +99,12 @@ module ActiveModel
       AttributeSet.new(new_attributes)
     end
 
+    def reverse_merge!(target_attributes)
+      attributes.reverse_merge!(target_attributes.attributes) && self
+    end
+
     def ==(other)
-      attributes == other.attributes
+      other.is_a?(AttributeSet) && attributes == other.send(:attributes)
     end
 
     protected

data/lib/active_model/attributes.rb

@@ -1,33 +1,67 @@
 # frozen_string_literal: true
 
-require "active_model/attribute_set"
-require "active_model/attribute/user_provided_default"
-
 module ActiveModel
-  module Attributes # :nodoc:
+  # = Active \Model \Attributes
+  #
+  # The Attributes module allows models to define attributes beyond simple Ruby
+  # readers and writers. Similar to Active Record attributes, which are
+  # typically inferred from the database schema, Active Model Attributes are
+  # aware of data types, can have default values, and can handle casting and
+  # serialization.
+  #
+  # To use Attributes, include the module in your model class and define your
+  # attributes using the +attribute+ macro. It accepts a name, a type, a default
+  # value, and any other options supported by the attribute type.
+  #
+  # ==== Examples
+  #
+  #   class Person
+  #     include ActiveModel::Attributes
+  #
+  #     attribute :name, :string
+  #     attribute :active, :boolean, default: true
+  #   end
+  #
+  #   person = Person.new
+  #   person.name = "Volmer"
+  #
+  #   person.name # => "Volmer"
+  #   person.active # => true
+  module Attributes
     extend ActiveSupport::Concern
+    include ActiveModel::AttributeRegistration
     include ActiveModel::AttributeMethods
 
     included do
       attribute_method_suffix "=", parameters: "value"
-      class_attribute :attribute_types, :_default_attributes, instance_accessor: false
-      self.attribute_types = Hash.new(Type.default_value)
-      self._default_attributes = AttributeSet.new({})
     end
 
     module ClassMethods
-      def attribute(name, cast_type = nil, default: NO_DEFAULT_PROVIDED, **options)
-        name = name.to_s
-
-        cast_type = Type.lookup(cast_type, **options) if Symbol === cast_type
-        cast_type ||= attribute_types[name]
-
-        self.attribute_types = attribute_types.merge(name => cast_type)
-        define_default_attribute(name, default, cast_type)
+      ##
+      # :call-seq: attribute(name, cast_type = nil, default: nil, **options)
+      #
+      # Defines a model attribute. In addition to the attribute name, a cast
+      # type and default value may be specified, as well as any options
+      # supported by the given cast type.
+      #
+      #   class Person
+      #     include ActiveModel::Attributes
+      #
+      #     attribute :name, :string
+      #     attribute :active, :boolean, default: true
+      #   end
+      #
+      #   person = Person.new
+      #   person.name = "Volmer"
+      #
+      #   person.name   # => "Volmer"
+      #   person.active # => true
+      def attribute(name, ...)
+        super
         define_attribute_method(name)
       end
 
-      # Returns an array of attribute names as strings
+      # Returns an array of attribute names as strings.
       #
       #   class Person
       #     include ActiveModel::Attributes
@@ -36,8 +70,7 @@ module ActiveModel
       #     attribute :age, :integer
       #   end
       #
-      #   Person.attribute_names
-      #   # => ["name", "age"]
+      #   Person.attribute_names # => ["name", "age"]
       def attribute_names
         attribute_types.keys
       end
@@ -55,27 +88,9 @@ module ActiveModel
             end
           end
         end
-
-        NO_DEFAULT_PROVIDED = Object.new # :nodoc:
-        private_constant :NO_DEFAULT_PROVIDED
-
-        def define_default_attribute(name, value, type)
-          self._default_attributes = _default_attributes.deep_dup
-          if value == NO_DEFAULT_PROVIDED
-            default_attribute = _default_attributes[name].with_type(type)
-          else
-            default_attribute = Attribute::UserProvidedDefault.new(
-              name,
-              value,
-              type,
-              _default_attributes.fetch(name.to_s) { nil },
-            )
-          end
-          _default_attributes[name] = default_attribute
-        end
     end
 
-    def initialize(*)
+    def initialize(*) # :nodoc:
       @attributes = self.class._default_attributes.deep_dup
       super
     end
@@ -85,7 +100,8 @@ module ActiveModel
       super
     end
 
-    # Returns a hash of all the attributes with their names as keys and the values of the attributes as values.
+    # Returns a hash of all the attributes with their names as keys and the
+    # values of the attributes as values.
     #
     #   class Person
     #     include ActiveModel::Attributes
@@ -94,14 +110,16 @@ module ActiveModel
     #     attribute :age, :integer
     #   end
     #
-    #   person = Person.new(name: 'Francesco', age: 22)
-    #   person.attributes
-    #   # => {"name"=>"Francesco", "age"=>22}
+    #   person = Person.new
+    #   person.name = "Francesco"
+    #   person.age = 22
+    #
+    #   person.attributes # => { "name" => "Francesco", "age" => 22}
     def attributes
       @attributes.to_hash
     end
 
-    # Returns an array of attribute names as strings
+    # Returns an array of attribute names as strings.
     #
     #   class Person
     #     include ActiveModel::Attributes
@@ -111,13 +129,12 @@ module ActiveModel
     #   end
     #
     #   person = Person.new
-    #   person.attribute_names
-    #   # => ["name", "age"]
+    #   person.attribute_names # => ["name", "age"]
     def attribute_names
       @attributes.keys
     end
 
-    def freeze
+    def freeze # :nodoc:
       @attributes = @attributes.clone.freeze unless frozen?
       super
     end

data/lib/active_model/callbacks.rb

@@ -4,14 +4,14 @@ require "active_support/core_ext/array/extract_options"
 require "active_support/core_ext/hash/keys"
 
 module ActiveModel
-  # == Active \Model \Callbacks
+  # = Active \Model \Callbacks
   #
   # Provides an interface for any class to have Active Record like callbacks.
   #
   # Like the Active Record methods, the callback chain is aborted as soon as
   # one of the methods throws +:abort+.
   #
-  # First, extend ActiveModel::Callbacks from the class you are creating:
+  # First, extend +ActiveModel::Callbacks+ from the class you are creating:
   #
   #   class MyModel
   #     extend ActiveModel::Callbacks
@@ -69,7 +69,7 @@ module ActiveModel
       end
     end
 
-    # define_model_callbacks accepts the same options +define_callbacks+ does,
+    # +define_model_callbacks+ accepts the same options +define_callbacks+ does,
     # in case you want to overwrite a default. Besides that, it also accepts an
     # <tt>:only</tt> option, where you can choose if you want all types (before,
     # around or after) or just some.
@@ -77,7 +77,7 @@ module ActiveModel
     #   define_model_callbacks :initialize, only: :after
     #
     # Note, the <tt>only: <type></tt> hash will apply to all callbacks defined
-    # on that method call. To get around this you can call the define_model_callbacks
+    # on that method call. To get around this you can call the +define_model_callbacks+
     # method as many times as you need.
     #
     #   define_model_callbacks :create,  only: :after
@@ -104,7 +104,7 @@ module ActiveModel
     #     end
     #   end
     #
-    # NOTE: +method_name+ passed to define_model_callbacks must not end with
+    # NOTE: +method_name+ passed to +define_model_callbacks+ must not end with
     # <tt>!</tt>, <tt>?</tt> or <tt>=</tt>.
     def define_model_callbacks(*callbacks)
       options = callbacks.extract_options!