806 lines
24 KiB
Bash
Executable File
806 lines
24 KiB
Bash
Executable File
#!/bin/bash
|
|
# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
|
|
|
function display_help() {
|
|
uecho "$scriptname: Outils pour gérer une installation de DokuWiki
|
|
|
|
USAGE
|
|
$scriptname cmd [options]
|
|
|
|
COMMANDES
|
|
newpage titre
|
|
Créer une nouvelle page avec le titre spécifié
|
|
newlog [titre]
|
|
Créer une nouvelle page datée du jour. Equivalent à newpage --log.
|
|
find filtre
|
|
Chercher les pages dont le nom correspondent au filtre
|
|
edit filtre
|
|
Editer la première page qui correspond au filtre
|
|
commit [msg]
|
|
Enregistrer les modifications dans le gestionnaire de version.
|
|
sync
|
|
Synchroniser un dokuwiki local vers une installation système. Requière
|
|
les droits de root.
|
|
generate srcdir
|
|
Générer la documentation du projet srcdir dans un espace de nom"
|
|
}
|
|
|
|
SCRIPT_ALIASES=(
|
|
dwa:newpage
|
|
dwl:find
|
|
dwe:edit
|
|
dwci:commit
|
|
dwsync:sync
|
|
)
|
|
|
|
if [ "$#" -eq 1 -a "$1" == --nutools-makelinks ]; then
|
|
# créer les liens
|
|
scriptname="$(basename "$0")"
|
|
for alias in "${SCRIPT_ALIASES[@]}"; do
|
|
alias="${alias%:*}"
|
|
ln -s "$scriptname" "$alias"
|
|
done
|
|
exit 0
|
|
fi
|
|
|
|
source "$(dirname "$0")/lib/ulib/ulib" || exit 1
|
|
urequire DEFAULTS
|
|
|
|
# Traduire le nom du script
|
|
for script_alias in "${SCRIPT_ALIASES[@]}"; do
|
|
splitpair "$script_alias" src dest
|
|
if [ "$scriptname" == "$src" ]; then
|
|
eval "set -- $dest \"\$@\""
|
|
scriptname=dokuwiki
|
|
break
|
|
fi
|
|
done
|
|
|
|
DWCOMMIT=1
|
|
set_defaults dokuwiki
|
|
|
|
function __check_dwdir0() {
|
|
[ -f "$1/doku.php" -a -d "$1/data/pages" -a -d "$1/data/media" ]
|
|
}
|
|
function __check_dwdir1() {
|
|
[ -f "$1/.dokuwiki" ]
|
|
}
|
|
function __check_dwdir() {
|
|
__check_dwdir0 "$1" && return 0
|
|
__check_dwdir1 "$1" && return 0
|
|
return 1
|
|
}
|
|
function find_dwdir() {
|
|
# trouver le répertoire du dokuwiki correspondant au répertoire $1 et
|
|
# retourner 0. Retourner 1 si $1 n'est pas dans un répertoire de dokuwiki.
|
|
local dwdir="$(abspath "${1:-.}")"
|
|
while [ "$dwdir" != "/" ]; do
|
|
if __check_dwdir "$dwdir"; then
|
|
echo "$dwdir"
|
|
return 0
|
|
fi
|
|
dwdir="$(dirname "$dwdir")"
|
|
done
|
|
if [ -n "$DOKUWIKIDIR" ] && __check_dwdir "$DOKUWIKIDIR"; then
|
|
echo "$(abspath "$DOKUWIKIDIR")"
|
|
return 0
|
|
fi
|
|
return 1
|
|
}
|
|
|
|
function get_pagesdir() {
|
|
# Obtenir le répertoire des pages du dokuwiki $1, qui a déjà été normalisé
|
|
# avec find_dwdir()
|
|
if [ -f "$1/doku.php" ]; then
|
|
echo "$1/data/pages"
|
|
elif [ -f "$1/.dokuwiki" ]; then
|
|
echo "$1"
|
|
fi
|
|
}
|
|
function get_mediadir() {
|
|
# Obtenir le répertoire de media du dokuwiki $1, qui a déjà été normalisé
|
|
# avec find_dwdir()
|
|
if [ -f "$1/doku.php" ]; then
|
|
echo "$1/data/media"
|
|
elif [ -f "$1/.dokuwiki" ]; then
|
|
echo "$1/_media"
|
|
fi
|
|
}
|
|
|
|
function in_datadir() {
|
|
# retourner 0 si le répertoire ou le fichier $1 est dans le répertoire pages
|
|
# ou media d'un dokuwiki.
|
|
local data dwdir
|
|
data="$(abspath "${1:-.}")"
|
|
dwdir="$(find_dwdir "$data")" || return 1
|
|
local pagesdir="$(get_pagesdir "$dwdir")"
|
|
[ "$data" == "pagesdir" -o "${data#$pagesdir/}" != "$data" ] && return 0
|
|
local mediadir="$(get_mediadir "$dwdir")"
|
|
[ "$data" == "mediadir" -o "${data#$mediadir/}" != "$data" ] && return 0
|
|
return 1
|
|
}
|
|
|
|
function compute_ns() {
|
|
# calculer le namespace correspondant au fichier ou au répertoire $1 et
|
|
# retourner 0. Le namespace est retourné normalisé, c'est à dire "" si pas
|
|
# de namespace, et "ns:" pour le namespace ns.
|
|
# retourner 1 si le namespace n'a pas pu être calculé, notamment parce que
|
|
# $1 n'est pas un fichier du dokuwiki.
|
|
local datadir dwdir ns
|
|
datadir="$(abspath "${1:-.}")"
|
|
if [ -e "$datadir" ]; then
|
|
[ -d "$datadir" ] || datadir="$(dirname "$datadir")"
|
|
fi
|
|
in_datadir "$datadir" || return 1
|
|
|
|
dwdir="$(find_dwdir "$datadir")" || return 1
|
|
|
|
local mediadir="$(get_mediadir "$dwdir")"
|
|
if [ "$datadir" == "mediadir" ]; then
|
|
return 0
|
|
elif [ "${datadir#$mediadir/}" != "$datadir" ]; then
|
|
ns="${datadir#$mediadir/}"
|
|
echo "${ns//\//:}"
|
|
return 0
|
|
fi
|
|
|
|
local pagesdir="$(get_pagesdir "$dwdir")"
|
|
if [ "$datadir" == "pagesdir" ]; then
|
|
return 0
|
|
elif [ "${datadir#$pagesdir/}" != "$datadir" ]; then
|
|
ns="${datadir#$pagesdir/}"
|
|
echo "${ns//\//:}"
|
|
return 0
|
|
fi
|
|
|
|
return 1
|
|
}
|
|
|
|
function norm_ns() {
|
|
# normaliser un namespace: le faire terminer par ":" s'il est non vide.
|
|
local ns="$1"
|
|
if [ -n "$ns" ]; then
|
|
[ "${ns%:}" == "$ns" ] && ns="$ns:"
|
|
echo "$ns"
|
|
fi
|
|
}
|
|
function clean_ns() {
|
|
# supprimer le ":" de fin d'un namespace
|
|
[ -n "$1" ] && echo "${1%:}"
|
|
}
|
|
|
|
function __create() {
|
|
local dwdir="$1" file="$2" title="$3" __newfiles="$4"
|
|
|
|
estepi "Création de la page $(ppath "$file")"
|
|
echo "# -*- coding: utf-8 mode: text -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
|
|
|
===== $title =====
|
|
|
|
" >"$file"
|
|
[ -n "$__newfiles" ] && array_add "$__newfiles" "$file"
|
|
[ -n "$edit" ] && "${EDITOR:-vi}" +5 "$file"
|
|
return 0
|
|
}
|
|
|
|
function __addtostart() {
|
|
local dwdir="$1" ns="$2" name="$3" title="$4" __newfiles="$5" __modfiles="$6"
|
|
|
|
local basestart="$(get_pagesdir "$dwdir")/${ns//://}start"
|
|
local start="$basestart.txt"
|
|
mkdirof "$start"
|
|
|
|
if [ -f "$start" ]; then
|
|
[ -n "$__modfiles" ] && array_add "$__modfiles" "$start"
|
|
else
|
|
echo >"$start" "\
|
|
# -*- coding: utf-8 mode: text -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
|
"
|
|
[ -n "$__newfiles" ] && array_add "$__newfiles" "$start"
|
|
fi
|
|
|
|
quietgrep "=== Pages non classées ===" "$start" || echo >>"$start" "\
|
|
===== Pages non classées =====
|
|
"
|
|
echo " * [[$ns$name|$title]]" >>"$start"
|
|
}
|
|
|
|
function __strip_dwdir() {
|
|
if [ "$1" == "$dwdir" ]; then
|
|
echo .
|
|
else
|
|
echo "${1#$dwdir/}"
|
|
fi
|
|
}
|
|
function __commit() {
|
|
local dwdir="$1" msg="$2"
|
|
[ -d "$dwdir/.git" ] || return 0
|
|
|
|
local -a __newfiles __modfiles
|
|
[ -n "$3" ] && array_copy __newfiles "$3"
|
|
array_map __newfiles __strip_dwdir
|
|
[ -n "$4" ] && array_copy __modfiles "$4"
|
|
array_map __modfiles __strip_dwdir
|
|
|
|
cwd="$(pwd)"
|
|
cd "$dwdir"
|
|
if [ -n "${__newfiles[*]}" -o -n "${__modfiles[*]}" ]; then
|
|
"$scriptdir/uproject" add "${__newfiles[@]}" "${__modfiles[@]}"
|
|
else
|
|
"$scriptdir/uproject" add .
|
|
fi
|
|
"$scriptdir/uproject" commit "$msg" "${__newfiles[@]}" "${__modfiles[@]}"
|
|
cd "$cwd"
|
|
}
|
|
|
|
################################################################################
|
|
function newpage_help() {
|
|
uecho "$scriptname newpage: créer une nouvelle page de wiki
|
|
|
|
USAGE
|
|
$scriptname newpage PAGE
|
|
|
|
PAGE est de la forme [ns:]titre
|
|
- ns est l'espace de nom dans lequel la nouvelle page doit être créée.
|
|
- titre est le titre de la nouvelle page.
|
|
- nom est le nom du fichier sur disque. il est calculé à partir de titre.
|
|
Toutes ces valeurs peuvent être forcées individuellement.
|
|
|
|
OPTIONS
|
|
-d DWDIR
|
|
Spécifier le répertoire du dokuwiki
|
|
-t TITRE
|
|
Forcer la valeur du titre de la page au lieu de la calculer à partir de
|
|
PAGE.
|
|
-s NS
|
|
Spécifier l'espace de nom dans lequel créer la nouvelle page au lieu de
|
|
le calculer à partir de PAGE ou du répertoire courant.
|
|
-n NOM
|
|
Forcer la valeur du nom de fichier à utiliser au lieu de la calculer à
|
|
partir de PAGE.
|
|
--log
|
|
Dater la nouvelle page de la date du jour. Cette option est utile pour
|
|
documenter des opérations journalières.
|
|
-c
|
|
Ne pas lancer l'édition du fichier après l'avoir créé. Si DWCOMMIT=1, ne
|
|
pas lancer l'enregistrement des modifications dans le gestionnaire de
|
|
version.
|
|
-o
|
|
Ne pas rajouter la mention de la nouvelle page dans [[start]]"
|
|
}
|
|
function newpage_cmd() {
|
|
eval "$(utools_local)"
|
|
local dwdir title ns name log
|
|
local edit=1 addtostart=1
|
|
parse_opts "${PRETTYOPTS[@]}" \
|
|
--help '$exit_with newpage_help' \
|
|
-d:,--dwdir: dwdir= \
|
|
-t:,--title: title= \
|
|
-s:,--ns:,--namespace: ns= \
|
|
-n:,--name: name= \
|
|
-l,--log log=1 \
|
|
-c,--noedit edit= \
|
|
-o,--orphan addtostart= \
|
|
@ args -- "$@" && set -- "${args[@]}" || die "$args"
|
|
|
|
dwdir="$(find_dwdir "$dwdir")" || die "Impossible de trouver dokuwiki. Etes-vous dans le bon répertoire?"
|
|
|
|
if [ -z "$ns" ]; then
|
|
ns="$(compute_ns .)"
|
|
fi
|
|
if [ -z "$title" ]; then
|
|
title="$1"
|
|
if [ -n "$title" ]; then
|
|
# éventuellement prendre le namespace dans le titre fourni en ligne
|
|
# de commande
|
|
if [ -z "$ns" ]; then
|
|
ns="$(echo "$title" | awk '{
|
|
ns = tolower($0)
|
|
if (match(ns, /^([-a-z0-9]+:)+/)) {
|
|
print substr(ns, 1, RLENGTH - 1)
|
|
}
|
|
}')"
|
|
[ -n "$ns" ] && title="${title:$((${#ns} + 1))}"
|
|
fi
|
|
elif [ -z "$log" ]; then
|
|
read_value "Veuillez entrer un titre pour la page de wiki à créer" title
|
|
fi
|
|
fi
|
|
ns="$(norm_ns "$ns")"
|
|
|
|
if [ -z "$name" ]; then
|
|
name="$(echo "$title" | awk '{
|
|
name = tolower($0)
|
|
gsub(/[^- /a-z0-9]/, "", name)
|
|
gsub(/\//, "-", name)
|
|
gsub(/ +/, "-", name)
|
|
print name
|
|
}')"
|
|
fi
|
|
if [ -n "$log" ]; then
|
|
title="$(date +"%d/%m/%Y")${title:+: $title}"
|
|
name="$(date +"%Y-%m-%d")${name:+-$name}"
|
|
fi
|
|
read_value "Veuillez confirmer le nom de la page" name "$name"
|
|
|
|
local basename="$name"
|
|
local basefile="$(get_pagesdir "$dwdir")/${ns//://}$name"
|
|
local file="$basefile.txt"
|
|
|
|
if [ -f "$file" ]; then
|
|
estepw "Le fichier $(ppath "$file") existe déjà."
|
|
ask_yesno "Si vous continuez, un NOUVEAU fichier avec un suffixe numérique sera créé.
|
|
Sinon, vous pouvez utiliser '$scriptname edit' pour modifier le fichier existant.
|
|
Voulez-vous continuer?" O || return 1
|
|
fi
|
|
local i=0
|
|
while [ -f "$file" ]; do
|
|
i=$(($i + 1))
|
|
name="$basename-$i"
|
|
file="$basefile-$i.txt"
|
|
done
|
|
mkdirof "$file"
|
|
|
|
local -a newfiles modfiles
|
|
__create "$dwdir" "$file" "$title" newfiles || return
|
|
if [ -n "$addtostart" ]; then
|
|
__addtostart "$dwdir" "$ns" "$name" "$title" newfiles modfiles || return
|
|
fi
|
|
if [ -n "$edit" -a -n "$DWCOMMIT" ]; then
|
|
__commit "$dwdir" "newpage $title --> $ns$name" newfiles modfiles || return
|
|
else
|
|
estepi "dwci $(qvals "dwci newpage $title --> $ns$name")"
|
|
fi
|
|
return 0
|
|
}
|
|
|
|
################################################################################
|
|
function find_help() {
|
|
uecho "$scriptname find: trouver une page
|
|
|
|
USAGE
|
|
$scriptname find <filtre>
|
|
|
|
OPTIONS
|
|
-d DWDIR
|
|
Spécifier le répertoire de dokuwiki
|
|
-s NAMESPACE
|
|
Restreindre la recherche à l'espace de nom spécifié"
|
|
}
|
|
function find_cmd() {
|
|
eval "$(utools_local)"
|
|
local dwdir ns
|
|
parse_opts "${PRETTYOPTS[@]}" \
|
|
--help '$exit_with find_help' \
|
|
-d:,--dwdir: dwdir= \
|
|
-s:,--ns:,--namespace: ns= \
|
|
@ args -- "$@" && set -- "${args[@]}" || die "$args"
|
|
|
|
dwdir="$(find_dwdir "$dwdir")" || die "Impossible de trouver dokuwiki. Etes-vous dans le bon répertoire?"
|
|
ns="$(clean_ns "$ns")"
|
|
|
|
local filter="$1"
|
|
|
|
local pages="$(get_pagesdir "$dwdir")"
|
|
local searchdir="$pages"
|
|
[ -n "$ns" ] && searchdir="$searchdir/${ns//://}"
|
|
|
|
[ -d "$searchdir" ] || return 1
|
|
find "$searchdir" -type f -name "*.txt" |
|
|
sed "s#^$pages/##g; s#.txt\$##g" |
|
|
csort | {
|
|
if [ -n "$filter" ]; then
|
|
grep "$filter"
|
|
else
|
|
cat
|
|
fi
|
|
}
|
|
}
|
|
|
|
################################################################################
|
|
function edit_help() {
|
|
uecho "$scriptname edit: modifier une page
|
|
|
|
USAGE
|
|
$scriptname edit <filtre>
|
|
|
|
OPTIONS
|
|
-d DWDIR
|
|
Spécifier le répertoire de dokuwiki
|
|
-s NAMESPACE
|
|
Restreindre la recherche à l'espace de nom spécifié"
|
|
}
|
|
function edit_cmd() {
|
|
eval "$(utools_local)"
|
|
local dwdir ns
|
|
parse_opts "${PRETTYOPTS[@]}" \
|
|
--help '$exit_with edit_help' \
|
|
-d:,--dwdir: dwdir= \
|
|
-s:,--ns:,--namespace: ns= \
|
|
@ args -- "$@" && set -- "${args[@]}" || die "$args"
|
|
|
|
dwdir="$(find_dwdir "$dwdir")" || die "Impossible de trouver dokuwiki. Etes-vous dans le bon répertoire?"
|
|
ns="$(clean_ns "$ns")"
|
|
|
|
local pagesdir="$(get_pagesdir "$dwdir")"
|
|
local filter="$1" found=
|
|
if [ -f "$filter" ]; then
|
|
local file="$(abspath "$filter")"
|
|
if [ "${file#$pagesdir/}" != "$file" -a "${file%.txt}" != "$file" ]; then
|
|
page="${file#$pagesdir/}"
|
|
page="${page%.txt}"
|
|
found=1
|
|
fi
|
|
fi
|
|
if [ -z "$found" ]; then
|
|
local -a pages
|
|
array_from_lines pages "$(find_cmd -qq -d "$dwdir" -n "$ns" "$filter")"
|
|
if [ "${#pages[*]}" -eq 0 ]; then
|
|
eerror "Aucune page de ce nom n'a été trouvée"
|
|
return 1
|
|
elif [ "${#pages[*]}" -eq 1 ]; then
|
|
page="${pages[0]}"
|
|
else
|
|
simple_menu page pages -t "Pages trouvées" \
|
|
-m "Veuillez choisir la page à éditer" -d "${pages[0]}"
|
|
fi
|
|
fi
|
|
|
|
local -a newfiles modfiles
|
|
"${EDITOR:-vi}" "$pagesdir/$page.txt"
|
|
array_add modfiles "$pagesdir/$page.txt"
|
|
|
|
if [ -n "$DWCOMMIT" ]; then
|
|
__commit "$dwdir" "edit ${page//\//:}" newfiles modfiles || return
|
|
else
|
|
estepi "dwci $(qvals "edit ${page//\//:}")"
|
|
fi
|
|
return 0
|
|
}
|
|
|
|
################################################################################
|
|
function commit_help() {
|
|
uecho "$scriptname commit: enregistrer les modifications dans le gestionnaire de version
|
|
|
|
USAGE
|
|
$scriptname commit <msg>
|
|
|
|
OPTIONS
|
|
-d DWDIR
|
|
Spécifier le répertoire de dokuwiki"
|
|
}
|
|
function commit_cmd() {
|
|
eval "$(utools_local)"
|
|
local dwdir
|
|
parse_opts "${PRETTYOPTS[@]}" \
|
|
--help '$exit_with commit_help' \
|
|
-d:,--dwdir: dwdir= \
|
|
@ args -- "$@" && set -- "${args[@]}" || die "$args"
|
|
|
|
dwdir="$(find_dwdir "$dwdir")" || die "Impossible de trouver dokuwiki. Etes-vous dans le bon répertoire?"
|
|
|
|
__commit "$dwdir" "$*" || return
|
|
return 0
|
|
}
|
|
|
|
################################################################################
|
|
function sync_help() {
|
|
uecho "$scriptname sync: synchroniser les fichiers vers un dokuwiki système.
|
|
|
|
USAGE
|
|
$scriptname sync [destdir]
|
|
|
|
OPTIONS
|
|
-d DWDIR
|
|
Spécifier le répertoire du dokuwiki local
|
|
--destdir DESTDIR
|
|
Spécifier le répertoire du dokuwiki système.
|
|
DESTDIR peut être un répertoire distant puisque la copie se fait avec
|
|
rsync. Mais les paramètres --dirmode, --filemode et --owner sont alors
|
|
ignorés. De plus, les indexes ne sont pas reconstruits.
|
|
Il est aussi possible de spécifier DESTDIR comme argument de ce script.
|
|
--dirmode DIRMODE
|
|
--filemode FILEMODE
|
|
--owner OWNER
|
|
Spécifier les modes et propriétaires des fichiers dans le dokuwiki
|
|
destination.
|
|
--no-reindex
|
|
Ne pas reconstruire l'index ni supprimer le cache après la mise à jour
|
|
des fichiers."
|
|
}
|
|
function sync_cmd() {
|
|
eval "$(utools_local)"
|
|
local dwdir destdir noconf
|
|
local dirmode filemode owner noreindex
|
|
parse_opts "${PRETTYOPTS[@]}" \
|
|
--help '$exit_with sync_help' \
|
|
--noconf noconf=1 \
|
|
-d:,--dwdir: dwdir= \
|
|
--destdir: destdir= \
|
|
--dirmode: dirmode= \
|
|
--filemode: filemode= \
|
|
--owner: owner= \
|
|
-n,--no-reindex noreindex=1 \
|
|
--reindex noreindex= \
|
|
@ args -- "$@" && set -- "${args[@]}" || die "$args"
|
|
|
|
if [ -z "$noconf" ]; then
|
|
dwdir="$(find_dwdir "$dwdir")" || die "Impossible de trouver dokuwiki. Etes-vous dans le bon répertoire?"
|
|
|
|
[ -f "$dwdir/.dokuwiki" ] && source "$dwdir/.dokuwiki"
|
|
[ -z "$destdir" -a -n "$1" ] && destdir="$1"
|
|
[ -n "$destdir" ] || destdir="$DWSYNC_DESTDIR"
|
|
[ -n "$destdir" ] || die "Vous devez spécifier le répertoire de destination"
|
|
|
|
[ -n "$dirmode" ] || dirmode="$DWSYNC_DIRMODE"
|
|
[ -n "$filemode" ] || filemode="$DWSYNC_FILEMODE"
|
|
[ -n "$owner" ] || owner="$DWSYNC_OWNER"
|
|
|
|
[ -n "$url" ] || url="$DWSYNC_URL"
|
|
fi
|
|
|
|
run_as_root sync $(get_verbosity_option) --noconf -d "$dwdir" --destdir "$destdir" \
|
|
${dirmode:+--dirmode "$dirmode"} \
|
|
${filemode:+--filemode "$filemode"} \
|
|
${owner:+--owner "$owner"} \
|
|
${noreindex:+--no-reindex} "$@"
|
|
|
|
local -a rsync reindexer
|
|
rsync=(rsync -rltD --delete-after)
|
|
reindexer=("$destdir/bin/indexer.php")
|
|
if check_verbosity -v; then
|
|
array_add rsync -v
|
|
elif ! check_verbosity -c; then
|
|
array_add rsync -q
|
|
array_add reindexer -q
|
|
fi
|
|
|
|
local srcmdir="$(get_mediadir "$dwdir")"
|
|
local srcpdir="$(get_pagesdir "$dwdir")"
|
|
local destmdir="$destdir/data/media"
|
|
local destpdir="$destdir/data/pages"
|
|
etitle "Synchronisation des fichiers"
|
|
if __check_dwdir0 "$dwdir"; then
|
|
# pagesdir et mediadir séparés
|
|
estep "$(ppath "$srcmdir") --> $(ppath "$destmdir")"
|
|
"${rsync[@]}" "$srcmdir/" "$destmdir"
|
|
estep "$(ppath "$srcpdir") --> $(ppath "$destpdir")"
|
|
"${rsync[@]}" "$srcpdir/" "$destpdir"
|
|
elif __check_dwdir1 "$dwdir"; then
|
|
# mediadir dans pagesdir
|
|
estep "$(ppath "$srcmdir") --> $(ppath "$destmdir")"
|
|
"${rsync[@]}" "$srcmdir/" "$destmdir"
|
|
estep "$(ppath "$srcpdir") --> $(ppath "$destpdir")"
|
|
"${rsync[@]}" \
|
|
--exclude /.git --exclude /.dokuwiki --exclude /.udir \
|
|
--exclude /_media \
|
|
--exclude .svn \
|
|
"$srcpdir/" "$destpdir"
|
|
fi
|
|
eend
|
|
|
|
if [ -n "$dirmode" ]; then
|
|
etitle "dirmode=$dirmode"
|
|
estep "$(ppath "$destmdir")"
|
|
find "$destmdir" -type d -exec chmod "$dirmode" {} \;
|
|
estep "$(ppath "$destpdir")"
|
|
find "$destpdir" -type d -exec chmod "$dirmode" {} \;
|
|
eend
|
|
fi
|
|
if [ -n "$filemode" ]; then
|
|
etitle "filemode=$filemode"
|
|
estep "$(ppath "$destmdir")"
|
|
find "$destmdir" -type f -exec chmod "$filemode" {} \;
|
|
estep "$(ppath "$destpdir")"
|
|
find "$destpdir" -type f -exec chmod "$filemode" {} \;
|
|
eend
|
|
fi
|
|
if [ -n "$owner" ]; then
|
|
etitle "owner=$owner"
|
|
estep "$(ppath "$destmdir")"
|
|
chown -R "$owner" "$destmdir"
|
|
estep "$(ppath "$destpdir")"
|
|
chown -R "$owner" "$destpdir"
|
|
eend
|
|
fi
|
|
|
|
if [ -z "$noreindex" -a -x "${reindexer[0]}" ]; then
|
|
etitle "Réindexation des fichiers"
|
|
"${reindexer[@]}"
|
|
|
|
#estep "Suppression du cache"
|
|
#local -a cachedirs
|
|
#array_lsdirs cachedirs "$destdir/data/cache"
|
|
#rm -rf "${cachedirs[@]}"
|
|
estep "Invalidation du cache"
|
|
touch "$destdir/conf/local.php"
|
|
|
|
if [ -n "$owner" ]; then
|
|
estep "owner=$owner"
|
|
chown -R "$owner" "$destdir/data/index"
|
|
fi
|
|
eend
|
|
fi
|
|
}
|
|
|
|
################################################################################
|
|
function generate_help() {
|
|
uecho "$scriptname generate: Générer la documentation d'un projet dans un espace de nom
|
|
|
|
USAGE
|
|
$scriptname generate [options] srcdir
|
|
|
|
Si srcdir contient un fichier .dokuwikigen, ce fichier est sourcé pour générer
|
|
la documentation. Les fonction setpage() et addpage() sont disponible.
|
|
|
|
OPTIONS
|
|
-d DWDIR
|
|
Spécifier le répertoire du dokuwiki
|
|
-s NS
|
|
Spécifier l'espace de nom dans lequel créer la documentation.
|
|
Par défaut, il s'agit de da:srcname où srcname est le nom de base
|
|
de srcdir."
|
|
}
|
|
function generate_cmd() {
|
|
eval "$(utools_local)"
|
|
local dwdir ns title
|
|
parse_opts "${PRETTYOPTS[@]}" \
|
|
--help '$exit_with generate_help' \
|
|
-d:,--dwdir: dwdir= \
|
|
-s:,--ns:,--namespace: ns= \
|
|
-t:,--title: title= \
|
|
@ args -- "$@" && set -- "${args[@]}" || die "$args"
|
|
|
|
dwdir="$(find_dwdir "$dwdir")" || die "Impossible de trouver dokuwiki. Etes-vous dans le bon répertoire?"
|
|
|
|
local srcdir="$(abspath "${1:-.}")"
|
|
[ -d "$srcdir" ] || die "Vous devez spécifier un répertoire de projet dont il faut générer la documentation"
|
|
local srcname=$(basename "$srcdir")
|
|
|
|
[ -n "$ns" ] || ns="da:$srcname"
|
|
ns="$(norm_ns "$ns")"
|
|
|
|
[ -n "$title" ] || title="$srcname"
|
|
|
|
function setpage() {
|
|
# Créer la page $1 avec le contenu de l'entrée standard
|
|
# $2 est un namespace local en dessous de $ns
|
|
local append
|
|
if [ "$1" == "--append" ]; then
|
|
append=1
|
|
shift
|
|
fi
|
|
local name="$1" localns="$2"
|
|
|
|
name="$(awk '{
|
|
gsub(/_/, "")
|
|
print tolower($0)
|
|
}' <<<"$name")"
|
|
# XXX normaliser le nom: en plus de le mettre en minuscule, il faut
|
|
# supprimer certains caractères spéciaux comme '_'. en faire la liste?
|
|
|
|
ns="$(norm_ns "$ns")"
|
|
[ -n "$localns" ] && local ns="$(norm_ns "$ns$localns")"
|
|
local basefile="$(get_pagesdir "$dwdir")/${ns//://}$name"
|
|
local file="$basefile.txt"
|
|
mkdirof "$file"
|
|
|
|
if [ -f "$file" ]; then
|
|
local -a __newfiles
|
|
array_from_lines __newfiles "$(<"$newfiles")"
|
|
array_contains __newfiles "$file" || echo "$file" >>"$modfiles"
|
|
else
|
|
echo "$file" >>"$newfiles"
|
|
fi
|
|
if [ -n "$append" ]; then
|
|
cat >>"$file"
|
|
else
|
|
estepi "$(ppath "$file")"
|
|
cat >"$file"
|
|
fi
|
|
}
|
|
function addpage() {
|
|
# ajouter le contenu de l'entrée standard à la page $1
|
|
setpage --append "$@"
|
|
}
|
|
function setmedia() {
|
|
# Créer le fichier de media $2 en copiant le contenu du fichier $1
|
|
# $3 est un namespace local en dessous de $ns
|
|
local source="$1" name="$2" localns="$3"
|
|
|
|
name="$(awk '{
|
|
gsub(/_/, "")
|
|
print tolower($0)
|
|
}' <<<"$name")"
|
|
# XXX normaliser le nom: en plus de le mettre en minuscule, il faut
|
|
# supprimer certains caractères spéciaux comme '_'. en faire la liste?
|
|
|
|
ns="$(norm_ns "$ns")"
|
|
[ -n "$localns" ] && local ns="$(norm_ns "$ns$localns")"
|
|
local file="$(get_mediadir "$dwdir")/${ns//://}$name"
|
|
mkdirof "$file"
|
|
|
|
if [ -f "$file" ]; then
|
|
local -a __newfiles
|
|
array_from_lines __newfiles "$(<"$newfiles")"
|
|
array_contains __newfiles "$file" || echo "$file" >>"$modfiles"
|
|
else
|
|
echo "$file" >>"$newfiles"
|
|
fi
|
|
estepi "$(ppath "$file")"
|
|
cat "$source" >"$file"
|
|
}
|
|
function gendefault() {
|
|
setpage start <<<"===== $title =====
|
|
"
|
|
if [ -f README.txt ]; then
|
|
{
|
|
awk 'NR==1 && $0 ~ /^#.*-\*-.*coding:/ {next} {print}' <README.txt
|
|
echo
|
|
} | addpage start
|
|
fi
|
|
|
|
local -a cmds
|
|
local first cmd cmdname
|
|
etitle "Documentation des outils"
|
|
array_lsfiles cmds .
|
|
first=1
|
|
for cmd in "${cmds[@]}"; do
|
|
cmdname="$(basename "$cmd")"
|
|
[ -x "$cmd" ] || continue
|
|
{
|
|
echo "===== $cmdname ====="
|
|
echo "<code>"
|
|
"$cmd" --help
|
|
echo "</code>"
|
|
} | setpage "$cmdname"
|
|
if [ -n "$first" ]; then
|
|
addpage start <<<"==== Outils ===="
|
|
first=
|
|
fi
|
|
addpage start <<<" * [[$ns$cmdname]]"
|
|
done
|
|
eend
|
|
}
|
|
|
|
local newfiles modfiles
|
|
ac_set_tmpfile newfiles
|
|
ac_set_tmpfile modfiles
|
|
(
|
|
cd "$srcdir"
|
|
if [ -x .dokuwikigen ]; then
|
|
./.dokuwikigen
|
|
elif [ -f .dokuwikigen ]; then
|
|
source ./.dokuwikigen
|
|
else
|
|
gendefault
|
|
fi
|
|
array_from_lines newfiles "$(<"$newfiles")"
|
|
array_from_lines modfiles "$(<"$modfiles")"
|
|
if [ -n "$DWCOMMIT" ]; then
|
|
__commit "$dwdir" "generate $srcdir" newfiles modfiles
|
|
else
|
|
estepi "dwci $(qvals "generate $srcdir")"
|
|
fi
|
|
)
|
|
}
|
|
|
|
################################################################################
|
|
|
|
parse_opts + "${PRETTYOPTS[@]}" \
|
|
--help '$exit_with display_help' \
|
|
@ args -- "$@" && set -- "${args[@]}" || die "$args"
|
|
|
|
cmd="$1"; shift
|
|
case "$cmd" in
|
|
"") exit_with display_help;;
|
|
newpage|createpage|addpage|page|p|new|n|create|c|add|a) newpage_cmd "$@";;
|
|
newlog|createlog|log|blog|date|d) newpage_cmd --log "$@";;
|
|
find|f|search|s|list|l) find_cmd "$@";;
|
|
edit|e|vim|vi) edit_cmd "$@";;
|
|
commit|ci) commit_cmd "$@";;
|
|
sync) sync_cmd "$@";;
|
|
generate|gen|g) generate_cmd "$@";;
|
|
*) die "$cmd: commande incorrecte";;
|
|
esac
|