mtodd-geoip 0.5.0

data/README.md

@@ -0,0 +1,105 @@
+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::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 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 
+
+    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
+  [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
+
+  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 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
+
+  4. Use it!
+
+Hints
+-----
+
+  1. Might need to set
+
+       export ARCHFLAGS="-arch i386"
+
+     to be able to compile the gem.
+
+     Example:
+
+        sudo env ARCHFLAGS="-arch i386" gem install geoip_city -- --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.
+
+License 
+-------
+Copyright (C) 2007--2009 Ryan Dahl (ry@tinyclouds.org), Matt Todd (mtodd@highgroove.com)
+
+I give permission for you to do whatever you'd like to do with this software.

data/Rakefile

@@ -0,0 +1,52 @@
+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'
+  s.description       = 'Generic GeoIP lookup tool. Based on the geoip_city RubyGem by Ryan Dahl'
+  s.author            = 'Matt Todd'
+  s.email             = 'mtodd@highgroove.com'
+  s.version           = "0.5.0"
+  s.summary           = "A Binding to the GeoIP C library"
+  s.homepage          = "http://github.com/mtodd/geoip"
+  s.files             = FileList['Rakefile', '*.rb', '*.c', 'README*']
+  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
+  `sudo env ARCHFLAGS="-arch i386" gem install pkg/geoip-0.5.0.gem -- --with-geoip-dir=/opt/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,9 @@
+require 'mkmf'
+
+dir_config("geoip")
+
+if have_library('GeoIP', 'GeoIP_record_by_ipnum') and have_header('GeoIPCity.h')
+  create_makefile('geoip')
+else
+  abort("you must have geoip c library installed!")
+end

data/geoip.c

@@ -0,0 +1,233 @@
+/* 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 mGeoIP;
+static VALUE mGeoIP_City;
+static VALUE mGeoIP_Organization;
+static VALUE rb_geoip_memory;
+static VALUE rb_geoip_filesystem;
+static VALUE rb_geoip_index;
+
+/* helper  */
+void rb_hash_sset(VALUE hash, const char *str, VALUE v) {
+  rb_hash_aset(hash, ID2SYM(rb_intern(str)), v);
+}
+
+/* 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", 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;
+}
+
+/* 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)
+{
+  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(STR2CSTR(filename), flag)) {
+    database = Data_Wrap_Struct(mGeoIP_City, 0, GeoIP_delete, gi);
+    rb_obj_call_init(database, 0, 0);
+  } else { 
+    rb_sys_fail("Problem opening database");
+  }
+  return database; 
+}
+
+/* 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, STR2CSTR(addr))) {
+    hash =  rb_city_record_to_hash(record);
+    GeoIPRecord_delete(record);
+  }
+  return hash;
+}
+
+/* GeoIP::Organization *******************************************************/
+
+// VALUE rb_org_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;
+// }
+
+static VALUE rb_geoip_org_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(STR2CSTR(filename), flag)) {
+    database = Data_Wrap_Struct(mGeoIP_Organization, 0, GeoIP_delete, gi);
+    rb_obj_call_init(database, 0, 0);
+  } else { 
+    rb_sys_fail("Problem opening database");
+  }
+  return database; 
+}
+
+/* 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') 
+ *    => {} 
+ */ 
+VALUE rb_geoip_org_look_up(VALUE self, VALUE addr) {
+  GeoIP *gi;
+  GeoIPRecord *record = NULL;
+  VALUE hash = rb_hash_new();
+  char * name = NULL;
+  
+  Check_Type(addr, T_STRING);
+  Data_Get_Struct(self, GeoIP, gi);
+  if(name = GeoIP_org_by_addr(gi, STR2CSTR(addr))) {
+    rb_hash_sset(hash, "name", rb_str_new2(name));
+  }
+  return hash;
+}
+
+/* GeoIP *********************************************************************/
+
+/* module GeoIP
+ *   class City; end
+ *   class Organization; end
+ * end
+ */
+
+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_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);
+}

data/test.rb

@@ -0,0 +1,59 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/geoip_city'
+require 'rubygems'
+require 'ruby-debug'
+Debugger.start
+
+class GeoIPTest < Test::Unit::TestCase
+  
+  def setup
+    ## Change me!
+    @dbfile = '/opt/GeoIP-1.4.2/share/GeoIP/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')
+    #debugger
+    assert_kind_of Hash, h
+    assert_equal 'Ithaca', 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 'Ithaca', h[:city]
+  end
+
+  def test_construction_filesystem
+    db = GeoIPCity::Database.new(@dbfile, :filesystem)
+    h = db.look_up('24.24.24.24')
+    assert_equal 'Ithaca', h[:city]
+  end
+
+  def test_construction_memory
+    db = GeoIPCity::Database.new(@dbfile, :memory)
+    h = db.look_up('24.24.24.24')
+    assert_equal 'Ithaca', 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 'Ithaca', h[:city]
+  end
+
+  def test_bad_db_file
+    assert_raises Errno::ENOENT do
+      GeoIPCity::Database.new('/blah')
+    end
+  end
+  
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification 
+name: mtodd-geoip
+version: !ruby/object:Gem::Version 
+  version: 0.5.0
+platform: ruby
+authors: 
+- Ryan Dahl
+- Matt Todd
+- Charles Brian Quinn
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-16 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Generic GeoIP lookup tool. Based on the geoip_city RubyGem by Ryan Dahl
+email: mtodd@highgroove.com
+executables: []
+
+extensions: 
+- extconf.rb
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- extconf.rb
+- test.rb
+- geoip.c
+- README.md
+has_rdoc: false
+homepage: http://github.com/mtodd/geoip
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- .
+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 Binding to the GeoIP C library
+test_files: 
+- test.rb