ru_propisju 1.2.0 → 2.0.0

data/Gemfile

@@ -0,0 +1,5 @@
+source :rubygems
+group :development do
+  gem "jeweler"
+  gem "rake"
+end

data/History.txt

@@ -1,3 +1,7 @@
+=== 2.0.0 / 2011-11-15
+
+* Добавлена поддержка украинского языка -  iz65535
+
 === 1.2.0 / 2011-11-15
 
 * Добавлена поддержка И Еще Нескольких Валют (тм) - terraplane

data/Rakefile

@@ -1,13 +1,33 @@
+# -*- encoding: utf-8 -*-
 # -*- ruby -*-
+$KCODE = 'u' if RUBY_VERSION < '1.9.0'
 
 require 'rubygems'
-require 'hoe'
+require 'jeweler'
+require './lib/ru_propisju'
 
-Hoe.spec 'ru_propisju' do | p |
-  p.readme_file = 'README.rdoc'
-  p.extra_rdoc_files  = FileList['*.rdoc'] + FileList['*.txt']
-  p.developer('Julik Tarkhanov', 'me@julik.nl')
-  p.clean_globs += %w( *.gemspec )
+Jeweler::Tasks.new do |gem|
+  gem.version = RuPropisju::VERSION
+  gem.name = "ru_propisju"
+  gem.summary = "Cумма прописью"
+  gem.email = "me@julik.nl"
+  gem.homepage = "http://github.com/julik/ru_propisju"
+  gem.authors = ["Julik Tarkhanov"]
+  gem.license = 'MIT'
+  
+  # Do not package invisibles
+  gem.files.exclude ".*"
 end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+desc "Run all tests"
+Rake::TestTask.new("test") do |t|
+  t.libs << "test"
+  t.pattern = 'test/**/test_*.rb'
+  t.verbose = true
+end
+
+task :default => [ :test ]
 
 # vim: syntax=ruby

data/lib/ru_propisju.rb

@@ -6,16 +6,141 @@ $KCODE = 'u' if RUBY_VERSION < '1.9.0'
 #   RuPropisju.rublej(123) # "сто двадцать три рубля"
 module RuPropisju
 
-  VERSION = '1.2.0'
+  VERSION = '2.0.0'
   
+  # http://www.xe.com/symbols.php
+  # (лица, приближенные форексам и всяким там валютам и курсам)
+  # говорят, что код валюты российского рубля - rub
+  CURRENCIES = {
+    "rur" => :rublej,
+    "rub" => :rublej,
+    "usd" => :dollarov,
+    "uah" => :griven,
+    "eur" => :evro,
+  }
+  SUPPORTED_CURRENCIES = CURRENCIES.keys.join ','
+  
+  TRANSLATIONS = {
+    "ru" => {
+      0 => "",
+      '0' => "ноль",
+      :thousands => ["тысяча", "тысячи", "тысяч"],
+      :millions => ["миллион", "миллиона", "миллионов"],
+      :billions => ["миллиард", "миллиарда", "миллиардов"],
+      100 => "сто",
+      200 => "двести",
+      300 => "триста",
+      400 => "четыреста",
+      500 => "пятьсот",
+      600 => "шестьсот",
+      700 => "семьсот",
+      800 => "восемьсот",
+      900 => "девятьсот",
+
+      10 => "десять",
+      11 => "одиннадцать",
+      12 => "двенадцать",
+      13 => "тринадцать",
+      14 => "четырнадцать",
+      15 => "пятнадцать",
+      16 => "шестнадцать",
+      17 => "семнадцать",
+      18 => "восемнадцать",
+      19 => "девятнадцать",
+      20 => "двадцать",
+      30 => "тридцать",
+      40 => "сорок",
+      50 => "пятьдесят",
+      60 => "шестьдесят",
+      70 => "семьдесят",
+      80 => "восемьдесят",
+      90 => "девяносто",
+      # единицы, местами - c учетом рода
+      1 => {1 => "один", 2 => 'одна', 3 => 'одно'},
+      2 => {1 => "два", 2 => 'две', 3 => 'два'},
+      3 => "три",
+      4 => "четыре",
+      5 => "пять",
+      6 => "шесть",
+      7 => "семь",
+      8 => "восемь",
+      9 => "девять",
+      :rub_integral => ["рубль", "рубля", "рублей"],
+      :rub_fraction => ['копейка', 'копейки', 'копеек'],
+      :uah_integral => ["гривна", "гривны", "гривен"],
+      :uah_fraction => ['копейка', 'копейки', 'копеек'],
+      :eur_integral => ["евро", "евро", "евро"],
+      # по опыту моей прошлой работы в банке
+      # центами называют дробную часть доллара
+      # а дробную часть евро называют евроцентом
+      :eur_fraction => ["цент", "цента", "центов"],
+      :usd_integral => ["доллар", "доллара", "долларов"],
+      :usd_fraction => ['цент', 'цента', 'центов'],
+    },
+    "ua" => {
+      0 => "",
+      '0' => "нуль",
+      :thousands => ["тисяча", "тисячі", "тисяч"],
+      :millions => ["мільйон", "мільйона", "мільйонів"],
+      :billions => ["мільярд", "мільярда", "мільярдів"],
+      100 => "сто",
+      200 => "двісті",
+      300 => "триста",
+      400 => "чотиреста",
+      500 => "п'ятьсот",
+      600 => "шістсот",
+      700 => "сімсот",
+      800 => "вісімсот",
+      900 => "дев'ятсот",
+
+      10 => "десять",
+      11 => "одинадцять",
+      12 => "дванадцять",
+      13 => "тринадцять",
+      14 => "чотирнадцять",
+      15 => "п'ятнадцять",
+      16 => "шістнадцять",
+      17 => "сімнадцять",
+      18 => "вісімнадцять",
+      19 => "дев'ятнадцять",
+      20 => "двадцять",
+      30 => "тридцять",
+      40 => "сорок",
+      50 => "п'ятьдесят",
+      60 => "шістдесят",
+      70 => "сімдесят",
+      80 => "вісімдесят",
+      90 => "дев'яносто",
+      # единицы, местами - c учетом рода
+      1 => {1 => "один", 2 => 'одна', 3 => 'одне'},
+      2 => {1 => "два", 2 => 'дві', 3 => 'два'},
+      3 => "три",
+      4 => "чотири",
+      5 => "п'ять",
+      6 => "шість",
+      7 => "сім",
+      8 => "вісім",
+      9 => "дев'ять",
+      :rub_integral => ["рубль", "рубля", "рублів"],
+      :rub_fraction => ['копійка', 'копійки', 'копійок'],
+      :uah_integral => ["гривня", "гривні", "гривень"],
+      :uah_fraction => ["копійка", "копійки", "копійок"],
+      :eur_integral => ["євро", "євро", "євро"],
+      :eur_fraction => ["євроцент", "євроцента", "євроцентів"],
+      :usd_integral => ["долар", "долара", "доларів"],
+      :usd_fraction => ['цент', 'цента', 'центів'],
+    }
+  }
+
+
   # Кидается при запросе неизвестной валюты
   class UnknownCurrency < ArgumentError
   end
-  
+
   # Выбирает нужный падеж существительного в зависимости от числа
   #
   #   choose_plural(3, "штука", "штуки", "штук") #=> "штуки"
-  def choose_plural(amount, *variants)
+  def choose_plural(amount, variants)
     mod_ten = amount % 10
     mod_hundred = amount % 100
     variant = if (mod_ten == 1 && mod_hundred != 11)
@@ -29,34 +154,39 @@ module RuPropisju
     end
     variants[variant-1]
   end
-  
+
   # Выводит сумму прописью в зависимости от выбранной валюты.
   # Поддерживаемые валюты: rur, usd, uah, eur
   #
   #   amount_in_words(345.2, 'rur') #=> "триста сорок пять рублей 20 копеек"
-  def amount_in_words(amount, currency)
-    unless CURRENCIES.has_key?(currency.to_s.downcase)
-      raise UnknownCurrency, "Unsupported currency #{currency}, the following are supported: #{CURRENCIES.keys.join(", ")}"
+  def amount_in_words(amount, currency, locale = :ru)
+    currency = currency.to_s.downcase
+    unless CURRENCIES.has_key? currency
+      raise UnknownCurrency, "Unsupported currency #{currency}, the following are supported: #{SUPPORTED_CURRENCIES}"
     end
-    method(CURRENCIES[currency.to_s.downcase]).call(amount)
+    method(CURRENCIES[currency]).call(amount, locale)
   end
-  
+
   # Выводит целое или дробное число как сумму в рублях прописью
   #
   #   rublej(345.2) #=> "триста сорок пять рублей 20 копеек"
-  def rublej(amount)
+  def rublej(amount, locale = :ru)
     pts = []
+    locale_root = TRANSLATIONS[locale.to_s]
 
-    pts << propisju_shtuk(amount.to_i, 1, "рубль", "рубля", "рублей") unless amount.to_i == 0
+    integrals = locale_root[:rub_integral]
+    fractions = locale_root[:rub_fraction]
+
+    pts << propisju_shtuk(amount.to_i, 1, integrals, locale) unless amount.to_i == 0
 
     if amount.kind_of?(Float)
       remainder = (amount.divmod(1)[1]*100).round
-      if (remainder == 100)
-        pts = [propisju_shtuk(amount.to_i+1, 1, 'рубль', 'рубля', 'рублей')]
+      if remainder == 100
+        pts = [propisju_shtuk(amount.to_i+1, 1, integrals, locale)]
       else
         kop = remainder.to_i
         unless kop.zero?
-          pts << kop << choose_plural(kop, 'копейка', 'копейки', 'копеек')
+          pts << kop << choose_plural(kop, fractions)
         end
       end
     end
@@ -68,46 +198,53 @@ module RuPropisju
   #
   #   propisju(243) => "двести сорок три"
   #   propisju(221, 2) => "двести двадцать одна"
-  def propisju(amount, gender = 1)
+  def propisju(amount, gender, locale = :ru)
     if amount.is_a?(Integer) || amount.is_a?(Bignum)
-      propisju_int(amount, gender)
+      propisju_int(amount, gender, [], locale)
     else # также сработает для Decimal, дробные десятичные числительные в долях поэтому женского рода
-      propisju_float(amount)
+      propisju_float(amount, locale)
     end
   end
 
   # Выводит целое или дробное число как сумму в гривнах прописью
   #
   #  griven(32) #=> "тридцать две гривны"
-  def griven(amount)
-    pts = []
+  def griven(amount, locale = 'ru')
+    locale_root = TRANSLATIONS[locale.to_s]
 
-    pts << propisju_int(amount.to_i, 2, "гривна", "гривны", "гривен") unless amount.to_i == 0
-    if amount.kind_of?(Float)
+    integrals = locale_root[:uah_integral]
+    fractions = locale_root[:uah_fraction]
+
+    pts = []
+    pts << propisju_int(amount.to_i, 2, integrals, locale) unless amount.to_i == 0
+    if amount.kind_of? Float
       remainder = (amount.divmod(1)[1]*100).round
-      if (remainder == 100)
-        pts = [propisju_int(amount.to_i + 1, 2, 'гривна', 'гривны', 'гривен')]
+      if remainder == 100
+        pts = [propisju_int(amount.to_i + 1, 2, integrals, locale)]
       else
-        pts << propisju_int(remainder.to_i, 2, 'копейка', 'копейки', 'копеек')
+        pts << propisju_int(remainder.to_i, 2, fractions, locale)
       end
     end
-
     pts.join(' ')
   end
 
   # Выводит целое или дробное число как сумму в долларах прописью
   #
   #  dollarov(32) #=> "тридцать два доллара"
-  def dollarov(amount)
+  def dollarov(amount, locale = 'ru')
     pts = []
+    locale_root = TRANSLATIONS[locale.to_s]
+
+    integrals = locale_root[:usd_integral]
+    fractions = locale_root[:usd_fraction]
 
-    pts << propisju_int(amount.to_i, 1, "доллар", "доллара", "долларов") unless amount.to_i == 0
+    pts << propisju_int(amount.to_i, 1, integrals, locale) unless amount.to_i == 0
     if amount.kind_of?(Float)
       remainder = (amount.divmod(1)[1]*100).round
       if (remainder == 100)
-        pts = [propisju_int(amount.to_i + 1, 1, 'доллар', 'доллара', 'долларов')]
+        pts = [propisju_int(amount.to_i + 1, 1, integrals, locale)]
       else
-        pts << propisju_int(remainder.to_i, 1, 'цент', 'цента', 'центов')
+        pts << propisju_int(remainder.to_i, 1, fractions, locale)
       end
     end
 
@@ -117,16 +254,20 @@ module RuPropisju
   # Выводит целое или дробное число как сумму в евро прописью
   #
   #  evro(32) #=> "тридцать два евро"
-  def evro(amount)
+  def evro(amount, locale = 'ru')
     pts = []
+    locale = locale.to_sym
 
-    pts << propisju_int(amount.to_i, 1, "евро", "евро", "евро") unless amount.to_i == 0
+    integrals = TRANSLATIONS[locale.to_s][:eur_integral]
+    fractions = TRANSLATIONS[locale.to_s][:eur_fraction]
+
+    pts << propisju_int(amount.to_i, 1, integrals, locale) unless amount.to_i == 0
     if amount.kind_of?(Float)
       remainder = (amount.divmod(1)[1]*100).round
       if (remainder == 100)
-        pts = [propisju_int(amount.to_i + 1, 1, 'евро', 'евро', 'евро')]
+        pts = [propisju_int(amount.to_i + 1, 1, integrals, locale)]
       else
-        pts << propisju_int(remainder.to_i, 1, 'цент', 'цента', 'центов')
+        pts << propisju_int(remainder.to_i, 1, fractions, locale)
       end
     end
 
@@ -136,19 +277,19 @@ module RuPropisju
   # Выводит сумму прописью в рублях по количеству копеек
   #
   #  kopeek(343) #=> "три рубля 43 копейки"
-  def kopeek(amount)
-    rublej(amount / 100.0)
+  def kopeek(amount, locale = :ru)
+    rublej(amount / 100.0, locale)
   end
 
   # Выводит сумму данного существительного прописью и выбирает правильное число и падеж
   #
   #    RuPropisju.propisju_shtuk(21, 3, "колесо", "колеса", "колес") #=> "двадцать одно колесо"
   #    RuPropisju.propisju_shtuk(21, 1, "мужик", "мужика", "мужиков") #=> "двадцать один мужик"
-  def propisju_shtuk(items, gender = 1, *forms)
+  def propisju_shtuk(items, gender, forms, locale = :ru)
     r = if items == items.to_i
-      [propisju(items, gender), choose_plural(items, *forms)]
+      [propisju(items, gender, locale), choose_plural(items, forms)]
     else
-      [propisju(items, gender), forms[1]]
+      [propisju(items, gender, locale), forms[1]]
     end
 
     r.join(" ")
@@ -156,128 +297,125 @@ module RuPropisju
 
   private
 
-  def compose_ordinal(into, remaining_amount, gender, one_item='', two_items='', five_items='')
+  # ранее интерфейс был похож на интерфейс внешний (one_item, two_items, five_items),
+  # однако списковая форма строк выглядит предпочтительнее, поэтому интерфейс изменен.
+  # по хорошему надо менять также внешний интерфейс, но это может сломать совместимость
+  def compose_ordinal(into, remaining_amount, gender, item_forms=[], locale = :ru)
+    locale = locale.to_sym
+
     rest, rest1, chosen_ordinal, ones, tens, hundreds = [nil]*6
     #
     rest = remaining_amount % 1000
     remaining_amount = remaining_amount / 1000
-    if rest == 0
+    if rest.zero?
       # последние три знака нулевые
-      into = five_items + " " if into == ""
+      into = item_forms[2] if into.empty?
       return [into, remaining_amount]
     end
-    #
-    # начинаем подсчет с Rest
-    chosen_ordinal = five_items
 
+    locale_root = TRANSLATIONS[locale.to_s]
+    # начинаем подсчет с Rest
     # сотни
-    hundreds = case rest / 100
-      when 0 then ""
-      when 1 then "сто "
-      when 2 then "двести "
-      when 3 then "триста "
-      when 4 then "четыреста "
-      when 5 then "пятьсот "
-      when 6 then "шестьсот "
-      when 7 then "семьсот "
-      when 8 then "восемьсот "
-      when 9 then "девятьсот "
-    end
+    hundreds = locale_root[(rest / 100).to_i * 100]
 
     # десятки
     rest = rest % 100
     rest1 = rest / 10
+    # единички
     ones = ""
-    tens = case rest1
-      when 0 then ""
-      when 1 # особый случай
-        case rest
-          when 10 then "десять "
-          when 11 then "одиннадцать "
-          when 12 then "двенадцать "
-          when 13 then "тринадцать "
-          when 14 then "четырнадцать "
-          when 15 then "пятнадцать "
-          when 16 then "шестнадцать "
-          when 17 then "семнадцать "
-          when 18 then "восемнадцать "
-          when 19 then "девятнадцать "
-        end
-      when 2 then "двадцать "
-      when 3 then "тридцать "
-      when 4 then "сорок "
-      when 5 then "пятьдесят "
-      when 6 then "шестьдесят "
-      when 7 then "семьдесят "
-      when 8 then "восемьдесят "
-      when 9 then "девяносто "
-    end
-    #
-    if rest1 < 1 or rest1 > 1 # единицы
+    tens = locale_root[rest1 == 1 ? rest : rest1 * 10]
+    # индекс выбранной формы
+    chosen_ordinal = 2
+    if rest1 < 1 || rest1 > 1 # единицы
+      value = locale_root[rest % 10]
+      # если попался хэш, делаем выбор согласно рода
+      value = value[gender] if value.kind_of? Hash
+      ones = value
       case rest % 10
-        when 1
-          ones = case gender
-            when 1 then "один "
-            when 2 then "одна "
-            when 3 then "одно "
-          end
-          chosen_ordinal = one_item
-        when 2
-          if gender == 2
-            ones = "две "
-          else
-            ones = "два "
-          end
-          chosen_ordinal = two_items
-        when 3
-          ones = "три "
-          chosen_ordinal = two_items
-        when 4
-          ones = "четыре "
-          chosen_ordinal = two_items
-        when 5
-          ones = "пять "
-        when 6
-          ones = "шесть "
-        when 7
-          ones = "семь "
-        when 8
-          ones = "восемь "
-        when 9
-          ones = "девять "
+        when 1 then chosen_ordinal = 0 # индекс формы меняется
+        when 2..4 then chosen_ordinal = 1 # индекс формы меняется
       end
     end
-
-    plural = [hundreds, tens, ones, chosen_ordinal,  " ",  into].join.strip
+    plural = [
+      hundreds,
+      tens,
+      ones,
+      item_forms[chosen_ordinal],
+      into
+    ].compact.reject(&:empty?).join(' ').strip
     return [plural, remaining_amount]
   end
-  
-  DECIMALS = %w( целая десятая сотая тысячная десятитысячная стотысячная
-      миллионная десятимиллионная стомиллионная миллиардная десятимиллиардная
-      стомиллиардная триллионная
-  ).map{|e| [e, e.gsub(/ая$/, "ых"), e.gsub(/ая$/, "ых"), ] }.freeze
-  
-  CURRENCIES = {
-    "rur" => :rublej,
-    "usd" => :dollarov,
-    "uah" => :griven,
-    "eur" => :evro,
+
+  DECIMALS = {
+    :ru =>{
+      :source_words => [
+        'целая',
+        'десятая',
+        'сотая',
+        'тысячная',
+        'десятитысячная',
+        'стотысячная',
+        'миллионная',
+        'десятимиллионная',
+        'стомиллионная',
+        'миллиардная',
+        'десятимиллиардная',
+        'стомиллиардная',
+        'триллионная'
+      ],
+      :prefix => ["ая", 'ых'],
+    },
+    :ua => {
+      :source_words => [
+        'ціла',
+        'десята',
+        'сота',
+        'тисячна',
+        'десятитисячна',
+        'стотисячна',
+        'мільйонна',
+        'десятимільйонна',
+        'стомільйонна',
+        'мільярдна',
+        'десятимільярдна',
+        'стомільярдна',
+        'трильонна'
+      ],
+      :prefix => ["а", 'их'],
+    },
   }
-  
+
+
+#   DECIMALS = %w( целая десятая сотая тысячная десятитысячная стотысячная
+#       миллионная десятимиллионная стомиллионная миллиардная десятимиллиардная
+#       стомиллиардная триллионная
+#   ).map{|e| [e, e.gsub(/ая$/, "ых"), e.gsub(/ая$/, "ых"), ] }.freeze
+#
+
   # Выдает сумму прописью с учетом дробной доли. Дробная доля округляется до миллионной, или (если
   # дробная доля оканчивается на нули) до ближайшей доли ( 500 тысячных округляется до 5 десятых).
   # Дополнительный аргумент - род существительного (1 - мужской, 2- женский, 3-средний)
-  def propisju_float(num)
+  def propisju_float(num, locale = :ru)
+    locale_root = DECIMALS[locale.to_sym]
+    source_expression = locale_root[:prefix][0]
+    target_prefix = locale_root[:prefix][1]
+    words = locale_root[:source_words].map do |e|
+      [
+        e,
+        e.gsub(/#{source_expression}$/, target_prefix),
+        e.gsub(/#{source_expression}$/, target_prefix),
+      ]
+    end.freeze
 
     # Укорачиваем до триллионной доли
-    formatted = ("%0.#{DECIMALS.length}f" % num).gsub(/0+$/, '')
+    formatted = ("%0.#{words.length}f" % num).gsub(/0+$/, '')
     wholes, decimals = formatted.split(/\./)
 
-    return propisju_int(wholes.to_i) if decimals.to_i.zero?
+    return propisju_int(wholes.to_i, 1, [], locale) if decimals.to_i.zero?
 
-    whole_st = propisju_shtuk(wholes.to_i, 2, *DECIMALS[0])
+    whole_st = propisju_shtuk(wholes.to_i, 2, words[0], locale)
 
-    rem_st = propisju_shtuk(decimals.to_i, 2, *DECIMALS[decimals.length])
+    rem_st = propisju_shtuk(decimals.to_i, 2, words[decimals.length], locale)
     [whole_st, rem_st].compact.join(" ")
   end
 
@@ -291,28 +429,28 @@ module RuPropisju
   #
   # Примерно так:
   #   propisju(42, 1, "сволочь", "сволочи", "сволочей") # => "сорок две сволочи"
-  def propisju_int(amount, gender = 1, one_item = '', two_items = '', five_items = '')
+  def propisju_int(amount, gender = 1, item_forms = [], locale = :ru)
 
-    return "ноль " + five_items if amount.zero?
+    locale_root = TRANSLATIONS[locale.to_s]
 
-    # единицы
-    into, remaining_amount = compose_ordinal('', amount, gender, one_item, two_items, five_items)
+    return locale_root['0'] + ' ' + item_forms[2] if amount.zero?
 
-    return into if remaining_amount == 0
-
-    # тысячи
-    into, remaining_amount = compose_ordinal(into, remaining_amount, 2, "тысяча", "тысячи", "тысяч")
-
-    return into if remaining_amount == 0
-
-    # миллионы
-    into, remaining_amount = compose_ordinal(into, remaining_amount, 1, "миллион", "миллиона", "миллионов")
-
-    return into if remaining_amount == 0
+    # единицы
+    into, remaining_amount = compose_ordinal('', amount, gender, item_forms, locale)
+
+    return into if remaining_amount.zero?
+
+    [:thousands, :millions, :billions].each do |type|
+      into, remaining_amount = compose_ordinal(
+        into,
+        remaining_amount,
+        (type == :thousands ? 2 : 1), # пол женский только для тысяч
+        locale_root[type],
+        locale
+      )
+      return into if remaining_amount.zero?
+    end
 
-    # миллиарды
-    into, remaining_amount = compose_ordinal(into, remaining_amount, 1, "миллиард", "миллиарда", "миллиардов")
-    return into
   end
 
   alias_method :rublja, :rublej

data/ru_propisju.gemspec

@@ -0,0 +1,47 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "ru_propisju"
+  s.version = "2.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Julik Tarkhanov"]
+  s.date = "2011-12-19"
+  s.email = "me@julik.nl"
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    "Gemfile",
+    "History.txt",
+    "README.rdoc",
+    "Rakefile",
+    "lib/ru_propisju.rb",
+    "ru_propisju.gemspec",
+    "test/test_ru_propisju.rb"
+  ]
+  s.homepage = "http://github.com/julik/ru_propisju"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.11"
+  s.summary = "C\u{443}\u{43c}\u{43c}\u{430} \u{43f}\u{440}\u{43e}\u{43f}\u{438}\u{441}\u{44c}\u{44e}"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+      s.add_development_dependency(%q<rake>, [">= 0"])
+    else
+      s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<rake>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<rake>, [">= 0"])
+  end
+end
+

data/test/test_ru_propisju.rb

@@ -1,67 +1,114 @@
-# -*- encoding: utf-8 -*- 
+# -*- encoding: utf-8 -*-
 $KCODE = 'u' if RUBY_VERSION < '1.9.0'
 
 require "test/unit"
 require "ru_propisju"
 
 class TestRuPropisju < Test::Unit::TestCase
-  
+
   def test_amount_in_words
     assert_raise(RuPropisju::UnknownCurrency) do
       RuPropisju.amount_in_words(123, "neumelix programmista")
     end
-    
+
+    # russian locale
     assert_equal "сто двадцать три рубля", RuPropisju.amount_in_words(123, :rur)
+    assert_equal "сто двадцать три рубля", RuPropisju.amount_in_words(123, :rub)
     assert_equal "сто двадцать три рубля", RuPropisju.amount_in_words(123, "RUR")
     assert_equal "сто двадцать три рубля", RuPropisju.amount_in_words(123, "rur")
     assert_equal "сто двадцать три гривны", RuPropisju.amount_in_words(123, "uah")
     assert_equal "сто двадцать три евро", RuPropisju.amount_in_words(123, "eur")
     assert_equal "сто двадцать три евро четырнадцать центов", RuPropisju.amount_in_words(123.14, "eur")
     assert_equal "сто двадцать три доллара четырнадцать центов", RuPropisju.amount_in_words(123.14, "usd")
+
+    # ua locale
+    assert_equal "сто двадцять три рубля", RuPropisju.amount_in_words(123, :rur, :ua)
+    assert_equal "сто двадцять три рубля", RuPropisju.amount_in_words(123, :rub, :ua)
+    assert_equal "сто двадцять три рубля", RuPropisju.amount_in_words(123, "RUR", "ua")
+    assert_equal "сто двадцять три рубля", RuPropisju.amount_in_words(123, "rur", "ua")
+    assert_equal "сто двадцять три гривні", RuPropisju.amount_in_words(123, "uah", "ua")
+    assert_equal "сто двадцять три євро", RuPropisju.amount_in_words(123, "eur", "ua")
+    assert_equal "сто двадцять три євро чотирнадцять євроцентів", RuPropisju.amount_in_words(123.14, "eur", :ua)
+    assert_equal "сто двадцять три долара чотирнадцять центів", RuPropisju.amount_in_words(123.14, "usd", :ua)
   end
-  
+
   def test_propisju_dollarov
     assert_equal "сто двадцать один доллар пятьдесят один цент", RuPropisju.dollarov(121.51)
+    assert_equal "сто двадцять один долар п'ятьдесят один цент", RuPropisju.dollarov(121.51, :ua)
   end
-  
+
   def test_propisju_euro
     assert_equal "сто двадцать один евро четыре цента", RuPropisju.evro(121.04)
+    assert_equal "сто двадцять один євро чотири євроцента", RuPropisju.evro(121.04, :ua)
   end
-  
+
   def test_propisju_for_ints
-    assert_equal "пятьсот двадцать три", RuPropisju.propisju(523)
-    assert_equal "шесть тысяч семьсот двадцать семь", RuPropisju.propisju(6727)
+    assert_equal "пятьсот двадцать три", RuPropisju.propisju(523, 1)
+    assert_equal "шесть тысяч семьсот двадцать семь", RuPropisju.propisju(6727, 1)
     assert_equal "восемь миллионов шестьсот пятьдесят два", RuPropisju.propisju(8000652, 1)
     assert_equal "восемь миллионов шестьсот пятьдесят две", RuPropisju.propisju(8000652, 2)
     assert_equal "восемь миллионов шестьсот пятьдесят два", RuPropisju.propisju(8000652, 3)
-    assert_equal "сорок пять", RuPropisju.propisju(45)
-    assert_equal "пять", RuPropisju.propisju(5)
-    assert_equal "шестьсот двенадцать", RuPropisju.propisju(612)
+    assert_equal "сорок пять", RuPropisju.propisju(45, 1)
+    assert_equal "пять", RuPropisju.propisju(5, 1)
+    assert_equal "шестьсот двенадцать", RuPropisju.propisju(612, 1)
+
+
+    # ukrainian locale
+    assert_equal "п'ятьсот двадцять три", RuPropisju.propisju(523, 1, :ua)
+    assert_equal "шість тисяч сімсот двадцять сім", RuPropisju.propisju(6727, 1, :ua)
+    assert_equal "вісім мільйонів шістсот п'ятьдесят два", RuPropisju.propisju(8000652, 1, :ua)
+    assert_equal "вісім мільйонів шістсот п'ятьдесят дві", RuPropisju.propisju(8000652, 2, :ua)
+    assert_equal "вісім мільйонів шістсот п'ятьдесят два", RuPropisju.propisju(8000652, 3, :ua)
+    assert_equal "сорок п'ять", RuPropisju.propisju(45, 1, :ua)
+    assert_equal "п'ять", RuPropisju.propisju(5, 1, :ua)
+    assert_equal "шістсот дванадцять", RuPropisju.propisju(612, 1, :ua)
+
   end
-  
+
   def test_propisju_shtuk
-    assert_equal "шесть целых", RuPropisju.propisju_shtuk(6, 2, "целая", "целых", "целых")
-    assert_equal "двадцать пять колес", RuPropisju.propisju_shtuk(25, 3, "колесо", "колеса", "колес")
-    assert_equal "двадцать одна подстава", RuPropisju.propisju_shtuk(21, 2, "подстава", "подставы", "подстав")    
-    assert_equal "двести двенадцать сволочей", RuPropisju.propisju_shtuk(212.00, 2, "сволочь", "сволочи", "сволочей")
-    assert_equal "двести двенадцать целых четыре десятых куска", RuPropisju.propisju_shtuk(212.40, 2, "кусок", "куска", "кусков")
+    assert_equal "шесть целых", RuPropisju.propisju_shtuk(6, 2, ["целая", "целых", "целых"])
+    assert_equal "двадцать пять колес", RuPropisju.propisju_shtuk(25, 3, ["колесо", "колеса", "колес"])
+    assert_equal "двадцать одна подстава", RuPropisju.propisju_shtuk(21, 2, ["подстава", "подставы", "подстав"])
+    assert_equal "двести двенадцать сволочей", RuPropisju.propisju_shtuk(212.00, 2, ["сволочь", "сволочи", "сволочей"])
+    assert_equal "двести двенадцать целых четыре десятых куска", RuPropisju.propisju_shtuk(212.40, 2, ["кусок", "куска", "кусков"])
+
+    # ua locale
+    assert_equal "шість цілих", RuPropisju.propisju_shtuk(6, 2, ["ціла", "цілих", "цілих"], :ua)
+    assert_equal "двадцять п'ять колес", RuPropisju.propisju_shtuk(25, 3, ["колесо", "колеса", "колес"], :ua)
+    assert_equal "двадцять одна підстава", RuPropisju.propisju_shtuk(21, 2, ["підстава", "підстави", "підстав"], :ua)
+    assert_equal "двісті дванадцять наволочів", RuPropisju.propisju_shtuk(212.00, 2, ["наволоч", "наволочі", "наволочів"], :ua)
+    assert_equal "двісті дванадцять цілих чотири десятих шматка", RuPropisju.propisju_shtuk(212.40, 2, ["шматок", "шматка", "шматків"], :ua)
   end
-  
+
   def test_propisju_for_floats
-    assert_equal "шесть целых пять десятых", RuPropisju.propisju(6.50)
-    assert_equal "триста сорок одна целая девять десятых", RuPropisju.propisju(341.9)
-    assert_equal "триста сорок одна целая двести сорок пять тысячных", RuPropisju.propisju(341.245)
-    assert_equal "двести три целых сорок одна сотая", RuPropisju.propisju(203.41)
-    assert_equal "четыреста сорок две целых пять десятых", RuPropisju.propisju(442.50000)
+    assert_equal "шесть целых пять десятых", RuPropisju.propisju(6.50, 1)
+    assert_equal "триста сорок одна целая девять десятых", RuPropisju.propisju(341.9, 1)
+    assert_equal "триста сорок одна целая двести сорок пять тысячных", RuPropisju.propisju(341.245, 1)
+    assert_equal "двести три целых сорок одна сотая", RuPropisju.propisju(203.41, 1)
+    assert_equal "четыреста сорок две целых пять десятых", RuPropisju.propisju(442.50000, 1)
+    # ua locale
+    assert_equal "шість цілих п'ять десятих", RuPropisju.propisju(6.50, 1, :ua)
+    assert_equal "триста сорок одна ціла дев'ять десятих", RuPropisju.propisju(341.9, 1, :ua)
+    assert_equal "триста сорок одна ціла двісті сорок п'ять тисячних", RuPropisju.propisju(341.245, 1, :ua)
+    assert_equal "двісті три цілих сорок одна сота", RuPropisju.propisju(203.41, 1, :ua)
+    assert_equal "чотиреста сорок дві цілих п'ять десятих", RuPropisju.propisju(442.50000, 1, :ua)
+
   end
-  
+
   def test_choose_plural
-    assert_equal "чемодана", RuPropisju.choose_plural(523, "чемодан", "чемодана", "чемоданов")
-    assert_equal "партий", RuPropisju.choose_plural(6727, "партия", "партии", "партий")
-    assert_equal "козлов", RuPropisju.choose_plural(45, "козел", "козла", "козлов")
-    assert_equal "колес", RuPropisju.choose_plural(260, "колесо", "колеса", "колес")
+    assert_equal "чемодана", RuPropisju.choose_plural(523, ["чемодан", "чемодана", "чемоданов"])
+    assert_equal "партий", RuPropisju.choose_plural(6727, ["партия", "партии", "партий"])
+    assert_equal "козлов", RuPropisju.choose_plural(45, ["козел", "козла", "козлов"])
+    assert_equal "колес", RuPropisju.choose_plural(260, ["колесо", "колеса", "колес"])
+
+    # ua locale
+
+    assert_equal "валізи", RuPropisju.choose_plural(523, ["валіза", "валізи", "валіз"])
+    assert_equal "партій", RuPropisju.choose_plural(6727, ["партія", "партії", "партій"])
+    assert_equal "козлів", RuPropisju.choose_plural(45, ["козел", "козла", "козлів"])
+    assert_equal "колес", RuPropisju.choose_plural(260, ["колесо", "колеса", "колес"])
   end
-  
+
   def test_rublej
     assert_equal "сто двадцать три рубля", RuPropisju.rublej(123)
     assert_equal "триста сорок три рубля 20 копеек", RuPropisju.rublej(343.20)
@@ -69,8 +116,16 @@ class TestRuPropisju < Test::Unit::TestCase
     assert_equal "триста тридцать два рубля", RuPropisju.rublej(331.995)
     assert_equal "один рубль", RuPropisju.rubl(1)
     assert_equal "три рубля 14 копеек", RuPropisju.rublja(3.14)
+
+    # ua locale
+    assert_equal "сто двадцять три рубля", RuPropisju.rublej(123, :ua)
+    assert_equal "триста сорок три рубля 20 копійок", RuPropisju.rublej(343.20, :ua)
+    assert_equal "42 копійки", RuPropisju.rublej(0.4187, :ua)
+    assert_equal "триста тридцять два рубля", RuPropisju.rublej(331.995, :ua)
+    assert_equal "один рубль", RuPropisju.rubl(1, :ua)
+    assert_equal "три рубля 14 копійок", RuPropisju.rublja(3.14, :ua)
   end
-  
+
   def test_griven
     assert_equal "сто двадцать три гривны", RuPropisju.griven(123)
     assert_equal "сто двадцать четыре гривны", RuPropisju.griven(124)
@@ -79,13 +134,28 @@ class TestRuPropisju < Test::Unit::TestCase
     assert_equal "триста тридцать две гривны", RuPropisju.griven(331.995)
     assert_equal "одна гривна", RuPropisju.grivna(1)
     assert_equal "три гривны четырнадцать копеек", RuPropisju.grivny(3.14)
+    # ua locale
+    assert_equal "сто двадцять три гривні", RuPropisju.griven(123, :ua)
+    assert_equal "сто двадцять чотири гривні", RuPropisju.griven(124, :ua)
+    assert_equal "триста сорок три гривні двадцять копійок", RuPropisju.griven(343.20, :ua)
+    assert_equal "сорок дві копійки", RuPropisju.griven(0.4187, :ua)
+    assert_equal "триста тридцять дві гривні", RuPropisju.griven(331.995, :ua)
+    assert_equal "одна гривня", RuPropisju.grivna(1, :ua)
+    assert_equal "три гривні чотирнадцять копійок", RuPropisju.grivny(3.14, :ua)
+
   end
-  
+
   def test_kopeek
     assert_equal "сто двадцать три рубля", RuPropisju.kopeek(12300)
     assert_equal "три рубля 14 копеек", RuPropisju.kopeek(314)
     assert_equal "32 копейки", RuPropisju.kopeek(32)
     assert_equal "21 копейка", RuPropisju.kopeika(21)
     assert_equal "3 копейки", RuPropisju.kopeiki(3)
+    # ua locale
+    assert_equal "сто двадцять три рубля", RuPropisju.kopeek(12300, :ua)
+    assert_equal "три рубля 14 копійок", RuPropisju.kopeek(314, :ua)
+    assert_equal "32 копійки", RuPropisju.kopeek(32, :ua)
+    assert_equal "21 копійка", RuPropisju.kopeika(21, :ua)
+    assert_equal "3 копійки", RuPropisju.kopeiki(3, :ua)
   end
 end

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ru_propisju
 version: !ruby/object:Gem::Version
-  version: !binary |-
-    MS4yLjA=
+  version: 2.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,55 +9,49 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-15 00:00:00.000000000 Z
+date: 2011-12-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: hoe
-  requirement: &2590690 !ruby/object:Gem::Requirement
+  name: jeweler
+  requirement: &10698430 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: '2.12'
+        version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2590690
-description: !binary |-
-  0JLRi9Cy0L7QtNC40YIg0YHRg9C80LzRgyDQv9GA0L7Qv9C40YHRjNGOINC4
-  INGB0YPQvNC80Ysg0LrQvtC/0LXQtdC6LCDRgNGD0LHQu9C10Lkg0Lgg0LPR
-  gNC40LLQtdC9LiDQn9C+0LzQvtCz0LDQtdGCINCyINCy0YvQsdC+0YDQtSDQ
-  v9GA0LDQstC40LvRjNC90L7Qs9C+INGH0LjRgdC70LjRgtC10LvRjNC90L7Q
-  s9C+Lg==
-email:
-- me@julik.nl
+  version_requirements: *10698430
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &10698180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *10698180
+description: 
+email: me@julik.nl
 executables: []
 extensions: []
 extra_rdoc_files:
-- !binary |-
-  SGlzdG9yeS50eHQ=
-- !binary |-
-  TWFuaWZlc3QudHh0
 - README.rdoc
 files:
-- !binary |-
-  SGlzdG9yeS50eHQ=
-- !binary |-
-  TWFuaWZlc3QudHh0
-- !binary |-
-  UkVBRE1FLnJkb2M=
-- !binary |-
-  UmFrZWZpbGU=
-- !binary |-
-  bGliL3J1X3Byb3Bpc2p1LnJi
-- !binary |-
-  dGVzdC90ZXN0X3J1X3Byb3Bpc2p1LnJi
-- .gemtest
+- Gemfile
+- History.txt
+- README.rdoc
+- Rakefile
+- lib/ru_propisju.rb
+- ru_propisju.gemspec
+- test/test_ru_propisju.rb
 homepage: http://github.com/julik/ru_propisju
-licenses: []
+licenses:
+- MIT
 post_install_message: 
-rdoc_options:
-- --main
-- README.rdoc
+rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
@@ -74,13 +67,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: ru_propisju
-rubygems_version: 1.8.5
+rubyforge_project: 
+rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
-summary: !binary |-
-  0JLRi9Cy0L7QtNC40YIg0YHRg9C80LzRgyDQv9GA0L7Qv9C40YHRjNGOINC4
-  INGB0YPQvNC80Ysg0LrQvtC/0LXQtdC6LCDRgNGD0LHQu9C10Lkg0Lgg0LPR
-  gNC40LLQtdC9
-test_files:
-- test/test_ru_propisju.rb
+summary: Cумма прописью
+test_files: []

data/Manifest.txt

@@ -1,6 +0,0 @@
-History.txt
-Manifest.txt
-README.rdoc
-Rakefile
-lib/ru_propisju.rb
-test/test_ru_propisju.rb