rupkl 0.1.0 → 0.3.0

data/lib/rupkl/node/operation.rb

@@ -2,184 +2,244 @@
 
 module RuPkl
   module Node
-    module OperationCommon
-      def to_ruby(scopes)
-        evaluate(scopes).to_ruby(nil)
+    module Operatable
+      def s_op(operator, key, context, position)
+        check_s_op(operator, position)
+
+        k = key.evaluate(context)
+        valid_key_operand?(k) ||
+          raise_invalid_key_error(operator, k, position)
+
+        (v = find_by_key(k)) ||
+          raise_no_key_found_error(k, context, position)
+
+        v.evaluate
       end
 
-      def to_string(scopes)
-        evaluate(scopes).to_string(nil)
+      def u_op(operator, position)
+        check_u_op(operator, position)
+        __send__(u_op_method(operator), position)
       end
 
-      def to_pkl_string(scopes)
-        evaluate(scopes).to_pkl_string(nil)
+      def b_op(operator, operand, context, position)
+        check_b_op(operator, position)
+        return self if short_circuit?(operator)
+
+        r_operand = operand.evaluate(context)
+        if valid_r_operand?(operator, r_operand)
+          __send__(b_op_method(operator), r_operand, position)
+        elsif [:==, :'!='].any?(operator)
+          Boolean.new(nil, operator != :==, position)
+        else
+          raise_invalid_r_operand_error(operator, r_operand, position)
+        end
+      end
+
+      def b_op_eq(r_operand, position)
+        result = self == r_operand
+        Boolean.new(nil, result, position)
+      end
+
+      def b_op_ne(r_operand, position)
+        result = self != r_operand
+        Boolean.new(nil, result, position)
       end
 
       private
 
-      def s_op(scopes)
-        r = receiver.evaluate(scopes)
-        check_operator(r)
+      def check_s_op(operator, position)
+        check_operator(operator, position)
+      end
 
-        k = key.evaluate(scopes)
-        check_key_operand(r, k)
+      def valid_key_operand?(_key)
+        true
+      end
 
-        r.find_by_key(k) ||
-          begin
-            message = "cannot find key '#{k.to_pkl_string(scopes)}'"
-            raise EvaluationError.new(message, position)
-          end
+      def raise_invalid_key_error(operator, key, position)
+        message =
+          "invalid key operand type #{key.class_name} is given " \
+          "for operator '#{operator}'"
+        raise EvaluationError.new(message, position)
       end
 
-      def u_op(scopes)
-        o = operand.evaluate(scopes)
-        check_operator(o)
+      def raise_no_key_found_error(key, context, position)
+        message = "cannot find key '#{key.to_pkl_string(context)}'"
+        raise EvaluationError.new(message, position)
+      end
 
-        result =
-          if operator == :-
-            -o.value
-          else
-            !o.value
-          end
-        create_op_result(result)
+      def check_u_op(operator, position)
+        op = :"#{operator}@"
+        check_operator(op, position)
       end
 
-      def b_op(scopes)
-        l = l_operand.evaluate(scopes)
-        check_operator(l)
-        return l if short_circuit?(l)
+      def u_op_method(operator)
+        { '-': :u_op_minus, '!': :u_op_negate }[operator]
+      end
 
-        r = r_operand.evaluate(scopes)
-        check_r_operand(l, r)
+      def check_b_op(operator, position)
+        check_operator(operator, position)
+      end
 
-        l, r = l.coerce(operator, r)
-        create_op_result(l.__send__(ruby_op, r))
+      def short_circuit?(_operator)
+        false
       end
 
-      def check_operator(operand)
-        undefined_operator?(operand) &&
-          begin
-            message =
-              "operator '#{operator}' is not defined for " \
-              "#{operand.class.basename} type"
-            raise EvaluationError.new(message, position)
-          end
+      def valid_r_operand?(_operator, operand)
+        operand.is_a?(self.class)
       end
 
-      def undefined_operator?(operand)
-        !operand.respond_to?(:undefined_operator?) ||
-          operand.undefined_operator?(operator)
+      def raise_invalid_r_operand_error(operator, r_operand, position)
+        message =
+          "invalid operand type #{r_operand.class_name} is given " \
+          "for operator '#{operator}'"
+        raise EvaluationError.new(message, position)
       end
 
-      def check_key_operand(receiver, key)
-        invalid_key_operand?(receiver, key) &&
-          begin
-            message =
-              "invalid key operand type #{key.class.basename} is given " \
-              "for operator '#{operator}'"
-            raise EvaluationError.new(message, position)
-          end
+      def b_op_method(operator)
+        {
+          '**': :b_op_exp,
+          '*': :b_op_mul, '/': :b_op_div,
+          '~/': :b_op_truncating_div, '%': :b_op_rem,
+          '+': :b_op_add, '-': :b_op_sub,
+          '<': :b_op_lt, '>': :b_op_gt,
+          '<=': :b_op_le, '>=': :b_op_ge,
+          '==': :b_op_eq, '!=': :b_op_ne,
+          '&&': :b_op_and, '||': :b_op_or
+        }[operator]
       end
 
-      def invalid_key_operand?(receiver, key)
-        receiver.respond_to?(:invalid_key_operand?) &&
-          receiver.invalid_key_operand?(key)
+      def check_operator(operator, position)
+        return if
+          [:==, :'!='].any?(operator) || defined_operator?(operator)
+
+        message = "operator '#{operator}' is not defined for #{class_name} type"
+        raise EvaluationError.new(message, position)
       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
+      def defined_operator?(_operator)
+        false
       end
+    end
 
-      def invalid_r_operand?(l_operand, r_operand)
-        if l_operand.respond_to?(:invalid_r_operand?)
-          l_operand.invalid_r_operand?(r_operand)
-        else
-          !r_operand.is_a?(l_operand.class)
-        end
+    module OperationCommon
+      include NodeCommon
+
+      def initialize(parent, operator, *operands, position)
+        super(parent, *operands, position)
+        @operator = operator
+        @operands = operands
       end
 
-      def short_circuit?(l_operand)
-        l_operand.respond_to?(:short_circuit?) &&
-          l_operand.short_circuit?(operator)
+      attr_reader :operator
+      attr_reader :operands
+
+      def copy(parent = nil, position = @position)
+        copied_operands = operands.map(&:copy)
+        self.class.new(parent, operator, *copied_operands, position)
       end
 
-      def ruby_op
-        { '&&': :&, '||': :|, '~/': :/ }.fetch(operator, operator)
+      private
+
+      def s_op(context)
+        r = receiver.evaluate(context)
+        r.s_op(operator, key, context, position)
       end
 
-      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)
-        end
+      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)
+        o.u_op(operator, position)
+      end
+
+      def b_op(context)
+        l = l_operand.evaluate(context)
+        l.b_op(operator, r_operand, context, position)
+      end
+
+      def null_coalescing_op(context)
+        l = l_operand.evaluate(context)
+        return l unless l.null?
+
+        r_operand.evaluate(context)
       end
     end
 
     class SubscriptOperation
       include OperationCommon
 
-      def initialize(receiver, key, position)
-        @receiver = receiver
-        @key = key
-        @position = position
+      def receiver
+        operands.first
       end
 
-      attr_reader :receiver
-      attr_reader :key
-      attr_reader :position
+      def key
+        operands.last
+      end
 
-      def operator
-        :[]
+      def evaluate(context = nil)
+        s_op(context)
       end
+    end
+
+    class NonNullOperation
+      include OperationCommon
 
-      def evaluate(scopes)
-        s_op(scopes)
+      def operand
+        operands.first
+      end
+
+      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/pair.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    class Pair < Any
+      include Operatable
+
+      uninstantiable_class
+
+      def first
+        @children[0]
+      end
+
+      def second
+        @children[1]
+      end
+
+      def evaluate(_context = nil)
+        self
+      end
+
+      def to_ruby(context = nil)
+        [first, second].map { _1.to_ruby(context) }
+      end
+
+      def to_pkl_string(context = nil)
+        to_string(context)
+      end
+
+      def to_string(context = nil)
+        element_strings =
+          [first, second].map { _1.to_pkl_string(context) }
+        "Pair(#{element_strings[0]}, #{element_strings[1]})"
+      end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          first == other.first && second == other.second
+      end
+
+      define_builtin_property(:first) do
+        first
+      end
+
+      define_builtin_property(:key) do
+        first
+      end
+
+      define_builtin_property(:second) do
+        second
+      end
+
+      define_builtin_property(:value) do
+        second
+      end
+    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 pkl_methods
+        @body&.pkl_methods
       end
 
-      attr_reader :properties
-      attr_reader :position
+      def pkl_classes
+        @body&.pkl_classes
+      end
 
-      def evaluate(scopes)
-        push_scope(scopes) do |s|
-          self.class.new(evaluate_properties(s), position)
-        end
+      def evaluate(context = nil)
+        resolve_structure(context)
+        super
       end
 
-      def to_ruby(scopes)
-        push_scope(scopes) do |s|
-          create_pkl_object(s, properties, nil, nil)
-        end
+      def to_ruby(context = nil)
+        to_pkl_object(context)
       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