numbers_in_words 0.2.0 → 0.3.0

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+ - "1.9.3"
+ - "2.1.7"
+ - "2.2.3"
+ - rbx
+script: ./bin/spec

data/Gemfile

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

data/README.md

@@ -1,7 +1,14 @@
+[![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)
+[![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-6/6-ff6799.svg)](https://github.com/badges/badgerbadgerbadger)
+
 Installation
 ============
 
-```
+```ruby
 gem 'numbers_in_words'
 
 require 'numbers_in_words'
@@ -11,32 +18,24 @@ require 'numbers_in_words/duck_punch' #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.
 
-I'm going to hopefully preempt some support queries by predicting this will happen:
-
-You've got one of:
+Usage
+=========
 
-```
-NoMethodError: undefined method `in_words' for 123:Fixnum
-NoMethodError: undefined method `in_numbers' for "123":String
-```
+```ruby
+require 'numbers_in_words'
 
-Here's why
-==========
+NumbersInWords.in_words(112)
+#=> one hundred and twelve
 
-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:
+NumbersInWords.in_numbers(112)
+#=>10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
 
-```
-require 'numbers_in_words'
-require 'numbers_in_words/duck_punch'
+NumbersInWords.in_numbers("Seventy million, five-hundred and fifty six thousand point eight nine three")
+#=> 70556000.893
 ```
 
-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.
 
-Usage
-=========
+Monkey patch version
 
 ```ruby
 require 'numbers_in_words'
@@ -51,42 +50,30 @@ require 'numbers_in_words/duck_punch'
 #=> 70556000.893
 ```
 
----------------
-
-Whilst creating this project I realized that in English:
-
-* Numbers are grouped in groups of threes
-* Numbers less than 1,000 are grouped by hundreds and then by tens
-* There are specific rules for when we put an "and" in between numbers
 
-It makes sense to manage the numbers by these groups, so
-I created a method groups_of which will split any integer into
-groups of a certain size. It returns a hash with the power of ten
-as the key and the multiplier as the value. E.g:
+NoMethodError `in_words` or `in_numbers`
+----------
+I'm going to hopefully preempt some support queries by predicting this will happen:
 
-```ruby
-31245.groups_of(3)
-#=> {0=>245,3=>31} #i.e. 31 thousands, and 245 ones
+You've got one of:
 
-245.group_of(2)
-#=> {0=>45,2=>2}    #i.e. 2 hundreds, and 45 ones
+```
+NoMethodError: undefined method `in_words' for 123:Fixnum
+NoMethodError: undefined method `in_numbers' for "123":String
 ```
 
-(In Japanese numbers are grouped in groups of 4, so it makes sense to try and
-separate the language related stuff from the number grouping related stuff)
-
-Example of usage:
+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
-245.group_words(2,"English") do |power, name, digits|
-  puts "#{digits}*10^#{power} #{digits} #{name}s"
-end
-
+require 'numbers_in_words'
+require 'numbers_in_words/duck_punch'
+```
 
-2  * 10^2 =  2 hundreds
-45 * 10^0 = 45 ones
+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
 ============

data/bin/spec

@@ -0,0 +1,2 @@
+bundle exec rspec spec/non_monkey_patch_spec.rb
+bundle exec rspec spec

data/lib/numbers_in_words.rb

@@ -16,9 +16,18 @@ module NumbersInWords
 
   class << self
     attr_writer :language
+
     def language
       @language ||= "English"
     end
+
+    def in_words(i, language=NumbersInWords.language)
+      NumbersInWords::ToWord.new(i, language).in_words
+    end
+
+    def in_numbers(s, language=NumbersInWords.language)
+      NumbersInWords::ToNumber.new(s, language).in_numbers
+    end
   end
 end
 

data/lib/numbers_in_words/duck_punch.rb

@@ -1,12 +1,12 @@
 module NumbersInWords
   def in_words language=NumbersInWords.language
-    NumbersInWords::ToWord.new(self, language).in_words
+    NumbersInWords.in_words(self, language)
   end
 end
 
 module WordsInNumbers
   def in_numbers language=NumbersInWords.language
-    NumbersInWords::ToNumber.new(self, language).in_numbers
+    NumbersInWords.in_numbers(self, language)
   end
 end
 

data/lib/numbers_in_words/english/language_writer_english.rb

@@ -9,7 +9,7 @@ module NumbersInWords
       end
 
       def negative
-        "minus " + (-@that).in_words
+        "minus " + NumbersInWords.in_words(-@that)
       end
 
       def in_words
@@ -33,13 +33,12 @@ module NumbersInWords
 
           digit = number - tens       #write the digits
 
-          output << " " + digit.in_words unless digit==0
+          output << " " + NumbersInWords.in_words(digit) unless digit==0
         else
           output << write() #longer numbers
         end
 
         output.strip
-
       end
 
       def handle_exception
@@ -67,24 +66,27 @@ module NumbersInWords
       def decimals
         int, decimals = NumberGroup.new(@that).split_decimals
         if int
-          out = int.in_words + " point "
+          out = NumbersInWords.in_words(int) + " point "
           decimals.each do |decimal|
-            out << decimal.to_i.in_words + " "
+            out << NumbersInWords.in_words(decimal.to_i) + " "
           end
           out.strip
         end
       end
 
       private
+
       def write_googols
         googols, remainder = NumberGroup.new(@that).split_googols
         output = ""
-        output << " " + googols.in_words + " googol"
+
+        output << " " + NumbersInWords.in_words(googols) + " googol"
         if remainder > 0
           prefix = " "
           prefix << "and " if remainder < 100
-          output << prefix + remainder.in_words
+          output << prefix + NumbersInWords.in_words(remainder)
         end
+
         output
       end
 
@@ -96,7 +98,7 @@ module NumbersInWords
             prefix = " "
             #no and between thousands and hundreds
             prefix << "and " if power == 0  and digits < 100
-            output << prefix + digits.in_words
+            output << prefix + NumbersInWords.in_words(digits)
             output << prefix + name unless power == 0
           end
         end

data/lib/numbers_in_words/number_parser.rb

@@ -43,7 +43,7 @@ module NumbersInWords::NumberParser
     memory = 0
     answer = 0
     reset = true #reset each time memory is reset
-    integers.each_with_index do |integer, index|
+    integers.each do |integer|
       if reset
         reset = false
         memory += integer

data/lib/numbers_in_words/version.rb

@@ -1,3 +1,3 @@
 module NumbersInWords
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/numbers_in_words.gemspec

@@ -14,8 +14,7 @@ Gem::Specification.new do |gem|
   gem.homepage      = "http://github.com/markburns/numbers_in_words"
 
   gem.add_dependency      "activesupport"
-  gem.add_development_dependency      "rspec"
-  gem.add_development_dependency      "debugger"
+  gem.add_development_dependency      "rspec", "~> 3.4.0"
 
   gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }

data/spec/language_writer_spec.rb

@@ -7,13 +7,13 @@ describe NumbersInWords::English::LanguageWriterEnglish do
     @writer.group_words(3) do |power, name, digits|
       case count
       when 0
-        power.should == 3
-        name.should == "thousand"
-        digits.should == 2
+        expect(power).to eq(3)
+        expect(name).to eq("thousand")
+        expect(digits).to eq(2)
       when 1
-        power.should == 0
-        name.should == "one"
-        digits.should == 111
+        expect(power).to eq(0)
+        expect(name).to eq("one")
+        expect(digits).to eq(111)
       end
       count += 1
     end

data/spec/non_monkey_patch_spec.rb

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

data/spec/number_group_spec.rb

@@ -4,13 +4,13 @@ describe NumbersInWords::NumberGroup do
   it "should split into group of three digit numbers" do
     g = Numeric::NumberGroup
 
-    g.groups_of(1                   ,3 ).should == {0=>1                                          }
-    g.groups_of(12                  ,3 ).should == {0=>12                                         }
-    g.groups_of(123                 ,3 ).should == {0=>123                                        }
-    g.groups_of(1111                ,3 ).should == {3=>1    , 0=>111                              }
-    g.groups_of(87654               ,3 ).should == {3=>87   , 0=>654                              }
-    g.groups_of(1_234_567           ,3 ).should == {6=>1    , 3=>234  , 0=>567                    }
-    g.groups_of(123_456_789_101_112 ,3 ).should == {12=>123 , 9=>456  , 6=>789  , 3=>101 , 0=>112 }
+    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 })
   end
 end
 

data/spec/numbers_in_words_spec.rb

@@ -1,79 +1,106 @@
 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
+
+    it "can be set" do
+      NumbersInWords.language = "some language"
+      expect(NumbersInWords.language).to eq "some language"
+    end
+  end
+
+  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| 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
     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|
-      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"
+    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"
+    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"
+    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")
   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"
+    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")
   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"
+    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")
   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"
+    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")
   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/
+    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/)
+    expect((10**9 + 0.1).in_words).to match(/one billion point one/)
   end
 end