ruby-next-core 0.14.0 → 1.0.1

data/lib/.rbnext/2.1/ruby-next/commands/nextify.rb

@@ -0,0 +1,295 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "pathname"
+
+require "ruby-next/language"
+
+module RubyNext
+  module Commands
+    class Nextify < Base
+      using RubyNext
+
+      class Stats
+        def initialize
+          @started_at = ::Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          @files = 0
+          @scans = 0
+          @transpiled_files = 0
+        end
+
+        def file!
+          @files += 1
+        end
+
+        def scan!
+          @scans += 1
+        end
+
+        def transpiled!
+          @transpiled_files += 1
+        end
+
+        def report
+          <<-TXT
+           Files processed: #{@files}
+           Total scans: #{@scans}
+           Files transpiled: #{@transpiled_files}
+           Completed in #{::Process.clock_gettime(Process::CLOCK_MONOTONIC) - @started_at}s
+          TXT
+        end
+      end
+
+      attr_reader :lib_path, :paths, :out_path, :min_version, :single_version, :specified_rewriters, :overwrite
+      alias_method :overwrite?, :overwrite
+      attr_reader :stats
+
+      def run
+        @stats = Stats.new
+
+        log "RubyNext core strategy: #{RubyNext::Core.strategy}"
+        log "RubyNext transpile mode: #{RubyNext::Language.mode}"
+
+        remove_rbnext!
+
+        @min_version ||= MIN_SUPPORTED_VERSION
+
+        paths.each do |path|
+          stats.file!
+
+          contents = File.read(path)
+          transpile path, contents
+        end
+
+        ensure_rbnext!
+
+        log stats.report
+      end
+
+      def parse!(args)
+        print_help = false
+        print_rewriters = false
+        rewriter_names = []
+        custom_rewriters = []
+        @single_version = false
+        @overwrite = false
+
+        optparser = base_parser do |opts|
+          opts.banner = "Usage: ruby-next nextify DIRECTORY_OR_FILE [options]"
+
+          opts.on("-o", "--output=OUTPUT", "Specify output directory or file or stdout") do |val|
+            @out_path = val
+          end
+
+          opts.on("--min-version=VERSION", "Specify the minimum Ruby version to support") do |val|
+            @min_version = Gem::Version.new(val)
+          end
+
+          opts.on("--single-version", "Only create one version of a file (for the earliest Ruby version)") do
+            @single_version = true
+          end
+
+          opts.on("--overwrite", "Overwrite original file") do
+            @overwrite = true
+          end
+
+          opts.on("--edge", "Enable edge (master) Ruby features") do |val|
+            ENV["RUBY_NEXT_EDGE"] = val.to_s
+            require "ruby-next/language/rewriters/edge"
+          end
+
+          opts.on("--proposed", "Enable proposed/experimental Ruby features") do |val|
+            ENV["RUBY_NEXT_PROPOSED"] = val.to_s
+            require "ruby-next/language/rewriters/proposed"
+          end
+
+          opts.on(
+            "--transpile-mode=MODE",
+            "Transpiler mode (ast or rewrite). Default: rewrite"
+          ) do |val|
+            Language.mode = val.to_sym
+          end
+
+          opts.on("--[no-]refine", "Do not inject `using RubyNext`") do |val|
+            Core.strategy = :core_ext unless val
+          end
+
+          opts.on("--list-rewriters", "List available rewriters") do |val|
+            print_rewriters = true
+          end
+
+          opts.on("--rewrite=REWRITERS...", "Specify particular Ruby features to rewrite") do |val|
+            rewriter_names << val
+          end
+
+          opts.on("--import-rewriter=REWRITERS...", "Specify paths to load custom rewritiers") do |val|
+            custom_rewriters << val
+          end
+
+          opts.on("-h", "--help", "Print help") do
+            print_help = true
+          end
+        end
+
+        optparser.parse!(args)
+
+        @lib_path = args[0]
+
+        if print_help
+          $stdout.puts optparser.help
+          exit 0
+        end
+
+        # Load custom rewriters
+        custom_rewriters.each do |path|
+          Kernel.load path
+        end
+
+        if print_rewriters
+          Language.rewriters.each do |rewriter|
+            $stdout.puts "#{rewriter::NAME} (\"#{rewriter::SYNTAX_PROBE}\")#{rewriter.unsupported_syntax? ? " (unsupported)" : ""}"
+          end
+          exit 0
+        end
+
+        unless ((((__safe_lvar__ = lib_path) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.then(&File.method(:exist?)))
+          $stdout.puts "Path not found: #{lib_path}"
+          $stdout.puts optparser.help
+          exit 2
+        end
+
+        if rewriter_names.any? && min_version
+          $stdout.puts "--rewrite cannot be used with --min-version simultaneously"
+          exit 2
+        end
+
+        @specified_rewriters =
+          if rewriter_names.any?
+            begin
+              Language.select_rewriters(*rewriter_names)
+            rescue Language::RewriterNotFoundError => error
+              $stdout.puts error.message
+              $stdout.puts "Try --list-rewriters to see list of available rewriters"
+              exit 2
+            end
+          end
+
+        if overwrite? && !single_version?
+          $stdout.puts "--overwrite only works with --single-version or explcit rewritires specified (via --rewrite)"
+          exit 2
+        end
+
+        @paths =
+          if File.directory?(lib_path)
+            Dir[File.join(lib_path, "**/*.rb")]
+          elsif File.file?(lib_path)
+            [lib_path].tap do |_|
+              @lib_path = File.dirname(lib_path)
+            end
+          end
+      end
+
+      private
+
+      def transpile(path, contents, version: min_version)
+        stats.scan!
+
+        rewriters = specified_rewriters || Language.rewriters.select { |rw| rw.unsupported_version?(version) }
+
+        context = Language::TransformContext.new
+
+        new_contents = Language.transform contents, context: context, rewriters: rewriters
+
+        return unless context.dirty?
+
+        versions = context.sorted_versions
+        version = versions.shift
+
+        # First, store already transpiled contents in the minimum required version dir
+        save new_contents, path, version
+
+        return if versions.empty? || single_version?
+
+        # Then, generate the source code for the next version
+        transpile path, contents, version: version
+      rescue SyntaxError, StandardError => e
+        warn "Failed to transpile #{path}: #{e.class} — #{e.message}"
+        warn e.backtrace.take(10).join("\n") if ENV["RUBY_NEXT_DEBUG"] == "1"
+        exit 1
+      end
+
+      def save(contents, path, version)
+        stats.transpiled!
+
+        return $stdout.puts(contents) if stdout?
+
+        paths = [Pathname.new(path).relative_path_from(Pathname.new(lib_path))]
+
+        paths.unshift(version.segments[0..1].join(".")) unless single_version?
+
+        if overwrite?
+          overwrite_file_content!(path: path, contents: contents)
+
+          return
+        end
+
+        next_path =
+          if next_dir_path.end_with?(".rb")
+            out_path
+          else
+            File.join(next_dir_path, *paths)
+          end
+
+        unless CLI.dry_run?
+          FileUtils.mkdir_p File.dirname(next_path)
+
+          File.write(next_path, contents)
+        end
+
+        log "Generated: #{next_path}"
+      end
+
+      def overwrite_file_content!(path: ::Kernel.raise(::ArgumentError, "missing keyword: path"), contents: ::Kernel.raise(::ArgumentError, "missing keyword: contents"))
+        unless CLI.dry_run?
+          File.write(path, contents)
+        end
+
+        log "Overwritten: #{path}"
+      end
+
+      def remove_rbnext!
+        return if CLI.dry_run? || stdout?
+
+        return unless File.directory?(next_dir_path)
+
+        log "Remove old files: #{next_dir_path}"
+        FileUtils.rm_r(next_dir_path)
+      end
+
+      def ensure_rbnext!
+        return if CLI.dry_run? || stdout?
+
+        return if File.directory?(next_dir_path)
+
+        return if next_dir_path.end_with?(".rb")
+
+        return if overwrite?
+
+        FileUtils.mkdir_p next_dir_path
+        File.write(File.join(next_dir_path, ".keep"), "")
+      end
+
+      def next_dir_path
+        @next_dir_path ||= out_path || File.join(lib_path, RUBY_NEXT_DIR)
+      end
+
+      def stdout?
+        out_path == "stdout"
+      end
+
+      def single_version?
+        single_version || specified_rewriters
+      end
+    end
+  end
+end

data/lib/.rbnext/2.1/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.1/ruby-next/language.rb

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
 
-gem "ruby-next-parser", ">= 2.8.0.3"
-gem "unparser", ">= 0.4.7"
+# Checking gem specs doesn't work in ruby.wasm
+unless RUBY_PLATFORM.match?(/wasm/)
+  gem "ruby-next-parser", ">= 2.8.0.3"
+  gem "unparser", ">= 0.4.7"
+end
 
-require "set"
+require "set" # rubocop:disable Lint/RedundantRequireStatement
 
 require "ruby-next"
 
@@ -62,8 +65,15 @@ module RubyNext
     end
 
     class << self
+      attr_reader :include_patterns
+      attr_reader :exclude_patterns
+
+      def watch_dirs
+        warn "[DEPRECATED] Use `RubyNext::Language.include_patterns` instead of `RubyNext::Language.watch_dirs`"
+        @watch_dirs
+      end
+
       attr_accessor :rewriters
-      attr_reader :watch_dirs
 
       attr_accessor :strategy
 
@@ -95,14 +105,17 @@ module RubyNext
       end
 
       def transform(source, rewriters: self.rewriters, using: RubyNext::Core.refine?, context: TransformContext.new)
+        text_rewriters, ast_rewriters = rewriters.partition(&:text?)
+
         retried = 0
-        new_source = nil
+        new_source = text_rewrite(source, rewriters: text_rewriters, using: using, context: context)
+
         begin
           new_source =
             if mode == :rewrite
-              rewrite(source, rewriters: rewriters, using: using, context: context)
+              rewrite(new_source, rewriters: ast_rewriters, using: using, context: context)
             else
-              regenerate(source, rewriters: rewriters, using: using, context: context)
+              regenerate(new_source, rewriters: ast_rewriters, using: using, context: context)
             end
         rescue Unparser::UnknownNodeError => err
           RubyNext.warn "Ruby Next fallbacks to \"rewrite\" transpiling mode since the version of Unparser you use doesn't support some syntax yet: #{err.message}.\n" \
@@ -119,8 +132,17 @@ module RubyNext
         Core.inject! new_source.dup
       end
 
+      def target_dir?(dirname)
+        # fnmatch? requires a file name, not a folder
+        fname = File.join(dirname, "x.rb")
+
+        include_patterns.any? { |pattern| File.fnmatch?(pattern, fname) } &&
+          exclude_patterns.none? { |pattern| File.fnmatch?(pattern, fname) }
+      end
+
       def transformable?(path)
-        watch_dirs.any? { |dir| path.start_with?(dir) }
+        include_patterns.any? { |pattern| File.fnmatch?(pattern, path) } &&
+          exclude_patterns.none? { |pattern| File.fnmatch?(pattern, path) }
       end
 
       # Rewriters required for the current version
@@ -165,14 +187,36 @@ module RubyNext
         end
       end
 
+      def text_rewrite(source, rewriters: ::Kernel.raise(::ArgumentError, "missing keyword: rewriters"), using: ::Kernel.raise(::ArgumentError, "missing keyword: using"), context: ::Kernel.raise(::ArgumentError, "missing keyword: context"))
+        rewriters.inject(source) do |src, rewriter|
+          rewriter.new(context).rewrite(src)
+        end.then do |new_source|
+          next source unless context.dirty?
+
+          new_source
+        end
+      end
+
       attr_writer :watch_dirs
+      attr_writer :include_patterns, :exclude_patterns
     end
 
     self.rewriters = []
-    self.watch_dirs = %w[app lib spec test].map { |path| File.join(Dir.pwd, path) }
+    self.watch_dirs = [].tap do |dirs|
+      # For backward compatibility
+      dirs.define_singleton_method(:<<) do |dir|
+        super(dir)
+        RubyNext::Language.include_patterns << File.join(dir, "*.rb")
+      end
+    end
+
+    self.include_patterns = %w[app lib spec test].map { |path| File.join(Dir.pwd, path, "*.rb") }
+    self.exclude_patterns = %w[vendor/bundle].map { |path| File.join(Dir.pwd, path, "*") }
     self.mode = ENV.fetch("RUBY_NEXT_TRANSPILE_MODE", "rewrite").to_sym
 
+    require "ruby-next/language/rewriters/abstract"
     require "ruby-next/language/rewriters/base"
+    require "ruby-next/language/rewriters/text"
 
     require "ruby-next/language/rewriters/2.1/numeric_literals"
     rewriters << Rewriters::NumericLiterals
@@ -186,6 +230,9 @@ module RubyNext
     require "ruby-next/language/rewriters/2.3/safe_navigation"
     rewriters << Rewriters::SafeNavigation
 
+    require "ruby-next/language/rewriters/2.5/rescue_within_block"
+    rewriters << Rewriters::RescueWithinBlock
+
     require "ruby-next/language/rewriters/2.7/args_forward"
     rewriters << Rewriters::ArgsForward
 
@@ -209,7 +256,7 @@ module RubyNext
     rewriters << Rewriters::InPattern
 
     require "ruby-next/language/rewriters/3.0/endless_method"
-    RubyNext::Language.rewriters << RubyNext::Language::Rewriters::EndlessMethod
+    rewriters << RubyNext::Language::Rewriters::EndlessMethod
 
     require "ruby-next/language/rewriters/3.1/oneline_pattern_parensless"
     rewriters << Rewriters::OnelinePatternParensless
@@ -229,16 +276,19 @@ module RubyNext
     require "ruby-next/language/rewriters/3.1/shorthand_hash"
     rewriters << RubyNext::Language::Rewriters::ShorthandHash
 
+    require "ruby-next/language/rewriters/3.2/anonymous_restargs"
+    rewriters << RubyNext::Language::Rewriters::AnonymousRestArgs
+
     # Put endless range in the end, 'cause Parser fails to parse it in
     # pattern matching
     require "ruby-next/language/rewriters/2.6/endless_range"
     rewriters << Rewriters::EndlessRange
 
-    if ENV["RUBY_NEXT_EDGE"] == "1"
+    if RubyNext.edge_syntax?
       require "ruby-next/language/rewriters/edge"
     end
 
-    if ENV["RUBY_NEXT_PROPOSED"] == "1"
+    if RubyNext.proposed_syntax?
       require "ruby-next/language/rewriters/proposed"
     end
   end

data/lib/.rbnext/2.3/ruby-next/commands/nextify.rb

@@ -10,9 +10,43 @@ module RubyNext
     class Nextify < Base
       using RubyNext
 
-      attr_reader :lib_path, :paths, :out_path, :min_version, :single_version, :specified_rewriters
+      class Stats
+        def initialize
+          @started_at = ::Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          @files = 0
+          @scans = 0
+          @transpiled_files = 0
+        end
+
+        def file!
+          @files += 1
+        end
+
+        def scan!
+          @scans += 1
+        end
+
+        def transpiled!
+          @transpiled_files += 1
+        end
+
+        def report
+          <<-TXT
+           Files processed: #{@files}
+           Total scans: #{@scans}
+           Files transpiled: #{@transpiled_files}
+           Completed in #{::Process.clock_gettime(Process::CLOCK_MONOTONIC) - @started_at}s
+          TXT
+        end
+      end
+
+      attr_reader :lib_path, :paths, :out_path, :min_version, :single_version, :specified_rewriters, :overwrite
+      alias_method :overwrite?, :overwrite
+      attr_reader :stats
 
       def run
+        @stats = Stats.new
+
         log "RubyNext core strategy: #{RubyNext::Core.strategy}"
         log "RubyNext transpile mode: #{RubyNext::Language.mode}"
 
@@ -21,16 +55,24 @@ module RubyNext
         @min_version ||= MIN_SUPPORTED_VERSION
 
         paths.each do |path|
+          stats.file!
+
           contents = File.read(path)
           transpile path, contents
         end
+
+        ensure_rbnext!
+
+        log stats.report
       end
 
       def parse!(args)
         print_help = false
         print_rewriters = false
         rewriter_names = []
+        custom_rewriters = []
         @single_version = false
+        @overwrite = false
 
         optparser = base_parser do |opts|
           opts.banner = "Usage: ruby-next nextify DIRECTORY_OR_FILE [options]"
@@ -47,11 +89,17 @@ module RubyNext
             @single_version = true
           end
 
+          opts.on("--overwrite", "Overwrite original file") do
+            @overwrite = true
+          end
+
           opts.on("--edge", "Enable edge (master) Ruby features") do |val|
+            ENV["RUBY_NEXT_EDGE"] = val.to_s
             require "ruby-next/language/rewriters/edge"
           end
 
           opts.on("--proposed", "Enable proposed/experimental Ruby features") do |val|
+            ENV["RUBY_NEXT_PROPOSED"] = val.to_s
             require "ruby-next/language/rewriters/proposed"
           end
 
@@ -74,6 +122,10 @@ module RubyNext
             rewriter_names << val
           end
 
+          opts.on("--import-rewriter=REWRITERS...", "Specify paths to load custom rewritiers") do |val|
+            custom_rewriters << val
+          end
+
           opts.on("-h", "--help", "Print help") do
             print_help = true
           end
@@ -88,9 +140,14 @@ module RubyNext
           exit 0
         end
 
+        # Load custom rewriters
+        custom_rewriters.each do |path|
+          Kernel.load path
+        end
+
         if print_rewriters
           Language.rewriters.each do |rewriter|
-            $stdout.puts "#{rewriter::NAME} (\"#{rewriter::SYNTAX_PROBE}\")"
+            $stdout.puts "#{rewriter::NAME} (\"#{rewriter::SYNTAX_PROBE}\")#{rewriter.unsupported_syntax? ? " (unsupported)" : ""}"
           end
           exit 0
         end
@@ -117,6 +174,11 @@ module RubyNext
             end
           end
 
+        if overwrite? && !single_version?
+          $stdout.puts "--overwrite only works with --single-version or explcit rewritires specified (via --rewrite)"
+          exit 2
+        end
+
         @paths =
           if File.directory?(lib_path)
             Dir[File.join(lib_path, "**/*.rb")]
@@ -130,6 +192,8 @@ module RubyNext
       private
 
       def transpile(path, contents, version: min_version)
+        stats.scan!
+
         rewriters = specified_rewriters || Language.rewriters.select { |rw| rw.unsupported_version?(version) }
 
         context = Language::TransformContext.new
@@ -150,16 +214,25 @@ module RubyNext
         transpile path, contents, version: version
       rescue SyntaxError, StandardError => e
         warn "Failed to transpile #{path}: #{e.class} — #{e.message}"
+        warn e.backtrace.take(10).join("\n") if ENV["RUBY_NEXT_DEBUG"] == "1"
         exit 1
       end
 
       def save(contents, path, version)
+        stats.transpiled!
+
         return $stdout.puts(contents) if stdout?
 
         paths = [Pathname.new(path).relative_path_from(Pathname.new(lib_path))]
 
         paths.unshift(version.segments[0..1].join(".")) unless single_version?
 
+        if overwrite?
+          overwrite_file_content!(path: path, contents: contents)
+
+          return
+        end
+
         next_path =
           if next_dir_path.end_with?(".rb")
             out_path
@@ -176,6 +249,14 @@ module RubyNext
         log "Generated: #{next_path}"
       end
 
+      def overwrite_file_content!(path:, contents:)
+        unless CLI.dry_run?
+          File.write(path, contents)
+        end
+
+        log "Overwritten: #{path}"
+      end
+
       def remove_rbnext!
         return if CLI.dry_run? || stdout?
 
@@ -185,8 +266,21 @@ module RubyNext
         FileUtils.rm_r(next_dir_path)
       end
 
+      def ensure_rbnext!
+        return if CLI.dry_run? || stdout?
+
+        return if File.directory?(next_dir_path)
+
+        return if next_dir_path.end_with?(".rb")
+
+        return if overwrite?
+
+        FileUtils.mkdir_p next_dir_path
+        File.write(File.join(next_dir_path, ".keep"), "")
+      end
+
       def next_dir_path
-        @next_dir_path ||= (out_path || File.join(lib_path, RUBY_NEXT_DIR))
+        @next_dir_path ||= out_path || File.join(lib_path, RUBY_NEXT_DIR)
       end
 
       def stdout?