rupkl 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8b6a7346123ff0c771a201f1218f0c2d92e3c34a16e4fe0f668724eb53726ee
-  data.tar.gz: 169990d7f909f37f72ea97ba2ff44c9634137fead23791ab6a80fddd9b3af109
+  metadata.gz: d7731a56bb62b392639860c5e0f82c2175e8bca4ecd439e8ccffd05d9b223b0f
+  data.tar.gz: 18487cb107c5a47212d185d782f4866d5fc5c0734b893986e4388c003728687d
 SHA512:
-  metadata.gz: 50e6f855bec47026a3a6f4b8b61b9fd61ceafc7686bcd0a51f459a42ae88a97ee954fb362f3450c89d6499fe6e1d97f2b2350350a2820607c007bc7a8e8d8190
-  data.tar.gz: ad63c41fa79cc9b487d6d3c7f4b129febbf914e564f15d9921072cf4680442dcc77c605d8d7cc283aa15662f15247f427ccbd218c2a1856681ca402500e2810f
+  metadata.gz: e9d8c2d0d8d9f4976ba804810285344b8f5a6cd308ce1eeff23eb3503feb365c2415d1876c8c879fdf38ca016b01dc849aaeb2e01ae502b9c0e0a44a1a2123ce
+  data.tar.gz: 2bc34ee5b570519a913299dbe5415fe9a7e3dd406b5912f729127ce152c18fd6821f769f9c6df6e677c0c114de935f401584e67e5ae385133aef318810f57ce0

data/README.md

@@ -116,7 +116,7 @@ Pkl code snippets used for RSpec examples are originaly from:
 ## Copyright & License
 
 Copyright © 2024 Taichi Ishitani.
-RuPkl is licensed under the terms of the [MIT License](https://opensource.org/licenses/MIT), see [LICENSE](LICENSE) for further details.
+RuPkl is licensed under the terms of the [MIT License](https://opensource.org/licenses/MIT), see [LICENSE.txt](LICENSE.txt) for further details.
 
 ## Code of Conduct
 

data/lib/rupkl/node/amend_expression.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    class AmendExpression
+      include NodeCommon
+
+      def initialize(parent, target, bodies, position)
+        super(parent, target, *bodies, position)
+        @target = target
+        @bodies = bodies
+      end
+
+      attr_reader :target
+      attr_reader :bodies
+
+      def evaluate(context = nil)
+        resolve_structure(context).evaluate(context)
+      end
+
+      def resolve_structure(context = nil)
+        t =
+          target
+            .resolve_reference(context)
+            .resolve_structure(context)
+        t.respond_to?(:body) ||
+          begin
+            message = "cannot amend the target type #{t.class.basename}"
+            raise EvaluationError.new(message, position)
+          end
+        do_amend(t.copy(parent))
+      end
+
+      def copy(parent = nil)
+        self.class.new(parent, target.copy, bodies.each(&:copy), position)
+      end
+
+      private
+
+      def do_amend(target)
+        bodies
+          .map { _1.copy(target).resolve_structure }
+          .then { target.merge!(*_1) }
+        target
+      end
+    end
+  end
+end

data/lib/rupkl/node/any.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    class Any
+      include NodeCommon
+
+      class << self
+        def abstract?
+          @abstract || false
+        end
+
+        def instantiable?
+          !@uninstantiable
+        end
+
+        def class_name
+          @class_name || basename.to_sym
+        end
+
+        def builtin_property(name)
+          @builtin_properties&.[](name.id)
+        end
+
+        def buildin_method(name)
+          @builtin_methods&.[](name.id)
+        end
+
+        private
+
+        def abstract_class
+          @abstract = true
+        end
+
+        def uninstantiable_class
+          @uninstantiable = true
+        end
+
+        def klass_name(name)
+          @class_name = name
+        end
+
+        def define_builtin_property(name, &body)
+          (@builtin_properties ||= {})[name] = body
+        end
+
+        def define_builtin_method(name, ...)
+          (@builtin_methods ||= {})[name] = BuiltinMethodDefinition.new(name, ...)
+        end
+      end
+
+      abstract_class
+      uninstantiable_class
+
+      def property(name)
+        builtin_property(name)
+      end
+
+      def pkl_method(name)
+        buildin_method(name)
+      end
+
+      def null?
+        false
+      end
+
+      private
+
+      def builtin_property(name)
+        self.class.ancestors.each do |klass|
+          next unless klass.respond_to?(:builtin_property)
+
+          body = klass.builtin_property(name)
+          return instance_exec(&body) if body
+        end
+
+        nil
+      end
+
+      def buildin_method(name)
+        self.class.ancestors.each do |klass|
+          next unless klass.respond_to?(:buildin_method)
+
+          method = klass.buildin_method(name)
+          return method if method
+        end
+
+        nil
+      end
+
+      def check_positive_number(number)
+        return unless number.value.negative?
+
+        m = "expected a positive number, but got '#{number.value}'"
+        raise EvaluationError.new(m, position)
+      end
+    end
+  end
+end

data/lib/rupkl/node/base.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    class Base < PklModule
+      include Singleton
+
+      def initialize
+        super(nil, nil, nil)
+      end
+
+      attr_reader :pkl_classes
+
+      class << self
+        private
+
+        def add_builtin_class(klass)
+          instance.instance_eval do
+            name = klass.class_name
+            (@pkl_classes ||= {})[name] = klass
+          end
+        end
+      end
+
+      add_builtin_class Any
+      add_builtin_class Boolean
+      add_builtin_class Number
+      add_builtin_class Int
+      add_builtin_class Float
+      add_builtin_class String
+      add_builtin_class Dynamic
+      add_builtin_class Mapping
+      add_builtin_class Listing
+      add_builtin_class PklModule
+
+      define_builtin_property(:NaN) do
+        Float.new(parent, ::Float::NAN, position)
+      end
+
+      define_builtin_property(:Infinity) do
+        Float.new(parent, ::Float::INFINITY, position)
+      end
+    end
+  end
+end

data/lib/rupkl/node/boolean.rb

@@ -2,12 +2,10 @@
 
 module RuPkl
   module Node
-    class Boolean
+    class Boolean < Any
       include ValueCommon
 
-      def evaluate(_scopes)
-        self
-      end
+      uninstantiable_class
 
       def undefined_operator?(operator)
         [:!, :==, :'!=', :'&&', :'||'].none?(operator)
@@ -16,6 +14,16 @@ module RuPkl
       def short_circuit?(operator)
         [operator, value] in [:'&&', false] | [:'||', true]
       end
+
+      define_builtin_method(:xor, other: Boolean) do |other|
+        result = value ^ other.value
+        Boolean.new(nil, result, position)
+      end
+
+      define_builtin_method(:implies, other: Boolean) do |other|
+        result = !value || other.value
+        Boolean.new(nil, result, position)
+      end
     end
   end
 end

data/lib/rupkl/node/context.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    class Context
+      def initialize(scopes, objects)
+        @scopes = scopes
+        @objects = objects
+      end
+
+      attr_reader :scopes
+      attr_reader :objects
+
+      def push_scope(scope)
+        Context.new([*scopes, scope], objects)
+      end
+
+      def push_object(object)
+        Context.new(scopes, [*objects, object])
+      end
+
+      def pop
+        Context.new(scopes&.slice(..-2), objects&.slice(..-2))
+      end
+    end
+  end
+end

data/lib/rupkl/node/declared_type.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    class DeclaredType
+      include TypeCommon
+
+      def initialize(parent, type, position)
+        super(parent, *type, position)
+        @type = type
+      end
+
+      attr_reader :type
+
+      def find_class(context)
+        find_type(type, context)
+      end
+
+      def to_s
+        type.last.id.to_s
+      end
+
+      private
+
+      def match_type?(klass, context)
+        rhs = klass
+        lhs = find_class(context)
+        rhs <= lhs
+      end
+    end
+  end
+end

data/lib/rupkl/node/dynamic.rb

@@ -2,36 +2,19 @@
 
 module RuPkl
   module Node
-    class Dynamic
+    class Dynamic < Any
       include StructCommon
 
-      def initialize(members, scopes, position)
-        @position = position
-        add_members(members, scopes)
+      def properties
+        @body&.properties(visibility: :object)
       end
 
-      attr_reader :properties
-      attr_reader :entries
-      attr_reader :elements
-      attr_reader :position
-
-      def evaluate(_scopes)
-        self
-      end
-
-      def to_ruby(_scopes)
-        create_pkl_object(nil, properties, entries, elements)
+      def entries
+        @body&.entries
       end
 
-      def to_pkl_string(_scopes)
-        to_pkl_string_object(*properties, *entries, *elements)
-      end
-
-      def merge!(other)
-        @properties = merge_hash_members(properties, other.properties, :name)
-        @entries = merge_hash_members(entries, other.entries, :key)
-        @elements = merge_array_members(elements, other.elements)
-        self
+      def elements
+        @body&.elements
       end
 
       def ==(other)
@@ -41,58 +24,44 @@ module RuPkl
           match_members?(elements, other.elements, true)
       end
 
-      def undefined_operator?(operator)
-        [:[], :==, :'!='].none?(operator)
-      end
-
       def find_by_key(key)
         find_entry(key) || find_element(key)
       end
 
-      private
-
-      def add_members(members, scopes)
-        return unless members
+      define_builtin_method(:length) do
+        result = elements&.size || 0
+        Int.new(nil, result, position)
+      end
 
-        push_scope(scopes) do |s|
-          members.each { |m| add_member(m, s) }
-        end
+      define_builtin_method(:hasProperty, name: String) do |name|
+        result = find_property(name.value.to_sym) && true || false
+        Boolean.new(nil, result, position)
       end
 
-      def add_member(member, scopes)
-        member.evaluate(scopes).then do |m|
-          case member
-          when ObjectProperty then add_property(m)
-          when ObjectEntry then add_entry(m)
-          else add_element(m)
+      define_builtin_method(:getProperty, name: String) do |name|
+        find_property(name.value.to_sym) ||
+          begin
+            m = "cannot find property '#{name.value}'"
+            raise EvaluationError.new(m, position)
           end
-        end
       end
 
-      def add_property(member)
-        add_hash_member((@properties ||= []), member, :name)
+      define_builtin_method(:getPropertyOrNull, name: String) do |name|
+        find_property(name.value.to_sym) || Null.new(nil, position)
       end
 
-      def add_entry(member)
-        add_hash_member((@entries ||= []), member, :key)
-      end
+      private
 
-      def add_element(member)
-        add_array_member((@elements ||= []), member)
+      def properties_not_allowed?
+        false
       end
 
-      def find_entry(key)
-        entries
-          &.find { _1.key == key }
-          &.then(&:value)
+      def entries_not_allowed?
+        false
       end
 
-      def find_element(index)
-        return nil unless elements
-        return nil unless index.value.is_a?(::Integer)
-
-        elements
-          .find.with_index { |_, i| i == index.value }
+      def elements_not_allowed?
+        false
       end
     end
   end

data/lib/rupkl/node/identifier.rb

@@ -3,17 +3,27 @@
 module RuPkl
   module Node
     class Identifier
-      def initialize(id, position)
+      include NodeCommon
+
+      def initialize(parent, id, position)
+        super(parent, position)
         @id = id
-        @position = position
       end
 
-      def ==(other)
-        other.instance_of?(self.class) && id == other.id
+      attr_reader :id
+
+      def copy(parent = nil)
+        self.class.new(parent, id, position)
       end
 
-      attr_reader :id
-      attr_reader :position
+      def ==(other)
+        id ==
+          if other.respond_to?(:id)
+            other.id
+          else
+            other
+          end
+      end
     end
   end
 end

data/lib/rupkl/node/listing.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    class Listing < Any
+      include StructCommon
+
+      def elements
+        @body&.elements
+      end
+
+      def ==(other)
+        other.instance_of?(self.class) &&
+          match_members?(elements, other.elements, true)
+      end
+
+      def find_by_key(key)
+        find_element(key)
+      end
+
+      define_builtin_property(:isEmpty) do
+        result = elements.nil? || elements.empty?
+        Boolean.new(self, result, position)
+      end
+
+      define_builtin_property(:length) do
+        result = elements&.size || 0
+        Int.new(self, result, position)
+      end
+
+      define_builtin_property(:isDistinct) do
+        result =
+          elements.nil? ||
+          elements.all? { |lhs| elements.one? { |rhs| rhs == lhs } }
+        Boolean.new(self, result || elements.nil?, position)
+      end
+
+      define_builtin_property(:distinct) do
+        result =
+          elements
+            &.each_with_object([]) { |e, l| l << e unless l.include?(e) }
+        body = ObjectBody.new(nil, result, position)
+        Listing.new(self, body, position)
+      end
+
+      define_builtin_method(:join, separator: String) do |separator|
+        result =
+          elements
+            &.map { _1.value.to_string }
+            &.join(separator.value)
+        String.new(nil, result || '', nil, position)
+      end
+
+      private
+
+      def elements_not_allowed?
+        false
+      end
+    end
+  end
+end

data/lib/rupkl/node/mapping.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    class Mapping < Any
+      include StructCommon
+
+      def entries
+        @body&.entries
+      end
+
+      def ==(other)
+        other.instance_of?(self.class) &&
+          match_members?(entries, other.entries, false)
+      end
+
+      def find_by_key(key)
+        find_entry(key)
+      end
+
+      define_builtin_property(:isEmpty) do
+        result = entries.nil? || entries.empty?
+        Boolean.new(self, result, position)
+      end
+
+      define_builtin_property(:length) do
+        result = entries&.size || 0
+        Int.new(self, result, position)
+      end
+
+      define_builtin_method(:containsKey, key: Any) do |key|
+        result = find_entry(key) && true || false
+        Boolean.new(nil, result, position)
+      end
+
+      define_builtin_method(:getOrNull, key: Any) do |key|
+        find_entry(key) || Null.new(nil, position)
+      end
+
+      private
+
+      def entries_not_allowed?
+        false
+      end
+    end
+  end
+end

data/lib/rupkl/node/member_finder.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    module MemberFinder
+      def property(name)
+        value = find_property(name)
+        return value if value
+
+        super if self.class <= Any
+      end
+
+      def pkl_method(name)
+        method = find_pkl_method(name)
+        return method if method
+
+        super if self.class <= Any
+      end
+
+      private
+
+      def find_property(name)
+        return unless respond_to?(:properties)
+
+        properties
+          &.find { _1.name == name }
+          &.value
+      end
+
+      def find_entry(key)
+        return unless respond_to?(:entries)
+
+        entries
+          &.find { _1.key == key }
+          &.value
+      end
+
+      def find_element(index)
+        return unless respond_to?(:elements)
+        return unless elements
+        return unless index.value.is_a?(::Integer)
+
+        elements
+          .find.with_index { |_, i| i == index.value }
+          &.value
+      end
+
+      def find_pkl_method(name)
+        return unless respond_to?(:pkl_methods)
+
+        pkl_methods&.find { _1.name == name }
+      end
+    end
+  end
+end