#428

backend/app/controllers/tag_versions_controller.rb

@@ -35,8 +35,18 @@ class TagVersionsController < ApplicationController
   private
 
   def serialise_versions rows, language_code
+    rows = rows.to_a
     user_ids = rows.map(&:created_by_user_id).compact.uniq
     users_by_id = User.where(id: user_ids).pluck(:id, :name).to_h
+    parent_ids = rows.flat_map do |row|
+      split_parent_tag_ids(row.parent_tag_ids) +
+          split_parent_tag_ids(row.attributes['prev_parent_tag_ids'])
+    end.uniq
+    parents_by_id = Tag.includes(
+        :tag_names, :materials, :deerjikists, :tag_descriptions,
+        parents: [:tag_names, :materials, :deerjikists, :tag_descriptions])
+        .where(id: parent_ids).index_by(&:id)
+    parent_json = parents_by_id.transform_values { TagRepr.base(_1, language_code:) }
 
     rows.map do |row|
       current_names = names_for_locale(row.names, language_code)
@@ -47,18 +57,10 @@ class TagVersionsController < ApplicationController
       cur_parent_tag_ids = split_parent_tag_ids(row.parent_tag_ids)
       prev_parent_tag_ids = split_parent_tag_ids(row.attributes['prev_parent_tag_ids'])
 
-      all_parent_tag_ids = (cur_parent_tag_ids | prev_parent_tag_ids)
-
-      tags_by_id =
-          Tag
-          .includes(:tag_names, :materials, :tag_descriptions, parents: :tag_descriptions)
-          .where(id: all_parent_tag_ids)
-          .index_by(&:id)
-
       parent_tags =
           build_version_values(cur_parent_tag_ids, prev_parent_tag_ids, key: :tag_id)
           .map do |h|
-            { tag: TagRepr.base(tags_by_id[h[:tag_id]], language_code:),
+            { tag: parent_json.fetch(h[:tag_id]),
               type: h[:type] }
           end
 
@@ -66,6 +68,7 @@ class TagVersionsController < ApplicationController
         version_no: row.version_no,
         event_type: row.event_type,
         names: row.names,
+        name_changes: name_changes(row.names, row.attributes['prev_names']),
         name: { current: current_names['name'], prev: previous_names['name'] },
         category: { current: row.category, prev: row.attributes['prev_category'] },
         deprecated_at: { current: row.deprecated_at&.iso8601,
@@ -97,11 +100,44 @@ class TagVersionsController < ApplicationController
   def split_values(values) = values.to_s.split(/\s+/).reject(&:blank?)
 
   def names_for_locale names, language_code
+    values = snapshot_names(names)[language_code]
+    values.is_a?(Hash) ? values : {}
+  end
+
+  def snapshot_names names
     values = names.is_a?(String) ? JSON.parse(names) : names
-    values&.fetch(language_code, {}) || {}
+    values.is_a?(Hash) ? values : {}
   rescue JSON::ParserError
     {}
   end
 
+  def name_changes current_names, previous_names
+    current = snapshot_names(current_names)
+    previous = snapshot_names(previous_names)
+    (current.keys | previous.keys).sort.filter_map do |language|
+      current_name = language_snapshot(current[language])
+      previous_name = language_snapshot(previous[language])
+      next if current_name == previous_name
+
+      { language_code: language, current: current_name, prev: previous_name }
+    end
+  end
+
+  def language_snapshot entry
+    return nil unless entry.is_a?(Hash)
+
+    aliases = Array(entry['aliases']).filter_map do |value|
+      value = { 'name' => value } if value.is_a?(String)
+      next unless value.is_a?(Hash) && value['name'].is_a?(String)
+
+      { name: value['name'], script_code: value['script_code'] }
+    end
+    aliases = aliases.uniq.sort_by { [_1[:name], _1[:script_code].to_s] }
+    { name: entry['name'],
+      script_code: entry['script_code'],
+      auto_generated: entry['auto_generated'],
+      aliases: }
+  end
+
   def split_parent_tag_ids(values) = split_values(values).map(&:to_i)
 end

backend/app/controllers/wiki_pages_controller.rb

@@ -37,27 +37,18 @@ class WikiPagesController < ApplicationController
   def autolink_candidates
     locale = resolve_locale!
     language = params.fetch(:language, locale.language_code)
+    language = 'ja' if language == 'und'
     return head :not_found unless language.is_a?(String)
-    target_locale =
-        if language == 'und'
-          locale
-        else
-          Locale.where(language_code: language, deprecated_at: nil,
-                       code: Locale.codes.values).order(:code).first
-        end
-    return head :not_found unless target_locale
+    return head :not_found unless Language.exists?(code: language)
 
-    candidates = []
-    unless language == 'und'
-      names = TagDescription.joins(tag: :tag_names)
-          .where(language_code: language, tag_names: { language_code: language })
-          .pluck('tag_descriptions.tag_id', 'tag_descriptions.id', 'tag_names.name')
-      candidates = names.map do |tag_id, description_id, name|
-        WikiPageRepr.autolink_tag(target_locale, tag_id:, description_id:, name:)
-      end
+    names = TagDescription.joins(tag: :tag_names)
+        .where(language_code: locale.language_code, tag_names: { language_code: language })
+        .pluck('tag_descriptions.tag_id', 'tag_descriptions.id', 'tag_names.name')
+    candidates = names.map do |tag_id, description_id, name|
+      WikiPageRepr.autolink_tag(locale, tag_id:, description_id:, name:, language:)
     end
     candidates.concat(TagGroup.order(:id).pluck(:id, :name).map do |id, name|
-      WikiPageRepr.autolink_group(target_locale, id:, name:, language:)
+      WikiPageRepr.autolink_group(locale, id:, name:, language:)
     end)
     render json: candidates
   end