basic101 0.2.0 → 1.0.1

data/test/integration/tests/fast/subtract.output

@@ -1,5 +0,0 @@
--1 
--1 
--1 
--1.1 
- 1 

data/test/integration/tests/fast/tab.bas

@@ -1,4 +0,0 @@
-10 PRINT TAB(10); "A"; TAB(20); "B"
-20 PRINT TAB(20);
-30 PRINT "C"; TAB(10); "D"
-50 PRINT TAB(0); "X"

data/test/integration/tests/fast/tab.output

@@ -1,3 +0,0 @@
-          A         B
-                    CD
-X

data/test/integration/tests/fast/tan.bas

@@ -1 +0,0 @@
-10 PRINT TAN(3.14159265 / 8)

data/test/integration/tests/fast/tan.output

@@ -1 +0,0 @@
- 0.4142136 

data/test/integration/tests/fast/val.bas

@@ -1,3 +0,0 @@
-10 PRINT VAL("123")
-20 PRINT VAL("123.45")
-30 PRINT VAL("  -1  ")

data/test/integration/tests/fast/val.output

@@ -1,3 +0,0 @@
- 123 
- 123.45 
--1 

data/test/spec/argument_checker_spec.rb

@@ -1,128 +0,0 @@
-require_relative 'spec_helper'
-
-module Basic101
-
-  describe ArgumentChecker do
-
-    subject {described_class.new(args, required_types, optional_types)}
-
-    context 'when takes [string]' do
-
-      let(:required_types) {[BasicString]}
-      let(:optional_types) {[]}
-
-      context 'when given [string]' do
-        let(:args) {[BasicString.new('')]}
-        specify do
-          expect{subject.check}.to_not raise_error
-        end
-      end
-
-      context 'when given []' do
-        let(:args) {[]}
-        specify do
-         expect do
-            subject.check
-         end.to raise_error InvalidArgumentError,
-          'Wrong number of arguments (0 instead of 1)'
-        end
-      end
-
-      context 'when given [string, string]' do
-        let(:args) {[BasicString.new(''), BasicString.new('')]}
-        specify do
-         expect do
-            subject.check
-         end.to raise_error InvalidArgumentError,
-          'Wrong number of arguments (2 instead of 1)'
-        end
-      end
-
-      context 'when given [integer]' do
-        let(:args) {[BasicInteger.new('')]}
-        specify do
-          expect do
-            subject.check
-          end.to raise_error InvalidArgumentError,
-          'Expected string but got integer'
-        end
-      end
-
-    end
-
-    context 'when takes [integer, integer?]' do
-
-      let(:required_types) {[BasicInteger]}
-      let(:optional_types) {[BasicInteger]}
-
-      context 'when given [integer]' do
-        let(:args) {[BasicInteger.new(0)]}
-        specify do
-         expect do
-            subject.check
-         end.to_not raise_error
-        end
-      end
-
-      context 'when given [integer, integer]' do
-        let(:args) {[BasicInteger.new(0), BasicInteger.new(0)]}
-        specify do
-          expect{subject.check}.to_not raise_error
-        end
-      end
-
-      context 'when given []' do
-        let(:args) {[]}
-        specify do
-         expect do
-            subject.check
-         end.to raise_error InvalidArgumentError,
-          'Wrong number of arguments (0 instead of 1..2)'
-        end
-      end
-
-      context 'when given [integer, integer, integer]' do
-        let(:args) {3.times.map {BasicInteger.new(0)}}
-        specify do
-         expect do
-            subject.check
-         end.to raise_error InvalidArgumentError,
-          'Wrong number of arguments (3 instead of 1..2)'
-        end
-      end
-
-      context 'when given [integer]' do
-        let(:args) {[BasicString.new('')]}
-        specify do
-          expect do
-            subject.check
-          end.to raise_error InvalidArgumentError,
-          'Expected integer but got string'
-        end
-      end
-
-      context 'when given [integer, string]' do
-        let(:args) {[BasicString.new('')]}
-        specify do
-          expect do
-            subject.check
-          end.to raise_error InvalidArgumentError,
-          'Expected integer but got string'
-        end
-      end
-
-      context 'when given [string, string]' do
-        let(:args) {[BasicString.new('')]}
-        specify do
-          expect do
-            subject.check
-          end.to raise_error InvalidArgumentError,
-          'Expected integer but got string'
-        end
-      end
-
-    end
-
-  end
-
-end

data/test/spec/basic_array_spec.rb

@@ -1,100 +0,0 @@
-require_relative 'spec_helper'
-
-module Basic101
-
-  describe BasicArray do
-
-    let(:default) {BasicInteger.new(0)}
-    subject {BasicArray.new(num_dimensions, default)}
-
-    describe 'default dimensions' do
-
-      context 'when 1 dimension' do
-        let(:num_dimensions) {1}
-        it 'should set each element to the default' do
-          expect(subject.get([0])).to eq default
-          expect(subject.get([10])).to eq default
-        end
-      end
-
-      context 'when 2 dimensions' do
-        let(:num_dimensions) {2}
-        it 'should set each element to the default' do
-          expect(subject.get([0, 0])).to eq default
-          expect(subject.get([0, 10])).to eq default
-          expect(subject.get([10, 0])).to eq default
-          expect(subject.get([10, 10])).to eq default
-        end
-      end
-
-    end
-
-    describe '#dimension' do
-
-      context 'when normal' do
-        let(:num_dimensions) {2}
-        before(:each) {subject.dimension([2, 3])} 
-        it 'should set each element to the default' do
-          expect(subject.get([0, 0])).to eq default
-          expect(subject.get([0, 3])).to eq default
-          expect(subject.get([2, 0])).to eq default
-          expect(subject.get([2, 3])).to eq default
-        end
-      end
-
-      context 'max index 0' do
-        let(:num_dimensions) {1}
-        before(:each) {subject.dimension([0])} 
-        specify do
-          expect(subject.get([0])).to eq default
-        end
-      end
-
-      context 'negative max index' do
-        let(:num_dimensions) {1}
-        specify do
-          expect{subject.dimension([-1])}.to raise_error ArraySizeError
-        end
-      end
-
-    end
-
-    describe '#set' do
-      let(:num_dimensions) {2}
-      before(:each) do
-        subject.dimension([1, 1])
-        subject.set([0, 0], BasicInteger.new(1))
-        subject.set([0, 1], BasicInteger.new(2))
-        subject.set([1, 0], BasicInteger.new(3))
-        subject.set([1, 1], BasicInteger.new(4))
-      end
-      specify {expect(subject.get([0, 0])).to eq BasicInteger.new(1)}
-      specify {expect(subject.get([0, 1])).to eq BasicInteger.new(2)}
-      specify {expect(subject.get([1, 0])).to eq BasicInteger.new(3)}
-      specify {expect(subject.get([1, 1])).to eq BasicInteger.new(4)}
-    end
-
-    describe 'bounds checking' do
-
-      let(:num_dimensions) {2}
-
-      it 'should reject negative indices' do
-        expect{subject.get([0, -1])}.to raise_error IndexError
-      end
-
-      it 'should reject too few indices' do
-        expect{subject.get([0])}.to raise_error IndexError
-      end
-
-      it 'should reject too many indices' do
-        expect{subject.get([0, 0, 0])}.to raise_error IndexError
-      end
-
-      it 'should reject too large an index' do
-        expect{subject.get([0, 11])}.to raise_error IndexError
-      end
-    end
-
-  end
-
-end

data/test/spec/basic_float_spec.rb

@@ -1,168 +0,0 @@
-require_relative 'spec_helper'
-
-module Basic101
-
-  describe BasicFloat do
-
-    it_should_behave_like 'a basic numeric'
-
-    describe '#simplest' do
-
-      context 'when no fractional part' do
-        it 'should return a basic integer' do
-          a = described_class.new(12.0)
-          b = a.simplest
-          expect(b).to eq BasicInteger.new(12)
-        end
-      end
-
-      context 'when fractional part' do
-        it 'should return itself' do
-          a = described_class.new(12.34)
-          b = a.simplest
-          expect(b).to eq a
-        end
-      end
-
-    end
-
-    describe 'type_name' do
-      let(:type_name) {'float'}
-      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 '.from_s' do
-
-      context 'when fixed-point' do
-        specify do
-          a = '1.2'
-          b = described_class.from_s(a)
-          expect(b.value).to eq 1.2
-        end
-      end
-
-      context 'when exponential' do
-        specify do
-          a = '-1.2E-2'
-          b = described_class.from_s(a)
-          expect(b.value).to eq -1.2E-2
-        end
-      end
-
-      context 'when no leading digits' do
-        specify do
-          a = '.2'
-          b = described_class.from_s(a)
-          expect(b.value).to eq 0.2
-        end
-      end
-
-      context 'when no trailing digits' do
-        specify do
-          a = '2.'
-          b = described_class.from_s(a)
-          expect(b.value).to eq 2.0
-        end
-      end
-
-    end
-
-    describe '#to_integer' do
-      specify do
-        a = described_class.new(2.6)
-        expect(a.to_integer).to eq BasicInteger.new(2)
-      end
-    end
-
-    describe '#to_float' do
-      specify do
-        a = described_class.new(2.6)
-        expect(a.to_float).to eq a
-      end
-    end
-
-    describe '#to_string' do
-      specify do
-        a = described_class.new(2.6)
-        expect{a.to_string}.to raise_error TypeError
-      end
-    end
-
-    describe '#and' do
-      specify do
-        a = described_class.new(0b1100)
-        b = BasicInteger.new(0b0110)
-        c = a.and(b)
-        expect(c).to eq BasicInteger.new(0b0100)
-      end
-    end
-
-    describe '#or' do
-      specify do
-        a = described_class.new(0b1100)
-        b = BasicInteger.new(0b0110)
-        c = a.or(b)
-        expect(c).to eq BasicInteger.new(0b1110)
-      end
-    end
-
-    describe '#not' do
-      specify do
-        a = described_class.new(10)
-        b = a.not
-          expect(b).to eq BasicInteger.new(-11)
-      end
-    end
-
-    describe '#floor' do
-      specify do
-        a = described_class.new(-1.5)
-        b = a.floor
-        expect(b).to eq BasicInteger.new(-2.0)
-      end
-    end
-
-    describe '#abs' do
-
-      it 'should turn negative into positive' do
-        a = described_class.new(-1.5)
-        b = a.abs
-        expect(b).to eq described_class.new(1.5)
-      end
-
-      it 'should leave positive alone' do
-        a = described_class.new(1.5)
-        b = a.abs
-        expect(b).to eq described_class.new(1.5)
-      end
-
-    end
-
-    describe '#sqr' do
-      specify do
-        a = described_class.new(2)
-        b = a.sqr
-        expect(b).to eq described_class.new(2 ** 0.5)
-      end
-    end
-
-    describe '#exp' do
-      specify do
-        a = described_class.new(1.5)
-        b = a.exp
-        expect(b).to eq described_class.new(Math::E ** 1.5)
-      end
-    end
- 
-   describe '#str' do
-      specify do
-        a = described_class.new(-12.34)
-        expect(a.str).to eq BasicString.new('-12.34')
-      end
-    end
-
-  end
-
-end

data/test/spec/basic_integer_spec.rb

@@ -1,270 +0,0 @@
-require_relative 'spec_helper'
-
-module Basic101
-
-  describe BasicInteger do
-
-    it_should_behave_like 'a basic numeric'
-
-    describe '#simplest' do
-      it 'should return itself' do
-        a = BasicInteger.new(1)
-        b = a.simplest
-        expect(b).to eq a
-      end
-    end
-
-    describe '.from_bool' do
-
-      it 'should convert true to basic -1' do
-        a = BasicInteger.from_bool(true)
-        expect(a).to eq BasicInteger.new(-1)
-      end
-
-      it 'should convert false to basic 0' do
-        a = BasicInteger.from_bool(false)
-        expect(a).to eq BasicInteger.new(0)
-      end
-
-    end
-
-    describe 'type_name' do
-      let(:type_name) {'integer'}
-      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 '#str' do
-      specify do
-        a = BasicInteger.new(-12)
-        expect(a.str).to eq BasicString.new('-12')
-      end
-    end
-
-    describe '#to_integer' do
-      specify do
-        a = BasicInteger.new(1)
-        expect(a.to_integer).to eq a
-      end
-    end
-
-    describe '#to_float' do
-      specify do
-        a = BasicInteger.new(1)
-        expect(a.to_float).to eq BasicFloat.new(1)
-      end
-    end
-
-    describe '#to_string' do
-      specify do
-        a = BasicInteger.new(1)
-        expect {a.to_string}.to raise_error TypeError
-      end
-    end
-
-    describe '#and' do
-
-      context 'when 0, 0' do
-        specify do
-          a = BasicInteger.new(0)
-          b = BasicInteger.new(0)
-          c = a.and(b)
-          expect(c).to eq BasicInteger.new(0)
-        end
-      end
-
-      context 'when 0, -1' do
-        specify do
-          a = BasicInteger.new(0)
-          b = BasicInteger.new(-1)
-          c = a.and(b)
-          expect(c).to eq BasicInteger.new(0)
-        end
-      end
-
-      context 'when -1, 0' do
-        specify do
-          a = BasicInteger.new(-1)
-          b = BasicInteger.new(0)
-          c = a.and(b)
-          expect(c).to eq BasicInteger.new(0)
-        end
-      end
-
-      context 'when -1, -1' do
-        specify do
-          a = BasicInteger.new(-1)
-          b = BasicInteger.new(-1)
-          c = a.and(b)
-          expect(c).to eq BasicInteger.new(-1)
-        end
-      end
-
-      context 'when bitwise' do
-        specify do
-          a = BasicInteger.new(0b1100)
-          b = BasicInteger.new(0b0110)
-          c = a.and(b)
-          expect(c).to eq BasicInteger.new(0b0100)
-        end
-      end
-
-      context 'when float' do
-        specify do
-          a = BasicFloat.new(0b11)
-          b = BasicFloat.new(-1.5)
-          c = a.and(b)
-          expect(c).to eq BasicInteger.new(0b11)
-        end
-      end
-
-    end
-
-    describe '#or' do
-
-      context 'when 0, 0' do
-        specify do
-          a = BasicInteger.new(0)
-          b = BasicInteger.new(0)
-          c = a.or(b)
-          expect(c).to eq BasicInteger.new(0)
-        end
-      end
-
-      context 'when 0, -1' do
-        specify do
-          a = BasicInteger.new(0)
-          b = BasicInteger.new(-1)
-          c = a.or(b)
-          expect(c).to eq BasicInteger.new(-1)
-        end
-      end
-
-      context 'when -1, 0' do
-        specify do
-          a = BasicInteger.new(-1)
-          b = BasicInteger.new(0)
-          c = a.or(b)
-          expect(c).to eq BasicInteger.new(-1)
-        end
-      end
-
-      context 'when -1, -1' do
-        specify do
-          a = BasicInteger.new(-1)
-          b = BasicInteger.new(-1)
-          c = a.or(b)
-          expect(c).to eq BasicInteger.new(-1)
-        end
-      end
-
-      context 'when bitwise' do
-        specify do
-          a = BasicInteger.new(0b1100)
-          b = BasicInteger.new(0b0110)
-          c = a.or(b)
-          expect(c).to eq BasicInteger.new(0b1110)
-        end
-      end
-
-      context 'when float' do
-        specify do
-          a = BasicFloat.new(1)
-          b = BasicFloat.new(-2.2)
-          c = a.or(b)
-          expect(c).to eq BasicInteger.new(-1)
-        end
-      end
-
-    end
-
-    describe '#not' do
-
-      context 'when 0' do
-        specify do
-          a = BasicInteger.new(0)
-          b = a.not
-          expect(b).to eq BasicInteger.new(-1)
-        end
-      end
-
-      context 'when -1' do
-        specify do
-          a = BasicInteger.new(-1)
-          b = a.not
-          expect(b).to eq BasicInteger.new(0)
-        end
-      end
-
-      context 'when bitwise' do
-        specify do
-          a = BasicInteger.new(123)
-          b = a.not
-            expect(b).to eq BasicInteger.new(-124)
-        end
-      end
-
-    end
-
-    describe '#chr' do
-
-      context 'normal' do
-        specify do
-          a = BasicInteger.new(65)
-          b = a.chr
-          expect(b).to eq BasicString.new("A")
-        end
-      end
-
-      context 'value too small' do
-        specify do
-          a = BasicInteger.new(-1)
-          expect {a.chr}.to raise_error InvalidArgumentError
-        end
-      end
-
-      context 'value too large' do
-        specify do
-          a = BasicInteger.new(256)
-          expect {a.chr}.to raise_error InvalidArgumentError
-        end
-      end
-
-    end
-
-    describe '#abs' do
-
-      it 'should turn negative into positive' do
-        a = BasicInteger.new(-1)
-        b = a.abs
-        expect(b).to eq BasicInteger.new(1)
-      end
-
-      it 'should leave positive alone' do
-        a = BasicInteger.new(1)
-        b = a.abs
-        expect(b).to eq BasicInteger.new(1)
-      end
-
-    end
-
-    describe '#sqr' do
-      specify do
-        a = BasicInteger.new(4)
-        b = a.sqr
-        expect(b).to eq BasicInteger.new(2)
-      end
-    end
-
-    describe '#exp' do
-      specify do
-        a = BasicInteger.new(4)
-        b = a.exp
-        expect(b).to eq BasicFloat.new(Math::E ** 4)
-      end
-    end
-
-  end
-
-end