Update vendor/

vendor/github.com/emersion/go-message/mail/address.go

@@ -0,0 +1,37 @@
+package mail
+
+import (
+	"net/mail"
+	"strings"
+)
+
+// Address represents a single mail address.
+type Address mail.Address
+
+// String formats the address as a valid RFC 5322 address. If the address's name
+// contains non-ASCII characters the name will be rendered according to
+// RFC 2047.
+func (a *Address) String() string {
+	return ((*mail.Address)(a)).String()
+}
+
+func parseAddressList(s string) ([]*Address, error) {
+	list, err := mail.ParseAddressList(s)
+	if err != nil {
+		return nil, err
+	}
+
+	addrs := make([]*Address, len(list))
+	for i, a := range list {
+		addrs[i] = (*Address)(a)
+	}
+	return addrs, nil
+}
+
+func formatAddressList(l []*Address) string {
+	formatted := make([]string, len(l))
+	for i, a := range l {
+		formatted[i] = a.String()
+	}
+	return strings.Join(formatted, ", ")
+}

vendor/github.com/emersion/go-message/mail/attachment.go

@@ -0,0 +1,38 @@
+package mail
+
+import (
+	"github.com/emersion/go-message"
+)
+
+// An AttachmentHeader represents an attachment's header.
+type AttachmentHeader struct {
+	message.Header
+}
+
+// NewAttachmentHeader creates a new AttachmentHeader.
+func NewAttachmentHeader() AttachmentHeader {
+	h := AttachmentHeader{make(message.Header)}
+	h.Set("Content-Disposition", "attachment")
+	h.Set("Content-Transfer-Encoding", "base64")
+	return h
+}
+
+// Filename parses the attachment's filename.
+func (h AttachmentHeader) Filename() (string, error) {
+	_, params, err := h.ContentDisposition()
+
+	filename, ok := params["filename"]
+	if !ok {
+		// Using "name" in Content-Type is discouraged
+		_, params, err = h.ContentType()
+		filename = params["name"]
+	}
+
+	return filename, err
+}
+
+// SetFilename formats the attachment's filename.
+func (h AttachmentHeader) SetFilename(filename string) {
+	dispParams := map[string]string{"filename": filename}
+	h.SetContentDisposition("attachment", dispParams)
+}

vendor/github.com/emersion/go-message/mail/header.go

@@ -0,0 +1,57 @@
+package mail
+
+import (
+	"net/mail"
+	"time"
+
+	"github.com/emersion/go-message"
+	"github.com/emersion/go-message/charset"
+)
+
+const dateLayout = "Mon, 02 Jan 2006 15:04:05 -0700"
+
+// A Header is a mail header.
+type Header struct {
+	message.Header
+}
+
+// NewHeader creates a new mail header.
+func NewHeader() Header {
+	return Header{make(message.Header)}
+}
+
+// AddressList parses the named header field as a list of addresses. If the
+// header is missing, it returns nil.
+func (h Header) AddressList(key string) ([]*Address, error) {
+	v := h.Get(key)
+	if v == "" {
+		return nil, nil
+	}
+	return parseAddressList(v)
+}
+
+// SetAddressList formats the named header to the provided list of addresses.
+func (h Header) SetAddressList(key string, addrs []*Address) {
+	h.Set(key, formatAddressList(addrs))
+}
+
+// Date parses the Date header field.
+func (h Header) Date() (time.Time, error) {
+	return mail.Header(h.Header).Date()
+}
+
+// SetDate formats the Date header field.
+func (h Header) SetDate(t time.Time) {
+	h.Set("Date", t.Format(dateLayout))
+}
+
+// Subject parses the Subject header field. If there is an error, the raw field
+// value is returned alongside the error.
+func (h Header) Subject() (string, error) {
+	return charset.DecodeHeader(h.Get("Subject"))
+}
+
+// SetSubject formats the Subject header field.
+func (h Header) SetSubject(s string) {
+	h.Set("Subject", charset.EncodeHeader(s))
+}

vendor/github.com/emersion/go-message/mail/mail.go

@@ -0,0 +1,9 @@
+// Package mail implements reading and writing mail messages.
+//
+// This package assumes that a mail message contains one or more text parts and
+// zero or more attachment parts. Each text part represents a different version
+// of the message content (e.g. a different type, a different language and so
+// on).
+//
+// RFC 5322 defines the Internet Message Format.
+package mail

vendor/github.com/emersion/go-message/mail/reader.go

@@ -0,0 +1,130 @@
+package mail
+
+import (
+	"container/list"
+	"io"
+	"strings"
+
+	"github.com/emersion/go-message"
+)
+
+// A PartHeader is a mail part header. It contains convenience functions to get
+// and set header fields.
+type PartHeader interface {
+	// Add adds the key, value pair to the header.
+	Add(key, value string)
+	// Del deletes the values associated with key.
+	Del(key string)
+	// Get gets the first value associated with the given key. If there are no
+	// values associated with the key, Get returns "".
+	Get(key string) string
+	// Set sets the header entries associated with key to the single element
+	// value. It replaces any existing values associated with key.
+	Set(key, value string)
+}
+
+// A Part is either a mail text or an attachment. Header is either a TextHeader
+// or an AttachmentHeader.
+type Part struct {
+	Header PartHeader
+	Body   io.Reader
+}
+
+// A Reader reads a mail message.
+type Reader struct {
+	Header Header
+
+	e       *message.Entity
+	readers *list.List
+}
+
+// NewReader creates a new mail reader.
+func NewReader(e *message.Entity) *Reader {
+	mr := e.MultipartReader()
+	if mr == nil {
+		// Artificially create a multipart entity
+		// With this header, no error will be returned by message.NewMultipart
+		h := make(message.Header)
+		h.Set("Content-Type", "multipart/mixed")
+		me, _ := message.NewMultipart(h, []*message.Entity{e})
+		mr = me.MultipartReader()
+	}
+
+	l := list.New()
+	l.PushBack(mr)
+
+	return &Reader{Header{e.Header}, e, l}
+}
+
+// CreateReader reads a mail header from r and returns a new mail reader.
+//
+// If the message uses an unknown transfer encoding or charset, CreateReader
+// returns an error that verifies message.IsUnknownEncoding, but also returns a
+// Reader that can be used.
+func CreateReader(r io.Reader) (*Reader, error) {
+	e, err := message.Read(r)
+	if err != nil && !message.IsUnknownEncoding(err) {
+		return nil, err
+	}
+
+	return NewReader(e), err
+}
+
+// NextPart returns the next mail part. If there is no more part, io.EOF is
+// returned as error.
+//
+// The returned Part.Body must be read completely before the next call to
+// NextPart, otherwise it will be discarded.
+//
+// If the part uses an unknown transfer encoding or charset, NextPart returns an
+// error that verifies message.IsUnknownEncoding, but also returns a Part that
+// can be used.
+func (r *Reader) NextPart() (*Part, error) {
+	for r.readers.Len() > 0 {
+		e := r.readers.Back()
+		mr := e.Value.(message.MultipartReader)
+
+		p, err := mr.NextPart()
+		if err == io.EOF {
+			// This whole multipart entity has been read, continue with the next one
+			r.readers.Remove(e)
+			continue
+		} else if err != nil && !message.IsUnknownEncoding(err) {
+			return nil, err
+		}
+
+		if pmr := p.MultipartReader(); pmr != nil {
+			// This is a multipart part, read it
+			r.readers.PushBack(pmr)
+		} else {
+			// This is a non-multipart part, return a mail part
+			mp := &Part{Body: p.Body}
+			t, _, _ := p.Header.ContentType()
+			disp, _, _ := p.Header.ContentDisposition()
+			if strings.HasPrefix(t, "text/") && disp != "attachment" {
+				mp.Header = TextHeader{p.Header}
+			} else {
+				mp.Header = AttachmentHeader{p.Header}
+			}
+			return mp, err
+		}
+	}
+
+	return nil, io.EOF
+}
+
+// Close finishes the reader.
+func (r *Reader) Close() error {
+	for r.readers.Len() > 0 {
+		e := r.readers.Back()
+		mr := e.Value.(message.MultipartReader)
+
+		if err := mr.Close(); err != nil {
+			return err
+		}
+
+		r.readers.Remove(e)
+	}
+
+	return nil
+}

vendor/github.com/emersion/go-message/mail/text.go

@@ -0,0 +1,18 @@
+package mail
+
+import (
+	"github.com/emersion/go-message"
+)
+
+// A TextHeader represents a message text header.
+type TextHeader struct {
+	message.Header
+}
+
+// NewTextHeader creates a new message text header.
+func NewTextHeader() TextHeader {
+	h := TextHeader{make(message.Header)}
+	h.Set("Content-Disposition", "inline")
+	h.Set("Content-Transfer-Encoding", "quoted-printable")
+	return h
+}

vendor/github.com/emersion/go-message/mail/writer.go

@@ -0,0 +1,73 @@
+package mail
+
+import (
+	"io"
+
+	"github.com/emersion/go-message"
+)
+
+// A Writer writes a mail message. A mail message contains one or more text
+// parts and zero or more attachments.
+type Writer struct {
+	mw *message.Writer
+}
+
+// CreateWriter writes a mail header to w and creates a new Writer.
+func CreateWriter(w io.Writer, header Header) (*Writer, error) {
+	header.Set("Content-Type", "multipart/mixed")
+
+	mw, err := message.CreateWriter(w, header.Header)
+	if err != nil {
+		return nil, err
+	}
+
+	return &Writer{mw}, nil
+}
+
+// CreateText creates a TextWriter. One or more parts representing the same text
+// in different formats can be written to a TextWriter.
+func (w *Writer) CreateText() (*TextWriter, error) {
+	h := make(message.Header)
+	h.Set("Content-Type", "multipart/alternative")
+
+	mw, err := w.mw.CreatePart(h)
+	if err != nil {
+		return nil, err
+	}
+	return &TextWriter{mw}, nil
+}
+
+// CreateSingleText creates a new single text part with the provided header. The
+// body of the part should be written to the returned io.WriteCloser. Only one
+// single text part should be written, use CreateText if you want multiple text
+// parts.
+func (w *Writer) CreateSingleText(header TextHeader) (io.WriteCloser, error) {
+	return w.mw.CreatePart(header.Header)
+}
+
+// CreateAttachment creates a new attachment with the provided header. The body
+// of the part should be written to the returned io.WriteCloser.
+func (w *Writer) CreateAttachment(header AttachmentHeader) (io.WriteCloser, error) {
+	return w.mw.CreatePart(header.Header)
+}
+
+// Close finishes the Writer.
+func (w *Writer) Close() error {
+	return w.mw.Close()
+}
+
+// TextWriter writes a mail message's text.
+type TextWriter struct {
+	mw *message.Writer
+}
+
+// CreatePart creates a new text part with the provided header. The body of the
+// part should be written to the returned io.WriteCloser.
+func (w *TextWriter) CreatePart(header TextHeader) (io.WriteCloser, error) {
+	return w.mw.CreatePart(header.Header)
+}
+
+// Close finishes the TextWriter.
+func (w *TextWriter) Close() error {
+	return w.mw.Close()
+}