basic101 0.1.0

data/test/spec/program_spec.rb

@@ -0,0 +1,45 @@
+require_relative 'spec_helper'
+
+module Basic101
+
+  describe Program do
+
+    let(:statement1) {Statement.new}
+    let(:statement2) {Statement.new}
+    let(:statement3) {Statement.new}
+    let(:statements) {[statement1, statement2, statement3]}
+    let(:line1) {Line.new(10, [statement1])}
+    let(:line2) {Line.new(20, [statement2, statement3])}
+    let(:lines) {[line1, line2]}
+
+    subject(:program) {described_class.new(lines)}
+
+    describe '#lines' do
+      specify do
+        expect(program.statements).to eq statements
+      end
+    end
+
+    describe '#[]' do
+      specify do
+        expect(program[0]).to eq statement1
+        expect(program[1]).to eq statement2
+        expect(program[2]).to eq statement3
+        expect(program[3]).to be_nil
+      end
+    end
+
+    describe '#index_of_line' do
+      specify do
+        expect(program.index_of_line(10)).to eq 0
+        expect(program.index_of_line(20)).to eq 1
+        expect {
+          program.index_of_line(30)
+        }.to raise_error(UndefinedLineNumberError,
+                         "Undefined line number 30")
+      end
+    end
+
+  end
+
+end

data/test/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+# simplecov must come first
+require 'simplecov'
+SimpleCov.command_name 'RSpec'
+
+require_relative '../../lib/basic101'
+
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+end
+
+glob = File.expand_path('support/**/*.rb', __dir__)
+Dir[glob].sort.each do |path|
+  require path
+end

data/test/spec/support/basic_numeric_helpers.rb

@@ -0,0 +1,327 @@
+module BasicNumericHelpers
+
+  include Basic101
+
+  shared_examples 'a basic numeric' do
+
+    it_behaves_like 'a basic object' do
+      let(:default_value) {0}
+    end
+
+    describe '#to_numeric' do
+      it 'should return itself' do
+        a = described_class.new(1)
+        b = a.to_numeric
+        expect(b).to eq a
+      end
+    end
+
+    describe '#eval' do
+      it 'should return itself' do
+        runtime = double Runtime
+        a = described_class.new(1)
+        b = a.eval(runtime)
+        expect(b).to eq a
+      end
+    end
+
+    describe '+' do
+
+      it 'should add a BasicInteger' do
+        a = described_class.new(1)
+        b = BasicInteger.new(2)
+        c = a + b
+        expect(c).to be_a BasicInteger
+        expect(c.value).to eq 3
+      end
+
+      it 'should add a BasicFloat yielding a BasicInteger' do
+        a = described_class.new(1)
+        b = BasicFloat.new(2)
+        c = a + b
+        expect(c).to be_a BasicInteger
+        expect(c.value).to eq 3
+      end
+
+      it 'should add a BasicFloat yielding a BasicFloat' do
+        a = described_class.new(1)
+        b = BasicFloat.new(2.5)
+        c = a + b
+        expect(c).to be_a BasicFloat
+        expect(c.value).to eq 1 + 2.5
+      end
+
+    end
+
+    describe '-' do
+
+      it 'should subtract a BasicInteger' do
+        a = described_class.new(1)
+        b = BasicInteger.new(2)
+        c = a - b
+        expect(c).to be_a BasicInteger
+        expect(c.value).to eq -1
+      end
+
+      it 'should subtract a BasicFloat yielding a BasicInteger' do
+        a = described_class.new(1)
+        b = BasicFloat.new(2)
+        c = a - b
+        expect(c).to be_a BasicInteger
+        expect(c.value).to eq -1
+      end
+
+      it 'should subtract a BasicFloat yielding a BasicFloat' do
+        a = described_class.new(1)
+        b = BasicFloat.new(2.5)
+        c = a - b
+        expect(c).to be_a BasicFloat
+        expect(c.value).to eq 1 - 2.5
+      end
+
+    end
+
+    describe '*' do
+
+      it 'should multiply a BasicInteger' do
+        a = described_class.new(4)
+        b = BasicInteger.new(2)
+        c = a * b
+        expect(c).to be_a BasicInteger
+        expect(c.value).to eq 8
+      end
+
+      it 'should multiply a BasicFloat yielding a BasicInteger' do
+        a = described_class.new(4)
+        b = BasicFloat.new(2)
+        c = a * b
+        expect(c).to be_a BasicInteger
+        expect(c.value).to eq 8
+      end
+
+      it 'should multiply a BasicFloat yielding a BasicFloat' do
+        a = described_class.new(4)
+        b = BasicFloat.new(0.3)
+        c = a * b
+        expect(c).to be_a BasicFloat
+        expect(c.value).to eq 4 * 0.3
+      end
+
+    end
+
+    describe '/' do
+
+      it 'should divide a BasicInteger' do
+        a = described_class.new(4)
+        b = BasicInteger.new(2)
+        c = a / b
+        expect(c).to be_a BasicInteger
+        expect(c.value).to eq 2
+      end
+
+      it 'should divide a BasicFloat yielding a BasicInteger' do
+        a = described_class.new(4)
+        b = BasicFloat.new(2)
+        c = a / b
+        expect(c).to be_a BasicInteger
+        expect(c.value).to eq 2
+      end
+
+      it 'should divide a BasicFloat yielding a BasicFloat' do
+        a = described_class.new(5)
+        b = BasicFloat.new(2)
+        c = a / b
+        expect(c).to be_a BasicFloat
+        expect(c.value).to eq 5 / 2.0
+      end
+
+    end
+
+    describe 'sin' do
+      specify do
+        a = described_class.new(Math::PI / 8.0)
+        b = a.sin
+        expect(b).to be_a BasicFloat
+        expect(b.value).to be_within(0.001).of(0.3826)
+      end
+    end
+
+    describe 'cos' do
+      specify do
+        a = described_class.new(Math::PI / 8.0)
+        b = a.cos
+        expect(b).to be_a BasicFloat
+        expect(b.value).to be_within(0.001).of(0.9238)
+      end
+    end
+
+    describe 'tan' do
+      specify do
+        a = described_class.new(Math::PI / 8.0)
+        b = a.tan
+        expect(b).to be_a BasicFloat
+        expect(b.value).to be_within(0.001).of(0.4142)
+      end
+    end
+
+    shared_examples 'compares against type' do |type|
+
+      describe '#<=>' do
+
+        it "should be less than a #{type}" do
+          a = described_class.new(-1)
+          b = BasicInteger.new(0)
+          expect(a.<=>(b)).to eq -1
+        end
+
+        it "should be equal to a #{type}" do
+          a = described_class.new(0)
+          b = BasicInteger.new(0)
+          expect(a.<=>(b)).to eq 0
+        end
+
+        it "should be greater than a #{type}" do
+          a = described_class.new(1)
+          b = BasicInteger.new(0)
+          expect(a.<=>(b)).to eq +1
+        end
+
+      end
+
+      describe 'comparison methods' do
+
+        shared_examples 'compares using a method' do
+          |method, less_than_result, equal_to_result, greater_than_result|
+
+          describe "##{method}" do
+
+            context 'when <' do
+              specify do
+                a = described_class.new(-1)
+                b = type.new(0)
+                c = a.send(method, b)
+                expect(c).to eq BasicInteger.from_bool(less_than_result)
+              end
+            end
+
+            context 'when =' do
+              specify do
+                a = described_class.new(0)
+                b = type.new(0)
+                c = a.send(method, b)
+                expect(c).to eq BasicInteger.from_bool(equal_to_result)
+              end
+            end
+
+            context 'when >' do
+              specify do
+                a = described_class.new(1)
+                b = type.new(0)
+                c = a.send(method, b)
+                expect(c).to eq BasicInteger.from_bool(greater_than_result)
+              end
+            end
+
+          end
+          
+        end
+
+        it_behaves_like 'compares using a method', :gt, false, false, true
+        it_behaves_like 'compares using a method', :ge, false, true, true
+        it_behaves_like 'compares using a method', :eq, false, true, false
+        it_behaves_like 'compares using a method', :le, true, true, false
+        it_behaves_like 'compares using a method', :lt, true, false, false
+        it_behaves_like 'compares using a method', :ne, true, false, true
+
+      end
+
+    end
+
+    it_should_behave_like 'compares against type', BasicInteger
+    it_should_behave_like 'compares against type', BasicFloat
+
+    describe '#sgn' do
+
+      context 'when negative' do
+        specify do
+          a = described_class.new(-10)
+          b = a.sgn
+          expect(b).to eq BasicInteger.new(-1)
+        end
+      end
+
+      context 'when zero' do
+        specify do
+          a = described_class.new(00)
+          b = a.sgn
+          expect(b).to eq BasicInteger.new(0)
+        end
+      end
+
+      context 'when positive' do
+        specify do
+          a = described_class.new(+10)
+          b = a.sgn
+          expect(b).to eq BasicInteger.new(+1)
+        end
+      end
+
+    end
+
+    describe '#log' do
+      specify do
+        a = described_class.new(2)
+        b = a.log
+        expect(b).to eq BasicFloat.new(Math.log(2))
+      end
+    end
+
+    describe 'printing' do
+
+      let(:output) {double Output}
+      let(:value) {123}
+      subject {described_class.new(value)}
+
+      describe '#print_string' do
+
+        context 'when positive' do
+          specify do
+            output.should_receive(:print).with(' 123 ')
+            subject.print_string(output)
+          end
+        end
+
+        context 'when negative' do
+          let(:value) {-123}
+          specify do
+            output.should_receive(:print).with('-123 ')
+            subject.print_string(output)
+          end
+        end
+
+      end
+
+      describe '#print_new_line' do
+        specify do
+          output.should_receive(:print).with("\n")
+          subject.print_new_line(output)
+        end
+      end
+
+    end
+
+    describe '#to_numeric' do
+      it 'should return itself' do
+        a = described_class.new(123)
+        b = a.to_numeric
+        expect(b).to eq a
+      end
+    end
+
+  end
+
+end
+
+RSpec.configure do |config|
+  config.include BasicNumericHelpers
+end

data/test/spec/support/basic_object_helpers.rb

@@ -0,0 +1,22 @@
+module BasicObjectHelpers
+
+  include Basic101
+
+  shared_examples 'a basic object' do
+
+    describe '#val' do
+      it 'should return itself' do
+        runtime = double Runtime
+        a = described_class.new(default_value)
+        b = a.eval(runtime)
+        expect(b).to eq a
+      end
+    end
+
+  end
+
+end
+
+RSpec.configure do |config|
+  config.include BasicObjectHelpers
+end

data/test/spec/transcript_spec.rb

@@ -0,0 +1,37 @@
+require_relative 'spec_helper'
+
+module Basic101
+
+  describe Transcript do
+
+    let(:path) {'/tmp/foo.bas'}
+    let(:input_file) {StringIO.new}
+    let(:output_file) {StringIO.new}
+    subject {Transcript.new(input_file, output_file)}
+
+    context 'nothing written' do
+      specify do
+        expect(input_file.string).to eq ''
+        expect(output_file.string).to eq ''
+      end
+    end
+
+    context 'output written' do
+      specify do
+        subject.save_output 'abc'
+        expect(input_file.string).to eq ''
+        expect(output_file.string).to eq 'abc'
+      end
+    end
+
+    context 'input written' do
+      specify do
+        subject.save_input 'abc'
+        expect(input_file.string).to eq 'abc'
+        expect(output_file.string).to eq ''
+      end
+    end
+
+  end
+
+end