ffi-geoip 0.0.1

data/lib/ffi-geoip/base.rb

@@ -0,0 +1,68 @@
+# encoding: UTF-8
+
+module GeoIP
+  module Base
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def release(ptr)
+        FFIGeoIP.GeoIP_delete(ptr)
+      end
+    end
+
+    def value_to_addr(value)
+      case value
+        when Numeric
+          GeoIP.num_to_addr(value)
+
+        when /^\d+\.\d+\.\d+\.\d+$/
+          value
+      end
+    end
+
+    private
+      def initialize_geoip(file, load_option = nil, check_cache = nil)
+        if load_option.nil?
+          load_option = :memory
+        end
+
+        flags = check_load_option(load_option) or
+          raise TypeError.new("the second option must be :memory, :filesystem, or :index")
+
+        if check_cache
+          flags |= GeoIPOptions[:check_cache]
+        end
+
+        if !File.exists?(file)
+          raise enoent_exception
+        else
+          @ptr = FFI::AutoPointer.new(
+            FFIGeoIP.GeoIP_open(file, flags),
+            self.class.method(:release)
+          )
+
+          if @ptr.null?
+            raise_enoent
+          end
+        end
+      end
+
+      def enoent_exception
+        Errno::ENOENT.new("Problem opening database")
+      end
+
+      def check_load_option(load_option)
+        case load_option
+          when :memory
+            GeoIP::GeoIPOptions[:memory_cache]
+          when :filesystem
+            GeoIP::GeoIPOptions[:standard]
+          when :index
+            GeoIP::GeoIPOptions[:index_cache]
+        end
+      end
+  end
+end
+

data/lib/ffi-geoip/city.rb

@@ -0,0 +1,26 @@
+# encoding: UTF-8
+
+module GeoIP
+  class City
+    include GeoIP::Base
+    include GeoIP::Tools
+
+    def initialize(*args)
+      initialize_geoip(*args)
+    end
+
+    def look_up(addr)
+      addr = value_to_addr(addr)
+      check_type(addr, String)
+
+      record = Record.new(FFIGeoIP.GeoIP_record_by_addr(@ptr, addr))
+
+      if !record.null?
+        hash = record.to_h
+        FFIGeoIP.GeoIPRecord_delete(record)
+        hash
+      end
+    end
+  end
+end
+

data/lib/ffi-geoip/country.rb

@@ -0,0 +1,24 @@
+# encoding: UTF-8
+
+module GeoIP
+  class Country
+    include GeoIP::Base
+    include GeoIP::Tools
+
+    def initialize(*args)
+      initialize_geoip(*args)
+    end
+
+    def look_up(addr)
+      addr = value_to_addr(addr)
+      check_type(addr, String)
+
+      fix_encoding(
+        :country_code => FFIGeoIP.GeoIP_country_code_by_addr(@ptr, addr),
+        :country_code3 => FFIGeoIP.GeoIP_country_code3_by_addr(@ptr, addr),
+        :country_name => FFIGeoIP.GeoIP_country_name_by_addr(@ptr, addr)
+      )
+    end
+  end
+end
+

data/lib/ffi-geoip/isp.rb

@@ -0,0 +1,20 @@
+# encoding: UTF-8
+
+module GeoIP
+  class ISP
+    include GeoIP::Base
+    include GeoIP::Tools
+
+    def initialize(*args)
+      initialize_geoip(*args)
+    end
+
+    def look_up(addr)
+      addr = value_to_addr(addr)
+      check_type(addr, String)
+
+      fix_encoding(:isp => FFIGeoIP.GeoIP_name_by_addr(@ptr, addr))
+    end
+  end
+end
+

data/lib/ffi-geoip/organization.rb

@@ -0,0 +1,20 @@
+# encoding: UTF-8
+
+module GeoIP
+  class Organization
+    include GeoIP::Base
+    include GeoIP::Tools
+
+    def initialize(*args)
+      initialize_geoip(*args)
+    end
+
+    def look_up(addr)
+      addr = value_to_addr(addr)
+      check_type(addr, String)
+
+      fix_encoding(:name => FFIGeoIP.GeoIP_name_by_addr(@ptr, addr))
+    end
+  end
+end
+

data/lib/ffi-geoip/record.rb

@@ -0,0 +1,53 @@
+# encoding: UTF-8
+
+module GeoIP
+  class Record < FFI::Struct
+    include Tools
+
+    layout(
+      :country_code,    :string,
+      :country_code3,   :string,
+      :country_name,    :string,
+      :region,          :string,
+      :city,            :string,
+      :postal_code,     :string,
+      :latitude,        :float,
+      :longitude,       :float,
+      :dma_code,        :int,
+      :area_code,       :int,
+      :charset,         :int,
+      :continent_code,  :string,
+      :country_conf,    :uchar,
+      :region_conf,     :uchar,
+      :city_conf,       :uchar,
+      :postal_conf,     :uchar,
+      :accuracy_radius, :int
+    )
+
+    HASH_KEYS = [
+      :country_code,
+      :country_code3,
+      :country_name,
+      :region,
+      :city,
+      :postal_code,
+      :latitude,
+      :longitude,
+      :dma_code,
+      :area_code
+    ].freeze
+
+    def to_h
+      hash = HASH_KEYS.each_with_object({}) do |key, memo|
+        memo[key] = self[key] unless self[key].nil?
+      end
+
+      if self[:region]
+        hash[:region_name] = FFIGeoIP.GeoIP_region_name_by_code(self[:country_code], self[:region])
+      end
+
+      fix_encoding(hash)
+    end
+  end
+end
+

data/lib/ffi-geoip/tools.rb

@@ -0,0 +1,26 @@
+# encoding: UTF-8
+
+module GeoIP
+  module Tools
+    private
+      def check_enum_value(enum, value)
+        enum[value] or
+          raise TypeError.new("Couldn't find valid #{enum.tag} value: #{value}")
+      end
+
+      def check_type(value, *types)
+        if !types.include?(value.class)
+          type_names = types.collect(&:name).join(' or ')
+
+          raise TypeError.new("wrong argument type #{value.class.name} (expected #{type_names})")
+        end
+      end
+
+      def fix_encoding(hash)
+        hash.each do |_, value|
+          value.encode!('UTF-8', 'ISO-8859-1') if value.is_a?(String)
+        end
+      end
+    end
+end
+

data/lib/ffi-geoip/version.rb

@@ -0,0 +1,6 @@
+# encoding: UTF-8
+
+module GeoIP
+  VERSION = "0.0.1"
+end
+

data/test/city_tests.rb

@@ -0,0 +1,77 @@
+# encoding: UTF-8
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+class GeoIPCityTest < Minitest::Test
+  PITTSBURGH = {
+    :country_code => "US",
+    :country_code3 => "USA",
+    :country_name => "United States",
+    :region => "PA",
+    :city => "Pittsburgh",
+    :latitude => 40.44060134887695,
+    :longitude => -79.99590301513672,
+    :dma_code => 508,
+    :area_code => 412,
+    :region_name => "Pennsylvania"
+  }
+
+  PITTSBURGH_IP = '12.87.118.0'
+
+  def assert_look_up(db, expected = PITTSBURGH, lookup = PITTSBURGH_IP)
+    hash = db.look_up(lookup)
+    assert_kind_of(Hash, hash)
+    assert_equal(expected, hash)
+  end
+
+  def assert_raises_type_error(db)
+    assert_raises(TypeError) do
+      db.look_up(nil)
+    end
+  end
+
+  def test_construction_default
+    db = GeoIP::City.new(CITY_DB)
+    assert_raises_type_error(db)
+    assert_look_up(db)
+  end
+
+  def test_construction_index
+    db = GeoIP::City.new(CITY_DB, :index)
+    assert_raises_type_error(db)
+    assert_look_up(db)
+  end
+
+  def test_construction_filesystem
+    db = GeoIP::City.new(CITY_DB, :filesystem)
+    assert_raises_type_error(db)
+    assert_look_up(db)
+  end
+
+  def test_construction_memory
+    db = GeoIP::City.new(CITY_DB, :memory)
+    assert_raises_type_error(db)
+    assert_look_up(db)
+  end
+
+  def test_construction_filesystem_check
+    db = GeoIP::City.new(CITY_DB, :filesystem, true)
+    assert_raises_type_error(db)
+    assert_look_up(db)
+  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(CITY_DB, :filesystem, true)
+    hash = db.look_up('89.160.20.112')
+    assert_equal('UTF-8', hash[:city].encoding.to_s)
+    assert_equal('Linköping', hash[:city])
+  end
+end
+

data/test/country_tests.rb

@@ -0,0 +1,51 @@
+# encoding: UTF-8
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+class GeoIPCountryTest < Minitest::Test
+  UNITED_STATES = {
+    :country_code => "US",
+    :country_code3 => "USA",
+    :country_name => "United States"
+  }
+
+  UNITED_STATES_IP = '12.87.118.0'
+
+  def assert_look_up(db, expected = UNITED_STATES, lookup = UNITED_STATES_IP)
+    hash = db.look_up(lookup)
+    assert_kind_of(Hash, hash)
+    assert_equal(expected, hash)
+  end
+
+  def test_construction_default
+    db = GeoIP::Country.new(COUNTRY_DB)
+    assert_raises_type_error(db)
+    assert_look_up(db)
+  end
+
+  def test_construction_filesystem
+    db = GeoIP::Country.new(COUNTRY_DB, :filesystem)
+    assert_raises_type_error(db)
+    assert_look_up(db)
+  end
+
+  def test_construction_memory
+    db = GeoIP::Country.new(COUNTRY_DB, :memory)
+    assert_raises_type_error(db)
+    assert_look_up(db)
+  end
+
+  def test_construction_filesystem_check
+    db = GeoIP::Country.new(COUNTRY_DB, :filesystem, true)
+    assert_raises_type_error(db)
+    assert_look_up(db)
+  end
+
+  def test_bad_db_file
+    assert_raises(Errno::ENOENT) do
+      GeoIP::Country.new('/supposed-to-fail')
+    end
+  end
+end
+

data/test/geoip_tests.rb

@@ -0,0 +1,50 @@
+# encoding: UTF-8
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+class GeoIPTest < Minitest::Test
+  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
+
+  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
+
+  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
+end
+

data/test/isp_tests.rb

@@ -0,0 +1,54 @@
+# encoding: UTF-8
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+class GeoIPISPTest < Minitest::Test
+  ISP = {
+    :isp => "AT&T Services"
+  }
+
+  ISP_IP = '12.87.118.0'
+
+  def assert_look_up(db, expected = ISP, lookup = ISP_IP)
+    hash = db.look_up(lookup)
+    assert_kind_of(Hash, hash)
+    assert_equal(expected, hash)
+  end
+
+  def test_construction_default
+    db = GeoIP::ISP.new(ISP_DB)
+    assert_raises_type_error(db)
+    assert_look_up(db)
+  end
+
+  # def test_construction_index
+  #   db = GeoIP::ISP.new(ISP_DB, :index)
+  #   assert_look_up(db, ISP_IP, :isp, 'Bell Aliant')
+  # end
+
+  def test_construction_filesystem
+    db = GeoIP::ISP.new(ISP_DB, :filesystem)
+    assert_raises_type_error(db)
+    assert_look_up(db)
+  end
+
+  def test_construction_memory
+    db = GeoIP::ISP.new(ISP_DB, :memory)
+    assert_raises_type_error(db)
+    assert_look_up(db)
+  end
+
+  def test_construction_filesystem_check
+    db = GeoIP::ISP.new(ISP_DB, :filesystem, true)
+    assert_raises_type_error(db)
+    assert_look_up(db)
+  end
+
+  def test_bad_db_file
+    assert_raises Errno::ENOENT do
+      GeoIP::ISP.new('/supposed-to-fail')
+    end
+  end
+end
+