reverse-polish-calculator 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.DS_Store
+tmp

data/.rvmrc

@@ -0,0 +1 @@
+rvm 1.9.2@reverse-polish-calculator

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Justin Ko
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,28 @@
+# reverse-polish-calculator
+
+This is a [RPN](http://en.wikipedia.org/wiki/Reverse_Polish_notation) (Reverse Polish Notation) command line calculator. It supports arithmetic, and *most* of the methods in Ruby's [Math](http://www.ruby-doc.org/core/classes/Math.html) module.
+
+## Synopsis
+
+    $ rpc
+    $ 5 # => stack: 5.0
+             aggregate: 0
+    $ 5 # => stack: 5.0, 5.0
+             aggregate: 0
+    $ + # => calculated: 5.0 + 5.0
+             stack: 
+             aggregate: 10.0
+             
+For more examples, check out the acceptance specs.
+    
+## Installation
+
+    gem install reverse-polish-calculator
+
+## License
+
+reverse-polish-calculator is released under the MIT license. See LICENSE for details.
+
+## Copyright
+
+Copyright (c) 2011 Justin Ko

data/Rakefile

@@ -0,0 +1,15 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+task :default => ['spec:unit', 'spec:acceptance']
+
+namespace :spec do
+  
+  [:acceptance, :unit].each do |suite|
+    desc "Run the #{suite} specs"
+    RSpec::Core::RakeTask.new(suite) do |t|
+      t.pattern = "./spec/#{suite}/**/*_spec.rb"
+    end
+  end
+  
+end

data/bin/rpc

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+$:.unshift(File.expand_path(File.dirname(__FILE__) + '/../lib'))
+
+require 'reverse-polish-calculator'
+
+ReversePolishCalculator.start

data/lib/reverse-polish-calculator.rb

@@ -0,0 +1,31 @@
+require 'reverse-polish-calculator/helpers'
+require 'reverse-polish-calculator/stack'
+require 'reverse-polish-calculator/inputs'
+require 'reverse-polish-calculator/input'
+require 'reverse-polish-calculator/errors'
+require 'reverse-polish-calculator/output'
+
+module ReversePolishCalculator
+  
+  def self.start
+    loop_with_error_handling do   
+      stack.add(gets.chomp)
+      stack.calculate
+      stack.output
+    end
+  end
+  
+  def self.stack
+    @stack ||= Stack.new
+  end
+  
+  def self.loop_with_error_handling
+    loop { yield }
+  rescue *Errors::Classes => exception
+    Errors.handle(exception)
+    Output.clear
+    stack.unswap
+    retry
+  end    
+  
+end

data/lib/reverse-polish-calculator/errors.rb

@@ -0,0 +1,27 @@
+module ReversePolishCalculator
+  module Errors
+        
+    MethodMapping = {
+      NoMethodError => :no_method_error,
+      Math::DomainError => :math_domain_error
+    }
+    
+    Classes = MethodMapping.keys
+    
+    def self.handle(exception)
+      send(MethodMapping[exception.class], exception)
+    end
+    
+    def self.no_method_error(exception)
+      ReversePolishCalculator.stack.remove(exception.name)
+      Helpers.multi_puts "Cannot calculate '#{exception.name}'"
+    end
+    
+    def self.math_domain_error(exception)
+      name = exception.message.match(/"(.+)"/)[1]
+      ReversePolishCalculator.stack.remove(name)
+      Helpers.multi_puts "Bad value for '#{name}'"
+    end
+    
+  end
+end

data/lib/reverse-polish-calculator/helpers.rb

@@ -0,0 +1,11 @@
+module ReversePolishCalculator
+  module Helpers
+    
+    def self.multi_puts(*strings)
+      return if $in_unit_spec_suite
+      strings.each {|str| puts str }
+      puts
+    end
+    
+  end
+end

data/lib/reverse-polish-calculator/input.rb

@@ -0,0 +1,38 @@
+module ReversePolishCalculator
+  class Input
+    
+    attr_reader :value
+    
+    def initialize(value)
+      @value = value
+      exit if exited?
+    end
+    
+    def exited?
+      value.downcase == 'q'
+    end
+    
+    def invoke(input_1, input_2 = nil)
+      if math_method?
+        Output.add "calculated: #{value}(#{input_1.to_f})"
+        Math.send(value, input_1.to_f)
+      else
+        Output.add "calculated: #{input_1.to_f} #{value} #{input_2.to_f}"
+        input_1.to_f.send(value, input_2.to_f)
+      end
+    end
+    
+    def math_method?
+      Math.respond_to?(value)
+    end
+    
+    def operand?
+      !!value[/\d/]
+    end
+    
+    def to_f
+      value.to_f
+    end
+    
+  end
+end

data/lib/reverse-polish-calculator/inputs.rb

@@ -0,0 +1,79 @@
+module ReversePolishCalculator
+  module Inputs
+    
+    attr_accessor :swapped
+    
+    def calculate(aggregate = 0)
+      @operands, @trash = [], []
+      @aggregate = aggregate
+      
+      each do |input|        
+        if input.operand?
+          add_operand(input)
+        elsif input.math_method?
+          invoke_math_method(input)
+        else          
+          invoke_binary_operator(input)
+        end
+      end
+      
+      empty_trash
+      calculation
+    end
+    
+    def add_operand(input)
+      @operands << input
+      @calculated = false
+    end
+    
+    def invoke_math_method(input)
+      operand = @operands.pop || @aggregate
+      @operands.push input.invoke(operand)
+      @trash << input << operand
+      @calculated = true
+    end
+    
+    def invoke_binary_operator(input)
+      operand_1 = @operands.pop
+      operand_2 = @operands.pop
+      
+      unless operand_2
+        self.swapped = true
+        operand_2 = operand_1
+        operand_1 = @aggregate
+      else
+        self.swapped = false
+      end
+
+      @operands.push(if @swapped
+        input.invoke(operand_1, operand_2)
+      else
+        input.invoke(operand_2, operand_1)
+      end)
+      
+      @trash << input << operand_1 << operand_2
+      @calculated = true
+    end
+    
+    def calculation
+      if @calculated
+        if swapped
+          @operands.first
+        else
+          @aggregate + @operands.last.to_f
+        end
+      else
+        @aggregate
+      end
+    end
+    
+    def empty_trash
+      delete_if {|input| @trash.include?(input) }
+    end
+    
+    def inspect
+      map(&:to_f).join(', ')
+    end
+    
+  end
+end

data/lib/reverse-polish-calculator/output.rb

@@ -0,0 +1,21 @@
+module ReversePolishCalculator
+  module Output
+        
+    def self.add(str)
+      texts.push(str)
+    end
+    
+    def self.texts
+      @texts ||= []
+    end
+    
+    def self.display
+      Helpers.multi_puts(*texts)
+    end
+    
+    def self.clear
+      texts.clear
+    end
+      
+  end
+end

data/lib/reverse-polish-calculator/stack.rb

@@ -0,0 +1,38 @@
+module ReversePolishCalculator
+  class Stack
+        
+    attr_reader :inputs, :aggregate
+    
+    def initialize
+      @inputs, @aggregate = [].extend(Inputs), 0
+    end
+    
+    def add(expression)
+      expression.split.each do |value|
+        @inputs << Input.new(value)
+      end
+    end
+    
+    def remove(input_value)
+      @inputs.delete_if do |input|
+        input.value == input_value.to_s
+      end
+    end
+    
+    def calculate
+      @aggregate = @inputs.calculate(aggregate)
+    end
+    
+    def output
+      Output.add "stack: #{@inputs.inspect}"
+      Output.add "aggregate: #{@aggregate}"
+      Output.display
+      Output.clear
+    end
+    
+    def unswap
+      inputs.swapped = false
+    end
+    
+  end
+end

data/lib/reverse-polish-calculator/version.rb

@@ -0,0 +1,3 @@
+module ReversePolishCalculator
+  VERSION = '0.0.1'
+end

data/reverse-polish-calculator.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+require 'reverse-polish-calculator/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'reverse-polish-calculator'
+  s.version     = ReversePolishCalculator::VERSION
+  s.authors     = 'Justin Ko'
+  s.email       = 'jko170@gmail.com'
+  s.homepage    = 'https://github.com/justinko/reverse-polish-calculator'
+  s.summary     = 'Reverse Polish Calculator'
+  s.description = 'Command line RPN (Reverse Polish Notation) calculator'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_path  = 'lib'
+  
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'aruba'
+end

data/spec/acceptance/complex_expressions_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe 'complex expressions' do
+  
+  describe '5 1 2 + 4 * + 3 - 2 / cos' do
+    context 'on one line' do
+      it 'aggregates to 7.0' do 
+        start
+        type '5 1 2 + 4 * + 3 - 2 / cos'
+        type 'q'
+      
+        assert_exact_output <<-OUTPUT.rpc
+          calculated: 1.0 + 2.0
+          calculated: 3.0 * 4.0
+          calculated: 5.0 + 12.0
+          calculated: 17.0 - 3.0
+          calculated: 14.0 / 2.0
+          calculated: cos(7.0)
+          stack: 
+          aggregate: 0.7539022543433046
+
+        OUTPUT
+      end
+    end
+    
+    context 'on separate lines' do
+      it 'aggregates to 10.0' do 
+        start
+        type '5'
+        type '1'
+        type '2'
+        type '+'
+        type '4'
+        type '*'
+        type '+'
+        type '3'
+        type '-'
+        type '2'
+        type '/'
+        type 'cos'
+        type 'q'
+      
+        assert_exact_output <<-OUTPUT.rpc
+          stack: 5.0
+          aggregate: 0
+
+          stack: 5.0, 1.0
+          aggregate: 0
+
+          stack: 5.0, 1.0, 2.0
+          aggregate: 0
+
+          calculated: 1.0 + 2.0
+          stack: 5.0
+          aggregate: 3.0
+
+          stack: 5.0, 4.0
+          aggregate: 3.0
+
+          calculated: 5.0 * 4.0
+          stack: 
+          aggregate: 23.0
+
+          calculated: 23.0 + 0.0
+          stack: 
+          aggregate: 23.0
+
+          stack: 3.0
+          aggregate: 23.0
+
+          calculated: 23.0 - 3.0
+          stack: 
+          aggregate: 20.0
+          
+          stack: 2.0
+          aggregate: 20.0
+          
+          calculated: 20.0 / 2.0
+          stack: 
+          aggregate: 10.0
+          
+          calculated: cos(10.0)
+          stack: 
+          aggregate: -0.8390715290764524
+
+        OUTPUT
+      end
+    end
+  end
+  
+end

data/spec/acceptance/error_handling_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe 'error handling' do
+  
+  describe "for an input that can't be calculated" do
+    it 'provides a message' do
+      start
+      type 'foo'
+      type '5'
+      type '4'
+      type '+'
+      type 'q'
+  
+      assert_exact_output <<-OUTPUT.rpc
+        Cannot calculate 'foo'
+
+        stack: 5.0
+        aggregate: 0
+        
+        stack: 5.0, 4.0
+        aggregate: 0
+        
+        calculated: 5.0 + 4.0
+        stack: 
+        aggregate: 9.0
+
+      OUTPUT
+    end
+  end
+  
+  describe 'for a trigonometric method' do
+    context 'that is called with a non-computable value' do
+      it 'provides a message' do
+        start
+        type '5'
+        type 'acos'
+        type 'q'
+  
+        assert_exact_output <<-OUTPUT.rpc
+          stack: 5.0
+          aggregate: 0
+        
+          Bad value for 'acos'
+
+        OUTPUT
+      end
+    end
+  end
+  
+end

data/spec/acceptance/simple_arithmetic_spec.rb

@@ -0,0 +1,173 @@
+require 'spec_helper'
+
+describe 'simple arithmetic' do
+  
+  describe 'addition' do
+    describe '2 2 +' do
+      context 'on separate lines' do
+        it 'aggregates to 4.0' do    
+          start
+          type '2'
+          type '2'
+          type '+'
+          type 'q'
+      
+          assert_exact_output <<-OUTPUT.rpc
+            stack: 2.0
+            aggregate: 0
+
+            stack: 2.0, 2.0
+            aggregate: 0
+
+            calculated: 2.0 + 2.0
+            stack: 
+            aggregate: 4.0
+
+          OUTPUT
+        end
+      end
+    
+      context 'on one line' do
+        it 'aggregates to 4.0' do    
+          start
+          type '2 2 +'
+          type 'q'
+      
+          assert_exact_output <<-OUTPUT.rpc
+            calculated: 2.0 + 2.0
+            stack: 
+            aggregate: 4.0
+
+          OUTPUT
+        end
+      end
+    end
+  end
+  
+  describe 'subtraction' do
+    describe '4 2 -' do
+      context 'on seperate lines' do
+        it 'aggregates to 2.0' do    
+          start
+          type '4'
+          type '2'
+          type '-'
+          type 'q'
+      
+          assert_exact_output <<-OUTPUT.rpc
+            stack: 4.0
+            aggregate: 0
+
+            stack: 4.0, 2.0
+            aggregate: 0
+
+            calculated: 4.0 - 2.0
+            stack: 
+            aggregate: 2.0
+
+          OUTPUT
+        end
+      end
+    
+      context 'on one line' do
+        it 'aggregates to 2.0' do    
+          start
+          type '4 2 -'
+          type 'q'
+      
+          assert_exact_output <<-OUTPUT.rpc
+            calculated: 4.0 - 2.0
+            stack: 
+            aggregate: 2.0
+
+          OUTPUT
+        end
+      end
+    end
+  end
+  
+  describe 'multiplication' do
+    describe '3 2 *' do
+      context 'on seperate lines' do
+        it 'aggregates to 6.0' do    
+          start
+          type '3'
+          type '2'
+          type '*'
+          type 'q'
+      
+          assert_exact_output <<-OUTPUT.rpc
+            stack: 3.0
+            aggregate: 0
+
+            stack: 3.0, 2.0
+            aggregate: 0
+
+            calculated: 3.0 * 2.0
+            stack: 
+            aggregate: 6.0
+
+          OUTPUT
+        end
+      end
+    
+      context 'on one line' do
+        it 'aggregates to 6.0' do    
+          start
+          type '3 2 *'
+          type 'q'
+      
+          assert_exact_output <<-OUTPUT.rpc
+            calculated: 3.0 * 2.0
+            stack: 
+            aggregate: 6.0
+
+          OUTPUT
+        end
+      end
+    end
+  end
+  
+  describe 'division' do
+    describe '10 2 /' do
+      context 'on seperate lines' do
+        it 'aggregates to 5.0' do    
+          start
+          type '10'
+          type '2'
+          type '/'
+          type 'q'
+      
+          assert_exact_output <<-OUTPUT.rpc
+            stack: 10.0
+            aggregate: 0
+
+            stack: 10.0, 2.0
+            aggregate: 0
+
+            calculated: 10.0 / 2.0
+            stack: 
+            aggregate: 5.0
+
+          OUTPUT
+        end
+      end
+    
+      context 'on one line' do
+        it 'aggregates to 5.0' do    
+          start
+          type '10 2 /'
+          type 'q'
+      
+          assert_exact_output <<-OUTPUT.rpc
+            calculated: 10.0 / 2.0
+            stack: 
+            aggregate: 5.0
+
+          OUTPUT
+        end
+      end
+    end
+  end
+  
+end

data/spec/acceptance/simple_trigonometric_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+describe 'simple trigonometric' do
+  
+  describe 'acos' do
+    describe 'given -1' do
+      it 'returns 3.141592653589793' do    
+        start
+        type '-1'
+        type 'acos'
+        type 'q'
+    
+        assert_exact_output <<-OUTPUT.rpc
+          stack: -1.0
+          aggregate: 0
+
+          calculated: acos(-1.0)
+          stack: 
+          aggregate: 3.141592653589793
+
+        OUTPUT
+      end
+    end
+  end
+  
+  describe 'asin' do
+    describe 'given -1' do
+      it 'returns -1.5707963267948966' do    
+        start
+        type '-1'
+        type 'asin'
+        type 'q'
+    
+        assert_exact_output <<-OUTPUT.rpc
+          stack: -1.0
+          aggregate: 0
+
+          calculated: asin(-1.0)
+          stack: 
+          aggregate: -1.5707963267948966
+
+        OUTPUT
+      end
+    end
+  end
+  
+  describe 'cos' do
+    describe 'given 1' do
+      it 'returns 0.5403023058681398' do    
+        start
+        type '1'
+        type 'cos'
+        type 'q'
+    
+        assert_exact_output <<-OUTPUT.rpc
+          stack: 1.0
+          aggregate: 0
+
+          calculated: cos(1.0)
+          stack: 
+          aggregate: 0.5403023058681398
+
+        OUTPUT
+      end
+    end
+  end
+  
+  describe 'tan' do
+    describe 'given 1' do
+      it 'returns 1.557407724654902' do    
+        start
+        type '1'
+        type 'tan'
+        type 'q'
+    
+        assert_exact_output <<-OUTPUT.rpc
+          stack: 1.0
+          aggregate: 0
+
+          calculated: tan(1.0)
+          stack: 
+          aggregate: 1.557407724654902
+
+        OUTPUT
+      end
+    end
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+
+require 'reverse-polish-calculator'
+require 'aruba/api'
+
+Dir['./spec/support/*.rb'].map {|f| require f}
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.include Aruba::Api, :example_group => {
+    :file_path => /spec\/acceptance/
+  }
+  config.before(:suite, :example_group => {
+    :file_path => /spec\/unit/
+  }) { $in_unit_spec_suite = true }
+end

data/spec/support/aruba.rb

@@ -0,0 +1,4 @@
+def start
+  @aruba_io_wait_seconds = 0.5
+  run_interactive './../../bin/rpc'
+end

data/spec/support/string_ext.rb

@@ -0,0 +1,5 @@
+class String
+  def rpc
+    split("\n").map(&:lstrip).join("\n") << "\n\n"
+  end
+end

data/spec/unit/reverse-polish-calculator/errors_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+module ReversePolishCalculator
+  describe Errors do
+    
+    describe '.handle' do
+      context 'given a NoMethodError exception' do
+        let(:exception) { NoMethodError.new }
+        
+        it 'calls .no_method_error' do
+          described_class.should_receive(:no_method_error).with(exception)
+          described_class.handle(exception)
+        end
+      end
+    end
+    
+    describe '.no_method_error' do
+      context 'given a NoMethodError exception' do
+        let(:exception) { NoMethodError.new('message', 'name') }
+        
+        it 'removes the offending input from the stack' do
+          ReversePolishCalculator.stack.should_receive(:remove).with('name')
+          described_class.no_method_error(exception)
+        end
+      end
+    end
+    
+    describe '.math_domain_error' do
+      context 'given a Math::DomainError exception' do
+        let(:exception) { Math::DomainError.new('the "name"') }
+        
+        it 'removes the offending input from the stack' do
+          ReversePolishCalculator.stack.should_receive(:remove).with('name')
+          described_class.math_domain_error(exception)
+        end
+      end
+    end
+    
+  end
+end

data/spec/unit/reverse-polish-calculator/input_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+module ReversePolishCalculator
+  describe Input do
+        
+    describe '#exited?' do
+      let(:input) { described_class.allocate }
+      
+      context 'with input value of "q"' do
+        it 'returns true' do
+          input.instance_variable_set('@value', 'q')
+          input.should be_exited
+        end
+      end
+      
+      context 'with input value of "Q"' do
+        it 'returns true' do
+          input.instance_variable_set('@value', 'Q')
+          input.should be_exited
+        end
+      end
+      
+      context 'with input value of "foo"' do
+        it 'returns false' do
+          input.instance_variable_set('@value', 'foo')
+          input.should_not be_exited
+        end
+      end
+    end
+    
+    describe '#invoke' do
+      context 'with input value of "+"' do
+        let(:input) { described_class.new('+') }
+        
+        context 'given 2 inputs that have a value of "2"' do
+          let(:input_1) { described_class.new('2') }
+          let(:input_2) { described_class.new('2') }
+          
+          it 'returns 4.0' do
+            input.invoke(input_1, input_2).should eq(4.0)
+          end
+        end
+      end
+      
+      context 'with input value of "acos"' do
+        let(:input) { described_class.new('acos') }
+        
+        context 'given 1 input with a value of "-1"' do
+          let(:input_1) { described_class.new('-1') }
+          
+          it 'returns 3.141592653589793' do
+            input.invoke(input_1).should eq(3.141592653589793)
+          end
+        end
+      end
+    end
+    
+    describe '#math_method?' do
+      context 'with input value of "acos"' do
+        it 'returns true' do
+          described_class.new('acos').should be_math_method
+        end
+      end
+      
+      context 'with input value of "foo"' do
+        it 'returns false' do
+          described_class.new('foo').should_not be_math_method
+        end
+      end
+    end
+    
+    describe '#operand?' do
+      context 'with input value of "5"' do
+        it 'returns true' do
+          described_class.new('5').should be_operand
+        end
+      end
+      
+      context 'with input value of "foo"' do
+        it 'returns false' do
+          described_class.new('foo').should_not be_operand
+        end
+      end
+    end
+    
+    describe '#to_f' do
+      context 'with input value of "5"' do
+        it 'returns 5.0' do
+          described_class.new('5').to_f.should eq(5.0)
+        end
+      end
+    end
+    
+  end
+end

data/spec/unit/reverse-polish-calculator/inputs_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+module ReversePolishCalculator
+  describe Inputs do
+    let(:inputs) { [].extend(described_class) }
+    
+    describe '#calculate' do
+      context 'given inputs: 2 2 +' do
+        before { add_inputs('2 2 +') }
+        
+        it 'returns 4.0' do
+          inputs.calculate.should eq(4.0)
+        end
+      end
+      
+      context 'given inputs: 2 +' do
+        before { add_inputs('2 +') }
+        
+        it 'returns 2.0' do
+          inputs.calculate.should eq(2.0)
+        end
+      end
+      
+      context 'given inputs: 2 2 2 + +' do
+        before { add_inputs('2 2 2 + +') }
+        
+        it 'returns 6.0' do
+          inputs.calculate.should eq(6.0)
+        end
+      end
+      
+      context 'given inputs: 2 2 + +' do
+        before { add_inputs('2 2 + +') }
+        
+        it 'returns 4.0' do
+          inputs.calculate.should eq(4.0)
+        end
+      end
+      
+      context 'given inputs: -1 acos' do
+        before { add_inputs('-1 acos') }
+        
+        it 'returns 3.141592653589793' do
+          inputs.calculate.should eq(3.141592653589793)
+        end
+      end
+      
+      context 'given inputs: cos' do
+        before { add_inputs('cos') }
+        
+        context 'and an aggregate of 3.0' do
+          it 'returns 2.010007503399555' do
+            inputs.calculate(3.0).should eq(2.010007503399555)
+          end
+        end
+      end
+    end
+    
+    describe '#inspect' do
+      before { add_inputs('1 2') }
+      specify { inputs.inspect.should eq('1.0, 2.0') }
+    end
+    
+    def add_inputs(expression)
+      expression.split.each do |input|
+        inputs << Input.new(input)
+      end
+    end
+    
+  end
+end

data/spec/unit/reverse-polish-calculator/output_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+module ReversePolishCalculator
+  describe Output do
+    
+    describe '.add' do
+      context 'given "foo"' do
+        it 'adds "foo" to the list of texts' do
+          described_class.add('foo')
+          described_class.texts.should include('foo')
+        end
+      end
+    end
+    
+    describe '.texts' do
+      it 'returns an array' do
+        described_class.texts.should be_an_instance_of(Array)
+      end
+    end
+    
+    describe '.display' do
+      before { described_class.clear }
+      
+      it 'calls Helpers.multi_puts with the list of texts' do
+        described_class.add('foo')
+        Helpers.should_receive(:multi_puts).with('foo')
+        described_class.display
+      end
+    end
+    
+    describe '.clear' do
+      it 'clears out the list of texts' do
+        described_class.add('foo')
+        described_class.clear
+        described_class.texts.should be_empty
+      end
+    end
+    
+  end
+end

data/spec/unit/reverse-polish-calculator/stack_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+module ReversePolishCalculator
+  describe Stack do
+    
+    describe '#add' do
+      context 'given a single character' do
+        before { subject.add('5') }
+        
+        it 'adds one input' do
+          subject.should have(1).inputs
+        end
+      end
+      
+      context 'given 3 characters between spaces' do
+        before { subject.add('1 2 3') }
+        
+        it 'adds 3 inputs' do
+          subject.should have(3).inputs
+        end
+      end
+    end
+    
+    describe '#remove' do
+      context 'given an input value that exists in inputs' do
+        before { subject.add('foo') }
+        
+        it 'removes the input' do
+          expect do
+            subject.remove('foo')
+          end.to change(subject.inputs, :size).by(-1)
+        end
+      end
+    end
+    
+    describe '#calculate' do        
+      it 'aggregates' do
+        subject.inputs << Input.new('2')
+        subject.inputs << Input.new('2')
+        subject.inputs << Input.new('+')
+        
+        subject.calculate
+        subject.aggregate.should eq(4.0)
+        
+        subject.inputs << Input.new('2')
+        subject.inputs << Input.new('2')
+        subject.inputs << Input.new('+')
+        
+        subject.calculate
+        subject.aggregate.should eq(8.0)
+        
+        subject.inputs << Input.new('2')
+        subject.inputs << Input.new('-')
+        
+        subject.calculate
+        subject.aggregate.should eq(6.0)
+        
+        subject.inputs << Input.new('2')
+        subject.inputs << Input.new('*')
+        
+        subject.calculate
+        subject.aggregate.should eq(12.0)
+      end
+    end
+    
+    describe '#output' do
+      it 'calls .add on Output, twice' do
+        Output.should_receive(:add).twice
+        subject.output
+      end
+      
+      it 'calls .display on Output' do
+        Output.should_receive(:display)
+        subject.output
+      end
+      
+      it 'calls .clear on Output' do
+        Output.should_receive(:clear)
+        subject.output
+      end
+    end
+    
+    describe '#unswap' do
+      context 'with inputs.swapped set to true' do
+        before { subject.inputs.swapped = true }
+        
+        it 'sets inputs.swapped to false' do
+          expect { subject.unswap }.to change {
+            subject.inputs.swapped }.from(true).to(false)
+        end
+      end
+    end
+    
+  end
+end

data/spec/unit/reverse-polish-calculator_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe ReversePolishCalculator do
+  
+  describe '.start' do
+    it 'starts the loop' do
+      described_class.should_receive(:loop)
+      described_class.start
+    end
+  end
+  
+  describe '.stack' do
+    it 'returns an instance of Stack' do
+      described_class.stack.should be_an_instance_of(described_class::Stack)
+    end
+  end
+  
+end

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification 
+name: reverse-polish-calculator
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Justin Ko
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-06 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: aruba
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: Command line RPN (Reverse Polish Notation) calculator
+email: jko170@gmail.com
+executables: 
+- rpc
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rvmrc
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/rpc
+- lib/reverse-polish-calculator.rb
+- lib/reverse-polish-calculator/errors.rb
+- lib/reverse-polish-calculator/helpers.rb
+- lib/reverse-polish-calculator/input.rb
+- lib/reverse-polish-calculator/inputs.rb
+- lib/reverse-polish-calculator/output.rb
+- lib/reverse-polish-calculator/stack.rb
+- lib/reverse-polish-calculator/version.rb
+- reverse-polish-calculator.gemspec
+- spec/acceptance/complex_expressions_spec.rb
+- spec/acceptance/error_handling_spec.rb
+- spec/acceptance/simple_arithmetic_spec.rb
+- spec/acceptance/simple_trigonometric_spec.rb
+- spec/spec_helper.rb
+- spec/support/aruba.rb
+- spec/support/string_ext.rb
+- spec/unit/reverse-polish-calculator/errors_spec.rb
+- spec/unit/reverse-polish-calculator/input_spec.rb
+- spec/unit/reverse-polish-calculator/inputs_spec.rb
+- spec/unit/reverse-polish-calculator/output_spec.rb
+- spec/unit/reverse-polish-calculator/stack_spec.rb
+- spec/unit/reverse-polish-calculator_spec.rb
+has_rdoc: true
+homepage: https://github.com/justinko/reverse-polish-calculator
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Reverse Polish Calculator
+test_files: 
+- spec/acceptance/complex_expressions_spec.rb
+- spec/acceptance/error_handling_spec.rb
+- spec/acceptance/simple_arithmetic_spec.rb
+- spec/acceptance/simple_trigonometric_spec.rb
+- spec/spec_helper.rb
+- spec/support/aruba.rb
+- spec/support/string_ext.rb
+- spec/unit/reverse-polish-calculator/errors_spec.rb
+- spec/unit/reverse-polish-calculator/input_spec.rb
+- spec/unit/reverse-polish-calculator/inputs_spec.rb
+- spec/unit/reverse-polish-calculator/output_spec.rb
+- spec/unit/reverse-polish-calculator/stack_spec.rb
+- spec/unit/reverse-polish-calculator_spec.rb