minitar 0.7 → 0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fe4dcb6889d7dd3e767dc3329f8e874d4359577f219b0a76df859617a253c4fb
-  data.tar.gz: 345a765b717201d0a47dbb4d52572d68d51797fb41f7df0f314e9a43b160e6de
+  metadata.gz: 1440e1c57cdd811497e6717a6f81791816bfb2ec5dce0981d9208c41bcd6f09d
+  data.tar.gz: e36cf70bd9acc32d73c95a48c1e67f494853f47603032cac05a84bd366417655
 SHA512:
-  metadata.gz: faf3628dd94d2a9f85c86a7662b8699911d022d5b7e75ea2f41effd6fd896252721e953203796cd99739f7c9e756066250d78e613ee606271d79c36753836df2
-  data.tar.gz: b0311f7166e41805adce3709c53a0acda7dcfe5b732abb16d278706b5e54b56cb2477e3e51bc0bf8d5f6143e61421fd11860a3e1fca22c57ea405f751fa8b369
+  metadata.gz: b615673d6e6626606e6e858d453af056870f4b8c88dade5641595b35733491e6dfe2ec32e90d28f7585308a4229f2ace63b47224c0b2877b44c5b028ee3c1031
+  data.tar.gz: ea2adda3fdcf9314c325cfa69f7ae5bbf6bc02732c8b131acef7406c45c4c53906a5612940fdc6d026d2fcda809b3a095abbe90bcf96a19f4082a653dcf8cbc3

data/Contributing.md

@@ -82,6 +82,8 @@ Thanks to everyone who has contributed to minitar:
 *   Kazuyoshi Kato
 *   dearblue
 *   Kevin McDermott
+*   inkstak
+*   Akinori MUSHA (knu)
 
 [Minitest]: https://github.com/seattlerb/minitest
 [quality commit messages]: http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html

data/History.md

@@ -1,3 +1,18 @@
+## 0.8 / 2019-01-05
+
+*   inkstak resolved an issue introduced in the fix for [#31][] by allowing
+    spaces to be considered valid characters in strict octal handling. Octal
+    conversion ignores leading spaces. Merged from a slightly modified version
+    of PR [#35][].
+
+*   dearblue contributed PR [#32][] providing an explicit call to #bytesize for
+    strings that include multibyte characters. The PR has been modified to be
+    compatible with older versions of Ruby and extend tests.
+
+*   Akinori MUSHA (knu) contributed PR [#36][] that treats certain badly
+    encoded regular files (with names ending in `/`) as if they were
+    directories on decode.
+
 ## 0.7 / 2018-02-19
 
 *   Fixed issue [#28][] with a modified version of PR [#29][] covering the
@@ -142,4 +157,7 @@
 [#28]: https://github.com/halostatue/minitar/issues/28
 [#29]: https://github.com/halostatue/minitar/issues/29
 [#30]: https://github.com/halostatue/minitar/issues/30
+[#32]: https://github.com/halostatue/minitar/issues/32
 [#33]: https://github.com/halostatue/minitar/issues/33
+[#35]: https://github.com/halostatue/minitar/issues/35
+[#36]: https://github.com/halostatue/minitar/issues/36

data/lib/archive/tar/minitar.rb

@@ -73,7 +73,7 @@ end
 #       tar.close
 #     end
 module Archive::Tar::Minitar
-  VERSION = '0.7'.freeze # :nodoc:
+  VERSION = '0.8'.freeze # :nodoc:
 
   # The base class for any minitar error.
   Error = Class.new(::StandardError)
@@ -279,7 +279,7 @@ module Archive::Tar::Minitar
 
     def included(mod)
       return if modules.include?(mod)
-      warn "Including #{self} has been deprecated."
+      warn "Including #{self} has been deprecated (Minitar will become a class)."
       modules << mod
     end
 
@@ -288,6 +288,21 @@ module Archive::Tar::Minitar
       @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'

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

@@ -123,7 +123,7 @@ class Archive::Tar::Minitar::PosixHeader
     private
 
     def strict_oct(string)
-      return string.oct if string =~ /\A[0-7]*\z/
+      return string.oct if string =~ /\A[0-7 ]*\z/
       raise ArgumentError, "#{string.inspect} is not a valid octal string"
     end
   end
@@ -179,6 +179,8 @@ class Archive::Tar::Minitar::PosixHeader
 
   private
 
+  include Archive::Tar::Minitar::ByteSize
+
   def oct(num, len)
     if num.nil?
       "\0" * (len + 1)
@@ -196,7 +198,7 @@ class Archive::Tar::Minitar::PosixHeader
            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 - str.size) % BLOCK_SIZE)
+    str + "\0" * ((BLOCK_SIZE - bytesize(str)) % BLOCK_SIZE)
   end
 
   ##

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

@@ -6,6 +6,8 @@ module Archive::Tar::Minitar
   # with random access data streams.
   class Reader
     include Enumerable
+    include Archive::Tar::Minitar::ByteSize
+
     # This marks the EntryStream closed for reading without closing the
     # actual data stream.
     module InvalidEntryStream
@@ -21,6 +23,8 @@ module Archive::Tar::Minitar
 
     # EntryStreams are pseudo-streams on top of the main data stream.
     class EntryStream
+      include Archive::Tar::Minitar::ByteSize
+
       Archive::Tar::Minitar::PosixHeader::FIELDS.each do |field|
         attr_reader field.to_sym
       end
@@ -59,7 +63,7 @@ module Archive::Tar::Minitar
         len ||= @size - @read
         max_read = [len, @size - @read].min
         ret = @io.read(max_read)
-        @read += ret.size
+        @read += bytesize(ret)
         ret
       end
 
@@ -74,13 +78,24 @@ module Archive::Tar::Minitar
 
       # Returns +true+ if the entry represents a directory.
       def directory?
-        @typeflag == '5'
+        case @typeflag
+        when '5'
+          true
+        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?('/')
+        else
+          false
+        end
       end
       alias directory directory?
 
       # Returns +true+ if the entry represents a plain file.
       def file?
-        @typeflag == '0' || @typeflag == "\0"
+        (@typeflag == '0' || @typeflag == "\0") && !@name.end_with?('/')
       end
       alias file file?
 
@@ -233,7 +248,7 @@ module Archive::Tar::Minitar
         else
           pending = size - entry.bytes_read
           while pending > 0
-            bread = @io.read([pending, 4096].min).size
+            bread = bytesize(@io.read([pending, 4096].min))
             raise UnexpectedEOF if @io.eof?
             pending -= bread
           end

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

@@ -3,6 +3,8 @@
 module Archive::Tar::Minitar
   # The class that writes a tar format archive to a data stream.
   class Writer
+    include Archive::Tar::Minitar::ByteSize
+
     # The exception raised when the user attempts to write more data to a
     # BoundedWriteStream than has been allocated.
     WriteBoundaryOverflow = Class.new(StandardError)
@@ -23,6 +25,8 @@ module Archive::Tar::Minitar
 
     # A WriteOnlyStream that also has a size limit.
     class BoundedWriteStream < WriteOnlyStream
+      include Archive::Tar::Minitar::ByteSize
+
       def self.const_missing(c)
         case c
         when :FileOverflow
@@ -48,10 +52,11 @@ module Archive::Tar::Minitar
       end
 
       def write(data)
-        raise WriteBoundaryOverflow if (data.size + @written) > @limit
+        size = bytesize(data)
+        raise WriteBoundaryOverflow if (size + @written) > @limit
         @io.write(data)
-        @written += data.size
-        data.size
+        @written += size
+        size
       end
     end
 
@@ -153,23 +158,24 @@ module Archive::Tar::Minitar
       else
         raise ArgumentError, 'No data provided' unless data
 
-        size = data.size if size < data.size
+        bytes = bytesize(data)
+        size = bytes if size.nil? || size < bytes
       end
 
       header[:size] = size
 
       write_header(name, header)
 
-      os = BoundedWriteStream.new(@io, opts[:size])
+      os = BoundedWriteStream.new(@io, size)
       if block_given?
         yield os
       else
         os.write(data)
       end
 
-      min_padding = opts[:size] - os.written
+      min_padding = size - os.written
       @io.write("\0" * min_padding)
-      remainder = (512 - (opts[:size] % 512)) % 512
+      remainder = (512 - (size % 512)) % 512
       @io.write("\0" * remainder)
     end
 
@@ -286,7 +292,7 @@ module Archive::Tar::Minitar
     end
 
     def split_name(name)
-      if name.size <= 100
+      if bytesize(name) <= 100
         prefix = ''
       else
         parts = name.split(/\//)
@@ -296,7 +302,7 @@ module Archive::Tar::Minitar
 
         loop do
           nxt = parts.pop || ''
-          break if newname.size + 1 + nxt.size >= 100
+          break if bytesize(newname) + 1 + bytesize(nxt) >= 100
           newname = "#{nxt}/#{newname}"
         end
 
@@ -305,7 +311,7 @@ module Archive::Tar::Minitar
         name = newname
       end
 
-      [ name, prefix, (name.size > 100 || prefix.size > 155) ]
+      [ name, prefix, (bytesize(name) > 100 || bytesize(prefix) > 155) ]
     end
   end
 end

data/lib/minitar.rb

@@ -2,7 +2,7 @@
 
 require 'archive/tar/minitar'
 
-if defined? ::Minitar
+if defined?(::Minitar) && ::Minitar != Archive::Tar::Minitar
   warn <<-EOS
 ::Minitar is already defined.
 This will conflict with future versions of minitar.

data/test/support/tar_test_helpers.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module TarTestHelpers
+  include Archive::Tar::Minitar::ByteSize
+
   Field = Struct.new(:name, :offset, :length)
   def self.Field(name, length) # rubocop:disable Style/MethodName
     @offset ||= 0
@@ -72,15 +74,25 @@ module TarTestHelpers
   end
 
   def header(type, fname, dname, length, mode)
+    raw_header(type,
+      asciiz(fname, 100),
+      asciiz(dname, 155),
+      z(to_oct(length, 11)),
+      z(to_oct(mode, 7))
+    )
+  end
+
+  def raw_header(type, fname, dname, length, mode)
     arr = [
-      asciiz(fname, 100), z(to_oct(mode, 7)), z(to_oct(nil, 7)),
-      z(to_oct(nil, 7)), z(to_oct(length, 11)), z(to_oct(0, 11)),
-      BLANK_CHECKSUM, type, NULL_100, USTAR, DOUBLE_ZERO, asciiz('', 32),
-      asciiz('', 32), z(to_oct(nil, 7)), z(to_oct(nil, 7)), asciiz(dname, 155)
+      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),
+      z(to_oct(nil, 7)), z(to_oct(nil, 7)), dname
     ]
+
     h = arr.join.bytes.to_a.pack('C100C8C8C8C12C12C8CC100C6C2C32C32C8C8C155')
-    ret = h + "\0" * (512 - h.size)
-    assert_equal(512, ret.size)
+    ret = h + "\0" * (512 - bytesize(h))
+    assert_equal(512, bytesize(ret))
     ret
   end
 
@@ -100,7 +112,7 @@ module TarTestHelpers
   end
 
   def asciiz(str, length)
-    str + "\0" * (length - str.length)
+    str + "\0" * (length - bytesize(str))
   end
 
   def sp(s)

data/test/test_tar_header.rb

@@ -80,6 +80,30 @@ class TestTarHeader < Minitest::Test
     assert(h.valid?)
   end
 
+  def test_from_stream_with_no_strict_octal
+    header = tar_file_header('a' * 100, '', 0o12345, -1213)
+    io     = StringIO.new(header)
+
+    assert_raises(ArgumentError) do
+      Archive::Tar::Minitar::PosixHeader.from_stream(io)
+    end
+  end
+
+  def test_from_stream_with_octal_wrapped_by_spaces
+    header = raw_header(0,
+      asciiz('a' * 100, 100),
+      asciiz('', 155),
+      "       1213\0",
+      z(to_oct(0o12345, 7))
+    )
+
+    header = update_checksum(header)
+    io     = StringIO.new(header)
+    header = Archive::Tar::Minitar::PosixHeader.from_stream(io)
+
+    assert_equal(651, header.size)
+  end
+
   def test_valid_with_invalid_header
     header = StringIO.new("testing")
     h = Archive::Tar::Minitar::PosixHeader.from_stream header

data/test/test_tar_input.rb

@@ -173,4 +173,47 @@ MDUzVDAwNDY0N2VQMGCgAygtLkksAjolEcjIzMOtDqgsLQ2/J0H+gNOjYBSMglEwyAEA2LchrwAGAAA=
       end
     end
   end
+
+  NON_STRICT_OCTAL_TGZ = Base64.decode64(<<-EOS).freeze
+H4sIAEk55FsAA0tJLEnUK0ks0kuvYqAVMDAwMDMxUQDR5mbmYNrACMjX0zMH
+AzMDUwUDIG1iZmZoYmCgYGBobGpuxqBgQDMXIYHSYqDvgU5KBDIy83CrAypL
+S8NjjgEYKMDpIQLkuzkYZmdOC2Fgfnv5PleTgcjxwvXVXbaOZ3fa61/6KzHD
+pENvy739mUkiKiJnJuyTbzEOuHPxvp+sXmL4E9WlJcc6FkaZh6z8srevpeRc
+Zrb33fXeS3u1Wk7euf7gVqzT7CjOTMHz7+d795uePVN97P2MV15Xav/du77x
+q911yx829XPfTf4v1PZndoXVlJ/fPP4fzrKdvL/q7P5VazRbzly/dHj+8/32
+x/yWrLZnWnQnr+4u/zTTs/tPbT8e/jl/5n9Vm7P7k/4xwr2RsDZv7c+eGgaN
+AQzKIQnSMnNSjWlsByjfm5pi5n8DGDAyQsv/RiZmxqP5nx4gJCOzWAGIQOlA
+wVhPgZdroF00CkbBKBgFo2AUjIJRMApGwSgYBaNgFIyCUTAKRsEoGAWjYBSM
+glEwCkbBKBgFo2AUjIJRMApIAQD0DyzXACgAAA==
+  EOS
+
+  def test_extract_with_non_strict_octal
+    reader = Zlib::GzipReader.new(StringIO.new(NON_STRICT_OCTAL_TGZ))
+
+    assert_raises(ArgumentError) do
+      Minitar.unpack(reader, 'data__')
+    end
+  end
+
+  OCTAL_WRAPPED_BY_SPACE_TGZ = Base64.decode64(<<-EOS).freeze
+H4sIAOQg5FsAA0tJLEnUK0ks0kuvYqAVMDAwMDMxUQDR5mbmYNrACMhXgAJj
+IyMFA3NzcxMzM0MTAwMFA0NjU3MzBgUDmrkICZQWA30PdFIikJGZh1sdUFla
+Gh5zDMBAAU4PESDfzcEwO3NaCAPz28v3uZoMRI4Xrq/usnU8u9Ne/9JfiRkm
+HXpb7u3PTBJRETkzYZ98i3HAnYv3/WT1EsOfqC4tOdaxMMo8ZOWXvX0tJecy
+s73vrvde2qvVcvLO9Qe3Yp1mR3FmCp5/P9+73/Tsmepj72e88rpS++/e9Y1f
+7a5b/rCpn/tu8n+htj+zK6ym/Pzm8f9wlu3k/VVn969ao9ly5vqlw/Of77c/
+5rdktT3Tojt5dXf5p5me3X9q+/Hwz/kz/6vanN2f9I8R7o2EtXlrf/bUMGgM
+YFAOSZCWmZNqTGM7QPne1BQz/xvAAEb+NzIxMx7N//QAIRmZxQpABEoHCsZ6
+CrxcA+2iUTAKRsEoGAWjYBSMglEwCkbBKBgFo2AUjIJRMApGwSgYBaNgFIyC
+UTAKRsEoGAWjYBSMglFACgAAuUHUvwAoAAA=
+  EOS
+
+  def test_extract_octal_wrapped_by_space
+    reader = Zlib::GzipReader.new(StringIO.new(OCTAL_WRAPPED_BY_SPACE_TGZ))
+    header = Archive::Tar::Minitar::PosixHeader.from_stream(reader)
+    assert_equal(210, header.size)
+
+    reader = Zlib::GzipReader.new(StringIO.new(OCTAL_WRAPPED_BY_SPACE_TGZ))
+    Minitar.unpack(reader, 'data__', [])
+  end
 end

data/test/test_tar_reader.rb

@@ -4,6 +4,8 @@ require 'minitar'
 require 'minitest_helper'
 
 class TestTarReader < Minitest::Test
+  include Archive::Tar::Minitar::ByteSize
+
   def test_open_no_block
     str = tar_file_header('lib/foo', '', 0o10644, 10) + "\0" * 512
     str += tar_file_header('bar', 'baz', 0o644, 0)
@@ -21,13 +23,14 @@ class TestTarReader < Minitest::Test
     str = tar_file_header('lib/foo', '', 0o10644, 10) + "\0" * 512
     str += tar_file_header('bar', 'baz', 0o644, 0)
     str += tar_dir_header('foo', 'bar', 0o12345)
+    str += tar_file_header('src/', '', 0o755, 0) # "file" with a trailing slash
     str += "\0" * 1024
-    names = %w(lib/foo bar foo)
-    prefixes = ['', 'baz', 'bar']
-    modes = [0o10644, 0o644, 0o12345]
-    sizes = [10, 0, 0]
-    isdir = [false, false, true]
-    isfile = [true, true, false]
+    names = %w(lib/foo bar foo src/)
+    prefixes = ['', 'baz', 'bar', '']
+    modes = [0o10644, 0o644, 0o12345, 0o755]
+    sizes = [10, 0, 0, 0]
+    isdir = [false, false, true, true]
+    isfile = [true, true, false, false]
     Minitar::Reader.new(StringIO.new(str)) do |is|
       i = 0
       is.each_entry do |entry|
@@ -51,15 +54,15 @@ class TestTarReader < Minitest::Test
 
   def test_rewind_entry_works
     content = ('a'..'z').to_a.join(' ')
-    str = tar_file_header('lib/foo', '', 0o10644, content.size) + content +
-      "\0" * (512 - content.size)
+    str = tar_file_header('lib/foo', '', 0o10644, bytesize(content)) +
+      content + "\0" * (512 - bytesize(content))
     str << "\0" * 1024
     Minitar::Reader.new(StringIO.new(str)) do |is|
       is.each_entry do |entry|
         3.times do
           entry.rewind
           assert_equal(content, entry.read)
-          assert_equal(content.size, entry.pos)
+          assert_equal(bytesize(content), entry.pos)
         end
       end
     end
@@ -67,8 +70,8 @@ class TestTarReader < Minitest::Test
 
   def test_rewind_works
     content = ('a'..'z').to_a.join(' ')
-    str = tar_file_header('lib/foo', '', 0o10644, content.size) + content +
-      "\0" * (512 - content.size)
+    str = tar_file_header('lib/foo', '', 0o10644, bytesize(content)) +
+      content + "\0" * (512 - bytesize(content))
     str << "\0" * 1024
     Minitar::Reader.new(StringIO.new(str)) do |is|
       3.times do
@@ -85,12 +88,12 @@ class TestTarReader < Minitest::Test
 
   def test_read_works
     contents = ('a'..'z').inject('') { |a, e| a << e * 100 }
-    str = tar_file_header('lib/foo', '', 0o10644, contents.size) + contents
-    str += "\0" * (512 - (str.size % 512))
+    str = tar_file_header('lib/foo', '', 0o10644, bytesize(contents)) + contents
+    str += "\0" * (512 - (bytesize(str) % 512))
     Minitar::Reader.new(StringIO.new(str)) do |is|
       is.each_entry do |entry|
         assert_kind_of(Minitar::Reader::EntryStream, entry)
-        data = entry.read(3000) # bigger than contents.size
+        data = entry.read(3000) # bigger than bytesize(contents)
         assert_equal(contents, data)
         assert_equal(true, entry.eof?)
       end
@@ -99,7 +102,7 @@ class TestTarReader < Minitest::Test
       is.each_entry do |entry|
         assert_kind_of(Minitar::Reader::EntryStream, entry)
         data = entry.read(100)
-        (entry.size - data.size).times { data << entry.getc.chr }
+        (entry.size - bytesize(data)).times { data << entry.getc.chr }
         assert_equal(contents, data)
         assert_equal(nil, entry.read(10))
         assert_equal(true, entry.eof?)

data/test/test_tar_writer.rb

@@ -4,11 +4,15 @@ require 'minitar'
 require 'minitest_helper'
 
 class TestTarWriter < Minitest::Test
+  include Archive::Tar::Minitar::ByteSize
+
   class DummyIO
+    include Archive::Tar::Minitar::ByteSize
+
     attr_reader :data
 
     def initialize
-      @data = ''
+      reset
     end
 
     def write(dat)
@@ -18,11 +22,14 @@ class TestTarWriter < Minitest::Test
 
     def reset
       @data = ''
+      @data.force_encoding('ascii-8bit') if @data.respond_to?(:force_encoding)
     end
   end
 
   def setup
     @data = 'a' * 10
+    @unicode = [0xc3.chr, 0xa5.chr].join * 10
+    @unicode.force_encoding('utf-8') if @unicode.respond_to?(:force_encoding)
     @dummyos = DummyIO.new
     @os = Minitar::Writer.new(@dummyos)
   end
@@ -146,12 +153,12 @@ class TestTarWriter < Minitest::Test
     offset = 512 * 2
     [content1, content2, ''].each do |data|
       assert_headers_equal(tar_file_header('lib/bar/baz', '', 0o644,
-        data.size), dummyos[offset, 512])
+        bytesize(data)), dummyos[offset, 512])
       offset += 512
       until !data || data == ''
         chunk = data[0, 512]
         data[0, 512] = ''
-        assert_equal(chunk + "\0" * (512 - chunk.size),
+        assert_equal(chunk + "\0" * (512 - bytesize(chunk)),
           dummyos[offset, 512])
         offset += 512
       end
@@ -186,7 +193,26 @@ class TestTarWriter < Minitest::Test
       f.write @data
     end
     @os.flush
-    assert_equal(@data + ("\0" * (512 - @data.size)),
+    assert_equal(@data + ("\0" * (512 - bytesize(@data))),
+      @dummyos.data[512, 512])
+  end
+
+  def test_write_unicode_data
+    @dummyos.reset
+
+    if @unicode.respond_to?(:bytesize)
+      assert_equal 10, @unicode.size
+      assert_equal 20, @unicode.bytesize
+      @unicode.force_encoding('ascii-8bit')
+    end
+
+    file = ['lib/foo/b', 0xc3.chr, 0xa5.chr, 'r'].join
+
+    @os.add_file_simple(file, :mode => 0o644, :size => 20) do |f|
+      f.write @unicode
+    end
+    @os.flush
+    assert_equal(@unicode + ("\0" * (512 - bytesize(@unicode))),
       @dummyos.data[512, 512])
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: minitar
 version: !ruby/object:Gem::Version
-  version: '0.7'
+  version: '0.8'
 platform: ruby
 authors:
 - Austin Ziegler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-28 00:00:00.000000000 Z
+date: 2019-01-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest