[ruby-core:113701] [Ruby master Feature#19694] Add Regexp#timeout= setter

Issue #19694 has been updated by Eregon (Benoit Daloze).





janosch-x (Janosch M=FCller) wrote in #note-7:

> ```ruby

> regexp =3D Regexp.with_timeout(2.0) { /foo/ }

> regexp.timeout # =3D> 2.0

> ```



That, and as proposed in the description, doesn't really work if literal Re=
gexps are created at parse time, before execution.

This is the case on CRuby:

```

$ ruby --disable-gems -e 'pp ObjectSpace.count_objects; O=3DObject.new; R=
=3D/a/' | grep REGEX

 :T_REGEXP=3D>3,

$ ruby --disable-gems -e 'pp ObjectSpace.count_objects; O=3DObject.new' | g=
rep REGEX    =20

 :T_REGEXP=3D>2,

```

and it is the case on TruffleRuby as well.



Also it could be confusing for `[2.0, 4.0].each { |t| Regexp.with_timeout(t=
) { /foo/ } }` (it would either set it to 2.0 or to the global timeout, nev=
er to 4.0).



Furthermore, even if that worked, it would then break Regexp interning, whe=
re the timeout at one place would affect another literal Regexp with the sa=
me pattern.



Basically, I think there is no way besides `Regexp.new(pattern, timeout: t)=
` if you want a custom timeout for a Regexp.

Literal Regexp are created too early to set anything.



And adding state (timeout=3D) to Regexp feels wrong, since most instances a=
re already immutable, and they might become all immutable.



I would suggest to close this, `Regexp.new("a", timeout: 2.0)` already work=
s and I think there is no alternative that works well to set the timeout pe=
r Regexp.



----------------------------------------

Feature #19694: Add Regexp#timeout=3D setter

https://bugs.ruby-lang.org/issues/19694#change-103347



* Author: aharpole (Aaron Harpole)

* Status: Open

* Priority: Normal

----------------------------------------

# Abstract



In addition to allowing for a Regexp timeout to be set on individual instan=
ces by setting a `timeout` argument in `Regexp.new`, I'm proposing that we =
also allow setting the timeout on Regexp objects with a `#timeout=3D` sette=
r.



# Background



To be able to roll out a global Regexp timeout for a large application, the=
re are inevitably some individual regexes for which a different timeout is =
appropriate. While the `timeout` keyword argument was added to `Regexp.new`=
, this isn't always a viable option.



In the case of regex literal syntax (`/ab*/` or `%r{ab*}`, for instance), i=
t's not possible to set a timeout at all right now without converting to `R=
egexp.new`, which may be awkward depending on the contents of the regex.



It also is desirable from time to time to be able to set a timeout for a re=
gex object after it's been initialized.



Finally, because we offer a `Regexp#timeout` getter, for consistency it wou=
ld be nice to also offer a setter.



The introduction of a `Regexp#timeout=3D` setter was mentioned as a possibl=
e way to set individual timeouts in https://bugs.ruby-lang.org/issues/19104=
#Specification.



# Proposal



I propose that we add the method `Regexp#timeout=3D`. It works the same way=
 the `timeout` argument works in `Regexp.new`, taking either a float or nil.



This makes it relatively easy to add timeouts to specific regex literals (r=
egex literals are frozen by default so you do have to `dup` them first):



```

emoji_filter_pattern =3D %r{

  (?<!#{Regexp.quote(ZERO_WIDTH_JOINER)})

  #{EmojiFilter.unicodes_pattern}

  (?!#{Regexp.union(EmojiFilter::MODIFIER_CHAR_MAP.keys.map { |k| Regexp.qu=
ote k })})

}x.dup

emoji_filter_pattern.timeout =3D 1.0

emoji_filter_pattern.freeze

```



# Implementation



This setter has been implemented in https://github.com/ruby/ruby/pull/7847.



# Evaluation



It's just a setter, so pretty straightforward in terms of implementation an=
d use.



# Discussion



It's worth considering other options for overriding `Regexp.timeout`. I'd l=
ove to see something like the following for overriding regexp timeouts as w=
ell:



```

Regexp.timeout =3D 1.0



Regexp.with_timeout(5.0) do

  evaluate_slower_regexes

end

```



It's possible to implement something like `Regexp.with_timeout` but it's no=
t thread-safe by default since it would involve overwriting `Regexp.timeout=
`.



# Summary



Regexp instances have a getter for timeout, and adding a corresponding sett=
er adds consistency and will make it easier for developers to adopt adding =
a global `Regexp.timeout` by making it simpler to adjust timeouts on a rege=
x by regex basis.



It's a minor change but the added consistency and flexibility help us optim=
ize for developer happiness.







--=20

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-c=
ore.ml.ruby-lang.org/