minitar 1.0.2 → 1.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (57) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +326 -0
  3. data/CODE_OF_CONDUCT.md +167 -0
  4. data/CONTRIBUTING.md +312 -0
  5. data/CONTRIBUTORS.md +27 -0
  6. data/LICENCE.md +42 -0
  7. data/Manifest.txt +31 -8
  8. data/README.md +82 -0
  9. data/Rakefile +74 -20
  10. data/SECURITY.md +54 -0
  11. data/lib/minitar/input.rb +242 -189
  12. data/lib/minitar/output.rb +72 -64
  13. data/lib/minitar/pax_header.rb +111 -0
  14. data/lib/minitar/posix_header.rb +276 -239
  15. data/lib/minitar/reader.rb +226 -231
  16. data/lib/minitar/version.rb +5 -0
  17. data/lib/minitar/writer.rb +246 -299
  18. data/lib/minitar.rb +134 -115
  19. data/licenses/bsdl.txt +20 -0
  20. data/licenses/dco.txt +34 -0
  21. data/licenses/ruby.txt +52 -0
  22. data/test/fixtures/issue_46.tar.gz +0 -0
  23. data/test/fixtures/issue_62.tar.gz +0 -0
  24. data/test/fixtures/tar_input.tgz +0 -0
  25. data/test/fixtures/test_input_non_strict_octal.tgz +0 -0
  26. data/test/fixtures/test_input_relative.tgz +0 -0
  27. data/test/fixtures/test_input_space_octal.tgz +0 -0
  28. data/test/fixtures/test_minitar.tar.gz +0 -0
  29. data/test/minitest_helper.rb +12 -1
  30. data/test/support/minitar_test_helpers/fixtures.rb +38 -0
  31. data/test/support/minitar_test_helpers/header.rb +130 -0
  32. data/test/support/minitar_test_helpers/tarball.rb +324 -0
  33. data/test/support/minitar_test_helpers.rb +36 -0
  34. data/test/test_filename_boundary_conditions.rb +74 -0
  35. data/test/test_gnu_tar_compatibility.rb +92 -0
  36. data/test/test_integration_pack_unpack_cycle.rb +38 -0
  37. data/test/test_issue_46.rb +5 -23
  38. data/test/test_issue_62.rb +50 -0
  39. data/test/test_minitar.rb +168 -39
  40. data/test/test_path_normalization.rb +170 -0
  41. data/test/test_pax_header.rb +104 -0
  42. data/test/test_pax_support.rb +66 -0
  43. data/test/test_tar_header.rb +289 -75
  44. data/test/test_tar_input.rb +14 -61
  45. data/test/test_tar_output.rb +7 -9
  46. data/test/test_tar_reader.rb +17 -18
  47. data/test/test_tar_writer.rb +105 -126
  48. data/test/test_windows_extraction.rb +121 -0
  49. metadata +108 -95
  50. data/Code-of-Conduct.md +0 -128
  51. data/Contributing.md +0 -94
  52. data/History.md +0 -236
  53. data/Licence.md +0 -15
  54. data/README.rdoc +0 -92
  55. data/docs/bsdl.txt +0 -19
  56. data/docs/ruby.txt +0 -56
  57. data/test/support/tar_test_helpers.rb +0 -134
data/test/test_minitar.rb CHANGED
@@ -1,60 +1,189 @@
1
- #!/usr/bin/env ruby
1
+ # frozen_string_literal: true
2
2
 
3
- require "minitar"
4
3
  require "minitest_helper"
5
- require "zlib"
6
4
 
7
5
  class TestMinitar < Minitest::Test
8
- FILE_2004 = Time.utc(2004).to_i
6
+ SCENARIO = {
7
+ "path" => nil,
8
+ "test" => "test",
9
+ "extra/test" => "extra/test",
10
+ "empty2004" => {mtime: TIME_2004, mode: 0o755, data: ""},
11
+ "notime" => {mtime: nil, data: "notime"}
12
+ }
9
13
 
10
- def test_pack_as_file
11
- input = [
12
- ["path", nil],
13
- ["test", "test"],
14
- ["extra/test", "extra/test"],
15
- [{name: "empty2004", mtime: FILE_2004, mode: 0o755}, ""]
16
- ]
14
+ def test_minitar_open_r
15
+ count = 0
17
16
 
18
- writer = StringIO.new
19
- Minitar::Output.open(writer) do |out_stream|
20
- input.each do |(name, data)|
21
- Minitar.pack_as_file(name, data, out_stream)
17
+ open_fixture("test_minitar") do |fixture|
18
+ Minitar.open(fixture, "r") do |stream|
19
+ stream.each do |entry|
20
+ assert_kind_of Minitar::Reader::EntryStream, entry
21
+
22
+ assert SCENARIO.has_key?(entry.name), "#{entry.name} not expected"
23
+
24
+ expected = SCENARIO[entry.name]
25
+
26
+ case expected
27
+ when nil
28
+ assert_equal 0, entry.size
29
+ assert_modes_equal 0o755, entry.mode, entry.name
30
+ assert entry.directory?, "#{entry.name} should be a directory"
31
+ when String
32
+ assert_equal expected.length, entry.size, entry.name
33
+ assert_modes_equal 0o644, entry.mode, entry.name
34
+ assert entry.file?, "#{entry.name} should be a file"
35
+
36
+ if entry.size.zero?
37
+ assert_nil entry.read
38
+ else
39
+ assert_equal expected, entry.read
40
+ end
41
+ when Hash
42
+ if expected[:data].nil?
43
+ assert_equal 0, entry.size
44
+ assert_modes_equal (expected[:mode] || 0o755), entry.mode, entry.name
45
+ assert entry.directory?, "#{entry.name} should be a directory"
46
+ else
47
+ assert_equal expected[:data].length, entry.size
48
+ assert_modes_equal (expected[:mode] || 0o644), entry.mode, entry.name
49
+ assert entry.file?, "#{entry.name} should be a file"
50
+ end
51
+
52
+ assert_equal expected[:mtime], entry.mtime if expected[:mtime]
53
+
54
+ if entry.size.zero?
55
+ assert_nil entry.read
56
+ else
57
+ assert_equal expected[:data], entry.read
58
+ end
59
+ end
60
+
61
+ count += 1
62
+ end
22
63
  end
23
64
  end
24
65
 
25
- expected = [
26
- {name: "path", size: 0, mode: 0o755},
27
- {name: "test", size: 4, mode: 0o644, data: "test"},
28
- {name: "extra/test", size: 10, mode: 0o0644, data: "extra/test"},
29
- {name: "empty2004", size: 0, mode: 0o755, mtime: FILE_2004, nil: true}
30
- ]
66
+ assert_equal SCENARIO.size, count
67
+ end
31
68
 
32
- count = 0
33
- reader = StringIO.new(writer.string)
34
- Minitar.open(reader) do |stream|
35
- stream.each.with_index do |entry, i|
36
- assert_kind_of Minitar::Reader::EntryStream, entry
69
+ def test_minitar_open_w
70
+ events = []
37
71
 
38
- assert_equal expected[i][:name], entry.name
39
- assert_equal expected[i][:size], entry.size
40
- assert_equal expected[i][:mode], entry.mode
72
+ writer = StringIO.new
73
+ Minitar.open(writer, "w") do |stream|
74
+ SCENARIO.each_pair do |name, data|
75
+ name, data =
76
+ if data.is_a?(Hash)
77
+ name = data.merge(name: name)
78
+ [name, name.delete(:data)]
79
+ else
80
+ [name, data]
81
+ end
41
82
 
42
- if expected[i].key?(:mtime)
43
- assert_equal expected[i][:mtime], entry.mtime
83
+ Minitar.pack_as_file(name, data, stream) do |op, entry_name, stats|
84
+ events << {
85
+ name: name,
86
+ data: data,
87
+ op: op,
88
+ entry_name: entry_name,
89
+ stats: stats
90
+ }
44
91
  end
92
+ end
93
+ end
45
94
 
46
- if expected[i].key?(:data)
47
- assert_equal expected[i][:data], entry.read
48
- end
95
+ assert_equal 5120, writer.string.length
49
96
 
50
- if expected[i].key?(:nil)
51
- assert_nil entry.read
52
- end
97
+ events.each do |event|
98
+ if event[:name].is_a?(Hash)
99
+ assert_equal event[:name][:name], event[:entry_name]
100
+ else
101
+ assert_equal event[:name], event[:entry_name]
102
+ end
53
103
 
54
- count += 1
104
+ case [event[:op], event[:entry_name]]
105
+ in [:dir, "path"]
106
+ assert_equal 0, event[:stats][:size]
107
+ assert_equal 493, event[:stats][:mode]
108
+
109
+ in [:file_start, "test"]
110
+ assert_equal 4, event[:stats][:size]
111
+ assert_equal 420, event[:stats][:mode]
112
+ assert_equal 4, event[:stats][:current]
113
+ assert_equal 4, event[:stats][:currinc]
114
+ assert_equal "test", event[:data]
115
+ in [:file_progress, "test"]
116
+ assert_equal 4, event[:stats][:size]
117
+ assert_equal 420, event[:stats][:mode]
118
+ assert_equal 4, event[:stats][:current]
119
+ assert_equal 4, event[:stats][:currinc]
120
+ assert_equal "test", event[:data]
121
+ in [:file_done, "test"]
122
+ assert_equal 4, event[:stats][:size]
123
+ assert_equal 420, event[:stats][:mode]
124
+ assert_equal 4, event[:stats][:current]
125
+ assert_equal 4, event[:stats][:currinc]
126
+ assert_equal "test", event[:data]
127
+
128
+ in [:file_start, "extra/test"]
129
+ assert_equal 10, event[:stats][:size]
130
+ assert_equal 420, event[:stats][:mode]
131
+ assert_equal 10, event[:stats][:current]
132
+ assert_equal 10, event[:stats][:currinc]
133
+ assert_equal "extra/test", event[:data]
134
+ in [:file_progress, "extra/test"]
135
+ assert_equal 10, event[:stats][:size]
136
+ assert_equal 420, event[:stats][:mode]
137
+ assert_equal 10, event[:stats][:current]
138
+ assert_equal 10, event[:stats][:currinc]
139
+ assert_equal "extra/test", event[:data]
140
+ in [:file_done, "extra/test"]
141
+ assert_equal 10, event[:stats][:size]
142
+ assert_equal 420, event[:stats][:mode]
143
+ assert_equal 10, event[:stats][:current]
144
+ assert_equal 10, event[:stats][:currinc]
145
+ assert_equal "extra/test", event[:data]
146
+
147
+ in [:file_start, "empty2004"]
148
+ assert_equal 0, event[:stats][:size]
149
+ assert_equal 493, event[:stats][:mode]
150
+ assert_equal 0, event[:stats][:current]
151
+ assert_equal 1072915200, event[:stats][:mtime]
152
+ assert_equal "", event[:data]
153
+ in [:file_done, "empty2004"]
154
+ assert_equal 0, event[:stats][:size]
155
+ assert_equal 493, event[:stats][:mode]
156
+ assert_equal 0, event[:stats][:current]
157
+ assert_equal 1072915200, event[:stats][:mtime]
158
+ assert_equal "", event[:data]
159
+
160
+ in [:file_start, "notime"]
161
+ assert_equal 6, event[:stats][:size]
162
+ assert_equal 420, event[:stats][:mode]
163
+ assert_equal 6, event[:stats][:current]
164
+ assert_equal 6, event[:stats][:currinc]
165
+ assert_equal "notime", event[:data]
166
+ in [:file_progress, "notime"]
167
+ assert_equal 6, event[:stats][:size]
168
+ assert_equal 420, event[:stats][:mode]
169
+ assert_equal 6, event[:stats][:current]
170
+ assert_equal 6, event[:stats][:currinc]
171
+ assert_equal "notime", event[:data]
172
+ in [:file_done, "notime"]
173
+ assert_equal 6, event[:stats][:size]
174
+ assert_equal 420, event[:stats][:mode]
175
+ assert_equal 6, event[:stats][:current]
176
+ assert_equal 6, event[:stats][:currinc]
177
+ assert_equal "notime", event[:data]
178
+ else
179
+ raise "Unknown operation #{event[:op].inspect} for #{event[:entry_name].inspect}"
55
180
  end
56
181
  end
182
+ end
57
183
 
58
- assert_equal expected.size, count
184
+ def test_minitar_x
185
+ assert_raises(ArgumentError) do
186
+ Minitar.open("foo", "x")
187
+ end
59
188
  end
60
189
  end
@@ -0,0 +1,170 @@
1
+ # frozen_string_literal: true
2
+
3
+ require "minitest_helper"
4
+
5
+ # Tests the private name normalization and relative path checks. These run on every
6
+ # platform because the alternate separator is passed as a parameter.
7
+ class TestPathNormalization < Minitest::Test
8
+ def input
9
+ @input ||= Minitar::Input.allocate
10
+ end
11
+
12
+ def normalize(name, alt_separator)
13
+ input.send(:normalize_entry_name, name, alt_separator)
14
+ end
15
+
16
+ def check(name)
17
+ input.send(:check_relative_path!, name)
18
+ end
19
+
20
+ # --- check_relative_path! (all platforms) ---
21
+
22
+ def test_check_rejects_parent_components
23
+ [
24
+ "..", "../x", "a/..", "a/../b", "a/../../x", "a/b/.."
25
+ ].each do |name|
26
+ assert_raises(Minitar::SecureRelativePathError, name) { check(name) }
27
+ end
28
+ end
29
+
30
+ def test_check_accepts_dots_within_a_component
31
+ [
32
+ "dirname../x", "..dirname/x", "a/dirname..", "a/..b/c", "...", "a/.../b", "a..b/c",
33
+ ".hidden/x", "a/./b"
34
+ ].each do |name|
35
+ check(name)
36
+ end
37
+
38
+ pass
39
+ end
40
+
41
+ # --- nil alt_separator (POSIX): nothing but squeeze ---
42
+
43
+ def test_nil_separator_keeps_backslashes_literal
44
+ [
45
+ "..\\x", "a\\..\\..\\x", "a\\..\\b", "..\\/x", "C:\\x", "C:x", "C:/x",
46
+ "\\\\host\\share\\x", "a\\b", "a.txt:stream", "...\\x", "dirname..\\x", "a. \\x"
47
+ ].each do |name|
48
+ assert_equal name, normalize(name, nil)
49
+ check(name)
50
+ end
51
+ end
52
+
53
+ def test_nil_separator_squeezes_slashes
54
+ assert_equal "a/b/c", normalize("a//b///c", nil)
55
+ end
56
+
57
+ # --- "\\" alt_separator (Windows semantics) ---
58
+
59
+ def test_backslash_separator_rejects_traversal
60
+ [
61
+ "..\\x", "a\\..\\..\\x", "a\\..\\b", "..\\/x", "../x", "a/..\\x", "a\\..",
62
+ "\\..\\x", "\\dir\\..\\x", "dir\\..\\..\\x"
63
+ ].each do |name|
64
+ assert_raises(Minitar::SecureRelativePathError, name) {
65
+ check(normalize(name, "\\"))
66
+ }
67
+ end
68
+ end
69
+
70
+ def test_backslash_separator_rejects_dot_only_components
71
+ [
72
+ "...\\x", "....\\x", "a\\...\\b", "a\\...", ".. \\x", ".. .\\x", "a\\.. "
73
+ ].each do |name|
74
+ assert_raises(Minitar::UnsafeFileNameError, name) { normalize(name, "\\") }
75
+ end
76
+ end
77
+
78
+ def test_backslash_separator_leaves_dot_and_dotdot_components_to_the_path_check
79
+ assert_equal "a/./b", normalize("a\\.\\b", "\\")
80
+ assert_equal "a/../b", normalize("a\\..\\b", "\\")
81
+ end
82
+
83
+ def test_backslash_separator_preserves_interior_dots
84
+ [
85
+ "a..b..c.txt", "a..b\\c.txt", "..a\\c.txt"
86
+ ].each do |name|
87
+ assert_equal name.tr("\\", "/"), normalize(name, "\\")
88
+ end
89
+ end
90
+
91
+ def test_backslash_separator_rejects_trailing_dots_and_spaces
92
+ [
93
+ "dirname..\\x", "dir.\\x", "dir \\x", "a\\file.", "a\\file ", "foo...\\x"
94
+ ].each do |name|
95
+ assert_raises(Minitar::UnsafeFileNameError, name) { normalize(name, "\\") }
96
+ end
97
+ end
98
+
99
+ def test_backslash_separator_accepts_ordinary_dots
100
+ assert_equal "a/./b", normalize("a\\.\\b", "\\")
101
+ assert_equal "dir..name/.hidden/a.b.txt/", normalize("dir..name\\.hidden\\a.b.txt\\", "\\")
102
+ end
103
+
104
+ def test_backslash_separator_converts_and_squeezes
105
+ assert_equal "a/b", normalize("a\\b", "\\")
106
+ assert_equal "a/b/c/d", normalize("a\\\\b//c\\/d", "\\")
107
+ end
108
+
109
+ def test_backslash_separator_rejects_drive_names
110
+ [
111
+ "C:\\x", "C:x", "C:/x", "c:\\x", "C:", "a\\C:\\x"
112
+ ].each do |name|
113
+ assert_raises(Minitar::UnsafeFileNameError, name) { normalize(name, "\\") }
114
+ end
115
+ end
116
+
117
+ def test_backslash_separator_turns_unc_names_into_relative_paths
118
+ {
119
+ "\\\\host\\share\\x" => "/host/share/x",
120
+ "//host/share/x" => "/host/share/x",
121
+ "\\/host/share" => "/host/share",
122
+ "\\\\host" => "/host"
123
+ }.each do |name, expected|
124
+ assert_equal expected, normalize(name, "\\")
125
+ check(expected)
126
+ end
127
+ end
128
+
129
+ def test_backslash_separator_rejects_alternate_data_streams
130
+ [
131
+ "a.txt:stream", "dir/a.txt:stream:$DATA", "dir:x/a", "a\\b:s"
132
+ ].each do |name|
133
+ assert_raises(Minitar::UnsafeFileNameError, name) { normalize(name, "\\") }
134
+ end
135
+ end
136
+
137
+ def test_unsafe_file_name_error_is_a_minitar_error
138
+ assert_operator Minitar::UnsafeFileNameError, :<, Minitar::Error
139
+ end
140
+
141
+ # --- end-to-end on POSIX: guards against over-normalizing ---
142
+
143
+ def test_posix_extraction_keeps_backslash_names_literal
144
+ skip "POSIX only" if Minitar.windows_separator?
145
+
146
+ names = ["..\\x", "a\\..\\..\\x", "a\\b", "dirname../x"]
147
+ Dir.mktmpdir do |root|
148
+ dest = File.join(root, "dest")
149
+ Minitar.unpack(tar_with(names), dest)
150
+
151
+ assert_equal names.map { _1.sub(%r{/.*}, "") }.uniq.sort, Dir.children(dest).sort
152
+ assert_path_exists File.join(dest, "..\\x")
153
+ assert_path_exists File.join(dest, "dirname..", "x")
154
+ assert_equal ["dest"], Dir.children(root)
155
+ end
156
+ end
157
+
158
+ private
159
+
160
+ def tar_with(names)
161
+ io = StringIO.new(+"".b)
162
+ Minitar::Writer.open(io) do |w|
163
+ names.each do |name|
164
+ w.add_file_simple(name, mode: 0o644, size: 1) { _1.write("x") }
165
+ end
166
+ end
167
+ io.rewind
168
+ io
169
+ end
170
+ end
@@ -0,0 +1,104 @@
1
+ require "minitest_helper"
2
+
3
+ class TestPaxHeader < Minitest::Test
4
+ def test_from_stream_with_size_attribute
5
+ pax_content = "19 size=8614356715\n28 mtime=1749098832.3200000\n"
6
+ pax_header = create_pax_header_from_stream(pax_content)
7
+
8
+ assert_equal 8614356715, pax_header.size
9
+ assert_equal "1749098832.3200000", pax_header.attributes["mtime"]
10
+ end
11
+
12
+ def test_from_stream_without_size_attribute
13
+ pax_content = "28 mtime=1749098832.3200000\n27 path=some/long/path.txt\n"
14
+ pax_header = create_pax_header_from_stream(pax_content)
15
+
16
+ assert_nil pax_header.size
17
+ assert_equal "some/long/path.txt", pax_header.path
18
+ assert_equal 1749098832.32, pax_header.mtime
19
+ end
20
+
21
+ def test_parse_multiline_values
22
+ pax_content = "22 foo=one\ntwo\nthree\n\n12 bar=four\n"
23
+ pax_header = Minitar::PaxHeader.from_data(pax_content)
24
+ assert_equal "one\ntwo\nthree\n", pax_header.attributes["foo"]
25
+ assert_equal "four", pax_header.attributes["bar"]
26
+ end
27
+
28
+ def test_from_stream_with_invalid_header
29
+ header_data = build_tar_file_header("regular_file.txt", "", 0o644, 100)
30
+ io = StringIO.new(header_data)
31
+
32
+ posix_header = Minitar::PosixHeader.from_stream(io)
33
+ refute posix_header.pax_header?
34
+
35
+ assert_raises(ArgumentError, "Header must be a PAX header") do
36
+ Minitar::PaxHeader.from_stream(io, posix_header)
37
+ end
38
+ end
39
+
40
+ def test_parse_content_with_multiple_attributes
41
+ pax_content = "19 size=8614356715\n28 mtime=1749098832.3200000\n27 path=some/long/path.txt\n"
42
+
43
+ pax_header = Minitar::PaxHeader.from_data(pax_content)
44
+
45
+ assert_equal 8614356715, pax_header.size
46
+ assert_equal "some/long/path.txt", pax_header.path
47
+ assert_equal 1749098832.32, pax_header.mtime
48
+
49
+ # Check raw attributes
50
+ assert_equal "8614356715", pax_header.attributes["size"]
51
+ assert_equal "1749098832.3200000", pax_header.attributes["mtime"]
52
+ assert_equal "some/long/path.txt", pax_header.attributes["path"]
53
+ end
54
+
55
+ def test_parse_content_with_invalid_length_format
56
+ assert_raises(ArgumentError) do
57
+ Minitar::PaxHeader.from_data("19 size=8614356715\ninvalid line\n23 path=valid/path.txt\n")
58
+ end
59
+ end
60
+
61
+ def test_parse_content_with_oversized_record
62
+ assert_raises(ArgumentError) do
63
+ Minitar::PaxHeader.from_data("19 size=8614356715\n999 toolong=value\n")
64
+ end
65
+ end
66
+
67
+ def test_from_stream_strips_padding
68
+ pax_content = "19 size=8614356715\n"
69
+ pax_header = create_pax_header_from_stream(pax_content)
70
+
71
+ # Should parse only the actual content, ignoring padding
72
+ assert_equal 8614356715, pax_header.size
73
+ assert_equal 1, pax_header.attributes.size # Only one attribute parsed
74
+
75
+ # Should have parsed content correctly
76
+ assert_equal 1, pax_header.attributes.size
77
+ assert_equal "8614356715", pax_header.attributes["size"]
78
+ end
79
+
80
+ def test_attributes_accessor
81
+ pax_content = "19 size=8614356715\n23 custom=custom_value\n"
82
+ pax_header = Minitar::PaxHeader.from_data(pax_content)
83
+
84
+ assert_equal "8614356715", pax_header.attributes["size"]
85
+ assert_equal "custom_value", pax_header.attributes["custom"]
86
+ assert_nil pax_header.attributes["nonexistent"]
87
+ end
88
+
89
+ def test_pax_header_to_s
90
+ pax_header = Minitar::PaxHeader.new(size: "8614356715", mtime: "1749098832.3200000")
91
+ assert_equal "19 size=8614356715\n28 mtime=1749098832.3200000\n", pax_header.to_s
92
+ end
93
+
94
+ private
95
+
96
+ def create_pax_header_from_stream(pax_content, name = "./PaxHeaders.X/test_file")
97
+ pax_header_data = build_tar_pax_header(name, "", pax_content.bytesize)
98
+ padded_content = pax_content.ljust((pax_content.bytesize / 512.0).ceil * 512, "\0")
99
+ io = StringIO.new(pax_header_data + padded_content)
100
+
101
+ posix_header = Minitar::PosixHeader.from_stream(io)
102
+ Minitar::PaxHeader.from_stream(io, posix_header)
103
+ end
104
+ end
@@ -0,0 +1,66 @@
1
+ require "minitest_helper"
2
+
3
+ class TestPaxSupport < Minitest::Test
4
+ def test_pax_header_size_extraction_in_reader
5
+ pax_content = "16 size=1048576\n28 mtime=1749098832.3200000\n"
6
+ tar_data = create_pax_with_file_headers(pax_content, "./PaxHeaders.X/large_file.mov", "large_file.mov", 1048576, 0)
7
+
8
+ entries = read_tar_entries(tar_data)
9
+ assert_equal 1, entries.size
10
+
11
+ entry = entries.first
12
+ assert_equal "large_file.mov", entry.name
13
+ assert_equal 1048576, entry.size # Size from PAX header
14
+ end
15
+
16
+ def test_pax_header_without_size_uses_header_size
17
+ pax_content = "28 mtime=1749098832.3200000\n"
18
+ tar_data = create_pax_with_file_headers(pax_content, "./PaxHeaders.X/normal_file.txt", "normal_file.txt", 12345, 12345)
19
+
20
+ entries = read_tar_entries(tar_data)
21
+ assert_equal 1, entries.size
22
+
23
+ entry = entries.first
24
+ assert_equal "normal_file.txt", entry.name
25
+ assert_equal 12345, entry.size # Original header size preserved
26
+ end
27
+
28
+ def test_pax_header_takes_precedence_over_posix_header_size
29
+ pax_content = "16 size=1048576\n28 mtime=1749098832.3200000\n"
30
+ tar_data = create_pax_with_file_headers(pax_content, "./PaxHeaders.X/precedence_file.txt", "precedence_file.txt", 12345, 12345)
31
+
32
+ entries = read_tar_entries(tar_data)
33
+ assert_equal 1, entries.size
34
+
35
+ entry = entries.first
36
+ assert_equal "precedence_file.txt", entry.name
37
+ assert_equal 1048576, entry.size # PAX size takes precedence over POSIX size (12345)
38
+ end
39
+
40
+ def test_pax_size_extraction_logic
41
+ pax_header_with_size = Minitar::PaxHeader.new(size: "1048576", mtime: "1749098832.3200000")
42
+ assert_equal 1048576, pax_header_with_size.size
43
+
44
+ pax_header_without_size = Minitar::PaxHeader.new(mtime: "1749098832.3200000")
45
+ assert_nil pax_header_without_size.size
46
+ end
47
+
48
+ private
49
+
50
+ def read_tar_entries(tar_data)
51
+ io = StringIO.new(tar_data)
52
+ Minitar::Reader.open(io, &:to_a)
53
+ end
54
+
55
+ def create_pax_with_file_headers(pax_content, pax_name, file_name, file_size, posix_header_file_size)
56
+ file_content = "x" * file_size
57
+ padded_file_content = file_content.ljust((file_size / 512.0).ceil * 512, "\0")
58
+
59
+ [
60
+ build_tar_pax_header(pax_name, "", pax_content.bytesize),
61
+ pax_content.ljust((pax_content.bytesize / 512.0).ceil * 512, "\0"),
62
+ build_tar_file_header(file_name, "", 0o644, file_size),
63
+ padded_file_content
64
+ ].join
65
+ end
66
+ end