skeem 0.2.21 → 0.2.22

data/spec/skeem/skm_empty_list_spec.rb

@@ -5,46 +5,46 @@ require_relative '../../lib/skeem/skm_empty_list' # Load the class under test
 
 module Skeem
   describe SkmEmptyList do
-    subject { SkmEmptyList.instance }
+    subject(:empty_list) { described_class.instance }
 
     context 'Initialization:' do
-      it 'should be initialized without argument' do
-        expect { SkmEmptyList.instance }.not_to raise_error
+      it 'is initialized without argument' do
+        expect { described_class.instance }.not_to raise_error
       end
 
       # Default (overridable) behavior of SkmElement
-      it 'should react by default to predicates' do
-        expect(subject).to be_list
-        expect(subject).to be_null
-        expect(subject).not_to be_pair
+      it 'reacts by default to predicates' do
+        expect(empty_list).to be_list
+        expect(empty_list).to be_null
+        expect(empty_list).not_to be_pair
       end
     end # context
 
     context 'Provided services:' do
       let(:runtime) { double('fake-runtime') }
 
-      it 'should be equivalent to itself' do
-        expect(subject).to be_eqv(SkmEmptyList.instance)
-        expect(subject).not_to be_eqv('()')
+      it 'is equivalent to itself' do
+        expect(empty_list).to be_eqv(described_class.instance)
+        expect(empty_list).not_to be_eqv('()')
       end
 
-      it "should return itself when receiving 'evaluate' message" do
-        expect(subject.evaluate(runtime)).to eq(subject)
+      it "returns itself when receiving 'evaluate' message" do
+        expect(empty_list.evaluate(runtime)).to eq(empty_list)
       end
 
-      it "should return itself receiving 'quasiquote' message" do
-        expect(subject.quasiquote(runtime)).to eq(subject)
+      it "returns itself receiving 'quasiquote' message" do
+        expect(empty_list.quasiquote(runtime)).to eq(empty_list)
       end
 
-      it "should reply to visitor's 'accept' message" do
+      it "replies to visitor's 'accept' message" do
         visitor = double('fake-visitor')
-        expect(visitor).to receive(:visit_empty_list).with(subject)
-        expect { subject.accept(visitor) }.not_to raise_error
+        allow(visitor).to receive(:visit_empty_list).with(empty_list)
+        expect { empty_list.accept(visitor) }.not_to raise_error
       end
 
-      it 'should return its representation upon inspection' do
+      it 'returns its representation upon inspection' do
         predicted = '<Skeem::SkmEmptyList: ()>'
-        expect(subject.inspect).to eq(predicted)
+        expect(empty_list.inspect).to eq(predicted)
       end
     end # context
   end # describe

data/spec/skeem/skm_frame_spec.rb

@@ -8,111 +8,114 @@ module Skeem
   describe SkmFrame do
     include DatumDSL
 
-    let(:sample_env) { SkmFrame.new }
+    let(:sample_env) { described_class.new }
+
+    subject(:a_frame) { described_class.new }
+
     context 'Initialization:' do
       it 'could be initialized without argument' do
-        expect { SkmFrame.new }.not_to raise_error
+        expect { described_class.new }.not_to raise_error
       end
 
       it 'could be initialized with optional argument' do
-        expect { SkmFrame.new(sample_env) }.not_to raise_error
+        expect { described_class.new(sample_env) }.not_to raise_error
       end
 
-      it 'should have no default bindings' do
-        expect(subject).to be_empty
+      it 'has no default bindings' do
+        expect(a_frame).to be_empty
       end
 
-      it 'should have depth of zero or one' do
-        expect(subject.depth).to be_zero
+      it 'has depth of zero or one' do
+        expect(a_frame.depth).to be_zero
 
-        instance = SkmFrame.new(sample_env)
+        instance = described_class.new(sample_env)
         expect(instance.depth).to eq(1)
       end
     end # context
 
     context 'Provided services:' do
-      it 'should add binding' do
+      it 'adds binding' do
         entry = double('original-dummy')
-        expect(entry).to receive(:bound!).with(subject)
+        allow(entry).to receive(:bound!).with(a_frame)
 
-        subject.add_binding('dummy', entry)
-        expect(subject.size).to eq(1)
-        expect(subject.bindings['dummy']).not_to be_nil
-        expect(subject.bindings['dummy']).to eq(entry)
+        a_frame.add_binding('dummy', entry)
+        expect(a_frame.size).to eq(1)
+        expect(a_frame.bindings['dummy']).not_to be_nil
+        expect(a_frame.bindings['dummy']).to eq(entry)
 
         # A child frame may shadow a parent's variable
-        child = SkmFrame.new(subject)
+        child = described_class.new(a_frame)
         entry2 = double('dummy')
-        expect(entry2).to receive(:bound!).with(child)
+        allow(entry2).to receive(:bound!).with(child)
         child.add_binding(identifier('dummy'), entry2)
 
         expect(child.bindings['dummy']).to eq(entry2)
-        expect(subject.bindings['dummy']).to eq(entry)
+        expect(a_frame.bindings['dummy']).to eq(entry)
       end
 
-      it 'should update bindings' do
+      it 'updates bindings' do
         entry1 = double('dummy')
-        expect(entry1).to receive(:bound!).with(subject)
+        allow(entry1).to receive(:bound!).with(a_frame)
 
         # Case 1: entry defined in this frame
-        subject.add_binding('dummy', entry1)
-        expect(subject.bindings['dummy']).to eq(entry1)
+        a_frame.add_binding('dummy', entry1)
+        expect(a_frame.bindings['dummy']).to eq(entry1)
 
         entry2 = double('still-dummy')
-        expect(entry2).to receive(:bound!).with(subject)
-        subject.update_binding(identifier('dummy'), entry2)
-        expect(subject.bindings['dummy']).to eq(entry2)
+        allow(entry2).to receive(:bound!).with(a_frame)
+        a_frame.update_binding(identifier('dummy'), entry2)
+        expect(a_frame.bindings['dummy']).to eq(entry2)
 
         # Case 2: entry defined in parent frame
-        child = SkmFrame.new(subject)
+        child = described_class.new(a_frame)
         entry3 = double('still-dummy')
-        expect(entry3).to receive(:bound!).with(subject)
+        allow(entry3).to receive(:bound!).with(a_frame)
         child.update_binding('dummy', entry3)
-        expect(subject.bindings['dummy']).to eq(entry3)
+        expect(a_frame.bindings['dummy']).to eq(entry3)
       end
 
-      it 'should retrieve entries' do
+      it 'retrieves entries' do
         # Case 1: non-existing entry
-        expect(subject.fetch('dummy')).to be_nil
+        expect(a_frame.fetch('dummy')).to be_nil
 
         # Case 2: existing entry
         entry = double('dummy')
-        expect(entry).to receive(:bound!).with(subject)
-        subject.add_binding('dummy', entry)
-        expect(subject.fetch('dummy')).to eq(entry)
+        allow(entry).to receive(:bound!).with(a_frame)
+        a_frame.add_binding('dummy', entry)
+        expect(a_frame.fetch('dummy')).to eq(entry)
 
         # Case 3: entry defined in parent frame
-        child = SkmFrame.new(subject)
+        child = described_class.new(a_frame)
         expect(child.fetch(identifier('dummy'))).to eq(entry)
       end
 
-      it 'should know whether it is empty' do
+      it 'knows whether it is empty' do
         # Case 1: no entry
-        expect(subject.empty?).to be_truthy
+        expect(a_frame).to be_empty
 
         # Case 2: existing entry
         entry = double('dummy')
-        expect(entry).to receive(:bound!).with(subject)
-        subject.add_binding('dummy', entry)
-        expect(subject.empty?).to be_falsey
+        allow(entry).to receive(:bound!).with(a_frame)
+        a_frame.add_binding('dummy', entry)
+        expect(a_frame).not_to be_empty
 
         # Case 3: entry defined in parent frame
-        nested = SkmFrame.new(subject)
-        expect(nested.empty?).to be_falsey
+        nested = described_class.new(a_frame)
+        expect(nested).not_to be_empty
       end
 
-      it 'should know the total number of bindings' do
+      it 'knows the total number of bindings' do
         # Case 1: non-existing entry
-        expect(subject.size).to be_zero
+        expect(a_frame.size).to be_zero
 
         # Case 2: existing entry
         entry = double('dummy')
-        expect(entry).to receive(:bound!).with(subject)
-        subject.add_binding('dummy', entry)
-        expect(subject.size).to eq(1)
+        allow(entry).to receive(:bound!).with(a_frame)
+        a_frame.add_binding('dummy', entry)
+        expect(a_frame.size).to eq(1)
 
         # Case 3: entry defined in parent environment
-        nested = SkmFrame.new(subject)
+        nested = described_class.new(a_frame)
         expect(nested.size).to eq(1)
       end
     end # context

data/spec/skeem/skm_pair_spec.rb

@@ -12,44 +12,44 @@ module Skeem
     let(:sample_cdr) { SkmEmptyList.instance }
 
     # Default instance is proper list of length 1
-    subject { SkmPair.new(sample_car, sample_cdr) }
+    subject(:a_pair) { described_class.new(sample_car, sample_cdr) }
 
     context 'Initialization:' do
-      it 'should be initialized with two arguments' do
-        expect { SkmPair.new(sample_car, sample_cdr) }.not_to raise_error
+      it 'is initialized with two arguments' do
+        expect { described_class.new(sample_car, sample_cdr) }.not_to raise_error
       end
 
-      it "should know its 'car' field" do
-        expect(subject.car).to eq(sample_car)
+      it "knows its 'car' field" do
+        expect(a_pair.car).to eq(sample_car)
       end
 
-      it "should know its 'cdr' field" do
-        expect(subject.cdr).to eq(sample_cdr)
+      it "knows its 'cdr' field" do
+        expect(a_pair.cdr).to eq(sample_cdr)
       end
 
       # Default (overridable) behavior of SkmElement
-      it 'should react by default to predicates' do
-        expect(subject).to be_list
-        expect(subject).not_to be_null
-        expect(subject).to be_pair
+      it 'reacts by default to predicates' do
+        expect(a_pair).to be_list
+        expect(a_pair).not_to be_null
+        expect(a_pair).to be_pair
       end
     end # context
 
     context 'Provided services:' do
       let(:runtime) { Runtime.new(SkmFrame.new) }
-      let(:list_length2) { SkmPair.new(integer(10), subject) }
+      let(:list_length2) { described_class.new(integer(10), a_pair) }
       let(:quirk_element) { double('three') }
       let(:quirk_members) { [integer(10), quirk_element] }
 
-      it 'should clone itself' do
-        cloned = subject.klone
-        expect(cloned.car).to eq(subject.car)
-        expect(cloned.cdr).to eq(subject.cdr)
+      it 'clones itself' do
+        cloned = a_pair.klone
+        expect(cloned.car).to eq(a_pair.car)
+        expect(cloned.cdr).to eq(a_pair.cdr)
       end
 
-      it 'should clone a proper list' do
-        pair2 = SkmPair.new(identifier('b'), SkmEmptyList.instance)
-        pair1 = SkmPair.new(identifier('a'), pair2)
+      it 'clones a proper list' do
+        pair2 = described_class.new(identifier('b'), SkmEmptyList.instance)
+        pair1 = described_class.new(identifier('a'), pair2)
 
         cloned = pair1.klone
         expect(cloned.car).to eq(identifier('a'))
@@ -57,9 +57,9 @@ module Skeem
         expect(cloned.cdr.cdr).to be_null
       end
 
-      it 'should clone a improper list' do
-        pair2 = SkmPair.new(identifier('b'), identifier('c'))
-        pair1 = SkmPair.new(identifier('a'), pair2)
+      it 'clones a improper list' do
+        pair2 = described_class.new(identifier('b'), identifier('c'))
+        pair1 = described_class.new(identifier('a'), pair2)
 
         cloned = pair1.klone
         expect(cloned.car).to eq(identifier('a'))
@@ -67,164 +67,164 @@ module Skeem
         expect(cloned.cdr.cdr).to eq(identifier('c'))
       end
 
-      it 'should know its length' do
-        expect(subject.length).to eq(1)
+      it 'knows its length' do
+        expect(a_pair.length).to eq(1)
 
         # Use a list of length 2
         expect(list_length2.length).to eq(2)
       end
 
-      it 'should respond false to `eqv?` message' do
-        expect(subject.eqv?(subject)).to eq(false)
+      it 'responds false to `eqv?` message' do
+        expect(a_pair.eqv?(a_pair)).to be(false)
       end
 
-      it 'should be Skeem equal to itself' do
-        expect(subject.skm_equal?(subject)).to eq(true)
+      it 'is Skeem equal to itself' do
+        expect(a_pair.skm_equal?(a_pair)).to be(true)
       end
 
 
-      it 'should be equal to other pair when their car and cdr match' do
-        instance = SkmPair.new(sample_car, sample_cdr)
-        expect(subject.skm_equal?(instance)).to eq(true)
+      it 'is equal to other pair when their car and cdr match' do
+        instance = described_class.new(sample_car, sample_cdr)
+        expect(a_pair.skm_equal?(instance)).to be(true)
         instance.car = integer(4)
-        expect(subject.skm_equal?(instance)).to eq(false)
+        expect(a_pair.skm_equal?(instance)).to be(false)
         instance.car = sample_car
-        instance.cdr = subject
-        expect(subject.skm_equal?(instance)).to eq(false)
+        instance.cdr = a_pair
+        expect(a_pair.skm_equal?(instance)).to be(false)
       end
 
-      it 'should clone itself after member evaluation' do
-        # subject contains self-evaluating members
-        expect(subject.clone_evaluate(runtime)).to eq(subject)
+      it 'clones itself after member evaluation' do
+        # a_pair contains self-evaluating members
+        expect(a_pair.clone_evaluate(runtime)).to eq(a_pair)
 
         # Make pair improper...
-        subject.cdr = nil
-        expect(subject.clone_evaluate(runtime)).to eq(subject)
+        a_pair.cdr = nil
+        expect(a_pair.clone_evaluate(runtime)).to eq(a_pair)
 
-        subject.cdr = integer(4)
-        expect(subject.clone_evaluate(runtime)).to eq(subject)
+        a_pair.cdr = integer(4)
+        expect(a_pair.clone_evaluate(runtime)).to eq(a_pair)
 
-        successor = SkmPair.new(string('Hi'), boolean(false))
-        subject.cdr = successor
-        expect(subject.clone_evaluate(runtime)).to eq(subject)
+        successor = described_class.new(string('Hi'), boolean(false))
+        a_pair.cdr = successor
+        expect(a_pair.clone_evaluate(runtime)).to eq(a_pair)
       end
 
-      it 'should convert itself into an array' do
-        expect(subject.to_a).to eq([sample_car])
+      it 'concerts itself into an array' do
+        expect(a_pair.to_a).to eq([sample_car])
 
         # Use a list of length 2
         expect(list_length2.to_a).to eq([integer(10), sample_car])
       end
 
-      it 'should return the last pair of a proper list' do
-        expect(subject.last_pair).to eq(subject)
+      it 'returns the last pair of a proper list' do
+        expect(a_pair.last_pair).to eq(a_pair)
 
-        pair2 = SkmPair.new(identifier('b'), SkmEmptyList.instance)
-        pair1 = SkmPair.new(identifier('a'), pair2)
+        pair2 = described_class.new(identifier('b'), SkmEmptyList.instance)
+        pair1 = described_class.new(identifier('a'), pair2)
         expect(pair1.last_pair).to eq(pair1)
       end
 
-      it 'should return the last pair of an improper list' do
-        pair3 = SkmPair.new(identifier('c'), identifier('d'))
-        pair2 = SkmPair.new(identifier('b'), pair3)
-        pair1 = SkmPair.new(identifier('a'), pair2)
+      it 'returns the last pair of an improper list' do
+        pair3 = described_class.new(identifier('c'), identifier('d'))
+        pair2 = described_class.new(identifier('b'), pair3)
+        pair1 = described_class.new(identifier('a'), pair2)
         expect(pair1.last_pair).to eq(pair3)
       end
 
-      it 'should return the last element of a list' do
-         expect(subject.last).to eq(sample_car)
+      it 'returns the last element of a list' do
+         expect(a_pair.last).to eq(sample_car)
          expect(list_length2.last).to eq(sample_car)
       end
 
-      it 'should append a new element to a list' do
-        subject.append(integer(4))
-        expect(subject.length).to eq(2)
-        expect(subject.to_a).to eq([3, 4])
+      it 'appends a new element to a list' do
+        a_pair.append(integer(4))
+        expect(a_pair.length).to eq(2)
+        expect(a_pair.to_a).to eq([3, 4])
       end
 
-      it 'should create a list from an array' do
+      it 'creates a list from an array' do
         # List of length 0
         array0 = []
-        list = SkmPair.create_from_a(array0)
+        list = described_class.create_from_a(array0)
         expect(list).to be_list # It's a proper list...
         expect(list.length).to eq(0)
         expect(list.to_a).to eq(array0)
 
         # List of length 1
         array1 = [boolean(false)]
-        list = SkmPair.create_from_a(array1)
+        list = described_class.create_from_a(array1)
         expect(list).to be_list # It's a proper list...
         expect(list.length).to eq(1)
         expect(list.to_a).to eq(array1)
 
         # List of length 2
         array2 = [identifier('f'), identifier('g')]
-        list = SkmPair.create_from_a(array2)
+        list = described_class.create_from_a(array2)
         expect(list).to be_list # It's a proper list...
         expect(list.length).to eq(2)
         expect(list.to_a).to eq(array2)
 
         # List of length 3
         array3 = [integer(4), integer(5), integer(6)]
-        list = SkmPair.create_from_a(array3)
+        list = described_class.create_from_a(array3)
         expect(list).to be_list # It's a proper list...
         expect(list.length).to eq(3)
         expect(list.to_a).to eq([4, 5, 6])
       end
 
-      it 'should support the each method' do
-        my_list = SkmPair.new('w', SkmPair.new('o', SkmPair.new('w', SkmEmptyList.instance)))
+      it 'supports the each method' do
+        my_list = described_class.new('w', described_class.new('o', described_class.new('w', SkmEmptyList.instance)))
         text = +''
         my_list.each { |ch| text << ch.upcase }
         expect(text).to eq('WOW')
       end
 
-      it 'should implement the verbatim predicate' do
-        expect(subject).to be_verbatim
-        subject.cdr = nil
-        expect(subject).to be_verbatim
-        instance = SkmPair.new(string('Hi'), SkmEmptyList.instance)
-        subject.cdr = instance
-        expect(subject).to be_verbatim
+      it 'implements the verbatim predicate' do
+        expect(a_pair).to be_verbatim
+        a_pair.cdr = nil
+        expect(a_pair).to be_verbatim
+        instance = described_class.new(string('Hi'), SkmEmptyList.instance)
+        a_pair.cdr = instance
+        expect(a_pair).to be_verbatim
         bad_end = double('fake_end')
         instance.cdr = bad_end
-        expect(bad_end).to receive(:verbatim?).and_return(false)
-        expect(subject).not_to be_verbatim
+        allow(bad_end).to receive(:verbatim?).and_return(false)
+        expect(a_pair).not_to be_verbatim
         bad_datum = double('fake-datum')
-        expect(bad_datum).to receive(:verbatim?).and_return(false)
+        allow(bad_datum).to receive(:verbatim?).and_return(false)
         instance.car = bad_datum
-        expect(subject).not_to be_verbatim
+        expect(a_pair).not_to be_verbatim
       end
 
-      it 'should evaluate its members' do
-        # subject contains simple literals
-        expect(subject.evaluate(runtime)).to eq(subject)
+      it 'evaluates its members' do
+        # a_pair contains simple literals
+        expect(a_pair.evaluate(runtime)).to eq(a_pair)
 
         # Check that members receive the 'evaluate' message
-        expect(quirk_element).to receive(:evaluate).with(runtime).and_return(integer(3))
-        instance = SkmPair.create_from_a(quirk_members)
+        allow(quirk_element).to receive(:evaluate).with(runtime).and_return(integer(3))
+        instance = described_class.create_from_a(quirk_members)
         expect { instance.evaluate(runtime) }.not_to raise_error
       end
 
-      it 'should quasiquote its members' do
-        # subject contains simple literals
-        expect(subject.quasiquote(runtime)).to eq(subject)
+      it 'quasiquote its members' do
+        # a_pair contains simple literals
+        expect(a_pair.quasiquote(runtime)).to eq(a_pair)
 
         # Check that members receive the 'quasiquote' message
-        expect(quirk_element).to receive(:quasiquote).with(runtime).and_return(integer(3))
-        instance = SkmPair.create_from_a(quirk_members)
+        allow(quirk_element).to receive(:quasiquote).with(runtime).and_return(integer(3))
+        instance = described_class.create_from_a(quirk_members)
         expect { instance.quasiquote(runtime) }.not_to raise_error
       end
 
-      it "should reply to visitor's 'accept' message" do
+      it "replies to visitor's 'accept' message" do
         visitor = double('fake-visitor')
-        expect(visitor).to receive(:visit_pair).with(subject)
-        expect { subject.accept(visitor) }.not_to raise_error
+        allow(visitor).to receive(:visit_pair).with(a_pair)
+        expect { a_pair.accept(visitor) }.not_to raise_error
       end
 
-      it 'should return its representation upon inspection' do
+      it 'returns its representation upon inspection' do
         predicted = '<Skeem::SkmPair: <Skeem::SkmInteger: 3>>'
-        expect(subject.inspect).to eq(predicted)
+        expect(a_pair.inspect).to eq(predicted)
 
         predicted = '<Skeem::SkmPair: <Skeem::SkmInteger: 10>, <Skeem::SkmInteger: 3>>'
         expect(list_length2.inspect).to eq(predicted)

data/spec/skeem/skm_procedure_exec_spec.rb

@@ -32,32 +32,32 @@ SKEEM
       result.root
     end
 
-    subject { SkmProcedureExec.new(sample_lamb) }
+    subject(:proc_exec) { described_class.new(sample_lamb) }
 
     context 'Initialization:' do
-      it 'should be initialized with one lambda' do
-        expect { SkmProcedureExec.new(sample_lamb) }.not_to raise_error
+      it 'is initialized with one lambda' do
+        expect { described_class.new(sample_lamb) }.not_to raise_error
       end
 
-      it 'should know the definition of the procedure' do
-        expect(subject.definition).to eq(sample_lamb)
+      it 'knows the definition of the procedure' do
+        expect(proc_exec.definition).to eq(sample_lamb)
       end
     end # context
 
     context 'Executing a compound procedure:' do
-      it 'should execute the procedure that is called' do
-        subject
+      it 'executes the procedure that is called' do
+        proc_exec
         call_args = sample_call.operands.to_a
-        result = subject.run!(interpreter.runtime, call_args)
+        result = proc_exec.run!(interpreter.runtime, call_args)
         expect(result).to eq(9)
       end
 
-      it 'should execute the procedure with a procedure call in argument' do
-        subject
+      it 'executes the procedure with a procedure call in argument' do
+        proc_exec
 
         ptree = interpreter.parse('(square (+ (+ 2 1) 2))')
         call_args = ptree.root.operands.to_a
-        result = subject.run!(interpreter.runtime, call_args)
+        result = proc_exec.run!(interpreter.runtime, call_args)
         expect(result).to eq(25)
       end
     end