heycarsten-gcoder 0.3.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,3 @@
+coverage
+rdoc
+pkg

data/README.rdoc

@@ -0,0 +1,7 @@
+= GCoder
+
+Instead of letting postal codes turn me into a postal coder, I made this gem!
+
+== Copyright
+
+Copyright (C) 2009 Carsten Nielsen. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,58 @@
+require 'rubygems'
+require 'rake'
+
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |g|
+    g.name = 'gcoder'
+    g.summary = 'A library for geocoding postal codes via the Google Maps ' \
+      'Geocoding API with a persisted cache through Tokyo Tyrant'
+    g.email = 'heycarsten@gmail.com'
+    g.homepage = 'http://github.com/heycarsten/gcoder'
+    g.authors = ['Carsten Nielsen']
+  end
+rescue LoadError
+  puts 'Jeweler not available. Install it with: sudo gem install ' \
+    'technicalpickles-jeweler -s http://gems.github.com'
+end
+
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort 'RCov is not available. In order to run rcov, you must: sudo gem ' \
+      'install spicycode-rcov'
+  end
+end
+
+
+task :default => :test
+
+# require 'rake/rdoctask'
+# Rake::RDocTask.new do |rdoc|
+#   if File.exist?('VERSION.yml')
+#     config = YAML.load(File.read('VERSION.yml'))
+#     version = [config[:major], config[:minor], config[:patch]].join('.')
+#   else
+#     version = ''
+#   end
+#   rdoc.rdoc_dir = 'rdoc'
+#   rdoc.title = "GCoder #{version}"
+#   rdoc.rdoc_files.include('README*')
+#   rdoc.rdoc_files.include('lib/**/*.rb')
+# end

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:minor: 3
+:patch: 0
+:major: 0

data/gcoder.gemspec

@@ -0,0 +1,57 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{gcoder}
+  s.version = "0.3.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Carsten Nielsen"]
+  s.date = %q{2009-06-26}
+  s.email = %q{heycarsten@gmail.com}
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION.yml",
+     "gcoder.gemspec",
+     "lib/gcoder.rb",
+     "lib/gcoder/config.rb",
+     "lib/gcoder/geocoding_api.rb",
+     "lib/gcoder/persistence.rb",
+     "lib/gcoder/resolver.rb",
+     "test/config_test.rb",
+     "test/gcoder_test.rb",
+     "test/geocoding_api_test.rb",
+     "test/persistence_test.rb",
+     "test/resolver_test.rb",
+     "test/test_helper.rb"
+  ]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/heycarsten/gcoder}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{A library for geocoding postal codes via the Google Maps Geocoding API with a persisted cache through Tokyo Tyrant}
+  s.test_files = [
+    "test/config_test.rb",
+     "test/gcoder_test.rb",
+     "test/geocoding_api_test.rb",
+     "test/persistence_test.rb",
+     "test/resolver_test.rb",
+     "test/test_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/lib/gcoder/config.rb

@@ -0,0 +1,26 @@
+module GCoder
+  module Config
+
+    # If :tt_port is 0 then :tt_host should point to a Unix socket.
+    @default_settings = {
+      :gmaps_api_key => nil,
+      :gmaps_api_timeout => 2,
+      :tt_host => nil,
+      :tt_port => 0,
+      :append_query => nil,
+      :no_raise_on_connection_fail => false }
+
+    def self.merge(overrides)
+      @default_settings.merge(overrides)
+    end
+
+    def self.update(hsh)
+      @default_settings.update(hsh)
+    end
+
+    def self.[](key)
+      @default_settings[key]
+    end
+
+  end
+end

data/lib/gcoder/geocoding_api.rb

@@ -0,0 +1,167 @@
+module GCoder
+  module GeocodingAPI
+
+    BASE_URI = 'http://maps.google.com/maps/geo'
+    BASE_PARAMS = {
+      :q => nil,
+      :output => 'json',
+      :oe => 'utf8',
+      :sensor => 'false',
+      :key => nil }
+
+
+    class Request
+
+      def self.get(query, options = {})
+        response = new(query, options).get
+        response.validate!
+        response.to_h
+      end
+
+      def initialize(query, options = {})
+        unless query
+          raise Errors::BlankRequestError, "query cannot be nil"
+        end
+        unless query.is_a?(String)
+          raise Errors::MalformedQueryError, "query must be String, not: #{query.class}"
+        end
+        @config = Config.merge(options)
+        @query = query
+        validate_state!
+      end
+
+      def params
+        BASE_PARAMS.merge(:key => @config[:gmaps_api_key], :q => query)
+      end
+
+      def to_params
+        params.inject([]) do |array, (key, value)|
+          array << "#{uri_escape key}=#{uri_escape value}"
+        end.join('&')
+      end
+
+      def query
+        @config[:append_query] ? "#{@query} #{@config[:append_query]}" : @query
+      end
+
+      def uri
+        [BASE_URI, '?', to_params].join
+      end
+
+      def get
+        return @json_response if @json_response
+        Timeout.timeout(@config[:gmaps_api_timeout]) do
+          Response.new(http_get)
+        end
+      rescue Timeout::Error
+        raise Errors::RequestTimeoutError, 'The query timed out at ' \
+        "#{@config[:timeout]} second(s)"
+      end
+
+      protected
+
+      def http_get
+        open(uri).read
+      end
+
+      # Snaked from Rack::Utils which 'stole' it from Camping.
+      def uri_escape(string)
+        string.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/n) do
+          '%' + $1.unpack('H2' * $1.size).join('%').upcase
+        end.tr(' ', '+')
+      end
+
+      def validate_state!
+        if '' == query.strip.to_s
+          raise Errors::BlankRequestError, 'You must specifiy a query to resolve.'
+        end
+        unless @config[:gmaps_api_key]
+          raise Errors::NoAPIKeyError, 'You must provide a Google Maps API ' \
+          'key in your configuration. Go to http://code.google.com/apis/maps/' \
+          'signup.html to get one.'
+        end
+      end
+
+    end
+
+
+    class Response
+
+      def initialize(raw_response)
+        @response = JSON.parse(raw_response)
+      end
+
+      def status
+        @response['Status']['code']
+      end
+
+      def validate!
+        case status
+        when 400
+          raise Errors::APIMalformedRequestError, 'The GMaps Geo API has ' \
+          'indicated that the request is not formed correctly: ' \
+          "(#{@response.inspect})"
+        when 602
+          raise Errors::APIGeocodingError, 'The GMaps Geo API has indicated ' \
+          "that it is not able to geocode the request: (#{@response.inspect})"
+        end
+      end
+
+      def to_h
+        { :accuracy => accuracy,
+          :country => {
+            :name => country_name,
+            :code => country_code,
+            :administrative_area => administrative_area },
+          :point => {
+            :longitude => longitude,
+            :latitude => latitude },
+          :box => box }
+      end
+
+      def box
+        { :north => placemark['ExtendedData']['LatLonBox']['north'],
+          :south => placemark['ExtendedData']['LatLonBox']['south'],
+          :east => placemark['ExtendedData']['LatLonBox']['east'],
+          :west => placemark['ExtendedData']['LatLonBox']['west'] }
+      end
+
+      def accuracy
+        placemark['AddressDetails']['Accuracy']
+      end
+
+      def latitude
+        placemark['Point']['coordinates'][1]
+      end
+
+      def longitude
+        placemark['Point']['coordinates'][0]
+      end
+
+      def latlon_box
+        placemark['ExtendedData']['LatLonBox']
+      end
+
+      def country_name
+        placemark['AddressDetails']['Country']['CountryName']
+      end
+
+      def country_code
+        placemark['AddressDetails']['Country']['CountryNameCode']
+      end
+
+      def administrative_area
+        placemark['AddressDetails']['Country']['AdministrativeArea']['AdministrativeAreaName']
+      end
+
+      private
+
+      def placemark
+        @response['Placemark'][0]
+      end
+
+    end
+
+
+  end
+end

data/lib/gcoder/persistence.rb

@@ -0,0 +1,80 @@
+module GCoder
+  module Persistence
+
+
+    class DataStore
+
+      def initialize(options = {})
+        @config = Config.merge(options)
+        unless @config[:tt_host]
+          raise ArgumentError, ':tt_host must be specified when it is not ' \
+          'present in the global configuration.'
+        end
+        @tyrant = Rufus::Tokyo::Tyrant.new(@config[:tt_host], @config[:tt_port])
+      rescue RuntimeError => boom
+        if boom.message.include?('couldn\'t connect to tyrant')
+          errmsg = 'Unable to connect to the Tokyo Tyrant server at ' \
+          "#{@config[:tt_host]} [#{@config[:tt_port]}]"
+          if @config[:no_raise_on_connection_fail]
+            @tyrant = nil
+            STDERR.puts("[GCODER] #{errmsg}")
+          else
+            raise Errors::TTUnableToConnectError, errmsg
+          end
+        else
+          raise boom
+        end
+      end
+
+      def fetch(key, &block)
+        unless block_given?
+          raise ArgumentError, 'no block was given but one was expected'
+        end
+        value = storage_get(key)
+        return value if value
+        storage_put(key, block.call(key.to_s))
+      end
+
+      def [](key)
+        storage_get(key)
+      end
+
+      def []=(key, value)
+        unless key.is_a?(String) || key.is_a?(Symbol)
+          raise ArgumentError, "key must be String or Symbol, not: #{key.class}"
+        end
+        storage_put(key, value)
+      end
+
+      protected
+
+      def storage_get(key)
+        if tyrant
+          value = tyrant[key.to_s]
+          value ? YAML.load(value) : nil
+        else
+          STDERR.puts "[GCODER] Unable to get #{key.inspect} " \
+          'because there is no Tyrant connection.'
+          nil
+        end
+      end
+
+      def storage_put(key, value)
+        if tyrant
+          tyrant[key.to_s.downcase] = YAML.dump(value)
+          value # <- We don't want to return YAML in this case.
+        else
+          STDERR.puts "[GCODER] Unable to put #{key.inspect} " \
+          'because there is no Tyrant connection.'
+          value
+        end
+      end
+
+      def tyrant
+        @tyrant
+      end
+
+    end
+
+  end
+end

data/lib/gcoder/resolver.rb

@@ -0,0 +1,15 @@
+module GCoder
+  class Resolver < Persistence::DataStore
+
+    def resolve(query)
+      fetch(query) do |q|
+        GeocodingAPI::Request.get(q, @config)
+      end
+    end
+
+    def [](postal_code)
+      resolve(postal_code)
+    end
+
+  end
+end

data/lib/gcoder.rb

@@ -0,0 +1,42 @@
+require 'rubygems'
+require 'rufus/tokyo/tyrant'
+require 'json'
+require 'yaml'
+require 'open-uri'
+require 'timeout'
+
+$:.unshift(File.dirname(__FILE__))
+
+require 'gcoder/config'
+require 'gcoder/geocoding_api'
+require 'gcoder/persistence'
+require 'gcoder/resolver'
+
+
+module GCoder
+
+  module Errors
+    class Error < StandardError; end
+    class MalformedQueryError < Error; end
+    class BlankRequestError < Error; end
+    class RequestTimeoutError < Error; end
+    class NoAPIKeyError < Error; end
+    class APIMalformedRequestError < Error; end
+    class APIGeocodingError < Error; end
+    class TTUnableToConnectError < Error; end
+    class InvalidStorageValueError < Error; end
+    class UnknownFormatSymbolError < Error; end
+  end
+
+
+  module ProxyMethods
+    def GCoder.config=(hsh)
+      Config.update(hsh)
+    end
+
+    def GCoder.connect(options = {})
+      Resolver.new(options)
+    end
+  end
+
+end

data/test/config_test.rb

@@ -0,0 +1,37 @@
+require 'test_helper'
+
+class ConfigTest < Test::Unit::TestCase
+
+  context 'Config#merge' do
+    setup do
+      @config = GCoder::Config.merge(:gmaps_api_timeout => 3)
+    end
+
+    should 'return a hash of updated config settings' do
+      assert_instance_of Hash, @config
+      assert_equal 6, @config.size
+      assert_equal 3, @config[:gmaps_api_timeout]
+    end
+
+    should 'not change default configuration' do
+      assert_equal 2, GCoder::Config[:gmaps_api_timeout]
+    end
+  end
+
+  context 'Config#update' do
+    setup do
+      @config = GCoder::Config.update(:gmaps_api_timeout => 1)
+    end
+
+    should 'return a hash of updated config settings' do
+      assert_instance_of Hash, @config
+      assert_equal 6, @config.size
+      assert_equal 1, @config[:gmaps_api_timeout]
+    end
+
+    should 'change default configuration' do
+      assert_equal 1, GCoder::Config[:gmaps_api_timeout]
+    end
+  end
+
+end

data/test/gcoder_test.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+class GCoderTest < Test::Unit::TestCase
+
+  context 'ProxyMethods' do
+    should 'be present in GCoder module' do
+      assert_respond_to GCoder, :config=
+      assert_respond_to GCoder, :connect
+    end
+
+    context 'GCoder.config=' do
+      should 'proxy to Config.update' do
+        GCoder::Config.expects(:update).with({})
+        assert GCoder.config = {}
+      end
+    end
+
+    context 'GCoder.connect' do
+      should 'proxy to Resolver.new' do
+        GCoder::Resolver.expects(:new).with({}).returns(:it_works)
+        assert_equal :it_works, GCoder.connect
+      end
+    end
+  end
+
+end

data/test/geocoding_api_test.rb

@@ -0,0 +1,74 @@
+require 'test_helper'
+
+
+class GeocodingAPITest < Test::Unit::TestCase
+
+  context 'initialize with incorrect arguments' do
+    should 'fail with no arguments' do
+      assert_raise ArgumentError do
+        GCoder::GeocodingAPI::Request.new
+      end
+    end
+
+    should 'fail with any argument other than a string' do
+      assert_raise GCoder::Errors::BlankRequestError do
+        GCoder::GeocodingAPI::Request.new(nil)
+      end
+      assert_raise GCoder::Errors::MalformedQueryError do
+        GCoder::GeocodingAPI::Request.new(0)
+      end
+    end
+
+    should 'fail when passed a blank string as an argument' do
+      assert_raise GCoder::Errors::BlankRequestError do
+        GCoder::GeocodingAPI::Request.new('         ')
+      end
+    end
+  end
+
+  context 'initialize with no API key present' do
+    should 'fall down, go boom' do
+      assert_raise GCoder::Errors::NoAPIKeyError do
+        GCoder::GeocodingAPI::Request.new('M6R2G5')
+      end
+    end
+  end
+
+  context 'query with correct arguments' do
+    setup do
+      @zip = GCoder::GeocodingAPI::Request.new('M6R2G5',
+        :gmaps_api_key => 'apikey')
+    end
+
+    should 'return parsed and tidied JSON' do
+      @zip.expects(:http_get).returns(PAYLOADS[:json_m6r2g5])
+      response = @zip.get.to_h
+      assert_equal 5, response[:accuracy]
+      assert_equal 'Canada', response[:country][:name]
+      assert_equal 'CA', response[:country][:code]
+      assert_equal 'ON', response[:country][:administrative_area]
+      assert_equal 43.6504650, response[:point][:latitude]
+      assert_equal -79.4449720, response[:point][:longitude]
+      assert_equal 43.6536126, response[:box][:north]
+      assert_equal 43.6473174, response[:box][:south]
+      assert_equal -79.4418244, response[:box][:east]
+      assert_equal -79.4481196, response[:box][:west]
+    end
+
+    should 'raise an error when API returns malformed request' do
+      @zip.expects(:http_get).returns(PAYLOADS[:json_400])
+      assert_raise GCoder::Errors::APIMalformedRequestError do
+        @zip.get.validate!
+      end
+    end
+
+    should 'have an appropriate URI' do
+      assert_match /output=json/, @zip.uri
+      assert_match /q=M6R2G5/, @zip.uri
+      assert_match /oe=u/, @zip.uri
+      assert_match /sensor=false/, @zip.uri
+      assert_match /key=apikey/, @zip.uri
+    end
+  end
+
+end

data/test/persistence_test.rb

@@ -0,0 +1,78 @@
+require 'test_helper'
+
+class PersistenceTest < Test::Unit::TestCase
+
+  context 'DataStore.new' do
+    should 'throw and argument error without :tt_host specified' do
+      assert_raise ArgumentError do
+        GCoder::Persistence::DataStore.new
+      end
+    end
+
+    should 'throw a better error if the Tokyo Tyrant connection fails' do
+      assert_raise GCoder::Errors::TTUnableToConnectError do
+        GCoder::Persistence::DataStore.new(:tt_host => '/tmp/fake')
+      end
+    end
+  end
+
+  context 'DataStore' do
+    setup do
+      Rufus::Tokyo::Tyrant.stubs(:new).returns({})
+      @db = GCoder::Persistence::DataStore.new(:tt_host => '/tmp/tttest')
+    end
+
+    context '#fetch' do
+      should 'raise an error without any block specified' do
+        assert_raise ArgumentError do
+          @db.fetch(:stuff)
+        end
+      end
+
+      should 'get a value that exists' do
+        @db[:test_key] = 'test_value'
+        assert_equal 'test_value', @db.fetch(:test_key) { raise 'ultrafail' }
+      end
+
+      should 'set the value to whatever the block yields if value is nil' do
+        @db.fetch(:test_key) { 'block_value' }
+        assert_equal 'block_value', @db[:test_key]
+      end
+    end
+
+    context '#[]=' do
+      should 'now allow numbers or nil as a key' do
+        assert_raise ArgumentError do
+          @db[nil] = 'extreme fail'
+        end
+        assert_raise ArgumentError do
+          @db[23] = 'massive fail'
+        end
+      end
+    end
+
+    context '#[]' do
+      should 'return nil for a key that does not exist' do
+        assert_nil @db['nope']
+        assert_nil @db['']
+        assert_nil @db[0]
+        assert_nil @db[nil]
+      end
+
+      should 'alow retrieval of nil' do
+        @db[:nil_key] = nil
+        assert_nil @db[:nil_key]
+      end
+
+      should 'return parsed JSON for keys that do exist' do
+        @db[:payload_1] = PAYLOADS[:test_string]
+        @db[:payload_2] = PAYLOADS[:test_hash]
+        @db[:payload_3] = PAYLOADS[:test_array]
+        assert_equal PAYLOADS[:test_string], @db[:payload_1]
+        assert_equal PAYLOADS[:test_hash], @db[:payload_2]
+        assert_equal PAYLOADS[:test_array], @db[:payload_3]
+      end
+    end
+  end
+
+end

data/test/resolver_test.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+
+class ResolverTest < Test::Unit::TestCase
+
+  context 'Resolver' do
+    setup do
+      Rufus::Tokyo::Tyrant.stubs(:new).returns({})
+      @db = GCoder::Resolver.new(:tt_host => '/tmp/tttest', :gmaps_api_key => 'testkey')
+    end
+
+    should 'return a hash of information for a new address' do
+      GCoder::GeocodingAPI::Request.any_instance.
+        expects(:http_get).returns(PAYLOADS[:json_m6r2g5])
+      assert_instance_of Hash, @db.resolve('m6r2g5')
+    end
+
+    should 'not call api when a cached postal code is called' do
+      assert_instance_of Hash, @db.resolve('m6r2g5')
+    end
+
+    should 'store the postal code key in the correct format' do
+      assert_instance_of Hash, @db.resolve('M6R2G5')
+    end
+
+    should 'allow [] to resolve with auto-instantiation' do
+      assert_instance_of Hash, @db['M6R2G5']
+    end
+
+    should 'raise malformed postal code error for a nil postal code' do
+      assert_raise GCoder::Errors::BlankRequestError do
+        @db.resolve(nil)
+      end
+    end
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,58 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$:.unshift(File.dirname(__FILE__))
+require 'gcoder'
+
+class Test::Unit::TestCase
+
+  PAYLOADS = {
+    :json_m6r2g5 => %q<
+{
+"name": "M6R2G5",
+"Status": {
+  "code": 200,
+  "request": "geocode"
+},
+"Placemark": [ {
+  "id": "p1",
+  "address": "Ontario M6R 2G5, Canada",
+  "AddressDetails": {"Country": {"CountryNameCode": "CA","CountryName": "Canada","AdministrativeArea": {"AdministrativeAreaName": "ON","PostalCode": {"PostalCodeNumber": "M6R 2G5"}}},"Accuracy": 5},
+  "ExtendedData": {
+    "LatLonBox": {
+      "north": 43.6536126,
+      "south": 43.6473174,
+      "east": -79.4418244,
+      "west": -79.4481196
+    }
+  },
+  "Point": {
+    "coordinates": [ -79.4449720, 43.6504650, 0 ]
+  }
+} ]
+}>,
+    :json_602 => %q<
+{
+  "name": "crashbangboom",
+  "Status": {
+    "code": 602,
+    "request": "geocode"
+  }
+}>,
+    :json_400 => %q<
+{
+  "name": "",
+  "Status": {
+    "code": 400,
+    "request": "geocode"
+  }
+}>,
+    :test_string => "test\nstring",
+    :test_hash => { 'test' => 'value', 100 => 'one hundred' },
+    :test_array => ['test', 1, 3.1415, true, false, nil]
+  }
+
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: heycarsten-gcoder
+version: !ruby/object:Gem::Version 
+  version: 0.3.0
+platform: ruby
+authors: 
+- Carsten Nielsen
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-26 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: heycarsten@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- README.rdoc
+- Rakefile
+- VERSION.yml
+- gcoder.gemspec
+- lib/gcoder.rb
+- lib/gcoder/config.rb
+- lib/gcoder/geocoding_api.rb
+- lib/gcoder/persistence.rb
+- lib/gcoder/resolver.rb
+- test/config_test.rb
+- test/gcoder_test.rb
+- test/geocoding_api_test.rb
+- test/persistence_test.rb
+- test/resolver_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/heycarsten/gcoder
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A library for geocoding postal codes via the Google Maps Geocoding API with a persisted cache through Tokyo Tyrant
+test_files: 
+- test/config_test.rb
+- test/gcoder_test.rb
+- test/geocoding_api_test.rb
+- test/persistence_test.rb
+- test/resolver_test.rb
+- test/test_helper.rb