#428

backend/app/controllers/post_versions_controller.rb

@@ -80,6 +80,7 @@ class PostVersionsController < ApplicationController
                           prev: row.attributes['prev_thumbnail_base'] },
         video_ms: { current: row.video_ms, prev: row.attributes['prev_video_ms'] },
         tags: build_version_tags(cur_tags, prev_tags),
+        parent_post_ids: row.parent_post_ids,
         original_created_from: {
             current: row.original_created_from&.iso8601,
             prev: row.attributes['prev_original_created_from']&.iso8601 },
@@ -121,10 +122,14 @@ class PostVersionsController < ApplicationController
             name = tag_names[snapshot['tag_id']] || snapshot.fetch('name')
             [tag_category_order(snapshot['category']),
              { identity: [:tag, snapshot['tag_id'], sections],
-               name: Post.tag_snapshot_literal(snapshot.merge('name' => name)) }]
+               name: Post.tag_snapshot_literal(snapshot.merge('name' => name)),
+               restore_name: tag_names[snapshot['tag_id']] &&
+                   Post.tag_snapshot_literal(snapshot.merge('name' => name)),
+               external: false }]
           elsif external_tag_names[snapshot['external_tag_id']]
             [6, { identity: [:external_tag, snapshot['external_tag_id']],
-                  name: external_tag_names[snapshot['external_tag_id']] }]
+                  name: external_tag_names[snapshot['external_tag_id']],
+                  restore_name: nil, external: true }]
           end
         }
         .sort_by { |order, tag| [order, tag[:name].downcase] }
@@ -136,8 +141,8 @@ class PostVersionsController < ApplicationController
   end
 
   def build_version_tags cur_tags, prev_tags
-    current = cur_tags.to_h { [_1[:identity], _1[:name]] }
-    previous = prev_tags.to_h { [_1[:identity], _1[:name]] }
+    current = cur_tags.index_by { _1[:identity] }
+    previous = prev_tags.index_by { _1[:identity] }
 
     (current.keys | previous.keys).map do |identity|
       type =
@@ -149,7 +154,9 @@ class PostVersionsController < ApplicationController
             'removed'
           end
 
-      { name: current[identity] || previous[identity], type: }
+      entry = current[identity] || previous[identity]
+      { name: entry[:name], restore_name: entry[:restore_name],
+        external: entry[:external], type: }
     end
   end
 end

backend/app/models/tag_name.rb

@@ -35,10 +35,17 @@ class TagName < ApplicationRecord
 
   def self.generate_name locale, tag, base_tag_name
     fallback = "Tag_##{ tag.id }"
-    return fallback unless locale.language_code == 'ain' && base_tag_name&.language_code == 'ja'
-
-    name = TagNameTranscription.ainu(base_tag_name.name)
-    candidate = new(tag:, name:, language_code: 'ain', script_code: 'Kana',
+    name =
+        case [locale.language_code, base_tag_name&.language_code]
+        when ['ain', 'ja']
+          TagNameTranscription.ainu(base_tag_name.name)
+        when ['ja', 'ain']
+          base_tag_name.name
+        else
+          return fallback
+        end
+    candidate = new(tag:, name:, language_code: locale.language_code,
+                    script_code: locale.script_code,
                     primary_flg: true, auto_generated: true)
     candidate.valid? ? name : fallback
   rescue TagNameTranscription::Unconvertible

backend/app/services/tag_name_completion.rb

@@ -16,7 +16,8 @@ class TagNameCompletion
         locales.to_a.uniq(&:language_code).each do |locale|
           next if primary_names.key?(locale.language_code)
 
-          name = TagName.generate_name(locale, tag, primary_names['ja'])
+          source_language = locale.language_code == 'ja' ? 'ain' : 'ja'
+          name = TagName.generate_name(locale, tag, primary_names[source_language])
           primary_names[locale.language_code] = create_name!(locale, tag, name)
         end
         tag.association(:tag_names).reset
@@ -29,10 +30,10 @@ class TagNameCompletion
       persist_name!(locale, tag, name)
     rescue ActiveRecord::RecordNotUnique, ActiveRecord::RecordInvalid => error
       fallback = "Tag_##{ tag.id }"
-      collision =
+      invalid_name =
           error.is_a?(ActiveRecord::RecordNotUnique) ||
-          error.record.errors.of_kind?(:name, :taken)
-      raise if name == fallback || !(collision)
+          error.record.errors[:name].present?
+      raise if name == fallback || !(invalid_name)
 
       persist_name!(locale, tag, fallback)
     end