While it’s always nice to peruse a table of contents, I thought it would be fun to summarize the information found in the Easy Active Record for Rails Developers by identifying 100 117 121 different bits of knowledge you’ll gain by reading it. Without further ado, here’s just a sampling of what you’ll learn by reading the book:

  1. Install the MySQL and PostgreSQL gems
  2. Configure your Rails project’s database.yml file.
  3. Create the project database using a convenient Rake task.
  4. Avoid typing bundle exec when executing Rake tasks.
  5. Install the RSpec, FactoryGirl and Database Cleaner gems.
  6. Create a model.
  7. Create a model’s corresponding database table.
  8. Easily revert (rollback) database table changes.
  9. View and manipulate data in the Rails console.
  10. Manipulate records in the Rails console without actually corrupting your database data.
  11. Change the Rails console prompt.
  12. Reload the Rails console without actually exiting it.
  13. Define model accessors and mutators (getters and setters).
  14. Create virtual attributes.
  15. Understand the structure and content of a migration file.
  16. View the migration status.
  17. Constrain the range of an integer.
  18. Constrain the size of a string.
  19. Constrain the precision and scale of a decimal.
  20. Define model attributes while simultaneously creating a new model.
  21. Modify existing tables using migrations.
  22. Add, rename and delete a table column using migrations.
  23. Drop a table using migrations.
  24. Understand the purpose of the db/schema.rb file.
  25. Override the default table naming convention.
  26. Override the default primary key designation.
  27. Create and run an RSpec-driven model test.
  28. Define fixtures using FactoryGirl.
  29. Eliminate test redundancy using test setups.
  30. Lint your factories.
  31. Create an HTML-formatted test report.
  32. Easily seed your project database using the db/seeds.rb file..
  33. Add database data using migrations.
  34. Use callbacks to manage the lifecycle of an Active Record object.
  35. The difference between the after_commit and after_save callbacks.
  36. Validate models using Rails validators.
  37. Determine whether an model object is valid.
  38. Retrieve and present model validation errors within the application view..
  39. Ensure a model attribute can only be assigned integer values within a specified range.
  40. Ensure a model attribute can only be assigned a specific number of characters.
  41. Create custom validation error messages.
  42. Create a custom validator.
  43. Use regular expressions within validators.
  44. Constrain model attribute values to a predefined set of allowable options.
  45. Confirm the user has entered the same password twice.
  46. Ensure a model attribute value is unique.
  47. Validate dates using the date_validator gem.
  48. Validate Boolean values.
  49. Validate model attributes while also allowing blank and nil values.
  50. Combine validators.
  51. Conditionally validate model attributes.
  52. Test your validations with RSpec.
  53. Create, update and delete records.
  54. The difference between save and save!.
  55. Create but not save records using the build method.
  56. Execute mass attribute assigment using the update method.
  57. The difference between the update_column and update_columns methods.
  58. Create a record if it doesn’t already exist.
  59. Understand why strong parameters were introduced in Rails 4.
  60. Integrate strong parameters into your Rails 4 application.
  61. The difference between the delete and destroy methods.
  62. Why you should use the find_each method when retrieving a large number of records.
  63. Select specific columns rather than retrieve all columns in a database table.
  64. Count records the correct way.
  65. Determine whether a record exists.
  66. Order records according to a specific column.
  67. Limit the number of returned records.
  68. Retrieve the first or last record.
  69. Retrieve a random record.
  70. Retrieve a specific record according to its primary key.
  71. Retrieve records according to a condition.
  72. Negate a conditional.
  73. Use parameter binding to avoid SQL injection attacks.
  74. Perform fuzzy searches.
  75. Use dynamic finders.
  76. Execute raw SQL.
  77. Group records by a specific column value.
  78. Filter grouped records using the having clause.
  79. Paginate results using the will_paginate gem.
  80. Create prettier URLs using the friendly_id gem.
  81. Use model scopes to create more readable code and eliminate redundancy.
  82. Test your model scopes using RSpec.
  83. Understand why database normalization is important.
  84. Understand the difference between the belongs_to and has_one association.
  85. Create, traverse, update, validate and test (using RSpec) a belongs_to association.
  86. Use counter caches for optimized association counting.
  87. Use conditions within a belongs_to association definition.
  88. Use scopes within a belongs_to association definition.
  89. Create, traverse, update, validate and test (using RSpec) a has_one association.
  90. Create, traverse, update, validate and test (using RSpec) a has_many association.
  91. Determine whether a has_many association exists.
  92. Define dependency behavior (determine whether a dependency should be orphaned or destroyed)
  93. Autosave has_many associations.
  94. Override the default has_many foreign key designation.
  95. Create, traverse, update, validate and test (using RSpec) a has_and_belongs_to_many association.
  96. Set a default sort order for has_and_belongs_to_many associations.
  97. Ensure unique has_and_belongs_to_many associations.
  98. Create, traverse, update, validate and test (using RSpec) a has_many :through association.
  99. Update a has_many :through attribute found in the join model.
  100. Convert a has_and_belongs_to_many Association to has_many :through
  101. Use the join method to join tables in every conceivable manner.
  102. Understand eager loading and when you should use the include method.
  103. Create and use polymorphic models.
  104. Understand Rails’ RESTful routing approach.
  105. Create a contact form using the mail_form gem.
  106. Configure Action Mailer to use a Gmail account.
  107. Create and display flash notices.
  108. Test a form using RSpec and Capybara.
  109. Use the collection_select form helper.
  110. Update a has_many :through association using a nested form.
  111. Create a password-protected administration interface.
  112. Understand why the formtastic and simple_form gems might be preferable over Rails’ default form generation features.
  113. Relieve stress on your eyes by integrating the awesome_print gem into the Rails console.
  114. Create a much more friendly error output using the better_errors gem.
  115. Take advantage of a powerful Rails console alternative called Pry.
  116. Optimize your application using column indexes.
  117. Cache pages, actions and fragments using native Rails caching features.
  118. Use the Devise gem to add user authentication, sign in, sign out, password recovery, and account management features.
  119. Override the default Devise view and e-mail templates to suit the design of your specific project.
  120. Add custom user profile attributes to the Devise User model.
  121. Restrict controller access to authenticated users.

Does Easy Active Record for Rails Developers sound like something you’d want to read? Buy the book now!

Is there a topic not listed here that you wonder whether I’ve covered? E-mail me and I’ll let you know!