geoip_city19 2.0.1

data/README

@@ -0,0 +1,67 @@
+= What?
+This is a library which provides a single function. The function takes as
+input an IP address and it outputs a hash containing best-guess geographical
+information (like city, country, latitude, and longitude).
+
+Actually this is only a Ruby binding to a C library which provides this
+function. Also, you must download a large binary database with all this
+mapping information. It is kindly provided free of charge by MaxMind.com. 
+
+= Usage
+   require 'geoip_city'
+   db = GeoIPCity::Database.new('/opt/GeoIP/share/GeoIP/GeoLiteCity.dat')
+   result = db.look_up('24.24.24.24')
+   p result 
+   # => {:city=>"Ithaca", 
+   #     :latitude=>42.4277992248535, 
+   #     :longitude=>-76.4981994628906, 
+   #     :country_code3=>"USA", 
+   #     :country_code=>"US",
+   #     :country_name=>"United States", 
+   #     :dma_code=>555,
+   #     :area_code=>607, 
+   #     :region=>"NY" }
+
+There are two optional arguments to database initializer.
+The first argument is the filename of the GeoIPCity.dat file 
+The second argument (optional) is to specify how GeoIP should
+keep the database in memory. There are three possibilities
+* :filesystem -- read database from filesystem, uses least memory.
+* :index -- the most frequently accessed index portion of the database, resulting in faster lookups than :filesystem, but less memory usage than :memory.
+* :memory -- load database into memory, faster performance but uses more memory.
+  (default)
+
+The third argument is boolean and decides whether the system should reload the database if changes are made to the dat file. (You probably don't need this. Default: false.)
+
+For example 
+
+  GeoIPCity::Database.new(dbfile, :filesystem, true)
+
+= Install
+Some variation of the following should work.
+
+1. Install the GeoCity C library. You can get it from here  
+   http://www.maxmind.com/app/c
+   For example, I like to install mine in /opt/GeoIP
+   so I do this:
+     tar -zxvf GeoIP-1.4.3.tar.gz 
+     cd GeoIP-1.4.3
+     ./configure --prefix=/opt/GeoIP
+     make && sudo make install
+
+2. Now install the geoip_city gem 
+     sudo gem install geoip_city -- --with-geoip-dir=/opt/GeoIP
+
+3. Download the GeoLite City database file in binary format from:
+   http://www.maxmind.com/app/geolitecity
+   Maybe this direct link will work:
+   http://www.maxmind.com/download/geoip/database/GeoLiteCity.dat.gz
+   I put this file in 
+   /opt/GeoIP/share/GeoIP/GeoLiteCity.dat
+
+4. Use it!
+
+= License 
+Copyright (C) 2007 Ryan Dahl (ry@tinyclouds.org)
+
+I give permission for you to do whatever you'd like to do with this software.

data/ext/geoip_city/extconf.rb

@@ -0,0 +1,9 @@
+require 'mkmf'
+
+dir_config("geoip")
+
+if have_library('GeoIP', 'GeoIP_record_by_ipnum') and have_header('GeoIPCity.h')
+  create_makefile('geoip_city')
+else
+  abort("you must have geoip c library installed!")
+end

data/ext/geoip_city/geoip_city.c

@@ -0,0 +1,132 @@
+/* ry dahl <ry@tinyclouds.org> May 21, 2007 */
+/* This program is free software. It comes without any warranty, to
+ * the extent permitted by applicable law. You can redistribute it
+ * and/or modify it under the terms of the Do What The Fuck You Want
+ * To Public License, Version 2, as published by Sam Hocevar. See
+ * http://sam.zoy.org/wtfpl/COPYING for more details. */
+#include <ruby.h>
+#include <GeoIP.h>
+#include <GeoIPCity.h>
+
+static VALUE cDB;
+static VALUE rb_geoip_memory; 
+static VALUE rb_geoip_filesystem; 
+static VALUE rb_geoip_index; 
+ 
+/* The first argument is the filename of the GeoIPCity.dat file 
+ * load_option = :standard, :index, or :memory. default :memory
+ * check_cache = true or false. default false
+ * 
+ * filesystem: read database from filesystem, uses least memory.
+ *
+ * index: the most frequently accessed index portion of the database,
+ *   resulting in faster lookups than :filesystem, but less memory usage than
+ *   :memory.
+ *
+ * memory: load database into memory, faster performance but uses more
+ *   memory.
+ */
+static VALUE rb_geoip_new(int argc, VALUE *argv, VALUE self)
+{
+  GeoIP *gi;
+  VALUE database = Qnil;
+  VALUE filename, load_option = Qnil, check_cache = Qnil;
+  int flag;
+
+  rb_scan_args(argc, argv, "12", &filename, &load_option, &check_cache);
+  if(NIL_P(load_option))
+    load_option = rb_geoip_memory;
+  if(NIL_P(check_cache))
+    check_cache = Qfalse;
+  Check_Type(load_option, T_SYMBOL);
+
+  if(load_option == rb_geoip_memory) {
+    flag = GEOIP_MEMORY_CACHE;
+  } else if(load_option == rb_geoip_filesystem) {
+    flag = GEOIP_STANDARD;
+  } else if(load_option == rb_geoip_index) {
+    flag = GEOIP_INDEX_CACHE;
+  } else {
+    rb_raise(rb_eTypeError, "the second option must be :memory, :filesystem, or :index");
+    return Qnil;
+  }
+
+  if(RTEST(check_cache)) flag |= GEOIP_CHECK_CACHE;
+  
+  if(gi = GeoIP_open(StringValuePtr(filename), flag)) {
+    database = Data_Wrap_Struct(cDB, 0, GeoIP_delete, gi);
+    rb_obj_call_init(database, 0, 0);
+  } else { 
+    rb_sys_fail("Problem opening database");
+  }
+  return database; 
+}
+
+/* helper  */
+void rb_hash_sset(VALUE hash, const char *str, VALUE v) {
+  rb_hash_aset(hash, ID2SYM(rb_intern(str)), v);
+}
+
+VALUE rb_record_to_hash (GeoIPRecord *record) 
+{
+  VALUE hash = rb_hash_new();
+
+  if(record->country_code)
+    rb_hash_sset(hash, "country_code", rb_str_new2(record->country_code));
+  if(record->country_code3)
+    rb_hash_sset(hash, "country_code3", rb_str_new2(record->country_code3));
+  if(record->country_name)
+    rb_hash_sset(hash, "country_name", rb_str_new2(record->country_name));
+  if(record->region)
+    rb_hash_sset(hash, "region", rb_str_new2(record->region));
+  if(record->city)
+    rb_hash_sset(hash, "city", rb_str_new2(record->city));
+  if(record->postal_code)
+    rb_hash_sset(hash, "postal_code", rb_str_new2(record->postal_code));
+  if(record->latitude)
+    rb_hash_sset(hash, "latitude", rb_float_new((double)record->latitude));
+  if(record->longitude)
+    rb_hash_sset(hash, "longitude", rb_float_new((double)record->longitude));
+  if(record->dma_code)
+    rb_hash_sset(hash, "dma_code", INT2NUM(record->dma_code));
+  if(record->area_code)
+    rb_hash_sset(hash, "area_code", INT2NUM(record->area_code));
+  
+  return hash;
+}
+
+/* Pass this function an IP address as a string, it will return a hash
+ * containing all the information that the database knows about the IP
+ *    db.look_up('24.24.24.24') 
+ *    => {:city=>"Ithaca", :latitude=>42.4277992248535, 
+ *        :country_code=>"US", :longitude=>-76.4981994628906, 
+ *        :country_code3=>"USA", :dma_code=>555, 
+ *        :country_name=>"United States", :area_code=>607, 
+ *        :region=>"NY"} 
+ */ 
+VALUE rb_geoip_look_up(VALUE self, VALUE addr) {
+  GeoIP *gi;
+  GeoIPRecord *record = NULL;
+  VALUE hash = Qnil; 
+  
+  Check_Type(addr, T_STRING);
+  Data_Get_Struct(self, GeoIP, gi);
+  if(record = GeoIP_record_by_addr(gi, StringValuePtr(addr))) {
+    hash =  rb_record_to_hash(record); 
+    GeoIPRecord_delete(record);
+  }
+  return hash;
+}
+
+void Init_geoip_city ()
+{
+  VALUE mGeoIP = rb_define_module("GeoIPCity");
+
+  rb_geoip_memory = ID2SYM(rb_intern("memory")); 
+  rb_geoip_filesystem = ID2SYM(rb_intern("filesystem")); 
+  rb_geoip_index = ID2SYM(rb_intern("index")); 
+
+  cDB = rb_define_class_under(mGeoIP, "Database", rb_cObject);
+  rb_define_singleton_method(cDB, "new", rb_geoip_new, -1);
+  rb_define_method(cDB, "look_up", rb_geoip_look_up, 1);
+}

data/lib/geoip_city.rb

@@ -0,0 +1,6 @@
+require "geoip_city.bundle"
+require "geoip_city/version"
+
+module GeoipCity
+  # Your code goes here...
+end

data/lib/geoip_city/version.rb

@@ -0,0 +1,3 @@
+module GeoipCity
+  VERSION = "2.0.1"
+end

data/test/test.rb

@@ -0,0 +1,57 @@
+require "bundler/setup"
+
+require "test/unit"
+require "geoip_city"
+
+class GeoIPTest < Test::Unit::TestCase
+
+  def setup
+    ## Change me!
+    @dbfile = 'data/GeoLiteCity.dat'
+  end
+
+
+  def test_construction_default
+    db = GeoIPCity::Database.new(@dbfile)
+
+    assert_raises TypeError do
+      db.look_up(nil)
+    end
+
+    h = db.look_up('24.24.24.24')
+    assert_kind_of Hash, h
+    assert_equal 'East Syracuse', h[:city]
+    assert_equal 'United States', h[:country_name]
+  end
+
+  def test_construction_index
+    db = GeoIPCity::Database.new(@dbfile, :index)
+    h = db.look_up('24.24.24.24')
+    assert_equal 'East Syracuse', h[:city]
+  end
+
+  def test_construction_filesystem
+    db = GeoIPCity::Database.new(@dbfile, :filesystem)
+    h = db.look_up('24.24.24.24')
+    assert_equal 'East Syracuse', h[:city]
+  end
+
+  def test_construction_memory
+    db = GeoIPCity::Database.new(@dbfile, :memory)
+    h = db.look_up('24.24.24.24')
+    assert_equal 'East Syracuse', h[:city]
+  end
+
+  def test_construction_filesystem_check
+    db = GeoIPCity::Database.new(@dbfile, :filesystem, true)
+    h = db.look_up('24.24.24.24')
+    assert_equal 'East Syracuse', h[:city]
+  end
+
+  def test_bad_db_file
+    assert_raises Errno::ENOENT do
+      GeoIPCity::Database.new('/blah')
+    end
+  end
+
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: geoip_city19
+version: !ruby/object:Gem::Version
+  version: 2.0.1
+  prerelease: 
+platform: ruby
+authors:
+- ry dahl
+- Chris Kraybill
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby 1.9 library provides a binding to the C library for, given an IP
+  address, return a JSON hash of best-guess geographical data
+email:
+- ry@tinyclouds.org
+- ckraybill@gmail.com
+executables: []
+extensions:
+- ext/geoip_city/extconf.rb
+extra_rdoc_files:
+- README
+- ext/geoip_city/geoip_city.c
+files:
+- lib/geoip_city/version.rb
+- lib/geoip_city.rb
+- ext/geoip_city/geoip_city.c
+- ext/geoip_city/extconf.rb
+- README
+- test/test.rb
+homepage: https://github.com/ckraybill/geoip_city
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 3476083723586382020
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 3476083723586382020
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A Binding to the GeoIP C library for Ruby 19
+test_files:
+- test/test.rb