minitar 0.9 → 0.12

data/lib/archive/tar/minitar.rb

@@ -2,18 +2,19 @@
 
 ##
 module Archive; end
+
 ##
 module Archive::Tar; end
 
-require 'fileutils'
-require 'rbconfig'
+require "fileutils"
+require "rbconfig"
 
-class << Archive::Tar #:nodoc:
-  def const_missing(const) #:nodoc:
+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'
+      warn "Archive::Tar::PosixHeader has been renamed to " \
+        "Archive::Tar::Minitar::PosixHeader"
       const_set :PosixHeader, Archive::Tar::Minitar::PosixHeader
     else
       super
@@ -29,7 +30,7 @@ class << Archive::Tar #:nodoc:
   end
 
   def modules
-    require 'set'
+    require "set"
     @modules ||= Set.new
   end
 end
@@ -73,7 +74,7 @@ end
 #       tar.close
 #     end
 module Archive::Tar::Minitar
-  VERSION = '0.9'.freeze # :nodoc:
+  VERSION = "0.12".freeze # :nodoc:
 
   # The base class for any minitar error.
   Error = Class.new(::StandardError)
@@ -99,36 +100,36 @@ module Archive::Tar::Minitar
     # corrupted <tt>stat()</tt> call on Windows.
     def dir?(path)
       # rubocop:disable Style/CharacterLiteral
-      File.directory?(path[-1] == ?/ ? path : "#{path}/")
+      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)
+    def open(dest, mode = "r", &block)
       case mode
-      when 'r'
+      when "r"
         Input.open(dest, &block)
-      when 'w'
+      when "w"
         Output.open(dest, &block)
       else
-        raise 'Unknown open mode for Archive::Tar::Minitar.open.'
+        raise "Unknown open mode for Archive::Tar::Minitar.open."
       end
     end
 
-    def const_missing(c) #:nodoc:
+    def const_missing(c) # :nodoc:
       case c
       when :BlockRequired
-        warn 'This constant has been removed.'
+        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)/
+    def windows? # :nodoc:
+      RbConfig::CONFIG["host_os"] =~ /^(mswin|mingw|cygwin)/
     end
 
     # A convenience method to pack the file provided. +entry+ may either be a
@@ -165,39 +166,39 @@ module Archive::Tar::Minitar
     # <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.kind_of?(Archive::Tar::Minitar::Output)
+    def pack_file(entry, outputter) # :yields action, name, stats:
+      if outputter.is_a?(Archive::Tar::Minitar::Output)
         outputter = outputter.tar
       end
 
       stats = {}
 
-      if entry.kind_of?(Hash)
+      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{\./}, '')
+      name = name.sub(%r{\./}, "")
       stat = File.stat(name)
-      stats[:mode]   ||= stat.mode
-      stats[:mtime]  ||= stat.mtime
+      stats[:mode] ||= stat.mode
+      stats[:mtime] ||= stat.mtime
       stats[:size] = stat.size
 
       if windows?
-        stats[:uid]  = nil
-        stats[:gid]  = nil
+        stats[:uid] = nil
+        stats[:gid] = nil
       else
-        stats[:uid]  ||= stat.uid
-        stats[:gid]  ||= stat.gid
+        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|
+          File.open(name, "rb") do |ff|
             until ff.eof?
               stats[:currinc] = os.write(ff.read(4096))
               stats[:current] += stats[:currinc]
@@ -210,7 +211,7 @@ module Archive::Tar::Minitar
         yield :dir, name, stats if block_given?
         outputter.mkdir(name, stats)
       else
-        raise %q(Don't yet know how to pack this type of file.)
+        raise "Don't yet know how to pack this type of file."
       end
     end
 
@@ -219,14 +220,14 @@ module Archive::Tar::Minitar
     # the resulting Archive::Tar::Minitar::Output stream; if +recurse_dirs+ is
     # true, then directories will be recursed.
     #
-    # If +src+ is an Array, it will be treated as the result of Find.find; all
-    # files matching will be packed.
+    # 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'
+      require "find"
       Output.open(dest) do |outp|
-        if src.kind_of?(Array)
+        if src.is_a?(Array)
           src.each do |entry|
-            if dir?(entry) and recurse_dirs
+            if dir?(entry) && recurse_dirs
               Find.find(entry) do |ee|
                 pack_file(ee, outp, &block)
               end
@@ -247,14 +248,14 @@ module Archive::Tar::Minitar
     # will be extracted.
     def unpack(src, dest, files = [], options = {}, &block)
       Input.open(src) do |inp|
-        if File.exist?(dest) and !dir?(dest)
-          raise %q(Can't unpack to a non-directory.)
+        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? or files.include?(entry.full_name)
+          if files.empty? || files.include?(entry.full_name)
             inp.extract_entry(dest, entry, options, &block)
           end
         end
@@ -269,8 +270,8 @@ module Archive::Tar::Minitar
         io.stat.file?
       else
         # Duck-type the rest of this.
-        methods ||= [ :pos, :pos=, :seek, :rewind ]
-        methods = [ methods ] unless methods.kind_of?(Array)
+        methods ||= [:pos, :pos=, :seek, :rewind]
+        methods = [methods] unless methods.is_a?(Array)
         methods.all? { |m| io.respond_to?(m) }
       end
     end
@@ -284,7 +285,7 @@ module Archive::Tar::Minitar
     end
 
     def modules
-      require 'set'
+      require "set"
       @modules ||= Set.new
     end
   end
@@ -293,7 +294,7 @@ module Archive::Tar::Minitar
   module ByteSize # :nodoc:
     private
 
-    if ''.respond_to?(:bytesize)
+    if "".respond_to?(:bytesize)
       def bytesize(item)
         item.bytesize
       end
@@ -305,6 +306,6 @@ module Archive::Tar::Minitar
   end
 end
 
-require 'archive/tar/minitar/posix_header'
-require 'archive/tar/minitar/input'
-require 'archive/tar/minitar/output'
+require "archive/tar/minitar/posix_header"
+require "archive/tar/minitar/input"
+require "archive/tar/minitar/output"

data/lib/archive-tar-minitar.rb

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

data/lib/minitar.rb

@@ -1,6 +1,6 @@
 # coding: utf-8
 
-require 'archive/tar/minitar'
+require "archive/tar/minitar"
 
 if defined?(::Minitar) && ::Minitar != Archive::Tar::Minitar
   warn <<-EOS

data/support/hoe/deprecated_gem.rb

@@ -0,0 +1,64 @@
+# A Hoe plug-in to provide a second, linked gemspec, for a gem that has been
+# deprecated in favour of a modern name. (The name is an artifact of Hoe's
+# plugin loading.)
+module Hoe::Deprecated_Gem # standard:disable Naming/ClassAndModuleCamelCase
+  def linked_spec(spec)
+    permitted_classes = %w[
+      Symbol Time Date Gem::Dependency Gem::Platform Gem::Requirement
+      Gem::Specification Gem::Version Gem::Version::Requirement
+      YAML::Syck::DefaultKey Syck::DefaultKey
+    ]
+    permitted_symbols = %w[development runtime]
+    atm = begin
+      YAML.safe_load(
+        YAML.dump(spec),
+        :permitted_classes => permitted_classes,
+        :permitted_symbols => permitted_symbols,
+        :aliases => true
+      )
+    rescue
+      YAML.safe_load(
+        YAML.dump(spec), permitted_classes, permitted_symbols, true
+      )
+    end
+    atm.name = "archive-tar-minitar"
+    d = %('#{atm.name}' has been deprecated; just install '#{spec.name}'.)
+    atm.description = "#{d} #{spec.description}"
+    atm.summary = atm.post_install_message = d
+    atm.files.delete_if do |f|
+      f !~ %r{lib/archive-tar-minitar\.rb}
+    end
+    atm.extra_rdoc_files.clear
+    atm.rdoc_options.clear
+    atm.dependencies.clear
+
+    version = Gem::Version.new(spec.version.segments.first(2).join("."))
+
+    atm.add_dependency(spec.name, "~> #{version}")
+    atm.add_dependency(%(#{spec.name}-cli), "~> #{version}")
+
+    unless @include_all
+      [:signing_key, :cert_chain].each { |name|
+        atm.send(:"#{name}=", atm.default_value(name))
+      }
+    end
+
+    atm
+  end
+
+  def define_deprecated_gem_tasks
+    gemspec = spec.name + ".gemspec"
+    atmspec = "archive-tar-minitar.gemspec"
+
+    file atmspec => gemspec do
+      File.open(atmspec, "w") { |f| f.write(linked_spec(spec).to_ruby) }
+    end
+
+    task :gemspec => atmspec
+
+    Gem::PackageTask.new linked_spec(spec) do |pkg|
+      pkg.need_tar = @need_tar
+      pkg.need_zip = @need_zip
+    end
+  end
+end

data/test/minitest_helper.rb

@@ -1,11 +1,12 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
-require 'fileutils'
-require 'minitar'
+require "fileutils"
+require "minitar"
 
-gem 'minitest'
-require 'minitest/autorun'
+gem "minitest"
+require "minitest/autorun"
+require "minitest/focus"
 
-Dir.glob(File.join(File.dirname(__FILE__), 'support/*.rb')).each do |support|
+Dir.glob(File.join(File.dirname(__FILE__), "support/*.rb")).sort.each do |support|
   require support
 end

data/test/support/tar_test_helpers.rb

@@ -4,7 +4,7 @@ module TarTestHelpers
   include Archive::Tar::Minitar::ByteSize
 
   Field = Struct.new(:name, :offset, :length)
-  def self.Field(name, length) # rubocop:disable Style/MethodName
+  def self.Field(name, length)
     @offset ||= 0
     field = Field.new(name, @offset, length)
     @offset += length
@@ -15,38 +15,38 @@ module TarTestHelpers
 
   private
 
-  FIELDS = {} # rubocop:disable Style/MutableConstant
-  FIELD_ORDER = [] # rubocop:disable Style/MutableConstant
-
-  Field('name', 100)
-  Field('mode', 8)
-  Field('uid', 8)
-  Field('gid', 8)
-  Field('size', 12)
-  Field('mtime', 12)
-  Field('checksum', 8)
-  Field('typeflag', 1)
-  Field('linkname', 100)
-  Field('magic', 6)
-  Field('version', 2)
-  Field('uname', 32)
-  Field('gname', 32)
-  Field('devmajor', 8)
-  Field('devminor', 8)
-  Field('prefix', 155)
-
-  BLANK_CHECKSUM = ' ' * 8
+  FIELDS = {}
+  FIELD_ORDER = []
+
+  Field("name", 100)
+  Field("mode", 8)
+  Field("uid", 8)
+  Field("gid", 8)
+  Field("size", 12)
+  Field("mtime", 12)
+  Field("checksum", 8)
+  Field("typeflag", 1)
+  Field("linkname", 100)
+  Field("magic", 6)
+  Field("version", 2)
+  Field("uname", 32)
+  Field("gname", 32)
+  Field("devmajor", 8)
+  Field("devminor", 8)
+  Field("prefix", 155)
+
+  BLANK_CHECKSUM = " " * 8
   NULL_100 = "\0" * 100
-  USTAR = "ustar\0".freeze
-  DOUBLE_ZERO = '00'.freeze
+  USTAR = "ustar\0"
+  DOUBLE_ZERO = "00"
 
   def assert_headers_equal(expected, actual)
     FIELD_ORDER.each do |field|
-      message = if field == 'checksum'
-                  'Header checksums are expected to match.'
-                else
-                  "Header field #{field} is expected to match."
-                end
+      message = if field == "checksum"
+        "Header checksums are expected to match."
+      else
+        "Header field #{field} is expected to match."
+      end
 
       offset = FIELDS[field].offset
       length = FIELDS[field].length
@@ -66,40 +66,44 @@ module TarTestHelpers
   end
 
   def tar_file_header(fname, dname, mode, length)
-    update_checksum(header('0', fname, dname, length, mode))
+    update_checksum(header("0", fname, dname, length, mode))
   end
 
   def tar_dir_header(name, prefix, mode)
-    update_checksum(header('5', name, prefix, 0, mode))
+    update_checksum(header("5", name, prefix, 0, mode))
   end
 
-  def header(type, fname, dname, length, mode)
+  def tar_symlink_header(name, prefix, mode, target)
+    update_checksum(header("2", name, prefix, 0, mode, target))
+  end
+
+  def header(type, fname, dname, length, mode, link_name = "")
     raw_header(type,
       asciiz(fname, 100),
       asciiz(dname, 155),
       z(to_oct(length, 11)),
-      z(to_oct(mode, 7))
-    )
+      z(to_oct(mode, 7)),
+      asciiz(link_name, 100))
   end
 
-  def raw_header(type, fname, dname, length, mode)
+  def raw_header(type, fname, dname, length, mode, link_name = "")
     arr = [
       fname, mode, z(to_oct(nil, 7)), z(to_oct(nil, 7)),
       length, z(to_oct(0, 11)), BLANK_CHECKSUM, type,
-      NULL_100, USTAR, DOUBLE_ZERO, asciiz('', 32), asciiz('', 32),
+      asciiz(link_name, 100), USTAR, DOUBLE_ZERO, asciiz("", 32), asciiz("", 32),
       z(to_oct(nil, 7)), z(to_oct(nil, 7)), dname
     ]
 
-    h = arr.join.bytes.to_a.pack('C100C8C8C8C12C12C8CC100C6C2C32C32C8C8C155')
+    h = arr.join.bytes.to_a.pack("C100C8C8C8C12C12C8CC100C6C2C32C32C8C8C155")
     ret = h + "\0" * (512 - bytesize(h))
     assert_equal(512, bytesize(ret))
     ret
   end
 
   def update_checksum(header)
-    header[FIELDS['checksum'].offset, FIELDS['checksum'].length] =
+    header[FIELDS["checksum"].offset, FIELDS["checksum"].length] =
       # inject(:+) was introduced in which version?
-      sp(z(to_oct(header.unpack('C*').inject { |a, e| a + e }, 6)))
+      sp(z(to_oct(header.unpack("C*").inject { |a, e| a + e }, 6)))
     header
   end
 
@@ -116,7 +120,7 @@ module TarTestHelpers
   end
 
   def sp(s)
-    s + ' '
+    s + " "
   end
 
   def z(s)
@@ -124,7 +128,7 @@ module TarTestHelpers
   end
 
   def mode_string(value)
-    '%04o' % (value & 0o777)
+    "%04o" % (value & 0o777)
   end
 
   Minitest::Test.send(:include, self)

data/test/test_tar_header.rb

@@ -1,79 +1,79 @@
 # frozen_string_literal: true
 
-require 'minitest_helper'
+require "minitest_helper"
 
 class TestTarHeader < Minitest::Test
   def test_arguments_are_checked
     ph = Archive::Tar::Minitar::PosixHeader
     assert_raises(ArgumentError) {
-      ph.new(:name => '', :size => '', :mode => '')
+      ph.new(:name => "", :size => "", :mode => "")
     }
     assert_raises(ArgumentError) {
-      ph.new(:name => '', :size => '', :prefix => '')
+      ph.new(:name => "", :size => "", :prefix => "")
     }
     assert_raises(ArgumentError) {
-      ph.new(:name => '', :prefix => '', :mode => '')
+      ph.new(:name => "", :prefix => "", :mode => "")
     }
     assert_raises(ArgumentError) {
-      ph.new(:prefix => '', :size => '', :mode => '')
+      ph.new(:prefix => "", :size => "", :mode => "")
     }
   end
 
   def test_basic_headers
     header = {
-      :name => 'bla',
+      :name => "bla",
       :mode => 0o12345,
       :size => 10,
-      :prefix => '',
-      :typeflag => '0'
+      :prefix => "",
+      :typeflag => "0"
     }
-    assert_headers_equal(tar_file_header('bla', '', 0o12345, 10),
+    assert_headers_equal(tar_file_header("bla", "", 0o12345, 10),
       Archive::Tar::Minitar::PosixHeader.new(header).to_s)
 
     header = {
-      :name => 'bla',
+      :name => "bla",
       :mode => 0o12345,
       :size => 0,
-      :prefix => '',
-      :typeflag => '5'
+      :prefix => "",
+      :typeflag => "5"
     }
-    assert_headers_equal(tar_dir_header('bla', '', 0o12345),
+    assert_headers_equal(tar_dir_header("bla", "", 0o12345),
       Archive::Tar::Minitar::PosixHeader.new(header).to_s)
   end
 
   def test_long_name_works
     header = {
-      :name => 'a' * 100, :mode => 0o12345, :size => 10, :prefix => ''
+      :name => "a" * 100, :mode => 0o12345, :size => 10, :prefix => ""
     }
-    assert_headers_equal(tar_file_header('a' * 100, '', 0o12345, 10),
+    assert_headers_equal(tar_file_header("a" * 100, "", 0o12345, 10),
       Archive::Tar::Minitar::PosixHeader.new(header).to_s)
     header = {
-      :name => 'a' * 100, :mode => 0o12345, :size => 10, :prefix => 'bb' * 60
+      :name => "a" * 100, :mode => 0o12345, :size => 10, :prefix => "bb" * 60
     }
-    assert_headers_equal(tar_file_header('a' * 100, 'bb' * 60, 0o12345, 10),
+    assert_headers_equal(tar_file_header("a" * 100, "bb" * 60, 0o12345, 10),
       Archive::Tar::Minitar::PosixHeader.new(header).to_s)
   end
 
   def test_from_stream
-    header = tar_file_header('a' * 100, '', 0o12345, 10)
+    header = tar_file_header("a" * 100, "", 0o12345, 10)
     header = StringIO.new(header)
     h = Archive::Tar::Minitar::PosixHeader.from_stream(header)
-    assert_equal('a' * 100, h.name)
+    assert_equal("a" * 100, h.name)
     assert_equal(0o12345, h.mode)
     assert_equal(10, h.size)
-    assert_equal('', h.prefix)
-    assert_equal('ustar', h.magic)
+    assert_equal("", h.prefix)
+    assert_equal("ustar", h.magic)
   end
 
   def test_from_stream_with_evil_name
-    header = tar_file_header("a \0" + "\0" * 97, '', 0o12345, 10)
+    header = tar_file_header("a \0" + "\0" * 97, "", 0o12345, 10)
     header = StringIO.new(header)
     h = Archive::Tar::Minitar::PosixHeader.from_stream header
-    assert_equal('a ', h.name)
+    assert_equal("a ", h.name)
   end
 
   def test_valid_with_valid_header
-    header = tar_file_header('a' * 100, '', 0o12345, 10)
+    header = tar_file_header("a" * 100, "", 0o12345, 10)
     header = StringIO.new(header)
     h = Archive::Tar::Minitar::PosixHeader.from_stream header
 
@@ -81,8 +81,8 @@ class TestTarHeader < Minitest::Test
   end
 
   def test_from_stream_with_no_strict_octal
-    header = tar_file_header('a' * 100, '', 0o12345, -1213)
-    io     = StringIO.new(header)
+    header = tar_file_header("a" * 100, "", 0o12345, -1213)
+    io = StringIO.new(header)
 
     assert_raises(ArgumentError) do
       Archive::Tar::Minitar::PosixHeader.from_stream(io)
@@ -91,14 +91,13 @@ class TestTarHeader < Minitest::Test
 
   def test_from_stream_with_octal_wrapped_by_spaces
     header = raw_header(0,
-      asciiz('a' * 100, 100),
-      asciiz('', 155),
+      asciiz("a" * 100, 100),
+      asciiz("", 155),
       "       1213\0",
-      z(to_oct(0o12345, 7))
-    )
+      z(to_oct(0o12345, 7)))
 
     header = update_checksum(header)
-    io     = StringIO.new(header)
+    io = StringIO.new(header)
     header = Archive::Tar::Minitar::PosixHeader.from_stream(io)
 
     assert_equal(651, header.size)