russian 0.6.0 → 1.0.0

data/lib/russian/locale/datetime.yml

@@ -1,39 +1,102 @@
 ru:
   date:
     formats:
-      # Форматы указываются в виде, поддерживаемом strftime.
-      # По умолчанию используется default.
-      # Можно добавлять собственные форматы
-      #
-      #
       # Use the strftime parameters for formats.
       # When no format has been given, it uses default.
       # You can provide other formats here if you like!
+      #
+      #
+      # Форматы указываются в виде, поддерживаемом strftime.
+      # По умолчанию используется default.
+      # Можно добавлять собственные форматы.
       default: "%d.%m.%Y"
       short: "%d %b"
       long: "%d %B %Y"
-    
-    # Названия дней недели -- контекстные и отдельностоящие
-    common_day_names: [воскресенье, понедельник, вторник, среда, четверг, пятница, суббота]
-    standalone_day_names: [Воскресенье, Понедельник, Вторник, Среда, Четверг, Пятница, Суббота]
+
+    # Названия дней недели — контекстные и отдельностоящие
+    common_day_names:
+      [воскресенье, понедельник, вторник, среда, четверг, пятница, суббота]
+    standalone_day_names:
+      [Воскресенье, Понедельник, Вторник, Среда, Четверг, Пятница, Суббота]
     common_abbr_day_names: [Вс, Пн, Вт, Ср, Чт, Пт, Сб]
     standalone_abbr_day_names: [вс, пн, вт, ср, чт, пт, сб]
 
-    # Названия месяцев -- сокращенные и полные, плюс отдельностоящие.
-    # Не забудьте nil в начале массиве (~)
-    # 
-    #
-    # Don't forget the nil at the beginning; there's no such thing as a 0th month
-    common_month_names: [~, января, февраля, марта, апреля, мая, июня, июля, августа, сентября, октября, ноября, декабря]
-    standalone_month_names: [~, Январь, Февраль, Март, Апрель, Май, Июнь, Июль, Август, Сентябрь, Октябрь, Ноябрь, Декабрь]
-    common_abbr_month_names: [~, янв., февр., марта, апр., мая, июня, июля, авг., сент., окт., нояб., дек.]
-    standalone_abbr_month_names: [~, янв., февр., март, апр., май, июнь, июль, авг., сент., окт., нояб., дек.]
-    
-    # Порядок компонентов даты для хелперов
+    # Don't forget the nil at the beginning; there's no such
+    # thing as a 0th month.
     #
     #
+    # Названия месяцев — сокращенные и полные, плюс отдельностоящие.
+    # Не забудьте nil в начале массива (~)
+    common_month_names:
+      [
+        ~,
+        января,
+        февраля,
+        марта,
+        апреля,
+        мая,
+        июня,
+        июля,
+        августа,
+        сентября,
+        октября,
+        ноября,
+        декабря,
+      ]
+    standalone_month_names:
+      [
+        ~,
+        Январь,
+        Февраль,
+        Март,
+        Апрель,
+        Май,
+        Июнь,
+        Июль,
+        Август,
+        Сентябрь,
+        Октябрь,
+        Ноябрь,
+        Декабрь,
+      ]
+    common_abbr_month_names:
+      [
+        ~,
+        янв.,
+        февр.,
+        марта,
+        апр.,
+        мая,
+        июня,
+        июля,
+        авг.,
+        сент.,
+        окт.,
+        нояб.,
+        дек.,
+      ]
+    standalone_abbr_month_names:
+      [
+        ~,
+        янв.,
+        февр.,
+        март,
+        апр.,
+        май,
+        июнь,
+        июль,
+        авг.,
+        сент.,
+        окт.,
+        нояб.,
+        дек.,
+      ]
+
     # Used in date_select and datime_select.
-    order: 
+    #
+    #
+    # Порядок компонентов даты для хелперов
+    order:
       - :day
       - :month
       - :year
@@ -44,7 +107,7 @@ ru:
       default: "%a, %d %b %Y, %H:%M:%S %z"
       short: "%d %b, %H:%M"
       long: "%d %B %Y, %H:%M"
-    
+
     # am/pm решено перевести как "утра/вечера" :)
     am: "утра"
     pm: "вечера"

data/lib/russian/locale/pluralization.rb

@@ -1,28 +1,49 @@
-# -*- encoding: utf-8 -*- 
+# frozen_string_literal: true
 
-# Правило плюрализации для русского языка, взято из CLDR, http://unicode.org/cldr/
+# Russian language pluralization rules, taken from CLDR project,
+# http://unicode.org/cldr/
 #
-# Russian language pluralization rules, taken from CLDR project, http://unicode.org/cldr/
+#
+# Правило плюрализации для русского языка, взято из CLDR,
+# http://unicode.org/cldr/
 #
 #   one -> n mod 10 is 1 and n mod 100 is not 11;
 #   few -> n mod 10 in 2..4 and n mod 100 not in 12..14;
 #   many -> n mod 10 is 0 or n mod 10 in 5..9 or n mod 100 in 11..14;
 #   other -> everything else
 #
-# Пример
+# Example:
 #
 #   :one  = 1, 21, 31, 41, 51, 61...
 #   :few  = 2-4, 22-24, 32-34...
 #   :many = 0, 5-20, 25-30, 35-40...
 #   :other = 1.31, 2.31, 5.31...
+from_2_to_4 = (2..4).to_a.freeze
+from_5_to_9 = (5..9).to_a.freeze
+from_11_to_14 = (11..14).to_a.freeze
+from_12_to_14 = (12..14).to_a.freeze
+
 {
-  :ru => {
-    :'i18n' => {
-      :plural => {
-        :rule => lambda { |n| 
-          n % 10 == 1 && n % 100 != 11 ? :one : [2, 3, 4].include?(n % 10) && ![12, 13, 14].include?(n % 100) ? :few : n % 10 == 0 || [5, 6, 7, 8, 9].include?(n % 10) || [11, 12, 13, 14].include?(n % 100) ? :many : :other 
-        }
+  ru: {
+    i18n: {
+      plural: {
+        rule: lambda do |n|
+          return :other unless n.is_a?(Numeric)
+
+          mod10 = n % 10
+          mod100 = n % 100
+
+          if mod10 == 1 && mod100 != 11
+            :one
+          elsif from_2_to_4.include?(mod10) && !from_12_to_14.include?(mod100)
+            :few
+          elsif mod10.zero? || from_5_to_9.include?(mod10) || from_11_to_14.include?(mod100)
+            :many
+          else
+            :other
+          end
+        end
       }
     }
   }
-}
+}

data/lib/russian/locale/transliterator.rb

@@ -1,16 +1,17 @@
-# -*- encoding: utf-8 -*- 
+# frozen_string_literal: true
 
-# I18n transliteration delegates to Russian::Transliteration (we're unable
-# to use common I18n transliteration tables with Russian)
+# I18n transliteration delegates to `Russian::Transliteration` (we're unable
+# to use common I18n transliteration tables with Russian).
 #
-# Правило транслитерации для I18n использует Russian::Transliteration
+#
+# Правило транслитерации для I18n использует `Russian::Transliteration`
 # (использовать обычный механизм и таблицу транслитерации I18n с
-# русским языком не получится)
+# русским языком не получится).
 {
-  :ru => {
-    :i18n => {
-      :transliterate => {
-        :rule => lambda { |str| Russian.transliterate(str) }
+  ru: {
+    i18n: {
+      transliterate: {
+        rule: ->(str) { Russian.transliterate(str) }
       }
     }
   }

data/lib/russian/russian_rails.rb

@@ -1,8 +1,99 @@
-# Rails hacks
-if defined?(ActiveModel)
-  require 'active_model_ext/custom_error_message'
-end
+# frozen_string_literal: true
+
+require_relative "active_model_ext/custom_error_message"
+require_relative "action_view_ext/helpers/date_helper"
+
+module Russian
+  # Installs Rails-specific patches exposed by the gem.
+  #
+  # The integration is lazy: outside Rails it does nothing, and inside Rails it
+  # wires itself through `ActiveSupport.on_load` hooks and also patches
+  # framework components that are already loaded.
+  #
+  #
+  # Устанавливает Rails-специфичные патчи, поставляемые gem'ом.
+  #
+  # Интеграция сделана "ленивой": вне Rails она ничего не делает,
+  # а внутри Rails подключается через `ActiveSupport.on_load` и
+  # дополнительно патчит уже загруженные части фреймворка.
+  #
+  # @example
+  #   require "russian"
+  #   Russian::RailsIntegration.install!
+  module RailsIntegration
+    module_function
+
+    # Installs Rails hooks and applies patches to already loaded components.
+    #
+    # The method is idempotent and safe to call more than once.
+    #
+    #
+    # Устанавливает Rails-хуки и применяет патчи к уже загруженным компонентам.
+    #
+    # Метод идемпотентен и безопасен для повторных вызовов.
+    #
+    # @return [void]
+    #
+    # @example
+    #   Russian::RailsIntegration.install!
+    def install!
+      return unless rails?
+
+      define_railtie!
+      install_hooks!
+
+      patch_active_model! if defined?(ActiveModel::Error)
+      patch_action_view! if defined?(ActionView::Helpers::DateTimeSelector)
+    end
+
+    # @private
+    def install_hooks!
+      return if @hooks_installed
+
+      %i[active_model active_model_error].each { |hook| on_load(hook, :patch_active_model!) }
+      on_load(:action_view, :patch_action_view!)
 
-if defined?(ActionView::Helpers)
-  require 'action_view_ext/helpers/date_helper' 
+      @hooks_installed = true
+    end
+
+    # @private
+    def on_load(hook, patcher)
+      ActiveSupport.on_load(hook) { Russian::RailsIntegration.public_send(patcher) }
+    end
+
+    # @private
+    def patch_active_model!
+      patch!(ActiveModel::Error.singleton_class, Russian::ActiveModelExt::ErrorPatch)
+    end
+
+    # @private
+    def patch_action_view!
+      patch!(ActionView::Helpers::DateHelper, Russian::ActionViewExt::Helpers::DateHelperPatch)
+      patch!(ActionView::Helpers::DateTimeSelector, Russian::ActionViewExt::Helpers::DateTimeSelectorPatch)
+    end
+
+    # @private
+    def patch!(target, extension)
+      target.prepend(extension) unless target < extension
+    end
+
+    # @private
+    def rails?
+      defined?(Rails::Railtie) && defined?(ActiveSupport) && ActiveSupport.respond_to?(:on_load)
+    end
+
+    # @private
+    def define_railtie!
+      return unless defined?(Rails::Railtie)
+      return if defined?(Russian::Railtie)
+
+      Russian.const_set(:Railtie, Class.new(Rails::Railtie) do
+        initializer "russian.install" do
+          Russian::RailsIntegration.install!
+        end
+      end)
+    end
+  end
 end
+
+Russian::RailsIntegration.install!

data/lib/russian/strptime.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require "date"
+require "time"
+
+module Russian
+  # Localized `strptime` helpers for Russian month and weekday names.
+  #
+  # The module normalizes Russian textual date/time tokens to the English
+  # tokens expected by Ruby's native parsers, then delegates to
+  # `Date.strptime`, `Time.strptime`, or `DateTime.strptime`.
+  #
+  #
+  # Локализованные хелперы `strptime` для русских названий месяцев и дней
+  # недели.
+  #
+  # Модуль нормализует русские текстовые токены даты и времени к английским
+  # токенам, которые ожидают стандартные parser'ы Ruby, а затем делегирует
+  # работу в `Date.strptime`, `Time.strptime` или `DateTime.strptime`.
+  module Strptime
+    module_function
+
+    # Parses a localized Russian date string with `Date.strptime`.
+    #
+    #
+    # Разбирает локализованную русскую строку даты через `Date.strptime`.
+    #
+    # @param string [String] Localized date string.
+    #   Локализованная строка даты.
+    # @param format [String] Optional `strptime` format string.
+    #   Строка формата `strptime`.
+    # @return [Date] Parsed date.
+    #   Разобранная дата.
+    def date_strptime(string, format = "%F")
+      Date.strptime(normalize_input(string, format), format, Date::ITALY)
+    end
+
+    # Parses a localized Russian date/time string with `Time.strptime`.
+    #
+    #
+    # Разбирает локализованную русскую строку даты и времени через
+    # `Time.strptime`.
+    #
+    # @param string [String] Localized date/time string.
+    #   Локализованная строка даты и времени.
+    # @param format [String] `strptime` format string.
+    #   Строка формата `strptime`.
+    # @param now [Time] Optional base time passed to `Time.strptime`.
+    #   Базовое значение времени, передаваемое в `Time.strptime`.
+    # @return [Time] Parsed time.
+    #   Разобранное время.
+    def time_strptime(string, format, now = Time.now)
+      Time.strptime(normalize_input(string, format), format, now)
+    end
+
+    # Parses a localized Russian date/time string with `DateTime.strptime`.
+    #
+    #
+    # Разбирает локализованную русскую строку даты и времени через
+    # `DateTime.strptime`.
+    #
+    # @param string [String] Localized date/time string.
+    #   Локализованная строка даты и времени.
+    # @param format [String] Optional `strptime` format string.
+    #   Строка формата `strptime`.
+    # @return [DateTime] Parsed datetime.
+    #   Разобранный `DateTime`.
+    def datetime_strptime(string, format = "%FT%T%z")
+      DateTime.strptime(normalize_input(string, format), format, Date::ITALY)
+    end
+
+    # @private
+    def normalize_input(string, format)
+      return string unless string.is_a?(String) && format.is_a?(String)
+
+      replacements = localized_replacements(format)
+      return string if replacements.empty?
+
+      token_regexp = Regexp.new(
+        "(?<!\\p{L})(?:#{replacements.keys.sort_by(&:length).reverse.map do |token|
+          Regexp.escape(token)
+        end.join("|")})(?!\\p{L})",
+        Regexp::IGNORECASE
+      )
+
+      string.gsub(token_regexp) { |token| replacements.fetch(token.downcase) }
+    end
+
+    # @private
+    def localized_replacements(format)
+      directives = directives_in(format)
+      replacements = {}
+
+      replacements.merge!(localized_tokens(month_names_key(format), Date::MONTHNAMES)) if directives.include?("B")
+
+      if directives.include?("b")
+        replacements.merge!(localized_tokens(abbr_month_names_key(format), Date::ABBR_MONTHNAMES))
+      end
+
+      replacements.merge!(localized_tokens(day_names_key(format), Date::DAYNAMES)) if directives.include?("A")
+
+      replacements.merge!(localized_tokens(abbr_day_names_key(format), Date::ABBR_DAYNAMES)) if directives.include?("a")
+
+      replacements
+    end
+
+    # @private
+    def localized_tokens(key, english_names)
+      localized_names = I18n.t(key, locale: Russian::LOCALE).compact
+      english_names = english_names.compact
+
+      localized_names.zip(english_names).each_with_object({}) do |(localized_name, english_name), replacements|
+        replacements[localized_name.downcase] = english_name
+      end
+    end
+
+    # @private
+    def directives_in(format)
+      directives = []
+      index = 0
+
+      while index < format.length
+        if format[index] != "%"
+          index += 1
+          next
+        end
+
+        if format[index + 1] == "%"
+          index += 2
+          next
+        end
+
+        index += 1
+        index += 1 while index < format.length && Russian::STRPTIME_DIRECTIVE_MODIFIERS.include?(format[index])
+        index += 1 while index < format.length && format[index].match?(/\d/)
+
+        index += 1 if index < format.length && %w[E O].include?(format[index])
+
+        directives << format[index] if index < format.length
+        index += 1
+      end
+
+      directives
+    end
+
+    # @private
+    def month_names_key(format)
+      Russian::LOCALIZE_MONTH_NAMES_MATCH.match?(format) ? :"date.common_month_names" : :"date.standalone_month_names"
+    end
+
+    # @private
+    def abbr_month_names_key(format)
+      Russian::LOCALIZE_ABBR_MONTH_NAMES_MATCH.match?(format) ? :"date.common_abbr_month_names" : :"date.standalone_abbr_month_names"
+    end
+
+    # @private
+    def day_names_key(format)
+      Russian::LOCALIZE_STANDALONE_DAY_NAMES_MATCH.match?(format) ? :"date.standalone_day_names" : :"date.common_day_names"
+    end
+
+    # @private
+    def abbr_day_names_key(format)
+      Russian::LOCALIZE_STANDALONE_ABBR_DAY_NAMES_MATCH.match?(format) ? :"date.common_abbr_day_names" : :"date.standalone_abbr_day_names"
+    end
+  end
+end

data/lib/russian/transliteration.rb

@@ -1,72 +1,106 @@
-# -*- encoding: utf-8 -*- 
+# frozen_string_literal: true
 
 module Russian
-  # Russian transliteration 
+  # Russian transliteration tables and helpers.
   #
-  # Транслитерация для букв русского алфавита
+  # Transliteration is heavily based on the
+  # [rutils](https://github.com/julik/rutils) gem by
+  # Julian "julik" Tarkhanov and contributors, then cleaned up and
+  # adapted for this gem.
+  #
+  #
+  # Таблицы и хелперы для русской транслитерации.
+  #
+  # Транслитерация во многом основана на gem
+  # [rutils](https://github.com/julik/rutils) Юлика Тарханова и
+  # соавторов, а затем упрощена и адаптирована для этого gem'а.
+  #
+  # @example
+  #   Russian::Transliteration.transliterate("Юлия")
+  #   # => "Yuliya"
+  #
+  #   Russian::Transliteration.transliterate("Н.П. Шерстяков")
+  #   # => "N.P. Sherstyakov"
   module Transliteration
-    extend self
-
-    # Transliteration heavily based on rutils gem by Julian "julik" Tarkhanov and Co.
-    # <http://rutils.rubyforge.org/>
-    # Cleaned up and optimized.
+    module_function
 
+    # @private
     LOWER_SINGLE = {
-      "і"=>"i","ґ"=>"g","ё"=>"yo","№"=>"#","є"=>"e",
-      "ї"=>"yi","а"=>"a","б"=>"b",
-      "в"=>"v","г"=>"g","д"=>"d","е"=>"e","ж"=>"zh",
-      "з"=>"z","и"=>"i","й"=>"y","к"=>"k","л"=>"l",
-      "м"=>"m","н"=>"n","о"=>"o","п"=>"p","р"=>"r",
-      "с"=>"s","т"=>"t","у"=>"u","ф"=>"f","х"=>"h",
-      "ц"=>"ts","ч"=>"ch","ш"=>"sh","щ"=>"sch","ъ"=>"'",
-      "ы"=>"y","ь"=>"","э"=>"e","ю"=>"yu","я"=>"ya",
-    }
+      "і" => "i", "ґ" => "g", "ё" => "yo", "№" => "#", "є" => "e",
+      "ї" => "yi", "а" => "a", "б" => "b",
+      "в" => "v", "г" => "g", "д" => "d", "е" => "e", "ж" => "zh",
+      "з" => "z", "и" => "i", "й" => "y", "к" => "k", "л" => "l",
+      "м" => "m", "н" => "n", "о" => "o", "п" => "p", "р" => "r",
+      "с" => "s", "т" => "t", "у" => "u", "ф" => "f", "х" => "h",
+      "ц" => "ts", "ч" => "ch", "ш" => "sh", "щ" => "sch", "ъ" => "'",
+      "ы" => "y", "ь" => "", "э" => "e", "ю" => "yu", "я" => "ya"
+    }.freeze
+    # @private
     LOWER_MULTI = {
-      "ье"=>"ie",
-      "ьё"=>"ie",
-    }
+      "ье" => "ie",
+      "ьё" => "ie"
+    }.freeze
 
+    # @private
     UPPER_SINGLE = {
-      "Ґ"=>"G","Ё"=>"YO","Є"=>"E","Ї"=>"YI","І"=>"I",
-      "А"=>"A","Б"=>"B","В"=>"V","Г"=>"G",
-      "Д"=>"D","Е"=>"E","Ж"=>"ZH","З"=>"Z","И"=>"I",
-      "Й"=>"Y","К"=>"K","Л"=>"L","М"=>"M","Н"=>"N",
-      "О"=>"O","П"=>"P","Р"=>"R","С"=>"S","Т"=>"T",
-      "У"=>"U","Ф"=>"F","Х"=>"H","Ц"=>"TS","Ч"=>"CH",
-      "Ш"=>"SH","Щ"=>"SCH","Ъ"=>"'","Ы"=>"Y","Ь"=>"",
-      "Э"=>"E","Ю"=>"YU","Я"=>"YA",
-    }
+      "Ґ" => "G", "Ё" => "YO", "Є" => "E", "Ї" => "YI", "І" => "I",
+      "А" => "A", "Б" => "B", "В" => "V", "Г" => "G",
+      "Д" => "D", "Е" => "E", "Ж" => "ZH", "З" => "Z", "И" => "I",
+      "Й" => "Y", "К" => "K", "Л" => "L", "М" => "M", "Н" => "N",
+      "О" => "O", "П" => "P", "Р" => "R", "С" => "S", "Т" => "T",
+      "У" => "U", "Ф" => "F", "Х" => "H", "Ц" => "TS", "Ч" => "CH",
+      "Ш" => "SH", "Щ" => "SCH", "Ъ" => "'", "Ы" => "Y", "Ь" => "",
+      "Э" => "E", "Ю" => "YU", "Я" => "YA"
+    }.freeze
+    # @private
     UPPER_MULTI = {
-      "ЬЕ"=>"IE",
-      "ЬЁ"=>"IE",
-    }
+      "ЬЕ" => "IE",
+      "ЬЁ" => "IE"
+    }.freeze
 
-    LOWER = (LOWER_SINGLE.merge(LOWER_MULTI)).freeze
-    UPPER = (UPPER_SINGLE.merge(UPPER_MULTI)).freeze
-    MULTI_KEYS = (LOWER_MULTI.merge(UPPER_MULTI)).keys.sort_by {|s| s.length}.reverse.freeze
+    # @private
+    LOWER = LOWER_SINGLE.merge(LOWER_MULTI).freeze
+    # @private
+    UPPER = UPPER_SINGLE.merge(UPPER_MULTI).freeze
+    # @private
+    TITLE = UPPER.transform_values(&:capitalize).freeze
+    # @private
+    MULTI_KEYS = LOWER_MULTI.merge(UPPER_MULTI).keys.sort_by(&:length).reverse.freeze
+    # @private
+    TOKEN_RE = /#{Regexp.union(MULTI_KEYS).source}|./m
 
-    # Transliterate a string with russian characters
+    # Transliterates a string containing Cyrillic characters.
+    #
+    # The method preserves non-Cyrillic characters and follows the historical
+    # casing rules of the gem.
+    #
+    #
+    # Транслитерирует строку, содержащую кириллические символы.
+    #
+    # Метод сохраняет некириллические символы и следует историческим правилам
+    # gem'а для регистра.
+    #
+    # @param str [String] String to transliterate.
+    #   Строка для транслитерации.
+    # @return [String] Transliteration result.
+    #   Результат транслитерации.
     #
-    # Возвращает строку, в которой все буквы русского алфавита заменены на похожую по звучанию латиницу
+    # @example
+    #   Russian::Transliteration.transliterate("Привет, мир!")
+    #   # => "Privet, mir!"
     def transliterate(str)
-      chars = str.scan(%r{#{MULTI_KEYS.join '|'}|\w|.})
+      tokens = str.scan(TOKEN_RE)
 
-      result = ""
+      tokens.each_with_index.map do |token, index|
+        lower = LOWER[token]
+        next lower if lower
 
-      chars.each_with_index do |char, index|
-        if UPPER.has_key?(char) && LOWER.has_key?(chars[index+1])
-          # combined case
-          result << UPPER[char].downcase.capitalize
-        elsif UPPER.has_key?(char)
-          result << UPPER[char]
-        elsif LOWER.has_key?(char)
-          result << LOWER[char]
-        else
-          result << char
-        end
-      end
+        upper = UPPER[token]
+        next TITLE[token] if upper && LOWER[tokens[index + 1]]
+        next upper if upper
 
-      result
+        token
+      end.join
     end
   end
-end
+end