skeem 0.0.17 → 0.0.18

data/spec/skeem/primitive/primitive_builder_spec.rb

@@ -1,15 +1,256 @@
 require_relative '../../spec_helper' # Use the RSpec framework
 
 # Load the class under test
-require_relative '../../../lib/skeem/primitive/primitive_builder'
+require_relative '../../../lib/skeem/interpreter'
 
 module Skeem
-  describe Primitive::PrimitiveBuilder do
-    
-    context 'Initialization:' do
-      it 'should be initialized without argument' do
-        expect { Interpreter.new() }.not_to raise_error
-      end
-    end # context
-  end # describe
-end # module      
+  module Primitive
+    describe 'Testing primitive procedures' do
+        subject { Interpreter.new }
+        context 'Arithmetic operators:' do
+        it 'should implement the addition operator' do
+          [
+            ['(+)', 0], # '+' as nullary operator. Example from section 6.2.6
+            ['(+ -3)', -3], # '+' as unary operator
+            ['(+ 3 4)', 7], # '+' as binary operator. Example from section 4.1.3
+            ['(+ 2 2.34)', 4.34]
+          ].each do |(expr, predicted)|
+            result = subject.run(expr)
+            expect(result.value).to eq(predicted)
+          end
+        end
+
+        it 'should implement the minus operator' do
+          [
+            ['(- 3)', -3], # '-' as unary operator (= sign change)
+            ['(- 3 4)', -1], # '-' as binary operator. Example from section 6.2.6
+            ['(- 3 4 5)', -6] # '-' as variadic operator. Example from section 6.2.6
+          ].each do |(expr, predicted)|
+            result = subject.run(expr)
+            expect(result.value).to eq(predicted)
+          end
+        end
+
+        it 'should implement the product operator' do
+          [
+            ['(*)', 1], # '*' as nullary operator. Example from section 6.2.6
+            ['(* 4)', 4], # '*' as unary operator. Example from section 6.2.6
+            ['(* 5 8)', 40], # '*' as binary operator.
+            ['(* 2 3 4 5)', 120] # '*' as variadic operator.
+          ].each do |(expr, predicted)|
+            result = subject.run(expr)
+            expect(result.value).to eq(predicted)
+          end
+        end
+
+        it 'should implement the division operator' do
+          [
+            ['(/ 3)', 1.0/3], # '/' as unary operator (= inverse of argument)
+            ['(/ 3 4)', 3.0/4], # '/' as binary operator.
+            ['(/ 3 4 5)', 3.0/20] # '/' as variadic operator. Example from section 6.2.6
+          ].each do |(expr, predicted)|
+            result = subject.run(expr)
+            expect(result.value).to eq(predicted)
+          end
+        end
+
+        it 'should implement the floor-remainder (modulo) procedure' do
+          checks = [
+            ['(floor-remainder 16 4)', 0], # Binary procedure.
+            ['(floor-remainder 5 2)', 1],
+            ['(floor-remainder -45.0 7)', 4.0],
+            ['(floor-remainder 10.0 -3.0)', -2.0],
+            ['(floor-remainder -17 -9)', -8]
+          ]
+          checks.each do |(skeem_expr, expectation)|
+            result = subject.run(skeem_expr)
+            expect(result.value).to eq(expectation)
+          end
+        end
+      end # context
+
+      context 'Comparison operators' do
+        it 'should implement the equality operator' do
+          checks = [
+            ['(= 3)', true], # '=' as unary operator
+            ['(= 3 3)', true], # '=' as binary operator
+            ['(= 3 (+ 1 2) (- 4 1))', true], # '=' as variadic operator
+            ['(= "foo" "foo")', true],
+            ['(= 3 4)', false],
+            ['(= "foo" "bar")', false]
+          ]
+          checks.each do |(skeem_expr, expectation)|
+            result = subject.run(skeem_expr)
+            expect(result.value).to eq(expectation)
+          end
+        end
+
+        it 'should implement the less than operator' do
+          checks = [
+            ['(< 3)', false], # '<' as unary operator
+            ['(< 3 4)', true], # '<' as binary operator
+            ['(< 3 (+ 2 2) (+ 4 1))', true], # '<' as variadic operator
+            ['(< 3 3)', false],
+            ['(< 3 2)', false],
+            ['(< 3 4 5 4)', false]
+          ]
+          checks.each do |(skeem_expr, expectation)|
+            result = subject.run(skeem_expr)
+            expect(result.value).to eq(expectation)
+          end
+        end
+
+        it 'should implement the greater than operator' do
+          checks = [
+            ['(> 3)', false], # '>' as unary operator
+            ['(> 3 2)', true], # '>' as binary operator
+            ['(> 3 (- 4 2) (- 2 1))', true], # '>' as variadic operator
+            ['(> 3 3)', false],
+            ['(> 3 4)', false],
+            ['(> 3 2 1 2)', false]
+          ]
+          checks.each do |(skeem_expr, expectation)|
+            result = subject.run(skeem_expr)
+            expect(result.value).to eq(expectation)
+          end
+        end
+
+        it 'should implement the less or equal than operator' do
+          checks = [
+            ['(<= 3)', true], # '<=' as unary operator
+            ['(<= 3 4)', true], # '<=' as binary operator
+            ['(<= 3 (+ 2 2) (+ 4 1))', true], # '<=' as variadic operator
+            ['(<= 3 3)', true],
+            ['(<= 3 2)', false],
+            ['(<= 3 4 5 4)', false],
+            ['(<= 3 4 5 5)', true]
+          ]
+          checks.each do |(skeem_expr, expectation)|
+            result = subject.run(skeem_expr)
+            expect(result.value).to eq(expectation)
+          end
+        end
+
+        it 'should implement the greater or equal than operator' do
+          checks = [
+            ['(>= 3)', true], # '>=' as unary operator
+            ['(>= 3 2)', true],
+            ['(>= 3 (- 4 2) (- 2 1))', true],
+            ['(>= 3 3)', true],
+            ['(>= 3 4)', false],
+            ['(>= 3 2 1 2)', false],
+            ['(>= 3 2 1 1)', true]
+          ]
+          checks.each do |(skeem_expr, expectation)|
+            result = subject.run(skeem_expr)
+            expect(result.value).to eq(expectation)
+          end
+        end
+      end # context
+
+      context 'Number predicates:' do
+        it 'should implement the number? predicate' do
+          checks = [
+            ['(number? 3.1)', true],
+            ['(number? 3)', true],
+            ['(number? "3")', false],
+            ['(number? #t)', false]
+          ]
+          checks.each do |(skeem_expr, expectation)|
+            result = subject.run(skeem_expr)
+            expect(result.value).to eq(expectation)
+          end
+        end
+        
+        it 'should implement the real? predicate' do
+          checks = [
+            ['(real? 3.1)', true],
+            ['(real? 3)', true],
+            ['(real? "3")', false],
+            ['(real? #t)', false]
+          ]
+          checks.each do |(skeem_expr, expectation)|
+            result = subject.run(skeem_expr)
+            expect(result.value).to eq(expectation)
+          end
+        end
+
+        it 'should implement the integer? predicate' do
+          checks = [
+            ['(integer? 3.1)', false],
+            # ['(integer? 3.0)', true], TODO: should pass when exact? will be implemented
+            ['(integer? 3)', true],
+            ['(integer? "3")', false],
+            ['(integer? #t)', false]
+          ]
+          checks.each do |(skeem_expr, expectation)|
+            result = subject.run(skeem_expr)
+            expect(result.value).to eq(expectation)
+          end
+        end
+      end # context
+      
+      context 'Boolean procedures:' do
+        it 'should implement the not procedure' do
+          checks = [
+            ['(not #t)', false],
+            ['(not 3)', false],
+            ['(not #f)', true]
+          ]
+          checks.each do |(skeem_expr, expectation)|
+            result = subject.run(skeem_expr)
+            expect(result.value).to eq(expectation)
+          end
+        end
+        
+        it 'should implement the boolean? procedure' do
+          checks = [
+            ['(boolean? #f)', true],
+            ['(boolean? 0)', false]
+          ]
+          checks.each do |(skeem_expr, expectation)|
+            result = subject.run(skeem_expr)
+            expect(result.value).to eq(expectation)
+          end
+        end          
+      end # context
+      
+      context 'String procedures:' do
+        it 'should implement the string? procedure' do
+          checks = [
+            ['(string? #f)', false],
+            ['(string? 3)', false],
+            ['(string? "hi")', true]
+          ]
+          checks.each do |(skeem_expr, expectation)|
+            result = subject.run(skeem_expr)
+            expect(result.value).to eq(expectation)
+          end
+        end      
+      end # context
+      
+      context 'Symbol procedures:' do      
+        it 'should implement the symbol? procedure' do
+          checks = [
+            ['(symbol? #f)', false],
+            ['(symbol? "bar")', false]
+          ]
+          checks.each do |(skeem_expr, expectation)|
+            result = subject.run(skeem_expr)
+            expect(result.value).to eq(expectation)
+          end
+        end
+      end # context
+      
+      context 'IO procedures:' do          
+        it 'should implement the newline procedure' do
+          default_stdout = $stdout
+          $stdout = StringIO.new()
+          subject.run('(newline) (newline) (newline)')
+          expect($stdout.string).to match(/\n\n\n$/)
+          $stdout = default_stdout
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/skeem/primitive/primitive_procedure_spec.rb

@@ -0,0 +1,162 @@
+require_relative '../../spec_helper' # Use the RSpec framework
+
+# Load the class under test
+require_relative '../../../lib/skeem/primitive/primitive_procedure'
+
+module Skeem
+  module Primitive
+    describe PrimitiveProcedure do
+      def call_proc(aName, args)
+        ProcedureCall.new(nil, aName, args)
+      end
+
+      let(:nullary) { SkmArity.new(0, 0) }
+      let(:unary) { SkmArity.new(1, 1) }
+      let(:binary) { SkmArity.new(2, 2) }
+      let(:zero_or_more) {SkmArity.new(0, '*') }
+      let(:one_or_more) {SkmArity.new(1, '*') }
+      let(:newline_code) do
+        ->(_runtime) { "\n" }
+      end
+
+      let(:cube) do
+        ->(_runtime, operand) { operand.value * operand.value * operand.value }
+      end
+
+      let(:sum) do
+        ->(_runtime, operand1, operand2) { operand1.value + operand2.value }
+      end
+
+      let(:length) do
+        ->(_runtime, operands) { operands.length }
+      end
+
+      subject { PrimitiveProcedure.new('cube', unary, cube) }
+
+      before(:each) { @passing = false }
+
+      context 'Initialization:' do
+        it 'should be initialized with a name, arity and a lambda' do
+          expect { PrimitiveProcedure.new('newline', nullary, newline_code) }.not_to raise_error
+        end
+
+        it 'should know its name' do
+          expect(subject.identifier.value).to eq('cube')
+        end
+
+        it 'should know its arity' do
+          expect(subject.arity).to eq([1, 1])
+        end
+
+        it 'should know its lambda' do
+          expect(subject.code).to eq(cube)
+        end
+
+        it 'should complain if third argument is not a lambda' do
+          kode = Proc.new { puts '' }
+
+          err = StandardError
+          err_msg = "Primitive procedure 'newline' must be implemented with a Ruby lambda."
+          expect { PrimitiveProcedure.new('newline', nullary, kode) }.to raise_error(err, err_msg)
+        end
+
+        it 'should complain if third argument is a nullary lambda' do
+          kode = ->() { puts '' } # Missing slot for Runtime object
+
+          err = StandardError
+          err_msg = "Primitive procedure 'newline' lambda takes no parameter."
+          expect { PrimitiveProcedure.new('newline', nullary, kode) }.to raise_error(err, err_msg)
+        end
+
+        it 'should complain when arity and parameter count mismatch' do
+          err = StandardError
+          msg1 = "Discrepancy in primitive procedure 'cube' "
+
+          msg2 = "between arity (0) + 1 and parameter count of lambda 2."
+          expect { PrimitiveProcedure.new('cube', nullary, cube) }.to raise_error(err, msg1 + msg2)
+
+          msg2 = "between arity (2) + 1 and parameter count of lambda 2."
+          expect { PrimitiveProcedure.new('cube', binary, cube) }.to raise_error(err, msg1 + msg2)
+
+          # Nasty; this discrepancy isn't detected
+          expect { PrimitiveProcedure.new('cube', zero_or_more, cube) }.not_to raise_error
+
+          expect { PrimitiveProcedure.new('cube', unary, cube) }.not_to raise_error
+
+          msg2 = "between arity (1) + 2 and parameter count of lambda 2."
+          expect { PrimitiveProcedure.new('cube', one_or_more, cube) }.to raise_error(err, msg1 + msg2)
+        end
+      end # context
+
+      context 'Procedure invokation:' do
+        it 'should support Skeem nullary procedure' do
+          pproc = PrimitiveProcedure.new('newline', nullary, newline_code)
+          rtime = double('fake-runtime')
+
+          invokation = call_proc('newline', nil)
+          expect(pproc.call(rtime, invokation)).to eq("\n")
+
+          too_much = call_proc('newline', ['superfluous'])
+          err = StandardError
+          ms1 = 'Wrong number of arguments for #<Procedure newline>'
+          ms2 = ' (required at least 0, got 1)'
+          expect { pproc.call(rtime, too_much) }.to raise_error(err, ms1 + ms2)
+        end
+
+        it 'should support Skeem unary procedure' do
+          pproc = PrimitiveProcedure.new('cube', unary, cube)
+          rtime = double('fake-runtime')
+
+          invokation = call_proc('cube', [SkmInteger.create(3)])
+          expect(pproc.call(rtime, invokation)).to eq(27)
+
+          too_few = call_proc('cube', nil)
+          err = StandardError
+          ms1 = 'Wrong number of arguments for #<Procedure cube>'
+          ms2 = ' (required at least 1, got 0)'
+          expect { pproc.call(rtime, too_few) }.to raise_error(err, ms1 + ms2)
+
+          too_much = call_proc('newline', ['foo', 'bar'])
+          err = StandardError
+          ms1 = 'Wrong number of arguments for #<Procedure cube>'
+          ms2 = ' (required at least 1, got 2)'
+          expect { pproc.call(rtime, too_much) }.to raise_error(err, ms1 + ms2)
+        end
+
+        it 'should support Skeem binary procedure' do
+          pproc = PrimitiveProcedure.new('sum', binary, sum)
+          rtime = double('fake-runtime')
+
+          invokation = call_proc('sum', [SkmInteger.create(3), SkmInteger.create(5)])
+          expect(pproc.call(rtime, invokation)).to eq(8)
+
+          too_few = call_proc('sum', [SkmInteger.create(3)])
+          err = StandardError
+          ms1 = 'Wrong number of arguments for #<Procedure sum>'
+          ms2 = ' (required at least 2, got 1)'
+          expect { pproc.call(rtime, too_few) }.to raise_error(err, ms1 + ms2)
+
+          too_much = call_proc('cube', ['foo', 'bar', 'quux'])
+          err = StandardError
+          ms1 = 'Wrong number of arguments for #<Procedure sum>'
+          ms2 = ' (required at least 2, got 3)'
+          expect { pproc.call(rtime, too_much) }.to raise_error(err, ms1 + ms2)
+        end
+
+        it 'should support Skeem variadic procedure' do
+          pproc = PrimitiveProcedure.new('length', zero_or_more, length)
+          rtime = double('fake-runtime')
+
+          invokation = call_proc('length', [SkmInteger.create(3), SkmInteger.create(5)])
+          expect(pproc.call(rtime, invokation)).to eq(2)
+
+          no_arg = call_proc('sum', nil)
+          expect(pproc.call(rtime, no_arg)).to eq(0)
+
+          many = call_proc('cube', ['foo', 'bar', 'quux'])
+          expect( pproc.call(rtime, many)).to eq(3)
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/skeem/s_expr_nodes_spec.rb

@@ -231,6 +231,9 @@ describe SkmIdentifier do
 
       it 'should know its members' do
         expect(subject.members).to eq(sample_members)
+        
+        other = SkmList.new([])
+        expect(other.members).to be_empty
       end
     end # context
 

data/spec/skeem/tokenizer_spec.rb

@@ -151,6 +151,7 @@ module Skeem
         token = subject.tokens.first
         expect(token.terminal).to eq('STRING_LIT')
         expect(token.lexeme).to eq('Some text')
+        expect(token.position.line).to eq(2)
       end
 
       it 'should skip trailing comments' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: skeem
 version: !ruby/object:Gem::Version
-  version: 0.0.17
+  version: 0.0.18
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-06 00:00:00.000000000 Z
+date: 2018-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -91,7 +91,7 @@ files:
 - lib/skeem/interpreter.rb
 - lib/skeem/parser.rb
 - lib/skeem/primitive/primitive_builder.rb
-- lib/skeem/primitive_procedure.rb
+- lib/skeem/primitive/primitive_procedure.rb
 - lib/skeem/runtime.rb
 - lib/skeem/s_expr_builder.rb
 - lib/skeem/s_expr_nodes.rb
@@ -104,6 +104,7 @@ files:
 - spec/skeem/interpreter_spec.rb
 - spec/skeem/parser_spec.rb
 - spec/skeem/primitive/primitive_builder_spec.rb
+- spec/skeem/primitive/primitive_procedure_spec.rb
 - spec/skeem/runtime_spec.rb
 - spec/skeem/s_expr_nodes_spec.rb
 - spec/skeem/tokenizer_spec.rb
@@ -140,6 +141,7 @@ test_files:
 - spec/skeem/interpreter_spec.rb
 - spec/skeem/parser_spec.rb
 - spec/skeem/primitive/primitive_builder_spec.rb
+- spec/skeem/primitive/primitive_procedure_spec.rb
 - spec/skeem/runtime_spec.rb
 - spec/skeem/s_expr_nodes_spec.rb
 - spec/skeem/tokenizer_spec.rb