geolocal 0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 42ed22b2aefba01694af9ec4f3fb0f969f307ef8
+  data.tar.gz: 969d5d208bb9fd73e83d363c2b628a370af600b7
+SHA512:
+  metadata.gz: 319338e43dac19ca42ef0e7d6d3ff59e4862a71f95b1e6f34f17f1b96675bbf966e4d190c68b26c9342ff3cc1bd1f3efc3c1287ea053f316e57b4e9653948490
+  data.tar.gz: c36302f7fa49e21a064410754030276cc2e71398618eca05dad5d0bfacfd11285a61b173627f10c6547a9ad57c0cb01b4aaaaa8c3e1205ef32883afdbb833b25

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+gemspec
+
+group :development do
+  gem 'guard'
+  gem 'guard-rspec'
+  gem 'guard-bundler'
+end

data/Guardfile

@@ -0,0 +1,17 @@
+guard :bundler do
+  watch('Gemfile')
+  watch(/^.+\.gemspec/)
+end
+
+guard :rspec, cmd: 'rspec' do
+  # run all specs if any Ruby file is modified
+  watch(%r{^lib/.+\.rb}) { "spec" }
+  # watch(%r{.*\.rb})
+  # watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+
+  # re-run just the spec
+  watch(%r{^spec/.+_spec\.rb$})
+
+  # run all specs if the helper is modified
+  watch(%r{spec/spec_helper\.rb})  { "spec" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014-2015 Scott Bronson
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,103 @@
+# Geolocal
+
+Allows IP addresses to geocoded with a single Ruby if statement.
+No network access, no context switches, no delay.  Just one low-calorie local lookup.
+
+
+## Installation
+
+The usual method, add this line to your Gemfile:
+
+```ruby
+gem 'geolocal'
+```
+
+
+## Usage
+
+First create a config file that describes the ranges you're interested in.
+Here's an example:
+
+```ruby
+Geolocal.configure do
+  config.countries = {
+    us: 'US',
+    central_america: %w[ BZ CR SV GT HN NI PA ]
+  }
+end
+```
+
+Now run `rake geolocal:update`.  It will download the geocoding data
+from the default provider (see the [providers](#providers) section) and
+create `lib/geolocal.rb`.
+
+```ruby
+Geolocal.in_us?(request.remote_ip)
+Geolocal.in_central_america?(IPAddr.new('200.16.66.0'))
+```
+
+
+## Config
+
+Here are the most common config keys.  See the docs for the provider
+you're using for more.
+
+* **provider**: Where to download the geocoding data.  Default: DB_IP.
+* **module**: The name of the module to receive the `in_*` methods.  Default: 'Geolocal'.
+* **file**: Path to the file to contain the generated code.  Default: `lib/#{module}.rb`.
+* **tmpdir**: the directory to contain intermediate files.  They will require tens of megabytes
+  for countries, hundreds for cities).  Default: `./tmp/geolocal`
+* **expires**: the amount of time to consider downloaded data valid.  Default: 1.month
+* **countries**: the ISO-codes of the countries to include in the lookup.
+* **ipv6**: whether the ranges should support ipv6 addresses.
+
+
+## Examples
+
+This uses the [Countries](https://github.com/hexorx/countries) gem
+to discover if an address is in the European Union:
+
+```ruby
+require 'countries'
+
+eu_codes = Country.find_all_by_eu_member(true).map(&:first)
+
+Geolocal.configure do |config|
+  config.countries = { us: 'US', eu: eu_codes }
+end
+```
+
+Now you can call `Geolocal.in_eu?(ip)`.  If the European Union ever changes,
+run `bundle update countries` and then `rake geolocal`.
+
+## Providers
+
+This gem currently only supoports the [DB-IP](https://db-ip.com/about/) database.
+There are lots of other databases available and this gem is organized to support them.
+Patches welcome.
+
+
+## Alternatives
+
+The [Geocoder gem](https://github.com/alexreisner/geocoder) offers
+[local database services](https://github.com/alexreisner/geocoder#ip-address-local-database-services).
+Geolocal is simpler, faster, and production ready, but the Geocoder gem offers more options and more providers.
+Geolocal also doesn't add any dependencies to your deploy, potentially making it easier to get working with oddball
+environments like Heroku.
+
+
+## TODO
+
+- [ ] performance information?  benchmarks.  space saving by going ipv4-only?
+- [ ] include a Rails generator for the config file?
+- [ ] write a command that takes the config on the command line and writes the result to stdout?
+- [ ] Add support for cities
+- [ ] replace Nokogiri dependency with a single regex?  Shame to force that dependency on all clients.
+- [ ] other sources for this data? [MainFacts](http://mainfacts.com/ip-address-space-addresses), [NirSoft](http://www.nirsoft.net/countryip/)
+- [ ] Add support for for-pay features like lat/lon and timezones?
+
+
+## Contributing
+
+To make this gem less imperfect, please submit your issues and patches on
+[GitHub](https://github.com/bronson/geolocal/).

data/Rakefile

@@ -0,0 +1,12 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+Dir.glob('lib/tasks/*.rake').each { |r| load r}
+
+Geolocal.configure do |config|
+  config.file = 'tmp/geolocal.rb' # 'lib/geolocal.rb' default would overwrite our source code
+end
+
+RSpec::Core::RakeTask.new(:spec)
+task :default => ['spec']
+task :test => ['spec']

data/config/geolocal.rb

@@ -0,0 +1,5 @@
+require 'geolocal'
+
+Geolocal.configure do |config|
+  config.countries = { us: 'US' }
+end

data/geolocal.gemspec

@@ -0,0 +1,27 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'geolocal/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "geolocal"
+  spec.version       = Geolocal::VERSION
+  spec.authors       = ["Scott Bronson"]
+  spec.email         = ["brons_geolo@rinspin.com"]
+  spec.summary       = "Generates plain Ruby if statements to geocode IP addresses"
+  spec.description   = "Geocode an IP address with a single if statement. No network access, no context switches, no waiting."
+  spec.homepage      = "http://github.com/bronson/geolocal"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  # hm...  this is only required when running 'rake download'.
+  spec.add_runtime_dependency "nokogiri"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "webmock"
+end

data/lib/geolocal.rb

@@ -0,0 +1,32 @@
+require 'geolocal/version'
+require 'geolocal/configuration'
+require 'geolocal/provider/base'
+
+
+module Geolocal
+  require 'geolocal/railtie' if defined? Rails
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+
+  def self.reset_configuration
+    @configuration = nil
+  end
+
+  def self.provider
+    @provider ||= configuration.load_provider.new
+  end
+
+  def self.download
+    provider.download
+  end
+
+  def self.update
+    provider.update
+  end
+end

data/lib/geolocal/configuration.rb

@@ -0,0 +1,45 @@
+class Configuration
+  OPTIONS = [ :provider, :module, :file, :tmpdir, :expires, :ipv6, :quiet, :countries ]
+  attr_accessor(*OPTIONS)
+
+  def initialize
+    # configuration defaults
+    @provider = 'Geolocal::Provider::DB_IP'
+    @module = 'Geolocal'
+    @file = nil       # default is computed
+    @tmpdir = 'tmp/geolocal'
+    @expires = nil    # provider chooses the most sensible
+    @ipv6 = true
+    @quiet = false
+    @countries = {}
+  end
+
+  # if not set, defaults to lib/module-name
+  def file
+    @file || "lib/#{module_file @module}.rb"
+  end
+
+  def require_provider_file
+    begin
+      # normal ruby/gem load path
+      Kernel.require module_file(@provider)
+    rescue LoadError
+      # used when running source code locally
+      Kernel.require "./lib/#{module_file(@provider)}.rb"
+    end
+  end
+
+  def load_provider
+    require_provider_file
+    @provider.split('::').reduce(Module, :const_get)
+  end
+
+  def to_hash
+    # returned keys will always be symbols
+    OPTIONS.reduce({}) { |a,v| a.merge! v => self.send(v) }
+  end
+
+  def module_file modname
+    modname.gsub('::', '/').gsub(/([a-z])([A-Z])/, '\1_\2').downcase
+  end
+end

data/lib/geolocal/provider/base.rb

@@ -0,0 +1,112 @@
+require 'ipaddr'
+
+
+module Geolocal
+  module Provider
+    class Base
+      def initialize params={}
+        @config = params.merge(Geolocal.configuration.to_hash)
+      end
+
+      def config
+        @config
+      end
+
+      def download
+        # TODO: skip download if local files are new enough
+        # TODO: provide a FORCE argument to force download anyway
+        download_files
+      end
+
+      def update
+        countries = config[:countries].merge(config[:countries]) { |name, country_codes|
+          Array(country_codes).map(&:upcase).to_set
+        }
+
+        results = countries.merge(countries) { "" }
+
+        read_ranges(countries) do |name,lo,hi|
+          results[name] << "#{IPAddr.new(lo).to_i}..#{IPAddr.new(hi).to_i},\n"
+        end
+
+        File.open(config[:file], 'w') do |file|
+          output(file, results)
+        end
+
+        status "done, result in #{config[:file]}\n"
+      end
+
+      def output file, results
+        names = results.keys
+        modname = config[:module]
+
+        write_header file, names, modname
+
+        file.write "module #{modname}\n"
+        names.each do |name|
+          write_method file, name
+        end
+        file.write "end\n\n"
+
+        status "  writing "
+        results.each do |name, body|
+          status "#{name} "
+          write_ranges file, modname, name, body
+        end
+        status "\n"
+      end
+
+
+      def write_header file, names, modname
+        file.write <<EOL
+# This file is autogenerated
+
+# Defines #{names.map { |n| "#{modname}.in_#{n}?" }.join(', ')}
+#     and #{names.map { |n| "#{modname}::#{n.upcase}" }.join(', ')}
+
+EOL
+      end
+
+      def write_method file, name
+        file.write <<EOL
+  def self.in_#{name}? addr
+    num = addr.to_i
+    #{name.upcase}.bsearch { |range| num > range.max ? 1 : num < range.min ? -1 : 0 }
+  end
+EOL
+      end
+
+      def write_ranges file, modname, name, body
+        file.write <<EOL
+#{modname}::#{name.upcase} = [
+#{body}]
+
+EOL
+      end
+    end
+  end
+end
+
+
+# random utilities
+module Geolocal
+  module Provider
+    class Base
+      # returns elapsed time of block in seconds
+      def time_block
+        start = Time.now
+        yield
+        stop = Time.now
+        stop - start + 0.0000001 # fudge to prevent division by zero
+      end
+
+      def status *args
+        unless config[:quiet]
+          Kernel.print(*args)
+          $stdout.flush unless args.last.end_with?("\n")
+        end
+      end
+    end
+  end
+end
+

data/lib/geolocal/provider/db_ip.rb

@@ -0,0 +1,86 @@
+require 'csv'
+require 'net/http'
+require 'fileutils'
+require 'zlib'
+
+require 'nokogiri'
+
+
+class Geolocal::Provider::DB_IP < Geolocal::Provider::Base
+  START_URL = 'https://db-ip.com/db/download/country'
+
+  # TODO: refactor progress and download code into a mixin?
+
+  def update_download_status size, length
+    @current_byte ||= 0
+    @previous_print ||= 0
+    @current_byte += size
+
+    if length
+      pct = @current_byte * 100 / length
+      pct = (pct / 5) * 5
+
+      if pct != @previous_print
+        @previous_print = pct
+        status pct.to_s + '% '
+      end
+    else
+      # server didn't supply a length, display running byte count?
+    end
+  end
+
+  def csv_file
+    "#{config[:tmpdir]}/dbip-country.csv.gz"
+  end
+
+  def download_files
+    page = Net::HTTP.get(URI START_URL)
+    doc = Nokogiri::HTML(page)
+    href = URI.parse doc.css('a.btn-primary').attr('href').to_s
+
+    # stream result because it's large
+    FileUtils.mkdir_p(config[:tmpdir])
+    status "downloading #{href} to #{csv_file}\n"
+
+    elapsed = time_block do
+      File.open(csv_file, 'wb') do |file|
+        Net::HTTP.new(href.host, href.port).request_get(href.path) do |response|
+          total_length = response['Content-Length'].to_i
+          status "  reading #{(total_length/1024.0/1024).round(1)} MB: "
+
+          response.read_body do |chunk|
+            file.write chunk
+            update_download_status(chunk.length, total_length)
+          end
+        end
+      end
+    end
+
+    status "\n  read #{@current_byte} bytes in #{elapsed.round(2)} seconds at " +
+         "#{(@current_byte/1024/elapsed).round(1)} KB/sec\n"
+  end
+
+  def read_ranges countries
+    status "computing ranges\n"
+
+    row_count = 0
+    match_count = 0
+
+    elapsed = time_block do
+      File.open(csv_file, 'r') do |file|
+        gz = Zlib::GzipReader.new(file)
+        CSV.new(gz, headers: false).each do |row|
+          row_count += 1
+          countries.each do |name, country_codes|
+            if country_codes.include?(row[2])
+              match_count += 1
+              yield name, row[0], row[1]
+            end
+          end
+        end
+      end
+    end
+
+    status "  matched #{match_count} of #{row_count} ranges in #{elapsed.round(2)} seconds\n"
+  end
+end

data/lib/geolocal/provider/test.rb

@@ -0,0 +1,2 @@
+class Test
+end

data/lib/geolocal/railtie.rb

@@ -0,0 +1,12 @@
+require 'geolocal'
+require 'rails'
+
+module Geolocal
+  class Railtie < Rails::Railtie
+    railtie_name :geolocal
+
+    rake_tasks do
+      load "tasks/geolocal.rake"
+    end
+  end
+end

data/lib/geolocal/version.rb

@@ -0,0 +1,3 @@
+module Geolocal
+  VERSION = "0.5"
+end

data/lib/tasks/geolocal.rake

@@ -0,0 +1,16 @@
+require './config/geolocal'
+
+namespace :geolocal do
+  desc "Downloads the most recent geocoding information"
+  task :download do
+    Geolocal.download
+  end
+
+  desc "Updates your geocoding statements to use new data."
+  task :update => :download do
+    Geolocal.update
+  end
+end
+
+desc "shorthand for running geolocal:update"
+task geolocal: 'geolocal:update'

data/spec/configuration_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+
+describe "configuration" do
+  let(:config) { Geolocal.configuration }
+
+  it "has the right defaults" do
+    # reset the configuration so we get the default configuration,
+    # not the test configuration that the spec_helper has set up.
+    Geolocal.reset_configuration
+    defaults = Geolocal.configuration
+
+    # these need to match the description in the readme
+    expect(defaults.provider).to eq 'Geolocal::Provider::DB_IP'
+    expect(defaults.module).to   eq 'Geolocal'
+    expect(defaults.file).to     eq 'lib/geolocal.rb'
+    expect(defaults.tmpdir).to   eq 'tmp/geolocal'
+    expect(defaults.expires).to  eq nil
+    expect(defaults.ipv6).to     eq true
+    expect(defaults.quiet).to    eq false
+    expect(defaults.countries).to eq({})
+  end
+
+
+  describe "reset method" do
+    before :each do
+      Geolocal.configure do |conf|
+        conf.module = "Changed"
+      end
+    end
+
+    it "resets the configuration" do
+      expect(Geolocal.configuration.module).to eq "Changed"
+      Geolocal.reset_configuration
+      expect(Geolocal.configuration.module).to eq "Geolocal"
+    end
+  end
+
+
+  describe "module names" do
+    it "can handle typical module names" do
+      module_name = "GeoRangeFinderID::QuickLook"
+      Geolocal.configure do |g|
+        g.module = module_name
+      end
+
+      expect(config.module).to eq module_name
+      expect(config.file).to eq "lib/geo_range_finder_id/quick_look.rb"
+    end
+
+    it "can handle a pathological module name" do
+      module_name = "Geolocal::Provider::DB_IP"
+      Geolocal.configure do |g|
+        g.module = module_name
+      end
+
+      expect(config.module).to eq module_name
+      expect(config.file).to eq "lib/geolocal/provider/db_ip.rb"
+    end
+  end
+
+
+  describe "to_hash" do
+    it "can do the conversion" do
+      expect(config.to_hash).to eq({
+        provider: 'Geolocal::Provider::DB_IP',
+        module: 'Geolocal',
+        file: 'lib/geolocal.rb',
+        tmpdir: 'tmp/geolocal',
+        expires: nil,
+        ipv6: true,
+        quiet: true,
+        countries: {}
+      })
+    end
+  end
+
+
+  describe "module paths" do
+    it "includes the correct provider when running as a gem" do
+      expect(Kernel).to receive(:require).with('geolocal/provider/db_ip')
+      config.require_provider_file
+    end
+
+    it "includes the correct provider when running locally" do
+      expect(Kernel).to receive(:require).with('geolocal/provider/db_ip') { raise LoadError }
+      expect(Kernel).to receive(:require).with('./lib/geolocal/provider/db_ip.rb')
+      config.require_provider_file
+    end
+  end
+end

data/spec/provider/db_ip_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+require 'geolocal/provider/db_ip'
+
+describe Geolocal::Provider::DB_IP do
+  let(:it) { described_class }
+  let(:provider) { it.new }
+
+
+  describe 'network operation' do
+    let(:country_page) {
+      <<-eol
+        <div class="container">
+          <h3>Free database download</h3>
+          <a href='http://download.db-ip.com/free/dbip-country-2015-02.csv.gz' class='btn btn-primary'>Download free IP-country database</a> (CSV, February 2015)
+        </div>
+      eol
+    }
+
+    # todo: would be nice to test returning lots of little chunks
+    let(:country_csv) {
+      <<-eol.gsub(/^\s*/, '')
+        "0.0.0.0","0.255.255.255","US"
+        "1.0.0.0","1.0.0.255","AU"
+        "1.0.1.0","1.0.3.255","CN"
+      eol
+    }
+
+    before do
+      stub_request(:get, 'https://db-ip.com/db/download/country').
+        with(headers: {'Accept'=>'*/*', 'User-Agent'=>'Ruby'}).
+        to_return(status: 200, body: country_page, headers: {})
+
+      stub_request(:get, "http://download.db-ip.com/free/dbip-country-2015-02.csv.gz").
+        with(:headers => {'Accept'=>'*/*', 'User-Agent'=>'Ruby'}).
+        to_return(:status => 200, :body => country_csv, :headers => {'Content-Length' => country_csv.length})
+    end
+
+    it 'can download the csv' do
+      # wow!!  can't do this in an around hook because it gets the ordering completely wrong.
+      # since around hooks wrap ALL before hooks, they end up using the previous test's config.
+      if File.exist?(provider.csv_file)
+        File.delete(provider.csv_file)
+      end
+
+      provider.download
+      expect(File.read provider.csv_file).to eq country_csv
+
+      File.delete(provider.csv_file)
+    end
+  end
+
+
+  describe 'generating' do
+    let(:example_output) {
+      <<EOL
+# This file is autogenerated
+
+# Defines Geolocal.in_us?, Geolocal.in_au?
+#     and Geolocal::US, Geolocal::AU
+
+module Geolocal
+  def self.in_us? addr
+    num = addr.to_i
+    US.bsearch { |range| num > range.max ? 1 : num < range.min ? -1 : 0 }
+  end
+  def self.in_au? addr
+    num = addr.to_i
+    AU.bsearch { |range| num > range.max ? 1 : num < range.min ? -1 : 0 }
+  end
+end
+
+Geolocal::US = [
+0..16777215,
+]
+
+Geolocal::AU = [
+16777216..16777471,
+]
+
+EOL
+    }
+
+    it 'can generate countries from a csv' do
+      outfile = 'tmp/geolocal.rb'
+      if File.exist?(outfile)
+        File.delete(outfile)
+      end
+
+      Geolocal.configure do |config|
+        config.tmpdir = 'spec/data'
+        config.file = outfile
+        config.countries = { us: 'US', au: 'AU' }
+      end
+      provider.update
+      expect(File.read outfile).to eq example_output
+      File.delete(outfile)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require 'geolocal'
+require 'webmock/rspec'
+
+WebMock.disable_net_connect!(allow_localhost: true)
+
+RSpec.configure do |config|
+  config.order = 'random'
+
+  config.before :each do
+    Geolocal.reset_configuration
+    Geolocal.configure do |geoconf|
+      geoconf.quiet = true
+    end
+  end
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: geolocal
+version: !ruby/object:Gem::Version
+  version: '0.5'
+platform: ruby
+authors:
+- Scott Bronson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Geocode an IP address with a single if statement. No network access,
+  no context switches, no waiting.
+email:
+- brons_geolo@rinspin.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- config/geolocal.rb
+- geolocal.gemspec
+- lib/geolocal.rb
+- lib/geolocal/configuration.rb
+- lib/geolocal/provider/base.rb
+- lib/geolocal/provider/db_ip.rb
+- lib/geolocal/provider/test.rb
+- lib/geolocal/railtie.rb
+- lib/geolocal/version.rb
+- lib/tasks/geolocal.rake
+- spec/configuration_spec.rb
+- spec/data/dbip-country.csv.gz
+- spec/provider/db_ip_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/bronson/geolocal
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Generates plain Ruby if statements to geocode IP addresses
+test_files:
+- spec/configuration_spec.rb
+- spec/data/dbip-country.csv.gz
+- spec/provider/db_ip_spec.rb
+- spec/spec_helper.rb