rley 0.5.14 → 0.6.00

data/lib/rley/{parser → parse_rep}/parse_tree_factory.rb

@@ -3,7 +3,7 @@ require_relative 'parse_rep_creator'
 require_relative 'cst_builder'
 
 module Rley # This module is used as a namespace
-  module Parser # This module is used as a namespace
+  module ParseRep # This module is used as a namespace
     # Utility class that helps to create a ParseTree from
     # a given Parsing object.
     class ParseTreeFactory < ParseRepCreator

data/lib/rley/parser/gfg_parsing.rb

@@ -1,8 +1,8 @@
 require_relative 'gfg_chart'
 require_relative 'error_reason'
 require_relative 'parse_entry_tracker'
-require_relative 'parse_forest_factory'
-require_relative 'parse_tree_factory'
+require_relative '../parse_rep/parse_forest_factory'
+require_relative '../parse_rep/parse_tree_factory'
 
 
 module Rley # This module is used as a namespace
@@ -177,7 +177,13 @@ module Rley # This module is used as a namespace
       # Factory method. Builds a ParseForest from the parse result.
       # @return [ParseForest]
       def parse_forest()
-        factory = ParseForestFactory.new(self)
+        msg = <<-END_MSG
+ Method Rley::Parser::GFGParsing.parse_forest is deprecated, call
+ Rley::Engine::to_pforest. It will be removed April 1st 
+ or version 0.6.1 (whichever is first)       
+END_MSG
+        # $stderr.puts(msg)      
+        factory = ParseRep::ParseForestFactory.new(self)
 
         return factory.create
       end
@@ -185,7 +191,13 @@ module Rley # This module is used as a namespace
       # Factory method. Builds a ParseTree from the parse result.
       # @return [ParseTree]
       def parse_tree(aBuilder = nil)
-        factory = ParseTreeFactory.new(self)
+        msg = <<-END_MSG
+Method Rley::Parser::GFGParsing.parse_tree is deprecated, call
+Rley::Engine::to_ptree. It will be removed April 1st 
+or version 0.6.1 (whichever is first)       
+END_MSG
+        $stderr.puts(msg)
+        factory = ParseRep::ParseTreeFactory.new(self)
 
         return factory.create(aBuilder)
       end      

data/spec/rley/engine_spec.rb

@@ -0,0 +1,127 @@
+require_relative '../spec_helper'
+
+
+require_relative '../../lib/rley/lexical/token'
+require_relative '../../lib/rley/parse_rep/cst_builder'
+require_relative '../../lib/rley/parse_tree_visitor'
+
+# Load the class under test
+require_relative '../../lib/rley/engine'
+
+module Rley # Open this namespace to avoid module qualifier prefixes
+  describe Engine do
+    subject { Engine.new }
+
+    context 'Creation and initialization:' do
+      it 'could be created without argument' do
+        expect { Engine.new }.not_to raise_error
+      end
+
+      it 'could be created with block argument' do
+        expect { Engine.new do |config|
+            config.parse_repr = :raw
+          end
+        }.not_to raise_error
+      end
+
+      it "shouldn't have a link to a grammar yet" do
+        expect(subject.grammar).to be_nil
+      end
+    end # context
+
+    context 'Grammar building:' do
+      it 'should build grammar' do
+        subject.build_grammar do
+          add_terminals('a', 'b', 'c')
+          add_production('S' => ['A'])
+          add_production('A' => %w[a A c])
+          add_production('A' => ['b'])
+        end
+
+        expect(subject.grammar).to be_kind_of(Rley::Syntax::Grammar)
+        expect(subject.grammar.rules.size).to eq(3)
+      end
+    end # context
+
+    class ABCTokenizer
+      # Constructor
+      def initialize(someText)
+        @input = someText.dup
+      end
+
+      def each()
+        lexemes = @input.scan(/\S/)
+        lexemes.each do |ch|
+          if ch =~ /[abc]/
+            yield Rley::Lexical::Token.new(ch, ch)
+          else
+             raise StandardError, "Invalid character #{ch}"
+          end
+        end
+      end
+    end # class
+
+    # Utility method. Ensure that the engine
+    # has the defnition of a sample grammar
+    def add_sample_grammar(anEngine)
+      anEngine.build_grammar do
+        add_terminals('a', 'b', 'c')
+        add_production('S' => ['A'])
+        add_production('A' => %w[a A c])
+        add_production('A' => ['b'])
+      end
+    end
+
+    context 'Parsing:' do
+      subject do
+        instance = Engine.new
+        add_sample_grammar(instance)
+        instance
+      end
+
+      it 'should parse a stream of tokens' do
+        sample_text = 'a a b c c'
+        tokenizer = ABCTokenizer.new(sample_text)
+        result = subject.parse(tokenizer)
+        expect(result).to be_success
+      end
+    end # context
+
+
+
+    context 'Parse tree manipulation:' do
+      subject do
+        instance = Engine.new
+        add_sample_grammar(instance)
+        instance
+      end
+      
+      let(:sample_tokenizer) do
+        sample_text = 'a a b c c'
+        ABCTokenizer.new(sample_text)      
+      end
+
+      it 'should build default parse trees' do
+        raw_result = subject.parse(sample_tokenizer)
+        ptree = subject.convert(raw_result)
+        expect(ptree).to be_kind_of(PTree::ParseTree)
+      end
+
+      it 'should build custom parse trees' do
+        # Cheating: we point to default tree builder (CST)
+        subject.configuration.repr_builder = ParseRep::CSTBuilder        
+        raw_result = subject.parse(sample_tokenizer)
+        ptree = subject.convert(raw_result)
+        expect(ptree).to be_kind_of(PTree::ParseTree)
+      end
+      
+      it 'should provide a parse visitor' do
+        raw_result = subject.parse(sample_tokenizer)
+        ptree = subject.to_ptree(raw_result)
+        visitor = subject.ptree_visitor(ptree)
+        expect(visitor).to be_kind_of(ParseTreeVisitor)
+      end    
+    end # context
+  end # describe
+end # module
+

data/spec/rley/formatter/asciitree_spec.rb

@@ -6,18 +6,20 @@ require_relative '../../../lib/rley/lexical/token'
 require_relative '../../../lib/rley/parser/gfg_earley_parser'
 require_relative '../../../lib/rley/ptree/parse_tree'
 require_relative '../../../lib/rley/parse_tree_visitor'
+require_relative '../../../lib/rley/engine'
 # 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
+        sandbox = Object.new
+        sandbox.extend(GrammarABCHelper)
+        builder = sandbox.grammar_abc_builder
         builder.grammar
       end
       
@@ -27,15 +29,9 @@ module Rley # Re-open the module to get rid of qualified names
       let(:c_) { grammar_abc.name2symbol['c'] }
       
       # Helper method that mimicks the output of a tokenizer
-      # for the language specified by gramma_abc
+      # for the language specified by grammar_abc
       let(:grm_abc_tokens1) do
-        [
-          Lexical::Token.new('a', a_),
-          Lexical::Token.new('a', a_),
-          Lexical::Token.new('b', b_),
-          Lexical::Token.new('c', c_),
-          Lexical::Token.new('c', c_)
-        ]
+        %w[a a b c c].map { |ch| Lexical::Token.new(ch, ch) }
       end
 
       # Factory method that builds a sample parse tree.
@@ -51,9 +47,11 @@ module Rley # Re-open the module to get rid of qualified names
       #    +- 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
+        engine = Rley::Engine.new
+        engine.use_grammar(grammar_abc)     
+        parse_result = engine.parse(grm_abc_tokens1)
+        ptree = engine.convert(parse_result)
+        ptree
       end
   
       let(:destination) { StringIO.new('', 'w') }

data/spec/rley/formatter/bracket_notation_spec.rb

@@ -6,18 +6,20 @@ require_relative '../../../lib/rley/lexical/token'
 require_relative '../../../lib/rley/parser/gfg_earley_parser'
 require_relative '../../../lib/rley/ptree/parse_tree'
 require_relative '../../../lib/rley/parse_tree_visitor'
+require_relative '../../../lib/rley/engine'
 # 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
+        sandbox = Object.new
+        sandbox.extend(GrammarABCHelper)
+        builder = sandbox.grammar_abc_builder
         builder.grammar
       end
       
@@ -27,15 +29,9 @@ module Rley # Re-open the module to get rid of qualified names
       let(:c_) { grammar_abc.name2symbol['c'] }
       
       # Helper method that mimicks the output of a tokenizer
-      # for the language specified by gramma_abc
+      # for the language specified by grammar_abc
       let(:grm_abc_tokens1) do
-        [
-          Lexical::Token.new('a', a_),
-          Lexical::Token.new('a', a_),
-          Lexical::Token.new('b', b_),
-          Lexical::Token.new('c', c_),
-          Lexical::Token.new('c', c_)
-        ]
+        %w[a a b c c].map { |ch| Lexical::Token.new(ch, ch) }
       end
 
       # Factory method that builds a sample parse tree.
@@ -51,9 +47,11 @@ module Rley # Re-open the module to get rid of qualified names
       #    +- 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
+        engine = Rley::Engine.new
+        engine.use_grammar(grammar_abc)     
+        parse_result = engine.parse(grm_abc_tokens1)
+        ptree = engine.convert(parse_result)
+        ptree   
       end
   
       let(:destination) { StringIO.new('', 'w') }

data/spec/rley/formatter/debug_spec.rb

@@ -6,18 +6,20 @@ require_relative '../../../lib/rley/lexical/token'
 require_relative '../../../lib/rley/parser/gfg_earley_parser'
 require_relative '../../../lib/rley/ptree/parse_tree'
 require_relative '../../../lib/rley/parse_tree_visitor'
+require_relative '../../../lib/rley/engine'
 # Load the class under test
 require_relative '../../../lib/rley/formatter/debug'
 
 module Rley # Re-open the module to get rid of qualified names
   module Formatter
     describe Debug do
-      include GrammarABCHelper # Mix-in module for grammar abc
 
-      # Factory method. Build a production with the given sequence
-      # of symbols as its rhs.
+    # Factory method. Build a production with the given sequence    
+    # of symbols as its rhs.
       let(:grammar_abc) do
-        builder = grammar_abc_builder
+        sandbox = Object.new
+        sandbox.extend(GrammarABCHelper)
+        builder = sandbox.grammar_abc_builder
         builder.grammar
       end
       
@@ -27,15 +29,9 @@ module Rley # Re-open the module to get rid of qualified names
       let(:c_) { grammar_abc.name2symbol['c'] }
       
       # Helper method that mimicks the output of a tokenizer
-      # for the language specified by gramma_abc
+      # for the language specified by grammar_abc
       let(:grm_abc_tokens1) do
-        [
-          Lexical::Token.new('a', a_),
-          Lexical::Token.new('a', a_),
-          Lexical::Token.new('b', b_),
-          Lexical::Token.new('c', c_),
-          Lexical::Token.new('c', c_)
-        ]
+        %w[a a b c c].map { |ch| Lexical::Token.new(ch, ch) }
       end
 
       # Factory method that builds a sample parse tree.
@@ -51,9 +47,11 @@ module Rley # Re-open the module to get rid of qualified names
       #    +- 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
+        engine = Rley::Engine.new
+        engine.use_grammar(grammar_abc)     
+        parse_result = engine.parse(grm_abc_tokens1)
+        ptree = engine.convert(parse_result)
+        ptree
       end
   
       let(:destination) { StringIO.new('', 'w') }

data/spec/rley/formatter/json_spec.rb

@@ -12,12 +12,12 @@ require_relative '../../../lib/rley/formatter/json'
 module Rley # Re-open the module to get rid of qualified names
   module Formatter
     describe Json do
-      include GrammarABCHelper # Mix-in module with builder 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
+        sandbox = Object.new
+        sandbox.extend(GrammarABCHelper)
+        builder = sandbox.grammar_abc_builder
         builder.grammar
       end
 
@@ -27,15 +27,9 @@ module Rley # Re-open the module to get rid of qualified names
       let(:c_) { grammar_abc.name2symbol['c'] }
 
       # Helper method that mimicks the output of a tokenizer
-      # for the language specified by gramma_abc
+      # for the language specified by grammar_abc
       let(:grm_abc_tokens1) do
-        [
-          Lexical::Token.new('a', a_),
-          Lexical::Token.new('a', a_),
-          Lexical::Token.new('b', b_),
-          Lexical::Token.new('c', c_),
-          Lexical::Token.new('c', c_)
-        ]
+        %w[a a b c c].map { |ch| Lexical::Token.new(ch, ch) }
       end
 
       # Factory method that builds a sample parse tree.
@@ -51,9 +45,11 @@ module Rley # Re-open the module to get rid of qualified names
       #    +- 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
+        engine = Rley::Engine.new
+        engine.use_grammar(grammar_abc)     
+        parse_result = engine.parse(grm_abc_tokens1)
+        ptree = engine.convert(parse_result)
+        ptree
       end
 
       let(:destination) { StringIO.new('', 'w') }

data/spec/rley/{parser → parse_rep}/ambiguous_parse_spec.rb

@@ -8,10 +8,10 @@ require_relative '../support/expectation_helper'
 require_relative '../support/grammar_ambig01_helper'
 
 # Load the class under test
-require_relative '../../../lib/rley/parser/parse_forest_builder'
+require_relative '../../../lib/rley/parse_rep/parse_forest_builder'
 
 module Rley # Open this namespace to avoid module qualifier prefixes
-  module Parser
+  module ParseRep
     describe 'Coping with ambiguous grammar' do
       include GrammarHelper     # Mix-in with token factory method
       include ExpectationHelper # Mix-in with expectation on parse entry sets
@@ -45,7 +45,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
       end
 
       before(:each) do
-        factory = ParseWalkerFactory.new
+        factory = Parser::ParseWalkerFactory.new
         accept_entry = sentence_result.accepting_entry
         accept_index = sentence_result.chart.last_index
         @walker = factory.build_walker(accept_entry, accept_index, true)

data/spec/rley/{parser → parse_rep}/ast_builder_spec.rb

@@ -2,7 +2,8 @@ require_relative '../../spec_helper'
 
 require_relative '../../../lib/rley/parser/gfg_earley_parser'
 require_relative '../../../lib/rley/parser/parse_walker_factory'
-require_relative '../../../lib/rley/parser/parse_tree_builder'
+# require_relative '../../../lib/rley/parser/parse_tree_builder'
+require_relative '../../../lib/rley/parse_rep/ast_base_builder'
 require_relative '../../../lib/rley/ptree/parse_tree'
 
 require_relative '../support/expectation_helper'
@@ -11,7 +12,7 @@ require_relative '../support/grammar_arr_int_helper'
 
 
 module Rley # This module is used as a namespace
-  module Parser # This module is used as a namespace
+  module ParseRep # This module is used as a namespace
     ArrayNode = Struct.new(:children) do
       def initialize()
         super
@@ -24,9 +25,9 @@ module Rley # This module is used as a namespace
     end
 
     IntegerNode = Struct.new(:value, :position) do
-      def initialize(integerLiteral, aPosition)
+      def initialize(integerToken, aPosition)
         super
-        self.value = integerLiteral.to_i
+        self.value = integerToken.lexeme.to_i
         self.position = aPosition
       end
 
@@ -35,93 +36,43 @@ module Rley # This module is used as a namespace
       end
     end
 
-    # The purpose of a ASTBuilder is to build piece by piece an AST
-    # (Abstract Syntax Tree) from a sequence of input tokens and
-    # visit events produced by walking over a GFGParsing object.
-    # Uses the Builder GoF pattern.
-    # The Builder pattern creates a complex object
-    # (say, a parse tree) from simpler objects (terminal and non-terminal
-    # nodes) and using a step by step approach.
-    class ASTBuilder < ParseTreeBuilder
-      protected
-
-      # Method to override
-      # Create a parse tree object with given
-      # node as root node.
-      def create_tree(aRootNode)
-        return Rley::PTree::ParseTree.new(aRootNode)
-      end
-
-      # Method to override
-      # Factory method for creating a node object for the given
-      # input token.
-      # @param terminal [Terminal] Terminal symbol associated with the token
-      # @param aTokenPosition [Integer] Position of token in the input stream
-      # @param aToken [Token] The input token
-      def new_leaf_node(_production, terminal, aTokenPosition, aToken)
-        if terminal.name == 'integer'
-          IntegerNode.new(aToken.lexeme, aTokenPosition)
-        else
-          PTree::TerminalNode.new(aToken, aTokenPosition)
-        end
-      end
-
-      # Method to override.
-      # Factory method for creating a parent node object.
-      # @param aProduction [Production] Production rule
-      # @param aRange [Range] Range of tokens matched by the rule
-      # @param theTokens [Array] The input tokens
-      # @param theChildren [Array] Children nodes (one per rhs symbol)
-      def new_parent_node(aProduction, aRange, theTokens, theChildren)
-        node = case aProduction.name
-                 when 'P_0'
-                   reduce_P_0(aRange, theTokens, theChildren)
-
-                 when 'arr_0'
-                   reduce_arr_0(aRange, theTokens, theChildren)
-
-                 when 'sequence_0'
-                   reduce_sequence_0(aRange, theTokens, theChildren)
-
-                 when 'sequence_1'
-                   reduce_sequence_1(aRange, theTokens, theChildren)
-
-                 when 'list_0'
-                   reduce_list_0(aRange, theTokens, theChildren)
+    class ASTBuilder < ASTBaseBuilder
+      Terminal2NodeClass = {
+        'integer' => IntegerNode
+      }.freeze
 
-                 when 'list_1'
-                   reduce_list_1(aRange, theTokens, theChildren)
-                 else
-                  err_msg = "Don't know production #{aProduction.name}"
-                  raise StandardError, err_msg
-               end
-
-        return node
+      def terminal2node()
+        Terminal2NodeClass
       end
 
-      def reduce_P_0(_range, _tokens, theChildren)
-        return theChildren[0]
+      def reduce_P_0(_aProd, _range, _tokens, theChildren)
+        return_first_child(_range, _tokens, theChildren)
       end
 
-      def reduce_arr_0(_range, _tokens, theChildren)
+      # rule 'arr' => %w([ sequence ])
+      def reduce_arr_0(_aProd, _range, _tokens, theChildren)
         return theChildren[1]
       end
 
-      def reduce_sequence_0(_range, _tokens, theChildren)
-        return theChildren[0]
+      # rule 'sequence' => ['list']
+      def reduce_sequence_0(_aProd, _range, _tokens, theChildren)
+        return_first_child(_range, _tokens, theChildren)
       end
 
-      def reduce_sequence_1(_range, _tokens, _children)
+      # rule 'sequence' => []
+      def reduce_sequence_1(_aProd, _range, _tokens, _children)
         return ArrayNode.new
       end
 
-      def reduce_list_0(_range, _tokens, theChildren)
+      # rule 'list' => %w[list , integer]
+      def reduce_list_0(_aProd, _range, _tokens, theChildren)
         node = theChildren[0]
         node.children << theChildren[2]
         return node
       end
 
-      def reduce_list_1(_range, _tokens, theChildren)
+      # rule 'list' => 'integer'
+      def reduce_list_1(_aProd, _range, _tokens, theChildren)
         node = ArrayNode.new
         node.children << theChildren[0]
         return node
@@ -132,7 +83,7 @@ end # module
 
 
 module Rley # Open this namespace to avoid module qualifier prefixes
-  module Parser
+  module ParseRep
     describe ASTBuilder do
       include ExpectationHelper # Mix-in with expectation on parse entry sets
       include GrammarArrIntHelper # Mix-in for array of integers language
@@ -150,7 +101,7 @@ module Rley # Open this namespace to avoid module qualifier prefixes
 
       def init_walker(theParser, theTokens)
         result = theParser.parse(theTokens)
-        factory = ParseWalkerFactory.new
+        factory = Parser::ParseWalkerFactory.new
         accept_entry = result.accepting_entry
         accept_index = result.chart.last_index
         @walker = factory.build_walker(accept_entry, accept_index)
@@ -236,15 +187,15 @@ module Rley # Open this namespace to avoid module qualifier prefixes
         # Event: visit P => . arr | 0 0
         # Event: visit .P | 0 0
 
-        it 'should accept a first visit event' do
-          stack = get_stack(subject)
+        # it 'should accept a first visit event' do
+          # stack = get_stack(subject)
 
-          next_event('visit P. | 0 7')
-          expect(stack.size).to eq(1)
-          # stack: [P[0, 7]]
-          expect(stack.last.range).to eq(create_range(0, 7))
-          expect(stack.last.children).to be_nil
-        end
+          # next_event('visit P. | 0 7')
+          # expect(stack.size).to eq(1)
+          # # stack: [P[0, 7]]
+          # expect(stack.last.range).to eq(create_range(0, 7))
+          # expect(stack.last.children).to be_nil
+        # end
 
         it 'should build a tree for an empty array' do
           stack = get_stack(subject)