loxxy 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de9d3c24db15863c6ea99c2a9c8a2e413b2a243ddf79de28da5583d1944fc4e4
-  data.tar.gz: a5f6dacfd67b6833e3c051273765e1d94c95d1d1700a974a09a3caf0519a1570
+  metadata.gz: d1b591e9ed6ae88b4b4232c01c4f08fd4453fb499a665c368cd64ce2135a6718
+  data.tar.gz: 6bc1f01f9f0a963a2781271c46391e2c2801b61cc1b076e0b79be30450bee2af
 SHA512:
-  metadata.gz: 3c4bd62b1a9cd960ee97d807a5f44a26cc360df4344975210ca967117c62585a2138fef382ffb5ea7d79f002b9a9a951ba77622cb8d799973c0ad8a24ffbae52
-  data.tar.gz: 5b14b5c4a6ae98f5e1d9a819160393393654cc3d817e36f1da68cd12fcfedfbce47097463dc6babcf36b5582e970ea41b4cef5ebceb768b962c8bd7b02bcb553
+  metadata.gz: 5dd208921fc139eb5f48b182abbe64b919c514904dfab073b09c4a9656989db5c95a5e1bd6f72733a46af8351dc6f95ab94612d8016c22e13dbcedd4637db90b
+  data.tar.gz: 63ac04a1cd79335daf5dbb38de2615e89044c49ec74fd174200149ef24d829861c3af0e7bf62862cbffc03940b955a6c9336344696d432e4efaa83d2dc1e9d35

data/.rubocop.yml

@@ -170,6 +170,9 @@ Naming/BlockParameterName:
 
 Naming/MethodParameterName:
   Enabled: false
+  
+Naming/MethodName:
+  Enabled: false
 
 Naming/VariableName:
   Enabled: false

data/CHANGELOG.md

@@ -1,3 +1,19 @@
+## [0.0.7] - 2021-01-06
+- Lox grammar reworked, initial AST classes created.
+
+## Added
+- Class `Parser` this one generates AST's (Abstract Syntax Tree)
+- Class `AST::ASTVisitor` draft initial implementation.
+- Class `AST::BinaryExpr` draft initial implementation.
+- Class `AST::LoxCompoundExpr` draft initial implementation.
+- Class `AST::LiteralExpr` draft initial implementation.
+- Class `AST::LoxNode` draft initial implementation.
+
+## Changed
+- File `spec_helper.rb`: removed Bundler dependency
+- Class `AST::ASTBuilder` added initial `reduce_` methods.
+- File `README.md` Removed example with AST generation since this is in flux.
+
 ## [0.0.6] - 2021-01-03
 - First iteration of a parser with AST generation.
 

data/README.md

@@ -1,7 +1,7 @@
 # Loxxy
 
-A Ruby implementation of the [Lox programming language](https://craftinginterpreters.com/the-lox-language.html),
-a simple language used in Bob Nystrom's online book [Crafting Interpreters](https://craftinginterpreters.com/).
+A Ruby implementation of the [Lox programming language](https://craftinginterpreters.com/the-lox-language.html ),
+a simple language used in Bob Nystrom's online book [Crafting Interpreters](https://craftinginterpreters.com/ ).
 
 ## Purpose of this project:
 - To deliver an open source example of a programming language fully implemented in Ruby  
@@ -14,7 +14,7 @@ a simple language used in Bob Nystrom's online book [Crafting Interpreters](http
 - [DONE] Raw parser. It parses Lox programs and generates a parse tree.
 - [DONE] Tailored parser for generating AST (Abstract Syntax Tree)
 - [STARTED] Custom AST builder class  
-- [TODO] Hierarchy classes for representing Lox expressions in AST  
+- [STARTED] Hierarchy classes for representing Lox expressions in AST  
 - [TODO] Interpreter or transpiler
 
 ## Example
@@ -48,8 +48,7 @@ tree_formatter.render(visitor)
 This is the output produced by the above example:
 ```
 program
-+-- declaration_star
-|   +-- declaration_star
++-- declaration_plus
 |   +-- declaration
 |       +-- statement
 |           +-- printStmt
@@ -58,69 +57,18 @@ program
 |               |   +-- assignment
 |               |       +-- logic_or
 |               |           +-- logic_and
-|               |           |   +-- equality
-|               |           |   |   +-- comparison
-|               |           |   |   |   +-- term
-|               |           |   |   |   |   +-- factor
-|               |           |   |   |   |   |   +-- unary
-|               |           |   |   |   |   |   |   +-- call
-|               |           |   |   |   |   |   |       +-- primary
-|               |           |   |   |   |   |   |       |   +-- STRING: '"Hello, world!"'
-|               |           |   |   |   |   |   |       +-- refinement_star
-|               |           |   |   |   |   |   +-- multiplicative_star
-|               |           |   |   |   |   +-- additive_star
-|               |           |   |   |   +-- comparisonTest_star
-|               |           |   |   +-- equalityTest_star
-|               |           |   +-- conjunct_star
-|               |           +-- disjunct_star
+|               |               +-- equality
+|               |                   +-- comparison
+|               |                       +-- term
+|               |                           +-- factor
+|               |                               +-- unary
+|               |                                   +-- call
+|               |                                       +-- primary
+|               |                                           +-- STRING: '"Hello, world!"'
 |               +-- SEMICOLON: ';'
 +-- EOF: ''
 ```
 
-### Example using Parser class
-Except for the `Parser` class name, this example is identical 
-to the previous one.
-
-```ruby
-require 'loxxy'
-
-
-lox_input = <<-LOX_END
-  // Your first Lox program!
-  print "Hello, world!";
-LOX_END
-
-# Show that the parser accepts the above program
-parser = Loxxy::FrontEnd::Parser.new
-
-# Now parse the input into an abstract parse tree...
-ptree = parser.parse(lox_input)
-
-# Display the parse tree thanks to Rley utility classes...
-visitor = Rley::ParseTreeVisitor.new(ptree)
-tree_formatter = Rley::Formatter::Asciitree.new($stdout)
-tree_formatter.render(visitor)
-```
-
-However the output differs significantly:
-```
-program
-+-- declaration_star
-|   +-- printStmt
-|       +-- PRINT: 'print'
-|       +-- logic_or
-|       |   +-- logic_and
-|       |       +-- equality
-|       |           +-- comparison
-|       |               +-- term
-|       |                   +-- factor
-|       |                       +-- call
-|       |                           +-- STRING: '"Hello, world!"'
-|       +-- SEMICOLON: ';'
-+-- EOF: ''
-```
-
-
 
 ## Installation
 

data/lib/loxxy/ast/ast_builder.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require_relative '../datatype/all_datatypes'
+require_relative 'lox_literal_expr'
+require_relative 'lox_binary_expr'
 
 module Loxxy
   module Ast
@@ -69,6 +71,27 @@ module Loxxy
 
         node
       end
+
+      # rule('additive_star' => 'additive_star additionOp factor').as 'additionOp_expr'
+      def reduce_additionOp_expr(_production, _range, _tokens, theChildren)
+        (operand1, operator_node, operand2) = theChildren
+        operator = operator_node.symbol.name == 'MINUS' ? :- : :+
+        LoxBinaryExpr.new(operator_node.token.position, operator, operand1, operand2)
+      end
+
+      # rule('multiplicative_star' => 'multiplicative_star multOp unary').as 'multOp_expr'
+      # def reduce_multOp_expr(_production, _range, _tokens, theChildren)
+      #   (operand1, operator, operand2) = theChildren
+      #   LoxBinaryExpr.new(operator.token.position, operator, operand1, operand2)
+      # end
+
+      # rule('primary' => 'FALSE' | TRUE').as 'literal_expr'
+      def reduce_literal_expr(_production, _range, _tokens, theChildren)
+        first_child = theChildren.first
+        pos = first_child.token.position
+        literal = first_child.token.value
+        LoxLiteralExpr.new(pos, literal)
+      end
     end # class
   end # module
 end # module

data/lib/loxxy/ast/ast_visitor.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Loxxy
+  module Ast
+    class ASTVisitor
+      # Link to the top node to visit
+      attr_reader(:top)
+
+      # List of objects that subscribed to the visit event notification.
+      attr_reader(:subscribers)
+
+      # attr_reader(:runtime)
+
+      # Build a visitor for the given top.
+      # @param aRoot [AST::LoxNode] the parse tree to visit.
+      def initialize(aTop)
+        raise StandardError if aTop.nil?
+
+        @top = aTop
+        @subscribers = []
+      end
+
+      # Add a subscriber for the visit event notifications.
+      # @param aSubscriber [Object]
+      def subscribe(aSubscriber)
+        subscribers << aSubscriber
+      end
+
+      # Remove the given object from the subscription list.
+      # The object won't be notified of visit events.
+      # @param aSubscriber [Object]
+      def unsubscribe(aSubscriber)
+        subscribers.delete_if { |entry| entry == aSubscriber }
+      end
+
+      # The signal to begin the visit of the top.
+      def start # (aRuntime)
+        # @runtime = aRuntime
+        top.accept(self)
+      end
+
+      # Visit event. The visitor is visiting the
+      # given terminal node containing a datatype object.
+      # @param aLiteralExpr [AST::LoxLiteralExpr] the leaf node to visit.
+      def visit_literal_expr(aLiteralExpr)
+        broadcast(:before_literal_expr, aLiteralExpr)
+        broadcast(:after_literal_expr, aLiteralExpr)
+      end
+
+=begin
+
+
+      def visit_compound_datum(aCompoundDatum)
+        broadcast(:before_compound_datum, aCompoundDatum)
+        traverse_children(aCompoundDatum)
+        broadcast(:after_compound_datum, aCompoundDatum)
+      end
+
+      # Visit event. The visitor is visiting the
+      # given empty list object.
+      # @param anEmptyList [SkmEmptyList] the empty list object to visit.
+      def visit_empty_list(anEmptyList)
+        broadcast(:before_empty_list, anEmptyList)
+        broadcast(:after_empty_list, anEmptyList)
+      end
+
+      def visit_pair(aPair)
+        broadcast(:before_pair, aPair)
+        traverse_car_cdr(aPair)
+        broadcast(:after_pair, aPair)
+      end
+=end
+=begin
+   # Visit event. The visitor is about to visit the given non terminal node.
+    # @param aNonTerminalNode [NonTerminalNode] the node to visit.
+    def visit_nonterminal(aNonTerminalNode)
+      if @traversal == :post_order
+        broadcast(:before_non_terminal, aNonTerminalNode)
+        traverse_subnodes(aNonTerminalNode)
+      else
+        traverse_subnodes(aNonTerminalNode)
+        broadcast(:before_non_terminal, aNonTerminalNode)
+      end
+      broadcast(:after_non_terminal, aNonTerminalNode)
+    end
+=end
+
+      private
+
+      def traverse_children(aParent)
+        children = aParent.children
+        broadcast(:before_children, aParent, children)
+
+        # Let's proceed with the visit of children
+        children.each { |a_child| a_child.accept(self) }
+
+        broadcast(:after_children, aParent, children)
+      end
+
+      def traverse_car_cdr(aPair)
+        if aPair.car
+          broadcast(:before_car, aPair, aPair.car)
+          aPair.car.accept(self)
+          broadcast(:after_car, aPair, aPair.car)
+        end
+        if aPair.cdr
+          broadcast(:before_cdr, aPair, aPair.cdr)
+          aPair.cdr.accept(self)
+          broadcast(:after_cdr, aPair, aPair.cdr)
+        end
+      end
+
+      # Send a notification to all subscribers.
+      # @param msg [Symbol] event to notify
+      # @param args [Array] arguments of the notification.
+      def broadcast(msg, *args)
+        subscribers.each do |subscr|
+          next unless subscr.respond_to?(msg) || subscr.respond_to?(:accept_all)
+
+          subscr.send(msg, runtime, *args)
+        end
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/ast/lox_binary_expr.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'lox_compound_expr'
+
+module Loxxy
+  module Ast
+    class LoxBinaryExpr < LoxCompoundExpr
+      # @return [Symbol]
+      attr_reader :operator
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param operand1 [Loxxy::Ast::LoxNode]
+      # @param operand2 [Loxxy::Ast::LoxNode]
+      def initialize(aPosition, anOperator, operand1, operand2)
+        super(aPosition, [operand1, operand2])
+        @operator = anOperator
+      end
+
+      alias operands subnodes
+    end # class
+  end # module
+end # module

data/lib/loxxy/ast/lox_compound_expr.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'lox_node'
+
+module Loxxy
+  module Ast
+    class LoxCompoundExpr < LoxNode
+      # @return [Array<Ast::LoxNode>]
+      attr_reader :subnodes
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param theSubnodes [Array<Ast::LoxNode>]
+      def initialize(aPosition, theSubnodes)
+        super(aPosition)
+        @subnodes = theSubnodes
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_compound_expr(self)
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/ast/lox_literal_expr.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'lox_node'
+
+module Loxxy
+  module Ast
+    class LoxLiteralExpr < LoxNode
+      # @return [Loxxy::Datatype::BuiltinDatatype]
+      attr_reader :literal
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param aLiteral [Loxxy::Datatype::BuiltinDatatype]
+      def initialize(aPosition, aLiteral)
+        super(aPosition)
+        @literal = aLiteral
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_literal_expr(self)
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/ast/lox_node.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Loxxy
+  module Ast
+    class LoxNode
+      # return [Rley::Lexical::Position] Position of the entry in the input stream.
+      attr_reader :position
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      def initialize(aPosition)
+        @position = aPosition
+      end
+
+      # Abstract method.
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param _visitor [LoxxyTreeVisitor] the visitor
+      def accept(_visitor)
+        raise NotImplementedError
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/front_end/grammar.rb

@@ -26,11 +26,12 @@ module Loxxy
       add_terminals('EOF')
 
       # Top-level rule that matches an entire Lox program
-      rule('program' => 'declaration_star EOF')
+      rule('program' => 'EOF')
+      rule('program' => 'declaration_plus EOF')
 
       # Declarations: bind an identifier to something
-      rule('declaration_star' => 'declaration_star declaration')
-      rule('declaration_star' => [])
+      rule('declaration_plus' => 'declaration_plus declaration')
+      rule('declaration_plus' => 'declaration')
       rule('declaration' => 'classDecl')
       rule('declaration' => 'funDecl')
       rule('declaration' => 'varDecl')
@@ -75,7 +76,8 @@ module Loxxy
       rule('printStmt' => 'PRINT expression SEMICOLON')
       rule('returnStmt' => 'RETURN expression_opt SEMICOLON')
       rule('whileStmt' => 'WHILE LEFT_PAREN expression RIGHT_PAREN statement')
-      rule('block' => 'LEFT_BRACE declaration_star RIGHT_BRACE')
+      rule('block' => 'LEFT_BRACE declaration_plus RIGHT_BRACE')
+      rule('block' => 'LEFT_BRACE RIGHT_BRACE')
 
       # Expressions: produce values
       rule('expression_opt' => 'expression')
@@ -85,49 +87,56 @@ module Loxxy
       rule('assignment' => 'logic_or')
       rule('owner_opt' => 'call DOT')
       rule('owner_opt' => [])
-      rule('logic_or' => 'logic_and disjunct_star')
-      rule('disjunct_star' => 'disjunct_star OR logic_and')
-      rule('disjunct_star' => [])
-      rule('logic_and' => 'equality conjunct_star')
-      rule('conjunct_star' => 'conjunct_star AND equality')
-      rule('conjunct_star' => [])
-      rule('equality' => 'comparison equalityTest_star')
-      rule('equalityTest_star' => 'equalityTest_star equalityTest comparison')
-      rule('equalityTest_star' => [])
+      rule('logic_or' => 'logic_and')
+      rule('logic_or' => 'logic_and disjunct_plus')
+      rule('disjunct_plus' => 'disjunct_plus OR logic_and')
+      rule('disjunct_plus' => 'OR logic_and')
+      rule('logic_and' => 'equality')
+      rule('logic_and' => 'equality conjunct_plus')
+      rule('conjunct_plus' => 'conjunct_plus AND equality')
+      rule('conjunct_' => 'AND equality')
+      rule('equality' => 'comparison')
+      rule('equality' => 'comparison equalityTest_plus')
+      rule('equalityTest_plus' => 'equalityTest_plus equalityTest comparison')
+      rule('equalityTest_star' => 'equalityTest comparison')
       rule('equalityTest' => 'BANG_EQUAL')
       rule('equalityTest' => 'EQUAL_EQUAL')
-      rule('comparison' => 'term comparisonTest_star')
-      rule('comparisonTest_star' => 'comparisonTest_star comparisonTest term')
-      rule('comparisonTest_star' => [])
+      rule('comparison' => 'term')
+      rule('comparison' => 'term comparisonTest_plus')
+      rule('comparisonTest_plus' => 'comparisonTest_plus comparisonTest term')
+      rule('comparisonTest_plus' => 'comparisonTest term')
       rule('comparisonTest' => 'GREATER')
       rule('comparisonTest' => 'GREATER_EQUAL')
       rule('comparisonTest' => 'LESS')
       rule('comparisonTest' => 'LESS_EQUAL')
-      rule('term' => 'factor additive_star')
-      rule('additive_star' => 'additive_star additionOp factor')
-      rule('additive_star' => [])
+      rule('term' => 'factor')
+      rule('term' => 'factor additive_plus')
+      rule('additive_plus' => 'additive_plus additionOp factor').as 'additionOp_expr'
+      rule('additive_plus' => 'additionOp factor')
       rule('additionOp' => 'MINUS')
       rule('additionOp' => 'PLUS')
-      rule('factor' => 'unary multiplicative_star')
-      rule('multiplicative_star' => 'multiplicative_star multOp unary')
-      rule('multiplicative_star' => [])
+      rule('factor' => 'unary')
+      rule('factor' => 'multiplicative_plus')
+      rule('multiplicative_plus' => 'multiplicative_plus multOp unary') # .as 'multOp_expr'
+      rule('multiplicative_plus' => 'multOp unary')
       rule('multOp' => 'SLASH')
       rule('multOp' => 'STAR')
       rule('unary' => 'unaryOp unary')
       rule('unary' => 'call')
       rule('unaryOp' => 'BANG')
       rule('unaryOp' => 'MINUS')
-      rule('call' => 'primary refinement_star')
-      rule('refinement_star' => 'refinement_star refinement')
-      rule('refinement_star' => [])
+      rule('call' => 'primary')
+      rule('call' => 'primary refinement_plus')
+      rule('refinement_plus' => 'refinement_plus refinement')
+      rule('refinement_plus' => 'refinement')
       rule('refinement' => 'LEFT_PAREN arguments_opt RIGHT_PAREN')
       rule('refinement' => 'DOT IDENTIFIER')
-      rule('primary' => 'TRUE')
-      rule('primary' => 'FALSE')
-      rule('primary' => 'NIL')
+      rule('primary' => 'TRUE').as 'literal_expr'
+      rule('primary' => 'FALSE').as 'literal_expr'
+      rule('primary' => 'NIL').as 'literal_expr'
       rule('primary' => 'THIS')
-      rule('primary' => 'NUMBER')
-      rule('primary' => 'STRING')
+      rule('primary' => 'NUMBER').as 'literal_expr'
+      rule('primary' => 'STRING').as 'literal_expr'
       rule('primary' => 'IDENTIFIER')
       rule('primary' => 'LEFT_PAREN expression RIGHT_PAREN')
       rule('primary' => 'SUPER DOT IDENTIFIER')

data/lib/loxxy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Loxxy
-  VERSION = '0.0.6'
+  VERSION = '0.0.7'
 end

data/spec/front_end/parser_spec.rb

@@ -10,6 +10,18 @@ module Loxxy
     describe Parser do
       subject { Parser.new }
 
+      # Utility method to walk towards deeply nested node
+      # @param aNTNode [Rley::PTree::NonTerminalNode]
+      # @param subnodePath[Array<Integer>] An Array of subnode indices
+      def walk_subnodes(aNTNode, subnodePath)
+        curr_node = aNTNode
+        subnodePath.each do |index|
+          curr_node = curr_node.subnodes[index]
+        end
+
+        curr_node
+      end
+
       context 'Initialization:' do
         it 'should be initialized without argument' do
           expect { Parser.new }.not_to raise_error
@@ -25,11 +37,7 @@ module Loxxy
           # Parse results MUST to comply to grammar rule:
           #   program => declaration_star EOF
           #   where the declaration_star MUST be empty
-          expect(aParseTree.root.symbol.name).to eq('program')
-          expect(aParseTree.root.subnodes.size).to eq(1)
-          eof = aParseTree.root.subnodes[0]
-          expect(eof).to be_kind_of(Rley::PTree::TerminalNode)
-          expect(eof.symbol.name).to eq('EOF')
+          expect(aParseTree.root.symbol.name).to eq('EOF')
         end
 
         it 'should cope with an empty input' do
@@ -52,18 +60,59 @@ module Loxxy
         end
       end # context
 
-      context 'Parsing expressions:' do
-        # Utility method to walk towards deeply nested node
-        # @param aNTNode [Rley::PTree::NonTerminalNode]
-        # @param subnodePath[Array<Integer>] An Array of subnode indices
-        def walk_subnodes(aNTNode, subnodePath)
-          curr_node = aNTNode
-          subnodePath.each do |index|
-            curr_node = curr_node.subnodes[index]
+      context 'Parsing literals:' do
+        it 'should parse a false literal' do
+          input = 'false;'
+          ptree = subject.parse(input)
+          leaf = walk_subnodes(ptree.root, [0, 0])
+          expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
+          expect(leaf.literal).to be_equal(Datatype::False.instance)
+        end
+
+        it 'should parse a true literal' do
+          input = 'true;'
+          ptree = subject.parse(input)
+          leaf = walk_subnodes(ptree.root, [0, 0])
+          expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
+          expect(leaf.literal).to be_equal(Datatype::True.instance)
+        end
+
+        it 'should parse number literals' do
+          inputs = %w[1234; 12.34;]
+          inputs.each do |source|
+            ptree = subject.parse(source)
+            leaf = walk_subnodes(ptree.root, [0, 0])
+            expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
+            expect(leaf.literal).to be_kind_of(Datatype::Number)
+            expect(leaf.literal.value).to eq(source.to_f)
           end
+        end
 
-          curr_node
+        it 'should parse string literals' do
+          inputs = [
+            '"I am a string";',
+            '"";',
+            '"123";'
+          ]
+          inputs.each do |source|
+            ptree = subject.parse(source)
+            leaf = walk_subnodes(ptree.root, [0, 0])
+            expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
+            expect(leaf.literal).to be_kind_of(Datatype::LXString)
+            expect(leaf.literal.value).to eq(source.gsub(/(^")|(";$)/, ''))
+          end
         end
+
+        it 'should parse a nil literal' do
+          input = 'nil;'
+          ptree = subject.parse(input)
+          leaf = walk_subnodes(ptree.root, [0, 0])
+          expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
+          expect(leaf.literal).to be_equal(Datatype::Nil.instance)
+        end
+      end
+
+      context 'Parsing expressions:' do
         it 'should parse a hello world program' do
           program = <<-LOX_END
             // Your first Lox program!
@@ -72,25 +121,31 @@ LOX_END
           ptree = subject.parse(program)
           root = ptree.root
           expect(root.symbol.name).to eq('program')
-          (decls, eof) = root.subnodes
-          expect(decls).to be_kind_of(Rley::PTree::NonTerminalNode)
-          expect(decls.symbol.name).to eq('declaration_star')
-          prnt_stmt = decls.subnodes[0]
+          (prnt_stmt, eof) = root.subnodes
           expect(prnt_stmt).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(prnt_stmt.symbol.name).to eq('printStmt')
           expect(prnt_stmt.subnodes.size).to eq(3)
           expect(prnt_stmt.subnodes[0]).to be_kind_of(Rley::PTree::TerminalNode)
           expect(prnt_stmt.subnodes[0].symbol.name).to eq('PRINT')
-          expect(prnt_stmt.subnodes[1]).to be_kind_of(Rley::PTree::NonTerminalNode)
-          # leaf_node = walk_subnodes(prnt_stmt, [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
-          # expect(leaf_node).to be_kind_of(Rley::PTree::TerminalNode)
-          # expect(leaf_node.symbol.name).to eq('STRING')
-          # expect(leaf_node.token.value).to eq('Hello, world!')
+          expect(prnt_stmt.subnodes[1]).to be_kind_of(Loxxy::Ast::LoxLiteralExpr)
+          expect(prnt_stmt.subnodes[1].literal).to be_kind_of(Loxxy::Datatype::LXString)
+          expect(prnt_stmt.subnodes[1].literal.value).to eq('Hello, world!')
           expect(prnt_stmt.subnodes[2]).to be_kind_of(Rley::PTree::TerminalNode)
           expect(prnt_stmt.subnodes[2].symbol.name).to eq('SEMICOLON')
           expect(eof).to be_kind_of(Rley::PTree::TerminalNode)
           expect(eof.symbol.name).to eq('EOF')
         end
-      end
+      end # context
+
+      context 'Parsing literals:' do
+        it 'should parse the addition of two number literals' do
+          # input = '123 + 456;'
+          # ptree = subject.parse(input)
+          # term = walk_subnodes(ptree.root, [0, 0, 0, 0, 0, 0, 0])
+          # expect(leaf).to be_kind_of(Ast::LoxBinaryExpr)
+          # expect(leaf.literal).to be_equal(Datatype::False.instance)
+        end
+      end # context
     end # describe
   end # module
 end # module

data/spec/front_end/raw_parser_spec.rb

@@ -26,10 +26,7 @@ module Loxxy
           #   program => declaration_star EOF
           #   where the declaration_star MUST be empty
           expect(aParseTree.root.symbol.name).to eq('program')
-          (decls, eof) = aParseTree.root.subnodes
-          expect(decls).to be_kind_of(Rley::PTree::NonTerminalNode)
-          expect(decls.symbol.name).to eq('declaration_star')
-          expect(decls.subnodes).to be_empty
+          eof = aParseTree.root.subnodes.first
           expect(eof).to be_kind_of(Rley::PTree::TerminalNode)
           expect(eof.symbol.name).to eq('EOF')
         end
@@ -76,8 +73,8 @@ LOX_END
           expect(root.symbol.name).to eq('program')
           (decls, eof) = root.subnodes
           expect(decls).to be_kind_of(Rley::PTree::NonTerminalNode)
-          expect(decls.symbol.name).to eq('declaration_star')
-          stmt = decls.subnodes[1].subnodes[0]
+          expect(decls.symbol.name).to eq('declaration_plus')
+          stmt = decls.subnodes[0].subnodes[0]
           expect(stmt).to be_kind_of(Rley::PTree::NonTerminalNode)
           expect(stmt.symbol.name).to eq('statement')
           prnt_stmt = stmt.subnodes[0]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: loxxy
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-03 00:00:00.000000000 Z
+date: 2021-01-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -85,6 +85,11 @@ files:
 - Rakefile
 - lib/loxxy.rb
 - lib/loxxy/ast/ast_builder.rb
+- lib/loxxy/ast/ast_visitor.rb
+- lib/loxxy/ast/lox_binary_expr.rb
+- lib/loxxy/ast/lox_compound_expr.rb
+- lib/loxxy/ast/lox_literal_expr.rb
+- lib/loxxy/ast/lox_node.rb
 - lib/loxxy/datatype/all_datatypes.rb
 - lib/loxxy/datatype/boolean.rb
 - lib/loxxy/datatype/builtin_datatype.rb