loxxy 0.0.15 → 0.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7624afc97e5e8d3cee171dc9fbbe7a45c45698595109a5281d9f58fcaebd73ec
-  data.tar.gz: 67ec959b7758245f414314ea9c8b0a2bbf40a5e01133f17325fa40ab720858f0
+  metadata.gz: 7d7d30d3246aa8a8f06f3456d3996c680e9ddb4ed31bcf9fff99685702e50dd1
+  data.tar.gz: dc428ddd0fc03e153e70873bc2827b6e4aac813e5fdfba40ef2f28bfa7283fc2
 SHA512:
-  metadata.gz: adcb9cf6b353b09cf623df330fbdff35255571f8781dfd0b46ea6ab32c02cf55bd0130f94414cd91aa8cb798b1ea7cd4aef4844acc556147b5e4b387d099b8c0
-  data.tar.gz: 47230281481b965fe1dddd74f763568a0ca125454800984c41fb29629d26c37ae8f7fa0320a38ca784abe605dfb5dc14f4a9c26b0d269240ea07c5e2feb6241b
+  metadata.gz: d90f2494a324be036dae2f3d38636c571009b60f19d2b3d917b242ab98d231e03bb121f577e5598ac63514cc5817814972cabe927f05af2842a5a97c89eb69d9
+  data.tar.gz: e09a70a27baa1408904e1bfe512f4f523b8e4efd1aab00412b993c8f4a35b5498f1f6ddb5e67697108c80a91778301e41c15741451e73e1d869496d96441757a

data/CHANGELOG.md

@@ -1,3 +1,25 @@
+## [0.0.16] - 2021-01-11
+- The interpreter can evaluate product and division of two numbers.
+- It also implements equality `==` and inequality `!=` operators
+
+## Added
+- Method `Datatype::False#==` for equality testing
+- Method `Datatype::False#!=` for inequality testing
+- Method `Datatype::LXString#==` for equality testing
+- Method `Datatype::LXString#!=` for inequality testing
+- Method `Datatype::Nil#==` for equality testing
+- Method `Datatype::Nil#!=` for inequality testing
+- Method `Datatype::Number#==` for equality testing
+- Method `Datatype::Number#!=` for inequality testing
+- Method `Datatype::Number#*` for multiply operator
+- Method `Datatype::Number#/` for divide operator
+- Method `Datatype::True#==` for equality testing
+- Method `Datatype::True#!=` for inequality testing
+
+## Changed
+- Method `BackEnd::Engine#after_binary_expr` to allow `*`, `/`, `==`, `!=` operators
+- File `README.md` updated for the newly implemented operators
+
 ## [0.0.15] - 2021-01-11
 - The interpreter can evaluate substraction between two numbers.
 

data/README.md

@@ -166,6 +166,9 @@ The parser recognizes all the __Lox__ operators, delimiters and separators:
 Of these, the interpreter implements: 
 `+` (addition of two numbers or string concatenation)
 `-` (difference between two numbers)
+`*` (product of two numbers)
+`/` (division of two number)
+`==` and `!=` (in)equality testing of two Lox values
 
 #### Delimiters
 The parser knows all the __Lox__ grouping delimiters:  
@@ -193,9 +196,9 @@ loxxy supports  all the standard __Lox__ datatypes:
 ### Implemented expressions
 Loxxy implements expressions:
 - Plain literals only; or,
-- Addition of two numbers; or,
-- Subtraction of two numbers; or,  
-- Concatenation of two strings
+- Addition, subtraction, product and division of two numbers; or,
+- Concatenation of two strings,
+- (In)equality test of two Lox values
 
 ### Implemented statements
 Loxxy implements the following statements:

data/lib/loxxy/back_end/engine.rb

@@ -44,7 +44,7 @@ module Loxxy
         op = aBinaryExpr.operator
         operand2 = stack.pop
         operand1 = stack.pop
-        implemented = %i[+ -].include?(op)
+        implemented = %i[+ - * / == !=].include?(op)
         if implemented && operand1.respond_to?(op)
           stack.push operand1.send(op, operand2)
         else

data/lib/loxxy/datatype/false.rb

@@ -19,6 +19,22 @@ module Loxxy
       def false?
         true
       end
+
+      # Check for equality of a Lox False with another Lox object
+      # @param other [Datatype::BuiltinDatatype, FalseClass, Object]
+      # @return [Datatype::Boolean]
+      def ==(other)
+        falsey = other.kind_of?(False) || other.kind_of?(FalseClass)
+        falsey ? True.instance : False.instance
+      end
+
+      # Check for inequality of a Lox False with another Lox object
+      # @param other [Datatype::BuiltinDatatype, FalseClass, Object]
+      # @return [Datatype::Boolean]
+      def !=(other)
+        falsey = other.kind_of?(False) || other.kind_of?(FalseClass)
+        falsey ? False.instance : True.instance
+      end
     end # class
 
     False.instance.freeze # Make the sole instance immutable

data/lib/loxxy/datatype/lx_string.rb

@@ -7,8 +7,8 @@ module Loxxy
   module Datatype
     # Class for representing a Lox string of characters value.
     class LXString < BuiltinDatatype
-      # Compare a Lox String with another Lox (or genuine Ruby) String
-      # @param other [Datatype::LxString, String]
+      # Check the equality of a Lox String with another Lox object.
+      # @param other [Datatype::LxString, String, Object]
       # @return [Datatype::Boolean]
       def ==(other)
         case other
@@ -17,8 +17,21 @@ module Loxxy
         when String
           (value == other) ? True.instance : False.instance
         else
-          err_msg = "Cannot compare a #{self.class} with #{other.class}"
-          raise StandardError, err_msg
+          False.instance
+        end
+      end
+
+      # Check the inequality of a Lox String with another Lox object.
+      # @param other [Datatype::LxString, String, Object]
+      # @return [Datatype::Boolean]
+      def !=(other)
+        case other
+        when LXString
+          (value != other.value) ? True.instance : False.instance
+        when String
+          (value != other) ? True.instance : False.instance
+        else
+          True.instance
         end
       end
 

data/lib/loxxy/datatype/nil.rb

@@ -14,6 +14,22 @@ module Loxxy
         super(nil)
       end
 
+      # Check the equality with another object.
+      # @param other [Datatype::BuiltinDatatype, NilClass, Object]
+      # @return [Datatype::Boolean]
+      def ==(other)
+        is_nil = other.kind_of?(Nil) || other.kind_of?(NilClass)
+        is_nil ? True.instance : False.instance
+      end
+
+      # Check the inequality with another object.
+      # @param other [Datatype::BuiltinDatatype, NilClass, Object]
+      # @return [Datatype::Boolean]
+      def !=(other)
+        is_nil = other.kind_of?(Nil) || other.kind_of?(NilClass)
+        is_nil ? False.instance : True.instance
+      end
+
       # Method called from Lox to obtain the text representation of nil.
       # @return [String]
       def to_str

data/lib/loxxy/datatype/number.rb

@@ -7,21 +7,6 @@ module Loxxy
   module Datatype
     # Class for representing a Lox numeric value.
     class Number < BuiltinDatatype
-      # Compare a Lox Number with another Lox (or genuine Ruby) Number
-      # @param other [Datatype::Number, Numeric]
-      # @return [Datatype::Boolean]
-      def ==(other)
-        case other
-        when Number
-          (value == other.value) ? True.instance : False.instance
-        when Numeric
-          (value == other) ? True.instance : False.instance
-        else
-          err_msg = "Cannot compare a #{self.class} with #{other.class}"
-          raise StandardError, err_msg
-        end
-      end
-
       # Perform the addition of two Lox numbers or
       # one Lox number and a Ruby Numeric
       # @param other [Loxxy::Datatype::Number, Numeric]
@@ -54,6 +39,66 @@ module Loxxy
         end
       end
 
+      # Perform the multiplication of two Lox numbers or
+      # one Lox number and a Ruby Numeric
+      # @param other [Loxxy::Datatype::Number, Numeric]
+      # @return [Loxxy::Datatype::Number]
+      def *(other)
+        case other
+        when Number
+          self.class.new(value * other.value)
+        when Numeric
+          self.class.new(value * other)
+        else
+          err_msg = "'*': Operands must be numbers."
+          raise TypeError, err_msg
+        end
+      end
+
+      # Perform the division of two Lox numbers or
+      # one Lox number and a Ruby Numeric
+      # @param other [Loxxy::Datatype::Number, Numeric]
+      # @return [Loxxy::Datatype::Number]
+      def /(other)
+        case other
+        when Number
+          self.class.new(value / other.value)
+        when Numeric
+          self.class.new(value / other)
+        else
+          err_msg = "'/': Operands must be numbers."
+          raise TypeError, err_msg
+        end
+      end
+
+      # Check the equality of a Lox number object with another object
+      # @param other [Datatype::BuiltinDatatype, Numeric, Object]
+      # @return [Datatype::Boolean]
+      def ==(other)
+        case other
+        when Number
+          (value == other.value) ? True.instance : False.instance
+        when Numeric
+          (value == other) ? True.instance : False.instance
+        else
+          False.instance
+        end
+      end
+
+      # Check the inequality of a Lox number object with another object
+      # @param other [Datatype::BuiltinDatatype, Numeric, Object]
+      # @return [Datatype::Boolean]
+      def !=(other)
+        case other
+        when Number
+          (value != other.value) ? True.instance : False.instance
+        when Numeric
+          (value != other) ? True.instance : False.instance
+        else
+          True.instance
+        end
+      end
+
       protected
 
       def validated_value(aValue)

data/lib/loxxy/datatype/true.rb

@@ -19,6 +19,22 @@ module Loxxy
       def true?
         true
       end
+
+      # Check for equality of a Lox True with another Lox object
+      # @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
+
+      # Check for inequality of a Lox True with another Lox object
+      # @param other [Datatype::BuiltinDatatype, TrueClass, Object]
+      # @return [Datatype::Boolean]
+      def !=(other)
+        thruthy = other.kind_of?(True) || other.kind_of?(TrueClass)
+        thruthy ? False.instance : True.instance
+      end
     end # class
 
     True.instance.freeze # Make the sole instance immutable

data/lib/loxxy/version.rb

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

data/spec/interpreter_spec.rb

@@ -25,32 +25,88 @@ 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 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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: loxxy
 version: !ruby/object:Gem::Version
-  version: 0.0.15
+  version: 0.0.16
 platform: ruby
 authors:
 - Dimitri Geshef