patchwork

// Command patchwork publishes revision feeds for living pages.
package main

import (
	"context"
	"errors"
	"flag"
	"fmt"
	"io"
	"log/slog"
	"os"
	"os/signal"

	"git.pablomurad.com/pablo/patchwork/internal/config"
	"git.pablomurad.com/pablo/patchwork/internal/engine"
	"git.pablomurad.com/pablo/patchwork/internal/source/folder"
	"git.pablomurad.com/pablo/patchwork/internal/store"
)

// version is set at build time with -ldflags "-X main.version=...".
var version = "dev"

const usage = `patchwork publishes revision feeds for living pages.

Usage:
  patchwork <command> [flags]

Commands:
  init      write a commented patchwork.yaml
  scan      scan the content folder once and apply the publish rules
  watch     keep scanning as files change
  log       show a page's public history
  diff      show what changed in a revision
  doctor    check the config, the content and the database
  version   print the version

Every command except init and version reads patchwork.yaml from the
current directory, or the file named by --config or PATCHWORK_CONFIG.
Run "patchwork <command> -h" for a command's flags.
`

func main() {
	if len(os.Args) < 2 {
		fmt.Fprint(os.Stderr, usage)
		os.Exit(2)
	}
	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
	defer stop()

	cmd, args := os.Args[1], os.Args[2:]
	var err error
	switch cmd {
	case "init":
		err = cmdInit(args)
	case "scan":
		err = cmdScan(ctx, args)
	case "watch":
		err = cmdWatch(ctx, args)
	case "log":
		err = cmdLog(ctx, args)
	case "diff":
		err = cmdDiff(ctx, args)
	case "doctor":
		err = cmdDoctor(ctx, args)
	case "version", "-v", "--version":
		fmt.Println("patchwork", version)
	case "help", "-h", "--help":
		fmt.Print(usage)
	default:
		fmt.Fprintf(os.Stderr, "patchwork: unknown command %q\n\n%s", cmd, usage)
		os.Exit(2)
	}
	if err != nil {
		if errors.Is(err, flag.ErrHelp) {
			os.Exit(2)
		}
		if errors.Is(err, errProblems) {
			os.Exit(1)
		}
		fmt.Fprintln(os.Stderr, "patchwork:", err)
		os.Exit(1)
	}
}

// errProblems makes a command exit 1 after it has printed its own report.
var errProblems = errors.New("problems found")

func newFlags(name, args string) *flag.FlagSet {
	fs := flag.NewFlagSet(name, flag.ContinueOnError)
	fs.Usage = func() {
		fmt.Fprintf(fs.Output(), "Usage: patchwork %s %s\n", name, args)
		fs.PrintDefaults()
	}
	return fs
}

func configFlag(fs *flag.FlagSet) *string {
	def := os.Getenv("PATCHWORK_CONFIG")
	if def == "" {
		def = "patchwork.yaml"
	}
	return fs.String("config", def, "path to patchwork.yaml")
}

// app is what most commands need: config, store and engine.
type app struct {
	cfg    *config.Config
	store  *store.Store
	engine *engine.Engine
	log    *slog.Logger
}

func openApp(configPath string) (*app, error) {
	cfg, err := config.Load(configPath)
	if err != nil {
		return nil, err
	}
	st, err := store.Open(cfg.DB)
	if err != nil {
		return nil, err
	}
	e, err := engine.New(st, cfg)
	if err != nil {
		st.Close()
		return nil, err
	}
	return &app{cfg: cfg, store: st, engine: e, log: slog.New(slog.NewTextHandler(os.Stderr, nil))}, nil
}

func (a *app) Close() error { return a.store.Close() }

func (a *app) runner() *folder.Runner {
	m := folder.Matcher{Include: a.cfg.Source.Include, Exclude: a.cfg.Source.Exclude}
	return folder.NewRunner(a.cfg.Source.Path, m, a.engine, a.log)
}

func cmdInit(args []string) error {
	fs := newFlags("init", "[-o patchwork.yaml] [-force]")
	out := fs.String("o", "patchwork.yaml", "file to write")
	force := fs.Bool("force", false, "overwrite an existing file")
	if err := fs.Parse(args); err != nil {
		return err
	}
	if _, err := os.Stat(*out); err == nil && !*force {
		return fmt.Errorf("%s already exists (use -force to overwrite)", *out)
	}
	if err := os.WriteFile(*out, config.Example, 0o644); err != nil {
		return err
	}
	fmt.Printf("wrote %s; set site.base_url and source.path, then run: patchwork doctor\n", *out)
	return nil
}

var stdout io.Writer = os.Stdout