geocoder2 0.1.0

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/*_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 = "Geocoder2 #{Geocoder2::VERSION}"
+  rdoc.rdoc_files.include('*.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/bin/geocode2

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'geocoder2/cli'
+
+Geocoder2::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 = 'Geocoder2DalliClientKeys'
+    @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
+Geocoder2.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
+
+Geocoder2.configure(:cache => AutoexpireCacheRedis.new(Redis.new))

data/examples/cache_bypass.rb

@@ -0,0 +1,48 @@
+# This class allows you to configure how Geocoder2 should treat errors that occur when
+# the cache is not available.
+# Configure it like this
+# config/initializers/geocoder2.rb
+# Geocoder2.configure(
+#  :cache => Geocoder2::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 Geocoder2::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/gemfiles/Gemfile.mongoid-2.4.x

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

data/json?address=26+leonard+street%2C+Belmont&key=AIzaSyDoltU6YL8XeIQrSLFGk6ZfpKaWkPukwYQ&language=en

@@ -0,0 +1,68 @@
+{
+   "results" : [
+      {
+         "address_components" : [
+            {
+               "long_name" : "26",
+               "short_name" : "26",
+               "types" : [ "street_number" ]
+            },
+            {
+               "long_name" : "Leonard Street",
+               "short_name" : "Leonard St",
+               "types" : [ "route" ]
+            },
+            {
+               "long_name" : "Belmont",
+               "short_name" : "Belmont",
+               "types" : [ "locality", "political" ]
+            },
+            {
+               "long_name" : "Greater Geelong City",
+               "short_name" : "Greater Geelong",
+               "types" : [ "administrative_area_level_2", "political" ]
+            },
+            {
+               "long_name" : "Victoria",
+               "short_name" : "VIC",
+               "types" : [ "administrative_area_level_1", "political" ]
+            },
+            {
+               "long_name" : "Australia",
+               "short_name" : "AU",
+               "types" : [ "country", "political" ]
+            },
+            {
+               "long_name" : "3216",
+               "short_name" : "3216",
+               "types" : [ "postal_code" ]
+            }
+         ],
+         "formatted_address" : "26 Leonard St, Belmont VIC 3216, Australia",
+         "geometry" : {
+            "location" : {
+               "lat" : -38.1704428,
+               "lng" : 144.3313951
+            },
+            "location_type" : "ROOFTOP",
+            "viewport" : {
+               "northeast" : {
+                  "lat" : -38.1690938197085,
+                  "lng" : 144.3327440802915
+               },
+               "southwest" : {
+                  "lat" : -38.1717917802915,
+                  "lng" : 144.3300461197085
+               }
+            }
+         },
+         "place_id" : "ChIJzz9XwJ0T1GoRKPvo8BszH70",
+         "plus_code" : {
+            "compound_code" : "R8HJ+RH Geelong, Victoria, Australia",
+            "global_code" : "4RH6R8HJ+RH"
+         },
+         "types" : [ "street_address" ]
+      }
+   ],
+   "status" : "OK"
+}

data/lib/generators/geocoder2/config/config_generator.rb

@@ -0,0 +1,14 @@
+require 'rails/generators'
+
+module Geocoder2
+  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 Geocoder2."
+    def add_initializer
+      template "initializer.rb", "config/initializers/geocoder2.rb"
+    end
+  end
+end
+

data/lib/generators/geocoder2/config/templates/initializer.rb

@@ -0,0 +1,21 @@
+Geocoder2.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 => "geocoder2:", # 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/geocoder2/cache.rb

@@ -0,0 +1,89 @@
+module Geocoder2
+  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 # ----------------------------------------------------------------
+
+    attr_reader :prefix, :store
+
+    ##
+    # 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