minitar 0.8 → 0.12

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

@@ -1,6 +1,6 @@
 # coding: utf-8
 
-require 'archive/tar/minitar/reader'
+require "archive/tar/minitar/reader"
 
 module Archive::Tar::Minitar
   # Wraps a Archive::Tar::Minitar::Reader with convenience methods and wrapped
@@ -19,14 +19,17 @@ module Archive::Tar::Minitar
     #    Archive::Tar::Minitar::Input.open(io) { |input| block } -> obj
     def self.open(input)
       stream = new(input)
-      return stream unless block_given?
-
-      # This exception context must remain, otherwise the stream closes on open
-      # even if a block is not given.
-      begin
-        yield stream
-      ensure
-        stream.close
+
+      if block_given?
+        # This exception context must remain, otherwise the stream closes on
+        # open even if a block is not given.
+        begin
+          yield stream
+        ensure
+          stream.close
+        end
+      else
+        stream
       end
     end
 
@@ -48,7 +51,7 @@ module Archive::Tar::Minitar
     def self.each_entry(input)
       return to_enum(__method__, input) unless block_given?
 
-      open(input) do |stream|
+      Input.open(input) do |stream|
         stream.each do |entry|
           yield entry
         end
@@ -68,10 +71,10 @@ module Archive::Tar::Minitar
     #    Archive::Tar::Minitar::Input.new(path) -> input
     def initialize(input)
       @io = if input.respond_to?(:read)
-              input
-            else
-              ::Kernel.open(input, 'rb')
-            end
+        input
+      else
+        ::Kernel.open(input, "rb")
+      end
 
       unless Archive::Tar::Minitar.seekable?(@io, :rewind)
         raise Archive::Tar::Minitar::NonSeekableStream
@@ -93,7 +96,7 @@ module Archive::Tar::Minitar
     ensure
       @tar.rewind
     end
-    alias each each_entry
+    alias_method :each, :each_entry
 
     # Extracts the current +entry+ to +destdir+. If a block is provided, it
     # yields an +action+ Symbol, the full name of the file being extracted
@@ -114,11 +117,11 @@ module Archive::Tar::Minitar
     #                     cycle.
     # <tt>:entry</tt>::   The entry being extracted; this is a
     #                     Reader::EntryStream, with all methods thereof.
-    def extract_entry(destdir, entry) # :yields action, name, stats:
+    def extract_entry(destdir, entry, options = {}, &block) # :yields action, name, stats:
       stats = {
-        :current  => 0,
-        :currinc  => 0,
-        :entry    => entry
+        :current => 0,
+        :currinc => 0,
+        :entry => entry
       }
 
       # extract_entry is not vulnerable to prefix '/' vulnerabilities, but it
@@ -130,66 +133,16 @@ module Archive::Tar::Minitar
       # leave +destdir+.
       #
       # However, squeeze consecutive '/' characters together.
-      full_name = entry.full_name.squeeze('/')
+      full_name = entry.full_name.squeeze("/")
 
-      if full_name =~ /\.{2}(?:\/|\z)/
-        raise SecureRelativePathError, %q(Path contains '..')
+      if /\.{2}(?:\/|\z)/.match?(full_name)
+        raise SecureRelativePathError, "Path contains '..'"
       end
 
       if entry.directory?
-        dest = File.join(destdir, full_name)
-
-        yield :dir, full_name, stats if block_given?
-
-        if Archive::Tar::Minitar.dir?(dest)
-          begin
-            FileUtils.chmod(entry.mode, dest)
-          rescue
-            nil
-          end
-        else
-          File.unlink(dest.chomp('/')) if File.symlink?(dest.chomp('/'))
-
-          FileUtils.mkdir_p(dest, :mode => entry.mode)
-          FileUtils.chmod(entry.mode, dest)
-        end
-
-        fsync_dir(dest)
-        fsync_dir(File.join(dest, '..'))
-        return
+        extract_directory(destdir, full_name, entry, stats, options, &block)
       else # it's a file
-        destdir = File.join(destdir, File.dirname(full_name))
-        FileUtils.mkdir_p(destdir, :mode => 0o755)
-
-        destfile = File.join(destdir, File.basename(full_name))
-
-        File.unlink(destfile) if File.symlink?(destfile)
-
-        # Errno::ENOENT
-        # rubocop:disable Style/RescueModifier
-        FileUtils.chmod(0o600, destfile) rescue nil
-        # rubocop:enable Style/RescueModifier
-
-        yield :file_start, full_name, stats if block_given?
-
-        File.open(destfile, 'wb', entry.mode) do |os|
-          loop do
-            data = entry.read(4096)
-            break unless data
-
-            stats[:currinc] = os.write(data)
-            stats[:current] += stats[:currinc]
-
-            yield :file_progress, full_name, stats if block_given?
-          end
-          os.fsync
-        end
-
-        FileUtils.chmod(entry.mode, destfile)
-        fsync_dir(File.dirname(destfile))
-        fsync_dir(File.join(File.dirname(destfile), '..'))
-
-        yield :file_done, full_name, stats if block_given?
+        extract_file(destdir, full_name, entry, stats, options, &block)
       end
     end
 
@@ -211,12 +164,80 @@ module Archive::Tar::Minitar
 
     def fsync_dir(dirname)
       # make sure this hits the disc
-      dir = open(dirname, 'rb')
+      dir = IO.open(dirname, "rb")
       dir.fsync
     rescue # ignore IOError if it's an unpatched (old) Ruby
       nil
     ensure
       dir.close if dir rescue nil # rubocop:disable Style/RescueModifier
     end
+
+    def extract_directory(destdir, full_name, entry, stats, options)
+      dest = File.join(destdir, full_name)
+
+      yield :dir, full_name, stats if block_given?
+
+      if Archive::Tar::Minitar.dir?(dest)
+        begin
+          FileUtils.chmod(entry.mode, dest)
+        rescue
+          nil
+        end
+      else
+        File.unlink(dest.chomp("/")) if File.symlink?(dest.chomp("/"))
+
+        FileUtils.mkdir_p(dest, :mode => entry.mode)
+        FileUtils.chmod(entry.mode, dest)
+      end
+
+      if options.fetch(:fsync, true)
+        fsync_dir(dest)
+        fsync_dir(File.join(dest, ".."))
+      end
+    end
+
+    def extract_file(destdir, full_name, entry, stats, options)
+      destdir = File.join(destdir, File.dirname(full_name))
+      FileUtils.mkdir_p(destdir, :mode => 0o755)
+
+      destfile = File.join(destdir, File.basename(full_name))
+
+      File.unlink(destfile) if File.symlink?(destfile)
+
+      # Errno::ENOENT
+      # rubocop:disable Style/RescueModifier
+      FileUtils.chmod(0o600, destfile) rescue nil
+      # rubocop:enable Style/RescueModifier
+
+      yield :file_start, full_name, stats if block_given?
+
+      File.open(destfile, "wb", entry.mode) do |os|
+        loop do
+          data = entry.read(4096)
+          break unless data
+
+          stats[:currinc] = os.write(data)
+          stats[:current] += stats[:currinc]
+
+          yield :file_progress, full_name, stats if block_given?
+        end
+
+        if options.fetch(:fsync, true)
+          yield :file_fsync, full_name, stats if block_given?
+          os.fsync
+        end
+      end
+
+      FileUtils.chmod(entry.mode, destfile)
+
+      if options.fetch(:fsync, true)
+        yield :dir_fsync, full_name, stats if block_given?
+
+        fsync_dir(File.dirname(destfile))
+        fsync_dir(File.join(File.dirname(destfile), ".."))
+      end
+
+      yield :file_done, full_name, stats if block_given?
+    end
   end
 end

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

@@ -1,6 +1,6 @@
 # coding: utf-8
 
-require 'archive/tar/minitar/writer'
+require "archive/tar/minitar/writer"
 
 module Archive::Tar::Minitar
   # Wraps a Archive::Tar::Minitar::Writer with convenience methods and wrapped
@@ -40,7 +40,7 @@ module Archive::Tar::Minitar
     def self.tar(output)
       return to_enum(__method__, output) unless block_given?
 
-      open(output) do |stream|
+      Output.open(output) do |stream|
         yield stream.tar
       end
     end
@@ -55,10 +55,10 @@ module Archive::Tar::Minitar
     #    Archive::Tar::Minitar::Output.new(path) -> output
     def initialize(output)
       @io = if output.respond_to?(:write)
-              output
-            else
-              ::Kernel.open(output, 'wb')
-            end
+        output
+      else
+        ::Kernel.open(output, "wb")
+      end
       @tar = Archive::Tar::Minitar::Writer.new(@io)
     end
 

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

@@ -2,8 +2,10 @@
 
 ##
 module Archive; end
+
 ##
 module Archive::Tar; end
+
 ##
 module Archive::Tar::Minitar; end
 
@@ -36,12 +38,12 @@ module Archive::Tar::Minitar; end
 # unrecognized typeflag value as a regular file."
 class Archive::Tar::Minitar::PosixHeader
   BLOCK_SIZE = 512
-  MAGIC_BYTES = 'ustar'.freeze
+  MAGIC_BYTES = "ustar".freeze
 
-  GNU_EXT_LONG_LINK = '././@LongLink'
+  GNU_EXT_LONG_LINK = "././@LongLink"
 
   # Fields that must be set in a POSIX tar(1) header.
-  REQUIRED_FIELDS = [ :name, :size, :prefix, :mode ].freeze
+  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,
@@ -60,9 +62,9 @@ class Archive::Tar::Minitar::PosixHeader
   attr_accessor :name
 
   # The pack format passed to Array#pack for encoding a header.
-  HEADER_PACK_FORMAT    = 'a100a8a8a8a12a12a7aaa100a6a2a32a32a8a8a155'.freeze
+  HEADER_PACK_FORMAT = "a100a8a8a8a12a12a7aaa100a6a2a32a32a8a8a155".freeze
   # The unpack format passed to String#unpack for decoding a header.
-  HEADER_UNPACK_FORMAT  = 'Z100A8A8A8A12A12A8aZ100A6A2Z32Z32A8A8Z155'.freeze
+  HEADER_UNPACK_FORMAT = "Z100A8A8A8A12A12A8aZ100A6A2Z32Z32A8A8Z155".freeze
 
   class << self
     # Creates a new PosixHeader from a data stream.
@@ -79,23 +81,23 @@ class Archive::Tar::Minitar::PosixHeader
 
     # 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
+      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?)
 
@@ -123,7 +125,7 @@ class Archive::Tar::Minitar::PosixHeader
     private
 
     def strict_oct(string)
-      return string.oct if string =~ /\A[0-7 ]*\z/
+      return string.oct if /\A[0-7 ]*\z/.match?(string)
       raise ArgumentError, "#{string.inspect} is not a valid octal string"
     end
   end
@@ -136,13 +138,13 @@ class Archive::Tar::Minitar::PosixHeader
     end
 
     v[:mtime] = v[:mtime].to_i
-    v[:checksum] ||= ''
-    v[:typeflag] ||= '0'
-    v[:magic]    ||= MAGIC_BYTES
-    v[:version]  ||= '00'
+    v[:checksum] ||= ""
+    v[:typeflag] ||= "0"
+    v[:magic] ||= MAGIC_BYTES
+    v[:version] ||= "00"
 
     FIELDS.each do |f|
-      instance_variable_set("@#{f}", v[f])
+      instance_variable_set(:"@#{f}", v[f])
     end
 
     @empty = v[:empty]
@@ -161,7 +163,7 @@ class Archive::Tar::Minitar::PosixHeader
   # 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
+    typeflag == "L" && name == GNU_EXT_LONG_LINK
   end
 
   # A string representation of the header.
@@ -169,11 +171,11 @@ class Archive::Tar::Minitar::PosixHeader
     update_checksum
     header(@checksum)
   end
-  alias to_str to_s
+  alias_method :to_str, :to_s
 
   # Update the checksum field.
   def update_checksum
-    hh = header(' ' * 8)
+    hh = header(" " * 8)
     @checksum = oct(calculate_checksum(hh), 6)
   end
 
@@ -190,13 +192,13 @@ class Archive::Tar::Minitar::PosixHeader
   end
 
   def calculate_checksum(hdr)
-    hdr.unpack('C*').inject { |a, e| a + e }
+    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]
+      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

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

@@ -11,14 +11,21 @@ module Archive::Tar::Minitar
     # This marks the EntryStream closed for reading without closing the
     # actual data stream.
     module InvalidEntryStream
-      # rubocop:disable Style/SingleLineMethods
-      # rubocop:disable Style/EmptyLineBetweenDefs
-      def read(*); raise ClosedStream; end
-      def getc; raise ClosedStream; end
-      def rewind; raise ClosedStream; end
-      def closed?; true; end
-      # rubocop:enable Style/EmptyLineBetweenDefs
-      # rubocop:enable Style/SingleLineMethods Style/EmptyLineBetweenDefs
+      def read(*)
+        raise ClosedStream
+      end
+
+      def getc
+        raise ClosedStream
+      end
+
+      def rewind
+        raise ClosedStream
+      end
+
+      def closed?
+        true
+      end
     end
 
     # EntryStreams are pseudo-streams on top of the main data stream.
@@ -30,24 +37,24 @@ module Archive::Tar::Minitar
       end
 
       def initialize(header, io)
-        @io       = io
-        @name     = header.name
-        @mode     = header.mode
-        @uid      = header.uid
-        @gid      = header.gid
-        @size     = header.size
-        @mtime    = header.mtime
+        @io = io
+        @name = header.name
+        @mode = header.mode
+        @uid = header.uid
+        @gid = header.gid
+        @size = header.size
+        @mtime = header.mtime
         @checksum = header.checksum
         @typeflag = header.typeflag
         @linkname = header.linkname
-        @magic    = header.magic
-        @version  = header.version
-        @uname    = header.uname
-        @gname    = header.gname
+        @magic = header.magic
+        @version = header.version
+        @uname = header.uname
+        @gname = header.gname
         @devmajor = header.devmajor
         @devminor = header.devminor
-        @prefix   = header.prefix
-        @read     = 0
+        @prefix = header.prefix
+        @read = 0
         @orig_pos =
           if Archive::Tar::Minitar.seekable?(@io)
             @io.pos
@@ -79,25 +86,25 @@ module Archive::Tar::Minitar
       # Returns +true+ if the entry represents a directory.
       def directory?
         case @typeflag
-        when '5'
+        when "5"
           true
-        when '0', "\0"
+        when "0", "\0"
           # If the name ends with a slash, treat it as a directory.
           # This is what other major tar implementations do for
           # interoperability and compatibility with older tar variants
           # and some new ones.
-          @name.end_with?('/')
+          @name.end_with?("/")
         else
           false
         end
       end
-      alias directory directory?
+      alias_method :directory, :directory?
 
       # Returns +true+ if the entry represents a plain file.
       def file?
-        (@typeflag == '0' || @typeflag == "\0") && !@name.end_with?('/')
+        (@typeflag == "0" || @typeflag == "\0") && !@name.end_with?("/")
       end
-      alias file file?
+      alias_method :file, :file?
 
       # Returns +true+ if the current read pointer is at the end of the
       # EntryStream data.
@@ -125,7 +132,7 @@ module Archive::Tar::Minitar
 
       # Returns the full and proper name of the entry.
       def full_name
-        if @prefix != ''
+        if @prefix != ""
           File.join(@prefix, @name)
         else
           @name
@@ -185,7 +192,7 @@ module Archive::Tar::Minitar
     def self.each_entry(io)
       return to_enum(__method__, io) unless block_given?
 
-      open(io) do |reader|
+      Input.open(io) do |reader|
         reader.each_entry do |entry|
           yield entry
         end
@@ -195,7 +202,11 @@ module Archive::Tar::Minitar
     # Creates and returns a new Reader object.
     def initialize(io)
       @io = io
-      @init_pos = io.pos rescue nil
+      @init_pos = begin
+        io.pos
+      rescue
+        nil
+      end
     end
 
     # Resets the read pointer to the beginning of data stream. Do not call
@@ -229,14 +240,17 @@ module Archive::Tar::Minitar
         raise Archive::Tar::Minitar::InvalidTarStream if header.size < 0
 
         if header.long_name?
-          name = @io.read(512).rstrip
+          name_block = (header.size / 512.0).ceil * 512
+
+          name = @io.read(name_block).rstrip
           header = PosixHeader.from_stream(@io)
+
           return if header.empty?
           header.name = name
         end
 
         entry = EntryStream.new(header, @io)
-        size  = entry.size
+        size = entry.size
 
         yield entry
 
@@ -259,7 +273,7 @@ module Archive::Tar::Minitar
         entry.close
       end
     end
-    alias each each_entry
+    alias_method :each, :each_entry
 
     # Returns false if the reader is open (it never closes).
     def closed?