rley 0.0.08 → 0.0.09

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MzI5OGY5NWE3MzQ1OGQ4NjFmOGIyMjQ4ZTM4Y2M0NzE4YTg2ZmRhMQ==
+    NjMyOTZiYzU4MjllMDU0NjlmYTZjZWIxNWY1Y2U0YTlmYjQzOWQxMg==
   data.tar.gz: !binary |-
-    MmNhYWMxODI3YjQ1NTMyYzk4NmE5NDk3Yzc4YTc4NTQzNjk0MzNkZg==
+    NzlhZDNkZGIwZTMzMzJhZmQyYWVlODE5MzUzODQ4NWNmMzFiY2M2ZQ==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    MDZmZGFhMDVjMGI1YjQ0ZGUwNjIyMmMwNzBkYWRkOTVkMGU4ZGJhNGQ3ZDFi
-    YzRmMTdlMDBhZTlhOWZlMWVlNjM1ZWRhZWY5NzQ2Y2EyNDJhYzg2YWJhYjU3
-    YjNmMTQ5MzgwNmRlYTEyNmEyNTc1YjdhZjgxNTQ4YTNmYTA2MjA=
+    MjU2MjE0ZGQwZDE2MjU1OGIzYzRkZjc4ZDZmNzI4ODQ3YmY2NGQ4MWY4YWFk
+    NTQzZGY0YjNhMjUwNWUzOWYwMjM0ZTk2ODRlMjQ3M2RhNWViMWU4ZGEwNjEx
+    ODQzOTk5MzM1NzE3MTY3ZWRiOGNmZWIwOWY2YTE4MzVkM2ViOGU=
   data.tar.gz: !binary |-
-    ZGE3MDM5OTNlNDEwN2EwMTQzZGQ2ZmMzNmUyNjVmMGY2MmQ0MjRlMWJkMmM1
-    NDI3YWEzNTlhYTQzMDZlNDZjYmI1NzNiNTYwMDI0NGY4NmI4NGQ4Yjc3OGQ5
-    ZmE4MDQ3ZjZmYTljYTg0YjEyOWYzMmU5ODUyOTU4Yjk5MWJjZGY=
+    YzczYTY4Y2FlMWUyZWNhMjEyYjhhM2RkMzk0YzNmNjQ0MTE4NGZiMjQ2MDY2
+    Y2IzOGI1YjNjNzgyZTNlMmMyNzAyYjc3MDQzYjY2YzkzZmVjZDE5OThkZTc5
+    ZTMzMGVmNGUwYjk0Y2QxN2E3OGJjNGI0MWE0ZDRlZTRkYmY2NGM=

data/CHANGELOG.md

@@ -1,6 +1,12 @@
+### 0.0.09 / 2014-11-15
+* [NEW]  New class `GrammarBuilder` added and tested, its purpose is 
+to simplify the construction of grammars.
+
+
 ### 0.0.08 / 2014-11-14
 * [CHANGE]  `EarleyParser#parse` method: Initial API documentation.
-* [INFO] This version was committed to force Travis CI to execute a complete build (failed because Travis couldn't connect to GitHub)
+* [INFO] This version was committed to force Travis CI to execute a complete build 
+failed because Travis couldn't connect to GitHub)
 
 ### 0.0.07 / 2014-11-14
 * [CHANGE]  spec file of `EarleyParser` class: Test added. Parser works with simple expression grammar.

data/lib/rley/constants.rb

@@ -3,7 +3,7 @@
 
 module Rley # Module used as a namespace
   # The version number of the gem.
-  Version = '0.0.08'
+  Version = '0.0.09'
 
   # Brief description of the gem.
   Description = "Ruby implementation of the Earley's parsing algorithm"

data/lib/rley/parser/earley_parser.rb

@@ -20,8 +20,8 @@ module Rley # This module is used as a namespace
       # after "advancing" the dot
       attr_reader(:next_mapping)
 
-      # @param aGrammar [Grammar] A context-free grammar that defines the language
-      # of the input to be parsed.
+      # @param aGrammar [Grammar] A context-free grammar that defines the 
+      # language of the input to be parsed.
       def initialize(aGrammar)
         @grammar = aGrammar
         @dotted_items = build_dotted_items(grammar)

data/lib/rley/syntax/grammar_builder.rb

@@ -0,0 +1,114 @@
+require_relative 'verbatim_symbol'
+require_relative 'literal'
+require_relative 'non_terminal'
+require_relative 'production'
+require_relative 'grammar'
+
+module Rley # This module is used as a namespace
+  module Syntax # This module is used as a namespace
+    # Builder pattern. Builder pattern builds a complex object
+    # (say, a grammar) from simpler objects (terminals and productions)
+    # and using a step by step approach.
+    class GrammarBuilder
+      # The list of symbols of the language.
+      # Grammar symbols are categorized into terminal (symbol)
+      # and non-terminal (symbol).
+      attr_reader(:symbols)
+
+      # The list of production rules for the grammar to build
+      attr_reader(:productions)
+
+      def initialize()
+        @symbols = {}
+        @productions = []
+      end
+
+      # Retrieve a grammar symbol from its name.
+      # Raise an exception if not found.
+      # @param [aSymbolName] the name of a symbol grammar.
+      # @return [GrmSymbol] the retrieved symbol.
+      def [](aSymbolName)
+        return symbols[aSymbolName]
+      end
+
+      # Add the terminal symbols of the language
+      # terminalSymbols [String or Terminal] one or more terminal symbols
+      # to add to the grammar.
+      def add_terminals(*terminalSymbols)
+        new_symbs = build_symbols(Terminal, terminalSymbols)
+        symbols.merge!(new_symbs)
+      end
+
+      # Add the non-terminal symbols of the language
+      # nonTerminalSymbols [String or NonTerminal] one or more non-terminal
+      # symbols to add to the grammar.
+      def add_non_terminals(*nonTerminalSymbols)
+        new_symbs = build_symbols(NonTerminal, nonTerminalSymbols)
+        symbols.merge!(new_symbs)
+      end
+
+      # builder.add_production('A' => ['a', 'A', 'c'])
+      def add_production(aProductionRepr)
+        aProductionRepr.each_pair do |(lhs_name, rhs_repr)|
+          lhs = self[lhs_name]
+          case rhs_repr
+            when Array
+              rhs_constituents = rhs_repr.map { |name| self[name] }
+            when String
+              rhs_constituents = [ self[rhs_repr] ]
+          end
+          new_prod = Production.new(lhs, rhs_constituents)
+          productions << new_prod
+        end
+      end
+
+      # Given the grammar symbols and productions added to the builder,
+      # build the resulting grammar.
+      def grammar()
+        fail StandardError, 'No symbol found for grammar' if symbols.empty?
+        if productions.empty?
+          fail StandardError, 'No production found for grammar'
+        end
+
+        return Grammar.new(productions.dup)
+      end
+
+      private
+
+      # Add the given grammar symbols.
+      # @param aClass [Class] The class of grammar symbols to instantiate.
+      # @param aSymbol [Array] array of elements are treated as follows:
+      #   if the element is already a grammar symbol, then it added as is,
+      #   otherwise it is considered as the name of a grammar symbol
+      # of the specified class to build.
+      def build_symbols(aClass, theSymbols)
+        symbs = {}
+        theSymbols.each do |s|
+          new_symbol = build_symbol(aClass, s)
+          symbs[new_symbol.name] = new_symbol
+        end
+
+        return symbs
+      end
+
+
+      # If the argument is already a grammar symbol object then it is
+      # returned as is. Otherwise, the argument is treated as a name
+      # for a new instance of the given class.
+      # @param aClass [Class] The class of grammar symbols to instantiate
+      # @param aSymbol [GrmSymbol-like or String]
+      # @return [Array] list of grammar symbols
+      def build_symbol(aClass, aSymbolArg)
+        if aSymbolArg.kind_of?(GrmSymbol)
+          a_symbol = aSymbolArg
+        else
+          a_symbol = aClass.new(aSymbolArg)
+        end
+
+        return a_symbol
+      end
+    end # class
+  end # module
+end # module
+
+# End of file

data/lib/rley/syntax/production.rb

@@ -22,7 +22,7 @@ module Rley # This module is used as a namespace
       alias_method :head, :lhs
 
       def initialize(aNonTerminal, theSymbols)
-        @lhs = aNonTerminal
+        @lhs = valid_lhs(aNonTerminal)
         @rhs = SymbolSeq.new(theSymbols)
       end
 
@@ -31,6 +31,20 @@ module Rley # This module is used as a namespace
       def empty?()
         return rhs.empty?
       end
+
+      private
+
+      # Validation method. Return the validated input argument or
+      # raise an exception.
+      def valid_lhs(aNonTerminal)
+        unless aNonTerminal.kind_of?(NonTerminal)
+          msg_prefix = 'Left side of production must be a non-terminal symbol'
+          msg_suffix = ", found a #{aNonTerminal.class} instead."
+          fail StandardError, msg_prefix + msg_suffix
+        end
+
+        return aNonTerminal
+      end
     end # class
   end # module
 end # module

data/spec/rley/parser/earley_parser_spec.rb

@@ -282,7 +282,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
             { origin: 0, production: prod_S2, dot: -1 },
             { origin: 0, production: prod_M1, dot: 1 },
             { origin: 0, production: prod_P, dot: -1 },
-            { origin: 0, production: prod_S1, dot: 1 },
+            { origin: 0, production: prod_S1, dot: 1 }
           ]
           compare_state_set(parse_result.chart[1], expectations)
 
@@ -297,7 +297,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
             { origin: 0, production: prod_S1, dot: 2 },
             { origin: 2, production: prod_M1, dot: 0 },
             { origin: 2, production: prod_M2, dot: 0 },
-            { origin: 2, production: prod_T, dot: 0 },
+            { origin: 2, production: prod_T, dot: 0 }
           ]
           compare_state_set(parse_result.chart[2], expectations)
 
@@ -324,7 +324,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
           expectations = [
             { origin: 2, production: prod_M1, dot: 2 },
-            { origin: 4, production: prod_T, dot: 0 },
+            { origin: 4, production: prod_T, dot: 0 }
           ]
           compare_state_set(parse_result.chart[4], expectations)
 

data/spec/rley/syntax/grammar_builder_spec.rb

@@ -0,0 +1,142 @@
+require_relative '../../spec_helper'
+
+# Load the class under test
+require_relative '../../../lib/rley/syntax/grammar_builder'
+
+module Rley # Open this namespace to avoid module qualifier prefixes
+  module Syntax # Open this namespace to avoid module qualifier prefixes
+    describe GrammarBuilder do
+
+      context 'Initialization:' do
+        it 'should be created without argument' do
+          expect { GrammarBuilder.new }.not_to raise_error
+        end
+        
+        it 'should have no grammar symbols at start' do
+            expect(subject.symbols).to be_empty
+        end
+
+        it 'should have no productions at start' do
+            expect(subject.productions).to be_empty
+        end
+
+      end # context
+
+      context 'Adding symbols:' do
+        it 'should build terminals from their names' do
+          subject.add_terminals('a', 'b', 'c')
+          expect(subject.symbols.size).to eq(3)
+          expect(subject.symbols['a']).to be_kind_of(Terminal)
+          expect(subject.symbols['a'].name).to eq('a')
+          expect(subject.symbols['b']).to be_kind_of(Terminal)
+          expect(subject.symbols['b'].name).to eq('b')
+          expect(subject.symbols['c']).to be_kind_of(Terminal)
+          expect(subject.symbols['c'].name).to eq('c')
+        end
+
+        it 'should accept already built terminals' do
+          a = Terminal.new('a')
+          b = VerbatimSymbol.new('b')
+          c = Literal.new('c', /c/)
+
+          subject.add_terminals(a, b, c)
+          expect(subject.symbols.size).to eq(3)
+          expect(subject.symbols['a']).to eq(a)
+          expect(subject.symbols['b']).to eq(b)
+          expect(subject.symbols['c']).to eq(c)
+        end
+        
+        it 'should build non-terminals from their names' do
+          subject.add_non_terminals('PP', 'VP', 'DT')
+          expect(subject.symbols.size).to eq(3)
+          expect(subject.symbols['PP']).to be_kind_of(NonTerminal)
+          expect(subject.symbols['PP'].name).to eq('PP')
+          expect(subject.symbols['VP']).to be_kind_of(NonTerminal)
+          expect(subject.symbols['VP'].name).to eq('VP')
+          expect(subject.symbols['DT']).to be_kind_of(NonTerminal)
+          expect(subject.symbols['DT'].name).to eq('DT')
+        end
+
+        it 'should accept already built terminals' do
+          a = Terminal.new('a')
+          b = VerbatimSymbol.new('b')
+          c = Literal.new('c', /c/)
+
+          subject.add_terminals(a, b, c)
+          expect(subject.symbols.size).to eq(3)
+          expect(subject.symbols['a']).to eq(a)
+          expect(subject.symbols['b']).to eq(b)
+          expect(subject.symbols['c']).to eq(c)
+        end
+      end # context
+      
+      context 'Adding productions:' do
+        subject do
+          instance = GrammarBuilder.new
+          instance.add_terminals('a', 'b', 'c')
+          instance.add_non_terminals('S', 'A')
+          instance
+        end
+        
+        it 'should add a valid production' do
+          # case of a rhs representation that consists of one name
+          expect { subject.add_production('S' => 'A') }.not_to raise_error
+          expect(subject.productions.size).to eq(1)
+          new_prod = subject.productions[0]
+          expect(new_prod.lhs).to eq(subject['S'])
+          expect(new_prod.rhs[0]).to eq(subject['A'])
+          
+          subject.add_production('A' => %w(a A c))
+          expect(subject.productions.size).to eq(2)
+          new_prod = subject.productions.last
+          expect(new_prod.lhs).to eq(subject['A'])
+          expect_rhs = [ subject['a'], subject['A'], subject['c'] ]
+          expect(new_prod.rhs.members).to eq(expect_rhs)
+          
+          subject.add_production('A' => ['b'])
+          expect(subject.productions.size).to eq(3)
+          new_prod = subject.productions.last
+          expect(new_prod.lhs).to eq(subject['A'])
+          expect(new_prod.rhs[0]).to eq(subject['b'])
+        end 
+      end # context
+      
+      context 'Building grammar:' do
+        subject do
+          instance = GrammarBuilder.new
+          instance.add_terminals('a', 'b', 'c')
+          instance.add_non_terminals('S', 'A')
+          instance.add_production('S' => ['A'])
+          instance.add_production('A' => %w(a A c))
+          instance.add_production('A' => ['b'])
+          instance
+        end
+        
+        it 'should build a grammar' do
+          expect(subject.grammar).to be_kind_of(Grammar)
+          grm = subject.grammar
+          expect(grm.rules).to eq(subject.productions)
+        end
+        
+        it 'should complain in absence of symbols' do
+          instance = GrammarBuilder.new
+          err = StandardError
+          msg = 'No symbol found for grammar'
+          expect { instance.grammar }.to raise_error(err, msg)
+        end
+        
+        it 'should complain in absence of productions' do
+          instance = GrammarBuilder.new
+          instance.add_terminals('a', 'b', 'c')
+          instance.add_non_terminals('S', 'A')
+          err = StandardError
+          msg = 'No production found for grammar'
+          expect { instance.grammar }.to raise_error(err, msg)
+        end
+      end
+
+    end # describe
+  end # module
+end # module
+
+# End of file

data/spec/rley/syntax/production_spec.rb

@@ -39,6 +39,15 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           instance = Production.new(sentence, [])
           expect(instance).to be_empty
         end
+        
+        it 'should complain if its lhs is not a non-terminal' do
+          err = StandardError
+          msg_prefix = 'Left side of production must be a non-terminal symbol'
+          msg_suffix = ", found a #{String} instead."  
+          msg = msg_prefix + msg_suffix
+          expect { Production.new('wrong', sequence) }.to raise_error(err, msg)
+
+        end
       end # context
 
     end # describe

data/spec/rley/syntax/symbol_seq_spec.rb

@@ -41,7 +41,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       context 'Provided services:' do
         it 'should compare compare with itself' do
-          me = subject
+          me = subject  # Use another name to please Rubocop
           expect(subject == me).to eq(true)
         end
 
@@ -55,6 +55,12 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           unequal_one = SymbolSeq.new([verb, pp, np])
           expect(subject == unequal_one).not_to eq(true)
         end
+        
+        it 'should complain when unable to compare' do
+          err = StandardError
+          msg = 'Cannot compare a SymbolSeq with a Fixnum'
+          expect { subject == 1 }.to raise_error(err, msg)
+        end
       end # context
 
     end # describe

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rley
 version: !ruby/object:Gem::Version
-  version: 0.0.08
+  version: 0.0.09
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-14 00:00:00.000000000 Z
+date: 2014-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -94,6 +94,7 @@ files:
 - lib/rley/parser/state_set.rb
 - lib/rley/parser/token.rb
 - lib/rley/syntax/grammar.rb
+- lib/rley/syntax/grammar_builder.rb
 - lib/rley/syntax/grm_symbol.rb
 - lib/rley/syntax/literal.rb
 - lib/rley/syntax/non_terminal.rb
@@ -108,8 +109,7 @@ files:
 - spec/rley/parser/parsing_spec.rb
 - spec/rley/parser/state_set_spec.rb
 - spec/rley/parser/token_spec.rb
-- spec/rley/support/grammar_abc.rb
-- spec/rley/support/grammar_helper.rb
+- spec/rley/syntax/grammar_builder_spec.rb
 - spec/rley/syntax/grammar_spec.rb
 - spec/rley/syntax/grm_symbol_spec.rb
 - spec/rley/syntax/literal_spec.rb
@@ -158,6 +158,7 @@ test_files:
 - spec/rley/parser/parsing_spec.rb
 - spec/rley/parser/state_set_spec.rb
 - spec/rley/parser/token_spec.rb
+- spec/rley/syntax/grammar_builder_spec.rb
 - spec/rley/syntax/grammar_spec.rb
 - spec/rley/syntax/grm_symbol_spec.rb
 - spec/rley/syntax/literal_spec.rb

data/spec/rley/support/grammar_abc.rb

@@ -1,22 +0,0 @@
-require_relative '../../../lib/rley/syntax/verbatim_symbol'
-require_relative '../../../lib/rley/syntax/non_terminal'
-require_relative '../../../lib/rley/syntax/production'
-require_relative '../../../lib/rley/parser/token'
-
-
-
-      # Grammar 1: A very simple language
-      # (based on example in N. Wirth "Compiler Construction" book, p. 6)
-      # 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]) }

data/spec/rley/support/grammar_helper.rb

@@ -1,16 +0,0 @@
-require_relative '../../../lib/rley/syntax/verbatim_symbol'
-require_relative '../../../lib/rley/syntax/non_terminal'
-require_relative '../../../lib/rley/syntax/production'
-require_relative '../../../lib/rley/syntax/grammar'
-
-module Rley # This module is used as a namespace
-  # Mix-in module that provides factory methods that simplify the construction 
-  # of a grammar from its constituents.
-  module GrammarHelper
-    # Create a production
-    def production()
-    end
-  end # module
-end # module
-
-# End of file