loxxy 0.0.9 → 0.0.14

data/lib/loxxy/interpreter.rb

@@ -0,0 +1,40 @@
+# 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.
+    # Return the result of the last executed expression (if any)
+    # @param lox_input [String] Lox program to evaluate
+    # @return [Loxxy::Datatype::BuiltinDatatype]
+    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.9'
+  VERSION = '0.0.14'
 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,12 +22,34 @@ module Loxxy
       end
 
       context 'Provided services:' do
-        it 'compares with another string' do
-          expect(subject).to eq(sample_text)
-          expect(subject).to eq(LXString.new(sample_text.dup))
+        it 'should give its display representation' do
+          expect(subject.to_str).to eq(sample_text)
+        end
+
+        it 'compares with another Lox string' do
+          result = subject == LXString.new(sample_text.dup)
+          expect(result).to be_true
+
+          result = subject == LXString.new('other-text')
+          expect(result).to be_false
+
+          result = subject == LXString.new('')
+          expect(result).to be_false
+
+          # Two empty strings are equal
+          result = LXString.new('') == LXString.new('')
+          expect(result).to be_true
+        end
+
+        it 'compares with a Ruby string' do
+          result = subject == sample_text.dup
+          expect(result).to be_true
+
+          result = subject == 'other-text'
+          expect(result).to be_false
 
-          expect(subject).not_to eq('')
-          expect(subject).not_to eq('other-text')
+          result = subject == ''
+          expect(result).to be_false
         end
       end
     end # describe

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,47 @@
+# 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 compare with other Lox numbers' do
+          result = subject == Number.new(sample_value)
+          expect(result).to be_true
+
+          result = subject == Number.new(5)
+          expect(result).to be_false
+        end
+
+        it 'should compare with Ruby numbers' do
+          result = subject == sample_value
+          expect(result).to be_true
+
+          result = subject == 5
+          expect(result).to be_false
+        end
+
+        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
           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
           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
             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
             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
           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,10 +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]
-          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
-          expect(parent.symbol.name).to eq('exprStmt')
-          expr = parent.subnodes[0]
+          expr = ptree.root
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:+)
           expect(expr.operands[0].literal.value).to eq(123)
@@ -154,10 +141,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]
-          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
-          expect(parent.symbol.name).to eq('exprStmt')
-          expr = parent.subnodes[0]
+          expr = ptree.root
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:-)
           expect(expr.operands[0].literal.value).to eq(4)
@@ -167,10 +151,7 @@ LOX_END
         it 'should parse multiple additive operations' do
           input = '5 + 2 - 3;'
           ptree = subject.parse(input)
-          parent = ptree.root.subnodes[0]
-          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
-          expect(parent.symbol.name).to eq('exprStmt')
-          expr = parent.subnodes[0]
+          expr = ptree.root
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:-)
           expect(expr.operands[0]).to be_kind_of(Ast::LoxBinaryExpr)
@@ -183,10 +164,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]
-          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
-          expect(parent.symbol.name).to eq('exprStmt')
-          expr = parent.subnodes[0]
+          expr = ptree.root
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:/)
           expect(expr.operands[0].literal.value).to eq(8)
@@ -196,10 +174,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]
-          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
-          expect(parent.symbol.name).to eq('exprStmt')
-          expr = parent.subnodes[0]
+          expr = ptree.root
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:*)
           expect(expr.operands[0].literal.value).to eq(12.34)
@@ -209,10 +184,7 @@ LOX_END
         it 'should parse multiple multiplicative operations' do
           input = '5 * 2 / 3;'
           ptree = subject.parse(input)
-          parent = ptree.root.subnodes[0]
-          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
-          expect(parent.symbol.name).to eq('exprStmt')
-          expr = parent.subnodes[0]
+          expr = ptree.root
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:/)
           expect(expr.operands[0]).to be_kind_of(Ast::LoxBinaryExpr)
@@ -225,10 +197,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]
-          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
-          expect(parent.symbol.name).to eq('exprStmt')
-          expr = parent.subnodes[0]
+          expr = ptree.root
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:+)
           expect(expr.operands[0].literal.value).to eq(5)
@@ -243,10 +212,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]
-          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
-          expect(parent.symbol.name).to eq('exprStmt')
-          expr = parent.subnodes[0]
+          expr = ptree.root
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:+)
           expect(expr.operands[0].literal.value).to eq('Lo')
@@ -255,20 +221,87 @@ LOX_END
       end # context
 
       context 'Parsing comparison expressions' do
-        it 'should parse the comparison of two number literals' do
-          %w[> >= < <=].each do |predicate|
+      it 'should parse the comparison of two number literals' do
+        %w[> >= < <=].each do |predicate|
+          input = "3 #{predicate} 2;"
+          ptree = subject.parse(input)
+          expr = ptree.root
+          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operator).to eq(predicate.to_sym)
+          expect(expr.operands[0].literal.value).to eq(3)
+          expect(expr.operands[1].literal.value).to eq(2)
+        end
+      end
+      end # context
+
+      context 'Parsing equality expressions' do
+        it 'should parse the equality of two number literals' do
+          %w[!= ==].each do |predicate|
             input = "3 #{predicate} 2;"
             ptree = subject.parse(input)
-            parent = ptree.root.subnodes[0]
-            expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
-            expect(parent.symbol.name).to eq('exprStmt')
-            expr = parent.subnodes[0]
+            expr = ptree.root
             expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
             expect(expr.operator).to eq(predicate.to_sym)
             expect(expr.operands[0].literal.value).to eq(3)
             expect(expr.operands[1].literal.value).to eq(2)
           end
         end
+
+        it 'should parse combination of equality expressions' do
+          input = '5 != 2 == false; // A bit contrived example'
+          ptree = subject.parse(input)
+          expr = ptree.root
+          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operator).to eq(:==)
+          expect(expr.operands[0]).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operands[0].operator).to eq(:!=)
+          expect(expr.operands[0].operands[0].literal.value).to eq(5)
+          expect(expr.operands[0].operands[1].literal.value).to eq(2)
+          expect(expr.operands[1].literal.value).to be_falsey
+        end
+      end # context
+
+      context 'Parsing logical expressions' do
+        it 'should parse the logical operations betweentwo sub-expression' do
+          %w[or and].each do |connector|
+            input = "5 > 2 #{connector} 3 <= 4;"
+            ptree = subject.parse(input)
+            expr = ptree.root
+            expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+            expect(expr.operator).to eq(connector.to_sym)
+            expect(expr.operands[0]).to be_kind_of(Ast::LoxBinaryExpr)
+            expect(expr.operands[0].operator).to eq(:>)
+            expect(expr.operands[0].operands[0].literal.value).to eq(5)
+            expect(expr.operands[0].operands[1].literal.value).to eq(2)
+            expect(expr.operands[1]).to be_kind_of(Ast::LoxBinaryExpr)
+            expect(expr.operands[1].operator).to eq(:<=)
+            expect(expr.operands[1].operands[0].literal.value).to eq(3)
+            expect(expr.operands[1].operands[1].literal.value).to eq(4)
+          end
+        end
+
+        it 'should parse a combinations of logical expressions' do
+          input = '4 > 3 and 1 < 2 or 4 >= 5;'
+          ptree = subject.parse(input)
+          expr = ptree.root
+          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operator).to eq(:or) # or has lower precedence than and
+          expect(expr.operands[0]).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operands[0].operator).to eq(:and)
+          conjuncts = expr.operands[0].operands
+          expect(conjuncts[0]).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(conjuncts[0].operator).to eq(:>)
+          expect(conjuncts[0].operands[0].literal.value).to eq(4)
+          expect(conjuncts[0].operands[1].literal.value).to eq(3)
+          expect(conjuncts[1]).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(conjuncts[1].operator).to eq(:<)
+          expect(conjuncts[1].operands[0].literal.value).to eq(1)
+          expect(conjuncts[1].operands[1].literal.value).to eq(2)
+          expect(expr.operands[1]).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operands[1].operator).to eq(:>=)
+          expect(expr.operands[1].operands[0].literal.value).to eq(4)
+          expect(expr.operands[1].operands[1].literal.value).to eq(5)
+        end
       end # context
     end # describe
   end # module