Change the message to "available fonts".
[gnus] / lisp / nndiary.el
1 ;;; nndiary.el --- A diary backend for Gnus
2
3 ;; Copyright (C) 1999-2001 Didier Verna.
4
5 ;; Author:        Didier Verna <didier@xemacs.org>
6 ;; Maintainer:    Didier Verna <didier@xemacs.org>
7 ;; Created:       Fri Jul 16 18:55:42 1999
8 ;; Last Revision: Wed Aug  8 17:36:21 2001
9 ;; Keywords:      calendar mail news
10
11 ;; This file is part of Gnus.
12
13 ;; Gnus is free software; you can redistribute it and/or modify
14 ;; it under the terms of the GNU General Public License as published by
15 ;; the Free Software Foundation; either version 2 of the License, or
16 ;; (at your option) any later version.
17
18 ;; Gnus is distributed in the hope that it will be useful,
19 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
20 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21 ;; GNU General Public License for more details.
22
23 ;; You should have received a copy of the GNU General Public License
24 ;; along with this program; if not, write to the Free Software
25 ;; Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26
27
28 ;;; Commentary:
29
30 ;; Contents management by FCM version 0.1.
31
32 ;; Description:
33 ;; ===========
34
35 ;; This package implements NNDiary, a diary backend for Gnus.  NNDiary is a
36 ;; mail backend, pretty similar to nnml in its functionnning (it has all the
37 ;; features of nnml, actually), but in which messages are treated as event
38 ;; reminders.
39
40 ;; Here is a typical scenario:
41 ;; - You've got a date with Andy Mc Dowell or Bruce Willis (select according
42 ;;   to your sexual preference) in one month.  You don't want to forget it.
43 ;; - Send a (special) diary message to yourself (see below).
44 ;; - Forget all about it and keep on getting and reading new mail, as usual.
45 ;; - From time to time, as you type `g' in the group buffer and as the date
46 ;;   is getting closer, the message will pop up again, just like if it were
47 ;;   new and unread.
48 ;; - Read your "new" messages, this one included, and start dreaming of the
49 ;;   night you're gonna have.
50 ;; - Once the date is over (you actually fell asleep just after dinner), the
51 ;;   message will be automatically deleted if it is marked as expirable.
52
53 ;; Some more notes on the diary backend:
54 ;; - NNDiary is a *real* mail backend.  You *really* send real diary
55 ;;   messsages.  This means for instance that you can give appointements to
56 ;;   anybody (provided they use Gnus and NNDiary) by sending the diary message
57 ;;   to them as well.
58 ;; - However, since NNDiary also has a 'request-post method, you can also
59 ;;  `C-u a' instead of `C-u m' on a diary group and the message won't actually
60 ;;   be sent; just stored in the group.
61 ;; - The events you want to remember need not be punctual.  You can set up
62 ;;   reminders for regular dates (like once each week, each monday at 13:30
63 ;;   and so on).  Diary messages of this kind will never be deleted (unless
64 ;;   you do it explicitely).  But that, you guessed.
65
66
67 ;; Usage:
68 ;; =====
69
70 ;;  1/ NNDiary has two modes of operation: traditional (the default) and
71 ;;     autonomous.
72 ;;     a/ In traditional mode, NNDiary does not get new mail by itself.  You
73 ;;        have to move mails from your primary mail backend to nndiary
74 ;;        groups.
75 ;;     b/ In autonomous mode, NNDiary retrieves its own mail and handles it
76 ;;        independantly of your primary mail backend.  To use NNDiary in
77 ;;        autonomous mode, you have several things to do:
78 ;;           i/ Put (setq nndiary-get-new-mail t) in your gnusrc file.
79 ;;          ii/ Diary messages contain several `X-Diary-*' special headers.
80 ;;              You *must* arrange that these messages be split in a private
81 ;;              folder *before* Gnus treat them.  You need this because Gnus
82 ;;              is not able yet to manage multiple backends for mail
83 ;;              retrieval.  Getting them from a separate source will
84 ;;              compensate this misfeature to some extent, as we will see.
85 ;;              As an example, here's my procmailrc entry to store diary files
86 ;;              in ~/.nndiary (the default nndiary mail source file):
87 ;;
88 ;;              :0 HD :
89 ;;              * ^X-Diary
90 ;;              .nndiary
91 ;;         iii/ Customize the variables `nndiary-mail-sources' and
92 ;;              `nndiary-split-methods'.  These are replacements for the usual
93 ;;              mail sources and split methods which, and will be used in
94 ;;              autonomous mode.  `nndiary-mail-sources' defaults to
95 ;;              '(file :path "~/.nndiary").
96 ;;  2/ Install nndiary somewhere Emacs / Gnus can find it.  Normally, you
97 ;;     *don't* have to '(require 'nndiary) anywhere.  Gnus will do so when
98 ;;     appropriate as long as nndiary is somewhere in the load path.
99 ;;  3/ Now, customize the rest of nndiary.  In particular, you should
100 ;;     customize `nndiary-reminders', the list of times when you want to be
101 ;;     reminded of your appointements (e.g. 3 weeks before, then 2 days
102 ;;     before, then 1 hour before and that's it).
103 ;;  4/ You *must* use the group timestamp feature of Gnus.  This adds a
104 ;;     timestamp to each groups' parameters (please refer to the Gnus
105 ;;     documentation ("Group Timestamp" info node) to see how it's done.
106 ;;  5/ Once you have done this, you may add a permanent nndiary virtual server
107 ;;     (something like '(nndiary "")) to your `gnus-secondary-select-methods'.
108 ;;     Yes, this server will be able to retrieve mails and split them when you
109 ;;     type `g' in the group buffer, just as if it were your only mail backend.
110 ;;     This is the benefit of using a private folder.
111 ;;  6/ Hopefully, almost everything (see the TODO section below) will work as
112 ;;     expected when you restart Gnus: in the group buffer, `g' and `M-g' will
113 ;;     also get your new diary mails, `F' will find your new diary groups etc.
114
115
116 ;; How to send diary messages:
117 ;; ==========================
118
119 ;; There are 7 special headers in diary messages. These headers are of the
120 ;; form `X-Diary-<something>', the <something> being one of `Minute', `Hour',
121 ;; `Dom', `Month', `Year', `Time-Zone' and `Dow'. `Dom' means "Day of Month",
122 ;; and `dow' means "Day of Week".  These headers actually behave like crontab
123 ;; specifications and define the event date(s).
124
125 ;; For all headers but the `Time-Zone' one, a header value is either a
126 ;; star (meaning all possible values), or a list of fields (separated by a
127 ;; comma).  A field is either an integer, or a range.  A range is two integers
128 ;; separated by a dash.  Possible integer values are 0-59 for `Minute', 0-23
129 ;; for `Hour', 1-31 for `Dom', `1-12' for Month, above 1971 for `Year' and 0-6
130 ;; for `Dow' (0 = sunday).  As a special case, a star in either `Dom' or `Dow'
131 ;; doesn't mean "all possible values", but "use only the other field".  Note
132 ;; that if both are star'ed, the use of either one gives the same result :-),
133
134 ;; The `Time-Zone' header is special in that it can have only one value (you
135 ;; bet ;-).
136 ;; A star doesn't mean "all possible values" (because it has no sense), but
137 ;; "the current local time zone".
138
139 ;; As an example, here's how you would say "Each Monday and each 1st of month,
140 ;; at 12:00, 20:00, 21:00, 22:00, 23:00 and 24:00, from 1999 to 2010" (I let
141 ;; you find what to do then):
142 ;;
143 ;;   X-Diary-Minute: 0
144 ;;   X-Diary-Hour: 12, 20-24
145 ;;   X-Diary-Dom: 1
146 ;;   X-Diary-Month: *
147 ;;   X-Diary-Year: 1999-2010
148 ;;   X-Diary-Dow: 1
149 ;;   X-Diary-Time-Zone: *
150 ;;
151 ;;
152 ;; Sending a diary message is not different from sending any other kind of
153 ;; mail, except that such messages are identified by the presence of these
154 ;; special headers.
155
156
157
158 ;; Bugs / Todo:
159 ;; ===========
160
161 ;; * Respooling doesn't work because contrary to the request-scan function,
162 ;;   Gnus won't allow me to override the split methods when calling the
163 ;;   respooling backend functions.
164 ;; * There's a bug in the time zone mechanism with variable TZ locations.
165 ;; * We could allow a keyword like `ask' in X-Diary-* headers, that would mean
166 ;;   "ask for value upon reception of the message".
167 ;; * We could add an optional header X-Diary-Reminders to specify a special
168 ;;   reminders value for this message. Suggested by Jody Klymak.
169 ;; * We should check messages validity in other circumstances than just
170 ;;   moving an article from sonwhere else (request-accept). For instance, when
171 ;;   editing / saving and so on.
172
173
174 ;; Remarks:
175 ;; =======
176
177 ;; * nnoo.
178 ;;   NNDiary is very similar to nnml.  This makes the idea of using nnoo (to
179 ;;   derive nndiary from nnml) natural.  However, my experience with nnoo is
180 ;;   that for reasonably complex backends like this one, noo is a burden
181 ;;   rather than an help.  It's tricky to use, not everything can be
182 ;;   inherited, what can be inherited and when is not very clear, and you've
183 ;;   got to be very careful because a little mistake can fuck up your your
184 ;;   other backends, especially because their variables will be use instead of
185 ;;   your real ones.  Finally, I found it easier to just clone the needed
186 ;;   parts of nnml, and tracking nnml updates is not a big deal.
187
188 ;;   IMHO, nnoo is actually badly designed.  A much simpler, and yet more
189 ;;   powerful one would be to make *real* functions and variables for a new
190 ;;   backend based on another. Lisp is a reflexive language so that's a very
191 ;;   easy thing to do: inspect the function's form, replace occurences of
192 ;;   <nnfrom> (even in strings) with <nnto>, and you're done.
193
194 ;; * nndiary-get-new-mail, nndiary-mail-source and nndiary-split-methods:
195 ;;   NNDiary has some experimental parts, in the sense Gnus normally uses only
196 ;;   one mail backends for mail retreival and splitting.  This backend is also
197 ;;   an attempt to make it behave differently.  For Gnus developpers: as you
198 ;;   can see if you snarf into the code, that was not a very difficult thing
199 ;;   to do.  Something should be done about the respooling breakage though.
200
201
202 ;;; Code:
203
204 (require 'nnoo)
205 (require 'nnheader)
206 (require 'nnmail)
207 (eval-when-compile (require 'cl))
208
209 (require 'gnus-start)
210 (require 'gnus-sum)
211
212 ;; Compatibility Functions  =================================================
213
214 (if (fboundp 'signal-error)
215     (defun nndiary-error (&rest args)
216       (apply #'signal-error 'nndiary args))
217   (defun nndiary-error (&rest args)
218     (apply #'error args)))
219
220
221 ;; Backend behavior customization ===========================================
222
223 (defgroup nndiary nil
224   "The Gnus Diary backend."
225   :group 'gnus-diary)
226
227 (defcustom nndiary-mail-sources
228   `((file :path ,(expand-file-name "~/.nndiary")))
229   "*NNDiary specific mail sources.
230 This variable is used by nndiary in place of the standard `mail-sources'
231 variable when `nndiary-get-new-mail' is set to non-nil.  These sources
232 must contain diary messages ONLY."
233   :group 'nndiary
234   :group 'mail-source
235   :type 'sexp)
236
237 (defcustom nndiary-split-methods '(("diary" ""))
238   "*NNDiary specific split methods.
239 This variable is used by nndiary in place of the standard
240 `nnmail-split-methods' variable when `nndiary-get-new-mail' is set to
241 non-nil."
242   :group 'nndiary
243   :group 'nnmail-split
244   :type '(choice (repeat :tag "Alist" (group (string :tag "Name") regexp))
245                  (function-item nnmail-split-fancy)
246                  (function :tag "Other")))
247
248
249 (defcustom nndiary-reminders '((0 . day))
250   "*Different times when you want to be reminded of your appointements.
251 Diary articles will appear again, as if they'd been just received.
252
253 Entries look like (3 . day) which means something like \"Please
254 Hortense, would you be so kind as to remind me of my appointments 3 days
255 before the date, thank you very much. Anda, hmmm... by the way, are you
256 doing anything special tonight ?\".
257
258 The units of measure are 'minute 'hour 'day 'week 'month and 'year (no,
259 not 'century, sorry).
260
261 NOTE: the units of measure actually express dates, not durations: if you
262 use 'week, messages will pop up on Sundays at 00:00 (or Mondays if
263 `nndiary-week-starts-on-monday' is non nil) and *not* 7 days before the
264 appointement, if you use 'month, messages will pop up on the first day of
265 each months, at 00:00 and so on.
266
267 If you really want to specify a duration (like 24 hours exactly), you can
268 use the equivalent in minutes (the smallest unit).  A fuzz of 60 seconds
269 maximum in the reminder is not that painful, I think.  Although this
270 scheme might appear somewhat weird at a first glance, it is very powerful.
271 In order to make this clear, here are some examples:
272
273 - '(0 . day): this is the default value of `nndiary-reminders'.  It means
274   pop up the appointements of the day each morning at 00:00.
275
276 - '(1 . day): this means pop up the appointements the day before, at 00:00.
277
278 - '(6 . hour): for an appointement at 18:30, this would pop up the
279   appointement message at 12:00.
280
281 - '(360 . minute): for an appointement at 18:30 and 15 seconds, this would
282   pop up the appointement message at 12:30."
283   :group 'nndiary
284   :type '(repeat (cons :format "%v\n"
285                        (integer :format "%v")
286                        (choice :format "%[%v(s)%] before...\n"
287                                :value day
288                                (const :format "%v" minute)
289                                (const :format "%v" hour)
290                                (const :format "%v" day)
291                                (const :format "%v" week)
292                                (const :format "%v" month)
293                                (const :format "%v" year)))))
294
295 (defcustom nndiary-week-starts-on-monday nil
296   "*Whether a week starts on monday (otherwise, sunday)."
297   :type 'boolean
298   :group 'nndiary)
299
300
301 (defcustom nndiary-request-create-group-hooks nil
302   "*Hooks to run after `nndiary-request-create-group' is executed.
303 The hooks will be called with the full group name as argument."
304   :group 'nndiary
305   :type 'hook)
306
307 (defcustom nndiary-request-update-info-hooks nil
308   "*Hooks to run after `nndiary-request-update-info-group' is executed.
309 The hooks will be called with the full group name as argument."
310   :group 'nndiary
311   :type 'hook)
312
313 (defcustom nndiary-request-accept-article-hooks nil
314   "*Hooks to run before accepting an article.
315 Executed near the beginning of `nndiary-request-accept-article'.
316 The hooks will be called with the article in the current buffer."
317   :group 'nndiary
318   :type 'hook)
319
320 (defcustom nndiary-check-directory-twice t
321   "*If t, check directories twice to avoid NFS failures."
322   :group 'nndiary
323   :type 'boolean)
324
325
326 ;; Backend declaration ======================================================
327
328 ;; Well, most of this is nnml clonage.
329
330 (nnoo-declare nndiary)
331
332 (defvoo nndiary-directory (nnheader-concat gnus-directory "diary/")
333   "Spool directory for the nndiary backend.")
334
335 (defvoo nndiary-active-file
336     (expand-file-name "active" nndiary-directory)
337   "Active file for the nndiary backend.")
338
339 (defvoo nndiary-newsgroups-file
340     (expand-file-name "newsgroups" nndiary-directory)
341   "Newsgroups description file for the nndiary backend.")
342
343 (defvoo nndiary-get-new-mail nil
344   "Whether nndiary gets new mail and split it.
345 Contrary to traditional mail backends, this variable can be set to t
346 even if your primary mail backend also retreives mail. In such a case,
347 NDiary uses its own mail-sources and split-methods.")
348
349 (defvoo nndiary-nov-is-evil nil
350   "If non-nil, Gnus will never use nov databases for nndiary groups.
351 Using nov databases will speed up header fetching considerably.
352 This variable shouldn't be flipped much.  If you have, for some reason,
353 set this to t, and want to set it to nil again, you should always run
354 the `nndiary-generate-nov-databases' command.  The function will go
355 through all nnml directories and generate nov databases for them
356 all.  This may very well take some time.")
357
358 (defvoo nndiary-prepare-save-mail-hook nil
359   "*Hook run narrowed to an article before saving.")
360
361 (defvoo nndiary-inhibit-expiry nil
362   "If non-nil, inhibit expiry.")
363
364 \f
365
366 (defconst nndiary-version "0.2-b14"
367   "Current Diary backend version.")
368
369 (defun nndiary-version ()
370   "Current Diary backend version."
371   (interactive)
372   (message "NNDiary version %s" nndiary-version))
373
374
375 (defvoo nndiary-nov-file-name ".overview")
376
377 (defvoo nndiary-current-directory nil)
378 (defvoo nndiary-current-group nil)
379 (defvoo nndiary-status-string "" )
380 (defvoo nndiary-nov-buffer-alist nil)
381 (defvoo nndiary-group-alist nil)
382 (defvoo nndiary-active-timestamp nil)
383 (defvoo nndiary-article-file-alist nil)
384
385 (defvoo nndiary-generate-active-function 'nndiary-generate-active-info)
386 (defvoo nndiary-nov-buffer-file-name nil)
387 (defvoo nndiary-file-coding-system nnmail-file-coding-system)
388
389 (defconst nndiary-headers
390   '(("Minute" 0 59)
391     ("Hour" 0 23)
392     ("Dom" 1 31)
393     ("Month" 1 12)
394     ("Year" 1971)
395     ("Dow" 0 6)
396     ("Time-Zone" (("Y" -43200)
397
398                   ("X" -39600)
399
400                   ("W" -36000)
401
402                   ("V" -32400)
403
404                   ("U" -28800)
405                   ("PST" -28800)
406
407                   ("T"   -25200)
408                   ("MST" -25200)
409                   ("PDT" -25200)
410
411                   ("S"   -21600)
412                   ("CST" -21600)
413                   ("MDT" -21600)
414
415                   ("R"   -18000)
416                   ("EST" -18000)
417                   ("CDT" -18000)
418
419                   ("Q"   -14400)
420                   ("AST" -14400)
421                   ("EDT" -14400)
422
423                   ("P"   -10800)
424                   ("ADT" -10800)
425
426                   ("O" -7200)
427
428                   ("N" -3600)
429
430                   ("Z"   0)
431                   ("GMT" 0)
432                   ("UT"  0)
433                   ("UTC" 0)
434                   ("WET" 0)
435
436                   ("A"    3600)
437                   ("CET"  3600)
438                   ("MET"  3600)
439                   ("MEZ"  3600)
440                   ("BST"  3600)
441                   ("WEST" 3600)
442
443                   ("B"    7200)
444                   ("EET"  7200)
445                   ("CEST" 7200)
446                   ("MEST" 7200)
447                   ("MESZ" 7200)
448
449                   ("C" 10800)
450
451                   ("D" 14400)
452
453                   ("E" 18000)
454
455                   ("F" 21600)
456
457                   ("G" 25200)
458
459                   ("H" 28800)
460
461                   ("I"   32400)
462                   ("JST" 32400)
463
464                   ("K"   36000)
465                   ("GST" 36000)
466
467                   ("L" 39600)
468
469                   ("M"    43200)
470                   ("NZST" 43200)
471
472                   ("NZDT" 46800))))
473   ;; List of NNDiary headers that specify the time spec. Each header name is
474   ;; followed by either two integers (specifying a range of possible values
475   ;; for this header) or one list (specifying all the possible values for this
476   ;; header). In the latter case, the list does NOT include the unspecifyed
477   ;; spec (*).
478   ;; For time zone values, we have symbolic time zone names associated with
479   ;; the (relative) number of seconds ahead GMT.
480   )
481
482
483 ;;; Interface functions =====================================================
484
485 (nnoo-define-basics nndiary)
486
487 (deffoo nndiary-retrieve-headers (sequence &optional group server fetch-old)
488   (when (nndiary-possibly-change-directory group server)
489     (save-excursion
490       (set-buffer nntp-server-buffer)
491       (erase-buffer)
492       (let* ((file nil)
493              (number (length sequence))
494              (count 0)
495              (file-name-coding-system nnmail-pathname-coding-system)
496              beg article
497              (nndiary-check-directory-twice
498               (and nndiary-check-directory-twice
499                    ;; To speed up, disable it in some case.
500                    (or (not (numberp nnmail-large-newsgroup))
501                        (<= number nnmail-large-newsgroup)))))
502         (if (stringp (car sequence))
503             'headers
504           (if (nndiary-retrieve-headers-with-nov sequence fetch-old)
505               'nov
506             (while sequence
507               (setq article (car sequence))
508               (setq file (nndiary-article-to-file article))
509               (when (and file
510                          (file-exists-p file)
511                          (not (file-directory-p file)))
512                 (insert (format "221 %d Article retrieved.\n" article))
513                 (setq beg (point))
514                 (nnheader-insert-head file)
515                 (goto-char beg)
516                 (if (search-forward "\n\n" nil t)
517                     (forward-char -1)
518                   (goto-char (point-max))
519                   (insert "\n\n"))
520                 (insert ".\n")
521                 (delete-region (point) (point-max)))
522               (setq sequence (cdr sequence))
523               (setq count (1+ count))
524               (and (numberp nnmail-large-newsgroup)
525                    (> number nnmail-large-newsgroup)
526                    (zerop (% count 20))
527                    (nnheader-message 6 "nndiary: Receiving headers... %d%%"
528                                      (/ (* count 100) number))))
529
530             (and (numberp nnmail-large-newsgroup)
531                  (> number nnmail-large-newsgroup)
532                  (nnheader-message 6 "nndiary: Receiving headers...done"))
533
534             (nnheader-fold-continuation-lines)
535             'headers))))))
536
537 (deffoo nndiary-open-server (server &optional defs)
538   (nnoo-change-server 'nndiary server defs)
539   (when (not (file-exists-p nndiary-directory))
540     (ignore-errors (make-directory nndiary-directory t)))
541   (cond
542    ((not (file-exists-p nndiary-directory))
543     (nndiary-close-server)
544     (nnheader-report 'nndiary "Couldn't create directory: %s"
545                      nndiary-directory))
546    ((not (file-directory-p (file-truename nndiary-directory)))
547     (nndiary-close-server)
548     (nnheader-report 'nndiary "Not a directory: %s" nndiary-directory))
549    (t
550     (nnheader-report 'nndiary "Opened server %s using directory %s"
551                      server nndiary-directory)
552     t)))
553
554 (deffoo nndiary-request-regenerate (server)
555   (nndiary-possibly-change-directory nil server)
556   (nndiary-generate-nov-databases server)
557   t)
558
559 (deffoo nndiary-request-article (id &optional group server buffer)
560   (nndiary-possibly-change-directory group server)
561   (let* ((nntp-server-buffer (or buffer nntp-server-buffer))
562          (file-name-coding-system nnmail-pathname-coding-system)
563          path gpath group-num)
564     (if (stringp id)
565         (when (and (setq group-num (nndiary-find-group-number id))
566                    (cdr
567                     (assq (cdr group-num)
568                           (nnheader-article-to-file-alist
569                            (setq gpath
570                                  (nnmail-group-pathname
571                                   (car group-num)
572                                   nndiary-directory))))))
573           (setq path (concat gpath (int-to-string (cdr group-num)))))
574       (setq path (nndiary-article-to-file id)))
575     (cond
576      ((not path)
577       (nnheader-report 'nndiary "No such article: %s" id))
578      ((not (file-exists-p path))
579       (nnheader-report 'nndiary "No such file: %s" path))
580      ((file-directory-p path)
581       (nnheader-report 'nndiary "File is a directory: %s" path))
582      ((not (save-excursion (let ((nnmail-file-coding-system
583                                   nndiary-file-coding-system))
584                              (nnmail-find-file path))))
585       (nnheader-report 'nndiary "Couldn't read file: %s" path))
586      (t
587       (nnheader-report 'nndiary "Article %s retrieved" id)
588       ;; We return the article number.
589       (cons (if group-num (car group-num) group)
590             (string-to-int (file-name-nondirectory path)))))))
591
592 (deffoo nndiary-request-group (group &optional server dont-check)
593   (let ((file-name-coding-system nnmail-pathname-coding-system))
594     (cond
595      ((not (nndiary-possibly-change-directory group server))
596       (nnheader-report 'nndiary "Invalid group (no such directory)"))
597      ((not (file-exists-p nndiary-current-directory))
598       (nnheader-report 'nndiary "Directory %s does not exist"
599                        nndiary-current-directory))
600      ((not (file-directory-p nndiary-current-directory))
601       (nnheader-report 'nndiary "%s is not a directory"
602                        nndiary-current-directory))
603      (dont-check
604       (nnheader-report 'nndiary "Group %s selected" group)
605       t)
606      (t
607       (nnheader-re-read-dir nndiary-current-directory)
608       (nnmail-activate 'nndiary)
609       (let ((active (nth 1 (assoc group nndiary-group-alist))))
610         (if (not active)
611             (nnheader-report 'nndiary "No such group: %s" group)
612           (nnheader-report 'nndiary "Selected group %s" group)
613           (nnheader-insert "211 %d %d %d %s\n"
614                            (max (1+ (- (cdr active) (car active))) 0)
615                            (car active) (cdr active) group)))))))
616
617 (deffoo nndiary-request-scan (&optional group server)
618   ;; Use our own mail sources and split methods while Gnus doesn't let us have
619   ;; multiple backends for retrieving mail.
620   (let ((mail-sources nndiary-mail-sources)
621         (nnmail-split-methods nndiary-split-methods))
622     (setq nndiary-article-file-alist nil)
623     (nndiary-possibly-change-directory group server)
624     (nnmail-get-new-mail 'nndiary 'nndiary-save-nov nndiary-directory group)))
625
626 (deffoo nndiary-close-group (group &optional server)
627   (setq nndiary-article-file-alist nil)
628   t)
629
630 (deffoo nndiary-request-create-group (group &optional server args)
631   (nndiary-possibly-change-directory nil server)
632   (nnmail-activate 'nndiary)
633   (cond
634    ((assoc group nndiary-group-alist)
635     t)
636    ((and (file-exists-p (nnmail-group-pathname group nndiary-directory))
637          (not (file-directory-p (nnmail-group-pathname
638                                  group nndiary-directory))))
639     (nnheader-report 'nndiary "%s is a file"
640                      (nnmail-group-pathname group nndiary-directory)))
641    (t
642     (let (active)
643       (push (list group (setq active (cons 1 0)))
644             nndiary-group-alist)
645       (nndiary-possibly-create-directory group)
646       (nndiary-possibly-change-directory group server)
647       (let ((articles (nnheader-directory-articles nndiary-current-directory)))
648         (when articles
649           (setcar active (apply 'min articles))
650           (setcdr active (apply 'max articles))))
651       (nnmail-save-active nndiary-group-alist nndiary-active-file)
652       (run-hook-with-args 'nndiary-request-create-group-hooks
653                           (gnus-group-prefixed-name group
654                                                     (list "nndiary" server)))
655       t))
656    ))
657
658 (deffoo nndiary-request-list (&optional server)
659   (save-excursion
660     (let ((nnmail-file-coding-system nnmail-active-file-coding-system)
661           (file-name-coding-system nnmail-pathname-coding-system))
662       (nnmail-find-file nndiary-active-file))
663     (setq nndiary-group-alist (nnmail-get-active))
664     t))
665
666 (deffoo nndiary-request-newgroups (date &optional server)
667   (nndiary-request-list server))
668
669 (deffoo nndiary-request-list-newsgroups (&optional server)
670   (save-excursion
671     (nnmail-find-file nndiary-newsgroups-file)))
672
673 (deffoo nndiary-request-expire-articles (articles group &optional server force)
674   (nndiary-possibly-change-directory group server)
675   (let ((active-articles
676          (nnheader-directory-articles nndiary-current-directory))
677         article rest number)
678     (nnmail-activate 'nndiary)
679     ;; Articles not listed in active-articles are already gone,
680     ;; so don't try to expire them.
681     (setq articles (gnus-intersection articles active-articles))
682     (while articles
683       (setq article (nndiary-article-to-file (setq number (pop articles))))
684       (if (and (nndiary-deletable-article-p group number)
685                ;; Don't use nnmail-expired-article-p. Our notion of expiration
686                ;; is a bit peculiar ...
687                (or force (nndiary-expired-article-p article)))
688           (progn
689             ;; Allow a special target group.
690             (unless (eq nnmail-expiry-target 'delete)
691               (with-temp-buffer
692                 (nndiary-request-article number group server (current-buffer))
693                 (let ((nndiary-current-directory nil))
694                   (nnmail-expiry-target-group nnmail-expiry-target group))))
695             (nnheader-message 5 "Deleting article %s in %s" number group)
696             (condition-case ()
697                 (funcall nnmail-delete-file-function article)
698               (file-error (push number rest)))
699             (setq active-articles (delq number active-articles))
700             (nndiary-nov-delete-article group number))
701         (push number rest)))
702     (let ((active (nth 1 (assoc group nndiary-group-alist))))
703       (when active
704         (setcar active (or (and active-articles
705                                 (apply 'min active-articles))
706                            (1+ (cdr active)))))
707       (nnmail-save-active nndiary-group-alist nndiary-active-file))
708     (nndiary-save-nov)
709     (nconc rest articles)))
710
711 (deffoo nndiary-request-move-article
712     (article group server accept-form &optional last)
713   (let ((buf (get-buffer-create " *nndiary move*"))
714         result)
715     (nndiary-possibly-change-directory group server)
716     (nndiary-update-file-alist)
717     (and
718      (nndiary-deletable-article-p group article)
719      (nndiary-request-article article group server)
720      (let (nndiary-current-directory
721            nndiary-current-group
722            nndiary-article-file-alist)
723        (save-excursion
724          (set-buffer buf)
725          (insert-buffer-substring nntp-server-buffer)
726          (setq result (eval accept-form))
727          (kill-buffer (current-buffer))
728          result))
729      (progn
730        (nndiary-possibly-change-directory group server)
731        (condition-case ()
732            (funcall nnmail-delete-file-function
733                     (nndiary-article-to-file  article))
734          (file-error nil))
735        (nndiary-nov-delete-article group article)
736        (when last
737          (nndiary-save-nov)
738          (nnmail-save-active nndiary-group-alist nndiary-active-file))))
739     result))
740
741 (deffoo nndiary-request-accept-article (group &optional server last)
742   (nndiary-possibly-change-directory group server)
743   (nnmail-check-syntax)
744   (run-hooks 'nndiary-request-accept-article-hooks)
745   (when (nndiary-schedule)
746     (let (result)
747       (when nnmail-cache-accepted-message-ids
748         (nnmail-cache-insert (nnmail-fetch-field "message-id")))
749       (if (stringp group)
750           (and
751            (nnmail-activate 'nndiary)
752            (setq result
753                  (car (nndiary-save-mail
754                        (list (cons group (nndiary-active-number group))))))
755            (progn
756              (nnmail-save-active nndiary-group-alist nndiary-active-file)
757              (and last (nndiary-save-nov))))
758         (and
759          (nnmail-activate 'nndiary)
760          (if (and (not (setq result
761                              (nnmail-article-group 'nndiary-active-number)))
762                   (yes-or-no-p "Moved to `junk' group; delete article? "))
763              (setq result 'junk)
764            (setq result (car (nndiary-save-mail result))))
765          (when last
766            (nnmail-save-active nndiary-group-alist nndiary-active-file)
767            (when nnmail-cache-accepted-message-ids
768              (nnmail-cache-close))
769            (nndiary-save-nov))))
770       result))
771   )
772
773 (deffoo nndiary-request-post (&optional server)
774   (nnmail-do-request-post 'nndiary-request-accept-article server))
775
776 (deffoo nndiary-request-replace-article (article group buffer)
777   (nndiary-possibly-change-directory group)
778   (save-excursion
779     (set-buffer buffer)
780     (nndiary-possibly-create-directory group)
781     (let ((chars (nnmail-insert-lines))
782           (art (concat (int-to-string article) "\t"))
783           headers)
784       (when (ignore-errors
785               (nnmail-write-region
786                (point-min) (point-max)
787                (or (nndiary-article-to-file article)
788                    (expand-file-name (int-to-string article)
789                                      nndiary-current-directory))
790                nil (if (nnheader-be-verbose 5) nil 'nomesg))
791               t)
792         (setq headers (nndiary-parse-head chars article))
793         ;; Replace the NOV line in the NOV file.
794         (save-excursion
795           (set-buffer (nndiary-open-nov group))
796           (goto-char (point-min))
797           (if (or (looking-at art)
798                   (search-forward (concat "\n" art) nil t))
799               ;; Delete the old NOV line.
800               (delete-region (progn (beginning-of-line) (point))
801                              (progn (forward-line 1) (point)))
802             ;; The line isn't here, so we have to find out where
803             ;; we should insert it.  (This situation should never
804             ;; occur, but one likes to make sure...)
805             (while (and (looking-at "[0-9]+\t")
806                         (< (string-to-int
807                             (buffer-substring
808                              (match-beginning 0) (match-end 0)))
809                            article)
810                         (zerop (forward-line 1)))))
811           (beginning-of-line)
812           (nnheader-insert-nov headers)
813           (nndiary-save-nov)
814           t)))))
815
816 (deffoo nndiary-request-delete-group (group &optional force server)
817   (nndiary-possibly-change-directory group server)
818   (when force
819     ;; Delete all articles in GROUP.
820     (let ((articles
821            (directory-files
822             nndiary-current-directory t
823             (concat nnheader-numerical-short-files
824                     "\\|" (regexp-quote nndiary-nov-file-name) "$")))
825           article)
826       (while articles
827         (setq article (pop articles))
828         (when (file-writable-p article)
829           (nnheader-message 5 "Deleting article %s in %s..." article group)
830           (funcall nnmail-delete-file-function article))))
831     ;; Try to delete the directory itself.
832     (ignore-errors (delete-directory nndiary-current-directory)))
833   ;; Remove the group from all structures.
834   (setq nndiary-group-alist
835         (delq (assoc group nndiary-group-alist) nndiary-group-alist)
836         nndiary-current-group nil
837         nndiary-current-directory nil)
838   ;; Save the active file.
839   (nnmail-save-active nndiary-group-alist nndiary-active-file)
840   t)
841
842 (deffoo nndiary-request-rename-group (group new-name &optional server)
843   (nndiary-possibly-change-directory group server)
844   (let ((new-dir (nnmail-group-pathname new-name nndiary-directory))
845         (old-dir (nnmail-group-pathname group nndiary-directory)))
846     (when (ignore-errors
847             (make-directory new-dir t)
848             t)
849       ;; We move the articles file by file instead of renaming
850       ;; the directory -- there may be subgroups in this group.
851       ;; One might be more clever, I guess.
852       (let ((files (nnheader-article-to-file-alist old-dir)))
853         (while files
854           (rename-file
855            (concat old-dir (cdar files))
856            (concat new-dir (cdar files)))
857           (pop files)))
858       ;; Move .overview file.
859       (let ((overview (concat old-dir nndiary-nov-file-name)))
860         (when (file-exists-p overview)
861           (rename-file overview (concat new-dir nndiary-nov-file-name))))
862       (when (<= (length (directory-files old-dir)) 2)
863         (ignore-errors (delete-directory old-dir)))
864       ;; That went ok, so we change the internal structures.
865       (let ((entry (assoc group nndiary-group-alist)))
866         (when entry
867           (setcar entry new-name))
868         (setq nndiary-current-directory nil
869               nndiary-current-group nil)
870         ;; Save the new group alist.
871         (nnmail-save-active nndiary-group-alist nndiary-active-file)
872         t))))
873
874 (deffoo nndiary-set-status (article name value &optional group server)
875   (nndiary-possibly-change-directory group server)
876   (let ((file (nndiary-article-to-file article)))
877     (cond
878      ((not (file-exists-p file))
879       (nnheader-report 'nndiary "File %s does not exist" file))
880      (t
881       (with-temp-file file
882         (nnheader-insert-file-contents file)
883         (nnmail-replace-status name value))
884       t))))
885
886 \f
887 ;;; Interface optional functions ============================================
888
889 (deffoo nndiary-request-update-info (group info &optional server)
890   (nndiary-possibly-change-directory group)
891   (let ((timestamp (gnus-group-parameter-value (gnus-info-params info)
892                                                'timestamp t)))
893     (if (not timestamp)
894         (nnheader-report 'nndiary "Group %s doesn't have a timestamp" group)
895       ;; else
896       ;; Figure out which articles should be re-new'ed
897       (let ((articles (nndiary-flatten (gnus-info-read info) 0))
898             article file unread buf)
899         (save-excursion
900           (setq buf (nnheader-set-temp-buffer " *nndiary update*"))
901           (while (setq article (pop articles))
902             (setq file (concat nndiary-current-directory
903                                (int-to-string article)))
904             (and (file-exists-p file)
905                  (nndiary-renew-article-p file timestamp)
906                  (push article unread)))
907           ;;(message "unread: %s" unread)
908           (sit-for 1)
909           (kill-buffer buf))
910         (setq unread (sort unread '<))
911         (and unread
912              (gnus-info-set-read info (gnus-update-read-articles
913                                        (gnus-info-group info) unread t)))
914         ))
915     (run-hook-with-args 'nndiary-request-update-info-hooks
916                         (gnus-info-group info))
917     t))
918
919
920 \f
921 ;;; Internal functions ======================================================
922
923 (defun nndiary-article-to-file (article)
924   (nndiary-update-file-alist)
925   (let (file)
926     (if (setq file (cdr (assq article nndiary-article-file-alist)))
927         (expand-file-name file nndiary-current-directory)
928       ;; Just to make sure nothing went wrong when reading over NFS --
929       ;; check once more.
930       (if nndiary-check-directory-twice
931           (when (file-exists-p
932                  (setq file (expand-file-name (number-to-string article)
933                                               nndiary-current-directory)))
934             (nndiary-update-file-alist t)
935             file)))))
936
937 (defun nndiary-deletable-article-p (group article)
938   "Say whether ARTICLE in GROUP can be deleted."
939   (let (path)
940     (when (setq path (nndiary-article-to-file article))
941       (when (file-writable-p path)
942         (or (not nnmail-keep-last-article)
943             (not (eq (cdr (nth 1 (assoc group nndiary-group-alist)))
944                      article)))))))
945
946 ;; Find an article number in the current group given the Message-ID.
947 (defun nndiary-find-group-number (id)
948   (save-excursion
949     (set-buffer (get-buffer-create " *nndiary id*"))
950     (let ((alist nndiary-group-alist)
951           number)
952       ;; We want to look through all .overview files, but we want to
953       ;; start with the one in the current directory.  It seems most
954       ;; likely that the article we are looking for is in that group.
955       (if (setq number (nndiary-find-id nndiary-current-group id))
956           (cons nndiary-current-group number)
957         ;; It wasn't there, so we look through the other groups as well.
958         (while (and (not number)
959                     alist)
960           (or (string= (caar alist) nndiary-current-group)
961               (setq number (nndiary-find-id (caar alist) id)))
962           (or number
963               (setq alist (cdr alist))))
964         (and number
965              (cons (caar alist) number))))))
966
967 (defun nndiary-find-id (group id)
968   (erase-buffer)
969   (let ((nov (expand-file-name nndiary-nov-file-name
970                                (nnmail-group-pathname group
971                                                       nndiary-directory)))
972         number found)
973     (when (file-exists-p nov)
974       (nnheader-insert-file-contents nov)
975       (while (and (not found)
976                   (search-forward id nil t)) ; We find the ID.
977         ;; And the id is in the fourth field.
978         (if (not (and (search-backward "\t" nil t 4)
979                       (not (search-backward"\t" (gnus-point-at-bol) t))))
980             (forward-line 1)
981           (beginning-of-line)
982           (setq found t)
983           ;; We return the article number.
984           (setq number
985                 (ignore-errors (read (current-buffer))))))
986       number)))
987
988 (defun nndiary-retrieve-headers-with-nov (articles &optional fetch-old)
989   (if (or gnus-nov-is-evil nndiary-nov-is-evil)
990       nil
991     (let ((nov (expand-file-name nndiary-nov-file-name
992                                  nndiary-current-directory)))
993       (when (file-exists-p nov)
994         (save-excursion
995           (set-buffer nntp-server-buffer)
996           (erase-buffer)
997           (nnheader-insert-file-contents nov)
998           (if (and fetch-old
999                    (not (numberp fetch-old)))
1000               t                         ; Don't remove anything.
1001             (nnheader-nov-delete-outside-range
1002              (if fetch-old (max 1 (- (car articles) fetch-old))
1003                (car articles))
1004              (car (last articles)))
1005             t))))))
1006
1007 (defun nndiary-possibly-change-directory (group &optional server)
1008   (when (and server
1009              (not (nndiary-server-opened server)))
1010     (nndiary-open-server server))
1011   (if (not group)
1012       t
1013     (let ((pathname (nnmail-group-pathname group nndiary-directory))
1014           (file-name-coding-system nnmail-pathname-coding-system))
1015       (when (not (equal pathname nndiary-current-directory))
1016         (setq nndiary-current-directory pathname
1017               nndiary-current-group group
1018               nndiary-article-file-alist nil))
1019       (file-exists-p nndiary-current-directory))))
1020
1021 (defun nndiary-possibly-create-directory (group)
1022   (let ((dir (nnmail-group-pathname group nndiary-directory)))
1023     (unless (file-exists-p dir)
1024       (make-directory (directory-file-name dir) t)
1025       (nnheader-message 5 "Creating mail directory %s" dir))))
1026
1027 (defun nndiary-save-mail (group-art)
1028   "Called narrowed to an article."
1029   (let (chars headers)
1030     (setq chars (nnmail-insert-lines))
1031     (nnmail-insert-xref group-art)
1032     (run-hooks 'nnmail-prepare-save-mail-hook)
1033     (run-hooks 'nndiary-prepare-save-mail-hook)
1034     (goto-char (point-min))
1035     (while (looking-at "From ")
1036       (replace-match "X-From-Line: ")
1037       (forward-line 1))
1038     ;; We save the article in all the groups it belongs in.
1039     (let ((ga group-art)
1040           first)
1041       (while ga
1042         (nndiary-possibly-create-directory (caar ga))
1043         (let ((file (concat (nnmail-group-pathname
1044                              (caar ga) nndiary-directory)
1045                             (int-to-string (cdar ga)))))
1046           (if first
1047               ;; It was already saved, so we just make a hard link.
1048               (funcall nnmail-crosspost-link-function first file t)
1049             ;; Save the article.
1050             (nnmail-write-region (point-min) (point-max) file nil
1051                                  (if (nnheader-be-verbose 5) nil 'nomesg))
1052             (setq first file)))
1053         (setq ga (cdr ga))))
1054     ;; Generate a nov line for this article.  We generate the nov
1055     ;; line after saving, because nov generation destroys the
1056     ;; header.
1057     (setq headers (nndiary-parse-head chars))
1058     ;; Output the nov line to all nov databases that should have it.
1059     (let ((ga group-art))
1060       (while ga
1061         (nndiary-add-nov (caar ga) (cdar ga) headers)
1062         (setq ga (cdr ga))))
1063     group-art))
1064
1065 (defun nndiary-active-number (group)
1066   "Compute the next article number in GROUP."
1067   (let ((active (cadr (assoc group nndiary-group-alist))))
1068     ;; The group wasn't known to nndiary, so we just create an active
1069     ;; entry for it.
1070     (unless active
1071       ;; Perhaps the active file was corrupt?  See whether
1072       ;; there are any articles in this group.
1073       (nndiary-possibly-create-directory group)
1074       (nndiary-possibly-change-directory group)
1075       (unless nndiary-article-file-alist
1076         (setq nndiary-article-file-alist
1077               (sort
1078                (nnheader-article-to-file-alist nndiary-current-directory)
1079                'car-less-than-car)))
1080       (setq active
1081             (if nndiary-article-file-alist
1082                 (cons (caar nndiary-article-file-alist)
1083                       (caar (last nndiary-article-file-alist)))
1084               (cons 1 0)))
1085       (push (list group active) nndiary-group-alist))
1086     (setcdr active (1+ (cdr active)))
1087     (while (file-exists-p
1088             (expand-file-name (int-to-string (cdr active))
1089                               (nnmail-group-pathname group nndiary-directory)))
1090       (setcdr active (1+ (cdr active))))
1091     (cdr active)))
1092
1093 (defun nndiary-add-nov (group article headers)
1094   "Add a nov line for the GROUP base."
1095   (save-excursion
1096     (set-buffer (nndiary-open-nov group))
1097     (goto-char (point-max))
1098     (mail-header-set-number headers article)
1099     (nnheader-insert-nov headers)))
1100
1101 (defsubst nndiary-header-value ()
1102   (buffer-substring (match-end 0) (progn (end-of-line) (point))))
1103
1104 (defun nndiary-parse-head (chars &optional number)
1105   "Parse the head of the current buffer."
1106   (save-excursion
1107     (save-restriction
1108       (unless (zerop (buffer-size))
1109         (narrow-to-region
1110          (goto-char (point-min))
1111          (if (search-forward "\n\n" nil t) (1- (point)) (point-max))))
1112       ;; Fold continuation lines.
1113       (goto-char (point-min))
1114       (while (re-search-forward "\\(\r?\n[ \t]+\\)+" nil t)
1115         (replace-match " " t t))
1116       ;; Remove any tabs; they are too confusing.
1117       (subst-char-in-region (point-min) (point-max) ?\t ? )
1118       (let ((headers (nnheader-parse-head t)))
1119         (mail-header-set-chars headers chars)
1120         (mail-header-set-number headers number)
1121         headers))))
1122
1123 (defun nndiary-open-nov (group)
1124   (or (cdr (assoc group nndiary-nov-buffer-alist))
1125       (let ((buffer (get-buffer-create (format " *nndiary overview %s*"
1126                                                group))))
1127         (save-excursion
1128           (set-buffer buffer)
1129           (set (make-local-variable 'nndiary-nov-buffer-file-name)
1130                (expand-file-name
1131                 nndiary-nov-file-name
1132                 (nnmail-group-pathname group nndiary-directory)))
1133           (erase-buffer)
1134           (when (file-exists-p nndiary-nov-buffer-file-name)
1135             (nnheader-insert-file-contents nndiary-nov-buffer-file-name)))
1136         (push (cons group buffer) nndiary-nov-buffer-alist)
1137         buffer)))
1138
1139 (defun nndiary-save-nov ()
1140   (save-excursion
1141     (while nndiary-nov-buffer-alist
1142       (when (buffer-name (cdar nndiary-nov-buffer-alist))
1143         (set-buffer (cdar nndiary-nov-buffer-alist))
1144         (when (buffer-modified-p)
1145           (nnmail-write-region 1 (point-max) nndiary-nov-buffer-file-name
1146                                nil 'nomesg))
1147         (set-buffer-modified-p nil)
1148         (kill-buffer (current-buffer)))
1149       (setq nndiary-nov-buffer-alist (cdr nndiary-nov-buffer-alist)))))
1150
1151 ;;;###autoload
1152 (defun nndiary-generate-nov-databases (&optional server)
1153   "Generate NOV databases in all nndiary directories."
1154   (interactive (list (or (nnoo-current-server 'nndiary) "")))
1155   ;; Read the active file to make sure we don't re-use articles
1156   ;; numbers in empty groups.
1157   (nnmail-activate 'nndiary)
1158   (unless (nndiary-server-opened server)
1159     (nndiary-open-server server))
1160   (setq nndiary-directory (expand-file-name nndiary-directory))
1161   ;; Recurse down the directories.
1162   (nndiary-generate-nov-databases-1 nndiary-directory nil t)
1163   ;; Save the active file.
1164   (nnmail-save-active nndiary-group-alist nndiary-active-file))
1165
1166 (defun nndiary-generate-nov-databases-1 (dir &optional seen no-active)
1167   "Regenerate the NOV database in DIR."
1168   (interactive "DRegenerate NOV in: ")
1169   (setq dir (file-name-as-directory dir))
1170   ;; Only scan this sub-tree if we haven't been here yet.
1171   (unless (member (file-truename dir) seen)
1172     (push (file-truename dir) seen)
1173     ;; We descend recursively
1174     (let ((dirs (directory-files dir t nil t))
1175           dir)
1176       (while (setq dir (pop dirs))
1177         (when (and (not (string-match "^\\." (file-name-nondirectory dir)))
1178                    (file-directory-p dir))
1179           (nndiary-generate-nov-databases-1 dir seen))))
1180     ;; Do this directory.
1181     (let ((files (sort (nnheader-article-to-file-alist dir)
1182                        'car-less-than-car)))
1183       (if (not files)
1184           (let* ((group (nnheader-file-to-group
1185                          (directory-file-name dir) nndiary-directory))
1186                  (info (cadr (assoc group nndiary-group-alist))))
1187             (when info
1188               (setcar info (1+ (cdr info)))))
1189         (funcall nndiary-generate-active-function dir)
1190         ;; Generate the nov file.
1191         (nndiary-generate-nov-file dir files)
1192         (unless no-active
1193           (nnmail-save-active nndiary-group-alist nndiary-active-file))))))
1194
1195 (eval-when-compile (defvar files))
1196 (defun nndiary-generate-active-info (dir)
1197   ;; Update the active info for this group.
1198   (let* ((group (nnheader-file-to-group
1199                  (directory-file-name dir) nndiary-directory))
1200          (entry (assoc group nndiary-group-alist))
1201          (last (or (caadr entry) 0)))
1202     (setq nndiary-group-alist (delq entry nndiary-group-alist))
1203     (push (list group
1204                 (cons (or (caar files) (1+ last))
1205                       (max last
1206                            (or (let ((f files))
1207                                  (while (cdr f) (setq f (cdr f)))
1208                                  (caar f))
1209                                0))))
1210           nndiary-group-alist)))
1211
1212 (defun nndiary-generate-nov-file (dir files)
1213   (let* ((dir (file-name-as-directory dir))
1214          (nov (concat dir nndiary-nov-file-name))
1215          (nov-buffer (get-buffer-create " *nov*"))
1216          chars file headers)
1217     (save-excursion
1218       ;; Init the nov buffer.
1219       (set-buffer nov-buffer)
1220       (buffer-disable-undo)
1221       (erase-buffer)
1222       (set-buffer nntp-server-buffer)
1223       ;; Delete the old NOV file.
1224       (when (file-exists-p nov)
1225         (funcall nnmail-delete-file-function nov))
1226       (while files
1227         (unless (file-directory-p (setq file (concat dir (cdar files))))
1228           (erase-buffer)
1229           (nnheader-insert-file-contents file)
1230           (narrow-to-region
1231            (goto-char (point-min))
1232            (progn
1233              (search-forward "\n\n" nil t)
1234              (setq chars (- (point-max) (point)))
1235              (max 1 (1- (point)))))
1236           (unless (zerop (buffer-size))
1237             (goto-char (point-min))
1238             (setq headers (nndiary-parse-head chars (caar files)))
1239             (save-excursion
1240               (set-buffer nov-buffer)
1241               (goto-char (point-max))
1242               (nnheader-insert-nov headers)))
1243           (widen))
1244         (setq files (cdr files)))
1245       (save-excursion
1246         (set-buffer nov-buffer)
1247         (nnmail-write-region 1 (point-max) nov nil 'nomesg)
1248         (kill-buffer (current-buffer))))))
1249
1250 (defun nndiary-nov-delete-article (group article)
1251   (save-excursion
1252     (set-buffer (nndiary-open-nov group))
1253     (when (nnheader-find-nov-line article)
1254       (delete-region (point) (progn (forward-line 1) (point)))
1255       (when (bobp)
1256         (let ((active (cadr (assoc group nndiary-group-alist)))
1257               num)
1258           (when active
1259             (if (eobp)
1260                 (setf (car active) (1+ (cdr active)))
1261               (when (and (setq num (ignore-errors (read (current-buffer))))
1262                          (numberp num))
1263                 (setf (car active) num)))))))
1264     t))
1265
1266 (defun nndiary-update-file-alist (&optional force)
1267   (when (or (not nndiary-article-file-alist)
1268             force)
1269     (setq nndiary-article-file-alist
1270           (nnheader-article-to-file-alist nndiary-current-directory))))
1271
1272
1273 (defun nndiary-string-to-int (str min &optional max)
1274   ;; Like `string-to-int' but barf if STR is not exactly an integer, and not
1275   ;; within the specified bounds.
1276   ;; Signals are caught by `nndiary-schedule'.
1277   (if (not (string-match "^[ \t]*[0-9]+[ \t]*$" str))
1278       (nndiary-error "not an integer value")
1279     ;; else
1280     (let ((val (string-to-int str)))
1281       (and (or (< val min)
1282                (and max (> val max)))
1283            (nndiary-error "value out of range"))
1284       val)))
1285
1286 (defun nndiary-parse-schedule-value (str min-or-values max)
1287   ;; Parse the schedule string STR, or signal an error.
1288   ;; Signals are caught by `nndary-schedule'.
1289   (if (string-match "[ \t]*\\*[ \t]*" str)
1290       ;; unspecifyed
1291       nil
1292     ;; specifyed
1293     (if (listp min-or-values)
1294         ;; min-or-values is values
1295         ;; #### NOTE: this is actually only a hack for time zones.
1296         (let ((val (and (string-match "[ \t]*\\([^ \t]+\\)[ \t]*" str)
1297                         (match-string 1 str))))
1298           (if (and val (setq val (assoc val min-or-values)))
1299               (list (cadr val))
1300             (nndiary-error "invalid syntax")))
1301       ;; min-or-values is min
1302       (mapcar
1303        (lambda (val)
1304          (let ((res (split-string val "-")))
1305            (cond
1306             ((= (length res) 1)
1307              (nndiary-string-to-int (car res) min-or-values max))
1308             ((= (length res) 2)
1309              ;; don't know if crontab accepts this, but ensure
1310              ;; that BEG is <= END
1311              (let ((beg (nndiary-string-to-int (car res) min-or-values max))
1312                    (end (nndiary-string-to-int (cadr res) min-or-values max)))
1313                (cond ((< beg end)
1314                       (cons beg end))
1315                      ((= beg end)
1316                       beg)
1317                      (t
1318                       (cons end beg)))))
1319             (t
1320              (nndiary-error "invalid syntax")))
1321            ))
1322        (split-string str ",")))
1323     ))
1324
1325 ;; ### FIXME: remove this function if it's used only once.
1326 (defun nndiary-parse-schedule (head min-or-values max)
1327   ;; Parse the cron-like value of header X-Diary-HEAD in current buffer.
1328   ;; - Returns nil if `*'
1329   ;; - Otherwise returns a list of integers and/or ranges (BEG . END)
1330   ;; The exception is the Timze-Zone value which is always of the form (STR).
1331   ;; Signals are caught by `nndary-schedule'.
1332   (let ((header (format "^X-Diary-%s: \\(.*\\)$" head)))
1333     (goto-char (point-min))
1334     (if (not (re-search-forward header nil t))
1335         (nndiary-error "header missing")
1336       ;; else
1337       (nndiary-parse-schedule-value (match-string 1) min-or-values max))
1338     ))
1339
1340 (defsubst nndiary-schedule ()
1341   (let (head)
1342     (condition-case arg
1343         (mapcar
1344          (lambda (elt)
1345            (setq head (nth 0 elt))
1346            (nndiary-parse-schedule (nth 0 elt) (nth 1 elt) (nth 2 elt)))
1347          nndiary-headers)
1348       (t
1349        (nnheader-report 'nndiary "X-Diary-%s header parse error: %s."
1350                         head (cdr arg))
1351        nil))
1352     ))
1353
1354 (defun nndiary-max (spec)
1355   ;; Returns the max of specification SPEC, or nil for permanent schedules.
1356   (unless (null spec)
1357     (let ((elts spec)
1358           (max 0)
1359           elt)
1360       (while (setq elt (pop elts))
1361         (if (integerp elt)
1362             (and (> elt max) (setq max elt))
1363           (and (> (cdr elt) max) (setq max (cdr elt)))))
1364       max)))
1365
1366 (defun nndiary-flatten (spec min &optional max)
1367   ;; flatten the spec by expanding ranges to all possible values.
1368   (let (flat n)
1369     (cond ((null spec)
1370            ;; this happens when I flatten something else than one of my
1371            ;; schedules (a list of read articles for instance).
1372            (unless (null max)
1373              (setq n min)
1374              (while (<= n max)
1375                (push n flat)
1376                (setq n (1+ n)))))
1377           (t
1378            (let ((elts spec)
1379                  elt)
1380              (while (setq elt (pop elts))
1381                (if (integerp elt)
1382                    (push elt flat)
1383                  ;; else
1384                  (setq n (car elt))
1385                  (while (<= n (cdr elt))
1386                    (push n flat)
1387                    (setq n (1+ n))))))))
1388     flat))
1389
1390 (defun nndiary-unflatten (spec)
1391   ;; opposite of flatten: build ranges if possible
1392   (setq spec (sort spec '<))
1393   (let (min max res)
1394     (while (setq min (pop spec))
1395       (setq max min)
1396       (while (and (car spec) (= (car spec) (1+ max)))
1397         (setq max (1+ max))
1398         (pop spec))
1399       (if (= max min)
1400           (setq res (append res (list min)))
1401         (setq res (append res (list (cons min max))))))
1402     res))
1403
1404 (defun nndiary-compute-reminders (date)
1405   ;; Returns a list of times corresponding to the reminders of date DATE.
1406   ;; See the comment in `nndiary-reminders' about rounding.
1407   (let* ((reminders nndiary-reminders)
1408          (date-elts (decode-time date))
1409          ;; ### NOTE: out-of-range values are accepted by encode-time. This
1410          ;; makes our life easier.
1411          (monday (- (nth 3 date-elts)
1412                     (if nndiary-week-starts-on-monday
1413                         (if (zerop (nth 6 date-elts))
1414                             6
1415                           (- (nth 6 date-elts) 1))
1416                       (nth 6 date-elts))))
1417          reminder res)
1418     ;; remove the DOW and DST entries
1419     (setf (nthcdr 6 date-elts) (nthcdr 8 date-elts))
1420     (while (setq reminder (pop reminders))
1421       (push
1422        (cond ((eq (cdr reminder) 'minute)
1423               (subtract-time
1424                (apply 'encode-time 0 (nthcdr 1 date-elts))
1425                (seconds-to-time (* (car reminder) 60.0))))
1426              ((eq (cdr reminder) 'hour)
1427               (subtract-time
1428                (apply 'encode-time 0 0 (nthcdr 2 date-elts))
1429                (seconds-to-time (* (car reminder) 3600.0))))
1430              ((eq (cdr reminder) 'day)
1431               (subtract-time
1432                (apply 'encode-time 0 0 0 (nthcdr 3 date-elts))
1433                (seconds-to-time (* (car reminder) 86400.0))))
1434              ((eq (cdr reminder) 'week)
1435               (subtract-time
1436                (apply 'encode-time 0 0 0 monday (nthcdr 4 date-elts))
1437                (seconds-to-time (* (car reminder) 604800.0))))
1438              ((eq (cdr reminder) 'month)
1439               (subtract-time
1440                (apply 'encode-time 0 0 0 1 (nthcdr 4 date-elts))
1441                (seconds-to-time (* (car reminder) 18748800.0))))
1442              ((eq (cdr reminder) 'year)
1443               (subtract-time
1444                (apply 'encode-time 0 0 0 1 1 (nthcdr 5 date-elts))
1445                (seconds-to-time (* (car reminder) 400861056.0)))))
1446        res))
1447     (sort res 'time-less-p)))
1448
1449 (defun nndiary-last-occurence (sched)
1450   ;; Returns the last occurence of schedule SCHED as an Emacs time struct, or
1451   ;; nil for permanent schedule or errors.
1452   (let ((minute (nndiary-max (nth 0 sched)))
1453         (hour (nndiary-max (nth 1 sched)))
1454         (year (nndiary-max (nth 4 sched)))
1455         (time-zone (or (and (nth 6 sched) (car (nth 6 sched)))
1456                        (current-time-zone))))
1457     (when year
1458       (or minute (setq minute 59))
1459       (or hour (setq hour 23))
1460       ;; I'll just compute all possible values and test them by decreasing
1461       ;; order until one succeeds. This is probably quide rude, but I got
1462       ;; bored in finding a good algorithm for doing that ;-)
1463       ;; ### FIXME: remove identical entries.
1464       (let ((dom-list (nth 2 sched))
1465             (month-list (sort (nndiary-flatten (nth 3 sched) 1 12) '>))
1466             (year-list (sort (nndiary-flatten (nth 4 sched) 1971) '>))
1467             (dow-list (nth 5 sched)))
1468         ;; Special case: an asterisk in one of the days specifications means
1469         ;; that only the other should be taken into account. If both are
1470         ;; unspecified, you would get all possible days in both.
1471         (cond ((null dow-list)
1472                ;; this gets all days if dom-list is nil
1473                (setq dom-list (nndiary-flatten dom-list 1 31)))
1474               ((null dom-list)
1475                ;; this also gets all days if dow-list is nil
1476                (setq dow-list (nndiary-flatten dow-list 0 6)))
1477               (t
1478                (setq dom-list (nndiary-flatten dom-list 1 31))
1479                (setq dow-list (nndiary-flatten dow-list 0 6))))
1480         (or
1481          (catch 'found
1482            (while (setq year (pop year-list))
1483              (let ((months month-list)
1484                    month)
1485                (while (setq month (pop months))
1486                  ;; Now we must merge the Dows with the Doms. To do that, we
1487                  ;; have to know which day is the 1st one for this month.
1488                  ;; Maybe there's simpler, but decode-time(encode-time) will
1489                  ;; give us the answer.
1490                  (let ((first (nth 6 (decode-time
1491                                       (encode-time 0 0 0 1 month year
1492                                                    time-zone))))
1493                        (max (cond ((= month 2)
1494                                    (if (date-leap-year-p year) 29 28))
1495                                   ((<= month 7)
1496                                    (if (zerop (% month 2)) 30 31))
1497                                   (t
1498                                    (if (zerop (% month 2)) 31 30))))
1499                        (doms dom-list)
1500                        (dows dow-list)
1501                        day days)
1502                    ;; first, review the doms to see if they are valid.
1503                    (while (setq day (pop doms))
1504                      (and (<= day max)
1505                           (push day days)))
1506                    ;; second add all possible dows
1507                    (while (setq day (pop dows))
1508                      ;; days start at 1.
1509                      (setq day (1+ (- day first)))
1510                      (and (< day 0) (setq day (+ 7 day)))
1511                      (while (<= day max)
1512                        (push day days)
1513                        (setq day (+ 7 day))))
1514                    ;; Finally, if we have some days, they are valid
1515                    (when days
1516                      (sort days '>)
1517                      (throw 'found
1518                             (encode-time 0 minute hour
1519                                          (car days) month year time-zone)))
1520                    )))))
1521          ;; There's an upper limit, but we didn't find any last occurence.
1522          ;; This means that the schedule is undecidable. This can happen if
1523          ;; you happen to say something like "each Feb 31 until 2038".
1524          (progn
1525            (nnheader-report 'nndiary "Undecidable schedule")
1526            nil))
1527         ))))
1528
1529 (defun nndiary-next-occurence (sched now)
1530   ;; Returns the next occurence of schedule SCHED, starting from time NOW.
1531   ;; If there's no next occurence, returns the last one (if any) which is then
1532   ;; in the past.
1533   (let* ((today (decode-time now))
1534          (this-minute (nth 1 today))
1535          (this-hour (nth 2 today))
1536          (this-day (nth 3 today))
1537          (this-month (nth 4 today))
1538          (this-year (nth 5 today))
1539          (minute-list (sort (nndiary-flatten (nth 0 sched) 0 59) '<))
1540          (hour-list (sort (nndiary-flatten (nth 1 sched) 0 23) '<))
1541          (dom-list (nth 2 sched))
1542          (month-list (sort (nndiary-flatten (nth 3 sched) 1 12) '<))
1543          (years (if (nth 4 sched)
1544                     (sort (nndiary-flatten (nth 4 sched) 1971) '<)
1545                   t))
1546          (dow-list (nth 5 sched))
1547          (year (1- this-year))
1548          (time-zone (or (and (nth 6 sched) (car (nth 6 sched)))
1549                         (current-time-zone))))
1550     ;; Special case: an asterisk in one of the days specifications means that
1551     ;; only the other should be taken into account. If both are unspecified,
1552     ;; you would get all possible days in both.
1553     (cond ((null dow-list)
1554            ;; this gets all days if dom-list is nil
1555            (setq dom-list (nndiary-flatten dom-list 1 31)))
1556           ((null dom-list)
1557            ;; this also gets all days if dow-list is nil
1558            (setq dow-list (nndiary-flatten dow-list 0 6)))
1559           (t
1560            (setq dom-list (nndiary-flatten dom-list 1 31))
1561            (setq dow-list (nndiary-flatten dow-list 0 6))))
1562     ;; Remove past years.
1563     (unless (eq years t)
1564       (while (and (car years) (< (car years) this-year))
1565         (pop years)))
1566     (if years
1567         ;; Because we might not be limited in years, we must guard against
1568         ;; infinite loops. Appart from cases like Feb 31, there are probably
1569         ;; other ones, (no monday XXX 2nd etc). I don't know any algorithm to
1570         ;; decide this, so I assume that if we reach 10 years later, the
1571         ;; schedule is undecidable.
1572         (or
1573          (catch 'found
1574            (while (if (eq years t)
1575                       (and (setq year (1+ year))
1576                            (<= year (+ 10 this-year)))
1577                     (setq year (pop years)))
1578              (let ((months month-list)
1579                    month)
1580                ;; Remove past months for this year.
1581                (and (= year this-year)
1582                     (while (and (car months) (< (car months) this-month))
1583                       (pop months)))
1584                (while (setq month (pop months))
1585                  ;; Now we must merge the Dows with the Doms. To do that, we
1586                  ;; have to know which day is the 1st one for this month.
1587                  ;; Maybe there's simpler, but decode-time(encode-time) will
1588                  ;; give us the answer.
1589                  (let ((first (nth 6 (decode-time
1590                                       (encode-time 0 0 0 1 month year
1591                                                    time-zone))))
1592                        (max (cond ((= month 2)
1593                                    (if (date-leap-year-p year) 29 28))
1594                                   ((<= month 7)
1595                                    (if (zerop (% month 2)) 30 31))
1596                                   (t
1597                                    (if (zerop (% month 2)) 31 30))))
1598                        (doms dom-list)
1599                        (dows dow-list)
1600                        day days)
1601                    ;; first, review the doms to see if they are valid.
1602                    (while (setq day (pop doms))
1603                      (and (<= day max)
1604                           (push day days)))
1605                    ;; second add all possible dows
1606                    (while (setq day (pop dows))
1607                      ;; days start at 1.
1608                      (setq day (1+ (- day first)))
1609                      (and (< day 0) (setq day (+ 7 day)))
1610                      (while (<= day max)
1611                        (push day days)
1612                        (setq day (+ 7 day))))
1613                    ;; Aaaaaaall right. Now we have a valid list of DAYS for
1614                    ;; this month and this year.
1615                    (when days
1616                      (setq days (sort days '<))
1617                      ;; Remove past days for this year and this month.
1618                      (and (= year this-year)
1619                           (= month this-month)
1620                           (while (and (car days) (< (car days) this-day))
1621                             (pop days)))
1622                      (while (setq day (pop days))
1623                        (let ((hours hour-list)
1624                              hour)
1625                          ;; Remove past hours for this year, this month and
1626                          ;; this day.
1627                          (and (= year this-year)
1628                               (= month this-month)
1629                               (= day this-day)
1630                               (while (and (car hours)
1631                                           (< (car hours) this-hour))
1632                                 (pop hours)))
1633                          (while (setq hour (pop hours))
1634                            (let ((minutes minute-list)
1635                                  minute)
1636                              ;; Remove past hours for this year, this month,
1637                              ;; this day and this hour.
1638                              (and (= year this-year)
1639                                   (= month this-month)
1640                                   (= day this-day)
1641                                   (= hour this-hour)
1642                                   (while (and (car minutes)
1643                                               (< (car minutes) this-minute))
1644                                     (pop minutes)))
1645                              (while (setq minute (pop minutes))
1646                                ;; Ouch! Here, we've got a complete valid
1647                                ;; schedule. It's a good one if it's in the
1648                                ;; future.
1649                                (let ((time (encode-time 0 minute hour day
1650                                                         month year
1651                                                         time-zone)))
1652                                  (and (time-less-p now time)
1653                                       (throw 'found time)))
1654                                ))))
1655                        ))
1656                    )))
1657              ))
1658          (nndiary-last-occurence sched))
1659       ;; else
1660       (nndiary-last-occurence sched))
1661     ))
1662
1663 (defun nndiary-expired-article-p (file)
1664   (with-temp-buffer
1665     (if (nnheader-insert-head file)
1666         (let ((sched (nndiary-schedule)))
1667           ;; An article has expired if its last schedule (if any) is in the
1668           ;; past. A permanent schedule never expires.
1669           (and sched
1670                (setq sched (nndiary-last-occurence sched))
1671                (time-less-p sched (current-time))))
1672       ;; else
1673       (nnheader-report 'nndiary "Could not read file %s" file)
1674       nil)
1675     ))
1676
1677 (defun nndiary-renew-article-p (file timestamp)
1678   (erase-buffer)
1679   (if (nnheader-insert-head file)
1680       (let ((now (current-time))
1681             (sched (nndiary-schedule)))
1682         ;; The article should be re-considered as unread if there's a reminder
1683         ;; between the group timestamp and the current time.
1684         (when (and sched (setq sched (nndiary-next-occurence sched now)))
1685           (let ((reminders ;; add the next occurence itself at the end.
1686                  (append (nndiary-compute-reminders sched) (list sched))))
1687             (while (and reminders (time-less-p (car reminders) timestamp))
1688               (pop reminders))
1689             ;; The reminders might be empty if the last date is in the past,
1690             ;; or we've got at least the next occurence itself left. All past
1691             ;; dates are renewed.
1692             (or (not reminders)
1693                 (time-less-p (car reminders) now)))
1694           ))
1695     ;; else
1696     (nnheader-report 'nndiary "Could not read file %s" file)
1697     nil))
1698
1699 ;; The end... ===============================================================
1700
1701 (mapcar
1702  (lambda (elt)
1703    (let ((header (intern (format "X-Diary-%s" (car elt)))))
1704      ;; Required for building NOV databases and some other stuff
1705      (add-to-list 'gnus-extra-headers header)
1706      (add-to-list 'nnmail-extra-headers header)))
1707  nndiary-headers)
1708
1709 (unless (assoc "nndiary" gnus-valid-select-methods)
1710   (gnus-declare-backend "nndiary" 'post-mail 'respool 'address))
1711
1712 (provide 'nndiary)
1713
1714
1715 ;;; nndiary.el ends here