This is the CalculatorAdvanced Kata from the Kata gem. I've just finished it and would love some feedback on my solution.
CalculatorAdvanced Kata Add Method Allow the expression to handle new lines between numbers - example: "1\n2\n3" computes to 6 - example: "2,3\n4" computes to 9 - detail: Consecutive use of delimeters should raise an exception - example: "1,\n2" or "1\n,2" completed (Y|n): Calling method with a negative number will give an exception - detail: The exception should tell the user "negatives not allowed" - detail: The exception will list the negative number that was in the string - detail: The exception should list all negatives if there is more than one completed (Y|n): Diff and Product Method should raise the same exceptions as the add method - detail: Consecutive Delimiters - detail: Negative Numbers completed (Y|n): Define Custom Delimeters Allow the add method to accept a different delimiter - detail: The line of the string will contain "//[delimeter]\n... - detail: This line is optional and all previous tests should pass - example: "//[;]\n1;2" computes to 3 - detail: "1;2" should raise an exception completed (Y|n): Allow the diff method to accept a different delimiter like add - example: //[;]\n2;1 computes to 1 completed (Y|n): Allow the prod method to accept a different delimiter like add - example: //[;]\n2;1 computes to 2 completed (Y|n): Allow the div method to accept a different delimiter like add - example: //[;]\n3;2 computes to 1 completed (Y|n): Allow the add method to handle multiple different delimeters - example: multiple delimeters can be specified using "//[delimeter]...[delimeter]\n... - example: "//[*][;]\n1*2;3" computes to 6 - example: "//[*][;][#]\n5*4;3#2" computes to -4 - example: "//[#][;][*]\n1*2#3;4,5\n6" computes to 21 completed (Y|n): Allow the diff method to handle multiple different delimeters - example: "//[*][;]\n1*2;3" computes to -4 completed (Y|n): Allow the prod method to handle multiple different delimeters - example: "//[*][;]\n1*2;3" computes to 6 completed (Y|n): Allow the div method to handle multiple different delimeters - example: "//[*][;]\n1*2;3" computes to 0 completed (Y|n): ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━┓ ┃ Requirement ┃ Time ┃ ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╊━━━━━━━━━━┫ ┃ Allow the expression to handle new lines between numbers ┃ 00:37:20 ┃ ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╊━━━━━━━━━━┫ ┃ Calling method with a negative number will give an exception ┃ 00:20:55 ┃ ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╊━━━━━━━━━━┫ ┃ should raise the same exceptions as the add method ┃ 00:08:41 ┃ ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╊━━━━━━━━━━┫ ┃ Allow the add method to accept a different delimiter ┃ 00:22:51 ┃ ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╊━━━━━━━━━━┫ ┃ Allow the diff method to accept a different delimiter like add ┃ 00:06:04 ┃ ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╊━━━━━━━━━━┫ ┃ Allow the prod method to accept a different delimiter like add ┃ 00:01:49 ┃ ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╊━━━━━━━━━━┫ ┃ Allow the div method to accept a different delimiter like add ┃ 00:01:46 ┃ ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╊━━━━━━━━━━┫ ┃ Allow the add method to handle multiple different delimeters ┃ 00:55:48 ┃ ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╊━━━━━━━━━━┫ ┃ Allow the diff method to handle multiple different delimeters ┃ 00:00:54 ┃ ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╊━━━━━━━━━━┫ ┃ Allow the prod method to handle multiple different delimeters ┃ 00:00:38 ┃ ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╊━━━━━━━━━━┫ ┃ Allow the div method to handle multiple different delimeters ┃ 00:00:43 ┃ ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┻━━━━━━━━━━┛
And, here's the Class I created:
class Calculatoradvanced attr_reader :expr def expr=(expression='') @expr = expression validate_expression end alias_method :initialize, :expr= def add @values.inject(&:+) end def diff @values.inject(&:-) end def prod @values.inject(&:*) end def div @values.inject(&:/) end private def validate_expression if @expr =~ /,\n/ || @expr =~ /\n,/ raise "Consecutive Delimiters" end split_string = ",\n" if match = @expr.match(/\/\/([^\n]*)\n(.*)/m) delimeters, @expr = match.captures delimeters = delimeters.split(/[\[\]]/) delimeters.reject! { |delimeter| delimeter == '' } split_string = "#{Regexp.escape(delimeters.join)}" + split_string end @values = @expr.split(/[#{split_string}]/).map(&:to_i) @negatives = @values.select { |value| value < 0 } if (@negatives && @negatives.any?) raise "negatives not allowed: #{@negatives.join(', ')}" end end end I'm really unsatisfied with the test for Consecutive Delimiters. If anyone knows of a good way to make that test more flexible, I'd love to hear it.
Here are my specs:
require 'spec_helper' require 'calculatoradvanced' describe Calculatoradvanced do subject(:calc) { Calculatoradvanced.new(expression) } context 'with an empty expression' do let(:expression) { '' } specify { expect { calc }.to_not raise_exception } end context 'with expression "1\n2\n3"' do let(:expression) { "1\n2\n3" } specify { expect { calc }.to_not raise_exception } its(:add) { should eq(6) } end context 'with expression "2,3\n4"' do let(:expression) { "2,3\n4" } its(:add) { should eq(9) } its(:expr) { should eq("2,3\n4") } end context 'with expression "1,\n2"' do let(:expression) { "1,\n2" } specify { expect { calc.add }.to raise_exception } end context 'with expression "1\n,2"' do let(:expression) { "1\n,2" } specify { expect { calc.add }.to raise_exception } end shared_examples_for 'expression validation' do specify { expect { method }.to raise_exception(RuntimeError, /negatives not allowed/) } specify { expect { method }.to raise_exception(RuntimeError, /-1, -2, -3/) } end context 'with expression "-1,-2\n-3"' do let(:expression) { "-1,-2\n-3" } context '.add' do let(:method) { calc.add } it_behaves_like 'expression validation' end context '.diff' do let(:method) { calc.diff } it_behaves_like 'expression validation' end context '.prod' do let(:method) { calc.prod } it_behaves_like 'expression validation' end end context 'with expression "//[;]\n1;2"' do let(:expression) { "//[;]\n1;2" } its(:add) { should eq(3) } end context 'with expression "//[;]\n2;1"' do let(:expression) { "//[;]\n2;1" } its(:diff) { should eq(1) } its(:prod) { should eq(2) } end context 'with expression "//[;]\n3;2"' do let(:expression) { "//[;]\n3;2" } its(:div) { should eq(1) } end context 'with expression "//[*][;]\n1*2;3"' do let(:expression) { "//[*][;]\n1*2;3" } its(:add) { should eq(6) } its(:diff) { should eq(-4) } its(:prod) { should eq(6) } its(:div) { should eq(0) } end context 'with expression "//[*][;][#]\n5*4;3#2"' do let(:expression) { "//[*][;][#]\n5*4;3#2" } its(:diff) { should eq(-4) } end context 'with expression "//[#][;][*]\n1*2#3;4,5\n6"' do let(:expression) { "//[#][;][*]\n1*2#3;4,5\n6" } its(:add) { should eq(21) } end end 
