♻️ No recursive call in data_handler + overall cleanup

Author: Mario-SO

src/core/engine.zig

@@ -25,45 +25,43 @@ pub const DataHandler = struct {
     // Returns null if there are no more bars or if the next row fails to parse.
     // Uses an ArenaAllocator for temporary allocations during parsing.
     pub fn nextBar(self: *DataHandler) !?Bar {
-        if (self.current_index >= self.all_rows.items.len) {
-            return null; // No more data
-        }
+        while (self.current_index < self.all_rows.items.len) {
+            // Use a temporary ArenaAllocator for parsing each row
+            var arena = std.heap.ArenaAllocator.init(self.allocator);
+            defer arena.deinit(); // Ensure arena is deinitialized even if we continue the loop
+            const temp_allocator = arena.allocator();
 
-        // Use a temporary ArenaAllocator for parsing each row
-        var arena = std.heap.ArenaAllocator.init(self.allocator);
-        defer arena.deinit();
-        const temp_allocator = arena.allocator();
+            const row_str = self.all_rows.items[self.current_index];
+            const current_row_index = self.current_index; // Store index before potential increment
+            self.current_index += 1;
 
-        const row_str = self.all_rows.items[self.current_index];
-        self.current_index += 1;
+            // Try parsing the row
+            const maybe_bar = Bar.parse(row_str, temp_allocator) catch |err| {
+                // Log or handle allocation errors during parsing if necessary
+                std.debug.print("ERROR: Allocation error during Bar.parse at index {d}: {s}\n", .{ current_row_index, @errorName(err) });
+                // If allocation fails, we might want to stop completely or skip.
+                // Continuing the loop might lead to repeated allocation errors.
+                // For now, let's skip this row like other parsing errors.
+                continue; // Skip to the next iteration (next row)
+            };
 
-        // Try parsing the row
-        const maybe_bar = Bar.parse(row_str, temp_allocator) catch |err| {
-            // Log or handle allocation errors during parsing if necessary
-            std.debug.print("ERROR: Allocation error during Bar.parse: {s}\n", .{@errorName(err)});
-            return error.ParsingAllocationError; // Propagate allocation errors
-        };
+            if (maybe_bar == null) {
+                // Parsing failed (e.g., bad format, wrong field count), warning printed inside Bar.parse
+                // Log the index of the bad row for easier debugging
+                std.debug.print("WARN: Skipping invalid bar data at index {d}\n", .{current_row_index});
+                continue; // Skip to the next iteration (next row)
+            }
 
-        if (maybe_bar == null) {
-            // Parsing failed (e.g., bad format, wrong field count), warning printed inside Bar.parse
-            // Optionally log here too, or decide to retry/skip
-            // For now, we just return null, effectively skipping the bad row.
-            // To distinguish between end-of-data and bad row, the loop calling this
-            // might need to check the index or we could return an error enum.
-            // Let's try fetching the *next* valid bar instead of returning null immediately.
-            return self.nextBar(); // Recursive call to get the next *valid* one
-            // WARNING: Recursive call could lead to stack overflow on large chunks of bad data.
-            // An iterative approach would be safer.
-            // TODO: Refactor to iterative loop to find next valid bar.
+            // Successfully parsed a bar
+            return maybe_bar.?;
         }
 
-        return maybe_bar.?;
+        // Reached the end of the data without finding a valid bar
+        return null;
     }
 
     // Resets the handler to the beginning of the data stream.
     pub fn reset(self: *DataHandler) void {
         self.current_index = 0;
     }
 };
-
-// TODO: Add test cases for DataHandler

src/core/types.zig

@@ -17,14 +17,6 @@ pub fn main() !void {
     // --- Log Initial Config --- (Keep this part)
     logger.logConfig(context.config.value);
     logger.logStrategy(context.strategy.value);
-    // logger.logOhlcvHeader(); // Engine/Results will handle data logging if needed
-    // // Log the first 10 rows using the pretty logger
-    // var i: usize = 0;
-    // for (context.ohlcvData.body.items) |row_str| {
-    //     if (i >= 10) break; // Stop after logging 10 rows
-    //     logger.logOhlcvRowPretty(row_str, allocator);
-    //     i += 1;
-    // }
 
     // --- Initialize and Run Backtest Engine ---
     var engine = try BacktestEngine.init(allocator, &context);
@@ -33,5 +25,5 @@ pub fn main() !void {
 
     try engine.run();
 
-    print("\nApplication finished successfully.\n", .{});
+    print("\nBacktest finished successfully.\n", .{});
 }

src/engine/data_handler.zig

@@ -1,6 +1,3 @@
-//! This module provides structs for parsing and manipulating CSV data
-//! [Released under GNU LGPLv3]
-//!
 const std = @import("std");
 const Allocator = std.mem.Allocator;
 const ArrayList = std.ArrayList;

src/main.zig

@@ -1,5 +1,3 @@
-//! This module provides structs for parsing and manipulating CSV data
-//! [Released under GNU LGPLv3]
 const std = @import("std");
 const TableError = @import("csv-parser.zig").TableError;
 

src/utils/csv/csv-parser.zig

@@ -79,84 +79,3 @@ pub const AppContext = struct {
         // Note: We don't deinit the allocator itself here, assuming it's managed externally (e.g., GPA in main)
     }
 };
-
-test "loadConfig" {
-    // Test the new AppContext init
-    // Use the testing allocator directly for automatic leak detection
-    const allocator = std.testing.allocator;
-
-    // Mock file system (Assuming a test setup or adjust paths)
-    // For simplicity, we'll assume config/config.json, config/buy-and-hold.json, data/btc.csv exist
-    // In a real scenario, you'd mock std.fs.cwd() or create temporary test files.
-
-    // Create dummy files for testing if they don't exist
-    _ = std.fs.cwd().makePath("config") catch |err| switch (err) {
-        error.PathAlreadyExists => {},
-        else => |e| return e,
-    };
-    _ = std.fs.cwd().makePath("data") catch |err| switch (err) {
-        error.PathAlreadyExists => {},
-        else => |e| return e,
-    };
-
-    var config_file = try std.fs.cwd().createFile("config/config.json", .{});
-    defer config_file.close();
-    _ = try config_file.writeAll(
-        \\{
-        \\  "budget": 10000,
-        \\  "strategy": "buy-and-hold.json",
-        \\  "data": "btc.csv"
-        \\}
-    );
-
-    var strat_file = try std.fs.cwd().createFile("config/buy-and-hold.json", .{});
-    defer strat_file.close();
-    _ = try strat_file.writeAll(
-        \\{
-        \\  "buyAt": 1000
-        \\}
-    );
-
-    var data_file = try std.fs.cwd().createFile("data/btc.csv", .{});
-    defer data_file.close();
-    _ = try data_file.writeAll(
-        \\timestamp,open,high,low,close,volume
-        \\2024-01-01T00:00:00Z,42000.00,42100.00,41900.00,42050.00,100.50
-    );
-
-    var context = try AppContext.init(allocator);
-    defer context.deinit();
-
-    try std.testing.expectEqual(@as(u64, 10000), context.config.value.budget);
-    try std.testing.expectEqualSlices(u8, "buy-and-hold.json", context.config.value.strategy);
-    try std.testing.expectEqualSlices(u8, "btc.csv", context.config.value.data);
-    try std.testing.expectEqual(@as(u64, 1000), context.strategy.value.buyAt);
-    try std.testing.expectEqual(@as(usize, 1), context.ohlcvData.body.items.len); // Check if CSV data was loaded
-
-    // Clean up dummy files
-    try std.fs.cwd().deleteFile("config/config.json");
-    try std.fs.cwd().deleteFile("config/buy-and-hold.json");
-    try std.fs.cwd().deleteFile("data/btc.csv");
-    try std.fs.cwd().deleteDir("config");
-    try std.fs.cwd().deleteDir("data");
-}
-
-// Comment out old tests or remove them
-// test "loadConfig" {
-//     const config = try loadConfig(std.testing.allocator);
-//     defer config.deinit();
-//
-//     try std.testing.expectEqual(@as(u64, 10000), config.value.budget);
-//     try std.testing.expectEqualSlices(u8, "buy-and-hold.json", config.value.strategy);
-//     try std.testing.expectEqualSlices(u8, "btc.csv", config.value.data);
-// }
-//
-// test "loadStrategySettings" {
-//     // Need to create dummy config/buy-and-hold.json for this test
-//     // ... (test setup code) ...
-//     const strat = try loadStrategySettings(std.testing.allocator, "config/buy-and-hold.json");
-//     defer strat.deinit();
-//
-//     try std.testing.expectEqual(@as(u64, 1000), strat.value.buyAt);
-//     // ... (test cleanup code) ...
-// }