Something went wrong. Try again.
Kagi Mail CLI client
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181package compose
import ( "errors" "fmt" "net/mail" "strings"
km "tangled.org/matilde.at/km/internal/mail")
// Errors returned by Parse and ParseEdited. Callers may match them with// errors.Is.var ( ErrEmptyBody = errors.New("message body is empty: aborting") ErrUnchanged = errors.New("message unchanged: aborting"))
// Serialise renders m as an editor buffer://// From: Name <addr>// To: a@example.org, "Doe, Jane" <jane@example.org>// Cc:// Subject: hello//// body//// Bcc is written only when non-empty. Attachments, reply headers and// identity ids are not part of the buffer; Parse leaves them zero, so callers// copy them over from the original Message with Message.Merge.func Serialise(m Message) string { var b strings.Builder header := func(name, value string) { b.WriteString(name + ":") if value != "" { b.WriteString(" " + value) } b.WriteString("\n") } header("From", FormatAddress(m.From)) header("To", FormatAddresses(m.To)) header("Cc", FormatAddresses(m.Cc)) if len(m.Bcc) > 0 { header("Bcc", FormatAddresses(m.Bcc)) } header("Subject", m.Subject) b.WriteString("\n") b.WriteString(m.Body) if m.Body != "" && !strings.HasSuffix(m.Body, "\n") { b.WriteString("\n") } return b.String()}
// Parse reads an editor buffer. Headers (From, To, Cc, Bcc, Subject; names// are case-insensitive; continuation lines start with white space) end at the// first blank line; everything after it is the body. Address lists are parsed// with net/mail, so bare addresses, display names and quoted commas all work.// An empty or whitespace-only body yields ErrEmptyBody. An unknown header is// an error, since it would otherwise be silently dropped.func Parse(buf string) (Message, error) { buf = strings.ReplaceAll(buf, "\r\n", "\n") head, body, _ := strings.Cut(buf, "\n\n") var m Message var lines []string for _, l := range strings.Split(head, "\n") { if (strings.HasPrefix(l, " ") || strings.HasPrefix(l, "\t")) && len(lines) > 0 { lines[len(lines)-1] += " " + strings.TrimSpace(l) continue } if strings.TrimSpace(l) == "" { continue } lines = append(lines, l) } for _, l := range lines { name, value, ok := strings.Cut(l, ":") if !ok { return Message{}, fmt.Errorf("malformed header line %q (expected \"Name: value\")", l) } name = strings.TrimSpace(name) value = strings.TrimSpace(value) var err error switch strings.ToLower(name) { case "from": var from []km.Address if from, err = ParseAddresses(value); err == nil { if len(from) > 1 { err = errors.New("only one address is allowed") } else if len(from) == 1 { m.From = from[0] } } case "to": m.To, err = ParseAddresses(value) case "cc": m.Cc, err = ParseAddresses(value) case "bcc": m.Bcc, err = ParseAddresses(value) case "subject": m.Subject = value default: return Message{}, fmt.Errorf("unknown header %q", name) } if err != nil { return Message{}, fmt.Errorf("%s: %w", name, err) } } if strings.TrimSpace(body) == "" { return Message{}, ErrEmptyBody } m.Body = strings.TrimRight(body, " \t\n") + "\n" return m, nil}
// ParseEdited is Parse for the result of an editor session that started from// initial: an unchanged buffer yields ErrUnchanged.func ParseEdited(initial, edited string) (Message, error) { if edited == initial { return Message{}, ErrUnchanged } return Parse(edited)}
// ParseAddresses parses a comma-separated address list ("a@x.org, Jane// <j@x.org>"). An empty string gives nil.func ParseAddresses(s string) ([]km.Address, error) { if strings.TrimSpace(s) == "" { return nil, nil } list, err := mail.ParseAddressList(s) if err != nil { return nil, err } out := make([]km.Address, len(list)) for i, a := range list { out[i] = km.Address{Name: a.Name, Email: a.Address} } return out, nil}
// ParseAddressFlags parses repeatable, possibly comma-separated flag values.func ParseAddressFlags(values []string) ([]km.Address, error) { var out []km.Address for _, v := range values { as, err := ParseAddresses(v) if err != nil { return nil, fmt.Errorf("%q: %w", v, err) } out = append(out, as...) } return out, nil}
// FormatAddress renders one address for humans and for the buffer: the bare// address, or `Name <addr>` with the name quoted when it contains specials.func FormatAddress(a km.Address) string { if a.Email == "" && a.Name == "" { return "" } if a.Name == "" { return a.Email } name := a.Name if strings.ContainsAny(name, "()<>[]:;@\\,.\"") { name = `"` + strings.NewReplacer(`\`, `\\`, `"`, `\"`).Replace(name) + `"` } return name + " <" + a.Email + ">"}
// FormatAddresses joins FormatAddress with ", ", skipping empty addresses.func FormatAddresses(as []km.Address) string { var parts []string for _, a := range as { if s := FormatAddress(a); s != "" { parts = append(parts, s) } } return strings.Join(parts, ", ")}