rley 0.3.00 → 0.3.01

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5b7bad0d01ea1fbe0656bf1765843288c1521b26
-  data.tar.gz: d7b96f2d154b172c0847b3a96eaf0b6422439db1
+  metadata.gz: a668b1310cdd11c57771b1c26a85418a129f4c7c
+  data.tar.gz: 81e9d24b519700e79b508e72c9f8ada5b24d04a0
 SHA512:
-  metadata.gz: 76fa3fcf95a3bb55ca2e13eb1b449032cb3030cf18c5ab114e2398aeec16401d8c2b738f9818831dd4360d143f24f1240ffd13b8f0c495dcb8f5c684675ec894
-  data.tar.gz: 52f7f640dfc96d9f78a9ee1a44da1fb81086d446b1196d9a422bb5f6e7312c0e6ea089ce595b78b3b4c1d51d4cf810b18cda26fefd2477f7b5190dc9dfb8bca3
+  metadata.gz: 0ed6712c6dcfaf69b5e445fee8694917bb50a93a0bf6fff05931146453f6c129bee9166b128227d0ddfe7798347f97989def511e379d34f185a83290d8feee38
+  data.tar.gz: e83de687d95f2622163e91265feee3d560da37f769a7b6176a4ba73b8b4874b2458a3539d96b67eb909961eee62ba180c71a37ced9e97146942f2c1a5ff87b7e

data/.travis.yml

@@ -1,6 +1,6 @@
 language: ruby
 rvm:
-  - 1.9.3
+#  - 1.9.3
   - 2.0.0
   - 2.1.0
   - 2.2.0

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+### 0.3.01 / 2016-10-23
+* [CHANGED] Method `ParseWalkerFactory#build_walker`. Signature change in order prevent direct dependency on `GFGParsing` class.
+* [CHANGED] Class `ParseForestBuilder`. Removal of `parsing` attribute, no direct dependency on `GFGParsing` class.
+* [CHANGED] 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. 
 

data/lib/rley/constants.rb

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

data/lib/rley/parser/parse_forest_builder.rb

@@ -9,8 +9,8 @@ module Rley # This module is used as a namespace
     # (say, a parse forest) from simpler objects (terminal and non-terminal
     # nodes) and using a step by step approach.
     class ParseForestBuilder
-      # Link to parse result
-      attr_reader(:parsing)
+      # The sequence of input tokens  
+      attr_reader(:tokens)
 
       # Link to forest object
       attr_reader(:forest)
@@ -25,8 +25,8 @@ module Rley # This module is used as a namespace
       # This is needed for synchronizing backtracking
       attr_reader(:entry2path_to_alt)
 
-      def initialize(aParsingResult)
-        @parsing = aParsingResult
+      def initialize(theTokens)
+        @tokens = theTokens
         @curr_path = []
         @entry2node = {}
         @entry2path_to_alt = {}
@@ -66,7 +66,7 @@ private
           if curr_path.empty?
             # Build parse forest with root node derived from the
             # accepting parse entry.
-            @forest = create_forest(anEntry)
+            @forest = create_forest(anEntry, anIndex)
           else
             # if current_parent node matches the lhs non-terminal of anEntry
             # set its origin to the origin of its first child (if not yet assigned)
@@ -155,8 +155,8 @@ private
       end
       
       # Create an empty parse forest
-      def create_forest(anEntry)
-        full_range = { low: 0, high: parsing.chart.last_index }
+      def create_forest(anEntry, anIndex)
+        full_range = { low: 0, high: anIndex }
         root_node = create_non_terminal_node(anEntry, full_range)
         return Rley::SPPF::ParseForest.new(root_node)      
       end
@@ -183,7 +183,7 @@ private
 
       def create_token_node(anEntry, anIndex)
         token_position = anIndex - 1
-        curr_token = parsing.tokens[token_position]
+        curr_token = tokens[token_position]
         new_node = SPPF::TokenNode.new(curr_token, token_position)
         candidate = add_node_to_forest(new_node)
         entry2node[anEntry] = candidate        

data/lib/rley/parser/parse_forest_factory.rb

@@ -13,7 +13,7 @@ module Rley # This module is used as a namespace
       def initialize(aParsingResult)
         @parsing = aParsingResult
       end
-
+        
       # Factory that produces the parse forest
       def build_parse_forest()
         a_walker = walker(parsing)
@@ -39,13 +39,15 @@ private
       # of a GFGParsing
       def walker(aParseResult)
         walker_factory = ParseWalkerFactory.new
-        walker = walker_factory.build_walker(aParseResult)
+        accept_entry = aParseResult.accepting_entry
+        accept_index = aParseResult.chart.last_index        
+        walker = walker_factory.build_walker(accept_entry, accept_index)
       end
 
       # Create a Builder, that is, an object
       # that will create piece by piece the forest
       def builder(aParseResult)
-        ParseForestBuilder.new(aParseResult)
+        ParseForestBuilder.new(aParseResult.tokens)
       end
     end # class
   end # module

data/lib/rley/parser/parse_walker_factory.rb

@@ -35,10 +35,9 @@ module Rley # This module is used as a namespace
     class ParseWalkerFactory
       # Build an Enumerator that will yield the parse entries as it
       # walks backwards on the parse graph
-      def build_walker(aParseResult)
+      def build_walker(acceptingEntry, maxIndex)
         # Local context for the enumerator
-        parsing = aParseResult
-        ctx = init_context(aParseResult)
+        ctx = init_context(acceptingEntry, maxIndex)
 
         walker = Enumerator.new do |receiver| # 'receiver' is a Yielder
           # At this point: current entry == accepting entry
@@ -56,7 +55,7 @@ module Rley # This module is used as a namespace
               end
             end
 
-            result = jump_to_antecedent(ctx, parsing)
+            result = jump_to_antecedent(ctx)
             # Emit detection of scan edge if any...            
             receiver << result[0] if result.size > 1
             ctx.curr_entry = result.last
@@ -68,10 +67,10 @@ module Rley # This module is used as a namespace
 
 private
       # Context factory method
-      def init_context(aParseResult)
+      def init_context(acceptingEntry, maxIndex)
         context = ParseWalkerContext.new
-        context.entry_set_index = aParseResult.chart.last_index
-        context.curr_entry = aParseResult.accepting_entry
+        context.entry_set_index = maxIndex
+        context.curr_entry = acceptingEntry
         context.visitees = Set.new
         context.nterm2start = {}
         context.return_stack = []
@@ -125,12 +124,12 @@ private
       # Given the current entry from context object
       # Go to the parse entry that is one of its antecedent
       # The context object is updated
-      def jump_to_antecedent(aContext, aParseResult)
+      def jump_to_antecedent(aContext)
         entries = []
         return entries if aContext.curr_entry.orphan?
         
         if aContext.curr_entry.antecedents.size == 1
-          entries = antecedent_of(aContext, aParseResult)
+          entries = antecedent_of(aContext)
         else
           entries = select_antecedent(aContext)
         end
@@ -139,7 +138,7 @@ private
       end
 
       # Handle the case of an entry having one antecedent only
-      def antecedent_of(aContext, aParseResult)
+      def antecedent_of(aContext)
         new_entry = aContext.curr_entry.antecedents.first
         events = [new_entry]
         traversed_edge = new_entry.vertex.edges.first

data/spec/rley/parser/parse_forest_builder_spec.rb

@@ -45,12 +45,12 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       let(:walker) do
         factory = ParseWalkerFactory.new
-        factory.build_walker(sample_result)
+        accept_entry = sample_result.accepting_entry
+        accept_index = sample_result.chart.last_index
+        factory.build_walker(accept_entry, accept_index)
       end
 
-      subject do
-        ParseForestBuilder.new(sample_result)
-      end
+      subject { ParseForestBuilder.new(sample_tokens) }
 
       # Emit a text representation of the current path.
       def path_to_s()
@@ -60,12 +60,12 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
 
       context 'Initialization:' do
-        it 'should be created with a GFGParsing' do
-          expect { ParseForestBuilder.new(sample_result) }.not_to raise_error
+        it 'should be created with a sequence of tokens' do
+          expect { ParseForestBuilder.new(sample_tokens) }.not_to raise_error
         end
 
-        it 'should know the parse result' do
-          expect(subject.parsing).to eq(sample_result)
+        it 'should know the input tokens' do
+          expect(subject.tokens).to eq(sample_tokens)
         end
 
         it 'should have an empty path' do

data/spec/rley/parser/parse_forest_factory_spec.rb

@@ -62,19 +62,20 @@ module Rley # Open this namespace to avoid module qualifier prefixes
           expect(subject.parsing).to eq(sample_result)
         end
       end
-=begin      
+      
       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 '../sppf/forest_representation'           
           File.open("forest.yml", "w") { |f| YAML.dump(forest, f) }
           pen = ForestRepresentation.new
-          pen.generate_graph(forest, File.open("forest.dot", "w"))          
+          pen.generate_graph(forest, File.open("forest.dot", "w")) 
+=end          
         end        
-      end # context
-=end      
+      end # context      
     end # describe
   end # module
 end # module

data/spec/rley/parser/parse_walker_factory_spec.rb

@@ -63,8 +63,10 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         parser = Parser::GFGEarleyParser.new(sample_grammar)
         parser.parse(sample_tokens)
       end
-
-      let(:subject) { ParseWalkerFactory.new }
+      
+      let(:accept_entry) { sample_result.accepting_entry }
+      let(:accept_index) { sample_result.chart.last_index }
+      subject { ParseWalkerFactory.new }
 
 
       context 'Initialization:' do
@@ -75,18 +77,18 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       context 'Parse graph traversal:' do
         it 'should create an Enumerator as a walker' do
-          expect(subject.build_walker(sample_result)).to be_kind_of(Enumerator)
+          expect(subject.build_walker(accept_entry, accept_index)).to be_kind_of(Enumerator)
         end
 
         it 'should return the accepting parse entry in the first place' do
-          walker = subject.build_walker(sample_result)
+          walker = subject.build_walker(accept_entry, accept_index)
           first_event = walker.next
           expectations = [:visit, sample_result.accepting_entry, 4]
           event_expectations(first_event, expectations)
         end
 
         it 'should traverse the parse graph backwards' do
-          walker = subject.build_walker(sample_result)
+          walker = subject.build_walker(accept_entry, accept_index)
           event1 = walker.next
           expectations = [:visit, 'Phi. | 0', 4]
           event_expectations(event1, expectations)
@@ -222,7 +224,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         end
         
         it 'should raise an exception at end of visit' do
-          walker = subject.build_walker(sample_result)
+          walker = subject.build_walker(accept_entry, accept_index)
           32.times { walker.next }
           
           expect{ walker.next }.to raise_error(StopIteration)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rley
 version: !ruby/object:Gem::Version
-  version: 0.3.00
+  version: 0.3.01
 platform: ruby
 authors:
 - Dimitri Geshef
@@ -293,7 +293,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.6.7
 signing_key: 
 specification_version: 4
 summary: Ruby implementation of the Earley's parsing algorithm