loxxy 0.0.13 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e689f37b8b4893aff00f320707982cc1b09c17258abee50d0ae82f2d9d9d04db
-  data.tar.gz: 57aa5e505c245cabd8f4e583a6300dbd5071b9ba580228103c4f9972c7679174
+  metadata.gz: 18b1d3e9f498ca8249775f55cc3950622d9f5a49cd67db912816cc60f15b3d16
+  data.tar.gz: 5766130089ebbe6d85a90a9f59ac1a505202c0e2646d4d7da93af025a80b0651
 SHA512:
-  metadata.gz: 9336292545bd83f18d8f1be0a820717dcbe33cbb3b912697ea3e5245b726a5d79810ca6613c07017aef9d766670008bf49f59f6948922f18433db4a0df94f41e
-  data.tar.gz: 149d09683e80f1d36a1939cfa13faefb1fc2bdae3b096bbde34d8824f67a305627018229e453b7b9655c78ae45b815726535a307125d238f6399df2c3d0f1aec
+  metadata.gz: 621832b48a5625081a0b82a8f8992d78709a1d4a053d8e4719140510242ce14d4418ca23c82d9f52186453c42d5d432203e7af496d7f92726f75622c743119e2
+  data.tar.gz: aa67901fae29e13d3154e274c7014fe2002fb7e054c62cf253e87e44ac421747db9f5f05ef1e108cd92c8c0124ceb93b31fa537de64f875607c096465f89aee4

data/README.md

@@ -74,10 +74,11 @@ require 'loxxy'
 
 lox = Loxxy::Interpreter.new
 
-lox_program = '12.34; // A fractional number'
+lox_program = '37 + 5; // THE answer'
 result = lox.evaluate(lox_program) # => Loxxy::Datatype::Number
 
-puts result.value # Output: 12.34
+# `result` is a Ruby object, so let's use it...
+puts result.value # Output: 42
 ```
 
 ## Example using RawParser class
@@ -130,11 +131,84 @@ program
 Although the interpreter should parse almost any valid Lox program,
 it currently can evaluate a tiny set of AST node (AST = Abstract Syntax Tree).
 
-Here are the language features supported by the interpreter:
-- Line comments,
-- All the Lox literals (booleans, numbers, strings and nil),
+Here are the language features currently supported by the interpreter:
+
+- [Comments](#comments)
+- [Keywords](#keywords)
+- [Operators and Special Chars](#operators-and-special-chars)
+- [Datatypes](#datatypes)
+- [Statements](#statements)
 - `print` statement.
 
+### Comments
+
+Loxxy supports single line C-style comments.
+
+```javascript
+// single line comment
+```
+
+### Keywords
+
+The parser knows all the __Lox__ reserved keywords:
+```lang-none
+and, class, else, false, fun, for, if, nil, or,
+print, return, super, this, true, var, while
+```
+Of these, the interpreter implements: `false`, `nil`, `true`
+
+### Operators and Special Chars
+#### Operators
+The parser recognizes all the __Lox__ operators, delimiters and separators:
+- Arithmetic operators: `+`, `-`, `*`, `/`
+- Comparison operators: `>`, `>=`, `<`, `<=`
+- Equality operators: `==`, `!=`
+
+Of these, the interpreter implements: 
+`+` (addition of two numbers or string concatenation)
+
+#### Delimiters
+The parser knows all the __Lox__ grouping delimiters:  
+(`, ), `{`, `}`
+
+These aren't yet implemented in the interpreter.
+
+The other characters that have a special meaning in __Lox__ are:
+- `,` Used in parameter list
+- `.` For the dot notation (i.e. calling a method)
+- `;` The semicolon is used to terminates expressions
+- `=` Assignment
+
+The parser recognizes them all but the interpreter accepts the semicolons only.
+
+### Datatypes
+
+Loxxy supports the following standard __Lox__ datatypes:
+- `Boolean`: Can be `true` or `false`
+- `Number`: Can be an integer or a floating-point numbers. For example: `123, 12.34, -45.67`
+- `String`: Sequence of characters surrounded by `"`. For example: `"Hello!"`
+- `Nil`: Used to define a null value, denoted by the `nil` keyword
+
+All the Lox literals (booleans, numbers, strings and nil),
+
+## Statements
+### Implemented expressions
+Loxxy implements expressions:
+- Consisting of literals only; or,
+- Addition of two numbers; or,
+- Concatenation of two strings
+
+### Implemented statements
+Loxxy implements the following statements:
+- Expressions (see above sub-section)
+- Print statement
+
+```javascript
+// Print statement with nested concatenation
+print "Hello" + ", " + "world!";
+```
+
+
 
 ## Installation
 

data/lib/loxxy/ast/ast_visitor.rb

@@ -59,6 +59,14 @@ module Loxxy
         broadcast(:after_print_stmt, aPrintStmt)
       end
 
+      # Visit event. The visitor is about to visit a print statement expression.
+      # @param aBinaryExpr [AST::LOXBinaryExpr] the binary expression node to visit
+      def visit_binary_expr(aBinaryExpr)
+        broadcast(:before_binary_expr, aBinaryExpr)
+        traverse_subnodes(aBinaryExpr)
+        broadcast(:after_binary_expr, aBinaryExpr)
+      end
+
       # Visit event. The visitor is visiting the
       # given terminal node containing a datatype object.
       # @param aLiteralExpr [AST::LoxLiteralExpr] the leaf node to visit.

data/lib/loxxy/ast/lox_binary_expr.rb

@@ -16,6 +16,12 @@ module Loxxy
         @operator = anOperator
       end
 
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [Ast::ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_binary_expr(self)
+      end
+
       alias operands subnodes
     end # class
   end # module

data/lib/loxxy/ast/lox_print_stmt.rb

@@ -11,7 +11,6 @@ module Loxxy
         super(aPosition, [anExpression])
       end
 
-      # Abstract method.
       # Part of the 'visitee' role in Visitor design pattern.
       # @param visitor [Ast::ASTVisitor] the visitor
       def accept(visitor)

data/lib/loxxy/back_end/engine.rb

@@ -40,6 +40,19 @@ module Loxxy
         @ostream.print tos.to_str
       end
 
+      def after_binary_expr(aBinaryExpr)
+        op = aBinaryExpr.operator
+        operand2 = stack.pop
+        operand1 = stack.pop
+        implemented = [:+].include?(op)
+        if implemented && operand1.respond_to?(op)
+          stack.push operand1.send(op, operand2)
+        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/false.rb

@@ -13,6 +13,12 @@ module Loxxy
       def initialize
         super(false)
       end
+
+      # Is this object representing a false value in Lox?
+      # @return [TrueClass]
+      def false?
+        true
+      end
     end # class
 
     False.instance.freeze # Make the sole instance immutable

data/lib/loxxy/datatype/lx_string.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'builtin_datatype'
+require_relative 'false'
+require_relative 'true'
 
 module Loxxy
   module Datatype
@@ -8,19 +9,35 @@ module Loxxy
     class LXString < BuiltinDatatype
       # Compare a Lox String with another Lox (or genuine Ruby) String
       # @param other [Datatype::LxString, String]
-      # @return [Boolean]
+      # @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
         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
+
       # Method called from Lox to obtain the text representation of the object.
       # @return [String]
       def to_str

data/lib/loxxy/datatype/number.rb

@@ -1,11 +1,43 @@
 # 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
+      # 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 numeric [Loxxy::Datatype::Number, Numeric]
+      # @return [Loxxy::Datatype::Number]
+      def +(numeric)
+        case numeric
+        when Number
+          self.class.new(value + numeric.value)
+        when Numeric
+          self.class.new(value + numeric)
+        else
+          err_msg = "`+': #{numeric.class} can't be coerced into #{self.class} (TypeError)"
+          raise TypeError, err_msg
+        end
+      end
+
       protected
 
       def validated_value(aValue)

data/lib/loxxy/datatype/true.rb

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

data/spec/datatype/lx_string_spec.rb

@@ -26,12 +26,30 @@ 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
       end
     end # describe

data/spec/datatype/number_spec.rb

@@ -22,6 +22,22 @@ 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

data/spec/interpreter_spec.rb

@@ -33,6 +33,18 @@ module Loxxy
         expect(result).to be_kind_of(Loxxy::Datatype::True)
       end
 
+      it 'should evaluate arithmetic operation' 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 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 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.13
+  version: 0.0.14
 platform: ruby
 authors:
 - Dimitri Geshef