i18n gemを触ってみる

 irb(main):002:0> I18n.load_path
=>
["/usr/local/bundle/gems/activesupport-6.1.7.8/lib/active_support/locale/en.yml",
 "/usr/local/bundle/gems/activesupport-6.1.7.8/lib/active_support/locale/en.rb",
 "/usr/local/bundle/gems/activemodel-6.1.7.8/lib/active_model/locale/en.yml",
 "/usr/local/bundle/gems/activerecord-6.1.7.8/lib/active_record/locale/en.yml",
 "/usr/local/bundle/gems/actionview-6.1.7.8/lib/action_view/locale/en.yml",
 "/usr/local/bundle/gems/faker-3.3.1/lib/locales/ar.yml",
 "/usr/local/bundle/gems/faker-3.3.1/lib/locales/bg.yml",
 "/usr/local/bundle/gems/faker-3.3.1/lib/locales/ca-CAT.yml",
 "/usr/local/bundle/gems/faker-3.3.1/lib/locales/ca.yml",
 "/usr/local/bundle/gems/faker-3.3.1/lib/locales/da-DK.yml",
 "/usr/local/bundle/gems/faker-3.3.1/lib/locales/de-AT.yml",
 "/usr/local/bundle/gems/faker-3.3.1/lib/locales/de-CH.yml",
 "/usr/local/bundle/gems/faker-3.3.1/lib/locales/de.yml",
 "/usr/local/bundle/gems/faker-3.3.1/lib/locales/ee.yml",
......
 "/usr/local/bundle/gems/faker-3.3.1/lib/locales/tr.yml",
 "/usr/local/bundle/gems/faker-3.3.1/lib/locales/uk.yml",
 "/usr/local/bundle/gems/faker-3.3.1/lib/locales/vi.yml",
 "/usr/local/bundle/gems/faker-3.3.1/lib/locales/zh-CN/bank.yml",
 "/usr/local/bundle/gems/faker-3.3.1/lib/locales/zh-CN.yml",
 "/usr/local/bundle/gems/faker-3.3.1/lib/locales/zh-TW.yml",
 "/var/app/config/locales/en.yml",
 "/usr/local/bundle/gems/web-console-4.2.1/lib/web_console/locales/en.yml"]
irb(main):003:0>

=> []
irb(main):005:0> I18n.locale
=> :en
irb(main):006:0>
irb(main):007:0> I18n.t("en.hello")
=> "Translation missing: en.en.hello"
irb(main):008:0> I18n.t("hello")
=> "Hello world"
irb(main):009:0> I18n.with_locale("ja")
/usr/local/bundle/gems/i18n-1.14.6/lib/i18n.rb:353:in `with_locale': no block given (yield) (LocalJumpError)
irb(main):010:0> I18n.locale = "ja"
=> "ja"
irb(main):011:0> I18n.t("hello")
=> "Translation missing: ja.hello"
irb(main):012:0> I18n.locale
=> :ja
irb(main):013:0>

<!-- app/views/products/show.html.erb -->
<%= t('product_price', price: @product.price) %>

# config/locales/en.yml
en:
  product_price: "$%{price}"

irb(main):009:0> I18n.t :record_invalid, scope: [:activerecord, :errors, :messages]
=> "Translation missing: ja.activerecord.errors.messages.record_invalid"
irb(main):010:0>

I18n.translate "activerecord.errors.messages.record_invalid"
I18n.t "activerecord.errors.messages.record_invalid"
I18n.t "errors.messages.record_invalid", scope: :activerecord
I18n.t :record_invalid, scope: "activerecord.errors.messages"
I18n.t :record_invalid, scope: [:activerecord, :errors, :messages]

es:
  books:
    index:
      title: "Título"

<%= t '.title' %>

 frozen_string_literal: true

module ActiveModel
  # == Active \Model \Translation
  #
  # Provides integration between your object and the Rails internationalization
  # (i18n) framework.
  #
  # A minimal implementation could be:
  #
  #   class TranslatedPerson
  #     extend ActiveModel::Translation
  #   end
  #
  #   TranslatedPerson.human_attribute_name('my_attribute')
  #   # => "My attribute"
  #
  # This also provides the required class methods for hooking into the
  # Rails internationalization API, including being able to define a
  # class based +i18n_scope+ and +lookup_ancestors+ to find translations in
  # parent classes.
  module Translation
    include ActiveModel::Naming

    # Returns the +i18n_scope+ for the class. Overwrite if you want custom lookup.
    def i18n_scope
      :activemodel
    end

    # When localizing a string, it goes through the lookup returned by this
    # method, which is used in ActiveModel::Name#human,
    # ActiveModel::Errors#full_messages and
    # ActiveModel::Translation#human_attribute_name.
    def lookup_ancestors
      ancestors.select { |x| x.respond_to?(:model_name) }
    end

    # Transforms attribute names into a more human format, such as "First name"
    # instead of "first_name".
    #
    #   Person.human_attribute_name("first_name") # => "First name"
    #
    # Specify +options+ with additional translating options.
    def human_attribute_name(attribute, options = {})
      options   = { count: 1 }.merge!(options)
      parts     = attribute.to_s.split(".")
      attribute = parts.pop
      namespace = parts.join("/") unless parts.empty?
      attributes_scope = "#{i18n_scope}.attributes"

      if namespace
        defaults = lookup_ancestors.map do |klass|
          :"#{attributes_scope}.#{klass.model_name.i18n_key}/#{namespace}.#{attribute}"
        end
        defaults << :"#{attributes_scope}.#{namespace}.#{attribute}"
      else
        defaults = lookup_ancestors.map do |klass|
          :"#{attributes_scope}.#{klass.model_name.i18n_key}.#{attribute}"
        end
      end

      debugger
      defaults << :"attributes.#{attribute}"
      defaults << options.delete(:default) if options[:default]
      defaults << attribute.humanize

      options[:default] = defaults
      I18n.translate(defaults.shift, **options)
    end
  end
end

(byebug) I18n.translate("attributes.last_name")
"Translation missing: en.attributes.last_name"
(byebug) options
{:count=>1, :default=>[:"activerecord.attributes.user.last_name", :"attributes.last_name", "Last name"]}
(byebug) options[:default]
[:"activerecord.attributes.user.last_name", :"attributes.last_name", "Last name"]
(byebug) options[:default].pop
"Last name"
(byebug) options[:default]
[:"activerecord.attributes.user.last_name", :"attributes.last_name"]
(byebug) options[:default].push("yakunashi")
[:"activerecord.attributes.user.last_name", :"attributes.last_name", "yakunashi"]
(byebug) I18n.translate("attributes.last_name")
"Translation missing: en.attributes.last_name"
(byebug) I18n.translate("attributes.last_name", defaults)
*** ArgumentError Exception: wrong number of arguments (given 2, expected 0..1)

nil
(byebug) I18n.translate("attributes.last_name", **options)
"yakunashi"

I18n.t :missing, default: "【訳文なし】"
# => '【訳文なし】'

I18n.t :missing, default: [:also_missing,  "【訳文なし】"]
# =>  '【訳文なし】'

    def lookup_ancestors
      ancestors.select { |x| x.respond_to?(:model_name) }
    end

irb(main):002:0> Dir[Rails.root.join("config", "locales", "**", "*.{rb,yml}")]
=> ["/var/app/config/locales/en.yml", "/var/app/config/locales/ja.yml", "/var/app/config/locales/models/user/ja.yml"]

irb(main):004:0> User.method(:human_attribute_name).source_location
=> ["/usr/local/bundle/gems/activemodel-6.1.7.8/lib/active_model/translation.rb", 44]

bash-5.1# bundle info activemodel
  * activemodel (6.1.7.8)
	Summary: A toolkit for building modeling frameworks (part of Rails).
	Homepage: https://rubyonrails.org
	Documentation: https://api.rubyonrails.org/v6.1.7.8/
	Source Code: https://github.com/rails/rails/tree/v6.1.7.8/activemodel
	Changelog: https://github.com/rails/rails/blob/v6.1.7.8/activemodel/CHANGELOG.md
	Bug Tracker: https://github.com/rails/rails/issues
	Mailing List: https://discuss.rubyonrails.org/c/rubyonrails-talk
	Path: /usr/local/bundle/gems/activemodel-6.1.7.8
	Reverse Dependencies:
		activerecord (6.1.7.8) depends on activemodel (= 6.1.7.8)
		rails (6.1.7.8) depends on activemodel (= 6.1.7.8)
		web-console (4.2.1) depends on activemodel (>= 6.0.0)
bash-5.1#

# == Schema Information
#
# Table name: users
#
#  id               :bigint           not null, primary key
#  crypted_password :string
#  email            :string           not null
#  first_name       :string           not null
#  last_name        :string           not null
#  salt             :string
#  created_at       :datetime         not null
#  updated_at       :datetime         not null
#
# Indexes
#
#  index_users_on_email  (email) UNIQUE
#
class User < ApplicationRecord
  # Userモデルにソーサリーを使用していることを知らせる
  authenticates_with_sorcery!

  has_many :products, dependent: :destroy

  validates :password, length: { minimum: 3 }, if: -> { new_record? || changes[:crypted_password] }
  # confirmation:このバリデーションは仮想の属性を作成します
  # https://railsguides.jp/active_record_validations.html#confirmation
  validates :password, confirmation: true, if: -> { new_record? || changes[:crypted_password] }
  validates :password_confirmation, presence: true, if: -> { new_record? || changes[:crypted_password] }

  validates :email, uniqueness: true
  validates :email, presence: true
end

irb(main):001:0> User.new(password: "hoge", password_confirmation: "hoge")
irb(main):002:0*
=> #<User:0x00007f2992f50790 id: nil, email: nil, first_name: nil, last_name: nil, created_at: nil, updated_at: nil, crypted_password: nil, salt: nil>
irb(main):003:0> user = User.new(password: "hoge", password_confirmation: "hoge")
irb(main):004:0*
=> #<User:0x00007f298f91d8d0 id: nil, email: nil, first_name: nil, last_name: nil, created_at: nil, updated_at: nil, crypted_password: nil, salt: nil>
irb(main):005:0> user.valid?
  User Exists? (1.1ms)  SELECT 1 AS one FROM "users" WHERE "users"."email" IS NULL LIMIT $1  [["LIMIT", 1]]
=> false
irb(main):006:0> user.errors.full_messages
=> ["Email can't be blank"]

irb(main):001:0> user = User.new(password: "hoge", password_confirmation: "hoge")
=> #<User:0x00007f4a3fcb7448 id: nil, email: nil, first_name: nil, last_name: nil, created_at: nil, updated_at: nil, crypted_password: nil, salt: nil>
irb(main):002:0> user.valid?
  User Exists? (0.9ms)  SELECT 1 AS one FROM "users" WHERE "users"."email" IS NULL LIMIT $1  [["LIMIT", 1]]
=> false
irb(main):003:0> user.errors.full_messages

[474, 483] in /usr/local/bundle/gems/activemodel-6.1.7.8/lib/active_model/errors.rb
   474:     #   person = Person.create(address: '123 First St.')
   475:     #   person.errors.full_messages
   476:     #   # => ["Name is too short (minimum is 5 characters)", "Name can't be blank", "Email can't be blank"]
   477:     def full_messages
   478:       debugger
=> 479:       @errors.map(&:full_message)
   480:     end
   481:     alias :to_a :full_messages
   482:
   483:     # Returns all the full error messages for a given attribute in an array.
(byebug) @errors
[#<ActiveModel::Error attribute=email, type=blank, options={}>]
(byebug) @errors[0]
#<ActiveModel::Error attribute=email, type=blank, options={}>
(byebug) @errors[0].full_message
"Email can't be blank"
(byebug) @errors[0].method(:full_message).source_location
["/usr/local/bundle/gems/activemodel-6.1.7.8/lib/active_model/error.rb", 158]
(byebug) exit
bash-5.1# vim v
bash-5.1# vim "/usr/local/bundle/gems/activemodel-6.1.7.8/lib/active_model/error.rb"
bash-5.1# exit
exit

irb(main):001:0> user = User.new(password: "hoge", password_confirmation: "hoge")
=> #<User:0x00007f62e45b50d8 id: nil, email: nil, first_name: nil, last_name: nil, created_at: nil, updated_at: nil, crypted_password: nil, salt: nil>
irb(main):002:0> user.valid?
  User Exists? (0.8ms)  SELECT 1 AS one FROM "users" WHERE "users"."email" IS NULL LIMIT $1  [["LIMIT", 1]]
=> false
irb(main):003:0> user.errors
=>
#<ActiveModel::Errors:0x00007f62e55b7f80
 @base=
  #<User:0x00007f62e45b50d8
   id: nil,
   email: nil,
   first_name: nil,
   last_name: nil,
   created_at: nil,
   updated_at: nil,
   crypted_password: "$2a$10$fX2JPPXeuAH..k2PGH7OXOoZA7vo.stINjxjnzK6N/msPsw60Kgga",
   salt: "B2TQEuXN4QZ2K6nh_zWY">,
 @errors=[#<ActiveModel::Error attribute=email, type=blank, options={}>]>
irb(main):004:0> user.errors.full_messages

[156, 165] in /usr/local/bundle/gems/activemodel-6.1.7.8/lib/active_model/error.rb
   156:     #   error = ActiveModel::Error.new(person, :name, :too_short, count: 5)
   157:     #   error.full_message
   158:     #   # => "Name is too short (minimum is 5 characters)"
   159:     def full_message
   160:       debugger
=> 161:       self.class.full_message(attribute, message, @base)
   162:     end
   163:
   164:     # See if error matches provided +attribute+, +type+ and +options+.
   165:     #
(byebug) self.class
ActiveModel::Error
(byebug) attribute
:email
(byebug) message
"can't be blank"
(byebug) @base
#<User id: nil, email: nil, first_name: nil, last_name: nil, created_at: nil, updated_at: nil, crypted_password: "$2a$10$fX2JPPXeuAH..k2PGH7OXOoZA7vo.stINjxjnzK6N/m...", salt: "B2TQEuXN4QZ2K6nh_zWY">
(byebug)

# frozen_string_literal: true

require "active_support/core_ext/class/attribute"

module ActiveModel
  # == Active \Model \Error
  #
  # Represents one single error
  class Error
    CALLBACKS_OPTIONS = [:if, :unless, :on, :allow_nil, :allow_blank, :strict]
    MESSAGE_OPTIONS = [:message]

    class_attribute :i18n_customize_full_message, default: false

    def self.full_message(attribute, message, base) # :nodoc:
      return message if attribute == :base

      base_class = base.class
      attribute = attribute.to_s

      if i18n_customize_full_message && base_class.respond_to?(:i18n_scope)
        attribute = attribute.remove(/\[\d+\]/)
        parts = attribute.split(".")
        attribute_name = parts.pop
        namespace = parts.join("/") unless parts.empty?
        attributes_scope = "#{base_class.i18n_scope}.errors.models"

        if namespace
          defaults = base_class.lookup_ancestors.map do |klass|
            [
              :"#{attributes_scope}.#{klass.model_name.i18n_key}/#{namespace}.attributes.#{attribute_name}.format",
              :"#{attributes_scope}.#{klass.model_name.i18n_key}/#{namespace}.format",
            ]
          end
        else
          defaults = base_class.lookup_ancestors.map do |klass|
            [
              :"#{attributes_scope}.#{klass.model_name.i18n_key}.attributes.#{attribute_name}.format",
              :"#{attributes_scope}.#{klass.model_name.i18n_key}.format",
            ]
          end
        end

        defaults.flatten!
     else
        defaults = []
      end

      defaults << :"errors.format"
      defaults << "%{attribute} %{message}"

      attr_name = attribute.tr(".", "_").humanize
      attr_name = base_class.human_attribute_name(attribute, {
        default: attr_name,
        base: base,
      })

      I18n.t(defaults.shift,
        default:  defaults,
        attribute: attr_name,
        message:   message)
    end

    def self.generate_message(attribute, type, base, options) # :nodoc:
      type = options.delete(:message) if options[:message].is_a?(Symbol)
      value = (attribute != :base ? base.read_attribute_for_validation(attribute) : nil)

      options = {
        model: base.model_name.human,
        attribute: base.class.human_attribute_name(attribute, { base: base }),
        value: value,
        object: base
      }.merge!(options)

      if base.class.respond_to?(:i18n_scope)
        i18n_scope = base.class.i18n_scope.to_s
        attribute = attribute.to_s.remove(/\[\d+\]/)

        defaults = base.class.lookup_ancestors.flat_map do |klass|
          [ :"#{i18n_scope}.errors.models.#{klass.model_name.i18n_key}.attributes.#{attribute}.#{type}",
            :"#{i18n_scope}.errors.models.#{klass.model_name.i18n_key}.#{type}" ]
        end
        defaults << :"#{i18n_scope}.errors.messages.#{type}"

        catch(:exception) do
          translation = I18n.translate(defaults.first, **options.merge(default: defaults.drop(1), throw: true))
          return translation unless translation.nil?
        end unless options[:message]
      else
        defaults = []
      end

      defaults << :"errors.attributes.#{attribute}.#{type}"
      defaults << :"errors.messages.#{type}"

      key = defaults.shift
      defaults = options.delete(:message) if options[:message]
      options[:default] = defaults

      I18n.translate(key, **options)
    end

    def initialize(base, attribute, type = :invalid, **options)
      @base = base
      @attribute = attribute
      @raw_type = type
      @type = type || :invalid
      @options = options
    end

    def initialize_dup(other) # :nodoc:
      @attribute = @attribute.dup
      @raw_type = @raw_type.dup
      @type = @type.dup
      @options = @options.deep_dup
    end

    # The object which the error belongs to
    attr_reader :base
    # The attribute of +base+ which the error belongs to
    attr_reader :attribute
    # The type of error, defaults to +:invalid+ unless specified
    attr_reader :type
    # The raw value provided as the second parameter when calling +errors#add+
    attr_reader :raw_type
    # The options provided when calling +errors#add+
    attr_reader :options

    # Returns the error message.
    #
    #   error = ActiveModel::Error.new(person, :name, :too_short, count: 5)
    #   error.message
   #   # => "is too short (minimum is 5 characters)"
    def message
      case raw_type
      when Symbol
        self.class.generate_message(attribute, raw_type, @base, options.except(*CALLBACKS_OPTIONS))
      else
        raw_type
      end
    end

    # Returns the error details.
    #
    #   error = ActiveModel::Error.new(person, :name, :too_short, count: 5)
    #   error.details
    #   # => { error: :too_short, count: 5 }
    def details
      { error: raw_type }.merge(options.except(*CALLBACKS_OPTIONS + MESSAGE_OPTIONS))
    end
    alias_method :detail, :details

    # Returns the full error message.
    #
    #   error = ActiveModel::Error.new(person, :name, :too_short, count: 5)
    #   error.full_message
    #   # => "Name is too short (minimum is 5 characters)"
    def full_message
      self.class.full_message(attribute, message, @base)
    end

    # See if error matches provided +attribute+, +type+ and +options+.
    #
    # Omitted params are not checked for a match.
    def match?(attribute, type = nil, **options)
      if @attribute != attribute || (type && @type != type)
        return false
      end

      options.each do |key, value|
        if @options[key] != value
          return false
        end
      end

      true
   end

    # See if error matches provided +attribute+, +type+ and +options+ exactly.
    #
    # All params must be equal to Error's own attributes to be considered a
    # strict match.
    def strict_match?(attribute, type, **options)
      return false unless match?(attribute, type)

      options == @options.except(*CALLBACKS_OPTIONS + MESSAGE_OPTIONS)
    end

    def ==(other) # :nodoc:
      other.is_a?(self.class) && attributes_for_hash == other.attributes_for_hash
    end
    alias eql? ==

    def hash # :nodoc:
      attributes_for_hash.hash
    end

    def inspect # :nodoc:
      "#<#{self.class.name} attribute=#{@attribute}, type=#{@type}, options=#{@options.inspect}>"
    end

    protected
      def attributes_for_hash
        [@base, @attribute, @raw_type, @options.except(*CALLBACKS_OPTIONS)]
      end
  end
end

irb(main):001:0> user = User.new(password: "hoge", password_confirmation: "hoge")
=> #<User:0x00007fb68c77a480 id: nil, email: nil, first_name: nil, last_name: nil, created_at: nil, updated_at: nil, crypted_password: nil, salt: nil>
irb(main):002:0> user.valid?
  User Exists? (0.8ms)  SELECT 1 AS one FROM "users" WHERE "users"."email" IS NULL LIMIT $1  [["LIMIT", 1]]
=> false
irb(main):003:0> user.errors.full_messages
irb(main):003:0> user.errors.full_messages

[92, 101] in /usr/local/bundle/gems/activemodel-6.1.7.8/lib/active_model/error.rb
    92:
    93:       defaults << :"errors.attributes.#{attribute}.#{type}"
    94:       defaults << :"errors.messages.#{type}"
    95:
    96:       debugger
=>  97:       key = defaults.shift
    98:       defaults = options.delete(:message) if options[:message]
    99:       options[:default] = defaults
   100:
   101:       I18n.translate(key, **options)
(byebug) defaults
[:"activerecord.errors.models.user.attributes.email.blank", :"activerecord.errors.models.user.blank", :"activerecord.errors.messages.blank", :"errors.attributes.email.blank", :"errors.messages.blank"]
(byebug) base.class
User(id: integer, email: string, first_name: string, last_name: string, created_at: datetime, updated_at: datetime, crypted_password: string, salt: string)
(byebug) User.i18n_scope
:activerecord
(byebug)

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"

<!-- app/views/products/show.html.erb -->
<%= t('product_price', price: @product.price) %>

# config/locales/en.yml
en:
  product_price: "$%{price}"

irb(main):006:0> user.errors.full_messages
[54, 63] in /usr/local/bundle/gems/activemodel-6.1.7.8/lib/active_model/error.rb
   54:         default: attr_name,
   55:         base: base,
   56:       })
   57:
   58:       debugger
=> 59:       I18n.t(defaults.shift,
   60:         default:  defaults,
   61:         attribute: attr_name,
   62:         message:   message)
   63:     end
(byebug) defaults
[:"errors.format", "%{attribute} %{message}"]
(byebug) attr_name
"Email"
(byebug) message
"can't be blank"
(byebug)  I18n.t(:"errors.format")
"%{attribute} %{message}"
(byebug)  I18n.t(:"errors.format")
"%{attribute} %{message}"
(byebug) attribute
"email"
(byebug) message