ruby-next-core 0.10.5 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 34691e69e3f0725ece379addac8297e0b69e9ed0a55fb1a06bfe3ca970213eae
-  data.tar.gz: 23edfba446641d2658d754f3678eb79de8ee332a4d481d4714887769392ad272
+  metadata.gz: 1e73900618b0d9da915699c40c610736e19919ac0d11bce7c7dc58e7d5ddb84b
+  data.tar.gz: b07917f44a763467f4bed145ae1224ba8aeb03eaba7924b2787c681df4b704f8
 SHA512:
-  metadata.gz: 0d41912b15fd77ed3a1d2d2665a3375a212a1815e26e85724d2e0960af1daa5c714b126efca1c5621dc76b16af3d612c35a077be3472ca607548a757dea253ac
-  data.tar.gz: 02d860b6d0730f48b990c6c8dd9a3ef49e022ea7a0ae637a64cd0c29a74ee1e6c2b0f4cdf0ed25886029a49d9e2df8044b9e016aead9733ca322fd3579093949
+  metadata.gz: fb7bc9bc3416a8b6df9e99f346fb15c2c0ae0a9d63bba739adaa6c604110eaa753a5d7b00d98443400e92d7233fba7b4fda2a43e866ce85ef04ed46cd7e89a4c
+  data.tar.gz: 0b6410607425aaa0afb66309fa07739e72e3b8cbf94addf85d501f136755159db968225b6d1752a1bda77911592252d48e2d2c5421dae5798d5741ef6ec33616

data/CHANGELOG.md

@@ -2,6 +2,46 @@
 
 ## master
 
+## 0.13.0 (2021-09-27)
+
+- Added `Enumerable#tally` with the resulting hash. ([@skryukov][])
+
+- Added `Array#intersect?`. ([@skryukov][])
+
+## 0.12.0 (2021-01-12)
+
+- Added required keyword arguments rewriter. ([@palkan][])
+
+Required kwargs were introduced in 2.1. Now we make them possible in 2.0.
+
+- Added numeric literals rewriter. ([@palkan][])
+
+Now it's possible to generate Ruby 2.0 compatible code from `2i + 1/3r`.
+
+- Fixed several safe navigation (`&.`) bugs. ([@palkan][])
+
+See [#68](https://github.com/ruby-next/ruby-next/issues/68) and [#69](https://github.com/ruby-next/ruby-next/issues/69).
+
+## 0.11.1 (2020-12-28)
+
+- Use separate _namespace_ for proposed features to avoid conflicts with new Ruby version. ([@palkan][])
+
+Previously, we used the upcoming Ruby version number for proposed features (e.g., `3.0.0`), which broke
+the load path setup, since transpiled files were not loaded anymore.
+Now that's fixed by using a _virtual_ version number for proposals (`1995.next.0`).
+
+## 0.11.0 (2020-12-24) 🎄
+
+- Extended proposed shorthand Hash syntax to support kwargs as well. ([@palkan][])
+
+You can try it: `x = 1; y = 2; foo(x:, y:) # => foo(x: x, y: y)`.
+
+- **Rewrite mode is used by default in transpiler**. ([@palkan][])
+
+- Move 3.0 features to stable features. ([@palkan][])
+
+- Refactor `a => x` and `a in x` to comply with Ruby 3.0. ([@palkan][])
+
 ## 0.10.5 (2020-10-13)
 
 - Fix Unparser 0.5.0 compatibility. ([@palkan][])
@@ -247,3 +287,4 @@ p a #=> 1
 [@palkan]: https://github.com/palkan
 [backports]: https://github.com/marcandre/backports
 [@sl4vr]: https://github.com/sl4vr
+[@skryukov]: https://github.com/skryukov

data/README.md

@@ -21,8 +21,20 @@ That's why Ruby Next implements the `master` features as fast as possible.
 
 Read more about the motivation behind the Ruby Next in this post: [Ruby Next: Make all Rubies quack alike](https://evilmartians.com/chronicles/ruby-next-make-all-rubies-quack-alike).
 
-<a href="https://evilmartians.com/?utm_source=ruby-next">
-<img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg" alt="Sponsored by Evil Martians" width="236" height="54"></a>
+<table style="border:none;">
+<tr>
+<td>
+     <a href="https://evilmartians.com/?utm_source=ruby-next">
+          <img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg" alt="Sponsored by Evil Martians" width="236" height="54">
+     </a>
+</td>
+<td>
+     <a href="http://www.digitalfukuoka.jp/topics/169">
+          <img src="http://www.digitalfukuoka.jp/javascripts/kcfinder/upload/images/excellence.jpg" width="200">
+     </a>
+</td>
+</tr>
+</table>
 
 ## Posts
 
@@ -93,8 +105,7 @@ def greet(val) =
       '👽'
     end
 
-greet(hello: 'martian') => greeting
-puts greeting
+puts greet(hello: 'martian')
 "
 
 => 👽
@@ -179,17 +190,17 @@ In the AST mode, we parse the source code into AST, modifies this AST and **gene
 
 In the rewrite mode, we apply changes to the source code itself, thus, keeping the original formatting of the unaffected code (in a similar way to RuboCop's autocorrect feature).
 
-By default, we use the AST mode. That could likely change in the future when we collect enough feedback on the rewrite mode and fix potential bugs.
-
 The main benefit of the rewrite mode is that it preserves the original code line numbers and layout, which is especially useful in debugging.
 
+By default, we use the rewrite mode. If you found a bug with rewrite mode which is not reproducible in the AST mode, please, let us know.
+
 You can change the transpiler mode:
 
 - From code by setting `RubyNext::Language.mode = :ast` or `RubyNext::Language.mode = :rewrite`.
-- Via environmental variable `RUBY_NEXT_TRANSPILE_MODE=rewrite`.
+- Via environmental variable `RUBY_NEXT_TRANSPILE_MODE=ast`.
 - Via CLI option ([see below](#cli)).
 
-**NOTE:** For the time being, Unparser [doesn't support](https://github.com/mbj/unparser/pull/142) new Ruby 2.7 AST nodes, so we always use rewrite mode in Ruby 2.7+.
+**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
 
@@ -220,7 +231,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`). 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`). 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:
 
@@ -323,7 +334,7 @@ due to the way feature resolving works in Ruby (scanning the `$LOAD_PATH` and ha
 
 If you're using [runtime mode](#runtime-usage) a long with `setup_gem_load_path` (e.g., in tests), the transpiled files are ignored (i.e., we do not modify `$LOAD_PATH`).
 
-\* Ruby Next avoids storing duplicates; instead, only the code for the earlier version is created and is assumed to be used with other versions. For example, if the transpiled code is the same for Ruby 2.5 and Ruby 2.6, only the `.rbnext/2.7/path/to/file.rb` is kept. That's why multiple entries are added to the `$LOAD_PATH` (`.rbnext/2.6` and `.rbnext/2.7` in the specified order for Ruby 2.5 and only `.rbnext/2.7` for Ruby 2.6).
+\* Ruby Next avoids storing duplicates; instead, only the code for the earlier version is created and is assumed to be used with other versions. For example, if the transpiled code is the same for Ruby 2.5 and Ruby 2.6, only the `.rbnext/2.7/path/to/file.rb` is kept. That's why multiple entries are added to the `$LOAD_PATH` (`.rbnext/2.6`, `.rbnext/2.7`, and `.rbnext/3.0` in the specified order for Ruby 2.5, and `.rbnext/2.7` and `.rbnext/3.0` for Ruby 2.6).
 
 ### Transpiled files vs. VCS vs. installing from source
 
@@ -446,6 +457,8 @@ AllCops:
 
 We currently provide support for Ruby 2.2, 2.3 and 2.4.
 
+**NOTE:** By "support" here we mean using `ruby-next` CLI and runtime transpiling. Transpiled code may run on Ruby 2.0+.
+
 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.
 
@@ -509,17 +522,13 @@ require "ruby-next/language/runtime"
 
 ### Supported edge features
 
-- "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)).
-
-- Find pattern (`[0, 1, 2] in [*, 1 => a, *c]`) ([#16828](https://bugs.ruby-lang.org/issues/16828)).
+`Array#intersect?` ([#15198](https://bugs.ruby-lang.org/issues/15198))
 
 ### 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)).
+- Shorthand Hash/kwarg notation (`data = {x, y}` or `foo(x:, y:)`) ([#15236](https://bugs.ruby-lang.org/issues/15236)).
 
 ## Contributing
 

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

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+require "set"
+
+require "ruby-next/config"
+require "ruby-next/utils"
+
+module RubyNext
+  module Core
+    # Patch contains the extension implementation
+    # and meta information (e.g., Ruby version).
+    class Patch
+      attr_reader :refineables, :name, :mod, :method_name, :version, :body, :singleton, :core_ext, :supported, :native, :location
+
+      # Create a new patch for module/class (mod)
+      # with the specified uniq name
+      #
+      # `core_ext` defines the strategy for core extensions:
+      #    - :patch — extend class directly
+      #    - :prepend — extend class by prepending a module (e.g., when needs `super`)
+      def initialize(mod = nil, method: ::Kernel.raise(::ArgumentError, "missing keyword: method"), version: ::Kernel.raise(::ArgumentError, "missing keyword: version"), name: nil, supported: nil, native: nil, location: nil, refineable: mod, core_ext: :patch, singleton: nil)
+        @mod = mod
+        @method_name = method
+        @version = version
+        if method_name && mod
+          @supported = supported.nil? ? mod.method_defined?(method_name) : supported
+          # define whether running Ruby has a native implementation for this method
+          # for that, we check the source_location (which is nil for C defined methods)
+          @native = native.nil? ? (supported? && native_location?(mod.instance_method(method_name).source_location)) : native
+        end
+        @singleton = singleton
+        @refineables = Array(refineable)
+        @body = yield
+        @core_ext = core_ext
+        @location = location || build_location(caller_locations(1, 5))
+        @name = name || build_module_name
+      end
+
+      def prepend?
+        core_ext == :prepend
+      end
+
+      def core_ext?
+        !mod.nil?
+      end
+
+      alias supported? supported
+      alias native? native
+      alias singleton? singleton
+
+      def to_module
+        Module.new.tap do |ext|
+          ext.module_eval(body, *location)
+
+          RubyNext::Core.const_set(name, ext)
+        end
+      end
+
+      private
+
+      def build_module_name
+        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/, "")
+      end
+
+      def build_location(trace_locations)
+        # The caller_locations behaviour depends on implementaion,
+        # e.g. in JRuby https://github.com/jruby/jruby/issues/6055
+        while trace_locations.first.label != "patch"
+          trace_locations.shift
+        end
+
+        trace_location = trace_locations[1]
+
+        [trace_location.absolute_path, trace_location.lineno + 2]
+      end
+
+      def native_location?(location)
+        location.nil? || location.first.match?(/(<internal:|resource:\/truffleruby\/core)/)
+      end
+    end
+
+    # Registry for patches
+    class Patches
+      attr_reader :extensions, :refined
+
+      def initialize
+        @names = Set.new
+        @extensions = Hash.new { |h, k| h[k] = [] }
+        @refined = Hash.new { |h, k| h[k] = [] }
+      end
+
+      # Register new patch
+      def <<(patch)
+        raise ArgumentError, "Patch already registered: #{patch.name}" if @names.include?(patch.name)
+        @names << patch.name
+        @extensions[patch.mod] << patch if patch.core_ext?
+        patch.refineables.each { |r| @refined[r] << patch } unless patch.native?
+      end
+    end
+
+    class << self
+      STRATEGIES = %i[refine core_ext backports].freeze
+
+      attr_reader :strategy
+
+      def strategy=(val)
+        raise ArgumentError, "Unknown strategy: #{val}. Available: #{STRATEGIES.join(",")}" unless STRATEGIES.include?(val)
+        @strategy = val
+      end
+
+      def refine?
+        strategy == :refine
+      end
+
+      def core_ext?
+        strategy == :core_ext || strategy == :backports
+      end
+
+      def backports?
+        strategy == :backports
+      end
+
+      def patch(*__rest__, &__block__)
+        patches << Patch.new(*__rest__, &__block__)
+      end
+
+      # Inject `using RubyNext` at the top of the source code
+      def inject!(contents)
+        if contents.frozen?
+          contents = contents.sub(/^(\s*[^#\s].*)/, 'using RubyNext;\1')
+        else
+          contents.sub!(/^(\s*[^#\s].*)/, 'using RubyNext;\1')
+        end
+        contents
+      end
+
+      def patches
+        @patches ||= Patches.new
+      end
+    end
+
+    # Use refinements by default
+    self.strategy = ENV.fetch("RUBY_NEXT_CORE_STRATEGY", "refine").to_sym
+  end
+end
+
+require "backports/2.5" if RubyNext::Core.backports?
+
+require "ruby-next/core/kernel/then"
+
+require "ruby-next/core/proc/compose"
+
+require "ruby-next/core/enumerable/tally"
+require "ruby-next/core/enumerable/filter"
+require "ruby-next/core/enumerable/filter_map"
+
+require "ruby-next/core/enumerator/produce"
+
+require "ruby-next/core/array/difference_union_intersection"
+
+require "ruby-next/core/hash/merge"
+
+require "ruby-next/core/string/split"
+
+require "ruby-next/core/symbol/start_with"
+require "ruby-next/core/symbol/end_with"
+
+require "ruby-next/core/unboundmethod/bind_call"
+
+require "ruby-next/core/time/floor"
+require "ruby-next/core/time/ceil"
+
+# Core extensions required for pattern matching
+# Required for pattern matching with refinements
+unless defined?(NoMatchingPatternError)
+  class NoMatchingPatternError < StandardError
+  end
+end
+
+require "ruby-next/core/constants/no_matching_pattern_error"
+require "ruby-next/core/constants/frozen_error"
+require "ruby-next/core/array/deconstruct"
+require "ruby-next/core/hash/deconstruct_keys"
+require "ruby-next/core/struct/deconstruct"
+require "ruby-next/core/struct/deconstruct_keys"
+
+require "ruby-next/core/hash/except"
+
+require "ruby-next/core/array/intersect"
+
+# Generate refinements
+RubyNext.module_eval do
+  RubyNext::Core.patches.refined.each do |mod, patches|
+    # Only refine modules when supported
+    next unless mod.is_a?(Class) || RubyNext::Utils.refine_modules?
+
+    refine mod do
+      patches.each do |patch|
+        module_eval(patch.body, *patch.location)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+gem "ruby-next-parser", ">= 2.8.0.3"
+gem "unparser", ">= 0.4.7"
+
+require "set"
+
+require "ruby-next"
+
+module RubyNext
+  # Language module contains tools to transpile newer Ruby syntax
+  # into an older one.
+  #
+  # It works the following way:
+  #   - Takes a Ruby source code as input
+  #   - Generates the AST using the edge parser (via the `parser` gem)
+  #   - Pass this AST through the list of processors (one feature = one processor)
+  #   - Each processor may modify the AST
+  #   - Generates a transpiled source code from the transformed AST (via the `unparser` gem)
+  module Language
+    using RubyNext
+
+    require "ruby-next/language/parser"
+    require "ruby-next/language/unparser"
+
+    RewriterNotFoundError = Class.new(StandardError)
+
+    class TransformContext
+      attr_reader :versions, :use_ruby_next
+
+      def initialize
+        # Minimum supported RubyNext version
+        @min_version = MIN_SUPPORTED_VERSION
+        @dirty = false
+        @versions = Set.new
+        @use_ruby_next = false
+      end
+
+      # Called by rewriter when it performs transfomrations
+      def track!(rewriter)
+        @dirty = true
+        versions << rewriter.class::MIN_SUPPORTED_VERSION
+      end
+
+      def use_ruby_next!
+        @use_ruby_next = true
+      end
+
+      alias use_ruby_next? use_ruby_next
+
+      def dirty?
+        @dirty == true
+      end
+
+      def min_version
+        versions.min
+      end
+
+      def sorted_versions
+        versions.to_a.sort
+      end
+    end
+
+    class << self
+      attr_accessor :rewriters
+      attr_reader :watch_dirs
+
+      attr_accessor :strategy
+
+      MODES = %i[rewrite ast].freeze
+
+      attr_reader :mode
+
+      def mode=(val)
+        raise ArgumentError, "Unknown mode: #{val}. Available: #{MODES.join(",")}" unless MODES.include?(val)
+        @mode = val
+      end
+
+      def rewrite?
+        mode == :rewrite?
+      end
+
+      def ast?
+        mode == :ast
+      end
+
+      def runtime!
+        require "ruby-next/language/rewriters/runtime"
+
+        @runtime = true
+      end
+
+      def runtime?
+        @runtime
+      end
+
+      def transform(source, rewriters: self.rewriters, using: RubyNext::Core.refine?, context: TransformContext.new)
+        retried = 0
+        new_source = nil
+        begin
+          new_source =
+            if mode == :rewrite
+              rewrite(source, rewriters: rewriters, using: using, context: context)
+            else
+              regenerate(source, rewriters: rewriters, using: using, context: context)
+            end
+        rescue Unparser::UnknownNodeError => err
+          RubyNext.warn "Ruby Next fallbacks to \"rewrite\" transpiling mode since the version of Unparser you use doesn't support some syntax yet: #{err.message}.\n" \
+            "Try upgrading the Unparser or set transpiling mode to \"rewrite\" in case you use some edge or experimental syntax."
+          self.mode = :rewrite
+          retried += 1
+          retry unless retried > 1
+          raise
+        end
+
+        return new_source unless RubyNext::Core.refine?
+        return new_source unless using && context.use_ruby_next?
+
+        Core.inject! new_source.dup
+      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
+
+      # This method guarantees that rewriters will be returned in order they defined in Language module
+      def select_rewriters(*names)
+        rewriters_delta = names - rewriters.map { |rewriter| rewriter::NAME }
+        if rewriters_delta.any?
+          raise RewriterNotFoundError, "Rewriters not found: #{rewriters_delta.join(",")}"
+        end
+
+        rewriters.select { |rewriter| names.include?(rewriter::NAME) }
+      end
+
+      private
+
+      def regenerate(source, rewriters: ::Kernel.raise(::ArgumentError, "missing keyword: rewriters"), using: ::Kernel.raise(::ArgumentError, "missing keyword: using"), context: ::Kernel.raise(::ArgumentError, "missing keyword: context"))
+        parse_with_comments(source).then do |(ast, comments)|
+          rewriters.inject(ast) do |tree, rewriter|
+            rewriter.new(context).process(tree)
+          end.then do |new_ast|
+            next source unless context.dirty?
+
+            Unparser.unparse(new_ast, comments)
+          end
+        end
+      end
+
+      def rewrite(source, rewriters: ::Kernel.raise(::ArgumentError, "missing keyword: rewriters"), using: ::Kernel.raise(::ArgumentError, "missing keyword: using"), context: ::Kernel.raise(::ArgumentError, "missing keyword: context"))
+        rewriters.inject(source) do |src, rewriter|
+          buffer = Parser::Source::Buffer.new("<dynamic>")
+          buffer.source = src
+
+          rewriter.new(context).rewrite(buffer, parse(src))
+        end.then do |new_source|
+          next source unless context.dirty?
+
+          new_source
+        end
+      end
+
+      attr_writer :watch_dirs
+    end
+
+    self.rewriters = []
+    self.watch_dirs = %w[app lib spec test].map { |path| File.join(Dir.pwd, path) }
+    self.mode = ENV.fetch("RUBY_NEXT_TRANSPILE_MODE", "rewrite").to_sym
+
+    require "ruby-next/language/rewriters/base"
+
+    require "ruby-next/language/rewriters/squiggly_heredoc"
+    rewriters << Rewriters::SquigglyHeredoc
+
+    require "ruby-next/language/rewriters/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/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"
+    rewriters << Rewriters::NumberedParams
+
+    require "ruby-next/language/rewriters/pattern_matching"
+    rewriters << Rewriters::PatternMatching
+
+    # Must be added after general pattern matching rewriter to become
+    # no-op in Ruby <2.7
+    require "ruby-next/language/rewriters/find_pattern"
+    rewriters << Rewriters::FindPattern
+
+    require "ruby-next/language/rewriters/in_pattern"
+    rewriters << Rewriters::InPattern
+
+    # Put endless range in the end, 'cause Parser fails to parse it in
+    # pattern matching
+    require "ruby-next/language/rewriters/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"
+    end
+
+    if ENV["RUBY_NEXT_PROPOSED"] == "1"
+      require "ruby-next/language/proposed"
+    end
+  end
+end

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

@@ -57,7 +57,7 @@ module RubyNext
 
           opts.on(
             "--transpile-mode=MODE",
-            "Transpiler mode (ast or rewrite). Default: ast"
+            "Transpiler mode (ast or rewrite). Default: rewrite"
           ) do |val|
             Language.mode = val.to_sym
           end
@@ -95,7 +95,7 @@ module RubyNext
           exit 0
         end
 
-        unless ((!lib_path.nil? || nil) && lib_path.then(&File.method(:exist?)))
+        unless ((((__safe_lvar__ = lib_path) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.then(&File.method(:exist?)))
           $stdout.puts "Path not found: #{lib_path}"
           $stdout.puts optparser.help
           exit 2

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

@@ -8,7 +8,7 @@ module RubyNext
           def eval(source, bind = nil, *args)
             new_source = ::RubyNext::Language::Runtime.transform(
               source,
-              using: ((!bind.nil? || nil) && bind.receiver) == TOPLEVEL_BINDING.receiver || ((!((!bind.nil? || nil) && bind.receiver).nil? || nil) && ((!bind.nil? || nil) && bind.receiver).is_a?(Module))
+              using: ((((__safe_lvar__ = bind) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.receiver) == TOPLEVEL_BINDING.receiver || ((((__safe_lvar__ = ((((__safe_lvar__ = bind) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.receiver)) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.is_a?(Module))
             )
             RubyNext.debug_source(new_source, "(#{caller_locations(1, 1).first})")
             super new_source, bind, *args
@@ -20,7 +20,7 @@ module RubyNext
     module InstanceEval # :nodoc:
       refine Object do
         def instance_eval(*args, &block)
-          return super(*args, &block) if block_given?
+          return super(*args, &block) if block
 
           source = args.shift
           new_source = ::RubyNext::Language::Runtime.transform(source, using: false)
@@ -33,7 +33,7 @@ module RubyNext
     module ClassEval
       refine Module do
         def module_eval(*args, &block)
-          return super(*args, &block) if block_given?
+          return super(*args, &block) if block
 
           source = args.shift
           new_source = ::RubyNext::Language::Runtime.transform(source, using: false)
@@ -42,7 +42,7 @@ module RubyNext
         end
 
         def class_eval(*args, &block)
-          return super(*args, &block) if block_given?
+          return super(*args, &block) if block
 
           source = args.shift
           new_source = ::RubyNext::Language::Runtime.transform(source, using: false)