skeem 0.2.14 → 0.2.18

data/spec/skeem/primitive/primitive_builder_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../spec_helper' # Use the RSpec framework
 
 # Load the class under test
@@ -41,8 +43,8 @@ SKEEM
             ['(+)', 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
-            ['(+ 1/2 2/3)', Rational(7,6)],
-            ['(+ 1/2 3)', Rational(7,2)],
+            ['(+ 1/2 2/3)', Rational(7, 6)],
+            ['(+ 1/2 3)', Rational(7, 2)],
             ['(+ 2 2.34)', 4.34]
           ]
           compare_to_predicted(checks)
@@ -219,7 +221,7 @@ SKEEM
             ["(equal? (make-vector 5 'a) (make-vector 5 'a))", true],
             ['(equal? car car)', true],
             ['(equal? car cdr)', false],
-            ['(equal? (lambda (x) x) (lambda (y) y))', false],
+            ['(equal? (lambda (x) x) (lambda (y) y))', false]
           ]
           compare_to_predicted(checks) do |result, expectation|
             if result.length > 1
@@ -355,7 +357,7 @@ SKEEM
             ['(integer? "3")', false],
             ['(integer? #t)', false]
           ]
-         compare_to_predicted(checks)
+          compare_to_predicted(checks)
         end
 
         it 'should implement the number->string procedure' do
@@ -396,7 +398,7 @@ SKEEM
             ['(or)', false],
             ['(or #f)', false],
             ['(or #f #t)', true],
-            ['(or #f #f #f)', false],
+            ['(or #f #f #f)', false]
 
           ]
           compare_to_predicted(checks)
@@ -485,11 +487,11 @@ SKEEM
           compare_to_predicted(checks)
         end
 
-       it 'should implement the string-length procedure' do
+        it 'should implement the string-length procedure' do
           checks = [
             ['(string-length "abc")', 3],
             ['(string-length "")', 0],
-            ['(string-length "hi there")', 8],
+            ['(string-length "hi there")', 8]
           ]
           compare_to_predicted(checks)
         end
@@ -544,7 +546,7 @@ SKEEM
           compare_to_predicted(checks)
         end
 
-          it 'should implement the null? procedure' do
+        it 'should implement the null? procedure' do
           checks = [
             ['(null? #f)', false],
             ['(null? 1)', false],
@@ -591,7 +593,7 @@ SKEEM
           example = "(cons '(a b) 'c)" # => ((a b) . c)
           result = subject.run(example)
           expect(result.car).to be_kind_of(SkmPair)
-          expect(result.car.to_a).to eq(['a', 'b'])
+          expect(result.car.to_a).to eq(%w[a b])
           expect(result.cdr).to be_kind_of(SkmIdentifier)
           expect(result.cdr).to eq('c')
         end
@@ -616,7 +618,7 @@ SKEEM
           result = subject.run(example)
           expect(result).to be_list
           expect(result.length).to eq(3)
-          expect(result.to_a).to eq(['b', 'c', 'd'])
+          expect(result.to_a).to eq(%w[b c d])
 
           expect_expr("(cdr '(1 . 2))").to eq(2)
 
@@ -624,29 +626,37 @@ SKEEM
           expect { subject.run(example) }.to raise_error(StandardError)
         end
 
+        it 'should implement the length procedure' do
+          example = '(make-list 2 3)'
+          result = subject.run(example)
+          expect(result).to be_list
+          expect(result.length).to eq(2)
+          expect(result.to_a).to eq([3, 3])
+        end
+
         it 'should implement the length procedure' do
           checks = [
             ["(length '())", 0],
             ["(length '(1))", 1],
             ["(length '(1 2))", 2],
             ["(length '(1 2 3))", 3],
-           ["(length '(a (b) (c d e)))", 3]
+            ["(length '(a (b) (c d e)))", 3]
           ]
           compare_to_predicted(checks)
         end
 
         it 'should implement the append procedure' do
           checks = [
-            ["(append '(a b c) '())", array2list_ids(['a', 'b', 'c'])],
-            ["(append '() '(a b c))", array2list_ids(['a', 'b', 'c'])],
-            ["(append '(x) '(y))", array2list_ids(['x', 'y'])],
-            ["(append '(a) '(b c d))", array2list_ids(['a', 'b', 'c', 'd'])],
-            ["(append '(a b) '(c d))", array2list_ids(['a', 'b', 'c', 'd'])],
-            ["(append '(a b) '(c) 'd)", array2list_ids(['a', 'b', 'c', 'd'])],
+            ["(append '(a b c) '())", array2list_ids(%w[a b c])],
+            ["(append '() '(a b c))", array2list_ids(%w[a b c])],
+            ["(append '(x) '(y))", array2list_ids(%w[x y])],
+            ["(append '(a) '(b c d))", array2list_ids(%w[a b c d])],
+            ["(append '(a b) '(c d))", array2list_ids(%w[a b c d])],
+            ["(append '(a b) '(c) 'd)", array2list_ids(%w[a b c d])],
             ["(append '(a (b)) '((c)))", [SkmIdentifier.create('a'),
               SkmPair.create_from_a(array2list_ids(['b'])),
               SkmPair.create_from_a(array2list_ids(['c']))]],
-            [ "(append '() 'a)", SkmIdentifier.create('a')]
+            ["(append '() 'a)", SkmIdentifier.create('a')]
           ]
           compare_to_predicted(checks) do |result, expectation|
             if result.kind_of?(SkmPair)
@@ -659,18 +669,18 @@ SKEEM
 
         it 'should implement the procedure for an improper list' do
           result = subject.run("(append '(a b) '(c . d))")
-          expect(result.car).to eq( SkmIdentifier.create('a'))
-          expect(result.cdr.car).to eq( SkmIdentifier.create('b'))
-          expect(result.cdr.cdr.car).to eq( SkmIdentifier.create('c'))
-          expect(result.cdr.cdr.cdr).to eq( SkmIdentifier.create('d'))
+          expect(result.car).to eq(SkmIdentifier.create('a'))
+          expect(result.cdr.car).to eq(SkmIdentifier.create('b'))
+          expect(result.cdr.cdr.car).to eq(SkmIdentifier.create('c'))
+          expect(result.cdr.cdr.cdr).to eq(SkmIdentifier.create('d'))
         end
 
 
         it 'should implement the reverse procedure' do
           checks = [
             ["(reverse '())", SkmEmptyList.instance],
-            ["(reverse '(a b c))", array2list_ids(['c', 'b', 'a'])],
-            ["(reverse '((a) b c))", array2list_ids(['c', 'b']) << SkmPair.new(SkmIdentifier.create('a'), nil)]
+            ["(reverse '(a b c))", array2list_ids(%w[c b a])],
+            ["(reverse '((a) b c))", array2list_ids(%w[c b]) << SkmPair.new(SkmIdentifier.create('a'), nil)]
           ]
           compare_to_predicted(checks) do |result, expectation|
             if result.kind_of?(SkmPair)
@@ -684,7 +694,7 @@ SKEEM
         it 'should implement the list->vector procedure' do
           checks = [
             ["(list->vector '())", []],
-            ["(list->vector '(a b c))", ['a', 'b', 'c']]
+            ["(list->vector '(a b c))", %w[a b c]]
           ]
           compare_to_predicted(checks) do |result, expectation|
             expect(result.to_a).to eq(expectation)
@@ -692,7 +702,7 @@ SKEEM
         end
 
         it 'should implement the set-car! procedure' do
-          source =<<-SKEEM
+          source = <<-SKEEM
   (define x '(a b c))
   (set-car! x 1)
   x
@@ -702,7 +712,7 @@ SKEEM
         end
 
         it 'should implement the set-cdr! procedure' do
-          source =<<-SKEEM
+          source = <<-SKEEM
   (define x '(a b c))
   (set-cdr! x 1)
   x
@@ -736,13 +746,13 @@ SKEEM
         it 'should implement the list-copy procedure' do
           checks = [
             ["(list-copy '())", []],
-            ["(list-copy '(a b c))", ['a', 'b', 'c']]
+            ["(list-copy '(a b c))", %w[a b c]]
           ]
           compare_to_predicted(checks) do |result, expectation|
             expect(result.to_a).to eq(expectation)
           end
 
-          source =<<-SKEEM
+          source = <<-SKEEM
   (define a '(1 8 2 8)) ; a may be immutable
   (define b (list-copy a))
   (set-car! b 3) ; b is mutable
@@ -886,7 +896,7 @@ SKEEM
           checks = [
             ['(vector-length (make-vector 0))', 0],
             ["(vector-length (make-vector 0 'a))", 0],
-            ["(equal? (make-vector 5 'a) '#(a a a a a))", true],
+            ["(equal? (make-vector 5 'a) '#(a a a a a))", true]
           ]
           compare_to_predicted(checks)
         end
@@ -899,21 +909,21 @@ SKEEM
         end
 
         it 'should implement the vector-set! procedure' do
-          source =<<-SKEEM
+          source = <<-SKEEM
   (let
     ((vec (vector 0 '(2 2 2 2) "Anna")))
     (vector-set! vec 1 '("Sue" "Sue"))
   vec)
 SKEEM
-#(0 ("Sue" "Sue") "Anna")
+          # (0 ("Sue" "Sue") "Anna")
           result = subject.run(source)
           expect(result).to be_kind_of(SkmVector)
-          expectation = [SkmInteger.create(0), 
-            SkmPair.new(SkmString.create("Sue"), SkmPair.new(SkmString.create("Sue"), SkmEmptyList.instance)),
-            SkmString.create("Anna") ]
+          expectation = [SkmInteger.create(0),
+            SkmPair.new(SkmString.create('Sue'), SkmPair.new(SkmString.create('Sue'), SkmEmptyList.instance)),
+            SkmString.create('Anna')]
           expect(result).to eq(expectation)
 
-          source =<<-SKEEM
+          source = <<-SKEEM
   (let (
     (v (vector 'a 'b 'c 'd 'e)))
     (vector-set! v 2 'x)
@@ -921,13 +931,13 @@ SKEEM
 SKEEM
           result = subject.run(source)
           expect(result).to be_kind_of(SkmVector)
-          expect(result).to eq(array2list_ids(['a', 'b', 'x', 'd', 'e']))
+          expect(result).to eq(array2list_ids(%w[a b x d e]))
         end
 
         it 'should implement the vector->list procedure' do
           checks = [
-            ["(vector->list #())", []],
-            ["(vector->list '#(a b c))", ['a', 'b', 'c']]
+            ['(vector->list #())', []],
+            ["(vector->list '#(a b c))", %w[a b c]]
           ]
           compare_to_predicted(checks) do |result, expectation|
             expect(result.to_a).to eq(expectation)
@@ -938,9 +948,9 @@ SKEEM
       context 'Control procedures:' do
         it 'should implement the procedure? predicate' do
           checks = [
-            ["(procedure? car)", true],
+            ['(procedure? car)', true],
             ["(procedure? 'car)", false],
-            ["(procedure? (lambda (x) (* x x)))", true],
+            ['(procedure? (lambda (x) (* x x)))', true]
             # ["(procedure? '(lambda (x) (* x x)))", false] # Parse fail: non-standard syntax
           ]
           compare_to_predicted(checks)
@@ -955,7 +965,7 @@ SKEEM
 
         it 'should implement the map procedure' do
           checks = [
-            ["(map car '((a b) (d e) (g h)))", ['a', 'd', 'g']],
+            ["(map car '((a b) (d e) (g h)))", %w[a d g]],
             ["(map + '(1 2 3) '(4 5 6 7))", [5, 7, 9]]
           ]
           compare_to_predicted(checks) do |result, expectation|
@@ -965,16 +975,23 @@ SKEEM
       end # context
 
       context 'IO procedures:' do
-        it 'should implement the newline procedure' do
+        it 'should implement the display procedure' do
           default_stdout = $stdout
-          $stdout = StringIO.new()
-          subject.run('(newline) (newline) (newline)')
-          expect($stdout.string).to match(/\n\n\n$/)
+          $stdout = StringIO.new
+          subject.run('(display "Hello")')
+          expect($stdout.string).to eq('Hello')
           $stdout = default_stdout
         end
       end # context
 
       context 'Miscellaneous procedures' do
+        it 'should raise an exception with given error message' do
+          source = '(error "This is an error message")'
+          err = SkmError
+          msg = 'This is an error message'
+          expect { subject.run(source) }.to raise_error(err, msg)
+        end
+
         it 'should return true when an assertion succeeds' do
           source = <<-SKEEM
   (define x 2)
@@ -993,9 +1010,9 @@ SKEEM
           err = StandardError
           msg1 = 'Error: assertion failed on line 3, column 4'
           msg2 = 'with <Skeem::SkmBoolean: false>'
-          expect { subject.run(source) }.to raise_error(err, msg1 + ', '+ msg2)
+          expect { subject.run(source) }.to raise_error(err, "#{msg1}, #{msg2}")
         end
       end # context
     end # describe
   end # module
-end # module
+end # module

data/spec/skeem/primitive/primitive_procedure_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../spec_helper' # Use the RSpec framework
 
 # Load the class under test
@@ -9,8 +11,8 @@ module Skeem
       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(:zero_or_more) { SkmArity.new(0, '*') }
+      let(:one_or_more) { SkmArity.new(1, '*') }
       let(:newline_code) do
         ->(_runtime) { "\n" }
       end
@@ -49,7 +51,7 @@ module Skeem
         end
 
         it 'should complain if third argument is not a lambda' do
-          kode = Proc.new { puts '' }
+          kode = proc { puts '' }
 
           err = StandardError
           err_msg = "Primitive procedure 'newline' must be implemented with a Ruby lambda."
@@ -57,7 +59,7 @@ module Skeem
         end
 
         it 'should complain if third argument is a nullary lambda' do
-          kode = ->() { puts '' } # Missing slot for Runtime object
+          kode = -> { puts '' } # Missing slot for Runtime object
 
           err = StandardError
           err_msg = "Primitive procedure 'newline' lambda takes no parameter."
@@ -68,10 +70,10 @@ module Skeem
           err = StandardError
           msg1 = "Discrepancy in primitive procedure 'cube' "
 
-          msg2 = "between arity (0) + 1 and parameter count of lambda 2."
+          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."
+          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
@@ -79,7 +81,7 @@ module Skeem
 
           expect { PrimitiveProcedure.new('cube', unary, cube) }.not_to raise_error
 
-          msg2 = "between arity (1) + 2 and parameter count of lambda 2."
+          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
@@ -109,7 +111,7 @@ module Skeem
           ms2 = ' (required at least 1, got 0)'
           expect { pproc.call(rtime, []) }.to raise_error(err, ms1 + ms2)
 
-          too_much = ['foo', 'bar']
+          too_much = %w[foo bar]
           err = StandardError
           ms1 = 'Wrong number of arguments for #<Procedure cube>'
           ms2 = ' (required at least 1, got 2)'
@@ -129,7 +131,7 @@ module Skeem
           ms2 = ' (required at least 2, got 1)'
           expect { pproc.call(rtime, too_few) }.to raise_error(err, ms1 + ms2)
 
-          too_much = ['foo', 'bar', 'quux']
+          too_much = %w[foo bar quux]
           err = StandardError
           ms1 = 'Wrong number of arguments for #<Procedure sum>'
           ms2 = ' (required at least 2, got 3)'
@@ -146,11 +148,11 @@ module Skeem
           no_arg = []
           expect(pproc.call(rtime, no_arg)).to eq(0)
 
-          many = [SkmString.create('foo'), SkmString.create('bar'), 
+          many = [SkmString.create('foo'), SkmString.create('bar'),
             SkmString.create('quux')]
-          expect( pproc.call(rtime, many)).to eq(3)
+          expect(pproc.call(rtime, many)).to eq(3)
         end
       end # context
     end # describe
   end # module
-end # module
+end # module

data/spec/skeem/runtime_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../spec_helper' # Use the RSpec framework
 require_relative '../../lib/skeem/datum_dsl'
 require_relative '../../lib/skeem/s_expr_nodes'
@@ -8,7 +10,7 @@ require_relative '../../lib/skeem/runtime' # Load the class under test
 module Skeem
   describe Runtime do
     include DatumDSL
-    
+
     let(:some_env) { SkmFrame.new }
     subject { Runtime.new(some_env) }
 
@@ -20,7 +22,7 @@ module Skeem
       it 'should know the environment' do
         expect(subject.environment).to eq(some_env)
       end
-      
+
       it 'should have an empty call stack' do
         expect(subject.call_stack).to be_empty
       end
@@ -42,10 +44,10 @@ module Skeem
         expect(subject.include?('dummy')).to be_truthy
       end
     end # context
-      
+
     context 'Evaluation:' do
       include Primitive::PrimitiveBuilder
-      
+
       # it 'should evaluate a given entry' do
         # entry = integer(3)
         # result = double('fake-procedure')
@@ -54,21 +56,21 @@ module Skeem
         # subject.define('three', entry)
         # expect(subject.evaluate('three')).to eq(3)
       # end
-      
+
       it 'should evaluate a given list' do
         add_primitives(subject)
         sum = list([identifier('+'), 3, 4])
-        
+
         expect(subject.evaluate_form(sum)).to eq(7)
       end
     end # context
-      
+
     context 'Environment nesting:' do
       it 'should add nested environment' do
         expect(subject.depth).to eq(1)
         env_before = subject.environment
         subject.nest
-        
+
         expect(subject.environment).not_to eq(env_before)
         expect(subject.environment.parent).to eq(env_before)
         expect(subject.depth).to eq(2)
@@ -79,37 +81,37 @@ module Skeem
         subject.nest
         parent_before = subject.environment.parent
         expect(subject.depth).to eq(2)
-        
+
         subject.unnest
         expect(subject.environment).to eq(parent_before)
         expect(subject.depth).to eq(1)
       end
     end # context
-    
+
     context 'Call stack operations:' do
       let(:sample_call) do
         pos = double('fake-position')
-        ProcedureCall.new(pos, identifier('boolean?'), [integer(42)])      
+        ProcedureCall.new(pos, identifier('boolean?'), [integer(42)])
       end
-      
+
       it 'should push a call to the stack call' do
         expect { subject.push_call(sample_call) }.not_to raise_error
-        expect(subject.call_stack.size). to eq(1)
+        expect(subject.call_stack.size).to eq(1)
         expect(subject.caller).to eq(sample_call)
-        
+
         subject.push_call(sample_call.clone)
-        expect(subject.call_stack.size). to eq(2)
+        expect(subject.call_stack.size).to eq(2)
       end
 
       it 'should pop a call from the call stack' do
         subject.push_call(sample_call)
         expect { subject.pop_call }.not_to raise_error
         expect(subject.call_stack).to be_empty
-        
+
         err = StandardError
         msg = 'Skeem call stack empty!'
         expect { subject.pop_call }.to raise_error(err, msg)
       end
-    end # context    
+    end # context
   end # describe
-end # module
+end # module