rupkl 0.2.0 → 0.3.0

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

@@ -3,12 +3,9 @@
 module RuPkl
   module Node
     class Dynamic < Any
+      include Operatable
       include StructCommon
 
-      def properties
-        @body&.properties(visibility: :object)
-      end
-
       def entries
         @body&.entries
       end
@@ -17,6 +14,10 @@ module RuPkl
         @body&.elements
       end
 
+      def to_ruby(context = nil)
+        to_pkl_object(context)
+      end
+
       def ==(other)
         other.instance_of?(self.class) &&
           match_members?(properties, other.properties, false) &&
@@ -25,29 +26,32 @@ module RuPkl
       end
 
       def find_by_key(key)
-        find_entry(key) || find_element(key)
+        (find_entry(key) || find_element(key))&.value
       end
 
-      define_builtin_method(:length) do
+      define_builtin_method(:length) do |_, parent, position|
         result = elements&.size || 0
-        Int.new(nil, result, position)
+        Int.new(parent, result, position)
       end
 
-      define_builtin_method(:hasProperty, name: String) do |name|
-        result = find_property(name.value.to_sym) && true || false
-        Boolean.new(nil, result, position)
+      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
 
-      define_builtin_method(:getProperty, name: String) do |name|
-        find_property(name.value.to_sym) ||
+      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.value}'"
+            m = "cannot find property '#{name}'"
             raise EvaluationError.new(m, position)
           end
       end
 
-      define_builtin_method(:getPropertyOrNull, name: String) do |name|
-        find_property(name.value.to_sym) || Null.new(nil, position)
+      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
 
       private

data/lib/rupkl/node/identifier.rb

@@ -12,7 +12,7 @@ module RuPkl
 
       attr_reader :id
 
-      def copy(parent = nil)
+      def copy(parent = nil, position = @position)
         self.class.new(parent, id, position)
       end
 
@@ -24,6 +24,10 @@ module RuPkl
             other
           end
       end
+
+      def to_sym
+        id.to_sym
+      end
     end
   end
 end

data/lib/rupkl/node/if_expression.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    class IfExpression
+      include NodeCommon
+
+      def condition
+        @children[0]
+      end
+
+      def if_expression
+        @children[1]
+      end
+
+      def else_expression
+        @children[2]
+      end
+
+      def evaluate(context = nil)
+        resolve_structure(context).evaluate(context)
+      end
+
+      def resolve_structure(context = nil)
+        @result ||=
+          if evaluate_condition(context)
+            if_expression
+          else
+            else_expression
+          end
+        @result.resolve_structure(context)
+      end
+
+      private
+
+      def evaluate_condition(context)
+        evaluated = condition.evaluate(context)
+        return evaluated.value if evaluated.is_a?(Boolean)
+
+        message = "expected type 'Boolean', but got type '#{evaluated.class_name}'"
+        raise EvaluationError.new(message, position)
+      end
+    end
+  end
+end

data/lib/rupkl/node/intseq.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    class IntSeq < Any
+      include Operatable
+
+      uninstantiable_class
+
+      def initialize(parent, start, last, step, position)
+        super(parent, *[start, last, step].compact, position)
+      end
+
+      def start
+        children[0]
+      end
+
+      def last
+        children[1]
+      end
+
+      alias_method :end, :last
+
+      def step
+        children[2]
+      end
+
+      def evaluate(_context = nil)
+        self
+      end
+
+      def to_ruby(_context = nil)
+        to_array(self)
+      end
+
+      def to_pkl_string(context = nil)
+        to_string(context)
+      end
+
+      def to_string(context = nil)
+        start_value, last_value, step_value = children.map { _1.to_pkl_string(context) }
+        if step && step.value != 1
+          "IntSeq(#{start_value}, #{last_value}).step(#{step_value})"
+        else
+          "IntSeq(#{start_value}, #{last_value})"
+        end
+      end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          to_array(self) == to_array(other)
+      end
+
+      define_builtin_property(:start) do
+        Int.new(self, start.value, position)
+      end
+
+      define_builtin_property(:end) do
+        Int.new(self, last.value, position)
+      end
+
+      define_builtin_property(:step) do
+        Int.new(self, step&.value || 1, position)
+      end
+
+      define_builtin_method(:step, step: Int) do |args, parent, position|
+        step = args[:step]
+        if step.value.zero?
+          message = "expected a non zero number, but got '#{step.value}'"
+          raise EvaluationError.new(message, position)
+        end
+
+        IntSeq.new(parent, start, last, step, position)
+      end
+
+      private
+
+      def to_array(intseq)
+        start_value, last_value, step_value = intseq.children.map(&:value)
+        Range.new(start_value, last_value).step(step_value || 1).to_a
+      end
+    end
+  end
+end

data/lib/rupkl/node/listing.rb

@@ -3,19 +3,26 @@
 module RuPkl
   module Node
     class Listing < Any
+      include Operatable
       include StructCommon
 
       def elements
         @body&.elements
       end
 
+      def to_ruby(context = nil)
+        to_ruby_object(context) do |_properties, _entries, elements|
+          replace_self_array(elements, elements) || []
+        end
+      end
+
       def ==(other)
         other.instance_of?(self.class) &&
           match_members?(elements, other.elements, true)
       end
 
       def find_by_key(key)
-        find_element(key)
+        find_element(key)&.value
       end
 
       define_builtin_property(:isEmpty) do
@@ -43,12 +50,12 @@ module RuPkl
         Listing.new(self, body, position)
       end
 
-      define_builtin_method(:join, separator: String) do |separator|
+      define_builtin_method(:join, separator: String) do |args, parent, position|
         result =
           elements
             &.map { _1.value.to_string }
-            &.join(separator.value)
-        String.new(nil, result || '', nil, position)
+            &.join(args[:separator].value)
+        String.new(parent, result || '', nil, position)
       end
 
       private

data/lib/rupkl/node/map.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    class Map < Any
+      MapEntry = Struct.new(:key, :value) do
+        def match_key?(other_key)
+          key == other_key
+        end
+      end
+
+      include Operatable
+      include MemberFinder
+      undef_method :pkl_method
+
+      uninstantiable_class
+
+      def initialize(parent, entries, position)
+        @entries = compose_entries(entries, position)
+        super(parent, *@entries&.flat_map(&:to_a), position)
+      end
+
+      attr_reader :entries
+
+      def evaluate(_context = nil)
+        self
+      end
+
+      def to_ruby(context = nil)
+        entries&.to_h { |e| e.map { _1.to_ruby(context) } } || {}
+      end
+
+      def to_pkl_string(context = nil)
+        to_string(context)
+      end
+
+      def to_string(context = nil)
+        entry_string =
+          entries
+            &.flat_map { |entry| entry.map { _1.to_pkl_string(context) } }
+            &.join(', ')
+        "Map(#{entry_string})"
+      end
+
+      def b_op_add(r_operand, position)
+        result =
+          if entries && r_operand.entries
+            entries + r_operand.entries
+          else
+            entries || r_operand.entries
+          end
+        self.class.new(nil, result&.flat_map(&:to_a), position)
+      end
+
+      def ==(other)
+        return false unless other.is_a?(self.class)
+        return false unless entries&.size == other.entries&.size
+        return true unless entries
+
+        entries
+          .all? { |entry| entry.value == other.find_by_key(entry.key) }
+      end
+
+      def find_by_key(key)
+        find_entry(key)&.value
+      end
+
+      define_builtin_property(:isEmpty) do
+        result = entries.nil? || entries.empty?
+        Boolean.new(self, result, position)
+      end
+
+      define_builtin_property(:length) do
+        result = entries&.length || 0
+        Int.new(self, result, position)
+      end
+
+      define_builtin_property(:keys) do
+        keys = entries&.map(&:key)
+        Set.new(self, keys, position)
+      end
+
+      define_builtin_property(:values) do
+        values = entries&.map(&:value)
+        List.new(self, values, position)
+      end
+
+      define_builtin_property(:entries) do
+        key_value_pairs =
+          entries&.map { |e| Pair.new(nil, e.key, e.value, position) }
+        List.new(self, key_value_pairs, position)
+      end
+
+      private
+
+      def compose_entries(entries, position)
+        return if entries.nil? || entries.empty?
+
+        check_arity(entries, position)
+        entries.each_slice(2)&.with_object([]) do |(k, v), result|
+          index =
+            result.find_index { _1.match_key?(k) } ||
+            result.size
+          result[index] = MapEntry.new(k, v)
+        end
+      end
+
+      def check_arity(entries, position)
+        return if ((entries&.size || 0) % 2).zero?
+
+        m = 'number of arguments must be a multiple of two'
+        raise EvaluationError.new(m, position)
+      end
+
+      def defined_operator?(operator)
+        [:[], :+].any?(operator)
+      end
+    end
+  end
+end

data/lib/rupkl/node/mapping.rb

@@ -3,19 +3,26 @@
 module RuPkl
   module Node
     class Mapping < Any
+      include Operatable
       include StructCommon
 
       def entries
         @body&.entries
       end
 
+      def to_ruby(context = nil)
+        to_ruby_object(context) do |_properties, entries, _elements|
+          replace_self_hash(entries, entries) || {}
+        end
+      end
+
       def ==(other)
         other.instance_of?(self.class) &&
           match_members?(entries, other.entries, false)
       end
 
       def find_by_key(key)
-        find_entry(key)
+        find_entry(key)&.value
       end
 
       define_builtin_property(:isEmpty) do
@@ -28,13 +35,13 @@ module RuPkl
         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)
+      define_builtin_method(:containsKey, key: Any) do |args, parent, position|
+        result = find_entry(args[:key]) && true || false
+        Boolean.new(parent, result, position)
       end
 
-      define_builtin_method(:getOrNull, key: Any) do |key|
-        find_entry(key) || Null.new(nil, position)
+      define_builtin_method(:getOrNull, key: Any) do |args, parent, position|
+        find_entry(args[:key])&.value || Null.new(parent, position)
       end
 
       private