* [ruby-core:96769] [Ruby master Bug#16500] Argument added both to splat and last &block argument
[not found] <redmine.issue-16500.20200111000000@ruby-lang.org>
@ 2020-01-11 0:00 ` anatol.pomozov
2020-01-11 0:31 ` [ruby-core:96770] " mame
` (8 subsequent siblings)
9 siblings, 0 replies; 10+ messages in thread
From: anatol.pomozov @ 2020-01-11 0:00 UTC (permalink / raw)
To: ruby-core
Issue #16500 has been reported by anatolik (Anatol Pomozov).
----------------------------------------
Bug #16500: Argument added both to splat and last &block argument
https://bugs.ruby-lang.org/issues/16500
* Author: anatolik (Anatol Pomozov)
* Status: Open
* Priority: Normal
* Assignee:
* Target version:
* ruby -v: 2.7.0
* Backport: 2.5: UNKNOWN, 2.6: UNKNOWN, 2.7: UNKNOWN
----------------------------------------
Here is a followup for a ruby2.7 issue discussed here https://gitlab.com/groups/gitlab-org/-/epics/2380
I run gitlab with ruby2.7. Things work mostly fine except one weird issue. gitlab/lib/api/api_guard.rb calls Rack's `use` method:
```ruby
use Rack::OAuth2::Server::Resource::Bearer, 'The API' do |request|
# The authenticator only fetches the raw token string
# Must yield access token to store it in the env
request.access_token
end
```
The `use` method looks like
```ruby
def use(middleware, *args, &block)
if @map
mapping, @map = @map, nil
@use << proc { |app| generate_map app, mapping }
end
@use << proc { |app| middleware.new(app, *args, &block) }
end
```
For some reason `Proc` method set to `&block` *and* added to `args`. It sounds wrong. `Proc` should be set to `&block` only and `args` should contain only 1 argument.
--
https://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 10+ messages in thread
* [ruby-core:96770] [Ruby master Bug#16500] Argument added both to splat and last &block argument
[not found] <redmine.issue-16500.20200111000000@ruby-lang.org>
2020-01-11 0:00 ` [ruby-core:96769] [Ruby master Bug#16500] Argument added both to splat and last &block argument anatol.pomozov
@ 2020-01-11 0:31 ` mame
2020-01-11 0:52 ` [ruby-core:96771] " samuel
` (7 subsequent siblings)
9 siblings, 0 replies; 10+ messages in thread
From: mame @ 2020-01-11 0:31 UTC (permalink / raw)
To: ruby-core
Issue #16500 has been updated by mame (Yusuke Endoh).
Thank you for the report! I cannot reproduce the issue by a simple config.ru:
```
require "rack/oauth2"
use Rack::OAuth2::Server::Resource::Bearer, 'The API' do |request|
request.access_token
end
```
Adding `p args` into the definition of Rack's `use` shows only `["The API"]`. So I'd like to try it with the source code of gitlab. I have no idea at all about gitlab, so could you tell me how to reproduce it?
----------------------------------------
Bug #16500: Argument added both to splat and last &block argument
https://bugs.ruby-lang.org/issues/16500#change-83764
* Author: anatolik (Anatol Pomozov)
* Status: Open
* Priority: Normal
* Assignee:
* Target version:
* ruby -v: 2.7.0
* Backport: 2.5: UNKNOWN, 2.6: UNKNOWN, 2.7: UNKNOWN
----------------------------------------
Here is a followup for a ruby2.7 issue discussed here https://gitlab.com/groups/gitlab-org/-/epics/2380
I run gitlab with ruby2.7. Things work mostly fine except one weird issue. gitlab/lib/api/api_guard.rb calls Rack's `use` method:
```ruby
use Rack::OAuth2::Server::Resource::Bearer, 'The API' do |request|
# The authenticator only fetches the raw token string
# Must yield access token to store it in the env
request.access_token
end
```
The `use` method looks like
```ruby
def use(middleware, *args, &block)
if @map
mapping, @map = @map, nil
@use << proc { |app| generate_map app, mapping }
end
@use << proc { |app| middleware.new(app, *args, &block) }
end
```
For some reason `Proc` method set to `&block` *and* added to `args`. It sounds wrong. `Proc` should be set to `&block` only and `args` should contain only 1 argument.
--
https://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 10+ messages in thread
* [ruby-core:96771] [Ruby master Bug#16500] Argument added both to splat and last &block argument
[not found] <redmine.issue-16500.20200111000000@ruby-lang.org>
2020-01-11 0:00 ` [ruby-core:96769] [Ruby master Bug#16500] Argument added both to splat and last &block argument anatol.pomozov
2020-01-11 0:31 ` [ruby-core:96770] " mame
@ 2020-01-11 0:52 ` samuel
2020-01-11 1:21 ` [ruby-core:96772] " samuel
` (6 subsequent siblings)
9 siblings, 0 replies; 10+ messages in thread
From: samuel @ 2020-01-11 0:52 UTC (permalink / raw)
To: ruby-core
Issue #16500 has been updated by ioquatix (Samuel Williams).
We cannot reproduce this.
Can you make some script to reproduce this in isolation?
Including Gemfile and Gemfile.lock details.
----------------------------------------
Bug #16500: Argument added both to splat and last &block argument
https://bugs.ruby-lang.org/issues/16500#change-83765
* Author: anatolik (Anatol Pomozov)
* Status: Open
* Priority: Normal
* Assignee:
* Target version:
* ruby -v: 2.7.0
* Backport: 2.5: UNKNOWN, 2.6: UNKNOWN, 2.7: UNKNOWN
----------------------------------------
Here is a followup for a ruby2.7 issue discussed here https://gitlab.com/groups/gitlab-org/-/epics/2380
I run gitlab with ruby2.7. Things work mostly fine except one weird issue. gitlab/lib/api/api_guard.rb calls Rack's `use` method:
```ruby
use Rack::OAuth2::Server::Resource::Bearer, 'The API' do |request|
# The authenticator only fetches the raw token string
# Must yield access token to store it in the env
request.access_token
end
```
The `use` method looks like
```ruby
def use(middleware, *args, &block)
if @map
mapping, @map = @map, nil
@use << proc { |app| generate_map app, mapping }
end
@use << proc { |app| middleware.new(app, *args, &block) }
end
```
For some reason `Proc` method set to `&block` *and* added to `args`. It sounds wrong. `Proc` should be set to `&block` only and `args` should contain only 1 argument.
--
https://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 10+ messages in thread
* [ruby-core:96772] [Ruby master Bug#16500] Argument added both to splat and last &block argument
[not found] <redmine.issue-16500.20200111000000@ruby-lang.org>
` (2 preceding siblings ...)
2020-01-11 0:52 ` [ruby-core:96771] " samuel
@ 2020-01-11 1:21 ` samuel
2020-01-11 1:28 ` [ruby-core:96773] " samuel
` (5 subsequent siblings)
9 siblings, 0 replies; 10+ messages in thread
From: samuel @ 2020-01-11 1:21 UTC (permalink / raw)
To: ruby-core
Issue #16500 has been updated by ioquatix (Samuel Williams).
https://github.com/ruby-grape/grape/blob/d58dc0ab7a0b51625217deedd8110d1030be7cf7/lib/grape/middleware/stack.rb#L80-L84 is probably responsible for the failure.
----------------------------------------
Bug #16500: Argument added both to splat and last &block argument
https://bugs.ruby-lang.org/issues/16500#change-83766
* Author: anatolik (Anatol Pomozov)
* Status: Open
* Priority: Normal
* Assignee:
* Target version:
* ruby -v: 2.7.0
* Backport: 2.5: UNKNOWN, 2.6: UNKNOWN, 2.7: UNKNOWN
----------------------------------------
Here is a followup for a ruby2.7 issue discussed here https://gitlab.com/groups/gitlab-org/-/epics/2380
I run gitlab with ruby2.7. Things work mostly fine except one weird issue. gitlab/lib/api/api_guard.rb calls Rack's `use` method:
```ruby
use Rack::OAuth2::Server::Resource::Bearer, 'The API' do |request|
# The authenticator only fetches the raw token string
# Must yield access token to store it in the env
request.access_token
end
```
The `use` method looks like
```ruby
def use(middleware, *args, &block)
if @map
mapping, @map = @map, nil
@use << proc { |app| generate_map app, mapping }
end
@use << proc { |app| middleware.new(app, *args, &block) }
end
```
For some reason `Proc` method set to `&block` *and* added to `args`. It sounds wrong. `Proc` should be set to `&block` only and `args` should contain only 1 argument.
--
https://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 10+ messages in thread
* [ruby-core:96773] [Ruby master Bug#16500] Argument added both to splat and last &block argument
[not found] <redmine.issue-16500.20200111000000@ruby-lang.org>
` (3 preceding siblings ...)
2020-01-11 1:21 ` [ruby-core:96772] " samuel
@ 2020-01-11 1:28 ` samuel
2020-01-11 23:45 ` [ruby-core:96795] " samuel
` (4 subsequent siblings)
9 siblings, 0 replies; 10+ messages in thread
From: samuel @ 2020-01-11 1:28 UTC (permalink / raw)
To: ruby-core
Issue #16500 has been updated by ioquatix (Samuel Williams).
Assignee set to ioquatix (Samuel Williams)
Status changed from Open to Rejected
https://github.com/ruby-grape/grape/issues/1967
----------------------------------------
Bug #16500: Argument added both to splat and last &block argument
https://bugs.ruby-lang.org/issues/16500#change-83767
* Author: anatolik (Anatol Pomozov)
* Status: Rejected
* Priority: Normal
* Assignee: ioquatix (Samuel Williams)
* Target version:
* ruby -v: 2.7.0
* Backport: 2.5: UNKNOWN, 2.6: UNKNOWN, 2.7: UNKNOWN
----------------------------------------
Here is a followup for a ruby2.7 issue discussed here https://gitlab.com/groups/gitlab-org/-/epics/2380
I run gitlab with ruby2.7. Things work mostly fine except one weird issue. gitlab/lib/api/api_guard.rb calls Rack's `use` method:
```ruby
use Rack::OAuth2::Server::Resource::Bearer, 'The API' do |request|
# The authenticator only fetches the raw token string
# Must yield access token to store it in the env
request.access_token
end
```
The `use` method looks like
```ruby
def use(middleware, *args, &block)
if @map
mapping, @map = @map, nil
@use << proc { |app| generate_map app, mapping }
end
@use << proc { |app| middleware.new(app, *args, &block) }
end
```
For some reason `Proc` method set to `&block` *and* added to `args`. It sounds wrong. `Proc` should be set to `&block` only and `args` should contain only 1 argument.
--
https://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 10+ messages in thread
* [ruby-core:96795] [Ruby master Bug#16500] Argument added both to splat and last &block argument
[not found] <redmine.issue-16500.20200111000000@ruby-lang.org>
` (4 preceding siblings ...)
2020-01-11 1:28 ` [ruby-core:96773] " samuel
@ 2020-01-11 23:45 ` samuel
2020-01-11 23:59 ` [ruby-core:96796] " merch-redmine
` (3 subsequent siblings)
9 siblings, 0 replies; 10+ messages in thread
From: samuel @ 2020-01-11 23:45 UTC (permalink / raw)
To: ruby-core
Issue #16500 has been updated by ioquatix (Samuel Williams).
Status changed from Rejected to Open
On Ruby 2.7.0:
```
irb(main):020:-> x = [1, 2, ->{}]; puts(*x, &x.pop)
1
2
=> nil
irb(main):021:-> x = [1, 2, ->{}]; puts(*x, &x.last)
1
2
#<Proc:0x0000562763a56398 (irb):21 (lambda)>
=> nil
```
This seems like buggy behaviour related to the original issue.
----------------------------------------
Bug #16500: Argument added both to splat and last &block argument
https://bugs.ruby-lang.org/issues/16500#change-83788
* Author: anatolik (Anatol Pomozov)
* Status: Open
* Priority: Normal
* Assignee: ioquatix (Samuel Williams)
* Target version:
* ruby -v: 2.7.0
* Backport: 2.5: UNKNOWN, 2.6: UNKNOWN, 2.7: UNKNOWN
----------------------------------------
Here is a followup for a ruby2.7 issue discussed here https://gitlab.com/groups/gitlab-org/-/epics/2380
I run gitlab with ruby2.7. Things work mostly fine except one weird issue. gitlab/lib/api/api_guard.rb calls Rack's `use` method:
```ruby
use Rack::OAuth2::Server::Resource::Bearer, 'The API' do |request|
# The authenticator only fetches the raw token string
# Must yield access token to store it in the env
request.access_token
end
```
The `use` method looks like
```ruby
def use(middleware, *args, &block)
if @map
mapping, @map = @map, nil
@use << proc { |app| generate_map app, mapping }
end
@use << proc { |app| middleware.new(app, *args, &block) }
end
```
For some reason `Proc` method set to `&block` *and* added to `args`. It sounds wrong. `Proc` should be set to `&block` only and `args` should contain only 1 argument.
--
https://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 10+ messages in thread
* [ruby-core:96796] [Ruby master Bug#16500] Argument added both to splat and last &block argument
[not found] <redmine.issue-16500.20200111000000@ruby-lang.org>
` (5 preceding siblings ...)
2020-01-11 23:45 ` [ruby-core:96795] " samuel
@ 2020-01-11 23:59 ` merch-redmine
2020-01-12 0:12 ` [ruby-core:96797] " mame
` (2 subsequent siblings)
9 siblings, 0 replies; 10+ messages in thread
From: merch-redmine @ 2020-01-11 23:59 UTC (permalink / raw)
To: ruby-core
Issue #16500 has been updated by jeremyevans0 (Jeremy Evans).
ioquatix (Samuel Williams) wrote:
> On Ruby 2.7.0:
>
> ```
> irb(main):020:-> x = [1, 2, ->{}]; puts(*x, &x.pop)
> 1
> 2
> => nil
> irb(main):021:-> x = [1, 2, ->{}]; puts(*x, &x.last)
> 1
> 2
> #<Proc:0x0000562763a56398 (irb):21 (lambda)>
> => nil
> ```
>
> This seems like buggy behaviour related to the original issue.
I'm not sure if that behavior is buggy. puts ignores a passed block, so the behavior seems expected.
```ruby
def a(*args, &b)
p [args, b]
end
x = [1, 2, ->{}]; a(*x, &x.pop)
# => [[1, 2], #<Proc:0x00001100c1362518 (irb):4 (lambda)>]
x = [1, 2, ->{}]; a(*x, &x.last)
# => [[1, 2, #<Proc:0x000011004f2b0ba0 (irb):5 (lambda)>], #<Proc:0x000011004f2b0ba0 (irb):5 (lambda)>]
```
Same results with Ruby 1.9.
----------------------------------------
Bug #16500: Argument added both to splat and last &block argument
https://bugs.ruby-lang.org/issues/16500#change-83789
* Author: anatolik (Anatol Pomozov)
* Status: Open
* Priority: Normal
* Assignee: ioquatix (Samuel Williams)
* Target version:
* ruby -v: 2.7.0
* Backport: 2.5: UNKNOWN, 2.6: UNKNOWN, 2.7: UNKNOWN
----------------------------------------
Here is a followup for a ruby2.7 issue discussed here https://gitlab.com/groups/gitlab-org/-/epics/2380
I run gitlab with ruby2.7. Things work mostly fine except one weird issue. gitlab/lib/api/api_guard.rb calls Rack's `use` method:
```ruby
use Rack::OAuth2::Server::Resource::Bearer, 'The API' do |request|
# The authenticator only fetches the raw token string
# Must yield access token to store it in the env
request.access_token
end
```
The `use` method looks like
```ruby
def use(middleware, *args, &block)
if @map
mapping, @map = @map, nil
@use << proc { |app| generate_map app, mapping }
end
@use << proc { |app| middleware.new(app, *args, &block) }
end
```
For some reason `Proc` method set to `&block` *and* added to `args`. It sounds wrong. `Proc` should be set to `&block` only and `args` should contain only 1 argument.
--
https://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 10+ messages in thread
* [ruby-core:96797] [Ruby master Bug#16500] Argument added both to splat and last &block argument
[not found] <redmine.issue-16500.20200111000000@ruby-lang.org>
` (6 preceding siblings ...)
2020-01-11 23:59 ` [ruby-core:96796] " merch-redmine
@ 2020-01-12 0:12 ` mame
2020-01-12 16:38 ` [ruby-core:96807] [Ruby master Bug#16500] Argument is added to both " eregontp
2020-01-12 16:45 ` [ruby-core:96808] " eregontp
9 siblings, 0 replies; 10+ messages in thread
From: mame @ 2020-01-12 0:12 UTC (permalink / raw)
To: ruby-core
Issue #16500 has been updated by mame (Yusuke Endoh).
Ruby 2.7 partially changed the behavior. Coped from my comment: https://github.com/ruby-grape/grape/issues/1967#issuecomment-573366122
```ruby
# in 2.6 or before
args = [1, 2, -> {}]; foo( *args, &args.pop) #=> passes [1, 2] (bug; [1, 2, ->{}] is expected)
args = [1, 2, -> {}]; foo(0, *args, &args.pop) #=> passes [0, 1, 2] (bug; [0, 1, 2, ->{}] is expected)
# in 2.7
args = [1, 2, -> {}]; foo( *args, &args.pop) #=> passes [1, 2] (bug; [1, 2, ->{}] is expected)
args = [1, 2, -> {}]; foo(0, *args, &args.pop) #=> passes [0, 1, 2, ->{}] (good)
```
So, there are two issues.
* The issue that this ticket says is caused by a behavior change of 2.7, and ruby-grape's change will fix the issue https://github.com/ruby-grape/grape/commit/dec3e1ff5dbf3215a714565e62b12bd2ef6b0ddb
* The behavior of `args = [1, 2, -> {}]; foo( *args, &args.pop)` should pass `[1, 2, ->{}]`, and we should fix the bug on the ruby interpreter.
----------------------------------------
Bug #16500: Argument added both to splat and last &block argument
https://bugs.ruby-lang.org/issues/16500#change-83790
* Author: anatolik (Anatol Pomozov)
* Status: Open
* Priority: Normal
* Assignee: ioquatix (Samuel Williams)
* Target version:
* ruby -v: 2.7.0
* Backport: 2.5: UNKNOWN, 2.6: UNKNOWN, 2.7: UNKNOWN
----------------------------------------
Here is a followup for a ruby2.7 issue discussed here https://gitlab.com/groups/gitlab-org/-/epics/2380
I run gitlab with ruby2.7. Things work mostly fine except one weird issue. gitlab/lib/api/api_guard.rb calls Rack's `use` method:
```ruby
use Rack::OAuth2::Server::Resource::Bearer, 'The API' do |request|
# The authenticator only fetches the raw token string
# Must yield access token to store it in the env
request.access_token
end
```
The `use` method looks like
```ruby
def use(middleware, *args, &block)
if @map
mapping, @map = @map, nil
@use << proc { |app| generate_map app, mapping }
end
@use << proc { |app| middleware.new(app, *args, &block) }
end
```
For some reason `Proc` method set to `&block` *and* added to `args`. It sounds wrong. `Proc` should be set to `&block` only and `args` should contain only 1 argument.
--
https://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 10+ messages in thread
* [ruby-core:96807] [Ruby master Bug#16500] Argument is added to both splat and last &block argument
[not found] <redmine.issue-16500.20200111000000@ruby-lang.org>
` (7 preceding siblings ...)
2020-01-12 0:12 ` [ruby-core:96797] " mame
@ 2020-01-12 16:38 ` eregontp
2020-01-12 16:45 ` [ruby-core:96808] " eregontp
9 siblings, 0 replies; 10+ messages in thread
From: eregontp @ 2020-01-12 16:38 UTC (permalink / raw)
To: ruby-core
Issue #16500 has been updated by Eregon (Benoit Daloze).
mame (Yusuke Endoh) wrote:
> * The behavior of `args = [1, 2, -> {}]; foo( *args, &args.pop)` should pass `[1, 2, ->{}]`, and we should fix the bug on the ruby interpreter.
Why is that better than the previous behavior?
Changing that will be more incompatible.
----------------------------------------
Bug #16500: Argument is added to both splat and last &block argument
https://bugs.ruby-lang.org/issues/16500#change-83802
* Author: anatolik (Anatol Pomozov)
* Status: Open
* Priority: Normal
* Assignee: ioquatix (Samuel Williams)
* Target version:
* ruby -v: 2.7.0
* Backport: 2.5: UNKNOWN, 2.6: UNKNOWN, 2.7: UNKNOWN
----------------------------------------
Here is a followup for a ruby2.7 issue discussed here https://gitlab.com/groups/gitlab-org/-/epics/2380
I run gitlab with ruby2.7. gitlab/lib/api/api_guard.rb calls Rack's `use` method:
```ruby
use Rack::OAuth2::Server::Resource::Bearer, 'The API' do |request|
# The authenticator only fetches the raw token string
# Must yield access token to store it in the env
request.access_token
end
```
The `use` method looks like:
```ruby
def use(middleware, *args, &block)
if @map
mapping, @map = @map, nil
@use << proc { |app| generate_map app, mapping }
end
@use << proc { |app| middleware.new(app, *args, &block) }
end
```
For some reason, a `Proc` object was set to `&block` *and* added to `args`. It sounds wrong. A `Proc` should only be set to `&block`, and `args` should contain only one argument.
--
https://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 10+ messages in thread
* [ruby-core:96808] [Ruby master Bug#16500] Argument is added to both splat and last &block argument
[not found] <redmine.issue-16500.20200111000000@ruby-lang.org>
` (8 preceding siblings ...)
2020-01-12 16:38 ` [ruby-core:96807] [Ruby master Bug#16500] Argument is added to both " eregontp
@ 2020-01-12 16:45 ` eregontp
9 siblings, 0 replies; 10+ messages in thread
From: eregontp @ 2020-01-12 16:45 UTC (permalink / raw)
To: ruby-core
Issue #16500 has been updated by Eregon (Benoit Daloze).
FWIW the 2.6 behavior is detailed in ruby/spec:
https://github.com/ruby/spec/blob/84d606aa8e85a8fef6521b3402dae612d04288c4/language/send_spec.rb#L424-L445
From commit
https://github.com/ruby/spec/commit/01992ab93dd893d9e8bf79db9f5ff7d250952097
which shows RubyGems used to rely on the 2.6 behavior.
What I want to say is existing code relies on 2.6 behavior.
It's probably good to always evaluate positional arguments before the block argument for consistency, but it's an incompatible change.
----------------------------------------
Bug #16500: Argument is added to both splat and last &block argument
https://bugs.ruby-lang.org/issues/16500#change-83803
* Author: anatolik (Anatol Pomozov)
* Status: Open
* Priority: Normal
* Assignee: ioquatix (Samuel Williams)
* Target version:
* ruby -v: 2.7.0
* Backport: 2.5: UNKNOWN, 2.6: UNKNOWN, 2.7: UNKNOWN
----------------------------------------
Here is a followup for a ruby2.7 issue discussed here https://gitlab.com/groups/gitlab-org/-/epics/2380
I run gitlab with ruby2.7. gitlab/lib/api/api_guard.rb calls Rack's `use` method:
```ruby
use Rack::OAuth2::Server::Resource::Bearer, 'The API' do |request|
# The authenticator only fetches the raw token string
# Must yield access token to store it in the env
request.access_token
end
```
The `use` method looks like:
```ruby
def use(middleware, *args, &block)
if @map
mapping, @map = @map, nil
@use << proc { |app| generate_map app, mapping }
end
@use << proc { |app| middleware.new(app, *args, &block) }
end
```
For some reason, a `Proc` object was set to `&block` *and* added to `args`. It sounds wrong. A `Proc` should only be set to `&block`, and `args` should contain only one argument.
--
https://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 10+ messages in thread
end of thread, other threads:[~2020-01-12 16:46 UTC | newest]
Thread overview: 10+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
[not found] <redmine.issue-16500.20200111000000@ruby-lang.org>
2020-01-11 0:00 ` [ruby-core:96769] [Ruby master Bug#16500] Argument added both to splat and last &block argument anatol.pomozov
2020-01-11 0:31 ` [ruby-core:96770] " mame
2020-01-11 0:52 ` [ruby-core:96771] " samuel
2020-01-11 1:21 ` [ruby-core:96772] " samuel
2020-01-11 1:28 ` [ruby-core:96773] " samuel
2020-01-11 23:45 ` [ruby-core:96795] " samuel
2020-01-11 23:59 ` [ruby-core:96796] " merch-redmine
2020-01-12 0:12 ` [ruby-core:96797] " mame
2020-01-12 16:38 ` [ruby-core:96807] [Ruby master Bug#16500] Argument is added to both " eregontp
2020-01-12 16:45 ` [ruby-core:96808] " eregontp
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).