ultra-fast-mod 0.0.1

data/geocoder-1.8.6/lib/geocoder/results/geoapify.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require 'geocoder/results/base'
+
+module Geocoder
+  module Result
+    # https://apidocs.geoapify.com/docs/geocoding/api
+    class Geoapify < Base
+      def address(_format = :full)
+        properties['formatted']
+      end
+
+      def address_line1
+        properties['address_line1']
+      end
+
+      def address_line2
+        properties['address_line2']
+      end
+
+      def house_number
+        properties['housenumber']
+      end
+
+      def street
+        properties['street']
+      end
+
+      def postal_code
+        properties['postcode']
+      end
+
+      def district
+        properties['district']
+      end
+
+      def suburb
+        properties['suburb']
+      end
+
+      def city
+        properties['city']
+      end
+
+      def county
+        properties['county']
+      end
+
+      def state
+        properties['state']
+      end
+
+      # Not currently available in the API
+      def state_code
+        ''
+      end
+
+      def country
+        properties['country']
+      end
+
+      def country_code
+        return unless properties['country_code']
+
+        properties['country_code'].upcase
+      end
+
+      def coordinates
+        return unless properties['lat']
+        return unless properties['lon']
+
+        [properties['lat'], properties['lon']]
+      end
+
+      # See: https://tools.ietf.org/html/rfc7946#section-3.1
+      #
+      # Each feature has a "Point" type in the Geoapify API.
+      def geometry
+        return unless data['geometry']
+
+        symbol_hash data['geometry']
+      end
+
+      # See: https://tools.ietf.org/html/rfc7946#section-5
+      def bounds
+        data['bbox']
+      end
+
+      # Type of the result, one of:
+      #
+      #   * :unknown
+      #   * :amenity
+      #   * :building
+      #   * :street
+      #   * :suburb
+      #   * :district
+      #   * :postcode
+      #   * :city
+      #   * :county
+      #   * :state
+      #   * :country
+      #
+      def type
+        return :unknown unless properties['result_type']
+
+        properties['result_type'].to_sym
+      end
+
+      # Distance in meters to given bias:proximity or to given coordinates for
+      # reverse geocoding
+      def distance
+        properties['distance']
+      end
+
+      # Calculated rank for the result, containing the following keys:
+      #
+      #   * `popularity` - The popularity score of the result
+      #   * `confidence` - The confidence value of the result (0-1)
+      #   * `match_type` - The result's match type, one of following:
+      #      * full_match
+      #      * inner_part
+      #      * match_by_building
+      #      * match_by_street
+      #      * match_by_postcode
+      #      * match_by_city_or_disrict
+      #      * match_by_country_or_state
+      #
+      # Example:
+      #   {
+      #     popularity: 8.615793062435909,
+      #     confidence: 0.88,
+      #     match_type: :full_match
+      #   }
+      def rank
+        return unless properties['rank']
+
+        r = symbol_hash(properties['rank'])
+        r[:match_type] = r[:match_type].to_sym if r[:match_type]
+        r
+      end
+
+      # Examples:
+      #
+      # Open
+      #   {
+      #     sourcename: 'openstreetmap',
+      #     wheelchair: 'limited',
+      #     wikidata: 'Q186125',
+      #     wikipedia: 'en:Madison Square Garden',
+      #     website: 'http://www.thegarden.com/',
+      #     phone: '12124656741',
+      #     osm_type: 'W',
+      #     osm_id: 138141251,
+      #     continent: 'North America',
+      #   }
+      def datasource
+        return unless properties['datasource']
+
+        symbol_hash properties['datasource']
+      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
+end

data/geocoder-1.8.6/lib/geocoder/results/geocoder_ca.rb

@@ -0,0 +1,60 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class GeocoderCa < Base
+
+    def coordinates
+      [@data['latt'].to_f, @data['longt'].to_f]
+    end
+
+    def address(format = :full)
+      "#{street_address}, #{city}, #{state} #{postal_code}, #{country}".sub(/^[ ,]*/, "")
+    end
+
+    def street_address
+      "#{@data['stnumber']} #{@data['staddress']}"
+    end
+
+    def city
+      @data['city'] or (@data['standard'] and @data['standard']['city']) or ""
+    end
+
+    def state
+      @data['prov'] or (@data['standard'] and @data['standard']['prov']) or ""
+    end
+
+    alias_method :state_code, :state
+
+    def postal_code
+      @data['postal'] or (@data['standard'] and @data['standard']['postal']) or ""
+    end
+
+    def country
+      country_code == 'CA' ? 'Canada' : 'United States'
+    end
+
+    def country_code
+      return nil if state.nil? || state == ""
+      canadian_province_abbreviations.include?(state) ? "CA" : "US"
+    end
+
+    def self.response_attributes
+      %w[latt longt inlatt inlongt distance stnumber staddress prov
+        NearRoad NearRoadDistance betweenRoad1 betweenRoad2
+        intersection major_intersection]
+    end
+
+    response_attributes.each do |a|
+      define_method a do
+        @data[a]
+      end
+    end
+
+
+    private # ----------------------------------------------------------------
+
+    def canadian_province_abbreviations
+      %w[ON QC NS NB MB BC PE SK AB NL]
+    end
+  end
+end

data/geocoder-1.8.6/lib/geocoder/results/geocodio.rb

@@ -0,0 +1,78 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Geocodio < Base
+    def number
+      address_components["number"]
+    end
+
+    def street
+      address_components["street"]
+    end
+
+    def suffix
+      address_components["suffix"]
+    end
+
+    def street_address
+      [number, address_components["formatted_street"]].compact.join(' ')
+    end
+
+    def state
+      address_components["state"]
+    end
+    alias_method :state_code, :state
+
+    def zip
+      # Postal code is not returned for Canada geocode results
+      address_components["zip"] || ""
+    end
+    alias_method :postal_code, :zip
+
+    def country
+      # Geocodio supports US and Canada, however they don't return the full
+      # country name.
+
+      if country_code == "CA"
+        "Canada"
+      else
+        "United States"
+      end
+    end
+
+    def country_code
+      address_components['country']
+    end
+
+    def city
+      address_components["city"]
+    end
+
+    def postdirectional
+      address_components["postdirectional"]
+    end
+
+    def location
+      @data['location']
+    end
+
+    def coordinates
+      ['lat', 'lng'].map{ |i| location[i].to_f } if location
+    end
+
+    def accuracy
+      @data['accuracy'].to_f if @data.key?('accuracy')
+    end
+
+    def formatted_address(format = :full)
+      @data['formatted_address']
+    end
+    alias_method :address, :formatted_address
+
+    private
+
+    def address_components
+      @data['address_components'] || {}
+    end
+  end
+end

data/geocoder-1.8.6/lib/geocoder/results/geoip2.rb

@@ -0,0 +1,76 @@
+require 'geocoder/results/base'
+
+module Geocoder
+  module Result
+    class Geoip2 < Base
+
+      def coordinates
+        %w[latitude longitude].map do |l|
+          data.fetch('location', {}).fetch(l, 0.0)
+        end
+      end
+
+      def city
+        fetch_name(
+          data.fetch('city', {}).fetch('names', {})
+        )
+      end
+
+      def state
+        fetch_name(
+          data.fetch('subdivisions', []).fetch(0, {}).fetch('names', {})
+        )
+      end
+
+      def state_code
+        data.fetch('subdivisions', []).fetch(0, {}).fetch('iso_code', '')
+      end
+
+      def country
+        fetch_name(
+          data.fetch('country', {}).fetch('names', {})
+        )
+      end
+
+      def country_code
+        data.fetch('country', {}).fetch('iso_code', '')
+      end
+
+      def postal_code
+        data.fetch('postal', {}).fetch('code', '')
+      end
+
+      def self.response_attributes
+        %w[ip]
+      end
+
+      response_attributes.each do |a|
+        define_method a do
+          @data[a]
+        end
+      end
+
+      def language=(l)
+        @language = l.to_s
+      end
+
+      def language
+        @language ||= default_language
+      end
+
+      def data
+        @data.to_hash
+      end
+
+      private
+
+      def default_language
+        @default_language = Geocoder.config[:language].to_s
+      end
+
+      def fetch_name(names)
+        names[language] || names[default_language] || ''
+      end
+    end
+  end
+end

data/geocoder-1.8.6/lib/geocoder/results/geoportail_lu.rb

@@ -0,0 +1,71 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class GeoportailLu < Base
+
+    def coordinates
+      geomlonlat['coordinates'].reverse if geolocalized?
+    end
+
+    def address
+      full_address
+    end
+
+    def city
+      try_to_extract 'locality', detailled_address
+    end
+
+    def state
+      'Luxembourg'
+    end
+
+    def state_code
+      'LU'
+    end
+
+    def postal_code
+      try_to_extract 'zip', detailled_address
+    end
+
+    def street_address
+      [street_number, street].compact.join(' ')
+    end
+
+    def street_number
+      try_to_extract 'postnumber', detailled_address
+    end
+
+    def street
+      try_to_extract 'street', detailled_address
+    end
+
+    def full_address
+      data['address']
+    end
+
+    def geomlonlat
+      data['geomlonlat']
+    end
+
+    def detailled_address
+      data['AddressDetails']
+    end
+
+    alias_method :country, :state
+    alias_method :province, :state
+    alias_method :country_code, :state_code
+    alias_method :province_code, :state_code
+
+    private
+
+    def geolocalized?
+      !!try_to_extract('coordinates', geomlonlat)
+    end
+
+    def try_to_extract(key, hash)
+      if hash.is_a?(Hash) and hash.include?(key)
+        hash[key]
+      end
+    end
+  end
+end

data/geocoder-1.8.6/lib/geocoder/results/google.rb

@@ -0,0 +1,150 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Google < Base
+
+    def coordinates
+      ['lat', 'lng'].map{ |i| geometry['location'][i] }
+    end
+
+    def address(format = :full)
+      formatted_address
+    end
+
+    def neighborhood
+      if neighborhood = address_components_of_type(:neighborhood).first
+        neighborhood['long_name']
+      end
+    end
+
+    def city
+      fields = [:locality, :sublocality,
+        :administrative_area_level_3,
+        :administrative_area_level_2]
+      fields.each do |f|
+        if entity = address_components_of_type(f).first
+          return entity['long_name']
+        end
+      end
+      return nil # no appropriate components found
+    end
+
+    def state
+      if state = address_components_of_type(:administrative_area_level_1).first
+        state['long_name']
+      end
+    end
+
+    def state_code
+      if state = address_components_of_type(:administrative_area_level_1).first
+        state['short_name']
+      end
+    end
+
+    def sub_state
+      if state = address_components_of_type(:administrative_area_level_2).first
+        state['long_name']
+      end
+    end
+
+    def sub_state_code
+      if state = address_components_of_type(:administrative_area_level_2).first
+        state['short_name']
+      end
+    end
+
+    def country
+      if country = address_components_of_type(:country).first
+        country['long_name']
+      end
+    end
+
+    def country_code
+      if country = address_components_of_type(:country).first
+        country['short_name']
+      end
+    end
+
+    def postal_code
+      if postal = address_components_of_type(:postal_code).first
+        postal['long_name']
+      end
+    end
+
+    def route
+      if route = address_components_of_type(:route).first
+        route['long_name']
+      end
+    end
+
+    def street_number
+      if street_number = address_components_of_type(:street_number).first
+        street_number['long_name']
+      end
+    end
+
+    def street_address
+      [street_number, route].compact.join(' ')
+    end
+
+    def types
+      @data['types']
+    end
+
+    def formatted_address
+      @data['formatted_address']
+    end
+
+    def address_components
+      @data['address_components']
+    end
+
+    ##
+    # Get address components of a given type. Valid types are defined in
+    # Google's Geocoding API documentation and include (among others):
+    #
+    #   :street_number
+    #   :locality
+    #   :neighborhood
+    #   :route
+    #   :postal_code
+    #
+    def address_components_of_type(type)
+      address_components.select{ |c| c['types'].include?(type.to_s) }
+    end
+
+    def geometry
+      @data['geometry']
+    end
+
+    def precision
+      geometry['location_type'] if geometry
+    end
+
+    def partial_match
+      @data['partial_match']
+    end
+
+    def place_id
+      @data['place_id']
+    end
+
+    def viewport
+      viewport = geometry['viewport'] || fail
+      bounding_box_from viewport
+    end
+
+    def bounds
+      bounding_box_from geometry['bounds']
+    end
+
+    private
+
+    def bounding_box_from(box)
+      return nil unless box
+      south, west = %w(lat lng).map { |c| box['southwest'][c] }
+      north, east = %w(lat lng).map { |c| box['northeast'][c] }
+      [south, west, north, east]
+    end
+  end
+end

data/geocoder-1.8.6/lib/geocoder/results/google_places_details.rb

@@ -0,0 +1,39 @@
+require "geocoder/results/google"
+
+module Geocoder
+  module Result
+    class GooglePlacesDetails < Google
+      def place_id
+        @data["place_id"]
+      end
+
+      def types
+        @data["types"] || []
+      end
+
+      def reviews
+        @data["reviews"] || []
+      end
+
+      def rating
+        @data["rating"]
+      end
+
+      def rating_count
+        @data["user_ratings_total"]
+      end
+
+      def phone_number
+        @data["international_phone_number"]
+      end
+
+      def website
+        @data["website"]
+      end
+
+      def photos
+        @data["photos"]
+      end
+    end
+  end
+end

data/geocoder-1.8.6/lib/geocoder/results/google_places_search.rb

@@ -0,0 +1,52 @@
+require "geocoder/results/google"
+
+module Geocoder
+  module Result
+    class GooglePlacesSearch < Google
+
+      def types
+        @data["types"] || []
+      end
+
+      def rating
+        @data["rating"]
+      end
+
+      def photos
+        @data["photos"]
+      end
+
+      def city
+        ""
+      end
+
+      def state
+        ""
+      end
+
+      def state_code
+        ""
+      end
+
+      def province
+        ""
+      end
+
+      def province_code
+        ""
+      end
+
+      def postal_code
+        ""
+      end
+
+      def country
+        ""
+      end
+
+      def country_code
+        ""
+      end
+    end
+  end
+end

data/geocoder-1.8.6/lib/geocoder/results/google_premier.rb

@@ -0,0 +1,6 @@
+require 'geocoder/results/google'
+
+module Geocoder::Result
+  class GooglePremier < Google
+  end
+end