minitar 1.0.2 → 1.1.0

data/test/support/minitar_test_helpers/fixtures.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Minitar::TestHelpers::Fixtures
+  def Fixture(name) = FIXTURES.fetch(name)
+
+  def open_fixture(name)
+    fixture = Fixture(name)
+
+    io = fixture.open("rb").then {
+      if %w[.gz .tgz].include?(fixture.extname.to_s)
+        Zlib::GzipReader.new(_1)
+      else
+        _1
+      end
+    }.tap {
+      yield _1 if block_given?
+    }
+  ensure
+    io&.close if block_given?
+  end
+
+  FIXTURES = Pathname(__dir__)
+    .join("../../fixtures")
+    .expand_path
+    .glob("**")
+    .each_with_object({}) {
+      next if _1.directory?
+
+      name = _1.dup
+      name = name.basename(name.extname) until name.nil? || name.extname.empty?
+
+      _2[name.to_s] = _1
+    }
+    .freeze
+  private_constant :FIXTURES
+
+  Minitest::Test.send(:include, self)
+end

data/test/support/minitar_test_helpers/header.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+# Test assertions and helpers for working with header objects.
+module Minitar::TestHelpers::Header
+  private
+
+  # Assert that the +actual+ header is equal to +expected+.
+  def assert_headers_equal(expected, actual)
+    actual = actual.to_s
+    __field_order.each do |field|
+      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
+
+      assert_equal expected[offset, length], actual[offset, length], message
+    end
+  end
+
+  def assert_modes_equal(expected, actual, filename)
+    return if Minitar.windows?
+
+    assert_equal mode_string(expected), mode_string(actual), "Mode for #{filename} does not match"
+  end
+
+  def build_raw_header(type, name, prefix, size, mode, link_name = "") =
+    [
+      name, mode, z(octal(nil, 7)), z(octal(nil, 7)), size, z(octal(0, 11)),
+      BLANK_CHECKSUM, type, asciiz(link_name, 100), USTAR, DOUBLE_ZERO, asciiz("", 32),
+      asciiz("", 32), z(octal(nil, 7)), z(octal(nil, 7)), prefix
+    ].join.bytes.to_a.pack("C100C8C8C8C12C12C8CC100C6C2C32C32C8C8C155").then {
+      "#{_1}#{"\0" * (512 - _1.bytesize)}"
+    }.tap { assert_equal 512, _1.bytesize }
+
+  def build_header(type, name, prefix, size, mode, link_name = "") =
+    build_raw_header(
+      type,
+      asciiz(name, 100),
+      asciiz(prefix, 155),
+      z(octal(size, 11)),
+      z(octal(mode, 7)),
+      asciiz(link_name, 100)
+    )
+
+  def build_tar_file_header(name, prefix, mode, size) =
+    build_header("0", name, prefix, size, mode).then {
+      update_header_checksum(_1)
+    }
+
+  def build_tar_dir_header(name, prefix, mode) =
+    build_header("5", name, prefix, 0, mode).then {
+      update_header_checksum(_1)
+    }
+
+  def build_tar_symlink_header(name, prefix, mode, target) =
+    build_header("2", name, prefix, 0, mode, target).then {
+      update_header_checksum(_1)
+    }
+
+  def build_tar_pax_header(name, prefix, content_size) =
+    build_header("x", name, prefix, content_size, 0o644).then {
+      update_header_checksum(_1)
+    }
+
+  def update_header_checksum(header) =
+    header.tap { |h|
+      checksum = __fields["checksum"]
+      h[checksum.offset, checksum.length] =
+        h.unpack("C*")
+          .inject(:+)
+          .then { octal(_1, 6) }
+          .then { z(_1) }
+          .then { sp(_1) }
+    }
+
+  def octal(n, pad_size) = n.nil? ? "\0" * pad_size : "%0#{pad_size}o" % n
+
+  def asciiz(str, size) = "#{str}#{"\0" * (size - str.bytesize)}"
+
+  def sp(s) = "#{s} "
+
+  def z(s) = "#{s}\0"
+
+  def mode_string(value) = "%04o" % (value & 0o777)
+
+  def __field_order = FIELD_ORDER
+
+  def __fields = FIELDS
+
+  FIELD_ORDER = []
+  private_constant :FIELD_ORDER
+
+  FIELDS = {}
+  private_constant :FIELDS
+
+  Field = Struct.new(:name, :offset, :length)
+  private_constant :Field
+
+  BLANK_CHECKSUM = (" " * 8).freeze
+  private_constant :BLANK_CHECKSUM
+
+  DOUBLE_ZERO = "00"
+  private_constant :DOUBLE_ZERO
+
+  NULL_100 = ("\0" * 100).freeze
+  private_constant :NULL_100
+
+  USTAR = "ustar\0"
+  private_constant :USTAR
+
+  fields = [
+    ["name", 100], ["mode", 8], ["uid", 8], ["gid", 8], ["size", 12], ["mtime", 12],
+    ["checksum", 8], ["typeflag", 1], ["linkname", 100], ["magic", 6], ["version", 2],
+    ["uname", 32], ["gname", 32], ["devmajor", 8], ["devminor", 8], ["prefix", 155]
+  ]
+  offset = 0
+
+  fields.each do |(name, length)|
+    FIELDS[name] = Field.new(name, offset, length)
+    FIELD_ORDER << name
+    offset += length
+  end
+
+  Minitest::Test.send(:include, self)
+end

data/test/support/minitar_test_helpers/tarball.rb

@@ -0,0 +1,324 @@
+# frozen_string_literal: true
+
+require "open3"
+
+# Test assertions and helpers for working with tarballs.
+#
+# Includes Minitar in-memory and on-disk operations and GNU tar helpers.
+module Minitar::TestHelpers::Tarball
+  private
+
+  GNU_TAR = %w[tar gtar].find { |program|
+    path = `bash -c "command -v '#{program}'"`.chomp
+
+    if path.empty?
+      false
+    else
+      version = `#{program} --version`.chomp
+      version =~ /\(GNU tar\)|Free Software Foundation/
+    end
+  }.freeze
+
+  # Given the +original_files+ file hash (input to +create_tar_string+) and the
+  # +extracted_files+ file has (output from +extract_tar_string+), ensures that the tar
+  # structure is preserved, including checking for possible regression of issue 62.
+  #
+  # Such a regression would result in a directory like <tt>>/b/c.txt</tt> looking like
+  # <tt>a/b/a/b/c.txt</tt> (but only for long filenames).
+  def assert_tar_structure_preserved(original_files, extracted_files)
+    assert_equal original_files.length, extracted_files.length, "File counts do not match"
+
+    original_paths = original_files.keys.sort
+    extracted_paths = extracted_files.keys.sort
+
+    assert_equal original_paths, extracted_paths, "Complete file paths should match exactly"
+
+    original_files.each do |filename, content|
+      assert extracted_files.key?(filename), "File #{filename} should be extracted"
+
+      assert_equal content, extracted_files[filename], "Content should be preserved for #{filename}"
+
+      next unless filename.include?("/")
+
+      dirname, basename = File.split(filename)
+      bad_pattern = File.join(dirname, dirname, basename)
+
+      duplicated_paths = extracted_paths.select { |path| path == bad_pattern }
+
+      refute duplicated_paths.any?,
+        "Regression of #62, path duplication on extraction! " \
+        "Original: #{filename}, " \
+        "Bad pattern found: #{bad_pattern}, " \
+        "All extracted paths: #{extracted_paths}"
+    end
+  end
+
+  # Create a tarball string from the +file_hash+ (<tt>{filename => content}</tt>).
+  def create_tar_string(file_hash) =
+    StringIO.new.tap { |io|
+      Minitar::Output.open(io) do |output|
+        file_hash.each do |filename, content|
+          next if content.nil?
+          Minitar.pack_as_file(filename, content.to_s.dup, output)
+        end
+      end
+    }.string
+
+  # Extract a hash of <tt>{filename => content}</tt> from the +tar_data+. Directories are
+  # skipped.
+  def extract_tar_string(tar_data) =
+    {}.tap { |files|
+      Minitar::Input.open(StringIO.new(tar_data)) do |input|
+        input.each do |entry|
+          next if entry.directory?
+          files[entry.full_name] = entry.read
+        end
+      end
+    }
+
+  # Create a tarball string from the +file_hash+ (<tt>{filename => content}</tt>) provided
+  # and immediately extracts a hash of <tt>{filename => content}</tt> from the tarball
+  # string. Directories are skipped.
+  def roundtrip_tar_string(file_hash) =
+    create_tar_string(file_hash).then { extract_tar_string(_1) }
+
+  def has_gnu_tar? = !GNU_TAR&.empty?
+
+  Workspace = Struct.new(:tmpdir, :source, :target, :tarball, :files, keyword_init: true)
+  private_constant :Workspace
+
+  # Prepare a workspace for a file-based test.
+  def workspace(with_files: nil)
+    raise "Workspace requires a block" unless block_given?
+    raise "No nested workspace permitted" if @workspace
+
+    tmpdir =
+      if Pathname.respond_to?(:mktmpdir)
+        Pathname.mktmpdir
+      else
+        Pathname(Dir.mktmpdir)
+      end
+
+    source = tmpdir.join("source")
+    target = tmpdir.join("target")
+    tarball = tmpdir.join("test.tar")
+
+    @workspace = Workspace.new(
+      tmpdir: tmpdir,
+      source: source,
+      target: target,
+      tarball: tarball
+    )
+
+    source.mkpath
+    target.mkpath
+
+    prepare_workspace(with_files:) if with_files
+
+    yield @workspace
+  ensure
+    tmpdir&.rmtree
+    @workspace = nil
+  end
+
+  def prepare_workspace(with_files:)
+    missing_workspace!
+
+    raise "Missing workspace" unless @workspace
+    raise "Files already prepared" if @workspace.files
+
+    @workspace.files = with_files.each_pair do
+      full_path = @workspace.source.join(_1)
+
+      if _2.nil?
+        full_path.mkpath
+
+        assert full_path.directory?, "#{full_path} should be created as a directory"
+      else
+        full_path.dirname.mkpath
+        full_path.write(_2)
+
+        assert full_path.file?, "#{full_path} should be created as a file"
+      end
+    end
+  end
+
+  def gnu_tar_create_in_workspace
+    missing_workspace!
+
+    __gnu_tar(:create)
+
+    assert @workspace.tarball.file?, "Workspace tarball not created by GNU tar"
+    assert @workspace.tarball.size > 0, "Workspace tarball should not be empty"
+  end
+
+  def gnu_tar_extract_in_workspace
+    missing_workspace!
+
+    assert @workspace.tarball.file?, "Workspace tarball not present for extraction"
+    assert @workspace.tarball.size > 0, "Workspace tarball should not be empty"
+
+    __gnu_tar(:extract)
+  end
+
+  def gnu_tar_list_in_workspace
+    missing_workspace!
+
+    assert @workspace.tarball.file?, "Workspace tarball not present for extraction"
+    assert @workspace.tarball.size > 0, "Workspace tarball should not be empty"
+
+    __gnu_tar(:list).strip.split($/)
+  end
+
+  def minitar_pack_in_workspace
+    missing_workspace!
+
+    @workspace.tarball.open("wb") do |tar_io|
+      Dir.chdir(@workspace.source) do
+        Minitar.pack(".", tar_io)
+      end
+    end
+
+    assert @workspace.tarball.file?, "Workspace tarball not created by Minitar.pack"
+    assert @workspace.tarball.size > 0, "Workspace tarball should not be empty"
+  end
+
+  def minitar_unpack_in_workspace
+    missing_workspace!
+
+    assert @workspace.tarball.file?, "Workspace tarball not present for extraction"
+    assert @workspace.tarball.size > 0, "Workspace tarball should not be empty"
+
+    @workspace.tarball.open("rb") do
+      Minitar.unpack(_1, @workspace.target)
+    end
+  end
+
+  def minitar_writer_create_in_workspace
+    missing_workspace!
+
+    @workspace.tarball.open("wb") do |tar_io|
+      Minitar::Writer.open(tar_io) do |writer|
+        @workspace.files.each_pair do |name, content|
+          full_path = @workspace.source.join(name)
+          stat = full_path.stat
+
+          writer.add_file_simple(name, mode: stat.mode, size: stat.size) do
+            _1.write(content)
+          end
+        end
+      end
+    end
+
+    assert @workspace.tarball.file?, "Workspace tarball not created by Minitar::Writer"
+    assert @workspace.tarball.size > 0, "Workspace tarball should not be empty"
+  end
+
+  def assert_files_extracted_in_workspace
+    missing_workspace!
+
+    @workspace.files.each_pair do
+      target = @workspace.target.join(_1)
+      assert target.exist?, "#{_1.inspect} does not exist"
+
+      if _2.nil?
+        assert target.directory?, "#{_1} is not a directory"
+      else
+        assert_equal _2, @workspace.target.join(_1).read, "#{_1} content does not match"
+      end
+    end
+  end
+
+  def refute_file_path_duplication_in_workspace
+    missing_workspace!
+
+    @workspace.files.each_key do
+      next unless _1.include?("/")
+
+      dir, filename = Pathname(_1).split
+      dup_path = dir.join(dir, filename)
+      refute @workspace.target.join(dup_path).exist?,
+        "No path duplication should occur: #{dup_path}"
+    end
+  end
+
+  def assert_extracted_files_match_source_files_in_workspace
+    missing_workspace!
+
+    source_files = __collect_relative_paths(@workspace.source)
+    target_files = __collect_relative_paths(@workspace.target)
+
+    assert_equal source_files, target_files,
+      "Complete directory structure should match exactly"
+  end
+
+  def __collect_relative_paths(dir)
+    return [] unless dir.directory?
+
+    dir.glob("**/*").map { _1.relative_path_from(dir).to_s }.sort
+  end
+
+  def assert_file_modes_match_in_workspace
+    missing_workspace!
+
+    return if Minitar.windows?
+
+    @workspace.files.each_key do |file_path|
+      source = @workspace.source.join(file_path)
+      target = @workspace.target.join(file_path)
+
+      source_mode = source.stat.mode & 0o777
+      target_mode = target.stat.mode & 0o777
+
+      assert_modes_equal source_mode, target_mode, file_path
+    end
+  end
+
+  def missing_workspace!
+    raise "Missing workspace" unless defined?(@workspace)
+  end
+
+  def __gnu_tar(action)
+    missing_workspace!
+
+    cmd = [GNU_TAR]
+    cmd.push("--force-local") if Minitar.windows?
+
+    case action
+    when :create
+      cmd.push("-cf", @workspace.tarball.to_s, "-C", @workspace.source.to_s, ".")
+    when :extract
+      cmd.push("-xf", @workspace.tarball.to_s, "-C", @workspace.target.to_s)
+    when :list
+      cmd.push("-tf", @workspace.tarball.to_s)
+    end
+
+    stdout_str = ""
+    stderr_str = ""
+    status = nil
+
+    Open3.popen3(*cmd) do |stdin, stdout, stderr, wait_thread|
+      stdin.close
+      out_t = Thread.new { stdout.read }
+      err_t = Thread.new { stderr.read }
+      stdout_str = out_t.value.to_s
+      stderr_str = err_t.value.to_s
+      status = wait_thread.value
+    end
+
+    unless status.success?
+      warn stdout_str unless stdout_str.empty?
+      warn stderr_str unless stderr_str.empty?
+
+      if status.exited?
+        raise "command #{cmd.join(" ")} failed (exit status: #{status.exitstatus})"
+      else
+        raise "command #{cmd.join(" ")} failed (status: #{status.inspect})"
+      end
+    end
+
+    stdout_str
+  end
+
+  Minitest::Test.send(:include, self)
+end

data/test/support/minitar_test_helpers.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Minitar::TestHelpers
+  TIME_2004 = Time.utc(2004).to_i
+
+  BOUNDARY_SCENARIOS = {
+    ("a" * 99) => "99 chars content",
+    ("a" * 100) => "100 chars content",
+    ("a" * 101) => "101 chars content",
+    ("a" * 102) => "102 chars content",
+    "dir/#{"a" * 96}" => "nested path 100 total content",
+    "dir/#{"a" * 97}" => "nested path 101 total content",
+    "nested/#{"d" * 93}" => "nested 100 total content",
+    "nested/#{"e" * 94}" => "nested 101 total content"
+  }.freeze
+
+  MIXED_FILENAME_SCENARIOS = {
+    "short.txt" => "short content",
+    "medium_length_filename_under_100_chars.txt" => "medium content",
+    "dir1/medium_filename.js" => "medium nested content",
+    "#{"x" * 120}.txt" => "long content",
+    "nested/dir/#{"y" * 110}.css" => "long nested content"
+  }.freeze
+
+  VERY_LONG_FILENAME_SCENARIOS = {
+    "#{"f" * 180}.data" => "180 char filename content",
+    "#{"g" * 200}.json" => "200 char filename content",
+    "nested/path/#{"h" * 150}.css" => "nested long filename content",
+    "deep/nested/structure/#{"i" * 170}.html" => "deeply nested long content",
+    "project/src/main/#{"j" * 160}.java" => "project structure long content"
+  }.freeze
+
+  private
+
+  Minitest::Test.send(:include, self)
+end

data/test/test_filename_boundary_conditions.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "minitest_helper"
+
+class TestFilenameBoundaryConditions < Minitest::Test
+  SCENARIOS = [99, 100, 101, 102, 154, 155, 156].each_with_object({}) { |len, map|
+    name = "a" * len
+    content = "#{len} chars content"
+    map[name] = content
+
+    define_method :"test_single_file_#{len}_chars" do
+      file_map = {name => content}
+      files = roundtrip_tar_string(file_map)
+      assert_tar_structure_preserved file_map, files
+    end
+
+    name = "dir/#{"a" * (len - 4)}"
+    content = "dir/ #{len - 4} chars content: #{len} total chars"
+    map[name] = content
+
+    define_method :"test_nested_file_total_#{len}_chars" do
+      file_map = {name => content}
+      files = roundtrip_tar_string(file_map)
+      assert_tar_structure_preserved file_map, files
+    end
+  }
+
+  posix_scenarios = [155, 156].each_with_object({}) { |len, map|
+    name = "a" * len
+    content = "#{len} chars content"
+    map[name] = content
+
+    define_method :"test_posix_boundary_#{len}_chars" do
+      file_map = {name => content}
+      files = roundtrip_tar_string(file_map)
+      assert_tar_structure_preserved file_map, files
+    end
+  }
+
+  posix_total_scenarios = {155 => 100, 165 => 110}.each_with_object({}) { |(k, v), map|
+    name = "prefix_#{"a" * (k - 7)}/name_#{"a" * (v - 5)}"
+    content = "prefix #{k} name #{v} chars"
+    map[name] = content
+
+    define_method :"test_posix_total_boundary_#{k + v + 1}_chars" do
+      file_map = {name => content}
+      files = roundtrip_tar_string(file_map)
+      assert_tar_structure_preserved file_map, files
+    end
+  }
+
+  name = "very_long_component_name_with_many_characters"
+    .then { _1 * 3 }
+    .then { [_1] }
+    .then { _1 * 8 }
+    .then { _1.join("/") }
+    .then { "#{_1}/final_file_with_long_name.txt" }
+  content = "Content for very long path"
+
+  define_method :test_long_near_system_limits do
+    file_map = {name => content}
+    files = roundtrip_tar_string(file_map)
+    assert_tar_structure_preserved file_map, files
+  end
+
+  SCENARIOS[name] = content
+
+  SCENARIOS.merge!(posix_scenarios, posix_total_scenarios)
+
+  def test_full_scenario_in_archive
+    files = roundtrip_tar_string(SCENARIOS)
+    assert_tar_structure_preserved(SCENARIOS, files)
+  end
+end

data/test/test_gnu_tar_compatibility.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "minitest_helper"
+
+class TestGnuTarCompatibility < Minitest::Test
+  def setup
+    skip "GNU tar not available" unless has_gnu_tar?
+  end
+
+  def test_roundtrip_gnu_tar_cf_minitar_unpack
+    # Use mixed filename scenarios from shared test utilities for comprehensive testing
+    files = MIXED_FILENAME_SCENARIOS.dup
+    # Add one very long filename to test GNU extension compatibility
+    files[VERY_LONG_FILENAME_SCENARIOS.keys.first] = VERY_LONG_FILENAME_SCENARIOS.values.first
+
+    workspace with_files: files do
+      gnu_tar_create_in_workspace
+      minitar_unpack_in_workspace
+
+      assert_files_extracted_in_workspace
+      refute_file_path_duplication_in_workspace
+    end
+  end
+
+  def test_roundtrip_minitar_pack_gnu_tar_xf
+    # Use different mixed scenarios for the reverse roundtrip test
+    files = MIXED_FILENAME_SCENARIOS.dup
+    # Add a different very long filename to test GNU extension compatibility
+    files[VERY_LONG_FILENAME_SCENARIOS.keys.last] = VERY_LONG_FILENAME_SCENARIOS.values.last
+
+    workspace with_files: files do
+      gnu_tar_create_in_workspace
+      minitar_unpack_in_workspace
+
+      assert_files_extracted_in_workspace
+    end
+  end
+
+  def test_roundtrip_gnu_tar_cf_minitar_unpack_mixed_filenames
+    # Test GNU tar create → Minitar extract with mixed filename lengths
+    files = {
+      "short.txt" => "short content",
+      "medium_length_filename.js" => "medium content",
+      "#{"f" * 120}.css" => "long content",
+      "dir/#{"g" * 130}.html" => "nested long content"
+    }
+
+    workspace with_files: files do
+      gnu_tar_create_in_workspace
+      minitar_unpack_in_workspace
+
+      assert_files_extracted_in_workspace
+      refute_file_path_duplication_in_workspace
+    end
+  end
+
+  def test_minitar_writer_gnu_tar_xf_with_long_filenames
+    # Test Minitar create → GNU tar extract with long filenames
+    files = {
+      "#{"j" * 120}.txt" => "content for 120 char filename",
+      "nested/path/#{"k" * 110}.js" => "content for nested long filename",
+      "#{"m" * 200}.html" => "content for very long filename",
+      "regular_file.md" => "regular file content"
+    }
+
+    workspace with_files: files do
+      minitar_writer_create_in_workspace
+      gnu_tar_extract_in_workspace
+      assert_files_extracted_in_workspace
+    end
+  end
+
+  def test_gnu_tar_list_compatibility_with_long_filenames
+    # Test that GNU tar can list files created by Minitar with long filenames
+    files = {
+      "#{"f" * 180}.data" => "gnu extension test content"
+    }
+
+    workspace with_files: files do
+      minitar_writer_create_in_workspace
+
+      list_output = gnu_tar_list_in_workspace
+      files.each_key do |name|
+        assert list_output.find { _1 == name },
+          "#{name} not present in GNU tar list output: #{list_output}"
+      end
+
+      gnu_tar_extract_in_workspace
+      assert_files_extracted_in_workspace
+    end
+  end
+end