Unfollowing Users

A few readers have also asked me to add an Unfollow button for the sample social network in Rails Crash Course. Here’s how I made that happen:

I created a new branch called unfollow-user and added the Unfollow button.

Here are the steps I followed:

  1. Update config/routes.rb to include a route for unfollow_user. Since this removes a row from the database, I used the DELETE HTTP verb.
  2. Add an unfollow! method to app/models/user.rb, similar to the follow! method.
  3. Add an unfollow action to app/controllers/users_controller.rb, similar to the follow action.
  4. Add a Unfollow button to the view at app/views/users/show.html.erb. I also added some logic to show the correct button.

The changes are in this commit: 29fa67a

Hope this helps!

Destroying Comments

A reader asked if I could add the destroy action to CommentsController for the sample blog in Rails Crash Course. The changes are summarized below.

I created a new branch called comments-destroy and then added the destroy action.

Here are the steps I followed:

  1. Update config/routes.rb to include a route for comments destroy
  2. Add a destroy method to app/controllers/comments_controller.rb
  3. Add a Destroy link to the comment partial at app/views/comments/_comment.html.erb

The changes are in this commit: f410496

Note this is the same as Exercise 3 at the end of Chapter 5. The answers for all exercises are in the back of the book.

Hope this helps!

No “Getting Started” Tonight

The Getting Started with Ruby on Rails workshop has been cancelled due to lack of signups. That’s a shame, I was really looking forward to this one. Obviously I didn’t do the best job of getting the word out about this event.

Let me know if you were also looking forward to it and I’ll see if I can set up another session in the future. Another alternative might be something like a screencast or Google Hangout.

Keep Talking

I’m giving the beginner talk at this month’s Austin on Rails meeting. Come to Capital Factory at 7:00pm on January 27 to learn about Active Record Associations. After my talk, Steve Madere is covering Hobo. Austin on Rails is always a lot of fun. The Rails community in Austin is great, there’s free pizza, and drinks and socialization after the meeting.

I’m also leading an evening workshop called Getting Started with Ruby on Rails for General Assembly on Monday, February 2 from 7:00pm – 9:00pm. General Assembly is new in Austin, but the company has been around since 2011. Today they teach classes all over the world.

This workshop covers the tools used by Ruby on Rails programmers, the basics of the Ruby programming language, and the components of Rails and how they work together. If you know the basics of web development, and are curious about building web apps with Rails, come spend the evening with me and see what Rails is all about.

Rails Crash Course

After way too many nights and weekends, and way too much iced coffee, it’s finally done…

Rails Crash Course Cover

Rails Crash Course is my new book on the Ruby on Rails web framework. This book is based on the curriculum I’ve used in the past to teach Ruby on Rails to both new programmers and experienced web developers.

The first section teaches the fundamentals of both Ruby and Rails. It covers the model-view-controller pattern used by Ruby on Rails in detail. At the end of the first section you learn how to set up a git repository for your application and deploy it Heroku.

The second section covers more advanced topics such as authentication, testing, performance optimization, security, and debugging. These concepts are explained as you build a simple social network app. It also covers creating your own Web API. The book concludes with a chapter on setting up your own Amazon EC2 server and deploying your application using Capistrano.

The book should ship around the middle of October (I already have my copies). You can preorder the book directly from No Starch Press or from Amazon.

Lone Star Ruby Conf 2013

Tickets are now on sale for the Lone Star Ruby Conference 2013 in Austin, TX from July 18-20. The speaker line-up this year looks amazing.

This will be my third year to attend and my second year to offer training. I am teaching two sessions on July 18.

My morning session is called From X to Ruby. It is designed for developers with experience in other languages who are looking to move to Ruby. I will cover the basics of Ruby syntax and idioms with an emphasis on things that are different from other languages.

My afternoon session is simply called Advanced Ruby. It is the perfect next step for people in my morning session, or anyone else who has some experience with Ruby, wanting to “level up” their skills. I will discuss Ruby’s object model, modules / mixins, and metaprogramming.

I’m looking forward to reconnecting with the community, both local and from around the world. If you’re at all interested in Ruby, I highly recommend this conference and I hope to see you there.

Active Record Demystified

I spoke at Austin on Rails back in February. I gave the “beginner” talk and attempted to explain some of the magic behind Active Record.

It’s about 27 minutes including a short Q&A. If you’re new to Rails, or just curious, check out the video below and let me know what you think.

Many thanks to AustinTechVideos for recording my talk and making it available.

Upcoming Events

It’s a great time to be a Rubyist in Austin. There are several upcoming events that I’m looking forward to attending.

First, I’m giving a talk on Rails Application Security at the Austin on Rails meeting tomorrow evening. The meeting will also feature lightning talks covering a variety of beginner topics. Be sure to get there early.

Next, the second session of my GeekAustin Beginning Rails class starts August 4. The last class went really well and I’m looking forward to teaching it again. There are still seats available. For full details and to sign up, see the EventBright page at http://geekaustinrailsclass.eventbrite.com/.

Then, the Lone Star Ruby Conf starts on August 11 with a day of training. Followed by the conference proper on August 12 and 13. The keynote speakers and session topics are all outstanding this year. I am not speaking (this year), but I plan to be an active participant. Hopefully I’ll see you around town.

Your First Rails 3 Plugin

On several different projects I have needed to find the newest and oldest record in certain models. The code to do this is pretty simple (especially in Rails 3).

For example, here is a snippet to find the newest Post:

@post = Post.order('created_at DESC').first

We can make this even better by defining a method in the Post class like this:

def newest
  order('created_at DESC').first

With this new method our code becomes:

@post = Post.newest

But now we’re faced with having to add that method to lots of different models. This sounds like a perfect job for a simple Rails 3 plugin.

It’s Just a Gem

Plugins in Rails 3 are created just like any other Ruby gem. You can use whatever you like to create a new gem. Currently, I’m using Bundler:

bundle gem date_filter

This will create several files for you. The most important are the gemspec file and the contents of the lib directory.

The gemspec

Your gemspec file tells the world about your gem. The first thing you’ll want to do is edit this file and fill in the information marked with TODO – your name, e-mail address, gem summary, and gem description.

The rest of the file should take care of itself. Note that the gem version is stored in date_filter/version.rb. Also, the list of files, test files, and executables is filled in automatically with git commands.

The lib directory

Inside the lib directory you’ll find a file called date_filter.rb and a directory called date_filter. A common practice is to keep the contents of date_filter.rb pretty minimal.

Most of your actual code should go in separate files inside the date_filter
directory. For example, here is my date_filter.rb file in its entirety:

require 'active_record'
require File.expand_path('../date_filter/base', __FILE__)

ActiveRecord::Base.class_eval { include DateFilter::Base }

Note that I am requiring ActiveRecord here. This is based on wycats advice – If You Override Something, Require It

Next I require base.rb inside the date_filter directory. This contains the source for the plugin.

The last line actually includes my code into ActiveRecord::Base. Since I am adding class methods, I use class_eval.


Finally, here is the code for the plugin. It’s common practice to separate class methods from instance methods in Rails plugins. In this case I have a separate module for the class methods.

When DateFilter::Base is included into ActiveRecord::Base the method included is called. This method then extends ActiveRecord::Base with the methods in the ClassMethods module.

module DateFilter
  module Base
    def self.included(base)
      base.send :extend, ClassMethods

    module ClassMethods
      def newest
        order('created_at DESC').first

      def oldest
        order('created_at ASC').first

Building and Installing

If you made it this far, you’re ready to build and install your new plugin. Bundler includes some rake tasks to help with this
automatically. You can see these by running rake -T

rake build
rake install
rake release

rake build will create a directory called pkg and build your new gem into this directory. You can then install it with the gem command.

rake install will build and install your new gem. To use it in a Rails project, you will need to add it to your Gemfile and run bundle install.


If you have an account at RubyGems.org you can also release your new gem. Check your profile page for your API key. Include your API key in ~/.gem/credentials as instructed, then run rake release to build and upload your gem to the site.

This should get you started building your own Rails 3 plugins. There are still a couple of pretty important things missing from this process – tests and documentation. I plan to cover both of these in a future post.

The complete source for this plugin is up at github. The gem is also available at RubyGems.org.