[Note: from this point on, I'll use "Rails" to mean "Rails 3"]

Installing Rspec for Rails 3

The first new thing to be aware of is the rspec-rails gem; because Rails 3 is much more modular and extensible than previous versions of the framework, this one gem can do all the work of plugging RSpec into your Rails apps.

Install the gem thus:

gem install rspec-rails --pre

The --pre tells Rubygems to install the beta version of the gem, which you’ll need for Rails 3 development.

The next step is to tell your Rails app to use the rspec-rails gem; this is done quite simply in your app’s Bundle file. Because you don’t need RSpec in production, add the gem to the development and test groups only:

# in path/to/your/app/Bundle
group :development, :test do
  # the version number may be different for you.
  # Use gem list rspec-rails --local on your command line
  # to get the exact version number.
  gem 'rspec-rails', '2.0.0.beta.20'
end

The final step is to run the following in the root of your Rails app:

script/rails generate rspec:install

This sets up a spec/ folder and some helper files.

Using RSpec

Now you’ve installed the rspec-rails gem, using RSpec is actually really simple. The gem tells Rails to use rspec to generate test files, which means that generators will create spec files without you having to pass in any extra options (if you check the options for rails generate model, you’ll see that there’s a --test-framework option. You don’t need to use this to specify RSpec; after installing rspec-rails, RSpec will be used by default).

So, to generate a Person model with corresponding person_spec.rb, all you need to do is this (the same applies to controllers, helpers, etc):

rails generate model Person

Check out spec/models/person_spec.rb to see the stub spec for your Person model. That’s really all you need to know to start using RSpec on Rails 3, but do checkout the rspec-rails repository on Github: the README gives more in-depth explanations of a lot of the points I’ve made here, and also has extra tips on writing specs for controllers, views, responses, and routes.

Pro Tips

A few cools things I’ve found using RSpec in my new Rails apps:

Helper Specs

Helpers specs have access to a special object in the helper object, which includes your helper. For example, in person_helper_spec.rb the helper object has access to all the methods in PersonHelper. This makes it really easy to test your helper methods:

# Assumes a PersonHelper with a #speak method.
describe PersonHelper do
  describe '#speak' do
    # roughly equivalent to:
    #
    # helper = Object.new
    # helper.send :include, PersonHelper
    # helper.speak.should == 'Hello'
    it 'says Hello' do
      helper.speak.should == 'Hello'
    end
  end
end

Spec Support Files

Although it’s not there by default, if you create a folder spec/support, then every file under that folder will be required when you run specs. This is really useful if you want to keep custom RSpec matchers, mocks, or other supporting code, in separate files (for example, you might want to keep custom matcher code in spec/support/my_matcher.rb and mocks in spec/support/mocks.rb).

Hopefully this post has helped you can a handle on how to use RSpec with the latest version of Rails. If you spot any other “pro tips”, post them in the comments! Thanks for reading.

What constantly amazes me about Apple is the company’s ability to look into the future and see what people will want before “people” know it themselves. This is a clever trick, and one that makes Apple a ton of money, but it isn’t exactly difficult: for any budding entrepreneur, the question to ask yourself is “what would be cool?”.

Throw away those expectations/limitations. Think fantasy, not reality. A car operated by your mind? Draw up some blueprints. It’s Apple’s ability to think not just outside, but way beyond the box that has put them ahead; they have an almost naive, child-like optimism when it comes to new products. A touchscreen phone that’s also a miniature computer? Yeah, why not.

And why not indeed. Cool is the way forward. If you’re going to make money you might as well do it bringing enjoyment to people’s lives, and “people” don’t care about profit margins or technological limitations, they just like stuff that’s easy and fun to use. Stuff that’s new, stuff that’s different. And stuff that feels a little bit like it’s from the future. Magic is probably the right word.

Framework Agnosticism

This is huge. In previous versions of Rails, we were locked into ActiveRecord for database abstraction, and Prototype for Javascript. Both are fine choices, but Rails 3 gives you the option to use other libraries if you want to (you can stick with the defaults as before too).

I love jQuery, so I’ll be using that in all my Rails 3 projects instead of Prototype. You could also use DataMapper or Sequel in place of ActiveRecord, if you so desire. The important thing is that Rails 3 is more of a framework in the truest sense: a codebase into which we can plug our own favourite libraries, rather than a monolithic API without much flexibility when it comes to libraries.

Improved Plugin API

What better evidence do you need than this: Rails 3 itself is built on its own plugin API (internals like ActiveRecord and ActionMailer use the same code as third-party plugins to do their stuff — you can read more about this on the Rails blog). This makes things about 100% easier for plugin developers, and stops us from feeling like we sometimes have to dig into the dark depths of Rails, where we shouldn’t be, to make our plugins work.

More Thoughtful Code

As with any update, a huge amount of thought has gone into Rails 3 and I’ve been particularly impressed by the clarity of code turned out on this release. It feels like Rails has got leaner, cleaner, and better structured; this can only be good for us Rails developers in the long run: cleaner framework code means better performance and makes it easier to troubleshoot bugs (in the Rails code and in your own). Check out the new ActionMailer API for an example: it’s a great improvement over Rails 2.x — no longer the model/controller mongrel that it used to be!

Those are my top three reasons to use Rails 3 now. If you’re wavering, jump in and give it a try!

This is all unsurprising of course: unsolicited marketing is impersonal, intrusive, and more often than not irrelevant to the people it targets. So, I might be putting myself in line for some criticism when I say: I’ve been promoting my website design business using sales calls for the past three years.

What? Yes, that’s right: sales calls. Hello sir or madam, can I interested you in bla bla bla. However, it works, and what’s more people respond very well to it for one simple reason: I make every effort not to sound like I’m selling something.

1. I’m ridiculously polite: I usually begin my calls by asking if I’ve got the right number and apologising for intruding on the person’s time. If they’re not interested, I wish them good luck with their business and thank them for their time.
2. I’m friendly: if the person I’m calling wants to talk about their dog, I’ll talk about their dog (no, I’m not selling dog products). I take time answer their questions; I don’t read from a script, I respond to each person individually.
3. I’m helpful: if someone wants advice, even if they’re not going to pay me money, I give it. If they have a problem with their website, I offer to email them a solution even if they’ve said no to my sales pitch. I gain nothing financially from this, but I tell you what: it makes me feel good :)

I can imagine marketing professionals trembling as they read this. How many hours have I wasted chatting about some old lady’s dog when I could be making the next sale? Well, maybe a total of two or three hours over three years. But it stops me from feeling like I’m one of those awful, godless people who’s calling people out of the blue with the sole intention of getting their money. Call me crazy, but I say that’s worth the extra time.

I’m surprised that more businesses don’t take this approach to marketing. Every sales call I’ve ever had was from some guy/girl sat in a call centre somewhere, with zero interest in me as a person. Business is about people! People + demand + other people + supply = business. When you’re sat behind a computer, you tend to forget that. Why not go out of your way to be decent to the people who don’t pay you money, as well as those who do? At the very least, you’ll get a good reputation.

So: anti-marketing. Marketing that doesn’t feel like marketing. It’s the way forward.

If you’re self-employed or freelance, the goal here is to free up more of your time to relax and enjoy yourself or to work on other projects. If you’re an employee working for the man, our aim is to cut down on the hours which you have to work to accomplish your key tasks (leaving you more time to either catch up on your todo list, or play solitaire).

For me, cutting down your work hours is a matter of asking three simple questions about your work:

1: Does This Work Need To Be Done?

The first question is the most obvious — cut out the things that aren’t absolutely essential, and you’ll save yourself time. The criteria by which you judge a task’s importance will vary, but a good rule of thumb is this: if you don’t do this “important” task, will the consequences be irreversible? You’ll be surprised how many times you’ll answer “no” to that question.

2: Do I Need To Be Doing This?

Often it’s faster and more productive to have someone else do something for you — especially when the other person is an expert and you’re not. Don’t be afraid to delegate and free up your time to focus on the essentials.

By the way, this question is different to “Do I want to be doing this”! Sorry. Sometimes you have to work on something that you don’t want to work on: that’s unavoidable. The idea is to delegate work which can be done equally well, or better, by someone else.

3: How Can This Be Done Better?

Not “done faster”; “done better“. This question helps you future-proof your work: the best way to avoid emergencies and panic in the future is to do a good job now.

Make a list of the key goals of whatever project you’re working on, and ask yourself whether you’re going about accomplishing those goals in the best way. Change isn’t always necessary, but sometimes you’ll realise that a lot needs to be altered — that can be daunting, but it’s worth putting in a little more time now to save yourself a lot of time in the future.

The Results

Does this work in practice? For the past three months I’ve been using this strategy and I’d say I’m around 25% more productive, and 25% less busy. Most importantly, I feel much more relaxed and on top of my work. So give it a try — I hope you get the same results.

Work is too much like work

You know that feeling you get when you’ve been thinking long and hard over a particular problem: your head feels like mush, your eyes hurt, you can’t focus. Your mind feels tight, it feels like you’ve lost touch with your real energy. After close to ten years’ of meditation, I can tell you that this is a Bad Thing.

My suggestion is that “work”, in the traditional sense of the word, is one of the worst ways to get things done. Work means mental exertion, which in most cases nowadays means a ridiculous focus on logic, and the idea that “nose to the grindstone” is the only way to get results.

Doesn’t that sound awful? How about relaxing and letting your subconscious take care of things, instead. It really works: I’ve lost count of the numbers of times a solution to a difficult problem had come to me, without effort, while I’ve been walking, cooking, or playing guitar.

Stop thinking, stop trying

The burden of “work” is too much thinking. Logic, planning, analysis: all of these are good as part of an holistic approach, but bad when they take the lead on business decisions. They serve a purpose, but intuition and the subconscious are much more powerful. Yes, that’s right: I run my business on gut instinct. It’s so much more effective!

My advice is to let your mind slip back into alpha waves, and let “important” decisions take care of themselves. My approach nowadays is to arm myself with all the facts, then completely ignore the situation for a few days: meditate, go walking, work on something else. After my subconscious has had the time to work on the problem, the answer presents itself naturally, and without effort.

Making it work for you

This all sounds very Zen, but how does it apply to you? Well, just try it. You can’t control your own mind, but you can give your mind a break: next time you catch yourself thinking away too hard at a problem, just drop it. Leave the office, go outside, listen to music, do something relaxing. And I think “relaxing” is the key word here: you need to put yourself into situations that allow you to unwind, situations that don’t require logic: this gives your mind the space it needs to work creatively.

Ignore the received “wisdom” that says you have to work hard (and think hard) in order to get things done.

Here’s an example:

require 'ostruct'

s = OpenStruct.new
s.name # => nil
s.name = 'James'
s.name # => 'James'

Note that we don’t need to initialise the ‘name’ attribute: we just set the value and Ruby takes care of the rest. Want to add a new attribute? Easy.

s.age # => nil
s.age = 29
s.age # => 29

We can add any attribute we want to our objects, on the fly, and different instances of the OpenStruct class can have different attributes. Importantly, we don’t have to worry about what methods we send to our OpenStructs, because anything that doesn’t have a value just returns nil ¹:

s.location # => nil
s.hobbies # => nil

Clearing Values

To unset a value, we can do one of two things: in most cases, it’s the obvious…

2.age # => 29
s.age = nil
s.age # => nil

…but to grab the value before setting the attribute back to nil, we can use delete_field ²:

# Returns 29, and sets 'age' to nil
age = s.delete_field('age')
age # => 29
s.age # => nil

Initialising With Values

We can create new OpenStruct objects with attribute/value pairs by providing a hash:

s = OpenStruct.new(:name => 'James', :occupation => 'Rubyist')
s.name # => 'James'
s.occupation # => 'Rubyist'

How It Works

Behind the scenes, Ruby uses a hash to implement OpenStruct’s easy access so we get all the flexibility of a hash with a nice, clean, method-style access laid on top. Don’t worry about the details: just throw whatever you want into your OpenStructs, and let Ruby take care of your data.

Advanced Initialization

If you want object with the flexibility of OpenStructs but with default values for some attributes then something like the following would work:

require 'ostruct'

class MyStruct < OpenStruct
  # Hard-code age and status
  def initialize(hash = {})
    super hash.merge(:age => 29, :role => 'Manager')
  end
end

s = MyStruct.new(:name => 'Bob')
s.name # => 'Bob'
s.age # => 29
s.role # => 'Manager'

# We can override the default values
s = MyStruct.new(:age => 45)
s.age # => 45

OpenStruct vs Struct

Ruby’s Struct is subtly, but importantly, different to OpenStruct. How to use Struct is another blog post, but put simply Structs are less flexible. Check the Struct docs for more info :)

It Just Works

Paperclip on Rails 3 now just works.

Back in February 2010, I wrote about how to use Paperclip on an early beta release of Rails 3 — back then, a few small hacks were required to get Paperclip running. Now Rails 3 is at beta 4, and it’s safe to assume that we’re as close as we can be to an official Rails release — minus a few last minute tweaks, of course — and both the framework itself and the Paperclip plugin are more stable and more compatible. The good news, then, is that it’s very easy to use the Rails 3 and Paperclip together.

How To Use Paperclip With Rails 3

These instructions are good for Rails 3 beta 4, and Paperclip 9223a917. They’ll probably work on other versions of Rails and Paperclip, too.

1. Install Rails 3
2. Create a new Rails app
3. Install Paperclip
4. Create a model
5. Create a controller and views
6. Define your routes

You can find the important files (controller, model, views, and routes) in this gist, and the full application code is available on Github.

Install Rails 3

Install the latest prerelease of Rails with the following:

$ gem install rails --pre

Create a new Rails app

The command for creating Rails apps has changed in Rails 3. In the bright new future, everything is done using “rails” ¹:

$ rails new paperclip_example

Install Paperclip

Paperclip’s master branch is now good to go with Rails 3. Install from Github thus:

$ rails plugin install git://github.com/thoughtbot/paperclip.git

Create a model

In order to work with Paperclip, your model needs a few special database columns. In this case, I’m creating a User class which will have an attached avatar image.

$ rails generate model User \
avatar_file_name:string \
avatar_content_type:string \
avatar_file_size:integer \
avatar_updated_at:datetime
$ rake db:migrate

I use Paperclip’s has_attached_file method to define my avatar attachment:

class User < ActiveRecord::Base
  has_attached_file :avatar, :styles => {
    :thumb => '50x'
  }
end

Create a controller and views

I’m setting up a simple UsersController with index, new, and create actions (and corresponding routes). You’ll probably want to go further, but if all you’re interested in is proof-of-concept then this is enough.

$ rails generate controller Users

See this gist for the code in my UsersController, and the HTML in my views.

Define your routes

In config/routes.rb:

PaperclipExample::Application.routes.draw do |map|
  resources :users, :only => [:index, :new, :create]
  root :to => 'users#index'
end

Lastly, if you’re mapping your app’s root to a controller, remember to delete public/index.html.

And You’re Done

That’s really all there is to it. Use rails server to start your app and view the results. Did it work for you?

Jim Barraud, Manifest’s creator, describes the theme thus:

A clean and streamlined theme that focused on the content and not the distractions. It utilizes a single column, 500 pixel wide layout. No sidebars. No widgets.

There’s so much to love about that quote. Single column. Focus on content. No sidebars. No widgets. Simplicity, simplicity, simplicity.

I’ve always loved websites and blogs which are pared right back to the bone — nearly too simple — for the simple reason that I spend so much time on the web! After surfing through websites which bash me round the head with flashy graphics, it’s such a relief when I come to rest at a site designed by someone who knows the meaning of negative space and subdued (if any) graphics.

And aspiring writers: this is the kind of presentation that you should be wrapping around your lovingly crafted blog posts: let your language speak for itself.

So: a beautiful, simple, elegant theme: download Manifest here.

I don’t even own an iPad, but I’m already blogging about the DODOCase  and have bookmarked the website, so kudos to these guys for excellent marketing!

Photo by adamjackson on Flickr (license)