Steaming Up The Engine for The Rails

I’ve been digging through and playing with the Rails Framework now for about 4 months with intent (I guess I’ve read about it, learned about, but not played with it for well over 4 years). I’ve gained a pretty good familiarity with the parts of the framework. Below, I’ve laid out some of the key things that I’ve done over and over just to become familiar with the commands, organization, and other elements within the framework. These also, in this specific order, is what I’ve found works best for getting a Ruby on Rails Application Project kick started (on a *nix based machine, the rvm commands will however not work on Windows, you’ll need to find a respective replacement).

[sourcecode language=”bash”]
$ mkdir steaming_up_the_engine
$ cd steaming_up_the_engine
$ rvm –rvmrc –create 1.9.2@steaming_up_the_engine
$ cd ..
$ cd steaming_up_the_engine
$ cd ..
$ rails new steaming_up_the_engine -T
$ open .
$ cd steaming_up_the_engine
$ git init
$ mate .gitignore
…edit and save the .gitignore file with whatever additions you may need or want…
[sourcecode language=”bash”]
$ git -A
$ git commit -m ‘first commit.’
$ rm public/index.html
$ rails generate rspec:install
…edit your Gemfile(See below Gemfile for contents)…
[sourcecode language=”bash”]
$ rails generate controller home index contact about
$ git rm -r spec/views
$ git rm -r spec/helpers
$ mate config/routes.rb

…edit the routes.rb so there is the index page handling the root page…

Gemfile (Located in ~/projectRoot/Gemfile)

[sourcecode language=”ruby”]
source ‘’

gem ‘rails’
gem ‘sqlite3’

group :development do
gem ‘rspec-rails’

group :test do
gem ‘rspec-rails’
gem ‘webrat’

group :assets do
gem ‘sass-rails’, ‘~> 3.1.4’
gem ‘coffee-rails’, ‘~> 3.1.1’
gem ‘uglifier’, ‘>= 1.0.3’

gem ‘jquery-rails’

route.rb file.

[sourcecode language=”ruby”]
SteamingUpTheEngine::Application.routes.draw do
get "home/index"
get "home/about"
get "home/contact"
root :to => ‘home#index’

mkdir creates a new directory called steaming_up_the_engine.

cd steaming_up_the_engine moves the active working directory of the terminal/bash to steaming_up_the_engine (i.e. cd stands for change directory).

rvm is the rvm application command, –rvmrc is the feature being created, –create is the command to issue on the feature.  1.9.2 is the version of Ruby that will be used for the project and the name after the @ is the name of the project itself. For more information about the rvmrc script check out my previous entry or the rvm site on rvmrc.

The action to cd .. moves out of the directory and then cd steaming_up_the_engine moves back in to initiate the script that the rvm command created for us. After that, the working directory is moved back outside of the application folder.

rails is simply the rails framework application command, new tells the application to create a new rails application based on the framework, and -T is a switch to prevent any tests from being generated.

open . actually opens the Finder to view the just created project in the working directory. The screenshot below is the Finder with the newly created rails app.

Finder showing the newly created Rails Application in a column display.
Finder showing the newly created Rails Application in a column display.

Again move back into the application working directory.

git init initializes a local git repository for the project.

mate .gitignore opens up the .gitignore file that was created by the rails command for editing.  mate is the command for the TextMate Application. If you don’t have TextMate, then you would have to change mate to a command that relates to whatever you use to edit your code files. Check out my previous blog entry for a sample .gitignore file.

git -A adds all new files for commit to the local git repository.

git commit -m ‘first commit’ actually commits the new project to the git repository.

rm public/index.html removes the default static page that displays if the application is run at this point. I never need it, but it does come in handy sometimes if you’re troubleshooting if a server runs and just want to deploy something to verify you’re doing it right (such as to EngineYard or Heroku).

rspec can be setup and configured to run in your Rails project with the rails command rails generate rspec:install. If the rspec gem isn’t already in your project, remember to gem install rspec or add it to the gemfile and run bundle install.

The first of these commands that actually starts building the site is the rails generator command. rails generate controller Pages home contact creates the pages, controllers, and routes for the pages. Because the rspec has been configured for the project, when rails generates the controller and pages tests will be created in the spec directory.

After the creation of those pages remove the unnecessary test files in helpers and views under spec. git rm -r spec/views and git rm -r spec/helpers will get rid of these files.

Now you’re ready to really get started actually building something in those pages. Enjoy!

Ruby on Rails Hittin’ The Big Time, A Friday PSA

How do you know that Ruby on Rails has already hit the big time?  Not that it needs anymore proof that it is absolutely one of the MAJOR platforms available right now…

  1. Recruiters now regularly come to user groups & offer to “buy the beer” afterwards.
  2. The split of job searches on sites now easily come up with dozens upon dozens of Ruby on Rails Jobs.
  3. Enterprise & Other Managers are commonly asking what the “Ruby on Rails Dev Base” looks like.  In other words, they want to know who and how many people they can hire.
Anyway that you look, you’ll see Ruby on Rails making inroads at a company near you! Keep your eyes peeled, and if you aren’t polyglot now, you might want to start thinking about it.
Cheers!  Happy disruptive markets to you!  😀

Keeping Your Rails Projects Organized Right!

I’ve been working with Rails now for about 3 months. At first I jumped right in like a bull in a china shop. I have since, suffered the frustration of doing so. I’ve experimented on OS-X, Windows, and Linux (primarily the Ubuntu Distro). Among these three operating systems, getting up and running with rails is a breeze. Sure, I’ve wrecked more than a few apps I started, blown to smithereens a few machine images, and been generally destructive – but that’s not a bad way to learn at all. 😉

Through this trundling, I’ve come to find there are a few things that should be reviewed and learned thoroughly before smashing into the china shop (i.e. rails or Ruby for that matter). One of these tools is RVM. Another is Git. These tools, without doubt or question, you MUST LEARN! There is just too much value in both of these tools to try to ignore either one. First a quick description of each:

Git – Git is a source control server and respective client software.
RVM – Ruby enVironment Manager – RVM, sometimes referred to as the Ruby Version Manager also, is a way to maintain the various gems and other environment settings that are used for a particular project. It enables switching back and forth between versions of ruby, keeping ruby updated, and much much more.  In .NET, think of it as choosing which version of .NET to use, except with more power to go beyond just merely choosing which version. These two tools are pivotal in having a smooth, consistent, and understandable workflow. There is one other issue for Windows users here though, RVM does not and will not ever run on Windows. One can however install cygwin to get it running or they can use Pik.


Below I have a short workflow tutorial, which I’ve broken out to getting started, working, and operational.

Getting Started

This is the first stage of any development project. Regardless of using PHP, Rails, .NET, Java, or whatever, there are certain things that need done. The key elements that I’ve found over the years include, not in any particular order;

  • Setup source control
  • Setup your environment
  • Start your basic project
After each of these things are done, and working together properly, it’s time to get coding. 🙂  First, setup a directory that will be the home for the entire project.

[sourcecode language=”bash”]
$ mkdir sampleWorkflow

Next run the command to setup your environment for this specific project.

[sourcecode language=”bash”]
$ rvm –rvmrc –create 1.9.2@sampleWorkflow
$ cd ..
$ cd sampleWorkflow/
= RVM has encountered a new or modified .rvmrc file in the current directory =
= This is a shell script and therefore may contain any shell commands. =
= =
= Examine the contents of this file carefully to be sure the contents are =
= safe before trusting it! ( Choose v[iew] below to view the contents ) =
Do you wish to trust this .rvmrc file? (/Users/adron/a_code/sampleWorkflow/.rvmrc)
y[es], n[o], v[iew], c[ancel]> yes
$ ruby -v
ruby 1.9.2p290 (2011-07-09 revision 32553) [x86_64-darwin10.8.0]

In the command above, rvm being the application, –rvmrc the parameter for what is being done, and –create is the command for the action to be taken. The 1.9.2 before the @ is the Ruby version and the value after the @ is the environment name, in this case being the same as the folder.

Once the command is run, move out and back into the folder to view how the rvmrc file will work. When you navigate into the directory again, the script will run, initiating the environment for Ruby 1.9.2. It will also ask to confirm if you trust the file. Running the ruby -v command to determine the version, will now display the active ruby version for this folder.

If you’re only using one version of Ruby, this might not seem that useful. But over time as you work with multiple projects, you will often find that different projects use different versions of Ruby. Sometimes 1.8.7 or jruby or rubinius. If that’s the case, rvm is a life saver in simplifying and keeping environments neatly organized.

Now that the environment is setup, we’ll need source control setup and as I generally prefer, an initial commit. Make sure to move into the directory that was just created. Issue the following git commands.

[sourcecode language=”bash”]
$ git init
Initialized empty Git repository in /Users/adron/a_code/sampleWorkflow/.git/

With our directory now intialized for git, it is best to get a git .gitignore file created. (I know, that’s a lot of get gittin). Use mate, or whatever your editor is you prefer, and create a .gitignore file.

[sourcecode language=”bash”]
$ mate .gitignore

At this point you’ll want to add something to the ignore file. I always start with the following basic files and folders to ignore. I’ve also written a short entry on what these files and folders are that I’m ignoring in the post Gotta Get Git.

[sourcecode language=”bash”]
#OS junk files

#Webstorm & Rubymine files

#Rails Heroku and other bits to ignore

Once that is entered, save the file and close. Next we’ll do our first commit. This is always a good practice, then there are no accidental commits of files that aren’t needed. Also note, I did not exclude the rvmrc file, this is needed to insure clarity about the environment when cloning the repository in the future.

[sourcecode language=”bash”]
$ git add -A
$ git commit -m ‘first commit’
[master (root-commit) ea81bed] first commit
3 files changed, 131 insertions(+), 0 deletions(-)
create mode 100644 .gitignore
create mode 100644 .rvmrc
create mode 100644 .rvmrc.10.29.2011-11:33:32

Now that this is recorded in source control history (not of course in the main repo, we’ll do that in a second) I like to go ahead and create the rails application. Move to a directory just below where the ‘sampleWorkflow’ directory is and create a rails application named the same thing. Since we already created the .gitignore file, we’ll be prompted to overwrite, which isn’t needed since the .gitignore is already setup correctly.

[sourcecode language=”bash”]
$ ls
sampleWorkflow someOtherAppOrSomething
$ rails new sampleWorkflow
create README
create Rakefile
conflict .gitignore
Overwrite /Users/adron/a_code/sampleWorkflow/.gitignore? (enter "h" for help) [Ynaqdh] n
skip .gitignore
create Gemfile
create app
create app/assets/images/rails.png
create app/assets/javascripts/application.js
create app/assets/stylesheets/application.css

…more stuff shows up…

[sourcecode language=”bash”]
create tmp/cache
create tmp/cache/assets
create vendor/assets/stylesheets
create vendor/assets/stylesheets/.gitkeep
create vendor/plugins
create vendor/plugins/.gitkeep
run bundle install
Fetching source index for
Using rake (
Using multi_json (1.0.3)
Using activesupport (3.1.1)
Using builder (3.0.0)
Using i18n (0.6.0)
Using activemodel (3.1.1)
Using erubis (2.7.0)

…more stuff shows up…

[sourcecode language=”bash”]
Using railties (3.1.1)
Using coffee-rails (3.1.1)
Using jquery-rails (1.0.16)
Using rails (3.1.1)
Using sass (3.1.10)
Using sass-rails (3.1.4)
Using sqlite3 (1.3.4)
Using turn (0.8.3)
Using uglifier (1.0.4)
Your bundle is complete! Use `bundle show [gemname]` to see where a bundled gem is installed.

…and then when finished do a commit of the recent additions.

[sourcecode language=”bash”]
$ git add -A
$ git commit -m ‘Adding Rails 3.1 Project.’

Now add the appropriate remote sources for git and the project is ready for development.

[sourcecode language=”bash”]
$ git remote add origin
$ git remote -v
origin (fetch)
origin (push)

The example, with extra example code in place, is available on @Github at


On a regular basis, while coding, one wants to commit their regular work and push those changes to the server (@Github in this scenario). After every change, add the changes to the commit, then commit with a message as shown. When done, do a pull to insure everything is up to date and then a push.

[sourcecode language=”bash”]
$ git status
# On branch master
# Changes not staged for commit:
# (use "git add …" to update what will be committed)
# (use "git checkout — …" to discard changes in working directory)
# modified: Gemfile
no changes added to commit (use "git add" and/or "git commit -a")
$ git add -A
$ git commit -m ‘updated Gemfile.’
[master b06aa76] updated Gemfile.
1 files changed, 0 insertions(+), 1 deletions(-)
$ git pull
Already up-to-date.
$ git push
Counting objects: 5, done.
Delta compression using up to 8 threads.
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 289 bytes, done.
Total 3 (delta 2), reused 0 (delta 0)
6986cd0..b06aa76 master -> master


This section, I’m going to primarily provide a bunch of links to specific instances of features for Git or RVM.

Git Branching

[sourcecode language=”bash”]
$ git checkout -b modify-branchSwitched to a new branch ‘modify-branch’$ git branch  master* modify-branch

…make some changes…

[sourcecode language=”bash”]
$ git add -A
$ git commit -m ‘committing a minor file change while in a branch.’
[modify-branch 726e770] committing a minor file change while in a branch.
1 files changed, 3 insertions(+), 1 deletions(-)
$ git push
Everything up-to-date
$ git checkout master
Switched to branch ‘master’
$ git merge modify-branch
Updating b967d4e..726e770
Fast-forward | 4 +++-
1 files changed, 3 insertions(+), 1 deletions(-)
$ git branch -d modify-branch
Deleted branch modify-branch (was 726e770).

Git Rebasing

Git Stashing

Managing Gemsets

“Working Directory doesn’t exist” in Rubymine! ARRRGGGHHH!!

So a few weeks back I created a Rubymine Ruby on Rails Project I was kicking off. I got it running, did some scaffolding, started customizing that for what I needed. I had created this project on Windows 7 and did not realize the implications of this. I did a clone via github of the code on a Mac via bash. I then opened Rubymine and opened the project. That’s when I got this error message, “Working Directory doesn’t exist”. I thought, well what the…   no reason for this. I’ve barely edited the project!!

I checked out the Jetbrains Forums and didn’t find an answer at the time, but did find others having the problem. Just today, Tyler Williams posted what had happened. Being that I don’t delete my projects, even slightly broken, for many days I went back to look at the .idea files as Tyler Williams suggested. Sure enough, my setting was hard coded (I suppose by the IDE??).

Which leads me to my recent thought that maybe I’ll be using TextMate more and Rubymine a little less. Even though, I do love the refactorings, code completion, and all that. But since I’m in the learning stage, and I’m doing hard core TDD (best I can with Ruby 🙂 ) I ought to not use the IDE as a crutch and instead force myself to learn the language well & the Rails Technology Framework! I’m getting there, but the battle still exists for me. At this point, I do my Ruby & Rails work about 1/2 in TextMate and 1/2 in Rubymine. Anyway, if you run into “Working Directory doesn’t exist” in Rubymine, now you have a good lead on what to do.

Last Night’s Cafe Racer Ruby on Rails Meetup; Kilt Lifter, EngineYard, Heroku and a Ruby Tone

Yesterday evening at the Cafe Racer Ruby on Rails meetupI knocked out these specific tasks.

Kilt Lifter by Pike Brewing Company
Kilt Lifter by Pike Brewing Company
  • Drank a solid tasty Kilt Lifter.
  • Created a sample beginning application, with standard migrations, and errata, and made two simple models with respective scaffolding.
  • Deployed the beginnings of a sample application to Heroku.
  • Deployed the beginnings of a sample application to EngineYard.

For Kilt Lifter information, click on the image at the right. If you live in the northwest, you know what’s up with the beer capital of the world (i.e. Portland, and the northwest in general, for info see here or click on the image to the left). We love our beer up here in these parts, we love it with a passion and it shows with more brewpubs, beer options, varieties, home brews, and other flavors than anywhere else in the world. No, I did not mis-state that, the northwest has more than anywhere else in the world, almost by an order of magnitude!  More than Germany, Ireland, England, the East Coast of the US, and the list goes on. So if you’re up for a beer and some coding, or just a beer, head to the northwest! We’ll have a few for ya to taste. 😉

The initial Ruby on Rails Application I created I started with RubyMine from Jetbrains. Simply a File -> New Project -> Rails Application, etc, etc. I worked through some of the issues with fellow rubiests and railers at the meetup. We did run into a confusing and nasty issue with Postgresql. Why was I installing Postgresql you ask? Well I was trying to do a deployment to Heroku, which provides a free shared instance of postgresql. I gotta admit, of all the things that Heroku makes absurdly easy, setting up a database is not one of them. Maybe I’m missing a bit, but I don’t know what the instance of the server is, what the username or password is, or anything of that sort. It isn’t all that intuitive that you have to add the database as an add-on either. At least, it wasn’t to the 3-4 of us that were working on it.

The other problem I ran into was what process I should actually use to install Postgresql. The firsts thing I tried to do was submit the “gem install pg” which ended with a completely wonky description. The error message read as:

[sourcecode language=”bash”]
$ sudo gem install pg
Building native extensions. This could take a while…
ERROR: Error installing pg:
ERROR: Failed to build gem native extension.

/System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/bin/ruby extconf.rb install pg
extconf.rb:1: command not found: pg_config –version
ERROR: can’t find pg_config.
HINT: Make sure pg_config is in your PATH


I found a fix, here put together by Graham Ashton. Thanks Graham!

The fix involved simply to add a path variable…

[sourcecode language=”bash”]
$ PATH=$PATH:/Library/PostgreSQL/8.3/bin sudo gem install pg

Meanwhile I dived into EngineYard and got the application up and running in short order. I have to say I am much impressed by the increased visibility into what’s going on with EngineYard. Heroku seems to hide just a bit too much. Add to that their over-reliance on AWS East and not geographically dispersing the platform, I’m leaning even heavier on suggesting EngineYard for startups and companies that want a cloud provider platform to build to.

Once the applications I’ve been working on get to a certain state, I’ll be providing a write up regarding the applications. However, until then, feel free to follow me on Twitter and Github or jump in fork my code and send me a pull request.  🙂

Update: Just some images from the meetup.

Ruby on Rails meetup at Cafe Racer - Corner Table
Ruby on Rails meetup at Cafe Racer - Corner Table
Ruby on Rails Meetup at Cafe Racer
Ruby on Rails Meetup at Cafe Racer