Collapse include + sources and options in step builder (#122)

Author: KurtWagner

build.zig

@@ -50,6 +50,11 @@ const BuiltRule = struct {
     }
 };
 
+const BuildOptions = struct {
+    target: std.Build.ResolvedTarget,
+    optimize: std.builtin.OptimizeMode,
+};
+
 pub const BuilderOptions = struct {
     /// You should never need to set this. Defaults to native host.
     target: ?std.Build.ResolvedTarget = null,
@@ -69,27 +74,29 @@ pub const BuilderOptions = struct {
     optimize: std.builtin.OptimizeMode = .Debug,
 };
 
-/// Creater a step builder for zlinter
+/// Create a step builder for zlinter
 pub fn builder(b: *std.Build, options: BuilderOptions) StepBuilder {
     return .{
         .rules = .empty,
-        .include_paths = .empty,
-        .exclude_paths = .empty,
-        .sources = .empty,
+        .exclude = .empty,
+        .include = .empty,
+        .options = .{
+            .optimize = options.optimize,
+            .target = options.target orelse b.graph.host,
+        },
         .b = b,
-        .optimize = options.optimize,
-        .target = options.target orelse b.graph.host,
     };
 }
 
-/// Represents a source that can be linted.
-pub const LintSource = union(enum) {
+/// Represents something that should be linted.
+const LintIncludeSource = union(enum) {
     /// e.g., library or executable.
     compiled_unit: struct {
         compile_step: *std.Build.Step.Compile,
     },
+    path: std.Build.LazyPath,
 
-    pub fn compiled(compile: *std.Build.Step.Compile) LintSource {
+    pub fn compiled(compile: *std.Build.Step.Compile) LintIncludeSource {
         return .{
             .compiled_unit = .{
                 .compile_step = compile,
@@ -98,15 +105,17 @@ pub const LintSource = union(enum) {
     }
 };
 
+/// Represents something that should be excluded from linting.
+const LintExcludeSource = union(enum) {
+    path: std.Build.LazyPath,
+};
+
 const StepBuilder = struct {
     rules: shims.ArrayList(BuiltRule),
-    // TODO: Collapse paths and sources into one array for union `LintSource`.
-    include_paths: shims.ArrayList(std.Build.LazyPath),
-    exclude_paths: shims.ArrayList(std.Build.LazyPath),
-    sources: shims.ArrayList(LintSource),
+    include: shims.ArrayList(LintIncludeSource),
+    exclude: shims.ArrayList(LintExcludeSource),
+    options: BuildOptions,
     b: *std.Build,
-    target: std.Build.ResolvedTarget,
-    optimize: std.builtin.OptimizeMode,
 
     pub fn addRule(
         self: *StepBuilder,
@@ -121,23 +130,22 @@ const StepBuilder = struct {
                 self.b,
                 source,
                 .{
-                    .optimize = self.optimize,
-                    .target = self.target,
+                    .optimize = self.options.optimize,
+                    .target = self.options.target,
                 },
                 config,
             ),
         ) catch @panic("OOM");
     }
 
-    /// Adds a source to be linted (e.g., library or executable). Only inputs
-    /// resolved to this source within the projects path will be linted.
+    /// Adds a source to be linted (e.g., library, executable or path). Only
+    /// inputs resolved to this source within the projects path will be linted.
     ///
-    /// If a source is not set then it falls back to linting the include paths.
-    /// If no include paths are given then it falls back to linting all source
-    /// files under the current working directory.
-    pub fn addSource(self: *StepBuilder, source: LintSource) void {
+    /// If no paths are given or resolved then it falls back to linting all
+    /// zig source files under the current working directory.
+    pub fn addSource(self: *StepBuilder, source: LintIncludeSource) void {
         const arena = self.b.allocator;
-        self.sources.append(arena, source) catch @panic("OOM");
+        self.include.append(arena, source) catch @panic("OOM");
     }
 
     /// Set the paths to include or exclude when running the linter.
@@ -160,9 +168,9 @@ const StepBuilder = struct {
         const arena = self.b.allocator;
 
         if (paths.include) |includes|
-            for (includes) |path| self.include_paths.append(arena, path) catch @panic("OOM");
+            for (includes) |path| self.include.append(arena, .{ .path = path }) catch @panic("OOM");
         if (paths.exclude) |excludes|
-            for (excludes) |path| self.exclude_paths.append(arena, path) catch @panic("OOM");
+            for (excludes) |path| self.exclude.append(arena, .{ .path = path }) catch @panic("OOM");
     }
 
     pub fn build(self: *StepBuilder) *std.Build.Step {
@@ -172,18 +180,14 @@ const StepBuilder = struct {
             b,
             self.rules.items,
             .{
-                .target = self.target,
-                .optimize = self.optimize,
-                .zlinter = .{
-                    .dependency = b.dependencyFromBuildZig(
-                        @"build.zig",
-                        .{},
-                    ),
-                },
-                .include_paths = self.include_paths.items,
-                .exclude_paths = self.exclude_paths.items,
-                .sources = self.sources.items,
+                .dependency = b.dependencyFromBuildZig(
+                    @"build.zig",
+                    .{},
+                ),
             },
+            self.include.items,
+            self.exclude.items,
+            self.options,
         );
     }
 };
@@ -364,19 +368,18 @@ pub fn build(b: *std.Build) void {
 
     const lint_cmd = b.step("lint", "Lint the linters own source code.");
     lint_cmd.dependOn(step: {
-        var sources = shims.ArrayList(LintSource).empty;
-        sources.append(b.allocator, .compiled(b.addLibrary(.{
+        var include = shims.ArrayList(LintIncludeSource).empty;
+        include.append(b.allocator, .compiled(b.addLibrary(.{
             .name = "zlinter",
             .root_module = zlinter_lib_module,
         }))) catch @panic("OOM");
 
-        var include_paths = shims.ArrayList(std.Build.LazyPath).empty;
-        var exclude_paths = shims.ArrayList(std.Build.LazyPath).empty;
+        var exclude = shims.ArrayList(LintExcludeSource).empty;
 
         // Also lint all files within project, not just those resolved to our compiled source.
-        include_paths.append(b.allocator, b.path("./")) catch @panic("OOM");
-        exclude_paths.append(b.allocator, b.path("integration_tests/test_cases")) catch @panic("OOM");
-        exclude_paths.append(b.allocator, b.path("integration_tests/src/test_case_references.zig")) catch @panic("OOM");
+        include.append(b.allocator, .{ .path = b.path("./") }) catch @panic("OOM");
+        exclude.append(b.allocator, .{ .path = b.path("integration_tests/test_cases") }) catch @panic("OOM");
+        exclude.append(b.allocator, .{ .path = b.path("integration_tests/src/test_case_references.zig") }) catch @panic("OOM");
 
         break :step buildStep(
             b,
@@ -430,13 +433,12 @@ pub fn build(b: *std.Build) void {
                     },
                 ),
             },
+            .{ .module = zlinter_lib_module },
+            include.items,
+            exclude.items,
             .{
-                .sources = sources.items,
                 .target = target,
                 .optimize = optimize,
-                .include_paths = include_paths.items,
-                .exclude_paths = exclude_paths.items,
-                .zlinter = .{ .module = zlinter_lib_module },
             },
         );
     });
@@ -492,19 +494,15 @@ fn toZonString(val: anytype, allocator: std.mem.Allocator) []const u8 {
 fn buildStep(
     b: *std.Build,
     rules: []const BuiltRule,
-    options: struct {
-        target: std.Build.ResolvedTarget,
-        optimize: std.builtin.OptimizeMode,
-        zlinter: union(enum) {
-            dependency: *std.Build.Dependency,
-            module: *std.Build.Module,
-        },
-        include_paths: []const std.Build.LazyPath,
-        exclude_paths: []const std.Build.LazyPath,
-        sources: []const LintSource,
+    zlinter: union(enum) {
+        dependency: *std.Build.Dependency,
+        module: *std.Build.Module,
     },
+    include: []const LintIncludeSource,
+    exclude: []const LintExcludeSource,
+    options: BuildOptions,
 ) *std.Build.Step {
-    const zlinter_lib_module: *std.Build.Module, const exe_file: std.Build.LazyPath, const build_rules_exe_file: std.Build.LazyPath = switch (options.zlinter) {
+    const zlinter_lib_module: *std.Build.Module, const exe_file: std.Build.LazyPath, const build_rules_exe_file: std.Build.LazyPath = switch (zlinter) {
         .dependency => |d| .{ d.module("zlinter"), d.path("src/exe/run_linter.zig"), d.path("build_rules.zig") },
         .module => |m| .{ m, b.path("src/exe/run_linter.zig"), b.path("build_rules.zig") },
     };
@@ -552,9 +550,8 @@ fn buildStep(
     const zlinter_run = ZlinterRun.create(
         b,
         zlinter_exe,
-        options.include_paths,
-        options.exclude_paths,
-        options.sources,
+        include,
+        exclude,
     );
 
     return &zlinter_run.step;
@@ -755,14 +752,11 @@ const ZlinterRun = struct {
     /// CLI arguments to be passed to zlinter when executed
     argv: shims.ArrayList(Arg),
 
-    /// Include paths configured within the build file.
-    include_paths: []const std.Build.LazyPath,
-
     /// Exclude paths confiured within the build file.
-    exclude_paths: []const std.Build.LazyPath,
+    exclude: []const LintExcludeSource,
 
     /// The sources to lint (e.g., an executable or library).
-    sources: []const LintSource,
+    include: []const LintIncludeSource,
 
     const Arg = union(enum) {
         artifact: *std.Build.Step.Compile,
@@ -772,9 +766,8 @@ const ZlinterRun = struct {
     pub fn create(
         owner: *std.Build,
         exe: *std.Build.Step.Compile,
-        include_paths: []const std.Build.LazyPath,
-        exclude_paths: []const std.Build.LazyPath,
-        sources: []const LintSource,
+        include: []const LintIncludeSource,
+        exclude: []const LintExcludeSource,
     ) *ZlinterRun {
         const arena = owner.allocator;
 
@@ -787,15 +780,10 @@ const ZlinterRun = struct {
                 .makeFn = make,
             }),
             .argv = .empty,
-            .exclude_paths = exclude_paths,
-            .include_paths = include_paths,
-            .sources = sources,
+            .exclude = exclude,
+            .include = include,
         };
 
-        for (include_paths) |path| {
-            addWatchInput(owner, &self.step, path, .lintable_file) catch @panic("OOM");
-        }
-
         self.argv.append(arena, .{ .artifact = exe }) catch @panic("OOM");
 
         if (owner.args) |args| self.addArgs(args);
@@ -811,11 +799,17 @@ const ZlinterRun = struct {
         const bin_file = exe.getEmittedBin();
         bin_file.addStepDependencies(&self.step);
 
-        for (sources) |s| {
+        for (include) |s| {
             switch (s) {
-                .compiled_unit => |info| {
-                    self.step.dependOn(&info.compile_step.step);
-                },
+                .compiled_unit => |info| self.step.dependOn(
+                    &info.compile_step.step,
+                ),
+                .path => |path| addWatchInput(
+                    owner,
+                    &self.step,
+                    path,
+                    .lintable_file,
+                ) catch @panic("OOM"),
             }
         }
 
@@ -861,13 +855,11 @@ const ZlinterRun = struct {
 
         var includes: shims.ArrayList(std.Build.LazyPath) = try .initCapacity(
             b.allocator,
-            @max(1, run.include_paths.len),
+            @max(1, run.include.len),
         );
         defer includes.deinit(b.allocator);
 
-        includes.appendSliceAssumeCapacity(run.include_paths);
-
-        for (run.sources) |source| {
+        for (run.include) |source| {
             switch (source) {
                 .compiled_unit => |info| {
                     var exe = info.compile_step;
@@ -906,15 +898,27 @@ const ZlinterRun = struct {
                         }
                     }
                 },
+                .path => |path| try includes.append(
+                    b.allocator,
+                    path,
+                ),
             }
         }
         if (includes.items.len == 0) {
             includes.appendAssumeCapacity(b.path("./"));
         }
 
+        var excludes: shims.ArrayList(std.Build.LazyPath) = try .initCapacity(b.allocator, run.exclude.len);
+        defer excludes.deinit(b.allocator);
+        for (run.exclude) |exclude| {
+            switch (exclude) {
+                .path => |path| excludes.appendAssumeCapacity(path),
+            }
+        }
+
         const build_info_zon_bytes: []const u8 = toZonString(BuildInfo{
             .include_paths = try subPaths(&run.step, includes.items),
-            .exclude_paths = try subPaths(&run.step, run.exclude_paths),
+            .exclude_paths = try subPaths(&run.step, excludes.items),
         }, b.allocator);
 
         const env_map = arena.create(std.process.EnvMap) catch @panic("OOM");