Reconfiguration des fichiers Ruby on Rails I18N YAML à l'aide de dictionnaires

cette question de StackOverflow m'a donné matière à réflexion sur ce qui est une bonne structure pour les Rails i18n fichiers, donc j'ai pensé que je partagerais une autre structure pour le remaniement des Rails i18n fichiers yml pour votre considération/critique.

étant donné que je voudrais

1. garder la structure par défaut de l'application afin que je puisse utiliser la sténographie "lazy" comme t('.some_translation') dans mes vues, ainsi que d'avoir une idée où les traductions sont utilisées dans l'application,
2. éviter autant de répétition de chaîne que possible, en particulier avec des mots qui ne sont pas identiques, mais qui ont aussi des contextes/significations identiques,
3. il suffit de changer une clé une seule fois pour qu'elle se reflète partout où elle est référencée,

pour un config/locales/fr.YML fichier qui ressemble à quelque chose comme ceci:

activerecord:
  attributes:
    user:
      email: Email
      name: Name
      password: Password
      password_confirmation: Confirmation
  models:
    user: User
users:
  fields:
    email: Email
    name: Name
    password: Password
    confirmation: Confirmation
sessions:
  new:
    email: Email
    password: Password

je peux voyez qu'il y a une répétition significative, et que le contexte de mots comme "Email" et "mot de passe" sont sans ambiguïté et ont le même sens dans leurs vues respectives. Il serait un peu ennuyeux d'avoir à aller changer tous si je décide de changer de "Courriel" pour "e-mail", donc j'aimerais refactoriser les cordes pour faire référence à un dictionnaire de la sorte. Alors, que diriez-vous d'ajouter un hachage de dictionnaire en haut du fichier avec quelques ancres & comme ceci:

dictionary:
  email: &email Email
  name: &name Name
  password: &password Password
  confirmation: &confirmation Confirmation

activerecord:
  attributes:
    user:
      email: *email
      name: *name
      password: *password
      password_confirmation: *confirmation
  models:
    user: User
users:
  fields:  
    email: *email
    name: *name
    password: *password
    confirmation: *confirmation
sessions:
  new:
    email: *email
    password: *password

vous pouvez toujours continuer à utiliser des chaînes statiques (par exemple" Utilisateur " ci-dessus), mais chaque fois que vous obtenez plus d'une instance de exactement le même mot/phrase dans vos vues, vous pouvez le remanier vers le dictionnaire. Si la traduction du dictionnaire d'une clé dans la langue de base n'a pas de sens pour une langue cible, alors il suffit de changer la valeur référencée dans la langue cible en une chaîne statique ou de l'ajouter comme entrée supplémentaire au dictionnaire de la langue cible. Je suis sûr que chaque langue le dictionnaire peut être refactorisé dans un autre fichier s'il devient trop gros et lourd (Tant qu'il est réimporté en haut du fichier de traduction pour que les références fonctionnent).

cette façon de structurer les fichiers i18n yaml semble bien fonctionner avec certaines applications de test locales sur lesquelles je l'ai essayé. J'espère que le merveilleux Localeapp fournira un soutien pour ce genre d'ancrage / référencement à l'avenir. Mais de toute façon, tous ces dictionnaires ne peuvent pas peut-être une idée originale, alors y a-t-il d'autres problèmes avec le référencement d'ancre dans YAML, ou peut-être juste avec l'ensemble du "dictionnaire" concept en général? Ou est-ce qu'il est juste préférable de simplement enlever le backend par défaut et le remplacer par Redis ou quelque chose si vous avez des besoins au-delà des conventions i18n de Rails par défaut?

Modifier :

je voulais essayer d'adresser l'exemple de flux de travail de tigrish mentionné dans un commentaire ci-dessous, jusqu'ici, plutôt que comme un autre commentaire ci-dessous sa réponse. S'il vous plaît excusez-moi si Je ne semble pas obtenir les points étant fait ou si je suis juste naïf:

Point 1 : vous avez un attribut "name" général pour les modèles ActiveRecord, et ils tous pointent juste au dictionnaire générique pour le nom:

dictionary:
  name: &name Name

activerecord:
  attributes:
    name: *name
    user:
      name: *name
    product:
      name: *name

Point 2 : le nom du modèle Utilisateur doit être changé. D'autres noms rester le même.

Option 1 : conserver les noms des champs model identiques sur le verso et juste changer la traduction de l'avant vers laquelle il pointe.

dictionary:
  name: &name Name
  full_name: &full_name Full Name

activerecord:
  attributes:
    name: *name
    user:
      name: *full_name
    product:
      name: *name

Option 2 : changez également le nom du champ User model. Il faudrait pour cela modifier toute référence à cette clé dans le code, ainsi qu'une migration change_table / rename_column .

dictionary:
  name: &name Name
  full_name: &full_name Full Name

activerecord:
  attributes:
    name: *name
    user:
      full_name: *full_name
    product:
      name: *name

Option 3 : si vous voulez être très complet, modifiez l'information contenue dans un" nom " pour séparer les champs de base de données/Activemodel, qui auraient besoin de nouvelles entrées de dictionnaire et une migration. Vous pouvez décider sur vos vues comment vous voudriez qu'un" nom complet "s'affiche:

dictionary:
  name: &name Name
  name_prefix: &name_prefix Prefix
  first_name: &first_name First
  middle_name: &middle_name Middle
  last_name: &last_name Last
  name_suffix: &name_suffix Suffix

activerecord:
  attributes:
    name: *name
    user:
      name_prefix: *name_prefix
      first_name: *first_name
      middle_name: *middle_name
      last_name: *last_name
      name_suffix: *name_suffix
    product:
      name: *name

Point 3 : toute personne pour une raison quelconque a besoin d'un changement de traduction, Marketing dans ce cas. Je vais suivre de Point 2 L'exemple de L'Option 1

Option 1 : les noms des champs du modèle sont les mêmes, il suffit de changer la traduction de l'extrémité avant.

dictionary:
  name: &name Name
  full_name: &full_name Full Name
  funky_name: &funky_name Ur Phunky Phresh Naym

activerecord:
  attributes:
    name: *name
    user:
      name: *full_name
    product:
      name: *name
sessions: # Sign up page keys
  new:
    name: *funky_name

Option 2 : "Funky name" a désespérément besoin d'être sauvegardé dans la base de données, aussi, pour une raison quelconque. Appelons-le un username si personne ne s'y oppose (ou funky_name si pour une raison quelconque le Marketing insiste).

dictionary:
  name: &name Name
  full_name: &full_name Full Name
  funky_name: &funky_name Ur Phunky Phresh Naym

activerecord:
  attributes:
    name: *name
    user:
      name: *full_name
      username: *funky_name
    product:
      name: *name
sessions: # Sign up page keys
  new:
    name: *name
    funky_name: *funky_name

D'accord, donc j'admets que j'ai peu d'idée de ce que je fais, cependant, Je suis prêt à être abattu publiquement afin de comprendre pourquoi cette façon de travailler avec i18n dans Haml est une mauvaise idée dans une application Rails. Difficile à lire? Entretien cauchemar? Est-ce vraiment considéré comme 'hacking the file format' si j'utilise (ce que je pense être) une caractéristique de la langue?

merci encore à tigrish de m'avoir amené à sortir tout ça.