loxxy 0.0.12 → 0.0.17

data/spec/datatype/number_spec.rb

@@ -22,9 +22,35 @@ module Loxxy
       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
+
+        it 'should compute the addition with another number' do
+          addition = subject + Number.new(10)
+          expect(addition == -2.34).to be_true
+        end
+
+        it 'should compute the subtraction with another number' do
+          subtraction = subject - Number.new(10)
+          expect(subtraction == -22.34).to be_true
+        end
       end
     end # describe
   end # module

data/spec/front_end/parser_spec.rb

@@ -64,7 +64,7 @@ module Loxxy
         it 'should parse a false literal' do
           input = 'false;'
           ptree = subject.parse(input)
-          leaf = ptree.root.subnodes[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 = ptree.root.subnodes[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 = ptree.root.subnodes[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 = ptree.root.subnodes[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 = ptree.root.subnodes[0]
+          leaf = ptree.root
           expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
           expect(leaf.literal).to be_equal(Datatype::Nil.instance)
         end
@@ -131,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
-          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)
@@ -144,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
-          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)
@@ -157,10 +151,7 @@ LOX_END
         it 'should parse multiple additive operations' do
           input = '5 + 2 - 3;'
           ptree = subject.parse(input)
-          parent = ptree.root
-          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)
@@ -173,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
-          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)
@@ -186,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
-          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)
@@ -199,10 +184,7 @@ LOX_END
         it 'should parse multiple multiplicative operations' do
           input = '5 * 2 / 3;'
           ptree = subject.parse(input)
-          parent = ptree.root
-          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)
@@ -215,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
-          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)
@@ -233,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
-          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')
@@ -249,10 +225,7 @@ LOX_END
         %w[> >= < <=].each do |predicate|
           input = "3 #{predicate} 2;"
           ptree = subject.parse(input)
-          parent = ptree.root
-          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)
@@ -266,10 +239,7 @@ LOX_END
           %w[!= ==].each do |predicate|
             input = "3 #{predicate} 2;"
             ptree = subject.parse(input)
-            parent = ptree.root
-            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)
@@ -280,10 +250,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
-          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)
@@ -299,10 +266,7 @@ LOX_END
           %w[or and].each do |connector|
             input = "5 > 2 #{connector} 3 <= 4;"
             ptree = subject.parse(input)
-            parent = ptree.root
-            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(connector.to_sym)
             expect(expr.operands[0]).to be_kind_of(Ast::LoxBinaryExpr)
@@ -319,10 +283,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
-          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(:or) # or has lower precedence than and
           expect(expr.operands[0]).to be_kind_of(Ast::LoxBinaryExpr)

data/spec/interpreter_spec.rb

@@ -25,9 +25,145 @@ module Loxxy
       end
     end # context
 
+    context 'Evaluating arithmetic operations code:' do
+      it 'should evaluate an addition of two numbers' do
+        result = subject.evaluate('123 + 456; // => 579')
+        expect(result).to be_kind_of(Loxxy::Datatype::Number)
+        expect(result == 579).to be_true
+      end
+
+      it 'should evaluate a subtraction of two numbers' do
+        result = subject.evaluate('4 - 3; // => 1')
+        expect(result).to be_kind_of(Loxxy::Datatype::Number)
+        expect(result == 1).to be_true
+      end
+
+      it 'should evaluate a multiplication of two numbers' do
+        result = subject.evaluate('5 * 3; // => 15')
+        expect(result).to be_kind_of(Loxxy::Datatype::Number)
+        expect(result == 15).to be_true
+      end
+
+      it 'should evaluate a division of two numbers' do
+        result = subject.evaluate('8 / 2; // => 4')
+        expect(result).to be_kind_of(Loxxy::Datatype::Number)
+        expect(result == 4).to be_true
+      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 evaluate string concatenation' do
+        result = subject.evaluate('"str" + "ing"; // => "string"')
+        expect(result).to be_kind_of(Loxxy::Datatype::LXString)
+        expect(result == 'string').to be_true
+      end
+
+      it 'should perform the equality tests of two values' do
+        [
+          ['nil == nil;', true],
+          ['true == true;', true],
+          ['true == false;', false],
+          ['1 == 1;', true],
+          ['1 == 2;', false],
+          ['0 == 0;', true],
+          ['"str" == "str";', true],
+          ['"str" == "ing";', false],
+          ['"" == "";', true],
+          ['nil == false;', false],
+          ['false == 0;', false],
+          ['0 == "0";', false]
+        ].each do |(source, predicted)|
+          lox = Loxxy::Interpreter.new
+          result = lox.evaluate(source)
+          expect(result.value == predicted).to be_truthy
+        end
+      end
+
+      it 'should perform the inequality test of two values' do
+        [
+          ['nil != nil;', false],
+          ['true != true;', false],
+          ['true != false;', true],
+          ['1 != 1;', false],
+          ['1 != 2;', true],
+          ['0 != 0;', false],
+          ['"str" != "str";', false],
+          ['"str" != "ing";', true],
+          ['"" != "";', false],
+          ['nil != false;', true],
+          ['false != 0;', true],
+          ['0 != "0";', true]
+        ].each do |(source, predicted)|
+          lox = Loxxy::Interpreter.new
+          result = lox.evaluate(source)
+          expect(result.value == predicted).to be_truthy
+        end
+      end
+
+      it 'should evaluate a comparison of two numbers' do
+        [
+          ['1 < 2;', true],
+          ['2 < 2;', false],
+          ['2 < 1;', false],
+          ['1 <= 2;', true],
+          ['2 <= 2;', true],
+          ['2 <= 1;', false],
+          ['1 > 2;', false],
+          ['2 > 2;', false],
+          ['2 > 1;', true],
+          ['1 >= 2;', false],
+          ['2 >= 2;', true],
+          ['2 >= 1;', true],
+          ['0 < -0;', false],
+          ['-0 < 0;', false],
+          ['0 > -0;', false],
+          ['-0 > 0;', false],
+          ['0 <= -0;', true],
+          ['-0 <= 0;', true],
+          ['0 >= -0;', true],
+          ['-0 >= 0;', true]
+        ].each do |(source, predicted)|
+          lox = Loxxy::Interpreter.new
+          result = lox.evaluate(source)
+          expect(result.value == predicted).to be_truthy
+        end
+      end
+
+      it 'should evaluate the change sign of a number' do
+        [
+          ['- 3;', -3],
+          ['- - 3;', 3],
+          ['- - - 3;', -3]
+        ].each do |(source, predicted)|
+          lox = Loxxy::Interpreter.new
+          result = lox.evaluate(source)
+          expect(result.value == predicted).to be_truthy
+        end
+      end
+
+      it 'should evaluate the negation of an object' do
+        [
+          ['!true;', false],
+          ['!false;', true],
+          ['!!true;', true],
+          ['!123;', false],
+          ['!0;', false],
+          ['!nil;', true],
+          ['!"";', false]
+        ].each do |(source, predicted)|
+          lox = Loxxy::Interpreter.new
+          result = lox.evaluate(source)
+          expect(result.value == predicted).to be_truthy
+        end
+      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!')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: loxxy
 version: !ruby/object:Gem::Version
-  version: 0.0.12
+  version: 0.0.17
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-09 00:00:00.000000000 Z
+date: 2021-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -93,6 +93,7 @@ files:
 - lib/loxxy/ast/lox_node.rb
 - lib/loxxy/ast/lox_noop_expr.rb
 - lib/loxxy/ast/lox_print_stmt.rb
+- lib/loxxy/ast/lox_unary_expr.rb
 - lib/loxxy/back_end/engine.rb
 - lib/loxxy/datatype/all_datatypes.rb
 - lib/loxxy/datatype/boolean.rb