patch: -> { step Destroy.method(:tidy_storage), before: :delete_model }

Patching has no implicit, magical side-effects and is strongly encouraged to customize flows for a specific case in a quick and consise way.

Another solution is using the Safe Navigation Operator &. introduced in Ruby 2.3 which is a bit better because this is a language feature rather than an opinionated runtime environment pollution

I don't see a way to hook into Devise's route mapping load process to add the action (several monkey patching attempts failed)

According to this comment you might want to override the structurally_incompatible_values_for_or to overcome the issue: def structurally_incompatible_values_for_or(other) Relation::SINGLE_VALUE_METHODS.reject { |m| send("#{m}_value") == other.send("#{m}_value") } + (Relation::MULTI_VALUE_METHODS - [:eager_load, :references, :extending]).reject { |m| send("#{m}_values") == other.send("#{m}_values") } + (Relation::CLAUSE_METHODS - [:having, :where]).reject { |m| send("#{m}_clause") == other.send("#{m}_clause") } end

You can afford to make a proper PR to upstream.

The change would be useful to other people as-is.

The change is too consequential to be developed in situ.

Patches can be reviewed as part of your normal review process, forks probably can't

Get told in big red letters when the dependency changed and you need to check that your fix is still valid.

Keep your patches colocated with the code that depends on them.

Sometimes forks need extra build steps, e.g. with react-native for Android. Forget that noise.

There are other features you *could* actually polyfill, such as Array.of, Number.isNaN or Object.assign, because those don’t introduce syntax changes to the language – except that you shouldn’t.

Polyfills are naughty as they patch native APIs, while ponyfills are pure and don't affect the environment.

How are ponyfills better than polyfills? A polyfill is code that adds missing functionality by monkey patching an API. Unfortunately, it usually globally patches built-ins, which affects all code running in the environment. This is especially problematic when a polyfill is not fully spec compliant (which in some cases is impossible), as it could cause very hard to debug bugs and inconsistencies. Or when the spec for a new feature changes and your code depends on behavior that a module somewhere else in the dependency tree polyfills differently. In general, you should not modify API's you don't own.

Want to use this now? Existing projects A more robust and maintainable way to incorporate this patch into your workflow using patch-package:

But I'll definitely take underscore mixins over extending String.prototype or other clunky implementations any day.

Instead of re-opening Ruby classes like that (I get involuntary twitches), for our little exercise we are going to invent another name

prepend_message

allowing common connections to be made wirelessly