rley 0.2.12 → 0.2.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1d9b026414b1eb219f64ea54d5246bef7f38752a
-  data.tar.gz: 27f2cd60e08fbe83d51c40edc1cd32ff909ff14d
+  metadata.gz: 3487e06363e33e6a4e0c0e5c05a74379913589ab
+  data.tar.gz: f0907aa318f914f1ae63082b4e7158f929b2e746
 SHA512:
-  metadata.gz: 89bf91254a63bbdeeef9fe523da4662705beecb874f687415aa5e396b5ad244b6461a371b11357f651f014c3908942f05ecd226306279ce97b88fe1c2edf6dd5
-  data.tar.gz: d4e4cd201db5de2b04497726580b1b83773429fef206df81aa7040ef1e34b5df4b134e86bbb53cbb1fc84949224de6cfb6cfb6a42403cf7a1465bfbd3a519c51
+  metadata.gz: bdda4a8211470a1290befe63adfd65c278a3376a706ca367542f7ed1a7bbacc072a0167f08f539d94272ca3145e8b4821ac1f9912dc0d2d8824e01768689ea10
+  data.tar.gz: a23fe29e4573e412275e5ae8fcc5da35763954e130085628353cfce78651f30b0bc5a08ce0130c6edfd317ed952d57029fbfec1842c6fd46f895475061289750

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+### 0.2.14 / 2015-11-25
+* [FIX] Method `StateSet#ambiguities` overlooked some ambiguities in parse sets.
+
+### 0.2.13 / 2015-11-25
+* [NEW] method `Parsing#ambiguous?` returns true if more than one successful parse tree can be retried from parse results.
+* [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 
+    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 
     production rule for the start symbol of a grammar.

data/examples/parsers/parsing_ambig.rb

@@ -62,14 +62,21 @@ tokens = tokenizer(valid_input, grammar_amb)
 # Step 5. Let the parser process the input
 result = parser.parse(tokens)
 puts "Parsing success? #{result.success?}"
-pp result
+puts "Ambiguous parse? #{result.ambiguous?}"
+# 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
@@ -81,5 +88,5 @@ 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
 # 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.12'
+  Version = '0.2.14'
 
   # Brief description of the gem.
   Description = "Ruby implementation of the Earley's parsing algorithm"

data/lib/rley/parser/chart.rb

@@ -6,8 +6,9 @@ module Rley # This module is used as a namespace
     # Also called a parse table
     # A one-dimensional array with n + 1 entries (n = number of input tokens).
     class Chart
+      # An array of state sets (one per input token + 1)
       attr_reader(:state_sets)
-      
+            
       # The level of trace details reported on stdout during the parse.
       # The possible values are:
       # 0: No trace output (default case)
@@ -33,6 +34,11 @@ module Rley # This module is used as a namespace
       def start_dotted_rule()
         return self[0].states.first.dotted_rule
       end
+      
+      # Return the start (non-terminal) symbol of the grammar.
+      def start_symbol()
+        return state_sets.first.states[0].dotted_rule.lhs
+      end
 
       # Access the state set at given position
       def [](index)

data/lib/rley/parser/parsing.rb

@@ -25,10 +25,23 @@ module Rley # This module is used as a namespace
       # followed the syntax specified by the grammar)
       def success?()
         # Success can be detected as follows:
-        # The last chart entry has a complete parse state
-        # with the start symbol as lhs
-        found = end_parse_state
-        return !found.nil?
+        # The last chart entry has at least one complete parse state
+        # for the start symbol with an origin == 0
+        last_chart_entry = chart.state_sets[-1]
+        start_symbol = chart.start_symbol
+
+        # Retrieve all the complete states with start symbol in lhs 
+        end_states = last_chart_entry.states_rewriting(start_symbol)
+        success_states = end_states.select { |st| st.origin == 0 }
+        
+        return !success_states.empty?
+      end
+
+      # Return true if there are more than one complete state
+      # for the same lhs and same origin in any state set.
+      def ambiguous?()
+        found = chart.state_sets.find { |set| !set.ambiguities.empty? }
+        return ! found.nil?
       end
 
       # Factory method. Builds a ParseTree from the parse result.
@@ -48,7 +61,7 @@ module Rley # This module is used as a namespace
           # puts "Matching symbol: #{match_symbol}"
           # puts 'Parse tree:'
           # puts builder.root.to_string(0)
-        
+
           # Place the symbol on left of the dot in the parse tree
           done = insert_matched_symbol(state_tracker, builder)
           break if done
@@ -130,16 +143,18 @@ module Rley # This module is used as a namespace
         return predicted + others
       end
 
-      # Retrieve the parse state that represents a complete, successful parse
+      # Retrieve the parse state(s) that represents a complete, successful parse
       # After a successful parse, the last chart entry
-      # has a parse state that involves the start production and
+      # has a parse state that involves the start symbol and
       # has a dot positioned at the end of its rhs.
-      def end_parse_state()
-        start_dotted_rule = chart.start_dotted_rule
-        start_production = start_dotted_rule.production
+      def end_parse_states()
         last_chart_entry = chart.state_sets[-1]
-        candidate_states = last_chart_entry.states_for(start_production)
-        return candidate_states.find(&:complete?)
+        start_symbol = chart.start_symbol
+
+        # Retrieve all the complete states with origin at 0
+        end_states = last_chart_entry.states_rewriting(start_symbol)
+
+        return end_states
       end
 
 
@@ -179,7 +194,7 @@ module Rley # This module is used as a namespace
       # Factory method. Creates and initializes a ParseStateTracker instance.
       def new_state_tracker()
         instance = ParseStateTracker.new(chart.last_index)
-        instance.parse_state = end_parse_state
+        instance.parse_state = end_parse_states.first
 
         return instance
       end

data/lib/rley/parser/state_set.rb

@@ -35,6 +35,7 @@ module Rley # This module is used as a namespace
       def states_expecting(aSymbol)
         return states.select { |s| s.dotted_rule.next_symbol == aSymbol }
       end
+     
 
       # The list of complete ParseState that have the given non-terminal 
       # symbol as the lhs of their production.
@@ -70,6 +71,25 @@ module Rley # This module is used as a namespace
         terminals = expecting_terminals.map { |s| s.dotted_rule.next_symbol }
         return terminals.uniq
       end
+      
+      # Return an Array of Arrays of ambiguous parse states.
+      def ambiguities()
+        complete_states = states.select { |st|  st.complete? }
+        return [] if complete_states.size <= 1
+        
+        # Group parse state by lhs symbol and origin
+        groupings = complete_states.group_by do |st|
+          "#{st.dotted_rule.lhs.object_id}"
+        end
+        
+        # Retain the groups having more than one element.
+        ambiguous_groups = []
+        groupings.each_value do |a_group|
+          ambiguous_groups << a_group if a_group.size > 1
+        end
+        
+        return ambiguous_groups
+      end
 
       private
 

data/spec/rley/parser/chart_spec.rb

@@ -16,6 +16,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
   module Parser # Open this namespace to avoid module qualifier prefixes
     describe Chart do
       let(:count_token) { 20 }
+      let(:sample_start_symbol) { double('fake_non-terminal') }
       let(:dotted_rule) { double('fake-dotted-item') }
 
       let(:output) { StringIO.new('', 'w') }
@@ -28,10 +29,14 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       let(:sample_tracer) { ParseTracer.new(0, output, token_seq) }
       
       # Default instantiation rule
-      subject { Chart.new([ dotted_rule ], count_token, sample_tracer) }
+      subject do 
+        allow(dotted_rule).to receive(:lhs).and_return(sample_start_symbol)
+        Chart.new([ dotted_rule ], count_token, sample_tracer) 
+      end
 
       context 'Initialization:' do
         it 'should be created with start dotted rule, token count, tracer' do
+          allow(dotted_rule).to receive(:lhs).and_return(sample_start_symbol)
           expect { Chart.new([ dotted_rule ], count_token, sample_tracer) }
             .not_to raise_error
         end
@@ -51,6 +56,10 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         it 'should know the start dotted rule' do
           expect(subject.start_dotted_rule).to eq(dotted_rule)
         end
+        
+        it 'should know the start symbol' do
+          expect(subject.start_symbol).to eq(sample_start_symbol)
+        end
 
         it 'should have at least one non-empty state set' do
           expect(subject.last_index).to eq(0)

data/spec/rley/parser/earley_parser_spec.rb

@@ -163,6 +163,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         it 'should parse a valid simple input' do
           parse_result = subject.parse(grm1_tokens)
           expect(parse_result.success?).to eq(true)
+          expect(parse_result.ambiguous?).to eq(false)
 
           ######################
           # Expectation chart[0]:
@@ -263,6 +264,7 @@ SNIPPET
           instance = EarleyParser.new(grammar_expr)
           parse_result = instance.parse(grm2_tokens)
           expect(parse_result.success?).to eq(true)
+          expect(parse_result.ambiguous?).to eq(false)
 
           ###################### S(0): . 2 + 3 * 4
           # Expectation chart[0]:
@@ -397,6 +399,7 @@ SNIPPET
           expect { instance.parse(tokens) }.not_to raise_error
           parse_result = instance.parse(tokens)
           expect(parse_result.success?).to eq(true)
+          expect(parse_result.ambiguous?).to eq(true)
 
           ###################### S(0): . 2 + 3 * 4
           # Expectation chart[0]:
@@ -484,6 +487,7 @@ SNIPPET
           expect { instance.parse(tokens) }.not_to raise_error
           parse_result = instance.parse(tokens)
           expect(parse_result.success?).to eq(true)
+          expect(parse_result.ambiguous?).to eq(true)          
 
           ###################### S(0): . abc + def + ghi
           # Expectation chart[0]:
@@ -565,8 +569,7 @@ MSG
           expect { subject.parse(wrong) }
             .to raise_error(err, err_msg.chomp)
 =begin
-          expect(parse_result.success?).to eq(false)
-
+          # This code is never reached (because of exception)
           ###################### S(0) == . a a c c
           # Expectation chart[0]:
           expected = [
@@ -592,7 +595,6 @@ MSG
           ]
           compare_state_texts(parse_result.chart[2], expected)
 
-
           ###################### S(3) == a a c? c
           state_set_3 = parse_result.chart[3]
           expect(state_set_3.states).to be_empty  # This is an error symptom

data/spec/rley/parser/parsing_spec.rb

@@ -170,7 +170,7 @@ SNIPPET
           return [state_tracker, builder]
         end
 
-
+# Spiff
         it 'should create the root of a parse tree' do
           (state_tracker, builder) = prepare_parse_tree(subject)
           # The root node should correspond to the start symbol and

data/spec/rley/parser/state_set_spec.rb

@@ -71,6 +71,31 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(subject.states_rewriting(non_term)).to eq([state2])
         end
         
+        it 'should list of ambiguous states' do
+          prod1 = double('fake-production1')
+          prod2 = double('fake-production2')
+          expect(subject.ambiguities.size).to eq(0)
+          
+          # Adding states
+          subject.push_state(state1)
+          allow(dotted_rule1).to receive(:production).and_return(prod1)
+          allow(dotted_rule1).to receive(:"reduce_item?").and_return(true)
+          allow(dotted_rule1).to receive(:lhs).and_return(:something)     
+          expect(subject.ambiguities.size).to eq(0)
+          allow(dotted_rule2).to receive(:production).and_return(prod2)
+          allow(dotted_rule2).to receive(:"reduce_item?").and_return(true)
+          allow(dotted_rule2).to receive(:lhs).and_return(:something_else)  
+          subject.push_state(state2)
+          expect(subject.ambiguities.size).to eq(0)
+          dotted_rule3 = double('fake_dotted_rule3')
+          allow(dotted_rule3).to receive(:production).and_return(prod2)
+          allow(dotted_rule3).to receive(:"reduce_item?").and_return(true)
+          allow(dotted_rule3).to receive(:lhs).and_return(:something_else)  
+          state3 = ParseState.new(dotted_rule3, 5)
+          subject.push_state(state3) 
+          expect(subject.ambiguities[0]).to eq([state2, state3])          
+        end
+        
         it 'should complain when impossible predecessor of parse state' do
           subject.push_state(state1)
           subject.push_state(state2)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rley
 version: !ruby/object:Gem::Version
-  version: 0.2.12
+  version: 0.2.14
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-20 00:00:00.000000000 Z
+date: 2015-11-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -54,6 +54,9 @@ dependencies:
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.8.0
@@ -61,6 +64,9 @@ dependencies:
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.8.0
@@ -68,6 +74,9 @@ dependencies:
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.7.0
@@ -75,6 +84,9 @@ dependencies:
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.7.0