ruby-next-core 0.13.3 → 0.15.0

data/lib/ruby-next/language/rewriters/3.1/anonymous_block.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module Rewriters
+      class AnonymousBlock < Base
+        NAME = "anonymous-block"
+        SYNTAX_PROBE = "obj = Object.new; def obj.foo(&) bar(&); end"
+        MIN_SUPPORTED_VERSION = Gem::Version.new("3.1.0")
+
+        BLOCK = :__block__
+
+        def on_args(node)
+          block = node.children.last
+
+          return super unless block&.type == :blockarg
+          return super unless block.children.first.nil?
+
+          context.track! self
+
+          replace(block.loc.expression, "&#{BLOCK}")
+
+          node.updated(
+            :args,
+            [
+              *node.children.slice(0, node.children.index(block)),
+              s(:blockarg, BLOCK)
+            ]
+          )
+        end
+
+        def on_send(node)
+          block = extract_block_pass(node)
+          return super unless block&.children == [nil]
+
+          process_block(node, block)
+        end
+
+        def on_super(node)
+          block = extract_block_pass(node)
+          return super unless block&.children == [nil]
+
+          process_block(node, block)
+        end
+
+        private
+
+        def extract_block_pass(node)
+          node.children.find { |child| child.is_a?(::Parser::AST::Node) && child.type == :block_pass }
+        end
+
+        def process_block(node, block)
+          replace(block.loc.expression, "&#{BLOCK}")
+
+          process(
+            node.updated(
+              nil,
+              [
+                *node.children.take(node.children.index(block)),
+                s(:block_pass, s(:lvar, BLOCK))
+              ]
+            )
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ruby-next/language/rewriters/3.1/endless_method_command.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module Rewriters
+      class EndlessMethodCommand < EndlessMethod
+        NAME = "endless-method-command"
+        SYNTAX_PROBE = "obj = Object.new; def obj.foo = puts 'Hello'"
+        MIN_SUPPORTED_VERSION = Gem::Version.new("3.1.0")
+
+        def process_def(node)
+          return node unless command?(node)
+
+          super(node)
+        end
+
+        def process_defs(node)
+          return node unless command?(node)
+
+          super(node)
+        end
+
+        private
+
+        def command?(node)
+          buffer = ::Parser::Source::Buffer.new("(endless-method-rewriter)").tap do |buffer|
+            buffer.source = node.loc.expression.source
+          end
+
+          parser30.parse(buffer)
+          false
+        rescue ::Parser::SyntaxError
+          true
+        end
+
+        def parser30
+          require "parser/ruby30" unless defined?(::Parser::Ruby30)
+
+          ::Parser::Ruby30.new(Language::Builder.new).tap do |prs|
+            prs.diagnostics.all_errors_are_fatal = true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby-next/language/rewriters/3.1/oneline_pattern_parensless.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module Rewriters
+      using RubyNext
+
+      # Allow omitting parentheses around patterns in `=>` and `in`
+      class OnelinePatternParensless < Base
+        NAME = "pattern-matching-oneline-parensless"
+        SYNTAX_PROBE = "[1, 2] => a, b"
+        MIN_SUPPORTED_VERSION = Gem::Version.new("3.1.0")
+
+        def on_match_pattern(node)
+          _, pattern = *node.children
+
+          # When no parens, children boundaries are the same as the whole pattern
+          if (
+            pattern.type == :array_pattern ||
+            pattern.type == :hash_pattern
+          ) &&
+              pattern.children.any? &&
+              pattern.loc.column == pattern.children.first.loc.column &&
+              pattern.loc.last_column == pattern.children.last.loc.last_column
+
+            context.track! self
+
+            left_p, right_p = pattern.type == :array_pattern ? %w([ ]) : %w[{ }]
+
+            insert_before(pattern.loc.expression, left_p)
+            insert_after(pattern.loc.expression, right_p)
+          else
+            super(node)
+          end
+        end
+
+        alias on_match_pattern_p on_match_pattern
+      end
+    end
+  end
+end

data/lib/ruby-next/language/rewriters/3.1/pin_vars_pattern.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module Rewriters
+      using RubyNext
+
+      # Separate pattern matching rewriter for Ruby 2.7 and 3.0 to
+      # transpile only ^(ivar|cvar|gvar)
+      class PinVarsPattern < PatternMatching
+        NAME = "pattern-matching-pin-vars"
+        SYNTAX_PROBE = "@a = 0; case 0; in ^@a; true; end"
+        MIN_SUPPORTED_VERSION = Gem::Version.new("3.1.0")
+
+        def on_case_match(node)
+          @has_pin_vars = false
+          process_regular_node(node).then do |new_node|
+            return new_node unless has_pin_vars
+            super(node)
+          end
+        end
+
+        def on_match_pattern(node)
+          @has_pin_vars = false
+          process_regular_node(node).then do |new_node|
+            return new_node unless has_pin_vars
+            super(node)
+          end
+        end
+
+        def on_match_pattern_p(node)
+          @has_pin_vars = false
+          process_regular_node(node).then do |new_node|
+            return new_node unless has_pin_vars
+            super(node)
+          end
+        end
+
+        def on_pin(node)
+          @has_pin_vars = node.children.first.type != :lvar
+          super(node)
+        end
+
+        private
+
+        attr_reader :has_pin_vars
+      end
+    end
+  end
+end

data/lib/ruby-next/language/rewriters/3.1/refinement_import_methods.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# Add binding argument to all self-less eval's
+module RubyNext
+  module Language
+    module Rewriters
+      class RefinementImportMethods < Language::Rewriters::Base
+        NAME = "refinement-import-methods"
+        SYNTAX_PROBE = "a = Module.new{}; Module.new do; refine String do; import_methods a end; end"
+        MIN_SUPPORTED_VERSION = Gem::Version.new("3.1.0")
+
+        def on_block(node)
+          sender, args, body = *node
+          receiver, mid, * = *sender
+
+          return super unless mid == :refine && receiver.nil?
+
+          return super unless body
+
+          @within_refinement = true
+
+          node.updated(
+            nil,
+            [
+              sender,
+              args,
+              process(body)
+            ]
+          ).tap do
+            @within_refinement = false
+          end
+        end
+
+        def on_send(node)
+          return super unless @within_refinement
+
+          _receiver, mid, *children = *node
+
+          return super unless mid == :import_methods
+
+          context.track! self
+
+          updated = node.updated(
+            nil,
+            [
+              s(:const, s(:const, s(:cbase), :RubyNext), :Core),
+              mid,
+              *children,
+              s(:send, nil, :binding)
+            ]
+          )
+
+          replace(node.loc.expression, updated)
+
+          updated
+        end
+      end
+    end
+  end
+end

data/lib/ruby-next/language/rewriters/{shorthand_hash.rb → 3.1/shorthand_hash.rb}

@@ -5,13 +5,15 @@ module RubyNext
     module Rewriters
       class ShorthandHash < Base
         NAME = "shorthand-hash"
-        SYNTAX_PROBE = "data = {x}"
-        MIN_SUPPORTED_VERSION = Gem::Version.new(RubyNext::NEXT_VERSION)
+        SYNTAX_PROBE = "data = {x:}"
+        MIN_SUPPORTED_VERSION = Gem::Version.new("3.1.0")
+
+        def on_pair(node)
+          return super(node) unless node.children[0].loc.last_column == node.children[1].loc.last_column
 
-        def on_ipair(node)
           context.track! self
 
-          ident, = *node.children
+          _, ident, = *node.children
 
           key = key_from_ident(ident)
 

data/lib/ruby-next/language/rewriters/base.rb

@@ -15,6 +15,18 @@ module RubyNext
 
       class Base < ::Parser::TreeRewriter
         class LocalsTracker
+          using(Module.new do
+            refine ::Parser::AST::Node do
+              def to_index
+                children&.first || type
+              end
+            end
+
+            refine ::Object do
+              alias to_index itself
+            end
+          end)
+
           attr_reader :stacks
 
           def initialize
@@ -29,7 +41,7 @@ module RubyNext
           def [](name, suffix = nil)
             fetch(name).then do |name|
               next name unless suffix
-              :"#{name}#{suffix}__"
+              :"#{name}#{suffix.to_index}__"
             end
           end
 
@@ -54,7 +66,7 @@ module RubyNext
         end
 
         class << self
-          # Returns true if the syntax is supported
+          # Returns true if the syntax is not supported
           # by the current Ruby (performs syntax check, not version check)
           def unsupported_syntax?
             save_verbose, $VERBOSE = $VERBOSE, nil

data/lib/ruby-next/language/rewriters/proposed/bind_vars_pattern.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module Rewriters
+      using RubyNext
+
+      # Separate pattern matching rewriter for Ruby <3.2 to
+      # transpile patterns with variable (instance, class, global) binding
+      class BindVarsPattern < PatternMatching
+        NAME = "pattern-matching-find-pattern"
+        SYNTAX_PROBE = "case 0; in @a; true; else; 1; end"
+        MIN_SUPPORTED_VERSION = Gem::Version.new(RubyNext::NEXT_VERSION)
+
+        def on_case_match(node)
+          @has_vars_pattern = false
+          process_regular_node(node).then do |new_node|
+            return new_node unless has_vars_pattern
+            super(node)
+          end
+        end
+
+        def on_match_pattern(node)
+          @has_vars_pattern = false
+          process_regular_node(node).then do |new_node|
+            return new_node unless has_vars_pattern
+            super(node)
+          end
+        end
+
+        def on_match_pattern_p(node)
+          @has_vars_pattern = false
+          process_regular_node(node).then do |new_node|
+            return new_node unless has_vars_pattern
+            super(node)
+          end
+        end
+
+        def on_match_var(node)
+          @has_vars_pattern = true if node.children[0].is_a?(::Parser::AST::Node)
+          super(node)
+        end
+
+        private
+
+        attr_reader :has_vars_pattern
+      end
+    end
+  end
+end

data/lib/ruby-next/language/rewriters/proposed.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# Load experimental, proposed etc. Ruby features
+
+require "ruby-next/language/rewriters/proposed/method_reference"
+RubyNext::Language.rewriters << RubyNext::Language::Rewriters::MethodReference
+
+require "ruby-next/language/rewriters/proposed/bind_vars_pattern"
+RubyNext::Language.rewriters << RubyNext::Language::Rewriters::BindVarsPattern

data/lib/ruby-next/language/rewriters/runtime.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
 # Load rewriters only required for runtime transpiling
-
-require "ruby-next/language/rewriters/runtime/dir"
+require "ruby-next/language/rewriters/2.4/dir"
 RubyNext::Language.rewriters << RubyNext::Language::Rewriters::Dir

data/lib/ruby-next/language/setup.rb

@@ -12,7 +12,7 @@ module RubyNext
         return if File.directory?(target_dir)
 
         Dir.chdir(root_dir) do
-          unless system("bundle exec ruby-next nextify ./#{lib_dir} -o #{target_dir} > /dev/null 2>&1")
+          unless system("bundle exec ruby-next nextify ./#{lib_dir} -o #{target_dir} --min-version=#{RUBY_VERSION} > /dev/null 2>&1")
             RubyNext.warn "Traspiled files are missing in: #{target_dir}. \n" \
               "Make sure you have gem 'ruby-next' in your Gemfile to auto-transpile the required files from source on load. " \
               "Otherwise the code from #{root_dir} may not work correctly."

data/lib/ruby-next/language.rb

@@ -174,54 +174,75 @@ module RubyNext
 
     require "ruby-next/language/rewriters/base"
 
-    require "ruby-next/language/rewriters/squiggly_heredoc"
+    require "ruby-next/language/rewriters/2.1/numeric_literals"
+    rewriters << Rewriters::NumericLiterals
+
+    require "ruby-next/language/rewriters/2.1/required_kwargs"
+    rewriters << Rewriters::RequiredKwargs
+
+    require "ruby-next/language/rewriters/2.3/squiggly_heredoc"
     rewriters << Rewriters::SquigglyHeredoc
 
-    require "ruby-next/language/rewriters/safe_navigation"
+    require "ruby-next/language/rewriters/2.3/safe_navigation"
     rewriters << Rewriters::SafeNavigation
 
-    require "ruby-next/language/rewriters/numeric_literals"
-    rewriters << Rewriters::NumericLiterals
-
-    require "ruby-next/language/rewriters/required_kwargs"
-    rewriters << Rewriters::RequiredKwargs
+    require "ruby-next/language/rewriters/2.5/rescue_within_block"
+    rewriters << Rewriters::RescueWithinBlock
 
-    require "ruby-next/language/rewriters/args_forward"
+    require "ruby-next/language/rewriters/2.7/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"
+    require "ruby-next/language/rewriters/2.7/numbered_params"
     rewriters << Rewriters::NumberedParams
 
-    require "ruby-next/language/rewriters/pattern_matching"
+    require "ruby-next/language/rewriters/2.7/pattern_matching"
     rewriters << Rewriters::PatternMatching
 
+    # Must be added after general args forward rewriter to become
+    # no-op in Ruby <2.7
+    require "ruby-next/language/rewriters/3.0/args_forward_leading"
+    rewriters << Rewriters::ArgsForwardLeading
+
     # Must be added after general pattern matching rewriter to become
     # no-op in Ruby <2.7
-    require "ruby-next/language/rewriters/find_pattern"
+    require "ruby-next/language/rewriters/3.0/find_pattern"
     rewriters << Rewriters::FindPattern
 
-    require "ruby-next/language/rewriters/in_pattern"
+    require "ruby-next/language/rewriters/3.0/in_pattern"
     rewriters << Rewriters::InPattern
 
+    require "ruby-next/language/rewriters/3.0/endless_method"
+    RubyNext::Language.rewriters << RubyNext::Language::Rewriters::EndlessMethod
+
+    require "ruby-next/language/rewriters/3.1/oneline_pattern_parensless"
+    rewriters << Rewriters::OnelinePatternParensless
+
+    require "ruby-next/language/rewriters/3.1/pin_vars_pattern"
+    rewriters << Rewriters::PinVarsPattern
+
+    require "ruby-next/language/rewriters/3.1/anonymous_block"
+    rewriters << Rewriters::AnonymousBlock
+
+    require "ruby-next/language/rewriters/3.1/refinement_import_methods"
+    rewriters << Rewriters::RefinementImportMethods
+
+    require "ruby-next/language/rewriters/3.1/endless_method_command"
+    rewriters << Rewriters::EndlessMethodCommand
+
+    require "ruby-next/language/rewriters/3.1/shorthand_hash"
+    rewriters << RubyNext::Language::Rewriters::ShorthandHash
+
     # Put endless range in the end, 'cause Parser fails to parse it in
     # pattern matching
-    require "ruby-next/language/rewriters/endless_range"
+    require "ruby-next/language/rewriters/2.6/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"
+      require "ruby-next/language/rewriters/edge"
     end
 
     if ENV["RUBY_NEXT_PROPOSED"] == "1"
-      require "ruby-next/language/proposed"
+      require "ruby-next/language/rewriters/proposed"
     end
   end
 end

data/lib/ruby-next/pry.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+# This file contains patches for Pry integration.
+# It's supposed to be required inside .pryrc files.
+
+require "ruby-next/language/setup"
+require "ruby-next/language/runtime"
+
+# Enables refinements by injecting "using RubyNext"
+# before Pry copies and memorizes the TOPLEVEL_BINDING.
+Pry.singleton_class.prepend(Module.new do
+  def toplevel_binding
+    unless defined?(@_using_injected) && @_using_injected
+      orig_binding = super
+
+      # Copy TOPLEVEL_BINDING without local variables.
+      TOPLEVEL_BINDING.eval <<-RUBY
+        using RubyNext
+
+        def self.__pry__
+          binding
+        end
+
+        Pry.toplevel_binding = __pry__
+
+        class << self; undef __pry__; end
+      RUBY
+
+      # Inject local variables from the original binding.
+      orig_binding.local_variables.each do |var|
+        value = orig_binding.local_variable_get(var)
+        @toplevel_binding.local_variable_set(var, value)
+      end
+
+      @_using_injected = true
+    end
+
+    super
+  end
+end)
+
+# Enables edge Ruby syntax by transpiling the code
+# before it's evaluated in the context of a binding.
+Pry.prepend(Module.new do
+  def current_binding
+    super.tap do |obj|
+      next if obj.respond_to?(:__nextified__)
+
+      obj.instance_eval do
+        def eval(code, *args)
+          new_code = ::RubyNext::Language::Runtime.transform(code, using: false)
+
+          super(new_code, *args)
+        end
+
+        def __nextified__
+        end
+      end
+    end
+  end
+end)
+
+# Enables edge Ruby syntax for multi-line input.
+Pry::Code.singleton_class.prepend(Module.new do
+  def complete_expression?(str)
+    silence_stderr do
+      ::Parser::RubyNext.parse(str)
+    end
+
+    true
+  rescue Parser::SyntaxError => ex
+    case ex.message
+    when /unexpected token \$end/
+      false
+    else
+      true
+    end
+  end
+
+  private
+
+  def silence_stderr
+    stderr = StringIO.new
+    orig_stderr, $stderr = $stderr, stderr
+
+    yield
+
+    $stderr = orig_stderr
+  end
+end)

data/lib/ruby-next/rubocop.rb

@@ -79,10 +79,6 @@ module RuboCop
         trigger_responding_cops(:on_meth_ref, node)
       end
 
-      def on_ipair(node)
-        trigger_responding_cops(:on_ipair, node)
-      end
-
       unless method_defined?(:on_numblock)
         def on_numblock(node)
           children = node.children
@@ -108,6 +104,21 @@ module RuboCop
       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"
 
@@ -147,6 +158,15 @@ module RuboCop
           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

data/lib/ruby-next/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyNext
-  VERSION = "0.13.3"
+  VERSION = "0.15.0"
 end

data/lib/uby-next/irb.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "ruby-next/irb"

data/lib/uby-next/pry.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "ruby-next/pry"