RailsSpace: Building a Social Networking Website with Ruby on Rails

Reviewed September 9th, 2007 @ 12:57PM

[Book Cover] RailsSpace: Building a Social Networking Website with Ruby on Rails

RailsSpace: Building a Social Networking Website with Ruby on Rails by Michael Hartl and Aurelius Prochazka is part of the Addison-Wesley Professional Ruby Series and does an excellent job of teaching Ruby on Rails through a hands-on, real world application. If you are like me then you probably cringed at the thought of yet another social networking site. However, after reading through the first part to this book my apprehensions were put at ease. The authors explained in the opening chapter that “There’s a tension in any educational book between the two extremes of pure tutorial and pure reference. We land firmly on the tutorial side of this spectrum—“ The audience for the book is anyone beginning with Ruby on Rails. This book assumes no prior knowledge of Rails or Ruby, and sticks to that through the entire book. Each chapter walks you through the process of creating RailsSpace, while also teaching you best practices and some of the nuances of Ruby and the Rails framework.

This book is broken into two main parts, Foundations and Building a Social Network, with each part comprising several chapters each.


  • Getting Started

    With the introduction out of the way, it is time to jump into building the application. This chapter assists you in getting Ruby on Rails and its dependencies on your platform of choice, and then gives instruction for setting up your development environment. Once all of the pieces are in place they move to setting up your rails application, and how to get started with your first pages. They use rails generator to create the controllers and give you an idea of the default routing of a Rails application. The rest of the chapter spends some time building views and using embedded ruby to work with your templates. For the beginner to Ruby or Rails, this part is valuable for the rest of the application. They teach the basics of Ruby and introduce you to instance variables, hashes, and symbols. It isn’t practical for them to cover everything, so they also give you direction on finding answers to questions that might arise. The first place to look is always the API. We have the basics down, we have created our application, generated some controllers, and put our navigation into place.

  • Modeling users

    What good is a social networking site without any users? Here we are introduced to setting up our models in our application. This chapter touches on defining your schema through the use of migrations. You build the migration, run the migration, and then work within the model to create your validations. They spend some time with the validations and show you how to use the default helper methods or extend the validations to be more powerful and suit your needs. Now we have a place to store our users, lets move on to the process of letting them become part of the community.

  • Registering users

    This chapter focuses on the process needed to allow a user to register to RailsSpace. We are introduced to some more Rails magic as we build the User controller and the views. We start first with the view of the registration form and learn how to use Rails helpers to generate our form fields and error messages. Next we look at the action that handles the response to the user. This involves the validation, flash error messages, and flash notifications. With the registration in place, we take a pause to look at something very important in any software development: testing.

  • Getting started with testing

    Before we move any further we need to make sure things are responding as they should be. Testing things yourself may seem practical when the application is small, but as it expands testing proves to be extremely useful. We create tests for the database connection, our site controller, the registration process, and testing of the User model. Testing allows us to check all important aspects of our application. We can simulate the processes of a user and assure that we receive the proper response and that everything stays fine tuned. This chapter sets the foundation for the rest of the application as we expand and create new tests. We have tested everything is working as planned, now let’s handle the process of logging in.

  • Logging in and out

    Authenticating a user may seem simple at first glance, but there are often times steps that are overlooked in the process. This chapter attempts to cover all bases of making the login process painless. We learn how to setup the database for sessions and how to utilize them in our application. The sessions allow us to keep state of a user and their privileges. This also means that we need to protect our pages and some of our actions. They take the time to cover friendly URL forwarding, letting a user be directed back to any page after they login. Again, we run tests as we build more pieces onto the application. The end of the chapter is spent looking at the current code and refactoring to keep neat and tidy with the DRY principle. Just as with testing, this is also a very important part to the application and something the authors spend time doing with each and every piece of the application. We are also introduced to some more helpful Ruby nuances such as boolean methods and the bang! methods. A user has the ability to login, but we can take it one step further.

  • Advanced login

    Users now have the ability to login. It is time to extend the login by allowing the application to remember the user. This chapter is spent on building the remember me functionality. This involves extending several aspects including the User model, the user session, and the authentication cookie stored in the browser. Since we are updating different aspects we take the time to extend our tests, assure our previous tests still work, and refactor some more of the code that we are building.

  • Updating user information

    With login out of the way it is time to look at allowing users to interact with the website. The first part to this interaction is allowing them to update their details and information. This chapter discusses the process of allowing a user to change their email or update their password. The username is left untouched, as we will be creating a permalink with their username.

    Our foundation is set. We have come a long way in just a few chapters, now it is time to extend our solid foundation.

Building a Social Network

  • Personal profiles

    In the last chapter we allowed the user to update their email and password. Now we extend that to let the user create their own profile or spec. This allows a user to share all of their most intimate details one a single page. We look at building the user profile to be modular and utilize the same views for the public face and administrative face. We are introduced to some more rails helpers and some advanced routing techniques named routes. The user profile is in place, now it is time to create the pieces that allow all of your friends, teachers, aunts, and enemies to find you.

  • Community

    The next few chapters will be spent building the central hub that will allow you to interact with the community as a whole. The first part addresses setting up the Community controller and setting up sample data to test our features with. Our first piece to the community controller is allowing you to browse users by an alphabetical index. This shows us some more options of the find method in ActiveRecord and how we can implement pagination and a summary in our results. Browsing by an alphabetical index is helpful, but lets move on to allow search and browsing by A/S/L.

  • Searching and browsing

    Here we are introduced to plugins and using Ferret to help us with our search. As with the alphabetical listing we set it up to allow pagination within the results. We then setup a custom form to allow the user to search by age and sex. This utilizes the same views to return the results and allow pagination. Now we look at the location part. This is a little more advanced as it uses a GeoData database and a proximity search that allows you to find other users within a certain mileage of your current zip code. This concludes giving us all of the tools we need to find any information we need related to our users.

  • Avatars

    What good is a name without a face? This chapter discusses several new aspects. The first is using a model that doesn’t connect to a table in the database. The second is handling image uploads and resizing. We create the interface and allow for the user to upload, save, or delete their picture.

  • Email

    This chapter introduces us to Active Mailer, an aspect of Rails that allows us to send emails. We will setup a model that extends Active Mailer, configure our server to send email, and create the necessary links to allow users to contact their friends. We create a double-blind email system that allows the users to contact each other without exposing their actual email address. Naturally, we add the methods that allow you to correspond with the user. Once it is all in place, we take a look at some new testing methods that allow us to simulate the sending of emails without filling our inboxes.

  • Friendships

    Friendships live at the core of creating a social networking system. After all, the more friends you have the more popular you must be in real life! Again, we are introduced to some new modeling techniques in this chapter. In order for a user to be a friend with another user, we must create the relationship accordingly. This involves having a Friendship model that has the current user ID, and the friend ID. Using has_many :through we are able to recursively look through this table to keep track of the friendships and their statuses. As with everything else, we take the time at the end to test and refactor.

  • RESTful blogs

    This chapter throws an advanced topic our way, that of creating RESTful URLs for our application. There is much to be explained here, so I will avoid repetition. REST allows you to create neat URLs while also keeping your CRUD actions neat and tidy. This is important as we allow the users of our system to create blogs. Each user can have their own blog. Each blog can have many posts. Each post can have many comments (depending on how many friends you have). Using REST and map.resources to create our URLs we can utilize several Rails helper methods as well as give us a structure like http://www.example.com/user/name/blog/blog-title/blog-comments/. Though that may seem long and convoluted, it also allows us to utilize the power of the respond_to block to allow for RSS in each section without a lot of hassle.

    This is just a small glimpse at what this chapter covers in regards to REST. This proved to be one of the most useful chapters for me. Utilizing this power in rails also warrants some new testing functionality to check for. We test to make sure everything is working, then move to implementing some Ajax into our application.

  • Blog comments with Ajax

    We wouldn’t be very web 2.0 without Ajax. This chapter shows how to implement Ajax into our commenting system. We use both Ajax requests to submit the comments, and animation to toggle the display of the comment form. Rails comes with Prototype and Scriptaculous built in, so those libraries are used for the interaction. This is the only chapter that rubbed me the wrong way. I know that productivity is important, but I also don’t like the way that Rails implements JavaScript inline all over the place. I am in the camp of unobtrusive JavaScript, so this seems like going backwards to me. Sure, it is simple to implement with Rails helpers, but the output is simply horrendous. The chapter still has important aspects, I just feel they could be built in an unobtrusive manner, especially when you are using JavaScript to toggle the display of your comment form.

  • What next?

    This chapter focuses on deployment of our application and the options available to us. It also addresses the issues of scaling, both with hardware and software, and administrating your Rails application.

I may seem cynical about social networks, but this truly book pays attention to the small details. Building a social network is a great tutorial that covers many aspects of Rails and building your own application - no matter what it is. It has several callout boxes that give more explanation where it is needed. It discusses the importance of testing. It shows the importance of refactoring. All of this comes together to make a great reading experience and knowledge gained. If you are a Rails professional, there might not be a whole lot new for you, but if you are just beginning Rails this is an excellent full-blown tutorial. Even if you don’t want to create a social networking site, the foundation and principles set in this book will give you the knowledge needed to start building your own application.