ruby-next-core 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0456426952d07bcec1db2c70d256177bd8d1503c8edc7e667e2af62bf5f03ae3'
-  data.tar.gz: 4528e483af6cd8cdbf7b613454a0051abd5aaad4ec6cd02c727690d64fbfd848
+  metadata.gz: 18e3905f1324ff7061b59c61aaabd4faf91ff5bcbe2e2896ceda6f2514427b71
+  data.tar.gz: f87cad7947307e13f3da37624eff499f62ae1b8398f902107c8cc7179ee6a5be
 SHA512:
-  metadata.gz: a25d4e8c619b0644f4bcb0f411d0f0c86d1aa7c343ab0e55b42c4d8adad10b2c5c7072ee13f019c9da29223774f6c34c353f58b64f32caf91e60040ec1b029a2
-  data.tar.gz: 02e6e9bdc4379b2542fe6802160f2946ac9d151878bea3f51bcd27da749f7e0bb2cf2891aa0ddf88f5a8221185d8ab9e1bdab4e639de6d69c2a44409e734626c
+  metadata.gz: 4c2530ece05aa6e2bb8e0437f38f5d198a9a081039101ec03c836a01162a92685c5dc6dc2d90f1608c1466002b1afcca3fdf9ddb36774ff1b47a2d438f7cb0ae
+  data.tar.gz: cf6f93b2f8f869354e594ee8e5932acd96ecd78201223a6630f74d6fc13423d220459d9524a81266342f23913304f41a30c3face46be1291022e09b2f15caee3

data/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## master
 
+## 0.5.0 (2020-03-20)
+
+- Add `rewrite` transpiler mode. ([@palkan][])
+
+Add support for rewriting the source code instead of rebuilding it from scratch to
+preserve the original layout and improve the debugging experience.
+
 ## 0.4.0 (2020-03-09)
 
 - Optimize pattern matching transpiled code. ([@palkan][])
@@ -67,7 +74,7 @@ p a #=> 1
 
 - Support hash pattern in array and vice versa. ([@palkan][])
 
-- Handle multile `-e` in `uby-next`. ([@palkan][])
+- Handle multiple `-e` in `uby-next`. ([@palkan][])
 
 ## 0.1.0 (2019-11-16)
 

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2019 Vladimir Dementyev
+Copyright (c) 2019-2020 Vladimir Dementyev
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -24,6 +24,19 @@ That's why Ruby Next implements the `master` features as fast as possible.
 
 - [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)
 
+## Table of contents
+
+- [Overview](#overview)
+- [Polyfills](#using-only-polyfills)
+- [Transpiling](#transpiling)
+  - [Modes](#transpiler-modes)
+  - [CLI](#cli)
+  - [Using in gems](#integrating-into-a-gem-development)
+  - [Runtime usage](#runtime-usage)
+  - [Bootsnap integration](#using-with-bootsnap)
+  - [`ruby -ruby-next`](#uby-next)
+- [Proposed & edge features](#proposed-and-edge-features)
+
 ## Overview
 
 Ruby Next consists of two parts: **core** and **language**.
@@ -75,14 +88,16 @@ require "ruby-next/core_ext"
 The following _rule of thumb_ is recommended when choosing between refinements and monkey-patches:
 
 - Use refinements for libraries development (to avoid conflicts with others code)
-- Using core extensions could be considered for application development (no need to think about `using RubyNext`); this approach could potentially lead to conflicts with dependendices (if these dependencies are not using refinements 🙂)
+- 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
 
 [**The list of supported APIs.**][features_core]
 
-## Transpiling, or using edge Ruby syntax features
+## Transpiling
+
+Ruby Next allows you to transpile\* edge Ruby syntax to older versions.
 
-Ruby Next transpiler relies on two libraries: [parser][] and [unparser][].
+Transpiler relies on two libraries: [parser][] and [unparser][].
 
 **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).
 
@@ -103,40 +118,23 @@ gem install ruby-next
 
 [**The list of supported syntax features.**][features_syntax]
 
-### Integrating into a gem development
+### Transpiler modes
 
-We recommend _pre-transpiling_ source code to work with older versions before releasing it.
+Ruby Next currently provides two different modes of generating transpiled code: _AST_ and _rewrite_.
 
-This is how you can do that with Ruby Next:
+In the AST mode, we parse the source code into AST, modifies this AST and **generate a new code from AST** (using [unparser][unparser]). Thus, the transpiled code being identical in terms of functionality has a different formatting.
 
-- Write source code using the modern/edge Ruby syntax.
+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).
 
-- Generate transpiled code by calling `ruby-next nextify ./lib` (e.g., before releasing or pushing to VCS).
+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.
 
-This will produce `lib/.rbnext` folder containing the transpiled files, `lib/.rbnext/2.6`, `lib/.rbnext/2.7`. The version in the path indicates which Ruby version is required for the original functionality. Only the source files containing new syntax are added to this folder.
+The main benefit of the rewrite mode is that it preserves the original code line numbers and layout, which is especially useful in debugging.
 
-**NOTE:** Do not edit these files manually, either run linters/type checkers/whatever against these files.
+You can change the transpiler mode:
 
-- Add the following code to your gem's _entrypoint_ (the file that is required first and contains other `require`-s):
-
-```ruby
-require "ruby-next/language/setup"
-
-RubyNext::Language.setup_gem_load_path
-```
-
-The `setup_gem_load_path` does the following:
-
-- Resolves the current ruby version.
-- Checks whether there are directories corresponding to the current and earlier\* Ruby versions within the `.rbnext` folder.
-- Add the path to this directory to the `$LOAD_PATH` before the path to the gem's directory.
-
-That's why need an _entrypoint_: all the subsequent `require` calls will load the transpiled files instead of the original ones
-due to the way feature resolving works in Ruby (scanning the `$LOAD_PATH` and halting as soon as the matching file is found).
-
-**NOTE:** `require_relative` should be avoided due to the way we _hijack_ the features loading mechanism.
-
-\* 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).
+- From code by setting `RubyNext::Language.mode = :ast` or `RubyNext::Language.mode = :rewrite`.
+- Via environmental variable `RUBY_NEXT_TRANSPILE_MODE=rewrite`.
+- Via CLI option ([see below](#cli)).
 
 ## CLI
 
@@ -155,6 +153,7 @@ Usage: ruby-next nextify DIRECTORY_OR_FILE [options]
         --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)
+        --transpile-mode=MODE        Transpiler mode (ast or rewrite). Default: ast
         --[no-]refine                Do not inject `using RubyNext`
     -h, --help                       Print help
     -V                               Turn on verbose mode
@@ -191,7 +190,7 @@ Usage: ruby-next core_ext [options]
     -V                               Turn on verbose mode
 ```
 
-The most common usecase is to backport the APIs required by pattern matching. You can do this, for example,
+The most common use-case is to backport the APIs required by pattern matching. You can do this, for example,
 by including only monkey-patches containing the `"deconstruct"` in their names:
 
 ```sh
@@ -215,7 +214,42 @@ $ ruby-next core_ext -l --name=filter --name=deconstruct
   - StructDeconstruct
 ```
 
-## Runtime mode
+### Integrating into a gem development
+
+We recommend _pre-transpiling_ source code to work with older versions before releasing it.
+
+This is how you can do that with Ruby Next:
+
+- Write source code using the modern/edge Ruby syntax.
+
+- Generate transpiled code by calling `ruby-next nextify ./lib` (e.g., before releasing or pushing to VCS).
+
+This will produce `lib/.rbnext` folder containing the transpiled files, `lib/.rbnext/2.6`, `lib/.rbnext/2.7`. The version in the path indicates which Ruby version is required for the original functionality. Only the source files containing new syntax are added to this folder.
+
+**NOTE:** Do not edit these files manually, either run linters/type checkers/whatever against these files.
+
+- Add the following code to your gem's _entrypoint_ (the file that is required first and contains other `require`-s):
+
+```ruby
+require "ruby-next/language/setup"
+
+RubyNext::Language.setup_gem_load_path
+```
+
+The `setup_gem_load_path` does the following:
+
+- Resolves the current ruby version.
+- Checks whether there are directories corresponding to the current and earlier\* Ruby versions within the `.rbnext` folder.
+- Add the path to this directory to the `$LOAD_PATH` before the path to the gem's directory.
+
+That's why need an _entrypoint_: all the subsequent `require` calls will load the transpiled files instead of the original ones
+due to the way feature resolving works in Ruby (scanning the `$LOAD_PATH` and halting as soon as the matching file is found).
+
+**NOTE:** `require_relative` should be avoided due to the way we _hijack_ the features loading mechanism.
+
+\* 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).
+
+## Runtime usage
 
 It is also possible to transpile Ruby source code in run-time via Ruby Next.
 
@@ -270,20 +304,23 @@ RUBYOPT="-ruby-next" ruby my_ruby_script.rb
 ruby -ruby-next -e "puts [2, 4, 5].tally"
 ```
 
-## Unofficial/experimental features
+## Proposed and edge features
 
-Ruby Next also provides support for some features not-yet-merged into Ruby master (or reverted).
+Ruby Next aims to bring edge and proposed features to Ruby community before they (hopefully) reach an official Ruby release.
+This includes:
+
+- Features already merged to [master](https://github.com/ruby/ruby) (_edge_)
+- Features proposed in [Ruby bug tracker](https://bugs.ruby-lang.org/) (_proposed_)
+- Features once merged to master but got 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):
+Currently, 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.

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

@@ -43,6 +43,13 @@ module RubyNext
             Language.rewriters << Language::Rewriters::MethodReference
           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

data/lib/ruby-next/core.rb

@@ -132,7 +132,7 @@ module RubyNext
     end
 
     # Use refinements by default
-    self.strategy = :refine
+    self.strategy = ENV.fetch("RUBY_NEXT_CORE_STRATEGY", "refine").to_sym
   end
 end
 

data/lib/ruby-next/language.rb

@@ -63,14 +63,41 @@ module RubyNext
       attr_accessor :rewriters
       attr_reader :watch_dirs
 
-      def transform(source, rewriters: self.rewriters, using: RubyNext::Core.refine?, context: TransformContext.new)
-        parse(source).then do |ast|
+      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 transform(*args, **kwargs)
+        if mode == :rewrite
+          rewrite(*args, **kwargs)
+        else
+          regenerate(*args, **kwargs)
+        end
+      end
+
+      def regenerate(source, rewriters: self.rewriters, using: RubyNext::Core.refine?, context: TransformContext.new)
+        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)
+            Unparser.unparse(new_ast, comments)
           end.then do |source|
             next source unless RubyNext::Core.refine?
             next source unless using && context.use_ruby_next?
@@ -80,6 +107,23 @@ module RubyNext
         end
       end
 
+      def rewrite(source, rewriters: self.rewriters, using: RubyNext::Core.refine?, context: TransformContext.new)
+        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.then do |source|
+          next source unless RubyNext::Core.refine?
+          next source unless using && context.use_ruby_next?
+
+          Core.inject! source.dup
+        end
+      end
+
       def transformable?(path)
         watch_dirs.any? { |dir| path.start_with?(dir) }
       end
@@ -96,21 +140,24 @@ module RubyNext
 
     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", "ast").to_sym
 
     require "ruby-next/language/rewriters/base"
 
-    require "ruby-next/language/rewriters/endless_range"
-    rewriters << Rewriters::EndlessRange
-
-    require "ruby-next/language/rewriters/pattern_matching"
-    rewriters << Rewriters::PatternMatching
-
     require "ruby-next/language/rewriters/args_forward"
     rewriters << Rewriters::ArgsForward
 
     require "ruby-next/language/rewriters/numbered_params"
     rewriters << Rewriters::NumberedParams
 
+    require "ruby-next/language/rewriters/pattern_matching"
+    rewriters << Rewriters::PatternMatching
+
+    # 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
+
     if ENV["RUBY_NEXT_ENABLE_METHOD_REFERENCE"] == "1"
       require "ruby-next/language/rewriters/method_reference"
       RubyNext::Language.rewriters << RubyNext::Language::Rewriters::MethodReference

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

@@ -21,8 +21,17 @@ module RubyNext
         buffer = ::Parser::Source::Buffer.new(file).tap do |buffer|
           buffer.source = source
         end
+
         parser.parse(buffer)
       end
+
+      def parse_with_comments(source, file = "(string)")
+        buffer = ::Parser::Source::Buffer.new(file).tap do |buffer|
+          buffer.source = source
+        end
+
+        parser.parse_with_comments(buffer)
+      end
     end
   end
 end

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

@@ -13,6 +13,8 @@ module RubyNext
         def on_forward_args(node)
           context.track! self
 
+          replace(node.loc.expression, "(*#{REST}, &#{BLOCK})")
+
           node.updated(
             :args,
             [
@@ -25,6 +27,8 @@ module RubyNext
         def on_send(node)
           return unless node.children[2]&.type == :forwarded_args
 
+          replace(node.children[2].loc.expression, "*#{REST}, &#{BLOCK}")
+
           node.updated(
             nil,
             [
@@ -37,6 +41,8 @@ module RubyNext
         def on_super(node)
           return unless node.children[0]&.type == :forwarded_args
 
+          replace(node.children[0].loc.expression, "*#{REST}, &#{BLOCK}")
+
           node.updated(
             nil,
             forwarded_args

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

@@ -98,6 +98,27 @@ module RubyNext
 
         private
 
+        def replace(range, ast)
+          @source_rewriter&.replace(range, unparse(ast))
+        end
+
+        def remove(range)
+          @source_rewriter&.remove(range)
+        end
+
+        def insert_after(range, ast)
+          @source_rewriter&.insert_after(range, unparse(ast))
+        end
+
+        def insert_before(range, ast)
+          @source_rewriter&.insert_before(range, unparse(ast))
+        end
+
+        def unparse(ast)
+          return ast if ast.is_a?(String)
+          Unparser.unparse(ast)
+        end
+
         attr_reader :context
       end
     end

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

@@ -36,6 +36,8 @@ module RubyNext
                 :INFINITY)
             end
 
+          replace(node.loc.expression, "#{node.children.first.loc.expression.source}..#{unparse(new_end)}")
+
           node.updated(
             :irange,
             [

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

@@ -12,6 +12,13 @@ module RubyNext
 
           receiver, mid = *node.children
 
+          replace(
+            node.children.first.loc.expression.end.join(
+              node.loc.expression.end
+            ),
+            ".method(:#{mid})"
+          )
+
           node.updated(
             :send,
             [

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

@@ -12,14 +12,20 @@ module RubyNext
         def on_numblock(node)
           context.track! self
 
-          proc_or_lambda, num, *rest = *node.children
+          proc_or_lambda, num, body = *node.children
+
+          if proc_or_lambda.type == :lambda
+            insert_before(node.loc.begin, "(#{unparse(proc_args(num))})")
+          else
+            insert_after(node.loc.begin, " |#{unparse(proc_args(num))}|")
+          end
 
           node.updated(
             :block,
             [
               proc_or_lambda,
               proc_args(num),
-              *rest
+              body
             ]
           )
         end

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

@@ -240,16 +240,17 @@ module RubyNext
             arr: MATCHEE_ARR,
             hash: MATCHEE_HASH
           ) do
-            build_if_clause(node.children[1], node.children[2..-1])
+            build_case_when(node.children[1..-1])
           end
 
-          # remove unused predicate assignments and truthy expressions
-          patterns = predicates.process(patterns)
+          case_clause = predicates.process(s(:case, *patterns))
+
+          rewrite_case_in! node, matchee_ast, case_clause
 
           node.updated(
             :begin,
             [
-              matchee_ast, patterns
+              matchee_ast, case_clause
             ]
           )
         end
@@ -285,26 +286,67 @@ module RubyNext
               matchee,
               pattern
             ]
-          )
+          ).tap do |new_node|
+            replace(node.loc.expression, new_node)
+          end
         end
 
         private
 
-        def build_if_clause(node, rest)
-          if node&.type == :in_pattern
-            predicates.reset!
-            build_in_pattern(node, rest)
-          else
-            raise "Unexpected else in the middle of case ... in" if rest && rest.size > 0
-            # else clause must be present
-            (process(node) || no_matching_pattern).then do |else_node|
-              next else_node unless else_node.type == :empty_else
-              s(:empty)
+        def rewrite_case_in!(node, matchee, new_node)
+          replace(node.loc.keyword, "case; when (#{unparse(matchee)}) && false")
+          remove(node.children[0].loc.expression)
+
+          node.children[1..-1].each.with_index do |clause, i|
+            if clause&.type == :in_pattern
+              # handle multiline clauses differently
+              if clause.loc.last_line > clause.children[0].loc.last_line + 1
+                height = clause.loc.last_line - clause.children[0].loc.last_line
+                padding = "\n" * height
+                body_indent = " " * clause.children[2].loc.column
+                replace(
+                  clause.loc.expression,
+                  "when #{unparse(new_node.children[i].children[0])}" \
+                  "#{padding}" \
+                  "#{body_indent}#{clause.children[2].loc.expression.source}"
+                )
+              else
+                replace(
+                  clause.loc.keyword.end.join(clause.children[0].loc.expression.end),
+                  new_node.children[i].children[0]
+                )
+                remove(clause.children[1].loc.expression) if clause.children[1]
+                replace(clause.loc.keyword, "when ")
+              end
+            elsif clause.nil?
+              insert_after(node.children[-2].loc.expression, "; else; #{unparse(new_node.children.last)}")
             end
           end
         end
 
-        def build_in_pattern(clause, rest)
+        def build_case_when(nodes)
+          else_clause = nil
+          clauses = []
+
+          nodes.each do |clause|
+            if clause&.type == :in_pattern
+              clauses << build_when_clause(clause)
+            else
+              else_clause = process(clause)
+            end
+          end
+
+          else_clause = (else_clause || no_matching_pattern).then do |node|
+            next node unless node.type == :empty_else
+            s(:empty)
+          end
+
+          clauses << else_clause
+          clauses
+        end
+
+        def build_when_clause(clause)
+          predicates.reset!
           [
             with_guard(
               send(
@@ -315,11 +357,7 @@ module RubyNext
             ),
             process(clause.children[2] || s(:nil)) # expression
           ].then do |children|
-            if rest && rest.size > 0
-              children << build_if_clause(rest.first, rest[1..-1])
-            end
-
-            s(:if, *children)
+            s(:when, *children)
           end
         end
 

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

@@ -24,7 +24,7 @@ module RubyNext
 
           $stdout.puts source_with_lines(new_contents, path) if ENV["RUBY_NEXT_DEBUG"] == "1"
 
-          TOPLEVEL_BINDING.eval(new_contents, path)
+          evaluate(new_contents, path)
           true
         end
 
@@ -39,6 +39,25 @@ module RubyNext
           return unless Language.transformable?(path)
           path
         end
+
+        if defined?(JRUBY_VERSION)
+          def evaluate(code, filepath)
+            new_toplevel.eval(code, filepath)
+          end
+
+          def new_toplevel
+            # Create new "toplevel" binding to avoid lexical scope re-use
+            # (aka "leaking refinements")
+            eval "proc{binding}.call", TOPLEVEL_BINDING, __FILE__, __LINE__
+          end
+        else
+          def evaluate(code, filepath)
+            # This is workaround to solve the "leaking refinements" problem in MRI
+            RubyVM::InstructionSequence.compile(code, filepath).then do |iseq|
+              iseq.eval
+            end
+          end
+        end
       end
     end
   end

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

@@ -19,6 +19,8 @@ module RubyNext
           dirname = File.dirname(basename)
         end
 
+        dirname = File.realpath(dirname)
+
         current_index = $LOAD_PATH.index(dirname)
 
         raise "Gem's lib is not in the $LOAD_PATH: #{dirname}" if current_index.nil?

data/lib/ruby-next/utils.rb

@@ -20,7 +20,7 @@ module RubyNext
 
         $LOAD_PATH.find do |lp|
           lpath = File.join(lp, path)
-          return lpath if File.file?(lpath)
+          return File.realpath(lpath) if File.file?(lpath)
         end
       end
     end

data/lib/ruby-next/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-next-core
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Vladimir Dementyev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-09 00:00:00.000000000 Z
+date: 2020-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.7.0.0
+        version: 2.7.0.5
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.7.0.0
+        version: 2.7.0.5
 - !ruby/object:Gem::Dependency
   name: unparser
   requirement: !ruby/object:Gem::Requirement