ruby-next-core 0.13.3 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c37d70af44462c4f2a42db64ca27a9b99fa08e9278d5e308dd3ba5fb67aa7b3
-  data.tar.gz: fb832052e7479e0c5719e57904b105f47721d1688e9ec47f4d58d7f75de9fffb
+  metadata.gz: 28083aad6fa1b32e00c885533e4c9c732a2401057f9ed6a939cd78ff3b1b58bb
+  data.tar.gz: 55734dd6e38699ff7e03c2723633ecd063f8fd97fe8878ca553772dbdac08ab3
 SHA512:
-  metadata.gz: dd6760a195e2ca5aa0b47295069526fbe67aa183e28dc36d6076aa3fc0d3b58411320d043f1c7f2a9c19803193b6b84ff4a640cfa0fe3e14d813032340fe0ad4
-  data.tar.gz: 6f2bf81c74312a1e1e3b68ac24df8ca2eb7ce679f8de9c8009c9550e880b0f8a0c18d7532f0570e003cd9511502af6607219f44e065be8d54d975a44e5dd12e5
+  metadata.gz: 7d42096d6a616470a402493894d5a7e65b7f08fd935dc8acfd0b91bf66016030edc93fd9c742aeed2fe8653dceb51c7b08c669e48ed1ff11373202cd738c9abc
+  data.tar.gz: a5740b48cb70283a3848d9415205baf7d17f4ee859562937b7f597bea0de43edba09f59bead4418284b395e6132cec92222b93cb1c1dc0c985adc3eda7b36986

data/CHANGELOG.md

@@ -2,6 +2,50 @@
 
 ## master
 
+## 0.15.0 (2022-03-21)
+
+- Support IRB ([@palkan][])
+
+- Create empty `.rbnext` folder during `nextify` if nothing to transpile. ([@palkan][])
+
+This would prevent from auto-transpiling a library every time when no files should be transpiled.
+
+- Auto-transpile using the current Ruby version. ([@palkan][])
+
+- Support Pry. ([@baygeldin][])
+
+- Add `rescue/ensure/else` within block rewriter for Ruby < 2.5. ([@fargelus][])
+
+## 0.14.1 (2022-01-21)
+
+- Fix nested find patterns transpiling. ([@palkan][])
+
+## 0.14.0 🎄
+
+- Add `Integer.try_convert`. ([@palkan][])
+
+- Add `Enumerable#compact`, `Enumerator::Lazy#compact`. ([@palkan][])
+
+- [Proposed] Add support for binding instance, class, global variables in pattern matching. ([@palkan][])
+
+This brings back rightward assignment: `42 => @v`.
+
+- Add `MatchData#match`. ([@palkan][])
+
+- Add support for command syntax in endless methods (`def foo() = puts "bar"`)
+
+- Add `Refinement#import_methods` support. ([@palkan][])
+
+This API only works in conjunction with transpiling, since it couldn't be backported purely as a method and requires passing an additional argument (Binding).
+
+You can find the details in [the PR](https://github.com/ruby-next/ruby-next/pull/85).
+
+- Added support for instance, class and global variables and expressions for pin operator. ([@palkan][])
+
+- Support omitting parentheses in one-line pattern matching. ([@palkan][])
+
+- Anonymous blocks `def b(&); c(&); end` ([@palkan][]).
+
 ## 0.13.3 (2021-12-08)
 
 - Revert 0.13.2 and freeze Parser version. ([@skryukov][])

data/README.md

@@ -71,8 +71,11 @@ _Please, submit a PR to add your project to the list!_
   - [`ruby -ruby-next`](#uby-next)
   - [Logging & Debugging](#logging-and-debugging)
 - [RuboCop](#rubocop)
+- [Using with IRB](#irb)
+- [Using with Pry](#pry)
 - [Using with EOL Rubies](#using-with-eol-rubies)
 - [Proposed & edge features](#proposed-and-edge-features)
+- [Known limitations](#known-limitations)
 
 ## Overview
 
@@ -200,8 +203,6 @@ You can change the transpiler mode:
 - Via environmental variable `RUBY_NEXT_TRANSPILE_MODE=ast`.
 - Via CLI option ([see below](#cli)).
 
-**NOTE:** For the time being, Unparser doesn't support Ruby 3.0 AST nodes, so we always use rewrite mode in Ruby 3.0+.
-
 ## CLI
 
 Ruby Next ships with the command-line interface (`ruby-next`) which provides the following functionality:
@@ -231,7 +232,7 @@ Usage: ruby-next nextify DIRECTORY_OR_FILE [options]
 
 The behaviour depends on whether you transpile a single file or a directory:
 
-- When transpiling a directory, the `.rbnext` subfolder is created within the target folder with subfolders for each supported Ruby versions (e.g., `.rbnext/2.6`, `.rbnext/2.7`, `.rbnext/3.0`). If you want to create only a single version (the smallest), you can also pass `--single-version` flag. In that case, no version directory is created (i.e., transpiled files go into `.rbnext`).
+- When transpiling a directory, the `.rbnext` subfolder is created within the target folder with subfolders for each supported Ruby versions (e.g., `.rbnext/2.6`, `.rbnext/2.7`, `.rbnext/3.0`, etc.). If you want to create only a single version (the smallest), you can also pass `--single-version` flag. In that case, no version directory is created (i.e., transpiled files go into `.rbnext`).
 
 - When transpiling a file and providing the output path as a _file_ path, only a single version is created. For example:
 
@@ -283,6 +284,8 @@ $ ruby-next core_ext -l --name=filter --name=deconstruct
   - EnumeratorLazyFilterMap
   - HashDeconstructKeys
   - StructDeconstruct
+
+...
 ```
 
 ### CLI configuration file
@@ -453,6 +456,38 @@ AllCops:
 
 **NOTE:** you need `ruby-next` gem available in the environment where you run RuboCop (having `ruby-next-core` is not enough).
 
+## IRB
+
+Ruby Next supports IRB. In order to enable edge Ruby features for your REPL, add the following line to your `.irbrc`:
+
+```ruby
+require "ruby-next/irb"
+```
+
+Alternatively, you can require it at startup:
+
+```sh
+irb -r ruby-next/irb
+# or
+irb -ruby-next/irb
+```
+
+## Pry
+
+Ruby Next supports Pry. In order to enable edge Ruby features for your REPL, add the following line to your `.pryrc`:
+
+```ruby
+require "ruby-next/pry"
+```
+
+Alternatively, you can require it at startup:
+
+```sh
+pry -r ruby-next/pry
+# or
+pry -ruby-next/pry
+```
+
 ## Using with EOL Rubies
 
 We currently provide support for Ruby 2.2, 2.3 and 2.4.
@@ -522,13 +557,38 @@ require "ruby-next/language/runtime"
 
 ### Supported edge features
 
-`Array#intersect?` ([#15198](https://bugs.ruby-lang.org/issues/15198))
+It's too early, Ruby 3.1 has just been released. See its features in the [supported features list](./SUPPORTED_FEATURES.md).
 
 ### Supported proposed features
 
 - _Method reference_ operator (`.:`) ([#13581](https://bugs.ruby-lang.org/issues/13581)).
+- Binding non-local variables in pattern matching (`42 => @v`) ([#18408](https://bugs.ruby-lang.org/issues/18408)).
+
+## Known limitations
+
+Ruby Next aims to be _reasonably compatible_ with MRI. That means, some edge cases could be uncovered. Below is the list of known limitations.
+
+For gem authors, we recommend testing against all supported versions on CI to make sure you're not hit by edge cases.
+
+### Enumerable methods
+
+Using refinements (`using RubyNext`) for modules could lead to unexpected behaviour in case there is also a `prepend` for the same module in Ruby <2.7.
+To eliminate this, we also refine Array (when appropriate), but other enumerables could be affected.
+
+See [this issue](https://bugs.ruby-lang.org/issues/13446) for details.
+
+### `Refinement#import_methods`
+
+- Doesn't support importing methods generated with `eval`.
+- Doesn't support aliases (both `alias` and `alias_method`).
+- In JRuby, importing attribute accessors/readers/writers is not supported.
+- When using AST transpiling in runtime, likely fails to import methods from a transpiled files (due to the updated source location).
+
+See the [original PR](https://github.com/ruby-next/ruby-next/pull/85) for more details.
+
+### Other
 
-- Shorthand Hash/kwarg notation (`data = {x, y}` or `foo(x:, y:)`) ([#15236](https://bugs.ruby-lang.org/issues/15236)).
+See [Parser's known issues](https://github.com/whitequark/parser#known-issues).
 
 ## Contributing
 

data/bin/transform

@@ -34,9 +34,13 @@ OptionParser.new do |opts|
     transform_opts[:rewriters] = RubyNext::Language.current_rewriters
   end
 
-  opts.on("--rewrite", "User rewrite transpiling mode") do
+  opts.on("--rewrite", "Use rewrite transpiling mode") do
     RubyNext::Language.mode = :rewrite
   end
+
+  opts.on("--ast", "Use AST transpiling mode") do
+    RubyNext::Language.mode = :ast
+  end
 end.parse!
 
 puts RubyNext::Language.transform(contents, **transform_opts)

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

@@ -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/, "")
+        "#{mod_name}#{camelized_method_name}".gsub(/\W/, "") # rubocop:disable Performance/StringReplacement
       end
 
       def build_location(trace_locations)
@@ -173,6 +173,8 @@ require "ruby-next/core/unboundmethod/bind_call"
 require "ruby-next/core/time/floor"
 require "ruby-next/core/time/ceil"
 
+require "ruby-next/core/refinement/import"
+
 # Core extensions required for pattern matching
 # Required for pattern matching with refinements
 unless defined?(NoMatchingPatternError)
@@ -191,6 +193,10 @@ require "ruby-next/core/hash/except"
 
 require "ruby-next/core/array/intersect"
 
+require "ruby-next/core/matchdata/match"
+require "ruby-next/core/enumerable/compact"
+require "ruby-next/core/integer/try_convert"
+
 # Generate refinements
 RubyNext.module_eval do
   RubyNext::Core.patches.refined.each do |mod, patches|

data/lib/.rbnext/2.1/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/.rbnext/2.3/ruby-next/commands/nextify.rb

@@ -24,6 +24,8 @@ module RubyNext
           contents = File.read(path)
           transpile path, contents
         end
+
+        ensure_rbnext!
       end
 
       def parse!(args)
@@ -48,11 +50,11 @@ module RubyNext
           end
 
           opts.on("--edge", "Enable edge (master) Ruby features") do |val|
-            require "ruby-next/language/edge"
+            require "ruby-next/language/rewriters/edge"
           end
 
           opts.on("--proposed", "Enable proposed/experimental Ruby features") do |val|
-            require "ruby-next/language/proposed"
+            require "ruby-next/language/rewriters/proposed"
           end
 
           opts.on(
@@ -185,6 +187,17 @@ 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")
+
+        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

data/lib/.rbnext/2.3/ruby-next/language/eval.rb

@@ -37,6 +37,7 @@ module RubyNext
 
           source = args.shift
           new_source = ::RubyNext::Language::Runtime.transform(source, using: false)
+
           RubyNext.debug_source(new_source, "(#{caller_locations(1, 1).first})")
           super new_source, *args
         end

data/lib/.rbnext/2.3/ruby-next/language/rewriters/{pattern_matching.rb → 2.7/pattern_matching.rb}

@@ -243,6 +243,7 @@ module RubyNext
 
           @deconstructed_keys = {}
           @predicates = Predicates::CaseIn.new
+          @lvars = []
 
           matchee_ast =
             s(:begin, s(:lvasgn, MATCHEE, node.children[0]))
@@ -272,6 +273,7 @@ module RubyNext
 
           @deconstructed_keys = {}
           @predicates = Predicates::Noop.new
+          @lvars = []
 
           matchee =
             s(:begin, s(:lvasgn, MATCHEE, node.children[0]))
@@ -282,10 +284,12 @@ module RubyNext
               arr: MATCHEE_ARR,
               hash: MATCHEE_HASH
             ) do
-              send(
-                :"#{node.children[1].type}_clause",
-                node.children[1]
-              ).then do |node|
+              with_declared_locals do
+                send(
+                  :"#{node.children[1].type}_clause",
+                  node.children[1]
+                )
+              end.then do |node|
                 s(:begin,
                   s(:or,
                     node,
@@ -306,6 +310,41 @@ module RubyNext
 
         alias on_in_match on_match_pattern
 
+        def on_match_pattern_p(node)
+          context.track! self
+
+          @deconstructed_keys = {}
+          @predicates = Predicates::Noop.new
+          @lvars = []
+
+          matchee =
+            s(:begin, s(:lvasgn, MATCHEE, node.children[0]))
+
+          pattern =
+            locals.with(
+              matchee: MATCHEE,
+              arr: MATCHEE_ARR,
+              hash: MATCHEE_HASH
+            ) do
+              with_declared_locals do
+                send(
+                  :"#{node.children[1].type}_clause",
+                  node.children[1]
+                )
+              end
+            end
+
+          node.updated(
+            :and,
+            [
+              matchee,
+              pattern
+            ]
+          ).tap do |new_node|
+            replace(node.loc.expression, inline_blocks(unparse(new_node)))
+          end
+        end
+
         private
 
         def rewrite_case_in!(node, matchee, new_node)
@@ -363,13 +402,15 @@ module RubyNext
         def build_when_clause(clause)
           predicates.reset!
           [
-            with_guard(
-              send(
-                :"#{clause.children[0].type}_clause",
-                clause.children[0]
-              ),
-              clause.children[1] # guard
-            ),
+            with_declared_locals do
+              with_guard(
+                send(
+                  :"#{clause.children[0].type}_clause",
+                  clause.children[0]
+                ),
+                clause.children[1] # guard
+              )
+            end,
             process(clause.children[2] || s(:nil)) # expression
           ].then do |children|
             s(:when, *children)
@@ -407,13 +448,14 @@ module RubyNext
         end
 
         def match_var_clause(node, left = s(:lvar, locals[:matchee]))
-          return s(:true) if node.children[0] == :_
+          var = node.children[0]
+          return s(:true) if var == :_
 
-          check_match_var_alternation! node.children[0]
+          check_match_var_alternation!(var)
 
           s(:begin,
             s(:or,
-              s(:begin, s(:lvasgn, node.children[0], left)),
+              s(:begin, build_var_assignment(var, left)),
               s(:true)))
         end
 
@@ -508,11 +550,10 @@ module RubyNext
         def array_find(head, *nodes, tail)
           index = s(:lvar, :__i__)
 
-          match_vars = []
-
           head_match =
             unless head.children.empty?
-              match_vars << s(:lvasgn, head.children[0].children[0])
+              # we only need to call this to track the lvar usage
+              build_var_assignment(head.children[0].children[0])
 
               arr_take = s(:send,
                 s(:lvar, locals[:arr]),
@@ -524,16 +565,19 @@ module RubyNext
 
           tail_match =
             unless tail.children.empty?
-              match_vars << s(:lvasgn, tail.children[0].children[0])
+              # we only need to call this to track the lvar usage
+              build_var_assignment(tail.children[0].children[0])
 
               match_var_clause(tail.children[0], arr_slice(index + nodes.size, -1))
             end
 
           nodes.each do |node|
             if node.type == :match_var
-              match_vars << s(:lvasgn, node.children[0])
+              # we only need to call this to track the lvar usage
+              build_var_assignment(node.children[0])
             elsif node.type == :match_as
-              match_vars << s(:lvasgn, node.children[1].children[0])
+              # we only need to call this to track the lvar usage
+              build_var_assignment(node.children[1].children[0])
             end
           end
 
@@ -561,19 +605,7 @@ module RubyNext
             s(:args,
               s(:arg, :_),
               s(:arg, :__i__)),
-            pattern).then do |block|
-            next block if match_vars.empty?
-
-            # We need to declare match vars outside of `find` block
-            locals_declare = s(:begin, s(:masgn,
-              s(:mlhs, *match_vars),
-              s(:nil)))
-
-            s(:begin,
-              s(:or,
-                locals_declare,
-                block))
-          end
+            pattern)
         end
 
         def array_match_rest(index, node, *tail)
@@ -616,6 +648,14 @@ module RubyNext
           end
         end
 
+        def find_pattern_array_element(node, index)
+          element = arr_item_at(index)
+          locals.with(arr: locals[:arr, index]) do
+            predicates.push :"i#{index}"
+            find_pattern_clause(node, element).tap { predicates.pop }
+          end
+        end
+
         def hash_pattern_array_element(node, index)
           element = arr_item_at(index)
           locals.with(hash: locals[:arr, index]) do
@@ -796,6 +836,15 @@ module RubyNext
           end
         end
 
+        def find_pattern_hash_element(node, key)
+          element = hash_value_at(key)
+          key_index = deconstructed_key(key)
+          locals.with(arr: locals[:hash, key_index]) do
+            predicates.push :"k#{key_index}"
+            find_pattern_clause(node, element).tap { predicates.pop }
+          end
+        end
+
         def hash_element(head, *tail)
           send("#{head.type}_hash_element", head).then do |node|
             next node if tail.empty?
@@ -861,6 +910,10 @@ module RubyNext
           match_var_clause(child, s(:lvar, locals[:hash]))
         end
 
+        def pin_hash_element(node, index)
+          case_eq_hash_element node.children[0], index
+        end
+
         def case_eq_hash_element(node, key)
           case_eq_clause node, hash_value_at(key)
         end
@@ -911,6 +964,24 @@ module RubyNext
           end
         end
 
+        def with_declared_locals
+          lvars.clear
+          node = yield
+
+          return node if lvars.empty?
+
+          # We need to declare match lvars outside of the outer `find` block,
+          # so we do that for that whole pattern
+          locals_declare = s(:begin, s(:masgn,
+            s(:mlhs, *lvars.uniq.map { |_1| s(:lvasgn, _1) }),
+            s(:nil)))
+
+          s(:begin,
+            s(:or,
+              locals_declare,
+              node))
+        end
+
         def no_matching_pattern
           raise_error(
             :NoMatchingPatternError,
@@ -945,13 +1016,17 @@ module RubyNext
 
         private
 
-        attr_reader :deconstructed_keys, :predicates
+        attr_reader :deconstructed_keys, :predicates, :lvars
 
         # Raise SyntaxError if match-var is used within alternation
         # https://github.com/ruby/ruby/blob/672213ef1ca2b71312084057e27580b340438796/compile.c#L5900
         def check_match_var_alternation!(name)
           return unless locals.key?(ALTERNATION_MARKER)
 
+          if name.is_a?(::Parser::AST::Node)
+            raise ::SyntaxError, "illegal variable in alternative pattern (#{name.children.first})"
+          end
+
           return if name.start_with?("_")
 
           raise ::SyntaxError, "illegal variable in alternative pattern (#{name})"
@@ -968,6 +1043,18 @@ module RubyNext
         def inline_blocks(source)
           source.gsub(/(?:do|{) \|_, __i__\|\n\s*([^\n]+)\n\s*(?:end|})/, '{ |_, __i__| \1 }')
         end
+
+        # Value could be omitted for mass assignment
+        def build_var_assignment(var, value = nil)
+          unless var.is_a?(::Parser::AST::Node)
+            lvars << var
+            return s(:lvasgn, *[var, value].compact)
+          end
+
+          asign_type = :"#{var.type.to_s[0]}vasgn"
+
+          s(asign_type, *[var.children[0], value].compact)
+        end
       end
     end
   end