parse list and find appropriate format

2 files changed, 66 insertions, 26 deletions

diff --git a/src/Image.zig b/src/Image.zig
new file mode 100644
index 0000000..99f0382
--- /dev/null
+++ b/src/Image.zig
@@ -0,0 +1,42 @@
+const std = @import("std");
+
+const Self = @This();
+
+s: []u8,
+
+pub const Format = enum {
+    png,
+    jpg,
+    webp,
+    html,
+
+    fn str(self: Format) []const u8 {
+        return switch (self) {
+            .png => "png",
+            .jpg => "jpg",
+            .webp => "webp",
+            .html => "html",
+        };
+    }
+};
+
+pub fn init(allocator: std.mem.Allocator, s: []const u8) !Self {
+    const self = Self{ .s = try allocator.alloc(u8, s.len + 5) };
+    @memcpy(self.s[0 .. self.s.len - 5], s);
+    self.s[self.s.len - 5] = '.';
+    return self;
+}
+
+pub fn deinit(self: Self, allocator: std.mem.Allocator) void {
+    allocator.free(self.s);
+}
+
+pub fn name(self: Self) []u8 {
+    return self.s[0 .. self.s.len - 5];
+}
+
+pub fn path(self: Self, fmt: Format) []u8 {
+    const ext = fmt.str();
+    @memcpy(self.s[self.s.len - 4 .. self.s.len - 4 + ext.len], ext);
+    return self.s[0 .. self.s.len - 4 + ext.len];
+}
diff --git a/src/main.zig b/src/main.zig
index 1058654..ac1c5cb 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -1,36 +1,34 @@
 const std = @import("std");
-const StringArray = std.ArrayList([]u8);
+const Image = @import("Image.zig");
 
 pub fn main() !void {
     var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
     defer arena.deinit();
     const allocator = arena.allocator();
 
-    var dir = try std.fs.cwd().openDir(".", .{ .iterate = true });
-    defer dir.close();
+    const list = blk: {
+        const list = try std.fs.cwd().openFile("list", .{});
+        defer list.close();
+        break :blk try list.readToEndAlloc(allocator, 4096 * 4096);
+    };
 
-    // list directory files (sorted by name)
-    var size: usize = 0;
-    var iter = dir.iterate();
-    while (try iter.next()) |e| {
-        if (e.kind != .file) continue;
-        std.log.debug("{s}", .{e.name});
-        size += 1;
-    }
-    var files = try allocator.alloc([]u8, size);
-    var i: usize = 0;
-    iter = dir.iterate();
-    while (try iter.next()) |e| {
-        if (e.kind != .file) continue;
-        files[i] = try allocator.alloc(u8, e.name.len);
-        @memcpy(files[i], e.name);
-        i += 1;
-    }
-    std.mem.sort([]u8, files, {}, struct {
-        fn f(_: void, a: []u8, b: []u8) bool {
-            return std.mem.lessThan(u8, a, b);
-        }
-    }.f);
+    var tokens = std.mem.tokenizeAny(u8, list, ",\n");
+    while (tokens.next()) |tok| {
+        const img = try Image.init(allocator, tok);
+        defer img.deinit(allocator);
 
-    std.log.info("{s}", .{files});
+        const ext = ext: {
+            const exts = [_]Image.Format{ .png, .webp, .jpg };
+            for (exts) |e| {
+                const path = img.path(e);
+                const exist = blk: {
+                    std.fs.cwd().access(path, .{}) catch break :blk false;
+                    break :blk true;
+                };
+                if (exist) break :ext e;
+            }
+            unreachable;
+        };
+        std.log.debug("{s} {}", .{ img.name(), ext });
+    }
 }