geo_loc 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 85f8da0f505236bceaffc0b362d4343c3027795b
+  data.tar.gz: be4a7ab27768cc9889882a34953a10b5ef385576
+SHA512:
+  metadata.gz: b247a7760ffc4f16c4160c29726f7a5578b685c2be34b48e94e536a0ffd6d36f904c657d6c58dab0b90b0406ee131f7b1695d263abefcd7db742ab287ae0cd4c
+  data.tar.gz: 7a6fc5fba322c615039c618bf91d35927f7cd7eea58bb9432a4e134587b67c85ce350716bf332177b57e56a8b1011195bb4314cf1b809eb2245061d5ff236387

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--warnings
+--require spec_helper

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in geo_loc.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,14 @@
+Copyright (c) 2014 Justin Wiley
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.

data/README.md

@@ -0,0 +1,89 @@
+# GeoLoc
+
+A quick-and-dirty wrapper for the GeoIP gem that handles downloading and unzipping geodata.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'geo_loc'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install geo_loc
+
+## Usage
+
+Caveats:
+
+- this gem is the minimum viable product for my purposes, your mileage may vary, feel free to fork and contribute if you run into issues
+- it's designed for city level lookup resolution using Maxminds free city IP data, other lookup methods are not currently supported
+- it assumes data files are .gzipped
+
+The [GeoIP gem](https://github.com/cjheath/geoip) does a great job of accepting an IP address and digging through a MaxMind geolocation file to find a corresponding address.
+
+One thing it doesn't do, however, is pull and unzip the data file for you.  This gem attempts to add this functionality, by automatically downloading the file if necessary and storing it in a sensible directory (or directory of your choice).
+
+### Typical usage
+
+    require 'geo_loc'
+
+    if gdata = GeoLoc.new.ip('10.0.0.1')
+      self.country = gdata[:country_code2]
+      self.state = gdata[:region_name]
+      self.city = gdata[:city_name]
+      self.zip = gdata[:postal_code]
+      self.lat = gdata[:latitude]
+      self.long = gdata[:longitude]
+    else
+      # ...sadness
+    end
+
+This will download the latest release of Maxmind city data (see GeoIP gem for locations) if it doesn't already exist, and gzip it.
+
+The #ip method rescues StandardError, so connectivity issues, file format issues will be logged and nil returned.
+
+The hash returned by #ip comes directly from geoip, see geoip for details.
+
+### Frequency of update
+
+City data is **not** automatically refreshed.  If you're deploying your application once a week or more frequently, and the data file is stored in a location that is overwritten after every deploy, this isn't an issue since the next time GeoLoc.new.ip executes it will pull the file.  If it is an issue, you can manually force the sync data via:
+
+	GeoLoc.new.sync_data!
+
+Since syncing will pull down and decompress an 11mb+ file, users may experience a delay the first time GeoLoc.new.ip executes.  It's probably a good idea to do this as part of your deploy process.
+
+Note that #sync_data! does not rescue exceptions.
+
+### Overriding default locations
+
+Without any initialization options, GeoLoc will try to pick default directory locations for you.  If Rails is defined, it will use Rails.root + '/tmp'.  If Rails isn't defined, it will use '/tmp'.  An example of customized options:
+
+	GeoLoc.new(filename: 'my-file', 
+		geodata_dir: 'my-dir', 
+		geodata_file: 'geodata', 
+		compressed_geodata_file: 'geodata.gz', 
+		geodata_url: 'http://thedata.gz', 
+		logger: MyLogger.new('/tmp/mylogger.log'))
+
+In general, the options will work if only one is passed, for example if you want to customize the data where geodata is stored.
+
+### Rspec warnings
+
+	warning: instance variable @data_exists not initialized
+
+Is being triggered on running unit specs, if you know the cause and resolution to this issue, please let me know.
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/geo_loc/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/geo_loc.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'geo_loc/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "geo_loc"
+  spec.version       = GeoLoc::VERSION
+  spec.authors       = ["Justin Wiley"]
+  spec.email         = ["justin.wiley@gmail.com"]
+  spec.summary       = %q{A quick-and-dirty wrapper for the GeoIP gem that handles downloading and unzipping geodata}
+  spec.description   = %q{A quick-and-dirty wrapper for the GeoIP gem that handles downloading and unzipping geodata}
+  spec.homepage      = ""
+  spec.license       = "GPL V3"
+
+  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"]
+
+  spec.add_dependency "geoip", "~> 1.4.0"
+
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/lib/geo_loc.rb

@@ -0,0 +1,68 @@
+require 'geo_loc/version'
+require 'geoip'
+require 'open-uri'
+require 'zlib'
+require 'logger'
+
+# Geolocates given IP using maxminds geo ip database
+# Pulls database down if it doesnt exists
+# Note that in test environment (outside of mocked unit tests), will pull the ~11mb file, leading to lengthened initial test run
+
+class GeoLoc
+  # FILENAME = 'GeoLiteCity.dat'
+  # GEODATA_FILE = File.join(Rails.root, '/tmp/', FILENAME)
+  # COMPRESSED_GEODATA_FILE = File.join(Rails.root, FILENAME + '.gz')
+  # GEODATA_URL = 'http://geolite.maxmind.com/download/geoip/database/GeoLiteCity.dat.gz'
+
+  attr_accessor :filename, :geodata_file, :geodata_dir, :compressed_geodata_file, :geodata_url, :logger
+
+  def initialize(filename: nil, geodata_dir: nil, geodata_file: nil, compressed_geodata_file: nil, geodata_url: nil, logger: nil)
+    self.filename = filename || 'GeoLiteCity.dat'
+    self.geodata_dir = geodata_dir || root_dir
+    self.geodata_file = geodata_file || File.join(self.geodata_dir, self.filename)
+    self.compressed_geodata_file = compressed_geodata_file || self.geodata_file + '.gz'
+    self.geodata_url = geodata_url || 'http://geolite.maxmind.com/download/geoip/database/GeoLiteCity.dat.gz'
+    self.logger = logger || logger_method
+  end
+
+  def logger_method; defined?(Rails) && Rails.respond_to?(:logger) ? Rails.logger : Logger.new('/tmp/geoloc.log'); end
+  def root_dir; defined?(Rails) && Rails.respond_to?(:root) ? File.join(Rails.root, '/tmp') : '/tmp'; end
+
+  def download_compressed_geodata
+    logger.info "Downloading geodata #{geodata_url}"
+    open(compressed_geodata_file, 'wb') {|f| f << open(geodata_url).read }
+  end
+
+  def decompress_geodata
+    logger.info "Decompressing #{compressed_geodata_file}"
+    File.open(compressed_geodata_file) do |cf|
+      begin
+        gz = Zlib::GzipReader.new(cf)
+        File.open(geodata_file, 'w'){|f| f << gz.read}
+      ensure
+        gz.close
+      end
+    end
+  end
+
+  def sync_data!
+    download_compressed_geodata
+    decompress_geodata
+  end
+
+  def ip ip_address
+    begin
+      if @data_exists || File.exist?(geodata_file)
+        @data_exists = true
+      else
+        sync_data!
+      end
+
+      @geoip ||= GeoIP.new(geodata_file)
+      @geoip.city(ip_address).try(:to_hash)
+    rescue StandardError => e
+      logger.error "Failed to geo ip address #{ip_address}\n#{e}\n#{e.backtrace.join("\n")}"
+      nil
+    end
+  end
+end

data/lib/geo_loc/version.rb

@@ -0,0 +1,3 @@
+class GeoLoc
+  VERSION = "0.0.1"
+end

data/spec/lib/geo_loc_spec.rb

@@ -0,0 +1,100 @@
+# require 'pry'
+require_relative '../../lib/geo_loc.rb'
+require_relative '../spec_helper'
+
+describe GeoLoc do
+  let(:gl) { GeoLoc.new }
+  let(:gddir) { gl.geodata_dir }
+  let(:gdfile) { gl.geodata_file }
+  let(:gdzfile) { gl.compressed_geodata_file }
+  let(:gdurl) { gl.geodata_url }
+  let(:double_io) { double('IO', read: 'data')}
+
+  before do
+    GeoLoc.send(:remove_const, :Rails) if defined? GeoLoc::Rails
+  end
+
+  describe 'intialize' do
+    it 'provides default locations for storing geodata, url of where to download data from' do
+      gdfile.should be == "/tmp/GeoLiteCity.dat"
+      gddir.should be == '/tmp'
+      gdzfile.should be == "/tmp/GeoLiteCity.dat.gz"
+      gdurl.should be ==  "http://geolite.maxmind.com/download/geoip/database/GeoLiteCity.dat.gz"
+    end
+
+    it 'allows these values to be overridden as options' do
+      gl = GeoLoc.new geodata_dir: '/mydir'
+      gl.geodata_dir.should be == '/mydir'
+    end
+
+    it 'uses Rails envrionment root dir if Rails is defined' do
+      class GeoLoc::Rails
+        def self.root; 'rails-root'; end
+        def self.logger; Logger.new('/dev/null'); end
+      end
+      gddir.should be == 'rails-root/tmp'
+    end
+  end
+
+  describe 'refreshing geo ip data' do
+    before do
+      [gdzfile, gdfile].map{|f| FileUtils.rm(f) if File.exist?(f) }
+    end
+
+    it '#download_compressed_geodata pulls down compressed geoip data' do
+      gl.should_receive(:open).with(gdurl).and_return(double_io)
+      gl.should_receive(:open).with(gdzfile, 'wb').and_yield([])
+
+      gl.download_compressed_geodata
+    end
+
+    it '#decompress_geodata decompresses geodata using zlib' do
+      contents = 'test data'
+      Zlib::GzipWriter.open(gdzfile) do |gz|
+        gz.write contents
+      end
+
+      File.exist?(gdfile).should be_falsey
+      gl.decompress_geodata
+      res = File.read(gdfile)
+      res.should be == contents
+    end
+
+    it '#sync_data! does both, downloads and decompresses' do
+      gl.should_receive(:download_compressed_geodata)
+      gl.should_receive(:decompress_geodata)
+      gl.sync_data!
+    end
+  end
+
+  describe '#ip' do
+    let(:double_geoip) { double(GeoIP, city: 'city data') }
+    let(:ip) { '127.0.0.1' }
+
+    it 'returns the geo data for a given ip address' do
+      gl.stub(:sync_data!)
+      double_geoip.should_receive(:city).with(ip)
+      GeoIP.should_receive(:new).with(gdfile).and_return(double_geoip)
+      gl.ip(ip)
+    end
+  
+    it 'should sync the data file if it doesnt exist' do
+      File.should_receive(:exist?).and_return(false)
+      gl.should_receive(:sync_data!)
+      GeoIP.should_receive(:new).with(gdfile).and_return(double_geoip)
+      gl.ip(ip)
+    end
+
+    it 'should not sync if it does' do
+      File.should_receive(:exist?).and_return(true)
+      gl.should_not_receive(:sync_data!)
+      GeoIP.should_receive(:new).with(gdfile).and_return(double_geoip)
+      gl.ip(ip)
+    end
+
+    it 'rescues exceptions, returning nil' do
+      File.should_receive(:exist?).and_raise(StandardError)
+      gl.ip(ip).should be_nil
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,84 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, make a
+# separate helper file that requires this one and then use it only in the specs
+# that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+  config.expect_with :rspec do |c|
+    c.syntax = :should
+  end
+  config.mock_with :rspec do |c|
+    c.syntax = :should
+  end
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+    expectations.syntax = :expect
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+    mocks.syntax = :expect
+
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended.
+    mocks.verify_partial_doubles = true
+  end
+=end
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: geo_loc
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Justin Wiley
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: geoip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.0
+- !ruby/object:Gem::Dependency
+  name: pry
+  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: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: A quick-and-dirty wrapper for the GeoIP gem that handles downloading
+  and unzipping geodata
+email:
+- justin.wiley@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- geo_loc.gemspec
+- lib/geo_loc.rb
+- lib/geo_loc/version.rb
+- spec/lib/geo_loc_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- GPL V3
+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.2.2
+signing_key: 
+specification_version: 4
+summary: A quick-and-dirty wrapper for the GeoIP gem that handles downloading and
+  unzipping geodata
+test_files:
+- spec/lib/geo_loc_spec.rb
+- spec/spec_helper.rb