loxxy 0.0.15 → 0.0.20

data/lib/loxxy/datatype/true.rb

@@ -19,6 +19,14 @@ module Loxxy
       def true?
         true
       end
+
+      # Check for equality of a Lox True with another Lox object / Ruby true
+      # @param other [Datatype::True, TrueClass, Object]
+      # @return [Datatype::Boolean]
+      def ==(other)
+        thruthy = other.kind_of?(True) || other.kind_of?(TrueClass)
+        thruthy ? True.instance : False.instance
+      end
     end # class
 
     True.instance.freeze # Make the sole instance immutable

data/lib/loxxy/front_end/grammar.rb

@@ -68,9 +68,9 @@ module Loxxy
       rule('forTest' => 'expression_opt SEMICOLON')
       rule('forUpdate' => 'expression_opt')
 
-      rule('ifStmt' => 'IF ifCondition statement elsePart_opt')
-      rule('ifCondition' => 'LEFT_PAREN expression RIGHT_PAREN')
-      rule('elsePart_opt' => 'ELSE statement')
+      rule('ifStmt' => 'IF ifCondition statement elsePart_opt').as 'if_stmt'
+      rule('ifCondition' => 'LEFT_PAREN expression RIGHT_PAREN').as 'keep_symbol2'
+      rule('elsePart_opt' => 'ELSE statement').as 'keep_symbol2'
       rule('elsePart_opt' => [])
 
       rule('printStmt' => 'PRINT expression SEMICOLON').as 'print_stmt'
@@ -121,7 +121,7 @@ module Loxxy
       rule('multiplicative_plus' => 'multOp unary').as 'multiplicative_plus_end'
       rule('multOp' => 'SLASH')
       rule('multOp' => 'STAR')
-      rule('unary' => 'unaryOp unary')
+      rule('unary' => 'unaryOp unary').as 'unary_expr'
       rule('unary' => 'call')
       rule('unaryOp' => 'BANG')
       rule('unaryOp' => 'MINUS')
@@ -138,7 +138,7 @@ module Loxxy
       rule('primary' => 'NUMBER').as 'literal_expr'
       rule('primary' => 'STRING').as 'literal_expr'
       rule('primary' => 'IDENTIFIER')
-      rule('primary' => 'LEFT_PAREN expression RIGHT_PAREN')
+      rule('primary' => 'LEFT_PAREN expression RIGHT_PAREN').as 'grouping_expr'
       rule('primary' => 'SUPER DOT IDENTIFIER')
 
       # Utility rules

data/lib/loxxy/version.rb

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

data/spec/front_end/parser_spec.rb

@@ -262,12 +262,12 @@ LOX_END
       end # context
 
       context 'Parsing logical expressions' do
-        it 'should parse the logical operations betweentwo sub-expression' do
+        it 'should parse the logical operations between two 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).to be_kind_of(Ast::LoxLogicalExpr)
             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(:>)
@@ -284,9 +284,9 @@ LOX_END
           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).to be_kind_of(Ast::LoxLogicalExpr)
           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]).to be_kind_of(Ast::LoxLogicalExpr)
           expect(expr.operands[0].operator).to eq(:and)
           conjuncts = expr.operands[0].operands
           expect(conjuncts[0]).to be_kind_of(Ast::LoxBinaryExpr)

data/spec/interpreter_spec.rb

@@ -25,32 +25,231 @@ module Loxxy
       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
-
+    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 substraction of two numbers' do
+      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 evaluate the "conjunction" of two values' do
+        [
+          # Return the first falsey argument
+          ['false and 1;', false],
+          ['nil and 1;', nil],
+          ['true and 1;', 1],
+          ['1 and 2 and false;', false],
+          ['1 and 2 and nil;', nil],
+
+          # Return the last argument if all are truthy
+          ['1 and true;', true],
+          ['0 and true;', true],
+          ['"false" and 0;', 0],
+          ['1 and 2 and 3;', 3]
+
+          # TODO test short-circuit at first false argument
+        ].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 "disjunction" of two values' do
+        [
+          # Return the first truthy argument
+          ['1 or true;', 1],
+          ['false or 1;', 1],
+          ['nil or 1;', 1],
+          ['false or false or true;', true],
+          ['1 and 2 and nil;', nil],
+
+          # Return the last argument if all are falsey
+          ['false or false;', false],
+          ['nil or false;', false],
+          ['false or nil;', nil],
+          ['false or false or false;', false],
+          ['false or false or nil;', nil]
+
+          # TODO test short-circuit at first false argument
+        ].each do |(source, predicted)|
+          lox = Loxxy::Interpreter.new
+          result = lox.evaluate(source)
+          expect(result.value == predicted).to be_truthy
+        end
+      end
+
+      it 'should supprt expressions between parentheses' do
+        [
+          ['3 + 4 * 5;', 23],
+          ['(3 + 4) * 5;', 35],
+          ['(5 - (3 - 1)) + -(1);', 2]
+        ].each do |(source, predicted)|
+          lox = Loxxy::Interpreter.new
+          result = lox.evaluate(source)
+          expect(result.value == predicted).to be_truthy
+        end
+      end
+
+      it 'should evaluate an if statement' do
+        [
+          # Evaluate the 'then' expression if the condition is true.
+          ['if (true) print "then-branch";', 'then-branch'],
+          ['if (false) print "ignored";', ''],
+          # TODO: test with then block body
+          # TODO: test with assignment in if condition
+
+          # Evaluate the 'else' expression if the condition is false.
+          ['if (true) print "then-branch"; else print "else-branch";', 'then-branch'],
+          ['if (false) print "then-branch"; else print "else-branch";', 'else-branch'],
+          ['if (0) print "then-branch"; else print "else-branch";', 'then-branch'],
+          ['if (nil) print "then-branch"; else print "else-branch";', 'else-branch'],
+          # TODO: test with else block body
+
+          # TODO: A dangling else binds to the right-most if.
+          # ['if (true) if (false) print "bad"; else print "good";', 'good'],
+          # ['if (false) if (true) print "bad"; else print "worse";', 'bad']
+        ].each do |(source, predicted)|
+          io = StringIO.new
+          cfg = { ostream: io }
+          lox = Loxxy::Interpreter.new(cfg)
+          result = lox.evaluate(source)
+          expect(io.string).to eq(predicted)
+        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.15
+  version: 0.0.20
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-11 00:00:00.000000000 Z
+date: 2021-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -89,10 +89,14 @@ files:
 - lib/loxxy/ast/ast_visitor.rb
 - lib/loxxy/ast/lox_binary_expr.rb
 - lib/loxxy/ast/lox_compound_expr.rb
+- lib/loxxy/ast/lox_grouping_expr.rb
+- lib/loxxy/ast/lox_if_stmt.rb
 - lib/loxxy/ast/lox_literal_expr.rb
+- lib/loxxy/ast/lox_logical_expr.rb
 - 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