ruby-next-core 0.8.0 → 0.10.0

data/lib/.rbnext/2.3/ruby-next/utils.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Utils
+    module_function
+
+    if $LOAD_PATH.respond_to?(:resolve_feature_path)
+      def resolve_feature_path(feature)
+        ((!$LOAD_PATH.resolve_feature_path(feature).nil?) || nil) && $LOAD_PATH.resolve_feature_path(feature).last
+      rescue LoadError
+      end
+    else
+      def resolve_feature_path(path)
+        if File.file?(relative = File.expand_path(path))
+          path = relative
+        end
+
+        path = "#{path}.rb" if File.extname(path).empty?
+
+        return path if Pathname.new(path).absolute?
+
+        $LOAD_PATH.find do |lp|
+          lpath = File.join(lp, path)
+          return File.realpath(lpath) if File.file?(lpath)
+        end
+      end
+    end
+
+    def source_with_lines(source, path)
+      source.lines.map.with_index do |line, i|
+        "#{(i + 1).to_s.rjust(4)}:  #{line}"
+      end.tap do |lines|
+        lines.unshift "   0:  # source: #{path}"
+      end
+    end
+
+    # Returns true if modules refinement is supported in current version
+    def refine_modules?
+      @refine_modules ||=
+        begin
+          # Make sure that including modules within refinements works
+          # See https://github.com/oracle/truffleruby/issues/2026
+          eval <<-RUBY, TOPLEVEL_BINDING, __FILE__, __LINE__ + 1
+           module RubyNext::Utils::A; end
+           class RubyNext::Utils::B
+             include RubyNext::Utils::A
+           end
+           using(Module.new do
+             refine RubyNext::Utils::A do
+               include(Module.new do
+                 def i_am_refinement
+                   "yes, you are!"
+                 end
+               end)
+             end
+           end)
+           RubyNext::Utils::B.new.i_am_refinement
+          RUBY
+          true
+        rescue TypeError, NoMethodError
+          false
+        end
+    end
+  end
+end

data/lib/ruby-next.rb

@@ -4,17 +4,18 @@ require "ruby-next/version"
 
 module RubyNext
   # Mininum Ruby version supported by RubyNext
-  MIN_SUPPORTED_VERSION = Gem::Version.new("2.5.0")
+  MIN_SUPPORTED_VERSION = Gem::Version.new("2.2.0")
 
   # Where to store transpiled files (relative from the project LOAD_PATH, usually `lib/`)
   RUBY_NEXT_DIR = ".rbnext"
 
   # Defines last minor version for every major version
   LAST_MINOR_VERSIONS = {
-    2 => 8
+    2 => 8, # 2.8 is required for backward compatibility: some gems already uses it
+    3 => 0
   }.freeze
 
-  LATEST_VERSION = [2, 8].freeze
+  LATEST_VERSION = [3, 0].freeze
 
   class << self
     def next_version(version = RUBY_VERSION)
@@ -33,6 +34,8 @@ module RubyNext
     end
   end
 
-  require_relative "ruby-next/core"
-  require_relative "ruby-next/logging"
+  require "ruby-next/setup_self"
+  require "ruby-next/core"
+  require "ruby-next/core_ext" if RubyNext::Core.core_ext?
+  require "ruby-next/logging"
 end

data/lib/ruby-next/cli.rb

@@ -61,7 +61,7 @@ module RubyNext
     def maybe_print_help
       return unless @print_help
 
-      STDOUT.puts optparser.help
+      $stdout.puts optparser.help
       exit 0
     end
 
@@ -85,7 +85,7 @@ module RubyNext
           opts.banner = "Usage: ruby-next COMMAND [options]"
 
           opts.on("-v", "--version", "Print version") do
-            STDOUT.puts RubyNext::VERSION
+            $stdout.puts RubyNext::VERSION
             exit 0
           end
 

data/lib/ruby-next/commands/core_ext.rb

@@ -69,7 +69,7 @@ module RubyNext
         RubyNext::Core.patches.extensions
           .values
           .flatten
-          .filter do |patch|
+          .select do |patch|
           next if min_version && Gem::Version.new(patch.version) <= min_version
           next if filter && !filter.match?(patch.name)
           true
@@ -160,7 +160,7 @@ module RubyNext
         # remove empty lines
         new_src.gsub!(/^\s+$/, "")
         # remove traling blank lines
-        new_src.gsub!(/\n\z/, "")
+        new_src.delete_suffix!("\n")
         new_src
       end
     end

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

@@ -10,12 +10,16 @@ module RubyNext
     class Nextify < Base
       using RubyNext
 
-      attr_reader :lib_path, :paths, :out_path, :min_version, :single_version
+      attr_reader :lib_path, :paths, :out_path, :min_version, :single_version, :specified_rewriters
 
       def run
         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|
           contents = File.read(path)
           transpile path, contents
@@ -24,7 +28,8 @@ module RubyNext
 
       def parse!(args)
         print_help = false
-        @min_version = MIN_SUPPORTED_VERSION
+        print_rewriters = false
+        rewriter_names = []
         @single_version = false
 
         optparser = base_parser do |opts|
@@ -61,6 +66,14 @@ module RubyNext
             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("-h", "--help", "Print help") do
             print_help = true
           end
@@ -75,12 +88,35 @@ module RubyNext
           exit 0
         end
 
+        if print_rewriters
+          Language.rewriters.each do |rewriter|
+            $stdout.puts "#{rewriter::NAME} (\"#{rewriter::SYNTAX_PROBE}\")"
+          end
+          exit 0
+        end
+
         unless lib_path&.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
+
         @paths =
           if File.directory?(lib_path)
             Dir[File.join(lib_path, "**/*.rb")]
@@ -94,16 +130,11 @@ module RubyNext
       private
 
       def transpile(path, contents, version: min_version)
-        rewriters = Language.rewriters.select { |rw| rw.unsupported_version?(version) }
+        rewriters = specified_rewriters || Language.rewriters.select { |rw| rw.unsupported_version?(version) }
 
         context = Language::TransformContext.new
 
-        new_contents =
-          if Gem::Version.new(version) >= Gem::Version.new("2.7.0") && !defined?(Unparser::Emitter::CaseMatch)
-            Language.rewrite contents, context: context, rewriters: rewriters
-          else
-            Language.transform contents, context: context, rewriters: rewriters
-          end
+        new_contents = Language.transform contents, context: context, rewriters: rewriters
 
         return unless context.dirty?
 
@@ -120,25 +151,17 @@ module RubyNext
       end
 
       def save(contents, path, version)
-        return $stdout.puts(contents) if out_path == "stdout"
+        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?
 
         next_path =
-          if out_path
-            if out_path.end_with?(".rb")
-              out_path
-            else
-              File.join(out_path, *paths)
-            end
+          if next_dir_path.end_with?(".rb")
+            out_path
           else
-            File.join(
-              lib_path,
-              RUBY_NEXT_DIR,
-              *paths
-            )
+            File.join(next_dir_path, *paths)
           end
 
         unless CLI.dry_run?
@@ -150,7 +173,26 @@ module RubyNext
         log "Generated: #{next_path}"
       end
 
-      alias single_version? single_version
+      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 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/ruby-next/core.rb

@@ -2,6 +2,8 @@
 
 require "set"
 
+require "ruby-next/utils"
+
 module RubyNext
   module Core
     # Patch contains the extension implementation
@@ -23,7 +25,7 @@ module RubyNext
           @supported = supported.nil? ? mod.method_defined?(method_name) : supported
           # define whether running Ruby has a native implementation for this method
           # for that, we check the source_location (which is nil for C defined methods)
-          @native = native.nil? ? (supported? && mod.instance_method(method_name).source_location.nil?) : native
+          @native = native.nil? ? (supported? && native_location?(mod.instance_method(method_name).source_location)) : native
         end
         @singleton = singleton
         @refineables = Array(refineable)
@@ -73,6 +75,10 @@ module RubyNext
 
         [trace_location.absolute_path, trace_location.lineno + 2]
       end
+
+      def native_location?(location)
+        location.nil? || location.first.match?(/(<internal:|resource:\/truffleruby\/core)/)
+      end
     end
 
     # Registry for patches
@@ -95,7 +101,7 @@ module RubyNext
     end
 
     class << self
-      STRATEGIES = %i[refine core_ext].freeze
+      STRATEGIES = %i[refine core_ext backports].freeze
 
       attr_reader :strategy
 
@@ -109,7 +115,11 @@ module RubyNext
       end
 
       def core_ext?
-        strategy == :core_ext
+        strategy == :core_ext || strategy == :backports
+      end
+
+      def backports?
+        strategy == :backports
       end
 
       def patch(*args, **kwargs, &block)
@@ -136,29 +146,31 @@ module RubyNext
   end
 end
 
-require_relative "core/kernel/then"
+require "backports/2.5" if RubyNext::Core.backports?
+
+require "ruby-next/core/kernel/then"
 
-require_relative "core/proc/compose"
+require "ruby-next/core/proc/compose"
 
-require_relative "core/enumerable/tally"
-require_relative "core/enumerable/filter"
-require_relative "core/enumerable/filter_map"
+require "ruby-next/core/enumerable/tally"
+require "ruby-next/core/enumerable/filter"
+require "ruby-next/core/enumerable/filter_map"
 
-require_relative "core/enumerator/produce"
+require "ruby-next/core/enumerator/produce"
 
-require_relative "core/array/difference_union_intersection"
+require "ruby-next/core/array/difference_union_intersection"
 
-require_relative "core/hash/merge"
+require "ruby-next/core/hash/merge"
 
-require_relative "core/string/split"
+require "ruby-next/core/string/split"
 
-require_relative "core/symbol/start_with"
-require_relative "core/symbol/end_with"
+require "ruby-next/core/symbol/start_with"
+require "ruby-next/core/symbol/end_with"
 
-require_relative "core/unboundmethod/bind_call"
+require "ruby-next/core/unboundmethod/bind_call"
 
-require_relative "core/time/floor"
-require_relative "core/time/ceil"
+require "ruby-next/core/time/floor"
+require "ruby-next/core/time/ceil"
 
 # Core extensions required for pattern matching
 # Required for pattern matching with refinements
@@ -167,15 +179,20 @@ unless defined?(NoMatchingPatternError)
   end
 end
 
-require_relative "core/constants/no_matching_pattern_error"
-require_relative "core/array/deconstruct"
-require_relative "core/hash/deconstruct_keys"
-require_relative "core/struct/deconstruct"
-require_relative "core/struct/deconstruct_keys"
+require "ruby-next/core/constants/no_matching_pattern_error"
+require "ruby-next/core/array/deconstruct"
+require "ruby-next/core/hash/deconstruct_keys"
+require "ruby-next/core/struct/deconstruct"
+require "ruby-next/core/struct/deconstruct_keys"
+
+require "ruby-next/core/hash/except"
 
 # Generate refinements
 RubyNext.module_eval do
   RubyNext::Core.patches.refined.each do |mod, patches|
+    # Only refine modules when supported
+    next unless mod.is_a?(Class) || RubyNext::Utils.refine_modules?
+
     refine mod do
       patches.each do |patch|
         module_eval(patch.body, *patch.location)

data/lib/ruby-next/core/array/deconstruct.rb

@@ -1,21 +1,21 @@
 # frozen_string_literal: true
 
 RubyNext::Core.patch Array, method: :deconstruct, version: "2.7" do
-  <<~RUBY
-    def deconstruct
-      self
-    end
+  <<-RUBY
+def deconstruct
+  self
+end
   RUBY
 end
 
 # We need to hack `respond_to?` in Ruby 2.5, since it's not working with refinements
 if Gem::Version.new(RUBY_VERSION) < Gem::Version.new("2.6")
   RubyNext::Core.patch refineable: Array, name: "ArrayRespondToDeconstruct", method: :deconstruct, version: "2.7" do
-    <<~RUBY
-      def respond_to?(mid, *)
-        return true if mid == :deconstruct
-        super
-      end
+    <<-RUBY
+def respond_to?(mid, *)
+  return true if mid == :deconstruct
+  super
+end
     RUBY
   end
 end

data/lib/ruby-next/core/array/difference_union_intersection.rb

@@ -1,25 +1,25 @@
 # frozen_string_literal: true
 
 RubyNext::Core.patch Array, method: :union, version: "2.6" do
-  <<~RUBY
-    def union(*others)
-      others.reduce(Array.new(self).uniq) { |acc, arr| acc | arr }
-    end
+  <<-RUBY
+def union(*others)
+  others.reduce(Array.new(self).uniq) { |acc, arr| acc | arr }
+end
   RUBY
 end
 
 RubyNext::Core.patch Array, method: :difference, version: "2.6" do
-  <<~RUBY
-    def difference(*others)
-      others.reduce(Array.new(self)) { |acc, arr| acc - arr }
-    end
+  <<-RUBY
+def difference(*others)
+  others.reduce(Array.new(self)) { |acc, arr| acc - arr }
+end
   RUBY
 end
 
 RubyNext::Core.patch Array, method: :intersection, version: "2.7" do
-  <<~RUBY
-    def intersection(*others)
-      others.reduce(Array.new(self)) { |acc, arr| acc & arr }
-    end
+  <<-RUBY
+def intersection(*others)
+  others.reduce(Array.new(self)) { |acc, arr| acc & arr }
+end
   RUBY
 end