Overview
This is part 2 of HostMySite's tutorial for building a blog in Rails. Please go through
part 1 and
part 2 before you start this section. In this section, we're going to add the ability to put our blog posts into categories. In the course of doing this we'll learn some more advanced Rails features
Create Categories
We need to start by generating some scaffolding around our categories table that we created at the beginning of the tutorial, using the following command:
../script/generate scaffold category
Once this is done you should be able to browse to the controller,
http://[domain]/blog/categories/ and create a few example categories - give them whatever name/descriptions you'd like. Get at least 4-5 of them
Model
Now we're going to introduce an awesome new database relationship:
HABTM!. That stands for "has and belongs to many" and is a perfect fit for what we want to do here. Basically we need to link two tables:
posts, which each have an id, and
categories, which each have an id. However neither has a direct link to the other - they can't, because each post can have more than one category, and each category can be assigned to many posts. To get around this we've got a third table:
categories_posts - this table has entries with both a category_id and a post_id. We'll use it to find which categories belong to which posts. And with Rails, that's easy
Open up the
posts model,
models/post.rb and add the following text:
| has_and_belongs_to_many :categories |
And now open the
categories model,
models/category.rb, and setup the link the other way:
| has_and_belongs_to_many :posts |
Simple as that - Rails figures out that our join table will be called
categories_posts by combining the names of the two existing tables(in alphabetical order) and now when we load a post, the associated categories will be loaded for us right along with it. Even more amazing, if we go back later and delete a category or post, Rails will automatically delete any associated records out of our join table - cleaning up for us
Controller
A very quick edit for the controller(
controllers/posts_controller.rb) as well. Simply add this line to our
new and
edit methods:
| @categories = Category.find(:all) |
Doing this loads the full list of categories into a variable which we can use in the
new and
edit views - this will let us build a form field to allow users to select their post's categories
View
Almost done, but now we need to write a bit of more complicated code. Open up
views/posts/_form.rhtml. We need to add a form field to allow people to select a category or categories. It needs to be a multi-select field to allow multiple selections. Here's the code we'll use:
<% unless @categories.empty? %>
<%= link_to 'Category', {:controller => 'categories' } %><br/>
<select name="post[category_ids][]" multiple="multiple">
<option></option>
<%= options_from_collection_for_select( @categories, :id, :name) %><br/><br/>
</select>
<% end %>
|
A few things worth explaining here:
* the field name,
post[category_ids][] is important - we specified category_ids because of the special circumstance of this being a
HABTM relationship
* we're using options_from_collection_for_select - passing it the object to build the list from, the id/name fields
----
Now in list view,
views/posts/list.rhtml, we're going to add the following code under
<%= nl2br(post.post) %>:
| <%= render :partial => 'category', :locals => { :categories => post.categories } %> |
We're using another partial, because we want to be able to display these categories in both the
list and
show views. Let's add the same code to the
show view now too - you'll just need to change
post.categories to
@post.categories because of the way our variables are set in the two different views
Now we can create the partial,
views/posts/_category.rhtml, with the following code:
<% unless categories.empty? %>
<br/><br/><i>Categories:
<%= @cats = ""
categories.each {|cat| @cats += link_to (cat.name, :controller => 'categories', :action => 'show', :id => cat.id) + ", " }
@cats.chomp(", ") # returned to the browser because it's the last item in this section
%>
</i>
<% end %>
|
The code says: if
post.categories isn't empty(i.e. if this post does have assigned categories), toss in some line breaks and a description. Then, we'll create an empty string [i]@cats[i], and loop through the [i]post.categories[i] array, giving each element the temporary name of [i]cat[i], and feeding it into a code block. Within the code block we'll concatenate @cats onto itself plus a link to the current category, and separate each name with a comma. Then at the very end, use [i]chomp[i] to yank off the trailing comma, and @cats is then displayed
----
You can now go back to your posts and add categories to any of your existing posts(or a new one). Also, if you have a post with existing categories and you edit it, the already set categories will be pre-selected in the form
Progress
So, we've put together a simple blog application: customized our layout, allowed user comments, added input validation, given users the ability to manage categories and categorize their posts...it's quite a lot. It may feel like it's been a good amount of coding as well, but let's see if that's true. Run the command:
rake stats
At the bottom of the output you'll see a tally of the total amount of code(and this includes scaffold code that Rails generated for us). Mine is:
Code LOC: 122. This isn't going to count our code in views, but we can get an idea of that too with this command:
cat views/posts/* | grep "<%" | wc -l
Total there is 53, and for many of these lines, calling them "code" is generous - we're basically just outputting variables. Regardless, our total is 175 lines - incredible given how much we've already implemented. And much of this code we didn't even write - Rails generated it for us
