castwide_numbers_in_words 1.0.2

data/lib/numbers_in_words.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'numbers_in_words/version'
+require 'numbers_in_words/exceptional_numbers'
+require 'numbers_in_words/parsing/number_parser'
+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
+  Error                 = ::Class.new(::StandardError)
+  AmbiguousParsingError = ::Class.new(Error)
+  DivideByZeroError     = ::Class.new(Error)
+  InvalidNumber         = ::Class.new(Error)
+
+  class << self
+    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 lookup(number)
+      exceptional_numbers.lookup(number)
+    end
+
+    def exceptional_number(text)
+      exceptional_numbers_to_i[text]
+    end
+
+    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/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) { Float::INFINITY }
+
+    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

data/spec/fractions_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+describe NumbersInWords do
+  FRACTION_EXAMPLES = {
+    'half' => 0.5,
+    'a half' => 0.5,
+    'one half' => 0.5,
+    'two halves' => 1.0,
+    'three halves' => 1.5,
+    'three quarters' => 0.75,
+    'three fifths' => 3 / 5.0,
+    'seven fifteenths' => 7 / 15.0
+  }.freeze
+
+  PENDING = {
+    'twenty and three fifteenths' => 20 + 3 / 15.0,
+    'three ninety-sevenths' => 3 / 97.0
+  }.freeze
+
+  FRACTION_EXAMPLES.each do |string, float|
+    it "#{string} == #{float}" do
+      expect(string.in_numbers).to eql(float)
+    end
+  end
+
+  PENDING.each do |string, float|
+    pending "#{string} == #{float}" do
+      expect(string.in_numbers).to eql(float)
+    end
+  end
+end

data/spec/non_monkey_patch_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'NumbersInWords' do # rubocop: disable Metrics/BlockLength
+  describe '.in_words' do
+    it do
+      expect(NumbersInWords.in_words(100)).to eq 'one hundred'
+      expect(NumbersInWords.in_words(-100)).to eq 'minus one hundred'
+      expect(NumbersInWords.in_words(24)).to eq 'twenty-four'
+      expect(NumbersInWords.in_words(1.2)).to eq 'one point two'
+      expect(NumbersInWords.in_words(100 * 10**100)).to eq 'one hundred googol'
+      expect(NumbersInWords.in_words(30 + 100 * 10**100)).to eq 'one hundred googol and thirty'
+    end
+  end
+
+  FRACTION_TO_WORDS = {
+    [1, 2] => 'one half',
+    [3, 2] => 'three halves',
+    [1, 3] => 'one third',
+    [1, 4] => 'one quarter',
+    [1, 5] => 'one fifth',
+    [1, 19] => 'one nineteenth',
+    [2, 17] => 'two seventeenths',
+    [1, 21] => 'one twenty-first',
+    [1, 32] => 'one thirty-second',
+    [1, 101] => 'one one hundred and first',
+    [3, 101] => 'three hundred and firsts',
+    [73, 102] => 'seventy-three hundred and seconds',
+    [13, 97] => 'thirteen ninety-sevenths'
+  }.freeze
+
+  FRACTION_TO_WORDS.each do |(numerator, denominator), string|
+    it "#{numerator}/#{denominator} == #{string}" do
+      expect(NumbersInWords.in_words(numerator.to_f / denominator, fraction: true)).to eql(string)
+    end
+  end
+
+  describe '.in_numbers' do
+    it do
+      expect(NumbersInWords.in_numbers('hundred')).to eq 100
+      expect(NumbersInWords.in_numbers('one hundred')).to eq 100
+
+      expect(NumbersInWords.in_numbers('minus one hundred')).to eq(-100)
+      expect(NumbersInWords.in_numbers('twenty four')).to eq 24
+      expect(NumbersInWords.in_numbers('one point two')).to eq 1.2
+      expect(NumbersInWords.in_numbers('one hundred googol')).to eq 100 * 10**100
+      expect(NumbersInWords.in_numbers('one hundred googol and thirty')).to eq 30 + 100 * 10**100
+    end
+  end
+end

data/spec/number_group_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require './spec/spec_helper'
+require 'numbers_in_words/number_group'
+
+describe NumbersInWords::NumberGroup do
+  it 'should split into group of three digit numbers' do
+    g = described_class
+    expect(g.groups_of(1, 3)).to eq({ 0 => 1 })
+    expect(g.groups_of(12, 3)).to eq({ 0 => 12 })
+    expect(g.groups_of(123, 3)).to eq({ 0 => 123 })
+    expect(g.groups_of(1111, 3)).to eq({ 3 => 1, 0 => 111 })
+    expect(g.groups_of(87_654, 3)).to eq({ 3 => 87, 0 => 654 })
+    expect(g.groups_of(1_234_567, 3)).to eq({ 6 => 1, 3 => 234, 0 => 567                    })
+    expect(g.groups_of(123_456_789_101_112, 3)).to eq({ 12 => 123, 9 => 456, 6 => 789, 3 => 101, 0 => 112 })
+  end
+end

data/spec/number_parser_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require './spec/spec_helper'
+require 'numbers_in_words/parsing/number_parser'
+
+describe NumbersInWords::NumberParser do
+  subject do
+    super().parse(number)
+  end
+
+  context 'with single digit' do
+    let(:number) { [9] }
+    it { expect(subject).to eq 9 }
+  end
+
+  context 'with thousands' do
+    let(:number) { [20, 1000] }
+    it { expect(subject).to eq 20_000 }
+  end
+
+  context 'with thousands with a leading one' do
+    let(:number) { [1, 1000, 6, 100] }
+    it { expect(subject).to eq 1600 }
+  end
+
+  context 'with hundreds' do
+    let(:number) { [2, 100, 45] }
+
+    it { expect(subject).to eq 245 }
+  end
+end

data/spec/numbers_in_words_spec.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require './spec/spec_helper'
+
+describe NumbersInWords do # rubocop: disable Metrics/BlockLength
+  describe '.in_words' do
+    it do
+      expect(NumbersInWords.in_words(100)).to eq 'one hundred'
+    end
+  end
+
+  describe '.in_numbers' do
+    it do
+      expect(NumbersInWords.in_numbers('one-hundred')).to eq 100
+    end
+  end
+
+  it 'should print the digits 0-9 correctly' do
+    numbers = %w[zero one two three four five six seven eight nine]
+
+    10.times { |i| expect(i.in_words).to eq(numbers[i]) }
+  end
+
+  it 'should print the digits 11-19 correctly' do
+    words = %w[eleven twelve thirteen fourteen fifteen sixteen seventeen eighteen nineteen]
+    numbers = [11, 12, 13, 14, 15, 16, 17, 18, 19]
+    numbers.each_with_index do |number, index|
+      expect(number.in_words).to eq(words[index])
+    end
+  end
+
+  it 'should handle two digit numbers' do
+    expect(21.in_words).to eq('twenty-one')
+  end
+
+  it 'should handle three digit numbers' do
+    expect(113.in_words).to eq('one hundred and thirteen')
+    expect(299.in_words).to eq('two hundred and ninety-nine')
+    expect(300.in_words).to eq('three hundred')
+    expect(101.in_words).to eq('one hundred and one')
+  end
+
+  it 'should print out some random examples correctly' do
+    expect(2999.in_words).to eq('two thousand nine hundred and ninety-nine')
+    expect(99_999.in_words).to eq('ninety-nine thousand nine hundred and ninety-nine')
+    expect(999_999.in_words).to eq('nine hundred and ninety-nine thousand nine hundred and ninety-nine')
+    expect(123_456.in_words).to eq('one hundred and twenty-three thousand four hundred and fifty-six')
+    expect(24_056.in_words).to eq('twenty-four thousand and fifty-six')
+    expect(17_054.in_words).to eq('seventeen thousand and fifty-four')
+    expect(11_004.in_words).to eq('eleven thousand and four')
+    expect(470_154.in_words).to eq('four hundred and seventy thousand one hundred and fifty-four')
+    expect(417_155.in_words).to eq('four hundred and seventeen thousand one hundred and fifty-five')
+    expect(999_999.in_words).to eq('nine hundred and ninety-nine thousand nine hundred and ninety-nine')
+    expect(1_000_000.in_words).to eq('one million')
+    expect(1_000_001.in_words).to eq('one million and one')
+    expect(112.in_words).to eq('one hundred and twelve')
+  end
+
+  it 'should handle edge cases' do
+    expect(1_000_001.in_words).to eq('one million and one')
+    expect((10 * 10**12 + 10**6 + 1).in_words).to eq('ten trillion one million and one')
+    expect((10**75).in_words).to eq('one quattuorvigintillion')
+    expect(10_001_001.in_words).to eq('ten million one thousand and one')
+  end
+
+  it 'should handle a googol and larger' do
+    googol = 10**100
+    expect((googol + 1).in_words).to eq('one googol and one')
+    expect((42 * googol + 16_777_216).in_words)
+      .to eq('forty-two googol sixteen million seven hundred and seventy-seven thousand two hundred and sixteen')
+    expect((42 * googol * googol).in_words).to eq('forty-two googol googol')
+  end
+
+  it 'should handle negative numbers' do
+    expect(-1.in_words).to eq('minus one')
+    expect(-9.in_words).to eq('minus nine')
+    expect(-10.in_words).to eq('minus ten')
+    expect(-15.in_words).to eq('minus fifteen')
+    expect(-100.in_words).to eq('minus one hundred')
+    expect((-1 * (10**100)).in_words).to eq('minus one googol')
+
+    expect(-123_456_789.in_words)
+      .to eq('minus one hundred and twenty-three million four hundred and ' \
+             'fifty-six thousand seven hundred and eighty-nine')
+  end
+
+  it 'should handle decimals' do
+    # because of lack of absolute accuracy with floats
+    # the output won't be exactly as you might expect
+    # so we will match rather than find equivalents
+    expect(1.1.in_words).to match(/one point one/)
+    expect(1.2345678.in_words).to match(/one point two three four five six seven eight/)
+    expect(1000.2345678.in_words).to match(/one thousand point two three four five six seven eight/)
+    expect(12_345.2345678.in_words)
+      .to match(/twelve thousand three hundred and forty-five point two three four five six seven eight/)
+
+    expect((10**9 + 0.1).in_words).to match(/one billion point one/)
+  end
+end

data/spec/numerical_strings_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require './spec/spec_helper'
+
+describe NumbersInWords do
+  it 'recognizes numerical strings' do
+    arr = %w[8 56 100 5789 3435356]
+    arr.each { |s| expect(s.in_numbers).to eql(s.to_f) }
+  end
+
+  MIXED = {
+    '19 hundred' => 1_900,
+    '20 thousand' => 20_000,
+    '100 million' => 100_000_000,
+    '7 billion' => 7_000_000_000,
+    '42 trillion' => 42_000_000_000_000,
+    '20 thousand and 4' => 20_004
+  }.freeze
+
+  MIXED.each do |k, v|
+    it do
+      expect(k.in_numbers).to eql(v)
+    end
+  end
+
+  PENDING_MIXED = {
+    '19 zero five' => 1_905
+  }.freeze
+
+  PENDING_MIXED.each do |k, v|
+    pending do
+      expect(k.in_numbers).to eql(v)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+if ENV['CC_TEST_REPORTER_ID']
+  require 'simplecov'
+  SimpleCov.start
+end
+
+unless Kernel.method_defined?(:silence_warnings)
+  module Kernel
+    def silence_warnings
+      with_warnings(nil) { yield }
+    end
+
+    def with_warnings(flag)
+      old_verbose = $VERBOSE
+      $VERBOSE = flag
+      yield
+    ensure
+      $VERBOSE = old_verbose
+    end
+  end
+end
+
+require 'numbers_in_words'
+require 'numbers_in_words/duck_punch'
+require 'byebug'

data/spec/to_word_spec.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+RSpec.describe NumbersInWords::ToWord do
+  let(:number) { 2_111 }
+  let(:writer) { described_class.new(number) }
+
+  describe '#in_words' do
+    let(:number) { 99 }
+
+    subject do
+      writer.in_words
+    end
+
+    it do
+      expect(subject).to eq 'ninety-nine'
+    end
+  end
+end