Support an alternative collection point for test libraries.
PiperOrigin-RevId: 231291427
diff --git a/ts_auto_deps/main.go b/ts_auto_deps/main.go
index 81542dc..2d1da26 100644
--- a/ts_auto_deps/main.go
+++ b/ts_auto_deps/main.go
@@ -12,8 +12,9 @@
var (
isRoot = flag.Bool("root", false, "the given path is the root of a TypeScript project "+
"(generates ts_config and ts_development_sources targets).")
- recursive = flag.Bool("recursive", false, "recursively update all packages under the given root.")
- files = flag.Bool("files", false, "treats arguments as file names. Filters .ts files, then runs on their dirnames.")
+ recursive = flag.Bool("recursive", false, "recursively update all packages under the given root.")
+ files = flag.Bool("files", false, "treats arguments as file names. Filters .ts files, then runs on their dirnames.")
+ allowAllTestLibraries = flag.Bool("allow_all_test_libraries", false, "treats testonly ts_libraries named 'all_tests' as an alternative to ts_config/ts_dev_srcs for registering tests")
)
func usage() {
@@ -58,7 +59,7 @@
}
host := updater.New(false, false, updater.QueryBasedBazelAnalyze, updater.LocalUpdateFile)
- if err := updater.Execute(host, paths, *isRoot, *recursive); err != nil {
+ if err := updater.Execute(host, paths, *isRoot, *recursive, *allowAllTestLibraries); err != nil {
platform.Error(err)
}
}
diff --git a/ts_auto_deps/updater/test_register.go b/ts_auto_deps/updater/test_register.go
new file mode 100644
index 0000000..794dcec
--- /dev/null
+++ b/ts_auto_deps/updater/test_register.go
@@ -0,0 +1,202 @@
+package updater
+
+import (
+ "context"
+ "fmt"
+ "path/filepath"
+
+ "github.com/bazelbuild/buildtools/build"
+ "github.com/bazelbuild/rules_typescript/ts_auto_deps/platform"
+)
+
+// isAllTestLibrary identifies testonly ts_libraries named "all_tests". Taze
+// will register tests with these rules instead of
+// ts_config/ts_development_sources rules to allow users to set up their builds
+// differently.
+func isAllTestLibrary(bld *build.File, r *build.Rule) bool {
+ if !ruleMatches(bld, r, "ts_library", ruleTypeTest) {
+ return false
+ }
+
+ if r.Name() != "all_tests" {
+ return false
+ }
+
+ return true
+}
+
+func getAllTestLibraries(bld *build.File) []*build.Rule {
+ var allTestRules []*build.Rule
+ for _, r := range buildRules(bld, "ts_library") {
+ if isAllTestLibrary(bld, r) {
+ allTestRules = append(allTestRules, r)
+ }
+ }
+ return allTestRules
+}
+
+// RegisterTestRules registers ts_library test targets with the project's
+// ts_config and ts_development_sources rules. It may also register the tests
+// with a testonly ts_library named "all_tests", which allows users to set up
+// their own BUILD layout. It's separated from UpdateBUILD since it's non-local,
+// multiple packages may all need to make writes to the same ts_config.
+func (upd *Updater) RegisterTestRules(ctx context.Context, allowAllTestLibrary bool, paths ...string) (bool, error) {
+ reg := &buildRegistry{make(map[string]*build.File), make(map[*build.File]bool)}
+ var g3root string
+ for _, path := range paths {
+ // declare variables manually so that g3root doesn't get overwritten by a :=
+ // declaration
+ var err error
+ var buildPath string
+ g3root, buildPath, err = getBUILDPath(ctx, path)
+ if err != nil {
+ return false, err
+ }
+ bld, err := reg.readBUILD(ctx, g3root, buildPath)
+ if err != nil {
+ return false, err
+ }
+ if tr := getRule(bld, "ts_library", ruleTypeTest); tr != nil {
+ // don't register all_test libraries themselves
+ if isAllTestLibrary(bld, tr) {
+ continue
+ }
+ platform.Infof("Registering test rule in closest ts_config & ts_development_sources")
+ target := AbsoluteBazelTarget(bld, tr.Name())
+ if err := reg.registerTestRule(ctx, bld, tsConfig, g3root, target); err != nil {
+ return false, err
+ }
+ // NodeJS rules should not be added to ts_development_sources automatically, because
+ // they typically do not run in the browser.
+ if tr.AttrString("runtime") != "nodejs" {
+ if err := reg.registerTestRule(ctx, bld, tsDevSrcs, g3root, target); err != nil {
+ return false, err
+ }
+ }
+ }
+ }
+
+ updated := false
+ for b := range reg.filesToUpdate {
+ fmt.Printf("Registered test(s) in %s\n", b.Path)
+ fileChanged, err := upd.maybeWriteBUILD(ctx, filepath.Join(g3root, b.Path), b)
+ if err != nil {
+ return false, err
+ }
+ updated = updated || fileChanged
+ }
+
+ return updated, nil
+}
+
+// buildRegistry buffers reads and writes done while registering ts_libraries
+// with ts_config and ts_development_sources rules, so that registers from
+// multiple packages all get applied at once.
+type buildRegistry struct {
+ bldFiles map[string]*build.File
+ filesToUpdate map[*build.File]bool
+}
+
+func (reg *buildRegistry) readBUILD(ctx context.Context, workspaceRoot, buildFilePath string) (*build.File, error) {
+ normalizedG3Path, err := getAbsoluteBUILDPath(workspaceRoot, buildFilePath)
+ if err != nil {
+ return nil, err
+ }
+
+ if bld, ok := reg.bldFiles[normalizedG3Path]; ok {
+ return bld, nil
+ }
+
+ bld, err := readBUILD(ctx, workspaceRoot, buildFilePath)
+ if err != nil {
+ return nil, err
+ }
+
+ reg.bldFiles[normalizedG3Path] = bld
+
+ return bld, nil
+}
+
+func (reg *buildRegistry) registerForPossibleUpdate(bld *build.File) {
+ reg.filesToUpdate[bld] = true
+}
+
+type registerTarget int
+
+const (
+ tsConfig registerTarget = iota
+ tsDevSrcs
+)
+
+func (rt registerTarget) kind() string {
+ if rt == tsConfig {
+ return "ts_config"
+ }
+
+ return "ts_development_sources"
+}
+
+func (rt registerTarget) ruleType() ruleType {
+ if rt == tsConfig {
+ return ruleTypeAny
+ }
+
+ return ruleTypeTest
+}
+
+// registerTestRule searches ancestor packages for a rule matching the register
+// target and adds the given target to it. If an all_tests library is found, the
+// rule is registered with it, instead of specified register target. Prints a
+// warning if no rule is found, but only returns an error if adding the
+// dependency fails.
+func (reg *buildRegistry) registerTestRule(ctx context.Context, bld *build.File, rt registerTarget, g3root, target string) error {
+ if buildHasDisableTaze(bld) {
+ return nil
+ }
+
+ var ruleToRegister *build.Rule
+ for _, r := range bld.Rules("") {
+ if isAllTestLibrary(bld, r) {
+ if hasDependency(bld, r, target) {
+ return nil
+ }
+
+ // an all_tests library takes presidence over a registerTarget, and there
+ // can only be one, since there can only be one rule with a given name, so
+ // can just break after finding
+ ruleToRegister = r
+ break
+ }
+ if ruleMatches(bld, r, rt.kind(), rt.ruleType()) {
+ if hasDependency(bld, r, target) {
+ return nil
+ }
+
+ // keep overwriting ruleToRegister so the last match in the BUILD gets
+ // used
+ ruleToRegister = r
+ }
+ }
+
+ if ruleToRegister != nil {
+ addDep(bld, ruleToRegister, target)
+ reg.registerForPossibleUpdate(bld)
+ return nil
+ }
+
+ parentDir := filepath.Dir(filepath.Dir(bld.Path))
+ for parentDir != "." && parentDir != "/" {
+ buildFile := filepath.Join(g3root, parentDir, "BUILD")
+ if _, err := platform.Stat(ctx, buildFile); err == nil {
+ parent, err := reg.readBUILD(ctx, g3root, buildFile)
+ if err != nil {
+ return err
+ }
+ return reg.registerTestRule(ctx, parent, rt, g3root, target)
+ }
+ parentDir = filepath.Dir(parentDir)
+ }
+ fmt.Printf("WARNING: no %s rule in parent packages of %s to register with.\n",
+ rt.kind(), target)
+ return nil
+}
diff --git a/ts_auto_deps/updater/updater.go b/ts_auto_deps/updater/updater.go
index 3f6980b..a45d04c 100644
--- a/ts_auto_deps/updater/updater.go
+++ b/ts_auto_deps/updater/updater.go
@@ -477,16 +477,26 @@
return true, nil
}
-func getBUILDPathAndBUILDFile(ctx context.Context, path string) (string, string, *build.File, error) {
+func getBUILDPath(ctx context.Context, path string) (string, string, error) {
path = strings.TrimSuffix(path, "/BUILD") // Support both package paths and BUILD files
if _, err := platform.Stat(ctx, path); os.IsNotExist(err) {
- return "", "", nil, err
+ return "", "", err
}
buildFilePath := filepath.Join(path, "BUILD")
g3root, err := workspace.Root(buildFilePath)
if err != nil {
+ return "", "", err
+ }
+
+ return g3root, buildFilePath, nil
+}
+
+func getBUILDPathAndBUILDFile(ctx context.Context, path string) (string, string, *build.File, error) {
+ g3root, buildFilePath, err := getBUILDPath(ctx, path)
+ if err != nil {
return "", "", nil, err
}
+
bld, err := readBUILD(ctx, g3root, buildFilePath)
if err != nil {
platform.Infof("Error reading building file!")
@@ -629,48 +639,6 @@
return upd.maybeWriteBUILD(ctx, buildFilePath, bld)
}
-// RegisterTsconfigAndTsDevelopmentSources registers ts_library targets with the project's
-// ts_config and ts_development_sources rules. It's separated from UpdateBUILD since it's
-// non-local, multiple packages may all need to make writes to the same ts_config.
-func (upd *Updater) RegisterTsconfigAndTsDevelopmentSources(ctx context.Context, paths ...string) (bool, error) {
- reg := &buildRegistry{make(map[string]*build.File), make(map[*build.File]bool)}
- var g3root string
- for _, path := range paths {
- var bld *build.File
- var err error
- g3root, _, bld, err = getBUILDPathAndBUILDFile(ctx, path)
- if err != nil {
- return false, err
- }
- if tr := getRule(bld, "ts_library", ruleTypeTest); tr != nil {
- platform.Infof("Registering test rule in closest ts_config & ts_development_sources")
- target := AbsoluteBazelTarget(bld, tr.Name())
- if err := reg.registerTestRule(ctx, bld, "ts_config", ruleTypeAny, g3root, target); err != nil {
- return false, err
- }
- // NodeJS rules should not be added to ts_development_sources automatically, because
- // they typically do not run in the browser.
- if tr.AttrString("runtime") != "nodejs" {
- if err := reg.registerTestRule(ctx, bld, "ts_development_sources", ruleTypeTest, g3root, target); err != nil {
- return false, err
- }
- }
- }
- }
-
- updated := false
- for b := range reg.filesToUpdate {
- fmt.Printf("Registered test(s) in %s\n", b.Path)
- fileChanged, err := upd.maybeWriteBUILD(ctx, filepath.Join(g3root, b.Path), b)
- if err != nil {
- return false, err
- }
- updated = updated || fileChanged
- }
-
- return updated, nil
-}
-
// IsTazeDisabledForDir checks if ts_auto_deps is disabled in the BUILD file in the dir,
// or if no BUILD file exists, in the closest ancestor BUILD
func IsTazeDisabledForDir(ctx context.Context, dir string) (bool, error) {
@@ -803,82 +771,6 @@
return s, nil, err
}
-// buildRegistry buffers reads and writes done while registering ts_libraries
-// with ts_config and ts_development_sources rules, so that registers from
-// multiple packages all get applied at once.
-type buildRegistry struct {
- bldFiles map[string]*build.File
- filesToUpdate map[*build.File]bool
-}
-
-func (reg *buildRegistry) readBUILD(ctx context.Context, workspaceRoot, buildFilePath string) (*build.File, error) {
- normalizedG3Path, err := getAbsoluteBUILDPath(workspaceRoot, buildFilePath)
- if err != nil {
- return nil, err
- }
-
- if bld, ok := reg.bldFiles[normalizedG3Path]; ok {
- return bld, nil
- }
-
- bld, err := readBUILD(ctx, workspaceRoot, buildFilePath)
- if err != nil {
- return nil, err
- }
-
- reg.bldFiles[normalizedG3Path] = bld
-
- return bld, nil
-}
-
-func (reg *buildRegistry) registerForPossibleUpdate(bld *build.File) {
- reg.filesToUpdate[bld] = true
-}
-
-// registerTestRule searches ancestor packages for a rule with the given ruleKind and ruleType
-// and adds the given target to it. Prints a warning if no rule is found, but only returns an error
-// if adding the dependency fails.
-func (reg *buildRegistry) registerTestRule(ctx context.Context, bld *build.File, ruleKind string, rt ruleType, g3root, target string) error {
- // If the target has already been registered in any of the rule with the given ruleKind and ruleType,
- // we shouldn't register it again.
- if targetRegisteredInRule(bld, ruleKind, rt, target) {
- return nil
- }
- if buildHasDisableTaze(bld) {
- return nil
- }
- r := getRule(bld, ruleKind, rt)
- if r != nil {
- addDep(bld, r, target)
- reg.registerForPossibleUpdate(bld)
- return nil
- }
- parentDir := filepath.Dir(filepath.Dir(bld.Path))
- for parentDir != "." && parentDir != "/" {
- buildFile := filepath.Join(g3root, parentDir, "BUILD")
- if _, err := platform.Stat(ctx, buildFile); err == nil {
- parent, err := reg.readBUILD(ctx, g3root, buildFile)
- if err != nil {
- return err
- }
- return reg.registerTestRule(ctx, parent, ruleKind, rt, g3root, target)
- }
- parentDir = filepath.Dir(parentDir)
- }
- ruleTypeStr := ""
- switch rt {
- case ruleTypeRegular:
- ruleTypeStr = "testonly=0"
- case ruleTypeTest, ruleTypeTestSupport:
- ruleTypeStr = "testonly=1"
- default:
- break
- }
- fmt.Printf("WARNING: no %s(%s) rule in parent packages of %s to register with.\n",
- ruleKind, ruleTypeStr, target)
- return nil
-}
-
type ruleType int
const (
@@ -888,6 +780,14 @@
ruleTypeTestSupport
)
+// isKind returns true if the rule has given kind. It also accepts "ng_modules"
+// as "ts_library" kind.
+func isKind(r *build.Rule, kind string) bool {
+ acceptNgModule := kind == "ts_library"
+
+ return r.Kind() == kind || (acceptNgModule && r.Kind() == "ng_module")
+}
+
func buildRules(bld *build.File, kind string) []*build.Rule {
// Find all rules, then filter by kind.
// This is nearly the same as just calling bld.Rules(kind), but allows to
@@ -896,9 +796,8 @@
// last build rule in the file in case multiple match, regardless of kind.
allRules := bld.Rules("")
var res []*build.Rule
- acceptNgModule := kind == "ts_library"
for _, r := range allRules {
- if r.Kind() == kind || (acceptNgModule && r.Kind() == "ng_module") {
+ if isKind(r, kind) {
res = append(res, r)
}
}
@@ -1152,8 +1051,11 @@
return r
}
-// ruleMatches return whether a rule matches the specified rt value.
-func ruleMatches(bld *build.File, r *build.Rule, rt ruleType) bool {
+// ruleMatches return whether a rule matches the specified kind and rt value.
+func ruleMatches(bld *build.File, r *build.Rule, kind string, rt ruleType) bool {
+ if !isKind(r, kind) {
+ return false
+ }
inTestingDir := determineRuleType(bld.Path, "somefile.ts") == ruleTypeTestSupport
hasTestsName := strings.HasSuffix(r.Name(), "_tests")
// Accept the rule if it matches the testonly attribute.
@@ -1174,9 +1076,8 @@
// targetRegisteredInRule returns whether a target has been registered in a rule that
// matches a specified ruleKind and ruleType in current build file
func targetRegisteredInRule(bld *build.File, ruleKind string, rt ruleType, target string) bool {
- rs := buildRules(bld, ruleKind)
- for _, r := range rs {
- if ruleMatches(bld, r, rt) && hasDependency(bld, r, target) {
+ for _, r := range bld.Rules("") {
+ if ruleMatches(bld, r, ruleKind, rt) && hasDependency(bld, r, target) {
return true
}
}
@@ -1186,10 +1087,10 @@
// getRule returns the last rule in bld that has the given ruleKind and matches
// the specified rt value.
func getRule(bld *build.File, ruleKind string, rt ruleType) *build.Rule {
- rs := buildRules(bld, ruleKind)
+ rs := bld.Rules("")
for i := len(rs) - 1; i >= 0; i-- {
r := rs[i]
- if ruleMatches(bld, r, rt) {
+ if ruleMatches(bld, r, ruleKind, rt) {
return r
}
}
@@ -1320,7 +1221,7 @@
}
// Execute runs ts_auto_deps on paths using host.
-func Execute(host *Updater, paths []string, isRoot bool, recursive bool) error {
+func Execute(host *Updater, paths []string, isRoot, recursive, allowAllTestLibraries bool) error {
ctx := context.Background()
for i, p := range paths {
isLastAndRoot := isRoot && i == len(paths)-1
@@ -1339,7 +1240,7 @@
}
}
}
- host.RegisterTsconfigAndTsDevelopmentSources(ctx, paths...)
+ host.RegisterTestRules(ctx, allowAllTestLibraries, paths...)
return nil
}
