loo.no - blog posts

Installing a Ruby dev environment on OSX

2010-11-21T16:06:56+00:00

I recently bought a new Macbook Air 13" (which is übercool btw), and took my time to set up my development environment properly. Here’s a recipe for setting up everything you need on a fresh OSX install, with some nice-to-have applications as well.

RVM

Although OSX comes with Ruby by default, you’re probably going to need different versions of Ruby sooner or later. RVM: Ruby Version Manager is a nice set of scripts, that enables you to switch between different versions of Ruby, including JRuby, REE, MRI and YARV. The basic installation is pretty straight forward, just run the following script and follow the post-installation instructions to run the required scripts upon opening a new bash shell.

bash < <( curl http://rvm.beginrescueend.com/releases/rvm-install-head )

After you’ve installed RVM, and loaded it, I recommend installing YARV (1.9.2) and set that as your default Ruby:

rvm install 1.9.2-head && rvm use 1.9.2 --default

Homebrew

Homebrew is a simple, yet powerful, package manager for OSX. It’ll allow you to easily install and manage different UNIX tools, pretty much like APT on Ubuntu. Installing Homebrew is pretty straight forward, except for the last step where you have to get the Apple developer tool, XCode.

Run this script to get Homebrew:

ruby -e "$(curl -fsSL https://gist.github.com/raw/323731/install_homebrew.rb)"

Then go download XCode from Apple. You’ll have to make an account, and download quite a large installation file. Uncheck everything except the base during the installation, unless you want the libs for iOS development and such.

Git

Git is a widely used VCS (Version Control System) amongst Rubyists, and you’ll need that for working with code on Github, the most popular host for open source Ruby projects. Since we’ve installed Homebrew, getting Git up and running on your machine is pretty easy:

brew install git

To configure Git for all your projects, you can add rules into ~/.gitconfig, this is how my config file looks like:

[user]
        name = Lars
        email = ovelar@gmail.com
[core]
        excludesfile = /Users/lars/.config/global-gitignore

The last line references a global gitignore file, where we’ll add files we know that we never want to check into our repositories. A basic gitignore file on OSX should atleast contain .DS\_Store, and you’ll probably add *.log as well.

MySQL

Installing MySQL with Homebrew is pretty straight forward as well:

brew install mysql
mysql_install_db

Post installation you will see a set of commands you can run to make MySQL start when you log in to your computer.

MongoDB

For my NoSQL adventures, I use MongoDB. For my production setup, I use a hosted service from MongoHQ, but I would recommend setting up a local instance for development and running tests. Installing MongoDB with Homebrew is also as easy as MySQL:

brew install mongodb

You’ll get the same output post installation, with two lines you have to run in order to have your MongoDB instance start up on login.

Editor

When it comes to editors, this is a matter of personal taste and a religious topic amongst programmers. When I got my first mac a year ago, I started using TextMate, which has been kind to me. Lately, I’ve started using MacVim, mostly because I wanted to have the same environment on my mac and ubuntu machine. Others might prefer emacs or even KomodoEdit. Anyways, you can install MacVim easily with Homebrew: brew install macvim

Nice to have utilitites

Visor allows you to have a roll-down terminal window on all your spaces.
Growl gives you pop-up notifications on your desktop, that can be utilized by things like AutoTest
GitX is a nice GUI for basic git stuff.
HyperDock enhances the default window manager in OSX
GithubNotifier gives you notifications (via growl) on new commits on you Github projects

Also, having a cool bash prompt is a must, this is what I use for my prompt which shows current ruby version (from RVM) and branch name if you’re in a Git repo:

PS1='\[\033[0;32m\]\u@\h\[\033[1;30m\] ($(~/.rvm/bin/rvm-prompt i v g))\[\033[0m\]\[\033[0m\] \[\033[1;33m\]\w\[\033[0m\]\[\033[1;37m\]$(__git_ps1 "[%s]")$ '

Happy hacking, and good luck with your new Mac :)

Installing Ubuntu 10.10 on a SATA-3 disk

2010-09-29T21:14:35+00:00

First, I have to brag about the specs for this little monster (compared to the old Core 2 Duo rig it’s replacing):

GA-X58A-UD3R motherboard
24GB of Corsair DDR3 1333mhz CL9 ram
Intel i7 950
Crucial RealSSD C300 2,5" 128GB SATA-3 (6gb/s)
Silverstone Fortress II miditower
Corsair HX 750W PSU
2 x Western Digitial Caviar® Green 2TB SATA2
Nvidia GTX 295

It’s a bit over-specced for web-development, but it sure is fast when running the cucumber test suite on the project I’m working on right now :)

I always install Windows before Ubuntu on a new rig, because I’m lazy enough to appreciate the automagic adding of the windows boot partition to grub. Installing windows on the SSD disk required it to be on a Sata-2 controller, and then switching to the Marvell 9128 chip once everything was installed.

However, when running the Ubuntu 10.10 installer for the first time, it only came up with my two Sata-2 drives at the partitioning step. Turns out, Ubuntu needs AHCI enabled for the Sata-3 controller in order to correctly identify the disks on it. AHCI, or Advanced Host Controller Interface, is a add-on for the Sata spec, which enables hot-plugging and native command queuing, as far as I know.

Enabling AHCI on the Marvell 9128 chip’s port 6-7 in the bios worked, and enabled me to install Ubuntu 10.10 beta without any more hassle. All devices working smoothly, and everything felt snappy and nice. However, when trying to boot Windows 7 again, I was getting this annoying and infamous BSOD (Blue Screen of Death). I rolled up my sleeves, and got to googling.

When you install Windows 7, which is the only windows version actually supporting AHCI, without any AHCI devices, Windows actually unloads the AHCI driver (which imo is a good thing). This resulted in my newly AHCI enabled system disk to be unreadable for Windows. Luckily, it’s pretty easy to re-enable the AHCI driver in Windows 7:

Shut down the machine, and turn off AHCI
Reboot into Windows 7 (Grub will still load)
Open regedit.exe, the equivalent of /etc/ on a *nix system
Navigate to HKEY_LOCAL_MACHINE/System/CurrentControlSet/Services/Msahci
Set it’s value to 0, and close regedit.
Reboot and celebrate

Now, you should have both Windows 7 and Ubuntu working perfectly alongside each other – and you can enjoy the awesomeness of having a Sata-3 system disk (Ubuntu uses 3 seconds (seriously) to boot on my rig).

Goodbye Google Wave

2010-08-07T04:50:24+00:00

It’s been over 12 months since I first tried Google Wave, and much has happened since that time. At first, it was compelling because Google promised they would “revolutionize the way we communicate”, and the open source nature of the protocol. In the first few months, I, as many others, struggled to find some good use-cases for this new platform, and stumbled around making silly robots but soon enough we found some good use for it.

For the past 6-7 months, Google Wave has been the platform for most of our day to day needs at Skalar. We’ve used it for project management, CRM, code reviews, brainstorming, knowledge base, issue tracking and so on. The last couple of months, we’ve even managed to get some of our customers and partners as active users.

What went wrong

Google Wave is brilliant in terms of communication and availability of the development team towards customers. It also provides the flexibility to be used (and abused) for almost anything you need – with a little imagination and patience. However, herein lies most of the “flaws” being pointed out by the people who didn’t embrace it.

When the beta-access started to roll out, nobody quite knew what to do with it, and being busy with other things and satisfied with their current collection of tools, they didn’t really give Wave a try. One of the commonly used arguments against Google Wave was that nobody of interest (customers, co-workers, average people (aka friends)) were there, and therefore it was no use to be there for you either. Instability and alpha versions of the web-client was probably the drop for those who never came back after their first visits.

However, Wave has changed rapidly over the past 12 months, becoming a more stable and refined platform. People can now be invited to and participate in a Wave without signing up for it, just by adding an email adress as you would normally to when sharing information with people. The web-client has improved a lot by adding wave-templates for common tasks, richer control over participants (yes, you can even remove people and give read-only permissions now!), gadgets have become more useful, and there are people with experience you can consult if you’re having trouble.

Sitepoint has a poll running now where 45% of the votes are against the shutdown, but these are mainly geeks that see the benefits of scrapping some of the old technologies like mail, the average user probably still wonders what google wave is/was.

No matter how much I, and 45% of sitepoint’s readers disagree with their decision, Google has decided to shut down wave early 2011. I still have a small hope that they will change their mind, but that’s probably not going to happen.

Wave lives on

Although Google is abandoning Wave, it is fully open sourced (except for the web client), and will therefore live on to some extent. There are some server implementations like PygoWave and RubyOnSails. And a couple of client implementations like WaveLook and the open sourced simple client from Google.

At their current state, none of these are production ready as far as I know, but hopefully they will get some momentum now that there’s a actual need for them.

Alternatives to Wave

What I’m looking for now, is a web-application that can cover all the stuff that Google Wave did. So far I’ve been checking out a couple of candidates, but none of them quite seem to have the flexibility that Wave had. This situation is like being given a Ferrari to drive for 12 months, then having it taken away. I want a new Ferrari-like car, but I don’t want to build it myself using bits and scraps from semi-good cars (lame analogy, I know, but you get the point).

What’s your take on the shutdown of Google Wave, and do you have some suggestions as to what application might be replacing it?

New design, new backend based on MongoDB

2010-08-06T21:39:10+00:00

I’ve remade the blog from scratch, again. This time I decided to not only give the front-end a overhaul, but also try out a NoSQL alternative to get some first-hand experience with it. While I’m polishing it, some things might be a bit weird, but hopefully everything should be readable and working as before.

I will do some articles later on some of the stuff I learned while coding this thing, but to put it short and sweet; I’ve had a great experience with developing using a combination of MongoDB (using Mongoid as my ORM), Compass and Rails 3 (beta 1,2,3,4 and RC :p).

This time I even managed to do it completely according to BDD, so every little function has green tests, and hopefully I’ll manage to keep it that way if I decide to add some more features.

Here’s some highlights:

Backend is now MongoDB running on MongoHQ
Frontend is valid HTML5, with some CSS3 styling
Comments system has been thrown away in favor of Disqus (sadly that removed “all” the old comments)
New design (with a color instead of just black & white)!

Thank you for taking the time to visit, and please leave some feedback in the comments if you have any!

Mirror images with Paperclip

2010-02-05T23:00:00+00:00

While implementing an awesome design, I needed to dynamically create a mirror effect on some thumbnails. Since I’m more or less dedicated to Paperclip, I decided to see if it could be done, without any monkeypatching. Here’s what I came up with.

First, I should explain my setup of Paperclip attachments in this project. Because I’m a bit lazy, I didn’t want to make too many migrations for every different type of attachment. Instead I created a STI class called PaperclipAttachment that is the base class of all the different types of attachments in this project

class CreatePaperclipAttachments < ActiveRecord::Migration
  def self.up
    create_table(:paperclip_attachments) do |t|
      t.string   :data_file_name
      t.string   :data_content_type
      t.integer  :data_file_size
      t.datetime :data_updated_at
      t.string :type
      t.references :container, :polymorphic => true
    end
  end
 
  def self.down
    drop_table :paperclip_attachments
  end
end

This class is defined as follows:

class PaperclipAttachment < ActiveRecord::Base
  # Relationships
  belongs_to :container, :polymorphic => true
 
  # Attributes
  attr_protected :data_file_name, :data_content_type, :data_file_size
 
  # Delegations
  delegate :path,:url, :to => :data
 
  # Extensions
  has_attached_file :data, { 
    :styles => lambda{|data| data.instance.class.attachment_styles},
    :processors => lambda{|instance| instance.class.processors},
    :path => ":rails_root/public/system/:class/:id_partition/:style/:basename.:extension",
    :url => "/system/:class/:id_partition/:style/:basename.:extension",
    :default_url => "/system/:class/defaults/missing_:style.png"
  }
 
  def self.attachment_styles
    {}
  end
 
  def self.processors
    [:thumbnail]
  end
end

The reason I’m proc’ing :styles and :processors, is that I want to be able to treat the different attachment styles differently. The file structure still stays logical, and the only “downside” I can see with this approach is that all attachments reside in the same table in the database.

So with this as the base for my project, I created a PDF class that inherits from this PaperclipAttachment class. I defined the different JPG snapshots of the PDF that I needed like this:

class Pdf < PaperclipAttachment
  def self.attachment_styles
    {
      :small_preview => { :geometry => '106x72>',  :format => :jpg },
      :preview =>       { :geometry => '297x210>', :format => :jpg }, 
      :big_preview =>   { :geometry => '460x300>', :format => :jpg }
    }
  end
end

So, it was time to implement the mirror effect. After considering making a processor for a bit, I decided to go with a less time consuming solution. Based on this shellscript from roundcube.net I started hacking on my Pdf class.

First, I added a couple of methods for getting the path and url of this mirror image. I wanted it to be connected to each Paperclip style, so I decided to put it in the same directory:

def mirror_path(style=:original)
  path(style).gsub(/.\w+$/,'') + '_mirror.png'
end
 
def mirror_url(style=:original)
  url(style).gsub(/.\w+(|\?\d+)$/,'') + '_mirror.png'
end

Then, the method that does the dirty work turned out like this. You can probably strip out half of it, but I wanted to have the height of the mirror effect snap to my current line-height, and some other semi-bloat stuff:

def mirror(args = {})
  style        = args[:style] || :small_preview
  infile       = args[:in] || path(style)
  outfile      = args[:out] || mirror_path(style)
  alpha        = args[:alpha] || 30
  line_height  = args[:line_height] || 18
  height_f     = 0.2
  width,height = Paperclip::Geometry.from_file(infile).to_s.split('x').collect(&:to_i)
  height       = ( (height * height_f) * ( 1.0 / line_height ) ).round / ( 1.0/line_height )
  geometry     = [width, height].collect(&:to_i).join 'x'
 
  command = "convert -size #{geometry} xc:none"
  command << " \\( \\( -flip #{infile} -crop #{geometry}+0+0 \\)"
  command << " -size #{geometry} gradient: -evaluate Pow 1.4"
  command << " -compose Copy_Opacity -composite \\) "
  command << " -compose blend -set \"option:compose:args\" #{alpha} -composite #{outfile}"
  
  warn "Mirroring: " + command if RAILS_ENV == 'development'
  
  system command
end

For configuration, I wanted to use the :styles hash provided by Paperclip. So I added a key called mirror on the styles I wanted to mirror:

{
  :small_preview => { :geometry => '106x72>',  :format => :jpg, :mirror => {:alpha => 30} },
  :preview =>       { :geometry => '297x210>', :format => :jpg, :mirror => {:alpha => 30} }, 
  :big_preview =>   { :geometry => '460x300>', :format => :jpg }
}

And then made a method to check which styles I should mirror, and call the mirror method:

def make_mirrors
  data.styles.each_pair do |style,style_hash|
    style_hash.select{|k,v| k == :mirror}.each{|k,v| self.mirror({:style => style}.merge(v))}
  end
  true
end

Voila! That’s the proof of concept that I’ve come up with so far, but I will probably refactor it a bit before putting it into production. Hopefully it’s of some use for someone else too :)

Bringing my blog into the new decade

2010-01-09T23:00:00+00:00

Being a new decade and all, I got some inspiration to do a little work on my blog again. This time I wanted to get up to speed with things, and make my markup valid HTML5. I also polished up the design a bit, adding some icons and stuff.

So far I haven’t really explored all the new features of HTML5 fully, but for now I’ll leave a few links to some good resources on the subject. Hopefully I’ll have an opportunity to play around with the more exotic features of HTML5 soon.

And btw, Happy new year :)

Easy zip generating with Rails, Nginx & Paperclip

2009-11-19T23:00:00+00:00

Tonight I decided to try making NGINX handle my zip generating, to save the server some work, and the user of some frustration waiting for background jobs to finish. Here’s what I came up with.

First of all, I re-compiled Nginx with two modules; mod_zip, and passenger module. You may drop the Passenger module if you are using some other server, this solution works with anything that can print out some text :)

Roughly, these are the required steps:

gem install passenger
cd nginx-folder/
.configure --add-module=/path/to/passenger/gem/ext/nginx --add-module=/path/to/mod_zip-1.x
sudo make && sudo make install

If you wonder where your passenger is, you can easily find the root of passenger by running

passenger-config --root

So on to the fun part! I started by adding a member method to my galleries route called zip:

ActionController::Routing::Routes.draw do |map|
  map.resources :galleries, :member => {:zip => :get}
end

And In my controller I added these two methods (it can probably be done cleaner, but hey, it’s working :) Suggestions for other ways of writing these are welcome!

class GalleriesController < ApplicationController
  def zip
    @gallery = Gallery.find(params[:id])
    paperzip(@gallery.images.collect(&:data), @gallery.name)
  end
  
  private 
    def paperzip( attachments= [], name= 'file', style= :original )
      # set headers
      response.headers["Content-Disposition"] = "attachment; filename=#{name}.zip"
      response.headers["X-Archive-Files"] = "zip"
  
      # Generate file list
      render :text => attachments.collect{|a| 
        ['-', File.size(a.path(style)), a.url(style,false), a.original_filename.gsub(/ /,'_')].join(' ')
      }.join("\r\n")+"\r\n"
    end
end

Whoa! Let me break that down for you a little bit. Firstly the member method zip, which now has the named route “zip_gallery_path(@gallery)” in you views btw:

def zip
  @gallery = Gallery.find(params[:id])
  paperzip(@gallery.images.collect(&:data), @gallery.name)
end

This basically finds our gallery from the :id param, and calls on this method we’re defining as private for this controller, called paperzip() (I know, catchy). paperzip() takes a collection of Images (which has_attached_file :data), a string containing a name for the zip file about to be made, and a symbol which you can use to zip down the style you want. I’m running with :original here.

Let’s move on to the next couple of lines:

response.headers["Content-Disposition"] = "attachment; filename=#{name}.zip"
response.headers["X-Archive-Files"] = "zip"

What we do here is setting some custom headers for our response back to the client, and Nginx. The content-disposition tells it we want the user to be prompted to download a file, called something.zip. The X-Archive-Files header is the one that makes mod_zip trigger, and eagerly await a list of files to zip down and send. Mod_zip requires a list of files that looks something like this:

md5 bytes /relative/path filename<linebreak>

Note that the linebreak needs to be a \r\n, and be on every line, even the last one. So, in order to construct this list, I added the following lines to the method, returning it using “render :text”

render :text => attachments.collect{|a| 
    ['-', File.size(a.path(style)), a.url(style,false), a.original_filename.gsub(/ /,'_')].join(' ')
  }.join("\r\n")+"\r\n"

And voila! Calling this action with a get request, will now trigger mod_zip and create us a fully working zip file. The good thing about using this over some other method, is that Nginx only uses a couple of kilobytes of that precious memory of yours while doing this, and does the job way quicker than any other method I’ve tried.

Practical use of Google Wave

2009-10-14T22:00:00+00:00

After playing around with wave in the developer preview, and giving it some thought, we tried the new beta version of Google Wave in a real-life scenario at the office today. Four of us were doing a sales effort (new experience), and found it to be a great tool for this purpose.

The case was that we wanted to do an effort on a backlog of leads and ideas by taking them one step further in the process. We started out by creating a Wave for each lead, inviting all the team members that were going to work on this.

Next thing was to get some organizing of these newly created waves. We solved it by tagging each of them with “lead” in the beginning, so we could create a saved search and clear them from our inboxes. In order to know who was responsible for the different leads, we also tagged the waves with our initials and created a saved search for our own leads.

And so the fun started. While I was working on my first lead, I needed some feedback on a few details from my colleague Guru, so I pinged him with a link to my lead wave and asked for some feedback. While I continued to work on another part of the same lead, I saw his comments coming in letter by letter, and responded quickly to some of them. This resulted in a very effective and quick dialogue and case solving method, and as a bonus we have a full log of how we came to the conclusions.

There have been a lot of people disbanding Google Wave lately due to it not being email, twitter, facebook or some other app. In my opinion, Google Wave is not the solution to all the quirks of our current tools, but as a simple group collaboration tool it’s so far the best I’ve tried. It will probably not replace Email or random IM in it’s current state, as many people (including myself) hope for, but it’s the thing in between that I didn’t know I was missing before I tried it.

I would love to hear about other success stories with using Google Wave for something useful. I found a few links to a few cheatsheets during our little session today, that you also might find useful:

Got my shiny new Macbook Pro 13" today!

2009-09-13T22:00:00+00:00

After some drooling over the recent macbooks that have been popping up all over the office during the summer, I finally got my own little shiny toy today. Thought I’d write a few words about my experience so far.

I’ve been playing around with my colleagues’ macbooks, and even owned two iPhones (I’m now a happy Android user btw), but it’s still something with the way Apple has packaged their gadgets that makes you feel like you’ve received some state-of-the-art space equipment. Needless to say – unpacking the macbook gave me that same “oooh, new gadget” feeling I like so much.

First thing I did after booting it up (and filling in all the boring details about me, myself, my work, hobbies and what I ate for breakfast, lunch and dinner) was to install Snow Leopard (fancy-talk for MacOS 10.6). The installation was pretty straight forward, and completed in under 1 hour.

Next big thing was installing TextMate – pretty much the whole reason that I got this Macbook in the first place tbh. I’ve envied all the happy ruby hackers with their Textmates up until now, so I can’t wait to try it out for myself. My primary use for this little shiny toy is development, so I needed to get all my ruby versions, gems and everything installed right away. Luckily for me, Mike Gunderloy wrote a complete guide to getting up and running with ruby development on Snow Leopard. After following his guide (skipping the backup & restore stuff since this is my first mac) I was up and running with all ruby versions, and enough gems to do a “rake gems:install” on my current projects.

To sum it all up; my first 6 hours as a macbook owner has been great. I’m having some difficulties getting used to the new way of navigating (loving the multi-touch pad btw), and installing applications. I’ve done a “sudo apt-get ” countless times the last couple of hours. Also, my original plan of switching some keys from this US version to norwegian letters failed brutally since the whole top of the chassis is different on the US version – so I’m learning a whole new keyboard layout as I go – no way I’m paying 4500 NOK (currently 760 USD) to get my æøå back!

Rounded corners with Paperclip

2009-08-09T22:00:00+00:00

When applying a new design to one of our projects, we were in a need of a Paperclip style with rounded corners. Luckily for us we had Paperclip’s :convert_options and strong ImageMagick-fu.

After trying out some different CSS hacks, and jQuery plugins for getting the rounded corner effects we wanted, we turned to Paperclip. Since this particular style of a photo was only to be used at one place in the new design, we could apply the rounded corners directly to the image.

I googled around a bit and found a fork of Paperclip by shadow11 with some changes that never made it into the official Paperclip repository. His approach was to add the rounded corner code into Paperclip itself, and provide a argument to has_attached called rounded. IMO that’s probably nice-to-have if you do a lot of rounded corners on your attachments, but probably not something most people need. So I went ahead and copy-pasted out the juicy parts from his commit.

Firstly, we need to make sure that the style we are applying rounded corners to is a PNG file, since that’s the only file-format we have on the web that’s capable of transparancy (which we’ll use for the rounded corners effect). So my initial User model (borrowed from the Paperclip example) looks like this:

class User < ActiveRecord::Base
  has_attached_file :avatar,
    :styles => { :medium => ["300x300>", :png],
                          :thumb =>  "100x100>" }
end

So, in order to get some corners stripped of this new PNG style, we need to utilize Paperclip’s convert_options, which allows us to give extra parameters to the ImageMagick convert command that Paperclip uses for resizing. The extra flags that does this job is as follows (I’m no ImageMagick pro-user, but a good copy-paster, and it actually works):

\( +clone  -threshold -1 -draw 'fill black polygon 0,0 0,5 5,0 fill white circle 5,5 5,0' \( +clone -flip \) -compose Multiply -composite \( +clone -flop \) -compose Multiply -composite \) +matte -compose CopyOpacity -composite

This adds a 5 pixel rounding to all four corners of our image, replacing the old ones with a transparent background.

In order to get this into my Avatar, all I had to do was to include this code in the hash being sent to has_attached (THE Paperclip command). While testing, I actually Proc’ed the convert_options and ended up with the code below, but that’s really not necessary, you probably want to roll your own something on this part. But here’s the full User model that’s working:


class User < ActiveRecord::Base
  has_attached_file :avatar,
                    :styles => { :medium => ["300x300>", :png],
                                 :thumb => "100x100>" },
                    :convert_options => {:medium => Proc.new{self.convert_options}}
 
  def self.convert_options
    trans = ""
    px = 20
    trans << " \\( +clone  -threshold -1 "
    trans << "-draw 'fill black polygon 0,0 0,#{px} #{px},0 fill white circle #{px},#{px} #{px},0' "
    trans << "\\( +clone -flip \\) -compose Multiply -composite "
    trans << "\\( +clone -flop \\) -compose Multiply -composite "
    trans << "\\) +matte -compose CopyOpacity -composite "
  end
end

And that’s all. The medium style of my attached Avatar is now rounded with nice 20px corners. Looking forward to implement this (in a cleaner way) on the project tomorrow.

My first Google Wave Robot: lobo-bot

2009-07-28T22:00:00+00:00

Since I’m a bit too tired to do anything useful (or useless) in either Python or Java, and these are the only two languages Google support as of now, I decided to hit Github in search for a ruby wrapper to the wave api. On my first search I found Rave, a JRuby wrapper for (parts of) the python API.

First I downloaded and installed JRuby and Google App Engine SDK, which was surprisingly easy. I’ve never really had a chance to test any of them, so it was interesting seeing what they were all about.

Setting up a new Rave robot is a breeze too. After installing the gem, you use this command to set it all up:

jruby -S rave create [robot_name] [options]

So, on to the hard part; coming up with an idea that was good enough to implement. Well, I failed at that part, and created a robot that edits all blips, and reverses words wrapped with @’s. Extremely useless, but fun to watch. Here’s the robot.rb for lobo-bot:

require 'rubygems'
require 'rave'
 
module LoboBot
  class Robot < Rave::Models::Robot
    ME = "lobo-bot@appspot.com"
    REGEXP = Regexp.compile '@\w+@'
    
    def document_changed(event, context)
      # Don't do anything if we triggered the event ourselves
      return if event.modified_by == ME
 
      context.blips.values.each do |blip|
        blip.content.scan(REGEXP).each do |match|
          # Find which range of the match
          range = blip.content.rindex(match)..blip.content.rindex(match)+match.length
          # Reverse!!
          blip.set_text_in_range(range, match.reverse)
        end
      end
    end
    
  end  
end

So… Well, it works, and I got to try out all of these new tools at once :-) For something a bit more useful, you can check out @senikk’s little robot who links all @names to their twitter accounts. I was thinking about porting it to Ruby, but unfortunately Rave doesn’t have set_annotation() method yet.

Hopefully I will come up with something more useful another day, but meanwhilst I recommend reading this stuff:

First Impressions of Google Wave

2009-07-27T22:00:00+00:00

So, I received an invitation to Google Wave yesterday, and I’ve been playing around with it quite a lot since that. One of the practical things about this sandbox access is that you actually get two users in the sandbox, one that is username@wavesandbox.com, and another called username-test@wavesandbox.com. This enables you to do some testing with yourself, and not having to bother everyone else with it.

Accounts at wavesandbox.com comes with Google Apps as well, so you have access to mail, docs, calendar and the regular Google Apps settings.

The Web interface looks very much like the Gmail interface, with some polishing. It’s three columns instead of the two in Gmail; on the left you have a navigation pane that lets you browse your waves by saved searches, folders, and some other. There’s also a settings menu under this pane, but this has not been implemented yet. In the middle you have a list over all waves in the category you’re in, which looks a lot like your inbox in gmail. On the right, you have the “show” view. This is where you view a selected wave, and can do all the magic editing, drag’n’drop of images etc. One very nice feature is that you can minimize “windows” within this web gui, to give more room to the ones you use at the moment.

Even though this is still a preview and it has some lacking features and a whole lot bugs, I can clearly see how this is going to be a liberation and replacement for most businesses that are currently using mail, forums, CRM systems, IM and other communication tools. Google Wave is all of these systems mixed together into awesomeness, plus a lot more.

Today (whenever I have some spare time) I will try to write my first robot to get to know the API a bit. Playing with the idea that Google Wave would be an awesome tool for collaborating on a CMS/Blog like this, so that will probably be my first little project.

Some other Google Wave articles worth reading:

Background processing with Paperclip

2009-07-26T22:00:00+00:00

I’m going to assume that you are familiar with Paperclip by now. If you’re not, you should download and implement immediately. The background daemon I’m using is delayed_job but you are of course free to use your weapon of choice. Ryan Bates recently did a nice screencast about delayed_job which I highly recommend (check out this Ascii-cast if you don’t like videos).

Ok, so on to the cool stuff, we start by making a table and all that:

class CreateImages < ActiveRecord::Migration
  def self.up
    create_table(:images) do |t|
    
      # default paperclip fields
      t.string   :data_file_name
      t.string   :data_content_type
      t.integer  :data_file_size
      t.datetime :data_updated_at
      
      # processing
      t.boolean :processing, :default => true
      
      # timestamps
      t.timestamps
      
    end
  end
  
  def self.down
    drop_table :images
  end
end

Pretty straight forward migration. The processing boolean is used to check whether a particular photo has been processed yet. It defaults to true, since we will always intercept Paperclip’s processing when a new Photo is added.

So let’s create an ImageJob, the little delayed_job gnome that will be doing all the dirty work.

class ImageJob < Struct.new(:image_id)
  def perform
    Image.find(self.image_id).perform
  end
end

This is a regular pattern for creating jobs in delayed_job. What it does is basically to (on perform) find the image in question, and call the instance method perform() on it which will do all the processing stuff. I normally add these jobs into lib/ since they’re not models per say.

In our Image model, we add the following:

before_data_post_process do |image|
  false if image.processing? # do not process if just added
end
  
after_create do |image|
  Delayed::Job.enqueue ImageJob.new(image.id) # add to queue
end

This utilizes Paperclip’s before_:attachment_post_process callback to halt the processing and just go through with the create action (save the record in db). After create, we add this Image to our delayed job queue.

Since it might take some time processing our Image, we add this little convenience method which serves two purposes; normally when using Paperclip you have to do model.attachment.url(:style) to get the url of the attachment, this method allows you to to model.url(:style). We are also able to return a default URL while processing the Image in the background.

def url(style = :original)
  if self.data && processing? && style != :original
    return data.send(:interpolate, @@default_url, "#{style}")
  end
  data.url(style)
end

So now we are ready to try out the actual processing, with this insanely advanced method on our Image model:

def perform
  self.processing = false # unlock for processing
  data.reprocess! # do the processing
  save
end

And that’s it. You can now start up your delayed_job queue listener, go into console and try out with a few files.

10.times { Image.create(:data => File.open('/home/lars/test.jpg')) }

Happy hacking :-)

Redirect all mails while developing your rails app

2009-07-26T22:00:00+00:00

The plugin is called MailBouncer, and is written by a colleague of mine, Trym Skaar. The installation is as easy as

config.gem "trym-mail_bouncer", 
  :lib => "mail_bouncer", :source => "http://gems.github.com"

in your environment.rb, or you can still do

gem install trym-mail_bouncer --source http://gems.github.com

After installing, go into $RAILS_ROOT/config/initializers/mail_bouncer.rb and do your setup

MailBouncer.configure do |config|
  config.enabled    = %w(development test).include? ENV["RAILS_ENV"]
  config.recipients = 'your@email.com'
end

And you’re done. All mails sent while being in development- or test-mode on your project will be redirected to your own debug mail account instead of out to your customers, and it will keep all headers intact so you can use it for debugging.

It has saved my day a couple of times already :-)

Gone surfin' (on Google Wave)

2009-07-26T22:00:00+00:00

After watching the video from Google I/O conference about Google Wave, and some hours of excited discussions and dreaming with my colleagues at the office, we all signed up for the Google Wave Sandbox program, hoping that one of us would get accepted.

I was the one who got lucky, and received an invitation to the sandbox today :D I’m really looking forward to many hours of exploring and coding in the weeks to come now. And the envy from my colleagues :P

Adding Exif data to your Image model with exifr

2009-07-26T22:00:00+00:00

I’m now using this great little gem called exifr in my project. It’s fairly nimble, but gets the job done. To include it in your rails project, add the following line in your config/environment.rb

config.gem "exifr"

You’ll also want to add some fields to the model you are saving the exif data to. The exif reading is quite fast so you might want to do it on-the-fly, but then you don’t get some new fields on your models for all those cool queries. Let’s add it to our Image model.

class AddExifFieldsToImages < ActiveRecord::Migration
  def self.up
    add_column :images, :width, :integer
    add_column :images, :height, :integer
    add_column :images, :camera_brand, :string
    add_column :images, :camera_model, :string
    add_column :images, :exposure_time, :string
    add_column :images, :f_number, :float
    add_column :images, :iso_speed_rating, :integer
    add_column :images, :focal_length, :float
    add_column :images, :shot_date_time, :datetime
  end
 
  def self.down
    remove_column :images, :width
    remove_column :images, :height
    remove_column :images, :camera_brand
    remove_column :images, :camera_model
    remove_column :images, :exposure_time
    remove_column :images, :f_number
    remove_column :images, :iso_speed_rating
    remove_column :images, :focal_length
    remove_column :images, :shot_date_time
  end
end

These are the fields I normally use, but there are probably more that are worth saving.

In order to get some data into these fields, we create this little method in our Image model:

def set_exif_data
  exif = EXIFR::JPEG.new( self.data.path )
  return if exif.nil? or not exif.exif?
  self.width            = exif.width
  self.height           = exif.height
  self.camera_brand     = exif.make
  self.camera_model     = exif.model
  self.exposure_time    = exif.exposure_time.to_s
  self.f_number         = exif.f_number.to_f
  self.iso_speed_rating = exif.iso_speed_ratings
  self.shot_date_time   = exif.date_time
  self.focal_length     = exif.focal_length.to_f
rescue
  false
end

In this example I get the path of the file from self.data.path, where data is my paperclip attachment called :data. If you have some other setup, you’ll have to change this to fit your needs.

Calling this method sets the fields to the correct values, but does not save the object. Using the setup with delayed_job from the last article you can a line in your perform() method to get exif data for all new Images, making the method as a whole like this:

def perform
  self.processing = false
  set_exif_data # this is the line we added
  data.reprocess!
  save
end

And voila, you now have added exif data to your images! Now it’s time to think out something cool to do with it…