rley 0.0.02

data/spec/rley/parser/parse_state_spec.rb

@@ -0,0 +1,99 @@
+require_relative '../../spec_helper'
+
+require_relative '../../../lib/rley/syntax/terminal'
+require_relative '../../../lib/rley/syntax/non_terminal'
+require_relative '../../../lib/rley/syntax/production'
+require_relative '../../../lib/rley/parser/dotted_item'
+
+# Load the class under test
+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
+
+    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
+  
+    let(:origin_val) { 3 }
+    let(:dotted_rule) { DottedItem.new(sample_prod, 2) }
+    let(:other_dotted_rule) { double('mock-dotted-item') }
+
+    # Default instantiation rule
+    subject { ParseState.new(dotted_rule, origin_val) }
+
+    context 'Initialization:' do
+
+      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
+
+      it 'should know the related dotted rule' do
+        expect(subject.dotted_rule).to eq(dotted_rule)
+      end
+
+      it 'should know the origin value' do
+        expect(subject.origin).to eq(origin_val)
+      end
+
+
+    end # context
+
+    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)
+
+        # 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
+      
+      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

data/spec/rley/parser/parsing_spec.rb

@@ -0,0 +1,118 @@
+require_relative '../../spec_helper'
+
+require_relative '../../../lib/rley/syntax/non_terminal'
+require_relative '../../../lib/rley/syntax/verbatim_symbol'
+require_relative '../../../lib/rley/syntax/production'
+require_relative '../../../lib/rley/parser/dotted_item'
+require_relative '../../../lib/rley/parser/token'
+# Load the class under test
+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
+
+    # 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
+
+    # Default instantiation rule
+    subject { Parsing.new(start_dotted_rule, grm1_tokens) }
+
+    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 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)
+        
+        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
+      
+      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
+        
+        # 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
+
+  end # describe
+
+  end # module
+end # module
+
+# End of file

data/spec/rley/parser/state_set_spec.rb

@@ -0,0 +1,68 @@
+require_relative '../../spec_helper'
+
+require_relative '../../../lib/rley/parser/parse_state'
+
+# Load the class under test
+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
+
+  end # module
+end # module
+
+# End of file

data/spec/rley/parser/token_spec.rb

@@ -0,0 +1,40 @@
+require_relative '../../spec_helper'
+
+require_relative '../../../lib/rley/syntax/terminal'
+
+# Load the class under test
+require_relative '../../../lib/rley/parser/token'
+
+module Rley # Open this namespace to avoid module qualifier prefixes
+  module Parser # Open this namespace to avoid module qualifier prefixes
+
+  describe Token do
+
+    let(:lexeme) { '"some text"' }
+    let(:sample_terminal) { Syntax::Terminal.new('if') }
+
+    context 'Initialization:' do
+
+
+      # Default instantiation rule
+      subject { Token.new(lexeme, sample_terminal) }
+
+      it 'should be created with a lexeme and a terminal argument' do
+        expect { Token.new(lexeme, sample_terminal) }.not_to raise_error
+      end
+
+      it 'should know its lexeme' do
+        expect(subject.lexeme).to eq(lexeme)
+      end
+
+      it 'should know its terminal' do
+        expect(subject.terminal).to eq(sample_terminal)
+      end
+    end # context
+
+  end # describe
+
+  end # module
+end # module
+
+# End of file

data/spec/rley/syntax/grammar_spec.rb

@@ -0,0 +1,149 @@
+require_relative '../../spec_helper'
+
+require_relative '../../../lib/rley/syntax/verbatim_symbol'
+require_relative '../../../lib/rley/syntax/non_terminal'
+require_relative '../../../lib/rley/syntax/production'
+
+# Load the class under test
+require_relative '../../../lib/rley/syntax/grammar'
+
+module Rley # Open this namespace to avoid module qualifier prefixes
+  module Syntax # Open this namespace to avoid module qualifier prefixes
+
+  describe Grammar do
+
+    # Factory method. Builds a list of productions
+    # having same lhs and the symbols sequence
+    # in their rhs.
+    def alternate_prods(aNonTerminal, sequences)
+      prods =  sequences.map do |symbs|
+        Production.new(aNonTerminal, symbs)
+      end
+
+      return prods
+    end
+
+    def build_verbatim_symbols(symbols)
+      result = {}
+      symbols.each { |symb| result[symb] = VerbatimSymbol.new(symb) }
+      result
+    end
+
+    # Grammar 1: arithmetical expressions with integers
+    let(:grm1_ops) do
+      operators = %w[+ - * / ( ) ]
+      build_verbatim_symbols(operators)
+    end
+
+    # Grammar symbols for integer arithmetic expressions
+    let(:number) { Literal.new('number', /\d+/)}  # Limited to positive integers
+    let(:add_op) { NonTerminal.new('add_op') }
+    let(:add_operators) { [grm1_ops['+'], grm1_ops['-']] }
+    let(:mult_op) { NonTerminal.new('mult_op') }
+    let(:mult_operators) { [grm1_ops['*'], grm1_ops['/']] }
+    let(:factor) { NonTerminal.new('factor') }
+    let(:term) { NonTerminal.new('term') }
+    let(:expression) { NonTerminal.new('expression') }
+
+
+    # Productions for grammar 1
+    let(:add_op_prods) { alternate_prods(add_op, add_operators) }
+    let(:mult_op_prods) { alternate_prods(mult_op, mult_operators) }
+    let(:factor_prods) do
+      alternatives = [
+        [number],
+        [grm1_ops['-'], factor],
+        [grm1_ops['('], expression, grm1_ops[')']]
+      ]
+      alternate_prods(factor, alternatives)
+    end
+    let(:term_prods) do
+      alternatives = [[factor], [term, mult_op, factor]]
+      alternate_prods(term, alternatives)
+    end
+    let(:expression_prods) do
+      alternatives = [ [term], [expression, add_op, term]]
+      alternate_prods(expression, alternatives)
+    end
+
+    # Grammar 2: A very simple language
+    # S ::= A.
+    # A ::= "a" A "c".
+    # A ::= "b".
+    let(:nt_S) { NonTerminal.new('S') }
+    let(:nt_A) { NonTerminal.new('A') }
+    let(:a_) { VerbatimSymbol.new('a') }
+    let(:b_)  { VerbatimSymbol.new('b') }
+    let(:c_)  { VerbatimSymbol.new('c') }
+    let(:prod_S) { Production.new(nt_S, [nt_A]) }
+    let(:prod_A1) { Production.new(nt_A, [a_, nt_A, c_]) }
+    let(:prod_A2) { Production.new(nt_A, [b_]) }
+
+=begin
+    # Non-terminals that specify the lexicon of the language
+    let(:noun) { NonTerminal.new('Noun') }
+    let(:noun_list) { %w(flights breeze trip morning) }
+    let(:verb) { NonTerminal.new('Verb') }
+    let(:verb_list) { %w(is prefer like need want fly) }
+    let(:adjective) { NonTerminal.new('Adjective') }
+    let(:adjective_list) { %w(cheapest non-stop first latest other direct) }
+    let(:pronoun) { NonTerminal.new('Pronoun') }
+    let(:pronoun_list) { %w(me I you it) }
+    let(:proper_noun) { NonTerminal.new('Proper_noun') }
+    let(:proper_noun_list) do [ 'Alaska', 'Baltimore', 'Los Angeles',
+      'Chicago', 'United', 'American' ]
+    end
+    let(:determiner) { NonTerminal.new('Determiner') }
+    let(:determiner_list) { %w(the a an this these that) }
+    let(:preposition) { NonTerminal.new('Preposition') }
+    let(:preposition_list) { %w(from to on near) }
+    let(:conjunction) { NonTerminal.new('Conjunction') }
+    let(:conjunction_list) { %w(and or but) }
+
+
+
+
+    let(:noun_prods) { prods_for_list(noun, noun_list) }
+    let(:verb_prods) { prods_for_list(verb, verb_list) }
+    let(:adjective_prods) { prods_for_list(adjective, adjective_list) }
+    let(:pronoun_prods) { prods_for_list(pronoun, pronoun_list) }
+    let(:proper_pronoun_prods) do
+      prods_for_list(proper_pronoun, proper_pronoun_list)
+    end
+    let(:determiner_prods) { prods_for_list(determiner, determiner_list) }
+    let(:preposition_prods) { prods_for_list(preposition, preposition_list) }
+    let(:conjunction_prods) { prods_for_list(conjunction, conjunction_list) }
+
+    # Productions for the L0 language (from Jurafki & Martin)
+    let(:nominal_prods) { Production}
+=end
+
+    context 'Initialization:' do
+      subject do
+        productions = [prod_S, prod_A1, prod_A2]
+        Grammar.new(productions)
+      end
+
+      it 'should be created with a list of productions' do
+        expect { Grammar.new([prod_S, prod_A1, prod_A2]) }.not_to raise_error
+      end
+
+      it 'should know its productions' do
+        expect(subject.rules).to eq([prod_S, prod_A1, prod_A2])
+      end
+
+      it 'should know its start symbol' do
+        expect(subject.start_symbol).to eq(nt_S)
+      end
+
+      it 'should know all its symbols' do
+        expect(subject.symbols).to eq([nt_S, nt_A, a_, c_, b_])
+      end
+    end # context
+
+  end # describe
+
+  end # module
+end # module
+
+# End of file