rley 0.4.02 → 0.4.03

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cd7c7f9e941ac7139080960dca0cb2a16665bcbd
-  data.tar.gz: dd4e2a8dae9fd1958427beab6c63b0e9206834e7
+  metadata.gz: 2d13db61565b20ef542592a59bcd056d4dd2192e
+  data.tar.gz: a8d8c12a600d9621d6be682570cb165d526641ef
 SHA512:
-  metadata.gz: 7611109ca8b7d99a090e88de7eea31cc08c22250d790c2befd3b3aaa9e222450ac900d10ab733d0ee72e831da0bf7a7ad07da6f6e33e20724879659a2e45d620
-  data.tar.gz: f81cc80909844e4cbd50ec85ad803b08483e714f78734b234de13b544f891f77759cdb8df4349dea1c68a8de250d44ef860e0a8bf27dd6313da08f0cc3c49b34
+  metadata.gz: 679e3f7d6747264092f317521e1f8f9e241ad912de71280c0c6d68454110bd3ba75fdc6f1f4a9c76ac61622ed87fba86f2662e3f15b5cd9a0e2d571b340e2988
+  data.tar.gz: edb83ffb5fb673f27abef6c7ef10014fb8c6c312de093251f6ce509e2893c20cf5114cb77abf1b97c1406d9d22d474b0ab577829acb9d59f58117e43e96eaef2

data/CHANGELOG.md

@@ -1,6 +1,8 @@
-### 0.4.02 / 2017-04-09
-* [NEW] Module re-organization for clearer dependencies: Classes `Token` and `TokenRange` are moved to a separate module `Tokens`.
-* [CHANGE] Code, specs, examples and `README.md` adapted to reflect the module re-organization.
+### 0.4.03 / 2017-04-17
+* [FIX] File `rley.rb` reference to obsolete `EarleyParser` class removed.
+* [NEW] `BracketNotation` formatter class. Allows parse tree output in Labelled Bracket Notation.
+* [CHANGE] Code refactoring in directory `examples\data_formats\JSON`. The demo command-line tool parses JSON and converts it into LBN (Labelled Bracket Notation). There are two diagrams (in SVG format) generated from the LBN output.
+
 
 ### 0.4.01 / 2016-12-21
 * [NEW] File `appveyor.yml`. Add AppVeyor CI to Github commits. AppVeyor complements Travis by running builds under Windows OS.
@@ -48,7 +50,7 @@
 ### 0.3.06 / 2016-11-06
 * [FIX] There were missing links to shared parse forest nodes for ambiguous parses.
 * [NEW] RSpec file `ambiguous_parse_spec.rb` added in order to test the parse forest building for an ambiguous parse.
-* [CHANGE] Attribute `ParseWalkerContext#nterm2start`: previous implementation assumed -wrongly- that for each non terminal there was only one start entry. 
+* [CHANGE] Attribute `ParseWalkerContext#nterm2start`: previous implementation assumed -wrongly- that for each non terminal there was only one start entry.
   Now this attribute uses nested hashes as data structure in order to disambiguate the mapping.
 * [CHANGE] Method `ParseWalkerFactory#visit_entry` updated to reflect change in the `ParseWalkerContext#nterm2start` attribute.
 * [CHANGE] Method `ParseWalkerFactory#visit_entry` now emits an event if an item entry is re-visited (previously, no such event were generated)
@@ -73,10 +75,10 @@
 ### 0.3.01 / 2016-10-23
 * [CHANGE] Method `ParseWalkerFactory#build_walker`. Signature change in order prevent direct dependency on `GFGParsing` class.
 * [CHANGE] Class `ParseForestBuilder`. Removal of `parsing` attribute, no direct dependency on `GFGParsing` class.
-* [CHANGE] Internal changed to `ParseForestFactory` class. 
+* [CHANGE] Internal changed to `ParseForestFactory` class.
 
 ### 0.3.00 / 2016-10-23
-* [CHANGE] Many new classes. The gem bundles a second parser that copes with ambiguous grammars. 
+* [CHANGE] Many new classes. The gem bundles a second parser that copes with ambiguous grammars.
 
 
 ### 0.2.15 / 2016-02-14
@@ -90,11 +92,11 @@
 * [CHANGED] method `Parsing#success?`. New implementation that relies on start symbol derivation.
 * [NEW] New method `Chart#start_symbol` added. Returns the start symbol of the grammar.
 * [NEW] New method `StateSet#ambiguities` added. Returns the parse sets that are ambiguous (= distinct derivation for same input tokens).
-* [FIX] In special cases the parsing didn't work correctly when there more than one 
+* [FIX] In special cases the parsing didn't work correctly when there more than one
     production rule for the start symbol of a grammar.
 
 ### 0.2.12 / 2015-11-20
-* [FIX] In special cases the parsing didn't work correctly when there more than one 
+* [FIX] In special cases the parsing didn't work correctly when there more than one
     production rule for the start symbol of a grammar.
 
 ### 0.2.11 / 2015-09-05
@@ -150,7 +152,7 @@ Version number bump: major re-design of the parse tree generation.
 * [FIX] Method `Parsing#parse_tree` now handles situations where there are multiple complete parse states for a non-terminal.
 
 ### 0.1.12 / 2014-12-22
-* [FIX] Fixed `Parsing#parse_tree`: code couldn't cope with parse state set containing more 
+* [FIX] Fixed `Parsing#parse_tree`: code couldn't cope with parse state set containing more
   than one parse state that expected the same symbol.
 * [NEW] Added one more parser example (for very basic arithmetic expression)
 
@@ -239,19 +241,19 @@ in method argument names between source code and documentation.
 
 
 ### 0.0.11 / 2014-11-16
-* [CHANGE]  Usage of `GrammarBuilder`simplified: the call to method `GrammarBuilder#add_non_terminal` isn't necessary. Method is removed 
+* [CHANGE]  Usage of `GrammarBuilder`simplified: the call to method `GrammarBuilder#add_non_terminal` isn't necessary. Method is removed
 * [CHANGE] Updated the `examples` folder accordingly.
 
 ### 0.0.10 / 2014-11-15
-* [NEW]  New folder `examples` added with two examples of grammar creation 
+* [NEW]  New folder `examples` added with two examples of grammar creation
 
 ### 0.0.09 / 2014-11-15
-* [NEW]  New class `GrammarBuilder` added and tested, its purpose is 
+* [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 
+* [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
@@ -280,4 +282,4 @@ failed because Travis couldn't connect to GitHub)
 
 
 ### 0.0.00 / 2014-11-07
-* [FEATURE] Initial public working version
+* [FEATURE] Initial public working version

data/README.md

@@ -1,4 +1,4 @@
-#[Rley](https://github.com/famished-tiger/Rley)
+[Rley](https://github.com/famished-tiger/Rley)
 
 [![Linux Build Status](https://img.shields.io/travis/famished-tiger/Rley/master.svg?label=Linux%20build)](https://travis-ci.org/famished-tiger/Rley)
 [![Build status](https://ci.appveyor.com/api/projects/status/l5adgcbfo128rvo9?svg=true)](https://ci.appveyor.com/project/famished-tiger/rley)
@@ -28,7 +28,7 @@ encode efficiently all the possible parse trees that result from an ambiguous
 grammar.  
 
 As another distinctive mark, __Rley__ is also the first Ruby implementation of a
-parsing library based on the new _Grammar Flow Graph_ approach (_TODO: add details_).
+parsing library based on the new _Grammar Flow Graph_ approach [References on GFG](#references-on-gfg).
 
 ### What it can do?
 Maybe parsing algorithms and internal implementation details are of lesser
@@ -217,7 +217,7 @@ ask it to generate a message.
     puts result.failure_reason.message unless result.success?
 ```
 
-Re-running the example with the error, result in the error message:
+Re-running the example with the error, results in the error message:
 ```
   Syntax error at or near token 2 >>>Mary<<<
   Expected one 'Verb', found a 'Proper-Noun' instead.
@@ -281,6 +281,15 @@ Here are a few other ones:
 ##  Thanks to:
 * Professor Keshav Pingali, one of the creators of the Grammar Flow Graph parsing approach for his encouraging e-mail exchanges.
 
+## References on GFG
+Since the __G__rammar __F__low __G__raph parsing approach is quite new, it has not yet taken a place in
+standard parser textbooks. Here are a few references (and links) of papers on GFG:    
+- K. Pingali, G. Bilardi. [Parsing with Pictures](http://apps.cs.utexas.edu/tech_reports/reports/tr/TR-2102.pdf)
+- K. Pingali, G. Bilardi. [A Graphical Model for Context-Free Grammar Parsing.](https://link.springer.com/chapter/10.1007/978-3-662-46663-6_1)
+  In : International Conference on Compiler Construction. Springer Berlin Heidelberg, 2015. p. 3-27.  
+- M. Fulbright. [An Evaluation of Two Approaches to Parsing](http://apps.cs.utexas.edu/tech_reports/reports/tr/TR-2199.pdf)  
+
+
 Copyright
 ---------
 Copyright (c) 2014-2017, Dimitri Geshef.  

data/examples/data_formats/JSON/JSON_demo.rb

@@ -6,7 +6,12 @@ parser = JSONParser.new
 # Parse the input file with name given in command-line
 if ARGV.empty?
   msg = <<-END_MSG
-Command-line symtax:
+A demo utility that converts a JSON file into labelled square notation (LBN).
+Use online tools (e.g. http://yohasebe.com/rsyntaxtree/) to visualize 
+parse trees from LBN output.
+
+Command-line syntax:
+
   ruby #{__FILE__} filename
   where:
     filename is the name of a JSON file
@@ -27,7 +32,17 @@ unless result.success?
   exit(1)
 end
 
-# Generate a parse forest from the parse result
-pforest = result.parse_forest
-# puts pforest.ambiguous?
+# Generate a parse tree from the parse result
+ptree = result.parse_tree
+require 'yaml'
+File.open('json1.yml', 'w') {|f| YAML.dump(ptree, f)}
+
+# Let's create a parse tree visitor
+visitor = Rley::ParseTreeVisitor.new(ptree)
+
+# Output the labelled bracket notation of the tree
+use_notation = Rley::Formatter::BracketNotation.new($stdout)
+use_notation.render(visitor)
+
+
 # End of file

data/examples/data_formats/JSON/JSON_grammar.rb

@@ -4,27 +4,33 @@ require 'rley'  # Load the gem
 
 ########################################
 # Define a grammar for JSON
+# Original JSON grammar is available http://www.json.org/fatfree.html
+# Official JSON grammar:  http://rfc7159.net/rfc7159#rfc.section.2
+# Names of grammar elements are based on the RFC 7159 documentation
 builder = Rley::Syntax::GrammarBuilder.new do
-  add_terminals('KEYWORD') # For true, false, null keywords
-  add_terminals('JSON_STRING', 'JSON_NUMBER')
-  add_terminals('LACCOL', 'RACCOL') # For '{', '}' delimiters
-  add_terminals('LBRACKET', 'RBRACKET') # For '[', ']' delimiters
-  add_terminals('COLON', 'COMMA') # For ':', ',' separators
-  rule 'json_text' => 'json_value'
-  rule 'json_value' => 'json_object'
-  rule 'json_value' => 'json_array'
-  rule 'json_value' => 'JSON_STRING'
-  rule 'json_value' => 'JSON_NUMBER'
-  rule 'json_value' => 'KEYWORD'
-  rule 'json_object' => %w(LACCOL json_pairs RACCOL)
-  rule 'json_object' => %w(LACCOL RACCOL)
-  rule 'json_pairs' => %w(json_pairs COMMA single_pair)
-  rule 'json_pairs' => 'single_pair'
-  rule 'single_pair' => %w(JSON_STRING COLON json_value)
-  rule 'json_array' => %w(LBRACKET array_items RBRACKET)
-  rule 'json_array' => %w(LBRACKET RBRACKET)
-  rule 'array_items' => %w(array_items COMMA json_value)
-  rule 'array_items' => %w(json_value)
+  add_terminals('false', 'null', 'true') # Literal names
+  add_terminals('string', 'number')
+  add_terminals('begin-object', 'end-object') # For '{', '}' delimiters
+  add_terminals('begin-array', 'end-array') # For '[', ']' delimiters
+  add_terminals('name-separator', 'value-separator') # For ':', ',' separators
+  rule 'JSON-text' => 'value'
+  rule 'value' => 'false'
+  rule 'value' => 'null'
+  rule 'value' => 'true'   
+  rule 'value' => 'object'
+  rule 'value' => 'array'
+  rule 'value' => 'number'
+  rule 'value' => 'string'  
+  rule 'object' => %w(begin-object member-list end-object)
+  rule 'object' => %w(begin-object end-object)
+  # Next rule is an example of a left recursive rule
+  rule 'member-list' => %w(member-list value-separator member)
+  rule 'member-list' => 'member'
+  rule 'member' => %w(string name-separator value)
+  rule 'array' => %w(begin-array array_items end-array)
+  rule 'array' => %w(begin-array end-array)
+  rule 'array_items' => %w(array_items value-separator value)
+  rule 'array_items' => %w(value)
 end
 
 # And now build the grammar...

data/examples/data_formats/JSON/JSON_lexer.rb

@@ -11,12 +11,12 @@ class JSONLexer
   attr_reader(:name2symbol)
 
   @@lexeme2name = {
-    '{' => 'LACCOL',
-    '}' => 'RACCOL',
-    '[' => 'LBRACKET',
-    ']' => 'RBRACKET',
-    ',' => 'COMMA',
-    ':' => 'COLON'
+    '{' => 'begin-object',
+    '}' => 'end-object',
+    '[' => 'begin-array',
+    ']' => 'end-array',
+    ',' => 'value-separator',
+    ':' => 'name-separator'
   }
 
   class ScanError < StandardError ; end
@@ -53,14 +53,6 @@ private
           token_type = name2symbol[type_name]
           token = Rley::Tokens::Token.new(curr_ch, token_type)
 
-        # LITERALS
-        when '"'  # Start string delimiter found
-          value = scanner.scan(/([^"\\]|\\.)*/)
-          end_delimiter = scanner.getch()
-          raise ScanError.new('No closing quotes (") found') if end_delimiter.nil?
-          token_type = name2symbol['JSON_STRING']
-          token = Rley::Tokens::Token.new(value, token_type)
-
         when /[ftn]/  # First letter of keywords
           @scanner.pos = scanner.pos - 1 # Simulate putback
           keyw = scanner.scan(/false|true|null/)
@@ -68,18 +60,24 @@ private
             invalid_keyw = scanner.scan(/\w+/)
             raise ScanError.new("Invalid keyword: #{invalid_keyw}")
           else
-            token_type = name2symbol['KEYWORD']
+            token_type = name2symbol[keyw]
             token = Rley::Tokens::Token.new(keyw, token_type)
           end
 
+        # LITERALS
+        when '"'  # Start string delimiter found
+          value = scanner.scan(/([^"\\]|\\.)*/)
+          end_delimiter = scanner.getch()
+          raise ScanError.new('No closing quotes (") found') if end_delimiter.nil?
+          token_type = name2symbol['string']
+          token = Rley::Tokens::Token.new(value, token_type)
 
         when /[-0-9]/ # Start character of number literal found
           @scanner.pos = scanner.pos - 1 # Simulate putback
           value = scanner.scan(/-?[0-9]+(\.[0-9]+)?([eE][-+]?[0-9])?/)
-          token_type = name2symbol['JSON_NUMBER']
+          token_type = name2symbol['number']
           token = Rley::Tokens::Token.new(value, token_type)
 
-
         else # Unknown token
           erroneous = curr_ch.nil? ? '' : curr_ch
           sequel = scanner.scan(/.{1,20}/)

data/lib/rley.rb

@@ -5,10 +5,11 @@
 require_relative './rley/constants'
 require_relative './rley/syntax/grammar_builder'
 require_relative './rley/tokens/token'
-require_relative './rley/parser/earley_parser'
 require_relative './rley/parser/gfg_earley_parser'
 require_relative './rley/parse_tree_visitor'
 require_relative './rley/formatter/debug'
 require_relative './rley/formatter/json'
+require_relative './rley/formatter/debug'
+require_relative './rley/formatter/bracket_notation'
 
 # 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.02'.freeze
+  Version = '0.4.03'.freeze
 
   # Brief description of the gem.
   Description = "Ruby implementation of the Earley's parsing algorithm".freeze

data/lib/rley/formatter/bracket_notation.rb

@@ -0,0 +1,68 @@
+require_relative 'base_formatter'
+
+
+module Rley # This module is used as a namespace
+  # Namespace dedicated to parse tree formatters.
+  module Formatter
+    # A formatter class that generates the labelled bracket notation (LBN)
+    # representation of a parse tree.
+    # The output can be then fed to an application or library that is
+    # capable of displaying parse tree diagrams.
+    # For Ruby developers, there is RSyntaxTree by Yoichiro Hasebe.
+    # (accessible via: http://yohasebe.com/rsyntaxtree/)
+    class BracketNotation < BaseFormatter
+
+      # Constructor.
+      # @param anIO [IO] The output stream to which the rendered grammar
+      # is written.
+      def initialize(anIO)
+        super(anIO)
+      end
+
+
+      # Method called by a ParseTreeVisitor to which the formatter subscribed.
+      # Notification of a visit event: the visitor is about to visit
+      # a non-terminal node
+      # @param nonterm [NonTerminalNode]
+      def before_non_terminal(aNonTerm)
+        write("[#{aNonTerm.symbol.name} ")
+      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
+      # @param _term [TerminalNode]
+      def before_terminal(aTerm)
+        write("[#{aTerm.symbol.name} ")
+      end
+
+      # Method called by a ParseTreeVisitor to which the formatter subscribed.
+      # Notification of a visit event: the visitor completed the visit of
+      # a terminal node.
+      # @param _term [TerminalNode]
+      def after_terminal(aTerm)
+        # Escape all opening and closing square brackets
+        escape_lbrackets = aTerm.token.lexeme.gsub(/\[/, "\\[")
+        escaped = escape_lbrackets.gsub(/\]/, "\\]")
+        write(escaped + ']')
+      end
+
+      # Method called by a ParseTreeVisitor to which the formatter subscribed.
+      # Notification of a visit event: the visitor completed the visit of
+      # a non-terminal node
+      # @param _nonterm [NonTerminalNode]
+      def after_non_terminal(_nonterm)
+        write(']')
+      end
+
+      private
+
+      def write(aText)
+        output.write(aText)
+      end
+    end # class
+  end # module
+end # module
+
+# End of file

data/lib/rley/parse_tree_visitor.rb

@@ -7,7 +7,7 @@ module Rley # This module is used as a namespace
 
     # List of objects that subscribed to the visit event notification.
     attr_reader(:subscribers)
-    
+
     # Indicates the kind of tree traversal to perform: :post_order, :pre-order
     attr_reader(:traversal)
 
@@ -52,7 +52,7 @@ module Rley # This module is used as a namespace
         broadcast(:before_non_terminal, aNonTerminalNode)
         traverse_subnodes(aNonTerminalNode)
       else
-        traverse_subnodes(aNonTerminalNode)  
+        traverse_subnodes(aNonTerminalNode)
         broadcast(:before_non_terminal, aNonTerminalNode)
       end
       broadcast(:after_non_terminal, aNonTerminalNode)
@@ -67,7 +67,7 @@ module Rley # This module is used as a namespace
     end
 
 
-    # Visit event. The visitor has completed its visit of the given 
+    # Visit event. The visitor has completed its visit of the given
     # non-terminal node.
     # @param aNonTerminalNode [NonTerminalNode] the node to visit.
     def end_visit_nonterminal(aNonTerminalNode)
@@ -81,17 +81,17 @@ module Rley # This module is used as a namespace
     end
 
     private
-    
-    # Visit event. The visitor is about to visit the subnodes of a non 
+
+    # Visit event. The visitor is about to visit the subnodes of a non
     # terminal node.
     # @param aParentNode [NonTeminalNode] the (non-terminal) parent node.
     def traverse_subnodes(aParentNode)
       subnodes = aParentNode.subnodes
       broadcast(:before_subnodes, aParentNode, subnodes)
-      
+
       # Let's proceed with the visit of subnodes
       subnodes.each { |a_node| a_node.accept(self) }
-      
+
       broadcast(:after_subnodes, aParentNode, subnodes)
     end
 

data/lib/rley/parser/dotted_item.rb

@@ -98,11 +98,6 @@ module Rley # This module is used as a namespace
         return result
       end
 
-      # An item with the dot in front of a terminal is called a shift item
-      def shift_item?()
-        return position.zero?
-      end
-
       # Return true if this dotted item has a dot one place
       # to the right compared to the dotted item argument.
       def successor_of?(another)

data/lib/rley/parser/parse_tree_builder.rb

@@ -114,11 +114,6 @@ module Rley # This module is used as a namespace
                 create_token_node(anEntry, anIndex)
 
               when NilClass # Dot at the beginning of production
-                if anEntry.vertex.dotted_item.production.empty?
-                  # Empty rhs => create an epsilon node ...
-                  # ... without changing current path
-                  create_epsilon_node(anEntry, anIndex)
-                end
                 curr_path.pop if curr_parent.kind_of?(SPPF::AlternativeNode)
             end
 
@@ -195,15 +190,6 @@ module Rley # This module is used as a namespace
         return candidate
       end
 
-
-      def create_epsilon_node(anEntry, anIndex)
-        new_node = PTree::EpsilonNode.new(anIndex)
-        candidate = add_node_to_tree(new_node)
-        entry2node[anEntry] = candidate
-
-        return candidate
-      end
-
       # Add the given node if not yet present in parse tree
       def add_node_to_tree(aNode)
         new_node = aNode

data/lib/rley/ptree/parse_tree_node.rb

@@ -14,6 +14,7 @@ module Rley # This module is used as a namespace
         @range = Tokens::TokenRange.new(aRange)
       end
 
+      # Assign a value from given range to each  undefined range bound
       def range=(aRange)
         range.assign(aRange)
       end

data/spec/rley/formatter/bracket_notation_spec.rb

@@ -0,0 +1,96 @@
+require_relative '../../spec_helper'
+require 'stringio'
+
+require_relative '../support/grammar_abc_helper'
+require_relative '../../../lib/rley/tokens/token'
+require_relative '../../../lib/rley/parser/gfg_earley_parser'
+require_relative '../../../lib/rley/ptree/parse_tree'
+require_relative '../../../lib/rley/parse_tree_visitor'
+# Load the class under test
+require_relative '../../../lib/rley/formatter/bracket_notation'
+
+module Rley # Re-open the module to get rid of qualified names
+  module Formatter
+    describe BracketNotation do
+      include GrammarABCHelper # Mix-in module for grammar abc
+
+      # Factory method. Build a production with the given sequence
+      # of symbols as its rhs.
+      let(:grammar_abc) do
+        builder = grammar_abc_builder
+        builder.grammar
+      end
+      
+      # Variables for the terminal symbols
+      let(:a_) { grammar_abc.name2symbol['a'] }
+      let(:b_) { grammar_abc.name2symbol['b'] }
+      let(:c_) { grammar_abc.name2symbol['c'] }
+      
+      # Helper method that mimicks the output of a tokenizer
+      # for the language specified by gramma_abc
+      let(:grm_abc_tokens1) do
+        [
+          Tokens::Token.new('a', a_),
+          Tokens::Token.new('a', a_),
+          Tokens::Token.new('b', b_),
+          Tokens::Token.new('c', c_),
+          Tokens::Token.new('c', c_)
+        ]
+      end
+
+      # Factory method that builds a sample parse tree.
+      # Generated tree has the following structure:
+      # S[0,5]
+      # +- A[0,5]
+      #    +- a[0,0]
+      #    +- A[1,4]
+      #    |  +- a[1,1]
+      #    |  +- A[2,3]
+      #    |  |  +- b[2,3]
+      #    |  +- c[3,4]
+      #    +- c[4,5]
+      # Capital letters represent non-terminal nodes
+      let(:grm_abc_ptree1) do
+        parser = Parser::GFGEarleyParser.new(grammar_abc)
+        parse_result = parser.parse(grm_abc_tokens1)
+        parse_result.parse_tree
+      end
+  
+      let(:destination) { StringIO.new('', 'w') }
+      subject { BracketNotation.new(destination) }
+
+      context 'Standard creation & initialization:' do
+        it 'should be initialized with an IO argument' do
+          expect { BracketNotation.new(StringIO.new('', 'w')) }.not_to raise_error
+        end
+        
+        it 'should know its output destination' do
+          expect(subject.output).to eq(destination)
+        end
+      end # context
+  
+
+      context 'Formatting events:' do   
+        it 'should support visit events of a parse tree' do
+          visitor = Rley::ParseTreeVisitor.new(grm_abc_ptree1)
+          subject.render(visitor)
+          expectations = '[S [A [a a][A [a a][A [b b]][c c]][c c]]]'
+          expect(destination.string).to eq(expectations)
+        end
+        
+        it 'should escape square brackets' do
+          f_node = double('fake-node')
+          f_token = double('fake-token')
+          expect(f_node).to receive(:token).and_return(f_token)
+          expect(f_token).to receive(:lexeme).and_return('[][]')
+          
+          subject.after_terminal(f_node)
+          expectations = '\[\]\[\]]'
+          expect(destination.string).to eq(expectations)          
+        end
+      end # context
+    end # describe
+  end # module
+end # module
+
+# End of file

data/spec/rley/gfg/item_vertex_spec.rb

@@ -110,6 +110,12 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           shortcut = ShortcutEdge.new(subject, next_vertex)
           expect(subject.shortcut).to eq(shortcut)
         end
+        
+        it 'should reject an invalid shortcut edge' do
+          err = StandardError
+          err_msg = 'Invalid shortcut argument'
+          expect { subject.shortcut = 'invalid'}.to raise_error(err, err_msg)
+        end        
       end # context
     end # describe
   end # module

data/spec/rley/parse_tree_visitor_spec.rb

@@ -212,6 +212,64 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         # Here we go...
         subject.start
       end
+      
+      it 'should also visit in pre-order' do
+        # Reminder: parse tree structure is
+        # S[0,5]
+        # +- A[0,5]
+        #    +- a[0,0]
+        #    +- A[1,4]
+        #    |  +- a[1,1]
+        #    |  +- A[2,3]
+        #    |  |  +- b[2,3]
+        #    |  +- c[3,4]
+        #    +- c[4,5]
+        root = grm_abc_ptree1.root
+        # Here we defeat encapsulation for the good cause
+        subject.instance_variable_set(:@traversal, :pre_order)
+        
+        children = root.subnodes
+        big_a_1 = children[0]
+        big_a_1_children = big_a_1.subnodes
+        big_a_2 = big_a_1_children[1]
+        big_a_2_children = big_a_2.subnodes
+        big_a_3 = big_a_2_children[1]
+        big_a_3_children = big_a_3.subnodes
+        expectations = [
+          [:before_ptree, [grm_abc_ptree1]],
+          # TODO: fix this test
+          #[:before_subnodes, [root, children]],          
+          #[:before_non_terminal, [root]],
+
+          # [:before_non_terminal, [big_a_1]],
+          # [:before_subnodes, [big_a_1, big_a_1_children]],
+          # [:before_terminal, [big_a_1_children[0]]],
+          # [:after_terminal, [big_a_1_children[0]]],
+          # [:before_non_terminal, [big_a_2]],
+          # [:before_subnodes, [big_a_2, big_a_2_children]],
+          # [:before_terminal, [big_a_2_children[0]]],
+          # [:after_terminal, [big_a_2_children[0]]],
+          # [:before_non_terminal, [big_a_3]],
+          # [:before_subnodes, [big_a_3, big_a_3_children]],
+          # [:before_terminal, [big_a_3_children[0]]],
+          # [:after_terminal, [big_a_3_children[0]]],
+          # [:after_subnodes, [big_a_3, big_a_3_children]],
+          # [:before_terminal, [big_a_2_children[2]]],
+          # [:after_terminal, [big_a_2_children[2]]],
+          # [:after_subnodes, [big_a_2, big_a_2_children]],
+          # [:before_terminal, [big_a_1_children[2]]],
+          # [:after_terminal, [big_a_1_children[2]]],
+          # [:after_subnodes, [big_a_1, big_a_1_children]],
+          # [:after_subnodes, [root, children]],
+          # [:after_ptree, [grm_abc_ptree1]]
+        ]
+        expectations.each do |(msg, args)|
+          expect(listener1).to receive(msg).with(*args).ordered
+        end
+        
+        # Here we go...
+        subject.start
+      end      
     end # context
   end # describe
 end # module

data/spec/rley/parser/state_set_spec.rb

@@ -31,6 +31,19 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           subject.push_state(state2)
           expect(subject.states).to eq([state1, state2])
         end
+        
+        it 'should ignore a second push of a state' do
+          expect(subject.states).to be_empty
+          subject.push_state(state1)
+          subject.push_state(state2)
+          expect(subject.states).to eq([state1, state2])
+          
+          # One tries to push an already pushed state
+          expect(subject.push_state(state1)).to be_falsy
+          
+          # ...It is not added
+          expect(subject.states).to eq([state1, state2])          
+        end        
 
         it 'should list the states expecting a given terminal' do
           # Case of no state

data/spec/rley/ptree/parse_tree_node_spec.rb

@@ -25,6 +25,17 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(subject.range).to eq(sample_range)
         end
       end # context
+      
+      context 'Initialization:' do
+        it 'should assign undefined range bounds' do
+          partial_range =  { low: 0 } # High bound left undefined
+          instance = ParseTreeNode.new(sample_symbol, partial_range)
+          
+          another = { low: 1, high: 4 } # High bound is specified
+          instance.range = another
+          expect(instance.range).to eq({low: 0, high: 4})
+        end      
+      end # context      
     end # describe
   end # module
 end # module

data/spec/rley/sppf/non_terminal_node_spec.rb

@@ -55,6 +55,10 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         it 'should have a string representation' do
           expect(subject.to_string(0)).to eq('VP[0, 3]')
         end
+        
+        it 'should return a key value of itself' do
+          expect(subject.key).to eq('VP[0, 3]')
+        end
       end # context
     end # describe
   end # module

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rley
 version: !ruby/object:Gem::Version
-  version: 0.4.02
+  version: 0.4.03
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-09 00:00:00.000000000 Z
+date: 2017-04-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -142,6 +142,7 @@ files:
 - lib/rley.rb
 - lib/rley/constants.rb
 - lib/rley/formatter/base_formatter.rb
+- lib/rley/formatter/bracket_notation.rb
 - lib/rley/formatter/debug.rb
 - lib/rley/formatter/json.rb
 - lib/rley/gfg/call_edge.rb
@@ -201,6 +202,7 @@ files:
 - lib/rley/syntax/verbatim_symbol.rb
 - lib/rley/tokens/token.rb
 - lib/rley/tokens/token_range.rb
+- spec/rley/formatter/bracket_notation_spec.rb
 - spec/rley/formatter/debug_spec.rb
 - spec/rley/formatter/json_spec.rb
 - spec/rley/gfg/call_edge_spec.rb
@@ -291,6 +293,7 @@ signing_key:
 specification_version: 4
 summary: Ruby implementation of the Earley's parsing algorithm
 test_files:
+- spec/rley/formatter/bracket_notation_spec.rb
 - spec/rley/formatter/debug_spec.rb
 - spec/rley/formatter/json_spec.rb
 - spec/rley/gfg/call_edge_spec.rb