rley 0.5.14 → 0.6.00

data/examples/general/calc_iter2/calc_lexer.rb

@@ -7,7 +7,7 @@ class CalcLexer
   attr_reader(:scanner)
   attr_reader(:lineno)
   attr_reader(:line_start)
-  attr_reader(:name2symbol)
+
 
   @@lexeme2name = {
     '(' => 'LPAREN',
@@ -30,9 +30,8 @@ class CalcLexer
 
   class ScanError < StandardError; end
 
-  def initialize(source, aGrammar)
+  def initialize(source)
     @scanner = StringScanner.new(source)
-    @name2symbol = aGrammar.name2symbol
     @lineno = 1
   end
 
@@ -78,8 +77,7 @@ class CalcLexer
   end
   
   def build_token(aSymbolName, aLexeme)
-    token_type = name2symbol[aSymbolName]
-    return Rley::Lexical::Token.new(aLexeme, token_type)    
+    return Rley::Lexical::Token.new(aLexeme, aSymbolName)    
   end
 
   def skip_whitespaces()

data/examples/general/calc_iter2/spec/calculator_spec.rb

@@ -1,5 +1,6 @@
 require 'rspec' # Use the RSpec framework
-require_relative '../calc_parser' # Load the class under test
+require_relative '../calc_lexer'
+require_relative '../calc_grammar'
 require_relative '../calc_ast_builder'
 
 RSpec.configure do |config|
@@ -9,10 +10,21 @@ end
 
 
 describe 'Calculator' do
-  def parse_expression(anExpression)
-    # Create a calculator parser object
-    parser = CalcParser.new
-    result = parser.parse_expression(anExpression)
+  def expect_expr(anExpression)
+    # Create a Rley facade object
+    engine = Rley::Engine.new do |cfg|
+      cfg.repr_builder = CalcASTBuilder
+    end
+    
+    engine.use_grammar(CalcGrammar)
+    raw_result = parse_expression(engine, anExpression)
+    ast = engine.to_ptree(raw_result)
+    return expect(ast.root.interpret)
+  end
+  
+  def parse_expression(anEngine, anExpression)
+    lexer = CalcLexer.new(anExpression)
+    result = anEngine.parse(lexer.tokens)
 
     unless result.success?
       # Stop if the parse failed...
@@ -24,31 +36,6 @@ describe 'Calculator' do
     return result
   end
 
-  def print_cst(aParseResult)
-    # Generate a parse tree from the parse result
-    ptree = aParseResult.parse_tree
-
-    # Let's create a parse tree visitor
-    visitor = Rley::ParseTreeVisitor.new(ptree)
-
-    # Now output formatted parse tree
-    renderer = Rley::Formatter::Asciitree.new($stdout)
-    renderer.render(visitor)
-  end
-
-  def build_ast(aParseResult)
-    tree_builder = CalcASTBuilder
-    # Generate an abstract syntax tree from the parse result
-    ast = aParseResult.parse_tree(tree_builder)
-    return ast.root
-  end
-
-  def expect_expr(anExpression)
-    parsing = parse_expression(anExpression)
-    ast = build_ast(parsing)
-    return expect(ast.interpret)
-  end
-
   context 'Parsing valid expressions' do
     it 'should evaluate simple integer literals' do
       expect_expr('2').to eq(2)
@@ -143,7 +130,7 @@ describe 'Calculator' do
     end
 
     it 'should handle nested exponentiations' do
-      expect_expr('2 ** 2**2)').to eq(16)
+      expect_expr('2 ** 2**2').to eq(16)
     end
 
     it 'should change sign of expression in parentheses' do

data/lib/rley.rb

@@ -6,11 +6,12 @@ require_relative './rley/constants'
 require_relative './rley/syntax/grammar_builder'
 require_relative './rley/lexical/token'
 require_relative './rley/parser/gfg_earley_parser'
-require_relative './rley/parser/parse_tree_builder'
+require_relative './rley/parse_rep/ast_base_builder'
 require_relative './rley/parse_tree_visitor'
 require_relative './rley/formatter/debug'
 require_relative './rley/formatter/json'
 require_relative './rley/formatter/asciitree'
 require_relative './rley/formatter/bracket_notation'
+require_relative './rley/engine'
 
 # 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.5.14'.freeze
+  Version = '0.6.00'.freeze
 
   # Brief description of the gem.
   Description = "Ruby implementation of the Earley's parsing algorithm".freeze

data/lib/rley/engine.rb

@@ -0,0 +1,122 @@
+require_relative './syntax/grammar_builder'
+require_relative './parser/gfg_earley_parser'
+require_relative './parse_rep/parse_tree_factory'
+
+module Rley # This module is used as a namespace
+  EngineConfig = Struct.new(
+    :parse_repr,
+    :repr_builder
+  ) do
+    def initialize()
+      super()
+      self.parse_repr = :parse_tree
+      self.repr_builder = :default
+    end
+  end
+
+  # Implementation of the GoF Facade design pattern.
+  # an Engine object provides a higher-level interface that shields
+  # Rley client code from the lower-level classes.
+  class Engine
+    attr_reader :configuration
+    attr_reader :grammar
+
+    # Constructor.
+    # @param &aBlock [Proc, Lambda] Code block for setting the configuration.
+    def initialize(&aConfigBlock)
+      @configuration = EngineConfig.new
+
+       yield configuration if block_given?
+    end
+
+    # Factory method.
+    # @param &aBlock [Proc, Lambda] Code block for creating the grammar.
+    def build_grammar(&aBlock)
+      builder = Rley::Syntax::GrammarBuilder.new(&aBlock)
+      @grammar = builder.grammar
+    end
+    
+    # Use the given grammar.
+    # @param aGrammar [Rley::Syntax::Grammar]
+    def use_grammar(aGrammar)
+      @grammar = aGrammar
+    end
+
+    # Parse the sequence of tokens produced by the given tokenizer object.
+    # @param aTokenizer [#each]
+    # @return [Parser::GFGParsing]
+    def parse(aTokenizer)
+      tokens = []
+      aTokenizer.each do |a_token|
+        if a_token
+          term_name = a_token.terminal
+          term_symb = grammar.name2symbol[term_name]
+          a_token.instance_variable_set(:@terminal, term_symb)
+          tokens << a_token
+        end
+      end
+      parser = build_parser(grammar)
+      return parser.parse(tokens)
+    end
+
+    # Convert raw parse result into a more convenient representation
+    # (parse tree or parse forest) as specified by the configuration.
+    # @param aRawParse [Parser::GFGParsing]
+    def convert(aRawParse)
+      result = case configuration.parse_repr
+                 when :parse_tree
+                   to_ptree(aRawParse)
+                 when :parse_forest
+                   to_pforest(aRawParse)
+               end
+
+      return result
+    end
+
+    # Convert raw parse result into a parse tree representation
+    # @param aRawParse [Parser::GFGParsing]
+    def to_ptree(aRawParse)
+      factory = ParseRep::ParseTreeFactory.new(aRawParse)
+      if configuration.repr_builder == :default
+        result = factory.create(nil)
+      else
+        result = factory.create(configuration.repr_builder)
+      end
+
+      return result
+    end
+
+    # Convert raw parse result into a parse forest representation
+    # @param aRawParse [Parser::GFGParsing]
+    # def to_pforest(aRawParse)
+      # factory = ParseRep::ParseForestFactory.new(aRawParse)
+      # if configuration.repr_builder == :default
+        # result = factory.create(nil)
+      # else
+        # result = factory.create(configuration.repr_builder)
+      # end
+
+      # return result
+    # end
+
+    # Build a visitor for the given parse tree
+    # @param aPTree[PTree::ParseTree]
+    # @return [ParseTreeVisitor]
+    def ptree_visitor(aPTree)
+      return Rley::ParseTreeVisitor.new(aPTree)
+    end
+
+    # @param aPTree[SPPF::ParseForest]
+    # @return [ParseForestVisitor]
+    # def pforest_visitor(aPForest)
+      # return Rley::ParseForestVisitor.new(aPForest)
+    # end
+
+    protected
+
+    def build_parser(aGrammar)
+      return Parser::GFGEarleyParser.new(aGrammar)
+    end
+  end # class
+end # module
+

data/lib/rley/parse_rep/ast_base_builder.rb

@@ -0,0 +1,128 @@
+require_relative '../ptree/parse_tree'
+require_relative 'parse_tree_builder'
+
+module Rley # This module is used as a namespace
+  module ParseRep # This module is used as a namespace
+    # Abstract class (to be subclassed).
+    # The purpose of an ASTBaseBuilder 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.
+    # It is an implementation of 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 ASTBaseBuilder < ParseTreeBuilder
+      # Method to override in subclass.
+      # Returns a Hash
+      # @return [Hash{String => Class}, Hash{String => Hash{String => Class}}]
+      #   Returned hash contains pairs of the form:
+      #   terminal name => Class implementing the terminal tokens
+      #   terminal name => Hash with pairs: rule name => Class
+      def terminal2node()
+        raise NotImplementedError
+      end
+      
+      # Method to override in subclass.
+      # Default class for representing terminal nodes.
+      # @return [Class]
+      def terminalnode_class()
+        PTree::TerminalNode
+      end
+      
+      # Default method name to invoke when production
+      # with given name is invoked.
+      # Override this method for other method naming convention.
+      # @param aProductionName [String]
+      # @return [String]
+      def method_name(aProductionName)
+        return 'reduce_' + aProductionName
+      end
+
+      # Utility method.
+      # Simply return the first child node
+      # @param _range [Lexical::TokenRange]
+      # @param _tokens [Array<Lexical::Token>]
+      # @param theChildren [Array<Object>]
+      def return_first_child(_range, _tokens, theChildren)
+        return theChildren[0]
+      end
+
+      # Utility method.
+      # Simply return the second child node
+      # @param _range [Lexical::TokenRange]
+      # @param _tokens [Array<Lexical::Token>]
+      # @param theChildren [Array<Object>]      
+      def return_second_child(_range, _tokens, theChildren)
+        return theChildren[1]
+      end
+
+      # Utility method.
+      # Simply return the last child node
+      # @param _range [Lexical::TokenRange]
+      # @param _tokens [Array<Lexical::Token>]
+      # @param theChildren [Array<Object>]      
+      def return_last_child(_range, _tokens, theChildren)
+        return theChildren[-1]
+      end
+
+      # Simply return an epsilon symbol
+      # @param _range [Lexical::TokenRange]
+      # @param _tokens [Array<Lexical::Token>]
+      # @param _hildren [Array<Object>]       
+      def return_epsilon(_range, _tokens, _children)
+        return nil
+      end
+      
+      protected
+     
+      # Overriding method.
+      # Create a parse tree object with given
+      # node as root node.
+      def create_tree(aRootNode)
+        return Rley::PTree::ParseTree.new(aRootNode)
+      end
+
+      # Factory method for creating a node object for the given
+      # input token.
+      # @param aTerminal [Syntax::Production] Relevant production rule
+      # @param aTerminal [Syntax::Terminal] Terminal symbol associated with the token
+      # @param aTokenPosition [Integer] Position of token in the input stream
+      # @param aToken [Lexical::Token] The input token
+      def new_leaf_node(aProduction, aTerminal, aTokenPosition, aToken)
+        klass = terminal2node.fetch(aTerminal.name, terminalnode_class)
+        if klass.is_a?(Hash)
+          # Lexical ambiguity...
+          klass = klass.fetch(aProduction.name)
+        end
+        node = klass.new(aToken, aTokenPosition)
+
+        return node
+      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)
+        mth_name = method_name(aProduction.name)
+        if self.respond_to?(mth_name, true)
+          node = send(mth_name, aProduction, aRange, theTokens, theChildren)
+        else
+          # Default action...
+          node = case aProduction.rhs.size
+                   when 0
+                     return_epsilon(aRange, theTokens, theChildren)
+                   when 1
+                     return_first_child(aRange, theTokens, theChildren)
+                   else
+                    raise StandardError, "Don't know production '#{aProduction.name}'"
+                 end            
+        end
+        return node
+      end
+    end # class
+  end # module
+end # module
+# End of file

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

@@ -4,7 +4,7 @@ require_relative '../ptree/terminal_node'
 require_relative '../ptree/parse_tree'
 
 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
     # The purpose of a CSTBuilder is to build piece by piece a CST
     # (Concrete Syntax Tree) from a sequence of input tokens and
     # visit events produced by walking over a GFGParsing object.

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

@@ -9,7 +9,7 @@ require_relative '../sppf/alternative_node'
 require_relative '../sppf/parse_forest'
 
 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
     # Builder GoF pattern. Builder pattern builds a complex object
     # (say, a parse forest) from simpler objects (terminal and non-terminal
     # nodes) and using a step by step approach.

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

@@ -2,7 +2,7 @@ require_relative 'parse_rep_creator'
 require_relative 'parse_forest_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 ParseForest from
     # a given Parsing object.
     class ParseForestFactory < ParseRepCreator
@@ -14,7 +14,7 @@ module Rley # This module is used as a namespace
         ParseForestBuilder.new(aParseResult.tokens)
       end
       
-      # When a end vertex is re-visited then jump
+      # When an end vertex is re-visited then jump
       # its corresponding start vertex. This behaviour
       # makes sense for sharing nodes.
       def jump_to_start()

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

@@ -1,7 +1,7 @@
-require_relative 'parse_walker_factory'
+require_relative '../parser/parse_walker_factory'
 
 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 representation of a parse from
     # a given Parsing object.
     class ParseRepCreator
@@ -39,7 +39,7 @@ module Rley # This module is used as a namespace
       # that will iterate over the relevant nodes (= parsing entries)
       # of a GFGParsing
       def walker(aParseResult)
-        walker_factory = ParseWalkerFactory.new
+        walker_factory = Parser::ParseWalkerFactory.new
         accept_entry = aParseResult.accepting_entry
         accept_index = aParseResult.chart.last_index
         walker_factory.build_walker(accept_entry, accept_index, jump_to_start)

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

@@ -9,7 +9,7 @@ require_relative '../ptree/terminal_node'
 require_relative '../ptree/parse_tree'
 
 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
     # Structure used internally by ParseTreeBuilder class.
     CSTRawNode = Struct.new(:range, :symbol, :children) do
       # Constructor.
@@ -55,11 +55,11 @@ module Rley # This module is used as a namespace
       # @param anIndex [anIndex] The token index associated with anEntry
       def receive_event(anEvent, anEntry, anIndex)
         # puts "Event: #{anEvent} #{anEntry} #{anIndex}"
-        if anEntry.dotted_entry? # A N => alpha . beta pattern?
+        if anEntry.dotted_entry? # N => alpha . beta pattern?
           process_item_entry(anEvent, anEntry, anIndex)
-        elsif anEntry.start_entry? # A .N pattern?
+        elsif anEntry.start_entry? # .N pattern?
           process_start_entry(anEvent, anEntry, anIndex)
-        elsif anEntry.end_entry? # A N. pattern?
+        elsif anEntry.end_entry? # N. pattern?
           process_end_entry(anEvent, anEntry, anIndex)
         else
           raise NotImplementedError