#428

backend/app/services/tag_name_completion.rb

@@ -0,0 +1,43 @@
+class TagNameCompletion
+  def self.for_locale! locale
+    named_tags = TagName.where(language_code: locale.language_code, primary_flg: true)
+                       .select(:tag_id)
+    Tag.where.not(id: named_tags).find_each do |tag|
+      for_tag!(tag, locales: [locale])
+    end
+  end
+
+  def self.for_tag! tag, locales: nil
+    locales ||= Locale.where(deprecated_at: nil).order(:language_code, :created_at, :script_code)
+    tag.with_lock do
+      primary_names = tag.tag_names.where(primary_flg: true).index_by(&:language_code)
+      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'])
+        primary_names[locale.language_code] = create_name!(locale, tag, name)
+      end
+      tag.association(:tag_names).reset
+    end
+  end
+
+  def self.create_name! locale, tag, name
+    persist_name!(locale, tag, name)
+  rescue ActiveRecord::RecordNotUnique, ActiveRecord::RecordInvalid => error
+    fallback = "Tag_##{ tag.id }"
+    collision = error.is_a?(ActiveRecord::RecordNotUnique) ||
+        error.record.errors.of_kind?(:name, :taken)
+    raise unless name != fallback && collision
+
+    persist_name!(locale, tag, fallback)
+  end
+  private_class_method :create_name!
+
+  def self.persist_name! locale, tag, name
+    TagName.transaction(requires_new: true) do
+      TagName.create!(tag:, name:, language_code: locale.language_code,
+                      script_code: locale.script_code, primary_flg: true, auto_generated: true)
+    end
+  end
+  private_class_method :persist_name!
+end

backend/app/services/tag_name_transcription.rb

@@ -0,0 +1,23 @@
+module TagNameTranscription
+  class Unconvertible < StandardError
+    ;
+  end
+
+  def self.ainu name
+    previous_script = nil
+    JapaneseSegments.split(name).map { |script, text|
+      boundary = previous_script && script != previous_script &&
+          JapaneseSegments.japanese?(previous_script) && JapaneseSegments.japanese?(script)
+      previous_script = script
+      reading = script == :kanji ? JisReadings.read(text) : text
+      output =
+          if script == :literal
+            text
+          else
+            Katakana.render(Phonology.adapt(reading))
+          end
+
+      boundary ? "_#{ output }" : output
+    }.join
+  end
+end

backend/app/services/tag_name_transcription/japanese_segments.rb

@@ -0,0 +1,30 @@
+module TagNameTranscription
+  module JapaneseSegments
+    JAPANESE_SCRIPTS = [:kanji, :hiragana, :katakana].freeze
+
+    def self.japanese?(script) = JAPANESE_SCRIPTS.include?(script)
+
+    def self.split name
+      segments = []
+      name.to_s.scan(/\X/).each do |character|
+        script = classify(character, segments.last&.first)
+        if segments.last&.first == script
+          segments.last[1] << character
+        else
+          segments << [script, character.dup]
+        end
+      end
+      segments
+    end
+
+    def self.classify character, previous_script
+      return previous_script if character == 'ー' && japanese?(previous_script)
+      return :kanji if character.match?(/\A\p{Han}\z/)
+      return :hiragana if character.match?(/\A\p{Hiragana}\p{M}*\z/)
+      return :katakana if character.match?(/\A\p{Katakana}\p{M}*\z/)
+      return :literal if character.match?(/\A(?:\p{Latin}\p{M}*|[!-~])\z/)
+
+      raise Unconvertible
+    end
+  end
+end

backend/app/services/tag_name_transcription/jis_readings.rb

@@ -0,0 +1,13 @@
+module TagNameTranscription
+  module JisReadings
+    SOURCE = Rails.root.join('config/tag_name_readings/jis_level_one.tsv')
+    READINGS = File.foreach(SOURCE, chomp: true).reject { _1.start_with?('#') }.to_h { |line|
+      character, reading, = line.split("\t")
+      [character, reading]
+    }.freeze
+
+    def self.read text
+      text.each_char.map { READINGS.fetch(_1) { raise Unconvertible } }.join
+    end
+  end
+end

backend/app/services/tag_name_transcription/katakana.rb

@@ -0,0 +1,24 @@
+module TagNameTranscription
+  module Katakana
+    ROWS = {
+        '' => 'アイウエオ',
+        'k' => 'カキクケコ',
+        's' => 'サシスセソ',
+        'c' => ['チャ', 'チ', 'チュ', 'チェ', 'チョ'],
+        't' => ['タ', 'ティ', 'トゥ', 'テ', 'ト'],
+        'n' => 'ナニヌネノ',
+        'h' => 'ハヒフヘホ',
+        'p' => 'パピプペポ',
+        'm' => 'マミムメモ',
+        'r' => 'ラリルレロ' }.freeze
+    SYLLABLES = ROWS.flat_map { |onset, letters|
+      kana = letters.is_a?(String) ? letters.chars : letters
+      ['a', 'i', 'u', 'e', 'o'].zip(kana).map { |vowel, letter| [onset + vowel, letter] }
+    }.to_h.merge(
+        'ya' => 'ヤ', 'yu' => 'ユ', 'yo' => 'ヨ', 'wa' => 'ワ',
+        'k' => 'ㇰ', 's' => 'ㇱ', 't' => 'ッ', 'n' => 'ン', 'm' => 'ㇺ', 'p' => 'ㇷ゚',
+        'r:a' => 'ㇻ', 'r:i' => 'ㇼ', 'r:u' => 'ㇽ', 'r:e' => 'ㇾ', 'r:o' => 'ㇿ').freeze
+
+    def self.render(sounds) = sounds.map { SYLLABLES.fetch(_1) }.join
+  end
+end

backend/app/services/tag_name_transcription/phonology.rb

@@ -0,0 +1,36 @@
+module TagNameTranscription
+  module Phonology
+    ROWS = {
+        'アイウエオ' => ['a', 'i', 'u', 'e', 'o'],
+        'カキクケコ' => ['ka', 'ki', 'ku', 'ke', 'ko'],
+        'ガギグゲゴ' => ['ka', 'ki', 'ku', 'ke', 'ko'],
+        'サシスセソ' => ['sa', 'si', 'su', 'se', 'so'],
+        'ザジズゼゾ' => ['ca', 'ci', 'cu', 'ce', 'co'],
+        'タチツテト' => ['ta', 'ci', 'cu', 'te', 'to'],
+        'ダヂヅデド' => ['ta', 'ci', 'cu', 'te', 'to'],
+        'ナニヌネノ' => ['na', 'ni', 'nu', 'ne', 'no'],
+        'ハヒフヘホ' => ['ha', 'hi', 'hu', 'he', 'ho'],
+        'バビブベボ' => ['pa', 'pi', 'pu', 'pe', 'po'],
+        'パピプペポ' => ['pa', 'pi', 'pu', 'pe', 'po'],
+        'マミムメモ' => ['ma', 'mi', 'mu', 'me', 'mo'],
+        'ヤユヨ' => ['ya', 'yu', 'yo'],
+        'ラリルレロ' => ['ra', 'ri', 'ru', 're', 'ro'],
+        'ワ' => ['wa'],
+        'ン' => ['n'],
+        'ッ' => ['t'],
+        'ㇰ' => ['k'],
+        'ㇱㇲ' => ['s', 's'],
+        'ㇳ' => ['t'],
+        'ㇴ' => ['n'],
+        'ㇺ' => ['m'],
+        'ㇻㇼㇽㇾㇿ' => ['r:a', 'r:i', 'r:u', 'r:e', 'r:o'] }.freeze
+    SOUNDS = ROWS.flat_map { |characters, sounds| characters.chars.zip(sounds) }.to_h.freeze
+
+    def self.adapt reading
+      kana = reading.unicode_normalize(:nfc).tr('ぁ-ゖ', 'ァ-ヶ').tr('ャュョ', 'ヤユヨ')
+      kana.delete('ー').scan(/\X/).map { |character|
+        character == 'ㇷ゚' ? 'p' : SOUNDS.fetch(character) { raise Unconvertible }
+      }
+    end
+  end
+end