rley 0.0.04 → 0.0.05

data/lib/rley/syntax/verbatim_symbol.rb

@@ -2,7 +2,6 @@ require_relative 'terminal' # Load superclass
 
 module Rley # This module is used as a namespace
   module Syntax # This module is used as a namespace
-
     # A verbatim word is terminal symbol that represents one unique word
     # in the language defined the grammar.
     class VerbatimSymbol < Terminal
@@ -14,7 +13,6 @@ module Rley # This module is used as a namespace
         @text = aText.dup
       end
     end # class
-
   end # module
 end # module
 

data/spec/rley/parser/chart_spec.rb

@@ -6,42 +6,40 @@ require_relative '../../../lib/rley/parser/chart'
 
 module Rley # Open this namespace to avoid module qualifier prefixes
   module Parser # Open this namespace to avoid module qualifier prefixes
+    describe Chart do
 
-  describe Chart do
+      let(:count_token) { 20 }
+      let(:dotted_rule) { double('fake-dotted-item') }
 
-    let(:count_token) { 20 }
-    let(:dotted_rule) { double('fake-dotted-item') }
+      context 'Initialization:' do
 
-    context 'Initialization:' do
+        # Default instantiation rule
+        subject { Chart.new(dotted_rule, count_token) }
 
-      # Default instantiation rule
-      subject { Chart.new(dotted_rule, count_token) }
+        it 'should be created with a start dotted rule and a token count' do
+          expect { Chart.new(dotted_rule, count_token) }.not_to raise_error
+        end
 
-      it 'should be created with a start dotted rule and a token count' do
-        expect { Chart.new(dotted_rule, count_token) }.not_to raise_error
-      end
+        it 'should have a seed state in first state_set' do
+          seed_state = ParseState.new(dotted_rule, 0)
+          expect(subject[0].states).to eq([seed_state])
 
-      it 'should have a seed state in first state_set' do
-        seed_state = ParseState.new(dotted_rule, 0)
-        expect(subject[0].states).to eq([seed_state])
+          # Shorthand syntax
+          expect(subject[0].first).to eq(seed_state)
+        end
 
-        # Shorthand syntax
-        expect(subject[0].first).to eq(seed_state)
-      end
+        it 'should have the correct state_set count' do
+          expect(subject.state_sets.size).to eq(count_token + 1)
+        end
 
-      it 'should have the correct state_set count' do
-        expect(subject.state_sets.size).to eq(count_token + 1)
-      end
+        it 'should the start dotted rule' do
+          expect(subject.start_dotted_rule).to eq(dotted_rule)
+        end
 
-      it 'should the start dotted rule' do
-        expect(subject.start_dotted_rule).to eq(dotted_rule)
-      end
-
-    end # context
-
-  end # describe
+      end # context
 
+    end # describe
   end # module
 end # module
 
-# End of file
+# End of file

data/spec/rley/parser/dotted_item_spec.rb

@@ -9,100 +9,95 @@ require_relative '../../../lib/rley/parser/dotted_item'
 
 module Rley # Open this namespace to avoid module qualifier prefixes
   module Parser # Open this namespace to avoid module qualifier prefixes
+    describe DottedItem do
 
-  describe DottedItem 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(: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(:empty_prod) do
-      Syntax::Production.new(nt_sentence,[])
-    end
-
-
-    subject { DottedItem.new(sample_prod, 1) }
-
-    context 'Initialization:' do
-      it 'should be created with a production and an index' do
-        expect { DottedItem.new(sample_prod, 0) }.not_to raise_error
-        expect { DottedItem.new(sample_prod, 3) }.not_to raise_error
-      end
-
-      it 'should complain when the index is out-of-bounds' do
-        err = StandardError
-        msg = 'Out of bound index'
-        expect { DottedItem.new(sample_prod, 4) }.to raise_error(err, msg)
-      end
-
-      it 'should know its production' do
-        expect(subject.production).to eq(sample_prod)
-      end
-      
-      it 'should know the lhs of the production' do
-        expect(subject.lhs).to eq(sample_prod.lhs)
+      # Factory method. Builds a production with given left-hand side (LHS)
+      # and given RHS (right-hand side)
+      def build_prod(theLHS, *theRHSSymbols)
+        return Syntax::Production.new(theLHS, theRHSSymbols)
       end
-
-      it 'should know its position' do
-        # At start position
-        instance1 = DottedItem.new(sample_prod, 0)
-        expect(instance1.position).to eq(0)
-
-        # At (before) last symbol
-        instance2 = DottedItem.new(sample_prod, 2)
-        expect(instance2.position).to eq(2)
-
-        # After all symbols in rhs
-        instance3 = DottedItem.new(sample_prod, 3)
-        expect(instance3.position).to eq(-1)
-
-        # At start/end at the same time (production is empty)
-        instance4 = DottedItem.new(Syntax::Production.new(nt_sentence, []), 0)
-        expect(instance4.position).to eq(-2)
-      end
-
-    end # context
-
-    context 'Provided service:' do
-      it 'should whether its dot is at start position' do
-        expect(subject).not_to be_at_start
+    
+      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) { build_prod(nt_sentence, t_a, t_b, t_c) }
+      let(:other_prod) {  build_prod(nt_sentence, t_a) }
+      let(:empty_prod) { build_prod(nt_sentence) }
+
+      # Default instantiation rule
+      subject { DottedItem.new(sample_prod, 1) }
+
+      context 'Initialization:' do
+        it 'should be created with a production and an index' do
+          expect { DottedItem.new(sample_prod, 0) }.not_to raise_error
+          expect { DottedItem.new(sample_prod, 3) }.not_to raise_error
+        end
+
+        it 'should complain when the index is out-of-bounds' do
+          err = StandardError
+          msg = 'Out of bound index'
+          expect { DottedItem.new(sample_prod, 4) }.to raise_error(err, msg)
+        end
+
+        it 'should know its production' do
+          expect(subject.production).to eq(sample_prod)
+        end
         
-        # At start position
-        instance1 = DottedItem.new(sample_prod, 0)
-        expect(instance1).to be_at_start
-        
-        # At start/end at the same time (production is empty)
-        instance2 = DottedItem.new(Syntax::Production.new(nt_sentence, []), 0)
-        expect(instance2).to be_at_start
+        it 'should know the lhs of the production' do
+          expect(subject.lhs).to eq(sample_prod.lhs)
+        end
+
+        it 'should know its position' do
+          # At start position
+          instance1 = DottedItem.new(sample_prod, 0)
+          expect(instance1.position).to eq(0)
+
+          # At (before) last symbol
+          instance2 = DottedItem.new(sample_prod, 2)
+          expect(instance2.position).to eq(2)
+
+          # After all symbols in rhs
+          instance3 = DottedItem.new(sample_prod, 3)
+          expect(instance3.position).to eq(-1)
+
+          # At start/end at the same time (production is empty)
+          instance4 = DottedItem.new(build_prod(nt_sentence), 0)
+          expect(instance4.position).to eq(-2)
+        end
+
+      end # context
+
+      context 'Provided service:' do
+        it 'should whether its dot is at start position' do
+          expect(subject).not_to be_at_start
+          
+          # At start position
+          instance1 = DottedItem.new(sample_prod, 0)
+          expect(instance1).to be_at_start
+          
+          # At start/end at the same time (production is empty)
+          instance2 = DottedItem.new(build_prod(nt_sentence), 0)
+          expect(instance2).to be_at_start
+        end
+
+        it 'should whether it is a reduce item' do
+          expect(subject).not_to be_reduce_item
+
+          first_instance = DottedItem.new(sample_prod, 3)
+          expect(first_instance).to be_reduce_item
+
+          second_instance = DottedItem.new(empty_prod, 0)
+          expect(second_instance).to be_reduce_item
+        end
+
+        it 'should know the symbol after the dot' do
+          expect(subject.next_symbol).to eq(t_b)
+        end
       end
 
-      it 'should whether it is a reduce item' do
-        expect(subject).not_to be_reduce_item
-
-        first_instance = DottedItem.new(sample_prod, 3)
-        expect(first_instance).to be_reduce_item
-
-        second_instance = DottedItem.new(empty_prod, 0)
-        expect(second_instance).to be_reduce_item
-      end
-
-      it 'should know the symbol after the dot' do
-        expect(subject.next_symbol).to eq(t_b)
-      end
-    end
-
-  end # describe
-
+    end # describe
   end # module
 end # module
 
 # End of file
-

data/spec/rley/parser/earley_parser_spec.rb

@@ -9,263 +9,299 @@ require_relative '../../../lib/rley/parser/earley_parser'
 
 module Rley # Open this namespace to avoid module qualifier prefixes
   module Parser # Open this namespace to avoid module qualifier prefixes
-
-  describe EarleyParser do
+    describe EarleyParser do
 =begin
-    let(:kw_true) { Syntax::VerbatimSymbol('true') }
-    let(:kw_false) { Syntax::VerbatimSymbol('false') }
-    let(:kw_null) { Syntax::VerbatimSymbol('null') }
-    let(:number) do
-      number_pattern = /[-+]?[0-9]+(\.[0-9]+)?([eE][-+]?[0-9]+)?/
-      Syntax::Literal('number', number_pattern)
-    end
-    let(:string) do
-      string_pattern = /"([^\\"]|\\.)*"/
-      Syntax::Literal('string', string_pattern)
-    end
-    let(:lbracket) { Syntax::VerbatimSymbol('[') }
-    let(:rbracket) { Syntax::VerbatimSymbol(']') }
-    let(:comma) { Syntax::VerbatimSymbol(',') }
-    let(:array) { Syntax::NonTerminal('Array') }
-    let(:object) { Syntax::NonTerminal('Object') }
-
-    let(:array_prod) do
-      Production.new(array, )
-    end
-=end
-
-    # 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(:grammar_abc) { Syntax::Grammar.new([prod_S, prod_A1, prod_A2]) }
-
-    # Helper method that mimicks the output of a tokenizer
-    # for the language specified by gramma_abc
-    def grm1_tokens()
-      tokens = [
-        Token.new('a', a_),
-        Token.new('a', a_),
-        Token.new('b', b_),
-        Token.new('c', c_),
-        Token.new('c', c_)
-      ]
-
-      return tokens
-    end
-
-
-    # Default instantiation rule
-    subject { EarleyParser.new(grammar_abc) }
-
-    context 'Initialization:' do
-      it 'should be created with a grammar' do
-        expect { EarleyParser.new(grammar_abc) }.not_to raise_error
+      let(:kw_true) { Syntax::VerbatimSymbol.new('true') }
+      let(:kw_false) { Syntax::VerbatimSymbol.new('false') }
+      let(:kw_null) { Syntax::VerbatimSymbol.new('null') }
+      let(:number) do
+        number_pattern = /[-+]?[0-9]+(\.[0-9]+)?([eE][-+]?[0-9]+)?/
+        Syntax::Literal.new('number', number_pattern)
       end
-
-      it 'should know its grammar' do
-        expect(subject.grammar).to eq(grammar_abc)
+      let(:string) do
+        string_pattern = /"([^\\"]|\\.)*"/
+        Syntax::Literal('string', string_pattern)
       end
-
-      it 'should know its dotted items' do
-        expect(subject.dotted_items.size).to eq(8)
+      let(:lbracket) { Syntax::VerbatimSymbol.new('[') }
+      let(:rbracket) { Syntax::VerbatimSymbol.new(']') }
+      let(:comma) { Syntax::VerbatimSymbol.new(',') }
+      let(:array) { Syntax::NonTerminal.new('Array') }
+      let(:object) { Syntax::NonTerminal.new('Object') }
+
+      let(:array_prod) do
+        Production.new(array, )
       end
+=end
 
-      it 'should have its start mapping initialized' do
-        expect(subject.start_mapping.size).to eq(2)
-
-        start_items_S = subject.start_mapping[nt_S]
-        expect(start_items_S.size).to eq(1)
-        expect(start_items_S[0].production).to eq(prod_S)
-
-        start_items_A = subject.start_mapping[nt_A]
-        expect(start_items_A.size).to eq(2)
+      # Grammar 1: A very simple language
+      # S ::= A.
+      # A ::= "a" A "c".
+      # A ::= "b".
+      # Let's create the grammar piece by piece
+      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(:grammar_abc) { Syntax::Grammar.new([prod_S, prod_A1, prod_A2]) }
+
+      # Helper method that mimicks the output of a tokenizer
+      # for the language specified by grammar_abc
+      def grm1_tokens()
+        tokens = [
+          Token.new('a', a_),
+          Token.new('a', a_),
+          Token.new('b', b_),
+          Token.new('c', c_),
+          Token.new('c', c_)
+        ]
 
-        # Assuming that dotted_items are created in same order
-        # than production in grammar.
-        expect(start_items_A[0].production).to eq(prod_A1)
-        expect(start_items_A[1].production).to eq(prod_A2)
+        return tokens
       end
 
-      it 'should have its next mapping initialized' do
-        expect(subject.next_mapping.size).to eq(5)
-      end
-    end # context
-
-    context 'Parsing: ' do
-      # Helper method. Compare the data from the parse state
-      # with values from expectation hash.
-      def compare_state(aState, expectations)
-        expect(aState.origin).to eq(expectations[:origin])
-        dotted_item = aState.dotted_rule
-        expect(dotted_item.production).to eq(expectations[:production])
-        expect(dotted_item.position).to eq(expectations[:dot])
-      end
 
-      it 'should parse a valid simple input' do
-        parse_result = subject.parse(grm1_tokens)
-        expect(parse_result.success?).to eq(true)
-
-        ######################
-        state_set_0 = parse_result.chart[0]
-        # Expectation chart[0]:
-        # S -> . A, 0           # start rule
-        # A -> . "a" A "c", 0   # predict from 0
-        # A -> . "b", 0         # predict from 0
-        expectations = { origin: 0, production: prod_S, dot: 0 }
-        compare_state(state_set_0.states[0], expectations)
-
-        expectations = { origin: 0, production: prod_A1, dot: 0 }
-        compare_state(state_set_0.states[1], expectations)
-
-        expectations = { origin: 0, production: prod_A2, dot: 0 }
-        compare_state(state_set_0.states[2], expectations)
-
-        ######################
-        state_set_1 = parse_result.chart[1]
-        expect(state_set_1.states.size).to eq(3)
-        # Expectation chart[1]:
-        # 0: A -> "a" . A "c", 0   # scan from S(0) 1
-        # 1: A -> . "a" A "c", 1   # predict from 0
-        # 2: A -> . "b", 1         # predict from 0
-        expectations = { origin: 0, production: prod_A1, dot: 1 }
-        compare_state(state_set_1.states[0], expectations)
-
-        expectations = { origin: 1, production: prod_A1, dot: 0 }
-        compare_state(state_set_1.states[1], expectations)
-
-        expectations = { origin: 1, production: prod_A2, dot: 0 }
-        compare_state(state_set_1.states[2], expectations)
-
-        ######################
-        state_set_2 = parse_result.chart[2]
-        expect(state_set_2.states.size).to eq(3)
-        # Expectation chart[2]:
-        # 0: A -> "a" . A "c", 1  # scan from S(0) 1
-        # 1: A -> . "a" A "c", 2  # predict from 0
-        # 2: A -> . "b", 2        # predict from 0
-        expectations = { origin: 1, production: prod_A1, dot: 1 }
-        compare_state(state_set_2.states[0], expectations)
-
-        expectations = { origin: 2, production: prod_A1, dot: 0 }
-        compare_state(state_set_2.states[1], expectations)
-
-        expectations = { origin: 2, production: prod_A2, dot: 0 }
-        compare_state(state_set_2.states[2], expectations)
-
-        ######################
-        state_set_3 = parse_result.chart[3]
-        expect(state_set_3.states.size).to eq(2)
-        # Expectation chart[3]:
-        # 0: A -> "b" ., 2      # scan from S(2) 2
-        # 1: A -> "a" A . "c", 1 # complete from 0 and S(2) 0
-        expectations = { origin: 2, production: prod_A2, dot: -1 }
-        compare_state(state_set_3.states[0], expectations)
-
-        expectations = { origin: 1, production: prod_A1, dot: 2 }
-        compare_state(state_set_3.states[1], expectations)
-
-        ######################
-        state_set_4 = parse_result.chart[4]
-        expect(state_set_4.states.size).to eq(2)
-        # Expectation chart[4]:
-        # 0: A -> "a" A "c" ., 1  # scan from S(3) 1
-        # 1: A -> "a" A . "c", 0  # complete from 0 and S(1) 0
-        expectations = { origin: 1, production: prod_A1, dot: -1 }
-        compare_state(state_set_4.states[0], expectations)
-
-        expectations = { origin: 0, production: prod_A1, dot: 2 }
-        compare_state(state_set_4.states[1], expectations)
-
-        ######################
-        state_set_5 = parse_result.chart[5]
-        expect(state_set_5.states.size).to eq(2)
-        # Expectation chart[5]:
-        # 0: A -> "a" A "c" ., 0  # scan from S(4) 1
-        # 1: S -> A ., 0  # complete from 0 and S(0) 0
-        expectations = { origin: 0, production: prod_A1, dot: -1 }
-        compare_state(state_set_5.states[0], expectations)
-
-        expectations = { origin: 0, production: prod_S, dot: -1 }
-        compare_state(state_set_5.states[1], expectations)
+      # Grammar 2: A simple arithmetic expression language
+      # E ::= S.
+      # S ::= S "+" M.
+      # S ::= M.
+      # M ::= M "*" M.
+      # M ::= T.
+      # T ::= an integer number token.
+      # Let's create the grammar piece by piece
+      let(:nt_E) { Syntax::NonTerminal.new('E') }
+      let(:nt_M) { Syntax::NonTerminal.new('M') }
+      let(:nt_T) { Syntax::NonTerminal.new('T') }
+      let(:plus) { Syntax::VerbatimSymbol.new('+') }
+      let(:star)  { Syntax::VerbatimSymbol.new('*') }
+      let(:integer) do
+        integer_pattern = /[-+]?[0-9]+/	# Decimal notation
+        Syntax::Literal.new('integer', integer_pattern)
+      end
+      let(:prod_E) { Syntax::Production.new(nt_E, [nt_S]) }
+      let(:prod_S1) { Syntax::Production.new(nt_S, [nt_S, plus, nt_M]) }
+      let(:prod_S2) { Syntax::Production.new(nt_S, [nt_M]) }
+      let(:prod_M1) { Syntax::Production.new(nt_M, [nt_M, star, nt_M]) }
+      let(:prod_M2) { Syntax::Production.new(nt_M, [nt_T]) }
+      let(:prod_T) { Syntax::Production.new(nt_T, [integer]) }
+      let(:grammar_expr) do
+        all_prods = [prod_E, prod_S1, prod_S2, prod_M1, prod_M2, prod_T]
+        Syntax::Grammar.new(all_prods)
       end
 
-      it 'should parse an invalid simple input' do
-        # Parse an erroneous input (b is missing)
-        wrong = [
-          Token.new('a', a_),
-          Token.new('a', a_),
-          Token.new('c', c_),
-          Token.new('c', c_)
+      # Helper method that mimicks the output of a tokenizer
+      # for the language specified by grammar_expr
+      def grm2_tokens()
+        tokens = [
+          Token.new('2', integer),
+          Token.new('+', plus),
+          Token.new('3', integer),
+          Token.new('*', star),
+          Token.new('4', integer)
         ]
-        parse_result = subject.parse(wrong)
-        expect(parse_result.success?).to eq(false)
-
-        ###################### S(0) == . a a c c
-        state_set_0 = parse_result.chart[0]
-        # Expectation chart[0]:
-        # S -> . A, 0 # start rule
-        # A -> . "a" A "c", 0
-        # A -> . "b", 0
-        expectations = { origin: 0, production: prod_S, dot: 0 }
-        compare_state(state_set_0.states[0], expectations)
-
-        expectations = { origin: 0, production: prod_A1, dot: 0 }
-        compare_state(state_set_0.states[1], expectations)
-
-        expectations = { origin: 0, production: prod_A2, dot: 0 }
-        compare_state(state_set_0.states[2], expectations)
-
-        ###################### S(1) == a . a c c
-        state_set_1 = parse_result.chart[1]
-        expect(state_set_1.states.size).to eq(3)
-        # Expectation chart[1]:
-        # 0: A -> "a" . A "c", 0   # scan from S(0) 1
-        # 1: A -> . "a" A "c", 1   # predict from 0
-        # 2: A -> . "b", 1         # predict from 0
-        expectations = { origin: 0, production: prod_A1, dot: 1 }
-        compare_state(state_set_1.states[0], expectations)
-
-        expectations = { origin: 1, production: prod_A1, dot: 0 }
-        compare_state(state_set_1.states[1], expectations)
-
-        expectations = { origin: 1, production: prod_A2, dot: 0 }
-        compare_state(state_set_1.states[2], expectations)
-
-        ###################### S(2) == a a . c c
-        state_set_2 = parse_result.chart[2]
-        expect(state_set_2.states.size).to eq(3)
-        # Expectation chart[2]:
-        # 0: A -> "a" . A "c", 1  # scan from S(0) 1
-        # 1: A -> . "a" A "c", 2  # predict from 0
-        # 2: A -> . "b", 2        # predict from 0
-        expectations = { origin: 1, production: prod_A1, dot: 1 }
-        compare_state(state_set_2.states[0], expectations)
-
-        expectations = { origin: 2, production: prod_A1, dot: 0 }
-        compare_state(state_set_2.states[1], expectations)
-
-        expectations = { origin: 2, production: prod_A2, dot: 0 }
-        compare_state(state_set_2.states[2], expectations)
-
-        ###################### S(3) == a a c? c
-        state_set_3 = parse_result.chart[3]
-        expect(state_set_3.states).to be_empty  # This is an error symptom       
+
+        return tokens
       end
-    end # context
 
-  end # describe
 
+      # Default instantiation rule
+      subject { EarleyParser.new(grammar_abc) }
+
+      context 'Initialization:' do
+        it 'should be created with a grammar' do
+          expect { EarleyParser.new(grammar_abc) }.not_to raise_error
+          expect { EarleyParser.new(grammar_expr) }.not_to raise_error
+        end
+
+        it 'should know its grammar' do
+          expect(subject.grammar).to eq(grammar_abc)
+        end
+
+        it 'should know its dotted items' do
+          expect(subject.dotted_items.size).to eq(8)
+        end
+
+        it 'should have its start mapping initialized' do
+          expect(subject.start_mapping.size).to eq(2)
+
+          start_items_S = subject.start_mapping[nt_S]
+          expect(start_items_S.size).to eq(1)
+          expect(start_items_S[0].production).to eq(prod_S)
+
+          start_items_A = subject.start_mapping[nt_A]
+          expect(start_items_A.size).to eq(2)
+
+          # Assuming that dotted_items are created in same order
+          # than production in grammar.
+          expect(start_items_A[0].production).to eq(prod_A1)
+          expect(start_items_A[1].production).to eq(prod_A2)
+        end
+
+        it 'should have its next mapping initialized' do
+          expect(subject.next_mapping.size).to eq(5)
+        end
+      end # context
+
+      context 'Parsing: ' do
+        # Helper method. Compare the data from the parse state
+        # with values from expectation hash.
+        def compare_state(aState, expectations)
+          expect(aState.origin).to eq(expectations[:origin])
+          dotted_item = aState.dotted_rule
+          expect(dotted_item.production).to eq(expectations[:production])
+          expect(dotted_item.position).to eq(expectations[:dot])
+        end
+
+        # Helper method. Compare the data from all the parse states
+        # of a given StateSet with an array of expectation hashes.
+        def compare_state_set(aStateSet, expectations)
+          (0...expectations.size).each do |i|
+            compare_state(aStateSet.states[i], expectations[i])
+          end
+        end
+
+        it 'should parse a valid simple input' do
+          parse_result = subject.parse(grm1_tokens)
+          expect(parse_result.success?).to eq(true)
+
+          ######################
+          # Expectation chart[0]:
+          # S -> . A, 0           # start rule
+          # A -> . "a" A "c", 0   # predict from 0
+          # A -> . "b", 0         # predict from 0
+          expectations = [
+            { origin: 0, production: prod_S, dot: 0 },
+            { origin: 0, production: prod_A1, dot: 0 },
+            { origin: 0, production: prod_A2, dot: 0 }
+          ]
+          compare_state_set(parse_result.chart[0], expectations)
+
+          ######################
+          state_set_1 = parse_result.chart[1]
+          expect(state_set_1.states.size).to eq(3)
+          # Expectation chart[1]:
+          # 0: A -> "a" . A "c", 0   # scan from S(0) 1
+          # 1: A -> . "a" A "c", 1   # predict from 0
+          # 2: A -> . "b", 1         # predict from 0
+          expectations = [
+            { origin: 0, production: prod_A1, dot: 1 },
+            { origin: 1, production: prod_A1, dot: 0 },
+            { origin: 1, production: prod_A2, dot: 0 }
+          ]
+          compare_state_set(state_set_1, expectations)
+
+          ######################
+          state_set_2 = parse_result.chart[2]
+          expect(state_set_2.states.size).to eq(3)
+          # Expectation chart[2]:
+          # 0: A -> "a" . A "c", 1  # scan from S(0) 1
+          # 1: A -> . "a" A "c", 2  # predict from 0
+          # 2: A -> . "b", 2        # predict from 0
+          expectations = [
+            { origin: 1, production: prod_A1, dot: 1 },
+            { origin: 2, production: prod_A1, dot: 0 },
+            { origin: 2, production: prod_A2, dot: 0 }
+          ]
+          compare_state_set(state_set_2, expectations)
+
+          ######################
+          state_set_3 = parse_result.chart[3]
+          expect(state_set_3.states.size).to eq(2)
+          # Expectation chart[3]:
+          # 0: A -> "b" ., 2      # scan from S(2) 2
+          # 1: A -> "a" A . "c", 1 # complete from 0 and S(2) 0
+          expectations = [
+            { origin: 2, production: prod_A2, dot: -1 },
+            { origin: 1, production: prod_A1, dot: 2 }
+          ]
+          compare_state_set(state_set_3, expectations)
+
+          ######################
+          state_set_4 = parse_result.chart[4]
+          expect(state_set_4.states.size).to eq(2)
+          # Expectation chart[4]:
+          # 0: A -> "a" A "c" ., 1  # scan from S(3) 1
+          # 1: A -> "a" A . "c", 0  # complete from 0 and S(1) 0
+          expectations = [
+            { origin: 1, production: prod_A1, dot: -1 },
+            { origin: 0, production: prod_A1, dot: 2 }
+          ]
+          compare_state_set(state_set_4, expectations)
+
+          ######################
+          state_set_5 = parse_result.chart[5]
+          expect(state_set_5.states.size).to eq(2)
+          # Expectation chart[5]:
+          # 0: A -> "a" A "c" ., 0  # scan from S(4) 1
+          # 1: S -> A ., 0  # complete from 0 and S(0) 0
+          expectations = [
+            { origin: 0, production: prod_A1, dot: -1 },
+            { origin: 0, production: prod_S, dot: -1 }
+          ]
+          compare_state_set(state_set_5, expectations)
+        end
+
+        it 'should parse an invalid simple input' do
+          # Parse an erroneous input (b is missing)
+          wrong = [
+            Token.new('a', a_),
+            Token.new('a', a_),
+            Token.new('c', c_),
+            Token.new('c', c_)
+          ]
+          parse_result = subject.parse(wrong)
+          expect(parse_result.success?).to eq(false)
+
+          ###################### S(0) == . a a c c
+          # Expectation chart[0]:
+          # S -> . A, 0 # start rule
+          # A -> . "a" A "c", 0
+          # A -> . "b", 0
+          expectations = [
+            { origin: 0, production: prod_S, dot: 0 },
+            { origin: 0, production: prod_A1, dot: 0 },
+            { origin: 0, production: prod_A2, dot: 0 }
+          ]
+          compare_state_set(parse_result.chart[0], expectations)
+
+          ###################### S(1) == a . a c c
+          state_set_1 = parse_result.chart[1]
+          expect(state_set_1.states.size).to eq(3)
+          # Expectation chart[1]:
+          # 0: A -> "a" . A "c", 0   # scan from S(0) 1
+          # 1: A -> . "a" A "c", 1   # predict from 0
+          # 2: A -> . "b", 1         # predict from 0
+          expectations = [
+            { origin: 0, production: prod_A1, dot: 1 },
+            { origin: 1, production: prod_A1, dot: 0 },
+            { origin: 1, production: prod_A2, dot: 0 }
+          ]
+          compare_state_set(state_set_1, expectations)
+
+          ###################### S(2) == a a . c c
+          state_set_2 = parse_result.chart[2]
+          expect(state_set_2.states.size).to eq(3)
+          # Expectation chart[2]:
+          # 0: A -> "a" . A "c", 1  # scan from S(0) 1
+          # 1: A -> . "a" A "c", 2  # predict from 0
+          # 2: A -> . "b", 2        # predict from 0
+          expectations = [
+            { origin: 1, production: prod_A1, dot: 1 },
+            { origin: 2, production: prod_A1, dot: 0 },
+            { origin: 2, production: prod_A2, dot: 0 }
+          ]
+          compare_state_set(state_set_2, expectations)
+
+          ###################### S(3) == a a c? c
+          state_set_3 = parse_result.chart[3]
+          expect(state_set_3.states).to be_empty  # This is an error symptom
+        end
+      end # context
+
+    end # describe
   end # module
 end # module
 
 # End of file
-