mu-find - Online nel cloud

PROGRAMMA:

NOME

mu_find: trova i messaggi di posta elettronica nel file mu Banca dati.

SINOSSI

mu Find [opzioni] <cerca espressione>

DESCRIZIONE

mu Find Europe è mu comando per la ricerca dei messaggi di posta elettronica archiviati in precedenza utilizzando mu
Index(1).

RICERCA MAIL

mu Find avvia una ricerca di messaggi nel database che corrispondono a qualche modello di ricerca. Per
esempio:

$ devi trovare oggetto:neve da:john

troverebbe tutti i messaggi di John con "neve" nel campo dell'oggetto, qualcosa del tipo:

2009-03-05 17:57:33 EET Lucialucia@example.com> correre nella neve
2009-03-05 18:38:24 EET Mariusmarius@foobar.com> Re: correre sulla neve

Tieni presente che questo è l'output predefinito in testo semplice, che è l'impostazione predefinita, quindi non è necessario utilizzarlo
--format=normale. Per altri tipi di output (come collegamenti simbolici, XML o espressioni s), vedere
la discussione in VERSIONI-sezione seguente su --formato.

Il modello di ricerca viene preso come parametro della riga di comando. Se il parametro di ricerca consiste
di più parti (come nell'esempio) vengono trattate come se esistesse una logica E
fra loro.

mu si affida al database Xapian per le sue capacità di ricerca, quindi offre tutto il
funzionalità di ricerca che Xapian offre; per tutti i dettagli consultare:
http://xapian.org/docs/queryparser.html

Una caratteristica speciale di mu è che non distingue tra maiuscolo e minuscolo,
né le versioni accentate o non accentate dei caratteri. Tutto corrisponde. Generalmente, mu prova a
sii "ansioso" nell'abbinamento, poiché filtrare i risultati indesiderati è solitamente preferibile rispetto a non farlo
messaggi corrispondenti.

Una ricerca con caratteri jolly è una ricerca in cui a * corrisponde all'ultimo n carattere/i in una stringa.
La stringa deve sempre iniziare con uno o più caratteri prima del carattere jolly. mu supporta
i caratteri jolly eseguono ricerche in tutti i campi eccetto maildir e percorsi. Per ricevere tutte le e-mail con a
soggetto contenente una parola che inizia con com, Puoi usare:

$ devi trovare 'oggetto:com*'

e ricevere e-mail su computer, commenti, compilazione e così via. Nota, quando scappi da
nella riga di comando è importante mettere la query tra virgolette, altrimenti la shell lo farebbe
interpretare il '*'. È altrettanto importante ricordare che "*" richiama il carattere jolly
cercare solo se utilizzato come carattere più a destra di un termine di ricerca. Inoltre, lo è non è un
un'espressione regolare.

Il modo di base per cercare un messaggio è digitare alcune parole che lo corrispondono, come faresti in an
motore di ricerca su Internet. Per esempio,

$ devo trovare la banana scimmia

troverà tutti i messaggi che contengono sia "scimmia" che "banana" nel corpo o nell'oggetto
o uno dei campi dell'indirizzo (a/da/cc).

Come accennato, la corrispondenza non fa distinzione tra maiuscole e minuscole e senza distinzione con l'accento; così

$ mu trovi Mönkey BÄNAÑå

produce gli stessi risultati dell'esempio precedente.

mu riconosce anche i prefissi per campi specifici nei messaggi; Per esempio:

$ mu trova oggetto:pinguino

per trovare messaggi con la parola pinguino nel campo dell'oggetto. Puoi abbreviare
soggetto: solo per s:. Ecco la tabella completa dei campi di ricerca e delle relative abbreviazioni:

cc,c Destinatario(i) Cc (copia carbone)
bcc,h Destinatario(i) Ccn (copia per conoscenza nascosta)
da,f Mittente del messaggio
a,t A: destinatario/i
oggetto,s Oggetto del messaggio
maildir,m Maildir
msgid,i ID messaggio
prio,p Priorità del messaggio ('bassa', 'normale' o 'alta')
flag,g Flag di messaggio
date,d Intervallo di date
dimensione,z Dimensione del messaggio
embed,e Cerca all'interno di parti di testo incorporate (messaggi, allegati)
file,j Nome del file dell'allegato
mime,y Tipo MIME di una o più parti del messaggio
tag,x Tag per il messaggio (Etichetta X e / o Parole chiave X)
list,v Mailing list (ad esempio il valore List-Id)

Ci sono anche i campi speciali contatti, che corrisponde a tutti i campi di contatto (da, a, cc
e bcc), E ricetta, che corrisponde a tutti i campi destinatario (a, cc e bcc).

Il significato della maggior parte dei campi sopra indicati dovrebbe essere chiaro, ma alcuni richiedono qualcosa in più
discussione. Innanzitutto, il campo flag del messaggio descrive alcune proprietà del messaggio, come
elencati nella tabella seguente:

d,bozza Bozza di messaggio
f,contrassegnato Contrassegnato
n,new Nuovo messaggio (in new/Maildir)
p,superato Superato ("Gestito")
r,rispose Rispose
s,visto visto
t,trashed Contrassegnato per l'eliminazione
a,attach Ha allegato
z,signed Messaggio firmato
x,crittografato Messaggio crittografato
l,list Messaggio della mailing list

Usando questo, possiamo cercare ad esempio tutti i messaggi firmati che hanno un allegato:

$ mu trova flag:firmato flag:attach

Anche i messaggi crittografati possono essere firmati, ma questo è visibile solo dopo la decrittografia e
quindi, è invisibile a mu.

La priorità del messaggio ha tre valori possibili: bassa, normale o alta. Possiamo abbinarli
utilizzando prima: - ad esempio, per ricevere tutti i messaggi ad alta priorità con oggetto contenente
qualche uccello:

$ mu trova prio:alto soggetto:usignolo

Il campo Maildir descrive il percorso della directory iniziale dopo il percorso base di Maildir e
prima di /cur/ or /nuovo/ parte. Quindi, ad esempio, se c'è un messaggio con il nome del file
~/Maildir/lists/running/cur/1234.213: 2,, potresti trovarlo (e tutti gli altri messaggi in
lo stesso maildir) con:

$ devi trovare maildir:/lists/running

Nota la "/" iniziale. Se vuoi far corrispondere i messaggi nella directory 'root', puoi farlo con a
separare '/':

$ devi trovare maildir:/

(e ovviamente puoi usare il file m: scorciatoia invece di indirizzo e-mail:)

. Data: (o d:) il parametro di ricerca è "speciale" nel fatto che accetta un intervallo di
date. Per ora, queste date sono nel formato ISO 8601 (AAAAMMGGGHHMM); puoi tralasciare il
parte destra, e mu aggiungerà il resto, a seconda che questo sia l'inizio o la fine
l'intervallo di date. Ad esempio, per l'inizio dell'intervallo sarebbe "201012".
interpretato come "20101201010000", ovvero 1 dicembre 2010 alle ore 00:00, mentre per la fine del
intervallo, questo verrebbe interpretato come "20101231122359" o 31 dicembre 2010 alle 23:59. Se
se si omette completamente la parte sinistra, si presuppone che la data di inizio sia il 1 gennaio, anno 0
alle 00:00. Allo stesso modo, se si omette la parte destra, si presuppone che i dati finali siano gli ultimi
secondo dell'anno 9999.

Per ricevere tutti i messaggi tra il 5 maggio 2009 (incluso) e il 2 giugno 2010, è necessario
potrei usare:

$ mu trova la data:20090505..20100602

I caratteri non numerici vengono ignorati, quindi quanto segue è equivalente ma più leggibile:

$ mu trova la data:2009-05-05..2010-06-02

La precisione è fino al minuto e per gli orari viene utilizzata la notazione di 24 ore, quindi un altro esempio
sarebbe:

$ mu find date:2009-05-05/12:23..2010-06-02/17:18

mu comprendere anche le date relative, sotto forma di numero positivo seguito da h (ora),
d (giorno), w (settimana), m (30 giorni) o y (365 giorni). Alcuni esempi per spiegare questo:

5h cinque ore nel passato
2w due settimane fa
3m tre volte 30 giorni nel passato
1y 365 giorni nel passato

Usando questa notazione, puoi ad esempio abbinare messaggi vecchi di due e tre settimane:

$ mu trova la data: 3w..2w

Ci sono alcune parole chiave speciali per le date, vale a dire "adesso", che significa il momento presente e
'oggi' per l'inizio di oggi. Quindi, per ricevere tutti i messaggi inviati o ricevuti oggi, tu
potrei usare:

$ mu trova la data: oggi... adesso

. Taglia or z ti permette di abbinare Taglia gamme -- ovvero, corrisponde ai messaggi che contengono un byte-
dimensione entro un certo intervallo. Unità (B (per byte), K (per 1000 byte) e M (per 1000 *
1000 byte) sono supportati). Ad esempio, per ricevere tutti i messaggi compresi tra 10 Kb e 2 Mb
(assumendo le unità SI), potresti usare:

$ mu trova la dimensione: 10K..2M

È importante ricordare che se un termine di ricerca include spazi, dovresti farlo citare quelli
parti. Così, quando we Dai un'occhiata at , il i seguenti esempi:

$ mu Find maildir:/Sent articoli yogurt
$ mu Find maildir:'/Sent Elementi' yogurt

. prima di tutto domanda Ricerche da messaggi in , il /Inviato corrispondenza della directory di posta articoli e yogurt,
mentre la seconda query cerca il file /Inviato articoli maildir alla ricerca dei messaggi corrispondenti
yogurt.

Puoi abbinare contro tutti i messaggi che utilizzano "" (o ''):

$ devi trovare ""

VERSIONI

Nota: alcune delle opzioni importanti sono descritte nel file mu(1) man-page e non qui, come
si applicano a più comandi mu.

. Find-command ha varie opzioni che influenzano il modo mu visualizza i risultati. Se
non specifichi nulla, le impostazioni predefinite sono --fields="d f s", --sortfield=data e
--inversione.

-f, --campi=
specifica una stringa che determina quali campi vengono visualizzati nell'output. Questo
la stringa è composta da un numero di caratteri (ad esempio "s" per oggetto o "f" per
from), che verrà sostituito con il campo effettivo nell'output. Campi che non lo sono
noto verrà restituito così com'è, consentendo alcune semplici formattazioni.

Per esempio:

$ mu trova oggetto:snow --fields "dfs"

elencherebbe la data, l'oggetto e il mittente di tutti i messaggi con "neve" nel messaggio
soggetto.

La tabella dei caratteri sostitutivi è un superset dell'elenco dei riferimenti per la ricerca
parametri; l'elenco completo:

t to: destinatario
c cc: destinatario (in copia carbone).
h Ccn: (copia carbone nascosta, hdestinatario nascosto).
d Inviato dmangiato del messaggio
f Mittente del messaggio (from:)
g Flag dei messaggi (flags)
l Percorso completo del messaggio (lposizione)
pMessaggio ppriorità (alta, normale, bassa)
s Messaggio soggetto
iMessaggio-id
m maidir

I flag dei messaggi sono gli stessi che abbiamo già visto nei flag dei messaggi sopra.
Pertanto, un messaggio che viene "visto", ha un allegato ed è firmato avrebbe "asz"
come stringa di output corrispondente, mentre un nuovo messaggio crittografato avrebbe "nx".

-s, --sortfield = e -z,
--inversione specifica il campo in base al quale ordinare i risultati della ricerca e la direzione
(vale a dire, 'inverso' significa che l'ordinamento dovrebbe essere invertito - ZA). Il seguente
i campi sono supportati:

cc,c Destinatario(i) Cc (copia carbone)
bcc,h Destinatario(i) Ccn (copia per conoscenza nascosta)
data,d data di invio del messaggio
da,f mittente del messaggio
maildir,m maildir
msgid, id messaggio
prio,p priorità del messaggio
oggetto del messaggio oggetto
a,t A:-destinatario(i)

Pertanto, ad esempio, per ordinare i messaggi per data, potresti specificare:

$ mu find fahrrad --fields "dfs" --sortfield=data --reverse

Tieni presente che se specifichi un campo di ordinamento, per impostazione predefinita i messaggi vengono ordinati al contrario
Ordine (discendente) (ad esempio, dal più basso al più alto). Di solito è una buona scelta,
ma per le date potrebbe essere più utile ordinare nella direzione opposta.

-n, --maxnum=
Se > 0, visualizza al massimo quel numero di voci. Se non specificato, tutti corrispondenti
vengono visualizzate le voci.

--summary-len=
Se > 0, utilizza quel numero di righe del messaggio per fornire un riepilogo.

--formato=plain|link|xquery|xml|sexp
risultati di output nel formato specificato.

L'impostazione predefinita è pianura, ovvero output normale con una riga per messaggio.

Collegamento restituisce i risultati come directory di posta con collegamenti simbolici ai messaggi trovati.
Ciò consente una facile integrazione con i client di posta (vedi sotto per maggiori informazioni).
See --linksdir e --clearlinks qua sotto.

xml formatta i risultati della ricerca come XML.

sesso formatta i risultati della ricerca come un'espressione s utilizzata nella programmazione Lisp
ambienti.

xquery mostra la query Xapian corrispondente ai termini di ricerca. Questo è pensato per
per scopi di debug.

--linksdir = e -c, --clearlinks
genera i risultati come directory di posta con collegamenti simbolici ai messaggi trovati. Questo
consente una facile integrazione con i client di posta (vedi sotto per maggiori informazioni). mu
creerà la maildir se non esiste ancora.

Se specifichi --clearlinks, tutti i collegamenti simbolici esistenti verranno cancellati dalla destinazione
indirizzo di posta; ciò consente il riutilizzo della stessa directory. Un'alternativa sarebbe quella
eliminare prima la directory di destinazione, ma è molto probabile che ciò accada accidentalmente
rimuovere qualcosa che non dovrebbe essere rimosso.

$ devi trovare grolsch --linksdir=~/Maildir/search --clearlinks

memorizzerà i collegamenti ai messaggi trovati in ~/Maildir/search. Se la directory non lo fa
esiste ancora, sarà creato.

Nota: quando mu crea una Maildir per questi link, inserisce automaticamente un file
.noindex file, da cui escludere la directory mu Index.

--dopo= mostra solo i messaggi i cui file di messaggi erano
Ultima modifica (mtime) dopo . è un UNIX tempo_t valore, il
numero di secondi dal 1970-01-01 (in UTC).

Dalla riga di comando è possibile utilizzare il file quando comando per ottenere questo valore. Per esempio,
considera solo i messaggi modificati (o creati) negli ultimi 5 minuti, potresti
specificare
--after=`data +%s --date='5 minuti fa'`
Questo presuppone la GNU quando comando.

--esecuz=
, il --esecuz comando provoca il command da eseguire su ogni messaggio abbinato; per
Ad esempio, per vedere il testo non elaborato di tutti i messaggi che corrispondono a "milkshake", potresti utilizzare:
$ mu trova milkshake --exec='meno'
che equivale più o meno a:
$ devi trovare milkshake --fields="l" | xargs meno

-b, --segnalibro=
utilizzare una query di ricerca con segnalibro. Utilizzando questa opzione, una query dal file dei segnalibri
verrà anteposto ad altre query di ricerca. Vedere mu-segnalibri(1) per i dettagli di
il file dei segnalibri.

--skip-dups,-u ogni volta che ci sono più messaggi con il file
stesso nome, mostra solo il primo. Questo è utile se hai copie dello stesso
messaggio, che è un evento comune quando si utilizza, ad esempio, Gmail insieme a
mappa offline.

--include-relativo,-r includono anche i messaggi a cui fa riferimento
i messaggi corrispondenti, ad es. includere messaggi che fanno parte dello stesso messaggio
thread come alcuni messaggi corrispondenti. Questo è utile se vuoi lo stile Gmail
'conversazioni'. Tieni presente che la ricerca di questi messaggi correlati rallenta le ricerche.

-t, --thread mostra i messaggi in un formato "thread", ovvero
con rientro e frecce che mostrano i thread di conversazione nell'elenco di
messaggi corrispondenti.

I messaggi nell'elenco dei thread vengono rientrati in base alla profondità della discussione,
e sono preceduti da una sorta di freccia con informazioni relative al thread sul file
messaggio, come nella tabella seguente:

| | normale | orfano | duplicato |
|-------------+--------+--------+-----------|
| primo figlio | `-> | `*> | `=> |
| altro | |-> | |*> | |=> |

Qui, un 'orfano' è un messaggio senza un messaggio principale (nell'elenco delle corrispondenze),
e un duplicato è un messaggio il cui message-id è già stato visto in precedenza; non questo potrebbe
non essere realmente lo stesso messaggio, se l'id del messaggio è stato copiato.

L'algoritmo utilizzato per determinare i thread è basato su quello di Jamie Zawinksi
descrizione: http://www.jwz.org/doc/threading.html

Esempio query
Ecco alcuni semplici esempi di mu query di ricerca; puoi renderne molti più complicati
query utilizzando vari operatori logici, parentesi e così via, ma in quelle dell'autore
esperienza, in genere è più veloce trovare un messaggio con una semplice query semplicemente cercando
alcune parole.

Trova tutti i messaggi contenenti sia "ape" che "uccello" (in qualsiasi campo)

$ devo trovare un'ape E un uccello

o più breve, perché E è implicito:

$ devo trovare l'uccello delle api

Trova tutti i messaggi con Frodo o Sam:

$ devi trovare 'Frodo OR Sam'

Trova tutti i messaggi con "wombat" come oggetto e "capibara" ovunque:

$ mu trova oggetto:wombat capibara

Trova tutti i messaggi nella cartella "Archivio" di Fred:

$ devi trovarlo da:fred maildir:/Archive

Trova tutti i messaggi non letti con allegati:

$ mu trova flag:allega flag:non letto

Trova tutti i messaggi con allegati PDF:

$ mu trova mime:application/pdf

Trova tutti i messaggi con immagini allegate:

$ devi trovare 'mime:image/*'

Nota[1]: l'argomento deve essere racchiuso tra virgolette, altrimenti la shell interpreterà '*' Nota[2]: il
Il carattere jolly '*' può essere utilizzato solo come ultima parte (più a destra) di un termine di ricerca. Nota 3]:
i caratteri non verbali (come € o ☺) vengono ignorati nelle query; non puoi cercarli.

Integrazione mu Find con mail clienti
cane bastardo

Da cane bastardo puoi usare quanto segue nel tuo muttrc; premendo il tasto F8 verrà avviato a
cerca e F9 ti porterà ai risultati.

# macro mutt per mu
indice macro " devi trovare --clearlinks --format=links --linksdir=~/Maildir/search "
"devo trovare"
indice macro "~/Maildir/search"
"troverò risultati"

Wanderlust

Sam B ha suggerito quanto segue su mu-mailing list. Per prima cosa aggiungi quanto segue a
il tuo file di configurazione Wanderlust:

(richiede 'elmo-search)
(elmo-search-register-engine
'mu' file-locale
:prog "/usr/local/bin/mu" ;; o ovunque tu lo abbia installato
:args '("trova" modello "--fields" "l") :charset 'utf-8)

(setq elmo-search-default-engine 'mu)
;; per quando digiti "g" nella cartella o nel riepilogo.
(setq wl-default-spec "[")

Ora puoi effettuare la ricerca utilizzando il file g rilegatura dei tasti; puoi anche creare virtuale permanente
cartelle quando i messaggi corrispondono a qualche espressione aggiungendo qualcosa come il
seguendo il tuo e cartelle file.

Cartelle V {
[data:oggi..adesso]!mu "Oggi"

[dimensione: 1m..100m]!mu "Grande"

[flag:non letto]!mu "Non letto"
}

Dopo aver riavviato Wanderlust, dovrebbero apparire le cartelle virtuali.

Wanderlust (vecchio)

Un altro modo per integrarsi mu e voglia di girovagare è mostrato di seguito; il suddetto
è consigliato, ma se per qualche motivo non funziona, può esserlo quello riportato di seguito
un'alternativa.

(defvar mu-wl-mu-programma "/usr/local/bin/mu")
(defvar mu-wl-search-folder "ricerca")

(defun mu-wl-search ()
"cerca i messaggi con `mu' e passa ai risultati"
(let* ((muexpr (read-string "Trova messaggi corrispondenti: "))
(sfldr (concat elmo-maildir-percorso-cartella "/"
mu-wl-cartella-ricerca))
(cmdline (concat mu-wl-mu-programma " trova "
"--clearlinks --format=links --linksdir='" sfldr "' "
muexpr))
(rv (riga di comando del comando shell)))
(cond
((= rv 0) (messaggio "Richiesta riuscita"))
((= rv 2) (messaggio "Nessuna corrispondenza trovata"))
(t (messaggio "Errore durante l'esecuzione della query")))
(= vv 0)))

(defun mu-wl-search-and-goto ()
"cerca e passa alla cartella con i risultati"
(interattivo)
(quando (mu-wl-search)
(wl-summary-goto-folder-subr
(concat "." mu-wl-cartella-ricerca)
'aggiornamento forzato nil nil t)
(wl-riepilogo-ordina-per-data)))

;; interrogando sia nel riepilogo che nella cartella
(define-key wl-summary-mode-map (kbd "Q");; => query
'(lambda()(interattivo)(mu-wl-cerca-e-vai)))
(define-key wl-folder-mode-map (kbd "Q") ;; => query
'(lambda()(interattivo)(mu-wl-cerca-e-vai)))

RITORNO VALORE

mu Find restituisce 0 in caso di completamento positivo; se la ricerca è stata eseguita, è necessario
esserci almeno una corrispondenza. Qualsiasi altra cosa porta a un valore restituito diverso da zero, ad esempio:

| codice | significato |
|-------+--------------------------------|
| 0 | va bene |
| 1 | errore generale |
| 2| nessuna corrispondenza (per 'mu find') |
| 4| il database è danneggiato |

CODIFICA

mu Find l'output è codificato in base alle impostazioni locali per --format=normale (l'impostazione predefinita) e UTF-8
per tutti gli altri formati (sesso, xml).

Utilizza mu-find online utilizzando i servizi onworks.net