Replace test `Man` with `Human`

The commit replaces the `Man` model used in tests with a `Human` model. It
also replaces the existing `Human` model with a `SuperHuman` model
inheriting from `Human`.

While this may seem like a cosmetic change, I see it as more of an
inclusivity change. I think it makes sense for a number of reasons:

* Prior to this commit the `Human` model inherited from `Man`. At best
  this makes no sense (it should be the other way around). At worst it
  is offensive and harmful to the community.
* It doesn't seem inclusive to me to have exclusively male-gendered
  examples in the codebase.
* There is no particular reason for these examples to be gendered.
* `man` is hard to grep for, since it also matches `many, manager,
  manual, etc`

For the most part this is a simple search and replace. The one exception
to that is that I had to add the table name to the model so we could use
"humans" instead of "humen".

activerecord/test/assets/schema_dump_5_1.yml

@@ -316,7 +316,7 @@ data_sources:
   triangles: true
   non_poly_ones: true
   non_poly_twos: true
-  men: true
+  humans: true
   faces: true
   interests: true
   zines: true

activerecord/test/cases/associations/has_and_belongs_to_many_associations_test.rb

@@ -120,7 +120,7 @@ class Sink < ActiveRecord::Base
 end
 
 class Source < ActiveRecord::Base
-  self.table_name = "men"
+  self.table_name = "humans"
   has_and_belongs_to_many :sinks, join_table: :edges
 end
 

activerecord/test/cases/associations/inverse_associations_test.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "cases/helper"
-require "models/man"
+require "models/human"
 require "models/face"
 require "models/interest"
 require "models/zine"
@@ -26,14 +26,14 @@ class AutomaticInverseFindingTests < ActiveRecord::TestCase
   fixtures :ratings, :comments, :cars
 
   def test_has_one_and_belongs_to_should_find_inverse_automatically_on_multiple_word_name
-    monkey_reflection = MixedCaseMonkey.reflect_on_association(:man)
-    man_reflection = Man.reflect_on_association(:mixed_case_monkey)
+    monkey_reflection = MixedCaseMonkey.reflect_on_association(:human)
+    human_reflection = Human.reflect_on_association(:mixed_case_monkey)
 
     assert monkey_reflection.has_inverse?, "The monkey reflection should have an inverse"
-    assert_equal man_reflection, monkey_reflection.inverse_of, "The monkey reflection's inverse should be the man reflection"
+    assert_equal human_reflection, monkey_reflection.inverse_of, "The monkey reflection's inverse should be the human reflection"
 
-    assert man_reflection.has_inverse?, "The man reflection should have an inverse"
-    assert_equal monkey_reflection, man_reflection.inverse_of, "The man reflection's inverse should be the monkey reflection"
+    assert human_reflection.has_inverse?, "The human reflection should have an inverse"
+    assert_equal monkey_reflection, human_reflection.inverse_of, "The human reflection's inverse should be the monkey reflection"
   end
 
   def test_has_many_and_belongs_to_should_find_inverse_automatically_for_model_in_module
@@ -136,9 +136,9 @@ class AutomaticInverseFindingTests < ActiveRecord::TestCase
   end
 
   def test_polymorphic_has_one_should_find_inverse_automatically
-    man_reflection = Man.reflect_on_association(:polymorphic_face_without_inverse)
+    human_reflection = Human.reflect_on_association(:polymorphic_face_without_inverse)
 
-    assert_predicate man_reflection, :has_inverse?
+    assert_predicate human_reflection, :has_inverse?
   end
 end
 
@@ -158,13 +158,13 @@ class InverseAssociationTests < ActiveRecord::TestCase
   end
 
   def test_should_be_able_to_ask_a_reflection_if_it_has_an_inverse
-    has_one_with_inverse_ref = Man.reflect_on_association(:face)
+    has_one_with_inverse_ref = Human.reflect_on_association(:face)
     assert_predicate has_one_with_inverse_ref, :has_inverse?
 
-    has_many_with_inverse_ref = Man.reflect_on_association(:interests)
+    has_many_with_inverse_ref = Human.reflect_on_association(:interests)
     assert_predicate has_many_with_inverse_ref, :has_inverse?
 
-    belongs_to_with_inverse_ref = Face.reflect_on_association(:man)
+    belongs_to_with_inverse_ref = Face.reflect_on_association(:human)
     assert_predicate belongs_to_with_inverse_ref, :has_inverse?
 
     has_one_without_inverse_ref = Club.reflect_on_association(:sponsor)
@@ -178,14 +178,14 @@ class InverseAssociationTests < ActiveRecord::TestCase
   end
 
   def test_inverse_of_method_should_supply_the_actual_reflection_instance_it_is_the_inverse_of
-    has_one_ref = Man.reflect_on_association(:face)
-    assert_equal Face.reflect_on_association(:man), has_one_ref.inverse_of
+    has_one_ref = Human.reflect_on_association(:face)
+    assert_equal Face.reflect_on_association(:human), has_one_ref.inverse_of
 
-    has_many_ref = Man.reflect_on_association(:interests)
-    assert_equal Interest.reflect_on_association(:man), has_many_ref.inverse_of
+    has_many_ref = Human.reflect_on_association(:interests)
+    assert_equal Interest.reflect_on_association(:human), has_many_ref.inverse_of
 
-    belongs_to_ref = Face.reflect_on_association(:man)
-    assert_equal Man.reflect_on_association(:face), belongs_to_ref.inverse_of
+    belongs_to_ref = Face.reflect_on_association(:human)
+    assert_equal Human.reflect_on_association(:face), belongs_to_ref.inverse_of
   end
 
   def test_associations_with_no_inverse_of_should_return_nil
@@ -204,7 +204,7 @@ class InverseAssociationTests < ActiveRecord::TestCase
     assert_raise(ArgumentError) { belongs_to_ref.klass }
     assert_nil belongs_to_ref.inverse_of
 
-    belongs_to_ref = Face.reflect_on_association(:human)
+    belongs_to_ref = Face.reflect_on_association(:super_human)
     assert_raise(ArgumentError) { belongs_to_ref.klass }
     assert_nil belongs_to_ref.inverse_of
   end
@@ -221,98 +221,98 @@ class InverseAssociationTests < ActiveRecord::TestCase
 end
 
 class InverseHasOneTests < ActiveRecord::TestCase
-  fixtures :men, :faces
+  fixtures :humans, :faces
 
   def test_parent_instance_should_be_shared_with_child_on_find
-    m = men(:gordon)
+    m = humans(:gordon)
     f = m.face
-    assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
+    assert_equal m.name, f.human.name, "Name of human should be the same before changes to parent instance"
     m.name = "Bongo"
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to parent instance"
-    f.man.name = "Mungo"
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to child-owned instance"
+    assert_equal m.name, f.human.name, "Name of human should be the same after changes to parent instance"
+    f.human.name = "Mungo"
+    assert_equal m.name, f.human.name, "Name of human should be the same after changes to child-owned instance"
   end
 
   def test_parent_instance_should_be_shared_with_eager_loaded_child_on_find
-    m = Man.all.merge!(where: { name: "Gordon" }, includes: :face).first
+    m = Human.all.merge!(where: { name: "Gordon" }, includes: :face).first
     f = m.face
-    assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
+    assert_equal m.name, f.human.name, "Name of human should be the same before changes to parent instance"
     m.name = "Bongo"
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to parent instance"
-    f.man.name = "Mungo"
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to child-owned instance"
+    assert_equal m.name, f.human.name, "Name of human should be the same after changes to parent instance"
+    f.human.name = "Mungo"
+    assert_equal m.name, f.human.name, "Name of human should be the same after changes to child-owned instance"
 
-    m = Man.all.merge!(where: { name: "Gordon" }, includes: :face, order: "faces.id").first
+    m = Human.all.merge!(where: { name: "Gordon" }, includes: :face, order: "faces.id").first
     f = m.face
-    assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
+    assert_equal m.name, f.human.name, "Name of human should be the same before changes to parent instance"
     m.name = "Bongo"
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to parent instance"
-    f.man.name = "Mungo"
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to child-owned instance"
+    assert_equal m.name, f.human.name, "Name of human should be the same after changes to parent instance"
+    f.human.name = "Mungo"
+    assert_equal m.name, f.human.name, "Name of human should be the same after changes to child-owned instance"
   end
 
   def test_parent_instance_should_be_shared_with_newly_built_child
-    m = Man.first
+    m = Human.first
     f = m.build_face(description: "haunted")
-    assert_not_nil f.man
-    assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
+    assert_not_nil f.human
+    assert_equal m.name, f.human.name, "Name of human should be the same before changes to parent instance"
     m.name = "Bongo"
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to parent instance"
-    f.man.name = "Mungo"
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to just-built-child-owned instance"
+    assert_equal m.name, f.human.name, "Name of human should be the same after changes to parent instance"
+    f.human.name = "Mungo"
+    assert_equal m.name, f.human.name, "Name of human should be the same after changes to just-built-child-owned instance"
   end
 
   def test_parent_instance_should_be_shared_with_newly_created_child
-    m = Man.first
+    m = Human.first
     f = m.create_face(description: "haunted")
-    assert_not_nil f.man
-    assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
+    assert_not_nil f.human
+    assert_equal m.name, f.human.name, "Name of human should be the same before changes to parent instance"
     m.name = "Bongo"
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to parent instance"
-    f.man.name = "Mungo"
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to newly-created-child-owned instance"
+    assert_equal m.name, f.human.name, "Name of human should be the same after changes to parent instance"
+    f.human.name = "Mungo"
+    assert_equal m.name, f.human.name, "Name of human should be the same after changes to newly-created-child-owned instance"
   end
 
   def test_parent_instance_should_be_shared_with_newly_created_child_via_bang_method
-    m = Man.first
+    m = Human.first
     f = m.create_face!(description: "haunted")
-    assert_not_nil f.man
-    assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
+    assert_not_nil f.human
+    assert_equal m.name, f.human.name, "Name of human should be the same before changes to parent instance"
     m.name = "Bongo"
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to parent instance"
-    f.man.name = "Mungo"
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to newly-created-child-owned instance"
+    assert_equal m.name, f.human.name, "Name of human should be the same after changes to parent instance"
+    f.human.name = "Mungo"
+    assert_equal m.name, f.human.name, "Name of human should be the same after changes to newly-created-child-owned instance"
   end
 
   def test_parent_instance_should_be_shared_with_replaced_via_accessor_child
-    m = Man.first
+    m = Human.first
     f = Face.new(description: "haunted")
     m.face = f
-    assert_not_nil f.man
-    assert_equal m.name, f.man.name, "Name of man should be the same before changes to parent instance"
+    assert_not_nil f.human
+    assert_equal m.name, f.human.name, "Name of human should be the same before changes to parent instance"
     m.name = "Bongo"
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to parent instance"
-    f.man.name = "Mungo"
-    assert_equal m.name, f.man.name, "Name of man should be the same after changes to replaced-child-owned instance"
+    assert_equal m.name, f.human.name, "Name of human should be the same after changes to parent instance"
+    f.human.name = "Mungo"
+    assert_equal m.name, f.human.name, "Name of human should be the same after changes to replaced-child-owned instance"
   end
 
   def test_trying_to_use_inverses_that_dont_exist_should_raise_an_error
-    assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Man.first.dirty_face }
+    assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Human.first.dirty_face }
   end
 end
 
 class InverseHasManyTests < ActiveRecord::TestCase
-  fixtures :men, :interests, :posts, :authors, :author_addresses
+  fixtures :humans, :interests, :posts, :authors, :author_addresses
 
   def test_parent_instance_should_be_shared_with_every_child_on_find
-    m = men(:gordon)
+    m = humans(:gordon)
     is = m.interests
     is.each do |i|
-      assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
+      assert_equal m.name, i.human.name, "Name of human should be the same before changes to parent instance"
       m.name = "Bongo"
-      assert_equal m.name, i.man.name, "Name of man should be the same after changes to parent instance"
-      i.man.name = "Mungo"
-      assert_equal m.name, i.man.name, "Name of man should be the same after changes to child-owned instance"
+      assert_equal m.name, i.human.name, "Name of human should be the same after changes to parent instance"
+      i.human.name = "Mungo"
+      assert_equal m.name, i.human.name, "Name of human should be the same after changes to child-owned instance"
     end
   end
 
@@ -320,170 +320,170 @@ class InverseHasManyTests < ActiveRecord::TestCase
     a = authors(:david)
     ps = a.posts
     ps.each do |p|
-      assert_equal a.name, p.author.name, "Name of man should be the same before changes to parent instance"
+      assert_equal a.name, p.author.name, "Name of human should be the same before changes to parent instance"
       a.name = "Bongo"
-      assert_equal a.name, p.author.name, "Name of man should be the same after changes to parent instance"
+      assert_equal a.name, p.author.name, "Name of human should be the same after changes to parent instance"
       p.author.name = "Mungo"
-      assert_equal a.name, p.author.name, "Name of man should be the same after changes to child-owned instance"
+      assert_equal a.name, p.author.name, "Name of human should be the same after changes to child-owned instance"
     end
 
     sps = a.special_posts
     sps.each do |sp|
-      assert_equal a.name, sp.author.name, "Name of man should be the same before changes to parent instance"
+      assert_equal a.name, sp.author.name, "Name of human should be the same before changes to parent instance"
       a.name = "Bongo"
-      assert_equal a.name, sp.author.name, "Name of man should be the same after changes to parent instance"
+      assert_equal a.name, sp.author.name, "Name of human should be the same after changes to parent instance"
       sp.author.name = "Mungo"
-      assert_equal a.name, sp.author.name, "Name of man should be the same after changes to child-owned instance"
+      assert_equal a.name, sp.author.name, "Name of human should be the same after changes to child-owned instance"
     end
   end
 
   def test_parent_instance_should_be_shared_with_eager_loaded_children
-    m = Man.all.merge!(where: { name: "Gordon" }, includes: :interests).first
+    m = Human.all.merge!(where: { name: "Gordon" }, includes: :interests).first
     is = m.interests
     is.each do |i|
-      assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
+      assert_equal m.name, i.human.name, "Name of human should be the same before changes to parent instance"
       m.name = "Bongo"
-      assert_equal m.name, i.man.name, "Name of man should be the same after changes to parent instance"
-      i.man.name = "Mungo"
-      assert_equal m.name, i.man.name, "Name of man should be the same after changes to child-owned instance"
+      assert_equal m.name, i.human.name, "Name of human should be the same after changes to parent instance"
+      i.human.name = "Mungo"
+      assert_equal m.name, i.human.name, "Name of human should be the same after changes to child-owned instance"
     end
 
-    m = Man.all.merge!(where: { name: "Gordon" }, includes: :interests, order: "interests.id").first
+    m = Human.all.merge!(where: { name: "Gordon" }, includes: :interests, order: "interests.id").first
     is = m.interests
     is.each do |i|
-      assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
+      assert_equal m.name, i.human.name, "Name of human should be the same before changes to parent instance"
       m.name = "Bongo"
-      assert_equal m.name, i.man.name, "Name of man should be the same after changes to parent instance"
-      i.man.name = "Mungo"
-      assert_equal m.name, i.man.name, "Name of man should be the same after changes to child-owned instance"
+      assert_equal m.name, i.human.name, "Name of human should be the same after changes to parent instance"
+      i.human.name = "Mungo"
+      assert_equal m.name, i.human.name, "Name of human should be the same after changes to child-owned instance"
     end
   end
 
   def test_parent_instance_should_be_shared_with_newly_block_style_built_child
-    m = Man.first
+    m = Human.first
     i = m.interests.build { |ii| ii.topic = "Industrial Revolution Re-enactment" }
     assert_not_nil i.topic, "Child attributes supplied to build via blocks should be populated"
-    assert_not_nil i.man
-    assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
+    assert_not_nil i.human
+    assert_equal m.name, i.human.name, "Name of human should be the same before changes to parent instance"
     m.name = "Bongo"
-    assert_equal m.name, i.man.name, "Name of man should be the same after changes to parent instance"
-    i.man.name = "Mungo"
-    assert_equal m.name, i.man.name, "Name of man should be the same after changes to just-built-child-owned instance"
+    assert_equal m.name, i.human.name, "Name of human should be the same after changes to parent instance"
+    i.human.name = "Mungo"
+    assert_equal m.name, i.human.name, "Name of human should be the same after changes to just-built-child-owned instance"
   end
 
   def test_parent_instance_should_be_shared_with_newly_created_via_bang_method_child
-    m = Man.first
+    m = Human.first
     i = m.interests.create!(topic: "Industrial Revolution Re-enactment")
-    assert_not_nil i.man
-    assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
+    assert_not_nil i.human
+    assert_equal m.name, i.human.name, "Name of human should be the same before changes to parent instance"
     m.name = "Bongo"
-    assert_equal m.name, i.man.name, "Name of man should be the same after changes to parent instance"
-    i.man.name = "Mungo"
-    assert_equal m.name, i.man.name, "Name of man should be the same after changes to newly-created-child-owned instance"
+    assert_equal m.name, i.human.name, "Name of human should be the same after changes to parent instance"
+    i.human.name = "Mungo"
+    assert_equal m.name, i.human.name, "Name of human should be the same after changes to newly-created-child-owned instance"
   end
 
   def test_parent_instance_should_be_shared_with_newly_block_style_created_child
-    m = Man.first
+    m = Human.first
     i = m.interests.create { |ii| ii.topic = "Industrial Revolution Re-enactment" }
     assert_not_nil i.topic, "Child attributes supplied to create via blocks should be populated"
-    assert_not_nil i.man
-    assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
+    assert_not_nil i.human
+    assert_equal m.name, i.human.name, "Name of human should be the same before changes to parent instance"
     m.name = "Bongo"
-    assert_equal m.name, i.man.name, "Name of man should be the same after changes to parent instance"
-    i.man.name = "Mungo"
-    assert_equal m.name, i.man.name, "Name of man should be the same after changes to newly-created-child-owned instance"
+    assert_equal m.name, i.human.name, "Name of human should be the same after changes to parent instance"
+    i.human.name = "Mungo"
+    assert_equal m.name, i.human.name, "Name of human should be the same after changes to newly-created-child-owned instance"
   end
 
   def test_parent_instance_should_be_shared_within_create_block_of_new_child
-    man = Man.first
-    interest = man.interests.create do |i|
-      assert i.man.equal?(man), "Man of child should be the same instance as a parent"
+    human = Human.first
+    interest = human.interests.create do |i|
+      assert i.human.equal?(human), "Human of child should be the same instance as a parent"
     end
-    assert interest.man.equal?(man), "Man of the child should still be the same instance as a parent"
+    assert interest.human.equal?(human), "Human of the child should still be the same instance as a parent"
   end
 
   def test_parent_instance_should_be_shared_within_build_block_of_new_child
-    man = Man.first
-    interest = man.interests.build do |i|
-      assert i.man.equal?(man), "Man of child should be the same instance as a parent"
+    human = Human.first
+    interest = human.interests.build do |i|
+      assert i.human.equal?(human), "Human of child should be the same instance as a parent"
     end
-    assert interest.man.equal?(man), "Man of the child should still be the same instance as a parent"
+    assert interest.human.equal?(human), "Human of the child should still be the same instance as a parent"
   end
 
   def test_parent_instance_should_be_shared_with_poked_in_child
-    m = men(:gordon)
+    m = humans(:gordon)
     i = Interest.create(topic: "Industrial Revolution Re-enactment")
     m.interests << i
-    assert_not_nil i.man
-    assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
+    assert_not_nil i.human
+    assert_equal m.name, i.human.name, "Name of human should be the same before changes to parent instance"
     m.name = "Bongo"
-    assert_equal m.name, i.man.name, "Name of man should be the same after changes to parent instance"
-    i.man.name = "Mungo"
-    assert_equal m.name, i.man.name, "Name of man should be the same after changes to newly-created-child-owned instance"
+    assert_equal m.name, i.human.name, "Name of human should be the same after changes to parent instance"
+    i.human.name = "Mungo"
+    assert_equal m.name, i.human.name, "Name of human should be the same after changes to newly-created-child-owned instance"
   end
 
   def test_parent_instance_should_be_shared_with_replaced_via_accessor_children
-    m = Man.first
+    m = Human.first
     i = Interest.new(topic: "Industrial Revolution Re-enactment")
     m.interests = [i]
-    assert_not_nil i.man
-    assert_equal m.name, i.man.name, "Name of man should be the same before changes to parent instance"
+    assert_not_nil i.human
+    assert_equal m.name, i.human.name, "Name of human should be the same before changes to parent instance"
     m.name = "Bongo"
-    assert_equal m.name, i.man.name, "Name of man should be the same after changes to parent instance"
-    i.man.name = "Mungo"
-    assert_equal m.name, i.man.name, "Name of man should be the same after changes to replaced-child-owned instance"
+    assert_equal m.name, i.human.name, "Name of human should be the same after changes to parent instance"
+    i.human.name = "Mungo"
+    assert_equal m.name, i.human.name, "Name of human should be the same after changes to replaced-child-owned instance"
   end
 
   def test_parent_instance_should_be_shared_with_first_and_last_child
-    man = Man.first
+    human = Human.first
 
-    assert man.interests.first.man.equal? man
-    assert man.interests.last.man.equal? man
+    assert human.interests.first.human.equal? human
+    assert human.interests.last.human.equal? human
   end
 
   def test_parent_instance_should_be_shared_with_first_n_and_last_n_children
-    man = Man.first
+    human = Human.first
 
-    interests = man.interests.first(2)
-    assert interests[0].man.equal? man
-    assert interests[1].man.equal? man
+    interests = human.interests.first(2)
+    assert interests[0].human.equal? human
+    assert interests[1].human.equal? human
 
-    interests = man.interests.last(2)
-    assert interests[0].man.equal? man
-    assert interests[1].man.equal? man
+    interests = human.interests.last(2)
+    assert interests[0].human.equal? human
+    assert interests[1].human.equal? human
   end
 
   def test_parent_instance_should_find_child_instance_using_child_instance_id
-    man = Man.create!
+    human = Human.create!
     interest = Interest.create!
-    man.interests = [interest]
+    human.interests = [interest]
 
-    assert interest.equal?(man.interests.first), "The inverse association should use the interest already created and held in memory"
-    assert interest.equal?(man.interests.find(interest.id)), "The inverse association should use the interest already created and held in memory"
-    assert man.equal?(man.interests.first.man), "Two inversion should lead back to the same object that was originally held"
-    assert man.equal?(man.interests.find(interest.id).man), "Two inversions should lead back to the same object that was originally held"
+    assert interest.equal?(human.interests.first), "The inverse association should use the interest already created and held in memory"
+    assert interest.equal?(human.interests.find(interest.id)), "The inverse association should use the interest already created and held in memory"
+    assert human.equal?(human.interests.first.human), "Two inversion should lead back to the same object that was originally held"
+    assert human.equal?(human.interests.find(interest.id).human), "Two inversions should lead back to the same object that was originally held"
   end
 
   def test_parent_instance_should_find_child_instance_using_child_instance_id_when_created
-    man = Man.create!
-    interest = Interest.create!(man: man)
+    human = Human.create!
+    interest = Interest.create!(human: human)
 
-    assert man.equal?(man.interests.first.man), "Two inverses should lead back to the same object that was originally held"
-    assert man.equal?(man.interests.find(interest.id).man), "Two inversions should lead back to the same object that was originally held"
+    assert human.equal?(human.interests.first.human), "Two inverses should lead back to the same object that was originally held"
+    assert human.equal?(human.interests.find(interest.id).human), "Two inversions should lead back to the same object that was originally held"
 
-    assert_nil man.interests.find(interest.id).man.name, "The name of the man should match before the name is changed"
-    man.name = "Ben Bitdiddle"
-    assert_equal man.name, man.interests.find(interest.id).man.name, "The name of the man should match after the parent name is changed"
-    man.interests.find(interest.id).man.name = "Alyssa P. Hacker"
-    assert_equal man.name, man.interests.find(interest.id).man.name, "The name of the man should match after the child name is changed"
+    assert_nil human.interests.find(interest.id).human.name, "The name of the human should match before the name is changed"
+    human.name = "Ben Bitdiddle"
+    assert_equal human.name, human.interests.find(interest.id).human.name, "The name of the human should match after the parent name is changed"
+    human.interests.find(interest.id).human.name = "Alyssa P. Hacker"
+    assert_equal human.name, human.interests.find(interest.id).human.name, "The name of the human should match after the child name is changed"
   end
 
   def test_find_on_child_instance_with_id_should_not_load_all_child_records
-    man = Man.create!
-    interest = Interest.create!(man: man)
+    human = Human.create!
+    interest = Interest.create!(human: human)
 
-    man.interests.find(interest.id)
-    assert_not_predicate man.interests, :loaded?
+    human.interests.find(interest.id)
+    assert_not_predicate human.interests, :loaded?
   end
 
   def test_raise_record_not_found_error_when_invalid_ids_are_passed
@@ -491,68 +491,68 @@ class InverseHasManyTests < ActiveRecord::TestCase
     # are indeed invalid.
     Interest.delete_all
 
-    man = Man.create!
+    human = Human.create!
 
     invalid_id = 245324523
-    assert_raise(ActiveRecord::RecordNotFound) { man.interests.find(invalid_id) }
+    assert_raise(ActiveRecord::RecordNotFound) { human.interests.find(invalid_id) }
 
     invalid_ids = [8432342, 2390102913, 2453245234523452]
-    assert_raise(ActiveRecord::RecordNotFound) { man.interests.find(invalid_ids) }
+    assert_raise(ActiveRecord::RecordNotFound) { human.interests.find(invalid_ids) }
   end
 
   def test_raise_record_not_found_error_when_no_ids_are_passed
-    man = Man.create!
+    human = Human.create!
 
-    exception = assert_raise(ActiveRecord::RecordNotFound) { man.interests.load.find() }
+    exception = assert_raise(ActiveRecord::RecordNotFound) { human.interests.load.find() }
 
     assert_equal exception.model, "Interest"
     assert_equal exception.primary_key, "id"
   end
 
   def test_trying_to_use_inverses_that_dont_exist_should_raise_an_error
-    assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Man.first.secret_interests }
+    assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Human.first.secret_interests }
   end
 
   def test_child_instance_should_point_to_parent_without_saving
-    man = Man.new
+    human = Human.new
     i = Interest.create(topic: "Industrial Revolution Re-enactment")
 
-    man.interests << i
-    assert_not_nil i.man
+    human.interests << i
+    assert_not_nil i.human
 
-    i.man.name = "Charles"
-    assert_equal i.man.name, man.name
+    i.human.name = "Charles"
+    assert_equal i.human.name, human.name
 
-    assert_not_predicate man, :persisted?
+    assert_not_predicate human, :persisted?
   end
 
   def test_inverse_instance_should_be_set_before_find_callbacks_are_run
     reset_callbacks(Interest, :find) do
-      Interest.after_find { raise unless association(:man).loaded? && man.present? }
+      Interest.after_find { raise unless association(:human).loaded? && human.present? }
 
-      assert_predicate Man.first.interests.reload, :any?
-      assert_predicate Man.includes(:interests).first.interests, :any?
-      assert_predicate Man.joins(:interests).includes(:interests).first.interests, :any?
+      assert_predicate Human.first.interests.reload, :any?
+      assert_predicate Human.includes(:interests).first.interests, :any?
+      assert_predicate Human.joins(:interests).includes(:interests).first.interests, :any?
     end
   end
 
   def test_inverse_instance_should_be_set_before_initialize_callbacks_are_run
     reset_callbacks(Interest, :initialize) do
-      Interest.after_initialize { raise unless association(:man).loaded? && man.present? }
+      Interest.after_initialize { raise unless association(:human).loaded? && human.present? }
 
-      assert_predicate Man.first.interests.reload, :any?
-      assert_predicate Man.includes(:interests).first.interests, :any?
-      assert_predicate Man.joins(:interests).includes(:interests).first.interests, :any?
+      assert_predicate Human.first.interests.reload, :any?
+      assert_predicate Human.includes(:interests).first.interests, :any?
+      assert_predicate Human.joins(:interests).includes(:interests).first.interests, :any?
     end
   end
 end
 
 class InverseBelongsToTests < ActiveRecord::TestCase
-  fixtures :men, :faces, :interests
+  fixtures :humans, :faces, :interests
 
   def test_child_instance_should_be_shared_with_parent_on_find
     f = faces(:trusting)
-    m = f.man
+    m = f.human
     assert_equal f.description, m.face.description, "Description of face should be the same before changes to child instance"
     f.description = "gormless"
     assert_equal f.description, m.face.description, "Description of face should be the same after changes to child instance"
@@ -561,16 +561,16 @@ class InverseBelongsToTests < ActiveRecord::TestCase
   end
 
   def test_eager_loaded_child_instance_should_be_shared_with_parent_on_find
-    f = Face.all.merge!(includes: :man, where: { description: "trusting" }).first
-    m = f.man
+    f = Face.all.merge!(includes: :human, where: { description: "trusting" }).first
+    m = f.human
     assert_equal f.description, m.face.description, "Description of face should be the same before changes to child instance"
     f.description = "gormless"
     assert_equal f.description, m.face.description, "Description of face should be the same after changes to child instance"
     m.face.description = "pleasing"
     assert_equal f.description, m.face.description, "Description of face should be the same after changes to parent-owned instance"
 
-    f = Face.all.merge!(includes: :man, order: "men.id", where: { description: "trusting" }).first
-    m = f.man
+    f = Face.all.merge!(includes: :human, order: "humans.id", where: { description: "trusting" }).first
+    m = f.human
     assert_equal f.description, m.face.description, "Description of face should be the same before changes to child instance"
     f.description = "gormless"
     assert_equal f.description, m.face.description, "Description of face should be the same after changes to child instance"
@@ -580,7 +580,7 @@ class InverseBelongsToTests < ActiveRecord::TestCase
 
   def test_child_instance_should_be_shared_with_newly_built_parent
     f = faces(:trusting)
-    m = f.build_man(name: "Charles")
+    m = f.build_human(name: "Charles")
     assert_not_nil m.face
     assert_equal f.description, m.face.description, "Description of face should be the same before changes to child instance"
     f.description = "gormless"
@@ -591,7 +591,7 @@ class InverseBelongsToTests < ActiveRecord::TestCase
 
   def test_child_instance_should_be_shared_with_newly_created_parent
     f = faces(:trusting)
-    m = f.create_man(name: "Charles")
+    m = f.create_human(name: "Charles")
     assert_not_nil m.face
     assert_equal f.description, m.face.description, "Description of face should be the same before changes to child instance"
     f.description = "gormless"
@@ -602,7 +602,7 @@ class InverseBelongsToTests < ActiveRecord::TestCase
 
   def test_should_not_try_to_set_inverse_instances_when_the_inverse_is_a_has_many
     i = interests(:trainspotting)
-    m = i.man
+    m = i.human
     assert_not_nil m.interests
     iz = m.interests.detect { |_iz| _iz.id == i.id }
     assert_not_nil iz
@@ -616,7 +616,7 @@ class InverseBelongsToTests < ActiveRecord::TestCase
   def test_with_has_many_inversing_should_try_to_set_inverse_instances_when_the_inverse_is_a_has_many
     with_has_many_inversing do
       i = interests(:trainspotting)
-      m = i.man
+      m = i.human
       assert_not_nil m.interests
       iz = m.interests.detect { |_iz| _iz.id == i.id }
       assert_not_nil iz
@@ -630,15 +630,15 @@ class InverseBelongsToTests < ActiveRecord::TestCase
 
   def test_with_has_many_inversing_does_not_trigger_association_callbacks_on_set_when_the_inverse_is_a_has_many
     with_has_many_inversing do
-      man = interests(:trainspotting).man_with_callbacks
-      assert_not_predicate man, :add_callback_called?
+      human = interests(:trainspotting).human_with_callbacks
+      assert_not_predicate human, :add_callback_called?
     end
   end
 
   def test_child_instance_should_be_shared_with_replaced_via_accessor_parent
     f = Face.first
-    m = Man.new(name: "Charles")
-    f.man = m
+    m = Human.new(name: "Charles")
+    f.human = m
     assert_not_nil m.face
     assert_equal f.description, m.face.description, "Description of face should be the same before changes to child instance"
     f.description = "gormless"
@@ -648,26 +648,26 @@ class InverseBelongsToTests < ActiveRecord::TestCase
   end
 
   def test_trying_to_use_inverses_that_dont_exist_should_raise_an_error
-    assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Face.first.horrible_man }
+    assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Face.first.horrible_human }
   end
 
   def test_building_has_many_parent_association_inverses_one_record
     with_has_many_inversing do
       interest = Interest.new
-      interest.build_man
-      assert_equal 1, interest.man.interests.size
+      interest.build_human
+      assert_equal 1, interest.human.interests.size
       interest.save!
-      assert_equal 1, interest.man.interests.size
+      assert_equal 1, interest.human.interests.size
     end
   end
 end
 
 class InversePolymorphicBelongsToTests < ActiveRecord::TestCase
-  fixtures :men, :faces, :interests
+  fixtures :humans, :faces, :interests
 
   def test_child_instance_should_be_shared_with_parent_on_find
     f = Face.all.merge!(where: { description: "confused" }).first
-    m = f.polymorphic_man
+    m = f.polymorphic_human
     assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same before changes to child instance"
     f.description = "gormless"
     assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same after changes to child instance"
@@ -676,16 +676,16 @@ class InversePolymorphicBelongsToTests < ActiveRecord::TestCase
   end
 
   def test_eager_loaded_child_instance_should_be_shared_with_parent_on_find
-    f = Face.all.merge!(where: { description: "confused" }, includes: :man).first
-    m = f.polymorphic_man
+    f = Face.all.merge!(where: { description: "confused" }, includes: :human).first
+    m = f.polymorphic_human
     assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same before changes to child instance"
     f.description = "gormless"
     assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same after changes to child instance"
     m.polymorphic_face.description = "pleasing"
     assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same after changes to parent-owned instance"
 
-    f = Face.all.merge!(where: { description: "confused" }, includes: :man, order: "men.id").first
-    m = f.polymorphic_man
+    f = Face.all.merge!(where: { description: "confused" }, includes: :human, order: "humans.id").first
+    m = f.polymorphic_human
     assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same before changes to child instance"
     f.description = "gormless"
     assert_equal f.description, m.polymorphic_face.description, "Description of face should be the same after changes to child instance"
@@ -695,43 +695,43 @@ class InversePolymorphicBelongsToTests < ActiveRecord::TestCase
 
   def test_child_instance_should_be_shared_with_replaced_via_accessor_parent
     face = faces(:confused)
-    new_man = Man.new
+    new_human = Human.new
 
-    assert_not_nil face.polymorphic_man
-    face.polymorphic_man = new_man
+    assert_not_nil face.polymorphic_human
+    face.polymorphic_human = new_human
 
-    assert_equal face.description, new_man.polymorphic_face.description, "Description of face should be the same before changes to parent instance"
+    assert_equal face.description, new_human.polymorphic_face.description, "Description of face should be the same before changes to parent instance"
     face.description = "Bongo"
-    assert_equal face.description, new_man.polymorphic_face.description, "Description of face should be the same after changes to parent instance"
-    new_man.polymorphic_face.description = "Mungo"
-    assert_equal face.description, new_man.polymorphic_face.description, "Description of face should be the same after changes to replaced-parent-owned instance"
+    assert_equal face.description, new_human.polymorphic_face.description, "Description of face should be the same after changes to parent instance"
+    new_human.polymorphic_face.description = "Mungo"
+    assert_equal face.description, new_human.polymorphic_face.description, "Description of face should be the same after changes to replaced-parent-owned instance"
   end
 
   def test_inversed_instance_should_not_be_reloaded_after_stale_state_changed
-    new_man = Man.new
+    new_human = Human.new
     face = Face.new
-    new_man.face = face
+    new_human.face = face
 
-    old_inversed_man = face.man
-    new_man.save!
-    new_inversed_man = face.man
+    old_inversed_human = face.human
+    new_human.save!
+    new_inversed_human = face.human
 
-    assert_same old_inversed_man, new_inversed_man
+    assert_same old_inversed_human, new_inversed_human
   end
 
   def test_inversed_instance_should_not_be_reloaded_after_stale_state_changed_with_validation
-    face = Face.new man: Man.new
+    face = Face.new human: Human.new
 
-    old_inversed_man = face.man
+    old_inversed_human = face.human
     face.save!
-    new_inversed_man = face.man
+    new_inversed_human = face.human
 
-    assert_same old_inversed_man, new_inversed_man
+    assert_same old_inversed_human, new_inversed_human
   end
 
   def test_should_not_try_to_set_inverse_instances_when_the_inverse_is_a_has_many
     i = interests(:llama_wrangling)
-    m = i.polymorphic_man
+    m = i.polymorphic_human
     assert_not_nil m.polymorphic_interests
     iz = m.polymorphic_interests.detect { |_iz| _iz.id == i.id }
     assert_not_nil iz
@@ -745,7 +745,7 @@ class InversePolymorphicBelongsToTests < ActiveRecord::TestCase
   def test_with_has_many_inversing_should_try_to_set_inverse_instances_when_the_inverse_is_a_has_many
     with_has_many_inversing do
       i = interests(:llama_wrangling)
-      m = i.polymorphic_man
+      m = i.polymorphic_human
       assert_not_nil m.polymorphic_interests
       iz = m.polymorphic_interests.detect { |_iz| _iz.id == i.id }
       assert_not_nil iz
@@ -759,39 +759,39 @@ class InversePolymorphicBelongsToTests < ActiveRecord::TestCase
 
   def test_with_has_many_inversing_does_not_trigger_association_callbacks_on_set_when_the_inverse_is_a_has_many
     with_has_many_inversing do
-      man = interests(:llama_wrangling).polymorphic_man_with_callbacks
-      assert_not_predicate man, :add_callback_called?
+      human = interests(:llama_wrangling).polymorphic_human_with_callbacks
+      assert_not_predicate human, :add_callback_called?
     end
   end
 
   def test_trying_to_access_inverses_that_dont_exist_shouldnt_raise_an_error
     # Ideally this would, if only for symmetry's sake with other association types
-    assert_nothing_raised { Face.first.horrible_polymorphic_man }
+    assert_nothing_raised { Face.first.horrible_polymorphic_human }
   end
 
   def test_trying_to_set_polymorphic_inverses_that_dont_exist_at_all_should_raise_an_error
-    # fails because no class has the correct inverse_of for horrible_polymorphic_man
-    assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Face.first.horrible_polymorphic_man = Man.first }
+    # fails because no class has the correct inverse_of for horrible_polymorphic_human
+    assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Face.first.horrible_polymorphic_human = Human.first }
   end
 
   def test_trying_to_set_polymorphic_inverses_that_dont_exist_on_the_instance_being_set_should_raise_an_error
-    # passes because Man does have the correct inverse_of
-    assert_nothing_raised { Face.first.polymorphic_man = Man.first }
+    # passes because Human does have the correct inverse_of
+    assert_nothing_raised { Face.first.polymorphic_human = Human.first }
     # fails because Interest does have the correct inverse_of
-    assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Face.first.polymorphic_man = Interest.first }
+    assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Face.first.polymorphic_human = Interest.first }
   end
 end
 
 # NOTE - these tests might not be meaningful, ripped as they were from the parental_control plugin
 # which would guess the inverse rather than look for an explicit configuration option.
 class InverseMultipleHasManyInversesForSameModel < ActiveRecord::TestCase
-  fixtures :men, :interests, :zines
+  fixtures :humans, :interests, :zines
 
   def test_that_we_can_load_associations_that_have_the_same_reciprocal_name_from_different_models
     assert_nothing_raised do
       i = Interest.first
       i.zine
-      i.man
+      i.human
     end
   end
 
@@ -799,7 +799,7 @@ class InverseMultipleHasManyInversesForSameModel < ActiveRecord::TestCase
     assert_nothing_raised do
       i = Interest.first
       i.build_zine(title: "Get Some in Winter! 2008")
-      i.build_man(name: "Gordon")
+      i.build_human(name: "Gordon")
       i.save!
     end
   end

activerecord/test/cases/associations_test.rb

@@ -19,7 +19,7 @@ require "models/ship"
 require "models/liquid"
 require "models/molecule"
 require "models/electron"
-require "models/man"
+require "models/human"
 require "models/interest"
 require "models/pirate"
 require "models/parrot"
@@ -240,13 +240,13 @@ class AssociationProxyTest < ActiveRecord::TestCase
   end
 
   test "inverses get set of subsets of the association" do
-    man = Man.create
-    man.interests.create
+    human = Human.create
+    human.interests.create
 
-    man = Man.find(man.id)
+    human = Human.find(human.id)
 
     assert_queries(1) do
-      assert_equal man, man.interests.where("1=1").first.man
+      assert_equal human, human.interests.where("1=1").first.human
     end
   end
 

activerecord/test/cases/nested_attributes_test.rb

@@ -7,7 +7,7 @@ require "models/ship_part"
 require "models/bird"
 require "models/parrot"
 require "models/treasure"
-require "models/man"
+require "models/human"
 require "models/interest"
 require "models/owner"
 require "models/pet"
@@ -140,19 +140,19 @@ class TestNestedAttributesInGeneral < ActiveRecord::TestCase
   end
 
   def test_reject_if_with_a_proc_which_returns_true_always_for_has_many
-    Man.accepts_nested_attributes_for :interests, reject_if: proc { |attributes| true }
-    man = Man.create(name: "John")
-    interest = man.interests.create(topic: "photography")
-    man.update(interests_attributes: { topic: "gardening", id: interest.id })
+    Human.accepts_nested_attributes_for :interests, reject_if: proc { |attributes| true }
+    human = Human.create(name: "John")
+    interest = human.interests.create(topic: "photography")
+    human.update(interests_attributes: { topic: "gardening", id: interest.id })
     assert_equal "photography", interest.reload.topic
   end
 
   def test_destroy_works_independent_of_reject_if
-    Man.accepts_nested_attributes_for :interests, reject_if: proc { |attributes| true }, allow_destroy: true
-    man = Man.create(name: "Jon")
-    interest = man.interests.create(topic: "the ladies")
-    man.update(interests_attributes: { _destroy: "1", id: interest.id })
-    assert_empty man.reload.interests
+    Human.accepts_nested_attributes_for :interests, reject_if: proc { |attributes| true }, allow_destroy: true
+    human = Human.create(name: "Jon")
+    interest = human.interests.create(topic: "the ladies")
+    human.update(interests_attributes: { _destroy: "1", id: interest.id })
+    assert_empty human.reload.interests
   end
 
   def test_reject_if_is_not_short_circuited_if_allow_destroy_is_false
@@ -169,10 +169,10 @@ class TestNestedAttributesInGeneral < ActiveRecord::TestCase
   end
 
   def test_has_many_association_updating_a_single_record
-    Man.accepts_nested_attributes_for(:interests)
-    man = Man.create(name: "John")
-    interest = man.interests.create(topic: "photography")
-    man.update(interests_attributes: { topic: "gardening", id: interest.id })
+    Human.accepts_nested_attributes_for(:interests)
+    human = Human.create(name: "John")
+    interest = human.interests.create(topic: "photography")
+    human.update(interests_attributes: { topic: "gardening", id: interest.id })
     assert_equal "gardening", interest.reload.topic
   end
 
@@ -186,12 +186,12 @@ class TestNestedAttributesInGeneral < ActiveRecord::TestCase
   end
 
   def test_first_and_array_index_zero_methods_return_the_same_value_when_nested_attributes_are_set_to_update_existing_record
-    Man.accepts_nested_attributes_for(:interests)
-    man = Man.create(name: "John")
-    interest = man.interests.create topic: "gardening"
-    man = Man.find man.id
-    man.interests_attributes = [{ id: interest.id, topic: "gardening" }]
-    assert_equal man.interests.first.topic, man.interests[0].topic
+    Human.accepts_nested_attributes_for(:interests)
+    human = Human.create(name: "John")
+    interest = human.interests.create topic: "gardening"
+    human = Human.find human.id
+    human.interests_attributes = [{ id: interest.id, topic: "gardening" }]
+    assert_equal human.interests.first.topic, human.interests[0].topic
   end
 
   def test_allows_class_to_override_setter_and_call_super
@@ -219,10 +219,10 @@ class TestNestedAttributesInGeneral < ActiveRecord::TestCase
   end
 
   def test_should_not_create_duplicates_with_create_with
-    Man.accepts_nested_attributes_for(:interests)
+    Human.accepts_nested_attributes_for(:interests)
 
     assert_difference("Interest.count", 1) do
-      Man.create_with(
+      Human.create_with(
         interests_attributes: [{ topic: "Pirate king" }]
       ).find_or_create_by!(
         name: "Monkey D. Luffy"
@@ -817,17 +817,17 @@ module NestedAttributesOnACollectionAssociationTests
   end
 
   def test_validate_presence_of_parent_works_with_inverse_of
-    Man.accepts_nested_attributes_for(:interests)
-    assert_equal :man, Man.reflect_on_association(:interests).options[:inverse_of]
-    assert_equal :interests, Interest.reflect_on_association(:man).options[:inverse_of]
+    Human.accepts_nested_attributes_for(:interests)
+    assert_equal :human, Human.reflect_on_association(:interests).options[:inverse_of]
+    assert_equal :interests, Interest.reflect_on_association(:human).options[:inverse_of]
 
     repair_validations(Interest) do
-      Interest.validates_presence_of(:man)
-      assert_difference "Man.count" do
+      Interest.validates_presence_of(:human)
+      assert_difference "Human.count" do
         assert_difference "Interest.count", 2 do
-          man = Man.create!(name: "John",
+          human = Human.create!(name: "John",
                             interests_attributes: [{ topic: "Cars" }, { topic: "Sports" }])
-          assert_equal 2, man.interests.count
+          assert_equal 2, human.interests.count
         end
       end
     end
@@ -839,14 +839,14 @@ module NestedAttributesOnACollectionAssociationTests
   end
 
   def test_numeric_column_changes_from_zero_to_no_empty_string
-    Man.accepts_nested_attributes_for(:interests)
+    Human.accepts_nested_attributes_for(:interests)
 
     repair_validations(Interest) do
       Interest.validates_numericality_of(:zine_id)
-      man = Man.create(name: "John")
-      interest = man.interests.create(topic: "bar", zine_id: 0)
+      human = Human.create(name: "John")
+      interest = human.interests.create(topic: "bar", zine_id: 0)
       assert interest.save
-      assert_not man.update(interests_attributes: { id: interest.id, zine_id: "foo" })
+      assert_not human.update(interests_attributes: { id: interest.id, zine_id: "foo" })
     end
   end
 

activerecord/test/cases/relation/where_chain_test.rb

@@ -3,7 +3,7 @@
 require "cases/helper"
 require "models/post"
 require "models/author"
-require "models/man"
+require "models/human"
 require "models/essay"
 require "models/comment"
 require "models/categorization"
@@ -11,7 +11,7 @@ require "models/categorization"
 
 module ActiveRecord
   class WhereChainTest < ActiveRecord::TestCase
-    fixtures :posts, :comments, :authors, :men, :essays
+    fixtures :posts, :comments, :authors, :humans, :essays
 
     def test_missing_with_association
       assert posts(:authorless).author.blank?
@@ -105,8 +105,8 @@ module ActiveRecord
     end
 
     def test_rewhere_with_polymorphic_association
-      relation = Essay.where(writer: authors(:david)).rewhere(writer: men(:steve))
-      expected = Essay.where(writer: men(:steve))
+      relation = Essay.where(writer: authors(:david)).rewhere(writer: humans(:steve))
+      expected = Essay.where(writer: humans(:steve))
 
       assert_equal expected.to_a, relation.to_a
     end

activerecord/test/cases/validations/absence_validation_test.rb

@@ -3,12 +3,12 @@
 require "cases/helper"
 require "models/face"
 require "models/interest"
-require "models/man"
+require "models/human"
 require "models/topic"
 
 class AbsenceValidationTest < ActiveRecord::TestCase
   def test_non_association
-    boy_klass = Class.new(Man) do
+    boy_klass = Class.new(Human) do
       def self.name; "Boy" end
       validates_absence_of :name
     end
@@ -18,7 +18,7 @@ class AbsenceValidationTest < ActiveRecord::TestCase
   end
 
   def test_has_one_marked_for_destruction
-    boy_klass = Class.new(Man) do
+    boy_klass = Class.new(Human) do
       def self.name; "Boy" end
       validates_absence_of :face
     end
@@ -32,7 +32,7 @@ class AbsenceValidationTest < ActiveRecord::TestCase
   end
 
   def test_has_many_marked_for_destruction
-    boy_klass = Class.new(Man) do
+    boy_klass = Class.new(Human) do
       def self.name; "Boy" end
       validates_absence_of :interests
     end
@@ -48,7 +48,7 @@ class AbsenceValidationTest < ActiveRecord::TestCase
   end
 
   def test_does_not_call_to_a_on_associations
-    boy_klass = Class.new(Man) do
+    boy_klass = Class.new(Human) do
       def self.name; "Boy" end
       validates_absence_of :face
     end

activerecord/test/cases/validations/association_validation_test.rb

@@ -3,7 +3,7 @@
 require "cases/helper"
 require "models/topic"
 require "models/reply"
-require "models/man"
+require "models/human"
 require "models/interest"
 
 class AssociationValidationTest < ActiveRecord::TestCase
@@ -80,20 +80,20 @@ class AssociationValidationTest < ActiveRecord::TestCase
 
   def test_validates_presence_of_belongs_to_association__parent_is_new_record
     repair_validations(Interest) do
-      # Note that Interest and Man have the :inverse_of option set
-      Interest.validates_presence_of(:man)
-      man = Man.new(name: "John")
-      interest = man.interests.build(topic: "Airplanes")
-      assert interest.valid?, "Expected interest to be valid, but was not. Interest should have a man object associated"
+      # Note that Interest and Human have the :inverse_of option set
+      Interest.validates_presence_of(:human)
+      human = Human.new(name: "John")
+      interest = human.interests.build(topic: "Airplanes")
+      assert interest.valid?, "Expected interest to be valid, but was not. Interest should have a human object associated"
     end
   end
 
   def test_validates_presence_of_belongs_to_association__existing_parent
     repair_validations(Interest) do
-      Interest.validates_presence_of(:man)
-      man = Man.create!(name: "John")
-      interest = man.interests.build(topic: "Airplanes")
-      assert interest.valid?, "Expected interest to be valid, but was not. Interest should have a man object associated"
+      Interest.validates_presence_of(:human)
+      human = Human.create!(name: "John")
+      interest = human.interests.build(topic: "Airplanes")
+      assert interest.valid?, "Expected interest to be valid, but was not. Interest should have a human object associated"
     end
   end
 end

activerecord/test/cases/validations/presence_validation_test.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
 require "cases/helper"
-require "models/man"
+require "models/human"
 require "models/face"
 require "models/interest"
 require "models/speedometer"
 require "models/dashboard"
 
 class PresenceValidationTest < ActiveRecord::TestCase
-  class Boy < Man; end
+  class Boy < Human; end
 
   repair_validations(Boy)
 

activerecord/test/fixtures/essays.yml

@@ -12,5 +12,5 @@ mary_stay_home:
 
 steve_connecting_the_dots:
   name: Connecting The Dots
-  writer_type: Man
+  writer_type: Human
   writer_id: Steve

activerecord/test/fixtures/faces.yml

@@ -1,11 +1,11 @@
 trusting:
   description: trusting
-  man: gordon
+  human: gordon
 
 weather_beaten:
   description: weather beaten
-  man: steve
+  human: steve
 
 confused:
   description: confused
-  polymorphic_man: gordon (Man)
+  polymorphic_human: gordon (Human)

activerecord/test/fixtures/interests.yml

@@ -1,33 +1,33 @@
 trainspotting:
   topic: Trainspotting
   zine: staying_in
-  man: gordon
+  human: gordon
 
 birdwatching:
   topic: Birdwatching
   zine: staying_in
-  man: gordon
+  human: gordon
 
 stamp_collecting:
   topic: Stamp Collecting
   zine: staying_in
-  man: gordon
+  human: gordon
 
 hunting:
   topic: Hunting
   zine: going_out
-  man: steve
+  human: steve
 
 woodsmanship:
   topic: Woodsmanship
   zine: going_out
-  man: steve
+  human: steve
 
 survival:
   topic: Survival
   zine: going_out
-  man: steve
+  human: steve
 
 llama_wrangling:
   topic: Llama Wrangling
-  polymorphic_man: gordon (Man)
+  polymorphic_human: gordon (Human)

activerecord/test/models/face.rb

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
 class Face < ActiveRecord::Base
-  belongs_to :man, inverse_of: :face
-  belongs_to :human, polymorphic: true
-  belongs_to :polymorphic_man, polymorphic: true, inverse_of: :polymorphic_face
+  belongs_to :human, inverse_of: :face
+  belongs_to :super_human, polymorphic: true
+  belongs_to :polymorphic_human, 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_human_without_inverse, polymorphic: true
   # These are "broken" inverse_of associations 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_human, class_name: "Human", inverse_of: :horrible_face
+  belongs_to :horrible_polymorphic_human, polymorphic: true, inverse_of: :horrible_polymorphic_face
 
   validate do
-    man
+    human
   end
 end

activerecord/test/models/human.rb

@@ -1,28 +1,30 @@
 # frozen_string_literal: true
 
-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
+class Human < ActiveRecord::Base
+  self.table_name = "humans"
+
+  has_one :face, inverse_of: :human
+  has_one :polymorphic_face, class_name: "Face", as: :polymorphic_human, inverse_of: :polymorphic_human
+  has_one :polymorphic_face_without_inverse, class_name: "Face", as: :poly_human_without_inverse
+  has_many :interests, inverse_of: :human
   has_many :interests_with_callbacks,
     class_name: "Interest",
     before_add: :add_called,
     after_add: :add_called,
-    inverse_of: :man_with_callbacks
+    inverse_of: :human_with_callbacks
   has_many :polymorphic_interests,
     class_name: "Interest",
-    as: :polymorphic_man,
-    inverse_of: :polymorphic_man
+    as: :polymorphic_human,
+    inverse_of: :polymorphic_human
   has_many :polymorphic_interests_with_callbacks,
     class_name: "Interest",
-    as: :polymorphic_man,
+    as: :polymorphic_human,
     before_add: :add_called,
     after_add: :add_called,
-    inverse_of: :polymorphic_man
+    inverse_of: :polymorphic_human
   # 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_human
+  has_many :secret_interests, class_name: "Interest", inverse_of: :secret_human
   has_one :mixed_case_monkey
 
   attribute :add_callback_called, :boolean, default: false
@@ -32,5 +34,5 @@ class Man < ActiveRecord::Base
   end
 end
 
-class Human < Man
+class SuperHuman < Human
 end

activerecord/test/models/interest.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
 class Interest < ActiveRecord::Base
-  belongs_to :man, inverse_of: :interests
-  belongs_to :man_with_callbacks,
-    class_name: "Man",
-    foreign_key: :man_id,
+  belongs_to :human, inverse_of: :interests
+  belongs_to :human_with_callbacks,
+    class_name: "Human",
+    foreign_key: :human_id,
     inverse_of: :interests_with_callbacks
-  belongs_to :polymorphic_man, polymorphic: true, inverse_of: :polymorphic_interests
-  belongs_to :polymorphic_man_with_callbacks,
-    foreign_key: :polymorphic_man_id,
-    foreign_type: :polymorphic_man_type,
+  belongs_to :polymorphic_human, polymorphic: true, inverse_of: :polymorphic_interests
+  belongs_to :polymorphic_human_with_callbacks,
+    foreign_key: :polymorphic_human_id,
+    foreign_type: :polymorphic_human_type,
     polymorphic: true,
     inverse_of: :polymorphic_interests_with_callbacks
   belongs_to :zine, inverse_of: :interests

activerecord/test/models/mixed_case_monkey.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class MixedCaseMonkey < ActiveRecord::Base
-  belongs_to :man
+  belongs_to :human
 end

activerecord/test/schema/schema.rb

@@ -1009,27 +1009,27 @@ ActiveRecord::Schema.define do
     create_table(t, force: true) { }
   end
 
-  create_table :men, force: true do |t|
+  create_table :humans, force: true do |t|
     t.string  :name
   end
 
   create_table :faces, force: true do |t|
     t.string  :description
-    t.integer :man_id
-    t.integer :polymorphic_man_id
-    t.string  :polymorphic_man_type
-    t.integer :poly_man_without_inverse_id
-    t.string  :poly_man_without_inverse_type
-    t.integer :horrible_polymorphic_man_id
-    t.string  :horrible_polymorphic_man_type
-    t.references :human, polymorphic: true, index: false
+    t.integer :human_id
+    t.integer :polymorphic_human_id
+    t.string  :polymorphic_human_type
+    t.integer :poly_human_without_inverse_id
+    t.string  :poly_human_without_inverse_type
+    t.integer :horrible_polymorphic_human_id
+    t.string  :horrible_polymorphic_human_type
+    t.references :super_human, polymorphic: true, index: false
   end
 
   create_table :interests, force: true do |t|
     t.string :topic
-    t.integer :man_id
-    t.integer :polymorphic_man_id
-    t.string :polymorphic_man_type
+    t.integer :human_id
+    t.integer :polymorphic_human_id
+    t.string :polymorphic_human_type
     t.integer :zine_id
   end