minitar 1.0.2 → 1.1.0

data/test/test_integration_pack_unpack_cycle.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "minitest_helper"
+
+class TestIntegrationPackUnpackCycle < Minitest::Test
+  def test_comprehensive
+    files = MIXED_FILENAME_SCENARIOS.merge(
+      VERY_LONG_FILENAME_SCENARIOS,
+      BOUNDARY_SCENARIOS,
+      {
+        "empty_dir" => nil,
+        "nested/empty" => nil,
+        "long_dir_#{"i" * 120}" => nil,
+        "root_file.txt" => "root content",
+        "level1/file1.txt" => "level1 content",
+        "level1/level2/file2.txt" => "level2 content",
+        "level1/level2/level3/#{"deep" * 30}.txt" => "deep nested with long name",
+        "#{"long_dir" * 20}/file_in_long_dir.txt" => "file in long directory name",
+        "mixed/#{"long_subdir" * 15}/#{"long_file" * 25}.txt" => "long dir and file names"
+      }
+    )
+
+    workspace with_files: files do |ws|
+      minitar_pack_in_workspace
+
+      assert ws.tarball.file?, "Tarball does not exist"
+      assert ws.tarball.size > 0, "Tarball should not be empty"
+
+      minitar_unpack_in_workspace
+
+      assert_files_extracted_in_workspace
+      refute_file_path_duplication_in_workspace
+
+      assert_extracted_files_match_source_files_in_workspace
+      assert_file_modes_match_in_workspace
+    end
+  end
+end

data/test/test_issue_46.rb

@@ -1,44 +1,26 @@
-#!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require "minitar"
 require "minitest_helper"
-require "base64"
-require "zlib"
 
 class TestIssue46 < Minitest::Test
-  SUPERLONG_TGZ = Base64.decode64(<<~EOS).freeze
-    H4sIAK1+smYAA+3WQQ6CMBAF0K49BScAprYd3XkALoECSiQlQYzXt0IkSKLGBdXE
-    /zbtNF000PkQRmG0SWq7T0p7FPOIHaNUNzrTkWI5zPt1IiYtgmSm8zw4n9q0CQLR
-    1HX7at/lkOeVjwP5FZNcKm14tU63uyyPUP91/e3rCJ75uF/j/Gej+6yXw/fArbnM
-    Z2ZlDKlb/ktNrEQQ+3gA9/xP3aS0z/e5bUXh40B+/Vj+oJ63Xkzff26zoqzmzf13
-    /d/98437n0izQf8DAAAAAAAAAAAAAAAAAHziCqQuXDYAKAAA
-  EOS
-
-  FILETIMES = Time.utc(2004).to_i
-
-  superlong_name = (["0123456789abcde"] * 33).join("/")
-
   SUPERLONG_CONTENTS = {
-    superlong_name => {size: 496, mode: 0o644},
+    ["0123456789abcde"].then { _1 * 33 }.join("/") => {size: 496, mode: 0o644},
     "endfile" => {size: 0, mode: 0o644}
   }
 
   def test_each_works
-    reader = Zlib::GzipReader.new(StringIO.new(SUPERLONG_TGZ))
-
-    Minitar::Input.open(reader) do |stream|
+    Minitar::Input.open(open_fixture("issue_46")) do |stream|
       outer = 0
       stream.each.with_index do |entry, i|
         assert_kind_of Minitar::Reader::EntryStream, entry
         assert SUPERLONG_CONTENTS.key?(entry.name), "File #{entry.name} not defined"
 
         assert_equal SUPERLONG_CONTENTS[entry.name][:size],
-          entry.size,
-          "File sizes sizes do not match: #{entry.name}"
+          entry.size, "File sizes sizes do not match: #{entry.name}"
 
         assert_modes_equal(SUPERLONG_CONTENTS[entry.name][:mode],
           entry.mode, entry.name)
-        assert_equal FILETIMES, entry.mtime, "entry.mtime"
+        assert_equal TIME_2004, entry.mtime, "entry.mtime"
 
         outer += 1
       end

data/test/test_issue_62.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "minitest_helper"
+
+class TestIssue62 < Minitest::Test
+  # These are representative filenames from issue #62 which were extracted incorrectly.
+  FILENAMES = [
+    "hpg5lfg/1j/973e4t/hqc/djcrcb1l49ardcthyl5u80dcgmo03cp5mh938wr38dka7us1ja4i3dfrp3ahg4q2ooet6avyw45nqpzrcxfzdemvzj07oftcghtkl5bdc.gz",
+    "hpg5lfg/1j/973e4t/hqc/mioxx4h9tgcc9gqw0j8z2fj2covf6nsplrwggyjsg4swmh0glzy2jji4n2gspvb2vlki7zmu81046hvgt4fstlk6fldv0p1w3nf7o6.css",
+    "k6hly56/mh/ri2pa1/04/0afdks3r6k1mbf64xzuwh5efkuxurro63rbckjssmz9mdratf6ayfduqpb0r9qxx2mgnrs0thi0ohh4qtfylfd6cd506zawwic0u3ec0iluu4myn.map",
+    "k6hly56/mh/ri2pa1/04/5k8mnvwxe7hmvp1n932o4mn2b25gqrxfrbe4jfjbig6kzhphnsfkrtqruypfzl93u0ohlv9yyxcoxn6jg6iv5ml8e27jdqjiikyq3.js"
+  ].freeze
+
+  FILENAMES.each do |filename|
+    first, *, last = filename.split("/")
+    last = File.extname(last)
+
+    define_method :"test_issue_62_path_#{first}_#{last}" do
+      file_map = {filename => "Test content for #{File.basename(filename)}"}
+      files = roundtrip_tar_string(file_map)
+
+      assert_tar_structure_preserved file_map, files
+    end
+  end
+
+  def test_issue_62_full_regression
+    file_map = FILENAMES.each_with_object({}) { |name, map|
+      map[name] = "Test content for #{File.basename(name)}"
+    }
+    files = roundtrip_tar_string(file_map)
+
+    assert_tar_structure_preserved file_map, files
+  end
+
+  def test_issue_62_mixed_filename_lengths_no_regression
+    file_map = MIXED_FILENAME_SCENARIOS.dup
+    FILENAMES.each { file_map[_1] = "content for problematic filename #{_1}" }
+
+    files = roundtrip_tar_string(file_map)
+
+    assert_tar_structure_preserved file_map, files
+  end
+
+  def test_issue_62_very_long_filenames_no_regression
+    file_map = VERY_LONG_FILENAME_SCENARIOS.dup
+    files = roundtrip_tar_string(file_map)
+
+    assert_tar_structure_preserved file_map, files
+  end
+end

data/test/test_minitar.rb

@@ -1,60 +1,189 @@
-#!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require "minitar"
 require "minitest_helper"
-require "zlib"
 
 class TestMinitar < Minitest::Test
-  FILE_2004 = Time.utc(2004).to_i
+  SCENARIO = {
+    "path" => nil,
+    "test" => "test",
+    "extra/test" => "extra/test",
+    "empty2004" => {mtime: TIME_2004, mode: 0o755, data: ""},
+    "notime" => {mtime: nil, data: "notime"}
+  }
 
-  def test_pack_as_file
-    input = [
-      ["path", nil],
-      ["test", "test"],
-      ["extra/test", "extra/test"],
-      [{name: "empty2004", mtime: FILE_2004, mode: 0o755}, ""]
-    ]
+  def test_minitar_open_r
+    count = 0
 
-    writer = StringIO.new
-    Minitar::Output.open(writer) do |out_stream|
-      input.each do |(name, data)|
-        Minitar.pack_as_file(name, data, out_stream)
+    open_fixture("test_minitar") do |fixture|
+      Minitar.open(fixture, "r") do |stream|
+        stream.each do |entry|
+          assert_kind_of Minitar::Reader::EntryStream, entry
+
+          assert SCENARIO.has_key?(entry.name), "#{entry.name} not expected"
+
+          expected = SCENARIO[entry.name]
+
+          case expected
+          when nil
+            assert_equal 0, entry.size
+            assert_modes_equal 0o755, entry.mode, entry.name
+            assert entry.directory?, "#{entry.name} should be a directory"
+          when String
+            assert_equal expected.length, entry.size, entry.name
+            assert_modes_equal 0o644, entry.mode, entry.name
+            assert entry.file?, "#{entry.name} should be a file"
+
+            if entry.size.zero?
+              assert_nil entry.read
+            else
+              assert_equal expected, entry.read
+            end
+          when Hash
+            if expected[:data].nil?
+              assert_equal 0, entry.size
+              assert_modes_equal (expected[:mode] || 0o755), entry.mode, entry.name
+              assert entry.directory?, "#{entry.name} should be a directory"
+            else
+              assert_equal expected[:data].length, entry.size
+              assert_modes_equal (expected[:mode] || 0o644), entry.mode, entry.name
+              assert entry.file?, "#{entry.name} should be a file"
+            end
+
+            assert_equal expected[:mtime], entry.mtime if expected[:mtime]
+
+            if entry.size.zero?
+              assert_nil entry.read
+            else
+              assert_equal expected[:data], entry.read
+            end
+          end
+
+          count += 1
+        end
       end
     end
 
-    expected = [
-      {name: "path", size: 0, mode: 0o755},
-      {name: "test", size: 4, mode: 0o644, data: "test"},
-      {name: "extra/test", size: 10, mode: 0o0644, data: "extra/test"},
-      {name: "empty2004", size: 0, mode: 0o755, mtime: FILE_2004, nil: true}
-    ]
+    assert_equal SCENARIO.size, count
+  end
 
-    count = 0
-    reader = StringIO.new(writer.string)
-    Minitar.open(reader) do |stream|
-      stream.each.with_index do |entry, i|
-        assert_kind_of Minitar::Reader::EntryStream, entry
+  def test_minitar_open_w
+    events = []
 
-        assert_equal expected[i][:name], entry.name
-        assert_equal expected[i][:size], entry.size
-        assert_equal expected[i][:mode], entry.mode
+    writer = StringIO.new
+    Minitar.open(writer, "w") do |stream|
+      SCENARIO.each_pair do |name, data|
+        name, data =
+          if data.is_a?(Hash)
+            name = data.merge(name: name)
+            [name, name.delete(:data)]
+          else
+            [name, data]
+          end
 
-        if expected[i].key?(:mtime)
-          assert_equal expected[i][:mtime], entry.mtime
+        Minitar.pack_as_file(name, data, stream) do |op, entry_name, stats|
+          events << {
+            name: name,
+            data: data,
+            op: op,
+            entry_name: entry_name,
+            stats: stats
+          }
         end
+      end
+    end
 
-        if expected[i].key?(:data)
-          assert_equal expected[i][:data], entry.read
-        end
+    assert_equal 5120, writer.string.length
 
-        if expected[i].key?(:nil)
-          assert_nil entry.read
-        end
+    events.each do |event|
+      if event[:name].is_a?(Hash)
+        assert_equal event[:name][:name], event[:entry_name]
+      else
+        assert_equal event[:name], event[:entry_name]
+      end
 
-        count += 1
+      case [event[:op], event[:entry_name]]
+      in [:dir, "path"]
+        assert_equal 0, event[:stats][:size]
+        assert_equal 493, event[:stats][:mode]
+
+      in [:file_start, "test"]
+        assert_equal 4, event[:stats][:size]
+        assert_equal 420, event[:stats][:mode]
+        assert_equal 4, event[:stats][:current]
+        assert_equal 4, event[:stats][:currinc]
+        assert_equal "test", event[:data]
+      in [:file_progress, "test"]
+        assert_equal 4, event[:stats][:size]
+        assert_equal 420, event[:stats][:mode]
+        assert_equal 4, event[:stats][:current]
+        assert_equal 4, event[:stats][:currinc]
+        assert_equal "test", event[:data]
+      in [:file_done, "test"]
+        assert_equal 4, event[:stats][:size]
+        assert_equal 420, event[:stats][:mode]
+        assert_equal 4, event[:stats][:current]
+        assert_equal 4, event[:stats][:currinc]
+        assert_equal "test", event[:data]
+
+      in [:file_start, "extra/test"]
+        assert_equal 10, event[:stats][:size]
+        assert_equal 420, event[:stats][:mode]
+        assert_equal 10, event[:stats][:current]
+        assert_equal 10, event[:stats][:currinc]
+        assert_equal "extra/test", event[:data]
+      in [:file_progress, "extra/test"]
+        assert_equal 10, event[:stats][:size]
+        assert_equal 420, event[:stats][:mode]
+        assert_equal 10, event[:stats][:current]
+        assert_equal 10, event[:stats][:currinc]
+        assert_equal "extra/test", event[:data]
+      in [:file_done, "extra/test"]
+        assert_equal 10, event[:stats][:size]
+        assert_equal 420, event[:stats][:mode]
+        assert_equal 10, event[:stats][:current]
+        assert_equal 10, event[:stats][:currinc]
+        assert_equal "extra/test", event[:data]
+
+      in [:file_start, "empty2004"]
+        assert_equal 0, event[:stats][:size]
+        assert_equal 493, event[:stats][:mode]
+        assert_equal 0, event[:stats][:current]
+        assert_equal 1072915200, event[:stats][:mtime]
+        assert_equal "", event[:data]
+      in [:file_done, "empty2004"]
+        assert_equal 0, event[:stats][:size]
+        assert_equal 493, event[:stats][:mode]
+        assert_equal 0, event[:stats][:current]
+        assert_equal 1072915200, event[:stats][:mtime]
+        assert_equal "", event[:data]
+
+      in [:file_start, "notime"]
+        assert_equal 6, event[:stats][:size]
+        assert_equal 420, event[:stats][:mode]
+        assert_equal 6, event[:stats][:current]
+        assert_equal 6, event[:stats][:currinc]
+        assert_equal "notime", event[:data]
+      in [:file_progress, "notime"]
+        assert_equal 6, event[:stats][:size]
+        assert_equal 420, event[:stats][:mode]
+        assert_equal 6, event[:stats][:current]
+        assert_equal 6, event[:stats][:currinc]
+        assert_equal "notime", event[:data]
+      in [:file_done, "notime"]
+        assert_equal 6, event[:stats][:size]
+        assert_equal 420, event[:stats][:mode]
+        assert_equal 6, event[:stats][:current]
+        assert_equal 6, event[:stats][:currinc]
+        assert_equal "notime", event[:data]
+      else
+        raise "Unknown operation #{event[:op].inspect} for #{event[:entry_name].inspect}"
       end
     end
+  end
 
-    assert_equal expected.size, count
+  def test_minitar_x
+    assert_raises(ArgumentError) do
+      Minitar.open("foo", "x")
+    end
   end
 end

data/test/test_pax_header.rb

@@ -0,0 +1,104 @@
+require "minitest_helper"
+
+class TestPaxHeader < Minitest::Test
+  def test_from_stream_with_size_attribute
+    pax_content = "19 size=8614356715\n28 mtime=1749098832.3200000\n"
+    pax_header = create_pax_header_from_stream(pax_content)
+
+    assert_equal 8614356715, pax_header.size
+    assert_equal "1749098832.3200000", pax_header.attributes["mtime"]
+  end
+
+  def test_from_stream_without_size_attribute
+    pax_content = "28 mtime=1749098832.3200000\n27 path=some/long/path.txt\n"
+    pax_header = create_pax_header_from_stream(pax_content)
+
+    assert_nil pax_header.size
+    assert_equal "some/long/path.txt", pax_header.path
+    assert_equal 1749098832.32, pax_header.mtime
+  end
+
+  def test_parse_multiline_values
+    pax_content = "22 foo=one\ntwo\nthree\n\n12 bar=four\n"
+    pax_header = Minitar::PaxHeader.from_data(pax_content)
+    assert_equal "one\ntwo\nthree\n", pax_header.attributes["foo"]
+    assert_equal "four", pax_header.attributes["bar"]
+  end
+
+  def test_from_stream_with_invalid_header
+    header_data = build_tar_file_header("regular_file.txt", "", 0o644, 100)
+    io = StringIO.new(header_data)
+
+    posix_header = Minitar::PosixHeader.from_stream(io)
+    refute posix_header.pax_header?
+
+    assert_raises(ArgumentError, "Header must be a PAX header") do
+      Minitar::PaxHeader.from_stream(io, posix_header)
+    end
+  end
+
+  def test_parse_content_with_multiple_attributes
+    pax_content = "19 size=8614356715\n28 mtime=1749098832.3200000\n27 path=some/long/path.txt\n"
+
+    pax_header = Minitar::PaxHeader.from_data(pax_content)
+
+    assert_equal 8614356715, pax_header.size
+    assert_equal "some/long/path.txt", pax_header.path
+    assert_equal 1749098832.32, pax_header.mtime
+
+    # Check raw attributes
+    assert_equal "8614356715", pax_header.attributes["size"]
+    assert_equal "1749098832.3200000", pax_header.attributes["mtime"]
+    assert_equal "some/long/path.txt", pax_header.attributes["path"]
+  end
+
+  def test_parse_content_with_invalid_length_format
+    assert_raises(ArgumentError) do
+      Minitar::PaxHeader.from_data("19 size=8614356715\ninvalid line\n23 path=valid/path.txt\n")
+    end
+  end
+
+  def test_parse_content_with_oversized_record
+    assert_raises(ArgumentError) do
+      Minitar::PaxHeader.from_data("19 size=8614356715\n999 toolong=value\n")
+    end
+  end
+
+  def test_from_stream_strips_padding
+    pax_content = "19 size=8614356715\n"
+    pax_header = create_pax_header_from_stream(pax_content)
+
+    # Should parse only the actual content, ignoring padding
+    assert_equal 8614356715, pax_header.size
+    assert_equal 1, pax_header.attributes.size  # Only one attribute parsed
+
+    # Should have parsed content correctly
+    assert_equal 1, pax_header.attributes.size
+    assert_equal "8614356715", pax_header.attributes["size"]
+  end
+
+  def test_attributes_accessor
+    pax_content = "19 size=8614356715\n23 custom=custom_value\n"
+    pax_header = Minitar::PaxHeader.from_data(pax_content)
+
+    assert_equal "8614356715", pax_header.attributes["size"]
+    assert_equal "custom_value", pax_header.attributes["custom"]
+    assert_nil pax_header.attributes["nonexistent"]
+  end
+
+  def test_pax_header_to_s
+    pax_header = Minitar::PaxHeader.new(size: "8614356715", mtime: "1749098832.3200000")
+    assert_equal "19 size=8614356715\n28 mtime=1749098832.3200000\n", pax_header.to_s
+  end
+
+  private
+
+  def create_pax_header_from_stream(pax_content, name = "./PaxHeaders.X/test_file")
+    pax_header_data = build_tar_pax_header(name, "", pax_content.bytesize)
+    padded_content = pax_content.ljust((pax_content.bytesize / 512.0).ceil * 512, "\0")
+    io = StringIO.new(pax_header_data + padded_content)
+
+    posix_header = Minitar::PosixHeader.from_stream(io)
+    Minitar::PaxHeader.from_stream(io, posix_header)
+  end
+end

data/test/test_pax_support.rb

@@ -0,0 +1,66 @@
+require "minitest_helper"
+
+class TestPaxSupport < Minitest::Test
+  def test_pax_header_size_extraction_in_reader
+    pax_content = "16 size=1048576\n28 mtime=1749098832.3200000\n"
+    tar_data = create_pax_with_file_headers(pax_content, "./PaxHeaders.X/large_file.mov", "large_file.mov", 1048576, 0)
+
+    entries = read_tar_entries(tar_data)
+    assert_equal 1, entries.size
+
+    entry = entries.first
+    assert_equal "large_file.mov", entry.name
+    assert_equal 1048576, entry.size  # Size from PAX header
+  end
+
+  def test_pax_header_without_size_uses_header_size
+    pax_content = "28 mtime=1749098832.3200000\n"
+    tar_data = create_pax_with_file_headers(pax_content, "./PaxHeaders.X/normal_file.txt", "normal_file.txt", 12345, 12345)
+
+    entries = read_tar_entries(tar_data)
+    assert_equal 1, entries.size
+
+    entry = entries.first
+    assert_equal "normal_file.txt", entry.name
+    assert_equal 12345, entry.size  # Original header size preserved
+  end
+
+  def test_pax_header_takes_precedence_over_posix_header_size
+    pax_content = "16 size=1048576\n28 mtime=1749098832.3200000\n"
+    tar_data = create_pax_with_file_headers(pax_content, "./PaxHeaders.X/precedence_file.txt", "precedence_file.txt", 12345, 12345)
+
+    entries = read_tar_entries(tar_data)
+    assert_equal 1, entries.size
+
+    entry = entries.first
+    assert_equal "precedence_file.txt", entry.name
+    assert_equal 1048576, entry.size  # PAX size takes precedence over POSIX size (12345)
+  end
+
+  def test_pax_size_extraction_logic
+    pax_header_with_size = Minitar::PaxHeader.new(size: "1048576", mtime: "1749098832.3200000")
+    assert_equal 1048576, pax_header_with_size.size
+
+    pax_header_without_size = Minitar::PaxHeader.new(mtime: "1749098832.3200000")
+    assert_nil pax_header_without_size.size
+  end
+
+  private
+
+  def read_tar_entries(tar_data)
+    io = StringIO.new(tar_data)
+    Minitar::Reader.open(io, &:to_a)
+  end
+
+  def create_pax_with_file_headers(pax_content, pax_name, file_name, file_size, posix_header_file_size)
+    file_content = "x" * file_size
+    padded_file_content = file_content.ljust((file_size / 512.0).ceil * 512, "\0")
+
+    [
+      build_tar_pax_header(pax_name, "", pax_content.bytesize),
+      pax_content.ljust((pax_content.bytesize / 512.0).ceil * 512, "\0"),
+      build_tar_file_header(file_name, "", 0o644, file_size),
+      padded_file_content
+    ].join
+  end
+end