num2words 0.1.5 → 0.2.0

data/config/locales/ru.yml

@@ -13,13 +13,6 @@ ru:
       - ["миллиард", "миллиарда", "миллиардов"]
       - ["триллион", "триллиона", "триллионов"]
 
-    currencies:
-      RUB:
-        name: ["рубль", "рубля", "рублей"]
-        fractional:
-          name: ["копейка", "копейки", "копеек"]
-          feminine: true
-
     grammar:
       minus: "минус"
       conjunction: "целых"
@@ -55,6 +48,10 @@ ru:
                       "десятого", "одиннадцатого", "двенадцатого", "тринадцатого", "четырнадцатого", "пятнадцатого", "шестнадцатого", "семнадцатого", "восемнадцатого", "девятнадцатого",
                       "двадцатого", "двадцать первого", "двадцать второго", "двадцать третьего", "двадцать четвёртого", "двадцать пятого", "двадцать шестого", "двадцать седьмого", "двадцать восьмого", "двадцать девятого",
                       "тридцатого", "тридцать первого"]
+          neuter: ["первое", "второе", "третье", "четвёртое", "пятое", "шестое", "седьмое", "восьмое", "девятое",
+                   "десятое", "одиннадцатое", "двенадцатое", "тринадцатое", "четырнадцатое", "пятнадцатое", "шестнадцатое", "семнадцатое", "восемнадцатое", "девятнадцатое",
+                   "двадцатое", "двадцать первое", "двадцать второе", "двадцать третье", "двадцать четвёртое", "двадцать пятое", "двадцать шестое", "двадцать седьмое", "двадцать восьмое", "двадцать девятое",
+                   "тридцатое", "тридцать первое"]
 
     datetime:
       template: "%{date}, %{time}"
@@ -63,8 +60,8 @@ ru:
         default: "%{day} %{month} %{year} года"
         nominative: "%{day} %{month} %{year} год"
       months:
-        default: [ "января", "февраля", "марта", "апреля", "мая", "июня", "июля", "августа", "сентября", "октября", "ноября", "декабря" ]
-        nominative: [ "января", "февраля", "марта", "апреля", "мая", "июня", "июля", "августа", "сентября", "октября", "ноября", "декабря" ]
+        default: ["января", "февраля", "марта", "апреля", "мая", "июня", "июля", "августа", "сентября", "октября", "ноября", "декабря"]
+        nominative: ["января", "февраля", "марта", "апреля", "мая", "июня", "июля", "августа", "сентября", "октября", "ноября", "декабря"]
     time:
       template:
         hours_only: "%{hours}"
@@ -74,3 +71,132 @@ ru:
         hour: ["час", "часа", "часов"]
         minute: ["минута", "минуты", "минут"]
         second: ["секунда", "секунды", "секунд"]
+
+    warnings:
+      currency_not_available: "Валюта %{currency} недоступна для локали %{lang}, используется текущая."
+
+    currencies:
+      RUB:
+        major_unit: ["рубль", "рубля", "рублей"]
+        minor_unit: ["копейка", "копейки", "копеек"]
+        symbol: "₽"
+      USD:
+        major_unit: ["доллар", "доллара", "долларов"]
+        minor_unit: ["цент", "цента", "центов"]
+        symbol: "$"
+      EUR:
+        major_unit: ["евро", "евро", "евро"]
+        minor_unit: ["цент", "цента", "центов"]
+        symbol: "€"
+      GBP:
+        major_unit: ["фунт", "фунта", "фунтов"]
+        minor_unit: ["пенс", "пенса", "пенсов"]
+        symbol: "£"
+      CNY:
+        major_unit: ["юань", "юаня", "юаней"]
+        minor_unit: ["фэнь", "фэня", "фэней"]
+        symbol: "¥"
+      JPY:
+        major_unit: ["иена", "иены", "иен"]
+        minor_unit: ["сэн", "сэн", "сэн"]
+        symbol: "¥"
+      KRW:
+        major_unit: ["вона", "воны", "вон"]
+        minor_unit: ["чон", "чона", "чон"]
+        symbol: "₩"
+      TRY:
+        major_unit: ["лира", "лиры", "лир"]
+        minor_unit: ["куруш", "куруша", "курушей"]
+        symbol: "₺"
+      PLN:
+        major_unit: ["злотый", "злотых", "злотых"]
+        minor_unit: ["грош", "гроша", "грошей"]
+        symbol: "zł"
+      UAH:
+        major_unit: ["гривна", "гривны", "гривен"]
+        minor_unit: ["копейка", "копейки", "копеек"]
+        symbol: "₴"
+      CZK:
+        major_unit: ["крона", "кроны", "крон"]
+        minor_unit: ["галирж", "галиржа", "галиржей"]
+        symbol: "Kč"
+      RON:
+        major_unit: ["лей", "лея", "леев"]
+        minor_unit: ["бан", "бана", "банов"]
+        symbol: "lei"
+      BGN:
+        major_unit: ["лев", "лева", "левов"]
+        minor_unit: ["стотинка", "стотинки", "стотинок"]
+        symbol: "лв"
+      BYN:
+        major_unit: ["белорусский рубль", "белорусских рубля", "белорусских рублей"]
+        minor_unit: ["копейка", "копейки", "копеек"]
+        symbol: "Br"
+      KZT:
+        major_unit: ["тенге", "тенге", "тенге"]
+        minor_unit: ["тиын", "тиына", "тиынов"]
+        symbol: "₸"
+      ILS:
+        major_unit: ["шекель", "шекеля", "шекелей"]
+        minor_unit: ["агора", "агоры", "агорот"]
+        symbol: "₪"
+      SEK:
+        major_unit: ["крона", "кроны", "крон"]
+        minor_unit: ["эре", "эре", "эре"]
+        symbol: "kr"
+      NOK:
+        major_unit: ["крона", "кроны", "крон"]
+        minor_unit: ["эре", "эре", "эре"]
+        symbol: "kr"
+      DKK:
+        major_unit: ["крона", "кроны", "крон"]
+        minor_unit: ["эре", "эре", "эре"]
+        symbol: "kr"
+      HUF:
+        major_unit: ["форинт", "форинта", "форинтов"]
+        minor_unit: ["филлер", "филлера", "филлеров"]
+        symbol: "Ft"
+      SAR:
+        major_unit: ["риал", "риала", "риалов"]
+        minor_unit: ["халяла", "халялы", "халялов"]
+        symbol: "﷼"
+      INR:
+        major_unit: ["рупия", "рупии", "рупий"]
+        minor_unit: ["пайса", "пайсы", "пайс"]
+        symbol: "₹"
+      THB:
+        major_unit: ["бат", "бата", "батов"]
+        minor_unit: ["сатанг", "сатанга", "сатангов"]
+        symbol: "฿"
+      VND:
+        major_unit: ["донг", "донга", "донгов"]
+        minor_unit: ["су", "су", "су"]
+        symbol: "₫"
+      IDR:
+        major_unit: ["рупия", "рупии", "рупий"]
+        minor_unit: ["сена", "сены", "сенов"]
+        symbol: "Rp"
+      IRR:
+        major_unit: ["риал", "риала", "риалов"]
+        minor_unit: ["динам", "динама", "динамов"]
+        symbol: "﷼"
+      RSD:
+        major_unit: ["динар", "динара", "динаров"]
+        minor_unit: ["пара", "пары", "пар"]
+        symbol: "дин"
+      MYR:
+        major_unit: ["ринггит", "ринггита", "ринггитов"]
+        minor_unit: ["сен", "сена", "сенов"]
+        symbol: "RM"
+      BDT:
+        major_unit: ["така", "таки", "так"]
+        minor_unit: ["пойша", "пойши", "пойш"]
+        symbol: "৳"
+      PKR:
+        major_unit: ["рупия", "рупии", "рупий"]
+        minor_unit: ["пайса", "пайсы", "пайс"]
+        symbol: "₨"
+      KES:
+        major_unit: ["шиллинг", "шиллинга", "шиллингов"]
+        minor_unit: ["цент", "цента", "центов"]
+        symbol: "Sh"

data/exe/num2words-console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "num2words"
+require "num2words/console"
+
+Num2words::Console.start

data/lib/num2words/config.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Num2words
+  class Config
+    attr_accessor :currency_warnings
+
+    def initialize
+      reset!
+    end
+
+    def default_currency(locale = nil, currency = nil)
+      if currency
+        currency = currency.to_s.upcase.to_sym
+        available = available_currencies(locale)
+
+        if available.include?(currency)
+          locale ? @local_currency[locale] = currency : @global_currency = currency
+        elsif currency_warnings
+          warn I18n.t("num2words.warnings.currency_not_available", lang: locale, currency: currency, locale: locale)
+        end
+      end
+
+      locale ? (@local_currency[locale] || available_currencies(locale).first || @global_currency) : @global_currency
+    end
+
+    def available_currencies(locale = I18n.locale)
+      I18n.t("num2words.currencies", locale: locale).keys.map(&:to_sym)
+    end
+
+    def reset!(locale = nil)
+      return @local_currency.delete(locale) if locale
+
+      @global_currency   = available_currencies.first
+      @local_currency    = {}
+      @currency_warnings = true
+    end
+  end
+
+  def self.config
+    @config ||= Config.new
+  end
+
+  def self.reset!
+    config.reset!(locale)
+  end
+
+  def self.default_currency(locale = nil, currency = nil)
+    config.default_currency(locale, currency)
+  end
+
+  def self.available_currencies(locale = I18n.locale)
+    config.available_currencies(locale)
+  end
+
+  def self.currency_warnings
+    config.currency_warnings
+  end
+
+  def self.currency_warnings=(value)
+    config.currency_warnings = value
+  end
+end

data/lib/num2words/console.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Num2words
+  module Console
+    module_function
+
+    def start
+      puts "Добро пожаловать в консоль num2words!"
+      puts "Можете использовать: Num2words.to_words(#{Time.now.year})"
+      puts "-------------------------------------------------------------"
+
+      require "irb"
+      IRB.start(__FILE__)
+    end
+  end
+end

data/lib/num2words/converter.rb

@@ -2,27 +2,33 @@
 
 require "date"
 require "time"
+require "bigdecimal"
 
 module Num2words
   class Converter
     class << self
       def to_words(number, *args, **opts)
-        locale      = args[0].is_a?(Symbol) ? args[0] : opts[:locale] || I18n.default_locale
-        type_only   = args[1].is_a?(Symbol) ? args[1] : opts[:only]
-        type_short  = args[2].is_a?(TrueClass) || args[2].is_a?(FalseClass) ? args[2] : opts[:short] || false
+        locale = args[0].is_a?(Symbol) ? args[0] : opts[:locale] || I18n.default_locale
+        type_only = args[1].is_a?(Symbol) ? args[1] : opts[:only]
+        type_short = args[2].is_a?(TrueClass) || args[2].is_a?(FalseClass) ? args[2] : opts[:short] || false
 
-        feminine    = opts[:feminine] || false
-        style       = opts[:style] || :fraction
-        word_case   = opts[:word_case] || :default
+        feminine = opts[:feminine] || false
+        style = opts[:style] || :fraction
+        word_case = opts[:word_case] || :default
         date_format = opts[:format] || :default
+        date_case = opts[:date_case] || :default
+        joiner = opts[:joiner] || :default
+
+        validate_option!(:date_case, date_case, %i[default genitive])
+        validate_option!(:joiner, joiner, %i[default and])
 
         locale_data = Locales[locale]
 
         result = case detect_type(number)
-                 when :float then to_words_fractional(number, locale, feminine, locale_data, style: style)
+                 when :float then to_words_fractional(number, locale, feminine, locale_data, style: style, joiner: joiner)
                  when :integer then to_words_integer(number, locale, feminine, locale_data)
-                 when :datetime then to_words_datetime(number, locale, locale_data, format: date_format, only: type_only, short: type_short)
-                 when :date then to_words_date(number, locale, locale_data, format: date_format)
+                 when :datetime then to_words_datetime(number, locale, locale_data, format: date_format, only: type_only, short: type_short, date_case: date_case)
+                 when :date then to_words_date(number, locale, locale_data, format: date_format, date_case: date_case)
                  when :time then to_words_time(number, locale, locale_data, short: type_short)
                  else nil
                  end
@@ -33,26 +39,60 @@ module Num2words
       end
 
       def to_currency(amount, *args, **opts)
-        locale      = args.first.is_a?(Symbol) ? args.first : opts[:locale] || I18n.default_locale
-        word_case   = opts[:word_case] || :downcase
-        locale_data = Locales[locale]
+        locale = args.first.is_a?(Symbol) ? args.first : opts[:locale] || I18n.default_locale
+        word_case = opts[:word_case] || :downcase
+        currency = (opts[:code] || Num2words.default_currency(locale)).to_s.upcase.to_sym
+        minor = opts[:minor] || :always
 
-        major_str, minor_str = sprintf('%.2f', amount).split('.')
-        major_value = major_str.to_i
-        minor_value = minor_str.to_i
+        validate_option!(:minor, minor, %i[always nonzero never])
 
-        major_words = to_words(major_value, locale: locale)
-        major_name  = pluralize(major_value, *locale_data::MAJOR_UNIT)
+        unless Num2words.available_currencies(locale).include?(currency)
+          warn I18n.t("num2words.warnings.currency_not_available",
+                      currency: currency, locale: locale) if Num2words.currency_warnings
+          currency = Num2words.default_currency(locale)
+        end
 
-        minor_words = to_words(minor_value, locale: locale, feminine: true)
-        minor_name  = pluralize(minor_value, *locale_data::MINOR_UNIT)
+        currency_data = I18n.t("num2words.currencies.#{currency}", locale: locale) or
+          raise ArgumentError, "Currency #{currency} not defined in locale #{locale}"
 
-        result = [major_words, major_name, minor_words, minor_name].join(" ")
-        apply_case(result, word_case)
+        decimal_amount = decimal_currency_amount(amount)
+        major_value, minor_value = format('%.2f', decimal_amount.abs).split('.').map(&:to_i)
+
+        parts = [
+          to_words(major_value, locale: locale),
+          pluralize(major_value, *currency_data[:major_unit])
+        ]
+
+        include_minor = minor == :always || (minor == :nonzero && minor_value.positive?)
+        if include_minor
+          parts.concat([
+            to_words(minor_value, locale: locale, feminine: true),
+            pluralize(minor_value, *currency_data[:minor_unit])
+          ])
+        end
+
+        parts.unshift(Locales[locale]::GRAMMAR[:minus] || "minus") if decimal_amount.negative?
+
+        apply_case(parts.join(" ").strip, word_case)
       end
 
       private
 
+      def validate_option!(name, value, allowed_values)
+        return if allowed_values.include?(value)
+
+        raise ArgumentError, "Unsupported #{name} option: #{value.inspect}"
+      end
+
+      def decimal_currency_amount(amount)
+        return amount if amount.is_a?(BigDecimal)
+
+        normalized_amount = amount.is_a?(String) ? amount.tr(",", ".") : amount.to_s
+        BigDecimal(normalized_amount)
+      rescue ArgumentError
+        raise ArgumentError, "Unsupported currency amount: #{amount.inspect}"
+      end
+
       def pluralize(number, singular, few, plural)
         number = number.abs
         return plural if (11..14).include?(number % 100)
@@ -85,21 +125,23 @@ module Num2words
         words.compact
       end
 
-      def to_words_fractional(number, locale, feminine, locale_data, style: :fraction)
-        minus_word       = locale_data::GRAMMAR[:minus] || "minus"
-        conjunction_word = locale_data::GRAMMAR[:conjunction] || "and"
+      def to_words_fractional(number, locale, feminine, locale_data, style: :fraction, joiner: :default)
+        minus_word = locale_data::GRAMMAR[:minus] || "minus"
+        conjunction_word = joiner.to_sym == :and ? "и" : locale_data::GRAMMAR[:conjunction] || "and"
         default_fraction = locale_data::GRAMMAR[:default_fraction] || "parts"
-        fractions_data   = locale_data::FRACTIONS || {}
+        fractions_data = locale_data::FRACTIONS || {}
 
-        sign_word = number.negative? ? minus_word : ""
+        negative = number.is_a?(String) ? number.start_with?("-") : number.negative?
+        sign_word = negative ? minus_word : ""
 
-        integer_string, fraction_string = number.abs.to_s.split('.', 2)
+        absolute_number = number.is_a?(String) ? number.sub(/\A-/, "").tr(",", ".") : number.abs.to_s
+        integer_string, fraction_string = absolute_number.split('.', 2)
         integer_value = integer_string.to_i
 
         return to_words_integer(integer_value, locale, feminine, locale_data) if fraction_string.to_i.zero?
 
         fraction_string = fraction_string.sub(/0+\z/, "")
-        numerator   = fraction_string.to_i
+        numerator = fraction_string.to_i
         denominator = 10 ** fraction_string.length
 
         integer_words = to_words_integer(integer_value, locale, feminine, locale_data)
@@ -121,6 +163,10 @@ module Num2words
       def to_words_integer(number, locale, feminine, locale_data)
         integer_value = Integer(number)
 
+        minus_word = locale_data::GRAMMAR[:minus] || "minus"
+        negative = integer_value.negative?
+        integer_value = integer_value.abs
+
         return (feminine ? locale_data::ONES_FEM[0] : locale_data::ONES_MASC[0]) if integer_value.zero?
 
         groups = integer_value.to_s
@@ -134,10 +180,11 @@ module Num2words
           words.concat triple_to_words(group_value, scale_index, locale_data, feminine: group_feminine)
         end
 
+        words.unshift(minus_word) if negative
         words.join(" ")
       end
 
-      def to_words_date(date, locale, locale_data, format: :default)
+      def to_words_date(date, locale, locale_data, format: :default, date_case: :default)
         date = Date.parse(date.to_s) unless date.is_a?(Date)
 
         day, month, year = [date.day, date.month, date.year]
@@ -150,9 +197,10 @@ module Num2words
         raise ArgumentError, "Months not found for locale #{locale}" unless months
         raise ArgumentError, "Template not found for locale #{locale}" unless template
 
-        day_words   = to_words_ordinal(day, locale, format, locale_data, gender: :neuter)
+        day_gender = date_case.to_sym == :genitive ? :masculine : :neuter
+        day_words = to_words_ordinal(day, locale, format, locale_data, gender: day_gender)
         month_words = months[month - 1]
-        year_words  = to_words_ordinal(year, locale, format, locale_data)
+        year_words = to_words_ordinal(year, locale, format, locale_data)
 
         template % { day: day_words, month: month_words, year: year_words }
       end
@@ -164,13 +212,13 @@ module Num2words
         gender_data = ordinals[gender] || ordinals[:masculine]
         raise ArgumentError, "Gender #{gender} not found for locale #{locale}, format #{format}" unless gender_data
 
-        return gender_data[value - 1] if gender_data[value]
+        return gender_data[value - 1] if value.between?(1, gender_data.length)
 
         if value > 31
           thousands = (value / 100) * 100
-          last_two  = value % 100
+          last_two = value % 100
 
-          base_year   = to_words_integer(thousands, locale, false, locale_data)
+          base_year = to_words_integer(thousands, locale, false, locale_data)
           last_ordinal = gender_data[last_two - 1] || to_words_integer(last_two, locale, false, locale_data)
           last_ordinal = to_words_integer(last_two, locale, false, locale_data) if locale == :en
 
@@ -185,7 +233,7 @@ module Num2words
 
         return time.strftime("%H:%M") if format == :short
 
-        words    = locale_data::TIME[:words]
+        words = locale_data::TIME[:words]
         template = locale_data::TIME_TEMPLATE
 
         hours = [
@@ -219,14 +267,13 @@ module Num2words
         end
       end
 
-
-      def to_words_datetime(datetime, locale, locale_data, format: :default, only: nil, short: false)
+      def to_words_datetime(datetime, locale, locale_data, format: :default, only: nil, short: false, date_case: :default)
         datetime = DateTime.parse(datetime) if datetime.is_a?(String)
 
         date_format = short && only == :date ? :short : format
         time_format = short && only == :time ? :short : :default
 
-        date_part = to_words_date(datetime.to_date, locale, locale_data, format: date_format)
+        date_part = to_words_date(datetime.to_date, locale, locale_data, format: date_format, date_case: date_case)
         time_part = to_words_time(datetime.to_time, locale, locale_data, format: time_format, short: short)
 
         return date_part if only == :date
@@ -250,19 +297,19 @@ module Num2words
 
       def detect_type(value)
         case value
-        when Integer   then :integer
-        when Float     then :float
-        when Date      then :date
-        when Time      then :time
-        when DateTime  then :datetime
+        when Integer then :integer
+        when Float then :float
+        when DateTime then :datetime
+        when Date then :date
+        when Time then :time
         when String
           return :integer if value.match?(/\A-?\d+\z/)
-          return :float   if value.match?(/\A-?\d+\.\d+\z/)
-          return :time    if value.match?(/\A\d{1,2}:\d{2}(:\d{2})?\z/)
+          return :float if value.match?(/\A-?\d+[\.,]\d+\z/)
+          return :time if value.match?(/\A\d{1,2}:\d{2}(:\d{2})?\z/)
 
           # Форматы даты
-          return :date     if value.match?(/\A\d{1,2}[.\-]\d{1,2}[.\-]\d{2,4}\z/)
-          return :date     if value.match?(/\A\d{4}-\d{2}-\d{2}\z/)
+          return :date if value.match?(/\A\d{1,2}[.\-]\d{1,2}[.\-]\d{2,4}\z/)
+          return :date if value.match?(/\A\d{4}-\d{2}-\d{2}\z/)
           return :datetime if value.match?(/\A\d{1,2}[.\-]\d{1,2}[.\-]\d{2,4}\s+\d{1,2}:\d{2}(:\d{2})?\z/)
           return :datetime if value.match?(/\A\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}(:\d{2})?([.,]\d+)?(Z|[+\-]\d{2}:?\d{2})?\z/)
 

data/lib/num2words/locales/ar.rb

@@ -10,8 +10,16 @@ module Num2words
       HUNDREDS = I18n.t("num2words.hundreds", locale: :ar)
       SCALES = I18n.t("num2words.scales", locale: :ar)
 
-      MAJOR_UNIT = I18n.t("num2words.currencies.SAR.name", locale: :ar)
-      MINOR_UNIT = I18n.t("num2words.currencies.SAR.fractional.name", locale: :ar)
+      FRACTIONS = I18n.t("num2words.fractions", locale: :ar)
+      GRAMMAR = I18n.t("num2words.grammar", locale: :ar)
+
+      DATE = I18n.t("num2words.date", locale: :ar)
+      DATE_TEMPLATE = I18n.t("num2words.date.template", locale: :ar)
+      TIME = I18n.t("num2words.time", locale: :ar)
+      TIME_TEMPLATE = I18n.t("num2words.time.template", locale: :ar)
+      DATETIME_TEMPLATE = I18n.t("num2words.datetime.template", locale: :ar)
+
+      ORDINALS = I18n.t("num2words.numbers.ordinals", locale: :ar)
     end
 
     register :ar, AR

data/lib/num2words/locales/be.rb

@@ -10,8 +10,16 @@ module Num2words
       HUNDREDS = I18n.t("num2words.hundreds", locale: :be)
       SCALES = I18n.t("num2words.scales", locale: :be)
 
-      MAJOR_UNIT = I18n.t("num2words.currencies.BYN.name", locale: :be)
-      MINOR_UNIT = I18n.t("num2words.currencies.BYN.fractional.name", locale: :be)
+      FRACTIONS = I18n.t("num2words.fractions", locale: :be)
+      GRAMMAR = I18n.t("num2words.grammar", locale: :be)
+
+      DATE = I18n.t("num2words.date", locale: :be)
+      DATE_TEMPLATE = I18n.t("num2words.date.template", locale: :be)
+      TIME = I18n.t("num2words.time", locale: :be)
+      TIME_TEMPLATE = I18n.t("num2words.time.template", locale: :be)
+      DATETIME_TEMPLATE = I18n.t("num2words.datetime.template", locale: :be)
+
+      ORDINALS = I18n.t("num2words.numbers.ordinals", locale: :be)
     end
 
     register :be, BE

data/lib/num2words/locales/bg.rb

@@ -10,8 +10,16 @@ module Num2words
       HUNDREDS = I18n.t("num2words.hundreds", locale: :bg)
       SCALES = I18n.t("num2words.scales", locale: :bg)
 
-      MAJOR_UNIT = I18n.t("num2words.currencies.BGN.name", locale: :bg)
-      MINOR_UNIT = I18n.t("num2words.currencies.BGN.fractional.name", locale: :bg)
+      FRACTIONS = I18n.t("num2words.fractions", locale: :bg)
+      GRAMMAR = I18n.t("num2words.grammar", locale: :bg)
+
+      DATE = I18n.t("num2words.date", locale: :bg)
+      DATE_TEMPLATE = I18n.t("num2words.date.template", locale: :bg)
+      TIME = I18n.t("num2words.time", locale: :bg)
+      TIME_TEMPLATE = I18n.t("num2words.time.template", locale: :bg)
+      DATETIME_TEMPLATE = I18n.t("num2words.datetime.template", locale: :bg)
+
+      ORDINALS = I18n.t("num2words.numbers.ordinals", locale: :bg)
     end
 
     register :bg, BG

data/lib/num2words/locales/bn.rb

@@ -10,8 +10,16 @@ module Num2words
       HUNDREDS = I18n.t("num2words.hundreds", locale: :bn)
       SCALES = I18n.t("num2words.scales", locale: :bn)
 
-      MAJOR_UNIT = I18n.t("num2words.currencies.BDT.name", locale: :bn)
-      MINOR_UNIT = I18n.t("num2words.currencies.BDT.fractional.name", locale: :bn)
+      FRACTIONS = I18n.t("num2words.fractions", locale: :bn)
+      GRAMMAR = I18n.t("num2words.grammar", locale: :bn)
+
+      DATE = I18n.t("num2words.date", locale: :bn)
+      DATE_TEMPLATE = I18n.t("num2words.date.template", locale: :bn)
+      TIME = I18n.t("num2words.time", locale: :bn)
+      TIME_TEMPLATE = I18n.t("num2words.time.template", locale: :bn)
+      DATETIME_TEMPLATE = I18n.t("num2words.datetime.template", locale: :bn)
+
+      ORDINALS = I18n.t("num2words.numbers.ordinals", locale: :bn)
     end
 
     register :bn, BN

data/lib/num2words/locales/cs.rb

@@ -10,8 +10,16 @@ module Num2words
       HUNDREDS = I18n.t("num2words.hundreds", locale: :cs)
       SCALES = I18n.t("num2words.scales", locale: :cs)
 
-      MAJOR_UNIT = I18n.t("num2words.currencies.CZK.name", locale: :cs)
-      MINOR_UNIT = I18n.t("num2words.currencies.CZK.fractional.name", locale: :cs)
+      FRACTIONS = I18n.t("num2words.fractions", locale: :cs)
+      GRAMMAR = I18n.t("num2words.grammar", locale: :cs)
+
+      DATE = I18n.t("num2words.date", locale: :cs)
+      DATE_TEMPLATE = I18n.t("num2words.date.template", locale: :cs)
+      TIME = I18n.t("num2words.time", locale: :cs)
+      TIME_TEMPLATE = I18n.t("num2words.time.template", locale: :cs)
+      DATETIME_TEMPLATE = I18n.t("num2words.datetime.template", locale: :cs)
+
+      ORDINALS = I18n.t("num2words.numbers.ordinals", locale: :cs)
     end
 
     register :cs, CS

data/lib/num2words/locales/da.rb

@@ -10,8 +10,16 @@ module Num2words
       HUNDREDS = I18n.t("num2words.hundreds", locale: :da)
       SCALES = I18n.t("num2words.scales", locale: :da)
 
-      MAJOR_UNIT = I18n.t("num2words.currencies.DKK.name", locale: :da)
-      MINOR_UNIT = I18n.t("num2words.currencies.DKK.fractional.name", locale: :da)
+      FRACTIONS = I18n.t("num2words.fractions", locale: :da)
+      GRAMMAR = I18n.t("num2words.grammar", locale: :da)
+
+      DATE = I18n.t("num2words.date", locale: :da)
+      DATE_TEMPLATE = I18n.t("num2words.date.template", locale: :da)
+      TIME = I18n.t("num2words.time", locale: :da)
+      TIME_TEMPLATE = I18n.t("num2words.time.template", locale: :da)
+      DATETIME_TEMPLATE = I18n.t("num2words.datetime.template", locale: :da)
+
+      ORDINALS = I18n.t("num2words.numbers.ordinals", locale: :da)
     end
 
     register :da, DA

data/lib/num2words/locales/de.rb

@@ -10,8 +10,16 @@ module Num2words
       HUNDREDS = I18n.t("num2words.hundreds", locale: :de)
       SCALES = I18n.t("num2words.scales", locale: :de)
 
-      MAJOR_UNIT = I18n.t("num2words.currencies.EUR.name", locale: :de)
-      MINOR_UNIT = I18n.t("num2words.currencies.EUR.fractional.name", locale: :de)
+      FRACTIONS = I18n.t("num2words.fractions", locale: :de)
+      GRAMMAR = I18n.t("num2words.grammar", locale: :de)
+
+      DATE = I18n.t("num2words.date", locale: :de)
+      DATE_TEMPLATE = I18n.t("num2words.date.template", locale: :de)
+      TIME = I18n.t("num2words.time", locale: :de)
+      TIME_TEMPLATE = I18n.t("num2words.time.template", locale: :de)
+      DATETIME_TEMPLATE = I18n.t("num2words.datetime.template", locale: :de)
+
+      ORDINALS = I18n.t("num2words.numbers.ordinals", locale: :de)
     end
 
     register :de, DE