ultra-fast-mod 0.0.1

data/geocoder-1.8.6/lib/geocoder/query.rb

@@ -0,0 +1,125 @@
+module Geocoder
+  class Query
+    attr_accessor :text, :options
+
+    def initialize(text, options = {})
+      self.text = text
+      self.options = options
+    end
+
+    def execute
+      lookup.search(text, options)
+    end
+
+    def to_s
+      text
+    end
+
+    def sanitized_text
+      if coordinates?
+        if text.is_a?(Array)
+          text.join(',')
+        else
+          text.split(/\s*,\s*/).join(',')
+        end
+      else
+        text.to_s.strip
+      end
+    end
+
+    ##
+    # Get a Lookup object (which communicates with the remote geocoding API)
+    # appropriate to the Query text.
+    #
+    def lookup
+      if !options[:street_address] and (options[:ip_address] or ip_address?)
+        name = options[:ip_lookup] || Configuration.ip_lookup || Geocoder::Lookup.ip_services.first
+      else
+        name = options[:lookup] || Configuration.lookup || Geocoder::Lookup.street_services.first
+      end
+      Lookup.get(name)
+    end
+
+    def url
+      lookup.query_url(self)
+    end
+
+    ##
+    # Is the Query blank? (ie, should we not bother searching?)
+    # A query is considered blank if its text is nil or empty string AND
+    # no URL parameters are specified.
+    #
+    def blank?
+      !params_given? and (
+        (text.is_a?(Array) and text.compact.size < 2) or
+        text.to_s.match(/\A\s*\z/)
+      )
+    end
+
+    ##
+    # Does the Query text look like an IP address?
+    #
+    # Does not check for actual validity, just the appearance of four
+    # dot-delimited numbers.
+    #
+    def ip_address?
+      IpAddress.new(text).valid? rescue false
+    end
+
+    ##
+    # Is the Query text a loopback or private IP address?
+    #
+    def internal_ip_address?
+      ip_address? && IpAddress.new(text).internal?
+    end
+
+    ##
+    # Is the Query text a loopback IP address?
+    #
+    def loopback_ip_address?
+      ip_address? && IpAddress.new(text).loopback?
+    end
+
+    ##
+    # Is the Query text a private IP address?
+    #
+    def private_ip_address?
+      ip_address? && IpAddress.new(text).private?
+    end
+
+    ##
+    # Does the given string look like latitude/longitude coordinates?
+    #
+    def coordinates?
+      text.is_a?(Array) or (
+        text.is_a?(String) and
+        !!text.to_s.match(/\A-?[0-9\.]+, *-?[0-9\.]+\z/)
+      )
+    end
+
+    ##
+    # Return the latitude/longitude coordinates specified in the query,
+    # or nil if none.
+    #
+    def coordinates
+      sanitized_text.split(',') if coordinates?
+    end
+
+    ##
+    # Should reverse geocoding be performed for this query?
+    #
+    def reverse_geocode?
+      coordinates?
+    end
+
+    def language
+      options[:language]
+    end
+
+    private # ----------------------------------------------------------------
+
+    def params_given?
+      !!(options[:params].is_a?(Hash) and options[:params].keys.size > 0)
+    end
+  end
+end

data/geocoder-1.8.6/lib/geocoder/railtie.rb

@@ -0,0 +1,26 @@
+require 'geocoder/models/active_record'
+
+module Geocoder
+  if defined? Rails::Railtie
+    require 'rails'
+    class Railtie < Rails::Railtie
+      initializer 'geocoder.insert_into_active_record', before: :load_config_initializers do
+        ActiveSupport.on_load :active_record do
+          Geocoder::Railtie.insert
+        end
+      end
+      rake_tasks do
+        load "tasks/geocoder.rake"
+        load "tasks/maxmind.rake"
+      end
+    end
+  end
+
+  class Railtie
+    def self.insert
+      if defined?(::ActiveRecord)
+        ::ActiveRecord::Base.extend(Model::ActiveRecord)
+      end
+    end
+  end
+end

data/geocoder-1.8.6/lib/geocoder/request.rb

@@ -0,0 +1,114 @@
+require 'ipaddr'
+
+module Geocoder
+  module Request
+
+    # The location() method is vulnerable to trivial IP spoofing.
+    #   Don't use it in authorization/authentication code, or any
+    #   other security-sensitive application.  Use safe_location
+    #   instead.
+    def location
+      @location ||= Geocoder.search(geocoder_spoofable_ip, ip_address: true).first
+    end
+
+    # This safe_location() protects you from trivial IP spoofing.
+    #   For requests that go through a proxy that you haven't
+    #   whitelisted as trusted in your Rack config, you will get the
+    #   location for the IP of the last untrusted proxy in the chain,
+    #   not the original client IP.  You WILL NOT get the location
+    #   corresponding to the original client IP for any request sent
+    #   through a non-whitelisted proxy.
+    def safe_location
+      @safe_location ||= Geocoder.search(ip, ip_address: true).first
+    end
+
+    # There's a whole zoo of nonstandard headers added by various
+    #   proxy softwares to indicate original client IP.
+    # ANY of these can be trivially spoofed!
+    #   (except REMOTE_ADDR, which should by set by your server,
+    #    and is included at the end as a fallback.
+    # Order does matter: we're following the convention established in
+    #   ActionDispatch::RemoteIp::GetIp::calculate_ip()
+    #   https://github.com/rails/rails/blob/master/actionpack/lib/action_dispatch/middleware/remote_ip.rb
+    #   where the forwarded_for headers, possibly containing lists,
+    #   are arbitrarily preferred over headers expected to contain a
+    #   single address.
+    GEOCODER_CANDIDATE_HEADERS = ['HTTP_X_FORWARDED_FOR',
+                                  'HTTP_X_FORWARDED',
+                                  'HTTP_FORWARDED_FOR',
+                                  'HTTP_FORWARDED',
+                                  'HTTP_X_CLIENT_IP',
+                                  'HTTP_CLIENT_IP',
+                                  'HTTP_X_REAL_IP',
+                                  'HTTP_X_CLUSTER_CLIENT_IP',
+                                  'REMOTE_ADDR']
+
+    def geocoder_spoofable_ip
+
+      # We could use a more sophisticated IP-guessing algorithm here,
+      # in which we'd try to resolve the use of different headers by
+      # different proxies.  The idea is that by comparing IPs repeated
+      # in different headers, you can sometimes decide which header
+      # was used by a proxy further along in the chain, and thus
+      # prefer the headers used earlier.  However, the gains might not
+      # be worth the performance tradeoff, since this method is likely
+      # to be called on every request in a lot of applications.
+      GEOCODER_CANDIDATE_HEADERS.each do |header|
+        if @env.has_key? header
+          addrs = geocoder_split_ip_addresses(@env[header])
+          addrs = geocoder_remove_port_from_addresses(addrs)
+          addrs = geocoder_reject_non_ipv4_addresses(addrs)
+          addrs = geocoder_reject_trusted_ip_addresses(addrs)
+          return addrs.first if addrs.any?
+        end
+      end
+
+      @env['REMOTE_ADDR']
+    end
+
+    private
+
+    def geocoder_split_ip_addresses(ip_addresses)
+      ip_addresses ? ip_addresses.strip.split(/[,\s]+/) : []
+    end
+
+    # use Rack's trusted_proxy?() method to filter out IPs that have
+    #   been configured as trusted; includes private ranges by
+    #   default.  (we don't want every lookup to return the location
+    #   of our own proxy/load balancer)
+    def geocoder_reject_trusted_ip_addresses(ip_addresses)
+      ip_addresses.reject { |ip| trusted_proxy?(ip) }
+    end
+
+    def geocoder_remove_port_from_addresses(ip_addresses)
+      ip_addresses.map do |ip|
+        # IPv4
+        if ip.count('.') > 0
+          ip.split(':').first
+        # IPv6 bracket notation
+        elsif match = ip.match(/\[(\S+)\]/)
+          match.captures.first
+        # IPv6 bare notation
+        else
+          ip
+        end
+      end
+    end
+
+    def geocoder_reject_non_ipv4_addresses(ip_addresses)
+      ips = []
+      for ip in ip_addresses
+        begin
+          valid_ip = IPAddr.new(ip)
+        rescue
+          valid_ip = false
+        end
+        ips << valid_ip.to_s if valid_ip
+      end
+      return ips.any? ? ips : ip_addresses
+    end
+  end
+end
+
+ActionDispatch::Request.__send__(:include, Geocoder::Request) if defined?(ActionDispatch::Request)
+Rack::Request.__send__(:include, Geocoder::Request) if defined?(Rack::Request)

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

@@ -0,0 +1,146 @@
+require 'geocoder/results/base'
+
+module Geocoder
+  module Result
+    class AbstractApi < Base
+
+      ##
+      # Geolocation
+
+      def state
+        @data['region']
+      end
+
+      def state_code
+        @data['region_iso_code']
+      end
+
+      def city
+        @data["city"]
+      end
+
+      def city_geoname_id
+        @data["city_geoname_id"]
+      end
+
+      def region_geoname_id
+        @data["region_geoname_id"]
+      end
+
+      def postal_code
+        @data["postal_code"]
+      end
+
+      def country
+        @data["country"]
+      end
+
+      def country_code
+        @data["country_code"]
+      end
+
+      def country_geoname_id
+        @data["country_geoname_id"]
+      end
+
+      def country_is_eu
+        @data["country_is_eu"]
+      end
+
+      def continent
+        @data["continent"]
+      end
+
+      def continent_code
+        @data["continent_code"]
+      end
+
+      def continent_geoname_id
+        @data["continent_geoname_id"]
+      end
+
+      ##
+      # Security
+
+      def is_vpn?
+        @data.dig "security", "is_vpn"
+      end
+
+      ##
+      # Timezone
+
+      def timezone_name
+        @data.dig "timezone", "name"
+      end
+
+      def timezone_abbreviation
+        @data.dig "timezone", "abbreviation"
+      end
+
+      def timezone_gmt_offset
+        @data.dig "timezone", "gmt_offset"
+      end
+
+      def timezone_current_time
+        @data.dig "timezone", "current_time"
+      end
+
+      def timezone_is_dst
+        @data.dig "timezone", "is_dst"
+      end
+
+      ##
+      # Flag
+
+      def flag_emoji
+        @data.dig "flag", "emoji"
+      end
+
+      def flag_unicode
+        @data.dig "flag", "unicode"
+      end
+
+      def flag_png
+        @data.dig "flag", "png"
+      end
+
+      def flag_svg
+        @data.dig "flag", "svg"
+      end
+
+      ##
+      # Currency
+
+      def currency_currency_name
+        @data.dig "currency", "currency_name"
+      end
+
+      def currency_currency_code
+        @data.dig "currency", "currency_code"
+      end
+
+      ##
+      # Connection
+
+      def connection_autonomous_system_number
+        @data.dig "connection", "autonomous_system_number"
+      end
+
+      def connection_autonomous_system_organization
+        @data.dig "connection", "autonomous_system_organization"
+      end
+
+      def connection_connection_type
+        @data.dig "connection", "connection_type"
+      end
+
+      def connection_isp_name
+        @data.dig "connection", "isp_name"
+      end
+
+      def connection_organization_name
+        @data.dig "connection", "organization_name"
+      end
+    end
+  end
+end

data/geocoder-1.8.6/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/geocoder-1.8.6/lib/geocoder/results/amazon_location_service.rb

@@ -0,0 +1,62 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class AmazonLocationService < Base
+    def initialize(result)
+      @place = result.place
+      super
+    end
+
+    def coordinates
+      [@place.geometry.point[1], @place.geometry.point[0]]
+    end
+
+    def address
+      @place.label
+    end
+
+    def neighborhood
+      @place.neighborhood
+    end
+
+    def route
+      @place.street
+    end
+
+    def city
+      @place.municipality || @place.sub_region
+    end
+
+    def state
+      @place.region
+    end
+
+    def state_code
+      @place.region
+    end
+
+    def province
+      @place.region
+    end
+
+    def province_code
+      @place.region
+    end
+
+    def postal_code
+      @place.postal_code
+    end
+
+    def country
+      @place.country
+    end
+
+    def country_code
+      @place.country
+    end
+
+    def place_id
+      data.place_id if data.respond_to?(:place_id)
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Azure < Base
+    def address
+      @data['address']['freeformAddress']
+    end
+
+    def building_number
+      @data['address']['buildingNumber']
+    end
+
+    def city
+      @data['address']['municipality']
+    end
+
+    def coordinates
+      if @data['position'].is_a?(String) # reverse geocoding result
+        @data['position'].split(',').map(&:to_f)
+      elsif @data['position'].is_a?(Hash) # forward geocoding result
+        [@data['position']['lat'], @data['position']['lon']]
+      end
+    end
+
+    def country
+      @data['address']['country']
+    end
+
+    def country_code
+      @data['address']['countryCode']
+    end
+
+    def district
+      @data['address']['municipalitySubdivision']
+    end
+
+    def postal_code
+      @data['address']['postalCode']
+    end
+
+    def province
+      @data['address']['countrySubdivision']
+    end
+
+    def state
+      @data['address']['countrySubdivision']
+    end
+
+    def state_code
+      @data['address']['countrySubdivisionCode']
+    end
+
+    def street_name
+      @data['address']['streetName']
+    end
+
+    def street_number
+      @data['address']['streetNumber']
+    end
+
+    def viewport
+      @data['viewport'] || {}
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+require 'geocoder/results/base'
+
+module Geocoder::Result
+  class Baidu < Base
+
+    def coordinates
+      ['lat', 'lng'].map{ |i| @data['location'][i] }
+    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