ffi-libarchive 0.2.0 → 0.4.1

data/README.md

@@ -3,10 +3,75 @@ ffi-libarchive
 A Ruby FFI binding to [libarchive][0].
 
 This library provides Ruby FFI bindings to the well-known
-[libarchive library][0]. It aims to be interface compatiable
-to libarchive-ruby.
+[libarchive library][0].
 
-## Why this instead of libarchive-ruby?
+## Installation
+
+Ensure that you have libarchive installed. On Debian/Ubuntu:
+
+```sh
+apt install libarchive13
+```
+
+On macOS with Homebrew:
+```sh
+brew install libarchive
+```
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ffi-libarchive'
+```
+
+And then execute:
+
+```shell
+$ bundle
+```
+
+Or install it yourself as:
+
+```shell
+$ gem install ffi-libarchive
+```
+
+## Usage
+
+To extract an archive into the current directory:
+
+```ruby
+flags = Archive::EXTRACT_PERM
+reader = Archive::Reader.open_filename('/path/to/archive.tgz')
+
+reader.each_entry do |entry|
+  reader.extract(entry, flags.to_i)
+end
+reader.close
+```
+
+To create a gzipped tar archive:
+
+```ruby
+Archive.write_open_filename('my.tgz', Archive::COMPRESSION_GZIP, Archive::FORMAT_TAR_PAX_RESTRICTED) do |tar|
+  content = File.read 'some_path'
+  size = content.size
+  tar.new_entry do |e|
+    e.pathname = 'some_path'
+    e.size = size
+    e.filetype = Archive::Entry::FILE
+    tar.write_header e
+    tar.write_data content
+  end
+end
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at <https://github.com/chef/ffi-libarchive>. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Community Guidelines](https://docs.chef.io/community_guidelines.html) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the Apache License, v2
 
 [0]: https://github.com/libarchive/libarchive
-[1]: https://github.com/Hanmac/libarchive-ruby

data/Rakefile

@@ -1,11 +1,28 @@
-require 'bundler/gem_tasks'
-
-require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new do |t|
-  t.rspec_opts = [
-    '--color',
-    '--format progress',
-  ].join(' ')
+#!/usr/bin/env rake
+
+require "bundler/setup"
+require "bundler/gem_tasks"
+require "chefstyle"
+require "rubocop/rake_task"
+require "rake/testtask"
+
+namespace :style do
+  desc "Run Ruby style checks"
+  RuboCop::RakeTask.new(:ruby)
+end
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/test_ffi-libarchive.rb"]
 end
 
-task default: :spec
+desc "Run all style checks"
+task style: ["style:ruby"]
+
+desc "Run style & unit tests on Travis"
+task travis: %w{style test}
+
+# Default
+desc "Run style, unit"
+task default: %w{style test}

data/VERSION

@@ -0,0 +1 @@
+0.4.1

data/ffi-libarchive.gemspec

@@ -1,25 +1,25 @@
 # coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'ffi-libarchive/version'
+require "ffi-libarchive/version"
 
 Gem::Specification.new do |s|
-  s.name = 'ffi-libarchive'
+  s.name = "ffi-libarchive"
   s.version = Archive::VERSION
-  s.authors = ['John Bellone', 'Jamie Winsor', 'Frank Fischer']
+  s.authors = ["John Bellone", "Jamie Winsor", "Frank Fischer"]
   s.email = %w{jbellone@bloomberg.net jamie@vialstudios.com frank-fischer@shadow-soft.de}
-  s.description = 'A Ruby FFI binding to libarchive.'
+  s.description = "A Ruby FFI binding to libarchive."
   s.summary = s.description
-  s.homepage = 'https://github.com/johnbellone/ffi-libarchive'
-  s.license = 'GPL 3.0'
+  s.homepage = "https://github.com/chef/ffi-libarchive"
+  s.license = "Apache-2.0"
 
-  s.files = `git ls-files`.split($/)
-  s.test_files = s.files.grep(%r{^(test)/})
+  s.files = %w{ Gemfile Rakefile README.md LICENSE VERSION } + Dir.glob("{lib,test}/**/*", File::FNM_DOTMATCH).reject { |f| File.directory?(f) } + Dir.glob("*.gemspec")
   s.require_paths = %w{lib}
-  s.required_ruby_version = '>= 1.9'
+  s.required_ruby_version = ">= 2.4.0"
 
-  s.add_dependency 'ffi', '~> 1.0'
+  s.add_dependency "ffi", "~> 1.0"
 
-  s.add_development_dependency 'bundler'
-  s.add_development_dependency 'rake'
+  s.add_development_dependency "bundler"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "test-unit"
 end

data/lib/ffi-libarchive.rb

@@ -8,8 +8,8 @@ module Archive
   # they will be joined to the end of the libray path using
   # <tt>File.join</tt>.
   #
-  def self.libpath( *args )
-    rv =  args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+  def self.libpath(*args)
+    rv = args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
     if block_given?
       begin
         $LOAD_PATH.unshift LIBPATH
@@ -18,14 +18,14 @@ module Archive
         $LOAD_PATH.shift
       end
     end
-    return rv
+    rv
   end
 
   # Returns the lpath for the module. If any arguments are given,
   # they will be joined to the end of the path using
   # <tt>File.join</tt>.
   #
-  def self.path( *args )
+  def self.path(*args)
     rv = args.empty? ? PATH : ::File.join(PATH, args.flatten)
     if block_given?
       begin
@@ -35,7 +35,7 @@ module Archive
         $LOAD_PATH.shift
       end
     end
-    return rv
+    rv
   end
 
   # Utility method used to require all files ending in .rb that lie in the
@@ -43,15 +43,14 @@ module Archive
   # in. Optionally, a specific _directory_ name can be passed in such that
   # the _filename_ does not have to be equivalent to the directory.
   #
-  def self.require_all_libs_relative_to( fname, dir = nil )
-    dir ||= ::File.basename(fname, '.*')
+  def self.require_all_libs_relative_to(fname, dir = nil)
+    dir ||= ::File.basename(fname, ".*")
     search_me = ::File.expand_path(
-        ::File.join(::File.dirname(fname), dir, '**', '*.rb'))
+      ::File.join(::File.dirname(fname), dir, "**", "*.rb"))
 
-    Dir.glob(search_me).sort.each {|rb| require rb}
+    Dir.glob(search_me).sort.each { |rb| require rb }
   end
-
-end  # module Archive
+end # module Archive
 
 require File.join(Archive::LIBPATH, "ffi-libarchive", "archive")
 require File.join(Archive::LIBPATH, "ffi-libarchive", "reader")

data/lib/ffi-libarchive/archive.rb

@@ -1,15 +1,14 @@
-require 'ffi'
+require "ffi"
 
 module Archive
-
   module C
-    def self.attach_function_maybe *args
+    def self.attach_function_maybe(*args)
       attach_function(*args)
-    rescue FFI::NotFoundError
+    rescue FFI::NotFoundError # rubocop:disable Lint/HandleExceptions
     end
 
     extend FFI::Library
-    ffi_lib ["archive", "libarchive.so.2"]
+    ffi_lib %w{libarchive.so.13 libarchive.13 libarchive.so libarchive archive}
 
     attach_function :archive_version_number, [], :int
     attach_function :archive_version_string, [], :string
@@ -21,8 +20,49 @@ module Archive
     attach_function :archive_read_open_memory, [:pointer, :pointer, :size_t], :int
     attach_function :archive_read_support_compression_program, [:pointer, :string], :int
     attach_function :archive_read_support_compression_all, [:pointer], :int
-    attach_function :archive_read_support_format_all, [:pointer], :int
-    # TODO: this function has been renamed to :archive_read_free in libarchive 3.0
+
+    attach_function_maybe :archive_read_set_format, [:pointer, :int], :int
+    attach_function_maybe :archive_read_append_filter, [:pointer, :int], :int
+    attach_function_maybe :archive_read_append_filter_program, [:pointer, :pointer], :int
+    attach_function_maybe :archive_read_append_filter_program_signature, [:pointer, :string, :pointer, :size_t], :int
+
+    attach_function_maybe :archive_read_support_filter_all, [:pointer], :int
+    attach_function_maybe :archive_read_support_filter_bzip2, [:pointer], :int
+    attach_function_maybe :archive_read_support_filter_compress, [:pointer], :int
+    attach_function_maybe :archive_read_support_filter_gzip, [:pointer], :int
+    attach_function_maybe :archive_read_support_filter_grzip, [:pointer], :int
+    attach_function_maybe :archive_read_support_filter_lrzip, [:pointer], :int
+    attach_function_maybe :archive_read_support_filter_lz4, [:pointer], :int
+    attach_function_maybe :archive_read_support_filter_lzip, [:pointer], :int
+    attach_function_maybe :archive_read_support_filter_lzma, [:pointer], :int
+    attach_function_maybe :archive_read_support_filter_lzop, [:pointer], :int
+    attach_function_maybe :archive_read_support_filter_none, [:pointer], :int
+    attach_function_maybe :archive_read_support_filter_program, [:pointer], :int
+    attach_function_maybe :archive_read_support_filter_program_signature, [:pointer], :int
+    attach_function_maybe :archive_read_support_filter_rpm, [:pointer], :int
+    attach_function_maybe :archive_read_support_filter_uu, [:pointer], :int
+    attach_function_maybe :archive_read_support_filter_xz, [:pointer], :int
+
+    attach_function_maybe :archive_read_support_format_all, [:pointer], :int
+    attach_function_maybe :archive_read_support_format_7zip, [:pointer], :int
+    attach_function_maybe :archive_read_support_format_ar, [:pointer], :int
+    attach_function_maybe :archive_read_support_format_by_code, [:pointer], :int
+    attach_function_maybe :archive_read_support_format_cab, [:pointer], :int
+    attach_function_maybe :archive_read_support_format_cpio, [:pointer], :int
+    attach_function_maybe :archive_read_support_format_empty, [:pointer], :int
+    attach_function_maybe :archive_read_support_format_gnutar, [:pointer], :int
+    attach_function_maybe :archive_read_support_format_iso9660, [:pointer], :int
+    attach_function_maybe :archive_read_support_format_lha, [:pointer], :int
+    attach_function_maybe :archive_read_support_format_mtree, [:pointer], :int
+    attach_function_maybe :archive_read_support_format_rar, [:pointer], :int
+    attach_function_maybe :archive_read_support_format_raw, [:pointer], :int
+    attach_function_maybe :archive_read_support_format_tar, [:pointer], :int
+    attach_function_maybe :archive_read_support_format_warc, [:pointer], :int
+    attach_function_maybe :archive_read_support_format_xar, [:pointer], :int
+    attach_function_maybe :archive_read_support_format_zip, [:pointer], :int
+    attach_function_maybe :archive_read_support_format_zip_streamable, [:pointer], :int
+    attach_function_maybe :archive_read_support_format_zip_seekable, [:pointer], :int
+
     attach_function :archive_read_finish, [:pointer], :int
     attach_function :archive_read_extract, [:pointer, :pointer, :int], :int
     attach_function :archive_read_header_position, [:pointer], :int
@@ -35,13 +75,11 @@ module Archive
     callback :archive_open_callback, [:pointer, :pointer], :int
     callback :archive_write_callback, [:pointer, :pointer, :pointer, :size_t], :int
     callback :archive_close_callback, [:pointer, :pointer], :int
-    # TODO: the following function is the real definition but uses multiple callbacks. This implies that it will not work with Rubinius (currently), but luckily we only need the write-callback actually.
-    #attach_function :archive_write_open, [:pointer, :pointer, :archive_open_callback, :archive_write_callback, :archive_close_callback], :int
     attach_function :archive_write_open, [:pointer, :pointer, :pointer, :archive_write_callback, :pointer], :int
-    # TODO: catch errors if not defined
     attach_function :archive_write_set_compression_none, [:pointer], :int
     attach_function_maybe :archive_write_set_compression_gzip, [:pointer], :int
     attach_function_maybe :archive_write_set_compression_bzip2, [:pointer], :int
+    attach_function_maybe :archive_write_set_compression_deflate, [:pointer], :int
     attach_function_maybe :archive_write_set_compression_compress, [:pointer], :int
     attach_function_maybe :archive_write_set_compression_lzma, [:pointer], :int
     attach_function_maybe :archive_write_set_compression_xz, [:pointer], :int
@@ -159,10 +197,10 @@ module Archive
 
     EOF    = 1
     OK     = 0
-    RETRY  = (-10)
-    WARN   = (-20)
-    FAILED = (-25)
-    FATAL  = (-30)
+    RETRY  = -10
+    WARN   = -20
+    FAILED = -25
+    FATAL  = -30
 
     DATA_BUFFER_SIZE = 2**16
   end
@@ -176,6 +214,11 @@ module Archive
   COMPRESSION_XZ       = 6
   COMPRESSION_UU       = 7
   COMPRESSION_RPM      = 8
+  COMPRESSION_LZIP     = 9
+  COMPRESSION_LRZIP    = 10
+  COMPRESSION_LZOP     = 11
+  COMPRESSION_GRZIP    = 12
+  COMPRESSION_LZ4      = 13
 
   FORMAT_BASE_MASK           = 0xff0000
   FORMAT_CPIO                = 0x10000
@@ -202,58 +245,67 @@ module Archive
   FORMAT_MTREE               = 0x80000
   FORMAT_RAW                 = 0x90000
   FORMAT_XAR                 = 0xA0000
+  FORMAT_LHA                 = 0xB0000
+  FORMAT_CAB                 = 0xC0000
+  FORMAT_RAR                 = 0xD0000
+  FORMAT_7ZIP                = 0xE0000
+  FORMAT_WARC                = 0xF0000
 
-  EXTRACT_OWNER              = (0x0001)
-  EXTRACT_PERM               = (0x0002)
-  EXTRACT_TIME               = (0x0004)
-  EXTRACT_NO_OVERWRITE       = (0x0008)
-  EXTRACT_UNLINK             = (0x0010)
-  EXTRACT_ACL                = (0x0020)
-  EXTRACT_FFLAGS             = (0x0040)
-  EXTRACT_XATTR              = (0x0080)
-  EXTRACT_SECURE_SYMLINKS    = (0x0100)
-  EXTRACT_SECURE_NODOTDOT    = (0x0200)
-  EXTRACT_NO_AUTODIR         = (0x0400)
-  EXTRACT_NO_OVERWRITE_NEWER = (0x0800)
-  EXTRACT_SPARSE             = (0x1000)
+  EXTRACT_OWNER              = 0x0001
+  EXTRACT_PERM               = 0x0002
+  EXTRACT_TIME               = 0x0004
+  EXTRACT_NO_OVERWRITE       = 0x0008
+  EXTRACT_UNLINK             = 0x0010
+  EXTRACT_ACL                = 0x0020
+  EXTRACT_FFLAGS             = 0x0040
+  EXTRACT_XATTR              = 0x0080
+  EXTRACT_SECURE_SYMLINKS    = 0x0100
+  EXTRACT_SECURE_NODOTDOT    = 0x0200
+  EXTRACT_NO_AUTODIR         = 0x0400
+  EXTRACT_NO_OVERWRITE_NEWER = 0x0800
+  EXTRACT_SPARSE             = 0x1000
+  EXTRACT_MAC_METADATA       = 0x2000
+  EXTRACT_NO_HFS_COMPRESSION = 0x4000
+  EXTRACT_HFS_COMPRESSION_FORCED = 0x8000
+  EXTRACT_SECURE_NOABSOLUTEPATHS = 0x10000
+  EXTRACT_CLEAR_NOCHANGE_FFLAGS = 0x20000
 
-  def self.read_open_filename file_name, command = nil, &block
+  def self.read_open_filename(file_name, command = nil, &block)
     Reader.open_filename file_name, command, &block
   end
 
-  def self.read_open_memory string, command = nil, &block
+  def self.read_open_memory(string, command = nil, &block)
     Reader.open_memory string, command, &block
   end
 
-  def self.write_open_filename file_name, compression, format, &block
+  def self.write_open_filename(file_name, compression, format, &block)
     Writer.open_filename file_name, compression, format, &block
   end
 
-  def self.write_open_memory string, compression, format, &block
+  def self.write_open_memory(string, compression, format, &block)
     Writer.open_memory string, compression, format, &block
   end
 
   def self.version_number
-    C::archive_version_number
+    C.archive_version_number
   end
 
   def self.version_string
-    C::archive_version_string
+    C.archive_version_string
   end
 
   class Error < StandardError
     def initialize(archive)
-      if archive.kind_of? String
+      if archive.is_a? String
         super archive
       else
-        super "#{C::archive_error_string(archive)}"
+        super C.archive_error_string(archive).to_s
       end
     end
   end
 
   class BaseArchive
-
-    def initialize alloc, free
+    def initialize(alloc, free)
       @archive = nil
       @archive_free = nil
       @archive = alloc.call
@@ -261,11 +313,11 @@ module Archive
       raise Error, @archive unless @archive
 
       @archive_free[0] = free
-      ObjectSpace.define_finalizer( self, BaseArchive.finalizer(@archive, @archive_free) )
+      ObjectSpace.define_finalizer(self, BaseArchive.finalizer(@archive, @archive_free))
     end
 
-    def self.finalizer archive, archive_free
-      Proc.new do |*args|
+    def self.finalizer(archive, archive_free)
+      proc do |*_args|
         archive_free[0].call(archive) if archive_free[0]
       end
     end
@@ -289,12 +341,11 @@ module Archive
     protected :archive
 
     def error_string
-      C::archive_error_string(@archive)
+      C.archive_error_string(@archive)
     end
 
     def errno
-      C::archive_errno(@archive)
+      C.archive_errno(@archive)
     end
   end
-
 end