apt-pkg 0.0.4 → 0.5.0

data/ext/apt_pkg/apt-pkg.h

@@ -3,6 +3,7 @@
 #include <apt-pkg/debversion.h>
 #include <apt-pkg/pkgcache.h>
 #include <apt-pkg/strutl.h>
+#include <apt-pkg/pkgsystem.h>
 #include <apt-pkg/init.h>
 
 /* from '<ruby/dl.h>' */
@@ -20,5 +21,6 @@ static VALUE string_to_bool(VALUE self, VALUE text);
 static VALUE check_domain_list(VALUE self, VALUE host, VALUE list);
 /* Versioning */
 static VALUE cmp_version(VALUE self, VALUE pkg_version_a, VALUE pkg_version_b);
-static VALUE check_dep(VALUE self, VALUE pkg_version_a, VALUE cmp_type, VALUE pkg_version_b);
+static VALUE check_dep(VALUE self, VALUE pkg_version_a, VALUE cmp_type,
+                       VALUE pkg_version_b);
 static VALUE upstream_version(VALUE self, VALUE ver);

data/ext/apt_pkg/configuration.cpp

@@ -8,16 +8,16 @@
  *   Debian::AptPkg::Configuration.architectures # => ["amd64"]
  *
  **/
-static
-VALUE architectures(VALUE self) {
-    VALUE result = rb_ary_new();
-    std::vector<std::string> arches = APT::Configuration::getArchitectures();
-    std::vector<std::string>::const_iterator I;
-    for (I = arches.begin(); I != arches.end(); I++)
-    {
-        rb_ary_push(result, rb_str_new2((*I).c_str()));
-    }
-    return result;
+static VALUE
+architectures(VALUE self)
+{
+  VALUE result = rb_ary_new();
+  std::vector < std::string > arches = APT::Configuration::getArchitectures();
+  std::vector < std::string >::const_iterator I;
+  for (I = arches.begin(); I != arches.end(); ++I) {
+    rb_ary_push(result, rb_str_new2((*I).c_str()));
+  }
+  return result;
 }
 
 /*
@@ -28,10 +28,11 @@ VALUE architectures(VALUE self) {
  *   Debian::AptPkg::Configuration.check_architecture("all") # => true
  *
  **/
-static
-VALUE check_architecture(VALUE self, VALUE arch) {
-    int res = APT::Configuration::checkArchitecture(StringValuePtr(arch));
-    return INT2BOOL(res);
+static VALUE
+check_architecture(VALUE self, VALUE arch)
+{
+  int res = APT::Configuration::checkArchitecture(StringValuePtr(arch));
+  return INT2BOOL(res);
 }
 
 /*
@@ -47,18 +48,19 @@ VALUE check_architecture(VALUE self, VALUE arch) {
  *   Debian::AptPkg::Configuration.languages(false) # => ["en"]
  *
  **/
-static
-VALUE languages(int argc, VALUE* argv, VALUE self) {
-    VALUE all;
-    rb_scan_args(argc, argv, "01", &all);
-    VALUE result = rb_ary_new();
-    std::vector<std::string> const langs = APT::Configuration::getLanguages(all);
-    std::vector<std::string>::const_iterator I;
-    for (I = langs.begin(); I != langs.end(); I++)
-    {
-        rb_ary_push(result, rb_str_new2((*I).c_str()));
-    }
-    return result;
+static VALUE
+languages(int argc, VALUE *argv, VALUE self)
+{
+  VALUE all;
+  rb_scan_args(argc, argv, "01", &all);
+  VALUE result = rb_ary_new();
+  std::vector < std::string > const langs =
+    APT::Configuration::getLanguages(all);
+  std::vector < std::string >::const_iterator I;
+  for (I = langs.begin(); I != langs.end(); ++I) {
+    rb_ary_push(result, rb_str_new2((*I).c_str()));
+  }
+  return result;
 }
 
 /*
@@ -69,15 +71,16 @@ VALUE languages(int argc, VALUE* argv, VALUE self) {
  *   Debian::AptPkg::Configuration.check_language("fr") # => true
  *
  **/
-static
-VALUE check_language(int argc, VALUE* argv, VALUE self) {
-    if (argc > 2 || argc == 0) {
-        rb_raise(rb_eArgError, "wrong number of arguments");
-    }
-    VALUE lang, all;
-    rb_scan_args(argc, argv, "11", &lang,  &all);
-    int res = APT::Configuration::checkLanguage(StringValuePtr(lang), all);
-    return INT2BOOL(res);
+static VALUE
+check_language(int argc, VALUE *argv, VALUE self)
+{
+  if (argc > 2 || argc == 0) {
+    rb_raise(rb_eArgError, "wrong number of arguments");
+  }
+  VALUE lang, all;
+  rb_scan_args(argc, argv, "11", &lang, &all);
+  int res = APT::Configuration::checkLanguage(StringValuePtr(lang), all);
+  return INT2BOOL(res);
 }
 
 /*
@@ -88,16 +91,16 @@ VALUE check_language(int argc, VALUE* argv, VALUE self) {
  *   Debian::AptPkg::Configuration.compressors # => ["gz"]
  *
  **/
-static
-VALUE compressors(VALUE self) {
-    VALUE result = rb_ary_new();
-    std::vector<std::string> cmps = APT::Configuration::getCompressionTypes();
-    std::vector<std::string>::const_iterator I;
-    for (I = cmps.begin(); I != cmps.end(); I++)
-    {
-        rb_ary_push(result, rb_str_new2((*I).c_str()));
-    }
-    return result;
+static VALUE
+compressors(VALUE self)
+{
+  VALUE result = rb_ary_new();
+  std::vector < std::string > cmps = APT::Configuration::getCompressionTypes();
+  std::vector < std::string >::const_iterator I;
+  for (I = cmps.begin(); I != cmps.end(); ++I) {
+    rb_ary_push(result, rb_str_new2((*I).c_str()));
+  }
+  return result;
 }
 
 /*
@@ -114,17 +117,18 @@ VALUE compressors(VALUE self) {
  *   Debian::AptPkg::Configuration.config_find('Dir::Etc::main') # => "apt.conf"
  *
  **/
-static
-VALUE config_find(int argc, VALUE* argv, VALUE self) {
-    if (argc > 2 || argc == 0) {
-        rb_raise(rb_eArgError, "wrong number of arguments");
-    }
-    VALUE name, default_key;
-    rb_scan_args(argc, argv, "11", &name,  &default_key);
-    if (NIL_P(default_key))
-        default_key = rb_str_new2("");
-    return rb_str_new2(_config->Find(StringValuePtr(name),
-                StringValuePtr(default_key)).c_str());
+static VALUE
+config_find(int argc, VALUE *argv, VALUE self)
+{
+  if (argc > 2 || argc == 0) {
+    rb_raise(rb_eArgError, "wrong number of arguments");
+  }
+  VALUE name, default_key;
+  rb_scan_args(argc, argv, "11", &name, &default_key);
+  if (NIL_P(default_key))
+    default_key = rb_str_new2("");
+  return rb_str_new2(_config->Find(StringValuePtr(name),
+                                   StringValuePtr(default_key)).c_str());
 }
 
 /*
@@ -144,39 +148,43 @@ VALUE config_find(int argc, VALUE* argv, VALUE self) {
  *   Debian::AptPkg::Configuration.config_find_file('Dir::Etc::main') # => "/etc/apt/apt.conf"
  *
  **/
-static
-VALUE config_find_file(int argc, VALUE* argv, VALUE self) {
-    if (argc > 2 || argc == 0) {
-        rb_raise(rb_eArgError, "wrong number of arguments");
-    }
-    VALUE name, default_key;
-    rb_scan_args(argc, argv, "11", &name,  &default_key);
-    if (NIL_P(default_key))
-        default_key = rb_str_new2("");
-    return rb_str_new2(_config->FindFile(StringValuePtr(name),
-                StringValuePtr(default_key)).c_str());
+static VALUE
+config_find_file(int argc, VALUE *argv, VALUE self)
+{
+  if (argc > 2 || argc == 0) {
+    rb_raise(rb_eArgError, "wrong number of arguments");
+  }
+  VALUE name, default_key;
+  rb_scan_args(argc, argv, "11", &name, &default_key);
+  if (NIL_P(default_key))
+    default_key = rb_str_new2("");
+  return rb_str_new2(_config->FindFile(StringValuePtr(name),
+                                       StringValuePtr(default_key)).c_str());
 }
 
 void
-init_apt_pkg_configuration() {
-    VALUE rb_mDebian = rb_define_module("Debian");
-    VALUE rb_mDebianAptPkg = rb_define_module_under(rb_mDebian, "AptPkg");
-    VALUE rb_mDebianAptPkgConfiguration =
-        rb_define_module_under(rb_mDebianAptPkg, "Configuration");
+init_apt_pkg_configuration()
+{
+  VALUE rb_mDebian = rb_define_module("Debian");
+  VALUE rb_mDebianAptPkg = rb_define_module_under(rb_mDebian, "AptPkg");
+  VALUE rb_mDebianAptPkgConfiguration =
+    rb_define_module_under(rb_mDebianAptPkg, "Configuration");
 
-    rb_define_singleton_method(rb_mDebianAptPkgConfiguration, "architectures",
-            RUBY_METHOD_FUNC(architectures), 0);
-    rb_define_singleton_method(rb_mDebianAptPkgConfiguration, "check_architecture",
-            RUBY_METHOD_FUNC(check_architecture), 1);
-    rb_define_singleton_method(rb_mDebianAptPkgConfiguration, "languages",
-            RUBY_METHOD_FUNC(languages), -1);
-    rb_define_singleton_method(rb_mDebianAptPkgConfiguration, "check_language",
-            RUBY_METHOD_FUNC(check_language), -1);
-    rb_define_singleton_method(rb_mDebianAptPkgConfiguration, "compressors",
-            RUBY_METHOD_FUNC(compressors), 0);
+  rb_define_singleton_method(rb_mDebianAptPkgConfiguration, "architectures",
+                             RUBY_METHOD_FUNC(architectures), 0);
+  rb_define_singleton_method(rb_mDebianAptPkgConfiguration,
+                             "check_architecture",
+                             RUBY_METHOD_FUNC(check_architecture), 1);
+  rb_define_singleton_method(rb_mDebianAptPkgConfiguration, "languages",
+                             RUBY_METHOD_FUNC(languages), -1);
+  rb_define_singleton_method(rb_mDebianAptPkgConfiguration, "check_language",
+                             RUBY_METHOD_FUNC(check_language), -1);
+  rb_define_singleton_method(rb_mDebianAptPkgConfiguration, "compressors",
+                             RUBY_METHOD_FUNC(compressors), 0);
 
-    rb_define_singleton_method(rb_mDebianAptPkgConfiguration, "config_find",
-            RUBY_METHOD_FUNC(config_find), -1);
-    rb_define_singleton_method(rb_mDebianAptPkgConfiguration, "config_find_file",
-            RUBY_METHOD_FUNC(config_find_file), -1);
+  rb_define_singleton_method(rb_mDebianAptPkgConfiguration, "config_find",
+                             RUBY_METHOD_FUNC(config_find), -1);
+  rb_define_singleton_method(rb_mDebianAptPkgConfiguration,
+                             "config_find_file",
+                             RUBY_METHOD_FUNC(config_find_file), -1);
 }

data/ext/apt_pkg/extconf.rb

@@ -1,8 +1,5 @@
 require 'mkmf'
-
-have_library("stdc++")
-have_library("apt-pkg")
-
+have_library('stdc++')
+have_library('apt-pkg')
 dir_config('apt_pkg')
-
 create_makefile('apt_pkg')

data/ext/apt_pkg/pkgcache.cpp

@@ -1,65 +1,406 @@
 #include "pkgcache.h"
 
+static VALUE e_mDebianAptPkgInitError, rb_cPackage, rb_cVersion;
+
+/*
+ * private
+ */
+bool
+config_system_initialized()
+{
+  string const arch = _config->Find("APT::Architecture");
+  if (arch.empty()) {
+    return false;
+  }
+  return true;
+}
+
 /*
  * call-seq: gen_caches() -> bool
  *
  * Call the main cache generator.
+ * Raise `Debian::AptPkg::InitError` when config, system, cache is not
+ * configured.
  *
  *   Debian::AptPkg::PkgCache.gen_caches # => false
  *
  **/
-static
-VALUE gen_caches(VALUE self) {
-    pkgCacheFile CacheFile;
-    int res = CacheFile.BuildCaches(NULL, true);
-    return INT2BOOL(res);
+static VALUE
+gen_caches(VALUE self)
+{
+  if (!config_system_initialized()) {
+    rb_raise(e_mDebianAptPkgInitError, "System not initialized");
+  }
+  pkgCacheFile CacheFile;
+  int res = CacheFile.BuildCaches(NULL, true);
+  return INT2BOOL(res);
+}
+
+/*
+ * call-seq: update() -> bool
+ *
+ * Update the index files used by the cache.
+ * Raise `Debian::AptPkg::InitError` when config, system, cache is not
+ * configured.
+ *
+ *   Debian::AptPkg::PkgCache.update # => false
+ *
+ **/
+static VALUE
+update(VALUE self)
+{
+  if (!config_system_initialized()) {
+    rb_raise(e_mDebianAptPkgInitError, "System not initialized");
+  }
+  pkgCacheFile CacheFile;
+  // Get the source list
+  if (CacheFile.BuildSourceList() == false) {
+    return Qnil;
+  }
+  pkgAcquireStatus *Stat(NULL);
+  pkgSourceList *List = CacheFile.GetSourceList();
+  int res = ListUpdate(*Stat, *List);
+  return INT2BOOL(res);
+}
+
+/*
+ * call-seq: is_multi_arch() -> bool
+ *
+ * An attribute determining whether the cache supports multi-arch.
+ * Raise `Debian::AptPkg::InitError` when config, system, cache is not
+ * configured.
+ *
+ *   Debian::AptPkg::PkgCache.is_multi_arch # => false
+ *
+ **/
+static VALUE
+is_multi_arch(VALUE self)
+{
+  if (!config_system_initialized()) {
+    rb_raise(e_mDebianAptPkgInitError, "System not initialized");
+  }
+  pkgCacheFile CacheFile;
+  pkgCache *Cache = CacheFile.GetPkgCache();
+  if (Cache == NULL) {
+    return Qnil;
+  }
+  int res = Cache->MultiArchCache();
+  return INT2BOOL(res);
+}
+
+/*
+ * call-seq: packages() -> array, nil
+ *
+ * A list of Debian::AptPkg::Package objects stored in the cache
+ * Raise `Debian::AptPkg::InitError` when config, system, cache is not
+ * configured.
+ *
+ *   Debian::AptPkg::PkgCache.packages
+ *
+ **/
+static VALUE
+packages(int argc, VALUE *argv, VALUE self)
+{
+  if (!config_system_initialized()) {
+    rb_raise(e_mDebianAptPkgInitError, "System not initialized");
+  }
+  VALUE result = rb_ary_new();
+  pkgCacheFile CacheFile;
+  if (CacheFile.GetPkgCache() == 0) {
+    return Qnil;
+  }
+  for (pkgCache::PkgIterator Pkg = CacheFile.GetPkgCache()->PkgBegin(); not Pkg.end(); ++Pkg) {
+    VALUE current_version;
+    if (Pkg->CurrentVer == 0) {
+      current_version = Qnil;
+    } else {
+      current_version = rb_struct_new(rb_cVersion,
+          rb_str_new2(Pkg.CurrentVer().ParentPkg().Name()),
+          rb_str_new2(Pkg.CurrentVer().VerStr()),
+          rb_str_new2(Pkg.CurrentVer().Section()),
+          rb_str_new2(Pkg.CurrentVer().Arch()),
+          INT2FIX(Pkg.CurrentVer()->Size),
+          INT2FIX(Pkg.CurrentVer()->InstalledSize),
+          INT2FIX(Pkg.CurrentVer()->Hash),
+          INT2FIX(Pkg.CurrentVer()->ID),
+          INT2FIX(Pkg.CurrentVer()->Priority)
+          );
+    }
+    VALUE rb_cPackage_args[7];
+    rb_cPackage_args[0] = INT2FIX(Pkg->ID);
+    rb_cPackage_args[1] = rb_str_new2(Pkg.Name());
+    rb_cPackage_args[2] = rb_str_new2(Pkg.FullName().c_str());
+    rb_cPackage_args[3] = rb_str_new2(Pkg.Arch());
+    rb_cPackage_args[4] = INT2BOOL((Pkg->Flags & pkgCache::Flag::Essential) != 0);
+    rb_cPackage_args[5] = INT2BOOL((Pkg->Flags & pkgCache::Flag::Important) != 0);
+    rb_cPackage_args[6] = current_version;
+    rb_ary_push(result, rb_class_new_instance(7,
+          rb_cPackage_args,
+          rb_cPackage
+          ));
+  }
+  return result;
 }
 
 /*
  * call-seq: pkg_names() -> array, nil
  *
+ * Deprecated and will removed in 0.6.0
  * List the names of all packages in the system.
- * Return nil when cache is not generated.
+ * Raise `Debian::AptPkg::InitError` when config, system, cache is not
+ * configured.
  *
  *   Debian::AptPkg::PkgCache.pkg_names('gcolor2') # => ["gcolor2"]
  *
  **/
-static
-VALUE pkg_names(int argc, VALUE* argv, VALUE self) {
-    if (argc > 1 || argc == 0) {
-        rb_raise(rb_eArgError, "You must give at least one search argument");
-    }
-    VALUE name;
-    rb_scan_args(argc, argv, "01", &name);
-    if (NIL_P(name) || RSTRING_LEN(name) < 1) {
-        rb_raise(rb_eArgError, "You must give at least one search pattern");
-    }
-    VALUE result = rb_ary_new();
+static VALUE
+pkg_names(int argc, VALUE *argv, VALUE self)
+{
+  rb_warn("Debian::AptPkg::PkgCache.pkg_names is deprecated; " \
+          "use Debian::AptPkg::PkgCache.packages instead");
+  if (!config_system_initialized()) {
+    rb_raise(e_mDebianAptPkgInitError, "System not initialized");
+  }
+  if (argc > 1 || argc == 0) {
+    rb_raise(rb_eArgError, "You must give at least one search argument");
+  }
+  VALUE name;
+  rb_scan_args(argc, argv, "01", &name);
+  if (NIL_P(name) || RSTRING_LEN(name) < 1) {
+    rb_raise(rb_eArgError, "You must give at least one search pattern");
+  }
+  VALUE result = rb_ary_new();
 
-    pkgCacheFile CacheFile;
-    if (CacheFile.GetPkgCache() == 0) {
-        return Qnil;
-    }
-    pkgCache::GrpIterator I = CacheFile.GetPkgCache()->GrpBegin();
+  pkgCacheFile CacheFile;
+  if (CacheFile.GetPkgCache() == 0) {
+    return Qnil;
+  }
+  pkgCache::GrpIterator I = CacheFile.GetPkgCache()->GrpBegin();
 
-    const char *pkgname = StringValuePtr(name);
-    for (;I.end() != true; ++I) {
-        if (strncmp(I.Name(), pkgname, strlen(pkgname)) == 0) {
-            rb_ary_push(result, rb_str_new2(I.Name()));
-        }
+  const char *pkgname = StringValuePtr(name);
+  for (; I.end() != true; ++I) {
+    if (strncmp(I.Name(), pkgname, strlen(pkgname)) == 0) {
+      rb_ary_push(result, rb_str_new2(I.Name()));
     }
-    return result;
+  }
+  return result;
+}
+
+/*
+ * call-seq: package_count() -> int, nil
+ *
+ * The total number of packages available in the cache.
+ * Raise `Debian::AptPkg::InitError` when config, system, cache is not
+ * configured.
+ *
+ *   Debian::AptPkg::PkgCache.package_count # => 69511
+ *
+ **/
+static VALUE
+package_count(VALUE self)
+{
+  if (!config_system_initialized()) {
+    rb_raise(e_mDebianAptPkgInitError, "System not initialized");
+  }
+  pkgCacheFile CacheFile;
+  pkgCache *Cache = CacheFile.GetPkgCache();
+  if (Cache == NULL) {
+    return Qnil;
+  }
+  return INT2FIX(Cache->HeaderP->PackageCount);
+}
+
+/*
+ * call-seq: version_count() -> int, nil
+ *
+ * The total number of package versions available in the cache.
+ * Raise `Debian::AptPkg::InitError` when config, system, cache is not
+ * configured.
+ *
+ *   Debian::AptPkg::PkgCache.version_count # => 84630
+ *
+ **/
+static VALUE
+version_count(VALUE self)
+{
+  if (!config_system_initialized()) {
+    rb_raise(e_mDebianAptPkgInitError, "System not initialized");
+  }
+  pkgCacheFile CacheFile;
+  pkgCache *Cache = CacheFile.GetPkgCache();
+  if (Cache == NULL) {
+    return Qnil;
+  }
+  return INT2FIX(Cache->HeaderP->VersionCount);
+}
+
+/*
+ * call-seq: depends_count() -> int, nil
+ *
+ * The total number of dependencies stored in the cache.
+ * Raise `Debian::AptPkg::InitError` when config, system, cache is not
+ * configured.
+ *
+ *   Debian::AptPkg::PkgCache.depends_count # => 551983
+ *
+ **/
+static VALUE
+depends_count(VALUE self)
+{
+  if (!config_system_initialized()) {
+    rb_raise(e_mDebianAptPkgInitError, "System not initialized");
+  }
+  pkgCacheFile CacheFile;
+  pkgCache *Cache = CacheFile.GetPkgCache();
+  if (Cache == NULL) {
+    return Qnil;
+  }
+  return INT2FIX(Cache->HeaderP->DependsCount);
+}
+
+/*
+ * call-seq: package_file_count() -> int, nil
+ *
+ * The total number of packages files available.
+ * Raise `Debian::AptPkg::InitError` when config, system, cache is not
+ * configured.
+ *
+ *   Debian::AptPkg::PkgCache.package_file_count # => 17
+ *
+ **/
+static VALUE
+package_file_count(VALUE self)
+{
+  if (!config_system_initialized()) {
+    rb_raise(e_mDebianAptPkgInitError, "System not initialized");
+  }
+  pkgCacheFile CacheFile;
+  pkgCache *Cache = CacheFile.GetPkgCache();
+  if (Cache == NULL) {
+    return Qnil;
+  }
+  return INT2FIX(Cache->HeaderP->PackageFileCount);
+}
+
+/*
+ * call-seq: ver_file_count() -> int, nil
+ *
+ * The total number of version and package file relations stored in the cache.
+ * Raise `Debian::AptPkg::InitError` when config, system, cache is not
+ * configured.
+ *
+ *   Debian::AptPkg::PkgCache.ver_file_count # => 11274
+ *
+ **/
+static VALUE
+ver_file_count(VALUE self)
+{
+  if (!config_system_initialized()) {
+    rb_raise(e_mDebianAptPkgInitError, "System not initialized");
+  }
+  pkgCacheFile CacheFile;
+  pkgCache *Cache = CacheFile.GetPkgCache();
+  if (Cache == NULL) {
+    return Qnil;
+  }
+  return INT2FIX(Cache->HeaderP->VerFileCount);
+}
+
+/*
+ * call-seq: provides_count() -> int, nil
+ *
+ * The number of provided packages.
+ * Raise `Debian::AptPkg::InitError` when config, system, cache is not
+ * configured.
+ *
+ *   Debian::AptPkg::PkgCache.provides_count # => 69511
+ *
+ **/
+static VALUE
+provides_count(VALUE self)
+{
+  if (!config_system_initialized()) {
+    rb_raise(e_mDebianAptPkgInitError, "System not initialized");
+  }
+  pkgCacheFile CacheFile;
+  pkgCache *Cache = CacheFile.GetPkgCache();
+  if (Cache == NULL) {
+    return Qnil;
+  }
+  return INT2FIX(Cache->HeaderP->ProvidesCount);
+}
+
+/*
+ * call-seq: group_count() -> int, nil
+ *
+ * The number of groups in the cache.
+ * Raise `Debian::AptPkg::InitError` when config, system, cache is not
+ * configured.
+ *
+ *   Debian::AptPkg::PkgCache.group_count # => 16730
+ *
+ **/
+static VALUE
+group_count(VALUE self)
+{
+  if (!config_system_initialized()) {
+    rb_raise(e_mDebianAptPkgInitError, "System not initialized");
+  }
+  pkgCacheFile CacheFile;
+  pkgCache *Cache = CacheFile.GetPkgCache();
+  if (Cache == NULL) {
+    return Qnil;
+  }
+  return INT2FIX(Cache->HeaderP->GroupCount);
 }
 
 void
-init_apt_pkg_pkgcache() {
-    VALUE rb_mDebian = rb_define_module("Debian");
-    VALUE rb_mDebianAptPkg = rb_define_module_under(rb_mDebian, "AptPkg");
-    VALUE rb_mDebianAptPkgConfiguration = rb_define_module_under(rb_mDebianAptPkg,
-            "PkgCache");
-
-    rb_define_singleton_method(rb_mDebianAptPkgConfiguration, "gen_caches",
-            RUBY_METHOD_FUNC(gen_caches), 0);
-    rb_define_singleton_method(rb_mDebianAptPkgConfiguration, "pkg_names",
-            RUBY_METHOD_FUNC(pkg_names), -1);
+init_apt_pkg_pkgcache()
+{
+  VALUE rb_mDebian = rb_define_module("Debian");
+  VALUE rb_mDebianAptPkg = rb_define_module_under(rb_mDebian, "AptPkg");
+  VALUE rb_mDebianAptPkgCache = rb_define_module_under(rb_mDebianAptPkg,
+                                                               "PkgCache");
+  e_mDebianAptPkgInitError = rb_define_class_under(rb_mDebianAptPkg,
+                                                    "InitError",
+                                                    rb_eRuntimeError);
+  rb_cPackage = rb_const_get_at(rb_mDebianAptPkg, rb_intern("Package"));
+  rb_cVersion = rb_struct_define_under(rb_mDebianAptPkg, "Version",
+      "parent_package_name",
+      "version_string",
+      "section",
+      "arch",
+      "size",
+      "installed_size",
+      "hash",
+      "id",
+      "priority",
+      NULL);
+
+  rb_define_singleton_method(rb_mDebianAptPkgCache, "gen_caches",
+                             RUBY_METHOD_FUNC(gen_caches), 0);
+  rb_define_singleton_method(rb_mDebianAptPkgCache, "update",
+                             RUBY_METHOD_FUNC(update), 0);
+  rb_define_singleton_method(rb_mDebianAptPkgCache, "is_multi_arch",
+                             RUBY_METHOD_FUNC(is_multi_arch), 0);
+  rb_define_singleton_method(rb_mDebianAptPkgCache, "packages",
+                             RUBY_METHOD_FUNC(packages), 0);
+  rb_define_singleton_method(rb_mDebianAptPkgCache, "pkg_names",
+                             RUBY_METHOD_FUNC(pkg_names), -1);
+
+  rb_define_singleton_method(rb_mDebianAptPkgCache, "package_count",
+                             RUBY_METHOD_FUNC(package_count), 0);
+  rb_define_singleton_method(rb_mDebianAptPkgCache, "version_count",
+                             RUBY_METHOD_FUNC(version_count), 0);
+  rb_define_singleton_method(rb_mDebianAptPkgCache, "depends_count",
+                             RUBY_METHOD_FUNC(depends_count), 0);
+  rb_define_singleton_method(rb_mDebianAptPkgCache,
+                             "package_file_count",
+                             RUBY_METHOD_FUNC(package_file_count), 0);
+  rb_define_singleton_method(rb_mDebianAptPkgCache, "ver_file_count",
+                             RUBY_METHOD_FUNC(ver_file_count), 0);
+  rb_define_singleton_method(rb_mDebianAptPkgCache, "provides_count",
+                             RUBY_METHOD_FUNC(provides_count), 0);
+  rb_define_singleton_method(rb_mDebianAptPkgCache, "group_count",
+                             RUBY_METHOD_FUNC(group_count), 0);
 }