sypex_geo 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bb5f6cd269004ce0ac3ef7c190008ca0341cb219
-  data.tar.gz: b1fbd13bb57fc6fb0fff8c118d77719f5856ee38
+  metadata.gz: 270f6a9db891c1f4f6235ca37888a22a1cb6aa18
+  data.tar.gz: 2882b224bdbc064f518858245d670df34b08225b
 SHA512:
-  metadata.gz: 12c16308ea7729916da8279fa967669a6b9083b9c4d352e7156ca1aa36a13a64d1b23ca4fe80ca166f544e6195510cf31144046038255df078d71ca922a0be08
-  data.tar.gz: 9fac5ecb9febc9751efb7892a469ba92c0c2b97ab5839c60548cd2cc2fc5b833148408b7999861e88cf7bdd0dd20c865d580ea19cf891d7f5696a3e0d1e205b2
+  metadata.gz: 0cbf268f45fcf101a93e837a82567ce4b824be475e20c86c12e5b9d2211619c707b68d13ff1d209ce2d18b7f25966d26b0d3b2fe69f363004bb4a2e70551a67f
+  data.tar.gz: 189c75e6d57c803d169c74f36f711b02a38545a132f5e81512775e14545e7af5a4436861aafa5caad480203930619b62a95e022014419be00a1773979ab2dbfc

data/.travis.yml

@@ -6,11 +6,13 @@ rvm:
   - 2.1.0
 
 env:
-  - SYPEXGEO_CITY_MAX_DB=sypexgeo_city_max.dat
+  - SXGEO_DB=SxGeo.dat
+  - SXGEO_CITY_DB=SxGeoCity.dat
 
 before_script:
-  - '[ -f sypexgeo_city_max.dat ] || (wget http://sypexgeo.net/files/SxGeoCityMax_utf8.zip && unzip SxGeoCityMax_utf8.zip && mv SxGeoCityMax.dat sypexgeo_city_max.dat)'
+  - 'wget http://sypexgeo.net/files/SxGeoCountry.zip && unzip SxGeoCountry.zip'
+  - 'wget http://sypexgeo.net/files/SxGeoCity_utf8.zip && unzip SxGeoCity_utf8.zip'
 
 addons:
   code_climate:
-    repo_token: 15e49d47a87a130d4a3cde0bb2ce14fe9053f525e92495a215027aff3e552368 
+    repo_token: 15e49d47a87a130d4a3cde0bb2ce14fe9053f525e92495a215027aff3e552368

data/README.md

@@ -1,4 +1,7 @@
 [![Gem Version](https://badge.fury.io/rb/sypex_geo.svg)](http://badge.fury.io/rb/sypex_geo)
+[![Build Status](https://travis-ci.org/kolesnikovde/sypex_geo.svg?branch=master)](https://travis-ci.org/kolesnikovde/sypex_geo)
+[![Code Climate](https://codeclimate.com/github/kolesnikovde/sypex_geo/badges/gpa.svg)](https://codeclimate.com/github/kolesnikovde/sypex_geo)
+[![Test Coverage](https://codeclimate.com/github/kolesnikovde/sypex_geo/badges/coverage.svg)](https://codeclimate.com/github/kolesnikovde/sypex_geo)
 
 # SypexGeo
 
@@ -19,65 +22,43 @@ And then execute:
 ```ruby
 require 'sypex_geo'
 
-db = SypexGeo::Database.new('./sypex_geo_city_max.dat')
-db.lookup(<IPv4 address>)
+db = SypexGeo::Database.new('./SxGeoCity.dat')
+location = db.query('<IPv4 address>')
+
+location.city
+# => {
+#   id: 524901,
+#   lat: 55.75222,
+#   lon: 37.61556,
+#   name_ru: 'Москва',
+#   name_en: 'Moscow'
+# }
+
+location.region
 # => {
-#   city: {
-#     id: 524901,
-#     lat: 55,
-#     lon: 37,
-#     name_ru: 'Москва',
-#     name_en: 'Moscow',
-#     okato: '45'
-#   },
-#   country: {
-#     id: 185,
-#     iso: 'RU'
-#   },
-#   region: nil
+#   id: 524894,
+#   iso: 'RU-MOW',
+#   name_ru: 'Москва',
+#   name_en: 'Moskva'
 # }
 
-# Query details.
-db.lookup(<IPv4 address>, true)
+location.country
 # => {
-#   city: {
-#     id: 524901,
-#     lat: 55,
-#     lon: 37,
-#     name_ru: 'Москва',
-#     name_en: 'Moscow',
-#     okato: '45'
-#   },
-#   region: {
-#     id: 524894,
-#     name_ru: 'Москва',
-#     name_en: 'Moskva',
-#     lat: 55,
-#     lon: 37,
-#     iso: 'RU-MOW',
-#     timezone: 'Europe/Moscow',
-#     okato: '45'
-#   },
-#   country: {
-#     id: 185,
-#     iso: 'RU',
-#     continent: 'EU',
-#     lat: 60,
-#     lon: 100,
-#     name_ru: 'Россия',
-#     name_en: 'Russia',
-#     timezone: 'Europe/Moscow'
-#   }
+#   id: 185,
+#   iso: 'RU',
+#   lat: 60.0,
+#   lon: 100.0,
+#   name_ru: 'Россия',
+#   name_en: 'Russia'
 # }
 
-# "memory_mode"
-db = SypexGeo::MemoryDatabase.new('./sypex_geo_city_max.dat')
-db.lookup(<IPv4 address>)
+location.country_code
+# => 'RU'
 ```
 
 ## Testing
 
-    $ SYPEXGEO_CITY_MAX_DB=./sypexgeo_city_max.dat rspec
+    $ SXGEO_DB=./SxGeo.dat SXGEO_CITY_DB=./SxGeoCity.dat rspec
 
 ## License
 

data/lib/sypex_geo/database.rb

@@ -5,159 +5,126 @@ module SypexGeo
   end
 
   class Database
-    attr_reader :version
+    TYPE_COUNTRY = 1
+    TYPE_CITY    = 3
+
+    attr_reader :version, :time
 
     def initialize(path)
       @file = File.open(path, 'rb')
 
-      setup!
+      parse_header
+      setup
     end
 
-    def lookup(ip, full = false)
-      if seek = search(ip)
-        read_location(seek, full)
+    def query(ip)
+      if position = search(ip)
+        Result.new(position, self)
       end
     end
 
+    def read_country(position)
+      @country_parser ||= Pack.new(@country_pack)
+      @country_parser.parse(@cities_db[position, @country_size])
+    end
+
+    def read_region(position)
+      @region_parser ||= Pack.new(@region_pack)
+      @region_parser.parse(@regions_db[position, @region_size])
+    end
+
+    def read_city(position)
+      @city_parser ||= Pack.new(@city_pack)
+      @city_parser.parse(@cities_db[position, @city_size])
+    end
+
+    def country?
+      @type == TYPE_COUNTRY
+    end
+
+    def city?
+      @type == TYPE_CITY
+    end
+
     def inspect
       "#<#{self.class}:0x#{object_id} @version=#{@version}>"
     end
 
     protected
 
-    def setup!
+    def parse_header
       if header = @file.read(40)
         id, @version, @time, @type, @charset,
-        @b_idx_len, @m_idx_len, @range, @db_items, @id_len,
-        @max_region, @max_city, @region_size, @city_size,
-        @max_country, @country_size,
+        @block_idx_size, @main_idx_size, @range, @db_records_count, @id_size,
+        @region_size, @city_size, @regions_db_size, @cities_db_size,
+        @country_size, @countries_db_size,
         @pack_size = header.unpack('a3CNCCCnnNCnnNNnNn')
       end
 
       raise DatabaseError.new, 'Wrong file format' unless id == 'SxG'
+    end
 
+    def setup
       @pack = @file.read(@pack_size).split("\0")
-      @b_idx_arr = @file.read(@b_idx_len * 4).unpack('N*')
-      @m_idx_arr = @file.read(@m_idx_len * 4).scan(/.{1,4}/m)
+      @country_pack, @region_pack, @city_pack = @pack
+
+      @block_idx = @file.read(@block_idx_size * 4).unpack('N*')
+      @main_idx = @file.read(@main_idx_size * 4).scan(/.{1,4}/m)
 
-      @block_len = 3 + @id_len
-      @db_begin = @file.tell
-      @regions_begin = @db_begin + @db_items * @block_len
-      @cities_begin = @regions_begin + @region_size
+      @db_record_size = 3 + @id_size
+      @db = @file.read(@db_records_count * @db_record_size)
+      @regions_db = @file.read(@regions_db_size) if @regions_db_size > 0
+      @cities_db = @file.read(@cities_db_size) if @cities_db_size > 0
     end
 
     def search(ip)
-      ip1n = ip.to_i
-
-      return if ip1n == 0 or ip1n == 127 or ip1n >= 224
+      octet = ip.to_i
+      return if octet == 0 or octet == 127 or octet >= @block_idx_size
 
+      min, max = @block_idx[octet - 1], @block_idx[octet]
+      range = @range
       ipn = IPAddr.new(ip).hton
-      blocks_min, blocks_max = @b_idx_arr[ip1n - 1], @b_idx_arr[ip1n]
-
-      if blocks_max - blocks_min > @range
-        part = search_idx(ipn, blocks_min / @range, (blocks_max / @range) - 1)
-        min = part > 0 ? part * @range : 0
-        max = part > @m_idx_len ? @db_items : (part + 1) * @range
-        min = blocks_min if min < blocks_min
-        max = blocks_max if max > blocks_max
-      else
-        min = blocks_min
-        max = blocks_max
+
+      if max - min > range
+        min = range * main_idx_search(ipn, min / range, (max / range) - 1)
+        max = min + range
       end
 
-      search_db(ipn, min, max)
+      db_search(ipn, min, max)
     end
 
-    def search_idx(ipn, min, max)
-      idx = @m_idx_arr
+    def main_idx_search(ipn, min, max)
+      idx = @main_idx
 
-      while max - min > 8
-        offset = (min + max) >> 1
+      while min < max
+        mid = (min + max) / 2
 
-        if ipn > idx[offset]
-          min = offset
+        if ipn > idx[mid]
+          min = mid + 1
         else
-          max = offset
+          max = mid
         end
       end
 
-      while ipn > idx[min]
-        break if min >= max
-        min += 1
-      end
-
       min
     end
 
-    def search_db(ipn, min, max)
-      len = max - min
-      @file.pos = @db_begin + min * @block_len
-      search_db_chunk(@file.read(len * @block_len), ipn, 0, len - 1)
-    end
-
-    def search_db_chunk(data, ipn, min, max)
-      block_len = @block_len
+    def db_search(ipn, min, max)
+      db = @db
+      db_record_size = @db_record_size
+      octets = ipn[1, 3]
 
-      if max - min > 1
-        ipn = ipn[1, 3]
+      while min < max
+        mid = (min + max) / 2
 
-        while max - min > 8
-          offset = (min + max) >> 1
-
-          if ipn > data[offset * block_len, 3]
-            min = offset
-          else
-            max = offset
-          end
-        end
-
-        while ipn >= data[min * block_len, 3]
-          min += 1
-          break if min >= max
+        if octets > db[mid * db_record_size, 3]
+          min = mid + 1
+        else
+          max = mid
         end
-      else
-        min += 1
-      end
-
-      data[min * block_len - @id_len, @id_len].unpack('H*').first.hex
-    end
-
-    def read_data(seek, limit, type)
-      @file.pos = (type == TYPE_REGION ? @regions_begin : @cities_begin) + seek
-      Pack.parse(@pack[type], @file.read(limit))
-    end
-
-    def read_country(seek)
-      read_data(seek, @max_country, TYPE_COUNTRY)
-    end
-
-    def read_region(seek)
-      read_data(seek, @max_region, TYPE_REGION)
-    end
-
-    def read_city(seek)
-      read_data(seek, @max_city, TYPE_CITY)
-    end
-
-    def read_location(seek, full = false)
-      region = nil
-      city = nil
-      country = nil
-
-      if seek < @country_size
-        country = read_country(seek)
-      elsif city = read_city(seek)
-        region_seek = city.delete(:region_seek)
-        country_id = city.delete(:country_id)
-        country = { id: country_id, iso: COUNTRY_CODES[country_id - 1] }
-      end
-
-      if full and region_seek
-        region = read_region(region_seek)
-        country = read_country(region.delete(:country_seek))
       end
 
-      { city: city, region: region, country: country }
+      db[min * db_record_size - @id_size, @id_size].unpack('H*')[0].hex
     end
   end
 end

data/lib/sypex_geo/pack.rb

@@ -1,28 +1,21 @@
 module SypexGeo
-  module Pack
+  class Pack
     def self.parse(pack, data)
+      new(pack).parse(data)
+    end
+
+    def initialize(pack)
+      @pack = pack
+    end
+
+    def parse(data)
+      @data = data
+      @pos = 0
       result = {}
-      pos = 0
-
-      pack.split('/').each do |p|
-        type, name = p.split(':')
-
-        if data.nil? or data.empty?
-          val = type[0] =~ /b|c/ ? '' : 0
-        else
-          if type[0] == 'b'
-            len = data.index("\0", pos) - pos + 1
-            val = data[pos, len - 1].force_encoding('UTF-8')
-          else
-            len = type_length(type)
-            val = unpack(type, data[pos, len])
-            val = val[0] if val.is_a?(Array)
-          end
-
-          pos += len
-        end
-
-        result[name.to_sym] = val
+
+      @pack.split('/').each do |part|
+        chunk, name = part.split(':')
+        result[name.to_sym] = parse_chunk(chunk)
       end
 
       result
@@ -30,33 +23,90 @@ module SypexGeo
 
     protected
 
-    def self.type_length(type)
-      case type[0]
-      when /t|T/   then 1
-      when /s|S|n/ then 2
-      when /m|M/   then 3
-      when 'd'     then 8
-      when 'c'     then type[1..-1].to_i
-      else 4
+    def parse_chunk(chunk)
+      case chunk[0]
+      when 't' then read_int8(chunk)
+      when 'T' then read_uint8(chunk)
+      when 's' then read_int16(chunk)
+      when 'S' then read_uint16(chunk)
+      when 'm' then read_int24(chunk)
+      when 'M' then read_uint24(chunk)
+      when 'i' then read_int32(chunk)
+      when 'I' then read_uint32(chunk)
+      when 'f' then read_float(chunk)
+      when 'd' then read_double(chunk)
+      when 'n' then read_decimal16(chunk)
+      when 'N' then read_decimal32(chunk)
+      when 'c' then read_chars(chunk)
+      when 'b' then read_blob(chunk)
       end
     end
 
-    def self.unpack(type, val)
-      case type[0]
-      when 't' then val.unpack('c')
-      when 'T' then val.unpack('C')
-      when 's' then val.unpack('s')
-      when 'S' then val.unpack('S')
-      when 'm' then (val + (val[2].ord >> 7) > 0 ? "\xFF" : "\0").unpack('l')
-      when 'M' then (val + "\0").unpack('L')
-      when 'i' then val.unpack('l')
-      when 'I' then val.unpack('L')
-      when 'f' then val.unpack('f')
-      when 'd' then val.unpack('d')
-      when 'n' then val.unpack('s')[0] / (10 ** type[1].to_i)
-      when 'N' then val.unpack('l')[0] / (10 ** type[1].to_i)
-      when 'c' then val.rstrip
-      end
+    def read(len)
+      @pos += len
+      @data[@pos - len, len]
+    end
+
+    def read_string(len)
+      read(len).strip.force_encoding('UTF-8')
+    end
+
+    def read_int8(chunk)
+      read(1).unpack('c')[0]
+    end
+
+    def read_uint8(chunk)
+      read(1).unpack('C')[0]
+    end
+
+    def read_int16(chunk)
+      read(2).unpack('s')[0]
+    end
+
+    def read_uint16(chunk)
+      read(2).unpack('S')[0]
+    end
+
+    def read_int24(chunk)
+      raw = read(3)
+      raw = raw + (raw[2].ord >> 7) > 0 ? "\xFF" : "\0"
+      raw.unpack('l')[0]
+    end
+
+    def read_uint24(chunk)
+      (read(3) + "\0").unpack('L')[0]
+    end
+
+    def read_int32(chunk)
+      read(4).unpack('l')[0]
+    end
+
+    def read_uint32(chunk)
+      read(4).unpack('L')[0]
+    end
+
+    def read_float(chunk)
+      read(4).unpack('f')[0]
+    end
+
+    def read_double(chunk)
+      read(8).unpack('d')[0]
+    end
+
+    def read_decimal16(chunk)
+      read(2).unpack('s')[0].to_f / (10 ** chunk[1].to_i)
+    end
+
+    def read_decimal32(chunk)
+      read(4).unpack('l')[0].to_f / (10 ** chunk[1].to_i)
+    end
+
+    def read_chars(chunk)
+      read_string(chunk[1..-1].to_i)
+    end
+
+    def read_blob(chunk)
+      read_string(@data.index("\0", @pos) - @pos + 1)
     end
   end
 end

data/lib/sypex_geo/result.rb

@@ -0,0 +1,40 @@
+module SypexGeo
+  COUNTRY_CODES = %w[
+    AP EU AD AE AF AG AI AL AM AN AO AQ AR AS AT AU AW AZ BA BB BD BE BF BG
+    BH BI BJ BM BN BO BR BS BT BV BW BY BZ CA CC CD CF CG CH CI CK CL CM CN
+    CO CR CU CV CX CY CZ DE DJ DK DM DO DZ EC EE EG EH ER ES ET FI FJ FK FM
+    FO FR FX GA GB GD GE GF GH GI GL GM GN GP GQ GR GS GT GU GW GY HK HM HN
+    HR HT HU ID IE IL IN IO IQ IR IS IT JM JO JP KE KG KH KI KM KN KP KR KW
+    KY KZ LA LB LC LI LK LR LS LT LU LV LY MA MC MD MG MH MK ML MM MN MO MP
+    MQ MR MS MT MU MV MW MX MY MZ NA NC NE NF NG NI NL NO NP NR NU NZ OM PA
+    PE PF PG PH PK PL PM PN PR PS PT PW PY QA RE RO RU RW SA SB SC SD SE SG
+    SH SI SJ SK SL SM SN SO SR ST SV SY SZ TC TD TF TG TH TJ TK TM TN TO TL
+    TR TT TV TW TZ UA UG UM US UY UZ VA VC VE VG VI VN VU WF WS YE YT RS ZA
+    ZM ME ZW A1 A2 O1 AX GG IM JE BL MF
+  ]
+
+  class Result
+    def initialize(position, database)
+      @position = position
+      @database = database
+    end
+
+    def city
+      @city ||= @database.read_city(@position)
+    end
+
+    def region
+      @region ||= @database.read_region(city[:region_seek])
+    end
+
+    def country
+      @country ||= @database.read_country(region[:country_seek])
+    end
+
+    def country_code
+      @country_code ||= begin
+        COUNTRY_CODES[(@database.country? ? @position : city[:country_id]) - 1]
+      end
+    end
+  end
+end

data/lib/sypex_geo/version.rb

@@ -1,3 +1,3 @@
 module SypexGeo
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/lib/sypex_geo.rb

@@ -1,24 +1,4 @@
 require 'sypex_geo/database'
-require 'sypex_geo/memory_database'
+require 'sypex_geo/result'
 require 'sypex_geo/pack'
 require 'sypex_geo/version'
-
-module SypexGeo
-  TYPE_COUNTRY = 0
-  TYPE_REGION  = 1
-  TYPE_CITY    = 2
-
-  COUNTRY_CODES = %w[
-    AP EU AD AE AF AG AI AL AM AN AO AQ AR AS AT AU AW AZ BA BB BD BE BF BG
-    BH BI BJ BM BN BO BR BS BT BV BW BY BZ CA CC CD CF CG CH CI CK CL CM CN
-    CO CR CU CV CX CY CZ DE DJ DK DM DO DZ EC EE EG EH ER ES ET FI FJ FK FM
-    FO FR FX GA GB GD GE GF GH GI GL GM GN GP GQ GR GS GT GU GW GY HK HM HN
-    HR HT HU ID IE IL IN IO IQ IR IS IT JM JO JP KE KG KH KI KM KN KP KR KW
-    KY KZ LA LB LC LI LK LR LS LT LU LV LY MA MC MD MG MH MK ML MM MN MO MP
-    MQ MR MS MT MU MV MW MX MY MZ NA NC NE NF NG NI NL NO NP NR NU NZ OM PA
-    PE PF PG PH PK PL PM PN PR PS PT PW PY QA RE RO RU RW SA SB SC SD SE SG
-    SH SI SJ SK SL SM SN SO SR ST SV SY SZ TC TD TF TG TH TJ TK TM TN TO TL
-    TR TT TV TW TZ UA UG UM US UY UZ VA VC VE VG VI VN VU WF WS YE YT RS ZA
-    ZM ME ZW A1 A2 O1 AX GG IM JE BL MF
-  ]
-end

data/spec/sypex_geo_spec.rb

@@ -1,5 +1,8 @@
+# coding: utf-8
+
 require './spec/spec_helper'
 require 'sypex_geo'
+require 'ipaddr'
 
 describe SypexGeo do
   let(:demo_ip) do
@@ -7,111 +10,128 @@ describe SypexGeo do
     '80.90.64.1'
   end
 
-  let(:default_db_file) do
-    File.expand_path(__FILE__ + '/../support/sypexgeo_city_max.dat')
-  end
-
   let(:invalid_db_file) do
     File.expand_path(__FILE__ + '/../support/invalid.dat')
   end
 
-  let(:db_file) do
-    ENV['SYPEXGEO_CITY_MAX_DB'] || default_db_file
-  end
+  shared_examples 'geo db' do
+    describe '#initialize' do
+      it 'raises error if database is invalid' do
+        expect do
+          described_class.new(invalid_db_file)
+        end.to raise_error(SypexGeo::DatabaseError)
+      end
+    end
 
-  let(:city_info) do
-    {
-      city: {
-        id: 524901,
-        lat: 55,
-        lon: 37,
-        name_ru: 'Москва',
-        name_en: 'Moscow',
-        okato: '45'
-      },
-      country: {
-        id: 185,
-        iso: 'RU'
-      },
-      region: nil
-    }
+    describe '#query' do
+      it 'returns nil if IP address is reserved' do
+        expect(subject.query('0.0.0.0')).to be_nil
+        expect(subject.query('127.0.0.0')).to be_nil
+        expect(subject.query('224.0.0.0')).to be_nil
+        expect(subject.query('255.0.0.0')).to be_nil
+      end
+
+      it 'raises error if IP address is invalid' do
+        error = if IPAddr.const_defined?('InvalidAddressError')
+                  IPAddr::InvalidAddressError
+                else
+                  ArgumentError
+                end
+
+        expect do
+          subject.query('1.invalid')
+        end.to raise_error(error)
+      end
+    end
   end
 
-  let(:location_info) do
-    {
-      city: {
+  shared_examples 'city db' do
+    it_behaves_like 'geo db'
+
+    let(:city_info) do
+      {
         id: 524901,
-        lat: 55,
-        lon: 37,
+        country_id: 185,
+        lat: 55.75222,
+        lon: 37.61556,
         name_ru: 'Москва',
         name_en: 'Moscow',
-        okato: '45'
-      },
-      region: {
+        region_seek: 11795
+      }
+    end
+
+    let(:region_info) do
+      {
         id: 524894,
+        iso: 'RU-MOW',
         name_ru: 'Москва',
         name_en: 'Moskva',
-        lat: 55,
-        lon: 37,
-        iso: 'RU-MOW',
-        timezone: 'Europe/Moscow',
-        okato: '45'
-      },
-      country: {
+        country_seek: 9128
+      }
+    end
+
+    let(:country_info) do
+      {
         id: 185,
         iso: 'RU',
-        continent: 'EU',
-        lat: 60,
-        lon: 100,
+        lat: 60.0,
+        lon: 100.0,
         name_ru: 'Россия',
-        name_en: 'Russia',
-        timezone: 'Europe/Moscow'
+        name_en: 'Russia'
       }
-    }
-  end
+    end
 
-  shared_examples 'geoip_database' do
-    describe '#initialize' do
-      it 'raises error if database is invalid' do
-        expect do
-          subject.class.new(invalid_db_file)
-        end.to raise_error(SypexGeo::DatabaseError)
-      end
+    let(:country_code) do
+      'RU'
     end
 
-    describe '#lookup' do
-      it 'returns nil if IP address is reserved' do
-        expect(subject.lookup('0.0.0.0')).to be_nil
-        expect(subject.lookup('127.0.0.0')).to be_nil
-        expect(subject.lookup('224.0.0.0')).to be_nil
-        expect(subject.lookup('255.0.0.0')).to be_nil
-      end
+    it { should be_city }
+    it { should_not be_country }
 
-      it 'raises IPAddr::InvalidAddressError if IP address is invalid' do
-        expect do
-          subject.lookup('1.invalid')
-        end.to raise_error(IPAddr::InvalidAddressError)
-      end
+    describe '#query' do
+      it 'returns location info' do
+        location = subject.query(demo_ip)
 
-      it 'returns city info' do
-        expect(subject.lookup(demo_ip)).to eq(city_info)
+        expect(location.city).to eq(city_info)
+        expect(location.region).to eq(region_info)
+        expect(location.country).to eq(country_info)
+        expect(location.country_code).to eq(country_code)
       end
+    end
+  end
+
+  shared_examples 'country db' do
+    it_behaves_like 'geo db'
+
+    let(:country_code) do
+      'RU'
+    end
 
-      it 'returns detailed location info if specified' do
-        expect(subject.lookup(demo_ip, true)).to eq(location_info)
+    it { should be_country }
+    it { should_not be_city }
+
+    describe '#query' do
+      it 'returns country code' do
+        expect(subject.query(demo_ip).country_code).to eq(country_code)
       end
     end
   end
 
   describe SypexGeo::Database do
-    subject(:db) { SypexGeo::Database.new(db_file) }
+    if ENV['SXGEO_CITY_DB']
+      context 'city db' do
+        subject { SypexGeo::Database.new(ENV['SXGEO_CITY_DB']) }
 
-    it_behaves_like 'geoip_database'
-  end
+        it_behaves_like 'city db'
+      end
+    end
 
-  describe SypexGeo::MemoryDatabase do
-    subject(:db) { SypexGeo::MemoryDatabase.new(db_file) }
+    if ENV['SXGEO_DB']
+      context 'country db' do
+        subject { SypexGeo::Database.new(ENV['SXGEO_DB']) }
 
-    it_behaves_like 'geoip_database'
+        it_behaves_like 'country db'
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sypex_geo
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Kolesnikov Danil
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-22 00:00:00.000000000 Z
+date: 2014-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -82,8 +82,8 @@ files:
 - Rakefile
 - lib/sypex_geo.rb
 - lib/sypex_geo/database.rb
-- lib/sypex_geo/memory_database.rb
 - lib/sypex_geo/pack.rb
+- lib/sypex_geo/result.rb
 - lib/sypex_geo/version.rb
 - spec/spec_helper.rb
 - spec/support/invalid.dat
@@ -109,7 +109,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.2.1
 signing_key: 
 specification_version: 4
 summary: Sypex Geo IP database adapter for Ruby.

data/lib/sypex_geo/memory_database.rb

@@ -1,20 +0,0 @@
-module SypexGeo
-  class MemoryDatabase < Database
-    def setup!
-      super
-
-      @db = @file.read(@db_items * @block_len)
-      @regions_db = @file.read(@region_size) if @region_size > 0
-      @cities_db = @file.read(@city_size) if @city_size > 0
-    end
-
-    def search_db(ipn, min, max)
-      search_db_chunk(@db, ipn, min, max)
-    end
-
-    def read_data(seek, limit, type)
-      raw = (type == TYPE_REGION ? @regions_db : @cities_db)[seek, limit]
-      Pack.parse(@pack[type], raw)
-    end
-  end
-end