ruby-next-core 0.9.1 → 0.10.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5689b631e2b8dd6e9222a60b25434fcb323d008458342c395ff891015d9f651d
-  data.tar.gz: 6178612f34fbbe59ea3f3042fc62ea23cc3bede62a944e187791a7304164d819
+  metadata.gz: 06e8a3264f44b75ea1c9c15b86857a99b20e537e34c1345a3cdb585ecc9ff815
+  data.tar.gz: 4a9fac897b70b243b4f465e3cb4b4d7f7e6838f9d119cb44befbac809ae57f66
 SHA512:
-  metadata.gz: f24eef8dc28b0ad4e8f9d5073d1254f31111354291b9bfb60cb8c688fbf312f153ba8fe17886183798b9413280bac554f9012e2ec2b63d250f0bf3c34a3362eb
-  data.tar.gz: d9ab4a36680864b81cd545d438e001a51e4c6dfbca56336a971b557af50786b70c7b7f9eee37698fc0373480e56f51c153080b9e06ec218dc8d08e0da2dc79d6
+  metadata.gz: 383cfb7155da80a785f52996d470ed20e47f5e936973eddab95487fa1be952d829ccefc7605fd2e90967ab0bece5e8da678b6ba11be62534377762de9a247cc7
+  data.tar.gz: 05e872e67ec2a44076ab20cc7ca3592e010e5bb0ec0fb8249e1b6cfb46119049ad376ba7fb189c21a531b02ef12b98f9fc70f8c4467df9451e8c05f8cda80dc0

data/CHANGELOG.md

@@ -2,6 +2,47 @@
 
 ## master
 
+## 0.10.3 (2020-09-28)
+
+- Update RuboCop integration to handle the latest Parser changes. ([@palkan][])
+
+Parser 2.7.1.5 unified endless and normal methods and rightward and leftward assignments, thus, making some cops report false negatives.
+
+## 0.10.2 (2020-09-09)
+
+- Fix regression when `nextify` produces incorrect files for 2.7. ([@palkan][])
+
+## ~~0.10.1~~
+
+## 0.10.0 (2020-09-02)
+
+- Add proposed shorthand Hash syntax. ([@palkan][])
+
+You can try it: `x = 1; y = 2; data = {x, y}`.
+
+- Add leading argument support to args forwarding. ([@palkan][])
+
+`def a(...) b(1, ...); end`.
+
+- Add `Hash#except`. ([@palkan][])
+
+`{a: 1, b: 2}.except(:a) == {b: 2}`
+
+- Add find pattern support. ([@palkan][])
+
+Now you can do: `[0, 1, 2] in [*, 1 => a, *c]`.
+
+- Add Ruby 2.2 support. ([@palkan][])
+
+With support for safe navigation operator (`&.`) and squiggly heredocs (`<<~TXT`).
+
+## 0.9.2 (2020-06-24)
+
+- Support passing rewriters to CLI. ([@sl4vr][])
+
+Use `nextify --list-rewriters` to view all available rewriters.
+Use `nextify` with `--rewrite=REWRITERS...` option to specify which particular rewriters to use.
+
 ## 0.9.1 (2020-06-05)
 
 - Keep `ruby-next` version in sync with `ruby-next-core`. ([@palkan][])
@@ -195,3 +236,4 @@ p a #=> 1
 
 [@palkan]: https://github.com/palkan
 [backports]: https://github.com/marcandre/backports
+[@sl4vr]: https://github.com/sl4vr

data/README.md

@@ -1,3 +1,4 @@
+[![Cult Of Martians](http://cultofmartians.com/assets/badges/badge.svg)](https://cultofmartians.com/tasks/ruby-next-cli-rewriters.html#task)
 [![Gem Version](https://badge.fury.io/rb/ruby-next.svg)](https://rubygems.org/gems/ruby-next) [![Build](https://github.com/ruby-next/ruby-next/workflows/Build/badge.svg)](https://github.com/ruby-next/ruby-next/actions)
 [![JRuby Build](https://github.com/ruby-next/ruby-next/workflows/JRuby%20Build/badge.svg)](https://github.com/ruby-next/ruby-next/actions?query=workflow%3A%22TruffleRuby+Build%22)
 [![TruffleRuby Build](https://github.com/ruby-next/ruby-next/workflows/TruffleRuby%20Build/badge.svg)](https://github.com/ruby-next/ruby-next/actions?query=workflow%3A%22TruffleRuby+Build%22)
@@ -36,6 +37,8 @@ Read more about the motivation behind the Ruby Next in this post: [Ruby Next: Ma
 - Ruby gems
   - [anyway_config](https://github.com/palkan/anyway_config)
   - [graphql-fragment_cache](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache)
+- Rails applications
+  - [anycable_rails_demo](https://github.com/anycable/anycable_rails_demo)
 - mruby
   - [ACLI](https://github.com/palkan/acli)
 
@@ -67,7 +70,7 @@ Core provides **polyfills** for Ruby core classes APIs via Refinements (default
 Language is responsible for **transpiling** edge Ruby syntax into older versions. It could be done
 programmatically or via CLI. It also could be done in runtime.
 
-Currently, Ruby Next supports Ruby versions 2.3+, including JRuby 9.2.8+ and TruffleRuby 20.1+ (with some limitations). Support for EOL versions (<2.5) slightly differs though ([see below](#using-with-eol-rubies)).
+Currently, Ruby Next supports Ruby versions 2.2+, including JRuby 9.2.8+ and TruffleRuby 20.1+ (with some limitations). Support for EOL versions (<2.5) slightly differs though ([see below](#using-with-eol-rubies)).
 
 Please, [open an issue](https://github.com/ruby-next/ruby-next/issues/new/choose) or join the discussion in the existing ones if you would like us to support older Ruby versions.
 
@@ -138,7 +141,7 @@ The following _rule of thumb_ is recommended when choosing between refinements a
 - Using core extensions could be considered for application development (no need to think about `using RubyNext`); this approach could potentially lead to conflicts with dependencies (if these dependencies are not using refinements 🙂)
 - Use core extensions if refinements are not supported by your platform
 
-**NOTE:** TruffleRuby doesn't fully support refinements (refining modules is not supported as of v20.1.0).
+**NOTE:** _Edge_ APIs (i.e., from the Ruby's master branch) are included by default.
 
 [**The list of supported APIs.**][features_core]
 
@@ -200,12 +203,15 @@ It has the following interface:
 ```sh
 $ ruby-next nextify
 Usage: ruby-next nextify DIRECTORY_OR_FILE [options]
-    -o, --output=OUTPUT              Specify output directory or file or stdout (use -o stdout for that)
+    -o, --output=OUTPUT              Specify output directory or file or stdout
         --min-version=VERSION        Specify the minimum Ruby version to support
         --single-version             Only create one version of a file (for the earliest Ruby version)
-        --enable-method-reference    Enable reverted method reference syntax (requires custom parser)
+        --edge                       Enable edge (master) Ruby features
+        --proposed                   Enable proposed/experimental Ruby features
         --transpile-mode=MODE        Transpiler mode (ast or rewrite). Default: ast
         --[no-]refine                Do not inject `using RubyNext`
+        --list-rewriters             List available rewriters
+        --rewrite=REWRITERS...       Specify particular Ruby features to rewrite
     -h, --help                       Print help
     -V                               Turn on verbose mode
         --dry-run                    Print verbose output without generating files
@@ -423,6 +429,8 @@ You must set `TargetRubyVersion: next` to make RuboCop use a Ruby Next parser.
 
 Alternatively, you can load the patch from the command line by running: `rubocop -r ruby-next/rubocop ...`.
 
+We recommend using the latest RuboCop version, 'cause it has support for new nodes built-in.
+
 Also, when pre-transpiling source code with `ruby-next nextify`, we suggest ignoring the transpiled files:
 
 ```yml
@@ -435,7 +443,7 @@ AllCops:
 
 ## Using with EOL Rubies
 
-We currently provide support for Ruby 2.3 and 2.4. Work on 2.2 is in progress.
+We currently provide support for Ruby 2.2, 2.3 and 2.4.
 
 Ruby Next itself relies on 2.5 features and contains polyfills only for version 2.5+ (and that won't change).
 Thus, to make it work with <2.5 we need to backport some APIs ourselves.
@@ -465,6 +473,8 @@ RUBY_NEXT_CORE_STRATEGY=backports ruby-next nextify lib/
 
 **NOTE:** Make sure you have `backports` gem installed globally or added to your bundle (if you're using `bundle exec ruby-next ...`).
 
+**NOTE:** For Ruby 2.2, safe navigation operator (`&.`) and squiggly heredocs (`<<~TXT`) support is provided.
+
 ## Proposed and edge features
 
 Ruby Next aims to bring edge and proposed features to Ruby community before they (hopefully) reach an official Ruby release.
@@ -498,12 +508,16 @@ require "ruby-next/language/runtime"
 
 - "Endless" method definition (`def foo() = 42`) ([#16746](https://bugs.ruby-lang.org/issues/16746)).
 
-- Right-hand assignment (`13.divmod(5) => a,b`) ([#15921](https://bugs.ruby-lang.org/issues/15921))
+- Right-hand assignment (`13.divmod(5) => a,b`) ([#15921](https://bugs.ruby-lang.org/issues/15921)).
+
+- Find pattern (`[0, 1, 2] in [*, 1 => a, *c]`) ([#16828](https://bugs.ruby-lang.org/issues/16828)).
 
 ### Supported proposed features
 
 - _Method reference_ operator (`.:`) ([#13581](https://bugs.ruby-lang.org/issues/13581)).
 
+- Shorthand Hash notation (`data = {x, y}`) ([#15236](https://bugs.ruby-lang.org/issues/15236)).
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at [https://github.com/ruby-next/ruby-next](ttps://github.com/ruby-next/ruby-next).

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

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "pathname"
+
+module RubyNext
+  module Commands
+    class CoreExt < Base
+      using RubyNext
+
+      attr_reader :out_path, :min_version, :names, :list, :filter, :original_command
+      alias list? list
+
+      def run
+        log "Select core extensions for Ruby v#{min_version}" \
+            "#{filter ? " and matching #{filter.inspect}" : ""}"
+
+        matching_patches.then do |patches|
+          next print_list(patches) if list?
+          generate_core_ext(patches)
+        end
+      end
+
+      def parse!(args)
+        print_help = false
+        @min_version = MIN_SUPPORTED_VERSION
+        @original_command = "ruby-next core_ext #{args.join(" ")}"
+        @names = []
+        @list = false
+        @out_path = File.join(Dir.pwd, "core_ext.rb")
+
+        optparser = base_parser do |opts|
+          opts.banner = "Usage: ruby-next core_ext [options]"
+
+          opts.on("-o", "--output=OUTPUT", "Specify output file or stdout (default: ./core_ext.rb)") do |val|
+            @out_path = val
+          end
+
+          opts.on("-l", "--list", "List all available extensions") do
+            @list = true
+          end
+
+          opts.on("--min-version=VERSION", "Specify the minimum Ruby version to support") do |val|
+            @min_version = Gem::Version.new(val)
+          end
+
+          opts.on("-n", "--name=NAME", "Filter extensions by name") do |val|
+            names << val
+          end
+
+          opts.on("-h", "--help", "Print help") do
+            print_help = true
+          end
+        end
+
+        optparser.parse!(args)
+
+        if print_help
+          $stdout.puts optparser.help
+          exit 0
+        end
+
+        @filter = /(#{names.join("|")})/i unless names.empty?
+      end
+
+      private
+
+      def matching_patches
+        RubyNext::Core.patches.extensions
+          .values
+          .flatten
+          .select do |patch|
+          next if min_version && Gem::Version.new(patch.version) <= min_version
+          next if filter && !filter.match?(patch.name)
+          true
+        end
+      end
+
+      def print_list(patches)
+        grouped_patches = patches.group_by(&:version).sort_by(&:first)
+        grouped_patches.each do |(group, patches)|
+          $stdout.puts "#{group} extensions:\n"
+          $stdout.puts patches.sort_by(&:name).map { |patch| "  - #{patch.name}" }.join("\n")
+          $stdout.puts "\n"
+        end
+      end
+
+      def generate_core_ext(patches)
+        grouped_patches = patches.group_by(&:mod).sort_by { |(mod, patch)| mod.singleton_class? ? mod.inspect : mod.name }
+
+        buffer = []
+
+        buffer << "# frozen_string_literal: true\n"
+
+        buffer << generation_meta
+
+        grouped_patches.each do |mod, patches|
+          singleton = mod.singleton_class?
+          extend_name = singleton ? patches.first.singleton.name : mod.name
+          prepend_name = singleton ? "#{patches.first.singleton.name}.singleton_class" : mod.name
+
+          prepended, extended = patches.partition(&:prepend?)
+
+          prepended.map do |patch|
+            name = "RubyNext::Core::#{patch.name}"
+
+            buffer << <<-RUBY
+             module #{name}
+             #{indent_and_trim(patch.body)}
+             end
+             #{prepend_name}.prepend #{name}
+            RUBY
+
+            name
+          end
+
+          class_or_module = mod.is_a?(Class) ? "class" : "module"
+
+          buffer << "#{class_or_module} #{extend_name}"
+
+          buffer << "  class << self" if singleton
+
+          indent_size = singleton ? 4 : 2
+
+          buffer << extended.map do |patch|
+            indent_and_trim(patch.body, indent_size)
+          end.join("\n\n")
+
+          buffer << "  end" if singleton
+
+          buffer << "end\n"
+        end
+
+        contents = buffer.join("\n")
+
+        return $stdout.puts(contents) if out_path == "stdout"
+
+        unless CLI.dry_run?
+          FileUtils.mkdir_p File.dirname(out_path)
+          File.write(out_path, contents)
+        end
+
+        log "Generated: #{out_path}"
+      end
+
+      def generation_meta
+        <<-MSG
+# Generated by Ruby Next v#{RubyNext::VERSION} using the following command:
+#
+#   #{original_command}
+#
+        MSG
+      end
+
+      def indent_and_trim(src, size = 2)
+        new_src = src.dup
+        # indent code using <size> spaces
+        new_src.gsub!(/^/, " " * size)
+        # remove empty lines
+        new_src.gsub!(/^\s+$/, "")
+        # remove traling blank lines
+        new_src.delete_suffix!("\n")
+        new_src
+      end
+    end
+  end
+end

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

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "pathname"
+
+require "ruby-next/language"
+
+module RubyNext
+  module Commands
+    class Nextify < Base
+      using RubyNext
+
+      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
+        end
+      end
+
+      def parse!(args)
+        print_help = false
+        print_rewriters = false
+        rewriter_names = []
+        @single_version = false
+
+        optparser = base_parser do |opts|
+          opts.banner = "Usage: ruby-next nextify DIRECTORY_OR_FILE [options]"
+
+          opts.on("-o", "--output=OUTPUT", "Specify output directory or file or stdout") do |val|
+            @out_path = val
+          end
+
+          opts.on("--min-version=VERSION", "Specify the minimum Ruby version to support") do |val|
+            @min_version = Gem::Version.new(val)
+          end
+
+          opts.on("--single-version", "Only create one version of a file (for the earliest Ruby version)") do
+            @single_version = true
+          end
+
+          opts.on("--edge", "Enable edge (master) Ruby features") do |val|
+            require "ruby-next/language/edge"
+          end
+
+          opts.on("--proposed", "Enable proposed/experimental Ruby features") do |val|
+            require "ruby-next/language/proposed"
+          end
+
+          opts.on(
+            "--transpile-mode=MODE",
+            "Transpiler mode (ast or rewrite). Default: ast"
+          ) do |val|
+            Language.mode = val.to_sym
+          end
+
+          opts.on("--[no-]refine", "Do not inject `using RubyNext`") do |val|
+            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
+        end
+
+        optparser.parse!(args)
+
+        @lib_path = args[0]
+
+        if print_help
+          $stdout.puts optparser.help
+          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.nil?) || nil) && 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")]
+          elsif File.file?(lib_path)
+            [lib_path].tap do |_|
+              @lib_path = File.dirname(lib_path)
+            end
+          end
+      end
+
+      private
+
+      def transpile(path, contents, version: min_version)
+        rewriters = specified_rewriters || Language.rewriters.select { |rw| rw.unsupported_version?(version) }
+
+        context = Language::TransformContext.new
+
+        new_contents = Language.transform contents, context: context, rewriters: rewriters
+
+        return unless context.dirty?
+
+        versions = context.sorted_versions
+        version = versions.shift
+
+        # First, store already transpiled contents in the minimum required version dir
+        save new_contents, path, version
+
+        return if versions.empty? || single_version?
+
+        # 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)
+        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 next_dir_path.end_with?(".rb")
+            out_path
+          else
+            File.join(next_dir_path, *paths)
+          end
+
+        unless CLI.dry_run?
+          FileUtils.mkdir_p File.dirname(next_path)
+
+          File.write(next_path, contents)
+        end
+
+        log "Generated: #{next_path}"
+      end
+
+      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