geocoder 1.5.2 → 1.7.0

data/lib/geocoder/results/nationaal_georegister_nl.rb

@@ -0,0 +1,62 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class NationaalGeoregisterNl < Base
+
+    def response_attributes
+      @data
+    end
+
+    def coordinates
+      @data['centroide_ll'][6..-2].split(' ').map(&:to_f).reverse
+    end
+
+    def formatted_address
+      @data['weergavenaam']
+    end
+
+    alias_method :address, :formatted_address
+
+    def province
+      @data['provincienaam']
+    end
+
+    alias_method :state, :province
+
+    def city
+      @data['woonplaatsnaam']
+    end
+
+    def district
+      @data['gemeentenaam']
+    end
+
+    def street
+      @data['straatnaam']
+    end
+
+    def street_number
+      @data['huis_nlt']
+    end
+
+    def address_components
+      @data
+    end
+
+    def state_code
+      @data['provinciecode']
+    end
+
+    def postal_code
+      @data['postcode']
+    end
+
+    def country
+      "Netherlands"
+    end
+
+    def country_code
+      "NL"
+    end
+  end
+end

data/lib/geocoder/results/nominatim.rb

@@ -76,6 +76,10 @@ module Geocoder::Result
       @data['address']['neighbourhood']
     end
 
+    def municipality
+      @data['address']['municipality']
+    end
+
     def coordinates
       [@data['lat'].to_f, @data['lon'].to_f]
     end

data/lib/geocoder/results/osmnames.rb

@@ -0,0 +1,56 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Osmnames < Base
+    def address
+      @data['display_name']
+    end
+
+    def coordinates
+      [@data['lat'].to_f, @data['lon'].to_f]
+    end
+
+    def viewport
+      west, south, east, north = @data['boundingbox'].map(&:to_f)
+      [south, west, north, east]
+    end
+
+    def state
+      @data['state']
+    end
+    alias_method :state_code, :state
+
+    def place_class
+      @data['class']
+    end
+
+    def place_type
+      @data['type']
+    end
+
+    def postal_code
+      ''
+    end
+
+    def country_code
+      @data['country_code']
+    end
+
+    def country
+      @data['country']
+    end
+
+    def self.response_attributes
+      %w[house_number street city name osm_id osm_type boundingbox place_rank
+      importance county rank name_suffix]
+    end
+
+    response_attributes.each do |a|
+      unless method_defined?(a)
+        define_method a do
+          @data[a]
+        end
+      end
+    end
+  end
+end

data/lib/geocoder/results/photon.rb

@@ -0,0 +1,119 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Photon < Base
+    def name
+      properties['name']
+    end
+
+    def address(_format = :full)
+      parts = []
+      parts << name if name
+      parts << street_address if street_address
+      parts << city
+      parts << state if state
+      parts << postal_code
+      parts << country
+
+      parts.join(', ')
+    end
+
+    def street_address
+      return unless street
+      return street unless house_number
+
+      "#{house_number} #{street}"
+    end
+
+    def house_number
+      properties['housenumber']
+    end
+
+    def street
+      properties['street']
+    end
+
+    def postal_code
+      properties['postcode']
+    end
+
+    def city
+      properties['city']
+    end
+
+    def state
+      properties['state']
+    end
+
+    def state_code
+      ''
+    end
+
+    def country
+      properties['country']
+    end
+
+    def country_code
+      ''
+    end
+
+    def coordinates
+      return unless geometry
+      return unless geometry[:coordinates]
+
+      geometry[:coordinates].reverse
+    end
+
+    def geometry
+      return unless data['geometry']
+
+      symbol_hash data['geometry']
+    end
+
+    def bounds
+      properties['extent']
+    end
+
+    # Type of the result (OSM object type), one of:
+    #
+    #   :node
+    #   :way
+    #   :relation
+    #
+    def type
+      {
+        'N' => :node,
+        'W' => :way,
+        'R' => :relation
+      }[properties['osm_type']]
+    end
+
+    def osm_id
+      properties['osm_id']
+    end
+
+    # See: https://wiki.openstreetmap.org/wiki/Tags
+    def osm_tag
+      return unless properties['osm_key']
+      return properties['osm_key'] unless properties['osm_value']
+
+      "#{properties['osm_key']}=#{properties['osm_value']}"
+    end
+
+    private
+
+    def properties
+      @properties ||= data['properties'] || {}
+    end
+
+    def symbol_hash(orig_hash)
+      {}.tap do |result|
+        orig_hash.each_key do |key|
+          next unless orig_hash[key]
+
+          result[key.to_sym] = orig_hash[key]
+        end
+      end
+    end
+  end
+end

data/lib/geocoder/results/uk_ordnance_survey_names.rb

@@ -0,0 +1,59 @@
+require 'geocoder/results/base'
+require 'easting_northing'
+
+module Geocoder::Result
+  class UkOrdnanceSurveyNames < Base
+
+    def coordinates
+      @coordinates ||= Geocoder::EastingNorthing.new(
+        easting: data['GEOMETRY_X'],
+        northing: data['GEOMETRY_Y'],
+      ).lat_lng
+    end
+
+    def city
+      is_postcode? ? data['DISTRICT_BOROUGH'] : data['NAME1']
+    end
+
+    def county
+      data['COUNTY_UNITARY']
+    end
+    alias state county
+
+    def county_code
+      code_from_uri data['COUNTY_UNITARY_URI']
+    end
+    alias state_code county_code
+
+    def province
+      data['REGION']
+    end
+
+    def province_code
+      code_from_uri data['REGION_URI']
+    end
+
+    def postal_code
+      is_postcode? ? data['NAME1'] : ''
+    end
+
+    def country
+      'United Kingdom'
+    end
+
+    def country_code
+      'UK'
+    end
+
+    private
+
+    def is_postcode?
+      data['LOCAL_TYPE'] == 'Postcode'
+    end
+
+    def code_from_uri(uri)
+      return '' if uri.nil?
+      uri.split('/').last
+    end
+  end
+end

data/lib/geocoder/results/yandex.rb

@@ -2,78 +2,223 @@ require 'geocoder/results/base'
 
 module Geocoder::Result
   class Yandex < Base
+    # Yandex result has difficult tree structure,
+    # and presence of some nodes depends on exact search case.
+
+    # Also Yandex lacks documentation about it.
+    # See https://tech.yandex.com/maps/doc/geocoder/desc/concepts/response_structure-docpage/
+
+    # Ultimatly, we need to find Locality and/or Thoroughfare data.
+
+    # It may resides on the top (ADDRESS_DETAILS) level.
+    # example: 'Baltic Sea'
+    # "AddressDetails": {
+    #   "Locality": {
+    #     "Premise": {
+    #       "PremiseName": "Baltic Sea"
+    #     }
+    #   }
+    # }
+
+    ADDRESS_DETAILS = %w[
+      GeoObject metaDataProperty GeocoderMetaData
+      AddressDetails
+    ].freeze
+
+    # On COUNTRY_LEVEL.
+    # example: 'Potomak'
+    # "AddressDetails": {
+    #   "Country": {
+    #     "AddressLine": "reka Potomak",
+    #     "CountryNameCode": "US",
+    #     "CountryName": "United States of America",
+    #     "Locality": {
+    #       "Premise": {
+    #         "PremiseName": "reka Potomak"
+    #       }
+    #     }
+    #   }
+    # }
+
+    COUNTRY_LEVEL = %w[
+      GeoObject metaDataProperty GeocoderMetaData
+      AddressDetails Country
+    ].freeze
+
+    # On ADMIN_LEVEL (usually state or city)
+    # example: 'Moscow, Tverskaya'
+    # "AddressDetails": {
+    #   "Country": {
+    #     "AddressLine": "Moscow, Tverskaya Street",
+    #     "CountryNameCode": "RU",
+    #     "CountryName": "Russia",
+    #     "AdministrativeArea": {
+    #       "AdministrativeAreaName": "Moscow",
+    #       "Locality": {
+    #         "LocalityName": "Moscow",
+    #         "Thoroughfare": {
+    #           "ThoroughfareName": "Tverskaya Street"
+    #         }
+    #       }
+    #     }
+    #   }
+    # }
+
+    ADMIN_LEVEL = %w[
+      GeoObject metaDataProperty GeocoderMetaData
+      AddressDetails Country
+      AdministrativeArea
+    ].freeze
+
+    # On SUBADMIN_LEVEL (may refer to urban district)
+    # example: 'Moscow Region, Krasnogorsk'
+    # "AddressDetails": {
+    #   "Country": {
+    #     "AddressLine": "Moscow Region, Krasnogorsk",
+    #     "CountryNameCode": "RU",
+    #     "CountryName": "Russia",
+    #     "AdministrativeArea": {
+    #       "AdministrativeAreaName": "Moscow Region",
+    #       "SubAdministrativeArea": {
+    #         "SubAdministrativeAreaName": "gorodskoy okrug Krasnogorsk",
+    #         "Locality": {
+    #           "LocalityName": "Krasnogorsk"
+    #         }
+    #       }
+    #     }
+    #   }
+    # }
+
+    SUBADMIN_LEVEL = %w[
+      GeoObject metaDataProperty GeocoderMetaData
+      AddressDetails Country
+      AdministrativeArea
+      SubAdministrativeArea
+    ].freeze
+
+    # On DEPENDENT_LOCALITY_1 (may refer to district of city)
+    # example: 'Paris, Etienne Marcel'
+    # "AddressDetails": {
+    #   "Country": {
+    #     "AddressLine": "Île-de-France, Paris, 1er Arrondissement, Rue Étienne Marcel",
+    #     "CountryNameCode": "FR",
+    #     "CountryName": "France",
+    #     "AdministrativeArea": {
+    #       "AdministrativeAreaName": "Île-de-France",
+    #       "Locality": {
+    #         "LocalityName": "Paris",
+    #         "DependentLocality": {
+    #           "DependentLocalityName": "1er Arrondissement",
+    #           "Thoroughfare": {
+    #             "ThoroughfareName": "Rue Étienne Marcel"
+    #           }
+    #         }
+    #       }
+    #     }
+    #   }
+    # }
+
+    DEPENDENT_LOCALITY_1 = %w[
+      GeoObject metaDataProperty GeocoderMetaData
+      AddressDetails Country
+      AdministrativeArea Locality
+      DependentLocality
+    ].freeze
+
+    # On DEPENDENT_LOCALITY_2 (for special cases like turkish "mahalle")
+    # https://en.wikipedia.org/wiki/Mahalle
+    # example: 'Istanbul Mabeyinci Yokuşu 17'
+
+    # "AddressDetails": {
+    #   "Country": {
+    #     "AddressLine": "İstanbul, Fatih, Saraç İshak Mah., Mabeyinci Yokuşu, 17",
+    #     "CountryNameCode": "TR",
+    #     "CountryName": "Turkey",
+    #     "AdministrativeArea": {
+    #       "AdministrativeAreaName": "İstanbul",
+    #       "SubAdministrativeArea": {
+    #         "SubAdministrativeAreaName": "Fatih",
+    #         "Locality": {
+    #           "DependentLocality": {
+    #             "DependentLocalityName": "Saraç İshak Mah.",
+    #             "Thoroughfare": {
+    #               "ThoroughfareName": "Mabeyinci Yokuşu",
+    #               "Premise": {
+    #                 "PremiseNumber": "17"
+    #               }
+    #             }
+    #           }
+    #         }
+    #       }
+    #     }
+    #   }
+    # }
+
+    DEPENDENT_LOCALITY_2 = %w[
+      GeoObject metaDataProperty GeocoderMetaData
+      AddressDetails Country
+      AdministrativeArea
+      SubAdministrativeArea Locality
+      DependentLocality
+    ].freeze
 
     def coordinates
       @data['GeoObject']['Point']['pos'].split(' ').reverse.map(&:to_f)
     end
 
-    def address(format = :full)
+    def address(_format = :full)
       @data['GeoObject']['metaDataProperty']['GeocoderMetaData']['text']
     end
 
     def city
-      if state.empty? and address_details and address_details.has_key? 'Locality'
-        address_details['Locality']['LocalityName']
-      elsif sub_state.empty? and address_details and address_details.has_key? 'AdministrativeArea' and
-          address_details['AdministrativeArea'].has_key? 'Locality'
-        address_details['AdministrativeArea']['Locality']['LocalityName']
-      elsif not sub_state_city.empty?
-        sub_state_city
-      else
-        ""
-      end
+      result =
+        if state.empty?
+          find_in_hash(@data, *COUNTRY_LEVEL, 'Locality', 'LocalityName')
+        elsif sub_state.empty?
+          find_in_hash(@data, *ADMIN_LEVEL, 'Locality', 'LocalityName')
+        else
+          find_in_hash(@data, *SUBADMIN_LEVEL, 'Locality', 'LocalityName')
+        end
+
+      result || ""
     end
 
     def country
-      if address_details
-        address_details['CountryName']
-      else
-        ""
-      end
+      find_in_hash(@data, *COUNTRY_LEVEL, 'CountryName') || ""
     end
 
     def country_code
-      if address_details
-        address_details['CountryNameCode']
-      else
-        ""
-      end
+      find_in_hash(@data, *COUNTRY_LEVEL, 'CountryNameCode') || ""
     end
 
     def state
-      if address_details and address_details['AdministrativeArea']
-        address_details['AdministrativeArea']['AdministrativeAreaName']
-      else
-        ""
-      end
+      find_in_hash(@data, *ADMIN_LEVEL, 'AdministrativeAreaName') || ""
     end
 
     def sub_state
-      if !state.empty? and address_details and address_details['AdministrativeArea']['SubAdministrativeArea']
-        address_details['AdministrativeArea']['SubAdministrativeArea']['SubAdministrativeAreaName']
-      else
-        ""
-      end
+      return "" if state.empty?
+      find_in_hash(@data, *SUBADMIN_LEVEL, 'SubAdministrativeAreaName') || ""
     end
 
     def state_code
       ""
     end
 
-    def postal_code
-      ""
+    def street
+      thoroughfare_data.is_a?(Hash) ? thoroughfare_data['ThoroughfareName'] : ""
     end
 
-    def premise_name
-      address_details['Locality']['Premise']['PremiseName']
+    def street_number
+      premise.is_a?(Hash) ? premise.fetch('PremiseNumber', "") : ""
     end
 
-    def street
-      thoroughfare_data && thoroughfare_data['ThoroughfareName']
+    def premise_name
+      premise.is_a?(Hash) ? premise.fetch('PremiseName', "") : ""
     end
 
-    def street_number
-      thoroughfare_data && thoroughfare_data['Premise'] && thoroughfare_data['Premise']['PremiseNumber']
+    def postal_code
+      return "" unless premise.is_a?(Hash)
+      find_in_hash(premise, 'PostalCode', 'PostalCodeNumber') || ""
     end
 
     def kind
@@ -93,42 +238,55 @@ module Geocoder::Result
 
     private # ----------------------------------------------------------------
 
-    def thoroughfare_data
-      locality_data && locality_data['Thoroughfare']
+    def top_level_locality
+      find_in_hash(@data, *ADDRESS_DETAILS, 'Locality')
     end
 
-    def locality_data
-      dependent_locality && subadmin_locality && admin_locality
+    def country_level_locality
+      find_in_hash(@data, *COUNTRY_LEVEL, 'Locality')
     end
 
     def admin_locality
-      address_details && address_details['AdministrativeArea'] &&
-        address_details['AdministrativeArea']['Locality']
+      find_in_hash(@data, *ADMIN_LEVEL, 'Locality')
     end
 
     def subadmin_locality
-      address_details && address_details['AdministrativeArea'] &&
-        address_details['AdministrativeArea']['SubAdministrativeArea'] &&
-        address_details['AdministrativeArea']['SubAdministrativeArea']['Locality']
+      find_in_hash(@data, *SUBADMIN_LEVEL, 'Locality')
     end
 
     def dependent_locality
-      address_details && address_details['AdministrativeArea'] &&
-        address_details['AdministrativeArea']['SubAdministrativeArea'] &&
-        address_details['AdministrativeArea']['SubAdministrativeArea']['Locality'] &&
-        address_details['AdministrativeArea']['SubAdministrativeArea']['Locality']['DependentLocality']
+      find_in_hash(@data, *DEPENDENT_LOCALITY_1) ||
+        find_in_hash(@data, *DEPENDENT_LOCALITY_2)
+    end
+
+    def locality_data
+      dependent_locality || subadmin_locality || admin_locality ||
+        country_level_locality || top_level_locality
+    end
+
+    def thoroughfare_data
+      locality_data['Thoroughfare'] if locality_data.is_a?(Hash)
     end
 
-    def address_details
-      @data['GeoObject']['metaDataProperty']['GeocoderMetaData']['AddressDetails']['Country']
+    def premise
+      if thoroughfare_data.is_a?(Hash)
+        thoroughfare_data['Premise']
+      elsif locality_data.is_a?(Hash)
+        locality_data['Premise']
+      end
     end
 
-    def sub_state_city
-      if !sub_state.empty? and address_details and address_details['AdministrativeArea']['SubAdministrativeArea'].has_key? 'Locality'
-        address_details['AdministrativeArea']['SubAdministrativeArea']['Locality']['LocalityName'] || ""
-      else
-        ""
+    def find_in_hash(source, *keys)
+      key = keys.shift
+      result = source[key]
+
+      if keys.empty?
+        return result
+      elsif !result.is_a?(Hash)
+        return nil
       end
+
+      find_in_hash(result, *keys)
     end
   end
 end

data/lib/geocoder/sql.rb

@@ -44,13 +44,13 @@ module Geocoder
     end
 
     def within_bounding_box(sw_lat, sw_lng, ne_lat, ne_lng, lat_attr, lon_attr)
-      spans = "#{lat_attr} BETWEEN #{sw_lat} AND #{ne_lat} AND "
+      spans = "#{lat_attr} BETWEEN #{sw_lat.to_f} AND #{ne_lat.to_f} AND "
       # handle box that spans 180 longitude
       if sw_lng.to_f > ne_lng.to_f
-        spans + "(#{lon_attr} BETWEEN #{sw_lng} AND 180 OR " +
-        "#{lon_attr} BETWEEN -180 AND #{ne_lng})"
+        spans + "(#{lon_attr} BETWEEN #{sw_lng.to_f} AND 180 OR " +
+        "#{lon_attr} BETWEEN -180 AND #{ne_lng.to_f})"
       else
-        spans + "#{lon_attr} BETWEEN #{sw_lng} AND #{ne_lng}"
+        spans + "#{lon_attr} BETWEEN #{sw_lng.to_f} AND #{ne_lng.to_f}"
       end
     end
 

data/lib/geocoder/util.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Geocoder
+  module Util
+    #
+    # Recursive version of Hash#merge!
+    #
+    # Adds the contents of +h2+ to +h1+,
+    # merging entries in +h1+ with duplicate keys with those from +h2+.
+    #
+    # Compared with Hash#merge!, this method supports nested hashes.
+    # When both +h1+ and +h2+ contains an entry with the same key,
+    # it merges and returns the values from both hashes.
+    #
+    #    h1 = {"a" => 100, "b" => 200, "c" => {"c1" => 12, "c2" => 14}}
+    #    h2 = {"b" => 254, "c" => {"c1" => 16, "c3" => 94}}
+    #    recursive_hash_merge(h1, 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 self.recursive_hash_merge(h1, h2)
+      h1.merge!(h2) do |_key, oldval, newval|
+        oldval.class == h1.class ? self.recursive_hash_merge(oldval, newval) : newval
+      end
+    end
+  end
+end