Issue #10320 has been updated by Jrg W Mittag. Nobuyoshi Nakada wrote: > I think this feature should be an instance method of `Module`, similar to `load` rather than `require`. Yes, I believe having `Module#load` and possibly `Module#require` and `Module#require_relative` would be the most logical: ~~~ruby # not namespaced: require 'foo' module Bar;end # namespaced: module Bar require 'foo' end ~~~ Re-using those names would be a backwards-incompatible change, though. I have seen people use the second form sometimes. This is a replacement for the hard-to-use `wrap` optional argument to `Kernel#load`: ~~~ruby load 'foo', true # is almost equivalent to Module.new.load 'foo' ~~~ This can be naturally extended to `Binding#load`, `Binding#require`, and `Binding#require_relative`. As with the `wrap` argument to `Kernel#load`, the question is, what should references like `::String` in the loaded script refer to? I think it would be nice if it offered *complete* isolation by default, with an option to revert to the current behavior of `load`, e.g. with an API like this: ~~~ruby class Module def load(path, pollute_global: false) end end ~~~ ---------------------------------------- Feature #10320: require into module https://bugs.ruby-lang.org/issues/10320#change-56209 * Author: So Wieso * Status: Open * Priority: Normal * Assignee: ---------------------------------------- When requiring a library, global namespace always gets polluted, at least with one module name. So when requiring a gem with many dependencies, at least one constant enters global namespace per dependency, which can easily get out of hand (especially when gems are not enclosed in a module). Would it be possible to extend require (and load, require_relative) to put all content into a custom module and not into global namespace? Syntax ideas: ~~~ruby require 'libfile', into: :Lib # keyword-argument require 'libfile' in Lib # with keyword, also defining a module Lib at current binding (unless defined? Lib) require_qualified 'libfile', :Lib ~~~ This would also make including code into libraries much easier, as it is well scoped. ~~~ruby module MyGem require 'needed' in Need def do_something Need::important.process! end end # library user is never concerned over needed's content ~~~ Some problems to discuss: * requiring into two different modules means loading the file twice? * monkeypatching libraries should only affect the module вк auto refinements? * maybe also allow a binding as argument, not only a module? * privately require, so that required constants and methods are not accessible from the outside of a module (seems to difficult) * what about $global constants, read them from global scope but copy-write them only to local scope? Similar issue: https://bugs.ruby-lang.org/issues/5643 -- https://bugs.ruby-lang.org/ Unsubscribe: <mailto:ruby-core-request / ruby-lang.org?subject=unsubscribe> <http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>