rupkl 0.1.0 → 0.2.0

data/lib/rupkl/node/value_common.rb

@@ -3,24 +3,33 @@
 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_ruby(context = nil)
+        evaluate(context).value
+      end
+
+      def to_string(context = nil)
+        to_ruby(context).to_s
       end
 
-      def to_string(scopes)
-        to_ruby(scopes).to_s
+      def to_pkl_string(context = nil)
+        to_string(context)
       end
 
-      def to_pkl_string(scopes)
-        to_string(scopes)
+      def copy(parent = nil)
+        self.class.new(parent, @value, position)
       end
 
       def ==(other)

data/lib/rupkl/parser/expression.rb

@@ -3,46 +3,98 @@
 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(: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,
+          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_operation) do
         (
           (str(:-) | str(:!)).as(:unary_operator) >>
-            ws? >> subscript_operation.as(:operand)
-        ) | subscript_operation
+            ws? >> non_null_operation.as(:operand)
+        ) | 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 +105,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 +125,112 @@ 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(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(operand: simple(:operand), non_null_operator: simple(:operator)) do
+        Node::NonNullOperation.new(nil, operator.to_sym, operand, operand.position)
+      end
+
       rule(unary_operator: simple(:operator), operand: simple(:operand)) do
-        Node::UnaryOperation.new(operator.to_sym, operand, node_position(operator))
+        Node::UnaryOperation.new(nil, operator.to_sym, operand, node_position(operator))
       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

data/lib/rupkl/parser/literal.rb

@@ -13,16 +13,16 @@ module RuPkl
 
     define_transform do
       rule(true_value: simple(:v)) do
-        Node::Boolean.new(true, node_position(v))
+        Node::Boolean.new(nil, true, node_position(v))
       end
 
       rule(false_value: simple(:v)) do
-        Node::Boolean.new(false, node_position(v))
+        Node::Boolean.new(nil, false, node_position(v))
       end
     end
 
     #
-    # Integer literal
+    # Int literal
     #
     define_parser do
       rule(:bin_literal) do
@@ -41,18 +41,18 @@ module RuPkl
         str('0x') >> match('[\h]') >> match('[_\h]').repeat
       end
 
-      rule(:integer_literal) do
+      rule(:int_literal) do
         (
           bin_literal | oct_literal | hex_literal | dec_literal
-        ).as(:integer_literal)
+        ).as(:int_literal)
       end
     end
 
     define_transform do
-      rule(integer_literal: simple(:v)) do
+      rule(int_literal: simple(:v)) do
         base = { 'b' => 2, 'o' => 8, 'x' => 16 }.fetch(v.to_s[1], 10)
         value = v.to_s.tr('_', '').to_i(base)
-        Node::Integer.new(value, node_position(v))
+        Node::Int.new(nil, value, node_position(v))
       end
     end
 
@@ -75,7 +75,7 @@ module RuPkl
     define_transform do
       rule(float_literal: simple(:f)) do
         v = f.to_s.tr('_', '').to_f
-        Node::Float.new(v, node_position(f))
+        Node::Float.new(nil, v, node_position(f))
       end
     end
 
@@ -225,19 +225,25 @@ module RuPkl
 
     define_transform do
       rule(ss_bq: simple(:bq), ss_eq: simple(:eq)) do
-        Node::String.new(nil, nil, node_position(bq))
+        Node::String.new(nil, nil, nil, node_position(bq))
       end
 
       rule(ss_bq: simple(:bq), ss_portions: subtree(:portions), ss_eq: simple(:eq)) do
-        Node::String.new(nil, process_ss_portions(portions, bq), node_position(bq))
+        Node::String.new(
+          nil, nil, process_ss_portions(portions, bq),
+          node_position(bq)
+        )
       end
 
       rule(ms_bq: simple(:bq), ms_eq: simple(:eq)) do
-        Node::String.new(nil, nil, node_position(bq))
+        Node::String.new(nil, nil, nil, node_position(bq))
       end
 
       rule(ms_bq: simple(:bq), ms_portions: subtree(:portions), ms_eq: simple(:eq)) do
-        Node::String.new(nil, process_ms_portions(portions, bq, eq), node_position(bq))
+        Node::String.new(
+          nil, nil, process_ms_portions(portions, bq, eq),
+          node_position(bq)
+        )
       end
 
       private

data/lib/rupkl/parser/method.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RuPkl
+  class Parser
+    define_parser do
+      rule(:method_header) do
+        kw_function.as(:kw_function) >> ws >>
+          id.as(:name) >> ws? >> method_params.as(:params) >>
+          (ws? >> type_annotation.as(:type)).maybe
+      end
+
+      rule(:method_params) do
+        bracketed(list(method_param).maybe, '(', ')').as(:method_params)
+      end
+
+      rule(:method_param) do
+        (
+          id.as(:name) >> (ws? >> type_annotation.as(:type)).maybe
+        ).as(:method_param)
+      end
+    end
+
+    define_transform do
+      rule(method_params: subtree(:params)) do
+        params == '' ? nil : Array(params)
+      end
+
+      rule(
+        method_param: { name: simple(:name) }
+      ) do
+        Node::MethodParam.new(nil, name, nil, name.position)
+      end
+
+      rule(
+        method_param: { name: simple(:name), type: simple(:type) }
+      ) do
+        Node::MethodParam.new(nil, name, type, name.position)
+      end
+    end
+  end
+end

data/lib/rupkl/parser/misc.rb

@@ -45,6 +45,10 @@ module RuPkl
             .map { _1.is_a?(String) && str(_1).ignore || _1 }
         bra_matcher >> ws? >> atom >> ws? >> cket_matcher
       end
+
+      def list(atom, delimiter = ',')
+        atom >> (ws? >> str(delimiter).ignore >> ws? >> atom).repeat
+      end
     end
   end
 end

data/lib/rupkl/parser/object.rb

@@ -4,27 +4,30 @@ module RuPkl
   class Parser
     define_parser do
       rule(:object) do
-        bracketed(
-          object_members.as(:members).maybe,
-          str('{').as(:start), '}'
-        ).as(:object)
+        (object_body >> (ws? >> object_body).repeat).as(:bodies).as(:object)
       end
 
-      rule(:object_members) do
-        object_member >> (ws >> object_member).repeat
+      rule(:object_body) do
+        members = object_member >> (ws >> object_member).repeat
+        bracketed(
+          members.as(:members).maybe,
+          str('{').as(:body_begin), '}'
+        ).as(:object_body)
       end
 
       rule(:object_member) do
-        object_property | object_entry | object_element
+        [
+          object_method, object_element,
+          object_property, object_entry
+        ].inject(:|)
       end
 
       rule(:object_property) do
         (
           id.as(:name) >> ws? >>
             (
-              (str('=').ignore >> ws? >> expression.as(:value)) |
-              (object >> (ws? >> object).repeat).as(:objects)
-            )
+              (str('=').ignore >> ws? >> expression) | object
+            ).as(:value)
         ).as(:object_property)
       end
 
@@ -32,40 +35,69 @@ module RuPkl
         (
           bracketed(expression.as(:key), '[', ']') >> ws? >>
             (
-              (str('=').ignore >> ws? >> expression.as(:value)) |
-              (object >> (ws? >> object).repeat).as(:objects)
-            )
+              (str('=').ignore >> ws? >> expression) | object
+            ).as(:value)
         ).as(:object_entry)
       end
 
       rule(:object_element) do
-        expression
+        (
+          expression >> (ws? >> match('[={]')).absent?
+        ).as(:object_element)
+      end
+
+      rule(:object_method) do
+        (
+          method_header >> ws? >>
+          str('=').ignore >> ws? >> expression.as(:body)
+        ).as(:object_method)
       end
     end
 
     define_transform do
-      rule(object: { start: simple(:s) }) do
-        Node::UnresolvedObject.new(nil, node_position(s))
+      rule(object: { bodies: subtree(:b) }) do
+        bodies = Array(b)
+        Node::UnresolvedObject.new(nil, nil, bodies, bodies.first.position)
       end
 
-      rule(object: { start: simple(:s), members: subtree(:m) }) do
-        Node::UnresolvedObject.new(Array(m), node_position(s))
+      rule(object_body: { body_begin: simple(:b) }) do
+        Node::ObjectBody.new(nil, nil, node_position(b))
       end
 
-      rule(object_property: { name: simple(:n), value: simple(:v) }) do
-        Node::ObjectProperty.new(n, v, nil, n.position)
+      rule(object_body: { body_begin: simple(:b), members: subtree(:m) }) do
+        Node::ObjectBody.new(nil, Array(m), node_position(b))
       end
 
-      rule(object_property: { name: simple(:n), objects: subtree(:o) }) do
-        Node::ObjectProperty.new(n, nil, Array(o), n.position)
+      rule(object_property: { name: simple(:n), value: simple(:v) }) do
+        Node::ObjectProperty.new(nil, n, v, n.position)
       end
 
       rule(object_entry: { key: simple(:k), value: simple(:v) }) do
-        Node::ObjectEntry.new(k, v, nil, k.position)
+        Node::ObjectEntry.new(nil, k, v, k.position)
+      end
+
+      rule(object_element: simple(:e)) do
+        Node::ObjectElement.new(nil, e, e.position)
+      end
+
+      rule(
+        object_method:
+          {
+            kw_function: simple(:kw), name: simple(:name),
+            params: subtree(:params), body: simple(:body)
+          }
+      ) do
+        Node::MethodDefinition.new(nil, name, params, nil, body, node_position(kw))
       end
 
-      rule(object_entry: { key: simple(:k), objects: subtree(:o) }) do
-        Node::ObjectEntry.new(k, nil, Array(o), k.position)
+      rule(
+        object_method:
+          {
+            kw_function: simple(:kw), name: simple(:name),
+            params: subtree(:params), type: simple(:type), body: simple(:body)
+          }
+      ) do
+        Node::MethodDefinition.new(nil, name, params, type, body, node_position(kw))
       end
     end
   end

data/lib/rupkl/parser/pkl_class.rb

@@ -7,22 +7,42 @@ module RuPkl
         (
           id.as(:name) >> ws? >>
           (
-            (str('=').ignore >> ws? >> expression.as(:value)) |
-            (object >> (ws? >> object).repeat).as(:objects)
-          )
+            (str('=').ignore >> ws? >> expression) | object
+          ).as(:value)
         ).as(:class_property)
       end
+
+      rule(:pkl_class_method) do
+        (
+          method_header >> ws? >>
+          str('=').ignore >> ws? >> expression.as(:body)
+        ).as(:pkl_class_method)
+      end
     end
 
     define_transform do
       rule(class_property: { name: simple(:n), value: simple(:v) }) do
-        Node::PklClassProperty.new(n, v, nil, n.position)
+        Node::ObjectProperty.new(nil, n, v, n.position)
       end
-    end
 
-    define_transform do
-      rule(class_property: { name: simple(:n), objects: subtree(:o) }) do
-        Node::PklClassProperty.new(n, nil, Array(o), n.position)
+      rule(
+        pkl_class_method:
+          {
+            kw_function: simple(:kw), name: simple(:name),
+            params: subtree(:params), body: simple(:body)
+          }
+      ) do
+        Node::MethodDefinition.new(nil, name, params, nil, body, node_position(kw))
+      end
+
+      rule(
+        pkl_class_method:
+          {
+            kw_function: simple(:kw), name: simple(:name),
+            params: subtree(:params), type: simple(:type), body: simple(:body)
+          }
+      ) do
+        Node::MethodDefinition.new(nil, name, params, type, body, node_position(kw))
       end
     end
   end

data/lib/rupkl/parser/pkl_module.rb

@@ -14,18 +14,20 @@ module RuPkl
       end
 
       rule(:pkl_module_item) do
-        pkl_class_property
+        pkl_class_method | pkl_class_property
       end
     end
 
     define_transform do
       rule(pkl_module: simple(:_)) do
-        Node::PklModule.new(nil, sof_position)
+        body = Node::ObjectBody.new(nil, nil, sof_position)
+        Node::PklModule.new(nil, body, sof_position)
       end
 
       rule(pkl_module: { items: subtree(:items) }) do
         Array(items)
-          .then { Node::PklModule.new(_1, _1.first.position) }
+          .then { Node::ObjectBody.new(nil, _1, _1.first.position) }
+          .then { Node::PklModule.new(nil, _1, _1.position) }
       end
     end
   end