rley 0.4.03 → 0.4.04

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2d13db61565b20ef542592a59bcd056d4dd2192e
-  data.tar.gz: a8d8c12a600d9621d6be682570cb165d526641ef
+  metadata.gz: 5100723b47c2572c2ac0b5996413eb4cd8e462ba
+  data.tar.gz: 4d37be9ca7128a36f77505560c7214454e413eb5
 SHA512:
-  metadata.gz: 679e3f7d6747264092f317521e1f8f9e241ad912de71280c0c6d68454110bd3ba75fdc6f1f4a9c76ac61622ed87fba86f2662e3f15b5cd9a0e2d571b340e2988
-  data.tar.gz: edb83ffb5fb673f27abef6c7ef10014fb8c6c312de093251f6ce509e2893c20cf5114cb77abf1b97c1406d9d22d474b0ab577829acb9d59f58117e43e96eaef2
+  metadata.gz: c197b1b962408e3a3ce4be5d310c227bdc638028d9a40d26b89c544232f59a8ce994228e4ae3673cbe6147dbcd520ee53c36a0620e3c7871edd3aba46762933f
+  data.tar.gz: 21b59e0b9b5c942be83954b35ee15650e1bc2c2aa2f9a6f1ebba645b94e3f822df510026825354512cf7eea879431feed852f34cef9fd176c5d0b89377504a46

data/CHANGELOG.md

@@ -1,8 +1,15 @@
+### 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.
+
 ### 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.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.01 / 2016-12-21
 * [NEW] File `appveyor.yml`. Add AppVeyor CI to Github commits. AppVeyor complements Travis by running builds under Windows OS.

data/examples/data_formats/JSON/JSON_demo.rb

@@ -1,32 +1,23 @@
+require_relative 'cli_options'
 require_relative 'JSON_parser'
 
-# Create a JSON parser object
-parser = JSONParser.new 
+prog_name = 'JSON_demo'
+prog_version = '0.1.0'
 
-# Parse the input file with name given in command-line
+cli_options = CLIOptions.new(prog_name, prog_version, ARGV)
 if ARGV.empty?
-  msg = <<-END_MSG
-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
-    
-  Example:
-  ruby #{__FILE__} sample01.json
-END_MSG
-  puts msg
+  puts 'Missing input file name.'
+  puts 'Use -h option for command-line help.'
   exit(1)
 end
+
 file_name = ARGV[0]
+# Create a JSON parser object
+parser = JSONParser.new 
 result = parser.parse_file(file_name) # result object contains parse details
 
 unless result.success?
-  # Stop if the parse failed...
+  # Stop if parse failed...
   puts "Parsing of '#{file_name}' failed"
   puts result.failure_reason.message
   exit(1)
@@ -34,15 +25,18 @@ end
 
 # Generate a parse tree from the parse result
 ptree = result.parse_tree
-require 'yaml'
-File.open('json1.yml', 'w') {|f| YAML.dump(ptree, f)}
+
+# Select the output format
+case cli_options[:format]
+  when :ascii_tree
+    renderer = Rley::Formatter::Asciitree.new($stdout)
+  when :labelled
+    renderer = Rley::Formatter::BracketNotation.new($stdout)
+end
 
 # 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)
-
-
+# Now output formatted parse tree
+renderer.render(visitor)
 # End of file

data/examples/data_formats/JSON/JSON_grammar.rb

@@ -4,7 +4,7 @@ require 'rley'  # Load the gem
 
 ########################################
 # Define a grammar for JSON
-# Original JSON grammar is available http://www.json.org/fatfree.html
+# Original JSON grammar is available at: 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
@@ -27,11 +27,11 @@ builder = Rley::Syntax::GrammarBuilder.new do
   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 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)
+  rule 'array-items' => %w(array-items value-separator value)
+  rule 'array-items' => %w(value)
 end
 
-# And now build the grammar...
+# And now build the JSON grammar...
 GrammarJSON = builder.grammar

data/examples/data_formats/JSON/JSON_parser.rb

@@ -1,6 +1,6 @@
 # Purpose: to demonstrate how to build and render a parse tree for JSON
 # language
-require 'rley'  # Load the gem
+require 'rley'  # Load the Rley gem
 require_relative 'json_lexer'
 
 # Steps to render a parse tree (of a valid parsed input):

data/examples/data_formats/JSON/cli_options.rb

@@ -0,0 +1,65 @@
+require 'optparse'
+
+# A Hash specialization that collects the command-line options
+class CLIOptions < Hash
+#labelled square notation (LBN).
+#Use online tools (e.g. http://yohasebe.com/rsyntaxtree/) to visualize
+#parse trees from LBN output.
+
+  def initialize(progName, progVersion, args)
+    super()
+    
+    # Default values
+    self[:prog_name] = progName
+    self[:prog_version] = progVersion
+    self[:format] = :ascii_tree
+    
+    options = build_option_parser
+    options.parse!(args)
+  end
+
+  private
+
+  def build_option_parser
+    OptionParser.new do |opts|
+      opts.banner = <<-END_BANNER
+#{self[:prog_name]}: a demo utility that parses a JSON file
+and renders its parse tree to the standard output 
+in the format specified in the command-line.
+
+Usage: JSON_demo.rb [options] FILE
+
+Examples:
+JSON_demo --format ascii_tree sample01.jon
+END_BANNER
+
+      opts.separator ''
+
+      format_help = <<-END_TEXT
+Select the output format (default: ascii_tree). Available formats:
+  ascii_tree  Simple text representation of parse trees
+  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)
+      opts.on('-f', '--format FORMAT', formats, format_help) do |frm|
+        self[:format] = frm
+      end
+
+      opts.separator ''
+      opts.separator '  **** Utility ****'
+
+      opts.on('-v', '--version', 'Display the program version.') do
+        puts self[:prog_version]
+        exit
+      end
+
+      # No argument, shows at tail.  This will print an options summary.
+      opts.on_tail('-h', '--help', 'Display this help message.') do
+        puts opts
+        exit
+      end
+    end
+  end
+end # class

data/lib/rley.rb

@@ -9,7 +9,7 @@ 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/asciitree'
 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.03'.freeze
+  Version = '0.4.04'.freeze
 
   # Brief description of the gem.
   Description = "Ruby implementation of the Earley's parsing algorithm".freeze

data/lib/rley/formatter/asciitree.rb

@@ -0,0 +1,128 @@
+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 draws parse trees by using characters
+    class Asciitree < BaseFormatter
+      # TODO
+      attr_reader(:curr_path)
+
+      # For each node in curr_path, there is a corresponding string value.
+      # Allowed string values are: 'first', 'last', 'first_and_last', 'other'
+      attr_reader(:ranks)
+
+      attr_reader(:nesting_prefix)
+
+      attr_reader(:blank_indent)
+
+      attr_reader(:continuation_indent)
+
+      # Constructor.
+      # @param anIO [IO] The output stream to which the rendered grammar
+      # is written.
+      def initialize(anIO)
+        super(anIO)
+        @curr_path = []
+        @ranks = []
+
+        @nesting_prefix = '+-- '
+        @blank_indent = '    '
+        @continuation_indent = '|   '
+      end
+
+
+      # Method called by a ParseTreeVisitor to which the formatter subscribed.
+      # Notification of a visit event: the visitor is about to visit
+      # the children of a non-terminal node
+      # @param _parent [NonTerminalNode]
+      # @param _children [Array] array of children nodes
+      def before_subnodes(parent, children)
+        rank_of(parent)
+        curr_path << parent
+      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)
+        emit(aNonTerm)
+      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)
+        emit(aTerm, ": '#{aTerm.token.lexeme}'")
+      end
+
+
+      # Method called by a ParseTreeVisitor to which the formatter subscribed.
+      # Notification of a visit event: the visitor completed the visit of
+      # the children of a non-terminal node.
+      # @param _parent [NonTerminalNode]
+      # @param _children [Array] array of children nodes
+      def after_subnodes(_parent, _children)
+        curr_path.pop
+        ranks.pop
+      end
+
+      private
+
+      # Parent node is last node in current path
+      # or current path is empty (then aChild is root node)
+      def rank_of(aChild)
+        if curr_path.empty?
+          rank = 'root'
+        elsif curr_path[-1].subnodes.size == 1
+          rank = 'first_and_last'
+        else
+          parent = curr_path[-1]
+          siblings = parent.subnodes
+          siblings_last_index = siblings.size - 1
+          rank = case siblings.find_index(aChild)
+                 when 0 then 'first'
+                 when siblings_last_index then 'last'
+                 else
+                  'other'
+                 end
+        end
+        self.ranks << rank
+      end
+
+      # 'root', 'first', 'first_and_last', 'last', 'other'
+      def path_prefix()
+        return '' if ranks.empty?
+
+        prefix = ''
+        @ranks.each_with_index do |rank, i|
+          next if i == 0
+
+          case rank
+            when 'first', 'other'
+              prefix << continuation_indent
+
+            when 'last', 'first_and_last', 'root'
+              prefix << blank_indent
+            else
+          end
+        end
+
+        prefix << nesting_prefix
+        return prefix
+      end
+
+
+      def emit(aNode, aSuffix = '')
+        output.puts("#{path_prefix}#{aNode.symbol.name}#{aSuffix}")
+      end
+    end # class
+  end # module
+end # module
+
+# End of file

data/spec/rley/formatter/asciitree_spec.rb

@@ -0,0 +1,95 @@
+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/asciitree'
+
+module Rley # Re-open the module to get rid of qualified names
+  module Formatter
+    describe Asciitree 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 { Asciitree.new(destination) }
+
+      context 'Standard creation & initialization:' do
+        it 'should be initialized with an IO argument' do
+          expect { Asciitree.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 'Rendering:' do   
+        it 'should render a parse tree' do
+          visitor = Rley::ParseTreeVisitor.new(grm_abc_ptree1)
+          subject.render(visitor)
+          expectations = <<-SNIPPET
+S
++-- A
+    +-- a: 'a'
+    +-- A
+    |   +-- a: 'a'
+    |   +-- A
+    |   |   +-- b: 'b'
+    |   +-- c: 'c'
+    +-- c: 'c'
+SNIPPET
+          expect(destination.string).to eq(expectations)
+        end
+      end # context
+    end # describe
+  end # module
+end # module
+
+# End of file

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rley
 version: !ruby/object:Gem::Version
-  version: 0.4.03
+  version: 0.4.04
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-17 00:00:00.000000000 Z
+date: 2017-05-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -135,12 +135,14 @@ files:
 - examples/data_formats/JSON/JSON_grammar.rb
 - examples/data_formats/JSON/JSON_lexer.rb
 - examples/data_formats/JSON/JSON_parser.rb
+- examples/data_formats/JSON/cli_options.rb
 - examples/general/calc/calc_demo.rb
 - examples/general/calc/calc_grammar.rb
 - examples/general/calc/calc_lexer.rb
 - examples/general/calc/calc_parser.rb
 - lib/rley.rb
 - lib/rley/constants.rb
+- lib/rley/formatter/asciitree.rb
 - lib/rley/formatter/base_formatter.rb
 - lib/rley/formatter/bracket_notation.rb
 - lib/rley/formatter/debug.rb
@@ -202,6 +204,7 @@ files:
 - lib/rley/syntax/verbatim_symbol.rb
 - lib/rley/tokens/token.rb
 - lib/rley/tokens/token_range.rb
+- spec/rley/formatter/asciitree_spec.rb
 - spec/rley/formatter/bracket_notation_spec.rb
 - spec/rley/formatter/debug_spec.rb
 - spec/rley/formatter/json_spec.rb
@@ -293,6 +296,7 @@ signing_key:
 specification_version: 4
 summary: Ruby implementation of the Earley's parsing algorithm
 test_files:
+- spec/rley/formatter/asciitree_spec.rb
 - spec/rley/formatter/bracket_notation_spec.rb
 - spec/rley/formatter/debug_spec.rb
 - spec/rley/formatter/json_spec.rb