geokit 1.8.5 → 1.9.0

data/test/test_inflector.rb

@@ -2,7 +2,6 @@
 require File.join(File.dirname(__FILE__), 'helper')
 
 class InflectorTest < Test::Unit::TestCase #:nodoc: all
-
   def test_titleize
     assert_equal 'Sugar Grove', Geokit::Inflector.titleize('Sugar Grove')
     assert_equal 'Sugar Grove', Geokit::Inflector.titleize('Sugar grove')

data/test/test_ipgeocoder.rb

@@ -2,29 +2,28 @@
 require File.join(File.dirname(__FILE__), 'helper')
 
 class IpGeocoderTest < BaseGeocoderTest #:nodoc: all
-
-  IP_FAILURE=<<-EOF
+  IP_FAILURE = <<-EOF
     Country: SWITZERLAND (CH)
     City: (Unknown City)
     Latitude:
     Longitude:
     EOF
 
-  IP_SUCCESS=<<-EOF
+  IP_SUCCESS = <<-EOF
     Country: UNITED STATES (US)
     City: Sugar Grove, IL
     Latitude: 41.7696
     Longitude: -88.4588
     EOF
 
-  IP_LATIN=<<-EOF
+  IP_LATIN = <<-EOF
     Country: BRAZIL (BR)
     City: S\xE3o Jos\xE9 do Rio Pr\xEAto\n
     Latitude: -20.8
     Longitude: -49.3833
     EOF
 
-  IP_UNICODED=<<-EOF
+  IP_UNICODED = <<-EOF
     Country: SWEDEN (SE)
     City: Borås
     Latitude: 57.7167
@@ -45,7 +44,7 @@ class IpGeocoderTest < BaseGeocoderTest #:nodoc: all
 
   def setup
     super
-    @success.provider = "ip"
+    @success.provider = 'ip'
   end
 
   def test_successful_lookup
@@ -57,10 +56,10 @@ class IpGeocoderTest < BaseGeocoderTest #:nodoc: all
     assert_not_nil location
     assert_equal 41.7696, location.lat
     assert_equal(-88.4588, location.lng)
-    assert_equal "Sugar Grove", location.city
-    assert_equal "IL", location.state
-    assert_equal "US", location.country_code
-    assert_equal "ip", location.provider
+    assert_equal 'Sugar Grove', location.city
+    assert_equal 'IL', location.state
+    assert_equal 'US', location.country_code
+    assert_equal 'ip', location.provider
     assert location.success?
   end
 
@@ -75,8 +74,8 @@ class IpGeocoderTest < BaseGeocoderTest #:nodoc: all
     assert_equal 12.9167, location.lng
     assert_equal "Bor\303\245s", location.city
     assert_nil location.state
-    assert_equal "SE", location.country_code
-    assert_equal "ip", location.provider
+    assert_equal 'SE', location.country_code
+    assert_equal 'ip', location.provider
     assert location.success?
   end
 
@@ -90,10 +89,10 @@ class IpGeocoderTest < BaseGeocoderTest #:nodoc: all
     assert_not_nil location
     assert_equal -20.8, location.lat
     assert_equal -49.3833, location.lng
-    assert_equal "São José Do Rio Prêto", location.city
+    assert_equal 'São José Do Rio Prêto', location.city
     assert_nil location.state
-    assert_equal "BR", location.country_code
-    assert_equal "ip", location.provider
+    assert_equal 'BR', location.country_code
+    assert_equal 'ip', location.provider
     assert location.success?
   end
 
@@ -102,7 +101,7 @@ class IpGeocoderTest < BaseGeocoderTest #:nodoc: all
     failure.expects(:body).returns(IP_FAILURE)
     url = 'http://api.hostip.info/get_html.php?ip=128.178.0.0&position=true'
     Geokit::Geocoders::IpGeocoder.expects(:call_geocoder_service).with(url).returns(failure)
-    location = Geokit::Geocoders::IpGeocoder.geocode("128.178.0.0")
+    location = Geokit::Geocoders::IpGeocoder.geocode('128.178.0.0')
     assert_not_nil location
     assert !location.success?
   end
@@ -118,7 +117,7 @@ class IpGeocoderTest < BaseGeocoderTest #:nodoc: all
 
   def test_invalid_ip
     Geokit::Geocoders::IpGeocoder.expects(:call_geocoder_service).never
-    location = Geokit::Geocoders::IpGeocoder.geocode("blah")
+    location = Geokit::Geocoders::IpGeocoder.geocode('blah')
     assert_not_nil location
     assert !location.success?
   end
@@ -127,7 +126,7 @@ class IpGeocoderTest < BaseGeocoderTest #:nodoc: all
     failure = MockFailure.new
     url = 'http://api.hostip.info/get_html.php?ip=12.215.42.19&position=true'
     Geokit::Geocoders::IpGeocoder.expects(:call_geocoder_service).with(url).returns(failure)
-    location = Geokit::Geocoders::IpGeocoder.geocode("12.215.42.19")
+    location = Geokit::Geocoders::IpGeocoder.geocode('12.215.42.19')
     assert_not_nil location
     assert !location.success?
   end

data/test/test_latlng.rb

@@ -1,65 +1,80 @@
 require File.join(File.dirname(__FILE__), 'helper')
 
 class LatLngTest < Test::Unit::TestCase #:nodoc: all
-
   def setup
-    @loc_a = Geokit::LatLng.new(32.918593,-96.958444)
-    @loc_e = Geokit::LatLng.new(32.969527,-96.990159)
+    @loc_a = Geokit::LatLng.new(32.918593, -96.958444)
+    @loc_e = Geokit::LatLng.new(32.969527, -96.990159)
     @point = Geokit::LatLng.new(@loc_a.lat, @loc_a.lng)
   end
 
   def valid_reverse_geocoding_result
     location = Geokit::GeoLoc.new({
-      :city => "Essen",
-      :country_code => "DE",
-      :lat => 51.4578329,
-      :lng => 7.0166848,
-      :provider => "google",
-      :state => "Nordrhein-Westfalen",
-      :street_address => "Porscheplatz 1",
-      :zip => "45127"
+      city: 'Essen',
+      country_code: 'DE',
+      lat: 51.4578329,
+      lng: 7.0166848,
+      provider: 'google',
+      state: 'Nordrhein-Westfalen',
+      street_address: 'Porscheplatz 1',
+      zip: '45127'
     })
 
-    location.full_address = "Porscheplatz 1, 45127 Essen, Deutschland"
+    location.full_address = 'Porscheplatz 1, 45127 Essen, Deutschland'
     location.precision = 'address'
     location.provider = 'google'
     location.success = true
     location
   end
 
+  def test_existance_of_latitude_alias
+    assert_respond_to(@loc_a, :latitude)
+  end
+
+  def test_existance_of_longitude_alias
+    assert_respond_to(@loc_a, :longitude)
+  end
+
+  def test_that_lat_and_latitude_are_same_object
+    assert_same(@loc_a.lat, @loc_a.latitude)
+  end
+
+  def test_that_lng_and_longitude_are_same_object
+    assert_same(@loc_a.lng, @loc_a.longitude)
+  end
+
   def test_distance_between_same_using_defaults
     assert_equal 0, Geokit::LatLng.distance_between(@loc_a, @loc_a)
     assert_equal 0, @loc_a.distance_to(@loc_a)
   end
 
   def test_distance_between_same_with_miles_and_flat
-    assert_equal 0, Geokit::LatLng.distance_between(@loc_a, @loc_a, :units => :miles, :formula => :flat)
-    assert_equal 0, @loc_a.distance_to(@loc_a, :units => :miles, :formula => :flat)
+    assert_equal 0, Geokit::LatLng.distance_between(@loc_a, @loc_a, units: :miles, formula: :flat)
+    assert_equal 0, @loc_a.distance_to(@loc_a, units: :miles, formula: :flat)
   end
 
   def test_distance_between_same_with_kms_and_flat
-    assert_equal 0, Geokit::LatLng.distance_between(@loc_a, @loc_a, :units => :kms, :formula => :flat)
-    assert_equal 0, @loc_a.distance_to(@loc_a, :units => :kms, :formula => :flat)
+    assert_equal 0, Geokit::LatLng.distance_between(@loc_a, @loc_a, units: :kms, formula: :flat)
+    assert_equal 0, @loc_a.distance_to(@loc_a, units: :kms, formula: :flat)
   end
 
   def test_distance_between_same_with_nms_and_flat
-    assert_equal 0, Geokit::LatLng.distance_between(@loc_a, @loc_a, :units => :nms, :formula => :flat)
-    assert_equal 0, @loc_a.distance_to(@loc_a, :units => :nms, :formula => :flat)
+    assert_equal 0, Geokit::LatLng.distance_between(@loc_a, @loc_a, units: :nms, formula: :flat)
+    assert_equal 0, @loc_a.distance_to(@loc_a, units: :nms, formula: :flat)
   end
 
   def test_distance_between_same_with_miles_and_sphere
-    assert_equal 0, Geokit::LatLng.distance_between(@loc_a, @loc_a, :units => :miles, :formula => :sphere)
-    assert_equal 0, @loc_a.distance_to(@loc_a, :units => :miles, :formula => :sphere)
+    assert_equal 0, Geokit::LatLng.distance_between(@loc_a, @loc_a, units: :miles, formula: :sphere)
+    assert_equal 0, @loc_a.distance_to(@loc_a, units: :miles, formula: :sphere)
   end
 
   def test_distance_between_same_with_kms_and_sphere
-    assert_equal 0, Geokit::LatLng.distance_between(@loc_a, @loc_a, :units => :kms, :formula => :sphere)
-    assert_equal 0, @loc_a.distance_to(@loc_a, :units => :kms, :formula => :sphere)
+    assert_equal 0, Geokit::LatLng.distance_between(@loc_a, @loc_a, units: :kms, formula: :sphere)
+    assert_equal 0, @loc_a.distance_to(@loc_a, units: :kms, formula: :sphere)
   end
 
   def test_distance_between_same_with_nms_and_sphere
-    assert_equal 0, Geokit::LatLng.distance_between(@loc_a, @loc_a, :units => :nms, :formula => :sphere)
-    assert_equal 0, @loc_a.distance_to(@loc_a, :units => :nms, :formula => :sphere)
+    assert_equal 0, Geokit::LatLng.distance_between(@loc_a, @loc_a, units: :nms, formula: :sphere)
+    assert_equal 0, @loc_a.distance_to(@loc_a, units: :nms, formula: :sphere)
   end
 
   def test_distance_between_diff_using_defaults
@@ -68,46 +83,51 @@ class LatLngTest < Test::Unit::TestCase #:nodoc: all
   end
 
   def test_distance_between_diff_with_miles_and_flat
-    assert_in_delta 3.97, Geokit::LatLng.distance_between(@loc_a, @loc_e, :units => :miles, :formula => :flat), 0.2
-    assert_in_delta 3.97, @loc_a.distance_to(@loc_e, :units => :miles, :formula => :flat), 0.2
+    assert_in_delta 3.97, Geokit::LatLng.distance_between(@loc_a, @loc_e, units: :miles, formula: :flat), 0.2
+    assert_in_delta 3.97, @loc_a.distance_to(@loc_e, units: :miles, formula: :flat), 0.2
   end
 
   def test_distance_between_diff_with_kms_and_flat
-    assert_in_delta 6.39, Geokit::LatLng.distance_between(@loc_a, @loc_e, :units => :kms, :formula => :flat), 0.4
-    assert_in_delta 6.39, @loc_a.distance_to(@loc_e, :units => :kms, :formula => :flat), 0.4
+    assert_in_delta 6.39, Geokit::LatLng.distance_between(@loc_a, @loc_e, units: :kms, formula: :flat), 0.4
+    assert_in_delta 6.39, @loc_a.distance_to(@loc_e, units: :kms, formula: :flat), 0.4
+  end
+
+  def test_distance_between_diff_with_meters_and_flat
+    assert_in_delta 6390, Geokit::LatLng.distance_between(@loc_a, @loc_e, units: :meters, formula: :flat), 2
+    assert_in_delta 6390, @loc_a.distance_to(@loc_e, units: :meters, formula: :flat), 2
   end
 
   def test_distance_between_diff_with_nms_and_flat
-    assert_in_delta 3.334, Geokit::LatLng.distance_between(@loc_a, @loc_e, :units => :nms, :formula => :flat), 0.4
-    assert_in_delta 3.334, @loc_a.distance_to(@loc_e, :units => :nms, :formula => :flat), 0.4
+    assert_in_delta 3.334, Geokit::LatLng.distance_between(@loc_a, @loc_e, units: :nms, formula: :flat), 0.4
+    assert_in_delta 3.334, @loc_a.distance_to(@loc_e, units: :nms, formula: :flat), 0.4
   end
 
   def test_distance_between_diff_with_miles_and_sphere
-    assert_in_delta 3.97, Geokit::LatLng.distance_between(@loc_a, @loc_e, :units => :miles, :formula => :sphere), 0.01
-    assert_in_delta 3.97, @loc_a.distance_to(@loc_e, :units => :miles, :formula => :sphere), 0.01
+    assert_in_delta 3.97, Geokit::LatLng.distance_between(@loc_a, @loc_e, units: :miles, formula: :sphere), 0.01
+    assert_in_delta 3.97, @loc_a.distance_to(@loc_e, units: :miles, formula: :sphere), 0.01
   end
 
   def test_distance_between_diff_with_kms_and_sphere
-    assert_in_delta 6.39, Geokit::LatLng.distance_between(@loc_a, @loc_e, :units => :kms, :formula => :sphere), 0.01
-    assert_in_delta 6.39, @loc_a.distance_to(@loc_e, :units => :kms, :formula => :sphere), 0.01
+    assert_in_delta 6.39, Geokit::LatLng.distance_between(@loc_a, @loc_e, units: :kms, formula: :sphere), 0.01
+    assert_in_delta 6.39, @loc_a.distance_to(@loc_e, units: :kms, formula: :sphere), 0.01
   end
 
   def test_distance_between_diff_with_nms_and_sphere
-    assert_in_delta 3.454, Geokit::LatLng.distance_between(@loc_a, @loc_e, :units => :nms, :formula => :sphere), 0.01
-    assert_in_delta 3.454, @loc_a.distance_to(@loc_e, :units => :nms, :formula => :sphere), 0.01
+    assert_in_delta 3.454, Geokit::LatLng.distance_between(@loc_a, @loc_e, units: :nms, formula: :sphere), 0.01
+    assert_in_delta 3.454, @loc_a.distance_to(@loc_e, units: :nms, formula: :sphere), 0.01
   end
 
   def test_manually_mixed_in
     assert_equal 0, Geokit::LatLng.distance_between(@point, @point)
     assert_equal 0, @point.distance_to(@point)
     assert_equal 0, @point.distance_to(@loc_a)
-    assert_in_delta 3.97, @point.distance_to(@loc_e, :units => :miles, :formula => :flat), 0.2
-    assert_in_delta 6.39, @point.distance_to(@loc_e, :units => :kms, :formula => :flat), 0.4
-    assert_in_delta 3.334, @point.distance_to(@loc_e, :units => :nms, :formula => :flat), 0.4
+    assert_in_delta 3.97, @point.distance_to(@loc_e, units: :miles, formula: :flat), 0.2
+    assert_in_delta 6.39, @point.distance_to(@loc_e, units: :kms, formula: :flat), 0.4
+    assert_in_delta 3.334, @point.distance_to(@loc_e, units: :nms, formula: :flat), 0.4
   end
 
   def test_heading_between
-    assert_in_delta 332, Geokit::LatLng.heading_between(@loc_a,@loc_e), 0.5
+    assert_in_delta 332, Geokit::LatLng.heading_between(@loc_a, @loc_e), 0.5
   end
 
   def test_heading_to
@@ -115,65 +135,65 @@ class LatLngTest < Test::Unit::TestCase #:nodoc: all
   end
 
   def test_class_endpoint
-    endpoint=Geokit::LatLng.endpoint(@loc_a, 332, 3.97)
+    endpoint = Geokit::LatLng.endpoint(@loc_a, 332, 3.97)
     assert_in_delta @loc_e.lat, endpoint.lat, 0.0005
     assert_in_delta @loc_e.lng, endpoint.lng, 0.0005
   end
 
   def test_instance_endpoint
-    endpoint=@loc_a.endpoint(332, 3.97)
+    endpoint = @loc_a.endpoint(332, 3.97)
     assert_in_delta @loc_e.lat, endpoint.lat, 0.0005
     assert_in_delta @loc_e.lng, endpoint.lng, 0.0005
   end
 
   def test_midpoint
-    midpoint=@loc_a.midpoint_to(@loc_e)
+    midpoint = @loc_a.midpoint_to(@loc_e)
     assert_in_delta 32.944061, midpoint.lat, 0.0005
     assert_in_delta(-96.974296, midpoint.lng, 0.0005)
   end
 
   def test_normalize
-    lat=37.7690
-    lng=-122.443
-    res=Geokit::LatLng.normalize(lat,lng)
-    assert_equal res,Geokit::LatLng.new(lat,lng)
-    res=Geokit::LatLng.normalize("#{lat}, #{lng}")
-    assert_equal res,Geokit::LatLng.new(lat,lng)
-    res=Geokit::LatLng.normalize("#{lat} #{lng}")
-    assert_equal res,Geokit::LatLng.new(lat,lng)
-    res=Geokit::LatLng.normalize("#{lat.to_i} #{lng.to_i}")
-    assert_equal res,Geokit::LatLng.new(lat.to_i,lng.to_i)
-    res=Geokit::LatLng.normalize([lat,lng])
-    assert_equal res,Geokit::LatLng.new(lat,lng)
+    lat = 37.7690
+    lng = -122.443
+    res = Geokit::LatLng.normalize(lat, lng)
+    assert_equal res, Geokit::LatLng.new(lat, lng)
+    res = Geokit::LatLng.normalize("#{lat}, #{lng}")
+    assert_equal res, Geokit::LatLng.new(lat, lng)
+    res = Geokit::LatLng.normalize("#{lat} #{lng}")
+    assert_equal res, Geokit::LatLng.new(lat, lng)
+    res = Geokit::LatLng.normalize("#{lat.to_i} #{lng.to_i}")
+    assert_equal res, Geokit::LatLng.new(lat.to_i, lng.to_i)
+    res = Geokit::LatLng.normalize([lat, lng])
+    assert_equal res, Geokit::LatLng.new(lat, lng)
   end
 
   def test_hash
-    lat=37.7690
-    lng=-122.443
-    first = Geokit::LatLng.new(lat,lng)
-    second = Geokit::LatLng.new(lat,lng)
+    lat = 37.7690
+    lng = -122.443
+    first = Geokit::LatLng.new(lat, lng)
+    second = Geokit::LatLng.new(lat, lng)
     assert_equal first.hash, second.hash
   end
 
   def test_eql?
-    lat=37.7690
-    lng=-122.443
-    first = Geokit::LatLng.new(lat,lng)
-    second = Geokit::LatLng.new(lat,lng)
+    lat = 37.7690
+    lng = -122.443
+    first = Geokit::LatLng.new(lat, lng)
+    second = Geokit::LatLng.new(lat, lng)
     assert first.eql?(second)
     assert second.eql?(first)
   end
 
   def test_valid_when_lat_and_lng_defined
-    assert Geokit::LatLng.new(37.7690,-122.443).valid?
+    assert Geokit::LatLng.new(37.7690, -122.443).valid?
   end
 
   def test_not_valid_when_lat_is_nil
-    assert ! Geokit::LatLng.new(nil,-122.443).valid?
+    assert ! Geokit::LatLng.new(nil, -122.443).valid?
   end
 
   def test_not_valid_when_lng_is_nil
-    assert ! Geokit::LatLng.new(37.7690,nil).valid?
+    assert ! Geokit::LatLng.new(37.7690, nil).valid?
   end
 
   def test_reverse_geocode
@@ -181,40 +201,40 @@ class LatLngTest < Test::Unit::TestCase #:nodoc: all
     Geokit::Geocoders::MultiGeocoder.expects(:reverse_geocode).with(point).returns(valid_reverse_geocoding_result)
     res = point.reverse_geocode
 
-    assert_equal "Nordrhein-Westfalen", res.state
-    assert_equal "Essen", res.city
-    assert_equal "45127", res.zip
-    assert_equal "51.4578329,7.0166848", res.ll # slightly dif from yahoo
+    assert_equal 'Nordrhein-Westfalen', res.state
+    assert_equal 'Essen', res.city
+    assert_equal '45127', res.zip
+    assert_equal '51.4578329,7.0166848', res.ll # slightly dif from yahoo
     assert res.is_us? == false
-    assert_equal "Porscheplatz 1, 45127 Essen, Deutschland", res.full_address #slightly different from yahoo
+    assert_equal 'Porscheplatz 1, 45127 Essen, Deutschland', res.full_address # slightly different from yahoo
   end
 
   def test_reverse_geocoding_using_specific_geocoder
     point = Geokit::LatLng.new(51.4578329, 7.0166848)
     Geokit::Geocoders::GoogleGeocoder.expects(:reverse_geocode).with(point).returns(valid_reverse_geocoding_result)
-    res = point.reverse_geocode(:using => Geokit::Geocoders::GoogleGeocoder)
+    res = point.reverse_geocode(using: Geokit::Geocoders::GoogleGeocoder)
 
-    assert_equal "Nordrhein-Westfalen", res.state
-    assert_equal "Essen", res.city
-    assert_equal "45127", res.zip
-    assert_equal "51.4578329,7.0166848", res.ll # slightly dif from yahoo
+    assert_equal 'Nordrhein-Westfalen', res.state
+    assert_equal 'Essen', res.city
+    assert_equal '45127', res.zip
+    assert_equal '51.4578329,7.0166848', res.ll # slightly dif from yahoo
     assert res.is_us? == false
-    assert_equal "Porscheplatz 1, 45127 Essen, Deutschland", res.full_address #slightly different from yahoo
-    assert_equal "google", res.provider
+    assert_equal 'Porscheplatz 1, 45127 Essen, Deutschland', res.full_address # slightly different from yahoo
+    assert_equal 'google', res.provider
   end
 
   def test_reverse_geocoding_using_specific_geocoder_short_syntax
     point = Geokit::LatLng.new(51.4578329, 7.0166848)
     Geokit::Geocoders::GoogleGeocoder.expects(:reverse_geocode).with(point).returns(valid_reverse_geocoding_result)
-    res = point.reverse_geocode(:using => :google)
+    res = point.reverse_geocode(using: :google)
 
-    assert_equal "Nordrhein-Westfalen", res.state
-    assert_equal "Essen", res.city
-    assert_equal "45127", res.zip
-    assert_equal "51.4578329,7.0166848", res.ll # slightly dif from yahoo
+    assert_equal 'Nordrhein-Westfalen', res.state
+    assert_equal 'Essen', res.city
+    assert_equal '45127', res.zip
+    assert_equal '51.4578329,7.0166848', res.ll # slightly dif from yahoo
     assert res.is_us? == false
-    assert_equal "Porscheplatz 1, 45127 Essen, Deutschland", res.full_address #slightly different from yahoo
-    assert_equal "google", res.provider
+    assert_equal 'Porscheplatz 1, 45127 Essen, Deutschland', res.full_address # slightly different from yahoo
+    assert_equal 'google', res.provider
   end
 
   def test_to_dms

data/test/test_map_quest.rb

@@ -1,55 +1,52 @@
 require File.join(File.dirname(__FILE__), 'helper')
 
 class MapQuestGeocoderTest < BaseGeocoderTest #:nodoc: all
-
   def setup
     super
     @full_address = '100 Spear St Apt. 5, San Francisco, CA, 94105-1522, US'
-    @google_full_hash = {:street_address=>"100 Spear St Apt. 5", :city=>"San Francisco", :state=>"CA", :zip=>"94105", :country_code=>"US"}
-    @google_city_hash = {:city=>"San Francisco", :state=>"CA"}
+    @google_full_hash = {street_address: '100 Spear St Apt. 5', city: 'San Francisco', state: 'CA', zip: '94105', country_code: 'US'}
+    @google_city_hash = {city: 'San Francisco', state: 'CA'}
 
     @google_full_loc = Geokit::GeoLoc.new(@google_full_hash)
     @google_city_loc = Geokit::GeoLoc.new(@google_city_hash)
   end
 
-
   def test_map_quest_full_address_with_geo_loc
     VCR.use_cassette('map_quest_full') do
-    key = 'Fmjtd%7Cluur2d0125%2C2s%3Do5-9a8lhz'
-    Geokit::Geocoders::MapQuestGeocoder.key =key
+      key = 'Fmjtd%7Cluur2d0125%2C2s%3Do5-9a8lhz'
+    Geokit::Geocoders::MapQuestGeocoder.key = key
     url = "https://www.mapquestapi.com/geocoding/v1/address?key=#{key}&location=100+Spear+St+Apt.+5%2C+San+Francisco%2C+CA%2C+94105%2C+US"
     TestHelper.expects(:last_url).with(url)
-    res=Geokit::Geocoders::MapQuestGeocoder.geocode(@google_full_loc)
-    assert_equal "CA", res.state
-    assert_equal "San Francisco", res.city
+    res = Geokit::Geocoders::MapQuestGeocoder.geocode(@google_full_loc)
+    assert_equal 'CA', res.state
+    assert_equal 'San Francisco', res.city
     assert_array_in_delta [37.7921509, -122.394], res.to_a # slightly dif from yahoo
     assert res.is_us?
-    assert_equal "100 Spear St, Apt 5, San Francisco, CA, 94105-1500, US", res.full_address #slightly different from yahoo
-    assert_equal "map_quest", res.provider
+    assert_equal '100 Spear St, Apt 5, San Francisco, CA, 94105-1500, US', res.full_address # slightly different from yahoo
+    assert_equal 'map_quest', res.provider
     end
   end
 
-
   def test_reverse_geocode
     VCR.use_cassette('map_quest_reverse_madrid') do
-    madrid = Geokit::GeoLoc.new
-    madrid.lat, madrid.lng = "40.4167413", "-3.7032498"
+      madrid = Geokit::GeoLoc.new
+    madrid.lat, madrid.lng = '40.4167413', '-3.7032498'
     key = 'Fmjtd%7Cluur2d0125%2C2s%3Do5-9a8lhz'
-    Geokit::Geocoders::MapQuestGeocoder.key =key
+    Geokit::Geocoders::MapQuestGeocoder.key = key
     url = "https://www.mapquestapi.com/geocoding/v1/reverse?key=#{key}&location=#{madrid.lat},#{madrid.lng}"
     TestHelper.expects(:last_url).with(url)
-    res=Geokit::Geocoders::MapQuestGeocoder.do_reverse_geocode(madrid.ll)
+    res = Geokit::Geocoders::MapQuestGeocoder.do_reverse_geocode(madrid.ll)
 
     assert_equal madrid.lat.to_s.slice(1..5), res.lat.to_s.slice(1..5)
     assert_equal madrid.lng.to_s.slice(1..5), res.lng.to_s.slice(1..5)
-    assert_equal "ES", res.country_code
-    assert_equal "map_quest", res.provider
+    assert_equal 'ES', res.country_code
+    assert_equal 'map_quest', res.provider
 
-    assert_equal "Madrid", res.city
-    assert_equal "Comunidad de Madrid", res.state
+    assert_equal 'Madrid', res.city
+    assert_equal 'Comunidad de Madrid', res.state
 
     assert_equal nil, res.country
-    assert_equal "28014", res.zip
+    assert_equal '28014', res.zip
     assert_equal true, res.success
     end
   end