numbers_in_words 0.4.0 → 0.4.1

data/.travis.yml

@@ -1,7 +1,7 @@
+sudo: false
 language: ruby
 rvm:
- - "1.9.3"
- - "2.1.7"
- - "2.2.3"
- - rbx
+ - "2.4.6"
+ - "2.5.5"
+ - "2.6.3"
 script: ./bin/spec

data/Gemfile

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
-gem "codeclimate-test-reporter", group: :test, require: nil
+gem 'byebug'
 # Specify your gem's dependencies in numbers_in_words.gemspec
 gemspec

data/README.md

@@ -1,24 +1,16 @@
 [![Build Status](http://img.shields.io/travis/markburns/numbers_in_words.svg)](https://travis-ci.org/markburns/numbers_in_words)
-[![Dependency Status](http://img.shields.io/gemnasium/markburns/numbers_in_words.svg)](https://gemnasium.com/markburns/numbers_in_words)
-[![Code Climate](http://img.shields.io/codeclimate/github/markburns/numbers_in_words.svg)](https://codeclimate.com/github/markburns/numbers_in_words)
-[![Test Coverage](https://codeclimate.com/github/markburns/numbers_in_words/badges/coverage.svg)](https://codeclimate.com/github/markburns/numbers_in_words/coverage)
+[![Maintainability](https://api.codeclimate.com/v1/badges/a51210488896b798af20/maintainability)](https://codeclimate.com/github/markburns/numbers_in_words/maintainability)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/a51210488896b798af20/test_coverage)](https://codeclimate.com/github/markburns/numbers_in_words/test_coverage)
 [![Gem Version](http://img.shields.io/gem/v/numbers_in_words.svg)](https://rubygems.org/gems/numbers_in_words)
 [![License](http://img.shields.io/:license-mit-blue.svg)](http://markburns.mit-license.org)
-[![Badges](http://img.shields.io/:badges-7/7-ff6799.svg)](https://github.com/badges/badgerbadgerbadger)
 
 Installation
 ============
 
 ```ruby
 gem 'numbers_in_words'
-
-require 'numbers_in_words'
-require 'numbers_in_words/duck_punch' #optional see why later
 ```
 
-This project was created for a test for a job interview. I haven't really used
-it myself, but I saw it mentioned somewhere so I thought I'd tidy it up a bit.
-
 Usage
 =========
 
@@ -33,6 +25,9 @@ NumbersInWords.in_numbers("one googol")
 
 NumbersInWords.in_numbers("Seventy million, five-hundred and fifty six thousand point eight nine three")
 #=> 70556000.893
+
+NumbersInWords.in_numbers("nineteen sixty five")
+#=> 1965
 ```
 
 
@@ -50,36 +45,3 @@ require 'numbers_in_words/duck_punch'
 "Seventy million, five-hundred and fifty six thousand point eight nine three".in_numbers
 #=> 70556000.893
 ```
-
-
-NoMethodError `in_words` or `in_numbers`
-----------
-I'm going to hopefully preempt some support queries by predicting this will happen:
-
-You've got one of:
-
-```
-NoMethodError: undefined method `in_words' for 123:Fixnum
-NoMethodError: undefined method `in_numbers' for "123":String
-```
-
-Previous versions of this gem duckpunched Fixnum and String with a whole bunch
-of methods. This gem will now only add methods if you specifically tell it to
-with:
-
-```ruby
-require 'numbers_in_words'
-require 'numbers_in_words/duck_punch'
-```
-
-Plus it now only adds a single `#in_words` method to `Numeric` and an `#in_numbers`
-method to `String` instead of a whole bunch of them.
-
-
-Future plans
-============
-
-* Handle complex numbers
-* Option for outputting punctuation
-* Reject invalid numbers
-* Support for other languages

data/Rakefile

@@ -1 +1,3 @@
-require "bundler/gem_tasks"
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'

data/lib/numbers_in_words.rb

@@ -1,33 +1,57 @@
-require 'active_support/core_ext/array'
+# frozen_string_literal: true
 
-require "numbers_in_words/version"
-require 'numbers_in_words/language_writer'
-
-require 'numbers_in_words/english/constants'
-require 'numbers_in_words/english/language_writer_english'
-
-require 'numbers_in_words/number_group'
-require 'numbers_in_words/number_parser'
-require 'numbers_in_words/to_number'
+require 'numbers_in_words/version'
+require 'numbers_in_words/exceptional_numbers'
 require 'numbers_in_words/to_word'
+require 'numbers_in_words/parsing/to_number'
 
 module NumbersInWords
-  LENGTH_OF_GOOGOL = 101 #length of the string i.e. one with 100 zeros
+  LENGTH_OF_GOOGOL      = 101 # length of the string i.e. one with 100 zeros
+  Error                 = ::Class.new(::StandardError)
+  AmbiguousParsingError = ::Class.new(Error)
+  DivideByZeroError     = ::Class.new(Error)
+  InvalidNumber         = ::Class.new(Error)
 
   class << self
-    attr_writer :language
+    extend Forwardable
+    def_delegators :exceptional_numbers, :fraction
+
+    def in_words(num, fraction: false)
+      ToWord.new(num).in_words(fraction: fraction)
+    end
+
+    def in_numbers(words, only_compress: false)
+      ToNumber.new(words, only_compress).call
+    end
+
+    def exceptional_numbers
+      @exceptional_numbers ||= ExceptionalNumbers.new
+    end
 
-    def language
-      @language ||= "English"
+    def lookup(number)
+      exceptional_numbers.lookup(number)
     end
 
-    def in_words(i, language=NumbersInWords.language, only_compress=false)
-      NumbersInWords::ToWord.new(i, language).in_words(only_compress)
+    def exceptional_number(text)
+      exceptional_numbers_to_i[text]
     end
 
-    def in_numbers(s, language=NumbersInWords.language, only_compress=false)
-      NumbersInWords::ToNumber.new(s, language).in_numbers(only_compress)
+    def power_of_ten(text)
+      powers_of_ten_to_i[text]
+    end
+
+    private
+
+    def exceptional_numbers_to_i
+      @exceptional_numbers_to_i ||= swap_keys exceptional_numbers.to_h
+    end
+
+    def powers_of_ten_to_i
+      @powers_of_ten_to_i ||= swap_keys POWERS_OF_TEN
+    end
+
+    def swap_keys(hash)
+      hash.each_with_object({}) { |(k, v), h| h[v] = k }
     end
   end
 end
-

data/lib/numbers_in_words/duck_punch.rb

@@ -1,19 +1,23 @@
+# frozen_string_literal: true
+
 module NumbersInWords
-  def in_words language=NumbersInWords.language
-    NumbersInWords.in_words(self, language)
+  module NumericExtension
+    def in_words(fraction: false)
+      NumbersInWords::ToWord.new(self).in_words(fraction: fraction)
+    end
   end
-end
 
-module WordsInNumbers
-  def in_numbers(only_compress = false, language=NumbersInWords.language)
-    NumbersInWords::ToNumber.new(self, language).in_numbers(only_compress)
+  module StringExtension
+    def in_numbers(only_compress: false)
+      NumbersInWords::ToNumber.new(self, only_compress).call
+    end
   end
 end
 
 class String
-  include WordsInNumbers
+  include NumbersInWords::StringExtension
 end
 
 class Numeric
-  include NumbersInWords
+  include NumbersInWords::NumericExtension
 end

data/lib/numbers_in_words/exceptional_numbers.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+require_relative 'fraction'
+require_relative 'powers_of_ten'
+
+module NumbersInWords
+  class ExceptionalNumbers
+    extend Forwardable
+
+    DEFINITIONS = {
+      0 => { number: 'zero', ordinal: 'zeroth' },
+      1 => { number: 'one', ordinal: 'first' },
+      2 => { number: 'two', ordinal: 'second', fraction: { singular: 'half', plural: 'halves' } },
+      3 => { number: 'three', ordinal: 'third' },
+      4 => { number: 'four', ordinal: 'fourth', fraction: { singular: 'quarter', plural: 'quarters' } },
+      5 => { number: 'five', ordinal: 'fifth' },
+      6 => { number: 'six' },
+      7 => { number: 'seven' },
+      8 => { number: 'eight', ordinal: 'eighth' },
+      9 => { number: 'nine', ordinal: 'ninth' },
+      10 => { number: 'ten' },
+      11 => { number: 'eleven' },
+      12 => { number: 'twelve', ordinal: 'twelfth' },
+      13 => { number: 'thirteen' },
+      14 => { number: 'fourteen' },
+      15 => { number: 'fifteen' },
+      16 => { number: 'sixteen' },
+      17 => { number: 'seventeen' },
+      18 => { number: 'eighteen' },
+      19 => { number: 'nineteen' },
+      20 => { number: 'twenty', ordinal: 'twentieth' },
+      30 => { number: 'thirty', ordinal: 'thirtieth' },
+      40 => { number: 'forty', ordinal: 'fortieth' },
+      50 => { number: 'fifty', ordinal: 'fiftieth' },
+      60 => { number: 'sixty', ordinal: 'sixtieth' },
+      70 => { number: 'seventy', ordinal: 'seventieth' },
+      80 => { number: 'eighty', ordinal: 'eightieth' },
+      90 => { number: 'ninety', ordinal: 'ninetieth' }
+    }.freeze
+
+    def fraction_names
+      @fraction_names ||= determine_fraction_names
+    end
+
+    def lookup_fraction(words)
+      fraction_lookup[words]
+    end
+
+    def fraction_lookup
+      @fraction_lookup ||= generate_fraction_lookup
+    end
+
+    def lookup(number)
+      to_h[number]
+    end
+
+    def fractions
+      DEFINITIONS
+    end
+
+    def fraction(denominator: nil, numerator: nil, word: nil)
+      raise unless denominator || word
+
+      numerator ||= 1
+
+      denominator ||= NumbersInWords.in_numbers(word)
+
+      Fraction.new(denominator: denominator, numerator: numerator, attributes: DEFINITIONS[denominator])
+    end
+
+    def to_h
+      @to_h ||= DEFINITIONS.transform_values do |h|
+        h[:number]
+      end
+    end
+
+    private
+
+    def generate_fraction_lookup
+      named_fractions.each_with_object({}) do |f, result|
+        f.lookup_keys.each do |k|
+          key = k.split(' ').last
+          result[key] = 1.0 / f.denominator.to_f
+        end
+      end
+    end
+
+    def named_fractions
+      @named_fractions ||= numbers.flat_map do |n|
+        [
+          Fraction.new(denominator: n, numerator: 1),
+          Fraction.new(denominator: n, numerator: 2)
+        ]
+      end
+    end
+
+    def numbers
+      (2..100).to_a + powers_of_ten_skipping_googolplex.map { |p| 10**p }
+    end
+
+    def powers_of_ten_skipping_googolplex
+      POWERS_OF_TEN.keys[0..-2]
+    end
+
+    def determine_fraction_names
+      names = named_fractions.map(&:in_words)
+
+      words = names.map(&:split).map(&:last)
+      words += strip_punctuation(words)
+      words.uniq
+    end
+
+    def strip_punctuation(words)
+      words.map { |w| w.gsub(/^a-z/, ' ') }
+    end
+  end
+end

data/lib/numbers_in_words/fraction.rb

@@ -0,0 +1,151 @@
+# 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 to_r
+      return 0.0 if denominator == Float::INFINITY
+
+      (numerator / denominator.to_f).rationalize(EPSILON)
+    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
+      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))
+        # I suppose we could also call this an 'infinitieth'
+        return pluralize? ? 'googolplexths' : 'googolplexth'
+      end
+
+      NumbersInWords.in_words(numerator) + ' ' + fraction
+    end
+
+    def ordinal
+      pluralize? ? pluralized_ordinal_in_words : singular_ordinal_in_words
+    end
+
+    def fraction
+      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 plural
+      exception && (fraction_plural || singular + 's') || ordinal_plural
+    end
+
+    def singular
+      (exception && exception[:singular]) || ordinal
+    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