rupkl 0.2.0 → 0.3.0

data/lib/rupkl/node/operation.rb

@@ -2,6 +2,125 @@
 
 module RuPkl
   module Node
+    module Operatable
+      def s_op(operator, key, context, position)
+        check_s_op(operator, position)
+
+        k = key.evaluate(context)
+        valid_key_operand?(k) ||
+          raise_invalid_key_error(operator, k, position)
+
+        (v = find_by_key(k)) ||
+          raise_no_key_found_error(k, context, position)
+
+        v.evaluate
+      end
+
+      def u_op(operator, position)
+        check_u_op(operator, position)
+        __send__(u_op_method(operator), position)
+      end
+
+      def b_op(operator, operand, context, position)
+        check_b_op(operator, position)
+        return self if short_circuit?(operator)
+
+        r_operand = operand.evaluate(context)
+        if valid_r_operand?(operator, r_operand)
+          __send__(b_op_method(operator), r_operand, position)
+        elsif [:==, :'!='].any?(operator)
+          Boolean.new(nil, operator != :==, position)
+        else
+          raise_invalid_r_operand_error(operator, r_operand, position)
+        end
+      end
+
+      def b_op_eq(r_operand, position)
+        result = self == r_operand
+        Boolean.new(nil, result, position)
+      end
+
+      def b_op_ne(r_operand, position)
+        result = self != r_operand
+        Boolean.new(nil, result, position)
+      end
+
+      private
+
+      def check_s_op(operator, position)
+        check_operator(operator, position)
+      end
+
+      def valid_key_operand?(_key)
+        true
+      end
+
+      def raise_invalid_key_error(operator, key, position)
+        message =
+          "invalid key operand type #{key.class_name} is given " \
+          "for operator '#{operator}'"
+        raise EvaluationError.new(message, position)
+      end
+
+      def raise_no_key_found_error(key, context, position)
+        message = "cannot find key '#{key.to_pkl_string(context)}'"
+        raise EvaluationError.new(message, position)
+      end
+
+      def check_u_op(operator, position)
+        op = :"#{operator}@"
+        check_operator(op, position)
+      end
+
+      def u_op_method(operator)
+        { '-': :u_op_minus, '!': :u_op_negate }[operator]
+      end
+
+      def check_b_op(operator, position)
+        check_operator(operator, position)
+      end
+
+      def short_circuit?(_operator)
+        false
+      end
+
+      def valid_r_operand?(_operator, operand)
+        operand.is_a?(self.class)
+      end
+
+      def raise_invalid_r_operand_error(operator, r_operand, position)
+        message =
+          "invalid operand type #{r_operand.class_name} is given " \
+          "for operator '#{operator}'"
+        raise EvaluationError.new(message, position)
+      end
+
+      def b_op_method(operator)
+        {
+          '**': :b_op_exp,
+          '*': :b_op_mul, '/': :b_op_div,
+          '~/': :b_op_truncating_div, '%': :b_op_rem,
+          '+': :b_op_add, '-': :b_op_sub,
+          '<': :b_op_lt, '>': :b_op_gt,
+          '<=': :b_op_le, '>=': :b_op_ge,
+          '==': :b_op_eq, '!=': :b_op_ne,
+          '&&': :b_op_and, '||': :b_op_or
+        }[operator]
+      end
+
+      def check_operator(operator, position)
+        return if
+          [:==, :'!='].any?(operator) || defined_operator?(operator)
+
+        message = "operator '#{operator}' is not defined for #{class_name} type"
+        raise EvaluationError.new(message, position)
+      end
+
+      def defined_operator?(_operator)
+        false
+      end
+    end
+
     module OperationCommon
       include NodeCommon
 
@@ -14,7 +133,7 @@ module RuPkl
       attr_reader :operator
       attr_reader :operands
 
-      def copy(parent = nil)
+      def copy(parent = nil, position = @position)
         copied_operands = operands.map(&:copy)
         self.class.new(parent, operator, *copied_operands, position)
       end
@@ -23,18 +142,7 @@ module RuPkl
 
       def s_op(context)
         r = receiver.evaluate(context)
-        check_operator(r)
-
-        k = key.evaluate(context)
-        check_key_operand(r, k)
-
-        (v = r.find_by_key(k)) ||
-          begin
-            message = "cannot find key '#{k.to_pkl_string(context)}'"
-            raise EvaluationError.new(message, position)
-          end
-
-        v.evaluate
+        r.s_op(operator, key, context, position)
       end
 
       def non_null_op(context)
@@ -47,28 +155,12 @@ module RuPkl
 
       def u_op(context)
         o = operand.evaluate(context)
-        check_operator(o)
-
-        result =
-          if operator == :-
-            -o.value
-          else
-            !o.value
-          end
-        create_op_result(result)
+        o.u_op(operator, position)
       end
 
       def b_op(context)
         l = l_operand.evaluate(context)
-        check_operator(l)
-        return l if short_circuit?(l)
-
-        r = r_operand.evaluate(context)
-        check_r_operand(l, r)
-          .then { return _1 if _1 }
-
-        l, r = l.coerce(operator, r)
-        create_op_result(l.__send__(ruby_op, r))
+        l.b_op(operator, r_operand, context, position)
       end
 
       def null_coalescing_op(context)
@@ -77,75 +169,6 @@ module RuPkl
 
         r_operand.evaluate(context)
       end
-
-      def check_operator(operand)
-        undefined_operator?(operand) &&
-          begin
-            message =
-              "operator '#{operator}' is not defined for " \
-              "#{operand.class.basename} type"
-            raise EvaluationError.new(message, position)
-          end
-      end
-
-      def undefined_operator?(operand)
-        !operand.respond_to?(:undefined_operator?) ||
-          operand.undefined_operator?(operator)
-      end
-
-      def check_key_operand(receiver, key)
-        invalid_key_operand?(receiver, key) &&
-          begin
-            message =
-              "invalid key operand type #{key.class.basename} is given " \
-              "for operator '#{operator}'"
-            raise EvaluationError.new(message, position)
-          end
-      end
-
-      def invalid_key_operand?(receiver, key)
-        receiver.respond_to?(:invalid_key_operand?) &&
-          receiver.invalid_key_operand?(key)
-      end
-
-      def check_r_operand(l_operand, r_operand)
-        return unless invalid_r_operand?(l_operand, r_operand)
-
-        if [:==, :'!='].include?(operator)
-          create_op_result(operator != :==)
-        else
-          message =
-            "invalid operand type #{r_operand.class.basename} is given " \
-            "for operator '#{operator}'"
-          raise EvaluationError.new(message, position)
-        end
-      end
-
-      def invalid_r_operand?(l_operand, r_operand)
-        if l_operand.respond_to?(:invalid_r_operand?)
-          l_operand.invalid_r_operand?(r_operand)
-        else
-          !r_operand.is_a?(l_operand.class)
-        end
-      end
-
-      def short_circuit?(l_operand)
-        l_operand.respond_to?(:short_circuit?) &&
-          l_operand.short_circuit?(operator)
-      end
-
-      def ruby_op
-        { '&&': :&, '||': :|, '~/': :/ }.fetch(operator, operator)
-      end
-
-      def create_op_result(result)
-        case result
-        when ::Integer then Int.new(parent, result, position)
-        when ::Float then Float.new(parent, result, position)
-        when ::String then String.new(parent, result, nil, position)
-        when true, false then Boolean.new(parent, result, position)
-        end
-      end
     end
 
     class SubscriptOperation

data/lib/rupkl/node/pair.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    class Pair < Any
+      include Operatable
+
+      uninstantiable_class
+
+      def first
+        @children[0]
+      end
+
+      def second
+        @children[1]
+      end
+
+      def evaluate(_context = nil)
+        self
+      end
+
+      def to_ruby(context = nil)
+        [first, second].map { _1.to_ruby(context) }
+      end
+
+      def to_pkl_string(context = nil)
+        to_string(context)
+      end
+
+      def to_string(context = nil)
+        element_strings =
+          [first, second].map { _1.to_pkl_string(context) }
+        "Pair(#{element_strings[0]}, #{element_strings[1]})"
+      end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          first == other.first && second == other.second
+      end
+
+      define_builtin_property(:first) do
+        first
+      end
+
+      define_builtin_property(:key) do
+        first
+      end
+
+      define_builtin_property(:second) do
+        second
+      end
+
+      define_builtin_property(:value) do
+        second
+      end
+    end
+  end
+end

data/lib/rupkl/node/pkl_module.rb

@@ -8,10 +8,6 @@ module RuPkl
       abstract_class
       klass_name :Module
 
-      def properties
-        @body&.properties(visibility: :object)
-      end
-
       def pkl_methods
         @body&.pkl_methods
       end
@@ -25,6 +21,10 @@ module RuPkl
         super
       end
 
+      def to_ruby(context = nil)
+        to_pkl_object(context)
+      end
+
       private
 
       def properties_not_allowed?

data/lib/rupkl/node/regex.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    class Regex < Any
+      include Operatable
+
+      uninstantiable_class
+
+      def initialize(parent, pattern, position)
+        super
+        @pattern = Regexp.new(pattern.value)
+      end
+
+      attr_reader :pattern
+
+      def evaluate(_context = nil)
+        self
+      end
+
+      def to_ruby(_context = nil)
+        pattern
+      end
+
+      def to_pkl_string(context = nil)
+        to_string(context)
+      end
+
+      def to_string(context = nil)
+        source_string = source.to_pkl_string(context)
+        "Regex(#{source_string})"
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && pattern == other.pattern
+      end
+
+      define_builtin_property(:pattern) do
+        source
+      end
+
+      define_builtin_property(:groupCount) do
+        Int.new(nil, group_count, position)
+      end
+
+      define_builtin_method(:findMatchesIn, input: String) do |args, parent, position|
+        find_matches(args[:input].value, parent, position)
+      end
+
+      define_builtin_method(:matchEntire, input: String) do |args, parent, position|
+        match_entire(args[:input].value, parent, position)
+      end
+
+      private
+
+      def source
+        @children[0]
+      end
+
+      def group_count
+        Regexp::Parser
+          .parse(pattern)
+          .each_expression.count { |exp, _| exp.capturing? }
+      end
+
+      def find_matches(string, parent, position)
+        matches = []
+        offset = 0
+        while (match_data = match_pattern(string, offset))
+          matches << RegexMatch.create(match_data, nil, position)
+          offset = calc_next_offset(match_data, offset)
+        end
+        List.new(parent, matches, position)
+      end
+
+      def match_entire(string, parent, position)
+        match_pattern(string, 0).then do |m|
+          if m && m.end(0) == string.size
+            RegexMatch.create(m, parent, position)
+          else
+            Null.new(parent, position)
+          end
+        end
+      end
+
+      def match_pattern(string, offset)
+        return if offset > string.size
+
+        pattern.match(string, offset)
+      end
+
+      def calc_next_offset(match_data, offset)
+        if match_data[0].empty?
+          offset + 1
+        else
+          match_data.end(0)
+        end
+      end
+    end
+
+    class RegexMatch < Any
+      include Operatable
+
+      uninstantiable_class
+
+      class << self
+        def create(match_data, parent, position)
+          groups = Array.new(match_data.size) do |i|
+            if match_data[i]
+              create_regex_match(
+                match_data[i], match_data.begin(i),
+                match_data.end(i), nil, nil, position
+              )
+            else
+              Null.new(nil, position)
+            end
+          end
+          create_regex_match(
+            match_data[0], match_data.begin(0),
+            match_data.end(0), groups, parent, position
+          )
+        end
+
+        private
+
+        def create_regex_match(value, start_offset, end_offset, groups, parent, position)
+          v = String.new(nil, value, nil, position)
+          s = Int.new(nil, start_offset, position)
+          e = Int.new(nil, end_offset, position)
+          g = List.new(nil, groups, position)
+          new(parent, v, s, e, g, position)
+        end
+      end
+
+      def value
+        @children[0]
+      end
+
+      def start
+        @children[1]
+      end
+
+      alias_method :start_offset, :start
+
+      def end
+        @children[2]
+      end
+
+      alias_method :end_offset, :end
+
+      def groups
+        @children[3]
+      end
+
+      def evaluate(_context = nil)
+        self
+      end
+
+      def to_ruby(context = nil)
+        {
+          value: value, start: start_offset, end: end_offset, groups: groups
+        }.transform_values { |v| v.to_ruby(context) }
+      end
+
+      def to_pkl_string(context = nil)
+        to_string(context)
+      end
+
+      def to_string(context)
+        value.to_string(context)
+      end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          value == other.value && start_offset == other.start &&
+          end_offset == other.end && groups == other.groups
+      end
+
+      define_builtin_property(:value) do
+        value
+      end
+
+      define_builtin_property(:start) do
+        start_offset
+      end
+
+      define_builtin_property(:end) do
+        end_offset
+      end
+
+      define_builtin_property(:groups) do
+        groups
+      end
+    end
+  end
+end