From mboxrd@z Thu Jan 1 00:00:00 1970 X-Msuck: nntp://news.gmane.io/gmane.emacs.gnus.general/79363 Path: news.gmane.org!not-for-mail From: Dave Abrahams Newsgroups: gmane.emacs.gnus.general Subject: Re: Gnus Questions #1: Article Expiry Date: Mon, 04 Jul 2011 20:50:24 -0400 Message-ID: References: <87sjqm15mp.fsf@yun.yagibdah.de> NNTP-Posting-Host: lo.gmane.org Mime-Version: 1.0 Content-Type: text/plain X-Trace: dough.gmane.org 1309827119 23533 80.91.229.12 (5 Jul 2011 00:51:59 GMT) X-Complaints-To: usenet@dough.gmane.org NNTP-Posting-Date: Tue, 5 Jul 2011 00:51:59 +0000 (UTC) To: ding@gnus.org Original-X-From: ding-owner+M27659@lists.math.uh.edu Tue Jul 05 02:51:53 2011 Return-path: Envelope-to: ding-account@gmane.org Original-Received: from util0.math.uh.edu ([129.7.128.18]) by lo.gmane.org with esmtp (Exim 4.69) (envelope-from ) id 1Qdtrk-0000Nu-QD for ding-account@gmane.org; Tue, 05 Jul 2011 02:51:53 +0200 Original-Received: from localhost ([127.0.0.1] helo=lists.math.uh.edu) by util0.math.uh.edu with smtp (Exim 4.63) (envelope-from ) id 1Qdtqh-00012T-2E; Mon, 04 Jul 2011 19:50:47 -0500 Original-Received: from mx1.math.uh.edu ([129.7.128.32]) by util0.math.uh.edu with esmtps (TLSv1:AES256-SHA:256) (Exim 4.63) (envelope-from ) id 1Qdtqf-00012K-8D for ding@lists.math.uh.edu; Mon, 04 Jul 2011 19:50:45 -0500 Original-Received: from quimby.gnus.org ([80.91.231.51]) by mx1.math.uh.edu with esmtps (TLSv1:AES256-SHA:256) (Exim 4.76) (envelope-from ) id 1Qdtqc-0001cW-BX for ding@lists.math.uh.edu; Mon, 04 Jul 2011 19:50:44 -0500 Original-Received: from lo.gmane.org ([80.91.229.12]) by quimby.gnus.org with esmtp (Exim 4.72) (envelope-from ) id 1QdtqZ-0007bI-CS for ding@gnus.org; Tue, 05 Jul 2011 02:50:39 +0200 Original-Received: from list by lo.gmane.org with local (Exim 4.69) (envelope-from ) id 1QdtqY-0008Qr-RR for ding@gnus.org; Tue, 05 Jul 2011 02:50:38 +0200 Original-Received: from 207-172-223-249.c3-0.smr-ubr3.sbo-smr.ma.static.cable.rcn.com ([207.172.223.249]) by main.gmane.org with esmtp (Gmexim 0.1 (Debian)) id 1AlnuQ-0007hv-00 for ; Tue, 05 Jul 2011 02:50:38 +0200 Original-Received: from dave by 207-172-223-249.c3-0.smr-ubr3.sbo-smr.ma.static.cable.rcn.com with local (Gmexim 0.1 (Debian)) id 1AlnuQ-0007hv-00 for ; Tue, 05 Jul 2011 02:50:38 +0200 X-Injected-Via-Gmane: http://gmane.org/ Original-Lines: 386 Original-X-Complaints-To: usenet@dough.gmane.org X-Gmane-NNTP-Posting-Host: 207-172-223-249.c3-0.smr-ubr3.sbo-smr.ma.static.cable.rcn.com User-Agent: Gnus/5.110018 (No Gnus v0.18) Emacs/23.3 (darwin) Cancel-Lock: sha1:CqhJB7/xadgyO7LrSmp19TzIebQ= X-Spam-Score: -4.9 (----) List-ID: Precedence: bulk Xref: news.gmane.org gmane.emacs.gnus.general:79363 Archived-At: Lee, thanks a *lot* for jumping in. I know this is a big one... on Mon Jul 04 2011, lee wrote: > Dave Abrahams writes: > >> * I presume that "expiring" an article means the same as "putting the >> article through the expiry process" (?) > > Well, when I mark an article `E', I'm "expiring" it. I don't believe that interpretation consistent with the terminology as used in the majority of the document. IIUC, marking an article `E' makes it "expirable" but the actual expiration happens later, if at all. > It'll be purged some time later --- apparently only *if* I enter and > leave the group the article is in later. There are other ways to trigger the expiry process, e.g. `M-g' (gnus-summary-rescan-group) and expiry doesn't necessarily mean the article will be deleted (or "purged"). For example, the article could be refiled. Or nothing at all could happen. It all depends how you set things up, as far as I can tell. It would be nice to have a detailed description of exactly what options and user hooks are checked/called by the system in what order. > If I don't, the article will never be purged: is that true? The article can be deleted in other ways, e.g. `B DEL' (gnus-summary-delete-article). >> * What's the difference between `gnus-summary-expire-articles' and >> `gnus-summary-expire-articles-now'? The documentation doesn't make >> that clear. > > The difference is in "delete all expirable articles in the group /that > have been around for a while/" vs. "This means that *all* articles > eligible for expiry in the current group will disappear" /right now/. Yeah, I read all those words, but they didn't add up to any obvious distinction for me. The phrases "have been around for a while" and "eligible for expiry" are vague at best. By contrast the use of "delete" and "disappear" seem implausibly concrete for a system whose expiration behavior can range from "do nothing" (which is undocumented, but that's what you get from nnimap if the expiry target is nil) to "forward the article to my mother-in-law" (if I write the function to do that). I would rather say that the articles are "sent to the group's expiry target" (a phrase I'd suitably define in Expiring Mail::). > The documentation could be more clear on this, Thus my posting :-) > like: > > > ,---- > | `B e' > | Perform an expiry process on the articles in the current > | group. Only articles that are expirable *and due to be purged* > | will be purged. The expiry process is performed by the function > | `gnus-summary-expire-articles'. (See Expiring Mail::). > | > | `B C-M-e' > | Purge all the expirable articles in the current group *right > | now*. This means that all expirable articles will be purged > | immediately. The purging process is performed by the function > | `gnus-summary-expire-articles-now'. (See Expiring Mail::). > `---- Unfortunately, that change doesn't improve the clarity for me. It doubles down on the overly-concrete aspects of the existing text. It also makes it sound like `B e' isn't directly bound to `gnus-summary-expire-articles', but instead invokes it indirectly as /part/ of its functionality. If the following changes are accurate, I prefer them: `B e' - `gnus-summary-expire-articles' Run all articles in the current group that are marked expirable (`E') through the expiry process (*note Expiring Mail::). `B C-M-e' - `gnus-summary-expire-articles-now' Send all articles in the current group marked expirable (`E') directly to their expiry target regardless of their age (*note Expiring Mail::). > How about renaming "gnus-summary-expire-articles-now" to > "gnus-summary-purge-articles" (or to "gnus-purge-articles")? > > There also needs to be some clarification about what "expiring" means. +1 > There seem to be actually quite a few stages of expirableness: Using an informal definition of `expirable' ("when expiry runs, this article will be sent to the expiry target"), I agree. I think the docs are pretty strict about using `expirable' only to refer to articles marked `E', though. Now, we could discuss the merits of changing that, but it's the status quo. > * not expirable, depends on gnus-inhibit-user-auto-expire, Based on my reading of the docs, I don't think it depends on that. `gnus-inhibit-user-auto-expire' seems to prevent `gnus-summary-mark-as-expirable' (normally bound to `E') from having any effect: ,---- | *If non-nil, user marking commands will not mark an article as | expirable, even if the group has auto-expire turned on. `---- AFAICT an article that already has an `E' mark is still expirable in both the formal and informal sense, though. [I don't know what other "user marking commands" this text might be referring to. Are there any?] > nnfolder-inhibit-expiry?? > * marked as `E', depends on age > * marked as `r', depends on age, total-expire > * marked as `R', depends on age, total-expire > * marked as `O', depends on age, total-expire > * marked as `K', depends on age, total-expire > * marked as `Y', depends on age, total-expire The above matches my understanding. > * marked as "and so on"[1], apparently depends total-expire only Yeah, that's disturbingly vague. > * marked as `G': depends on gnus-inhibit-user-auto-expire, Again, unless the docs are just wrong or extremely misleading, I don't think so. > nnfolder-inhibit-expiry?? > > > Then there's the purgability of articles. It seems that articles marked > `G' are always purged on leaving a group. > Perhaps they cannot be purged > eventually, depending on some settings (and marks, maybe): My (weak) understanding is that `G' (cancelled) only applies to nntp groups and what happens to cancelled articles depends on whether the nntp server responds to cancellation. > ,---- [ info:gnus#Expiring Mail ] > | If `gnus-inhibit-user-auto-expire' is non-`nil', user marking > | commands will not mark an article as expirable, even if the group has > | auto-expire turned on. > `---- > > This mentions marking only. Will articles in stages of expirableness > eventually be purged nonetheless? To answer precisely, I believe they will be sent to their expiry targets according to the usual other criteria (e.g. age) and regardless of this setting. At least, that's what the doc seems to say. A quick experiment should be enough to confirm this, though, if you have doubts. > What disables the purgability of an article? If "purge" means "delete," then as far as I can tell nothing disables it other than, potentially, the server itself (e.g. if something like dovecot is serving you a read-only IMAP group or an nntp server disallows article cancellation) > [1] { > ,---- [ info:gnus#Expiring Mail ] > | So, in addition to the articles marked `E', also the articles > | marked `r', `R', `O', `K', `Y' and so on are considered > | expirable. > `---- > > What other marks are there? Lots. My most complete list of marks to date is below, but I wouldn't be surprised to learn that I missed something.: "R" "K" "-" " " (gnus-unread-mark) "r" (explicit delete) "X" (explicit kill)" "Y" (low score) "=" (gnus-unsendable-mark) "%" (gnus-downloadable-mark") "!" (gnus-ticked-mark) "$" (gnus-spam-mark) "?" (gnus-dormant-mark) "E" (gnus-expirable-mark) "O" (gnus-ancient-mark) Articles that were marked as read in previous sessions and are now "old" "A" (gnus-replied-mark) All articles that you have replied to or made a followup to "*" Article is "[[info:gnus#Persistent%20Articles][persistent]]" `C' Marked as read by a catchup (`gnus-catchup-mark'). `G' Canceled article (`gnus-canceled-mark') `Q' Sparsely reffed article (`gnus-sparse-mark'). `M' Article marked as read by duplicate suppression (`gnus-duplicate-mark'). > Can I prevent articles from being marked as `O' automatically? Good question > What means `r`? The documentation (somewhere) says it means the article was "explicitly deleted," but near as I can tell, it means you invoked gnus-summary-mark-as-read-forward (`d') on the article. Aside from that and the effects of potentially having different membership in `gnus-auto-expirable-marks', it's equivalent to `R'. I think. > Can I configure > which marks put articles into stages of expirableness? See gnus-auto-expirable-marks. Not sure if that's what you have in mind, though. > There needs > to be an overview of the possible marks in the chapter about > expiring mail, or somewhere. > } Indeed: http://debbugs.gnu.org/db/89/8978.html >> * What's the point of backend-specific expiry settings like >> nnfolder-inhibit-expiry (I'm referring to the `nnfolder-' part when I >> say `backend-specific')? Don't we have enough other ways to say "this >> group/server isn't expirable?" > > Hm, nnfolder-inhibit-expiry doesn't seem to be explained in the > documentation. What does it inhibit, the purgability or the > expirableness? My guess from the name is that it prevents the expiry process from running on that group. > Which other ways to say that a server/group isn't expirable (or > purgeable, which is a difference) have you found? I think, among others: setting nnmail-expiry-wait to `never', and if undocumented behaviors count, setting nnmail-expiry-target to nil. and similar settings in the individual group parameters. > Is there a way to request information about the expirableness and > purgability of articles? You'd get an information like "This article is > [not expirable | expired | expirable and will expire when ...] because > .... This article is [not purgable | purgable and will be purged when > ...] because ....". Gnus must have some way of figuring this out to be > able to expire and purge articles correctly. That is an *excellent* idea for a new feature. I suggest `M-x gnus-bug RET [feature-request]...' >> * [[info:gnus#Expiring Mail]] mentions `having auto expiry switched on' >> but doesn't say how to do that. Are we talking about the auto-expire >> group parameter here, or something else? > > Yeah, it should be clarified. > >> * "Total Expire" and "Auto Expire" >> >> * The main point of using "Total Expire" instead of "Auto Expire" >> seems to be that with "total expire" you can keep a distinction >> between expirable (`E') and other marks that indicate an article was >> read... until expiry actually runs. At that point, if you're using >> total expire they're all treated the same. With "auto expire," on >> the other hand, you know that only articles marked `E' will be >> put through the expiry process. > > Yes: Total-expire makes articles purgeable *without* marking > them. Auto-expire makes articles purgeable *by* marking them. I obviously don't understand your definition of "purgeable." I used to think it meant "able to be deleted," but now I think it's something else. I think I disagree with your use of "*without* marking," as IIUC an article must acquire one of the "read marks" in order to be expired. >> * From [[info:gnus#Adaptive Scoring]] I think I conclude that adaptive >> scoring takes effect at expiry time, and "auto-expire" changes all >> read marks to `E' too early for adaptive scoring to do its work. Is >> that right? > > Non-adaptive scoring seems to happen when you enter a group. Each time > you enter the group, the scoring rules are applied, resulting in > incredible scores. I wonder what the idea behind this way of > implementing it is. Is that different with adaptive scoring? I don't know. I don't think it's particularly relevant to my question or the topic of expiry (which I'm trying to handle in this thread) so if you don't mind I'd prefer not to discuss that here, just to keep this from spiralling way beyond everyone's TL;DR limit. >> Okay, now that I read it again I think it's saying that with >> "auto-expire," if I can somehow produce a mark other than `E' for an >> article that's been read,, that article can persist even if it's >> neither dormant or ticked. That's fine as far as it goes but >> mentioning it seems almost pointless, since Gnus is going to >> automatically mark everything I read as `E'. What am I missing? > > Auto-expire does *not* lead to eventually purging articles you don't > touch, while total-expire *does* lead to eventually purging articles you > don't touch (because gnus touches them with scoring and `O' marks, for > example). Well, define "touch." I think you mean "read." But maybe you don't, because IIUC `O' is only applied by Gnus to articles you've read (as you seem to acknowledge below). I suppose scoring can mark articles automatically. >> * This (from [[info:gnus#Expiring Mail]]) seems confusing for what I >> think are related reasons: >> >> ,---- >> | Note that making a group auto-expirable doesn't mean that all read >> | articles are expired--only the articles marked as expirable will be >> | expired >> `---- >> >> If auto-expire automatically marks articles expirable when you read >> them, doesn't that /necessarily/ mean all read articles are expired >> (except articles you read in the past?). > > The documentation somewhat struggles trying to explain that the > auto-expire option doesn't do anything else than marking articles with > `E' when they otherwise would be marked `R'. > > To say just that and not much more would probably suffice. I think, if that's accurate, it would be *far* preferable. > Thinking of this, what's the point behind gnus changing marks > automatically? When I mark something read, it'll later be marked `O'. I happen to find that mark useful: I strive to maintain "Inbox Zero" and `O' lets me know that an article has been sitting around in my Inbox a bit too long. > When marking something as killed, that doesn't seem to be any different > from marking it as read (unless you use adaptive scoring maybe). Gnus > automatically marks it as `O' as well. Yeah, that's odd. `R', `r', and `K' all seem to mean roughly the same thing. And depending on how you have expiry set up for your group it's quite possible that a number of other marks also mean roughly the same thing. I'm thinking of replacing the display of those marks in my summary line with something more semantically useful. > Why doesn't gnus keep the distinction between "read" and "killed"? Hmm... My guess is that under the covers, it does, and the mark just gets hidden by `O' when an article is old enough. > When I enter a group after having killed some of the threads, I still > want to be able to see what threads I've killed, what I have actually > read and what I didn't read but "cought up" with. I don't trust the > scoring because it might hide things from me I want to see, so seeing > what I read, killed and cought up with is an important information to > me. > > Can't gnus mark as `R' what I've read, as `K' what I've killed and > as `O' what I cought up with and keep these marks intact? Well, you can customize the summary line format almost infinitely and use your own marks. That's what I meant by "replacing the display of those marks in my summary line with something more semantically useful." However, I also think Gnus could/should have a more useful (and simpler) default right out of the box. -- Dave Abrahams BoostPro Computing http://www.boostpro.com