cgit.sxemacs.org Git - gnus/blob - lisp/nndiary.el

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