numbers_and_words 0.11.2 → 0.11.3

data/lib/numbers_and_words/translations.rb

@@ -22,6 +22,7 @@ require 'numbers_and_words/translations/pt'
 require 'numbers_and_words/translations/pt-BR'
 require 'numbers_and_words/translations/ka'
 require 'numbers_and_words/translations/cs'
+require 'numbers_and_words/translations/vi'
 
 module NumbersAndWords
   module Translations

data/lib/numbers_and_words/translations/cs.rb

@@ -12,53 +12,26 @@ module NumbersAndWords
         t([options[:prefix], :ones, options[:gender]].join('.'))[number]
       end
 
-      # for 20, 30, 60
       def tens(number, options = {})
         t([options[:prefix], :tens, gender_to_use(options)].join('.'))[number]
       end
 
-      # for 12, 13, 19
-      def teens(number_arr, options = {})
-        t([options[:prefix], :teens, gender_to_use(options)].join('.'))[number_arr.first]
+      def teens(numbers, options = {})
+        t([options[:prefix], :teens, gender_to_use(options)].join('.'))[numbers[0]]
       end
 
-      # for 42, 23, 69
-      def tens_with_ones(numbers_arr, options = {})
-        connector = ' '
-        [tens(numbers_arr[1], options), connector, ones(numbers_arr[0], options)].join
+      def tens_with_ones(numbers, options = {})
+        [tens(numbers[1], options), ones(numbers[0], options)].join(' ')
       end
 
       def hundreds(number, options = {})
         t([options[:prefix], :hundreds, gender_to_use(options)].join('.'))[number]
       end
 
-      def megs(capacity, options = {})
-        number = options[:number]
-        mega_name = "#{options[:prefix]}.mega"
-        number ? t(mega(capacity), count: number) : t(mega_name)[capacity]
-      end
-
-      def mega(capacity)
-        t(:mega)[capacity]
-      end
-
       def integral(number, _options = {})
         t(:integral, count: number)
       end
 
-      def micros(capacity, number = nil, separator = '')
-        micro, prefix = capacity
-        micros = t(:micro, count: number)[micro]
-        [micro_prefix(prefix), micros].compact.join separator
-      end
-
-      def micro_prefix(capacity)
-        case capacity
-        when 2 then t(:sub_micro)[2]
-        when 1 then t(:sub_micro)[1]
-        end
-      end
-
       private
 
       def ordinal?(options)

data/lib/numbers_and_words/translations/de.rb

@@ -1,7 +1,7 @@
 module NumbersAndWords
   module Translations
     class De < Base
-      include NumbersAndWords::Translations::Families::Latin
+      include NumbersAndWords::Translations::Families::Base
       DEFAULT_POSTFIX = :combine
 
       def ones(number, options = {})
@@ -9,11 +9,11 @@ module NumbersAndWords
       end
 
       def tens_with_ones(numbers, options = {})
-        [tens(numbers[1]), ones(numbers[0], options)].reverse.join 'und'
+        [tens(numbers[1]), ones(numbers[0], options)].reverse.join(union)
       end
 
       def hundreds(number, _options = {})
-        [ones(number), t(:hundreds)].join('')
+        [ones(number), t(:hundreds)].join
       end
 
       def zero(_options = {})

data/lib/numbers_and_words/translations/en-GB.rb

@@ -1,6 +1,8 @@
 module NumbersAndWords
   module Translations
-    class EnGb < En
+    class EnGb < Base
+      include NumbersAndWords::Translations::Families::Latin
+      include NumbersAndWords::Translations::Extensions::FractionSignificance
     end
   end
 end

data/lib/numbers_and_words/translations/es.rb

@@ -1,7 +1,7 @@
 module NumbersAndWords
   module Translations
     class Es < Base
-      include NumbersAndWords::Translations::Families::Latin
+      include NumbersAndWords::Translations::Families::Base
       include NumbersAndWords::Translations::Extensions::FractionSignificance
 
       def zero(_options = {})
@@ -15,34 +15,19 @@ module NumbersAndWords
         t([:ones, options[:gender]].join('.'))[number]
       end
 
+      def tens_with_ones(numbers, options = {})
+        super numbers, options.merge(separator: " #{union} ")
+      end
+
       def twenties_with_ones(numbers, options = {})
         return t(%i[twenties apocopated].join('.')) if options[:is_apocopated]
         t([:twenties, options[:gender]].join('.'))[numbers[0]]
       end
 
-      def tens_with_ones(numbers, options = {})
-        [tens(numbers[1], alone: false),
-         t(:union),
-         ones(numbers[0], options)].join(' ')
-      end
-
       def hundreds(number, options = {})
         return t(%i[hundreds apocopated].join('.')) if options[:is_apocopated]
         t([:hundreds, options[:gender]].join('.'))[number]
       end
-
-      def micros(capacity, number = nil)
-        micro, prefix = capacity
-        micros = number ? t(micro(micro), count: number) : micro(micro)
-        [micro_prefix(prefix), micros].compact.join
-      end
-
-      def micro_prefix(capacity)
-        case capacity
-        when 2 then t('micro_prefix.hundreds')
-        when 1 then t('micro_prefix.tens')
-        end
-      end
     end
   end
 end

data/lib/numbers_and_words/translations/et.rb

@@ -3,13 +3,8 @@ module NumbersAndWords
     class Et < Base
       include NumbersAndWords::Translations::Families::Latin
 
-      def tens_with_ones(numbers, _options = {})
-        [tens(numbers[1], alone: false), ones(numbers[0])].join ' '
-      end
-
-      def hundreds(number, options = {})
-        options[:separator] = ''
-        super number, options
+      def hundreds(number, _options = {})
+        super number, separator: ''
       end
     end
   end

data/lib/numbers_and_words/translations/extensions/fraction_significance.rb

@@ -2,10 +2,10 @@ module NumbersAndWords
   module Translations
     module Extensions
       module FractionSignificance
-        def micros(capacity, number = nil, separator = '-')
+        def micros(capacity, number = nil)
           micro, prefix = capacity
           micros = number ? t(micro(micro), count: number) : micro(micro)
-          [micro_prefix(prefix), micros].compact.join separator
+          [micro_prefix(prefix), micros].compact.join(t('micro_prefix.union'))
         end
 
         def micro(capacity)
@@ -14,8 +14,8 @@ module NumbersAndWords
 
         def micro_prefix(capacity)
           case capacity
-          when 2 then t(:hundreds)
-          when 1 then tens(1)
+          when 2 then t('micro_prefix.hundreds')
+          when 1 then t('micro_prefix.tens')
           end
         end
       end

data/lib/numbers_and_words/translations/families/base.rb

@@ -11,7 +11,7 @@ module NumbersAndWords
         end
 
         def tens_with_ones(numbers, options = {})
-          [tens(numbers[1]), ones(numbers[0], options)].join options[:separator]
+          [tens(numbers[1]), ones(numbers[0], options)].join options[:separator] || ' '
         end
 
         def megs(capacity, options = {})
@@ -28,8 +28,8 @@ module NumbersAndWords
           t :union
         end
 
-        def union_separator
-          t :union_separator
+        def micro_separator
+          t :micro_separator
         end
       end
     end

data/lib/numbers_and_words/translations/families/cyrillic.rb

@@ -4,22 +4,18 @@ module NumbersAndWords
       module Cyrillic
         include NumbersAndWords::Translations::Families::Base
 
-        def ones(number, options = {})
-          t(:ones)[options[:gender]][number]
+        def zero(_options = {})
+          t(:ones).values.first[0]
         end
 
-        def tens_with_ones(numbers, options = {})
-          [tens(numbers[1]), ones(numbers[0], options)].join ' '
+        def ones(number, options = {})
+          t(:ones)[options[:gender]][number]
         end
 
         def hundreds(number, _options = {})
           t(:hundreds)[number]
         end
 
-        def zero(_options = {})
-          t(:ones).values.first[0]
-        end
-
         def integral(number, _options = {})
           t(:integral, count: number)
         end

data/lib/numbers_and_words/translations/fr.rb

@@ -7,30 +7,25 @@ module NumbersAndWords
       SPECIAL_TENS_CASE = 8
 
       def tens(number, options = {})
-        options[:alone] = true if options[:alone].nil?
-        SPECIAL_TENS_CASE == number && options[:alone] ? t(:eighty) : super(number)
+        return t(:eighty) if number == SPECIAL_TENS_CASE && options[:alone].nil?
+        super number, options
       end
 
       def tens_with_ones(numbers, _options = {})
         if [7, 9].include? numbers[1]
-          [tens(numbers[1] - 1, alone: false), teens(numbers)].join '-'
+          [tens(numbers[1] - 1, alone: false), teens(numbers)].join('-')
         else
-          union = numbers[0] == 1 ? ' et ' : '-'
-          [tens(numbers[1], alone: false), ones(numbers[0])].join union
+          separator = numbers[0] == 1 ? " #{union} " : '-'
+          [tens(numbers[1], alone: false), ones(numbers[0])].join(separator)
         end
       end
 
       def hundreds(number, options = {})
-        options[:pluralize] = false if options[:pluralize].nil?
-        hundreds = t(:hundreds, count: options[:pluralize] ? number : 1)
-        number == 1 ? hundreds : [t(:ones)[number], hundreds].join(' ')
-      end
+        count = options[:pluralize] ? number : 1
+        hundreds = t(:hundreds, count: count)
 
-      def micro_prefix(capacity)
-        case capacity
-        when 2 then t(:hundreds, count: 1)
-        when 1 then tens(1)
-        end
+        return hundreds if number == 1
+        [t(:ones)[number], hundreds].join(' ')
       end
     end
   end

data/lib/numbers_and_words/translations/hu.rb

@@ -6,16 +6,11 @@ module NumbersAndWords
 
       def tens_with_ones(numbers, options = {})
         ones, tens = numbers
-        [t(:tens_with_ones)[tens], t([options[:prefix], :ones_with_tens].join('.'))[ones]].join ''
+        [t(:tens_with_ones)[tens], t([options[:prefix], :ones_with_tens].join('.'))[ones]].join
       end
 
       def hundreds(number, options = {})
-        options[:separator] = ''
-        super number, options
-      end
-
-      def micros(capacity, _number = nil, separator = '')
-        super capacity, nil, separator
+        super number, options.merge(separator: '')
       end
     end
   end

data/lib/numbers_and_words/translations/ka.rb

@@ -46,26 +46,16 @@ module NumbersAndWords
                   ones(numbers[0])
                 end
 
-        [t([:partials, range[:name]].join('.')), minor].join ''
+        [t([:partials, range[:name]].join('.')), minor].join
       end
 
       def hundreds(number, options = {})
         options[:prefix] ||= options[:only_hundreds] == true ? nil : :partials
 
-        parts = [t([options[:prefix], :one_hundred].join('.'))]
+        parts = [t([options[:prefix], :hundreds].join('.'))]
         parts.unshift(ones(number, prefix: :partials)) if number > 1
 
-        parts.join ''
-      end
-
-      def megs(capacity, options = {})
-        if capacity == 1
-          t([options[:prefix], :one_thousand].join('.'))
-        elsif capacity == 2
-          t([options[:prefix], :one_million].join('.'))
-        elsif capacity == 3
-          t([options[:prefix], :one_billion].join('.'))
-        end
+        parts.join
       end
     end
   end

data/lib/numbers_and_words/translations/lt.rb

@@ -3,17 +3,8 @@ module NumbersAndWords
     class Lt < Base
       include NumbersAndWords::Translations::Families::Latin
 
-      def tens(number, _options = {})
-        super(number)
-      end
-
-      def tens_with_ones(numbers, _options = {})
-        [tens(numbers[1], alone: false), ones(numbers[0])].join ' '
-      end
-
-      def hundreds(number, options = {})
-        options[:is_hundred] = false if options[:is_hundred].nil?
-        options[:is_hundred] ? t(:one_hundred) : t(:hundreds)[number - 1]
+      def hundreds(number, _options = {})
+        t(:hundreds)[number]
       end
     end
   end

data/lib/numbers_and_words/translations/lv.rb

@@ -3,17 +3,8 @@ module NumbersAndWords
     class Lv < Base
       include NumbersAndWords::Translations::Families::Latin
 
-      def tens(number, _options = {})
-        super(number)
-      end
-
-      def tens_with_ones(numbers, _options = {})
-        [tens(numbers[1], alone: false), ones(numbers[0])].join ' '
-      end
-
-      def hundreds(number, options = {})
-        options[:is_hundred] = false if options[:is_hundred].nil?
-        options[:is_hundred] ? t(:one_hundred) : t(:hundreds)[number - 1]
+      def hundreds(number, _options = {})
+        t(:hundreds)[number]
       end
     end
   end

data/lib/numbers_and_words/translations/nl.rb

@@ -4,11 +4,12 @@ module NumbersAndWords
       include NumbersAndWords::Translations::Families::Latin
 
       def tens_with_ones(numbers, _options = {})
-        [ones(numbers[0]), tens(numbers[1])].join 'en'
+        [ones(numbers[0]), tens(numbers[1])].join(union)
       end
 
       def hundreds(number, _options = {})
-        number == 1 ? t(:hundreds) : [t(:ones)[number], t(:hundreds)].join
+        return t(:hundreds) if number == 1
+        super number, separator: ''
       end
     end
   end

data/lib/numbers_and_words/translations/pt-BR.rb

@@ -1,7 +1,7 @@
 module NumbersAndWords
   module Translations
     class PtBr < Base
-      include NumbersAndWords::Translations::Families::Latin
+      include NumbersAndWords::Translations::Families::Base
       include NumbersAndWords::Translations::Extensions::FractionSignificance
 
       def integral(number, _options = {})
@@ -18,11 +18,9 @@ module NumbersAndWords
       end
 
       def tens(number, options = {})
-        options[:alone] = true if options[:alone].nil?
         path = [options[:prefix], :tens]
-        path.push(options[:gender]) if ordinal? options
-        translated = t(path.join('.'))[number]
-        options[:alone] ? translated : "#{union} " + translated
+        path.push(options[:gender]) if ordinal?(options)
+        t(path.join('.'))[number]
       end
 
       def teens(number, options = {})
@@ -31,33 +29,28 @@ module NumbersAndWords
       end
 
       def tens_with_ones(numbers, options = {})
-        connector = ' '
-        connector = " #{union} " unless ordinal? options
+        connector = ordinal?(options) ? ' ' : " #{union} "
         [tens(numbers[1], options), connector, ones(numbers[0], options)].join
       end
 
       def hundreds(number, options = {})
-        return t(:one_hundred) if options[:is_one_hundred] && !(ordinal? options)
-        translated = t([options[:prefix], :hundreds, options[:gender]].join('.'))[number - 1]
-        return translated if ordinal? options
-        options[:is_hundred] ? translated : translated + " #{union}"
+        return t(:one_hundred) if options[:is_one_hundred] && !ordinal?(options)
+        hundreds = t([options[:prefix], :hundreds, options[:gender]].join('.'))[number]
+        return hundreds if ordinal?(options) || options[:is_hundred]
+        [hundreds, union].join(' ')
       end
 
       def megs(capacity, options = {})
-        return t([options[:prefix], :mega, options[:gender]].join('.'))[capacity] if ordinal? options
-
-        options[:is_one] = false if options[:is_one].nil?
-        connector = " #{union}"
-        connector = ',' if options[:is_with_comma]
-        suffix = options[:is_opaque] ? '' : connector
-        suffix = options[:is_without_connector] ? '' : suffix
-        (options[:is_one] ? t(:mega)[capacity] : t(:megas)[capacity]) + suffix
+        return t([options[:prefix], :mega, options[:gender]].join('.'))[capacity] if ordinal?(options)
+        return super(capacity, options) if options[:is_opaque] || options[:is_without_connector]
+        suffix = options[:is_with_comma] ? ',' : " #{union}"
+        super(capacity, options) + suffix
       end
 
-      def micros(capacity, number, separator = t('micro_prefix.separator'))
+      def micros(capacity, number = nil)
         micro, prefix = capacity
         micros = number ? t(micro(micro), count: number) : micro(micro)
-        [micro_prefix(prefix, number), micros].compact.join(" #{separator} ")
+        [micro_prefix(prefix, number), micros].compact.join(t('micro_prefix.union'))
       end
 
       def micro_prefix(capacity, number)