rails-geocoder 0.9.10 → 0.9.11

data/lib/geocoder/results/google.rb

@@ -12,19 +12,31 @@ module Geocoder::Result
     end
 
     def city
-      address_components_of_type(:locality).first['long_name']
+      fields = [:locality, :sublocality, :administrative_area_level_3,
+        :administrative_area_level_2, :administrative_area_level_1]
+      fields.each do |f|
+        if entity = address_components_of_type(f).first
+          return entity['long_name']
+        end
+      end
     end
 
     def country
-      address_components_of_type(:country).first['long_name']
+      if country = address_components_of_type(:country).first
+        country['long_name']
+      end
     end
 
     def country_code
-      address_components_of_type(:country).first['short_name']
+      if country = address_components_of_type(:country).first
+        country['short_name']
+      end
     end
 
     def postal_code
-      address_components_of_type(:postal_code).first['long_name']
+      if postal = address_components_of_type(:postal_code).first
+        postal['long_name']
+      end
     end
 
     def types

data/test/fixtures/geocoder_ca_madison_square_garden.json

@@ -0,0 +1 @@
+test({"longt":"-73.992006","latt":"40.749101"});

data/test/fixtures/geocoder_ca_no_results.json

@@ -0,0 +1 @@
+test({"longt":"-0.000000","error":{"description":"Postal Code is not in the proper Format.","code":"005"},"latt":"176946676.000000"});

data/test/fixtures/geocoder_ca_reverse.json

@@ -0,0 +1,34 @@
+test({
+  "latt":"45.423733",
+  "longt":"-75.676333",
+  "inlatt":"45.424035",
+  "inlongt":"-75.675941",
+  "betweenRoad1":"Chapel",
+  "betweenRoad2":"Russell",
+  "distance":"0.034",
+  "stnumber":"289",
+  "staddress":"Somerset ST E",
+  "city":"Ottawa",
+  "prov":"ON",
+  "postal":"K1N6W1",
+  "NearRoad":"Somerset ST E",
+  "NearRoadDistance":"0.013",
+  "intersection":{
+    "lattx":"45.423733",
+    "longtx":"-75.676333",
+    "distance":"0.045",
+    "street1":"Somerset St E",
+    "street2":"Russell Ave",
+    "city":"OTTAWA",
+    "prov":"ON"
+  },
+  "major_intersection":{
+    "lattx":"45.4241623853",
+    "longtx":"-75.6753026518",
+    "distance":"0.052",
+    "street1":"Chapel St",
+    "street2":"Somerset St E",
+    "city":"OTTAWA",
+    "prov":"ON"
+  }
+});

data/test/fixtures/google_no_locality.json

@@ -0,0 +1,51 @@
+{
+  "status": "OK",
+  "results": [ {
+    "types": [ "route" ],
+    "formatted_address": "Al Ahram, Haram, Giza, Egypt",
+    "address_components": [ {
+      "long_name": "Al Ahram",
+      "short_name": "Al Ahram",
+      "types": [ "route" ]
+    }, {
+      "long_name": "Haram",
+      "short_name": "Haram",
+      "types": [ "administrative_area_level_2", "political" ]
+    }, {
+      "long_name": "Al Jizah",
+      "short_name": "Al Jizah",
+      "types": [ "administrative_area_level_1", "political" ]
+    }, {
+      "long_name": "Egypt",
+      "short_name": "EG",
+      "types": [ "country", "political" ]
+    } ],
+    "geometry": {
+      "location": {
+        "lat": 29.9803527,
+        "lng": 31.1330307
+      },
+      "location_type": "APPROXIMATE",
+      "viewport": {
+        "southwest": {
+          "lat": 29.9768276,
+          "lng": 31.1302189
+        },
+        "northeast": {
+          "lat": 29.9831228,
+          "lng": 31.1365141
+        }
+      },
+      "bounds": {
+        "southwest": {
+          "lat": 29.9775337,
+          "lng": 31.1327483
+        },
+        "northeast": {
+          "lat": 29.9824167,
+          "lng": 31.1339847
+        }
+      }
+    }
+  } ]
+}

data/test/geocoder_test.rb

@@ -1,9 +1,10 @@
+# encoding: utf-8
 require 'test_helper'
 
 class GeocoderTest < Test::Unit::TestCase
 
   def setup
-    Geocoder::Configuration.lookup = :google
+    Geocoder::Configuration.set_defaults
   end
 
 
@@ -19,22 +20,15 @@ class GeocoderTest < Test::Unit::TestCase
 
   # --- sanity checks ---
 
-  def test_distance_between
-    assert_equal 69, Geocoder::Calculations.distance_between(0,0, 0,1).round
-  end
-
-  def test_geographic_center
-    assert_equal [0.0, 0.5],
-      Geocoder::Calculations.geographic_center([[0,0], [0,1]])
-    assert_equal [0.0, 1.0],
-      Geocoder::Calculations.geographic_center([[0,0], [0,1], [0,2]])
+  def test_uses_https_for_secure_query
+    Geocoder::Configuration.use_https = true
+    g = Geocoder::Lookup::Google.new
+    assert_match /^https:/, g.send(:query_url, {:a => 1, :b => 2})
   end
 
-  def test_does_not_choke_on_nil_address
-    v = Venue.new("Venue", nil)
-    assert_nothing_raised do
-      v.geocode
-    end
+  def test_uses_http_by_default
+    g = Geocoder::Lookup::Google.new
+    assert_match /^http:/, g.send(:query_url, {:a => 1, :b => 2})
   end
 
   def test_distance_to_returns_float
@@ -49,6 +43,14 @@ class GeocoderTest < Test::Unit::TestCase
     assert_equal v.distance_from(30, -94), v.distance_to(30, -94)
   end
 
+  def test_coordinates_method
+    assert Geocoder.coordinates("Madison Square Garden, New York, NY").is_a?(Array)
+  end
+
+  def test_address_method
+    assert Geocoder.address(40.750354, -73.993371).is_a?(String)
+  end
+
 
   # --- general ---
 
@@ -70,7 +72,7 @@ class GeocoderTest < Test::Unit::TestCase
     e = Event.new(*venue_params(:msg))
     coords = [40.750354, -73.993371]
     e.geocode
-    assert_equal coords.map{ |c| c.to_s }.join(','), e.coordinates
+    assert_equal coords.map{ |c| c.to_s }.join(','), e.coords_string
   end
 
   def test_geocode_with_block_doesnt_auto_assign_coordinates
@@ -118,22 +120,176 @@ class GeocoderTest < Test::Unit::TestCase
     assert_equal address, v.address
   end
 
+  def test_search_returns_empty_array_when_no_results
+    street_lookups.each do |l|
+      Geocoder::Configuration.lookup = l
+      assert_equal [], Geocoder.search("no results"),
+        "Lookup #{l} does not return empty array when no results."
+    end
+  end
+
+  def test_result_has_required_attributes
+    all_lookups.each do |l|
+      Geocoder::Configuration.lookup = l
+      result = Geocoder.search(45.423733, -75.676333).first
+      assert_result_has_required_attributes(result)
+    end
+  end
+
+
+  # --- calcluations ---
+
+  def test_longitude_degree_distance_at_equator
+    assert_equal 69, Geocoder::Calculations.longitude_degree_distance(0).round
+  end
+
+  def test_longitude_degree_distance_at_new_york
+    assert_equal 53, Geocoder::Calculations.longitude_degree_distance(40).round
+  end
+
+  def test_longitude_degree_distance_at_north_pole
+    assert_equal 0, Geocoder::Calculations.longitude_degree_distance(89.98).round
+  end
+
+  def test_distance_between_in_miles
+    assert_equal 69, Geocoder::Calculations.distance_between(0,0, 0,1).round
+    la_to_ny = Geocoder::Calculations.distance_between(34.05,-118.25, 40.72,-74).round
+    assert (la_to_ny - 2444).abs < 10
+  end
+
+  def test_distance_between_in_kilometers
+    assert_equal 111, Geocoder::Calculations.distance_between(0,0, 0,1, :units => :km).round
+    la_to_ny = Geocoder::Calculations.distance_between(34.05,-118.25, 40.72,-74, :units => :km).round
+    assert (la_to_ny - 3942).abs < 10
+  end
+
+  def test_geographic_center_with_arrays
+    assert_equal [0.0, 0.5],
+      Geocoder::Calculations.geographic_center([[0,0], [0,1]])
+    assert_equal [0.0, 1.0],
+      Geocoder::Calculations.geographic_center([[0,0], [0,1], [0,2]])
+  end
+
+  def test_geographic_center_with_mixed_arguments
+    p1 = [0, 0]
+    p2 = Landmark.new("Some Cold Place", 0, 1)
+    assert_equal [0.0, 0.5], Geocoder::Calculations.geographic_center([p1, p2])
+  end
+
+  def test_bounding_box_calculation_in_miles
+    center = [51, 7] # Cologne, DE
+    radius = 10 # miles
+    dlon = radius / Geocoder::Calculations.latitude_degree_distance
+    dlat = radius / Geocoder::Calculations.longitude_degree_distance(center[0])
+    corners = [50.86, 6.77, 51.14, 7.23]
+    assert_equal corners.map{ |i| (i * 100).round },
+      Geocoder::Calculations.bounding_box(center[0], center[1], radius).map{ |i| (i * 100).round }
+  end
+
+  def test_bounding_box_calculation_in_kilometers
+    center = [51, 7] # Cologne, DE
+    radius = 111 # kilometers (= 1 degree latitude)
+    dlon = radius / Geocoder::Calculations.latitude_degree_distance(:km)
+    dlat = radius / Geocoder::Calculations.longitude_degree_distance(center[0], :km)
+    corners = [50, 5.41, 52, 8.59]
+    assert_equal corners.map{ |i| (i * 100).round },
+      Geocoder::Calculations.bounding_box(center[0], center[1], radius, :units => :km).map{ |i| (i * 100).round }
+  end
+
+
+  # --- bearing ---
+
+  def test_compass_points
+    assert_equal "N",  Geocoder::Calculations.compass_point(0)
+    assert_equal "N",  Geocoder::Calculations.compass_point(1.0)
+    assert_equal "N",  Geocoder::Calculations.compass_point(360)
+    assert_equal "N",  Geocoder::Calculations.compass_point(361)
+    assert_equal "N",  Geocoder::Calculations.compass_point(-22)
+    assert_equal "NW", Geocoder::Calculations.compass_point(-23)
+    assert_equal "S",  Geocoder::Calculations.compass_point(180)
+    assert_equal "S",  Geocoder::Calculations.compass_point(181)
+  end
+
+  def test_bearing_between
+    bearings = {
+      :n => 0,
+      :e => 90,
+      :s => 180,
+      :w => 270
+    }
+    points = {
+      :n => [41, -75],
+      :e => [40, -74],
+      :s => [39, -75],
+      :w => [40, -76]
+    }
+    directions = [:n, :e, :s, :w]
+    methods = [:linear, :spherical]
+
+    methods.each do |m|
+      directions.each_with_index do |d,i|
+        opp = directions[(i + 2) % 4] # opposite direction
+        p1 = points[d]
+        p2 = points[opp]
+
+        args = p1 + p2 + [:method => m]
+        b = Geocoder::Calculations.bearing_between(*args)
+        assert (b - bearings[opp]).abs < 1,
+          "Bearing (#{m}) should be close to #{bearings[opp]} but was #{b}."
+      end
+    end
+  end
+
+
+  # --- input handling ---
+
+  def test_ip_address_detection
+    assert Geocoder.send(:ip_address?, "232.65.123.94")
+    assert Geocoder.send(:ip_address?, "666.65.123.94") # technically invalid
+    assert !Geocoder.send(:ip_address?, "232.65.123.94.43")
+    assert !Geocoder.send(:ip_address?, "232.65.123")
+  end
+
+  def test_blank_query_detection
+    assert Geocoder.send(:blank_query?, nil)
+    assert Geocoder.send(:blank_query?, "")
+    assert Geocoder.send(:blank_query?, "\t  ")
+    assert !Geocoder.send(:blank_query?, "a")
+    assert !Geocoder.send(:blank_query?, "Москва") # no ASCII characters
+  end
+
+  def test_does_not_choke_on_nil_address
+    all_lookups.each do |l|
+      Geocoder::Configuration.lookup = l
+      assert_nothing_raised { Venue.new("Venue", nil).geocode }
+    end
+  end
+
+
+  # --- error handling ---
+
+  def test_does_not_choke_on_timeout
+    # keep test output clean: suppress timeout warning
+    orig = $VERBOSE; $VERBOSE = nil
+    all_lookups.each do |l|
+      Geocoder::Configuration.lookup = l
+      assert_nothing_raised { Geocoder.search("timeout") }
+    end
+    $VERBOSE = orig
+  end
+
 
   # --- Google ---
 
-  def test_result_address_components_of_type
-    result = Geocoder.search("Madison Square Garden, New York, NY")
+  def test_google_result_components
+    result = Geocoder.search("Madison Square Garden, New York, NY").first
     assert_equal "Manhattan",
       result.address_components_of_type(:sublocality).first['long_name']
   end
 
-  def test_google_result_has_required_attributes
-    result = Geocoder.search("Madison Square Garden, New York, NY")
-    assert_result_has_required_attributes(result)
-  end
-
-  def test_google_returns_nil_when_no_results
-    assert_nil Geocoder.search("no results")
+  def test_google_returns_city_when_no_locality_in_result
+    result = Geocoder.search("no locality").first
+    assert_equal "Haram", result.city
   end
 
 
@@ -141,79 +297,79 @@ class GeocoderTest < Test::Unit::TestCase
 
   def test_yahoo_result_components
     Geocoder::Configuration.lookup = :yahoo
-    result = Geocoder.search("Madison Square Garden, New York, NY")
-    assert_equal "10001", result.postal
+    result = Geocoder.search("Madison Square Garden, New York, NY").first
+    assert_equal "10001", result.postal_code
   end
 
   def test_yahoo_address_formatting
     Geocoder::Configuration.lookup = :yahoo
-    result = Geocoder.search("Madison Square Garden, New York, NY")
+    result = Geocoder.search("Madison Square Garden, New York, NY").first
     assert_equal "Madison Square Garden, New York, NY  10001, United States",
       result.address
   end
 
-  def test_yahoo_result_has_required_attributes
-    Geocoder::Configuration.lookup = :yahoo
-    result = Geocoder.search("Madison Square Garden, New York, NY")
-    assert_result_has_required_attributes(result)
-  end
 
-  def test_yahoo_returns_nil_when_no_results
-    Geocoder::Configuration.lookup = :yahoo
-    assert_nil Geocoder.search("no results")
+  # --- Geocoder.ca ---
+
+  def test_geocoder_ca_result_components
+    Geocoder::Configuration.lookup = :geocoder_ca
+    result = Geocoder.search(45.423733, -75.676333).first
+    assert_equal "CA", result.country_code
+    assert_equal "289 Somerset ST E, Ottawa, ON K1N6W1, Canada", result.address
   end
 
 
   # --- FreeGeoIp ---
 
   def test_freegeoip_result_on_ip_address_search
-    result = Geocoder.search("74.200.247.59")
+    result = Geocoder.search("74.200.247.59").first
     assert result.is_a?(Geocoder::Result::Freegeoip)
   end
 
   def test_freegeoip_result_components
-    result = Geocoder.search("74.200.247.59")
+    result = Geocoder.search("74.200.247.59").first
     assert_equal "Plano, TX 75093, United States", result.address
   end
 
-  def test_freegeoip_result_has_required_attributes
-    result = Geocoder.search("74.200.247.59")
-    assert_result_has_required_attributes(result)
-  end
-
 
   # --- search queries ---
 
-  def test_ip_address_detection
-    assert Geocoder.send(:ip_address?, "232.65.123.94")
-    assert Geocoder.send(:ip_address?, "666.65.123.94") # technically invalid
-    assert !Geocoder.send(:ip_address?, "232.65.123.94.43")
-    assert !Geocoder.send(:ip_address?, "232.65.123")
+  def test_hash_to_query
+    g = Geocoder::Lookup::Google.new
+    assert_equal "a=1&b=2", g.send(:hash_to_query, {:a => 1, :b => 2})
   end
 
-  def test_blank_query_detection
-    assert Geocoder.send(:blank_query?, nil)
-    assert Geocoder.send(:blank_query?, "")
-    assert Geocoder.send(:blank_query?, ", , (-)")
-    assert !Geocoder.send(:blank_query?, "a")
+  def test_google_api_key
+    Geocoder::Configuration.api_key = "MY_KEY"
+    g = Geocoder::Lookup::Google.new
+    assert_match "key=MY_KEY", g.send(:query_url, "Madison Square Garden, New York, NY  10001, United States")
   end
 
-  def test_hash_to_query
-    g = Geocoder::Lookup::Google.new
-    assert_equal "a=1&b=2", g.send(:hash_to_query, {:a => 1, :b => 2})
+  def test_yahoo_app_id
+    Geocoder::Configuration.api_key = "MY_KEY"
+    g = Geocoder::Lookup::Yahoo.new
+    assert_match "appid=MY_KEY", g.send(:query_url, "Madison Square Garden, New York, NY  10001, United States")
+  end
+
+  def test_detection_of_coordinates_in_search_string
+    Geocoder::Configuration.lookup = :geocoder_ca
+    result = Geocoder.search("51.178844, -1.826189").first
+    assert_not_nil result.city
+    # city only present if reverse geocoding search performed
   end
 
 
   private # ------------------------------------------------------------------
 
   def assert_result_has_required_attributes(result)
-    assert result.coordinates.is_a?(Array)
-    assert result.latitude.is_a?(Float)
-    assert result.longitude.is_a?(Float)
-    assert result.city.is_a?(String)
-    assert result.postal_code.is_a?(String)
-    assert result.country.is_a?(String)
-    assert result.country_code.is_a?(String)
-    assert_not_nil result.address
+    m = "Lookup #{Geocoder::Configuration.lookup} does not support %s attribute."
+    assert result.coordinates.is_a?(Array),   m % "coordinates"
+    assert result.latitude.is_a?(Float),      m % "latitude"
+    assert result.longitude.is_a?(Float),     m % "longitude"
+    assert result.city.is_a?(String),         m % "city"
+    assert result.postal_code.is_a?(String),  m % "postal_code"
+    assert result.country.is_a?(String),      m % "country"
+    assert result.country_code.is_a?(String), m % "country_code"
+    assert_not_nil result.address,            m % "address"
   end
 end