skeem 0.2.15 → 0.2.16

data/spec/skeem/interpreter_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'stringio'
 require_relative '../spec_helper' # Use the RSpec framework
 require_relative '../../lib/skeem/datum_dsl'
@@ -14,7 +16,7 @@ module Skeem
       end
 
       it 'could be initialized with a block argument' do
-        expect { Interpreter.new { |interp| }  }.not_to raise_error
+        expect { Interpreter.new { |interp| } }.not_to raise_error
       end
 
       it 'should have a parser' do
@@ -90,6 +92,7 @@ module Skeem
       end
 
       it 'should evaluate vector of constants' do
+        require 'benchmark'
         source = '#(2018 10 20 "Sat")'
         result = subject.run(source)
         expect(result).to be_kind_of(SkmVector)
@@ -108,7 +111,7 @@ module Skeem
 
     context 'Built-in primitives' do
       it 'should implement variable definition' do
-        result = subject.run('(define x 28)')
+        subject.run('(define x 28)')
         expect(subject.fetch('x')).to eq(28)
       end
 
@@ -125,7 +128,7 @@ SKEEM
       end
 
       it 'should implement the simple conditional form' do
-         checks = [
+        checks = [
           ['(if (> 3 2) "yes")', 'yes'],
           ['(if (> 2 3) "yes")', SkmUndefined.instance]
         ]
@@ -157,7 +160,7 @@ SKEEM
       ((< x 0) -1)
     )))
 SKEEM
-        result = subject.run(source)
+        subject.run(source)
         checks = [
           ['(signum 3)', 1],
           ['(signum 0)', 0],
@@ -175,7 +178,7 @@ SKEEM
       ((< x 0) => -1)
     )))
 SKEEM
-        result = subject.run(source)
+        subject.run(source)
         checks = [
           ['(signum 3)', 1],
           ['(signum 0)', 0],
@@ -193,7 +196,7 @@ SKEEM
       (else -1)
     )))
 SKEEM
-        result = subject.run(source)
+        subject.run(source)
         checks = [
           ['(signum 3)', 1],
           ['(signum 0)', 0],
@@ -211,7 +214,7 @@ SKEEM
       end
 
       it 'should implement the quotation of constant literals' do
-         checks = [
+        checks = [
           ['(quote a)', 'a'],
           ['(quote 145932)', 145932],
           ['(quote "abc")', 'abc'],
@@ -367,8 +370,6 @@ SKEEM
         result = subject.run(source)
         expect(result.last.value).to eq(20)
       end
-
-
     end # context
 
     context 'Binding constructs:' do
@@ -406,7 +407,7 @@ SKEEM
       end
 
       it 'should support the nesting of a lambda in a let expression' do
-        source =<<-SKEEM
+        source = <<-SKEEM
   (define make-counter
     (lambda ()
        (let ((count 0))
@@ -477,7 +478,7 @@ SKEEM
 
     context 'Quasiquotation:' do
       it 'should implement the quasiquotation of constant literals' do
-         checks = [
+        checks = [
           ['(quasiquote a)', 'a'],
           ['(quasiquote 145932)', 145932],
           ['(quasiquote "abc")', 'abc'],
@@ -518,7 +519,7 @@ SKEEM
           expect(result.members[index]).to eq(value)
         end
 
-        source = "`#()"
+        source = '`#()'
         result = subject.run(source)
         expect(result).to be_kind_of(SkmVector)
         expect(result).to be_empty
@@ -555,7 +556,7 @@ SKEEM
           result = result.cdr
         end
 
-        source = "`()"
+        source = '`()'
         result = subject.run(source)
         expect(result).to be_kind_of(SkmEmptyList)
         expect(result).to be_null
@@ -576,7 +577,7 @@ SKEEM
           result = result.cdr
         end
 
-        source = "`()"
+        source = '`()'
         result = subject.run(source)
         expect(result).to be_kind_of(SkmEmptyList)
         expect(result).to be_null
@@ -801,46 +802,56 @@ SKEEM
         compare_to_predicted(checks)
       end
 
-        it 'should implement the truncate-quotient procedure' do
-          checks = [
-            ['(truncate-quotient 5 2)', 2],
-            ['(truncate-quotient -5 2)', -2],
-            ['(truncate-quotient 5 -2)', -2],
-            ['(truncate-quotient -5 -2)', 2],
-            ['(quotient 5 2)', 2],
-            ['(quotient -5 2)', -2],
-            ['(quotient 5 -2)', -2],
-            ['(quotient -5 -2)', 2]
-          ]
-          compare_to_predicted(checks)
-        end
+      it 'should implement the truncate-quotient procedure' do
+        checks = [
+          ['(truncate-quotient 5 2)', 2],
+          ['(truncate-quotient -5 2)', -2],
+          ['(truncate-quotient 5 -2)', -2],
+          ['(truncate-quotient -5 -2)', 2],
+          ['(quotient 5 2)', 2],
+          ['(quotient -5 2)', -2],
+          ['(quotient 5 -2)', -2],
+          ['(quotient -5 -2)', 2]
+        ]
+        compare_to_predicted(checks)
+      end
 
-        it 'should implement the truncate-remainder procedure' do
-          checks = [
-            ['(truncate-remainder 5 2)', 1],
-            ['(truncate-remainder -5 2)', -1],
-            ['(truncate-remainder 5 -2)', 1],
-            ['(truncate-remainder -5 -2)', -1],
-            ['(remainder 5 2)', 1],
-            ['(remainder -5 2)', -1],
-            ['(remainder 5 -2)', 1],
-            ['(remainder -5 -2)', -1]
-          ]
-          compare_to_predicted(checks)
-        end
+      it 'should implement the truncate-remainder procedure' do
+        checks = [
+          ['(truncate-remainder 5 2)', 1],
+          ['(truncate-remainder -5 2)', -1],
+          ['(truncate-remainder 5 -2)', 1],
+          ['(truncate-remainder -5 -2)', -1],
+          ['(remainder 5 2)', 1],
+          ['(remainder -5 2)', -1],
+          ['(remainder 5 -2)', 1],
+          ['(remainder -5 -2)', -1]
+        ]
+        compare_to_predicted(checks)
+      end
 
       it 'should implement the test-equal procedure' do
         checks = [
-          ["(test-equal (cons 1 2) (cons 1 2))", true]
+          ['(test-equal (cons 1 2) (cons 1 2))', true]
         ]
         compare_to_predicted(checks)
       end
     end # context
-    
+
     context 'Input/output:' do
+      it 'should implement the include expression' do
+        initial_dir = Dir.pwd
+        filedir = File.dirname(__FILE__)
+        Dir.chdir(filedir)
+        source = '(include "add4.skm")' # Path is assumed to be relative to pwd
+        result = subject.run(source)
+        expect(result.last).to eq(10)
+        Dir.chdir(initial_dir)
+      end
+
       it 'should implement the newline procedure' do
         default_stdout = $stdout
-        $stdout = StringIO.new()
+        $stdout = StringIO.new
         subject.run('(newline) (newline) (newline)')
         expect($stdout.string).to match(/\n\n\n$/)
         $stdout = default_stdout
@@ -895,7 +906,7 @@ SKEEM
 SKEEM
         result = subject.run(source)
         expect(result).to eq([0, 1, 2, 3, 4])
-        
+
         source = <<-SKEEM
           (let ((x '(1 3 5 7 9)))
             (do (
@@ -904,8 +915,25 @@ SKEEM
               ((null? x) sum))) ; => 25
 SKEEM
         result = subject.run(source)
-        expect(result).to eq(25)        
+        expect(result).to eq(25)
       end
     end # context
+
+    context 'Macro processing:' do
+      # it 'should parse macro expressions' do
+        # source = <<-SKEEM
+          # (define-syntax while
+            # (syntax-rules ()
+              # ((while condition body ...)
+               # (let loop ()
+                 # (if condition
+                     # (begin
+                       # body ...
+                       # (loop))
+                     # #f)))))
+# SKEEM
+        # ptree = subject.parse(source)
+      # end
+    end
   end # describe
-end # module
+end # module

data/spec/skeem/lambda_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../spec_helper' # Use the RSpec framework
 
 # Load the class under test
@@ -75,13 +77,13 @@ SKEEM
 
         expect(result.last).to eq(136)
       end
-      
+
       it 'should accept calls to anonymous procedures' do
         source = '((lambda (x) (+ x x)) 4)'
         result = subject.run(source)
         expect(result).to eq(8)
       end
-      
+
       it 'should accept unary second-order lambdas' do
         source = <<-SKEEM
   (define add-with
@@ -94,10 +96,10 @@ SKEEM
         expect(result).to eq(7)
       end
     end # context
-      
+
     context 'More advanced features:' do
       subject { Interpreter.new }
-    
+
       it 'should implement binary second-order functions' do
         source = <<-SKEEM
   (define compose
@@ -105,10 +107,10 @@ SKEEM
       (lambda (x)
         (f (g x)))))
 SKEEM
-        result = subject.run(source)
+        subject.run(source)
         result = subject.run('((compose list square) 5)')
         expect(result.last).to eq(25)
-      end       
+      end
     end # context
   end # describe
-end # module
+end # module

data/spec/skeem/parser_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../spec_helper' # Use the RSpec framework
 require_relative '../../lib/skeem/tokenizer' # Load the class under test
 
@@ -5,7 +7,7 @@ module Skeem
   describe Parser do
     context 'Initialization:' do
       it 'should be initialized without argument' do
-        expect { Parser.new() }.not_to raise_error
+        expect { Parser.new }.not_to raise_error
       end
 
       it 'should have its parse engine initialized' do
@@ -16,11 +18,11 @@ module Skeem
     context 'Parsing literals:' do
       it 'should parse isolated booleans' do
         samples = [
-        ['#f', false],
+          ['#f', false]
 #        ['#false', false],
 #        ['#t', true],
 #        ['#true', true]
-      ]
+        ]
         samples.each do |source, predicted|
           ptree = subject.parse(source)
           expect(ptree.root).to be_kind_of(SkmBoolean)
@@ -30,12 +32,12 @@ module Skeem
 
       it 'should parse isolated integers' do
         samples = [
-        ['0', 0],
-        ['3', 3],
-        ['-3', -3],
-        ['+12345', 12345],
-        ['-12345', -12345]
-      ]
+          ['0', 0],
+          ['3', 3],
+          ['-3', -3],
+          ['+12345', 12345],
+          ['-12345', -12345]
+        ]
         samples.each do |source, predicted|
           ptree = subject.parse(source)
           expect(ptree.root).to be_kind_of(SkmInteger)
@@ -45,12 +47,12 @@ module Skeem
 
       it 'should parse isolated real numbers' do
         samples = [
-        ['0.0', 0.0],
-        ['3.14', 3.14],
-        ['-3.14', -3.14],
-        ['+123e+45', 123e+45],
-        ['-123e-45', -123e-45]
-      ]
+          ['0.0', 0.0],
+          ['3.14', 3.14],
+          ['-3.14', -3.14],
+          ['+123e+45', 123e+45],
+          ['-123e-45', -123e-45]
+        ]
         samples.each do |source, predicted|
           ptree = subject.parse(source)
           expect(ptree.root).to be_kind_of(SkmReal)
@@ -60,8 +62,8 @@ module Skeem
 
       it 'should parse isolated strings' do
         samples = [
-        ['"Hello world!"', 'Hello world!']
-      ]
+          ['"Hello world!"', 'Hello world!']
+        ]
         samples.each do |source, predicted|
           ptree = subject.parse(source)
           expect(ptree.root).to be_kind_of(SkmString)
@@ -71,8 +73,8 @@ module Skeem
 
       it 'should parse isolated identifiers' do
         samples = [
-        ['the-word-recursion-has-many-meanings', 'the-word-recursion-has-many-meanings']
-      ]
+          %w[the-word-recursion-has-many-meanings the-word-recursion-has-many-meanings]
+        ]
         samples.each do |source, predicted|
           ptree = subject.parse(source)
           expect(ptree.root).to be_kind_of(SkmVariableReference)

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,21 +618,21 @@ 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)
 
           example = "(cdr '())" # => error
           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        
+        end
 
         it 'should implement the length procedure' do
           checks = [
@@ -638,23 +640,23 @@ SKEEM
             ["(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')]
+                                          SkmPair.create_from_a(array2list_ids(['b'])),
+                                          SkmPair.create_from_a(array2list_ids(['c']))]],
+            ["(append '() 'a)", SkmIdentifier.create('a')]
           ]
           compare_to_predicted(checks) do |result, expectation|
             if result.kind_of?(SkmPair)
@@ -667,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)
@@ -692,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)
@@ -700,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
@@ -710,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
@@ -744,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
@@ -894,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
@@ -907,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") ]
+                         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)
@@ -929,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)
@@ -946,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)
@@ -963,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|
@@ -975,7 +977,7 @@ SKEEM
       context 'IO procedures:' do
         it 'should implement the display procedure' do
           default_stdout = $stdout
-          $stdout = StringIO.new()
+          $stdout = StringIO.new
           subject.run('(display "Hello")')
           expect($stdout.string).to eq('Hello')
           $stdout = default_stdout
@@ -983,6 +985,13 @@ SKEEM
       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)
@@ -1001,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