loxxy 0.1.12 → 0.1.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 665b2f201c4e369bb46b4b62cd8398f8d1f6f563b073fb6e1595b767f306c627
-  data.tar.gz: 7bd3ca2024f2f05150d3fd8af9cdaee28d6dc4d2bbe48ebfe6ae9fd78166fc7f
+  metadata.gz: 172ec5df8e553332b497968f7b910383cb38314aabbdb84fdb42fba6986841ea
+  data.tar.gz: 3d72fd4f13f507f88e9e735e1ebdd0d63fd603b771f9cfb552b9aa38b5b3ca6a
 SHA512:
-  metadata.gz: 0cffb636754ac0140aa7873955c75d8e6a048a0806cacf22484de91bacecb4fdb7d55127f7ff6e2f5602ff02f1eb9f24de788a6be0053768c68f12b9cdd0caab
-  data.tar.gz: 331fb47a8a46a9ea6a086556814b95aba7d7a4d7a3c600f82acacfd38dd567c657ca79f6ce683e17e64e8104167692a2b49e7628bac9d8536a5bd0625ceab347
+  metadata.gz: 61073737ef6c069e6e1177fa79cdac543253e06ea63d2ca1b00517c08a06f46948fe7d51257308935d92579152793b4fe60bc0f5b901a1c931e5eafab9f35ecd
+  data.tar.gz: 57c87936451c3015511740d7d44f01d8f032a06e597bdfd1d133119413c227a61df11847f86a4be3a2b3440cc1f614a43b1144cceef05a58ade56ca1fa3c598b

data/CHANGELOG.md

@@ -1,3 +1,29 @@
+## [0.1.13] - 2021-04-05
+- `Loxxy` now implements method calls
+
+## New
+- Class `Ast::LoxGetExpr` a syntax node that represents a read access to an object property
+- Class `Ast::LoxSetExpr` a syntax node that represents a write access to an object property
+- Method `Ast::ASTBuilder#reduce_set_expr` parse action for write access to an object property
+- Method `Ast::ASTBuilder#reduce_get_expr` parse action for read access to an object property
+- Method `Ast::Visitor#visit_set_expr` visit of an `Ast::LoxSetExpr` node
+- Method `Ast::Visitor#visit_get_expr` visit of an `Ast::LoxGetExpr` node
+- Method `BackEnd::Engine#after_set_expr` runtime action for property setting
+- Method `BackEnd::Engine#after_get_expr` runtime action for property getting
+- Method `BackEnd::LoxInstance#set` implementation of write accessor
+- Method `BackEnd::LoxInstance#getr` implementation of read accessor
+- Method `BackEnd::Resolver#after_set_expr` resolve action for property setting
+- Method `BackEnd::Resolver#after_get_expr` resolve action for property getting
+
+## Changed
+- Method `Ast::ASTBuilder#reduce_assign_expr` expanded to support write access to an object property
+- Class `LoxClassStmt`: methods are now aggregate under the `body` attribute
+- Class `LoxFunStmt`: has a new attribute `is_method` and inherits from `Ast::LoxNode`
+- Method `BackEnd::Engine#after_class_stmt` methods are aggregated into the classes
+- Method `BackEnd::Engine#after_fun_stmt` extension for method
+- File `grammar.rb` added names to two syntax rules
+
+
 ## [0.1.12] - 2021-04-03
 - Intermediate version: `Loxxy` does instance creation (default constructor)
 

data/lib/loxxy/ast/all_lox_nodes.rb

@@ -4,11 +4,13 @@ require_relative 'lox_fun_stmt'
 require_relative 'lox_variable_expr'
 require_relative 'lox_literal_expr'
 require_relative 'lox_noop_expr'
+require_relative 'lox_get_expr'
 require_relative 'lox_call_expr'
 require_relative 'lox_grouping_expr'
 require_relative 'lox_unary_expr'
 require_relative 'lox_binary_expr'
 require_relative 'lox_logical_expr'
+require_relative 'lox_set_expr'
 require_relative 'lox_assign_expr'
 require_relative 'lox_block_stmt'
 require_relative 'lox_while_stmt'

data/lib/loxxy/ast/ast_builder.rb

@@ -269,10 +269,22 @@ module Loxxy
 
       # rule('assignment' => 'owner_opt IDENTIFIER EQUAL assignment')
       def reduce_assign_expr(_production, _range, tokens, theChildren)
-        var_name = theChildren[1].token.lexeme.dup
-        Ast::LoxAssignExpr.new(tokens[1].position, var_name, theChildren[3])
+        name_assignee = theChildren[1].token.lexeme.dup
+        if theChildren[0].kind_of?(Ast::LoxSetExpr)
+          theChildren[0].property = name_assignee
+          theChildren[0].subnodes << theChildren[3]
+          theChildren[0]
+        else
+          Ast::LoxAssignExpr.new(tokens[1].position, name_assignee, theChildren[3])
+        end
+      end
+
+      # rule('owner_opt' => 'call DOT')
+      def reduce_set_expr(_production, _range, tokens, theChildren)
+        Ast::LoxSetExpr.new(tokens[1].position, theChildren[0])
       end
 
+
       # rule('comparisonTest_plus' => 'comparisonTest_plus comparisonTest term').as 'comparison_t_plus_more'
       # TODO: is it meaningful to implement this rule?
 
@@ -317,6 +329,11 @@ module Loxxy
         LoxCallExpr.new(tokens[0].position, args)
       end
 
+      # rule('refinement' => 'DOT IDENTIFIER').as 'get_expr'
+      def reduce_get_expr(_production, _range, tokens, theChildren)
+        LoxGetExpr.new(tokens[0].position, theChildren[1].token.lexeme)
+      end
+
       # rule('primary' => 'LEFT_PAREN expression RIGHT_PAREN')
       def reduce_grouping_expr(_production, _range, tokens, theChildren)
         subexpr = theChildren[1]

data/lib/loxxy/ast/ast_visitor.rb

@@ -68,7 +68,7 @@ module Loxxy
       end
 
       # Visit event. The visitor is about to visit a class declaration.
-      # @param aXlassStmt [AST::LOXClassStmt] the for statement node to visit
+      # @param aClassStmt [AST::LOXClassStmt] the for statement node to visit
       def visit_class_stmt(aClassStmt)
         broadcast(:before_class_stmt, aClassStmt)
         traverse_subnodes(aClassStmt) # The methods are visited here...
@@ -131,6 +131,13 @@ module Loxxy
         broadcast(:after_assign_expr, anAssignExpr, self)
       end
 
+      # @param aSetExpr [AST::LOXGetExpr] the get expression node to visit
+      def visit_set_expr(aSetExpr)
+        broadcast(:before_set_expr, aSetExpr)
+        traverse_subnodes(aSetExpr)
+        broadcast(:after_set_expr, aSetExpr, self)
+      end
+
       # Visit event. The visitor is about to visit a logical expression.
       # Since logical expressions may take shorcuts by not evaluating all their
       # sub-expressiosns, they are responsible for visiting or not their children.
@@ -169,6 +176,12 @@ module Loxxy
         broadcast(:after_call_expr, aCallExpr, self)
       end
 
+      # @param aGetExpr [AST::LOXGetExpr] the get expression node to visit
+      def visit_get_expr(aGetExpr)
+        broadcast(:before_get_expr, aGetExpr)
+        broadcast(:after_get_expr, aGetExpr, self)
+      end
+
       # Visit event. The visitor is about to visit a grouping expression.
       # @param aGroupingExpr [AST::LoxGroupingExpr] grouping expression to visit
       def visit_grouping_expr(aGroupingExpr)
@@ -203,7 +216,6 @@ module Loxxy
       # @param aFunStmt [AST::LoxFunStmt] function declaration to visit
       def visit_fun_stmt(aFunStmt)
         broadcast(:before_fun_stmt, aFunStmt, self)
-        traverse_subnodes(aFunStmt)
         broadcast(:after_fun_stmt, aFunStmt, self)
       end
 

data/lib/loxxy/ast/lox_class_stmt.rb

@@ -5,14 +5,19 @@ require_relative 'lox_compound_expr'
 module Loxxy
   module Ast
     class LoxClassStmt < LoxCompoundExpr
+      # @return [String] the class name
       attr_reader :name
 
+      # @return [Array<Ast::LoxFunStmt>] the methods
+      attr_reader :body
+
       # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
       # @param condExpr [Loxxy::Ast::LoxNode] iteration condition
-      # @param theBody [Loxxy::Ast::LoxNode]
+      # @param theBody [Array<Loxxy::Ast::LoxNode>]
       def initialize(aPosition, aName, theMethods)
-        super(aPosition, theMethods)
+        super(aPosition, [])
         @name = aName.dup
+        @body = theMethods
       end
 
       # Part of the 'visitee' role in Visitor design pattern.
@@ -20,8 +25,6 @@ module Loxxy
       def accept(visitor)
         visitor.visit_class_stmt(self)
       end
-
-      alias body subnodes
     end # class
   end # module
 end # module

data/lib/loxxy/ast/lox_fun_stmt.rb

@@ -1,24 +1,26 @@
 # frozen_string_literal: true
 
-require_relative 'lox_compound_expr'
+require_relative 'lox_node'
 
 module Loxxy
   module Ast
     # rubocop: disable Style/AccessorGrouping
-    class LoxFunStmt < LoxCompoundExpr
+    class LoxFunStmt < LoxNode
       attr_reader :name
       attr_reader :params
       attr_reader :body
+      attr_accessor :is_method
 
       # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
       # @param aName [String]
       # @param arguments [Array<String>]
       # @param body [Ast::LoxBlockStmt]
       def initialize(aPosition, aName, paramList, aBody)
-        super(aPosition, [])
+        super(aPosition)
         @name = aName.dup
         @params = paramList
         @body = aBody
+        @is_method = false
       end
 
       # Part of the 'visitee' role in Visitor design pattern.

data/lib/loxxy/ast/lox_get_expr.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'lox_node'
+
+module Loxxy
+  module Ast
+    class LoxGetExpr < LoxNode
+      # @return [Ast::LoxNode] the object to which the property belongs to
+      attr_accessor :object
+
+      # @return [String] Name of an object property
+      attr_reader :property
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param aPropertyName [String] Name of an object property
+      def initialize(aPosition, aPropertyName)
+        super(aPosition)
+        @property = aPropertyName
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_get_expr(self)
+      end
+
+      alias callee= object=
+    end # class
+  end # module
+end # module

data/lib/loxxy/ast/lox_set_expr.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'lox_compound_expr'
+
+module Loxxy
+  module Ast
+    class LoxSetExpr < LoxCompoundExpr
+      # @return [Ast::LoxNode] the object to which the property belongs to
+      attr_reader :object
+
+      # @return [String] Name of an object property
+      attr_accessor :property
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param anObject [Ast::LoxNode] The object which the given property is being set
+      def initialize(aPosition, anObject)
+        super(aPosition, [])
+        @object = anObject
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_set_expr(self)
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/back_end/engine.rb

@@ -69,8 +69,15 @@ module Loxxy
         # Do nothing, subnodes were already evaluated
       end
 
-      def after_class_stmt(aClassStmt, _visitor)
-        klass = LoxClass.new(aClassStmt.name, aClassStmt.methods, self)
+      def after_class_stmt(aClassStmt, aVisitor)
+        # Convert LoxFunStmt into LoxFunction
+        meths = aClassStmt.body.map do |func_node|
+          func_node.is_method = true
+          func_node.accept(aVisitor)
+          stack.pop
+        end
+
+        klass = LoxClass.new(aClassStmt.name, meths, self)
         new_var = Variable.new(aClassStmt.name, klass)
         symbol_table.insert(new_var)
       end
@@ -153,6 +160,18 @@ module Loxxy
         variable.assign(value)
       end
 
+      def after_set_expr(aSetExpr, aVisitor)
+        value = stack.pop
+        # Evaluate object part
+        aSetExpr.object.accept(aVisitor)
+        assignee = stack.pop
+        unless assignee.kind_of?(LoxInstance)
+          raise StandardError, 'Only instances have fields.'
+        end
+
+        assignee.set(aSetExpr.property, value)
+      end
+
       def after_logical_expr(aLogicalExpr, visitor)
         op = aLogicalExpr.operator
         operand1 = stack.pop # only first operand was evaluated
@@ -235,6 +254,16 @@ module Loxxy
         end
       end
 
+      def after_get_expr(aGetExpr, aVisitor)
+        aGetExpr.object.accept(aVisitor)
+        instance = stack.pop
+        unless instance.kind_of?(LoxInstance)
+          raise StandardError, 'Only instances have properties.'
+        end
+
+        stack.push instance.get(aGetExpr.property)
+      end
+
       def after_grouping_expr(_groupingExpr)
         # Do nothing: work was already done by visiting /evaluating the subexpression
       end
@@ -242,7 +271,7 @@ module Loxxy
       def after_variable_expr(aVarExpr, aVisitor)
         var_name = aVarExpr.name
         var = variable_lookup(aVarExpr)
-        raise StandardError, "Unknown variable #{var_name}" unless var
+        raise StandardError, "Undefined variable '#{var_name}'." unless var
 
         var.value.accept(aVisitor) # Evaluate variable value then push on stack
       end
@@ -259,8 +288,12 @@ module Loxxy
 
       def after_fun_stmt(aFunStmt, _visitor)
         function = LoxFunction.new(aFunStmt.name, aFunStmt.params, aFunStmt.body, self)
-        new_var = Variable.new(aFunStmt.name, function)
-        symbol_table.insert(new_var)
+        if aFunStmt.is_method
+          stack.push function
+        else
+          new_var = Variable.new(aFunStmt.name, function)
+          symbol_table.insert(new_var)
+        end
       end
 
       private

data/lib/loxxy/back_end/lox_class.rb

@@ -10,15 +10,18 @@ module Loxxy
       # @return [String] The name of the class
       attr_reader :name
 
-      # @return [Array<>] the list of methods
-      attr_reader :methods
+      # @return [Hash{String => LoxFunction}] the list of methods
+      attr_reader :meths
       attr_reader :stack
 
       # Create a class with given name
       # @param aName [String] The name of the class
       def initialize(aName, theMethods, anEngine)
         @name = aName.dup
-        @methods = theMethods
+        @meths = {}
+        theMethods.each do |func|
+          meths[func.name] = func
+        end
         @stack = anEngine.stack
       end
 
@@ -35,6 +38,11 @@ module Loxxy
         engine.stack.push(instance)
       end
 
+      # @param aName [String] the method name to search for
+      def find_method(aName)
+        meths[aName]
+      end
+
       # Logical negation.
       # As a function is a truthy thing, its negation is thus false.
       # @return [Datatype::False]

data/lib/loxxy/back_end/lox_instance.rb

@@ -6,16 +6,20 @@ module Loxxy
   module BackEnd
     # Runtime representation of a Lox object (instance).
     class LoxInstance
-      # @return BackEnd::LoxClass] the class this this object belong
+      # @return BackEnd::LoxClass] the class that this object is an instance of
       attr_reader :klass
 
       attr_reader :stack
 
+      # @return [Hash{String => BuiltinDatatype | LoxFunction | LoxInstance }]
+      attr_reader :fields
+
       # Create an instance from given class
       # @param aClass [BackEnd::LoxClass] the class this this object belong
       def initialize(aClass, anEngine)
         @klass = aClass
         @stack = anEngine.stack
+        @fields = {}
       end
 
       def accept(_visitor)
@@ -26,6 +30,29 @@ module Loxxy
       def to_str
         "#{klass.to_str} instance"
       end
+
+      # Look up the value of property with given name
+      # aName [String] name of object property
+      def get(aName)
+        return fields[aName] if fields.include? aName
+
+        method = klass.find_method(aName)
+        unless method
+          raise StandardError, "Undefined property '#{aName}'."
+        end
+
+        method
+      end
+
+      # Set the value of property with given name
+      # aName [String] name of object property
+      def set(aName, aValue)
+        unless fields.include? aName
+          raise StandardError, "Undefined property '#{aName}'."
+        end
+
+        fields[aName] = aValue
+      end
     end # class
   end # module
 end # module

data/lib/loxxy/back_end/resolver.rb

@@ -58,8 +58,11 @@ module Loxxy
         declare(aClassStmt.name)
       end
 
-      def after_class_stmt(aClassStmt, _visitor)
+      def after_class_stmt(aClassStmt, aVisitor)
         define(aClassStmt.name)
+        aClassStmt.body.each do |fun_stmt|
+          resolve_function(fun_stmt, :method, aVisitor)
+        end
       end
 
       def before_for_stmt(aForStmt)
@@ -109,6 +112,11 @@ module Loxxy
         resolve_local(anAssignExpr, aVisitor)
       end
 
+      def after_set_expr(aSetExpr, aVisitor)
+        # Evaluate object part
+        aSetExpr.object.accept(aVisitor)
+      end
+
       # Variable expressions require their variables resolved
       def before_variable_expr(aVarExpr)
         var_name = aVarExpr.name
@@ -127,6 +135,11 @@ module Loxxy
         aCallExpr.arguments.reverse_each { |arg| arg.accept(aVisitor) }
       end
 
+      def after_get_expr(aGetExpr, aVisitor)
+        # Evaluate object part
+        aGetExpr.object.accept(aVisitor)
+      end
+
       # function declaration creates a new scope for its body & binds its parameters for that scope
       def before_fun_stmt(aFunStmt, aVisitor)
         declare(aFunStmt.name)

data/lib/loxxy/front_end/grammar.rb

@@ -87,7 +87,7 @@ module Loxxy
       rule('expression' => 'assignment')
       rule('assignment' => 'owner_opt IDENTIFIER EQUAL assignment').as 'assign_expr'
       rule('assignment' => 'logic_or')
-      rule('owner_opt' => 'call DOT')
+      rule('owner_opt' => 'call DOT').as 'set_expr'
       rule('owner_opt' => [])
       rule('logic_or' => 'logic_and')
       rule('logic_or' => 'logic_and disjunct_plus').as 'logical_expr'
@@ -132,7 +132,7 @@ module Loxxy
       rule('refinement_plus' => 'refinement_plus refinement').as 'refinement_plus_more'
       rule('refinement_plus' => 'refinement').as 'refinement_plus_end'
       rule('refinement' => 'LEFT_PAREN arguments_opt RIGHT_PAREN').as 'call_arglist'
-      rule('refinement' => 'DOT IDENTIFIER')
+      rule('refinement' => 'DOT IDENTIFIER').as 'get_expr'
       rule('primary' => 'TRUE').as 'literal_expr'
       rule('primary' => 'FALSE').as 'literal_expr'
       rule('primary' => 'NIL').as 'literal_expr'

data/lib/loxxy/version.rb

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

data/spec/front_end/parser_spec.rb

@@ -305,6 +305,83 @@ LOX_END
           expect(expr.operands[1].operands[1].literal.value).to eq(5)
         end
       end # context
+
+      context 'Object orientation:' do
+        it 'should parse object property get access' do
+          input = 'print someObject.someProperty;'
+          ptree = subject.parse(input)
+          expr = ptree.root.subnodes[0]
+          expect(expr).to be_kind_of(Ast::LoxPrintStmt)
+          get_expr = expr.subnodes[0]
+          expect(get_expr).to be_kind_of(Ast::LoxGetExpr)
+          expect(get_expr.object.name).to eq('someObject')
+          expect(get_expr.property).to eq('someProperty')
+        end
+
+        it 'should parse nested call expressions' do
+          input = 'print egg.scramble(3).with(cheddar);'
+          # From section 12.3.1, one expects something like:
+          # LoxCallExpr
+          # +- arguments = ['cheddar']
+          # +- callee = LoxGetExpr
+          #    +- property = 'with'
+          #    +- object = LoxCallExpr
+          #       +- arguments = [3]
+          #       +- callee = LoxGetExpr
+          #          +- property = 'scramble'
+          #          +- object = variable 'egg'
+          ptree = subject.parse(input)
+          print_stmt = ptree.root.subnodes[0]
+          expect(print_stmt).to be_kind_of(Ast::LoxPrintStmt)
+          outer_call = print_stmt.subnodes[0]
+          expect(outer_call).to be_kind_of(Ast::LoxCallExpr)
+          expect(outer_call.arguments[0].name).to eq('cheddar')
+          expect(outer_call.callee).to be_kind_of(Ast::LoxGetExpr)
+          expect(outer_call.callee.property).to eq('with')
+          inner_call = outer_call.callee.object
+          expect(inner_call).to be_kind_of(Ast::LoxCallExpr)
+          expect(inner_call.arguments[0].literal).to eq(3)
+          expect(inner_call.callee).to be_kind_of(Ast::LoxGetExpr)
+          expect(inner_call.callee.property).to eq('scramble')
+          expect(inner_call.callee.object.name).to eq('egg')
+        end
+
+        it 'should parse object property set access' do
+          input = 'someObject.someProperty = value;'
+          ptree = subject.parse(input)
+          expr = ptree.root.subnodes[0]
+          expect(expr).to be_kind_of(Ast::LoxSetExpr)
+          expect(expr.object.name).to eq('someObject')
+          expect(expr.property).to eq('someProperty')
+          expect(expr.subnodes[0]).to be_kind_of(Ast::LoxVariableExpr)
+          expect(expr.subnodes[0].name).to eq('value')
+        end
+
+        it 'should parse complex set access' do
+          input = 'breakfast.omelette.filling.meat = ham;'
+          # From section 12.3.2, one expects something like:
+          # LoxSetExpr
+          # +- property = 'meat'
+          # +- subnodes[0] = LoxVariableExpr 'ham'
+          # +- object = LoxGetExpr
+          #    +- property = 'filling'
+          #    +- object = LoxGetExpr
+          #       +- property = 'omelette'
+          #       +- object = LoxVariableExpr 'breakfast'
+          ptree = subject.parse(input)
+          expr = ptree.root.subnodes[0]
+          expect(expr).to be_kind_of(Ast::LoxSetExpr)
+          expect(expr.property).to eq('meat')
+          expect(expr.subnodes[0]).to be_kind_of(Ast::LoxVariableExpr)
+          expect(expr.subnodes[0].name).to eq('ham')
+          expect(expr.object).to be_kind_of(Ast::LoxGetExpr)
+          expect(expr.object.property).to eq('filling')
+          expect(expr.object.object).to be_kind_of(Ast::LoxGetExpr)
+          expect(expr.object.object.property).to eq('omelette')
+          expect(expr.object.object.object).to be_kind_of(Ast::LoxVariableExpr)
+          expect(expr.object.object.object.name).to eq('breakfast')
+        end
+      end # context
     end # describe
   end # module
 end # module

data/spec/interpreter_spec.rb

@@ -451,8 +451,19 @@ LOX_END
       end
       # rubocop: enable Style/StringConcatenation
 
-      it 'should support class declaration' do
+      it 'should print the hello world message' do
         program = <<-LOX_END
+          var greeting = "Hello"; // Declaring a variable
+          print greeting + ", " + "world!"; // ... Playing with concatenation
+        LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('Hello, world!')
+      end
+    end # context
+
+    context 'Object orientation:' do
+      let(:duck_class) do
+        snippet = <<-LOX_END
           class Duck {
             noise() {
               quack();
@@ -462,33 +473,41 @@ LOX_END
               print "quack";
             }
           }
-          print Duck;
+        LOX_END
+
+        snippet
+      end
+
+      it 'should support class declaration' do
+        program = <<-LOX_END
+          #{duck_class}
+
+          print Duck; // Class names can appear in statements
         LOX_END
         expect { subject.evaluate(program) }.not_to raise_error
         expect(sample_cfg[:ostream].string).to eq('Duck')
       end
 
-      it 'should support instance creation' do
+      it 'should support default instance creation' do
         program = <<-LOX_END
-          class Duck {
-            quack() {
-              print "quack";
-            }
-          }
-          var daffy = Duck();
+          #{duck_class}
+
+          var daffy = Duck(); // Default constructor
           print daffy;
         LOX_END
         expect { subject.evaluate(program) }.not_to raise_error
         expect(sample_cfg[:ostream].string).to eq('Duck instance')
       end
 
-      it 'should print the hello world message' do
+      it 'should support calls to method' do
         program = <<-LOX_END
-          var greeting = "Hello"; // Declaring a variable
-          print greeting + ", " + "world!"; // ... Playing with concatenation
+          #{duck_class}
+
+          var daffy = Duck(); // Default constructor
+          daffy.quack();
         LOX_END
         expect { subject.evaluate(program) }.not_to raise_error
-        expect(sample_cfg[:ostream].string).to eq('Hello, world!')
+        expect(sample_cfg[:ostream].string).to eq('quack')
       end
     end # context
   end # describe

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: loxxy
 version: !ruby/object:Gem::Version
-  version: 0.1.12
+  version: 0.1.13
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-03 00:00:00.000000000 Z
+date: 2021-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -97,6 +97,7 @@ files:
 - lib/loxxy/ast/lox_compound_expr.rb
 - lib/loxxy/ast/lox_for_stmt.rb
 - lib/loxxy/ast/lox_fun_stmt.rb
+- lib/loxxy/ast/lox_get_expr.rb
 - lib/loxxy/ast/lox_grouping_expr.rb
 - lib/loxxy/ast/lox_if_stmt.rb
 - lib/loxxy/ast/lox_literal_expr.rb
@@ -106,6 +107,7 @@ files:
 - lib/loxxy/ast/lox_print_stmt.rb
 - lib/loxxy/ast/lox_return_stmt.rb
 - lib/loxxy/ast/lox_seq_decl.rb
+- lib/loxxy/ast/lox_set_expr.rb
 - lib/loxxy/ast/lox_unary_expr.rb
 - lib/loxxy/ast/lox_var_stmt.rb
 - lib/loxxy/ast/lox_variable_expr.rb