to_russian_words 1.1.3 → 1.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 76a4e11c1c88b6b6314f0aa1a3799fd43b505e7b
-  data.tar.gz: d4eaac1f43767afe425ec5eb99c570e32ce7d930
+SHA256:
+  metadata.gz: 2fa00e231f37cc6a9c17b4992c265f20989aed5bca7e308fb015bfabc8c97c44
+  data.tar.gz: f700e3f291646f2829c0b23de72469adfa7e0c2257563b2dbee07b76e6d42c44
 SHA512:
-  metadata.gz: b69998d59c7a3e8327eda7a716be631aba75ec7db9a73663fade52d9516225fbeffd74b65221a1eaddfcb6c17e83cccdf93f4323845aec88557e4db59f829db9
-  data.tar.gz: 7a0545fba7c84714b0602e9cbc0348f55430e0133b232e18ac7f8d6316526c2bc10c5854ff39a1893fcb5a40fff08b5acb4b8c8a1f56b0c24742e57fdb0d69c9
+  metadata.gz: 95bc1539e7e55acf0566d85a88f43d8c68b90c3ba0f8c3c3fd1fccdcb101ad15708fd968e25e20a3569e6aa8b02cddf2ef48608b7d01fca936d957453dec2634
+  data.tar.gz: cd595886dd1c316a73153b1fa790d18a25e27e3a2081698a5e824279348fafc10f409139dfd3238aa93be14776ea32c855a7ae069b2d22bebb3d65c852c182b9

data/.rubocop.yml

@@ -1,8 +1,6 @@
 AllCops:
   TargetRubyVersion: 2.3
   UseCache: false
-Style/BracesAroundHashParameters:
-  EnforcedStyle: context_dependent
 Style/CollectionMethods:
   Description: Preferred collection methods.
   StyleGuide: https://github.com/bbatsov/ruby-style-guide#map-find-select-reduce-size
@@ -21,7 +19,7 @@ Style/DotPosition:
   SupportedStyles:
   - leading
   - trailing
-Style/FileName:
+Naming/FileName:
   Description: Use snake_case for source file names.
   StyleGuide: https://github.com/bbatsov/ruby-style-guide#snake-case-files
   Enabled: false
@@ -35,7 +33,8 @@ Style/IfUnlessModifier:
   Description: Favor modifier if/unless usage when you have a single-line body.
   StyleGuide: https://github.com/bbatsov/ruby-style-guide#if-as-a-modifier
   Enabled: false
-  MaxLineLength: 80
+Layout/LineLength:
+  Max: 120
 Style/OptionHash:
   Description: Don't use option hashes when you can use keyword arguments.
   Enabled: false
@@ -61,8 +60,10 @@ Style/PredicateName:
   - is_
   - has_
   - have_
+  - does_
   NamePrefixBlacklist:
   - is_
+  - does_
   Exclude:
   - spec/**/*
 Style/RaiseArgs:
@@ -114,7 +115,15 @@ Style/StringLiteralsInInterpolation:
   SupportedStyles:
   - single_quotes
   - double_quotes
-Style/TrailingCommaInLiteral:
+Style/TrailingCommaInArrayLiteral:
+  Description: Checks for trailing comma in parameter lists and literals.
+  StyleGuide: https://github.com/bbatsov/ruby-style-guide#no-trailing-array-commas
+  Enabled: false
+  EnforcedStyleForMultiline: no_comma
+  SupportedStyles:
+  - comma
+  - no_comma
+Style/TrailingCommaInHashLiteral:
   Description: Checks for trailing comma in parameter lists and literals.
   StyleGuide: https://github.com/bbatsov/ruby-style-guide#no-trailing-array-commas
   Enabled: false
@@ -167,7 +176,7 @@ Lint/AssignmentInCondition:
 Style/InlineComment:
   Description: Avoid inline comments.
   Enabled: false
-Style/AccessorMethodName:
+Naming/AccessorMethodName:
   Description: Check the naming of accessor methods for get_/set_.
   Enabled: false
 Style/Alias:
@@ -221,11 +230,11 @@ Style/WhenThen:
 Lint/EachWithObjectArgument:
   Description: Check for immutable argument given to each_with_object.
   Enabled: true
-Lint/HandleExceptions:
+Lint/SuppressedException:
   Description: Don't suppress exception.
   StyleGuide: https://github.com/bbatsov/ruby-style-guide#dont-hide-exceptions
   Enabled: false
-Lint/LiteralInCondition:
+Lint/LiteralAsCondition:
   Description: Checks of literals used in conditions.
   Enabled: false
 Lint/LiteralInInterpolation:

data/.tool-versions

@@ -0,0 +1 @@
+ruby 3.1.2

data/Gemfile

@@ -3,4 +3,4 @@ source "https://rubygems.org"
 
 # Specify your gem's dependencies in to_russian_words.gemspec
 gem "coveralls", require: false
-gemspec
+gemspec

data/lib/to_russian_words/divisions.rb

@@ -1,24 +1,25 @@
 # frozen_string_literal: true
+
 module ToRussianWords
   module Divisions
     NOMINATIVE_DIVISIONS = [
-      ([''] * 10),
-      ['', 'тысяча', (['тысячи'] * 3),  (['тысяч'] * 5)].flatten,
-      ['', 'миллион', (['миллиона'] * 3),  (['миллионов'] * 5)].flatten,
-      ['', 'миллиард', (['миллиарда'] * 3),  (['миллиардов'] * 5)].flatten,
-      ['', 'триллион', (['триллиона'] * 3),  (['триллионов'] * 5)].flatten,
-      ['', 'квадрильон', (['квадрильона'] * 3),  (['квадрильонов'] * 5)].flatten,
-      ['', 'нониллион', (['нониллиона'] * 3),  (['нониллионов'] * 5)].flatten
+      ["", "", ""].freeze,
+      %w(тысяча тысячи тысяч).freeze,
+      %w(миллион миллиона миллионов).freeze,
+      %w(миллиард миллиарда миллиардов).freeze,
+      %w(триллион триллиона триллионов).freeze,
+      %w(квадрильон квадрильона квадрильонов).freeze,
+      %w(нониллион нониллиона нониллионов).freeze
     ].freeze
 
     DATIVE_DIVISIONS = [
-      ([''] * 10),
-      ['', 'тысячи', (['тысяч'] * 8)].flatten,
-      ['', 'миллиона', (['миллионов'] * 8)].flatten,
-      ['', 'миллиарда', (['миллиардов'] * 8)].flatten,
-      ['', 'триллиона', (['триллионов'] * 8)].flatten,
-      ['', 'квадрильона', (['квадрильонов'] * 8)].flatten,
-      ['', 'нониллиона', (['нониллионов'] * 8)].flatten,
+      ["", "", ""].freeze,
+      %w(тысячи тысяч тысяч).freeze,
+      %w(миллиона миллионов миллионов).freeze,
+      %w(миллиарда миллиардов миллиардов).freeze,
+      %w(триллиона триллионов триллионов).freeze,
+      %w(квадрильона квадрильонов квадрильонов).freeze,
+      %w(нониллиона нониллионов нониллионов).freeze
     ].freeze
   end
 end

data/lib/to_russian_words/russian_gender_labels.rb

@@ -1,12 +1,65 @@
 # frozen_string_literal: true
+
 module ToRussianWords
   module RussianGenderLabels
-    NOMINATIVE_RUSSIAN_FEMALE_LABEL = [
-      '', 'одна', 'две'
-    ].freeze
+    NOMINATIVE_RUSSIAN_FEMALE_LABEL = {
+      1 => "одна",
+      2 => "две",
+
+      21 => "двадцать одна",
+      22 => "двадцать две",
+
+      31 => "тридцать одна",
+      32 => "тридцать две",
+
+      41 => "сорок одна",
+      42 => "сорок две",
+
+      51 => "пятьдесят одна",
+      52 => "пятьдесят две",
+
+      61 => "шестьдесят одна",
+      62 => "шестьдесят две",
+
+      71 => "семьдесят одна",
+      72 => "семьдесят две",
+
+      81 => "восемьдесят одна",
+      82 => "восемьдесят две",
+
+      91 => "девяносто одна",
+      92 => "девяносто две",
+
+    }.freeze
+
+    DATIVE_RUSSIAN_FEMALE_LABEL = {
+      0 => "",
+      1 => "одной",
+      2 => "двух",
+
+      21 => "двадцати одной",
+      22 => "двадцати двух",
+
+      31 => "тридцати одной",
+      32 => "тридцати двух",
+
+      41 => "сорока одной",
+      42 => "сорока двух",
+
+      51 => "пятидесяти одной",
+      52 => "пятидесяти двух",
+
+      61 => "шестидесяти одной",
+      62 => "шестидесяти двух",
+
+      71 => "семидесяти одной",
+      72 => "семидесяти двух",
+
+      81 => "восьмидесяти одной",
+      82 => "восьмидесяти двух",
 
-    DATIVE_RUSSIAN_FEMALE_LABEL = [
-      '', 'одной', 'двух'
-    ].freeze
+      91 => "девяноста одной",
+      92 => "девяноста двух",
+    }.freeze
   end
 end

data/lib/to_russian_words/utils.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
-require_relative './under_hundred.rb'
-require_relative "./divisions.rb"
-require_relative "./russian_gender_labels.rb"
+
+require_relative "./under_hundred"
+require_relative "./divisions"
+require_relative "./russian_gender_labels"
 module ToRussianWords
   module Utils
     include UnderHundred
@@ -10,41 +11,74 @@ module ToRussianWords
 
     def result_below_one_thousand(num, counter, russian_case)
       hundred, remaining = num.divmod(100)
-
       return higher_than_hundred(hundred, remaining, counter, russian_case) if hundred != 0
-      under_hundred(russian_case, counter == 1 ? num : nil)[remaining] if hundred == 0 && remaining != 0
+
+      if hundred == 0 && remaining != 0
+        get_label(russian_case: russian_case, hundred: counter == 1 ? num : nil, counter: counter,
+                  remaining: remaining)
+      end
     end
 
     def higher_than_hundred(hundred, remaining, counter, russian_case)
-      century = (hundred == 1 ? '' : under_hundred(russian_case, hundred)[hundred])
+      century = (hundred == 1 ? "" : get_label(russian_case: russian_case, hundred: hundred, remaining: hundred))
       if remaining != 0
-        return century + "#{hundred_name(hundred, russian_case)} " + under_hundred(russian_case)[remaining]
+        return century + "#{hundred_name(hundred,
+                                         russian_case)} " + get_label(russian_case: russian_case, counter: counter,
+                                                                      remaining: remaining)
       end
-      return century + "#{hundred_name(hundred, russian_case)} " if remaining == 0
+      century + "#{hundred_name(hundred, russian_case)} " if remaining == 0
     end
 
     def check_sign(num)
-      num < 0 ? [num.abs, 'negative '] : [num, '']
+      num < 0 ? [num.abs, "negative "] : [num, ""]
     end
 
     def numerical?(num)
       Integer(num)
-    rescue
-      raise 'A whole number is expected'
+    rescue StandardError
+      raise "A whole number is expected"
     end
 
-    def under_hundred(russian_case, hundred = 0)
+    def under_hundred(russian_case, hundred = 0, counter = 0)
       case russian_case
-      when 'dative'
-        [1, 2].include?(hundred) ? DATIVE_RUSSIAN_FEMALE_LABEL : DATIVE_UNDER_HUNDRED
+      when "dative"
+        if [1, 2].include?(hundred)
+          [DATIVE_RUSSIAN_FEMALE_LABEL, DATIVE_UNDER_HUNDRED]
+        else
+          (
+                if counter == 1
+                  [DATIVE_RUSSIAN_FEMALE_LABEL, DATIVE_UNDER_HUNDRED]
+                else
+                  [DATIVE_UNDER_HUNDRED, DATIVE_UNDER_HUNDRED]
+                end
+              )
+        end
+
       else
-        [1, 2].include?(hundred) ? NOMINATIVE_RUSSIAN_FEMALE_LABEL : NOMINATIVE_UNDER_HUNDRED
+        if [1, 2].include?(hundred)
+          [NOMINATIVE_RUSSIAN_FEMALE_LABEL, NOMINATIVE_UNDER_HUNDRED]
+        else
+          (
+                if counter == 1
+                  [NOMINATIVE_RUSSIAN_FEMALE_LABEL, NOMINATIVE_UNDER_HUNDRED]
+                else
+                  [NOMINATIVE_UNDER_HUNDRED, NOMINATIVE_UNDER_HUNDRED]
+                end
+              )
+        end
       end
     end
 
+    def get_label(russian_case:, remaining:, hundred: 0, counter: 0)
+      female, male = under_hundred(russian_case, hundred, counter)
+      res = female[remaining]
+      res = male[remaining] if res.nil?
+      res
+    end
+
     def divisions(russian_case)
       case russian_case
-      when 'dative'
+      when "dative"
         DATIVE_DIVISIONS
       else
         NOMINATIVE_DIVISIONS
@@ -53,23 +87,40 @@ module ToRussianWords
 
     def hundred_name(hundred, russian_case)
       case russian_case
-      when 'dative'
+      when "dative"
         if hundred == 1
-          'ста'
+          "ста"
         else
-          'сот'
+          "сот"
         end
       else
-        if [1, 4].include? hundred
-          'сто'
+        if [1].include? hundred
+          "сто"
         elsif hundred == 2
-          'сти'
-        elsif hundred == 3
-          'ста'
+          "сти"
+        elsif [3, 4].include?(hundred)
+          "ста"
         else
-          'сот'
+          "сот"
         end
       end
     end
+
+    def get_division(russian_case, counter, remaining)
+      # binding.pry
+      variants = divisions(russian_case)[counter]
+      pluralize(remaining, *variants)
+    end
+
+    def pluralize(number, singular, few, plural)
+      number = number.abs
+      return plural if (11..14).include?(number % 100)
+
+      case number % 10
+      when 1 then singular
+      when 2..4 then few
+      else plural
+      end
+    end
   end
 end

data/lib/to_russian_words/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module ToRussianWords
-  VERSION = '1.1.3'
+  VERSION = '1.1.5'
 end

data/lib/to_russian_words.rb

@@ -1,31 +1,33 @@
 # frozen_string_literal: true
+
 module ToRussianWords
-  require 'to_russian_words/version'
-  require_relative './to_russian_words/under_hundred.rb'
-  require_relative './to_russian_words/divisions.rb'
-  require_relative './to_russian_words/utils.rb'
+  require "to_russian_words/version"
+  require_relative "./to_russian_words/under_hundred"
+  require_relative "./to_russian_words/divisions"
+  require_relative "./to_russian_words/utils"
 
   include ToRussianWords::UnderHundred
   include ToRussianWords::Divisions
   include ToRussianWords::Utils
 
-  def to_words(russian_case = 'nominative')
+  def to_words(russian_case = "nominative")
     to_russian_words(russian_case)
   end
 
-  def to_russian_words(russian_case = 'nominative')
+  def to_russian_words(russian_case = "nominative")
     num = numerical?(self)
     num, sign = check_sign(num)
-    return (sign + under_hundred(russian_case)[num]) if num <= 100
+    return (sign + get_label(russian_case: russian_case, remaining: num)) if num <= 100
+
     counter = 0
     result = []
     while num != 0
       num, remaining = num.divmod(1000)
       temp_result = result_below_one_thousand(remaining, counter, russian_case)
-      result << temp_result + ' ' + divisions(russian_case)[counter][remaining.to_s.last.to_i] if temp_result
+      result << temp_result + " " + get_division(russian_case, counter, remaining) if temp_result
       counter += 1
     end
-    sign + result.reverse.join(' ').rstrip
+    sign + result.reverse.join(" ").rstrip
   end
 end
 

data/spec/spec_helper.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
+
 require "coveralls"
 Coveralls.wear!
-$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
 require "to_russian_words"
 require "pry"
+
 RSpec.configure do |config|
   config.expect_with :rspec do |expectations|
     expectations.include_chain_clauses_in_custom_matcher_descriptions = true

data/spec/to_russiam_words_spec.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
+
 require_relative "spec_helper"
 RSpec.describe "to_russian_word" do
   context "#to_word" do
-    it "converts 1 to `one`" do
+    it "converts 1 to `один`" do
       expect(1.to_russian_words).to eq("один")
     end
 
-    it "converts '1' to `one`" do
+    it "converts '1' to `один`" do
       expect("1".to_russian_words).to eq("один")
     end
 
@@ -22,5 +23,58 @@ RSpec.describe "to_russian_word" do
       # Fixnum before Ruby 2.4, Integer from Ruby 2.4
       expect(1.methods).to include :to_russian_words
     end
+
+    it "converts 123 to `сто двадцать три`" do
+      expect(123.to_russian_words).to eq("сто двадцать три")
+    end
+
+    it "converts 1234 to `одна тысяча двести тридцать четыре`" do
+      expect(1234.to_russian_words).to eq("одна тысяча двести тридцать четыре")
+    end
+
+    it "converts 12345 to `двенадцать тысяч триста сорок пять`" do
+      expect(12_345.to_russian_words).to eq("двенадцать тысяч триста сорок пять")
+    end
+
+    it "converts 122456 to `сто двадцать две тысячи четыреста пятьдесят шесть`" do
+      expect(122_456.to_russian_words).to eq("сто двадцать две тысячи четыреста пятьдесят шесть")
+    end
+    it "converts 41234 to `сорок одна тысяча двести тридцать четыре`" do
+      expect(41_234.to_russian_words).to eq("сорок одна тысяча двести тридцать четыре")
+    end
+
+    it "converts 42234 to `сорок две тысячи двести тридцать четыре`" do
+      expect(42_234.to_russian_words).to eq("сорок две тысячи двести тридцать четыре")
+    end
+
+    it "converts 21021021 to `двадцать один миллион двадцать одна тысяча двадцать один`" do
+      expect(21_021_021.to_russian_words).to eq("двадцать один миллион двадцать одна тысяча двадцать один")
+    end
+
+    it "converts 2021021 to `два миллиона двадцать одна тысяча двадцать один`" do
+      expect(2_021_021.to_russian_words).to eq("два миллиона двадцать одна тысяча двадцать один")
+    end
+  end
+
+  context "#to_words('dative')" do
+    it "converts 20 to 'двадцати'" do
+      expect(20.to_russian_words("dative")).to eq("двадцати")
+    end
+    it "converts 21 to 'двадцати одного'" do
+      expect(21.to_russian_words("dative")).to eq("двадцати одного")
+    end
+    it "converts 22 to 'двадцати двух'" do
+      expect(22.to_russian_words("dative")).to eq("двадцати двух")
+    end
+    it "converts 23 to 'двадцати трех'" do
+      expect(23.to_russian_words("dative")).to eq("двадцати трех")
+    end
+    it 'converts 21021021 to "двадцати одного миллиона двадцати одной тысячи двадцати одного"' do
+      expect(21_021_021.to_russian_words("dative")).to eq("двадцати одного миллиона двадцати одной тысячи двадцати одного")
+    end
+
+    it 'converts 12012012 to "двенадцати миллионов двенадцати тысяч двенадцати"' do
+      expect(12_012_012.to_russian_words("dative")).to eq("двенадцати миллионов двенадцати тысяч двенадцати")
+    end
   end
 end

data/spec/to_russian_words/division_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative "../spec_helper"
 RSpec.describe "DIVISIONS" do
   let(:subject) do
@@ -12,10 +13,14 @@ RSpec.describe "DIVISIONS" do
   end
 
   it "has '' at index 0" do
-    expect(subject[0]).to eq ""
+    expect(subject[0][0]).to eq ""
   end
 
   it "is expected to be frozen" do
     expect(subject.frozen?).to be true
   end
+
+  it "is expected to be frozen" do
+    expect(subject[0].frozen?).to be true
+  end
 end

data/to_russian_words.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rubocop"
   spec.add_development_dependency "rspec"

metadata

@@ -1,29 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: to_russian_words
 version: !ruby/object:Gem::Version
-  version: 1.1.3
+  version: 1.1.5
 platform: ruby
 authors:
 - Vasiliy Gandzha
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-28 00:00:00.000000000 Z
+date: 2025-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -90,6 +89,7 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
+- ".tool-versions"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -109,7 +109,6 @@ homepage: https://github.com/VasiliyG/to_russian_words
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -124,9 +123,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.8
-signing_key: 
+rubygems_version: 3.6.2
 specification_version: 4
 summary: This would convert numbers into russian words.
 test_files: