acamargo-geoip_city 1.0

data/README.md

@@ -0,0 +1,110 @@
+Ruby GeoIPCity 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_city'
+    db = GeoIPCity::Database.new('/opt/GeoIP/share/GeoIP/GeoLiteCity.dat')
+    result = db.look_up('24.24.24.24')
+    p result 
+    # => {:country_code3=>"USA",
+    #     :latitude=>40.6763000488281,
+    #     :country_name=>"United States",
+    #     :longitude=>-73.7751998901367,
+    #     :region=>"NY",
+    #     :dma_code=>501,
+    #     :region_name=>"New York",
+    #     :area_code=>718,
+    #     :city=>"Jamaica",
+    #     :country_code=>"US",
+    #     :postal_code=>"11434"}
+
+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 acamargo-geoip_city -s http://gemcutter.org -- --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.
+
+  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
+-----
+
+[rdocs](http://geoip-city.rubyforge.org/)
+
+[git repo](https://github.com/ry/geoip-city/tree)
+
+License 
+-------
+Copyright (C) 2007--2009 Ryan Dahl (ry@tinyclouds.org)
+
+I give permission for you to do whatever you'd like to do with this software.

data/Rakefile

@@ -0,0 +1,47 @@
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+task :default => [:compile, :test]
+
+CLEAN.add "geoip_city.{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_city.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_city'
+  s.author            = 'ry dahl'
+  s.email             = 'ry@tinyclouds.org'
+  s.version           = "0.2.0"
+  s.summary           = "A Binding to the GeoIP C library"
+  s.homepage          = "http://geoip_city.rubyforge.org"
+  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_city.c") { ruby 'extconf.rb' }
+
+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_city')
+else
+  abort("you must have geoip c library installed!")
+end

data/geoip_city.c

@@ -0,0 +1,134 @@
+/* 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(STR2CSTR(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->country_code && record->region)
+    rb_hash_sset(hash, "region_name", rb_str_new2(GeoIP_region_name_by_code(record->country_code, 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", :region_name=>"New York"} 
+ */ 
+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, STR2CSTR(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/test.rb

@@ -0,0 +1,61 @@
+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 'Jamaica', h[:city]
+    assert_equal 'New York', h[:region_name]
+    assert_equal 'NY', h[:region]
+    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 'Jamaica', h[:city]
+  end
+
+  def test_construction_filesystem
+    db = GeoIPCity::Database.new(@dbfile, :filesystem)
+    h = db.look_up('24.24.24.24')
+    assert_equal 'Jamaica', h[:city]
+  end
+
+  def test_construction_memory
+    db = GeoIPCity::Database.new(@dbfile, :memory)
+    h = db.look_up('24.24.24.24')
+    assert_equal 'Jamaica', 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 'Jamaica', 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: acamargo-geoip_city
+version: !ruby/object:Gem::Version 
+  version: "1.0"
+platform: ruby
+authors: 
+- "Andr\xC3\xA9 Camargo"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-03 00:00:00 -02:00
+default_executable: 
+dependencies: []
+
+description: Generic GeoIP lookup tool. Based on the geoip_city RubyGem by Ryan Dahl
+email: andre@boaideia.inf.br
+executables: []
+
+extensions: 
+- extconf.rb
+extra_rdoc_files: []
+
+files: 
+- extconf.rb
+- geoip_city.c
+- Rakefile
+- README.md
+- test.rb
+has_rdoc: true
+homepage: http://github.com/acamargo/geoip-city
+licenses: []
+
+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.3.5
+signing_key: 
+specification_version: 3
+summary: A Ruby binding to the GeoIP C Library
+test_files: 
+- test.rb