pepe-graticule 0.2.11

data/lib/graticule/geocoder/geocoder_ca.rb

@@ -0,0 +1,54 @@
+module Graticule #:nodoc:
+  module Geocoder #:nodoc:
+
+    # TODO: Reverse Geocoding
+    class GeocoderCa < Rest
+
+      def initialize(auth = nil)
+        @url = URI.parse 'http://geocoder.ca/'
+        @auth = auth
+      end
+
+      def locate(address)
+        get :locate => address.is_a?(String) ? address : location_from_params(address).to_s(:country => false)
+      end
+      
+    private
+      
+      def parse_response(xml) #:nodoc:
+        returning Location.new do |location|
+          location.latitude = xml.elements['geodata/latt'].text.to_f
+          location.longitude = xml.elements['geodata/longt'].text.to_f
+          location.street = xml.elements['geodata/standard/staddress'].text
+          location.locality = xml.elements['geodata/standard/city'].text
+          location.region = xml.elements['geodata/standard/prov'].text
+        end
+      end
+
+      def check_error(xml) #:nodoc:
+        error = xml.elements['geodata/error']
+        if error
+          code = error.elements['code'].text.to_i
+          message = error.elements['description'].text
+          if (1..3).include?(code)
+            raise CredentialsError, message
+          elsif (4..8).include?(code)
+            raise AddressError, message
+          else
+            raise Error, message
+          end
+        end
+      end
+
+      def make_url(params) #:nodoc:
+        params[:auth]       = @auth if @auth
+        params[:standard]   = 1
+        params[:showpostal] = 1
+        params[:geoit]      = 'XML'
+        super params
+      end
+
+
+    end
+  end
+end

data/lib/graticule/geocoder/geocoder_us.rb

@@ -0,0 +1,51 @@
+module Graticule #:nodoc:
+  module Geocoder #:nodoc:
+
+    # A library for lookup up coordinates with geocoder.us' API.
+    #
+    # http://geocoder.us/help/
+    class GeocoderUs < Rest
+
+      # Creates a new GeocoderUs object optionally using +username+ and
+      # +password+.
+      #
+      # You can sign up for a geocoder.us account here:
+      #
+      # http://geocoder.us/user/signup
+      def initialize(user = nil, password = nil)
+        if user and password then
+          @url = URI.parse 'http://geocoder.us/member/service/rest/geocode'
+          @url.user = user
+          @url.password = password
+        else
+          @url = URI.parse 'http://rpc.geocoder.us/service/rest/geocode'
+        end
+      end
+
+      # Locates +address+ and returns the address' latitude and longitude or
+      # raises an AddressError.
+      def locate(address)
+        get :address => address.is_a?(String) ? address : location_from_params(address).to_s(:country => false)
+      end
+      
+    private
+
+      def parse_response(xml) #:nodoc:
+        location = Location.new
+        location.street = xml.elements['rdf:RDF/geo:Point/dc:description'].text
+
+        location.latitude = xml.elements['rdf:RDF/geo:Point/geo:lat'].text.to_f
+        location.longitude = xml.elements['rdf:RDF/geo:Point/geo:long'].text.to_f
+
+        return location
+      end
+
+      def check_error(xml) #:nodoc:
+        raise AddressError, xml.text if xml.text =~ /couldn't find this address! sorry/
+        raise Error, xml.text if xml.text =~ /Your browser sent a request that this server could not understand./
+        raise Error, xml.text if !(xml.text =~ /geo:Point/)
+      end
+
+    end
+  end
+end

data/lib/graticule/geocoder/google.rb

@@ -0,0 +1,100 @@
+
+module Graticule #:nodoc:
+  module Geocoder #:nodoc:
+  
+    # First you need a Google Maps API key.  You can register for one here:
+    # http://www.google.com/apis/maps/signup.html
+    # 
+    #   gg = Graticule.service(:google).new(MAPS_API_KEY)
+    #   location = gg.locate '1600 Amphitheater Pkwy, Mountain View, CA'
+    #   p location.coordinates
+    #   #=> [37.423111, -122.081783
+    #
+    class Google < Rest
+      # http://www.google.com/apis/maps/documentation/#Geocoding_HTTP_Request
+    
+      # http://www.google.com/apis/maps/documentation/reference.html#GGeoAddressAccuracy
+      PRECISION = {
+        0 => :unknown,      # Unknown location. (Since 2.59)
+        1 => :country,      # Country level accuracy. (Since 2.59)
+        2 => :state,        # Region (state, province, prefecture, etc.) level accuracy. (Since 2.59)
+        3 => :state,        # Sub-region (county, municipality, etc.) level accuracy. (Since 2.59)
+        4 => :city,         # Town (city, village) level accuracy. (Since 2.59)
+        5 => :zip,          # Post code (zip code) level accuracy. (Since 2.59)
+        6 => :street,       # Street level accuracy. (Since 2.59)
+        7 => :street,       # Intersection level accuracy. (Since 2.59)
+        8 => :address       # Address level accuracy. (Since 2.59)
+      }
+
+      # Creates a new GoogleGeocode that will use Google Maps API +key+.
+      def initialize(key)
+        @key = key
+        @url = URI.parse 'http://maps.google.com/maps/geo'
+      end
+
+      # Locates +address+ returning a Location
+      def locate(address)
+        get :q => address.is_a?(String) ? address : location_from_params(address).to_s
+      end
+
+    private
+
+      # Extracts a Location from +xml+.
+      def parse_response(xml) #:nodoc:
+        longitude, latitude, = xml.elements['/kml/Response/Placemark/Point/coordinates'].text.split(',').map { |v| v.to_f }
+        returning Location.new(:latitude => latitude, :longitude => longitude) do |l|
+          address = REXML::XPath.first(xml, '//xal:AddressDetails',
+            'xal' => "urn:oasis:names:tc:ciq:xsdschema:xAL:2.0")
+
+          if address
+            l.street = value(address.elements['.//ThoroughfareName/text()'])
+            l.locality = value(address.elements['.//LocalityName/text()'])
+            l.region = value(address.elements['.//AdministrativeAreaName/text()'])
+            l.postal_code = value(address.elements['.//PostalCodeNumber/text()'])
+            l.country = value(address.elements['.//CountryNameCode/text()'])
+            l.precision = PRECISION[address.attribute('Accuracy').value.to_i] || :unknown
+          end
+        end
+      end
+
+      # Extracts and raises an error from +xml+, if any.
+      def check_error(xml) #:nodoc:
+        status = xml.elements['/kml/Response/Status/code'].text.to_i
+        case status
+        when 200 then # ignore, ok
+        when 500 then
+          raise Error, 'server error'
+        when 601 then
+          raise AddressError, 'missing address'
+        when 602 then
+          raise AddressError, 'unknown address'
+        when 603 then
+          raise AddressError, 'unavailable address'
+        when 610 then
+          raise CredentialsError, 'invalid key'
+        when 620 then
+          raise CredentialsError, 'too many queries'
+        else
+          raise Error, "unknown error #{status}"
+        end
+      end
+
+      # Creates a URL from the Hash +params+.  Automatically adds the key and
+      # sets the output type to 'xml'.
+      def make_url(params) #:nodoc:
+        params[:key] = @key
+        params[:output] = 'xml'
+
+        super params
+      end
+    
+      def value(element)
+        element.value if element
+      end
+  
+      def text(element)
+        element.text if element
+      end
+    end
+  end
+end

data/lib/graticule/geocoder/host_ip.rb

@@ -0,0 +1,41 @@
+require 'yaml'
+
+module Graticule #:nodoc:
+  module Geocoder #:nodoc:
+
+    class HostIp < Base
+
+      def initialize
+        @url = URI.parse 'http://api.hostip.info/get_html.php'
+      end
+
+      # Geocode an IP address using http://hostip.info
+      def locate(address)
+        get :ip => address, :position => true
+      end
+    
+    private
+    
+      def prepare_response(response)
+        # add new line so YAML.load doesn't puke
+        YAML.load(response + "\n")
+      end
+      
+      def parse_response(response) #:nodoc:
+        returning Location.new do |location|
+          location.latitude = response['Latitude']
+          location.longitude = response['Longitude']
+          location.locality, location.region = response['City'].split(', ')
+          country = response['Country'].match(/\((\w+)\)$/)
+          location.country = country[1] if country
+        end
+      end
+
+      def check_error(response) #:nodoc:
+        raise AddressError, 'Unknown' if response['City'] =~ /Unknown City/
+        raise AddressError, 'Private Address' if response['City'] =~ /Private Address/
+      end
+
+    end
+  end
+end

data/lib/graticule/geocoder/local_search_maps.rb

@@ -0,0 +1,45 @@
+module Graticule #:nodoc:
+  module Geocoder #:nodoc:
+
+    # A library for lookup of coordinates with http://geo.localsearchmaps.com/
+    #
+    # See http://emad.fano.us/blog/?p=277
+    class LocalSearchMaps < Base
+    
+      def initialize
+        @url = URI.parse 'http://geo.localsearchmaps.com/'
+      end
+    
+      # This web service will handle some addresses outside the US
+      # if given more structured arguments than just a string address
+      # So allow input as a hash for the different arguments (:city, :country, :zip)
+      def locate(params)
+        get params.is_a?(String) ? {:loc => params} : map_attributes(location_from_params(params))
+      end
+      
+    private
+    
+      def map_attributes(location)
+        mapping = {:street => :street, :locality => :city, :region => :state, :postal_code => :zip, :country => :country}
+        mapping.keys.inject({}) do |result,attribute|
+          result[mapping[attribute]] = location.attributes[attribute] unless location.attributes[attribute].blank?
+          result
+        end
+      end
+    
+      def check_error(js)
+        raise AddressError, "Empty Response" if js.nil?
+        raise AddressError, 'Location not found' if js =~ /location not found/
+      end
+    
+      def parse_response(js)
+        returning Location.new do |location|
+          coordinates = js.match(/map.centerAndZoom\(new GPoint\((.+?), (.+?)\)/)
+          location.longitude = coordinates[1].to_f
+          location.latitude = coordinates[2].to_f
+        end
+      end
+      
+    end
+  end
+end

data/lib/graticule/geocoder/mapquest.rb

@@ -0,0 +1,87 @@
+module Graticule #:nodoc:
+  module Geocoder #:nodoc:
+
+    # Mapquest requires both a client id and a password, which you can
+    # get by registering at:
+    # http://developer.mapquest.com/Home/Register?_devAPISignup_WAR_devAPISignup_action=signup&_devAPISignup_WAR_devAPISignup_clientType=Developer
+    #
+    # mq = Graticule.service(:mapquest).new(CLIENT_ID, PASSWORD)
+    # location = gg.locate('44 Allen Rd., Lovell, ME 04051') 
+    # [42.78942, -86.104424]
+    #
+    class Mapquest < Rest 
+      # I would link to the documentation here, but there is none that will do anything but confuse you.
+
+      PRECISION = {
+        'L1' => :address,
+        'I1' => :street,
+        'B1' => :street,
+        'B2' => :street,
+        'B3' => :street,
+        'Z3' => :zip,
+        'Z4' => :zip,
+        'Z2' => :zip,
+        'Z1' => :zip,
+        'A5' => :city,
+        'A4' => :county,
+        'A3' => :state,
+        'A1' => :country
+      }
+
+      def initialize(client_id, password)
+        @password = password
+        @client_id = client_id
+        @url = URI.parse('http://geocode.dev.mapquest.com/mq/mqserver.dll')
+      end
+
+      # Locates +address+ returning a Location
+      def locate(address)
+        get :q => address.is_a?(String) ? address : location_from_params(address).to_s
+      end
+
+      protected
+
+      def make_url(params) #:nodoc
+        query = "e=5&<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?><Geocode Version=\"1\"> \
+          #{address_string(params[:q])}#{authentication_string}</Geocode>"
+        url = @url.dup
+        url.query = URI.escape(query)
+        url
+      end
+
+      # Extracts a location from +xml+.
+      def parse_response(xml) #:nodoc:
+        longitude = xml.elements['/GeocodeResponse/LocationCollection/GeoAddress/LatLng/Lng'].text.to_f
+        latitude = xml.elements['/GeocodeResponse/LocationCollection/GeoAddress/LatLng/Lat'].text.to_f
+        returning Location.new(:latitude => latitude, :longitude => longitude) do |l|
+          address = REXML::XPath.first(xml, '/GeocodeResponse/LocationCollection/GeoAddress')
+
+          if address
+            l.street = value(address.elements['./Street/text()'])
+            l.locality = value(address.elements['./AdminArea5/text()'])
+            l.region = value(address.elements['./AdminArea3/text()'])
+            l.postal_code = value(address.elements['./PostalCode/text()'])
+            l.country = value(address.elements['./AdminArea1/text()'])
+            l.precision = PRECISION[value(address.elements['./ResultCode/text()'])[0,2]]
+          end
+        end
+      end
+
+      # Extracts and raises any errors in +xml+
+      def check_error(xml) #:nodoc
+      end
+
+      def value(element)
+        element.value if element
+      end
+
+      def authentication_string
+        "<Authentication Version=\"2\"><Password>#{@password}</Password><ClientId>#{@client_id}</ClientId></Authentication>"
+      end
+
+      def address_string(query)
+        "<Address><Street>#{query}</Street></Address><GeocodeOptionsCollection Count=\"0\"/>"
+      end
+    end
+  end
+end

data/lib/graticule/geocoder/meta_carta.rb

@@ -0,0 +1,33 @@
+
+module Graticule
+  module Geocoder
+
+    # Library for looking up coordinates with MetaCarta's GeoParser API.
+    #
+    # http://labs.metacarta.com/GeoParser/documentation.html
+    class MetaCarta < Rest
+
+      def initialize # :nodoc:
+        @url = URI.parse 'http://labs.metacarta.com/GeoParser/'
+      end
+
+      # Finds +location+ and returns a Location object.
+      def locate(location)
+        get :q => location.is_a?(String) ? location : location_from_params(location).to_s, :output => 'locations'
+      end
+      
+    private
+
+      def check_error(xml) # :nodoc:
+        raise AddressError, 'bad location' unless xml.elements['Locations/Location']
+      end
+
+      def parse_response(xml) # :nodoc:
+        result = xml.elements['/Locations/Location[1]']
+        coords = result.elements['Centroid/gml:Point/gml:coordinates'].text.split ','
+        Location.new :latitude => coords.first.to_f, :longitude => coords.last.to_f
+      end
+      
+    end
+  end
+end

data/lib/graticule/geocoder/multi.rb

@@ -0,0 +1,46 @@
+module Graticule #:nodoc:
+  module Geocoder #:nodoc:
+    class Multi
+      
+      # The Multi geocoder allows you to use multiple geocoders in succession.
+      #
+      #   geocoder = Graticule.service(:multi).new(
+      #     Graticule.service(:google).new("api_key"),
+      #     Graticule.service(:yahoo).new("api_key"),
+      #   )
+      #   geocoder.locate '49423' # <= tries geocoders in succession
+      #
+      # The Multi geocoder will try the geocoders in order if a Graticule::AddressError
+      # is raised.  You can customize this behavior by passing in a block to the Multi
+      # geocoder.  For example, to try the geocoders until one returns a result with a
+      # high enough precision:
+      #
+      #   geocoder = Graticule.service(:multi).new(geocoders) do |result|
+      #     [:address, :street].include?(result.precision)
+      #   end
+      #
+      # Geocoders will be tried in order until the block returned true for one of the results
+      #
+      def initialize(*geocoders, &acceptable)
+        @acceptable = acceptable || lambda { true }
+        @geocoders = geocoders.flatten
+      end
+      
+      def locate(address)
+        last_error = nil
+        @geocoders.each do |geocoder|
+          begin
+            result = geocoder.locate address
+            return result if @acceptable.call(result)
+          rescue Error => e
+            last_error = e
+          rescue Errno::ECONNREFUSED
+            logger.error("Connection refused to #{service}")
+          end
+        end
+        raise last_error || AddressError.new("Couldn't find '#{address}' with any of the services")
+      end
+      
+    end
+  end
+end