skeem 0.2.21 → 0.2.22

data/spec/skeem/lambda_spec.rb

@@ -7,7 +7,7 @@ require_relative '../../lib/skeem/interpreter'
 
 module Skeem
   describe 'The interpreter and compound procedures' do
-    subject do
+    subject(:interpreter) do
       # We load the interpreter with the primitive procedures only
       Interpreter.new { |interp| interp.add_primitives(interp.runtime) }
     end
@@ -30,85 +30,85 @@ SKEEM
     end
 
     context 'Defining compound procedures:' do
-      it 'should accept the definition of simple procedure with arity 1' do
+      it 'accepts the definition of simple procedure with arity 1' do
         source = "#{definition_set}\nsquare"
-        result = subject.run(source)
+        result = interpreter.run(source)
 
         square = result.last
-        expect(square).to be_kind_of(SkmLambda)
+        expect(square).to be_a(SkmLambda)
         expect(square.arity).to eq(1)
-        expect(square.environment).to eq(subject.runtime.environment)
+        expect(square.environment).to eq(interpreter.runtime.environment)
       end
 
-      it 'should accept the definition of simple procedure with arity 2' do
+      it 'accepts the definition of simple procedure with arity 2' do
         source = "#{definition_set}\nsum-of-squares"
-        result = subject.run(source)
+        result = interpreter.run(source)
 
         square = result.last
-        expect(square).to be_kind_of(SkmLambda)
+        expect(square).to be_a(SkmLambda)
         expect(square.arity).to eq(2)
-        expect(square.environment).to eq(subject.runtime.environment)
+        expect(square.environment).to eq(interpreter.runtime.environment)
       end
     end # context
 
     context 'Calling compound procedures:' do
-      it 'should support the call to a simple procedure with arity 1' do
+      it 'supports the call to a simple procedure with arity 1' do
         # Case 1: argument is a simple datum
-        subject.run(definition_set)
-        result = subject.run('(square 2)')
+        interpreter.run(definition_set)
+        result = interpreter.run('(square 2)')
         expect(result).to eq(4)
 
         # Case 2: argument is a sub-expression
-        ptree = subject.parse('(square (+ 2 1))')
+        ptree = interpreter.parse('(square (+ 2 1))')
         proc_call = ptree.root
-        expect(proc_call.evaluate(subject.runtime)).to eq(9)
+        expect(proc_call.evaluate(interpreter.runtime)).to eq(9)
       end
 
-      it 'should support the call to a simple procedure with arity 2' do
+      it 'supports the call to a simple procedure with arity 2' do
         source = "#{definition_set}\n(sum-of-squares 3 4)"
-        result = subject.run(source)
+        result = interpreter.run(source)
 
         expect(result.last).to eq(25)
       end
 
-      it 'should support the call to a nested lambda procedure' do
+      it 'supports the call to a nested lambda procedure' do
         source = "#{definition_set}\n(f 5)"
-        result = subject.run(source)
+        result = interpreter.run(source)
 
         expect(result.last).to eq(136)
       end
 
-      it 'should accept calls to anonymous procedures' do
+      it 'accepts calls to anonymous procedures' do
         source = '((lambda (x) (+ x x)) 4)'
-        result = subject.run(source)
+        result = interpreter.run(source)
         expect(result).to eq(8)
       end
 
-      it 'should accept unary second-order lambdas' do
+      it 'accepts unary second-order lambdas' do
         source = <<-SKEEM
   (define add-with
     (lambda (x) (lambda (y) (+ x y)))
   )
   (define add4 (add-with 4))
 SKEEM
-        subject.run(source)
-        result = subject.run('(add4 3)')
+        interpreter.run(source)
+        result = interpreter.run('(add4 3)')
         expect(result).to eq(7)
       end
     end # context
 
     context 'More advanced features:' do
-      subject { Interpreter.new }
+      subject(:interpreter) { Interpreter.new }
 
-      it 'should implement binary second-order functions' do
+      it 'implements binary second-order functions' do
         source = <<-SKEEM
   (define compose
     (lambda (f g)
       (lambda (x)
         (f (g x)))))
 SKEEM
-        subject.run(source)
-        result = subject.run('((compose list square) 5)')
+        interpreter.run(source)
+        result = interpreter.run('((compose list square) 5)')
         expect(result.last).to eq(25)
       end
     end # context

data/spec/skeem/parser_spec.rb

@@ -5,18 +5,20 @@ require_relative '../../lib/skeem/tokenizer' # Load the class under test
 
 module Skeem
   describe Parser do
+    subject(:parser) { described_class.new }
+
     context 'Initialization:' do
-      it 'should be initialized without argument' do
-        expect { Parser.new }.not_to raise_error
+      it 'is initialized without argument' do
+        expect { described_class.new }.not_to raise_error
       end
 
-      it 'should have its parse engine initialized' do
-        expect(subject.engine).to be_kind_of(Rley::Engine)
+      it 'has its parse engine initialized' do
+        expect(parser.engine).to be_a(Rley::Engine)
       end
     end # context
 
     context 'Parsing literals:' do
-      it 'should parse isolated booleans' do
+      it 'parses isolated booleans' do
         samples = [
           ['#f', false]
 #        ['#false', false],
@@ -24,13 +26,13 @@ module Skeem
 #        ['#true', true]
         ]
         samples.each do |source, predicted|
-          ptree = subject.parse(source)
-          expect(ptree.root).to be_kind_of(SkmBoolean)
+          ptree = parser.parse(source)
+          expect(ptree.root).to be_a(SkmBoolean)
           expect(ptree.root.value).to eq(predicted)
         end
       end
 
-      it 'should parse isolated integers' do
+      it 'parses isolated integers' do
         samples = [
           ['0', 0],
           ['3', 3],
@@ -39,14 +41,14 @@ module Skeem
           ['-12345', -12345]
         ]
         samples.each do |source, predicted|
-          ptree = subject.parse(source)
-          expect(ptree.root).to be_kind_of(SkmInteger)
+          ptree = parser.parse(source)
+          expect(ptree.root).to be_a(SkmInteger)
           expect(ptree.root.value).to eq(predicted)
         end
       end
 
       # rubocop: disable Style/ExponentialNotation
-      it 'should parse isolated real numbers' do
+      it 'parses isolated real numbers' do
         samples = [
           ['0.0', 0.0],
           ['3.14', 3.14],
@@ -55,42 +57,42 @@ module Skeem
           ['-123e-45', -123e-45]
         ]
         samples.each do |source, predicted|
-          ptree = subject.parse(source)
-          expect(ptree.root).to be_kind_of(SkmReal)
+          ptree = parser.parse(source)
+          expect(ptree.root).to be_a(SkmReal)
           expect(ptree.root.value).to eq(predicted)
         end
       end
       # rubocop: enable Style/ExponentialNotation
 
-      it 'should parse isolated strings' do
+      it 'parses isolated strings' do
         samples = [
           ['"Hello world!"', 'Hello world!']
         ]
         samples.each do |source, predicted|
-          ptree = subject.parse(source)
-          expect(ptree.root).to be_kind_of(SkmString)
+          ptree = parser.parse(source)
+          expect(ptree.root).to be_a(SkmString)
           expect(ptree.root.value).to eq(predicted)
         end
       end
 
-      it 'should parse isolated identifiers' do
+      it 'parses isolated identifiers' do
         samples = [
           %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)
+          ptree = parser.parse(source)
+          expect(ptree.root).to be_a(SkmVariableReference)
           expect(ptree.root.value).to eq(predicted)
         end
       end
     end # context
 
-    context 'Parsing forms:' do
-      # it 'should parse definitions' do
-        # source = '(define r 10)'
-        # expect { subject.parse(source) }.not_to raise_error
-      # end
-    end # context
+    # context 'Parsing forms:' do
+    #   # it 'parses definitions' do
+    #     # source = '(define r 10)'
+    #     # expect { parser.parse(source) }.not_to raise_error
+    #   # end
+    # end # context
   end # describe
 end # module