checkpoint: before remove starlark_library gen

Author: pcj

language/starlarkbundle/bazelignore_test.go

@@ -0,0 +1,149 @@
+/* Copyright 2020 The Bazel Authors. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package starlarkbundle
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestRemoveAbsolutePathsFromBazelignore(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected string
+		removed  bool
+	}{
+		{
+			name: "removes absolute paths",
+			input: `.build/
+/.github/
+.swiftpm/
+/.vscode/
+`,
+			expected: `.build/
+.swiftpm/
+`,
+			removed: true,
+		},
+		{
+			name: "keeps relative paths",
+			input: `.build/
+.github/
+.swiftpm/
+.vscode/
+`,
+			expected: `.build/
+.github/
+.swiftpm/
+.vscode/
+`,
+			removed: false,
+		},
+		{
+			name: "handles empty lines",
+			input: `.build/
+
+/.github/
+
+.swiftpm/
+`,
+			expected: `.build/
+
+
+.swiftpm/
+`,
+			removed: true,
+		},
+		{
+			name: "handles comments and absolute paths",
+			input: `# Comment
+.build/
+/absolute/path
+relative/path
+/another/absolute
+`,
+			expected: `# Comment
+.build/
+relative/path
+`,
+			removed: true,
+		},
+		{
+			name:     "empty file",
+			input:    "",
+			expected: "",
+			removed:  false,
+		},
+		{
+			name: "only absolute paths",
+			input: `/path1
+/path2
+/path3
+`,
+			expected: ``,
+			removed: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Create temp directory
+			tmpDir := t.TempDir()
+			bazelignorePath := filepath.Join(tmpDir, ".bazelignore")
+
+			// Write input content
+			if err := os.WriteFile(bazelignorePath, []byte(tt.input), 0644); err != nil {
+				t.Fatalf("failed to write test file: %v", err)
+			}
+
+			// Create extension
+			ext := NewLanguage().(*starlarkBundleLang)
+			ext.logger = nil // Disable logging for tests
+
+			// Run the function
+			err := ext.removeAbsolutePathsFromBazelignore(bazelignorePath)
+			if err != nil {
+				t.Fatalf("removeAbsolutePathsFromBazelignore failed: %v", err)
+			}
+
+			// Read result
+			result, err := os.ReadFile(bazelignorePath)
+			if err != nil {
+				t.Fatalf("failed to read result file: %v", err)
+			}
+
+			if string(result) != tt.expected {
+				t.Errorf("Content mismatch:\ngot:\n%q\n\nwant:\n%q", string(result), tt.expected)
+			}
+		})
+	}
+}
+
+func TestRemoveAbsolutePathsFromBazelignore_NonExistent(t *testing.T) {
+	tmpDir := t.TempDir()
+	bazelignorePath := filepath.Join(tmpDir, ".bazelignore")
+
+	ext := NewLanguage().(*starlarkBundleLang)
+	ext.logger = nil
+
+	// Should not error on non-existent file
+	err := ext.removeAbsolutePathsFromBazelignore(bazelignorePath)
+	if err != nil {
+		t.Errorf("expected no error for non-existent file, got: %v", err)
+	}
+}

language/starlarkbundle/language.go

@@ -23,10 +23,12 @@ package starlarkbundle
 
 import (
 	"flag"
+	"fmt"
 	"io"
 	"log"
 	"maps"
 	"os"
+	"path/filepath"
 	"strings"
 
 	"github.com/bazelbuild/bazel-gazelle/config"
@@ -39,17 +41,21 @@ import (
 
 const (
 	languageName                          = "starlark_bundle"
+	starlarkBundleRepoNameDirectiveName   = "starlark_bundle_repo_name"
 	starlarkBundleRootDirectiveName       = "starlark_bundle_root"
 	starlarkBundleExcludeDirectiveName    = "starlark_bundle_exclude"
 	starlarkBundleLogFileDirectiveName    = "starlark_bundle_log_file"
 	starlarkModuleDependencyDirectiveName = "module_dependency"
+	coarseDependencies                    = true
 )
 
 type starlarkBundleLang struct {
 	starlarkBundleRoot        *string
+	starlarkBundleRepoName    string
 	starlarkBundleExcludeDirs []string
 	moduleDeps                map[string]string
 	starlarkLibraries         map[label.Label]*rule.Rule
+	bzlFiles                  map[string]bool
 	logFile                   string
 	logWriter                 *os.File
 	logger                    *log.Logger
@@ -60,6 +66,7 @@ type starlarkBundleLang struct {
 func NewLanguage() language.Language {
 	return &starlarkBundleLang{
 		starlarkLibraries: map[label.Label]*rule.Rule{},
+		bzlFiles:          map[string]bool{},
 		moduleDeps:        map[string]string{},
 	}
 }
@@ -80,7 +87,7 @@ func (ext *starlarkBundleLang) RegisterFlags(fs *flag.FlagSet, cmd string, c *co
 
 func (ext *starlarkBundleLang) CheckFlags(fs *flag.FlagSet, c *config.Config) error {
 	if ext.logFile != "" {
-		ext.createLogger(c, ext.logFile)
+		ext.createLogger(ext.logFile)
 		ext.logf("CheckFlags: log file initialized from flag: %s", ext.logFile)
 	}
 	if ext.logger == nil {
@@ -108,6 +115,8 @@ func (ext *starlarkBundleLang) Configure(c *config.Config, rel string, f *rule.F
 					log.Fatalf("gazelle:%s should only be set once (refusing to override %q with %q)", starlarkBundleRootDirectiveName, *ext.starlarkBundleRoot, d.Value)
 				}
 				ext.starlarkBundleRoot = &rel
+			case starlarkBundleRepoNameDirectiveName:
+				ext.starlarkBundleRepoName = d.Value
 			case starlarkBundleExcludeDirectiveName:
 				ext.starlarkBundleExcludeDirs = append(ext.starlarkBundleExcludeDirs, d.Value)
 			case starlarkModuleDependencyDirectiveName:
@@ -118,13 +127,13 @@ func (ext *starlarkBundleLang) Configure(c *config.Config, rel string, f *rule.F
 				ext.moduleDeps[nameVersion[0]] = nameVersion[1]
 				ext.logf("Added module dependency: %q -> %q", nameVersion[0], nameVersion[1])
 			case starlarkBundleLogFileDirectiveName:
-				ext.createLogger(c, d.Value)
+				ext.createLogger(d.Value)
 			}
 		}
 	}
 }
 
-func (ext *starlarkBundleLang) createLogger(c *config.Config, logFile string) {
+func (ext *starlarkBundleLang) createLogger(logFile string) {
 	if logFile != "" {
 		f, err := os.OpenFile(logFile, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0666)
 		if err == nil {
@@ -202,7 +211,12 @@ func (ext *starlarkBundleLang) Resolve(c *config.Config, ix *resolve.RuleIndex,
 	case starlarkLibraryKind:
 		starlarkLibraryResolve(c, ix, r, importsRaw, from, ext)
 	case starlarkBundleKind:
-		starlarkBundleResolve(r, ext.starlarkLibraries)
+		if coarseDependencies {
+			starlarkBundleResolveCoarse(r, ext.starlarkLibraries, ext.moduleDeps)
+		} else {
+			starlarkBundleResolve(r, ext.starlarkLibraries)
+
+		}
 	}
 }
 
@@ -230,6 +244,26 @@ func (ext *starlarkBundleLang) GenerateRules(args language.GenerateArgs) (result
 
 	ext.logf("GenerateRules: visiting %s", args.Rel)
 
+	if args.Rel == "" {
+		// REPO.bazel causes visibility issues if the root BUILD file has been
+		// deleted but still referencing non-existent rules.  This should be
+		// moved to the part where gazelle cleans up build files.
+		repoFile := filepath.Join(args.Config.RepoRoot, "REPO.bazel")
+		if _, err := os.Stat(repoFile); err == nil {
+			ext.logf("Removing REPO.bazel from root package")
+			if err := os.Remove(repoFile); err != nil {
+				ext.logf("ERROR: failed to remove REPO.bazel: %v", err)
+			}
+		}
+
+		bazelIgnore := filepath.Join(args.Config.RepoRoot, "REPO.bazel")
+		if _, err := os.Stat(bazelIgnore); err == nil {
+			if err := ext.removeAbsolutePathsFromBazelignore(bazelIgnore); err != nil {
+				ext.logf("ERROR: failed to cleanup .bazelignore file: %v", err)
+			}
+		}
+	}
+
 	for _, r := range []language.GenerateResult{
 		starlarkLibraryGenerate(args, ext.starlarkLibraries, ext),
 		starlarkBundleGenerate(args, ext.starlarkBundleRoot),
@@ -264,3 +298,49 @@ func (ext *starlarkBundleLang) logf(format string, args ...any) {
 		ext.logger.Printf(format, args...)
 	}
 }
+
+// removeAbsolutePathsFromBazelignore reads a .bazelignore file and removes
+// any lines that are absolute paths (starting with /).
+func (ext *starlarkBundleLang) removeAbsolutePathsFromBazelignore(bazelignorePath string) error {
+	ext.logf("Checking .bazelignore file: %s", bazelignorePath)
+
+	// Read the file
+	content, err := os.ReadFile(bazelignorePath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil // File doesn't exist, nothing to do
+		}
+		return fmt.Errorf("failed to read .bazelignore: %w", err)
+	}
+
+	// Split into lines
+	lines := strings.Split(string(content), "\n")
+	var filteredLines []string
+	removedCount := 0
+
+	for _, line := range lines {
+		trimmed := strings.TrimSpace(line)
+		// Keep the line if it's not an absolute path
+		if trimmed == "" || !strings.HasPrefix(trimmed, "/") {
+			filteredLines = append(filteredLines, line)
+		} else {
+			ext.logf("  Removing absolute path from .bazelignore: %q", trimmed)
+			removedCount++
+		}
+	}
+
+	// If nothing changed, don't rewrite the file
+	if removedCount == 0 {
+		ext.logf("  No absolute paths found in .bazelignore")
+		return nil
+	}
+
+	// Write back the filtered content
+	newContent := strings.Join(filteredLines, "\n")
+	if err := os.WriteFile(bazelignorePath, []byte(newContent), 0644); err != nil {
+		return fmt.Errorf("failed to write .bazelignore: %w", err)
+	}
+
+	ext.logf("  Removed %d absolute path(s) from .bazelignore", removedCount)
+	return nil
+}

language/starlarkbundle/starlark_bundle.go

@@ -22,6 +22,7 @@ limitations under the License.
 package starlarkbundle
 
 import (
+	"log"
 	"sort"
 
 	"github.com/bazelbuild/bazel-gazelle/config"
@@ -33,7 +34,7 @@ import (
 
 const (
 	starlarkBundleKind = "starlark_bundle"
-	starlarkBundleName = "docs"
+	starlarkBundleName = "bundle"
 )
 
 var starlarkBundleKindInfo = map[string]rule.KindInfo{
@@ -60,6 +61,8 @@ func starlarkBundleImports(_ *config.Config, _ *rule.Rule, _ *rule.File) []resol
 	return nil
 }
 
+// starlarkBundleResolveResolve iterates the set of stalark_library rules and
+// adds them to it's deps list.
 func starlarkBundleResolve(r *rule.Rule, starlarkLibraries map[label.Label]*rule.Rule) {
 	deps := make([]string, 0, len(starlarkLibraries))
 	for dep := range starlarkLibraries {
@@ -72,6 +75,54 @@ func starlarkBundleResolve(r *rule.Rule, starlarkLibraries map[label.Label]*rule
 	}
 }
 
+// starlarkBundleResolveCoarse iterates the set of stalark_library rules and
+// adds them to it's deps list.  It also takes out all external dependencies
+// from the library rules and collects them into itself, but only as the :bundle
+// target.  This is because we cannot ensure that the fine-grained dependency
+// structure is correct. However, we can (hopefully) ensure that the
+// coarse-grained dependency graph of bundles is correct.
+func starlarkBundleResolveCoarse(r *rule.Rule, starlarkLibraries map[label.Label]*rule.Rule, moduleDeps map[string]string) {
+	deps := make([]string, 0, len(starlarkLibraries))
+	for dep, r := range starlarkLibraries {
+		deps = append(deps, dep.String())
+
+		ruleDeps := r.AttrStrings("deps")
+		p1, _ := partitionExternalDeps(ruleDeps)
+		r.SetAttr("deps", p1)
+	}
+
+	if false {
+		for _, module := range moduleDeps {
+			dep := label.New(module, "", "bundle")
+			deps = append(deps, dep.String())
+		}
+	}
+
+	if len(deps) > 0 {
+		sort.Strings(deps)
+		r.SetAttr("deps", deps)
+	}
+}
+
+func partitionExternalDeps(deps []string) ([]string, []label.Label) {
+	var p1 []string      // first and third-party deps
+	var p3 []label.Label // first and third-party deps
+
+	for _, dep := range deps {
+		from, err := label.Parse(dep)
+		if err != nil {
+			log.Panicf("invalid dep label: %v", dep)
+		}
+		if from.Repo != "" {
+			p3 = append(p3, from)
+		} else {
+			p1 = append(p1, dep)
+		}
+	}
+
+	return p1, p3
+}
+
 func starlarkBundleGenerate(args language.GenerateArgs, root *string) (result language.GenerateResult) {
 	if root == nil || *root != args.Rel {
 		return result