katalyst-govuk-formbuilder 1.9.0 → 1.9.2

data/vendor/bundle/ruby/3.3.0/gems/activemodel-7.1.3.4/CHANGELOG.md

@@ -0,0 +1,264 @@
+## Rails 7.1.3.4 (June 04, 2024) ##
+
+*   No changes.
+
+
+## Rails 7.1.3.3 (May 16, 2024) ##
+
+*   No changes.
+
+
+## Rails 7.1.3.2 (February 21, 2024) ##
+
+*   No changes.
+
+
+## Rails 7.1.3.1 (February 21, 2024) ##
+
+*   No changes.
+
+
+## Rails 7.1.3 (January 16, 2024) ##
+
+*   No changes.
+
+
+## Rails 7.1.2 (November 10, 2023) ##
+
+*   Make `==(other)` method of AttributeSet safe.
+
+    *Dmitry Pogrebnoy*
+
+
+## Rails 7.1.1 (October 11, 2023) ##
+
+*   No changes.
+
+
+## Rails 7.1.0 (October 05, 2023) ##
+
+*   No changes.
+
+
+## Rails 7.1.0.rc2 (October 01, 2023) ##
+
+*   No changes.
+
+
+## Rails 7.1.0.rc1 (September 27, 2023) ##
+
+*   Remove change in the typography of user facing error messages.
+    For example, “can’t be blank” is again “can't be blank”.
+
+    *Rafael Mendonça França*
+
+
+## Rails 7.1.0.beta1 (September 13, 2023) ##
+
+*   Support composite identifiers in `to_key`
+
+    `to_key` avoids wrapping `#id` value into an `Array` if `#id` already an array
+
+    *Nikita Vasilevsky*
+
+*   Add `ActiveModel::Conversion.param_delimiter` to configure delimiter being used in `to_param`
+
+    *Nikita Vasilevsky*
+
+*   `undefine_attribute_methods` undefines alias attribute methods along with attribute methods.
+
+    *Nikita Vasilevsky*
+
+*   Error.full_message now strips ":base" from the message.
+
+    *zzak*
+
+*   Add a load hook for `ActiveModel::Model` (named `active_model`) to match the load hook for
+    `ActiveRecord::Base` and allow for overriding aspects of the `ActiveModel::Model` class.
+
+    *Lewis Buckley*
+
+*   Improve password length validation in ActiveModel::SecurePassword to consider byte size for BCrypt
+    compatibility.
+
+    The previous password length validation only considered the character count, which may not
+    accurately reflect the 72-byte size limit imposed by BCrypt. This change updates the validation
+    to consider both character count and byte size while keeping the character length validation in place.
+
+    ```ruby
+    user = User.new(password: "a" * 73)  # 73 characters
+    user.valid? # => false
+    user.errors[:password] # => ["is too long"]
+
+
+    user = User.new(password: "あ" * 25)  # 25 characters, 75 bytes
+    user.valid? # => false
+    user.errors[:password] # => ["is too long"]
+    ```
+
+    *ChatGPT*, *Guillermo Iguaran*
+
+*   `has_secure_password` now generates an `#{attribute}_salt` method that returns the salt
+    used to compute the password digest. The salt will change whenever the password is changed,
+    so it can be used to create single-use password reset tokens with `generates_token_for`:
+
+    ```ruby
+    class User < ActiveRecord::Base
+      has_secure_password
+
+      generates_token_for :password_reset, expires_in: 15.minutes do
+        password_salt&.last(10)
+      end
+    end
+    ```
+
+    *Lázaro Nixon*
+
+*   Improve typography of user facing error messages. In English contractions,
+    the Unicode APOSTROPHE (`U+0027`) is now RIGHT SINGLE QUOTATION MARK
+    (`U+2019`). For example, "can't be blank" is now "can’t be blank".
+
+    *Jon Dufresne*
+
+*   Add class to `ActiveModel::MissingAttributeError` error message.
+
+    Show which class is missing the attribute in the error message:
+
+    ```ruby
+    user = User.first
+    user.pets.select(:id).first.user_id
+    # => ActiveModel::MissingAttributeError: missing attribute 'user_id' for Pet
+    ```
+
+    *Petrik de Heus*
+
+*   Raise `NoMethodError` in `ActiveModel::Type::Value#as_json` to avoid unpredictable
+    results.
+
+    *Vasiliy Ermolovich*
+
+*   Custom attribute types that inherit from Active Model built-in types and do
+    not override the `serialize` method will now benefit from an optimization
+    when serializing attribute values for the database.
+
+    For example, with a custom type like the following:
+
+    ```ruby
+    class DowncasedString < ActiveModel::Type::String
+      def cast(value)
+        super&.downcase
+      end
+    end
+
+    ActiveRecord::Type.register(:downcased_string, DowncasedString)
+
+    class User < ActiveRecord::Base
+      attribute :email, :downcased_string
+    end
+
+    user = User.new(email: "FooBar@example.com")
+    ```
+
+    Serializing the `email` attribute for the database will be roughly twice as
+    fast.  More expensive `cast` operations will likely see greater improvements.
+
+    *Jonathan Hefner*
+
+*   `has_secure_password` now supports password challenges via a
+    `password_challenge` accessor and validation.
+
+    A password challenge is a safeguard to verify that the current user is
+    actually the password owner.  It can be used when changing sensitive model
+    fields, such as the password itself.  It is different than a password
+    confirmation, which is used to prevent password typos.
+
+    When `password_challenge` is set, the validation checks that the value's
+    digest matches the *currently persisted* `password_digest` (i.e.
+    `password_digest_was`).
+
+    This allows a password challenge to be done as part of a typical `update`
+    call, just like a password confirmation.  It also allows a password
+    challenge error to be handled in the same way as other validation errors.
+
+    For example, in the controller, instead of:
+
+    ```ruby
+    password_params = params.require(:password).permit(
+      :password_challenge,
+      :password,
+      :password_confirmation,
+    )
+
+    password_challenge = password_params.delete(:password_challenge)
+    @password_challenge_failed = !current_user.authenticate(password_challenge)
+
+    if !@password_challenge_failed && current_user.update(password_params)
+      # ...
+    end
+    ```
+
+    You can now write:
+
+    ```ruby
+    password_params = params.require(:password).permit(
+      :password_challenge,
+      :password,
+      :password_confirmation,
+    ).with_defaults(password_challenge: "")
+
+    if current_user.update(password_params)
+      # ...
+    end
+    ```
+
+    And, in the view, instead of checking `@password_challenge_failed`, you can
+    render an error for the `password_challenge` field just as you would for
+    other form fields, including utilizing `config.action_view.field_error_proc`.
+
+    *Jonathan Hefner*
+
+*   Support infinite ranges for `LengthValidator`s `:in`/`:within` options
+
+    ```ruby
+    validates_length_of :first_name, in: ..30
+    ```
+
+    *fatkodima*
+
+*   Add support for beginless ranges to inclusivity/exclusivity validators:
+
+    ```ruby
+    validates_inclusion_of :birth_date, in: -> { (..Date.today) }
+    ```
+
+    ```ruby
+    validates_exclusion_of :birth_date, in: -> { (..Date.today) }
+    ```
+
+    *Bo Jeanes*
+
+*   Make validators accept lambdas without record argument
+
+    ```ruby
+    # Before
+    validates_comparison_of :birth_date, less_than_or_equal_to: ->(_record) { Date.today }
+
+    # After
+    validates_comparison_of :birth_date, less_than_or_equal_to: -> { Date.today }
+    ```
+
+    *fatkodima*
+
+*   Fix casting long strings to `Date`, `Time` or `DateTime`
+
+    *fatkodima*
+
+*   Use different cache namespace for proxy calls
+
+    Models can currently have different attribute bodies for the same method
+    names, leading to conflicts. Adding a new namespace `:active_model_proxy`
+    fixes the issue.
+
+    *Chris Salzberg*
+
+Please check [7-0-stable](https://github.com/rails/rails/blob/7-0-stable/activemodel/CHANGELOG.md) for previous changes.

data/vendor/bundle/ruby/3.3.0/gems/activemodel-7.1.3.4/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/vendor/bundle/ruby/3.3.0/gems/activemodel-7.1.3.4/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}[link: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}[link: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}[link: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}[link: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}[link: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}[link:classes/ActiveModel/Serialization.html]
+
+* Internationalization (i18n) support
+
+    class Person
+      extend ActiveModel::Translation
+    end
+
+    Person.human_attribute_name('my_attribute')
+    # => "My attribute"
+
+  {Learn more}[link: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}[link: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}[link: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/vendor/bundle/ruby/3.3.0/gems/activemodel-7.1.3.4/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/vendor/bundle/ruby/3.3.0/gems/activemodel-7.1.3.4/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