minitar 0.9 → 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
@@ -51,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
@@ -71,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
@@ -96,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
@@ -119,9 +119,9 @@ module Archive::Tar::Minitar
     #                     Reader::EntryStream, with all methods thereof.
     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
@@ -133,10 +133,10 @@ 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?
@@ -164,7 +164,7 @@ 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
@@ -184,7 +184,7 @@ module Archive::Tar::Minitar
           nil
         end
       else
-        File.unlink(dest.chomp('/')) if File.symlink?(dest.chomp('/'))
+        File.unlink(dest.chomp("/")) if File.symlink?(dest.chomp("/"))
 
         FileUtils.mkdir_p(dest, :mode => entry.mode)
         FileUtils.chmod(entry.mode, dest)
@@ -192,7 +192,7 @@ module Archive::Tar::Minitar
 
       if options.fetch(:fsync, true)
         fsync_dir(dest)
-        fsync_dir(File.join(dest, '..'))
+        fsync_dir(File.join(dest, ".."))
       end
     end
 
@@ -211,7 +211,7 @@ module Archive::Tar::Minitar
 
       yield :file_start, full_name, stats if block_given?
 
-      File.open(destfile, 'wb', entry.mode) do |os|
+      File.open(destfile, "wb", entry.mode) do |os|
         loop do
           data = entry.read(4096)
           break unless data
@@ -234,7 +234,7 @@ module Archive::Tar::Minitar
         yield :dir_fsync, full_name, stats if block_given?
 
         fsync_dir(File.dirname(destfile))
-        fsync_dir(File.join(File.dirname(destfile), '..'))
+        fsync_dir(File.join(File.dirname(destfile), ".."))
       end
 
       yield :file_done, full_name, stats if block_given?

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?

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

@@ -30,8 +30,8 @@ module Archive::Tar::Minitar
       def self.const_missing(c)
         case c
         when :FileOverflow
-          warn 'Writer::BoundedWriteStream::FileOverflow has been renamed ' \
-            'to Writer::WriteBoundaryOverflow'
+          warn "Writer::BoundedWriteStream::FileOverflow has been renamed " \
+            "to Writer::WriteBoundaryOverflow"
           const_set :FileOverflow,
             Archive::Tar::Minitar::Writer::WriteBoundaryOverflow
         else
@@ -46,9 +46,9 @@ module Archive::Tar::Minitar
       attr_reader :written
 
       def initialize(io, limit)
-        @io       = io
-        @limit    = limit
-        @written  = 0
+        @io = io
+        @limit = limit
+        @written = 0
       end
 
       def write(data)
@@ -65,7 +65,7 @@ module Archive::Tar::Minitar
     def self.const_missing(c)
       case c
       when :BoundedStream
-        warn 'BoundedStream has been renamed to BoundedWriteStream'
+        warn "BoundedStream has been renamed to BoundedWriteStream"
         const_set(:BoundedStream, BoundedWriteStream)
       else
         super
@@ -101,7 +101,7 @@ module Archive::Tar::Minitar
 
     # Creates and returns a new Writer object.
     def initialize(io)
-      @io     = io
+      @io = io
       @closed = false
     end
 
@@ -139,10 +139,10 @@ module Archive::Tar::Minitar
       raise ClosedStream if @closed
 
       header = {
-        :mode   => opts.fetch(:mode, 0o644),
-        :mtime  => opts.fetch(:mtime, nil),
-        :gid    => opts.fetch(:gid, nil),
-        :uid    => opts.fetch(:uid, nil)
+        :mode => opts.fetch(:mode, 0o644),
+        :mtime => opts.fetch(:mtime, nil),
+        :gid => opts.fetch(:gid, nil),
+        :uid => opts.fetch(:uid, nil)
       }
 
       data = opts.fetch(:data, nil)
@@ -151,12 +151,12 @@ module Archive::Tar::Minitar
       if block_given?
         if data
           raise ArgumentError,
-            'Too much data (opts[:data] and block_given?).'
+            "Too much data (opts[:data] and block_given?)."
         end
 
-        raise ArgumentError, 'No size provided' unless size
+        raise ArgumentError, "No size provided" unless size
       else
-        raise ArgumentError, 'No data provided' unless data
+        raise ArgumentError, "No data provided" unless data
 
         bytes = bytesize(data)
         size = bytes if size.nil? || size < bytes
@@ -164,7 +164,8 @@ module Archive::Tar::Minitar
 
       header[:size] = size
 
-      write_header(name, header)
+      short_name, prefix, needs_long_name = split_name(name)
+      write_header(header, name, short_name, prefix, needs_long_name)
 
       os = BoundedWriteStream.new(@io, size)
       if block_given?
@@ -211,12 +212,15 @@ module Archive::Tar::Minitar
         raise Archive::Tar::Minitar::NonSeekableStream
       end
 
+      short_name, prefix, needs_long_name = split_name(name)
+
+      data_offset = needs_long_name ? 3 * 512 : 512
       init_pos = @io.pos
-      @io.write("\0" * 512) # placeholder for the header
+      @io.write("\0" * data_offset) # placeholder for the header
 
       yield WriteOnlyStream.new(@io), opts
 
-      size      = @io.pos - (init_pos + 512)
+      size = @io.pos - (init_pos + data_offset)
       remainder = (512 - (size % 512)) % 512
       @io.write("\0" * remainder)
 
@@ -227,9 +231,11 @@ module Archive::Tar::Minitar
         :mtime => opts[:mtime],
         :size => size,
         :gid => opts[:gid],
-        :uid => opts[:uid],
+        :uid => opts[:uid]
       }
-      write_header(name, header)
+
+      write_header(header, name, short_name, prefix, needs_long_name)
+
       @io.pos = final_pos
     end
 
@@ -239,13 +245,38 @@ module Archive::Tar::Minitar
 
       header = {
         :mode => opts[:mode],
-        :typeflag => '5',
+        :typeflag => "5",
+        :size => 0,
+        :gid => opts[:gid],
+        :uid => opts[:uid],
+        :mtime => opts[:mtime]
+      }
+
+      short_name, prefix, needs_long_name = split_name(name)
+      write_header(header, name, short_name, prefix, needs_long_name)
+
+      nil
+    end
+
+    # 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)
+      header = {
+        :name => name,
+        :mode => opts[:mode],
+        :typeflag => "2",
         :size => 0,
+        :linkname => link_target,
         :gid => opts[:gid],
         :uid => opts[:uid],
         :mtime => opts[:mtime],
+        :prefix => prefix
       }
-      write_header(name, header)
+      @io.write(PosixHeader.new(header))
       nil
     end
 
@@ -271,47 +302,45 @@ module Archive::Tar::Minitar
 
     private
 
-    def write_header(long_name, header)
-      short_name, prefix, needs_long_name = split_name(long_name)
-
+    def write_header(header, long_name, short_name, prefix, needs_long_name)
       if needs_long_name
         long_name_header = {
-          :prefix => '',
+          :prefix => "",
           :name => PosixHeader::GNU_EXT_LONG_LINK,
-          :typeflag => 'L',
-          :size => long_name.length,
-          :mode => 0,
+          :typeflag => "L",
+          :size => long_name.length + 1,
+          :mode => 0
         }
         @io.write(PosixHeader.new(long_name_header))
         @io.write(long_name)
         @io.write("\0" * (512 - (long_name.length % 512)))
       end
 
-      new_header = header.merge({ :name => short_name, :prefix => prefix })
+      new_header = header.merge({:name => short_name, :prefix => prefix})
       @io.write(PosixHeader.new(new_header))
     end
 
     def split_name(name)
       if bytesize(name) <= 100
-        prefix = ''
+        prefix = ""
       else
-        parts = name.split(/\//)
+        parts = name.split("/")
         newname = parts.pop
 
-        nxt = ''
+        nxt = ""
 
         loop do
-          nxt = parts.pop || ''
+          nxt = parts.pop || ""
           break if bytesize(newname) + 1 + bytesize(nxt) >= 100
           newname = "#{nxt}/#{newname}"
         end
 
-        prefix = (parts + [nxt]).join('/')
+        prefix = (parts + [nxt]).join("/")
 
         name = newname
       end
 
-      [ name, prefix, (bytesize(name) > 100 || bytesize(prefix) > 155) ]
+      [name, prefix, bytesize(name) > 100 || bytesize(prefix) > 155]
     end
   end
 end