rley 0.8.14 → 0.9.01

data/spec/rley/lexical/literal_spec.rb

@@ -16,14 +16,14 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       context 'Initialization:' do
         # Default instantiation rule
-        subject { Literal.new(lexeme.to_f, lexeme, a_terminal, a_pos) }
+        subject(:a_literal) { described_class.new(lexeme.to_f, lexeme, a_terminal, a_pos) }
 
-        it 'should be created with a value, lexeme, terminal and position' do
-          expect { Literal.new(lexeme.to_f, lexeme, a_terminal, a_pos) }.not_to raise_error
+        it 'is created with a value, lexeme, terminal and position' do
+          expect { described_class.new(lexeme.to_f, lexeme, a_terminal, a_pos) }.not_to raise_error
         end
 
-        it 'should know its value' do
-          expect(subject.value).to eq(lexeme.to_f)
+        it 'knows its value' do
+          expect(a_literal.value).to eq(lexeme.to_f)
         end
       end # context
     end # describe

data/spec/rley/lexical/token_range_spec.rb

@@ -11,87 +11,87 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       let(:sample_range) { { low: 0, high: 5 } }
 
       # Default instantiation rule
-      subject { TokenRange.new(sample_range) }
+      subject(:a_range) { described_class.new(sample_range) }
 
       context 'Initialization:' do
-        it 'could be created with a range Hash' do
+        it 'is created with a range Hash' do
           # No bounds provided
-          expect { TokenRange.new({}) }.not_to raise_error
+          expect { described_class.new({}) }.not_to raise_error
 
           # Low bound provided
-          expect { TokenRange.new(low: 0) }.not_to raise_error
+          expect { described_class.new(low: 0) }.not_to raise_error
 
           # High bound provided
-          expect { TokenRange.new(high: 5) }.not_to raise_error
+          expect { described_class.new(high: 5) }.not_to raise_error
 
           # Both bounds provided
-          expect { TokenRange.new(low: 0, high: 5) }.not_to raise_error
+          expect { described_class.new(low: 0, high: 5) }.not_to raise_error
         end
 
-        it 'could be created with another TokenRange' do
+        it 'is created with another TokenRange' do
           # Low bound provided
-          instance = TokenRange.new(low: 0)
-          expect { TokenRange.new(instance) }.not_to raise_error
+          instance = described_class.new(low: 0)
+          expect { described_class.new(instance) }.not_to raise_error
 
           # High bound provided
-          instance = TokenRange.new(high: 5)
-          expect { TokenRange.new(instance) }.not_to raise_error
+          instance = described_class.new(high: 5)
+          expect { described_class.new(instance) }.not_to raise_error
 
           # Both bounds provided
-          instance = TokenRange.new(low: 0, high: 5)
-          expect { TokenRange.new(instance) }.not_to raise_error
+          instance = described_class.new(low: 0, high: 5)
+          expect { described_class.new(instance) }.not_to raise_error
         end
 
-        it 'should know its low bound' do
-          expect(subject.low).to eq(0)
+        it 'knows its low bound' do
+          expect(a_range.low).to eq(0)
         end
 
-        it 'should know its low bound' do
-          expect(subject.high).to eq(5)
+        it 'knows its high bound' do
+          expect(a_range.high).to eq(5)
         end
       end # context
 
       context 'Provided services:' do
-        it 'should compare to another range' do
-          me = subject
-          expect(subject == me).to eq(true)
-          equal = TokenRange.new(low: 0, high: 5)
-          expect(subject == equal).to eq(true)
-          # expect(subject == [0..5]).to eq(true)
-          expect(subject == [0, 5]).to eq(true)
+        it 'compares to another range' do
+          me = a_range
+          expect(a_range == me).to be(true)
+          equal = described_class.new(low: 0, high: 5)
+          expect(a_range == equal).to be(true)
+          # expect(a_range == [0..5]).to be(true)
+          expect(a_range == [0, 5]).to be(true)
         end
 
 
-        it 'should know whether it is bounded or not' do
-          expect(subject).to be_bounded
+        it 'knows whether it is bounded or not' do
+          expect(a_range).to be_bounded
 
           # Case: only low bound is set
-          instance = TokenRange.new(low: 0)
+          instance = described_class.new(low: 0)
           expect(instance).not_to be_bounded
 
           # Case: only upper bound is set
-          instance = TokenRange.new(high: 5)
+          instance = described_class.new(high: 5)
           expect(instance).not_to be_bounded
 
           # No bound is set
-          instance = TokenRange.new({})
+          instance = described_class.new({})
           expect(instance).not_to be_bounded
         end
 
-        it 'should assign its open bounds' do
+        it 'assigns its open bounds' do
           some_range = { low: 1, high: 4 }
 
           ###########
           # Case of bounded token range...
-          subject.assign(some_range)
+          a_range.assign(some_range)
 
           # ... should be unchanged
-          expect(subject.low).to eq(sample_range[:low])
-          expect(subject.high).to eq(sample_range[:high])
+          expect(a_range.low).to eq(sample_range[:low])
+          expect(a_range.high).to eq(sample_range[:high])
 
           ###########
           # Case: only low bound is set
-          instance = TokenRange.new(low: 0)
+          instance = described_class.new(low: 0)
           instance.assign(some_range)
 
           # Expectation: high is assigned the new value
@@ -101,7 +101,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
           ###########
           # Case: only high bound is set
-          instance = TokenRange.new(high: 5)
+          instance = described_class.new(high: 5)
           instance.assign(some_range)
 
           # Expectation: low is assigned the new value
@@ -111,7 +111,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
           ###########
           # Case: no bound is set
-          instance = TokenRange.new({})
+          instance = described_class.new({})
           instance.assign(some_range)
 
           # Expectation: low is assigned the new value
@@ -120,48 +120,48 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(instance.high).to eq(4)
         end
 
-        it 'should tell whether an index value lies outside the range' do
+        it 'tells whether an index value lies outside the range' do
           # Out of range...
-          expect(subject.out_of_range?(-1)).to eq(true)
-          expect(subject.out_of_range?(6)).to eq(true)
+          expect(a_range.out_of_range?(-1)).to be(true)
+          expect(a_range.out_of_range?(6)).to be(true)
 
           # On boundaries...
-          expect(subject.out_of_range?(0)).to eq(false)
-          expect(subject.out_of_range?(5)).to eq(false)
+          expect(a_range.out_of_range?(0)).to be(false)
+          expect(a_range.out_of_range?(5)).to be(false)
 
           # Inside boundaries
-          expect(subject.out_of_range?(2)).to eq(false)
+          expect(a_range.out_of_range?(2)).to be(false)
 
-          instance = TokenRange.new(low: nil, high: 5)
+          instance = described_class.new(low: nil, high: 5)
 
           # Lower bound is nil
-          expect(instance.out_of_range?(-1)).to eq(false)
-          expect(instance.out_of_range?(5)).to eq(false)
-          expect(instance.out_of_range?(6)).to eq(true)
+          expect(instance.out_of_range?(-1)).to be(false)
+          expect(instance.out_of_range?(5)).to be(false)
+          expect(instance.out_of_range?(6)).to be(true)
 
-          instance = TokenRange.new(low: 0, high: nil)
+          instance = described_class.new(low: 0, high: nil)
 
           # Upper bound is nil
-          expect(instance.out_of_range?(-1)).to eq(true)
-          expect(instance.out_of_range?(0)).to eq(false)
-          expect(instance.out_of_range?(6)).to eq(false)
+          expect(instance.out_of_range?(-1)).to be(true)
+          expect(instance.out_of_range?(0)).to be(false)
+          expect(instance.out_of_range?(6)).to be(false)
         end
 
-        it 'should provide a text representation of itself' do
+        it 'provides a text representation of itself' do
           # Case 1: not bound is set
-          instance = TokenRange.new({})
+          instance = described_class.new({})
           expect(instance.to_string(0)).to eq('[?, ?]')
 
           # Case: only low bound is set
-          instance = TokenRange.new(low: 0)
+          instance = described_class.new(low: 0)
           expect(instance.to_string(0)).to eq('[0, ?]')
 
           # Case: only upper bound is set
-          instance = TokenRange.new(high: 5)
+          instance = described_class.new(high: 5)
           expect(instance.to_string(0)).to eq('[?, 5]')
 
           # Case: both bounds are set
-          instance = TokenRange.new(low: 0, high: 5)
+          instance = described_class.new(low: 0, high: 5)
           expect(instance.to_string(0)).to eq('[0, 5]')
         end
       end

data/spec/rley/lexical/token_spec.rb

@@ -10,39 +10,40 @@ require_relative '../../../lib/rley/lexical/token'
 module Rley # Open this namespace to avoid module qualifier prefixes
   module Lexical # Open this namespace to avoid module qualifier prefixes
     describe Token do
+      # Default instantiation rule
+      subject(:a_token) { described_class.new(lexeme, a_terminal, a_pos) }
+
       let(:lexeme) { '"some text"' }
       let(:a_terminal) { Syntax::Terminal.new('if') }
       let(:a_pos) { Position.new(3, 4) }
-      # Default instantiation rule
-      subject { Token.new(lexeme, a_terminal, a_pos) }
 
       context 'Initialization:' do
-        it 'could be created with a lexeme and a terminal ' do
-          expect { Token.new(lexeme, a_terminal) }.not_to raise_error
+        it 'is created with a lexeme and a terminal' do
+          expect { described_class.new(lexeme, a_terminal) }.not_to raise_error
         end
 
-        it 'could be created with a lexeme, a terminal and position' do
-          expect { Token.new(lexeme, a_terminal, a_pos) }.not_to raise_error
+        it 'is created with a lexeme, a terminal and position' do
+          expect { described_class.new(lexeme, a_terminal, a_pos) }.not_to raise_error
         end
 
-        it 'should know its lexeme' do
-          expect(subject.lexeme).to eq(lexeme)
+        it 'knows its lexeme' do
+          expect(a_token.lexeme).to eq(lexeme)
         end
 
-        it 'should know its terminal' do
-          expect(subject.terminal).to eq(a_terminal)
+        it 'knows its terminal' do
+          expect(a_token.terminal).to eq(a_terminal)
         end
 
-        it 'should know its position' do
+        it 'knows its position' do
           new_pos = Position.new(5, 7)
-          subject.position = new_pos
-          expect(subject.position).to eq(new_pos)
+          a_token.position = new_pos
+          expect(a_token.position).to eq(new_pos)
         end
       end # context
 
-      context 'Initialization:' do
-        it 'should accept a new position' do
-          expect(subject.position).to eq(a_pos)
+      context 'Provided services:' do
+        it 'accepts a new position' do
+          expect(a_token.position).to eq(a_pos)
         end
       end # context
     end # describe

data/spec/rley/parse_forest_visitor_spec.rb

@@ -25,6 +25,9 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       return Rley::SPPF::NonTerminalNode.new(a_vertex.non_terminal, aRange)
     end
 
+    # Default instantiation rule
+    subject(:a_visitor) { described_class.new(forest_root) }
+
     let(:grammar_sppf) do
       builder = grammar_sppf_builder
       builder.grammar
@@ -53,22 +56,17 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       factory.create
     end
 
-
-    # Default instantiation rule
-    subject { ParseForestVisitor.new(forest_root) }
-
-
     context 'Standard creation & initialization:' do
-      it 'should be initialized with a parse forest argument' do
-        expect { ParseForestVisitor.new(forest_root) }.not_to raise_error
+      it 'is initialized with a parse forest argument' do
+        expect { described_class.new(forest_root) }.not_to raise_error
       end
 
-      it 'should know the parse forest to visit' do
-        expect(subject.pforest).to eq(forest_root)
+      it 'knows the parse forest to visit' do
+        expect(a_visitor.pforest).to eq(forest_root)
       end
 
-      it "shouldn't have subscribers at start" do
-        expect(subject.subscribers).to be_empty
+      it "doesn't have subscribers at start" do
+        expect(a_visitor.subscribers).to be_empty
       end
     end # context
 
@@ -77,24 +75,24 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       let(:listener1) { double('fake-subscriber1') }
       let(:listener2) { double('fake-subscriber2') }
 
-      it 'should allow subscriptions' do
-        subject.subscribe(listener1)
-        expect(subject.subscribers.size).to eq(1)
-        expect(subject.subscribers).to eq([listener1])
+      it 'allows subscriptions' do
+        a_visitor.subscribe(listener1)
+        expect(a_visitor.subscribers.size).to eq(1)
+        expect(a_visitor.subscribers).to eq([listener1])
 
-        subject.subscribe(listener2)
-        expect(subject.subscribers.size).to eq(2)
-        expect(subject.subscribers).to eq([listener1, listener2])
+        a_visitor.subscribe(listener2)
+        expect(a_visitor.subscribers.size).to eq(2)
+        expect(a_visitor.subscribers).to eq([listener1, listener2])
       end
 
-      it 'should allow un-subcriptions' do
-        subject.subscribe(listener1)
-        subject.subscribe(listener2)
-        subject.unsubscribe(listener2)
-        expect(subject.subscribers.size).to eq(1)
-        expect(subject.subscribers).to eq([listener1])
-        subject.unsubscribe(listener1)
-        expect(subject.subscribers).to be_empty
+      it 'allows un-subcriptions' do
+        a_visitor.subscribe(listener1)
+        a_visitor.subscribe(listener2)
+        a_visitor.unsubscribe(listener2)
+        expect(a_visitor.subscribers.size).to eq(1)
+        expect(a_visitor.subscribers).to eq([listener1])
+        a_visitor.unsubscribe(listener1)
+        expect(a_visitor.subscribers).to be_empty
       end
     end # context
 
@@ -140,13 +138,13 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       end
 
       def check_legs(expectations)
-        (parent, path_signature) = subject.legs[-1]
+        (parent, path_signature) = a_visitor.legs[-1]
         expect(parent.to_string(0)).to eq(expectations[0])
         expect(path_signature).to eq(expectations[1])
       end
 
       def check_node_accesses(node, paths)
-        actual_paths = subject.node_accesses.fetch(node)
+        actual_paths = a_visitor.node_accesses.fetch(node)
         expect(actual_paths).to eq(paths)
       end
 
@@ -154,12 +152,12 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       # Default instantiation rule
       subject do
-        instance = ParseForestVisitor.new(grm_sppf_pforest1)
+        instance = described_class.new(grm_sppf_pforest1)
         instance.subscribe(checker)
         instance
       end
 
-      it 'should react to the start_visit_pforest message' do
+      it 'reacts to the start_visit_pforest message' do
         # Notify subscribers when start the visit of the pforest
         # expect(listener1).to receive(:before_pforest).with(forest_root)
         checker.expectations = [
@@ -267,7 +265,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
             check_event(event, item, [:before_alternative, prediction])
             check_legs(['Alt(A => a .)[0, 1]', 7130]) # 2 * 5 * 23 * 31
             check_node_accesses(item, [7130])
-            # p(subject.legs)
+            # p(a_visitor.legs)
           end,
           lambda do |event, parent, children|
             prediction = 'Alt(A => a .)[0, 1]'
@@ -487,7 +485,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
             check_event(event, item, [:after_pforest, grm_sppf_pforest1])
           end
         ]
-        subject.start
+        a_visitor.start
       end
     end # context
   end # describe

data/spec/rley/parse_rep/ambiguous_parse_spec.rb

@@ -46,7 +46,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(child.to_string(0)).to eq(anExpectation)
       end
 
-      before(:each) do
+      before do
         factory = Parser::ParseWalkerFactory.new
         accept_entry = sentence_result.accepting_entry
         accept_index = sentence_result.chart.last_index
@@ -73,7 +73,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
         subject { ParseForestBuilder.new(expr_tokens) }
 
-        it 'should handle walker events' do
+        it 'handles walker events' do
           next_event(:visit, 'P. | 0') # Event 1
           expected_curr_path('P[0, 5]')
 

data/spec/rley/parse_rep/ast_builder_spec.rb

@@ -99,7 +99,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         arr_int_tokenizer('[2 , 3, 5 ]')
       end
 
-      subject { ASTBuilder.new(sample_tokens) }
+      subject(:a_builder) { described_class.new(sample_tokens) }
 
       def init_walker(theParser, theTokens)
         result = theParser.parse(theTokens)
@@ -112,7 +112,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       def skip_events(count)
         count.times do
           event = @walker.next
-          subject.receive_event(*event)
+          a_builder.receive_event(*event)
         end
       end
 
@@ -125,20 +125,20 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       end
 
       context 'Initialization:' do
-        it 'should be created with a sequence of tokens' do
-          expect { ASTBuilder.new(sample_tokens) }.not_to raise_error
+        it 'is created with a sequence of tokens' do
+          expect { described_class.new(sample_tokens) }.not_to raise_error
         end
 
-        it 'should know the input tokens' do
-          expect(subject.tokens).to eq(sample_tokens)
+        it 'knows the input tokens' do
+          expect(a_builder.tokens).to eq(sample_tokens)
         end
 
-        it "shouldn't know the result yet" do
-          expect(subject.result).to be_nil
+        it "doesn't know the result yet" do
+          expect(a_builder.result).to be_nil
         end
 
-        it 'should have an empty stack' do
-          expect(subject.send(:stack)).to be_empty
+        it 'has an empty stack' do
+          expect(a_builder.send(:stack)).to be_empty
         end
       end # context
 
@@ -148,11 +148,11 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           (ev_type, entry, index) = event
           actual = "#{ev_type} #{entry} #{index}"
           expect(actual).to eq(expectation)
-          subject.receive_event(*event)
+          a_builder.receive_event(*event)
         end
 
 
-        before(:each) do
+        before do
           @parser = Parser::GFGEarleyParser.new(sample_grammar)
           init_walker(@parser, sample_tokens)
         end
@@ -189,8 +189,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         # Event: visit P => . arr | 0 0
         # Event: visit .P | 0 0
 
-        it 'should accept a first visit event' do
-          stack = get_stack(subject)
+        it 'accepts a first visit event' do
+          stack = get_stack(a_builder)
 
           next_event('visit P. | 0 7')
           expect(stack.size).to eq(1)
@@ -199,8 +199,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(stack.last.children).to be_nil
         end
 
-        it 'should build a tree for an empty array' do
-          stack = get_stack(subject)
+        it 'builds a tree for an empty array' do
+          stack = get_stack(a_builder)
 
           next_event('visit P. | 0 7')
           next_event('visit P => arr . | 0 7')
@@ -216,7 +216,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           next_event('visit arr => [ sequence ] . | 0 7')
           # stack: [P[0, 7], arr[0, 7]]
           rbracket = stack.last.children[-1]
-          expect(rbracket).to be_kind_of(PTree::TerminalNode)
+          expect(rbracket).to be_a(PTree::TerminalNode)
           expect(rbracket.to_s).to eq("][6, 7]: ']'")
 
           next_event('visit arr => [ sequence . ] | 0 6')
@@ -238,12 +238,12 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
           next_event('visit list => list , integer . | 1 6')
           intval = stack.last.children[-1]
-          expect(intval).to be_kind_of(IntegerNode)
+          expect(intval).to be_a(IntegerNode)
           expect(intval.value).to eq(5)
 
           next_event('visit list => list , . integer | 1 5')
           comma = stack.last.children[-2]
-          expect(comma).to be_kind_of(PTree::TerminalNode)
+          expect(comma).to be_a(PTree::TerminalNode)
           expect(comma.to_s).to eq(",[4, 5]: ','")
 
           next_event('visit list => list . , integer | 1 4')
@@ -256,12 +256,12 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
           next_event('visit list => list , integer . | 1 4')
           intval = stack.last.children[-1]
-          expect(intval).to be_kind_of(IntegerNode)
+          expect(intval).to be_a(IntegerNode)
           expect(intval.value).to eq(3)
 
           next_event('visit list => list , . integer | 1 3')
           comma = stack.last.children[-2]
-          expect(comma).to be_kind_of(PTree::TerminalNode)
+          expect(comma).to be_a(PTree::TerminalNode)
           expect(comma.to_s).to eq(",[2, 3]: ','")
 
           next_event('visit list => list . , integer | 1 2')
@@ -275,14 +275,14 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
           next_event('visit list => integer . | 1 2')
           intval = stack.last.children[-1]
-          expect(intval).to be_kind_of(IntegerNode)
+          expect(intval).to be_a(IntegerNode)
           expect(intval.value).to eq(2)
 
           next_event('visit list => . integer | 1 1')
           expect(stack.size).to eq(5)
           # stack: [P[0, 7], arr[0, 7], sequence[1, 6], list[1, 6], list[1, 4]
           list_node = stack.last.children[0]
-          expect(list_node).to be_kind_of(ArrayNode)
+          expect(list_node).to be_a(ArrayNode)
           expect(list_node.children.size).to eq(1)
           expect(list_node.children.last.value).to eq(2)
 
@@ -292,7 +292,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(stack.size).to eq(4)
           # stack: [P[0, 7], arr[0, 7], sequence[1, 6], list[1, 6]
           list_node = stack.last.children[0]
-          expect(list_node).to be_kind_of(ArrayNode)
+          expect(list_node).to be_a(ArrayNode)
           expect(list_node.children.size).to eq(2)
           expect(list_node.children.last.value).to eq(3)
 
@@ -301,7 +301,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           next_event('revisit list => . list , integer | 1 1')
           # stack: [P[0, 7], arr[0, 7], sequence[1, 6]
           list_node = stack.last.children.last
-          expect(list_node).to be_kind_of(ArrayNode)
+          expect(list_node).to be_a(ArrayNode)
           expect(list_node.children.size).to eq(3)
           expect(list_node.children.last.value).to eq(5)
 
@@ -311,21 +311,21 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(stack.size).to eq(2)
           # stack: [P[0, 7], arr[0, 7]
           list_node = stack.last.children[1]
-          expect(list_node).to be_kind_of(ArrayNode)
+          expect(list_node).to be_a(ArrayNode)
           expect(list_node.children.size).to eq(3)
 
           next_event('visit .sequence | 1 1')
 
           next_event('visit arr => [ . sequence ] | 0 1')
           lbracket = stack.last.children[0]
-          expect(lbracket).to be_kind_of(PTree::TerminalNode)
+          expect(lbracket).to be_a(PTree::TerminalNode)
           expect(lbracket.to_s).to eq("[[0, 1]: '['")
 
           next_event('visit arr => . [ sequence ] | 0 0')
           expect(stack.size).to eq(1)
           # stack: [P[0, 7]
           array_node = stack.last.children[0]
-          expect(array_node).to be_kind_of(ArrayNode)
+          expect(array_node).to be_a(ArrayNode)
           expect(array_node.children.size).to eq(3)
 
 
@@ -333,8 +333,8 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
           next_event('visit P => . arr | 0 0')
           expect(stack.size).to eq(0)
-          expect(subject.result).not_to be_nil
-          root = subject.result.root
+          expect(a_builder.result).not_to be_nil
+          root = a_builder.result.root
           expect(root.interpret).to eq([2, 3, 5])
 
           next_event('visit .P | 0 0')