rails-geocoder 0.9.8 → 0.9.9

data/lib/geocoder/configuration.rb

@@ -1,8 +1,16 @@
 module Geocoder
   class Configuration
-    cattr_accessor :timeout
+    def self.timeout; @@timeout; end
+    def self.timeout=(obj); @@timeout = obj; end
+
+    def self.lookup; @@lookup; end
+    def self.lookup=(obj); @@lookup = obj; end
+
+    def self.yahoo_appid; @@yahoo_appid; end
+    def self.yahoo_appid=(obj); @@yahoo_appid = obj; end
   end
 end
 
-Geocoder::Configuration.timeout = 3
-
+Geocoder::Configuration.timeout     = 3
+Geocoder::Configuration.lookup      = :google
+Geocoder::Configuration.yahoo_appid = ""

data/lib/geocoder/lookups/base.rb

@@ -0,0 +1,110 @@
+require 'net/http'
+unless defined? ActiveSupport::JSON
+  begin
+    require 'json'
+  rescue LoadError
+    raise LoadError, "Please install the json gem to parse geocoder results."
+  end
+end
+
+module Geocoder
+  module Lookup
+    class Base
+
+      ##
+      # Query the geocoding API and return a Geocoder::Result object.
+      # Returns +nil+ on timeout or error.
+      #
+      # Takes a search string (eg: "Mississippi Coast Coliseumf, Biloxi, MS",
+      # "205.128.54.202") for geocoding, or coordinates (latitude, longitude)
+      # for reverse geocoding.
+      #
+      def search(*args)
+        if res = result(args.join(","), args.size == 2)
+          result_class.new(res)
+        end
+      end
+
+
+      private # -------------------------------------------------------------
+
+      ##
+      # Geocoder::Result object or nil on timeout or other error.
+      #
+      def result(query, reverse = false)
+        fail
+      end
+
+      ##
+      # URL to use for querying the geocoding engine.
+      #
+      def query_url(query, reverse = false)
+        fail
+      end
+
+      ##
+      # Class of the result objects
+      #
+      def result_class
+        eval("Geocoder::Result::#{self.class.to_s.split(":").last}")
+      end
+
+      ##
+      # Returns a parsed search result (Ruby hash).
+      #
+      def fetch_data(query, reverse = false)
+        begin
+          parse_raw_data fetch_raw_data(query, reverse)
+        rescue SocketError
+          warn "Geocoding API connection cannot be established."
+        rescue TimeoutError
+          warn "Geocoding API not responding fast enough " +
+            "(see Geocoder::Configuration.timeout to set limit)."
+        end
+      end
+
+      ##
+      # Parses a raw search result (returns hash or array).
+      #
+      def parse_raw_data(raw_data)
+        if defined?(JSON) and defined?(JSON.parse)
+          begin
+            JSON.parse(raw_data)
+          rescue
+            warn "Geocoding API's response was not valid JSON."
+          end
+        elsif defined?(ActiveSupport::JSON)
+          ActiveSupport::JSON.decode(raw_data)
+        else
+          raise Geocoder::Error, "No JSON-parsing library found. " +
+            "Please install either the 'json' or 'activesupport' gem."
+        end
+      end
+
+      ##
+      # Fetches a raw search result (JSON string).
+      #
+      def fetch_raw_data(query, reverse = false)
+        url = query_url(query, reverse)
+        timeout(Geocoder::Configuration.timeout) do
+          Net::HTTP.get_response(URI.parse(url)).body
+        end
+      end
+
+      ##
+      # Is the given string a loopback IP address?
+      #
+      def loopback_address?(ip)
+        !!(ip == "0.0.0.0" or ip.match(/^127/))
+      end
+
+      ##
+      # Simulate ActiveSupport's Object#to_query.
+      #
+      def hash_to_query(hash)
+        require 'cgi' unless defined?(CGI) && defined?(CGI.escape)
+        hash.collect{ |p| p.map{ |i| CGI.escape i.to_s } * '=' }.sort * '&'
+      end
+    end
+  end
+end

data/lib/geocoder/lookups/freegeoip.rb

@@ -0,0 +1,40 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/freegeoip'
+
+module Geocoder::Lookup
+  class Freegeoip < Base
+
+    private # ---------------------------------------------------------------
+
+    def result(query, reverse = false)
+      # don't look up a loopback address, just return the stored result
+      return reserved_result(query) if loopback_address?(query)
+      begin
+        if doc = fetch_data(query, reverse)
+          doc
+        end
+      rescue StandardError # Freegeoip.net returns HTML on bad request
+        nil
+      end
+    end
+
+    def reserved_result(ip)
+      {
+        "ip"           => ip,
+        "city"         => "",
+        "region_code"  => "",
+        "region_name"  => "",
+        "metrocode"    => "",
+        "zipcode"      => "",
+        "latitude"     => "0",
+        "longitude"    => "0",
+        "country_name" => "Reserved",
+        "country_code" => "RD"
+      }
+    end
+
+    def query_url(query, reverse = false)
+      "http://freegeoip.net/json/#{query}"
+    end
+  end
+end

data/lib/geocoder/lookups/google.rb

@@ -0,0 +1,31 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/google"
+
+module Geocoder::Lookup
+  class Google < Base
+
+    private # ---------------------------------------------------------------
+
+    def result(query, reverse = false)
+      doc = fetch_data(query, reverse)
+      case doc['status']; when "OK" # OK status implies >0 results
+        doc['results'].first
+      when "OVER_QUERY_LIMIT"
+        warn "Google Geocoding API error: over query limit."
+      when "REQUEST_DENIED"
+        warn "Google Geocoding API error: request denied."
+      when "INVALID_REQUEST"
+        warn "Google Geocoding API error: invalid request."
+      end
+    end
+
+    def query_url(query, reverse = false)
+      params = {
+        (reverse ? :latlng : :address) => query,
+        :sensor => "false"
+      }
+      "http://maps.google.com/maps/api/geocode/json?" + hash_to_query(params)
+    end
+  end
+end
+

data/lib/geocoder/lookups/yahoo.rb

@@ -0,0 +1,29 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/yahoo"
+
+module Geocoder::Lookup
+  class Yahoo < Base
+
+    private # ---------------------------------------------------------------
+
+    def result(query, reverse = false)
+      doc = fetch_data(query, reverse)
+      if doc = doc['ResultSet'] and doc['Error'] == 0
+        doc['Results'].first if doc['Found'] > 0
+      else
+        warn "Yahoo Geocoding API error: #{doc['Error']} (#{doc['ErrorMessage']})."
+      end
+    end
+
+    def query_url(query, reverse = false)
+      params = {
+        :location =>  query,
+        :flags => "JXTSR",
+        :gflags => "AC#{'R' if reverse}",
+        :appid => Geocoder::Configuration.yahoo_appid
+      }
+      "http://where.yahooapis.com/geocode?" + hash_to_query(params)
+    end
+  end
+end
+

data/lib/geocoder/{active_record.rb → orms/active_record.rb}

@@ -1,8 +1,13 @@
+require 'geocoder/orms/base'
+require 'geocoder/orms/active_record_legacy'
+
 ##
 # Add geocoding functionality to any ActiveRecord object.
 #
-module Geocoder
+module Geocoder::Orm
   module ActiveRecord
+    include Base
+    include ActiveRecord::Legacy
 
     ##
     # Implementation of 'included' hook method.
@@ -28,7 +33,7 @@ module Geocoder
         #
         scope :near, lambda{ |location, *args|
           latitude, longitude = location.is_a?(Array) ?
-            location : Geocoder::Lookup.coordinates(location)
+            location : Geocoder.coordinates(location)
           if latitude and longitude
             near_scope_options(latitude, longitude, *args)
           else
@@ -112,7 +117,7 @@ module Geocoder
           ["#{lat_attr} BETWEEN ? AND ? AND #{lon_attr} BETWEEN ? AND ?"] +
           coordinate_bounds(latitude, longitude, radius)
         if obj = options[:exclude]
-          conditions[0] << " AND id != ?"
+          conditions[0] << " AND #{table_name}.id != ?"
           conditions << obj.id
         end
         {
@@ -142,94 +147,34 @@ module Geocoder
     end
 
     ##
-    # Read the coordinates [lat,lon] of an object. This is not great but it
-    # seems cleaner than polluting the instance method namespace.
-    #
-    def read_coordinates
-      [:latitude, :longitude].map{ |i| send self.class.geocoder_options[i] }
-    end
-
-    ##
-    # Is this object geocoded? (Does it have latitude and longitude?)
-    #
-    def geocoded?
-      read_coordinates.compact.size > 0
-    end
-
-    ##
-    # Calculate the distance from the object to a point (lat,lon).
-    #
-    # <tt>:units</tt> :: <tt>:mi</tt> (default) or <tt>:km</tt>
-    #
-    def distance_to(lat, lon, units = :mi)
-      return nil unless geocoded?
-      mylat,mylon = read_coordinates
-      Geocoder::Calculations.distance_between(mylat, mylon, lat, lon, :units => units)
-    end
-
-    ##
-    # Get other geocoded objects within a given radius.
-    #
-    # <tt>:units</tt> :: <tt>:mi</tt> (default) or <tt>:km</tt>
+    # Look up coordinates and assign to +latitude+ and +longitude+ attributes
+    # (or other as specified in +geocoded_by+). Returns coordinates (array).
     #
-    def nearbys(radius = 20, units = :mi)
-      return [] unless geocoded?
-      options = {:exclude => self, :units => units}
-      self.class.near(read_coordinates, radius, options)
-    end
-
-    ##
-    # Fetch coordinates and assign +latitude+ and +longitude+. Also returns
-    # coordinates as an array: <tt>[lat, lon]</tt>.
-    #
-    def fetch_coordinates(save = false)
-      address_method = self.class.geocoder_options[:user_address]
-      unless address_method.is_a? Symbol
-        raise Geocoder::ConfigurationError,
-          "You are attempting to fetch coordinates but have not specified " +
-          "a method which provides an address for the object."
-      end
-      coords = Geocoder::Lookup.coordinates(send(address_method))
-      unless coords.blank?
-        method = (save ? "update" : "write") + "_attribute"
-        send method, self.class.geocoder_options[:latitude],  coords[0]
-        send method, self.class.geocoder_options[:longitude], coords[1]
+    def geocode
+      do_lookup(false) do |o,r|
+        unless r.latitude.nil? or r.longitude.nil?
+          o.send :write_attribute, self.class.geocoder_options[:latitude],  r.latitude
+          o.send :write_attribute, self.class.geocoder_options[:longitude], r.longitude
+        end
+        r.coordinates
       end
-      coords
     end
 
-    ##
-    # Fetch coordinates and update (save) +latitude+ and +longitude+ data.
-    #
-    def fetch_coordinates!
-      fetch_coordinates(true)
-    end
+    #alias_method :fetch_coordinates, :geocode
 
     ##
-    # Fetch address and assign +address+ attribute. Also returns
-    # address as a string.
+    # Look up address and assign to +address+ attribute (or other as specified
+    # in +reverse_geocoded_by+). Returns address (string).
     #
-    def fetch_address(save = false)
-      lat_attr = self.class.geocoder_options[:latitude]
-      lon_attr = self.class.geocoder_options[:longitude]
-      unless lat_attr.is_a?(Symbol) and lon_attr.is_a?(Symbol)
-        raise Geocoder::ConfigurationError,
-          "You are attempting to fetch an address but have not specified " +
-          "attributes which provide coordinates for the object."
-      end
-      address = Geocoder::Lookup.address(send(lat_attr), send(lon_attr))
-      unless address.blank?
-        method = (save ? "update" : "write") + "_attribute"
-        send method, self.class.geocoder_options[:fetched_address], address
+    def reverse_geocode
+      do_lookup(true) do |o,r|
+        unless r.address.nil?
+          o.send :write_attribute, self.class.geocoder_options[:fetched_address], r.address
+        end
+        r.address
       end
-      address
     end
 
-    ##
-    # Fetch address and update (save) +address+ data.
-    #
-    def fetch_address!
-      fetch_address(true)
-    end
+    #alias_method :fetch_address, :reverse_geocode
   end
 end

data/lib/geocoder/orms/active_record_legacy.rb

@@ -0,0 +1,58 @@
+module Geocoder::Orm::ActiveRecord
+  module Legacy
+
+    ##
+    # Fetch coordinates and update (save) +latitude+ and +longitude+ data.
+    #
+    def fetch_coordinates!
+      warn "DEPRECATION WARNING: The 'fetch_coordinates!' method is deprecated and will be removed in geocoder v1.0. " +
+        "Please use 'geocode' instead and then save your objects manually."
+      do_lookup(false) do |o,r|
+        unless r.latitude.nil? or r.longitude.nil?
+          o.send :update_attribute, self.class.geocoder_options[:latitude],  r.latitude
+          o.send :update_attribute, self.class.geocoder_options[:longitude], r.longitude
+        end
+        r.coordinates
+      end
+    end
+
+    def fetch_coordinates(*args)
+      warn "DEPRECATION WARNING: The 'fetch_coordinates' method will cease taking " +
+        "an argument in geocoder v1.0. Please save your objects manually." if args.size > 0
+      do_lookup(false) do |o,r|
+        unless r.latitude.nil? or r.longitude.nil?
+          method = ((args.size > 0 && args.first) ? "update" : "write" ) + "_attribute"
+          o.send method, self.class.geocoder_options[:latitude],  r.latitude
+          o.send method, self.class.geocoder_options[:longitude], r.longitude
+        end
+        r.coordinates
+      end
+    end
+
+    ##
+    # Fetch address and update (save) +address+ data.
+    #
+    def fetch_address!
+      warn "DEPRECATION WARNING: The 'fetch_address!' method is deprecated and will be removed in geocoder v1.0. " +
+        "Please use 'reverse_geocode' instead and then save your objects manually."
+      do_lookup(true) do |o,r|
+        unless r.address.nil?
+          o.send :update_attribute, self.class.geocoder_options[:fetched_address], r.address
+        end
+        r.address
+      end
+    end
+
+    def fetch_address(*args)
+      warn "DEPRECATION WARNING: The 'fetch_address' method will cease taking " +
+        "an argument in geocoder v1.0. Please save your objects manually." if args.size > 0
+      do_lookup(true) do |o,r|
+        unless r.latitude.nil? or r.longitude.nil?
+          method = ((args.size > 0 && args.first) ? "update" : "write" ) + "_attribute"
+          o.send method, self.class.geocoder_options[:fetched_address], r.address
+        end
+        r.address
+      end
+    end
+  end
+end

data/lib/geocoder/orms/base.rb

@@ -0,0 +1,96 @@
+module Geocoder
+  module Orm
+    module Base
+
+      ##
+      # Is this object geocoded? (Does it have latitude and longitude?)
+      #
+      def geocoded?
+        read_coordinates.compact.size > 0
+      end
+
+      ##
+      # Calculate the distance from the object to an arbitrary point.
+      # Takes two floats (latitude, longitude) and a symbol specifying the
+      # units to be used (:mi or :km; default is :mi).
+      #
+      def distance_to(lat, lon, units = :mi)
+        return nil unless geocoded?
+        mylat,mylon = read_coordinates
+        Geocoder::Calculations.distance_between(mylat, mylon, lat, lon, :units => units)
+      end
+
+      alias_method :distance_from, :distance_to
+
+      ##
+      # Get nearby geocoded objects. Takes a radius (integer) and a symbol
+      # representing the units of the ratius (:mi or :km; default is :mi).
+      #
+      def nearbys(radius = 20, units = :mi)
+        return [] unless geocoded?
+        options = {:exclude => self, :units => units}
+        self.class.near(read_coordinates, radius, options)
+      end
+
+      ##
+      # Look up coordinates and assign to +latitude+ and +longitude+ attributes
+      # (or other as specified in +geocoded_by+). Returns coordinates (array).
+      #
+      def geocode
+        fail
+      end
+
+      ##
+      # Look up address and assign to +address+ attribute (or other as specified
+      # in +reverse_geocoded_by+). Returns address (string).
+      #
+      def reverse_geocode
+        fail
+      end
+
+
+      private # --------------------------------------------------------------
+
+      ##
+      # Look up geographic data based on object attributes (configured in
+      # geocoded_by or reverse_geocoded_by) and handle the result with the
+      # block (given to geocoded_by or reverse_geocoded_by). The block is
+      # given two-arguments: the object being geocoded and a
+      # Geocoder::Result object with the geocoding results).
+      #
+      def do_lookup(reverse = false)
+        options = self.class.geocoder_options
+        if reverse and options[:reverse_geocode]
+          args = [:latitude, :longitude]
+        elsif !reverse and options[:geocode]
+          args = [:user_address]
+        else
+          return
+        end
+        args.map!{ |a| send(options[a]) }
+
+        if result = Geocoder.search(*args)
+
+          # execute custom block, if specified in configuration
+          block_key = reverse ? :reverse_block : :geocode_block
+          if custom_block = options[block_key]
+            custom_block.call(self, result)
+
+          # else execute block passed directly to this method,
+          # which generally performs the "auto-assigns"
+          elsif block_given?
+            yield(self, result)
+          end
+        end
+      end
+
+      ##
+      # Read the coordinates [lat,lon] of the object.
+      # Looks at user config to determine attributes.
+      #
+      def read_coordinates
+        [:latitude, :longitude].map{ |i| send self.class.geocoder_options[i] }
+      end
+    end
+  end
+end