basic101 0.2.0 → 1.0.1

data/test/spec/basic_numeric_spec.rb

@@ -1,16 +0,0 @@
-require_relative 'spec_helper'
-
-module Basic101
-
-  describe BasicNumeric do
-
-    describe 'type_name' do
-      let(:type_name) {'numeric'}
-      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
-
-  end
-
-end

data/test/spec/basic_object_spec.rb

@@ -1,22 +0,0 @@
-require_relative 'spec_helper'
-
-module Basic101
-
-  describe BasicObject do
-
-    describe 'type_name' do
-      let(:type_name) {'object'}
-      specify {expect(subject.class.type_name).to eq type_name}
-      specify {expect(subject.type_name).to eq type_name}
-    end
-
-    describe '#eval' do
-      let(:runtime) {double Runtime}
-      it 'should return itself' do
-        expect(subject.eval(runtime)).to eq subject
-      end
-    end
-
-  end
-
-end

data/test/spec/basic_string_spec.rb

@@ -1,259 +0,0 @@
-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
-          expect(output).to receive(:print).with('123')
-          subject.print_string(output)
-        end
-      end
-
-      describe '#print_new_line' do
-        specify do
-          expect(output).to receive(:print).with("\n")
-          subject.print_new_line(output)
-        end
-      end
-
-    end
-
-  end
-
-end

data/test/spec/for_stack_spec.rb

@@ -1,70 +0,0 @@
-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

@@ -1,143 +0,0 @@
-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
-          expect(input_reader.read_string).to eq 'abc'
-        end
-      end
-
-      context 'with comma' do
-        let(:line) {%Q'"abc,def",123'}
-        specify do
-          expect(input_reader.read_string).to eq 'abc,def'
-        end
-      end
-
-      context 'with quote' do
-        let(:line) {%Q'"abc""def",123'}
-        specify do
-          expect(input_reader.read_string).to eq 'abc"def'
-        end
-      end
-
-      context 'when blank' do
-        let(:line) {",abc"}
-        specify do
-          expect(input_reader.read_string).to eq ''
-        end
-      end
-
-      context 'when end of line' do
-        let(:line) {""}
-        specify do
-          expect(input_reader.read_string).to 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
-          expect(input_reader.read_numeric).to eq 123
-        end
-      end
-
-      context 'when positive integer' do
-        let(:line) {"+123,abc"}
-        specify do
-          expect(input_reader.read_numeric).to eq 123
-        end
-      end
-
-      context 'when negative integer' do
-        let(:line) {"-123,abc"}
-        specify do
-          expect(input_reader.read_numeric).to eq -123
-        end
-      end
-
-      context 'when float' do
-        let(:line) {"1.2,abc"}
-        specify do
-          expect(input_reader.read_numeric).to be_within(0.000001).of(1.2)
-        end
-      end
-
-      context 'when positive float' do
-        let(:line) {"+1.2,abc"}
-        specify do
-          expect(input_reader.read_numeric).to be_within(0.000001).of(1.2)
-        end
-      end
-
-      context 'when negative float' do
-        let(:line) {"-1.2,abc"}
-        specify do
-          expect(input_reader.read_numeric).to 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

@@ -1,102 +0,0 @@
-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) {allow(file).to receive(:isatty).and_return(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
-            expect(output).to 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
-            expect(output).to 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
-            expect(output).to 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
-            expect(output).to_not receive(:print)
-            input.read_line
-          end
-        end
-
-      end
-
-    end
-
-  end
-
-end

data/test/spec/line_spec.rb

@@ -1,18 +0,0 @@
-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