rupkl 0.1.0 → 0.3.0

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

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

@@ -0,0 +1,266 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    class Duration < 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)
+        Duration.new(nil, value.u_op_minus(position), unit, position)
+      end
+
+      def ==(other)
+        other.is_a?(Duration) &&
+          begin
+            l = calc_second(self)
+            r = calc_second(other)
+            l.value == r.value
+          end
+      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_second(self)
+          #   r = calc_second(r_operand)
+          #   l.b_op_lt(r, position)
+          # end
+          def #{method_name}(r_operand, position)
+            l = calc_second(self)
+            r = calc_second(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)
+          #   Duration.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)
+            Duration.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)
+          #   Duration.new(nil, result, unit, position)
+          # end
+          def #{method_name}(r_operand, position)
+            result = value.#{method_name}(r_operand, position)
+            Duration.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?(Duration)
+          #     l = calc_second(self)
+          #     r = calc_second(r_operand)
+          #     l.b_op_div(r, position)
+          #   else
+          #     result = value.b_op_div(r_operand, position)
+          #     Duration.new(nil, result, unit, position)
+          #   end
+          # end
+          def #{method_name}(r_operand, position)
+            if r_operand.is_a?(Duration)
+              l = calc_second(self)
+              r = calc_second(r_operand)
+              l.#{method_name}(r, position)
+            else
+              result = value.#{method_name}(r_operand, position)
+              Duration.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(:isoString) do
+        unless value.value.finite?
+          message = "cannot convert duration '#{to_string(nil)}' to ISO 8601 duration"
+          raise EvaluationError.new(message, position)
+        end
+
+        String.new(self, iso8601_string, nil, position)
+      end
+
+      define_builtin_method(
+        :isBetween, first: Duration, last: Duration
+      ) do |args, parent, position|
+        r = calc_second(self)
+        f = calc_second(args[:first])
+        l = calc_second(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)
+        Duration.new(parent, value, unit, position)
+      end
+
+      private
+
+      UNIT_FACTOR = {
+        ns: 10.0**-9, us: 10.0**-6, ms: 10.0**-3,
+        s: 1, min: 60, h: 60 * 60, d: 24 * 60 * 60
+      }.freeze
+
+      def unit_factor(unit)
+        factor = UNIT_FACTOR[unit]
+        if factor >= 1
+          Int.new(nil, factor, nil)
+        else
+          Float.new(nil, factor, nil)
+        end
+      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 | Duration
+        else super
+        end
+      end
+
+      def calc_second(duration)
+        factor = unit_factor(duration.unit)
+        duration.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(duration, unit, position)
+        return duration.value if duration.unit == unit
+
+        second = calc_second(duration)
+        result = second.b_op_div(unit_factor(unit), position)
+        if result.value.to_i == result.value
+          Int.new(nil, result.value, position)
+        else
+          result
+        end
+      end
+
+      def iso8601_string
+        return 'PT0S' if value.value.zero?
+
+        parts = value.value.negative? && ['-PT'] || ['PT']
+        iso8601_elements.each do |unit, n|
+          parts << format_iso8601_element(unit, n)
+        end
+
+        parts.join
+      end
+
+      def iso8601_elements
+        result, _ =
+          [:h, :min, :s]
+            .inject([{}, calc_second(self).value.abs]) do |(elements, sec), unit|
+              q, r =
+                if unit == :s
+                  sec
+                else
+                  sec.divmod(UNIT_FACTOR[unit])
+                end
+              elements[unit] = q if q.positive?
+
+              [elements, r]
+            end
+
+        result
+      end
+
+      def format_iso8601_element(unit, value)
+        s =
+          if unit != :s || value.to_i == value
+            value
+          else
+            format('%.12f', value).sub(/0+\Z/, '')
+          end
+        "#{s}#{unit[0].upcase}"
+      end
+
+      def unit_symbol(string, position)
+        symbol = string.value.to_sym
+        return symbol if UNIT_FACTOR.key?(symbol)
+
+        message =
+          'expected value of type ' \
+          '"ns"|"us"|"ms"|"s"|"min"|"h"|"d", ' \
+          "but got #{string.to_pkl_string(nil)}"
+        raise EvaluationError.new(message, position)
+      end
+    end
+  end
+end

data/lib/rupkl/node/dynamic.rb

@@ -2,36 +2,20 @@
 
 module RuPkl
   module Node
-    class Dynamic
+    class Dynamic < Any
+      include Operatable
       include StructCommon
 
-      def initialize(members, scopes, position)
-        @position = position
-        add_members(members, scopes)
+      def entries
+        @body&.entries
       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 elements
+        @body&.elements
       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 to_ruby(context = nil)
+        to_pkl_object(context)
       end
 
       def ==(other)
@@ -41,58 +25,47 @@ 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)
+        (find_entry(key) || find_element(key))&.value
       end
 
-      private
-
-      def add_members(members, scopes)
-        return unless members
+      define_builtin_method(:length) do |_, parent, position|
+        result = elements&.size || 0
+        Int.new(parent, result, position)
+      end
 
-        push_scope(scopes) do |s|
-          members.each { |m| add_member(m, s) }
-        end
+      define_builtin_method(:hasProperty, name: String) do |args, parent, position|
+        name = args[:name].value.to_sym
+        result = find_property(name) && true || false
+        Boolean.new(parent, 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 |args, _, position|
+        name = args[:name].value.to_sym
+        find_property(name)&.value ||
+          begin
+            m = "cannot find property '#{name}'"
+            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 |args, parent, position|
+        name = args[:name].value.to_sym
+        find_property(name)&.value || Null.new(parent, 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