ultra-fast-mod 0.0.1

data/geocoder-1.8.6/bin/console

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'geocoder'
+
+if File.exist?("api_keys.yml")
+  require 'yaml'
+  @api_keys = YAML.load(File.read("api_keys.yml"), symbolize_names: true)
+  Geocoder.configure(@api_keys)
+end
+
+require 'irb'
+IRB.start

data/geocoder-1.8.6/bin/geocode

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'geocoder/cli'
+
+Geocoder::Cli.run ARGV

data/geocoder-1.8.6/examples/app_defined_lookup_services.rb

@@ -0,0 +1,22 @@
+# To extend the Geocoder with additional lookups that come from the application,
+# not shipped with the gem, define a "child" lookup in your application, based on existing one.
+# This is required because the Geocoder::Configuration is a Singleton and stores one api key per lookup.
+
+# in app/libs/geocoder/lookup/my_preciousss.rb
+module Geocoder::Lookup
+  class MyPreciousss < Google
+  end
+end
+
+# Update Geocoder's street_services on initialize:
+# config/initializers/geocoder.rb
+Geocoder::Lookup.street_services << :my_preciousss
+
+# Override the configuration when necessary (e.g. provide separate Google API key for the account):
+Geocoder.configure(my_preciousss: { api_key: 'abcdef' })
+
+# Lastly, search using your custom lookup service/api keys
+Geocoder.search("Paris", lookup: :my_preciousss)
+
+# This is useful when we have groups of users in the application who use Google paid services
+# and we want to properly separate them and allow using individual API KEYS or timeouts.

data/geocoder-1.8.6/examples/cache_bypass.rb

@@ -0,0 +1,48 @@
+# This class allows you to configure how Geocoder should treat errors that occur when
+# the cache is not available.
+# Configure it like this
+# config/initializers/geocoder.rb
+# Geocoder.configure(
+#  :cache => Geocoder::CacheBypass.new(Redis.new)
+# )
+#
+# Depending on the value of @bypass this will either
+# raise the exception (true) or swallow it and pretend the cache did not return a hit (false)
+#
+class Geocoder::CacheBypass
+  def initialize(target, bypass = true)
+    @target = target
+    @bypass = bypass
+  end
+
+
+  def [](key)
+    with_bypass { @target[key] }
+  end
+
+  def []=(key, value)
+    with_bypass(value) { @target[key] = value }
+  end
+
+  def keys
+    with_bypass([]) { @target.keys }
+  end
+
+  def del(key)
+    with_bypass { @target.del(key) }
+  end
+
+  private
+
+  def with_bypass(return_value_if_exception = nil, &block)
+    begin
+      yield
+    rescue
+      if @bypass
+        return_value_if_exception
+      else
+        raise # reraise original exception
+      end
+    end
+  end
+end

data/geocoder-1.8.6/examples/reverse_geocode_job.rb

@@ -0,0 +1,40 @@
+# This class implements an ActiveJob job for performing reverse-geocoding
+# asynchronously. Example usage:
+
+# if @location.save && @location.address.blank?
+#   ReverseGeocodeJob.perform_later(@location)
+# end
+
+# Be sure to configure the queue adapter in config/application.rb:
+# config.active_job.queue_adapter = :sidekiq
+
+# You can read the Rails docs for more information on configuring ActiveJob:
+# http://edgeguides.rubyonrails.org/active_job_basics.html
+
+class ReverseGeocodeJob < ActiveJob::Base
+  queue_as :high
+
+  def perform(location)
+    address = address(location)
+
+    if address.present?
+      location.update(address: address)
+    end
+  end
+
+  private
+
+  def address(location)
+    Geocoder.address(location.coordinates)
+  rescue => exception
+    MonitoringService.notify(exception, location: { id: location.id })
+
+    if retryable?(exception)
+      raise exception
+    end
+  end
+
+  def retryable?(exception)
+    exception.is_a?(Timeout::Error) || exception.is_a?(SocketError)
+  end
+end

data/geocoder-1.8.6/lib/easting_northing.rb

@@ -0,0 +1,171 @@
+module Geocoder
+  class EastingNorthing
+    attr_reader :easting, :northing, :lat_lng
+
+    def initialize(opts)
+      @easting = opts[:easting]
+      @northing = opts[:northing]
+
+      @lat_lng = to_WGS84(to_osgb_36)
+    end
+
+    private
+
+    def to_osgb_36
+      osgb_fo  = 0.9996012717
+      northing0 = -100_000.0
+      easting0 = 400_000.0
+      phi0 = deg_to_rad(49.0)
+      lambda0 = deg_to_rad(-2.0)
+      a = 6_377_563.396
+      b = 6_356_256.909
+      eSquared = ((a * a) - (b * b)) / (a * a)
+      phi = 0.0
+      lambda = 0.0
+      n = (a - b) / (a + b)
+      m = 0.0
+      phiPrime = ((northing - northing0) / (a * osgb_fo)) + phi0
+
+      while (northing - northing0 - m) >= 0.001
+        m =
+          (b * osgb_fo)\
+            * (((1 + n + ((5.0 / 4.0) * n * n) + ((5.0 / 4.0) * n * n * n))\
+              * (phiPrime - phi0))\
+              - (((3 * n) + (3 * n * n) + ((21.0 / 8.0) * n * n * n))\
+                * Math.sin(phiPrime - phi0)\
+                * Math.cos(phiPrime + phi0))\
+              + ((((15.0 / 8.0) * n * n) + ((15.0 / 8.0) * n * n * n))\
+                * Math.sin(2.0 * (phiPrime - phi0))\
+                * Math.cos(2.0 * (phiPrime + phi0)))\
+              - (((35.0 / 24.0) * n * n * n)\
+                * Math.sin(3.0 * (phiPrime - phi0))\
+                * Math.cos(3.0 * (phiPrime + phi0))))
+
+        phiPrime += (northing - northing0 - m) / (a * osgb_fo)
+      end
+
+      v = a * osgb_fo * ((1.0 - eSquared * sin_pow_2(phiPrime))**-0.5)
+      rho =
+        a\
+          * osgb_fo\
+          * (1.0 - eSquared)\
+          * ((1.0 - eSquared * sin_pow_2(phiPrime))**-1.5)
+      etaSquared = (v / rho) - 1.0
+      vii = Math.tan(phiPrime) / (2 * rho * v)
+      viii =
+        (Math.tan(phiPrime) / (24.0 * rho * (v**3.0)))\
+          * (5.0\
+            + (3.0 * tan_pow_2(phiPrime))\
+            + etaSquared\
+            - (9.0 * tan_pow_2(phiPrime) * etaSquared))
+      ix =
+        (Math.tan(phiPrime) / (720.0 * rho * (v**5.0)))\
+          * (61.0\
+            + (90.0 * tan_pow_2(phiPrime))\
+            + (45.0 * tan_pow_2(phiPrime) * tan_pow_2(phiPrime)))
+      x = sec(phiPrime) / v
+      xi =
+        (sec(phiPrime) / (6.0 * v * v * v))\
+          * ((v / rho) + (2 * tan_pow_2(phiPrime)))
+      xiii =
+        (sec(phiPrime) / (120.0 * (v**5.0)))\
+          * (5.0\
+            + (28.0 * tan_pow_2(phiPrime))\
+            + (24.0 * tan_pow_2(phiPrime) * tan_pow_2(phiPrime)))
+      xiia =
+        (sec(phiPrime) / (5040.0 * (v**7.0)))\
+          * (61.0\
+            + (662.0 * tan_pow_2(phiPrime))\
+            + (1320.0 * tan_pow_2(phiPrime) * tan_pow_2(phiPrime))\
+            + (720.0\
+              * tan_pow_2(phiPrime)\
+              * tan_pow_2(phiPrime)\
+              * tan_pow_2(phiPrime)))
+      phi =
+        phiPrime\
+          - (vii * ((easting - easting0)**2.0))\
+          + (viii * ((easting - easting0)**4.0))\
+          - (ix * ((easting - easting0)**6.0))
+      lambda =
+        lambda0\
+          + (x * (easting - easting0))\
+          - (xi * ((easting - easting0)**3.0))\
+          + (xiii * ((easting - easting0)**5.0))\
+          - (xiia * ((easting - easting0)**7.0))
+
+      [rad_to_deg(phi), rad_to_deg(lambda)]
+    end
+
+    def to_WGS84(latlng)
+      latitude = latlng[0]
+      longitude = latlng[1]
+
+      a = 6_377_563.396
+      b = 6_356_256.909
+      eSquared = ((a * a) - (b * b)) / (a * a)
+
+      phi = deg_to_rad(latitude)
+      lambda = deg_to_rad(longitude)
+      v = a / Math.sqrt(1 - eSquared * sin_pow_2(phi))
+      h = 0
+      x = (v + h) * Math.cos(phi) * Math.cos(lambda)
+      y = (v + h) * Math.cos(phi) * Math.sin(lambda)
+      z = ((1 - eSquared) * v + h) * Math.sin(phi)
+
+      tx = 446.448
+      ty = -124.157
+      tz = 542.060
+
+      s  = -0.0000204894
+      rx = deg_to_rad(0.00004172222)
+      ry = deg_to_rad(0.00006861111)
+      rz = deg_to_rad(0.00023391666)
+
+      xB = tx + (x * (1 + s)) + (-rx * y) + (ry * z)
+      yB = ty + (rz * x) + (y * (1 + s)) + (-rx * z)
+      zB = tz + (-ry * x) + (rx * y) + (z * (1 + s))
+
+      a = 6_378_137.000
+      b = 6_356_752.3141
+      eSquared = ((a * a) - (b * b)) / (a * a)
+
+      lambdaB = rad_to_deg(Math.atan(yB / xB))
+      p = Math.sqrt((xB * xB) + (yB * yB))
+      phiN = Math.atan(zB / (p * (1 - eSquared)))
+
+      (1..10).each do |_i|
+        v = a / Math.sqrt(1 - eSquared * sin_pow_2(phiN))
+        phiN1 = Math.atan((zB + (eSquared * v * Math.sin(phiN))) / p)
+        phiN = phiN1
+      end
+
+      phiB = rad_to_deg(phiN)
+
+      [phiB, lambdaB]
+    end
+
+    def deg_to_rad(degrees)
+      degrees / 180.0 * Math::PI
+    end
+
+    def rad_to_deg(r)
+      (r / Math::PI) * 180
+    end
+
+    def sin_pow_2(x)
+      Math.sin(x) * Math.sin(x)
+    end
+
+    def cos_pow_2(x)
+      Math.cos(x) * Math.cos(x)
+    end
+
+    def tan_pow_2(x)
+      Math.tan(x) * Math.tan(x)
+    end
+
+    def sec(x)
+      1.0 / Math.cos(x)
+    end
+  end
+end

data/geocoder-1.8.6/lib/generators/geocoder/config/config_generator.rb

@@ -0,0 +1,14 @@
+require 'rails/generators'
+
+module Geocoder
+  class ConfigGenerator < Rails::Generators::Base
+    source_root File.expand_path("../templates", __FILE__)
+
+    desc "This generator creates an initializer file at config/initializers, " +
+         "with the default configuration options for Geocoder."
+    def add_initializer
+      template "initializer.rb", "config/initializers/geocoder.rb"
+    end
+  end
+end
+

data/geocoder-1.8.6/lib/generators/geocoder/config/templates/initializer.rb

@@ -0,0 +1,27 @@
+Geocoder.configure(
+  # Geocoding options
+  # timeout: 3,                 # geocoding service timeout (secs)
+  # lookup: :nominatim,         # name of geocoding service (symbol)
+  # ip_lookup: :ipinfo_io,      # name of IP address geocoding service (symbol)
+  # language: :en,              # ISO-639 language code
+  # use_https: false,           # use HTTPS for lookup requests? (if supported)
+  # http_proxy: nil,            # HTTP proxy server (user:pass@host:port)
+  # https_proxy: nil,           # HTTPS proxy server (user:pass@host:port)
+  # api_key: nil,               # API key for geocoding service
+  # cache: nil,                 # cache object (must respond to #[], #[]=, and #del)
+
+  # Exceptions that should not be rescued by default
+  # (if you want to implement custom error handling);
+  # supports SocketError and Timeout::Error
+  # always_raise: [],
+
+  # Calculation options
+  # units: :mi,                 # :km for kilometers or :mi for miles
+  # distances: :linear          # :spherical or :linear
+
+  # Cache configuration
+  # cache_options: {
+  #   expiration: 2.days,
+  #   prefix: 'geocoder:'
+  # }
+)

data/geocoder-1.8.6/lib/generators/geocoder/maxmind/geolite_city_generator.rb

@@ -0,0 +1,30 @@
+require 'rails/generators/migration'
+require 'generators/geocoder/migration_version'
+
+module Geocoder
+  module Generators
+    module Maxmind
+      class GeoliteCityGenerator < Rails::Generators::Base
+        include Rails::Generators::Migration
+        include Generators::MigrationVersion
+
+        source_root File.expand_path('../templates', __FILE__)
+
+        def copy_migration_files
+          migration_template "migration/geolite_city.rb", "db/migrate/geocoder_maxmind_geolite_city.rb"
+        end
+
+        # Define the next_migration_number method (necessary for the
+        # migration_template method to work)
+        def self.next_migration_number(dirname)
+          if ActiveRecord::Base.timestamped_migrations
+            sleep 1 # make sure each time we get a different timestamp
+            Time.new.utc.strftime("%Y%m%d%H%M%S")
+          else
+            "%.3d" % (current_migration_number(dirname) + 1)
+          end
+        end
+      end
+    end
+  end
+end

data/geocoder-1.8.6/lib/generators/geocoder/maxmind/geolite_country_generator.rb

@@ -0,0 +1,30 @@
+require 'rails/generators/migration'
+require 'generators/geocoder/migration_version'
+
+module Geocoder
+  module Generators
+    module Maxmind
+      class GeoliteCountryGenerator < Rails::Generators::Base
+        include Rails::Generators::Migration
+        include Generators::MigrationVersion
+
+        source_root File.expand_path('../templates', __FILE__)
+
+        def copy_migration_files
+          migration_template "migration/geolite_country.rb", "db/migrate/geocoder_maxmind_geolite_country.rb"
+        end
+
+        # Define the next_migration_number method (necessary for the
+        # migration_template method to work)
+        def self.next_migration_number(dirname)
+          if ActiveRecord::Base.timestamped_migrations
+            sleep 1 # make sure each time we get a different timestamp
+            Time.new.utc.strftime("%Y%m%d%H%M%S")
+          else
+            "%.3d" % (current_migration_number(dirname) + 1)
+          end
+        end
+      end
+    end
+  end
+end

data/geocoder-1.8.6/lib/generators/geocoder/maxmind/templates/migration/geolite_city.rb

@@ -0,0 +1,30 @@
+class GeocoderMaxmindGeoliteCity < ActiveRecord::Migration<%= migration_version %>
+  def self.up
+    create_table :maxmind_geolite_city_blocks, id: false do |t|
+      t.column :start_ip_num, :bigint, null: false
+      t.column :end_ip_num, :bigint, null: false
+      t.column :loc_id, :bigint, null: false
+    end
+    add_index :maxmind_geolite_city_blocks, :loc_id
+    add_index :maxmind_geolite_city_blocks, :start_ip_num, unique: true
+    add_index :maxmind_geolite_city_blocks, [:end_ip_num, :start_ip_num], unique: true, name: 'index_maxmind_geolite_city_blocks_on_end_ip_num_range'
+
+    create_table :maxmind_geolite_city_location, id: false do |t|
+      t.column :loc_id, :bigint, null: false
+      t.string :country, null: false
+      t.string :region, null: false
+      t.string :city
+      t.string :postal_code, null: false
+      t.float :latitude
+      t.float :longitude
+      t.integer :metro_code
+      t.integer :area_code
+    end
+    add_index :maxmind_geolite_city_location, :loc_id, unique: true
+  end
+
+  def self.down
+    drop_table :maxmind_geolite_city_location
+    drop_table :maxmind_geolite_city_blocks
+  end
+end

data/geocoder-1.8.6/lib/generators/geocoder/maxmind/templates/migration/geolite_country.rb

@@ -0,0 +1,17 @@
+class GeocoderMaxmindGeoliteCountry < ActiveRecord::Migration<%= migration_version %>
+  def self.up
+    create_table :maxmind_geolite_country, id: false do |t|
+      t.column :start_ip, :string
+      t.column :end_ip, :string
+      t.column :start_ip_num, :bigint, null: false
+      t.column :end_ip_num, :bigint, null: false
+      t.column :country_code, :string, null: false
+      t.column :country, :string, null: false
+    end
+    add_index :maxmind_geolite_country, :start_ip_num, unique: true
+  end
+
+  def self.down
+    drop_table :maxmind_geolite_country
+  end
+end

data/geocoder-1.8.6/lib/generators/geocoder/migration_version.rb

@@ -0,0 +1,15 @@
+module Geocoder
+  module Generators
+    module MigrationVersion
+      def rails_5?
+        Rails::VERSION::MAJOR == 5
+      end
+
+      def migration_version
+        if rails_5?
+          "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+Dir["#{__dir__}/cache_stores/*.rb"].each {|file| require file }
+
+module Geocoder
+  class Cache
+
+    def initialize(store, config)
+      @class = (Geocoder::CacheStore.const_get("#{store.class}", false) rescue Geocoder::CacheStore::Generic)
+      @store_service = @class.new(store, config)
+    end
+
+    ##
+    # Read from the Cache.
+    #
+    def [](url)
+      interpret store_service.read(url)
+    rescue => e
+      Geocoder.log(:warn, "Geocoder cache read error: #{e}")
+    end
+
+    ##
+    # Write to the Cache.
+    #
+    def []=(url, value)
+      store_service.write(url, value)
+    rescue => e
+      Geocoder.log(:warn, "Geocoder cache write error: #{e}")
+    end
+
+    ##
+    # Delete cache entry for given URL,
+    # or pass <tt>:all</tt> to clear all URLs.
+    #
+    def expire(url)
+      if url == :all
+        if store_service.respond_to?(:keys)
+          urls.each{ |u| expire(u) }
+        else
+          raise(NoMethodError, "The Geocoder cache store must implement `#keys` for `expire(:all)` to work")
+        end
+      else
+        expire_single_url(url)
+      end
+    end
+
+
+    private # ----------------------------------------------------------------
+
+    def store_service; @store_service; end
+
+    ##
+    # Array of keys with the currently configured prefix
+    # that have non-nil values.
+    #
+    def keys
+      store_service.keys
+    end
+
+    ##
+    # Array of cached URLs.
+    #
+    def urls
+      store_service.urls
+    end
+
+    ##
+    # Clean up value before returning. Namely, convert empty string to nil.
+    # (Some key/value stores return empty string instead of nil.)
+    #
+    def interpret(value)
+      value == "" ? nil : value
+    end
+
+    def expire_single_url(url)
+      store_service.remove(url)
+    end
+  end
+end

data/geocoder-1.8.6/lib/geocoder/cache_stores/base.rb

@@ -0,0 +1,40 @@
+module Geocoder::CacheStore
+  class Base
+    def initialize(store, options)
+      @store = store
+      @config = options
+      @prefix = config[:prefix]
+    end
+
+    ##
+    # Array of keys with the currently configured prefix
+    # that have non-nil values.
+    def keys
+      store.keys.select { |k| k.match(/^#{prefix}/) and self[k] }
+    end
+
+    ##
+    # Array of cached URLs.
+    #
+    def urls
+      keys
+    end
+
+    protected # ----------------------------------------------------------------
+
+    def prefix; @prefix; end
+    def store; @store; end
+    def config; @config; end
+
+    ##
+    # Cache key for a given URL.
+    #
+    def key_for(url)
+      if url.match(/^#{prefix}/)
+        url
+      else
+        [prefix, url].join
+      end
+    end
+  end
+end

data/geocoder-1.8.6/lib/geocoder/cache_stores/generic.rb

@@ -0,0 +1,35 @@
+require 'geocoder/cache_stores/base'
+
+module Geocoder::CacheStore
+  class Generic < Base
+    def write(url, value)
+      case
+      when store.respond_to?(:[]=)
+        store[key_for(url)] = value
+      when store.respond_to?(:set)
+        store.set key_for(url), value
+      when store.respond_to?(:write)
+        store.write key_for(url), value
+      end
+    end
+
+    def read(url)
+      case
+      when store.respond_to?(:[])
+        store[key_for(url)]
+      when store.respond_to?(:get)
+        store.get key_for(url)
+      when store.respond_to?(:read)
+        store.read key_for(url)
+      end
+    end
+
+    def keys
+      store.keys
+    end
+
+    def remove(key)
+      store.delete(key)
+    end
+  end
+end

data/geocoder-1.8.6/lib/geocoder/cache_stores/redis.rb

@@ -0,0 +1,34 @@
+require 'geocoder/cache_stores/base'
+
+module Geocoder::CacheStore
+  class Redis < Base
+    def initialize(store, options)
+      super
+      @expiration = options[:expiration]
+    end
+
+    def write(url, value, expire = @expiration)
+      if expire.present?
+        store.set key_for(url), value, ex: expire
+      else
+        store.set key_for(url), value
+      end
+    end
+
+    def read(url)
+      store.get key_for(url)
+    end
+
+    def keys
+      store.keys("#{prefix}*")
+    end
+
+    def remove(key)
+      store.del(key)
+    end
+
+    private # ----------------------------------------------------------------
+
+    def expire; @expiration; end
+  end
+end