rley 0.2.11 → 0.2.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f8e948ad67fc54061db90c17fdd492a637d86ee5
-  data.tar.gz: 0ae31c54bb56f2b031c666da5e50a6e4c5b652ad
+  metadata.gz: 1d9b026414b1eb219f64ea54d5246bef7f38752a
+  data.tar.gz: 27f2cd60e08fbe83d51c40edc1cd32ff909ff14d
 SHA512:
-  metadata.gz: 47625538467f3e61d2d49d566e9aede25def7faabd5685d21fa30c66c4a10dea1846631916f2a9c16e8abdf6778a6d596a0ad6abd1aef44bba45ff72905ee4d6
-  data.tar.gz: f4afa9d44afb07221b5418025a65bc8bd9a0bf9b98175344d6db6e3f6985bd1e719139efe6e5f2eede4eaa4cd359d43c536cdb4b06812f9a309d087c6c8f591c
+  metadata.gz: 89bf91254a63bbdeeef9fe523da4662705beecb874f687415aa5e396b5ad244b6461a371b11357f651f014c3908942f05ecd226306279ce97b88fe1c2edf6dd5
+  data.tar.gz: d4e4cd201db5de2b04497726580b1b83773429fef206df81aa7040ef1e34b5df4b134e86bbb53cbb1fc84949224de6cfb6cfb6a42403cf7a1465bfbd3a519c51

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+### 0.2.12 / 2015-11-20
+* [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
 * [CHANGE] Code re-formatted to please Rubocop 0.34.0
 * [CHANGE] File `.travis.yml`: added new Rubies: MRI 2.2.0 and JRuby 9.0.

data/examples/parsers/parsing_ambig.rb

@@ -14,7 +14,7 @@ require 'rley'  # Load the gem
 
 ########################################
 # Step 1. Define a grammar for a very simple language
-# Grammar 3: A ambiguous arithmetic expression language
+# Grammar 3: An ambiguous arithmetic expression language
 # (based on example in article on Earley's algorithm in Wikipedia)
 # Let's create the grammar step-by-step with the grammar builder:
 builder = Rley::Syntax::GrammarBuilder.new

data/examples/parsers/parsing_tricky.rb

@@ -0,0 +1,91 @@
+# Purpose: to demonstrate how to build and render a parse tree
+
+require 'pp' # TODO remove this dependency
+require 'rley'  # Load the gem
+
+# Steps to render a parse tree (of a valid parsed input):
+# 1. Define a grammar
+# 2. Create a tokenizer for the language
+# 3. Create a parser for that grammar
+# 4. Tokenize the input
+# 5. Let the parser process the input
+# 6. Generate a parse tree from the parse result
+# 7. Render the parse tree (in JSON)
+
+########################################
+# Step 1. Define a problematic grammar
+# Grammar Z: A grammar with hidden left recursion and a cycle
+# (based on example in article of Elizabeth Scott, "SPPF-Style Parsing From Earley Recognisers"
+# Electronic Notes in Theoretical Computer Science 203 (2008) 53–67
+# Let's create the grammar step-by-step with the grammar builder:
+builder = Rley::Syntax::GrammarBuilder.new
+builder.add_terminals('a', 'b')
+builder.add_production('S' => %w(A T))
+builder.add_production('S' => %w(a T))
+builder.add_production('A' => 'a')
+builder.add_production('A' => %w(B A))
+builder.add_production('B' => []) # Empty RHS
+builder.add_production('T' => %w(b b b))
+
+# And now build the grammar...
+grammar_tricky = builder.grammar
+
+
+########################################
+# 2. Create a tokenizer for the language
+# The tokenizer transforms the input into an array of tokens
+def tokenizer(aText, aGrammar)
+  tokens = aText.chars.map do |lexeme|
+    case lexeme
+      when 'a', 'b'
+        terminal = aGrammar.name2symbol[lexeme]
+      else
+        msg = "Unknown input text '#{lexeme}'"
+        fail StandardError, msg
+    end
+    Rley::Parser::Token.new(lexeme, terminal)
+  end
+
+  return tokens
+end
+
+########################################
+# Step 3. Create a parser for that grammar
+parser = Rley::Parser::EarleyParser.new(grammar_tricky)
+
+########################################
+# Step 3. Tokenize the input
+valid_input = 'abbb'
+tokens = tokenizer(valid_input, grammar_tricky)
+
+########################################
+# Step 5. Let the parser process the input
+result = parser.parse(tokens)
+puts "Parsing success? #{result.success?}"
+#pp result
+
+result.chart.state_sets.each_with_index do |aStateSet, index|
+  puts "State[#{index}]"
+  puts "========"
+  aStateSet.states.each { |aState| puts aState.to_s }
+end
+
+=begin
+########################################
+# Step 6. Generate a parse tree from the parse result
+ptree = result.parse_tree
+pp ptree
+#=begin
+########################################
+# Step 7. Render the parse tree (in JSON)
+# Let's create a parse tree visitor
+visitor = Rley::ParseTreeVisitor.new(ptree)
+
+#Here we create a renderer object...
+renderer = Rley::Formatter::Json.new(STDOUT)
+
+# Now emit the parse tree as JSON on the console output
+puts "JSON rendering of the parse tree for '#{valid_input}' input:"
+renderer.render(visitor)
+=end
+# 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.2.11'
+  Version = '0.2.12'
 
   # Brief description of the gem.
   Description = "Ruby implementation of the Earley's parsing algorithm"

data/lib/rley/parser/chart.rb

@@ -15,11 +15,16 @@ module Rley # This module is used as a namespace
       # 2: Same as of 1 with the addition of the prediction rules
       attr_reader(:tracer)
 
-      # @param aTracerLevel [ParseTracer] A tracer object. 
-      def initialize(startDottedItem, tokenCount, aTracer)
+      # @param startItems [Array] A non-empty Array of dotted items for 
+      #   the start symbol.
+      # @param tokenCount [Fixnum] The number of lexemes in the input to parse.
+      # @param aTracer [ParseTracer] A tracer object. 
+      def initialize(startItems, tokenCount, aTracer)
         @tracer = aTracer
         @state_sets = Array.new(tokenCount + 1) { |_| StateSet.new }
-        push_state(startDottedItem, 0, 0, :start_rule)
+        startItems.each do |startDottedItem|
+          push_state(startDottedItem, 0, 0, :start_rule)
+        end
       end
 
       # The dotted item/rule used to seed the parse chart.

data/lib/rley/parser/earley_parser.rb

@@ -41,7 +41,7 @@ module Rley # This module is used as a namespace
       # @return [Parsing] an object that embeds the parse results.
       def parse(aTokenSequence, aTraceLevel = 0)
         tracer = ParseTracer.new(aTraceLevel, $stdout, aTokenSequence)
-        result = Parsing.new(start_dotted_item, aTokenSequence, tracer)
+        result = Parsing.new(start_dotted_items, aTokenSequence, tracer)
         last_token_index = aTokenSequence.size
         (0..last_token_index).each do |i|
           handle_error(result) if result.chart[i].empty?
@@ -115,10 +115,13 @@ module Rley # This module is used as a namespace
 
       # The dotted item for the start production and
       # with the dot at the beginning of the rhs
-      def start_dotted_item()
-        # TODO: remove assumption that first dotted_item is 
-        # for start production
-        return dotted_items[0]
+      def start_dotted_items()
+        start_symbol = grammar.start_symbol
+        start_items = dotted_items.select do |anItem|
+          (anItem.lhs == start_symbol) && anItem.at_start?
+        end
+        
+        return start_items
       end
 
       

data/lib/rley/parser/parsing.rb

@@ -16,9 +16,9 @@ module Rley # This module is used as a namespace
       # 0: No trace output (default case)
       # 1: Show trace of scanning and completion rules
       # 2: Same as of 1 with the addition of the prediction rules
-      def initialize(startDottedRule, theTokens, aTracer)
+      def initialize(startDottedRules, theTokens, aTracer)
         @tokens = theTokens.dup
-        @chart = Chart.new(startDottedRule, tokens.size, aTracer)
+        @chart = Chart.new(startDottedRules, tokens.size, aTracer)
       end
 
       # Return true if the parse was successful (= input tokens

data/spec/rley/parser/chart_spec.rb

@@ -26,13 +26,13 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       end
 
       let(:sample_tracer) { ParseTracer.new(0, output, token_seq) }
+      
+      # Default instantiation rule
+      subject { Chart.new([ dotted_rule ], count_token, sample_tracer) }
 
       context 'Initialization:' do
-        # Default instantiation rule
-        subject { Chart.new(dotted_rule, count_token, sample_tracer) }
-
         it 'should be created with start dotted rule, token count, tracer' do
-          expect { Chart.new(dotted_rule, count_token, sample_tracer) }
+          expect { Chart.new([ dotted_rule ], count_token, sample_tracer) }
             .not_to raise_error
         end
 
@@ -82,7 +82,6 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           ParseState.new(aDottedRule, origin)
         end
 
-        subject { Chart.new(dotted_rule, count_token, sample_tracer) }
 
         it 'should trace its initialization' do
           subject[0]  # Force constructor call here

data/spec/rley/parser/earley_parser_spec.rb

@@ -270,9 +270,9 @@ SNIPPET
             'P => . S | 0',         # start rule
             "S => . S '+' M | 0",   # predict from (1)
             'S => . M | 0',         # predict from (1)
-            "M => . M '*' T | 0",   # predict from (3)
-            'M => . T | 0',         # predict from (3)
-            'T => . integer | 0'    # predict from (3)
+            "M => . M '*' T | 0",   # predict from (4)
+            'M => . T | 0',         # predict from (4)
+            'T => . integer | 0'    # predict from (4)
           ]
           compare_state_texts(parse_result.chart[0], expected)
 
@@ -637,7 +637,7 @@ MSG
           ###################### S(0) == . a a / a
           # Expectation chart[0]:
           expected = [
-            'Z => . E | 0',     # start rule
+            'Z => . E | 0',     # start rule           
             'E => . E Q F | 0', # predict from (1)
             'E => . F | 0',     # predict from (1)
             "F => . 'a' | 0"    # predict from (3)

data/spec/rley/parser/parsing_spec.rb

@@ -54,14 +54,14 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       let(:sample_tracer) { ParseTracer.new(0, output, grm1_tokens) }
 
       # Default instantiation rule
-      subject { Parsing.new(start_dotted_rule, grm1_tokens, sample_tracer) }
+      subject { Parsing.new([ start_dotted_rule ], grm1_tokens, sample_tracer) }
 
       context 'Initialization:' do
-        it 'should be created with list of tokens, start dotted rule, trace' do
-          start_rule = start_dotted_rule
+        it 'should be created with list of tokens, start dotted rules, trace' do
+          start_rules = [ start_dotted_rule ]
           tokens = grm1_tokens
           tracer = sample_tracer
-          expect { Parsing.new(start_rule, tokens, tracer) }.not_to raise_error
+          expect { Parsing.new(start_rules, tokens, tracer) }.not_to raise_error
         end
 
         it 'should know the input tokens' do
@@ -74,7 +74,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
         it 'should emit trace level 1 info' do
           tracer = ParseTracer.new(1, output, grm1_tokens)
-          Parsing.new(start_dotted_rule, grm1_tokens, tracer)
+          Parsing.new([ start_dotted_rule ], grm1_tokens, tracer)
           expectations = <<-SNIPPET
 ['a', 'a', 'b', 'c', 'c']
 |. a . a . b . c . c .|

data/spec/rley/support/grammar_abc_helper.rb

@@ -8,9 +8,9 @@ module GrammarABCHelper
   def grammar_abc_builder()
     builder = Rley::Syntax::GrammarBuilder.new
     builder.add_terminals('a', 'b', 'c')
-    builder.add_production('S' => ['A'])
+    builder.add_production('S' => 'A')
     builder.add_production('A' => %w(a A c))
-    builder.add_production('A' => ['b'])
+    builder.add_production('A' => 'b')
 
     return builder
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rley
 version: !ruby/object:Gem::Version
-  version: 0.2.11
+  version: 0.2.12
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-05 00:00:00.000000000 Z
+date: 2015-11-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -130,6 +130,7 @@ files:
 - examples/parsers/parsing_b_expr.rb
 - examples/parsers/parsing_err_expr.rb
 - examples/parsers/parsing_groucho.rb
+- examples/parsers/parsing_tricky.rb
 - examples/parsers/tracing_parser.rb
 - examples/recognizers/recognizer_abc.rb
 - lib/rley.rb