geocoder 0.1.1 → 0.9.8

data/CHANGELOG.rdoc

@@ -0,0 +1,96 @@
+= Changelog
+
+Per-release changes to Geocoder.
+
+== 0.9.8 (2011 Feb 8)
+
+* Include geocode:all Rake task in gem (was missing!).
+* Add Geocoder.search for access to Google's full response.
+* Add ability to configure Google connection timeout.
+* Emit warnings on Google connection problems and errors.
+* Refactor: insert Geocoder into ActiveRecord via Railtie.
+
+== 0.9.7 (2011 Feb 1)
+
+* Add reverse geocoding (+reverse_geocoded_by+).
+* Prevent exception (uninitialized constant Geocoder::Net) when net/http not already required (sleepycat).
+* Refactor: split monolithic Geocoder module into several smaller ones.
+
+== 0.9.6 (2011 Jan 19)
+
+* Fix incompatibility with will_paginate gem.
+* Include table names in GROUP BY clause of nearby scope to avoid ambiguity in joins (matchu).
+
+== 0.9.5 (2010 Oct 15)
+
+* Fix broken PostgreSQL compatibility (now 100% compatible).
+* Switch from Google's XML to JSON geocoding API.
+* Separate Rails 2 and Rails 3-compatible branches.
+* Don't allow :conditions hash in 'options' argument to 'nearbys' method (was deprecated in 0.9.3).
+
+== 0.9.4 (2010 Aug 2)
+
+* Google Maps API key no longer required (uses geocoder v3).
+
+== 0.9.3 (2010 Aug 2)
+
+* Fix incompatibility with Rails 3 RC 1.
+* Deprecate 'options' argument to 'nearbys' method.
+* Allow inclusion of 'nearbys' in Arel method chains.
+
+== 0.9.2 (2010 Jun 3)
+
+* Fix LIMIT clause bug in PostgreSQL (reported by kenzie).
+
+== 0.9.1 (2010 May 4)
+
+* Use scope instead of named_scope in Rails 3.
+
+== 0.9.0 (2010 Apr 2)
+
+* Fix bug in PostgreSQL support (caused "PGError: ERROR:  column "distance" does not exist"), reported by developish.
+
+== 0.8.9 (2010 Feb 11)
+
+* Add Rails 3 compatibility.
+* Avoid querying Google when query would be an empty string.
+
+== 0.8.8 (2009 Dec 7)
+
+* Automatically select a less accurate but compatible distance algorithm when SQLite database detected (fixes SQLite incompatibility).
+
+== 0.8.7 (2009 Nov 4)
+
+* Added Geocoder.geographic_center method.
+* Replaced _get_coordinates class method with read_coordinates instance method.
+
+== 0.8.6 (2009 Oct 27)
+
+* The fetch_coordinates method now assigns coordinates to attributes (behaves like fetch_coordinates! used to) and fetch_coordinates! both assigns and saves the attributes.
+* Added geocode:all rake task.
+
+== 0.8.5 (2009 Oct 26)
+
+* Avoid calling deprecated method from within Geocoder itself.
+
+== 0.8.4 (2009 Oct 23)
+
+* Deprecate <tt>find_near</tt> class method in favor of +near+ named scope.
+
+== 0.8.3 (2009 Oct 23)
+
+* Update Google URL query string parameter to reflect recent changes in Google's API.
+
+== 0.8.2 (2009 Oct 12)
+
+* Allow a model's geocoder search string method to be something other than an ActiveRecord attribute.
+* Clean up documentation.
+
+== 0.8.1 (2009 Oct 8)
+
+* Extract XML-fetching code from Geocoder.search and place in Geocoder._fetch_xml (for ease of mocking).
+* Add tests for coordinate-fetching instance methods.
+
+== 0.8.0 (2009 Oct 1)
+
+First release.

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2006 Paul Smith <paul@cnt.org>
+Copyright (c) 2009-10 Alex Reisner
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -0,0 +1,215 @@
+= Geocoder
+
+Geocoder adds object geocoding and database-agnostic distance calculations to Ruby on Rails. It's as simple as calling <tt>fetch_coordinates!</tt> on your objects, and then using a scope like <tt>Venue.near("Billings, MT")</tt>. Since it does not rely on proprietary database functions finding geocoded objects in a given area works with out-of-the-box MySQL or even SQLite.
+
+Geocoder is compatible with Rails 2.x and 3.x. <b>This is the README for the 3.x branch.</b> Please see the 2.x branch for installation instructions, documentation, and issues.
+
+
+== 1. Install
+
+=== As a Gem
+
+Add this to your Gemfile:
+
+  gem "rails-geocoder", :require => "geocoder"
+
+and run this at the command prompt:
+
+  bundle install
+
+=== Or As a Plugin
+
+At the command prompt:
+
+  rails plugin install git://github.com/alexreisner/geocoder.git
+
+
+== 2. Configure
+
+A) Add +latitude+ and +longitude+ columns to your model:
+
+  rails generate migration AddLatitudeAndLongitudeToYourModel latitude:float longitude:float
+  rake db:migrate
+
+B) Tell geocoder where your model stores its address:
+
+  geocoded_by :address
+
+C) Optionally, auto-fetch coordinates every time your model is saved:
+
+  after_validation :fetch_coordinates
+
+<i>Note that you are not stuck with the +latitude+ and +longitude+ column names, or the +address+ method. See "More On Configuration" below for details.</i>
+
+
+== 3. Use
+
+Assuming +obj+ is an instance of a geocoded class, you can get its coordinates:
+
+  obj.fetch_coordinates              # fetches and assigns coordinates
+  obj.fetch_coordinates!             # also saves lat, lon attributes
+
+If you have a lot of objects you can use this Rake task to geocode them all:
+
+  rake geocode:all CLASS=YourModel
+
+Once +obj+ is geocoded you can do things like this:
+
+  obj.nearbys(30)                    # other objects within 30 miles
+  obj.distance_to(40.714, -100.234)  # distance to arbitrary point
+
+To find objects by location, use the following scopes:
+
+  Venue.near('Omaha, NE, US', 20)    # venues within 20 miles of Omaha
+  Venue.near([40.71, 100.23], 20)    # venues within 20 miles of a point
+  Venue.geocoded                     # venues with coordinates
+  Venue.not_geocoded                 # venues without coordinates
+
+Some utility methods are also available:
+
+  # distance (in miles) between Eiffel Tower and Empire State Building
+  Geocoder::Calculations.distance_between( 48.858205,2.294359,  40.748433,-73.985655 )
+
+  # look up coordinates of some location (like searching Google Maps)
+  Geocoder.fetch_coordinates("25 Main St, Cooperstown, NY")
+
+  # find the geographic center (aka center of gravity) of objects or points
+  Geocoder::Calculations.geographic_center([ city1, city2, city3, [40.22,-73.99], city4 ])
+
+
+== More On Configuration
+
+You are not stuck with using the +latitude+ and +longitude+ database column names for storing coordinates. For example, to use +lat+ and +lon+:
+
+  geocoded_by :address, :latitude  => :lat, :longitude => :lon
+
+The string to use for geocoding can be anything you'd use to search Google Maps. For example, any of the following are acceptable:
+
+  714 Green St, Big Town, MO
+  Eiffel Tower, Paris, FR
+  Paris, TX, US
+
+If your model has +address+, +city+, +state+, and +country+ attributes you might do something like this:
+
+  geocoded_by :location
+
+  def location
+    [address, city, state, country].compact.join(', ')
+  end
+
+Please see the code (<tt>lib/geocoder/active_record.rb</tt>) for more methods and detailed information about arguments (eg, working with kilometers).
+
+You can also set the timeout used for connections to Google's geocoding service. The default is 3 seconds, but if you want to set it to 5 you could put the following in an initializer:
+
+  Geocoder::Configuration.timeout = 5
+
+
+== Reverse Geocoding
+
+If you need reverse geocoding (lat/long coordinates to address), do something like the following in your model:
+
+  reverse_geocoded_by :latitude, :longitude
+  after_validation :fetch_address
+
+and make sure it has +latitude+ and +longitude+ attributes, as well as an +address+ attribute. As with regular geocoding, you can specify alternate names for all of these attributes, for example:
+
+  reverse_geocoded_by :lat, :lon, :address => :location
+
+
+== Forward and Reverse Geocoding in the Same Model
+
+If you apply both forward and reverse geocoding functionality to the same model, you can provide different methods for storing the fetched address (reverse geocoding) and providing an address to use when fetching coordinates (forward geocoding), for example:
+
+  class Venue
+
+    # build an address from street, city, and state attributes
+    geocoded_by :address_from_components
+
+    # store the Google-provided address in the full_address attribute
+    reverse_geocoded_by :latitude, :longitude, :address => :full_address
+  end
+
+However, there can be only one set of latitude/longitude attributes, and whichever you specify last will be used. For example:
+
+  class Venue
+
+    geocoded_by :address,
+      :latitude  => :fetched_latitude,  # this will be overridden by the below
+      :longitude => :fetched_longitude  # same here
+
+    reverse_geocoded_by :latitude, :longitude
+  end
+
+The reason for this is that we don't want ambiguity when doing distance calculations. We need a single, authoritative source for coordinates!
+
+
+== Getting More Information
+
+Those familiar with Google's Geocoding API know that it returns much more information than just an address or set of coordinates. If you want access to the entire response you can use the <tt>Geocoder.search</tt> method:
+
+  results = Geocoder.search("McCarren Park, Brooklyn, NY")
+  r = results.first
+
++r+ is now a Geocoder::Result object which has methods like the following:
+
+  r.geometry
+   => {
+    "location"=>{"lng"=>-79.3801601, "lat"=>43.6619568},
+    "location_type"=>"ROOFTOP",
+    "viewport"=>{
+      "northeast"=>{"lng"=>-79.3770125, "lat"=>43.6651044},
+      "southwest"=>{"lng"=>-79.3833077, "lat"=>43.6588092}
+    }
+  }
+
+  r.address_components_of_type(:neighborhood)
+   => [{
+    "long_name"=>"Greenpoint",
+    "short_name"=>"Greenpoint",
+    "types"=>["neighborhood", "political"]
+  }]
+
+Please see the Geocoder::Result class for more information, as well as Google's API documentation (http://code.google.com/apis/maps/documentation/geocoding/#JSON).
+
+
+== SQLite
+
+SQLite's lack of trigonometric functions requires an alternate implementation of the +near+ method (scope). When using SQLite, Geocoder will automatically use a less accurate algorithm for finding objects near a given point. Results of this algorithm should not be trusted too much as it will return objects that are outside the given radius.
+
+It is also not possible to calculate distances between points without the trig functions so you cannot sort results by "nearness."
+
+
+=== Discussion
+
+There are few options for finding objects near a given point in SQLite without installing extensions:
+
+1. Use a square instead of a circle for finding nearby points. For example, if you want to find points near 40.71, 100.23, search for objects with latitude between 39.71 and 41.71 and longitude between 99.23 and 101.23. One degree of latitude or longitude is at most 69 miles so divide your radius (in miles) by 69.0 to get the amount to add and subtract from your center coordinates to get the upper and lower bounds. The results will not be very accurate (you'll get points outside the desired radius--at worst 29% farther away), but you will get all the points within the required radius.
+
+2. Load all objects into memory and compute distances between them using the <tt>Geocoder::Calculations.distance_between</tt> method. This will produce accurate results but will be very slow (and use a lot of memory) if you have a lot of objects in your database.
+
+3. If you have a large number of objects (so you can't use approach #2) and you need accurate results (better than approach #1 will give), you can use a combination of the two. Get all the objects within a square around your center point, and then eliminate the ones that are too far away using <tt>Geocoder::Calculations.distance_between</tt>.
+
+Because Geocoder needs to provide this functionality as a scope, we must go with option #1, but feel free to implement #2 or #3 if you need more accuracy.
+
+
+== Known Issue
+
+You cannot use the +near+ scope with another scope that provides an +includes+ option because the +SELECT+ clause generated by +near+ will overwrite it (or vice versa). Instead, try using +joins+ and pass a <tt>:select</tt> option to the +near+ scope to get the columns you want. For example, in Rails 2 syntax:
+
+  # instead of :includes => :venues:
+  City.near("Omaha, NE", 20, :select => "venues.*").all(:joins => :venues)
+
+If anyone has a more elegant solution to this problem I am very interested in seeing it.
+
+
+== To-do List
+
+* support different ORMs (DataMapper, Mongoid, etc)
+* use completely separate "drivers" for different AR adapters?
+  * seems reasonable since we're using very DB-specific features
+  * also need to make sure 'mysql2' is supported
+* make 'near' scope work with AR associations
+  * http://stackoverflow.com/questions/3266358/geocoder-rails-plugin-near-search-problem-with-activerecord
+
+
+Copyright (c) 2009-11 Alex Reisner, released under the MIT license

data/Rakefile

@@ -1,53 +1,56 @@
-require 'rake/rdoctask'
-require 'rake/gempackagetask'
 require 'rubygems'
-
-GEOCODER_VERSION = "0.1.1"
-
-PKG_FILES = FileList["lib/**/*", "bin/**/*", "[A-Z]*",
-  "test/**/*"].exclude(/\b\.svn\b/)
-
-desc "Run all tests"
-task :default => [ :test ]
-
-desc "Run all tests"
-task :test do
-  ruby "test/ts_geocoder.rb"
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name        = "rails-geocoder"
+    gem.summary     = %Q{Add geocoding functionality to Rails models.}
+    gem.description = %Q{Geocoder adds object geocoding and database-agnostic distance calculations to Ruby on Rails. It does not rely on proprietary database functions so finding geocoded objects in a given area is easily done using out-of-the-box MySQL or even SQLite.}
+    gem.email       = "alex@alexreisner.com"
+    gem.homepage    = "http://github.com/alexreisner/geocoder"
+    gem.authors     = ["Alex Reisner"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
 end
 
-desc "Generate documentation"
-task :docs do
-  sh "rdoc -S -N -o doc -t \"Geocoder Documentation\" README TODO lib"
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
 end
 
-spec = Gem::Specification.new do |s|
-  s.platform = Gem::Platform::RUBY
-  s.summary = "Geocoding library and CLI."
-  s.name = "geocoder"
-  s.version = GEOCODER_VERSION
-  s.requirements << "none"
-  s.require_path = "lib"
-  s.author = "Paul Smith"
-  s.files = PKG_FILES
-  s.autorequire = "geocoder"
-  s.email = "paul@cnt.org"
-  s.rubyforge_project = "geocoder"
-  s.homepage = "http://geocoder.rubyforge.org"
-  s.bindir = "bin"
-  s.executables = ["geocode"]
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
 end
 
-Rake::GemPackageTask.new(spec) do |pkg|
-  pkg.need_zip = true
-  pkg.need_tar = true
-end
+task :test => :check_dependencies
 
-desc "Install local gem"
-task :install => [ :repackage ] do
-  sh "sudo gem install -l pkg/geocoder-#{GEOCODER_VERSION}.gem"
-end
+task :default => :test
 
-desc "Uninstall gem"
-task :uninstall do
-  sh "sudo gem uninstall geocoder"
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "geocoder #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
 end

data/lib/geocoder.rb

@@ -1,327 +1,23 @@
-#--
-# Copyright (c) 2006 Paul Smith <paul@cnt.org>
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#++
-#
-# = Geocoder -- Geocoding library for Ruby
-#
-require 'cgi'
-require 'net/http'
-require 'rexml/document'
-require 'timeout'
+require "geocoder/configuration"
+require "geocoder/calculations"
+require "geocoder/lookup"
+require "geocoder/result"
+require "geocoder/active_record"
+require "geocoder/railtie"
 
 module Geocoder
+  extend self
 
-  class BlankLocationString < Exception; end
-  class GeocodingError < Exception; end
-
-  FIELDS = [ ["latitude", "Latitude"],
-             ["longitude", "Longitude"],
-             ["address", "Address"],
-             ["city", "City"],
-             ["state", "State"], 
-             ["zip", "ZIP Code"] ].freeze
-
-  class Base
-    # +location+ is a string, any of the following:
-    # * city, state
-    # * city, state, zip
-    # * zip
-    # * street, city, state
-    # * street, city, state, zip
-    # * street, zip
-    def geocode location, *args
-      options = { :timeout => nil }
-      options.update(args.pop) if args.last.is_a?(Hash)
-      @options = options
-      if location.nil? or location.empty?
-        raise BlankLocationString
-      end
-      location = String location
-      results = parse request(location)
-      create_response results
-    end
-          
-    def create_response results
-      Response.new results
-    end
-
-    # Makes an HTTP GET request on URL and returns the body
-    # of the response
-    def get url, timeout=5
-      url = URI.parse url
-      http = Net::HTTP.new url.host, url.port
-      res = Timeout::timeout(timeout) {
-        http.get url.request_uri
-      }
-      res.body
-    end
-
-    def request location
-      get url(location), @options[:timeout]
-    end
-  end
-
-  class GeoCoderUs < Base
-    def initialize *args
-      #
-    end
-
-    private
-
-    def parse csv_text
-      if csv_text =~ /^2: /
-        raise GeocodingError, csv_text.split(": ")[1]
-      end
-      results = []
-      csv_text.split("\n").each do |line|
-        latitude, longitude, address, city, state, zip = line.split ","
-        result = Result.new
-        result.latitude = latitude
-        result.longitude = longitude
-        result.address = address
-        result.city = city
-        result.state = state
-        result.zip = zip
-        results << result
-      end
-      results
-    end
-
-    # Returns URL of geocoder.us web service
-    def url address
-      "http://rpc.geocoder.us/service/csv?address=#{CGI.escape address}"
-    end
-  end
-
-  class Yahoo < Base
-    include REXML
-    # Requires a Y! Application ID
-    # http://developer.yahoo.net/faq/index.html#appid
-    def initialize appid
-      @appid = appid
-    end
-
-    private
-
-    # return array of results
-    def parse xml
-      # Create a new REXML::Document object from the raw XML text
-      xml = Document.new xml
-      # 
-      # Normally, Y! will return an XML document with the root node
-      # <ResultSet>; if the request bombs, they return one with the
-      # root node <Error>
-      if is_error? xml
-        msgs = []
-        # Bubble up an exception using the error messages from Y!
-        xml.root.elements.each("Message") { |e| msgs << e.get_text.value }
-        raise GeocodingError, msgs.join(", ")
-      else
-        results = []
-        xml.root.elements.each "Result" do |e|
-          result = Result.new
-          # add fields
-          fields.each do |field|
-            text = e.elements[field.capitalize].get_text
-            if text.respond_to? :value
-              result.send "#{field}=", text.value
-            end
-          end
-          # add attributes
-          attributes.each do |attribute|
-            result.send "#{attribute}=", e.attributes[attribute]
-          end
-          results << result
-        end
-        results
-      end
-    end
-
-    def fields
-      %w| latitude longitude address city state zip country |
-    end
-
-    def attributes
-      %w| precision warning |
-    end
-
-    def is_error? document
-      document.root.name == "Error"
-    end
-
-    # Returns URL of Y! Geocoding web service
-    def url location
-      "http://api.local.yahoo.com/MapsService/V1/geocode?appid=#{@appid}&location=#{CGI.escape location}"
-    end
-  end
-
-  SERVICES = { :yahoo => Yahoo,
-               :geocoderus => GeoCoderUs }.freeze
-
-  class Result < Struct.new :latitude, :longitude, :address, :city,
-                            :state, :zip, :country, :precision,
-                            :warning
-    alias :lat :latitude
-    alias :lng :longitude
+  ##
+  # Alias for Geocoder::Lookup.search.
+  #
+  def search(*args)
+    Lookup.search(*args)
   end
 
-  # A Response is a representation of the entire response from the
-  # Y! Geocoding web service, which may include multiple results,
-  # as well as warnings and errors
-  class Response < Array
-    def initialize results
-      results.each do |result|
-        self << result
-      end
-    end
-
-    # Geocoding was an unqualified success if one result in the result 
-    # set is retured and there is no warning attribute in that result
-    def success?
-      size == 1 and self[0].warning.nil?
-    end
-
-    def bullseye?
-      success?
-    end
-
-    # Returns latitude in degrees decimal
-    def latitude
-      self[0].latitude if bullseye?
-    end
-
-    # Returns longitude in degrees decimal
-    def longitude
-      self[0].longitude if bullseye?
-    end
-
-    # Returns normalized street address, capitalized
-    def address
-      self[0].address if bullseye?
-    end
-
-    # Returns normalized city name, capitalized
-    def city
-      self[0].city if bullseye?
-    end
-
-    # Returns normalized two-letter USPS state abbreviation
-    def state
-      self[0].state if bullseye?
-    end
-
-    alias_method :array_zip, :zip
-   
-    # Returns normalized ZIP Code, or postal code
-    def zip
-      self[0].zip if bullseye?
-    end
-
-    # Returns two-letter country code abbreviation
-    def country
-      self[0].country if bullseye?
-    end
-
-    alias :lat :latitude
-    alias :lng :longitude
-  end
-
-  class Cli
-    require 'optparse'
-    require 'ostruct'
-
-    def self.parse args
-      options = OpenStruct.new
-      # default values
-      options.appid = "YahooDemo"
-      options.service = Yahoo
-      options.timeout = 5
-      opts = OptionParser.new do |opts|
-        opts.banner = "Usage: geocode [options] location"
-        opts.separator ""
-        opts.separator "Options:"
-        opts.on "-a appid", "--appid appid", "Yahoo! Application ID" do |a|
-          options.appid = a
-        end
-        opts.on "-s service", "--service service", "`yahoo' or `geocoderus'" do |s|
-          options.service = SERVICES[s]
-        end
-        opts.on "-t secs", "--timeout secs", Integer, "Timeout in seconds" do |t|
-          options.timeout = t
-        end
-        opts.on "-q", "--quiet", "Quiet output" do |q|
-          options.quiet = q
-        end
-        opts.on_tail "-h", "--help", "Show this message" do
-          puts opts
-          exit
-        end
-        opts.parse! args
-      end
-      [options, opts]
-    end
-
-    def initialize cli_args
-      @options, @opt_parser = Cli::parse cli_args
-      @location = cli_args.join " "
-    end
-
-    def report result
-      buffer = []
-      if @options.quiet
-        result.each do |r|
-          buffer << FIELDS.collect do |k,v|
-            r.send k
-          end.join(",")
-        end
-      else
-        buffer << "Found #{result.size} result(s)."
-        buffer << buffer.last.gsub(/./, "-")
-        buffer << result.collect do |r|
-          FIELDS.collect do |k,v|
-            "#{v}: #{r.send k}"
-          end.join("\n")
-        end.join("\n- - - -\n")
-      end
-      puts buffer.join("\n")
-    end
-
-    def go!
-      g = @options.service.new @options.appid
-      begin
-        result = g.geocode @location, :timeout => @options.timeout
-        report result
-      rescue BlankLocationString
-        STDERR.puts "You have to give an address to geocode!"
-        puts
-        puts @opt_parser
-        exit
-      rescue Timeout::Error
-        STDERR.puts "The remote geocoding service timed-out. Try increasing the timeout value (-t)."
-        exit
-      rescue Geocoder::GeocodingError => e
-        STDERR.puts "Geocoder: #{e}"
-        exit
-      end
-    end
-  end
+  # exception classes
+  class Error < StandardError; end
+  class ConfigurationError < Error; end
 end
+
+Geocoder::Railtie.insert