rley 0.0.04 → 0.0.05

data/spec/rley/parser/parse_state_spec.rb

@@ -10,90 +10,90 @@ require_relative '../../../lib/rley/parser/parse_state'
 
 module Rley # Open this namespace to avoid module qualifier prefixes
   module Parser # Open this namespace to avoid module qualifier prefixes
+    describe ParseState do
 
-  describe ParseState do
+      let(:t_a) { Syntax::Terminal.new('A') }
+      let(:t_b) { Syntax::Terminal.new('B') }
+      let(:t_c) { Syntax::Terminal.new('C') }
+      let(:nt_sentence) { Syntax::NonTerminal.new('sentence') }
 
-    let(:t_a) { Syntax::Terminal.new('A') }
-    let(:t_b) { Syntax::Terminal.new('B') }
-    let(:t_c) { Syntax::Terminal.new('C') }
-    let(:nt_sentence) { Syntax::NonTerminal.new('sentence') }
+      let(:sample_prod) do
+        Syntax::Production.new(nt_sentence, [t_a, t_b, t_c])
+      end
 
-    let(:sample_prod) do
-      Syntax::Production.new(nt_sentence, [t_a, t_b, t_c])
-    end
+      let(:other_prod) do
+        Syntax::Production.new(nt_sentence, [t_a])
+      end
 
-    let(:other_prod) do
-      Syntax::Production.new(nt_sentence, [t_a])
-    end
-    
-    let(:empty_prod) do
-      Syntax::Production.new(nt_sentence,[])
-    end
-  
-    let(:origin_val) { 3 }
-    let(:dotted_rule) { DottedItem.new(sample_prod, 2) }
-    let(:other_dotted_rule) { double('mock-dotted-item') }
+      let(:empty_prod) do
+        Syntax::Production.new(nt_sentence, [])
+      end
 
-    # Default instantiation rule
-    subject { ParseState.new(dotted_rule, origin_val) }
+      let(:origin_val) { 3 }
+      let(:dotted_rule) { DottedItem.new(sample_prod, 2) }
+      let(:other_dotted_rule) { double('mock-dotted-item') }
 
-    context 'Initialization:' do
+      # Default instantiation rule
+      subject { ParseState.new(dotted_rule, origin_val) }
 
-      it 'should be created with a dotted item and a origin position' do
-        expect { ParseState.new(dotted_rule, origin_val) }.not_to raise_error
-      end
-      
-      it 'should complain when the dotted rule is nil' do
-        err = StandardError
-        msg = 'Dotted item cannot be nil'
-        expect { ParseState.new(nil, 2) }.to raise_error(err, msg)
-      end
+      context 'Initialization:' do
 
-      it 'should know the related dotted rule' do
-        expect(subject.dotted_rule).to eq(dotted_rule)
-      end
+        it 'should be created with a dotted item and a origin position' do
+          args = [dotted_rule, origin_val]
+          expect { ParseState.new(*args) }.not_to raise_error
+        end
 
-      it 'should know the origin value' do
-        expect(subject.origin).to eq(origin_val)
-      end
+        it 'should complain when the dotted rule is nil' do
+          err = StandardError
+          msg = 'Dotted item cannot be nil'
+          expect { ParseState.new(nil, 2) }.to raise_error(err, msg)
+        end
 
+        it 'should know the related dotted rule' do
+          expect(subject.dotted_rule).to eq(dotted_rule)
+        end
 
-    end # context
+        it 'should know the origin value' do
+          expect(subject.origin).to eq(origin_val)
+        end
 
-    context 'Provided services:' do
-      it 'should compare with itself' do
-        expect(subject == subject).to eq(true)
-      end
 
-      it 'should compare with another' do
-        equal = ParseState.new(dotted_rule, origin_val)
-        expect(subject == equal).to eq(true)
+      end # context
 
-        # Same dotted_rule, different origin
-        diff_origin = ParseState.new(dotted_rule, 2)
-        expect(subject == diff_origin).to eq(false)
+      context 'Provided services:' do
+        it 'should compare with itself' do
+          synonym = subject # Fool Rubocop
+          expect(subject == synonym).to eq(true)
+        end
 
-        # Different dotted item, same origin
-        diff_rule = ParseState.new(other_dotted_rule, 3)
-        expect(subject == diff_rule).to eq(false)
-      end
-      
-      it 'should know if the parsing reached the end of the production' do
-        expect(subject).not_to be_complete
-        at_end = DottedItem.new(sample_prod, 3)
+        it 'should compare with another' do
+          equal = ParseState.new(dotted_rule, origin_val)
+          expect(subject == equal).to eq(true)
 
-        instance = ParseState.new(at_end, 2)
-        expect(instance).to be_complete        
-      end
-      
-      it 'should know the next expected symbol' do
-        expect(subject.next_symbol).to eq(t_c)     
-      end
-    end # context
+          # Same dotted_rule, different origin
+          diff_origin = ParseState.new(dotted_rule, 2)
+          expect(subject == diff_origin).to eq(false)
+
+          # Different dotted item, same origin
+          diff_rule = ParseState.new(other_dotted_rule, 3)
+          expect(subject == diff_rule).to eq(false)
+        end
+
+        it 'should know if the parsing reached the end of the production' do
+          expect(subject).not_to be_complete
+          at_end = DottedItem.new(sample_prod, 3)
+
+          instance = ParseState.new(at_end, 2)
+          expect(instance).to be_complete
+        end
 
-  end # describe
+        it 'should know the next expected symbol' do
+          expect(subject.next_symbol).to eq(t_c)
+        end
+      end # context
 
+    end # describe
   end # module
 end # module
 
-# End of file
+# End of file

data/spec/rley/parser/parsing_spec.rb

@@ -10,109 +10,108 @@ require_relative '../../../lib/rley/parser/parsing'
 
 module Rley # Open this namespace to avoid module qualifier prefixes
   module Parser # Open this namespace to avoid module qualifier prefixes
+    describe Parsing do
 
-  describe Parsing do
+      # Grammar 1: A very simple language
+      # S ::= A.
+      # A ::= "a" A "c".
+      # A ::= "b".
+      let(:nt_S) { Syntax::NonTerminal.new('S') }
+      let(:nt_A) { Syntax::NonTerminal.new('A') }
+      let(:a_) { Syntax::VerbatimSymbol.new('a') }
+      let(:b_)  { Syntax::VerbatimSymbol.new('b') }
+      let(:c_)  { Syntax::VerbatimSymbol.new('c') }
+      let(:prod_S) { Syntax::Production.new(nt_S, [nt_A]) }
+      let(:prod_A1) { Syntax::Production.new(nt_A, [a_, nt_A, c_]) }
+      let(:prod_A2) { Syntax::Production.new(nt_A, [b_]) }
+      let(:start_dotted_rule) { DottedItem.new(prod_S, 0) }
 
-    # Grammar 1: A very simple language
-    # S ::= A.
-    # A ::= "a" A "c".
-    # A ::= "b".
-    let(:nt_S) { Syntax::NonTerminal.new('S') }
-    let(:nt_A) { Syntax::NonTerminal.new('A') }
-    let(:a_) { Syntax::VerbatimSymbol.new('a') }
-    let(:b_)  { Syntax::VerbatimSymbol.new('b') }
-    let(:c_)  { Syntax::VerbatimSymbol.new('c') }
-    let(:prod_S) { Syntax::Production.new(nt_S, [nt_A]) }
-    let(:prod_A1) { Syntax::Production.new(nt_A, [a_, nt_A, c_]) }
-    let(:prod_A2) { Syntax::Production.new(nt_A, [b_]) }
-    let(:start_dotted_rule) { DottedItem.new(prod_S, 0) }
-
-    # Helper method that mimicks the output of a tokenizer
-    # for the language specified by gramma_abc
-    let(:grm1_tokens) do
-      [
-        Token.new('a', a_),
-        Token.new('a', a_),
-        Token.new('b', b_),
-        Token.new('c', c_),
-        Token.new('c', c_)
-      ]
-    end
+      # Helper method that mimicks the output of a tokenizer
+      # for the language specified by gramma_abc
+      let(:grm1_tokens) do
+        [
+          Token.new('a', a_),
+          Token.new('a', a_),
+          Token.new('b', b_),
+          Token.new('c', c_),
+          Token.new('c', c_)
+        ]
+      end
 
-    # Default instantiation rule
-    subject { Parsing.new(start_dotted_rule, grm1_tokens) }
+      # Default instantiation rule
+      subject { Parsing.new(start_dotted_rule, grm1_tokens) }
 
-    context 'Initialization:' do
+      context 'Initialization:' do
 
-      it 'should be created with a list of tokens and a start dotted rule' do
-        expect { Parsing.new(start_dotted_rule, grm1_tokens) }.not_to raise_error
-      end
-      
-      it 'should know the input tokens' do
-        expect(subject.tokens).to eq(grm1_tokens)
-      end
+        it 'should be created with list of tokens and start dotted rule' do
+          start_rule = start_dotted_rule
+          tokens = grm1_tokens
+          expect { Parsing.new(start_rule, tokens) }.not_to raise_error
+        end
+        
+        it 'should know the input tokens' do
+          expect(subject.tokens).to eq(grm1_tokens)
+        end
 
-      it 'should know its chart object' do
-        expect(subject.chart).to be_kind_of(Chart)
-      end
+        it 'should know its chart object' do
+          expect(subject.chart).to be_kind_of(Chart)
+        end
 
-    end # context
-    
-    context 'Parsing:' do
-      it 'should push a state to a given chart entry' do
-        expect(subject.chart[1]).to be_empty
-        item = DottedItem.new(prod_A1, 1)
+      end # context
+      
+      context 'Parsing:' do
+        it 'should push a state to a given chart entry' do
+          expect(subject.chart[1]).to be_empty
+          item = DottedItem.new(prod_A1, 1)
+          
+          subject.push_state(item, 1, 1)
+          expect(subject.chart[1]).not_to be_empty
+          expect(subject.chart[1].first.dotted_rule).to eq(item)
+          
+          # Pushing twice the same state must be no-op
+          subject.push_state(item, 1, 1)
+          expect(subject.chart[1].size).to eq(1)
+        end
         
-        subject.push_state(item, 1, 1)
-        expect(subject.chart[1]).not_to be_empty
-        expect(subject.chart[1].first.dotted_rule).to eq(item)
+        it 'should complain when trying to push a nil dotted item' do
+          err = StandardError
+          msg = 'Dotted item may not be nil'
+          expect { subject.push_state(nil, 1, 1) }.to raise_error(err, msg)
+        end
         
-        # Pushing twice the same state must be no-op
-        subject.push_state(item, 1, 1)
-        expect(subject.chart[1].size).to eq(1)
-      end
-      
-      it 'should complain when trying to push a nil dotted item' do
-        err = StandardError
-        msg = 'Dotted item may not be nil'
-        expect { subject.push_state(nil, 1, 1) }.to raise_error(err, msg)
-      end
-      
-      
-      it 'should retrieve the parse states that expect a given terminal' do
-        item1 = DottedItem.new(prod_A1, 2)
-        item2 = DottedItem.new(prod_A1, 1)
-        subject.push_state(item1, 2, 2)
-        subject.push_state(item2, 2, 2)
-        states = subject.states_expecting(c_, 2)
-        expect(states.size).to eq(1)
-        expect(states[0].dotted_rule).to eq(item1)
-      end
-      
-      it 'should update the states upon token match' do
-        # When a input token matches an expected terminal symbol
-        # then new parse states must be pushed to the following chart slot
-        expect(subject.chart[1]).to be_empty
         
-        item1 = DottedItem.new(prod_A1, 0)
-        item2 = DottedItem.new(prod_A2, 0)
-        subject.push_state(item1, 0, 0)
-        subject.push_state(item2, 0, 0)
-        subject.scanning(a_, 0) { |i| i } # Code block is mock
+        it 'should retrieve the parse states that expect a given terminal' do
+          item1 = DottedItem.new(prod_A1, 2)
+          item2 = DottedItem.new(prod_A1, 1)
+          subject.push_state(item1, 2, 2)
+          subject.push_state(item2, 2, 2)
+          states = subject.states_expecting(c_, 2)
+          expect(states.size).to eq(1)
+          expect(states[0].dotted_rule).to eq(item1)
+        end
         
-        # Expected side effect: a new state at chart[1]
-        expect(subject.chart[1].size).to eq(1)
-        new_state = subject.chart[1].states[0]
-        expect(new_state.dotted_rule).to eq(item1)
-        expect(new_state.origin).to eq(0)
-      end
-      
-      # completion(aState, aPosition, &nextMapping)
-    end
+        it 'should update the states upon token match' do
+          # When a input token matches an expected terminal symbol
+          # then new parse states must be pushed to the following chart slot
+          expect(subject.chart[1]).to be_empty
+          
+          item1 = DottedItem.new(prod_A1, 0)
+          item2 = DottedItem.new(prod_A2, 0)
+          subject.push_state(item1, 0, 0)
+          subject.push_state(item2, 0, 0)
+          subject.scanning(a_, 0) { |i| i } # Code block is mock
+          
+          # Expected side effect: a new state at chart[1]
+          expect(subject.chart[1].size).to eq(1)
+          new_state = subject.chart[1].states[0]
+          expect(new_state.dotted_rule).to eq(item1)
+          expect(new_state.origin).to eq(0)
+        end
 
-  end # describe
+      end
 
+    end # describe
   end # module
 end # module
 
-# End of file
+# End of file

data/spec/rley/parser/state_set_spec.rb

@@ -7,62 +7,60 @@ require_relative '../../../lib/rley/parser/state_set'
 
 module Rley # Open this namespace to avoid module qualifier prefixes
   module Parser # Open this namespace to avoid module qualifier prefixes
-
-  describe StateSet do
-    let(:dotted_rule1) { double('fake_dotted_rule1') }
-    let(:state1) { ParseState.new(dotted_rule1, 2) }
-    let(:dotted_rule2) { double('fake_dotted_rule2') }
-    let(:state2) { ParseState.new(dotted_rule2, 5) }
-
-    context 'Initialization:' do
-
-      it 'should be created without argument' do
-        expect { StateSet.new }.not_to raise_error
-      end
-    end # context
-
-    context 'Provided services:' do
-
-      it 'should push a state' do
-        expect(subject.states).to be_empty
-        expect { subject.push_state(state1) }.not_to raise_error
-        expect(subject).not_to be_empty
-        subject.push_state(state2)
-        expect(subject.states).to eq([state1, state2])
-      end
-
-      it 'should list the states expecting a given terminal' do
-        # Case of no state
-        expect(subject.states_expecting(:a)).to be_empty
-
-        # Adding states
-        subject.push_state(state1)
-        subject.push_state(state2)
-        allow(dotted_rule1).to receive(:next_symbol).and_return(:b)
-        allow(dotted_rule2).to receive(:next_symbol).and_return(:a)
-        expect(subject.states_expecting(:a)).to eq([state2])
-        expect(subject.states_expecting(:b)).to eq([state1])
-      end
-
-      it 'should list the states related to a production' do
-        a_prod = double('fake-production')
-
-        # Case of no state
-        expect(subject.states_for(a_prod)).to be_empty
-
-        # Adding states
-        subject.push_state(state1)
-        subject.push_state(state2)
-        allow(dotted_rule1).to receive(:production).and_return(:dummy)
-        allow(dotted_rule2).to receive(:production).and_return(a_prod)
-        expect(subject.states_for(a_prod)).to eq([state2])
-      end
-
-    end # context
-
-  end # describe
-
+    describe StateSet do
+      let(:dotted_rule1) { double('fake_dotted_rule1') }
+      let(:state1) { ParseState.new(dotted_rule1, 2) }
+      let(:dotted_rule2) { double('fake_dotted_rule2') }
+      let(:state2) { ParseState.new(dotted_rule2, 5) }
+
+      context 'Initialization:' do
+
+        it 'should be created without argument' do
+          expect { StateSet.new }.not_to raise_error
+        end
+      end # context
+
+      context 'Provided services:' do
+
+        it 'should push a state' do
+          expect(subject.states).to be_empty
+          expect { subject.push_state(state1) }.not_to raise_error
+          expect(subject).not_to be_empty
+          subject.push_state(state2)
+          expect(subject.states).to eq([state1, state2])
+        end
+
+        it 'should list the states expecting a given terminal' do
+          # Case of no state
+          expect(subject.states_expecting(:a)).to be_empty
+
+          # Adding states
+          subject.push_state(state1)
+          subject.push_state(state2)
+          allow(dotted_rule1).to receive(:next_symbol).and_return(:b)
+          allow(dotted_rule2).to receive(:next_symbol).and_return(:a)
+          expect(subject.states_expecting(:a)).to eq([state2])
+          expect(subject.states_expecting(:b)).to eq([state1])
+        end
+
+        it 'should list the states related to a production' do
+          a_prod = double('fake-production')
+
+          # Case of no state
+          expect(subject.states_for(a_prod)).to be_empty
+
+          # Adding states
+          subject.push_state(state1)
+          subject.push_state(state2)
+          allow(dotted_rule1).to receive(:production).and_return(:dummy)
+          allow(dotted_rule2).to receive(:production).and_return(a_prod)
+          expect(subject.states_for(a_prod)).to eq([state2])
+        end
+
+      end # context
+
+    end # describe
   end # module
 end # module
 
-# End of file
+# End of file