numbers_and_words 0.11.2 → 0.11.7

data/lib/numbers_and_words/translations/de.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 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 +11,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,10 @@
+# frozen_string_literal: true
+
 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/en.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module NumbersAndWords
   module Translations
     class En < Base

data/lib/numbers_and_words/translations/es.rb

@@ -1,47 +1,37 @@
+# frozen_string_literal: true
+
 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 = {})
-        t(%i[ones male].join('.'))[0]
+        t('ones.male')[0]
       end
 
       def ones(number, options = {})
         return if options[:is_one_thousand]
-        return t(%i[ones apocopated].join('.')) if number == 1 &&
-                                                   options[:is_apocopated]
-        t([:ones, options[:gender]].join('.'))[number]
-      end
+        return t('ones.apocopated') if number == 1 &&
+                                       options[:is_apocopated]
 
-      def twenties_with_ones(numbers, options = {})
-        return t(%i[twenties apocopated].join('.')) if options[:is_apocopated]
-        t([:twenties, options[:gender]].join('.'))[numbers[0]]
+        t([:ones, options[:gender]].join('.'))[number]
       end
 
       def tens_with_ones(numbers, options = {})
-        [tens(numbers[1], alone: false),
-         t(:union),
-         ones(numbers[0], options)].join(' ')
+        super numbers, options.merge(separator: " #{union} ")
       end
 
-      def hundreds(number, options = {})
-        return t(%i[hundreds apocopated].join('.')) if options[:is_apocopated]
-        t([:hundreds, options[:gender]].join('.'))[number]
-      end
+      def twenties_with_ones(numbers, options = {})
+        return t('twenties.apocopated') if options[:is_apocopated]
 
-      def micros(capacity, number = nil)
-        micro, prefix = capacity
-        micros = number ? t(micro(micro), count: number) : micro(micro)
-        [micro_prefix(prefix), micros].compact.join
+        t([:twenties, options[:gender]].join('.'))[numbers[0]]
       end
 
-      def micro_prefix(capacity)
-        case capacity
-        when 2 then t('micro_prefix.hundreds')
-        when 1 then t('micro_prefix.tens')
-        end
+      def hundreds(number, options = {})
+        return t('hundreds.apocopated') if options[:is_apocopated]
+
+        t([:hundreds, options[:gender]].join('.'))[number]
       end
     end
   end

data/lib/numbers_and_words/translations/et.rb

@@ -1,15 +1,12 @@
+# frozen_string_literal: true
+
 module NumbersAndWords
   module Translations
     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

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 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 +16,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module NumbersAndWords
   module Translations
     module Families
@@ -11,7 +13,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 +30,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

@@ -1,25 +1,23 @@
+# frozen_string_literal: true
+
 module NumbersAndWords
   module Translations
     module Families
       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/families/latin.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module NumbersAndWords
   module Translations
     module Families

data/lib/numbers_and_words/translations/fr.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module NumbersAndWords
   module Translations
     class Fr < Base
@@ -7,30 +9,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 '-'
-        else
-          union = numbers[0] == 1 ? ' et ' : '-'
-          [tens(numbers[1], alone: false), ones(numbers[0])].join union
-        end
+      def tens_with_ones(numbers, options = {})
+        return [tens(numbers[1] - 1, alone: false), teens(numbers)].join('-') if [7, 9].include? numbers[1]
+
+        separator = numbers[0] == 1 ? " #{union} " : '-'
+        super numbers, options.merge(separator: separator)
       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)
+
+        return hundreds if number == 1
 
-      def micro_prefix(capacity)
-        case capacity
-        when 2 then t(:hundreds, count: 1)
-        when 1 then tens(1)
-        end
+        [t(:ones)[number], hundreds].join(' ')
       end
     end
   end

data/lib/numbers_and_words/translations/hu.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module NumbersAndWords
   module Translations
     class Hu < Base
@@ -6,16 +8,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/hy.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module NumbersAndWords
+  module Translations
+    class Hy < Base
+      include NumbersAndWords::Translations::Families::Latin
+
+      def tens_with_ones(numbers, options = {})
+        options[:separator] ||= ''
+        super
+      end
+
+      def hundreds(number, _options = {})
+        parts = [t(:hundreds)]
+        parts.unshift(t(:ones)[number]) if number > 1
+
+        parts.join(' ')
+      end
+    end
+  end
+end

data/lib/numbers_and_words/translations/it.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module NumbersAndWords
   module Translations
     class It < Base

data/lib/numbers_and_words/translations/ka.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module NumbersAndWords
   module Translations
     class Ka < Base
@@ -40,32 +42,22 @@ module NumbersAndWords
       def tens_with_ones(numbers, _options = {})
         range = vigesimal_range(numbers[1])
 
-        minor = if numbers[1] - range[:multiplicative] > 0
+        minor = if (numbers[1] - range[:multiplicative]).positive?
                   teens(numbers)
                 else
                   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

@@ -1,19 +1,12 @@
+# frozen_string_literal: true
+
 module NumbersAndWords
   module Translations
     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

@@ -1,19 +1,12 @@
+# frozen_string_literal: true
+
 module NumbersAndWords
   module Translations
     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

@@ -1,14 +1,18 @@
+# frozen_string_literal: true
+
 module NumbersAndWords
   module Translations
     class Nl < Base
       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,9 @@
+# frozen_string_literal: true
+
 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 = {})
@@ -14,50 +16,48 @@ module NumbersAndWords
 
       def ones(number, options = {})
         return if options[:is_one_thousand]
+
         t([options[:prefix], :ones, options[:gender]].join('.'))[number]
       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 = {})
-        return [tens(1, options), ' ', ones(number[0], options)].join if ordinal? options
+        return [tens(1, options), ones(number[0], options)].join(' ') if ordinal? options
+
         super(number, options)
       end
 
       def tens_with_ones(numbers, options = {})
-        connector = ' '
-        connector = " #{union} " unless ordinal? options
-        [tens(numbers[1], options), connector, ones(numbers[0], options)].join
+        connector = ordinal?(options) ? ' ' : " #{union} "
+        [tens(numbers[1], options), ones(numbers[0], options)].join(connector)
       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)