skeem 0.2.21 → 0.2.22

data/spec/skeem/primitive/primitive_procedure_spec.rb

@@ -29,66 +29,66 @@ module Skeem
         ->(_runtime, operands) { operands.length }
       end
 
-      subject { PrimitiveProcedure.new('cube', unary, cube) }
+      subject(:primitive) { described_class.new('cube', unary, cube) }
 
-      before(:each) { @passing = false }
+      before { @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
+        it 'is initialized with a name, arity and a lambda' do
+          expect { described_class.new('newline', nullary, newline_code) }.not_to raise_error
         end
 
-        it 'should know its name' do
-          expect(subject.identifier.value).to eq('cube')
+        it 'knows its name' do
+          expect(primitive.identifier.value).to eq('cube')
         end
 
-        it 'should know its arity' do
-          expect(subject.arity).to eq([1, 1])
+        it 'knows its arity' do
+          expect(primitive.arity).to eq([1, 1])
         end
 
-        it 'should know its lambda' do
-          expect(subject.code).to eq(cube)
+        it 'knows its lambda' do
+          expect(primitive.code).to eq(cube)
         end
 
-        it 'should complain if third argument is not a lambda' do
+        it 'complains if third argument is not a lambda' do
           kode = proc { 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)
+          expect { described_class.new('newline', nullary, kode) }.to raise_error(err, err_msg)
         end
 
-        it 'should complain if third argument is a nullary lambda' do
+        it 'complains 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)
+          expect { described_class.new('newline', nullary, kode) }.to raise_error(err, err_msg)
         end
 
-        it 'should complain when arity and parameter count mismatch' do
+        it 'complains 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)
+          expect { described_class.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)
+          expect { described_class.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 { described_class.new('cube', zero_or_more, cube) }.not_to raise_error
 
-          expect { PrimitiveProcedure.new('cube', unary, cube) }.not_to raise_error
+          expect { described_class.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)
+          expect { described_class.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)
+        it 'supports Skeem nullary procedure' do
+          pproc = described_class.new('newline', nullary, newline_code)
           rtime = double('fake-runtime')
 
           expect(pproc.call(rtime, [])).to eq("\n")
@@ -99,8 +99,8 @@ module Skeem
           expect { pproc.call(rtime, ['superfluous']) }.to raise_error(err, ms1 + ms2)
         end
 
-        it 'should support Skeem unary procedure' do
-          pproc = PrimitiveProcedure.new('cube', unary, cube)
+        it 'supports Skeem unary procedure' do
+          pproc = described_class.new('cube', unary, cube)
           rtime = double('fake-runtime')
 
           args = [SkmInteger.create(3)]
@@ -118,8 +118,8 @@ module Skeem
           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)
+        it 'supports Skeem binary procedure' do
+          pproc = described_class.new('sum', binary, sum)
           rtime = double('fake-runtime')
 
           args = [SkmInteger.create(3), SkmInteger.create(5)]
@@ -138,8 +138,8 @@ module Skeem
           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)
+        it 'supports Skeem variadic procedure' do
+          pproc = described_class.new('length', zero_or_more, length)
           rtime = double('fake-runtime')
 
           args = [SkmInteger.create(3), SkmInteger.create(5)]

data/spec/skeem/runtime_spec.rb

@@ -12,79 +12,80 @@ module Skeem
     include DatumDSL
 
     let(:some_env) { SkmFrame.new }
-    subject { Runtime.new(some_env) }
+
+    subject(:runtime) { described_class.new(some_env) }
 
     context 'Initialization:' do
-      it 'should be initialized with an environment' do
-        expect { Runtime.new(SkmFrame.new) }.not_to raise_error
+      it 'is initialized with an environment' do
+        expect { described_class.new(SkmFrame.new) }.not_to raise_error
       end
 
-      it 'should know the environment' do
-        expect(subject.environment).to eq(some_env)
+      it 'knows the environment' do
+        expect(runtime.environment).to eq(some_env)
       end
 
-      it 'should have an empty call stack' do
-        expect(subject.call_stack).to be_empty
+      it 'has an empty call stack' do
+        expect(runtime.call_stack).to be_empty
       end
     end # context
 
     context 'Provided services:' do
-      it 'should add entries to the environment' do
+      it 'adds entries to the environment' do
         entry = double('dummy')
-        expect(entry).to receive(:bound!)
-        subject.add_binding('dummy', entry)
-        expect(subject.environment.size).to eq(1)
+        allow(entry).to receive(:bound!)
+        runtime.add_binding('dummy', entry)
+        expect(runtime.environment.size).to eq(1)
       end
 
-      it 'should know the keys in the environment' do
-        expect(subject.include?('dummy')).to be_falsey
+      it 'knows the keys in the environment' do
+        expect(runtime).not_to include('dummy')
         entry = double('dummy')
-        expect(entry).to receive(:bound!)
-        subject.add_binding('dummy', entry)
-        expect(subject.include?('dummy')).to be_truthy
+        allow(entry).to receive(:bound!)
+        runtime.add_binding('dummy', entry)
+        expect(runtime).to include('dummy')
       end
     end # context
 
     context 'Evaluation:' do
       include Primitive::PrimitiveBuilder
 
-      # it 'should evaluate a given entry' do
+      # it 'evaluates a given entry' do
         # entry = integer(3)
         # result = double('fake-procedure')
-        # expect(entry).to receive(:expression).and_return(result)
-        # expect(result).to receive(:evaluate).with(subject).and_return(integer(3))
-        # subject.define('three', entry)
-        # expect(subject.evaluate('three')).to eq(3)
+        # expect(entry).to have_received(:expression).and_return(result)
+        # expect(result).to have_received(:evaluate).with(runtime).and_return(integer(3))
+        # runtime.define('three', entry)
+        # expect(runtime.evaluate('three')).to eq(3)
       # end
 
-      it 'should evaluate a given list' do
-        add_primitives(subject)
+      it 'evaluates a given list' do
+        add_primitives(runtime)
         sum = list([identifier('+'), 3, 4])
 
-        expect(subject.evaluate_form(sum)).to eq(7)
+        expect(runtime.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)
+      it 'adds nested environment' do
+        expect(runtime.depth).to eq(1)
+        env_before = runtime.environment
+        runtime.nest
+
+        expect(runtime.environment).not_to eq(env_before)
+        expect(runtime.environment.parent).to eq(env_before)
+        expect(runtime.depth).to eq(2)
       end
 
-      it 'should remove nested environment' do
-        expect(subject.depth).to eq(1)
-        subject.nest
-        parent_before = subject.environment.parent
-        expect(subject.depth).to eq(2)
+      it 'removes nested environment' do
+        expect(runtime.depth).to eq(1)
+        runtime.nest
+        parent_before = runtime.environment.parent
+        expect(runtime.depth).to eq(2)
 
-        subject.unnest
-        expect(subject.environment).to eq(parent_before)
-        expect(subject.depth).to eq(1)
+        runtime.unnest
+        expect(runtime.environment).to eq(parent_before)
+        expect(runtime.depth).to eq(1)
       end
     end # context
 
@@ -94,23 +95,23 @@ module Skeem
         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.caller).to eq(sample_call)
+      it 'pushes a call to the stack call' do
+        expect { runtime.push_call(sample_call) }.not_to raise_error
+        expect(runtime.call_stack.size).to eq(1)
+        expect(runtime.caller).to eq(sample_call)
 
-        subject.push_call(sample_call.clone)
-        expect(subject.call_stack.size).to eq(2)
+        runtime.push_call(sample_call.clone)
+        expect(runtime.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
+      it 'pops a call from the call stack' do
+        runtime.push_call(sample_call)
+        expect { runtime.pop_call }.not_to raise_error
+        expect(runtime.call_stack).to be_empty
 
         err = StandardError
         msg = 'Skeem call stack empty!'
-        expect { subject.pop_call }.to raise_error(err, msg)
+        expect { runtime.pop_call }.to raise_error(err, msg)
       end
     end # context
   end # describe

data/spec/skeem/s_expr_nodes_spec.rb

@@ -12,27 +12,27 @@ module Skeem
     let(:operator) { SkmIdentifier.create('+') }
     let(:operands) { [1, 2, 3] }
 
-    subject { ProcedureCall.new(pos, operator, operands) }
+    subject(:proc_call) { described_class.new(pos, operator, operands) }
 
     context 'Initialization:' do
-      it 'should be initialized with an operator symbol and its operands' do
-        expect { ProcedureCall.new(pos, operator, operands) }.not_to raise_error
+      it 'is initialized with an operator symbol and its operands' do
+        expect { described_class.new(pos, operator, operands) }.not_to raise_error
       end
 
-      it 'should know its operator' do
-        expect(subject.operator).to eq(operator)
+      it 'knows its operator' do
+        expect(proc_call.operator).to eq(operator)
       end
 
-      it 'should know its operands' do
-        expect(subject.operands.inspect).to eq('<Skeem::SkmPair: 1, 2, 3>')
+      it 'knows its operands' do
+        expect(proc_call.operands.inspect).to eq('<Skeem::SkmPair: 1, 2, 3>')
       end
     end # context
 
     context 'Provided services:' do
-      it 'should return its text representation' do
+      it 'returns its text representation' do
         txt1 = '<Skeem::ProcedureCall: <Skeem::SkmIdentifier: +>, '
         txt2 = '@operands <Skeem::SkmPair: 1, 2, 3>>'
-        expect(subject.inspect).to eq(txt1 + txt2)
+        expect(proc_call.inspect).to eq(txt1 + txt2)
       end
     end # context
   end # describe
@@ -43,32 +43,32 @@ module Skeem
     let(:s_consequent) { double('fake-consequent') }
     let(:s_alt) { double('fake-alternate') }
 
-    subject { SkmCondition.new(pos, s_test, s_consequent, s_alt) }
+    subject(:condition) { described_class.new(pos, s_test, s_consequent, s_alt) }
 
     context 'Initialization:' do
-      it 'should be initialized with a pos and 3 expressions' do
-        expect { SkmCondition.new(pos, s_test, s_consequent, s_alt) }.not_to raise_error
+      it 'is initialized with a pos and 3 expressions' do
+        expect { described_class.new(pos, s_test, s_consequent, s_alt) }.not_to raise_error
       end
 
-      it 'should know its test' do
-        expect(subject.test).to eq(s_test)
+      it 'knows its test' do
+        expect(condition.test).to eq(s_test)
       end
 
-      it 'should know its consequent' do
-        expect(subject.consequent).to eq(s_consequent)
+      it 'knows its consequent' do
+        expect(condition.consequent).to eq(s_consequent)
       end
 
-      it 'should know its alternate' do
-        expect(subject.alternate).to eq(s_alt)
+      it 'knows its alternate' do
+        expect(condition.alternate).to eq(s_alt)
       end
     end # context
 
     context 'Provided services:' do
-      it 'should return its text representation' do
+      it 'returns its text representation' do
         txt1 = '<Skeem::SkmCondition: @test #<Double "fake-test">, '
         txt2 = '@consequent #<Double "fake-consequent">, '
         txt3 = '@alternate #<Double "fake-alternate">>'
-        expect(subject.inspect).to eq(txt1 + txt2 + txt3)
+        expect(condition.inspect).to eq(txt1 + txt2 + txt3)
       end
     end # context
   end # describe
@@ -80,33 +80,33 @@ module Skeem
     let(:s_sequence) { double('fake-sequence') }
     let(:s_body) { { defs: s_defs, sequence: s_sequence } }
 
-    subject { SkmLambdaRep.new(pos, s_formals, s_body) }
+    subject(:lambda_rep) { described_class.new(pos, s_formals, s_body) }
 
     context 'Initialization:' do
-      it 'should be initialized with a pos and 3 expressions' do
-        expect { SkmLambdaRep.new(pos, s_formals, s_body) }.not_to raise_error
+      it 'is initialized with a pos and 3 expressions' do
+        expect { described_class.new(pos, s_formals, s_body) }.not_to raise_error
       end
 
-      it 'should know its formals' do
-        expect(subject.formals).to eq(s_formals)
+      it 'knows its formals' do
+        expect(lambda_rep.formals).to eq(s_formals)
       end
 
-      it 'should know its definitions' do
-        expect(subject.definitions).to eq(s_defs)
+      it 'knows its definitions' do
+        expect(lambda_rep.definitions).to eq(s_defs)
       end
 
-      it 'should know its sequence' do
-        expect(subject.sequence).to eq(s_sequence)
+      it 'knows its sequence' do
+        expect(lambda_rep.sequence).to eq(s_sequence)
       end
     end # context
 
     context 'Provided services:' do
-      it 'should return its text representation' do
+      it 'returns its text representation' do
         txt1 = '<Skeem::SkmLambdaRep: @formals #<Double "fake-formals">, '
         txt2 = '@definitions #<Double "fake-definitions">, '
         txt3 = '@sequence #<Double "fake-sequence">>>'
         # Remove "unpredictable" part of actual text
-        expectation = subject.inspect.gsub(/@object_id=[0-9a-z]+, /, '')
+        expectation = lambda_rep.inspect.gsub(/@object_id=[0-9a-z]+, /, '')
         expect(expectation).to eq(txt1 + txt2 + txt3)
       end
     end # context

data/spec/skeem/skm_compound_datum_spec.rb

@@ -8,49 +8,49 @@ module Skeem
   describe SkmCompoundDatum do
     include DatumDSL
 
-    let(:sample_members) { [1, 2, 3] }
     let(:sample_members) { [integer(1), integer(2), integer(3)] }
-    subject { SkmCompoundDatum.new(sample_members) }
+
+    subject(:datum) { described_class.new(sample_members) }
 
     context 'Initialization:' do
-      it 'should be initialized with its members' do
-        expect { SkmCompoundDatum.new(sample_members) }.not_to raise_error
+      it 'is initialized with its members' do
+        expect { described_class.new(sample_members) }.not_to raise_error
       end
 
-      it 'should know its members' do
-        expect(subject.members).to eq(sample_members)
+      it 'knows its members' do
+        expect(datum.members).to eq(sample_members)
 
-        other = SkmCompoundDatum.new([])
+        other = described_class.new([])
         expect(other.members).to be_empty
       end
     end # context
 
     context 'Provided basic services:' do
-      it 'should assert that it is equal to itself' do
-        expect(subject).to eq(subject)
+      it 'asserts that it is equal to itself' do
+        expect(datum).to eq(datum)
       end
 
-      it 'should assert the equality by member values' do
+      it 'asserts the equality by member values' do
         # Comparison with other instances
-        expect(subject).to eq(SkmCompoundDatum.new(sample_members))
-        expect(subject).not_to eq(SkmCompoundDatum.new([]))
-        expect(subject).not_to eq(SkmCompoundDatum.new(sample_members.rotate))
+        expect(datum).to eq(described_class.new(sample_members))
+        expect(datum).not_to eq(described_class.new([]))
+        expect(datum).not_to eq(described_class.new(sample_members.rotate))
 
         # Comparison with array of values
-        expect(subject).to eq(sample_members)
-        expect(subject).not_to eq(sample_members.rotate)
+        expect(datum).to eq(sample_members)
+        expect(datum).not_to eq(sample_members.rotate)
       end
 
-      it 'should respond to visitor' do
+      it 'responds to visitor' do
         visitor = double('fake-visitor')
-        expect(visitor).to receive(:visit_compound_datum).with(subject)
-        expect { subject.accept(visitor) }.not_to raise_error
+        allow(visitor).to receive(:visit_compound_datum).with(datum)
+        expect { datum.accept(visitor) }.not_to raise_error
       end
 
-      it 'should return its text representation' do
+      it 'returns its text representation' do
         txt1 = '<Skeem::SkmCompoundDatum: <Skeem::SkmInteger: 1>,'
         txt2 = '<Skeem::SkmInteger: 2>, <Skeem::SkmInteger: 3>>'
-        expect(subject.inspect).to eq("#{txt1} #{txt2}")
+        expect(datum.inspect).to eq("#{txt1} #{txt2}")
       end
     end # context
 
@@ -59,39 +59,40 @@ module Skeem
       let(:quirk_members) { [integer(1), quirk_datum, integer(3)] }
       let(:runtime) { double('fake-runtime') }
 
-      it 'should evaluate its members' do
+      it 'evaluates its members' do
         # subject contains simple literals
-        expect(subject.evaluate(runtime)).to eq(subject)
+        expect(datum.evaluate(runtime)).to eq(datum)
 
         # Check that members receive the 'evaluate' message
-        expect(quirk_datum).to receive(:evaluate).with(runtime).and_return(integer(2))
-        instance = SkmCompoundDatum.new(quirk_members)
-        expect(instance.evaluate(runtime)).to eq(subject)
+        allow(quirk_datum).to receive(:evaluate).with(runtime).and_return(integer(2))
+        instance = described_class.new(quirk_members)
+        expect(instance.evaluate(runtime)).to eq(datum)
       end
 
-      it 'should quasiquoting its members' do
+      it 'quasiquotes its members' do
         # subject contains simple literals
-        expect(subject.quasiquote(runtime)).to eq(subject)
+        expect(datum.quasiquote(runtime)).to eq(datum)
 
         # Check that members receive the 'quasiquote' message
-        expect(quirk_datum).to receive(:quasiquote).with(runtime).and_return(integer(2))
-        instance = SkmCompoundDatum.new(quirk_members)
-        expect(instance.quasiquote(runtime)).to eq(subject)
+        allow(quirk_datum).to receive(:quasiquote).with(runtime).and_return(integer(2))
+        instance = described_class.new(quirk_members)
+        expect(instance.quasiquote(runtime)).to eq(datum)
       end
     end # context
   end # describe
 
   describe SkmVector do
     let(:sample_members) { [1, 2, 3] }
-    subject { SkmVector.new(sample_members) }
+
+    subject(:vector) { described_class.new(sample_members) }
 
     context 'Initialization:' do
-      it 'should be initialized with its members' do
-        expect { SkmVector.new(sample_members) }.not_to raise_error
+      it 'is initialized with its members' do
+        expect { described_class.new(sample_members) }.not_to raise_error
       end
 
-      it 'should react positively to vector? predicate' do
-        expect(subject).to be_vector
+      it 'reacts positively to vector? predicate' do
+        expect(vector).to be_vector
       end
     end # context
   end # describe

data/spec/skeem/skm_element_spec.rb

@@ -6,30 +6,31 @@ require_relative '../../lib/skeem/skm_element' # Load the class under test
 module Skeem
   describe SkmElement do
     let(:pos) { double('fake-position') }
-    subject { SkmElement.new(pos) }
+
+    subject(:element) { described_class.new(pos) }
 
     context 'Initialization:' do
-      it 'should be initialized with a position' do
-        expect { SkmElement.new(pos) }.not_to raise_error
+      it 'is initialized with a position' do
+        expect { described_class.new(pos) }.not_to raise_error
       end
 
-      it 'should know its position' do
-        expect(subject.position).to eq(pos)
+      it 'knows its position' do
+        expect(element.position).to eq(pos)
       end
 
       # Default (overridable) behavior of SkmElement
-      it 'should react by default to predicates' do
-        expect(subject).not_to be_boolean
-        expect(subject).not_to be_number
-        expect(subject).not_to be_real
-        expect(subject).not_to be_integer
-        expect(subject).not_to be_string
-        expect(subject).not_to be_symbol
-        expect(subject).not_to be_list
-        expect(subject).not_to be_null
-        expect(subject).not_to be_pair
-        expect(subject).not_to be_vector
-        expect(subject).not_to be_verbatim
+      it 'reacts by default to predicates' do
+        expect(element).not_to be_boolean
+        expect(element).not_to be_number
+        expect(element).not_to be_real
+        expect(element).not_to be_integer
+        expect(element).not_to be_string
+        expect(element).not_to be_symbol
+        expect(element).not_to be_list
+        expect(element).not_to be_null
+        expect(element).not_to be_pair
+        expect(element).not_to be_vector
+        expect(element).not_to be_verbatim
       end
     end # context
 
@@ -38,38 +39,38 @@ module Skeem
       let(:visitor) { double('fake-visitor') }
       let(:not_implemented) { NotImplementedError }
 
-      it 'should be equivalent to itself' do
-        expect(subject).to be_eqv(subject)
-        expect(subject).not_to be_eqv(subject.clone)
+      it 'is equivalent to itself' do
+        expect(element).to be_eqv(element)
+        expect(element).not_to be_eqv(element.clone)
       end
 
-      it "should ignore the 'done!' message" do
-        expect { subject.done! }.not_to raise_error
+      it "ignores the 'done!' message" do
+        expect { element.done! }.not_to raise_error
       end
 
-      it "should ignore the 'quoted!' message" do
-        expect { subject.quoted! }.not_to raise_error
+      it "ignores the 'quoted!' message" do
+        expect { element.quoted! }.not_to raise_error
       end
 
-      it "should ignore the 'unquoted!' message" do
-        expect { subject.unquoted! }.not_to raise_error
+      it "ignores the 'unquoted!' message" do
+        expect { element.unquoted! }.not_to raise_error
       end
 
-      it "should complain when receiving 'skm_equal?' message" do
+      it "complains when receiving 'skm_equal?' message" do
         msg = 'Missing implementation of method Skeem::SkmElement#skm_equal?'
-        expect { subject.skm_equal?('omg') }.to raise_error(NotImplementedError, msg)
+        expect { element.skm_equal?('omg') }.to raise_error(NotImplementedError, msg)
       end
 
-      it "should complain when receiving 'evaluate' message" do
-        expect { subject.evaluate(runtime) }.to raise_error(not_implemented)
+      it "complains when receiving 'evaluate' message" do
+        expect { element.evaluate(runtime) }.to raise_error(not_implemented)
       end
 
-      it "should complain when receiving 'quasiquote' message" do
-        expect { subject.quasiquote(runtime) }.to raise_error(not_implemented)
+      it "complains when receiving 'quasiquote' message" do
+        expect { element.quasiquote(runtime) }.to raise_error(not_implemented)
       end
 
-      it "should complain when receiving 'accept' message" do
-        expect { subject.accept(visitor) }.to raise_error(not_implemented)
+      it "complains when receiving 'accept' message" do
+        expect { element.accept(visitor) }.to raise_error(not_implemented)
       end
     end # context
   end # describe