@shortlink-org/portolan 0.1.0 → 0.2.0

package/internal/commands/packagejson.go

@@ -1,159 +0,0 @@
-package commands
-
-import (
-	"encoding/json"
-	"strings"
-
-	"github.com/shortlink-org/portolan/catalog"
-)
-
-// readPackageJSON lists the scripts of a package manifest, in the order the
-// file lists them, because the author put `build` before `deploy` for a
-// reason and a sorted list would lose it. `pre` and `post` hooks of a listed
-// script are folded into it, the way the runner runs them. The line to type
-// is the runner's: npm keeps `start`, `test`, `stop` and `restart` as
-// commands of their own, and a checkout with a pnpm or yarn lockfile is
-// typed at that tool instead.
-func readPackageJSON(file, src, runner string) ([]catalog.Command, []string) {
-	scripts, lines, err := packageScripts(src)
-	if err != nil {
-		return nil, []string{file + ": " + err.Error()}
-	}
-
-	out := make([]catalog.Command, 0, len(scripts))
-	for _, script := range scripts {
-		out = append(out, catalog.Command{
-			Runner: runner,
-			Name:   script.name,
-			Run:    runLine(runner, script.name),
-			Body:   script.body,
-			Source: at(file, lines[script.name]),
-		})
-	}
-
-	return hooks(out, "pre", "post"), nil
-}
-
-type script struct{ name, body string }
-
-// packageScripts walks the document token by token, which is the one way
-// encoding/json will give back an object's keys in file order.
-func packageScripts(src string) ([]script, map[string]int, error) {
-	dec := json.NewDecoder(strings.NewReader(src))
-	tok, err := dec.Token()
-	if err != nil || tok != json.Delim('{') {
-		return nil, nil, wrap("not a JSON object", err)
-	}
-	for dec.More() {
-		keyTok, err := dec.Token()
-		if err != nil {
-			return nil, nil, wrap("not a JSON object", err)
-		}
-		key, _ := keyTok.(string)
-		if key != "scripts" {
-			var skip json.RawMessage
-			if err := dec.Decode(&skip); err != nil {
-				return nil, nil, wrap("not a JSON object", err)
-			}
-
-			continue
-		}
-
-		offset := int(dec.InputOffset())
-		var raw json.RawMessage
-		if err := dec.Decode(&raw); err != nil {
-			return nil, nil, wrap("scripts could not be read", err)
-		}
-		var byName map[string]string
-		if err := json.Unmarshal(raw, &byName); err != nil {
-			return nil, nil, wrap("scripts is not an object of strings", err)
-		}
-		order := keyOrder(raw)
-		scripts := make([]script, 0, len(order))
-		for _, name := range order {
-			scripts = append(scripts, script{name: name, body: byName[name]})
-		}
-
-		return scripts, keyLines(src, offset, raw), nil
-	}
-
-	return nil, nil, nil
-}
-
-func wrap(what string, err error) error {
-	if err == nil {
-		return errString(what)
-	}
-
-	return errString(what + ": " + err.Error())
-}
-
-type errString string
-
-func (e errString) Error() string { return string(e) }
-
-// keyOrder reads the keys of a JSON object in the order they are written.
-func keyOrder(raw json.RawMessage) []string {
-	dec := json.NewDecoder(strings.NewReader(string(raw)))
-	if tok, err := dec.Token(); err != nil || tok != json.Delim('{') {
-		return nil
-	}
-	var keys []string
-	for dec.More() {
-		tok, err := dec.Token()
-		if err != nil {
-			return keys
-		}
-		if key, ok := tok.(string); ok {
-			keys = append(keys, key)
-		}
-		var skip json.RawMessage
-		if err := dec.Decode(&skip); err != nil {
-			return keys
-		}
-	}
-
-	return keys
-}
-
-// keyLines finds the line each script's key sits on. The decoder says where
-// the `scripts` key ended, the object opens at the next brace, and each key's
-// position inside the object is then a position in the file.
-func keyLines(src string, offset int, raw json.RawMessage) map[string]int {
-	lines := map[string]int{}
-	brace := strings.Index(src[offset:], "{")
-	if brace < 0 {
-		return lines
-	}
-	start := offset + brace
-	object := string(raw)
-	for _, key := range keyOrder(raw) {
-		quoted := `"` + key + `"`
-		at := strings.Index(object, quoted)
-		if at < 0 {
-			continue
-		}
-		lines[key] = 1 + strings.Count(src[:start+at], "\n")
-		// Blank the key so a second script whose name contains this one
-		// (`build` inside `build:watch`) is not found at the first.
-		object = object[:at] + strings.Repeat(" ", len(quoted)) + object[at+len(quoted):]
-	}
-
-	return lines
-}
-
-func runLine(runner, name string) string {
-	switch runner {
-	case "npm":
-		switch name {
-		case "start", "test", "stop", "restart":
-			return "npm " + name
-		}
-
-		return "npm run " + name
-	case "bun":
-		return "bun run " + name
-	}
-
-	return runner + " " + name
-}

package/internal/commands/pyproject.go

@@ -1,169 +0,0 @@
-package commands
-
-import (
-	"regexp"
-	"strings"
-
-	"github.com/shortlink-org/portolan/catalog"
-)
-
-var tomlHeader = regexp.MustCompile(`^\[([^\]]+)\]\s*$`)
-var tomlKey = regexp.MustCompile(`^([A-Za-z0-9_.-]+|"[^"]+")\s*=\s*(.*)$`)
-var tomlString = regexp.MustCompile(`^(?:"((?:[^"\\]|\\.)*)"|'([^']*)')`)
-var tomlInlineField = regexp.MustCompile(`(\w+)\s*=\s*(?:"((?:[^"\\]|\\.)*)"|'([^']*)'|\[([^\]]*)\])`)
-
-// readPyproject lists the tasks of the two task runners that live in
-// pyproject.toml: poe (`[tool.poe.tasks]`) and pdm (`[tool.pdm.scripts]`).
-// Python has no runner of its own, and uv has no task section, so a
-// pyproject without one of these tables declares no commands.
-//
-// The reader is a line scanner, not a TOML parser: it follows table headers
-// and reads `name = "cmd"`, `name = ["cmd", "arg"]`, `name = { cmd = "...",
-// help = "..." }` and `[tool.poe.tasks.name]` subtables. That is the whole of
-// what either runner's documentation shows, and a full parser would be a
-// dependency for the sake of shapes nobody writes.
-func readPyproject(file, src string) []catalog.Command {
-	runners := []struct {
-		table  string
-		runner string
-		run    string
-	}{
-		{"tool.poe.tasks", "poe", "poe "},
-		{"tool.pdm.scripts", "pdm", "pdm run "},
-	}
-
-	lines := strings.Split(src, "\n")
-	var out []catalog.Command
-	for _, r := range runners {
-		var cmds []catalog.Command
-		byName := map[string]int{}
-		upsert := func(cmd catalog.Command) {
-			if i, ok := byName[cmd.Name]; ok {
-				if cmd.Doc != "" {
-					cmds[i].Doc = cmd.Doc
-				}
-				if cmd.Body != "" {
-					cmds[i].Body = cmd.Body
-				}
-
-				return
-			}
-			byName[cmd.Name] = len(cmds)
-			cmds = append(cmds, cmd)
-		}
-
-		table := ""
-		for i, line := range lines {
-			text := strings.TrimSpace(line)
-			if m := tomlHeader.FindStringSubmatch(text); m != nil {
-				table = strings.TrimSpace(m[1])
-
-				continue
-			}
-			if text == "" || strings.HasPrefix(text, "#") {
-				continue
-			}
-			m := tomlKey.FindStringSubmatch(text)
-			if m == nil {
-				continue
-			}
-			key, value := strings.Trim(m[1], `"`), strings.TrimSpace(m[2])
-
-			switch {
-			case table == r.table:
-				// `name = ...` in the tasks table itself.
-				cmd := catalog.Command{Runner: r.runner, Name: key, Run: r.run + key, Source: at(file, i+1)}
-				cmd.Body, cmd.Doc = tomlTask(value)
-				upsert(cmd)
-			case strings.HasPrefix(table, r.table+"."):
-				// `[tool.poe.tasks.name]` and its fields.
-				name := strings.Trim(strings.TrimPrefix(table, r.table+"."), `"`)
-				cmd := catalog.Command{Runner: r.runner, Name: name, Run: r.run + name}
-				if _, known := byName[name]; !known {
-					cmd.Source = at(file, i+1)
-					for j := i - 1; j >= 0; j-- {
-						if tomlHeader.MatchString(strings.TrimSpace(lines[j])) {
-							cmd.Source = at(file, j+1)
-
-							break
-						}
-					}
-				}
-				switch key {
-				case "cmd", "script", "shell", "call", "expr", "ref":
-					cmd.Body = tomlScalar(value)
-				case "sequence", "composite":
-					cmd.Body = strings.Join(tomlList(value), "\n")
-				case "help":
-					cmd.Doc = tomlScalar(value)
-				}
-				upsert(cmd)
-			}
-		}
-		out = append(out, cmds...)
-	}
-
-	return hooks(filterTypeable(out), "pre_", "post_")
-}
-
-func filterTypeable(cmds []catalog.Command) []catalog.Command {
-	kept := cmds[:0]
-	for _, cmd := range cmds {
-		if typeable(cmd.Name) {
-			kept = append(kept, cmd)
-		}
-	}
-
-	return kept
-}
-
-// tomlTask reads the value of a task entry: a string, a list, or an inline
-// table with a cmd and a help.
-func tomlTask(value string) (body, doc string) {
-	switch {
-	case strings.HasPrefix(value, "{"):
-		for _, m := range tomlInlineField.FindAllStringSubmatch(value, -1) {
-			field := m[1]
-			text := unescape(m[2] + m[3])
-			switch field {
-			case "cmd", "script", "shell", "call", "expr", "ref":
-				body = text
-			case "sequence", "composite":
-				body = strings.Join(tomlList("["+m[4]+"]"), "\n")
-			case "help":
-				doc = text
-			}
-		}
-
-		return body, doc
-	case strings.HasPrefix(value, "["):
-		return strings.Join(tomlList(value), " "), ""
-	}
-
-	return tomlScalar(value), ""
-}
-
-func tomlScalar(value string) string {
-	if m := tomlString.FindStringSubmatch(value); m != nil {
-		return unescape(m[1] + m[2])
-	}
-	if strings.HasPrefix(value, `"""`) {
-		return strings.TrimSpace(strings.Trim(value, `"`))
-	}
-
-	return strings.TrimSpace(value)
-}
-
-func tomlList(value string) []string {
-	inner := strings.TrimSuffix(strings.TrimPrefix(strings.TrimSpace(value), "["), "]")
-	var items []string
-	for _, m := range regexp.MustCompile(`"((?:[^"\\]|\\.)*)"|'([^']*)'`).FindAllStringSubmatch(inner, -1) {
-		items = append(items, unescape(m[1]+m[2]))
-	}
-
-	return items
-}
-
-func unescape(s string) string {
-	return strings.NewReplacer(`\"`, `"`, `\\`, `\`, `\n`, "\n", `\t`, "\t").Replace(s)
-}

package/internal/commands/taskfile.go

@@ -1,101 +0,0 @@
-package commands
-
-import (
-	"strings"
-
-	"gopkg.in/yaml.v3"
-
-	"github.com/shortlink-org/portolan/catalog"
-)
-
-// readTaskfile lists the tasks of a Taskfile, in the order the file lists
-// them. A task marked `internal` is not one `task --list` offers and is not
-// one here. `desc` is the doc, and `summary` stands in when there is no desc.
-// The cmds are the body; a cmd that calls another task is written as the
-// runner would show it.
-func readTaskfile(file, src string) ([]catalog.Command, []string) {
-	var doc yaml.Node
-	if err := yaml.Unmarshal([]byte(src), &doc); err != nil {
-		return nil, []string{file + ": not YAML, so no tasks were read: " + err.Error()}
-	}
-	root := doc.Content
-	if len(root) == 0 || root[0].Kind != yaml.MappingNode {
-		return nil, nil
-	}
-	tasks := mappingValue(root[0], "tasks")
-	if tasks == nil || tasks.Kind != yaml.MappingNode {
-		return nil, nil
-	}
-
-	var out []catalog.Command
-	for i := 0; i+1 < len(tasks.Content); i += 2 {
-		key, value := tasks.Content[i], tasks.Content[i+1]
-		name := key.Value
-		if !typeable(name) {
-			continue
-		}
-		cmd := catalog.Command{
-			Runner: "task",
-			Name:   name,
-			Run:    "task " + name,
-			Source: at(file, key.Line),
-		}
-		switch value.Kind {
-		case yaml.ScalarNode:
-			cmd.Body = value.Value
-		case yaml.SequenceNode:
-			cmd.Body = strings.Join(cmdLines(value), "\n")
-		case yaml.MappingNode:
-			if internal := mappingValue(value, "internal"); internal != nil && internal.Value == "true" {
-				continue
-			}
-			if desc := mappingValue(value, "desc"); desc != nil {
-				cmd.Doc = strings.TrimSpace(desc.Value)
-			} else if summary := mappingValue(value, "summary"); summary != nil {
-				cmd.Doc = strings.TrimSpace(summary.Value)
-			}
-			if cmds := mappingValue(value, "cmds"); cmds != nil {
-				cmd.Body = strings.Join(cmdLines(cmds), "\n")
-			} else if single := mappingValue(value, "cmd"); single != nil {
-				cmd.Body = single.Value
-			}
-		}
-		out = append(out, cmd)
-	}
-
-	return out, nil
-}
-
-func mappingValue(node *yaml.Node, key string) *yaml.Node {
-	if node == nil || node.Kind != yaml.MappingNode {
-		return nil
-	}
-	for i := 0; i+1 < len(node.Content); i += 2 {
-		if node.Content[i].Value == key {
-			return node.Content[i+1]
-		}
-	}
-
-	return nil
-}
-
-func cmdLines(node *yaml.Node) []string {
-	var lines []string
-	if node.Kind == yaml.ScalarNode {
-		return []string{strings.TrimSpace(node.Value)}
-	}
-	for _, item := range node.Content {
-		switch item.Kind {
-		case yaml.ScalarNode:
-			lines = append(lines, strings.TrimSpace(item.Value))
-		case yaml.MappingNode:
-			if cmd := mappingValue(item, "cmd"); cmd != nil {
-				lines = append(lines, strings.TrimSpace(cmd.Value))
-			} else if task := mappingValue(item, "task"); task != nil {
-				lines = append(lines, "task "+task.Value)
-			}
-		}
-	}
-
-	return lines
-}

package/internal/commands/testdata/estate/.cargo/config.toml

@@ -1,7 +0,0 @@
-[build]
-rustflags = ["-D", "warnings"]
-
-[alias]
-xtask = "run --package xtask --"
-gen = { cmd = "run --package xtask -- gen" }
-_secret = "test --release"

package/internal/commands/testdata/estate/Makefile

@@ -1,33 +0,0 @@
-# The stubs are generated from the contracts vendored in this tree.
-GRPC := internal/transport/grpc
-BIN ?= bin/pricing
-
-.PHONY: help
-help: ## List the targets
-	@grep -E '^[a-z].*##' $(MAKEFILE_LIST)
-
-.PHONY: gen build
-gen: ## Regenerate the gRPC stubs
-	buf generate $(GRPC)/quote/proto -o $(GRPC)/quote/gen
-	buf generate $(GRPC)/price_list/proto -o $(GRPC)/price_list/gen
-
-# Compiles every package. Nothing is installed.
-build:
-	go build ./...
-
-test lint: build
-	go test ./...
-
-_internal:
-	@true
-
-$(BIN): build
-	cp out $(BIN)
-
-%.pb.go: %.proto
-	protoc $<
-
-ifeq ($(CI),1)
-ci: test
-	@echo done
-endif

package/internal/commands/testdata/estate/Taskfile.yml

@@ -1,21 +0,0 @@
-version: "3"
-
-tasks:
-  default:
-    cmds:
-      - task: build
-  build:
-    desc: Compile the binary
-    cmds:
-      - go build -o bin/svc ./cmd/svc
-  migrate:
-    summary: Apply pending migrations
-    cmd: goose up
-  _shared:
-    cmds:
-      - echo hidden
-  lint:
-    internal: true
-    cmds:
-      - golangci-lint run
-  fmt: gofmt -w .

package/internal/commands/testdata/estate/build.gradle.kts

@@ -1,21 +0,0 @@
-plugins {
-    id("org.springframework.boot") version "4.1.1"
-    application
-}
-
-tasks.register<Exec>("generateProto") {
-    description = "Regenerate the gRPC stubs"
-    commandLine("buf", "generate")
-}
-
-tasks.register("_shared") {
-    doLast { println("hidden") }
-}
-
-val smokeTest by tasks.registering(Test::class) {
-    description = "Run the tests that need the compose stack"
-}
-
-task legacyTask {
-    doLast { println("old syntax") }
-}

package/internal/commands/testdata/estate/justfile

@@ -1,20 +0,0 @@
-set shell := ["bash", "-cu"]
-port := "8080"
-
-alias t := test
-
-# Run the service against the compose stack
-dev:
-    docker compose up -d
-    cargo run
-
-[doc("Run the tests, unit and integration")]
-test *args:
-    cargo test {{args}}
-
-[private]
-release:
-    cargo build --release
-
-_setup:
-    rustup default stable

package/internal/commands/testdata/estate/package.json

@@ -1,13 +0,0 @@
-{
-  "name": "cart",
-  "scripts": {
-    "build": "tsc -p tsconfig.build.json",
-    "prebuild": "rimraf dist",
-    "start": "node dist/main.js",
-    "test": "vitest run",
-    "build:watch": "tsc -w",
-    "generate": "npm run generate:api && npm run generate:auth",
-    "generate:api": "openapi-typescript openapi.yaml -o types.ts"
-  },
-  "dependencies": {}
-}

package/internal/commands/testdata/estate/pom.xml

@@ -1,29 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project>
-  <groupId>org.portolan.payments</groupId>
-  <artifactId>ledger</artifactId>
-  <packaging>jar</packaging>
-  <dependencies>
-    <dependency>
-      <artifactId>flyway-maven-plugin</artifactId>
-    </dependency>
-  </dependencies>
-  <build>
-    <pluginManagement>
-      <plugins>
-        <plugin>
-          <artifactId>jib-maven-plugin</artifactId>
-        </plugin>
-      </plugins>
-    </pluginManagement>
-    <plugins>
-      <plugin>
-        <groupId>org.springframework.boot</groupId>
-        <artifactId>spring-boot-maven-plugin</artifactId>
-      </plugin>
-      <plugin>
-        <artifactId>protobuf-maven-plugin</artifactId>
-      </plugin>
-    </plugins>
-  </build>
-</project>

package/internal/commands/testdata/estate/pyproject.toml

@@ -1,27 +0,0 @@
-[project]
-name = "billing"
-version = "0.1.0"
-
-[project.scripts]
-billing = "billing.cli:main"
-
-[tool.poe.tasks]
-test = "pytest"
-lint = ["ruff", "check", "."]
-serve = { cmd = "python manage.py runserver", help = "Run the dev server" }
-_hidden = "echo no"
-
-[tool.poe.tasks.migrate]
-help = "Apply pending migrations"
-cmd = "python manage.py migrate"
-
-[tool.poe.tasks.check]
-sequence = ["lint", "test"]
-
-[tool.pdm.scripts]
-pre_test = "echo before"
-test = "pytest -x"
-
-[tool.pdm.scripts.worker]
-shell = "celery -A billing worker"
-help = "Run the celery worker"

package/internal/commands/testdata/estate/xtask/src/main.rs

@@ -1,27 +0,0 @@
-use clap::{Parser, Subcommand};
-
-#[derive(Parser)]
-struct Cli {
-    #[command(subcommand)]
-    command: Command,
-}
-
-#[derive(Subcommand)]
-enum Command {
-    /// Regenerate the gRPC stubs from the vendored protos
-    Gen,
-    /// Run fmt, clippy and the tests the way CI does
-    Ci { #[arg(long)] fix: bool },
-    #[command(about = "Build the release artefacts")]
-    Dist(DistArgs),
-}
-
-fn main() {
-    let arg = std::env::args().nth(1);
-    match arg.as_deref() {
-        Some("gen") => gen(),
-        // Run the benchmarks against the compose stack
-        Some("bench") | Some("perf") => bench(),
-        _ => usage(),
-    }
-}