rupkl 0.1.0 → 0.2.0

data/lib/rupkl/node/operation.rb

@@ -3,36 +3,50 @@
 module RuPkl
   module Node
     module OperationCommon
-      def to_ruby(scopes)
-        evaluate(scopes).to_ruby(nil)
-      end
+      include NodeCommon
 
-      def to_string(scopes)
-        evaluate(scopes).to_string(nil)
+      def initialize(parent, operator, *operands, position)
+        super(parent, *operands, position)
+        @operator = operator
+        @operands = operands
       end
 
-      def to_pkl_string(scopes)
-        evaluate(scopes).to_pkl_string(nil)
+      attr_reader :operator
+      attr_reader :operands
+
+      def copy(parent = nil)
+        copied_operands = operands.map(&:copy)
+        self.class.new(parent, operator, *copied_operands, position)
       end
 
       private
 
-      def s_op(scopes)
-        r = receiver.evaluate(scopes)
+      def s_op(context)
+        r = receiver.evaluate(context)
         check_operator(r)
 
-        k = key.evaluate(scopes)
+        k = key.evaluate(context)
         check_key_operand(r, k)
 
-        r.find_by_key(k) ||
+        (v = r.find_by_key(k)) ||
           begin
-            message = "cannot find key '#{k.to_pkl_string(scopes)}'"
+            message = "cannot find key '#{k.to_pkl_string(context)}'"
             raise EvaluationError.new(message, position)
           end
+
+        v.evaluate
       end
 
-      def u_op(scopes)
-        o = operand.evaluate(scopes)
+      def non_null_op(context)
+        o = operand.evaluate(context)
+        return o unless o.null?
+
+        m = "expected a non-null value but got '#{o.to_pkl_string(context)}'"
+        raise EvaluationError.new(m, position)
+      end
+
+      def u_op(context)
+        o = operand.evaluate(context)
         check_operator(o)
 
         result =
@@ -44,18 +58,26 @@ module RuPkl
         create_op_result(result)
       end
 
-      def b_op(scopes)
-        l = l_operand.evaluate(scopes)
+      def b_op(context)
+        l = l_operand.evaluate(context)
         check_operator(l)
         return l if short_circuit?(l)
 
-        r = r_operand.evaluate(scopes)
+        r = r_operand.evaluate(context)
         check_r_operand(l, r)
+          .then { return _1 if _1 }
 
         l, r = l.coerce(operator, r)
         create_op_result(l.__send__(ruby_op, r))
       end
 
+      def null_coalescing_op(context)
+        l = l_operand.evaluate(context)
+        return l unless l.null?
+
+        r_operand.evaluate(context)
+      end
+
       def check_operator(operand)
         undefined_operator?(operand) &&
           begin
@@ -87,13 +109,16 @@ module RuPkl
       end
 
       def check_r_operand(l_operand, r_operand)
-        invalid_r_operand?(l_operand, r_operand) &&
-          begin
-            message =
-              "invalid operand type #{r_operand.class.basename} is given " \
-              "for operator '#{operator}'"
-            raise EvaluationError.new(message, position)
-          end
+        return unless invalid_r_operand?(l_operand, r_operand)
+
+        if [:==, :'!='].include?(operator)
+          create_op_result(operator != :==)
+        else
+          message =
+            "invalid operand type #{r_operand.class.basename} is given " \
+            "for operator '#{operator}'"
+          raise EvaluationError.new(message, position)
+        end
       end
 
       def invalid_r_operand?(l_operand, r_operand)
@@ -115,10 +140,10 @@ module RuPkl
 
       def create_op_result(result)
         case result
-        when ::Integer then Integer.new(result, position)
-        when ::Float then Float.new(result, position)
-        when ::String then String.new(result, nil, position)
-        when ::TrueClass, ::FalseClass then Boolean.new(result, position)
+        when ::Integer then Int.new(parent, result, position)
+        when ::Float then Float.new(parent, result, position)
+        when ::String then String.new(parent, result, nil, position)
+        when true, false then Boolean.new(parent, result, position)
         end
       end
     end
@@ -126,60 +151,72 @@ module RuPkl
     class SubscriptOperation
       include OperationCommon
 
-      def initialize(receiver, key, position)
-        @receiver = receiver
-        @key = key
-        @position = position
+      def receiver
+        operands.first
+      end
+
+      def key
+        operands.last
       end
 
-      attr_reader :receiver
-      attr_reader :key
-      attr_reader :position
+      def evaluate(context = nil)
+        s_op(context)
+      end
+    end
+
+    class NonNullOperation
+      include OperationCommon
 
-      def operator
-        :[]
+      def operand
+        operands.first
       end
 
-      def evaluate(scopes)
-        s_op(scopes)
+      def evaluate(context = nil)
+        non_null_op(context)
       end
     end
 
     class UnaryOperation
       include OperationCommon
 
-      def initialize(operator, operand, position)
-        @operator = operator
-        @operand = operand
-        @position = position
+      def operand
+        operands.first
       end
 
-      attr_reader :operator
-      attr_reader :operand
-      attr_reader :position
-
-      def evaluate(scopes)
-        u_op(scopes)
+      def evaluate(context = nil)
+        u_op(context)
       end
     end
 
     class BinaryOperation
       include OperationCommon
 
-      def initialize(operator, l_operand, r_operand, position)
-        @operator = operator
-        @l_operand = l_operand
-        @r_operand = r_operand
-        @position = position
+      def l_operand
+        operands.first
       end
 
-      attr_reader :operator
-      attr_reader :l_operand
-      attr_reader :r_operand
-      attr_reader :position
+      def r_operand
+        operands.last
+      end
+
+      def evaluate(context = nil)
+        b_op(context)
+      end
+    end
+
+    class NullCoalescingOperation
+      include OperationCommon
+
+      def l_operand
+        operands.first
+      end
+
+      def r_operand
+        operands.last
+      end
 
-      def evaluate(scopes)
-        b_op(scopes)
+      def evaluate(context = nil)
+        null_coalescing_op(context)
       end
     end
   end

data/lib/rupkl/node/pkl_module.rb

@@ -2,45 +2,33 @@
 
 module RuPkl
   module Node
-    class PklModule
+    class PklModule < Any
       include StructCommon
 
-      def initialize(items, position)
-        @position = position
-        items&.each do |item|
-          case item
-          when PklClassProperty then add_property(item)
-          end
-        end
+      abstract_class
+      klass_name :Module
+
+      def properties
+        @body&.properties(visibility: :object)
       end
 
-      attr_reader :properties
-      attr_reader :position
+      def pkl_methods
+        @body&.pkl_methods
+      end
 
-      def evaluate(scopes)
-        push_scope(scopes) do |s|
-          self.class.new(evaluate_properties(s), position)
-        end
+      def pkl_classes
+        @body&.pkl_classes
       end
 
-      def to_ruby(scopes)
-        push_scope(scopes) do |s|
-          create_pkl_object(s, properties, nil, nil)
-        end
+      def evaluate(context = nil)
+        resolve_structure(context)
+        super
       end
 
       private
 
-      def add_property(property)
-        (@properties ||= []) << property
-      end
-
-      def evaluate_properties(scopes)
-        properties&.each_with_object([]) do |property, result|
-          property
-            .evaluate(scopes)
-            .then { add_hash_member(result, _1, :name) }
-        end
+      def properties_not_allowed?
+        false
       end
     end
   end

data/lib/rupkl/node/reference_resolver.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    module ReferenceResolver
+      private
+
+      def resolve_member_reference(context, target, receiver, nullable)
+        scopes, raise_error, ifnone =
+          if receiver
+            evaluate_receiver(receiver, context)&.then do |r|
+              [[r], raise_error?(r, nullable), ifnone_value(r)]
+            end
+          else
+            exec_on(context) do |c|
+              [[c&.objects&.last, Base.instance, *c&.scopes], true]
+            end
+          end
+        find_member(scopes, target, raise_error, ifnone)
+      end
+
+      def raise_error?(receiver, nullable)
+        !(nullable && receiver&.null?)
+      end
+
+      def evaluate_receiver(receiver, context)
+        return unless receiver
+
+        if receiver.structure?
+          receiver
+            .resolve_reference(context)
+            .resolve_structure(context)
+        else
+          receiver.evaluate(context)
+        end
+      end
+
+      def find_member(scopes, target, raise_error, ifnone)
+        if scope_index.index
+          get_member_node(scopes[scope_index.index], target)
+        else
+          search_member(scopes, target, raise_error, ifnone)
+        end
+      end
+
+      def search_member(scopes, target, raise_error, ifnone)
+        node, index = search_member_from_scopes(scopes, target)
+        if node
+          scope_index.index = index
+          return node
+        end
+
+        raise_error &&
+          (raise unresolve_reference_error(target))
+
+        ifnone
+      end
+
+      def search_member_from_scopes(scopes, target)
+        scopes.reverse_each.with_index do |scope, i|
+          node = get_member_node(scope, target)
+          return [node, scopes.size - i - 1] if node
+        end
+
+        nil
+      end
+
+      ScopeIndex = Struct.new(:index)
+
+      def scope_index
+        @scope_index ||= ScopeIndex.new
+      end
+
+      def copy_scope_index(target)
+        target.instance_exec(scope_index) { @scope_index = _1 }
+      end
+    end
+  end
+end