rupkl 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8b6a7346123ff0c771a201f1218f0c2d92e3c34a16e4fe0f668724eb53726ee
-  data.tar.gz: 169990d7f909f37f72ea97ba2ff44c9634137fead23791ab6a80fddd9b3af109
+  metadata.gz: f84f197edd08a0aa623b11f6fd14c83e3fefaf880f0b70a8f6e84eb6599f4ad6
+  data.tar.gz: 9f3294541be5d4ea4ac6c71fe12f501752cf3b6c447194a8b6254723742c169b
 SHA512:
-  metadata.gz: 50e6f855bec47026a3a6f4b8b61b9fd61ceafc7686bcd0a51f459a42ae88a97ee954fb362f3450c89d6499fe6e1d97f2b2350350a2820607c007bc7a8e8d8190
-  data.tar.gz: ad63c41fa79cc9b487d6d3c7f4b129febbf914e564f15d9921072cf4680442dcc77c605d8d7cc283aa15662f15247f427ccbd218c2a1856681ca402500e2810f
+  metadata.gz: a4ed0408a38e1db11008cd03922c295ac0e0fd42b22a2d9c6d47bd91e73f3de344aa2af1559d4e83d407a49cc51ec95e595da83ce0572d6b1ab86d17c4f79e05
+  data.tar.gz: a055b31ced095d7e8f851830c03daf63388d1ef23f343e7f1dd6292205e9a0a99a54bc2b5119e9489487084fe28b2d3a37af28c21197b0d0f7367e39446bffbb

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_name}"
+            raise EvaluationError.new(message, position)
+          end
+        do_amend(t.copy(parent))
+      end
+
+      def copy(parent = nil, position = @position)
+        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,110 @@
+# 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 ||= to_s.split('::').last.to_sym
+        end
+
+        def builtin_property(name)
+          @builtin_properties&.[](name.to_sym)
+        end
+
+        def buildin_method(name)
+          @builtin_methods&.[](name.to_sym)
+        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
+
+      def class_name
+        self.class.class_name
+      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, position)
+        return unless number.value.negative?
+
+        m = "expected a positive number, but got '#{number.value}'"
+        raise EvaluationError.new(m, position)
+      end
+
+      protected
+
+      def execute_builtin_method(name, arguments, parent, position)
+        buildin_method(name)
+          .execute_method(self, arguments, parent, position)
+      end
+    end
+  end
+end

data/lib/rupkl/node/base.rb

@@ -0,0 +1,75 @@
+# 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(self, ::Float::NAN, position)
+      end
+
+      define_builtin_property(:Infinity) do
+        Float.new(self, ::Float::INFINITY, position)
+      end
+
+      define_builtin_method(
+        :List, elements: [Any, varparams: true]
+      ) do |args, parent, position|
+        List.new(parent, args[:elements], position)
+      end
+
+      define_builtin_method(
+        :Set, elements: [Any, varparams: true]
+      ) do |args, parent, position|
+        Set.new(parent, args[:elements], position)
+      end
+
+      define_builtin_method(:Pair, first: Any, second: Any) do |args, parent, position|
+        Pair.new(parent, args[:first], args[:second], position)
+      end
+
+      define_builtin_method(
+        :Map, entries: [Any, varparams: true]
+      ) do |args, parent, position|
+        Map.new(parent, args[:entries], position)
+      end
+
+      define_builtin_method(:IntSeq, start: Int, last: Int) do |args, parent, position|
+        IntSeq.new(parent, args[:start], args[:last], nil, position)
+      end
+
+      define_builtin_method(:Regex, pattern: String) do |args, parent, position|
+        Regex.new(parent, args[:pattern], position)
+      end
+    end
+  end
+end

data/lib/rupkl/node/boolean.rb

@@ -2,15 +2,40 @@
 
 module RuPkl
   module Node
-    class Boolean
+    class Boolean < Any
       include ValueCommon
+      include Operatable
 
-      def evaluate(_scopes)
-        self
+      uninstantiable_class
+
+      def u_op_negate(position)
+        Boolean.new(nil, !value, position)
+      end
+
+      def b_op_and(r_operand, position)
+        result = value && r_operand.value
+        Boolean.new(nil, result, position)
+      end
+
+      def b_op_or(r_operand, position)
+        result = value || r_operand.value
+        Boolean.new(nil, result, position)
       end
 
-      def undefined_operator?(operator)
-        [:!, :==, :'!=', :'&&', :'||'].none?(operator)
+      define_builtin_method(:xor, other: Boolean) do |args, parent, position|
+        result = value ^ args[:other].value
+        Boolean.new(parent, result, position)
+      end
+
+      define_builtin_method(:implies, other: Boolean) do |args, parent, position|
+        result = !value || args[:other].value
+        Boolean.new(parent, result, position)
+      end
+
+      private
+
+      def defined_operator?(operator)
+        [:'!@', :'&&', :'||'].any?(operator)
       end
 
       def short_circuit?(operator)

data/lib/rupkl/node/collection.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    class Collection < Any
+      include Operatable
+
+      abstract_class
+      uninstantiable_class
+
+      def initialize(parent, elements, position)
+        super(parent, *elements, position)
+      end
+
+      alias_method :elements, :children
+
+      def evaluate(_context = nil)
+        self
+      end
+
+      def to_ruby(context = nil)
+        elements&.map { _1.to_ruby(context) } || []
+      end
+
+      def to_pkl_string(context = nil)
+        to_string(context)
+      end
+
+      def to_string(context = nil)
+        element_string =
+          elements
+            &.map { _1.to_pkl_string(context) }
+            &.join(', ')
+        "#{class_name}(#{element_string})"
+      end
+
+      def ==(other)
+        other.instance_of?(self.class) && elements == other.elements
+      end
+
+      def b_op_add(r_operand, position)
+        result =
+          if elements && r_operand.elements
+            elements + r_operand.elements
+          else
+            elements || r_operand.elements
+          end
+        self.class.new(nil, result, position)
+      end
+
+      define_builtin_property(:length) do
+        result = elements&.size || 0
+        Int.new(self, result, position)
+      end
+
+      define_builtin_property(:isEmpty) do
+        result = elements.nil? || elements.empty?
+        Boolean.new(self, result, position)
+      end
+
+      define_builtin_property(:first) do
+        elements&.first || raise_wrong_collection_size_error
+      end
+
+      define_builtin_property(:firstOrNull) do
+        elements&.first || Null.new(parent, position)
+      end
+
+      define_builtin_property(:rest) do
+        if (result = elements&.[](1..))
+          self.class.new(parent, result, position)
+        else
+          raise_wrong_collection_size_error
+        end
+      end
+
+      define_builtin_property(:restOrNull) do
+        if (result = elements&.[](1..))
+          self.class.new(parent, result, position)
+        else
+          Null.new(parent, position)
+        end
+      end
+
+      define_builtin_property(:last) do
+        elements&.last || raise_wrong_collection_size_error
+      end
+
+      define_builtin_property(:lastOrNull) do
+        elements&.last || Null.new(parent, position)
+      end
+
+      define_builtin_property(:single) do
+        size = elements&.size || 0
+        size == 1 && elements.first ||
+          raise_wrong_collection_size_error { 'expected a single-element collection' }
+      end
+
+      define_builtin_property(:singleOrNull) do
+        size = elements&.size || 0
+        size == 1 && elements.first || Null.new(parent, position)
+      end
+
+      define_builtin_property(:lastIndex) do
+        result = (elements&.size || 0) - 1
+        Int.new(parent, result, position)
+      end
+
+      private
+
+      def remove_duplicate_elements(elements)
+        elements
+          &.each_with_object([]) { |e, a| a.include?(e) || (a << e) }
+      end
+
+      def raise_wrong_collection_size_error
+        message =
+          if block_given?
+            yield
+          else
+            'expected a non-empty collection'
+          end
+        raise EvaluationError.new(message, position)
+      end
+
+      def valid_r_operand?(operator, operand)
+        operand.is_a?(self.class) ||
+          operator == :+ && (operand in List | Set)
+      end
+    end
+
+    class List < Collection
+      include MemberFinder
+      undef_method :pkl_method
+
+      uninstantiable_class
+
+      def find_by_key(key)
+        find_element(key)
+      end
+
+      define_builtin_property(:isDistinct) do
+        result =
+          elements.nil? ||
+          elements.all? { |e| elements.one?(e) }
+        Boolean.new(parent, result, position)
+      end
+
+      define_builtin_property(:distinct) do
+        result = remove_duplicate_elements(elements)
+        List.new(parent, result, position)
+      end
+
+      private
+
+      def defined_operator?(operator)
+        [:[], :+].any?(operator)
+      end
+    end
+
+    class Set < Collection
+      uninstantiable_class
+
+      def initialize(parent, elements, position)
+        unique_elements = remove_duplicate_elements(elements)
+        super(parent, unique_elements, position)
+      end
+
+      private
+
+      def defined_operator?(operator)
+        operator == :+
+      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