Getting Started with Ruby on Rails

Now we can start to take a look at Rails. In this lecture, I will provide a quick reminder of the details of the MVC architecture, show some basics of using embedded Ruby to generate content for View files and finally use Rails' generated links to navigate between pages.

An archive of the complete project that was created for this lecture can be found in the supplementary material. I do strongly recommend taking the trouble to type up the code for the project by hand first, but you may find the archive useful to refer to if you have any problems.

This lecture introduces the larger sample application that we will use for the remainder of the course. We will explore rails routes a little more, and then introduce the layout file that fleshes view files out into complete html documents. Finally, we will introduce helpers, that can be used to customise view files.

In this lecture, we will introduce the use of Rails' "partials" to capture small reusable chunks of html content. Specifically, we will use partials to capture the header, footer and nav bar for our website.

We will also take another look at our routes, and introduce the Rails "link_to" method.

There are two broad choices for a Rails development environment. Many prefer the lightweight command line plus programmer's editor route. The alternative is to use a full fledged IDE. I will talk about both in this lecture.

I will also briefly cover the options for backend database.

Having developed well specified and tested code, you will now want to maintain it in a carefully managed repository,won't you! In this lecture we will review the fundamentals behind the distributed version control system Git, and show you how to set up a remote repository in GitHub.

We will replace the static Events page with a dynamically generated index of Events in this lecture. This will introduce you to Rails' Active Record. This manages the Object-Relational mapping that takes care of the relationship between a Rails model at its persistent representation in the database. We will use a scaffold generator to produce the: events controller; all the views that correspond to actions in the controller; an update to the routes.rb file; the database migration; and, of course, the Event.rb class for the model itself.

We have generated a model with a CRUD interface so that users may add and update events. But we also need to ensure that all the data that must be provided before an event is saved, is indeed provided - and in the correct format. For that we use Rails Validations. Even more importantly, we need to ensure that only authorised users change data. We introduce Ruby's Action Callbacks and then use these to place an authentication layer on those actions whose access needs to be controlled. Rather than code up authentication from scratch, we will use the Devise gem. This will also introduce you to the use of Ruby Gems.

Building Associations between classes is so easy in Rails. This lecture demonstrates how we can use Active Record to build a one-to-many association between two classes in a model. We also show how to ensure that dependent objects are destroyed automatically when a parent object is destroyed.

We left the sample application with a couple of issues. Firstly, the foreign key for the event that is associated with a comment needed to be added manually. In this lecture we will see how to automatically pass the foreign key to the comments controller. Secondly, the comments are on a different page to the associated event. We will move the comments for a specific event to that event's Show page. Finally, we will use some jQuery magic to hide and reveal the comments list without page refresh. This will provide an introduction to the use of jQuery and unobtrusive JavaScript.

You will find a zip file containing the complete code for the project so far under the Resources section. This should have all the links correctly setup as per the discussions around this lecture, but do send me a message if I have missed anything.

As we build up content in this Chapter, we will also start to style our sample web application. Before we commit to styling we need to pull together a Boilerplate of best practice to handle cross-browser compatibilities and other known issues to ensure our application has a consistent look and feel.

We will gain more experience of using the new HTML5 elements in this lecture. They will help us provide meaningful structure to the pages in our application. In addition, we will start to bring in some basic styling with CSS.

CSS can do magic, but it also does a lot of things badly.

Sassy CSS sorts out the issues properly and makes CSS truly DRY. We will first introduce Sprockets - a general purpose tool for managing asset pipelines. Then we will show how SCSS enables you to define and structure your styling assets much more effectively than was possible with vanilla CSS.

In keeping with its maxim of "Convention over configuration", Rails includes support for designing/generating "RESTful" APIs. In this chapter, we will review the basics of routing in Rails, and then discuss how the concepts of REST (Representational State Transfer) are used in Rails.

This lecture looks in detail at the mappings from Routes to Controller Actions that are automatically generated for you when you declare a Resource in Rails. As well as simplifying the navigation through your application, it also automatically generates a public facing RESTful API for you. We will show how to make this API respond to requests for different representations of a resource.

Ruby Gems enable you to extend Rails Core with best practice solutions for many of the common programming problems that are found when building Rails Apps. These are easy to plug into your project and offer mature and stable enhancements. We will explore some of the best in more detail in the remainder of the lectures in this chapter.

These two gems offer complementary functionality. CarrierWave supports upload of media files into a Web Application. RMagick provides some extremely useful image processing capability. We will see how these two gems can work together to enable us to add the capability to upload image files, and have them automatically resized into versions that are suitable for different uses in our Sample Application.

I give a quick summary of where we are, and then provide some pointers to sources of material for continuing the adventure.

If you are ready to take a more intensive web development course, Bloc offers a Developer Apprenticeship. You can save $100 on enrollment with the coupon code "learnrails".

How Bloc Works:

• Continuous coaching: Meet 3 times per week, one-on-one, with a Bloc mentor vested in your success.
• Intensive: Bloc is a results-focused program with a 25 hour/week commitment.
• Real-World projects: You'll build clones of Reddit, Wikipedia, Kissmetrics, and Google Reader and learn industry standard tools.
• Jump-start your passion project: As your final capstone project, you'll build your own Ruby on Rails website from scratch with your mentor's help.

This lecture covers more detail about Git. While much of the focus is on the use of Git's capability for using branches, a number of other important features are introduced. Once you have gone through this lecture you should have enough information to both work on your own projects and contribute to a shared project.

We show off ActiveRecord::Live with a simple application for streaming data from the server into a client view. We start off with the simplest of examples but gradually refine this into a comprehensive end-to-end example that captures all the key technology you need to stream data into a Rails View. There is a lot of new stuff in this lecture: JavaScript; jQuery; Server-Sent Events. I will introduce these, but we will go into them all in more depth as we progress through the advanced material.

The two key lessons of this lecture are:

1. Follow the HTML5 recommendation of declaring your document as using the UTF-8 Unicode encoding scheme;
2. Once you have done that, eliminate (as far as is possible) character references.

http://www.unicode.org/charts/