tar: rename reader to iterator

Itarator has `next` function, iterates over tar files. When using from
outside of module with `tar.` prefix makes more sense.

var iter = tar.iterator(reader, null);
while (try iter.next()) |file| {
...
}

Author: ianic

lib/std/tar.zig

@@ -225,14 +225,16 @@ fn nullStr(str: []const u8) []const u8 {
     return str;
 }
 
-pub fn tarReader(reader: anytype, diagnostics: ?*Options.Diagnostics) TarReader(@TypeOf(reader)) {
+/// Iterates over files in tar archive.
+/// `next` returns each file in `reader` tar archive.
+pub fn iterator(reader: anytype, diagnostics: ?*Options.Diagnostics) Iterator(@TypeOf(reader)) {
     return .{
         .reader = reader,
         .diagnostics = diagnostics,
     };
 }
 
-fn TarReader(comptime ReaderType: type) type {
+fn Iterator(comptime ReaderType: type) type {
     return struct {
         reader: ReaderType,
         diagnostics: ?*Options.Diagnostics,
@@ -358,7 +360,7 @@ fn TarReader(comptime ReaderType: type) type {
                         // Use just attributes from last extended header.
                         self.initFile();
 
-                        var rdr = paxReader(self.reader, @intCast(size));
+                        var rdr = paxIterator(self.reader, @intCast(size));
                         while (try rdr.next()) |attr| {
                             switch (attr.kind) {
                                 .path => {
@@ -393,10 +395,10 @@ fn TarReader(comptime ReaderType: type) type {
     };
 }
 
-// Pax attributes reader.
-// Size is length of pax extended header in reader.
-fn paxReader(reader: anytype, size: usize) PaxReader(@TypeOf(reader)) {
-    return PaxReader(@TypeOf(reader)){
+/// Pax attributes iterator.
+/// Size is length of pax extended header in reader.
+fn paxIterator(reader: anytype, size: usize) PaxIterator(@TypeOf(reader)) {
+    return PaxIterator(@TypeOf(reader)){
         .reader = reader,
         .size = size,
     };
@@ -408,7 +410,7 @@ const PaxAttributeKind = enum {
     size,
 };
 
-fn PaxReader(comptime ReaderType: type) type {
+fn PaxIterator(comptime ReaderType: type) type {
     return struct {
         size: usize, // cumulative size of all pax attributes
         reader: ReaderType,
@@ -508,8 +510,7 @@ pub fn pipeToFileSystem(dir: std.fs.Dir, reader: anytype, options: Options) !voi
         },
     }
 
-    var iter = tarReader(reader, options.diagnostics);
-
+    var iter = iterator(reader, options.diagnostics);
     while (try iter.next()) |file| {
         switch (file.kind) {
             .directory => {
@@ -601,7 +602,7 @@ test "tar stripComponents" {
     try expectEqualStrings("c", try stripComponents("a/b/c", 2));
 }
 
-test "tar PaxReader" {
+test "tar PaxIterator" {
     const Attr = struct {
         kind: PaxAttributeKind,
         value: []const u8 = undefined,
@@ -699,10 +700,10 @@ test "tar PaxReader" {
 
     outer: for (cases) |case| {
         var stream = std.io.fixedBufferStream(case.data);
-        var rdr = paxReader(stream.reader(), case.data.len);
+        var iter = paxIterator(stream.reader(), case.data.len);
 
         var i: usize = 0;
-        while (rdr.next() catch |err| {
+        while (iter.next() catch |err| {
             if (case.err) |e| {
                 try std.testing.expectEqual(e, err);
                 continue;

lib/std/tar/test.zig

@@ -1,7 +1,6 @@
 const std = @import("../std.zig");
-const builtin = @import("builtin");
 const tar = std.tar;
-const assert = std.debug.assert;
+const testing = std.testing;
 
 test "tar run Go test cases" {
     const Case = struct {
@@ -318,33 +317,33 @@ test "tar run Go test cases" {
 
     for (cases) |case| {
         var fsb = std.io.fixedBufferStream(case.data);
-        var iter = tar.tarReader(fsb.reader(), null);
+        var iter = tar.iterator(fsb.reader(), null);
         var i: usize = 0;
         while (iter.next() catch |err| {
             if (case.err) |e| {
-                try std.testing.expectEqual(e, err);
+                try testing.expectEqual(e, err);
                 continue;
             } else {
                 return err;
             }
         }) |actual| : (i += 1) {
             const expected = case.files[i];
-            try std.testing.expectEqualStrings(expected.name, actual.name);
-            try std.testing.expectEqual(expected.size, actual.size);
-            try std.testing.expectEqual(expected.kind, actual.kind);
-            try std.testing.expectEqual(expected.mode, actual.mode);
-            try std.testing.expectEqualStrings(expected.link_name, actual.link_name);
+            try testing.expectEqualStrings(expected.name, actual.name);
+            try testing.expectEqual(expected.size, actual.size);
+            try testing.expectEqual(expected.kind, actual.kind);
+            try testing.expectEqual(expected.mode, actual.mode);
+            try testing.expectEqualStrings(expected.link_name, actual.link_name);
 
             if (case.chksums.len > i) {
                 var md5writer = Md5Writer{};
                 try actual.write(&md5writer);
                 const chksum = md5writer.chksum();
-                try std.testing.expectEqualStrings(case.chksums[i], &chksum);
+                try testing.expectEqualStrings(case.chksums[i], &chksum);
             } else {
                 if (!expected.truncated) try actual.skip(); // skip file content
             }
         }
-        try std.testing.expectEqual(case.files.len, i);
+        try testing.expectEqual(case.files.len, i);
     }
 }