minitar 0.12.1 → 1.0.0

data/test/test_tar_input.rb

@@ -6,28 +6,28 @@ require "base64"
 require "zlib"
 
 class TestTarInput < Minitest::Test
-  TEST_TGZ = Base64.decode64(<<-EOS).freeze
-H4sIAKJpllQAA0tJLEnUK0ks0kuvYqAVMDAwMDMxUQDR5mbmYNrACMIHA2MjIwUDc3NzEzMz
-QxMDAwUDQ2NTczMGBQOauQgJlBYDfQ90SiKQkZmHWx1QWVoaHnMgXlGA00MEyHdzMMzOnBbC
-wPz28n2uJgOR44Xrq7tsHc/utNe/9FdihkmH3pZ7+zOTRFREzkzYJ99iHHDn4n0/Wb3E8Ceq
-S0uOdSyMMg9Z+WVvX0vJucxs77vrvZf2arWcvHP9wa1Yp9lRnJmC59/P9+43PXum+tj7Ga+8
-rtT+u3d941e765Y/bOrnvpv8X6jtz+wKqyk/v3n8P5xlO3l/1dn9q9Zotpy5funw/Of77Y/5
-LVltz7ToTl7dXf5ppmf3n9p+PPxz/sz/qjZn9yf9Y4R7I2Ft3tqfPTUMGgMYlEMSpGXmpBrT
-2A5Qvjc1xZ3/DTDyv5GJmfFo/qcHCMnILFYAIlA6UDDWU+DlGmgXjYJRMApGwSgYBaNgFIyC
-UTAKRsEoGAWjYBSMglEwCkbBKBgFo2AUjIJRMApGwSgYBaNgFIwCUgAAGnyo6wAoAAA=
+  TEST_TGZ = Base64.decode64(<<~EOS).freeze
+    H4sIAKJpllQAA0tJLEnUK0ks0kuvYqAVMDAwMDMxUQDR5mbmYNrACMIHA2MjIwUDc3NzEzMz
+    QxMDAwUDQ2NTczMGBQOauQgJlBYDfQ90SiKQkZmHWx1QWVoaHnMgXlGA00MEyHdzMMzOnBbC
+    wPz28n2uJgOR44Xrq7tsHc/utNe/9FdihkmH3pZ7+zOTRFREzkzYJ99iHHDn4n0/Wb3E8Ceq
+    S0uOdSyMMg9Z+WVvX0vJucxs77vrvZf2arWcvHP9wa1Yp9lRnJmC59/P9+43PXum+tj7Ga+8
+    rtT+u3d941e765Y/bOrnvpv8X6jtz+wKqyk/v3n8P5xlO3l/1dn9q9Zotpy5funw/Of77Y/5
+    LVltz7ToTl7dXf5ppmf3n9p+PPxz/sz/qjZn9yf9Y4R7I2Ft3tqfPTUMGgMYlEMSpGXmpBrT
+    2A5Qvjc1xZ3/DTDyv5GJmfFo/qcHCMnILFYAIlA6UDDWU+DlGmgXjYJRMApGwSgYBaNgFIyC
+    UTAKRsEoGAWjYBSMglEwCkbBKBgFo2AUjIJRMApGwSgYBaNgFIwCUgAAGnyo6wAoAAA=
   EOS
   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
@@ -52,36 +52,36 @@ UTAKRsEoGAWjYBSMglEwCkbBKBgFo2AUjIJRMApGwSgYBaNgFIwCUgAAGnyo6wAoAAA=
     Minitar::Input.open(reader) do |stream|
       outer = 0
       stream.each.with_index do |entry, i|
-        assert_kind_of(Minitar::Reader::EntryStream, entry)
+        assert_kind_of Minitar::Reader::EntryStream, entry
         assert TEST_CONTENTS.key?(entry.name)
 
-        assert_equal(TEST_CONTENTS[entry.name][:size], entry.size, entry.name)
+        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))
           Minitar::Input.open(data_reader) do |is2|
             inner = 0
             is2.each_with_index do |entry2, _j|
-              assert_kind_of(Minitar::Reader::EntryStream, entry2)
+              assert_kind_of Minitar::Reader::EntryStream, entry2
               assert TEST_DATA_CONTENTS.key?(entry2.name)
               assert_equal(TEST_DATA_CONTENTS[entry2.name][:size], entry2.size,
                 entry2.name)
               assert_modes_equal(TEST_DATA_CONTENTS[entry2.name][:mode],
                 entry2.mode, entry2.name)
-              assert_equal(FILETIMES, entry2.mtime, entry2.name)
+              assert_equal FILETIMES, entry2.mtime, entry2.name
               inner += 1
             end
-            assert_equal(4, inner)
+            assert_equal 4, inner
           end
         end
 
         outer += 1
       end
 
-      assert_equal(2, outer)
+      assert_equal 2, outer
     end
   end
 
@@ -100,7 +100,7 @@ UTAKRsEoGAWjYBSMglEwCkbBKBgFo2AUjIJRMApGwSgYBaNgFIwCUgAAGnyo6wAoAAA=
         else
           assert(File.file?(name))
 
-          assert_equal(TEST_CONTENTS[entry.name][:size], File.stat(name).size)
+          assert_equal TEST_CONTENTS[entry.name][:size], File.stat(name).size
         end
 
         assert_modes_equal(TEST_CONTENTS[entry.name][:mode],
@@ -136,7 +136,7 @@ UTAKRsEoGAWjYBSMglEwCkbBKBgFo2AUjIJRMApGwSgYBaNgFIwCUgAAGnyo6wAoAAA=
         outer_count += 1
       end
 
-      assert_equal(2, outer_count)
+      assert_equal 2, outer_count
     end
   end
 
@@ -145,7 +145,7 @@ UTAKRsEoGAWjYBSMglEwCkbBKBgFo2AUjIJRMApGwSgYBaNgFIwCUgAAGnyo6wAoAAA=
 
     IO.respond_to?(:write) &&
       IO.write("data__/file4", "") ||
-      File.open("data__/file4", "w") { |f| f.write "" }
+      File.write("data__/file4", "")
 
     File.symlink("data__/file4", "data__/file3")
     File.symlink("data__/file4", "data__/data")
@@ -158,33 +158,33 @@ UTAKRsEoGAWjYBSMglEwCkbBKBgFo2AUjIJRMApGwSgYBaNgFIwCUgAAGnyo6wAoAAA=
     refute File.symlink?("data__/data")
   end
 
-  RELATIVE_DIRECTORY_TGZ = Base64.decode64 <<-EOS
-H4sICIIoKVgCA2JhZC1kaXIudGFyANPT0y8sTy0qqWSgHTAwMDAzMVEA0eZmpmDawAjChwEFQ2MDQyMg
-MDUzVDAwNDY0N2VQMGCgAygtLkksAjolEcjIzMOtDqgsLQ2/J0H+gNOjYBSMglEwyAEA2LchrwAGAAA=
+  RELATIVE_DIRECTORY_TGZ = Base64.decode64 <<~EOS
+    H4sICIIoKVgCA2JhZC1kaXIudGFyANPT0y8sTy0qqWSgHTAwMDAzMVEA0eZmpmDawAjChwEFQ2MDQyMg
+    MDUzVDAwNDY0N2VQMGCgAygtLkksAjolEcjIzMOtDqgsLQ2/J0H+gNOjYBSMglEwyAEA2LchrwAGAAA=
   EOS
 
   def test_extract_entry_fails_with_relative_directory
     reader = Zlib::GzipReader.new(StringIO.new(RELATIVE_DIRECTORY_TGZ))
     Minitar::Input.open(reader) do |stream|
       stream.each do |entry|
-        assert_raises Archive::Tar::Minitar::SecureRelativePathError do
+        assert_raises Minitar::SecureRelativePathError do
           stream.extract_entry("data__", entry)
         end
       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==
+  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
@@ -195,23 +195,23 @@ glEwCkbBKBgFo2AUjIJRMApIAQD0DyzXACgAAA==
     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=
+  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)
+    header = 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__", [])
@@ -219,9 +219,9 @@ UTAKRsEoGAWjYBSMglFACgAAuUHUvwAoAAA=
 
   def test_fsync_false
     outer = 0
-    Minitar.unpack(Zlib::GzipReader.new(StringIO.new(TEST_TGZ)), "data__", [], :fsync => false) do |_label, _path, _stats|
+    Minitar.unpack(Zlib::GzipReader.new(StringIO.new(TEST_TGZ)), "data__", [], fsync: false) do |_label, _path, _stats|
       outer += 1
     end
-    assert_equal(6, outer)
+    assert_equal 6, outer
   end
 end

data/test/test_tar_output.rb

@@ -34,7 +34,7 @@ class TestTarOutput < Minitest::Test
       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? }
           end
@@ -46,9 +46,9 @@ class TestTarOutput < Minitest::Test
       names_from_tar = is.map do |entry|
         entry.name
       end
-      assert_equal(NAMES, names_from_tar)
+      assert_equal NAMES, names_from_tar
     end
   ensure
-    ff.close if ff
+    ff&.close
   end
 end

data/test/test_tar_reader.rb

@@ -4,8 +4,6 @@ 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)
@@ -34,35 +32,35 @@ class TestTarReader < Minitest::Test
     Minitar::Reader.new(StringIO.new(str)) do |is|
       i = 0
       is.each_entry do |entry|
-        assert_kind_of(Minitar::Reader::EntryStream, entry)
-        assert_equal(names[i], entry.name)
-        assert_equal(prefixes[i], entry.prefix)
-        assert_equal(sizes[i], entry.size)
-        assert_equal(modes[i], entry.mode)
-        assert_equal(isdir[i], entry.directory?)
-        assert_equal(isfile[i], entry.file?)
+        assert_kind_of Minitar::Reader::EntryStream, entry
+        assert_equal names[i], entry.name
+        assert_equal prefixes[i], entry.prefix
+        assert_equal sizes[i], entry.size
+        assert_equal modes[i], entry.mode
+        assert_equal isdir[i], entry.directory?
+        assert_equal isfile[i], entry.file?
         if prefixes[i] != ""
-          assert_equal(File.join(prefixes[i], names[i]), entry.full_name)
+          assert_equal File.join(prefixes[i], names[i]), entry.full_name
         else
-          assert_equal(names[i], entry.name)
+          assert_equal names[i], entry.name
         end
         i += 1
       end
-      assert_equal(names.size, i)
+      assert_equal names.size, i
     end
   end
 
   def test_rewind_entry_works
     content = ("a".."z").to_a.join(" ")
-    str = tar_file_header("lib/foo", "", 0o10644, bytesize(content)) +
-      content + "\0" * (512 - bytesize(content))
+    str = tar_file_header("lib/foo", "", 0o10644, content.bytesize) +
+      content + "\0" * (512 - content.bytesize)
     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(bytesize(content), entry.pos)
+          assert_equal content, entry.read
+          assert_equal content.bytesize, entry.pos
         end
       end
     end
@@ -70,53 +68,53 @@ class TestTarReader < Minitest::Test
 
   def test_rewind_works
     content = ("a".."z").to_a.join(" ")
-    str = tar_file_header("lib/foo", "", 0o10644, bytesize(content)) +
-      content + "\0" * (512 - bytesize(content))
+    str = tar_file_header("lib/foo", "", 0o10644, content.bytesize) +
+      content + "\0" * (512 - content.bytesize)
     str << "\0" * 1024
     Minitar::Reader.new(StringIO.new(str)) do |is|
       3.times do
         is.rewind
         i = 0
         is.each_entry do |entry|
-          assert_equal(content, entry.read)
+          assert_equal content, entry.read
           i += 1
         end
-        assert_equal(1, i)
+        assert_equal 1, i
       end
     end
   end
 
   def test_read_works
     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))
+    str = tar_file_header("lib/foo", "", 0o10644, contents.bytesize) + contents
+    str += "\0" * (512 - (str.bytesize % 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 bytesize(contents)
-        assert_equal(contents, data)
-        assert_equal(true, entry.eof?)
+        assert_kind_of Minitar::Reader::EntryStream, entry
+        data = entry.read(3000) # bigger than contents.bytesize
+        assert_equal contents, data
+        assert entry.eof?
       end
     end
     Minitar::Reader.new(StringIO.new(str)) do |is|
       is.each_entry do |entry|
-        assert_kind_of(Minitar::Reader::EntryStream, entry)
+        assert_kind_of Minitar::Reader::EntryStream, entry
         data = entry.read(100)
-        (entry.size - bytesize(data)).times { data << entry.getc.chr }
-        assert_equal(contents, data)
-        assert_equal(nil, entry.read(10))
-        assert_equal(true, entry.eof?)
+        (entry.size - data.bytesize).times { data << entry.getc.chr }
+        assert_equal contents, data
+        assert_nil entry.read(10)
+        assert entry.eof?
       end
     end
     Minitar::Reader.new(StringIO.new(str)) do |is|
       is.each_entry do |entry|
-        assert_kind_of(Minitar::Reader::EntryStream, entry)
+        assert_kind_of Minitar::Reader::EntryStream, entry
         data = entry.read
-        assert_equal(contents, data)
-        assert_equal(nil, entry.read(10))
-        assert_equal(nil, entry.read)
-        assert_equal(nil, entry.getc)
-        assert_equal(true, entry.eof?)
+        assert_equal contents, data
+        assert_nil entry.read(10)
+        assert_nil entry.read
+        assert_nil entry.getc
+        assert entry.eof?
       end
     end
   end
@@ -125,25 +123,25 @@ class TestTarReader < Minitest::Test
     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)
+        assert_kind_of Minitar::Reader::EntryStream, entry
         data = entry.read
-        assert_equal(nil, data)
-        assert_equal(nil, entry.read(10))
-        assert_equal(nil, entry.read)
-        assert_equal(nil, entry.getc)
-        assert_equal(true, entry.eof?)
+        assert_nil data
+        assert_nil entry.read(10)
+        assert_nil entry.read
+        assert_nil entry.getc
+        assert entry.eof?
       end
     end
     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)
+        assert_kind_of Minitar::Reader::EntryStream, entry
         data = entry.read
-        assert_equal(nil, data)
-        assert_equal(nil, entry.read(10))
-        assert_equal(nil, entry.read)
-        assert_equal(nil, entry.getc)
-        assert_equal(true, entry.eof?)
+        assert_nil data
+        assert_nil entry.read(10)
+        assert_nil entry.read
+        assert_nil entry.getc
+        assert entry.eof?
       end
     end
     str = tar_dir_header("foo", "bar", 0o12345)
@@ -151,19 +149,19 @@ class TestTarReader < Minitest::Test
     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)
+        assert_kind_of Minitar::Reader::EntryStream, entry
         data = entry.read
-        assert_equal(nil, data)
-        assert_equal(nil, entry.read(10))
-        assert_equal(nil, entry.read)
-        assert_equal(nil, entry.getc)
-        assert_equal(true, entry.eof?)
+        assert_nil data
+        assert_nil entry.read(10)
+        assert_nil entry.read
+        assert_nil entry.getc
+        assert entry.eof?
       end
     end
   end
 
   def test_read_invalid_tar_file
-    assert_raises Archive::Tar::Minitar::InvalidTarStream do
+    assert_raises Minitar::InvalidTarStream do
       Minitar::Reader.open(StringIO.new("testing")) do |r|
         r.each_entry do |entry|
           fail "invalid tar file should not read files"

data/test/test_tar_writer.rb

@@ -4,11 +4,7 @@ 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
@@ -50,32 +46,32 @@ class TestTarWriter < Minitest::Test
     @dummyos.reset
 
     Minitar::Writer.open(@dummyos) do |os|
-      os.add_file_simple("lib/foo/bar", :mode => 0o644, :size => 10) do |f|
+      os.add_file_simple("lib/foo/bar", mode: 0o644, size: 10) do |f|
         f.write "a" * 10
       end
-      os.add_file_simple("lib/bar/baz", :mode => 0o644, :size => 100) do |f|
+      os.add_file_simple("lib/bar/baz", mode: 0o644, size: 100) do |f|
         f.write "fillme"
       end
     end
 
     assert_headers_equal(tar_file_header("lib/foo/bar", "", 0o644, 10),
       @dummyos.data[0, 512])
-    assert_equal("a" * 10 + "\0" * 502, @dummyos.data[512, 512])
+    assert_equal "a" * 10 + "\0" * 502, @dummyos.data[512, 512]
     assert_headers_equal(tar_file_header("lib/bar/baz", "", 0o644, 100),
       @dummyos.data[512 * 2, 512])
-    assert_equal("fillme" + "\0" * 506, @dummyos.data[512 * 3, 512])
-    assert_equal("\0" * 512, @dummyos.data[512 * 4, 512])
-    assert_equal("\0" * 512, @dummyos.data[512 * 5, 512])
+    assert_equal "fillme" + "\0" * 506, @dummyos.data[512 * 3, 512]
+    assert_equal "\0" * 512, @dummyos.data[512 * 4, 512]
+    assert_equal "\0" * 512, @dummyos.data[512 * 5, 512]
   end
 
   def test_write_operations_fail_after_closed
     @dummyos.reset
-    @os.add_file_simple("sadd", :mode => 0o644, :size => 20) { |f| }
+    @os.add_file_simple("sadd", mode: 0o644, size: 20) { |f| }
     @os.close
     assert_raises(Minitar::ClosedStream) { @os.flush }
-    assert_raises(Minitar::ClosedStream) { @os.add_file("dfdsf", :mode => 0o644) {} }
-    assert_raises(Minitar::ClosedStream) { @os.mkdir "sdfdsf", :mode => 0o644 }
-    assert_raises(Minitar::ClosedStream) { @os.symlink "a", "b", :mode => 0o644 }
+    assert_raises(Minitar::ClosedStream) { @os.add_file("dfdsf", mode: 0o644) {} }
+    assert_raises(Minitar::ClosedStream) { @os.mkdir "sdfdsf", mode: 0o644 }
+    assert_raises(Minitar::ClosedStream) { @os.symlink "a", "b", mode: 0o644 }
   end
 
   def test_file_name_is_split_correctly
@@ -103,7 +99,7 @@ class TestTarWriter < Minitest::Test
       "#{"a" * 49}x"
     ]
     names.each do |name|
-      @os.add_file_simple(name, :mode => 0o644, :size => 10) {}
+      @os.add_file_simple(name, mode: 0o644, size: 10) {}
     end
     names.each_index do |i|
       assert_headers_equal(
@@ -117,13 +113,13 @@ class TestTarWriter < Minitest::Test
     @dummyos.reset
 
     @os.add_file_simple(File.join("a" * 152, "b" * 10, "c" * 92),
-      :mode => 0o644, :size => 10) {}
+      mode: 0o644, size: 10) {}
     @os.add_file_simple(File.join("d" * 162, "e" * 10),
-      :mode => 0o644, :size => 10) {}
+      mode: 0o644, size: 10) {}
     @os.add_file_simple(File.join("f" * 10, "g" * 110),
-      :mode => 0o644, :size => 10) {}
+      mode: 0o644, size: 10) {}
     # Issue #6.
-    @os.add_file_simple("a" * 114, :mode => 0o644, :size => 10) {}
+    @os.add_file_simple("a" * 114, mode: 0o644, size: 10) {}
 
     # "././@LongLink", a file name, its actual header, its data, ...
     4.times do |i|
@@ -137,7 +133,7 @@ class TestTarWriter < Minitest::Test
 
     long_name_file_content = "where_is_all_the_content_gone"
 
-    @os.add_file_simple("a" * 114, :mode => 0o0644, :data => long_name_file_content)
+    @os.add_file_simple("a" * 114, mode: 0o0644, data: long_name_file_content)
 
     assert_equal(long_name_file_content,
       @dummyos.data[3 * 512, long_name_file_content.bytesize])
@@ -156,7 +152,7 @@ class TestTarWriter < Minitest::Test
     long_name_file_content = "where_is_all_the_content_gone"
 
     Minitar::Writer.open(dummyos) do |os|
-      os.add_file("a" * 114, :mode => 0o0644) do |f|
+      os.add_file("a" * 114, mode: 0o0644) do |f|
         f.write(long_name_file_content)
       end
     end
@@ -177,58 +173,58 @@ class TestTarWriter < Minitest::Test
     content1 = ("a".."z").to_a.join("") # 26
     content2 = ("aa".."zz").to_a.join("") # 1352
     Minitar::Writer.open(dummyos) do |os|
-      os.add_file("lib/foo/bar", :mode => 0o644) { |f, _opts| f.write "a" * 10 }
-      os.add_file("lib/bar/baz", :mode => 0o644) { |f, _opts| f.write content1 }
-      os.add_file("lib/bar/baz", :mode => 0o644) { |f, _opts| f.write content2 }
-      os.add_file("lib/bar/baz", :mode => 0o644) { |_f, _opts| }
+      os.add_file("lib/foo/bar", mode: 0o644) { |f, _opts| f.write "a" * 10 }
+      os.add_file("lib/bar/baz", mode: 0o644) { |f, _opts| f.write content1 }
+      os.add_file("lib/bar/baz", mode: 0o644) { |f, _opts| f.write content2 }
+      os.add_file("lib/bar/baz", mode: 0o644) { |_f, _opts| }
     end
     assert_headers_equal(tar_file_header("lib/foo/bar", "", 0o644, 10),
       dummyos[0, 512])
-    assert_equal(%(#{"a" * 10}#{"\0" * 502}), dummyos[512, 512])
+    assert_equal %(#{"a" * 10}#{"\0" * 502}), dummyos[512, 512]
     offset = 512 * 2
     [content1, content2, ""].each do |data|
       assert_headers_equal(tar_file_header("lib/bar/baz", "", 0o644,
-        bytesize(data)), dummyos[offset, 512])
+        data.bytesize), dummyos[offset, 512])
       offset += 512
       until !data || data == ""
         chunk = data[0, 512]
         data[0, 512] = ""
-        assert_equal(chunk + "\0" * (512 - bytesize(chunk)),
+        assert_equal(chunk + "\0" * (512 - chunk.bytesize),
           dummyos[offset, 512])
         offset += 512
       end
     end
-    assert_equal("\0" * 1024, dummyos[offset, 1024])
+    assert_equal "\0" * 1024, dummyos[offset, 1024]
   end
 
   def test_add_file_tests_seekability
-    assert_raises(Archive::Tar::Minitar::NonSeekableStream) do
-      @os.add_file("libdfdsfd", :mode => 0o644) { |f| }
+    assert_raises(Minitar::NonSeekableStream) do
+      @os.add_file("libdfdsfd", mode: 0o644) { |f| }
     end
   end
 
   def test_write_header
     @dummyos.reset
-    @os.add_file_simple("lib/foo/bar", :mode => 0o644, :size => 0) {}
+    @os.add_file_simple("lib/foo/bar", mode: 0o644, size: 0) {}
     @os.flush
     assert_headers_equal(tar_file_header("lib/foo/bar", "", 0o644, 0),
       @dummyos.data[0, 512])
     @dummyos.reset
-    @os.mkdir("lib/foo", :mode => 0o644)
+    @os.mkdir("lib/foo", mode: 0o644)
     assert_headers_equal(tar_dir_header("lib/foo", "", 0o644),
       @dummyos.data[0, 512])
-    @os.mkdir("lib/bar", :mode => 0o644)
+    @os.mkdir("lib/bar", mode: 0o644)
     assert_headers_equal(tar_dir_header("lib/bar", "", 0o644),
       @dummyos.data[512 * 1, 512])
   end
 
   def test_write_data
     @dummyos.reset
-    @os.add_file_simple("lib/foo/bar", :mode => 0o644, :size => 10) do |f|
+    @os.add_file_simple("lib/foo/bar", mode: 0o644, size: 10) do |f|
       f.write @data
     end
     @os.flush
-    assert_equal(@data + ("\0" * (512 - bytesize(@data))),
+    assert_equal(@data + ("\0" * (512 - @data.bytesize)),
       @dummyos.data[512, 512])
   end
 
@@ -243,27 +239,27 @@ class TestTarWriter < Minitest::Test
 
     file = ["lib/foo/b", 0xc3.chr, 0xa5.chr, "r"].join
 
-    @os.add_file_simple(file, :mode => 0o644, :size => 20) do |f|
+    @os.add_file_simple(file, mode: 0o644, size: 20) do |f|
       f.write @unicode
     end
     @os.flush
-    assert_equal(@unicode + ("\0" * (512 - bytesize(@unicode))),
+    assert_equal(@unicode + ("\0" * (512 - @unicode.bytesize)),
       @dummyos.data[512, 512])
   end
 
   def test_file_size_is_checked
     @dummyos.reset
     assert_raises(Minitar::Writer::WriteBoundaryOverflow) do
-      @os.add_file_simple("lib/foo/bar", :mode => 0o644, :size => 10) do |f|
+      @os.add_file_simple("lib/foo/bar", mode: 0o644, size: 10) do |f|
         f.write "1" * 100
       end
     end
-    @os.add_file_simple("lib/foo/bar", :mode => 0o644, :size => 10) { |f| }
+    @os.add_file_simple("lib/foo/bar", mode: 0o644, size: 10) { |f| }
   end
 
   def test_symlink
     @dummyos.reset
-    @os.symlink("lib/foo/bar", "lib/foo/baz", :mode => 0o644)
+    @os.symlink("lib/foo/bar", "lib/foo/baz", mode: 0o644)
     @os.flush
     assert_headers_equal(tar_symlink_header("lib/foo/bar", "", 0o644, "lib/foo/baz"),
       @dummyos.data[0, 512])