minitar 1.0.2 → 1.1.0

data/lib/minitar/writer.rb

@@ -1,40 +1,27 @@
+# frozen_string_literal: true
+
 class Minitar
   # The class that writes a tar format archive to a data stream.
   class Writer
-    # The exception raised when the user attempts to write more data to a
-    # BoundedWriteStream than has been allocated.
+    # The exception raised when the user attempts to write more data to
+    # a BoundedWriteStream than has been allocated.
     WriteBoundaryOverflow = Class.new(StandardError)
 
-    # A stream wrapper that can only be written to. Any attempt to read
-    # from this restricted stream will result in a NameError being thrown.
+    # A stream wrapper that can only be written to. Any attempt to read from this
+    # restricted stream will result in a NameError being thrown.
     class WriteOnlyStream
       def initialize(io)
         @io = io
       end
 
-      def write(data)
-        @io.write(data)
-      end
+      def write(data) = @io.write(data)
     end
 
-    private_constant :WriteOnlyStream if respond_to?(:private_constant)
+    private_constant :WriteOnlyStream
 
     # A WriteOnlyStream that also has a size limit.
     class BoundedWriteStream < WriteOnlyStream
-      def self.const_missing(c)
-        case c
-        when :FileOverflow
-          warn "Writer::BoundedWriteStream::FileOverflow has been renamed " \
-            "to Writer::WriteBoundaryOverflow"
-          const_set :FileOverflow,
-            Minitar::Writer::WriteBoundaryOverflow
-        else
-          super
-        end
-      end
-
-      # The maximum number of bytes that may be written to this data
-      # stream.
+      # The maximum number of bytes that may be written to this data stream.
       attr_reader :limit
       # The current total number of bytes written to this data stream.
       attr_reader :written
@@ -54,25 +41,14 @@ class Minitar
       end
     end
 
-    private_constant :BoundedWriteStream if respond_to?(:private_constant)
-
-    def self.const_missing(c)
-      case c
-      when :BoundedStream
-        warn "BoundedStream has been renamed to BoundedWriteStream"
-        const_set(:BoundedStream, BoundedWriteStream)
-      else
-        super
-      end
-    end
+    private_constant :BoundedWriteStream
 
-    # With no associated block, +Writer::open+ is a synonym for +Writer::new+.
-    # If the optional code block is given, it will be passed the new _writer_
-    # as an argument and the Writer object will automatically be closed when
-    # the block terminates. In this instance, +Writer::open+ returns the value
-    # of the block.
+    # With no associated block, +Writer::open+ is a synonym for +Writer::new+. If the
+    # optional code block is given, it will be passed the new _writer_ as an argument and
+    # the Writer object will automatically be closed when the block terminates. In this
+    # instance, +Writer::open+ returns the value of the block.
     #
-    # call-seq:
+    # :call-seq:
     #    w = Minitar::Writer.open(STDOUT)
     #    w.add_file_simple('foo.txt', :size => 3)
     #    w.close
@@ -80,12 +56,12 @@ class Minitar
     #    Minitar::Writer.open(STDOUT) do |w|
     #      w.add_file_simple('foo.txt', :size => 3)
     #    end
-    def self.open(io) # :yields Writer:
+    def self.open(io) # :yields: Writer
       writer = new(io)
       return writer unless block_given?
 
-      # This exception context must remain, otherwise the stream closes on open
-      # even if a block is not given.
+      # This exception context must remain, otherwise the stream closes on open even if
+      # a block is not given.
       begin
         yield writer
       ensure
@@ -100,36 +76,35 @@ class Minitar
     end
 
     # Adds a file to the archive as +name+. The data can be provided in the
-    # <tt>opts[:data]</tt> or provided to a BoundedWriteStream that is
-    # yielded to the provided block.
+    # <tt>opts[:data]</tt> or provided to a BoundedWriteStream that is yielded to the
+    # provided block.
     #
-    # If <tt>opts[:data]</tt> is provided, all other values to +opts+ are
-    # optional. If the data is provided to the yielded BoundedWriteStream,
-    # <tt>opts[:size]</tt> must be provided.
+    # If <tt>opts[:data]</tt> is provided, all other values to +opts+ are optional. If the
+    # data is provided to the yielded BoundedWriteStream, <tt>opts[:size]</tt> must be
+    # provided.
     #
     # Valid parameters to +opts+ are:
     #
     # <tt>:data</tt>::  Optional. The data to write to the archive.
-    # <tt>:mode</tt>::  The Unix file permissions mode value. If not
-    #                   provided, defaults to 0644.
-    # <tt>:size</tt>::  The size, in bytes. If <tt>:data</tt> is provided,
-    #                   this parameter may be ignored (if it is less than
-    #                   the size of the data provided) or used to add
-    #                   padding (if it is greater than the size of the data
+    # <tt>:mode</tt>::  The Unix file permissions mode value. If not provided, defaults to
+    #                   0o644.
+    # <tt>:size</tt>::  The size, in bytes. If <tt>:data</tt> is provided, this parameter
+    #                   may be ignored (if it is less than the size of the data provided)
+    #                   or used to add padding (if it is greater than the size of the data
     #                   provided).
     # <tt>:uid</tt>::   The Unix file owner user ID number.
     # <tt>:gid</tt>::   The Unix file owner group ID number.
     # <tt>:mtime</tt>:: File modification time, interpreted as an integer.
     #
-    # An exception will be raised if the Writer is already closed, or if
-    # more data is written to the BoundedWriteStream than expected.
+    # An exception will be raised if the Writer is already closed, or if more data is
+    # written to the BoundedWriteStream than expected.
     #
-    # call-seq:
+    # :call-seq:
     #    writer.add_file_simple('foo.txt', :data => "bar")
     #    writer.add_file_simple('foo.txt', :size => 3) do |w|
     #      w.write("bar")
     #    end
-    def add_file_simple(name, opts = {}) # :yields BoundedWriteStream:
+    def add_file_simple(name, opts = {}) # :yields: BoundedWriteStream
       raise ClosedStream if @closed
 
       header = {
@@ -143,11 +118,7 @@ class Minitar
       size = opts.fetch(:size, nil)
 
       if block_given?
-        if data
-          raise ArgumentError,
-            "Too much data (opts[:data] and block_given?)."
-        end
-
+        raise ArgumentError, "Too much data (opts[:data] and block_given?)." if data
         raise ArgumentError, "No size provided" unless size
       else
         raise ArgumentError, "No data provided" unless data
@@ -175,36 +146,32 @@ class Minitar
     end
 
     # Adds a file to the archive as +name+. The data can be provided in the
-    # <tt>opts[:data]</tt> or provided to a yielded +WriteOnlyStream+. The
-    # size of the file will be determined from the amount of data written
-    # to the stream.
+    # <tt>opts[:data]</tt> or provided to a yielded +WriteOnlyStream+. The size of the
+    # file will be determined from the amount of data written to the stream.
     #
     # Valid parameters to +opts+ are:
     #
-    # <tt>:mode</tt>::  The Unix file permissions mode value. If not
-    #                   provided, defaults to 0644.
+    # <tt>:mode</tt>::  The Unix file permissions mode value. If not provided, defaults to
+    #                   0o644.
     # <tt>:uid</tt>::   The Unix file owner user ID number.
     # <tt>:gid</tt>::   The Unix file owner group ID number.
     # <tt>:mtime</tt>:: File modification time, interpreted as an integer.
     # <tt>:data</tt>::  Optional. The data to write to the archive.
     #
-    # If <tt>opts[:data]</tt> is provided, this acts the same as
-    # #add_file_simple. Otherwise, the file's size will be determined from
-    # the amount of data written to the stream.
+    # If <tt>opts[:data]</tt> is provided, this acts the same as #add_file_simple.
+    # Otherwise, the file's size will be determined from the amount of data written to the
+    # stream.
     #
-    # For #add_file to be used without <tt>opts[:data]</tt>, the Writer
-    # must be wrapping a stream object that is seekable. Otherwise,
-    # #add_file_simple must be used.
+    # For #add_file to be used without <tt>opts[:data]</tt>, the Writer must be wrapping
+    # a stream object that is seekable. Otherwise, #add_file_simple must be used.
     #
     # +opts+ may be modified during the writing of the file to the stream.
-    def add_file(name, opts = {}, &) # :yields WriteOnlyStream, +opts+:
+    def add_file(name, opts = {}, &) # :yields: WriteOnlyStream, +opts+
       raise ClosedStream if @closed
 
       return add_file_simple(name, opts, &) if opts[:data]
 
-      unless Minitar.seekable?(@io)
-        raise Minitar::NonSeekableStream
-      end
+      raise Minitar::NonSeekableStream unless Minitar.seekable?(@io)
 
       short_name, prefix, needs_long_name = split_name(name)
 
@@ -255,7 +222,6 @@ class Minitar
     # Creates a symbolic link entry in the tar.
     def symlink(name, link_target, opts = {})
       raise ClosedStream if @closed
-
       raise FileNameTooLong if link_target.size > 100
 
       name, prefix = split_name(name)
@@ -270,24 +236,20 @@ class Minitar
         mtime: opts[:mtime],
         prefix: prefix
       }
-      @io.write(PosixHeader.new(header))
+      @io.write(PosixHeader.new(header).to_s)
       nil
     end
 
-    # Passes the #flush method to the wrapped stream, used for buffered
-    # streams.
+    # Passes the #flush method to the wrapped stream, used for buffered streams.
     def flush
       raise ClosedStream if @closed
       @io.flush if @io.respond_to?(:flush)
     end
 
     # Returns false if the writer is open.
-    def closed?
-      @closed
-    end
+    def closed? = @closed
 
-    # Closes the Writer. This does not close the underlying wrapped output
-    # stream.
+    # Closes the Writer. This does not close the underlying wrapped output stream.
     def close
       return if @closed
       @io.write("\0" * 1024)
@@ -305,13 +267,13 @@ class Minitar
           size: long_name.length + 1,
           mode: 0
         }
-        @io.write(PosixHeader.new(long_name_header))
+        @io.write(PosixHeader.new(long_name_header).to_s)
         @io.write(long_name)
         @io.write("\0" * (512 - (long_name.length % 512)))
       end
 
       new_header = header.merge({name: short_name, prefix: prefix})
-      @io.write(PosixHeader.new(new_header))
+      @io.write(PosixHeader.new(new_header).to_s)
     end
 
     def split_name(name)

data/lib/minitar.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 require "fileutils"
 require "rbconfig"
+require "rbconfig/sizeof"
 
 # == Synopsis
 #
@@ -8,8 +11,8 @@ require "rbconfig"
 #     require 'zlib'
 #     require 'minitar'
 #
-#     # Packs everything that matches Find.find('tests').
-#     # test.tar will automatically be closed by Minitar.pack.
+#     # 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.
@@ -23,11 +26,10 @@ require "rbconfig"
 #     # 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.
+# 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(""))
@@ -40,52 +42,51 @@ require "rbconfig"
 #       tar.close
 #     end
 class Minitar
-  VERSION = "1.0.2".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.
+  # 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.
+  # 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.
+  # 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).
+  # 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)
 end
 
 class << Minitar
-  # Tests if +path+ refers to a directory. Fixes an apparently
-  # corrupted <tt>stat()</tt> call on Windows.
+  # Tests if +path+ refers to a directory. Fixes an apparently corrupted <tt>stat()</tt>
+  # call on Windows.
   def dir?(path)
-    File.directory?((path[-1] == "/") ? path : "#{path}/")
+    path = "#{path}/" unless path.to_s.end_with?("/")
+    File.directory?(path)
   end
 
-  # A convenience method for wrapping Minitar::Input.open
-  # (mode +r+) and Minitar::Output.open (mode +w+). No other
-  # modes are currently supported.
+  # A convenience method for wrapping Minitar::Input.open (mode +r+ or +rb) and
+  # Minitar::Output.open (mode +w+ or +wb+). No other modes are currently supported.
   def open(dest, mode = "r", &)
     case mode
-    when "r"
+    when "r", "rb"
       Minitar::Input.open(dest, &)
-    when "w"
-      Minitar::Output.open(dest, &block)
+    when "w", "wb"
+      Minitar::Output.open(dest, &)
     else
-      raise "Unknown open mode for Minitar.open."
+      raise ArgumentError, "Unknown open mode for Minitar.open."
     end
   end
 
-  def windows? # :nodoc:
-    RbConfig::CONFIG["host_os"] =~ /^(mswin|mingw|cygwin)/
-  end
+  def windows? = # :nodoc:
+    RUBY_PLATFORM =~ /^(?:cyginw|mingw|mswin)/i ||
+      RbConfig::CONFIG["host_os"].to_s =~ /^(cygwin|mingw|mswin|windows)/i ||
+      File::ALT_SEPARATOR == "\\"
 
   # A convenience method to pack the provided +data+ as a file named +entry+. +entry+ may
   # either be a name or a Hash with the fields described below. When only a name is
@@ -100,10 +101,8 @@ class << Minitar
   #
   # If +data+ is +nil+, a directory will be created. Use an empty String for a normal
   # empty file.
-  def pack_as_file(entry, data, outputter) # :yields action, name, stats:
-    if outputter.is_a?(Minitar::Output)
-      outputter = outputter.tar
-    end
+  def pack_as_file(entry, data, outputter) # :yields: action, name, stats
+    outputter = outputter.tar if outputter.is_a?(Minitar::Output)
 
     stats = {
       gid: nil,
@@ -114,8 +113,11 @@ class << Minitar
     }
 
     if entry.is_a?(Hash)
-      name = entry.delete(:name)
-      entry.each_pair { stats[_1] = _2 unless _2.nil? }
+      name = entry[:name]
+      entry.each_pair {
+        next if _1 == :name
+        stats[_1] = _2 unless _2.nil?
+      }
     else
       name = entry
     end
@@ -151,33 +153,27 @@ class << Minitar
   # <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 Minitar::Input#extract_entry.
+  # During packing, if a block is provided, #pack_file yields an +action+ Symbol, the full
+  # name of the file being packed, and a Hash of statistical information, just as with
+  # 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_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>: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?(Minitar::Output)
-      outputter = outputter.tar
-    end
+  def pack_file(entry, outputter) # :yields: action, name, stats
+    outputter = outputter.tar if outputter.is_a?(Minitar::Output)
 
     stats = {}
 
@@ -223,13 +219,12 @@ class << Minitar
     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 Minitar::Output stream; if +recurse_dirs+ is
-  # true, then directories will be recursed.
+  # 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
+  # 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.
+  # 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"
     Minitar::Output.open(dest) do |outp|
@@ -251,9 +246,8 @@ class << Minitar
     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.
+  # 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)
     Minitar::Input.open(src) do |inp|
       if File.exist?(dest) && !dir?(dest)
@@ -272,8 +266,8 @@ class << Minitar
 
   # 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.
+    # 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
@@ -286,5 +280,7 @@ class << Minitar
 end
 
 require "minitar/posix_header"
+require "minitar/pax_header"
 require "minitar/input"
 require "minitar/output"
+require "minitar/version"

data/licenses/bsdl.txt

@@ -0,0 +1,20 @@
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/licenses/dco.txt

@@ -0,0 +1,34 @@
+Developer Certificate of Origin
+Version 1.1
+
+Copyright (C) 2004, 2006 The Linux Foundation and its contributors.
+
+Everyone is permitted to copy and distribute verbatim copies of this
+license document, but changing it is not allowed.
+
+
+Developer's Certificate of Origin 1.1
+
+By making a contribution to this project, I certify that:
+
+(a) The contribution was created in whole or in part by me and I
+    have the right to submit it under the open source license
+    indicated in the file; or
+
+(b) The contribution is based upon previous work that, to the best
+    of my knowledge, is covered under an appropriate open source
+    license and I have the right under that license to submit that
+    work with modifications, whether created in whole or in part
+    by me, under the same open source license (unless I am
+    permitted to submit under a different license), as indicated
+    in the file; or
+
+(c) The contribution was provided directly to me by some other
+    person who certified (a), (b) or (c) and I have not modified
+    it.
+
+(d) I understand and agree that this project and the contribution
+    are public and that a record of the contribution (including all
+    personal information I submit with it, including my sign-off) is
+    maintained indefinitely and may be redistributed consistent with
+    this project or the open source license(s) involved.

data/licenses/ruby.txt

@@ -0,0 +1,52 @@
+1. You may make and give away verbatim copies of the source form of the
+   software without restriction, provided that you duplicate all of the
+   original copyright notices and associated disclaimers.
+
+2. You may modify your copy of the software in any way, provided that
+   you do at least ONE of the following:
+
+   a. place your modifications in the Public Domain or otherwise
+      make them Freely Available, such as by posting said
+      modifications to Usenet or an equivalent medium, or by allowing
+      the author to include your modifications in the software.
+
+   b. use the modified software only within your corporation or
+      organization.
+
+   c. give non-standard binaries non-standard names, with
+      instructions on where to get the original software distribution.
+
+   d. make other distribution arrangements with the author.
+
+3. You may distribute the software in object code or binary form,
+   provided that you do at least ONE of the following:
+
+   a. distribute the binaries and library files of the software,
+      together with instructions (in the manual page or equivalent)
+      on where to get the original distribution.
+
+   b. accompany the distribution with the machine-readable source of
+      the software.
+
+   c. give non-standard binaries non-standard names, with
+      instructions on where to get the original software distribution.
+
+   d. make other distribution arrangements with the author.
+
+4. You may modify and include the part of the software into any other
+   software (possibly commercial).  But some files in the distribution
+   are not written by the author, so that they are not under these terms.
+
+   For the list of those files and their copying conditions, see the
+   file LEGAL.
+
+5. The scripts and library files supplied as input to or produced as
+   output from the software do not automatically fall under the
+   copyright of the software, but belong to whomever generated them,
+   and may be sold commercially, and may be aggregated with this
+   software.
+
+6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+   IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+   PURPOSE.

data/test/minitest_helper.rb

@@ -1,10 +1,21 @@
+# frozen_string_literal: true
+
 require "fileutils"
 require "minitar"
+require "pathname"
+require "stringio"
+require "zlib"
 
 gem "minitest"
 require "minitest/autorun"
 require "minitest/focus"
 
-Dir.glob(File.join(File.dirname(__FILE__), "support/*.rb")).sort.each do |support|
+if ENV["STRICT"] != "false"
+  $VERBOSE = true
+  Warning[:deprecated] = true
+  require "minitest/error_on_warning"
+end
+
+Dir.glob(File.join(__dir__, "support/**/*.rb")).sort.each do |support|
   require support
 end