invidious-mod/src/invidious/helpers/i18next.cr

# I18next-compatible implementation of plural forms
#
module I18next::Plurals
  # -----------------------------------
  #  I18next plural forms definition
  # -----------------------------------

  private enum PluralForms
    # One singular, one plural forms
    Single_gt_one  = 1 # E.g: French
    Single_not_one = 2 # E.g: English

    # No plural forms (E.g: Azerbaijani)
    None = 3

    # One singular, two plural forms
    Dual_Slavic = 4 # E.g: Russian

    # Special cases (rules used by only one or two language(s))
    Special_Arabic           =  5
    Special_Czech_Slovak     =  6
    Special_Polish_Kashubian =  7
    Special_Welsh            =  8
    Special_Irish            = 10
    Special_Scottish_Gaelic  = 11
    Special_Icelandic        = 12
    Special_Javanese         = 13
    Special_Cornish          = 14
    Special_Lithuanian       = 15
    Special_Latvian          = 16
    Special_Macedonian       = 17
    Special_Mandinka         = 18
    Special_Maltese          = 19
    Special_Romanian         = 20
    Special_Slovenian        = 21
    Special_Hebrew           = 22
  end

  private PLURAL_SETS = {
    PluralForms::Single_gt_one => [
      "ach", "ak", "am", "arn", "br", "fil", "fr", "gun", "ln", "mfe", "mg",
      "mi", "oc", "pt", "pt-BR", "tg", "tl", "ti", "tr", "uz", "wa",
    ],
    PluralForms::Single_not_one => [
      "af", "an", "ast", "az", "bg", "bn", "ca", "da", "de", "dev", "el", "en",
      "eo", "es", "et", "eu", "fi", "fo", "fur", "fy", "gl", "gu", "ha", "hi",
      "hu", "hy", "ia", "it", "kk", "kn", "ku", "lb", "mai", "ml", "mn", "mr",
      "nah", "nap", "nb", "ne", "nl", "nn", "no", "nso", "pa", "pap", "pms",
      "ps", "pt-PT", "rm", "sco", "se", "si", "so", "son", "sq", "sv", "sw",
      "ta", "te", "tk", "ur", "yo",
    ],
    PluralForms::None => [
      "ay", "bo", "cgg", "fa", "ht", "id", "ja", "jbo", "ka", "km", "ko", "ky",
      "lo", "ms", "sah", "su", "th", "tt", "ug", "vi", "wo", "zh",
    ],
    PluralForms::Dual_Slavic => [
      "be", "bs", "cnr", "dz", "hr", "ru", "sr", "uk",
    ],
  }

  private PLURAL_SINGLES = {
    "ar"  => PluralForms::Special_Arabic,
    "cs"  => PluralForms::Special_Czech_Slovak,
    "csb" => PluralForms::Special_Polish_Kashubian,
    "cy"  => PluralForms::Special_Welsh,
    "ga"  => PluralForms::Special_Irish,
    "gd"  => PluralForms::Special_Scottish_Gaelic,
    "he"  => PluralForms::Special_Hebrew,
    "is"  => PluralForms::Special_Icelandic,
    "iw"  => PluralForms::Special_Hebrew,
    "jv"  => PluralForms::Special_Javanese,
    "kw"  => PluralForms::Special_Cornish,
    "lt"  => PluralForms::Special_Lithuanian,
    "lv"  => PluralForms::Special_Latvian,
    "mk"  => PluralForms::Special_Macedonian,
    "mnk" => PluralForms::Special_Mandinka,
    "mt"  => PluralForms::Special_Maltese,
    "pl"  => PluralForms::Special_Polish_Kashubian,
    "ro"  => PluralForms::Special_Romanian,
    "sk"  => PluralForms::Special_Czech_Slovak,
    "sl"  => PluralForms::Special_Slovenian,
  }

  # The array indices matches the PluralForms enum above
  private NUMBERS = [
    [1, 2],                # 1
    [1, 2],                # 2
    [1],                   # 3
    [1, 2, 5],             # 4
    [0, 1, 2, 3, 11, 100], # 5
    [1, 2, 5],             # 6
    [1, 2, 5],             # 7
    [1, 2, 3, 8],          # 8
    [1, 2],                # 9 (not used)
    [1, 2, 3, 7, 11],      # 10
    [1, 2, 3, 20],         # 11
    [1, 2],                # 12
    [0, 1],                # 13
    [1, 2, 3, 4],          # 14
    [1, 2, 10],            # 15
    [1, 2, 0],             # 16
    [1, 2],                # 17
    [0, 1, 2],             # 18
    [1, 2, 11, 20],        # 19
    [1, 2, 20],            # 20
    [5, 1, 2, 3],          # 21
    [1, 2, 20, 21],        # 22
  ]

  # "or" ()
  private NUMBERS_OR = [2, 1]

  # -----------------------------------
  #  I18next plural resolver class
  # -----------------------------------

  class Resolver
    @@forms : Hash(String, PluralForms) = init_rules()
    @@version : UInt8 = 3

    # Options
    property simplify_plural_suffix : Bool = true

    # Suffixes
    SUFFIXES_V1 = {
      "",
      "_plural_1",
      "_plural_2",
      "_plural_3",
      "_plural_11",
      "_plural_100",
    }
    SUFFIXES_V2 = {"_0", "_1", "_2", "_3", "_11", "_100"}
    SUFFIXES_V3 = {"_0", "_1", "_2", "_3", "_4", "_5"}

    def initialize(version : UInt8 = 3)
      # Sanity checks
      # V4 isn't supported, as it requires a full CLDR database.
      if version > 4 || version == 0
        raise "Invalid i18next version: v#{version}."
      elsif version == 4
        # Logger.error("Unsupported i18next version: v4. Falling back to v3")
        @@version = 3
      else
        @@version = version
      end
    end

    def self.init_rules
      # Look into sets
      PLURAL_SETS.each do |form, langs|
        langs.each { |lang| @@forms[lang] = form }
      end

      # Add plurals from the "singles" set
      @@forms.merge!(PLURAL_SINGLES)
    end

    def get_plural_form(locale : String) : PluralForms
      # Extract the ISO 639-1 or 639-2 code from an RFC 5646
      # language code, except for pt-BR which needs to be kept as-is.
      if locale.starts_with?("pt-BR")
        locale = "pt-BR"
      else
        locale = locale.split('-')[0]
      end

      return @@forms[locale] if @@forms[locale]?

      # If nothing was found, then use the most common form, i.e
      # one singular and one plural, as in english. Not perfect,
      # but better than yielding an exception at the user.
      return PluralForms::Single_not_one
    end

    def get_suffix(locale : String, count : Int) : String
      # Checked count must be absolute. In i18next, `rule.noAbs` is used to
      # determine if comparison should be done on a signed or unsigned integer,
      # but this variable is never set, resulting in the comparison always
      # being done on absolute numbers.
      return get_suffix_retrocompat(locale, count.abs)
    end

    def get_suffix_retrocompat(locale : String, count : Int) : String
      # Get plural form
      plural_form = get_plural_form(locale)
      rule_numbers = (locale == "or") ? NUMBERS_OR : NUMBERS[plural_form.to_i]

      # Languages with no plural have no suffix
      return "" if plural_form.none?

      # Get the index and suffix for this number
      # idx = Todo
      suffix = rule_numbers[idx]

      # Simple plurals are handled differently in all versions (but v4)
      if @simplify_plural_suffix && rule_numbers.size == 2 && rule_numbers[0] == 1
        return "_plural" if (suffix == 2)
        return "" if (suffix == 1)
      end

      # More complex plurals
      # TODO: support `options.prepend` for v2 and v3
      # this.options.prepend && suffix.toString() ? this.options.prepend + suffix.toString() : suffix.toString()
      case @version
      when 1 then return SUFFIXES_V1[idx]
      when 2 then return SUFFIXES_V2[idx]
      else        return SUFFIXES_V3[idx]
      end
    end
  end
end