geocoder 1.1.0 → 1.1.1

data/CHANGELOG.rdoc

@@ -2,6 +2,14 @@
 
 Per-release changes to Geocoder.
 
+== 1.1.1 (2012 Feb 16)
+
+* Add distance_from_sql class method to geocoded class (thanks github.com/dwilkie).
+* Add OverQueryLimitError and raise when relevant for Google lookup.
+* Fix: don't cache API data if response indicates an error.
+* Fix: within_bounding_box now uses correct lat/lon DB columns (thanks github.com/kongo).
+* Fix: error accessing city in some cases with Yandex result (thanks github.com/kor6n and sld).
+
 == 1.1.0 (2011 Dec 3)
 
 * A block passed to geocoded_by is now always executed, even if the geocoding service returns no results. This means you need to make sure you have results before trying to assign data to your object.

data/lib/geocoder/lookups/base.rb

@@ -120,14 +120,14 @@ module Geocoder
       # Parses a raw search result (returns hash or array).
       #
       def parse_raw_data(raw_data)
-        if defined?(ActiveSupport::JSON)
-          ActiveSupport::JSON.decode(raw_data)
-        else
-          begin
+        begin
+          if defined?(ActiveSupport::JSON)
+            ActiveSupport::JSON.decode(raw_data)
+          else
             JSON.parse(raw_data)
-          rescue
-            warn "Geocoding API's response was not valid JSON."
           end
+        rescue
+          warn "Geocoding API's response was not valid JSON."
         end
       end
 
@@ -146,15 +146,16 @@ module Geocoder
         timeout(Geocoder::Configuration.timeout) do
           url = query_url(query, reverse)
           uri = URI.parse(url)
-          unless cache and response = cache[url]
+          unless cache and body = cache[url]
             client = http_client.new(uri.host, uri.port)
             client.use_ssl = true if Geocoder::Configuration.use_https
-            response = client.get(uri.request_uri).body
-            if cache
-              cache[url] = response
+            response = client.get(uri.request_uri)
+            body = response.body
+            if cache and (200..399).include?(response.code.to_i)
+              cache[url] = body
             end
           end
-          response
+          body
         end
       end
 

data/lib/geocoder/results/yandex.rb

@@ -14,8 +14,10 @@ module Geocoder::Result
     def city
       if state.empty?
         address_details['Locality']['LocalityName']
-      else
+      elsif sub_state.empty?
         address_details['AdministrativeArea']['Locality']['LocalityName']
+      else 
+        address_details['AdministrativeArea']['SubAdministrativeArea']['Locality']['LocalityName']
       end
     end
 
@@ -35,6 +37,14 @@ module Geocoder::Result
       end
     end
 
+    def sub_state
+      if !state.empty? and address_details['AdministrativeArea']['SubAdministrativeArea']
+        address_details['AdministrativeArea']['SubAdministrativeArea']['SubAdministrativeAreaName']
+      else
+        ""
+      end
+    end
+
     def state_code
       ""
     end

data/lib/geocoder/stores/active_record.rb

@@ -50,11 +50,11 @@ module Geocoder::Store
         scope :within_bounding_box, lambda{ |bounds|
           sw_lat, sw_lng, ne_lat, ne_lng = bounds.flatten if bounds
           return where(:id => false) unless sw_lat && sw_lng && ne_lat && ne_lng
-          spans = "latitude BETWEEN #{sw_lat} AND #{ne_lat} AND "
+          spans = "#{geocoder_options[:latitude]} BETWEEN #{sw_lat} AND #{ne_lat} AND "
           spans << if sw_lng > ne_lng   # Handle a box that spans 180
-            "longitude BETWEEN #{sw_lng} AND 180 OR longitude BETWEEN -180 AND #{ne_lng}"
+            "#{geocoder_options[:longitude]} BETWEEN #{sw_lng} AND 180 OR #{geocoder_options[:longitude]} BETWEEN -180 AND #{ne_lng}"
           else
-            "longitude BETWEEN #{sw_lng} AND #{ne_lng}"
+            "#{geocoder_options[:longitude]} BETWEEN #{sw_lng} AND #{ne_lng}"
           end
           { :conditions => spans }
         }
@@ -66,6 +66,11 @@ module Geocoder::Store
     #
     module ClassMethods
 
+      def distance_from_sql(location, *args)
+        latitude, longitude = Geocoder::Calculations.extract_coordinates(location)
+        distance_from_sql_options(latitude, longitude, *args) if latitude and longitude
+      end
+
       private # ----------------------------------------------------------------
 
       ##
@@ -92,14 +97,19 @@ module Geocoder::Store
         end
       end
 
+      def distance_from_sql_options(latitude, longitude, options = {})
+        if connection.adapter_name.match /sqlite/i
+          approx_distance_from_sql(latitude, longitude, options)
+        else
+          full_distance_from_sql(latitude, longitude, options)
+        end
+      end
+
       ##
       # Scope options hash for use with a database that supports POWER(),
       # SQRT(), PI(), and trigonometric functions SIN(), COS(), ASIN(),
       # ATAN2(), DEGREES(), and RADIANS().
       #
-      # Distance calculations based on the excellent tutorial at:
-      # http://www.scribd.com/doc/2569355/Geo-Distance-Search-with-MySQL
-      #
       # Bearing calculation based on:
       # http://www.beginningspatial.com/calculating_bearing_one_point_another
       #
@@ -128,11 +138,8 @@ module Geocoder::Store
             ")) + 360 " +
           "AS decimal) % 360"
         end
-        earth = Geocoder::Calculations.earth_radius(options[:units] || :mi)
-        distance = "#{earth} * 2 * ASIN(SQRT(" +
-          "POWER(SIN((#{latitude} - #{lat_attr}) * PI() / 180 / 2), 2) + " +
-          "COS(#{latitude} * PI() / 180) * COS(#{lat_attr} * PI() / 180) * " +
-          "POWER(SIN((#{longitude} - #{lon_attr}) * PI() / 180 / 2), 2) ))"
+
+        distance = full_distance_from_sql(latitude, longitude, options)
         conditions = ["#{distance} <= ?", radius]
         default_near_scope_options(latitude, longitude, radius, options).merge(
           :select => "#{options[:select] || "#{table_name}.*"}, " +
@@ -142,6 +149,36 @@ module Geocoder::Store
         )
       end
 
+
+      # Distance calculations based on the excellent tutorial at:
+      # http://www.scribd.com/doc/2569355/Geo-Distance-Search-with-MySQL
+
+      def full_distance_from_sql(latitude, longitude, options)
+        lat_attr = geocoder_options[:latitude]
+        lon_attr = geocoder_options[:longitude]
+
+        earth = Geocoder::Calculations.earth_radius(options[:units] || :mi)
+
+        "#{earth} * 2 * ASIN(SQRT(" +
+          "POWER(SIN((#{latitude} - #{table_name}.#{lat_attr}) * PI() / 180 / 2), 2) + " +
+          "COS(#{latitude} * PI() / 180) * COS(#{table_name}.#{lat_attr} * PI() / 180) * " +
+          "POWER(SIN((#{longitude} - #{table_name}.#{lon_attr}) * PI() / 180 / 2), 2) ))"
+      end
+
+      def approx_distance_from_sql(latitude, longitude, options)
+        lat_attr = geocoder_options[:latitude]
+        lon_attr = geocoder_options[:longitude]
+
+        dx = Geocoder::Calculations.longitude_degree_distance(30, options[:units] || :mi)
+        dy = Geocoder::Calculations.latitude_degree_distance(options[:units] || :mi)
+
+        # sin of 45 degrees = average x or y component of vector
+        factor = Math.sin(Math::PI / 4)
+
+        "(#{dy} * ABS(#{table_name}.#{lat_attr} - #{latitude}) * #{factor}) + " +
+          "(#{dx} * ABS(#{table_name}.#{lon_attr} - #{longitude}) * #{factor})"
+      end
+
       ##
       # Scope options hash for use with a database without trigonometric
       # functions, like SQLite. Approach is to find objects within a square
@@ -166,14 +203,8 @@ module Geocoder::Store
           bearing = false
         end
 
-        dx = Geocoder::Calculations.longitude_degree_distance(30, options[:units] || :mi)
-        dy = Geocoder::Calculations.latitude_degree_distance(options[:units] || :mi)
-
-        # sin of 45 degrees = average x or y component of vector
-        factor = Math.sin(Math::PI / 4)
+        distance = approx_distance_from_sql(latitude, longitude, options)
 
-        distance = "(#{dy} * ABS(#{lat_attr} - #{latitude}) * #{factor}) + " +
-          "(#{dx} * ABS(#{lon_attr} - #{longitude}) * #{factor})"
         b = Geocoder::Calculations.bounding_box([latitude, longitude], radius, options)
         conditions = [
           "#{lat_attr} BETWEEN ? AND ? AND #{lon_attr} BETWEEN ? AND ?"] +
@@ -235,11 +266,12 @@ module Geocoder::Store
     #
     def reverse_geocode
       do_lookup(true) do |o,rs|
-        r = rs.first
-        unless r.address.nil?
-          o.send :write_attribute, self.class.geocoder_options[:fetched_address], r.address
+        if r = rs.first
+          unless r.address.nil?
+            o.send :write_attribute, self.class.geocoder_options[:fetched_address], r.address
+          end
+          r.address
         end
-        r.address
       end
     end
 

data/lib/geocoder/stores/mongo_base.rb

@@ -71,11 +71,12 @@ module Geocoder::Store
     #
     def reverse_geocode
       do_lookup(true) do |o,rs|
-        r = rs.first
-        unless r.address.nil?
-          o.send :write_attribute, self.class.geocoder_options[:fetched_address], r.address
+        if r = rs.first
+          unless r.address.nil?
+            o.send :write_attribute, self.class.geocoder_options[:fetched_address], r.address
+          end
+          r.address
         end
-        r.address
       end
     end
   end

data/lib/geocoder/version.rb

@@ -1,3 +1,3 @@
 module Geocoder
-  VERSION = "1.1.0"
+  VERSION = "1.1.1"
 end

metadata

@@ -2,7 +2,7 @@
 name: geocoder
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 1.1.0
+  version: 1.1.1
 platform: ruby
 authors: 
 - Alex Reisner
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-12-03 00:00:00 -05:00
+date: 2012-02-16 00:00:00 -05:00
 default_executable: 
 dependencies: []