bitium-geoip-c 0.8.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2852d7ce55698d783c1f10d714dd2e37cf8780ab
+  data.tar.gz: 3d75afaf70a65129fcc1e9a1079f25255d12a589
+SHA512:
+  metadata.gz: f922e7d7785f57a25e1ddc3b89ea2f56f8667d3e8db5d771acd05676f44eb2de02879e4e00a763f0e4349af7bd5316dfd125ad12520efe86396f6fd9e76c3bd8
+  data.tar.gz: 7256508bb9da37cbfdbc18f631c4e90165deb8a395a6a4b40fc9bdad312210f86de264955caa1c1c13c52103162c29dc7c1209653100a915df10520c41090ee2

data/README.md

@@ -0,0 +1,160 @@
+Ruby GeoIP Bindings
+=======================
+
+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'
+    db = GeoIP::City.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 arguments to database initializer.
+
+  1. The first argument is the filename of the GeoIPCity.dat file 
+
+  2. 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` -- (Default.) Load database into memory, faster performance but uses more memory.
+
+  3. 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 
+
+    GeoIP::City.new(dbfile, :filesystem, true)
+
+Usage for Organization Search
+-----------------------------
+
+    require 'geoip'
+    db = GeoIP::Organization.new('/opt/GeoIP/share/GeoIP/GeoIPOrg.dat')
+    db.look_up('24.24.24.24')
+    # => {:name=>"Road Runner"}
+
+The name is the only data available for Organizations.
+
+Install
+-------
+
+Some variation of the following should work.
+
+  1. Install the GeoCity C library. You can get it from
+  [MaxMind](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
+
+    On Mac OS X, you can install using [homebrew](http://github.com/mxcl/homebrew):
+
+        brew install geoip
+
+    Linux platforms utilizing Apt have several packages available:
+
+        geoip-bin
+        geoip-database
+        libgeoip-dev
+
+  2. Now install the `geoip` gem
+
+        gem install geoip-c -- --with-geoip-dir=/opt/GeoIP
+
+    Alternatively, if you installed libgeoip using homebrew:
+
+        gem install geoip-c
+
+  3. Download the GeoLite City database file in binary format at http://www.maxmind.com/app/geolitecity
+     Maybe this [direct link](http://www.maxmind.com/download/geoip/database/GeoLiteCity.dat.gz) will work.
+     I put this file in 
+
+        /opt/GeoIP/share/GeoIP/GeoLiteCity.dat
+
+    If you installed libgeoip using homebrew then put it in:
+
+        /usr/local/share/GeoIP/GeoLiteCity.dat
+
+     If you are a paying customer, you will download the files required below:
+
+     [MaxMind Customer Downloads](http://www.maxmind.com/app/download_files)
+
+     You will want to get the City Rev1 data file and Organization files at minimum.
+
+  4. Use it!
+
+     See above for usage details.
+
+Hints
+-----
+
+  1. Might need to set
+
+        export ARCHFLAGS="-arch i386"
+
+    to be able to compile the gem.
+
+    Example:
+
+        env ARCHFLAGS="-arch i386" gem install geoip-c -- --with-geoip-dir=/opt/GeoIP
+
+  2. You might find [this shell script](http://github.com/grimen/my_shell_scripts/blob/8cf04cb6829e68a47f2d6f9d9e057766ea72beb4/install_geoip-city.sh)
+     helpful to install the C library.
+
+Links
+-----
+
+This iteration of the library is based on the hard work of Ryah Dahl (ry@tinyclouds.org). You can find the original RDocs and Git Repo below:
+
+[rdocs](http://geoip-city.rubyforge.org/)
+[git repo](https://github.com/ry/geoip-city/tree)
+
+Thanks
+------
+
+Special appreciation and thanks belongs to Ry Dahl for his initial work on this library.
+
+Many thanks to our contributors:
+
+* Charles Brian Quinn ([seebq](https://github.com/seebq))
+* Michael Sheakoski
+* Silvio Quadri
+* Leonardo Almeida ([leogalmeida](https://github.com/leogalmeida))
+
+License
+-------
+Copyright (C) 2007--2009 Ryah Dahl (ry@tinyclouds.org), Matt Todd (mtodd@highgroove.com)
+
+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.

data/Rakefile

@@ -0,0 +1,55 @@
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+task :default => [:compile, :test]
+
+CLEAN.add "geoip.{o,bundle,so,obj,pdb,lib,def,exp}"
+CLOBBER.add ['Makefile', 'mkmf.log','doc']
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_files.add ['README', 'geoip.c']
+  rdoc.main = "README" # page to start on
+  rdoc.rdoc_dir = 'doc/' # rdoc output folder
+end
+
+Rake::TestTask.new do |t|
+  t.test_files = ['test.rb']
+  t.verbose = true
+end
+
+spec = Gem::Specification.new do |s|
+  s.name              = 'geoip-c'
+  s.version           = "0.8.1"
+
+  s.authors           = ['Ryah Dahl', 'Matt Todd', 'Andy Lindeman']
+  s.email             = ['alindeman@gmail.com', 'mtodd@highgroove.com']
+
+  s.summary           = "A Binding to the GeoIP C library"
+  s.description       = 'Generic GeoIP lookup tool. Based on the geoip_city RubyGem by Ryah Dahl'
+  s.homepage          = "http://github.com/mtodd/geoip"
+
+  s.files             = ["Rakefile", "extconf.rb", "test.rb", "geoip.c", "README.md"]
+  s.test_files        = ['test.rb']
+  s.extensions        = ['extconf.rb']
+  s.require_path      = '.'
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.need_tar = true
+  p.gem_spec = spec
+end
+
+desc 'compile the extension'
+task(:compile => 'Makefile') { sh 'make' }
+file('Makefile' => "geoip.c") { ruby 'extconf.rb' }
+
+task :install => [:gem] do
+  `env ARCHFLAGS="-arch i386" gem install pkg/geoip-c-0.5.0.gem -- --with-geoip-dir=/usr/local/GeoIP`
+end
+
+task(:webpage) do
+  sh 'scp -r doc/* rydahl@rubyforge.org:/var/www/gforge-projects/geoip-city/'
+end

data/extconf.rb

@@ -0,0 +1,19 @@
+require 'mkmf'
+
+dir_config("geoip")
+
+unless have_func('iconv_open', 'iconv.h') or have_library('iconv', 'iconv_open', 'iconv.h')
+  abort "you must have iconv library installed!"
+end
+
+if have_library('GeoIP', 'GeoIP_record_by_ipnum') and have_header('GeoIPCity.h')
+  # Defines HAVE_GEOIP_ADDR_TO_NUM
+  have_func('GeoIP_addr_to_num', 'GeoIP.h')
+
+  # Defines HAVE_GEOIP_NUM_TO_ADDR
+  have_func('GeoIP_num_to_addr', 'GeoIP.h')
+
+  create_makefile('geoip')
+else
+  abort("you must have geoip c library installed!")
+end

data/geoip.c

@@ -0,0 +1,408 @@
+/* ry dahl <ry@tinyclouds.org> May 21, 2007 */
+/* Matt Todd <mtodd@highgroove.com> June 4, 2009 */
+/* 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>
+#include "iconv.h"
+
+static VALUE mGeoIP;
+static VALUE mGeoIP_City;
+static VALUE mGeoIP_Country;
+static VALUE mGeoIP_Organization;
+static VALUE mGeoIP_ISP;
+static VALUE mGeoIP_NetSpeed;
+static VALUE mGeoIP_Domain;
+static VALUE mGeoIP_TimeZone;
+static VALUE rb_geoip_memory;
+static VALUE rb_geoip_filesystem;
+static VALUE rb_geoip_index;
+
+#ifndef HAVE_GEOIP_ADDR_TO_NUM
+  // Support geoip <= 1.4.6
+  #define GeoIP_addr_to_num _GeoIP_addr_to_num
+#endif
+
+#ifndef HAVE_GEOIP_NUM_TO_ADDR
+  // Support geoip <= 1.4.6
+
+  // Fixes a bug with 64bit architectures where this delcaration doesn't exist
+  // in the GeoIP library causing segmentation faults.
+  char *_GeoIP_num_to_addr(GeoIP* gi, unsigned long ipnum);
+  #define GeoIP_num_to_addr(ipnum) _GeoIP_num_to_addr(NULL, ipnum)
+#endif
+
+/* helpers */
+void rb_hash_sset(VALUE hash, const char *str, VALUE v) {
+  rb_hash_aset(hash, ID2SYM(rb_intern(str)), v);
+}
+
+/*  pulled from http://blog.inventic.eu/?p=238 and
+    https://github.com/Vagabond/erlang-iconv/blob/master/c_src/iconv_drv.c */
+static VALUE encode_to_utf8_and_return_rb_str(char *value) {
+  char dst[BUFSIZ];
+  if (value==NULL) {
+    return rb_str_new2("");
+  }
+  size_t srclen = strlen(value);
+  size_t dstlen = srclen * 2;
+
+  char * pIn = value;
+  char * pOut = ( char*)dst;
+
+  iconv_t cd = iconv_open("UTF-8","ISO-8859-1");
+  iconv(cd, &pIn, &srclen, &pOut, &dstlen);
+  iconv_close(cd);
+
+  *(pOut++) = 0; /* ensure we null terminate */
+
+  return rb_str_new2(dst);
+}
+
+int check_load_option(VALUE load_option) {
+  if(load_option == rb_geoip_memory) {
+    return GEOIP_MEMORY_CACHE;
+  } else if(load_option == rb_geoip_filesystem) {
+    return GEOIP_STANDARD;
+  } else if(load_option == rb_geoip_index) {
+    return GEOIP_INDEX_CACHE;
+  } else {
+    rb_raise(rb_eTypeError, "the second option must be :memory, :filesystem, or :index");
+    return Qnil;
+  }
+}
+
+/* Generic initializer */
+static VALUE rb_geoip_database_new(VALUE mGeoIP_Database_Class, 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(flag = check_load_option(load_option)) flag;
+
+  if(RTEST(check_cache)) flag |= GEOIP_CHECK_CACHE;
+
+  if(gi = GeoIP_open(StringValuePtr(filename), flag)) {
+    database = Data_Wrap_Struct(mGeoIP_Database_Class, 0, GeoIP_delete, gi);
+    rb_obj_call_init(database, 0, 0);
+  } else {
+    rb_sys_fail("Problem opening database");
+  }
+  return database;
+}
+
+/* Generic, single-value look up method */
+static VALUE generic_single_value_lookup_response(char *key, char *value)
+{
+  VALUE result = rb_hash_new();
+  if(value) {
+    rb_hash_sset(result, key, encode_to_utf8_and_return_rb_str(value));
+    return result;
+  } else {
+    return Qnil;
+  }
+}
+
+/* GeoIP::City ***************************************************************/
+
+VALUE rb_city_record_to_hash(GeoIPRecord *record)
+{
+  VALUE hash = rb_hash_new();
+
+  if(record->country_code)
+    rb_hash_sset(hash, "country_code", encode_to_utf8_and_return_rb_str(record->country_code));
+  if(record->country_code3)
+    rb_hash_sset(hash, "country_code3", encode_to_utf8_and_return_rb_str(record->country_code3));
+  if(record->country_name)
+    rb_hash_sset(hash, "country_name", encode_to_utf8_and_return_rb_str(record->country_name));
+  if(record->region) {
+    rb_hash_sset(hash, "region", encode_to_utf8_and_return_rb_str(record->region));
+    rb_hash_sset(hash, "region_name", encode_to_utf8_and_return_rb_str(GeoIP_region_name_by_code(record->country_code, record->region)));
+  }
+  if(record->city)
+    rb_hash_sset(hash, "city", encode_to_utf8_and_return_rb_str(record->city));
+  if(record->postal_code)
+    rb_hash_sset(hash, "postal_code", encode_to_utf8_and_return_rb_str(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;
+}
+
+/* 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_city_new(int argc, VALUE *argv, VALUE self)
+{
+  return rb_geoip_database_new(mGeoIP_City, argc, argv, self);
+}
+
+/* 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_city_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_city_record_to_hash(record);
+    GeoIPRecord_delete(record);
+  }
+  return hash;
+}
+
+/* GeoIP::Country ************************************************************/
+
+/* GeoIP::Country.new('/path/to/GeoIPCountry.dat')
+ * load_option is not required for this database because it is ignored.
+ */
+static VALUE rb_geoip_country_new(int argc, VALUE *argv, VALUE self)
+{
+  return rb_geoip_database_new(mGeoIP_Country, argc, argv, self);
+}
+
+/* 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')
+ *    => {:country_code=>"US",
+ *        :country_code3=>"USA",
+ *        :country_name=>"United States"}
+ */
+VALUE rb_geoip_country_look_up(VALUE self, VALUE addr) {
+  GeoIP *gi;
+  VALUE hash = Qnil;
+  int country_id;
+  
+  Check_Type(addr, T_STRING);
+  Data_Get_Struct(self, GeoIP, gi);
+  country_id = GeoIP_id_by_addr(gi, StringValuePtr(addr));
+  if(country_id < 1) return Qnil;
+  
+  hash = rb_hash_new();
+  rb_hash_sset(hash, "country_code", rb_str_new2(GeoIP_country_code[country_id]));
+  rb_hash_sset(hash, "country_code3", rb_str_new2(GeoIP_country_code3[country_id]));
+  rb_hash_sset(hash, "country_name", rb_str_new2(GeoIP_country_name[country_id]));
+  
+  return hash;
+}
+
+/* GeoIP::Organization *******************************************************/
+
+/* GeoIP::Organization.new('/path/to/GeoIPOrg.dat', load_option)
+ * load_option can be:
+ * * :memory - load the data into memory, fastest (default)
+ * * :filesystem - look up from filesystem, least memory intensive
+ * * :index - stores in memory most recent queries
+ *
+ */
+static VALUE rb_geoip_org_new(int argc, VALUE *argv, VALUE self)
+{
+  return rb_geoip_database_new(mGeoIP_Organization, argc, argv, self);
+}
+
+/* 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') 
+ *    => {:name => "Road Runner"}
+ */ 
+VALUE rb_geoip_org_look_up(VALUE self, VALUE addr) {
+  GeoIP *gi;
+  Check_Type(addr, T_STRING);
+  Data_Get_Struct(self, GeoIP, gi);
+  return generic_single_value_lookup_response("name", GeoIP_name_by_addr(gi, StringValuePtr(addr)));
+}
+
+/* GeoIP::ISP *******************************************************/
+
+/* GeoIP::ISP.new('/path/to/GeoIPISP.dat', load_option)
+ * load_option can be:
+ * * :memory - load the data into memory, fastest (default)
+ * * :filesystem - look up from filesystem, least memory intensive
+ * * :index - stores in memory most recent queries
+ *
+ */
+static VALUE rb_geoip_isp_new(int argc, VALUE *argv, VALUE self)
+{
+  return rb_geoip_database_new(mGeoIP_ISP, argc, argv, self);
+}
+
+/* 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')
+ *    => {:isp => "Road Runner"}
+ */
+VALUE rb_geoip_isp_look_up(VALUE self, VALUE addr) {
+  GeoIP *gi;
+  Check_Type(addr, T_STRING);
+  Data_Get_Struct(self, GeoIP, gi);
+  return generic_single_value_lookup_response("isp", GeoIP_name_by_addr(gi, StringValuePtr(addr)));
+}
+
+/* GeoIP::NetSpeed *******************************************************/
+
+/* GeoIP::NetSpeed.new('/path/to/GeoIPNetSpeed.dat', load_option)
+ * load_option can be:
+ * * :memory - load the data into memory, fastest (default)
+ * * :filesystem - look up from filesystem, least memory intensive
+ * * :index - stores in memory most recent queries
+ *
+ */
+static VALUE rb_geoip_netspeed_new(int argc, VALUE *argv, VALUE self)
+{
+  return rb_geoip_database_new(mGeoIP_NetSpeed, argc, argv, self);
+}
+
+/* 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')
+ *    => {:netspeed => "Cable/DSL"}
+ */
+VALUE rb_geoip_netspeed_look_up(VALUE self, VALUE addr) {
+  GeoIP *gi;
+  Check_Type(addr, T_STRING);
+  Data_Get_Struct(self, GeoIP, gi);
+  return generic_single_value_lookup_response("netspeed", GeoIP_name_by_addr(gi, StringValuePtr(addr)));
+}
+
+/* GeoIP::Domain *******************************************************/
+
+/* GeoIP::Domain.new('/path/to/GeoIPDomain.dat', load_option)
+ * load_option can be:
+ * * :memory - load the data into memory, fastest (default)
+ * * :filesystem - look up from filesystem, least memory intensive
+ * * :index - stores in memory most recent queries
+ *
+ */
+static VALUE rb_geoip_domain_new(int argc, VALUE *argv, VALUE self)
+{
+  return rb_geoip_database_new(mGeoIP_Domain, argc, argv, self);
+}
+
+/* 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')
+ *    => {:domain => "rr.com"}
+ */
+VALUE rb_geoip_domain_look_up(VALUE self, VALUE addr) {
+  GeoIP *gi;
+  Check_Type(addr, T_STRING);
+  Data_Get_Struct(self, GeoIP, gi);
+  return generic_single_value_lookup_response("domain", GeoIP_name_by_addr(gi, StringValuePtr(addr)));
+}
+
+/* GeoIP::TimeZone *******************************************************/
+
+/* GeoIP::TimeZone.look_up(country, region)
+ */
+static VALUE rb_geoip_timezone_lookup(VALUE self, VALUE country, VALUE region)
+{
+  Check_Type(country, T_STRING);
+  Check_Type(region, T_STRING);
+
+  const char* tz = GeoIP_time_zone_by_country_and_region(
+      StringValuePtr(country), StringValuePtr(region));
+  return rb_str_new2(tz);
+}
+
+/* GeoIP *********************************************************************/
+
+/* Returns the numeric form of an IP address.
+ *
+ * For example:
+ * 24.24.24.24 => 404232216
+ *
+ * This is used in order to be able to perform searches in CSV versions of the
+ * data files or in SQL records if the data has been put there.
+ */
+VALUE rb_geoip_addr_to_num(VALUE self, VALUE addr) {
+  Check_Type(addr, T_STRING);
+  return UINT2NUM((unsigned int)GeoIP_addr_to_num(StringValuePtr(addr)));
+}
+
+
+VALUE rb_geoip_num_to_addr(VALUE self, VALUE num) {
+  VALUE num_type = TYPE(num);
+  switch(num_type) {
+    case T_FIXNUM: break;
+    case T_BIGNUM: break;
+    default: rb_raise(rb_eTypeError, "wrong argument type %s (expected Fixnum or Bignum)", rb_obj_classname(num));
+  }
+  return rb_str_new2((char*)GeoIP_num_to_addr((unsigned long)NUM2ULONG(num)));
+}
+
+void Init_geoip()
+{
+  mGeoIP = rb_define_module("GeoIP");
+
+  rb_geoip_memory = ID2SYM(rb_intern("memory"));
+  rb_geoip_filesystem = ID2SYM(rb_intern("filesystem"));
+  rb_geoip_index = ID2SYM(rb_intern("index"));
+
+  mGeoIP_City = rb_define_class_under(mGeoIP, "City", rb_cObject);
+  rb_define_singleton_method(mGeoIP_City, "new",      rb_geoip_city_new,      -1);
+  rb_define_method(          mGeoIP_City, "look_up",  rb_geoip_city_look_up,  1);
+
+  mGeoIP_Country = rb_define_class_under(mGeoIP, "Country", rb_cObject);
+  rb_define_singleton_method(mGeoIP_Country, "new",      rb_geoip_country_new,      -1);
+  rb_define_method(          mGeoIP_Country, "look_up",  rb_geoip_country_look_up,  1);
+
+  mGeoIP_Organization = rb_define_class_under(mGeoIP, "Organization", rb_cObject);
+  rb_define_singleton_method(mGeoIP_Organization, "new",     rb_geoip_org_new,     -1);
+  rb_define_method(          mGeoIP_Organization, "look_up", rb_geoip_org_look_up, 1);
+
+  mGeoIP_ISP = rb_define_class_under(mGeoIP, "ISP", rb_cObject);
+  rb_define_singleton_method(mGeoIP_ISP, "new",     rb_geoip_isp_new,     -1);
+  rb_define_method(          mGeoIP_ISP, "look_up", rb_geoip_isp_look_up, 1);
+
+  mGeoIP_NetSpeed = rb_define_class_under(mGeoIP, "NetSpeed", rb_cObject);
+  rb_define_singleton_method(mGeoIP_NetSpeed, "new",     rb_geoip_netspeed_new,     -1);
+  rb_define_method(          mGeoIP_NetSpeed, "look_up", rb_geoip_netspeed_look_up, 1);
+
+  mGeoIP_Domain = rb_define_class_under(mGeoIP, "Domain", rb_cObject);
+  rb_define_singleton_method(mGeoIP_Domain, "new",     rb_geoip_domain_new,     -1);
+  rb_define_method(          mGeoIP_Domain, "look_up", rb_geoip_domain_look_up, 1);
+
+  mGeoIP_TimeZone = rb_define_class_under(mGeoIP, "TimeZone", rb_cObject);
+  rb_define_singleton_method(mGeoIP_TimeZone, "look_up", rb_geoip_timezone_lookup, 2);
+
+  rb_define_singleton_method(mGeoIP, "addr_to_num", rb_geoip_addr_to_num, 1);
+  rb_define_singleton_method(mGeoIP, "num_to_addr", rb_geoip_num_to_addr, 1);
+}

data/test.rb

@@ -0,0 +1,175 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/geoip'
+require 'rubygems'
+# require 'ruby-debug'
+# Debugger.start
+
+CITY_DB = ENV.fetch("CITY", '/usr/local/GeoIP/share/GeoIP/GeoLiteCity.dat')
+ORG_DB  = ENV.fetch("ORG",  '/usr/local/GeoIP/share/GeoIP/GeoIPOrg.dat')
+
+class Test::Unit::TestCase
+
+  def assert_look_up(db, addr, field, value)
+    h = db.look_up(addr)
+    assert_equal value, h[field]
+    h
+  end
+
+end
+
+class GeoIPTest < Test::Unit::TestCase
+  
+  def setup
+    @ip = "24.24.24.24"
+    @ipnum = 16777216*24 + 65536*24 + 256*24 + 24
+    
+    @large_ip = "245.245.245.245"
+    @large_ipnum = 16777216*245 + 65536*245 + 256*245 + 245
+  end
+  
+  # addr_to_num
+  
+  def test_addr_to_num_converts_an_ip_to_an_ipnum
+    assert_equal @ipnum, GeoIP.addr_to_num(@ip)
+  end
+  
+  def test_addr_to_num_converts_large_ips_to_an_ipnum_correctly
+    assert_equal @large_ipnum, GeoIP.addr_to_num(@large_ip)
+  end
+  
+  def test_addr_to_num_expects_an_ip_string
+    assert_raises TypeError do 
+      GeoIP.addr_to_num(nil) 
+    end
+  end
+  
+  def test_addr_to_num_returns_zero_for_an_illformed_ip_string
+    assert_equal 0, GeoIP.addr_to_num("foo.bar")
+  end
+  
+  # num_to_addr
+  
+  def test_num_to_addr_converts_an_ipnum_to_an_ip
+    assert_equal @ip, GeoIP.num_to_addr(@ipnum)
+  end
+  
+  def test_num_to_addr_converts_large_ipnums_to_an_ip_correctly
+    assert_equal @large_ip, GeoIP.num_to_addr(@large_ipnum)
+  end
+  
+  def test_num_to_addr_expects_a_numeric_ip
+    assert_raises TypeError do
+      GeoIP.num_to_addr(nil)
+    end
+    assert_raises TypeError do
+      GeoIP.num_to_addr("foo.bar")
+    end
+  end
+  
+  # timezone
+
+  def test_tz_from_country_region
+    assert_equal 'America/New_York', GeoIP::TimeZone.look_up('US', 'NY')
+  end
+end
+
+class GeoIPCityTest < Test::Unit::TestCase
+  
+  def setup
+    ## Change me!
+    @dbfile = CITY_DB
+  end
+
+  def test_construction_default
+    db = GeoIP::City.new(@dbfile)
+    
+    assert_raises TypeError do 
+      db.look_up(nil) 
+    end
+    
+    h = db.look_up('24.24.24.24')
+    #debugger
+    assert_kind_of Hash, h
+    assert_equal 'New York', h[:city]
+    assert_equal 'United States', h[:country_name]
+  end
+
+  def test_construction_index
+    db = GeoIP::City.new(@dbfile, :index)
+    assert_look_up(db, '24.24.24.24', :city, 'New York')
+  end
+
+  def test_construction_filesystem
+    db = GeoIP::City.new(@dbfile, :filesystem)
+    assert_look_up(db, '24.24.24.24', :city, 'New York')
+  end
+
+  def test_construction_memory
+    db = GeoIP::City.new(@dbfile, :memory)
+    assert_look_up(db, '24.24.24.24', :city, 'New York')
+  end
+
+  def test_construction_filesystem_check
+    db = GeoIP::City.new(@dbfile, :filesystem, true)
+    assert_look_up(db, '24.24.24.24', :city, 'New York')
+  end
+
+  def test_bad_db_file
+    assert_raises Errno::ENOENT do
+      GeoIP::City.new('/supposed-to-fail')
+    end
+  end
+
+  def test_character_encoding_converted_to_utf8_first
+    db = GeoIP::City.new(@dbfile, :filesystem, true)
+    assert_look_up(db, '201.85.50.148', :city, 'São Paulo')
+  end
+
+end
+
+class GeoIPOrgTest < Test::Unit::TestCase
+  
+  def setup
+    ## Change me!
+    @dbfile = ORG_DB
+  end
+
+  def test_construction_default
+    db = GeoIP::Organization.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 'Road Runner', h[:name]
+  end
+
+  def test_construction_index
+    db = GeoIP::Organization.new(@dbfile, :index)
+    assert_look_up(db, '24.24.24.24', :name, 'Road Runner')
+  end
+
+  def test_construction_filesystem
+    db = GeoIP::Organization.new(@dbfile, :filesystem)
+    assert_look_up(db, '24.24.24.24', :name, 'Road Runner')
+  end
+
+  def test_construction_memory
+    db = GeoIP::Organization.new(@dbfile, :memory)
+    assert_look_up(db, '24.24.24.24', :name, 'Road Runner')
+  end
+
+  def test_construction_filesystem_check
+    db = GeoIP::Organization.new(@dbfile, :filesystem, true)
+    assert_look_up(db, '24.24.24.24', :name, 'Road Runner')
+  end
+
+  def test_bad_db_file
+    assert_raises Errno::ENOENT do
+      GeoIP::Organization.new('/supposed-to-fail')
+    end
+  end
+
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: bitium-geoip-c
+version: !ruby/object:Gem::Version
+  version: 0.8.1
+platform: ruby
+authors:
+- Ryan Dahl
+- Matt Todd
+- Charles Brian Quinn
+- Michael Sheakoski
+- Silvio Quadri
+- Andy Lindeman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-31 00:00:00.000000000 Z
+dependencies: []
+description: Generic GeoIP lookup tool. Based on the geoip_city RubyGem by Ryan Dahl
+email:
+- alindeman@gmail.com
+- mtodd@highgroove.com
+executables: []
+extensions:
+- extconf.rb
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- extconf.rb
+- geoip.c
+- test.rb
+homepage: http://github.com/mtodd/geoip
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- "."
+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 Binding to the GeoIP C library
+test_files:
+- test.rb
+has_rdoc: