I was lately asked by my Initial #RubyFriend mentee just how to note the callbacks existing on an Energetic Document design. I really did not understand.
They were taking a look at a substantial tradition codebase, with some big versions specified throughout numerous data. The versions utilized numerous treasures, personalized callbacks, as well as problems. It was extremely difficult to analyze what behaviors the callbacks were triggering.
I located reference of debugging callbacks in the Bed rails API paperwork as well as, after a little excavating, developed an easy loophole you can make use of to locate the callbacks specified on an Energetic Document design.
Usage …
… a loophole in the Bed rails console.
Open up the console.
Paste this code right into the console to see the user-defined callbacks on a design:
YourModel __ callbacks each_with_object( Hash brand-new([])) do |( k, callbacks), result|
following if k = = : verify # neglect recognitions
callbacks each do | c|
# get rid of autosaving callbacks from outcome
following if c filter to_s consist of?(" autosave")
following if c filter to_s consist of?(" _ ensure_no_duplicate_errors")
result["#{c.kind}_#{c.name}"] + = [c.filter]
end
end
For the Individual item in my application, which utilizes the Devise treasure for verification, the outcomes appear like this:
=>> {
" before_validation"=>>[:downcase_keys, :strip_whitespace, :set_timestamps_for_agreements],
" after_save"=>>[#<Proc:0x00000001133b94d0 /.../gems/money-rails-1.15.0/lib/money-rails/active_record/monetizable.rb:148>],
" before_save"=>>[:ensure_authentication_token],
" after_create"=>>[:skip_reconfirmation_in_callback!],
" before_create"=>>[:generate_confirmation_token],
" after_update"=>>[:send_password_change_notification, :send_email_changed_notification],
" before_update"=>>[:clear_reset_password_token :postpone_email_change_until_confirmation_and_regenerate_confirmation_token],
" after_commit"=>>[:send_on_create_confirmation_instructions, :send_reconfirmation_instructions],
}
Below you can see the callbacks placed right into the Individual design based upon our arrangement of the design treasure. These aren’t provided in the app/models/user. rb documents.
You can likewise see a vibrant Proc– based callback placed by our use the money-rails treasure.
Just how does this job?
The # __ callbacks technique on a design is specified as a course technique using Energetic Assistance If accessed straight, like calling YourModel. __ callbacks, it returns a complicated hash framework including the reasoning carried out by the Energetic Document circumstances prior to or after altering its state.
The code over just takes out the major technique telephone calls.
In the certain code over I have actually assumed the following:
You aren’t thinking about seeing every one of the recognitions. Code like validates_presence_of: feature produces an access in the callback chain. We miss showing these with next if k ==: verify
You aren’t thinking about the callbacks that instantly conserve the worths of connected versions where you have_many: related_models For This Reason next if c.filter.to _ s.include?(" autosave")
Why?
When you’re brand-new to a complicated application this might work as a debugging device.
I have a tendency to restrict my use callbacks as long as feasible as a result of the convenience with which I have actually perplexed myself in the past, however if you remain in a codebase that utilizes them a whole lot, this could obtain you up to speed up with the existing behavior faster.
Why not?
Please do not utilize this code in manufacturing. It’s just for debugging as well as assisting you to recognize a brand-new codebase.
I can not consider a factor to utilize this in application code. Additionally, the __ prefix in the technique name shows this is primarily based upon Bed rails’s interior API as well as goes through transform.
