rupkl 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d7731a56bb62b392639860c5e0f82c2175e8bca4ecd439e8ccffd05d9b223b0f
-  data.tar.gz: 18487cb107c5a47212d185d782f4866d5fc5c0734b893986e4388c003728687d
+  metadata.gz: f84f197edd08a0aa623b11f6fd14c83e3fefaf880f0b70a8f6e84eb6599f4ad6
+  data.tar.gz: 9f3294541be5d4ea4ac6c71fe12f501752cf3b6c447194a8b6254723742c169b
 SHA512:
-  metadata.gz: e9d8c2d0d8d9f4976ba804810285344b8f5a6cd308ce1eeff23eb3503feb365c2415d1876c8c879fdf38ca016b01dc849aaeb2e01ae502b9c0e0a44a1a2123ce
-  data.tar.gz: 2bc34ee5b570519a913299dbe5415fe9a7e3dd406b5912f729127ce152c18fd6821f769f9c6df6e677c0c114de935f401584e67e5ae385133aef318810f57ce0
+  metadata.gz: a4ed0408a38e1db11008cd03922c295ac0e0fd42b22a2d9c6d47bd91e73f3de344aa2af1559d4e83d407a49cc51ec95e595da83ce0572d6b1ab86d17c4f79e05
+  data.tar.gz: a055b31ced095d7e8f851830c03daf63388d1ef23f343e7f1dd6292205e9a0a99a54bc2b5119e9489487084fe28b2d3a37af28c21197b0d0f7367e39446bffbb

data/lib/rupkl/node/amend_expression.rb

@@ -25,13 +25,13 @@ module RuPkl
             .resolve_structure(context)
         t.respond_to?(:body) ||
           begin
-            message = "cannot amend the target type #{t.class.basename}"
+            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)
+      def copy(parent = nil, position = @position)
         self.class.new(parent, target.copy, bodies.each(&:copy), position)
       end
 

data/lib/rupkl/node/any.rb

@@ -15,15 +15,15 @@ module RuPkl
         end
 
         def class_name
-          @class_name || basename.to_sym
+          @class_name ||= to_s.split('::').last.to_sym
         end
 
         def builtin_property(name)
-          @builtin_properties&.[](name.id)
+          @builtin_properties&.[](name.to_sym)
         end
 
         def buildin_method(name)
-          @builtin_methods&.[](name.id)
+          @builtin_methods&.[](name.to_sym)
         end
 
         private
@@ -64,6 +64,10 @@ module RuPkl
         false
       end
 
+      def class_name
+        self.class.class_name
+      end
+
       private
 
       def builtin_property(name)
@@ -88,12 +92,19 @@ module RuPkl
         nil
       end
 
-      def check_positive_number(number)
+      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

@@ -34,11 +34,41 @@ module RuPkl
       add_builtin_class PklModule
 
       define_builtin_property(:NaN) do
-        Float.new(parent, ::Float::NAN, position)
+        Float.new(self, ::Float::NAN, position)
       end
 
       define_builtin_property(:Infinity) do
-        Float.new(parent, ::Float::INFINITY, position)
+        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

data/lib/rupkl/node/boolean.rb

@@ -4,25 +4,42 @@ module RuPkl
   module Node
     class Boolean < Any
       include ValueCommon
+      include Operatable
 
       uninstantiable_class
 
-      def undefined_operator?(operator)
-        [:!, :==, :'!=', :'&&', :'||'].none?(operator)
+      def u_op_negate(position)
+        Boolean.new(nil, !value, position)
       end
 
-      def short_circuit?(operator)
-        [operator, value] in [:'&&', false] | [:'||', true]
+      def b_op_and(r_operand, position)
+        result = value && r_operand.value
+        Boolean.new(nil, result, position)
       end
 
-      define_builtin_method(:xor, other: Boolean) do |other|
-        result = value ^ other.value
+      def b_op_or(r_operand, position)
+        result = value || r_operand.value
         Boolean.new(nil, result, position)
       end
 
-      define_builtin_method(:implies, other: Boolean) do |other|
-        result = !value || other.value
-        Boolean.new(nil, result, position)
+      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)
+        [operator, value] in [:'&&', false] | [:'||', true]
       end
     end
   end

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/data_size.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    class DataSize < Any
+      include Operatable
+
+      uninstantiable_class
+
+      def initialize(parent, value, unit, position)
+        super(parent, value, position)
+        @unit = unit
+      end
+
+      attr_reader :unit
+
+      def value
+        @children[0]
+      end
+
+      def evaluate(_context = nil)
+        self
+      end
+
+      def to_ruby(context = nil)
+        value.to_ruby(context) * unit_factor(unit)
+      end
+
+      def to_pkl_string(context = nil)
+        to_string(context)
+      end
+
+      def to_string(context = nil)
+        "#{value.to_pkl_string(context)}.#{unit}"
+      end
+
+      def u_op_minus(position)
+        DataSize.new(nil, value.u_op_minus(position), unit, position)
+      end
+
+      def ==(other)
+        other.is_a?(DataSize) &&
+          calc_byte_size(self).value == calc_byte_size(other).value
+      end
+
+      [:b_op_lt, :b_op_gt, :b_op_le, :b_op_ge].each do |method_name|
+        class_eval(<<~M, __FILE__, __LINE__ + 1)
+          # def b_op_lt(r_operand, position)
+          # l = calc_byte_size(self)
+          # r = calc_byte_size(r_operand)
+          # l.b_op_lt(r, position)
+          # end
+          def #{method_name}(r_operand, position)
+            l = calc_byte_size(self)
+            r = calc_byte_size(r_operand)
+            l.#{method_name}(r, position)
+          end
+        M
+      end
+
+      [:b_op_add, :b_op_sub].each do |method_name|
+        class_eval(<<~M, __FILE__, __LINE__ + 1)
+          # def b_op_add(r_operand, position)
+          #   l, r, u = align_unit(self, r_operand)
+          #   result = l.b_op_add(r, position)
+          #   DataSize.new(nil, result, u, position)
+          # end
+          def #{method_name}(r_operand, position)
+            l, r, u = align_unit(self, r_operand)
+            result = l.#{method_name}(r, position)
+            DataSize.new(nil, result, u, position)
+          end
+        M
+      end
+
+      [:b_op_mul, :b_op_rem, :b_op_exp].each do |method_name|
+        class_eval(<<~M, __FILE__, __LINE__ + 1)
+          # def b_op_mul(r_operand, position)
+          #   result = value.b_op_mul(r_operand, position)
+          #   DataSize.new(nil, result, unit, position)
+          # end
+          def #{method_name}(r_operand, position)
+            result = value.#{method_name}(r_operand, position)
+            DataSize.new(nil, result, unit, position)
+          end
+        M
+      end
+
+      [:b_op_div, :b_op_truncating_div].each do |method_name|
+        class_eval(<<~M, __FILE__, __LINE__ + 1)
+          # def b_op_div(r_operand, position)
+          #   if r_operand.is_a?(DataSize)
+          #     l = calc_byte_size(self)
+          #     r = calc_byte_size(r_operand)
+          #     l.b_op_div(r, position)
+          #   else
+          #     result = value.b_op_div(r_operand, position)
+          #     DataSize.new(nil, result, unit, position)
+          #   end
+          # end
+          def #{method_name}(r_operand, position)
+            if r_operand.is_a?(DataSize)
+              l = calc_byte_size(self)
+              r = calc_byte_size(r_operand)
+              l.#{method_name}(r, position)
+            else
+              result = value.#{method_name}(r_operand, position)
+              DataSize.new(nil, result, unit, position)
+            end
+          end
+        M
+      end
+
+      define_builtin_property(:value) do
+        value
+      end
+
+      define_builtin_property(:unit) do
+        String.new(self, unit.to_s, nil, position)
+      end
+
+      define_builtin_property(:isPositive) do
+        result = value.value.zero? || value.value.positive?
+        Boolean.new(self, result, position)
+      end
+
+      define_builtin_property(:isBinaryUnit) do
+        result = [:b, :kib, :mib, :gib, :tib, :pib].include?(unit)
+        Boolean.new(self, result, position)
+      end
+
+      define_builtin_property(:isDecimalUnit) do
+        result = [:b, :kb, :mb, :gb, :tb, :pb].include?(unit)
+        Boolean.new(self, result, position)
+      end
+
+      define_builtin_method(
+        :isBetween, first: DataSize, last: DataSize
+      ) do |args, parent, position|
+        r = calc_byte_size(self)
+        f = calc_byte_size(args[:first])
+        l = calc_byte_size(args[:last])
+        r.execute_builtin_method(:isBetween, { first: f, last: l }, parent, position)
+      end
+
+      define_builtin_method(:toUnit, unit: String) do |args, parent, position|
+        unit = unit_symbol(args[:unit], position)
+        value = convert_unit(self, unit, position)
+        DataSize.new(parent, value, unit, position)
+      end
+
+      define_builtin_method(:toBinaryUnit) do |_args, parent, position|
+        if (unit = to_binary_unit)
+          value = convert_unit(self, unit, position)
+          DataSize.new(parent, value, unit, position)
+        else
+          self
+        end
+      end
+
+      define_builtin_method(:toDecimalUnit) do |_args, parent, position|
+        if (unit = to_decimal_unit)
+          value = convert_unit(self, unit, position)
+          DataSize.new(parent, value, unit, position)
+        else
+          self
+        end
+      end
+
+      private
+
+      UNIT_FACTOR = {
+        b: 1000**0,
+        kb: 1000**1, mb: 1000**2, gb: 1000**3,
+        tb: 1000**4, pb: 1000**5,
+        kib: 1024**1, mib: 1024**2, gib: 1024**3,
+        tib: 1024**4, pib: 1024**5
+      }.freeze
+
+      def unit_factor(unit)
+        UNIT_FACTOR[unit]
+      end
+
+      def defined_operator?(operator)
+        [:[], :'!@', :'&&', :'||'].none?(operator)
+      end
+
+      def valid_r_operand?(operator, operand)
+        case operator
+        when :*, :%, :** then operand in Number
+        when :/, :'~/' then operand in Number | DataSize
+        else super
+        end
+      end
+
+      def calc_byte_size(data_size)
+        factor = Int.new(nil, unit_factor(data_size.unit), nil)
+        data_size.value.b_op_mul(factor, nil)
+      end
+
+      def align_unit(l_operand, r_operand)
+        unit =
+          if unit_factor(l_operand.unit) >= unit_factor(r_operand.unit)
+            l_operand.unit
+          else
+            r_operand.unit
+          end
+
+        [
+          convert_unit(l_operand, unit, position),
+          convert_unit(r_operand, unit, position),
+          unit
+        ]
+      end
+
+      def convert_unit(data_size, unit, position)
+        return data_size.value if data_size.unit == unit
+
+        byte_size = calc_byte_size(data_size)
+        factor = Int.new(nil, unit_factor(unit), nil)
+        if (byte_size.value % factor.value).zero?
+          byte_size.b_op_truncating_div(factor, position)
+        else
+          byte_size.b_op_div(factor, position)
+        end
+      end
+
+      def unit_symbol(string, position)
+        symbol = string.value.to_sym
+        return symbol if UNIT_FACTOR.key?(symbol)
+
+        message =
+          'expected value of type ' \
+          '"b"|"kb"|"kib"|"mb"|"mib"|"gb"|"gib"|"tb"|"tib"|"pb"|"pib", ' \
+          "but got #{string.to_pkl_string(nil)}"
+        raise EvaluationError.new(message, position)
+      end
+
+      def to_binary_unit
+        {
+          kb: :kib, mb: :mib, gb: :gib,
+          tb: :tib, pb: :pib
+        }[unit]
+      end
+
+      def to_decimal_unit
+        {
+          kib: :kb, mib: :mb, gib: :gb,
+          tib: :tb, pib: :pb
+        }[unit]
+      end
+    end
+  end
+end