ruby-next-core 0.15.3 → 1.0.1

data/lib/.rbnext/3.2/ruby-next/rubocop.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+# This file contains patches to RuboCop to support
+# edge features and fix some bugs with 2.7+ syntax
+
+require "parser/ruby-next/version"
+require "ruby-next/config"
+require "ruby-next/language/parser"
+
+module RuboCop
+  # Transform Ruby Next parser version to a float, e.g.: "2.8.0.1" => 2.801
+  RUBY_NEXT_VERSION = Parser::NEXT_VERSION.match(/(^\d+)\.(.+)$/)[1..-1].map { |part| part.delete(".") }.join(".").to_f
+
+  class TargetRuby
+    class RuboCopNextConfig < RuboCopConfig
+      private
+
+      def find_version
+        version = @config.for_all_cops["TargetRubyVersion"]
+        return unless version == "next"
+
+        RUBY_NEXT_VERSION
+      end
+    end
+
+    new_rubies = KNOWN_RUBIES + [RUBY_NEXT_VERSION]
+    remove_const :KNOWN_RUBIES
+    const_set :KNOWN_RUBIES, new_rubies
+
+    new_sources = [RuboCopNextConfig] + SOURCES
+    remove_const :SOURCES
+    const_set :SOURCES, new_sources
+  end
+end
+
+module RuboCop
+  class ProcessedSource
+    module ParserClassExt
+      def parser_class(version)
+        return super unless version == RUBY_NEXT_VERSION
+
+        require "parser/rubynext"
+        Parser::RubyNext
+      end
+    end
+
+    prepend ParserClassExt
+  end
+end
+
+# Let's make this file Ruby 2.2 compatible to avoid transpiling
+# rubocop:disable Layout/HeredocIndentation
+module RuboCop
+  module AST
+    module Traversal
+      # Fixed in https://github.com/rubocop-hq/rubocop/pull/7786
+      %i[case_match in_pattern find_pattern match_pattern match_pattern_p].each do |type|
+        next if method_defined?(:"on_#{type}")
+        module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+def on_#{type}(node)
+node.children.each { |child| send(:"on_\#{child.type}", child) if child }
+nil
+end
+        RUBY
+      end
+    end
+
+    unless Builder.method_defined?(:match_pattern_p)
+      Builder.include RubyNext::Language::BuilderExt
+    end
+  end
+end
+# rubocop:enable Layout/HeredocIndentation
+
+module RuboCop
+  module Cop
+    # Commissioner class is responsible for processing the AST and delegating
+    # work to the specified cops.
+    class Commissioner
+      def on_meth_ref(node)
+        trigger_responding_cops(:on_meth_ref, node)
+      end
+
+      unless method_defined?(:on_numblock)
+        def on_numblock(node)
+          children = node.children
+          child = children[0]
+          send(:"on_#{child.type}", child)
+          # children[1] is the number of parameters
+          return unless (child = children[2])
+
+          send(:"on_#{child.type}", child)
+        end
+      end
+
+      unless method_defined?(:on_def_e)
+        def on_def_e(node)
+          _name, _args_node, body_node = *node
+          send(:"on_#{body_node.type}", body_node)
+        end
+
+        def on_defs_e(node)
+          _definee_node, _name, _args_node, body_node = *node
+          send(:"on_#{body_node.type}", body_node)
+        end
+      end
+    end
+
+    Commissioner.prepend(Module.new do
+      # Ignore anonymous blocks
+      def on_block_pass(node)
+        return if node.children == [nil]
+
+        super
+      end
+
+      def on_blockarg(node)
+        return if node.children == [nil]
+
+        super
+      end
+    end)
+
+    module Layout
+      require "rubocop/cop/layout/assignment_indentation"
+
+      POTENTIAL_RIGHT_TYPES = %i[ivasgn lvasgn cvasgn gvasgn casgn masgn].freeze
+
+      AssignmentIndentation.prepend(Module.new do
+        def check_assignment(node, *__rest__)
+          return if rightward?(node)
+          super
+        end
+
+        private
+
+        def rightward?(node)
+          return unless POTENTIAL_RIGHT_TYPES.include?(node.type)
+
+          return unless node.loc.operator
+
+          assignee_loc =
+            if node.type == :masgn
+              node.children[0].loc.expression
+            else
+              node.loc.name
+            end
+
+          return false unless assignee_loc
+
+          assignee_loc.begin_pos > node.loc.operator.end_pos
+        end
+      end)
+
+      require "rubocop/cop/layout/empty_line_between_defs"
+      EmptyLineBetweenDefs.prepend(Module.new do
+        def def_end(node)
+          return super unless node.loc.end.nil?
+
+          node.loc.expression.line
+        end
+      end)
+
+      require "rubocop/cop/layout/space_after_colon"
+      SpaceAfterColon.prepend(Module.new do
+        def on_pair(node)
+          return if node.children[0].loc.last_column == node.children[1].loc.last_column
+
+          super(node)
+        end
+      end)
+    end
+
+    module Style
+      require "rubocop/cop/style/single_line_methods"
+      SingleLineMethods.prepend(Module.new do
+        def on_def(node)
+          return if node.loc.end.nil?
+          super
+        end
+
+        def on_defs(node)
+          return if node.loc.end.nil?
+          super
+        end
+      end)
+
+      require "rubocop/cop/style/def_with_parentheses"
+      DefWithParentheses.prepend(Module.new do
+        def on_def(node)
+          return if node.loc.end.nil?
+          super
+        end
+
+        def on_defs(node)
+          return if node.loc.end.nil?
+          super
+        end
+      end)
+
+      require "rubocop/cop/style/trailing_method_end_statement"
+      TrailingMethodEndStatement.prepend(Module.new do
+        def on_def(node)
+          return if node.loc.end.nil?
+          super
+        end
+      end)
+    end
+  end
+end

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

@@ -10,9 +10,45 @@ 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,18 +57,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]"
@@ -49,11 +91,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
 
@@ -76,6 +124,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
@@ -90,9 +142,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
@@ -119,6 +176,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")]
@@ -132,6 +194,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
@@ -157,12 +221,20 @@ module RubyNext
       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
@@ -179,6 +251,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?
 
@@ -195,12 +275,14 @@ module RubyNext
 
         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?

data/lib/ruby-next/config.rb

@@ -10,16 +10,18 @@ module RubyNext
   # 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 => 1
+    3 => 4
   }.freeze
 
-  LATEST_VERSION = [3, 1].freeze
+  LATEST_VERSION = [3, 4].freeze
 
   # A virtual version number used for proposed features
   NEXT_VERSION = "1995.next.0"
 
   class << self
     # TruffleRuby claims its RUBY_VERSION to be X.Y while not supporting all the features
+    # Currently (23.0.1), it still doesn't support pattern matching, although claims to be "like 3.1".
+    # So, we fallback to 2.6.5 (since we cannot use 2.7).
     if defined?(TruffleRuby)
       def current_ruby_version
         "2.6.5"
@@ -30,6 +32,15 @@ module RubyNext
       end
     end
 
+    # Returns true if we want to use edge syntax
+    def edge_syntax?
+      %w[y true 1].include?(ENV["RUBY_NEXT_EDGE"])
+    end
+
+    def proposed_syntax?
+      %w[y true 1].include?(ENV["RUBY_NEXT_PROPOSED"])
+    end
+
     def next_ruby_version(version = current_ruby_version)
       return if version == Gem::Version.new(NEXT_VERSION)
 
@@ -46,5 +57,21 @@ module RubyNext
 
       Gem::Version.new(nxt)
     end
+
+    # Load transpile settings from the RC file (nextify command flags)
+    def load_from_rc(path = ".rbnextrc")
+      return unless File.exist?(path)
+
+      require "yaml"
+
+      args = YAML.load_file(path)&.fetch("nextify", "")&.lines&.flat_map { |line| line.chomp.split(/\s+/) }
+
+      ENV["RUBY_NEXT_EDGE"] ||= "true" if args.delete("--edge")
+      ENV["RUBY_NEXT_PROPOSED"] ||= "true" if args.delete("--proposed")
+      ENV["RUBY_NEXT_TRANSPILE_MODE"] ||= "rewrite" if args.delete("--transpile-mode=rewrite")
+      ENV["RUBY_NEXT_TRANSPILE_MODE"] ||= "ast" if args.delete("--transpile-mode=ast")
+    end
   end
+
+  load_from_rc
 end

data/lib/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}" }.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}" }.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/ruby-next/core/matchdata/deconstruct.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+RubyNext::Core.patch MatchData, method: :deconstruct, version: "3.2" do
+  <<-'RUBY'
+def deconstruct
+  captures.map(&:to_str)
+end
+  RUBY
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+RubyNext::Core.patch MatchData, method: :deconstruct_keys, version: "3.2" do
+  <<-'RUBY'
+def deconstruct_keys(keys)
+  raise TypeError, "wrong argument type #{keys.class} (expected Array)" if keys && !keys.is_a?(Array)
+
+  captured = named_captures.transform_keys!(&:to_sym)
+  return captured if keys.nil?
+
+  return {} if keys.size > captured.size
+
+  keys.each_with_object({}) do |k, acc|
+    raise TypeError, "wrong argument type #{k.class} (expected Symbol)" unless Symbol === k
+    return acc unless captured.key?(k)
+    acc[k] = self[k]
+  end
+end
+  RUBY
+end

data/lib/ruby-next/core/matchdata/named_captures.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+RubyNext::Core.patch MatchData, method: :named_captures, version: "3.3", supported: "a".match(/a/).method(:named_captures).arity != 0, core_ext: :prepend do
+  <<-'RUBY'
+def named_captures(symbolize_names: false)
+  return super() unless symbolize_names
+
+  super().transform_keys!(&:to_sym)
+end
+  RUBY
+end