added regular expression filter

Author: SuSonicTH

build.zig

@@ -4,12 +4,20 @@ pub fn build(b: *std.Build) void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
 
+    const mvzr = b.dependency("mvzr", .{
+        .target = target,
+        .optimize = optimize,
+    });
+
     const exe = b.addExecutable(.{
         .name = "csvcut",
         .root_module = b.createModule(.{
             .root_source_file = b.path("src/main.zig"),
             .target = target,
             .optimize = optimize,
+            .imports = &.{
+                .{ .name = "mvzr", .module = mvzr.module("mvzr") },
+            },
         }),
     });
 

build.zig.zon

@@ -3,7 +3,12 @@
     .version = "0.1.1-beta",
     .fingerprint = 0x8035f4e75082840a,
 
-    .dependencies = .{},
+    .dependencies = .{
+        .mvzr = .{
+            .url = "https://github.com/mnemnion/mvzr/archive/refs/tags/v0.3.7.tar.gz",
+            .hash = "mvzr-0.3.7-ZSOky5FtAQB2VrFQPNbXHQCFJxWTMAYEK7ljYEaMR6jt",
+        },
+    },
 
     .paths = .{
         "build.zig",

src/USAGE.txt

@@ -81,14 +81,19 @@ Options:
                                but removes given columns from output
 
       --filter [filter,..]     list of filters that are applied
-                               argument field1=value1,field2=value2,....
+                               argument field1=value,field2~regex,....
+                               only lines were all fields are matching are outputted
+
+                               field=value => the value has to match exactly
+                               field~regex => the regular expression has to match
+                               
                                can be used multiple times, if any filter matches
                                the line will be output
 
       --filterOut [filter,...] list of negative filters that are applied
                                inverse of --filter
                                ignores lines that match any filter
-                               is applied befroe --filter
+                               is applied before --filter
 
       --trim                   removes space & tab characters from start & end
       --unique                 only output unique lines

src/exitCode.zig

@@ -12,6 +12,7 @@ pub const ExitCode = enum(u8) {
     includeAndExcludeTogether,
     countAndUniqueAreExclusive,
     extraLfWithoutLength,
+    regexCompileError,
 
     couldNotOpenInputFile,
     couldNotOpenOutputFile,
@@ -34,7 +35,7 @@ pub const ExitCode = enum(u8) {
             .includeAndExcludeTogether => return "--include and --exclude cannot be used together",
             .extraLfWithoutLength => return "--extraLF and --extraCRLF are only used for fixed field processing with --lengths",
             .countAndUniqueAreExclusive => return "--count and --unique are exclusive, use either, not both at the same time",
-
+            .regexCompileError => return "invalid regex '{s}' for field '{s}'",
             .couldNotOpenInputFile => return "could not open input file '{s}' reason: {}",
             .couldNotOpenOutputFile => return "could not open output file '{s}' reason: {}",
             .couldNotReadHeader => return "could not read header from file '{s}'",

src/options.zig

@@ -1,5 +1,7 @@
 const std = @import("std");
 const CsvLine = @import("FieldReader/CsvLine.zig");
+const ExitCode = @import("exitCode.zig").ExitCode;
+const mvzr = @import("mvzr");
 
 pub const OutputFormat = enum {
     csv,
@@ -23,7 +25,8 @@ const Selection = union(enum) {
 const OptionError = error{
     NoSuchField,
     NoHeader,
-    MoreThanOneEqualInFilter,
+    NoEqualOrTildeInFilter,
+    RegexCompileError,
 };
 
 pub const Options = struct {
@@ -202,14 +205,21 @@ pub const Options = struct {
     }
 };
 
+const FilterType = enum { equal, regex };
+const FilterValue = struct {
+    value: []const u8,
+    type: FilterType,
+    regex: ?mvzr.Regex,
+};
+
 pub const Filter = struct {
     selectionList: SelectionList,
-    values: std.array_list.Managed([]const u8),
+    values: std.array_list.Managed(FilterValue),
 
     pub fn init(allocator: std.mem.Allocator) !Filter {
         return .{
             .selectionList = try SelectionList.init(allocator),
-            .values = std.array_list.Managed([]const u8).init(allocator),
+            .values = std.array_list.Managed(FilterValue).init(allocator),
         };
     }
 
@@ -219,18 +229,31 @@ pub const Filter = struct {
     }
 
     pub fn append(self: *Filter, filter: []const u8) !void {
-        var it = std.mem.splitScalar(u8, filter, '=');
-        if (it.next()) |field| {
-            try self.selectionList.append(field);
-        }
-        if (it.next()) |value| {
-            try self.values.append(value);
+        var eqlPos: usize = 0;
+        var filterType: FilterType = undefined;
+
+        if (std.mem.indexOfScalar(u8, filter, '=')) |pos| {
+            eqlPos = pos;
+            filterType = .equal;
+        } else if (std.mem.indexOfScalar(u8, filter, '~')) |pos| {
+            eqlPos = pos;
+            filterType = .regex;
         } else {
-            try self.values.append("");
+            return OptionError.NoEqualOrTildeInFilter;
         }
-        if (it.next()) |_| {
-            return OptionError.MoreThanOneEqualInFilter;
+
+        const field = filter[0..eqlPos];
+        try self.selectionList.append(field);
+
+        const value = filter[eqlPos + 1 ..];
+        var regex: ?mvzr.Regex = null;
+        if (filterType == .regex) {
+            regex = mvzr.compile(value);
+            if (regex == null) {
+                ExitCode.regexCompileError.printErrorAndExit(.{ value, field });
+            }
         }
+        try self.values.append(.{ .value = value, .type = filterType, .regex = regex });
     }
 
     pub fn calculateIndices(self: *Filter, header: ?[][]const u8) !void {
@@ -239,8 +262,14 @@ pub const Filter = struct {
 
     pub fn matches(self: *const Filter, fields: [][]const u8) bool {
         for (self.selectionList.indices.?, 0..) |fieldIndex, i| {
-            if (!std.mem.eql(u8, fields[fieldIndex], self.values.items[i])) {
-                return false;
+            const value = self.values.items[i];
+            switch (value.type) {
+                .equal => if (!std.mem.eql(u8, fields[fieldIndex], value.value)) {
+                    return false;
+                },
+                .regex => if (!value.regex.?.isMatch(fields[fieldIndex])) {
+                    return false;
+                },
             }
         }
         return true;
@@ -304,9 +333,9 @@ const SelectionList = struct {
         return minusPos;
     }
 
-    fn addRange(list: *std.array_list.Managed(Selection), field: []const u8, miusPos: usize) !void {
-        if (toNumber(field[0..miusPos])) |from| {
-            if (toNumber(field[miusPos + 1 ..])) |to| {
+    fn addRange(list: *std.array_list.Managed(Selection), field: []const u8, minusPos: usize) !void {
+        if (toNumber(field[0..minusPos])) |from| {
+            if (toNumber(field[minusPos + 1 ..])) |to| {
                 for (from..to + 1) |index| {
                     try list.append(.{ .index = index - 1 });
                 }