english_number 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dbfb04a49783d692acf4b2678cf40a8676789818
-  data.tar.gz: e3daab7f43df9fccb48ee8208236e11671b5f510
+  metadata.gz: ad1e9753922557166b6fd050738d7dec6a4d0b70
+  data.tar.gz: fa8ce30e3cc5af982efa6d566dac4f6b360a3b4d
 SHA512:
-  metadata.gz: a5fc9196246f1f04dbfd7d1f585518c8d176a3444c44cbe72c4d219e1f958d1b88dbc62af5a3688772e252c00ad4746eb7d1d97382de4bc516ac033b1dba5c83
-  data.tar.gz: f7223aa2771a89bb48e17c3a652f3b11911c7e586728dc50d5f64fa22d50704bce68960e5f34c6b21a0d2ad3869fad6d6262667327c231e9efc06b0a5d3431ca
+  metadata.gz: 96b2a71799d08d7702f97d7b1d31cb997f96a5a72a033d810928752f209a7c27dc811ac2458fff1f075697e3eeda2f8cd4ff6fe10185f58ea8ed17b6fb753d23
+  data.tar.gz: f7c05cf0299f4abf37a01e14d77cbaa37906d903e74f66071c7fbe244c950fef85be8fbb017d191517a7d7604e707c05373900cb39218c68b173bdc40b0f2c88

data/CHANGELOG.md

@@ -0,0 +1,14 @@
+## 0.0.3 (May 15, 2016)
+
+  * Added feature - gem works for three-digits long numbers (limit still set on 2 digits though, it can be changed in module ::Translate)
+  * Added specs to cover all classes' and modules' public methods
+  * Refactored whole code
+ 
+## 0.0.2 (May 13, 2016)
+
+  * Created working gem, limited to two-digit long numbers
+  * Added specs and simplecov (100% coverage)
+
+
+
+  

data/README.md

@@ -0,0 +1,74 @@
+== english_number
+
+<!--TODO:-->
+<!--{<img src="https://badge.fury.io/rb/numbers_and_words.svg?branch=master" alt="Gem Version" />}[http://badge.fury.io/rb/numbers_and_words]-->
+<!--{<img src="https://gemnasium.com/kslazarev/numbers_and_words.svg?branch=master" alt="Dependency Status" />}[https://gemnasium.com/kslazarev/numbers_and_words]-->
+<!--{<img src="https://codeclimate.com/github/kslazarev/numbers_and_words.svg?branch=master" />}[https://codeclimate.com/github/kslazarev/numbers_and_words]-->
+<!--{<img src="https://secure.travis-ci.org/kslazarev/numbers_and_words.svg?branch=master" />}[http://travis-ci.org/kslazarev/numbers_and_words]-->
+<!--{<img src="https://coveralls.io/repos/kslazarev/numbers_and_words/badge.svg?branch=master" alt="Coverage Status" />}[https://coveralls.io/r/kslazarev/numbers_and_words]-->
+
+Convert numbers to words in English. Limit of digits handled can be set. For now works for up to 3 digits. Additionally EnglishNumber objects can be added, subtracted, multiplied and divided.
+
+
+== Supported Languages
+
+* English [en]
+
+
+== Examples
+
+    EnglishNumber.new(5).in_english
+    => "five"
+
+    EnglishNumber.new(65).in_english
+    => "sixty-five"
+
+    EnglishNumber.new(100).in_english
+    => nil
+    
+    EnglishNumber.new(-100).in_english
+    => nil
+
+    EnglishNumber.new(78.4444).in_english
+    => "seventy-eight"
+
+    EnglishNumber.new(-80).in_english
+    => "minus-eighty"
+    
+    (EnglishNumber.new(80) + EnglishNumber.new(13)).in_english
+    => "ninety-three"
+    
+    (EnglishNumber.new(74) - EnglishNumber.new(35)).in_english
+    => "thirty-nine"
+    
+    (EnglishNumber.new(-80) * EnglishNumber.new(0.5)).in_english
+    => "forty"
+    
+    (EnglishNumber.new(50) / EnglishNumber.new(-2)).in_english
+    => "minus-twenty-five"
+    
+
+== Requirements 
+
+* 2.3.0 <= Ruby
+
+
+== Installation
+
+    gem install english_number
+
+== License
+
+MIT License
+
+== Changes
+
+See CHANGELOG.md for last changes.
+
+Fork the project. Make your feature addition or bug fix with tests.
+
+Send a pull request. 
+
+== Contacts
+
+* Piotr Brych (mailto:pbrych@gmail.com)

data/english_number.gemspec

@@ -1,11 +1,11 @@
 Gem::Specification.new do |s|
   s.name        = 'english_number'
-  s.version     = '0.0.2'
-  s.date        = '2016-05-13'
+  s.version     = '0.0.3'
+  s.date        = '2016-05-15'
   s.summary     = "Converting English numbers to strings"
   s.description = "Example: EnglishNumber.new(63).in_english # => 'sixty-three'.\n 
                    EnglishNumber objects can be added, subtracted, multiplied, divided.\n
-                   For now gem is deliberately limited to numbers maximum two digits long."
+                   For now gem is deliberately limited to numbers maximum three digits long.\n"
   
   s.authors     = ["Piotr Brych"]
   s.email       = 'pbrych@gmail.com'

data/lib/digits/three_digits.rb

@@ -0,0 +1,44 @@
+require 'modules/compute'
+require 'modules/translate'
+
+class ThreeDigits
+  include Compute
+  include Translate
+
+  def self.run(num)
+    new(num).in_words
+  end
+  
+  def in_words
+    num_mod(100).zero? ? simple_hundreds : complex_hundreds
+  end
+  
+  private
+  
+  attr_reader :num
+  
+  def initialize(num)
+    @num = num
+  end
+  
+  def first_digit
+    single_digits(in_array[0].to_i)
+  end
+  
+  def rest_digits
+    in_array[1..-1].join.to_i
+  end
+  
+  def rest
+    rest_digits < 10 ? single_digits(rest_digits) : TwoDigits.run(rest_digits)
+  end
+  
+  def simple_hundreds
+    [first_digit, prefix(power_of_ten)].join('-')
+  end
+  
+  def complex_hundreds
+    [first_digit, prefix(power_of_ten), rest].join('-')
+  end
+  
+end

data/lib/digits/two_digits.rb

@@ -22,23 +22,23 @@ class TwoDigits
   end
   
   def less_than_20?
-    num_abs < 20
+    num < 20
   end
   
   def less_than_20 
-    numbers_in_words['tenss'][num_mod]
+    numbers_in_words['tenss'][num_mod(10)]
   end
   
   def more_than_19
-    num_mod.zero? ? simple_tens : complex_tens
+    num_mod(10).zero? ? simple_tens : complex_tens
   end
   
   def simple_tens
-    numbers_in_words['tens'][num_abs/10]
+    numbers_in_words['tens'][num/10]
   end
   
   def complex_tens
-    simple_tens+'-'+numbers_in_words['ones'][num_mod]
+    [simple_tens, single_digits(num_mod(10))].join('-')
   end
   
 end

data/lib/english_number.rb

@@ -2,6 +2,7 @@ require 'yaml'
 require 'active_support/inflector'
 
 require 'digits/two_digits'
+require 'digits/three_digits'
 require 'modules/compute'
 require 'modules/translate'
 
@@ -12,10 +13,12 @@ class EnglishNumber
   
   def initialize(num)
     raise ArgumentError unless num.is_a?(Numeric)
-    @num = num.to_i
+    @num = num
   end
   
   # To get translation use #in_english method from ::Translate
+  # Limit of digits can be set on constant DIGITS_LIMIT on ::Translate
+  # For now gem works for up to three-digit numbers
   
 end
 

data/lib/modules/compute.rb

@@ -9,12 +9,8 @@ module Compute
     end
   end
   
-  def num_mod
-    num_abs.modulo(10)
+  def num_mod(number)
+    num.abs.modulo(number)
   end
 
-  def num_abs
-    num.abs
-  end
-  
 end

data/lib/modules/languages/english_numbers.yml

@@ -1,3 +1,4 @@
 ones: [zero, one, two, three, four, five, six, seven, eight, nine]
 tenss: [ten, eleven, twelve, thirteen, fourteen, fifteen, sixteen, seventeen, eighteen, nineteen]
-tens: [zero, ten, twenty, thirty, forty, fifty, sixty, seventy, eighty, ninety]
+tens: [zero, ten, twenty, thirty, forty, fifty, sixty, seventy, eighty, ninety]
+powers: [one, ten, hundred, thousand, ten-thousand, hundred-thousand, million, ten-million, hundred-million, billion]

data/lib/modules/translate.rb

@@ -1,28 +1,50 @@
 module Translate
+  # Set the limit of translated number of digits
+  DIGITS_LIMIT = 2
 
   def in_english
-    # Limit of digits - ready for further extensions
-    return nil if digits_count > 2
+    return nil if over_limit?
     
     num < 0 ? "minus-#{in_words}" : in_words
   end
 
   private
 
+  def over_limit?
+    digits_count > DIGITS_LIMIT
+  end
+
   def numbers_in_words
     return YAML.load_file(File.join(File.dirname(File.expand_path(__FILE__)), 'languages/english_numbers.yml'))
   end
   
   def in_words
-    return single_digits(num_abs) unless digits_count > 1
-    "#{single_digits(digits_count).capitalize}Digits".constantize.send(:run, num)
+    return single_digits(formatted_num) unless digits_count > 1
+    "#{single_digits(digits_count).capitalize}Digits".constantize.send(:run, formatted_num)
+  end
+  
+  def in_array
+    formatted_num.to_s.split(//)
   end
   
   def digits_count
-    num.to_s.delete('-').split(//).count
+    in_array.count
+  end
+  
+  def power_of_ten
+    digits_count - 1
   end
   
   def single_digits(number)
     numbers_in_words['ones'][number]
   end
+  
+  def prefix(number)
+    numbers_in_words['powers'][number]
+  end
+  
+  def formatted_num
+    num.abs.to_i
+  end
+  
 end

data/spec/integrations/english_number_int_spec.rb

@@ -2,72 +2,154 @@ RSpec.describe EnglishNumber do
   subject(:eng_num) { described_class }
   
   # Integration tests
-  it 'includes Compute module' do
-    expect(eng_num.included_modules).to include(Compute)
+  it 'includes Translate module' do
+    expect(eng_num.included_modules).to include(Translate)
   end
   
   describe '::Translate module' do
+    
+    context 'when single digit' do
   
-    it 'translates one digit numbers to English words' do
-      expect(eng_num.new(6).in_english).to eq('six')
+      it 'translates one digit numbers to English words' do
+        expect(eng_num.new(6).in_english).to eq('six')
+      end
+      
+      it 'translates negative one digit numbers' do
+        expect(eng_num.new(-7).in_english).to eq('minus-seven')
+      end
+      
+      it 'translates float numbers to English words rounded down' do
+        expect(eng_num.new(5.5).in_english).to eq('five')
+      end
+      
     end
     
-    it 'translates two digit numbers < 20 to English words' do
-      expect(eng_num.new(11).in_english).to eq('eleven')
-    end
+    context 'when two digits', if: Translate::DIGITS_LIMIT > 1 do
     
-    it 'translates two digit numbers >= 20 to English words' do
-      expect(eng_num.new(22).in_english).to eq('twenty-two')
-    end
+      it 'translates two digit numbers < 20 to English words' do
+        expect(eng_num.new(11).in_english).to eq('eleven')
+      end
+      
+      it 'translates two digit numbers >= 20 to English words' do
+        expect(eng_num.new(22).in_english).to eq('twenty-two')
+      end
+      
+      it 'translates negative two digit numbers < 20' do
+        expect(eng_num.new(-15).in_english).to eq('minus-fifteen')
+      end
     
-    it 'translates float numbers to English words rounded down' do
-      expect(eng_num.new(24.5).in_english).to eq('twenty-four')
+      it 'translates negative two digit numbers >= 20' do
+        expect(eng_num.new(-43).in_english).to eq('minus-forty-three')
+      end
+      
+      it 'translates float numbers to English words rounded down' do
+        expect(eng_num.new(24.5).in_english).to eq('twenty-four')
+      end
+      
+      it 'translates multiplications of 10 properly' do
+        expect(eng_num.new(30).in_english).to eq('thirty')
+      end
+      
     end
     
-    it 'doesn\'t translate numbers greater than 99' do
-      expect(eng_num.new(99).in_english).to eq('ninety-nine')
-      expect(eng_num.new(100).in_english).to eq(nil)
-    end
+    context 'when three digits', if: Translate::DIGITS_LIMIT > 2 do
     
-    it 'translates negative one digit numbers' do
-      expect(eng_num.new(-7).in_english).to eq('minus-seven')
-    end
+      it 'translates three digit numbers to English words' do
+        expect(eng_num.new(765).in_english).to eq('seven-hundred-sixty-five')
+      end
+      
+      it 'translates negative three digit numbers' do
+        expect(eng_num.new(-145).in_english).to eq('minus-one-hundred-forty-five')
+      end
     
-    it 'translates negative two digit numbers < 20' do
-      expect(eng_num.new(-15).in_english).to eq('minus-fifteen')
-    end
+      it 'translates multiplications of 100 properly' do
+        expect(eng_num.new(400).in_english).to eq('four-hundred')
+      end
     
-    it 'translates negative two digit numbers >= 20' do
-      expect(eng_num.new(-43).in_english).to eq('minus-forty-three')
     end
     
-    it 'doesn\'t translate numbers lower than -99' do
-      expect(eng_num.new(-99).in_english).to eq('minus-ninety-nine')
-      expect(eng_num.new(-100).in_english).to eq(nil)
-    end 
+    context 'when over set limit of digits' do
+      let(:limit) { 10**Translate::DIGITS_LIMIT }
+      let(:num) { rand(limit..10*limit) }
+      
+      it 'doesn\'t translate positive numbers with more digits than limit' do
+        expect(eng_num.new(num).in_english).to eq(nil)
+      end
+     
+      it 'doesn\'t translate negative numbers with more digits than limit' do
+        expect(eng_num.new(0-num).in_english).to eq(nil)
+      end 
+    end
     
   end
   
-  it 'includes Translate module' do
-    expect(eng_num.included_modules).to include(Translate)
+  it 'includes Compute module' do
+    expect(eng_num.included_modules).to include(Compute)
   end
   
   describe '::Compute module' do
     
-    it 'adds numbers and returns new object' do
-      expect((eng_num.new(12) + eng_num.new(86)).in_english).to eq('ninety-eight')
+    context 'adds numbers and returns new object' do
+      
+      it 'single digits' do
+        expect((eng_num.new(2) + eng_num.new(6)).num).to eq(8)
+      end
+      
+      it 'two digits', if: Translate::DIGITS_LIMIT > 1 do
+        expect((eng_num.new(12) + eng_num.new(86)).num).to eq(98)
+      end
+      
+      it 'three digits', if: Translate::DIGITS_LIMIT > 2 do
+        expect((eng_num.new(112) + eng_num.new(245)).num).to eq(357)
+      end
     end
     
-    it 'subtracts numbers and returns new object' do
-      expect((eng_num.new(10) - eng_num.new(17)).in_english).to eq('minus-seven')
+    context 'subtracts numbers and returns new object' do
+      
+      it 'single digits' do
+        expect((eng_num.new(7) - eng_num.new(3)).num).to eq(4)
+      end
+      
+      it 'two digits' do
+        expect((eng_num.new(10) - eng_num.new(17)).num).to eq(-7)
+      end
+      
+      it 'three digits' do
+        expect((eng_num.new(765) - eng_num.new(265)).num).to eq(500)
+      end
+      
     end
     
-    it 'multiplies numbers and returns new object' do
-      expect((eng_num.new(2) * eng_num.new(2)).in_english).to eq('four')
+    context 'multiplies numbers and returns new object' do
+      
+      it 'single digits' do
+        expect((eng_num.new(2) * eng_num.new(3)).num).to eq(6)
+      end
+      
+      it 'two digits' do
+        expect((eng_num.new(11) * eng_num.new(45)).num).to eq(495)
+      end
+      
+      it 'three digits' do
+        expect((eng_num.new(765) - eng_num.new(265)).num).to eq(500)
+      end
+      
     end
     
-    it 'divides numbers and returns new object' do
-      expect((eng_num.new(55) / eng_num.new(2)).in_english).to eq('twenty-seven')
+    
+    context 'divides numbers and returns new object' do
+      
+      it 'single digits' do
+        expect((eng_num.new(8) / eng_num.new(2)).num).to eq(4)
+      end
+      
+      it 'two digits' do
+        expect((eng_num.new(66) / eng_num.new(3)).num).to eq(22)
+      end
+      
+      it 'three digits' do
+        expect((eng_num.new(754) / eng_num.new(4)).num).to eq(188)
+      end
     end
     
   end

data/spec/unit_tests/compute_spec.rb

@@ -60,13 +60,9 @@ RSpec.describe 'Compute module' do
   
   context 'having any object with num attribute' do
     let(:object) { dummy_class.new(-68) }
-    
-    it '#num_abs returns absolute from the num attribute' do
-      expect(object.num_abs).to eq(68)
-    end
-    
-    it '#num_mod returns modulo from dividing num attribute absolute by 10' do
-      expect(object.num_mod).to eq(8)
+
+    it '#num_mod returns modulo from dividing num attribute absolute by given number' do
+      expect(object.num_mod(10)).to eq(8)
     end
     
   end

data/spec/unit_tests/english_number_unit_spec.rb

@@ -53,8 +53,4 @@ RSpec.describe EnglishNumber do
     
   end
   
-  it 'transforms floating numbers to integers' do
-    expect(eng_num.new(78.543).num).to eq(78)
-  end
-  
 end

data/spec/unit_tests/three_digits_spec.rb

@@ -0,0 +1,61 @@
+RSpec.describe ThreeDigits do
+  subject(:three_dig) { described_class }
+  
+  context 'modules' do
+    
+    it 'includes Compute module' do
+      expect(three_dig.included_modules).to include(Compute)
+    end
+    
+    it 'includes Translate module' do
+      expect(three_dig.included_modules).to include(Translate)
+    end
+    
+  end
+  
+  context '#run' do
+    let(:num) { rand }
+    let(:inst) { instance_double('ThreeDigits') }
+  
+    it 'responds to class method #run(num)' do
+      expect(three_dig).to respond_to(:run).with(1).argument
+      three_dig.run(num)
+    end
+    
+    it 'when #run used it it invokes #in_words on new instance' do
+      allow(three_dig).to receive(:new).with(num) { inst }
+      expect(inst).to receive(:in_words)
+      three_dig.run(num)
+    end
+  
+  end
+  
+  context '#in_words', if: Translate::DIGITS_LIMIT > 2 do
+
+    context 'works for three-digit numbers:' do
+      it '100' do
+        expect(three_dig.new(100).in_words).to eq('one-hundred')
+      end
+      it '121' do
+        expect(three_dig.new(121).in_words).to eq('one-hundred-twenty-one')
+      end
+      it '237' do
+        expect(three_dig.new(237).in_words).to eq('two-hundred-thirty-seven')
+      end
+      it '300' do
+        expect(three_dig.new(300).in_words).to eq('three-hundred')
+      end
+      it '600' do
+        expect(three_dig.new(600).in_words).to eq('six-hundred')
+      end
+      it '873' do
+        expect(three_dig.new(873).in_words).to eq('eight-hundred-seventy-three')
+      end
+      it '999' do
+        expect(three_dig.new(999).in_words).to eq('nine-hundred-ninety-nine')
+      end
+    end
+  
+  end
+  
+end

data/spec/unit_tests/translate_spec.rb

@@ -0,0 +1,31 @@
+RSpec.describe 'Translate module' do
+  let(:dummy_class) { Class.new { 
+      include Translate
+      attr_reader :num
+      def initialize(num)
+        @num = num
+      end } }
+  
+  
+  context '#in_english, having any object with num attribute' do
+    let(:limit_number) { 10**Translate::DIGITS_LIMIT }
+    let(:within_limit_num) { rand(limit_number) }
+    let(:positive_num_object) { dummy_class.new(within_limit_num) }
+    let(:negative_num_object) { dummy_class.new(0-within_limit_num) }
+    let(:overlimit_num) { rand(limit_number..10*limit_number) }
+    let(:bad_object) { dummy_class.new(overlimit_num) }
+
+    it 'returns nil when digits count of num is over limit set in over_limit? method' do
+      expect(bad_object.in_english).to eq(nil)
+    end
+    
+    it 'should add "minus-" when the num is negative' do
+      expect(negative_num_object.in_english).to match(/^minus-/)
+    end
+    
+    it 'shouldn\'t add "minus-" when the num is positive' do
+      expect(positive_num_object.in_english).not_to match(/^minus-/)
+    end
+  end
+  
+end

data/spec/unit_tests/two_digits_spec.rb

@@ -0,0 +1,61 @@
+RSpec.describe TwoDigits do
+  subject(:two_dig) { described_class }
+  
+  context 'modules' do
+    
+    it 'includes Compute module' do
+      expect(two_dig.included_modules).to include(Compute)
+    end
+    
+    it 'includes Translate module' do
+      expect(two_dig.included_modules).to include(Translate)
+    end
+    
+  end
+  
+  context '#run' do
+    let(:num) { rand }
+    let(:inst) { instance_double('TwoDigits') }
+  
+    it 'responds to class method #run(num)' do
+      expect(two_dig).to respond_to(:run).with(1).argument
+      two_dig.run(num)
+    end
+    
+    it 'when #run used it it invokes #in_words on new instance' do
+      allow(two_dig).to receive(:new).with(num) { inst }
+      expect(inst).to receive(:in_words)
+      two_dig.run(num)
+    end
+  
+  end
+  
+  context '#in_words', if: Translate::DIGITS_LIMIT > 1 do
+
+    context 'works for two-digit numbers smaller than 20:' do
+      it '10' do
+        expect(two_dig.new(10).in_words).to eq('ten')
+      end
+      it '16' do
+        expect(two_dig.new(16).in_words).to eq('sixteen')
+      end
+      it '19' do
+        expect(two_dig.new(19).in_words).to eq('nineteen')
+      end
+    end
+    
+    context 'works for two-digit numbers greater than 19' do
+      it '25' do
+        expect(two_dig.new(25).in_words).to eq('twenty-five')
+      end
+      it '50' do
+        expect(two_dig.new(50).in_words).to eq('fifty')
+      end
+      it '99' do
+        expect(two_dig.new(99).in_words).to eq('ninety-nine')
+      end
+      
+    end
+  end
+  
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: english_number
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Piotr Brych
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-13 00:00:00.000000000 Z
+date: 2016-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -54,7 +54,7 @@ dependencies:
         version: 0.11.2
 description: "Example: EnglishNumber.new(63).in_english # => 'sixty-three'.\n \n                   EnglishNumber
   objects can be added, subtracted, multiplied, divided.\n\n                   For
-  now gem is deliberately limited to numbers maximum two digits long."
+  now gem is deliberately limited to numbers maximum three digits long.\n"
 email: pbrych@gmail.com
 executables: []
 extensions: []
@@ -62,8 +62,11 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- CHANGELOG.md
 - Gemfile
+- README.md
 - english_number.gemspec
+- lib/digits/three_digits.rb
 - lib/digits/two_digits.rb
 - lib/english_number.rb
 - lib/modules/compute.rb
@@ -73,6 +76,9 @@ files:
 - spec/spec_helper.rb
 - spec/unit_tests/compute_spec.rb
 - spec/unit_tests/english_number_unit_spec.rb
+- spec/unit_tests/three_digits_spec.rb
+- spec/unit_tests/translate_spec.rb
+- spec/unit_tests/two_digits_spec.rb
 homepage: http://rubygems.org/gems/english-number.rb
 licenses:
 - MIT