geocoder-kb 1.2.6

data/Rakefile

@@ -0,0 +1,25 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/unit/**/*_test.rb'
+  test.verbose = true
+end
+
+Rake::TestTask.new(:integration) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/integration/*_test.rb'
+  test.verbose = true
+end
+
+task :default => [:test]
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "Geocoder #{Geocoder::VERSION}"
+  rdoc.rdoc_files.include('*.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/bin/geocode

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

data/examples/autoexpire_cache_dalli.rb

@@ -0,0 +1,62 @@
+# This class implements a cache with simple delegation to the the Dalli Memcached client
+# https://github.com/mperham/dalli
+#
+# A TTL is set on initialization
+
+class AutoexpireCacheDalli
+  def initialize(store, ttl = 86400)
+    @store = store
+    @keys = 'GeocoderDalliClientKeys'
+    @ttl = ttl
+  end
+
+  def [](url)
+    res = @store.get(url)
+    res = YAML::load(res) if res.present?
+    res
+  end
+
+  def []=(url, value)
+    if value.nil?
+      del(url)
+    else
+      key_cache_add(url) if @store.add(url, YAML::dump(value), @ttl)
+    end
+    value
+  end
+
+  def keys
+    key_cache
+  end
+
+  def del(url)
+    key_cache_delete(url) if @store.delete(url)
+  end
+
+  private
+
+  def key_cache
+    the_keys = @store.get(@keys)
+    if the_keys.nil?
+      @store.add(@keys, YAML::dump([]))
+      []
+    else
+      YAML::load(the_keys)
+    end
+  end
+
+  def key_cache_add(key)
+    @store.replace(@keys, YAML::dump(key_cache << key))
+  end
+
+  def key_cache_delete(key)
+    tmp = key_cache
+    tmp.delete(key)
+    @store.replace(@keys, YAML::dump(tmp))
+  end
+end
+
+# Here Dalli is set up as on Heroku using the Memcachier gem.
+# https://devcenter.heroku.com/articles/memcachier#ruby
+# On other setups you might have to specify your Memcached server in Dalli::Client.new
+Geocoder.configure(:cache => AutoexpireCacheDalli.new(Dalli::Client.new))

data/examples/autoexpire_cache_redis.rb

@@ -0,0 +1,28 @@
+# This class implements a cache with simple delegation to the Redis store, but
+# when it creates a key/value pair, it also sends an EXPIRE command with a TTL.
+# It should be fairly simple to do the same thing with Memcached.
+class AutoexpireCacheRedis
+  def initialize(store, ttl = 86400)
+    @store = store
+    @ttl = ttl
+  end
+
+  def [](url)
+    @store.[](url)
+  end
+
+  def []=(url, value)
+    @store.[]=(url, value)
+    @store.expire(url, @ttl)
+  end
+
+  def keys
+    @store.keys
+  end
+
+  def del(url)
+    @store.del(url)
+  end
+end
+
+Geocoder.configure(:cache => AutoexpireCacheRedis.new(Redis.new))

data/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/examples/sidekiq_worker.rb

@@ -0,0 +1,16 @@
+# This class implements a Sidekiq worker for performing geocoding
+# asynchronously. Do something like this in your controller:
+#
+# if @object.save
+#   GeocoderWorker.perform_async(@object.id)
+# end
+#
+class GeocoderWorker
+  include Sidekiq::Worker
+
+  def perform(object_id)
+    object = Object.find(object_id)
+    object.geocode
+    object.save!
+  end
+end

data/gemfiles/Gemfile.mongoid-2.4.x

@@ -0,0 +1,16 @@
+source "http://rubygems.org"
+
+gemspec :path => '..'
+
+group :development, :test do
+  gem 'rake'
+  gem 'mongoid', '2.4.11'
+  gem 'bson_ext', :platforms => :ruby
+  gem 'geoip'
+
+  gem 'rails'
+
+  platforms :jruby do
+    gem 'jruby-openssl'
+  end
+end

data/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/lib/generators/geocoder/config/templates/initializer.rb

@@ -0,0 +1,21 @@
+Geocoder.configure(
+  # geocoding options
+  # :timeout      => 3,           # geocoding service timeout (secs)
+  # :lookup       => :google,     # name of 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 #keys)
+  # :cache_prefix => "geocoder:", # prefix (string) to use for all cache keys
+
+  # exceptions that should not be rescued by default
+  # (if you want to implement custom error handling);
+  # supports SocketError and TimeoutError
+  # :always_raise => [],
+
+  # calculation options
+  # :units     => :mi,       # :km for kilometers or :mi for miles
+  # :distances => :linear    # :spherical or :linear
+)

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

@@ -0,0 +1,28 @@
+require 'rails/generators/migration'
+
+module Geocoder
+  module Generators
+    module Maxmind
+      class GeoliteCityGenerator < Rails::Generators::Base
+        include Rails::Generators::Migration
+
+        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/lib/generators/geocoder/maxmind/geolite_country_generator.rb

@@ -0,0 +1,28 @@
+require 'rails/generators/migration'
+
+module Geocoder
+  module Generators
+    module Maxmind
+      class GeoliteCountryGenerator < Rails::Generators::Base
+        include Rails::Generators::Migration
+
+        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/lib/generators/geocoder/maxmind/templates/migration/geolite_city.rb

@@ -0,0 +1,30 @@
+class GeocoderMaxmindGeoliteCity < ActiveRecord::Migration
+  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/lib/generators/geocoder/maxmind/templates/migration/geolite_country.rb

@@ -0,0 +1,17 @@
+class GeocoderMaxmindGeoliteCountry < ActiveRecord::Migration
+  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/lib/geocoder.rb

@@ -0,0 +1,47 @@
+require "geocoder/configuration"
+require "geocoder/query"
+require "geocoder/calculations"
+require "geocoder/exceptions"
+require "geocoder/cache"
+require "geocoder/request"
+require "geocoder/lookup"
+require "geocoder/ip_address"
+require "geocoder/models/active_record" if defined?(::ActiveRecord)
+require "geocoder/models/mongoid" if defined?(::Mongoid)
+require "geocoder/models/mongo_mapper" if defined?(::MongoMapper)
+
+module Geocoder
+
+  ##
+  # Search for information about an address or a set of coordinates.
+  #
+  def self.search(query, options = {})
+    query = Geocoder::Query.new(query, options) unless query.is_a?(Geocoder::Query)
+    query.blank? ? [] : query.execute
+  end
+
+  ##
+  # Look up the coordinates of the given street or IP address.
+  #
+  def self.coordinates(address, options = {})
+    if (results = search(address, options)).size > 0
+      results.first.coordinates
+    end
+  end
+
+  ##
+  # Look up the address of the given coordinates ([lat,lon])
+  # or IP address (string).
+  #
+  def self.address(query, options = {})
+    if (results = search(query, options)).size > 0
+      results.first.address
+    end
+  end
+end
+
+# load Railtie if Rails exists
+if defined?(Rails)
+  require "geocoder/railtie"
+  Geocoder::Railtie.insert
+end

data/lib/geocoder/cache.rb

@@ -0,0 +1,90 @@
+module Geocoder
+  class Cache
+
+    def initialize(store, prefix)
+      @store = store
+      @prefix = prefix
+    end
+
+    ##
+    # Read from the Cache.
+    #
+    def [](url)
+      interpret 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
+
+    ##
+    # Write to the Cache.
+    #
+    def []=(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
+
+    ##
+    # Delete cache entry for given URL,
+    # or pass <tt>:all</tt> to clear all URLs.
+    #
+    def expire(url)
+      if url == :all
+        urls.each{ |u| expire(u) }
+      else
+        expire_single_url(url)
+      end
+    end
+
+
+    private # ----------------------------------------------------------------
+
+    def prefix; @prefix; end
+    def store; @store; end
+
+    ##
+    # Cache key for a given URL.
+    #
+    def key_for(url)
+      [prefix, url].join
+    end
+
+    ##
+    # Array of keys with the currently configured prefix
+    # that have non-nil values.
+    #
+    def keys
+      store.keys.select{ |k| k.match(/^#{prefix}/) and interpret(store[k]) }
+    end
+
+    ##
+    # Array of cached URLs.
+    #
+    def urls
+      keys.map{ |k| k[/^#{prefix}(.*)/, 1] }
+    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)
+      key = key_for(url)
+      store.respond_to?(:del) ? store.del(key) : store.delete(key)
+    end
+  end
+end