@shortlink-org/portolan 0.1.0 → 0.2.1

package/plugins/extract-proto/resolve.go

@@ -1,222 +0,0 @@
-package main
-
-// Turning a name as written into the thing it names.
-//
-// A proto reference is relative to where it was written: `Money` inside
-// `shop.v1.Order` might mean `shop.v1.Order.Money`, `shop.v1.Money`, or
-// `Money` at the root, and proto searches outwards in that order. A leading dot
-// means the search is skipped and the name is already absolute.
-//
-// A name that resolves to nothing is NOT an error here. A narrowed vendored
-// copy importing a file nobody vendored beside it is the normal case - see the
-// header of parse.go - and the answer is to say the type is unresolved and
-// carry on, not to refuse to describe the file.
-
-import (
-	"sort"
-	"strings"
-)
-
-// scalars are proto's built-in types, which never resolve to a declaration.
-var scalars = map[string]bool{
-	"double": true, "float": true, "int32": true, "int64": true,
-	"uint32": true, "uint64": true, "sint32": true, "sint64": true,
-	"fixed32": true, "fixed64": true, "sfixed32": true, "sfixed64": true,
-	"bool": true, "string": true, "bytes": true,
-}
-
-func isScalar(name string) bool { return scalars[name] }
-
-// Index is every declaration in a set of files, by fully-qualified name.
-type Index struct {
-	files []*File
-
-	messages map[string]*Message
-	enums    map[string]*Enum
-	fileOf   map[string]*File
-	fqnOf    map[*Message]string
-}
-
-// NewIndex walks the files once and records every message and enum in them,
-// nested ones included, under the name the rest of the world would use.
-func NewIndex(files []*File) *Index {
-	ix := &Index{
-		files:    files,
-		messages: map[string]*Message{},
-		enums:    map[string]*Enum{},
-		fileOf:   map[string]*File{},
-		fqnOf:    map[*Message]string{},
-	}
-
-	for _, file := range files {
-		for _, m := range file.Messages {
-			ix.addMessage(file, file.Package, m)
-		}
-		for _, e := range file.Enums {
-			ix.addEnum(file, join(file.Package, e.Name), e)
-		}
-	}
-
-	return ix
-}
-
-func (ix *Index) addMessage(file *File, scope string, m *Message) {
-	fqn := join(scope, m.Name)
-	ix.messages[fqn] = m
-	ix.fileOf[fqn] = file
-	ix.fqnOf[m] = fqn
-
-	for _, nested := range m.Messages {
-		ix.addMessage(file, fqn, nested)
-	}
-	for _, e := range m.Enums {
-		ix.addEnum(file, join(fqn, e.Name), e)
-	}
-}
-
-func (ix *Index) addEnum(file *File, fqn string, e *Enum) {
-	ix.enums[fqn] = e
-	ix.fileOf[fqn] = file
-}
-
-// Resolve finds what `name`, written inside `scope`, refers to.
-//
-// scope is a fully-qualified name - a package, or a message inside one. The
-// search walks outwards from it, which is what proto itself does.
-func (ix *Index) Resolve(scope, name string) (string, bool) {
-	if name == "" || isScalar(name) {
-		return "", false
-	}
-
-	if strings.HasPrefix(name, ".") {
-		fqn := strings.TrimPrefix(name, ".")
-
-		return fqn, ix.declared(fqn)
-	}
-
-	parts := strings.Split(scope, ".")
-	for i := len(parts); i >= 0; i-- {
-		fqn := join(strings.Join(parts[:i], "."), name)
-		if ix.declared(fqn) {
-			return fqn, true
-		}
-	}
-
-	return "", false
-}
-
-func (ix *Index) declared(fqn string) bool {
-	_, message := ix.messages[fqn]
-	_, enum := ix.enums[fqn]
-
-	return message || enum
-}
-
-func (ix *Index) Message(fqn string) *Message { return ix.messages[fqn] }
-func (ix *Index) Enum(fqn string) *Enum       { return ix.enums[fqn] }
-func (ix *Index) FileOf(fqn string) *File     { return ix.fileOf[fqn] }
-
-// FQN is the name a message is known by, once it has been indexed.
-func (ix *Index) FQN(m *Message) string { return ix.fqnOf[m] }
-
-// Names is every declared name, sorted. Determinism is not a nicety here: the
-// fragment these end up in is committed and compared by `gen:check`, so a map
-// iterated in Go's order would produce a different file every run.
-func (ix *Index) Names() []string {
-	out := make([]string, 0, len(ix.messages)+len(ix.enums))
-	for fqn := range ix.messages {
-		out = append(out, fqn)
-	}
-	for fqn := range ix.enums {
-		out = append(out, fqn)
-	}
-	sort.Strings(out)
-
-	return out
-}
-
-// TypeRef is one field's type, resolved as far as it could be.
-type TypeRef struct {
-	// Written is the type as the author typed it, rendered the way the catalog
-	// renders types: `[]LineItem`, `map[string]Money`, `Money`.
-	Written string
-
-	// FQN is what the named type resolves to, empty for a scalar or for a name
-	// nothing in the tree declares.
-	FQN string
-
-	// Unresolved is the name that could not be found, empty when there was
-	// nothing to find or the search succeeded. It is a diagnostic, not a
-	// failure: a narrowed vendored copy is expected to have some.
-	Unresolved string
-}
-
-// resolveType renders a field's type and resolves the name inside it.
-//
-// A map is rendered `map[K]V` and resolved on its value: the key of a proto map
-// is always a scalar, and the value is the half that can name a message.
-func (ix *Index) resolveType(scope string, f *Field) TypeRef {
-	if key, value, ok := mapParts(f.Type); ok {
-		inner := ix.resolveType(scope, &Field{Type: value})
-
-		return TypeRef{
-			Written:    "map[" + key + "]" + inner.Written,
-			FQN:        inner.FQN,
-			Unresolved: inner.Unresolved,
-		}
-	}
-
-	ref := TypeRef{Written: shortName(f.Type)}
-	if f.Label == "repeated" {
-		ref.Written = "[]" + ref.Written
-	}
-
-	if isScalar(f.Type) {
-		return ref
-	}
-
-	if fqn, ok := ix.Resolve(scope, f.Type); ok {
-		ref.FQN = fqn
-	} else {
-		ref.Unresolved = f.Type
-	}
-
-	return ref
-}
-
-// mapParts splits `map<string, Money>` into its two arguments.
-func mapParts(typ string) (string, string, bool) {
-	if !strings.HasPrefix(typ, "map<") || !strings.HasSuffix(typ, ">") {
-		return "", "", false
-	}
-	inner := typ[len("map<") : len(typ)-1]
-	comma := strings.Index(inner, ",")
-	if comma < 0 {
-		return "", "", false
-	}
-
-	return strings.TrimSpace(inner[:comma]), strings.TrimSpace(inner[comma+1:]), true
-}
-
-// shortName is the last segment of a dotted name.
-//
-// The catalog spells a type the way a reader says it - `Money`, not
-// `shop.v1.Money` - and its `defs` keys are deliberately bare for the same
-// reason: two sources meaning different things by `Money` should collide
-// visibly rather than coexist as two quietly different entries.
-func shortName(name string) string {
-	name = strings.TrimPrefix(name, ".")
-	if i := strings.LastIndex(name, "."); i >= 0 {
-		return name[i+1:]
-	}
-
-	return name
-}
-
-func join(scope, name string) string {
-	if scope == "" {
-		return name
-	}
-
-	return scope + "." + name
-}

package/plugins/extract-proto/resolve_test.go

@@ -1,119 +0,0 @@
-package main
-
-// Name resolution, on its own. A proto reference means whatever the innermost
-// enclosing scope that declares it means, and a name nothing declares is a
-// diagnostic rather than a failure.
-
-import "testing"
-
-func indexed(t *testing.T) *Index {
-	t.Helper()
-
-	orders, _ := parseFile(t, "orders.proto")
-	money, _ := parseFile(t, "money.proto")
-
-	return NewIndex([]*File{orders, money})
-}
-
-func TestResolvesAcrossFiles(t *testing.T) {
-	ix := indexed(t)
-
-	fqn, ok := ix.Resolve("shop.v1", "Money")
-	if !ok || fqn != "shop.v1.Money" {
-		t.Errorf("Money from shop.v1: %q %v", fqn, ok)
-	}
-	if ix.Message(fqn) == nil {
-		t.Error("the resolved name does not lead back to the message")
-	}
-}
-
-// Proto searches outwards from where the name was written, so the nested type
-// wins over anything of the same name further out.
-func TestResolvesInnermostFirst(t *testing.T) {
-	ix := indexed(t)
-
-	fqn, ok := ix.Resolve("shop.v1.Order", "Address")
-	if !ok || fqn != "shop.v1.Order.Address" {
-		t.Errorf("Address from inside Order: %q %v", fqn, ok)
-	}
-
-	// The same name written one scope out finds nothing, which is the point.
-	if _, ok := ix.Resolve("shop.v1", "Address"); ok {
-		t.Error("a nested type resolved from outside the message that nests it")
-	}
-}
-
-func TestLeadingDotIsAbsolute(t *testing.T) {
-	ix := indexed(t)
-
-	fqn, ok := ix.Resolve("shop.v1.Order", ".shop.v1.Money")
-	if !ok || fqn != "shop.v1.Money" {
-		t.Errorf("absolute name: %q %v", fqn, ok)
-	}
-}
-
-func TestNestedEnumIsIndexed(t *testing.T) {
-	ix := indexed(t)
-
-	fqn, ok := ix.Resolve("shop.v1.Order", "Channel")
-	if !ok || fqn != "shop.v1.Order.Channel" {
-		t.Errorf("nested enum: %q %v", fqn, ok)
-	}
-	if ix.Enum(fqn) == nil {
-		t.Error("the resolved name does not lead back to the enum")
-	}
-}
-
-// The whole reason this parser is tolerant: a narrowed vendored copy imports
-// files nobody vendored beside it, and it must still be describable.
-func TestUnresolvedIsReportedNotFatal(t *testing.T) {
-	ix := indexed(t)
-
-	ref := ix.resolveType("shop.v1", &Field{Type: "Nowhere"})
-	if ref.Unresolved != "Nowhere" {
-		t.Errorf("an unknown type was not reported: %+v", ref)
-	}
-	if ref.Written != "Nowhere" {
-		t.Errorf("an unknown type must still be shown as written: %q", ref.Written)
-	}
-}
-
-// Types are rendered the way the catalog renders types, and resolved on the
-// half that can name a message.
-func TestTypeRendering(t *testing.T) {
-	ix := indexed(t)
-
-	cases := []struct {
-		field        Field
-		written, fqn string
-	}{
-		{Field{Type: "string"}, "string", ""},
-		{Field{Type: "Money"}, "Money", "shop.v1.Money"},
-		{Field{Type: "shop.v1.Money"}, "Money", "shop.v1.Money"},
-		{Field{Type: "LineItem", Label: "repeated"}, "[]LineItem", "shop.v1.LineItem"},
-		{Field{Type: "map<string, string>"}, "map[string]string", ""},
-		{Field{Type: "map<string, Money>"}, "map[string]Money", "shop.v1.Money"},
-	}
-
-	for _, c := range cases {
-		got := ix.resolveType("shop.v1", &c.field)
-		if got.Written != c.written || got.FQN != c.fqn {
-			t.Errorf("%s: %q -> %q (want %q -> %q)", c.field.Type, got.Written, got.FQN, c.written, c.fqn)
-		}
-	}
-}
-
-// The fragment is committed and compared by gen:check, so anything derived from
-// a map has to come out in the same order every run.
-func TestNamesAreSorted(t *testing.T) {
-	names := indexed(t).Names()
-
-	for i := 1; i < len(names); i++ {
-		if names[i-1] > names[i] {
-			t.Fatalf("names are not sorted: %q before %q", names[i-1], names[i])
-		}
-	}
-	if len(names) == 0 {
-		t.Fatal("nothing was indexed")
-	}
-}

package/plugins/extract-redis/describe.go

@@ -1,19 +0,0 @@
-package main
-
-import (
-	_ "embed"
-
-	"github.com/shortlink-org/portolan/plugin"
-)
-
-//go:embed options.schema.json
-var optionsSchema []byte
-
-func descriptor() plugin.Descriptor {
-	return plugin.Descriptor{
-		Name:    "extract-redis",
-		Summary: "Finds runtime construction of supported Go Redis clients and adds the service-owned Redis store to the catalog.",
-		Phases:  []string{plugin.PhaseExtract},
-		Options: optionsSchema,
-	}
-}

package/plugins/extract-redis/describe_test.go

@@ -1,11 +0,0 @@
-package main
-
-import (
-	"testing"
-
-	"github.com/shortlink-org/portolan/plugin/schematest"
-)
-
-func TestOptionsSchemaMatchesStruct(t *testing.T) {
-	schematest.Check(t, optionsSchema, Options{})
-}

package/plugins/extract-redis/extract.go

@@ -1,183 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"go/ast"
-	"strconv"
-	"strings"
-
-	"github.com/shortlink-org/portolan/catalog"
-	"github.com/shortlink-org/portolan/internal/goscan"
-	"github.com/shortlink-org/portolan/plugin"
-)
-
-type redisConstruction struct {
-	at goscan.Source
-}
-
-func extract(in plugin.Input, opts Options) (plugin.Response, error) {
-	b := &plugin.Builder{}
-	tree, err := goscan.Read(in.Root)
-	if err != nil {
-		return plugin.Response{}, err
-	}
-
-	owner := opts.Context + "." + opts.Service
-	service := catalog.Service{
-		ID:         owner,
-		Slug:       opts.Service,
-		Provides:   []catalog.RpcService{},
-		Consumes:   []catalog.RpcCall{},
-		Aggregates: []catalog.Aggregate{},
-	}
-	stores := []catalog.Store{}
-	if found := findRedisConstruction(tree); found != nil {
-		keyspaces := scanRedisKeyspaces(tree)
-		storeSlug := firstNonEmpty(opts.Store, "redis")
-		storeID := owner + "." + storeSlug
-		service.Stores = []string{storeID}
-		stores = append(stores, catalog.Store{
-			ID:        storeID,
-			Slug:      storeSlug,
-			Name:      firstNonEmpty(opts.Name, opts.Service+" Redis"),
-			Kind:      catalog.StoreKindRedis,
-			Owner:     owner,
-			Tables:    []catalog.Table{},
-			Keyspaces: keyspaces,
-			Source:    found.at.String(),
-		})
-	} else {
-		b.Warn(owner, "no supported Redis client construction was found in non-test Go source")
-	}
-
-	fragment := catalog.Catalog{
-		GeneratedAt: in.GeneratedAt,
-		Commit:      in.Commit,
-		Contexts: []catalog.BoundedContext{{
-			ID:       opts.Context,
-			Slug:     opts.Context,
-			Services: []catalog.Service{service},
-		}},
-		Defs:   map[string]catalog.TypeDef{},
-		Flows:  []catalog.Flow{},
-		Adrs:   []catalog.Adr{},
-		Stores: stores,
-	}
-	encoded, err := json.MarshalIndent(fragment, "", "  ")
-	if err != nil {
-		return plugin.Response{}, err
-	}
-	b.File(firstNonEmpty(opts.Out, "redis.json"), string(encoded)+"\n")
-
-	return b.Response(), nil
-}
-
-func findRedisConstruction(tree *goscan.Tree) *redisConstruction {
-	for _, file := range tree.Files {
-		var found *redisConstruction
-		ast.Inspect(file.Node, func(node ast.Node) bool {
-			if found != nil {
-				return false
-			}
-			call, ok := node.(*ast.CallExpr)
-			if !ok {
-				return true
-			}
-			sel, ok := call.Fun.(*ast.SelectorExpr)
-			if !ok {
-				return true
-			}
-			pkg, ok := sel.X.(*ast.Ident)
-			if !ok {
-				return true
-			}
-			importPath := redisImportPath(file, pkg.Name)
-			if !isRedisConstructor(importPath, sel.Sel.Name) {
-				return true
-			}
-			found = &redisConstruction{at: tree.At(call.Pos())}
-			return false
-		})
-		if found != nil {
-			return found
-		}
-	}
-
-	return nil
-}
-
-// Versioned Go module paths end in v8/v9, while the packages still call
-// themselves redis. goscan cannot infer an external package clause from the
-// import path, so fill in the stable package names of the clients understood
-// by this extractor. Explicit aliases are already present in file.Imports.
-func redisImportPath(file *goscan.File, packageName string) string {
-	for _, spec := range file.Node.Imports {
-		importPath, err := strconv.Unquote(spec.Path.Value)
-		if err != nil || !isRedisClientImport(importPath) {
-			continue
-		}
-		if spec.Name != nil {
-			if spec.Name.Name == packageName {
-				return importPath
-			}
-			continue
-		}
-		if packageName == defaultRedisPackage(importPath) {
-			return importPath
-		}
-	}
-	return ""
-}
-
-func isRedisConstructor(importPath, name string) bool {
-	switch {
-	case isGoRedisImport(importPath):
-		switch name {
-		case "NewClient", "NewClusterClient", "NewFailoverClient", "NewFailoverClusterClient":
-			return true
-		}
-	case importPath == "github.com/redis/rueidis" || strings.HasPrefix(importPath, "github.com/redis/rueidis/"):
-		return name == "NewClient"
-	case importPath == "github.com/gomodule/redigo/redis":
-		return name == "Dial" || name == "DialURL"
-	}
-
-	return false
-}
-
-func isRedisClientImport(importPath string) bool {
-	return isGoRedisImport(importPath) || importPath == "github.com/redis/rueidis" ||
-		strings.HasPrefix(importPath, "github.com/redis/rueidis/") || importPath == "github.com/gomodule/redigo/redis"
-}
-
-func isGoRedisImport(importPath string) bool {
-	for _, base := range []string{"github.com/redis/go-redis", "github.com/go-redis/redis"} {
-		if importPath == base {
-			return true
-		}
-		version, ok := strings.CutPrefix(importPath, base+"/v")
-		if !ok || version == "" {
-			continue
-		}
-		if _, err := strconv.Atoi(version); err == nil {
-			return true
-		}
-	}
-	return false
-}
-
-func defaultRedisPackage(importPath string) string {
-	if importPath == "github.com/redis/rueidis" || strings.HasPrefix(importPath, "github.com/redis/rueidis/") {
-		return "rueidis"
-	}
-	return "redis"
-}
-
-func firstNonEmpty(values ...string) string {
-	for _, value := range values {
-		if value != "" {
-			return value
-		}
-	}
-	return ""
-}