RailsTips - Home

jQuery on Rails: Why Bother?

2008-11-20T21:30:00Z

In which I explain why I use jQuery at times and how you can as well. Oh, and I provide a wealth of links. Links are fun!

A few people have suggested that I post about how to use jQuery with Rails. I thought about it and felt that others have already covered it quite well but why not collect their posts here for you to enjoy, right? Plus, I do all my JavaScript from scatch so I do not really ever use the helpers Rails provides and as such could not post intelligently on them.

So John, When Did You Quit Prototype?

I haven’t! I do not intend to ever quit using Prototype. Honestly, I have used jQuery quite a bit less than Prototype. I have found that jQuery and Prototype are both great and in different situations I will use a different library. The one thing I will say is even if you don’t actually switch to jQuery, I think it is important to learn new things and stretch yourself. It is good to feel frustrated and like a beginner. Also, jQuery takes a very different approach which has actually helped me write better Prototype code. Hope this is helpful and not overwhelming. :)

Creating A Plugin

Today, I wrote an article on How to Create a jQuery Plugin From Scratch over on my Addicted To New site. I picked out the most basic thing a plugin could do and explained each step in a lot of detail. Give it a read if you are into Prototype but are curious about jQuery.

Live Search and Fancy Zooming

After creating my live search with quicksilver for prototype example, I decided to port it to jQuery (view demo). Then, humbly, I was corrected by the jQuery man himself, John Resig, who re-ported my port in a more jQuery-ish functional style. For those that are curious, I also massaged the AJAX-RDoc project to use quicksilver searching. This is really helpful when you can’t quite remember a method name.

Likewise, when I created fancy zoom for prototype, my partner in crime, Steve Smith, created a port of fancy zoom for jQuery (view demo). Fancy Zoom is great for showing text and images with an Apple-esque, in page zoom transition or even Flash if you have a video you would like to feature.

jQuery Railscast

Ryan Bates did an awesome job showing how to use the jQuery on Rails plugin with Rails in a recent screencast. He also gave a really quick example on how to create a plugin. I would recommend watching this and subscribing to his Railscasts, which are great.

jRails Plugin

jRails is a drop-in jQuery replacement for Prototype/script.aculo.us on Rails. Using jRails, you can get all of the same default Rails helpers for javascript functionality using the lighter jQuery library. Ryan shows how to use it in the screencast mentioned above, but I thought I would also mention it separately. If you are a fan of the Rails javascript/ajax helpers, this plugin is for you. It makes each of them work with jQuery and has some nice demos on the site.

Link Love

While dispelling the myth that Rails is tied to Prototype, DHH gave some jQuery examples.

Brandon showed how he includes the authenticity token using prototype and the pug automatic shows how to do the same using jQuery.

Ben Curtis has a tutorial on how to do drag and drop sorting with jQuery and Rails.

Yehuda Katz has a year old presentation on jQuery and Rails that is still worth a look.

Nutrun has a more full post on how to do unobtrusive ajax with jQuery and Rails

ErrTheBlog (errtheblog is dead. long live errtheblog!) gave jQuery some serious love a while back in their jSkinny article. Chris also created a plugin named Facebox that is used extensively on GitHub and has a short post that shows how to get jQuery working with respond_to.

If you are a fan of Low Pro, Dan Webb has created a port of Low Pro for jQuery. (article #1, article #2)

In some Rails Rumble observations, it was noted that jQuery was more widely used than Prototype.

Don’t forget that “jQuery UI provides abstractions for low-level interaction and high-level, themeable widgets, built on top of the jQuery JavaScript Library, that you can use to build highly interactive web applications.” Be sure to check out the demos.

If you are a fan of Twitter, you can follow jQuery for links to articles and such.

Nathan Smith gave a crash course on jQuery that includes a sweet airline seat demo.

jQuery does not come with all of Prototype’s functionality out of the box, but you can usually find a plugin that does what you need if you are too lazy to make something yourself.

Lastly, one of my favorite jQuery resources is Visual jQuery. I found this site a blessing when I was trying to learn jQuery.

Feel free to post your favorite jQuery/Rails resources as a comment below.

Delayed Gratification with Rails

2008-11-19T20:35:00Z

In which Daniel Morrison covers how to install and use delayed job, a rails plugin that encapsulates the common pattern of executing longer tasks in the background.

I realized when I started taking suggestions that I would not be able to do them all justice, so I asked a few of my friends to be guest authors. Daniel Morrison, of Collective Idea, is the first and will be showing a few ways he has used delayed job to offload tasks to the background. Without any further ado, here is Dan.

At Collective Idea, we started using delayed_job a few months ago, and have fallen in love with its simplicity. In fact, my first implementation of it was done and tested on a quick train ride to Chicago, with time to spare.

So it’s easy?

Yep, you can add delayed_job in 10 minutes or less.

Getting Started

Install the plugin, which is available on GitHub.

Then build & run a migration to add the delayed_jobs table:

create_table :delayed_jobs, :force => true do |table|
  table.integer  :priority, :default => 0
  table.integer  :attempts, :default => 0
  table.text     :handler
  table.string   :last_error
  table.datetime :run_at
  table.datetime :locked_at
  table.datetime :failed_at
  table.string   :locked_by
  table.timestamps
end

(In the future there will be a generator for this step. Tobi, please merge some of the forks!)

Run your jobs

The rest of the article will focus on creating jobs, but when you want to run them, you can simply run rake jobs:work

The job runner will grab a few jobs and run them one at a time. It locks them so that multiple runners won’t conflict, and it will retry jobs a number of times if it fails for some reason. If it does fail, it stores the most recent error message. Play around in script/console with the Delayed::Job model to see how it works.

There are some other ways to run jobs in production in some of the forks on github. Collective Idea’s for example, adds script/delayed_job. The rake task will work for now though.

Example 1: Delay Something

Now the fun part: pick something to delay. A great place for delay is email. I’ve seen places where apps have broken due to email not being able to send. Maybe the client changed their email server and didn’t tell the programmer, or maybe the mail server was temporarily down for maintenance. Either way, it generally shouldn’t stop our app.

Here’s a common controller pattern for a contact form:

def create
  @contact_form = ContactForm.new(params[:contact_form])

  if @contact_form.save
    flash[:notice] = 'Your feedback has been sent. Thanks for contacting us!'
    ContactMailer.deliver_contact_request(@contact_form)
    redirect_to @contact_form
  else
    render :action => "new" 
  end
end

The problem is that if the mailer fails due to outside circumstances, we’re throwing an error. We could rescue from that, but since there’s nothing the user can do, we shouldn’t involve them.

Instead, let’s send email as a delayed_job, which will retry on failure and also keep track of the last error it sees.

Here’s the refactored action:

def create
  @contact_form = ContactForm.new(params[:contact_form])

  if @contact_form.save
    flash[:notice] = 'Your feedback has been sent. Thanks for contacting us!'
    ContactMailer.send_later(:deliver_contact_request, @contact_form)
    redirect_to @contact_form
  else
    render :action => "new" 
  end
end

That’s it! send_later works just like send, but magically turns it into a delayed_job. Now our user can keep clicking through the app, and the email will send in a few seconds.

Example 2: A more complex example.

My first use of delayed_job was a large import process that could take 5 minutes or more. What’s going on here is the user uploads a large CSV file that we then processed the crap out of, adding hundreds or thousands of rows to different tables.

In my controller, I had something along these lines:

def update
  @item = Item.find(params[:id])
  if @item.update_attributes(params[:item])
    @item.import_file.import!
    redirect_to @item
  else
    render :action => 'edit'
  end
end

The problem here is the browser has to sit and wait until the import! method finishes. Not good. There’s no need for the user to wait for the import. We can give them a message in the interface that the import is still in-progress.

So change the controller method above to this:

def update
  @item = Item.find(params[:id])
  if @item.update_attributes(params[:item])
    Delayed::Job.enqueue ImportJob.new(@item.import_file)
    redirect_to @item
  else
    render :action => 'edit'
  end
end

ImportJob is a simple class I’ve defined and tossed in the lib/ directory.

class ImportJob
  attr_accessor :import_file_id

  def initialize(import_file)
    self.import_file_id = import_file.id
  end

  def perform
    import_file = ImportFile.find(import_file_id)
    import_file.import!
    import_file.complete!
  end    
end

Again, that’s it! Our ImportJob, holding our ImportFile (which is an ActiveRecord object, using attachment_fu) is added to the queue. When we pop it off the queue later, the perform method is called, which does our import. My complete! method sets a completed_at flag so I can tell the user that we’re done.

My real code is a bit more complex, but hopefully you can see how this style can by used for doing multi-step jobs.

Example 3: Tiny but useful.

The import job above adds a lot (hundreds) of locations to this app that will show up on a map eventually. I’m using acts_as_geocodable (because it’s awesome) to geocode the addresses via Google & Yahoo, but I don’t need that info right away, and I don’t need it holding up the imports.

acts_as_geocodable does its work by adding an after_filter :attach_geocode automatically to the model you specify.

So for my app, I changed it from an after_filter to a delayed_job.

Here’s all the code it took:

class Location < ActiveRecord::Base
  acts_as_geocodable

  # some code removed for clarity

  def attach_geocode_with_delay
    self.send_later(:attach_geocode_without_delay)
  end
  alias_method_chain :attach_geocode, :delay

end

Very fun.

Your turn

There’s really not much more to delayed_job than that. Its simplicity is what makes it great. So go and delay something already!

HappyMapper, Making XML Fun Again

2008-11-17T07:10:00Z

In which I show that XML does not have to suck—instead you can just HappyMap it!

As much as I write about XML, you would swear it is all I do, but I promise it is not. In fact, I do not really use XML that often, but I will admit that I am intrigued by it. A while back, you may remember, I posted about ROXML, a ruby object to xml mapping library. I liked the idea but not the implementation. Soon after, I started playing around with what I have named HappyMapper, a ruby object to xml mapping library.

I wrote nearly 95% of it in a weekend and then let it sit. I let it sit so long that it started to rot. Today it hit me that I do not have to finish something in order to release it. The thing that wasn’t working was xml with a default namespace. For good reasons I am sure, libxml-ruby does not like having default namespaces. I thought to myself, you know, this library is cool even without namespace junk. I mean who even uses namespaces other than Amazon. I started to package it for release and then I noticed a few nitpicky things. I tweaked them and five hours later I had also fixed the namespace issue and changed the API a bit. So much for releasing unfinished code in hopes that someone smarter than I would finish it up…

Examples

But I digress, you do not care about all that, right? How about some examples? Twitter’s xml seems to be popular on this here blawg, so I will start with that. Given this xml sample from twitter:

<statuses type="array"> 
  <status> 
    <created_at>Sat Aug 09 05:38:12 +0000 2008</created_at> 
    <id>882281424</id> 
    <text>I so just thought the guy lighting the Olympic torch was falling when he began to run on the wall. Wow that would have been catastrophic.</text> 
    <source>web</source> 
    <truncated>false</truncated> 
    <in_reply_to_status_id>1234</in_reply_to_status_id> 
    <in_reply_to_user_id>12345</in_reply_to_user_id> 
    <favorited></favorited> 
    <user> 
      <id>4243</id> 
      <name>John Nunemaker</name> 
      <screen_name>jnunemaker</screen_name> 
      <location>Mishawaka, IN, US</location> 
      <description>Loves his wife, ruby, notre dame football and iu basketball</description> 
      <profile_image_url>http://s3.amazonaws.com/twitter_production/profile_images/53781608/Photo_75_normal.jpg</profile_image_url> 
      <url>http://addictedtonew.com</url> 
      <protected>false</protected> 
      <followers_count>486</followers_count> 
    </user> 
  </status> 
</statuses>

You could setup the following ruby objects:

class User
  include HappyMapper

  element :id, Integer
  element :name, String
  element :screen_name, String
  element :location, String
  element :description, String
  element :profile_image_url, String
  element :url, String
  element :protected, Boolean
  element :followers_count, Integer
end

class Status
  include HappyMapper

  element :id, Integer
  element :text, String
  element :created_at, Time
  element :source, String
  element :truncated, Boolean
  element :in_reply_to_status_id, Integer
  element :in_reply_to_user_id, Integer
  element :favorited, Boolean
  has_one :user, User
end

statuses = Status.parse(xml_string)
statuses.each do |status|
  puts status.user.name, status.user.screen_name, status.text, status.source, ''
end

You can note a few things about HappyMapper from that example.

Each xml element and attribute can be typecast.
You can define association-like elements that are formed from other HappyMapper objects (see has_one :user, User in Status).
You get a parse method when including HappyMapper that takes a string and does all the magic for you.

That was an easy one, how about something more complex and ugly, like some Amazon xml. Given some Amazon xml such as this:

<?xml version="1.0" encoding="UTF-8"?>
<ItemSearchResponse xmlns="http://webservices.amazon.com/AWSECommerceService/2005-10-05">
    <OperationRequest>
        <HTTPHeaders>
            <Header Name="UserAgent">
            </Header>
        </HTTPHeaders>
        <RequestId>16WRJBVEM155Q026KCV1</RequestId>
        <Arguments>
            <Argument Name="SearchIndex" Value="Books"></Argument>
            <Argument Name="Service" Value="AWSECommerceService"></Argument>
            <Argument Name="Title" Value="Ruby on Rails"></Argument>
            <Argument Name="Operation" Value="ItemSearch"></Argument>
            <Argument Name="AWSAccessKeyId" Value="dontbeaswoosh"></Argument>
        </Arguments>
        <RequestProcessingTime>0.064924955368042</RequestProcessingTime>
    </OperationRequest>
    <Items>
        <Request>
            <IsValid>True</IsValid>
            <ItemSearchRequest>
                <SearchIndex>Books</SearchIndex>
                <Title>Ruby on Rails</Title>
            </ItemSearchRequest>
        </Request>
        <TotalResults>22</TotalResults>
        <TotalPages>3</TotalPages>
        <Item>
            <ASIN>0321480791</ASIN>
        <DetailPageURL>http://www.amazon.com/gp/redirect.html%3FASIN=0321480791%26tag=ws%26lcode=xm2%26cID=2025%26ccmID=165953%26location=/o/ASIN/0321480791%253FSubscriptionId=dontbeaswoosh</DetailPageURL>
            <ItemAttributes>
                <Author>Michael Hartl</Author>
                <Author>Aurelius Prochazka</Author>
                <Manufacturer>Addison-Wesley Professional</Manufacturer>
                <ProductGroup>Book</ProductGroup>
                <Title>RailsSpace: Building a Social Networking Website with Ruby on Rails (Addison-Wesley Professional Ruby Series)</Title>
            </ItemAttributes>
        </Item>
    </Items>
</ItemSearchResponse>

You could create the following objects to obtain Item information:

module PITA
  class Item
    include HappyMapper

    tag 'Item' # if you put class in module you need tag
    element :asin, String, :tag => 'ASIN'
    element :detail_page_url, String, :tag => 'DetailPageURL'
    element :manufacturer, String, :tag => 'Manufacturer', :deep => true
  end

  class Items
    include HappyMapper

    tag 'Items' # if you put class in module you need tag
    element :total_results, Integer, :tag => 'TotalResults'
    element :total_pages, Integer, :tag => 'TotalPages'
    has_many :items, Item
  end
end

item = PITA::Items.parse(xml_string, :single => true, :use_default_namespace => true)
item.items.each do |i|
  puts i.asin, i.detail_page_url, i.manufacturer, ''
end

The previous example showed a few more things.

You can put your HappyMapper objects in a module and define the tag name (see tag ‘Item’ inside PITA::Item).
You can create nice methods for crappy camel cased xml tags (see element :total_pages, Integer, :tag => 'TotalPages' in PITA::Items).
There is also a has_many association-like method that allows defining a collection of HappyMapper objects. (see has_many :items, Item in PITA::Items)
You do not have to map exact parent child relationships. You can go deep see diving with the :deep option on any element to pluck out grandchildren and such. (see element :manufacturer in PITA::Item)

Installation

Installation is typical as the gem is on rubyforge and github.

#rubyforge
$ sudo gem install happymapper

# github
$ sudo gem install jnunemaker-happymapper

If you run into problems, feel free to fork and add some specs for the xml it is not working with. From there you can dive in and fix them or let me know and I will take a look. Think this will be handy? Got an idea? Let me know in the comments below. Oh, and yes, in the future, HappyMapper will have killer HTTParty integration.

Sinatra for IRC

2008-11-14T15:30:00Z

In which I extol the virtues of Isaac for working with IRC in Ruby and at the same time beg library authors to rethink their APIs.

My favorite Campfire feature is the history. I love that it persists between Campfire sessions. On the opposite side of the spectrum, I hate that IRC doesn’t. I decided it would be nice to have a bot that sits in the room and stores all the chatter to the database. Once that was working, it would be handy to have a simple web front end that allowed searching and viewing by day. I have seen sites out there that do that but like any programmer decided to make something for myself.

Finding Some Code

First up, I needed to find a good IRC library for Ruby. I did research for about 30 minutes and found a ton of libraries on GitHub: Net/IRC, on_irc, irc4r, irkr, rbot, minibot, kirby and autumn. I even came across the code that runs rails.loglibrary.com, which is kind of what I want to do but not quite. Each library did things a bit differently and they all had their strengths and weaknesses, but one thing stood out: they almost all required that I was familiar with IRC protocols and terminologies.

The Solution

If I was getting paid to do this, I would want to know inside and out how things work. Because this is a side project, I just wanted to get up and running quickly. At that moment, I remembered SearchParty (which incidentally runs on Sinatra) and headed over there to search for irc. Right at the top of my delicious items was Isaac, which I had totally forgotten about.

“You want to create an IRC bot quickly? Then Isaac is you.”

Yes, I want to create an IRC bot quickly. That is exactly what I want to do.

“Be aware…a large portion of the IRC standard has not been implemented, simply because I haven’t needed it yet.”

I don’t care if the entire spec is implemented. All I care about is whether or not the stuff I want is implemented and what the API is in Ruby to do that stuff.

The Code

A few minutes later, I had the following snippet of code running which allowed my bot to login to an IRC room and listen to all the chatter. Wow. Awesome.


require 'rubygems'
require 'isaac'

config do |c|
  c.nick    = "fantasticalbot" 
  c.server  = "irc.freenode.net" 
  c.port    = 6667
end

on :connect do
  join "#fantasticalroom" 
end

on :channel, /.*/ do
  msg channel, "Got your message #{nick} (#{match[0]})" 
end

If you have used Sinatra, you can immediately see the similarities. You can even define helpers in the same way that you would with Sinatra. Now this doesn’t do everything I mentioned that I want to do, but it was a nice start. All that is left is to drop in ActiveRecord or DataMapper or implement some kind of a web hook to an app and I am good to go.

Conclusion

There are two points to this article. The first is that Isaac is really cool if you want to dabble with IRC from Ruby. The second point, and probably more important, is when you create a library, think about the API that other programmers will use more than you think about the spec you are implementing. I suspect few people out there want to learn every spec that they work with. Most people are probably like me and have a simple need and want a simple solution.

This is one of the reasons HTTParty was created and why I am now working on IMAParty. Spec is important, but every “to the spec” library needs a simplistic DSL on top that makes them easy to use for the 80% of people that only need 20% of the features.

Creating and Integrating Bookmarklets with Rails

2008-11-13T05:40:00Z

In which I show how to create and integrate handy dandy bookmarklets with your Rails app.

If your application stores information, one of the most critical keys to success is allowing users to get that information in quick. If the process is a pain, they’ll move on to something else. One way to allow for easy and quick data entry is a bookmarklet. I recently created a couple for an app I am scratching an itch with and thought I would share the results with you.

Two FYIs: For some reason I sniffed twice during the recording, but I decided to leave them both in to add some “reality.” Also, the ND YouTube tab was open because I was going to show how the tumblr bookmarklet works, not because I forgot the tab open.

Creating and Integrating Bookmarklets with Rails

Can't Miss RubyConf Wrapup

2008-11-11T04:30:00Z

In which I further extol the virtues of RubyConf with a wrap up post covering the final two days.

I lost the steam to write about each day individually as the last two days always seem to fly by much faster than the first. That said, here are the notes I could gather from my moleskin and varioius sheets of paper I scratched on.

Thursday

Jon Dahl had an interesting talk on Aristotle and Software.

Ben Scofield talked about All I Really Need to Know* I Learned by Writing My Own Web Framework. I can’t say that we need another web framework for ruby right now but I enjoyed this talk. Ben’s whole point was how much he learned by writing a web framework from scratch. I couldn’t agree more. I haven’t written my own web framework but writing pure ruby is really the best way to learn ruby. You can’t really learn ruby by just writing rails apps.

Dean Wampler talked about Better Ruby Through Functional Programming. Functional programming seems really interesting. Basically, variables are immutable. Because they don’t change state, it is easier to write “side effect free” concurrent code. Recursion is big in functional programming. Basically recursion in functional programming is equivalent to loops in sequential programming (ruby is sequential). I haven’t really looked at any functional languages and I thoroughly enjoy thinking about things in a different way so this talk was good.

Jim Weirich had an awesome presentation on “What Every Rubyist Should Know About Threads.” Threads were a hot topic as I mentioned in my day one summary. Jim explained that Moore’s Law is no longer true, so concurrency is going to be important. Instead of getting faster CPUs, computers are getting multiple CPUs. In order to fully take advantage of multiple CPUs, you have to be able to have native threads. Ruby 1.9 gets closer to native threads but isn’t there. In order to safely program concurrently in Ruby, Jim gave four tips:

Protect every shared memory access with synchronize block (check out mutex core library)
Be aware of extended situations that need to be atomic.
Need strategy to avoid deadlock.
Evaluate every line in every library used by your program, not just your own code.

Basically, threading is hard. He gave a really quick mention of Clojure, a dynamic programming language that targets the Java Virtual Machine.

Yehuda Katz gave a worthwhile presentation on “Writing Code That Doesn’t Suck: Interface Oriented Design.” The talk started pretty slow and I nearly tuned out as he just covered concepts, but gave no code examples. Once he finally got to the code, I enjoyed the thoughts and examples.

The premise is that most of us test implementation more than we test results, which is what we really care about. Test what you do not want to break. Unit testing is great for isolation but it is not regression testing. I’ve been thinking about something similar to this a lot lately since I started using RSpec on all projects, so it was interesting to hear this perspective. I’ll definitely be testing more based on results rather than on implementation in the future.

Rich Kilmer presented on OS X Application Development with HotCocoa and man was it hot. HotCocoa is an awesome wrapper around MacRuby that makes building cocoa apps sane. I cannot wait to try this out. It comes bundled with MacRuby so simple install and enjoy. There is not much online about HotCocoa as it is only about 3 months old but when the video comes out give this talk a watch. You’ll be amazed. It appears to make cocoa development as easy as HTTParty makes web services.

Dave Thomas’ keynote fricken rocked. Basically he said we should fork ruby and try out some crazy ideas. He then recanted at the end, but the notion that ruby should be extended and played around with more was pretty interesting. The ideas he mentioned were RubyLite, Parallel Ruby (Puby or Pruby), Optionally Typed Ruby (Otuby) and Closure Based Ruby (Cluby). Cluby was really interesting. It bordered on JavaScript in places but I am a fan of JS so that did not bother me. Dave really challenged the community to think differently and try some stuff out.

Thursday night after Dave’s keynote, Pivotal Labs threw a poolside party in honor of Tracker, which was a good time. I had a great discussion about Merb and about CouchDB with Matt Aimonetti and was nearly pushed into the pool, during a discussion of whether or not I should open source a sweet web analytics app I’m working on with my friend Chas.

Friday

Friday I only attended one presentation, but it was possibly my favorite day. Over lunch and through most of the afternoon, I had a great chat with Ryan Daigle, Nathaniel Talbott and Geoff Grosenbach. I think often times at technical conferences we get caught up in code and miss out on a wealth of business knowledge. We talked about “to partner” or “not to partner”, predictable markets, passive income, productivity, efficiency, ideas and a whole lot more.

RubyConf was a blast this year. I finally felt comfortable pretty much the whole time and felt like I opened up a lot. Thanks to all who said hi and to those I did not get to meet…cheers to next year.

Can't Miss Coverage of RubyConf Day 1

2008-11-07T16:00:00Z

In which I cover the highs and lows of day one at RubyConf 2008 in Orlando.

So yesterday was day one of RubyConf in Orlando. I’m not keeping really detailed notes as I’m trying to pay attention more and note taking seems to hinder that but I’ll give a quick overview.

Matz Keynote

The day started with Matz keynote. As always, he was pleasant and pretty funny. He spoke about his reasons for ruby and confessed his love for all of us. Search twitter for Matz and you can find a bunch of his good quotes from the keynote.

Gregg Pollack – Scaling Ruby

Next up was Gregg Pollack’s talk on Scaling Ruby (without Rails). Side note: scaling does not appear to be a direct topic at the conference but threads, concurrency and distributed programming are getting some heavy coverage. Gregg had possibly the best put together presentation I have ever witnessed. I talked to him later and he said it was all keynote but I think it was black magic.

He started by going through a wonderful explanation of threading and the benefits of single threaded vs. multi-threaded. After threading, he dove into message queues and did a wonderful demo of Starling. He closed the talk covering ruby prof, how to profile and some examples of what is expensive in ruby. The concepts he covered are not simple ones but Gregg did a phenomenal job of making them appear simple with great visual aides. He has a pdf on the RailsEnvy site and his talk has been released as an EnvyCast.

Scott Chacon – Using Git in Ruby Apps

At RailsConf Scott did a presentation on git that broke the record for number of slides. This talk was not as fast paced, but I enjoyed it a lot more. It was one of those talks that instantly started firing neurons in my brain, mostly because I hadn’t really thought a lot about using Git for storage in an app. Examples Scott gave were git-wiki, ticgit, sqlgit and grit (which powers github).

Jamis Buck

Jamis did a presentation on how to say goodbye to the enterprise and embrace Ruby’s idioms. I didn’t really come from the enterprise but that is not to say that I don’t have bad habits. He had a couple of good quotes.

I was on the dependency injection horse and riding it for all it was worth.

I’m not into dependency injection but that cracked me up. If you don’t know what DI is, it’s ok as Jamis said you are probably better off.

Code just in time, not just in case.

This hit home. Often times I think what I might need down the rode but I always end up with a more complex solution than when I just create something that I need. It is far easier to add more code than to remove code at a later date.

The Evening

There are always a few presentations that really get me thinking, but the best part of any conference is hanging out with people who share the same passions. In the evening, I went out to eat at Chili’s with Ryan Daigle, James Avery and Corey Haines. We had some rousing discussions about perfectionism, getting stuff out there, building apps, ideas, blogging and advertising.

Conclusion

I have found it really interesting what a hot topic threading is this year. I have recently been reading up on Threads in ruby and how they work and I will post some stuff here at some point. It is kind of interesting to see how each conference kind of ends up with an overall theme, despite the lack of collaboration between presenters and no theme being stated by conference organizers.

Last year I blogged some suggestions for RubyConf. I have no idea if it helped but the name tag font size was markedly larger and it seems like things are starting a bit later. Not 10 but today’s talks started at 9:30 which is far easier to ~~stumble~~ stroll into. That is all for day one. Nunemaker out.

Testing Merb Controllers with RSpec

2008-10-28T18:45:00Z

In which I discuss AstroTrain, a Merb/DataMapper, email web hook app and how I added a users controller with specs to it.

I think web hooks are sweet. The idea of making micro apps that take the pain out of typically painful things and allow for ridiculous re-use is really intriguing to me. In my receiving email research, I came across a few web hook apps that work with email (ie: MailHook). Who wants to keep messing with postfix for every app they want to receive email with? I don’t, that is for sure. That is why I got pretty stoked when I saw technoweenie start working on an email web hook app astutely named AstroTrain. I almost immediately forked it and started playing around.

Astrotrain is written with Merb and DataMapper. Merb has changed a lot since I last played with it so it took me a while to get my bearings. Now that I have, I’m feeling more comfortable, yet still occasionally frustrated. Because the API has changed so much, it’s kind of hard to find up to date examples of how to get things done in Merb. I’m not going to go in depth on why I did what I did, but I thought I would show the simple users controller I added to Astrotrain and the specs to make sure it is behaving. If there are any Merbists out there who have suggestions for making this more merb-ish, let me know in the comments and I’ll update accordingly.

app/controllers/users.rb

class Users < Application
  before :ensure_authenticated
  before :ensure_admin

  def index
    @users = User.all
    render
  end

  def show(id)
    @user = User.get(id)
    raise NotFound unless @user
    @mappings = @user.mappings
    render
  end

  def new
    @user = User.new
    render
  end

  def create(user)
    @user = User.new(user)
    if @user.save
      redirect url(:users), :message => {:notice => "User was successfully created"}
    else
      render :new
    end
  end

  def edit(id)
    @user = User.get(id)
    raise NotFound unless @user
    render
  end

  def update(user)
    @user = User.get(params[:id])
    raise NotFound unless @user
    if @user.update_attributes(user)
      redirect url(:users), :message => {:notice => "User was successfully updated"}
    else
      render :show
    end
  end

  def destroy(id)
    @user = User.get(id)
    raise NotFound unless @user
    if @user.destroy
      redirect url(:users)
    else
      raise InternalServerError
    end
  end
end

spec/controllers/users_spec.rb

require File.join(File.dirname(__FILE__), '..', 'spec_helper.rb')

describe "UserNotFound", :shared => true do
  before do
    User.stub!(:get).and_return(nil)
  end

  it "should raise NotFound" do
    lambda {
      do_request
    }.should raise_error
  end
end

describe Users do

  describe "GET index" do
    def do_request
      dispatch_to(Users, :index) do |controller|
        controller.stub!(:ensure_authenticated)
        controller.stub!(:ensure_admin)
        controller.stub!(:render)
      end
    end

    it "should be successful" do
      do_request.should be_successful
    end

    it "should assign users for the view" do
      users = [mock(:user), mock(:user)]
      User.should_receive(:all).and_return(users)
      do_request.assigns(:users).should == users
    end
  end

  describe "GET show" do
    before do
      @user = mock(:user)
      @mappings = [mock(:mapping)]
      @user.stub!(:mappings).and_return(@mappings)
      User.stub!(:get).and_return(@user)
    end

    def do_request
      dispatch_to(Users, :show, :id => 1) do |controller|
        controller.stub!(:ensure_authenticated)
        controller.stub!(:ensure_admin)
        controller.stub!(:render)
      end
    end

    it "should be successful" do
      do_request.should be_successful
    end

    it "should assign user for the view" do
      User.should_receive(:get).with('1').and_return(@user)
      do_request.assigns(:user).should == @user
    end
  end

  describe "GET show (with missing user)" do    
    def do_request
      dispatch_to(Users, :show, :id => 1) do |controller|
        controller.stub!(:ensure_authenticated)
        controller.stub!(:ensure_admin)
        controller.stub!(:render)
      end
    end

    it_should_behave_like 'UserNotFound'
  end

  describe "Get new" do
    before do
      @user = mock(:user)
      User.stub!(:new).and_return(@user)
    end

    def do_request
      dispatch_to(Users, :new) do |controller|
        controller.stub!(:ensure_authenticated)
        controller.stub!(:ensure_admin)
        controller.stub!(:render)
      end
    end

    it "should assign user for view" do
      User.should_receive(:new).and_return(@user)
      do_request.assigns(:user).should == @user
    end

    it "should be successful" do
      do_request.should be_successful
    end
  end

  describe "POST create (with valid user)" do
    before do
      @attrs = {'login' => 'jnunemaker'}
      @user = mock(:user, :save => true)
      User.stub!(:new).and_return(@user)
    end

    def do_request
      dispatch_to(Users, :create, :user => @attrs) do |controller|
        controller.stub!(:ensure_authenticated)
        controller.stub!(:ensure_admin)
        controller.stub!(:render)
      end
    end

    it "should assign new user" do
      User.should_receive(:new).with(@attrs).and_return(@user)
      do_request.assigns(:user).should == @user
    end

    it "should save the user" do
      @user.should_receive(:save).and_return(true)
      do_request
    end

    it "should redirect" do
      do_request.should redirect_to(url(:users))
    end
  end

  describe "POST create (with invalid user)" do
    before do
      @attrs = {'login' => ''}
      @user = mock(:user, :save => false)
      User.stub!(:new).and_return(@user)
    end

    def do_request
      dispatch_to(Users, :create, :user => @attrs) do |controller|
        controller.stub!(:ensure_authenticated)
        controller.stub!(:ensure_admin)
        controller.stub!(:render)
      end
    end

    it "should assign new user" do
      User.should_receive(:new).with(@attrs).and_return(@user)
      do_request.assigns(:user).should == @user
    end

    it "should attempt to save the user" do
      @user.should_receive(:save).and_return(false)
      do_request
    end

    it "should be successful" do
      do_request.should be_successful
    end
  end

  describe "GET edit" do
    before do
      @user = mock(:user)
      @mappings = [mock(:mapping)]
      @user.stub!(:mappings).and_return(@mappings)
      User.stub!(:get).and_return(@user)
    end

    def do_request
      dispatch_to(Users, :edit, :id => 1) do |controller|
        controller.stub!(:ensure_authenticated)
        controller.stub!(:ensure_admin)
        controller.stub!(:render)
      end
    end

    it "should be successful" do
      do_request.should be_successful
    end

    it "should assign user for the view" do
      User.should_receive(:get).with('1').and_return(@user)
      do_request.assigns(:user).should == @user
    end
  end

  describe "GET edit (with missing user)" do    
    def do_request
      dispatch_to(Users, :edit, :id => 1) do |controller|
        controller.stub!(:ensure_authenticated)
        controller.stub!(:ensure_admin)
        controller.stub!(:render)
      end
    end

    it_should_behave_like 'UserNotFound'
  end

  describe "PUT update (with valid user)" do
    before do
      @attrs = {'login' => 'jnunemaker'}
      @user = mock(:user, :update_attributes => true)
      User.stub!(:get).and_return(@user)
    end

    def do_request
      dispatch_to(Users, :update, :id => 1, :user => @attrs) do |controller|
        controller.stub!(:ensure_authenticated)
        controller.stub!(:ensure_admin)
        controller.stub!(:render)
      end
    end

    it "should assign user" do
      User.should_receive(:get).with('1').and_return(@user)
      do_request.assigns(:user).should == @user
    end

    it "should update the user's attributes" do
      @user.should_receive(:update_attributes).and_return(true)
      do_request
    end

    it "should redirect" do
      do_request.should redirect_to(url(:users))
    end
  end

  describe "PUT update (with invalid user)" do
    before do
      @attrs = {'login' => ''}
      @user = mock(:user, :update_attributes => false)
      User.stub!(:get).and_return(@user)
    end

    def do_request
      dispatch_to(Users, :update, :id => 1, :user => @attrs) do |controller|
        controller.stub!(:ensure_authenticated)
        controller.stub!(:ensure_admin)
        controller.stub!(:render)
      end
    end

    it "should assign new user" do
      User.should_receive(:get).with('1').and_return(@user)
      do_request.assigns(:user).should == @user
    end

    it "should attempt to update the user's attributes" do
      @user.should_receive(:update_attributes).and_return(false)
      do_request
    end

    it "should be successful" do
      do_request.should be_successful
    end
  end

  describe "PUT update (with missing user)" do    
    def do_request
      dispatch_to(Users, :update, :id => 1) do |controller|
        controller.stub!(:ensure_authenticated)
        controller.stub!(:ensure_admin)
        controller.stub!(:render)
      end
    end

    it_should_behave_like 'UserNotFound'
  end

  describe "DELETE destroy" do
    before do
      @user = mock(:users, :destroy => true)
      User.stub!(:get).and_return(@user)
    end

    def do_request
      dispatch_to(Users, :destroy, :id => 1) do |controller|
        controller.stub!(:ensure_authenticated)
        controller.stub!(:ensure_admin)
        controller.stub!(:render)
      end
    end

    it "should find the user" do
      User.should_receive(:get).with('1').and_return(@user)
      do_request
    end

    it "should destroy the user" do
      @user.should_receive(:destroy).and_return(true)
      do_request
    end

    it "should redirect" do
      do_request.should redirect_to(url(:users))
    end
  end

  describe "DELETE destroy (with missing user)" do    
    def do_request
      dispatch_to(Users, :destroy, :id => 1) do |controller|
        controller.stub!(:ensure_authenticated)
        controller.stub!(:ensure_admin)
        controller.stub!(:render)
      end
    end

    it_should_behave_like 'UserNotFound'
  end
end

I haven’t really spec’d everything. I should probably add stuff to make sure it doesn’t work if the user is not authenticated or is not an admin. It might even be good to test the views a bit, though they are pretty simple. Hope this helps others starting to dive into the 1.0 merb release candidates.

AstroTrain is only really ready for the brave but rest assured that when it is ready to hit the big time, I’ll post here again with a how to get it running and integrated with your app.

Using Gmail with IMAP to Receive Email in Rails

2008-10-27T15:20:00Z

In which I show how to use Gmail with IMAP to receive email in a Rails, thus avoiding having to configure or setup Postfix.

The number one article suggestion thus far is how to receive email in a rails app. Ask and you shall receive. What I am about to present is just a first run at it and I am not going to promise that it scales. :) That said, I fooled around with it a bit and found it relatively easy. I will post more on the topic as I play more with receiving email, but what follows is enough to at least get you up and running. The email address I used for this is actually a Gmail address, so using this method does not involve postfix or some other mail server configuration.

The Project

The project that I added email receiving functionality to was YardVote, a weekend project by my friends at Collective Idea. YardVote allows people to record a “yard” with the political signs that were present in said yard and displays them on a google map. I was immediately enamored with the idea but found entering signs on my iPhone to be a bit tedious. Giving that everyone seems to be interested in receiving email, that it would be handy for yardvote, and that yardvote was open source, I decided to take a crack at it.

The Process

The path to success in summary form was this:

Check for new emails
Create new or update existing location from each email
Archive emails that have been processed to avoid duplicates
Turn process of checking and processing email into daemon

bin/mail_receiver.rb

For whatever reason, I created a bin directory and a mail_receiver.rb script inside of that. Actually, it was for a reason. I think bin seems like a good place for stuff like this. I could have used the script directory, but I figured I would leave that for Rails and plugins. I will over comment the code below to help with any parts of it that may raise questions.

# default rails environment to development
ENV['RAILS_ENV'] ||= 'development'
# require rails environment file which basically "boots" up rails for this script
require File.join(File.dirname(__FILE__), '..', 'config', 'environment')
require 'net/imap'
require 'net/http'

# amount of time to sleep after each loop below
SLEEP_TIME = 60

# mail.yml is the imap config for the email account (ie: username, host, etc.)
config = YAML.load(File.read(File.join(RAILS_ROOT, 'config', 'mail.yml')))

# this script will continue running forever
loop do
  begin
    # make a connection to imap account
    imap = Net::IMAP.new(config['host'], config['port'], true)
    imap.login(config['username'], config['password'])
    # select inbox as our mailbox to process
    imap.select('Inbox')

    # get all emails that are in inbox that have not been deleted
    imap.uid_search(["NOT", "DELETED"]).each do |uid|
      # fetches the straight up source of the email for tmail to parse
      source   = imap.uid_fetch(uid, ['RFC822']).first.attr['RFC822']

      # Location#new_from_email accepts the source and creates new location
      location = Location.new_from_email(source)

      # check for an existing location that matches the one created from email source
      existing = Location.existing_address(location)

      if existing
        # location exists so update the sign color to the emailed location
        existing.signs = location.signs
        if existing.save
          # existing location was updated
        else
          # existing location was invalid
        end
      elsif location.save
        # emailed location was valid and created
      else
        # emailed location was invalid
      end

      # there isn't move in imap so we copy to new mailbox and then delete from inbox
      imap.uid_copy(uid, "[Gmail]/All Mail")
      imap.uid_store(uid, "+FLAGS", [:Deleted])
    end

    # expunge removes the deleted emails
    imap.expunge
    imap.logout
    imap.disconnect

  # NoResponseError and ByResponseError happen often when imap'ing
  rescue Net::IMAP::NoResponseError => e
    # send to log file, db, or email
  rescue Net::IMAP::ByeResponseError => e
    # send to log file, db, or email
  rescue => e
    # send to log file, db, or email
  end

  # sleep for SLEEP_TIME and then do it all over again
  sleep(SLEEP_TIME)
end

Location#new_from_email

The only piece of code that you might need to help what I showed above make sense is the Location#new_from_email method.

class Location < ActiveRecord::Base
  def self.new_from_email(source)
    attrs, email = {}, TMail::Mail.parse(source)
    # set signs attribute equal to subject in proper form
    attrs[:signs]   = email.subject.blank? ? '' : email.subject.downcase.strip.titleize
    # set street equal to the body with email signatures stripped
    attrs[:street]  = parse_address(email.body)
    # create new location from the attributes
    new(attrs)
  end

  def self.parse_address(body)
    body.split("\n\n").first
  end
end

Location#new_from_email Specs

While working on the new_from_email method, I created an emails directory inside fixtures that had several ways an email could be sent to YardVote. Then, I created a few specs to make sure that new_from_email was actually working.

describe Location do
  describe "#new_from_email" do
    it "should be subject" do
      location = Location.new_from_email(email_fixture(:red_no_subject))
      location.should have_error_on(:signs)
    end

    it "should require body" do
      location = Location.new_from_email(email_fixture(:red_no_body))
      location.valid?
      location.errors.full_messages.should include("We can't find a precise enough address match.")
    end

    it "should set street to email body" do
      location = Location.new_from_email(email_fixture(:red))
      location.street.should == '1600 Pennsylvania Ave. Washington, D.C.'
    end

    it "should set sign equal to subject" do
      location = Location.new_from_email(email_fixture(:red))
      location.signs.should == 'Red'
    end

    it "should work with mixed case subject" do
      location = Location.new_from_email(email_fixture(:red_mixedcase_subject))
      location.signs.should == 'Red'
    end

    it "should work with upper case subject" do
      location = Location.new_from_email(email_fixture(:red_uppercase_subject))
      location.signs.should == 'Red'
    end

    it "should work with multi line body" do
      location = Location.new_from_email(email_fixture(:red_address_two_lines))
      location.valid?
      location.to_location.to_s.should == "1600 Pennsylvania Ave Nw\nWashington, DC 20006" 
    end

    it "should work with multi line body and email signature" do
      location = Location.new_from_email(email_fixture(:red_address_two_lines_sig))
      location.valid?
      location.to_location.to_s.should == "1600 Pennsylvania Ave Nw\nWashington, DC 20006" 
    end
  end
end

bin/mail_receiver_ctl.rb

Now that I could check for new email and process that email, it was time to daemonize the script. The benefit of daemonizing is that you get nice and easy start, stop and restart commands, along with a PID. The PID makes monitoring your script possible, which is needed because it is bound to crash or begin sucking up to much memory.

require 'rubygems'
require 'daemons'
dir = File.dirname(__FILE__)
Daemons.run(dir + '/mail_receiver.rb')

What, you wanted more? Now you can run commands like ruby bin/mail_receiver_ctl.rb start to start your script and ruby bin/mail_receiver_ctl.rb stop to stop it. Very handy.

config/mail.god

The whole setup was running fine for a while, but sure enough, a few days later, I noticed that a few of my emails were still sitting in the inbox. This was because the script had crashed. I fiddled around with god a little bit and came up with the following script, mostly stolen from Ryan Bates Railscast on god.

RAILS_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))

God.watch do |w|
  # script that needs to be run to start, stop and restart
  script          = "ruby #{RAILS_ROOT}/bin/mail_receiver_ctl.rb" 
  # attaching rails env to each script line to be sure the daemon starts in production mode
  rails_env       = "RAILS_ENV=production" 

  w.name          = "mail-receiver" 
  w.group         = "mail" 
  w.interval      = 60.seconds
  w.start         = "#{script} start #{rails_env}" 
  w.restart       = "#{script} restart #{rails_env}" 
  w.stop          = "#{script} stop #{rails_env}" 
  w.start_grace   = 20.seconds
  w.restart_grace = 20.seconds
  w.pid_file      = "#{RAILS_ROOT}/log/mail_receiver.pid" 

  w.behavior(:clean_pid_file)

  w.start_if do |start|
    start.condition(:process_running) do |c|
      c.interval = 10.seconds
      c.running = false
    end
  end

  w.restart_if do |restart|
    restart.condition(:memory_usage) do |c|
      c.above = 100.megabytes
      c.times = [3, 5]
    end

    restart.condition(:cpu_usage) do |c|
      c.above = 80.percent
      c.times = 5
    end
  end

  w.lifecycle do |on|
    on.condition(:flapping) do |c|
      c.to_state = [:start, :restart]
      c.times = 5
      c.within = 5.minute
      c.transition = :unmonitored
      c.retry_in = 10.minutes
      c.retry_times = 5
      c.retry_within = 2.hours
    end
  end
end

Conclusion

Two hours, three files and a few extra methods later, YardVote could receive email. Before too long, I will be adding custom email addresses per person into an application such as Flickr and Highrise. I will be sure to post on that here, but, for now, I hope this helps people get started. Also, you can see the code actually implemented in the app on github.

I think we need to get more knowledge share on how to do things like this in Rails. If you have added receiving emails into your Rails app, how did you do it? Post a comment or link to an article that you wrote or used. Below are a few of the articles I have seen around the interwebs.

Receiving Email in Rails links

Free Conference Ticket

2008-10-22T19:50:00Z

In which I give away a free conference pass to the first commenter interested.

I received a complimentary pass to the Voices That Matter Professional Ruby Conference in Boston November 17-20. I am going to RubyConf at the beginning of the month so I am going to pass on the free pass. If you are wanting to go for free, leave a comment and I’ll contact you by email. First come first serve, no hoops to jump through or contests to win. I’d feel horrible letting a free ticket to anything go to waste.

The core conference costs $995, so this is a pretty sweet deal. You can read more about the conference on the website. Also, if you do not get the free pass, you can use the priority code PR2MAL4 to receive a $200 discount, as already mentioned by the fine folks over at Rails Spikes.

Update: 10/24/2008 – The ticket has been claimed.

Public Indecency, Protect Your Bits and Don't Touch My Privates

2008-10-22T05:20:00Z

In which I discuss method visibility and the subtle difference between protected and private in hopes of clearing things up for those new to ruby.

One thing that I remember as confusing when I was starting out in ruby was “protected.” I understood the difference between private and public, but I remember protected seeming mysterious for quite a while. In the same vein as my class and instance variables article, I’ve decided to throw some examples together in hopes that those new to ruby will find it helpful. If I miss anything or am flat out wrong on something, let me know in the comments.

Public

If you don’t explicitly state private or protected, your methods are public. This is pretty easy to understand and the code samples below show that public methods can be called for an instance of a class, in an instance of an unrelated class and in an instance of an inherited class. In other words, you can call a public methods wherever you want.

class A
  def foo
    puts 'foo in A'
  end
end

a = A.new
a.foo

class B
  def foo
    puts 'foo in B'
    a = A.new
    a.foo
  end
end

b = B.new
b.foo

class C < A
  def bar
    puts 'foo in C'
    foo
  end
end

c = C.new
c.bar

# Outputs: 
# foo in A
# foo in B
# foo in A
# foo in C
# foo in A

Private

Private methods are named that for a reason. It means that they are private to the class they belong to and cannot be used outside of that class, without using send.

class A
  private
    def foo
      puts 'foo in A'
    end
end

a = A.new
a.foo

# NoMethodError: private method ‘foo’ called for ...

Likewise, as one would expect, subclassing and attempting to use a private method outside of the class definition will result in much of the same.

class A
  private
    def foo
      puts 'foo in A'
    end
end

class B < A
end

b = B.new
b.foo

# NoMethodError: private method ‘foo’ called for ...

Valid Private Uses

You can however use private methods inside of a class definition and inside of a subclass definition.

class A
  def bar
    puts 'bar in A'
    foo
  end

  private
    def foo
      puts 'foo in A'
    end
end

class B < A
  def baz
    puts 'baz in B'
    foo
  end
end

a = A.new
a.bar

b = B.new
b.baz

# Outputs:
# bar in A
# foo in A
# baz in B
# foo in A

Protected

Protected is similar to private but has one quite subtle difference. Like private, protected cannot be used outside of the class definition.

class A  
  protected
    def foo
      puts 'foo in A'
    end
end

a = A.new
a.foo

# NoMethodError: protected method ‘foo’ called for ...

class B < A
end

b = B.new
b.foo

# NoMethodError: protected method ‘foo’ called for ...

Also, like private, you can use protected inside of a class definition as long as it is wrapped with a public method.

class A  
  def bar
    puts 'bar in A'
    foo
  end

  protected
    def foo
      puts 'foo in A'
    end
end

a = A.new
a.bar

class B < A
  def baz
    puts 'baz in B'
    foo
  end
end

b = B.new
b.baz

# Outputs:
# bar in A
# foo in A
# baz in B
# foo in A

The Subtle Difference

This is where the weird part of protected comes in. You can instantiate a class and call a protected instance method on that class inside of a subclass and things will work just fine.

class A  
  protected
    def foo
      puts 'foo in A'
    end
end

class B < A
  def baz
    puts 'baz in B'
    a = A.new
    a.foo
  end
end

b = B.new
b.baz

# Outputs:
# baz in B
# foo in A

The same is not true of private, however, and you will end up with a NoMethodError.

class A  
  private
    def foo
      puts 'foo in A'
    end
end

class B < A
  def baz
    puts 'baz in B'
    a = A.new
    a.foo
  end
end

b = B.new
b.baz

# Outputs:
# baz in B
# NoMethodError: private method ‘foo’ called for ...

More on Method Visibility

Jamis Buck posted a great article on this a while ago. I am hoping the fact that I did not use metaprogramming in my examples will help those who are just starting out and might not understand the syntax in Jamis’ post. That said, his article is definitely worth a read as well.

Giving Mailers, Observers and Sweepers Their Own Space

2008-10-20T15:35:00Z

In which I post my first screencast on RailsTips all about an alternate way of structuring mailers, observers and sweepers in rails.

I can admit it. I am not a huge fan of video on the web, mostly because you cannot scan a video and I am a big time scanner. That said, Peepcode and Railscasts have shown me where video can really be leveraged to help someone understand a concept that would take too long to write a post about. Well, I decided to give it a whirl. I am not happy with the overall quality of the video, but it is good enough for now. I’ll work on video settings and such as I go along.

Videos Will Have Their Own Pages

Putting a video in the content column here would force a video too small to be worth watching, so I will be setting up separate pages for concepts that would be better covered with video. These pages will include code samples, related links and the embedded video. Do not worry, there is not another feed to subscribe to. Each time I make a screencast, I will be sure to create a related article here.

The First Railstips Screencast

Ok, enough of that, on to the first screencast for RailsTips. I have never really liked having my mailers, observers and sweepers all pushed into app/models, especially that mailers use views in app/views. Over that past months, I have amalgamated some stuff I picked up on the web and started using that instead. Let me know if you find the video helpful or have suggestions for improvements.

Giving Mailers, Observers and Sweepers Their Own Space

Who Done What? a.k.a. User Stamping

2008-10-17T16:30:00Z

In which I discuss how to automatically stamp your models with who done it.

Something I do in every app I create is add creator_id and updater_id to nearly every model. As created_at and updated_at are known as timestamping, I refer to my creator and updater attributes as “user stamping.” The annoying part is in every controller I had to assign those attributes to the currently logged in user. This isn’t a big deal but I’m lazy so I started to look for solutions.

Thread.current

The first thing that popped into my head was Thread.current. Thread.current is basically a hash that allows you to assign thread-safe key value pairs for the current thread. My thought, based on some research, was to wrap Thread.current[:myapp_user_id] with User.current so I could just use User.current in any active record model. Only problem is that smelled a little bit and I figured would be frowned upon by the community as you really shouldn’t access request stuff in your models like that. You can read more about threads and Thread.current if you want.

Solution: Sweeper

I brainstormed a bit with Brandon Keepers and he suggested a few things. Eventually, we decided on a sweeper as they have access to controllers which would have access to the current user. Tada! User Stamp, the plugin, was born. I whipped it together last night (< 50 LOC), added a few specs, and put it up on github this morning.

Installation

Installation is uber predictable.

script/plugin install git://github.com/jnunemaker/user_stamp.git

Once plugin is installed and user_stamp call with list of models to track in application.rb.

class ApplicationController < ActionController::Base
  user_stamp Post, Asset, Job
end

If you actually want to access this stuff through associations and show it in your app you could do something like this:

class Post < ActiveRecord::Base
  belongs_to :creator, :class_name => 'User'
  belongs_to :updater, :class_name => 'User'
end

Then, say in a view, you could do the following:

<h1><%=h @post.name %></h1>

<div><%= @post.content %></div>

<p>Posted by <%=h @post.creator.name %></p>

Let me know what you think in the comments. Bugs can be reported in lighthouse.

Suggest a Topic Today

2008-10-15T03:09:00Z

In which I beg you, the fair reader, to suggest topics for me to cover. Go on, it won’t hurt. I promise.

I get inspiration for topics on my own, but I thought I would also open it up to the populace. If you have a topic you’d like me to write about here, let me know. I’ve setup a topic forum on uservoice. I also put a link in the header of this site that links to the uservoice forum.

I’ve seen several applications try this out and I’m curious to see if it works for blogs. If I don’t get anything over the next while I’ll take it down, but who knows, maybe you all have some good ideas. If there is anything you don’t know how to do or would like to learn more about in ruby or rails, suggest a topic today.

Update (Oct 15): Wow. Already 10 topics suggested. All of them seem worthy of a post too. Fun thing is I’ll have to do some research for a couple of them as I’m not even up on the topic.

How To Generate PDFs in Rails With Prawn

2008-10-14T02:42:00Z

In which I show how to use the new kid on the ruby pdf generation block, prawn, with rails.

It’s been a while since I’ve needed to generate a PDF in ruby. I typically discourage clients from it because, well, I’m lazy and it’s a pain. I’ve always kind of hated pdf generation. It has always felt a tad awkward, be it in PHP, ColdFusion (6, unfortunately before cfdocument) and even Ruby. This time around, I decided to try out the new kid on the block, Prawn. On the website I just linked to, they recommend the prawnto plugin, so I gave it a whirl. My conclusions are that they work pretty well. Granted, I was just creating some text and formatting it, but I got up and running quickly. For your enjoyment, I’ll cover some basics below.

Create and Install

Note: I’m assuming Rails 2.1+. Fire up terminal and create a new app and install the prawnto plugin.

rails prawn_demo
sudo gem install prawn
script/plugin install git://github.com/thorny-sun/prawnto.git

Now add prawn as a dependency in environment.rb.

config.gem 'prawn'

For the sake of the demo we’ll need some demo data. Let’s create a Book model with some columns that we can shove lorem ipsum into.

script/generate scaffold book title:string author:string description:text
rake db:migrate

BooksController#show Example

I ran over to The Pragmatic Programmer’s site and snagged a few titles to enter as test data. Let’s get started with something simple and add a pdf version of the show action. Open up the books controller and add format.pdf { render :layout => false } so that the action looks something like this:

def show
  @book = Book.find(params[:id])

  respond_to do |format|
    format.html # show.html.erb
    format.xml  { render :xml => @book }
    format.pdf { render :layout => false }
  end
end

Now if you visit http://localhost:3000/books/2.pdf, you’ll get a template is missing error. Let’s add the show view. The prawnto plugin adds all the wiring, so all you need to do is create the show.pdf.prawn file inside app/views/books. For now, lets hello world that mofo with the following:

pdf.text "Hello World!"

Now if you revisit that url, you’ll get a pdf that says hello world. Simple, eh? Let’s make the view specific to the book and tweak the look a bit.

pdf.font "Helvetica" 
pdf.font.size = 13
pdf.text "Book: #{@book.title}", :size => 16, :style => :bold, :spacing => 4
pdf.text "Author: #{@book.author}", :spacing => 16
pdf.text @book.description

The first two lines set the default font stuff. As you can see, pdf.text takes a string and then a hash of options. :size adjust the font size, :style changes the weight, and :spacing controls the space between lines. Pretty self-explanatory, but I thought I would cover it anyway.

BooksController#index Example

Now let’s create a pdf of all the books with each book on it’s own page. Add format.pdf { render :layout => false } to the respond to block in the index action and create the following index.pdf.prawn view:

pdf.font "Helvetica" 
pdf.font.size = 13

@books.each do |book|
  pdf.text "Book: #{book.title}", :size => 16, :style => :bold, :spacing => 4
  pdf.text "Author: #{book.author}", :spacing => 16
  pdf.text book.description
  pdf.start_new_page
end

So the examples I showed were pretty basic and there is a lot more you can do with prawn, but I didn’t feel like coming up with examples. Helpers work just like in views which is handy. Also, prawn does images and data tables in a pretty simple manner. Check out the prawn and prawnto websites for more.