#55

backend/spec/requests/locale_write_paths_spec.rb

@@ -202,17 +202,19 @@ RSpec.describe 'Locale propagation on write paths', type: :request do
       expect(response).to have_http_status(:ok), response.body
       expect(TagName.find_by!(language_code: 'en', name: 'english_alias'))
           .to have_attributes(
-              script_code: 'Latn', canonical_id: english_name.id,
+              script_code: 'Latn',
               tag_id: tag.id, primary_flg: false, language_code: 'en')
       expect(tag.reload.tag_name_id).to eq(english_name.id)
+      primary = TagName.find_by!(tag_id: tag.id, language_code: 'en', primary_flg: true)
+      expect(primary).to have_attributes(name: 'english_original', script_code: 'Latn')
     end
 
     it 'does not take an alias from another language' do
       japanese = create(:tag, name: 'japanese_owner')
       japanese_alias = create(:tag_name, :alias, name: 'shared_alias',
-                                                canonical: japanese.tag_name)
+                                                tag: japanese)
       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')
 
       put "/tags/#{ tag.id }", params: {
@@ -221,12 +223,14 @@ RSpec.describe 'Locale propagation on write paths', type: :request do
 
       expect(response).to have_http_status(:ok), response.body
       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(TagName.find_by!(language_code: 'en', name: 'shared_alias'))
           .to have_attributes(
-              canonical_id: english_name.id, tag_id: tag.id,
+              tag_id: tag.id, script_code: 'Latn',
               primary_flg: false, language_code: 'en')
+      expect(TagName.where(name: 'shared_alias').pluck(:language_code, :tag_id))
+          .to contain_exactly(['ja', japanese.id], ['en', tag.id])
     end
   end
 end

backend/spec/requests/posts_spec.rb

@@ -129,7 +129,7 @@ RSpec.describe 'Posts API', type: :request do
     let!(:tag) { create(:tag, tag_name:, category: :general) }
     let!(:tag_name2) { create(:tag_name, name: 'unko') }
     let!(:tag2) { create(:tag, tag_name: tag_name2, category: :deerjikist) }
-    let!(:alias_tag_name) { create(:tag_name, :alias, name: 'manko', canonical: tag_name) }
+    let!(:alias_tag_name) { create(:tag_name, :alias, name: 'manko', tag:) }
 
     let!(:hit_post) do
       Post.create!(uploaded_user: user, title: 'hello spec world',
@@ -351,7 +351,7 @@ RSpec.describe 'Posts API', type: :request do
       let!(:baz_tag) { create(:tag, tag_name: baz_tag_name, category: :general) }
 
       let!(:foo_alias_tag_name) do
-        create(:tag_name, :alias, name: 'not_spec_foo_alias', canonical: foo_tag_name)
+        create(:tag_name, :alias, name: 'not_spec_foo_alias', tag: foo_tag)
       end
 
       let!(:foo_only_post) do
@@ -854,7 +854,7 @@ RSpec.describe 'Posts API', type: :request do
             15.times.map do |i|
               tag_name = create(:tag_name, name: "show_query_tag_#{ i }")
               tag = create(:tag, tag_name:, category: :general)
-              create(:tag_name, :alias, name: "show_query_alias_#{ i }", canonical: tag_name)
+              create(:tag_name, :alias, name: "show_query_alias_#{ i }", tag:)
               PostTag.create!(post: post_record, tag:)
               tag
             end
@@ -999,7 +999,7 @@ RSpec.describe 'Posts API', type: :request do
 
   describe 'POST /posts' do
     let(:member) { create(:user, :member) }
-    let!(:alias_tag_name) { create(:tag_name, :alias, name: 'manko', canonical: tag_name) }
+    let!(:alias_tag_name) { create(:tag_name, :alias, name: 'manko', tag:) }
 
     it '401 when not logged in' do
       sign_out

backend/spec/requests/tags_spec.rb

@@ -4,7 +4,7 @@ require 'rails_helper'
 RSpec.describe 'Tags API', type: :request do
   let!(:tn) { create(:tag_name, name: 'spec_tag') }
   let!(:tag) { create(:tag, tag_name: tn, category: :general) }
-  let!(:alias_tn) { create(:tag_name, :alias, name: 'unko', canonical: tn) }
+  let!(:alias_tn) { create(:tag_name, :alias, name: 'unko', tag:) }
   let!(:post) { Post.create!(url: 'https://example.com/unkounkounko') }
   let!(:post_tag) { PostTag.create!(post:, tag:) }
   let!(:tn2) { create(:tag_name, name: 'unknown') }
@@ -466,7 +466,7 @@ RSpec.describe 'Tags API', type: :request do
     it 'excludes external tags but preserves internal alias matches when nico is false' do
       internal = create(:tag, category: :general, name: 'switch_internal', post_count: 1)
       alias_target = create(:tag, category: :general, name: 'alias_target', post_count: 1)
-      create(:tag_name, :alias, name: 'switch_alias', canonical: alias_target.tag_name)
+      create(:tag_name, :alias, name: 'switch_alias', tag: alias_target)
       create(:external_tag, name: 'switch_external', post_count: 1)
 
       get '/tags/autocomplete', params: { q: 'switch', nico: '0' }
@@ -479,13 +479,13 @@ RSpec.describe 'Tags API', type: :request do
     end
 
     ['%', '_'].each do |wildcard|
-      it "treats #{ wildcard } literally for canonical, alias, and external names" do
+      it "treats #{ wildcard } literally for primary, alias, and external names" do
         literal = "literal#{ wildcard }match"
         create(:tag, category: :general, name: literal, post_count: 1)
         alias_target = create(
             :tag, category: :general, name: 'literal_alias_target', post_count: 1)
         create(:tag_name, :alias, name: "#{ literal }_alias",
-                                  canonical: alias_target.tag_name)
+                                  tag: alias_target)
         create(:external_tag, name: literal, post_count: 1)
         create(:tag, category: :general, name: 'literalXmatch', post_count: 2)
         create(:external_tag, name: 'literalXmatch', post_count: 2)
@@ -509,7 +509,7 @@ RSpec.describe 'Tags API', type: :request do
       expect(t['matched_alias']).to be(nil)
     end
 
-    it 'returns matching canonical tags by q with aliases' do
+    it 'returns matching primary tag names by q with aliases' do
       get '/tags/autocomplete', params: { q: 'unk' }
 
       expect(response).to have_http_status(:ok)
@@ -772,7 +772,8 @@ RSpec.describe 'Tags API', type: :request do
         }
 
         expect(response).to have_http_status(:ok)
-        expect(TagName.find_by!(name: 'spec_tag').canonical).to eq(tag.reload.tag_name)
+        expect(TagName.find_by!(language_code: 'ja', name: 'spec_tag'))
+            .to have_attributes(tag_id: tag.id, primary_flg: false)
 
         patch "/tags/#{ tag.id }", params: { name: 'spec_tag' }
 
@@ -781,8 +782,10 @@ RSpec.describe 'Tags API', type: :request do
         tag.reload
 
         expect(tag.name).to eq('spec_tag')
-        expect(tag.tag_name.canonical_id).to be_nil
-        expect(TagName.find_by!(name: 'patch_roundtrip_target').canonical).to eq(tag.tag_name)
+        expect(tag.tag_name).to have_attributes(
+            tag_id: tag.id, language_code: 'ja', primary_flg: true)
+        expect(TagName.find_by!(language_code: 'ja', name: 'patch_roundtrip_target'))
+            .to have_attributes(tag_id: tag.id, primary_flg: false)
       end
 
       it '別 tag の正規名には変更できない' do
@@ -801,7 +804,8 @@ RSpec.describe 'Tags API', type: :request do
         )
 
         expect(tag.reload.name).to eq('spec_tag')
-        expect(tag.tag_name.aliases.map(&:name)).to contain_exactly('unko')
+        expect(TagName.where(tag_id: tag.id, language_code: 'ja', primary_flg: false).pluck(:name))
+            .to contain_exactly('unko')
         expect(wiki_page.reload.tag_name).to eq(tag.tag_name)
       end
 
@@ -1170,14 +1174,17 @@ RSpec.describe 'Tags API', type: :request do
         expect(tag.name).to eq('put_renamed_tag')
         expect(tag.category).to eq('meme')
 
-        expect(TagName.find_by(name: 'put_alias_a').canonical).to eq(tag.tag_name)
-        expect(TagName.find_by(name: 'put_alias_b').canonical).to eq(tag.tag_name)
+        expect(TagName.find_by!(language_code: 'ja', name: 'put_alias_a'))
+            .to have_attributes(tag_id: tag.id, primary_flg: false)
+        expect(TagName.find_by!(language_code: 'ja', name: 'put_alias_b'))
+            .to have_attributes(tag_id: tag.id, primary_flg: false)
 
         old_name_alias = TagName.find_by(name: 'spec_tag')
         expect(old_name_alias).to be_present
-        expect(old_name_alias.canonical).to eq(tag.tag_name)
+        expect(old_name_alias).to have_attributes(
+            tag_id: tag.id, language_code: 'ja', primary_flg: false)
 
-        expect(alias_tn.reload.canonical).to be_nil
+        expect(alias_tn.reload.tag_id).to be_nil
 
         expect(tag.parents.map(&:name)).to contain_exactly(
           'put_kept_parent',
@@ -1212,7 +1219,8 @@ RSpec.describe 'Tags API', type: :request do
 
         tag.reload
 
-        expect(TagName.find_by(name: 'put_alias_self_test').canonical).to eq(tag.tag_name)
+        expect(TagName.find_by!(language_code: 'ja', name: 'put_alias_self_test'))
+            .to have_attributes(tag_id: tag.id, primary_flg: false)
         expect(json['aliases']).to include('put_alias_self_test')
         expect(json['aliases']).not_to include('spec_tag')
       end
@@ -1283,10 +1291,14 @@ RSpec.describe 'Tags API', type: :request do
         tag.reload
 
         expect(tag.name).to eq('spec_tag')
-        expect(TagName.find_by!(name: 'put_roundtrip_b').canonical).to eq(tag.tag_name)
-        expect(tag.tag_name.aliases.map(&:name)).to contain_exactly('put_roundtrip_b', 'unko')
-        expect(tag.tag_name.aliases.map(&:name)).not_to include('spec_tag')
-        expect(alias_tn.reload.canonical).to eq(tag.tag_name)
+        expect(TagName.find_by!(language_code: 'ja', name: 'put_roundtrip_b'))
+            .to have_attributes(tag_id: tag.id, primary_flg: false)
+        expect(TagName.where(tag_id: tag.id, language_code: 'ja', primary_flg: false).pluck(:name))
+            .to contain_exactly('put_roundtrip_b', 'unko')
+        expect(TagName.where(tag_id: tag.id, language_code: 'ja', primary_flg: false).pluck(:name))
+            .not_to include('spec_tag')
+        expect(alias_tn.reload).to have_attributes(
+            tag_id: tag.id, language_code: 'ja', primary_flg: false)
 
         version = tag.tag_versions.order(:version_no).last
 
@@ -1395,7 +1407,7 @@ RSpec.describe 'Tags API', type: :request do
         )
       end
 
-      it 'wiki を持つ tag を旧 alias へ戻しても wiki を新 canonical へ移す' do
+      it 'wiki を持つ tag を旧 alias へ戻しても wiki を新しい正本名へ移す' do
         wiki_page =
             Wiki::Commit.create_content!(
                 tag_name: tag.tag_name,
@@ -1429,7 +1441,8 @@ RSpec.describe 'Tags API', type: :request do
 
         expect(wiki_page.reload.tag_name).to eq(tag.tag_name)
         expect(TagName.find_by!(name: 'put_wiki_roundtrip_b').wiki_page).to be_nil
-        expect(TagName.find_by!(name: 'put_wiki_roundtrip_b').canonical).to eq(tag.tag_name)
+        expect(TagName.find_by!(language_code: 'ja', name: 'put_wiki_roundtrip_b'))
+            .to have_attributes(tag_id: tag.id, primary_flg: false)
 
         versions = wiki_page.wiki_versions.order(:version_no).last(2)
 
@@ -1443,9 +1456,11 @@ RSpec.describe 'Tags API', type: :request do
             category: :general)
         stolen_alias = create(:tag_name, :alias,
             name: 'put_stolen_alias',
-            canonical: old_owner.tag_name)
+            tag: old_owner)
 
-        expect(old_owner.tag_name.aliases.map(&:name)).to include('put_stolen_alias')
+        expect(TagName.where(tag_id: old_owner.id, language_code: 'ja',
+                              primary_flg: false).pluck(:name))
+            .to include('put_stolen_alias')
 
         expect {
           put "/tags/#{ tag.id }", params: {
@@ -1461,8 +1476,11 @@ RSpec.describe 'Tags API', type: :request do
 
         expect(response).to have_http_status(:ok)
 
-        expect(stolen_alias.reload.canonical).to eq(tag.tag_name)
-        expect(old_owner.reload.tag_name.aliases.map(&:name)).not_to include('put_stolen_alias')
+        expect(stolen_alias.reload).to have_attributes(
+            tag_id: tag.id, language_code: 'ja', primary_flg: false)
+        expect(TagName.where(tag_id: old_owner.id, language_code: 'ja',
+                              primary_flg: false).pluck(:name))
+            .not_to include('put_stolen_alias')
 
         old_owner_versions = old_owner.tag_versions.order(:version_no)
 
@@ -1479,7 +1497,7 @@ RSpec.describe 'Tags API', type: :request do
             category: :general)
         stolen_alias = create(:tag_name, :alias,
             name: 'put_alias_collision_name',
-            canonical: old_owner.tag_name)
+            tag: old_owner)
         wiki_page =
             Wiki::Commit.create_content!(
                 tag_name: tag.tag_name,
@@ -1502,9 +1520,13 @@ RSpec.describe 'Tags API', type: :request do
         stolen_alias.reload
 
         expect(tag.name).to eq('put_alias_collision_name')
-        expect(stolen_alias.canonical_id).to be_nil
-        expect(TagName.find_by!(name: 'spec_tag').canonical).to eq(tag.tag_name)
-        expect(old_owner.tag_name.aliases.map(&:name)).not_to include('put_alias_collision_name')
+        expect(stolen_alias).to have_attributes(
+            tag_id: tag.id, language_code: 'ja', primary_flg: true)
+        expect(TagName.find_by!(language_code: 'ja', name: 'spec_tag'))
+            .to have_attributes(tag_id: tag.id, primary_flg: false)
+        expect(TagName.where(tag_id: old_owner.id, language_code: 'ja',
+                              primary_flg: false).pluck(:name))
+            .not_to include('put_alias_collision_name')
 
         old_owner_versions = old_owner.tag_versions.order(:version_no)