rails-geocoder 0.9.4 → 0.9.5

data/CHANGELOG.rdoc

@@ -2,6 +2,13 @@
 
 Per-release changes to Geocoder.
 
+== 0.9.5 (2010 Oct 15)
+
+* Fix broken PostgreSQL compatibility (now 100% compatible).
+* Switch from Google's XML to JSON geocoding API.
+* Separate Rails 2 and Rails 3-compatible branches.
+* Don't allow :conditions hash in 'options' argument to 'nearbys' method (was deprecated in 0.9.3).
+
 == 0.9.4 (2010 Aug 2)
 
 * Google Maps API key no longer required (uses geocoder v3).

data/README.rdoc

@@ -2,46 +2,33 @@
 
 Geocoder adds object geocoding and database-agnostic distance calculations to Ruby on Rails. It's as simple as calling <tt>fetch_coordinates!</tt> on your objects, and then using a scope like <tt>Venue.near("Billings, MT")</tt>. Since it does not rely on proprietary database functions finding geocoded objects in a given area works with out-of-the-box MySQL or even SQLite.
 
-<b>Geocoder is currently compatible with Rails 2.x and Rails 3.</b> Also, a Google Maps API key is no longer necessary.
+Geocoder is compatible with Rails 2.x and 3.x. <b>This is the README for the 3.x branch.</b> Please see the 2.x branch for installation instructions, documentation, and issues.
 
 
 == 1. Install
 
-=== a. Rails 2
+=== As a Gem
 
-Install either as a plugin:
+Add this to your Gemfile:
 
-  script/plugin install git://github.com/alexreisner/geocoder.git
-
-or as a gem:
+  gem "rails-geocoder", :require => "geocoder"
 
-  # add to config/environment.rb:
-  config.gem "rails-geocoder", :lib => "geocoder", :source => "http://gemcutter.org/"
-  
-  # at command prompt:
-  sudo rake gems:install
+and run this at the command prompt:
 
+  bundle install
 
-=== b. Rails 3
+=== Or As a Plugin
 
-Install either as a plugin:
+At the command prompt:
 
   rails plugin install git://github.com/alexreisner/geocoder.git
 
-or as a gem:
-
-  # add to Gemfile:
-  gem "rails-geocoder", :require => "geocoder"
-  
-  # at command prompt:
-  bundle install
-
 
 == 2. Configure
 
 A) Add +latitude+ and +longitude+ columns to your model:
 
-  script/generate migration AddLatitudeAndLongitudeToYourModel latitude:float longitude:float
+  rails generate migration AddLatitudeAndLongitudeToYourModel latitude:float longitude:float
   rake db:migrate
 
 B) Tell geocoder where your model stores its address:
@@ -82,10 +69,10 @@ Some utility methods are also available:
 
   # distance (in miles) between Eiffel Tower and Empire State Building
   Geocoder.distance_between( 48.858205,2.294359,  40.748433,-73.985655 )
-  
+
   # look up coordinates of some location (like searching Google Maps)
   Geocoder.fetch_coordinates("25 Main St, Cooperstown, NY")
-  
+
   # find the geographic center (aka center of gravity) of objects or points
   Geocoder.geographic_center([ city1, city2, city3, [40.22,-73.99], city4 ])
 
@@ -144,9 +131,16 @@ If anyone has a more elegant solution to this problem I am very interested in se
 
 == To-do List
 
-* make 'near' scope work with 'select' options
+* use completely separate "drivers" for different AR adapters?
+  * seems reasonable since we're using very DB-specific features
+  * also need to make sure 'mysql2' is supported
+* add reverse geocoding
+* make 'near' scope work with AR associations
+  * http://stackoverflow.com/questions/3266358/geocoder-rails-plugin-near-search-problem-with-activerecord
 * prepend table names to column names in SQL distance expression (required
   to do joins on another geocoded model)
+* unobtrusively add ability to get a result with more data (Geocoder object?)
+  * the default usage should remain dead simple
 
 
 Copyright (c) 2009-10 Alex Reisner, released under the MIT license

data/VERSION

@@ -1 +1 @@
-0.9.4
+0.9.5

data/lib/geocoder.rb

@@ -1,10 +1,8 @@
-require 'rexml/document'
-
 ##
 # Add geocoding functionality (via Google) to any object.
 #
 module Geocoder
-  
+
   ##
   # Implementation of 'included' hook method.
   #
@@ -13,21 +11,21 @@ module Geocoder
     base.class_eval do
 
       # scope: geocoded objects
-      send(Geocoder.scope_method_name, :geocoded,
+      scope :geocoded,
         :conditions => "#{geocoder_options[:latitude]} IS NOT NULL " +
-          "AND #{geocoder_options[:longitude]} IS NOT NULL")
+          "AND #{geocoder_options[:longitude]} IS NOT NULL"
 
       # scope: not-geocoded objects
-      send(Geocoder.scope_method_name, :not_geocoded,
+      scope :not_geocoded,
         :conditions => "#{geocoder_options[:latitude]} IS NULL " +
-          "OR #{geocoder_options[:longitude]} IS NULL")
-      
+          "OR #{geocoder_options[:longitude]} IS NULL"
+
       ##
       # Find all objects within a radius (in miles) of the given location
       # (address string). Location (the first argument) may be either a string
       # to geocode or an array of coordinates (<tt>[lat,long]</tt>).
       #
-      send(Geocoder.scope_method_name, :near, lambda{ |location, *args|
+      scope :near, lambda{ |location, *args|
         latitude, longitude = location.is_a?(Array) ?
           location : Geocoder.fetch_coordinates(location)
         if latitude and longitude
@@ -35,10 +33,10 @@ module Geocoder
         else
           {}
         end
-      })
+      }
     end
   end
-    
+
   ##
   # Methods which will be class methods of the including class.
   #
@@ -48,13 +46,16 @@ module Geocoder
     # Get options hash suitable for passing to ActiveRecord.find to get
     # records within a radius (in miles) of the given point.
     # Options hash may include:
-    # 
-    # +order+     :: column(s) for ORDER BY SQL clause
-    # +limit+     :: number of records to return (for LIMIT SQL clause)
-    # +offset+    :: number of records to skip (for OFFSET SQL clause)
-    # +select+    :: string with the SELECT SQL fragment (e.g. “id, name”)
+    #
+    # +units+   :: <tt>:mi</tt> (default) or <tt>:km</tt>
+    # +exclude+ :: an object to exclude (used by the #nearbys method)
+    # +order+   :: column(s) for ORDER BY SQL clause
+    # +limit+   :: number of records to return (for LIMIT SQL clause)
+    # +offset+  :: number of records to skip (for OFFSET SQL clause)
+    # +select+  :: string with the SELECT SQL fragment (e.g. “id, name”)
     #
     def near_scope_options(latitude, longitude, radius = 20, options = {})
+      radius *= km_in_mi if options[:units] == :km
       if ActiveRecord::Base.connection.adapter_name == "SQLite"
         approx_near_scope_options(latitude, longitude, radius, options)
       else
@@ -68,7 +69,7 @@ module Geocoder
     ##
     # Scope options hash for use with a database that supports POWER(),
     # SQRT(), PI(), and trigonometric functions (SIN(), COS(), and ASIN()).
-    # 
+    #
     # Taken from the excellent tutorial at:
     # http://www.scribd.com/doc/2569355/Geo-Distance-Search-with-MySQL
     #
@@ -99,7 +100,7 @@ module Geocoder
         :select => options[:select] || nil
       )
     end
-    
+
     ##
     # Options used for any near-like scope.
     #
@@ -109,27 +110,19 @@ module Geocoder
       conditions = \
         ["#{lat_attr} BETWEEN ? AND ? AND #{lon_attr} BETWEEN ? AND ?"] +
         coordinate_bounds(latitude, longitude, radius)
-      
-      # Handle conditions. Passing of conditions by developers is deprecated
-      # but we will still need to handle conditions so, for example, we can
-      # exclude objects by ID from the nearbys method. This is incredibly
-      # ugly and doesn't work for a conditions hash: try using Arel?
-      if options[:conditions].is_a?(String)
-        options[:conditions] = [options[:conditions]]
-      end
-      if options[:conditions].is_a?(Array)
-        conditions[0] = "(#{conditions[0]}) AND #{options[:conditions][0]}"
-        conditions << options[:conditions][1]
+      if obj = options[:exclude]
+        conditions[0] << " AND id != ?"
+        conditions << obj.id
       end
-      
       {
+        :group  => columns.map{ |c| c.name}.join(','),
         :order  => options[:order],
         :limit  => options[:limit],
         :offset => options[:offset],
         :conditions => conditions
       }
     end
-    
+
     ##
     # Get the rough high/low lat/long bounds for a geographic point and
     # radius. Returns an array: <tt>[lat_lo, lat_hi, lon_lo, lon_hi]</tt>.
@@ -145,6 +138,13 @@ module Geocoder
         longitude + (radius / factor)
       ]
     end
+
+    ##
+    # Conversion factor: km to mi.
+    #
+    def km_in_mi
+      0.621371192
+    end
   end
 
   ##
@@ -161,7 +161,7 @@ module Geocoder
   def geocoded?
     read_coordinates.compact.size > 0
   end
-  
+
   ##
   # Calculate the distance from the object to a point (lat,lon).
   # Valid units are defined in <tt>distance_between</tt> class method.
@@ -171,26 +171,17 @@ module Geocoder
     mylat,mylon = read_coordinates
     Geocoder.distance_between(mylat, mylon, lat, lon, :units => units)
   end
-  
+
   ##
-  # Get other geocoded objects within a given radius (in miles). Takes a
-  # radius (in miles) and options for passing to the +near+ scope
-  # (<tt>:order</tt>, <tt>:limit</tt>, and <tt>:offset</tt>).
+  # Get other geocoded objects within a given radius.
+  # Valid units are defined in <tt>distance_between</tt> class method.
   #
-  def nearbys(radius = 20, options = {})
-    if options != {}
-      warn "DEPRECATION WARNING: The 'options' argument to the nearbys " +
-        "method is deprecated and will be removed from rails-geocoder in " +
-        "a future version. Nearbys now returns a scope so you should " +
-        "specify more scopes and/or conditions via chaining. For example: " +
-        "city.nearbys(20).order('name').limit(10). Support for Rails 2.x " +
-        "will be discontinued soon."
-    end
+  def nearbys(radius = 20, units = :mi)
     return [] unless geocoded?
-    options.reverse_merge!(:conditions => ["id != ?", id])
+    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>.
@@ -214,55 +205,36 @@ module Geocoder
     fetch_coordinates(true)
   end
 
-  ##
-  # Query Google for the coordinates of the given phrase.
-  # Returns array [lat,lon] if found, nil if not found or if network error.
-  #
-  def self.fetch_coordinates(query)
-    return nil if query.blank?
-    return nil unless doc = self.search(query)
-    
-    # make sure search found a result
-    e = doc.elements['GeocodeResponse/status']
-    return nil unless (e and e.text == "OK")
-
-    # isolate the relevant part of the result
-    place = doc.elements['GeocodeResponse/result/geometry/location']
-
-    # blindly use the first results (assume they are most accurate)
-    ['lat', 'lng'].map{ |i| place.elements[i].text.to_f }
-  end
-  
   ##
   # Calculate the distance between two points on Earth (Haversine formula).
   # Takes two sets of coordinates and an options hash:
-  # 
+  #
   # <tt>:units</tt> :: <tt>:mi</tt> (default) or <tt>:km</tt>
   #
   def self.distance_between(lat1, lon1, lat2, lon2, options = {})
-    
+
     # set default options
     options[:units] ||= :mi
-    
+
     # define conversion factors
-    units = { :mi => 3956, :km => 6371 }
-    
+    conversions = { :mi => 3956, :km => 6371 }
+
     # convert degrees to radians
     lat1 = to_radians(lat1)
     lon1 = to_radians(lon1)
     lat2 = to_radians(lat2)
     lon2 = to_radians(lon2)
-    
+
     # compute distances
     dlat = (lat1 - lat2).abs
     dlon = (lon1 - lon2).abs
-    
+
     a = (Math.sin(dlat / 2))**2 + Math.cos(lat1) *
-        (Math.sin(dlon / 2))**2 * Math.cos(lat2)  
-    c = 2 * Math.atan2( Math.sqrt(a), Math.sqrt(1-a))  
-    c * units[options[:units]]
+        (Math.sin(dlon / 2))**2 * Math.cos(lat2)
+    c = 2 * Math.atan2( Math.sqrt(a), Math.sqrt(1-a))
+    c * conversions[options[:units]]
   end
-  
+
   ##
   # Compute the geographic center (aka geographic midpoint, center of
   # gravity) for an array of geocoded objects and/or [lat,lon] arrays
@@ -270,15 +242,15 @@ module Geocoder
   # the procedure documented at http://www.geomidpoint.com/calculation.html.
   #
   def self.geographic_center(points)
-  
+
     # convert objects to [lat,lon] arrays and remove nils
     points = points.map{ |p|
       p.is_a?(Array) ? p : (p.geocoded?? p.read_coordinates : nil)
     }.compact
-    
+
     # convert degrees to radians
     points.map!{ |p| [to_radians(p[0]), to_radians(p[1])] }
-    
+
     # convert to Cartesian coordinates
     x = []; y = []; z = []
     points.each do |p|
@@ -291,12 +263,12 @@ module Geocoder
     xa, ya, za = [x,y,z].map do |c|
       c.inject(0){ |tot,i| tot += i } / c.size.to_f
     end
-    
+
     # convert back to latitude/longitude
     lon = Math.atan2(ya, xa)
     hyp = Math.sqrt(xa**2 + ya**2)
     lat = Math.atan2(za, hyp)
-    
+
     # return answer in degrees
     [to_degrees(lat), to_degrees(lon)]
   end
@@ -307,35 +279,57 @@ module Geocoder
   def self.to_radians(degrees)
     degrees * (Math::PI / 180)
   end
-  
+
   ##
   # Convert radians to degrees.
   #
   def self.to_degrees(radians)
     (radians * 180.0) / Math::PI
   end
-  
+
   ##
   # Query Google for geographic information about the given phrase.
+  # Returns a hash representing a valid geocoder response.
+  # Returns nil if non-200 HTTP response, timeout, or other error.
   #
   def self.search(query)
-    if doc = _fetch_xml(query)
-      REXML::Document.new(doc)
+    doc = _fetch_parsed_response(query)
+    doc && doc['status'] == "OK" ? doc : nil
+  end
+
+  ##
+  # Query Google for the coordinates of the given phrase.
+  # Returns array [lat,lon] if found, nil if not found or if network error.
+  #
+  def self.fetch_coordinates(query)
+    return nil unless doc = self.search(query)
+    # blindly use the first results (assume they are most accurate)
+    place = doc['results'].first['geometry']['location']
+    ['lat', 'lng'].map{ |i| place[i] }
+  end
+
+  ##
+  # Returns a parsed Google geocoder search result (hash).
+  # This method is not intended for general use (prefer Geocoder.search).
+  #
+  def self._fetch_parsed_response(query)
+    if doc = _fetch_raw_response(query)
+      ActiveSupport::JSON.decode(doc)
     end
   end
-  
+
   ##
-  # Request an XML geo search result from Google.
+  # Returns a raw Google geocoder search result (JSON).
   # This method is not intended for general use (prefer Geocoder.search).
   #
-  def self._fetch_xml(query)
-    params = {
-      :address => query,
-      :sensor  => "false"
-    }
-    url = "http://maps.google.com/maps/api/geocode/xml?" + params.to_query
-    
-    # Query geocoder and make sure it responds quickly.
+  def self._fetch_raw_response(query)
+    return nil if query.blank?
+
+    # build URL
+    params = { :address => query, :sensor  => "false" }
+    url = "http://maps.google.com/maps/api/geocode/json?" + params.to_query
+
+    # query geocoder and make sure it responds quickly
     begin
       resp = nil
       timeout(3) do
@@ -345,24 +339,13 @@ module Geocoder
       return nil
     end
   end
-  
-  ##
-  # Name of the ActiveRecord scope method.
-  #
-  def self.scope_method_name
-    begin
-      Rails.version.starts_with?("3") ? :scope : :named_scope
-    rescue NameError
-      :named_scope
-    end
-  end
 end
 
 ##
 # Add geocoded_by method to ActiveRecord::Base so Geocoder is accessible.
 #
 ActiveRecord::Base.class_eval do
-  
+
   ##
   # Set attribute names and include the Geocoder module.
   #

data/rails-geocoder.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rails-geocoder}
-  s.version = "0.9.4"
+  s.version = "0.9.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Alex Reisner"]
-  s.date = %q{2010-08-02}
+  s.date = %q{2010-10-15}
   s.description = %q{Geocoder adds object geocoding and database-agnostic distance calculations to Ruby on Rails. It does not rely on proprietary database functions so finding geocoded objects in a given area is easily done using out-of-the-box MySQL or even SQLite.}
   s.email = %q{alex@alexreisner.com}
   s.extra_rdoc_files = [
@@ -28,25 +28,25 @@ Gem::Specification.new do |s|
      "lib/geocoder.rb",
      "lib/tasks/geocoder_tasks.rake",
      "rails-geocoder.gemspec",
-     "test/fixtures/madison_square_garden.xml",
+     "test/fixtures/madison_square_garden.json",
      "test/geocoder_test.rb",
      "test/test_helper.rb"
   ]
   s.homepage = %q{http://github.com/alexreisner/geocoder}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.6}
+  s.rubygems_version = %q{1.3.7}
   s.summary = %q{Add geocoding functionality to Rails models.}
   s.test_files = [
-    "test/geocoder_test.rb",
-     "test/test_helper.rb"
+    "test/test_helper.rb",
+     "test/geocoder_test.rb"
   ]
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
     else
     end
   else

data/test/fixtures/madison_square_garden.json

@@ -0,0 +1,57 @@
+{
+  "status": "OK",
+  "results": [ {
+    "types": [ "street_address" ],
+    "formatted_address": "4 Penn Plaza, New York, NY 10001, USA",
+    "address_components": [ {
+      "long_name": "4",
+      "short_name": "4",
+      "types": [ "street_number" ]
+    }, {
+      "long_name": "Penn Plaza",
+      "short_name": "Penn Plaza",
+      "types": [ "route" ]
+    }, {
+      "long_name": "Manhattan",
+      "short_name": "Manhattan",
+      "types": [ "sublocality", "political" ]
+    }, {
+      "long_name": "New York",
+      "short_name": "New York",
+      "types": [ "locality", "political" ]
+    }, {
+      "long_name": "New York",
+      "short_name": "New York",
+      "types": [ "administrative_area_level_2", "political" ]
+    }, {
+      "long_name": "New York",
+      "short_name": "NY",
+      "types": [ "administrative_area_level_1", "political" ]
+    }, {
+      "long_name": "United States",
+      "short_name": "US",
+      "types": [ "country", "political" ]
+    }, {
+      "long_name": "10001",
+      "short_name": "10001",
+      "types": [ "postal_code" ]
+    } ],
+    "geometry": {
+      "location": {
+        "lat": 40.7503540,
+        "lng": -73.9933710
+      },
+      "location_type": "ROOFTOP",
+      "viewport": {
+        "southwest": {
+          "lat": 40.7473324,
+          "lng": -73.9965316
+        },
+        "northeast": {
+          "lat": 40.7536276,
+          "lng": -73.9902364
+        }
+      }
+    }
+  } ]
+}

data/test/geocoder_test.rb

@@ -7,12 +7,12 @@ class GeocoderTest < Test::Unit::TestCase
     assert_equal [40.750354, -73.993371], v.fetch_coordinates
     assert_equal [40.750354, -73.993371], [v.latitude, v.longitude]
   end
-  
+
   # sanity check
   def test_distance_between
     assert_equal 69, Geocoder.distance_between(0,0, 0,1).round
   end
-  
+
   # sanity check
   def test_geographic_center
     assert_equal [0.0, 0.5],

data/test/test_helper.rb

@@ -10,24 +10,24 @@ $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 #
 module ActiveRecord
   class Base
-    
+
     def initialize
       @attributes = {}
     end
-    
+
     def read_attribute(attr_name)
       @attributes[attr_name.to_sym]
     end
-    
+
     def write_attribute(attr_name, value)
       @attributes[attr_name.to_sym] = value
     end
-    
+
     def update_attribute(attr_name, value)
       write_attribute(attr_name.to_sym, value)
     end
-    
-    def self.named_scope(*args); end
+
+    def self.scope(*args); end
   end
 end
 
@@ -38,9 +38,8 @@ require 'geocoder'
 # Mock HTTP request to Google.
 #
 module Geocoder
-  def self._fetch_xml(query)
-    filename = File.join("test", "fixtures", "madison_square_garden.xml")
-    File.read(filename)
+  def self._fetch_raw_response(query)
+    File.read(File.join("test", "fixtures", "madison_square_garden.json"))
   end
 end
 
@@ -49,13 +48,13 @@ end
 #
 class Venue < ActiveRecord::Base
   geocoded_by :address
-  
+
   def initialize(name, address)
     super()
     write_attribute :name, name
     write_attribute :address, address
   end
-  
+
   ##
   # If method not found, assume it's an ActiveRecord attribute reader.
   #

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rails-geocoder
 version: !ruby/object:Gem::Version 
+  hash: 49
   prerelease: false
   segments: 
   - 0
   - 9
-  - 4
-  version: 0.9.4
+  - 5
+  version: 0.9.5
 platform: ruby
 authors: 
 - Alex Reisner
@@ -14,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-02 00:00:00 -04:00
+date: 2010-10-15 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -39,7 +40,7 @@ files:
 - lib/geocoder.rb
 - lib/tasks/geocoder_tasks.rake
 - rails-geocoder.gemspec
-- test/fixtures/madison_square_garden.xml
+- test/fixtures/madison_square_garden.json
 - test/geocoder_test.rb
 - test/test_helper.rb
 has_rdoc: true
@@ -52,26 +53,30 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Add geocoding functionality to Rails models.
 test_files: 
-- test/geocoder_test.rb
 - test/test_helper.rb
+- test/geocoder_test.rb

data/test/fixtures/madison_square_garden.xml

@@ -1,69 +0,0 @@
-<GeocodeResponse> 
- <status>OK</status> 
- <result> 
-  <type>street_address</type> 
-  <formatted_address>4 Penn Plaza, New York, NY 10001, USA</formatted_address> 
-  <address_component> 
-   <long_name>4</long_name> 
-   <short_name>4</short_name> 
-   <type>street_number</type> 
-  </address_component> 
-  <address_component> 
-   <long_name>Penn Plaza</long_name> 
-   <short_name>Penn Plaza</short_name> 
-   <type>route</type> 
-  </address_component> 
-  <address_component> 
-   <long_name>Manhattan</long_name> 
-   <short_name>Manhattan</short_name> 
-   <type>sublocality</type> 
-   <type>political</type> 
-  </address_component> 
-  <address_component> 
-   <long_name>New York</long_name> 
-   <short_name>New York</short_name> 
-   <type>locality</type> 
-   <type>political</type> 
-  </address_component> 
-  <address_component> 
-   <long_name>New York</long_name> 
-   <short_name>New York</short_name> 
-   <type>administrative_area_level_2</type> 
-   <type>political</type> 
-  </address_component> 
-  <address_component> 
-   <long_name>New York</long_name> 
-   <short_name>NY</short_name> 
-   <type>administrative_area_level_1</type> 
-   <type>political</type> 
-  </address_component> 
-  <address_component> 
-   <long_name>United States</long_name> 
-   <short_name>US</short_name> 
-   <type>country</type> 
-   <type>political</type> 
-  </address_component> 
-  <address_component> 
-   <long_name>10001</long_name> 
-   <short_name>10001</short_name> 
-   <type>postal_code</type> 
-  </address_component> 
-  <geometry> 
-   <location> 
-    <lat>40.7503540</lat> 
-    <lng>-73.9933710</lng> 
-   </location> 
-   <location_type>ROOFTOP</location_type> 
-   <viewport> 
-    <southwest> 
-     <lat>40.7473324</lat> 
-     <lng>-73.9965316</lng> 
-    </southwest> 
-    <northeast> 
-     <lat>40.7536276</lat> 
-     <lng>-73.9902364</lng> 
-    </northeast> 
-   </viewport> 
-  </geometry> 
- </result> 
-</GeocodeResponse>