rley 0.5.03 → 0.5.04

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bf5a9c73feeebf98f1714d89796bc073b406734e
-  data.tar.gz: 33aad5b8b337bb617bda98c55adfd94d9ebfba03
+  metadata.gz: b5c84e4d5e47e769c76da705abef632e4748311c
+  data.tar.gz: 876569a22741aa76f5d9b7bec8404c0a518e02b3
 SHA512:
-  metadata.gz: b1bb0f88617f3ce5c6b7f964c7849e70a016d7889a9568a3d2ba310d4f42f094cc76167f9ca64cb7cae7f71ca00af672f791afb4ba3460199e383dfbeece78c2
-  data.tar.gz: db471ad23ae2a0bdf4f1408ed8371635cfe808808b5daa4454fa3b1189cc107a4ac99514e50f805cdfb58e1ff3ff61cfba8840a5dbeadad9f5766118e7424075
+  metadata.gz: da13f9f5924752adc98be8822f079e078ff4e5345a1cbf63dcd3f6d0c28c695397abf4f80db6fa38e549615cb1db264baadcb4b3fdc1428ef45ac3aa490459cf
+  data.tar.gz: 84b73e987ffb98f5ce5cf1a57f62a743507bff497c8c8c3294e887310036ba9893796ec5f3b9d1d8f2335b7c33bb47cda3e6455e7f66ce0dfcb3c85b90e629a4

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+### 0.5.04 / 2017-10-26
+* [Fix] Method GrmFlowGraph#traverse_df code terminated prematurely with nested call edges.
+* [CHANGE] Method Grammar#name_production: suffix in default production name is changed (e.g. 'expression[3]' changed to expression_3)
+
 ### 0.5.03 / 2017-10-09
 * [CHANGE] Refactoring code style to please Rubocop 0.50.0
 * [CHANGE] File `.rubocop.yml`: Disabling heredoc cop because it produces false negatives

data/examples/data_formats/JSON/json_ast_builder.rb

@@ -52,37 +52,37 @@ class JSONASTBuilder < Rley::Parser::ParseTreeBuilder
   # @param theChildren [Array] Children nodes (one per rhs symbol)
   def new_parent_node(aProduction, aRange, theTokens, theChildren)
     node = case aProduction.name
-      when 'JSON-text[0]' # rule 'JSON-text' => 'value'
+      when 'JSON-text_0' # rule 'JSON-text' => 'value'
         return_first_child(aRange, theTokens, theChildren)
 
-      when /value\[\d\]/
+      when /value_\d/
         return_first_child(aRange, theTokens, theChildren)
 
-      when 'object[0]'
+      when 'object_0'
         reduce_object_0(aProduction, aRange, theTokens, theChildren)
 
-      when 'object[1]'
+      when 'object_1'
         reduce_object_1(aRange, theTokens, theChildren)
 
-      when 'member-list[0]'
+      when 'member-list_0'
         reduce_member_list_0(aRange, theTokens, theChildren)
 
-      when 'member-list[1]'
+      when 'member-list_1'
         reduce_member_list_1(aProduction, aRange, theTokens, theChildren)
 
-      when 'member[0]'
+      when 'member_0'
         reduce_member_0(aProduction, aRange, theTokens, theChildren)
 
-      when 'array[0]'
+      when 'array_0'
         reduce_array_0(aProduction, aRange, theTokens, theChildren)
 
-      when 'array[1]'
+      when 'array_1'
         reduce_array_1(aRange, theTokens, theChildren)
 
-      when 'array-items[0]'
+      when 'array-items_0'
         reduce_array_items_0(aRange, theTokens, theChildren)
 
-      when 'array-items[1]'
+      when 'array-items_1'
         reduce_array_items_1(aProduction, aRange, theTokens, theChildren)
       else
         raise StandardError, "Don't know production #{aProduction.name}"

data/examples/general/calc_iter1/calc_ast_builder.rb

@@ -58,38 +58,38 @@ class CalcASTBuilder < Rley::Parser::ParseTreeBuilder
   # @param theChildren [Array] Children nodes (one per rhs symbol)
   def new_parent_node(aProduction, aRange, theTokens, theChildren)
     node = case aProduction.name
-      when 'expression[0]' # rule 'expression' => 'simple_expression'
+      when 'expression_0' # rule 'expression' => 'simple_expression'
         return_first_child(aRange, theTokens, theChildren)
 
-      when 'simple_expression[0]' # rule 'simple_expression' => 'term'
+      when 'simple_expression_0' # rule 'simple_expression' => 'term'
         return_first_child(aRange, theTokens, theChildren)
 
-      when 'simple_expression[1]'
+      when 'simple_expression_1'
         # rule 'simple_expression' => %w[simple_expression add_operator term]
         reduce_simple_expression_1(aProduction, aRange, theTokens, theChildren)
 
-      when 'term[0]' # rule 'term' => 'factor'
+      when 'term_0' # rule 'term' => 'factor'
         return_first_child(aRange, theTokens, theChildren)
 
-      when 'term[1]' # rule 'term' => %w[term mul_operator factor]
+      when 'term_1' # rule 'term' => %w[term mul_operator factor]
         reduce_term_1(aProduction, aRange, theTokens, theChildren)
 
-      when 'factor[0]' # rule 'factor' => 'NUMBER'
+      when 'factor_0' # rule 'factor' => 'NUMBER'
         return_first_child(aRange, theTokens, theChildren)
 
-      when 'factor[1]' # rule 'factor' => %w[LPAREN expression RPAREN]
+      when 'factor_1' # rule 'factor' => %w[LPAREN expression RPAREN]
         return_second_child(aRange, theTokens, theChildren)
 
-      when 'add_operator[0]' # rule 'add_operator' => 'PLUS'
+      when 'add_operator_0' # rule 'add_operator' => 'PLUS'
         reduce_add_operator_0(aProduction, aRange, theTokens, theChildren)
 
-      when 'add_operator[1]' # rule 'add_operator' => 'MINUS'
+      when 'add_operator_1' # rule 'add_operator' => 'MINUS'
         reduce_add_operator_1(aProduction, aRange, theTokens, theChildren)
 
-      when 'mul_operator[0]' # rule 'mul_operator' => 'STAR'
+      when 'mul_operator_0' # rule 'mul_operator' => 'STAR'
          reduce_mul_operator_0(aProduction, aRange, theTokens, theChildren)
 
-      when 'mul_operator[1]' # rule 'mul_operator' =>  'DIVIDE'
+      when 'mul_operator_1' # rule 'mul_operator' =>  'DIVIDE'
          reduce_mul_operator_1(aProduction, aRange, theTokens, theChildren)
 
       else

data/lib/rley/constants.rb

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

data/lib/rley/gfg/grm_flow_graph.rb

@@ -46,9 +46,10 @@ module Rley # This module is used as a namespace
         mark_unreachable_symbols
       end
 
-      Branching = Struct.new(:vertex, :to_visit, :visited) do
-        def initialize(aVertex)
+      Branching = Struct.new(:vertex, :in_edge, :to_visit, :visited) do
+        def initialize(aVertex, aCallEdge)
           super(aVertex)
+          self.in_edge = aCallEdge
           self.to_visit = aVertex.edges.dup
           self.visited = []
         end
@@ -64,6 +65,15 @@ module Rley # This module is used as a namespace
           return next_one
         end
       end
+      
+      def print_vertex(aText, aVertex)
+        print aText + ' '
+        if aVertex.kind_of?(NonTerminalVertex)
+          puts "#{aVertex.class} #{aVertex.non_terminal.name}"
+        else
+          p(aVertex.label)
+        end       
+      end
 
       # Walk over all the vertices of the graph that are reachable from a given
       # start vertex. This is a depth-first graph traversal.
@@ -74,29 +84,38 @@ module Rley # This module is used as a namespace
         visited = Set.new
         stack = []
         visitee = aStartVertex
+        curr_edge = nil
 
         begin
+          # print_vertex( 'Traversing', visitee)
+          
           first_time = !visited.include?(visitee)
           if first_time
             yield(visitee)
             visited << visitee
-          end
-
+          end         
+                      
           case visitee
             when Rley::GFG::StartVertex
               if first_time
-                stack.push(Branching.new(visitee))
+                stack.push(Branching.new(visitee, curr_edge))
                 curr_edge = stack.last.next_edge
               else
-                # Skip start and end vertices
+                # Skip both start and end vertices
                 # Retrieve the corresponding return edge
                 curr_edge = get_matching_return(curr_edge)
               end
 
             when Rley::GFG::EndVertex
-              stack.pop if stack.last.done?
-              break if stack.empty?
-              curr_edge = stack.last.next_edge
+              if stack.last.done?
+                popped = stack.pop
+                break if stack.empty?
+                # puts "Popped!"
+                return_key = popped.in_edge.key.sub(/^CALL/, 'RET')
+                curr_edge = visitee.edges.find { |e| e.key == return_key }
+              else
+                curr_edge = stack.last.next_edge          
+              end
 
             else
               # All other vertex types have only one successor
@@ -105,7 +124,8 @@ module Rley # This module is used as a namespace
           visitee = curr_edge.successor unless curr_edge.nil?
         end until stack.empty?
         # Now process the end vertex matching the initial start vertex
-        yield(end_vertex_for[aStartVertex.non_terminal])
+        last_one = end_vertex_for[aStartVertex.non_terminal]
+        yield(last_one) unless visited.include?(last_one)
       end
 
       private
@@ -288,11 +308,13 @@ module Rley # This module is used as a namespace
           a_vertex.non_terminal.unreachable = true
         end
 
-        # Now traverse graph from start vertex
-        # and make all visited non-terminals as reachable
+        # Now traverse graph from start vertex of graph
+        # and mark all visited non-terminals as reachable
         traverse_df(start_vertex) do |a_vertex|
-          next unless a_vertex.kind_of?(StartVertex)
-          a_vertex.non_terminal.unreachable = false
+          # print_vertex('  Visiting', a_vertex)
+          if a_vertex.kind_of?(StartVertex)
+            a_vertex.non_terminal.unreachable = false
+          end
         end
       end
     end # class

data/lib/rley/syntax/grammar.rb

@@ -78,10 +78,10 @@ module Rley # This module is used as a namespace
         prefix = aProduction.lhs.name.dup
         previous = index.zero? ? nil : rules[index - 1]
         if previous.nil? || previous.lhs != aProduction.lhs
-          suffix = '[0]'
+          suffix = '_0'
         else
-          prev_serial = previous.name.match(/\[(\d+)\]$/)
-          suffix = "[#{prev_serial[1].to_i + 1}]"
+          prev_serial = previous.name.match(/_(\d+)$/)
+          suffix = "_#{prev_serial[1].to_i + 1}"
         end
 
         aProduction.name = prefix + suffix

data/spec/rley/gfg/grm_flow_graph_spec.rb

@@ -191,6 +191,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
             'A.',
             'A => . b',
             'A => b .',
+            'S => A .',
             'S.'
           ]
           expect(result).to eq(expected)

data/spec/rley/parser/ast_builder_spec.rb

@@ -74,22 +74,22 @@ module Rley # This module is used as a namespace
       # @param theChildren [Array] Children nodes (one per rhs symbol)
       def new_parent_node(aProduction, aRange, theTokens, theChildren)
         node = case aProduction.name
-                 when 'P[0]'
+                 when 'P_0'
                    reduce_P_0(aRange, theTokens, theChildren)
 
-                 when 'arr[0]'
+                 when 'arr_0'
                    reduce_arr_0(aRange, theTokens, theChildren)
 
-                 when 'sequence[0]'
+                 when 'sequence_0'
                    reduce_sequence_0(aRange, theTokens, theChildren)
 
-                 when 'sequence[1]'
+                 when 'sequence_1'
                    reduce_sequence_1(aRange, theTokens, theChildren)
 
-                 when 'list[0]'
+                 when 'list_0'
                    reduce_list_0(aRange, theTokens, theChildren)
 
-                 when 'list[1]'
+                 when 'list_1'
                    reduce_list_1(aRange, theTokens, theChildren)
                  else
                   err_msg = "Don't know production #{aProduction.name}"

data/spec/rley/syntax/grammar_spec.rb

@@ -162,7 +162,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         
         it 'should ensure that each production has a name' do
           subject.rules.each do |prod|
-            expect(prod.name).to match(Regexp.new("#{prod.lhs.name}\\[\\d\\]"))
+            expect(prod.name).to match(Regexp.new("#{prod.lhs.name}_\\d$"))
           end
         end
       end # context

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rley
 version: !ruby/object:Gem::Version
-  version: 0.5.03
+  version: 0.5.04
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-09 00:00:00.000000000 Z
+date: 2017-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: coveralls