Add rule coverage (#126)

* Add rule coverage

Author: pcj

language/scala/BUILD.bazel

@@ -11,6 +11,7 @@ go_library(
         "cache.go",
         "configure.go",
         "conflict_resolver_registry.go",
+        "coverage.go",
         "cross_resolve.go",
         "deps_cleaner_registry.go",
         "existing_scala_rule.go",
@@ -79,6 +80,7 @@ gazelle_binary(
 go_test(
     name = "scala_test",
     srcs = [
+        "coverage_test.go",
         "existing_scala_rule_test.go",
         "flags_test.go",
         "golden_test.go",

language/scala/coverage.go

@@ -0,0 +1,27 @@
+package scala
+
+type packageRuleCoverage struct {
+	// managed represents the total number of rules that are managed by
+	// scala-gazelle (actual number of rules that we provided deps for)
+	managed int
+	// total represents the total number of rules in a package that we have a
+	// RuleProvider for.
+	total int
+}
+
+func (sl *scalaLang) reportCoverage(printf func(format string, v ...any)) {
+	if !sl.existingScalaRuleCoverageFlagValue {
+		return
+	}
+
+	var managed int
+	var total int
+	for _, pkg := range sl.packages {
+		managed += pkg.ruleCoverage.managed
+		total += pkg.ruleCoverage.total
+	}
+
+	percent := float32(managed) / float32(total) * 100
+
+	printf("scala-gazelle coverage is %0.1f%% (%d/%d)", percent, managed, total)
+}

language/scala/coverage_test.go

@@ -0,0 +1 @@
+package scala

language/scala/flags.go

@@ -23,6 +23,7 @@ const (
 	existingScalaBinaryRuleFlagName      = "existing_scala_binary_rule"
 	existingScalaLibraryRuleFlagName     = "existing_scala_library_rule"
 	existingScalaTestRuleFlagName        = "existing_scala_test_rule"
+	existingScalaRuleCoverageFlagName    = "existing_scala_rule_coverage"
 	scalaGazelleCacheFileFlagName        = "scala_gazelle_cache_file"
 	scalaGazelleDebugProcessFileFlagName = "scala_gazelle_debug_process"
 	scalaGazelleCacheKeyFlagName         = "scala_gazelle_cache_key"
@@ -35,6 +36,7 @@ const (
 func (sl *scalaLang) RegisterFlags(flags *flag.FlagSet, cmd string, c *config.Config) {
 	flags.BoolVar(&sl.debugProcessFlagValue, scalaGazelleDebugProcessFileFlagName, false, "if true, prints the process ID and waits for debugger to attach")
 	flags.BoolVar(&sl.printCacheKey, scalaGazellePrintCacheKeyFlagName, true, "if a cache key is set, print the version for auditing purposes")
+	flags.BoolVar(&sl.existingScalaRuleCoverageFlagValue, existingScalaRuleCoverageFlagName, true, "report coverage statistics")
 	flags.StringVar(&sl.cacheFileFlagValue, scalaGazelleCacheFileFlagName, "", "optional path a cache file (.json or .pb)")
 	flags.StringVar(&sl.cacheKeyFlagValue, scalaGazelleCacheKeyFlagName, "", "optional string that can be used to bust the cache file")
 	flags.StringVar(&sl.cpuprofileFlagValue, cpuprofileFileFlagName, "", "optional path a cpuprofile file (.prof)")

language/scala/language.go

@@ -50,9 +50,10 @@ type scalaLang struct {
 	existingScalaLibraryRulesFlagValue collections.StringSlice
 	// existingScalaLibraryRulesFlagValue is the value of the
 	// existing_scala_test_rule repeatable flag
-	existingScalaTestRulesFlagValue collections.StringSlice
-	cpuprofileFlagValue             string
-	memprofileFlagValue             string
+	existingScalaTestRulesFlagValue    collections.StringSlice
+	cpuprofileFlagValue                string
+	existingScalaRuleCoverageFlagValue bool
+	memprofileFlagValue                string
 	// cache is the loaded cache, if configured
 	cache scpb.Cache
 	// ruleProviderRegistry is the rule registry implementation.  This holds the

language/scala/lifecycle.go

@@ -37,6 +37,7 @@ func (sl *scalaLang) onEnd() {
 		}
 	}
 
+	sl.reportCoverage(log.Printf)
 	sl.stopCpuProfiling()
 	sl.stopMemoryProfiling()
 }

language/scala/scala_package.go

@@ -45,6 +45,8 @@ type scalaPackage struct {
 	// resolveFuncs is a list of resolve work that needs to be deferred until
 	// all rules in a package have been processed.
 	resolveWork []func()
+	// used for tracking coverage
+	ruleCoverage *packageRuleCoverage
 }
 
 // newScalaPackage constructs a Package given a list of scala files.
@@ -64,6 +66,7 @@ func newScalaPackage(
 		cfg:              cfg,
 		rules:            make(map[string]*rule.Rule),
 		resolveWork:      make([]func(), 0),
+		ruleCoverage:     &packageRuleCoverage{},
 	}
 	s.gen = s.generateRules(true)
 	// s.empty = s.generateRules(false)
@@ -127,31 +130,35 @@ func (s *scalaPackage) generateRules(enabled bool) []scalarule.RuleProvider {
 		for _, r := range s.file.Rules {
 			fqn := fullyQualifiedLoadName(s.file.Loads, r.Kind())
 			existingRulesByFQN[fqn] = append(existingRulesByFQN[fqn], r)
+			if _, ok := s.providerRegistry.LookupProvider(fqn); ok {
+				s.ruleCoverage.total += 1
+			}
 		}
 	}
 
 	configuredRules := s.cfg.ConfiguredRules()
 
-	for _, rc := range configuredRules {
+	for _, ruleConfig := range configuredRules {
 		// if enabled != rc.Enabled {
-		if !rc.Enabled {
+		if !ruleConfig.Enabled {
 			// log.Printf("%s: skipping rule config %s (not enabled)", s.rel, rc.Name)
 			continue
 		}
-		rule := s.provideRule(rc)
+		rule := s.provideRule(ruleConfig)
 		if rule != nil {
 			rules = append(rules, rule)
 		}
-		existing := existingRulesByFQN[rc.Implementation]
+		existing := existingRulesByFQN[ruleConfig.Implementation]
 		if len(existing) > 0 {
 			for _, r := range existing {
-				rule := s.resolveRule(rc, r)
+				rule := s.resolveRule(ruleConfig, r)
 				if rule != nil {
+					s.ruleCoverage.managed += 1
 					rules = append(rules, rule)
 				}
 			}
 		}
-		delete(existingRulesByFQN, rc.Implementation)
+		delete(existingRulesByFQN, ruleConfig.Implementation)
 	}
 
 	return rules

pkg/scalaconfig/config.go

@@ -406,7 +406,6 @@ func (c *Config) GetImplicitImports(lang, imp string) (deps []string) {
 
 // ConfiguredRules returns an ordered list of configured rules
 func (c *Config) ConfiguredRules() []*scalarule.Config {
-
 	names := make([]string, 0)
 	for name := range c.rules {
 		names = append(names, name)