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