glot: move source files around for easier goat merge

cmd/glot/lex_util.go

···
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log/slog"
+	"sort"
+	"strings"
+
+	"github.com/bluesky-social/indigo/api/agnostic"
+	"github.com/bluesky-social/indigo/atproto/atclient"
+	"github.com/bluesky-social/indigo/atproto/identity"
+	"github.com/bluesky-social/indigo/atproto/lexicon"
+	"github.com/bluesky-social/indigo/atproto/syntax"
+
+	"github.com/urfave/cli/v3"
+)
+
+var (
+	schemaNSID = syntax.NSID("com.atproto.lexicon.schema")
+)
+
+func nsidGroup(nsid syntax.NSID) string {
+	parts := strings.Split(string(nsid), ".")
+	g := strings.Join(parts[0:len(parts)-1], ".") + "."
+	return g
+}
+
+// Checks if a string is a valid NSID group pattern, which is a partial NSID ending in '.' or '.*'
+func ParseNSIDGroup(raw string) (string, error) {
+	if strings.HasSuffix(raw, ".*") {
+		raw = raw[:len(raw)-1]
+	}
+	if !strings.HasSuffix(raw, ".") {
+		return "", fmt.Errorf("not an NSID group pattern")
+	}
+	_, err := syntax.ParseNSID(raw + "name")
+	if err != nil {
+		return "", fmt.Errorf("not an NSID group pattern")
+	}
+	return raw, nil
+}
+
+// helper which runs a comparison function across local and remote schemas, based on 'cmd' configuration
+func runComparisons(ctx context.Context, cmd *cli.Command, comp func(ctx context.Context, cmd *cli.Command, nsid syntax.NSID, localJSON, remoteJSON json.RawMessage) error) error {
+
+	// collect all NSID/path mappings
+	localSchemas, err := collectSchemaJSON(cmd)
+	if err != nil {
+		return err
+	}
+	remoteSchemas := map[syntax.NSID]json.RawMessage{}
+
+	localGroups := map[string]bool{}
+	allNSIDMap := map[syntax.NSID]bool{}
+	for k := range localSchemas {
+		g := nsidGroup(k)
+		localGroups[g] = true
+		allNSIDMap[k] = true
+	}
+
+	for g := range localGroups {
+		if err := resolveLexiconGroup(ctx, cmd, g, &remoteSchemas); err != nil {
+			return err
+		}
+	}
+
+	for k := range remoteSchemas {
+		allNSIDMap[k] = true
+	}
+	allNSID := []string{}
+	for k := range allNSIDMap {
+		allNSID = append(allNSID, string(k))
+	}
+	sort.Strings(allNSID)
+
+	anyFailures := false
+	for _, k := range allNSID {
+		nsid := syntax.NSID(k)
+		if err := comp(ctx, cmd, nsid, localSchemas[nsid], remoteSchemas[nsid]); err != nil {
+			if err != ErrLintFailures {
+				return err
+			}
+			anyFailures = true
+		}
+	}
+
+	if anyFailures {
+		return ErrLintFailures
+	}
+	return nil
+}
+
+// helper which resolves and fetches all lexicon schemas (as JSON), storing them in provided map
+func resolveLexiconGroup(ctx context.Context, cmd *cli.Command, group string, remote *map[syntax.NSID]json.RawMessage) error {
+
+	slog.Debug("resolving schemas for NSID group", "group", group)
+
+	// TODO: netclient support for listing records
+	dir := identity.BaseDirectory{}
+	did, err := dir.ResolveNSID(ctx, syntax.NSID(group+"name"))
+	if err != nil {
+		// if NSID isn't registered, just skip comparison
+		slog.Warn("skipping NSID pattern which did not resolve", "group", group)
+		return nil
+	}
+	ident, err := dir.LookupDID(ctx, did)
+	if err != nil {
+		return err
+	}
+	c := atclient.NewAPIClient(ident.PDSEndpoint())
+
+	cursor := ""
+	for {
+		// collection string, cursor string, limit int64, repo string, reverse bool
+		resp, err := agnostic.RepoListRecords(ctx, c, schemaNSID.String(), cursor, 100, ident.DID.String(), false)
+		if err != nil {
+			return err
+		}
+		for _, rec := range resp.Records {
+			aturi, err := syntax.ParseATURI(rec.Uri)
+			if err != nil {
+				return err
+			}
+			nsid, err := syntax.ParseNSID(aturi.RecordKey().String())
+			if err != nil {
+				slog.Warn("ignoring invalid schema NSID", "did", ident.DID, "rkey", aturi.RecordKey())
+				continue
+			}
+			if nsidGroup(nsid) != group {
+				// ignoring other NSIDs
+				continue
+			}
+			if rec.Value == nil {
+				return fmt.Errorf("missing record value: %s", nsid)
+			}
+
+			// parse file to check for errors
+			// TODO: use json/v2 when available for case-sensitivity
+			var sf lexicon.SchemaFile
+			err = json.Unmarshal(*rec.Value, &sf)
+			if err == nil {
+				err = sf.FinishParse()
+			}
+			if err == nil {
+				err = sf.CheckSchema()
+			}
+			if err != nil {
+				return fmt.Errorf("invalid lexicon schema record (%s): %w", nsid, err)
+			}
+
+			(*remote)[nsid] = *rec.Value
+
+		}
+		if resp.Cursor != nil && *resp.Cursor != "" {
+			cursor = *resp.Cursor
+		} else {
+			break
+		}
+	}
+	return nil
+}

cmd/glot/new.go cmd/glot/lex_new.go

···
 	"github.com/urfave/cli/v3"
 )
 
-//go:embed templates/record.json
+//go:embed lexicon-templates/record.json
 var tmplRecord string
 
-//go:embed templates/query-view.json
+//go:embed lexicon-templates/query-view.json
 var tmplQueryView string
 
-//go:embed templates/query-list.json
+//go:embed lexicon-templates/query-list.json
 var tmplQueryList string
 
-//go:embed templates/procedure.json
+//go:embed lexicon-templates/procedure.json
 var tmplProcedure string
 
 var cmdNew = &cli.Command{

cmd/glot/util.go

···
-package main
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/bluesky-social/indigo/atproto/syntax"
-)
-
-var (
-	schemaNSID = syntax.NSID("com.atproto.lexicon.schema")
-)
-
-func nsidGroup(nsid syntax.NSID) string {
-	parts := strings.Split(string(nsid), ".")
-	g := strings.Join(parts[0:len(parts)-1], ".") + "."
-	return g
-}
-
-// Checks if a string is a valid NSID group pattern, which is a partial NSID ending in '.' or '.*'
-func ParseNSIDGroup(raw string) (string, error) {
-	if strings.HasSuffix(raw, ".*") {
-		raw = raw[:len(raw)-1]
-	}
-	if !strings.HasSuffix(raw, ".") {
-		return "", fmt.Errorf("not an NSID group pattern")
-	}
-	_, err := syntax.ParseNSID(raw + "name")
-	if err != nil {
-		return "", fmt.Errorf("not an NSID group pattern")
-	}
-	return raw, nil
-}

cmd/glot/util_compare.go

···
-package main
-
-import (
-	"context"
-	"encoding/json"
-	"sort"
-
-	"github.com/bluesky-social/indigo/atproto/syntax"
-
-	"github.com/urfave/cli/v3"
-)
-
-func runComparisons(ctx context.Context, cmd *cli.Command, comp func(ctx context.Context, cmd *cli.Command, nsid syntax.NSID, localJSON, remoteJSON json.RawMessage) error) error {
-
-	// collect all NSID/path mappings
-	localSchemas, err := collectSchemaJSON(cmd)
-	if err != nil {
-		return err
-	}
-	remoteSchemas := map[syntax.NSID]json.RawMessage{}
-
-	localGroups := map[string]bool{}
-	allNSIDMap := map[syntax.NSID]bool{}
-	for k := range localSchemas {
-		g := nsidGroup(k)
-		localGroups[g] = true
-		allNSIDMap[k] = true
-	}
-
-	for g := range localGroups {
-		if err := resolveLexiconGroup(ctx, cmd, g, &remoteSchemas); err != nil {
-			return err
-		}
-	}
-
-	for k := range remoteSchemas {
-		allNSIDMap[k] = true
-	}
-	allNSID := []string{}
-	for k := range allNSIDMap {
-		allNSID = append(allNSID, string(k))
-	}
-	sort.Strings(allNSID)
-
-	anyFailures := false
-	for _, k := range allNSID {
-		nsid := syntax.NSID(k)
-		if err := comp(ctx, cmd, nsid, localSchemas[nsid], remoteSchemas[nsid]); err != nil {
-			if err != ErrLintFailures {
-				return err
-			}
-			anyFailures = true
-		}
-	}
-
-	if anyFailures {
-		return ErrLintFailures
-	}
-	return nil
-}

cmd/glot/util_fetch.go

···
-package main
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"log/slog"
-
-	"github.com/bluesky-social/indigo/api/agnostic"
-	"github.com/bluesky-social/indigo/atproto/atclient"
-	"github.com/bluesky-social/indigo/atproto/identity"
-	"github.com/bluesky-social/indigo/atproto/lexicon"
-	"github.com/bluesky-social/indigo/atproto/syntax"
-
-	"github.com/urfave/cli/v3"
-)
-
-// helper which resolves and fetches all lexicon schemas (as JSON), storing them in provided map
-func resolveLexiconGroup(ctx context.Context, cmd *cli.Command, group string, remote *map[syntax.NSID]json.RawMessage) error {
-
-	slog.Debug("resolving schemas for NSID group", "group", group)
-
-	// TODO: netclient support for listing records
-	dir := identity.BaseDirectory{}
-	did, err := dir.ResolveNSID(ctx, syntax.NSID(group+"name"))
-	if err != nil {
-		// if NSID isn't registered, just skip comparison
-		slog.Warn("skipping NSID pattern which did not resolve", "group", group)
-		return nil
-	}
-	ident, err := dir.LookupDID(ctx, did)
-	if err != nil {
-		return err
-	}
-	c := atclient.NewAPIClient(ident.PDSEndpoint())
-
-	cursor := ""
-	for {
-		// collection string, cursor string, limit int64, repo string, reverse bool
-		resp, err := agnostic.RepoListRecords(ctx, c, schemaNSID.String(), cursor, 100, ident.DID.String(), false)
-		if err != nil {
-			return err
-		}
-		for _, rec := range resp.Records {
-			aturi, err := syntax.ParseATURI(rec.Uri)
-			if err != nil {
-				return err
-			}
-			nsid, err := syntax.ParseNSID(aturi.RecordKey().String())
-			if err != nil {
-				slog.Warn("ignoring invalid schema NSID", "did", ident.DID, "rkey", aturi.RecordKey())
-				continue
-			}
-			if nsidGroup(nsid) != group {
-				// ignoring other NSIDs
-				continue
-			}
-			if rec.Value == nil {
-				return fmt.Errorf("missing record value: %s", nsid)
-			}
-
-			// parse file to check for errors
-			// TODO: use json/v2 when available for case-sensitivity
-			var sf lexicon.SchemaFile
-			err = json.Unmarshal(*rec.Value, &sf)
-			if err == nil {
-				err = sf.FinishParse()
-			}
-			if err == nil {
-				err = sf.CheckSchema()
-			}
-			if err != nil {
-				return fmt.Errorf("invalid lexicon schema record (%s): %w", nsid, err)
-			}
-
-			(*remote)[nsid] = *rec.Value
-
-		}
-		if resp.Cursor != nil && *resp.Cursor != "" {
-			cursor = *resp.Cursor
-		} else {
-			break
-		}
-	}
-	return nil
-}