rupkl 0.1.0 → 0.3.0

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,30 @@ 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
+
+    define_parser do
+      rule(:modifier) do
+        kw_local.as(:modifier)
+      end
+
+      rule(:modifiers) do
+        (modifier >> ws).repeat(1).as(:modifiers)
+      end
+    end
+
+    define_transform do
+      rule(modifier: simple(:modifier)) do
+        modifier.to_sym
+      end
+
+      rule(modifiers: sequence(:modifiers)) do
+        modifiers.to_h { |m| [m.to_sym, true] }
+      end
     end
   end
 end

data/lib/rupkl/parser/object.rb

@@ -4,27 +4,32 @@ module RuPkl
   class Parser
     define_parser do
       rule(:object) do
+        (object_body >> (ws? >> object_body).repeat).as(:bodies).as(:object)
+      end
+
+      rule(:object_body) do
         bracketed(
-          object_members.as(:members).maybe,
-          str('{').as(:start), '}'
-        ).as(:object)
+          object_items.as(:items).maybe,
+          str('{').as(:body_begin), '}'
+        ).as(:object_body)
       end
 
-      rule(:object_members) do
-        object_member >> (ws >> object_member).repeat
+      rule(:object_items) do
+        object_item >> (ws >> object_item).repeat
       end
 
-      rule(:object_member) do
-        object_property | object_entry | object_element
+      rule(:object_item) do
+        [
+          when_generator, for_generator,
+          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)
-            )
+          modifiers.as(:modifiers).maybe >> id.as(:name) >> ws? >>
+            ((str('=').ignore >> ws? >> expression) | object).as(:value)
         ).as(:object_property)
       end
 
@@ -32,40 +37,150 @@ 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
+        (
+          modifiers.absent? >> 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
+
+      rule(:when_generator) do
+        (
+          kw_when.as(:kw_when) >> ws? >>
+          bracketed(expression.as(:condition), '(', ')') >> ws? >>
+          object_body.as(:when_body) >>
+          (ws? >> kw_else.ignore >> ws? >> object_body.as(:else_body)).maybe
+        ).as(:when_generator)
+      end
+
+      rule(:for_generator) do
+        (
+          header =
+            (id.as(:key_name) >> ws? >> str(',') >> ws?).maybe >>
+            id.as(:value_name) >> ws >> kw_in >> ws >> expression.as(:iterable)
+          kw_for.as(:kw_for) >> ws? >>
+            bracketed(header, '(', ')') >> ws? >> object_body.as(:body)
+        ).as(:for_generator)
       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(:body_begin) }) do
+        Node::ObjectBody.new(nil, nil, node_position(body_begin))
+      end
+
+      rule(
+        object_body: {
+          body_begin: simple(:body_begin), items: subtree(:items)
+        }
+      ) do
+        Node::ObjectBody.new(nil, Array(items), node_position(body_begin))
       end
 
       rule(object_property: { name: simple(:n), value: simple(:v) }) do
-        Node::ObjectProperty.new(n, v, nil, n.position)
+        Node::ObjectProperty.new(nil, n, v, nil, n.position)
       end
 
-      rule(object_property: { name: simple(:n), objects: subtree(:o) }) do
-        Node::ObjectProperty.new(n, nil, Array(o), n.position)
+      rule(
+        object_property:
+          {
+            modifiers: subtree(:m), name: simple(:n), value: simple(:v)
+          }
+      ) do
+        Node::ObjectProperty.new(nil, n, v, m, 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_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
+
+      rule(
+        when_generator:
+          {
+            kw_when: simple(:kw), condition: simple(:condition),
+            when_body: simple(:when_body)
+          }
+      ) do
+        Node::WhenGenerator.new(
+          nil, condition, when_body, nil, nil, node_position(kw)
+        )
+      end
+
+      rule(
+        when_generator:
+          {
+            kw_when: simple(:kw), condition: simple(:condition),
+            when_body: simple(:when_body), else_body: simple(:else_body)
+          }
+      ) do
+        Node::WhenGenerator.new(
+          nil, condition, when_body, else_body, nil, node_position(kw)
+        )
+      end
+
+      rule(
+        for_generator:
+          {
+            kw_for: simple(:kw), value_name: simple(:value_name),
+            iterable: simple(:iterable), body: simple(:body)
+          }
+      ) do
+        Node::ForGenerator.new(
+          nil, nil, value_name, iterable, body, nil, node_position(kw)
+        )
       end
 
-      rule(object_entry: { key: simple(:k), objects: subtree(:o) }) do
-        Node::ObjectEntry.new(k, nil, Array(o), k.position)
+      rule(
+        for_generator:
+          {
+            kw_for: simple(:kw),
+            key_name: simple(:key_name), value_name: simple(:value_name),
+            iterable: simple(:iterable), body: simple(:body)
+          }
+      ) do
+        Node::ForGenerator.new(
+          nil, key_name, value_name, iterable, body, nil, node_position(kw)
+        )
       end
     end
   end

data/lib/rupkl/parser/pkl_class.rb

@@ -5,24 +5,51 @@ module RuPkl
     define_parser do
       rule(:pkl_class_property) do
         (
-          id.as(:name) >> ws? >>
-          (
-            (str('=').ignore >> ws? >> expression.as(:value)) |
-            (object >> (ws? >> object).repeat).as(:objects)
-          )
+          modifiers.as(:modifiers).maybe >> id.as(:name) >> ws? >>
+            ((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, nil, 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(
+        class_property:
+          {
+            modifiers: subtree(:m), name: simple(:n), value: simple(:v)
+          }
+      ) do
+        Node::ObjectProperty.new(nil, n, v, m, n.position)
+      end
+
+      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

data/lib/rupkl/parser/type.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RuPkl
+  class Parser
+    define_parser do
+      rule(:declared_type) do
+        id.as(:type).as(:declared_type)
+      end
+
+      rule(:type) do
+        declared_type
+      end
+
+      rule(:type_annotation) do
+        str(':').ignore >> ws? >> type
+      end
+    end
+
+    define_transform do
+      rule(
+        declared_type:
+          { type: simple(:t) }
+      ) do
+        Node::DeclaredType.new(nil, Array(t), t.position)
+      end
+    end
+  end
+end

data/lib/rupkl/parser.rb

@@ -73,6 +73,14 @@ module RuPkl
     end
 
     class Transform < Parslet::Transform
+      class << self
+        private
+
+        def define_helper(name, &body)
+          private define_method(name, &body)
+        end
+      end
+
       def apply(obj, context = nil, filename: nil)
         @filename = filename if filename
         super(obj, context)

data/lib/rupkl/pkl_object.rb

@@ -4,10 +4,8 @@ module RuPkl
   class PklObject
     include Enumerable
 
-    def initialize(properties, entries, elements)
-      @properties = properties
-      @entries = entries
-      @elements = elements
+    def initialize
+      @properties, @entries, @elements = yield(self)
       define_property_accessors
     end
 
@@ -84,12 +82,18 @@ module RuPkl
       end
     end
 
+    def pretty_print_cycle(pp)
+      if element_only?
+        pp.text('[...]')
+      else
+        pp.text('{...}')
+      end
+    end
+
     private
 
     def define_property_accessors
-      return unless @properties
-
-      properties.each_key do |name|
+      @properties&.each_key do |name|
         singleton_class.class_eval(<<~M, __FILE__, __LINE__ + 1)
           # def foo
           #   properties[__method__]

data/lib/rupkl/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RuPkl
-  VERSION = '0.1.0'
+  VERSION = '0.3.0'
 end

data/lib/rupkl.rb

@@ -1,29 +1,58 @@
 # frozen_string_literal: true
 
+require 'base64'
+require 'digest/md5'
+require 'digest/sha1'
+require 'digest/sha2'
+require 'singleton'
 require 'stringio'
 require 'parslet'
-require 'facets/module/basename'
+require 'regexp_parser'
 
 require_relative 'rupkl/version'
 require_relative 'rupkl/exception'
 require_relative 'rupkl/pkl_object'
+require_relative 'rupkl/node/context'
+require_relative 'rupkl/node/node_common'
 require_relative 'rupkl/node/value_common'
+require_relative 'rupkl/node/type_common'
+require_relative 'rupkl/node/member_finder'
 require_relative 'rupkl/node/struct_common'
-require_relative 'rupkl/node/boolean'
-require_relative 'rupkl/node/number'
-require_relative 'rupkl/node/string'
+require_relative 'rupkl/node/reference_resolver'
 require_relative 'rupkl/node/identifier'
+require_relative 'rupkl/node/declared_type'
 require_relative 'rupkl/node/member_reference'
+require_relative 'rupkl/node/method_definition'
+require_relative 'rupkl/node/method_call'
+require_relative 'rupkl/node/amend_expression'
+require_relative 'rupkl/node/if_expression'
 require_relative 'rupkl/node/operation'
-require_relative 'rupkl/node/object'
+require_relative 'rupkl/node/this'
+require_relative 'rupkl/node/any'
+require_relative 'rupkl/node/null'
+require_relative 'rupkl/node/boolean'
+require_relative 'rupkl/node/number'
+require_relative 'rupkl/node/string'
+require_relative 'rupkl/node/regex'
+require_relative 'rupkl/node/data_size'
+require_relative 'rupkl/node/duration'
+require_relative 'rupkl/node/pair'
+require_relative 'rupkl/node/collection'
+require_relative 'rupkl/node/map'
+require_relative 'rupkl/node/intseq'
 require_relative 'rupkl/node/dynamic'
-require_relative 'rupkl/node/pkl_class'
+require_relative 'rupkl/node/mapping'
+require_relative 'rupkl/node/listing'
+require_relative 'rupkl/node/object'
 require_relative 'rupkl/node/pkl_module'
+require_relative 'rupkl/node/base'
 require_relative 'rupkl/parser'
 require_relative 'rupkl/parser/misc'
 require_relative 'rupkl/parser/literal'
 require_relative 'rupkl/parser/identifier'
+require_relative 'rupkl/parser/type'
 require_relative 'rupkl/parser/expression'
+require_relative 'rupkl/parser/method'
 require_relative 'rupkl/parser/object'
 require_relative 'rupkl/parser/pkl_class'
 require_relative 'rupkl/parser/pkl_module'