samjones-calculator 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 450579aba0c0d50d4f55a692db441e15b278abd8
-  data.tar.gz: 9b7b92648664b1e93463eedc984330dd17641f08
+  metadata.gz: 8496db06a4c79a55168cfdb0355a03c85a3f83e5
+  data.tar.gz: 198891de801f830dcfc595546b2daa693535e00c
 SHA512:
-  metadata.gz: f7cc190c53a504282bfbd468f517bc7c849ba5163924baa0e58dca4a52cfee89f19390da33d439e1bd509bdc4d6cfab13c5c1ec10679918a65648625723d1086
-  data.tar.gz: d0e8262c13b58257e4282f0541ce47f745da9c1dad0eedcde022f606d40ac6dd27f2db529ec58c561b5164ba2e99195db34372ecb38715bcd98d042b773ae820
+  metadata.gz: 9b10f9ab5b17660bbc280f01cc3e9d94146db21c3e15810edbae24a801b55b1e7b0e5f2044c803b512f990fb5df01e02617c42426742bfb14327fa2ed8d51a20
+  data.tar.gz: fe8d3c61d4a48877c0560f000cd013955e1dfd176c0d7def246c836ce75925580b87fff26a48e2966506acf06a2db40c8ec8b8986ebc600d6ccc2de08724d9ee

data/lib/calculator/string_calculator.rb

@@ -1,7 +1,9 @@
+require 'tokenizer/tokenizer'
+
 class StringCalculator
-  def initialize(value = 0, tokenizer = Tokenizer.new)
+  include Tokenizer
+  def initialize(value = 0)
     @value = value
-    @tokenizer = tokenizer
   end
 
   def value
@@ -9,14 +11,13 @@ class StringCalculator
   end
 
   def add(string)
+    check_negatives(string)
     @value += sum_ints(string)
     self
   end
 
   def sum_ints(string)
-    ints = @tokenizer.ints(string)
-    @negs = ints.select { |i| i<0 }
-    ints.inject(:+)
+    ints(string).inject(:+)
   end
 
 
@@ -25,8 +26,9 @@ class StringCalculator
     self
   end
 
-  def check_negatives
-    raise "Negatives not allowed! #{@negs.join(', ')}" if @negs.any?
+  def check_negatives(string)
+    negs = ints(string).select { |i| i<0 }
+    raise "Negatives not allowed! #{negs.join(', ')}" if negs.any?
     self
   end
 end

data/lib/tokenizer/tokenizer.rb

@@ -1,4 +1,4 @@
-class Tokenizer
+module Tokenizer
   def initialize
     @regex_or = '|'
 

data/spec/calculator/calculator_spec.rb

@@ -1,116 +1,165 @@
 require 'calculator/string_calculator'
-require 'tokenizer/tokenizer'
 
-def tokenizer(test)
-  tokenizer = instance_double('Tokenizer')
-  allow(tokenizer).to receive(:ints) { test[:ints] }
-  expect(tokenizer).to receive(:ints).with(test[:string])
-  tokenizer
-end
 
 describe 'StringCalculator' do
 
-  it 'should have a default value' do
-    expect(StringCalculator.new.value).to eq(0)
-    expect(StringCalculator.new(0).value).to eq(0)
-    expect(StringCalculator.new(10).value).to eq(10)
-  end
-
-  context 'add' do
-    it 'should add' do
-      [{
-           :initial_value => 0,
-           :string => '10',
-           :ints => [10],
-           :result => 10
-       },
-       {
-           :initial_value => 10,
-           :string => '10',
-           :ints => [10],
-           :result => 20
-       },
-       {
-           :initial_value => 10,
-           :string => '0',
-           :ints => [0],
-           :result => 10
-       }
-      ].each { |test|
-        expect(StringCalculator.new(test[:initial_value], tokenizer(test)).add(test[:string]).value).to eq(test[:result])
-      }
+  context 'initial values' do
+    it 'should have a default value' do
+      expect(StringCalculator.new.value).to eq(0)
     end
 
-    it 'should add with no negatives when checking for negatives' do
-      [{
-           :initial_value => 0,
-           :string => '10',
-           :ints => [10],
-           :result => 10
-       }
-      ].each { |test|
-        expect(StringCalculator.new(test[:initial_value], tokenizer(test)).add(test[:string]).check_negatives.value).to eq(test[:result])
-      }
+
+    [
+        {
+            :initial_value => 0,
+            :value => 0
+        },
+        {
+            :initial_value => 10,
+            :value => 10
+        }
+    ].each do |test_case|
+      it 'should have a value' do
+        expect(StringCalculator.new(test_case[:initial_value]).value).to eq(test_case[:value])
+      end
     end
+  end
+
 
-    it 'should not add with negatives when checking for negatives' do
-      [{
-           :initial_value => 0,
-           :string => '-10',
-           :ints => [-10],
-           :result => 10
-       }
-      ].each { |test|
-        expect { StringCalculator.new(test[:initial_value], tokenizer(test)).add(test[:string]).check_negatives }.to raise_error('Negatives not allowed! -10')
-      }
+  context 'sum' do
+    [
+        {
+            :initial_value => 0,
+            :string => '10,20',
+            :ints => [10, 20],
+            :sum => 30
+        },
+        {
+            :initial_value => 10,
+            :string => '10,20',
+            :ints => [10, 20],
+            :sum => 30
+        },
+        {
+            :initial_value => 0,
+            :string => '10,-20',
+            :ints => [10, -20],
+            :sum => -10
+        },
+        {
+            :initial_value => 10,
+            :string => '10,-20',
+            :ints => [10, -20],
+            :sum => -10
+        }
+    ].each do |test_case|
+      it 'should sum ints' do
+        calculator = StringCalculator.new(test_case[:initial_value])
+        allow(calculator).to receive(:ints).and_return(test_case[:ints])
+        expect(calculator.sum_ints(test_case[:string])).to eq(test_case[:sum])
+      end
     end
   end
 
-  context 'subtract' do
-    it 'should subtract' do
-      [{
-           :initial_value => 0,
-           :string => '10',
-           :ints => [10],
-           :result => -10
-       },
-       {
-           :initial_value => 10,
-           :string => '10',
-           :ints => [10],
-           :result => 0
-       }
-      ].each { |test|
-        expect(StringCalculator.new(test[:initial_value], tokenizer(test)).subtract(test[:string]).value).to eq(test[:result])
-      }
+
+  context 'check negatives' do
+    [
+        {
+            :initial_value => 0,
+            :string => '10,20',
+            :ints => [10, 20],
+            :raise => false
+        },
+        {
+            :initial_value => 0,
+            :string => '10,-20',
+            :ints => [10, -20],
+            :raise => true,
+            :error => 'Negatives not allowed! -20'
+        },
+        {
+            :initial_value => 0,
+            :string => '10,-20,-30',
+            :ints => [10, -20, -30],
+            :raise => true,
+            :error => 'Negatives not allowed! -20, -30'
+        }
+    ].each do |test_case|
+      it 'should check negatives' do
+        calculator = StringCalculator.new(test_case[:initial_value])
+        allow(calculator).to receive(:ints).and_return(test_case[:ints])
+        expect { calculator.check_negatives(test_case[:string]) }.to raise_error(test_case[:error]) if test_case[:raise]
+        expect(calculator.check_negatives(test_case[:string])).to eq(calculator) unless test_case[:raise]
+      end
     end
+  end
+
 
-    it 'should subtract with no negatives when checking for negatives' do
-      [{
-           :initial_value => 0,
-           :string => '10',
-           :ints => [10],
-           :result => -10
-       }
-      ].each { |test|
-        expect(StringCalculator.new(test[:initial_value], tokenizer(test)).subtract(test[:string]).check_negatives.value).to eq(test[:result])
-      }
+  context 'add' do
+    [
+        {
+            :initial_value => 0,
+            :string => '10,20',
+            :ints => [10, 20],
+            :value => 30,
+            :raise => false
+        },
+        {
+            :initial_value => 10,
+            :string => '10,20',
+            :ints => [10, 20],
+            :value => 40,
+            :raise => false
+        },
+        {
+            :initial_value => 0,
+            :string => '10,20',
+            :ints => [10, 20],
+            :raise => true
+        }
+    ].each do |test_case|
+      it 'should add' do
+        calculator = StringCalculator.new(test_case[:initial_value])
+        allow(calculator).to receive(:ints).and_return(test_case[:ints])
+        allow(calculator).to receive(:check_negatives) { raise 'Error' if test_case[:raise] }
+        expect { calculator.add(test_case[:string]) }.to raise_error('Error') if test_case[:raise]
+        expect(calculator.add(test_case[:string]).value).to eq(test_case[:value]) unless test_case[:raise]
+      end
     end
+  end
 
-    it 'should not subtract with negatives when checking for negatives' do
-      [{
-           :initial_value => 0,
-           :string => '-10',
-           :ints => [-10],
-           :result => 10
-       }
-      ].each { |test|
-        expect { StringCalculator.new(test[:initial_value], tokenizer(test)).subtract(test[:string]).check_negatives }.to raise_error('Negatives not allowed! -10')
-      }
+
+  context 'subtract' do
+    [
+        {
+            :initial_value => 0,
+            :string => '10,20',
+            :ints => [10, 20],
+            :value => -30,
+        },
+        {
+            :initial_value => 50,
+            :string => '10,20',
+            :ints => [10, 20],
+            :value => 20,
+        }
+    ].each do |test_case|
+      it 'should subtract' do
+        calculator = StringCalculator.new(test_case[:initial_value])
+        allow(calculator).to receive(:ints).and_return(test_case[:ints])
+        expect(calculator.subtract(test_case[:string]).value).to eq(test_case[:value])
+      end
     end
   end
 
-  it 'should do both' do
-    expect(StringCalculator.new.add('10').subtract('5').add('15,10').subtract('5,2').value).to eq(23)
+
+  context 'preserve value' do
+    it 'should preserve value calls' do
+      calculator = StringCalculator.new(0)
+      allow(calculator).to receive(:ints).and_return([10, 20])
+      expect(calculator.subtract('10,20').value).to eq(-30)
+      allow(calculator).to receive(:ints).and_return([30, 40])
+      expect(calculator.add('30,40').value).to eq(40)
+    end
   end
 end

data/spec/tokenizer/tokenizer_spec.rb

@@ -1,44 +1,56 @@
 require 'tokenizer/tokenizer.rb'
 
-describe 'Tokenizer' do
-  it "should not blow up" do
-    expect(Tokenizer.new.ints).to eq([])
-    expect(Tokenizer.new.ints('')).to eq([])
+describe Tokenizer do
+
+  let(:tokenizer) { Class.new { include Tokenizer }.new }
+
+
+  it 'should not blow up' do
+    expect(tokenizer.ints).to eq([])
+    expect(tokenizer.ints('')).to eq([])
   end
 
-  it "should tokenize" do
-    expect(Tokenizer.new.tokens('abc')).to eq(['abc'])
-    expect(Tokenizer.new.tokens('abc,123')).to eq(['abc', '123'])
+
+  it 'should tokenize' do
+    expect(tokenizer.tokens('abc')).to eq(['abc'])
+    expect(tokenizer.tokens('abc,123')).to eq(['abc', '123'])
   end
 
-  it "should handle multiple delimiters" do
-    expect(Tokenizer.new.tokens("1,2\n3")).to eq(['1', '2', '3'])
+
+  it 'should handle multiple delimiters' do
+    expect(tokenizer.tokens("1,2\n3")).to eq(['1', '2', '3'])
   end
 
-  it "should handle setting delimiter" do
-    expect(Tokenizer.new.tokens("//'\n1'2")).to eq(['1', '2'])
+
+  it 'should handle setting delimiter' do
+    expect(tokenizer.tokens("//'\n1'2")).to eq(['1', '2'])
   end
 
-  it "should handle setting multiple delimiters" do
-    expect(Tokenizer.new.tokens("//['][#]\n1'2#3")).to eq(['1', '2', '3'])
+
+  it 'should handle setting multiple delimiters' do
+    expect(tokenizer.tokens("//['][#]\n1'2#3")).to eq(['1', '2', '3'])
   end
 
-  it "should handle complex delimiters" do
-    expect(Tokenizer.new.tokens("//['#]\n1'#2")).to eq(['1', '2'])
+
+  it 'should handle complex delimiters' do
+    expect(tokenizer.tokens("//['#]\n1'#2")).to eq(['1', '2'])
   end
 
-  it "should test for int" do
-    expect(Tokenizer.new.is_i?("123")).to eq(true)
-    expect(Tokenizer.new.is_i?("abc")).to eq(false)
+
+  it 'should test for int' do
+    expect(tokenizer.is_i?("123")).to eq(true)
+    expect(tokenizer.is_i?("abc")).to eq(false)
   end
 
-  it "should return ints" do
-    expect(Tokenizer.new.ints('1')).to eq([1])
-    expect(Tokenizer.new.ints('1,2')).to eq([1, 2])
+
+  it 'should return ints' do
+    expect(tokenizer.ints('1')).to eq([1])
+    expect(tokenizer.ints('1,2')).to eq([1, 2])
   end
 
-  it "should filter non ints" do
-    expect(Tokenizer.new.ints('abc,123')).to eq([123])
+
+  it 'should filter non ints' do
+    expect(tokenizer.ints('abc,123')).to eq([123])
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: samjones-calculator
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - Sam Jones
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-11 00:00:00.000000000 Z
+date: 2016-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -115,8 +115,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.6.4
 signing_key: 
 specification_version: 4
 summary: String Calculator
 test_files: []
+has_rdoc: