Merge branch 'master' into sharmila/fix-version

Author: sharmila-oai

.github/workflows/publish.yaml

@@ -0,0 +1,29 @@
+# Cut a release whenever a new tag is pushed or via workflow_dispatch.
+# Uses bazel-contrib release ruleset: build, attest, and publish to GitHub Releases.
+name: Release
+on:
+  workflow_dispatch:
+    inputs:
+      tag_name:
+        description: Git tag being released
+        required: true
+        type: string
+  push:
+    tags:
+      - "v*.*.*"
+permissions:
+  id-token: write
+  attestations: write
+  contents: write
+jobs:
+  release:
+    uses: bazel-contrib/.github/.github/workflows/release_ruleset.yaml@v7.2.2
+    with:
+      release_files: archives/release.tar.gz
+      prerelease: false
+      tag_name: ${{ inputs.tag_name || github.ref_name }}
+    permissions:
+      id-token: write        # Needed to attest provenance
+      attestations: write    # Needed to attest provenance
+      contents: write       # Needed to upload release files
+    secrets: {}

.github/workflows/release.yaml

@@ -0,0 +1,39 @@
+#!/usr/bin/env bash
+
+set -o errexit -o nounset -o pipefail
+
+# Argument provided by reusable workflow caller, see
+# https://github.com/bazel-contrib/.github/blob/master/.github/workflows/release_ruleset.yaml
+TAG=$1
+
+mkdir -p archives
+tar --exclude-vcs \
+  --exclude=bazel-* \
+  --exclude=.github \
+  --exclude=archives \
+  --exclude=cli/src/test \
+  -zcf "archives/release.tar.gz" .
+
+SHA=$(shasum -a 256 archives/release.tar.gz | awk '{print $1}')
+
+cat << EOF
+## Using Bzlmod (MODULE.bazel)
+
+Add to your \`MODULE.bazel\` file:
+
+\`\`\`starlark
+bazel_dep(name = "bazel-diff", version = "${TAG#v}")
+\`\`\`
+
+## Using WORKSPACE
+
+\`\`\`starlark
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+http_archive(
+  name = "bazel-diff",
+  sha256 = "${SHA}",
+  strip_prefix = "",
+  url = "https://github.com/Tinder/bazel-diff/releases/download/${TAG}/release.tar.gz",
+)
+\`\`\`
+EOF

.github/workflows/release_prep.sh

@@ -1,6 +1,6 @@
 module(
     name = "bazel-diff",
-    version = "17.0.3",
+    version = "17.1.4",
     compatibility_level = 0,
 )
 

MODULE.bazel

@@ -5,7 +5,6 @@ release_source_archive:
 		--exclude=bazel-* \
 		--exclude=.github \
 		--exclude=archives \
-		--exclude=cli/src/test \
 		-zcf "archives/release.tar.gz" .
 
 .PHONY: release_deploy_jar

MODULE.bazel.lock

@@ -341,7 +341,7 @@ First, add the following snippet to your project:
 #### Bzlmod snippet
 
 ```bazel
-bazel_dep(name = "bazel-diff", version = "15.0.5")
+bazel_dep(name = "bazel-diff", version = "17.1.0")
 ```
 
 You can now run the tool with:

Makefile

@@ -30,7 +30,7 @@ class BazelQueryService(
 
   @OptIn(ExperimentalCoroutinesApi::class)
   private suspend fun determineBazelVersion(): Triple<Int, Int, Int> {
-    val cmd = arrayOf(bazelPath.toString(), "--version")
+    val cmd = arrayOf(bazelPath.toString(), "version")
     logger.i { "Executing Bazel version command: ${cmd.joinToString()}" }
     val result =
         process(
@@ -45,12 +45,19 @@ class BazelQueryService(
       throw RuntimeException("Bazel version command failed, exit code ${result.resultCode}")
     }
 
-    if (result.output.size != 1 || !result.output.first().startsWith("bazel ")) {
-      throw RuntimeException("Bazel version command returned unexpected output: ${result.output}")
-    }
+    // "bazel version" outputs "Build label: X.Y.Z" on one of the lines; accept that or legacy "bazel X.Y.Z".
+    val versionString =
+        result.output
+            .firstOrNull { it.startsWith("Build label: ") }
+            ?.removePrefix("Build label: ")?.trim()
+            ?: result.output
+                .firstOrNull { it.startsWith("bazel ") }
+                ?.removePrefix("bazel ")?.trim()
+            ?: throw RuntimeException(
+                "Bazel version command returned unexpected output: ${result.output}")
     // Trim off any prerelease suffixes (e.g., 8.6.0-rc1 or 8.6.0rc1).
-    val versionString = result.output.first().removePrefix("bazel ").trim().split('-')[0]
-    val version = versionString.split('.').map { it.takeWhile { c -> c.isDigit() }.toInt() }.toTypedArray()
+    val version =
+        versionString.split('-')[0].split('.').map { it.takeWhile { c -> c.isDigit() }.toInt() }.toTypedArray()
     return Triple(version[0], version[1], version[2])
   }
 

README.md

@@ -136,6 +136,37 @@ class E2ETest {
     testE2E(emptyList(), emptyList(), "/fixture/impacted_targets-1-2.txt")
   }
 
+  @Test
+  fun testDetermineBazelVersion() {
+    // E2E coverage for BazelQueryService.determineBazelVersion(): version is resolved lazily
+    // when the first query runs. Running generate-hashes to completion validates that
+    // "bazel version" is executed and parsed successfully (e.g. "Build label: X.Y.Z").
+    val projectA = extractFixtureProject("/fixture/integration-test-1.zip")
+    val workingDirectory = File(projectA, "integration")
+    val outputDir = temp.newFolder()
+    val outputPath = File(outputDir, "hashes.json")
+
+    val cli = CommandLine(BazelDiff())
+    val exitCode = cli.execute(
+        "generate-hashes",
+        "-w",
+        workingDirectory.absolutePath,
+        "-b",
+        "bazel",
+        outputPath.absolutePath)
+
+    assertThat(exitCode).isEqualTo(0)
+    assertThat(outputPath.readText().isNotEmpty()).isEqualTo(true)
+  }
+
+  @Test
+  fun testE2EWithNoKeepGoing() {
+    testE2E(
+        listOf("--no-keep_going"),
+        emptyList(),
+        "/fixture/impacted_targets-1-2.txt")
+  }
+
   @Test
   fun testE2EIncludingTargetType() {
     testE2E(
@@ -996,6 +1027,19 @@ class E2ETest {
     // which is designed to fail during analysis
     assertThat(exitCodeWithCquery).isEqualTo(1)
 
+    // Test with --no-keep_going: cquery should fail (no partial results, immediate failure)
+    val outputNoKeepGoing = File(outputDir, "hashes_no_keep_going.json")
+    val exitCodeWithNoKeepGoing = cli.execute(
+        "generate-hashes",
+        "-w",
+        workspace.absolutePath,
+        "-b",
+        "bazel",
+        "--useCquery",
+        "--no-keep_going",
+        outputNoKeepGoing.absolutePath)
+    assertThat(exitCodeWithNoKeepGoing).isEqualTo(1)
+
     // Test with --keep_going enabled (default behavior)
     // With keep_going, cquery returns partial results but still exits with code 1
     // The current implementation allows exit codes 0 and 3, but cquery with keep_going