#55

backend/spec/models/locale_spec.rb

@@ -27,10 +27,10 @@ RSpec.describe Locale, type: :model do
     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)
+                            primary_flg: true)
     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)
+                            script_code: 'Latn', primary_flg: true)
     expect(TagName.where(language_code: 'fr', primary_flg: true,
                          tag_id: [first.id, second.id]).count).to eq(2)
   end
@@ -53,13 +53,13 @@ RSpec.describe Locale, type: :model do
     prepare_french_reference!
     tag = create(:tag, name: 'alias_only_tag')
     alias_name = create(:tag_name, :alias, name: 'alias_fr',
-                                          canonical: tag.tag_name,
+                                          tag:,
                                           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,
+        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',

backend/spec/models/tag_name_sanitisation_rule_spec.rb

@@ -79,7 +79,7 @@ RSpec.describe TagNameSanitisationRule, type: :model do
       end
     end
 
-    context 'when a conflicting canonical tag_name exists' do
+    context 'when a conflicting primary tag name exists' do
       let!(:existing) { create(:tag_name, name: 'foobar') }
       let!(:source) do
         create(:tag_name, name: 'tmp').tap do |tn|
@@ -105,8 +105,7 @@ RSpec.describe TagNameSanitisationRule, type: :model do
 
       it 'moves the tag to the existing tag_name' do
         described_class.apply!
-        expected_tag_name_id = existing.canonical_id || existing.id
-        expect(source_tag.reload.tag_name_id).to eq(expected_tag_name_id)
+        expect(source_tag.reload.tag_name_id).to eq(existing.id)
         expect(TagName.unscoped.exists?(source_tag_name_id)).to be(false)
       end
     end
@@ -114,7 +113,7 @@ 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
-        create(:tag_name, :alias, name: 'foobar', canonical: existing_tag.tag_name)
+        create(:tag_name, :alias, name: 'foobar', tag: existing_tag)
       end
       let!(:source) do
         create(:tag_name, name: 'tmp').tap do |tn|
@@ -122,11 +121,15 @@ RSpec.describe TagNameSanitisationRule, type: :model do
         end
       end
 
-      it 'deletes only the source and preserves the alias and its canonical tag' do
+      it 'deletes only the source and preserves the alias and its owning tag' do
         described_class.apply!
 
         expect(TagName.unscoped.exists?(source.id)).to be(false)
-        expect(alias_name.reload.canonical).to eq(existing_tag.tag_name)
+        expect(alias_name.reload).to have_attributes(
+            tag_id: existing_tag.id, language_code: 'ja', primary_flg: false)
+        expect(TagName.find_by!(tag_id: existing_tag.id,
+                                language_code: 'ja', primary_flg: true))
+            .to eq(existing_tag.tag_name)
         expect(Tag.find(existing_tag.id)).to eq(existing_tag)
       end
     end

backend/spec/models/tag_name_spec.rb

@@ -32,37 +32,58 @@ RSpec.describe TagName, type: :model do
 
     expect(tag.reload.tag_name.reload.tag_id).to eq(tag.id)
     expect(tag.tag_name.tag).to eq(tag)
+    expect(described_class.find_by!(tag_id: tag.id, language_code: 'ja', primary_flg: true))
+        .to eq(tag.tag_name)
   end
 
-  it 'accepts an alias owned by the canonical tag' do
+  it 'persists an alias owned by the same tag as its primary name' do
     tag = create(:tag)
-    alias_name = build(:tag_name, name: 'valid_alias', canonical: tag.tag_name,
-                                 tag:, primary_flg: false)
+    alias_name = create(:tag_name, :alias, name: 'valid_alias', tag:)
 
-    expect(alias_name).to have_attributes(
-        canonical_id: tag.tag_name_id, tag_id: tag.id,
+    expect(alias_name.reload).to have_attributes(
+        tag_id: tag.id,
         primary_flg: false, language_code: 'ja')
-    expect(alias_name).to be_valid
+    primary = described_class.find_by!(tag_id: alias_name.tag_id,
+                                       language_code: alias_name.language_code,
+                                       primary_flg: true)
+    expect(primary).to eq(tag.tag_name)
   end
 
   describe '.canonicalise' do
+    it 'resolves the primary name of the alias language on the same tag' do
+      tag = create(:tag, name: '日本語正本')
+      english_primary = create(:tag_name, tag:, name: 'english_primary',
+                                          language_code: 'en', script_code: 'Latn')
+      english_alias = create(:tag_name, :alias, tag:, name: 'english_alias',
+                                                 language_code: 'en', script_code: 'Latn')
+      representative_id = tag.tag_name_id
+
+      primary = described_class.find_by!(tag_id: english_alias.tag_id,
+                                         language_code: english_alias.language_code,
+                                         primary_flg: true)
+
+      expect(primary).to eq(english_primary)
+      expect(described_class.canonicalise(locale, [english_alias.name]))
+          .to eq([english_primary.name])
+      expect(tag.reload.tag_name_id).to eq(representative_id)
+    end
+
     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,
+                                                 tag: japanese)
+      english_alias = create(:tag_name, :alias, name: 'shared_alias',
+                                                tag: english,
                                                 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,
+          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,
+          tag_id: english.id,
           primary_flg: false, language_code: 'en')
       expect(described_class.canonicalise(locale, ['shared_alias']))
           .to eq(['english_canonical'])

backend/spec/models/tag_spec.rb

@@ -37,17 +37,16 @@ RSpec.describe Tag, type: :model do
                                       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,
+                                                 tag: japanese)
+      english_alias = create(:tag_name, :alias, name: 'shared_alias',
+                                                tag: english,
                                                 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,
+          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,
+          tag_id: english.id,
           primary_flg: false, language_code: 'en')
       expect(described_class.normalise_tags!(
           english_locale, ['shared_alias'],
@@ -270,12 +269,12 @@ RSpec.describe Tag, type: :model do
       expect(tag.category).to eq('character')
     end
 
-    it 'reuses the canonical tag for an alias without changing its category' do
+    it 'reuses the owning tag for an alias without changing its category' do
       tag = create(:tag, category: :character)
       representative_id = tag.tag_name_id
-      alias_name = create(:tag_name, :alias, name: 'lookup_alias', canonical: tag.tag_name)
+      alias_name = create(:tag_name, :alias, name: 'lookup_alias', tag:)
       expect(alias_name.reload).to have_attributes(
-          canonical_id: tag.tag_name_id, tag_id: tag.id,
+          tag_id: tag.id,
           primary_flg: false, language_code: 'ja')
       found = nil
 
@@ -289,14 +288,14 @@ RSpec.describe Tag, type: :model do
       expect(tag.reload.tag_name_id).to eq(representative_id)
     end
 
-    it 'reuses the canonical tag through another alias' do
+    it 'reuses the owning 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:)
+      primary = tag.tag_name
+      alias_name = create(:tag_name, :alias, name: 'lookup_alias', tag:)
+      other_alias = create(:tag_name, :alias, name: 'lookup_other_alias', tag:)
 
       expect([alias_name.reload, other_alias.reload]).to all(have_attributes(
-          canonical_id: canonical.id, tag_id: tag.id,
+          tag_id: tag.id,
           primary_flg: false, language_code: 'ja'))
 
       expect {
@@ -305,7 +304,7 @@ RSpec.describe Tag, type: :model do
         expect(found).to eq(tag)
       }.to change(Tag, :count).by(0).and change(TagName, :count).by(0)
 
-      expect(tag.tag_name).to eq(canonical)
+      expect(tag.reload.tag_name).to eq(primary)
     end
   end
 
@@ -329,7 +328,8 @@ RSpec.describe Tag, type: :model do
         expect(PostTag.exists?(post: post_record, tag: source_tag)).to be(false)
         expect(target_link).to be_present
         expect(Tag.unscoped.exists?(source_tag.id)).to be(false)
-        expect(source_tag_name.reload.canonical_id).to eq(target_tag.tag_name_id)
+        expect(source_tag_name.reload).to have_attributes(
+            tag_id: target_tag.id, language_code: 'ja', primary_flg: false)
         expect(target_tag.reload.post_count).to eq(1)
       end
     end
@@ -355,7 +355,8 @@ RSpec.describe Tag, type: :model do
         expect(target_post_tag.reload.sections).to contain_exactly(target_section)
 
         expect(Tag.unscoped.exists?(source_tag.id)).to be(false)
-        expect(source_tag_name.reload.canonical_id).to eq(target_tag.tag_name_id)
+        expect(source_tag_name.reload).to have_attributes(
+            tag_id: target_tag.id, language_code: 'ja', primary_flg: false)
         expect(target_tag.reload.post_count).to eq(1)
       end
     end
@@ -363,7 +364,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 = create(:tag_name, :alias, name: 'merge_alias', canonical: source_tag_name)
+      source_alias = create(:tag_name, :alias, name: 'merge_alias', tag: source_tag)
       TagVersioning.ensure_snapshot!(source_tag, created_by_user: user)
       original_version = source_tag.tag_versions.first
 
@@ -433,7 +434,8 @@ RSpec.describe Tag, type: :model do
         expect(Tag.unscoped.exists?(source_tag.id)).to be(false)
         expect(PostTag.exists?(post: post_record, tag: source_tag)).to be(false)
         expect(target_link).to be_present
-        expect(source_tag_name.reload.canonical_id).to eq(target_tag.tag_name_id)
+        expect(source_tag_name.reload).to have_attributes(
+            tag_id: target_tag.id, language_code: 'ja', primary_flg: false)
         expect(target_tag.reload.post_count).to eq(1)
       end
     end
@@ -464,7 +466,8 @@ RSpec.describe Tag, type: :model do
         expect(target_link).to be_present
 
         expect(Tag.unscoped.exists?(source_tag.id)).to be(false)
-        expect(source_tag_name.reload.canonical_id).to eq(target_tag.tag_name_id)
+        expect(source_tag_name.reload).to have_attributes(
+            tag_id: target_tag.id, language_code: 'ja', primary_flg: false)
         expect(target_tag.reload.post_count).to eq(1)
       end
     end
@@ -493,7 +496,8 @@ RSpec.describe Tag, type: :model do
         }.to raise_error(ActiveRecord::RecordInvalid)
 
         expect(Tag.unscoped.exists?(earlier_source.id)).to be(true)
-        expect(earlier_name.reload.canonical_id).to be_nil
+        expect(earlier_name.reload).to have_attributes(
+            tag_id: earlier_source.id, language_code: 'ja', primary_flg: true)
         expect(TagVersion.where(tag_id: [earlier_source.id, source_tag.id, target_tag.id]))
             .to be_empty
         expect(Tag.unscoped.exists?(source_tag.id)).to be(true)
@@ -502,7 +506,8 @@ RSpec.describe Tag, type: :model do
         expect(source_post_tag.sections).to contain_exactly(source_section)
         expect(PostTag.find_by(post: post_record, tag: target_tag)).to be_nil
         expect(source_tag.reload.post_count).to eq(1)
-        expect(source_tag_name.reload.canonical_id).to be_nil
+        expect(source_tag_name.reload).to have_attributes(
+            tag_id: source_tag.id, language_code: 'ja', primary_flg: true)
         expect(target_tag.reload.post_count).to eq(0)
       end
     end