skeem 0.2.20 → 0.2.22

data/spec/skeem/skm_simple_datum_spec.rb

@@ -5,6 +5,7 @@ require_relative '../spec_helper' # Use the RSpec framework
 require_relative '../../lib/skeem/skm_simple_datum' # Load the classes under test
 
 module Skeem
+  # rubocop: disable Style/OpenStructUse
   describe SkmSimpleDatum do
     let(:pos) { double('fake-position') }
     let(:dummy_symbol) { double('fake-symbol') }
@@ -15,84 +16,85 @@ module Skeem
       obj.lexeme = sample_value
       obj
     end
-    let(:instance) { SkmSimpleDatum.create(3) }
-    subject { SkmSimpleDatum.new(dummy_token, pos) }
+    let(:instance) { described_class.create(3) }
+
+    subject(:datum) { described_class.new(dummy_token, pos) }
 
     context 'Initialization:' do
-      it 'should be initialized with a token and a position' do
-        expect { SkmSimpleDatum.new(dummy_token, pos) }.not_to raise_error
+      it 'is initialized with a token and a position' do
+        expect { described_class.new(dummy_token, pos) }.not_to raise_error
       end
 
       it 'could be created with just a value' do
-        expect { SkmSimpleDatum.create(3) }.not_to raise_error
-        expect(instance).to be_kind_of(SkmSimpleDatum)
+        expect { described_class.create(3) }.not_to raise_error
+        expect(instance).to be_a(described_class)
         expect(instance.value).to eq(3)
       end
 
-      it 'should know its token' do
-        expect(subject.token).to eq(dummy_token)
+      it 'knows its token' do
+        expect(datum.token).to eq(dummy_token)
       end
 
-      it 'should know its value' do
-        expect(subject.value).to eq(sample_value)
+      it 'knows its value' do
+        expect(datum.value).to eq(sample_value)
       end
 
-      it "should know the token's symbol" do
-        expect(subject.symbol).to eq(dummy_symbol)
+      it "knows the token's symbol" do
+        expect(datum.symbol).to eq(dummy_symbol)
       end
     end # context
 
     context 'Provided services:' do
       let(:runtime) { double('fake-runtime') }
 
-      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 value' do
+      it 'asserts the equality by value' do
         # Comparison with other instances
-        expect(instance).to eq(SkmSimpleDatum.create(3))
-        expect(instance).not_to eq(SkmSimpleDatum.create('foo'))
+        expect(instance).to eq(described_class.create(3))
+        expect(instance).not_to eq(described_class.create('foo'))
 
         # Comparison with PORO values
         expect(instance).to eq(3)
         expect(instance).not_to eq('foo')
       end
 
-      it 'should be equivalent to itself' do
-        expect(subject).to be_eqv(subject)
+      it 'is equivalent to itself' do
+        expect(datum).to be_eqv(datum)
       end
 
-      it 'should be equivalent by value' do
-        same = SkmSimpleDatum.create(3)
+      it 'is equivalent by value' do
+        same = described_class.create(3)
         expect(instance).to be_eqv(same)
       end
 
-      it 'should be Skeem equal to itself' do
-        expect(subject).to be_skm_equal(subject)
+      it 'is Skeem equal to itself' do
+        expect(datum).to be_skm_equal(datum)
       end
 
-      it 'should be Skeem equal by value' do
-        same = SkmSimpleDatum.create(3)
+      it 'is Skeem equal by value' do
+        same = described_class.create(3)
         expect(instance).to be_skm_equal(same)
       end
 
-      it 'should be self-evaluating' do
-        expect(subject.evaluate(runtime)).to be_equal(subject)
+      it 'is self-evaluating' do
+        expect(datum.evaluate(runtime)).to equal(datum)
       end
 
-      it 'should be self-quasiquoting' do
-        expect(subject.quasiquote(runtime)).to be_equal(subject)
+      it 'is self-quasiquoting' do
+        expect(datum.quasiquote(runtime)).to equal(datum)
       end
 
-      it 'should return its text representation' do
-        expect(subject.inspect).to eq('<Skeem::SkmSimpleDatum: sample-value>')
+      it 'returns its text representation' do
+        expect(datum.inspect).to eq('<Skeem::SkmSimpleDatum: sample-value>')
       end
 
-      it 'should respond to visitor' do
+      it 'responds to visitor' do
         visitor = double('fake-visitor')
-        expect(visitor).to receive(:visit_simple_datum).with(subject)
-        expect { subject.accept(visitor) }.not_to raise_error
+        allow(visitor).to receive(:visit_simple_datum).with(datum)
+        expect { datum.accept(visitor) }.not_to raise_error
       end
     end # context
   end # describe
@@ -107,21 +109,22 @@ module Skeem
       obj.lexeme = sample_value
       obj
     end
-    subject { SkmBoolean.new(dummy_token, pos) }
+
+    subject(:boolean) { described_class.new(dummy_token, pos) }
 
     context 'Initialization:' do
-      it 'should be initialized with a token and a position' do
-        expect { SkmBoolean.new(dummy_token, pos) }.not_to raise_error
+      it 'is initialized with a token and a position' do
+        expect { described_class.new(dummy_token, pos) }.not_to raise_error
       end
 
-      it 'should react positively to boolean? predicate' do
-        expect(subject).to be_boolean
+      it 'reacts positively to boolean? predicate' do
+        expect(boolean).to be_boolean
       end
     end # context
 
     context 'Provided services:' do
-      it 'should return its text representation' do
-        expect(subject.inspect).to eq('<Skeem::SkmBoolean: false>')
+      it 'returns its text representation' do
+        expect(boolean.inspect).to eq('<Skeem::SkmBoolean: false>')
       end
     end # context
   end # describe
@@ -136,21 +139,22 @@ module Skeem
       obj.lexeme = sample_value
       obj
     end
-    subject { SkmNumber.new(dummy_token, pos) }
+
+    subject(:number) { described_class.new(dummy_token, pos) }
 
     context 'Initialization:' do
-      it 'should be initialized with a token and a position' do
-        expect { SkmNumber.new(dummy_token, pos) }.not_to raise_error
+      it 'is initialized with a token and a position' do
+        expect { described_class.new(dummy_token, pos) }.not_to raise_error
       end
     end # context
 
     context 'Provided services:' do
-      it 'should react positively to number? predicate' do
-        expect(subject).to be_number
+      it 'reacts positively to number? predicate' do
+        expect(number).to be_number
       end
 
-      it 'should return its text representation' do
-        expect(subject.inspect).to eq('<Skeem::SkmNumber: 0.51>')
+      it 'returns its text representation' do
+        expect(number.inspect).to eq('<Skeem::SkmNumber: 0.51>')
       end
     end # context
   end # describe
@@ -165,28 +169,29 @@ module Skeem
       obj.lexeme = sample_value
       obj
     end
-    subject { SkmReal.new(dummy_token, pos) }
+
+    subject(:real) { described_class.new(dummy_token, pos) }
 
     context 'Provided services:' do
-      it 'should react positively to number? predicate' do
-        expect(subject).to be_number
+      it 'reacts positively to number? predicate' do
+        expect(real).to be_number
       end
 
-      it 'should react positively to real? predicate' do
-        expect(subject).to be_real
+      it 'reacts positively to real? predicate' do
+        expect(real).to be_real
       end
 
-      it 'should react negatively to exact? predicate' do
-        expect(subject).not_to be_exact
+      it 'reacts negatively to exact? predicate' do
+        expect(real).not_to be_exact
       end
 
-      it 'should implement the eqv? predicate' do
-        same = SkmReal.create(0.51)
-        different = SkmReal.create(1.21)
+      it 'implements the eqv? predicate' do
+        same = described_class.create(0.51)
+        different = described_class.create(1.21)
 
-        expect(subject).to be_eqv(subject)
-        expect(subject).to be_eqv(same)
-        expect(subject).not_to be_eqv(different)
+        expect(real).to be_eqv(real)
+        expect(real).to be_eqv(same)
+        expect(real).not_to be_eqv(different)
       end
     end # context
   end # describe
@@ -201,33 +206,34 @@ module Skeem
       obj.lexeme = sample_value
       obj
     end
-    subject { SkmInteger.new(dummy_token, pos) }
+
+    subject(:integer) { described_class.new(dummy_token, pos) }
 
     context 'Provided services:' do
-      it 'should react positively to number? predicate' do
-        expect(subject).to be_number
+      it 'reacts positively to number? predicate' do
+        expect(integer).to be_number
       end
 
-      it 'should react positively to real? predicate' do
-        expect(subject).to be_real
+      it 'reacts positively to real? predicate' do
+        expect(integer).to be_real
       end
 
-      it 'should react positively to integer? predicate' do
-        expect(subject).to be_real
+      it 'reacts positively to integer? predicate' do
+        expect(integer).to be_real
       end
 
-      it 'should react positively to exact? predicate' do
-        expect(subject).to be_exact
+      it 'reacts positively to exact? predicate' do
+        expect(integer).to be_exact
       end
 
-      it 'should implement the eqv? predicate' do
-        three = SkmInteger.create(3)
+      it 'implements the eqv? predicate' do
+        three = described_class.create(3)
         real3 = SkmReal.create(3.0)
-        four = SkmInteger.create(4)
+        four = described_class.create(4)
 
-        expect(subject).to be_eqv(three)
-        expect(subject).not_to be_eqv(real3)
-        expect(subject).not_to be_eqv(four)
+        expect(integer).to be_eqv(three)
+        expect(integer).not_to be_eqv(real3)
+        expect(integer).not_to be_eqv(four)
       end
     end # context
   end # describe
@@ -242,15 +248,16 @@ module Skeem
       obj.lexeme = sample_value
       obj
     end
-    subject { SkmString.new(dummy_token, pos) }
+
+    subject(:string) { described_class.new(dummy_token, pos) }
 
     context 'Provided services:' do
-      it 'should react positively to string? predicate' do
-        expect(subject).to be_string
+      it 'reacts positively to string? predicate' do
+        expect(string).to be_string
       end
 
-      it 'should return its text representation' do
-        expect(subject.inspect).to eq('<Skeem::SkmString: Hello>')
+      it 'returns its text representation' do
+        expect(string.inspect).to eq('<Skeem::SkmString: Hello>')
       end
     end # context
   end # describe
@@ -265,37 +272,39 @@ module Skeem
       obj.lexeme = sample_value
       obj
     end
-    subject { SkmIdentifier.new(dummy_token, pos) }
+
+    subject(:identifier) { described_class.new(dummy_token, pos) }
 
     context 'Provided services:' do
       it 'could be initialized with a token and a position' do
-        expect { SkmIdentifier.new(dummy_token, pos) }.not_to raise_error
+        expect { described_class.new(dummy_token, pos) }.not_to raise_error
       end
 
       it 'could be initialized with a token, a position and a flag' do
-        expect { SkmIdentifier.new(dummy_token, pos, true) }.not_to raise_error
+        expect { described_class.new(dummy_token, pos, true) }.not_to raise_error
       end
 
-      it 'should know whether it is used as a variable name' do
-        expect(subject.is_var_name).to eq(false)
+      it 'knows whether it is used as a variable name' do
+        expect(identifier.is_var_name).to be(false)
 
-        instance = SkmIdentifier.new(dummy_token, pos, true)
-        expect(instance.is_var_name).to eq(true)
+        instance = described_class.new(dummy_token, pos, true)
+        expect(instance.is_var_name).to be(true)
       end
 
-      it 'should react positively to symbol? predicate' do
-        expect(subject).to be_symbol
+      it 'reacts positively to symbol? predicate' do
+        expect(identifier).to be_symbol
       end
 
-      it 'should react to verbatim? predicate' do
-        expect(subject).to be_verbatim
-        instance = SkmIdentifier.new(dummy_token, pos, true)
+      it 'reacts to verbatim? predicate' do
+        expect(identifier).to be_verbatim
+        instance = described_class.new(dummy_token, pos, true)
         expect(instance).not_to be_verbatim
       end
 
-      it 'should return its text representation' do
-        expect(subject.inspect).to eq('<Skeem::SkmIdentifier: this-is-it!>')
+      it 'returns its text representation' do
+        expect(identifier.inspect).to eq('<Skeem::SkmIdentifier: this-is-it!>')
       end
     end # context
   end # describe
+  # rubocop: enable Style/OpenStructUse
 end # module

data/spec/skeem/skm_unary_expression_spec.rb

@@ -10,23 +10,23 @@ module Skeem
     let(:pos) { double('fake-position') }
     let(:sample_child) { double('fake-child') }
 
-    subject { SkmUnaryExpression.new(pos, sample_child) }
+    subject(:unary_expr) { described_class.new(pos, sample_child) }
 
     context 'Initialization:' do
-      it 'should be initialized with a position and a child element' do
-        expect { SkmUnaryExpression.new(pos, sample_child) }.not_to raise_error
+      it 'is initialized with a position and a child element' do
+        expect { described_class.new(pos, sample_child) }.not_to raise_error
       end
 
-      it 'should know its child' do
-        expect(subject.child).to eq(sample_child)
+      it 'knows its child' do
+        expect(unary_expr.child).to eq(sample_child)
       end
     end # context
 
     context 'Provided basic services:' do
-      it 'should respond to visitor' do
+      it 'responds to visitor' do
         visitor = double('fake-visitor')
-        expect(visitor).to receive(:visit_unary_expression).with(subject)
-        expect { subject.accept(visitor) }.not_to raise_error
+        expect(visitor).to receive(:visit_unary_expression).with(unary_expr)
+        expect { unary_expr.accept(visitor) }.not_to raise_error
       end
     end # context
   end # describe
@@ -36,42 +36,42 @@ module Skeem
 
     let(:sample_literal) { string('foo') }
 
-    subject { SkmQuotation.new(sample_literal) }
+    subject(:quotation) { described_class.new(sample_literal) }
 
     context 'Initialization:' do
-      it 'should be initialized with a Skeem element' do
-        expect { SkmQuotation.new(sample_literal) }.not_to raise_error
+      it 'is initialized with a Skeem element' do
+        expect { described_class.new(sample_literal) }.not_to raise_error
       end
 
-      it 'should know its datum' do
-        expect(subject.datum).to be_equal(sample_literal)
-        expect(subject.datum).to be_equal(subject.child)
+      it 'knows its datum' do
+        expect(quotation.datum).to equal(sample_literal)
+        expect(quotation.datum).to equal(quotation.child)
       end
     end # context
 
     context 'Provided services:' do
       let(:runtime) { Runtime.new(SkmFrame.new) }
 
-      # it 'should return the child(datum) at evaluation' do
-        # expect(subject.evaluate(runtime)).to be_equal(subject.child)
+      # it 'returns the child(datum) at evaluation' do
+        # expect(unary_expr.evaluate(runtime)).to equal(unary_expr.child)
       # end
 
-      it 'should implement quasiquotation' do
+      it 'implements quasiquotation' do
         # Case 1: child is idempotent with quasiquote
-        expect(subject.quasiquote(runtime)).to be_equal(subject)
+        expect(quotation.quasiquote(runtime)).to equal(quotation)
 
         # Case 2: quasiquoted child is different
         child = double('fake-child')
-        expect(child).to receive(:quasiquote).with(runtime).and_return(integer(3))
-        instance = SkmQuasiquotation.new(child)
+        allow(child).to receive(:quasiquote).with(runtime).and_return(integer(3))
+        instance = described_class.new(child)
         expect(instance.child).to eq(child)
         quasi_result = instance.quasiquote(runtime)
-        expect(quasi_result).to eq(3)
+        expect(quasi_result.child.value).to eq(3)
       end
 
-      it 'should return its text representation' do
+      it 'returns its text representation' do
         txt1 = '<Skeem::SkmQuotation: <Skeem::SkmString: foo>>'
-        expect(subject.inspect).to eq(txt1)
+        expect(quotation.inspect).to eq(txt1)
       end
     end # context
   end # describe
@@ -82,79 +82,78 @@ module Skeem
 
     let(:sample_literal) { string('foo') }
 
-    subject { SkmQuasiquotation.new(sample_literal) }
+    subject(:quasiquote) { described_class.new(sample_literal) }
 
     context 'Initialization:' do
-      it 'should be initialized with a Skeem element' do
-        expect { SkmQuasiquotation.new(sample_literal) }.not_to raise_error
+      it 'is initialized with a Skeem element' do
+        expect { described_class.new(sample_literal) }.not_to raise_error
       end
     end # context
 
     context 'Provided services:' do
       let(:runtime) { Runtime.new(SkmFrame.new) }
 
-      it 'should return the child(template) at evaluation' do
-        expect(subject.evaluate(runtime)).to be_equal(subject.child)
+      it 'returns the child(template) at evaluation' do
+        expect(quasiquote.evaluate(runtime)).to equal(quasiquote.child)
       end
 
-      it 'should accept quasiquotation' do
+      it 'accepts quasiquotation' do
         # Case 1: child is idempotent with quasiquote
-        expect(subject.quasiquote(runtime)).to be_equal(subject.child)
+        expect(quasiquote.quasiquote(runtime)).to equal(quasiquote.child)
 
         # Case 2: quasiquoted child is different
         child = double('fake-child')
-        expect(child).to receive(:quasiquote).with(runtime).and_return(integer(3))
-        instance = SkmQuotation.new(child)
+        allow(child).to receive(:quasiquote).with(runtime).and_return(integer(3))
+        instance = described_class.new(child)
         expect(instance.child).to eq(child)
         quasi_result = instance.quasiquote(runtime)
-        expect(quasi_result.child).to eq(3)
+        expect(quasi_result).to eq(3)
       end
 
-      it 'should return its text representation' do
+      it 'returns its text representation' do
         txt1 = '<Skeem::SkmQuasiquotation: <Skeem::SkmString: foo>>'
-        expect(subject.inspect).to eq(txt1)
+        expect(quasiquote.inspect).to eq(txt1)
       end
     end # context
   end # describe
 
-
   describe SkmUnquotation do
     include DatumDSL
 
     let(:sample_literal) { string('foo') }
 
-    subject { SkmUnquotation.new(sample_literal) }
+    subject(:unquote) { described_class.new(sample_literal) }
 
     context 'Initialization:' do
-      it 'should be initialized with a Skeem element' do
-        expect { SkmUnquotation.new(sample_literal) }.not_to raise_error
+      it 'is initialized with a Skeem element' do
+        expect { described_class.new(sample_literal) }.not_to raise_error
       end
     end # context
 
     context 'Provided services:' do
       let(:runtime) { Runtime.new(SkmFrame.new) }
 
-      it 'should return the child(template) at evaluation' do
-        expect(subject.evaluate(runtime)).to be_equal(subject.child)
+      it 'returns the child(template) at evaluation' do
+        expect(unquote.evaluate(runtime)).to equal(unquote.child)
       end
 
-      it 'should accept quasiquotation' do
+      it 'accepts quasiquotation' do
         # Case 1: child is idempotent with evaluate
-        expect(subject.quasiquote(runtime)).to be_equal(subject.child)
+        expect(unquote.quasiquote(runtime)).to equal(unquote.child)
 
         # Case 2: quasiquoted child is different
         child = double('fake-child')
-        expect(child).to receive(:unquoted!)
-        expect(child).to receive(:evaluate).with(runtime).and_return(integer(3))
-        instance = SkmUnquotation.new(child)
+        allow(child).to receive(:unquoted!)
+        allow(child).to receive(:evaluate).with(runtime).and_return(integer(3))
+        instance = described_class.new(child)
         expect(instance.child).to eq(child)
         quasi_result = instance.quasiquote(runtime)
         expect(quasi_result).to eq(3)
       end
 
-      it 'should return its text representation' do
+      it 'returns its text representation' do
         txt1 = '<Skeem::SkmUnquotation: <Skeem::SkmString: foo>>'
-        expect(subject.inspect).to eq(txt1)
+        expect(unquote.inspect).to eq(txt1)
       end
     end # context
   end # describe
@@ -165,37 +164,37 @@ module Skeem
     let(:pos) { double('fake-position') }
     let(:sample_var) { identifier('three') }
 
-    subject { SkmVariableReference.new(pos, sample_var) }
+    subject(:var_ref) { described_class.new(pos, sample_var) }
 
     context 'Initialization:' do
-      it 'should be initialized with a position and a symbol' do
-        expect { SkmVariableReference.new(pos, sample_var) }.not_to raise_error
+      it 'is initialized with a position and a symbol' do
+        expect { described_class.new(pos, sample_var) }.not_to raise_error
       end
 
-      it 'should know its variable' do
-        expect(subject.variable).to be_equal(sample_var)
-        expect(subject.variable).to be_equal(subject.child)
+      it 'knows its variable' do
+        expect(var_ref.variable).to equal(sample_var)
+        expect(var_ref.variable).to equal(var_ref.child)
       end
     end # context
 
     context 'Provided services:' do
       let(:runtime) { Runtime.new(SkmFrame.new) }
 
-      before(:each) do
+      before do
         runtime.add_binding('three', integer(3))
       end
 
-      it "should return the variable's value at evaluation" do
-        expect(subject.evaluate(runtime)).to eq(3)
+      it "returns the variable's value at evaluation" do
+        expect(var_ref.evaluate(runtime)).to eq(3)
       end
 
-      it 'should return itself at quasiquotation' do
-        expect(subject.quasiquote(runtime)).to be_equal(subject)
+      it 'returns itself at quasiquotation' do
+        expect(var_ref.quasiquote(runtime)).to equal(var_ref)
       end
 
-      it 'should return its text representation' do
+      it 'returns its text representation' do
         txt1 = '<Skeem::SkmVariableReference: <Skeem::SkmIdentifier: three>>'
-        expect(subject.inspect).to eq(txt1)
+        expect(var_ref.inspect).to eq(txt1)
       end
     end # context
   end # describe