numbers_in_words 0.3.0 → 1.0.0

data/lib/numbers_in_words/parsing/to_number.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative './special'
+require_relative './fraction_parsing'
+
+module NumbersInWords
+  class ToNumber
+    include FractionParsing
+    extend Forwardable
+    def_delegator :that, :to_s
+
+    attr_reader :that, :only_compress
+
+    def initialize(that, only_compress)
+      @that = that
+      @only_compress = only_compress
+    end
+
+    def call
+      special || decimal || as_numbers
+    end
+
+    private
+
+    def special
+      Special.new(that, only_compress).call
+    end
+
+    def decimal
+      match = check_decimal text
+      return unless match
+
+      integer = NumbersInWords.in_numbers(match.pre_match)
+      decimal = NumbersInWords.in_numbers(match.post_match)
+      integer + "0.#{decimal}".to_f
+    end
+
+    def as_numbers
+      numbers = word_array_to_nums text.split(' ')
+
+      NumbersInWords::NumberParser.new.parse numbers, only_compress: only_compress
+    end
+
+    def word_array_to_nums(words)
+      words.map { |i| word_to_num(i) }.compact
+    end
+
+    # handles simple single word numbers
+    # e.g. one, seven, twenty, eight, thousand etc
+    def word_to_num(word)
+      text = canonize(word.to_s.chomp.strip)
+
+      NumbersInWords.exceptional_number(text) || fraction(text) || power(text)
+    end
+
+    def power(text)
+      power = NumbersInWords.power_of_ten(text)
+
+      10**power if power
+    end
+
+    def canonize(word)
+      aliases[word] || word
+    end
+
+    def aliases
+      {
+        'a' => 'one',
+        'oh' => 'zero'
+      }
+    end
+
+    def check_decimal(txt)
+      txt.match(/\spoint\s/)
+    end
+  end
+end

data/lib/numbers_in_words/powers_of_ten.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module NumbersInWords
+  GOOGOL = 10**100
+
+  POWERS_OF_TEN = {
+    0 => 'one',
+    1 => 'ten',
+    2 => 'hundred',
+    1 * 3 => 'thousand',
+    2 * 3 => 'million',
+    3 * 3 => 'billion',
+    4 * 3 => 'trillion',
+    5 * 3 => 'quadrillion',
+    6 * 3 => 'quintillion',
+    7 * 3 => 'sextillion',
+    8 * 3 => 'septillion',
+    9 * 3 => 'octillion',
+    10 * 3 => 'nonillion',
+    11 * 3 => 'decillion',
+    12 * 3 => 'undecillion',
+    13 * 3 => 'duodecillion',
+    14 * 3 => 'tredecillion',
+    15 * 3 => 'quattuordecillion',
+    16 * 3 => 'quindecillion',
+    17 * 3 => 'sexdecillion',
+    18 * 3 => 'septendecillion',
+    19 * 3 => 'octodecillion',
+    20 * 3 => 'novemdecillion',
+    21 * 3 => 'vigintillion',
+    22 * 3 => 'unvigintillion',
+    23 * 3 => 'duovigintillion',
+    24 * 3 => 'trevigintillion',
+    25 * 3 => 'quattuorvigintillion',
+    26 * 3 => 'quinvigintillion',
+    27 * 3 => 'sexvigintillion',
+    28 * 3 => 'septenvigintillion',
+    29 * 3 => 'octovigintillion',
+    30 * 3 => 'novemvigintillion',
+    31 * 3 => 'trigintillion',
+    32 * 3 => 'untrigintillion',
+    33 * 3 => 'duotrigintillion',
+    100 => 'googol',
+    101 * 3 => 'centillion',
+    GOOGOL => 'googolplex'
+  }.freeze
+
+  POWERS_RX = Regexp.union(POWERS_OF_TEN.values[1..-1]).freeze
+end

data/lib/numbers_in_words/to_word.rb

@@ -1,19 +1,84 @@
-class NumbersInWords::ToWord
-  def initialize that, language=NumbersInWords.language
-    @that = that
-    @language = language
-  end
+# frozen_string_literal: true
+
+require_relative 'writer'
+require_relative 'number_group'
+require_relative 'fraction'
 
-  def in_words language=nil
-    language ||= @language
+module NumbersInWords
+  # Arbitrarily small number for rationalizing fractions
+  EPSILON = 0.0000000001
 
-    case language
-    when "English" #allow for I18n
-      in_english
+  class ToWord
+    attr_reader :that
+
+    def initialize(that)
+      @that = that
     end
-  end
 
-  def in_english
-    NumbersInWords::English::LanguageWriterEnglish.new(@that).in_words
+    def to_i
+      that.to_i
+    end
+
+    def negative
+      return unless to_i.negative?
+
+      'minus ' + NumbersInWords.in_words(-@that)
+    end
+
+    def in_words(fraction: false)
+      as_fraction(fraction) ||
+        handle_exceptional_numbers ||
+        decimals ||
+        negative ||
+        output
+    end
+
+    def as_fraction(fraction)
+      return Fraction.in_words(that) if fraction
+    end
+
+    def decimals
+      int, decimals = NumberGroup.new(@that).split_decimals
+      return unless int
+
+      out = NumbersInWords.in_words(int) + ' point '
+      decimals.each do |decimal|
+        out << NumbersInWords.in_words(decimal.to_i) + ' '
+      end
+      out.strip
+    end
+
+    def output
+      output = if to_i.to_s.length == 2 # 20-99
+                 handle_tens(to_i)
+               else
+                 Writer.new(that).call # longer numbers
+               end
+
+      output.strip
+    end
+
+    def handle_tens(number)
+      output = ''
+
+      tens = (number / 10).round * 10 # write the tens
+
+      output += NumbersInWords.lookup(tens) # e.g. eighty
+
+      digit = number - tens # write the digits
+
+      unless digit.zero?
+        join = number < 100 ? '-' : ' '
+        output << join + NumbersInWords.in_words(digit)
+      end
+
+      output
+    end
+
+    def handle_exceptional_numbers
+      return unless @that.is_a?(Integer)
+
+      NumbersInWords.exceptional_numbers.lookup(@that)
+    end
   end
 end

data/lib/numbers_in_words/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module NumbersInWords
-  VERSION = "0.3.0"
+  VERSION = '1.0.0'
 end

data/lib/numbers_in_words/writer.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module NumbersInWords
+  class Writer
+    def initialize(that)
+      @that = that
+    end
+
+    def call
+      length = @that.to_s.length
+      output =
+        if length == 3
+          # e.g. 113 splits into "one hundred" and "thirteen"
+          write_groups(2)
+
+          # more than one hundred less than one googol
+        elsif length < LENGTH_OF_GOOGOL
+          write_groups(3)
+
+        elsif length >= LENGTH_OF_GOOGOL
+          write_googols
+        end
+      output.strip
+    end
+
+    def group_words(size)
+      # 1000 and over Numbers are split into groups of three
+      groups = NumberGroup.groups_of @that, size
+      powers = groups.keys.sort.reverse # put in descending order
+
+      powers.each do |power|
+        name = NumbersInWords::POWERS_OF_TEN[power]
+        digits = groups[power]
+        yield power, name, digits
+      end
+    end
+
+    private
+
+    def write_googols
+      googols, remainder = NumberGroup.new(@that).split_googols
+      output = ''
+
+      output = output + ' ' + NumbersInWords.in_words(googols) + ' googol'
+      if remainder.positive?
+        prefix = ' '
+        prefix += 'and ' if remainder < 100
+        output = output + prefix + NumbersInWords.in_words(remainder)
+      end
+
+      output
+    end
+
+    def write_groups(group)
+      # e.g. 113 splits into "one hundred" and "thirteen"
+      output = ''
+      group_words(group) do |power, name, digits|
+        if digits.positive?
+          prefix = ' '
+          # no and between thousands and hundreds
+          prefix += 'and ' if power.zero? && (digits < 100)
+          output = output + prefix + NumbersInWords.in_words(digits)
+          output = output + prefix + name unless power.zero?
+        end
+      end
+      output
+    end
+  end
+end

data/numbers_in_words.gemspec

@@ -1,23 +1,24 @@
-# -*- encoding: utf-8 -*-
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'numbers_in_words/version'
 
 Gem::Specification.new do |gem|
-  gem.name          = "numbers_in_words"
-  gem.description   = "#in_words method for integers and #in_numbers for strings"
-  gem.summary       = "Example: 123.in_words # => \"one hundred and twenty three\", \"seventy-five point eight\".in_numbers # = > 75.8"
+  gem.name          = 'numbers_in_words'
+  gem.description   = 'convert written numbers into Integers and vice-versa'
+  gem.summary       = 'Example: NumbersInWords.in_words(123) # => ' \
+    '"one hundred and twenty three", NumbersInWords.in_numbers("seventy-five point eight") # = > 75.8'
 
   gem.version       = NumbersInWords::VERSION
-  gem.authors       = ["Mark Burns"]
-  gem.email         = ["markthedeveloper@gmail.com"]
-  gem.homepage      = "http://github.com/markburns/numbers_in_words"
+  gem.authors       = ['Mark Burns', 'Dimid Duchovny']
+  gem.email         = ['markthedeveloper@gmail.com', 'dimidd@gmail.com']
+  gem.homepage      = 'http://github.com/markburns/numbers_in_words'
 
-  gem.add_dependency      "activesupport"
-  gem.add_development_dependency      "rspec", "~> 3.4.0"
+  gem.add_development_dependency      'rspec', '~> 3.4.0'
+  gem.add_development_dependency      'rubocop'
 
-  gem.files         = `git ls-files`.split($/)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.require_paths = ["lib"]
+  gem.require_paths = ['lib']
 end

data/spec/exceptional_numbers_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require './spec/spec_helper'
+
+describe NumbersInWords::ExceptionalNumbers do
+  describe '#fraction' do
+    FRACTIONS = {
+      [1, 2] => 'one half',
+      [2, 2] => 'two halves',
+      [3, 2] => 'three halves',
+      [1, 3] => 'one third',
+      [1, 4] => 'one quarter',
+      [2, 17] => 'two seventeenths',
+      [1, 1_000] => 'one one thousandth',
+      [74, 101] => 'seventy-four hundred and firsts',
+      [13, 97] => 'thirteen ninety-sevenths',
+      [131, 1_000] => 'one hundred and thirty-one thousandths'
+    }.freeze
+
+    FRACTIONS.each do |(numerator, denominator), string|
+      it "#{numerator}/#{denominator} == #{string}" do
+        expect(subject.fraction(denominator: denominator, numerator: numerator).in_words).to eql(string)
+      end
+    end
+  end
+end

data/spec/fraction_spec.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+RSpec.describe NumbersInWords::Fraction do # rubocop: disable Metrics/BlockLength
+  subject do
+    described_class.new(numerator: numerator, denominator: denominator, attributes: attributes)
+  end
+
+  let(:numerator) { 1 }
+
+  context 'halves' do
+    let(:denominator) { 2 }
+    let(:attributes) do
+      { number: 'two',
+        ordinal: 'second',
+        fraction: { singular: 'half', plural: 'halves' } }
+    end
+
+    it do
+      expect(subject.in_words).to eq 'one half'
+    end
+
+    context 'with plural' do
+      let(:numerator) { 2 }
+
+      it do
+        expect(subject.in_words).to eq 'two halves'
+      end
+    end
+  end
+
+  context 'quarters' do
+    let(:denominator) { 4 }
+    let(:attributes) do
+      {
+        number: 'four',
+        ordinal: 'fourth',
+        fraction: { singular: 'quarter' }
+      }
+    end
+
+    it do
+      expect(subject.in_words).to eq 'one quarter'
+    end
+  end
+
+  context 'fifths' do
+    let(:denominator) { 5 }
+    let(:attributes) do
+      { number: 'five', ordinal: 'fifth' }
+    end
+
+    it do
+      expect(subject.in_words).to eq 'one fifth'
+    end
+  end
+
+  context 'sixths' do
+    let(:denominator) { 6 }
+    let(:attributes) { {} }
+
+    it do
+      expect(subject.in_words).to eq 'one sixth'
+    end
+  end
+
+  context 'nineteenths' do
+    let(:denominator) { 19 }
+    let(:attributes) { {} }
+
+    it do
+      expect(subject.in_words).to eq 'one nineteenth'
+      expect(subject.fraction).to eq 'nineteenth'
+    end
+
+    context 'plural' do
+      let(:numerator) { 763 }
+
+      it do
+        expect(subject.in_words).to eq 'seven hundred and sixty-three nineteenths'
+      end
+    end
+  end
+
+  context 'one hundred and seconds' do
+    let(:denominator) { 102 }
+    let(:attributes) { {} }
+
+    it do
+      expect(subject.in_words).to eq 'one one hundred and second'
+    end
+  end
+
+  context 'one hundred and sixth' do
+    let(:denominator) { 106 }
+    let(:attributes) { {} }
+
+    it do
+      expect(subject.in_words).to eq 'one one hundred and sixth'
+    end
+  end
+
+  context 'one hundred and nineteenth' do
+    let(:denominator) { 119 }
+    let(:attributes) { {} }
+
+    it do
+      expect(subject.ordinal).to eq 'one hundred and nineteenth'
+      expect(subject.in_words).to eq 'one one hundred and nineteenth'
+    end
+  end
+
+  context 'one thousandth' do
+    let(:denominator) { 1000 }
+    let(:attributes) { {} }
+
+    it do
+      expect(subject.ordinal).to eq 'one thousandth'
+      expect(subject.in_words).to eq 'one one thousandth'
+    end
+
+    context 'plural' do
+      let(:numerator) { 2 }
+      let(:denominator) { 1000 }
+
+      it do
+        expect(subject.in_words).to eq 'two thousandths'
+      end
+    end
+  end
+
+  context 'googolplexths' do
+    let(:denominator) { Kernel.silence_warnings { 10**(10**100) } }
+
+    let(:attributes) do
+      { number: 'googolplex',
+        ordinal: 'googolplexth',
+        fraction: { singular: 'googolplexth', plural: 'googolplexths' } }
+    end
+
+    it do
+      expect(subject.in_words).to eq 'one infinitieth'
+    end
+
+    context 'with plural' do
+      let(:numerator) { 2 }
+
+      it do
+        expect(subject.in_words).to eq 'two infinitieths'
+      end
+    end
+  end
+end