w3d6-w3d7

Question 1

What is a callback?

Answer 1

Code that is run at a certain moment of an object’s life cycle (i.e. at creation, updating, deletion, etc.)

Question 2

In an association, what happens to objects that belong to another object when the object they belong to is destroyed (read: the object the foreign key points to is destroyed)?

Answer 2

The objects are considered widowed.

Question 3

Explain the following code:

class User < ActiveRecord::Base
has_many :posts, :dependent => :destroy
end

Answer 3

When a User is destroyed, the posts that belong to it are destroyed as well.

Question 4

Where is :dependent added?

Answer 4

In has_many relations.

Question 5

What are some other options for :dependent?

Answer 5

:nullify

Sets the foreign key to null when its target is destroyed.

Question 6

How do we guarantee referential integrity?

Answer 6

Add a FOREIGN KEY constraint at the db level.

Question 7

Explain the following code:

class User  true
  before_validation :ensure_random_code

  protected
  def ensure_random_code
    # assign a random code
    self.random_code ||= SecureRandom.hex(8)
  end
end

Answer 7

This is an example of callback registration: the random code attribute is added in case it is forgotten as part of the object’s validation.

Question 8

What is an important property of callback methods?

Answer 8

They should be protected or private.

Question 9

What are some useful ActiveRecord callbacks?

Answer 9

before_validation (handy as a last chance to set forgotten fields upon creation, not saving/updating)
• after_create (handy to do some post-create logic, like send a confirmation email)
• after_destroy (handy to perform post-destroy clean-up logic)

Question 10

Explain the following code:

before_validation(:on => :create) do
self.number = number.gsub(/[^0-9]/, “”) if attribute_present?(“number”)
end

Answer 10

Strip everything but digits, so the user can specify “555 234 34” or
“5552-3434” or both will mean “55523434”

Question 11

What is wrong with the following ERB:

Answer 11

The Law of Demeter is being violated; objects are talking to objects besides their neighbors/more than one dot is being used.

Question 12

What does #delegate do and what options does it take?

Answer 12

delegate allows getter methods to be generated for other classes in associations, so that multiple dots are no longer needed. prefix: true can be specified so that sensible prefixes can be given to these getter methods.

Question 13

Assuming we have an office, doctor, and patient, what code would make the following ERB viable:

Answer 13

class Office < ActiveRecord::Base
  belongs_to :doctor
end

class Doctor < ActiveRecord::Base
  has_one :office
  has_many :patients
  delegate :number,
           :address,
           to: :office,
           prefix: true
end

class Patient < ActiveRecord::Base
  belongs_to :doctor
  delegate :name, 
           :specialty,
           :office_number, 
           :office_address, 
           to: :doctor, 
           prefix: true
end

Question 14

T/F: It does not matter what kind of SQL db you’re using; Rails migrations are db agnostic and will work with all of them.

Answer 14

T

Question 15

What is the first thing that happens when a server running Rails gets a request from a web browser?

Answer 15

It first goes to the Rails router.

Question 16

What does the Rails router do?

Answer 16

The router decides what the request is trying to do based on its address and other HTTP parameters.

Question 17

What is the command to see all available routes in a Rails app?

Answer 17

rake routes

Question 18

Explain the output of rake routes:

Prefix Verb URI Pattern Controller#Actionarticles GET /articles(.:format) articles#index

Answer 18

The prefix, articles, provides articles_path (the relative path) and articles_url (the full http address) as Rails methods.

The verb, GET, is the HTTP verb.

The URI pattern is like a regex in that is specifies what is given to the controller with that name (articles can take /articles/, /articles.json, etc.)

The final column is where the route maps to the controller method.

Question 19

What is special about instance variables in Rails controllers?

Answer 19

They are automatically transferred from the controller to the object which renders the view template.

Question 20

What are the arguments given to the #link_to helper?

Answer 20

The displayed text of the link, and the URL of the link (typically _path or _url macro)

Question 21

What is a synonym for a controller action?

Answer 21

A controller method.

Question 22

What action is typically used to render a view?

Answer 22

show

Question 23

Where are URL parameters stored?

Answer 23

In the ‘params’ hash

Question 24

What is the basic reason to add forms to a page?

Answer 24

To create a viable method for users to interact with the web and, by proxy, the db.

Question 25

What does #form_for do?

Answer 25

This Rails helper takes an iv param, an object, and that object can be put in a do loop for each element the user needs to input.

Question 26

Views can reference instance variables. Where are these instance variables declared?

Answer 26

In the corresponding controller method.

Question 27

What is one way to inspect the params hash?

Answer 27

Put a fail/raise statement into the controller action which is called ath the point where you want to inspect.

Question 28

What is the point of having strong parameters?

Answer 28

They prevent us from blindly accepting the entirety of the params hash as a parameter to creating an object. What if it included malicious code?

Question 29

How can we use #require to to enforce strong parameters?

Answer 29

Use it in a helper to declare, along with #permit, which parts of the params hash you want to use:

def article_params
params.require(:article).permit(:title, :body)
end

Question 30

What is the naming convention for partials?

Answer 30

Begin the filename with an underscore:

app/views/articles/_form.html.erb

Question 31

What is a flash and how can we add one to an action?

Answer 31

A flash is a message to let a user know that something has taken place:

flash.notice = “Article ‘#{@article.title}’ Updated!”