ruby-next-core 0.10.1 → 0.11.0

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

@@ -6,7 +6,7 @@ module RubyNext
 
     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
+        ((!$LOAD_PATH.resolve_feature_path(feature).nil? || nil) && $LOAD_PATH.resolve_feature_path(feature).last)
       rescue LoadError
       end
     else

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

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require "set"
+
+require "ruby-next/config"
+require "ruby-next/utils"
+
+module RubyNext
+  module Core
+    # Patch contains the extension implementation
+    # and meta information (e.g., Ruby version).
+    class Patch
+      attr_reader :refineables, :name, :mod, :method_name, :version, :body, :singleton, :core_ext, :supported, :native, :location
+
+      # Create a new patch for module/class (mod)
+      # with the specified uniq name
+      #
+      # `core_ext` defines the strategy for core extensions:
+      #    - :patch — extend class directly
+      #    - :prepend — extend class by prepending a module (e.g., when needs `super`)
+      def initialize(mod = nil, method:, version:, name: nil, supported: nil, native: nil, location: nil, refineable: mod, core_ext: :patch, singleton: nil)
+        @mod = mod
+        @method_name = method
+        @version = version
+        if method_name && mod
+          @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? && native_location?(mod.instance_method(method_name).source_location)) : native
+        end
+        @singleton = singleton
+        @refineables = Array(refineable)
+        @body = yield
+        @core_ext = core_ext
+        @location = location || build_location(caller_locations(1, 5))
+        @name = name || build_module_name
+      end
+
+      def prepend?
+        core_ext == :prepend
+      end
+
+      def core_ext?
+        !mod.nil?
+      end
+
+      alias supported? supported
+      alias native? native
+      alias singleton? singleton
+
+      def to_module
+        Module.new.tap do |ext|
+          ext.module_eval(body, *location)
+
+          RubyNext::Core.const_set(name, ext)
+        end
+      end
+
+      private
+
+      def build_module_name
+        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/, "")
+      end
+
+      def build_location(trace_locations)
+        # The caller_locations behaviour depends on implementaion,
+        # e.g. in JRuby https://github.com/jruby/jruby/issues/6055
+        while trace_locations.first.label != "patch"
+          trace_locations.shift
+        end
+
+        trace_location = trace_locations[1]
+
+        [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
+    class Patches
+      attr_reader :extensions, :refined
+
+      def initialize
+        @names = Set.new
+        @extensions = Hash.new { |h, k| h[k] = [] }
+        @refined = Hash.new { |h, k| h[k] = [] }
+      end
+
+      # Register new patch
+      def <<(patch)
+        raise ArgumentError, "Patch already registered: #{patch.name}" if @names.include?(patch.name)
+        @names << patch.name
+        @extensions[patch.mod] << patch if patch.core_ext?
+        patch.refineables.each { |r| @refined[r] << patch } unless patch.native?
+      end
+    end
+
+    class << self
+      STRATEGIES = %i[refine core_ext backports].freeze
+
+      attr_reader :strategy
+
+      def strategy=(val)
+        raise ArgumentError, "Unknown strategy: #{val}. Available: #{STRATEGIES.join(",")}" unless STRATEGIES.include?(val)
+        @strategy = val
+      end
+
+      def refine?
+        strategy == :refine
+      end
+
+      def core_ext?
+        strategy == :core_ext || strategy == :backports
+      end
+
+      def backports?
+        strategy == :backports
+      end
+
+      def patch(*__rest__, &__block__)
+        patches << Patch.new(*__rest__, &__block__)
+      end
+
+      # Inject `using RubyNext` at the top of the source code
+      def inject!(contents)
+        if contents.frozen?
+          contents = contents.sub(/^(\s*[^#\s].*)/, 'using RubyNext;\1')
+        else
+          contents.sub!(/^(\s*[^#\s].*)/, 'using RubyNext;\1')
+        end
+        contents
+      end
+
+      def patches
+        @patches ||= Patches.new
+      end
+    end
+
+    # Use refinements by default
+    self.strategy = ENV.fetch("RUBY_NEXT_CORE_STRATEGY", "refine").to_sym
+  end
+end
+
+require "backports/2.5" if RubyNext::Core.backports?
+
+require "ruby-next/core/kernel/then"
+
+require "ruby-next/core/proc/compose"
+
+require "ruby-next/core/enumerable/tally"
+require "ruby-next/core/enumerable/filter"
+require "ruby-next/core/enumerable/filter_map"
+
+require "ruby-next/core/enumerator/produce"
+
+require "ruby-next/core/array/difference_union_intersection"
+
+require "ruby-next/core/hash/merge"
+
+require "ruby-next/core/string/split"
+
+require "ruby-next/core/symbol/start_with"
+require "ruby-next/core/symbol/end_with"
+
+require "ruby-next/core/unboundmethod/bind_call"
+
+require "ruby-next/core/time/floor"
+require "ruby-next/core/time/ceil"
+
+# Core extensions required for pattern matching
+# Required for pattern matching with refinements
+unless defined?(NoMatchingPatternError)
+  class NoMatchingPatternError < StandardError
+  end
+end
+
+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)
+      end
+    end
+  end
+end

data/lib/ruby-next.rb

@@ -1,41 +1,8 @@
 # frozen_string_literal: true
 
 require "ruby-next/version"
-
-module RubyNext
-  # Mininum Ruby version supported by RubyNext
-  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 is required for backward compatibility: some gems already uses it
-    3 => 0
-  }.freeze
-
-  LATEST_VERSION = [3, 0].freeze
-
-  class << self
-    def next_version(version = RUBY_VERSION)
-      major, minor = Gem::Version.new(version).segments.map(&:to_i)
-
-      return if major >= LATEST_VERSION.first && minor >= LATEST_VERSION.last
-
-      nxt =
-        if LAST_MINOR_VERSIONS[major] == minor
-          "#{major + 1}.0.0"
-        else
-          "#{major}.#{minor + 1}.0"
-        end
-
-      Gem::Version.new(nxt)
-    end
-  end
-
-  require "ruby-next/setup_self"
-  require "ruby-next/core"
-  require "ruby-next/core_ext" if RubyNext::Core.core_ext?
-  require "ruby-next/logging"
-end
+require "ruby-next/config"
+require "ruby-next/setup_self"
+require "ruby-next/core"
+require "ruby-next/core_ext" if RubyNext::Core.core_ext?
+require "ruby-next/logging"

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

@@ -57,7 +57,7 @@ module RubyNext
 
           opts.on(
             "--transpile-mode=MODE",
-            "Transpiler mode (ast or rewrite). Default: ast"
+            "Transpiler mode (ast or rewrite). Default: rewrite"
           ) do |val|
             Language.mode = val.to_sym
           end
@@ -148,6 +148,9 @@ module RubyNext
 
         # 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}"
+        exit 1
       end
 
       def save(contents, path, version)

data/lib/ruby-next/config.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RubyNext
+  # Mininum Ruby version supported by RubyNext
+  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 is required for backward compatibility: some gems already uses it
+    3 => 0
+  }.freeze
+
+  LATEST_VERSION = [3, 0].freeze
+
+  class << self
+    # TruffleRuby claims it's 2.7.2 compatible but...
+    if defined?(TruffleRuby) && ::RUBY_VERSION =~ /^2\.7/
+      def current_ruby_version
+        "2.6.5"
+      end
+    else
+      def current_ruby_version
+        ::RUBY_VERSION
+      end
+    end
+
+    def next_ruby_version(version = current_ruby_version)
+      major, minor = Gem::Version.new(version).segments.map(&:to_i)
+
+      return if major >= LATEST_VERSION.first && minor >= LATEST_VERSION.last
+
+      nxt =
+        if LAST_MINOR_VERSIONS[major] == minor
+          "#{major + 1}.0.0"
+        else
+          "#{major}.#{minor + 1}.0"
+        end
+
+      Gem::Version.new(nxt)
+    end
+  end
+end

data/lib/ruby-next/core.rb

@@ -2,6 +2,7 @@
 
 require "set"
 
+require "ruby-next/config"
 require "ruby-next/utils"
 
 module RubyNext
@@ -17,7 +18,7 @@ module RubyNext
       # `core_ext` defines the strategy for core extensions:
       #    - :patch — extend class directly
       #    - :prepend — extend class by prepending a module (e.g., when needs `super`)
-      def initialize(mod = nil, method:, name: nil, version:, supported: nil, native: nil, location: nil, refineable: mod, core_ext: :patch, singleton: nil)
+      def initialize(mod = nil, method:, version:, name: nil, supported: nil, native: nil, location: nil, refineable: mod, core_ext: :patch, singleton: nil)
         @mod = mod
         @method_name = method
         @version = version
@@ -122,8 +123,8 @@ module RubyNext
         strategy == :backports
       end
 
-      def patch(*args, **kwargs, &block)
-        patches << Patch.new(*args, **kwargs, &block)
+      def patch(...)
+        patches << Patch.new(...)
       end
 
       # Inject `using RubyNext` at the top of the source code
@@ -175,7 +176,7 @@ require "ruby-next/core/time/ceil"
 # Core extensions required for pattern matching
 # Required for pattern matching with refinements
 unless defined?(NoMatchingPatternError)
-  class NoMatchingPatternError < RuntimeError
+  class NoMatchingPatternError < StandardError
   end
 end
 

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

@@ -9,7 +9,7 @@ end
 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")
+if Gem::Version.new(::RubyNext.current_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, *)

data/lib/ruby-next/core/constants/no_matching_pattern_error.rb

@@ -11,7 +11,7 @@ RubyNext::Core.patch Object,
   supported: true,
   location: [__FILE__, __LINE__ + 2] do
   <<-RUBY
-class NoMatchingPatternError < RuntimeError
+class NoMatchingPatternError < StandardError
 end
   RUBY
 end

data/lib/ruby-next/core/hash/deconstruct_keys.rb

@@ -9,7 +9,7 @@ end
 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")
+if Gem::Version.new(::RubyNext.current_ruby_version) < Gem::Version.new("2.6")
   RubyNext::Core.patch refineable: Hash, name: "HashRespondToDeconstructKeys", method: :deconstruct_keys, version: "2.7" do
     <<-RUBY
 def respond_to?(mid, *)

data/lib/ruby-next/core/struct/deconstruct_keys.rb

@@ -10,9 +10,9 @@ def deconstruct_keys(keys)
 
   keys.each_with_object({}) do |k, acc|
     # if k is Symbol and not a member of a Struct return {}
-    next if (Symbol === k || String === k) && !members.include?(k.to_sym)
+    return {} if (Symbol === k || String === k) && !members.include?(k.to_sym)
     # if k is Integer check that index is not ouf of bounds
-    next if Integer === k && k > size - 1
+    return {} if Integer === k && k > size - 1
     acc[k] = self[k]
   end
 end
@@ -20,7 +20,7 @@ end
 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")
+if Gem::Version.new(::RubyNext.current_ruby_version) < Gem::Version.new("2.6")
   RubyNext::Core.patch refineable: Struct, name: "StructRespondToDeconstruct", method: :deconstruct_keys, version: "2.7" do
     <<-RUBY
 def respond_to?(mid, *)

data/lib/ruby-next/core_ext.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "ruby-next/config"
+require "ruby-next/setup_self"
 require "ruby-next/core"
 
 # Monkey-patch core classes using the same patches as for refinements

data/lib/ruby-next/language.rb

@@ -39,7 +39,7 @@ module RubyNext
       # Called by rewriter when it performs transfomrations
       def track!(rewriter)
         @dirty = true
-        versions << rewriter.class.min_supported_minor_version
+        versions << rewriter.class::MIN_SUPPORTED_VERSION
       end
 
       def use_ruby_next!
@@ -101,9 +101,9 @@ module RubyNext
           regenerate(*args, **kwargs)
         end
       rescue Unparser::UnknownNodeError
-        if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.7.0")
-          RubyNext.warn "Ruby Next fallbacks to \"rewrite\" transpiling mode since Unparser doesn't support 2.7+ AST yet.\n" \
-            "See https://github.com/mbj/unparser/pull/142"
+        if Gem::Version.new(::RubyNext.current_ruby_version) >= Gem::Version.new("3.0.0")
+          RubyNext.warn "Ruby Next fallbacks to \"rewrite\" transpiling mode since Unparser doesn't support 3.0+ AST yet.\n" \
+            "See https://github.com/mbj/unparser/issues/168"
           self.mode = :rewrite
         end
         rewrite(*args, **kwargs)
@@ -169,7 +169,7 @@ module RubyNext
 
     self.rewriters = []
     self.watch_dirs = %w[app lib spec test].map { |path| File.join(Dir.pwd, path) }
-    self.mode = ENV.fetch("RUBY_NEXT_TRANSPILE_MODE", "ast").to_sym
+    self.mode = ENV.fetch("RUBY_NEXT_TRANSPILE_MODE", "rewrite").to_sym
 
     require "ruby-next/language/rewriters/base"
 
@@ -182,6 +182,11 @@ module RubyNext
     require "ruby-next/language/rewriters/args_forward"
     rewriters << Rewriters::ArgsForward
 
+    # Must be added after general args forward rewriter to become
+    # no-op in Ruby <2.7
+    require "ruby-next/language/rewriters/args_forward_leading"
+    rewriters << Rewriters::ArgsForwardLeading
+
     require "ruby-next/language/rewriters/numbered_params"
     rewriters << Rewriters::NumberedParams
 
@@ -193,11 +198,17 @@ module RubyNext
     require "ruby-next/language/rewriters/find_pattern"
     rewriters << Rewriters::FindPattern
 
+    require "ruby-next/language/rewriters/in_pattern"
+    rewriters << Rewriters::InPattern
+
     # Put endless range in the end, 'cause Parser fails to parse it in
     # pattern matching
     require "ruby-next/language/rewriters/endless_range"
     rewriters << Rewriters::EndlessRange
 
+    require "ruby-next/language/rewriters/endless_method"
+    RubyNext::Language.rewriters << RubyNext::Language::Rewriters::EndlessMethod
+
     if ENV["RUBY_NEXT_EDGE"] == "1"
       require "ruby-next/language/edge"
     end