Module: RuNumerals

Defined in:
lib/version.rb,
lib/ru_numerals.rb

Constant Summary collapse

VERSION =

RuNumerals version

'1.0.2'
RUBGRAM =

Грамматика слова “рубль”

"мн|рубль|рубля|рублю|рубль|рублём|рубле|рубли|рублей|рублям|рубли|рублями|рублях"
KOPGRAM =

Грамматика слова “копейка”

"жн|копейка|копейки|копейке|копейку|копейкой|копейке|копейки|копеек|копейкам|копейки|копейками|копейках"
DOLLARGRAM =

Грамматика слова “доллар”

"мн|доллар|доллара|доллару|доллар|долларом|долларе|доллары|долларов|долларам|доллары|долларами|долларах"
CENTGRAM =

Грамматика слова “цент”

"мн|цент|цента|центу|цент|центом|центе|центы|центов|центам|центы|центами|центах"
EUROGRAM =

Грамматика слова “евро”

"мн|евро|евро|евро|евро|евро|евро|евро|евро|евро|евро|евро|евро"
EUROCENTGRAM =

Грамматика слова “евроцент”

"мн|евроцент|евроцента|евроценту|евроцент|евроцентом|евроценте|евроценты|евроцентов|евроцентам|евроценты|евроцентами|центах"

Class Method Summary collapse

Class Method Details

.extend(cls, *methods) ⇒ nil

Добавляет метод или методы RuNumerals классу. Если опции не указаны, то классу добавляются все подходящие функции.

Examples:


RuNumerals::extend(Integer)                 #=> nil
1.ru_numeral                                #=> "один"
1.ru_ordinal("д")                           #=> "первому"
RuNumerals::extend(Float,:ru_rubleskopecks) #=> nil
1.25.ru_rubleskopecks("и",:nospellkop)      #=> "один рубль 25 копеек"

Parameters:

  • cls (Class) —

    объект для преобразования

  • methods (Array) —

    методы

    • :ru_numeral (Symbol) - добавить метод ru_numeral (только для Integer)

    • :ru_ordinal (Symbol) - добавить метод ru_ordinal (только для Integer)

    • :ru_date (Symbol) - добавить метод ru_date (только для Time)

    • :ru_time (Symbol) - добавить метод ru_time (только для Time)

    • :ru_fractional (Symbol) - добавить метод ru_fractional (только для Float и Rational)

    • :ru_money (Symbol) - добавить метод ru_money (только для Float)

    • :ru_rubles (Symbol) - добавить метод ru_rubles (только для Float)

    • :ru_kopecks (Symbol) - добавить метод ru_kopecks (только для Float)

    • :ru_rubleskopecks (Symbol) - добавить метод ru_rubleskopecks (только для Float)

    • :ru_dollars (Symbol) - добавить метод ru_dollars (только для Float)

    • :ru_cents (Symbol) - добавить метод ru_cents (только для Float)

    • :ru_dollarscents (Symbol) - добавить метод ru_dollarscents (только для Float)

    • :ru_euros (Symbol) - добавить метод ru_euros (только для Float)

    • :ru_eurocents (Symbol) - добавить метод ru_eurocents (только для Float)

    • :ru_euroseurocents (Symbol) - добавить метод ru_euroseurocents (только для Float)

Returns:

  • (nil)

Raises:

  • (ArgumentError) 


844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
 
# File 'lib/ru_numerals.rb', line 844

def extend(cls,*methods)
  if ( cls.class != Class ) then
    raise ArgumentError, %Q/Argument must be Class, current argument class is "#{cls.Class}, "/, caller
  end
  if not EXTEND_MAP.keys.include?(cls) then
    raise ArgumentError, %Q/Class "#{cls}" is not supported/, caller
  end
  if methods.nil? or methods.empty? then
    all_methods=true
  else
    all_methods=false
    methods.each do |i|
      if not EXTEND_MAP[cls].include?(i) then
        raise ArgumentError, %Q/Method "#{i}" is not supported for class "#{cls}"/, caller
      end
    end
  end
  methods_to_ext= (all_methods ? EXTEND_MAP[cls] : methods)
  methods_to_ext.each do |i|
    case i 
      when :ru_numeral then
        cls.send(:define_method,i) do |gr_casus='и', grammar='мн', min_order=0|
          RuNumerals::ru_numeral(self, gr_casus, grammar, min_order)
        end
      when :ru_ordinal then
        cls.send(:define_method,i) do |gr_casus='и', grammar='мн', plural=false|
          RuNumerals::ru_ordinal(self, gr_casus, grammar, plural)
        end
      when :ru_money then
        cls.send(:define_method,i) do |gr_casus='и', r_gram=nil,k_gram=nil, **opts|
          RuNumerals::ru_money(self, gr_casus,r_gram,k_gram,opts)
        end
      when :ru_date then
        cls.send(:define_method,i) do |gr_casus='и', **opts|
          RuNumerals::ru_date(self, gr_casus, opts)
        end           
      when :ru_time then
        cls.send(:define_method,i) do |gr_casus='и', **opts|
          RuNumerals::ru_time(self, gr_casus, opts)
        end           
      when :ru_rubles then
        cls.send(:define_method,i) do |gr_casus='и', **opts|
          RuNumerals::ru_rubles(self, gr_casus, opts)
        end           
      when :ru_kopecks then
        cls.send(:define_method,i) do |gr_casus='и', **opts|
          RuNumerals::ru_kopecks(self, gr_casus, opts)
        end           
      when :ru_rubleskopecks then
        cls.send(:define_method,i) do |gr_casus='и', **opts|
          RuNumerals::ru_rubleskopecks(self, gr_casus, opts)
        end           
      when :ru_dollars then
        cls.send(:define_method,i) do |gr_casus='и', **opts|
          RuNumerals::ru_dollars(self, gr_casus, opts)
        end           
      when :ru_cents
        cls.send(:define_method,i) do |gr_casus='и', **opts|
          RuNumerals::ru_cents(self, gr_casus, opts)
        end           
      when :ru_dollarscents then
        cls.send(:define_method,i) do |gr_casus='и', **opts|
          RuNumerals::ru_dollarscents(self, gr_casus, opts)
        end           
      when :ru_euros then
        cls.send(:define_method,i) do |gr_casus='и', **opts|
          RuNumerals::ru_euros(self, gr_casus, opts)
        end           
      when :ru_eurocents then
        cls.send(:define_method,i) do |gr_casus='и', **opts|
          RuNumerals::ru_eurocents(self, gr_casus, opts)
        end           
      when :ru_euroseurocents then
        cls.send(:define_method,i) do |gr_casus='и', **opts|
          RuNumerals::ru_euroseurocents(self, gr_casus, opts)
        end           
      when :ru_fractional then
        cls.send(:define_method,i) do |gr_casus='и', grammar=nil, **opts|
          RuNumerals::ru_fractional(self, gr_casus, grammar, opts)
        end           
    end
  end
  nil
end

.ru_cents(n, gr_casus = "и", **options) ⇒ String

Преобразует число в текстовое представление денежной суммы в центах (n*100)

Examples:


RuNumerals::ru_cents(2123.29)           #=> "двести двенадцать тысяч триста двадцать девять центов"
RuNumerals::ru_cents(3,"т",spellkop: false) #=> "300 центами"

Parameters:

  • n (Integer, Float) —

    объект для преобразования

  • gr_casus (String) (defaults to: "и") —

    падеж числительного

  • options (Hash) —

    опции

Options Hash (**options):

  • :spellkop (true, false) — default: true —

    преобразовать в числительное число центов, значение выводится в формате “%02d”

Returns:

  • (String)

Raises:

  • (ArgumentError) 


744
745
746
 
# File 'lib/ru_numerals.rb', line 744

def ru_cents(n,gr_casus="и",**options)
  ru_money(n,gr_casus,nil,CENTGRAM,options)
end

.ru_date(d, gr_casus = "и", **options) ⇒ String

Преобразует объект класса Time в текстовое представление даты

Examples:


RuNumerals::ru_date(Time.now)                                 #=> "девятое ноября две тысячи шестнадцатого года"
RuNumerals::ru_date(Time.now, "д",spellyy: false)             #=> "девятому ноября 2016 года"
RuNumerals::ru_date(Time.now, spelldd: false, spellyy: false) #=> "9 ноября 2016 года"

Parameters:

  • d (Time) —

    объект для преобразования

  • gr_casus (String) (defaults to: "и") —

    падеж числительного

  • options (Hash) —

    опции

Options Hash (**options):

  • :spelldd (true, false) — default: true —

    преобразовать в числительное число месяца

  • :spellyy (true, false) — default: true —

    преобразовать в числительное год

Returns:

  • (String)

Raises:

  • (ArgumentError) 


470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
 
# File 'lib/ru_numerals.rb', line 470

def ru_date(d, gr_casus="и", **options )
  if not d.kind_of?(Time) then
    raise ArgumentError, %Q/The argument must be Time class. Argument has class "#{d.class}", value "#{d}"/, caller
  end
  spelldd=true
  spellyy=true
  options.each do |k,v|
    case k
      when :spelldd then spelldd=v
      when :spellyy then spellyy=v
      else raise ArgumentError, %Q/Invalid option key #{k} value "#{v}"/, caller
    end
  end
  if spelldd then
    day_part=ru_ordinal(d.day,gr_casus,"с")
  else
    day_part=d.day.to_s
  end
  day_part + " " + MONTAB[d.mon-1] + " " + (spellyy ? ru_ordinal(d.year,"р",YEARGRAM) : (d.year.to_s + " года"))
end

.ru_dollars(n, gr_casus = "и", **options) ⇒ String

Преобразует число в текстовое представление денежной суммы в долларах. Дробная часть отбрасываются.

Examples:


RuNumerals::ru_dollars(2123.29)           #=> "две тысячи сто двадцать три доллара"
RuNumerals::ru_dollars(3,"т",spellrub: false) #=> "3 долларами"

Parameters:

  • n (Integer, Float) —

    объект для преобразования

  • gr_casus (String) (defaults to: "и") —

    падеж числительного

  • options (Hash) —

    опции

Options Hash (**options):

  • :spellrub (true, false) — default: true —

    преобразовать в числительное число долларов

Returns:

  • (String)

Raises:

  • (ArgumentError) 


728
729
730
 
# File 'lib/ru_numerals.rb', line 728

def ru_dollars(n,gr_casus="и",**options)
  ru_money(n,gr_casus,DOLLARGRAM,nil,options)
end

.ru_dollarscents(n, gr_casus = "и", **options) ⇒ String

Преобразует число в текстовое представление денежной суммы в долларах и центах

Examples:


RuNumerals::ru_dollarscents(2123.29)           #=> "две тысячи сто двадцать три доллара двадцать девять центов"
RuNumerals::ru_dollarscents(3,"т",spellkop: false) #=> "тремя долларами 00 центов"

Parameters:

  • n (Integer, Float) —

    объект для преобразования

  • gr_casus (String) (defaults to: "и") —

    падеж числительного

  • options (Hash) —

    опции

Options Hash (**options):

  • :spellrub (true, false) — default: true —

    преобразовать в числительное число долларов

  • :spellkop (true, false) — default: true —

    преобразовать в числительное число центов, значение выводится в формате “%02d”

Returns:

  • (String)

Raises:

  • (ArgumentError) 


761
762
763
 
# File 'lib/ru_numerals.rb', line 761

def ru_dollarscents(n,gr_casus="и",**options)
  ru_money(n,gr_casus,DOLLARGRAM,CENTGRAM,options)
end

.ru_eurocents(n, gr_casus = "и", **options) ⇒ String

Преобразует число в текстовое представление денежной суммы в евроцентах (n*100)

Examples:


RuNumerals::ru_eurocents(2123.29)           #=> "двести двенадцать тысяч триста двадцать девять евроцентов"
RuNumerals::ru_eurocents(3,"т",spellkop: false) #=> "300 евроцентами"

Parameters:

  • n (Integer, Float) —

    объект для преобразования

  • gr_casus (String) (defaults to: "и") —

    падеж числительного

  • options (Hash) —

    опции

Options Hash (**options):

  • :spellkop (true, false) — default: true —

    преобразовать в числительное число евроцентов, значение выводится в формате “%02d”

Returns:

  • (String)

Raises:

  • (ArgumentError) 


793
794
795
 
# File 'lib/ru_numerals.rb', line 793

def ru_eurocents(n,gr_casus="и",**options)
  ru_money(n,gr_casus,nil,EUROCENTGRAM,options)
end

.ru_euros(n, gr_casus = "и", **options) ⇒ String

Преобразует число в текстовое представление денежной суммы в евро. Дробная часть отбрасываются.

Examples:


RuNumerals::ru_euros(2123.29)           #=> "две тысячи сто двадцать три евро"
RuNumerals::ru_euros(3,"т",spellrub: false) #=> "3 евро"

Parameters:

  • n (Integer, Float) —

    объект для преобразования

  • gr_casus (String) (defaults to: "и") —

    падеж числительного

  • options (Hash) —

    опции

Options Hash (**options):

  • :spellrub (true, false) — default: true —

    преобразовать в числительное число евро

Returns:

  • (String)

Raises:

  • (ArgumentError) 


777
778
779
 
# File 'lib/ru_numerals.rb', line 777

def ru_euros(n,gr_casus="и",**options)
  ru_money(n,gr_casus,EUROGRAM,nil,options)
end

.ru_euroseurocents(n, gr_casus = "и", **options) ⇒ String

Преобразует число в текстовое представление денежной суммы в евро и евроцентах

Examples:


RuNumerals::ru_euroseurocents(2123.29)           #=> "две тысячи сто двадцать три евро двадцать девять евроцентов"
RuNumerals::ru_euroseurocents(3,"т",spellkop: false) #=> "тремя долларами 00 евроцентов"

Parameters:

  • n (Integer, Float) —

    объект для преобразования

  • gr_casus (String) (defaults to: "и") —

    падеж числительного

  • options (Hash) —

    опции

Options Hash (**options):

  • :spellrub (true, false) — default: true —

    преобразовать в числительное число евро

  • :spellkop (true, false) — default: true —

    преобразовать в числительное число евроцентов, значение выводится в формате “%02d”

Returns:

  • (String)

Raises:

  • (ArgumentError) 


810
811
812
 
# File 'lib/ru_numerals.rb', line 810

def ru_euroseurocents(n,gr_casus="и",**options)
  ru_money(n,gr_casus,EUROGRAM,EUROCENTGRAM,options)
end

.ru_fractional(n, gr_casus = "и", grammar = nil, **options) ⇒ String

Преобразует дробное число в его текстовое представление

Если знаменатель равен единице (аргумент типа Integer как частный случай), то результатом будет количественное числительное (будет осуществлен вызов ru_numeral)

Examples:


RuNumerals::ru_fractional(Rational(8,7))                   #=> "одна целая одна седьмая"
RuNumerals::ru_fractional(Rational(8,7),"",improper: true) #=> "восемь седьмых"
RuNumerals::ru_fractional(Rational(8,7),improper: true)    #=> "восемь седьмых"
RuNumerals::ru_fractional(Rational(6,2),"т")               #=> "тремя"
RuNumerals::ru_fractional(1001.02)                         #=> "одна тысяча одна целая две сотых"

Parameters:

  • n (Rational, Float, Integer) —

    объект для преобразования

  • gr_casus (String) (defaults to: "и") —

    падеж числительного

  • grammar (String) (defaults to: nil) —

    грамматика

  • options (Hash) —

    опции

Options Hash (**options):

  • :improper (true, false) — default: false —

    не преобразовать в правильную дробь

Returns:

  • (String)

Raises:

  • (ArgumentError) 


614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
 
# File 'lib/ru_numerals.rb', line 614

def ru_fractional(n,gr_casus="и",grammar=nil, **options)
  improper=false
  options.each do |k,v|
    case k
      when :improper then improper=v
      else raise ArgumentError, %Q/Invalid option key #{k} value "#{v}"/, caller
    end
  end
  if n.kind_of?(Integer) then
    numer=n
    denom=1
  elsif n.kind_of?(Float) then
    m=n.to_s.match('([-+]?[0-9]+)\.([0-9]+)([eE]([-+][0-9]+))?')
    numer=(m[1] + m[2]).to_i
    denom_order=(m[2].length - (m[3].nil? ? 0 : m[4].to_i))
    while denom_order < 0
      numer*=10
      denom_order+=1
    end
    while numer%10 == 0 && denom_order > 0
      numer/=10
      denom_order-=1
    end
    denom=10**denom_order
  elsif n.kind_of?(Rational) then
    numer=n.numerator
    denom=n.denominator
  else
    raise ArgumentError, %Q/The number must be one of Rational, Float or Integer. Argument has class "#{n.class}", value "#{n}"/, caller
  end
  if denom == 1 then
    return ru_numeral(numer, gr_casus, grammar)
  end
  if (not improper) && numer.abs >= denom then
    t_str=ru_numeral((numer < 0 ? -(numer.abs/denom) : numer/denom),gr_casus,WHOLEGRAM)
    numer=numer.abs%denom
  else
    t_str=""
  end
  if not numer.zero? then
    t_str << " " if not t_str.empty?
    t_str << ru_numeral(numer,gr_casus,"ж") + " "
    if numer%10 == 1 then
      t_str << ru_ordinal(denom,gr_casus,"ж")
    elsif gr_casus == "и" then
      t_str << ru_ordinal(denom,"р","ж",true)
    else
      t_str << ru_ordinal(denom,gr_casus,"ж",true)
    end
  end
  t_str  + (grammar.nil? ? "" : (" " + ru_numeral(1,"р",grammar,-1)))
end

.ru_kopecks(n, gr_casus = "и", **options) ⇒ String

Преобразует число в текстовое представление денежной суммы в копейках (n*100)

Examples:


RuNumerals::ru_kopecks(2123.29)           #=> "двести двенадцать тысяч триста двадцать девять копеек"
RuNumerals::ru_kopecks(3,"т",spellkop: false) #=> "300 копейками"

Parameters:

  • n (Integer, Float) —

    объект для преобразования

  • gr_casus (String) (defaults to: "и") —

    падеж числительного

  • options (Hash) —

    опции

Options Hash (**options):

  • :spellkop (true, false) — default: true —

    преобразовать в числительное число копеек, значение выводится в формате “%02d”

Returns:

  • (String)

Raises:

  • (ArgumentError) 


695
696
697
 
# File 'lib/ru_numerals.rb', line 695

def ru_kopecks(n,gr_casus="и",**options)
  ru_money(n,gr_casus,nil,KOPGRAM,options)
end

.ru_money(n, gr_casus, rub_gram, kop_gram, **options) ⇒ String

Преобразует число в текстовое представление денежной суммы

Examples:


RuNumerals::ru_money(123.029,"и",RuNumerals::RUBGRAM,RuNumerals::KOPGRAM)
         #=> "сто двадцать три рубля три копейки"
RuNumerals::ru_money(123.029,"р",RuNumerals::RUBGRAM,RuNumerals::KOPGRAM, spellkop: false)
         #=> "ста двадцати трёх рублей 03 копеек"
RuNumerals::ru_money(123.029,"т",nil,RuNumerals::KOPGRAM)
         #=> "двенадцатью тысячами тремястами тремя копейками"

Parameters:

  • n (Integer, Float) —

    объект для преобразования

  • gr_casus (String) —

    падеж числительного

  • rub_gram (String) —

    грамматика “рублей”, если nil или “”, то выводятся только “копейки” со значением n*100

  • kop_gram (String) —

    грамматика “копеек”, если nil или “”, то “копейки” не выводятся и их значение отбрасывается

  • options (Hash) —

    опции

Options Hash (**options):

  • :spellrub (true, false) — default: true —

    преобразовать в числительное число “рублей”

  • :spellkop (true, false) — default: true —

    преобразовать в числительное число “копеек”, значение выводится в формате “%02d”

Returns:

  • (String)

Raises:

  • (ArgumentError) 


553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
 
# File 'lib/ru_numerals.rb', line 553

def ru_money(n,gr_casus,rub_gram, kop_gram, **options)
  if not (n.kind_of?(Integer) || n.kind_of?(Float)) then
    raise ArgumentError, %Q/The number must be Integer or Float. Argument has class "#{n.class}", value "#{n}"/, caller
  end
  n=n.to_f
  spellrub=true
  spellkop=true
  options.each do |k,v|
    case k
      when :spellrub then spellrub=v
      when :spellkop then spellkop=v
      else raise ArgumentError, %Q/Invalid option key #{k} value "#{v}"/, caller
    end
  end
  if (rub_gram.nil? || rub_gram.empty?) && (kop_gram.nil? || kop_gram.empty? ) then
    raise ArgumentError, %Q/Both grammars are nil/, caller
  end
  if rub_gram.nil? || rub_gram.empty? then
    kops=(n*100).round
    if spellkop then
      return ru_numeral(kops,gr_casus,kop_gram)
    else
      return kops.to_s + " " + ru_numeral(kops,gr_casus,kop_gram,-1)
    end
  end
  rubs=n.truncate
  kops=((n*100)%100).round
  if spellrub then
    rub_s=ru_numeral(rubs,gr_casus,rub_gram)
  else
    rub_s=rubs.to_s + " " + ru_numeral(rubs,gr_casus,rub_gram,-1)
  end
  return rub_s if ( kop_gram.nil? || kop_gram.empty? )
  if spellkop then
    kop_s=ru_numeral(kops,gr_casus,kop_gram)
  else
    kop_s=("%02d" % kops.to_s) + " " + ru_numeral(kops,gr_casus,kop_gram,-1)
  end
  rub_s + " " + kop_s
end

.ru_numeral(n, gr_casus = "и", grammar = "мн", minorder = 0) ⇒ String

Преобразует число в количественное числительное

Examples:

RuNumerals::ru_numeral(154,'д')                       #=> "ста пятидесяти четырём"
RuNumerals::ru_numeral(101,'','с',1)                  #=> "ноль тысяч сто одно"
RuNumerals::ru_numeral(1,'',RuNumerals::RUBGRAM,-1)   #=> "рубль"
RuNumerals::ru_numeral(2,'',RuNumerals::RUBGRAM,-1)   #=> "рубля"

Parameters:

  • n (Integer) —

    число для преобразования

  • gr_casus (String) (defaults to: "и") —

    падеж числительного

  • grammar (String) (defaults to: "мн") —

    грамматика

  • minorder (Integer) (defaults to: 0) —

    минимальный порядок тысяч (см. примеры). Если минимальный порядок < 0, то собственно числительное не выводится

Returns:

  • (String)

Raises:

  • (ArgumentError) 


367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
 
# File 'lib/ru_numerals.rb', line 367

def ru_numeral(n,gr_casus = "и", grammar = "мн", minorder = 0)
  if not n.kind_of?(Integer) then
    raise ArgumentError, %Q/The number must be Integer. Argument has class "#{n.class}", value "#{n}"/, caller
  end
  gr_casus="и" if gr_casus.nil? || gr_casus.empty?
  minorder=minorder.to_i
  set_grammar(grammar)
  @animate=false if n > 10 and n%10 != 1
  casus=CASUS_STR.index(gr_casus.downcase)
  if not casus
    raise ArgumentError, %Q/The grammatical case must be one of "ирдвтп". Current value of argument is "#{gr_casus}"/, caller
  end
  if n < 0 then
    is_negative=true
    n=-n
  else
    is_negative=false
  end
  order=get_order(n)
  if order > ORDWORD.length then
    raise ArgumentError, %Q/Too big number #{n}. Max number supported is #{10**((ORDWORD.length+1)*3) - 1}/, caller
  end
  triad=0
  return get_tail(n%1000,casus,@animate,0) if minorder < 0
  t_str= is_negative ? "минус " : ""
  [[minorder,ORDWORD.length].min,order].max.downto(0) do |i|
    triad=(n/(10**(3*i)))%1000
    t_str << milli(triad,casus,@gender,@animate,i) + " " if triad.nonzero? || t_str.empty?
  end
  t_str << get_grammar(0,1,1) if triad.zero? && n.nonzero?
  t_str.rstrip
end

.ru_ordinal(n, gr_casus = "и", grammar = "мн", plural = false) ⇒ String

Преобразует число в порядковое числительное

Examples:


RuNumerals::ru_ordinal(1)                 #=> "первый"
RuNumerals::ru_ordinal(2)                 #=> "второй"    
RuNumerals::ru_ordinal(250000000,'в','ж') #=> "двухсотпятидесятимиллионную"
RuNumerals::ru_ordinal(5,'т','ж',true)    #=> "пятыми"
RuNumerals::ru_ordinal(-5,'в','о')        #=> "минус пятого"

Parameters:

  • n (Integer) —

    число для преобразования

  • gr_casus (String) (defaults to: "и") —

    падеж числительного

  • grammar (String) (defaults to: "мн") —

    грамматика

  • plural (true, false) (defaults to: false) —

    множественное число

Returns:

  • (String)

Raises:

  • (ArgumentError) 


417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
 
# File 'lib/ru_numerals.rb', line 417

def ru_ordinal(n, gr_casus = "и", grammar = "мн", plural = false)
  if not n.kind_of?(Integer) then
    raise ArgumentError, %Q/The number must be Integer. Argument has class "#{n.class}", value "#{n}"/, caller
  end
  gr_casus="и" if gr_casus.nil? || gr_casus.empty?
  set_grammar(grammar)
  casus=CASUS_STR.index(gr_casus.downcase)
  if not casus
    raise ArgumentError, %Q/The grammatical case must be one of "ирдвтп". Current value of argument is "#{gr_casus}"/, caller
  end
  if n < 0 then
    is_negative=true
    n=-n
  else
    is_negative=false
  end
  order=get_order(n)
  if order > ORDWORD.length then
    raise ArgumentError, %Q/Too big number #{n}. Max number supported is  #{10**((ORDWORD.length+1)*3) - 1}/, caller
  end
  @gender=3 if plural
  if n.zero? then
    return (ORDINALS[0] + get_ending(0,@animate, @gender, casus) + " " + get_grammar(0, plural ? 1 : 0 , casus)).rstrip
  end
  t_str = first_ordinal(n%1000,@animate,@gender,casus)
  1.upto(get_order(n)) do |i|
    triad=(n/(10**(3*i)))%1000
    if triad.nonzero? then
      if not t_str.empty? then
        t_str = (triad == 1 ? get_grammar(i,0,0) : milli(triad,0,0,false,i)) + " " + t_str
      else
        t_str = second_ordinal(triad, i, @animate, @gender, casus)
      end
    end
  end
  (( is_negative ? "минус " : "" ) + t_str + " " + get_grammar(0, plural ? 1 : 0, casus)).rstrip
end

.ru_rubles(n, gr_casus = "и", **options) ⇒ String

Преобразует число в текстовое представление денежной суммы в рублях. Дробная часть отбрасываются.

Examples:


RuNumerals::ru_rubles(2123.29)           #=> "две тысячи сто двадцать три рубля"
RuNumerals::ru_rubles(3,"т", spellrub: false) #=> "3 рублями"

Parameters:

  • n (Integer, Float) —

    объект для преобразования

  • gr_casus (String) (defaults to: "и") —

    падеж числительного

  • options (Hash) —

    опции

Options Hash (**options):

  • :spellrub (true, false) — default: true —

    преобразовать в числительное число рублей

Returns:

  • (String)

Raises:

  • (ArgumentError) 


679
680
681
 
# File 'lib/ru_numerals.rb', line 679

def ru_rubles(n,gr_casus="и",**options)
  ru_money(n,gr_casus,RUBGRAM,nil,options)
end

.ru_rubleskopecks(n, gr_casus = "и", **options) ⇒ String

Преобразует число в текстовое представление денежной суммы в рублях и копейках

Examples:


RuNumerals::ru_rubleskopecks(2123.29)           #=> "две тысячи сто двадцать три рубля двадцать девять копеек"
RuNumerals::ru_rubleskopecks(3,"т",spellkop: false) #=> "тремя рублями 00 копеек"

Parameters:

  • n (Integer, Float) —

    объект для преобразования

  • gr_casus (String) (defaults to: "и") —

    падеж числительного

  • options (Hash) —

    опции

Options Hash (**options):

  • :spellrub (true, false) — default: true —

    преобразовать в числительное число рублей

  • :spellkop (true, false) — default: true —

    преобразовать в числительное число копеек, значение выводится в формате “%02d”

Returns:

  • (String)

Raises:

  • (ArgumentError) 


712
713
714
 
# File 'lib/ru_numerals.rb', line 712

def ru_rubleskopecks(n,gr_casus="и",**options)
  ru_money(n,gr_casus,RUBGRAM,KOPGRAM,options)
end

.ru_time(d, gr_casus = "и", **options) ⇒ String

Преобразует объект класса Time в текстовое представление времени

Examples:


RuNumerals::ru_time(Time.now)                                      
        #=> "восемнадцать часов пятьдесят две минуты двадцать секунд"
RuNumerals::ru_time(Time.now,"д",spellhh: false , spellmm: false , spellss: false)
        #=> "18 часам 52 минутам 20 секундам"
RuNumerals::ru_time(Time.now,'',spellhh: false , spellmm: false , noseconds: false)
        #=> "18 часов 52 минуты"

Parameters:

  • d (Time) —

    объект для преобразования

  • gr_casus (String) (defaults to: "и") —

    падеж числительного

  • options (Hash) —

    опции

Options Hash (**options):

  • :spellhh (true, false) — default: true —

    преобразовать в числительное часы

  • :spellmm (true, false) — default: true —

    преобразовать в числительное минуты

  • :spellss (true, false) — default: true —

    преобразовать в числительное секунды

  • :seconds (true, false) — default: true —

    показывать секунды

Returns:

  • (String)

Raises:

  • (ArgumentError) 


511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
 
# File 'lib/ru_numerals.rb', line 511

def ru_time(d, gr_casus="и", **options)
  if not d.kind_of?(Time) then
    raise ArgumentError, %Q/The argument must be Time class. Argument has class "#{d.class}", value "#{d}"/, caller
  end
  spellhh=true
  spellmm=true
  spellss=true
  seconds=true
  options.each do |k,v|
    case k
      when :spellhh then spellhh=v
      when :spellmm then spellmm=v
      when :spellss then spellss=v
      when :seconds then seconds=v
      else raise ArgumentError, %Q/Invalid option key #{k} value "#{v}"/, caller
    end
  end
  (spellhh ? ru_numeral(d.hour, gr_casus, HOURGRAM ) : (d.hour.to_s + " " + ru_numeral(d.hour, gr_casus, HOURGRAM, -1 ))) + " " + 
  (spellmm ? ru_numeral(d.min, gr_casus, MINGRAM ) : (d.min.to_s + " "+ ru_numeral(d.min, gr_casus, MINGRAM, -1 ))) + 
  (seconds ?  ( " " + (spellss ? ru_numeral(d.sec, gr_casus, SECGRAM ) : (d.sec.to_s + " " + ru_numeral(d.sec, gr_casus, SECGRAM, -1 )))) : "")
end