My Professional Blog

In my continuing efforts to work Ruby and Rails into the Enterprise, I’ve been working on adapting Rick Olson and Josh Goebel’s Beast discussion forums engine. Its excellent work on their part and quite fun to play with.

My adaptations are:

• Modify user authentication to use our LDAP user repository — so users can just use their existing credentials
• Using YUI Reset, Fonts, and Grids throughout
• Modifying the markup to be slightly more semantic
• Adding Digg-style pagination
• Applying design inspiration from Odeo, SimpleBits, and Cork’d as well as others.

I’m not done yet, but its starting to look pretty decent. Here’s a peek:

We have been asked whether GeoKit could be made to support UK addresses and this is something that we’re interested in doing.  I must admit that I was incompletely uninformed as to how different these addresses really are.  Just have a look at Wikipedia has to say about UK addresses.  In specific, we’ve been asked to support this geocoding service: www.postcodeanywhere.co.uk.

So since we’re looking into this, I thought it might be a good idea to solicit other suggestions for geocoding services and address variants which GeoKit doesn’t already support, but which would be useful to the Rails community.  It appears there will be some refactoring involved, so it makes sense to do a little due diligence by broadening the input process.

So drop me or Andre a note or comment and let us know.

The recent GeoKit publicity has caused an influx of new visitors to this blog. Now that the traffic is subsiding somewhat, I thought I’d take a look at the geography of Rails. It seems an appropriate tangential GeoKit topic.

So have a look at the map. 44% of the traffic came from the United States — looks like the East Coast and West Coast primarily. Next, came Germany at close to 9% — Berlin mostly. Canada came in at 7%. 17% of the traffic came from smaller countries.

I find this pretty fascinating and definitely flattering that such a wide range of people would pay a visit to this blog.

We just checked in code which improves the readability of GeoKit’s finders. Its quite obvious from the code, so just take a look at these examples:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# Find the nearest store.
stores = Store.find(:nearest, :origin => an_origin)

# Find the farthest store away.
stores = Store.find(:farthest, :origin => an_origin)

# Find within a radius.
stores = Store.find(:all, :within => 5, :origin => an_origin)

# Find outside a radius.
stores = Store.find(:all, :beyond => 5, :origin => an_origin)

# Find within a range.
stores = Store.find(:all, :range => 5..10, :origin => an_origin)

Over at Earthcode, a request was made to enable the distance_between and distance_to methods to accept physical locations in pre-geocoded string form. I have added this improvement, so you can now do:

1
2
3
4
5
6
7

# Geocode from and to, then calculate the distance
# between them.
dist = Store.distance_between(“Irving, TX“, 
                              “San Francisco, CA“)

# Geocode the to, then calculate the distance to it.
dist = irving.distance_to(“San Francisco, CA“)

Andre has also added further flexibility to the :origin to include setting it to an array of lat / lng values. Usage looks like:

1
2
3

# Presumably some previous geocoding and then this:
stores = Store.find(:all, :origin => [37.792,-122.393], 
                    :conditions => ‘distance < 10‘) 

Keep the feedback coming!

I recently discovered CodeRay as a means to pretty up my Rails-based tutorial examples. But unfortunately, this blog runs under WordPress which is PHP-based, so I can’t use CodeRay here. Or can I?

While not the most seamless process, I now run my code examples through my CodeRay HTML Generator and then paste them into my WordPress posts. Since I use the same stylesheets for both apps, the styles are consistent.

If you have a similar scenario, feel free to use the generator yourself. I don’t keep any snippets…but won’t I see them on your blog anyway?

In the last couple of days, I added a couple of minor feature tweaks.

First, the finders will now all accept optional :units and :formula keys to enable you to override the units and formula used by the model by default. This makes it possible to serve distance queries in miles or kms and even to modify the formula used in the query. Overriding the formula might be important if you know the proximity is close and you don’t care about precise accuracy. It might also be helpful in the event that your dataset grows beyond that which would perform using the more taxing Haversine (:sphere) formula.

The second feature is a bit more subtle and edge case-like. If you steer away from our defaults and customize the lat / lng attributes, then the :origin was previously unable to handle taking an instance of those rows that you seek. I made a change to enable it to detect that situation. So now, you can do this. I did find one issue and that’s with the distance_from method which counts on lat / lng. Hopefully, I can add the same introspection and tidy that up as well. This will enable full customization for lat / lng attributes. Of course, you can write your own accessors to get around this, but still…

If you have any additional feedback, feel free to send Andre or I an email.

UPDATE: The update is complete, you can now compare the distance of Mappable instances which customize their lat / lng attributes when running as acts_as_mappable. If you don’t understand what this means, you probably don’t need the feature, so don’t sweat it.

This is a follow-up to my last post on distance queries in Rails. Since that post, I’ve enlisted the help of Andre Lewis at Earthcode.com to help super-charge the feature set. If you don’t know Andre, he’s the author of the upcoming book Beginning Google Maps Applications with Rails and Ajax, so I think he’s uniquely qualified.

The Rdoc is the best place to go to learn more. We’ve set it up on RubyForge. But just to whet your appetite, just imagine not having to code any nasty trigonometry into your SQL to include distance columns or conditions. Or imagine having ready access to Google, Yahoo, Geocoder.us, and Geocoder.ca geocoders separately or in a failover configuration. If that’s not enough, imagine integrating geocoders into your finders! For instance:

1
2
3

stores = Store.find(:all, 
                    :origin => “100 Spear St, San Francisco, CA“, 
                    :conditions => “distance < 10“)

where the origin value serves as the anchor for the distance calculation and gets geocoded on the fly.

All this is done through a declaration like this:

1
2
3
4
5
6

class Store < ActiveRecord::Base
  belongs_to :company
  
  # Enables distance calculations and sweet, clean distance queries.
  acts_as_mappable
end

The goal of the plug-in is to clean up client code for location-based applications. I think we’ve succeeded. Enjoy everyone!

I’m writing an application which has store locator-like use cases. If you’ve ever written anything like this, you know that the SQL can get quite messy. To keep my code clean and elegant, I’ve written a Rails plugin called acts_as_mappable to ease my development. Perhaps it will help others as well.

With this being my first Rails plugin, some disclaimers are in order. First, its very v0.1 and experimental. While its written to potentially support multiple databases, it not only supports MySQL. Also, as primarily a Java developer, I find it sometimes challenging to write idiomatic Ruby. If you review the source for the plugin, you may recognize opportunities for improvement. If you’d like to make some suggestions, I’m very open to receiving them. Also, any patches or bug reports would be appreciated too.

The README file contains a pretty complete guide to the plugins capabilities — it basically provides distance calculation and query services. The test suite is also fairly extensive, so you can review it to get a good idea of what you can do. In typical Rails fashion, mixing this in would like something like this:

1
2
3
4
5
6

class Location < ActiveRecord::Base
  belongs_to :company
  
  # Pretty SQL distance queries and distance calculations.
  acts_as_mappable
end

And then there’s a host of finders that become available. If this whets your appetite, give it a look.

At present, the plugin is available here, but I’ll make it available in a public SVN repository sometime soon.