Review: Scaffolding

$ rails new twitter
$ cd twitter
$ rails generate scaffold Tweet body:string handle:string
$ rake db:migrate
$ rails s

Review: Views

• Rails views are like advanced HTML files
• You can write any (valid) HTML you wish to use, but you can also use Ruby to generate HTML code dynamically (e.g. with loops)
• Standard Rails views end with the .html.erb extension instead
• The .erb stands for 'evaluated Ruby'. This means they can have both HTML and Ruby inside them

Review: View Helper Methods

• Views have access to special helper methods, that are only accessible inside views
• Examples include link_to, image_tag
• These are simple methods (like puts), but they are designed only for Rails views, and usually used to generate HTML tags
• You can write your own Helper Methods for Rails views to simplify your Ruby code inside views.

Layouts

• Layouts are html.erb files that serve as a wrapper for all rendered pages
• You can place content that is common to all pages in them, such as HTML and HEAD tags, as well as headers and footers for your web site layout.
• Rails apps ship with a default layout, found in layouts/application.html.erb

Code-Along

Let's update our Twitter app to use the application layout for a header and footer.

Views: Common Helper Methods

• image_tag (generate an img tag)
• link_to (generate an a tag)
• mail_to (generate an a tag to send email)

Creating a new Resource

with form_for

• form_for is a Rails view helper tag to help easily generate forms
• It takes as an argument the instance variable for the resource you are creating or editing
• It gives you a "form variable", which you can then invoke all the form methods on to easily generate form fields

TODO: Teach form fields and how they map to DB column types.

Code-Along

Let's scaffold a User resource with additional fields.

Solution: github.com/iExperience/twitter

Partials

• Partials are "small views" that are shared between multiple views
• They end in .html.erb just like views, but they begin with _ (e.g. _form.html.erb)
• Partials can be included into another view by using the command render :partial => 'form'. The extension of the file is optional.
• Even shorter syntax for partials: render 'form'. This assumes the file is in the same folder as the View that is including it.

RECAP

• We can use view helpers to generate HTML tags
• We can use layouts to reuse code across all pages
• We can use forms to generate forms and form fields
• We can use partials to share view code between views

EXERCISES

http://iexperience.github.io/exercises/6A.html

-- TODO: Move to 8A

--

Controllers & Routes

Review: Models

• Application data is stored in a database
• Working with databases is hard, so we use Models to simplify the work
• ActiveRecord provides us with methods to easily work with the database
• We can use rails console as an enhanced IRB environment that includes our Rails app classes

IN views/tweets/index.html.erb

Where does @tweets come from?

• We know it is an array of Tweet instances
• We know Tweet instance responds to methods for its attributes (e.g. .body and .handle)
• We still don't know how @tweets gets initialized...

Controllers

• Controllers talk to the database, and pass data to the views
• They use Models to talk to the database
• They use instance variables to pass data to the views
• Controllers are custom Ruby classes that inherit from ApplicationController, just like how Models are custom classes that inherit from ActiveRecord::Base

Controller for each Resource

• The same way we have a Model for each resource, we have a Controller for each resource
• For the tweets resource, we have a Tweet model class, and a TweetsController controller class
• For the users resource, we have a User model class, and a UsersController controller class
• Note the plurality on models (singular) and controllers (plural)

How does it all fit together?

URL -> Controller -> Method

• When you visit /tweets, it instantiates the TweetsController class and calls the index method on it
• When you visit /tweets/new, it instantiates the TweetsController and calls the new method on it
• When you visit /users/1/edit, it instantiates the UsersController and calls the edit method on it

Actions

Inside a Controller class, the methods (e.g. index and new) are referred to as actions.

Code-Along

Let's take a look at the code inside app/controllers to get a better sense of what Controller code looks like.

The Map

Routes

• These mappings of a particular URL pattern onto a particular Controller and Action are known as routes
• Routes are how users access your applications (think of them as gateways into your database)
• Eventually, these mappings will become second nature
• In the meantime, you can use a command in your terminal to see all the routes:

$ rake routes

rake routes

$ rake routes
    Prefix Verb   URI Pattern                Controller#Action
    tweets GET    /tweets(.:format)          tweets#index
           POST   /tweets(.:format)          tweets#create
 new_tweet GET    /tweets/new(.:format)      tweets#new
edit_tweet GET    /tweets/:id/edit(.:format) tweets#edit
     tweet GET    /tweets/:id(.:format)      tweets#show
           PATCH  /tweets/:id(.:format)      tweets#update
           PUT    /tweets/:id(.:format)      tweets#update
           DELETE /tweets/:id(.:format)      tweets#destroy

Q. So, where did all these 'routes' come from?

A. Rails Scaffolding created them for you, in the routes.rb file. A set of routes were created for each resource.

routes.rb

Rails.application.routes.draw do

  resources :tweets

  resources :users

end

routes.rb

• In the routes.rb file, the resources method allows you to create a collection of routes in one line
• Just by typing resources :tweets, Rails will create all of the routes associated with the tweets resource (e.g. everything we saw in the rake routes output)
• The resources method is the simplest way to create a set of CRUD routes for a given resource
• When you scaffold a resource, it places the resources declaration for the resource in the routes.rb file automatically

The Complete Picture

RECAP

• The collection of Model instances (e.g. @tweets) is populated into views by Controllers
• Controllers are custom classes that inherit from ApplicationController
• Routes are the mechanism through which a given url (e.g. /tweets) invokes a particular method (e.g. index) in a controller (e.g. TweetsController)
• Routes are declared in the routes.rb file, using the simple resources method.

Code-Along

Let's modify the Twitter app to change the @tweets data set in the Controller before it passes it along to the view.

Solution: github.com/iExperience/twitter

EXERCISES

http://iexperience.github.io/exercises/7A.html