minitar 0.8 → 0.12

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)

data/test/test_tar_input.rb

@@ -1,9 +1,9 @@
 #!/usr/bin/env ruby
 
-require 'minitar'
-require 'minitest_helper'
-require 'base64'
-require 'zlib'
+require "minitar"
+require "minitest_helper"
+require "base64"
+require "zlib"
 
 class TestTarInput < Minitest::Test
   TEST_TGZ = Base64.decode64(<<-EOS).freeze
@@ -19,23 +19,23 @@ UTAKRsEoGAWjYBSMglEwCkbBKBgFo2AUjIJRMApGwSgYBaNgFIwCUgAAGnyo6wAoAAA=
   FILETIMES = Time.utc(2004).to_i
 
   TEST_CONTENTS = {
-    'data.tar.gz' => { :size => 210, :mode => 0o644 },
-    'file3' => { :size => 18, :mode => 0o755 }
+    "data.tar.gz" => {:size => 210, :mode => 0o644},
+    "file3" => {:size => 18, :mode => 0o755}
   }.freeze
 
   TEST_DATA_CONTENTS = {
-    'data/' => { :size => 0, :mode => 0o755 },
-    'data/__dir__/' => { :size => 0, :mode => 0o755 },
-    'data/file1' => { :size => 16, :mode => 0o644 },
-    'data/file2' => { :size => 16, :mode => 0o644 }
+    "data/" => {:size => 0, :mode => 0o755},
+    "data/__dir__/" => {:size => 0, :mode => 0o755},
+    "data/file1" => {:size => 16, :mode => 0o644},
+    "data/file2" => {:size => 16, :mode => 0o644}
   }.freeze
 
   def setup
-    FileUtils.mkdir_p('data__')
+    FileUtils.mkdir_p("data__")
   end
 
   def teardown
-    FileUtils.rm_rf('data__')
+    FileUtils.rm_rf("data__")
   end
 
   def test_open_no_block
@@ -58,7 +58,7 @@ UTAKRsEoGAWjYBSMglEwCkbBKBgFo2AUjIJRMApGwSgYBaNgFIwCUgAAGnyo6wAoAAA=
         assert_equal(TEST_CONTENTS[entry.name][:size], entry.size, entry.name)
         assert_modes_equal(TEST_CONTENTS[entry.name][:mode],
           entry.mode, entry.name)
-        assert_equal(FILETIMES, entry.mtime, 'entry.mtime')
+        assert_equal(FILETIMES, entry.mtime, "entry.mtime")
 
         if i.zero?
           data_reader = Zlib::GzipReader.new(StringIO.new(entry.read))
@@ -90,8 +90,8 @@ UTAKRsEoGAWjYBSMglEwCkbBKBgFo2AUjIJRMApGwSgYBaNgFIwCUgAAGnyo6wAoAAA=
     Minitar::Input.open(reader) do |stream|
       outer_count = 0
       stream.each_with_index do |entry, i|
-        stream.extract_entry('data__', entry)
-        name = File.join('data__', entry.name)
+        stream.extract_entry("data__", entry)
+        name = File.join("data__", entry.name)
 
         assert TEST_CONTENTS.key?(entry.name)
 
@@ -108,12 +108,12 @@ UTAKRsEoGAWjYBSMglEwCkbBKBgFo2AUjIJRMApGwSgYBaNgFIwCUgAAGnyo6wAoAAA=
 
         if i.zero?
           begin
-            ff = File.open(name, 'rb')
+            ff = File.open(name, "rb")
             data_reader = Zlib::GzipReader.new(ff)
             Minitar::Input.open(data_reader) do |is2|
               is2.each_with_index do |entry2, _j|
-                is2.extract_entry('data__', entry2)
-                name2 = File.join('data__', entry2.name)
+                is2.extract_entry("data__", entry2)
+                name2 = File.join("data__", entry2.name)
 
                 assert TEST_DATA_CONTENTS.key?(entry2.name)
 
@@ -144,18 +144,18 @@ UTAKRsEoGAWjYBSMglEwCkbBKBgFo2AUjIJRMApGwSgYBaNgFIwCUgAAGnyo6wAoAAA=
     return if Minitar.windows?
 
     IO.respond_to?(:write) &&
-      IO.write('data__/file4', '') ||
-      File.open('data__/file4', 'w') { |f| f.write '' }
+      IO.write("data__/file4", "") ||
+      File.open("data__/file4", "w") { |f| f.write "" }
 
-    File.symlink('data__/file4', 'data__/file3')
-    File.symlink('data__/file4', 'data__/data')
+    File.symlink("data__/file4", "data__/file3")
+    File.symlink("data__/file4", "data__/data")
 
-    Minitar.unpack(Zlib::GzipReader.new(StringIO.new(TEST_TGZ)), 'data__')
-    Minitar.unpack(Zlib::GzipReader.new(File.open('data__/data.tar.gz', 'rb')),
-      'data__')
+    Minitar.unpack(Zlib::GzipReader.new(StringIO.new(TEST_TGZ)), "data__")
+    Minitar.unpack(Zlib::GzipReader.new(File.open("data__/data.tar.gz", "rb")),
+      "data__")
 
-    refute File.symlink?('data__/file3')
-    refute File.symlink?('data__/data')
+    refute File.symlink?("data__/file3")
+    refute File.symlink?("data__/data")
   end
 
   RELATIVE_DIRECTORY_TGZ = Base64.decode64 <<-EOS
@@ -168,7 +168,7 @@ MDUzVDAwNDY0N2VQMGCgAygtLkksAjolEcjIzMOtDqgsLQ2/J0H+gNOjYBSMglEwyAEA2LchrwAGAAA=
     Minitar::Input.open(reader) do |stream|
       stream.each do |entry|
         assert_raises Archive::Tar::Minitar::SecureRelativePathError do
-          stream.extract_entry('data__', entry)
+          stream.extract_entry("data__", entry)
         end
       end
     end
@@ -191,7 +191,7 @@ glEwCkbBKBgFo2AUjIJRMApIAQD0DyzXACgAAA==
     reader = Zlib::GzipReader.new(StringIO.new(NON_STRICT_OCTAL_TGZ))
 
     assert_raises(ArgumentError) do
-      Minitar.unpack(reader, 'data__')
+      Minitar.unpack(reader, "data__")
     end
   end
 
@@ -214,6 +214,14 @@ UTAKRsEoGAWjYBSMglFACgAAuUHUvwAoAAA=
     assert_equal(210, header.size)
 
     reader = Zlib::GzipReader.new(StringIO.new(OCTAL_WRAPPED_BY_SPACE_TGZ))
-    Minitar.unpack(reader, 'data__', [])
+    Minitar.unpack(reader, "data__", [])
+  end
+
+  def test_fsync_false
+    outer = 0
+    Minitar.unpack(Zlib::GzipReader.new(StringIO.new(TEST_TGZ)), "data__", [], :fsync => false) do |_label, _path, _stats|
+      outer += 1
+    end
+    assert_equal(6, outer)
   end
 end

data/test/test_tar_output.rb

@@ -1,24 +1,24 @@
 #!/usr/bin/env ruby
 
-require 'minitar'
-require 'minitest_helper'
+require "minitar"
+require "minitest_helper"
 
 class TestTarOutput < Minitest::Test
-  NAMES = ['a', 'b', 'c', 'd' * 200]
+  NAMES = ["a", "b", "c", "d" * 200]
 
   def setup
-    FileUtils.mkdir_p('data__')
+    FileUtils.mkdir_p("data__")
     NAMES.each do |filename|
-      name = File.join('data__', filename)
-      File.open(name, 'wb') { |f|
+      name = File.join("data__", filename)
+      File.open(name, "wb") { |f|
         f.puts "#{name}: 123456789012345678901234567890"
       }
     end
-    @tarfile = 'data__/bla2.tar'
+    @tarfile = "data__/bla2.tar"
   end
 
   def teardown
-    FileUtils.rm_rf('data__')
+    FileUtils.rm_rf("data__")
   end
 
   def test_open_no_block
@@ -31,17 +31,17 @@ class TestTarOutput < Minitest::Test
 
   def test_file_looks_good
     Minitar::Output.open(@tarfile) do |os|
-      Dir.chdir('data__') do
+      Dir.chdir("data__") do
         NAMES.each do |name|
           stat = File.stat(name)
-          opts = { :size => stat.size, :mode => 0o644 }
+          opts = {:size => stat.size, :mode => 0o644}
           os.tar.add_file_simple(name, opts) do |ss|
-            File.open(name, 'rb') { |ff| ss.write(ff.read(4096)) until ff.eof? }
+            File.open(name, "rb") { |ff| ss.write(ff.read(4096)) until ff.eof? }
           end
         end
       end
     end
-    ff = File.open(@tarfile, 'rb')
+    ff = File.open(@tarfile, "rb")
     Minitar::Reader.open(ff) do |is|
       names_from_tar = is.map do |entry|
         entry.name

data/test/test_tar_reader.rb

@@ -1,15 +1,15 @@
 #!/usr/bin/env ruby
 
-require 'minitar'
-require 'minitest_helper'
+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)
-    str += tar_dir_header('foo', 'bar', 0o12345)
+    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 += "\0" * 1024
 
     reader = Minitar::Reader.open(StringIO.new(str))
@@ -20,13 +20,13 @@ class TestTarReader < Minitest::Test
   end
 
   def test_multiple_entries
-    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 = 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 src/)
-    prefixes = ['', 'baz', 'bar', '']
+    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]
@@ -41,7 +41,7 @@ class TestTarReader < Minitest::Test
         assert_equal(modes[i], entry.mode)
         assert_equal(isdir[i], entry.directory?)
         assert_equal(isfile[i], entry.file?)
-        if prefixes[i] != ''
+        if prefixes[i] != ""
           assert_equal(File.join(prefixes[i], names[i]), entry.full_name)
         else
           assert_equal(names[i], entry.name)
@@ -53,8 +53,8 @@ class TestTarReader < Minitest::Test
   end
 
   def test_rewind_entry_works
-    content = ('a'..'z').to_a.join(' ')
-    str = tar_file_header('lib/foo', '', 0o10644, bytesize(content)) +
+    content = ("a".."z").to_a.join(" ")
+    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|
@@ -69,8 +69,8 @@ class TestTarReader < Minitest::Test
   end
 
   def test_rewind_works
-    content = ('a'..'z').to_a.join(' ')
-    str = tar_file_header('lib/foo', '', 0o10644, bytesize(content)) +
+    content = ("a".."z").to_a.join(" ")
+    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|
@@ -87,8 +87,8 @@ class TestTarReader < Minitest::Test
   end
 
   def test_read_works
-    contents = ('a'..'z').inject('') { |a, e| a << e * 100 }
-    str = tar_file_header('lib/foo', '', 0o10644, bytesize(contents)) + contents
+    contents = ("a".."z").inject("") { |a, e| a << e * 100 }
+    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|
@@ -122,7 +122,7 @@ class TestTarReader < Minitest::Test
   end
 
   def test_eof_works
-    str = tar_file_header('bar', 'baz', 0o644, 0)
+    str = tar_file_header("bar", "baz", 0o644, 0)
     Minitar::Reader.new(StringIO.new(str)) do |is|
       is.each_entry do |entry|
         assert_kind_of(Minitar::Reader::EntryStream, entry)
@@ -134,7 +134,7 @@ class TestTarReader < Minitest::Test
         assert_equal(true, entry.eof?)
       end
     end
-    str = tar_dir_header('foo', 'bar', 0o12345)
+    str = tar_dir_header("foo", "bar", 0o12345)
     Minitar::Reader.new(StringIO.new(str)) do |is|
       is.each_entry do |entry|
         assert_kind_of(Minitar::Reader::EntryStream, entry)
@@ -146,9 +146,9 @@ class TestTarReader < Minitest::Test
         assert_equal(true, entry.eof?)
       end
     end
-    str = tar_dir_header('foo', 'bar', 0o12345)
-    str += tar_file_header('bar', 'baz', 0o644, 0)
-    str += tar_file_header('bar', 'baz', 0o644, 0)
+    str = tar_dir_header("foo", "bar", 0o12345)
+    str += tar_file_header("bar", "baz", 0o644, 0)
+    str += tar_file_header("bar", "baz", 0o644, 0)
     Minitar::Reader.new(StringIO.new(str)) do |is|
       is.each_entry do |entry|
         assert_kind_of(Minitar::Reader::EntryStream, entry)