Added test to ensure that DescendantsTracker does not leak memory on singleton classes
Change ActionController::Parameters#require behavior when value is empty
When the value for the required key is empty an ActionController::ParameterMissing is raised which gets caught by ActionController::Base and turned into a 400 Bad Request reply with a message in the body saying the key is missing, which is misleading.

With these changes, ActionController::EmptyParameter will be raised which ActionController::Base will catch and turn into a 400 Bad Request reply with a message in the body saying the key value is empty.
Fix doc in Postgres database creation
add active model basics wip to guides/documents.yaml
Remove sqlite specific`supports_autoincrement?` which always defaults to true
support :unless_exist for FileCache
allow to test AR master against AR-JDBC master (with `ENV['AR_JDBC']`)
`export AR_JDBC=true` on travis-ci as a *before_install* (but on jruby only)
Moved all JSON core extensions into core_ext/object/json

TL;DR The primary driver is to remove autoload surprise.

This is related to #12106. (The root cause for that ticket is that
json/add defines Regexp#to_json among others, but here I'll reproduce
the problem without json/add.)

Before:

   >> require 'active_support/core_ext/to_json'
   => true
   >> //.as_json
   NoMethodError: undefined method `as_json' for //:Regexp
     from (irb):3
     from /Users/godfrey/.rvm/rubies/ruby-2.0.0-p195/bin/irb:16:in `<main>'
   >> //.to_json
   => "\"(?-mix:)\""
   >> //.as_json
   => "(?-mix:)"

After:

   >> require 'active_support/core_ext/to_json'
   => true
   >> //.as_json
   => "(?-mix:)"

This is because ActiveSupport::JSON is autoloaded the first time
Object#to_json is called, which causes additional core extentions
(previously defined in active_support/json/encoding.rb) to be loaded.

When someone require 'active_support/core_ext', the expectation is
that it would add certain methods to the core classes NOW. The
previous behaviour causes additional methods to be loaded the first
time you call `to_json`, which could cause nasty surprises and other
unplesant side-effects.

This change moves all core extensions in to core_ext/json. AS::JSON is
still autoloaded on first #to_json call, but since it nolonger
include the core extensions, it should address the aforementioned bug.

*Requiring core_ext/object/to_json now causes a deprecation warnning*
Add params option for button_to

The parameters are rendered as hidden form fields within the generated
form. This is useful for when a record has multiple buttons associated
with it, each of which target the same controller method, but which
need to submit different attributes.
Renamed generated_feature_methods to generated_association_methods.
fixed a doc bug in the CHANGELOG.md s/does no longer depend on/no longer depends on/
Use ActiveRecord::Base#update! instead of #update_attributes!
[ci skip] Add explanation on Rack::Sendfile and fix serve static files setting.
Just change ENV and restore it afterwards.

Stubbing ENV[] is not safe outside MRI. At some point after the
stubbing has occurred a backtrace is printed to the ActiveSupport
warning log: there Rubinius accesses ENV['RBX_NOCOLOR'] to determine
if it should print the backtrace with colors or not, causing the
stub to fail. Other implementations might access ENV in a different
way too, we just can't predict it.
The only thing we can do here is to actually set the ENV with what
we want and restore it afterwards.
this code is never used, remove it
remove more dead code

We control the inputs to `construct`, so the wrong type shouldn't be
passed in ever.
extract the string handling part to a method.

We know the structure passed in to the `construct` method will be a
hash, so we don't need to test it all the time.  The key value will be a
symbol or string, so handle it with the special method
Assert presence of "frozen" in error message, not the full MRI message.

Related to all the other issues regarding message independent assertions
to make Rails compatible with other Ruby implementations other than MRI.

The best way here would be to have a specific error raised when modifying
frozen objects, like FrozenObjectError or something. But since Ruby
doesn't provide such a thing, we must limit the assertion to the lowest
common denominator, which is word "frozen".
Allow methods arity below -1 in assert_responds.

Every method from MRI's core classes is written in C. This means
Method#arity always returns -1 for methods with a variable number of
arguments. This is not the case with Rubinius, where, for example
Array#slice! is implemented in Ruby and has arity -2, since is
defined as def slice!(start, length = undefined)