From dfdf2b019afb665b5b30cf0dd41ea16eef81568e Mon Sep 17 00:00:00 2001 From: k3nny Date: Sat, 11 Jul 2026 17:59:13 +0200 Subject: [PATCH] =?UTF-8?q?feat(gradle):=20release=20v1.6.0=20=E2=80=94=20?= =?UTF-8?q?Gradle=20build=20file=20version=20bump?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Add internal/gradle package with ReadVersion and WriteVersion for build.gradle (Groovy DSL, single-quoted) and build.gradle.kts (Kotlin DSL, double-quoted). Quote style is preserved on write. regexp.QuoteMeta ensures version strings with dots or special characters are safe. Config follows the established multi-value pattern: - gradle.build_file: single path (opt-in, no default) - gradle.build_files: list for multi-module projects (overrides build_file) - --gradle flag overrides build_file and clears build_files 100% per-package statement coverage maintained across all 13 packages; FuzzReadVersion and FuzzWriteVersion added per fuzzing guidelines. Co-Authored-By: Claude Sonnet 4.6 --- .releaser.yml | 11 ++ CHANGELOG.md | 9 ++ CLAUDE.md | 3 +- README.md | 10 +- ROADMAP.md | 2 +- cmd/main.go | 74 +++++++++++--- cmd/main_test.go | 117 ++++++++++++++++++++- docs/content/changelog.md | 17 ++++ docs/content/configuration.md | 29 ++++++ docs/content/usage.md | 1 + internal/config/config.go | 26 +++++ internal/config/config_test.go | 46 +++++++++ internal/gradle/gradle.go | 54 ++++++++++ internal/gradle/gradle_test.go | 180 +++++++++++++++++++++++++++++++++ 14 files changed, 558 insertions(+), 21 deletions(-) create mode 100644 internal/gradle/gradle.go create mode 100644 internal/gradle/gradle_test.go diff --git a/.releaser.yml b/.releaser.yml index fb3e0d8..e48912a 100644 --- a/.releaser.yml +++ b/.releaser.yml @@ -50,6 +50,17 @@ git: # - "packages/frontend/package.json" # - "packages/backend/package.json" +# gradle: + # Single build.gradle or build.gradle.kts path (opt-in — no default). + # Both Groovy DSL (single-quoted) and Kotlin DSL (double-quoted) are supported. + # build_file: "build.gradle" + + # Multiple build files for multi-module projects (overrides build_file). + # build_files: + # - "build.gradle" + # - "module-a/build.gradle" + # - "module-b/build.gradle" + gitlab: # GitLab instance URL. Falls back to the CI_SERVER_URL environment variable. # url: "https://gitlab.example.com" diff --git a/CHANGELOG.md b/CHANGELOG.md index 9f204e5..7bab5d2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,6 +3,15 @@ All notable changes to this project will be documented in this file. Format: [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). +## [1.6.0] - 2026-07-11 + +### Added + +- **Gradle support** — new `internal/gradle` package; reads and writes the version assignment in `build.gradle` (Groovy DSL, single-quoted) and `build.gradle.kts` (Kotlin DSL, double-quoted); original quote style preserved on write; `regexp.QuoteMeta` ensures version strings with dots or special chars are safe +- **`gradle.build_file` / `gradle.build_files` config** — opt-in, no default; `build_files` list overrides `build_file` for multi-module projects; follows the same multi-value pattern as `maven.pom_paths` and `node.package_jsons` +- **`--gradle ` flag** — overrides `gradle.build_file` from config and clears `gradle.build_files`; mirrored in verbose config table as `gradle.paths` +- **`FuzzReadVersion` / `FuzzWriteVersion`** in `internal/gradle` — 100% per-package statement coverage maintained across all 13 packages + ## [1.5.1] - 2026-07-11 ### Added diff --git a/CLAUDE.md b/CLAUDE.md index 194bbbd..8b2f2fb 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -61,12 +61,13 @@ All seed cases must pass. The table below is authoritative — keep it in sync w | `internal/branch` | `FuzzParse` | parses branch name strings | | `internal/changelog` | `FuzzUpdate` | rewrites arbitrary existing file content | | `internal/commits` | `FuzzParse` | parses arbitrary commit message strings | +| `internal/gradle` | `FuzzReadVersion`, `FuzzWriteVersion` | reads/rewrites arbitrary Gradle build file content | | `internal/glclient` | `FuzzEncodeProjectPath` | encodes arbitrary project path strings | | `internal/maven` | `FuzzReadVersion`, `FuzzReplaceProjectVersion` | reads/rewrites arbitrary XML file content | | `internal/node` | `FuzzReadVersion`, `FuzzWriteVersion` | reads/rewrites arbitrary JSON file content | | `internal/notes` | `FuzzGenerate` | generates notes from arbitrary commit messages | -Packages **not** requiring fuzz tests (no free-form text parsing): `internal/config` (yaml.v3 handles parsing), `internal/ghclient` (HTTP client, no text parsing), `internal/gitutil` (git operations), `internal/version` (typed inputs only), `cmd` (CLI orchestration). +Packages **not** requiring fuzz tests (no free-form text parsing): `internal/config` (yaml.v3 handles parsing), `internal/ghclient` (HTTP client, no text parsing), `internal/gitutil` (git operations), `internal/version` (typed inputs only), `cmd` (CLI orchestration). When adding a new package, check whether it parses text or rewrites files — if yes, add a row above. Fuzz seed corpus guidelines: - Include a realistic happy-path input as the first seed. diff --git a/README.md b/README.md index ce79404..efb9951 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # releaser -![release](https://img.shields.io/badge/release-v1.5.1-blue.svg) +![release](https://img.shields.io/badge/release-v1.6.0-blue.svg) A CI-friendly release automation tool for GitFlow workflows using Conventional Commits. @@ -23,7 +23,7 @@ release/1.2 branch 2. **Tag discovery** — finds the latest tag matching `major.minor.*` on the current branch 3. **Commit analysis** — parses Conventional Commits between last tag and HEAD 4. **Version bump** — increments patch (the minor is owned by the branch) -5. **Release** — updates `pom.xml`, commits, tags, creates GitLab or GitHub release +5. **Release** — updates `pom.xml` / `package.json` / `build.gradle`, commits, tags, creates GitLab or GitHub release ## Version bump rules @@ -115,6 +115,12 @@ node: # opt-in — no default; om # - "packages/frontend/package.json" # - "packages/backend/package.json" +gradle: # opt-in — no default; omit to skip + # build_file: "build.gradle" # Groovy or Kotlin DSL; single path + # build_files: # multi-module: list overrides build_file + # - "build.gradle" + # - "module-a/build.gradle" + gitlab: url: "https://gitlab.example.com" # or env CI_SERVER_URL token: "" # env GITLAB_TOKEN (never commit this) diff --git a/ROADMAP.md b/ROADMAP.md index 47c35e0..60be26f 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -85,5 +85,5 @@ ## Future / backlog -- Gradle support (`build.gradle` / `build.gradle.kts`) +- ~~Gradle support (`build.gradle` / `build.gradle.kts`)~~ — ✓ shipped v1.6.0 (`internal/gradle`; Groovy + Kotlin DSL; multi-module via `gradle.build_files`; `--gradle` flag) - Slack / Teams notification on release diff --git a/cmd/main.go b/cmd/main.go index e0652b3..7b2dddf 100644 --- a/cmd/main.go +++ b/cmd/main.go @@ -18,6 +18,7 @@ import ( "git.k3nny.fr/releaser/internal/ghclient" "git.k3nny.fr/releaser/internal/gitutil" "git.k3nny.fr/releaser/internal/glclient" + "git.k3nny.fr/releaser/internal/gradle" "git.k3nny.fr/releaser/internal/maven" "git.k3nny.fr/releaser/internal/node" "git.k3nny.fr/releaser/internal/notes" @@ -78,6 +79,17 @@ node: # - "packages/frontend/package.json" # - "packages/backend/package.json" +gradle: + # Single build.gradle or build.gradle.kts path (opt-in — no default). + # Both Groovy DSL (single-quoted) and Kotlin DSL (double-quoted) are supported. + # build_file: "build.gradle" + + # Multiple build files for multi-module projects (overrides build_file). + # build_files: + # - "build.gradle" + # - "module-a/build.gradle" + # - "module-b/build.gradle" + gitlab: # GitLab instance URL. Falls back to the CI_SERVER_URL environment variable. # url: "https://gitlab.example.com" @@ -149,6 +161,7 @@ func newRootCmd() *cobra.Command { branchOverride string repoPath string pomOverride string + gradleOverride string changelogFile string tagPrefixFlag string tagPrefixSet bool @@ -171,6 +184,7 @@ func newRootCmd() *cobra.Command { repoPath: repoPath, branchOverride: branchOverride, pomOverride: pomOverride, + gradleOverride: gradleOverride, changelogFile: changelogFile, tagPrefixFlag: tagPrefixFlag, tagPrefixSet: tagPrefixSet, @@ -196,6 +210,7 @@ func newRootCmd() *cobra.Command { root.Flags().StringVar(&branchOverride, "branch", "", "override branch name detection (required in detached HEAD)") root.Flags().StringVar(&repoPath, "repo", ".", "path to git repository") root.Flags().StringVar(&pomOverride, "pom", "", "override maven.pom_path from config") + root.Flags().StringVar(&gradleOverride, "gradle", "", "override gradle.build_file from config") root.Flags().StringVar(&changelogFile, "changelog-file", "CHANGELOG.md", "path to changelog file relative to repo root") root.Flags().StringVar(&tagPrefixFlag, "tag-prefix", "", "override git.tag_prefix from config") root.Flags().StringVar(&patternFlag, "branch-pattern", "", "override git.branch_pattern from config") @@ -215,22 +230,23 @@ func main() { } type options struct { - init bool - verbose bool - repoPath string - branchOverride string - pomOverride string - changelogFile string - tagPrefixFlag string - tagPrefixSet bool - patternFlag string - patternSet bool - dryRun bool - noPush bool - noRelease bool - noCommit bool - tagOnly bool - releaseEnvFile string + init bool + verbose bool + repoPath string + branchOverride string + pomOverride string + gradleOverride string + changelogFile string + tagPrefixFlag string + tagPrefixSet bool + patternFlag string + patternSet bool + dryRun bool + noPush bool + noRelease bool + noCommit bool + tagOnly bool + releaseEnvFile string } func printVerboseConfig(cfg config.Config, src config.Sources) { @@ -273,6 +289,13 @@ func printVerboseConfig(cfg config.Config, src config.Sources) { } return strings.Join(paths, ", ") }()}, + {"gradle.paths", func() string { + paths := cfg.Gradle.EffectiveBuildFiles() + if len(paths) == 0 { + return "(not configured)" + } + return strings.Join(paths, ", ") + }()}, {"gitlab.url", cfg.GitLab.URL}, {"gitlab.token", func() string { if cfg.GitLab.Token != "" { @@ -360,6 +383,11 @@ func run(o options) error { cfg.Maven.PomPaths = nil src["maven.pom_paths"] = "flag: --pom" } + if o.gradleOverride != "" { + cfg.Gradle.BuildFile = o.gradleOverride + cfg.Gradle.BuildFiles = nil + src["gradle.build_files"] = "flag: --gradle" + } if o.patternSet { cfg.Git.BranchPattern = o.patternFlag src["git.branch_pattern"] = "flag: --branch-pattern" @@ -552,6 +580,20 @@ func run(o options) error { filesToCommit = append(filesToCommit, relPkgPath) } + // build.gradle / build.gradle.kts (opt-in via gradle.build_file / gradle.build_files) + for _, relGradlePath := range cfg.Gradle.EffectiveBuildFiles() { + gradlePath := filepath.Join(absRepo, relGradlePath) + currentGradleVersion, err := gradle.ReadVersion(gradlePath) + if err != nil { + return fmt.Errorf("read gradle version: %w", err) + } + if err := gradle.WriteVersion(gradlePath, currentGradleVersion, nextVersion); err != nil { + return fmt.Errorf("update gradle version: %w", err) + } + logDone("%s: %s → %s", relGradlePath, currentGradleVersion, nextVersion) + filesToCommit = append(filesToCommit, relGradlePath) + } + // CHANGELOG.md changelogAbsPath := filepath.Join(absRepo, o.changelogFile) if err := changelog.Update(changelogAbsPath, nextTag, nextVersion, messages); err != nil { diff --git a/cmd/main_test.go b/cmd/main_test.go index 239846c..8713ce7 100644 --- a/cmd/main_test.go +++ b/cmd/main_test.go @@ -1093,7 +1093,8 @@ func TestPrintVerboseConfigBumpRulesAndNode(t *testing.T) { Git: config.GitConfig{ BumpRules: config.BumpRulesConfig{Breaking: "minor", Feat: "minor", Fix: "minor"}, }, - Node: config.NodeConfig{PackageJSON: "package.json"}, + Node: config.NodeConfig{PackageJSON: "package.json"}, + Gradle: config.GradleConfig{BuildFile: "build.gradle"}, } src := config.Sources{} @@ -1112,6 +1113,9 @@ func TestPrintVerboseConfigBumpRulesAndNode(t *testing.T) { if !strings.Contains(output, "package.json") { t.Error("expected 'package.json' in output for node.paths") } + if !strings.Contains(output, "build.gradle") { + t.Error("expected 'build.gradle' in output for gradle.paths") + } } // ── node package.json handling ──────────────────────────────────────────────── @@ -1200,3 +1204,114 @@ func TestRunNodeWriteVersionFails(t *testing.T) { t.Fatal("expected error when package.json is read-only") } } + +// ── gradle build file handling ──────────────────────────────────────────────── + +func writeGradleFile(t *testing.T, dir, ver string) { + t.Helper() + content := fmt.Sprintf("group = \"com.example\"\nversion = \"%s\"\n", ver) + if err := os.WriteFile(filepath.Join(dir, "build.gradle"), []byte(content), 0644); err != nil { + t.Fatal(err) + } +} + +func TestRunGradleVersionBump(t *testing.T) { + dir := t.TempDir() + repo, err := gogit.PlainInit(dir, false) + if err != nil { + t.Fatal(err) + } + writeGradleFile(t, dir, "0.0.0") + commitAll(t, repo, dir, "chore: init") + + os.WriteFile(filepath.Join(dir, ".releaser.yml"), []byte("gradle:\n build_file: \"build.gradle\"\n"), 0644) + + addFile(t, dir, "x.go", "// fix") + w, _ := repo.Worktree() + w.Add("x.go") + w.Commit("fix: something", &gogit.CommitOptions{Author: testSig()}) + + if err := execCmd(t, "--no-push", "--branch", "release/1.2", "--repo", dir); err != nil { + t.Fatalf("gradle version bump: unexpected error: %v", err) + } + + data, _ := os.ReadFile(filepath.Join(dir, "build.gradle")) + if !strings.Contains(string(data), `version = "1.2.0"`) { + t.Errorf("expected version 1.2.0 in build.gradle, got: %s", data) + } +} + +func TestRunGradleOverrideFlag(t *testing.T) { + dir := t.TempDir() + repo, err := gogit.PlainInit(dir, false) + if err != nil { + t.Fatal(err) + } + // Write gradle file at custom path + if err := os.MkdirAll(filepath.Join(dir, "sub"), 0755); err != nil { + t.Fatal(err) + } + content := "version = \"0.0.0\"\n" + os.WriteFile(filepath.Join(dir, "sub", "build.gradle"), []byte(content), 0644) + commitAll(t, repo, dir, "chore: init") + + addFile(t, dir, "x.go", "// fix") + w, _ := repo.Worktree() + w.Add("x.go") + w.Commit("fix: something", &gogit.CommitOptions{Author: testSig()}) + + if err := execCmd(t, "--no-push", "--branch", "release/1.2", "--repo", dir, "--gradle", "sub/build.gradle"); err != nil { + t.Fatalf("--gradle flag: unexpected error: %v", err) + } + + data, _ := os.ReadFile(filepath.Join(dir, "sub", "build.gradle")) + if !strings.Contains(string(data), `version = "1.2.0"`) { + t.Errorf("expected version 1.2.0, got: %s", data) + } +} + +func TestRunGradleReadVersionFails(t *testing.T) { + dir := t.TempDir() + repo, err := gogit.PlainInit(dir, false) + if err != nil { + t.Fatal(err) + } + // build.gradle with no version assignment + os.WriteFile(filepath.Join(dir, "build.gradle"), []byte(`group = "com.example"`), 0644) + commitAll(t, repo, dir, "chore: init") + + os.WriteFile(filepath.Join(dir, ".releaser.yml"), []byte("gradle:\n build_file: \"build.gradle\"\n"), 0644) + + addFile(t, dir, "x.go", "// fix") + w, _ := repo.Worktree() + w.Add("x.go") + w.Commit("fix: something", &gogit.CommitOptions{Author: testSig()}) + + if err := execCmd(t, "--branch", "release/1.2", "--repo", dir); err == nil { + t.Fatal("expected error when build.gradle has no version assignment") + } +} + +func TestRunGradleWriteVersionFails(t *testing.T) { + dir := t.TempDir() + repo, err := gogit.PlainInit(dir, false) + if err != nil { + t.Fatal(err) + } + writeGradleFile(t, dir, "0.0.0") + commitAll(t, repo, dir, "chore: init") + + os.WriteFile(filepath.Join(dir, ".releaser.yml"), []byte("gradle:\n build_file: \"build.gradle\"\n"), 0644) + + addFile(t, dir, "x.go", "// fix") + w, _ := repo.Worktree() + w.Add("x.go") + w.Commit("fix: something", &gogit.CommitOptions{Author: testSig()}) + + os.Chmod(filepath.Join(dir, "build.gradle"), 0444) + defer os.Chmod(filepath.Join(dir, "build.gradle"), 0644) + + if err := execCmd(t, "--branch", "release/1.2", "--repo", dir); err == nil { + t.Fatal("expected error when build.gradle is read-only") + } +} diff --git a/docs/content/changelog.md b/docs/content/changelog.md index 4a327a9..b2b2906 100644 --- a/docs/content/changelog.md +++ b/docs/content/changelog.md @@ -3,6 +3,23 @@ title: Changelog weight: 50 --- +## v1.6.0 — 2026-07-11 + +### Added + +- **Gradle support** — opt-in via `gradle.build_file` (single path) or `gradle.build_files` (list, overrides single); supports both Groovy DSL (`version = '1.2.3'`) and Kotlin DSL (`version = "1.2.3"`); original quote style preserved on write; `--gradle ` CLI flag for one-off overrides + +## v1.5.1 — 2026-07-11 + +### Added + +- **Documentation site** — Hugo + Geekdoc; installation, CLI reference, configuration, CI integration, and changelog pages; deployed to `gh-pages` via Gitea CI on push to `main` +- **`FuzzUpdate`** in `internal/changelog` and **`FuzzWriteVersion`** in `internal/node` — complete fuzz coverage for all file-rewriting packages + +### Changed + +- **CLAUDE.md** — fuzzing completeness guidelines with authoritative table + ## v1.5.0 — 2026-07-11 ### Added diff --git a/docs/content/configuration.md b/docs/content/configuration.md index dc58d47..fdb667d 100644 --- a/docs/content/configuration.md +++ b/docs/content/configuration.md @@ -45,6 +45,14 @@ node: # opt-in — omit section t # - "packages/frontend/package.json" # - "packages/backend/package.json" +gradle: # opt-in — omit section to skip + # build_file: "build.gradle" # Groovy or Kotlin DSL; single path + + # Multi-module: list overrides build_file. + # build_files: + # - "build.gradle" + # - "module-a/build.gradle" + gitlab: url: "https://gitlab.example.com" # or env CI_SERVER_URL token: "" # prefer env GITLAB_TOKEN @@ -119,3 +127,24 @@ node: - "packages/frontend/package.json" - "packages/backend/package.json" ``` + +## Gradle support + +The `gradle` section is opt-in — if omitted, no build file is touched. Both Groovy DSL (`version = '1.2.3'`) and Kotlin DSL (`version = "1.2.3"`) are supported; the original quote style is preserved on write. + +```yaml +gradle: + build_file: "build.gradle" +``` + +Use `build_files` for multi-module projects: + +```yaml +gradle: + build_files: + - "build.gradle" + - "module-a/build.gradle" + - "module-b/build.gradle" +``` + +The `--gradle ` CLI flag sets a single build file path and clears `build_files`. diff --git a/docs/content/usage.md b/docs/content/usage.md index 71dd12b..43b9d64 100644 --- a/docs/content/usage.md +++ b/docs/content/usage.md @@ -39,6 +39,7 @@ releaser --verbose --dry-run | `--branch-pattern ` | `^(?:.*/)?release/(\d+)\.(\d+)$` | Override branch pattern (two capture groups: major, minor) | | `--tag-prefix ` | `""` | Prefix for version tags (e.g. `v` → `v1.2.3`) | | `--pom ` | `pom.xml` | Path to pom.xml relative to repo root | +| `--gradle ` | — | Override `gradle.build_file` from config | | `--changelog-file ` | `CHANGELOG.md` | Path to changelog file | | `--release-env-file ` | `release.env` | Path for dotenv artifact; pass `""` to disable | | `--no-commit` | false | Update version files but stop before committing | diff --git a/internal/config/config.go b/internal/config/config.go index bdeb4a3..f804ea6 100644 --- a/internal/config/config.go +++ b/internal/config/config.go @@ -17,6 +17,7 @@ type Config struct { Git GitConfig `yaml:"git"` Maven MavenConfig `yaml:"maven"` Node NodeConfig `yaml:"node"` + Gradle GradleConfig `yaml:"gradle"` GitLab GitLabConfig `yaml:"gitlab"` GitHub GitHubConfig `yaml:"github"` } @@ -73,6 +74,23 @@ func (n NodeConfig) EffectivePaths() []string { return nil } +type GradleConfig struct { + BuildFile string `yaml:"build_file"` // single path (opt-in, no default) + BuildFiles []string `yaml:"build_files"` // multiple paths; overrides BuildFile +} + +// EffectiveBuildFiles returns the list of Gradle build file paths to process. +// Returns nil when no gradle paths are configured (gradle processing is opt-in). +func (g GradleConfig) EffectiveBuildFiles() []string { + if len(g.BuildFiles) > 0 { + return g.BuildFiles + } + if g.BuildFile != "" { + return []string{g.BuildFile} + } + return nil +} + type GitLabConfig struct { URL string `yaml:"url"` Token string `yaml:"token"` @@ -117,6 +135,8 @@ func defaultSources() Sources { "maven.pom_paths": "default", "node.package_json": "default", "node.package_jsons": "default", + "gradle.build_file": "default", + "gradle.build_files": "default", "gitlab.url": "default", "gitlab.token": "default", "gitlab.project": "default", @@ -193,6 +213,12 @@ func LoadWithSources(dir string) (Config, Sources, error) { if len(overlay.Node.PackageJSONs) > 0 { src["node.package_jsons"] = "config file" } + if overlay.Gradle.BuildFile != "" { + src["gradle.build_file"] = "config file" + } + if len(overlay.Gradle.BuildFiles) > 0 { + src["gradle.build_files"] = "config file" + } if overlay.GitLab.URL != "" { src["gitlab.url"] = "config file" } diff --git a/internal/config/config_test.go b/internal/config/config_test.go index 88582ed..8ec882a 100644 --- a/internal/config/config_test.go +++ b/internal/config/config_test.go @@ -292,6 +292,52 @@ func TestApplyEnvWithSourcesCIServerURL(t *testing.T) { } } +func TestGradleEffectiveBuildFiles(t *testing.T) { + // Neither set → nil (opt-in) + if got := (GradleConfig{}).EffectiveBuildFiles(); got != nil { + t.Errorf("empty config: got %v, want nil", got) + } + // BuildFile only + if got := (GradleConfig{BuildFile: "build.gradle"}).EffectiveBuildFiles(); len(got) != 1 || got[0] != "build.gradle" { + t.Errorf("BuildFile only: got %v", got) + } + // BuildFiles wins over BuildFile + g := GradleConfig{BuildFile: "build.gradle", BuildFiles: []string{"a/build.gradle", "b/build.gradle"}} + if got := g.EffectiveBuildFiles(); len(got) != 2 || got[0] != "a/build.gradle" { + t.Errorf("BuildFiles priority: got %v", got) + } +} + +func TestLoadGradleSources(t *testing.T) { + dir := t.TempDir() + content := "gradle:\n build_file: \"build.gradle\"\n" + if err := os.WriteFile(filepath.Join(dir, filename), []byte(content), 0644); err != nil { + t.Fatal(err) + } + _, src, err := LoadWithSources(dir) + if err != nil { + t.Fatal(err) + } + if src["gradle.build_file"] != "config file" { + t.Errorf("src[gradle.build_file] = %q, want %q", src["gradle.build_file"], "config file") + } +} + +func TestLoadGradleBuildFilesSources(t *testing.T) { + dir := t.TempDir() + content := "gradle:\n build_files:\n - \"a/build.gradle\"\n - \"b/build.gradle\"\n" + if err := os.WriteFile(filepath.Join(dir, filename), []byte(content), 0644); err != nil { + t.Fatal(err) + } + _, src, err := LoadWithSources(dir) + if err != nil { + t.Fatal(err) + } + if src["gradle.build_files"] != "config file" { + t.Errorf("src[gradle.build_files] = %q, want %q", src["gradle.build_files"], "config file") + } +} + func TestLoadPartialOverride(t *testing.T) { dir := t.TempDir() // Only override tag_prefix — commit_message should keep its default diff --git a/internal/gradle/gradle.go b/internal/gradle/gradle.go new file mode 100644 index 0000000..43a1ab7 --- /dev/null +++ b/internal/gradle/gradle.go @@ -0,0 +1,54 @@ +package gradle + +import ( + "fmt" + "os" + "regexp" +) + +// versionRe matches a Gradle/Kotlin DSL version assignment on its own line. +// Group 1 captures the version string (without quotes). +// Handles both double-quoted (Kotlin/Groovy) and single-quoted (Groovy) forms, +// with or without spaces around =. +var versionRe = regexp.MustCompile(`(?m)^[ \t]*version\s*=\s*["']([^"']+)["']`) + +// ReadVersion returns the version value from a build.gradle or build.gradle.kts file. +func ReadVersion(path string) (string, error) { + data, err := os.ReadFile(path) + if err != nil { + return "", fmt.Errorf("read %s: %w", path, err) + } + m := versionRe.FindStringSubmatch(string(data)) + if m == nil { + return "", fmt.Errorf("no version assignment found in %s", path) + } + return m[1], nil +} + +// WriteVersion replaces the version assignment in a build.gradle or build.gradle.kts +// file in-place. oldVersion must match what ReadVersion returned. Quote style is preserved. +func WriteVersion(path, oldVersion, newVersion string) error { + data, err := os.ReadFile(path) + if err != nil { + return fmt.Errorf("read %s: %w", path, err) + } + updated, ok := replaceVersion(string(data), oldVersion, newVersion) + if !ok { + return fmt.Errorf("version %q not found in %s", oldVersion, path) + } + return os.WriteFile(path, []byte(updated), 0644) +} + +// replaceVersion finds and replaces the first version assignment line in a Gradle build file. +// Quote style (single or double) of the original line is preserved. +// Returns the updated content and true if a replacement was made. +func replaceVersion(content, oldVersion, newVersion string) (string, bool) { + re := regexp.MustCompile(`(?m)^([ \t]*version\s*=\s*)(["'])` + regexp.QuoteMeta(oldVersion) + `["']`) + m := re.FindStringSubmatchIndex(content) + if m == nil { + return content, false + } + prefix := content[m[2]:m[3]] // "version = " etc., preserving whitespace + quote := content[m[4]:m[5]] // " or ' + return content[:m[0]] + prefix + quote + newVersion + quote + content[m[1]:], true +} diff --git a/internal/gradle/gradle_test.go b/internal/gradle/gradle_test.go new file mode 100644 index 0000000..32ed906 --- /dev/null +++ b/internal/gradle/gradle_test.go @@ -0,0 +1,180 @@ +package gradle + +import ( + "os" + "path/filepath" + "strings" + "testing" +) + +const gradleGroovy = `plugins { + id 'java' +} + +group = 'com.example' +version = '1.2.3' +description = 'My project' +` + +const gradleKotlin = `plugins { + kotlin("jvm") version "1.9.0" +} + +group = "com.example" +version = "1.2.3" +description = "My project" +` + +func writeGradle(t *testing.T, content string) string { + t.Helper() + path := filepath.Join(t.TempDir(), "build.gradle") + if err := os.WriteFile(path, []byte(content), 0644); err != nil { + t.Fatal(err) + } + return path +} + +// ── ReadVersion ────────────────────────────────────────────────────────────── + +func TestReadVersionGroovy(t *testing.T) { + got, err := ReadVersion(writeGradle(t, gradleGroovy)) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if got != "1.2.3" { + t.Errorf("got %q, want 1.2.3", got) + } +} + +func TestReadVersionKotlin(t *testing.T) { + got, err := ReadVersion(writeGradle(t, gradleKotlin)) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if got != "1.2.3" { + t.Errorf("got %q, want 1.2.3", got) + } +} + +func TestReadVersionNoSpaces(t *testing.T) { + got, err := ReadVersion(writeGradle(t, `version="1.0.0"`)) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if got != "1.0.0" { + t.Errorf("got %q, want 1.0.0", got) + } +} + +func TestReadVersionMissingFile(t *testing.T) { + _, err := ReadVersion(filepath.Join(t.TempDir(), "build.gradle")) + if err == nil { + t.Error("expected error for missing file") + } +} + +func TestReadVersionNoVersionField(t *testing.T) { + _, err := ReadVersion(writeGradle(t, `group = "com.example"`)) + if err == nil { + t.Error("expected error when no version assignment is present") + } +} + +// ── WriteVersion ───────────────────────────────────────────────────────────── + +func TestWriteVersionKotlin(t *testing.T) { + path := writeGradle(t, gradleKotlin) + if err := WriteVersion(path, "1.2.3", "1.2.4"); err != nil { + t.Fatalf("unexpected error: %v", err) + } + data, _ := os.ReadFile(path) + if !strings.Contains(string(data), `version = "1.2.4"`) { + t.Errorf("expected updated version; got:\n%s", data) + } + // plugin version declaration must not be touched + if !strings.Contains(string(data), `kotlin("jvm") version "1.9.0"`) { + t.Error("plugin version was incorrectly modified") + } +} + +func TestWriteVersionGroovy(t *testing.T) { + path := writeGradle(t, gradleGroovy) + if err := WriteVersion(path, "1.2.3", "1.2.4"); err != nil { + t.Fatalf("unexpected error: %v", err) + } + data, _ := os.ReadFile(path) + if !strings.Contains(string(data), `version = '1.2.4'`) { + t.Errorf("expected updated version with single quotes; got:\n%s", data) + } +} + +func TestWriteVersionMissingFile(t *testing.T) { + err := WriteVersion(filepath.Join(t.TempDir(), "build.gradle"), "1.0.0", "1.0.1") + if err == nil { + t.Error("expected error for missing file") + } +} + +func TestWriteVersionNotFound(t *testing.T) { + path := writeGradle(t, gradleKotlin) + err := WriteVersion(path, "9.9.9", "9.9.10") + if err == nil { + t.Error("expected error when old version not found in file") + } +} + +func TestWriteVersionReadOnly(t *testing.T) { + path := writeGradle(t, gradleKotlin) + os.Chmod(path, 0444) + defer os.Chmod(path, 0644) + err := WriteVersion(path, "1.2.3", "1.2.4") + if err == nil { + t.Error("expected error writing to read-only file") + } +} + +// ── replaceVersion ──────────────────────────────────────────────────────────── + +func TestReplaceVersionNotFound(t *testing.T) { + content := `group = "com.example"` + got, ok := replaceVersion(content, "1.0.0", "1.0.1") + if ok { + t.Error("expected ok=false when version not present") + } + if got != content { + t.Error("content should be unchanged when not found") + } +} + +// ── fuzz ────────────────────────────────────────────────────────────────────── + +// FuzzReadVersion verifies ReadVersion never panics on arbitrary file content. +func FuzzReadVersion(f *testing.F) { + f.Add(gradleGroovy) + f.Add(gradleKotlin) + f.Add(`version="1.0.0"`) + f.Add(`group = "com.example"`) + f.Add("") + f.Add("\x00\xff") + + f.Fuzz(func(t *testing.T, content string) { + path := filepath.Join(t.TempDir(), "build.gradle") + os.WriteFile(path, []byte(content), 0644) //nolint:errcheck + ReadVersion(path) //nolint:errcheck + }) +} + +// FuzzWriteVersion verifies WriteVersion never panics on arbitrary content or version strings. +func FuzzWriteVersion(f *testing.F) { + f.Add(gradleGroovy, "1.2.3", "1.2.4") + f.Add(gradleKotlin, "1.2.3", "1.2.4") + f.Add(`version="1.0.0"`, "1.0.0", "1.0.1") + f.Add("", "1.0.0", "1.0.1") + f.Add(`version = "1.0.0"`, "", "1.0.1") + + f.Fuzz(func(t *testing.T, content, oldVersion, newVersion string) { + path := filepath.Join(t.TempDir(), "build.gradle") + os.WriteFile(path, []byte(content), 0644) //nolint:errcheck + WriteVersion(path, oldVersion, newVersion) //nolint:errcheck + }) +}