feat(sidekick/swift): track path to monorepo root (#5190)

When generating the `Package.swift` files we need to reference local
packages by their path. It is easier to express all these paths as
relative to the project monorepo root, and the generator can inject
enough `../` paths to find the root. I expect in most cases `../../`
will be enough.

Author: coryan

internal/sidekick/swift/annotate_model.go

@@ -22,13 +22,15 @@ type modelAnnotations struct {
 	CopyrightYear string
 	BoilerPlate   []string
 	PackageName   string
+	MonorepoRoot  string
 }
 
 func (codec *codec) annotateModel() error {
 	annotations := &modelAnnotations{
 		CopyrightYear: codec.GenerationYear,
 		BoilerPlate:   license.HeaderBulk(),
 		PackageName:   codec.PackageName,
+		MonorepoRoot:  codec.MonorepoRoot,
 	}
 	codec.Model.Codec = annotations
 	for _, message := range codec.Model.Messages {

internal/sidekick/swift/annotate_model_test.go

@@ -33,6 +33,7 @@ func TestModelAnnotations(t *testing.T) {
 	want := &modelAnnotations{
 		PackageName:   "GoogleCloudWorkflowsV1",
 		CopyrightYear: "2038",
+		MonorepoRoot:  ".",
 	}
 	if diff := cmp.Diff(want, model.Codec, cmpopts.IgnoreFields(modelAnnotations{}, "BoilerPlate")); diff != "" {
 		t.Errorf("mismatch (-want +got):\n%s", diff)

internal/sidekick/swift/codec.go

@@ -16,6 +16,7 @@ package swift
 
 import (
 	"fmt"
+	"path/filepath"
 	"time"
 
 	"github.com/googleapis/librarian/internal/config"
@@ -33,18 +34,35 @@ import (
 type codec struct {
 	GenerationYear string
 	PackageName    string
+	MonorepoRoot   string
 	// Most libraries are generated from `googleapis`. Rarely, we use protobuf,
 	// gapic-showcase, or a different root.
 	RootName     string
 	Model        *api.API
 	Dependencies []config.SwiftDependency
 }
 
-func newCodec(model *api.API, cfg *parser.ModelConfig, swiftCfg *config.SwiftPackage) *codec {
+func newCodec(model *api.API, cfg *parser.ModelConfig, swiftCfg *config.SwiftPackage, outdir string) (*codec, error) {
 	year, _, _ := time.Now().Date()
+	absOutdir, err := filepath.Abs(outdir)
+	if err != nil {
+		return nil, err
+	}
+	// The generator must run at the root of the monorepo, because that is where we keep the `librarian.yaml` file and
+	// because all the `outdir` directories are computed relative to that location. So effectively this gets the root
+	// of the monorepo.
+	absRoot, err := filepath.Abs(".")
+	if err != nil {
+		return nil, err
+	}
+	rel, err := filepath.Rel(absOutdir, absRoot)
+	if err != nil {
+		return nil, err
+	}
 	result := &codec{
 		GenerationYear: fmt.Sprintf("%04d", year),
 		PackageName:    PackageName(model),
+		MonorepoRoot:   rel,
 		RootName:       "googleapis",
 		Model:          model,
 	}
@@ -63,5 +81,5 @@ func newCodec(model *api.API, cfg *parser.ModelConfig, swiftCfg *config.SwiftPac
 			// Ignore other options.
 		}
 	}
-	return result
+	return result, nil
 }

internal/sidekick/swift/codec_test.go

@@ -31,10 +31,14 @@ func TestParseOptions(t *testing.T) {
 		},
 	}
 	model := api.NewTestAPI([]*api.Message{}, []*api.Enum{}, []*api.Service{})
-	got := newCodec(model, cfg, nil)
+	got, err := newCodec(model, cfg, nil, ".")
+	if err != nil {
+		t.Fatal(err)
+	}
 	want := &codec{
 		GenerationYear: "2038",
 		PackageName:    "GoogleCloudBigtable",
+		MonorepoRoot:   ".",
 		RootName:       "test-root",
 		Model:          model,
 	}
@@ -49,5 +53,9 @@ func newTestCodec(t *testing.T, model *api.API, options map[string]string) *code
 	cfg := &parser.ModelConfig{
 		Codec: options,
 	}
-	return newCodec(model, cfg, nil)
+	codec, err := newCodec(model, cfg, nil, ".")
+	if err != nil {
+		t.Fatal(err)
+	}
+	return codec
 }

internal/sidekick/swift/generate.go

@@ -31,7 +31,10 @@ var templates embed.FS
 
 // Generate generates code from the model.
 func Generate(ctx context.Context, model *api.API, outdir string, cfg *parser.ModelConfig, swiftCfg *config.SwiftPackage) error {
-	codec := newCodec(model, cfg, swiftCfg)
+	codec, err := newCodec(model, cfg, swiftCfg, outdir)
+	if err != nil {
+		return err
+	}
 	if err := codec.annotateModel(); err != nil {
 		return err
 	}