rley 0.6.03 → 0.6.04

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0100f83a11838d8f996fdb6057f3292cb8377562
-  data.tar.gz: d497a30317385d5aac6adbc247a0162abb59b57d
+  metadata.gz: 7dde019f49699000c53d19d500ccf1e5497ab155
+  data.tar.gz: 967a24d5da4566776c5d011971801aec07e0dbc8
 SHA512:
-  metadata.gz: db578e84d91d34009b07badaab7070ad2fbc6d0d5b042ac2f9e75edaa6a75d8bba15543b3c5cf017f4821bc8695791e91b48c8ebdac6896069e55ba8d96b51d1
-  data.tar.gz: efffade432255e86a4939bd36d306f1a35203267a6fcbeb72df9b60a62d92342a0ea56d978499a01b9d0dfce533e9b7858a38c8b1e3dacca5bc5524adfcf8802
+  metadata.gz: 6415d986dd8296c28f7af9d32b8329a03c8861386830eb915ffa196de311848420cd35a171d661a7ce68948d428b224f1a8c2f009aa2b734477eecb9bf32a679
+  data.tar.gz: a0453cd6917b6658d549053216cfb9134ec5dc3e7de7e6cf0e2f3240502532077897264d456be748c7bdd8a5adeb9104f266b8004f7d19fef0e9fe9db3ade1c9

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+### 0.6.04 / 2018-03-30
+* [CHANGE] Method `GrammarBuilder#add_production` Simplified rule entry syntax
+* [CHANGE] File `examples/NML/pico_en_demo.rb` updated to reflect the simplified rule syntax.
+* [CHANGE] File `README.md` updated to reflect the simplified rule syntax.
+* [CHANGE] Struct EngineConfig added the diganose field.
+* [FIX] Method `Production#initialize`: Now raises an exception when rhs is nil
+* [FIX] Method `ParseTreeBuilder#create_tree`: Now raises an exception when root node of tree is nil
+* [FIX] Method `GFGParsing#nullable_rule`: Nasty bug with antecedent link fixed.
+
 ### 0.6.03 / 2018-03-10
 * [CHANGE] File `lib/parser/error_reason.rb` Improved error location reporting
 * [CHANGE] File `README.md` updated to reflect the improved error location reporting.

data/README.md

@@ -107,13 +107,13 @@ The subset of English grammar is based on an example from the NLTK book.
       add_terminals('Determiner', 'Preposition')
 
       # Here we define the productions (= grammar rules)
-      rule 'S' => %w[NP VP]
+      rule 'S' => 'NP VP'
       rule 'NP' => 'Proper-Noun'
-      rule 'NP' => %w[Determiner Noun]
-      rule 'NP' => %w[Determiner Noun PP]
-      rule 'VP' => %w[Verb NP]
-      rule 'VP' => %w[Verb NP PP]
-      rule 'PP' => %w[Preposition NP]
+      rule 'NP' => 'Determiner Noun'
+      rule 'NP' => 'Determiner Noun PP'
+      rule 'VP' => 'Verb NP'
+      rule 'VP' => 'Verb NP PP'
+      rule 'PP' => 'Preposition NP'
     end
 ```  
 

data/examples/NLP/pico_en_demo.rb

@@ -21,13 +21,13 @@ engine.build_grammar do
   add_terminals('Determiner', 'Preposition')
 
   # Here we define the productions (= grammar rules)
-  rule 'S' => %w[NP VP]
+  rule 'S' => 'NP VP'
   rule 'NP' => 'Proper-Noun'
-  rule 'NP' => %w[Determiner Noun]
-  rule 'NP' => %w[Determiner Noun PP]
-  rule 'VP' => %w[Verb NP]
-  rule 'VP' => %w[Verb NP PP]
-  rule 'PP' => %w[Preposition NP]
+  rule 'NP' => 'Determiner Noun'
+  rule 'NP' => 'Determiner Noun PP'
+  rule 'VP' => 'Verb NP'
+  rule 'VP' => 'Verb NP PP'
+  rule 'PP' => 'Preposition NP'
 end
 
 ########################################
@@ -98,7 +98,7 @@ end
 
 ########################################
 # Step 5. Parse the input
-input_to_parse = 'John saw Mary with a '
+input_to_parse = 'John saw Mary with a telescope'
 # input_to_parse = 'the dog saw a man in the park' # This one is ambiguous
 # Convert input text into a sequence of token objects...
 tokens = tokenizer(input_to_parse)

data/lib/rley/constants.rb

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

data/lib/rley/engine.rb

@@ -5,12 +5,14 @@ require_relative './parse_rep/parse_tree_factory'
 module Rley # This module is used as a namespace
   EngineConfig = Struct.new(
     :parse_repr,
-    :repr_builder
+    :repr_builder,
+    :diagnose
   ) do
     def initialize()
       super()
       self.parse_repr = :parse_tree
       self.repr_builder = :default
+      self.diagnose = false
     end
   end
 
@@ -18,7 +20,12 @@ module Rley # This module is used as a namespace
   # an Engine object provides a higher-level interface that shields
   # Rley client code from the lower-level classes.
   class Engine
+    # @!attribute [r] configuration
+    #   @return [EngineConfig] the engine's configuration 
     attr_reader :configuration
+    
+    # @!attribute [r] grammar
+    #   @return [Rley::Syntax::Grammar] the grammar of the language to parse    
     attr_reader :grammar
 
     # Constructor.
@@ -28,7 +35,7 @@ module Rley # This module is used as a namespace
     end
 
     # Factory method.
-    # @param &aBlock [Proc, Lambda] Code block for creating the grammar.
+    # @param aBlock [Proc, Lambda] Code block for creating the grammar.
     def build_grammar(&aBlock)
       builder = Rley::Syntax::GrammarBuilder.new(&aBlock)
       @grammar = builder.grammar
@@ -53,6 +60,7 @@ module Rley # This module is used as a namespace
         tokens << a_token
       end
       parser = build_parser(grammar)
+      parser.gf_graph.diagnose if configuration.diagnose
       return parser.parse(tokens)
     end
 

data/lib/rley/parse_rep/ast_base_builder.rb

@@ -68,7 +68,7 @@ module Rley # This module is used as a namespace
       # Simply return an epsilon symbol
       # @param _range [Lexical::TokenRange]
       # @param _tokens [Array<Lexical::Token>]
-      # @param _hildren [Array<Object>]       
+      # @param _children [Array<Object>]       
       def return_epsilon(_range, _tokens, _children)
         return nil
       end
@@ -84,7 +84,7 @@ module Rley # This module is used as a namespace
 
       # Factory method for creating a node object for the given
       # input token.
-      # @param aTerminal [Syntax::Production] Relevant production rule
+      # @param aProduction [Syntax::Production] Relevant production rule
       # @param aTerminal [Syntax::Terminal] Terminal associated with the token
       # @param aTokenPosition [Integer] Position of token in the input stream
       # @param aToken [Lexical::Token] The input token

data/lib/rley/parse_rep/parse_tree_builder.rb

@@ -79,6 +79,7 @@ module Rley # This module is used as a namespace
       # Create a parse tree object with given
       # node as root node.
       def create_tree(aRootNode)
+        raise StandardError, 'Root node of parse tree is nil!' if aRootNode.nil?
         return Rley::PTree::ParseTree.new(aRootNode)
       end      
 

data/lib/rley/parser/error_reason.rb

@@ -9,7 +9,7 @@ module Rley # Module used as a namespace
       attr_reader(:rank)
 
       # Constructor
-      # @param aPosition [Fixnum] The rank number of the offending input token
+      # @param aRank [Fixnum] The sequence number of the offending input token.
       def initialize(aRank)
         @rank = aRank
       end

data/lib/rley/parser/gfg_parsing.rb

@@ -66,18 +66,29 @@ module Rley # This module is used as a namespace
       # This method is invoked when a dotted entry is added
       # to the parse entry set of the from [A => alpha . B beta, k]
       # and B is nullable
-      # Then the entry [A => alpha B . beta, k] is added to the current
-      # sigma set.
+      # Then the following entries are added to the current sigma set:
+      # [.B, i]
+      # [B => ., i] TODO: what if indirectly nullable?
+      # [B., i]
+      # [A => alpha B . beta, k]
       def nullable_rule(anEntry, aPosition)
         next_symbol = anEntry.next_symbol
-        end_vertex = gf_graph.end_vertex_for[next_symbol]
         pos = aPosition
-        end_entry = push_entry(end_vertex, anEntry.origin, pos, :nullable_rule)
+        start = gf_graph.start_vertex_for[next_symbol]
+        start_entry = apply_rule(anEntry, start, pos, pos, :nullable_rule)
+
+        end_vertex = gf_graph.end_vertex_for[next_symbol]
+        end_entry = push_entry(end_vertex, pos, pos, :nullable_rule)
+
+        start.edges.each do |edge|
+          succ = edge.successor # succ always an ItemVertex
+          next if succ.dotted_item.production.generative?
+          succ_entry = apply_rule(start_entry, succ, pos, pos, :nullable_rule)
+          apply_rule(succ_entry, end_vertex, pos, pos, :nullable_rule)
+        end
+
         curr_vertex = anEntry.vertex
         next_vertex = curr_vertex.shortcut.successor
-
-        # first pos == origin
-        # second pos == position
         apply_rule(end_entry, next_vertex, anEntry.origin, pos, :nullable_rule)
       end
 
@@ -249,7 +260,6 @@ END_MSG
       def unexpected_token(aPosition)
         unexpected = tokens[aPosition]
         expected = chart.sets[aPosition].expected_terminals
-
         reason = UnexpectedToken.new(aPosition, unexpected, expected)
         faulty(reason)
       end

data/lib/rley/parser/parse_walker_factory.rb

@@ -63,6 +63,8 @@ module Rley # This module is used as a namespace
             receiver << event unless event.nil?
 
             if ctx.curr_entry.orphan? # No antecedent?...
+              err_msg = "No antecedent for #{ctx.curr_entry} at rank #{ctx.entry_set_index}"
+              raise StandardError, err_msg unless ctx.curr_entry.start_entry?
               break if ctx.backtrack_points.empty?
               receiver << use_backtrack_point(ctx)
               receiver << visit_entry(ctx.curr_entry, ctx)

data/lib/rley/syntax/grammar_builder.rb

@@ -73,13 +73,14 @@ module Rley # This module is used as a namespace
           lhs = get_nonterminal(lhs_name)
           case rhs_repr
             when Array
-              rhs_constituents = rhs_repr.map { |name| get_nonterminal(name) }
+              rhs_members = rhs_repr.map { |name| get_nonterminal(name) }
             when String
-              rhs_constituents = [get_nonterminal(rhs_repr)]
+              # rhs_members = [get_nonterminal(rhs_repr)]
+              rhs_members = rhs_repr.scan(/\S+/).map { |name| get_nonterminal(name) }
             when Terminal
-              rhs_constituents = [rhs_repr]
+              rhs_members = [rhs_repr]
           end
-          new_prod = Production.new(lhs, rhs_constituents)
+          new_prod = Production.new(lhs, rhs_members)
           productions << new_prod
         end
         

data/lib/rley/syntax/production.rb

@@ -35,7 +35,7 @@ module Rley # This module is used as a namespace
       # @param theSymbols [list<Terminal | NonTerminal>] symbols of rhs.      
       def initialize(aNonTerminal, theSymbols)
         @lhs = valid_lhs(aNonTerminal)
-        @rhs = SymbolSeq.new(theSymbols)       
+        @rhs = valid_rhs(theSymbols)       
       end
 
       # Is the rhs empty?
@@ -83,6 +83,16 @@ module Rley # This module is used as a namespace
 
         return aNonTerminal
       end
+      
+      def valid_rhs(theSymbols)
+        if theSymbols.nil?
+          msg_prefix = 'Right side of a production of the kind '
+          msg_suffix = "'#{lhs.name}' => ... is nil."
+          raise StandardError, msg_prefix + msg_suffix    
+        end 
+      
+        return SymbolSeq.new(theSymbols)
+      end
     end # class
   end # module
 end # module

data/spec/rley/support/grammar_abc_helper.rb

@@ -8,7 +8,7 @@ module GrammarABCHelper
     builder = Rley::Syntax::GrammarBuilder.new do
       add_terminals('a', 'b', 'c')
       rule 'S' => 'A'
-      rule 'A' => %w[a A c]
+      rule 'A' => 'a A c'
       rule 'A' => 'b'
     end
 

data/spec/rley/syntax/grammar_builder_spec.rb

@@ -97,10 +97,18 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           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)
+          
+          # Try another syntax
+          subject.add_production('A' => 'a A c')
+          expect(subject.productions.size).to eq(3)
+          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)          
 
           # GrammarBuilder#rule is an alias of add_production
           subject.rule('A' => ['b'])
-          expect(subject.productions.size).to eq(3)
+          expect(subject.productions.size).to eq(4)
           new_prod = subject.productions.last
           expect(new_prod.lhs).to eq(subject['A'])
           expect(new_prod.rhs[0]).to eq(subject['b'])

data/spec/rley/syntax/production_spec.rb

@@ -22,6 +22,14 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         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 complain when its rhs is nil' do
+          err = StandardError
+          msg_prefix = 'Right side of a production of the kind '
+          msg_suffix = "'Sentence' => ... is nil." 
+          msg = msg_prefix + msg_suffix
+          expect { Production.new(sentence, nil) }.to raise_error(err, msg)
+        end
 
         it 'should know its lhs' do
           expect(subject.lhs).to eq(sentence)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rley
 version: !ruby/object:Gem::Version
-  version: 0.6.03
+  version: 0.6.04
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-10 00:00:00.000000000 Z
+date: 2018-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: coveralls