rley 0.4.07 → 0.4.08

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3ddc536143d5391aac2c513060d9f0afa43656f7
-  data.tar.gz: 69e5069295d886ea1287b17cdb7453506d589552
+  metadata.gz: 0ce91c79f9088da09449654c9b6e1b6e0581cf1c
+  data.tar.gz: 3b1e3cc1ce21d3b031b7b09cdbb7606e2eb5a747
 SHA512:
-  metadata.gz: 18f44cd59717551570814e180c735e62badf109c291cb1b41cbaf709bfc2af6cc78864ceb34060b9eb3ca017ab7cfd2e642f1848770b87cced6b1752d27896c0
-  data.tar.gz: 668c3f7737921db9ad35301034be75b91faa584d1ede14fabb253a0dffa6d5a43dc09c94289df714236f0e184a59eb3f10775a2bbd16a6f5a39e8c746969871e
+  metadata.gz: 7bd55bc558c857bab67f080169c1f9d72705fb66fda177c63032fdb0e8e6674efd1119f9fafba3681593dbc9b027beb05081bfe3f38fb99f46068f94b2563282
+  data.tar.gz: 54186ced4b193fa133b48ecdb2cddad7df0960cd2499b2ae48bc586a657cc7a2e49466b42570d78e8be4d0d123b6c821f5c9ab75b98d2e3c3d04d4876fd61f0e

data/.travis.yml

@@ -6,13 +6,11 @@ rvm:
   - 2.3.4
   - 2.4.1
   - ruby-head
-  - rbx-2.7
   - jruby-9.1.9.0    
   - jruby-head 
 matrix:
   allow_failures:
     - rvm: ruby-head
-    - rvm: rbx-2.7
     - rvm: jruby-head
 
 gemfile:

data/CHANGELOG.md

@@ -1,16 +1,24 @@
+### 0.4.08 / 2017-08-06
+* [FIX] File `/spec/spec_helper.rb` replaced deprecated syntax for `SimpleCov::Formatter::MultiFormatter` construction
+* [NEW] File `examples/data_formats/JSON/json_minifier.rb` Added a working JSON minifier to the demo app.
+* [NEW] Class `Syntax::Production` Each production can have a name.
+* [CHANGE] File `.travis.yml`: removal of Rubinius (rbx) in the list of Ruby versions.
+* [CHANGE] DRYing the classes `ParseTreeFactory` and `ParseForestFactory` by inheriting from  `ParseRepCreator`
+* [CHANGE] Minor documentation updates.
+
 ### 0.4.07 / 2017-05-25
-* [FIX] To avoid Fixnum deprecation error in Ruby 2.4 abd higher, all explicit references to Fixnum has been removed.
+* [FIX] To avoid Fixnum deprecation error in Ruby 2.4 and higher, all explicit references to Fixnum has been removed.
 * [FIX] File `.rubocop.yml`: folder `examples` was excluded from Rubocop control. Now it is in code analysis scope.
-* [NEW] File `spec\.rubocop.yml` to tune the code analysis for Rspec files
+* [NEW] File `spec/.rubocop.yml` to tune the code analysis for Rspec files
 * [NEW] File `examples\.rubocop.yml` to tune the code analysis for example files
 * [CHANGE] Code re-styling to please Rubocop 0.49.0: less than 10 offences remain (from above 200 count!)
 * [CHANGE] Added support for Ruby 2.4.x. Files `.travis.yml` and `README.md` updated.
 
 
 ### 0.4.06 / 2017-05-25
-* [FIX] File `formatter\asciitree.rb` fixed inconsistency in comments that caused Yard warnings.
-* [FIX] File `formatter\bracket_notation.rb` fixed inconsistency in comments that caused Yard warnings.
-* [FIX] File `parser\parse_entry_set.rb` fixed inconsistency in comments that caused Yard warnings.
+* [FIX] File `formatter/asciitree.rb` fixed inconsistency in comments that caused Yard warnings.
+* [FIX] File `formatter/bracket_notation.rb` fixed inconsistency in comments that caused Yard warnings.
+* [FIX] File `parser/parse_entry_set.rb` fixed inconsistency in comments that caused Yard warnings.
 * [NEW] Method `Grammar#diagnose` performs a number of checks on the grammar. It detects whether:  
   there are undefined non-terminals (i.e. non-terminals without a rule that define them)
   there are non-productive non-terminals (i.e. non-terminals that don't derive a sting of terminals)
@@ -20,14 +28,11 @@
 * [NEW] Method `GrmSymbol#generative?` inidcates whether the grammar symbol can produce a sequence of terminals.
 * [CHANGE] Class `GrammarBuilder` Improved the API documentation.
 
-
 ### 0.4.05 / 2017-05-06
 * [CHANGE] File `README.md` Added documentation on how to build parse trees and manipulate them.
-* [CHANGE] File `examples\NLP\mini_en_demo.rb` now emits different parse tree representations.
+* [CHANGE] File `examples/NLP/mini_en_demo.rb` now emits different parse tree representations.
 * [NEW] Directory `www`. Contains a diagram output produced from Rley and fed to online RSyntaxTree tool.
 
-
-
 ### 0.4.04 / 2017-05-01
 * [NEW] `Asciitree` formatter class. Allows parse tree output in simple printable text.
 * [CHANGE] Major enhancements in directory `examples\data_formats\JSON`. The demo command-line tool parses JSON and outputs the parse tree in one of the supported formats.

data/README.md

@@ -110,7 +110,7 @@ The subset of English grammar is based on an example from the NLTK book.
     grammar = builder.grammar
 ```  
 
-## Creating a lexicon
+### Creating a lexicon
 
 ```ruby
     # To simplify things, lexicon is implemented as a Hash with pairs of the form:
@@ -139,7 +139,7 @@ The subset of English grammar is based on an example from the NLTK book.
 ```  
 
 
-## Creating a tokenizer
+### Creating a tokenizer
 ```ruby
     # A tokenizer reads the input string and converts it into a sequence of tokens
     # Highly simplified tokenizer implementation.
@@ -162,14 +162,14 @@ creating a lexicon and tokenizer from scratch. Here are a few Ruby Part-of-Speec
 
 
 
-## Building the parser
+### Building the parser
 ```ruby
   # Easy with Rley...
   parser = Rley::Parser::GFGEarleyParser.new(grammar)
 ```
 
 
-## Parsing some input
+### Parsing some input
 ```ruby
     input_to_parse = 'John saw Mary with a telescope'
     # Convert input text into a sequence of token objects...
@@ -191,7 +191,7 @@ representing the parse outcome:
 
 For our whirlwind tour, we will opt for parse trees.
 
-## Generating the parse tree
+### Generating the parse tree
 
 ```ruby
     ptree = result.parse_tree
@@ -210,7 +210,7 @@ Let's do it by:
 - Using one of the built-in visit subscribers specifically created to render the
  parse tree in a given output format.  
 
-### Creating a parse tree visitor  
+#### Creating a parse tree visitor  
 Good news: creating a parse tree visitor for the parse tree `ptree` is just
 an one-liner:
 
@@ -219,7 +219,7 @@ an one-liner:
     visitor = Rley::ParseTreeVisitor.new(ptree)
 ```
 
-### Visiting the parse tree
+#### Visiting the parse tree
 
 Unsurprisingly, to start the parse tree visit, one calls the `#start` method:
 
@@ -293,7 +293,7 @@ the tree node being visited.
 
 Not really impressive? So let's use another formatter...
 
-### Visualizing the parse tree structure
+#### Visualizing the parse tree structure
 If one replaces the previous formatter by an instance of
 `Rley::Formatter::Asciitree` the output now shows the parse tree structure.
 
@@ -345,7 +345,6 @@ By the way, this tool is also a Ruby gem, [rsyntaxtree](https://rubygems.org/gem
 ![Sample parse tree diagram](www/sample_parse_tree.png)
 
 
-
 ## Error reporting
 __Rley__ is a non-violent parser, that is, it won't throw an exception when it
 detects a syntax error. Instead, the parse result will be marked as

data/examples/data_formats/JSON/cli_options.rb

@@ -26,10 +26,10 @@ class CLIOptions < Hash
 and renders its parse tree to the standard output 
 in the format specified in the command-line.
 
-Usage: JSON_demo.rb [options] FILE
+Usage: json_demo.rb [options] FILE
 
 Examples:
-JSON_demo --format ascii_tree sample01.jon
+json_demo --format ascii_tree sample01.json
 END_BANNER
 
       opts.separator ''
@@ -37,11 +37,12 @@ END_BANNER
       format_help = <<-END_TEXT
 Select the output format (default: ascii_tree). Available formats:
   ascii_tree  Simple text representation of parse trees
+  minify      Strip all unnecessary whitespace in the input json file
   labelled    Labelled square notation (LBN)
               Use online tools (e.g. http://yohasebe.com/rsyntaxtree/) 
               to visualize parse trees from LBN output.
 END_TEXT
-      formats = %i[ascii_tree labelled]
+      formats = %i[ascii_tree labelled minify]
       opts.on('-f', '--format FORMAT', formats, format_help) do |frm|
         self[:format] = frm
       end

data/examples/data_formats/JSON/json_demo.rb

@@ -1,8 +1,9 @@
 require_relative 'cli_options'
 require_relative 'json_parser'
+require_relative 'json_minifier'
 
 prog_name = 'json_demo'
-prog_version = '0.1.0'
+prog_version = '0.2.0'
 
 cli_options = CLIOptions.new(prog_name, prog_version, ARGV)
 if ARGV.empty?
@@ -32,6 +33,8 @@ case cli_options[:format]
     renderer = Rley::Formatter::Asciitree.new($stdout)
   when :labelled
     renderer = Rley::Formatter::BracketNotation.new($stdout)
+  when :minify
+    renderer = JSONMinifier.new($stdout)    
 end
 
 # Let's create a parse tree visitor

data/examples/data_formats/JSON/json_lexer.rb

@@ -1,4 +1,4 @@
-# File: JSON_lexer.rb
+# File: json_lexer.rb
 # Lexer for the JSON data format
 require 'rley' # Load the gem
 require 'strscan'

data/examples/data_formats/JSON/json_minifier.rb

@@ -0,0 +1,45 @@
+# File: json_minifier.rb
+
+
+# A JSON minifier, it removes unnecessary whitespaces in a JSON expression.
+# It typically reduces size by half.
+class JSONMinifier
+  # The IO output stream in which the formatter's result will be sent.
+  attr_reader(:output)
+
+  # Constructor.
+  # @param anIO [IO] an output IO where the formatter's result will
+  # be placed.
+  def initialize(anIO)
+    @output = anIO
+  end
+
+  # Given a parse tree visitor, perform the visit
+  # and render the visit events in the output stream.
+  # @param aVisitor [ParseTreeVisitor]
+  def render(aVisitor)
+    aVisitor.subscribe(self)
+    aVisitor.start
+    aVisitor.unsubscribe(self)
+  end
+
+  # Method called by a ParseTreeVisitor to which the formatter subscribed.
+  # Notification of a visit event: the visitor is about to visit
+  # a terminal node. The only thing the JSON minifier has to do is
+  # to render the input tokens almost as they appear initially.
+  # @param aTerm [TerminalNode]
+  def before_terminal(aTerm)
+    # Lexeme is the original text representation of the token
+    lexeme = aTerm.token.lexeme
+    literal = if aTerm.symbol.name == 'string'
+                # String values are delimited by double quotes
+                '"' + lexeme + '"'
+              else
+                lexeme
+              end
+
+    output << literal
+  end
+end # class
+
+# End of file

data/lib/rley/constants.rb

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

data/lib/rley/formatter/asciitree.rb

@@ -41,7 +41,7 @@ module Rley # This module is used as a namespace
       # Notification of a visit event: the visitor is about to visit
       # the children of a non-terminal node
       # @param parent [NonTerminalNode]
-      # @param children [Array<ParseTreeNode>] array of children nodes
+      # @param _children [Array<ParseTreeNode>] array of children nodes
       def before_subnodes(parent, _children)
         rank_of(parent)
         curr_path << parent

data/lib/rley/gfg/grm_flow_graph.rb

@@ -67,10 +67,9 @@ module Rley # This module is used as a namespace
 
       # Walk over all the vertices of the graph that are reachable from a given
       # start vertex. This is a depth-first graph traversal.
-      # @param aStartVertex [StartVertex] the depth-first traversal begins 
+      # @param aStartVertex [StartVertex] the depth-first traversal begins
       #   from here
-      # @param visitAction [Proc] block code called when a new graph vertex 
-      #   is found
+      # @param _visitAction [Proc] block called when a new graph vertex is found
       def traverse_df(aStartVertex, &_visitAction)
         visited = Set.new
         stack = []

data/lib/rley/parser/gfg_parsing.rb

@@ -146,7 +146,7 @@ module Rley # This module is used as a namespace
       def parse_forest()
         factory = ParseForestFactory.new(self)
 
-        return factory.build_parse_forest
+        return factory.create
       end
       
       # Factory method. Builds a ParseTree from the parse result.
@@ -154,7 +154,7 @@ module Rley # This module is used as a namespace
       def parse_tree()
         factory = ParseTreeFactory.new(self)
 
-        return factory.build_parse_tree
+        return factory.create
       end      
 
       # Retrieve the very first parse entry added to the chart.

data/lib/rley/parser/parse_forest_builder.rb

@@ -17,8 +17,8 @@ module Rley # This module is used as a namespace
       # The sequence of input tokens
       attr_reader(:tokens)
 
-      # Link to forest object
-      attr_reader(:forest)
+      # Link to forest object (being) built
+      attr_reader(:result)
 
       # Link to current path
       attr_reader(:curr_path)
@@ -77,7 +77,7 @@ module Rley # This module is used as a namespace
             range = { low: anEntry.origin, high: anIndex }
             non_terminal = anEntry.vertex.non_terminal
             create_non_terminal_node(anEntry, range, non_terminal)
-            @forest = create_forest(curr_parent) unless @last_visitee
+            @result = create_forest(curr_parent) unless @last_visitee
 
           when :backtrack
             # Restore path
@@ -187,7 +187,7 @@ module Rley # This module is used as a namespace
         range = curr_parent.range
         alternative = Rley::SPPF::AlternativeNode.new(vertex, range)
         add_subnode(alternative)
-        forest.is_ambiguous = true
+        result.is_ambiguous = true
         # puts "FOREST ADD #{alternative.key}"
 
         return alternative
@@ -218,11 +218,11 @@ module Rley # This module is used as a namespace
       # Add the given node if not yet present in parse forest
       def add_node_to_forest(aNode)
         key_node = aNode.key
-        if forest.include?(key_node)
-          new_node = forest.key2node[key_node]
+        if result.include?(key_node)
+          new_node = result.key2node[key_node]
         else
           new_node = aNode
-          forest.key2node[key_node] = new_node
+          result.key2node[key_node] = new_node
           # puts "FOREST ADD #{key_node}"
         end
         add_subnode(new_node, false)

data/lib/rley/parser/parse_forest_factory.rb

@@ -1,49 +1,13 @@
-require_relative 'parse_walker_factory'
+require_relative 'parse_rep_creator'
 require_relative 'parse_forest_builder'
 
 module Rley # This module is used as a namespace
   module Parser # This module is used as a namespace
     # Utility class that helps to create a ParseForest from
     # a given Parsing object.
-    class ParseForestFactory
-      # Link to Parsing object (= results of recognizer)
-      attr_reader(:parsing)
+    class ParseForestFactory < ParseRepCreator
 
-
-      def initialize(aParsingResult)
-        @parsing = aParsingResult
-      end
-
-      # Factory that produces the parse forest
-      def build_parse_forest()
-        a_walker = walker(parsing)
-        a_builder = builder(parsing)
-
-        begin
-          loop do
-            event = a_walker.next
-            # puts "EVENT #{event[0]} #{event[1]}"
-            a_builder.receive_event(*event)
-          end
-        rescue StopIteration
-          # Do nothing
-        end
-
-        return a_builder.forest
-      end
-
-
-      private
-
-      # Create a Parsing walker, that is, an object
-      # that will iterate over the relevant nodes (= parsing entries)
-      # of a GFGParsing
-      def walker(aParseResult)
-        walker_factory = ParseWalkerFactory.new
-        accept_entry = aParseResult.accepting_entry
-        accept_index = aParseResult.chart.last_index
-        walker_factory.build_walker(accept_entry, accept_index)
-      end
+      protected
 
       # Create a Builder, that is, an object
       # that will create piece by piece the forest

data/lib/rley/parser/parse_rep_creator.rb

@@ -0,0 +1,53 @@
+require_relative 'parse_walker_factory'
+
+module Rley # This module is used as a namespace
+  module Parser # This module is used as a namespace
+    # Utility class that helps to create a representation of a parse from
+    # a given Parsing object.
+    class ParseRepCreator
+      # @return [GFGParsing] Link to Parsing object (= results of recognizer)
+      attr_reader(:parsing)
+      
+      # Constructor. Creates and initialize a ParseRepCreator instance.
+      # @return [ParseRepCreator]
+      def initialize(aParsingResult)
+        @parsing = aParsingResult
+      end      
+      
+      # Factory method that produces the representation of the parse.
+      # @return [ParseTree] The parse representation.
+      def create()
+        a_walker = walker(parsing)
+        a_builder = builder(parsing)
+
+        begin
+          loop do
+            event = a_walker.next
+            # puts "EVENT #{event[0]} #{event[1]}"
+            a_builder.receive_event(*event)
+          end
+        rescue StopIteration
+          # Do nothing
+        end
+
+        return a_builder.result
+      end
+      
+      private
+      
+      # Create a Parsing walker, that is, an object
+      # that will iterate over the relevant nodes (= parsing entries)
+      # of a GFGParsing
+      def walker(aParseResult)
+        walker_factory = ParseWalkerFactory.new
+        accept_entry = aParseResult.accepting_entry
+        accept_index = aParseResult.chart.last_index
+        walker_factory.build_walker(accept_entry, accept_index)
+      end      
+      
+    end # class
+  end # module
+end # module
+
+# End of file 
+   

data/lib/rley/parser/parse_tree_builder.rb

@@ -9,15 +9,16 @@ require_relative '../ptree/parse_tree'
 
 module Rley # This module is used as a namespace
   module Parser # This module is used as a namespace
-    # Builder GoF pattern. Builder pattern builds a complex object
+    # Builder GoF pattern.  
+    # The Builder pattern creates a complex object
     # (say, a parse tree) from simpler objects (terminal and non-terminal
     # nodes) and using a step by step approach.
     class ParseTreeBuilder
-      # The sequence of input tokens
+      # @return [Array<Token>] The sequence of input tokens
       attr_reader(:tokens)
 
-      # Link to tree object
-      attr_reader(:tree)
+      # Link to tree object (being) built
+      attr_reader(:result)
 
       # Link to current path
       attr_reader(:curr_path)
@@ -28,7 +29,8 @@ module Rley # This module is used as a namespace
       # A hash with pairs of the form: visited parse entry => tree node
       attr_reader(:entry2node)
 
-
+      # Create a new builder instance.
+      # @param theTokens [Array<Token>] The sequence of input tokens.
       def initialize(theTokens)
         @tokens = theTokens
         @curr_path = []
@@ -71,7 +73,7 @@ module Rley # This module is used as a namespace
             range = { low: anEntry.origin, high: anIndex }
             non_terminal = anEntry.vertex.non_terminal
             create_non_terminal_node(anEntry, range, non_terminal)
-            @tree = create_tree(curr_parent) unless @last_visitee
+            @result = create_tree(curr_parent) unless @last_visitee
           else
             raise NotImplementedError
         end
@@ -143,7 +145,7 @@ module Rley # This module is used as a namespace
         range = curr_parent.range
         alternative = Rley::PTree::AlternativeNode.new(vertex, range)
         add_subnode(alternative)
-        tree.is_ambiguous = true
+        result.is_ambiguous = true
         # puts "FOREST ADD #{alternative.key}"
 
         return alternative

data/lib/rley/parser/parse_tree_factory.rb

@@ -1,49 +1,13 @@
-require_relative 'parse_walker_factory'
+require_relative 'parse_rep_creator'
 require_relative 'parse_tree_builder'
 
 module Rley # This module is used as a namespace
   module Parser # This module is used as a namespace
     # Utility class that helps to create a ParseTree from
     # a given Parsing object.
-    class ParseTreeFactory
-      # Link to Parsing object (= results of recognizer)
-      attr_reader(:parsing)
+    class ParseTreeFactory < ParseRepCreator
 
-
-      def initialize(aParsingResult)
-        @parsing = aParsingResult
-      end
-
-      # Factory that produces the parse tree
-      def build_parse_tree()
-        a_walker = walker(parsing)
-        a_builder = builder(parsing)
-
-        begin
-          loop do
-            event = a_walker.next
-            # puts "EVENT #{event[0]} #{event[1]}"
-            a_builder.receive_event(*event)
-          end
-        rescue StopIteration
-          # Do nothing
-        end
-
-        return a_builder.tree
-      end
-
-
-      private
-
-      # Create a Parsing walker, that is, an object
-      # that will iterate over the relevant nodes (= parsing entries)
-      # of a GFGParsing
-      def walker(aParseResult)
-        walker_factory = ParseWalkerFactory.new
-        accept_entry = aParseResult.accepting_entry
-        accept_index = aParseResult.chart.last_index
-        walker_factory.build_walker(accept_entry, accept_index)
-      end
+      protected
 
       # Create a Builder, that is, an object
       # that will create piece by piece the forest

data/lib/rley/parser/parse_walker_factory.rb

@@ -8,16 +8,20 @@ require_relative '../gfg/start_vertex'
 
 module Rley # This module is used as a namespace
   module Parser # This module is used as a namespace
+    # Utility class used internally by the Enumerator created
+    # with a ParseWalkerContext object. It holds the state of
+    # the walk over a GFGParsing object.
     ParseWalkerContext = Struct.new(
-      :curr_entry, # Parse entry currently being visited
-      :entry_set_index, # Sigma set index of current parse entry
-      :visitees, # The set of already visited parse entries
+      :curr_entry, # @return [ParseEntry] entry being visited
+      :entry_set_index, # @return [Integer] Set index of current parse entry
+      :visitees, # @return [Set<ParseEntry>] The set of already visited entries
       :nterm2start, # Nested hashes. Pairs of first level are of the form:
       # non-terminal symbol => { index(=origin) => start entry }
-      :return_stack, # A stack of parse entries
+      :return_stack, # @return [Array<ParseEntry>] A stack of parse entries
       :backtrack_points
     )
 
+
     WalkerBacktrackpoint = Struct.new(
       :entry_set_index, # Sigma set index of current parse entry
       :return_stack, # A stack of parse entries
@@ -25,12 +29,11 @@ module Rley # This module is used as a namespace
       :antecedent_index
     )
 
-    # A factory that creates an enumerator
-    #  that itself walks through a given parsing graph.
-    # The walker yields visit events.
-    # Terminology warning: this class implements an external iterator
-    # for a given GFGParsing object. In other words, its instances are objects
-    # distinct for the GFGParsing.
+    # A factory that creates an Enumerator object
+    # that itself walks through a GFGParsing object.
+    # The walker (= Enumerator) yields visit events.  
+    # This class implements an external iterator
+    # for a given GFGParsing object.
     # This is different from the internal iterators, usually implemented 
     # in Ruby with an :each method.
     # Allows to perform a backwards traversal over the relevant parse entries.
@@ -40,7 +43,12 @@ module Rley # This module is used as a namespace
     # (i.e. they belong to a path that leads to the accepting parse entry)
     class ParseWalkerFactory
       # Build an Enumerator that will yield the parse entries as it
-      # walks backwards on the parse graph
+      # walks backwards on the parse graph.
+      # @param acceptingEntry [ParseEntry] the final ParseEntry of a 
+      #    successful parse.
+      # @param maxIndex [Integer] the index of the last input token.
+      # @return [Enumerator] yields visit events when walking over the 
+      #   parse result
       def build_walker(acceptingEntry, maxIndex)
         # Local context for the enumerator
         ctx = init_context(acceptingEntry, maxIndex)

data/lib/rley/ptree/parse_tree.rb

@@ -12,7 +12,7 @@ module Rley # This module is used as a namespace
     # during the parse. 
     # The root node corresponds to the main/start symbol of the grammar.
     class ParseTree
-      # The root node of the tree
+      # @return [ParseTreeNode] The root node of the tree.
       attr_reader(:root)
 
       # @param theRootNode [ParseTreeNode] The root node of the parse tree.

data/lib/rley/ptree/terminal_node.rb

@@ -8,7 +8,7 @@ module Rley # This module is used as a namespace
 
       # aPosition is the position of the token in the input stream.      
       def initialize(aToken, aPos)
-        (major, minor) =  
+        # (major, minor) =  
         
         # Use '1.class' trick to support both Integer and Fixnum classes
         range = aPos.kind_of?(1.class) ? { low: aPos, high: aPos + 1 } : aPos

data/lib/rley/syntax/grammar.rb

@@ -31,7 +31,10 @@ module Rley # This module is used as a namespace
         @symbols = []
         @name2symbol = {}
         valid_productions = validate_productions(theProductions)
-        valid_productions.each { |prod| add_production(prod) }
+        valid_productions.each do |prod| 
+          add_production(prod)
+          name_production(prod)
+        end
         diagnose
 
         # TODO: use topological sorting
@@ -65,6 +68,22 @@ module Rley # This module is used as a namespace
 
         aProduction.rhs.each { |symb| add_symbol(symb) }
       end
+      
+      def name_production(aProduction)
+        if aProduction.name.nil?
+          index = rules.find_index(aProduction)
+          prefix = aProduction.lhs.name.dup
+          previous = index.zero? ? nil : rules[index - 1]
+          if previous.nil? || previous.lhs != aProduction.lhs
+            suffix = '[0]'
+          else
+            prev_serial = previous.name.match(/\[(\d+)\]$/)
+            suffix = "[#{prev_serial[1].to_i + 1}]"   
+          end
+          
+          aProduction.name = prefix + suffix
+        end
+      end
 
       # Perform some check of the grammar.
       def diagnose()

data/lib/rley/syntax/grammar_builder.rb

@@ -67,7 +67,7 @@ module Rley # This module is used as a namespace
       #   builder.rule 'A' => %w[a A  c]  # Call parentheses are optional
       # @param aProductionRepr [Hash{String, Array<String>}] 
       #   A Hash-based representation of a production.
-      # @return [void]      
+      # @return [Production] The created Production instance
       def add_production(aProductionRepr)
         aProductionRepr.each_pair do |(lhs_name, rhs_repr)|
           lhs = get_nonterminal(lhs_name)
@@ -82,6 +82,8 @@ module Rley # This module is used as a namespace
           new_prod = Production.new(lhs, rhs_constituents)
           productions << new_prod
         end
+        
+        return productions.last
       end
 
       # Given the grammar symbols and productions added to the builder,

data/lib/rley/syntax/production.rb

@@ -16,6 +16,9 @@ module Rley # This module is used as a namespace
       # @return [NonTerminal] The left-hand side of the rule.
       attr_reader(:lhs)
       
+      # @return [String] The unique name of the production rule.
+      attr_accessor(:name)
+      
       # @return [Boolean ]A production is generative when all of its 
       # rhs members are generative (that is, they can each generate/derive
       # a non-empty string of terminals).
@@ -26,9 +29,12 @@ module Rley # This module is used as a namespace
       alias body rhs
       alias head lhs
 
+      # Create a Production instance.
+      # @param aNonTerminal [NonTerminal] The left-hand side of the rule.
+      # @param theSymbols [list<Terminal | NonTerminal>] symbols of rhs.      
       def initialize(aNonTerminal, theSymbols)
         @lhs = valid_lhs(aNonTerminal)
-        @rhs = SymbolSeq.new(theSymbols)
+        @rhs = SymbolSeq.new(theSymbols)       
       end
 
       # Is the rhs empty?

data/spec/rley/parser/groucho_spec.rb

@@ -99,7 +99,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       end
       
       def root_children
-          subject.forest.root.subnodes    
+          subject.result.root.subnodes    
       end      
 
 

data/spec/rley/parser/parse_forest_builder_spec.rb

@@ -97,7 +97,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
         it 'should initialize the root node' do
           next_event(:visit, 'Phi. | 0')
-          forest = subject.forest
+          forest = subject.result
 
           expect(forest.root.to_string(0)).to eq('Phi[0, 4]')
           expected_curr_path('Phi[0, 4]')

data/spec/rley/parser/parse_forest_factory_spec.rb

@@ -68,7 +68,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       context 'Parse forest construction' do
         it 'should build a parse forest' do
-          forest = subject.build_parse_forest
+          forest = subject.create
           expect(forest).to be_kind_of(SPPF::ParseForest)
 =begin
           require 'yaml'

data/spec/rley/parser/parse_tree_builder_spec.rb

@@ -81,7 +81,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
         it 'should initialize the root node' do
           next_event(:visit, 'P. | 0')
-          tree = subject.tree
+          tree = subject.result
 
           expect(tree.root.to_string(0)).to eq('P[0, 5]')
           expected_curr_path('P[0, 5]')
@@ -227,12 +227,13 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           end
 
           # Lightweight sanity check
-          expect(subject.tree).not_to be_nil
-          expect(subject.tree).to be_kind_of(PTree::ParseTree)
-          expect(subject.tree.root.to_s).to eq('P[0, 5]')
-          expect(subject.tree.root.subnodes.size).to eq(1)
-          child_node = subject.tree.root.subnodes[0]
+          expect(subject.result).not_to be_nil
+          expect(subject.result).to be_kind_of(PTree::ParseTree)
+          expect(subject.result.root.to_s).to eq('P[0, 5]')
+          expect(subject.result.root.subnodes.size).to eq(1)
+          child_node = subject.result.root.subnodes[0]
           expect(child_node.to_s).to eq('S[0, 5]')
+          
           expect(child_node.subnodes.size).to eq(3)
           first_grandchild = child_node.subnodes[0]
           expect(first_grandchild.to_s).to eq('S[0, 1]')

data/spec/rley/parser/parse_tree_factory_spec.rb

@@ -1,40 +1,28 @@
 require_relative '../../spec_helper'
 
 require_relative '../../../lib/rley/parser/gfg_earley_parser'
-
 require_relative '../../../lib/rley/syntax/grammar_builder'
 require_relative '../support/grammar_helper'
+require_relative '../support/grammar_abc_helper'
 require_relative '../support/expectation_helper'
 
 # Load the class under test
-require_relative '../../../lib/rley/parser/parse_forest_factory'
+require_relative '../../../lib/rley/parser/parse_tree_factory'
 
 module Rley # Open this namespace to avoid module qualifier prefixes
   module Parser
-    describe ParseForestFactory do
+    describe ParseTreeFactory do
       include GrammarHelper     # Mix-in with token factory method
       include ExpectationHelper # Mix-in with expectation on parse entry sets
+      include GrammarABCHelper  # Mix-in for a sample grammar
 
       let(:sample_grammar) do
-          # Grammar based on paper from Elisabeth Scott
-          # "SPPF-Style Parsing From Earley Recognizers" in
-          # Notes in Theoretical Computer Science 203, (2008), pp. 53-67
-          # contains a hidden left recursion and a cycle
-          builder = Syntax::GrammarBuilder.new do
-            add_terminals('a', 'b')
-            rule 'Phi' => 'S'
-            rule 'S' => %w[A T]
-            rule 'S' => %w[a T]
-            rule 'A' => 'a'
-            rule 'A' => %w[B A]
-            rule 'B' => []
-            rule 'T' => %w[b b b]
-          end
-          builder.grammar
+        builder = grammar_abc_builder
+        builder.grammar
       end
 
       let(:sample_tokens) do
-        build_token_sequence(%w[a b b b], sample_grammar)
+        build_token_sequence(%w[a b c], sample_grammar)
       end
 
       let(:sample_result) do
@@ -44,7 +32,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
 
       subject do
-        ParseForestFactory.new(sample_result)
+        ParseTreeFactory.new(sample_result)
       end
 
       # Emit a text representation of the current path.
@@ -58,7 +46,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       context 'Initialization:' do
         it 'should be created with a GFGParsing' do
-          expect { ParseForestFactory.new(sample_result) }.not_to raise_error
+          expect { ParseTreeFactory.new(sample_result) }.not_to raise_error
         end
 
         it 'should know the parse result' do
@@ -66,17 +54,10 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         end
       end
 
-      context 'Parse forest construction' do
-        it 'should build a parse forest' do
-          forest = subject.build_parse_forest
-          expect(forest).to be_kind_of(SPPF::ParseForest)
-=begin
-          require 'yaml'
-          require_relative '../../../exp/lab/forest_representation'
-          File.open("forest.yml", "w") { |f| YAML.dump(forest, f) }
-          pen = ForestRepresentation.new
-          pen.generate_graph(forest, File.open("forest.dot", "w"))
-=end
+      context 'Parse tree construction' do
+        it 'should build a parse tree' do
+          forest = subject.create
+          expect(forest).to be_kind_of(PTree::ParseTree)
         end
       end # context
     end # describe

data/spec/rley/syntax/grammar_spec.rb

@@ -159,6 +159,12 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(subject.name2symbol['b']).to eq(b_)
           expect(subject.name2symbol['c']).to eq(c_)
         end
+        
+        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\\]"))
+          end
+        end
       end # context
 
       context 'Grammar diagnosis:' do

data/spec/rley/syntax/production_spec.rb

@@ -40,6 +40,10 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(instance).to be_empty
         end
         
+        it 'should be anonymous at creation' do
+          expect(subject.name).to be_nil
+        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'
@@ -48,6 +52,14 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect { Production.new('wrong', sequence) }.to raise_error(err, msg)
         end
       end # context
+      
+      context 'Provided services:' do
+        it 'should accept a name' do
+          a_name = 'nominem'
+          subject.name = a_name
+          expect(subject.name).to eq(a_name)
+        end
+      end # context
     end # describe
   end # module
 end # module

data/spec/rley/syntax/symbol_seq_spec.rb

@@ -58,7 +58,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         
         it 'should complain when unable to compare' do
           err = StandardError
-          msg = "Cannot compare a SymbolSeq with a String"
+          msg = 'Cannot compare a SymbolSeq with a String'
           expect { subject == 'dummy-text' }.to raise_error(err, msg)
         end
       end # context

data/spec/spec_helper.rb

@@ -6,14 +6,14 @@ require 'coveralls'
 
 Coveralls.wear!
 
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new([
   SimpleCov::Formatter::HTMLFormatter,
   Coveralls::SimpleCov::Formatter
-]
+])
 
-
-require 'rspec' # Use the RSpec framework
 require 'pp'    # Use pretty-print for debugging purposes
+require 'rspec' # Use the RSpec framework
+
 
 RSpec.configure do |config|
   config.expect_with :rspec do |c|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rley
 version: !ruby/object:Gem::Version
-  version: 0.4.07
+  version: 0.4.08
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-27 00:00:00.000000000 Z
+date: 2017-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: coveralls
@@ -135,6 +135,7 @@ files:
 - examples/data_formats/JSON/json_demo.rb
 - examples/data_formats/JSON/json_grammar.rb
 - examples/data_formats/JSON/json_lexer.rb
+- examples/data_formats/JSON/json_minifier.rb
 - examples/data_formats/JSON/json_parser.rb
 - examples/general/calc/calc_demo.rb
 - examples/general/calc/calc_grammar.rb
@@ -173,6 +174,7 @@ files:
 - lib/rley/parser/parse_entry_tracker.rb
 - lib/rley/parser/parse_forest_builder.rb
 - lib/rley/parser/parse_forest_factory.rb
+- lib/rley/parser/parse_rep_creator.rb
 - lib/rley/parser/parse_state.rb
 - lib/rley/parser/parse_state_tracker.rb
 - lib/rley/parser/parse_tracer.rb