Merge pull request #195 from rabbitmq/erlang_app_path_ignore-directive

erlang_app_path_ignore directive

Author: HoloRin

gazelle/README.md

@@ -87,3 +87,84 @@ gazelle(
 ```
 
 Then run `bazel run //:gazelle`
+
+## Directives
+
+- `erlang_resolve`
+
+  Example: `# gazelle:erlang_resolve rabbit_common @rabbitmq-server//deps/rabbit_common:erlang_app`
+
+  Purpose: Provides explicit resolution from an erlang application name to it's label
+
+- `erlang_module_source_lib`
+
+  Example: `# gazelle:erlang_module_source_lib Elixir.RabbitMQ.CLI.CommandBehaviour:rabbitmq_cli`
+
+  Purpose: Indicates which erlang application contains a given module, irrespective of `moduleindex.yaml`
+
+- `erlang_exclude_when_rule_of_kind_exists`
+
+  Purpose: Tells the erlang extension for gazelle to skip rule generation for a given directory, if a BUILD file already exists and contains a rule of this type
+
+- `erlang_generate_beam_files_macro`
+
+  Example: `# gazelle:erlang_generate_beam_files_macro`
+
+  Purpose: Tells the erlang extension to generate `app.bzl` and define all of the rules for compiling beam files within it. This allows for a much more compact BUILD file
+
+- `erlang_generate_fewer_bytecode_rules`
+
+  Purpose: Tells the erlang extension to generate rules that compile byte code in up to 3 phases (parse transforms, behaviours, the rest) instead of generating a rule per beam file (the default). This can provide a speed boost for some projects, such as rabbitmq-server, which is an umbrella project with many sources and applications.
+
+- `erlang_always_generate_test_beam_files`
+
+  Purpose: Tells the erlang extention to generate the rules that compile source for test, even if the application contains no test suites
+
+- `erlang_skip_rules`
+
+  Example: `# gazelle:erlang_skip_rules assert_suites2,xref,plt,dialyze
+`
+
+  Purpose: Tells the erlang extension not to generate rules of these types
+
+- `erlang_apps_dirs`
+
+  Example: `# gazelle:erlang_apps_dirs deps`
+
+  Purpose: Tells the erlang extension too look in additional directories within the project in addition to `apps` for local applications. Only useful for umbrella repos.
+
+- `erlang_app_testonly`
+
+  Purpose: Sets `testonly = True` on the rules generated. Useful for marking a test dependency as something that should not be shipped.
+
+- `erlang_app_dep`
+
+  Purpose: An erlang application name to add as a depencency, in addition to the detected deps
+
+- `erlang_app_dep_ignore`
+
+  Purpose: Ignores a detected dependency entirely, both for compilation and runtime
+
+- `erlang_app_dep_exclude`
+
+  Example: `# gazelle:erlang_app_dep_exclude rabbitmq_cli`
+
+  Purpose: Excludes a detected dependency from the generated `.app` file for an app, useful for optional dependencies
+
+- `erlang_app_path_ignore`
+
+  Purpose: Exclude files matching the pattern from an `erlang_app` rule and its sources
+
+- `erlang_app_extra_app`
+
+  Purpose: Inject an additional application into the `.app` file, under the `applications` key
+
+- `erlang_no_tests`
+
+  Purpose: Don't generate rules associated with tests. Useful for dependencies
+
+- `erlang_erlc_opt`
+
+  Example: `# gazelle:erlang_erlc_opt -DBUILD_WITHOUT_QUIC`
+
+  Purpose: Adds additional values to the `erlc_opts` rule. Useful as it applies when parsing sources to determine dependencies

gazelle/configure.go

@@ -28,6 +28,7 @@ const (
 	erlangAppDepDirective                = "erlang_app_dep"
 	erlangAppDepIgnoreDirective          = "erlang_app_dep_ignore"
 	erlangAppDepBuildOnlyDirective       = "erlang_app_dep_exclude"
+	erlangAppPathIgnoreDirective         = "erlang_app_path_ignore"
 	erlangAppExtraAppDirective           = "erlang_app_extra_app"
 	erlangNoTestsDirective               = "erlang_no_tests"
 	erlangErlcOptDirective               = "erlang_erlc_opt"
@@ -102,6 +103,7 @@ type ErlangConfig struct {
 	ExcludeWhenRuleOfKindExists     mutable_set.MutableSet[string]
 	IgnoredDeps                     mutable_set.MutableSet[string]
 	ExcludedDeps                    mutable_set.MutableSet[string]
+	IgnoredPaths                    mutable_set.MutableSet[string]
 	GenerateBeamFilesMacro          bool
 	GenerateFewerBytecodeRules      bool
 	GenerateTestBeamUnconditionally bool
@@ -129,6 +131,7 @@ func (erlang *Configurer) defaultErlangConfig(globalConfig *ErlangGlobalConfig)
 		ExcludeWhenRuleOfKindExists:     mutable_set.New[string](),
 		IgnoredDeps:                     defaultIgnoredDeps,
 		ExcludedDeps:                    mutable_set.New[string](),
+		IgnoredPaths:                    mutable_set.New[string](),
 		GenerateBeamFilesMacro:          false,
 		GenerateFewerBytecodeRules:      erlang.compact,
 		GenerateTestBeamUnconditionally: false,
@@ -163,6 +166,7 @@ func erlangConfigForRel(c *config.Config, rel string) *ErlangConfig {
 			ExcludeWhenRuleOfKindExists:     mutable_set.Copy(parentConfig.ExcludeWhenRuleOfKindExists),
 			IgnoredDeps:                     mutable_set.Copy(parentConfig.IgnoredDeps),
 			ExcludedDeps:                    mutable_set.Copy(parentConfig.ExcludedDeps),
+			IgnoredPaths:                    mutable_set.Copy(parentConfig.IgnoredPaths),
 			GenerateBeamFilesMacro:          parentConfig.GenerateBeamFilesMacro,
 			GenerateFewerBytecodeRules:      parentConfig.GenerateFewerBytecodeRules,
 			GenerateTestBeamUnconditionally: parentConfig.GenerateTestBeamUnconditionally,
@@ -233,6 +237,7 @@ func (erlang *Configurer) KnownDirectives() []string {
 		erlangAppDepDirective,
 		erlangAppDepIgnoreDirective,
 		erlangAppDepBuildOnlyDirective,
+		erlangAppPathIgnoreDirective,
 		erlangAppExtraAppDirective,
 		erlangNoTestsDirective,
 		erlangErlcOptDirective,
@@ -309,6 +314,13 @@ func (erlang *Configurer) Configure(c *config.Config, rel string, f *rule.File)
 				erlangConfig.IgnoredDeps.Add(d.Value)
 			case erlangAppDepBuildOnlyDirective:
 				erlangConfig.ExcludedDeps.Add(d.Value)
+			case erlangAppPathIgnoreDirective:
+				p := path.Join(rel, d.Value)
+				if err := checkPathMatchPattern(p); err != nil {
+					Log(c, "    the exclusion pattern is not valid", p, ":", err)
+					continue
+				}
+				erlangConfig.IgnoredPaths.Add(p)
 			case erlangAppExtraAppDirective:
 				erlangConfig.ExtraApps.Add(d.Value)
 			case erlangNoTestsDirective:

gazelle/generate.go

@@ -12,6 +12,7 @@ import (
 	"github.com/bazelbuild/bazel-gazelle/merger"
 	"github.com/bazelbuild/bazel-gazelle/rule"
 	"github.com/bazelbuild/buildtools/build"
+	"github.com/bmatcuk/doublestar/v4"
 	"github.com/rabbitmq/rules_erlang/gazelle/fetch"
 	"github.com/rabbitmq/rules_erlang/gazelle/slices"
 )
@@ -192,6 +193,22 @@ func importBareErlang(args language.GenerateArgs, erlangApp *ErlangAppBuilder) e
 			if err != nil {
 				return err
 			}
+
+			rootRel, err := filepath.Rel(args.Config.RepoRoot, path)
+			if err != nil {
+				return err
+			}
+			erlangConfig := erlangConfigForRel(args.Config, rootRel)
+			for _, pattern := range erlangConfig.IgnoredPaths.Values(strings.Compare) {
+				if m, _ := doublestar.PathMatch(pattern, rootRel); m {
+					if info.IsDir() {
+						return filepath.SkipDir
+					} else {
+						return nil
+					}
+				}
+			}
+
 			if info.IsDir() {
 				if slices.Contains(ignoredDirs, filepath.Base(path)) {
 					return filepath.SkipDir

test/gazelle/testdata/basic_rebar_compact_rules/BUILD.in

@@ -1 +1,3 @@
 # gazelle:erlang_generate_fewer_bytecode_rules
+
+# gazelle:erlang_app_path_ignore test/foo.*

test/gazelle/testdata/basic_rebar_compact_rules/BUILD.out

@@ -7,6 +7,8 @@ load("@rules_erlang//:ct.bzl", "assert_suites2")
 
 # gazelle:erlang_generate_fewer_bytecode_rules
 
+# gazelle:erlang_app_path_ignore test/foo.*
+
 erlc_opts(
     name = "erlc_opts",
     values = select({

test/gazelle/testdata/basic_rebar_compact_rules/test/foo.erl

@@ -0,0 +1 @@
+-module(foo).