ruby-next-core 0.9.2 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31bef7eea12c9a2c8b04f3daa62816e96b764bcbaf7cfc0f01d4bf1b040f34b9
-  data.tar.gz: 793834fef3c0a00944b7026a975f7ee4b97219ae42b2b3ebfb5327d4a3e5311c
+  metadata.gz: 6cab7345f16f61d3a35a307024885c4b9a0055bb946f473bdd5a386b27175ec2
+  data.tar.gz: c3b2004bf5cd1b9dd49d2a7892bd3e88472a632f4cdc8da310bdb56fb96171d9
 SHA512:
-  metadata.gz: 690f42ac5954bbe4b2c6a0e4ee0a05f4842c87a4ade5bccb3f7be90d76b92df89e715a07c785f5286bb4137ac3357fe4341e90b41f010db8716fab5a9bdcfb83
-  data.tar.gz: 48bd02bbd66656cd9892cad1c8fe767c205bfba5eb47c59cfacdf3060af3c7cf886fbba6396283f3e19eb1da66cd53e9b6a5125595ec694cd8c37ad6ecb4e0f1
+  metadata.gz: 4f6b3d6f64e0303e1b69fa5a99ececcf605c7413285c05feb03d9308da8449296fbea96b8779a3ac6b72dca8351ac10cd20f11161b1581ac6a60a85d951ca0d3
+  data.tar.gz: 44e5f05020cae47e13d1a89627c94d890b07daccd1e7dcf51e2e4e0eed208fca2c946e4db674f53fa0581477a368e80c73474ffc657a53f55c1e962bd3d668ba

data/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 ## master
 
+## 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][])

data/README.md

@@ -37,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)
 
@@ -68,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.
 
@@ -139,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]
 
@@ -427,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
@@ -439,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.
@@ -469,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.
@@ -502,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,198 @@
+# 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
+      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