numbers_in_words 0.1.1 → 0.5.0

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

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

@@ -1,113 +1,99 @@
-require './lib/numbers_in_words'
+# frozen_string_literal: true
 
-describe NumbersInWords::NumberGroup do
+require './spec/spec_helper'
 
-  it "should split into group of three digit numbers" do
-    Numeric::NumberGroup.groups_of(1,3).should == {0=>1}
-    Numeric::NumberGroup.groups_of(12,3).should == {0=>12}
-    Numeric::NumberGroup.groups_of(123,3).should == {0=>123}
-    Numeric::NumberGroup.groups_of(1111,3).should == {3=>1,0=>111}
-    Numeric::NumberGroup.groups_of(87654,3).should == {3=>87,0=>654}
-    Numeric::NumberGroup.groups_of(1234567,3).should == {6=>1,3=>234,0=>567}
-    Numeric::NumberGroup.groups_of(123456789101112,3).should == {12=>123,9=>456,6=>789,3=>101,0=>112}
+describe NumbersInWords do # rubocop: disable Metrics/BlockLength
+  describe '.in_words' do
+    it do
+      expect(NumbersInWords.in_words(100)).to eq 'one hundred'
+    end
   end
-end
 
-describe NumbersInWords::LanguageWriterEnglish do
-  it "should display numbers grouped" do
-    count = 0
-    @writer = NumbersInWords::LanguageWriterEnglish.new(2111)
-    @writer.group_words(3) do |power, name, digits|
-      case count
-      when 0
-        power.should == 3
-        name.should == "thousand"
-        digits.should == 2
-      when 1
-        power.should == 0
-        name.should == "one"
-        digits.should == 111
-      end
-      count += 1
+  describe '.in_numbers' do
+    it do
+      expect(NumbersInWords.in_numbers('one-hundred')).to eq 100
     end
   end
-end
-
 
-describe NumbersInWords do
-  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| i.in_words.should==numbers[i] }
+    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|
-      number.in_words.should==words[index]
-
+      expect(number.in_words).to eq(words[index])
     end
   end
 
-  it "should handle two digit numbers" do
-    21.in_words. should == "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
-    113.in_words. should == "one hundred and thirteen"
-    299.in_words. should == "two hundred and ninety nine"
-    300.in_words. should == "three hundred"
-    101.in_words. should == "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
-    2999     .in_words. should == "two thousand nine hundred and ninety nine"
-    99999    .in_words. should == "ninety nine thousand nine hundred and ninety nine"
-    999999   .in_words. should == "nine hundred and ninety nine thousand nine hundred and ninety nine"
-    123456   .in_words. should == "one hundred and twenty three thousand four hundred and fifty six"
-    17054    .in_words. should == "seventeen thousand and fifty four"
-    11004    .in_words. should == "eleven thousand and four"
-    470154   .in_words. should == "four hundred and seventy thousand one hundred and fifty four"
-    417155   .in_words. should == "four hundred and seventeen thousand one hundred and fifty five"
-    999999   .in_words. should == "nine hundred and ninety nine thousand nine hundred and ninety nine"
-    1000000  .in_words. should == "one million"
-    1000001  .in_words. should == "one million and one"
-    112      .in_words. should == "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
-    1000001                 .in_words. should == "one million and one"
-    (10*10**12 + 10**6 +1)  .in_words. should == "ten trillion one million and one"
-    (10**75)                .in_words. should == "one quattuorvigintillion"
-    10001001                .in_words. should == "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
-    (10**100 + 1)          .in_words. should == "one googol and one"
-    (42*10**100 + 16777216).in_words. should == "forty two googol sixteen million seven hundred and seventy seven thousand two hundred and sixteen"
-    (42* 10**100 * 10**100).in_words. should == "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
-    -1            .in_words.should == "minus one"
-    -9            .in_words.should == "minus nine"
-    -10           .in_words.should == "minus ten"
-    -15           .in_words.should == "minus fifteen"
-    -100          .in_words.should == "minus one hundred"
-    (-1*(10**100)).in_words.should == "minus one googol"
-    -123456789    .in_words.should == "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
-    1.1          .in_words.should =~ /one point one/
-    1.2345678    .in_words.should =~ /one point two three four five six seven eight/
-    1000.2345678 .in_words.should =~ /one thousand point two three four five six seven eight/
-    12345.2345678.in_words.should =~ /twelve thousand three hundred and forty five point two three four five six seven eight/
-    (10**9 + 0.1).in_words.should =~ /one billion point one/
+  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