December 2024 - ruby-core - ml.ruby-lang.org

[ruby-core:120266] [Ruby master Feature#6648] Provide a standard API for retrieving all command-line flags passed to Ruby
by Dan0042 (Daniel DeLorme) 16 Dec '24

16 Dec '24

Issue #6648 has been updated by Dan0042 (Daniel DeLorme). deivid (David Rodríguez) wrote in #note-48: > In the case of Bundler, we would use this feature when we detect that a different version of Bundler is running than the one in the `Gemfile.lock` file. In that case, we would do some environment manipulation to make sure the locked version is actually used in a subsequent process, and then re-run the original process. In our case, I think it would only make sense to re-run the original command in the original directory. I don't follow the logic here. You would re-run the original command in the original directory, just so that it can change back to the directory specified by `-C`. What for? Why not just stay in the CWD if you're going to wind up back there anyway? What's the point of using `Process.original_working_directory` and `-C` to cancel each other? Oh, and here's an interesting tidbit I just learned that might impact how to handle this: Ruby loads the script *after* changing to the dir specified by `-C`. That means `ruby -C foo x.rb` loads the script `foo/x.rb`. And when you re-execute you have to be in directory `foo` (or expand the script path). ---------------------------------------- Feature #6648: Provide a standard API for retrieving all command-line flags passed to Ruby https://bugs.ruby-lang.org/issues/6648#change-111033 * Author: headius (Charles Nutter) * Status: Assigned * Assignee: matz (Yukihiro Matsumoto) ---------------------------------------- Currently there are no standard mechanisms to get the flags passed to the currently running Ruby implementation. The available mechanisms are not ideal: * Scanning globals and hoping they have not been tweaked to new settings * Using external wrappers to launch Ruby * ??? Inability to get the full set of command-line flags, including flags passed to the VM itself (and probably VM-specific) makes it impossible to launch subprocess Ruby instances with the same settings. A real world example of this is "((%bundle exec%))" when called with a command line that sets various flags, a la ((%jruby -Xsome.vm.setting --1.9 -S bundle exec%)). None of these flags can propagate to the subprocess, so odd behaviors result. The only option is to put the flags into an env var (((|JRUBY_OPTS|)) or ((|RUBYOPT|))) but this breaks the flow of calling a simple command line. JRuby provides mechanisms to get all its command line options, but they require calling Java APIs from Ruby's API set. Rubinius provides its own API for accessing comand-line options, but I do not know if it includes VM-level flags as well as standard Ruby flags. I know there is a (({RubyVM})) namespace in the 2.0 line. If that namespace is intended to be general-purpose for VM-level features, it would be a good host for this API. Something like... ``` class << RubyVM def vm_args; end # returns array of command line args *not* passed to the target script def script; end # returns the script being executed...though this overlaps with $0 def script_args; end # returns args passed to the script...though this overlaps with ARGV, but that is perhaps warranted since ARGV can be modified (i.e. you probably want the original args) end ``` -- https://bugs.ruby-lang.org/

1 0

[ruby-core:120265] [Ruby master Feature#6648] Provide a standard API for retrieving all command-line flags passed to Ruby
by deivid 16 Dec '24

16 Dec '24

Issue #6648 has been updated by deivid (David Rodríguez). I agree with @Eregon and I believe ideally we would store `-C` in `ruby_args` but also provide a way to access the original working directory. That way people can choose where to re-run the original command. In the case of Bundler, we would use this feature when we detect that a different version of Bundler is running than the one in the `Gemfile.lock` file. In that case, we would do some environment manipulation to make sure the locked version is actually used in a subsequent process, and then re-run the original process. In our case, I think it would only make sense to re-run the original command in the original directory. Alternatively, we could do some manipulation of original `-C` arguments to expand them to a single value with the absolute path where Ruby ends up running. But I like the `Process.original_working_directory` idea better. ---------------------------------------- Feature #6648: Provide a standard API for retrieving all command-line flags passed to Ruby https://bugs.ruby-lang.org/issues/6648#change-111032 * Author: headius (Charles Nutter) * Status: Assigned * Assignee: matz (Yukihiro Matsumoto) ---------------------------------------- Currently there are no standard mechanisms to get the flags passed to the currently running Ruby implementation. The available mechanisms are not ideal: * Scanning globals and hoping they have not been tweaked to new settings * Using external wrappers to launch Ruby * ??? Inability to get the full set of command-line flags, including flags passed to the VM itself (and probably VM-specific) makes it impossible to launch subprocess Ruby instances with the same settings. A real world example of this is "((%bundle exec%))" when called with a command line that sets various flags, a la ((%jruby -Xsome.vm.setting --1.9 -S bundle exec%)). None of these flags can propagate to the subprocess, so odd behaviors result. The only option is to put the flags into an env var (((|JRUBY_OPTS|)) or ((|RUBYOPT|))) but this breaks the flow of calling a simple command line. JRuby provides mechanisms to get all its command line options, but they require calling Java APIs from Ruby's API set. Rubinius provides its own API for accessing comand-line options, but I do not know if it includes VM-level flags as well as standard Ruby flags. I know there is a (({RubyVM})) namespace in the 2.0 line. If that namespace is intended to be general-purpose for VM-level features, it would be a good host for this API. Something like... ``` class << RubyVM def vm_args; end # returns array of command line args *not* passed to the target script def script; end # returns the script being executed...though this overlaps with $0 def script_args; end # returns args passed to the script...though this overlaps with ARGV, but that is perhaps warranted since ARGV can be modified (i.e. you probably want the original args) end ``` -- https://bugs.ruby-lang.org/

1 0

[ruby-core:119925] [Ruby master Feature#20893] random/formatter.rb: Separate from securerandom
by nobu (Nobuyoshi Nakada) 16 Dec '24

16 Dec '24

Issue #20893 has been reported by nobu (Nobuyoshi Nakada). ---------------------------------------- Feature #20893: random/formatter.rb: Separate from securerandom https://bugs.ruby-lang.org/issues/20893 * Author: nobu (Nobuyoshi Nakada) * Status: Open * Assignee: matz (Yukihiro Matsumoto) ---------------------------------------- For historical reasons, random/formatter.rb is included in ruby/securerandom, but it does not contain any security-related methods as evidenced by the fact that its path is not under `securerandom/`, but only contains generic methods for PRNGs, including the standard class `Random`. So I propose to either: 1. put it back in the standard library, or 2. separate it into a new gem. Adding a new dependency may not be welcomed, as seen in the recent issues with base64. -- https://bugs.ruby-lang.org/

2 3

[ruby-core:120251] [Ruby master Bug#20954] Ractor.main? returns 0 on the main ractor
by zverok (Victor Shepelev) 15 Dec '24

15 Dec '24

Issue #20954 has been reported by zverok (Victor Shepelev). ---------------------------------------- Bug #20954: Ractor.main? returns 0 on the main ractor https://bugs.ruby-lang.org/issues/20954 * Author: zverok (Victor Shepelev) * Status: Open * ruby -v: 3.4.0dev (2024-12-15T13:36:38Z master 366fd9642f) +PRISM [x86_64-linux] * Backport: 3.1: DONTNEED, 3.2: DONTNEED, 3.3: DONTNEED ---------------------------------------- Very minor (as the value is still truthy) but slightly confusing. ```ruby Ractor.main? #=> 0 ``` ``` $ ruby -v ruby 3.4.0dev (2024-12-15T13:36:38Z master 366fd9642f) +PRISM [x86_64-linux] ``` -- https://bugs.ruby-lang.org/

2 1

[ruby-core:117657] [Ruby master Bug#20447] Ruby 3.3.1 broken on i686
by vo.x (Vit Ondruch) 15 Dec '24

15 Dec '24

Issue #20447 has been reported by vo.x (Vit Ondruch). ---------------------------------------- Bug #20447: Ruby 3.3.1 broken on i686 https://bugs.ruby-lang.org/issues/20447 * Author: vo.x (Vit Ondruch) * Status: Open * ruby -v: ruby 3.3.1 (2024-04-23 revision c56cd86388) [i686-linux] * Backport: 3.0: UNKNOWN, 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN ---------------------------------------- ~~~ gcc -O2 -flto=auto -ffat-lto-objects -fexceptions -g -grecord-gcc-switches -pipe -Wall -Werror=format-security -Wp,-U_FORTIFY_SOURCE,-D_FORTIFY_SOURCE=3 -Wp,-D_GLIBCXX_ASSERTIONS -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -fstack-protector-strong -specs=/usr/lib/rpm/redhat/redhat-annobin-cc1 -march=i686 -mtune=generic -msse2 -mfpmath=sse -mstackrealign -fasynchronous-unwind-tables -fstack-clash-protection -fPIC -m32 -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2 -fstack-protector-strong -fno-strict-overflow -fvisibility=hidden -fexcess-precision=standard -DRUBY_EXPORT -I. -I.ext/include/i386-linux -I/builddir/build/BUILD/ruby-3.3.1/include -I/builddir/build/BUILD/ruby-3.3.1 -I/builddir/build/BUILD/ruby-3.3.1/prism -I/builddir/build/BUILD/ruby-3.3.1/enc/unicode/15.0.0 -o time.o -c /builddir/build/BUILD/ruby-3.3.1/time.c make: Leaving directory '/builddir/build/BUILD/ruby-3.3.1/redhat-linux-build' /builddir/build/BUILD/ruby-3.3.1/time.c: In function ‘zone_timelocal’: /builddir/build/BUILD/ruby-3.3.1/time.c:2345:35: error: passing argument 3 of ‘split_second’ from incompatible pointer type [-Wincompatible-pointer-types] 2345 | split_second(tobj->timew, &t, &s); | ^~ | | | wideval_t * {aka long long unsigned int *} /builddir/build/BUILD/ruby-3.3.1/time.c:616:58: note: expected ‘VALUE *’ {aka ‘long unsigned int *’} but argument is of type ‘wideval_t *’ {aka ‘long long unsigned int *’} 616 | split_second(wideval_t timew, wideval_t *timew_p, VALUE *subsecx_p) | ~~~~~~~^~~~~~~~~ make: *** [Makefile:447: time.o] Error 1 make: *** Waiting for unfinished jobs.... make: Entering directory '/builddir/build/BUILD/ruby-3.3.1/redhat-linux-build' ~~~ This is presumably due to #20327 / https://github.com/ruby/ruby/pull/10332. There seems to be medicine in master commit:git|055613fd868a8c94e43893f8c58a00cdd2a81f6d or maybe the whole https://github.com/ruby/ruby/pull/10332, not sure -- https://bugs.ruby-lang.org/

8 14

[ruby-core:120242] [Ruby master Feature#6648] Provide a standard API for retrieving all command-line flags passed to Ruby
by Dan0042 (Daniel DeLorme) 14 Dec '24

14 Dec '24

Issue #6648 has been updated by Dan0042 (Daniel DeLorme). I'm in favor of not storing `-C` in ruby_args. In general, `-C` is mutually exclusive with the program doing its own `Dir.chdir`. Either the program changes its working directory to "x", or if it doesn't then you'd use `-C x` as a workaround. In the odd case that both `-C dir1` and `Dir.chdir("dir2")` are used, I think that "dir2" should be the one used in subsequent #exec calls. But ideally we would have some real-world examples of how `-C` is used in order to guide this decision. ---------------------------------------- Feature #6648: Provide a standard API for retrieving all command-line flags passed to Ruby https://bugs.ruby-lang.org/issues/6648#change-111010 * Author: headius (Charles Nutter) * Status: Assigned * Assignee: matz (Yukihiro Matsumoto) ---------------------------------------- Currently there are no standard mechanisms to get the flags passed to the currently running Ruby implementation. The available mechanisms are not ideal: * Scanning globals and hoping they have not been tweaked to new settings * Using external wrappers to launch Ruby * ??? Inability to get the full set of command-line flags, including flags passed to the VM itself (and probably VM-specific) makes it impossible to launch subprocess Ruby instances with the same settings. A real world example of this is "((%bundle exec%))" when called with a command line that sets various flags, a la ((%jruby -Xsome.vm.setting --1.9 -S bundle exec%)). None of these flags can propagate to the subprocess, so odd behaviors result. The only option is to put the flags into an env var (((|JRUBY_OPTS|)) or ((|RUBYOPT|))) but this breaks the flow of calling a simple command line. JRuby provides mechanisms to get all its command line options, but they require calling Java APIs from Ruby's API set. Rubinius provides its own API for accessing comand-line options, but I do not know if it includes VM-level flags as well as standard Ruby flags. I know there is a (({RubyVM})) namespace in the 2.0 line. If that namespace is intended to be general-purpose for VM-level features, it would be a good host for this API. Something like... ``` class << RubyVM def vm_args; end # returns array of command line args *not* passed to the target script def script; end # returns the script being executed...though this overlaps with $0 def script_args; end # returns args passed to the script...though this overlaps with ARGV, but that is perhaps warranted since ARGV can be modified (i.e. you probably want the original args) end ``` -- https://bugs.ruby-lang.org/

1 0

[ruby-core:120213] [Ruby master Bug#20948] Constant references incorrectly cached in `module (expr)::Foo`
by mame (Yusuke Endoh) 14 Dec '24

14 Dec '24

Issue #20948 has been reported by mame (Yusuke Endoh). ---------------------------------------- Bug #20948: Constant references incorrectly cached in `module (expr)::Foo` https://bugs.ruby-lang.org/issues/20948 * Author: mame (Yusuke Endoh) * Status: Assigned * Assignee: ko1 (Koichi Sasada) * Backport: 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN ---------------------------------------- ```ruby module M1 module Foo X = 1 end end module M2 module Foo X = 2 end end [M1, M2].each do module it::Foo p X #=> expected: prints "1" then "2"; actual: prints "1" twice end end ```` To be honest, I don't think it's worth slowing down the processor for this, but I create a ticket since I discovered it and since ko1 seemed to have a bit of an idea of how to solve it. -- https://bugs.ruby-lang.org/

2 1

[ruby-core:120240] [Ruby master Feature#6648] Provide a standard API for retrieving all command-line flags passed to Ruby
by Eregon (Benoit Daloze) 14 Dec '24

14 Dec '24

Issue #6648 has been updated by Eregon (Benoit Daloze). nobu (Nobuyoshi Nakada) wrote in #note-45: > Removed or renamed. > It can rerun fine by removing `-C` options and staying in the current directory. But current directory might have changed e.g. by `Dir.chdir`, so using `Dir.pwd` (explicitly or implicitly) is no good, it's the same as ARGV vs "original ARGV". From that I think it's clear we should save the original arguments (Ruby options and Ruby user arguments) as well as the original CWD (as a String). Of course in the worst case CWD might no longer exist/renamed or even `.../bin/ruby` has been removed, but those are not the cases we are interested in with this feature (there are intrinsic limitations, they are fine). ---------------------------------------- Feature #6648: Provide a standard API for retrieving all command-line flags passed to Ruby https://bugs.ruby-lang.org/issues/6648#change-111008 * Author: headius (Charles Nutter) * Status: Assigned * Assignee: matz (Yukihiro Matsumoto) ---------------------------------------- Currently there are no standard mechanisms to get the flags passed to the currently running Ruby implementation. The available mechanisms are not ideal: * Scanning globals and hoping they have not been tweaked to new settings * Using external wrappers to launch Ruby * ??? Inability to get the full set of command-line flags, including flags passed to the VM itself (and probably VM-specific) makes it impossible to launch subprocess Ruby instances with the same settings. A real world example of this is "((%bundle exec%))" when called with a command line that sets various flags, a la ((%jruby -Xsome.vm.setting --1.9 -S bundle exec%)). None of these flags can propagate to the subprocess, so odd behaviors result. The only option is to put the flags into an env var (((|JRUBY_OPTS|)) or ((|RUBYOPT|))) but this breaks the flow of calling a simple command line. JRuby provides mechanisms to get all its command line options, but they require calling Java APIs from Ruby's API set. Rubinius provides its own API for accessing comand-line options, but I do not know if it includes VM-level flags as well as standard Ruby flags. I know there is a (({RubyVM})) namespace in the 2.0 line. If that namespace is intended to be general-purpose for VM-level features, it would be a good host for this API. Something like... ``` class << RubyVM def vm_args; end # returns array of command line args *not* passed to the target script def script; end # returns the script being executed...though this overlaps with $0 def script_args; end # returns args passed to the script...though this overlaps with ARGV, but that is perhaps warranted since ARGV can be modified (i.e. you probably want the original args) end ``` -- https://bugs.ruby-lang.org/

1 0

[ruby-core:120133] [Ruby master Feature#20935] API for Globally Enabling/Disabling Happy Eyeballs Version 2 in the Socket Class
by shioimm (Misaki Shioi) 14 Dec '24

14 Dec '24

Issue #20935 has been reported by shioimm (Misaki Shioi). ---------------------------------------- Feature #20935: API for Globally Enabling/Disabling Happy Eyeballs Version 2 in the Socket Class https://bugs.ruby-lang.org/issues/20935 * Author: shioimm (Misaki Shioi) * Status: Open ---------------------------------------- When introducing Happy Eyeballs Version 2 to `Socket.tcp` (https://bugs.ruby-lang.org/issues/20108) it was pointed out that there should be a way to disable this feature (https://bugs.ruby-lang.org/issues/20108#note-7) To address this, I added `fast_fallback: true or false` keyword argument to both `Socket.tcp` and `TCPSocket.new`. Additionally, I introduced two singleton methods to the `Socket` class: `tcp_fast_fallback=` and `tcp_fast_fallback`. These can be used as follows: ```ruby Socket.tcp(host, port, fast_fallback: true) TCPSocket.new(host, port, fast_fallback: true) # Globally controlling HEv2 Socket.tcp_fast_fallback = true # => true Socket.tcp_fast_fallback # => true ``` I apologize for this after the implementation, but I would like to discuss whether adding these APIs is appropriate. -- https://bugs.ruby-lang.org/

2 2

[ruby-core:119852] [Ruby master Feature#20882] Provide Boolean(...)
by getajobmike (Mike Perham) 14 Dec '24

14 Dec '24

Issue #20882 has been reported by getajobmike (Mike Perham). ---------------------------------------- Feature #20882: Provide Boolean(...) https://bugs.ruby-lang.org/issues/20882 * Author: getajobmike (Mike Perham) * Status: Open ---------------------------------------- Ruby provides Integer(...) and Float(...) global methods to coerce values. Is there a similar method for Booleans? I'd like to do something like: ``` # ENV["SOME_FEATURE"] is unset Boolean(ENV["SOME_FEATURE"]) # => false # ENV["SOME_FEATURE"] is unset, but allow a default? Boolean(ENV["SOME_FEATURE"], true) # => true # explicitly disable ENV["SOME_FEATURE"] = "0" Boolean(ENV["SOME_FEATURE"], true) # => false # explicitly enable ENV["SOME_FEATURE"] = "1" Boolean(ENV["SOME_FEATURE"]) # => true ``` -- https://bugs.ruby-lang.org/

11 11