mirror of
git://git.code.sf.net/p/zsh/code
synced 2025-01-01 17:24:50 +01:00
259 lines
8.1 KiB
Bash
259 lines
8.1 KiB
Bash
#!/bin/zsh
|
|
# All arguments are joined with spaces and inserted into the calendar
|
|
# file at the appropriate point.
|
|
#
|
|
# While the function compares the date of the new entry with dates in the
|
|
# existing calendar file, it does not do any sorting; it inserts the new
|
|
# entry before the first existing entry with a later date and time.
|
|
|
|
emulate -L zsh
|
|
setopt extendedglob # xtrace
|
|
|
|
local context=":datetime:calendar_add:"
|
|
local vdatefmt="%Y%m%dT%H%M%S"
|
|
local d='[[:digit:]]'
|
|
|
|
local calendar newfile REPLY lastline opt text occur
|
|
local -a calendar_entries lockfiles reply occurrences
|
|
integer my_date done rstat nolock nobackup new_recurring
|
|
integer keep_my_uid
|
|
local -A reply parse_new parse_old
|
|
local -a match mbegin mend
|
|
local my_uid their_uid
|
|
|
|
autoload -Uz calendar_{parse,read,lockfiles}
|
|
|
|
while getopts "BL" opt; do
|
|
case $opt in
|
|
(B)
|
|
nobackup=1
|
|
;;
|
|
|
|
(L)
|
|
nolock=1
|
|
;;
|
|
|
|
(*)
|
|
return 1
|
|
;;
|
|
esac
|
|
done
|
|
shift $(( OPTIND - 1 ))
|
|
|
|
# Read the calendar file from the calendar-file style
|
|
zstyle -s $context calendar-file calendar ||
|
|
calendar=~/calendar
|
|
newfile=$calendar.new.$HOST.$$
|
|
|
|
local addline="$*"
|
|
if ! calendar_parse $addline; then
|
|
print "$0: failed to parse date/time" >&2
|
|
return 1
|
|
fi
|
|
parse_new=("${(@kv)reply}")
|
|
(( my_date = $parse_new[time] ))
|
|
if zstyle -t $context reformat-date; then
|
|
local datefmt
|
|
zstyle -s $context date-format datefmt ||
|
|
datefmt="%a %b %d %H:%M:%S %Z %Y"
|
|
strftime -s REPLY $datefmt $parse_new[time]
|
|
addline="$REPLY $parse_new[text1]"
|
|
fi
|
|
if [[ -n $parse_new[rptstr] ]]; then
|
|
(( new_recurring = 1 ))
|
|
if [[ $parse_new[rptstr] = CANCELLED ]]; then
|
|
(( done = 1 ))
|
|
elif [[ $addline = (#b)(*[[:space:]\#]RECURRENCE[[:space:]]##)([^[:space:]]##)([[:space:]]*|) ]]; then
|
|
# Use the updated recurrence time
|
|
strftime -s REPLY $vdatefmt ${parse_new[schedrpttime]}
|
|
addline="${match[1]}$REPLY${match[3]}"
|
|
else
|
|
# Add a recurrence time
|
|
[[ $addline = *$'\n' ]] || addline+=$'\n'
|
|
strftime -s REPLY $vdatefmt ${parse_new[schedrpttime]}
|
|
addline+=" # RECURRENCE $REPLY"
|
|
fi
|
|
fi
|
|
|
|
# $calendar doesn't necessarily exist yet.
|
|
|
|
# Match a UID, a unique identifier for the entry inherited from
|
|
# text/calendar format.
|
|
local uidpat='(|*[[:space:]])UID[[:space:]]##(#b)([[:xdigit:]]##)(|[[:space:]]*)'
|
|
if [[ $addline = ${~uidpat} ]]; then
|
|
my_uid=${(U)match[1]}
|
|
fi
|
|
|
|
# start of subshell for OS file locking
|
|
(
|
|
# start of block for following always to clear up lockfiles.
|
|
# Not needed but harmless if OS file locking is used.
|
|
{
|
|
if (( ! nolock )); then
|
|
if zmodload -F zsh/system b:zsystem && zsystem supports flock &&
|
|
zsystem flock $calendar 2>/dev/null; then
|
|
# locked OK
|
|
:
|
|
else
|
|
calendar_lockfiles $calendar || exit 1
|
|
fi
|
|
fi
|
|
|
|
if [[ -f $calendar ]]; then
|
|
calendar_read $calendar
|
|
|
|
if [[ -n $my_uid ]]; then
|
|
# Pre-scan to events with the same UID
|
|
for line in $calendar_entries; do
|
|
calendar_parse $line || continue
|
|
parse_old=("${(@kv)reply}")
|
|
# Recurring with a UID?
|
|
if [[ $line = ${~uidpat} ]]; then
|
|
their_uid=${(U)match[1]}
|
|
if [[ $their_uid = $my_uid ]]; then
|
|
# Deal with recurrences and also some add some
|
|
# extra magic for cancellation.
|
|
|
|
# See if we have found a recurrent version
|
|
if [[ -z $parse_old[rpttime] ]]; then
|
|
# No, so assume this is a straightforward replacement
|
|
# of a non-recurring event.
|
|
|
|
# Is this a cancellation of a non-recurring event?
|
|
# Look for an OCCURRENCE in the form
|
|
# OCCURRENCE 20100513T110000 CANCELLED
|
|
# although we don't bother looking at the date/time---
|
|
# it's one-off, so this should already be unique.
|
|
if [[ $new_recurring -eq 0 && \
|
|
$parse_new[text1] = (|*[[:space:]\#])"OCCURRENCE"[[:space:]]##([^[:space:]]##[[:space:]]##CANCELLED)(|[[:space:]]*) ]]; then
|
|
# Yes, so skip both the old and new events.
|
|
(( done = 1 ))
|
|
fi
|
|
# We'll skip this UID when we encounter it again.
|
|
continue
|
|
fi
|
|
if (( new_recurring )); then
|
|
# Replacing a recurrence; there can be only one.
|
|
# TBD: do we replace existing occurrences of the
|
|
# replaced recurrent event? I'm guessing not, but
|
|
# if we keep the UID then maybe we should.
|
|
#
|
|
# TBD: ick, suppose we're cancelling an even that
|
|
# we added to a recurring sequence but didn't replace
|
|
# the recurrence. We might get RPT CANCELLED for this.
|
|
# That would be bad. Should invent better way of
|
|
# cancelling non-recurring event.
|
|
continue
|
|
else
|
|
# The recorded event is recurring, but the new one is a
|
|
# one-off event. If there are embedded OCCURRENCE declarations,
|
|
# use those.
|
|
#
|
|
# TBD: We could be clever about text associated
|
|
# with the occurrence. Copying the entire text
|
|
# of the meeting seems like overkill but people often
|
|
# add specific remarks about why this occurrence was
|
|
# moved/cancelled.
|
|
#
|
|
# TBD: one case we don't yet handle is cancelling
|
|
# something that isn't replacing a recurrence, i.e.
|
|
# something we added as OCCURRENCE XXXXXXXXTXXXXXX <when>.
|
|
# If we're adding a CANCELLED occurrence we should
|
|
# look to see if it matches <when> and if so simply
|
|
# delete that occurrence.
|
|
#
|
|
# TBD: one nasty case is if the new occurrence
|
|
# occurs before the current scheduled time. As we
|
|
# never look backwards we'll miss it.
|
|
text=$addline
|
|
occurrences=()
|
|
while [[ $text = (#b)(|*[[:space:]\#])"OCCURRENCE"[[:space:]]##([^[:space:]]##[[:space:]]##[^[:space:]]##)(|[[:space:]]*) ]]; do
|
|
occurrences+=($match[2])
|
|
text="$match[1] $match[3]"
|
|
done
|
|
if (( ! ${#occurrences} )); then
|
|
# No embedded occurrences. We'll manufacture one
|
|
# that doesn't refer to an original recurrence.
|
|
strftime -s REPLY $vdatefmt $my_date
|
|
occurrences=("XXXXXXXXTXXXXXX $REPLY")
|
|
fi
|
|
# Add these occurrences, checking if they replace
|
|
# an existing one.
|
|
for occur in ${(o)occurrences}; do
|
|
REPLY=${occur%%[[:space:]]*}
|
|
# Only update occurrences that refer to genuine
|
|
# recurrences.
|
|
if [[ $REPLY = [[:digit:]](#c8)T[[:digit:]](#c6) && $line = (#b)(|*[[:space:]\#])(OCCURRENCE[[:space:]]##)${REPLY}[[:space:]]##[^[:space:]]##(|[[:space:]]*) ]]; then
|
|
# Yes, update in situ
|
|
line="${match[1]}${match[2]}$occur${match[3]}"
|
|
else
|
|
# No, append.
|
|
[[ $line = *$'\n' ]] || line+=$'\n'
|
|
line+=" # OCCURRENCE $occur"
|
|
fi
|
|
done
|
|
# The line we're adding now corresponds to the
|
|
# original event. We'll skip the matching UID
|
|
# in the file below, however.
|
|
addline=$line
|
|
# We need to work out which event is next, so
|
|
# reparse.
|
|
if calendar_parse $addline; then
|
|
parse_new=("${(@kv)reply}")
|
|
(( my_date = ${parse_new[time]} ))
|
|
if zstyle -t $context reformat-date; then
|
|
zstyle -s $context date-format datefmt
|
|
strftime -s REPLY $datefmt $parse_new[time]
|
|
addline="$REPLY $parse_new[text1]"
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
done
|
|
fi
|
|
|
|
{
|
|
for line in $calendar_entries; do
|
|
calendar_parse $line || continue
|
|
parse_old=("${(@kv)reply}")
|
|
if (( ! done && ${parse_old[time]} > my_date )); then
|
|
print -r -- $addline
|
|
(( done = 1 ))
|
|
fi
|
|
# We've already merged any information on the same UID
|
|
# with our new text, probably.
|
|
if [[ $keep_my_uid -eq 0 && -n $my_uid && $line = ${~uidpat} ]]; then
|
|
their_uid=${(U)match[1]}
|
|
[[ $my_uid = $their_uid ]] && continue
|
|
fi
|
|
if [[ $parse_old[time] -eq $my_date && $line = $addline ]]; then
|
|
(( done )) && continue # paranoia: shouldn't happen
|
|
(( done = 1 ))
|
|
fi
|
|
print -r -- $line
|
|
done
|
|
(( done )) || print -r -- $addline
|
|
} >$newfile
|
|
if (( ! nobackup )); then
|
|
if ! mv $calendar $calendar.old; then
|
|
print "Couldn't back up $calendar to $calendar.old.
|
|
New calendar left in $newfile." >&2
|
|
(( rstat = 1 ))
|
|
fi
|
|
fi
|
|
else
|
|
(( done )) || print -r -- $addline >$newfile
|
|
fi
|
|
|
|
if (( !rstat )) && ! mv $newfile $calendar; then
|
|
print "Failed to rename $newfile to $calendar.
|
|
Old calendar left in $calendar.old." >&2
|
|
(( rstat = 1 ))
|
|
fi
|
|
} always {
|
|
(( ${#lockfiles} )) && rm -f $lockfiles
|
|
}
|
|
|
|
exit $rstat
|
|
)
|