activemodel 5.2.3

data/lib/active_model/forbidden_attributes_protection.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  # Raised when forbidden attributes are used for mass assignment.
+  #
+  #   class Person < ActiveRecord::Base
+  #   end
+  #
+  #   params = ActionController::Parameters.new(name: 'Bob')
+  #   Person.new(params)
+  #   # => ActiveModel::ForbiddenAttributesError
+  #
+  #   params.permit!
+  #   Person.new(params)
+  #   # => #<Person id: nil, name: "Bob">
+  class ForbiddenAttributesError < StandardError
+  end
+
+  module ForbiddenAttributesProtection # :nodoc:
+    private
+      def sanitize_for_mass_assignment(attributes)
+        if attributes.respond_to?(:permitted?)
+          raise ActiveModel::ForbiddenAttributesError if !attributes.permitted?
+          attributes.to_h
+        else
+          attributes
+        end
+      end
+      alias :sanitize_forbidden_attributes :sanitize_for_mass_assignment
+  end
+end

data/lib/active_model/gem_version.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  # Returns the version of the currently loaded \Active \Model as a <tt>Gem::Version</tt>
+  def self.gem_version
+    Gem::Version.new VERSION::STRING
+  end
+
+  module VERSION
+    MAJOR = 5
+    MINOR = 2
+    TINY  = 3
+    PRE   = nil
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+  end
+end

data/lib/active_model/lint.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Lint
+    # == Active \Model \Lint \Tests
+    #
+    # You can test whether an object is compliant with the Active \Model API by
+    # including <tt>ActiveModel::Lint::Tests</tt> in your TestCase. It will
+    # include tests that tell you whether your object is fully compliant,
+    # or if not, which aspects of the API are not implemented.
+    #
+    # Note an object is not required to implement all APIs in order to work
+    # with Action Pack. This module only intends to provide guidance in case
+    # you want all features out of the box.
+    #
+    # These tests do not attempt to determine the semantic correctness of the
+    # returned values. For instance, you could implement <tt>valid?</tt> to
+    # always return +true+, and the tests would pass. It is up to you to ensure
+    # that the values are semantically meaningful.
+    #
+    # Objects you pass in are expected to return a compliant object from a call
+    # to <tt>to_model</tt>. It is perfectly fine for <tt>to_model</tt> to return
+    # +self+.
+    module Tests
+      # Passes if the object's model responds to <tt>to_key</tt> and if calling
+      # this method returns +nil+ when the object is not persisted.
+      # Fails otherwise.
+      #
+      # <tt>to_key</tt> returns an Enumerable of all (primary) key attributes
+      # of the model, and is used to a generate unique DOM id for the object.
+      def test_to_key
+        assert_respond_to model, :to_key
+        def model.persisted?() false end
+        assert model.to_key.nil?, "to_key should return nil when `persisted?` returns false"
+      end
+
+      # Passes if the object's model responds to <tt>to_param</tt> and if
+      # calling this method returns +nil+ when the object is not persisted.
+      # Fails otherwise.
+      #
+      # <tt>to_param</tt> is used to represent the object's key in URLs.
+      # Implementers can decide to either raise an exception or provide a
+      # default in case the record uses a composite primary key. There are no
+      # tests for this behavior in lint because it doesn't make sense to force
+      # any of the possible implementation strategies on the implementer.
+      def test_to_param
+        assert_respond_to model, :to_param
+        def model.to_key() [1] end
+        def model.persisted?() false end
+        assert model.to_param.nil?, "to_param should return nil when `persisted?` returns false"
+      end
+
+      # Passes if the object's model responds to <tt>to_partial_path</tt> and if
+      # calling this method returns a string. Fails otherwise.
+      #
+      # <tt>to_partial_path</tt> is used for looking up partials. For example,
+      # a BlogPost model might return "blog_posts/blog_post".
+      def test_to_partial_path
+        assert_respond_to model, :to_partial_path
+        assert_kind_of String, model.to_partial_path
+      end
+
+      # Passes if the object's model responds to <tt>persisted?</tt> and if
+      # calling this method returns either +true+ or +false+. Fails otherwise.
+      #
+      # <tt>persisted?</tt> is used when calculating the URL for an object.
+      # If the object is not persisted, a form for that object, for instance,
+      # will route to the create action. If it is persisted, a form for the
+      # object will route to the update action.
+      def test_persisted?
+        assert_respond_to model, :persisted?
+        assert_boolean model.persisted?, "persisted?"
+      end
+
+      # Passes if the object's model responds to <tt>model_name</tt> both as
+      # an instance method and as a class method, and if calling this method
+      # returns a string with some convenience methods: <tt>:human</tt>,
+      # <tt>:singular</tt> and <tt>:plural</tt>.
+      #
+      # Check ActiveModel::Naming for more information.
+      def test_model_naming
+        assert_respond_to model.class, :model_name
+        model_name = model.class.model_name
+        assert_respond_to model_name, :to_str
+        assert_respond_to model_name.human, :to_str
+        assert_respond_to model_name.singular, :to_str
+        assert_respond_to model_name.plural, :to_str
+
+        assert_respond_to model, :model_name
+        assert_equal model.model_name, model.class.model_name
+      end
+
+      # Passes if the object's model responds to <tt>errors</tt> and if calling
+      # <tt>[](attribute)</tt> on the result of this method returns an array.
+      # Fails otherwise.
+      #
+      # <tt>errors[attribute]</tt> is used to retrieve the errors of a model
+      # for a given attribute. If errors are present, the method should return
+      # an array of strings that are the errors for the attribute in question.
+      # If localization is used, the strings should be localized for the current
+      # locale. If no error is present, the method should return an empty array.
+      def test_errors_aref
+        assert_respond_to model, :errors
+        assert model.errors[:hello].is_a?(Array), "errors#[] should return an Array"
+      end
+
+      private
+        def model
+          assert_respond_to @model, :to_model
+          @model.to_model
+        end
+
+        def assert_boolean(result, name)
+          assert result == true || result == false, "#{name} should be a boolean"
+        end
+    end
+  end
+end

data/lib/active_model/locale/en.yml

@@ -0,0 +1,36 @@
+en:
+  errors:
+    # The default format to use in full error messages.
+    format: "%{attribute} %{message}"
+
+    # The values :model, :attribute and :value are always available for interpolation
+    # The value :count is available when applicable. Can be used for pluralization.
+    messages:
+      model_invalid: "Validation failed: %{errors}"
+      inclusion: "is not included in the list"
+      exclusion: "is reserved"
+      invalid: "is invalid"
+      confirmation: "doesn't match %{attribute}"
+      accepted: "must be accepted"
+      empty: "can't be empty"
+      blank: "can't be blank"
+      present: "must be blank"
+      too_long:
+        one: "is too long (maximum is 1 character)"
+        other: "is too long (maximum is %{count} characters)"
+      too_short:
+        one: "is too short (minimum is 1 character)"
+        other: "is too short (minimum is %{count} characters)"
+      wrong_length:
+        one: "is the wrong length (should be 1 character)"
+        other: "is the wrong length (should be %{count} characters)"
+      not_a_number: "is not a number"
+      not_an_integer: "must be an integer"
+      greater_than: "must be greater than %{count}"
+      greater_than_or_equal_to: "must be greater than or equal to %{count}"
+      equal_to: "must be equal to %{count}"
+      less_than: "must be less than %{count}"
+      less_than_or_equal_to: "must be less than or equal to %{count}"
+      other_than: "must be other than %{count}"
+      odd: "must be odd"
+      even: "must be even"

data/lib/active_model/model.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  # == Active \Model \Basic \Model
+  #
+  # 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::Model
+  #     attr_accessor :name, :age
+  #   end
+  #
+  #   person = Person.new(name: 'bob', age: '18')
+  #   person.name # => "bob"
+  #   person.age  # => "18"
+  #
+  # Note that, by default, <tt>ActiveModel::Model</tt> implements <tt>persisted?</tt>
+  # 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::Model
+  #     attr_accessor :id, :name
+  #
+  #     def persisted?
+  #       self.id == 1
+  #     end
+  #   end
+  #
+  #   person = Person.new(id: 1, name: 'bob')
+  #   person.persisted? # => true
+  #
+  # Also, if for some reason you need to run code on <tt>initialize</tt>, make
+  # sure you call +super+ if you want the attributes hash initialization to
+  # happen.
+  #
+  #   class Person
+  #     include ActiveModel::Model
+  #     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 <tt>ActiveModel::Model</tt>
+  # (see below).
+  module Model
+    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::Model
+    #     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::Model
+    #    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/naming.rb

@@ -0,0 +1,318 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/except"
+require "active_support/core_ext/module/introspection"
+require "active_support/core_ext/module/redefine_method"
+
+module ActiveModel
+  class Name
+    include Comparable
+
+    attr_reader :singular, :plural, :element, :collection,
+      :singular_route_key, :route_key, :param_key, :i18n_key,
+      :name
+
+    alias_method :cache_key, :collection
+
+    ##
+    # :method: ==
+    #
+    # :call-seq:
+    #   ==(other)
+    #
+    # Equivalent to <tt>String#==</tt>. Returns +true+ if the class name and
+    # +other+ are equal, otherwise +false+.
+    #
+    #   class BlogPost
+    #     extend ActiveModel::Naming
+    #   end
+    #
+    #   BlogPost.model_name == 'BlogPost'  # => true
+    #   BlogPost.model_name == 'Blog Post' # => false
+
+    ##
+    # :method: ===
+    #
+    # :call-seq:
+    #   ===(other)
+    #
+    # Equivalent to <tt>#==</tt>.
+    #
+    #   class BlogPost
+    #     extend ActiveModel::Naming
+    #   end
+    #
+    #   BlogPost.model_name === 'BlogPost'  # => true
+    #   BlogPost.model_name === 'Blog Post' # => false
+
+    ##
+    # :method: <=>
+    #
+    # :call-seq:
+    #   <=>(other)
+    #
+    # Equivalent to <tt>String#<=></tt>.
+    #
+    #   class BlogPost
+    #     extend ActiveModel::Naming
+    #   end
+    #
+    #   BlogPost.model_name <=> 'BlogPost'  # => 0
+    #   BlogPost.model_name <=> 'Blog'      # => 1
+    #   BlogPost.model_name <=> 'BlogPosts' # => -1
+
+    ##
+    # :method: =~
+    #
+    # :call-seq:
+    #   =~(regexp)
+    #
+    # Equivalent to <tt>String#=~</tt>. Match the class name against the given
+    # regexp. Returns the position where the match starts or +nil+ if there is
+    # no match.
+    #
+    #   class BlogPost
+    #     extend ActiveModel::Naming
+    #   end
+    #
+    #   BlogPost.model_name =~ /Post/ # => 4
+    #   BlogPost.model_name =~ /\d/   # => nil
+
+    ##
+    # :method: !~
+    #
+    # :call-seq:
+    #   !~(regexp)
+    #
+    # Equivalent to <tt>String#!~</tt>. Match the class name against the given
+    # regexp. Returns +true+ if there is no match, otherwise +false+.
+    #
+    #   class BlogPost
+    #     extend ActiveModel::Naming
+    #   end
+    #
+    #   BlogPost.model_name !~ /Post/ # => false
+    #   BlogPost.model_name !~ /\d/   # => true
+
+    ##
+    # :method: eql?
+    #
+    # :call-seq:
+    #   eql?(other)
+    #
+    # Equivalent to <tt>String#eql?</tt>. Returns +true+ if the class name and
+    # +other+ have the same length and content, otherwise +false+.
+    #
+    #   class BlogPost
+    #     extend ActiveModel::Naming
+    #   end
+    #
+    #   BlogPost.model_name.eql?('BlogPost')  # => true
+    #   BlogPost.model_name.eql?('Blog Post') # => false
+
+    ##
+    # :method: to_s
+    #
+    # :call-seq:
+    #   to_s()
+    #
+    # Returns the class name.
+    #
+    #   class BlogPost
+    #     extend ActiveModel::Naming
+    #   end
+    #
+    #   BlogPost.model_name.to_s # => "BlogPost"
+
+    ##
+    # :method: to_str
+    #
+    # :call-seq:
+    #   to_str()
+    #
+    # Equivalent to +to_s+.
+    delegate :==, :===, :<=>, :=~, :"!~", :eql?, :to_s,
+             :to_str, :as_json, to: :name
+
+    # Returns a new ActiveModel::Name instance. By default, the +namespace+
+    # and +name+ option will take the namespace and name of the given class
+    # respectively.
+    #
+    #   module Foo
+    #     class Bar
+    #     end
+    #   end
+    #
+    #   ActiveModel::Name.new(Foo::Bar).to_s
+    #   # => "Foo::Bar"
+    def initialize(klass, namespace = nil, name = nil)
+      @name = name || klass.name
+
+      raise ArgumentError, "Class name cannot be blank. You need to supply a name argument when anonymous class given" if @name.blank?
+
+      @unnamespaced = @name.sub(/^#{namespace.name}::/, "") if namespace
+      @klass        = klass
+      @singular     = _singularize(@name)
+      @plural       = ActiveSupport::Inflector.pluralize(@singular)
+      @element      = ActiveSupport::Inflector.underscore(ActiveSupport::Inflector.demodulize(@name))
+      @human        = ActiveSupport::Inflector.humanize(@element)
+      @collection   = ActiveSupport::Inflector.tableize(@name)
+      @param_key    = (namespace ? _singularize(@unnamespaced) : @singular)
+      @i18n_key     = @name.underscore.to_sym
+
+      @route_key          = (namespace ? ActiveSupport::Inflector.pluralize(@param_key) : @plural.dup)
+      @singular_route_key = ActiveSupport::Inflector.singularize(@route_key)
+      @route_key << "_index" if @plural == @singular
+    end
+
+    # Transform the model name into a more human format, using I18n. By default,
+    # it will underscore then humanize the class name.
+    #
+    #   class BlogPost
+    #     extend ActiveModel::Naming
+    #   end
+    #
+    #   BlogPost.model_name.human # => "Blog post"
+    #
+    # Specify +options+ with additional translating options.
+    def human(options = {})
+      return @human unless @klass.respond_to?(:lookup_ancestors) &&
+                           @klass.respond_to?(:i18n_scope)
+
+      defaults = @klass.lookup_ancestors.map do |klass|
+        klass.model_name.i18n_key
+      end
+
+      defaults << options[:default] if options[:default]
+      defaults << @human
+
+      options = { scope: [@klass.i18n_scope, :models], count: 1, default: defaults }.merge!(options.except(:default))
+      I18n.translate(defaults.shift, options)
+    end
+
+    private
+
+      def _singularize(string)
+        ActiveSupport::Inflector.underscore(string).tr("/".freeze, "_".freeze)
+      end
+  end
+
+  # == Active \Model \Naming
+  #
+  # Creates a +model_name+ method on your object.
+  #
+  # To implement, just extend ActiveModel::Naming in your object:
+  #
+  #   class BookCover
+  #     extend ActiveModel::Naming
+  #   end
+  #
+  #   BookCover.model_name.name   # => "BookCover"
+  #   BookCover.model_name.human  # => "Book cover"
+  #
+  #   BookCover.model_name.i18n_key              # => :book_cover
+  #   BookModule::BookCover.model_name.i18n_key  # => :"book_module/book_cover"
+  #
+  # Providing the functionality that ActiveModel::Naming provides in your object
+  # is required to pass the \Active \Model Lint test. So either extending the
+  # provided method below, or rolling your own is required.
+  module Naming
+    def self.extended(base) #:nodoc:
+      base.silence_redefinition_of_method :model_name
+      base.delegate :model_name, to: :class
+    end
+
+    # Returns an ActiveModel::Name object for module. It can be
+    # used to retrieve all kinds of naming-related information
+    # (See ActiveModel::Name for more information).
+    #
+    #   class Person
+    #     extend ActiveModel::Naming
+    #   end
+    #
+    #   Person.model_name.name     # => "Person"
+    #   Person.model_name.class    # => ActiveModel::Name
+    #   Person.model_name.singular # => "person"
+    #   Person.model_name.plural   # => "people"
+    def model_name
+      @_model_name ||= begin
+        namespace = parents.detect do |n|
+          n.respond_to?(:use_relative_model_naming?) && n.use_relative_model_naming?
+        end
+        ActiveModel::Name.new(self, namespace)
+      end
+    end
+
+    # Returns the plural class name of a record or class.
+    #
+    #   ActiveModel::Naming.plural(post)             # => "posts"
+    #   ActiveModel::Naming.plural(Highrise::Person) # => "highrise_people"
+    def self.plural(record_or_class)
+      model_name_from_record_or_class(record_or_class).plural
+    end
+
+    # Returns the singular class name of a record or class.
+    #
+    #   ActiveModel::Naming.singular(post)             # => "post"
+    #   ActiveModel::Naming.singular(Highrise::Person) # => "highrise_person"
+    def self.singular(record_or_class)
+      model_name_from_record_or_class(record_or_class).singular
+    end
+
+    # Identifies whether the class name of a record or class is uncountable.
+    #
+    #   ActiveModel::Naming.uncountable?(Sheep) # => true
+    #   ActiveModel::Naming.uncountable?(Post)  # => false
+    def self.uncountable?(record_or_class)
+      plural(record_or_class) == singular(record_or_class)
+    end
+
+    # Returns string to use while generating route names. It differs for
+    # namespaced models regarding whether it's inside isolated engine.
+    #
+    #   # For isolated engine:
+    #   ActiveModel::Naming.singular_route_key(Blog::Post) # => "post"
+    #
+    #   # For shared engine:
+    #   ActiveModel::Naming.singular_route_key(Blog::Post) # => "blog_post"
+    def self.singular_route_key(record_or_class)
+      model_name_from_record_or_class(record_or_class).singular_route_key
+    end
+
+    # Returns string to use while generating route names. It differs for
+    # namespaced models regarding whether it's inside isolated engine.
+    #
+    #   # For isolated engine:
+    #   ActiveModel::Naming.route_key(Blog::Post) # => "posts"
+    #
+    #   # For shared engine:
+    #   ActiveModel::Naming.route_key(Blog::Post) # => "blog_posts"
+    #
+    # The route key also considers if the noun is uncountable and, in
+    # such cases, automatically appends _index.
+    def self.route_key(record_or_class)
+      model_name_from_record_or_class(record_or_class).route_key
+    end
+
+    # Returns string to use for params names. It differs for
+    # namespaced models regarding whether it's inside isolated engine.
+    #
+    #   # For isolated engine:
+    #   ActiveModel::Naming.param_key(Blog::Post) # => "post"
+    #
+    #   # For shared engine:
+    #   ActiveModel::Naming.param_key(Blog::Post) # => "blog_post"
+    def self.param_key(record_or_class)
+      model_name_from_record_or_class(record_or_class).param_key
+    end
+
+    def self.model_name_from_record_or_class(record_or_class) #:nodoc:
+      if record_or_class.respond_to?(:to_model)
+        record_or_class.to_model.model_name
+      else
+        record_or_class.model_name
+      end
+    end
+    private_class_method :model_name_from_record_or_class
+  end
+end