That last feature has been particularly handy on Demozoo, which is currently hosted in borrowed space on a server that doesn’t really have 100-odd megabytes of free space for demo screenshots. However, attachment_fu comes a bit unstuck when you’re dealing with files that don’t come from a form upload – for instance, in my case I’m planning to have a scheduled task that leeches new productions and their screenshots from Pouët, and I’d quite like to take advantage of the Imagemagick-and-S3 goodness that attachment_fu brings. A bit of digging around was in order.

As the HowtoUploadFiles page on the Rails wiki helpfully explains, when you post a form containing a file upload field, it emerges on the Rails side as a sort-of IO object with a bunch of additional attributes: original_filename, content_type and length (in addition to the usual read method you expect from an IO object), and this is what the uploaded_data method (as implemented by attachment_fu) expects to be passed. According to Ruby’s principle of duck typing (i.e. it doesn’t have to actually be a duck, as long as it quacks like one and waddles like one), we therefore have to come up with our own sort-of IO object that behaves the same way, but with the data sourced from an HTTP fetch instead.

By a happy coincidence, the open-uri module from Ruby’s standard library returns a sort-of IO object that’s mutated in almost (but not quite) just the right way. It gives us content_type and length, but we’re still missing original_filename. Following the guidance of a rails recipe, I came up with the following code to tack that method on:

require 'open-uri'

class Screenshot < ActiveRecord::Base
  has_attachment(
    :content_type => :image,
    :resize_to => '400x300>',
    :storage => :s3
  )

  def source_uri=(uri)
    io = open(URI.parse(uri))
    (class << io; self; end;).class_eval do
      define_method(:original_filename) { base_uri.path.split('/').last }
    end

    self.uploaded_data = io
  end

end

The source_uri method is the bit we’re interested in; after getting back our IO object from open, we do some class-level fiddling (which, um, I don’t completely understand myself – I think it’s creating a subclass descending from the IO object or something) to define the missing method original_filename. (If your URLs are coming from somewhere unpredictable, like a web form, you might want to do something more robust than base_uri.path.split(‘/’).last – you might also want to deal with nil being passed as the URI.) We then pass our tweaked IO object off to the uploaded_data method, from where attachment_fu will start doing its stuff unaware that it isn’t really a form upload. Let’s see it in action then…

>> s = Screenshot.new(:source_uri => "http://www.pouet.net/screenshots/18890.jpg")
=> #<Screenshot id: nil, width: nil, height: nil, format: nil, size: nil,
content_type: "image/jpeg", filename: "18890.jpg">
>> s.save!
=> true
>> s.public_filename
=> "http://i-has-a-bucket.s3.amazonaws.com/1/18890.jpg"

There we go… one screenshot successfully uploaded to Amazon S3, without a form upload in sight! (And as a bonus, in theory open-uri ought to work just the same with FTP URLs as HTTP ones, if that floats your boat.)

The initial reception of the site has been mixed; there have been excited noises from people who have immediately seen its potential, and it’s already been useful for filling in those ‘dammit, what group is he in again’ memory lapses at the pub (as well as a cunning way to startle Smash on AssemblyTV, by introducing him as “Smash of jecoute” rather than his rather more well-known role in Fairlight). It’s also attracted some (not entirely unfair) comments that it’s basically a very unfinished clone of Pouët, to which I have three replies:

• Yes. Deadlines, party coding etc, mumble mumble, not enough time to add much data at all besides Pouët / add whizzy features other than the minimum necessary to make it work. *shuffles feet*
• Yes. But the massively important and really subtle difference is that it can handle individual people’s nicknames properly, even where they’re duplicated all over the place. (And that’s what’s taken two years to get right, pretty much.) For example, there are at least three people on the scene who go by the name of Simon and at least two groups called CPU, but if you enter a production by “Simon / CPU” then it knows exactly who you mean. And once you’ve got individual authors in the database, you can start indexing graphics and music. And if you don’t have to pick authors from a dropdown every single time, it becomes viable to enter a whole heap of complete party results in one sitting. Which will happen, soon.
• Yes. How about I stop trying to justify its existence right now, and work on it some more until it speaks for itself?

I like answer number 3 best.