numbers_in_words 0.2.0 → 0.5.1

data/lib/numbers_in_words/fraction.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module NumbersInWords
+  class Fraction
+    attr_reader :denominator, :numerator, :attributes
+
+    def self.in_words(that)
+      r = that.rationalize(EPSILON)
+
+      NumbersInWords
+        .fraction(denominator: r.denominator, numerator: r.numerator)
+        .in_words
+    end
+
+    def initialize(denominator:, numerator: 1, attributes: nil)
+      @denominator = denominator
+      @numerator = numerator
+      @attributes = attributes || NumbersInWords::ExceptionalNumbers::DEFINITIONS[denominator] || {}
+    end
+
+    def lookup_keys
+      key = in_words
+      key2 = strip_punctuation(key.split(' ')).join(' ')
+
+      key3 = "a #{key}"
+      key4 = "an #{key}"
+      key5 = "a #{key2}"
+      key6 = "an #{key2}"
+      [key, key2, key3, key4, key5, key6].uniq
+    end
+
+    def in_words
+      NumbersInWords.in_words(numerator) + ' ' + fraction
+    end
+
+    def ordinal
+      pluralize? ? pluralized_ordinal_in_words : singular_ordinal_in_words
+    end
+
+    def fraction
+      if denominator == Float::INFINITY
+        # We've reached the limits of ruby's number system
+        # by the time we get to a googolplex (10 ** (10 ** 100))
+        return pluralize? ? 'infinitieths' : 'infinitieth'
+      end
+
+      pluralize? ? pluralized_fraction : singular_fraction
+    end
+
+    private
+
+    def strip_punctuation(words)
+      words.map { |w| w.gsub(/^a-z/, ' ') }
+    end
+
+    def pluralized_fraction
+      fraction_plural || pluralized_ordinal_in_words
+    end
+
+    def singular_fraction
+      fraction_singular || singular_ordinal_in_words
+    end
+
+    def pluralized_ordinal_in_words
+      pluralized_ordinal || denominator_ordinal_in_words
+    end
+
+    def singular_ordinal_in_words
+      singular_ordinal || denominator_ordinal_in_words
+    end
+
+    def singular_ordinal
+      attributes[:ordinal]
+    end
+
+    def pluralized_ordinal
+      singular_ordinal && singular_ordinal + 's'
+    end
+
+    def pluralize?
+      numerator > 1
+    end
+
+    def denominator_ordinal_in_words
+      if denominator > 100
+        # one hundred and second
+        with_remainder(100, ' and ')
+      elsif denominator > 19
+        # two thirty-fifths
+        with_remainder(10, '-')
+      else
+        # one seventh
+        singular = NumbersInWords.in_words(denominator) + 'th'
+        pluralize? ? singular + 's' : singular
+      end
+    end
+
+    def with_remainder(mod, join_word)
+      rest = denominator % mod
+      main = denominator - rest
+      main = NumbersInWords.in_words(main)
+
+      main = main.gsub(/^one /, '') if pluralize?
+
+      rest_zero(rest, main) || joined(main, rest, join_word)
+    end
+
+    def joined(main, rest, join_word)
+      main +
+        join_word +
+        self.class.new(numerator: numerator, denominator: rest).ordinal
+    end
+
+    def rest_zero(rest, main)
+      return unless rest.zero?
+
+      if pluralize?
+        main + 'ths'
+      else
+        main + 'th'
+      end
+    end
+
+    def exception
+      attributes[:fraction]
+    end
+
+    def fraction_singular
+      exception && exception[:singular]
+    end
+
+    def fraction_plural
+      exception && exception[:plural]
+    end
+  end
+end

data/lib/numbers_in_words/number_group.rb

@@ -1,55 +1,64 @@
+# frozen_string_literal: true
+
 module NumbersInWords
   class NumberGroup
     include Enumerable
     attr_accessor :number
 
-    def each
-      @array.each { |item|  yield item}
+    def self.groups_of(number, size)
+      new(number).groups(size)
     end
 
-    def initialize number
+    def initialize(number)
       @number = number
     end
 
-    #split into groups this gives us 1234567 => 123 456 7
-    #so we need to reverse first
-    #in stages
-    def groups size
-      #1234567   => %w(765 432 1)
-      @array = @number.to_s.reverse.split("").in_groups_of(size)
-      #%w(765 432 1) => %w(1 432 765)
+    # split into groups this gives us 1234567 => 123 456 7
+    # so we need to reverse first
+    # in stages
+    def groups(size)
+      # 1234567   => %w(765 432 1)
+      @array = in_groups_of(@number.to_s.reverse.split(''), size)
+      # %w(765 432 1) => %w(1 432 765)
       @array.reverse!
 
-      #%w(1 432 765) => [1, 234, 567]
-      @array.map! {|group| group.reverse.join("").to_i}
+      # %w(1 432 765) => [1, 234, 567]
+      @array.map! { |group| group.reverse.join('').to_i }
       @array.reverse! # put in ascending order of power of ten
 
       power = 0
 
-      #[1, 234, 567] => {6 => 1, 3 => 234, 0 => 567}
-      @array.inject({}) do |o, digits|
+      # [1, 234, 567] => {6 => 1, 3 => 234, 0 => 567}
+      @array.each_with_object({}) do |digits, o|
         o[power] = digits
         power += size
-        o
       end
     end
 
     def split_decimals
-      if @number.is_a? Float
-        int, decimal = @number.to_s.split "."
+      return unless @number.is_a? Float
 
-        return int.to_i, decimal.split(//).map(&:to_i)
-      end
-    end
+      int, decimal = @number.to_s.split '.'
 
-    def self.groups_of number, size
-      new(number).groups(size)
+      [int.to_i, decimal.split(//).map(&:to_i)]
     end
 
     def split_googols
-      googols   = @number.to_s[0  ..  (-LENGTH_OF_GOOGOL)].to_i
-      remainder = @number.to_s[(1-LENGTH_OF_GOOGOL) .. -1].to_i
-      return googols, remainder
+      googols   = @number.to_s[0..-LENGTH_OF_GOOGOL].to_i
+      remainder = @number.to_s[(1 - LENGTH_OF_GOOGOL)..].to_i
+      [googols, remainder]
+    end
+
+    private
+
+    def in_groups_of(array, number, fill_with = nil)
+      # size % number gives how many extra we have;
+      # subtracting from number gives how many to add;
+      # modulo number ensures we don't add group of just fill.
+      padding = (number - array.size % number) % number
+      collection = array.dup.concat(Array.new(padding, fill_with))
+
+      collection.each_slice(number).to_a
     end
   end
 end

data/lib/numbers_in_words/parsing/fraction_parsing.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module NumbersInWords
+  module FractionParsing
+    def fraction(text)
+      return unless possible_fraction?(text)
+
+      NumbersInWords.exceptional_numbers.lookup_fraction(text)
+    end
+
+    def strip_punctuation(text)
+      text = text.downcase.gsub(/[^a-z 0-9]/, ' ')
+      to_remove = true
+
+      to_remove = text.gsub! '  ', ' ' while to_remove
+
+      text
+    end
+
+    def possible_fraction?(text)
+      words = text.split(' ')
+      result = words & NumbersInWords.exceptional_numbers.fraction_names
+      result.length.positive?
+    end
+
+    def text_including_punctuation
+      to_s.strip
+    end
+
+    def text
+      strip_punctuation text_including_punctuation
+    end
+  end
+end

data/lib/numbers_in_words/parsing/number_parser.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require_relative 'parse_fractions'
+require_relative 'parse_status'
+require_relative 'parse_individual_number'
+require_relative 'pair_parsing'
+
+module NumbersInWords
+  class NumberParser
+    # Example: 364,895,457,898
+    # three hundred and sixty four billion eight hundred and ninety five million
+    # four hundred and fifty seven thousand eight hundred and ninety eight
+    #
+    # 3 100 60 4 10^9, 8 100 90 5 10^6, 4 100 50 7 1000, 8 100 90 8
+    #                                                                    memory answer
+    # x1. 3 add to memory because answer and memory are zero                 3     0
+    # x2. memory * 100 (because memory<100)                                  300   0
+    # x3. 60 add to memory because memory > 60                               360   0
+    # x3. 4 add to memory because memory > 4                                364    0
+    # x4. multiply memory by 10^9 because memory < power of ten          364*10^9  0
+    # x5. add memory to answer  (and reset)memory > 8 (memory pow of ten > 2) 0   364*10^9
+    # x6. 8 add to memory because not finished                                8    ''
+    # x7. multiply memory by 100 because memory < 100                        800   ''
+    # x8. add 90 to memory because memory > 90                               890   ''
+    # x9. add 5 to memory because memory > 5                                 895   ''
+    # x10. multiply memory by 10^6 because memory < power of ten        895*10^6    ''
+    # x11. add memory to answer (and reset) because memory power ten > 2       0    364895 * 10^6
+    # x12. 4 add to memory because not finished                                4    ''
+    # x13. memory * 100 because memory < 100                                 400    ''
+    # x14. memory + 50 because memory > 50                                   450    ''
+    # x15. memory + 7  because memory > 7                                    457    ''
+    # x16. memory * 1000 because memory < 1000                            457000    ''
+    # x17. add memory to answer  (and reset)memory > 8 (memory pow of ten > 2) 0   364895457000
+    # x18. 8 add to memory because not finished                                8    ''
+    # x19. memory * 100 because memory < 100                                 800    ''
+    # x14. memory + 90 because memory > 90                                   890    ''
+    # x15. memory + 8  because memory > 8                                    898    ''
+    # 16. finished so add memory to answer
+
+    # Example
+    # 2001
+    # two thousand and one
+    # 2 1000 1
+    #                                                        memory answer
+    # 1. add 2 to memory because first                          2       0
+    # 2. multiply memory by 1000 because memory < 1000        2000      0
+    # 3. add memory to answer,reset,  because power of ten>2    0      2000
+    # 4. add 1 to memory                                        1      2000
+    # 5. finish - add memory to answer                          0      2001
+
+    SCALES_N = [10**2, 10**3, 10**6, 10**9, 10**12, 10**100].freeze
+
+    def parse(nums, only_compress: false)
+      fractions(nums) ||
+        small_numbers(nums, only_compress) ||
+        pair_parsing(nums, only_compress) ||
+        parse_each(nums)
+    end
+
+    private
+
+    def fractions(nums)
+      ParseFractions.new(nums).call
+    end
+
+    # 7 0.066666666666667 => 0.46666666666666
+
+    # 15 => 15
+    def small_numbers(nums, only_compress)
+      return unless nums.length < 2
+      return nums if only_compress
+
+      nums.empty? ? 0 : nums[0]
+    end
+
+    # 15 75 => 1,575
+    def pair_parsing(nums, only_compress)
+      return if (SCALES_N & nums).any?
+
+      pair_parse(nums, only_compress)
+    end
+
+    def parse_each(nums)
+      status = ParseStatus.new
+
+      nums.each do |num|
+        ParseIndividualNumber.new(status, num).call
+      end
+
+      status.calculate
+    end
+
+    def pair_parse(nums, only_compress)
+      PairParsing.new(nums, only_compress).pair_parse
+    end
+  end
+end

data/lib/numbers_in_words/parsing/pair_parsing.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module NumbersInWords
+  class PairParsing
+    attr_accessor :ints
+    attr_reader :only_compress
+
+    def initialize(ints, only_compress)
+      @ints = ints
+      @only_compress = only_compress
+    end
+
+    # 15,16
+    # 85,16
+    def pair_parse
+      ints = compressed
+      return ints if only_compress
+
+      return ints[0] if ints.length == 1
+
+      sum = 0
+
+      ints.each do |n|
+        sum *= n >= 10 ? 100 : 10
+        sum += n
+      end
+
+      sum
+    end
+
+    private
+
+    # [40, 2] => [42]
+    def compressed
+      return [] if ints.empty?
+
+      result = []
+      index = 0
+
+      index, result = compress_numbers(result, index)
+
+      result << ints[-1] if index < ints.length
+
+      result
+    end
+
+    def compress_numbers(result, index)
+      while index < ints.length - 1
+        int, jump = compress_int(ints[index], ints[index + 1])
+        result << int
+        index += jump
+      end
+
+      [index, result]
+    end
+
+    def compress_int(int, next_int)
+      tens = (int % 10).zero? && int > 10
+      return [int + next_int, 2] if tens && next_int < 10
+
+      [int, 1]
+    end
+  end
+end

data/lib/numbers_in_words/parsing/parse_fractions.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module NumbersInWords
+  class ParseFractions
+    attr_reader :nums
+
+    def initialize(nums)
+      @nums = nums.map(&:to_f)
+    end
+
+    def call
+      return if no_fractions?
+
+      just_fraction || calculate
+    end
+
+    def calculate
+      (parse(numbers) * parse(fractions)).rationalize(EPSILON).to_f
+    end
+
+    def parse(numbers)
+      NumberParser.new.parse(numbers)
+    end
+
+    def numbers
+      nums[0..index_of_fraction - 1]
+    end
+
+    def fractions
+      nums[index_of_fraction..]
+    end
+
+    def just_fraction
+      return nums.first if index_of_fraction.zero?
+    end
+
+    def index_of_fraction
+      nums.index { |n| n < 1.0 }
+    end
+
+    def no_fractions?
+      nums.all? { |n| n.zero? || n >= 1.0 }
+    end
+  end
+end