minitar 0.12.1 → 1.0.0

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: minitar
 version: !ruby/object:Gem::Version
-  version: 0.12.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Austin Ziegler
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-08-22 00:00:00.000000000 Z
+date: 2024-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -184,6 +184,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: standard-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: standard-thread_safety
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -230,17 +258,16 @@ files:
 - Rakefile
 - docs/bsdl.txt
 - docs/ruby.txt
-- lib/archive-tar-minitar.rb
-- lib/archive/tar/minitar.rb
-- lib/archive/tar/minitar/input.rb
-- lib/archive/tar/minitar/output.rb
-- lib/archive/tar/minitar/posix_header.rb
-- lib/archive/tar/minitar/reader.rb
-- lib/archive/tar/minitar/writer.rb
 - lib/minitar.rb
-- support/hoe/deprecated_gem.rb
+- lib/minitar/input.rb
+- lib/minitar/output.rb
+- lib/minitar/posix_header.rb
+- lib/minitar/reader.rb
+- lib/minitar/writer.rb
 - test/minitest_helper.rb
 - test/support/tar_test_helpers.rb
+- test/test_issue_46.rb
+- test/test_minitar.rb
 - test/test_tar_header.rb
 - test/test_tar_input.rb
 - test/test_tar_output.rb
@@ -255,9 +282,7 @@ metadata:
   source_code_uri: https://github.com/halostatue/minitar/
   bug_tracker_uri: https://github.com/halostatue/minitar/issues
   rubygems_mfa_required: 'true'
-post_install_message: |
-  The `minitar` executable is no longer bundled with `minitar`. If you are
-  expecting this executable, make sure you also install `minitar-cli`.
+post_install_message:
 rdoc_options:
 - "--main"
 - README.rdoc
@@ -267,14 +292,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '1.8'
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.17
+rubygems_version: 3.4.19
 signing_key:
 specification_version: 4
 summary: The minitar library is a pure-Ruby library that provides the ability to deal

data/lib/archive/tar/minitar/posix_header.rb

@@ -1,278 +0,0 @@
-# coding: utf-8
-
-##
-module Archive; end
-
-##
-module Archive::Tar; end
-
-##
-module Archive::Tar::Minitar; end
-
-# Implements the POSIX tar header as a Ruby class. The structure of
-# the POSIX tar header is:
-#
-#   struct tarfile_entry_posix
-#   {                      //                               pack/unpack
-#      char name[100];     // ASCII (+ Z unless filled)     a100/Z100
-#      char mode[8];       // 0 padded, octal, null         a8  /A8
-#      char uid[8];        // 0 padded, octal, null         a8  /A8
-#      char gid[8];        // 0 padded, octal, null         a8  /A8
-#      char size[12];      // 0 padded, octal, null         a12 /A12
-#      char mtime[12];     // 0 padded, octal, null         a12 /A12
-#      char checksum[8];   // 0 padded, octal, null, space  a8  /A8
-#      char typeflag[1];   // see below                     a   /a
-#      char linkname[100]; // ASCII + (Z unless filled)     a100/Z100
-#      char magic[6];      // "ustar\0"                     a6  /A6
-#      char version[2];    // "00"                          a2  /A2
-#      char uname[32];     // ASCIIZ                        a32 /Z32
-#      char gname[32];     // ASCIIZ                        a32 /Z32
-#      char devmajor[8];   // 0 padded, octal, null         a8  /A8
-#      char devminor[8];   // 0 padded, octal, null         a8  /A8
-#      char prefix[155];   // ASCII (+ Z unless filled)     a155/Z155
-#   };
-#
-# The #typeflag is one of several known values.
-#
-# POSIX indicates that "A POSIX-compliant implementation must treat any
-# unrecognized typeflag value as a regular file."
-class Archive::Tar::Minitar::PosixHeader
-  BLOCK_SIZE = 512
-  MAGIC_BYTES = "ustar".freeze
-
-  GNU_EXT_LONG_LINK = "././@LongLink"
-
-  # Fields that must be set in a POSIX tar(1) header.
-  REQUIRED_FIELDS = [:name, :size, :prefix, :mode].freeze
-  # Fields that may be set in a POSIX tar(1) header.
-  OPTIONAL_FIELDS = [
-    :uid, :gid, :mtime, :checksum, :typeflag, :linkname, :magic, :version,
-    :uname, :gname, :devmajor, :devminor
-  ].freeze
-
-  # All fields available in a POSIX tar(1) header.
-  FIELDS = (REQUIRED_FIELDS + OPTIONAL_FIELDS).freeze
-
-  FIELDS.each do |f|
-    attr_reader f.to_sym unless f.to_sym == :name
-  end
-
-  # The name of the file. By default, limited to 100 bytes. Required. May be
-  # longer (up to BLOCK_SIZE bytes) if using the GNU long name tar extension.
-  attr_accessor :name
-
-  # The pack format passed to Array#pack for encoding a header.
-  HEADER_PACK_FORMAT = "a100a8a8a8a12a12a7aaa100a6a2a32a32a8a8a155".freeze
-  # The unpack format passed to String#unpack for decoding a header.
-  HEADER_UNPACK_FORMAT = "Z100A8A8A8A12A12A8aZ100A6A2Z32Z32A8A8Z155".freeze
-
-  class << self
-    # Creates a new PosixHeader from a data stream.
-    def from_stream(stream)
-      from_data(stream.read(BLOCK_SIZE))
-    end
-
-    # Creates a new PosixHeader from a data stream. Deprecated; use
-    # PosixHeader.from_stream instead.
-    def new_from_stream(stream)
-      warn "#{__method__} has been deprecated; use from_stream instead."
-      from_stream(stream)
-    end
-
-    # Creates a new PosixHeader from a BLOCK_SIZE-byte data buffer.
-    def from_data(data)
-      fields = data.unpack(HEADER_UNPACK_FORMAT)
-      name = fields.shift
-      mode = fields.shift.oct
-      uid = fields.shift.oct
-      gid = fields.shift.oct
-      size = strict_oct(fields.shift)
-      mtime = fields.shift.oct
-      checksum = fields.shift.oct
-      typeflag = fields.shift
-      linkname = fields.shift
-      magic = fields.shift
-      version = fields.shift.oct
-      uname = fields.shift
-      gname = fields.shift
-      devmajor = fields.shift.oct
-      devminor = fields.shift.oct
-      prefix = fields.shift
-
-      empty = !data.each_byte.any?(&:nonzero?)
-
-      new(
-        :name => name,
-        :mode => mode,
-        :uid => uid,
-        :gid => gid,
-        :size => size,
-        :mtime => mtime,
-        :checksum => checksum,
-        :typeflag => typeflag,
-        :magic => magic,
-        :version => version,
-        :uname => uname,
-        :gname => gname,
-        :devmajor => devmajor,
-        :devminor => devminor,
-        :prefix => prefix,
-        :empty => empty,
-        :linkname => linkname
-      )
-    end
-
-    private
-
-    def strict_oct(string)
-      return string.oct if string =~ /\A[0-7 ]*\z/
-      raise ArgumentError, "#{string.inspect} is not a valid octal string"
-    end
-  end
-
-  # Creates a new PosixHeader. A PosixHeader cannot be created unless
-  # +name+, +size+, +prefix+, and +mode+ are provided.
-  def initialize(v)
-    REQUIRED_FIELDS.each do |f|
-      raise ArgumentError, "Field #{f} is required." unless v.key?(f)
-    end
-
-    v[:mtime] = v[:mtime].to_i
-    v[:checksum] ||= ""
-    v[:typeflag] ||= "0"
-    v[:magic] ||= MAGIC_BYTES
-    v[:version] ||= "00"
-
-    FIELDS.each do |f|
-      instance_variable_set(:"@#{f}", v[f])
-    end
-
-    @empty = v[:empty]
-  end
-
-  # Indicates if the header was an empty header.
-  def empty?
-    @empty
-  end
-
-  # Indicates if the header has a valid magic value.
-  def valid?
-    empty? || @magic == MAGIC_BYTES
-  end
-
-  # Returns +true+ if the header is a long name special header which indicates
-  # that the next block of data is the filename.
-  def long_name?
-    typeflag == "L" && name == GNU_EXT_LONG_LINK
-  end
-
-  # A string representation of the header.
-  def to_s
-    update_checksum
-    header(@checksum)
-  end
-  alias_method :to_str, :to_s
-
-  # Update the checksum field.
-  def update_checksum
-    hh = header(" " * 8)
-    @checksum = oct(calculate_checksum(hh), 6)
-  end
-
-  private
-
-  include Archive::Tar::Minitar::ByteSize
-
-  def oct(num, len)
-    if num.nil?
-      "\0" * (len + 1)
-    else
-      "%0#{len}o" % num
-    end
-  end
-
-  def calculate_checksum(hdr)
-    hdr.unpack("C*").inject { |a, e| a + e }
-  end
-
-  def header(chksum)
-    arr = [name, oct(mode, 7), oct(uid, 7), oct(gid, 7), oct(size, 11),
-      oct(mtime, 11), chksum, " ", typeflag, linkname, magic, version,
-      uname, gname, oct(devmajor, 7), oct(devminor, 7), prefix]
-    str = arr.pack(HEADER_PACK_FORMAT)
-    str + "\0" * ((BLOCK_SIZE - bytesize(str)) % BLOCK_SIZE)
-  end
-
-  ##
-  # :attr_reader: size
-  # The size of the file. Required.
-
-  ##
-  # :attr_reader: prefix
-  # The prefix of the file; the path before #name. Limited to 155 bytes.
-  # Required.
-
-  ##
-  # :attr_reader: mode
-  # The Unix file mode of the file. Stored as an octal integer. Required.
-
-  ##
-  # :attr_reader: uid
-  # The Unix owner user ID of the file. Stored as an octal integer.
-
-  ##
-  # :attr_reader: uname
-  # The user name of the Unix owner of the file.
-
-  ##
-  # :attr_reader: gid
-  # The Unix owner group ID of the file. Stored as an octal integer.
-
-  ##
-  # :attr_reader: gname
-  # The group name of the Unix owner of the file.
-
-  ##
-  # :attr_reader: mtime
-  # The modification time of the file in epoch seconds. Stored as an
-  # octal integer.
-
-  ##
-  # :attr_reader: checksum
-  # The checksum of the file. Stored as an octal integer. Calculated
-  # before encoding the header as a string.
-
-  ##
-  # :attr_reader: typeflag
-  # The type of record in the file.
-  #
-  # +0+::  Regular file. NULL should be treated as a synonym, for compatibility
-  #        purposes.
-  # +1+::  Hard link.
-  # +2+::  Symbolic link.
-  # +3+::  Character device node.
-  # +4+::  Block device node.
-  # +5+::  Directory.
-  # +6+::  FIFO node.
-  # +7+::  Reserved.
-
-  ##
-  # :attr_reader: linkname
-  # The name of the link stored. Not currently used.
-
-  ##
-  # :attr_reader: magic
-  # Always "ustar\0".
-
-  ##
-  # :attr_reader: version
-  # Always "00"
-
-  ##
-  # :attr_reader: devmajor
-  # The major device ID. Not currently used.
-
-  ##
-  # :attr_reader: devminor
-  # The minor device ID. Not currently used.
-end

data/lib/archive/tar/minitar.rb

@@ -1,311 +0,0 @@
-# coding: utf-8
-
-##
-module Archive; end
-
-##
-module Archive::Tar; end
-
-require "fileutils"
-require "rbconfig"
-
-class << Archive::Tar # :nodoc:
-  def const_missing(const) # :nodoc:
-    case const
-    when :PosixHeader
-      warn "Archive::Tar::PosixHeader has been renamed to " \
-        "Archive::Tar::Minitar::PosixHeader"
-      const_set :PosixHeader, Archive::Tar::Minitar::PosixHeader
-    else
-      super
-    end
-  end
-
-  private
-
-  def included(mod)
-    return if modules.include?(mod)
-    warn "Including Minitar via the #{self} namespace is deprecated."
-    modules.add mod
-  end
-
-  def modules
-    require "set"
-    @modules ||= Set.new
-  end
-end
-
-# == Synopsis
-#
-# Using minitar is easy. The simplest case is:
-#
-#     require 'zlib'
-#     require 'minitar'
-#
-#     # Packs everything that matches Find.find('tests').
-#     # test.tar will automatically be closed by Minitar.pack.
-#     Minitar.pack('tests', File.open('test.tar', 'wb'))
-#
-#     # Unpacks 'test.tar' to 'x', creating 'x' if necessary.
-#     Minitar.unpack('test.tar', 'x')
-#
-# A gzipped tar can be written with:
-#
-#     # test.tgz will be closed automatically.
-#     Minitar.pack('tests', Zlib::GzipWriter.new(File.open('test.tgz', 'wb'))
-#
-#     # test.tgz will be closed automatically.
-#     Minitar.unpack(Zlib::GzipReader.new(File.open('test.tgz', 'rb')), 'x')
-#
-# As the case above shows, one need not write to a file. However, it will
-# sometimes require that one dive a little deeper into the API, as in the case
-# of StringIO objects. Note that I'm not providing a block with
-# Minitar::Output, as Minitar::Output#close automatically closes both the
-# Output object and the wrapped data stream object.
-#
-#     begin
-#       sgz = Zlib::GzipWriter.new(StringIO.new(""))
-#       tar = Output.new(sgz)
-#       Find.find('tests') do |entry|
-#         Minitar.pack_file(entry, tar)
-#       end
-#     ensure
-#         # Closes both tar and sgz.
-#       tar.close
-#     end
-module Archive::Tar::Minitar
-  VERSION = "0.12.1".freeze # :nodoc:
-
-  # The base class for any minitar error.
-  Error = Class.new(::StandardError)
-  # Raised when a wrapped data stream class is not seekable.
-  NonSeekableStream = Class.new(Error)
-  # The exception raised when operations are performed on a stream that has
-  # previously been closed.
-  ClosedStream = Class.new(Error)
-  # The exception raised when a filename exceeds 256 bytes in length, the
-  # maximum supported by the standard Tar format.
-  FileNameTooLong = Class.new(Error)
-  # The exception raised when a data stream ends before the amount of data
-  # expected in the archive's PosixHeader.
-  UnexpectedEOF = Class.new(StandardError)
-  # The exception raised when a file contains a relative path in secure mode
-  # (the default for this version).
-  SecureRelativePathError = Class.new(Error)
-  # The exception raised when a file contains an invalid Posix header.
-  InvalidTarStream = Class.new(Error)
-
-  class << self
-    # Tests if +path+ refers to a directory. Fixes an apparently
-    # corrupted <tt>stat()</tt> call on Windows.
-    def dir?(path)
-      # rubocop:disable Style/CharacterLiteral
-      File.directory?((path[-1] == ?/) ? path : "#{path}/")
-      # rubocop:enable Style/CharacterLiteral
-    end
-
-    # A convenience method for wrapping Archive::Tar::Minitar::Input.open
-    # (mode +r+) and Archive::Tar::Minitar::Output.open (mode +w+). No other
-    # modes are currently supported.
-    def open(dest, mode = "r", &block)
-      case mode
-      when "r"
-        Input.open(dest, &block)
-      when "w"
-        Output.open(dest, &block)
-      else
-        raise "Unknown open mode for Archive::Tar::Minitar.open."
-      end
-    end
-
-    def const_missing(c) # :nodoc:
-      case c
-      when :BlockRequired
-        warn "This constant has been removed."
-        const_set(:BlockRequired, Class.new(StandardError))
-      else
-        super
-      end
-    end
-
-    def windows? # :nodoc:
-      RbConfig::CONFIG["host_os"] =~ /^(mswin|mingw|cygwin)/
-    end
-
-    # A convenience method to pack the file provided. +entry+ may either be a
-    # filename (in which case various values for the file (see below) will be
-    # obtained from <tt>File#stat(entry)</tt> or a Hash with the fields:
-    #
-    # <tt>:name</tt>::  The filename to be packed into the archive. Required.
-    # <tt>:mode</tt>::  The mode to be applied.
-    # <tt>:uid</tt>::   The user owner of the file. (Ignored on Windows.)
-    # <tt>:gid</tt>::   The group owner of the file. (Ignored on Windows.)
-    # <tt>:mtime</tt>:: The modification Time of the file.
-    #
-    # During packing, if a block is provided, #pack_file yields an +action+
-    # Symol, the full name of the file being packed, and a Hash of
-    # statistical information, just as with
-    # Archive::Tar::Minitar::Input#extract_entry.
-    #
-    # The +action+ will be one of:
-    # <tt>:dir</tt>::           The +entry+ is a directory.
-    # <tt>:file_start</tt>::    The +entry+ is a file; the extract of the
-    #                           file is just beginning.
-    # <tt>:file_progress</tt>:: Yielded every 4096 bytes during the extract
-    #                           of the +entry+.
-    # <tt>:file_done</tt>::     Yielded when the +entry+ is completed.
-    #
-    # The +stats+ hash contains the following keys:
-    # <tt>:current</tt>:: The current total number of bytes read in the
-    #                     +entry+.
-    # <tt>:currinc</tt>:: The current number of bytes read in this read
-    #                     cycle.
-    # <tt>:name</tt>::    The filename to be packed into the tarchive.
-    #                     *REQUIRED*.
-    # <tt>:mode</tt>::    The mode to be applied.
-    # <tt>:uid</tt>::     The user owner of the file. (+nil+ on Windows.)
-    # <tt>:gid</tt>::     The group owner of the file. (+nil+ on Windows.)
-    # <tt>:mtime</tt>::   The modification Time of the file.
-    def pack_file(entry, outputter) # :yields action, name, stats:
-      if outputter.is_a?(Archive::Tar::Minitar::Output)
-        outputter = outputter.tar
-      end
-
-      stats = {}
-
-      if entry.is_a?(Hash)
-        name = entry[:name]
-        entry.each { |kk, vv| stats[kk] = vv unless vv.nil? }
-      else
-        name = entry
-      end
-
-      name = name.sub(%r{\./}, "")
-      stat = File.stat(name)
-      stats[:mode] ||= stat.mode
-      stats[:mtime] ||= stat.mtime
-      stats[:size] = stat.size
-
-      if windows?
-        stats[:uid] = nil
-        stats[:gid] = nil
-      else
-        stats[:uid] ||= stat.uid
-        stats[:gid] ||= stat.gid
-      end
-
-      if File.file?(name)
-        outputter.add_file_simple(name, stats) do |os|
-          stats[:current] = 0
-          yield :file_start, name, stats if block_given?
-          File.open(name, "rb") do |ff|
-            until ff.eof?
-              stats[:currinc] = os.write(ff.read(4096))
-              stats[:current] += stats[:currinc]
-              yield :file_progress, name, stats if block_given?
-            end
-          end
-          yield :file_done, name, stats if block_given?
-        end
-      elsif dir?(name)
-        yield :dir, name, stats if block_given?
-        outputter.mkdir(name, stats)
-      else
-        raise "Don't yet know how to pack this type of file."
-      end
-    end
-
-    # A convenience method to pack files specified by +src+ into +dest+. If
-    # +src+ is an Array, then each file detailed therein will be packed into
-    # the resulting Archive::Tar::Minitar::Output stream; if +recurse_dirs+ is
-    # true, then directories will be recursed.
-    #
-    # If +src+ is not an Array, it will be treated as the result of Find.find;
-    # all files matching will be packed.
-    def pack(src, dest, recurse_dirs = true, &block)
-      require "find"
-      Output.open(dest) do |outp|
-        if src.is_a?(Array)
-          src.each do |entry|
-            if dir?(entry) && recurse_dirs
-              Find.find(entry) do |ee|
-                pack_file(ee, outp, &block)
-              end
-            else
-              pack_file(entry, outp, &block)
-            end
-          end
-        else
-          Find.find(src) do |entry|
-            pack_file(entry, outp, &block)
-          end
-        end
-      end
-    end
-
-    # A convenience method to unpack files from +src+ into the directory
-    # specified by +dest+. Only those files named explicitly in +files+
-    # will be extracted.
-    def unpack(src, dest, files = [], options = {}, &block)
-      Input.open(src) do |inp|
-        if File.exist?(dest) && !dir?(dest)
-          raise "Can't unpack to a non-directory."
-        end
-
-        FileUtils.mkdir_p(dest) unless File.exist?(dest)
-
-        inp.each do |entry|
-          if files.empty? || files.include?(entry.full_name)
-            inp.extract_entry(dest, entry, options, &block)
-          end
-        end
-      end
-    end
-
-    # Check whether +io+ can seek without errors.
-    def seekable?(io, methods = nil)
-      # The IO class throws an exception at runtime if we try to change
-      # position on a non-regular file.
-      if io.respond_to?(:stat)
-        io.stat.file?
-      else
-        # Duck-type the rest of this.
-        methods ||= [:pos, :pos=, :seek, :rewind]
-        methods = [methods] unless methods.is_a?(Array)
-        methods.all? { |m| io.respond_to?(m) }
-      end
-    end
-
-    private
-
-    def included(mod)
-      return if modules.include?(mod)
-      warn "Including #{self} has been deprecated (Minitar will become a class)."
-      modules << mod
-    end
-
-    def modules
-      require "set"
-      @modules ||= Set.new
-    end
-  end
-
-  # This exists to make bytesize implementations work across Ruby versions.
-  module ByteSize # :nodoc:
-    private
-
-    if "".respond_to?(:bytesize)
-      def bytesize(item)
-        item.bytesize
-      end
-    else
-      def bytesize(item)
-        item.size
-      end
-    end
-  end
-end
-
-require "archive/tar/minitar/posix_header"
-require "archive/tar/minitar/input"
-require "archive/tar/minitar/output"

data/lib/archive-tar-minitar.rb

@@ -1,3 +0,0 @@
-# coding: utf-8
-
-require "archive/tar/minitar"