modernizes hash syntax in activerecord

62 files changed, 535 insertions, 536 deletions

diff --git a/activerecord/test/models/admin/user.rb b/activerecord/test/models/admin/user.rb
index 3cd829a8d5..2e703f6219 100644
--- a/activerecord/test/models/admin/user.rb
+++ b/activerecord/test/models/admin/user.rb
@@ -15,11 +15,11 @@ class Admin::User < ActiveRecord::Base
 
   belongs_to :account
   store :params, accessors: [ :token ], coder: YAML
-  store :settings, :accessors => [ :color, :homepage ]
+  store :settings, accessors: [ :color, :homepage ]
   store_accessor :settings, :favorite_food
-  store :preferences, :accessors => [ :remember_login ]
-  store :json_data, :accessors => [ :height, :weight ], :coder => Coder.new
-  store :json_data_empty, :accessors => [ :is_a_good_guy ], :coder => Coder.new
+  store :preferences, accessors: [ :remember_login ]
+  store :json_data, accessors: [ :height, :weight ], coder: Coder.new
+  store :json_data_empty, accessors: [ :is_a_good_guy ], coder: Coder.new
 
   def phone_number
     read_store_attribute(:settings, :phone_number).gsub(/(\d{3})(\d{3})(\d{4})/,'(\1) \2-\3')
diff --git a/activerecord/test/models/aircraft.rb b/activerecord/test/models/aircraft.rb
index c4404a8094..ebd42ff824 100644
--- a/activerecord/test/models/aircraft.rb
+++ b/activerecord/test/models/aircraft.rb
@@ -1,5 +1,5 @@
 class Aircraft < ActiveRecord::Base
   self.pluralize_table_names = false
-  has_many :engines, :foreign_key => "car_id"
+  has_many :engines, foreign_key: "car_id"
   has_many :wheels, as: :wheelable
 end
diff --git a/activerecord/test/models/author.rb b/activerecord/test/models/author.rb
index a9f3063736..8633504d54 100644
--- a/activerecord/test/models/author.rb
+++ b/activerecord/test/models/author.rb
@@ -2,33 +2,33 @@ class Author < ActiveRecord::Base
   has_many :posts
   has_many :serialized_posts
   has_one :post
-  has_many :very_special_comments, :through => :posts
-  has_many :posts_with_comments, -> { includes(:comments) }, :class_name => "Post"
-  has_many :popular_grouped_posts, -> { includes(:comments).group("type").having("SUM(comments_count) > 1").select("type") }, :class_name => "Post"
-  has_many :posts_with_comments_sorted_by_comment_id, -> { includes(:comments).order("comments.id") }, :class_name => "Post"
-  has_many :posts_sorted_by_id_limited, -> { order("posts.id").limit(1) }, :class_name => "Post"
-  has_many :posts_with_categories, -> { includes(:categories) }, :class_name => "Post"
-  has_many :posts_with_comments_and_categories, -> { includes(:comments, :categories).order("posts.id") }, :class_name => "Post"
-  has_many :posts_with_special_categorizations, :class_name => "PostWithSpecialCategorization"
-  has_one  :post_about_thinking, -> { where("posts.title like '%thinking%'") }, :class_name => "Post"
-  has_one  :post_about_thinking_with_last_comment, -> { where("posts.title like '%thinking%'").includes(:last_comment) }, :class_name => "Post"
+  has_many :very_special_comments, through: :posts
+  has_many :posts_with_comments, -> { includes(:comments) }, class_name: "Post"
+  has_many :popular_grouped_posts, -> { includes(:comments).group("type").having("SUM(comments_count) > 1").select("type") }, class_name: "Post"
+  has_many :posts_with_comments_sorted_by_comment_id, -> { includes(:comments).order("comments.id") }, class_name: "Post"
+  has_many :posts_sorted_by_id_limited, -> { order("posts.id").limit(1) }, class_name: "Post"
+  has_many :posts_with_categories, -> { includes(:categories) }, class_name: "Post"
+  has_many :posts_with_comments_and_categories, -> { includes(:comments, :categories).order("posts.id") }, class_name: "Post"
+  has_many :posts_with_special_categorizations, class_name: "PostWithSpecialCategorization"
+  has_one  :post_about_thinking, -> { where("posts.title like '%thinking%'") }, class_name: "Post"
+  has_one  :post_about_thinking_with_last_comment, -> { where("posts.title like '%thinking%'").includes(:last_comment) }, class_name: "Post"
   has_many :comments, through: :posts do
     def ratings
       Rating.joins(:comment).merge(self)
     end
   end
-  has_many :comments_containing_the_letter_e, :through => :posts, :source => :comments
-  has_many :comments_with_order_and_conditions, -> { order("comments.body").where("comments.body like 'Thank%'") }, :through => :posts, :source => :comments
-  has_many :comments_with_include, -> { includes(:post) }, :through => :posts, :source => :comments
+  has_many :comments_containing_the_letter_e, through: :posts, source: :comments
+  has_many :comments_with_order_and_conditions, -> { order("comments.body").where("comments.body like 'Thank%'") }, through: :posts, source: :comments
+  has_many :comments_with_include, -> { includes(:post) }, through: :posts, source: :comments
 
   has_many :first_posts
-  has_many :comments_on_first_posts, -> { order("posts.id desc, comments.id asc") }, :through => :first_posts, :source => :comments
+  has_many :comments_on_first_posts, -> { order("posts.id desc, comments.id asc") }, through: :first_posts, source: :comments
 
   has_one :first_post
-  has_one :comment_on_first_post, -> { order("posts.id desc, comments.id asc") }, :through => :first_post, :source => :comments
+  has_one :comment_on_first_post, -> { order("posts.id desc, comments.id asc") }, through: :first_post, source: :comments
 
-  has_many :thinking_posts, -> { where(:title => "So I was thinking") }, :dependent => :delete_all, :class_name => "Post"
-  has_many :welcome_posts, -> { where(:title => "Welcome to the weblog") }, :class_name => "Post"
+  has_many :thinking_posts, -> { where(title: "So I was thinking") }, dependent: :delete_all, class_name: "Post"
+  has_many :welcome_posts, -> { where(title: "Welcome to the weblog") }, class_name: "Post"
 
   has_many :welcome_posts_with_one_comment,
            -> { where(title: "Welcome to the weblog").where("comments_count = ?", 1) },
@@ -37,110 +37,109 @@ class Author < ActiveRecord::Base
            -> { where(title: "Welcome to the weblog").where(Post.arel_table[:comments_count].gt(0)) },
            class_name: "Post"
 
-  has_many :comments_desc, -> { order("comments.id DESC") }, :through => :posts, :source => :comments
-  has_many :funky_comments, :through => :posts, :source => :comments
-  has_many :ordered_uniq_comments, -> { distinct.order("comments.id") }, :through => :posts, :source => :comments
-  has_many :ordered_uniq_comments_desc, -> { distinct.order("comments.id DESC") }, :through => :posts, :source => :comments
-  has_many :readonly_comments, -> { readonly }, :through => :posts, :source => :comments
+  has_many :comments_desc, -> { order("comments.id DESC") }, through: :posts, source: :comments
+  has_many :funky_comments, through: :posts, source: :comments
+  has_many :ordered_uniq_comments, -> { distinct.order("comments.id") }, through: :posts, source: :comments
+  has_many :ordered_uniq_comments_desc, -> { distinct.order("comments.id DESC") }, through: :posts, source: :comments
+  has_many :readonly_comments, -> { readonly }, through: :posts, source: :comments
 
   has_many :special_posts
-  has_many :special_post_comments, :through => :special_posts, :source => :comments
-  has_many :special_posts_with_default_scope, :class_name => "SpecialPostWithDefaultScope"
-
-  has_many :sti_posts, :class_name => "StiPost"
-  has_many :sti_post_comments, :through => :sti_posts, :source => :comments
-
-  has_many :special_nonexistent_posts, -> { where("posts.body = 'nonexistent'") }, :class_name => "SpecialPost"
-  has_many :special_nonexistent_post_comments, -> { where("comments.post_id" => 0) }, :through => :special_nonexistent_posts, :source => :comments
-  has_many :nonexistent_comments, :through => :posts
-
-  has_many :hello_posts, -> { where "posts.body = 'hello'" }, :class_name => "Post"
-  has_many :hello_post_comments, :through => :hello_posts, :source => :comments
-  has_many :posts_with_no_comments, -> { where("comments.id" => nil).includes(:comments) }, :class_name => "Post"
-
-  has_many :hello_posts_with_hash_conditions, -> { where(:body => "hello") }, :class_name => "Post"
-  has_many :hello_post_comments_with_hash_conditions, :through =>
-:hello_posts_with_hash_conditions, :source => :comments
-
-  has_many :other_posts,          :class_name => "Post"
-  has_many :posts_with_callbacks, :class_name => "Post", :before_add => :log_before_adding,
-           :after_add     => :log_after_adding,
-           :before_remove => :log_before_removing,
-           :after_remove  => :log_after_removing
-  has_many :posts_with_proc_callbacks, :class_name => "Post",
-           :before_add    => Proc.new {|o, r| o.post_log << "before_adding#{r.id || '<new>'}"},
-           :after_add     => Proc.new {|o, r| o.post_log << "after_adding#{r.id || '<new>'}"},
-           :before_remove => Proc.new {|o, r| o.post_log << "before_removing#{r.id}"},
-           :after_remove  => Proc.new {|o, r| o.post_log << "after_removing#{r.id}"}
-  has_many :posts_with_multiple_callbacks, :class_name => "Post",
-           :before_add => [:log_before_adding, Proc.new {|o, r| o.post_log << "before_adding_proc#{r.id || '<new>'}"}],
-           :after_add  => [:log_after_adding,  Proc.new {|o, r| o.post_log << "after_adding_proc#{r.id || '<new>'}"}]
-  has_many :unchangeable_posts, :class_name => "Post", :before_add => :raise_exception, :after_add => :log_after_adding
+  has_many :special_post_comments, through: :special_posts, source: :comments
+  has_many :special_posts_with_default_scope, class_name: "SpecialPostWithDefaultScope"
+
+  has_many :sti_posts, class_name: "StiPost"
+  has_many :sti_post_comments, through: :sti_posts, source: :comments
+
+  has_many :special_nonexistent_posts, -> { where("posts.body = 'nonexistent'") }, class_name: "SpecialPost"
+  has_many :special_nonexistent_post_comments, -> { where("comments.post_id" => 0) }, through: :special_nonexistent_posts, source: :comments
+  has_many :nonexistent_comments, through: :posts
+
+  has_many :hello_posts, -> { where "posts.body = 'hello'" }, class_name: "Post"
+  has_many :hello_post_comments, through: :hello_posts, source: :comments
+  has_many :posts_with_no_comments, -> { where("comments.id" => nil).includes(:comments) }, class_name: "Post"
+
+  has_many :hello_posts_with_hash_conditions, -> { where(body: "hello") }, class_name: "Post"
+  has_many :hello_post_comments_with_hash_conditions, through: :hello_posts_with_hash_conditions, source: :comments
+
+  has_many :other_posts,          class_name: "Post"
+  has_many :posts_with_callbacks, class_name: "Post", before_add: :log_before_adding,
+           after_add: :log_after_adding,
+           before_remove: :log_before_removing,
+           after_remove: :log_after_removing
+  has_many :posts_with_proc_callbacks, class_name: "Post",
+           before_add: Proc.new {|o, r| o.post_log << "before_adding#{r.id || '<new>'}"},
+           after_add: Proc.new {|o, r| o.post_log << "after_adding#{r.id || '<new>'}"},
+           before_remove: Proc.new {|o, r| o.post_log << "before_removing#{r.id}"},
+           after_remove: Proc.new {|o, r| o.post_log << "after_removing#{r.id}"}
+  has_many :posts_with_multiple_callbacks, class_name: "Post",
+           before_add: [:log_before_adding, Proc.new {|o, r| o.post_log << "before_adding_proc#{r.id || '<new>'}"}],
+           after_add: [:log_after_adding,  Proc.new {|o, r| o.post_log << "after_adding_proc#{r.id || '<new>'}"}]
+  has_many :unchangeable_posts, class_name: "Post", before_add: :raise_exception, after_add: :log_after_adding
 
   has_many :categorizations
-  has_many :categories, :through => :categorizations
-  has_many :named_categories, :through => :categorizations
+  has_many :categories, through: :categorizations
+  has_many :named_categories, through: :categorizations
 
   has_many :special_categorizations
-  has_many :special_categories, :through => :special_categorizations, :source => :category
-  has_one  :special_category,   :through => :special_categorizations, :source => :category
+  has_many :special_categories, through: :special_categorizations, source: :category
+  has_one  :special_category,   through: :special_categorizations, source: :category
 
-  has_many :categories_like_general, -> { where(:name => "General") }, :through => :categorizations, :source => :category, :class_name => "Category"
+  has_many :categories_like_general, -> { where(name: "General") }, through: :categorizations, source: :category, class_name: "Category"
 
-  has_many :categorized_posts, :through => :categorizations, :source => :post
-  has_many :unique_categorized_posts, -> { distinct }, :through => :categorizations, :source => :post
+  has_many :categorized_posts, through: :categorizations, source: :post
+  has_many :unique_categorized_posts, -> { distinct }, through: :categorizations, source: :post
 
-  has_many :nothings, :through => :kateggorisatons, :class_name => "Category"
+  has_many :nothings, through: :kateggorisatons, class_name: "Category"
 
   has_many :author_favorites
-  has_many :favorite_authors, -> { order("name") }, :through => :author_favorites
+  has_many :favorite_authors, -> { order("name") }, through: :author_favorites
 
-  has_many :taggings,        :through => :posts, :source => :taggings
-  has_many :taggings_2,      :through => :posts, :source => :tagging
-  has_many :tags,            :through => :posts
-  has_many :post_categories, :through => :posts, :source => :categories
-  has_many :tagging_tags,    :through => :taggings, :source => :tag
+  has_many :taggings,        through: :posts, source: :taggings
+  has_many :taggings_2,      through: :posts, source: :tagging
+  has_many :tags,            through: :posts
+  has_many :post_categories, through: :posts, source: :categories
+  has_many :tagging_tags,    through: :taggings, source: :tag
 
-  has_many :similar_posts, -> { distinct }, :through => :tags, :source => :tagged_posts
-  has_many :distinct_tags, -> { select("DISTINCT tags.*").order("tags.name") }, :through => :posts, :source => :tags
+  has_many :similar_posts, -> { distinct }, through: :tags, source: :tagged_posts
+  has_many :distinct_tags, -> { select("DISTINCT tags.*").order("tags.name") }, through: :posts, source: :tags
 
-  has_many :tags_with_primary_key, :through => :posts
+  has_many :tags_with_primary_key, through: :posts
 
   has_many :books
-  has_many :subscriptions,        :through => :books
-  has_many :subscribers, -> { order("subscribers.nick") }, :through => :subscriptions
-  has_many :distinct_subscribers, -> { select("DISTINCT subscribers.*").order("subscribers.nick") }, :through => :subscriptions, :source => :subscriber
+  has_many :subscriptions,        through: :books
+  has_many :subscribers, -> { order("subscribers.nick") }, through: :subscriptions
+  has_many :distinct_subscribers, -> { select("DISTINCT subscribers.*").order("subscribers.nick") }, through: :subscriptions, source: :subscriber
 
-  has_one :essay, :primary_key => :name, :as => :writer
-  has_one :essay_category, :through => :essay, :source => :category
-  has_one :essay_owner, :through => :essay, :source => :owner
+  has_one :essay, primary_key: :name, as: :writer
+  has_one :essay_category, through: :essay, source: :category
+  has_one :essay_owner, through: :essay, source: :owner
 
-  has_one :essay_2, :primary_key => :name, :class_name => "Essay", :foreign_key => :author_id
-  has_one :essay_category_2, :through => :essay_2, :source => :category
+  has_one :essay_2, primary_key: :name, class_name: "Essay", foreign_key: :author_id
+  has_one :essay_category_2, through: :essay_2, source: :category
 
-  has_many :essays, :primary_key => :name, :as => :writer
-  has_many :essay_categories, :through => :essays, :source => :category
-  has_many :essay_owners, :through => :essays, :source => :owner
+  has_many :essays, primary_key: :name, as: :writer
+  has_many :essay_categories, through: :essays, source: :category
+  has_many :essay_owners, through: :essays, source: :owner
 
-  has_many :essays_2, :primary_key => :name, :class_name => "Essay", :foreign_key => :author_id
-  has_many :essay_categories_2, :through => :essays_2, :source => :category
+  has_many :essays_2, primary_key: :name, class_name: "Essay", foreign_key: :author_id
+  has_many :essay_categories_2, through: :essays_2, source: :category
 
-  belongs_to :owned_essay, :primary_key => :name, :class_name => "Essay"
-  has_one :owned_essay_category, :through => :owned_essay, :source => :category
+  belongs_to :owned_essay, primary_key: :name, class_name: "Essay"
+  has_one :owned_essay_category, through: :owned_essay, source: :category
 
-  belongs_to :author_address,       :dependent => :destroy
-  belongs_to :author_address_extra, :dependent => :delete, :class_name => "AuthorAddress"
+  belongs_to :author_address,       dependent: :destroy
+  belongs_to :author_address_extra, dependent: :delete, class_name: "AuthorAddress"
 
-  has_many :category_post_comments, :through => :categories, :source => :post_comments
+  has_many :category_post_comments, through: :categories, source: :post_comments
 
-  has_many :misc_posts, -> { where(:posts => { :title => ["misc post by bob", "misc post by mary"] }) }, :class_name => "Post"
-  has_many :misc_post_first_blue_tags, :through => :misc_posts, :source => :first_blue_tags
+  has_many :misc_posts, -> { where(posts: { title: ["misc post by bob", "misc post by mary"] }) }, class_name: "Post"
+  has_many :misc_post_first_blue_tags, through: :misc_posts, source: :first_blue_tags
 
-  has_many :misc_post_first_blue_tags_2, -> { where(:posts => { :title => ["misc post by bob", "misc post by mary"] }) },
-           :through => :posts, :source => :first_blue_tags_2
+  has_many :misc_post_first_blue_tags_2, -> { where(posts: { title: ["misc post by bob", "misc post by mary"] }) },
+           through: :posts, source: :first_blue_tags_2
 
-  has_many :posts_with_default_include, :class_name => "PostWithDefaultInclude"
-  has_many :comments_on_posts_with_default_include, :through => :posts_with_default_include, :source => :comments
+  has_many :posts_with_default_include, class_name: "PostWithDefaultInclude"
+  has_many :comments_on_posts_with_default_include, through: :posts_with_default_include, source: :comments
 
   has_many :posts_with_signature, ->(record) { where("posts.title LIKE ?", "%by #{record.name.downcase}%") }, class_name: "Post"
 
@@ -205,5 +204,5 @@ end
 
 class AuthorFavorite < ActiveRecord::Base
   belongs_to :author
-  belongs_to :favorite_author, :class_name => "Author"
+  belongs_to :favorite_author, class_name: "Author"
 end
diff --git a/activerecord/test/models/bird.rb b/activerecord/test/models/bird.rb
index 2a51d903b8..24b839135d 100644
--- a/activerecord/test/models/bird.rb
+++ b/activerecord/test/models/bird.rb
@@ -5,7 +5,7 @@ class Bird < ActiveRecord::Base
   accepts_nested_attributes_for :pirate
 
   attr_accessor :cancel_save_from_callback
-  before_save :cancel_save_callback_method, :if => :cancel_save_from_callback
+  before_save :cancel_save_callback_method, if: :cancel_save_from_callback
   def cancel_save_callback_method
     throw(:abort)
   end
diff --git a/activerecord/test/models/book.rb b/activerecord/test/models/book.rb
index 5db4f64b74..edd0281127 100644
--- a/activerecord/test/models/book.rb
+++ b/activerecord/test/models/book.rb
@@ -1,7 +1,7 @@
 class Book < ActiveRecord::Base
   has_many :authors
 
-  has_many :citations, :foreign_key => "book1_id"
+  has_many :citations, foreign_key: "book1_id"
   has_many :references, -> { distinct }, through: :citations, source: :reference_of
 
   has_many :subscriptions
diff --git a/activerecord/test/models/bulb.rb b/activerecord/test/models/bulb.rb
index 88baa60035..3196207ac9 100644
--- a/activerecord/test/models/bulb.rb
+++ b/activerecord/test/models/bulb.rb
@@ -1,6 +1,6 @@
 class Bulb < ActiveRecord::Base
-  default_scope { where(:name => "defaulty") }
-  belongs_to :car, :touch => true
+  default_scope { where(name: "defaulty") }
+  belongs_to :car, touch: true
   scope :awesome, -> { where(frickinawesome: true) }
 
   attr_reader :scope_after_initialize, :attributes_after_initialize
diff --git a/activerecord/test/models/car.rb b/activerecord/test/models/car.rb
index 9f129689ef..92bff7ff96 100644
--- a/activerecord/test/models/car.rb
+++ b/activerecord/test/models/car.rb
@@ -3,16 +3,16 @@ class Car < ActiveRecord::Base
   has_many :all_bulbs, -> { unscope where: :name }, class_name: "Bulb"
   has_many :funky_bulbs, class_name: "FunkyBulb", dependent: :destroy
   has_many :failed_bulbs, class_name: "FailedBulb", dependent: :destroy
-  has_many :foo_bulbs, -> { where(:name => "foo") }, :class_name => "Bulb"
+  has_many :foo_bulbs, -> { where(name: "foo") }, class_name: "Bulb"
   has_many :awesome_bulbs, -> { awesome }, class_name: "Bulb"
 
   has_one :bulb
 
   has_many :tyres
-  has_many :engines, :dependent => :destroy, inverse_of: :my_car
-  has_many :wheels, :as => :wheelable, :dependent => :destroy
+  has_many :engines, dependent: :destroy, inverse_of: :my_car
+  has_many :wheels, as: :wheelable, dependent: :destroy
 
-  has_many :price_estimates, :as => :estimate_of
+  has_many :price_estimates, as: :estimate_of
 
   scope :incl_tyres, -> { includes(:tyres) }
   scope :incl_engines, -> { includes(:engines) }
diff --git a/activerecord/test/models/categorization.rb b/activerecord/test/models/categorization.rb
index 178aff0541..b99383d0b1 100644
--- a/activerecord/test/models/categorization.rb
+++ b/activerecord/test/models/categorization.rb
@@ -1,18 +1,18 @@
 class Categorization < ActiveRecord::Base
   belongs_to :post
   belongs_to :category, counter_cache: true
-  belongs_to :named_category, :class_name => "Category", :foreign_key => :named_category_name, :primary_key => :name
+  belongs_to :named_category, class_name: "Category", foreign_key: :named_category_name, primary_key: :name
   belongs_to :author
 
-  has_many :post_taggings, :through => :author, :source => :taggings
+  has_many :post_taggings, through: :author, source: :taggings
 
-  belongs_to :author_using_custom_pk,  :class_name => "Author", :foreign_key => :author_id, :primary_key => :author_address_extra_id
-  has_many   :authors_using_custom_pk, :class_name => "Author", :foreign_key => :id,        :primary_key => :category_id
+  belongs_to :author_using_custom_pk,  class_name: "Author", foreign_key: :author_id, primary_key: :author_address_extra_id
+  has_many   :authors_using_custom_pk, class_name: "Author", foreign_key: :id,        primary_key: :category_id
 end
 
 class SpecialCategorization < ActiveRecord::Base
   self.table_name = "categorizations"
-  default_scope { where(:special => true) }
+  default_scope { where(special: true) }
 
   belongs_to :author
   belongs_to :category
diff --git a/activerecord/test/models/category.rb b/activerecord/test/models/category.rb
index 0c6794ff65..e8654dca01 100644
--- a/activerecord/test/models/category.rb
+++ b/activerecord/test/models/category.rb
@@ -1,21 +1,21 @@
 class Category < ActiveRecord::Base
   has_and_belongs_to_many :posts
-  has_and_belongs_to_many :special_posts, :class_name => "Post"
-  has_and_belongs_to_many :other_posts, :class_name => "Post"
-  has_and_belongs_to_many :posts_with_authors_sorted_by_author_id, -> { includes(:authors).order("authors.id") }, :class_name => "Post"
+  has_and_belongs_to_many :special_posts, class_name: "Post"
+  has_and_belongs_to_many :other_posts, class_name: "Post"
+  has_and_belongs_to_many :posts_with_authors_sorted_by_author_id, -> { includes(:authors).order("authors.id") }, class_name: "Post"
 
   has_and_belongs_to_many :select_testing_posts,
                           -> { select "posts.*, 1 as correctness_marker" },
-                          :class_name => "Post",
-                          :foreign_key => "category_id",
-                          :association_foreign_key => "post_id"
+                          class_name: "Post",
+                          foreign_key: "category_id",
+                          association_foreign_key: "post_id"
 
   has_and_belongs_to_many :post_with_conditions,
-                          -> { where :title => "Yet Another Testing Title" },
-                          :class_name => "Post"
+                          -> { where title: "Yet Another Testing Title" },
+                          class_name: "Post"
 
-  has_and_belongs_to_many :popular_grouped_posts, -> { group("posts.type").having("sum(comments.post_id) > 2").includes(:comments) }, :class_name => "Post"
-  has_and_belongs_to_many :posts_grouped_by_title, -> { group("title").select("title") }, :class_name => "Post"
+  has_and_belongs_to_many :popular_grouped_posts, -> { group("posts.type").having("sum(comments.post_id) > 2").includes(:comments) }, class_name: "Post"
+  has_and_belongs_to_many :posts_grouped_by_title, -> { group("title").select("title") }, class_name: "Post"
 
   def self.what_are_you
     "a category..."
@@ -23,12 +23,12 @@ class Category < ActiveRecord::Base
 
   has_many :categorizations
   has_many :special_categorizations
-  has_many :post_comments, :through => :posts, :source => :comments
+  has_many :post_comments, through: :posts, source: :comments
 
-  has_many :authors, :through => :categorizations
-  has_many :authors_with_select, -> { select "authors.*, categorizations.post_id" }, :through => :categorizations, :source => :author
+  has_many :authors, through: :categorizations
+  has_many :authors_with_select, -> { select "authors.*, categorizations.post_id" }, through: :categorizations, source: :author
 
-  scope :general, -> { where(:name => "General") }
+  scope :general, -> { where(name: "General") }
 end
 
 class SpecialCategory < Category
diff --git a/activerecord/test/models/citation.rb b/activerecord/test/models/citation.rb
index 3d87eb795c..7d06387f56 100644
--- a/activerecord/test/models/citation.rb
+++ b/activerecord/test/models/citation.rb
@@ -1,3 +1,3 @@
 class Citation < ActiveRecord::Base
-  belongs_to :reference_of, :class_name => "Book", :foreign_key => :book2_id
+  belongs_to :reference_of, class_name: "Book", foreign_key: :book2_id
 end
diff --git a/activerecord/test/models/club.rb b/activerecord/test/models/club.rb
index e1b3e706f2..b2986a8c58 100644
--- a/activerecord/test/models/club.rb
+++ b/activerecord/test/models/club.rb
@@ -1,9 +1,9 @@
 class Club < ActiveRecord::Base
   has_one :membership
-  has_many :memberships, :inverse_of => false
-  has_many :members, :through => :memberships
+  has_many :memberships, inverse_of: false
+  has_many :members, through: :memberships
   has_one :sponsor
-  has_one :sponsored_member, :through => :sponsor, :source => :sponsorable, :source_type => "Member"
+  has_one :sponsored_member, through: :sponsor, source: :sponsorable, source_type: "Member"
   belongs_to :category
 
   has_many :favourites, -> { where(memberships: { favourite: true }) }, through: :memberships, source: :member
diff --git a/activerecord/test/models/comment.rb b/activerecord/test/models/comment.rb
index 45463b69f2..7315a1af8e 100644
--- a/activerecord/test/models/comment.rb
+++ b/activerecord/test/models/comment.rb
@@ -2,22 +2,22 @@ class Comment < ActiveRecord::Base
   scope :limit_by, lambda {|l| limit(l) }
   scope :containing_the_letter_e, -> { where("comments.body LIKE '%e%'") }
   scope :not_again, -> { where("comments.body NOT LIKE '%again%'") }
-  scope :for_first_post, -> { where(:post_id => 1) }
+  scope :for_first_post, -> { where(post_id: 1) }
   scope :for_first_author, -> { joins(:post).where("posts.author_id" => 1) }
   scope :created, -> { all }
 
-  belongs_to :post, :counter_cache => true
+  belongs_to :post, counter_cache: true
   belongs_to :author,   polymorphic: true
   belongs_to :resource, polymorphic: true
   belongs_to :developer
 
   has_many :ratings
 
-  belongs_to :first_post, :foreign_key => :post_id
+  belongs_to :first_post, foreign_key: :post_id
   belongs_to :special_post_with_default_scope, foreign_key: :post_id
 
-  has_many :children, :class_name => "Comment", :foreign_key => :parent_id
-  belongs_to :parent, :class_name => "Comment", :counter_cache => :children_count
+  has_many :children, class_name: "Comment", foreign_key: :parent_id
+  belongs_to :parent, class_name: "Comment", counter_cache: :children_count
 
   def self.what_are_you
     "a comment..."
diff --git a/activerecord/test/models/company.rb b/activerecord/test/models/company.rb
index 6a01dae18d..921cf10f30 100644
--- a/activerecord/test/models/company.rb
+++ b/activerecord/test/models/company.rb
@@ -7,12 +7,12 @@ class Company < AbstractCompany
 
   validates_presence_of :name
 
-  has_one :dummy_account, :foreign_key => "firm_id", :class_name => "Account"
+  has_one :dummy_account, foreign_key: "firm_id", class_name: "Account"
   has_many :contracts
-  has_many :developers, :through => :contracts
+  has_many :developers, through: :contracts
 
   scope :of_first_firm, lambda {
-    joins(:account => :firm).
+    joins(account: :firm).
     where("firms.id" => 1)
   }
 
@@ -35,7 +35,7 @@ module Namespaced
   end
 
   class Firm < ::Company
-    has_many :clients, :class_name => "Namespaced::Client"
+    has_many :clients, class_name: "Namespaced::Client"
   end
 
   class Client < ::Company
@@ -45,45 +45,45 @@ end
 class Firm < Company
   to_param :name
 
-  has_many :clients, -> { order "id" }, :dependent => :destroy, :before_remove => :log_before_remove, :after_remove  => :log_after_remove
-  has_many :unsorted_clients, :class_name => "Client"
-  has_many :unsorted_clients_with_symbol, :class_name => :Client
-  has_many :clients_sorted_desc, -> { order "id DESC" }, :class_name => "Client"
-  has_many :clients_of_firm, -> { order "id" }, :foreign_key => "client_of", :class_name => "Client", :inverse_of => :firm
-  has_many :clients_ordered_by_name, -> { order "name" }, :class_name => "Client"
-  has_many :unvalidated_clients_of_firm, :foreign_key => "client_of", :class_name => "Client", :validate => false
-  has_many :dependent_clients_of_firm, -> { order "id" }, :foreign_key => "client_of", :class_name => "Client", :dependent => :destroy
-  has_many :exclusively_dependent_clients_of_firm, -> { order "id" }, :foreign_key => "client_of", :class_name => "Client", :dependent => :delete_all
-  has_many :limited_clients, -> { limit 1 }, :class_name => "Client"
-  has_many :clients_with_interpolated_conditions, ->(firm) { where "rating > #{firm.rating}" }, :class_name => "Client"
-  has_many :clients_like_ms, -> { where("name = 'Microsoft'").order("id") }, :class_name => "Client"
-  has_many :clients_like_ms_with_hash_conditions, -> { where(:name => "Microsoft").order("id") }, :class_name => "Client"
-  has_many :plain_clients, :class_name => "Client"
-  has_many :clients_using_primary_key, :class_name => "Client",
-           :primary_key => "name", :foreign_key => "firm_name"
-  has_many :clients_using_primary_key_with_delete_all, :class_name => "Client",
-           :primary_key => "name", :foreign_key => "firm_name", :dependent => :delete_all
-  has_many :clients_grouped_by_firm_id, -> { group("firm_id").select("firm_id") }, :class_name => "Client"
-  has_many :clients_grouped_by_name, -> { group("name").select("name") }, :class_name => "Client"
-
-  has_one :account, :foreign_key => "firm_id", :dependent => :destroy, :validate => true
-  has_one :unvalidated_account, :foreign_key => "firm_id", :class_name => "Account", :validate => false
-  has_one :account_with_select, -> { select("id, firm_id") }, :foreign_key => "firm_id", :class_name=>"Account"
-  has_one :readonly_account, -> { readonly }, :foreign_key => "firm_id", :class_name => "Account"
+  has_many :clients, -> { order "id" }, dependent: :destroy, before_remove: :log_before_remove, after_remove: :log_after_remove
+  has_many :unsorted_clients, class_name: "Client"
+  has_many :unsorted_clients_with_symbol, class_name: :Client
+  has_many :clients_sorted_desc, -> { order "id DESC" }, class_name: "Client"
+  has_many :clients_of_firm, -> { order "id" }, foreign_key: "client_of", class_name: "Client", inverse_of: :firm
+  has_many :clients_ordered_by_name, -> { order "name" }, class_name: "Client"
+  has_many :unvalidated_clients_of_firm, foreign_key: "client_of", class_name: "Client", validate: false
+  has_many :dependent_clients_of_firm, -> { order "id" }, foreign_key: "client_of", class_name: "Client", dependent: :destroy
+  has_many :exclusively_dependent_clients_of_firm, -> { order "id" }, foreign_key: "client_of", class_name: "Client", dependent: :delete_all
+  has_many :limited_clients, -> { limit 1 }, class_name: "Client"
+  has_many :clients_with_interpolated_conditions, ->(firm) { where "rating > #{firm.rating}" }, class_name: "Client"
+  has_many :clients_like_ms, -> { where("name = 'Microsoft'").order("id") }, class_name: "Client"
+  has_many :clients_like_ms_with_hash_conditions, -> { where(name: "Microsoft").order("id") }, class_name: "Client"
+  has_many :plain_clients, class_name: "Client"
+  has_many :clients_using_primary_key, class_name: "Client",
+           primary_key: "name", foreign_key: "firm_name"
+  has_many :clients_using_primary_key_with_delete_all, class_name: "Client",
+           primary_key: "name", foreign_key: "firm_name", dependent: :delete_all
+  has_many :clients_grouped_by_firm_id, -> { group("firm_id").select("firm_id") }, class_name: "Client"
+  has_many :clients_grouped_by_name, -> { group("name").select("name") }, class_name: "Client"
+
+  has_one :account, foreign_key: "firm_id", dependent: :destroy, validate: true
+  has_one :unvalidated_account, foreign_key: "firm_id", class_name: "Account", validate: false
+  has_one :account_with_select, -> { select("id, firm_id") }, foreign_key: "firm_id", class_name: "Account"
+  has_one :readonly_account, -> { readonly }, foreign_key: "firm_id", class_name: "Account"
   # added order by id as in fixtures there are two accounts for Rails Core
   # Oracle tests were failing because of that as the second fixture was selected
-  has_one :account_using_primary_key, -> { order("id") }, :primary_key => "firm_id", :class_name => "Account"
-  has_one :account_using_foreign_and_primary_keys, :foreign_key => "firm_name", :primary_key => "name", :class_name => "Account"
+  has_one :account_using_primary_key, -> { order("id") }, primary_key: "firm_id", class_name: "Account"
+  has_one :account_using_foreign_and_primary_keys, foreign_key: "firm_name", primary_key: "name", class_name: "Account"
   has_one :account_with_inexistent_foreign_key, class_name: "Account", foreign_key: "inexistent"
-  has_one :deletable_account, :foreign_key => "firm_id", :class_name => "Account", :dependent => :delete
+  has_one :deletable_account, foreign_key: "firm_id", class_name: "Account", dependent: :delete
 
-  has_one :account_limit_500_with_hash_conditions, -> { where :credit_limit => 500 }, :foreign_key => "firm_id", :class_name => "Account"
+  has_one :account_limit_500_with_hash_conditions, -> { where credit_limit: 500 }, foreign_key: "firm_id", class_name: "Account"
 
-  has_one :unautosaved_account, :foreign_key => "firm_id", :class_name => "Account", :autosave => false
+  has_one :unautosaved_account, foreign_key: "firm_id", class_name: "Account", autosave: false
   has_many :accounts
-  has_many :unautosaved_accounts, :foreign_key => "firm_id", :class_name => "Account", :autosave => false
+  has_many :unautosaved_accounts, foreign_key: "firm_id", class_name: "Account", autosave: false
 
-  has_many :association_with_references, -> { references(:foo) }, :class_name => "Client"
+  has_many :association_with_references, -> { references(:foo) }, class_name: "Client"
 
   has_one :lead_developer, class_name: "Developer"
   has_many :projects
@@ -103,32 +103,32 @@ class Firm < Company
 end
 
 class DependentFirm < Company
-  has_one :account, :foreign_key => "firm_id", :dependent => :nullify
-  has_many :companies, :foreign_key => "client_of", :dependent => :nullify
-  has_one :company, :foreign_key => "client_of", :dependent => :nullify
+  has_one :account, foreign_key: "firm_id", dependent: :nullify
+  has_many :companies, foreign_key: "client_of", dependent: :nullify
+  has_one :company, foreign_key: "client_of", dependent: :nullify
 end
 
 class RestrictedWithExceptionFirm < Company
-  has_one :account, -> { order("id") }, :foreign_key => "firm_id", :dependent => :restrict_with_exception
-  has_many :companies, -> { order("id") }, :foreign_key => "client_of", :dependent => :restrict_with_exception
+  has_one :account, -> { order("id") }, foreign_key: "firm_id", dependent: :restrict_with_exception
+  has_many :companies, -> { order("id") }, foreign_key: "client_of", dependent: :restrict_with_exception
 end
 
 class RestrictedWithErrorFirm < Company
-  has_one :account, -> { order("id") }, :foreign_key => "firm_id", :dependent => :restrict_with_error
-  has_many :companies, -> { order("id") }, :foreign_key => "client_of", :dependent => :restrict_with_error
+  has_one :account, -> { order("id") }, foreign_key: "firm_id", dependent: :restrict_with_error
+  has_many :companies, -> { order("id") }, foreign_key: "client_of", dependent: :restrict_with_error
 end
 
 class Client < Company
-  belongs_to :firm, :foreign_key => "client_of"
-  belongs_to :firm_with_basic_id, :class_name => "Firm", :foreign_key => "firm_id"
-  belongs_to :firm_with_select, -> { select("id") }, :class_name => "Firm", :foreign_key => "firm_id"
-  belongs_to :firm_with_other_name, :class_name => "Firm", :foreign_key => "client_of"
-  belongs_to :firm_with_condition, -> { where "1 = ?", 1 }, :class_name => "Firm", :foreign_key => "client_of"
-  belongs_to :firm_with_primary_key, :class_name => "Firm", :primary_key => "name", :foreign_key => "firm_name"
-  belongs_to :firm_with_primary_key_symbols, :class_name => "Firm", :primary_key => :name, :foreign_key => :firm_name
-  belongs_to :readonly_firm, -> { readonly }, :class_name => "Firm", :foreign_key => "firm_id"
-  belongs_to :bob_firm, -> { where :name => "Bob" }, :class_name => "Firm", :foreign_key => "client_of"
-  has_many :accounts, :through => :firm, :source => :accounts
+  belongs_to :firm, foreign_key: "client_of"
+  belongs_to :firm_with_basic_id, class_name: "Firm", foreign_key: "firm_id"
+  belongs_to :firm_with_select, -> { select("id") }, class_name: "Firm", foreign_key: "firm_id"
+  belongs_to :firm_with_other_name, class_name: "Firm", foreign_key: "client_of"
+  belongs_to :firm_with_condition, -> { where "1 = ?", 1 }, class_name: "Firm", foreign_key: "client_of"
+  belongs_to :firm_with_primary_key, class_name: "Firm", primary_key: "name", foreign_key: "firm_name"
+  belongs_to :firm_with_primary_key_symbols, class_name: "Firm", primary_key: :name, foreign_key: :firm_name
+  belongs_to :readonly_firm, -> { readonly }, class_name: "Firm", foreign_key: "firm_id"
+  belongs_to :bob_firm, -> { where name: "Bob" }, class_name: "Firm", foreign_key: "client_of"
+  has_many :accounts, through: :firm, source: :accounts
   belongs_to :account
 
   validate do
@@ -181,9 +181,9 @@ class Client < Company
 end
 
 class ExclusivelyDependentFirm < Company
-  has_one :account, :foreign_key => "firm_id", :dependent => :delete
-  has_many :dependent_sanitized_conditional_clients_of_firm, -> { order("id").where("name = 'BigShot Inc.'") }, :foreign_key => "client_of", :class_name => "Client", :dependent => :delete_all
-  has_many :dependent_conditional_clients_of_firm, -> { order("id").where("name = ?", "BigShot Inc.") }, :foreign_key => "client_of", :class_name => "Client", :dependent => :delete_all
+  has_one :account, foreign_key: "firm_id", dependent: :delete
+  has_many :dependent_sanitized_conditional_clients_of_firm, -> { order("id").where("name = 'BigShot Inc.'") }, foreign_key: "client_of", class_name: "Client", dependent: :delete_all
+  has_many :dependent_conditional_clients_of_firm, -> { order("id").where("name = ?", "BigShot Inc.") }, foreign_key: "client_of", class_name: "Client", dependent: :delete_all
 end
 
 class SpecialClient < Client
@@ -193,8 +193,8 @@ class VerySpecialClient < SpecialClient
 end
 
 class Account < ActiveRecord::Base
-  belongs_to :firm, :class_name => "Company"
-  belongs_to :unautosaved_firm, :foreign_key => "firm_id", :class_name => "Firm", :autosave => false
+  belongs_to :firm, class_name: "Company"
+  belongs_to :unautosaved_firm, foreign_key: "firm_id", class_name: "Firm", autosave: false
 
   alias_attribute :available_credit, :credit_limit
 
diff --git a/activerecord/test/models/company_in_module.rb b/activerecord/test/models/company_in_module.rb
index b444f9c49c..e035a80ab8 100644
--- a/activerecord/test/models/company_in_module.rb
+++ b/activerecord/test/models/company_in_module.rb
@@ -6,23 +6,23 @@ module MyApplication
     end
 
     class Firm < Company
-      has_many :clients, -> { order("id") }, :dependent => :destroy
-      has_many :clients_sorted_desc, -> { order("id DESC") }, :class_name => "Client"
-      has_many :clients_of_firm, -> { order "id" }, :foreign_key => "client_of", :class_name => "Client"
-      has_many :clients_like_ms, -> { where("name = 'Microsoft'").order("id") }, :class_name => "Client"
-      has_one :account, :class_name => "MyApplication::Billing::Account", :dependent => :destroy
+      has_many :clients, -> { order("id") }, dependent: :destroy
+      has_many :clients_sorted_desc, -> { order("id DESC") }, class_name: "Client"
+      has_many :clients_of_firm, -> { order "id" }, foreign_key: "client_of", class_name: "Client"
+      has_many :clients_like_ms, -> { where("name = 'Microsoft'").order("id") }, class_name: "Client"
+      has_one :account, class_name: "MyApplication::Billing::Account", dependent: :destroy
     end
 
     class Client < Company
-      belongs_to :firm, :foreign_key => "client_of"
-      belongs_to :firm_with_other_name, :class_name => "Firm", :foreign_key => "client_of"
+      belongs_to :firm, foreign_key: "client_of"
+      belongs_to :firm_with_other_name, class_name: "Firm", foreign_key: "client_of"
 
       class Contact < ActiveRecord::Base; end
     end
 
     class Developer < ActiveRecord::Base
       has_and_belongs_to_many :projects
-      validates_length_of :name, :within => (3..20)
+      validates_length_of :name, within: (3..20)
     end
 
     class Project < ActiveRecord::Base
@@ -78,12 +78,12 @@ module MyApplication
     end
 
     class Account < ActiveRecord::Base
-      with_options(:foreign_key => :firm_id) do |i|
-        i.belongs_to :firm, :class_name => "MyApplication::Business::Firm"
-        i.belongs_to :qualified_billing_firm, :class_name => "MyApplication::Billing::Firm"
-        i.belongs_to :unqualified_billing_firm, :class_name => "Firm"
-        i.belongs_to :nested_qualified_billing_firm, :class_name => "MyApplication::Billing::Nested::Firm"
-        i.belongs_to :nested_unqualified_billing_firm, :class_name => "Nested::Firm"
+      with_options(foreign_key: :firm_id) do |i|
+        i.belongs_to :firm, class_name: "MyApplication::Business::Firm"
+        i.belongs_to :qualified_billing_firm, class_name: "MyApplication::Billing::Firm"
+        i.belongs_to :unqualified_billing_firm, class_name: "Firm"
+        i.belongs_to :nested_qualified_billing_firm, class_name: "MyApplication::Billing::Nested::Firm"
+        i.belongs_to :nested_unqualified_billing_firm, class_name: "Nested::Firm"
       end
 
       validate :check_empty_credit_limit
diff --git a/activerecord/test/models/computer.rb b/activerecord/test/models/computer.rb
index 0295ff9736..1c9856e1af 100644
--- a/activerecord/test/models/computer.rb
+++ b/activerecord/test/models/computer.rb
@@ -1,3 +1,3 @@
 class Computer < ActiveRecord::Base
-  belongs_to :developer, :foreign_key=>"developer"
+  belongs_to :developer, foreign_key: "developer"
 end
diff --git a/activerecord/test/models/contact.rb b/activerecord/test/models/contact.rb
index 15e3832204..47bbbbfd8b 100644
--- a/activerecord/test/models/contact.rb
+++ b/activerecord/test/models/contact.rb
@@ -1,7 +1,7 @@
 module ContactFakeColumns
   def self.extended(base)
     base.class_eval do
-      establish_connection(:adapter => "fake")
+      establish_connection(adapter: "fake")
 
       connection.data_sources = [table_name]
       connection.primary_keys = {
@@ -19,7 +19,7 @@ module ContactFakeColumns
 
       serialize :preferences
 
-      belongs_to :alternative, :class_name => "Contact"
+      belongs_to :alternative, class_name: "Contact"
     end
   end
 
diff --git a/activerecord/test/models/contract.rb b/activerecord/test/models/contract.rb
index e16758498f..32bd581377 100644
--- a/activerecord/test/models/contract.rb
+++ b/activerecord/test/models/contract.rb
@@ -1,7 +1,7 @@
 class Contract < ActiveRecord::Base
   belongs_to :company
   belongs_to :developer
-  belongs_to :firm, :foreign_key => "company_id"
+  belongs_to :firm, foreign_key: "company_id"
 
   before_save :hi
   after_save :bye
diff --git a/activerecord/test/models/customer.rb b/activerecord/test/models/customer.rb
index d464759430..71afd0866e 100644
--- a/activerecord/test/models/customer.rb
+++ b/activerecord/test/models/customer.rb
@@ -1,13 +1,13 @@
 class Customer < ActiveRecord::Base
   cattr_accessor :gps_conversion_was_run
 
-  composed_of :address, :mapping => [ %w(address_street street), %w(address_city city), %w(address_country country) ], :allow_nil => true
-  composed_of :balance, :class_name => "Money", :mapping => %w(balance amount), :converter => Proc.new(&:to_money)
-  composed_of :gps_location, :allow_nil => true
-  composed_of :non_blank_gps_location, :class_name => "GpsLocation", :allow_nil => true, :mapping => %w(gps_location gps_location),
-              :converter => lambda { |gps| self.gps_conversion_was_run = true; gps.blank? ? nil : GpsLocation.new(gps)}
-  composed_of :fullname, :mapping => %w(name to_s), :constructor => Proc.new { |name| Fullname.parse(name) }, :converter => :parse
-  composed_of :fullname_no_converter, :mapping => %w(name to_s), class_name: "Fullname"
+  composed_of :address, mapping: [ %w(address_street street), %w(address_city city), %w(address_country country) ], allow_nil: true
+  composed_of :balance, class_name: "Money", mapping: %w(balance amount), converter: Proc.new(&:to_money)
+  composed_of :gps_location, allow_nil: true
+  composed_of :non_blank_gps_location, class_name: "GpsLocation", allow_nil: true, mapping: %w(gps_location gps_location),
+              converter: lambda { |gps| self.gps_conversion_was_run = true; gps.blank? ? nil : GpsLocation.new(gps)}
+  composed_of :fullname, mapping: %w(name to_s), constructor: Proc.new { |name| Fullname.parse(name) }, converter: :parse
+  composed_of :fullname_no_converter, mapping: %w(name to_s), class_name: "Fullname"
 end
 
 class Address
diff --git a/activerecord/test/models/developer.rb b/activerecord/test/models/developer.rb
index 41cbe35cb4..6dc3c6d632 100644
--- a/activerecord/test/models/developer.rb
+++ b/activerecord/test/models/developer.rb
@@ -23,35 +23,35 @@ class Developer < ActiveRecord::Base
 
   has_and_belongs_to_many :projects_extended_by_name,
       -> { extending(DeveloperProjectsAssociationExtension) },
-      :class_name => "Project",
-      :join_table => "developers_projects",
-      :association_foreign_key => "project_id"
+      class_name: "Project",
+      join_table: "developers_projects",
+      association_foreign_key: "project_id"
 
   has_and_belongs_to_many :projects_extended_by_name_twice,
       -> { extending(DeveloperProjectsAssociationExtension, DeveloperProjectsAssociationExtension2) },
-      :class_name => "Project",
-      :join_table => "developers_projects",
-      :association_foreign_key => "project_id"
+      class_name: "Project",
+      join_table: "developers_projects",
+      association_foreign_key: "project_id"
 
   has_and_belongs_to_many :projects_extended_by_name_and_block,
       -> { extending(DeveloperProjectsAssociationExtension) },
-      :class_name => "Project",
-      :join_table => "developers_projects",
-      :association_foreign_key => "project_id" do
+      class_name: "Project",
+      join_table: "developers_projects",
+      association_foreign_key: "project_id" do
         def find_least_recent
           order("id ASC").first
         end
       end
 
-  has_and_belongs_to_many :special_projects, :join_table => "developers_projects", :association_foreign_key => "project_id"
+  has_and_belongs_to_many :special_projects, join_table: "developers_projects", association_foreign_key: "project_id"
   has_and_belongs_to_many :sym_special_projects,
-                          :join_table => :developers_projects,
-                          :association_foreign_key => "project_id",
-                          :class_name => "SpecialProject"
+                          join_table: :developers_projects,
+                          association_foreign_key: "project_id",
+                          class_name: "SpecialProject"
 
   has_many :audit_logs
   has_many :contracts
-  has_many :firms, :through => :contracts, :source => :firm
+  has_many :firms, through: :contracts, source: :firm
   has_many :comments, ->(developer) { where(body: "I'm #{developer.name}") }
   has_many :ratings, through: :comments
   has_one :ship, dependent: :nullify
@@ -59,20 +59,20 @@ class Developer < ActiveRecord::Base
   belongs_to :firm
   has_many :contracted_projects, class_name: "Project"
 
-  scope :jamises, -> { where(:name => "Jamis") }
+  scope :jamises, -> { where(name: "Jamis") }
 
-  validates_inclusion_of :salary, :in => 50000..200000
-  validates_length_of    :name, :within => 3..20
+  validates_inclusion_of :salary, in: 50000..200000
+  validates_length_of    :name, within: 3..20
 
   before_create do |developer|
-    developer.audit_logs.build :message => "Computer created"
+    developer.audit_logs.build message: "Computer created"
   end
 
   attr_accessor :last_name
   define_attribute_method "last_name"
 
   def log=(message)
-    audit_logs.build :message => message
+    audit_logs.build message: message
   end
 
   after_find :track_instance_count
@@ -87,13 +87,13 @@ class Developer < ActiveRecord::Base
 end
 
 class AuditLog < ActiveRecord::Base
-  belongs_to :developer, :validate => true
-  belongs_to :unvalidated_developer, :class_name => "Developer"
+  belongs_to :developer, validate: true
+  belongs_to :unvalidated_developer, class_name: "Developer"
 end
 
 class DeveloperWithBeforeDestroyRaise < ActiveRecord::Base
   self.table_name = "developers"
-  has_and_belongs_to_many :projects, :join_table => "developers_projects", :foreign_key => "developer_id"
+  has_and_belongs_to_many :projects, join_table: "developers_projects", foreign_key: "developer_id"
   before_destroy :raise_if_projects_empty!
 
   def raise_if_projects_empty!
@@ -108,16 +108,16 @@ end
 
 class DeveloperWithIncludes < ActiveRecord::Base
   self.table_name = "developers"
-  has_many :audit_logs, :foreign_key => :developer_id
+  has_many :audit_logs, foreign_key: :developer_id
   default_scope { includes(:audit_logs) }
 end
 
 class DeveloperFilteredOnJoins < ActiveRecord::Base
   self.table_name = "developers"
-  has_and_belongs_to_many :projects, -> { order("projects.id") }, :foreign_key => "developer_id", :join_table => "developers_projects"
+  has_and_belongs_to_many :projects, -> { order("projects.id") }, foreign_key: "developer_id", join_table: "developers_projects"
 
   def self.default_scope
-    joins(:projects).where(:projects => { :name => "Active Controller" })
+    joins(:projects).where(projects: { name: "Active Controller" })
   end
 end
 
@@ -135,30 +135,30 @@ end
 
 class LazyLambdaDeveloperCalledDavid < ActiveRecord::Base
   self.table_name = "developers"
-  default_scope lambda { where(:name => "David") }
+  default_scope lambda { where(name: "David") }
 end
 
 class LazyBlockDeveloperCalledDavid < ActiveRecord::Base
   self.table_name = "developers"
-  default_scope { where(:name => "David") }
+  default_scope { where(name: "David") }
 end
 
 class CallableDeveloperCalledDavid < ActiveRecord::Base
   self.table_name = "developers"
-  default_scope OpenStruct.new(:call => where(:name => "David"))
+  default_scope OpenStruct.new(call: where(name: "David"))
 end
 
 class ClassMethodDeveloperCalledDavid < ActiveRecord::Base
   self.table_name = "developers"
 
   def self.default_scope
-    where(:name => "David")
+    where(name: "David")
   end
 end
 
 class ClassMethodReferencingScopeDeveloperCalledDavid < ActiveRecord::Base
   self.table_name = "developers"
-  scope :david, -> { where(:name => "David") }
+  scope :david, -> { where(name: "David") }
 
   def self.default_scope
     david
@@ -167,14 +167,14 @@ end
 
 class LazyBlockReferencingScopeDeveloperCalledDavid < ActiveRecord::Base
   self.table_name = "developers"
-  scope :david, -> { where(:name => "David") }
+  scope :david, -> { where(name: "David") }
   default_scope { david }
 end
 
 class DeveloperCalledJamis < ActiveRecord::Base
   self.table_name = "developers"
 
-  default_scope { where(:name => "Jamis") }
+  default_scope { where(name: "Jamis") }
   scope :poor, -> { where("salary < 150000") }
   scope :david, -> { where name: "David" }
   scope :david2, -> { unscoped.where name: "David" }
@@ -183,26 +183,26 @@ end
 class PoorDeveloperCalledJamis < ActiveRecord::Base
   self.table_name = "developers"
 
-  default_scope -> { where(:name => "Jamis", :salary => 50000) }
+  default_scope -> { where(name: "Jamis", salary: 50000) }
 end
 
 class InheritedPoorDeveloperCalledJamis < DeveloperCalledJamis
   self.table_name = "developers"
 
-  default_scope -> { where(:salary => 50000) }
+  default_scope -> { where(salary: 50000) }
 end
 
 class MultiplePoorDeveloperCalledJamis < ActiveRecord::Base
   self.table_name = "developers"
 
-  default_scope -> { where(:name => "Jamis") }
-  default_scope -> { where(:salary => 50000) }
+  default_scope -> { where(name: "Jamis") }
+  default_scope -> { where(salary: 50000) }
 end
 
 module SalaryDefaultScope
   extend ActiveSupport::Concern
 
-  included { default_scope { where(:salary => 50000) } }
+  included { default_scope { where(salary: 50000) } }
 end
 
 class ModuleIncludedPoorDeveloperCalledJamis < DeveloperCalledJamis
@@ -213,14 +213,14 @@ end
 
 class EagerDeveloperWithDefaultScope < ActiveRecord::Base
   self.table_name = "developers"
-  has_and_belongs_to_many :projects, -> { order("projects.id") }, :foreign_key => "developer_id", :join_table => "developers_projects"
+  has_and_belongs_to_many :projects, -> { order("projects.id") }, foreign_key: "developer_id", join_table: "developers_projects"
 
   default_scope { includes(:projects) }
 end
 
 class EagerDeveloperWithClassMethodDefaultScope < ActiveRecord::Base
   self.table_name = "developers"
-  has_and_belongs_to_many :projects, -> { order("projects.id") }, :foreign_key => "developer_id", :join_table => "developers_projects"
+  has_and_belongs_to_many :projects, -> { order("projects.id") }, foreign_key: "developer_id", join_table: "developers_projects"
 
   def self.default_scope
     includes(:projects)
@@ -229,23 +229,23 @@ end
 
 class EagerDeveloperWithLambdaDefaultScope < ActiveRecord::Base
   self.table_name = "developers"
-  has_and_belongs_to_many :projects, -> { order("projects.id") }, :foreign_key => "developer_id", :join_table => "developers_projects"
+  has_and_belongs_to_many :projects, -> { order("projects.id") }, foreign_key: "developer_id", join_table: "developers_projects"
 
   default_scope lambda { includes(:projects) }
 end
 
 class EagerDeveloperWithBlockDefaultScope < ActiveRecord::Base
   self.table_name = "developers"
-  has_and_belongs_to_many :projects, -> { order("projects.id") }, :foreign_key => "developer_id", :join_table => "developers_projects"
+  has_and_belongs_to_many :projects, -> { order("projects.id") }, foreign_key: "developer_id", join_table: "developers_projects"
 
   default_scope { includes(:projects) }
 end
 
 class EagerDeveloperWithCallableDefaultScope < ActiveRecord::Base
   self.table_name = "developers"
-  has_and_belongs_to_many :projects, -> { order("projects.id") }, :foreign_key => "developer_id", :join_table => "developers_projects"
+  has_and_belongs_to_many :projects, -> { order("projects.id") }, foreign_key: "developer_id", join_table: "developers_projects"
 
-  default_scope OpenStruct.new(:call => includes(:projects))
+  default_scope OpenStruct.new(call: includes(:projects))
 end
 
 class ThreadsafeDeveloper < ActiveRecord::Base
diff --git a/activerecord/test/models/edge.rb b/activerecord/test/models/edge.rb
index 1de4756b28..e61d25c9bc 100644
--- a/activerecord/test/models/edge.rb
+++ b/activerecord/test/models/edge.rb
@@ -1,5 +1,5 @@
 # This class models an edge in a directed graph.
 class Edge < ActiveRecord::Base
-  belongs_to :source, :class_name => "Vertex", :foreign_key => "source_id"
-  belongs_to :sink,   :class_name => "Vertex", :foreign_key => "sink_id"
+  belongs_to :source, class_name: "Vertex", foreign_key: "source_id"
+  belongs_to :sink,   class_name: "Vertex", foreign_key: "sink_id"
 end
diff --git a/activerecord/test/models/engine.rb b/activerecord/test/models/engine.rb
index c30502e3ea..50c6717037 100644
--- a/activerecord/test/models/engine.rb
+++ b/activerecord/test/models/engine.rb
@@ -1,4 +1,4 @@
 class Engine < ActiveRecord::Base
-  belongs_to :my_car, :class_name => "Car", :foreign_key => "car_id",  :counter_cache => :engines_count
+  belongs_to :my_car, class_name: "Car", foreign_key: "car_id",  counter_cache: :engines_count
 end
 
diff --git a/activerecord/test/models/essay.rb b/activerecord/test/models/essay.rb
index ec4b982b5b..13267fbc21 100644
--- a/activerecord/test/models/essay.rb
+++ b/activerecord/test/models/essay.rb
@@ -1,5 +1,5 @@
 class Essay < ActiveRecord::Base
-  belongs_to :writer, :primary_key => :name, :polymorphic => true
-  belongs_to :category, :primary_key => :name
-  has_one :owner, :primary_key => :name
+  belongs_to :writer, primary_key: :name, polymorphic: true
+  belongs_to :category, primary_key: :name
+  has_one :owner, primary_key: :name
 end
diff --git a/activerecord/test/models/face.rb b/activerecord/test/models/face.rb
index 5f33372b16..5913bfa969 100644
--- a/activerecord/test/models/face.rb
+++ b/activerecord/test/models/face.rb
@@ -1,9 +1,9 @@
 class Face < ActiveRecord::Base
-  belongs_to :man, :inverse_of => :face
-  belongs_to :polymorphic_man, :polymorphic => true, :inverse_of => :polymorphic_face
+  belongs_to :man, inverse_of: :face
+  belongs_to :polymorphic_man, polymorphic: true, inverse_of: :polymorphic_face
   # Oracle identifier length is limited to 30 bytes or less, `polymorphic` renamed `poly`
-  belongs_to :poly_man_without_inverse, :polymorphic => true
+  belongs_to :poly_man_without_inverse, polymorphic: true
   # These is a "broken" inverse_of for the purposes of testing
-  belongs_to :horrible_man, :class_name => "Man", :inverse_of => :horrible_face
-  belongs_to :horrible_polymorphic_man, :polymorphic => true, :inverse_of => :horrible_polymorphic_face
+  belongs_to :horrible_man, class_name: "Man", inverse_of: :horrible_face
+  belongs_to :horrible_polymorphic_man, polymorphic: true, inverse_of: :horrible_polymorphic_face
 end
diff --git a/activerecord/test/models/hotel.rb b/activerecord/test/models/hotel.rb
index 203e384c76..7bc717c891 100644
--- a/activerecord/test/models/hotel.rb
+++ b/activerecord/test/models/hotel.rb
@@ -5,7 +5,7 @@ class Hotel < ActiveRecord::Base
   has_many :drink_designers, source_type: "DrinkDesigner", source: :employable, through: :chefs
 
   has_many :chef_lists, as: :employable_list
-  has_many :mocktail_designers, through: :chef_lists, source: :employable, :source_type => "MocktailDesigner"
+  has_many :mocktail_designers, through: :chef_lists, source: :employable, source_type: "MocktailDesigner"
 
   has_many :recipes, through: :chefs
 end
diff --git a/activerecord/test/models/interest.rb b/activerecord/test/models/interest.rb
index d5d9226204..ec79416ee7 100644
--- a/activerecord/test/models/interest.rb
+++ b/activerecord/test/models/interest.rb
@@ -1,5 +1,5 @@
 class Interest < ActiveRecord::Base
-  belongs_to :man, :inverse_of => :interests
-  belongs_to :polymorphic_man, :polymorphic => true, :inverse_of => :polymorphic_interests
-  belongs_to :zine, :inverse_of => :interests
+  belongs_to :man, inverse_of: :interests
+  belongs_to :polymorphic_man, polymorphic: true, inverse_of: :polymorphic_interests
+  belongs_to :zine, inverse_of: :interests
 end
diff --git a/activerecord/test/models/invoice.rb b/activerecord/test/models/invoice.rb
index fc6ef0230e..44ee717187 100644
--- a/activerecord/test/models/invoice.rb
+++ b/activerecord/test/models/invoice.rb
@@ -1,4 +1,4 @@
 class Invoice < ActiveRecord::Base
-  has_many :line_items, :autosave => true
+  has_many :line_items, autosave: true
   before_save {|record| record.balance = record.line_items.map(&:amount).sum }
 end
diff --git a/activerecord/test/models/item.rb b/activerecord/test/models/item.rb
index c2571dd7fb..336fb1769a 100644
--- a/activerecord/test/models/item.rb
+++ b/activerecord/test/models/item.rb
@@ -1,6 +1,6 @@
 class AbstractItem < ActiveRecord::Base
   self.abstract_class = true
-  has_one :tagging, :as => :taggable
+  has_one :tagging, as: :taggable
 end
 
 class Item < AbstractItem
diff --git a/activerecord/test/models/job.rb b/activerecord/test/models/job.rb
index 267f73bd6f..bbaef2792c 100644
--- a/activerecord/test/models/job.rb
+++ b/activerecord/test/models/job.rb
@@ -1,7 +1,7 @@
 class Job < ActiveRecord::Base
   has_many :references
-  has_many :people, :through => :references
-  belongs_to :ideal_reference, :class_name => "Reference"
+  has_many :people, through: :references
+  belongs_to :ideal_reference, class_name: "Reference"
 
-  has_many :agents, :through => :people
+  has_many :agents, through: :people
 end
diff --git a/activerecord/test/models/line_item.rb b/activerecord/test/models/line_item.rb
index 0dd921a300..93f7cceb13 100644
--- a/activerecord/test/models/line_item.rb
+++ b/activerecord/test/models/line_item.rb
@@ -1,3 +1,3 @@
 class LineItem < ActiveRecord::Base
-  belongs_to :invoice, :touch => true
+  belongs_to :invoice, touch: true
 end
diff --git a/activerecord/test/models/man.rb b/activerecord/test/models/man.rb
index 797c46dcbe..d2436a735c 100644
--- a/activerecord/test/models/man.rb
+++ b/activerecord/test/models/man.rb
@@ -1,11 +1,11 @@
 class Man < ActiveRecord::Base
-  has_one :face, :inverse_of => :man
-  has_one :polymorphic_face, :class_name => "Face", :as => :polymorphic_man, :inverse_of => :polymorphic_man
-  has_one :polymorphic_face_without_inverse, :class_name => "Face", :as => :poly_man_without_inverse
-  has_many :interests, :inverse_of => :man
-  has_many :polymorphic_interests, :class_name => "Interest", :as => :polymorphic_man, :inverse_of => :polymorphic_man
+  has_one :face, inverse_of: :man
+  has_one :polymorphic_face, class_name: "Face", as: :polymorphic_man, inverse_of: :polymorphic_man
+  has_one :polymorphic_face_without_inverse, class_name: "Face", as: :poly_man_without_inverse
+  has_many :interests, inverse_of: :man
+  has_many :polymorphic_interests, class_name: "Interest", as: :polymorphic_man, inverse_of: :polymorphic_man
   # These are "broken" inverse_of associations for the purposes of testing
-  has_one :dirty_face, :class_name => "Face", :inverse_of => :dirty_man
-  has_many :secret_interests, :class_name => "Interest", :inverse_of => :secret_man
+  has_one :dirty_face, class_name: "Face", inverse_of: :dirty_man
+  has_many :secret_interests, class_name: "Interest", inverse_of: :secret_man
   has_one :mixed_case_monkey
 end
diff --git a/activerecord/test/models/matey.rb b/activerecord/test/models/matey.rb
index 1badaede0a..80ee5f47c5 100644
--- a/activerecord/test/models/matey.rb
+++ b/activerecord/test/models/matey.rb
@@ -1,4 +1,4 @@
 class Matey < ActiveRecord::Base
   belongs_to :pirate
-  belongs_to :target, :class_name => "Pirate"
+  belongs_to :target, class_name: "Pirate"
 end
diff --git a/activerecord/test/models/member.rb b/activerecord/test/models/member.rb
index dd90d3e92b..93dfc8253f 100644
--- a/activerecord/test/models/member.rb
+++ b/activerecord/test/models/member.rb
@@ -2,34 +2,34 @@ class Member < ActiveRecord::Base
   has_one :current_membership
   has_one :selected_membership
   has_one :membership
-  has_one :club, :through => :current_membership
-  has_one :selected_club, :through => :selected_membership, :source => :club
-  has_one :favourite_club, -> { where "memberships.favourite = ?", true }, :through => :membership, :source => :club
-  has_one :hairy_club, -> { where :clubs => {:name => "Moustache and Eyebrow Fancier Club"} }, :through => :membership, :source => :club
-  has_one :sponsor, :as => :sponsorable
-  has_one :sponsor_club, :through => :sponsor
-  has_one :member_detail, :inverse_of => false
-  has_one :organization, :through => :member_detail
+  has_one :club, through: :current_membership
+  has_one :selected_club, through: :selected_membership, source: :club
+  has_one :favourite_club, -> { where "memberships.favourite = ?", true }, through: :membership, source: :club
+  has_one :hairy_club, -> { where clubs: {name: "Moustache and Eyebrow Fancier Club"} }, through: :membership, source: :club
+  has_one :sponsor, as: :sponsorable
+  has_one :sponsor_club, through: :sponsor
+  has_one :member_detail, inverse_of: false
+  has_one :organization, through: :member_detail
   belongs_to :member_type
 
-  has_many :nested_member_types, :through => :member_detail, :source => :member_type
-  has_one :nested_member_type, :through => :member_detail, :source => :member_type
+  has_many :nested_member_types, through: :member_detail, source: :member_type
+  has_one :nested_member_type, through: :member_detail, source: :member_type
 
-  has_many :nested_sponsors, :through => :sponsor_club, :source => :sponsor
-  has_one :nested_sponsor, :through => :sponsor_club, :source => :sponsor
+  has_many :nested_sponsors, through: :sponsor_club, source: :sponsor
+  has_one :nested_sponsor, through: :sponsor_club, source: :sponsor
 
-  has_many :organization_member_details, :through => :member_detail
-  has_many :organization_member_details_2, :through => :organization, :source => :member_details
+  has_many :organization_member_details, through: :member_detail
+  has_many :organization_member_details_2, through: :organization, source: :member_details
 
-  has_one :club_category, :through => :club, :source => :category
+  has_one :club_category, through: :club, source: :category
 
-  has_many :current_memberships, -> { where :favourite => true }
-  has_many :clubs, :through => :current_memberships
+  has_many :current_memberships, -> { where favourite: true }
+  has_many :clubs, through: :current_memberships
 
   has_many :tenant_memberships
   has_many :tenant_clubs, through: :tenant_memberships, class_name: "Club", source: :club
 
-  has_one :club_through_many, :through => :current_memberships, :source => :club
+  has_one :club_through_many, through: :current_memberships, source: :club
 
   belongs_to :admittable, polymorphic: true
   has_one :premium_club, through: :admittable
@@ -37,5 +37,5 @@ end
 
 class SelfMember < ActiveRecord::Base
   self.table_name = "members"
-  has_and_belongs_to_many :friends, :class_name => "SelfMember", :join_table => "member_friends"
+  has_and_belongs_to_many :friends, class_name: "SelfMember", join_table: "member_friends"
 end
diff --git a/activerecord/test/models/minivan.rb b/activerecord/test/models/minivan.rb
index 4fe79720ad..3c12406425 100644
--- a/activerecord/test/models/minivan.rb
+++ b/activerecord/test/models/minivan.rb
@@ -2,7 +2,7 @@ class Minivan < ActiveRecord::Base
   self.primary_key = :minivan_id
 
   belongs_to :speedometer
-  has_one :dashboard, :through => :speedometer
+  has_one :dashboard, through: :speedometer
 
   attr_readonly :color
 
diff --git a/activerecord/test/models/order.rb b/activerecord/test/models/order.rb
index 4ec7198c88..699be53959 100644
--- a/activerecord/test/models/order.rb
+++ b/activerecord/test/models/order.rb
@@ -1,4 +1,4 @@
 class Order < ActiveRecord::Base
-  belongs_to :billing, :class_name => "Customer", :foreign_key => "billing_customer_id"
-  belongs_to :shipping, :class_name => "Customer", :foreign_key => "shipping_customer_id"
+  belongs_to :billing, class_name: "Customer", foreign_key: "billing_customer_id"
+  belongs_to :shipping, class_name: "Customer", foreign_key: "shipping_customer_id"
 end
diff --git a/activerecord/test/models/organization.rb b/activerecord/test/models/organization.rb
index 1858351dd1..462830dadc 100644
--- a/activerecord/test/models/organization.rb
+++ b/activerecord/test/models/organization.rb
@@ -1,14 +1,14 @@
 class Organization < ActiveRecord::Base
   has_many :member_details
-  has_many :members, :through => :member_details
+  has_many :members, through: :member_details
 
-  has_many :authors, :primary_key => :name
-  has_many :author_essay_categories, :through => :authors, :source => :essay_categories
+  has_many :authors, primary_key: :name
+  has_many :author_essay_categories, through: :authors, source: :essay_categories
 
-  has_one :author, :primary_key => :name
-  has_one :author_owned_essay_category, :through => :author, :source => :owned_essay_category
+  has_one :author, primary_key: :name
+  has_one :author_owned_essay_category, through: :author, source: :owned_essay_category
 
-  has_many :posts, :through => :author, :source => :posts
+  has_many :posts, through: :author, source: :posts
 
   scope :clubs, -> { from("clubs") }
 end
diff --git a/activerecord/test/models/parrot.rb b/activerecord/test/models/parrot.rb
index 9ee9670da9..5b693664d4 100644
--- a/activerecord/test/models/parrot.rb
+++ b/activerecord/test/models/parrot.rb
@@ -3,13 +3,13 @@ class Parrot < ActiveRecord::Base
 
   has_and_belongs_to_many :pirates
   has_and_belongs_to_many :treasures
-  has_many :loots, :as => :looter
+  has_many :loots, as: :looter
   alias_attribute :title, :name
 
   validates_presence_of :name
 
   attr_accessor :cancel_save_from_callback
-  before_save :cancel_save_callback_method, :if => :cancel_save_from_callback
+  before_save :cancel_save_callback_method, if: :cancel_save_from_callback
   def cancel_save_callback_method
     throw(:abort)
   end
@@ -19,5 +19,5 @@ class LiveParrot < Parrot
 end
 
 class DeadParrot < Parrot
-  belongs_to :killer, :class_name => "Pirate", foreign_key: :killer_id
+  belongs_to :killer, class_name: "Pirate", foreign_key: :killer_id
 end
diff --git a/activerecord/test/models/person.rb b/activerecord/test/models/person.rb
index a33b4dca6b..f57d8bdbdf 100644
--- a/activerecord/test/models/person.rb
+++ b/activerecord/test/models/person.rb
@@ -3,10 +3,10 @@ class Person < ActiveRecord::Base
   has_many :secure_readers
   has_one  :reader
 
-  has_many :posts, :through => :readers
-  has_many :secure_posts, :through => :secure_readers
+  has_many :posts, through: :readers
+  has_many :secure_posts, through: :secure_readers
   has_many :posts_with_no_comments, -> { includes(:comments).where("comments.id is null").references(:comments) },
-                                    :through => :readers, :source => :post
+                                    through: :readers, source: :post
 
   has_many :friendships, foreign_key: "friend_id"
   # friends_too exists to test a bug, and probably shouldn't be used elsewhere
@@ -15,49 +15,49 @@ class Person < ActiveRecord::Base
 
   has_many :references
   has_many :bad_references
-  has_many :fixed_bad_references, -> { where :favourite => true }, :class_name => "BadReference"
-  has_one  :favourite_reference, -> { where "favourite=?", true }, :class_name => "Reference"
-  has_many :posts_with_comments_sorted_by_comment_id, -> { includes(:comments).order("comments.id") }, :through => :readers, :source => :post
+  has_many :fixed_bad_references, -> { where favourite: true }, class_name: "BadReference"
+  has_one  :favourite_reference, -> { where "favourite=?", true }, class_name: "Reference"
+  has_many :posts_with_comments_sorted_by_comment_id, -> { includes(:comments).order("comments.id") }, through: :readers, source: :post
   has_many :first_posts, -> { where(id: [1, 2]) }, through: :readers
 
-  has_many :jobs, :through => :references
-  has_many :jobs_with_dependent_destroy,    :source => :job, :through => :references, :dependent => :destroy
-  has_many :jobs_with_dependent_delete_all, :source => :job, :through => :references, :dependent => :delete_all
-  has_many :jobs_with_dependent_nullify,    :source => :job, :through => :references, :dependent => :nullify
+  has_many :jobs, through: :references
+  has_many :jobs_with_dependent_destroy,    source: :job, through: :references, dependent: :destroy
+  has_many :jobs_with_dependent_delete_all, source: :job, through: :references, dependent: :delete_all
+  has_many :jobs_with_dependent_nullify,    source: :job, through: :references, dependent: :nullify
 
-  belongs_to :primary_contact, :class_name => "Person"
-  has_many :agents, :class_name => "Person", :foreign_key => "primary_contact_id"
-  has_many :agents_of_agents, :through => :agents, :source => :agents
-  belongs_to :number1_fan, :class_name => "Person"
+  belongs_to :primary_contact, class_name: "Person"
+  has_many :agents, class_name: "Person", foreign_key: "primary_contact_id"
+  has_many :agents_of_agents, through: :agents, source: :agents
+  belongs_to :number1_fan, class_name: "Person"
 
-  has_many :personal_legacy_things, :dependent => :destroy
+  has_many :personal_legacy_things, dependent: :destroy
 
-  has_many :agents_posts,         :through => :agents,       :source => :posts
-  has_many :agents_posts_authors, :through => :agents_posts, :source => :author
+  has_many :agents_posts,         through: :agents,       source: :posts
+  has_many :agents_posts_authors, through: :agents_posts, source: :author
   has_many :essays, primary_key: "first_name", foreign_key: "writer_id"
 
-  scope :males,   -> { where(:gender => "M") }
+  scope :males,   -> { where(gender: "M") }
 end
 
 class PersonWithDependentDestroyJobs < ActiveRecord::Base
   self.table_name = "people"
 
-  has_many :references, :foreign_key => :person_id
-  has_many :jobs, :source => :job, :through => :references, :dependent => :destroy
+  has_many :references, foreign_key: :person_id
+  has_many :jobs, source: :job, through: :references, dependent: :destroy
 end
 
 class PersonWithDependentDeleteAllJobs < ActiveRecord::Base
   self.table_name = "people"
 
-  has_many :references, :foreign_key => :person_id
-  has_many :jobs, :source => :job, :through => :references, :dependent => :delete_all
+  has_many :references, foreign_key: :person_id
+  has_many :jobs, source: :job, through: :references, dependent: :delete_all
 end
 
 class PersonWithDependentNullifyJobs < ActiveRecord::Base
   self.table_name = "people"
 
-  has_many :references, :foreign_key => :person_id
-  has_many :jobs, :source => :job, :through => :references, :dependent => :nullify
+  has_many :references, foreign_key: :person_id
+  has_many :jobs, source: :job, through: :references, dependent: :nullify
 end
 
 
@@ -65,9 +65,9 @@ class LoosePerson < ActiveRecord::Base
   self.table_name = "people"
   self.abstract_class = true
 
-  has_one    :best_friend,    :class_name => "LoosePerson", :foreign_key => :best_friend_id
-  belongs_to :best_friend_of, :class_name => "LoosePerson", :foreign_key => :best_friend_of_id
-  has_many   :best_friends,   :class_name => "LoosePerson", :foreign_key => :best_friend_id
+  has_one    :best_friend,    class_name: "LoosePerson", foreign_key: :best_friend_id
+  belongs_to :best_friend_of, class_name: "LoosePerson", foreign_key: :best_friend_of_id
+  has_many   :best_friends,   class_name: "LoosePerson", foreign_key: :best_friend_id
 
   accepts_nested_attributes_for :best_friend, :best_friend_of, :best_friends
 end
@@ -77,9 +77,9 @@ class LooseDescendant < LoosePerson; end
 class TightPerson < ActiveRecord::Base
   self.table_name = "people"
 
-  has_one    :best_friend,    :class_name => "TightPerson", :foreign_key => :best_friend_id
-  belongs_to :best_friend_of, :class_name => "TightPerson", :foreign_key => :best_friend_of_id
-  has_many   :best_friends,   :class_name => "TightPerson", :foreign_key => :best_friend_id
+  has_one    :best_friend,    class_name: "TightPerson", foreign_key: :best_friend_id
+  belongs_to :best_friend_of, class_name: "TightPerson", foreign_key: :best_friend_of_id
+  has_many   :best_friends,   class_name: "TightPerson", foreign_key: :best_friend_id
 
   accepts_nested_attributes_for :best_friend, :best_friend_of, :best_friends
 end
@@ -89,7 +89,7 @@ class TightDescendant < TightPerson; end
 class RichPerson < ActiveRecord::Base
   self.table_name = "people"
 
-  has_and_belongs_to_many :treasures, :join_table => "peoples_treasures"
+  has_and_belongs_to_many :treasures, join_table: "peoples_treasures"
 
   before_validation :run_before_create, on: :create
   before_validation :run_before_validation
@@ -108,15 +108,15 @@ end
 class NestedPerson < ActiveRecord::Base
   self.table_name = "people"
 
-  has_one :best_friend, :class_name => "NestedPerson", :foreign_key => :best_friend_id
-  accepts_nested_attributes_for :best_friend, :update_only => true
+  has_one :best_friend, class_name: "NestedPerson", foreign_key: :best_friend_id
+  accepts_nested_attributes_for :best_friend, update_only: true
 
   def comments=(new_comments)
     raise RuntimeError
   end
 
   def best_friend_first_name=(new_name)
-    assign_attributes({ :best_friend_attributes => { :first_name => new_name } })
+    assign_attributes({ best_friend_attributes: { first_name: new_name } })
   end
 end
 
diff --git a/activerecord/test/models/personal_legacy_thing.rb b/activerecord/test/models/personal_legacy_thing.rb
index a7ee3a0bca..adde7a504a 100644
--- a/activerecord/test/models/personal_legacy_thing.rb
+++ b/activerecord/test/models/personal_legacy_thing.rb
@@ -1,4 +1,4 @@
 class PersonalLegacyThing < ActiveRecord::Base
   self.locking_column = :version
-  belongs_to :person, :counter_cache => true
+  belongs_to :person, counter_cache: true
 end
diff --git a/activerecord/test/models/pet.rb b/activerecord/test/models/pet.rb
index 06170837b6..51a3e42815 100644
--- a/activerecord/test/models/pet.rb
+++ b/activerecord/test/models/pet.rb
@@ -2,7 +2,7 @@ class Pet < ActiveRecord::Base
   attr_accessor :current_user
 
   self.primary_key = :pet_id
-  belongs_to :owner, :touch => true
+  belongs_to :owner, touch: true
   has_many :toys
   has_many :pet_treasures
   has_many :treasures, through: :pet_treasures
diff --git a/activerecord/test/models/pirate.rb b/activerecord/test/models/pirate.rb
index 7cb602f445..80a941874b 100644
--- a/activerecord/test/models/pirate.rb
+++ b/activerecord/test/models/pirate.rb
@@ -1,47 +1,47 @@
 class Pirate < ActiveRecord::Base
-  belongs_to :parrot, :validate => true
-  belongs_to :non_validated_parrot, :class_name => "Parrot"
-  has_and_belongs_to_many :parrots, -> { order("parrots.id ASC") }, :validate => true
-  has_and_belongs_to_many :non_validated_parrots, :class_name => "Parrot"
-  has_and_belongs_to_many :parrots_with_method_callbacks, :class_name => "Parrot",
-    :before_add    => :log_before_add,
-    :after_add     => :log_after_add,
-    :before_remove => :log_before_remove,
-    :after_remove  => :log_after_remove
-  has_and_belongs_to_many :parrots_with_proc_callbacks, :class_name => "Parrot",
-    :before_add    => proc {|p,pa| p.ship_log << "before_adding_proc_parrot_#{pa.id || '<new>'}"},
-    :after_add     => proc {|p,pa| p.ship_log << "after_adding_proc_parrot_#{pa.id || '<new>'}"},
-    :before_remove => proc {|p,pa| p.ship_log << "before_removing_proc_parrot_#{pa.id}"},
-    :after_remove  => proc {|p,pa| p.ship_log << "after_removing_proc_parrot_#{pa.id}"}
+  belongs_to :parrot, validate: true
+  belongs_to :non_validated_parrot, class_name: "Parrot"
+  has_and_belongs_to_many :parrots, -> { order("parrots.id ASC") }, validate: true
+  has_and_belongs_to_many :non_validated_parrots, class_name: "Parrot"
+  has_and_belongs_to_many :parrots_with_method_callbacks, class_name: "Parrot",
+    before_add: :log_before_add,
+    after_add: :log_after_add,
+    before_remove: :log_before_remove,
+    after_remove: :log_after_remove
+  has_and_belongs_to_many :parrots_with_proc_callbacks, class_name: "Parrot",
+    before_add: proc {|p,pa| p.ship_log << "before_adding_proc_parrot_#{pa.id || '<new>'}"},
+    after_add: proc {|p,pa| p.ship_log << "after_adding_proc_parrot_#{pa.id || '<new>'}"},
+    before_remove: proc {|p,pa| p.ship_log << "before_removing_proc_parrot_#{pa.id}"},
+    after_remove: proc {|p,pa| p.ship_log << "after_removing_proc_parrot_#{pa.id}"}
   has_and_belongs_to_many :autosaved_parrots, class_name: "Parrot", autosave: true
 
-  has_many :treasures, :as => :looter
-  has_many :treasure_estimates, :through => :treasures, :source => :price_estimates
+  has_many :treasures, as: :looter
+  has_many :treasure_estimates, through: :treasures, source: :price_estimates
 
   has_one :ship
-  has_one :update_only_ship, :class_name => "Ship"
-  has_one :non_validated_ship, :class_name => "Ship"
+  has_one :update_only_ship, class_name: "Ship"
+  has_one :non_validated_ship, class_name: "Ship"
   has_many :birds, -> { order("birds.id ASC") }
-  has_many :birds_with_method_callbacks, :class_name => "Bird",
-    :before_add    => :log_before_add,
-    :after_add     => :log_after_add,
-    :before_remove => :log_before_remove,
-    :after_remove  => :log_after_remove
-  has_many :birds_with_proc_callbacks, :class_name => "Bird",
-    :before_add     => proc {|p,b| p.ship_log << "before_adding_proc_bird_#{b.id || '<new>'}"},
-    :after_add      => proc {|p,b| p.ship_log << "after_adding_proc_bird_#{b.id || '<new>'}"},
-    :before_remove  => proc {|p,b| p.ship_log << "before_removing_proc_bird_#{b.id}"},
-    :after_remove   => proc {|p,b| p.ship_log << "after_removing_proc_bird_#{b.id}"}
-  has_many :birds_with_reject_all_blank, :class_name => "Bird"
+  has_many :birds_with_method_callbacks, class_name: "Bird",
+    before_add: :log_before_add,
+    after_add: :log_after_add,
+    before_remove: :log_before_remove,
+    after_remove: :log_after_remove
+  has_many :birds_with_proc_callbacks, class_name: "Bird",
+    before_add: proc {|p,b| p.ship_log << "before_adding_proc_bird_#{b.id || '<new>'}"},
+    after_add: proc {|p,b| p.ship_log << "after_adding_proc_bird_#{b.id || '<new>'}"},
+    before_remove: proc {|p,b| p.ship_log << "before_removing_proc_bird_#{b.id}"},
+    after_remove: proc {|p,b| p.ship_log << "after_removing_proc_bird_#{b.id}"}
+  has_many :birds_with_reject_all_blank, class_name: "Bird"
 
-  has_one :foo_bulb, -> { where :name => "foo" }, :foreign_key => :car_id, :class_name => "Bulb"
+  has_one :foo_bulb, -> { where name: "foo" }, foreign_key: :car_id, class_name: "Bulb"
 
-  accepts_nested_attributes_for :parrots, :birds, :allow_destroy => true, :reject_if => proc(&:empty?)
-  accepts_nested_attributes_for :ship, :allow_destroy => true, :reject_if => proc(&:empty?)
-  accepts_nested_attributes_for :update_only_ship, :update_only => true
+  accepts_nested_attributes_for :parrots, :birds, allow_destroy: true, reject_if: proc(&:empty?)
+  accepts_nested_attributes_for :ship, allow_destroy: true, reject_if: proc(&:empty?)
+  accepts_nested_attributes_for :update_only_ship, update_only: true
   accepts_nested_attributes_for :parrots_with_method_callbacks, :parrots_with_proc_callbacks,
-    :birds_with_method_callbacks, :birds_with_proc_callbacks, :allow_destroy => true
-  accepts_nested_attributes_for :birds_with_reject_all_blank, :reject_if => :all_blank
+    :birds_with_method_callbacks, :birds_with_proc_callbacks, allow_destroy: true
+  accepts_nested_attributes_for :birds_with_reject_all_blank, reject_if: :all_blank
 
   validates_presence_of :catchphrase
 
@@ -54,7 +54,7 @@ class Pirate < ActiveRecord::Base
   end
 
   attr_accessor :cancel_save_from_callback, :parrots_limit
-  before_save :cancel_save_callback_method, :if => :cancel_save_from_callback
+  before_save :cancel_save_callback_method, if: :cancel_save_from_callback
   def cancel_save_callback_method
     throw(:abort)
   end
@@ -82,7 +82,7 @@ class Pirate < ActiveRecord::Base
 end
 
 class DestructivePirate < Pirate
-  has_one :dependent_ship, :class_name => "Ship", :foreign_key => :pirate_id, :dependent => :destroy
+  has_one :dependent_ship, class_name: "Ship", foreign_key: :pirate_id, dependent: :destroy
 end
 
 class FamousPirate < ActiveRecord::Base
diff --git a/activerecord/test/models/post.rb b/activerecord/test/models/post.rb
index 395ba37e0b..8bfd79d907 100644
--- a/activerecord/test/models/post.rb
+++ b/activerecord/test/models/post.rb
@@ -25,18 +25,18 @@ class Post < ActiveRecord::Base
 
   belongs_to :author
 
-  belongs_to :author_with_posts, -> { includes(:posts) }, :class_name => "Author", :foreign_key => :author_id
-  belongs_to :author_with_address, -> { includes(:author_address) }, :class_name => "Author", :foreign_key => :author_id
+  belongs_to :author_with_posts, -> { includes(:posts) }, class_name: "Author", foreign_key: :author_id
+  belongs_to :author_with_address, -> { includes(:author_address) }, class_name: "Author", foreign_key: :author_id
 
   def first_comment
     super.body
   end
-  has_one :first_comment, -> { order("id ASC") }, :class_name => "Comment"
-  has_one :last_comment, -> { order("id desc") }, :class_name => "Comment"
+  has_one :first_comment, -> { order("id ASC") }, class_name: "Comment"
+  has_one :last_comment, -> { order("id desc") }, class_name: "Comment"
 
-  scope :with_special_comments, -> { joins(:comments).where(:comments => {:type => "SpecialComment"}) }
-  scope :with_very_special_comments, -> { joins(:comments).where(:comments => {:type => "VerySpecialComment"}) }
-  scope :with_post, ->(post_id) { joins(:comments).where(:comments => { :post_id => post_id }) }
+  scope :with_special_comments, -> { joins(:comments).where(comments: {type: "SpecialComment"}) }
+  scope :with_very_special_comments, -> { joins(:comments).where(comments: {type: "VerySpecialComment"}) }
+  scope :with_post, ->(post_id) { joins(:comments).where(comments: { post_id: post_id }) }
 
   scope :with_comments, -> { preload(:comments) }
   scope :with_tags, -> { preload(:taggings) }
@@ -68,29 +68,29 @@ class Post < ActiveRecord::Base
 
   has_many :comments_with_extend_2, extend: [NamedExtension, NamedExtension2], class_name: "Comment", foreign_key: "post_id"
 
-  has_many :author_favorites, :through => :author
-  has_many :author_categorizations, :through => :author, :source => :categorizations
-  has_many :author_addresses, :through => :author
+  has_many :author_favorites, through: :author
+  has_many :author_categorizations, through: :author, source: :categorizations
+  has_many :author_addresses, through: :author
   has_many :author_address_extra_with_address,
     through: :author_with_address,
     source: :author_address_extra
 
   has_one  :very_special_comment
-  has_one  :very_special_comment_with_post, -> { includes(:post) }, :class_name => "VerySpecialComment"
+  has_one  :very_special_comment_with_post, -> { includes(:post) }, class_name: "VerySpecialComment"
   has_one :very_special_comment_with_post_with_joins, -> { joins(:post).order("posts.id") }, class_name: "VerySpecialComment"
   has_many :special_comments
-  has_many :nonexistent_comments, -> { where "comments.id < 0" }, :class_name => "Comment"
+  has_many :nonexistent_comments, -> { where "comments.id < 0" }, class_name: "Comment"
 
-  has_many :special_comments_ratings, :through => :special_comments, :source => :ratings
-  has_many :special_comments_ratings_taggings, :through => :special_comments_ratings, :source => :taggings
+  has_many :special_comments_ratings, through: :special_comments, source: :ratings
+  has_many :special_comments_ratings_taggings, through: :special_comments_ratings, source: :taggings
 
-  has_many :category_posts, :class_name => "CategoryPost"
+  has_many :category_posts, class_name: "CategoryPost"
   has_many :scategories, through: :category_posts, source: :category
   has_and_belongs_to_many :categories
-  has_and_belongs_to_many :special_categories, :join_table => "categories_posts", :association_foreign_key => "category_id"
+  has_and_belongs_to_many :special_categories, join_table: "categories_posts", association_foreign_key: "category_id"
 
-  has_many :taggings, :as => :taggable, :counter_cache => :tags_count
-  has_many :tags, :through => :taggings do
+  has_many :taggings, as: :taggable, counter_cache: :tags_count
+  has_many :tags, through: :taggings do
     def add_joins_and_select
       select("tags.*, authors.id as author_id")
         .joins("left outer join posts on taggings.taggable_id = posts.id left outer join authors on posts.author_id = authors.id")
@@ -98,62 +98,62 @@ class Post < ActiveRecord::Base
     end
   end
 
-  has_many :taggings_with_delete_all, :class_name => "Tagging", :as => :taggable, :dependent => :delete_all, counter_cache: :taggings_with_delete_all_count
-  has_many :taggings_with_destroy, :class_name => "Tagging", :as => :taggable, :dependent => :destroy, counter_cache: :taggings_with_destroy_count
+  has_many :taggings_with_delete_all, class_name: "Tagging", as: :taggable, dependent: :delete_all, counter_cache: :taggings_with_delete_all_count
+  has_many :taggings_with_destroy, class_name: "Tagging", as: :taggable, dependent: :destroy, counter_cache: :taggings_with_destroy_count
 
-  has_many :tags_with_destroy, :through => :taggings, :source => :tag, :dependent => :destroy, counter_cache: :tags_with_destroy_count
-  has_many :tags_with_nullify, :through => :taggings, :source => :tag, :dependent => :nullify, counter_cache: :tags_with_nullify_count
+  has_many :tags_with_destroy, through: :taggings, source: :tag, dependent: :destroy, counter_cache: :tags_with_destroy_count
+  has_many :tags_with_nullify, through: :taggings, source: :tag, dependent: :nullify, counter_cache: :tags_with_nullify_count
 
-  has_many :misc_tags, -> { where :tags => { :name => "Misc" } }, :through => :taggings, :source => :tag
-  has_many :funky_tags, :through => :taggings, :source => :tag
-  has_many :super_tags, :through => :taggings
-  has_many :tags_with_primary_key, :through => :taggings, :source => :tag_with_primary_key
-  has_one :tagging, :as => :taggable
+  has_many :misc_tags, -> { where tags: { name: "Misc" } }, through: :taggings, source: :tag
+  has_many :funky_tags, through: :taggings, source: :tag
+  has_many :super_tags, through: :taggings
+  has_many :tags_with_primary_key, through: :taggings, source: :tag_with_primary_key
+  has_one :tagging, as: :taggable
 
-  has_many :first_taggings, -> { where :taggings => { :comment => "first" } }, :as => :taggable, :class_name => "Tagging"
-  has_many :first_blue_tags, -> { where :tags => { :name => "Blue" } }, :through => :first_taggings, :source => :tag
+  has_many :first_taggings, -> { where taggings: { comment: "first" } }, as: :taggable, class_name: "Tagging"
+  has_many :first_blue_tags, -> { where tags: { name: "Blue" } }, through: :first_taggings, source: :tag
 
-  has_many :first_blue_tags_2, -> { where :taggings => { :comment => "first" } }, :through => :taggings, :source => :blue_tag
+  has_many :first_blue_tags_2, -> { where taggings: { comment: "first" } }, through: :taggings, source: :blue_tag
 
-  has_many :invalid_taggings, -> { where "taggings.id < 0" }, :as => :taggable, :class_name => "Tagging"
-  has_many :invalid_tags, :through => :invalid_taggings, :source => :tag
+  has_many :invalid_taggings, -> { where "taggings.id < 0" }, as: :taggable, class_name: "Tagging"
+  has_many :invalid_tags, through: :invalid_taggings, source: :tag
 
-  has_many :categorizations, :foreign_key => :category_id
-  has_many :authors, :through => :categorizations
+  has_many :categorizations, foreign_key: :category_id
+  has_many :authors, through: :categorizations
 
-  has_many :categorizations_using_author_id, :primary_key => :author_id, :foreign_key => :post_id, :class_name => "Categorization"
-  has_many :authors_using_author_id, :through => :categorizations_using_author_id, :source => :author
+  has_many :categorizations_using_author_id, primary_key: :author_id, foreign_key: :post_id, class_name: "Categorization"
+  has_many :authors_using_author_id, through: :categorizations_using_author_id, source: :author
 
-  has_many :taggings_using_author_id, :primary_key => :author_id, :as => :taggable, :class_name => "Tagging"
-  has_many :tags_using_author_id, :through => :taggings_using_author_id, :source => :tag
+  has_many :taggings_using_author_id, primary_key: :author_id, as: :taggable, class_name: "Tagging"
+  has_many :tags_using_author_id, through: :taggings_using_author_id, source: :tag
 
-  has_many :images, :as => :imageable, :foreign_key => :imageable_identifier, :foreign_type => :imageable_class
-  has_one :main_image, :as => :imageable, :foreign_key => :imageable_identifier, :foreign_type => :imageable_class, :class_name => "Image"
+  has_many :images, as: :imageable, foreign_key: :imageable_identifier, foreign_type: :imageable_class
+  has_one :main_image, as: :imageable, foreign_key: :imageable_identifier, foreign_type: :imageable_class, class_name: "Image"
 
-  has_many :standard_categorizations, :class_name => "Categorization", :foreign_key => :post_id
-  has_many :author_using_custom_pk,  :through => :standard_categorizations
-  has_many :authors_using_custom_pk, :through => :standard_categorizations
-  has_many :named_categories, :through => :standard_categorizations
+  has_many :standard_categorizations, class_name: "Categorization", foreign_key: :post_id
+  has_many :author_using_custom_pk,  through: :standard_categorizations
+  has_many :authors_using_custom_pk, through: :standard_categorizations
+  has_many :named_categories, through: :standard_categorizations
 
   has_many :readers
   has_many :secure_readers
-  has_many :readers_with_person, -> { includes(:person) }, :class_name => "Reader"
-  has_many :people, :through => :readers
-  has_many :single_people, :through => :readers
-  has_many :people_with_callbacks, :source=>:person, :through => :readers,
-              :before_add    => lambda {|owner, reader| log(:added,   :before, reader.first_name) },
-              :after_add     => lambda {|owner, reader| log(:added,   :after,  reader.first_name) },
-              :before_remove => lambda {|owner, reader| log(:removed, :before, reader.first_name) },
-              :after_remove  => lambda {|owner, reader| log(:removed, :after,  reader.first_name) }
-  has_many :skimmers, -> { where :skimmer => true }, :class_name => "Reader"
-  has_many :impatient_people, :through => :skimmers, :source => :person
+  has_many :readers_with_person, -> { includes(:person) }, class_name: "Reader"
+  has_many :people, through: :readers
+  has_many :single_people, through: :readers
+  has_many :people_with_callbacks, source: :person, through: :readers,
+              before_add: lambda {|owner, reader| log(:added,   :before, reader.first_name) },
+              after_add: lambda {|owner, reader| log(:added,   :after,  reader.first_name) },
+              before_remove: lambda {|owner, reader| log(:removed, :before, reader.first_name) },
+              after_remove: lambda {|owner, reader| log(:removed, :after,  reader.first_name) }
+  has_many :skimmers, -> { where skimmer: true }, class_name: "Reader"
+  has_many :impatient_people, through: :skimmers, source: :person
 
   has_many :lazy_readers
-  has_many :lazy_readers_skimmers_or_not, -> { where(skimmer: [ true, false ]) }, :class_name => "LazyReader"
+  has_many :lazy_readers_skimmers_or_not, -> { where(skimmer: [ true, false ]) }, class_name: "LazyReader"
 
-  has_many :lazy_people, :through => :lazy_readers, :source => :person
-  has_many :lazy_readers_unscope_skimmers, -> { skimmers_or_not }, :class_name => "LazyReader"
-  has_many :lazy_people_unscope_skimmers, :through => :lazy_readers_unscope_skimmers, :source => :person
+  has_many :lazy_people, through: :lazy_readers, source: :person
+  has_many :lazy_readers_unscope_skimmers, -> { skimmers_or_not }, class_name: "LazyReader"
+  has_many :lazy_people_unscope_skimmers, through: :lazy_readers_unscope_skimmers, source: :person
 
   def self.top(limit)
     ranked_by_comments.limit_by(limit)
@@ -177,7 +177,7 @@ class SpecialPost < Post; end
 
 class StiPost < Post
   self.abstract_class = true
-  has_one :special_comment, :class_name => "SpecialComment"
+  has_one :special_comment, class_name: "SpecialComment"
 end
 
 class SubStiPost < StiPost
@@ -187,22 +187,22 @@ end
 class FirstPost < ActiveRecord::Base
   self.inheritance_column = :disabled
   self.table_name = "posts"
-  default_scope { where(:id => 1) }
+  default_scope { where(id: 1) }
 
-  has_many :comments, :foreign_key => :post_id
-  has_one  :comment,  :foreign_key => :post_id
+  has_many :comments, foreign_key: :post_id
+  has_one  :comment,  foreign_key: :post_id
 end
 
 class PostWithDefaultInclude < ActiveRecord::Base
   self.inheritance_column = :disabled
   self.table_name = "posts"
   default_scope { includes(:comments) }
-  has_many :comments, :foreign_key => :post_id
+  has_many :comments, foreign_key: :post_id
 end
 
 class PostWithSpecialCategorization < Post
-  has_many :categorizations, :foreign_key => :post_id
-  default_scope { where(:type => "PostWithSpecialCategorization").joins(:categorizations).where(:categorizations => { :special => true }) }
+  has_many :categorizations, foreign_key: :post_id
+  default_scope { where(type: "PostWithSpecialCategorization").joins(:categorizations).where(categorizations: { special: true }) }
 end
 
 class PostWithDefaultScope < ActiveRecord::Base
@@ -230,7 +230,7 @@ end
 class SpecialPostWithDefaultScope < ActiveRecord::Base
   self.inheritance_column = :disabled
   self.table_name = "posts"
-  default_scope { where(:id => [1, 5,6]) }
+  default_scope { where(id: [1, 5,6]) }
 end
 
 class PostThatLoadsCommentsInAnAfterSaveHook < ActiveRecord::Base
diff --git a/activerecord/test/models/price_estimate.rb b/activerecord/test/models/price_estimate.rb
index d09e2a88a3..ce086e40a3 100644
--- a/activerecord/test/models/price_estimate.rb
+++ b/activerecord/test/models/price_estimate.rb
@@ -1,4 +1,4 @@
 class PriceEstimate < ActiveRecord::Base
-  belongs_to :estimate_of, :polymorphic => true
+  belongs_to :estimate_of, polymorphic: true
   belongs_to :thing, polymorphic: true
 end
diff --git a/activerecord/test/models/project.rb b/activerecord/test/models/project.rb
index 1b3b807ee2..4d6b269731 100644
--- a/activerecord/test/models/project.rb
+++ b/activerecord/test/models/project.rb
@@ -1,17 +1,17 @@
 class Project < ActiveRecord::Base
   belongs_to :mentor
   has_and_belongs_to_many :developers, -> { distinct.order "developers.name desc, developers.id desc" }
-  has_and_belongs_to_many :readonly_developers, -> { readonly }, :class_name => "Developer"
-  has_and_belongs_to_many :non_unique_developers, -> { order "developers.name desc, developers.id desc" }, :class_name => "Developer"
-  has_and_belongs_to_many :limited_developers, -> { limit 1 }, :class_name => "Developer"
-  has_and_belongs_to_many :developers_named_david, -> { where("name = 'David'").distinct }, :class_name => "Developer"
-  has_and_belongs_to_many :developers_named_david_with_hash_conditions, -> { where(:name => "David").distinct }, :class_name => "Developer"
-  has_and_belongs_to_many :salaried_developers, -> { where "salary > 0" }, :class_name => "Developer"
-  has_and_belongs_to_many :developers_with_callbacks, :class_name => "Developer", :before_add => Proc.new {|o, r| o.developers_log << "before_adding#{r.id || '<new>'}"},
-                            :after_add => Proc.new {|o, r| o.developers_log << "after_adding#{r.id || '<new>'}"},
-                            :before_remove => Proc.new {|o, r| o.developers_log << "before_removing#{r.id}"},
-                            :after_remove => Proc.new {|o, r| o.developers_log << "after_removing#{r.id}"}
-  has_and_belongs_to_many :well_payed_salary_groups, -> { group("developers.salary").having("SUM(salary) > 10000").select("SUM(salary) as salary") }, :class_name => "Developer"
+  has_and_belongs_to_many :readonly_developers, -> { readonly }, class_name: "Developer"
+  has_and_belongs_to_many :non_unique_developers, -> { order "developers.name desc, developers.id desc" }, class_name: "Developer"
+  has_and_belongs_to_many :limited_developers, -> { limit 1 }, class_name: "Developer"
+  has_and_belongs_to_many :developers_named_david, -> { where("name = 'David'").distinct }, class_name: "Developer"
+  has_and_belongs_to_many :developers_named_david_with_hash_conditions, -> { where(name: "David").distinct }, class_name: "Developer"
+  has_and_belongs_to_many :salaried_developers, -> { where "salary > 0" }, class_name: "Developer"
+  has_and_belongs_to_many :developers_with_callbacks, class_name: "Developer", before_add: Proc.new {|o, r| o.developers_log << "before_adding#{r.id || '<new>'}"},
+                            after_add: Proc.new {|o, r| o.developers_log << "after_adding#{r.id || '<new>'}"},
+                            before_remove: Proc.new {|o, r| o.developers_log << "before_removing#{r.id}"},
+                            after_remove: Proc.new {|o, r| o.developers_log << "after_removing#{r.id}"}
+  has_and_belongs_to_many :well_payed_salary_groups, -> { group("developers.salary").having("SUM(salary) > 10000").select("SUM(salary) as salary") }, class_name: "Developer"
   belongs_to :firm
   has_one :lead_developer, through: :firm, inverse_of: :contracted_projects
 
diff --git a/activerecord/test/models/rating.rb b/activerecord/test/models/rating.rb
index 25a52c4ad7..7420821db0 100644
--- a/activerecord/test/models/rating.rb
+++ b/activerecord/test/models/rating.rb
@@ -1,4 +1,4 @@
 class Rating < ActiveRecord::Base
   belongs_to :comment
-  has_many :taggings, :as => :taggable
+  has_many :taggings, as: :taggable
 end
diff --git a/activerecord/test/models/reader.rb b/activerecord/test/models/reader.rb
index 8c7235ba9a..7c5a159fe0 100644
--- a/activerecord/test/models/reader.rb
+++ b/activerecord/test/models/reader.rb
@@ -1,22 +1,22 @@
 class Reader < ActiveRecord::Base
   belongs_to :post
-  belongs_to :person, :inverse_of => :readers
-  belongs_to :single_person, :class_name => "Person", :foreign_key => :person_id, :inverse_of => :reader
+  belongs_to :person, inverse_of: :readers
+  belongs_to :single_person, class_name: "Person", foreign_key: :person_id, inverse_of: :reader
   belongs_to :first_post, -> { where(id: [2, 3]) }
 end
 
 class SecureReader < ActiveRecord::Base
   self.table_name = "readers"
 
-  belongs_to :secure_post, :class_name => "Post", :foreign_key => "post_id"
-  belongs_to :secure_person, :inverse_of => :secure_readers, :class_name => "Person", :foreign_key => "person_id"
+  belongs_to :secure_post, class_name: "Post", foreign_key: "post_id"
+  belongs_to :secure_person, inverse_of: :secure_readers, class_name: "Person", foreign_key: "person_id"
 end
 
 class LazyReader < ActiveRecord::Base
   self.table_name = "readers"
   default_scope -> { where(skimmer: true) }
 
-  scope :skimmers_or_not, -> { unscope(:where => :skimmer) }
+  scope :skimmers_or_not, -> { unscope(where: :skimmer) }
 
   belongs_to :post
   belongs_to :person
diff --git a/activerecord/test/models/reference.rb b/activerecord/test/models/reference.rb
index 1cf6669dce..e2bb980fed 100644
--- a/activerecord/test/models/reference.rb
+++ b/activerecord/test/models/reference.rb
@@ -2,7 +2,7 @@ class Reference < ActiveRecord::Base
   belongs_to :person
   belongs_to :job
 
-  has_many :agents_posts_authors, :through => :person
+  has_many :agents_posts_authors, through: :person
 
   class << self; attr_accessor :make_comments; end
   self.make_comments = false
@@ -18,5 +18,5 @@ end
 
 class BadReference < ActiveRecord::Base
   self.table_name = "references"
-  default_scope { where(:favourite => false) }
+  default_scope { where(favourite: false) }
 end
diff --git a/activerecord/test/models/reply.rb b/activerecord/test/models/reply.rb
index 34b60bdef1..a2d169292a 100644
--- a/activerecord/test/models/reply.rb
+++ b/activerecord/test/models/reply.rb
@@ -1,14 +1,14 @@
 require "models/topic"
 
 class Reply < Topic
-  belongs_to :topic, :foreign_key => "parent_id", :counter_cache => true
-  belongs_to :topic_with_primary_key, :class_name => "Topic", :primary_key => "title", :foreign_key => "parent_title", :counter_cache => "replies_count"
-  has_many :replies, :class_name => "SillyReply", :dependent => :destroy, :foreign_key => "parent_id"
+  belongs_to :topic, foreign_key: "parent_id", counter_cache: true
+  belongs_to :topic_with_primary_key, class_name: "Topic", primary_key: "title", foreign_key: "parent_title", counter_cache: "replies_count"
+  has_many :replies, class_name: "SillyReply", dependent: :destroy, foreign_key: "parent_id"
 end
 
 class UniqueReply < Reply
-  belongs_to :topic, :foreign_key => "parent_id", :counter_cache => true
-  validates_uniqueness_of :content, :scope => "parent_id"
+  belongs_to :topic, foreign_key: "parent_id", counter_cache: true
+  validates_uniqueness_of :content, scope: "parent_id"
 end
 
 class SillyUniqueReply < UniqueReply
@@ -16,12 +16,12 @@ end
 
 class WrongReply < Reply
   validate :errors_on_empty_content
-  validate :title_is_wrong_create, :on => :create
+  validate :title_is_wrong_create, on: :create
 
   validate :check_empty_title
-  validate :check_content_mismatch, :on => :create
-  validate :check_wrong_update, :on => :update
-  validate :check_author_name_is_secret, :on => :special_case
+  validate :check_content_mismatch, on: :create
+  validate :check_wrong_update, on: :update
+  validate :check_author_name_is_secret, on: :special_case
 
   def check_empty_title
     errors[:title] << "Empty" unless attribute_present?("title")
@@ -51,11 +51,11 @@ class WrongReply < Reply
 end
 
 class SillyReply < Reply
-  belongs_to :reply, :foreign_key => "parent_id", :counter_cache => :replies_count
+  belongs_to :reply, foreign_key: "parent_id", counter_cache: :replies_count
 end
 
 module Web
   class Reply < Web::Topic
-    belongs_to :topic, :foreign_key => "parent_id", :counter_cache => true, :class_name => "Web::Topic"
+    belongs_to :topic, foreign_key: "parent_id", counter_cache: true, class_name: "Web::Topic"
   end
 end
diff --git a/activerecord/test/models/ship.rb b/activerecord/test/models/ship.rb
index eae360a9eb..77a7b22315 100644
--- a/activerecord/test/models/ship.rb
+++ b/activerecord/test/models/ship.rb
@@ -2,19 +2,19 @@ class Ship < ActiveRecord::Base
   self.record_timestamps = false
 
   belongs_to :pirate
-  belongs_to :update_only_pirate, :class_name => "Pirate"
+  belongs_to :update_only_pirate, class_name: "Pirate"
   belongs_to :developer, dependent: :destroy
-  has_many :parts, :class_name => "ShipPart"
+  has_many :parts, class_name: "ShipPart"
   has_many :treasures
 
-  accepts_nested_attributes_for :parts, :allow_destroy => true
-  accepts_nested_attributes_for :pirate, :allow_destroy => true, :reject_if => proc(&:empty?)
-  accepts_nested_attributes_for :update_only_pirate, :update_only => true
+  accepts_nested_attributes_for :parts, allow_destroy: true
+  accepts_nested_attributes_for :pirate, allow_destroy: true, reject_if: proc(&:empty?)
+  accepts_nested_attributes_for :update_only_pirate, update_only: true
 
   validates_presence_of :name
 
   attr_accessor :cancel_save_from_callback
-  before_save :cancel_save_callback_method, :if => :cancel_save_from_callback
+  before_save :cancel_save_callback_method, if: :cancel_save_from_callback
   def cancel_save_callback_method
     throw(:abort)
   end
diff --git a/activerecord/test/models/ship_part.rb b/activerecord/test/models/ship_part.rb
index 05c65f8a4a..1a633b8d77 100644
--- a/activerecord/test/models/ship_part.rb
+++ b/activerecord/test/models/ship_part.rb
@@ -1,7 +1,7 @@
 class ShipPart < ActiveRecord::Base
   belongs_to :ship
-  has_many :trinkets, :class_name => "Treasure", :as => :looter
-  accepts_nested_attributes_for :trinkets, :allow_destroy => true
+  has_many :trinkets, class_name: "Treasure", as: :looter
+  accepts_nested_attributes_for :trinkets, allow_destroy: true
   accepts_nested_attributes_for :ship
 
   validates_presence_of :name
diff --git a/activerecord/test/models/shop.rb b/activerecord/test/models/shop.rb
index 607a0a5b41..f9d23d13b0 100644
--- a/activerecord/test/models/shop.rb
+++ b/activerecord/test/models/shop.rb
@@ -1,10 +1,10 @@
 module Shop
   class Collection < ActiveRecord::Base
-    has_many :products, :dependent => :nullify
+    has_many :products, dependent: :nullify
   end
 
   class Product < ActiveRecord::Base
-    has_many :variants, :dependent => :delete_all
+    has_many :variants, dependent: :delete_all
     belongs_to :type
 
     class Type < ActiveRecord::Base
diff --git a/activerecord/test/models/sponsor.rb b/activerecord/test/models/sponsor.rb
index 5f7e47b583..175933ccf1 100644
--- a/activerecord/test/models/sponsor.rb
+++ b/activerecord/test/models/sponsor.rb
@@ -1,7 +1,7 @@
 class Sponsor < ActiveRecord::Base
-  belongs_to :sponsor_club, :class_name => "Club", :foreign_key => "club_id"
-  belongs_to :sponsorable, :polymorphic => true
-  belongs_to :thing, :polymorphic => true, :foreign_type => :sponsorable_type, :foreign_key => :sponsorable_id
-  belongs_to :sponsorable_with_conditions, -> { where :name => "Ernie"}, :polymorphic => true,
-             :foreign_type => "sponsorable_type", :foreign_key => "sponsorable_id"
+  belongs_to :sponsor_club, class_name: "Club", foreign_key: "club_id"
+  belongs_to :sponsorable, polymorphic: true
+  belongs_to :thing, polymorphic: true, foreign_type: :sponsorable_type, foreign_key: :sponsorable_id
+  belongs_to :sponsorable_with_conditions, -> { where name: "Ernie"}, polymorphic: true,
+             foreign_type: "sponsorable_type", foreign_key: "sponsorable_id"
 end
diff --git a/activerecord/test/models/subscriber.rb b/activerecord/test/models/subscriber.rb
index 269da472cf..a820329003 100644
--- a/activerecord/test/models/subscriber.rb
+++ b/activerecord/test/models/subscriber.rb
@@ -1,7 +1,7 @@
 class Subscriber < ActiveRecord::Base
   self.primary_key = "nick"
   has_many :subscriptions
-  has_many :books, :through => :subscriptions
+  has_many :books, through: :subscriptions
 end
 
 class SpecialSubscriber < Subscriber
diff --git a/activerecord/test/models/subscription.rb b/activerecord/test/models/subscription.rb
index bcac4738a3..1cedf6deae 100644
--- a/activerecord/test/models/subscription.rb
+++ b/activerecord/test/models/subscription.rb
@@ -1,4 +1,4 @@
 class Subscription < ActiveRecord::Base
-  belongs_to :subscriber, :counter_cache => :books_count
+  belongs_to :subscriber, counter_cache: :books_count
   belongs_to :book
 end
diff --git a/activerecord/test/models/tag.rb b/activerecord/test/models/tag.rb
index a49affaf3f..c907aea10f 100644
--- a/activerecord/test/models/tag.rb
+++ b/activerecord/test/models/tag.rb
@@ -1,9 +1,9 @@
 class Tag < ActiveRecord::Base
   has_many :taggings
-  has_many :taggables, :through => :taggings
+  has_many :taggables, through: :taggings
   has_one  :tagging
 
-  has_many :tagged_posts, :through => :taggings, :source => "taggable", :source_type => "Post"
+  has_many :tagged_posts, through: :taggings, source: "taggable", source_type: "Post"
 end
 
 class OrderedTag < Tag
diff --git a/activerecord/test/models/tagging.rb b/activerecord/test/models/tagging.rb
index 3ab9f50739..f739b4a197 100644
--- a/activerecord/test/models/tagging.rb
+++ b/activerecord/test/models/tagging.rb
@@ -4,10 +4,10 @@ end
 
 class Tagging < ActiveRecord::Base
   belongs_to :tag, -> { includes(:tagging) }
-  belongs_to :super_tag,   :class_name => "Tag", :foreign_key => "super_tag_id"
-  belongs_to :invalid_tag, :class_name => "Tag", :foreign_key => "tag_id"
-  belongs_to :blue_tag, -> { where :tags => { :name => "Blue" } }, :class_name => "Tag", :foreign_key => :tag_id
-  belongs_to :tag_with_primary_key, :class_name => "Tag", :foreign_key => :tag_id, :primary_key => :custom_primary_key
-  belongs_to :taggable, :polymorphic => true, :counter_cache => :tags_count
-  has_many :things, :through => :taggable
+  belongs_to :super_tag,   class_name: "Tag", foreign_key: "super_tag_id"
+  belongs_to :invalid_tag, class_name: "Tag", foreign_key: "tag_id"
+  belongs_to :blue_tag, -> { where tags: { name: "Blue" } }, class_name: "Tag", foreign_key: :tag_id
+  belongs_to :tag_with_primary_key, class_name: "Tag", foreign_key: :tag_id, primary_key: :custom_primary_key
+  belongs_to :taggable, polymorphic: true, counter_cache: :tags_count
+  has_many :things, through: :taggable
 end
diff --git a/activerecord/test/models/topic.rb b/activerecord/test/models/topic.rb
index 4e35e458ca..00f89a5364 100644
--- a/activerecord/test/models/topic.rb
+++ b/activerecord/test/models/topic.rb
@@ -5,15 +5,15 @@ class Topic < ActiveRecord::Base
       where "written_on < ?", time
     end
   }
-  scope :approved, -> { where(:approved => true) }
-  scope :rejected, -> { where(:approved => false) }
+  scope :approved, -> { where(approved: true) }
+  scope :rejected, -> { where(approved: false) }
 
   scope :scope_with_lambda, lambda { all }
 
-  scope :by_lifo, -> { where(:author_name => "lifo") }
+  scope :by_lifo, -> { where(author_name: "lifo") }
   scope :replied, -> { where "replies_count > 0" }
 
-  scope "approved_as_string", -> { where(:approved => true) }
+  scope "approved_as_string", -> { where(approved: true) }
   scope :anonymous_extension, -> { all } do
     def one
       1
@@ -22,7 +22,7 @@ class Topic < ActiveRecord::Base
 
   scope :with_object, Class.new(Struct.new(:klass)) {
     def call
-      klass.where(:approved => true)
+      klass.where(approved: true)
     end
   }.new(self)
 
@@ -35,8 +35,8 @@ class Topic < ActiveRecord::Base
   has_many :replies, dependent: :destroy, foreign_key: "parent_id", autosave: true
   has_many :approved_replies, -> { approved }, class_name: "Reply", foreign_key: "parent_id", counter_cache: "replies_count"
 
-  has_many :unique_replies, :dependent => :destroy, :foreign_key => "parent_id"
-  has_many :silly_unique_replies, :dependent => :destroy, :foreign_key => "parent_id"
+  has_many :unique_replies, dependent: :destroy, foreign_key: "parent_id"
+  has_many :silly_unique_replies, dependent: :destroy, foreign_key: "parent_id"
 
   serialize :content
 
@@ -113,6 +113,6 @@ end
 
 module Web
   class Topic < ActiveRecord::Base
-    has_many :replies, :dependent => :destroy, :foreign_key => "parent_id", :class_name => "Web::Reply"
+    has_many :replies, dependent: :destroy, foreign_key: "parent_id", class_name: "Web::Reply"
   end
 end
diff --git a/activerecord/test/models/treasure.rb b/activerecord/test/models/treasure.rb
index 04c3ef662c..fb2a5d44e2 100644
--- a/activerecord/test/models/treasure.rb
+++ b/activerecord/test/models/treasure.rb
@@ -1,10 +1,10 @@
 class Treasure < ActiveRecord::Base
   has_and_belongs_to_many :parrots
-  belongs_to :looter, :polymorphic => true
+  belongs_to :looter, polymorphic: true
   # No counter_cache option given
   belongs_to :ship
 
-  has_many :price_estimates, :as => :estimate_of
+  has_many :price_estimates, as: :estimate_of
   has_and_belongs_to_many :rich_people, join_table: "peoples_treasures", validate: false
 
   accepts_nested_attributes_for :looter
diff --git a/activerecord/test/models/vegetables.rb b/activerecord/test/models/vegetables.rb
index 5f6a17dbb3..ef310d2359 100644
--- a/activerecord/test/models/vegetables.rb
+++ b/activerecord/test/models/vegetables.rb
@@ -20,5 +20,5 @@ class KingCole < GreenCabbage
 end
 
 class RedCabbage < Cabbage
-  belongs_to :seller, :class_name => "Company"
+  belongs_to :seller, class_name: "Company"
 end
diff --git a/activerecord/test/models/vertex.rb b/activerecord/test/models/vertex.rb
index cd0ac92236..3d19433b6f 100644
--- a/activerecord/test/models/vertex.rb
+++ b/activerecord/test/models/vertex.rb
@@ -1,9 +1,9 @@
 # This class models a vertex in a directed graph.
 class Vertex < ActiveRecord::Base
-  has_many :sink_edges, :class_name => "Edge", :foreign_key => "source_id"
-  has_many :sinks, :through => :sink_edges
+  has_many :sink_edges, class_name: "Edge", foreign_key: "source_id"
+  has_many :sinks, through: :sink_edges
 
   has_and_belongs_to_many :sources,
-    :class_name => "Vertex", :join_table => "edges",
-    :foreign_key => "sink_id", :association_foreign_key => "source_id"
+    class_name: "Vertex", join_table: "edges",
+    foreign_key: "sink_id", association_foreign_key: "source_id"
 end
diff --git a/activerecord/test/models/wheel.rb b/activerecord/test/models/wheel.rb
index 26868bce5e..cba2b3e518 100644
--- a/activerecord/test/models/wheel.rb
+++ b/activerecord/test/models/wheel.rb
@@ -1,3 +1,3 @@
 class Wheel < ActiveRecord::Base
-  belongs_to :wheelable, :polymorphic => true, :counter_cache => true
+  belongs_to :wheelable, polymorphic: true, counter_cache: true
 end
diff --git a/activerecord/test/models/without_table.rb b/activerecord/test/models/without_table.rb
index 50c824e4ac..7c0fc286e1 100644
--- a/activerecord/test/models/without_table.rb
+++ b/activerecord/test/models/without_table.rb
@@ -1,3 +1,3 @@
 class WithoutTable < ActiveRecord::Base
-  default_scope -> { where(:published => true) }
+  default_scope -> { where(published: true) }
 end
diff --git a/activerecord/test/models/zine.rb b/activerecord/test/models/zine.rb
index c2d0fdaf25..3f2b348b46 100644
--- a/activerecord/test/models/zine.rb
+++ b/activerecord/test/models/zine.rb
@@ -1,3 +1,3 @@
 class Zine < ActiveRecord::Base
-  has_many :interests, :inverse_of => :zine
+  has_many :interests, inverse_of: :zine
 end