ruby-next-core 0.15.3 → 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"
@@ -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
 
@@ -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

data/lib/.rbnext/2.7/ruby-next/language/rewriters/2.7/pattern_matching.rb

@@ -185,7 +185,7 @@ module RubyNext
         # rubocop:disable Style/MissingRespondToMissing
         class Noop < Base
           # Return node itself, no memoization
-          def method_missing(mid, node, *)
+          def method_missing(mid, node, *__rest__)
             node
           end
         end
@@ -1035,7 +1035,7 @@ module RubyNext
           s(:send, node, :respond_to?, mid.to_ast_node)
         end
 
-        def respond_to_missing?(mid, *)
+        def respond_to_missing?(mid, *__rest__)
           return true if mid.to_s.match?(/_(clause|array_element)/)
           super
         end

data/lib/.rbnext/2.7/ruby-next/language/rewriters/text.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "ruby-next/language/paco_parser"
+
+module RubyNext
+  module Language
+    module Rewriters
+      class Text < Abstract
+        using RubyNext
+
+        class Normalizer < PacoParsers::Base
+          attr_reader :store
+
+          def initialize
+            @store = []
+          end
+
+          def normalizing(source)
+            many(
+              alt(
+                ruby_comment,
+                ruby_string,
+                ruby_code
+              )
+            ).parse(source, with_callstack: true)
+              .then(&:join)
+              .then do |_1|
+                if block_given?
+                  yield _1
+                else
+                  _1
+                end
+              end
+              .then do |new_source|
+              restore(new_source)
+            end
+          end
+
+          def ruby_comment
+            parse_comments.fmap do |result|
+              store << result
+              "# A#{store.size}Я\n"
+            end
+          end
+
+          def ruby_string
+            parse_strings.fmap do |result|
+              result.each_with_object([]) do |(type, str), acc|
+                if type == :literal
+                  store << str
+                  acc << "_A#{store.size}Я_"
+                else
+                  acc << str
+                end
+                acc
+              end.join
+            end
+          end
+
+          def ruby_code
+            any_char
+          end
+
+          def restore(source)
+            source.gsub(/(?:\# |_)A(\d+)Я(?:_|\n)/m) do |*args|
+              store[$1.to_i - 1]
+            end
+          end
+
+          def parse_comments
+            memoize { PacoParsers::Comments.new.default }
+          end
+
+          def parse_strings
+            memoize { PacoParsers::StringLiterals.new.default }
+          end
+        end
+
+        # Base class for rewriting parsers which adds the #track! method
+        class PacoParser < PacoParsers::Base
+          attr_reader :rewriter, :context
+
+          def initialize(rewriter, context)
+            @rewriter = rewriter
+            @context = context
+          end
+
+          def track!
+            context.track!(rewriter)
+          end
+        end
+
+        class << self
+          def parser(&block)
+            @paco_parser = Class.new(PacoParser, &block)
+          end
+
+          def paco_parser
+            return @paco_parser if @paco_parser
+
+            superclass.paco_parser if superclass.respond_to?(:paco_parser)
+          end
+
+          def text?
+            true
+          end
+        end
+
+        # Rewrite source code by ignoring string literals and comments
+        def rewrite(source)
+          Normalizer.new.normalizing(source) do |normalized|
+            safe_rewrite(normalized)
+          end
+        end
+
+        def safe_rewrite(source)
+          source
+        end
+
+        private
+
+        def parse(source)
+          parser_class = self.class.paco_parser
+          raise "No parser defined for #{self.class}" unless parser_class
+
+          paco_parser = self.class.paco_parser.new(self, context)
+          paco_parser.parse(source)
+        end
+      end
+    end
+  end
+end

data/lib/.rbnext/3.2/ruby-next/commands/base.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module RubyNext
+  module Commands
+    class Base
+      class << self
+        def run(args)
+          new(args).run
+        end
+      end
+
+      attr_reader :dry_run
+      alias dry_run? dry_run
+
+      def initialize(args)
+        parse! args
+      end
+
+      def parse!(*__rest__)
+        raise NotImplementedError
+      end
+
+      def run
+        raise NotImplementedError
+      end
+
+      def log(msg)
+        return unless CLI.verbose?
+
+        if CLI.dry_run?
+          $stdout.puts "[DRY RUN] #{msg}"
+        else
+          $stdout.puts msg
+        end
+      end
+
+      def base_parser
+        OptionParser.new do |opts|
+          yield opts
+
+          opts.on("-V", "Turn on verbose mode") do
+            CLI.verbose = true
+          end
+
+          opts.on("--dry-run", "Print verbose output without generating files") do
+            CLI.dry_run = true
+            CLI.verbose = true
+          end
+        end
+      end
+    end
+  end
+end