numbers_in_words 0.4.0 → 1.0.1

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

@@ -1,32 +1,51 @@
-require 'numbers_in_words'
+# frozen_string_literal: true
 
-describe "NumbersInWords" do
-  describe ".in_words" do
+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"
+      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
 
-    pending "This should be implemented" do
-      expect(NumbersInWords.in_words(100*10**100)).to eq "one hundred googols"
+  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
+  describe '.in_numbers' do
     it do
-      expect(NumbersInWords.in_numbers("one hundred")).to eq 100
+      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
+      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

@@ -1,17 +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 = Numeric::NumberGroup
-
-    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(87654               ,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 })
+  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

@@ -1,106 +1,99 @@
-require './spec/spec_helper'
-
-describe NumbersInWords do
-  describe ".language" do
-    after do
-      NumbersInWords.instance_variable_set(:"@language", nil)
-    end
-
-    it "has a default value" do
-      expect(NumbersInWords.language).to eq "English"
-    end
+# frozen_string_literal: true
 
-    it "can be set" do
-      NumbersInWords.language = "some language"
-      expect(NumbersInWords.language).to eq "some language"
-    end
-  end
+require './spec/spec_helper'
 
-  describe ".in_words" do
+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 'one hundred'
     end
   end
 
-  describe ".in_numbers" do
+  describe '.in_numbers' do
     it do
-      expect(NumbersInWords.in_numbers("one hundred")).to eq 100
+      expect(NumbersInWords.in_numbers('one-hundred')).to eq 100
     end
   end
 
-  it "should print the digits 0-9 correctly" do
+  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
+  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 = [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")
+  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")
+  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(99999    .in_words). to eq("ninety nine thousand nine hundred and ninety nine")
-    expect(999999   .in_words). to eq("nine hundred and ninety nine thousand nine hundred and ninety nine")
-    expect(123456   .in_words). to eq("one hundred and twenty three thousand four hundred and fifty six")
-    expect(17054    .in_words). to eq("seventeen thousand and fifty four")
-    expect(11004    .in_words). to eq("eleven thousand and four")
-    expect(470154   .in_words). to eq("four hundred and seventy thousand one hundred and fifty four")
-    expect(417155   .in_words). to eq("four hundred and seventeen thousand one hundred and fifty five")
-    expect(999999   .in_words). to eq("nine hundred and ninety nine thousand nine hundred and ninety nine")
-    expect(1000000  .in_words). to eq("one million")
-    expect(1000001  .in_words). to eq("one million and one")
-    expect(112      .in_words). to eq("one hundred and twelve")
+  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(1000001                 .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(10001001                .in_words). to eq("ten million one thousand and one")
+  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
-    n=10**100
-    expect((10**100 + 1)          .in_words). to eq("one googol and one")
-    expect((42*10**100 + 16777216).in_words). to eq("forty two googol sixteen million seven hundred and seventy seven thousand two hundred and sixteen")
-    expect((42* 10**100 * 10**100).in_words). to eq("forty two googol googol")
+  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(-123456789    .in_words).to eq("minus one hundred and twenty three million four hundred and fifty six thousand seven hundred and eighty nine")
+  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(12345.2345678.in_words).to match(/twelve thousand three hundred and forty five point two three four five six seven eight/)
+  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

@@ -1,19 +1,35 @@
+# frozen_string_literal: true
+
 require './spec/spec_helper'
 
 describe NumbersInWords do
-  it "should recognize numerical strings" do
-    arr = %w(8 56 100 5789 3435356)
-    arr.each{ |s| expect(s.in_numbers).to eql(s.to_f) }
+  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
 
-  it "should recognize mixed strings" do
-    mixed = {
-      "19 hundred" => 1_900.0,
-      "20 thousand" => 20_000.0,
-      "100 million" => 100_000_000.0,
-      "7 billion" => 7_000_000_000.0,
-      "42 trillion" => 42_000_000_000_000.0
-    }
-    mixed.each{ |k, v| expect(k.in_numbers).to eql(v) }
+  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

@@ -1,7 +1,26 @@
-require "codeclimate-test-reporter"
-CodeClimate::TestReporter.start
+# frozen_string_literal: true
 
-require 'numbers_in_words'
-require 'numbers_in_words/duck_punch'
+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

data/spec/words_in_numbers_spec.rb

@@ -1,145 +1,152 @@
+# frozen_string_literal: true
+
 require './spec/spec_helper'
 
-describe WordsInNumbers do
-  it "should do the digits 0-10" do
-    expect("zero"  .in_numbers).to eq(0)
-    expect("one"   .in_numbers).to eq(1)
-    expect("two"   .in_numbers).to eq(2)
-    expect("three" .in_numbers).to eq(3)
-    expect("four"  .in_numbers).to eq(4)
-    expect("five"  .in_numbers).to eq(5)
-    expect("six"   .in_numbers).to eq(6)
-    expect("seven" .in_numbers).to eq(7)
-    expect("eight" .in_numbers).to eq(8)
-    expect("nine"  .in_numbers).to eq(9)
+describe NumbersInWords::StringExtension do # rubocop: disable Metrics/BlockLength
+  it 'should do the digits 0-10' do
+    expect('zero'.in_numbers).to eq(0)
+    expect('one'.in_numbers).to eq(1)
+    expect('two'.in_numbers).to eq(2)
+    expect('three'.in_numbers).to eq(3)
+    expect('four'.in_numbers).to eq(4)
+    expect('five'.in_numbers).to eq(5)
+    expect('six'.in_numbers).to eq(6)
+    expect('seven'.in_numbers).to eq(7)
+    expect('eight'.in_numbers).to eq(8)
+    expect('nine'.in_numbers).to eq(9)
+  end
+
+  it 'should handle numbers for which there is one word' do
+    expect('ten'.in_numbers).to eq(10)
+    expect('eleven'.in_numbers).to eq(11)
+    expect('twelve'.in_numbers).to eq(12)
+    expect('thirteen'.in_numbers).to eq(13)
+    expect('fourteen'.in_numbers).to eq(14)
+    expect('fifteen'.in_numbers).to eq(15)
+    expect('sixteen'.in_numbers).to eq(16)
+    expect('seventeen'.in_numbers).to eq(17)
+    expect('eighteen'.in_numbers).to eq(18)
+    expect('nineteen'.in_numbers).to eq(19)
+    expect('twenty'.in_numbers).to eq(20)
   end
 
-  it "should handle numbers for which there is one word" do
-    expect("ten"       .in_numbers).to eq(10)
-    expect("eleven"    .in_numbers).to eq(11)
-    expect("twelve"    .in_numbers).to eq(12)
-    expect("thirteen"  .in_numbers).to eq(13)
-    expect("fourteen"  .in_numbers).to eq(14)
-    expect("fifteen"   .in_numbers).to eq(15)
-    expect("sixteen"   .in_numbers).to eq(16)
-    expect("seventeen" .in_numbers).to eq(17)
-    expect("eighteen"  .in_numbers).to eq(18)
-    expect("nineteen"  .in_numbers).to eq(19)
-    expect("twenty"    .in_numbers).to eq(20)
+  it 'should handle two word numbers up to 100' do
+    expect('twenty-one'.in_numbers).to eq(21)
+    expect('twenty-two'.in_numbers).to eq(22)
+    expect('twenty-three'.in_numbers).to eq(23)
+    expect('twenty-four'.in_numbers).to eq(24)
+    expect('twenty-five'.in_numbers).to eq(25)
+    expect('twenty-six'.in_numbers).to eq(26)
+    expect('twenty-seven'.in_numbers).to eq(27)
+    expect('twenty-eight'.in_numbers).to eq(28)
+    expect('seventy-six'.in_numbers).to eq(76)
+    expect('ninety-nine'.in_numbers).to eq(99)
   end
 
-  it "should handle two word numbers up to 100" do
-    expect("twenty one"   .in_numbers).to eq(21)
-    expect("twenty two"   .in_numbers).to eq(22)
-    expect("twenty three" .in_numbers).to eq(23)
-    expect("twenty four"  .in_numbers).to eq(24)
-    expect("twenty five"  .in_numbers).to eq(25)
-    expect("twenty six"   .in_numbers).to eq(26)
-    expect("twenty seven" .in_numbers).to eq(27)
-    expect("twenty eight" .in_numbers).to eq(28)
-    expect("seventy six"  .in_numbers).to eq(76)
-    expect("ninety nine"  .in_numbers).to eq(99)
+  it 'should handle hundreds' do
+    expect('one hundred'.in_numbers).to eq(100)
+    expect('two hundred'.in_numbers).to eq(200)
+    expect('three hundred'.in_numbers).to eq(300)
+    expect('nine hundred'.in_numbers).to eq(900)
+    expect('one hundred and seventy six'.in_numbers).to eq(176)
+    expect('one hundred and seventy nine'.in_numbers).to eq(179)
+    expect('nine hundred and ninety nine'.in_numbers).to eq(999)
   end
 
-  it "should handle hundreds" do
-    expect("one hundred"                  .in_numbers).to eq(100)
-    expect("two hundred"                  .in_numbers).to eq(200)
-    expect("three hundred"                .in_numbers).to eq(300)
-    expect("nine hundred"                 .in_numbers).to eq(900)
-    expect("one hundred and seventy six"  .in_numbers).to eq(176)
-    expect("one hundred and seventy nine" .in_numbers).to eq(179)
-    expect("nine hundred and ninety nine" .in_numbers).to eq(999)
+  it 'should handle unusual hundreds' do
+    expect('eleven hundred'.in_numbers).to eq(1100)
+    expect('twelve hundred'.in_numbers).to eq(1200)
+    expect('thirteen hundred'.in_numbers).to eq(1300)
+    expect('fifteen hundred'.in_numbers).to eq(1500)
+    expect('nineteen hundred'.in_numbers).to eq(1900)
+  end
+  it 'should handle thousands' do
+    expect('two thousand and one'.in_numbers).to eq(2001)
+    expect('one thousand'.in_numbers).to eq(1000)
+    expect('two thousand'.in_numbers).to eq(2000)
+    expect('three thousand'.in_numbers).to eq(3000)
+    expect('nine thousand'.in_numbers).to eq(9000)
+    expect('nine thousand two hundred'.in_numbers).to eq(9200)
+    expect('nine thousand two hundred and seven'.in_numbers).to eq(9207)
+    expect('nine thousand two hundred and ninety seven'.in_numbers).to eq(9297)
   end
 
-  it "should handle unusual hundreds" do
-    expect("eleven hundred"   .in_numbers).to eq(1100)
-    expect("twelve hundred"   .in_numbers).to eq(1200)
-    expect("thirteen hundred" .in_numbers).to eq(1300)
-    expect("fifteen hundred"  .in_numbers).to eq(1500)
-    expect("nineteen hundred" .in_numbers).to eq(1900)
+  it 'handles numbers that begin with a instead of one', :aggregate_failures do
+    expect('a thousand six hundred'.in_numbers).to eq(1600)
+    expect('a thousand six hundred and fifty-five'.in_numbers).to eq(1655)
+  end
+
+  it 'should handle larger numbers' do
+    expect('one million'.in_numbers).to eq(1_000_000)
+    expect('two googol five billion and seventy six'.in_numbers).to eq(2 * 10**100 + 5 * 10**9 + 76)
+    expect('thirty seven million'.in_numbers).to eq(37 * 10**6)
+    expect('twenty six googol'.in_numbers).to eq(26 * 10**100)
+  end
 
+  it 'should handle numbers in hundreds of thousands etc' do
+    expect('nine hundred thousand'.in_numbers).to eq(900_000)
+    expect('three hundred and fifty seven thousand'.in_numbers).to eq(357_000)
+    expect('five million three hundred and fifty seven thousand'.in_numbers).to eq(5_357_000)
+    expect('nine hundred and ninety nine trillion'.in_numbers).to eq(999 * 10**12)
   end
-  it "should handle thousands" do
-    expect("two thousand and one"                       .in_numbers) .to eq(2001)
-    expect("one thousand"                               .in_numbers) .to eq(1000)
-    expect("two thousand"                               .in_numbers) .to eq(2000)
-    expect("three thousand"                             .in_numbers) .to eq(3000)
-    expect("nine thousand"                              .in_numbers) .to eq(9000)
-    expect("nine thousand two hundred"                  .in_numbers) .to eq(9200)
-    expect("nine thousand two hundred and seven"        .in_numbers) .to eq(9207)
-    expect("nine thousand two hundred and ninety seven" .in_numbers) .to eq(9297)
-    end
-
-    it "should handle larger numbers" do
-    expect("one million"                                .in_numbers) .to eq(1000000)
-    expect("two googol five billion and seventy six"    .in_numbers) .to eq(2*10**100 + 5*10**9 + 76)
-    expect("thirty seven million"                       .in_numbers) .to eq(37 * 10**6)
-    expect("twenty six googol"                          .in_numbers) .to eq(26 * 10**100)
-    end
-
-  it "should handle numbers in hundreds of thousands etc" do
-    expect("nine hundred thousand"                                            .in_numbers) .to eq(900000)
-    expect("three hundred and fifty seven thousand"                           .in_numbers) .to eq(357000)
-    expect("five million three hundred and fifty seven thousand"              .in_numbers) .to eq(5357000)
-    expect("nine hundred and ninety nine trillion"                            .in_numbers) .to eq(999 * 10**12)
-    end
-    it "should handle negative numbers" do
-    expect("minus one"                                                        .in_numbers) .to eq(-1)
-    expect("minus two googol"                                                 .in_numbers) .to eq(-2 * 10**100)
-    expect("minus nine hundred and ninety nine trillion"                      .in_numbers) .to eq(-999 * 10**12)
-    end
-
-    it "should ignore punctuation and capitalisation" do
-    expect("Minus one"                                                        .in_numbers) .to eq(-1)
-    expect("FIVE Million, three hundred and fifty-seVen Thousand"             .in_numbers) .to eq(5357000)
-    expect("FIVE,,./';';';[] Million, three hundred and fifty-seVen Thousand" .in_numbers) .to eq(5357000)
-
-    end
-
-  it "should handle decimal points" do
-    expect("one point one"                        .in_numbers) .to eq(1.1)
-
-    expect("zero point seven six five three four" .in_numbers) .to eq(0.76534)
-    expect("one trillion point six"               .in_numbers) .to eq(10**12 + 0.6)
-
-    long_number = <<-NUMBER
-    nine duotrigintillion seven hundred and seventy seven untrigintillion
-    fifty nine trigintillion one hundred and sixty novemvigintillion
-    eight hundred and six octovigintillion seven hundred and thirty six
-    septenvigintillion four hundred and seventy one sexvigintillion
-    nine hundred and seventy quinvigintillion six hundred and thirty two
-    quattuorvigintillion eight hundred and twenty seven trevigintillion
-    eight hundred and thirty six duovigintillion nine hundred and fifty
-    two unvigintillion seven hundred and ten vigintillion eight hundred and one
-    novemdecillion nine hundred and forty eight octodecillion seven hundred
-    and five septendecillion six hundred and eighty three sexdecillion
-    one hundred and six quindecillion seven hundred and seven quattuordecillion
-    seven hundred and fifty seven tredecillion four hundred and twenty six
-    duodecillion seven hundred and ninety five undecillion seven hundred
-    and forty six decillion eight hundred and thirteen nonillion one hundred
-    and twenty seven octillion four hundred and sixty five septillion two
-    hundred and thirty seven sextillion one hundred and thirty nine
-    quintillion one hundred and fifty three quadrillion forty six
-    trillion seven hundred and fifty two billion eight hundred and three
-    million ninety three thousand seven hundred and ninety one point
-    eight nine five six four three two one eight nine five six seven eight
+  it 'should handle negative numbers' do
+    expect('minus one'.in_numbers).to eq(-1)
+    expect('minus two googol'.in_numbers).to eq(-2 * 10**100)
+    expect('minus nine hundred and ninety nine trillion'.in_numbers).to eq(-999 * 10**12)
+  end
+
+  it 'should ignore punctuation and capitalisation' do
+    expect('Minus one'.in_numbers).to eq(-1)
+    expect('FIVE Million, three hundred and fifty-seVen Thousand'.in_numbers).to eq(5_357_000)
+    expect("FIVE,,./';';';[] Million, three hundred and fifty-seVen Thousand".in_numbers).to eq(5_357_000)
+  end
+
+  it 'should handle decimal points' do # rubocop: disable Metrics/BlockLength
+    expect('one point one'.in_numbers).to eq(1.1)
+
+    expect('zero point seven six five three four'.in_numbers).to eq(0.76534)
+    expect('one trillion point six'.in_numbers).to eq(10**12 + 0.6)
+
+    long_number = <<~NUMBER
+      nine duotrigintillion seven hundred and seventy seven untrigintillion
+      fifty nine trigintillion one hundred and sixty novemvigintillion
+      eight hundred and six octovigintillion seven hundred and thirty six
+      septenvigintillion four hundred and seventy one sexvigintillion
+      nine hundred and seventy quinvigintillion six hundred and thirty two
+      quattuorvigintillion eight hundred and twenty seven trevigintillion
+      eight hundred and thirty six duovigintillion nine hundred and fifty
+      two unvigintillion seven hundred and ten vigintillion eight hundred and one
+      novemdecillion nine hundred and forty eight octodecillion seven hundred
+      and five septendecillion six hundred and eighty three sexdecillion
+      one hundred and six quindecillion seven hundred and seven quattuordecillion
+      seven hundred and fifty seven tredecillion four hundred and twenty six
+      duodecillion seven hundred and ninety five undecillion seven hundred
+      and forty six decillion eight hundred and thirteen nonillion one hundred
+      and twenty seven octillion four hundred and sixty five septillion two
+      hundred and thirty seven sextillion one hundred and thirty nine
+      quintillion one hundred and fifty three quadrillion forty six
+      trillion seven hundred and fifty two billion eight hundred and three
+      million ninety three thousand seven hundred and ninety one point
+      eight nine five six four three two one eight nine five six seven eight
     NUMBER
+
+    # rubocop: disable Metrics/LineLength
     expect(long_number.in_numbers).to eq(
-      9777059160806736471970632827836952710801948705683106707757426795746813127465237139153046752803093791.89564321895678
+      9_777_059_160_806_736_471_970_632_827_836_952_710_801_948_705_683_106_707_757_426_795_746_813_127_465_237_139_153_046_752_803_093_791.89564321895678
     )
+    # rubocop: enable Metrics/LineLength
 
-    expect("seventy five point eight four three two seven six nine four five one eight".
-      in_numbers).to eq(75.84327694518)
+    expect('seventy five point eight four three two seven six nine four five one eight'
+           .in_numbers).to eq(75.84327694518)
   end
 
-  it "should handle years notation" do
-    expect("fifteen sixteen".in_numbers) .to eq(1516)
-    expect("eighty five sixteen".in_numbers) .to eq(8516)
-    expect("nineteen ninety six".in_numbers) .to eq(1996)
-    expect("forty nine ninety eight forty seven seventy nine".in_numbers) .to eq(49984779)
-    expect("fifteen sixteen".in_numbers) .to eq(1516)
-    expect("fifteen sixteen seven".in_numbers) .to eq(15167)
-    expect("fifteen sixteen seventeen".in_numbers) .to eq(151617)
+  it 'should handle years notation' do
+    expect('fifteen sixteen'.in_numbers).to eq(1516)
+    expect('eighty five sixteen'.in_numbers).to eq(8516)
+    expect('nineteen ninety six'.in_numbers).to eq(1996)
+    expect('forty nine ninety eight forty seven seventy nine'.in_numbers).to eq(49_984_779)
+    expect('fifteen sixteen'.in_numbers).to eq(1516)
+    expect('fifteen sixteen seven'.in_numbers).to eq(15_167)
+    expect('fifteen sixteen seventeen'.in_numbers).to eq(151_617)
   end
-
 end