HandBrake/HandBrake-docs
1
0
Fork 0
mirror of https://github.com/HandBrake/HandBrake-docs.git synced 2025-12-10 00:44:52 -06:00
Code Issues Packages Projects Releases 1 Wiki Activity
HandBrake-docs/marsh
Bradley Sepos 69c8265d36 build: Update to marsh 0.2.0. 
Adds option to select number of concurrent jobs. Recommend --jobs 1 when using Jenkins or other software that clobbers the build environment.
2016-11-12 17:12:03 -05:00

2269 lines
97 KiB
Bash
Executable File
Raw Blame History

#!/bin/bash
# marsh - build static websites using markdown and bash
#
# Copyright 2016 Bradley Sepos
# Released under the MIT License. See LICENSE for details.
# https://github.com/bradleysepos/marsh
NAME="marsh"
VERSION="0.2.0"
SELF="${BASH_SOURCE[0]}"
SELF_DIR=$(cd $(dirname "${BASH_SOURCE[0]}") && pwd -P)
SELF_DIR="${SELF_DIR:-$(pwd)}"
SELF_NAME=$(basename "${SELF}")
MARKDOWN_OPTIONS_DEFAULT=(-1.0 +alphalist -autolink -cdata +definitionlist -divquote -dldiscount +dlextra -emphasis +ext +fencedcode +footnote +githubtags -header +html +image -latex +links -safelink +smarty +strikethrough +style +superscript +tables -tabstop -toc)
HELP="\
usage: ${SELF_NAME} [-h | --help]
${SELF_NAME} [-v | --version]
${SELF_NAME} build [--fetch] [--force] [-j # | --jobs #]
[--markdown markdown] [--markdown-options opt1,opt2] [config_file]
where:
-h, --help
display this help text
-v, --version
display version information
--fetch
download remote resources
--force
remove and replace existing targets (overwrite)
-j, --jobs
number of concurrent jobs to run using GNU Parallel
default: automatically chosen by GNU Parallel, if available
--markdown
path to markdown application
--markdown-options
markdown translation options (comma delimited)
default: $(echo ${MARKDOWN_OPTIONS_DEFAULT[@]} | sed 's/ /,/g')"
# creates bash variables from yaml records
# extended to support arrays, empty values, and more
# https://gist.github.com/DinoChiesa/3e3c3866b51290f31243
# https://gist.github.com/epiloque/8cf512c6d64641bde388
# https://gist.github.com/pkuczynski/8665367
function parse_yaml { # parse_yaml yaml_string_or_file variables_prefix spaces_per_indentation
local INPUT PREFIX INDENT S W FS
INPUT="${1:-}"
[[ "${INPUT}" == "" ]] && return 0
if [[ -f "${INPUT}" ]] && [[ -r "${INPUT}" ]]; then
INPUT=$(<"${INPUT}")
fi
PREFIX="${2:-}"
INDENT="${3:-}"
if [[ ! "${INDENT}" =~ '^[0-9]+$' ]] || [[ ! "${INDENT}" -eq 0 ]]; then
INDENT=2
fi
S='[[:space:]]*'
W='[a-zA-Z0-9_]*'
FS=$(echo @|tr @ '\034')
echo "${INPUT}" |
sed -n \
-e "s|^\(\(${S}\)\(-\) \)\{1\}\(${S}\)\(${W}\)${S}:${S}\(\".*\"\)\${S}\$|\3${FS}\2 \4${FS}\5${FS}\6|p" \
-e "s|^\(\(${S}\)\(-\) \)\{1\}\(${S}\)\(${W}\)${S}:${S}\(.*\)${S}\$|\3${FS}\2 \4${FS}\5${FS}\6|p" \
-e "s|^\(\(${S}\)\(-\) \)\{1\}\(${S}\)\(\".*\"\)${S}\$|\3${FS}\2 \4${FS}${FS}\5|p" \
-e "s|^\(\(${S}\)\(-\) \)\{1\}\(${S}\)\([^:].*\)${S}\$|\3${FS}\2 \4${FS}${FS}\5|p" \
-e "s|^\(${S}\)\(${W}\)${S}:${S}\(\".*\"\)${S}\$|${FS}\1${FS}\2${FS}\3|p" \
-e "s|^\(${S}\)\(${W}\)${S}:${S}\(.*\)${S}\$|${FS}\1${FS}\2${FS}\3|p" |
awk -F"${FS}" \
'#
# parse_csv, public domain, http://lorance.freeshell.org/csv/
#**************************************************************************
#
# This file is in the public domain.
#
# For more information email LoranceStinson+csv@gmail.com.
# Or see http://lorance.freeshell.org/csv/
#
# Parse a CSV string into an array.
# The number of fields found is returned.
# In the event of an error a negative value is returned and csverr is set to
# the error. See below for the error values.
#
# Parameters:
# string = The string to parse.
# csv = The array to parse the fields into.
# sep = The field separator character. Normally ,
# quote = The string quote character. Normally "
# escape = The quote escape character. Normally "
# newline = Handle embedded newlines. Provide either a newline or the
# string to use in place of a newline. If left empty embedded
# newlines cause an error.
# trim = When true spaces around the separator are removed.
# This affects parsing. Without this a space between the
# separator and quote result in the quote being ignored.
#
# These variables are private:
# fields = The number of fields found thus far.
# pos = Where to pull a field from the string.
# strtrim = True when a string is found so we know to remove the quotes.
#
# Error conditions:
# -1 = Unable to read the next line.
# -2 = Missing end quote.
# -3 = Missing separator.
#
# Notes:
# The code assumes that every field is preceded by a separator, even the
# first field. This makes the logic much simpler, but also requires a
# separator be prepended to the string before parsing.
function parse_csv(string,csv,sep,quote,escape,newline,trim, fields,pos,strtrim) {
# Make sure there is something to parse.
if (length(string) == 0) return 0;
string = sep string; # The code below assumes ,FIELD.
fields = 0; # The number of fields found thus far.
while (length(string) > 0) {
# Remove spaces after the separator if requested.
if (trim && substr(string, 2, 1) == " ") {
if (length(string) == 1) return fields;
string = substr(string, 2);
continue;
}
strtrim = 0; # Used to trim quotes off strings.
# Handle a quoted field.
if (substr(string, 2, 1) == quote) {
pos = 2;
do {
pos++
if (pos != length(string) &&
substr(string, pos, 1) == escape &&
(substr(string, pos + 1, 1) == quote ||
substr(string, pos + 1, 1) == escape)) {
# Remove escaped quote characters.
string = substr(string, 1, pos - 1) substr(string, pos + 1);
} else if (substr(string, pos, 1) == quote) {
# Found the end of the string.
strtrim = 1;
} else if (newline && pos >= length(string)) {
# Handle embedded newlines if requested.
if (getline == -1) {
csverr = "Unable to read the next line.";
return -1;
}
string = string newline $0;
}
} while (pos < length(string) && strtrim == 0)
if (strtrim == 0) {
csverr = "Missing end quote.";
return -2;
}
} else {
# Handle an empty field.
if (length(string) == 1 || substr(string, 2, 1) == sep) {
csv[fields] = "";
fields++;
if (length(string) == 1)
return fields;
string = substr(string, 2);
continue;
}
# Search for a separator.
pos = index(substr(string, 2), sep);
# If there is no separator the rest of the string is a field.
if (pos == 0) {
csv[fields] = substr(string, 2);
fields++;
return fields;
}
}
# Remove spaces after the separator if requested.
if (trim && pos != length(string) && substr(string, pos + strtrim, 1) == " ") {
trim = strtrim
# Count the number fo spaces found.
while (pos < length(string) && substr(string, pos + trim, 1) == " ") {
trim++
}
# Remove them from the string.
string = substr(string, 1, pos + strtrim - 1) substr(string, pos + trim);
# Adjust pos with the trimmed spaces if a quotes string was not found.
if (!strtrim) {
pos -= trim;
}
}
# Make sure we are at the end of the string or there is a separator.
if ((pos != length(string) && substr(string, pos + 1, 1) != sep)) {
csverr = "Missing separator.";
return -3;
}
# Gather the field.
csv[fields] = substr(string, 2 + strtrim, pos - (1 + strtrim * 2));
fields++;
# Remove the field from the string for the next pass.
string = substr(string, pos + 1);
}
return fields;
}
BEGIN { prefix = "'"${PREFIX}"'"; indent = '"${INDENT}"'; prev_level = 0; }
{
type = $1;
level = length($2)/indent;
key = $3;
val = $4;
out = "";
array = 0;
if (level < prev_level) { adepth[prev_level] = -1; }
if (adepth[level] == "") { adepth[level] = -1; }
if (type == "-") { adepth[level]++; }
vname[level] = key;
for (i in vname) {
if (i > (level)) { vname[i] = ""; }
}
for (i = 0; i < level; i++) {
if (vname[i] != "") {
out = out "_" vname[i];
if (adepth[i] > -1) { out = out "_" adepth[i+1]; }
} else {
out = out "_" adepth[i+1];
}
}
if (substr(val,1,1) == "[" && substr(val,length(val),1) == "]") {
array = 1;
gsub(/^\[[ ]*/, "", val);
gsub(/[ ]*\]$/, "", val);
num_vals = parse_csv(val, vals, ",", "\"", "\"", "\\n", 1);
if (num_vals < 0) {
# Error parsing inline array
exit 1;
}
} else {
if (substr(val,1,1) == "\"" && substr(val,length(val),1) == "\"") {
num_vals = parse_csv(val, vals, "'"${FS}"'", "\"", "\"", "\\n", 0);
if (num_vals < 0) {
# Error parsing
exit 1;
}
} else {
vals[1] = val;
}
}
if (key != "") { out = out "_" key; }
out = prefix out;
gsub(/__/, "_", out);
gsub(/_=/, "", out);
#for (i = 1; i <= length(vals); i++) {
for (i in vals) {
gsub(/"/, "\\\"", vals[i]);
if (vals[i] != "true" && vals[i] != "false") {
vals[i]="\"" vals[i] "\""
}
if (array == 1) {
print out "_" i "=" vals[i];
} else {
print out "=" vals[i];
}
}
delete vals;
prev_level = level;
}'
}
# tests whether a string is an exact match for an array item
function in_array { # in_array needle haystack[@]
local e
for e in "${@:2}"; do
[[ "${e}" == "${1}" ]] && return 0;
done
return 1
}
# creates an array from the contents of flat variables
# TEST_0="foo"; TEST_1="bar"; TEST_2="baz"
# eval $(flat_to_array "TEST" "TEST_") # loops over TEST_{0..2}
# echo "${TEST[*]}" # foo bar baz
function flat_to_array { # flat_to_array array_name variable_prefix
local ARRAY_NAME PREFIX INDEX ITEM
ARRAY_NAME="${1:-}"
[[ "${ARRAY_NAME}" == "" ]] && return 1
PREFIX="${2:-}"
[[ "${PREFIX}" == "" ]] && return 1
echo "${ARRAY_NAME}=()"
INDEX=0
ITEM="${PREFIX}${INDEX}"
ITEM="${!ITEM:-}"
while [[ "${ITEM}" != "" ]]; do
echo "${ARRAY_NAME}+=(\"${ITEM//\"/\\\"}\")"
INDEX=$((INDEX + 1))
ITEM="${PREFIX}${INDEX}"
ITEM="${!ITEM:-}"
done
return 0
}
# prints arguments combined with delimiters
# join_delimited ', ' ', ' ', ' foo bar baz # foo, bar, baz
# join_delimited ', ' ' and ' ', and ' foo bar baz # foo, bar, and baz
function join_delimited { # join_delimited delimiter1 delimiter2 delimiter3 args[@]
local DELIM1 DELIM2 DELIM3
DELIM1="${1:-}"
shift 1
DELIM2="${1:-}"
shift 1
DELIM3="${1:-}"
shift 1
if [[ "${#@}" -gt 0 ]]; then
echo -n "${1}"
if [[ "${#@}" -eq 2 ]]; then
echo "${DELIM2}${2}"
return 0
fi
while [[ "${#@}" -gt 2 ]]; do
echo -n "${DELIM1}${2}"
shift 1
done
echo -n "${2+$DELIM3$2}"
echo
fi
return 0
}
# prints md5 hash for a given string
function md5_string { # md5_string string
local STRING SYS_NAME
STRING="${1:-}"
SYS_NAME=$(uname | awk '{ print tolower($0)}')
if [[ "${SYS_NAME}" == "darwin" ]]; then
echo -n "${STRING}" | md5 -r | awk '{ print $1 }'
else
echo -n "${STRING}" | md5sum | awk '{ print $1 }'
fi
return 0
}
# transforms a string
function text_filter { # text_filter filters[@]
local FILTERS
local LF TEXT OPTIONS TEXT_TEMP DATE_FORMAT MAX_CHARS MAX_PARAS WRAP
LF=$'\n'
TEXT=$(</dev/stdin)
FILTERS=("${@}")
for FILTER in ${FILTERS[@]}; do
OPTIONS="${FILTER#*:}"
if [[ "${OPTIONS}" == "${FILTER}" ]]; then
OPTIONS=""
fi
OPTIONS=(${OPTIONS//:/ })
case "${FILTER}" in
date:*)
[[ "${TEXT}" == "" ]] && return 1
DATE_FORMAT="${OPTIONS[0]:-}"
if [[ "${DATE_FORMAT}" != "" ]]; then
TEXT_TEMP="${TEXT}"
if [[ "${#TEXT_TEMP}" -eq 10 ]]; then
TEXT_TEMP="${TEXT_TEMP} 00:00:00"
fi
case "${DATE_FORMAT}" in
[Rr][Ff][Cc]3339)
TEXT_TEMP=$(TZ=UTC date -jf '%Y-%m-%d %H:%M:%S' '+%Y-%m-%dT%T%z' "${TEXT_TEMP}" 2>/dev/null | sed -E -e 's/([0-9][0-9])$/:\1/')
[[ $? -ne 0 ]] && return 1
;;
esac
TEXT="${TEXT_TEMP}"
fi
;;
escape:html)
TEXT=$(echo "${TEXT}" | sed -e 's/&/\&amp;/g' -e 's/</\&lt;/g' -e 's/>/\&gt;/g' -e 's/"/\&quot;/g' -e 's/'"'"'/\&#39;/g');
;;
excerpt:*)
MAX_CHARS="${OPTIONS[0]:-}"
MAX_PARAS="${OPTIONS[1]:-}"
if [[ "${MAX_CHARS}" != "" ]]; then
[[ "${MAX_CHARS}" -lt 1 ]] && TEXT="" && break
TEXT=$(echo "${TEXT}" | text_filter headings:remove plaintext)
if [[ "${MAX_PARAS}" != "" ]]; then
TEXT=$(echo "${TEXT}" | awk -v RS="\n\n" 'NR<='${MAX_PARAS}'+1 { print $0 }')
fi
TEXT_TEMP=$(echo "${TEXT:0:$MAX_CHARS}")
if [[ "${TEXT}" != "${TEXT_TEMP}" ]]; then
if [[ "${MAX_CHARS}" -gt 3 ]]; then
TEXT=$(echo "${TEXT_TEMP:0:$((MAX_CHARS-3))}")
else
TEXT=""
fi
TEXT="${TEXT}..."
fi
TEXT=$(echo "${TEXT}${LF}")
fi
;;
excerpt)
TEXT=$(echo "${TEXT}" | text_filter excerpt:300:2)
;;
headings:push)
TEXT=$(echo "${TEXT}${LF}" | sed -E -e 'N;s/^(.*)\n([-]+|[=]+)$/# \1/' | sed -E -e 's/^([#]+ )/#\1/' -e 's/^####### (.+)$/**\1**/')
TEXT=$(echo "${TEXT}" | sed -E -e '/<\/?h[0-6][^>]*>/{s/<(\/)?h6/<\1strong/g' -e 's/<(\/)?h5/<\1h6/g' -e 's/<(\/)?h4/<\1h5/g' -e 's/<(\/)?h3/<\1h4/g' -e 's/<(\/)?h2/<\1h3/g' -e 's/<(\/)?h1/<\1h2/g' -e '}')
;;
headings:shift)
TEXT=$(echo "${TEXT}${LF}" | sed -E -e 'N;s/^(.*)\n([-]+|[=]+)$/# \1/' | sed -E -e '/^# .+$/d' -e 's/^#([#]+ )/\1/')
TEXT=$(echo "${TEXT}" | sed -E -e '/<h1[^>]*>.*<\/h1>/s///g' | sed -E -e '/<\/?h[0-6][^>]*>/{s/<(\/)h2/<\1h1/g' -e 's/<(\/)h3/<\1h2/g' -e 's/<(\/)h4/<\1h3/g' -e 's/<(\/)h5/<\1h4/g' -e 's/<(\/)h6/<\1h5/g' -e '}')
;;
headings:remove)
TEXT=$(echo "${TEXT}${LF}" | sed -E -e 'N;s/^(.*)\n([-]+|[=]+)$/# \1/' | sed -E -e '/^[#]+ .+$/d')
TEXT=$(echo "${TEXT}" | sed -E -e 's/<(h1|h2|h3|h4|h5|h6)[^>]*>.*<\/(h1|h2|h3|h4|h5|h6)>//g')
;;
plaintext)
# ':a;s/<[^>]*>//g;/</N;//ba' strips html tags and works across multiple lines (better version of 's/<[^>]*>//g')
# '/./,/^$/!d' deletes blank lines at start and collapses consecutive blank lines into one, leaving up to one blank line at end
TEXT=$(echo "${TEXT}" | sed -e ':a' -e 's/<[^>]*>//g' -e '/</N' -e '//ba' | sed '/./,/^$/!d')
;;
slug)
TEXT=$(echo "${TEXT}" | head -n 1 | sed -E -e 's/[ _]+/-/g' -e 's/[^-a-zA-Z0-9.]//g' -e 's/(^-+)|(-+$)//' | awk '{ print tolower($0) }')
;;
wrap:*)
WRAP="${OPTIONS[0]}"
TEXT=$(echo "<!-- ${WRAP} -->${LF}${TEXT}${LF}<!-- /${WRAP} -->${LF}")
;;
esac
done
echo "${TEXT}"
}
# prints a list of variables given their assignment commands, one per line, e.g. FOO="bar" prints FOO
function get_variables { # get_variables assignments_string
local STRING
STRING=$(</dev/stdin)
echo "${STRING}" | sed -E -e 's/^([^=]+[^+])[+]?=.*/\1/' | sort -u
}
# tests whether existing file or directory is child of parent directory
function is_child { # is_child directory child
local CURRENT_DIR DIRECTORY CHILD CD
CURRENT_DIR=$(pwd)
DIRECTORY="${1:-}"
[[ ! -d "${DIRECTORY}" ]] && return 1
DIRECTORY="${DIRECTORY%/}/"
CHILD="${2:-}"
if [[ -d "${CHILD}" ]]; then
CHILD_DIR="${CHILD%/}/"
elif [[ -f "${CHILD}" ]]; then
CHILD_DIR="${CHILD%/*}/"
else
return 1
fi
# parent dir
cd "${DIRECTORY}" >/dev/null 2>&1 || return 1
DIRECTORY=$(pwd -P . 2>/dev/null || command pwd)
cd "${CURRENT_DIR}"
# child dir
cd "${CHILD_DIR}" >/dev/null 2>&1 || return 1
CHILD_DIR=$(pwd -P . 2>/dev/null || command pwd)
cd "${CURRENT_DIR}"
# compare
if [[ -f "${CHILD}" ]] && [[ "${DIRECTORY}" == "${CHILD_DIR}" ]]; then
# file in directory root
return 0
fi
if [[ "${DIRECTORY}" != "${CHILD_DIR}" ]] && [[ "${CHILD_DIR#$DIRECTORY}" != "${CHILD_DIR}" ]]; then
# subdirectory or file in subdirectory
return 0
fi
return 1
}
# prints an integer transformation of a version string
# useful for simple comparisons, max input 999.999.999
# [[ $(version 2.10.9) -gt $(version 1.0.5) ]] # true
# [[ 2010009 -gt 1000005 ]] # true
function version { # version x(.x)?(.x)?
echo $(printf "%03d%03d%03d\n" $(echo "${1:-}" | sed -E -e 's/^([0-9]+(\.[0-9]+(\.[0-9]+)?)?).*$/\1/' | tr '.' '\n' | head -n 3)) | sed 's/^0*//' | sed 's/^$/0/'
}
# checks for required external tool
function dependency_exists { # dependency_exists dep
local DEP ERROR
DEP="${1:-}"; [[ "${DEP}" == "" ]] && return 1
ERROR=false
if echo "${DEP}" | grep '/' >/dev/null 2>&1 && [[ ! -x "${DEP}" ]]; then
echo "Unable to find command: ${DEP}" >&2
ERROR=true
elif ! hash "${DEP}" >/dev/null 2>&1; then
echo "Unable to find command: ${DEP}" >&2
ERROR=true
fi
[[ "${ERROR}" == true ]] && return 1
return 0
}
# checks for required external tools (plural)
function dependencies_exist { # dependencies_exist deps[@]
local DEPS ERRORS
DEPS=("${@}");
ERRORS=()
for DEP in ${DEPS[@]}; do
dependency_exists "${DEP}" 2>/dev/null || ERRORS+=("${DEP}")
done
if [[ "${#ERRORS[@]}" -ne 0 ]]; then
echo "Unable to find command(s): ${ERRORS[*]}" >&2
return 1
fi
return 0
}
# prints dependency requirements
function print_dependency { # print_dependency name url required_version found_version
local NAME URL VERSION FOUND
NAME="${1:-}"; [[ "${NAME}" == "" ]] && return 1
URL="${2:-}"
VERSION="${3:-}"
FOUND="${4:-}"
echo -n "${NAME}" >&2
if [[ "${VERSION}" != "" ]]; then
echo -n " version ${VERSION} or later" >&2
fi
echo -n " is required" >&2
if [[ "${FOUND}" != "" ]]; then
echo -n " (found version ${FOUND})" >&2
fi
if [[ "${URL}" != "" ]]; then
echo -n ": ${URL}" >&2
fi
echo >&2
}
# prints bash variable assignments for template metadata
function parse_template_metadata { # parse_template_metadata prefix template_dir template_config_extra
local PREFIX TEMPLATE_DIR TEMPLATE_CONFIG_EXTRA
local TEMPLATE_META TEMPLATE_META_VARS
local TEMPLATE_ASSETS_FONTS TEMPLATE_ASSETS_STYLES TEMPLATE_ASSETS_SCRIPTS TEMPLATE_ASSETS_IMAGES TEMPLATE_ASSETS_AUDIO TEMPLATE_ASSETS_VIDEO TEMPLATE_ASSETS_DOCUMENTS TEMPLATE_ASSETS_OTHER
local INDEX ASSET_TYPES ASSET_TYPE_UPPER ASSET FILTER_INDEX REGEX EXTENDED MATCH REPLACE EXTRA ASSETS_INDEX ASSETS ASSETS_TEMP
# init
PREFIX="${1:-}"
TEMPLATE_DIR="${2:-}"
[[ "${TEMPLATE_DIR}" == "" ]] && return 1
TEMPLATE_CONFIG_EXTRA="${3:-}"
# load config
if [[ -f "${TEMPLATE_DIR}/template.yaml" ]] && [[ -r "${TEMPLATE_DIR}/template.yaml" ]]; then
TEMPLATE_META=$(parse_yaml "${TEMPLATE_DIR}/template.yaml" "MARSH_TEMPLATE_")
[[ $? -ne 0 ]] && echo "Unable to parse yaml file: ${TEMPLATE_DIR}/template.yaml" >&2 && return 1
TEMPLATE_META_VARS=$(echo "${TEMPLATE_META}" | get_variables)
eval "${TEMPLATE_META}"
else
echo "Template configuration file not found: ${TEMPLATE_DIR}/template.yaml" >&2
return 1
fi
if [[ "${TEMPLATE_CONFIG_EXTRA}" != "" ]]; then
# load extra config
if [[ -f "${TEMPLATE_CONFIG_EXTRA}" ]] && [[ -r "${TEMPLATE_CONFIG_EXTRA}" ]]; then
TEMPLATE_META=$(parse_yaml "${TEMPLATE_CONFIG_EXTRA}" "MARSH_TEMPLATE_")
[[ $? -ne 0 ]] && echo "Unable to parse yaml file: ${TEMPLATE_CONFIG_EXTRA}" >&2 && return 1
TEMPLATE_META_VARS=$(echo "${TEMPLATE_META_VARS}"$'\n'"${TEMPLATE_META}" | get_variables)
eval "${TEMPLATE_META}"
else
echo "Template configuration file not found: ${TEMPLATE_CONFIG_EXTRA}" >&2
return 1
fi
fi
# print partials paths relative to template dir
[[ "${MARSH_TEMPLATE_Template_Partials_Base:-}" != "" ]] && echo "${PREFIX}Template_Partials_Base=\"${TEMPLATE_DIR}/${MARSH_TEMPLATE_Template_Partials_Base//\"/\\\"}\""
[[ "${MARSH_TEMPLATE_Template_Partials_Body:-}" != "" ]] && echo "${PREFIX}Template_Partials_Body=\"${TEMPLATE_DIR}/${MARSH_TEMPLATE_Template_Partials_Body//\"/\\\"}\""
[[ "${MARSH_TEMPLATE_Template_Partials_Archive:-}" != "" ]] && echo "${PREFIX}Template_Partials_Archive=\"${TEMPLATE_DIR}/${MARSH_TEMPLATE_Template_Partials_Archive//\"/\\\"}\""
[[ "${MARSH_TEMPLATE_Template_Partials_Document:-}" != "" ]] && echo "${PREFIX}Template_Partials_Document=\"${TEMPLATE_DIR}/${MARSH_TEMPLATE_Template_Partials_Document//\"/\\\"}\""
[[ "${MARSH_TEMPLATE_Template_Partials_Header:-}" != "" ]] && echo "${PREFIX}Template_Partials_Header=\"${TEMPLATE_DIR}/${MARSH_TEMPLATE_Template_Partials_Header//\"/\\\"}\""
[[ "${MARSH_TEMPLATE_Template_Partials_Nav:-}" != "" ]] && echo "${PREFIX}Template_Partials_Nav=\"${TEMPLATE_DIR}/${MARSH_TEMPLATE_Template_Partials_Nav//\"/\\\"}\""
[[ "${MARSH_TEMPLATE_Template_Partials_Footer:-}" != "" ]] && echo "${PREFIX}Template_Partials_Footer=\"${TEMPLATE_DIR}/${MARSH_TEMPLATE_Template_Partials_Footer//\"/\\\"}\""
[[ "${MARSH_TEMPLATE_Template_Partials_Redirect:-}" != "" ]] && echo "${PREFIX}Template_Partials_Redirect=\"${TEMPLATE_DIR}/${MARSH_TEMPLATE_Template_Partials_Redirect//\"/\\\"}\""
[[ "${MARSH_TEMPLATE_Template_Partials_Feed_Body:-}" != "" ]] && echo "${PREFIX}Template_Partials_Feed_Body=\"${TEMPLATE_DIR}/${MARSH_TEMPLATE_Template_Partials_Feed_Body//\"/\\\"}\""
[[ "${MARSH_TEMPLATE_Template_Partials_Feed_Document:-}" != "" ]] && echo "${PREFIX}Template_Partials_Feed_Document=\"${TEMPLATE_DIR}/${MARSH_TEMPLATE_Template_Partials_Feed_Document//\"/\\\"}\""
# assets
ASSET_TYPES=('Fonts' 'Styles' 'Scripts' 'Images' 'Audio' 'Video' 'Documents' 'Binaries' 'Other')
for ASSET_TYPE in ${ASSET_TYPES[@]}; do
eval "TEMPLATE_ASSETS_${ASSET_TYPE}=()"
INDEX=0
ASSET="MARSH_TEMPLATE_Template_Assets_${ASSET_TYPE}_${INDEX}"
ASSET="${!ASSET:-}"
while [[ "${ASSET}" != "" ]]; do
eval "TEMPLATE_ASSETS_${ASSET_TYPE}+=(\"${ASSET//\"/\\\"}\")"
INDEX=$((INDEX+1))
ASSET="MARSH_TEMPLATE_Template_Assets_${ASSET_TYPE}_${INDEX}"
ASSET="${!ASSET:-}"
done
done
# assets filters
FILTER_INDEX=0
REGEX="MARSH_TEMPLATE_Template_Filters_${FILTER_INDEX}_Regex"
REGEX="${!REGEX:-}"
EXTENDED="MARSH_TEMPLATE_Template_Filters_${FILTER_INDEX}_Extended"
EXTENDED="${!EXTENDED:-}"
# loop over assets filters
while [[ "${REGEX}" != "" ]]; do
# escape match
if [[ "$(echo ${REGEX} | grep -E '^s/.+[^\]/.*[^\]/g?$')" == "${REGEX}" ]]; then
MATCH=$(echo "${REGEX}" | sed -E 's/^s\/(.+[^\])\/.*[^\]\/g?/\1/' | sed 's/[[]\.|$(){}?+*^]/\\&/g')
REPLACE=$(echo "${REGEX}" | sed -E 's/^s\/.+[^\]\/(.*[^\])\/g?/\1/')
EXTRA=$(echo "${REGEX}" | sed -E 's/^s\/.+[^\]\/.*[^\]\/(g?)/\1/')
REGEX="s/${MATCH}/${REPLACE}/${EXTRA}"
elif [[ "$(echo ${REGEX} | grep -E '^s\|.+[^\]\|.*[^\]\|g?$')" == "${REGEX}" ]]; then
MATCH=$(echo "${REGEX}" | sed -E 's/^s\|(.+[^\])\|.*[^\]\|g?/\1/' | sed 's/[[]\.|$(){}?+*^]/\\&/g')
REPLACE=$(echo "${REGEX}" | sed -E 's/^s\|.+[^\]\|(.*[^\])\|g?/\1/')
EXTRA=$(echo "${REGEX}" | sed -E 's/^s\|.+[^\]\|.*[^\]\|(g?)/\1/')
REGEX="s|${MATCH}|${REPLACE}|${EXTRA}"
elif [[ "$(echo ${REGEX} | grep -E '^/.+[^\]/d?$')" == "${REGEX}" ]]; then
MATCH=$(echo "${REGEX}" | sed -E 's/^\/(.+[^\])\/d?/\1/' | sed 's/[[]\.|$(){}?+*^]/\\&/g')
REPLACE=""
EXTRA=$(echo "${REGEX}" | sed -E 's/^\/.+[^\]\/(d?)/\1/')
REGEX="/${MATCH}/${EXTRA}"
else
continue
fi
ASSETS_INDEX=0
ASSETS_TYPE="MARSH_TEMPLATE_Template_Filters_${FILTER_INDEX}_Assets_${ASSETS_INDEX}"
ASSETS_TYPE="${!ASSETS_TYPE}"
# loop over assets types for filter
while [[ "${ASSETS_TYPE}" != "" ]]; do
ASSETS="TEMPLATE_ASSETS_${ASSETS_TYPE}[@]"
ASSETS=(${!ASSETS})
ASSETS_TEMP=()
# loop over all individual assets of this type
for ASSET in ${ASSETS[@]}; do
# do regex
if [[ "${EXTENDED}" == true ]]; then
ASSET=$(echo "${ASSET}" | sed -E "${REGEX}" 2>/dev/null)
else
ASSET=$(echo "${ASSET}" | sed "${REGEX}" 2>/dev/null)
fi
# remove empty
if [[ "${ASSET:-}" != "" ]]; then
ASSETS_TEMP+=("${ASSET}")
fi
done
# update original array
eval "TEMPLATE_ASSETS_${ASSETS_TYPE}=()"
for I in "${!ASSETS_TEMP[@]}"; do
eval "TEMPLATE_ASSETS_${ASSETS_TYPE}+=(\"${ASSETS_TEMP[$I]//\"/\\\"}\")"
done
ASSETS_INDEX=$((ASSETS_INDEX+1))
ASSETS_TYPE="MARSH_TEMPLATE_Template_Filters_${FILTER_INDEX}_Assets_${ASSETS_INDEX}"
ASSETS_TYPE="${!ASSETS_TYPE:-}"
done
FILTER_INDEX=$((FILTER_INDEX+1))
REGEX="MARSH_TEMPLATE_Template_Filters_${FILTER_INDEX}_Regex"
REGEX="${!REGEX:-}"
EXTENDED="MARSH_TEMPLATE_Template_Filters_${FILTER_INDEX}_Extended"
EXTENDED="${!EXTENDED:-}"
ASSETS_INDEX=0
ASSETS_TYPE="MARSH_TEMPLATE_Template_Filters_${FILTER_INDEX}_Assets_${ASSETS_INDEX}"
ASSETS_TYPE="${!ASSETS_TYPE:-}"
done
# print assets
for ASSET_TYPE in ${ASSET_TYPES[@]}; do
ASSET_TYPE_UPPER=$(echo "${ASSET_TYPE}" | awk '{ print toupper($0) }')
ASSETS="TEMPLATE_ASSETS_${ASSET_TYPE}[@]"
ASSETS=(${!ASSETS})
echo "${PREFIX}ASSETS_${ASSET_TYPE_UPPER}=()"
for ASSET in ${ASSETS[@]}; do
[[ "${ASSET:-}" != "" ]] && echo "${PREFIX}ASSETS_${ASSET_TYPE_UPPER}+=(\"${ASSET//\"/\\\"}\")"
done
done
# unset temporary global variables
for VAR in ${TEMPLATE_META_VARS[@]}; do unset "${VAR}"; done
}
# loads target metadata into convenience variables
function get_target_metadata { # get_target_metadata source_prefix prefix
local SOURCE_PREFIX PREFIX
local TARGET_PATH TARGET_NAME TEMPLATE_SOURCE TARGET_TYPE TEMPLATE_REMOTE TARGET_FORCE TEMPLATE_FETCH TARGET_NAV
local II TEMPLATE_SOURCE TEMPLATE_REMOTE TEMPLATE_FETCH TEMPLATE_CONFIG
local FEED FEED_NAME FEED_COUNT FEED_CONTENT FEED_TYPES FEED_EXCLUDED_STATES
local ARCHIVE ARCHIVE_NAME ARCHIVE_COUNT ARCHIVE_CONTENT ARCHIVE_TYPES ARCHIVE_EXCLUDED_STATES
# init
SOURCE_PREFIX="${1:-}"
PREFIX="${2:-}"
# root
TARGET_PATH="${SOURCE_PREFIX}Path"
[[ -z ${!TARGET_PATH+isset} ]] && return 1
TARGET_NAME="${SOURCE_PREFIX}Name"
TARGET_SOURCE="${SOURCE_PREFIX}Source"
TARGET_TYPE="${SOURCE_PREFIX}Type"
TARGET_REMOTE="${SOURCE_PREFIX}Remote"
TARGET_FORCE="${SOURCE_PREFIX}Force"
TARGET_FETCH="${SOURCE_PREFIX}Fetch"
TARGET_NAV="${SOURCE_PREFIX}Navigation"
[[ "${!TARGET_PATH:-}" != "" ]] && echo "${PREFIX}PATH=\"${!TARGET_PATH//\"/\\\"}\""
[[ "${!TARGET_NAME:-}" != "" ]] && echo "${PREFIX}NAME=\"${!TARGET_NAME//\"/\\\"}\""
[[ "${!TARGET_SOURCE:-}" != "" ]] && echo "${PREFIX}SOURCE=\"${!TARGET_SOURCE//\"/\\\"}\""
[[ "${!TARGET_TYPE:-}" != "" ]] && echo "${PREFIX}TYPE=\"${!TARGET_TYPE//\"/\\\"}\""
[[ "${!TARGET_REMOTE:-}" != "" ]] && echo "${PREFIX}REMOTE=\"${!TARGET_REMOTE//\"/\\\"}\""
[[ "${!TARGET_NAV:-}" != "" ]] && echo "${PREFIX}NAV=\"${!TARGET_NAV//\"/\\\"}\""
[[ "${!TARGET_FORCE:-}" != "" ]] && echo "${PREFIX}FORCE=\"${!TARGET_FORCE//\"/\\\"}\""
[[ "${!TARGET_FETCH:-}" != "" ]] && echo "${PREFIX}FETCH=\"${!TARGET_FETCH//\"/\\\"}\""
# templates
echo "${PREFIX}TEMPLATES_SOURCE=()"
echo "${PREFIX}TEMPLATES_REMOTE=()"
echo "${PREFIX}TEMPLATES_FETCH=()"
echo "${PREFIX}TEMPLATES_CONFIG=()"
echo "${PREFIX}TEMPLATES=()"
II=0
TEMPLATE_SOURCE="${SOURCE_PREFIX}Templates_${II}_Source"
TEMPLATE_REMOTE="${SOURCE_PREFIX}Templates_${II}_Remote"
TEMPLATE_FETCH="${SOURCE_PREFIX}Templates_${II}_Fetch"
TEMPLATE_CONFIG="${SOURCE_PREFIX}Templates_${II}_Config"
while [[ "${!TEMPLATE_SOURCE:-}" != "" ]]; do
echo "${PREFIX}TEMPLATES_SOURCE+=(\"${!TEMPLATE_SOURCE//\"/\\\"}\")"
echo "${PREFIX}TEMPLATES_REMOTE+=(\"${!TEMPLATE_REMOTE//\"/\\\"}\")"
if [[ "${!TEMPLATE_FETCH:-}" == "true" ]]; then
echo "${PREFIX}TEMPLATES_FETCH+=(true)"
else
echo "${PREFIX}TEMPLATES_FETCH+=(false)"
fi
echo "${PREFIX}TEMPLATES_CONFIG+=(\"${!TEMPLATE_CONFIG//\"/\\\"}\")"
echo "${PREFIX}TEMPLATES+=(\"${!TEMPLATE_SOURCE##*/}-$(md5_string ${!TEMPLATE_REMOTE:-local}:${!TEMPLATE_SOURCE})\")"
II=$((II+1))
TEMPLATE_SOURCE="${SOURCE_PREFIX}Templates_${II}_Source"
TEMPLATE_REMOTE="${SOURCE_PREFIX}Templates_${II}_Remote"
TEMPLATE_FETCH="${SOURCE_PREFIX}Templates_${II}_Fetch"
TEMPLATE_CONFIG="${SOURCE_PREFIX}Templates_${II}_Config"
done
# feeds
echo "${PREFIX}FEEDS=()"
echo "${PREFIX}FEEDS_NAME=()"
echo "${PREFIX}FEEDS_COUNT=()"
echo "${PREFIX}FEEDS_CONTENT=()"
echo "${PREFIX}FEEDS_TYPES=()"
echo "${PREFIX}FEEDS_EXCLUDED_STATES=()"
II=0
FEED="${SOURCE_PREFIX}Feeds_${II}_Path"
FEED_NAME="${SOURCE_PREFIX}Feeds_${II}_Name"
FEED_COUNT="${SOURCE_PREFIX}Feeds_${II}_Count"
FEED_CONTENT="${SOURCE_PREFIX}Feeds_${II}_Content"
while [[ "${!FEED:-}" != "" ]]; do
echo "${PREFIX}FEEDS+=(\"${!FEED//\"/\\\"}\")"
echo "${PREFIX}FEEDS_NAME+=(\"${!FEED_NAME//\"/\\\"}\")"
echo "${PREFIX}FEEDS_COUNT+=(\"${!FEEDS_COUNT//\"/\\\"}\")"
echo "${PREFIX}FEEDS_CONTENT+=(\"${!FEEDS_CONTENT//\"/\\\"}\")"
eval $(flat_to_array "FEED_TYPES" "${SOURCE_PREFIX}Feeds_${II}_Types_")
OIFS="${IFS}"; IFS=$(echo @|tr @ '\034'); echo "${PREFIX}FEEDS_TYPES+=(\"${FEED_TYPES[*]//\"/\\\"}\")"; IFS="${OIFS}"
eval $(flat_to_array "FEED_EXCLUDED_STATES" "${SOURCE_PREFIX}Feeds_${II}_Exclude_")
OIFS="${IFS}"; IFS=$(echo @|tr @ '\034'); echo "${PREFIX}FEEDS_EXCLUDED_STATES+=(\"${FEED_EXCLUDED_STATES[*]//\"/\\\"}\")"; IFS="${OIFS}"
II=$((II+1))
FEED="${SOURCE_PREFIX}Feeds_${II}_Path"
FEED_NAME="${SOURCE_PREFIX}Feeds_${II}_Name"
FEEDS_COUNT="${SOURCE_PREFIX}Feeds_${II}_Count"
FEEDS_CONTENT="${SOURCE_PREFIX}Feeds_${II}_Content"
done
# archives
echo "${PREFIX}ARCHIVES=()"
echo "${PREFIX}ARCHIVES_NAME=()"
echo "${PREFIX}ARCHIVES_COUNT=()"
echo "${PREFIX}ARCHIVES_CONTENT=()"
echo "${PREFIX}ARCHIVES_TYPES=()"
echo "${PREFIX}ARCHIVES_EXCLUDED_STATES=()"
II=0
ARCHIVE="${SOURCE_PREFIX}Archives_${II}_Path"
ARCHIVE_NAME="${SOURCE_PREFIX}Archives_${II}_Name"
ARCHIVE_COUNT="${SOURCE_PREFIX}Archives_${II}_Count"
ARCHIVE_CONTENT="${SOURCE_PREFIX}Archives_${II}_Content"
while [[ "${!ARCHIVE:-}" != "" ]]; do
echo "${PREFIX}ARCHIVES+=(\"${!ARCHIVE//\"/\\\"}\")"
echo "${PREFIX}ARCHIVES_NAME+=(\"${!ARCHIVE_NAME//\"/\\\"}\")"
echo "${PREFIX}ARCHIVES_COUNT+=(\"${!ARCHIVES_COUNT//\"/\\\"}\")"
echo "${PREFIX}ARCHIVES_CONTENT+=(\"${!ARCHIVES_CONTENT//\"/\\\"}\")"
eval $(flat_to_array "ARCHIVE_TYPES" "${SOURCE_PREFIX}Archives_${II}_Types_")
OIFS="${IFS}"; IFS=$(echo @|tr @ '\034'); echo "${PREFIX}ARCHIVES_TYPES+=(\"${ARCHIVE_TYPES[*]//\"/\\\"}\")"; IFS="${OIFS}"
eval $(flat_to_array "ARCHIVE_EXCLUDED_STATES" "${SOURCE_PREFIX}Archives_${II}_Exclude_")
OIFS="${IFS}"; IFS=$(echo @|tr @ '\034'); echo "${PREFIX}ARCHIVES_EXCLUDED_STATES+=(\"${ARCHIVE_EXCLUDED_STATES[*]//\"/\\\"}\")"; IFS="${OIFS}"
II=$((II+1))
ARCHIVE="${SOURCE_PREFIX}Archives_${II}_Path"
ARCHIVE_NAME="${SOURCE_PREFIX}Archives_${II}_Name"
ARCHIVES_COUNT="${SOURCE_PREFIX}Archives_${II}_Count"
ARCHIVES_CONTENT="${SOURCE_PREFIX}Archives_${II}_Content"
done
return 0
}
# copies files, fetching if necessary and authorized
function get_files { # get_files source dest force fetch uri
local SOURCE DEST FORCE FETCH URI
local SOURCE_DIR CACHE TYPE REMOTE FILES
SOURCE="${1:-}"
DEST="${2:-}"
if [[ "${SOURCE}" == "" ]]; then
echo "Internal error copying files: source empty" >&2
return 1
elif [[ "${DEST}" == "" ]]; then
echo "Internal error copying files: destination empty" >&2
return 1
fi
SOURCE_DIR="${SOURCE%/*}"
SOURCE_DIR="${SOURCE_DIR:-.}"
FORCE="${3:-}"
FETCH="${4:-}"
URI="${5:-}"
CACHE=$(md5_string "${URI}")
[[ "${CACHE}" == "" ]] && CACHE=$(md5_string "${SOURCE}")
CACHE="${MARSH_TEMP}/${CACHE}"
TYPE="file"
REMOTE=false
if [[ "${URI}" != "" ]]; then
if [[ "${URI}" =~ ^(git|https?|ssh): ]] || [[ "${URI}" =~ ^.+@.+: ]]; then
# remote git
TYPE="git"
REMOTE=true
elif [[ "${URI}" =~ ^file: ]] || [[ "${URI}" =~ .git$ ]]; then
# local git
TYPE="git"
fi
fi
if [[ "${REMOTE}" != true ]] || [[ "${FETCH}" == true ]]; then
# fetch unnecessary/approved
if [[ "${TYPE}" != "file" ]] && [[ ! -e "${CACHE}" ]]; then
# cache does not exist, create it
mkdir -p "${CACHE}"
if [[ "${TYPE}" == "git" ]]; then
# clone repository
echo "Retrieving source: ${URI}"
if ! "${GIT}" clone --depth 1 --recursive "${URI}" "${CACHE}" >/dev/null 2>&1; then
# unable to clone repository
echo "Unable to retrieve source: ${URI}" >&2
return 1
fi
fi
fi
if [[ "${TYPE}" == "git" ]]; then
# files path relative to cache
SOURCE="${CACHE}/${SOURCE}"
SOURCE_DIR="${SOURCE%/*}"
SOURCE_DIR="${SOURCE_DIR:-.}"
fi
# select files for copy
if [[ -d "${SOURCE}" ]]; then
# entire directory
FILES="${SOURCE#$SOURCE_DIR/}"
DEST="${DEST%/$FILES}"
FILES=("${FILES}")
else
# directory contents
OIFS="${IFS}"
IFS=$'\n'
FILES=($(cd "${SOURCE_DIR}" >/dev/null 2>&1 && find . -maxdepth 1 -name "${SOURCE##*/}" | sed -e 's/^\.\///' -e 's/^\.$//'))
[[ $? -ne 0 ]] && IFS="${OIFS}" && echo "Unable to change into directory: ${SOURCE_DIR}" >&2 && return 1
IFS="${OIFS}"
fi
# loop over files
for FILE in ${FILES[@]}; do
# sanity
if [[ "${SOURCE_DIR}/${FILE}" == "${DEST%/}/${FILE}" ]]; then
# same source and destination
echo "Source and destination paths are equal: ${DEST}" >&2
return 1
fi
if [[ -e "${DEST%/}/${FILE}" ]] && [[ "${FORCE}" != true ]]; then
# path exists
echo "Path exists (--force to overwrite): ${DEST%/}/${FILE}" >&2
return 1
fi
# create path
if ! mkdir -p "${DEST}"; then
echo "Unable to create path: ${DEST}" >&2
return 1
fi
if [[ -d "${SOURCE_DIR}/${FILE}" ]]; then
# clean destination
if ! rm -rf "${DEST%/}/${FILE}"; then
echo "Unable to replace path: ${DEST}" >&2
return 1
fi
fi
# copy
if ! cp -R "${SOURCE_DIR}/${FILE}" "${DEST%/}/${FILE}"; then
echo "Unable to copy file: ${SOURCE_DIR}/${FILE} -> ${DEST%/}/${FILE}" >&2
return 1
fi
done
return 0
else
# fetch not explicitly authorized
echo "Remote source not authorized (--fetch to override): ${URI}" >&2
return 1
fi
}
# builds an index of directory contents, sorted by descending date
function build_index { # build_index index_type target_dir dest_file dest_title content_length count #types[@] types[@] #excluded_states[@] excluded_states[@]
local INDEX_TYPE TARGET_DIR DEST DEST_SUB_PREFIX DEST_TITLE CONTENT COUNT NUM_TYPES TYPES NUM_EXCLUDED_STATES EXCLUDED_STATES
local VALID DOCUMENTS DOCUMENTS_MAX DOCUMENT_META_PREFIX DOCUMENT_META DOCUMENT_META_VARS
local DOCUMENT TITLE DATE DATE_PRETTY LANGCODE ENCODING STATE EXCLUDE DEST_SUB URI ABSPATH
# init
INDEX_TYPE="${1:-}"
if [[ "${INDEX_TYPE}" != "archive" ]] && [[ "${INDEX_TYPE}" != "feed" ]]; then
return 1
fi
shift 1
TARGET_DIR="${1:-}"; [[ "${TARGET_DIR}" == "" ]] && return 1
DEST="${2:-}"; [[ "${DEST}" == "" ]] && return 1
DEST="${TARGET_DIR}/${DEST}"
DEST_SUB_PREFIX="${DEST}.${MARSH_UID}.subdocuments"
DEST_TITLE="${3:-}"
CONTENT="${4:-}"
CONTENT_VALID=('excerpt' 'none' '')
if ! in_array "${CONTENT%%:*}" "${CONTENT_VALID[@]}"; then
echo "Invalid archive content type: ${CONTENT%%:*}" >&2
return 1
fi
COUNT="${5:-}"
shift 5
NUM_TYPES="${1:-0}"
shift 1
TYPES=()
while [[ "${NUM_TYPES}" -gt 0 ]] && [[ "${#@}" -gt 0 ]]; do
TYPES+=("${1}")
NUM_TYPES=$((NUM_TYPES - 1 ))
shift
done
NUM_EXCLUDED_STATES="${1:-0}"
shift 1
EXCLUDED_STATES=()
while [[ "${NUM_EXCLUDED_STATES}" -gt 0 ]] && [[ "${#@}" -gt 0 ]]; do
EXCLUDED_STATES+=("${1}")
NUM_EXCLUDED_STATES=$((NUM_EXCLUDED_STATES - 1 ))
shift
done
# create directory
mkdir -p "${DEST%/*}" >/dev/null 2>&1 || return 1
# write yaml header
echo "---" > "${DEST}" 2>/dev/null || return 1
echo "Type: ${INDEX_TYPE}" >> "${DEST}"
echo "Date: $(date -u '+%Y-%m-%d %H:%M:%S')" >> "${DEST}"
echo "Title: ${DEST_TITLE}" >> "${DEST}"
echo "Language: English" >> "${DEST}"
echo "Language_Code: en" >> "${DEST}"
echo "---" >> "${DEST}"
echo "" >> "${DEST}"
if [[ "${INDEX_TYPE}" == "archive" ]]; then
echo "# ${DEST_TITLE}" >> "${DEST}"
echo "" >> "${DEST}"
fi
# loop over documents
VALID=0
DOCUMENTS=$(cd "${TARGET_DIR}" && find . -name '*.'"${MARSH_UID}"'.document' | sed 's/^\.\///' | sort -nr -t/)
DOCUMENTS_MAX="${#DOCUMENTS[@]}"
DOCUMENTS_MAX=$((DOCUMENTS_MAX - 1))
for DOCUMENT in ${DOCUMENTS[@]}; do
if [[ "${COUNT}" != "" ]] && [[ "${VALID}" -ge "${COUNT}" ]]; then
break
fi
DOCUMENT_META_PREFIX=$(echo "marsh_meta_${DOCUMENT}_" | sed -E -e 's/[^A-Za-z0-9_]/_/g')
DOCUMENT_META=$(parse_yaml "${TARGET_DIR}/${DOCUMENT%.document}.meta.yaml" "${DOCUMENT_META_PREFIX}")
[[ $? -ne 0 ]] && echo "Unable to parse yaml file: ${TARGET_DIR}/${DOCUMENT%.document}.meta.yaml" >&2 && return 1
DOCUMENT_META_VARS=$(echo "${DOCUMENT_META}" | get_variables)
eval "${DOCUMENT_META}"
TYPE="${DOCUMENT_META_PREFIX}Type"
TYPE="${!TYPE:-}"
if [[ "${TYPE}" == "archive" ]] || [[ "${TYPE}" == "feed" ]]; then
# archives and feeds are skipped by default
continue
fi
if [[ "${#TYPES[@]}" -gt 0 ]] && ! in_array "${TYPE}" "${TYPES[@]}"; then
# skip type if not in list
continue
fi
if [[ "${#EXCLUDED_STATES[@]}" -gt 0 ]]; then
STATE="${DOCUMENT_META_PREFIX}State"
STATE="${!STATE}"
if [[ "${STATE}" != "" ]]; then
# deprecated (no brackets)
# Key: foo, bar, baz
STATE=(${STATE//, /})
else
# YAML inline array
# Key: [ foo, bar, baz ]
eval $(flat_to_array "STATE" "${DOCUMENT_META_PREFIX}State_")
fi
for E in "${EXCLUDED_STATES[@]}"; do
if in_array "${E}" "${STATE[@]}"; then
# skip excluded state
continue 2
fi
done
fi
# valid subdocument
VALID=$((VALID + 1))
DEST_SUB="${DEST_SUB_PREFIX}.$((VALID-1))"
# process text
if [[ "${CONTENT}" == "none" ]]; then
touch "${DEST_SUB}.document"
elif [[ "${CONTENT}" != "" ]]; then
<"${TARGET_DIR:-.}/${DOCUMENT}" text_filter headings:push "${CONTENT}" "wrap:div.$(echo ${CONTENT} | sed -e 's/:[^ ]//g' -e 's/ /./g')" >> "${DEST_SUB}.document"
else
<"${TARGET_DIR:-.}/${DOCUMENT}" text_filter headings:push >> "${DEST_SUB}.document"
fi
# copy metadata
cp "${TARGET_DIR}/${DOCUMENT%.document}.meta.yaml" "${DEST_SUB}.meta.yaml.temp" >/dev/null 2>&1
# store paths (cannot calculate original path later)
URI="${TARGET_DIR#$MARSH_CONFIG_PATH}"
URI="${MARSH_CONFIG_URL%/}/${URI#/}/${DOCUMENT%.${MARSH_UID}.document}"
URI="${URI%.markdown}.html"
ABSPATH=""
[[ "${URI}" =~ / ]] && ABSPATH="${URI%/*}"
<"${DEST_SUB}.meta.yaml.temp" sed -e '/^\.\.\.$/d' > "${DEST_SUB}.meta.yaml"
echo "---" >> "${DEST_SUB}.meta.yaml"
echo "ABSPATH: ${ABSPATH}" >> "${DEST_SUB}.meta.yaml"
echo "URI: ${URI}" >> "${DEST_SUB}.meta.yaml"
echo "..." >> "${DEST_SUB}.meta.yaml"
# unset temporary global variables
for VAR in ${DOCUMENT_META_VARS[@]}; do unset "${VAR}"; done
done
return 0
}
# builds advanced navigation
function build_advanced_nav { # build_advanced_nav target_dir navigation_file
local TARGET_DIR NAV_NAME
local NAV_TARGETS NAV_DEST
# init
TARGET_DIR="${1:-}"; [[ "${TARGET_DIR}" == "" ]] && return 1
NAV_NAME="${2:-}"; [[ "${NAV_NAME}" == "" ]] && return 1
NAV_TARGETS=$(cd "${TARGET_DIR}" && find . -name "${NAV_NAME}" | sed 's/^\.\///')
for NAV_TARGET in ${NAV_TARGETS[@]}; do
NAV_TARGET="${TARGET_DIR}/${NAV_TARGET}"
NAV_DEST="${NAV_TARGET}.${MARSH_UID}.advanced-nav.html"
cp "${NAV_TARGET}" "${NAV_DEST}"
if head -n 1 "${NAV_DEST}" 2>/dev/null | grep -E '^---[ ]*(#.*)?$' >/dev/null 2>&1; then
# remove yaml
<"${NAV_DEST}" tail -n +$(awk '{ drop = 0; } /^---[ ]*(#.*)?$/ { if (NR==1) { drop = 1 } else if (NR>1) { exit } else { drop = 0; next } } drop == 0 { print }' "${NAV_DEST}" | wc -l | awk '{ print $1+3 }') > "${NAV_DEST}.temp"
else
cp "${NAV_DEST}" "${NAV_DEST}.temp"
fi
<"${NAV_DEST}.temp" process_markdown > "${NAV_DEST}"
rm -f "${NAV_DEST}.temp"
done
}
# builds a template and applies it to a document
function build_template { # build_template dest_dir target_dir document templates_dir template template_config_extra
function process_authors { # process_authors dest_array source_array
local DEST_ARRAY SOURCE_ARRAY ITEM
DEST_ARRAY="${1:-}"
[[ "${DEST_ARRAY}" == "" ]] && return 1
SOURCE_ARRAY="${2:-}"
[[ "${SOURCE_ARRAY}" == "" ]] && return 1
echo "${DEST_ARRAY}=()"
SOURCE_ARRAY="${SOURCE_ARRAY}[@]"
for ITEM in "${!SOURCE_ARRAY}"; do
ITEM=$(echo "${ITEM}" | sed -E -e 's/[ ]+<[^>]+>//g' -e 's/[ ]/\\\&nbsp\\\;/g')
echo "${DEST_ARRAY}+=(\"${ITEM}\")"
done
return 0
}
function process_conditionals { # process_conditionals file tag comparitor list[@]
local FILE TAG COMPARITOR LIST
local FILE_TEMP
FILE="${1:-}"; [[ "${FILE}" == "" ]] && return 1
TAG="${2:-}"; [[ "${TAG}" == "" ]] && return 1
COMPARITOR="${3:-}"; [[ "${COMPARITOR}" == "" ]] && return 1
LIST="${4:-}"; [[ "${LIST}" == "" ]] && return 1
LIST=(${4:-})
FILE_TEMP=$(mktemp "${MARSH_TEMP}/conditional-XXXXXX")
# process match
for ITEM in ${LIST[@]}; do
cp "${FILE}" "${FILE_TEMP}"
<"${FILE_TEMP}" \
awk '/^[ ]*\{\%[ ]*if[ ]+'${TAG//\./\.}'[ ]+'${COMPARITOR// /[ ]+}'[ ]+"'${ITEM}'"[ ]*\%\}[ ]*$/ {
tag=1;
line=1;
delete buffer;
}
{
buffer[line++]=$0;
}
(tag==1 && (/^[ ]*\{\%[ ]*endif[ ]*\%\}[ ]*$/ || /^[ ]*\{\%[ ]*else[ ]*\%\}[ ]*$/)) {
for (i=2; i < line-1; i++) {
print buffer[i];
}
}
(tag>0 && /^[ ]*\{\%[ ]*else[ ]*\%\}[ ]*$/) {
tag=2;
next;
}
(tag>0 && /^[ ]*\{\%[ ]*endif[ ]*\%\}[ ]*$/) {
tag=0;
next;
}
(tag==0) {
print;
}' \
> "${FILE}"
done
# process else
cp "${FILE}" "${FILE_TEMP}"
<"${FILE_TEMP}" \
awk '/^[ ]*\{\%[ ]*if[ ]+'${TAG//\./\.}'[ ]+'${COMPARITOR// /[ ]+}'[ ]+".+"[ ]*\%\}[ ]*$/ {
tag=1;
line=1;
delete buffer;
}
{
buffer[line++]=$0;
}
(tag==1) {
delete buffer;
}
(tag==2 && /^[ ]*\{\%[ ]*endif[ ]*\%\}[ ]*$/) {
for (i=2; i < line-1; i++) {
print buffer[i];
}
}
(tag>0 && /^[ ]*\{\%[ ]*else[ ]*\%\}[ ]*$/) {
tag=2;
next;
}
(tag>0 && /^[ ]*\{\%[ ]*endif[ ]*\%\}[ ]*$/) {
tag=0;
next;
}
(tag==0) {
print;
}' \
> "${FILE}"
}
function clean_conditionals { # clean_conditionals file
local FILE FILE_TEMP
FILE="${1:-}"; [[ "${FILE}" == "" ]] && return 1
FILE_TEMP=$(mktemp "${MARSH_TEMP}/conditional-XXXXXX")
# remove unsupported conditionals
cp "${FILE}" "${FILE_TEMP}"
<"${FILE_TEMP}" awk '/^[ ]*\{\%[ ]*if[^%]+\%\}[ ]*$/ {k=1;i=1;delete a} {a[i++]=$0} (k==1 && /^[ ]*\{\%[ ]*endif[ ]*\%\}[ ]*$/) {k=0;next} (k==0) { print }' > "${FILE}"
return 0
}
function replace_tags { # replace_tags document prefix
local DOCUMENT PREFIX
local TAGS TAG_ESC TAG_VAL TAG_NAME TAG_FILTERS TAG_VAR TAG_READFILE
# init
DOCUMENT="${1:-}"
PREFIX="${2:-}"
[[ "${DOCUMENT}" == "" ]] && return 1
# find template tags
OIFS="${IFS}"
IFS=$'\n'
TAGS=($(<"${DOCUMENT}" grep -Eo '\{\{[ ]*([a-z][a-z0-9-]*(\.[a-z][a-z0-9-]*)?)[ ]*(([ ]*\|[ ]*[a-z][a-z0-9-]*(\:[a-z0-9][a-z0-9-]*)*)*)[ ]*\}\}'))
IFS="${OIFS}"
# loop over tags
for I in "${!TAGS[@]}"; do
TAG_ESC=$(echo "${TAGS[$I]}" | sed 's/[][/.|$(){}?+*^]/\\&/g')
TAG_VAL=$(echo "${TAGS[$I]}" | sed -E -e 's/\{\{[ ]*([a-z][a-z0-9-]*(\.[a-z][a-z0-9-]*)?)[ ]*(([ ]*\|[ ]*[a-z][a-z0-9-]*(\:[a-z0-9][a-z0-9-]*)*)*)[ ]*\}\}/\1\3/')
TAG_NAME="${TAG_VAL%%|*}"
TAG_FILTERS="${TAG_VAL#$TAG_NAME}"
TAG_FILTERS=(${TAG_FILTERS//|/ })
TAG_READFILE=false
# map tag to variable
case "${TAG_NAME}" in
base.relpath)
TAG_VAR="${PREFIX}RELPATH"
;;
document.relpath)
TAG_VAR="${PREFIX}RELPATH"
;;
base.abspath)
TAG_VAR="${PREFIX}ABSPATH"
;;
document.abspath)
TAG_VAR="${PREFIX}ABSPATH"
;;
document.uri)
TAG_VAR="${PREFIX}URI"
;;
document)
TAG_VAR="${PREFIX}CONTENT"
TAG_READFILE=true
;;
document.authors)
TAG_VAR="${PREFIX}AUTHORS"
;;
document.copyright)
TAG_VAR="${PREFIX}Copyright"
;;
document.credits-url)
TAG_VAR="${PREFIX}Credits_URL"
;;
document.date)
TAG_VAR="${PREFIX}Date"
;;
document.language)
TAG_VAR="${PREFIX}Language"
;;
document.language-code)
TAG_VAR="${PREFIX}Language_Code"
;;
document.license)
TAG_VAR="${PREFIX}License"
;;
document.license-abbr)
TAG_VAR="${PREFIX}License_Abbr"
;;
document.license-url)
TAG_VAR="${PREFIX}License_URL"
;;
document.project)
TAG_VAR="${PREFIX}Project"
;;
document.project-version)
TAG_VAR="${PREFIX}Project_Version"
;;
document.project-url)
TAG_VAR="${PREFIX}Project_URL"
;;
document.redirect-url)
TAG_VAR="${PREFIX}Redirect_URL"
;;
document.state)
TAG_VAR="${PREFIX}State"
;;
document.title)
TAG_VAR="${PREFIX}Title"
;;
document.type)
TAG_VAR="${PREFIX}Type"
;;
*)
TAG_VAR=""
;;
esac
if [[ "${TAG_VAR}" != "" ]]; then
if [[ "${TAG_READFILE}" == true ]]; then
if [[ -f "${!TAG_VAR}" ]] && [[ -r "${!TAG_VAR}" ]]; then
TAG_VAR=$(<"${!TAG_VAR}")
else
return 1
fi
else
TAG_VAR="${!TAG_VAR}"
fi
TAG_VAR=$(echo "${TAG_VAR}" | text_filter "${TAG_FILTERS[@]}" | sed -e ':a' -e '$!{N' -e 'ba' -e '}' -e 's/[&/\]/\\&/g' -e 's/\n/\\&/g')
TAG_VAR=${TAG_VAR%$'\n'}
sed -E \
-e "/${TAG_ESC}/s//${TAG_VAR:-}/g" \
-i".${MARSH_UID}.backup" "${DOCUMENT}" && rm -f "${DOCUMENT}.${MARSH_UID}.backup"
else
# ignore unknown tags
:
fi
done
}
local DEST_DIR TARGET_DIR DOCUMENT TEMPLATE_DIR TEMPLATE TEMPLATE_CONFIG_EXTRA
local DOCUMENT_META DOCUMENT_META_VARS
local SUBDOCUMENTS
local INDEX DOCUMENT_AUTHORS
local TEMPLATE_PREFIX TEMPLATE_META TEMPLATE_META_VARS PARTIALS TEMPLATE_BASE TEMPLATE_TEMP
local NAV NAV_DIR NAV_NAME NAV_RELPATH
local TEMPLATE_STYLES TEMPLATE_SCRIPTS
# init
DEST_DIR="${1:-.}"
DEST_DIR="${DEST_DIR%/}"
TARGET_DIR="${2:-.}"
TARGET_DIR="${TARGET_DIR%/}"
DOCUMENT="${3:-}"
[[ "${DOCUMENT}" == "" ]] && return 1
DOCUMENT_EXT="${DOCUMENT##*.}"
DOCUMENT_DIR="./${DOCUMENT}"
DOCUMENT_DIR="${DOCUMENT_DIR%/*}"
DOCUMENT_DIR="${DOCUMENT_DIR#./}"
DOCUMENT_RELPATH="${DOCUMENT#./}" # strip current dir
DOCUMENT_RELPATH="${DOCUMENT_RELPATH//[^\/]}" # leave only slashes
DOCUMENT_RELPATH="${DOCUMENT_RELPATH//[\/]/../}" # slashes to dirs
DOCUMENT_RELPATH="${DOCUMENT_RELPATH:-./}" # empty to current dir
DOCUMENT_ABSPATH="${MARSH_CONFIG_URL:-}"
DOCUMENT_ABSPATH="${DOCUMENT_ABSPATH%/}/${TARGET_DIR}/${DOCUMENT_DIR}"
DOCUMENT_ABSPATH="${DOCUMENT_ABSPATH%/.}"
DEST="${DOCUMENT}"
DEST_NAME="${DEST%.$DOCUMENT_EXT}"
DEST_NAME="${DEST_NAME##*/}"
if echo "${DOCUMENT_EXT}" | grep -Ei '^(markdown|md|mkd|mkdn|mdown)$' >/dev/null 2>&1; then
DEST="${DEST%.*}.html"
fi
DEST="${DEST_DIR}/${TARGET_DIR}/${DEST}"
DOCUMENT="${DEST_DIR}/${TARGET_DIR}/${DOCUMENT}"
DOCUMENT_URI="${DOCUMENT_ABSPATH:+$DOCUMENT_ABSPATH/}${DEST##*/}"
TEMPLATE_DIR="${4:-}"
TEMPLATE="${5:-}"
TEMPLATE_CONFIG_EXTRA="${6:-}"
# verbosity
# seems logical to put this elsewhere, but this is a good catch-all for now
if [[ ! -e "${DEST}" ]]; then
echo " ${DEST#$DEST_DIR/}"
fi
# document
DOCUMENT_CONTENT="${DOCUMENT}.${MARSH_UID}.document"
[[ -e "${DOCUMENT_CONTENT}" ]] || return 1
# document metadata
if [[ -f "${DOCUMENT}.${MARSH_UID}.meta.yaml" ]] && [[ -r "${DOCUMENT}.${MARSH_UID}.meta.yaml" ]]; then
# parse metadata
DOCUMENT_META=$(parse_yaml "${DOCUMENT}.${MARSH_UID}.meta.yaml" "DOCUMENT_")
[[ $? -ne 0 ]] && echo "Unable to parse yaml file: ${DOCUMENT}.${MARSH_UID}.meta.yaml" >&2 && return 1
DOCUMENT_META_VARS=$(echo "${DOCUMENT_META}" | sed -E -e 's/^([^=]+)=.*/\1/')
eval "${DOCUMENT_META}"
fi
# authors
if [[ "${DOCUMENT_Authors}" != "" ]]; then
# deprecated (no brackets)
# Key: foo, bar, baz
#DOCUMENT_AUTHORS=$(echo "${DOCUMENT_Authors}" | sed -e 's/,[^ ]/, /g' -e 's/[ ]*<[^,]*>//g' -e 's/\(.*\), /\1, and /' -e 's/\([^,]\) /\1\\\&nbsp;/g')
DOCUMENT_AUTHORS=$(echo "${DOCUMENT_Authors}" | sed -e 's/,[^ ]/, /g' -e 's/[ ]*<[^,]*>//g' -e 's/\(.*\), /\1, and /')
DELIM_NUM=$(grep -o ',' <<< "${DOCUMENT_AUTHORS}" | wc -l)
if [[ "${DELIM_NUM}" -eq 1 ]]; then
DOCUMENT_AUTHORS=$(echo "${DOCUMENT_AUTHORS}" | sed -e 's/,//')
fi
else
# YAML inline array
# Key: [ foo, bar, baz ]
DOCUMENT_AUTHORS=()
eval $(flat_to_array "DOCUMENT_Authors" "DOCUMENT_Authors_")
eval $(process_authors "DOCUMENT_AUTHORS" "DOCUMENT_Authors")
DOCUMENT_AUTHORS=$(join_delimited ', ' ' and ' ', and ' ${DOCUMENT_AUTHORS[@]})
fi
# state
if [[ "${DOCUMENT_State}" != "" ]]; then
# deprecated (no brackets)
# Key: foo, bar, baz
DOCUMENT_State=(${DOCUMENT_State//, /})
else
# YAML inline array
# Key: [ foo, bar, baz ]
eval $(flat_to_array "DOCUMENT_State" "DOCUMENT_State_")
fi
# template
if [[ "${TEMPLATE_DIR}" != "" ]]; then
TEMPLATE_PREFIX="TEMPLATE_"
TEMPLATE_META=$(parse_template_metadata "${TEMPLATE_PREFIX}" "${TEMPLATE_DIR}/${TEMPLATE}" "${TEMPLATE_CONFIG_EXTRA}")
[[ $? -ne 0 ]] && return 1
TEMPLATE_META_VARS=$(echo "${TEMPLATE_META}" | get_variables)
eval "${TEMPLATE_META}"
# partials
PARTIALS=("${TEMPLATE_Template_Partials_Redirect:-}" "${TEMPLATE_Template_Partials_Base:-}" "${TEMPLATE_Template_Partials_Body:-}" "${TEMPLATE_Template_Partials_Archive:-}" "${TEMPLATE_Template_Partials_Document:-}" "${TEMPLATE_Template_Partials_Header:-}" "${TEMPLATE_Template_Partials_Footer:-}" "${TEMPLATE_Template_Partials_Nav:-}")
# conditionals
for J in "${!PARTIALS[@]}"; do
[[ "${PARTIALS[$J]}" == "" ]] && continue
# grep to avoid unnecessary processing
if [[ "$(<${PARTIALS[$J]} grep -Eo '\{\%[ ]*if[ ]+')" != "" ]]; then
# template contains conditionals, operate using a copy
TEMPLATE_TEMP=$(mktemp "${MARSH_TEMP}/template-XXXXXX")
cp "${PARTIALS[$J]}" "${TEMPLATE_TEMP}"
PARTIALS[$J]="${TEMPLATE_TEMP}"
# process
process_conditionals "${PARTIALS[$J]}" "document.state" "contains" "${DOCUMENT_State[@]}"
process_conditionals "${PARTIALS[$J]}" "document.type" "contains" "${DOCUMENT_Type[@]}"
# remove remaining conditionals
clean_conditionals "${PARTIALS[$J]}"
fi
done
TEMPLATE_Template_Partials_Redirect="${PARTIALS[0]:-}"
TEMPLATE_Template_Partials_Base="${PARTIALS[1]:-}"
TEMPLATE_Template_Partials_Body="${PARTIALS[2]:-}"
TEMPLATE_Template_Partials_Archive="${PARTIALS[3]:-}"
TEMPLATE_Template_Partials_Document="${PARTIALS[4]:-}"
TEMPLATE_Template_Partials_Header="${PARTIALS[5]:-}"
TEMPLATE_Template_Partials_Footer="${PARTIALS[6]:-}"
TEMPLATE_Template_Partials_Nav="${PARTIALS[7]:-}"
TEMPLATE_Template_Partials_Feed_Body="${TEMPLATE_Template_Partials_Feed_Body:-}"
TEMPLATE_Template_Partials_Feed_Document="${TEMPLATE_Template_Partials_Feed_Document:-}"
if [[ "${DOCUMENT_Type}" == "feed" ]]; then
if [[ "${TEMPLATE_Template_Partials_Feed_Body:-}" != "" ]]; then
cp "${TEMPLATE_Template_Partials_Feed_Body}" "${DEST}"
else
continue
fi
else
# body template
if [[ ! -e "${DEST}" ]]; then
if [[ "${TEMPLATE_Template_Partials_Body}" != "" ]]; then
cp "${TEMPLATE_Template_Partials_Body}" "${DEST}"
else
echo "Body partial not found for primary template: ${TEMPLATE}" >&2
return 1
fi
fi
# base template
if [[ "${DOCUMENT_Redirect_URL:-}" != "" ]]; then
# redirect
TEMPLATE_BASE="${TEMPLATE_Template_Partials_Redirect}"
fi
TEMPLATE_BASE="${TEMPLATE_BASE:-$TEMPLATE_Template_Partials_Base}"
if [[ "${TEMPLATE_BASE}" != "" ]]; then
# inject into base template
if [[ -f "${TEMPLATE_BASE}" ]] && [[ -r "${TEMPLATE_BASE}" ]]; then
cp "${DEST}" "${DEST}.${MARSH_UID}.temp"
cp "${TEMPLATE_BASE}" "${DEST}"
SUB=$(<"${DEST}.${MARSH_UID}.temp" sed -e ':a' -e '$!{N' -e 'ba' -e '}' -e 's/[&/\]/\\&/g' -e 's/\n/\\&/g')
SUB=${SUB%$'\n'}
SUB=${SUB%\\}
sed -E \
-e "/\{\{[ ]*template\.body[ ]*\}\}/s//${SUB:-}/g" \
-i".${MARSH_UID}.backup" "${DEST}" && rm -f "${DEST}.${MARSH_UID}.backup"
unset SUB
fi
fi
# remaining templates
if [[ -f "${TEMPLATE_Template_Partials_Archive}" ]] && [[ -r "${TEMPLATE_Template_Partials_Archive}" ]]; then
SUB=$(<"${TEMPLATE_Template_Partials_Archive}" sed -e ':a' -e '$!{N' -e 'ba' -e '}' -e 's/[&/\]/\\&/g' -e 's/\n/\\&/g')
SUB=${SUB%$'\n'}
SUB=${SUB%\\}
sed -E \
-e "/\{\{[ ]*template\.archive[ ]*\}\}/s//${SUB:-}/g" \
-i".${MARSH_UID}.backup" "${DEST}" && rm -f "${DEST}.${MARSH_UID}.backup"
unset SUB
fi
if [[ -f "${TEMPLATE_Template_Partials_Document}" ]] && [[ -r "${TEMPLATE_Template_Partials_Document}" ]]; then
SUB=$(<"${TEMPLATE_Template_Partials_Document}" sed -e ':a' -e '$!{N' -e 'ba' -e '}' -e 's/[&/\]/\\&/g' -e 's/\n/\\&/g')
SUB=${SUB%$'\n'}
SUB=${SUB%\\}
sed -E \
-e "/\{\{[ ]*template\.document[ ]*\}\}/s//${SUB:-}/g" \
-i".${MARSH_UID}.backup" "${DEST}" && rm -f "${DEST}.${MARSH_UID}.backup"
unset SUB
fi
if [[ -f "${TEMPLATE_Template_Partials_Header}" ]] && [[ -r "${TEMPLATE_Template_Partials_Header}" ]]; then
SUB=$(<"${TEMPLATE_Template_Partials_Header}" sed -e ':a' -e '$!{N' -e 'ba' -e '}' -e 's/[&/\]/\\&/g' -e 's/\n/\\&/g')
SUB=${SUB%$'\n'}
SUB=${SUB%\\}
sed -E \
-e "/\{\{[ ]*template\.header[ ]*\}\}/s//${SUB:-}/g" \
-i".${MARSH_UID}.backup" "${DEST}" && rm -f "${DEST}.${MARSH_UID}.backup"
unset SUB
fi
if [[ -f "${TEMPLATE_Template_Partials_Footer}" ]] && [[ -r "${TEMPLATE_Template_Partials_Footer}" ]]; then
SUB=$(<"${TEMPLATE_Template_Partials_Footer}" sed -e ':a' -e '$!{N' -e 'ba' -e '}' -e 's/[&/\]/\\&/g' -e 's/\n/\\&/g')
SUB=${SUB%$'\n'}
SUB=${SUB%\\}
sed -E \
-e "/\{\{[ ]*template\.footer[ ]*\}\}/s//${SUB:-}/g" \
-i".${MARSH_UID}.backup" "${DEST}" && rm -f "${DEST}.${MARSH_UID}.backup"
unset SUB
fi
if [[ -f "${TEMPLATE_Template_Partials_Nav}" ]] && [[ -r "${TEMPLATE_Template_Partials_Nav}" ]]; then
SUB=$(<"${TEMPLATE_Template_Partials_Nav}" sed -e ':a' -e '$!{N' -e 'ba' -e '}' -e 's/[&/\]/\\&/g' -e 's/\n/\\&/g')
SUB=${SUB%$'\n'}
SUB=${SUB%\\}
sed -E \
-e "/\{\{[ ]*template\.nav[ ]*\}\}/s//${SUB:-}/g" \
-i".${MARSH_UID}.backup" "${DEST}" && rm -f "${DEST}.${MARSH_UID}.backup"
unset SUB
fi
# scripts and styles
TEMPLATE_SCRIPTS=""
for SCRIPT in ${TEMPLATE_ASSETS_SCRIPTS[@]}; do
TEMPLATE_SCRIPTS="${TEMPLATE_SCRIPTS}<script src=\"${DOCUMENT_RELPATH}${SCRIPT}\"></script>"
done
TEMPLATE_SCRIPTS=$(echo "${TEMPLATE_SCRIPTS}" | sed -e ':a' -e '$!{N' -e 'ba' -e '}' -e 's/[&/\]/\\&/g' -e 's/\n/\\&/g')
TEMPLATE_STYLES=""
for STYLE in ${TEMPLATE_ASSETS_STYLES[@]}; do
TEMPLATE_STYLES="${TEMPLATE_STYLES}<link rel=\"stylesheet\" href=\"${DOCUMENT_RELPATH}${STYLE}\" />"
done
TEMPLATE_STYLES=$(echo "${TEMPLATE_STYLES}" | sed -e ':a' -e '$!{N' -e 'ba' -e '}' -e 's/[&/\]/\\&/g' -e 's/\n/\\&/g')
sed -E \
-e '/\{\{[ ]*template\.scripts[ ]*\}\}/s||'"${TEMPLATE_SCRIPTS}"'|g' \
-e '/\{\{[ ]*template\.styles[ ]*\}\}/s||'"${TEMPLATE_STYLES}"'|g' \
-i".${MARSH_UID}.backup" "${DEST}" && rm -f "${DEST}.${MARSH_UID}.backup"
# advanced navigation
for NAV in $(cd "${DEST_DIR}/${TARGET_DIR}" && find . -name "*.${MARSH_UID}.advanced-nav.html" | sed 's/^\.\///'); do
NAV_NAME="${NAV##*/}"
NAV_NAME="${NAV_NAME%.$MARSH_UID.advanced-nav.html}.html"
NAV_NAME=$(echo "${NAV_NAME}" | sed -E -e 's/\.(markdown|md|mkd|mkdn|mdown)(.html)$/\2/')
NAV_DIR="./${NAV}"
NAV_DIR="${NAV_DIR%/*}"
NAV_DIR="${NAV_DIR#./}"
if is_child "${DEST_DIR}/${TARGET_DIR}/${NAV_DIR}" "${DOCUMENT}"; then
NAV_RELPATH="${DOCUMENT_DIR#$NAV_DIR}"
NAV_RELPATH="${NAV_RELPATH//[^\/]}" # leave only slashes
NAV_RELPATH="${NAV_RELPATH//[\/]/../}" # slashes to dirs
NAV_RELPATH="${NAV_RELPATH:-.}" # empty to current dir
NAV_RELPATH="${NAV_RELPATH%/}" # drop trailing slash
<"${DEST_DIR}/${TARGET_DIR}/${NAV}" sed -E \
-e 's|<h1>([^<]+)</h1>|<h1><a href="'"${NAV_RELPATH}/${NAV_NAME}"'">\1</a></h1>|' \
-e 's|(<a href=")([^.])|\1'"${NAV_RELPATH}/"'\2|g' \
-e 's|<a (href="[^"]*'"${DEST_NAME}.html"'"[^>]*)>([^<>]+)</a>|<a \1 class="selected">\2</a>|g' \
> "${DEST}.${MARSH_UID}.temp"
SUB=$(<"${DEST}.${MARSH_UID}.temp" sed -e ':a' -e '$!{N' -e 'ba' -e '}' -e 's/[&/\]/\\&/g' -e 's/\n/\\&/g')
SUB=${SUB%$'\n'}
SUB=${SUB%\\}
sed -E \
-e "/\{\{[ ]*navigation[ ]*\}\}/s//${SUB}/g" \
-i".${MARSH_UID}.backup" "${DEST}" && rm -f "${DEST}.${MARSH_UID}.backup"
unset SUB
fi
done
sed -E \
-e 's/\{\{[ ]*navigation[ ]*\}\}//g' \
-i".${MARSH_UID}.backup" "${DEST}" && rm -f "${DEST}.${MARSH_UID}.backup"
fi # DOCUMENT_Type == "feed" else
# remove unused/unknown template includes
sed -E \
-e '/\{\{[ ]*template(\.[a-z]+)?[ ]*\}\}/s///' \
-i".${MARSH_UID}.backup" "${DEST}" && rm -f "${DEST}.${MARSH_UID}.backup"
# template tags
replace_tags "${DEST}" "DOCUMENT_"
# subdocuments
OIFS="${IFS}"
IFS=$'\n'
SUBDOCUMENTS=($(cd "${DEST_DIR}/${TARGET_DIR}/${DOCUMENT_DIR}" && find . -name "${DEST_NAME}${DOCUMENT_EXT:+.$DOCUMENT_EXT}.*" | grep -E '.+\.'"${MARSH_UID}"'\.subdocuments\.[0-9]+\.document$' | sed 's/^\.\///' | sed -E -e 's/(\.'"${MARSH_UID}"'\.subdocuments\.)/\1\|/' | sort -t \| -k2 -g | sed -E -e 's/(\.'"${MARSH_UID}"'\.subdocuments\.)\|/\1/'))
IFS="${OIFS}"
if [[ "${#SUBDOCUMENTS[@]}" -gt 0 ]]; then
for J in ${!SUBDOCUMENTS[@]}; do
# full path
SUBDOCUMENT="${DEST_DIR}/${TARGET_DIR}/${DOCUMENT_DIR}/${SUBDOCUMENTS[$J]}"
# document metadata
if [[ -f "${SUBDOCUMENT%.document}.meta.yaml" ]] && [[ -r "${SUBDOCUMENT%.document}.meta.yaml" ]]; then
# parse metadata
SUBDOCUMENT_META=$(parse_yaml "${SUBDOCUMENT%.document}.meta.yaml" "SUBDOCUMENT_")
[[ $? -ne 0 ]] && echo "Unable to parse yaml file: ${SUBDOCUMENT%.document}.meta.yaml" >&2 && return 1
SUBDOCUMENT_META_VARS=$(echo "${SUBDOCUMENT_META}" | sed -E -e 's/^([^=]+)=.*/\1/')
eval "${SUBDOCUMENT_META}"
fi
cp "${SUBDOCUMENT}" "${SUBDOCUMENT}.document"
SUBDOCUMENT_CONTENT="${SUBDOCUMENT}.document"
# authors
if [[ "${SUBDOCUMENT_Authors}" != "" ]]; then
# deprecated (no brackets)
# Authors: foo, bar, baz
#SUBDOCUMENT_AUTHORS=$(echo "${SUBDOCUMENT_Authors}" | sed -e 's/,[^ ]/, /g' -e 's/[ ]*<[^,]*>//g' -e 's/\(.*\), /\1, and /' -e 's/\([^,]\) /\1\\\&nbsp;/g')
SUBDOCUMENT_AUTHORS=$(echo "${SUBDOCUMENT_Authors}" | sed -e 's/,[^ ]/, /g' -e 's/[ ]*<[^,]*>//g' -e 's/\(.*\), /\1, and /')
DELIM_NUM=$(grep -o ',' <<< "${SUBDOCUMENT_AUTHORS}" | wc -l)
if [[ "${DELIM_NUM}" -eq 1 ]]; then
SUBDOCUMENT_AUTHORS=$(echo "${SUBDOCUMENT_AUTHORS}" | sed -e 's/,//')
fi
else
# YAML inline array
# Authors: [ foo, bar, baz ]
SUBDOCUMENT_AUTHORS=()
eval $(flat_to_array "SUBDOCUMENT_Authors" "SUBDOCUMENT_Authors_")
eval $(process_authors "SUBDOCUMENT_AUTHORS" "SUBDOCUMENT_Authors")
SUBDOCUMENT_AUTHORS=$(join_delimited ', ' ' and ' ', and ' ${SUBDOCUMENT_AUTHORS[@]})
fi
# state
if [[ "${SUBDOCUMENT_State}" != "" ]]; then
# deprecated (no brackets)
# Key: foo, bar, baz
SUBDOCUMENT_State=(${SUBDOCUMENT_State//, /})
else
# YAML inline array
# Key: [ foo, bar, baz ]
eval $(flat_to_array "SUBDOCUMENT_State" "SUBDOCUMENT_State_")
fi
if [[ "${DOCUMENT_Type}" == "feed" ]]; then
# document template
if [[ "${TEMPLATE_Template_Partials_Feed_Document:-}" != "" ]]; then
cp "${SUBDOCUMENT}" "${SUBDOCUMENT}.document"
cp "${TEMPLATE_Template_Partials_Feed_Document}" "${SUBDOCUMENT}"
fi
else
# markdown to html
<"${SUBDOCUMENT}" process_markdown > "${SUBDOCUMENT}.document"
# document template
cp "${TEMPLATE_Template_Partials_Document}" "${SUBDOCUMENT}"
fi
# inject html into template
SUB=$(<"${SUBDOCUMENT}.document" sed -e ':a' -e '$!{N' -e 'ba' -e '}' -e 's/[&/\]/\\&/g' -e 's/\n/\\&/g')
SUB=${SUB%$'\n'}
SUB=${SUB%\\}
sed -E \
-e "/\{\{[ ]*document[ ]*\}\}/s//${SUB}/g" \
-i".${MARSH_UID}.backup" "${SUBDOCUMENT}" && rm -f "${SUBDOCUMENT}.${MARSH_UID}.backup"
unset SUB
sed -E \
-e 's/\{\{[ ]*subdocuments[ ]*\}\}//g' \
-i".${MARSH_UID}.backup" "${SUBDOCUMENT}" && rm -f "${SUBDOCUMENT}.${MARSH_UID}.backup"
# template tags
replace_tags "${SUBDOCUMENT}" "SUBDOCUMENT_"
# combine with previous subdocuments
cat "${SUBDOCUMENT}" >> "${DOCUMENT}.${MARSH_UID}.subdocuments"
# unset temporary global variables
for VAR in ${SUBDOCUMENT_META_VARS[@]}; do unset "${VAR}"; done
done
cp "${DEST}" "${DEST}.temp"
<"${DEST}.temp" awk 'BEGIN { while (getline < "'"${DOCUMENT}.${MARSH_UID}.subdocuments"'") txt=txt $0 "\n"; gsub(/[&]/, "\\\\&", txt) } /\{\{[ ]*subdocuments[ ]*\}\}/{ gsub(/\{\{[ ]*subdocuments[ ]*\}\}/, txt) } 1' > "${DEST}"
fi
# unset temporary global variables
for VAR in ${TEMPLATE_META_VARS[@]}; do unset "${VAR}"; done
else
cp "${DOCUMENT_CONTENT}" "${DEST}"
fi # TEMPLATE_DIR != "" else
# smart comment tags
sed -E \
-e 's|<!--[ ]*([a-z]+)\.([^ ]*)[ ]*(.*)-->|<\1 class="\2" \3>|g' \
-e 's|<!--[ ]*([a-z]+)\#([^ ]*)[ ]*(.*)-->|<\1 id="\2" \3>|g' \
-e 's|<!--[ ]*\/([a-z]+)([.#])([^ ]*)[ ]*-->|</\1><!-- end \1\2\3 -->|g' \
-e 's|<!--[ ]*\.([^ ]*)[ ]*(.*)-->|<div class="\1" \2>|g' \
-e 's|<!--[ ]*\#([^ ]*)[ ]*(.*)-->|<div id="\1" \2>|g' \
-e 's|<!--[ ]*\/([.#])([^ ]*)[ ]*-->|</div><!-- end div\1\2 -->|g' \
-i".${MARSH_UID}.backup" "${DEST}" && rm -f "${DEST}.${MARSH_UID}.backup"
# multiple classes foo.bar.baz to foo bar baz
sed -E \
-e ':a' -e 's|class="([^."]+)\.([^"]+)"|class="\1 \2"|g' -e 'ta' \
-i".${MARSH_UID}.backup" "${DEST}" && rm -f "${DEST}.${MARSH_UID}.backup"
# unwrap figures
sed -E \
-e 's|<p><figure>|<figure>|' \
-e 's|</figure></p>|</figure>|' \
-i".${MARSH_UID}.backup" "${DEST}" && rm -f "${DEST}.${MARSH_UID}.backup"
# unset temporary global variables
for VAR in ${DOCUMENT_META_VARS[@]}; do unset "${VAR}"; done
}
# builds a document from a single file
function build_document { # build_document dest_dir target_dir document advanced_nav_name
local DEST_DIR TARGET_DIR DOCUMENT ADVANCED_NAV
local DOCUMENT_EXT DEST DEST_NAME
# init
DEST_DIR="${1:-.}"
DEST_DIR="${DEST_DIR%/}"
TARGET_DIR="${2:-.}"
TARGET_DIR="${TARGET_DIR%/}"
DOCUMENT="${3:-}"
[[ "${DOCUMENT}" == "" ]] && return 1
DOCUMENT_EXT="${DOCUMENT##*.}"
DOCUMENT_DIR="./${DOCUMENT}"
DOCUMENT_DIR="${DOCUMENT_DIR%/*}"
DOCUMENT_DIR="${DOCUMENT_DIR#./}"
DOCUMENT="${DEST_DIR}/${TARGET_DIR}/${DOCUMENT}"
TEMPLATE_DIR="${4:-}"
TEMPLATE_CONFIG_EXTRA="${5:-}"
ADVANCED_NAV="${6:-}"
ADVANCED_NAV="${ADVANCED_NAV%.$DOCUMENT_EXT}"
# normalize extensions
if echo "${DOCUMENT_EXT}" | grep -Ei '^(markdown|md|mkd|mkdn|mdown)$' >/dev/null 2>&1; then
DOCUMENT_EXT="markdown"
fi
# skip existing final document
if [[ "${DOCUMENT_EXT}" == "markdown" ]] && [[ -e "${DOCUMENT%.*}.html" ]]; then
return 0
fi
# split yaml and markdown, keep original
if head -n 1 "${DOCUMENT}" 2>/dev/null | grep -E '^---[ ]*(#.*)?$' >/dev/null 2>&1; then
echo "---" > "${DOCUMENT}.${MARSH_UID}.meta.yaml"
<"${DOCUMENT}" awk '{ drop = 0; } /^---[ ]*(#.*)?$/ { if (NR==1) { drop = 1 } else if (NR>1) { exit } else { drop = 0; next } } drop == 0 { print }' >> "${DOCUMENT}.${MARSH_UID}.meta.yaml"
<"${DOCUMENT}" tail -n +$(wc -l "${DOCUMENT}.${MARSH_UID}.meta.yaml" | awk '{ print $1+3 }') > "${DOCUMENT}.${MARSH_UID}.document"
echo "..." >> "${DOCUMENT}.${MARSH_UID}.meta.yaml"
fi
if [[ "${DOCUMENT_EXT}" == "markdown" ]]; then
# preprocess markdown to add implicit figures
# convert preprocessed markdown to html
cp "${DOCUMENT}.${MARSH_UID}.document" "${DOCUMENT}.${MARSH_UID}.document.temp"
<"${DOCUMENT}.${MARSH_UID}.document.temp" sed -E \
-e 's|^!\[(.+)]\([ ]*([^ ]+)[ ]*"(.+)"[ ]*\)$|<figure><a href="\2"><img src="\2" alt="\1" /></a><figcaption>\3</figcaption></figure>|' |
process_markdown > "${DOCUMENT}.${MARSH_UID}.document"
fi
# unset temporary global variables
for VAR in ${DOCUMENT_META_VARS[@]}; do unset "${VAR}"; done
}
# builds a target, parallel if possible
function build_target { # build_target dest_dir target advanced_nav templates_dir #templates[@] templates[@] #templates_config_extra[@] templates_config_extra[@]
local DEST_DIR TARGET ADVANCED_NAV TEMPLATES_DIR NUM_TEMPLATES TEMPLATES NUM_TEMPLATES_CONFIG_EXTRA TEMPLATES_CONFIG_EXTRA
local TEMPLATE_META TEMPLATE_META_VARS
local TARGET_DIR TEMPLATE_PREFIX DOCUMENTS PARALLEL
# init
DEST_DIR="${1:-.}"
DEST_DIR="${DEST_DIR%/}"
TARGET="${2:-}"
TARGET="${TARGET%/}"
TARGET_DIR="${TARGET%/*}"
TARGET_DIR="${TARGET_DIR:-.}"
TARGET="${TARGET:-*}"
ADVANCED_NAV="${3:-}"
TEMPLATES_DIR="${4:-}"
shift 4
NUM_TEMPLATES="${1:-0}"
shift 1
TEMPLATES=()
while [[ "${NUM_TEMPLATES}" -gt 0 ]] && [[ "${#@}" -gt 0 ]]; do
TEMPLATES+=("${1}")
NUM_TEMPLATES=$((NUM_TEMPLATES - 1 ))
shift
done
NUM_TEMPLATES_CONFIG_EXTRA="${1:-0}"
shift 1
TEMPLATES_CONFIG_EXTRA=()
while [[ "${NUM_TEMPLATES_CONFIG_EXTRA}" -gt 0 ]] && [[ "${#@}" -gt 0 ]]; do
TEMPLATES_CONFIG_EXTRA+=("${1}")
NUM_TEMPLATES_CONFIG_EXTRA=$((NUM_TEMPLATES_CONFIG_EXTRA - 1 ))
shift
done
# copy template assets
if [[ "${TEMPLATES_DIR}" != "" ]]; then
for I in "${!TEMPLATES[@]}"; do
TEMPLATE_PREFIX="TEMPLATE_"
TEMPLATE_META=$(parse_template_metadata "${TEMPLATE_PREFIX}" "${TEMPLATES_DIR}/${TEMPLATES[$I]}" "${TEMPLATES_CONFIG_EXTRA[$I]}")
[[ $? -ne 0 ]] && return 1
TEMPLATE_META_VARS=$(echo "${TEMPLATE_META}" | get_variables)
eval "${TEMPLATE_META}"
for ASSET in ${TEMPLATE_ASSETS_FONTS[@]} ${TEMPLATE_ASSETS_STYLES[@]} ${TEMPLATE_ASSETS_SCRIPTS[@]}; do
ASSET="${ASSET%\?*}"
if [[ -d "${TEMPLATES_DIR}/${TEMPLATES[$I]}/${ASSET}" ]]; then
mkdir -p "${DEST_DIR}/${TARGET_DIR}/${ASSET}"
elif [[ -f "${TEMPLATES_DIR}/${TEMPLATES[$I]}/${ASSET}" ]]; then
mkdir -p "${DEST_DIR}/${TARGET_DIR}/${ASSET%/*}"
fi
if [[ -e "${TEMPLATES_DIR}/${TEMPLATES[$I]}/${ASSET}" ]] && [[ -r "${TEMPLATES_DIR}/${TEMPLATES[$I]}/${ASSET}" ]]; then
cp -R "${TEMPLATES_DIR}/${TEMPLATES[$I]}/${ASSET}" "${DEST_DIR}/${TARGET_DIR}/${ASSET}"
fi
done
# unset temporary global variables
for VAR in ${TEMPLATE_META_VARS[@]}; do unset "${VAR}"; done
done
fi
# build target documents
if [[ "${TARGET}" == '*' ]]; then
DOCUMENTS=$(cd "${DEST_DIR}/${TARGET_DIR}" && find *)
elif [[ -d "${DEST_DIR}/${TARGET}" ]]; then
DOCUMENTS=$(cd "${DEST_DIR}/${TARGET}" && find .)
else
DOCUMENTS=$(cd "${DEST_DIR}/${TARGET_DIR}" && find "${TARGET##*/}")
fi
DOCUMENTS=$(echo "${DOCUMENTS}" | grep -Ei '\.(markdown|md|mkd|mkdn|mdown|xml)$' | sed 's/^\.\///')
PARALLEL=$(which parallel)
if [[ "${JOBS}" != 1 ]] && [[ "${PARALLEL:-}" != "" ]] && [[ "$(${PARALLEL} --version --no-notice 2>/dev/null | head -n 1 | grep -o 'GNU parallel')" == "GNU parallel" ]]; then
# in parallel
export -f build_document
if ! "${PARALLEL}" --halt now,fail=1 --no-notice "${JOBS:+--jobs=$JOBS}" "${SELF_DIR}/${SELF}" build-document "${DEST_DIR}" "${TARGET_DIR}" {} {} ::: "${DOCUMENTS[@]}" ::: "${ADVANCED_NAV}"; then
echo "Unable to build template: ${TEMPLATES[$I]}"
return 1
fi
if [[ "${TEMPLATES_DIR}" != "" ]] && [[ "${#TEMPLATES[@]}" -gt 0 ]]; then
export -f build_template
for I in "${!TEMPLATES[@]}"; do
if ! "${PARALLEL}" --halt now,fail=1 --no-notice "${JOBS:+--jobs=$JOBS}" "${SELF_DIR}/${SELF}" build-templates "${DEST_DIR}" "${TARGET_DIR}" {} "${TEMPLATES_DIR}" "${TEMPLATES[$I]}" "${TEMPLATES_CONFIG_EXTRA[$I]:-}" ::: "${DOCUMENTS[@]}"; then
echo "Unable to build template: ${TEMPLATES[$I]}"
return 1
fi
done
fi
else
# serially
for DOCUMENT in ${DOCUMENTS[@]}; do
if ! build_document "${DEST_DIR}" "${TARGET_DIR}" "${DOCUMENT}" "${ADVANCED_NAV}"; then
echo "Unable to build document: ${DOCUMENT}"
return 1
fi
if [[ "${TEMPLATES_DIR}" != "" ]] && [[ "${#TEMPLATES[@]}" -gt 0 ]]; then
for I in "${!TEMPLATES[@]}"; do
if ! build_template "${DEST_DIR}" "${TARGET_DIR}" "${DOCUMENT}" "${TEMPLATES_DIR}" "${TEMPLATES[$I]}" "${TEMPLATES_CONFIG_EXTRA[$I]:-}"; then
echo "Unable to build template: ${TEMPLATES[$I]}"
return 1
fi
done
fi
done
fi
}
# removes temporary files used during target builds
function clean_target { # clean_target target
local TARGET
TARGET="${1:-}"; [[ "${TARGET}" == "" ]] && return 1
find "${TARGET}" \( -iname '*.markdown' -or -iname '*.md' -or -iname '*.mkd' -or -iname '*.mkdn' -or -iname '*.mdown' -or -iname '*.marsh.feed' -or -name '*.'"${MARSH_UID}"'.*' \) -delete
}
# commands
COMMANDS=('build' 'build-document' 'build-templates')
COMMAND="${1:-}"
# validate command
if [[ ! "${COMMAND}" =~ ^- ]]; then
if [[ "${COMMAND}" == "" ]]; then
# command not specified
echo "Command not specified" >&2
echo -e "${HELP}"
exit 1
elif ! in_array "${COMMAND}" "${COMMANDS[@]}"; then
# invalid command
echo "Invalid command: ${COMMAND}" >&2
echo -e "${HELP}"
exit 1
fi
shift 1
else
# continue processing arguments
COMMAND=""
fi
# args
FETCH=false
FORCE=false
JOBS=""
MARKDOWN=""
OPTIND=1
OPTSPEC=":-:hvj:"
OPTARRAY=('-h' '--help' '-v' '--version' '--fetch' '--force' '-j' '--jobs' '--markdown' '--markdown-options') # all short and long options
while getopts "${OPTSPEC}" OPT; do
case "${OPT}" in
-)
case "${OPTARG}" in
help)
# Print help and exit
echo -e "${HELP}"
exit 0
;;
help=*)
# Print help and exit
echo -e "${HELP}"
exit 0
;;
version)
# Print version and exit
echo -e "${NAME} ${VERSION}"
exit 0
;;
version=*)
# Print version and exit
echo -e "${NAME} ${VERSION}"
exit 0
;;
jobs)
if [[ -z ${!OPTIND+isset} ]] || in_array "${!OPTIND}" "${OPTARRAY[@]}"; then
# Option without required argument
echo "Option --${OPTARG} requires a value" >&2
echo -e "${HELP}"
exit 1
fi
JOBS="${!OPTIND}"
if [[ ! "${JOBS}" =~ ^[1-9][0-9]*$ ]]; then
echo "Option --${OPTARG} requires a numeric value greater than zero" >&2
echo -e "${HELP}"
exit 1
fi
OPTIND=$((OPTIND + 1))
;;
jobs=*)
JOBS="${OPTARG#*=}"
if [[ ! "${JOBS}" =~ ^[1-9][0-9]*$ ]]; then
echo "Option --${OPTARG} requires a numeric value greater than zero" >&2
echo -e "${HELP}"
exit 1
fi
;;
markdown-options)
if [[ -z ${!OPTIND+isset} ]] || in_array "${!OPTIND}" "${OPTARRAY[@]}"; then
# Option without required argument
echo "Option --${OPTARG} requires a value" >&2
echo -e "${HELP}"
exit 1
fi
MARKDOWN_OPTIONS="${!OPTIND}"
OIFS="${IFS}"
IFS=$'\n'
MARKDOWN_OPTIONS=(${MARKDOWN_OPTIONS//,/$IFS})
IFS="${OIFS}"
OPTIND=$((OPTIND + 1))
;;
markdown-options=*)
MARKDOWN_OPTIONS="${OPTARG#*=}"
OIFS="${IFS}"
IFS=$'\n'
MARKDOWN_OPTIONS=(${MARKDOWN_OPTIONS//,/$IFS})
IFS="${OIFS}"
;;
markdown)
if [[ -z ${!OPTIND+isset} ]] || in_array "${!OPTIND}" "${OPTARRAY[@]}"; then
# Option without required argument
echo "Option --${OPTARG} requires a value" >&2
echo -e "${HELP}"
exit 1
fi
MARKDOWN="${!OPTIND}"
OPTIND=$((OPTIND + 1))
;;
markdown=*)
MARKDOWN="${OPTARG#*=}"
;;
fetch)
FETCH=true
;;
fetch=*)
# Option with prohibited value
echo "Option --${OPTARG%%=*} takes no value" >&2
echo -e "${HELP}"
exit 1
;;
force)
FORCE=true
;;
force=*)
# Option with prohibited value
echo "Option --${OPTARG%%=*} takes no value" >&2
echo -e "${HELP}"
exit 1
;;
*)
if [[ "${OPTERR}" == 1 ]]; then
# Invalid option specified
echo "Invalid option: --${OPTARG}" >&2
echo -e "${HELP}"
exit 1
fi
;;
esac
;;
h)
# Print help and exit
echo -e "${HELP}"
exit 0
;;
v)
# Print version and exit
echo "${NAME} ${VERSION}"
exit 0
;;
j)
# Number of jobs
JOBS="${OPTARG}"
if [[ ! "${JOBS}" =~ ^[1-9][0-9]*$ ]]; then
echo "Option -${OPT} requires a numeric value greater than zero" >&2
echo -e "${HELP}"
exit 1
fi
;;
:)
# Option without required value
echo "Option -${OPTARG} requires a value" >&2
echo -e "${HELP}"
exit 1
;;
\?)
# Invalid option specified
echo "Invalid option: -${OPTARG}" >&2
echo -e "${HELP}"
exit 1
;;
esac
done
shift $((OPTIND - 1))
# revalidate command
if [[ "${COMMAND}" == "" ]]; then
# command not specified
echo "Command not specified" >&2
echo -e "${HELP}"
exit 1
elif ! in_array "${COMMAND}" "${COMMANDS[@]}"; then
# invalid command
echo "Invalid command: ${COMMAND}" >&2
echo -e "${HELP}"
exit 1
fi
# parse config
if [[ "${MARSH_CONFIG_FILE:-}" == "" ]]; then
MARSH_CONFIG_FILE="${1:-$SELF_DIR}"
if [[ -d "${MARSH_CONFIG_FILE}" ]]; then
MARSH_CONFIG_FILE="$(cd ${MARSH_CONFIG_FILE} && (pwd -P . 2>/dev/null || command pwd))"
[[ "${MARSH_CONFIG_FILE}" != "" ]] && MARSH_CONFIG_FILE="${MARSH_CONFIG_FILE%/}/config.yaml"
fi
if [[ -f "${MARSH_CONFIG_FILE}" ]] && [[ -r "${MARSH_CONFIG_FILE}" ]]; then
MARSH_CONFIG=$(parse_yaml "${MARSH_CONFIG_FILE}" "CONFIG_")
[[ $? -ne 0 ]] && echo "Unable to parse yaml file: ${MARSH_CONFIG_FILE}" >&2 && return 1
eval "${MARSH_CONFIG}"
else
echo "Configuration file not found: ${MARSH_CONFIG_FILE#$SELF_DIR/}" >&2
exit 1
fi
if [[ "${CONFIG_Build_Path:-}" != "" ]]; then
MARSH_CONFIG_PATH="${CONFIG_Build_Path}"
[[ "${MARSH_CONFIG_FILE}" =~ / ]] && MARSH_CONFIG_FILE_DIR="${MARSH_CONFIG_FILE%/*}"
MARSH_CONFIG_FILE_DIR="${MARSH_CONFIG_FILE_DIR:-.}"
[[ ! "${MARSH_CONFIG_PATH}" =~ ^/ ]] && MARSH_CONFIG_PATH="${MARSH_CONFIG_FILE_DIR}/${MARSH_CONFIG_PATH}"
MARSH_CONFIG_PATH="${MARSH_CONFIG_PATH#./}"
else
echo "Build directory empty or not found in config: ${MARSH_CONFIG_FILE}" >&2
exit 1
fi
MARSH_CONFIG_URL="${CONFIG_Build_URL:-}"
export MARSH_CONFIG_FILE MARSH_CONFIG_FILE_DIR MARSH_CONFIG_PATH MARSH_CONFIG_URL
fi
# dependencies
GIT="git"
MD5="md5sum"
[[ "$(uname | awk '{ print tolower($0) }')" == "darwin" ]] && MD5="md5"
MARKDOWN="${MARKDOWN:-markdown}"
MARKDOWN_VERSION_REQ="2.2.1"
DEPS_MISSING=()
dependency_exists "${MD5}" || DEPS_MISSING+=("${MD5}")
if dependency_exists "${GIT}"; then
GIT_VERSION=$("${GIT}" --version | head -n 1 | sed -E -e 's/^git +version +([0-9]+(\.[0-9]+(\.[0-9]+)?)?).*$/\1/')
[[ $(version "${GIT_VERSION:-}") -ge $(version "2.3") ]] && export GIT_TERMINAL_PROMPT=0
else
DEPS_MISSING+=("${GIT}")
fi
if dependency_exists "${MARKDOWN}"; then
MARKDOWN_VERSION=$("${MARKDOWN%%\ *}" -V | head -n 1 | sed -E -e 's/^markdown: +discount +([0-9]+(\.[0-9]+(\.[0-9]+)?)?).*$/\1/')
[[ $(version "${MARKDOWN_VERSION:-}") -ge $(version "${MARKDOWN_VERSION_REQ}") ]] || DEPS_MISSING+=("${MARKDOWN}")
else
DEPS_MISSING+=("${MARKDOWN}")
fi
if [[ "${#DEPS_MISSING[@]}" -gt 0 ]]; then
in_array "${MD5}" "${DEPS_MISSING[@]}" && print_dependency "md5sum (md5 on Darwin/macOS)"
in_array "${GIT}" "${DEPS_MISSING[@]}" && print_dependency "Git" "https://git-scm.com/"
in_array "${MARKDOWN}" "${DEPS_MISSING[@]}" && print_dependency "Discount markdown" "http://www.pell.portland.or.us/~orc/Code/discount/" "${MARKDOWN_VERSION_REQ:-}" "${MARKDOWN_VERSION:-}"
exit 1
fi
# discount markdown options
if [[ -z ${MARKDOWN_OPTIONS+isset} ]]; then
MARKDOWN_OPTIONS=(${MARKDOWN_OPTIONS_DEFAULT[@]})
fi
for I in "${!MARKDOWN_OPTIONS[@]}"; do
MARKDOWN_OPTIONS[$I]="-f${MARKDOWN_OPTIONS[$I]}"
done
OIFS="${IFS}"
IFS=$'\n'
MARKDOWN_UNKNOWN=($(echo "test options" | "${MARKDOWN}" ${MARKDOWN_OPTIONS[@]} -VV 2>&1 >/dev/null | grep -i "unknown" | sed -E -e 's/^markdown: unknown option <([^>]+)>$/\1/'))
IFS="${OIFS}"
if [[ "${#MARKDOWN_UNKNOWN[@]}" -gt 0 ]]; then
echo -n "Unknown markdown options:" >&2
for UNKNOWN in "${MARKDOWN_UNKNOWN[@]}"; do
echo -n " '${UNKNOWN}'" >&2
done
echo ""
exit
fi
function process_markdown {
# re[lv]="footnote" is not valid html5; remove it
if [[ "${#MARKDOWN_OPTIONS[@]}" -gt 0 ]]; then
"${MARKDOWN}" ${MARKDOWN_OPTIONS[@]} ${@} | sed -E -e '/<a href="#[a-z]+:[^"]+" re[lv]="footnote">/s/ re[lv]="footnote"//g'
else
"${MARKDOWN}" ${@} | sed -E -e '/<a href="#[a-z]+:[^"]+" re[lv]="footnote">/s/ re[lv]="footnote"//g'
fi
}
export -f process_markdown
# create target directory
mkdir -p "${MARSH_CONFIG_PATH}"
# keep temporary directory creation close to trap to catch quick SIGINT
# temporary directory
if [[ "${MARSH_UID:-}" == "" ]]; then
MARSH_TEMP=$(mktemp -d "${TMPDIR:-/tmp/}marsh-XXXXXX")
MARSH_UID="marsh-${MARSH_TEMP##*marsh-}"
export MARSH_TEMP MARSH_UID
fi
TEMPLATES_DIR="${MARSH_TEMP}/templates"
mkdir -p "${TEMPLATES_DIR}"
# kills child processes and removes temporary files
function die_gracefully { # die_gracefully
trap - EXIT INT
trap ":" INT # prevent recursion due to spamming ctrl-c
echo "Killing all processes and cleaning up (ETA ~3 seconds)..." >&2
#trap - INT && kill -2 -- -$$ # should not be needed with `parallel --halt now,fail=1 ...`
sleep 2
rm -rf "${MARSH_TEMP}" || "Temporary files may still remain at: ${MARSH_TEMP}" >&2
sleep 1
trap - TERM && kill -- -$$
}
# work
if [[ "${COMMAND}" == "build" ]]; then
# die gracefully
trap "die_gracefully" EXIT INT TERM
# build everything
echo "${CONFIG_Build_Namex:-No Name} (${MARSH_CONFIG_FILE#$SELF_DIR/})"
echo "${CONFIG_Build_Path%/} -> ${CONFIG_Build_URL%/}"
# build
INDEX=0
PREFIX="CONFIG_Build_Targets_${INDEX}_"
while META=$(get_target_metadata "${PREFIX}" "TARGET_"); do
eval "${META}"
META_VARS=$(echo "${META}" | get_variables)
# get template
for I in "${!TARGET_TEMPLATES[@]}"; do
if [[ ! -e "${TEMPLATES_DIR}/${TARGET_TEMPLATES[$I]}" ]]; then
# fetch remote?
if [[ "${TARGET_TEMPLATES_FETCH[$I]}" == true ]] || [[ "${FETCH}" == true ]]; then
TARGET_TEMPLATES_FETCH[$I]=true
fi
if [[ "${TARGET_TEMPLATES_REMOTE[$I]}" == "" ]] && [[ ! "${TARGET_TEMPLATES_SOURCE[$I]}" =~ ^/ ]]; then
TARGET_TEMPLATES_SOURCE[$I]="${MARSH_CONFIG_FILE_DIR}/${TARGET_TEMPLATES_SOURCE[$I]}"
TARGET_TEMPLATES_SOURCE[$I]="${TARGET_TEMPLATES_SOURCE[$I]#./}"
fi
if [[ "${TARGET_TEMPLATES_CONFIG[$I]}" != "" ]] && [[ ! "${TARGET_TEMPLATES_CONFIG[$I]}" =~ ^/ ]]; then
TARGET_TEMPLATES_CONFIG[$I]="${MARSH_CONFIG_FILE_DIR}/${TARGET_TEMPLATES_CONFIG[$I]}"
TARGET_TEMPLATES_CONFIG[$I]="${TARGET_TEMPLATES_CONFIG[$I]#./}"
fi
get_files "${TARGET_TEMPLATES_SOURCE[$I]}/*" \
"${TEMPLATES_DIR}/${TARGET_TEMPLATES[$I]}" \
false \
"${TARGET_TEMPLATES_FETCH[$I]}" \
"${TARGET_TEMPLATES_REMOTE[$I]}" || die_gracefully
fi
done
# get source files for target
if [[ "${TARGET_FORCE}" == true ]] || [[ "${FORCE}" == true ]]; then
TARGET_FORCE=true
fi
if [[ "${TARGET_FETCH}" == true ]] || [[ "${FETCH}" == true ]]; then
TARGET_FETCH=true
fi
if [[ "${TARGET_REMOTE}" == "" ]] && [[ ! "${TARGET_SOURCE}" =~ ^/ ]]; then
TARGET_SOURCE="${MARSH_CONFIG_FILE_DIR}/${TARGET_SOURCE}"
TARGET_SOURCE="${TARGET_SOURCE#./}"
fi
if [[ "${TARGET_SOURCE}" != "" ]]; then
get_files "${TARGET_SOURCE}" \
"${MARSH_CONFIG_PATH}/${TARGET_PATH}" \
"${TARGET_FORCE}" \
"${TARGET_FETCH}" \
"${TARGET_REMOTE}" || die_gracefully
fi
# build advanced navigation
if [[ "${TARGET_NAV}" != "" ]]; then
build_advanced_nav "${MARSH_CONFIG_PATH}/${TARGET_PATH}" \
"${TARGET_NAV}" || die_gracefully
fi
# build target
build_target "${MARSH_CONFIG_PATH}" \
"${TARGET_PATH}" \
"${TARGET_NAV}" \
"${TEMPLATES_DIR}" \
"${#TARGET_TEMPLATES[@]}" \
"${TARGET_TEMPLATES[@]}" \
"${#TARGET_TEMPLATES_CONFIG[@]}" \
"${TARGET_TEMPLATES_CONFIG[@]}" || die_gracefully
# archives
for I in "${!TARGET_ARCHIVES[@]}"; do
if [[ "${TARGET_ARCHIVES[$I]}" != "" ]]; then
OIFS="${IFS}"
IFS=$(echo @|tr @ '\034')
TARGET_ARCHIVE_TYPES=(${TARGET_ARCHIVES_TYPES[$I]:-})
TARGET_ARCHIVE_EXCLUDED_STATES=(${TARGET_ARCHIVES_EXCLUDED_STATES[$I]:-})
IFS="${OIFS}"
if ! build_index "archive" \
"${MARSH_CONFIG_PATH}/${TARGET_PATH}" \
"${TARGET_ARCHIVES[$I]}" \
"${TARGET_ARCHIVES_NAME[$I]:-$TARGET_NAME}" \
"${TARGET_ARCHIVES_CONTENT[$I]}" \
"${TARGET_ARCHIVES_COUNT[$I]}" \
"${#TARGET_ARCHIVE_TYPES[@]}" \
"${TARGET_ARCHIVE_TYPES[@]}" \
"${#TARGET_ARCHIVE_EXCLUDED_STATES[@]}" \
"${TARGET_ARCHIVE_EXCLUDED_STATES[@]}" \
|| ! build_target "${MARSH_CONFIG_PATH}" \
"${TARGET_PATH}/${TARGET_ARCHIVES[$I]}" \
"" \
"${TEMPLATES_DIR}" \
"${#TARGET_TEMPLATES[@]}" \
"${TARGET_TEMPLATES[@]}" \
"${#TARGET_TEMPLATES_CONFIG[@]}" \
"${TARGET_TEMPLATES_CONFIG[@]}"
then
die_gracefully
fi
unset TARGET_ARCHIVE_TYPES TARGET_ARCHIVE_EXCLUDED_STATES
fi
done
# feeds
for I in "${!TARGET_FEEDS[@]}"; do
if [[ "${TARGET_FEEDS[$I]}" != "" ]]; then
OIFS="${IFS}"
IFS=$(echo @|tr @ '\034')
TARGET_FEED_TYPES=(${TARGET_FEEDS_TYPES[$I]:-})
TARGET_FEED_EXCLUDED_STATES=(${TARGET_FEEDS_EXCLUDED_STATES[$I]:-})
IFS="${OIFS}"
if ! build_index "feed" \
"${MARSH_CONFIG_PATH}/${TARGET_PATH}" \
"${TARGET_FEEDS[$I]}" \
"${TARGET_FEEDS_NAME[$I]:-$TARGET_NAME}" \
"${TARGET_FEEDS_CONTENT[$I]}" \
"${TARGET_FEEDS_COUNT[$I]}" \
"${#TARGET_FEEDS_TYPES[@]}" \
"${TARGET_FEEDS_TYPES[@]}" \
"${#TARGET_FEEDS_EXCLUDED_STATES[@]}" \
"${TARGET_FEEDS_EXCLUDED_STATES[@]}" \
|| ! build_target "${MARSH_CONFIG_PATH}" \
"${TARGET_PATH}/${TARGET_FEEDS[$I]}" \
"" \
"${TEMPLATES_DIR}" \
"${#TARGET_TEMPLATES[@]}" \
"${TARGET_TEMPLATES[@]}" \
"${#TARGET_TEMPLATES_CONFIG[@]}" \
"${TARGET_TEMPLATES_CONFIG[@]}"
then
die_gracefully
fi
unset TARGET_FEED_TYPES TARGET_FEED_EXCLUDED_STATES
fi
done
# clean build files
clean_target "${MARSH_CONFIG_PATH}/${TARGET_PATH}"
# unset temporary global variables
for VAR in ${META_VARS[@]}; do unset "${VAR}"; done
INDEX=$((INDEX+1))
PREFIX="CONFIG_Build_Targets_${INDEX}_"
done
# clean up
rm -rf "${MARSH_TEMP}"
trap - EXIT INT TERM
elif [[ "${COMMAND}" == "build-document" ]]; then
# build single document
build_document "${@}"
elif [[ "${COMMAND}" == "build-templates" ]]; then
# build templates for document
build_template "${@}"
fi
# done
exit 0
Reference in New Issue View Git Blame Copy Permalink