loxxy 0.0.12 → 0.0.17

data/lib/loxxy/back_end/engine.rb

@@ -22,9 +22,10 @@ module Loxxy
         @stack = []
       end
 
-      # Given an abstract syntax parse tree visitor, luanch the visit
+      # Given an abstract syntax parse tree visitor, launch the visit
       # and execute the visit events in the output stream.
       # @param aVisitor [AST::ASTVisitor]
+      # @return [Loxxy::Datatype::BuiltinDatatype]
       def execute(aVisitor)
         aVisitor.subscribe(self)
         aVisitor.start
@@ -39,6 +40,29 @@ module Loxxy
         @ostream.print tos.to_str
       end
 
+      def after_binary_expr(aBinaryExpr)
+        op = aBinaryExpr.operator
+        operand2 = stack.pop
+        operand1 = stack.pop
+        if operand1.respond_to?(op)
+          stack.push operand1.send(op, operand2)
+        else
+          msg1 = "`#{op}': Unimplemented operator for a #{operand1.class}."
+          raise StandardError, msg1
+        end
+      end
+
+      def after_unary_expr(anUnaryExpr)
+        op = anUnaryExpr.operator
+        operand = stack.pop
+        if operand.respond_to?(op)
+          stack.push operand.send(op)
+        else
+          msg1 = "`#{op}': Unimplemented operator for a #{operand1.class}."
+          raise StandardError, msg1
+        end
+      end
+
       # @param literalExpr [Ast::LoxLiteralExpr]
       def before_literal_expr(literalExpr)
         stack.push(literalExpr.literal)

data/lib/loxxy/datatype/boolean.rb

@@ -8,6 +8,17 @@ module Loxxy
     # An instance acts merely as a wrapper around a Ruby representation
     # of the value.
     class Boolean < BuiltinDatatype
+      # Is this object representing a false value in Lox?
+      # @return [FalseClass, TrueClass]
+      def false?
+        false
+      end
+
+      # Is this object representing the true value in Lox?
+      # @return [FalseClass, TrueClass]
+      def true?
+        false
+      end
     end # class
   end # module
 end # module

data/lib/loxxy/datatype/builtin_datatype.rb

@@ -14,6 +14,34 @@ module Loxxy
         @value = validated_value(aValue)
       end
 
+      # Is the value considered falsey in Lox?
+      # Rule: false and nil are falsey and everything else is truthy.
+      # This test used in conditional statements (i.e. if, while)
+      def falsey?
+        false # Default implementation
+      end
+
+      # Is the value considered truthy in Lox?
+      # Rule: false and nil are falsey and everything else is truthy.
+      # This test used in conditional statements (i.e. if, while)
+      def truthy?
+        true # Default implementation
+      end
+
+      # Negation ('not')
+      # Returns a boolean with opposite truthiness value.
+      # @return [Datatype::Boolean]
+      def !
+        falsey? ? True.instance : False.instance
+      end
+
+      # Check for inequality of this object with another Lox object
+      # @param other [Datatype::BuiltinDatatype, Object]
+      # @return [Datatype::Boolean]
+      def !=(other)
+        !(self == other)
+      end
+
       # Method called from Lox to obtain the text representation of the boolean.
       # @return [String]
       def to_str

data/lib/loxxy/datatype/false.rb

@@ -13,6 +13,34 @@ module Loxxy
       def initialize
         super(false)
       end
+
+      # Is this object representing a false value in Lox?
+      # @return [TrueClass]
+      def false?
+        true
+      end
+
+      # Is the value considered falsey in Lox?
+      # Rule: false and nil are falsey and everything else is truthy.
+      # This test used in conditional statements (i.e. if, while)
+      def falsey?
+        true
+      end
+
+      # Is the value considered truthy in Lox?
+      # Rule: false and nil are falsey and everything else is truthy.
+      # This test used in conditional statements (i.e. if, while)
+      def truthy?
+        false
+      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
     end # class
 
     False.instance.freeze # Make the sole instance immutable

data/lib/loxxy/datatype/lx_string.rb

@@ -1,23 +1,39 @@
 # frozen_string_literal: true
 
-require_relative 'builtin_datatype'
+require_relative 'false'
+require_relative 'true'
 
 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]
-      # @return [Boolean]
+      # Check the equality 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
-          when String
-            value == other
+        when LXString
+          (value == other.value) ? True.instance : False.instance
+        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
+
+      # Perform the concatenation of two Lox stings or
+      # one Lox string and a Ruby String
+      # @param other [Loxxy::Datatype::LXString, String]
+      # @return [Loxxy::Datatype::LXString]
+      def +(other)
+        case other
+        when LXString
+          self.class.new(value + other.value)
+        when Numeric
+          self.class.new(value + other)
+        else
+          err_msg = "`+': #{other.class} can't be coerced into #{self.class} (TypeError)"
+          raise TypeError, err_msg
         end
       end
 

data/lib/loxxy/datatype/nil.rb

@@ -14,6 +14,28 @@ 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
+
+      # Is the value considered falsey in Lox?
+      # Rule: false and nil are falsey and everything else is truthy.
+      # This test used in conditional statements (i.e. if, while)
+      def falsey?
+        true
+      end
+
+      # Is the value considered truthy in Lox?
+      # Rule: false and nil are falsey and everything else is truthy.
+      # This test used in conditional statements (i.e. if, while)
+      def truthy?
+        false
+      end
+
       # Method called from Lox to obtain the text representation of nil.
       # @return [String]
       def to_str

data/lib/loxxy/datatype/number.rb

@@ -1,11 +1,142 @@
 # frozen_string_literal: true
 
-require_relative 'builtin_datatype'
+require_relative 'false'
+require_relative 'true'
 
 module Loxxy
   module Datatype
     # Class for representing a Lox numeric value.
     class Number < BuiltinDatatype
+      # Perform the addition 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 = "`+': #{other.class} can't be coerced into #{self.class} (TypeError)"
+          raise TypeError, err_msg
+        end
+      end
+
+      # Perform the subtraction 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 = "`-': #{other.class} can't be coerced into #{self.class} (TypeError)"
+          raise TypeError, err_msg
+        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
+
+      # Unary minus (return value with changed sign)
+      # @return [Loxxy::Datatype::Number]
+      def -@
+        self.class.new(-value)
+      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 whether this Lox number has a greater value than given argument.
+      # @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
+          msg = "'>': Operands must be numbers."
+          raise StandardError, msg
+        end
+      end
+
+      # Check whether this Lox number has a greater or equal value
+      # than given argument.
+      # @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
+          msg = "'>': Operands must be numbers."
+          raise StandardError, msg
+        end
+      end
+
+      # Check whether this Lox number has a lesser value than given argument.
+      # @param other [Datatype::Number, Numeric]
+      # @return [Datatype::Boolean]
+      def <(other)
+        !(self >= other)
+      end
+
+      # Check whether this Lox number has a lesser or equal value
+      # than given argument.
+      # @param other [Datatype::Number, Numeric]
+      # @return [Datatype::Boolean]
+      def <=(other)
+        !(self > other)
+      end
+
       protected
 
       def validated_value(aValue)

data/lib/loxxy/datatype/true.rb

@@ -13,6 +13,20 @@ module Loxxy
       def initialize
         super(true)
       end
+
+      # Is this object representing the true value in Lox?
+      # @return [TrueClass]
+      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

@@ -58,7 +58,7 @@ module Loxxy
       rule('statement' => 'whileStmt')
       rule('statement' => 'block')
 
-      rule('exprStmt' => 'expression SEMICOLON')
+      rule('exprStmt' => 'expression SEMICOLON').as 'exprStmt'
 
       rule('forStmt' => 'FOR LEFT_PAREN forControl RIGHT_PAREN statement')
       rule('forControl' => 'forInitialization forTest forUpdate')
@@ -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')

data/lib/loxxy/interpreter.rb

@@ -19,8 +19,10 @@ module Loxxy
       @config = theOptions
     end
 
-    # Evaluate the given Lox program
+    # 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

data/lib/loxxy/version.rb

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

data/spec/datatype/lx_string_spec.rb

@@ -26,12 +26,35 @@ module Loxxy
           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))
+        it 'compares with another Lox string' do
+          result = subject == LXString.new(sample_text.dup)
+          expect(result).to be_true
 
-          expect(subject).not_to eq('')
-          expect(subject).not_to eq('other-text')
+          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
+
+          result = subject == ''
+          expect(result).to be_false
+        end
+
+        it 'performs the concatenation with another string' do
+          concatenation = LXString.new('str') + LXString.new('ing')
+          expect(concatenation == 'string').to be_true
         end
       end
     end # describe