[ruby-core:114867] [Ruby master Feature#19889] Let `Kernel.#require` search for files relative to the current working directory for non ./, ../ relative paths

Issue #19889 has been updated by rubyFeedback (robert heiler).


sawa wrote:

> This situation is making the specification of require versus require_relative
> difficult to understand, as well as causing inconvenience.

I kind of stay(ed) with require and almost never use require_relative. So for me
at the least it is not really an issue. Other ruby devs use require_relative
fine in their gems and code. I guess it is a matter of preference and how you
want to work with extension-code you write in ruby. For me it seemed easier to
think of every extensions as a gem, at the least when possible, and there I 
can do require 'name_of_the_gem/first_file_to_load.rb', which then may load
all the other .rb files.

As for ./ and ../ - I kind of try to ignore them completely, and when I get
a listing of a directory content or absolute path, I try to always store 
directories, or rather name of directories, with a trailing '/'. My mind just
prefers to see a trailing '/' whenever I work with a directory.

In many of my projects, under base/base.rb, I tend to add a method such as 
"def pwd" or "def return_pwd", that is basically Dir.pwd but also ensures
there is one trailing /. This may seem rather pointless, but I kind of like 
to use it consistently, and not rely on Dir.pwd directly. I also try to use
File.absolute_path() when it is feasible, even if it may not be absolutely
necessary. It just seems easier for me to rely on such awkward patterns.

On the other hand I (almost) never modify $LOAD_PATH; I think I only do so
for irbrc or so; other than that I try to just let ruby handle $LOAD_PATH
for me. At the least most of the time.

sawa wrote:

> Proposal: For non-./-or-../ relative paths, I propose to let Kernel.#require
> search relative to the current working directory if the file is not found
> relative to the paths in $LOAD_PATH, so that the methods load, require,
> and require_relative all work the same in this respect.

I somewhat understand the thought process here, even more so as I myself try
to avoid require_relative. :) But I think, people can use just require() too,
or? For some of the ruby code I use locally, such as, a simple example, the file at strategeme/strategeme.rb, I have:

    require_relative 'common.rb'

And this is then a local .rb file I use to power all the other ruby code 
that is solely for local use. The rest I tend to publish freely available
on rubygems.org, where I don't need to use require_relative. 

Interestingly some ruby gems seem to prefer require_relative, e. g.
webrick:

    httpservlet.rb # require_relative 'httpservlet/filehandler'

In such cases I just use require directly rather than require_relative.
But functionality-wise, I think both achieve just about the same?


----------------------------------------
Feature #19889: Let `Kernel.#require` search for files relative to the current working directory for non ./, ../ relative paths
https://bugs.ruby-lang.org/issues/19889#change-104715

* Author: sawa (Tsuyoshi Sawada)
* Status: Feedback
* Priority: Normal
----------------------------------------
My understanding is that `./` and `../` in the given path argument are interpreted relative to:

(1)
* The current working directory (for `load` or `require`)
* The requiring file's path (for `require_relative`)

which shows a division of labor between the methods, and seems reasonable. However, when it comes to other relative paths (e.g., `foo/bar.rb`), they are interpreted relative to:

(2)
* Paths in `$LOAD_PATH` (for `require`)
* Paths in `$LOAD_PATH` or **the current working directory** (for `load` or `require_relative`)

For example, given:

* File `some_path/foo/a.rb`
* File `some_path/b.rb` with content `require "foo/a"`
* Current directory at `some_path`,

running `ruby b.rb` raises a `LoadError`, but given:

* File `some_path/foo/a.rb`
* File `some_path/b.rb` with content ` require_relative "foo/a"`
* Current directory at `some_path`,

running `ruby b.rb` does not raise an error.

The search path in (2) for `require` is a proper subset of that of `load` and `require_relative`. There is no division of labor here; there is only inconvenience for `require`.

Furthermore, in (1), `require` (as well as `load`) is concerned with the current working directory while `require_relative` is not, but in (2), the relation is reversed: `require_relative` (as well as `load`) is concerned with the current working directory while `require` is not.

This situation is making the specification of `require` versus `require_relative` difficult to understand, as well as causing inconvenience.

**Proposal**: For non-`./`-or-`../` relative paths, I propose to let `Kernel.#require` search relative to the current working directory if the file is not found relative to the paths in `$LOAD_PATH`, so that the methods `load`, `require`, and `require_relative` all work the same in this respect.



-- 
https://bugs.ruby-lang.org/
 ______________________________________________
 ruby-core mailing list -- [e-mail]
 To unsubscribe send an email to [e-mail]
 ruby-core info -- https://ml.ruby-lang.org/mailman3/postorius/lists/ruby-core.ml.ruby-lang.org/