spiral_code

Meet Rack::UpsideDownTernet

Jeff Tucker — Thu, 01 Apr 2010 02:17:48 +0000

One of my coworkers recently tweeted his interested in a Rack-compliant version of the upside-down-ternet. Inspired by the upcoming April Fools’ Day, I took the challenge and created Rack::UpsideDownTernet. Check it out at GitHub!

Fun Stuff

Just like the original, this middleware downloads all the images on a page, transforms them with ImageMagick (-flip is the default transformation) and renders out the updated images. Pure. Simple. Fun.

Setup is just like any other middleware. Bonus: set your own image transformations!

# environment.rb
require 'rack_upside_down_ternet'
config.middleware.use Rack::UpsideDownTernet, '-blur 10 -flip'

Broken Stuff

Uses curl instead of just grabbing the file out of the images directory
Doesn’t even kinda work with remote/absolute URL images
Requires unicorn (or any multi-worker setup). Make sure you have at least 2 workers running, as your first request will block curl from downloading images
Requires that you create PROJECT_DIR/tmp and PROJECT_DIR/images/mod

Some Unicode tips for Ruby

Jeff Tucker — Wed, 24 Mar 2010 01:54:01 +0000

I recently released a Japanese word search builder (see the discussion in the Hacker News post). This was my first foray into the world of multibyte characters, and I quickly discovered the pain involved in simply printing “ありがと” to the screen. Below are some of the details I found to help me through this trial.

Tips to make your Unicode+Ruby experience easier

Read James Edward Gray’s Understanding m17n series. Every word. Period.
If at all possible, use Ruby 1.9+. As James describes, Unicode support is far better than in 1.8.x.
In spite of Ruby 1.9′s superior Unicode support, it still doesn’t read files as UTF8 by default. This means that loading any files which include Unicode characters will cause Ruby to lash out at you with complaints about multi-byte characters. To get around this, set the file’s encoding type at the start of the file.
```
# encoding: UTF-8
... unicode goes here ...
```
If you can’t use 1.9, make sure you use the Jcode library. It’s included with Ruby and adds lots of useful Unicode-oriented features to String and Regexp. The only disadvantage is that the original methods remain in place (e.g., you’ll have to make sure you call String#jsize rather than String#size).
```
require 'jcode'
"ありがと".size
# => 12
"ありがと".jsize
# => 4
```
If you plan for your Ruby file to be run directly, make sure you add the -KU flag to your shabang line. This will tell Ruby to be open to UTF8 data.
```
#!/usr/local/bin/env ruby -KU
... Ruby goes here ...
```
Familiarize yourself with iconv — both the Ruby library and the command line tool. This tool will allow you to translate data easily between various character encodings.
While not strictly required these days, it’s still recommended when serving HTML with Unicode data to set the content type both in a meta tag on the page and the in HTTP header.
```
HTTP/1.1 200 OK
Server: nginx/0.6.39
Date: Wed, 24 Mar 2010 00:39:47 GMT
Content-Type: text/html; charset=utf-8
...




...
```

Lightning-Quick Redis Viewer

Jeff Tucker — Sat, 27 Feb 2010 21:34:10 +0000

I’ve had the opportunity to work with the Redis datastore this week. If you’re not familiar with it, Redis is a blindingly-fast, in-memory key-value store. It supports several nice features such as string, list and set support (complete with set operations) and the ability to persist data to disk. Check out the official site for lots more info.

My project revolved around data collection, and I pretty quickly ran into the need to see what I was actually shoving into the database. After 10 minutes and only ~50 lines, I came up with a Sinatra backed Redis viewer. See the code below, or check out my gist on Github!

# app.rb
require 'rubygems'
require 'haml'
require 'sinatra'
require 'redis'

helpers do
  def redis
    @redis ||= Redis.new
  end
end

get "/" do
  @keys = redis.keys("*")
  haml :index
end

get "/:key" do
  @key = params[:key]
  @data = case redis.type(@key)
  when "string"
    Array(redis[@key])
  when "list"
    redis.lrange(@key, 0, -1)
  when "set"
    redis.set_members(@key)
  else
    []
  end
  haml :show
end

# views/index.haml
%html
%body
  %h1 Current Keys
  %ul
    - @keys.each do |key|
      %li
        %a{:href => "/#{key}"}= key

# views/show.haml
%html
%body
  %h1= "Data stored in '#{@key}'"
  %ul
    -@data.each do |data|
      %li
        %p= data

Testing Sunspot with Cucumber

Jeff Tucker — Sat, 06 Feb 2010 19:07:43 +0000

I’ve been using Sunspot as my full-text search provider for a few months now. It’s a very enjoyable library — it hooks itself into Rails, provides an extension to disable itself in RSpec and even throws in a few convenient rake tasks. This fun came to a quick end, though, when I started delving into Cucumber again. Any feature involving finding a Sunspot-enabled item failed completely, but without any helpful errors. After a shameful amount of time banging my head against the desk, I finally got everyone to play nicely.

The Code

Let’s just drop the code in and discuss it afterwards:

# config/sunspot.yml
# copy the test settings into the cucumber environment
test: &TEST
  solr:
    hostname: localhost
    port: 8981
    log_level: WARNING

cucumber:
  <<: *TEST

# features/support/config.rb
# start the Solr server and give it a few seconds to initialize
Sunspot::Rails::Server.start
sleep 5

# make sure that pickle calls #index! on our appropriate models
require File.join(File.dirname(__FILE__), 'pickle')
module Pickle
  module Session

    def create_model_with_sunspot(a_model_name, fields = nil)
      result = create_model_without_sunspot(a_model_name, fields)

      model = model(a_model_name)
      model.index! if model.respond_to?(:index!)

      result
    end
    alias_method_chain :create_model, :sunspot

  end
end

# clean out the Solr index after each scenario
After do
  Post.remove_all_from_index!
end

# shut down the Solr server
at_exit do
  Sunspot::Rails::Server.stop
end

The Details

This method was heavily influenced by Brandon Keeper’s post on using Cucumber with ThinkingSphinx. Thanks Brandon! So in my setup, I’m using Sunspot, Cucumber and Pickle (see Ryan Bates’ railscast on using Pickle with Cucumber for more details on the wonderful Pickle gem).

First and foremost is getting the testing Solr server running. It will look for settings in config/sunspot.yml according to the environment we’re running in, so we need to duplicate the test environment for cucumber. I’ve found that it takes 3-5 seconds for Solr to properly spin up, so we’re sleeping for a few seconds to avoid the problem.

Next we need to ensure that each model gets loaded into Solr’s index when created. If you’re instantiating models on your own, this boils down to calling #index! on any models that you create. Since I’m using Pickle (and didn’t want to rework the included pickle_steps.rb), I needed a bit more invasive measure. A bit of alias_method_chain voodoo lets me call #index! on every instantiated model that responds to it. This ensures that Pickle always adds it’s models to Solr’s index. I was pleased to find that I didn’t have to disable transactional fixtures

Finally, we need to ensure that our index is fresh for each scenario, so we clear the Solr index out after each scenario is run. If you want a more targeted approach, you can use

# features/support/config.rb
# clear Solr index only if we've actually used it
After('@sunspot') do
  Post.remove_all_from_index!
end

to only clear the Solr index after stories which are tagged with @sunspot. Once all the stories are run, shut down the server. Viola!

Now on Tumblr

Jeff Tucker — Sat, 06 Feb 2010 14:59:14 +0000

Much to my own distaste, I’ve been slowly migrating towards becoming a link-blog (see examples 1, 2, 3 and 4). I enjoy sharing random pages with the community, but feel that (what’s intended to be) a technical blog isn’t necessarily the best medium. Fortunately, I saw someone mention tumblr over the weekend, and after a 3-minute setup, I’m now using tumblr for all my link-blogging needs! You can follow all of my linky goodness there from now on, and I’ll save this blog for actual posts (which I’m well overdue on anyway).

Announcing Git Pivotal

Jeff Tucker — Sat, 30 Jan 2010 21:30:48 +0000

Using git effectively

Like most of the developer blogosphere, I was thoroughly excited to read Vincent Driessen’s post on branch management in git. It captured a simple and repeatable methodology for extracting a great deal of power from git without having to really dive down into its belly. Given that Vincent’s methodology relies heavily on feature and bugfix branches, I began looking for techniques on combining Pivotal Tracker — which I’ve been using recently for all of my project management needs — with git. I found some advice in Rein Henrichs’ article which suggests using Pivotal Tracker story ids as branch identifiers, but not much else on how to really tighten the two together.

Moving towards smoother integration

Further Googling didn’t reveal any tools to aide my new objective, so I set out to create my own toolkit. After a few evenings digging through Pivotal Tracker’s API (which actually changed from v2 to v3 while I worked ), I’m ready to announce my work: Git Pivotal. It’s a very alpha release currently, but I have some work in development that will (hopefully) stabilize it soon.

Git Pick

The first (and currently only) tool is git pick. After some simple configuration, this will grab your top-most available feature story from Pivotal Tracker, display some simple info about it and offer to create a feature branch for it off of your current branch.

What’s coming

I plan to add some additional commands for marking current feature branches as finished, managing bugs and bugfix branches and possibly integrating release stories as well. If you’re a fan of git and Pivotal Tracker, keep an eye on this project!

So what do you think? Is this useful? Share your thoughts below!

Links! (v4)

Jeff Tucker — Sat, 23 Jan 2010 03:30:19 +0000

More linky goodness. Also, I’d like to thank David Trasbo and Maxim Chernyak for picking up my post on my experiences with the Rails Bugmash. Thanks for the link-love guys!

Case Study: Continuous deployment makes releases non-events — A developer shares his experiences with continuous deployment. Perhaps a bit aggressive for my blood, but it’s a very interesting technique.
A successful Git branching model — A fantastic write-up on using git effectively. Plus it has pretty pictures! I know how much you love pretty pictures.
The Real Reason Outsourcing Continues To Fail — I hope to not run into the issue of outsourcing at all, but I’m more well-prepared now if I do.
Active Record Query Interface 3.0 — @lifo details the exciting new finder methods for Rails 3. Super impressive stuff.
Realism in UI Design — I’m fascinated by principles of design right now. @lkm shines light on a subtle but interesting point.

Rails Bugmash 2010

Jeff Tucker — Sat, 16 Jan 2010 23:47:37 +0000

The Rails Bugmash 2010 is well under way. I’ve compiled a few notes about what I’ve seen.

will_paginate

The current version of the gem (v2.3.12) doesn’t work, as it relies on the now-removed scope method. It looks like there’s a fork out there which resolves the issue, but it hasn’t been merged into master yet.

Formtastic

The current version of the gem (v0.9.7) seems to work just fine. All you need is an initializer to set the gem up and load it into rails:

require 'formtastic'

# from formtastic's rails/init.rb
ActionView::Base.send :include, Formtastic::SemanticFormHelper

validation_reflection

You can use validation_reflection (v.0.3.1) with Formtastic by simply requiring it in the initializer:

require 'formtastic'

# from formtastic's rails/init.rb
ActionView::Base.send :include, Formtastic::SemanticFormHelper

require 'validation_reflection'

Authlogic

Not sure about the working state of the gem yet, but the 2.x style generator is clearly not working. I’ve forked Paul Berry’s list of Rails 3 generators and added a simple user session generator.
Edit: Actually, the gem doesn’t work either. Seems to rely on a before_persisting callback which isn’t there anymore.

Edit II: The before_persisting callback is actually built by Authlogic. It seems the Authlogic::Session::Base module isn’t loading callbacks like it should.

RSpec

This is also a no-go in Rails 3. David Chelimsky, being the always-on-top-of-it developer, is already planning for RSpec 2.0 as a working partner for Rails 3. No sign of it yet in the github repo though. If you’re interesting in playing around anyway, you can find some RSpec generators at the link above.

Bundler

The new gem bundler is indeed pretty sexy. Unfortunately, with all that great work it does, it doesn’t actually load the gems into your Rails environment. Neither do any of the config files (boot.rb, application.rb, etc etc). David Trasbo had some luck adding Bundler.require_env to the end of the environment.rb file bundler creates, though he’s run into load-order troubles. José Valim recommends placing the line at the end of application.rb to ensure the Rails core is loaded first. This takes care of loading all the gems, so you can skip the initializers above.

Links! (v3)

Jeff Tucker — Fri, 15 Jan 2010 01:09:12 +0000

I’ll write a real post one day. I promise.

Hacking DNS — A great guide to mixing DynDNS with PairNIC.
A review of the Mac mini with Snow Leopard Server — Considering getting one of these. Ars gives a great writeup.
Mocking and Stubbing can be evil — I’m still up in the air on the topic of test mocks. I have more to say about this soon.
Ten Rules for Web Startups — Never know when you may want to build a web startup.
Simple rules for good typography — I’m currently trying to learn more about design fundamentals. Some good pointers here.
You Release Late and Infrequently — As the lead developer on a death march of a web site, I find a great deal of encouragement in this article.
jQuery 1.4 Released: The 15 Features you Must Know — In case you’ve just woken from a coma, jQuery 1.4 is out. Nettuts gives a good roundup of some of the neat new features.

Links! (v2)

Jeff Tucker — Mon, 28 Dec 2009 22:50:24 +0000

Okay, I promise I’m not trying to start a link blog (I think). My browsers have just found themselves buried in tabs this month.

The Rails 3 Router: Rack It Up — A post from Yahuda Katz detailing some of the new capabilities awaiting us in Rails 3
Migrating to Snow Leopard for Rails Development – A Definitive Guide — This is old news by now, but I finally picked up Snow Leopard this weekend.
Learn You a Haskell for Great Good! — This circled the web a while back too, though I just ran into a few days ago. I have a few too many languages on my plate right now, so this one’s going on the shelf for a while.
How to obtain and install an SSL/TLS certificate, for free — Everybody likes free stuff.
Full Disclojure — A series of screencasts on learning Clojure!
beautifului — An exhibit of great web UIs [h/t @rbates]
Web Creme — A site highlighting inspiring web designs