ultra-fast-mod 0.0.1

data/geocoder-1.8.6/lib/geocoder/lookups/esri.rb

@@ -0,0 +1,114 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/esri"
+require 'geocoder/esri_token'
+
+module Geocoder::Lookup
+  class Esri < Base
+
+    def name
+      "Esri"
+    end
+
+      def supported_protocols
+        [:https]
+      end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      action = query.reverse_geocode? ? "reverseGeocode" : "find"
+      "#{protocol}://geocode.arcgis.com/arcgis/rest/services/World/GeocodeServer/#{action}?"
+    end
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+
+      if (doc['error'].nil?)
+        if (!query.reverse_geocode?)
+          return [] if !doc['locations'] || doc['locations'].empty?
+        end
+        return [ doc ]
+      else
+        case [ doc['error']['code'] ]
+        when [498]
+          raise_error(Geocoder::InvalidApiKey, doc['error']['message']) ||
+            Geocoder.log(:warn, "#{self.name} Geocoding API error: #{doc['error']['message']}")
+        when [ 403 ]
+          raise_error(Geocoder::RequestDenied, 'ESRI request denied') ||
+            Geocoder.log(:warn, "#{self.name} ESRI request denied: #{doc['error']['message']}")
+        when [ 500 ], [501]
+          raise_error(Geocoder::ServiceUnavailable, 'ESRI service unavailable') ||
+            Geocoder.log(:warn, "#{self.name} ESRI service error: #{doc['error']['message']}")
+        else
+          raise_error(Geocoder::Error, doc['error']['message']) ||
+            Geocoder.log(:warn, "#{self.name} Geocoding error: #{doc['error']['message']}")
+        end
+      end
+      return []
+    end
+
+    def query_url_params(query)
+      params = {
+        :f => "pjson",
+        :outFields => "*"
+      }
+      if query.reverse_geocode?
+        params[:location] = query.coordinates.reverse.join(',')
+      else
+        params[:text] = query.sanitized_text
+      end
+
+      params[:token] = token(query)
+
+      if for_storage_value = for_storage(query)
+        params[:forStorage] = for_storage_value
+      end
+      params[:sourceCountry] = configuration[:source_country] if configuration[:source_country]
+      params[:preferredLabelValues] = configuration[:preferred_label_values] if configuration[:preferred_label_values]
+
+      params.merge(super)
+    end
+
+    def for_storage(query)
+      if query.options.has_key?(:for_storage)
+        query.options[:for_storage]
+      else
+        configuration[:for_storage]
+      end
+    end
+
+    def token(query)
+      token_instance = if query.options[:token]
+                         query.options[:token]
+                       else
+                         configuration[:token]
+                       end
+
+      if !valid_token_configured?(token_instance) && configuration.api_key
+        token_instance = create_and_save_token!(query)
+      end
+
+      token_instance.to_s unless token_instance.nil?
+    end
+
+    def valid_token_configured?(token_instance)
+      !token_instance.nil? && token_instance.active?
+    end
+
+    def create_and_save_token!(query)
+      token_instance = create_token
+
+      if query.options[:token]
+        query.options[:token] = token_instance
+      else
+        Geocoder.merge_into_lookup_config(:esri, token: token_instance)
+      end
+
+      token_instance
+    end
+
+    def create_token
+      Geocoder::EsriToken.generate_token(*configuration.api_key)
+    end
+  end
+end

data/geocoder-1.8.6/lib/geocoder/lookups/freegeoip.rb

@@ -0,0 +1,62 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/freegeoip'
+
+module Geocoder::Lookup
+  class Freegeoip < Base
+
+    def name
+      "FreeGeoIP"
+    end
+
+    def supported_protocols
+      if configuration[:host]
+        [:https]
+      else
+        # use https for default host
+        [:https]
+      end
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://#{host}/json/#{query.sanitized_text}?"
+    end
+
+    def query_url_params(query)
+      {
+        :apikey => configuration.api_key
+      }.merge(super)
+    end
+
+    def parse_raw_data(raw_data)
+      raw_data.match(/^<html><title>404/) ? nil : super(raw_data)
+    end
+
+    def results(query)
+      # don't look up a loopback or private address, just return the stored result
+      return [reserved_result(query.text)] if query.internal_ip_address?
+      # note: Freegeoip.net returns plain text "Not Found" on bad request
+      (doc = fetch_data(query)) ? [doc] : []
+    end
+
+    def reserved_result(ip)
+      {
+        "ip"           => ip,
+        "city"         => "",
+        "region_code"  => "",
+        "region_name"  => "",
+        "metro_code"    => "",
+        "zip_code"      => "",
+        "latitude"     => "0",
+        "longitude"    => "0",
+        "country_name" => "Reserved",
+        "country_code" => "RD"
+      }
+    end
+
+    def host
+      configuration[:host] || "freegeoip.app"
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'geocoder/lookups/base'
+require 'geocoder/results/geoapify'
+
+module Geocoder
+  module Lookup
+    # https://apidocs.geoapify.com/docs/geocoding/api
+    class Geoapify < Base
+      def name
+        'Geoapify'
+      end
+
+      def required_api_key_parts
+        ['api_key']
+      end
+
+      def supported_protocols
+        [:https]
+      end
+
+      private
+
+      def base_query_url(query)
+        method = if query.reverse_geocode?
+          'reverse'
+        elsif query.options[:autocomplete]
+          'autocomplete'
+        else
+          'search'
+        end
+        "https://api.geoapify.com/v1/geocode/#{method}?"
+      end
+
+      def results(query)
+        return [] unless (doc = fetch_data(query))
+
+        # The rest of the status codes should be already handled by the default
+        # functionality as the API returns correct HTTP response codes in most
+        # cases. There may be some unhandled cases still (such as over query
+        # limit reached) but there is not enough documentation to cover them.
+        case doc['statusCode']
+        when 500
+          raise_error(Geocoder::InvalidRequest) || Geocoder.log(:warn, doc['message'])
+        end
+
+        return [] unless doc['type'] == 'FeatureCollection'
+        return [] unless doc['features'] || doc['features'].present?
+
+        doc['features']
+      end
+
+      def query_url_params(query)
+        lang = query.language || configuration.language
+        params = { apiKey: configuration.api_key, lang: lang, limit: query.options[:limit] }
+
+        if query.reverse_geocode?
+          params.merge!(query_url_params_reverse(query))
+        else
+          params.merge!(query_url_params_coordinates(query))
+        end
+
+        params.merge!(super)
+      end
+
+      def query_url_params_coordinates(query)
+        { text: query.sanitized_text }
+      end
+
+      def query_url_params_reverse(query)
+        {
+          lat: query.coordinates[0],
+          lon: query.coordinates[1]
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/geocoder_ca"
+
+module Geocoder::Lookup
+  class GeocoderCa < Base
+
+    def name
+      "Geocoder.ca"
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://geocoder.ca/?"
+    end
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      if doc['error'].nil?
+        return [doc]
+      elsif doc['error']['code'] == "005"
+        # "Postal Code is not in the proper Format" => no results, just shut up
+      else
+        Geocoder.log(:warn, "Geocoder.ca service error: #{doc['error']['code']} (#{doc['error']['description']}).")
+      end
+      return []
+    end
+
+    def query_url_params(query)
+      params = {
+        :geoit    => "xml",
+        :jsonp    => 1,
+        :callback => "test",
+        :auth     => configuration.api_key
+      }.merge(super)
+      if query.reverse_geocode?
+        lat,lon = query.coordinates
+        params[:latt] = lat
+        params[:longt] = lon
+        params[:corner] = 1
+        params[:reverse] = 1
+      else
+        params[:locate] = query.sanitized_text
+        params[:showpostal] = 1
+      end
+      params
+    end
+
+    def parse_raw_data(raw_data)
+      super raw_data[/^test\((.*)\)\;\s*$/, 1]
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/geocodio"
+
+module Geocoder::Lookup
+  class Geocodio < Base
+
+    def name
+      "Geocodio"
+    end
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      return doc["results"] if doc['error'].nil?
+      
+      if doc['error'] == 'Invalid API key'
+        raise_error(Geocoder::InvalidApiKey) ||
+          Geocoder.log(:warn, "Geocodio service error: invalid API key.")
+      elsif doc['error'].match(/You have reached your daily maximum/)
+        raise_error(Geocoder::OverQueryLimitError, doc['error']) ||
+          Geocoder.log(:warn, "Geocodio service error: #{doc['error']}.")
+      else
+        raise_error(Geocoder::InvalidRequest, doc['error']) ||
+          Geocoder.log(:warn, "Geocodio service error: #{doc['error']}.")
+      end
+      []
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      path = query.reverse_geocode? ? "reverse" : "geocode"
+      "#{protocol}://api.geocod.io/v1.6/#{path}?"
+    end
+
+    def query_url_params(query)
+      {
+        :api_key => configuration.api_key,
+        :q => query.sanitized_text
+      }.merge(super)
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+require 'geocoder/lookups/base'
+require 'geocoder/results/geoip2'
+
+module Geocoder
+  module Lookup
+    class Geoip2 < Base
+      attr_reader :gem_name
+
+      def initialize
+        unless configuration[:file].nil?
+          begin
+            @gem_name = configuration[:lib] || 'maxminddb'
+            require @gem_name
+          rescue LoadError
+            raise "Could not load Maxmind DB dependency. To use the GeoIP2 lookup you must add the #{@gem_name} gem to your Gemfile or have it installed in your system."
+          end
+
+          @mmdb = db_class.new(configuration[:file].to_s)
+        end
+        super
+      end
+
+      def name
+        'GeoIP2'
+      end
+
+      def required_api_key_parts
+        []
+      end
+
+      private
+
+      def db_class
+        gem_name == 'hive_geoip2' ? Hive::GeoIP2 : MaxMindDB
+      end
+
+      def results(query)
+        return [] unless configuration[:file]
+
+        if @mmdb.respond_to?(:local_ip_alias) && !configuration[:local_ip_alias].nil?
+          @mmdb.local_ip_alias = configuration[:local_ip_alias]
+        end
+
+        result = @mmdb.lookup(query.to_s)
+        result.nil? ? [] : [result]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/geoportail_lu"
+
+module Geocoder
+  module Lookup
+    class GeoportailLu < Base
+
+      def name
+        "Geoportail.lu"
+      end
+
+      private # ---------------------------------------------------------------
+
+      def base_query_url(query)
+        if query.reverse_geocode?
+          reverse_geocode_url_base_path
+        else
+          search_url_base_path
+        end
+      end
+
+      def search_url_base_path
+        "#{protocol}://api.geoportail.lu/geocoder/search?"
+      end
+
+      def reverse_geocode_url_base_path
+        "#{protocol}://api.geoportail.lu/geocoder/reverseGeocode?"
+      end
+
+      def query_url_geoportail_lu_params(query)
+        query.reverse_geocode? ? reverse_geocode_params(query) : search_params(query)
+      end
+
+      def search_params(query)
+        {
+            queryString: query.sanitized_text
+        }
+      end
+
+      def reverse_geocode_params(query)
+        lat_lon = query.coordinates
+        {
+            lat: lat_lon.first,
+            lon: lat_lon.last
+        }
+      end
+
+      def query_url_params(query)
+        query_url_geoportail_lu_params(query).merge(super)
+      end
+
+      def results(query)
+        return [] unless doc = fetch_data(query)
+        if doc['success'] == true
+          result = doc['results']
+        else
+          result = []
+          raise_error(Geocoder::Error) ||
+              Geocoder.log(:warn, "Geportail.lu Geocoding API error")
+        end
+        result
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+require 'geocoder/lookups/base'
+require "geocoder/results/google"
+
+module Geocoder::Lookup
+  class Google < Base
+
+    def name
+      "Google"
+    end
+
+    def map_link_url(coordinates)
+      "http://maps.google.com/maps?q=#{coordinates.join(',')}"
+    end
+
+    def supported_protocols
+      # Google requires HTTPS if an API key is used.
+      if configuration.api_key
+        [:https]
+      else
+        [:http, :https]
+      end
+    end
+
+    private # ---------------------------------------------------------------
+
+    def base_query_url(query)
+      "#{protocol}://maps.googleapis.com/maps/api/geocode/json?"
+    end
+
+    def configure_ssl!(client)
+      client.instance_eval {
+        @ssl_context = OpenSSL::SSL::SSLContext.new
+        options = OpenSSL::SSL::OP_NO_SSLv2 | OpenSSL::SSL::OP_NO_SSLv3
+        if OpenSSL::SSL.const_defined?('OP_NO_COMPRESSION')
+          options |= OpenSSL::SSL::OP_NO_COMPRESSION
+        end
+        @ssl_context.set_params({options: options})
+      }
+    end
+
+    def valid_response?(response)
+      json = parse_json(response.body)
+      status = json["status"] if json
+      super(response) and ['OK', 'ZERO_RESULTS'].include?(status)
+    end
+
+    def result_root_attr
+      'results'
+    end
+
+    def results(query)
+      return [] unless doc = fetch_data(query)
+      case doc['status']
+      when "OK" # OK status implies >0 results
+        return doc[result_root_attr]
+      when "OVER_QUERY_LIMIT"
+        raise_error(Geocoder::OverQueryLimitError) ||
+          Geocoder.log(:warn, "#{name} API error: over query limit.")
+      when "REQUEST_DENIED"
+        raise_error(Geocoder::RequestDenied, doc['error_message']) ||
+          Geocoder.log(:warn, "#{name} API error: request denied (#{doc['error_message']}).")
+      when "INVALID_REQUEST"
+        raise_error(Geocoder::InvalidRequest, doc['error_message']) ||
+          Geocoder.log(:warn, "#{name} API error: invalid request (#{doc['error_message']}).")
+      end
+      return []
+    end
+
+    def query_url_google_params(query)
+      params = {
+        :sensor => "false",
+        :language => (query.language || configuration.language)
+      }
+      if query.options[:google_place_id]
+        params[:place_id] = query.sanitized_text
+      else
+        params[(query.reverse_geocode? ? :latlng : :address)] = query.sanitized_text
+      end
+      unless (bounds = query.options[:bounds]).nil?
+        params[:bounds] = bounds.map{ |point| "%f,%f" % point }.join('|')
+      end
+      unless (region = query.options[:region]).nil?
+        params[:region] = region
+      end
+      unless (components = query.options[:components]).nil?
+        params[:components] = components.is_a?(Array) ? components.join("|") : components
+      end
+      unless (result_type = query.options[:result_type]).nil?
+        params[:result_type] = result_type.is_a?(Array) ? result_type.join("|") : result_type
+      end
+      params
+    end
+
+    def query_url_params(query)
+      query_url_google_params(query).merge(
+        :key => configuration.api_key
+      ).merge(super)
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+require "geocoder/lookups/google"
+require "geocoder/results/google_places_details"
+
+module Geocoder
+  module Lookup
+    class GooglePlacesDetails < Google
+      def name
+        "Google Places Details"
+      end
+
+      def required_api_key_parts
+        ["key"]
+      end
+
+      def supported_protocols
+        [:https]
+      end
+
+      private
+
+      def base_query_url(query)
+        "#{protocol}://maps.googleapis.com/maps/api/place/details/json?"
+      end
+
+      def result_root_attr
+        'result'
+      end
+
+      def results(query)
+        result = super(query)
+        return [result] unless result.is_a? Array
+
+        result
+      end
+
+      def fields(query)
+        if query.options.has_key?(:fields)
+          return format_fields(query.options[:fields])
+        end
+
+        if configuration.has_key?(:fields)
+          return format_fields(configuration[:fields])
+        end
+
+        nil  # use Google Places defaults
+      end
+
+      def format_fields(*fields)
+        flattened = fields.flatten.compact
+        return if flattened.empty?
+
+        flattened.join(',')
+      end
+
+      def query_url_google_params(query)
+        {
+          placeid: query.text,
+          fields: fields(query),
+          language: query.language || configuration.language
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+require "geocoder/lookups/google"
+require "geocoder/results/google_places_search"
+
+module Geocoder
+  module Lookup
+    class GooglePlacesSearch < Google
+      def name
+        "Google Places Search"
+      end
+
+      def required_api_key_parts
+        ["key"]
+      end
+
+      def supported_protocols
+        [:https]
+      end
+
+      private
+
+      def result_root_attr
+        'candidates'
+      end
+
+      def base_query_url(query)
+        "#{protocol}://maps.googleapis.com/maps/api/place/findplacefromtext/json?"
+      end
+
+      def query_url_google_params(query)
+        {
+          input: query.text,
+          inputtype: 'textquery',
+          fields: fields(query),
+          locationbias: locationbias(query),
+          language: query.language || configuration.language
+        }
+      end
+
+      def fields(query)
+        if query.options.has_key?(:fields)
+          return format_fields(query.options[:fields])
+        end
+
+        if configuration.has_key?(:fields)
+          return format_fields(configuration[:fields])
+        end
+
+        default_fields
+      end
+
+      def default_fields
+        basic = %w[business_status formatted_address geometry icon name 
+          photos place_id plus_code types]
+        contact = %w[opening_hours]
+        atmosphere = %W[price_level rating user_ratings_total]
+        format_fields(basic, contact, atmosphere)
+      end
+
+      def format_fields(*fields)
+        flattened = fields.flatten.compact
+        return if flattened.empty?
+
+        flattened.join(',')
+      end
+
+      def locationbias(query)
+        if query.options.has_key?(:locationbias)
+          query.options[:locationbias]
+        else
+          configuration[:locationbias]
+        end
+      end
+    end
+  end
+end