ffi-libarchive 0.4.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd86d5c024c71eab9c05b65c2a650423acf6e082f09e65167b87a07c2ec9c6d5
-  data.tar.gz: b4ee964dc4caa87255c2f4ca6eedd43e6a962112f9481696ead94314bd7c482f
+  metadata.gz: 7a37a59bb2528341adba957354cc76a776d726a715390e6fa2261b9effcca7ca
+  data.tar.gz: 3e94f65843192c53a13352c0790833aad2e2deea833b6d97e68e068ffc5c2bef
 SHA512:
-  metadata.gz: 35e0e854d76bd8d579c2c3626a62474a7bd735df3f30f294068d0864c396d93957d3cba73b0fd4880c9e3035aca45aa31611e5ebdc9b9c73c68be5816b3cdb38
-  data.tar.gz: bb5610e6b77babfb94d535248de078674a5697cfcac3a0d37882da27455c9c7440f404d69127171628ec4ae320182d6ef34bc877a96957545593628545a8457c
+  metadata.gz: dddc27a6897a12278ef644b124c9f3e718cb837fba7e2b164cc4766041b8063139be1836525bbcfa7a13cd1be8637155c6a96a470cc4ada3448482cb2db9c14b
+  data.tar.gz: b2d00c86cd4563a8bc86b6bad28f7d07a6e4c90281f074866fe30a330a2b4697c5321e9708777ad429f4e779a467cc45c47f2ff3d0f0b9952cd1d7279296a4b8

data/lib/ffi-libarchive.rb

@@ -1,7 +1,7 @@
 module Archive
   # :stopdoc:
-  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
-  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  LIBPATH ||= ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH ||= ::File.dirname(LIBPATH) + ::File::SEPARATOR
   # :startdoc:
 
   # Returns the library path for the module. If any arguments are given,
@@ -46,7 +46,8 @@ module Archive
   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 }
   end

data/lib/ffi-libarchive/archive.rb

@@ -8,7 +8,7 @@ module Archive
     end
 
     extend FFI::Library
-    ffi_lib %w{libarchive.so.13 libarchive.13 libarchive.so libarchive archive}
+    ffi_lib %w{libarchive.so.13 libarchive.13 libarchive-13 libarchive.so libarchive archive}
 
     attach_function :archive_version_number, [], :int
     attach_function :archive_version_string, [], :string
@@ -16,15 +16,24 @@ module Archive
     attach_function :archive_errno, [:pointer], :int
 
     attach_function :archive_read_new, [], :pointer
-    attach_function :archive_read_open_filename, [:pointer, :string, :size_t], :int
-    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_open_filename, %i{pointer string size_t}, :int
+    attach_function :archive_read_open_memory, %i{pointer pointer size_t}, :int
+    attach_function :archive_read_open1, [:pointer], :int
+    attach_function :archive_read_support_compression_program, %i{pointer string}, :int
     attach_function :archive_read_support_compression_all, [:pointer], :int
 
-    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
+    callback :archive_read_callback, %i{pointer pointer pointer}, :int
+    callback :archive_skip_callback, %i{pointer pointer int64}, :int
+    callback :archive_seek_callback, %i{pointer pointer int64 int}, :int
+    attach_function :archive_read_set_read_callback, %i{pointer archive_read_callback}, :int
+    attach_function :archive_read_set_callback_data, %i{pointer pointer}, :int
+    attach_function :archive_read_set_skip_callback, %i{pointer archive_skip_callback}, :int
+    attach_function :archive_read_set_seek_callback, %i{pointer archive_seek_callback}, :int
+
+    attach_function_maybe :archive_read_set_format, %i{pointer int}, :int
+    attach_function_maybe :archive_read_append_filter, %i{pointer int}, :int
+    attach_function_maybe :archive_read_append_filter_program, %i{pointer pointer}, :int
+    attach_function_maybe :archive_read_append_filter_program_signature, %i{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
@@ -64,18 +73,18 @@ module Archive
     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_extract, %i{pointer pointer int}, :int
     attach_function :archive_read_header_position, [:pointer], :int
-    attach_function :archive_read_next_header, [:pointer, :pointer], :int
-    attach_function :archive_read_data, [:pointer, :pointer, :size_t], :size_t
-    attach_function :archive_read_data_into_fd, [:pointer, :int], :int
+    attach_function :archive_read_next_header, %i{pointer pointer}, :int
+    attach_function :archive_read_data, %i{pointer pointer size_t}, :size_t
+    attach_function :archive_read_data_into_fd, %i{pointer int}, :int
 
     attach_function :archive_write_new, [], :pointer
-    attach_function :archive_write_open_filename, [:pointer, :string], :int
-    callback :archive_open_callback, [:pointer, :pointer], :int
-    callback :archive_write_callback, [:pointer, :pointer, :pointer, :size_t], :int
-    callback :archive_close_callback, [:pointer, :pointer], :int
-    attach_function :archive_write_open, [:pointer, :pointer, :pointer, :archive_write_callback, :pointer], :int
+    attach_function :archive_write_open_filename, %i{pointer string}, :int
+    callback :archive_open_callback, %i{pointer pointer}, :int
+    callback :archive_write_callback, %i{pointer pointer pointer size_t}, :int
+    callback :archive_close_callback, %i{pointer pointer}, :int
+    attach_function :archive_write_open, %i{pointer pointer pointer archive_write_callback pointer}, :int
     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
@@ -83,7 +92,7 @@ module Archive
     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
-    attach_function :archive_write_set_compression_program, [:pointer, :string], :int
+    attach_function :archive_write_set_compression_program, %i{pointer string}, :int
 
     def self.archive_write_set_compression(archive, compression)
       case compression
@@ -106,94 +115,95 @@ module Archive
       end
     end
 
-    attach_function :archive_write_set_format, [:pointer, :int], :int
-    attach_function :archive_write_data, [:pointer, :pointer, :size_t], :ssize_t
-    attach_function :archive_write_header, [:pointer, :pointer], :int
+    attach_function :archive_write_set_format, %i{pointer int}, :int
+    attach_function :archive_write_data, %i{pointer pointer size_t}, :ssize_t
+    attach_function :archive_write_header, %i{pointer pointer}, :int
     attach_function :archive_write_finish, [:pointer], :void
     attach_function :archive_write_get_bytes_in_last_block, [:pointer], :int
-    attach_function :archive_write_set_bytes_in_last_block, [:pointer, :int], :int
+    attach_function :archive_write_set_bytes_in_last_block, %i{pointer int}, :int
 
     attach_function :archive_entry_new, [], :pointer
+    attach_function :archive_entry_clone, [:pointer], :pointer
     attach_function :archive_entry_free, [:pointer], :void
     attach_function :archive_entry_atime, [:pointer], :time_t
-    attach_function :archive_entry_atime_nsec, [:pointer, :time_t, :long], :void
+    attach_function :archive_entry_atime_nsec, %i{pointer time_t long}, :void
     attach_function_maybe :archive_entry_atime_is_set, [:pointer], :int
-    attach_function :archive_entry_set_atime, [:pointer, :time_t, :long], :int
+    attach_function :archive_entry_set_atime, %i{pointer time_t long}, :int
     attach_function_maybe :archive_entry_unset_atime, [:pointer], :int
     attach_function_maybe :archive_entry_birthtime, [:pointer], :time_t
-    attach_function_maybe :archive_entry_birthtime_nsec, [:pointer, :time_t, :long], :void
+    attach_function_maybe :archive_entry_birthtime_nsec, %i{pointer time_t long}, :void
     attach_function_maybe :archive_entry_birthtime_is_set, [:pointer], :int
-    attach_function_maybe :archive_entry_set_birthtime, [:pointer, :time_t, :long], :int
+    attach_function_maybe :archive_entry_set_birthtime, %i{pointer time_t long}, :int
     attach_function_maybe :archive_entry_unset_birthtime, [:pointer], :int
     attach_function :archive_entry_ctime, [:pointer], :time_t
-    attach_function :archive_entry_ctime_nsec, [:pointer, :time_t, :long], :void
+    attach_function :archive_entry_ctime_nsec, %i{pointer time_t long}, :void
     attach_function_maybe :archive_entry_ctime_is_set, [:pointer], :int
-    attach_function :archive_entry_set_ctime, [:pointer, :time_t, :long], :int
+    attach_function :archive_entry_set_ctime, %i{pointer time_t long}, :int
     attach_function_maybe :archive_entry_unset_ctime, [:pointer], :int
     attach_function :archive_entry_mtime, [:pointer], :time_t
-    attach_function :archive_entry_mtime_nsec, [:pointer, :time_t, :long], :void
+    attach_function :archive_entry_mtime_nsec, %i{pointer time_t long}, :void
     attach_function_maybe :archive_entry_mtime_is_set, [:pointer], :int
-    attach_function :archive_entry_set_mtime, [:pointer, :time_t, :long], :int
+    attach_function :archive_entry_set_mtime, %i{pointer time_t long}, :int
     attach_function_maybe :archive_entry_unset_mtime, [:pointer], :int
     attach_function :archive_entry_dev, [:pointer], :dev_t
-    attach_function :archive_entry_set_dev, [:pointer, :dev_t], :void
+    attach_function :archive_entry_set_dev, %i{pointer dev_t}, :void
     attach_function :archive_entry_devmajor, [:pointer], :dev_t
-    attach_function :archive_entry_set_devmajor, [:pointer, :dev_t], :void
+    attach_function :archive_entry_set_devmajor, %i{pointer dev_t}, :void
     attach_function :archive_entry_devminor, [:pointer], :dev_t
-    attach_function :archive_entry_set_devminor, [:pointer, :dev_t], :void
+    attach_function :archive_entry_set_devminor, %i{pointer dev_t}, :void
     attach_function :archive_entry_filetype, [:pointer], :mode_t
-    attach_function :archive_entry_set_filetype, [:pointer, :mode_t], :void
-    attach_function :archive_entry_fflags, [:pointer, :pointer, :pointer], :void
-    attach_function :archive_entry_set_fflags, [:pointer, :ulong, :ulong], :void
+    attach_function :archive_entry_set_filetype, %i{pointer mode_t}, :void
+    attach_function :archive_entry_fflags, %i{pointer pointer pointer}, :void
+    attach_function :archive_entry_set_fflags, %i{pointer ulong ulong}, :void
     attach_function :archive_entry_fflags_text, [:pointer], :string
-    attach_function :archive_entry_gid, [:pointer], :gid_t
-    attach_function :archive_entry_set_gid, [:pointer, :gid_t], :void
+    attach_function :archive_entry_gid, [:pointer], :uint
+    attach_function :archive_entry_set_gid, %i{pointer uint}, :void
     attach_function :archive_entry_gname, [:pointer], :string
-    attach_function :archive_entry_set_gname, [:pointer, :string], :void
+    attach_function :archive_entry_set_gname, %i{pointer string}, :void
     attach_function :archive_entry_hardlink, [:pointer], :string
-    attach_function :archive_entry_set_hardlink, [:pointer, :string], :void
-    attach_function :archive_entry_set_link, [:pointer, :string], :void
+    attach_function :archive_entry_set_hardlink, %i{pointer string}, :void
+    attach_function :archive_entry_set_link, %i{pointer string}, :void
     attach_function :archive_entry_ino, [:pointer], :ino_t
-    attach_function :archive_entry_set_ino, [:pointer, :ino_t], :void
+    attach_function :archive_entry_set_ino, %i{pointer ino_t}, :void
     attach_function :archive_entry_mode, [:pointer], :mode_t
-    attach_function :archive_entry_set_mode, [:pointer, :mode_t], :void
-    attach_function :archive_entry_set_perm, [:pointer, :mode_t], :void
+    attach_function :archive_entry_set_mode, %i{pointer mode_t}, :void
+    attach_function :archive_entry_set_perm, %i{pointer mode_t}, :void
     attach_function :archive_entry_nlink, [:pointer], :uint
-    attach_function :archive_entry_set_nlink, [:pointer, :uint], :void
+    attach_function :archive_entry_set_nlink, %i{pointer uint}, :void
     attach_function :archive_entry_pathname, [:pointer], :string
-    attach_function :archive_entry_set_pathname, [:pointer, :string], :void
+    attach_function :archive_entry_set_pathname, %i{pointer string}, :void
     attach_function :archive_entry_rdev, [:pointer], :dev_t
-    attach_function :archive_entry_set_rdev, [:pointer, :dev_t], :void
+    attach_function :archive_entry_set_rdev, %i{pointer dev_t}, :void
     attach_function :archive_entry_rdevmajor, [:pointer], :dev_t
-    attach_function :archive_entry_set_rdevmajor, [:pointer, :dev_t], :void
+    attach_function :archive_entry_set_rdevmajor, %i{pointer dev_t}, :void
     attach_function :archive_entry_rdevminor, [:pointer], :dev_t
-    attach_function :archive_entry_set_rdevminor, [:pointer, :dev_t], :void
+    attach_function :archive_entry_set_rdevminor, %i{pointer dev_t}, :void
     attach_function :archive_entry_size, [:pointer], :int64_t
-    attach_function :archive_entry_set_size, [:pointer, :int64_t], :void
+    attach_function :archive_entry_set_size, %i{pointer int64_t}, :void
     attach_function_maybe :archive_entry_unset_size, [:pointer], :void
     attach_function_maybe :archive_entry_size_is_set, [:pointer], :int
     attach_function :archive_entry_sourcepath, [:pointer], :string
     attach_function :archive_entry_strmode, [:pointer], :string
     attach_function :archive_entry_symlink, [:pointer], :string
-    attach_function :archive_entry_set_symlink, [:pointer, :string], :void
-    attach_function :archive_entry_uid, [:pointer], :uid_t
-    attach_function :archive_entry_set_uid, [:pointer, :uid_t], :void
+    attach_function :archive_entry_set_symlink, %i{pointer string}, :void
+    attach_function :archive_entry_uid, [:pointer], :uint
+    attach_function :archive_entry_set_uid, %i{pointer uint}, :void
     attach_function :archive_entry_uname, [:pointer], :string
-    attach_function :archive_entry_set_uname, [:pointer, :string], :void
-    attach_function :archive_entry_copy_stat, [:pointer, :pointer], :void
-    attach_function :archive_entry_copy_fflags_text, [:pointer, :string], :string
-    attach_function :archive_entry_copy_gname, [:pointer, :string], :string
-    attach_function :archive_entry_copy_uname, [:pointer, :string], :string
-    attach_function :archive_entry_copy_hardlink, [:pointer, :string], :string
-    attach_function :archive_entry_copy_link, [:pointer, :string], :string
-    attach_function :archive_entry_copy_symlink, [:pointer, :string], :string
-    attach_function :archive_entry_copy_sourcepath, [:pointer, :string], :string
-    attach_function :archive_entry_copy_pathname, [:pointer, :string], :string
+    attach_function :archive_entry_set_uname, %i{pointer string}, :void
+    attach_function :archive_entry_copy_stat, %i{pointer pointer}, :void
+    attach_function :archive_entry_copy_fflags_text, %i{pointer string}, :string
+    attach_function :archive_entry_copy_gname, %i{pointer string}, :string
+    attach_function :archive_entry_copy_uname, %i{pointer string}, :string
+    attach_function :archive_entry_copy_hardlink, %i{pointer string}, :string
+    attach_function :archive_entry_copy_link, %i{pointer string}, :string
+    attach_function :archive_entry_copy_symlink, %i{pointer string}, :string
+    attach_function :archive_entry_copy_sourcepath, %i{pointer string}, :string
+    attach_function :archive_entry_copy_pathname, %i{pointer string}, :string
     attach_function :archive_entry_xattr_clear, [:pointer], :void
-    attach_function :archive_entry_xattr_add_entry, [:pointer, :string, :pointer, :size_t], :void
+    attach_function :archive_entry_xattr_add_entry, %i{pointer string pointer size_t}, :void
     attach_function :archive_entry_xattr_count, [:pointer], :int
     attach_function :archive_entry_xattr_reset, [:pointer], :int
-    attach_function :archive_entry_xattr_next, [:pointer, :pointer, :pointer, :pointer], :int
+    attach_function :archive_entry_xattr_next, %i{pointer pointer pointer pointer}, :int
 
     EOF    = 1
     OK     = 0
@@ -278,6 +288,10 @@ module Archive
     Reader.open_memory string, command, &block
   end
 
+  def self.read_open_stream(reader, &block)
+    Reader.open_stream reader, &block
+  end
+
   def self.write_open_filename(file_name, compression, format, &block)
     Writer.open_filename file_name, compression, format, &block
   end
@@ -336,6 +350,7 @@ module Archive
 
     def archive
       raise Error, "No archive open" unless @archive
+
       @archive
     end
     protected :archive

data/lib/ffi-libarchive/entry.rb

@@ -17,14 +17,14 @@ module Archive
     CHARACTER_SPECIAL = 0020000 #  character device
     FIFO              = 0010000 #  FIFO
 
-    def self.from_pointer(entry)
-      new entry
+    def self.from_pointer(entry, clone: false)
+      new entry, clone: clone
     end
 
-    def initialize(entry = nil)
+    def initialize(entry = nil, clone: false)
       @entry_free = [true]
       if entry
-        @entry = entry
+        @entry = clone ? C.archive_entry_clone(entry) : entry
         yield self if block_given?
       else
         @entry = C.archive_entry_new
@@ -34,7 +34,7 @@ module Archive
           result = yield self
           C.archive_entry_free(@entry)
           @entry = nil
-          return result
+          result
         else
           @entry_free[0] = false
           ObjectSpace.define_finalizer(self, Entry.finalizer(@entry, @entry_free))
@@ -60,6 +60,7 @@ module Archive
 
     def entry
       raise "No entry object" unless @entry
+
       @entry
     end
 
@@ -182,6 +183,7 @@ module Archive
 
       stat = Archive::Stat.ffi_libarchive_create_lstat(filename)
       raise Error, "Copy stat failed: #{Archive::Stat.ffi_error}" if stat.null?
+
       C.archive_entry_copy_stat(entry, stat)
     ensure
       Archive::Stat.ffi_libarchive_free_stat(stat)
@@ -207,6 +209,7 @@ module Archive
 
       stat = Archive::Stat.ffi_libarchive_create_stat(filename)
       raise Error, "Copy stat failed: #{Archive::Stat.ffi_error}" if stat.null?
+
       C.archive_entry_copy_stat(entry, stat)
     ensure
       Archive::Stat.ffi_libarchive_free_stat(stat)
@@ -459,10 +462,10 @@ module Archive
       value = FFI::MemoryPointer.new :pointer
       size = FFI::MemoryPointer.new :size_t
       if C.archive_entry_xattr_next(entry, name, value, size) != C::OK
-        return nil
+        nil
       else
         # TODO: someday size.read_size_t could work
-        return [name.null? ? nil : name.read_string,
+        [name.null? ? nil : name.read_string,
                 value.null? ? nil : value.get_string(0, size.read_ulong)]
       end
     end

data/lib/ffi-libarchive/reader.rb

@@ -28,6 +28,19 @@ module Archive
       end
     end
 
+    def self.open_stream(reader)
+      if block_given?
+        reader = new reader: reader
+        begin
+          yield reader
+        ensure
+          reader.close
+        end
+      else
+        new reader: reader
+      end
+    end
+
     def initialize(params = {})
       super C.method(:archive_read_new), C.method(:archive_read_finish)
 
@@ -40,13 +53,44 @@ module Archive
 
       raise Error, @archive if C.archive_read_support_format_all(archive) != C::OK
 
-      if params[:file_name]
+      case
+      when params[:file_name]
         raise Error, @archive if C.archive_read_open_filename(archive, params[:file_name], 1024) != C::OK
-      elsif params[:memory]
+      when params[:memory]
         str = params[:memory]
         @data = FFI::MemoryPointer.new(str.bytesize + 1)
         @data.write_string str, str.bytesize
         raise Error, @archive if C.archive_read_open_memory(archive, @data, str.bytesize) != C::OK
+      when params[:reader]
+        @reader = params[:reader]
+        @buffer = nil
+
+        @read_callback = FFI::Function.new(:int, %i{pointer pointer pointer}) do |_, _, archive_data|
+          data = @reader.call || ""
+          @buffer = FFI::MemoryPointer.new(:char, data.size) if @buffer.nil? || @buffer.size < data.size
+          @buffer.write_bytes(data)
+          archive_data.write_pointer(@buffer)
+          data.size
+        end
+        C.archive_read_set_read_callback(archive, @read_callback)
+
+        if @reader.respond_to?(:skip)
+          @skip_callback = FFI::Function.new(:int, %i{pointer pointer int64}) do |_, _, offset|
+            @reader.skip(offset)
+          end
+          C.archive_read_set_skip_callback(archive, @skip_callback)
+        end
+
+        if @reader.respond_to?(:seek)
+          @seek_callback = FFI::Function.new(:int, %i{pointer pointer int64 int}) do |_, _, offset, whence|
+            @reader.seek(offset, whence)
+          end
+          C.archive_read_set_seek_callback(archive, @seek_callback)
+        end
+
+        # Required or open1 will segfault, even though the callback data is not used.
+        C.archive_read_set_callback_data(archive, nil)
+        raise Error, @archive if C.archive_read_open1(archive) != C::OK
       end
     rescue
       close
@@ -65,11 +109,11 @@ module Archive
       raise Error, @archive if C.archive_read_header_position archive
     end
 
-    def next_header
+    def next_header(clone_entry: false)
       entry_ptr = FFI::MemoryPointer.new(:pointer)
       case C.archive_read_next_header(archive, entry_ptr)
       when C::OK
-        Entry.from_pointer entry_ptr.read_pointer
+        Entry.from_pointer entry_ptr.read_pointer, clone: clone_entry
       when C::EOF
         @eof = true
         nil

data/lib/ffi-libarchive/version.rb

@@ -1,3 +1,3 @@
 module Archive
-  VERSION = "0.4.2".freeze
+  VERSION = "1.0.3".freeze
 end

data/lib/ffi-libarchive/writer.rb

@@ -58,9 +58,9 @@ module Archive
         end
         @data = write_callback params[:memory]
         raise Error, @archive if C.archive_write_open(archive, nil,
-                                                       nil,
-                                                       @data,
-                                                       nil) != C::OK
+          nil,
+          @data,
+          nil) != C::OK
       end
     rescue
       close
@@ -117,10 +117,12 @@ module Archive
           if (n = C.archive_write_data(ar, str, str.bytesize)) < 1
             return len
           end
+
           len += n
         end
       else
         raise ArgumentError, "wrong number of argument (#{args.size}) for 1)" if args.size != 1
+
         str = args[0]
         C.archive_write_data(archive, str, str.bytesize)
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ffi-libarchive
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 1.0.3
 platform: ruby
 authors:
 - John Bellone
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-21 00:00:00.000000000 Z
+date: 2020-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -40,34 +40,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  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: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 description: A Ruby FFI binding to libarchive.
 email:
 - jbellone@bloomberg.net
@@ -77,12 +49,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- Gemfile
 - LICENSE
-- README.md
-- Rakefile
-- VERSION
-- ffi-libarchive.gemspec
 - lib/ffi-libarchive.rb
 - lib/ffi-libarchive/archive.rb
 - lib/ffi-libarchive/entry.rb
@@ -90,10 +57,6 @@ files:
 - lib/ffi-libarchive/stat.rb
 - lib/ffi-libarchive/version.rb
 - lib/ffi-libarchive/writer.rb
-- test/data/test.tar.gz
-- test/sets/ts_read.rb
-- test/sets/ts_write.rb
-- test/test_ffi-libarchive.rb
 homepage: https://github.com/chef/ffi-libarchive
 licenses:
 - Apache-2.0
@@ -113,8 +76,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: A Ruby FFI binding to libarchive.

data/Gemfile

@@ -1,10 +0,0 @@
-source "https://rubygems.org"
-gemspec
-
-group :lint do
-  gem "chefstyle"
-end
-
-group :doc do
-  gem "yard"
-end

data/README.md

@@ -1,77 +0,0 @@
-ffi-libarchive
-==============
-A Ruby FFI binding to [libarchive][0].
-
-This library provides Ruby FFI bindings to the well-known
-[libarchive library][0].
-
-## 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

data/Rakefile

@@ -1,28 +0,0 @@
-#!/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
-
-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

@@ -1 +0,0 @@
-0.4.2

data/ffi-libarchive.gemspec

@@ -1,25 +0,0 @@
-# coding: utf-8
-lib = File.expand_path("../lib", __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "ffi-libarchive/version"
-
-Gem::Specification.new do |s|
-  s.name = "ffi-libarchive"
-  s.version = Archive::VERSION
-  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.summary = s.description
-  s.homepage = "https://github.com/chef/ffi-libarchive"
-  s.license = "Apache-2.0"
-
-  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 = ">= 2.4.0"
-
-  s.add_dependency "ffi", "~> 1.0"
-
-  s.add_development_dependency "bundler"
-  s.add_development_dependency "rake"
-  s.add_development_dependency "test-unit"
-end

data/test/sets/ts_read.rb

@@ -1,144 +0,0 @@
-require "ffi-libarchive"
-require "tmpdir"
-require "test/unit"
-
-class TS_ReadArchive < Test::Unit::TestCase
-
-  CONTENT_SPEC =
-    [
-       ["test/", "directory", 0755, nil ],
-       ["test/b/", "directory", 0755, nil ],
-       ["test/b/c/", "directory", 0755, nil ],
-       ["test/b/c/c.dat", "file", 0600, "\266\262\v_\266\243\305\3601\204\277\351\354\265\003\036\036\365f\377\210\205\032\222\346\370b\360u\032Y\301".b ],
-       ["test/b/c/d/", "directory", 0711, nil ],
-       ["test/b/c/d/d.dat", "symbolic_link", 0777, "../c.dat" ],
-       ["test/b/b.dat", "file", 0640, "s&\245\354(M\331=\270\000!s\355\240\252\355'N\304\343\bY\317\t\274\210\3128\321\347\234!".b ],
-       ["test/a.dat", "file", 0777, "\021\216\231Y\354\236\271\372\336\213\224R\211{D{\277\262\304\211xu\330\\\275@~\035\vSRM".b ]
-      ]
-
-  def setup
-    File.open("data/test.tar.gz", "rb") do |f|
-      @archive_content = f.read
-    end
-  end
-
-  def test_read_tar_gz_from_file
-    Archive.read_open_filename("data/test.tar.gz") do |ar|
-      verify_content(ar)
-    end
-  end
-
-  def test_read_tar_gz_from_file_with_external_gunzip
-    Archive.read_open_filename("data/test.tar.gz", "gunzip") do |ar|
-      verify_content(ar)
-    end
-  end
-
-  def test_read_tar_gz_from_memory
-    Archive.read_open_memory(@archive_content) do |ar|
-      verify_content(ar)
-    end
-  end
-
-  def test_read_tar_gz_from_memory_with_external_gunzip
-    Archive.read_open_memory(@archive_content, "gunzip") do |ar|
-      verify_content(ar)
-    end
-  end
-
-  def test_read_entry_bigger_than_internal_buffer
-    alphabet = "abcdefghijklmnopqrstuvwxyz"
-    entry_size = 1024 * 4 - 3
-
-    srand
-    content = ""
-    1.upto(entry_size) do |i|
-      index = rand(alphabet.size)
-      content += alphabet[index, 1]
-    end
-
-    Dir.mktmpdir do |dir|
-      Archive.write_open_filename(dir + "/test.tar.gz",
-                                  Archive::COMPRESSION_BZIP2, Archive::FORMAT_TAR) do |ar|
-        ar.new_entry do |entry|
-          entry.pathname = "chubby.dat"
-          entry.mode = 0666
-          entry.filetype = Archive::Entry::FILE
-          entry.atime = Time.now.to_i
-          entry.mtime = Time.now.to_i
-          entry.size = entry_size
-          ar.write_header(entry)
-          ar.write_data(content)
-        end
-      end
-
-      Archive.read_open_filename(dir + "/test.tar.gz") do |ar|
-        ar.next_header
-        data = ar.read_data
-
-        assert_equal entry_size, data.size
-        assert_equal content.size, data.size
-        assert_equal content, data
-      end
-
-      Archive.read_open_filename(dir + "/test.tar.gz") do |ar|
-        ar.next_header
-        data = ""
-        ar.read_data(128) { |chunk| data += chunk }
-
-        assert_equal content, data
-      end
-    end
-  end
-
-  def test_extract_no_additional_flags
-    Dir.mktmpdir do |dir|
-      Archive.read_open_filename("data/test.tar.gz") do |ar|
-        Dir.chdir(dir) do
-          ar.each_entry do |e|
-            ar.extract(e)
-            assert_not_equal File.mtime(e.pathname), e.mtime
-          end
-        end
-      end
-    end
-  end
-
-  def test_extract_extract_time
-    Dir.mktmpdir do |dir|
-      Archive.read_open_filename("data/test.tar.gz") do |ar|
-        Dir.chdir(dir) do
-          ar.each_entry do |e|
-            ar.extract(e, Archive::EXTRACT_TIME.to_i)
-            next if e.directory? || e.symbolic_link?
-            assert_equal File.mtime(e.pathname), e.mtime
-          end
-        end
-      end
-    end
-  end
-
-  private
-
-  def verify_content(ar)
-    content_spec_idx = 0
-
-    while (entry = ar.next_header)
-      expect_pathname, expect_type, expect_mode, expect_content = CONTENT_SPEC[content_spec_idx]
-
-      assert_equal expect_pathname, entry.pathname
-      assert_equal entry.send("#{expect_type}?"), true
-      assert_equal expect_mode, (entry.mode & 07777)
-
-      if entry.symbolic_link?
-        assert_equal expect_content, entry.symlink
-      elsif entry.file?
-        content = ar.read_data(1024)
-        assert_equal expect_content, content
-      end
-
-      content_spec_idx += 1
-    end
-  end
-
-end

data/test/sets/ts_write.rb

@@ -1,123 +0,0 @@
-require "ffi-libarchive"
-require "tmpdir"
-require "test/unit"
-
-class TS_WriteArchive < Test::Unit::TestCase
-
-  CONTENT_SPEC =
-    [
-       ["test/", "directory", 0755, nil ],
-       ["test/b/", "directory", 0755, nil ],
-       ["test/b/c/", "directory", 0755, nil ],
-       ["test/b/c/c.dat", "file", 0600, "\266\262\v_\266\243\305\3601\204\277\351\354\265\003\036\036\365f\377\210\205\032\222\346\370b\360u\032Y\301".b ],
-       ["test/b/c/d/", "directory", 0711, nil ],
-       ["test/b/c/d/d.dat", "symbolic_link", 0777, "../c.dat" ],
-       ["test/b/b.dat", "file", 0640, "s&\245\354(M\331=\270\000!s\355\240\252\355'N\304\343\bY\317\t\274\210\3128\321\347\234!".b ],
-       ["test/a.dat", "file", 0777, "\021\216\231Y\354\236\271\372\336\213\224R\211{D{\277\262\304\211xu\330\\\275@~\035\vSRM".b ]
-      ]
-
-  def test_end_to_end_write_read_tar_gz
-    Dir.mktmpdir do |dir|
-      Archive.write_open_filename(dir + "/test.tar.gz", :gzip, :tar) do |ar|
-        write_content(ar)
-      end
-
-      verify_content(dir + "/test.tar.gz")
-    end
-  end
-
-  def test_end_to_end_write_read_memory
-    memory = ""
-    Archive.write_open_memory(memory, Archive::COMPRESSION_GZIP, Archive::FORMAT_TAR) do |ar|
-      write_content ar
-    end
-    verify_content_memory(memory)
-  end
-
-  def test_end_to_end_write_read_tar_gz_with_external_gzip
-    Dir.mktmpdir do |dir|
-      Archive.write_open_filename(dir + "/test.tar.gz", "gzip", :tar) do |ar|
-        write_content(ar)
-      end
-
-      verify_content(dir + "/test.tar.gz")
-    end
-  end
-
-  private
-
-  def write_content(ar)
-    content_spec_idx = 0
-
-    while content_spec_idx < CONTENT_SPEC.size()
-      entry_path, entry_type, entry_mode, entry_content = \
-        CONTENT_SPEC[content_spec_idx]
-
-      ar.new_entry do |entry|
-        entry.pathname = entry_path
-        entry.mode = entry_mode
-        entry.filetype = eval "Archive::Entry::#{entry_type.upcase}" # rubocop:disable Security/Eval
-        entry.size = entry_content.size if entry_content
-        entry.symlink = entry_content if entry_type == "symbolic_link"
-        entry.atime = Time.now.to_i
-        entry.mtime = Time.now.to_i
-        ar.write_header(entry)
-
-        if entry_type == "file"
-          ar.write_data(entry_content)
-        end
-      end
-
-      content_spec_idx += 1
-    end
-  end
-
-  def verify_content_memory(memory)
-    Archive.read_open_memory(memory) do |ar|
-      content_spec_idx = 0
-
-      while (entry = ar.next_header)
-        expect_pathname, expect_type, expect_mode, expect_content = \
-          CONTENT_SPEC[content_spec_idx]
-
-        assert_equal expect_pathname, entry.pathname
-        assert_equal entry.send("#{expect_type}?"), true
-        assert_equal expect_mode, (entry.mode & 07777)
-
-        if entry.symbolic_link?
-          assert_equal expect_content, entry.symlink
-        elsif entry.file?
-          content = ar.read_data(1024)
-          assert_equal expect_content, content
-        end
-
-        content_spec_idx += 1
-      end
-    end
-  end
-
-  def verify_content(filename)
-    Archive.read_open_filename(filename) do |ar|
-      content_spec_idx = 0
-
-      while (entry = ar.next_header)
-        expect_pathname, expect_type, expect_mode, expect_content = \
-          CONTENT_SPEC[content_spec_idx]
-
-        assert_equal expect_pathname, entry.pathname
-        assert_equal entry.send("#{expect_type}?"), true
-        assert_equal expect_mode, (entry.mode & 07777)
-
-        if entry.symbolic_link?
-          assert_equal expect_content, entry.symlink
-        elsif entry.file?
-          content = ar.read_data(1024)
-          assert_equal expect_content, content
-        end
-
-        content_spec_idx += 1
-      end
-    end
-  end
-
-end

data/test/test_ffi-libarchive.rb

@@ -1,8 +0,0 @@
-
-Dir.chdir File.dirname(__FILE__)
-
-$LOAD_PATH.unshift "../lib/", "."
-
-require "test/unit"
-require "sets/ts_read"
-require "sets/ts_write"