#inverse_of

Topics

Rails App

Authentication

MVC - Model-View-Controller

Checked Boxes in HTML

Polymorphic Associations

Projects

RedditClone

Partner: Kat Telles

Learnings

before_action :require_login - jump to login page if not logged in

Commas in link_to "link text" destination_url - commas are required, will get expected keyword end error

Can pass a query_string "?sub_id:2" into URL so destination of button can parse params[:sub_id]

<%= link_to "Create new post", new_post_url(sub_id: "#{@sub.id}") %>

Error "You need to supply at least one validation" -- means you most likely forgot to write presence: true as an option in validates :thing1, :thing2

Place in stylesheets/application.css to apply default textarea size (or other defaults) on all web pages

input[type=textarea]{ width: 500 px; height: 150 px; }

Use save rather than save! in if/else blocks, since save returns false when it fails, whereas save! throws an error

Polymorphic associations - validate object rather than id

class PostSub validates :post, :sub, presence: true end

Nested HTML Forms

Extracting and Permitting Nested Data

Transactions

inverse_of

Today we made a social media web app that mimics some of the properties of Google+'s circles features.

Users sign up and authenticate like normal. Except this time we added the functionality of allowing users to enter their email and (if they so choose) send a password reset email to them allowing them to change their password if they click the specific link we provide. We also DRYed up the usual code by breaking it down into more helpers and form partials etc. We're really hammering in these important features since they're pretty necessary for almost any web application we'd make in the future. Security and Authorization reigns supreme when information is power!

After signing up or logging in, users can create different groups of users called Friend Circles (thanks Google+!) for which separate groups of friends (other users) for tailored content. The user can then make posts, which include several links and descriptions of links. We actually made several different models to represent our data/objects, but used nested forms and associations to create them all at once (or not at all if the data entered was invalid).

Most of the challenge in this project was creating the nested forms that created all of our objects at the same time through their associations (if you named the form fields effectively) and only saving them all to the database if they were all valid. Some frustration might arise if you filled out a bunch of fields and then were redirected because of one typo or missing validation, say your password was accidentally below the minimum length. A cool feature we added was to auto populate those fields that were persisted through because they were valid so the user didn't have to type them in again. COOL. Using inverse_of option in the has_many relation allowed us to tell rails the other side of the relation so that they could completely be tied together (in transaction like status) by rails magic, enabling two associated objects to be saved simultaneously, and their relation preserved, while automatically assigning foreign_keys at the time they are saved to the database. Pretty cool.

Directly from ActiveRecord documentation on bi-directional associations:

Bi-directional associations

When you specify an association there is usually an association on the associated model that specifies the same relationship in reverse. For example, with the following models:

class Dungeon < ActiveRecord::Base has_many :traps has_one :evil_wizard end class Trap < ActiveRecord::Base belongs_to :dungeon end class EvilWizard < ActiveRecord::Base belongs_to :dungeon end

The traps association on Dungeon and the dungeon association on Trap are the inverse of each other and the inverse of the dungeon association on EvilWizard is the evil_wizard association on Dungeon (and vice-versa). By default, Active Record doesn’t know anything about these inverse relationships and so no object loading optimization is possible. For example:

d = Dungeon.first t = d.traps.first d.level == t.dungeon.level # => true d.level = 10 d.level == t.dungeon.level # => false

The Dungeon instances d and t.dungeon in the above example refer to the same object data from the database, but are actually different in-memory copies of that data. **Specifying the :inverse_of option on associations lets you tell Active Record about inverse relationships and it will optimise object loading. For example, if we changed our model definitions to:

class Dungeon < ActiveRecord::Base has_many :traps, inverse_of: :dungeon has_one :evil_wizard, inverse_of: :dungeon end class Trap < ActiveRecord::Base belongs_to :dungeon, inverse_of: :traps end class EvilWizard < ActiveRecord::Base belongs_to :dungeon, inverse_of: :evil_wizard end

Then, from our code snippet above, d and t.dungeon are actually the same in-memory instance and our final d.level == t.dungeon.level will return true.

There are limitations to :inverse_of support:

does not work with :through associations.

does not work with :polymorphic associations.

Today, we set about to build a clone of Y Combinator's Hacker News. My partner, Eric, and I started from the bottom, and spent a good deal of time setting up some complex associations on the models. It was not a very agile way of going about things, I guess, as our approach had pretty much set the architecture in stone. Most of the complexity came in trying to model the relationship between nested comments. We ended up going with an ancestors table that joined the comments table on itself. Our comment model was a beast. Here's what it looked like:

  attr_accessible :article_id, :author_id, :body, :parent_comment_id

  validates :body, :author_id, :presence => true

  belongs_to :article, :inverse_of => :comments

  belongs_to :user

  belongs_to :parent_comment, :class_name => "Comment"

  has_many :child_comments, :class_name => "Comment", :foreign_key => :parent_comment_id

  has_many :comment_ancestors, :class_name => "CommentAncestry", :foreign_key => :descendant_id

  has_many :comment_descendants, :class_name => "CommentAncestry", :foreign_key => :ancestor_id

  has_many :ancestors, :through => :comment_ancestors

  has_many :descendants, :through => :comment_descendants

Crazy, huh? After that travail we proceeded to build the controllers, bake in authentication, and finally work on the views, with our first-ever implementation of nested forms. I introduced Eric to Twitter Bootstrap towards the end of the day, and we immediately made the site much prettier. I stayed a good bit of time after class completing the views, adding in validations, and refining the look.