geoip2_c 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a385241251a43ddd2d075ae6edf6079eee160022
+  data.tar.gz: ba99231f74e179e16f3274eda636860123e2923b
+SHA512:
+  metadata.gz: 460dc2adc04bb35833fe48b27688a8d1709ad39526e067bc13ce41d64bb85ee10326c6ff5f493668fad85d135ff213aad862f292e9754db518770e023b2e8756
+  data.tar.gz: 81b9fb3f1b408568894747fe0695d5892250a94dfdc373c663c6fdcd3d6d9def2fc3eacdeffbfdff77fb303b8fff75cb12ae742284eadba62400cf3b0f5a445d

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "test/MaxMind-DB"]
+	path = test/MaxMind-DB
+	url = https://github.com/maxmind/MaxMind-DB.git

data/.travis.yml

@@ -0,0 +1,25 @@
+sudo: required
+services:
+  - docker
+
+env:
+  DOCKER_COMPOSE_VERSION: 1.8.1
+
+before_install:
+  #- sudo apt-get update
+  #- sudo apt-get install -y docker-engine
+  - sudo rm /usr/local/bin/docker-compose
+  - curl -L https://github.com/docker/compose/releases/download/${DOCKER_COMPOSE_VERSION}/docker-compose-$(uname -s)-$(uname -m) > docker-compose
+  - chmod +x docker-compose
+  - sudo mv docker-compose /usr/local/bin/
+
+before_script:
+  - docker-compose build
+  - docker-compose ps
+  - docker-compose up -d
+  - docker-compose exec test bundle install
+  - docker-compose exec test bundle exec rake compile
+
+script:
+  - docker-compose exec test bundle exec rake test
+

data/Dockerfile

@@ -0,0 +1,6 @@
+FROM ruby:2.3.3-alpine
+
+RUN apk --no-cache --update add build-base ruby-dev libc6-compat libmaxminddb-dev git
+
+WORKDIR /app
+COPY . .

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in geoip2_c.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 okkez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,57 @@
+# GeoIP2
+
+This gem provides binding [libmaxminddb](http://maxmind.github.io/libmaxminddb/).
+
+This binding does not traverse all elements in lookup result by default.
+So you can get the element you want fast such as city name, country name or etc.
+
+## Requirements
+
+* Ruby 2.3 or later
+
+NOTE:
+
+This library uses `Hash#dig` and `Array#dig`.
+If you want to use this library with Ruby2.1 or Ruby2.2, you can install a gem which adds support `#dig` method.
+But I don't want to add extra dependency to this library, so I decided not to add extra dependency to support old Ruby versions.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'geoip2_c'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install geoip2_c
+
+## Usage
+
+```ruby
+require "geoip2"
+
+db = GeoIP2::Databaes.new("/path/to/GeoLite2-City.mmdb")
+result = db.lookup("66.102.9.80")
+retuls.get_value("city", "names", "en") # => "Mountain View"
+```
+
+## Development
+
+After checking out the repo, run `bundle install` to install dependencies. Then, run `rake test` to run the tests.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/okkez/geoip2_c.
+
+## License
+
+The gem is available as open source under the terms of the [Apache-2.0](http://opensource.org/licenses/Apache-2.0).
+

data/Rakefile

@@ -0,0 +1,18 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+require "rake/extensiontask"
+
+task :build => :compile
+
+Rake::ExtensionTask.new("geoip2") do |ext|
+  ext.lib_dir = "lib/geoip2"
+end
+
+task :default => [:clobber, :compile, :test]

data/docker-compose.yml

@@ -0,0 +1,6 @@
+version: "2"
+services:
+  test:
+    build:
+      context: .
+    command: ruby -run -e httpd

data/ext/geoip2/extconf.rb

@@ -0,0 +1,10 @@
+require "mkmf"
+
+dir_config("maxminddb")
+have_header("maxminddb.h")
+have_library("maxminddb")
+
+$CFLAGS << " -std=c99"
+# $CFLAGS << " -g -O0"
+
+create_makefile("geoip2/geoip2")

data/ext/geoip2/geoip2.c

@@ -0,0 +1,421 @@
+#include <ruby.h>
+#include <ruby/encoding.h>
+#include <maxminddb.h>
+
+VALUE rb_mGeoIP2;
+VALUE rb_cGeoIP2Database;
+VALUE rb_cGeoIP2LookupResult;
+VALUE rb_eGeoIP2Error;
+
+static void mmdb_open(const char *db_path, MMDB_s *mmdb);
+static void mmdb_close(MMDB_s *mmdb);
+static bool mmdb_is_closed(MMDB_s *mmdb);
+static void mmdb_free(void *mmdb);
+static MMDB_lookup_result_s mmdb_lookup(MMDB_s *mmdb, const char *ip_str, bool cleanup);
+static VALUE mmdb_entry_data_decode(MMDB_entry_data_s *entry_data);
+static VALUE mmdb_guard_parse_entry_data_list(VALUE ptr);
+static MMDB_entry_data_list_s *mmdb_parse_entry_data_list(MMDB_entry_data_list_s *data_list, VALUE *obj);
+
+static VALUE rb_geoip2_db_alloc(VALUE klass);
+static VALUE rb_geoip2_db_initialize(VALUE self, VALUE path);
+static VALUE rb_geoip2_db_close(VALUE self);
+static VALUE rb_geoip2_db_lookup(VALUE self, VALUE ip);
+
+static VALUE rb_geoip2_lr_alloc(VALUE klass);
+static VALUE rb_geoip2_lr_initialize(VALUE self);
+static VALUE rb_geoip2_lr_get_value(int argc, VALUE *argv, VALUE self);
+static VALUE rb_geoip2_lr_to_h(VALUE self);
+
+// static void lookup_result_free(void *pointer);
+// static size_t lookup_result_size(void *pointer);
+
+static const rb_data_type_t rb_mmdb_type = {
+  "geoip2/mmdb", {
+    0, mmdb_free, 0,
+  }, NULL, NULL
+};
+
+static const rb_data_type_t rb_lookup_result_type = {
+  "geoip2/lookup_result", {
+    0, 0, 0,
+  }, NULL, NULL
+};
+
+static void
+mmdb_open(const char *db_path, MMDB_s *mmdb)
+{
+  int status = MMDB_open(db_path, MMDB_MODE_MMAP, mmdb);
+
+  if (status != MMDB_SUCCESS) {
+    rb_raise(rb_eGeoIP2Error, "%s: %s", MMDB_strerror(status), db_path);
+  }
+}
+
+static void
+mmdb_close(MMDB_s *mmdb)
+{
+  MMDB_close(mmdb);
+  mmdb->file_content = NULL;
+}
+
+static bool
+mmdb_is_closed(MMDB_s *mmdb)
+{
+  return mmdb->file_content == NULL;
+}
+
+static void
+mmdb_free(void *ptr)
+{
+  MMDB_s *mmdb = (MMDB_s *)ptr;
+  if (!mmdb_is_closed(mmdb)) {
+    mmdb_close(mmdb);
+  }
+
+  xfree(mmdb);
+}
+
+static MMDB_lookup_result_s
+mmdb_lookup(MMDB_s *mmdb, const char *ip_str, bool cleanup)
+{
+  int gai_error;
+  int mmdb_error;
+
+  MMDB_lookup_result_s result =
+    MMDB_lookup_string(mmdb, ip_str, &gai_error, &mmdb_error);
+
+  if (gai_error != 0) {
+    if (cleanup && !mmdb_is_closed(mmdb)) {
+      mmdb_close(mmdb);
+    }
+    rb_raise(rb_eGeoIP2Error,
+             "getaddrinfo failed: %s", gai_strerror(gai_error));
+  }
+
+  if (mmdb_error != MMDB_SUCCESS) {
+    if (cleanup && !mmdb_is_closed(mmdb)) {
+      mmdb_close(mmdb);
+    }
+    rb_raise(rb_eGeoIP2Error,
+             "lookup failed: %s", MMDB_strerror(mmdb_error));
+  }
+
+  return result;
+}
+
+static VALUE
+mmdb_entry_data_decode(MMDB_entry_data_s *entry_data)
+{
+  switch (entry_data->type) {
+  case MMDB_DATA_TYPE_EXTENDED:
+    /* TODO: not implemented */
+    return Qnil;
+  case MMDB_DATA_TYPE_POINTER:
+    /* TODO: not implemented */
+    return Qnil;
+  case MMDB_DATA_TYPE_UTF8_STRING:
+    return rb_enc_str_new(entry_data->utf8_string,
+                          entry_data->data_size,
+                          rb_utf8_encoding());
+  case MMDB_DATA_TYPE_DOUBLE:
+    return DBL2NUM(entry_data->double_value);
+  case MMDB_DATA_TYPE_BYTES:
+    return rb_enc_str_new((const char *)entry_data->bytes,
+                          entry_data->data_size,
+                          rb_ascii8bit_encoding());
+  case MMDB_DATA_TYPE_UINT16:
+    return UINT2NUM(entry_data->uint16);
+  case MMDB_DATA_TYPE_UINT32:
+    return UINT2NUM(entry_data->uint32);
+  case MMDB_DATA_TYPE_MAP:
+    /* TODO: not implemented */
+    return Qnil;
+  case MMDB_DATA_TYPE_INT32:
+    return INT2NUM(entry_data->int32);
+  case MMDB_DATA_TYPE_UINT64:
+    return UINT2NUM(entry_data->uint64);
+  case MMDB_DATA_TYPE_UINT128:
+    /* FIXME I'm not sure */
+    return UINT2NUM(entry_data->uint128);
+  case MMDB_DATA_TYPE_ARRAY:
+    /* TODO: not implemented */
+    return Qnil;
+  case MMDB_DATA_TYPE_CONTAINER:
+    /* TODO: not implemented */
+    return Qnil;
+  case MMDB_DATA_TYPE_END_MARKER:
+    return Qnil;
+  case MMDB_DATA_TYPE_BOOLEAN:
+    return entry_data->boolean ? Qtrue : Qfalse;
+  case MMDB_DATA_TYPE_FLOAT:
+    return rb_float_new(entry_data->float_value);
+  default:
+    rb_raise(rb_eGeoIP2Error, "Unkown type: %d", entry_data->type);
+  }
+}
+
+static VALUE
+mmdb_guard_parse_entry_data_list(VALUE ptr)
+{
+  MMDB_entry_data_list_s *data_list =
+    (struct MMDB_entry_data_list_s *)ptr;
+  VALUE obj;
+
+  mmdb_parse_entry_data_list(data_list, &obj);
+  return obj;
+}
+
+static MMDB_entry_data_list_s *
+mmdb_parse_entry_data_list(MMDB_entry_data_list_s *data_list, VALUE *obj)
+{
+  switch (data_list->entry_data.type) {
+  case MMDB_DATA_TYPE_MAP:
+    {
+      uint32_t data_size = data_list->entry_data.data_size;
+      VALUE hash = rb_hash_new();
+      for (data_list = data_list->next; data_size && data_list; data_size--) {
+        VALUE key;
+        VALUE val;
+        key = mmdb_entry_data_decode(&data_list->entry_data);
+        data_list = data_list->next;
+        data_list = mmdb_parse_entry_data_list(data_list, &val);
+        rb_hash_aset(hash, key, val);
+      }
+      *obj = hash;
+      break;
+    }
+  case MMDB_DATA_TYPE_ARRAY:
+    {
+      uint32_t data_size = data_list->entry_data.data_size;
+      VALUE array = rb_ary_new();
+      for (data_list = data_list->next; data_size && data_list; data_size--) {
+        VALUE val;
+        data_list = mmdb_parse_entry_data_list(data_list, &val);
+        rb_ary_push(array, val);
+      }
+      *obj = array;
+      break;
+    }
+  case MMDB_DATA_TYPE_UTF8_STRING: /* fall through */
+  case MMDB_DATA_TYPE_BYTES:
+  case MMDB_DATA_TYPE_DOUBLE:
+  case MMDB_DATA_TYPE_UINT16:
+  case MMDB_DATA_TYPE_UINT32:
+  case MMDB_DATA_TYPE_INT32:
+  case MMDB_DATA_TYPE_UINT64:
+  case MMDB_DATA_TYPE_UINT128:
+  case MMDB_DATA_TYPE_BOOLEAN:
+  case MMDB_DATA_TYPE_FLOAT:
+    {
+      VALUE val = mmdb_entry_data_decode(&data_list->entry_data);
+      data_list = data_list->next;
+      *obj = val;
+      break;
+    }
+  default:
+    rb_raise(rb_eGeoIP2Error,
+             "Unkown type: %d",
+             data_list->entry_data.type);
+  }
+  return data_list;
+}
+
+static VALUE
+rb_geoip2_db_alloc(VALUE klass)
+{
+  VALUE obj;
+  MMDB_s *mmdb;
+  obj = TypedData_Make_Struct(klass, struct MMDB_s, &rb_mmdb_type, mmdb);
+  return obj;
+}
+
+static VALUE
+rb_geoip2_db_initialize(VALUE self, VALUE path)
+{
+  char *db_path;
+  MMDB_s *mmdb;
+
+  Check_Type(path, T_STRING);
+
+  db_path = StringValueCStr(path);
+
+  TypedData_Get_Struct(self, struct MMDB_s, &rb_mmdb_type, mmdb);
+  mmdb_open(db_path, mmdb);
+
+  return Qnil;
+}
+
+static VALUE
+rb_geoip2_db_close(VALUE self)
+{
+  MMDB_s *mmdb;
+
+  TypedData_Get_Struct(self, struct MMDB_s, &rb_mmdb_type, mmdb);
+
+  if (!mmdb_is_closed(mmdb)) {
+    mmdb_close(mmdb);
+  }
+
+  return Qnil;
+}
+
+static VALUE
+rb_geoip2_db_lookup(VALUE self, VALUE ip)
+{
+  char *ip_str;
+  MMDB_s *mmdb;
+  MMDB_lookup_result_s result;
+  MMDB_lookup_result_s *result_ptr;
+  VALUE obj;
+
+  Check_Type(ip, T_STRING);
+  ip_str = StringValueCStr(ip);
+
+  TypedData_Get_Struct(self, struct MMDB_s, &rb_mmdb_type, mmdb);
+  result = mmdb_lookup(mmdb, ip_str, false);
+
+  if (!result.found_entry) {
+    return Qnil;
+  }
+
+  obj = TypedData_Make_Struct(rb_cGeoIP2LookupResult,
+                              struct MMDB_lookup_result_s,
+                              &rb_lookup_result_type,
+                              result_ptr);
+  result_ptr->found_entry = result.found_entry;
+  result_ptr->entry = result.entry;
+  result_ptr->netmask = result.netmask;
+  return obj;
+}
+
+static VALUE
+rb_geoip2_lr_alloc(VALUE klass)
+{
+  VALUE obj;
+  MMDB_lookup_result_s *result;
+  obj = TypedData_Make_Struct(klass,
+                              struct MMDB_lookup_result_s,
+                              &rb_lookup_result_type,
+                              result);
+  return obj;
+}
+
+static VALUE
+rb_geoip2_lr_initialize(VALUE self)
+{
+  return Qnil;
+}
+
+static VALUE
+rb_geoip2_lr_get_value(int argc, VALUE *argv, VALUE self)
+{
+  VALUE arg;
+  VALUE rest;
+  char **path;
+  int i = 0;
+  MMDB_lookup_result_s *result = NULL;
+  MMDB_entry_s entry;
+  MMDB_entry_data_s entry_data;
+  char *tmp;
+  VALUE e;
+  int status;
+
+  rb_scan_args(argc, argv, "1*", &arg, &rest);
+  Check_Type(arg, T_STRING);
+  path = malloc(sizeof(char *) * (RARRAY_LEN(rest) + 2));
+
+  TypedData_Get_Struct(self,
+                       struct MMDB_lookup_result_s,
+                       &rb_lookup_result_type,
+                       result);
+
+  path[i] = StringValueCStr(arg);
+  while (RARRAY_LEN(rest) != 0) {
+    ++i;
+    e = rb_ary_shift(rest);
+    tmp = StringValueCStr(e);
+    path[i] = tmp;
+  }
+
+  path[i+1] = NULL;
+
+  entry = result->entry;
+
+  status = MMDB_aget_value(&entry, &entry_data, (const char *const *const)path);
+
+  if (status != MMDB_SUCCESS) {
+    free(path);
+    fprintf(stderr, "%s\n", MMDB_strerror(status));
+    return Qnil;
+  }
+
+  if (!entry_data.has_data) {
+    free(path);
+    return Qnil;
+  }
+
+  if (entry_data.type == MMDB_DATA_TYPE_MAP ||
+      entry_data.type == MMDB_DATA_TYPE_ARRAY) {
+    // FIXME optimize below code
+    VALUE array = rb_ary_new();
+    VALUE hash;
+    VALUE val;
+    for (int j = 0; path[j] != NULL; j++) {
+      rb_ary_push(array, rb_str_new_cstr(path[j]));
+    }
+    hash = rb_funcall(self, rb_intern("to_h"), 0);
+    val = rb_apply(hash, rb_intern("dig"), array);
+    free(path);
+    return val;
+  }
+
+  free(path);
+  return mmdb_entry_data_decode(&entry_data);
+}
+
+static VALUE
+rb_geoip2_lr_to_h(VALUE self)
+{
+  MMDB_lookup_result_s *result = NULL;
+  MMDB_entry_data_list_s *entry_data_list = NULL;
+  VALUE hash;
+  int status = 0;
+  int exception = 0;
+
+  TypedData_Get_Struct(self,
+                       struct MMDB_lookup_result_s,
+                       &rb_lookup_result_type,
+                       result);
+  status = MMDB_get_entry_data_list(&result->entry, &entry_data_list);
+  if (status != MMDB_SUCCESS) {
+    rb_raise(rb_eGeoIP2Error, "%s", MMDB_strerror(status));
+  }
+
+  hash = rb_protect(mmdb_guard_parse_entry_data_list, (VALUE)entry_data_list, &exception);
+  MMDB_free_entry_data_list(entry_data_list);
+
+  if (exception != 0) {
+    rb_jump_tag(exception);
+  }
+
+  return hash;
+}
+
+void
+Init_geoip2(void)
+{
+  rb_mGeoIP2 = rb_define_module("GeoIP2");
+  rb_cGeoIP2Database = rb_define_class_under(rb_mGeoIP2, "Database", rb_cData);
+  rb_cGeoIP2LookupResult = rb_define_class_under(rb_mGeoIP2, "LookupResult", rb_cData);
+  rb_eGeoIP2Error = rb_define_class_under(rb_mGeoIP2, "Error", rb_eStandardError);
+
+  rb_define_alloc_func(rb_cGeoIP2Database, rb_geoip2_db_alloc);
+  rb_define_method(rb_cGeoIP2Database, "initialize", rb_geoip2_db_initialize, 1);
+  rb_define_method(rb_cGeoIP2Database, "close", rb_geoip2_db_close, 0);
+  rb_define_method(rb_cGeoIP2Database, "lookup", rb_geoip2_db_lookup, 1);
+
+  rb_define_alloc_func(rb_cGeoIP2LookupResult, rb_geoip2_lr_alloc);
+  rb_define_method(rb_cGeoIP2LookupResult, "initialize", rb_geoip2_lr_initialize, 0);
+  rb_define_method(rb_cGeoIP2LookupResult, "get_value", rb_geoip2_lr_get_value, -1);
+  rb_define_method(rb_cGeoIP2LookupResult, "to_h", rb_geoip2_lr_to_h, 0);
+}

data/geoip2_c.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'geoip2/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "geoip2_c"
+  spec.version       = GeoIP2::VERSION
+  spec.authors       = ["okkez"]
+  spec.email         = ["okkez000@gmail.com"]
+
+  spec.summary       = %q{Write a short summary, because Rubygems requires one.}
+  spec.description   = %q{Write a longer description or delete this line.}
+  spec.homepage      = ""
+  spec.license       = "Apache-2.0"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "bin"
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.extensions    = ["ext/geoip2/extconf.rb"]
+
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 11.0"
+  spec.add_development_dependency "rake-compiler"
+  spec.add_development_dependency "test-unit", "~> 3.2"
+end

data/lib/geoip2/database.rb

@@ -0,0 +1,4 @@
+module GeoIP2
+  class Database
+  end
+end

data/lib/geoip2/lookup_result.rb

@@ -0,0 +1,7 @@
+module GeoIP2
+  class LookupResult
+    def dig(*keys)
+      get_value(*keys)
+    end
+  end
+end

data/lib/geoip2/version.rb

@@ -0,0 +1,3 @@
+module GeoIP2
+  VERSION = "0.1.0"
+end

data/lib/geoip2.rb

@@ -0,0 +1,7 @@
+require "geoip2/version"
+require "geoip2/geoip2"
+require "geoip2/database"
+require "geoip2/lookup_result"
+
+module GeoIP2
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: geoip2_c
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- okkez
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-12-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+description: Write a longer description or delete this line.
+email:
+- okkez000@gmail.com
+executables: []
+extensions:
+- ext/geoip2/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".gitmodules"
+- ".travis.yml"
+- Dockerfile
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- docker-compose.yml
+- ext/geoip2/extconf.rb
+- ext/geoip2/geoip2.c
+- geoip2_c.gemspec
+- lib/geoip2.rb
+- lib/geoip2/database.rb
+- lib/geoip2/lookup_result.rb
+- lib/geoip2/version.rb
+homepage: ''
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.4
+signing_key: 
+specification_version: 4
+summary: Write a short summary, because Rubygems requires one.
+test_files: []