geocoder 1.2.6 → 1.8.2

data/lib/geocoder/results/tencent.rb

@@ -0,0 +1,72 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Tencent < Base
+
+    def coordinates
+      ['lat', 'lng'].map{ |i| @data['location'][i] }
+    end
+
+    def address
+      "#{province}#{city}#{district}#{street}#{street_number}"
+
+      #@data['title'] or @data['address']
+    end
+
+    # NOTE: The Tencent reverse geocoding API has the field named
+    # 'address_component' compared to 'address_components' in the 
+    # regular geocoding API.
+    def province
+      @data['address_components'] and (@data['address_components']['province']) or 
+      (@data['address_component'] and @data['address_component']['province']) or
+      ""
+    end
+
+    alias_method :state, :province
+
+    def city
+      @data['address_components'] and (@data['address_components']['city']) or 
+      (@data['address_component'] and @data['address_component']['city']) or
+      ""
+    end
+
+    def district
+      @data['address_components'] and (@data['address_components']['district']) or 
+      (@data['address_component'] and @data['address_component']['district']) or
+      ""
+    end
+
+    def street
+      @data['address_components'] and (@data['address_components']['street']) or 
+      (@data['address_component'] and @data['address_component']['street']) or
+      ""
+    end
+
+    def street_number
+      @data['address_components'] and (@data['address_components']['street_number']) or 
+      (@data['address_component'] and @data['address_component']['street_number']) or
+      ""
+    end
+
+    def address_components
+      @data['address_components'] or @data['address_component']
+    end
+
+    def state_code
+      ""
+    end
+
+    def postal_code
+      ""
+    end
+
+    def country
+      "China"
+    end
+
+    def country_code
+      "CN"
+    end
+
+  end
+end

data/lib/geocoder/results/test.rb

@@ -15,7 +15,7 @@ module Geocoder
         end
       end
 
-      %w[latitude longitude neighborhood city state state_code sub_state
+      %w[coordinates neighborhood city state state_code sub_state
       sub_state_code province province_code postal_code country
       country_code address street_address street_number route geometry].each do |attr|
         add_result_attribute(attr)

data/lib/geocoder/results/twogis.rb

@@ -0,0 +1,76 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Twogis < Base
+    def coordinates
+      ['lat', 'lon'].map{ |i| @data['point'][i] } if @data['point']
+    end
+
+    def address(_format = :full)
+      @data['full_address_name'] || ''
+    end
+
+    def city
+      return '' unless @data['adm_div']
+      @data['adm_div'].select{|u| u["type"] == "city"}.first.try(:[], 'name') || ''
+    end
+
+    def region
+      return '' unless @data['adm_div']
+      @data['adm_div'].select{|u| u["type"] == "region"}.first.try(:[], 'name') || ''
+    end
+
+    def country
+      return '' unless @data['adm_div']
+      @data['adm_div'].select{|u| u["type"] == "country"}.first.try(:[], 'name') || ''
+    end
+
+    def district
+      return '' unless @data['adm_div']
+      @data['adm_div'].select{|u| u["type"] == "district"}.first.try(:[], 'name') || ''
+    end
+
+    def district_area
+      return '' unless @data['adm_div']
+      @data['adm_div'].select{|u| u["type"] == "district_area"}.first.try(:[], 'name') || ''
+    end
+
+    def street_address
+      @data['address_name'] || ''
+    end
+
+    def street
+      return '' unless @data['address_name']
+      @data['address_name'].split(', ').first
+    end
+
+    def street_number
+      return '' unless @data['address_name']
+      @data['address_name'].split(', ')[1] || ''
+    end
+
+    def type
+      @data['type'] || ''
+    end
+
+    def purpose_name
+      @data['purpose_name'] || ''
+    end
+
+    def building_name
+      @data['building_name'] || ''
+    end
+
+    def subtype
+      @data['subtype'] || ''
+    end
+
+    def subtype_specification
+      @data['subtype_specification'] || ''
+    end
+
+    def name
+      @data['name'] || ''
+    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,61 +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.has_key? 'Locality'
-        address_details['Locality']['LocalityName']
-      elsif sub_state.empty? 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
-      address_details['CountryName']
+      find_in_hash(@data, *COUNTRY_LEVEL, 'CountryName') || ""
     end
 
     def country_code
-      address_details['CountryNameCode']
+      find_in_hash(@data, *COUNTRY_LEVEL, 'CountryNameCode') || ""
     end
 
     def state
-      if 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['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 street_number
+      premise.is_a?(Hash) ? premise.fetch('PremiseNumber', "") : ""
     end
 
     def premise_name
-      address_details['Locality']['Premise']['PremiseName']
+      premise.is_a?(Hash) ? premise.fetch('PremiseName', "") : ""
+    end
+
+    def postal_code
+      return "" unless premise.is_a?(Hash)
+      find_in_hash(premise, 'PostalCode', 'PostalCodeNumber') || ""
     end
 
     def kind
@@ -67,18 +229,64 @@ module Geocoder::Result
       @data['GeoObject']['metaDataProperty']['GeocoderMetaData']['precision']
     end
 
+    def viewport
+      envelope = @data['GeoObject']['boundedBy']['Envelope'] || fail
+      east, north = envelope['upperCorner'].split(' ').map(&:to_f)
+      west, south = envelope['lowerCorner'].split(' ').map(&:to_f)
+      [south, west, north, east]
+    end
+
     private # ----------------------------------------------------------------
 
-    def address_details
-      @data['GeoObject']['metaDataProperty']['GeocoderMetaData']['AddressDetails']['Country']
+    def top_level_locality
+      find_in_hash(@data, *ADDRESS_DETAILS, 'Locality')
+    end
+
+    def country_level_locality
+      find_in_hash(@data, *COUNTRY_LEVEL, 'Locality')
+    end
+
+    def admin_locality
+      find_in_hash(@data, *ADMIN_LEVEL, 'Locality')
+    end
+
+    def subadmin_locality
+      find_in_hash(@data, *SUBADMIN_LEVEL, 'Locality')
     end
 
-    def sub_state_city
-      if !sub_state.empty? and address_details['AdministrativeArea']['SubAdministrativeArea'].has_key? 'Locality'
-        address_details['AdministrativeArea']['SubAdministrativeArea']['Locality']['LocalityName'] || ""
-      else
-        ""
+    def dependent_locality
+      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 premise
+      if thoroughfare_data.is_a?(Hash)
+        thoroughfare_data['Premise']
+      elsif locality_data.is_a?(Hash)
+        locality_data['Premise']
       end
     end
+
+    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

@@ -4,8 +4,8 @@ module Geocoder
 
     ##
     # Distance calculation for use with a database that supports POWER(),
-    # SQRT(), PI(), and trigonometric functions SIN(), COS(), ASIN(),
-    # ATAN2(), DEGREES(), and RADIANS().
+    # SQRT(), PI(), and trigonometric functions SIN(), COS(), ASIN(), 
+    # ATAN2().
     #
     # Based on the excellent tutorial at:
     # http://www.scribd.com/doc/2569355/Geo-Distance-Search-with-MySQL
@@ -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
 
@@ -59,6 +59,9 @@ module Geocoder
     # and an options hash which must include a :bearing value
     # (:linear or :spherical).
     #
+    # For use with a database that supports MOD() and trigonometric functions
+    # SIN(), COS(), ASIN(), ATAN2().
+    #
     # Based on:
     # http://www.beginningspatial.com/calculating_bearing_one_point_another
     #