imap

type Address ¶

type Address struct {
	Name    string
	Route   string
	Mailbox string
	Host    string
}

Address is one address from an ENVELOPE. It mirrors Net::IMAP::Address (members: name, route, mailbox, host). A field is "" where the wire form was NIL.

type AppendUIDData ¶

type AppendUIDData struct {
	UIDValidity  int64
	AssignedUIDs string
}

AppendUIDData is the data of an [APPENDUID uidvalidity uid] response code, mirroring Net::IMAP::AppendUIDData (members: uidvalidity, assigned_uids). AssignedUIDs is the sequence-set string the server reported (e.g. "3955").

type Argument ¶

type Argument = any

Argument is a value usable as an IMAP command argument. The accepted dynamic types mirror MRI's send_data dispatch:

nil              -> NIL
string           -> atom / quoted-string / literal (per send_string_data)
int / int64      -> a number
[]Argument       -> a parenthesised list
time.Time        -> a quoted date-time ("DD-Mon-YYYY HH:MM:SS +ZZZZ")
Date             -> a quoted date (DD-Mon-YYYY)
Flag             -> a backslash-prefixed atom (\Seen)
Atom             -> a raw atom, emitted verbatim
QuotedString     -> always a quoted string
Literal          -> always a literal
RawData          -> emitted verbatim with no quoting
*SequenceSet     -> the coalesced sequence-set form (1:3,7)

type Atom ¶

type Atom string

Atom is a command argument emitted verbatim as an atom (Net::IMAP::Atom).

type BodyStructure ¶

type BodyStructure struct {
	// Multipart is true when the body is a multipart/* (a parenthesised list of
	// nested parts followed by the subtype).
	Multipart bool

	// Parts holds the nested parts of a multipart body (nil for singlepart).
	Parts []*BodyStructure
	// MultipartSubtype is the subtype of a multipart body ("MIXED", "ALTERNATIVE").
	MultipartSubtype string

	// Singlepart fields (the body-type-1part grammar):
	MediaType   string // body-fld-type, e.g. "TEXT" / "IMAGE" / "MESSAGE"
	Subtype     string // body-fld-subtype, e.g. "PLAIN"
	Params      *OrderedAttr
	ContentID   string
	Description string
	Encoding    string
	Size        int64
	Lines       int64 // text body line count (TEXT subtype only); -1 if absent

	// Extension holds any remaining body-ext-* items (md5, disposition,
	// language, location, and the per-type extension data) as a generic list of
	// parsed values, in wire order.
	Extension []any
}

BodyStructure is the parsed BODY / BODYSTRUCTURE of a message part.

Boundary versus MRI ¶

MRI builds a tower of typed structs (BodyTypeText, BodyTypeBasic, BodyTypeMessage, BodyTypeMultipart, …) and assigns each body-fld-* slot a named member. This package instead returns one uniform, fully-recursive tree: every field of the body grammar is captured (so no information is lost), but the dispatch to a specific Ruby struct class — and the field-name mapping of the per-type extension data — is left to the host (rbgo), which knows the Ruby class registry. Parts is non-nil only for a multipart body; for a singlepart body the leading nstring/number fields populate the named slots and Extension holds the remaining body-ext-* items verbatim as a generic list.

This is the one documented-partial attribute: the parse is complete and loss-free, but it is not mapped to MRI's BodyType* struct names here.

func (b *BodyStructure) BodyType() string

type Builder ¶

type Builder struct {
	// contains filtered or unexported fields
}

Builder assembles tagged command lines with monotonic tags, mirroring Net::IMAP#generate_tag ("<prefix><4-digit>"). The zero value is not usable; use NewBuilder.

func NewBuilder(prefix string) *Builder

func (b *Builder) Append(mailbox string, flags []Flag, dt *Date, message string) (Command, error)

func (b *Builder) Authenticate(mechanism string) (Command, error)

func (b *Builder) Capability() (Command, error)

func (b *Builder) Check() (Command, error)

func (b *Builder) Close() (Command, error)

func (b *Builder) Command(cmd string, args ...Argument) (Command, error)

func (b *Builder) Copy(set *SequenceSet, mailbox string) (Command, error)

func (b *Builder) Create(mailbox string) (Command, error)

func (b *Builder) Delete(mailbox string) (Command, error)

func (b *Builder) Examine(mailbox string) (Command, error)

func (b *Builder) Expunge() (Command, error)

func (b *Builder) Fetch(set *SequenceSet, atts ...string) (Command, error)

func (b *Builder) Idle() (Command, error)

func (b *Builder) List(refName, mailbox string) (Command, error)

func (b *Builder) Login(user, password string) (Command, error)

func (b *Builder) Logout() (Command, error)

func (b *Builder) Lsub(refName, mailbox string) (Command, error)

func (b *Builder) NextTag() string

func (b *Builder) Noop() (Command, error)

func (b *Builder) Rename(oldName, newName string) (Command, error)

func (b *Builder) Search(keys ...Argument) (Command, error)

func (b *Builder) Select(mailbox string) (Command, error)

func (b *Builder) StartTLS() (Command, error)

func (b *Builder) Status(mailbox string, attrs ...string) (Command, error)

func (b *Builder) Store(set *SequenceSet, item string, flags []Flag) (Command, error)

func (b *Builder) Subscribe(mailbox string) (Command, error)

func (b *Builder) UIDCopy(set *SequenceSet, mailbox string) (Command, error)

func (b *Builder) UIDFetch(set *SequenceSet, atts ...string) (Command, error)

func (b *Builder) UIDSearch(keys ...Argument) (Command, error)

func (b *Builder) UIDStore(set *SequenceSet, item string, flags []Flag) (Command, error)

func (b *Builder) Unselect() (Command, error)

func (b *Builder) Unsubscribe(mailbox string) (Command, error)

type Command ¶

type Command struct {
	Tag      string
	Bytes    string
	Literals []LiteralSegment
}

Command is a fully-built tagged command ready to write to the socket. Bytes is the complete octet sequence ("TAG CMD args\r\n"); Tag is the tag the host must match against the eventual tagged response. When the command carries one or more literals, Bytes stops just after the first `{n}\r\n`; the remaining segments live in Literals and the host writes each after receiving a continuation request. For literal-free commands Literals is empty and Bytes is the whole line.

type ContinuationRequest ¶

type ContinuationRequest struct {
	Data    *ResponseText
	RawData string
}

ContinuationRequest is a command continuation request (`+ …`). It mirrors Net::IMAP::ContinuationRequest (members: data, raw_data).

type CopyUIDData ¶

type CopyUIDData struct {
	UIDValidity  int64
	SourceUIDs   string
	AssignedUIDs string
}

CopyUIDData is the data of a [COPYUID uidvalidity src dst] response code, mirroring Net::IMAP::CopyUIDData (members: uidvalidity, source_uids, assigned_uids). The two UID sets are the sequence-set strings the server sent.

type Date ¶

type Date struct {
	Year  int
	Month time.Month
	Day   int
}

Date is a calendar date emitted as the IMAP `DD-Mon-YYYY` quoted date.

type Envelope ¶

type Envelope struct {
	Date      string
	Subject   string
	From      []Address
	Sender    []Address
	ReplyTo   []Address
	To        []Address
	Cc        []Address
	Bcc       []Address
	InReplyTo string
	MessageID string
}

Envelope is the parsed ENVELOPE fetch attribute. It mirrors Net::IMAP::Envelope (members: date, subject, from, sender, reply_to, to, cc, bcc, in_reply_to, message_id). String members are "" where the wire form was NIL; address-list members are nil where the wire form was NIL.

type FetchData ¶

type FetchData struct {
	Seqno int64
	Attr  *OrderedAttr
}

FetchData is the data of a FETCH response. It mirrors Net::IMAP::FetchData (members: seqno, attr). Attr maps each fetch attribute name to its parsed value (see ParseResponse for the per-attribute value types), preserving the order the server sent them.

type Flag ¶

type Flag string

Flag is a system or keyword flag. System flags are reported by their bare name without the leading backslash and capitalised like Ruby's symbol (`\Seen` -> Flag("Seen")); the wildcard `\*` is Flag("*"). Keyword flags (no backslash) are reported verbatim.

type Literal ¶

type Literal string

Literal is a command argument always emitted as a literal (Net::IMAP::Literal): `{n}\r\n` followed by the bytes (the host sends the bytes after the server's continuation request).

type LiteralSegment ¶

type LiteralSegment struct {
	Data string
	Tail string
}

LiteralSegment is the literal payload plus the bytes that follow it (up to and including the next literal's `{n}\r\n`, or the trailing CRLF). The host writes Data after a continuation request, then writes Tail.

type MailboxList ¶

type MailboxList struct {
	Attr  []Flag
	Delim string // hierarchy delimiter, or "" for NIL
	Name  string
}

MailboxList is the data of a LIST or LSUB response. It mirrors Net::IMAP::MailboxList (members: attr, delim, name).

type OrderedAttr ¶

type OrderedAttr struct {
	// contains filtered or unexported fields
}

OrderedAttr is an insertion-ordered string-keyed map of FETCH attributes, mirroring the Ruby Hash that Net::IMAP::FetchData#attr returns (key order is the server's order).

func (o *OrderedAttr) Get(key string) (any, bool)

func (o *OrderedAttr) Keys() []string

func (o *OrderedAttr) Len() int

func (o *OrderedAttr) Set(key string, val any)

type OrderedInts ¶

type OrderedInts struct {
	// contains filtered or unexported fields
}

OrderedInts is an insertion-ordered string-keyed map of integers, used for the STATUS attr hash.

func (o *OrderedInts) Get(key string) (int64, bool)

func (o *OrderedInts) Keys() []string

func (o *OrderedInts) Len() int

func (o *OrderedInts) Set(key string, val int64)

type QuotedString ¶

type QuotedString string

QuotedString is a command argument always emitted as a quoted string (Net::IMAP::QuotedString).

type RawData ¶

type RawData string

RawData is a command argument emitted verbatim with no quoting (Net::IMAP::RawData).

type ReadLineFunc ¶

type ReadLineFunc func() (string, error)

ReadLineFunc reads the next CRLF-terminated line from the connection, including the trailing CRLF. It returns the line and nil on success, or a non-nil error (e.g. io.EOF) at end of stream. The host wires this to its buffered socket reader.

type ReadLiteralFunc ¶

type ReadLiteralFunc func(n int) (string, error)

ReadLiteralFunc reads exactly n bytes of literal payload from the connection. The host wires this to a full read of n octets off the socket.

type Reader ¶

type Reader struct {
	// contains filtered or unexported fields
}

Reader assembles complete response buffers from a line reader and a literal reader, then parses them. It is the parser-side seam: the host supplies the two transport callbacks and Reader does the IMAP framing (detecting a trailing `{n}\r\n`, reading n literal bytes, and continuing until the line is complete).

func NewReader(readLine ReadLineFunc, readLiteral ReadLiteralFunc) *Reader

func (r *Reader) ReadBuffer() (string, error)

func (r *Reader) ReadResponse() (Response, error)

type Response ¶

type Response interface {
	// contains filtered or unexported methods
}

Response is the common interface of the three response shapes ParseResponse returns: *TaggedResponse, *UntaggedResponse and *ContinuationRequest.

func ParseResponse(buf string) (Response, error)

type ResponseCode ¶

type ResponseCode struct {
	Name string
	Data any
}

ResponseCode is a bracketed response code such as [ALERT], [UIDVALIDITY 1234] or [PERMANENTFLAGS (\Deleted \Seen \*)]. It mirrors Net::IMAP::ResponseCode (members: name, data). Data is nil, an int64, a string, a []int64, or a []Flag depending on the code.

type ResponseText ¶

type ResponseText struct {
	Code *ResponseCode
	Text string
}

ResponseText is the human-readable text of a status response, with an optional bracketed [resp-text-code]. It mirrors Net::IMAP::ResponseText (members: code, text).

type SeqRange ¶

type SeqRange struct{ Lo, Hi int64 }

SeqRange is a closed range [Lo, Hi] for NewSequenceSet. Use Star for "*".

type SequenceSet ¶

type SequenceSet struct {
	// contains filtered or unexported fields
}

SequenceSet is a set of message sequence numbers or UIDs. It coalesces sorted values into ranges the way Net::IMAP::SequenceSet#valid_string does ([3,1,2] -> "1:3"). A value of 0 stands for "*" (the largest in the mailbox).

func NewSequenceSet(items ...any) (*SequenceSet, error)

func (s *SequenceSet) String() string

type StatusData ¶

type StatusData struct {
	Mailbox string
	Attr    *OrderedInts
}

StatusData is the data of a STATUS response. It mirrors Net::IMAP::StatusData (members: mailbox, attr). Attr maps each requested status item (MESSAGES, RECENT, UIDNEXT, UIDVALIDITY, UNSEEN, …) to its integer value, preserving the order the server sent them.

type TaggedResponse ¶

type TaggedResponse struct {
	Tag     string
	Name    string
	Data    *ResponseText
	RawData string
}

TaggedResponse is a tagged status response (`a001 OK …`). It mirrors Net::IMAP::TaggedResponse (members: tag, name, data, raw_data).

type UntaggedResponse ¶

type UntaggedResponse struct {
	Name    string
	Data    any
	RawData string
}

UntaggedResponse is an untagged response (`* …`). It mirrors Net::IMAP::UntaggedResponse (members: name, data, raw_data). Data's concrete type depends on Name: int64 for EXISTS/RECENT/EXPUNGE, *ResponseText for OK/NO/BAD/BYE/PREAUTH, []Flag for FLAGS, *MailboxList for LIST/LSUB, *StatusData for STATUS, []int64 for SEARCH, []string for CAPABILITY, and *FetchData for FETCH.