basic101 0.1.0

data/test/spec/basic_string_spec.rb

@@ -0,0 +1,259 @@
+require_relative 'spec_helper'
+
+module Basic101
+
+  describe BasicString do
+
+    it_behaves_like 'a basic object' do
+      let(:default_value) {''}
+    end
+
+    describe 'type_name' do
+      let(:type_name) {'string'}
+      subject {described_class.new(0)}
+      specify {expect(subject.class.type_name).to eq type_name}
+      specify {expect(subject.type_name).to eq type_name}
+    end
+
+    describe '#left' do
+
+      context 'when extracting substring' do
+        specify do
+          s = described_class.new('abcd')
+          expect(s.left(2)).to eq described_class.new('ab')
+        end
+      end
+
+      context 'when extracting null string' do
+        specify do
+          s = described_class.new('abcd')
+          expect(s.left(0)).to eq described_class.new('')
+        end
+      end
+
+      context 'when extracting entire string' do
+        specify do
+          s = described_class.new('abcd')
+          expect(s.left(10)).to eq described_class.new('abcd')
+        end
+      end
+
+      context 'when negative' do
+        specify do
+          s = described_class.new('abcd')
+          expect do
+            s.left(-1)
+          end.to raise_error InvalidArgumentError
+        end
+      end
+
+    end
+
+    describe '#length' do
+      specify do
+        s = described_class.new('abc')
+        expect(s.length).to eq BasicInteger.new(3)
+      end
+    end
+
+    describe '#mid' do
+
+      context 'when substring' do
+        specify do
+          s = described_class.new('abc')
+          expect(s.mid(2)).to eq described_class.new('bc')
+        end
+      end
+
+      context 'when short count' do
+        specify do
+          s = described_class.new('abc')
+          expect(s.mid(2, 1)).to eq described_class.new('b')
+        end
+      end
+
+      context 'when long count' do
+        specify do
+          s = described_class.new('abc')
+          expect(s.mid(2, 100)).to eq described_class.new('bc')
+        end
+      end
+
+      context 'when start past end of string' do
+        specify do
+          s = described_class.new('abc')
+          expect(s.mid(100)).to eq described_class.new('')
+        end
+      end
+
+      context 'when zero start' do
+        specify do
+          s = described_class.new('abc')
+          expect do
+            s.mid(0)
+          end.to raise_error InvalidArgumentError
+        end
+      end
+
+      context 'when zero count' do
+        specify do
+          s = described_class.new('abc')
+          expect do
+            s.mid(1, 0)
+          end.to raise_error InvalidArgumentError
+        end
+      end
+
+    end
+
+    describe '#+' do
+
+      it 'should concatenate a string' do
+        a = described_class.new('abc')
+        b = described_class.new('123')
+        c = a + b
+        expect(c).to eq described_class.new('abc123')
+      end
+
+      it 'should not concatenate an integer' do
+        a = described_class.new('abc')
+        b = BasicInteger.new(1)
+        expect {a + b}.to raise_error TypeError
+      end
+
+    end
+
+    describe '#right' do
+
+      context 'when entire string' do
+        specify do
+          a = described_class.new('abc')
+          b = a.right(10)
+          expect(b).to eq described_class.new('abc')
+        end
+      end
+
+      context 'when substring' do
+        specify do
+          a = described_class.new('abc')
+          b = a.right(2)
+          expect(b).to eq described_class.new('bc')
+        end
+      end
+
+      context 'when zero count' do
+        specify do
+          a = described_class.new('abc')
+          b = a.right(0)
+          expect(b).to eq described_class.new('')
+        end
+      end
+
+      context 'when negative count' do
+        specify do
+          a = described_class.new('abc')
+          expect { a.right(-1) }.to raise_error InvalidArgumentError
+        end
+      end
+
+    end
+
+    describe '#asc' do
+
+      context 'when not empty' do
+        specify do
+          a = described_class.new('ABC')
+          expect(a.asc).to eq BasicInteger.new(65)
+        end
+      end
+
+      context 'when empty' do
+        specify do
+          a = described_class.new('')
+          expect {a.asc}.to raise_error InvalidArgumentError
+        end
+      end
+
+    end
+
+    describe '#val' do
+
+      it 'converts to a float' do
+        a = described_class.new('1.23')
+        expect(a.val).to eq BasicFloat.new(1.23)
+      end
+
+      it 'converts to an integer' do
+        a = described_class.new('-123')
+        expect(a.val).to eq BasicInteger.new(-123)
+      end
+
+      it 'ignores white space' do
+        a = described_class.new("\t\n 123\t\n ")
+        expect(a.val).to eq BasicInteger.new(123)
+      end
+
+    end
+
+    describe '#to_numeric' do
+      it 'should refuse' do
+        a = described_class.new('abc')
+        expect do
+          a.to_numeric
+        end.to raise_error TypeError,
+        'string cannot be converted to numeric'
+      end
+    end
+
+    describe '#to_integer' do
+      specify do
+        a = described_class.new(12)
+        expect {a.to_integer}.to raise_error TypeError
+      end
+    end
+
+    describe '#to_float' do
+      specify do
+        a = described_class.new(12.34)
+        expect {a.to_float}.to raise_error TypeError
+      end
+    end
+
+    describe '#to_string' do
+      specify do
+        a = described_class.new('abc')
+        expect(a.to_string).to eq a
+      end
+    end
+
+    describe '#str' do
+      it 'should return itself' do
+        a = described_class.new('abc')
+        expect(a.str).to eq a
+      end
+    end
+
+    describe 'printing' do
+
+      let(:output) {double Output}
+      subject {described_class.new('123')}
+
+      describe '#print_string' do
+        specify do
+          output.should_receive(:print).with('123')
+          subject.print_string(output)
+        end
+      end
+
+      describe '#print_new_line' do
+        specify do
+          output.should_receive(:print).with("\n")
+          subject.print_new_line(output)
+        end
+      end
+
+    end
+
+  end
+
+end

data/test/spec/for_stack_spec.rb

@@ -0,0 +1,70 @@
+require_relative 'spec_helper'
+
+module Basic101
+
+  describe ForStack do
+
+    it 'should be empty' do
+      expect(subject).to be_empty
+    end
+
+    it 'should not be empty' do
+      statement1 = double(ForStatement, :reference => 'I')
+      subject.push statement1
+      expect(subject).to_not be_empty
+    end
+
+    it 'should act as a FIFO stack' do
+      statement1 = double(ForStatement, :reference => 'I')
+      statement2 = double(ForStatement, :reference => 'J')
+      subject.push statement1
+      subject.push statement2
+      expect(subject.pop).to eq statement2
+      expect(subject.pop).to eq statement1
+      expect(subject).to be_empty
+    end
+
+    it 'should refuse to have the same reference duplicated' do
+      statement1 = double(ForStatement, :reference => 'I')
+      statement2 = double(ForStatement, :reference => 'I')
+      subject.push statement1
+      expect do
+        subject.push statement2
+      end.to raise_error DuplicateReferenceInForStack
+    end
+
+    it 'should peek at the top of the stack' do
+      statement1 = double(ForStatement, :reference => 'I')
+      statement2 = double(ForStatement, :reference => 'J')
+      subject.push statement1
+      subject.push statement2
+      expect(subject.top).to eq statement2
+      subject.pop
+      expect(subject.top).to eq statement1
+      subject.pop
+      expect(subject.top).to be_nil      
+    end
+
+    it 'should delete entries with a reference variable' do
+      statement1 = double(ForStatement, :reference => 'I')
+      statement2 = double(ForStatement, :reference => 'J')
+      subject.push statement1
+      subject.push statement2
+      subject.delete_reference('I')
+      expect(subject.pop).to eq statement2
+      expect(subject).to be_empty
+    end
+
+    it 'should locate the entry for a given reference variable' do
+      statement1 = double(ForStatement, :reference => 'I')
+      statement2 = double(ForStatement, :reference => 'J')
+      subject.push statement1
+      subject.push statement2
+      expect(subject['I']).to eq statement1
+      expect(subject['J']).to eq statement2
+      expect(subject['K']).to be_nil
+    end
+
+  end
+
+end

data/test/spec/input_reader_spec.rb

@@ -0,0 +1,143 @@
+require_relative 'spec_helper'
+
+module Basic101
+
+  describe InputReader do
+
+    let(:input) {double Input, :read_line => line}
+    subject(:input_reader) {described_class.new(input)}
+
+    context 'invalid csv' do
+      let(:line) {%Q'"abc'}
+      specify do
+        expect {
+          input_reader
+        }.to raise_error BadInputFormatError, "Invalid format"
+      end
+    end
+
+    describe '#read_string' do
+
+      context 'when unquoted' do
+        let(:line) {%Q'abc,123'}
+        specify do
+          input_reader.read_string.should eq 'abc'
+        end
+      end
+
+      context 'with comma' do
+        let(:line) {%Q'"abc,def",123'}
+        specify do
+          input_reader.read_string.should eq 'abc,def'
+        end
+      end
+
+      context 'with quote' do
+        let(:line) {%Q'"abc""def",123'}
+        specify do
+          input_reader.read_string.should eq 'abc"def'
+        end
+      end
+
+      context 'when blank' do
+        let(:line) {",abc"}
+        specify do
+          input_reader.read_string.should eq ''
+        end
+      end
+
+      context 'when end of line' do
+        let(:line) {""}
+        specify do
+          input_reader.read_string.should eq ''
+        end
+      end
+
+      context 'when past end of line' do
+        let(:line) {''}
+        specify do
+          input_reader.read_string
+          expect {
+            input_reader.read_string
+          }.to raise_error TooFewInputItemsError, "Too few items"
+        end
+      end
+
+    end
+
+    describe '#read_numeric' do
+
+      context 'when integer' do
+        let(:line) {"123,abc"}
+        specify do
+          input_reader.read_numeric.should eq 123
+        end
+      end
+
+      context 'when positive integer' do
+        let(:line) {"+123,abc"}
+        specify do
+          input_reader.read_numeric.should eq 123
+        end
+      end
+
+      context 'when negative integer' do
+        let(:line) {"-123,abc"}
+        specify do
+          input_reader.read_numeric.should eq -123
+        end
+      end
+
+      context 'when float' do
+        let(:line) {"1.2,abc"}
+        specify do
+          input_reader.read_numeric.should be_within(0.000001).of(1.2)
+        end
+      end
+
+      context 'when positive float' do
+        let(:line) {"+1.2,abc"}
+        specify do
+          input_reader.read_numeric.should be_within(0.000001).of(1.2)
+        end
+      end
+
+      context 'when negative float' do
+        let(:line) {"-1.2,abc"}
+        specify do
+          input_reader.read_numeric.should be_within(0.000001).of(-1.2)
+        end
+      end
+
+      context 'when not numeric' do
+        let(:line) {"abc"}
+        specify do
+          expect {
+            input_reader.read_numeric
+          }.to raise_error BadInputFormatError, 'Not numeric: "abc"'
+        end
+      end
+
+      context 'when blank' do
+        let(:line) {",123"}
+        specify do
+          expect {
+            input_reader.read_numeric
+          }.to raise_error BadInputFormatError, 'Not numeric: ""'
+        end
+      end
+
+      context 'whe end of line' do
+        let(:line) {""}
+        specify do
+          expect {
+            input_reader.read_numeric 
+          }.to raise_error TooFewInputItemsError, "Too few items"
+        end
+      end
+
+    end
+
+  end
+
+end

data/test/spec/input_spec.rb

@@ -0,0 +1,102 @@
+require_relative 'spec_helper'
+
+module Basic101
+
+  describe Input do
+
+    let(:output_isatty) {true}
+    let(:input_isatty) {true}
+    let(:file) {StringIO.new(input_string)}
+    let(:output) {double Output, :isatty => output_isatty}
+    subject(:input) {described_class.new(output, file)}
+    before(:each) {file.stub(:isatty => input_isatty)}
+
+    describe 'transcript' do
+
+      let(:input_string) {"abc\n"}
+      let(:input_file) {StringIO.new}
+      let(:output_file) {StringIO.new}
+      let(:transcript) {Transcript.new(input_file, output_file)}
+
+      it 'should echo to the transcript' do
+        input.transcript = transcript
+        input.read_line
+        expect(input_file.string).to eq input_string
+      end
+
+    end
+
+    describe '#read_line' do
+
+      describe 'output' do
+
+        context 'when normal' do
+          let(:input_string) {"abc\ndef\n"}
+          specify do
+            expect(input.read_line).to eq "abc"
+            expect(input.read_line).to eq "def"
+            expect {
+              input.read_line
+            }.to raise_error NoMoreInputError, "No more input"
+          end
+        end
+
+        context 'when no terminating new-line' do
+          let(:input_string) {"abc"}
+          specify do
+            expect(input.read_line).to eq "abc"
+            expect {
+              input.read_line
+            }.to raise_error NoMoreInputError, "No more input"
+          end
+        end
+
+      end
+
+      describe 'echo' do
+
+        let(:input_string) {"abc\n"}
+
+        context 'when input is not tty and output is not tty' do
+          let(:input_isatty) {false}
+          let(:output_isatty) {false}
+          specify do
+            output.should receive(:echo).with(input_string)
+            input.read_line
+          end
+        end
+
+        context 'when input is not tty and output is tty' do
+          let(:input_isatty) {false}
+          let(:output_isatty) {true}
+          specify do
+            output.should receive(:echo).with(input_string)
+            input.read_line
+          end
+        end
+
+        context 'when input is tty and output is not tty' do
+          let(:input_isatty) {true}
+          let(:output_isatty) {false}
+          specify do
+            output.should receive(:echo).with(input_string)
+            input.read_line
+          end
+        end
+
+        context 'when input is tty and output is tty' do
+          let(:input_isatty) {true}
+          let(:output_isatty) {true}
+          specify do
+            output.should_not receive(:print)
+            input.read_line
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/test/spec/line_spec.rb

@@ -0,0 +1,18 @@
+require_relative 'spec_helper'
+
+module Basic101
+
+  describe Line do
+
+    let(:line_number) {10}
+    let(:statement1) {RemarkStatement.new}
+    let(:statement2) {RemarkStatement.new}
+    let(:statements) {[statement1, statement2]}
+    subject!(:line) {Line.new(line_number, statements)}
+
+    its(:line_number) {should eq line_number}
+    its(:statements) {should eq statements}
+
+  end
+
+end