Isaac Kearse

Remote thumbnails with Imagery

2010-02-15T00:00:00-08:00

Just a quick heads up to let you know I posted to our new company blog about generating thumbnails remotely with Heroku and Imagery. Check it out here, I’ll be writing more about work related stuff there so subscribe if you’re interested.

SafariRSS - HotCocoa Safari RSS Handler

2010-02-07T00:00:00-08:00

I use Safari as my primary browser and Google Reader (and Byline) for reading feeds. Subscribing to feeds was painful for me for a long time until I discovered Reader Notifier. Reader Notifier will sit in your status bar and notify you when you have new feed entries to read. You can also set it as your Default RSS reader in Safari and it will redirect you to Google Reader when you click the RSS button. This felt like overkill to me. My status bar is sacred, and I don’t need to be notified throughout the day about new feed entries. What I needed was a HotCocoa application that just did the bare minimum. Enter SafariRSS.

The Competition

Halfway through coding this app I was googling for some info on NSAppleEventManager and came across a remarkably similar project called Reader Helper. This is a good example of one of the benefits of using MacRuby & HotCocoa, with SafariRSS weighing in at around 25% of Reader Helper in terms of lines of code. On the flip side Reader Helper weighs in at less than 1% of the download size of SafariRSS if we bundle MacRuby with the application. Anyway I’m glad this project existed, as I was able to translate some of the code into MacRuby very easily.

Usage

Download SafariRSS and then go into Preferences in Safari and select it as the Default RSS reader:

Go to an awesome website and click on the RSS button on the right hand side of the Address Bar:

Wait a few seconds and you will be redirected to Google Reader with the option of subscribing to the feed in question:

Changing the redirect to another URL or launching another application should be a trivial exercise, here is the entire app:

begin
 require 'hotcocoa'
rescue LoadError
  require 'rubygems'
  require 'hotcocoa'
end

class Application

  include HotCocoa
  
  def start
    application :name => "SafariRSS" do |app|
      eventManager = NSAppleEventManager.sharedAppleEventManager
      gurl = 'GURL'.unpack('N').first
      eventManager.setEventHandler self, andSelector:"getURL:reply:", forEventClass:gurl , andEventID:gurl
    end
  end
  
  def getURL(event, reply:reply)
    url = event.paramDescriptorForKeyword('----'.unpack('N').first).stringValue.gsub('feed://', 'http://')
    NSWorkspace.sharedWorkspace.openURL NSURL.URLWithString("http://www.google.com/reader/view/feed/#{url}")
    NSApplication.sharedApplication.terminate nil
  end
  
end

Application.new.start

I’m not totally happy with how long it takes to launch the app and redirect to the URL, but all the apps I tried seem to take a similar length of time so I don’t think its an issue with MacRuby. Any ideas on how to speed it up would be much appreciated.
Checkout the source on GitHub and let me know what you think. I have only tested this app on MacRuby 0.5 but it will probably work on 0.6 also. As usual you can find a version with MacRuby bundled in the downloads section of the GitHub repo. I tried to make embedding MacRuby a little easier with this app, but I’ll go into the details of that in a future post.

Packaging A HotCocoa Application

2010-02-01T00:00:00-08:00

HotCocoa is a thin, idiomatic Ruby layer that sits above Cocoa and other frameworks. HotCocoa used to be included in MacRuby but is now managed as a separate gem. Developing a HotCocoa application with TextMate and Terminal is a lightweight and expressive alternative to using Xcode and Interface Builder and I encourage everyone to give it a shot. Now that HotCocoa is hosted on GitHub forking and sending pull requests is probably the easiest way for a lot of people to contribute to the MacRuby ecosystem.

Getting Started

Getting started with HotCocoa from the Terminal is a breeze:

  sudo macgem install hotcocoa
  hotcocoa demo
  cd demo
  macrake

These commands will install HotCocoa, create a skeleton demo application and launch the application, which should look something like this:

Distribution

Packaging up a HotCocoa app for distribution is also dead simple:

  macrake deploy

This task will copy the entire MacRuby Framework, including the HotCocoa gem, into the application bundle ready for download as a self-contained app.

When I was packaging up Stopwatch for download I decided to not include the standard library and cut down the size of the app from around 150MB to 30MB. This turned out to be harder than I expected. Rubygems is part of the standard library and since HotCocoa is now a gem I had to embed HotCocoa into the app without requiring Rubygems. Here are the two rake tasks that unpack HotCocoa and embed MacRuby in the application without the standard library:

  task :unpack do
    `macgem unpack hotcocoa` unless File.directory? "hotcocoa-0.5.1"
  end

  task :embed => [:clean, :unpack, :build] do
    `macruby_deploy --no-stdlib --embed "#{AppConfig.name}.app"`
  end

We also need to make sure HotCocoa is added to the application bundle by adding it to the sources in config/build.yml

  name: Stopwatch
  load: lib/application.rb
  version: "1.0"
  resources:
    - resources/**/*.*
  sources: 
    - lib/**/*.rb
    - hotcocoa*/lib/**/*.rb
  agent: true

And finally, require HotCocoa at the top of lib/application.rb

  require File.join(File.dirname(__FILE__), '..', 'hotcocoa-0.5.1', 'lib', 'hotcocoa')

So now embedding MacRuby & HotCocoa without the standard library is as simple as running:

  macrake embed

All zipped up the entire application is around 10MB.

Building

I also made a small modification to the HotCocoa application builder so that Stopwatch could run as an agent in the background. When I was trying to build my forked version of the HotCocoa gem I got this nasty error:

  macgem build hotcocoa.gemspec 
  ERROR:  While executing gem ... (IOError)
      not opened for reading
  not opened for reading (IOError)

A workaround for this is to use the MRI gem command for building and then macgem for installing:

  gem build hotcocoa.gemspec && sudo macgem install hotcocoa-0.5.1.gem

Stopwatch - A HotCocoa Status Bar Timer

2010-01-31T00:00:00-08:00

At work we use a job management web app called WorkflowMax. This product has a huge array of features but I mostly just use it for tracking the time I spend on client work. It ships with a javascript timer in the web app that is probably sufficient for most people, but I wanted to be able to work offline. They have an API so this seemed like a great excuse to build a MacRuby & HotCocoa application.

I decided Stopwatch should be a simple menu that lives in the status bar. On startup it will ask you for your WorkflowMax credentials:

WorkflowMax were kind enough to give me a demo account that people can use to try out the application. If you would like to play along at home you can use these credentials:

- Account Key: B65C7527334C4892A96549DBC7B88FB7
- Email Address: isaac@kearse.co.nz

Once you have entered your credentials in the Preferences panel and clicked Save, you should see an interface like this:

From right to left the drop down menus will show all your clients, all the jobs for a client and all the tasks for a job. When you click on the task “Design” on the left the timer will start and display a clock and task description in your status bar:

The timer will increment every minute and when you click on it you will be presented with a few options:

You can enter some notes about the task you’re working on, stop the task or start another task (which will also stop the current task). If the task is stopped the time you have worked will be written to disk in xml format, and then posted to the server when you have an internet connection.

Once stopped the task will stay in the status bar and to start it again you can just click start:

Download

You can ownload a self contained app here: http://github.com/isaac/Stopwatch/downloads, or find the source on github here: http://github.com/isaac/Stopwatch. If you want to build the app from source I recommend you install the latest MacRuby nightly build first.

I have bundled a slightly modified copy of the HotCocoa gem into Stopwatch and pushed my changes upstream. Also bundled with the app are a few other libraries: macruby-httpwrapper by Matt Aimonetti and aixmlserialize by Justin Palmer.

I’ll talk more about the technical aspects of the app in later posts, so let me know if there is anything you would like me to cover. Developing a MacRuby app with HotCocoa was a great experience and I was more than happy to have a holiday from Interface Builder and Xcode. If only I could develop iPhone & iPad apps in TextMate and Terminal!

Asynchronous Table Views With MacRuby

2010-01-10T00:00:00-08:00

Developing the initial UI for BirdWatch was relatively pain-free. After I put aside my fear and distrust of Interface Builder and figured out how everything fitted together with outlets and delegates it all came together quickly. This is roughly what it looked like:

Each search query in BirdWatch is an atom feed stored as an instance of PSFeed by the PubSub framework. When you click on the “macruby” query highlighted in blue above, the entries for that feed are sent to the table view on the right. Each entry in the feed is an instance of PSEntry and corresponds to one row in the table view. Each row is represented by the class Status:

class Status

  attr_accessor :image, :text

  def initialize(entry)
    @image = NSImage.imageNamed 'NSUser'
    @text = entry.content.plainTextString
  end
  
end

The instance variables @image and @text populate the left and right cell of each table view row respectively.

These are all simple method calls to local resources so its no suprise this table view loads and scrolls very quickly. But its a little boring, lets see what happens when we add some more visual interest and interactivity.

Twitter Profile Pictures

My first priority was to add twitter profile pictures to spice things up and show at a glance the author of each status message. Unlike the status text, the profile image is not stored locally by the PubSub framework and will need to be downloaded from twitter. First we find the URL of the picture in the status xml. In this case I want a bigger version so I do a gsub on the string returned. Then I construct a NSURL instance and finally create and return the image:

class Status

  attr_accessor :image, :text

  def initialize(entry)
    links = entry.XMLRepresentation.nodesForXPath '//link[@type="image/png"]', error:nil
    href = links.first.attributeForName("href").stringValue.gsub '_normal.', '_bigger.'
    @image = NSImage.alloc.initByReferencingURL NSURL.URLWithString(url)
    @text = entry.content.plainTextString
  end

end

At this point my application grinds to a halt and the beach ball of death becomes a constant companion. The initial loading time for each query is very slow, and trying to scroll through a large list of status messages is extremely painful. It seems downloading the profile images from twitter is blocking the UI and causing the application to become unresponsive.

Asynchronous NSURLConnections

Cocoa provides great support for asynchronous requests which we can leverage to download the profile images in the background and keep the app responsive. You may recognise some of the code below from the excellent hotcoca tutorials on the MacRuby site. The approach I’ll use here is to load the system-provided image when an instance of Status is first initialized. Then just before the cell is displayed on the screen I’ll kick off an asynchronous request to download the image from twitter, update the instance variable @image and reload the cell. Here is the method we will use in the table view delegate to start the request:

def tableView(view, willDisplayCell:cell, forTableColumn:column, row:row)
  if cell.image && cell.image.name == "NSUser"
    status = @entries[row]
    status.download do |data|
      status.image = NSImage.alloc.initWithData data
      view.reloadDataForRowIndexes NSIndexSet.indexSetWithIndex(row), columnIndexes:NSIndexSet.indexSetWithIndex(0)
    end
  end
end

So first we are checking if this is an image cell and if the cell is still holding the placeholder image. Then we retrieve the status that corresponds to this cell and call the method “download” on that status. The download method takes a block which will return the downloaded data asynchronously. This is where MacRuby really shines: putting a simple DSL on top of a complicated Cocoa class. Here is what the Status class looks with the download method and friends added:

class Status

  attr_accessor :image, :text

  def initialize(entry)
    @image = NSImage.imageNamed 'NSUser'
    @text = entry.content.plainTextString
    @loading = false
    @data = NSMutableData.new
    @url = url entry
  end

  def url(entry)
    links = entry.XMLRepresentation.nodesForXPath '//link[@type="image/png"]', error:nil
    href = links.first.attributeForName("href").stringValue.gsub '_normal.', '_bigger.'
    NSURL.URLWithString href
  end

  def download(&block)
    return if @loading
    @loading = true
    @block = block
    request = NSURLRequest.requestWithURL @url
    NSURLConnection.alloc.initWithRequest request, delegate:self
  end

  def connection(connection, didReceiveResponse:response)
    @data.setLength 0
  end

  def connection(connection, didReceiveData:data)
    @data.appendData data
  end

  def connection(connection, didFailWithError:error)
    @loading = false
  end

  def connectionDidFinishLoading(connection)
    @block.call @data
    @loading = false
  end

end

Before a download is started the @loading instance variable is checked to ensure we don’t try and start an extra request for the same object. During the request the data returned is appended to the @data instance variable and when it has finished @data is passed back to the original block in the table view delegate.

With this code in place the interface is snappy no matter how terrible your internet connection is, which is important if you are living in rural New Zealand. It’s also a lot easier on the eyes to see profile pictures in full colour and makes the content much more engaging.

Now to deal with that status message text: where are the links? who is talking? how long ago?
That will have to wait for another blog post because you would be shocked if you knew how long this has taken me to write.

You can have a look at the entire BirdWatch application on github here: http://github.com/isaac/BirdWatch. I have simplified some of the code above for readability. Please feel free to fork away and send patches or open up an issue on GitHub if you come across any problems or have any feature requests. I recommend installing the latest MacRuby nightly before you try to build and run the app from Xcode. If you don’t have the latest MacRuby nightly installed you can download a version with MacRuby embedded in the app from here: http://github.com/isaac/BirdWatch/downloads.

Meet BirdWatch - MacRuby Twitter Search

2010-01-01T00:00:00-08:00

[UPDATE] If you don’t have the latest MacRuby nightly installed you can download with a version with MacRuby embedded in the app from here: http://github.com/isaac/BirdWatch/downloads.

I’ve been following MacRuby with interest for a while and after watching the Meet MacRuby screencast from PeepCode I decided a twitter search client would be a good learning project.

To keep everything as simple as possible I decided to use the Twitter Search API in conjunction with the Publication Subscription Framework. Every search query made from the app becomes an atom feed, which is parsed, stored and updated by the PubSub framework.

You can get the source here and download the app here. I had a few issues embedding MacRuby into the application so you currently need MacRuby installed to run the app, if this is an issue for anyone let me know and I’ll sort it out.

Future plans include a Mail.app style unread count for each search, a transition from Interface Builder to hotcocoa for the UI and possibly integrating web views somehow to remove the complexity of building up attributed strings for each status message.