mdview/main.go

package main

import (
	_ "embed"
	"errors"
	"flag"
	"fmt"
	"log"
	"os"
	"os/signal"
	"path"
	"path/filepath"
	"strings"
	"syscall"

	"git.foosoft.net/alex/goldsmith"
	"git.foosoft.net/alex/goldsmith-components/filters/operator"
	"git.foosoft.net/alex/goldsmith-components/filters/wildcard"
	"git.foosoft.net/alex/goldsmith-components/plugins/document"
	"git.foosoft.net/alex/goldsmith-components/plugins/frontmatter"
	"git.foosoft.net/alex/goldsmith-components/plugins/livejs"
	"git.foosoft.net/alex/goldsmith-components/plugins/markdown"
	"github.com/PuerkitoBio/goquery"
	"github.com/fsnotify/fsnotify"
	"github.com/yuin/goldmark"
	"github.com/yuin/goldmark/extension"
	"github.com/yuin/goldmark/parser"
	"github.com/yuin/goldmark/renderer/html"
)

//go:embed css/github-markdown.css
var githubStyle string

//go:embed css/github-fixup.css
var githubFixup string

func watch(dir string, watcher *fsnotify.Watcher) error {
	watcher.Add(dir)

	items, err := os.ReadDir(dir)
	if err != nil {
		return err
	}

	for _, item := range items {
		fullPath := path.Join(dir, item.Name())
		if item.IsDir() {
			watch(fullPath, watcher)
		} else {
			watcher.Add(fullPath)
		}
	}

	return nil
}

func builder(dir string, callback func()) error {
	watcher, err := fsnotify.NewWatcher()
	if err != nil {
		return err
	}

	if err := watch(dir, watcher); err != nil {
		return err
	}

	var terminate bool
	signaler := make(chan os.Signal, 1)
	signal.Notify(
		signaler,
		os.Interrupt,
		syscall.SIGINT,
		syscall.SIGTERM,
	)

	callback()

	for !terminate {
		select {
		case event := <-watcher.Events:
			callback()
			if event.Op&fsnotify.Create == fsnotify.Create {
				if info, _ := os.Stat(event.Name); info != nil {
					if info.IsDir() {
						watch(event.Name, watcher)
					} else {
						watcher.Add(event.Name)
					}
				}
			}
		case <-signaler:
			log.Println("terminating...")
			terminate = true
		}
	}

	return nil
}

func build(sourceDir, targetDir string) {
	log.Println("building...")

	embedCss := func(file *goldsmith.File, doc *goquery.Document) error {
		var styleBuilder strings.Builder
		styleBuilder.WriteString("<style type=\"text/css\">\n")
		styleBuilder.WriteString(githubStyle)
		styleBuilder.WriteString(githubFixup)
		styleBuilder.WriteString("</style>")

		doc.Find("body").AddClass("markdown-body")
		doc.Find("head").SetHtml(styleBuilder.String())

		return nil
	}

	allowedPaths := []string{
		"**/*.gif",
		"**/*.html",
		"**/*.jpeg",
		"**/*.jpg",
		"**/*.md",
		"**/*.png",
		"**/*.svg",
	}

	forbiddenPaths := []string{
		"**/.*/**",
	}

	gm := goldmark.New(
		goldmark.WithExtensions(extension.GFM, extension.Typographer),
		goldmark.WithParserOptions(parser.WithAutoHeadingID()),
		goldmark.WithRendererOptions(html.WithUnsafe()),
	)

	var gs goldsmith.Goldsmith
	errs := gs.Begin(sourceDir).
		Clean(true).
		FilterPush(wildcard.New(allowedPaths...)).
		FilterPush(operator.Not(wildcard.New(forbiddenPaths...))).
		Chain(frontmatter.New()).
		Chain(markdown.NewWithGoldmark(gm)).
		Chain(livejs.New()).
		Chain(document.New(embedCss)).
		End(targetDir)

	for _, err := range errs {
		log.Println(err)
	}
}

func run(path string) error {
	switch strings.ToLower(filepath.Ext(path)) {
	case ".md", ".markdown":
		break
	default:
		return errors.New("unexpected file type")
	}

	if info, err := os.Stat(path); err != nil {
		return err
	} else if info.IsDir() {
		return errors.New("unexpected directory")
	}

	targetDir, err := os.MkdirTemp("", "mdv-*")
	if err != nil {
		return err
	}
	defer os.RemoveAll(targetDir)

	sourceDir := filepath.Dir(path)
	builder(sourceDir, func() {
		build(sourceDir, targetDir)
	})

	// if !self.open {
	// 	url := fmt.Sprintf("http://127.0.0.1:%d/%s", self.port, self.path)
	// 	log.Printf("opening %s in browser...", url)
	// 	webbrowser.Open(url)
	// 	self.open = true
	// }

	return nil
}

func main() {
	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "Usage %s [options] <path>\n\n", filepath.Base(os.Args[0]))
		fmt.Fprintln(os.Stderr, "Parameters:")
		flag.PrintDefaults()
	}

	flag.Parse()

	if flag.NArg() != 1 {
		flag.Usage()
		os.Exit(2)
	}

	if err := run(flag.Arg(0)); err != nil {
		log.Fatal(err)
	}

}