loxxy 0.0.8 → 0.0.13

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
           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,23 +174,17 @@ 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)
           expect(expr.operands[1].literal.value).to eq(0.3)
         end
 
-        it 'should parse multiple additive operations' do
+        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)
@@ -221,6 +193,115 @@ LOX_END
           expect(expr.operands[0].operands[1].literal.value).to eq(2)
           expect(expr.operands[1].literal.value).to eq(3)
         end
+
+        it 'should parse combination of terms and factors' do
+          input = '5 + 2 / 3;'
+          ptree = subject.parse(input)
+          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)
+          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(2)
+          expect(expr.operands[1].operands[1].literal.value).to eq(3)
+        end
+      end # context
+
+      context 'Parsing string concatenation' do
+        it 'should parse the concatenation of two string literals' do
+          input = '"Lo" + "ve";'
+          ptree = subject.parse(input)
+          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')
+          expect(expr.operands[1].literal.value).to eq('ve')
+        end
+      end # context
+
+      context 'Parsing comparison expressions' do
+      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)
+            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

data/spec/interpreter_spec.rb

@@ -0,0 +1,42 @@
+# 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 evaluate core data types' do
+        result = subject.evaluate('true; // Not false')
+        expect(result).to be_kind_of(Loxxy::Datatype::True)
+      end
+
+      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.8
+  version: 0.0.13
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-07 00:00:00.000000000 Z
+date: 2021-01-10 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