loxxy 0.4.09 → 0.4.10

data/spec/back_end/environment_spec.rb

@@ -10,8 +10,9 @@ module Loxxy
     describe Environment do
       let(:foo) { Datatype::LXString.new('foo') }
       let(:bar) { Datatype::LXString.new('bar') }
-      let(:mother) { Environment.new }
-      subject { Environment.new(mother) }
+      let(:mother) { described_class.new }
+
+      subject(:an_environ) { described_class.new(mother) }
 
       # Shortand factory method.
       def var(aName, aValue)
@@ -20,38 +21,38 @@ module Loxxy
 
       context 'Initialization:' do
         it 'could be initialized without argument' do
-          expect { Environment.new }.not_to raise_error
+          expect { described_class.new }.not_to raise_error
         end
 
         it 'could be initialized with a parent environment' do
-          expect { Environment.new(mother) }.not_to raise_error
+          expect { described_class.new(mother) }.not_to raise_error
         end
 
-        it "shouldn't have definitions by default" do
-          expect(subject.defns).to be_empty
+        it "doesn't have definitions by default" do
+          expect(an_environ.defns).to be_empty
         end
 
-        it 'should know its parent (if any)' do
-          expect(subject.enclosing).to eq(mother)
+        it 'knows its parent (if any)' do
+          expect(an_environ.enclosing).to eq(mother)
         end
       end # context
 
       context 'Provided services:' do
-        it 'should accept the addition of a variable' do
-          subject.insert(var('a', foo))
-          expect(subject.defns).not_to be_empty
-          var_a = subject.defns['a']
-          expect(var_a).to be_kind_of(Variable)
+        it 'accepts the addition of a variable' do
+          an_environ.insert(var('a', foo))
+          expect(an_environ.defns).not_to be_empty
+          var_a = an_environ.defns['a']
+          expect(var_a).to be_a(Variable)
           expect(var_a.name).to eq('a')
         end
 
-        it 'should accept the addition of multiple variables' do
-          subject.insert(var('a', foo))
-          expect(subject.defns).not_to be_empty
+        it 'accepts the addition of multiple variables' do
+          an_environ.insert(var('a', foo))
+          expect(an_environ.defns).not_to be_empty
 
-          subject.insert(var('b', bar))
-          var_b = subject.defns['b']
-          expect(var_b).to be_kind_of(Variable)
+          an_environ.insert(var('b', bar))
+          var_b = an_environ.defns['b']
+          expect(var_b).to be_a(Variable)
           expect(var_b.name).to eq('b')
         end
       end # context

data/spec/back_end/symbol_table_spec.rb

@@ -9,25 +9,25 @@ require_relative '../../lib/loxxy/back_end/symbol_table'
 module Loxxy
   module BackEnd
     describe SymbolTable do
-      subject { SymbolTable.new }
+      subject(:symb_table) { described_class.new }
 
       context 'Initialization:' do
-        it 'should be initialized without argument' do
-          expect { SymbolTable.new }.not_to raise_error
+        it 'is initialized without argument' do
+          expect { described_class.new }.not_to raise_error
         end
 
-        it 'should have a root BackEnd' do
-          expect(subject.root).not_to be_nil
-          expect(subject.current_env).to eq(subject.root)
-          expect(subject.root).to be_kind_of(BackEnd::Environment)
+        it 'has a root BackEnd' do
+          expect(symb_table.root).not_to be_nil
+          expect(symb_table.current_env).to eq(symb_table.root)
+          expect(symb_table.root).to be_a(BackEnd::Environment)
         end
 
-        it "shouldn't have names at initialization" do
-          expect(subject.name2envs).to be_empty
+        it "doesn't have names at initialization" do
+          expect(symb_table.name2envs).to be_empty
         end
 
-        it 'should be empty at initialization' do
-          expect(subject).to be_empty
+        it 'is empty at initialization' do
+          expect(symb_table).to be_empty
         end
       end # context
 
@@ -36,85 +36,85 @@ module Loxxy
           Variable.new(aName)
         end
 
-        it 'should allow the addition of a variable' do
-          expect { subject.insert(var('q')) }.not_to raise_error
-          expect(subject).not_to be_empty
-          expect(subject.name2envs['q']).to be_kind_of(Array)
-          expect(subject.name2envs['q'].size).to eq(1)
-          expect(subject.name2envs['q'].first).to eq(subject.current_env)
-          expect(subject.current_env.defns['q']).to be_kind_of(BackEnd::Variable)
+        it 'allows the addition of a variable' do
+          expect { symb_table.insert(var('q')) }.not_to raise_error
+          expect(symb_table).not_to be_empty
+          expect(symb_table.name2envs['q']).to be_a(Array)
+          expect(symb_table.name2envs['q'].size).to eq(1)
+          expect(symb_table.name2envs['q'].first).to eq(symb_table.current_env)
+          expect(symb_table.current_env.defns['q']).to be_a(BackEnd::Variable)
         end
 
-        it 'should allow the addition of several labels for same env' do
-          subject.insert(var('q'))
+        it 'allows the addition of several labels for same env' do
+          symb_table.insert(var('q'))
           # expect(i_name).to match(/^q_[0-9a-z]*$/)
 
-          expect { subject.insert(var('x')) }.not_to raise_error
-          expect(subject.name2envs['x']).to be_kind_of(Array)
-          expect(subject.name2envs['x'].first).to eq(subject.current_env)
-          expect(subject.current_env.defns['x']).to be_kind_of(BackEnd::Variable)
+          expect { symb_table.insert(var('x')) }.not_to raise_error
+          expect(symb_table.name2envs['x']).to be_a(Array)
+          expect(symb_table.name2envs['x'].first).to eq(symb_table.current_env)
+          expect(symb_table.current_env.defns['x']).to be_a(BackEnd::Variable)
         end
 
-        it 'should allow the entry into a new scope' do
-          subject.insert(var('q'))
+        it 'allows the entry into a new scope' do
+          symb_table.insert(var('q'))
           new_env = BackEnd::Environment.new
-          expect { subject.enter_environment(new_env) }.not_to raise_error
-          expect(subject.current_env).to eq(new_env)
-          expect(subject.current_env.enclosing).to eq(subject.root)
-          expect(subject.name2envs['q']).to eq([subject.root])
+          expect { symb_table.enter_environment(new_env) }.not_to raise_error
+          expect(symb_table.current_env).to eq(new_env)
+          expect(symb_table.current_env.enclosing).to eq(symb_table.root)
+          expect(symb_table.name2envs['q']).to eq([symb_table.root])
         end
 
-        it 'should allow the addition of same name in different scopes' do
-          subject.insert(var('q'))
-          subject.enter_environment(BackEnd::Environment.new)
-          subject.insert(var('q'))
-          expect(subject.name2envs['q']).to be_kind_of(Array)
-          expect(subject.name2envs['q'].size).to eq(2)
-          expect(subject.name2envs['q'].first).to eq(subject.root)
-          expect(subject.name2envs['q'].last).to eq(subject.current_env)
-          expect(subject.current_env.defns['q']).to be_kind_of(BackEnd::Variable)
+        it 'allows the addition of same name in different scopes' do
+          symb_table.insert(var('q'))
+          symb_table.enter_environment(BackEnd::Environment.new)
+          symb_table.insert(var('q'))
+          expect(symb_table.name2envs['q']).to be_a(Array)
+          expect(symb_table.name2envs['q'].size).to eq(2)
+          expect(symb_table.name2envs['q'].first).to eq(symb_table.root)
+          expect(symb_table.name2envs['q'].last).to eq(symb_table.current_env)
+          expect(symb_table.current_env.defns['q']).to be_a(BackEnd::Variable)
         end
 
-        it 'should allow the removal of a scope' do
-          subject.insert(var('q'))
+        it 'allows the removal of a scope' do
+          symb_table.insert(var('q'))
           new_env = BackEnd::Environment.new
-          subject.enter_environment(new_env)
-          subject.insert(var('q'))
-          expect(subject.name2envs['q'].size).to eq(2)
-
-          expect { subject.leave_environment }.not_to raise_error
-          expect(subject.current_env).to eq(subject.root)
-          expect(subject.name2envs['q'].size).to eq(1)
-          expect(subject.name2envs['q']).to eq([subject.root])
+          symb_table.enter_environment(new_env)
+          symb_table.insert(var('q'))
+          expect(symb_table.name2envs['q'].size).to eq(2)
+
+          expect { symb_table.leave_environment }.not_to raise_error
+          expect(symb_table.current_env).to eq(symb_table.root)
+          expect(symb_table.name2envs['q'].size).to eq(1)
+          expect(symb_table.name2envs['q']).to eq([symb_table.root])
         end
 
-        it 'should allow the search of an entry based on its name' do
-          subject.insert(var('q'))
-          subject.insert(var('x'))
-          subject.enter_environment(BackEnd::Environment.new)
-          subject.insert(var('q'))
-          subject.insert(var('y'))
+        it 'allows the search of an entry based on its name' do
+          symb_table.insert(var('q'))
+          symb_table.insert(var('x'))
+          symb_table.enter_environment(BackEnd::Environment.new)
+          symb_table.insert(var('q'))
+          symb_table.insert(var('y'))
 
           # Search for unknown name
-          expect(subject.lookup('z')).to be_nil
+          expect(symb_table.lookup('z')).to be_nil
 
           # Search for existing unique names
-          expect(subject.lookup('y')).to eq(subject.current_env.defns['y'])
-          expect(subject.lookup('x')).to eq(subject.root.defns['x'])
+          expect(symb_table.lookup('y')).to eq(symb_table.current_env.defns['y'])
+          expect(symb_table.lookup('x')).to eq(symb_table.root.defns['x'])
 
           # Search for redefined name
-          expect(subject.lookup('q')).to eq(subject.current_env.defns['q'])
+          expect(symb_table.lookup('q')).to eq(symb_table.current_env.defns['q'])
         end
 
-        it 'should list all the variables defined in all the szcope chain' do
-          subject.insert(var('q'))
-          subject.enter_environment(BackEnd::Environment.new)
-          subject.insert(var('x'))
-          subject.enter_environment(BackEnd::Environment.new)
-          subject.insert(var('y'))
-          subject.insert(var('x'))
+        it 'lists all the variables defined in all the szcope chain' do
+          symb_table.insert(var('q'))
+          symb_table.enter_environment(BackEnd::Environment.new)
+          symb_table.insert(var('x'))
+          symb_table.enter_environment(BackEnd::Environment.new)
+          symb_table.insert(var('y'))
+          symb_table.insert(var('x'))
 
-          vars = subject.all_variables
+          vars = symb_table.all_variables
           expect(vars.map(&:name)).to eq(%w[q x y x])
         end
       end # context

data/spec/back_end/variable_spec.rb

@@ -11,31 +11,32 @@ module Loxxy
     describe Variable do
       let(:sample_name) { 'iAmAVariable' }
       let(:sample_value) { 'here is my value' }
-      subject { Variable.new(sample_name, sample_value) }
+
+      subject(:a_var) { described_class.new(sample_name, sample_value) }
 
       context 'Initialization:' do
-        it 'should be initialized with a name and a value, or...' do
-          expect { Variable.new(sample_name, sample_value) }.not_to raise_error
+        it 'is initialized with a name and a value, or...' do
+          expect { described_class.new(sample_name, sample_value) }.not_to raise_error
         end
 
-        it 'should be initialized with just a name' do
-          expect { Variable.new(sample_name) }.not_to raise_error
+        it 'is initialized with just a name' do
+          expect { described_class.new(sample_name) }.not_to raise_error
         end
 
-        it 'should know its name' do
-          expect(subject.name).to eq(sample_name)
+        it 'knows its name' do
+          expect(a_var.name).to eq(sample_name)
         end
 
-        it 'should have a frozen name' do
-          expect(subject.name).to be_frozen
+        it 'has a frozen name' do
+          expect(a_var.name).to be_frozen
         end
 
-        it 'should know its value (if provided)' do
-          expect(subject.value).to eq(sample_value)
+        it 'knows its value (if provided)' do
+          expect(a_var.value).to eq(sample_value)
         end
 
-        it 'should have a nil value otherwise' do
-          instance = Variable.new(sample_name)
+        it 'has a nil value otherwise' do
+          instance = described_class.new(sample_name)
           expect(instance.value).to eq(Datatype::Nil.instance)
         end
       end # context

data/spec/datatype/boolean_spec.rb

@@ -8,22 +8,23 @@ require_relative '../../lib/loxxy/datatype/boolean'
 module Loxxy
   module Datatype
     describe Boolean do
-      let(:thruth_value) { false }
-      subject { Boolean.new(thruth_value) }
+      let(:truth_value) { false }
+
+      subject(:a_boolean) { described_class.new(truth_value) }
 
       context 'Initialization:' do
-        it 'should accept a boolean value at initialization' do
-          expect { Boolean.new(thruth_value) }.not_to raise_error
+        it 'accepts a boolean value at initialization' do
+          expect { described_class.new(truth_value) }.not_to raise_error
         end
 
-        it 'should know its value' do
-          expect(subject.value).to eq(thruth_value)
+        it 'knows its value' do
+          expect(a_boolean.value).to eq(truth_value)
         end
       end
 
       context 'Provided services:' do
-        it 'should give its display representation' do
-          expect(subject.to_str).to eq('false')
+        it 'gives its display representation' do
+          expect(a_boolean.to_str).to eq('false')
         end
       end
     end # describe

data/spec/datatype/lx_string_spec.rb

@@ -9,53 +9,54 @@ module Loxxy
   module Datatype
     describe LXString do
       let(:sample_text) { 'some_text' }
-      subject { LXString.new(sample_text) }
+
+      subject(:a_string) { described_class.new(sample_text) }
 
       context 'Initialization:' do
-        it 'should accept a String value at initialization' do
-          expect { LXString.new(sample_text) }.not_to raise_error
+        it 'accepts a String value at initialization' do
+          expect { described_class.new(sample_text) }.not_to raise_error
         end
 
-        it 'should know its value' do
-          expect(subject.value).to eq(sample_text)
+        it 'knows its value' do
+          expect(a_string.value).to eq(sample_text)
         end
       end
 
       context 'Provided services:' do
-        it 'should give its display representation' do
-          expect(subject.to_str).to eq(sample_text)
+        it 'gives its display representation' do
+          expect(a_string.to_str).to eq(sample_text)
         end
 
         # rubocop: disable Lint/BinaryOperatorWithIdenticalOperands
         it 'compares with another Lox string' do
-          result = subject == LXString.new(sample_text.dup)
+          result = a_string == described_class.new(sample_text.dup)
           expect(result).to be_true
 
-          result = subject == LXString.new('other-text')
+          result = a_string == described_class.new('other-text')
           expect(result).to be_false
 
-          result = subject == LXString.new('')
+          result = a_string == described_class.new('')
           expect(result).to be_false
 
           # Two empty strings are equal
-          result = LXString.new('') == LXString.new('')
+          result = described_class.new('') == described_class.new('')
           expect(result).to be_true
         end
         # rubocop: enable Lint/BinaryOperatorWithIdenticalOperands
 
         it 'compares with a Ruby string' do
-          result = subject == sample_text.dup
+          result = a_string == sample_text.dup
           expect(result).to be_true
 
-          result = subject == 'other-text'
+          result = a_string == 'other-text'
           expect(result).to be_false
 
-          result = subject == ''
+          result = a_string == ''
           expect(result).to be_false
         end
 
         it 'performs the concatenation with another string' do
-          concatenation = LXString.new('str') + LXString.new('ing')
+          concatenation = described_class.new('str') + described_class.new('ing')
           expect(concatenation == 'string').to be_true
         end
       end

data/spec/datatype/nil_spec.rb

@@ -8,17 +8,17 @@ require_relative '../../lib/loxxy/datatype/boolean'
 module Loxxy
   module Datatype
     describe Nil do
-      subject { Nil.instance }
+      subject(:nil_literal) { described_class.instance }
 
       context 'Initialization:' do
-        it 'should know its value' do
-          expect(subject.value).to be_nil
+        it 'knows its value' do
+          expect(nil_literal.value).to be_nil
         end
       end
 
       context 'Provided services:' do
-        it 'should give its display representation' do
-          expect(subject.to_str).to eq('nil')
+        it 'gives its display representation' do
+          expect(nil_literal.to_str).to eq('nil')
         end
       end
     end # describe

data/spec/datatype/number_spec.rb

@@ -9,47 +9,48 @@ module Loxxy
   module Datatype
     describe Number do
       let(:sample_value) { -12.34 }
-      subject { Number.new(sample_value) }
+
+      subject(:num_val) { described_class.new(sample_value) }
 
       context 'Initialization:' do
-        it 'should accept a Numeric value at initialization' do
-          expect { Number.new(sample_value) }.not_to raise_error
+        it 'accepts a Numeric value at initialization' do
+          expect { described_class.new(sample_value) }.not_to raise_error
         end
 
-        it 'should know its value' do
-          expect(subject.value).to eq(sample_value)
+        it 'knows its value' do
+          expect(num_val.value).to eq(sample_value)
         end
       end
 
       # rubocop: disable Lint/FloatComparison
       context 'Provided services:' do
-        it 'should compare with other Lox numbers' do
-          result = subject == Number.new(sample_value)
+        it 'compares with other Lox numbers' do
+          result = num_val == described_class.new(sample_value)
           expect(result).to be_true
 
-          result = subject == Number.new(5)
+          result = num_val == described_class.new(5)
           expect(result).to be_false
         end
 
-        it 'should compare with Ruby numbers' do
-          result = subject == sample_value
+        it 'compares with Ruby numbers' do
+          result = num_val == sample_value
           expect(result).to be_true
 
-          result = subject == 5
+          result = num_val == 5
           expect(result).to be_false
         end
 
-        it 'should give its display representation' do
-          expect(subject.to_str).to eq(sample_value.to_s)
+        it 'gives its display representation' do
+          expect(num_val.to_str).to eq(sample_value.to_s)
         end
 
-        it 'should compute the addition with another number' do
-          addition = subject + Number.new(10)
+        it 'computes the addition with another number' do
+          addition = num_val + described_class.new(10)
           expect(addition == -2.34).to be_true
         end
 
-        it 'should compute the subtraction with another number' do
-          subtraction = subject - Number.new(10)
+        it 'computes the subtraction with another number' do
+          subtraction = num_val - described_class.new(10)
           expect(subtraction == -22.34).to be_true
         end
       end # context