psql implementation of #index_name_exists?
clean up security guide: his => their [ci skip]
Merge pull request #13735 from xta/cleanup_security_guide

clean up security guide: his => their [ci skip]
Only some dynamic finders are deprecated.

find_by_* and find_by_*! are not deprecated for example, so lets add a
note only where it is needed

[ci skip]
Remove warnings on Ruby 2.1
Consistence in the block style
Fix eager load of Serializers on Active Model
set encoding to binmode for pipe
test to ensure bad prepared statements raise a StatementInvalid exception
translate exceptions on prepared statement failure
fix exception translation
Correct the version number to 4 in guides[ci skip]
Merge pull request #13748 from summerblue/master

Correct the version number to 4 in guides[ci skip]
Restore ActiveRecord states after a rollback for models w/o callbacks

This fixes a regression (#13744) that was caused by 67d8bb9.

In 67d8bb9, we introduced lazy rollback for records, such that the
record's internal states and attributes are not restored immediately
after a transaction rollback, but deferred until they are first
accessed.

This optimization is only performed when the model does not have any
transactional callbacks (e.g. `after_commit` and `after_create`).

Unfortunately, the models used to test the affected codepaths all
comes with some sort of transactional callbacks. Therefore this
codepath remains largely untested until now and as a result there are
a few issues in the implementation that remains hidden until now.

First, the `sync_with_transaction_state` (or more accurately,
`update_attributes_from_transaction_state`) would perform the
synchronization prematurely before a transaction is finalized (i.e.
comitted or rolled back). As a result, when the actuall rollback
happens, the record will incorrectly assumes that its internal states
match the transaction state, and neglect to perform the restore.

Second, `update_attributes_from_transaction_state` calls `committed!`
in some cases. This in turns checks for the `destroyed?` state which
also requires synchronization with the transaction stae, which causes
an infnite recurrsion.

This fix works by deferring the synchronization until the transaction
has been finalized (addressing the first point), and also unrolled
the `committed!` and `rolledback!` logic in-place (addressing the
second point).

It should be noted that the primary purpose of the `committed!` and
`rolledback!` methods are to trigger the relevant transactional
callbacks. Since this code path is only entered when there are no
transactional callbacks on the model, this shouldn't be necessary. By
unrolling the method calls, the intention here (to restore the states
when necessary) becomes more clear.
Merge pull request #13751 from chancancode/ar_rollback_fix

Restore ActiveRecord states after a rollback for models w/o callbacks
spring gem moved to rails/spring
Merge pull request #13756 from huoxito/rails-spring

spring gem moved to rails/spring
Spring in now under rails/spring [ci skip]
Merge pull request #13759 from raysrashmi/rails-spring

Spring in now under rails/spring [ci skip]
Update Changelog, Spring is under rails/spring [ci skip]