ruby-next-core 0.14.0 → 1.0.1

data/lib/.rbnext/2.7/ruby-next/core/data.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+# The code below originates from https://github.com/saturnflyer/polyfill-data
+
+if !Object.const_defined?(:Data) || !Data.respond_to?(:define)
+
+  # Drop legacy Data class
+  begin
+    Object.send(:remove_const, :Data)
+  rescue
+    nil
+  end
+
+  class Data < Object
+    using RubyNext
+
+    class << self
+      undef_method :new
+      attr_reader :members
+    end
+
+    def self.define(*args, &block)
+      raise ArgumentError if args.any?(/=/)
+      if block
+        mod = Module.new
+        mod.define_singleton_method(:_) do |klass|
+          klass.class_eval(&block)
+        end
+        arity_converter = mod.method(:_)
+      end
+      klass = ::Class.new(self)
+
+      klass.instance_variable_set(:@members, args.map(&:to_sym).freeze)
+
+      klass.define_singleton_method(:new) do |*new_args, **new_kwargs, &block|
+        init_kwargs = if new_args.any?
+          raise ArgumentError, "unknown arguments #{new_args[members.size..].join(", ")}" if new_args.size > members.size
+          members.take(new_args.size).zip(new_args).to_h
+        else
+          new_kwargs
+        end
+
+        allocate.tap do |instance|
+          instance.send(:initialize, **init_kwargs, &block)
+        end.freeze
+      end
+
+      class << klass
+        alias_method :[], :new
+        undef_method :define
+      end
+
+      args.each do |arg|
+        if klass.method_defined?(arg)
+          raise ArgumentError, "duplicate member #{arg}"
+        end
+        klass.define_method(arg) do
+          @attributes[arg]
+        end
+      end
+
+      if arity_converter
+        klass.class_eval(&arity_converter)
+      end
+
+      klass
+    end
+
+    def self.inherited(subclass)
+      subclass.instance_variable_set(:@members, members)
+    end
+
+    def members
+      self.class.members
+    end
+
+    def initialize(**kwargs)
+      kwargs_size = kwargs.size
+      members_size = members.size
+
+      if kwargs_size > members_size
+        extras = kwargs.except(*members).keys
+
+        if extras.size > 1
+          raise ArgumentError, "unknown keywords: #{extras.map { |_1| ":#{_1}" }.join(", ")}"
+        else
+          raise ArgumentError, "unknown keyword: :#{extras.first}"
+        end
+      elsif kwargs_size < members_size
+        missing = members.select { |k| !kwargs.include?(k) }
+
+        if missing.size > 1
+          raise ArgumentError, "missing keywords: #{missing.map { |_1| ":#{_1}" }.join(", ")}"
+        else
+          raise ArgumentError, "missing keyword: :#{missing.first}"
+        end
+      end
+
+      @attributes = members.map { |m| [m, kwargs[m]] }.to_h
+    end
+
+    def deconstruct
+      @attributes.values
+    end
+
+    def deconstruct_keys(array)
+      raise TypeError unless array.is_a?(Array) || array.nil?
+      return @attributes if array&.first.nil?
+
+      @attributes.slice(*array)
+    end
+
+    def to_h(&block)
+      @attributes.to_h(&block)
+    end
+
+    def hash
+      to_h.hash
+    end
+
+    def eql?(other)
+      self.class == other.class && hash == other.hash
+    end
+
+    def ==(other)
+      self.class == other.class && to_h == other.to_h
+    end
+
+    def inspect
+      attribute_markers = @attributes.map do |key, value|
+        insect_key = key.to_s.start_with?("@") ? ":#{key}" : key
+        "#{insect_key}=#{value}"
+      end.join(", ")
+
+      display = ["data", self.class.name, attribute_markers].compact.join(" ")
+
+      "#<#{display}>"
+    end
+    alias_method :to_s, :inspect
+
+    def with(**kwargs)
+      return self if kwargs.empty?
+
+      self.class.new(**@attributes.merge(kwargs))
+    end
+
+    private
+
+    def marshal_dump
+      @attributes
+    end
+
+    def marshal_load(attributes)
+      @attributes = attributes
+      freeze
+    end
+
+    def initialize_copy(source)
+      super.freeze
+    end
+  end
+
+end

data/lib/.rbnext/2.7/ruby-next/core.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "set"
+require "set" # rubocop:disable Lint/RedundantRequireStatement
 
 require "ruby-next/config"
 require "ruby-next/utils"
@@ -62,7 +62,7 @@ module RubyNext
         mod_name = singleton? ? singleton.name : mod.name
         camelized_method_name = method_name.to_s.split("_").map(&:capitalize).join
 
-        "#{mod_name}#{camelized_method_name}".gsub(/\W/, "") # rubocop:disable Performance/StringReplacement
+        "#{mod_name}#{camelized_method_name}".gsub(/\W/, "")
       end
 
       def build_location(trace_locations)
@@ -78,7 +78,7 @@ module RubyNext
       end
 
       def native_location?(location)
-        location.nil? || location.first.match?(/(<internal:|resource:\/truffleruby\/core)/)
+        location.nil? || location.first.match?(/(<internal:|resource:\/truffleruby\/core|uri:classloader:\/jruby)/)
       end
     end
 
@@ -125,7 +125,7 @@ module RubyNext
 
       def patch(*__rest__, &__block__)
         patches << Patch.new(*__rest__, &__block__)
-      end
+      end; respond_to?(:ruby2_keywords, true) && (ruby2_keywords :patch)
 
       # Inject `using RubyNext` at the top of the source code
       def inject!(contents)
@@ -197,6 +197,11 @@ require "ruby-next/core/matchdata/match"
 require "ruby-next/core/enumerable/compact"
 require "ruby-next/core/integer/try_convert"
 
+require "ruby-next/core/matchdata/deconstruct"
+require "ruby-next/core/matchdata/deconstruct_keys"
+require "ruby-next/core/matchdata/named_captures"
+require "ruby-next/core/time/deconstruct_keys"
+
 # Generate refinements
 RubyNext.module_eval do
   RubyNext::Core.patches.refined.each do |mod, patches|
@@ -210,3 +215,6 @@ RubyNext.module_eval do
     end
   end
 end
+
+# Load backports
+require "ruby-next/core/data" unless ENV["RUBY_NEXT_DISABLE_DATA"] == "true"

data/lib/.rbnext/2.7/ruby-next/language/paco_parsers/string_literals.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module PacoParsers
+      class StringLiterals < Base
+        PAIRS = {"[" => "]", "{" => "}", "<" => ">"}.freeze
+
+        def default
+          all_strings.fmap do |result|
+            reduce_tokens(result.flatten)
+          end
+        end
+
+        def all_strings
+          alt(
+            single_quoted,
+            double_quoted,
+            external_cmd_exec,
+            quoted,
+            quoted_expanded
+          )
+          # heredoc,
+          # heredoc_expanded
+        end
+
+        def quoted
+          seq(
+            string("%q"),
+            any_char.bind do |char|
+              end_symbol = string(PAIRS[char] || char)
+              escapable_string(succeed(char), end_symbol)
+            end
+          )
+        end
+
+        def single_quoted
+          escapable_string(string("'"))
+        end
+
+        def quoted_expanded
+          seq(
+            alt(string("%Q"), string("%")),
+            any_char.bind do |char|
+              end_symbol = string(PAIRS[char] || char)
+              escapable_string(succeed(char), end_symbol, interpolate: true)
+            end
+          )
+        end
+
+        def external_cmd_exec
+          escapable_string(string("`"), interpolate: true)
+        end
+
+        def double_quoted
+          escapable_string(string('"'), interpolate: true)
+        end
+
+        def escapable_string(left, right = nil, interpolate: false)
+          right ||= left
+          seq(
+            left,
+            many(
+              alt(
+                *[
+                  seq(string("\\"), right).fmap { |_1| [:literal, _1] },
+                  interpolate ? seq(
+                    string('#{'),
+                    lazy { alt(balanced("{", "}", alt(all_strings, any_char)), many(none_of("}"))) },
+                    string("}")
+                  ) : nil,
+                  not_followed_by(right).bind { any_char }.fmap { |_1| [:literal, _1] }
+                ].compact
+              )
+            ),
+            right
+          )
+        end
+
+        private
+
+        def reduce_tokens(tokens)
+          state = :literal
+
+          tokens.each_with_object([]) do |v, acc|
+            if v == :literal
+              acc << [:literal, +""] unless state == :literal
+              state = :next_literal
+              next acc
+            end
+
+            if state == :next_literal
+              state = :literal
+              acc.last[1] << v
+              next acc
+            end
+
+            if state == :literal
+              acc << [:code, +""]
+            end
+
+            state = :code
+            acc.last[1] << v
+          end
+        end
+      end
+    end
+  end
+end