cdamian-geoip_city 0.2.2

data/README.md

@@ -0,0 +1,108 @@
+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
+    # => {: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.
+
+  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/cdamian-geoip_city.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{cdamian-geoip_city}
+  s.version = "0.2.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["ry dahl"]
+  s.date = %q{2008-03-04}
+  s.email = %q{ry@tinyclouds.org}
+  s.extensions = ["extconf.rb"]
+  s.files = Dir.glob('**/*')
+  s.homepage = %q{http://github.com/ry/geoip-city}
+  s.require_paths = ["."]
+  s.rubygems_version = %q{1.6.2}
+  s.summary = %q{A Binding to the GeoIP C library}
+  s.test_files = ["test.rb"]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+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,178 @@
+/* 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>
+
+#ifdef HAVE_RUBY_ENCODING_H
+#include <ruby/encoding.h>
+static rb_encoding *utf8Encoding;
+#endif
+
+static VALUE cDB;
+static VALUE rb_geoip_memory;
+static VALUE rb_geoip_filesystem;
+static VALUE rb_geoip_index;
+
+#ifdef HAVE_RUBY_ENCODING_H
+#define ASSOCIATE_ENCODING(str) \
+  rb_enc_associate(str, utf8Encoding);  \
+  if (default_internal_enc) { \
+    str = rb_str_export_to_enc(str, default_internal_enc); \
+  }
+#else
+#define ASSOCIATE_ENCODING(str)
+#endif
+
+/* 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();
+#ifdef HAVE_RUBY_ENCODING_H
+  rb_encoding *default_internal_enc = rb_default_internal_encoding();
+#endif
+
+  if(record->country_code) {
+    VALUE str = rb_str_new2(record->country_code);
+    ASSOCIATE_ENCODING(str);
+    rb_hash_sset(hash, "country_code", str);
+  }
+
+  if(record->country_code3) {
+    VALUE str = rb_str_new2(record->country_code3);
+    ASSOCIATE_ENCODING(str);
+    rb_hash_sset(hash, "country_code3", str);
+  }
+
+  if(record->country_name) {
+    VALUE str = rb_str_new2(record->country_name);
+    ASSOCIATE_ENCODING(str);
+    rb_hash_sset(hash, "country_name", str);
+  }
+
+  if(record->region) {
+    VALUE str = rb_str_new2(record->region);
+    ASSOCIATE_ENCODING(str);
+    rb_hash_sset(hash, "region", str);
+  }
+
+  if(record->city) {
+    VALUE str = rb_str_new2(record->city);
+    ASSOCIATE_ENCODING(str);
+    rb_hash_sset(hash, "city", str);
+  }
+
+  if(record->postal_code)  {
+    VALUE str = rb_str_new2(record->city);
+    ASSOCIATE_ENCODING(str);
+    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);
+
+#ifdef HAVE_RUBY_ENCODING_H
+  utf8Encoding = rb_utf8_encoding();
+#endif
+}

data/test.rb

@@ -0,0 +1,70 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/geoip_city'
+require 'rubygems'
+
+class GeoIPTest < Test::Unit::TestCase
+
+  def setup
+    @dbfile = ENV['GEOIP_DB'] || 'GeoIPCity.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 '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 'Syracuse', h[:city]
+  end
+
+  def test_construction_filesystem
+    db = GeoIPCity::Database.new(@dbfile, :filesystem)
+    h = db.look_up('24.24.24.24')
+    assert_equal 'Syracuse', h[:city]
+  end
+
+  def test_construction_memory
+    db = GeoIPCity::Database.new(@dbfile, :memory)
+    h = db.look_up('24.24.24.24')
+    assert_equal '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 'Syracuse', h[:city]
+  end
+
+  def test_bad_db_file
+    assert_raises Errno::ENOENT do
+      GeoIPCity::Database.new('/blah')
+    end
+  end
+
+  if defined? Encoding
+    def test_string_encoding_support
+      Encoding.default_internal = nil
+      db = GeoIPCity::Database.new(@dbfile, :index)
+      h = db.look_up('24.24.24.24')
+      assert_equal Encoding.find('utf-8'), h[:city].encoding
+
+      Encoding.default_internal = Encoding.find('us-ascii')
+      db2 = GeoIPCity::Database.new(@dbfile, :index)
+      h2 = db2.look_up('24.24.24.24')
+      assert_equal Encoding.find('us-ascii'), h2[:city].encoding
+    end
+  end
+
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification 
+name: cdamian-geoip_city
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.2.2
+platform: ruby
+authors: 
+- ry dahl
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-03-04 00:00:00 -02:00
+default_executable: 
+dependencies: []
+
+description: 
+email: ry@tinyclouds.org
+executables: []
+
+extensions: 
+- extconf.rb
+extra_rdoc_files: []
+
+files: 
+- cdamian-geoip_city.gemspec
+- Rakefile
+- geoip_city.c
+- README.md
+- test.rb
+- extconf.rb
+has_rdoc: true
+homepage: http://github.com/ry/geoip-city
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- .
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 2
+summary: A Binding to the GeoIP C library
+test_files: 
+- test.rb