rupkl 0.1.0 → 0.2.0

data/lib/rupkl/node/string.rb

@@ -2,25 +2,41 @@
 
 module RuPkl
   module Node
-    class String
+    class String < Any
       include ValueCommon
 
-      def initialize(value, portions, position)
-        super(value, position)
+      uninstantiable_class
+
+      def initialize(parent, value, portions, position)
+        super(parent, value, position)
         @portions = portions
+        portions&.each do |portion|
+          portion.is_a?(NodeCommon) && add_child(portion)
+        end
       end
 
       attr_reader :portions
 
-      def evaluate(scopes)
-        s = value || evaluate_portions(scopes) || ''
-        self.class.new(s, nil, position)
+      def evaluate(context = nil)
+        @value ||= evaluate_portions(context)
+        self
       end
 
-      def to_pkl_string(scopes)
-        super(scopes)
-          .then { |s| escape(s) }
-          .then { |s| "\"#{s}\"" }
+      def to_pkl_string(context = nil)
+        s = to_ruby(context)
+        if invalid_string?(s)
+          s
+        else
+          "\"#{escape(s)}\""
+        end
+      end
+
+      def copy(parent = nil)
+        copied_portions =
+          portions&.map do |portion|
+            portion.is_a?(NodeCommon) && portion.copy || portion
+          end
+        self.class.new(parent, nil, copied_portions, position)
       end
 
       def undefined_operator?(operator)
@@ -28,27 +44,308 @@ module RuPkl
       end
 
       def invalid_key_operand?(key)
-        !key.is_a?(Integer)
+        !key.is_a?(Int)
       end
 
       def find_by_key(key)
         index = key.value
         return nil unless (0...value.length).include?(index)
 
-        self.class.new(value[index], nil, portions)
+        self.class.new(parent, value[index], nil, position)
+      end
+
+      define_builtin_property(:length) do
+        Int.new(self, value.length, position)
+      end
+
+      define_builtin_property(:lastIndex) do
+        Int.new(self, value.length - 1, position)
+      end
+
+      define_builtin_property(:isEmpty) do
+        Boolean.new(self, value.empty?, position)
+      end
+
+      define_builtin_property(:isBlank) do
+        result = /\A\p{White_Space}*\z/.match?(value)
+        Boolean.new(self, result, position)
+      end
+
+      define_builtin_property(:md5) do
+        hash = Digest::MD5.hexdigest(value)
+        String.new(self, hash, nil, position)
+      end
+
+      define_builtin_property(:sha1) do
+        hash = Digest::SHA1.hexdigest(value)
+        String.new(self, hash, nil, position)
+      end
+
+      define_builtin_property(:sha256) do
+        hash = Digest::SHA256.hexdigest(value)
+        String.new(self, hash, nil, position)
+      end
+
+      define_builtin_property(:sha256Int) do
+        hash = Digest::SHA256.digest(value).unpack1('q')
+        Int.new(self, hash, position)
+      end
+
+      define_builtin_property(:base64) do
+        result = Base64.urlsafe_encode64(value)
+        String.new(self, result, nil, position)
+      end
+
+      define_builtin_property(:base64Decoded) do
+        result = Base64.urlsafe_decode64(value)
+        String.new(self, result, nil, position)
+      rescue ArgumentError
+        message = "illegal base64: \"#{value}\""
+        raise EvaluationError.new(message, position)
+      end
+
+      define_builtin_method(:getOrNull, index: Int) do |index|
+        if (0...value.size).include?(index.value)
+          String.new(nil, value[index.value], nil, position)
+        else
+          Null.new(nil, position)
+        end
+      end
+
+      define_builtin_method(:substring, start: Int, exclusive_end: Int) do |s, e|
+        check_range(s.value, 0)
+        check_range(e.value, s.value)
+
+        String.new(nil, value[s.value...e.value], nil, position)
+      end
+
+      define_builtin_method(:substringOrNull, start: Int, exclusive_end: Int) do |s, e|
+        if inside_range?(s.value, 0) && inside_range?(e.value, s.value)
+          String.new(nil, value[s.value...e.value], nil, position)
+        else
+          Null.new(nil, position)
+        end
+      end
+
+      define_builtin_method(:repeat, count: Int) do |count|
+        check_positive_number(count)
+
+        result = value * count.value
+        String.new(nil, result, nil, position)
+      end
+
+      define_builtin_method(:contains, pattern: String) do |pattern|
+        result = value.include?(pattern.value)
+        Boolean.new(nil, result, position)
+      end
+
+      define_builtin_method(:startsWith, pattern: String) do |pattern|
+        result = value.start_with?(pattern.value)
+        Boolean.new(nil, result, position)
+      end
+
+      define_builtin_method(:endsWith, pattern: String) do |pattern|
+        result = value.end_with?(pattern.value)
+        Boolean.new(nil, result, position)
+      end
+
+      define_builtin_method(:indexOf, pattern: String) do |pattern|
+        index_of(:index, pattern) do
+          message = "\"#{pattern.value}\" does not occur in \"#{value}\""
+          raise EvaluationError.new(message, position)
+        end
+      end
+
+      define_builtin_method(:indexOfOrNull, pattern: String) do |pattern|
+        index_of(:index, pattern) do
+          Null.new(nil, position)
+        end
+      end
+
+      define_builtin_method(:lastIndexOf, pattern: String) do |pattern|
+        index_of(:rindex, pattern) do
+          message = "\"#{pattern.value}\" does not occur in \"#{value}\""
+          raise EvaluationError.new(message, position)
+        end
+      end
+
+      define_builtin_method(:lastIndexOfOrNull, pattern: String) do |pattern|
+        index_of(:rindex, pattern) do
+          Null.new(nil, position)
+        end
+      end
+
+      define_builtin_method(:take, n: Int) do |n|
+        check_positive_number(n)
+
+        result = value[0, n.value] || value
+        String.new(nil, result, nil, position)
+      end
+
+      define_builtin_method(:takeLast, n: Int) do |n|
+        check_positive_number(n)
+
+        pos = value.size - n.value
+        result = pos.negative? && value || value[pos..]
+        String.new(nil, result, nil, position)
+      end
+
+      define_builtin_method(:drop, n: Int) do |n|
+        check_positive_number(n)
+
+        result = value[n.value..] || ''
+        String.new(nil, result, nil, position)
+      end
+
+      define_builtin_method(:dropLast, n: Int) do |n|
+        check_positive_number(n)
+
+        length = value.size - n.value
+        result = length.negative? && '' || value[0, length]
+        String.new(nil, result, nil, position)
+      end
+
+      define_builtin_method(
+        :replaceFirst,
+        pattern: String, replacement: String
+      ) do |pattern, replacement|
+        result = value.sub(pattern.value, replacement.value)
+        String.new(nil, result, nil, position)
+      end
+
+      define_builtin_method(
+        :replaceLast,
+        pattern: String, replacement: String
+      ) do |pattern, replacement|
+        result =
+          if (index = value.rindex(pattern.value))
+            value.dup.tap { |s| s[index, replacement.value.size] = replacement.value }
+          else
+            value
+          end
+        String.new(nil, result, nil, position)
+      end
+
+      define_builtin_method(
+        :replaceAll,
+        pattern: String, replacement: String
+      ) do |pattern, replacement|
+        result = value.gsub(pattern.value, replacement.value)
+        String.new(nil, result, nil, position)
+      end
+
+      define_builtin_method(
+        :replaceRange,
+        start: Int, exclusive_end: Int, replacement: String
+      ) do |start, exclusive_end, replacement|
+        check_range(start.value, 0)
+        check_range(exclusive_end.value, start.value)
+
+        range = start.value...exclusive_end.value
+        result = value.dup.tap { |s| s[range] = replacement.value }
+        String.new(nil, result, nil, position)
+      end
+
+      define_builtin_method(:toUpperCase) do
+        String.new(nil, value.upcase, nil, position)
+      end
+
+      define_builtin_method(:toLowerCase) do
+        String.new(nil, value.downcase, nil, position)
+      end
+
+      define_builtin_method(:reverse) do
+        String.new(nil, value.reverse, nil, position)
+      end
+
+      define_builtin_method(:trim) do
+        pattern = /(?:\A\p{White_Space}+)|(?:\p{White_Space}+\z)/
+        String.new(nil, value.gsub(pattern, ''), nil, position)
+      end
+
+      define_builtin_method(:trimStart) do
+        pattern = /\A\p{White_Space}+/
+        String.new(nil, value.sub(pattern, ''), nil, position)
+      end
+
+      define_builtin_method(:trimEnd) do
+        pattern = /\p{White_Space}+\z/
+        String.new(nil, value.sub(pattern, ''), nil, position)
+      end
+
+      define_builtin_method(:padStart, width: Int, char: String) do |width, char|
+        pad(width, char, :pre)
+      end
+
+      define_builtin_method(:padEnd, width: Int, char: String) do |width, char|
+        pad(width, char, :post)
+      end
+
+      define_builtin_method(:capitalize) do
+        result =
+          value.empty? && value || value.dup.tap { |s| s[0] = s[0].upcase }
+        String.new(nil, result, nil, position)
+      end
+
+      define_builtin_method(:decapitalize) do
+        result =
+          value.empty? && value || value.dup.tap { |s| s[0] = s[0].downcase }
+        String.new(nil, result, nil, position)
+      end
+
+      define_builtin_method(:toInt) do
+        to_int do
+          message = "cannot parse string as Int \"#{value}\""
+          raise EvaluationError.new(message, position)
+        end
+      end
+
+      define_builtin_method(:toIntOrNull) do
+        to_int do
+          Null.new(nil, position)
+        end
+      end
+
+      define_builtin_method(:toFloat) do
+        to_float do
+          message = "cannot parse string as Float \"#{value}\""
+          raise EvaluationError.new(message, position)
+        end
+      end
+
+      define_builtin_method(:toFloatOrNull) do
+        to_float do
+          Null.new(nil, position)
+        end
+      end
+
+      define_builtin_method(:toBoolean) do
+        to_boolean do
+          message = "cannot parse string as Boolean \"#{value}\""
+          raise EvaluationError.new(message, position)
+        end
+      end
+
+      define_builtin_method(:toBooleanOrNull) do
+        to_boolean do
+          Null.new(nil, position)
+        end
       end
 
       private
 
-      def evaluate_portions(scopes)
-        portions
-          &.map { evaluate_portion(scopes, _1) }
-          &.join
+      def evaluate_portions(context)
+        evaluated_portions =
+          portions&.map do |portion|
+            evaluate_portion(portion, context)
+              .tap { |s| return s if invalid_string?(s) }
+          end
+        evaluated_portions&.join || ''
       end
 
-      def evaluate_portion(scopes, portion)
+      def evaluate_portion(portion, context)
         if portion.respond_to?(:to_string)
-          portion.to_string(scopes)
+          portion.to_string(context)
         else
           portion
         end
@@ -61,6 +358,79 @@ module RuPkl
         }
         string.gsub(/([\t\n\r"\\])/) { replace[_1] }
       end
+
+      def check_range(index, start_index)
+        return if inside_range?(index, start_index)
+
+        message = "index #{index} is out of range " \
+                  "#{start_index}..#{value.size}: \"#{value}\""
+        raise EvaluationError.new(message, position)
+      end
+
+      def inside_range?(index, start_index)
+        (start_index..value.size).include?(index)
+      end
+
+      def index_of(method, pattern)
+        result = value.__send__(method, pattern.value)
+        result && Int.new(nil, result, position) || yield
+      end
+
+      def pad(width, char, pre_post)
+        unless char.value.length == 1
+          message = "expected a char, but got \"#{char.value}\""
+          raise EvaluationError.new(message, position)
+        end
+
+        result =
+          pad_prefix_postfix(width, char, pre_post)
+            .then { |pre, post| [pre, value, post].join }
+        String.new(nil, result, nil, position)
+      end
+
+      def pad_prefix_postfix(width, char, pre_post)
+        pad_width = width.value - value.length
+        if pad_width <= 0
+          [nil, nil]
+        elsif pre_post == :pre
+          [char.value * pad_width, nil]
+        else
+          [nil, char.value * pad_width]
+        end
+      end
+
+      def to_int
+        Int.new(nil, Integer(remove_underscore_from_number(value), 10), position)
+      rescue ArgumentError
+        yield
+      end
+
+      def to_float
+        result =
+          case value
+          when 'NaN' then ::Float::NAN
+          when 'Infinity' then ::Float::INFINITY
+          when '-Infinity' then -::Float::INFINITY
+          else Float(remove_underscore_from_number(value))
+          end
+        Float.new(nil, result, position)
+      rescue ArgumentError
+        yield
+      end
+
+      def remove_underscore_from_number(string)
+        string.gsub(/(?:(?<=\d)|(?<=.[eE][+-]))_+/, '')
+      end
+
+      def to_boolean
+        result =
+          case value
+          when /\Atrue\z/i then true
+          when /\Afalse\z/i then false
+          else return yield
+          end
+        Boolean.new(nil, result, position)
+      end
     end
   end
 end

data/lib/rupkl/node/struct_common.rb

@@ -3,8 +3,68 @@
 module RuPkl
   module Node
     module StructCommon
-      def to_string(_scopes)
-        "new #{self.class.basename} #{to_pkl_string(nil)}"
+      include NodeCommon
+      include MemberFinder
+
+      def initialize(parent, body, position)
+        super
+        @body = body
+        body && check_members
+      end
+
+      attr_reader :body
+
+      def evaluate(context = nil)
+        do_evaluation(__method__, context, 1) do |c|
+          @body&.evaluate(c)
+        end
+        self
+      end
+
+      def resolve_structure(context = nil)
+        do_evaluation(__method__, context, 1) do |c|
+          @body&.resolve_structure(c)
+        end
+        self
+      end
+
+      def to_ruby(context = nil)
+        do_evaluation(__method__, context, 1, PklObject::SELF) do |c|
+          create_pkl_object(c)
+        end
+      end
+
+      def to_pkl_string(context = nil)
+        to_string(context)
+      end
+
+      def to_string(context = nil)
+        do_evaluation(__method__, context, 2, invalid_string) do |c|
+          to_string_object(c)
+        end
+      end
+
+      def current_context
+        super&.push_object(self) || Context.new(nil, [self])
+      end
+
+      def structure?
+        true
+      end
+
+      def copy(parent = nil)
+        self.class.new(parent, @body&.copy, position)
+      end
+
+      def merge!(*bodies)
+        return unless @body
+
+        @body.merge!(*bodies)
+        check_members
+      end
+
+      def undefined_operator?(operator)
+        [:[], :==, :'!='].none?(operator)
       end
 
       def coerce(_operator, r_operand)
@@ -13,26 +73,48 @@ module RuPkl
 
       private
 
-      def push_scope(scopes)
-        yield([*scopes, self])
+      def check_members
+        message =
+          if properties_not_allowed?
+            "'#{self.class.basename}' cannot have a property"
+          elsif entries_not_allowed?
+            "'#{self.class.basename}' cannot have an entry"
+          elsif elements_not_allowed?
+            "'#{self.class.basename}' cannot have an element"
+          end
+        message &&
+          (raise EvaluationError.new(message, position))
       end
 
-      def add_hash_member(members, member, accessor)
-        duplicate_member?(members, member, accessor) &&
-          begin
-            message = 'duplicate definition of member'
-            raise EvaluationError.new(message, member.position)
-          end
-        members << member
+      def properties_not_allowed?
+        body.properties
       end
 
-      def duplicate_member?(members, member, accessor)
-        members
-          .any? { _1.__send__(accessor) == member.__send__(accessor) }
+      def entries_not_allowed?
+        body.entries
+      end
+
+      def elements_not_allowed?
+        body.elements
+      end
+
+      def do_evaluation(method, context, limit, ifreachlimit = nil)
+        return ifreachlimit if reach_limit?(method, limit)
+
+        call_depth[method] += 1
+        result = yield(context&.push_object(self) || current_context)
+        call_depth.delete(method)
+
+        result
       end
 
-      def add_array_member(members, member)
-        members << member
+      def call_depth
+        @call_depth ||= Hash.new { |h, k| h[k] = 0 }
+      end
+
+      def reach_limit?(method, limit)
+        depth = call_depth[method]
+        depth >= 1 && depth >= limit
       end
 
       def match_members?(lhs, rhs, match_order)
@@ -44,58 +126,38 @@ module RuPkl
         end
       end
 
-      def merge_hash_members(lhs, rhs, accessor)
-        return nil unless lhs || rhs
-        return rhs unless lhs
-
-        rhs&.each do |r|
-          if (index = find_index(lhs, r, accessor))
-            lhs[index] = r
-          else
-            lhs << r
-          end
+      def create_pkl_object(context)
+        context.push_scope(@body).then do |c|
+          RuPkl::PklObject.new(
+            to_ruby_hash(@body.properties, c),
+            to_ruby_hash(@body.entries, c),
+            to_ruby_array(@body.elements, c)
+          )
         end
-
-        lhs
       end
 
-      def find_index(lhs, rhs, accessor)
-        lhs.find_index { _1.__send__(accessor) == rhs.__send__(accessor) }
+      def to_ruby_hash(members, context)
+        members&.to_h { _1.to_ruby(context) }
       end
 
-      def merge_array_members(lhs, rhs)
-        return nil unless lhs || rhs
-        return rhs unless lhs
-        return lhs unless rhs
-
-        lhs.concat(rhs)
+      def to_ruby_array(members, context)
+        members&.map { _1.to_ruby(context) }
       end
 
-      def create_pkl_object(scopes, properties, entries, elements)
-        RuPkl::PklObject.new(
-          to_ruby_hash_members(scopes, properties),
-          to_ruby_hash_members(scopes, entries),
-          to_ruby_array_members(scopes, elements)
-        )
+      def to_string_object(context)
+        "new #{self.class.basename} #{to_string_members(context)}"
       end
 
-      def to_ruby_hash_members(scopes, members)
-        members
-          &.to_h { _1.to_ruby(scopes) }
-      end
-
-      def to_ruby_array_members(scopes, members)
-        members
-          &.map { _1.to_ruby(scopes) }
-      end
-
-      def to_pkl_string_object(*members)
+      def to_string_members(context)
+        members = @body.members
         return '{}' if members.empty?
 
-        members
-          .map { _1.to_pkl_string(nil) }
-          .join('; ')
-          .then { "{ #{_1} }" }
+        context.push_scope(@body).then do |c|
+          members
+            .map { _1.to_pkl_string(c) }
+            .join('; ')
+            .then { "{ #{_1} }" }
+        end
       end
     end
   end

data/lib/rupkl/node/this.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    class This
+      include NodeCommon
+
+      def evaluate(context = nil)
+        resolve_reference(context)
+      end
+
+      def resolve_reference(context = nil)
+        (context || current_context).objects.last
+      end
+    end
+  end
+end

data/lib/rupkl/node/type_common.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RuPkl
+  module Node
+    module TypeCommon
+      include NodeCommon
+
+      def check_type(value, context, position)
+        klass = value.class
+        return if match_type?(klass, context)
+
+        message =
+          "expected type '#{self}', but got type '#{klass.class_name}'"
+        raise EvaluationError.new(message, position)
+      end
+
+      private
+
+      def find_type(type, context)
+        exec_on(context) do |c|
+          [Base.instance, *c&.objects]
+            .reverse_each do |scope|
+              next unless scope.respond_to?(:pkl_classes)
+
+              klass = scope.pkl_classes&.fetch(type.last.id, nil)
+              return klass if klass
+            end
+
+          raise EvaluationError.new("cannot find type '#{type.last.id}'", position)
+        end
+      end
+    end
+  end
+end