#!/usr/bin/gawk -f
#
# pak-web-site -- 2008-08-17, last edit 2008-09-20
#
# script to convert shtml web pages to static version with optional
#  compression
#
# Copyright (C) 2008 Grant Coady <http://bugsplatter.id.au/> GPLv2
#
# Home site: http://bugsplatter.id.au/pakweb/
#
#-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# merge ssi files / values
# `````````````````````````
# SSI (Server Side Include) directives to be replaced by their source 
#  are discovered at runtime.
#
# SSI directives to be replaced by value:
#  <!--#echo var="REQUEST_URI" -->
#
# special action:
# panel.html's menu list requires special action to replace the SSI 
#  conditional directives that control the CSS menu highlighting marker
#
# 1. when reading panel.html, strip the conditionals, leaving the <li> 
#    tag as the usual option
#
# 2. when rewriting html pages, check for the menu highlight select:
#    <!--#set var="menu" value="???" and store the $menu value as flag
#
# 3. while replacing panel.html text, if the target page's $menu value 
#    matches menu item, replace the match <li> with <li class=here>
#
#-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# compress files
# ```````````````
# when to compress files
# 
# html file may be compressed if:
#
# a) it is marked +x and contains no unrecognised ssi directives
#
# b) it is not marked +x
#
#-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# call:
#  pak-web-site -v gzrate=1 -v ssi_list="$(pak-web-scan)" \
#		$(find . -name "*.html" -type f | sort)
#
# call via pak-web wrapper script (recommended):
#	pak-web
#	pak-web usedir $some_dir_below_web_doc_root
#
# Note: this web site uses 'XBitHack Full' option for SSI files, thus the 
#  active SSI web files do not have the *.shtml extension.
#
BEGIN {
	print "\npak-web-site: make web pages static and gzip\n"
	webroot = "/home/web/bugsplatter"

	# automatic ssi include files discovery, see pak-web-scan script 
	#  that supplies the ssi_list, a colon separated pathname list 
	#  with semi-colon field split to path and ssi include directive
	ssi_count = split(ssi_list, a, ":")

	for (i = 1; i <= ssi_count; i++) {
		split(a[i], aa, ";")
		ssi_filename[i] = aa[1]
		ssi_file_ndx[ssi_filename[i]] = i
		ssi_incl_ndx[aa[2]] = i
	}

	# insert source files before target files, after command line parms
	i = 1; while (i < ARGC && ARGV[i] ~ /=/) { ++i }
	if (i < ARGC) {
		for (j = ARGC; j >= i; j--) {
			ARGV[j + ssi_count] = ARGV[j]	# make room
		}
		for (j = 1; j <= ssi_count; j++) {
			ARGV[i++] = ssi_filename[j]; ++ARGC # insert SSI files
		}
	}
	else {
		print "  usage:\n" \
			"    merge SSI files and compress:\n" \
			"      cd $web_doc_root\n" \
			"      pak-web-site $(find . -name \"*.html\"" \
			" -type f | sort)\n"
		++exitflag; exit
	}
	total_file_size = 0; total_gzip_size = 0

	# server ID, adjust to match your apache version
	signew = "\n<address>Apache/1.3.41 Server at bugsplatter.id.au " \
			"Port 80</address>\n"

	printf "%-60s %12s\n", "load SSI files into memory:", "size"
}
#-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# for pages found under the main menu, convert the footer filepath to 
#  have active links back to parent directories
#
function footlink_index(f,   a, i, n, s) {
	# for {index,README}.html link parent, perhaps grandparent
	n = split(f, a, "/"); s = ""
	for (i = 2; i <= n; i++) {
		if (i > n - 2) { s = s "/" a[i] }
		# link to index.html in parent directory
		if (i == n - 2) {
			s = s sprintf("/<a href=\"../\">%s</a>", a[i])
		}
		# link to index.html in grandparent directory
		if (i == n - 3) {
			s = s sprintf("/<a href=\"../../\">%s</a>", a[i])
		}
	}
	sub(/(index|README)\.html$/, "", s)
	return s
}
function footlink_other(f,   a, i, n, s) {
	# for <other>.html link current and parent directories
	n = split(f, a, "/"); s = ""
	for (i = 2; i <= n; i++) {
		if (i > n - 1) { s = s "/" a[i] }
		# link to index.html in current directory
		if (i == n - 1) {
			s = s sprintf("/<a href=\"./\">%s</a>", a[i])
		}
		# link to index.html in parent directory
		if (i == n - 2) {
			s = s sprintf("/<a href=\"../\">%s</a>", a[i])
		}
	}
	return  s
}
function make_footer_links(f) {
	footlink = f
	if (footlink  ~ /^\./) { sub(/^\./, "", footlink) }
	if (footlink !~ /^\//) { footlink = "/" footlink }
	if (footlink  ~ /(index|README)\.html$/) {
		return footlink_index(footlink)
	} else {
		return footlink_other(footlink)
	}
}
function get_size(f,   cmd, s) {
	cmd = "stat -c %s " f; cmd | getline s; close(cmd)
	return s
}
#-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# process SSI source files
# `````````````````````````
# read source files
!targets && FNR == 1 && (!(FILENAME in ssi_file_ndx)) {
	printf "\n%-60s %12s\n", "process target files:", 
			(gzrate?"saved":"by size")
	for (i in ssi_file_ndx) { close(i) }
	++targets
	#++exitflag; exit
}
!targets && FNR == 1 { printf "  %-63s", FILENAME }

# record size of ssi source files for gzip accounting
!targets && FNR == 1 && (FILENAME in ssi_file_ndx) {
	s = get_size(FILENAME)
	ssi_size[FILENAME] = s
	printf "%8d\n", s
	rec_num = ssi_read = 0
}
# arm ssi include file reader and skip ssi file marker line
!targets && FNR == 1 && /^<!-- ssi-file -->$/ { ++ssi_read; next }

# must have non-empty lines for page rewriter (junkdata needs this)
!targets && /^$/ { $0 = " " }

# menu: remove conditional menu ssi directives				part1
!targets && /<!--#if expr="\$menu = / { next }
!targets && /<!--#else --><li><!--#endif -->/ {
	sub(/<!--#else --><li><!--#endif -->/, "<li>")
}
# store ssi include file contents for page rewriter
!targets && ssi_read {
	ssi_data[ssi_file_ndx[FILENAME],++rec_num] = $0; next
}
#-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# process html files
# ```````````````````

# in case we get wildcard, ignore non-html files
FILENAME !~ /\.html$/ { ++skipfile; nextfile }

# no post-process on entry, post-process the file read on prior pass
FNR == 1 && targetcount { post_process() }

# setup rewriter for this pass
FNR == 1 {
	++targetcount
	if (debug) {
		print "read " FILENAME
	} else {
		# magical eye guide dash writer fluffy bit
		s = FILENAME " "
		if (targetcount % 2 == 1) {
			while (length(s) % 8)	{ s = s " " }
			while (length(s) < 57)	{ s = s "-       " }
			sub(/[ ]+$/, "", s)
		}
		printf "  %-63s", s
	}
	thisfile = FILENAME
	tempfile = thisfile ".temp"
	gzipfile = thisfile ".gz"
	footlink = make_footer_links(thisfile)

	menupage = ""; shrinkme = ssimerge = pre_flag = skipfile = 0
	if (system("[ -x " thisfile " ]") == 0 && \
			thisfile !~ /README\.html$/) { ++shrinkme }
}
# skip marked ssi include files
FNR == 1 && /^<!-- ssi-file -->$/ { ++skipfile; nextfile }

# allow <pre> tag in front of ssi directive for formatting
/^<pre><!--#/ { ++pre_flag; sub(/^<pre>/, "") }

# perform the SSI REQUEST_URI tag replacement for footer file path, this 
#  item may have leading / trailing text around the ssi directive
/^<!--#echo var=\"REQUEST_URI\" -->/ {
	++ssimerge
	if (pre_flag) { pre_flag = 0; printf "%s", "<pre>" > tempfile }
	sub(/<!--#echo var=\"REQUEST_URI\" -->/, footlink)
	print > tempfile
	next
}
# menu: extract menu highlight page name				part2
#  <!--#set var="menu" value="<menupage>"-->
/<!--#set var="menu" value="/ {
	sub(/<!--#set var="menu" value="/, "")
	sub(/" -->/, "")
	menupage = ">" $1 "</a>"
	next
}
# replace known ssi directives with their ssi source file contents, 
#  assumes no trailing content after the ssi include directive
($0 in ssi_incl_ndx) {
	++ssimerge
	src = ssi_incl_ndx[$0]
	if (pre_flag) { pre_flag = 0; printf "%s", "<pre>" > tempfile }
	i = 0
	# this while loop requires non-empty ssi replacement lines
	while (ssi_data[src,++i]) {

		# menu: mark menu page for highlighting			part3
		if (menupage) {
			s = ssi_data[src,i]
			if (s ~ menupage) {
				sub(/<li>/, "<li class=here>", s)
				menupage = ""
			}
			print s > tempfile
		} else {
			print ssi_data[src,i] > tempfile
		}
	}
	++ssi_this[ssi_filename[src]]
	next
}
# if find unrecognised SSI directive disable compression
/<!--#/ {
	if (pre_flag) { pre_flag = 0; printf "%s", "<pre>" > tempfile }
	shrinkme = 0
}

# copy other target records to tempfile
{ print > tempfile }
#-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
# complete page processing by performing backup, compression as required, 
#  and do some file size accounting
#
function post_process() {

	close(tempfile)
	# get original (thisfile) and merged (tempfile) file sizes
	cmd = "stat -c %s " thisfile
	cmd | getline this_size; close(cmd)
	if ((!ssimerge && !shrinkme) || skipfile) {
		gzip_size = temp_size = this_size
	} else {
		++rewritecount
		cmd = "stat -c %s " tempfile
		cmd | getline temp_size; close(cmd)
		gzip_size = temp_size
	}

	x_flag = system("[ -x " thisfile " ]") == 0

	# backup source, rename tempfile to source name for delivery-time 
	#  active ssi
	if (x_flag && ssimerge && !shrinkme) {
		# backup source unless already have a backup
		system("[ -r " thisfile ".src ] || mv " thisfile " " \
				thisfile ".src")
		system("mv -f " tempfile " " thisfile \
				" && chmod +x " thisfile)
		temp_size = this_size
	}
	# perhaps compress file, ignore small files
	if(!skipfile && ((x_flag && shrinkme) || !x_flag) && temp_size >100){
		system("gzip -c " tempfile " > " gzipfile)
		cmd = "stat -c %s " gzipfile
		cmd | getline gzip_size; close(cmd)
		++gzipped
		if (debug) { printf "    gzip: %-56s ", gzipfile }
	} else {
		if (debug) { printf "    nogz: %-56s ", thisfile }
	}
	# show percentage shrunk
	if (gzrate) {
		shrink = 100 * (temp_size - gzip_size) / temp_size
	} else {
		shrink = 100 * gzip_size / temp_size
	}
	if (gzip_size != temp_size) {
		printf "% 7.1f%%\n", shrink
	} else {
		printf "%8s\n", ".  "
	}
	# accounting
	total_gzip_size += gzip_size; total_file_size += temp_size
	for (i in ssi_this) { ++ssi_used[i] }

	# cleanup
	system("rm -f " tempfile); delete ssi_this
}
#-=-=-=-=-=-=-=-=-=-=-=--=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
END {
	if (exitflag) { exit }			# BEGIN block requested exit
	if (targetcount) { post_process() }	# process last file
	print ""
	if (!total_file_size) { exit }		# done if no files processed

	for (i = 1; i <= ssi_count; i++) {
		totalssi = totalssi + \
			ssi_used[ssi_filename[i]] * ssi_size[ssi_filename[i]]
	}

	total_file_size += totalssi		# account for ssi insertions

	# report rewriter + compression summary
	if (gzrate) {
		percent = 100 * (total_file_size - total_gzip_size) \
				/ total_file_size
	} else {
		percent = 100 * total_gzip_size / total_file_size
	}
	printf "Checked %d files, rewrote %d, gzipped %d, %#.1fk to %#.1fk, "\
			"%#.1f%% %s\n", targetcount, rewritecount, gzipped, 
			total_file_size / 1000, 
			total_gzip_size / 1000, percent, 
			(gzrate?"saved":"by size")

	# report ssi file insertions
	print "\nSSI files inserted:"
	for (i = 1; i <= ssi_count; i++) {
		printf "  %-50s: %3d x %5d %7d\n", ssi_filename[i],
			ssi_used[ssi_filename[i]], ssi_size[ssi_filename[i]], 
			ssi_used[ssi_filename[i]] * ssi_size[ssi_filename[i]]
	}
	printf "  % 50s: %19u\n\n", "Total ", totalssi
}
# end