rley 0.0.04 → 0.0.05

data/spec/rley/parser/token_spec.rb

@@ -7,34 +7,32 @@ 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
 
-  describe Token do
+      let(:lexeme) { '"some text"' }
+      let(:sample_terminal) { Syntax::Terminal.new('if') }
 
-    let(:lexeme) { '"some text"' }
-    let(:sample_terminal) { Syntax::Terminal.new('if') }
+      context 'Initialization:' do
 
-    context 'Initialization:' do
 
+        # Default instantiation rule
+        subject { Token.new(lexeme, sample_terminal) }
 
-      # 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 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 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
+        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
+# End of file

data/spec/rley/syntax/grammar_spec.rb

@@ -9,141 +9,139 @@ 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
 
-  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
 
-    # 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)
+        return prods
       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)
+      def build_verbatim_symbols(symbols)
+        result = {}
+        symbols.each { |symb| result[symb] = VerbatimSymbol.new(symb) }
+        result
       end
 
-      it 'should be created with a list of productions' do
-        expect { Grammar.new([prod_S, prod_A1, prod_A2]) }.not_to raise_error
+      # Grammar 1: arithmetical expressions with integers
+      let(:grm1_ops) do
+        operators = %w[+ - * / ( ) ]
+        build_verbatim_symbols(operators)
       end
 
-      it 'should know its productions' do
-        expect(subject.rules).to eq([prod_S, prod_A1, prod_A2])
+      # Grammar symbols for integer arithmetic expressions
+      let(:number) { Literal.new('number', /\d+/) }   # Positive integers only
+      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_]) }
 
-      it 'should know its start symbol' do
-        expect(subject.start_symbol).to eq(nt_S)
+=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) }
+
 
-      it 'should know all its symbols' do
-        expect(subject.symbols).to eq([nt_S, nt_A, a_, c_, b_])
+
+
+      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
-    end # context
+      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
 
-  end # describe
+        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
+# End of file

data/spec/rley/syntax/grm_symbol_spec.rb

@@ -5,25 +5,22 @@ require_relative '../../../lib/rley/syntax/grm_symbol'
 
 module Rley # Open this namespace to avoid module qualifier prefixes
   module Syntax # Open this namespace to avoid module qualifier prefixes
+    describe GrmSymbol do
+      let(:sample_name) { 'NP' }
+      subject { GrmSymbol.new(sample_name) }
 
-  describe GrmSymbol do
-    let(:sample_name) { 'NP' }
-    subject { GrmSymbol.new(sample_name) }
+      context 'Initialization:' do
+        it 'should be created with a name' do
+          expect { GrmSymbol.new('NP') }.not_to raise_error
+        end
 
-    context 'Initialization:' do
-      it 'should be created with a name' do
-        expect { GrmSymbol.new('NP') }.not_to raise_error
-      end
-
-      it 'should know its name' do
-        expect(subject.name).to eq(sample_name)
-      end
-    end # context
-
-  end # describe
+        it 'should know its name' do
+          expect(subject.name).to eq(sample_name)
+        end
+      end # context
 
+    end # describe
   end # module
 end # module
 
 # End of file
-

data/spec/rley/syntax/literal_spec.rb

@@ -5,28 +5,26 @@ require_relative '../../../lib/rley/syntax/literal'
 
 module Rley # Open this namespace to avoid module qualifier prefixes
   module Syntax # Open this namespace to avoid module qualifier prefixes
+    describe Literal do
+      let(:sample_name) { 'ordinal' }
+      subject { Literal.new(sample_name, /\d+/) }
 
-  describe Literal do
-    let(:sample_name) { 'ordinal' }
-    subject { Literal.new(sample_name, /\d+/) }
+      context 'Initialization:' do
+        it 'should be created with a name and regexp' do
+          expect { Literal.new(sample_name, /\d+/) }.not_to raise_error
+        end
 
-    context 'Initialization:' do
-      it 'should be created with a name and regexp' do
-        expect { Literal.new(sample_name, /\d+/) }.not_to raise_error
-      end
+        it 'should know its name' do
+          expect(subject.name).to eq(sample_name)
+        end
 
-      it 'should know its name' do
-        expect(subject.name).to eq(sample_name)
-      end
-
-      it 'should know its pattern' do
-        expect(subject.pattern).to eq(/\d+/)
-      end
-    end # context
-
-  end # describe
+        it 'should know its pattern' do
+          expect(subject.pattern).to eq(/\d+/)
+        end
+      end # context
 
+    end # describe
   end # module
 end # module
 
-# End of file
+# End of file

data/spec/rley/syntax/non_terminal_spec.rb

@@ -5,25 +5,22 @@ require_relative '../../../lib/rley/syntax/non_terminal'
 
 module Rley # Open this namespace to avoid module qualifier prefixes
   module Syntax # Open this namespace to avoid module qualifier prefixes
+    describe NonTerminal do
+      let(:sample_name) { 'noun' }
+      subject { NonTerminal.new(sample_name) }
 
-  describe NonTerminal do
-    let(:sample_name) { 'noun' }
-    subject { NonTerminal.new(sample_name) }
+      context 'Initialization:' do
+        it 'should be created with a name' do
+          expect { NonTerminal.new('noun') }.not_to raise_error
+        end
 
-    context 'Initialization:' do
-      it 'should be created with a name' do
-        expect { NonTerminal.new('noun') }.not_to raise_error
-      end
-
-      it 'should know its name' do
-        expect(subject.name).to eq(sample_name)
-      end
-    end # context
-
-  end # describe
+        it 'should know its name' do
+          expect(subject.name).to eq(sample_name)
+        end
+      end # context
 
+    end # describe
   end # module
 end # module
 
 # End of file
-

data/spec/rley/syntax/production_spec.rb

@@ -9,41 +9,39 @@ require_relative '../../../lib/rley/syntax/production'
 
 module Rley # Open this namespace to avoid module qualifier prefixes
   module Syntax # Open this namespace to avoid module qualifier prefixes
-
-  describe Production do
-    let(:sentence) { NonTerminal.new('Sentence') }
-    let(:np) { NonTerminal.new('NP') }
-    let(:vp) { NonTerminal.new('VP') }
-    let(:sequence) { [np, vp] }
-
-    # Default instantiation rule
-    subject { Production.new(sentence, sequence) }
-
-    context 'Initialization:' do
-      it 'should be created with a non-terminal and a symbol sequence' do
-        expect { Production.new(sentence, sequence) }.not_to raise_error
-      end
-
-      it 'should know its lhs' do
-        expect(subject.lhs).to eq(sentence)
-        expect(subject.head).to eq(sentence)
-      end
-
-      it 'should know its rhs' do
-        expect(subject.rhs).to eq(sequence)
-        expect(subject.body).to eq(sequence)
-      end
-
-      it 'should know whether its rhs is empty' do
-        expect(subject).not_to be_empty
-
-        instance = Production.new(sentence, [])
-        expect(instance).to be_empty
-      end
-    end # context
-
-  end # describe
-
+    describe Production do
+      let(:sentence) { NonTerminal.new('Sentence') }
+      let(:np) { NonTerminal.new('NP') }
+      let(:vp) { NonTerminal.new('VP') }
+      let(:sequence) { [np, vp] }
+
+      # Default instantiation rule
+      subject { Production.new(sentence, sequence) }
+
+      context 'Initialization:' do
+        it 'should be created with a non-terminal and a symbol sequence' do
+          expect { Production.new(sentence, sequence) }.not_to raise_error
+        end
+
+        it 'should know its lhs' do
+          expect(subject.lhs).to eq(sentence)
+          expect(subject.head).to eq(sentence)
+        end
+
+        it 'should know its rhs' do
+          expect(subject.rhs).to eq(sequence)
+          expect(subject.body).to eq(sequence)
+        end
+
+        it 'should know whether its rhs is empty' do
+          expect(subject).not_to be_empty
+
+          instance = Production.new(sentence, [])
+          expect(instance).to be_empty
+        end
+      end # context
+
+    end # describe
   end # module
 end # module