really-broken-geocoder 1.5.1

data/lib/geocoder/results/amap.rb

@@ -0,0 +1,87 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Amap < Base
+
+    def coordinates
+      location = @data['location'] || @data['roadinters'].try(:first).try(:[], 'location') \
+        || address_components.try(:[], 'streetNumber').try(:[], 'location')
+      location.to_s.split(",").reverse.map(&:to_f)
+    end
+
+    def address
+      formatted_address
+    end
+
+    def state
+      province
+    end
+
+    def province
+      address_components['province']
+    end
+
+    def city
+      address_components['city'] == [] ? province : address_components["city"]
+    end
+
+    def district
+      address_components['district']
+    end
+
+    def street
+      if address_components["neighborhood"]["name"] != []
+        return address_components["neighborhood"]["name"]
+      elsif address_components['township'] != []
+        return address_components["township"]
+      else
+        return @data['street'] || address_components['streetNumber'].try(:[], 'street')
+      end
+    end
+
+    def street_number
+      @data['number'] || address_components['streetNumber'].try(:[], 'number')
+    end
+
+    def formatted_address
+      @data['formatted_address']
+    end
+
+    def address_components
+      @data['addressComponent'] || @data
+    end
+
+    def state_code
+      ""
+    end
+
+    def postal_code
+      ""
+    end
+
+    def country
+      "China"
+    end
+
+    def country_code
+      "CN"
+    end
+
+    ##
+    # Get address components of a given type. Valid types are defined in
+    # Baidu's Geocoding API documentation and include (among others):
+    #
+    #   :business
+    #   :cityCode
+    #
+    def self.response_attributes
+      %w[roads pois roadinters]
+    end
+
+    response_attributes.each do |a|
+      define_method a do
+        @data[a]
+      end
+    end
+  end
+end

data/lib/geocoder/results/baidu.rb

@@ -0,0 +1,79 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Baidu < Base
+
+    def coordinates
+      ['lat', 'lng'].map{ |i| @data['location'][i] }
+    end
+
+    def address
+      @data['formatted_address']
+    end
+
+    def province
+      @data['addressComponent'] and @data['addressComponent']['province'] or ""
+    end
+
+    alias_method :state, :province
+
+    def city
+      @data['addressComponent'] and @data['addressComponent']['city'] or ""
+    end
+
+    def district
+      @data['addressComponent'] and @data['addressComponent']['district'] or ""
+    end
+
+    def street
+      @data['addressComponent'] and @data['addressComponent']['street'] or ""
+    end
+
+    def street_number
+      @data['addressComponent'] and @data['addressComponent']['street_number']
+    end
+
+    def formatted_address
+      @data['formatted_address'] or ""
+    end
+
+    alias_method :address, :formatted_address
+
+    def address_components
+      @data['addressComponent']
+    end
+
+    def state_code
+      ""
+    end
+
+    def postal_code
+      ""
+    end
+
+    def country
+      "China"
+    end
+
+    def country_code
+      "CN"
+    end
+
+    ##
+    # Get address components of a given type. Valid types are defined in
+    # Baidu's Geocoding API documentation and include (among others):
+    #
+    #   :business
+    #   :cityCode
+    #
+    def self.response_attributes
+      %w[business cityCode]
+    end
+
+    response_attributes.each do |a|
+      define_method a do
+        @data[a]
+      end
+    end
+  end
+end

data/lib/geocoder/results/baidu_ip.rb

@@ -0,0 +1,62 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class BaiduIp < Base
+    def coordinates
+      [point['y'].to_f, point['x'].to_f]
+    end
+
+    def address
+      @data['address']
+    end
+
+    def state
+      province
+    end
+
+    def province
+      address_detail['province']
+    end
+
+    def city
+      address_detail['city']
+    end
+
+    def district
+      address_detail['district']
+    end
+
+    def street
+      address_detail['street']
+    end
+
+    def street_number
+      address_detail['street_number']
+    end
+
+    def state_code
+      ""
+    end
+
+    def postal_code
+      ""
+    end
+
+    def country
+      "China"
+    end
+
+    def country_code
+      "CN"
+    end
+
+    private
+    def address_detail
+      @data['address_detail']
+    end
+
+    def point
+      @data['point']
+    end
+  end
+end

data/lib/geocoder/results/ban_data_gouv_fr.rb

@@ -0,0 +1,257 @@
+# encoding: utf-8
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class BanDataGouvFr < Base
+
+    #### BASE METHODS ####
+
+    def self.response_attributes
+      %w[limit attribution version licence type features]
+    end
+
+    response_attributes.each do |a|
+      unless method_defined?(a)
+        define_method a do
+          @data[a]
+        end
+      end
+    end
+
+    #### BEST RESULT ####
+
+    def result
+      features[0] if features.any?
+    end
+
+    #### GEOMETRY ####
+
+    def geometry
+      result['geometry'] if result
+    end
+
+    def precision
+      geometry['type'] if geometry
+    end
+
+    def coordinates
+      coords = geometry["coordinates"]
+      return [coords[1].to_f, coords[0].to_f]
+    end
+
+    #### PROPERTIES ####
+
+    # List of raw attrbutes returned by BAN data gouv fr API:
+    #
+    #   :id           =>    [string] UUID of the result, said to be not stable
+    #                       atm, based on IGN reference (Institut national de
+    #                       l'information géographique et forestière)
+    #
+    #   :type         =>    [string] result type (housenumber, street, city,
+    #                       town, village, locality)
+    #
+    #   :score        =>    [float] value between 0 and 1 giving result's
+    #                       relevancy
+    #
+    #   :housenumber  =>    [string] street number and extra information
+    #                       (bis, ter, A, B)
+    #
+    #   :street       =>    [string] street name
+    #
+    #   :name         =>    [string] housenumber and street name
+    #
+    #   :postcode     =>    [string] city post code (used for mails by La Poste,
+    #                       beware many cities got severeal postcodes)
+    #
+    #   :citycode     =>    [string] city code (INSEE reference,
+    #                       consider it as a french institutional UUID)
+    #
+    #   :city         =>    [string] city name
+    #
+    #   :context      =>    [string] department code, department name and
+    #                       region code
+    #
+    #   :label        =>    [string] full address without state, country name
+    #                       and country code
+    #
+    # CITIES ONLY PROPERTIES
+    #
+    #   :adm_weight   =>    [string] administrative weight (importance) of
+    #                       the city
+    #
+    #   :population   =>    [float] number of inhabitants with a 1000 factor
+    #
+    # For up to date doc (in french only) : https://adresse.data.gouv.fr/api/
+    #
+    def properties
+      result['properties'] if result
+    end
+
+    # List of usable Geocoder results' methods
+    #
+    #   score                   =>    [float] result relevance 0 to 1
+    #
+    #   location_id             =>    [string] location's IGN UUID
+    #
+    #   result_type             =>    [string] housenumber / street / city
+    #                                 / town / village / locality
+    #
+    #   international_address   =>    [string] full address with country code
+    #
+    #   national_address        =>    [string] full address with country code
+    #
+    #   street_address          =>    [string] housenumber + extra inf
+    #                                 + street name
+    #
+    #   street_number           =>    [string] housenumber + extra inf
+    #                                 (bis, ter, etc)
+    #
+    #   street_name             =>    [string] street's name
+    #
+    #   city_name               =>    [string] city's name
+    #
+    #   city_code               =>    [string] city's INSEE UUID
+    #
+    #   postal_code             =>    [string] city's postal code (used for mails)
+    #
+    #   context                 =>    [string] city's department code, department
+    #                                  name and region name
+    #
+    #   demartment_name         =>    [string] city's department name
+    #
+    #   department_code         =>    [string] city's department INSEE UUID
+    #
+    #   region_name             =>    [string] city's region name
+    #
+    #   population              =>    [string] city's inhabitants count
+    #
+    #   administrative_weight   =>    [integer] city's importance on a scale
+    #                                 from 6 (capital city) to 1 (regular village)
+    #
+    def score
+      properties['score']
+    end
+
+    def location_id
+      properties['id']
+    end
+
+    # Types
+    #
+    #   housenumber
+    #   street
+    #   city
+    #   town
+    #   village
+    #   locality
+    #
+    def result_type
+      properties['type']
+    end
+
+    def international_address
+      "#{national_address}, #{country}"
+    end
+
+    def national_address
+      properties['label']
+    end
+
+    def street_address
+      properties['name']
+    end
+
+    def street_number
+      properties['housenumber']
+    end
+
+    def street_name
+      properties['street']
+    end
+
+    def city_name
+      properties['city']
+    end
+
+    def city_code
+      properties['citycode']
+    end
+
+    def postal_code
+      properties['postcode']
+    end
+
+    def context
+      properties['context'].split(/,/).map(&:strip)
+    end
+
+    def department_code
+      context[0] if context.length > 0
+    end
+
+    # Monkey logic to handle fact Paris is both a city and a department
+    # in Île-de-France region
+    def department_name
+      if context.length > 1
+        if context[1] == "Île-de-France"
+          "Paris"
+        else
+          context[1]
+        end
+      end
+    end
+
+    def region_name
+      if context.length == 2 && context[1] == "Île-de-France"
+        context[1]
+      elsif context.length > 2
+        context[2]
+      end
+    end
+
+    def country
+      "France"
+    end
+
+    # Country code types
+    #    FR : France
+    #    GF : Guyane Française
+    #    RE : Réunion
+    #    NC : Nouvelle-Calédonie
+    #    GP : Guadeloupe
+    #    MQ : Martinique
+    #    MU : Maurice
+    #    PF : Polynésie française
+    #
+    # Will need refacto to handle different country codes, but BAN API
+    # is currently mainly designed for geocode FR country code addresses
+    def country_code
+      "FR"
+    end
+
+    #### ALIAS METHODS ####
+
+    alias_method :address, :international_address
+    alias_method :street, :street_name
+    alias_method :city, :city_name
+    alias_method :state, :region_name
+    alias_method :state_code, :state
+
+    #### CITIES' METHODS ####
+
+    def population
+      (properties['population'].to_f * 1000).to_i if city?(result_type)
+    end
+
+    def administrative_weight
+      properties['adm_weight'].to_i if city?(result_type)
+    end
+
+    private
+
+    def city?(result_type)
+      %w(village town city).include?(result_type)
+    end
+
+  end
+end