omg-activemodel 8.0.0.alpha1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b9199b4832bbe8dfdddaef904f1830bc5c43aee700c358b48b7ecc205f27d988
+  data.tar.gz: 14f2bbdd71b68ccbaa9613688c58197de86cd6e281260a3f062171ee46084af0
+SHA512:
+  metadata.gz: 4aaa1d510d524f7133108ec430fdad64f50ee8cb05e113a260c2ff203ed477ea574c7523c6c31cb1955fd4ed704b8e7b3df42c02ca7a918ab9694288f5c8ae12
+  data.tar.gz: 6dba06dff924fcf9bbccf45bf0eb3efd968daee301d619c0ad509cbfc6d3b602180735823d0cc731451c80451f792effd4140cb12a95ef6ae2b4e862a58365c8

data/CHANGELOG.md

@@ -0,0 +1,67 @@
+*   Add a default token generator for password reset tokens when using `has_secure_password`.
+
+    ```ruby
+    class User < ApplicationRecord
+      has_secure_password
+    end
+
+    user = User.create!(name: "david", password: "123", password_confirmation: "123")
+    token = user.password_reset_token
+    User.find_by_password_reset_token(token) # returns user
+
+    # 16 minutes later...
+    User.find_by_password_reset_token(token) # returns nil
+
+    # raises ActiveSupport::MessageVerifier::InvalidSignature since the token is expired
+    User.find_by_password_reset_token!(token)
+    ```
+
+    *DHH*
+
+*   Add a load hook `active_model_translation` for `ActiveModel::Translation`.
+
+    *Shouichi Kamiya*
+
+*   Add `raise_on_missing_translations` option to `ActiveModel::Translation`.
+    When the option is set, `human_attribute_name` raises an error if a translation of the given attribute is missing.
+
+    ```ruby
+    # ActiveModel::Translation.raise_on_missing_translations = false
+    Post.human_attribute_name("title")
+    => "Title"
+
+    # ActiveModel::Translation.raise_on_missing_translations = true
+    Post.human_attribute_name("title")
+    => Translation missing. Options considered were: (I18n::MissingTranslationData)
+        - en.activerecord.attributes.post.title
+        - en.attributes.title
+
+                raise exception.respond_to?(:to_exception) ? exception.to_exception : exception
+                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    ```
+
+    *Shouichi Kamiya*
+
+*   Introduce `ActiveModel::AttributeAssignment#attribute_writer_missing`
+
+    Provide instances with an opportunity to gracefully handle assigning to an
+    unknown attribute:
+
+    ```ruby
+    class Rectangle
+      include ActiveModel::AttributeAssignment
+
+      attr_accessor :length, :width
+
+      def attribute_writer_missing(name, value)
+        Rails.logger.warn "Tried to assign to unknown attribute #{name}"
+      end
+    end
+
+    rectangle = Rectangle.new
+    rectangle.assign_attributes(height: 10) # => Logs "Tried to assign to unknown attribute 'height'"
+    ```
+
+    *Sean Doyle*
+
+Please check [7-2-stable](https://github.com/rails/rails/blob/7-2-stable/activemodel/CHANGELOG.md) for previous changes.

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) David Heinemeier Hansson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README.rdoc

@@ -0,0 +1,266 @@
+= Active Model -- model interfaces for \Rails
+
+Active Model provides a known set of interfaces for usage in model classes.
+They allow for Action Pack helpers to interact with non-Active Record models,
+for example. Active Model also helps with building custom ORMs for use outside of
+the \Rails framework.
+
+You can read more about Active Model in the {Active Model Basics}[https://guides.rubyonrails.org/active_model_basics.html] guide.
+
+Prior to \Rails 3.0, if a plugin or gem developer wanted to have an object
+interact with Action Pack helpers, it was required to either copy chunks of
+code from \Rails, or monkey patch entire helpers to make them handle objects
+that did not exactly conform to the Active Record interface. This would result
+in code duplication and fragile applications that broke on upgrades. Active
+Model solves this by defining an explicit API. You can read more about the
+API in +ActiveModel::Lint::Tests+.
+
+Active Model provides a default module that implements the basic API required
+to integrate with Action Pack out of the box: ActiveModel::API.
+
+    class Person
+      include ActiveModel::API
+
+      attr_accessor :name, :age
+      validates_presence_of :name
+    end
+
+    person = Person.new(name: 'bob', age: '18')
+    person.name   # => 'bob'
+    person.age    # => '18'
+    person.valid? # => true
+
+It includes model name introspections, conversions, translations and
+validations, resulting in a class suitable to be used with Action Pack.
+See ActiveModel::API for more examples.
+
+Active Model also provides the following functionality to have ORM-like
+behavior out of the box:
+
+* Add attribute magic to objects
+
+    class Person
+      include ActiveModel::AttributeMethods
+
+      attribute_method_prefix 'clear_'
+      define_attribute_methods :name, :age
+
+      attr_accessor :name, :age
+
+      def clear_attribute(attr)
+        send("#{attr}=", nil)
+      end
+    end
+
+    person = Person.new
+    person.clear_name
+    person.clear_age
+
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveModel/AttributeMethods.html]
+
+* Callbacks for certain operations
+
+    class Person
+      extend ActiveModel::Callbacks
+      define_model_callbacks :create
+
+      def create
+        run_callbacks :create do
+          # Your create action methods here
+        end
+      end
+    end
+
+  This generates +before_create+, +around_create+ and +after_create+
+  class methods that wrap your create method.
+
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveModel/Callbacks.html]
+
+* Tracking value changes
+
+    class Person
+      include ActiveModel::Dirty
+
+      define_attribute_methods :name
+
+      def name
+        @name
+      end
+
+      def name=(val)
+        name_will_change! unless val == @name
+        @name = val
+      end
+
+      def save
+        # do persistence work
+        changes_applied
+      end
+    end
+
+    person = Person.new
+    person.name             # => nil
+    person.changed?         # => false
+    person.name = 'bob'
+    person.changed?         # => true
+    person.changed          # => ['name']
+    person.changes          # => { 'name' => [nil, 'bob'] }
+    person.save
+    person.name = 'robert'
+    person.save
+    person.previous_changes # => {'name' => ['bob, 'robert']}
+
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveModel/Dirty.html]
+
+* Adding +errors+ interface to objects
+
+  Exposing error messages allows objects to interact with Action Pack
+  helpers seamlessly.
+
+    class Person
+
+      def initialize
+        @errors = ActiveModel::Errors.new(self)
+      end
+
+      attr_accessor :name
+      attr_reader   :errors
+
+      def validate!
+        errors.add(:name, "cannot be nil") if name.nil?
+      end
+
+      def self.human_attribute_name(attr, options = {})
+        "Name"
+      end
+    end
+
+    person = Person.new
+    person.name = nil
+    person.validate!
+    person.errors.full_messages
+    # => ["Name cannot be nil"]
+
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveModel/Errors.html]
+
+* Model name introspection
+
+    class NamedPerson
+      extend ActiveModel::Naming
+    end
+
+    NamedPerson.model_name.name   # => "NamedPerson"
+    NamedPerson.model_name.human  # => "Named person"
+
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveModel/Naming.html]
+
+* Making objects serializable
+
+  ActiveModel::Serialization provides a standard interface for your object
+  to provide +to_json+ serialization.
+
+    class SerialPerson
+      include ActiveModel::Serialization
+
+      attr_accessor :name
+
+      def attributes
+        {'name' => name}
+      end
+    end
+
+    s = SerialPerson.new
+    s.serializable_hash   # => {"name"=>nil}
+
+    class SerialPerson
+      include ActiveModel::Serializers::JSON
+    end
+
+    s = SerialPerson.new
+    s.to_json             # => "{\"name\":null}"
+
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveModel/Serialization.html]
+
+* Internationalization (i18n) support
+
+    class Person
+      extend ActiveModel::Translation
+    end
+
+    Person.human_attribute_name('my_attribute')
+    # => "My attribute"
+
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveModel/Translation.html]
+
+* Validation support
+
+    class Person
+      include ActiveModel::Validations
+
+      attr_accessor :first_name, :last_name
+
+      validates_each :first_name, :last_name do |record, attr, value|
+        record.errors.add attr, "starts with z." if value.start_with?("z")
+      end
+    end
+
+    person = Person.new
+    person.first_name = 'zoolander'
+    person.valid?  # => false
+
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveModel/Validations.html]
+
+* Custom validators
+
+    class HasNameValidator < ActiveModel::Validator
+      def validate(record)
+        record.errors.add(:name, "must exist") if record.name.blank?
+      end
+    end
+
+    class ValidatorPerson
+      include ActiveModel::Validations
+      validates_with HasNameValidator
+      attr_accessor :name
+    end
+
+    p = ValidatorPerson.new
+    p.valid?                  # =>  false
+    p.errors.full_messages    # => ["Name must exist"]
+    p.name = "Bob"
+    p.valid?                  # =>  true
+
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveModel/Validator.html]
+
+
+== Download and installation
+
+The latest version of Active Model can be installed with RubyGems:
+
+  $ gem install activemodel
+
+Source code can be downloaded as part of the \Rails project on GitHub
+
+* https://github.com/rails/rails/tree/main/activemodel
+
+
+== License
+
+Active Model is released under the MIT license:
+
+* https://opensource.org/licenses/MIT
+
+
+== Support
+
+API documentation is at:
+
+* https://api.rubyonrails.org
+
+Bug reports for the Ruby on \Rails project can be filed here:
+
+* https://github.com/rails/rails/issues
+
+Feature requests should be discussed on the rails-core mailing list here:
+
+* https://discuss.rubyonrails.org/c/rubyonrails-core

data/lib/active_model/access.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/enumerable"
+require "active_support/core_ext/hash/indifferent_access"
+
+module ActiveModel
+  module Access # :nodoc:
+    def slice(*methods)
+      methods.flatten.index_with { |method| public_send(method) }.with_indifferent_access
+    end
+
+    def values_at(*methods)
+      methods.flatten.map! { |method| public_send(method) }
+    end
+  end
+end

data/lib/active_model/api.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  # = Active \Model \API
+  #
+  # Includes the required interface for an object to interact with
+  # Action Pack and Action View, using different Active \Model modules.
+  # It includes model name introspections, conversions, translations, and
+  # validations. Besides that, it allows you to initialize the object with a
+  # hash of attributes, pretty much like Active Record does.
+  #
+  # A minimal implementation could be:
+  #
+  #   class Person
+  #     include ActiveModel::API
+  #     attr_accessor :name, :age
+  #   end
+  #
+  #   person = Person.new(name: 'bob', age: '18')
+  #   person.name # => "bob"
+  #   person.age  # => "18"
+  #
+  # Note that, by default, +ActiveModel::API+ implements #persisted?
+  # to return +false+, which is the most common case. You may want to override
+  # it in your class to simulate a different scenario:
+  #
+  #   class Person
+  #     include ActiveModel::API
+  #     attr_accessor :id, :name
+  #
+  #     def persisted?
+  #       self.id.present?
+  #     end
+  #   end
+  #
+  #   person = Person.new(id: 1, name: 'bob')
+  #   person.persisted? # => true
+  #
+  # Also, if for some reason you need to run code on initialize ( ::new ), make
+  # sure you call +super+ if you want the attributes hash initialization to
+  # happen.
+  #
+  #   class Person
+  #     include ActiveModel::API
+  #     attr_accessor :id, :name, :omg
+  #
+  #     def initialize(attributes={})
+  #       super
+  #       @omg ||= true
+  #     end
+  #   end
+  #
+  #   person = Person.new(id: 1, name: 'bob')
+  #   person.omg # => true
+  #
+  # For more detailed information on other functionalities available, please
+  # refer to the specific modules included in +ActiveModel::API+
+  # (see below).
+  module API
+    extend ActiveSupport::Concern
+    include ActiveModel::AttributeAssignment
+    include ActiveModel::Validations
+    include ActiveModel::Conversion
+
+    included do
+      extend ActiveModel::Naming
+      extend ActiveModel::Translation
+    end
+
+    # Initializes a new model with the given +params+.
+    #
+    #   class Person
+    #     include ActiveModel::API
+    #     attr_accessor :name, :age
+    #   end
+    #
+    #   person = Person.new(name: 'bob', age: '18')
+    #   person.name # => "bob"
+    #   person.age  # => "18"
+    def initialize(attributes = {})
+      assign_attributes(attributes) if attributes
+
+      super()
+    end
+
+    # Indicates if the model is persisted. Default is +false+.
+    #
+    #  class Person
+    #    include ActiveModel::API
+    #    attr_accessor :id, :name
+    #  end
+    #
+    #  person = Person.new(id: 1, name: 'bob')
+    #  person.persisted? # => false
+    def persisted?
+      false
+    end
+  end
+end

data/lib/active_model/attribute/user_provided_default.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "active_model/attribute"
+
+module ActiveModel
+  class Attribute # :nodoc:
+    def with_user_default(value)
+      UserProvidedDefault.new(name, value, type, self.is_a?(FromDatabase) ? self : original_attribute)
+    end
+
+    class UserProvidedDefault < FromUser # :nodoc:
+      def initialize(name, value, type, database_default)
+        @user_provided_value = value
+        super(name, value, type, database_default)
+      end
+
+      def value_before_type_cast
+        if user_provided_value.is_a?(Proc)
+          @memoized_value_before_type_cast ||= user_provided_value.call
+        else
+          @user_provided_value
+        end
+      end
+
+      def with_type(type)
+        self.class.new(name, user_provided_value, type, original_attribute)
+      end
+
+      def marshal_dump
+        result = [
+          name,
+          value_before_type_cast,
+          type,
+          original_attribute,
+        ]
+        result << value if defined?(@value)
+        result
+      end
+
+      def marshal_load(values)
+        name, user_provided_value, type, original_attribute, value = values
+        @name = name
+        @user_provided_value = user_provided_value
+        @type = type
+        @original_attribute = original_attribute
+        if values.length == 5
+          @value = value
+        end
+      end
+
+      private
+        attr_reader :user_provided_value
+    end
+  end
+end