319 lines
9.7 KiB
Go
319 lines
9.7 KiB
Go
// SPDX-License-Identifier: AGPL-3.0-only
|
|
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"flag"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"os/signal"
|
|
"path/filepath"
|
|
"runtime"
|
|
"strings"
|
|
"syscall"
|
|
|
|
"gamertan.com/sandwich-hime/internal/compiler"
|
|
"gamertan.com/sandwich-hime/internal/devserver"
|
|
"gamertan.com/sandwich-hime/internal/version"
|
|
)
|
|
|
|
func main() {
|
|
os.Exit(run(context.Background(), os.Args[1:], os.Stdout, os.Stderr))
|
|
}
|
|
|
|
func run(ctx context.Context, args []string, stdout, stderr io.Writer) int {
|
|
if len(args) == 0 {
|
|
printHelp(stdout)
|
|
return 0
|
|
}
|
|
|
|
switch args[0] {
|
|
case "generate", "gen":
|
|
return runCompilerCommand(ctx, "generate", args[1:], stdout, stderr, compiler.Generate)
|
|
case "check", "bless":
|
|
return runCompilerCommand(ctx, args[0], args[1:], stdout, stderr, compiler.Check)
|
|
case "dev":
|
|
return runDev(ctx, args[1:], stdout, stderr)
|
|
case "version":
|
|
return runVersion(args[1:], stdout, stderr)
|
|
case "help", "-h", "--help":
|
|
printHelp(stdout)
|
|
return 0
|
|
default:
|
|
fmt.Fprintf(stderr, "himesan: unknown command %q\n\n", args[0])
|
|
printHelp(stderr)
|
|
return 2
|
|
}
|
|
}
|
|
|
|
type compilerOperation func(context.Context, []string) (compiler.Result, error)
|
|
|
|
func runCompilerCommand(ctx context.Context, command string, args []string, stdout, stderr io.Writer, operation compilerOperation) int {
|
|
flags := flag.NewFlagSet(command, flag.ContinueOnError)
|
|
flags.SetOutput(stderr)
|
|
jsonOutput := flags.Bool("json", false, "emit one machine-readable JSON result")
|
|
if err := flags.Parse(args); err != nil {
|
|
if errors.Is(err, flag.ErrHelp) {
|
|
return 0
|
|
}
|
|
return 2
|
|
}
|
|
|
|
result, operationErr := operation(ctx, flags.Args())
|
|
if *jsonOutput {
|
|
payload := struct {
|
|
Command string `json:"command"`
|
|
OK bool `json:"ok"`
|
|
Result compiler.Result `json:"result"`
|
|
}{Command: command, OK: operationErr == nil, Result: result}
|
|
encoder := json.NewEncoder(stdout)
|
|
encoder.SetEscapeHTML(false)
|
|
if err := encoder.Encode(payload); err != nil {
|
|
fmt.Fprintf(stderr, "himesan: encode JSON result: %v\n", err)
|
|
return 2
|
|
}
|
|
} else {
|
|
printDiagnostics(stderr, result.Diagnostics)
|
|
if operationErr == nil {
|
|
switch command {
|
|
case "generate":
|
|
fmt.Fprintf(stdout, "generated %d, unchanged %d (%d .sando files)\n", result.Changed, result.Unchanged, result.Discovered)
|
|
case "bless":
|
|
fmt.Fprintf(stdout, "blessed: generated output is current and valid (%d files checked, no writes)\n", result.Discovered)
|
|
default:
|
|
fmt.Fprintf(stdout, "checked %d .sando files: %d current\n", result.Discovered, result.Unchanged)
|
|
}
|
|
}
|
|
}
|
|
if operationErr != nil {
|
|
return 1
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func printDiagnostics(output io.Writer, diagnostics []compiler.Diagnostic) {
|
|
for _, item := range diagnostics {
|
|
fmt.Fprintf(output, "%s: %s\n", item.Severity, item.Error())
|
|
}
|
|
}
|
|
|
|
func runVersion(args []string, stdout, stderr io.Writer) int {
|
|
flags := flag.NewFlagSet("version", flag.ContinueOnError)
|
|
flags.SetOutput(stderr)
|
|
jsonOutput := flags.Bool("json", false, "emit machine-readable version information")
|
|
if err := flags.Parse(args); err != nil {
|
|
if errors.Is(err, flag.ErrHelp) {
|
|
return 0
|
|
}
|
|
return 2
|
|
}
|
|
if flags.NArg() != 0 {
|
|
fmt.Fprintln(stderr, "himesan version does not accept positional arguments")
|
|
return 2
|
|
}
|
|
information := struct {
|
|
Compiler string `json:"compiler"`
|
|
RuntimeABI string `json:"runtime_abi"`
|
|
Go string `json:"go"`
|
|
}{Compiler: version.Compiler, RuntimeABI: version.RuntimeABI, Go: runtime.Version()}
|
|
if *jsonOutput {
|
|
if err := json.NewEncoder(stdout).Encode(information); err != nil {
|
|
fmt.Fprintf(stderr, "himesan: encode version: %v\n", err)
|
|
return 2
|
|
}
|
|
return 0
|
|
}
|
|
fmt.Fprintf(stdout, "himesan %s (runtime ABI %s, %s)\n", information.Compiler, information.RuntimeABI, information.Go)
|
|
return 0
|
|
}
|
|
|
|
type stringList []string
|
|
|
|
func (values *stringList) String() string { return strings.Join(*values, ",") }
|
|
func (values *stringList) Set(value string) error {
|
|
if strings.TrimSpace(value) == "" {
|
|
return errors.New("value must not be empty")
|
|
}
|
|
*values = append(*values, value)
|
|
return nil
|
|
}
|
|
|
|
func runDev(parent context.Context, args []string, stdout, stderr io.Writer) int {
|
|
commandArgs, appArgs := splitAppArgs(args)
|
|
flags := flag.NewFlagSet("dev", flag.ContinueOnError)
|
|
flags.SetOutput(stderr)
|
|
configPath := flags.String("config", "", "himesan.json path (defaults to ./himesan.json when present)")
|
|
proxyAddress := flags.String("proxy", "", "stable loopback proxy address")
|
|
listenEnvironment := flags.String("listen-env", "", "environment variable used to pass the random upstream address")
|
|
healthPath := flags.String("health", "", "candidate health-check path")
|
|
var sourceRoots stringList
|
|
var watchRoots stringList
|
|
flags.Var(&sourceRoots, "source", "source root to generate and watch (repeatable)")
|
|
flags.Var(&watchRoots, "watch", "additional asset root to watch (repeatable)")
|
|
if err := flags.Parse(commandArgs); err != nil {
|
|
if errors.Is(err, flag.ErrHelp) {
|
|
return 0
|
|
}
|
|
return 2
|
|
}
|
|
if flags.NArg() > 1 {
|
|
fmt.Fprintln(stderr, "himesan dev accepts at most one Go package before --")
|
|
return 2
|
|
}
|
|
|
|
rootDir, config, err := loadDevelopmentConfig(*configPath)
|
|
if err != nil {
|
|
fmt.Fprintf(stderr, "himesan dev: %v\n", err)
|
|
return 1
|
|
}
|
|
if flags.NArg() == 1 {
|
|
config.GoPackage = flags.Arg(0)
|
|
}
|
|
if len(sourceRoots) != 0 {
|
|
config.SourceRoots = append([]string(nil), sourceRoots...)
|
|
}
|
|
if len(watchRoots) != 0 {
|
|
config.AdditionalWatchRoots = append([]string(nil), watchRoots...)
|
|
}
|
|
if *proxyAddress != "" {
|
|
config.ProxyAddress = *proxyAddress
|
|
}
|
|
if *listenEnvironment != "" {
|
|
config.ListenAddressEnv = *listenEnvironment
|
|
}
|
|
if *healthPath != "" {
|
|
config.HealthPath = *healthPath
|
|
}
|
|
if appArgs != nil {
|
|
config.AppArgs = append([]string(nil), appArgs...)
|
|
}
|
|
if err := config.Validate(); err != nil {
|
|
fmt.Fprintf(stderr, "himesan dev: %v\n", err)
|
|
return 2
|
|
}
|
|
|
|
resolvedSources := resolvePaths(rootDir, config.SourceRoots)
|
|
generate := func(ctx context.Context) error {
|
|
result, generateErr := compiler.Generate(ctx, resolvedSources)
|
|
for _, item := range result.Diagnostics {
|
|
if item.Severity == compiler.SeverityWarning {
|
|
fmt.Fprintf(stderr, "warning: %s\n", item.Error())
|
|
}
|
|
}
|
|
return generateErr
|
|
}
|
|
|
|
supervisor, err := devserver.New(devserver.Options{
|
|
RootDir: rootDir,
|
|
Config: config,
|
|
Generate: generate,
|
|
MapDiagnostics: mapDevelopmentDiagnostics,
|
|
OnEvent: func(event devserver.Event) {
|
|
switch event.Type {
|
|
case "ready":
|
|
fmt.Fprintf(stdout, "himesan dev: %s\n", event.Message)
|
|
case "reload":
|
|
fmt.Fprintln(stdout, "himesan dev: healthy candidate activated")
|
|
case "diagnostic":
|
|
fmt.Fprintf(stderr, "himesan dev [%s]: %s\n", event.Phase, event.Message)
|
|
}
|
|
},
|
|
Output: stdout,
|
|
ErrorOutput: stderr,
|
|
})
|
|
if err != nil {
|
|
fmt.Fprintf(stderr, "himesan dev: %v\n", err)
|
|
return 1
|
|
}
|
|
|
|
ctx, stop := signal.NotifyContext(parent, os.Interrupt, syscall.SIGTERM)
|
|
defer stop()
|
|
if err := supervisor.Run(ctx); err != nil {
|
|
fmt.Fprintf(stderr, "himesan dev: %v\n", err)
|
|
return 1
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func splitAppArgs(args []string) ([]string, []string) {
|
|
for index, value := range args {
|
|
if value == "--" {
|
|
return args[:index], args[index+1:]
|
|
}
|
|
}
|
|
return args, nil
|
|
}
|
|
|
|
func loadDevelopmentConfig(requested string) (string, devserver.Config, error) {
|
|
workingDirectory, err := os.Getwd()
|
|
if err != nil {
|
|
return "", devserver.Config{}, fmt.Errorf("get working directory: %w", err)
|
|
}
|
|
path := requested
|
|
if path == "" {
|
|
candidate := filepath.Join(workingDirectory, "himesan.json")
|
|
if _, statErr := os.Stat(candidate); statErr == nil {
|
|
path = candidate
|
|
} else if !os.IsNotExist(statErr) {
|
|
return "", devserver.Config{}, fmt.Errorf("inspect himesan.json: %w", statErr)
|
|
}
|
|
}
|
|
if path == "" {
|
|
return workingDirectory, devserver.DefaultConfig(), nil
|
|
}
|
|
absolute, err := filepath.Abs(path)
|
|
if err != nil {
|
|
return "", devserver.Config{}, fmt.Errorf("resolve config: %w", err)
|
|
}
|
|
config, err := devserver.LoadConfig(absolute)
|
|
if err != nil {
|
|
return "", devserver.Config{}, err
|
|
}
|
|
return filepath.Dir(absolute), config, nil
|
|
}
|
|
|
|
func resolvePaths(root string, paths []string) []string {
|
|
resolved := make([]string, 0, len(paths))
|
|
for _, path := range paths {
|
|
if filepath.IsAbs(path) {
|
|
resolved = append(resolved, filepath.Clean(path))
|
|
} else {
|
|
resolved = append(resolved, filepath.Join(root, filepath.Clean(path)))
|
|
}
|
|
}
|
|
return resolved
|
|
}
|
|
|
|
func mapDevelopmentDiagnostics(err error) []devserver.Diagnostic {
|
|
var diagnosticsError *compiler.DiagnosticsError
|
|
if !errors.As(err, &diagnosticsError) {
|
|
return nil
|
|
}
|
|
result := make([]devserver.Diagnostic, 0, len(diagnosticsError.Diagnostics))
|
|
for _, item := range diagnosticsError.Diagnostics {
|
|
result = append(result, devserver.Diagnostic{
|
|
Path: item.Path, Line: item.Line, Column: item.Column,
|
|
Code: item.Code, Message: item.Message, Severity: string(item.Severity),
|
|
})
|
|
}
|
|
return result
|
|
}
|
|
|
|
func printHelp(output io.Writer) {
|
|
fmt.Fprintln(output, "Sandwich Hime / Hime-san — HTML-first typed components for Go")
|
|
fmt.Fprintln(output)
|
|
fmt.Fprintln(output, "Usage:")
|
|
fmt.Fprintln(output, " himesan generate [--json] [paths...] generate adjacent .sando.go files")
|
|
fmt.Fprintln(output, " himesan gen [--json] [paths...] alias for generate")
|
|
fmt.Fprintln(output, " himesan check [--json] [paths...] validate sources and committed output without writes")
|
|
fmt.Fprintln(output, " himesan bless [--json] [paths...] friendly read-only alias for check")
|
|
fmt.Fprintln(output, " himesan dev [flags] [package] [-- app-args...] run the loopback last-good supervisor")
|
|
fmt.Fprintln(output, " himesan version [--json] print compiler and runtime ABI versions")
|
|
fmt.Fprintln(output)
|
|
fmt.Fprintln(output, "Templates use .sando; .san remains exclusively San language source.")
|
|
}
|