numbers_and_words 0.11.0 → 0.11.1

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

@@ -2,25 +2,25 @@ module NumbersAndWords
   module Translations
     module Families
       module Base
-
-        def teens numbers, options = {}
+        def teens(numbers, options = {})
           t("#{options[:prefix]}.teens")[numbers[0]]
         end
 
-        def tens number, options = {}
+        def tens(number, options = {})
           t("#{options[:prefix]}.tens")[number]
         end
 
-        def tens_with_ones numbers, options = {}
+        def tens_with_ones(numbers, options = {})
           [tens(numbers[1]), ones(numbers[0], options)].join options[:separator]
         end
 
-        def megs capacity, options = {}
-          number, mega_name = options[:number], "#{options[:prefix]}.mega"
-          number ? t(mega(capacity), :count => number) : t(mega_name)[capacity]
+        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
+        def mega(capacity)
           t(:mega)[capacity]
         end
 

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

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

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

@@ -4,16 +4,16 @@ module NumbersAndWords
       module Latin
         include NumbersAndWords::Translations::Families::Base
 
-        def ones number, options = {}
-          t([options[:prefix], :ones].join('.'))[number]
+        def zero(options = {})
+          t([options[:prefix], :ones].join('.'))[0]
         end
 
-        def hundreds number, options = {}
-          [t(:ones)[number], t([options[:prefix], :hundreds].join('.'))].join options[:separator] || ' '
+        def ones(number, options = {})
+          t([options[:prefix], :ones].join('.'))[number]
         end
 
-        def zero options = {}
-          t([options[:prefix], :ones].join('.'))[0]
+        def hundreds(number, options = {})
+          [t(:ones)[number], t([options[:prefix], :hundreds].join('.'))].join options[:separator] || ' '
         end
       end
     end

data/lib/numbers_and_words/translations/fr.rb

@@ -2,27 +2,35 @@ module NumbersAndWords
   module Translations
     class Fr < Base
       include NumbersAndWords::Translations::Families::Latin
+      include NumbersAndWords::Translations::Extensions::FractionSignificance
 
       SPECIAL_TENS_CASE = 8
 
-      def tens number, options = {}
+      def tens(number, options = {})
         options[:alone] = true if options[:alone].nil?
-        (SPECIAL_TENS_CASE == number and options[:alone]) ? t(:eighty) : super(number)
+        SPECIAL_TENS_CASE == number && options[:alone] ? t(:eighty) : super(number)
       end
 
-      def tens_with_ones numbers, options = {}
+      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
+          [tens(numbers[1], alone: false), ones(numbers[0])].join union
         end
       end
 
-      def hundreds number, options = {}
+      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(' ')
+        hundreds = t(:hundreds, count: options[:pluralize] ? number : 1)
+        number == 1 ? hundreds : [t(:ones)[number], hundreds].join(' ')
+      end
+
+      def micro_prefix(capacity)
+        case capacity
+        when 2 then t(:hundreds, count: 1)
+        when 1 then tens(1)
+        end
       end
     end
   end

data/lib/numbers_and_words/translations/hu.rb

@@ -4,17 +4,17 @@ module NumbersAndWords
       include NumbersAndWords::Translations::Families::Latin
       include NumbersAndWords::Translations::Extensions::FractionSignificance
 
-      def tens_with_ones numbers, options = {}
+      def tens_with_ones(numbers, options = {})
         ones, tens = numbers
         [t(:tens_with_ones)[tens], t([options[:prefix], :ones_with_tens].join('.'))[ones]].join ''
       end
 
-      def hundreds number, options = {}
+      def hundreds(number, options = {})
         options[:separator] = ''
         super number, options
       end
 
-      def micros capacity, number = nil, separator = ''
+      def micros(capacity, _number = nil, separator = '')
         super capacity, nil, separator
       end
     end

data/lib/numbers_and_words/translations/it.rb

@@ -3,11 +3,11 @@ module NumbersAndWords
     class It < Base
       include NumbersAndWords::Translations::Families::Latin
 
-      def tens_with_ones numbers, options = {}
-        super numbers, :separator => ''
+      def tens_with_ones(numbers, _options = {})
+        super numbers, separator: ''
       end
 
-      def hundreds number, options = {}
+      def hundreds(number, _options = {})
         [[number], t(:hundreds)].join ' '
       end
     end

data/lib/numbers_and_words/translations/ka.rb

@@ -22,12 +22,12 @@ module NumbersAndWords
           range: Range.new(0, 9, false),
           name: :eighty,
           multiplicative: 8
-        },
-      ]
+        }
+      ].freeze
 
-      def vigesimal_range number
+      def vigesimal_range(number)
         range = nil
-        TENS_VIGESIMAL_RANGES.each do|item|
+        TENS_VIGESIMAL_RANGES.each do |item|
           if item[:range].include? number
             range = item
             break
@@ -37,20 +37,20 @@ module NumbersAndWords
         range
       end
 
-      def tens_with_ones numbers, options = {}
+      def tens_with_ones(numbers, _options = {})
         range = vigesimal_range(numbers[1])
 
-        if numbers[1] - range[:multiplicative] > 0
-          minor = teens(numbers)
-        else
-          minor = ones(numbers[0])
-        end
+        minor = if numbers[1] - range[:multiplicative] > 0
+                  teens(numbers)
+                else
+                  ones(numbers[0])
+                end
 
         [t([:partials, range[:name]].join('.')), minor].join ''
       end
 
-      def hundreds number, options = {}
-        options[:prefix] ||= (options[:only_hundreds] == true) ? nil : :partials
+      def hundreds(number, options = {})
+        options[:prefix] ||= options[:only_hundreds] == true ? nil : :partials
 
         parts = [t([options[:prefix], :one_hundred].join('.'))]
         parts.unshift(ones(number, prefix: :partials)) if number > 1
@@ -58,7 +58,7 @@ module NumbersAndWords
         parts.join ''
       end
 
-      def megs capacity, options = {}
+      def megs(capacity, options = {})
         if capacity == 1
           t([options[:prefix], :one_thousand].join('.'))
         elsif capacity == 2

data/lib/numbers_and_words/translations/lt.rb

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

data/lib/numbers_and_words/translations/lv.rb

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

data/lib/numbers_and_words/translations/nl.rb

@@ -3,12 +3,12 @@ module NumbersAndWords
     class Nl < Base
       include NumbersAndWords::Translations::Families::Latin
 
-      def tens_with_ones numbers, options = {}
+      def tens_with_ones(numbers, _options = {})
         [ones(numbers[0]), tens(numbers[1])].join 'en'
       end
 
-      def hundreds number, options = {}
-        1 == number ? t(:hundreds) : [t(:ones)[number], t(:hundreds)].join
+      def hundreds(number, _options = {})
+        number == 1 ? t(:hundreds) : [t(:ones)[number], t(:hundreds)].join
       end
     end
   end

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

@@ -4,20 +4,20 @@ module NumbersAndWords
       include NumbersAndWords::Translations::Families::Latin
       include NumbersAndWords::Translations::Extensions::FractionSignificance
 
-      def integral number, options = {}
-        t(:integral, :count => number)
+      def integral(number, _options = {})
+        t(:integral, count: number)
       end
 
-      def zero options = {}
+      def zero(options = {})
         t([options[:prefix], :ones, :male].join('.'))[0]
       end
 
-      def ones number, options = {}
+      def ones(number, options = {})
         return if options[:is_one_thousand]
         t([options[:prefix], :ones, options[:gender]].join('.'))[number]
       end
 
-      def tens number, options = {}
+      def tens(number, options = {})
         options[:alone] = true if options[:alone].nil?
         path = [options[:prefix], :tens]
         path.push(options[:gender]) if ordinal? options
@@ -25,25 +25,25 @@ module NumbersAndWords
         options[:alone] ? translated : "#{union} " + translated
       end
 
-      def teens number, options = {}
+      def teens(number, options = {})
         return [tens(1, options), ' ', ones(number[0], options)].join if ordinal? options
         super(number, options)
       end
 
-      def tens_with_ones numbers, options = {}
+      def tens_with_ones(numbers, options = {})
         connector = ' '
-        connector = " #{union} "  unless ordinal? options
+        connector = " #{union} " unless ordinal? options
         [tens(numbers[1], options), connector, ones(numbers[0], options)].join
       end
 
-      def hundreds number, options = {}
-        return t(:one_hundred) if options[:is_one_hundred] and !(ordinal? options)
+      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}"
       end
 
-      def megs capacity, options = {}
+      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?
@@ -54,22 +54,22 @@ module NumbersAndWords
         (options[:is_one] ? t(:mega)[capacity] : t(:megas)[capacity]) + suffix
       end
 
-      def micros capacity, number, separator = ' de '
+      def micros(capacity, number, separator = t('micro_prefix.separator'))
         micro, prefix = capacity
-        micros = number ? t(micro(micro), :count => number) : micro(micro)
-        [micro_prefix(prefix, number), micros].compact.join separator
+        micros = number ? t(micro(micro), count: number) : micro(micro)
+        [micro_prefix(prefix, number), micros].compact.join(" #{separator} ")
       end
 
-      def micro_prefix capacity, number
+      def micro_prefix(capacity, number)
         case capacity
-        when 2 then t('micro_prefix.hundreds', :count => number)
-        when 1 then t('micro_prefix.tens', :count => number)
+        when 2 then t('micro_prefix.hundreds', count: number)
+        when 1 then t('micro_prefix.tens', count: number)
         end
       end
 
       private
 
-      def ordinal? options
+      def ordinal?(options)
         options[:prefix] == :ordinal
       end
     end

data/lib/numbers_and_words/translations/pt.rb

@@ -3,25 +3,24 @@ module NumbersAndWords
     class Pt < Base
       include NumbersAndWords::Translations::Families::Latin
 
-      def tens numbers, options = {}
+      def tens(numbers, options = {})
         options[:alone] = true if options[:alone].nil?
         options[:alone] ? super(numbers) : "#{t(:union)} " + super(numbers)
       end
 
-      def tens_with_ones numbers, options = {}
+      def tens_with_ones(numbers, _options = {})
         [tens(numbers[1]), " #{t(:union)} ", ones(numbers[0])].join
       end
 
-      def hundreds number, options = {}
+      def hundreds(number, options = {})
         return t(:one_hundred) if options[:is_one_hundred]
         options[:is_hundred] ? t(:hundreds)[number - 1] : t(:hundreds)[number - 1] + ' e'
       end
 
-      def megs capacity, options = {}
+      def megs(capacity, options = {})
         options[:is_one] = false if options[:is_one].nil?
         options[:is_one] ? t(:mega)[capacity] : t(:megas)[capacity]
       end
-
     end
   end
 end

data/lib/numbers_and_words/translations/ru.rb

@@ -4,22 +4,22 @@ module NumbersAndWords
       include NumbersAndWords::Translations::Families::Cyrillic
       include NumbersAndWords::Translations::Extensions::FractionSignificance
 
-      def micros capacity, number = nil, separator = ' '
+      def micros(capacity, number = nil, separator = ' ')
         micro, prefix = capacity
-        micros = t(:micro, :count => number)[micro]
+        micros = t(:micro, count: number)[micro]
         [micro_prefix(prefix), micros].compact.join separator
       end
 
-      def micro_prefix capacity
+      def micro_prefix(capacity)
         case capacity
         when 2 then t(:sub_micro)[2]
         when 1 then t(:sub_micro)[1]
         end
       end
 
-      #def fraction_separator options = {}
+      # def fraction_separator options = {}
       #  super if options[:with_fractional_separator]
-      #end
+      # end
     end
   end
 end

data/lib/numbers_and_words/translations/se.rb

@@ -3,8 +3,8 @@ module NumbersAndWords
     class Se < Base
       include NumbersAndWords::Translations::Families::Latin
 
-      def tens_with_ones numbers, options = {}
-        super numbers, :separator => '-'
+      def tens_with_ones(numbers, _options = {})
+        super numbers, separator: '-'
       end
     end
   end

data/lib/numbers_and_words/translations/tr.rb

@@ -3,18 +3,17 @@ module NumbersAndWords
     class Tr < Base
       include NumbersAndWords::Translations::Families::Latin
 
-      def tens_with_ones numbers, options = {}
-        super numbers, :separator => ' '
+      def tens_with_ones(numbers, _options = {})
+        super numbers, separator: ' '
       end
 
-      def hundreds number, options = {}
+      def hundreds(number, options = {})
         if number == 1
           [t([options[:prefix], :hundreds].join('.'))].join options[:separator] || ' '
         else
           [t(:ones)[number], t([options[:prefix], :hundreds].join('.'))].join options[:separator] || ' '
         end
       end
-
     end
   end
 end