loxxy 0.0.11 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 583f5c2f620ea8f45b339607103955eda2f32c02f0358ccb88cf4d20b4398d21
-  data.tar.gz: f349b949c1315473027eaaab589ff1cf2da89deca3b243cd1508c088bf9a9cc5
+  metadata.gz: 7274fd2d139354b984962f9317cae890344e528540f2f157772e7395cdfd7d33
+  data.tar.gz: c1b38a4dfcb441c00604926cbaf397ab555624270ca647448d9cc4d4f463f500
 SHA512:
-  metadata.gz: 9c93648c634783348a22b3b65cf710a59c0ca5e3cefc5a20d7c60b9b429b4334e1e5603cc2bf74f302aed881daa71634cb7253445b3f376838197637f79f8cc7
-  data.tar.gz: 67d60e89985322911a7842a2b5fc2e22b4ccc3136ffa216027089ea05ea56a6932d1de9b8917173ad072695aaa6abb2147d456f54d09f2878d7831937c42af74
+  metadata.gz: 27d5de6532213d1a995f86da84ccbd41a11b5f85c305e57a62f64637ad17852e622685e4261b1c62deb31c924bb8f8c29c4edd97e9776fabf7e0d06e5c302534
+  data.tar.gz: dab4a9e391c120c159a63e316f90065faf1415b54c9aa4c6f349f6be8e95de1289a2478f395e6b9e19b2e6f09482ae4db49a70e0d5d857eb5475cecad0590c69

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+## [0.0.12] - 2021-01-09
+- Initial interpreter capable of evaluating a tiny subset of Lox language.
+
+## Added
+- Class `AST::LoxNoopExpr`
+- Class `AST::LoxPrintStmt`
+- Class `BackEnd::Engine` implementation of the print statement logic
+- Class `Interpreter`
+
+## Changed
+- Class `Ast::ASTVisitor` Added visit method
+- File `README.md` added Hello world example.
+
 ## [0.0.11] - 2021-01-08
 - AST node generation for logical expression (and, or).
 

data/README.md

@@ -13,58 +13,26 @@ a simple language used in Bob Nystrom's online book [Crafting Interpreters](http
   a Lox interpreter written in Lox.
 
 ## Current status
-The __loxxy__ gem hosts two distinct parsers classes (`RawParser` and `Parser`).
-- A `RawParser` instance is able to recognize valid Lox input and to generate
-  a concrete parse tree from it.
-- A `Parser` instance can also parse Lox source code but will generate an AST
-  (Abstract Syntax Tree) that will be used by the future tree-walking interpreter.
-  Currently it generates AST for arithmetic expressions with literal numbers only.
-
-## Roadmap
-### Done
-- Scanner (tokenizer)
-- Lox grammar (in format required by Rley gem)   
-- Raw parser. It parses Lox programs and generates a raw parse tree.
-- Tailored parser for generating AST (Abstract Syntax Tree)
-  
-### Started
--  Custom AST builder class  
--  Classes for representing Lox expressions in AST
-
-### TODO
-AST Node generation
-Goal: parser should generate AST for any input Lox program
-- [X] Equality operator
-- [X] Logical operator (and, or)
-- [] Unary expressions (negate, not)
-- [] Grouping expressions
-- [] Print statement
-- [] Simple assignment expressions
-- [] Variable declaration
-- [] Dot notation
-- [] Block statement
-- [] If statement
-- [] For statement
-- [] While statement
-- [] Function declaration
-- [] Call expression
-- [] Return statement
-- [] Class declaration
-- [] AST generation covers complete grammar
-
-Tree-walking:
-- [] Tree visitor recognizes all AST node types
-
-Interpreter:
-- Keywords: symbol table, scope, activation record, class & object model, Lox test suite
-- [] Milestone: Interpreter handles expressions but function calls
-- [] Milestone: Interpreter handles `for`, `if`, `print`, `while` and block statements
-- [] Milestone: Interpreter handles variable declarations (global, block)
-- [] Milestone: Interpreter handles function declarations and calls
-- [] Milestone: Interpreter supports class and object definition
-- [] Milestone: Lox interpreter complete
+The project is still in inception and the interpreter is being implemented...
+Currently it can execute a very limited subset of __Lox__ language.
+
+The __loxxy__ gem also a parser class `RawPaser` that can, in principle, any valid Lox input.
+
+## Hello world example
+```ruby
+require 'loxxy'
+
+lox_program = <<LOX_END
+  // Your first Lox program!
+  print "Hello, world!";
+LOX_END
+
+lox = Loxxy::Interpreter.new
+lox.evaluate(lox_program) # => Hello, world!
+```
 
 ## Example using RawParser class
+
 ```ruby
 require 'loxxy'
 
@@ -109,6 +77,16 @@ program
 +-- EOF: ''
 ```
 
+## Suppported Lox language features
+Although the interpreter should parse almost any valid Lox program,
+it currently can evaluate a tiny set of AST node (AST = Abstract Syntax Tree).
+
+Here are the language features supported by the interpreter:
+- Line comments,
+- All the Lox literals (booleans, numbers, strings and nil),
+- `print` statement.
+
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/lib/loxxy.rb

@@ -1,10 +1,31 @@
 # frozen_string_literal: true
 
 require_relative 'loxxy/version'
+require_relative 'loxxy/interpreter'
 require_relative 'loxxy/front_end/raw_parser'
-require_relative 'loxxy/front_end/parser'
 
+# Namespace for all classes and constants of __loxxy__ gem.
 module Loxxy
   class Error < StandardError; end
-  # Your code goes here...
+  
+  # Shorthand method. Returns the sole object that represents
+  # a Lox false literal.
+  # @return [Loxxy::Datatype::False]
+  def self.lox_false
+    Datatype::False.instance
+  end  
+
+  # Shorthand method. Returns the sole object that represents
+  # a Lox nil literal.
+  # @return [Loxxy::Datatype::Nil]
+  def self.lox_nil
+    Datatype::Nil.instance
+  end
+  
+  # Shorthand method. Returns the sole object that represents
+  # a Lox true literal.
+  # @return [Loxxy::Datatype::True]
+  def self.lox_true
+    Datatype::False.instance
+  end  
 end

data/lib/loxxy/ast/all_lox_nodes.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative 'lox_print_stmt'
+require_relative 'lox_literal_expr'
+require_relative 'lox_noop_expr'

data/lib/loxxy/ast/ast_builder.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../datatype/all_datatypes'
-require_relative 'lox_literal_expr'
+require_relative 'all_lox_nodes'
 require_relative 'lox_binary_expr'
 
 module Loxxy
@@ -10,31 +10,33 @@ module Loxxy
     # (Abstract Syntax Tree) from a sequence of input tokens and
     # visit events produced by walking over a GFGParsing object.
     class ASTBuilder < Rley::ParseRep::ASTBaseBuilder
-      # Mapping Token name => operator | separator | delimiter characters
-      # @return [Hash{String => String}]
-      Name2special = {
-        'AND' => 'and',
-        'BANG' => '!',
-        'BANG_EQUAL' => '!=',
-        'COMMA' =>  ',',
-        'DOT' => '.',
-        'EQUAL' => '=',
-        'EQUAL_EQUAL' => '==',
-        'GREATER' => '>',
-        'GREATER_EQUAL' => '>=',
-        'LEFT_BRACE' =>  '{',
-        'LEFT_PAREN' => '(',
-        'LESS' => '<',
-        'LESS_EQUAL' => '<=',
-        'MINUS' => '-',
-        'OR' => 'or',
-        'PLUS' => '+',
-        'RIGHT_BRACE' => '}',
-        'RIGHT_PAREN' => ')',
-        'SEMICOLON' => ';',
-        'SLASH' =>  '/',
-        'STAR' => '*'
-      }.freeze
+      unless defined?(Name2special)
+        # Mapping Token name => operator | separator | delimiter characters
+        # @return [Hash{String => String}]
+        Name2special = {
+          'AND' => 'and',
+          'BANG' => '!',
+          'BANG_EQUAL' => '!=',
+          'COMMA' =>  ',',
+          'DOT' => '.',
+          'EQUAL' => '=',
+          'EQUAL_EQUAL' => '==',
+          'GREATER' => '>',
+          'GREATER_EQUAL' => '>=',
+          'LEFT_BRACE' =>  '{',
+          'LEFT_PAREN' => '(',
+          'LESS' => '<',
+          'LESS_EQUAL' => '<=',
+          'MINUS' => '-',
+          'OR' => 'or',
+          'PLUS' => '+',
+          'RIGHT_BRACE' => '}',
+          'RIGHT_PAREN' => ')',
+          'SEMICOLON' => ';',
+          'SLASH' =>  '/',
+          'STAR' => '*'
+        }.freeze
+      end # defined
 
       attr_reader :strict
 
@@ -117,6 +119,25 @@ module Loxxy
         [[operator, operand2]]
       end
 
+      #####################################
+      #  SEMANTIC ACTIONS
+      #####################################
+
+      # rule('program' => 'EOF').as 'null_program'
+      def reduce_null_program(_production, range, _tokens, _theChildren)
+        Ast::LoxNoopExpr.new(tokens[0].position)
+      end
+
+      # rule('program' => 'declaration_plus EOF').as ''
+      def reduce_lox_program(_production, range, tokens, theChildren)
+        return_first_child(range, tokens, theChildren)
+      end
+
+      # rule('printStmt' => 'PRINT expression SEMICOLON')
+      def reduce_print_stmt(_production, _range, tokens, theChildren)
+        Ast::LoxPrintStmt.new(tokens[1].position, theChildren[1])
+      end
+
       # rule('logic_or' => 'logic_and disjunct_plus')
       def reduce_logic_or_plus(production, range, tokens, theChildren)
         reduce_binary_operator(production, range, tokens, theChildren)
@@ -141,7 +162,7 @@ module Loxxy
       def reduce_logic_and_plus_more(production, range, tokens, theChildren)
         reduce_binary_plus_more(production, range, tokens, theChildren)
       end
-      
+
       # rule('conjunct_plus' => 'AND equality')
       def reduce_logic_and_plus_end(production, range, tokens, theChildren)
         reduce_binary_plus_end(production, range, tokens, theChildren)

data/lib/loxxy/ast/ast_visitor.rb

@@ -39,75 +39,55 @@ module Loxxy
         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)
+      # Visit event. The visitor is about to visit the ptree.
+      # @param aParseTree [Rley::PTre::ParseTree] the ptree to visit.
+      def start_visit_ptree(aParseTree)
+        broadcast(:before_ptree, aParseTree)
       end
 
-=begin
-
+      # Visit event. The visitor has completed the visit of the ptree.
+      # @param aParseTree [Rley::PTre::ParseTree] the visited ptree.
+      def end_visit_ptree(aParseTree)
+        broadcast(:after_ptree, aParseTree)
+      end
 
-      def visit_compound_datum(aCompoundDatum)
-        broadcast(:before_compound_datum, aCompoundDatum)
-        traverse_children(aCompoundDatum)
-        broadcast(:after_compound_datum, aCompoundDatum)
+      # Visit event. The visitor is about to visit a print statement expression.
+      # @param aPrintStmt [AST::LOXPrintStmt] the print statement node to visit
+      def visit_print_stmt(aPrintStmt)
+        broadcast(:before_print_stmt, aPrintStmt)
+        traverse_subnodes(aPrintStmt)
+        broadcast(:after_print_stmt, aPrintStmt)
       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)
+      # 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
 
-      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)
+      # Visit event. The visitor is about to visit the given non terminal node.
+      # @param aNonTerminalNode [Rley::PTre::NonTerminalNode] the node to visit.
+      def visit_nonterminal(_non_terminal_node)
+        # Loxxy interpreter encountered a CST node (Concrete Syntax Tree)
+        # that it cannot handle.
+        raise NotImplementedError, 'Loxxy cannot execute this code yet.'
       end
-      broadcast(:after_non_terminal, aNonTerminalNode)
-    end
-=end
 
       private
 
-      def traverse_children(aParent)
-        children = aParent.children
-        broadcast(:before_children, aParent, children)
+      # Visit event. The visitor is about to visit the subnodes of a non
+      # terminal node.
+      # @param aParentNode [Ast::LocCompoundExpr] the parent node.
+      def traverse_subnodes(aParentNode)
+        subnodes = aParentNode.subnodes
+        broadcast(:before_subnodes, aParentNode, subnodes)
 
-        # Let's proceed with the visit of children
-        children.each { |a_child| a_child.accept(self) }
+        # Let's proceed with the visit of subnodes
+        subnodes.each { |a_node| a_node.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
+        broadcast(:after_subnodes, aParentNode, subnodes)
       end
 
       # Send a notification to all subscribers.
@@ -117,7 +97,7 @@ module Loxxy
         subscribers.each do |subscr|
           next unless subscr.respond_to?(msg) || subscr.respond_to?(:accept_all)
 
-          subscr.send(msg, runtime, *args)
+          subscr.send(msg, *args)
         end
       end
     end # class

data/lib/loxxy/ast/lox_compound_expr.rb

@@ -5,7 +5,7 @@ require_relative 'lox_node'
 module Loxxy
   module Ast
     class LoxCompoundExpr < LoxNode
-      # @return [Array<Ast::LoxNode>]
+      # @return [Array<Ast::LoxNode>] the children nodes (sub-expressions)
       attr_reader :subnodes
 
       # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.

data/lib/loxxy/ast/lox_node.rb

@@ -11,6 +11,11 @@ module Loxxy
         @position = aPosition
       end
 
+      # Notification that the parsing was successfully completed
+      def done!
+        # Default: do nothing ...
+      end
+
       # Abstract method.
       # Part of the 'visitee' role in Visitor design pattern.
       # @param _visitor [LoxxyTreeVisitor] the visitor

data/lib/loxxy/ast/lox_noop_expr.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'lox_node'
+
+module Loxxy
+  module Ast
+    class LoxNoopExpr < LoxNode
+      # Abstract method.
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param _visitor [LoxxyTreeVisitor] the visitor
+      def accept(_visitor)
+        # Do nothing...
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/ast/lox_print_stmt.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'lox_compound_expr'
+
+module Loxxy
+  module Ast
+    class LoxPrintStmt < LoxCompoundExpr
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param anExpression [Ast::LoxNode] expression to output
+      def initialize(aPosition, anExpression)
+        super(aPosition, [anExpression])
+      end
+
+      # Abstract method.
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [Ast::ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_print_stmt(self)
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/back_end/engine.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# Load all the classes implementing AST nodes
+require_relative '../ast/all_lox_nodes'
+
+module Loxxy
+  module BackEnd
+    # An instance of this class executes the statements as when they
+    # occur during the abstract syntax tree walking.
+    # @note WIP: very crude implementation.
+    class Engine
+      # @return [Hash] A set of configuration options
+      attr_reader :config
+
+      # @return [Array] Data stack used for passing data between statements
+      attr_reader :stack
+
+      # @param theOptions [Hash]
+      def initialize(theOptions)
+        @config = theOptions
+        @ostream = config.include?(:ostream) ? config[:ostream] : $stdout
+        @stack = []
+      end
+
+      # Given an abstract syntax parse tree visitor, luanch the visit
+      # and execute the visit events in the output stream.
+      # @param aVisitor [AST::ASTVisitor]
+      def execute(aVisitor)
+        aVisitor.subscribe(self)
+        aVisitor.start
+        aVisitor.unsubscribe(self)
+        stack.empty? ? Datatype::Nil.instance : stack.pop
+      end
+
+      # Visit event handling
+
+      def after_print_stmt(_printStmt)
+        tos = stack.pop
+        @ostream.print tos.to_str
+      end
+
+      # @param literalExpr [Ast::LoxLiteralExpr]
+      def before_literal_expr(literalExpr)
+        stack.push(literalExpr.literal)
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/datatype/builtin_datatype.rb

@@ -14,6 +14,12 @@ module Loxxy
         @value = validated_value(aValue)
       end
 
+      # Method called from Lox to obtain the text representation of the boolean.
+      # @return [String]
+      def to_str
+        value.to_s # Default implementation...
+      end
+
       protected
 
       def validated_value(aValue)

data/lib/loxxy/datatype/lx_string.rb

@@ -21,6 +21,12 @@ module Loxxy
         end
       end
 
+      # Method called from Lox to obtain the text representation of the object.
+      # @return [String]
+      def to_str
+        value
+      end
+
       protected
 
       def validated_value(aValue)

data/lib/loxxy/datatype/nil.rb

@@ -13,6 +13,12 @@ module Loxxy
       def initialize
         super(nil)
       end
+
+      # Method called from Lox to obtain the text representation of nil.
+      # @return [String]
+      def to_str
+        'nil'
+      end
     end # class
 
     Nil.instance.freeze # Make the sole instance immutable

data/lib/loxxy/front_end/grammar.rb

@@ -26,8 +26,8 @@ module Loxxy
       add_terminals('EOF')
 
       # Top-level rule that matches an entire Lox program
-      rule('program' => 'EOF')
-      rule('program' => 'declaration_plus EOF')
+      rule('program' => 'EOF').as 'null_program'
+      rule('program' => 'declaration_plus EOF').as 'lox_program'
 
       # Declarations: bind an identifier to something
       rule('declaration_plus' => 'declaration_plus declaration')
@@ -73,7 +73,7 @@ module Loxxy
       rule('elsePart_opt' => 'ELSE statement')
       rule('elsePart_opt' => [])
 
-      rule('printStmt' => 'PRINT expression SEMICOLON')
+      rule('printStmt' => 'PRINT expression SEMICOLON').as 'print_stmt'
       rule('returnStmt' => 'RETURN expression_opt SEMICOLON')
       rule('whileStmt' => 'WHILE LEFT_PAREN expression RIGHT_PAREN statement')
       rule('block' => 'LEFT_BRACE declaration_plus RIGHT_BRACE')

data/lib/loxxy/interpreter.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative './front_end/parser'
+require_relative './ast/ast_visitor'
+require_relative './back_end/engine'
+
+module Loxxy
+  # A Lox tree-walking interpreter.
+  # It acts as a facade object that:
+  # - hides the internal plumbings of the front-end and back-end parts.
+  # - delegates all the core work to its subordinate objects.
+  # @note WIP: very crude implementation.
+  class Interpreter
+    # return [Hash]
+    attr_reader :config
+
+    # @param theOptions [Hash]
+    def initialize(theOptions = {})
+      @config = theOptions
+    end
+
+    # Evaluate the given Lox program
+    # @param lox_input [String] Lox program to evaluate
+    def evaluate(lox_input)
+      # Front-end scans, parses the input and blurps an AST...
+      parser = FrontEnd::Parser.new
+
+      # The AST is the data object passed to the back-end
+      ast_tree = parser.parse(lox_input)
+      visitor = Ast::ASTVisitor.new(ast_tree)
+
+      # Back-end launches the tree walking & reponds to visit events
+      # by executing the code determined by the visited AST node.
+      engine = BackEnd::Engine.new(config)
+      engine.execute(visitor)
+    end
+  end # class
+end # module

data/lib/loxxy/version.rb

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

data/spec/back_end/engine_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require 'stringio'
+
+# Load the class under test
+require_relative '../../lib/loxxy/back_end/engine'
+
+module Loxxy
+  module BackEnd
+    describe Engine do
+      let(:sample_options) do
+        { ostream: StringIO.new }
+      end
+      subject { Engine.new(sample_options) }
+
+      context 'Initialization:' do
+        it 'should accept a option Hash at initialization' do
+          expect { Engine.new(sample_options) }.not_to raise_error
+        end
+
+        it 'should know its config options' do
+          expect(subject.config).to eq(sample_options)
+        end
+
+        it 'should have an empty stack' do
+          expect(subject.stack).to be_empty
+        end
+      end
+
+      context 'Listening to visitor events:' do
+        let(:greeting) { Datatype::LXString.new('Hello, world') }
+        let(:sample_pos) { double('fake-position') }
+        let(:lit_expr) { Ast::LoxLiteralExpr.new(sample_pos, greeting) }
+
+        it "should react to 'before_literal_expr' event" do
+          expect { subject.before_literal_expr(lit_expr) }.not_to raise_error
+          expect(subject.stack.pop).to eq(greeting)
+        end
+      end
+    end # describe
+  end # module
+end # module

data/spec/datatype/boolean_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+
+# Load the class under test
+require_relative '../../lib/loxxy/datatype/boolean'
+
+module Loxxy
+  module Datatype
+    describe Boolean do
+      let(:thruth_value) { false }
+      subject { Boolean.new(thruth_value) }
+
+      context 'Initialization:' do
+        it 'should accept a boolean value at initialization' do
+          expect { Boolean.new(thruth_value) }.not_to raise_error
+        end
+
+        it 'should know its value' do
+          expect(subject.value).to eq(thruth_value)
+        end
+      end
+
+      context 'Provided services:' do
+        it 'should give its display representation' do
+          expect(subject.to_str).to eq('false')
+        end
+      end
+    end # describe
+  end # module
+end # module

data/spec/datatype/lx_string_spec.rb

@@ -22,6 +22,10 @@ module Loxxy
       end
 
       context 'Provided services:' do
+        it 'should give its display representation' do
+          expect(subject.to_str).to eq(sample_text)
+        end
+
         it 'compares with another string' do
           expect(subject).to eq(sample_text)
           expect(subject).to eq(LXString.new(sample_text.dup))

data/spec/datatype/nil_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+
+# Load the class under test
+require_relative '../../lib/loxxy/datatype/boolean'
+
+module Loxxy
+  module Datatype
+    describe Nil do
+      subject { Nil.instance }
+
+      context 'Initialization:' do
+        it 'should know its value' do
+          expect(subject.value).to be_nil
+        end
+      end
+
+      context 'Provided services:' do
+        it 'should give its display representation' do
+          expect(subject.to_str).to eq('nil')
+        end
+      end
+    end # describe
+  end # module
+end # module

data/spec/datatype/number_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+
+# Load the class under test
+require_relative '../../lib/loxxy/datatype/number'
+
+module Loxxy
+  module Datatype
+    describe Number do
+      let(:sample_value) { -12.34 }
+      subject { Number.new(sample_value) }
+
+      context 'Initialization:' do
+        it 'should accept a Numeric value at initialization' do
+          expect { Number.new(sample_value) }.not_to raise_error
+        end
+
+        it 'should know its value' do
+          expect(subject.value).to eq(sample_value)
+        end
+      end
+
+      context 'Provided services:' do
+        it 'should give its display representation' do
+          expect(subject.to_str).to eq(sample_value.to_s)
+        end
+      end
+    end # describe
+  end # module
+end # module

data/spec/front_end/parser_spec.rb

@@ -37,7 +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('EOF')
+          expect(aParseTree.root).to be_kind_of(Ast::LoxNoopExpr)
         end
 
         it 'should cope with an empty input' do
@@ -64,7 +64,7 @@ module Loxxy
         it 'should parse a false literal' do
           input = 'false;'
           ptree = subject.parse(input)
-          leaf = walk_subnodes(ptree.root, [0, 0])
+          leaf = ptree.root.subnodes[0]
           expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
           expect(leaf.literal).to be_equal(Datatype::False.instance)
         end
@@ -72,7 +72,7 @@ module Loxxy
         it 'should parse a true literal' do
           input = 'true;'
           ptree = subject.parse(input)
-          leaf = walk_subnodes(ptree.root, [0, 0])
+          leaf = ptree.root.subnodes[0]
           expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
           expect(leaf.literal).to be_equal(Datatype::True.instance)
         end
@@ -81,7 +81,7 @@ module Loxxy
           inputs = %w[1234; 12.34;]
           inputs.each do |source|
             ptree = subject.parse(source)
-            leaf = walk_subnodes(ptree.root, [0, 0])
+            leaf = ptree.root.subnodes[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)
@@ -96,7 +96,7 @@ module Loxxy
           ]
           inputs.each do |source|
             ptree = subject.parse(source)
-            leaf = walk_subnodes(ptree.root, [0, 0])
+            leaf = ptree.root.subnodes[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(/(^")|(";$)/, ''))
@@ -106,7 +106,7 @@ module Loxxy
         it 'should parse a nil literal' do
           input = 'nil;'
           ptree = subject.parse(input)
-          leaf = walk_subnodes(ptree.root, [0, 0])
+          leaf = ptree.root.subnodes[0]
           expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
           expect(leaf.literal).to be_equal(Datatype::Nil.instance)
         end
@@ -119,21 +119,11 @@ module Loxxy
             print "Hello, world!";
 LOX_END
           ptree = subject.parse(program)
-          root = ptree.root
-          expect(root.symbol.name).to eq('program')
-          (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(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')
+          prnt_stmt = ptree.root
+          expect(prnt_stmt).to be_kind_of(Ast::LoxPrintStmt)
+          expect(prnt_stmt.subnodes[0]).to be_kind_of(Ast::LoxLiteralExpr)
+          expect(prnt_stmt.subnodes[0].literal).to be_kind_of(Loxxy::Datatype::LXString)
+          expect(prnt_stmt.subnodes[0].literal.value).to eq('Hello, world!')
         end
       end # context
 
@@ -141,7 +131,7 @@ LOX_END
         it 'should parse the addition of two number literals' do
           input = '123 + 456;'
           ptree = subject.parse(input)
-          parent = ptree.root.subnodes[0]
+          parent = ptree.root
           expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
           expect(parent.symbol.name).to eq('exprStmt')
           expr = parent.subnodes[0]
@@ -154,7 +144,7 @@ LOX_END
         it 'should parse the subtraction of two number literals' do
           input = '4 - 3;'
           ptree = subject.parse(input)
-          parent = ptree.root.subnodes[0]
+          parent = ptree.root
           expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
           expect(parent.symbol.name).to eq('exprStmt')
           expr = parent.subnodes[0]
@@ -167,7 +157,7 @@ LOX_END
         it 'should parse multiple additive operations' do
           input = '5 + 2 - 3;'
           ptree = subject.parse(input)
-          parent = ptree.root.subnodes[0]
+          parent = ptree.root
           expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
           expect(parent.symbol.name).to eq('exprStmt')
           expr = parent.subnodes[0]
@@ -183,7 +173,7 @@ LOX_END
         it 'should parse the division of two number literals' do
           input = '8 / 2;'
           ptree = subject.parse(input)
-          parent = ptree.root.subnodes[0]
+          parent = ptree.root
           expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
           expect(parent.symbol.name).to eq('exprStmt')
           expr = parent.subnodes[0]
@@ -196,7 +186,7 @@ LOX_END
         it 'should parse the product of two number literals' do
           input = '12.34 * 0.3;'
           ptree = subject.parse(input)
-          parent = ptree.root.subnodes[0]
+          parent = ptree.root
           expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
           expect(parent.symbol.name).to eq('exprStmt')
           expr = parent.subnodes[0]
@@ -209,7 +199,7 @@ LOX_END
         it 'should parse multiple multiplicative operations' do
           input = '5 * 2 / 3;'
           ptree = subject.parse(input)
-          parent = ptree.root.subnodes[0]
+          parent = ptree.root
           expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
           expect(parent.symbol.name).to eq('exprStmt')
           expr = parent.subnodes[0]
@@ -225,7 +215,7 @@ LOX_END
         it 'should parse combination of terms and factors' do
           input = '5 + 2 / 3;'
           ptree = subject.parse(input)
-          parent = ptree.root.subnodes[0]
+          parent = ptree.root
           expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
           expect(parent.symbol.name).to eq('exprStmt')
           expr = parent.subnodes[0]
@@ -243,7 +233,7 @@ LOX_END
         it 'should parse the concatenation of two string literals' do
           input = '"Lo" + "ve";'
           ptree = subject.parse(input)
-          parent = ptree.root.subnodes[0]
+          parent = ptree.root
           expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
           expect(parent.symbol.name).to eq('exprStmt')
           expr = parent.subnodes[0]
@@ -259,7 +249,7 @@ LOX_END
         %w[> >= < <=].each do |predicate|
           input = "3 #{predicate} 2;"
           ptree = subject.parse(input)
-          parent = ptree.root.subnodes[0]
+          parent = ptree.root
           expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
           expect(parent.symbol.name).to eq('exprStmt')
           expr = parent.subnodes[0]
@@ -276,7 +266,7 @@ LOX_END
           %w[!= ==].each do |predicate|
             input = "3 #{predicate} 2;"
             ptree = subject.parse(input)
-            parent = ptree.root.subnodes[0]
+            parent = ptree.root
             expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
             expect(parent.symbol.name).to eq('exprStmt')
             expr = parent.subnodes[0]
@@ -290,7 +280,7 @@ LOX_END
         it 'should parse combination of equality expressions' do
           input = '5 != 2 == false; // A bit contrived example'
           ptree = subject.parse(input)
-          parent = ptree.root.subnodes[0]
+          parent = ptree.root
           expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
           expect(parent.symbol.name).to eq('exprStmt')
           expr = parent.subnodes[0]
@@ -309,7 +299,7 @@ LOX_END
           %w[or and].each do |connector|
             input = "5 > 2 #{connector} 3 <= 4;"
             ptree = subject.parse(input)
-            parent = ptree.root.subnodes[0]
+            parent = ptree.root
             expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
             expect(parent.symbol.name).to eq('exprStmt')
             expr = parent.subnodes[0]
@@ -329,7 +319,7 @@ LOX_END
         it 'should parse a combinations of logical expressions' do
           input = '4 > 3 and 1 < 2 or 4 >= 5;'
           ptree = subject.parse(input)
-          parent = ptree.root.subnodes[0]
+          parent = ptree.root
           expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
           expect(parent.symbol.name).to eq('exprStmt')
           expr = parent.subnodes[0]

data/spec/interpreter_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'spec_helper' # Use the RSpec framework
+require 'stringio'
+
+# Load the class under test
+require_relative '../lib/loxxy/interpreter'
+
+module Loxxy
+  # This spec contains the bare bones test for the Interpreter class.
+  # The execution of Lox code is tested elsewhere.
+  describe Interpreter do
+    let(:sample_cfg) do
+      { ostream: StringIO.new }
+    end
+    subject { Interpreter.new(sample_cfg) }
+
+    context 'Initialization:' do
+      it 'should accept a option Hash at initialization' do
+        expect { Interpreter.new(sample_cfg) }.not_to raise_error
+      end
+
+      it 'should know its config options' do
+        expect(subject.config).to eq(sample_cfg)
+      end
+    end # context
+
+    context 'Evaluating Lox code:' do
+      let(:hello_world) { 'print "Hello, world!";' }
+
+      it 'should print the hello world message' do
+        expect { subject.evaluate(hello_world) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('Hello, world!')
+      end
+    end # context
+  end # describe
+end # module

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: loxxy
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.0.12
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-08 00:00:00.000000000 Z
+date: 2021-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -84,12 +84,16 @@ files:
 - README.md
 - Rakefile
 - lib/loxxy.rb
+- lib/loxxy/ast/all_lox_nodes.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/ast/lox_noop_expr.rb
+- lib/loxxy/ast/lox_print_stmt.rb
+- lib/loxxy/back_end/engine.rb
 - lib/loxxy/datatype/all_datatypes.rb
 - lib/loxxy/datatype/boolean.rb
 - lib/loxxy/datatype/builtin_datatype.rb
@@ -103,12 +107,18 @@ files:
 - lib/loxxy/front_end/parser.rb
 - lib/loxxy/front_end/raw_parser.rb
 - lib/loxxy/front_end/scanner.rb
+- lib/loxxy/interpreter.rb
 - lib/loxxy/version.rb
 - loxxy.gemspec
+- spec/back_end/engine_spec.rb
+- spec/datatype/boolean_spec.rb
 - spec/datatype/lx_string_spec.rb
+- spec/datatype/nil_spec.rb
+- spec/datatype/number_spec.rb
 - spec/front_end/parser_spec.rb
 - spec/front_end/raw_parser_spec.rb
 - spec/front_end/scanner_spec.rb
+- spec/interpreter_spec.rb
 - spec/loxxy_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/famished-tiger/loxxy
@@ -136,8 +146,13 @@ signing_key:
 specification_version: 4
 summary: An implementation of the Lox programming language. WIP
 test_files:
+- spec/back_end/engine_spec.rb
+- spec/datatype/boolean_spec.rb
 - spec/datatype/lx_string_spec.rb
+- spec/datatype/nil_spec.rb
+- spec/datatype/number_spec.rb
 - spec/front_end/parser_spec.rb
 - spec/front_end/raw_parser_spec.rb
 - spec/front_end/scanner_spec.rb
+- spec/interpreter_spec.rb
 - spec/loxxy_spec.rb