ruby-next 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '04759bfe463ed9def346c1d880fbf3ba7f465be6dac80ac47022543c4be67796'
-  data.tar.gz: a437b160eb2cc3418361d14c962f86faef73f3319c1c6faf71c70bb605de460c
+  metadata.gz: 96fbef2a02f92547dcc39e30ac93fbe59ff98118a797dce1ca017816030e3353
+  data.tar.gz: dd6e45bd8dabbf84ea832f2faa0365b20d4bdc62b9d915fba07cca5a92274a40
 SHA512:
-  metadata.gz: bddaa30d7cd6000d3de03eab8e3b8372e119e3b1f73cb2a78820ab289dcf2a6e88976852012340263ab113b1bd2256e9d22ffaaae80e36b2eee34f88f2953e6c
-  data.tar.gz: a98075ae6d03f4126e2ac2c537d3f86bda82a57e4c446b702e1738fde8c2682442c5731280205ce35e13e96053059a952dd54ce5262456f6d963b9e5dfe815f0
+  metadata.gz: d9755fc420eea44ebc477466dba52015c524c769c57b1d85da809d46061693a07059de89e7021b9d18e443fac8ffce504289ec486bc74baf00c3cab43534a338
+  data.tar.gz: 1830041a93b1b0ee7409a950ed75dfc90bdc56894ba8b140ebf1c45d18d86981a030799ec52f0ad7e442f3f12f9f060260c52ebfb4d6c00087a4c5d0131e6ecd

data/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 ## master
 
+## 0.2.0 (2020-01-13) 🎄
+
+- Add `Enumerator.produce`. ([@palkan][])
+
+- Add Bootsnap integration. ([@palkan][])
+
+Add `require "ruby-next/language/bootsnap"` after setting up Bootsnap
+to transpile the files on load (and cache the resulted iseq via Bootsnap as usually).
+
+- Do not patch `eval` and friends when using runtime mode. ([@palkan][])
+
+Eval support should  be enabled explicitly via the `RubyNext::Language::Eval` refinement, 'cause we cannot handle all the edge cases easily (e.g., the usage caller's binding locals).
+
+- Revoke method reference support. ([@palkan][])
+
+You can still use this feature by enabling it explicitly (see Readme).
+
+- Support in modifier. ([@palkan][])
+
+```ruby
+{a:1, b: 2} in {a:, **}
+p a #=> 1
+```
+
 ## 0.1.0 (2019-11-18)
 
 - Support hash pattern in array and vice versa. ([@palkan][])

data/README.md

@@ -5,18 +5,22 @@
 
 > Make all Rubies quack like edge Ruby!
 
-Ruby Next is a tool for supporting modern/edge CRuby features (APIs and syntax) in older versions and alternative implementations. For example, you can use pattern matching and `Kernel#then` in Ruby 2.5 or [mruby][].
+Ruby Next is a collection of **polyfills** and a **transpiler** for supporting the latest and upcoming Ruby features (APIs and syntax) in older versions and alternative implementations. For example, you can use pattern matching and `Kernel#then` in Ruby 2.5 or [mruby][].
 
 Who might be interested in Ruby Next?
 
 - **Ruby gems maintainers** who want to write code using the latest Ruby version but still support older ones.
 - **Application developers** who want to give new features a try without waiting for the final release (or, more often, for the first patch).
-- **Users of non-MRI implementations** such as [mruby][], [JRuby][], [TruffleRuby][], [Opal][], [Artichoke][], [Prism][].
+- **Users of non-MRI implementations** such as [mruby][], [JRuby][], [TruffleRuby][], [Opal][], [RubyMotion][], [Artichoke][], [Prism][].
 
 Ruby Next also aims to help the community to assess new, _experimental_, MRI features by making it easier to play with them.
 That's why Ruby Next implements the `trunk` features as fast as possible.
 
-_⚡️ The project is in early alpha stage and looking for the first adopters. Main functionality has been implemented (see [the list][features]) but APIs could change in the future._
+_⚡️ The project is in a **beta** phase. That means that the main functionality has been implemented (see [the list][features]) and APIs shouldn't change a lot in the nearest future. On the other hand, the number of users/projects is not enough to say we're "production-ready". So, can't wait to hear your feedback 🙂_
+
+## Links
+
+- [Ruby Next: Make old Rubies quack like a new one](https://noti.st/palkan/j3i2Dr/ruby-next-make-old-rubies-quack-like-a-new-one) (RubyConf 2019)
 
 ## Overview
 
@@ -29,6 +33,7 @@ Language is responsible for **transpiling** edge Ruby syntax into older versions
 programmatically or via CLI. It also could be done in runtime.
 
 Currently, Ruby Next supports Ruby versions 2.5+ (including JRuby 9.2.8+).
+Please, [open an issue](https://github.com/ruby-next/ruby-next/issues/new/choose) if you would like us to support older Ruby versions.
 
 ## Using only polyfills
 
@@ -36,12 +41,14 @@ First, install a gem:
 
 ```ruby
 # Gemfile
-gem "ruby-next"
+gem "ruby-next-core"
 
 # gemspec
-spec.add_dependency "ruby-next"
+spec.add_dependency "ruby-next-core"
 ```
 
+**NOTE:** we use the different _distribution_ gem, `ruby-next-core`, to provide zero-dependency, polyfills-only version.
+
 Then, all you need is to load the Ruby Next:
 
 ```ruby
@@ -60,34 +67,24 @@ Ruby Next only refines core classes if necessary; thus, this line wouldn't have
 
 ## Transpiling, or using edge Ruby syntax features
 
-Ruby Next relies on its own version of the [parser][] gem hosted on Github Package Registry. That makes the installation process a bit more complicated than usual.
+Ruby Next transpiler relies on two libraries: [parser][] and [unparser][].
 
-[**The list of supported syntax features.**][features_syntax]
+**NOTE:** The "official" parser gem only supports the latest stable Ruby version, while Ruby Next aims to support edge and experimental Ruby features. To enable them, you should use our version of Parser (see [instructions](#using-ruby-next-parser) below).
 
-### Installing with Bundler
-
-First, configure your bundler to access GPR:
-
-```sh
-bundle config --local https://rubygems.pkg.github.com/ruby-next USERNAME:ACCESS_TOKEN
-```
-
-Then, add to your Gemfile:
+Installation:
 
 ```ruby
-source "https://rubygems.pkg.github.com/ruby-next" do
-  gem "parser", "2.6.3.102"
-end
-
-gem "unparser", "~> 0.4.5"
+# Gemfile
 gem "ruby-next"
-```
 
-**NOTE:** we don't add `parser` and `unparser` to the gem's runtime deps, 'cause they're not necessary if you only need polyfills.
+# gemspec
+spec.add_dependency "ruby-next"
 
-### Installing globally via `gem`
+# or install globally
+gem install ruby-next
+```
 
-Currently unavailable due to the limitations of Github Package Registry. See [issue](https://github.community/t5/GitHub-Actions/Can-t-install-Ruby-gem-after-publishing-to-Github-Package/m-p/35192/thread-id/2126).
+[**The list of supported syntax features.**][features_syntax]
 
 ### Integrating into a gem development
 
@@ -161,14 +158,38 @@ You can also automatically inject `using RubyNext` to every\* loaded file by als
 
 Since the runtime mode requires Kernel monkey-patching, it should be used carefully. For example, we use it in Ruby Next tests—works perfectly. But think twice before enabling it in production.
 
-We plan to add [Bootsnap][] integration in the future, which would allow us to avoid monkey-patching (by relying on the bullet-proofed Bootsnap's one 😉).
+Consider using [Bootsnap](#using-with-bootsnap) integration, 'cause its monkey-patching has been bullet-proofed 😉.
 
 \* Ruby Next doesn't hijack every required file but _watches_ only the configured directories: `./app/`, `./lib/`, `./spec/`, `./test/` (relative to the `pwd`). You can configure the watch dirs:
 
 ```ruby
-RubyNext::Language::Runtime.watch_dirs << "path/to/other/dir"
+RubyNext::Language.watch_dirs << "path/to/other/dir"
+```
+
+### Eval & similar
+
+By default, we do not hijack `Kernel.eval` and similar methods due to some limitations (e.g., there is no easy and efficient way to access the caller's scope, or _binding_, and some evaluations relies on local variables).
+
+If you want to support transpiling in `eval`-like methods, opt-in explicitly by activating the refinement:
+
+```ruby
+using RubyNext::Language::Eval
+```
+
+## Using with Bootsnap
+
+[Bootsnap][] is a great tool to speed-up your application load and it's included into the default Rails Gemfile. It patches Ruby mechanism of loading source files to make it possible to cache the intermediate representation (_iseq_).
+
+Ruby Next provides a specific integration which allows to add a transpiling step to this process, thus making the transpiler overhead as small as possible, because the cached and **already transpiled** version is used if no changes were made.
+
+To enable this integration, add the following line after the `require "bootsnap/setup"`:
+
+```ruby
+require "ruby-next/language/bootsnap"
 ```
 
+**NOTE:** there is no way to invalidate the cache when you upgrade Ruby Next (e.g., due to the bug fixes), so you should do this manually.
+
 ## `uby-next`
 
 You can also enable runtime mode by requiring `uby-next` while running a Ruby executable:
@@ -183,6 +204,55 @@ RUBYOPT="-ruby-next" ruby my_ruby_script.rb
 ruby -ruby-next -e "puts [2, 4, 5].tally"
 ```
 
+## Unofficial/experimental features
+
+Ruby Next also provides support for some features not-yet-merged into Ruby master (or reverted).
+
+These features require a [custom parser](#using-ruby-next-parser).
+
+Currenly, the only such feature is the [_method reference_ operator](https://bugs.ruby-lang.org/issues/13581):
+
+- Add `--enable-method-reference` option to `nextify` command when using CLI.
+- OR add it programmatically when using a runtime mode (see [example](https://github.com/ruby-next/ruby-next/blob/master/default.mspec)).
+- OR set `RUBY_NEXT_ENABLE_METHOD_REFERENCE=1` environment variable (works with CLI as well).
+
+## Using Ruby Next parser
+
+### Prerequisites
+
+Our own version of [parser][next_parser] gem is hosted on Github Package Registry. That makes the installation process a bit more complicated than usual.
+
+You must obtain an access token to use it. See the [GPR docs](https://help.github.com/en/github/managing-packages-with-github-package-registry/configuring-rubygems-for-use-with-github-package-registry#authenticating-to-github-package-registry).
+
+### Installing with Bundler
+
+First, configure your bundler to access GPR:
+
+```sh
+bundle config --local https://rubygems.pkg.github.com/ruby-next USERNAME:ACCESS_TOKEN
+```
+
+Then, add to your Gemfile:
+
+```ruby
+source "https://rubygems.pkg.github.com/ruby-next" do
+  gem "parser", "2.7.0.100"
+end
+
+gem "ruby-next"
+```
+
+**NOTE:** we don't add `parser` and `unparser` to the gem's runtime deps, 'cause they're not necessary if you only need polyfills.
+
+### Installing globally via `gem`
+
+You can install `ruby-next` globally by running the following commands:
+
+```sh
+gem install parser -v "2.7.0.100" --source "https://USERNAME:ACCESS_TOKEN@rubygems.pkg.github.com/ruby-next"
+gem install ruby-next
+```
+
 ## 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).
@@ -200,7 +270,10 @@ The gem is available as open source under the terms of the [MIT License](https:/
 [JRuby]: https://www.jruby.org
 [TruffleRuby]: https://github.com/oracle/truffleruby
 [Opal]: https://opalrb.com
+[RubyMotion]: http://www.rubymotion.com
 [Artichoke]: https://github.com/artichoke/artichoke
 [Prism]: https://github.com/prism-rb/prism
 [parser]: https://github.com/whitequark/parser
+[unparser]: https://github.com/mbj/unparser
+[next_parser]: https://github.com/ruby-next/parser
 [Bootsnap]: https://github.com/Shopify/bootsnap

data/bin/parse

@@ -15,5 +15,5 @@ contents =
     ARGV[0]
   end
 
-ast = RubyNext::Language::Parser.parse(contents)
+ast = RubyNext::Language.parse(contents)
 puts ast

data/bin/transform

@@ -2,12 +2,15 @@
 
 lib = File.expand_path("../../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-$VERBOSE = nil
 
 require "bundler/setup"
 
 require "ruby-next/language"
 
+# optional parsers
+require "ruby-next/language/rewriters/method_reference"
+RubyNext::Language.rewriters << RubyNext::Language::Rewriters::MethodReference
+
 contents =
   if File.exist?(ARGV[0])
     File.read(ARGV[0])

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

@@ -35,6 +35,11 @@ module RubyNext
           opts.on("--single-version", "Only create one version of a file (for the earliest Ruby version)") do
             @single_version = true
           end
+
+          opts.on("--enable-method-reference", "Enable reverted method reference syntax (requires custom parser)") do
+            require "ruby-next/language/rewriters/method_reference"
+            Language.rewriters << Language::Rewriters::MethodReference
+          end
         end
 
         @lib_path = args[0]

data/lib/ruby-next/core/enumerator/produce.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+unless Enumerator.respond_to?(:produce)
+  RubyNext.module_eval do
+    refine Enumerator.singleton_class do
+      # Based on https://github.com/zverok/enumerator_generate
+      def produce(*rest, &block)
+        raise ArgumentError, "wrong number of arguments (given #{rest.size}, expected 0..1)" if rest.size > 1
+        raise ArgumentError, "No block given" unless block
+
+        Enumerator.new(Float::INFINITY) do |y|
+          val = rest.empty? ? yield() : rest.pop
+
+          loop do
+            y << val
+            val = yield(val)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby-next/core/runtime.rb

@@ -2,9 +2,9 @@
 
 # Extend `Language.transform` to inject `using RubyNext` to every file
 RubyNext::Language.singleton_class.prepend(Module.new do
-  def transform(contents, **hargs)
+  def transform(contents, using: true, **hargs)
     # We cannot activate refinements in eval
-    RubyNext::Core.inject!(contents) unless hargs[:eval]
-    super(contents, **hargs)
+    new_contents = RubyNext::Core.inject!(contents) if using
+    super(new_contents || contents, using: using, **hargs)
   end
 end)

data/lib/ruby-next/core.rb

@@ -5,7 +5,11 @@ module RubyNext
     class << self
       # Inject `using RubyNext` at the top of the source code
       def inject!(contents)
-        contents.sub!(/^(\s*[^#\s].*)/, 'using RubyNext;\1')
+        if contents.frozen?
+          contents = contents.sub(/^(\s*[^#\s].*)/, 'using RubyNext;\1')
+        else
+          contents.sub!(/^(\s*[^#\s].*)/, 'using RubyNext;\1')
+        end
         contents
       end
     end
@@ -20,6 +24,8 @@ require_relative "core/enumerable/tally"
 require_relative "core/enumerable/filter"
 require_relative "core/enumerable/filter_map"
 
+require_relative "core/enumerator/produce"
+
 require_relative "core/array/difference_union_intersection"
 
 require_relative "core/hash/merge"

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "ruby-next"
+require "ruby-next/utils"
+require "ruby-next/language"
+
+# Patch bootsnap to transform source code.
+# Based on https://github.com/kddeisz/preval/blob/master/lib/preval.rb
+load_iseq = RubyVM::InstructionSequence.method(:load_iseq)
+
+if load_iseq.source_location[0].include?("/bootsnap/")
+  Bootsnap::CompileCache::ISeq.singleton_class.prepend(
+    Module.new do
+      def input_to_storage(source, path)
+        return super unless RubyNext::Language.transformable?(path)
+        source = RubyNext::Language.transform(source, rewriters: RubyNext::Language.current_rewriters)
+
+        $stdout.puts ::RubyNext::Utils.source_with_lines(source, path) if ENV["RUBY_NEXT_DEBUG"] == "1"
+
+        RubyVM::InstructionSequence.compile(source, path, path).to_binary
+      rescue SyntaxError
+        raise Bootsnap::CompileCache::Uncompilable, "syntax error"
+      end
+    end
+  )
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module KernelEval
+      refine Kernel do
+        def eval(source, bind = nil, *args)
+          new_source = ::RubyNext::Language::Runtime.transform(
+            source,
+            using: bind&.receiver == TOPLEVEL_BINDING.receiver || bind&.receiver&.is_a?(Module)
+          )
+          $stdout.puts ::RubyNext::Utils.source_with_lines(new_source, "(#{caller_locations(1, 1).first})") if ENV["RUBY_NEXT_DEBUG"] == "1"
+          super new_source, bind, *args
+        end
+      end
+    end
+
+    module InstanceEval # :nodoc:
+      refine Object do
+        def instance_eval(*args, &block)
+          return super(*args, &block) if block_given?
+
+          source = args.shift
+          new_source = ::RubyNext::Language::Runtime.transform(source, using: false)
+          $stdout.puts ::RubyNext::Utils.source_with_lines(new_source, "(#{caller_locations(1, 1).first})") if ENV["RUBY_NEXT_DEBUG"] == "1"
+          super new_source, *args
+        end
+      end
+    end
+
+    module ClassEval
+      refine Module do
+        def module_eval(*args, &block)
+          return super(*args, &block) if block_given?
+
+          source = args.shift
+          new_source = ::RubyNext::Language::Runtime.transform(source, using: false)
+          $stdout.puts ::RubyNext::Utils.source_with_lines(new_source, "(#{caller_locations(1, 1).first})") if ENV["RUBY_NEXT_DEBUG"] == "1"
+          super new_source, *args
+        end
+
+        def class_eval(*args, &block)
+          return super(*args, &block) if block_given?
+
+          source = args.shift
+          new_source = ::RubyNext::Language::Runtime.transform(source, using: false)
+          $stdout.puts ::RubyNext::Utils.source_with_lines(new_source, "(#{caller_locations(1, 1).first})") if ENV["RUBY_NEXT_DEBUG"] == "1"
+          super new_source, *args
+        end
+      end
+    end
+
+    # Refinements for `eval`-like methods.
+    # Transpiling eval is only possible if we do not use local from the binding,
+    # because we cannot access the binding of caller (without non-production ready hacks).
+    #
+    # This module is meant mainly for testing purposes.
+    module Eval
+      include InstanceEval
+      include ClassEval
+      include KernelEval
+    end
+  end
+end

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

@@ -1,23 +1,24 @@
 # frozen_string_literal: true
 
-require "ruby-next/utils"
-
 require "parser/ruby27"
-RubyNext::Language::Parser = Parser::Ruby27
 
-# See https://github.com/whitequark/parser/#usage
-Parser::Builders::Default.emit_lambda = true
-Parser::Builders::Default.emit_procarg0 = true
-Parser::Builders::Default.emit_encoding = true
-Parser::Builders::Default.emit_index = true
+module RubyNext
+  module Language
+    class Builder < ::Parser::Builders::Default
+      modernize
+    end
+
+    class << self
+      def parser
+        ::Parser::Ruby27.new(Builder.new)
+      end
 
-Parser::Builders::Default.prepend(Module.new do
-  def match_hash_var_from_str(begin_t, strings, end_t)
-    super.tap do
-      string = strings[0]
-      next unless string.type == :str
-      name, = *string
-      @parser.static_env.declare(name)
+      def parse(source, file = "(string)")
+        buffer = ::Parser::Source::Buffer.new(file).tap do |buffer|
+          buffer.source = source
+        end
+        parser.parse(buffer)
+      end
     end
   end
-end)
+end

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

@@ -5,6 +5,14 @@ using RubyNext
 module RubyNext
   module Language
     module Rewriters
+      CUSTOM_PARSER_REQUIRED = <<~MSG
+        The %s feature is not a part of the latest stable Ruby release
+        and is not supported by your Parser gem version.
+
+        Use RubyNext's parser to use it: https://github.com/ruby-next/parser
+
+      MSG
+
       class Base < ::Parser::TreeRewriter
         class LocalsTracker
           attr_reader :stacks
@@ -64,6 +72,16 @@ module RubyNext
           def unsupported_version?(version)
             self::MIN_SUPPORTED_VERSION > version
           end
+
+          private
+
+          def transform(source)
+            Language.transform(source, rewriters: [self], using: false)
+          end
+
+          def warn_custom_parser_required_for(feature)
+            warn(CUSTOM_PARSER_REQUIRED % feature)
+          end
         end
 
         attr_reader :locals

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

@@ -21,6 +21,10 @@ module RubyNext
             ]
           )
         end
+
+        unless transform(SYNTAX_PROBE) == "Language.method(:transform)"
+          warn_custom_parser_required_for("method reference")
+        end
       end
     end
   end

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

@@ -27,7 +27,7 @@ module RubyNext
         private
 
         def proc_args(n)
-          return s(:args, s(:procarg0, :_1)) if n == 1
+          return s(:args, s(:procarg0, s(:arg, :_1))) if n == 1
 
           (1..n).map do |numero|
             s(:arg, :"_#{numero}")

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

@@ -35,13 +35,12 @@ module RubyNext
         SYNTAX_PROBE = "case 0; in 0; true; else; 1; end"
         MIN_SUPPORTED_VERSION = Gem::Version.new("2.7.0")
 
-        MATCHEE = :__matchee__
-        MATCHEE_ARR = :__matchee_arr__
-        MATCHEE_HASH = :__matchee_hash__
+        MATCHEE = :__m__
+        MATCHEE_ARR = :__m_arr__
+        MATCHEE_HASH = :__m_hash__
 
         def on_case_match(node)
           context.track! self
-          context.use_ruby_next!
 
           @deconstructed = []
 
@@ -64,6 +63,39 @@ module RubyNext
           )
         end
 
+        def on_in_match(node)
+          context.track! self
+
+          @deconstructed = []
+
+          matchee =
+            s(:lvasgn, MATCHEE, node.children[0])
+
+          pattern =
+            locals.with(
+              matchee: MATCHEE,
+              arr: MATCHEE_ARR,
+              hash: MATCHEE_HASH
+            ) do
+              send(
+                :"#{node.children[1].type}_clause",
+                node.children[1]
+              ).then do |node|
+                s(:or,
+                  node,
+                  no_matching_pattern)
+              end
+            end
+
+          node.updated(
+            :and,
+            [
+              matchee,
+              pattern
+            ]
+          )
+        end
+
         private
 
         def build_if_clause(node, rest)
@@ -172,6 +204,8 @@ module RubyNext
           # only deconstruct once per case
           return if deconstructed.include?(locals[:arr])
 
+          context.use_ruby_next!
+
           right = s(:send, matchee, :deconstruct)
 
           deconstructed << locals[:arr]
@@ -276,7 +310,7 @@ module RubyNext
           # Optimization: avoid hash modifications when not needed
           # (we use #dup and #delete when "reading" values when **rest is present
           # to assign the rest of the hash copy to it)
-          @hash_match_rest = node.children.any? { |child| child.type == :match_rest }
+          @hash_match_rest = node.children.any? { |child| child.type == :match_rest || child.type == :match_nil_pattern }
           keys = hash_pattern_keys(node.children)
 
           deconstruct_keys_node(keys, matchee).then do |dnode|
@@ -299,7 +333,9 @@ module RubyNext
           return s(:nil) if children.empty?
 
           children.filter_map do |child|
-            return s(:nil) if child.type == :match_rest
+            # Skip ** without var
+            next if child.type == :match_rest && child.children.empty?
+            return s(:nil) if child.type == :match_rest || child.type == :match_nil_pattern
 
             send("#{child.type}_hash_key", child)
           end.then { |keys| s(:array, *keys) }
@@ -325,6 +361,8 @@ module RubyNext
           # Create a copy of the original hash if already deconstructed
           return hash_dup if deconstructed.include?(locals[:hash])
 
+          context.use_ruby_next!
+
           deconstructed << locals[:hash]
 
           right = s(:send,
@@ -398,6 +436,12 @@ module RubyNext
             match_var_clause(node, hash_value_at(key)))
         end
 
+        def match_nil_pattern_hash_element(node, _key = nil)
+          s(:send,
+            s(:lvar, locals[:hash]),
+            :empty?)
+        end
+
         def match_rest_hash_element(node, _key = nil)
           # case {}; in **; end
           return if node.children.empty?

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

@@ -5,55 +5,42 @@ require "pathname"
 require "ruby-next"
 require "ruby-next/utils"
 require "ruby-next/language"
+require "ruby-next/language/eval"
 
 using RubyNext
 
 module RubyNext
   module Language
     # Module responsible for runtime transformations
-    module Runtime
-      # Apply only rewriters required for the current version
-      REWRITERS = RubyNext::Language.rewriters.select(&:unsupported_syntax?)
 
+    module Runtime
       class << self
         include Utils
 
-        attr_reader :watch_dirs
-
         def load(path, wrap: false)
           raise "RubyNext cannot handle `load(smth, wrap: true)`" if wrap
 
           contents = File.read(path)
           new_contents = transform contents
 
-          puts source_with_lines(new_contents) if ENV["RUBY_NEXT_DEBUG"] == "1"
+          $stdout.puts source_with_lines(new_contents, path) if ENV["RUBY_NEXT_DEBUG"] == "1"
 
           TOPLEVEL_BINDING.eval(new_contents, path)
           true
         end
 
         def transform(contents, **options)
-          Language.transform(contents, rewriters: REWRITERS, **options)
-        end
-
-        def transformable?(path)
-          watch_dirs.any? { |dir| path.start_with?(dir) }
+          Language.transform(contents, rewriters: Language.current_rewriters, **options)
         end
 
         def feature_path(path)
           path = resolve_feature_path(path)
           return if path.nil?
           return if File.extname(path) != ".rb"
-          return unless transformable?(path)
+          return unless Language.transformable?(path)
           path
         end
-
-        private
-
-        attr_writer :watch_dirs
       end
-
-      self.watch_dirs = %w[app lib spec test].map { |path| File.join(Dir.pwd, path) }
     end
   end
 end
@@ -69,11 +56,13 @@ module Kernel
 
     return false if $LOADED_FEATURES.include?(realpath)
 
+    $LOADED_FEATURES << realpath
+
     RubyNext::Language::Runtime.load(realpath)
 
-    $LOADED_FEATURES << realpath
     true
   rescue => e
+    $LOADED_FEATURES.delete realpath
     warn "RubyNext failed to require '#{path}': #{e.message}"
     require_without_ruby_next(path)
   end
@@ -104,46 +93,4 @@ module Kernel
     warn "RubyNext failed to load '#{path}': #{e.message}"
     load_without_ruby_next(path)
   end
-
-  alias_method :eval_without_ruby_next, :eval
-  def eval(source, *args)
-    new_source = RubyNext::Language::Runtime.transform(source, eval: true)
-    eval_without_ruby_next new_source, *args
-  end
-end
-
-# Patch BasicObject to hijack instance_eval
-class BasicObject
-  alias_method :instance_eval_without_ruby_next, :instance_eval
-
-  def instance_eval(*args, &block)
-    return instance_eval_without_ruby_next(*args, &block) if block_given?
-
-    source = args.shift
-    new_source = ::RubyNext::Language::Runtime.transform(source, eval: true)
-    instance_eval_without_ruby_next new_source, *args
-  end
-end
-
-# Patch Module to hijack class_eval/module_eval
-class Module
-  alias_method :module_eval_without_ruby_next, :module_eval
-
-  def module_eval(*args, &block)
-    return module_eval_without_ruby_next(*args, &block) if block_given?
-
-    source = args.shift
-    new_source = ::RubyNext::Language::Runtime.transform(source, eval: true)
-    module_eval_without_ruby_next new_source, *args
-  end
-
-  alias_method :class_eval_without_ruby_next, :class_eval
-
-  def class_eval(*args, &block)
-    return class_eval_without_ruby_next(*args, &block) if block_given?
-
-    source = args.shift
-    new_source = ::RubyNext::Language::Runtime.transform(source, eval: true)
-    class_eval_without_ruby_next new_source, *args
-  end
 end

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

@@ -6,18 +6,3 @@ require "parser/current"
 $VERBOSE = save_verbose
 
 require "unparser"
-
-# Unparser patches
-
-# Unparser doesn't support endless ranges
-# Source: https://github.com/mbj/unparser/blob/a4f959d58b660ef0630659efa5882fc20936eb18/lib/unparser/emitter/literal/range.rb
-# TODO: propose a PR
-class Unparser::Emitter::Literal::Range
-  private
-
-  def dispatch
-    visit(begin_node)
-    write(TOKENS.fetch(node.type))
-    visit(end_node) unless end_node.nil?
-  end
-end

data/lib/ruby-next/language.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-gem "parser", "~> 2.6.3.102"
-gem "unparser", "~> 0.4.5"
+gem "parser", ">= 2.7.0.0"
+gem "unparser", ">= 0.4.7"
 
 require "set"
 
@@ -60,9 +60,10 @@ module RubyNext
 
     class << self
       attr_accessor :rewriters
+      attr_reader :watch_dirs
 
-      def transform(source, rewriters: self.rewriters, eval: false, context: TransformContext.new)
-        Parser.parse(source).then do |ast|
+      def transform(source, rewriters: self.rewriters, using: true, context: TransformContext.new)
+        parse(source).then do |ast|
           rewriters.inject(ast) do |tree, rewriter|
             rewriter.new(context).process(tree)
           end.then do |new_ast|
@@ -70,15 +71,29 @@ module RubyNext
 
             Unparser.unparse(new_ast)
           end.then do |source|
-            next source if eval || !context.use_ruby_next?
+            next source unless using && context.use_ruby_next?
 
             Core.inject! source.dup
           end
         end
       end
+
+      def transformable?(path)
+        watch_dirs.any? { |dir| path.start_with?(dir) }
+      end
+
+      # Rewriters required for the current version
+      def current_rewriters
+        @current_rewriters ||= rewriters.select(&:unsupported_syntax?)
+      end
+
+      private
+
+      attr_writer :watch_dirs
     end
 
     self.rewriters = []
+    self.watch_dirs = %w[app lib spec test].map { |path| File.join(Dir.pwd, path) }
 
     require "ruby-next/language/rewriters/base"
 
@@ -88,13 +103,15 @@ module RubyNext
     require "ruby-next/language/rewriters/pattern_matching"
     rewriters << Rewriters::PatternMatching
 
-    require "ruby-next/language/rewriters/method_reference"
-    rewriters << Rewriters::MethodReference
-
     require "ruby-next/language/rewriters/args_forward"
     rewriters << Rewriters::ArgsForward
 
     require "ruby-next/language/rewriters/numbered_params"
     rewriters << Rewriters::NumberedParams
+
+    if ENV["RUBY_NEXT_ENABLE_METHOD_REFERENCE"] == "1"
+      require "ruby-next/language/rewriters/method_reference"
+      RubyNext::Language.rewriters << RubyNext::Language::Rewriters::MethodReference
+    end
   end
 end

data/lib/ruby-next/utils.rb

@@ -25,9 +25,11 @@ module RubyNext
       end
     end
 
-    def source_with_lines(source)
+    def source_with_lines(source, path)
       source.lines.map.with_index do |line, i|
-        "#{i.to_s.rjust(3)}:  #{line}"
+        "#{(i + 1).to_s.rjust(4)}:  #{line}"
+      end.tap do |lines|
+        lines.unshift "   0:  # source: #{path}"
       end
     end
   end

data/lib/ruby-next/version.rb

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

data/lib/uby-next.rb

@@ -5,7 +5,7 @@ require "ruby-next/core/runtime"
 
 using RubyNext
 
-RubyNext::Language::Runtime.watch_dirs << Dir.pwd
+RubyNext::Language.watch_dirs << Dir.pwd
 
 require "stringio"
 

metadata

@@ -1,44 +1,60 @@
 --- !ruby/object:Gem::Specification
 name: ruby-next
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Vladimir Dementyev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-11-18 00:00:00.000000000 Z
+date: 2020-01-13 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby-next-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: parser
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.6.3.102
-  type: :development
+        version: 2.7.0.0
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.6.3.102
+        version: 2.7.0.0
 - !ruby/object:Gem::Dependency
   name: unparser
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.5
-  type: :development
+        version: 0.4.7
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.5
-description: "\n    Coming soon.\n  "
+        version: 0.4.7
+description: "\n    Ruby Next is a collection of polyfills and a transpiler for supporting
+  latest and upcoming edge CRuby features\n    in older versions and alternative implementations
+  (such as mruby, JRuby, Opal, Artichoke, RubyMotion, etc.).\n  "
 email:
 - dementiev.vm@gmail.com
 executables:
@@ -61,12 +77,15 @@ files:
 - lib/ruby-next/core/enumerable/filter.rb
 - lib/ruby-next/core/enumerable/filter_map.rb
 - lib/ruby-next/core/enumerable/tally.rb
+- lib/ruby-next/core/enumerator/produce.rb
 - lib/ruby-next/core/hash/merge.rb
 - lib/ruby-next/core/kernel/then.rb
 - lib/ruby-next/core/pattern_matching.rb
 - lib/ruby-next/core/proc/compose.rb
 - lib/ruby-next/core/runtime.rb
 - lib/ruby-next/language.rb
+- lib/ruby-next/language/bootsnap.rb
+- lib/ruby-next/language/eval.rb
 - lib/ruby-next/language/parser.rb
 - lib/ruby-next/language/rewriters/args_forward.rb
 - lib/ruby-next/language/rewriters/base.rb
@@ -83,7 +102,12 @@ files:
 homepage: http://github.com/palkan/ruby-next
 licenses:
 - MIT
-metadata: {}
+metadata:
+  bug_tracker_uri: http://github.com/ruby-next/ruby-next/issues
+  changelog_uri: https://github.com/ruby-next/ruby-next/blob/master/CHANGELOG.md
+  documentation_uri: http://github.com/ruby-next/ruby-next/blob/master/README.md
+  homepage_uri: http://github.com/ruby-next/ruby-next
+  source_code_uri: http://github.com/ruby-next/ruby-next
 post_install_message: 
 rdoc_options: []
 require_paths: