geocoder 1.1.4 → 1.1.8

data/lib/geocoder/stores/active_record.rb

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 require 'geocoder/sql'
 require 'geocoder/stores/base'
 
@@ -17,13 +18,15 @@ module Geocoder::Store
 
         # scope: geocoded objects
         scope :geocoded, lambda {
-          {:conditions => "#{geocoder_options[:latitude]} IS NOT NULL " +
-            "AND #{geocoder_options[:longitude]} IS NOT NULL"}}
+          where("#{geocoder_options[:latitude]} IS NOT NULL " +
+            "AND #{geocoder_options[:longitude]} IS NOT NULL")
+        }
 
         # scope: not-geocoded objects
         scope :not_geocoded, lambda {
-          {:conditions => "#{geocoder_options[:latitude]} IS NULL " +
-            "OR #{geocoder_options[:longitude]} IS NULL"}}
+          where("#{geocoder_options[:latitude]} IS NULL " +
+            "OR #{geocoder_options[:longitude]} IS NULL")
+        }
 
         ##
         # Find all objects within a radius of the given location.
@@ -35,7 +38,9 @@ module Geocoder::Store
         scope :near, lambda{ |location, *args|
           latitude, longitude = Geocoder::Calculations.extract_coordinates(location)
           if Geocoder::Calculations.coordinates_present?(latitude, longitude)
-            near_scope_options(latitude, longitude, *args)
+            options = near_scope_options(latitude, longitude, *args)
+            select(options[:select]).where(options[:conditions]).
+              order(options[:order])
           else
             # If no lat/lon given we don't want any results, but we still
             # need distance and bearing columns so you can add, for example:
@@ -53,11 +58,11 @@ module Geocoder::Store
         scope :within_bounding_box, lambda{ |bounds|
           sw_lat, sw_lng, ne_lat, ne_lng = bounds.flatten if bounds
           if sw_lat && sw_lng && ne_lat && ne_lng
-            {:conditions => Geocoder::Sql.within_bounding_box(
+            where(Geocoder::Sql.within_bounding_box(
               sw_lat, sw_lng, ne_lat, ne_lng,
               full_column_name(geocoder_options[:latitude]),
               full_column_name(geocoder_options[:longitude])
-            )}
+            ))
           else
             select(select_clause(nil, "NULL", "NULL")).where(false_condition)
           end
@@ -87,33 +92,47 @@ module Geocoder::Store
       # * +:units+   - <tt>:mi</tt> or <tt>:km</tt>; to be used.
       #   for interpreting radius as well as the +distance+ attribute which
       #   is added to each found nearby object.
-      #   See Geocoder::Configuration to know how configure default units.
+      #   Use Geocoder.configure[:units] to configure default units.
       # * +:bearing+ - <tt>:linear</tt> or <tt>:spherical</tt>.
       #   the method to be used for calculating the bearing (direction)
       #   between the given point and each found nearby point;
-      #   set to false for no bearing calculation.
-      #   See Geocoder::Configuration to know how configure default method.
-      # * +:select+  - string with the SELECT SQL fragment (e.g. “id, name”)
-      # * +:order+   - column(s) for ORDER BY SQL clause; default is distance;
-      #                set to false or nil to omit the ORDER BY clause
-      # * +:exclude+ - an object to exclude (used by the +nearbys+ method)
+      #   set to false for no bearing calculation. Use
+      #   Geocoder.configure[:distances] to configure default calculation method.
+      # * +:select+          - string with the SELECT SQL fragment (e.g. “id, name”)
+      # * +:select_distance+ - whether to include the distance alias in the
+      #                        SELECT SQL fragment (e.g. <formula> AS distance)
+      # * +:select_bearing+  - like +:select_distance+ but for bearing.
+      # * +:order+           - column(s) for ORDER BY SQL clause; default is distance;
+      #                        set to false or nil to omit the ORDER BY clause
+      # * +:exclude+         - an object to exclude (used by the +nearbys+ method)
       #
       def near_scope_options(latitude, longitude, radius = 20, options = {})
-        options[:units] ||= (geocoder_options[:units] || Geocoder::Configuration.units)
+        if options[:units]
+          options[:units] = options[:units].to_sym
+        end
+        options[:units] ||= (geocoder_options[:units] || Geocoder.config.units)
+        select_distance = options.fetch(:select_distance, true)
+        options[:order] = "" if !select_distance && !options.include?(:order)
+        select_bearing = options.fetch(:select_bearing, true)
         bearing = bearing_sql(latitude, longitude, options)
         distance = distance_sql(latitude, longitude, options)
+
+        b = Geocoder::Calculations.bounding_box([latitude, longitude], radius, options)
+        args = b + [
+          full_column_name(geocoder_options[:latitude]),
+          full_column_name(geocoder_options[:longitude])
+        ]
+        bounding_box_conditions = Geocoder::Sql.within_bounding_box(*args)
+
         if using_sqlite?
-          b = Geocoder::Calculations.bounding_box([latitude, longitude], radius, options)
-          args = b + [
-            full_column_name(geocoder_options[:latitude]),
-            full_column_name(geocoder_options[:longitude])
-          ]
-          conditions = Geocoder::Sql.within_bounding_box(*args)
+          conditions = bounding_box_conditions
         else
-          conditions = ["#{distance} <= ?", radius]
+          conditions = [bounding_box_conditions + " AND #{distance} <= ?", radius]
         end
         {
-          :select => select_clause(options[:select], distance, bearing),
+          :select => select_clause(options[:select],
+                                   select_distance ? distance : nil,
+                                   select_bearing ? bearing : nil),
           :conditions => add_exclude_condition(conditions, options[:exclude]),
           :order => options.include?(:order) ? options[:order] : "distance ASC"
         }
@@ -140,7 +159,7 @@ module Geocoder::Store
       #
       def bearing_sql(latitude, longitude, options = {})
         if !options.include?(:bearing)
-          options[:bearing] = Geocoder::Configuration.distances
+          options[:bearing] = Geocoder.config.distances
         end
         if options[:bearing]
           method_prefix = using_sqlite? ? "approx" : "full"
@@ -157,14 +176,23 @@ module Geocoder::Store
       ##
       # Generate the SELECT clause.
       #
-      def select_clause(columns, distance, bearing = nil)
-        if columns == :geo_only
+      def select_clause(columns, distance = nil, bearing = nil)
+        if columns == :id_only
+          return full_column_name(primary_key)
+        elsif columns == :geo_only
           clause = ""
         else
-          clause = (columns || full_column_name("*")) + ", "
+          clause = (columns || full_column_name("*"))
+        end
+        if distance
+          clause += ", " unless clause.empty?
+          clause += "#{distance} AS distance"
         end
-        clause + "#{distance} AS distance" +
-          (bearing ? ", #{bearing} AS bearing" : "")
+        if bearing
+          clause += ", " unless clause.empty?
+          clause += "#{bearing} AS bearing"
+        end
+        clause
       end
 
       ##
@@ -236,4 +264,3 @@ module Geocoder::Store
     alias_method :fetch_address, :reverse_geocode
   end
 end
-

data/lib/geocoder/stores/base.rb

@@ -58,10 +58,11 @@ module Geocoder
       ##
       # Get nearby geocoded objects.
       # Takes the same options hash as the near class method (scope).
+      # Returns nil if the object is not geocoded.
       #
       def nearbys(radius = 20, options = {})
-        return [] unless geocoded?
-        options.merge!(:exclude => self)
+        return nil unless geocoded?
+        options.merge!(:exclude => self) unless send(self.class.primary_key).nil?
         self.class.near(self, radius, options)
       end
 

data/lib/geocoder/stores/mongo_base.rb

@@ -24,7 +24,8 @@ module Geocoder::Store
 
           # Use BSON::OrderedHash if Ruby's hashes are unordered.
           # Conditions must be in order required by indexes (see mongo gem).
-          empty = RUBY_VERSION.split('.')[1].to_i < 9 ? BSON::OrderedHash.new : {}
+          version = RUBY_VERSION.split('.').map { |i| i.to_i }
+          empty = version[0] < 2 && version[1] < 9 ? BSON::OrderedHash.new : {}
 
           conds = empty.clone
           field = geocoder_options[:coordinates]

data/lib/geocoder/version.rb

@@ -1,3 +1,3 @@
 module Geocoder
-  VERSION = "1.1.4"
+  VERSION = "1.1.8"
 end

data/lib/geocoder.rb

@@ -43,10 +43,8 @@ module Geocoder
   # The working Cache object, or +nil+ if none configured.
   #
   def cache
-    if @cache.nil? and store = Configuration.cache
-      @cache = Cache.new(store, Configuration.cache_prefix)
-    end
-    @cache
+    warn "WARNING: Calling Geocoder.cache is DEPRECATED. The #cache method now belongs to the Geocoder::Lookup object."
+    Geocoder::Lookup.get(Geocoder.config.lookup).cache
   end
 end
 

data/lib/hash_recursive_merge.rb

@@ -0,0 +1,74 @@
+# 
+# = Hash Recursive Merge
+# 
+# Merges a Ruby Hash recursively, Also known as deep merge.
+# Recursive version of Hash#merge and Hash#merge!.
+# 
+# Category::    Ruby
+# Package::     Hash
+# Author::      Simone Carletti <weppos@weppos.net>
+# Copyright::   2007-2008 The Authors
+# License::     MIT License
+# Link::        http://www.simonecarletti.com/
+# Source::      http://gist.github.com/gists/6391/
+#
+module HashRecursiveMerge
+
+  #
+  # Recursive version of Hash#merge!
+  # 
+  # Adds the contents of +other_hash+ to +hsh+, 
+  # merging entries in +hsh+ with duplicate keys with those from +other_hash+.
+  # 
+  # Compared with Hash#merge!, this method supports nested hashes.
+  # When both +hsh+ and +other_hash+ contains an entry with the same key,
+  # it merges and returns the values from both arrays.
+  # 
+  #    h1 = {"a" => 100, "b" => 200, "c" => {"c1" => 12, "c2" => 14}}
+  #    h2 = {"b" => 254, "c" => {"c1" => 16, "c3" => 94}}
+  #    h1.rmerge!(h2)   #=> {"a" => 100, "b" => 254, "c" => {"c1" => 16, "c2" => 14, "c3" => 94}}
+  #    
+  # Simply using Hash#merge! would return
+  # 
+  #    h1.merge!(h2)    #=> {"a" => 100, "b" = >254, "c" => {"c1" => 16, "c3" => 94}}
+  # 
+  def rmerge!(other_hash)
+    merge!(other_hash) do |key, oldval, newval|
+      oldval.class == self.class ? oldval.rmerge!(newval) : newval
+    end
+  end
+
+  #
+  # Recursive version of Hash#merge
+  # 
+  # Compared with Hash#merge!, this method supports nested hashes.
+  # When both +hsh+ and +other_hash+ contains an entry with the same key,
+  # it merges and returns the values from both arrays.
+  # 
+  # Compared with Hash#merge, this method provides a different approch
+  # for merging nasted hashes.
+  # If the value of a given key is an Hash and both +other_hash+ abd +hsh
+  # includes the same key, the value is merged instead replaced with
+  # +other_hash+ value.
+  # 
+  #    h1 = {"a" => 100, "b" => 200, "c" => {"c1" => 12, "c2" => 14}}
+  #    h2 = {"b" => 254, "c" => {"c1" => 16, "c3" => 94}}
+  #    h1.rmerge(h2)    #=> {"a" => 100, "b" => 254, "c" => {"c1" => 16, "c2" => 14, "c3" => 94}}
+  #    
+  # Simply using Hash#merge would return
+  # 
+  #    h1.merge(h2)     #=> {"a" => 100, "b" = >254, "c" => {"c1" => 16, "c3" => 94}}
+  # 
+  def rmerge(other_hash)
+    r = {}
+    merge(other_hash) do |key, oldval, newval|
+      r[key] = oldval.class == self.class ? oldval.rmerge(newval) : newval
+    end
+  end
+
+end
+
+
+class Hash
+  include HashRecursiveMerge
+end

data/lib/oauth_util.rb

@@ -0,0 +1,112 @@
+# A utility for signing an url using OAuth in a way that's convenient for debugging
+# Note: the standard Ruby OAuth lib is here http://github.com/mojodna/oauth
+# Source: http://gist.github.com/383159
+# License: http://gist.github.com/375593
+# Usage: see example.rb below
+#
+# NOTE: This file has been modified from the original Gist:
+#
+# 1. Fix to prevent param-array conversion, as mentioned in Gist comment.
+# 2. Query string escaping has been changed. See:
+#   https://github.com/alexreisner/geocoder/pull/360
+#
+
+require 'uri'
+require 'cgi'
+require 'openssl'
+require 'base64'
+
+class OauthUtil
+
+  attr_accessor :consumer_key, :consumer_secret, :token, :token_secret, :req_method, 
+                :sig_method, :oauth_version, :callback_url, :params, :req_url, :base_str
+
+  def initialize
+    @consumer_key = ''
+    @consumer_secret = ''
+    @token = ''
+    @token_secret = ''
+    @req_method = 'GET'
+    @sig_method = 'HMAC-SHA1'
+    @oauth_version = '1.0'
+    @callback_url = ''
+  end
+
+  # openssl::random_bytes returns non-word chars, which need to be removed. using alt method to get length
+  # ref http://snippets.dzone.com/posts/show/491
+  def nonce
+    Array.new( 5 ) { rand(256) }.pack('C*').unpack('H*').first
+  end
+
+  def percent_encode( string )
+
+    # ref http://snippets.dzone.com/posts/show/1260
+    return URI.escape( string, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]") ).gsub('*', '%2A')
+  end
+
+  # @ref http://oauth.net/core/1.0/#rfc.section.9.2
+  def signature
+    key = percent_encode( @consumer_secret ) + '&' + percent_encode( @token_secret )
+
+    # ref: http://blog.nathanielbibler.com/post/63031273/openssl-hmac-vs-ruby-hmac-benchmarks
+    digest = OpenSSL::Digest::Digest.new( 'sha1' )
+    hmac = OpenSSL::HMAC.digest( digest, key, @base_str )
+
+    # ref http://groups.google.com/group/oauth-ruby/browse_thread/thread/9110ed8c8f3cae81
+    Base64.encode64( hmac ).chomp.gsub( /\n/, '' )
+  end
+
+  # sort (very important as it affects the signature), concat, and percent encode
+  # @ref http://oauth.net/core/1.0/#rfc.section.9.1.1
+  # @ref http://oauth.net/core/1.0/#9.2.1
+  # @ref http://oauth.net/core/1.0/#rfc.section.A.5.1
+  def query_string
+    pairs = []
+    @params.sort.each { | key, val | 
+      pairs.push( "#{ CGI.escape(key.to_s).gsub(/%(5B|5D)/n) { [$1].pack('H*') } }=#{ CGI.escape(val.to_s) }" )
+    }
+    pairs.join '&'
+  end
+
+  # organize params & create signature
+  def sign( parsed_url )
+
+    @params = {
+      'oauth_consumer_key' => @consumer_key,
+      'oauth_nonce' => nonce,
+      'oauth_signature_method' => @sig_method,
+      'oauth_timestamp' => Time.now.to_i.to_s,
+      'oauth_version' => @oauth_version
+    }
+
+    # if url has query, merge key/values into params obj overwriting defaults
+    if parsed_url.query
+      CGI.parse( parsed_url.query ).each do |k,v|
+        if v.is_a?(Array) && v.count == 1
+          @params[k] = v.first
+        else
+          @params[k] = v
+        end
+      end
+    end
+
+    # @ref http://oauth.net/core/1.0/#rfc.section.9.1.2
+    @req_url = parsed_url.scheme + '://' + parsed_url.host + parsed_url.path
+
+    # create base str. make it an object attr for ez debugging
+    # ref http://oauth.net/core/1.0/#anchor14
+    @base_str = [ 
+      @req_method, 
+      percent_encode( req_url ), 
+
+      # normalization is just x-www-form-urlencoded
+      percent_encode( query_string ) 
+
+    ].join( '&' )
+
+    # add signature
+    @params[ 'oauth_signature' ] = signature
+
+    return self
+  end
+end

data/test/cache_test.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+require 'test_helper'
+
+class CacheTest < Test::Unit::TestCase
+
+  def test_second_occurrence_of_request_is_cache_hit
+    Geocoder.configure(:cache => {})
+    Geocoder::Lookup.all_services_except_test.each do |l|
+      Geocoder.configure(:lookup => l)
+      set_api_key!(l)
+      results = Geocoder.search("Madison Square Garden")
+      assert !results.first.cache_hit,
+        "Lookup #{l} returned erroneously cached result."
+      results = Geocoder.search("Madison Square Garden")
+      assert results.first.cache_hit,
+        "Lookup #{l} did not return cached result."
+    end
+  end
+end

data/test/calculations_test.rb

@@ -3,10 +3,10 @@ require 'test_helper'
 
 class CalculationsTest < Test::Unit::TestCase
   def setup
-    Geocoder.configure do |config|
-      config.units  = :mi
-      config.distances = :linear
-    end
+    Geocoder.configure(
+      :units => :mi,
+      :distances => :linear
+    )
   end
 
   # --- degree distance ---
@@ -38,6 +38,12 @@ class CalculationsTest < Test::Unit::TestCase
     assert (la_to_ny - 3942).abs < 10
   end
 
+  def test_distance_between_in_nautical_miles
+    assert_equal 60, Geocoder::Calculations.distance_between([0,0], [0,1], :units => :nm).round
+    la_to_ny = Geocoder::Calculations.distance_between([34.05,-118.25], [40.72,-74], :units => :nm).round
+    assert (la_to_ny - 2124).abs < 10
+  end
+
 
   # --- geographic center ---
 

data/test/configuration_test.rb

@@ -7,69 +7,44 @@ class ConfigurationTest < Test::Unit::TestCase
   end
 
   def test_exception_raised_on_bad_lookup_config
-    Geocoder::Configuration.lookup = :stoopid
+    Geocoder.configure(:lookup => :stoopid)
     assert_raises Geocoder::ConfigurationError do
       Geocoder.search "something dumb"
     end
   end
 
-  # --- class method configuration ---
-  def test_configurated_by_class_method
-    Geocoder::Configuration.units = :mi
-    distance = Geocoder::Calculations.distance_between([0,0], [0,1]).round
-    assert_not_equal 111, distance
-    assert_equal      69, distance
-
-    Geocoder::Configuration.units = :km
-    distance = Geocoder::Calculations.distance_between([0,0], [0,1]).round
-    assert_equal    111, distance
-    assert_not_equal 69, distance
-
-    Geocoder::Configuration.distances = :spherical
-    angle = Geocoder::Calculations.bearing_between([50,-85], [40.750354, -73.993371]).round
-    assert_equal     136, angle
-    assert_not_equal 130, angle
+  def test_setting_with_class_method
+    Geocoder::Configuration.units = :test
+    assert_equal :test, Geocoder.config.units
+  end
 
-    Geocoder::Configuration.distances = :linear
-    angle = Geocoder::Calculations.bearing_between([50,-85], [40.750354, -73.993371]).round
-    assert_not_equal 136, angle
-    assert_equal     130, angle
+  def test_setting_with_configure_method
+    Geocoder.configure(:units => :test)
+    assert_equal :test, Geocoder.config.units
   end
 
-  # --- Geocoder#configure distances configuration ---
-  def test_geocoder_configuration
-    # DSL
+  def test_setting_with_block_syntax
+    orig = $VERBOSE; $VERBOSE = nil
     Geocoder.configure do |config|
-      config.units  = :mi
-      config.distances = :linear
+      config.units = :test
     end
+    assert_equal :test, Geocoder.config.units
+  ensure
+    $VERBOSE = orig
+  end
 
-    assert_equal Geocoder::Configuration.units, :mi
-    distance = Geocoder::Calculations.distance_between([0,0], [0,1]).round
-    assert_not_equal 111, distance
-    assert_equal      69, distance
-
-    assert_equal Geocoder::Configuration.distances, :linear
-    angle = Geocoder::Calculations.bearing_between([50,-85], [40.750354, -73.993371]).round
-    assert_not_equal 136, angle
-    assert_equal     130, angle
-
-    # Direct
-    Geocoder.configure.units  = :km
-    Geocoder.configure.distances = :spherical
-
-    assert_equal Geocoder::Configuration.units, :km
-    distance = Geocoder::Calculations.distance_between([0,0], [0,1]).round
-    assert_equal    111, distance
-    assert_not_equal 69, distance
-
-    assert_equal Geocoder::Configuration.distances, :spherical
-    angle = Geocoder::Calculations.bearing_between([50,-85], [40.750354, -73.993371]).round
-    assert_equal     136, angle
-    assert_not_equal 130, angle
+  def test_config_for_lookup
+    Geocoder.configure(
+      :timeout => 5,
+      :api_key => "aaa",
+      :google => {
+        :timeout => 2
+      }
+    )
+    assert_equal 2, Geocoder.config_for_lookup(:google).timeout
+    assert_equal "aaa", Geocoder.config_for_lookup(:google).api_key
   end
 
-  # Geocoder per-model configuration
   def test_model_configuration
     Landmark.reverse_geocoded_by :latitude, :longitude, :method => :spherical, :units => :km
     assert_equal :km,        Landmark.geocoder_options[:units]
@@ -90,7 +65,7 @@ class ConfigurationTest < Test::Unit::TestCase
     v.longitude = 0
 
     # method option > global configuration
-    Geocoder.configure.units  = :km
+    Geocoder.configure(:units => :km)
     assert_equal 69, v.distance_to([0,1], :mi).round
 
     # per-model configuration > global configuration

data/test/error_handling_test.rb

@@ -4,23 +4,26 @@ require 'test_helper'
 class ErrorHandlingTest < Test::Unit::TestCase
 
   def teardown
-    Geocoder::Configuration.always_raise = []
+    Geocoder.configure(:always_raise => [])
   end
 
   def test_does_not_choke_on_timeout
     # keep test output clean: suppress timeout warning
     orig = $VERBOSE; $VERBOSE = nil
     Geocoder::Lookup.all_services_except_test.each do |l|
-      Geocoder::Configuration.lookup = l
+      Geocoder.configure(:lookup => l)
+      set_api_key!(l)
       assert_nothing_raised { Geocoder.search("timeout") }
     end
+  ensure
     $VERBOSE = orig
   end
 
   def test_always_raise_timeout_error
-    Geocoder::Configuration.always_raise = [TimeoutError]
+    Geocoder.configure(:always_raise => [TimeoutError])
     Geocoder::Lookup.all_services_except_test.each do |l|
       lookup = Geocoder::Lookup.get(l)
+      set_api_key!(l)
       assert_raises TimeoutError do
         lookup.send(:results, Geocoder::Query.new("timeout"))
       end
@@ -28,9 +31,10 @@ class ErrorHandlingTest < Test::Unit::TestCase
   end
 
   def test_always_raise_socket_error
-    Geocoder::Configuration.always_raise = [SocketError]
+    Geocoder.configure(:always_raise => [SocketError])
     Geocoder::Lookup.all_services_except_test.each do |l|
       lookup = Geocoder::Lookup.get(l)
+      set_api_key!(l)
       assert_raises SocketError do
         lookup.send(:results, Geocoder::Query.new("socket_error"))
       end

data/test/fixtures/bing_invalid_key

@@ -0,0 +1 @@
+{"authenticationResultCode":"InvalidCredentials","brandLogoUri":"http:\\/\\/dev.virtualearth.net\\/Branding\\/logo_powered_by.png","copyright":"Copyright \xC2\xA9 2012 Microsoft and its suppliers. All rights reserved. This API cannot be accessed and the content and any results may not be used, reproduced or transmitted in any manner without express written permission from Microsoft Corporation.","errorDetails":["Access was denied. You may have entered your credentials incorrectly, or you might not have access to the requested resource or operation."],"resourceSets":[],"statusCode":401,"statusDescription":"Unauthorized","traceId":"5c539f6e70c44b2e858741b6c932318e|EWRM001670|02.00.83.1900|"}

data/test/fixtures/esri_madison_square_garden

@@ -0,0 +1,59 @@
+{
+ "spatialReference": {
+  "wkid": 4326,
+  "latestWkid": 4326
+ },
+ "locations": [
+  {
+   "name": "Madison Square Garden",
+   "extent": {
+    "xmin": -74.000241000000003,
+    "ymin": 40.744050000000001,
+    "xmax": -73.988241000000002,
+    "ymax": 40.756050000000002
+   },
+   "feature": {
+    "geometry": {
+     "x": -73.994238897999651,
+     "y": 40.750049813000487
+    },
+    "attributes": {
+     "Loc_name": "Gaz.WorldGazetteer.POI2",
+     "Score": 100,
+     "Match_addr": "Madison Square Garden",
+     "Addr_type": "POI",
+     "Type": "Sports Complex",
+     "PlaceName": "Madison Square Garden",
+     "Rank": "18",
+     "AddBldg": "",
+     "AddNum": "",
+     "AddNumFrom": "",
+     "AddNumTo": "",
+     "Side": "",
+     "StPreDir": "",
+     "StPreType": "",
+     "StName": "",
+     "StType": "",
+     "StDir": "",
+     "Nbrhd": "",
+     "City": "New York",
+     "Subregion": "New York",
+     "Region": "New York",
+     "Postal": "10001",
+     "PostalExt": "",
+     "Country": "USA",
+     "LangCode": "",
+     "Distance": 0,
+     "X": -73.994240000000005,
+     "Y": 40.750050000000002,
+     "DisplayX": -73.994240000000005,
+     "DisplayY": 40.750050000000002,
+     "Xmin": -74.000241000000003,
+     "Xmax": -73.988241000000002,
+     "Ymin": 40.744050000000001,
+     "Ymax": 40.756050000000002
+    }
+   }
+  }
+ ]
+}

data/test/fixtures/esri_no_results

@@ -0,0 +1,8 @@
+{
+ "spatialReference": {
+  "wkid": 4326,
+  "latestWkid": 4326
+ },
+ "locations": [
+  ]
+}