apt-pkg 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 16cd206a5d9b3137497d05f937ef5b78fcac7aa6bd62e4177b73ef98ff0d917e
+  data.tar.gz: b0bcc23a93c8112321c890487ee385c7cede6da1b3179da4e5f0ebf11b723161
+SHA512:
+  metadata.gz: 3e650327a185fca89e757e30659c8c61371e7d2950e47b72e463a6ed598da4656e7fcc2f831830acea7de9e045242636077746d9f692ab5ca55dc9f62182db56
+  data.tar.gz: 8ab515778e66c88f8b53f10d03d65e95db89db8061f166bd4235b2dd47f18433187162b645d663a8f38bcf937d06d4a7fbdd14391b887eafadc4652b35cad80c

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/History.md

@@ -0,0 +1,55 @@
+
+0.5.0 / 2020-07-22
+==================
+
+  * Debian::AptPkg::PkgCache.pkg_names deprecated
+  * Add all maintained Rubies on gitlab-ci
+  * Init listing packages on cache
+  * Quick fix gitlab ci
+  * Add .gitlab-ci.yml
+  * Rename lib/debian/apt_pkg/{version,gem_version}.rb
+  * Update README
+  * Tidy tests remove should
+  * Debian::AptPkg.init returns a boolean
+  * Fix mimitest warnings
+  * Remove cppcheck on CI version conflict
+  * Fix code lint
+  * Fix CI and update Rubies
+  * Fix libapt-pkg 2.1 compat
+  * Update apt-pkg deps
+  * Update doc Debian::AptPkg::InitError
+  * README: Bundler is not needed
+  * Use Debian::AptPkg::InitError instead of RuntimeError
+  * Fix rb_mDebianAptPkgCache name
+
+0.4.0 / 2016-10-06
+==================
+
+  * Raise RuntimeError instead of returning `nil`
+
+0.3.0 / 2016-01-23
+==================
+
+  * Prefer prefix ++/-- operators for non-primitive types
+  * Add Debian::AptPkg::PkgCache.update
+
+0.2.0 / 2016-01-04
+==================
+
+  * Fix cache count methods when not init
+  * Add init, init_{config,system}
+  * Add PkgCache.is_multi_arch method
+
+0.1.0 / 2015-12-20
+==================
+
+  * Change VERSION, APT_VERSION and LIBAPT_PKG_VERSION
+  * Add cache count methods
+  * Fix rake lint task exit status
+  * Fix syntax offences
+
+0.0.4 / 2015-12-19
+==================
+
+  * Simple search with `Debian::AptPkg::PkgCache.pkg_names("vim")`
+  * Documentation update

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License
+
+Copyright (c) 2014-2020 Laurent Arnoud <laurent@spkdev.net>
+
+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,63 @@
+# Ruby interface to apt-pkg
+
+Goal of this project is to have a proper Ruby binding to APT like in
+[Python](https://tracker.debian.org/pkg/python-apt).
+
+Currently install, remove packages commands are **not** implemented.
+
+## INSTALL
+
+```
+apt install build-essential ruby-dev libapt-pkg-dev (>= 1.0)
+gem install apt-pkg
+```
+
+## USING
+
+Basic usage:
+
+``` ruby
+require 'debian/apt_pkg'
+
+# Initialize the configuration and system of apt
+Debian::AptPkg.init
+
+# Update the index files used by the cache
+Debian::AptPkg::PkgCache.update
+
+# Search package by names
+Debian::AptPkg::PkgCache.pkg_names("vim")
+
+# List packages stored in the cache
+Debian::AptPkg::PkgCache.packages
+
+# List installed packages
+Debian::AptPkg::PkgCache.packages.select {|pkg| pkg.is_installed }
+```
+
+[Documentation](http://www.rubydoc.info/gems/apt-pkg)
+
+## BUILD
+
+``` console
+rake compile
+```
+
+## TEST
+
+``` console
+rake test
+```
+
+## LICENSE
+
+The MIT License
+
+Copyright (c) 2014-2020 Laurent Arnoud <laurent@spkdev.net>
+
+---
+[![Build](https://img.shields.io/travis/spk/ruby-apt-pkg.svg)](https://travis-ci.org/spk/ruby-apt-pkg)
+[![Version](https://img.shields.io/gem/v/apt-pkg.svg)](https://rubygems.org/gems/apt-pkg)
+[![Documentation](https://img.shields.io/badge/doc-rubydoc-blue.svg)](http://www.rubydoc.info/gems/apt-pkg)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](http://opensource.org/licenses/MIT "MIT")
+[![Project status](https://img.shields.io/badge/status-experimental-red)](https://github.com/spk/ruby-apt-pkg)

data/ext/apt_pkg/apt-pkg.cpp

@@ -0,0 +1,249 @@
+#include "apt-pkg.h"
+#include "configuration.h"
+#include "pkgcache.h"
+
+/*
+ * call-seq: init() -> bool
+ *
+ * Shorthand for doing init_config() and init_system().
+ *
+ *   Debian::AptPkg.init # => true
+ *
+ **/
+static VALUE
+init(VALUE self)
+{
+  int res = pkgInitConfig(*_config) && pkgInitSystem(*_config, _system);
+  return INT2BOOL(res);
+}
+
+/*
+ * call-seq: init_config() -> bool
+ *
+ * Load the default configuration and the config file.
+ *
+ *   Debian::AptPkg.init_config # => false
+ *
+ **/
+static VALUE
+init_config(VALUE self)
+{
+  int res = pkgInitConfig(*_config);
+  return INT2BOOL(res);
+}
+
+/*
+ * call-seq: init_system() -> bool
+ *
+ * Construct the apt_pkg system.
+ *
+ *   Debian::AptPkg.init_system # => false
+ *
+ **/
+static VALUE
+init_system(VALUE self)
+{
+  int res = pkgInitSystem(*_config, _system);
+  return INT2BOOL(res);
+}
+
+/*
+ * call-seq: cmp_version(pkg_version_a, pkg_version_b) -> int
+ *
+ * Compare the given versions.
+ *
+ * Return a strictly negative value if 'a' is smaller than 'b', 0 if they
+ * are equal, and a strictly positive value if 'a' is larger than 'b'.
+ *
+ *   Debian::AptPkg.cmp_version('1.1', '1.0') # => 1
+ *   Debian::AptPkg.cmp_version('1.0', '1.0') # => 0
+ *   Debian::AptPkg.cmp_version('1.0', '1.1') # => -1
+ *
+ **/
+static VALUE
+cmp_version(VALUE self, VALUE pkg_version_a, VALUE pkg_version_b)
+{
+  int res = debVS.CmpVersion(StringValuePtr(pkg_version_a),
+                             StringValuePtr(pkg_version_b));
+  return INT2FIX(res);
+}
+
+/*
+ * call-seq: check_dep(pkg_version_a, op, pkg_version_b) -> bool
+ *
+ * Compare the given versions with an operator.
+ *
+ * Params:
+ *
+ * +pkg_version_a+:: Version to compare from.
+ * +op+:: See operators const or string (<, >, <=, >=, =)
+ * +pkg_version_b+:: Version to compare to.
+ *
+ *   Debian::AptPkg.check_dep('1', '<', '2') # => true
+ *   Debian::AptPkg.check_dep('1', Debian::AptPkg::NOT_EQUALS, '2') # => true
+ *
+ **/
+static VALUE
+check_dep(VALUE self, VALUE pkg_version_a, VALUE cmp_type, VALUE pkg_version_b)
+{
+  unsigned int op = 0;
+  if (TYPE(cmp_type) == T_FIXNUM) {
+    op = NUM2INT(cmp_type);
+  } else {
+    const char *op_str = StringValuePtr(cmp_type);
+    if (strcmp(op_str, ">") == 0)
+      op_str = ">>";
+    if (strcmp(op_str, "<") == 0)
+      op_str = "<<";
+    if (*debListParser::ConvertRelation(op_str, op) != 0) {
+      rb_raise(rb_eArgError, "Bad comparison operation");
+      return 0;
+    }
+  }
+  int res = debVS.CheckDep(StringValuePtr(pkg_version_a), op,
+                           StringValuePtr(pkg_version_b));
+  return INT2BOOL(res);
+}
+
+/*
+ * call-seq: uri_to_filename(uri) -> string
+ *
+ * Return a filename which can be used to store the file.
+ *
+ *   Debian::AptPkg.uri_to_filename('http://debian.org/index.html') # => 'debian.org_index.html'
+ *
+ **/
+static VALUE
+uri_to_filename(VALUE self, VALUE uri)
+{
+  return rb_str_new2(URItoFileName(StringValuePtr(uri)).c_str());
+}
+
+/*
+ * call-seq: upstream_version(ver) -> string
+ *
+ * Return the upstream version for the Debian package version given by version.
+ *
+ *   Debian::AptPkg.upstream_version('3.4.15-1+b1') # => '3.4.15'
+ *
+ **/
+static VALUE
+upstream_version(VALUE self, VALUE ver)
+{
+  return rb_str_new2(debVS.UpstreamVersion(StringValuePtr(ver)).c_str());
+}
+
+/*
+ * call-seq: time_to_str(secondes) -> string
+ *
+ * Format a given duration in human-readable manner.
+ *
+ *   Debian::AptPkg.time_to_str(3601) # => '1h 0min 1s'
+ *
+ **/
+static VALUE
+time_to_str(VALUE self, VALUE secondes)
+{
+  return rb_str_new2(TimeToStr(NUM2INT(secondes)).c_str());
+}
+
+/*
+ * call-seq: size_to_str(size) -> string
+ *
+ * Return a string describing the size in a human-readable manner.
+ *
+ *   Debian::AptPkg.size_to_str(10000) # => '10.0 k'
+ *
+ **/
+static VALUE
+size_to_str(VALUE self, VALUE size)
+{
+  return rb_str_new2(SizeToStr(NUM2INT(size)).c_str());
+}
+
+/*
+ * call-seq: string_to_bool(text) -> int
+ *
+ * Parse the string input and return a boolean.
+ *
+ *   Debian::AptPkg.string_to_bool('yes') # => true
+ *   Debian::AptPkg.string_to_bool('no') # => false
+ *   Debian::AptPkg.string_to_bool('no-recognized') # => false
+ *
+ **/
+static VALUE
+string_to_bool(VALUE self, VALUE text)
+{
+  return INT2BOOL(StringToBool(StringValuePtr(text)) == 1);
+}
+
+/*
+ * call-seq: check_domain_list(host, list) -> bool
+ *
+ * See if the host name given by host is one of the domains given.
+ *
+ *   Debian::AptPkg.check_domain_list("alioth.debian.org", "debian.net,debian.org") # => true
+ *
+ **/
+static VALUE
+check_domain_list(VALUE self, VALUE host, VALUE list)
+{
+  int res = CheckDomainList(StringValuePtr(host), StringValuePtr(list));
+  return INT2BOOL(res);
+}
+
+void
+// cppcheck-suppress unusedFunction
+Init_apt_pkg()
+{
+  VALUE rb_mDebian = rb_define_module("Debian");
+  VALUE rb_mDebianAptPkg = rb_define_module_under(rb_mDebian, "AptPkg");
+
+  rb_define_singleton_method(rb_mDebianAptPkg, "init",
+                             RUBY_METHOD_FUNC(init), 0);
+  rb_define_singleton_method(rb_mDebianAptPkg, "init_config",
+                             RUBY_METHOD_FUNC(init_config), 0);
+  rb_define_singleton_method(rb_mDebianAptPkg, "init_system",
+                             RUBY_METHOD_FUNC(init_system), 0);
+
+  rb_define_singleton_method(rb_mDebianAptPkg, "uri_to_filename",
+                             RUBY_METHOD_FUNC(uri_to_filename), 1);
+  rb_define_singleton_method(rb_mDebianAptPkg, "time_to_str",
+                             RUBY_METHOD_FUNC(time_to_str), 1);
+  rb_define_singleton_method(rb_mDebianAptPkg, "size_to_str",
+                             RUBY_METHOD_FUNC(size_to_str), 1);
+  rb_define_singleton_method(rb_mDebianAptPkg, "string_to_bool",
+                             RUBY_METHOD_FUNC(string_to_bool), 1);
+  rb_define_singleton_method(rb_mDebianAptPkg, "check_domain_list",
+                             RUBY_METHOD_FUNC(check_domain_list), 2);
+  rb_define_singleton_method(rb_mDebianAptPkg, "cmp_version",
+                             RUBY_METHOD_FUNC(cmp_version), 2);
+  rb_define_singleton_method(rb_mDebianAptPkg, "check_dep",
+                             RUBY_METHOD_FUNC(check_dep), 3);
+  rb_define_singleton_method(rb_mDebianAptPkg, "upstream_version",
+                             RUBY_METHOD_FUNC(upstream_version), 1);
+
+  /* Represents less equal operator. */
+  rb_define_const(rb_mDebianAptPkg, "LESS_EQ", INT2FIX(pkgCache::Dep::LessEq));
+  /* Represents greater equal operator. */
+  rb_define_const(rb_mDebianAptPkg, "GREATER_EQ",
+                  INT2FIX(pkgCache::Dep::GreaterEq));
+  /* Represents less operator. */
+  rb_define_const(rb_mDebianAptPkg, "LESS", INT2FIX(pkgCache::Dep::Less));
+  /* Represents greater operator. */
+  rb_define_const(rb_mDebianAptPkg, "GREATER", INT2FIX(pkgCache::Dep::Greater));
+  /* Represents equals operator. */
+  rb_define_const(rb_mDebianAptPkg, "EQUALS", INT2FIX(pkgCache::Dep::Equals));
+  /* Represents not equals operator. */
+  rb_define_const(rb_mDebianAptPkg, "NOT_EQUALS",
+                  INT2FIX(pkgCache::Dep::NotEquals));
+
+  /* Represents the version of apt. */
+  rb_define_const(rb_mDebianAptPkg, "APT_VERSION", rb_str_new2(pkgVersion));
+  /* Represents the version of apt_pkg library. */
+  rb_define_const(rb_mDebianAptPkg, "LIBAPT_PKG_VERSION",
+                  rb_str_new2(pkgLibVersion));
+
+  init_apt_pkg_configuration();
+  init_apt_pkg_pkgcache();
+}

data/ext/apt_pkg/apt-pkg.h

@@ -0,0 +1,26 @@
+#include <ruby.h>
+#include <apt-pkg/deblistparser.h>
+#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>' */
+#define INT2BOOL(x)  ((x) ? Qtrue : Qfalse)
+
+using namespace std;
+
+/* function prototypes */
+extern "C" void Init_apt_pkg();
+/* String functions */
+static VALUE uri_to_filename(VALUE self, VALUE uri);
+static VALUE time_to_str(VALUE self, VALUE secondes);
+static VALUE size_to_str(VALUE self, VALUE size);
+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 upstream_version(VALUE self, VALUE ver);

data/ext/apt_pkg/configuration.cpp

@@ -0,0 +1,190 @@
+#include "configuration.h"
+
+/*
+ * call-seq: architectures() -> array
+ *
+ * Return the list of architectures supported on this system.
+ *
+ *   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;
+}
+
+/*
+ * call-seq: check_architecture(arch) -> bool
+ *
+ * Are we interested in the given Architecture.
+ *
+ *   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);
+}
+
+/*
+ * call-seq: languages() -> array
+ *
+ * Return the list of languages code.
+ *
+ * Params:
+ *
+ * +all+:: All languages code or short for false.
+ *
+ *   Debian::AptPkg::Configuration.languages # => ["en", "none", "fr"]
+ *   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;
+}
+
+/*
+ * call-seq: check_language(lang, all) -> bool
+ *
+ * Are we interested in the given language.
+ *
+ *   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);
+}
+
+/*
+ * call-seq: compressors() -> array
+ *
+ * Return the list of compressors supported on this system.
+ *
+ *   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;
+}
+
+/*
+ * call-seq: config_find(name, default_key = '') -> string
+ *
+ * Return the value stored at the option named key, or the value given by the
+ * string default if the option in question is not set.
+ *
+ * Params:
+ *
+ * +name+:: Key name.
+ * +default_key+:: Default key when config option not set.
+ *
+ *   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());
+}
+
+/*
+ * call-seq: config_find_file(name, default_key = '') -> string
+ *
+ * Locate the given key using find() and return the path to the file/directory.
+ * This uses a special algorithms which moves upwards in the configuration space
+ * and prepends the values of the options to the result. These methods are
+ * generally used for the options stored in the ‘Dir’ section of the
+ * configuration.
+ *
+ * Params:
+ *
+ * +name+:: Key name.
+ * +default_key+:: Default key when config option not set.
+ *
+ *   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());
+}
+
+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");
+
+  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);
+}