checkpoint: bazel_lib as starlark_repository actually builds!

Author: pcj

extensions/starlark_repository.bzl

@@ -0,0 +1,90 @@
+"""proto_repostitory.bzl provides the starlark_repository rule."""
+
+# Copyright 2014 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.
+
+load("@bazel_features//:features.bzl", "bazel_features")
+load("@build_stack_rules_proto//rules/proto:starlark_repository.bzl", "starlark_repository_attrs", starlark_repository_repo_rule = "starlark_repository")
+
+def _extension_metadata(
+        module_ctx,
+        *,
+        root_module_direct_deps = None,
+        root_module_direct_dev_deps = None,
+        reproducible = False):
+    """returns the module_ctx.extension_metadata in a bazel-version-aware way
+
+    This function was copied from the bazel-gazelle repository.
+    """
+
+    if not hasattr(module_ctx, "extension_metadata"):
+        return None
+    metadata_kwargs = {}
+    if bazel_features.external_deps.extension_metadata_has_reproducible:
+        metadata_kwargs["reproducible"] = reproducible
+    return module_ctx.extension_metadata(
+        root_module_direct_deps = root_module_direct_deps,
+        root_module_direct_dev_deps = root_module_direct_dev_deps,
+        **metadata_kwargs
+    )
+
+def _starlark_repository_impl(module_ctx):
+    # named_repos is a dict<K,V> where V is the kwargs for the actual
+    # "starlark_repository" repo rule and K is the tag.name (the name given by the
+    # MODULE.bazel author)
+    named_archives = {}
+
+    # iterate all the module tags and gather a list of named_archives.
+    #
+    # TODO(pcj): what is the best practice for version selection here? Do I need
+    # to check if module.is_root and handle that differently?
+    #
+    for module in module_ctx.modules:
+        for tag in module.tags.archive:
+            kwargs = {
+                attr: getattr(tag, attr)
+                for attr in _starlark_repository_archive_attrs.keys()
+                if hasattr(tag, attr)
+            }
+            named_archives[tag.name] = kwargs
+
+    # declare a repository rule foreach one
+    for apparent_name, kwargs in named_archives.items():
+        starlark_repository_repo_rule(
+            apparent_name = apparent_name,
+            **kwargs
+        )
+
+    return _extension_metadata(
+        module_ctx,
+        reproducible = True,
+    )
+
+_starlark_repository_archive_attrs = starlark_repository_attrs | {
+    "name": attr.string(
+        doc = "The repo name.",
+        mandatory = True,
+    ),
+}
+_starlark_repository_archive_attrs.pop("apparent_name")
+
+starlark_repository = module_extension(
+    implementation = _starlark_repository_impl,
+    tag_classes = dict(
+        archive = tag_class(
+            doc = "declare an http_archive repository that is post-processed by a custom version of gazelle that includes the 'protobuf' language",
+            attrs = _starlark_repository_archive_attrs,
+        ),
+    ),
+)

language/starlarkbundle/BUILD.bazel

@@ -1,9 +1,10 @@
-load("@io_bazel_rules_go//go:def.bzl", "go_library")
+load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
 
 go_library(
     name = "starlarkbundle",
     srcs = [
         "language.go",
+        "lifecycle.go",
         "starlark_bundle.go",
         "starlark_library.go",
     ],
@@ -20,3 +21,16 @@ go_library(
         "@com_github_bazelbuild_buildtools//build:go_default_library",
     ],
 )
+
+go_test(
+    name = "starlarkbundle_test",
+    srcs = [
+        "lifecycle_test.go",
+        "starlark_library_test.go",
+    ],
+    embed = [":starlarkbundle"],
+    deps = [
+        "@bazel_gazelle//config:go_default_library",
+        "@com_github_bazelbuild_buildtools//build:go_default_library",
+    ],
+)

language/starlarkbundle/language.go

@@ -23,8 +23,10 @@ package starlarkbundle
 
 import (
 	"flag"
+	"io"
 	"log"
 	"maps"
+	"os"
 	"strings"
 
 	"github.com/bazelbuild/bazel-gazelle/config"
@@ -36,22 +38,29 @@ import (
 )
 
 const (
-	languageName                       = "starlark_bundle"
-	starlarkBundleRootDirectiveName    = "starlark_bundle_root"
-	starlarkBundleExcludeDirectiveName = "starlark_bundle_exclude"
+	languageName                          = "starlark_bundle"
+	starlarkBundleRootDirectiveName       = "starlark_bundle_root"
+	starlarkBundleExcludeDirectiveName    = "starlark_bundle_exclude"
+	starlarkBundleLogFileDirectiveName    = "starlark_bundle_log_file"
+	starlarkModuleDependencyDirectiveName = "module_dependency"
 )
 
 type starlarkBundleLang struct {
 	starlarkBundleRoot        *string
 	starlarkBundleExcludeDirs []string
+	moduleDeps                map[string]string
 	starlarkLibraries         map[label.Label]*rule.Rule
+	logFile                   string
+	logWriter                 *os.File
+	logger                    *log.Logger
 }
 
 // NewLanguage is called by Gazelle to install this language extension in a
 // binary.
 func NewLanguage() language.Language {
 	return &starlarkBundleLang{
-		starlarkLibraries: make(map[label.Label]*rule.Rule),
+		starlarkLibraries: map[label.Label]*rule.Rule{},
+		moduleDeps:        map[string]string{},
 	}
 }
 
@@ -66,21 +75,32 @@ func (*starlarkBundleLang) Name() string {
 // https://pkg.go.dev/github.com/bazelbuild/bazel-gazelle/resolve?tab=doc#Resolver
 // interface, but are otherwise unused.
 func (ext *starlarkBundleLang) RegisterFlags(fs *flag.FlagSet, cmd string, c *config.Config) {
+	fs.StringVar(&ext.logFile, "starlark_bundle_log", "", "path to log file for starlark_bundle extension")
 }
 
-func (*starlarkBundleLang) CheckFlags(fs *flag.FlagSet, c *config.Config) error {
+func (ext *starlarkBundleLang) CheckFlags(fs *flag.FlagSet, c *config.Config) error {
+	if ext.logFile != "" {
+		ext.createLogger(c, ext.logFile)
+		ext.logf("CheckFlags: log file initialized from flag: %s", ext.logFile)
+	}
+	if ext.logger == nil {
+		ext.logger = log.New(io.Discard, "", 0)
+	}
 	return nil
 }
 
 func (*starlarkBundleLang) KnownDirectives() []string {
 	return []string{
 		starlarkBundleRootDirectiveName,
 		starlarkBundleExcludeDirectiveName,
+		starlarkBundleLogFileDirectiveName,
+		starlarkModuleDependencyDirectiveName,
 	}
 }
 
 func (ext *starlarkBundleLang) Configure(c *config.Config, rel string, f *rule.File) {
 	if f != nil {
+		ext.logf("Configure: processing %d directives in %s", len(f.Directives), rel)
 		for _, d := range f.Directives {
 			switch d.Key {
 			case starlarkBundleRootDirectiveName:
@@ -90,11 +110,37 @@ func (ext *starlarkBundleLang) Configure(c *config.Config, rel string, f *rule.F
 				ext.starlarkBundleRoot = &rel
 			case starlarkBundleExcludeDirectiveName:
 				ext.starlarkBundleExcludeDirs = append(ext.starlarkBundleExcludeDirs, d.Value)
+			case starlarkModuleDependencyDirectiveName:
+				nameVersion := strings.Fields(d.Value)
+				if len(nameVersion) != 2 {
+					log.Fatalf("malformed directive %s, should be NAME VERSION: %s", starlarkModuleDependencyDirectiveName, d.Value)
+				}
+				ext.moduleDeps[nameVersion[0]] = nameVersion[1]
+				ext.logf("Added module dependency: %q -> %q", nameVersion[0], nameVersion[1])
+			case starlarkBundleLogFileDirectiveName:
+				ext.createLogger(c, d.Value)
 			}
 		}
 	}
 }
 
+func (ext *starlarkBundleLang) createLogger(c *config.Config, logFile string) {
+	if logFile != "" {
+		f, err := os.OpenFile(logFile, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0666)
+		if err == nil {
+			ext.logWriter = f
+			ext.logger = log.New(f, "", log.LstdFlags)
+		} else {
+			log.Fatalf("attempting to open log file: %v", err)
+		}
+	}
+	if false && ext.logger == nil {
+		ext.logger = log.New(io.Discard, "", 0)
+	}
+
+	ext.logf("Log initialized")
+}
+
 // Kinds returns a map of maps rule names (kinds) and information on how to
 // match and merge attributes that may be found in rules of those kinds. All
 // kinds of rules generated for this language may be found here.
@@ -154,7 +200,7 @@ func (*starlarkBundleLang) Embeds(r *rule.Rule, from label.Label) []label.Label
 func (ext *starlarkBundleLang) Resolve(c *config.Config, ix *resolve.RuleIndex, rc *repo.RemoteCache, r *rule.Rule, importsRaw interface{}, from label.Label) {
 	switch r.Kind() {
 	case starlarkLibraryKind:
-		starlarkLibraryResolve(c, ix, r, importsRaw, from)
+		starlarkLibraryResolve(c, ix, r, importsRaw, from, ext)
 	case starlarkBundleKind:
 		starlarkBundleResolve(r, ext.starlarkLibraries)
 	}
@@ -182,8 +228,10 @@ func (ext *starlarkBundleLang) GenerateRules(args language.GenerateArgs) (result
 		}
 	}
 
+	ext.logf("GenerateRules: visiting %s", args.Rel)
+
 	for _, r := range []language.GenerateResult{
-		starlarkLibraryGenerate(args, ext.starlarkLibraries),
+		starlarkLibraryGenerate(args, ext.starlarkLibraries, ext),
 		starlarkBundleGenerate(args, ext.starlarkBundleRoot),
 	} {
 		result.Gen = append(result.Gen, r.Gen...)
@@ -193,3 +241,26 @@ func (ext *starlarkBundleLang) GenerateRules(args language.GenerateArgs) (result
 
 	return
 }
+
+func (ext *starlarkBundleLang) getModuleDependencyRepoName(repo string) (string, bool) {
+	ext.logf("getModuleDependencyRepoName called with repo=%q", repo)
+	if repo == "" {
+		ext.logf("  returning early for empty repo: @")
+		return "@", true
+	}
+	if mappedRepo, ok := ext.moduleDeps[repo]; ok {
+		ext.logf("  found mapping: %q -> %q", repo, mappedRepo)
+		return mappedRepo, true
+	} else {
+		ext.logf("  unknown module dependency: %q (known deps: %v)", repo, ext.moduleDeps)
+		log.Fatalf("unknown module dependency: %q", repo)
+		return repo, false
+	}
+}
+
+// logf logs a message using the extension's logger if configured
+func (ext *starlarkBundleLang) logf(format string, args ...any) {
+	if ext.logger != nil {
+		ext.logger.Printf(format, args...)
+	}
+}

language/starlarkbundle/lifecycle.go

@@ -0,0 +1,43 @@
+/* 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 (
+	"context"
+)
+
+// Before implements part of the language.LifecycleManager interface.
+func (ext *starlarkBundleLang) Before(context.Context) {
+	ext.logf("Lifecycle: Before() called")
+}
+
+// DoneGeneratingRules implements part of the language.FinishableLanguage interface.
+func (ext *starlarkBundleLang) DoneGeneratingRules() {
+	ext.logf("Lifecycle: DoneGeneratingRules() called")
+}
+
+// AfterResolvingDeps implements part of the language.LifecycleManager interface.
+// This is where we flush and close the log file.
+func (ext *starlarkBundleLang) AfterResolvingDeps(context.Context) {
+	ext.logf("Lifecycle: AfterResolvingDeps() called - flushing and closing log file")
+	if ext.logWriter != nil {
+		// Sync flushes any buffered data to disk
+		_ = ext.logWriter.Sync()
+		// Close the file
+		_ = ext.logWriter.Close()
+		ext.logWriter = nil
+	}
+}