Issue #20434 has been updated by Eregon (Benoit Daloze).
This seems a good simplification to me, I think the semantics of these encoding modifiers
are confusing to most Rubyists.
I wouldn't be worried too much about length of the replacement, because
`/.../s`/`/.../e` are likely very rare (using file encoding seems a good replacement for
those).
`/.../u` seems redundant with the default source encoding, so the `u` can likely just be
removed in most cases.
I'm not so sure `/.../n`, that may be more frequent.
Methods to convert an existing Regexp from one encoding to another feel suboptiomal,
because that will cause an extra Regexp instance and creating a Regexp is not cheap due to
many checks, allocations, and even compilation (AFAIK eager in CRuby at least).
So I think the existing
`Regexp.new("a".dup.force_encoding(Encoding::WINDOWS_31J))` is good enough.
And since this would address a deprecation, it seems very important that the code also
works on older Ruby versions.
(I'm all for `String#{encoded,with_encoding}` but it seems best to propose that as a
separate ticket)
I would be interested to have a good textual description in #20406 of how the encoding of
a Regexp is computed currently, it seems quite complex, but having it in text would allow
to reason more easily about it.
Maybe we could simplify it while remaining compatible (i.e. the specific value of
Regexp#encoding matters not so much, what matters is a Regexp can still be matched against
Strings of various encoding like it could before).
----------------------------------------
Misc #20434: Deprecate encoding-related regular expression modifiers
https://bugs.ruby-lang.org/issues/20434#change-108001
* Author: kddnewton (Kevin Newton)
* Status: Open
----------------------------------------
This is a follow-up to @duerst's comment here:
https://bugs.ruby-lang.org/issues/20406#note-6.
As noted in the other issue, there are many encodings that factor in to how a regular
expression operates. This includes:
* The encoding of the file
* The encoding of the string parts within the regular expression
* The regular expression encoding modifiers
* The encoding of the string being matched
At the time the modifiers were introduced, I believe the modifiers may have been the only
(??) encoding that factored in here. At this point, however, they can lead to quite a bit
of confusion, as noted in the other ticket.
I would like to propose to deprecate the regular expression encoding modifiers. Instead,
we could suggest in a warning to instead create a regular expression with an encoded
string. For example, when we find:
```ruby
/\x81\x40/s
```
we would instead suggest:
```ruby
::Regexp.new(::String.new("\x81\x40", encoding: "Windows-31J"))
```
or equivalent. As a migration path, we could do the following:
1. Emit a warning to change to the suggested expression
2. Change the compiler to compile to the suggested expression when those flags are found
3. Remove support for the flags
Step 2 may be unnecessary depending on how long of a timeline we would like to provide. To
be clear, I'm not advocating for any particular timeline, and would be fine with this
being multiple years/versions to give plenty of time for people to migrate. But I do think
this would be a good change to eliminate confusion about the interaction between the four
different encodings at play.
--
https://bugs.ruby-lang.org/