rupkl 0.1.0 → 0.3.0

data/lib/rupkl/node/struct_common.rb

@@ -3,36 +3,124 @@
 module RuPkl
   module Node
     module StructCommon
-      def to_string(_scopes)
-        "new #{self.class.basename} #{to_pkl_string(nil)}"
+      include NodeCommon
+      include MemberFinder
+
+      def initialize(parent, body, position)
+        super
+        @body = body
       end
 
-      def coerce(_operator, r_operand)
-        [self, r_operand]
+      attr_reader :body
+
+      def properties(visibility: :object)
+        @body&.properties(visibility: visibility)
       end
 
-      private
+      def entries
+        @body&.entries
+      end
+
+      def elements
+        @body&.elements
+      end
+
+      def members(visibility: :object)
+        @body&.members(visibility: visibility)
+      end
+
+      def items
+        @body&.items
+      end
+
+      def evaluate(context = nil)
+        do_evaluation(__method__, context, 1) do |c|
+          @body&.evaluate(c)
+        end
+        self
+      end
+
+      def resolve_structure(context = nil)
+        do_evaluation(__method__, context, 1) do |c|
+          @body&.resolve_structure(c)
+        end
+        @body && check_members
+        self
+      end
+
+      def to_pkl_string(context = nil)
+        to_string(context)
+      end
+
+      def to_string(context = nil)
+        do_evaluation(__method__, context, 2, invalid_string) do |c|
+          to_string_object(c)
+        end
+      end
+
+      def current_context
+        super&.push_object(self) || Context.new(nil, [self])
+      end
+
+      def structure?
+        true
+      end
 
-      def push_scope(scopes)
-        yield([*scopes, self])
+      def copy(parent = nil, position = @position)
+        self.class.new(parent, @body&.copy, position)
       end
 
-      def add_hash_member(members, member, accessor)
-        duplicate_member?(members, member, accessor) &&
-          begin
-            message = 'duplicate definition of member'
-            raise EvaluationError.new(message, member.position)
+      def merge!(*bodies)
+        return unless @body
+
+        @body.merge!(*bodies.compact)
+        check_members
+      end
+
+      private
+
+      def check_members
+        message =
+          if properties_not_allowed?
+            "'#{class_name}' cannot have a property"
+          elsif entries_not_allowed?
+            "'#{class_name}' cannot have an entry"
+          elsif elements_not_allowed?
+            "'#{class_name}' cannot have an element"
           end
-        members << member
+        message &&
+          (raise EvaluationError.new(message, position))
+      end
+
+      def properties_not_allowed?
+        properties.then { _1 && !_1.empty? }
+      end
+
+      def entries_not_allowed?
+        entries
+      end
+
+      def elements_not_allowed?
+        elements
+      end
+
+      def do_evaluation(method, context, limit, ifreachlimit = nil)
+        return ifreachlimit if reach_limit?(method, limit)
+
+        call_depth[method] += 1
+        result = yield(context&.push_object(self) || current_context)
+        call_depth.delete(method)
+
+        result
       end
 
-      def duplicate_member?(members, member, accessor)
-        members
-          .any? { _1.__send__(accessor) == member.__send__(accessor) }
+      def call_depth
+        @call_depth ||= Hash.new { |h, k| h[k] = 0 }
       end
 
-      def add_array_member(members, member)
-        members << member
+      def reach_limit?(method, limit)
+        depth = call_depth[method]
+        depth >= 1 && depth >= limit
       end
 
       def match_members?(lhs, rhs, match_order)
@@ -44,58 +132,67 @@ module RuPkl
         end
       end
 
-      def merge_hash_members(lhs, rhs, accessor)
-        return nil unless lhs || rhs
-        return rhs unless lhs
+      SELF = Object.new.freeze
 
-        rhs&.each do |r|
-          if (index = find_index(lhs, r, accessor))
-            lhs[index] = r
-          else
-            lhs << r
+      def to_pkl_object(context)
+        to_ruby_object(context) do |properties, entries, elements|
+          PklObject.new do |object|
+            [
+              replace_self_hash(properties, object),
+              replace_self_hash(entries, object),
+              replace_self_array(elements, object)
+            ]
           end
         end
-
-        lhs
       end
 
-      def find_index(lhs, rhs, accessor)
-        lhs.find_index { _1.__send__(accessor) == rhs.__send__(accessor) }
+      def to_ruby_object(context)
+        do_evaluation(__method__, context, 1, SELF) do |c|
+          results = convert_members(c)
+          yield(*results)
+        end
       end
 
-      def merge_array_members(lhs, rhs)
-        return nil unless lhs || rhs
-        return rhs unless lhs
-        return lhs unless rhs
-
-        lhs.concat(rhs)
+      def convert_members(context)
+        context.push_scope(@body).then do |c|
+          to_ruby = proc { _1.to_ruby(c) }
+          [
+            properties&.to_h(&to_ruby),
+            entries&.to_h(&to_ruby),
+            elements&.map(&to_ruby)
+          ]
+        end
       end
 
-      def create_pkl_object(scopes, properties, entries, elements)
-        RuPkl::PklObject.new(
-          to_ruby_hash_members(scopes, properties),
-          to_ruby_hash_members(scopes, entries),
-          to_ruby_array_members(scopes, elements)
-        )
+      def replace_self_hash(hash, replacement)
+        hash&.each do |key, value|
+          hash[key] = replacement if value.equal?(SELF)
+        end
       end
 
-      def to_ruby_hash_members(scopes, members)
-        members
-          &.to_h { _1.to_ruby(scopes) }
+      def replace_self_array(array, replacement)
+        array&.each_with_index do |value, i|
+          array[i] = replacement if value.equal?(SELF)
+        end
       end
 
-      def to_ruby_array_members(scopes, members)
-        members
-          &.map { _1.to_ruby(scopes) }
+      def to_string_object(context)
+        "new #{class_name} #{to_string_members(context)}"
       end
 
-      def to_pkl_string_object(*members)
+      def to_string_members(context)
         return '{}' if members.empty?
 
-        members
-          .map { _1.to_pkl_string(nil) }
-          .join('; ')
-          .then { "{ #{_1} }" }
+        context.push_scope(@body).then do |c|
+          members
+            .map { _1.to_pkl_string(c) }
+            .join('; ')
+            .then { "{ #{_1} }" }
+        end
+      end
+
+      def defined_operator?(operator)
+        operator == :[]
       end
     end
   end

data/lib/rupkl/node/this.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    class This
+      include NodeCommon
+
+      def evaluate(context = nil)
+        resolve_reference(context)
+      end
+
+      def resolve_reference(context = nil)
+        (context || current_context).objects.last
+      end
+    end
+  end
+end

data/lib/rupkl/node/type_common.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    module TypeCommon
+      include NodeCommon
+
+      def check_type(value, context, position)
+        klass = value.class
+        return if match_type?(klass, context)
+
+        message =
+          "expected type '#{self}', but got type '#{klass.class_name}'"
+        raise EvaluationError.new(message, position)
+      end
+
+      private
+
+      def find_type(type, context)
+        exec_on(context) do |c|
+          [Base.instance, *c&.objects]
+            .reverse_each do |scope|
+              next unless scope.respond_to?(:pkl_classes)
+
+              klass = scope.pkl_classes&.fetch(type.last.id, nil)
+              return klass if klass
+            end
+
+          raise EvaluationError.new("cannot find type '#{type.last.id}'", position)
+        end
+      end
+    end
+  end
+end

data/lib/rupkl/node/value_common.rb

@@ -3,32 +3,37 @@
 module RuPkl
   module Node
     module ValueCommon
-      def initialize(value, position)
+      include NodeCommon
+
+      def initialize(parent, value, position)
+        super(parent, position)
         @value = value
-        @position = position
       end
 
       attr_reader :value
-      attr_reader :position
 
-      def to_ruby(scopes)
-        evaluate(scopes).value
+      def evaluate(_context = nil)
+        self
       end
 
-      def to_string(scopes)
-        to_ruby(scopes).to_s
+      def to_ruby(context = nil)
+        evaluate(context).value
       end
 
-      def to_pkl_string(scopes)
-        to_string(scopes)
+      def to_string(context = nil)
+        to_ruby(context).to_s
       end
 
-      def ==(other)
-        other.instance_of?(self.class) && value == other.value
+      def to_pkl_string(context = nil)
+        to_string(context)
       end
 
-      def coerce(_operator, r_operand)
-        [value, r_operand.value]
+      def copy(parent = nil, position = @position)
+        self.class.new(parent, @value, position)
+      end
+
+      def ==(other)
+        other.instance_of?(self.class) && value == other.value
       end
     end
   end

data/lib/rupkl/parser/expression.rb

@@ -3,46 +3,112 @@
 module RuPkl
   class Parser
     define_parser do
+      rule(:argument_list) do
+        bracketed(list(expression).maybe, '(', ')').as(:argument_list)
+      end
+
       rule(:unqualified_member_ref) do
-        id.as(:unqualified_member_ref)
+        (
+          id.as(:name) >>
+            (pure_ws? >> argument_list.as(:arguments)).maybe
+        ).as(:unqualified_member_ref)
+      end
+
+      rule(:parenthesized_expression) do
+        bracketed(expression)
+      end
+
+      rule(:this_expression) do
+        kw_this.as(:this_expression)
+      end
+
+      rule(:null_expression) do
+        kw_null.as(:null_expression)
+      end
+
+      rule(:new_expression) do
+        (
+          kw_new.as(:kw_new) >>
+            (ws? >> type.as(:type)).maybe >>
+            (ws? >> object_body).repeat(1).as(:bodies)
+        ).as(:new_expression)
+      end
+
+      rule(:amend_expression) do
+        (
+          parenthesized_expression.as(:target) >>
+            (ws? >> object_body).repeat(1).as(:bodies)
+        ).as(:amend_expression)
+      end
+
+      rule(:if_expression) do
+        (
+          kw_if.as(:kw_if) >> ws? >>
+            bracketed(expression.as(:condition), '(', ')') >> ws? >>
+              expression.as(:if_expression) >> ws >>
+            kw_else.ignore >> ws >>
+              expression.as(:else_expression)
+        ).as(:if_expression)
       end
 
       rule(:primary) do
         [
-          float_literal, integer_literal, boolean_literal, string_literal,
-          unqualified_member_ref, bracketed(expression)
+          float_literal, int_literal, boolean_literal, string_literal,
+          this_expression, null_expression, new_expression, amend_expression,
+          if_expression, unqualified_member_ref, parenthesized_expression
         ].inject(:|)
       end
 
+      rule(:qualifier) do
+        (str('?.') | str('.'))
+      end
+
       rule(:qualified_member_ref) do
         (
-          primary.as(:receiver) >>
-            (ws? >> str('.') >> ws? >> id).repeat(1).as(:member)
-        ).as(:qualified_member_ref) | primary
+          ws? >> qualifier.as(:qualifier) >> ws? >>
+            id.as(:member) >> (pure_ws? >> argument_list.as(:arguments)).maybe
+        ).as(:qualified_member_ref)
+      end
+
+      rule(:subscript_key) do
+        (
+          pure_ws? >> bracketed(expression, '[', ']') >>
+            (ws? >> str('=')).absent?
+        ).as(:subscript_key)
       end
 
-      rule(:subscript_operation) do
+      rule(:qualified_member_ref_or_subscript_operation) do
         (
-          qualified_member_ref.as(:receiver) >>
+          primary.as(:receiver) >>
             (
-              pure_ws? >> bracketed(expression, '[', ']') >>
-                (ws? >> str('=')).absent?
-            ).repeat(1).as(:key)
-        ).as(:subscript_operation) | qualified_member_ref
+              qualified_member_ref | subscript_key
+            ).repeat(1).as(:member_ref_or_subscript_key)
+        ).as(:qualified_member_ref_or_subscript_operation) | primary
+      end
+
+      rule(:non_null_operation) do
+        (
+          qualified_member_ref_or_subscript_operation.as(:operand) >>
+            ws? >> str(:'!!').as(:non_null_operator)
+        ) | qualified_member_ref_or_subscript_operation
+      end
+
+      rule(:unary_operator) do
+        (str('-') | str('!')).as(:unary_operator)
       end
 
       rule(:unary_operation) do
         (
-          (str(:-) | str(:!)).as(:unary_operator) >>
-            ws? >> subscript_operation.as(:operand)
-        ) | subscript_operation
+          (unary_operator >> ws?).repeat(1).as(:operators) >>
+            non_null_operation.as(:operand)
+        ).as(:unary_operation) | non_null_operation
       end
 
       rule(:binary_operation) do
         expression = unary_operation
         operators = binary_operators
         reducer = proc { |l, o, r| { binary_operator: o, l_operand: l, r_operand: r } }
-        infix_expression(expression, *operators, &reducer) | unary_operation
+        infix_expression(expression, *operators, &reducer)
       end
 
       rule(:expression) do
@@ -53,12 +119,13 @@ module RuPkl
 
       def binary_operators
         operators = {
-          '||': 1, '&&': 2,
-          '==': 3, '!=': 3,
-          '<': 4, '>': 4, '<=': 4, '>=': 4,
-          '+': 5, '-': 5,
-          '*': 6, '/': 6, '~/': 6, '%': 6,
-          '**': 7
+          '??': 1,
+          '||': 2, '&&': 3,
+          '==': 4, '!=': 4,
+          '<': 5, '>': 5, '<=': 5, '>=': 5,
+          '+': 6, '-': 6,
+          '*': 7, '/': 7, '~/': 7, '%': 7,
+          '**': 8
         }
         operators
           .sort_by { |op, _| op.length }.reverse
@@ -72,48 +139,135 @@ module RuPkl
           else
             ws? >> str(operator) >> ws?
           end
-        if operator == :**
-          [atom, priority, :right]
-        else
-          [atom, priority, :left]
-        end
+        associativity =
+          (operator in :** | :'??') && :right || :left
+        [atom, priority, associativity]
       end
     end
 
     define_transform do
-      rule(unqualified_member_ref: simple(:member)) do
-        Node::MemberReference.new(nil, member, member.position)
+      rule(argument_list: subtree(:arguments)) do
+        arguments == '' ? nil : Array(arguments)
       end
 
       rule(
-        qualified_member_ref:
-          { receiver: simple(:receiver), member: sequence(:member) }
+        unqualified_member_ref:
+          { name: simple(:name) }
       ) do
-        member.inject(receiver) do |r, m|
-          Node::MemberReference.new(r, m, r.position)
-        end
+        Node::MemberReference.new(nil, nil, name, false, name.position)
       end
 
       rule(
-        subscript_operation:
-          { receiver: simple(:receiver), key: sequence(:key) }
+        unqualified_member_ref:
+          { name: simple(:name), arguments: subtree(:arguments) }
       ) do
-        key.inject(receiver) do |r, k|
-          Node::SubscriptOperation.new(r, k, r.position)
+        Node::MethodCall.new(nil, nil, name, arguments, false, name.position)
+      end
+
+      rule(
+        qualified_member_ref_or_subscript_operation:
+          {
+            receiver: simple(:receiver),
+            member_ref_or_subscript_key: subtree(:member_ref_or_subscript_key)
+          }
+      ) do
+        member_ref_or_subscript_key.inject(receiver) do |r, ref_or_key|
+          if ref_or_key.key?(:subscript_key)
+            process_subscript_operation(r, ref_or_key[:subscript_key])
+          else
+            process_member_ref(r, ref_or_key[:qualified_member_ref])
+          end
+        end
+      end
+
+      define_helper(:process_subscript_operation) do |receiver, key|
+        Node::SubscriptOperation.new(nil, :[], receiver, key, receiver.position)
+      end
+
+      define_helper(:process_member_ref) do |receiver, member_ref|
+        nullable = member_ref[:qualifier] == '?.'
+        if member_ref.key?(:arguments)
+          Node::MethodCall.new(
+            nil, receiver, member_ref[:member], member_ref[:arguments],
+            nullable, receiver.position
+          )
+        else
+          Node::MemberReference.new(
+            nil, receiver, member_ref[:member], nullable, receiver.position
+          )
         end
       end
 
-      rule(unary_operator: simple(:operator), operand: simple(:operand)) do
-        Node::UnaryOperation.new(operator.to_sym, operand, node_position(operator))
+      rule(this_expression: simple(:this)) do
+        Node::This.new(nil, node_position(this))
+      end
+
+      rule(null_expression: simple(:null)) do
+        Node::Null.new(nil, node_position(null))
+      end
+
+      rule(
+        new_expression:
+          { kw_new: simple(:n), bodies: subtree(:b) }
+      ) do
+        Node::UnresolvedObject.new(nil, nil, b, node_position(n))
+      end
+
+      rule(
+        new_expression:
+          { kw_new: simple(:n), type: simple(:t), bodies: subtree(:b) }
+      ) do
+        Node::UnresolvedObject.new(nil, t, b, node_position(n))
+      end
+
+      rule(
+        amend_expression:
+          { target: simple(:t), bodies: subtree(:b) }
+      ) do
+        Node::AmendExpression.new(nil, t, Array(b), t.position)
+      end
+
+      rule(
+        if_expression:
+          {
+            kw_if: simple(:kw), condition: simple(:condition),
+            if_expression: simple(:if_expression),
+            else_expression: simple(:else_expression)
+          }
+      ) do
+        Node::IfExpression.new(
+          nil, condition, if_expression, else_expression, node_position(kw)
+        )
+      end
+
+      rule(operand: simple(:operand), non_null_operator: simple(:operator)) do
+        Node::NonNullOperation.new(nil, operator.to_sym, operand, operand.position)
+      end
+
+      rule(unary_operator: simple(:op)) do
+        op
+      end
+
+      rule(
+        unary_operation: {
+          operators: sequence(:operators), operand: simple(:operand)
+        }
+      ) do
+        operators.reverse.inject(operand) do |result, operator|
+          Node::UnaryOperation.new(nil, operator.to_sym, result, node_position(operator))
+        end
       end
 
       rule(
         binary_operator: simple(:operator),
         l_operand: simple(:l_operand), r_operand: simple(:r_operand)
       ) do
-        Node::BinaryOperation.new(
-          operator.to_sym, l_operand, r_operand, l_operand.position
-        )
+        klass =
+          case operator.to_sym
+          when :'??' then Node::NullCoalescingOperation
+          else Node::BinaryOperation
+          end
+        klass.new(nil, operator.to_sym, l_operand, r_operand, l_operand.position)
       end
     end
   end

data/lib/rupkl/parser/identifier.rb

@@ -41,11 +41,11 @@ module RuPkl
           parse_error(message, node_position(id))
         end
 
-        Node::Identifier.new(id.to_sym, node_position(id))
+        Node::Identifier.new(nil, id.to_sym, node_position(id))
       end
 
       rule(quoted_id: simple(:id)) do
-        Node::Identifier.new(id.to_s[1..-2].to_sym, node_position(id))
+        Node::Identifier.new(nil, id.to_s[1..-2].to_sym, node_position(id))
       end
 
       private