Rails: Verwendung von i18n mit Rails 4-Aufzählungen

Antworten:

51

Ich habe auch kein bestimmtes Muster gefunden und einfach hinzugefügt:

en:
  user_status:
    active:   Active
    pending:  Pending...
    archived: Archived

zu einer beliebigen .yml-Datei. Dann aus meiner Sicht:

I18n.t :"user_status.#{user.status}"
pierrea
quelle
5
Ich habe etwas Ähnliches gemacht, aber ich habe es untergelegt {locale}.activerecord.attributes.{model}.{attribute}und eine t_enum(model, enum, value)Hilfsmethode geschrieben, damit die Enum-Übersetzungen neben der Label-Übersetzung liegen
Chris Beck,
76

Ab Rails 5 erben alle Modelle von ApplicationRecord.

class User < ApplicationRecord
  enum status: [:active, :pending, :archived]
end

Ich verwende diese Oberklasse, um eine generische Lösung für die Übersetzung von Aufzählungen zu implementieren:

class ApplicationRecord < ActiveRecord::Base
  self.abstract_class = true

  def self.human_enum_name(enum_name, enum_value)
    I18n.t("activerecord.attributes.#{model_name.i18n_key}.#{enum_name.to_s.pluralize}.#{enum_value}")
  end
end

Dann füge ich die Übersetzungen in meine .ymlDatei ein:

en:
  activerecord:
    attributes:
      user:
        statuses:
          active: "Active"
          pending: "Pending"
          archived: "Archived"

Um die Übersetzung zu erhalten, die ich verwende:

User.human_enum_name(:status, :pending)
=> "Pending"
Repolês
quelle
3
Wie würden Sie damit in einem Dropdown-Menü umgehen (dh wenn kein einzelner Wert angezeigt wird)?
Tirdadc
6
@tirdadc Sie können ein Dropdown wie folgt behandeln : <%= f.select :status, User.statuses.keys.collect { |status| [User.human_enum_name(:status, status), status] } %>.
Repolês
3
+1 gute Antwort. Ich habe es für meine Verwendung als Ansichtshilfemethode optimiert, da ich der Meinung bin, dass dies eher ein Ansichtsproblem darstellt, und den Attributnamen nicht zu pluralisieren: gist.github.com/abevoelker/fed59c2ec908de15acd27965e4725762 Nennen Sie es in einer Ansicht wiehuman_enum_name(@user, :status)
Abe Voelker
1
Per Repolês können Sie Ihrem Basismodell auch eine andere Klassenmethode für Dropdowns hinzufügen : self.human_enum_collection(enum_name). Code wäre send(enum_name.to_s.pluralize).keys.collect { |val| [human_enum_name(enum_name, val), val] }
armchairdj
32

Hier ist eine Ansicht:

select_tag :gender, options_for_select(Profile.gender_attributes_for_select)

Hier ist ein Modell (Sie können diesen Code tatsächlich in einen Helfer oder Dekorateur verschieben).

class Profile < ActiveRecord::Base
  enum gender: {male: 1, female: 2, trans: 3}

  # @return [Array<Array>]
  def self.gender_attributes_for_select
    genders.map do |gender, _|
      [I18n.t("activerecord.attributes.#{model_name.i18n_key}.genders.#{gender}"), gender]
    end
  end
end

Und hier ist die Gebietsschemadatei:

en:
  activerecord:
    attributes:
      profile:
        genders:
          male: Male
          female: Female
          trans: Trans
Aliaksandr
quelle
1
aber wie bekommt man in diesem Fall eine Übersetzung für einen einzelnen Datensatz? Weil .human_attribute_name('genders.male')nicht funktionieren
Stiig
Danke, funktioniert in meinem Fall wie Charme !
Matiss
Ich habe leichte Edelsteine ​​für diese Zwecke gemacht github.com/shlima/translate_enum
Aliaksandr
27

Um die Internationalisierung ähnlich wie bei jedem anderen Attribut zu halten, habe ich das verschachtelte Attribut wie hier zu sehen verwendet .

Wenn Sie eine Klasse haben User:

class User < ActiveRecord::Base
  enum role: [ :teacher, :coordinator ]
end

Und so ymlähnlich:

pt-BR:
  activerecord:
    attributes:
      user/role: # You need to nest the values under model_name/attribute_name
        coordinator: Coordenador
        teacher: Professor

Sie können verwenden:

User.human_attribute_name("role.#{@user.role}")
Doguita
quelle
1
Dies ist optisch ansprechend, verstößt jedoch gegen die Konvention activerecord.attributes.<fieldname>, die labelÜbersetzung für Formularhelfer zu sein
Chris Beck,
4
@ChrisBeck es scheint, dass dies der Konvention folgt, die im Rails I18n Guide beschrieben wird : guides.rubyonrails.org/…
danblaker
7

Modell:

enum stage: { starting: 1, course: 2, ending: 3 }

def self.i18n_stages(hash = {})
  stages.keys.each { |key| hash[I18n.t("checkpoint_stages.#{key}")] = key }
  hash
end

Gebietsschema:

checkpoint_stages:
    starting: Saída
    course: Percurso
    ending: Chegada

Und auf der Ansicht (.slim):

= f.input_field :stage, collection: Checkpoint.i18n_stages, as: :radio_buttons
Oswaldo Ferreira
quelle
6

Wenn Sie die Antwort von user3647358 näher erläutern, können Sie dies sehr genau so erreichen, wie Sie es bei der Übersetzung von Attributnamen gewohnt sind.

Gebietsschemadatei:

en:
  activerecord:
    attributes:
      profile:
        genders:
          male: Male
          female: Female
          trans: Trans

Übersetzen Sie mit I18n # t:

profile = Profile.first
I18n.t(profile.gender, scope: [:activerecord, :attributes, :profile, :genders])
Rafael Valverde
quelle
4

Versuchen Sie, TranslateEnum gem für diese Zwecke zu verwenden

class Post < ActiveRecord::Base
  enum status: { published: 0, archive: 1 }
  translate_enum :status
end


Post.translated_status(:published)
Post.translated_statuses

@post = Post.new(status: :published)
@post.translated_status 
Aliaksandr
quelle
1
Wir benutzen auch dieses Juwel. Hat den saubersten Ansatz von allen Optionen, die wir bewertet haben, und ist gut gepflegt.
Cseelus
3

Ich habe ein Juwel dafür geschaffen.

http://rubygems.org/gems/translated_attribute_value

Fügen Sie Ihrem Gemfile hinzu:

gem 'translated_attribute_value'

Wenn Sie ein Statusfeld für den Benutzer haben:

pt-BR:
  activerecord:
    attributes:
      user:
        status_translation:
          value1: 'Translation for value1'
          value2: 'Translation for value2'

Und aus Ihrer Sicht können Sie so anrufen:

user.status_translated

Es funktioniert mit Active Record, Mongoid oder jeder anderen Klasse mit Getter / Setter:

https://github.com/viniciusoyama/translated_attribute_value

Vinícius Oyama
quelle
3

Wenn wir die Antworten von Repolês und Aliaksandr für Rails 5 kombinieren , können wir zwei Methoden erstellen, mit denen Sie einen einzelnen Wert oder eine Sammlung von Werten aus einem Enum-Attribut übersetzen können.

Richten Sie die Übersetzungen in Ihrer .ymlDatei ein:

en:
  activerecord:
    attributes:
      user:
        statuses:
          active: "Active"
          pending: "Pending"
          archived: "Archived"

In der ApplicationRecordKlasse, von der alle Modelle erben, definieren wir eine Methode, die Übersetzungen für einen einzelnen Wert verarbeitet, und eine andere, die Arrays durch Aufrufen verarbeitet:

class ApplicationRecord < ActiveRecord::Base
  self.abstract_class = true

  def self.translate_enum_name(enum_name, enum_value)
    I18n.t("activerecord.attributes.#{model_name.i18n_key}.#{enum_name.to_s.pluralize}.#{enum_value}")
  end

  def self.translate_enum_collection(enum_name)
    enum_values = self.send(enum_name.to_s.pluralize).keys
    enum_values.map do |enum_value|
      self.translate_enum_name enum_name, enum_value
    end
  end
end 

In unseren Ansichten können wir dann einzelne Werte übersetzen:

<p>User Status: <%= User.translate_enum_name :status, @user.status %></p>

Oder die gesamte Sammlung von Enum-Werten:

<%= f.select(:status, User.translate_enum_collection :status) %>
ne5t
quelle
2

Probieren Sie das Juwel enum_help aus . Aus seiner Beschreibung:

Helfen Sie der ActiveRecord :: Enum-Funktion, mit I18n und simple_form einwandfrei zu funktionieren.

Kukunin
quelle
2

Hier ist eine t_enumHilfsmethode, die ich benutze.

<%= t_enum(@user, :status) %>

enum_helper.rb :

module EnumHelper

  def t_enum(inst, enum)
    value = inst.send(enum);
    t_enum_class(inst.class, enum, value)
  end

  def t_enum_class(klass, enum, value)
    unless value.blank?
      I18n.t("activerecord.enums.#{klass.to_s.demodulize.underscore}.#{enum}.#{value}")
    end
  end

end

user.rb :

class User < ActiveRecord::Base
  enum status: [:active, :pending, :archived]
end 

en.yml :

en:
  activerecord:
    enums:
      user:
        status:
          active:   "Active"
          pending:  "Pending..."
          archived: "Archived"
cweston
quelle
2

Das Model:

class User < ActiveRecord::Base
  enum role: [:master, :apprentice]
end

Die Gebietsschemadatei:

en:
  activerecord:
    attributes:
      user:
        master: Master
        apprentice: Apprentice

Verwendung:

User.human_attribute_name(:master) # => Master
User.human_attribute_name(:apprentice) # => Apprentice
Dmitry
quelle
Wie wäre es @user.role, denn das ist das Hauptproblem.
Code-MonKy
Der geradlinigste, sauberste und eleganteste Weg.
Fabian Winkler
5
AnyModel.human_attribute_name (: i_dont_exist) => "Ich existiere nicht"
Shiyason
1

Ich bevorzuge einen einfachen Helfer in application_helper

  def translate_enum(object, enum_name)
    I18n.t("activerecord.attributes.#{object.model_name.i18n_key}.#{enum_name.to_s.pluralize}.#{object.send(enum_name)}")
  end

Dann in meiner YML-Datei:

fr:
  activerecord:
    attributes:
      my_model:
        my_enum_plural:
          pending:  "En cours"
          accepted: "Accepté"
          refused:  "Refusé"
Schlange
quelle
0

Noch ein anderer Weg, ich finde es ein bisschen bequemer, ein Anliegen in Modellen zu verwenden

Besorgnis, Sorge :

module EnumTranslation
  extend ActiveSupport::Concern

  def t_enum(enum)
    I18n.t "activerecord.attributes.#{self.class.name.underscore}.enums.#{enum}.#{self.send(enum)}"
  end
end

YML:

fr:
    activerecord:
      attributes:
        campaign:
          title: Titre
          short_description: Description courte
          enums:
            status:
              failed: "Echec"

Aussicht :

<% @campaigns.each do |c| %>
  <%= c.t_enum("status") %>
<% end %>

Vergessen Sie nicht, Ihrem Modell Bedenken hinzuzufügen:

class Campaign < ActiveRecord::Base
  include EnumTranslation

  enum status: [:designed, :created, :active, :failed, :success]
end
Geoffrey H.
quelle
0

Sie können einfach einen Helfer hinzufügen:

def my_something_list
  modes = 'activerecord.attributes.mymodel.my_somethings'
  I18n.t(modes).map {|k, v| [v, k]}
end

und richten Sie es wie gewohnt ein:

en:
  activerecord:
    attributes:
      mymodel:
        my_somethings:
           my_enum_value: "My enum Value!"

Verwenden Sie es dann mit Ihrer Auswahl: my_something_list

ftshtw
quelle
0
class ApplicationRecord < ActiveRecord::Base
  self.abstract_class = true

  def self.enum(definitions)
    defind_i18n_text(definitions) if definitions.delete(:_human)
    super(definitions)
  end

  def self.defind_i18n_text(definitions)
    scope = i18n_scope
    definitions.each do |name, values|
      next if name.to_s.start_with?('_')
      define_singleton_method("human_#{name.to_s.tableize}") do
        p values
        values.map { |key, _value| [key, I18n.t("#{scope}.enums.#{model_name.i18n_key}.#{name}.#{key}")] }.to_h
      end

      define_method("human_#{name}") do
        I18n.t("#{scope}.enums.#{model_name.i18n_key}.#{name}.#{send(name)}")
      end
    end
  end
end


en:
  activerecord:
    enums:
      mymodel:
        my_somethings:
           my_enum_value: "My enum Value!"

enum status: [:unread, :down], _human: true
Kevin.Xin
quelle