Issue #15567 has been updated by jeremyevans0 (Jeremy Evans).


Eregon (Benoit Daloze) wrote in #note-19:
> > Eregon (Benoit Daloze) throw should not abort the transaction, it should be committed.
> 
> That is surprising to me.
> If `throw` is performed in the middle of the transaction block then maybe only half the operations are done, committing in that case seems wrong.
> ```ruby
> transaction do
>   update1
>   some_call_that_ends_up_in_throw
>   update2
> end
> ```

Rails 7 is going to start treating non-local, non-exception exits as rolling back the transaction, the same as exception exits.  I believe this is to work around the fact that Timeout uses throw (https://github.com/rails/rails/pull/29333).

Sequel won't make the same change.  I think that non-local, non-exception exits should commit the transaction, and only exceptions should roll the transaction back.  Changing the behavior just because of Timeout's design (even if Timeout is not used) seems to be a mistake to me.  I certainly have a lot of code that uses throw to exit transactions and expects the transaction will be committed. Sinatra and Roda both use throw for returning responses to web requests, for example:

```ruby
DB.transaction do
  DB[:table].insert

  unless update_related_table?
    redirect '/some-path' # throw
  end

  DB[:related_table].update
end
```

----------------------------------------
Feature #15567: Allow ensure to match specific situations
https://bugs.ruby-lang.org/issues/15567#change-92318

* Author: ioquatix (Samuel Williams)
* Status: Rejected
* Priority: Normal
* Assignee: ioquatix (Samuel Williams)
----------------------------------------
There are some situations where `rescue Exception` or `ensure` are not sufficient to correctly, efficiently and easily handle abnormal flow control.

Take the following program for example:

```
def doot
	yield
ensure
	# Did the function run to completion?
	return "abnormal" if $!
end

puts doot{throw :foo}
puts doot{raise "Boom"}
puts doot{"Hello World"}

catch(:foo) do
	puts doot{throw :foo}
end
```

Using `rescue Exception` is not sufficient as it is not invoked by `throw`.

Using `ensure` is inefficient because it's triggered every time, even though exceptional case might never happen or happen very infrequently.

I propose some way to limit the scope of the ensure block:

```
def doot
	yield
ensure when raise, throw
	return "abnormal"
end
```

The scope should be one (or more) of `raise`, `throw`, `return`, `next`, `break`, `redo`, `retry` (everything in `enum ruby_tag_type` except all except for `RUBY_TAG_FATAL`).

Additionally, it might be nice to support the inverted pattern, i.e.

```
def doot
	yield
ensure when not return
	return "abnormal"
end
```

Inverted patterns allow user to specify the behaviour without having problems if future scopes are introduced.

`return` in this case matches both explicit and implicit.




-- 
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>