rley 0.5.02 → 0.5.03

data/spec/spec_helper.rb

@@ -6,10 +6,12 @@ require 'coveralls'
 
 Coveralls.wear!
 
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new([
-  SimpleCov::Formatter::HTMLFormatter,
-  Coveralls::SimpleCov::Formatter
-])
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new(
+  [
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+  ]
+)
 
 require 'pp'    # Use pretty-print for debugging purposes
 require 'rspec' # Use the RSpec framework
@@ -25,5 +27,4 @@ RSpec.configure do |config|
   config.full_backtrace = true
 end
 
-
 # End of file

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rley
 version: !ruby/object:Gem::Version
-  version: 0.5.02
+  version: 0.5.03
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-08 00:00:00.000000000 Z
+date: 2017-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: coveralls
@@ -146,12 +146,6 @@ files:
 - examples/general/calc_iter1/calc_lexer.rb
 - examples/general/calc_iter1/calc_parser.rb
 - examples/general/calc_iter1/spec/calculator_spec.rb
-- examples/general/calc_iter2/calc_ast_builder.rb
-- examples/general/calc_iter2/calc_ast_nodes.rb
-- examples/general/calc_iter2/calc_demo.rb
-- examples/general/calc_iter2/calc_grammar.rb
-- examples/general/calc_iter2/calc_lexer.rb
-- examples/general/calc_iter2/calc_parser.rb
 - lib/rley.rb
 - lib/rley/constants.rb
 - lib/rley/formatter/asciitree.rb

data/examples/general/calc_iter2/calc_ast_builder.rb

@@ -1,186 +0,0 @@
-require_relative 'calc_ast_nodes'
-
-# The purpose of a CalcASTBuilder 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 CalcASTBuilder < Rley::Parser::ParseTreeBuilder
-  Terminal2NodeClass = {
-    # Plus sign character is ambiguous. It can represent an operator 
-    # or a positive value
-    '+' => { 'add_operator[0]' => CalcAddNode, 'sign[0]' => PTree::TerminalNode },
-    # Minus sign character is ambiguous. It can represent an operator 
-    # or a negative value
-    '-' => { 'add_operator[1]' => CalcSubtractNode, 'sign[1]' => CalcNegateNode },
-    '*' => CalcMultiplyNode,
-    '/' => CalcDivideNode,
-    'number' => CalcNumberNode
-  }
-
-  protected
-
-  def return_first_child(_range, _tokens, theChildren)
-    return theChildren[0]
-  end
-
-  def return_second_child(_range, _tokens, theChildren)
-    return theChildren[1]
-  end
-
-  def return_last_child(_range, _tokens, theChildren)
-    return theChildren[-1]
-  end
-
-  # Overriding method.
-  # Create a parse tree object with given
-  # node as root node.
-  def create_tree(aRootNode)
-    return Rley::PTree::ParseTree.new(aRootNode)
-  end
-
-  # Overriding method.
-  # Factory method for creating a node object for the given
-  # input token.
-  # @param aTerminal [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(aProduction, aTerminal, aTokenPosition, aToken)
-    klass = Terminal2NodeClass.fetch(aTerminal.name, CalcTerminalNode)
-    klass = klass[aProduction.name] if klass.is_a?(Hash) # Lexical ambiguity
-    return klass.new(aToken, aTokenPosition)
-  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 'expression[0]' # rule 'expression' => %w[sign simple_expression]
-        reduce_expression_0(aProduction, aRange, theTokens, theChildren)
-
-      # when /value\[\d\]/
-        # return_first_child(aRange, theTokens, theChildren)
-
-      # when 'object[0]'
-        # reduce_object_0(aProduction, aRange, theTokens, theChildren)
-
-      # when 'object[1]'
-        # reduce_object_1(aRange, theTokens, theChildren)
-
-      # when 'member-list[0]'
-        # reduce_member_list_0(aRange, theTokens, theChildren)
-
-      # when 'member-list[1]'
-        # reduce_member_list_1(aProduction, aRange, theTokens, theChildren)
-
-      # when 'member[0]'
-        # reduce_member_0(aProduction, aRange, theTokens, theChildren)
-
-      # when 'array[0]'
-        # reduce_array_0(aProduction, aRange, theTokens, theChildren)
-
-      # when 'array[1]'
-        # reduce_array_1(aRange, theTokens, theChildren)
-
-      # when 'array-items[0]'
-        # reduce_array_items_0(aRange, theTokens, theChildren)
-
-      when 'sign[0]' # rule 'sign' => 'PLUS'
-        return_first_child(aRange, theTokens, theChildren)
-
-      when 'sign[1]' # rule 'sign' => 'MINUS'
-        return_first_child(aRange, theTokens, theChildren)
-
-      when 'sign[2]' #rule 'sign' => []
-        reduce_sign_2(aProduction, aRange, theTokens, theChildren)
-      else
-        raise StandardError, "Don't know production #{aProduction.name}"
-    end
-
-    return node
-  end
-
-  # rule 'expression' => %w[sign simple_expression]
-  def reduce_expression_0(aProduction, aRange, theTokens, theChildren)
-    sign = theChildren[0]
-    # Check type of sign
-    node = if sign && sign.kind_of?(CalcNegateNode)
-      sign.members << theChildren.last
-    else
-      theChildren.last
-    end
-
-    return node
-  end
-
-  # rule 'sign' => []
-  def reduce_sign_2(aProduction, aRange, theTokens, theChildren)
-    return nil # TODO; check whether this make sense
-  end
-=begin
-    second_child = theChildren[1]
-    second_child.symbol = aProduction.lhs
-    return second_child
-  end
-
-  # rule 'object' => %w[begin-object end-object]
-  def reduce_object_1(aRange, theTokens, theChildren)
-    return CalcObjectNode.new(aProduction.lhs)
-  end
-
-  # rule 'member-list' => %w[member-list value-separator member]
-  def reduce_member_list_0(aRange, theTokens, theChildren)
-    node = theChildren[0]
-    node.members << theChildren.last
-    return node
-  end
-
-  # rule 'member-list' => 'member'
-  def reduce_member_list_1(aProduction, aRange, theTokens, theChildren)
-    node = CalcObjectNode.new(aProduction.lhs)
-    node.members << theChildren[0]
-    return node
-  end
-
-  # rule 'member' => %w[string name-separator value]
-  def reduce_member_0(aProduction, aRange, theTokens, theChildren)
-    return CalcPair.new(theChildren[0], theChildren[2], aProduction.lhs)
-  end
-
-  # rule 'object' => %w[begin-object member-list end-object]
-  def reduce_array_0(aProduction, aRange, theTokens, theChildren)
-    second_child = theChildren[1]
-    second_child.symbol = aProduction.lhs
-    return second_child
-  end
-
-
-  # rule 'array' => %w[begin-array end-array]
-  def reduce_array_1(aRange, theTokens, theChildren)
-    return CalcArrayNode.new
-  end
-
-  # rule 'array-items' => %w[array-items value-separator value]
-  def reduce_array_items_0(aRange, theTokens, theChildren)
-    node = theChildren[0]
-    node.children << theChildren[2]
-    return node
-  end
-
-
-
-  #   rule 'array-items' => %w[value]
-  def reduce_array_items_1(aProduction, aRange, theTokens, theChildren)
-    node = CalcArrayNode.new(aProduction.lhs)
-    node.children << theChildren[0]
-    return node
-  end
-=end
-end # class

data/examples/general/calc_iter2/calc_ast_nodes.rb

@@ -1,151 +0,0 @@
-# Classes that implement nodes of Abstract Syntax Trees (AST) representing
-# calculator parse results.
-
-
-CalcTerminalNode = Struct.new(:token, :value, :position) do
-  def initialize(aToken, aPosition)
-    self.token = aToken
-    self.position = aPosition
-    init_value(aToken.lexeme)
-  end
-
-  # This method can be overriden
-  def init_value(aLiteral)
-    self.value = aLiteral.dup
-  end
-
-  def symbol()
-    self.token.terminal
-  end
-
-  def to_ruby()
-    return value
-  end
-  
-  # Part of the 'visitee' role in Visitor design pattern.
-  # @param aVisitor[ParseTreeVisitor] the visitor
-  def accept(aVisitor)
-    aVisitor.visit_terminal(self)
-  end  
-end
-
-class CalcNumberNode  < CalcTerminalNode
-  def init_value(aLiteral)
-    case aLiteral
-      when /^[+-]?\d+$/
-        self.value = aLiteral.to_i
-
-      when /^[+-]?\d+(\.\d+)?([eE][+-]?\d+)?$/
-        self.value = aLiteral.to_f
-    end
-  end
-end
-
-class CalcCompositeNode
-  attr_accessor(:children)
-  attr_accessor(:symbol)
-
-  def initialize(aSymbol)
-    @symbol = aSymbol
-    @children = []    
-  end
-
-  # Part of the 'visitee' role in Visitor design pattern.
-  # @param aVisitor[ParseTreeVisitor] the visitor
-  def accept(aVisitor)
-    aVisitor.visit_nonterminal(self)
-  end
-  
-  alias subnodes children
-
-end # class
-
-class CalcUnaryOpNode < CalcCompositeNode
-  def initialize(aSymbol)
-    super(aSymbol)
-  end
-
-  # Convert this tree node in a simpler Ruby representation.
-  # Basically a Calc object corresponds to a Ruhy Hash
-  def to_ruby()
-    rep = {}
-    members.each do |pair|
-      rep[pair.name.to_ruby] = pair.value.to_ruby
-    end
-
-    return rep
-  end
-
-  alias members children
-end # class
-
-class CalcNegateNode CalcUnaryOpNode
-end # class
-
-class CalcBinaryOpNode < CalcCompositeNode
-  def initialize(aSymbol)
-    super(aSymbol)
-  end
-
-end # class
-
-class CalcAddNode < CalcBinaryOpNode
-
-  # Convert this tree node in a simpler Ruby representation.
-  # Basically a Calc object corresponds to a Ruhy Hash
-  def to_ruby()
-    rep = []
-    children.each do |child|
-      rep << child.to_ruby
-    end
-
-    return rep
-  end
-end # class
-
-
-class CalcSubtractNode < CalcBinaryOpNode
-
-  # Convert this tree node in a simpler Ruby representation.
-  # Basically a Calc object corresponds to a Ruhy Hash
-  def to_ruby()
-    rep = []
-    children.each do |child|
-      rep << child.to_ruby
-    end
-
-    return rep
-  end
-end # class
-
-class CalcMultiplyNode < CalcBinaryOpNode
-
-  # Convert this tree node in a simpler Ruby representation.
-  # Basically a Calc object corresponds to a Ruhy Hash
-  def to_ruby()
-    rep = []
-    children.each do |child|
-      rep << child.to_ruby
-    end
-
-    return rep
-  end
-end # class
-
-class CalcDivideNode < CalcBinaryOpNode
-
-  # Convert this tree node in a simpler Ruby representation.
-  # Basically a Calc object corresponds to a Ruhy Hash
-  def to_ruby()
-    rep = []
-    children.each do |child|
-      rep << child.to_ruby
-    end
-
-    return rep
-  end
-end # class
-
-
-
-

data/examples/general/calc_iter2/calc_demo.rb

@@ -1,40 +0,0 @@
-require_relative 'calc_parser'
-
-# Create a calculator parser object
-parser = CalcParser.new
-
-# Parse the input expression in command-line
-if ARGV.empty?
-  my_name = File.basename(__FILE__)
-  msg = <<-END_MSG
-Command-line symtax:
-  ruby #{my_name} "arithmetic expression"
-  where:
-    the arithmetic expression is enclosed between double quotes (")
-
-  Example:
-  ruby #{my_name} "2 * 3 + (4 - 1)"
-END_MSG
-  puts msg
-  exit(1)
-end
-puts ARGV[0]
-result = parser.parse_expression(ARGV[0])
-
-unless result.success?
-  # Stop if the parse failed...
-  puts "Parsing of '#{ARGV[0]}' failed"
-  puts "Reason: #{result.failure_reason.message}"
-  exit(1)
-end
-
-# Generate a parse tree from the parse result
-ptree = result.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 of file

data/examples/general/calc_iter2/calc_grammar.rb

@@ -1,28 +0,0 @@
-# Grammar for simple arithmetical expressions
-require 'rley' # Load the gem
-
-########################################
-# Define a grammar for basic arithmetical expressions
-builder = Rley::Syntax::GrammarBuilder.new do
-  add_terminals('NUMBER')
-  add_terminals('LPAREN', 'RPAREN') # For '(', ')' delimiters
-  add_terminals('PLUS', 'MINUS') # For '+', '-' operators or sign
-  add_terminals('STAR', 'DIVIDE') # For '*', '/' operators
-  rule 'expression' => %w[sign simple_expression]
-  rule 'simple_expression' => 'term'
-  rule 'simple_expression' => %w[simple_expression add_operator term]
-  rule 'term' => 'factor'
-  rule 'term' => %w[term mul_operator factor]
-  rule 'factor' => 'NUMBER'
-  rule 'factor' => %w[LPAREN expression RPAREN]
-  rule 'sign' => 'PLUS'
-  rule 'sign' => 'MINUS'
-  rule 'sign' => []
-  rule 'add_operator' => 'PLUS'
-  rule 'add_operator' => 'MINUS'  
-  rule 'mul_operator' => 'STAR'
-  rule 'mul_operator' => 'DIVIDE'   
-end
-
-# And now build the grammar...
-CalcGrammar = builder.grammar