path: root/vienna

#!/bin/sh
# vienna --- a tiny, tasty ssg
# by C. Duckworth <acdw@acdw.net>
# shellcheck disable=1090,2035

### Entry point

usage() {
	cat <<EOF
VIENNA: a tiny, tasty ssg
by C. Duckworth <acdw@acdw.net>

USAGE: vienna [-h]
       vienna [-C DIR] [-d DOMAIN] [-o DIR] [COMMAND]

FLAGS:
 -h         view this help

OPTIONS:
 -C DIR     operate in DIR, instead of \$PWD.
 -d DOMAIN  use DOMAIN as basis for urls. default: example.com
 -o DIR     output built site to DIR. default: ./out

PARAMETERS:
 clean      remove output directory before building
 publish    publish the site after building.
            NOTE: this requires a .vienna.sh file in the site root.
            you'll have to define a \`publish' function there.
 preview    preview the site locally after building.
            NOTE: this requires a .vienna.sh file in the site root.
            you'll have to define a \`preview' function there.

you can redefine any variables or functions vienna uses in \$VIENNA_CONFIG,
which by default is ./.vienna.sh.  vienna uses heredoc-inspired templating, so
you can include shell snippets and variables by doubling the dollar signs.

EOF
	exit "${1:-0}"
}

configure() {
	## Set up environment
	DOMAIN="${VIENNA_DOMAIN:-https://www.example.com}"
	TMPD="${VIENNA_TMPD:-/tmp/vienna}"
	WORKD="${VIENNA_WORKD:-$PWD}"
	OUTD="${VIENNA_OUTD:-out}"
	CONFIG="${VIENNA_CONFIG:-./.vienna.sh}"
	# Templates
	PAGE_TEMPLATE="${VIENNA_PAGE_TEMPLATE:-.page.tmpl.html}"
	INDEX_TEMPLATE="${VIENNA_INDEX_TEMPLATE:-.index.tmpl.html}"
	FEED_TEMPLATE="${VIENNA_FEED_TEMPLATE:-.feed.tmpl.xml}"
	# File extensions
	PAGE_RAW_EXT="${VIENNA_PAGE_RAW_EXT:-htm}"
	# Logging
	LOG=true
	## Parse command line arguments
	while getopts d:C:o:hq opt; do
		case "$opt" in
		d) DOMAIN="$OPTARG" ;;
		C) WORKD="$OPTARG" ;;
		o) OUTD="$OPTARG" ;;
		h) usage 0 ;;
		q) LOG=false ;;
		*) exit 1 ;;
		esac
	done
	## Log configuration variables
	log config "domain: $DOMAIN"
	log config "workdir: $WORKD"
	log config "output: $OUTD"
	## Initialize state
	FILE=
	## Cleanup after we're done
	trap cleanup INT QUIT
}

main() {
	# State predicates
	alias pagep=false indexp=false feedp=false
	# Convenience aliases
	alias body=cat title='meta title' pubdate='meta date'
	# Configure
	configure "$@"
	shift "$((OPTIND - 1))"
	# Further argument processing --- pre-build
	case "${1:-ok}" in
	ok) ;;
	clean)
		log vienna "clean"
		rm -r "$OUTD"
		exit
		;;
	esac
	# Prepare
	cd "$WORKD" || exit 2
	mkdir -p "$OUTD" || exit 2
	mkdir -p "$TMPD" || exit 2
	# Build pages
	alias pagep=true
	build *."$PAGE_RAW_EXT" || exit 2
	alias pagep=false
	# Build index
	alias indexp=true
	index *."$PAGE_RAW_EXT" || exit 2
	alias indexp=false
	# Build feed
	alias feedp=true
	feed *."$PAGE_RAW_EXT" || exit 2
	alias feedp=false
	# Copy static files
	static * || exit 2
	# Further argument processing --- post-build
	case "${1:-ok}" in
	ok) ;;
	publish)
		log vienna "publish"
		publish "$OUTD"
		;;
	preview)
		log vienna "preview"
		preview "$OUTD"
		;;
	*)
		log vienna "Don't know command \`$1'."
		exit 1
		;;
	esac
}

cleanup() {
	test -z "$DEBUG" &&
		test -z "$NODEP_RM" &&
		rm -r "$TMPD"
}

publish() {
	cat <<EOF >&2

I want to publish your website but I don't know how.
Make a $CONFIG file in this directory and write a \`publish'
function telling me what to do.  I recommend using \`rsync',
but you live your life."

EOF
	exit 3
}

preview() {
	cat <<EOF >&2

I want to show you a preview of your website but I don't
know how.  Make a $CONFIG file in this directory and write
a \`preview' function telling me what to do.  I recommend
using something like \`python -m http.server', but you live
your life."

EOF
	exit 3
}

### Utility

log() {
	if "$LOG"; then
		t="$1"
		shift
		echo >&2 "[$t]" "$@"
	fi
}

### File processing

## Building block functions

shellfix() { # shellfix FILE...
	## Replace ` with \`, $ with \$, and $$ with $
	# shellcheck disable=2016
	sed -E \
		-e 's/`/\\`/g' \
		-e 's/(^|[^\$])\$([^\$]|$)/\1\\$\2/g' \
		-e 's/\$\$/$/g' \
		"$@"
}

expand() { # expand TEMPLATE... < INPUT
	## Print TEMPLATE to stdout, expanding shell constructs.
	end="expand_:_${count:=0}_:_end"
	eval "$(
		echo "cat<<$end"
		shellfix "$@"
		echo
		echo "$end"
	)" && count=$((count + 1))
}

phtml() { # phtml < INPUT
	## Output HTML, pretty much.
	# Paragraphs unadorned with html tags will be wrapped in <p> tags, and
	# &, <, > will be escaped unless prepended with \.  Paragraphs where the
	# first character is < will be left as-is, excepting indentation on the
	# first line (an implementation detail).
	sed -E \
		'/./{H;1h;$!d;}; x;
		s#^[ \n\t]+[^<].*#&#;
		t par; b;
		:par;
			s#([^\\])&#\1\&amp;#g; s#\\&#\&#g;
			s#([^\\])<#\1\&lt;#g; s#\\<#<#g;
			s#([^\\])>#\1\&gt;#g; s#\\>#>#g;'
}

meta() { # meta FIELD [FILE] < INPUT
	## Extract metadata FIELDS from INPUT.
	# FILE gives the filename to save metadata to in the $WORKD.  It
	# defaults to the current value for $FILE.
	#
	# Metadata should exist as colon-separated data in an HTML comment at
	# the beginning of an input file.
	field="$1"
	file="${2:-$FILE}"
	metafile="$TMPD/${file}.meta"
	test -f "$metafile" ||
		sed '/<!--/n;/-->/q' >"$metafile"
	sed -n "s/^[ \t]*$field:[ \t]*//p" <"$metafile"
}

## Customizable bits

filters() { # filters < INPUT
	## The filters to run input through.
	# This is a good candidate for customization in .vienna.sh.
	expand | phtml
}

### Site building

build() { # build PAGE...
	## Compile PAGE(s) into $OUTD for publication.
	# Outputs a file of the format $OUTD/<PAGE>/index.html.
	test -f "$PAGE_TEMPLATE" || return 1
	for FILE; do
		log build "$FILE"
		outd="$OUTD/${FILE%.$PAGE_RAW_EXT}"
		outf="$outd/index.html"
		tmpf="$TMPD/$FILE.tmp"
		mkdir -p "$outd"
		filters <"$FILE" >"$tmpf"
		expand "$PAGE_TEMPLATE" <"$tmpf" >"$outf"
	done
}

index() { # index PAGE...
	## Build a site index from all PAGE(s) passed to it.
	# Wraps each PAGE in a <li><a> structure.
	test -f "$INDEX_TEMPLATE" || return 1
	for FILE; do
		log index "$FILE"
		link="$DOMAIN${DOMAIN:+/}${FILE%.$PAGE_RAW_EXT}"
		echo "<li><a href=\"$link\">$(meta title "$FILE")</a></li>"
	done | expand "$INDEX_TEMPLATE" >"$OUTD/index.html"
}

feed() { # feed PAGE...
	## Build an RSS 2.0 feed from PAGE(s).
	test -f "$FEED_TEMPLATE" || return 1
	for FILE; do
		log feed "$FILE"
		link="$DOMAIN${DOMAIN:+/}${FILE%.$PAGE_RAW_EXT}"
		date="$(meta pubdate "$FILE")"
		echo "<item>"
		echo "<title>$(meta title "$FILE")</title>"
		echo "<link>$link</link>"
		echo "<guid>$link</guid>"
		test -n "$date" && echo "<pubDate>$date</pubDate>"
		echo "</item>"
	done | expand "$FEED_TEMPLATE" >"$OUTD/feed.xml"
}

static() { # static FILE...
	## Copy static FILE(s) to $OUTD as-is.
	# Performs a simple heuristic to determine whether to copy a file or
	# not.
	for FILE; do
		case "$FILE" in
		.*) continue ;;
		*.htm) continue ;;
		"$OUTD") continue ;;
		*) cp -r "$FILE" "$OUTD/" ;;
		esac
	done
}

### Do the thing!

test -n "$DEBUG" && set -x
test -n "$SOURCE" || main "$@"