#55

backend/spec/models/locale_spec.rb

@@ -0,0 +1,69 @@
+require 'rails_helper'
+
+RSpec.describe Locale, type: :model do
+  def prepare_french_reference!
+    Language.find_or_create_by!(code: 'fr') { _1.name = 'French' }
+    Script.find_or_create_by!(code: 'Latn') { _1.name = 'Latin' }
+  end
+
+  def create_french_locale!
+    prepare_french_reference!
+    described_class.create!(code: 'fr', language_code: 'fr',
+                            script_code: 'Latn', name: 'French')
+  end
+
+  it 'generates a primary name for every existing tag using the name generator' do
+    first = create(:tag, name: 'first_existing_tag')
+    second = create(:tag, name: 'second_existing_tag')
+    allow(TagName).to receive(:generate_name).and_call_original
+    allow(TagName).to receive(:generate_name)
+        .with(kind_of(described_class), first, first.name)
+        .and_return('name_from_generator')
+
+    locale = create_french_locale!
+
+    expect(TagName).to have_received(:generate_name).with(locale, first, first.name)
+    expect(TagName).to have_received(:generate_name).with(locale, second, second.name)
+    expect(first.tag_names.find_by!(language_code: 'fr', primary_flg: true))
+        .to have_attributes(name: 'name_from_generator', tag_id: first.id,
+                            language_code: 'fr', script_code: 'Latn',
+                            primary_flg: true, canonical_id: nil)
+    expect(second.tag_names.find_by!(language_code: 'fr', primary_flg: true))
+        .to have_attributes(tag_id: second.id, language_code: 'fr',
+                            script_code: 'Latn', primary_flg: true, canonical_id: nil)
+    expect(TagName.where(language_code: 'fr', primary_flg: true,
+                         tag_id: [first.id, second.id]).count).to eq(2)
+  end
+
+  it 'does not duplicate an existing primary name in the new language' do
+    prepare_french_reference!
+    tag = create(:tag, name: 'already_named')
+    existing = create(:tag_name, name: 'nom_existant', tag:,
+                                 language_code: 'fr', script_code: 'Latn')
+
+    create_french_locale!
+
+    expect(TagName.where(tag_id: tag.id, language_code: 'fr', primary_flg: true))
+        .to contain_exactly(existing)
+    expect(existing.reload).to have_attributes(
+        tag_id: tag.id, language_code: 'fr', script_code: 'Latn', primary_flg: true)
+  end
+
+  it 'creates a primary name when the language has only an alias' do
+    prepare_french_reference!
+    tag = create(:tag, name: 'alias_only_tag')
+    alias_name = create(:tag_name, :alias, name: 'alias_fr',
+                                          canonical: tag.tag_name,
+                                          language_code: 'fr', script_code: 'Latn')
+
+    create_french_locale!
+
+    expect(alias_name.reload).to have_attributes(
+        canonical_id: tag.tag_name_id, tag_id: tag.id,
+        language_code: 'fr', script_code: 'Latn', primary_flg: false)
+    generated = TagName.find_by!(tag_id: tag.id, language_code: 'fr', primary_flg: true)
+    expect(generated).to have_attributes(tag_id: tag.id, language_code: 'fr',
+                                         script_code: 'Latn', primary_flg: true)
+    expect(TagName.where(tag_id: tag.id, language_code: 'fr', primary_flg: true).count).to eq(1)
+  end
+end

backend/spec/models/material_export_item_spec.rb

@@ -2,7 +2,7 @@ require 'rails_helper'
 
 RSpec.describe MaterialExportItem, type: :model do
   let(:user) { create(:user, :member) }
-  let(:tag) { Tag.create!(tag_name: TagName.create!(name: 'export_item'), category: :material) }
+  let(:tag) { create(:tag, name: 'export_item', category: :material) }
   let(:material) do
     Material.create!(tag:, url: 'https://example.com/material',
                      created_by_user: user, updated_by_user: user)

backend/spec/models/post_version_spec.rb

@@ -1,8 +1,8 @@
 require 'rails_helper'
 
 RSpec.describe PostVersion, type: :model do
-  let!(:tag_name) { TagName.create!(name: 'post_version_spec_tag') }
-  let!(:tag) { Tag.create!(tag_name: tag_name, category: :general) }
+  let!(:tag_name) { create(:tag_name, name: 'post_version_spec_tag') }
+  let!(:tag) { create(:tag, tag_name: tag_name, category: :general) }
 
   let!(:post_record) do
     Post.create!(title: 'spec post', url: 'https://example.com/post-version-spec').tap do |post|

backend/spec/models/tag_name_sanitisation_rule_spec.rb

@@ -34,9 +34,41 @@ RSpec.describe TagNameSanitisationRule, type: :model do
       described_class.create!(priority: 10, source_pattern: '_', replacement: '')
     end
 
+    context 'when only another language has the sanitised name' do
+      include_context 'English locale'
+
+      it 'keeps both names when sanitisation produces a cross-language match' do
+        japanese = create(:tag_name, name: 'foobar')
+        english = create(:tag_name, name: 'temporary',
+                                   language_code: 'en', script_code: 'Latn')
+        english.update_columns(name: 'foo_bar')
+
+        expect { described_class.apply! }.not_to change(TagName, :count)
+
+        expect(english.reload).to have_attributes(name: 'foobar', language_code: 'en')
+        expect(japanese.reload).to have_attributes(name: 'foobar', language_code: 'ja')
+      end
+
+      it 'renames without merging tags or deleting either language identity' do
+        japanese = create(:tag, name: 'foobar')
+        english_name = create(:tag_name, name: 'temporary',
+                                        language_code: 'en', script_code: 'Latn')
+        english = create(:tag, tag_name: english_name)
+        english_name.update_columns(name: 'foo_bar')
+
+        described_class.apply!
+
+        expect(english_name.reload).to have_attributes(
+            name: 'foobar', language_code: 'en', tag_id: english.id)
+        expect(japanese.reload.tag_name).to have_attributes(
+            name: 'foobar', language_code: 'ja', tag_id: japanese.id)
+        expect(english.reload.tag_name_id).to eq(english_name.id)
+      end
+    end
+
     context 'when no conflicting tag_name exists' do
       let!(:tag_name) do
-        TagName.create!(name: 'tmp').tap do |tn|
+        create(:tag_name, name: 'tmp').tap do |tn|
           tn.update_columns(name: 'foo_bar', updated_at: Time.current)
         end
       end
@@ -48,9 +80,9 @@ RSpec.describe TagNameSanitisationRule, type: :model do
     end
 
     context 'when a conflicting canonical tag_name exists' do
-      let!(:existing) { TagName.create!(name: 'foobar') }
+      let!(:existing) { create(:tag_name, name: 'foobar') }
       let!(:source) do
-        TagName.create!(name: 'tmp').tap do |tn|
+        create(:tag_name, name: 'tmp').tap do |tn|
           tn.update_columns(name: 'foo_bar', updated_at: Time.current)
         end
       end
@@ -63,7 +95,7 @@ RSpec.describe TagNameSanitisationRule, type: :model do
     end
 
     context 'when the source tag_name has a tag and the existing one has no tag' do
-      let!(:existing) { TagName.create!(name: 'foobar') }
+      let!(:existing) { create(:tag_name, name: 'foobar') }
       let!(:source_tag) { create(:tag, name: 'tmp', category: :general) }
       let!(:source_tag_name_id) { source_tag.tag_name_id }
 
@@ -82,10 +114,10 @@ RSpec.describe TagNameSanitisationRule, type: :model do
     context 'when the sanitised name is an alias of an existing tag' do
       let!(:existing_tag) { create(:tag) }
       let!(:alias_name) do
-        TagName.create!(name: 'foobar', canonical: existing_tag.tag_name)
+        create(:tag_name, :alias, name: 'foobar', canonical: existing_tag.tag_name)
       end
       let!(:source) do
-        TagName.create!(name: 'tmp').tap do |tn|
+        create(:tag_name, name: 'tmp').tap do |tn|
           tn.update_columns(name: 'foo_bar', updated_at: Time.current)
         end
       end
@@ -100,11 +132,11 @@ RSpec.describe TagNameSanitisationRule, type: :model do
     end
 
     context 'when both source and existing tag_names have tags' do
-      let!(:existing_tn) { TagName.create!(name: 'foobar') }
-      let!(:existing_tag) { Tag.create!(tag_name: existing_tn, category: :general) }
+      let!(:existing_tn) { create(:tag_name, name: 'foobar') }
+      let!(:existing_tag) { create(:tag, tag_name: existing_tn, category: :general) }
 
-      let!(:source_tn) { TagName.create!(name: 'tmp') }
-      let!(:source_tag) { Tag.create!(tag_name: source_tn, category: :general) }
+      let!(:source_tn) { create(:tag_name, name: 'tmp') }
+      let!(:source_tag) { create(:tag, tag_name: source_tn, category: :general) }
       let!(:source_tag_name_id) { source_tn.id }
 
       before do

backend/spec/models/tag_name_spec.rb

@@ -0,0 +1,73 @@
+require 'rails_helper'
+
+RSpec.describe TagName, type: :model do
+  include_context 'English locale'
+
+  it 'allows the same name in different languages' do
+    create(:tag_name, name: 'shared_name')
+    english = build(:tag_name, name: 'shared_name',
+                              language_code: 'en', script_code: 'Latn')
+
+    expect(english).to be_valid
+    expect { english.save! }.to change(described_class, :count).by(1)
+  end
+
+  it 'rejects a duplicate name within the same language' do
+    create(:tag_name, name: 'shared_name')
+    duplicate = build(:tag_name, name: 'shared_name')
+
+    expect(duplicate).to be_invalid
+    expect(duplicate.errors.of_kind?(:name, :taken)).to be(true)
+  end
+
+  it 'creates Japanese factory names without requiring a tag' do
+    name = create(:tag_name)
+
+    expect(name.reload).to have_attributes(
+        language_code: 'ja', script_code: 'Jpan', primary_flg: true, tag_id: nil)
+  end
+
+  it 'persists both sides of the representative tag factory association' do
+    tag = create(:tag)
+
+    expect(tag.reload.tag_name.reload.tag_id).to eq(tag.id)
+    expect(tag.tag_name.tag).to eq(tag)
+  end
+
+  it 'accepts an alias owned by the canonical tag' do
+    tag = create(:tag)
+    alias_name = build(:tag_name, name: 'valid_alias', canonical: tag.tag_name,
+                                 tag:, primary_flg: false)
+
+    expect(alias_name).to have_attributes(
+        canonical_id: tag.tag_name_id, tag_id: tag.id,
+        primary_flg: false, language_code: 'ja')
+    expect(alias_name).to be_valid
+  end
+
+  describe '.canonicalise' do
+    it 'resolves only aliases in the requested language' do
+      japanese = create(:tag, name: 'japanese_canonical')
+      english_name = create(:tag_name, name: 'english_canonical',
+                                      language_code: 'en', script_code: 'Latn')
+      english = create(:tag, tag_name: english_name)
+      japanese_alias = create(:tag_name, :alias, name: 'shared_alias',
+                                                 canonical: japanese.tag_name)
+      english_alias = create(:tag_name, :alias, name: 'temporary_alias',
+                                                canonical: english_name,
+                                                language_code: 'en', script_code: 'Latn')
+      english_alias.update_columns(name: 'shared_alias')
+
+      expect(japanese_alias.reload).to have_attributes(
+          canonical_id: japanese.tag_name_id, tag_id: japanese.id,
+          primary_flg: false, language_code: 'ja')
+      expect(english_alias.reload).to have_attributes(
+          canonical_id: english_name.id, tag_id: english.id,
+          primary_flg: false, language_code: 'en')
+      expect(described_class.canonicalise(locale, ['shared_alias']))
+          .to eq(['english_canonical'])
+      expect(described_class.canonicalise(Locale.nipponese, ['shared_alias']))
+          .to eq(['japanese_canonical'])
+    end
+  end
+end

backend/spec/models/tag_spec.rb

@@ -9,7 +9,7 @@ RSpec.describe Tag, type: :model do
         expect(tag).to be_invalid
         expect(tag.errors[:name]).to be_present
         expect {
-          described_class.normalise_tags!([name])
+          described_class.normalise_tags!(Locale.nipponese, [name])
         }.to raise_error(Tag::NicoTagNormalisationError)
       end
     end
@@ -25,19 +25,49 @@ RSpec.describe Tag, type: :model do
   end
 
   describe '.normalise_tags!' do
+    it 'canonicalises aliases in the supplied language only' do
+      Language.find_or_create_by!(code: 'en') { _1.name = 'English' }
+      Script.find_or_create_by!(code: 'Latn') { _1.name = 'Latin' }
+      Locale.insert_all!([
+          { code: 'en', language_code: 'en', script_code: 'Latn',
+            name: 'English', created_at: Time.current }]) unless Locale.exists?(code: 'en')
+      english_locale = Locale.find('en')
+      japanese = create(:tag, name: 'japanese_canonical')
+      english_name = create(:tag_name, name: 'english_canonical',
+                                      language_code: 'en', script_code: 'Latn')
+      english = create(:tag, tag_name: english_name)
+      japanese_alias = create(:tag_name, :alias, name: 'shared_alias',
+                                                 canonical: japanese.tag_name)
+      english_alias = create(:tag_name, :alias, name: 'temporary_alias',
+                                                canonical: english_name,
+                                                language_code: 'en', script_code: 'Latn')
+      english_alias.update_columns(name: 'shared_alias')
+
+      expect(japanese_alias.reload).to have_attributes(
+          canonical_id: japanese.tag_name_id, tag_id: japanese.id,
+          primary_flg: false, language_code: 'ja')
+      expect(english_alias.reload).to have_attributes(
+          canonical_id: english_name.id, tag_id: english.id,
+          primary_flg: false, language_code: 'en')
+      expect(described_class.normalise_tags!(
+          english_locale, ['shared_alias'],
+          with_tagme: false, with_no_deerjikist: false)).to eq([english])
+      expect(described_class.normalise_tags!(
+          Locale.nipponese, ['shared_alias'],
+          with_tagme: false, with_no_deerjikist: false)).to eq([japanese])
+    end
+
     it 'rejects deprecated tags when deny_deprecated is enabled' do
-      tag_name = TagName.create!(name: 'normalise deprecated tag')
-      deprecated_tag = Tag.create!(
-        tag_name:,
-        category: :general,
-        deprecated_at: 1.day.from_now
-      )
+      tag_name = create(:tag_name, name: 'normalise deprecated tag')
+      deprecated_tag = create(:tag,
+          tag_name:,
+          category: :general,
+          deprecated_at: 1.day.from_now)
 
       expect {
-        described_class.normalise_tags!(
-          [deprecated_tag.name],
-          deny_deprecated: true
-        )
+        described_class.normalise_tags!(Locale.nipponese,
+            [deprecated_tag.name],
+            deny_deprecated: true)
       }.to raise_error(Tag::DeprecatedTagNormalisationError) { |error|
         expect(error.tag_names).to eq([deprecated_tag.name])
       }
@@ -45,88 +75,79 @@ RSpec.describe Tag, type: :model do
 
     it 'rejects invalid section literals instead of treating them as zero' do
       expect {
-        described_class.normalise_tags!(
-          ['normalise_invalid_section[1:aa-2:00]'],
-          with_sections: true
-        )
+        described_class.normalise_tags!(Locale.nipponese,
+            ['normalise_invalid_section[1:aa-2:00]'],
+            with_sections: true)
       }.to raise_error(Tag::SectionLiteralParseError)
     end
 
     it 'parses open-ended section literals' do
-      result = described_class.normalise_tags!(
-        ['伊地知ニジカ[1:00-]'],
-        with_sections: true
-      )
+      result = described_class.normalise_tags!(Locale.nipponese,
+          ['伊地知ニジカ[1:00-]'],
+          with_sections: true)
 
       tag = result.fetch(:tags).find { _1.name == '伊地知ニジカ' }
       expect(result.fetch(:sections).fetch(tag.id)).to eq([[60_000, nil]])
     end
 
     it 'parses omitted begin as zero' do
-      result = described_class.normalise_tags!(
-        ['伊地知ニジカ[-1:00]'],
-        with_sections: true
-      )
+      result = described_class.normalise_tags!(Locale.nipponese,
+          ['伊地知ニジカ[-1:00]'],
+          with_sections: true)
 
       tag = result.fetch(:tags).find { _1.name == '伊地知ニジカ' }
       expect(result.fetch(:sections).fetch(tag.id)).to eq([[0, 60_000]])
     end
 
     it 'treats fully open section literals as plain tags' do
-      result = described_class.normalise_tags!(
-        ['伊地知ニジカ[-]'],
-        with_sections: true
-      )
+      result = described_class.normalise_tags!(Locale.nipponese,
+          ['伊地知ニジカ[-]'],
+          with_sections: true)
 
       tag = result.fetch(:tags).find { _1.name == '伊地知ニジカ' }
       expect(result.fetch(:sections)[tag.id]).to be_nil
     end
 
     it 'treats [0:00-] as a plain tag' do
-      result = described_class.normalise_tags!(
-        ['伊地知ニジカ[0:00-]'],
-        with_sections: true
-      )
+      result = described_class.normalise_tags!(Locale.nipponese,
+          ['伊地知ニジカ[0:00-]'],
+          with_sections: true)
 
       tag = result.fetch(:tags).find { _1.name == '伊地知ニジカ' }
       expect(result.fetch(:sections)[tag.id]).to be_nil
     end
 
     it 'expands zero-width sections to one millisecond' do
-      result = described_class.normalise_tags!(
-        ['伊地知ニジカ[1:00-1:00]'],
-        with_sections: true
-      )
+      result = described_class.normalise_tags!(Locale.nipponese,
+          ['伊地知ニジカ[1:00-1:00]'],
+          with_sections: true)
 
       tag = result.fetch(:tags).find { _1.name == '伊地知ニジカ' }
       expect(result.fetch(:sections).fetch(tag.id)).to eq([[60_000, 60_001]])
     end
 
     it 'swaps reversed section boundaries' do
-      result = described_class.normalise_tags!(
-        ['伊地知ニジカ[2:00-1:00]'],
-        with_sections: true
-      )
+      result = described_class.normalise_tags!(Locale.nipponese,
+          ['伊地知ニジカ[2:00-1:00]'],
+          with_sections: true)
 
       tag = result.fetch(:tags).find { _1.name == '伊地知ニジカ' }
       expect(result.fetch(:sections).fetch(tag.id)).to eq([[60_000, 120_000]])
     end
 
     it 'merges open-ended sections over later bounded sections' do
-      result = described_class.normalise_tags!(
-        ['伊地知ニジカ[1:00-][2:00-3:00]'],
-        with_sections: true
-      )
+      result = described_class.normalise_tags!(Locale.nipponese,
+          ['伊地知ニジカ[1:00-][2:00-3:00]'],
+          with_sections: true)
 
       tag = result.fetch(:tags).find { _1.name == '伊地知ニジカ' }
       expect(result.fetch(:sections).fetch(tag.id)).to eq([[60_000, nil]])
     end
 
     it 'merges adjacent bounded and open-ended sections' do
-      result = described_class.normalise_tags!(
-        ['伊地知ニジカ[1:00-3:00][3:00-]'],
-        with_sections: true
-      )
+      result = described_class.normalise_tags!(Locale.nipponese,
+          ['伊地知ニジカ[1:00-3:00][3:00-]'],
+          with_sections: true)
 
       tag = result.fetch(:tags).find { _1.name == '伊地知ニジカ' }
       expect(result.fetch(:sections).fetch(tag.id)).to eq([[60_000, nil]])
@@ -183,11 +204,65 @@ RSpec.describe Tag, type: :model do
   end
 
   describe '.find_or_create_by_tag_name!' do
+    context 'with an explicit locale' do
+      include_context 'English locale'
+
+      it 'creates the representative name with locale attributes and ownership' do
+        tag = described_class.find_or_create_by_tag_name!(
+            locale, 'english_name', category: :character)
+
+        expect(tag.tag_name.reload).to have_attributes(
+            language_code: 'en', script_code: 'Latn',
+            primary_flg: true, tag_id: tag.id)
+        expect(tag.category).to eq('character')
+      end
+
+      it 'creates separate tag identities for the same name in different languages' do
+        japanese = described_class.find_or_create_by_tag_name!(
+            Locale.nipponese, 'same_name', category: :general)
+        english = described_class.find_or_create_by_tag_name!(
+            locale, 'same_name', category: :character)
+
+        expect(english).not_to eq(japanese)
+        expect(english.tag_name.language_code).to eq('en')
+        expect(japanese.tag_name.language_code).to eq('ja')
+        expect(described_class.find_or_create_by_tag_name!(
+            locale, 'same_name', category: :general)).to eq(english)
+        expect(described_class.find_or_create_by_tag_name!(
+            Locale.nipponese, 'same_name', category: :general)).to eq(japanese)
+      end
+
+      it 'preserves the V1 representative when looking up another primary language' do
+        tag = create(:tag, name: '日本語代表名')
+        representative_id = tag.tag_name_id
+        english = create(:tag_name, name: 'english_primary', tag:,
+            language_code: 'en', script_code: 'Latn')
+
+        found = described_class.find_or_create_by_tag_name!(
+            locale, english.name, category: :general)
+
+        expect(found).to eq(tag)
+        expect(tag.reload.tag_name_id).to eq(representative_id)
+        expect(english.reload.tag_id).to eq(tag.id)
+      end
+
+      it 'normalises names using the supplied locale' do
+        tags = described_class.normalise_tags!(
+            locale, ['character:normalised_english'],
+            with_tagme: false, with_no_deerjikist: false)
+
+        expect(tags.length).to eq(1)
+        expect(tags.first.tag_name).to have_attributes(
+            name: 'normalised_english', language_code: 'en', script_code: 'Latn',
+            primary_flg: true, tag_id: tags.first.id)
+      end
+    end
+
     it 'creates a tag and name with the requested category after stripping whitespace' do
       tag = nil
 
       expect {
-        tag = described_class.find_or_create_by_tag_name!(
+        tag = described_class.find_or_create_by_tag_name!(Locale.nipponese,
             '  lookup_new  ', category: :character)
       }.to change(Tag, :count).by(1).and change(TagName, :count).by(1)
 
@@ -197,27 +272,38 @@ RSpec.describe Tag, type: :model do
 
     it 'reuses the canonical tag for an alias without changing its category' do
       tag = create(:tag, category: :character)
-      alias_name = TagName.create!(name: 'lookup_alias', canonical: tag.tag_name)
+      representative_id = tag.tag_name_id
+      alias_name = create(:tag_name, :alias, name: 'lookup_alias', canonical: tag.tag_name)
+      expect(alias_name.reload).to have_attributes(
+          canonical_id: tag.tag_name_id, tag_id: tag.id,
+          primary_flg: false, language_code: 'ja')
       found = nil
 
       expect {
-        found = described_class.find_or_create_by_tag_name!(
+        found = described_class.find_or_create_by_tag_name!(Locale.nipponese,
             alias_name.name, category: :general)
       }.to change(Tag, :count).by(0).and change(TagName, :count).by(0)
 
       expect(found).to eq(tag)
       expect(found.category).to eq('character')
+      expect(tag.reload.tag_name_id).to eq(representative_id)
     end
 
-    it 'creates a tag for an existing canonical name reached through an alias' do
-      canonical = create(:tag_name)
-      alias_name = TagName.create!(name: 'lookup_alias', canonical:)
-      tag = nil
+    it 'reuses the canonical tag through another alias' do
+      tag = create(:tag)
+      canonical = tag.tag_name
+      alias_name = create(:tag_name, :alias, name: 'lookup_alias', canonical:)
+      other_alias = create(:tag_name, :alias, name: 'lookup_other_alias', canonical:)
+
+      expect([alias_name.reload, other_alias.reload]).to all(have_attributes(
+          canonical_id: canonical.id, tag_id: tag.id,
+          primary_flg: false, language_code: 'ja'))
 
       expect {
-        tag = described_class.find_or_create_by_tag_name!(
+        found = described_class.find_or_create_by_tag_name!(Locale.nipponese,
             alias_name.name, category: :general)
-      }.to change(Tag, :count).by(1).and change(TagName, :count).by(0)
+        expect(found).to eq(tag)
+      }.to change(Tag, :count).by(0).and change(TagName, :count).by(0)
 
       expect(tag.tag_name).to eq(canonical)
     end
@@ -277,7 +363,7 @@ RSpec.describe Tag, type: :model do
     it 'keeps source history and records the new target alias after deleting the source' do
       user = create_member_user!
       source_name = source_tag.name
-      source_alias = TagName.create!(name: 'merge_alias', canonical: source_tag_name)
+      source_alias = create(:tag_name, :alias, name: 'merge_alias', canonical: source_tag_name)
       TagVersioning.ensure_snapshot!(source_tag, created_by_user: user)
       original_version = source_tag.tag_versions.first