Merge pull request #182 from wneessen/feature/179_refactor-variable-names-for-readability

Refactor variable names for readability

b64linebreaker.go

@@ -20,39 +20,39 @@ type Base64LineBreaker struct {
 	out  io.Writer
 }
 
-var nl = []byte(SingleNewLine)
+var newlineBytes = []byte(SingleNewLine)
 
 // Write writes the data stream and inserts a SingleNewLine when the maximum
 // line length is reached
-func (l *Base64LineBreaker) Write(b []byte) (n int, err error) {
+func (l *Base64LineBreaker) Write(data []byte) (numBytes int, err error) {
 	if l.out == nil {
 		err = fmt.Errorf(ErrNoOutWriter)
 		return
 	}
-	if l.used+len(b) < MaxBodyLength {
+	if l.used+len(data) < MaxBodyLength {
-		copy(l.line[l.used:], b)
+		copy(l.line[l.used:], data)
-		l.used += len(b)
+		l.used += len(data)
-		return len(b), nil
+		return len(data), nil
 	}
 
-	n, err = l.out.Write(l.line[0:l.used])
+	numBytes, err = l.out.Write(l.line[0:l.used])
 	if err != nil {
 		return
 	}
 	excess := MaxBodyLength - l.used
 	l.used = 0
 
-	n, err = l.out.Write(b[0:excess])
+	numBytes, err = l.out.Write(data[0:excess])
 	if err != nil {
 		return
 	}
 
-	n, err = l.out.Write(nl)
+	numBytes, err = l.out.Write(newlineBytes)
 	if err != nil {
 		return
 	}
 
-	return l.Write(b[excess:])
+	return l.Write(data[excess:])
 }
 
 // Close closes the Base64LineBreaker and writes any access data that is still
@@ -63,7 +63,7 @@ func (l *Base64LineBreaker) Close() (err error) {
 		if err != nil {
 			return
 		}
-		_, err = l.out.Write(nl)
+		_, err = l.out.Write(newlineBytes)
 	}
 
 	return

client.go

@@ -87,11 +87,11 @@ type DialContextFunc func(ctx context.Context, network, address string) (net.Con
 
 // Client is the SMTP client struct
 type Client struct {
-	// co is the net.Conn that the smtp.Client is based on
+	// connection is the net.Conn that the smtp.Client is based on
-	co net.Conn
+	connection net.Conn
 
 	// Timeout for the SMTP server connection
-	cto time.Duration
+	connTimeout time.Duration
 
 	// dsn indicates that we want to use DSN for the Client
 	dsn bool
@@ -102,8 +102,8 @@ type Client struct {
 	// dsnrntype defines the DSNRcptNotifyOption in case DSN is enabled
 	dsnrntype []string
 
-	// enc indicates if a Client connection is encrypted or not
+	// isEncrypted indicates if a Client connection is encrypted or not
-	enc bool
+	isEncrypted bool
 
 	// noNoop indicates the Noop is to be skipped
 	noNoop bool
@@ -121,17 +121,17 @@ type Client struct {
 	port         int
 	fallbackPort int
 
-	// sa is a pointer to smtp.Auth
+	// smtpAuth is a pointer to smtp.Auth
-	sa smtp.Auth
+	smtpAuth smtp.Auth
 
-	// satype represents the authentication type for SMTP AUTH
+	// smtpAuthType represents the authentication type for SMTP AUTH
-	satype SMTPAuthType
+	smtpAuthType SMTPAuthType
 
-	// sc is the smtp.Client that is set up when using the Dial*() methods
+	// smtpClient is the smtp.Client that is set up when using the Dial*() methods
-	sc *smtp.Client
+	smtpClient *smtp.Client
 
 	// Use SSL for the connection
-	ssl bool
+	useSSL bool
 
 	// tlspolicy sets the client to use the provided TLSPolicy for the STARTTLS protocol
 	tlspolicy TLSPolicy
@@ -142,11 +142,11 @@ type Client struct {
 	// user is the SMTP AUTH username
 	user string
 
-	// dl enables the debug logging on the SMTP client
+	// useDebugLog enables the debug logging on the SMTP client
-	dl bool
+	useDebugLog bool
 
-	// l is a logger that implements the log.Logger interface
+	// logger is a logger that implements the log.Logger interface
-	l log.Logger
+	logger log.Logger
 
 	// dialContextFunc is a custom DialContext function to dial target SMTP server
 	dialContextFunc DialContextFunc
@@ -198,12 +198,12 @@ var (
 )
 
 // NewClient returns a new Session client object
-func NewClient(h string, o ...Option) (*Client, error) {
+func NewClient(host string, opts ...Option) (*Client, error) {
 	c := &Client{
-		cto:       DefaultTimeout,
+		connTimeout: DefaultTimeout,
-		host:      h,
+		host:        host,
 		port:        DefaultPort,
-		tlsconfig: &tls.Config{ServerName: h, MinVersion: DefaultTLSMinVersion},
+		tlsconfig:   &tls.Config{ServerName: host, MinVersion: DefaultTLSMinVersion},
 		tlspolicy:   DefaultTLSPolicy,
 	}
 
@@ -213,11 +213,11 @@ func NewClient(h string, o ...Option) (*Client, error) {
 	}
 
 	// Override defaults with optionally provided Option functions
-	for _, co := range o {
+	for _, opt := range opts {
-		if co == nil {
+		if opt == nil {
 			continue
 		}
-		if err := co(c); err != nil {
+		if err := opt(c); err != nil {
 			return c, fmt.Errorf("failed to apply option: %w", err)
 		}
 	}
@@ -231,23 +231,23 @@ func NewClient(h string, o ...Option) (*Client, error) {
 }
 
 // WithPort overrides the default connection port
-func WithPort(p int) Option {
+func WithPort(port int) Option {
 	return func(c *Client) error {
-		if p < 1 || p > 65535 {
+		if port < 1 || port > 65535 {
 			return ErrInvalidPort
 		}
-		c.port = p
+		c.port = port
 		return nil
 	}
 }
 
 // WithTimeout overrides the default connection timeout
-func WithTimeout(t time.Duration) Option {
+func WithTimeout(timeout time.Duration) Option {
 	return func(c *Client) error {
-		if t <= 0 {
+		if timeout <= 0 {
 			return ErrInvalidTimeout
 		}
-		c.cto = t
+		c.connTimeout = timeout
 		return nil
 	}
 }
@@ -257,7 +257,7 @@ func WithTimeout(t time.Duration) Option {
 // Deprecated: use WithSSLPort instead.
 func WithSSL() Option {
 	return func(c *Client) error {
-		c.ssl = true
+		c.useSSL = true
 		return nil
 	}
 }
@@ -267,9 +267,9 @@ func WithSSL() Option {
 //
 // When the SSL connection fails and fallback is set to true,
 // the client will attempt to connect on port 25 using plaintext.
-func WithSSLPort(fb bool) Option {
+func WithSSLPort(fallback bool) Option {
 	return func(c *Client) error {
-		c.SetSSLPort(true, fb)
+		c.SetSSLPort(true, fallback)
 		return nil
 	}
 }
@@ -278,26 +278,26 @@ func WithSSLPort(fb bool) Option {
 // to StdErr
 func WithDebugLog() Option {
 	return func(c *Client) error {
-		c.dl = true
+		c.useDebugLog = true
 		return nil
 	}
 }
 
 // WithLogger overrides the default log.Logger that is used for debug logging
-func WithLogger(l log.Logger) Option {
+func WithLogger(logger log.Logger) Option {
 	return func(c *Client) error {
-		c.l = l
+		c.logger = logger
 		return nil
 	}
 }
 
 // WithHELO tells the client to use the provided string as HELO/EHLO greeting host
-func WithHELO(h string) Option {
+func WithHELO(helo string) Option {
 	return func(c *Client) error {
-		if h == "" {
+		if helo == "" {
 			return ErrInvalidHELO
 		}
-		c.helo = h
+		c.helo = helo
 		return nil
 	}
 }
@@ -305,9 +305,9 @@ func WithHELO(h string) Option {
 // WithTLSPolicy tells the client to use the provided TLSPolicy
 //
 // Deprecated: use WithTLSPortPolicy instead.
-func WithTLSPolicy(p TLSPolicy) Option {
+func WithTLSPolicy(policy TLSPolicy) Option {
 	return func(c *Client) error {
-		c.tlspolicy = p
+		c.tlspolicy = policy
 		return nil
 	}
 }
@@ -319,52 +319,52 @@ func WithTLSPolicy(p TLSPolicy) Option {
 // If the connection fails with TLSOpportunistic,
 // a plaintext connection is attempted on port 25 as a fallback.
 // NoTLS will allways use port 25.
-func WithTLSPortPolicy(p TLSPolicy) Option {
+func WithTLSPortPolicy(policy TLSPolicy) Option {
 	return func(c *Client) error {
-		c.SetTLSPortPolicy(p)
+		c.SetTLSPortPolicy(policy)
 		return nil
 	}
 }
 
 // WithTLSConfig tells the client to use the provided *tls.Config
-func WithTLSConfig(co *tls.Config) Option {
+func WithTLSConfig(tlsconfig *tls.Config) Option {
 	return func(c *Client) error {
-		if co == nil {
+		if tlsconfig == nil {
 			return ErrInvalidTLSConfig
 		}
-		c.tlsconfig = co
+		c.tlsconfig = tlsconfig
 		return nil
 	}
 }
 
 // WithSMTPAuth tells the client to use the provided SMTPAuthType for authentication
-func WithSMTPAuth(t SMTPAuthType) Option {
+func WithSMTPAuth(authtype SMTPAuthType) Option {
 	return func(c *Client) error {
-		c.satype = t
+		c.smtpAuthType = authtype
 		return nil
 	}
 }
 
 // WithSMTPAuthCustom tells the client to use the provided smtp.Auth for SMTP authentication
-func WithSMTPAuthCustom(a smtp.Auth) Option {
+func WithSMTPAuthCustom(smtpAuth smtp.Auth) Option {
 	return func(c *Client) error {
-		c.sa = a
+		c.smtpAuth = smtpAuth
 		return nil
 	}
 }
 
 // WithUsername tells the client to use the provided string as username for authentication
-func WithUsername(u string) Option {
+func WithUsername(username string) Option {
 	return func(c *Client) error {
-		c.user = u
+		c.user = username
 		return nil
 	}
 }
 
 // WithPassword tells the client to use the provided string as password/secret for authentication
-func WithPassword(p string) Option {
+func WithPassword(password string) Option {
 	return func(c *Client) error {
-		c.pass = p
+		c.pass = password
 		return nil
 	}
 }
@@ -386,9 +386,9 @@ func WithDSN() Option {
 // as described in the RFC 1891 and set the MAIL FROM Return option type to the
 // given DSNMailReturnOption
 // See: https://www.rfc-editor.org/rfc/rfc1891
-func WithDSNMailReturnType(mro DSNMailReturnOption) Option {
+func WithDSNMailReturnType(option DSNMailReturnOption) Option {
 	return func(c *Client) error {
-		switch mro {
+		switch option {
 		case DSNMailReturnHeadersOnly:
 		case DSNMailReturnFull:
 		default:
@@ -396,7 +396,7 @@ func WithDSNMailReturnType(mro DSNMailReturnOption) Option {
 		}
 
 		c.dsn = true
-		c.dsnmrtype = mro
+		c.dsnmrtype = option
 		return nil
 	}
 }
@@ -404,13 +404,13 @@ func WithDSNMailReturnType(mro DSNMailReturnOption) Option {
 // WithDSNRcptNotifyType enables the Client to request DSNs as described in the RFC 1891
 // and sets the RCPT TO notify options to the given list of DSNRcptNotifyOption
 // See: https://www.rfc-editor.org/rfc/rfc1891
-func WithDSNRcptNotifyType(rno ...DSNRcptNotifyOption) Option {
+func WithDSNRcptNotifyType(opts ...DSNRcptNotifyOption) Option {
 	return func(c *Client) error {
-		var rnol []string
+		var rcptOpts []string
 		var ns, nns bool
-		if len(rno) > 0 {
+		if len(opts) > 0 {
-			for _, crno := range rno {
+			for _, opt := range opts {
-				switch crno {
+				switch opt {
 				case DSNRcptNotifyNever:
 					ns = true
 				case DSNRcptNotifySuccess:
@@ -422,7 +422,7 @@ func WithDSNRcptNotifyType(rno ...DSNRcptNotifyOption) Option {
 				default:
 					return ErrInvalidDSNRcptNotifyOption
 				}
-				rnol = append(rnol, string(crno))
+				rcptOpts = append(rcptOpts, string(opt))
 			}
 		}
 		if ns && nns {
@@ -430,7 +430,7 @@ func WithDSNRcptNotifyType(rno ...DSNRcptNotifyOption) Option {
 		}
 
 		c.dsn = true
-		c.dsnrntype = rnol
+		c.dsnrntype = rcptOpts
 		return nil
 	}
 }
@@ -445,9 +445,9 @@ func WithoutNoop() Option {
 }
 
 // WithDialContextFunc overrides the default DialContext for connecting SMTP server
-func WithDialContextFunc(f DialContextFunc) Option {
+func WithDialContextFunc(dialCtxFunc DialContextFunc) Option {
 	return func(c *Client) error {
-		c.dialContextFunc = f
+		c.dialContextFunc = dialCtxFunc
 		return nil
 	}
 }
@@ -463,8 +463,8 @@ func (c *Client) ServerAddr() string {
 }
 
 // SetTLSPolicy overrides the current TLSPolicy with the given TLSPolicy value
-func (c *Client) SetTLSPolicy(p TLSPolicy) {
+func (c *Client) SetTLSPolicy(policy TLSPolicy) {
-	c.tlspolicy = p
+	c.tlspolicy = policy
 }
 
 // SetTLSPortPolicy overrides the current TLSPolicy with the given TLSPolicy
@@ -474,22 +474,22 @@ func (c *Client) SetTLSPolicy(p TLSPolicy) {
 // If the connection fails with TLSOpportunistic, a plaintext connection is
 // attempted on port 25 as a fallback.
 // NoTLS will allways use port 25.
-func (c *Client) SetTLSPortPolicy(p TLSPolicy) {
+func (c *Client) SetTLSPortPolicy(policy TLSPolicy) {
 	c.port = DefaultPortTLS
 
-	if p == TLSOpportunistic {
+	if policy == TLSOpportunistic {
 		c.fallbackPort = DefaultPort
 	}
-	if p == NoTLS {
+	if policy == NoTLS {
 		c.port = DefaultPort
 	}
 
-	c.tlspolicy = p
+	c.tlspolicy = policy
 }
 
 // SetSSL tells the Client wether to use SSL or not
-func (c *Client) SetSSL(s bool) {
+func (c *Client) SetSSL(ssl bool) {
-	c.ssl = s
+	c.useSSL = ssl
 }
 
 // SetSSLPort tells the Client wether or not to use SSL and fallback.
@@ -499,124 +499,124 @@ func (c *Client) SetSSL(s bool) {
 // Port 25 is used when SSL is unset (false).
 // When the SSL connection fails and fb is set to true,
 // the client will attempt to connect on port 25 using plaintext.
-func (c *Client) SetSSLPort(ssl bool, fb bool) {
+func (c *Client) SetSSLPort(ssl bool, fallback bool) {
 	c.port = DefaultPort
 	if ssl {
 		c.port = DefaultPortSSL
 	}
 
 	c.fallbackPort = 0
-	if fb {
+	if fallback {
 		c.fallbackPort = DefaultPort
 	}
 
-	c.ssl = ssl
+	c.useSSL = ssl
 }
 
 // SetDebugLog tells the Client whether debug logging is enabled or not
-func (c *Client) SetDebugLog(v bool) {
+func (c *Client) SetDebugLog(val bool) {
-	c.dl = v
+	c.useDebugLog = val
-	if c.sc != nil {
+	if c.smtpClient != nil {
-		c.sc.SetDebugLog(v)
+		c.smtpClient.SetDebugLog(val)
 	}
 }
 
 // SetLogger tells the Client which log.Logger to use
-func (c *Client) SetLogger(l log.Logger) {
+func (c *Client) SetLogger(logger log.Logger) {
-	c.l = l
+	c.logger = logger
-	if c.sc != nil {
+	if c.smtpClient != nil {
-		c.sc.SetLogger(l)
+		c.smtpClient.SetLogger(logger)
 	}
 }
 
 // SetTLSConfig overrides the current *tls.Config with the given *tls.Config value
-func (c *Client) SetTLSConfig(co *tls.Config) error {
+func (c *Client) SetTLSConfig(tlsconfig *tls.Config) error {
-	if co == nil {
+	if tlsconfig == nil {
 		return ErrInvalidTLSConfig
 	}
-	c.tlsconfig = co
+	c.tlsconfig = tlsconfig
 	return nil
 }
 
 // SetUsername overrides the current username string with the given value
-func (c *Client) SetUsername(u string) {
+func (c *Client) SetUsername(username string) {
-	c.user = u
+	c.user = username
 }
 
 // SetPassword overrides the current password string with the given value
-func (c *Client) SetPassword(p string) {
+func (c *Client) SetPassword(password string) {
-	c.pass = p
+	c.pass = password
 }
 
 // SetSMTPAuth overrides the current SMTP AUTH type setting with the given value
-func (c *Client) SetSMTPAuth(a SMTPAuthType) {
+func (c *Client) SetSMTPAuth(authtype SMTPAuthType) {
-	c.satype = a
+	c.smtpAuthType = authtype
 }
 
 // SetSMTPAuthCustom overrides the current SMTP AUTH setting with the given custom smtp.Auth
-func (c *Client) SetSMTPAuthCustom(sa smtp.Auth) {
+func (c *Client) SetSMTPAuthCustom(smtpAuth smtp.Auth) {
-	c.sa = sa
+	c.smtpAuth = smtpAuth
 }
 
 // setDefaultHelo retrieves the current hostname and sets it as HELO/EHLO hostname
 func (c *Client) setDefaultHelo() error {
-	hn, err := os.Hostname()
+	hostname, err := os.Hostname()
 	if err != nil {
-		return fmt.Errorf("failed cto read local hostname: %w", err)
+		return fmt.Errorf("failed to read local hostname: %w", err)
 	}
-	c.helo = hn
+	c.helo = hostname
 	return nil
 }
 
-// DialWithContext establishes a connection cto the SMTP server with a given context.Context
+// DialWithContext establishes a connection to the SMTP server with a given context.Context
-func (c *Client) DialWithContext(pc context.Context) error {
+func (c *Client) DialWithContext(dialCtx context.Context) error {
-	ctx, cfn := context.WithDeadline(pc, time.Now().Add(c.cto))
+	ctx, cancel := context.WithDeadline(dialCtx, time.Now().Add(c.connTimeout))
-	defer cfn()
+	defer cancel()
 
 	if c.dialContextFunc == nil {
-		nd := net.Dialer{}
+		netDialer := net.Dialer{}
-		c.dialContextFunc = nd.DialContext
+		c.dialContextFunc = netDialer.DialContext
 
-		if c.ssl {
+		if c.useSSL {
-			td := tls.Dialer{NetDialer: &nd, Config: c.tlsconfig}
+			tlsDialer := tls.Dialer{NetDialer: &netDialer, Config: c.tlsconfig}
-			c.enc = true
+			c.isEncrypted = true
-			c.dialContextFunc = td.DialContext
+			c.dialContextFunc = tlsDialer.DialContext
 		}
 	}
 	var err error
-	c.co, err = c.dialContextFunc(ctx, "tcp", c.ServerAddr())
+	c.connection, err = c.dialContextFunc(ctx, "tcp", c.ServerAddr())
 	if err != nil && c.fallbackPort != 0 {
 		// TODO: should we somehow log or append the previous error?
-		c.co, err = c.dialContextFunc(ctx, "tcp", c.serverFallbackAddr())
+		c.connection, err = c.dialContextFunc(ctx, "tcp", c.serverFallbackAddr())
 	}
 	if err != nil {
 		return err
 	}
 
-	sc, err := smtp.NewClient(c.co, c.host)
+	client, err := smtp.NewClient(c.connection, c.host)
 	if err != nil {
 		return err
 	}
-	if sc == nil {
+	if client == nil {
 		return fmt.Errorf("SMTP client is nil")
 	}
-	c.sc = sc
+	c.smtpClient = client
 
-	if c.l != nil {
+	if c.logger != nil {
-		c.sc.SetLogger(c.l)
+		c.smtpClient.SetLogger(c.logger)
 	}
-	if c.dl {
+	if c.useDebugLog {
-		c.sc.SetDebugLog(true)
+		c.smtpClient.SetDebugLog(true)
 	}
-	if err := c.sc.Hello(c.helo); err != nil {
+	if err = c.smtpClient.Hello(c.helo); err != nil {
 		return err
 	}
 
-	if err := c.tls(); err != nil {
+	if err = c.tls(); err != nil {
 		return err
 	}
 
-	if err := c.auth(); err != nil {
+	if err = c.auth(); err != nil {
 		return err
 	}
 
@@ -628,7 +628,7 @@ func (c *Client) Close() error {
 	if err := c.checkConn(); err != nil {
 		return err
 	}
-	if err := c.sc.Quit(); err != nil {
+	if err := c.smtpClient.Quit(); err != nil {
 		return fmt.Errorf("failed to close SMTP client: %w", err)
 	}
 
@@ -640,7 +640,7 @@ func (c *Client) Reset() error {
 	if err := c.checkConn(); err != nil {
 		return err
 	}
-	if err := c.sc.Reset(); err != nil {
+	if err := c.smtpClient.Reset(); err != nil {
 		return fmt.Errorf("failed to send RSET to SMTP client: %w", err)
 	}
 
@@ -649,18 +649,18 @@ func (c *Client) Reset() error {
 
 // DialAndSend establishes a connection to the SMTP server with a
 // default context.Background and sends the mail
-func (c *Client) DialAndSend(ml ...*Msg) error {
+func (c *Client) DialAndSend(messages ...*Msg) error {
 	ctx := context.Background()
-	return c.DialAndSendWithContext(ctx, ml...)
+	return c.DialAndSendWithContext(ctx, messages...)
 }
 
 // DialAndSendWithContext establishes a connection to the SMTP server with a
 // custom context and sends the mail
-func (c *Client) DialAndSendWithContext(ctx context.Context, ml ...*Msg) error {
+func (c *Client) DialAndSendWithContext(ctx context.Context, messages ...*Msg) error {
 	if err := c.DialWithContext(ctx); err != nil {
 		return fmt.Errorf("dial failed: %w", err)
 	}
-	if err := c.Send(ml...); err != nil {
+	if err := c.Send(messages...); err != nil {
 		return fmt.Errorf("send failed: %w", err)
 	}
 	if err := c.Close(); err != nil {
@@ -672,17 +672,17 @@ func (c *Client) DialAndSendWithContext(ctx context.Context, ml ...*Msg) error {
 // checkConn makes sure that a required server connection is available and extends the
 // connection deadline
 func (c *Client) checkConn() error {
-	if c.co == nil {
+	if c.connection == nil {
 		return ErrNoActiveConnection
 	}
 
 	if !c.noNoop {
-		if err := c.sc.Noop(); err != nil {
+		if err := c.smtpClient.Noop(); err != nil {
 			return ErrNoActiveConnection
 		}
 	}
 
-	if err := c.co.SetDeadline(time.Now().Add(c.cto)); err != nil {
+	if err := c.connection.SetDeadline(time.Now().Add(c.connTimeout)); err != nil {
 		return ErrDeadlineExtendFailed
 	}
 	return nil
@@ -696,30 +696,30 @@ func (c *Client) serverFallbackAddr() string {
 
 // tls tries to make sure that the STARTTLS requirements are satisfied
 func (c *Client) tls() error {
-	if c.co == nil {
+	if c.connection == nil {
 		return ErrNoActiveConnection
 	}
-	if !c.ssl && c.tlspolicy != NoTLS {
+	if !c.useSSL && c.tlspolicy != NoTLS {
-		est := false
+		hasStartTLS := false
-		st, _ := c.sc.Extension("STARTTLS")
+		extension, _ := c.smtpClient.Extension("STARTTLS")
 		if c.tlspolicy == TLSMandatory {
-			est = true
+			hasStartTLS = true
-			if !st {
+			if !extension {
 				return fmt.Errorf("STARTTLS mode set to: %q, but target host does not support STARTTLS",
 					c.tlspolicy)
 			}
 		}
 		if c.tlspolicy == TLSOpportunistic {
-			if st {
+			if extension {
-				est = true
+				hasStartTLS = true
 			}
 		}
-		if est {
+		if hasStartTLS {
-			if err := c.sc.StartTLS(c.tlsconfig); err != nil {
+			if err := c.smtpClient.StartTLS(c.tlsconfig); err != nil {
 				return err
 			}
 		}
-		_, c.enc = c.sc.TLSConnectionState()
+		_, c.isEncrypted = c.smtpClient.TLSConnectionState()
 	}
 	return nil
 }
@@ -729,40 +729,40 @@ func (c *Client) auth() error {
 	if err := c.checkConn(); err != nil {
 		return fmt.Errorf("failed to authenticate: %w", err)
 	}
-	if c.sa == nil && c.satype != "" {
+	if c.smtpAuth == nil && c.smtpAuthType != "" {
-		sa, sat := c.sc.Extension("AUTH")
+		hasSMTPAuth, smtpAuthType := c.smtpClient.Extension("AUTH")
-		if !sa {
+		if !hasSMTPAuth {
 			return fmt.Errorf("server does not support SMTP AUTH")
 		}
 
-		switch c.satype {
+		switch c.smtpAuthType {
 		case SMTPAuthPlain:
-			if !strings.Contains(sat, string(SMTPAuthPlain)) {
+			if !strings.Contains(smtpAuthType, string(SMTPAuthPlain)) {
 				return ErrPlainAuthNotSupported
 			}
-			c.sa = smtp.PlainAuth("", c.user, c.pass, c.host)
+			c.smtpAuth = smtp.PlainAuth("", c.user, c.pass, c.host)
 		case SMTPAuthLogin:
-			if !strings.Contains(sat, string(SMTPAuthLogin)) {
+			if !strings.Contains(smtpAuthType, string(SMTPAuthLogin)) {
 				return ErrLoginAuthNotSupported
 			}
-			c.sa = smtp.LoginAuth(c.user, c.pass, c.host)
+			c.smtpAuth = smtp.LoginAuth(c.user, c.pass, c.host)
 		case SMTPAuthCramMD5:
-			if !strings.Contains(sat, string(SMTPAuthCramMD5)) {
+			if !strings.Contains(smtpAuthType, string(SMTPAuthCramMD5)) {
 				return ErrCramMD5AuthNotSupported
 			}
-			c.sa = smtp.CRAMMD5Auth(c.user, c.pass)
+			c.smtpAuth = smtp.CRAMMD5Auth(c.user, c.pass)
 		case SMTPAuthXOAUTH2:
-			if !strings.Contains(sat, string(SMTPAuthXOAUTH2)) {
+			if !strings.Contains(smtpAuthType, string(SMTPAuthXOAUTH2)) {
 				return ErrXOauth2AuthNotSupported
 			}
-			c.sa = smtp.XOAuth2Auth(c.user, c.pass)
+			c.smtpAuth = smtp.XOAuth2Auth(c.user, c.pass)
 		default:
-			return fmt.Errorf("unsupported SMTP AUTH type %q", c.satype)
+			return fmt.Errorf("unsupported SMTP AUTH type %q", c.smtpAuthType)
 		}
 	}
 
-	if c.sa != nil {
+	if c.smtpAuth != nil {
-		if err := c.sc.Auth(c.sa); err != nil {
+		if err := c.smtpClient.Auth(c.smtpAuth); err != nil {
 			return fmt.Errorf("SMTP AUTH failed: %w", err)
 		}
 	}

client_119.go

@@ -10,123 +10,123 @@ package mail
 import "strings"
 
 // Send sends out the mail message
-func (c *Client) Send(ml ...*Msg) error {
+func (c *Client) Send(messages ...*Msg) error {
 	if cerr := c.checkConn(); cerr != nil {
 		return &SendError{Reason: ErrConnCheck, errlist: []error{cerr}, isTemp: isTempError(cerr)}
 	}
 	var errs []*SendError
-	for _, m := range ml {
+	for _, message := range messages {
-		m.sendError = nil
+		message.sendError = nil
-		if m.encoding == NoEncoding {
+		if message.encoding == NoEncoding {
-			if ok, _ := c.sc.Extension("8BITMIME"); !ok {
+			if ok, _ := c.smtpClient.Extension("8BITMIME"); !ok {
-				se := &SendError{Reason: ErrNoUnencoded, isTemp: false}
+				sendErr := &SendError{Reason: ErrNoUnencoded, isTemp: false}
-				m.sendError = se
+				message.sendError = sendErr
-				errs = append(errs, se)
+				errs = append(errs, sendErr)
 				continue
 			}
 		}
-		f, err := m.GetSender(false)
+		from, err := message.GetSender(false)
 		if err != nil {
-			se := &SendError{Reason: ErrGetSender, errlist: []error{err}, isTemp: isTempError(err)}
+			sendErr := &SendError{Reason: ErrGetSender, errlist: []error{err}, isTemp: isTempError(err)}
-			m.sendError = se
+			message.sendError = sendErr
-			errs = append(errs, se)
+			errs = append(errs, sendErr)
 			continue
 		}
-		rl, err := m.GetRecipients()
+		rcpts, err := message.GetRecipients()
 		if err != nil {
-			se := &SendError{Reason: ErrGetRcpts, errlist: []error{err}, isTemp: isTempError(err)}
+			sendErr := &SendError{Reason: ErrGetRcpts, errlist: []error{err}, isTemp: isTempError(err)}
-			m.sendError = se
+			message.sendError = sendErr
-			errs = append(errs, se)
+			errs = append(errs, sendErr)
 			continue
 		}
 
 		if c.dsn {
 			if c.dsnmrtype != "" {
-				c.sc.SetDSNMailReturnOption(string(c.dsnmrtype))
+				c.smtpClient.SetDSNMailReturnOption(string(c.dsnmrtype))
 			}
 		}
-		if err := c.sc.Mail(f); err != nil {
+		if err = c.smtpClient.Mail(from); err != nil {
-			se := &SendError{Reason: ErrSMTPMailFrom, errlist: []error{err}, isTemp: isTempError(err)}
+			sendErr := &SendError{Reason: ErrSMTPMailFrom, errlist: []error{err}, isTemp: isTempError(err)}
-			if reserr := c.sc.Reset(); reserr != nil {
+			if resetSendErr := c.smtpClient.Reset(); resetSendErr != nil {
-				se.errlist = append(se.errlist, reserr)
+				sendErr.errlist = append(sendErr.errlist, resetSendErr)
 			}
-			m.sendError = se
+			message.sendError = sendErr
-			errs = append(errs, se)
+			errs = append(errs, sendErr)
 			continue
 		}
 		failed := false
-		rse := &SendError{}
+		rcptSendErr := &SendError{}
-		rse.errlist = make([]error, 0)
+		rcptSendErr.errlist = make([]error, 0)
-		rse.rcpt = make([]string, 0)
+		rcptSendErr.rcpt = make([]string, 0)
-		rno := strings.Join(c.dsnrntype, ",")
+		rcptNotifyOpt := strings.Join(c.dsnrntype, ",")
-		c.sc.SetDSNRcptNotifyOption(rno)
+		c.smtpClient.SetDSNRcptNotifyOption(rcptNotifyOpt)
-		for _, r := range rl {
+		for _, rcpt := range rcpts {
-			if err := c.sc.Rcpt(r); err != nil {
+			if err = c.smtpClient.Rcpt(rcpt); err != nil {
-				rse.Reason = ErrSMTPRcptTo
+				rcptSendErr.Reason = ErrSMTPRcptTo
-				rse.errlist = append(rse.errlist, err)
+				rcptSendErr.errlist = append(rcptSendErr.errlist, err)
-				rse.rcpt = append(rse.rcpt, r)
+				rcptSendErr.rcpt = append(rcptSendErr.rcpt, rcpt)
-				rse.isTemp = isTempError(err)
+				rcptSendErr.isTemp = isTempError(err)
 				failed = true
 			}
 		}
 		if failed {
-			if reserr := c.sc.Reset(); reserr != nil {
+			if resetSendErr := c.smtpClient.Reset(); resetSendErr != nil {
-				rse.errlist = append(rse.errlist, err)
+				rcptSendErr.errlist = append(rcptSendErr.errlist, err)
 			}
-			m.sendError = rse
+			message.sendError = rcptSendErr
-			errs = append(errs, rse)
+			errs = append(errs, rcptSendErr)
 			continue
 		}
-		w, err := c.sc.Data()
+		writer, err := c.smtpClient.Data()
 		if err != nil {
-			se := &SendError{Reason: ErrSMTPData, errlist: []error{err}, isTemp: isTempError(err)}
+			sendErr := &SendError{Reason: ErrSMTPData, errlist: []error{err}, isTemp: isTempError(err)}
-			m.sendError = se
+			message.sendError = sendErr
-			errs = append(errs, se)
+			errs = append(errs, sendErr)
 			continue
 		}
-		_, err = m.WriteTo(w)
+		_, err = message.WriteTo(writer)
 		if err != nil {
-			se := &SendError{Reason: ErrWriteContent, errlist: []error{err}, isTemp: isTempError(err)}
+			sendErr := &SendError{Reason: ErrWriteContent, errlist: []error{err}, isTemp: isTempError(err)}
-			m.sendError = se
+			message.sendError = sendErr
-			errs = append(errs, se)
+			errs = append(errs, sendErr)
 			continue
 		}
-		m.isDelivered = true
+		message.isDelivered = true
 
-		if err := w.Close(); err != nil {
+		if err = writer.Close(); err != nil {
-			se := &SendError{Reason: ErrSMTPDataClose, errlist: []error{err}, isTemp: isTempError(err)}
+			sendErr := &SendError{Reason: ErrSMTPDataClose, errlist: []error{err}, isTemp: isTempError(err)}
-			m.sendError = se
+			message.sendError = sendErr
-			errs = append(errs, se)
+			errs = append(errs, sendErr)
 			continue
 		}
 
-		if err := c.Reset(); err != nil {
+		if err = c.Reset(); err != nil {
-			se := &SendError{Reason: ErrSMTPReset, errlist: []error{err}, isTemp: isTempError(err)}
+			sendErr := &SendError{Reason: ErrSMTPReset, errlist: []error{err}, isTemp: isTempError(err)}
-			m.sendError = se
+			message.sendError = sendErr
-			errs = append(errs, se)
+			errs = append(errs, sendErr)
 			continue
 		}
-		if err := c.checkConn(); err != nil {
+		if err = c.checkConn(); err != nil {
-			se := &SendError{Reason: ErrConnCheck, errlist: []error{err}, isTemp: isTempError(err)}
+			sendErr := &SendError{Reason: ErrConnCheck, errlist: []error{err}, isTemp: isTempError(err)}
-			m.sendError = se
+			message.sendError = sendErr
-			errs = append(errs, se)
+			errs = append(errs, sendErr)
 			continue
 		}
 	}
 
 	if len(errs) > 0 {
 		if len(errs) > 1 {
-			re := &SendError{Reason: ErrAmbiguous}
+			returnErr := &SendError{Reason: ErrAmbiguous}
 			for i := range errs {
-				re.errlist = append(re.errlist, errs[i].errlist...)
+				returnErr.errlist = append(returnErr.errlist, errs[i].errlist...)
-				re.rcpt = append(re.rcpt, errs[i].rcpt...)
+				returnErr.rcpt = append(returnErr.rcpt, errs[i].rcpt...)
 			}
 
 			// We assume that the isTemp flag from the last error we received should be the
 			// indicator for the returned isTemp flag as well
-			re.isTemp = errs[len(errs)-1].isTemp
+			returnErr.isTemp = errs[len(errs)-1].isTemp
 
-			return re
+			return returnErr
 		}
 		return errs[0]
 	}

client_120.go

@@ -13,97 +13,97 @@ import (
 )
 
 // Send sends out the mail message
-func (c *Client) Send(ml ...*Msg) (rerr error) {
+func (c *Client) Send(messages ...*Msg) (returnErr error) {
 	if err := c.checkConn(); err != nil {
-		rerr = &SendError{Reason: ErrConnCheck, errlist: []error{err}, isTemp: isTempError(err)}
+		returnErr = &SendError{Reason: ErrConnCheck, errlist: []error{err}, isTemp: isTempError(err)}
 		return
 	}
-	for _, m := range ml {
+	for _, message := range messages {
-		m.sendError = nil
+		message.sendError = nil
-		if m.encoding == NoEncoding {
+		if message.encoding == NoEncoding {
-			if ok, _ := c.sc.Extension("8BITMIME"); !ok {
+			if ok, _ := c.smtpClient.Extension("8BITMIME"); !ok {
-				m.sendError = &SendError{Reason: ErrNoUnencoded, isTemp: false}
+				message.sendError = &SendError{Reason: ErrNoUnencoded, isTemp: false}
-				rerr = errors.Join(rerr, m.sendError)
+				returnErr = errors.Join(returnErr, message.sendError)
 				continue
 			}
 		}
-		f, err := m.GetSender(false)
+		from, err := message.GetSender(false)
 		if err != nil {
-			m.sendError = &SendError{Reason: ErrGetSender, errlist: []error{err}, isTemp: isTempError(err)}
+			message.sendError = &SendError{Reason: ErrGetSender, errlist: []error{err}, isTemp: isTempError(err)}
-			rerr = errors.Join(rerr, m.sendError)
+			returnErr = errors.Join(returnErr, message.sendError)
 			continue
 		}
-		rl, err := m.GetRecipients()
+		rcpts, err := message.GetRecipients()
 		if err != nil {
-			m.sendError = &SendError{Reason: ErrGetRcpts, errlist: []error{err}, isTemp: isTempError(err)}
+			message.sendError = &SendError{Reason: ErrGetRcpts, errlist: []error{err}, isTemp: isTempError(err)}
-			rerr = errors.Join(rerr, m.sendError)
+			returnErr = errors.Join(returnErr, message.sendError)
 			continue
 		}
 
 		if c.dsn {
 			if c.dsnmrtype != "" {
-				c.sc.SetDSNMailReturnOption(string(c.dsnmrtype))
+				c.smtpClient.SetDSNMailReturnOption(string(c.dsnmrtype))
 			}
 		}
-		if err := c.sc.Mail(f); err != nil {
+		if err = c.smtpClient.Mail(from); err != nil {
-			m.sendError = &SendError{Reason: ErrSMTPMailFrom, errlist: []error{err}, isTemp: isTempError(err)}
+			message.sendError = &SendError{Reason: ErrSMTPMailFrom, errlist: []error{err}, isTemp: isTempError(err)}
-			rerr = errors.Join(rerr, m.sendError)
+			returnErr = errors.Join(returnErr, message.sendError)
-			if reserr := c.sc.Reset(); reserr != nil {
+			if resetSendErr := c.smtpClient.Reset(); resetSendErr != nil {
-				rerr = errors.Join(rerr, reserr)
+				returnErr = errors.Join(returnErr, resetSendErr)
 			}
 			continue
 		}
 		failed := false
-		rse := &SendError{}
+		rcptSendErr := &SendError{}
-		rse.errlist = make([]error, 0)
+		rcptSendErr.errlist = make([]error, 0)
-		rse.rcpt = make([]string, 0)
+		rcptSendErr.rcpt = make([]string, 0)
-		rno := strings.Join(c.dsnrntype, ",")
+		rcptNotifyOpt := strings.Join(c.dsnrntype, ",")
-		c.sc.SetDSNRcptNotifyOption(rno)
+		c.smtpClient.SetDSNRcptNotifyOption(rcptNotifyOpt)
-		for _, r := range rl {
+		for _, rcpt := range rcpts {
-			if err := c.sc.Rcpt(r); err != nil {
+			if err = c.smtpClient.Rcpt(rcpt); err != nil {
-				rse.Reason = ErrSMTPRcptTo
+				rcptSendErr.Reason = ErrSMTPRcptTo
-				rse.errlist = append(rse.errlist, err)
+				rcptSendErr.errlist = append(rcptSendErr.errlist, err)
-				rse.rcpt = append(rse.rcpt, r)
+				rcptSendErr.rcpt = append(rcptSendErr.rcpt, rcpt)
-				rse.isTemp = isTempError(err)
+				rcptSendErr.isTemp = isTempError(err)
 				failed = true
 			}
 		}
 		if failed {
-			if reserr := c.sc.Reset(); reserr != nil {
+			if resetSendErr := c.smtpClient.Reset(); resetSendErr != nil {
-				rerr = errors.Join(rerr, reserr)
+				returnErr = errors.Join(returnErr, resetSendErr)
 			}
-			m.sendError = rse
+			message.sendError = rcptSendErr
-			rerr = errors.Join(rerr, m.sendError)
+			returnErr = errors.Join(returnErr, message.sendError)
 			continue
 		}
-		w, err := c.sc.Data()
+		writer, err := c.smtpClient.Data()
 		if err != nil {
-			m.sendError = &SendError{Reason: ErrSMTPData, errlist: []error{err}, isTemp: isTempError(err)}
+			message.sendError = &SendError{Reason: ErrSMTPData, errlist: []error{err}, isTemp: isTempError(err)}
-			rerr = errors.Join(rerr, m.sendError)
+			returnErr = errors.Join(returnErr, message.sendError)
 			continue
 		}
-		_, err = m.WriteTo(w)
+		_, err = message.WriteTo(writer)
 		if err != nil {
-			m.sendError = &SendError{Reason: ErrWriteContent, errlist: []error{err}, isTemp: isTempError(err)}
+			message.sendError = &SendError{Reason: ErrWriteContent, errlist: []error{err}, isTemp: isTempError(err)}
-			rerr = errors.Join(rerr, m.sendError)
+			returnErr = errors.Join(returnErr, message.sendError)
 			continue
 		}
-		m.isDelivered = true
+		message.isDelivered = true
 
-		if err := w.Close(); err != nil {
+		if err = writer.Close(); err != nil {
-			m.sendError = &SendError{Reason: ErrSMTPDataClose, errlist: []error{err}, isTemp: isTempError(err)}
+			message.sendError = &SendError{Reason: ErrSMTPDataClose, errlist: []error{err}, isTemp: isTempError(err)}
-			rerr = errors.Join(rerr, m.sendError)
+			returnErr = errors.Join(returnErr, message.sendError)
 			continue
 		}
 
-		if err := c.Reset(); err != nil {
+		if err = c.Reset(); err != nil {
-			m.sendError = &SendError{Reason: ErrSMTPReset, errlist: []error{err}, isTemp: isTempError(err)}
+			message.sendError = &SendError{Reason: ErrSMTPReset, errlist: []error{err}, isTemp: isTempError(err)}
-			rerr = errors.Join(rerr, m.sendError)
+			returnErr = errors.Join(returnErr, message.sendError)
 			continue
 		}
-		if err := c.checkConn(); err != nil {
+		if err = c.checkConn(); err != nil {
-			m.sendError = &SendError{Reason: ErrConnCheck, errlist: []error{err}, isTemp: isTempError(err)}
+			message.sendError = &SendError{Reason: ErrConnCheck, errlist: []error{err}, isTemp: isTempError(err)}
-			rerr = errors.Join(rerr, m.sendError)
+			returnErr = errors.Join(returnErr, message.sendError)
 		}
 	}
 

client_test.go

@@ -49,9 +49,9 @@ func TestNewClient(t *testing.T) {
 			if c.host != tt.host {
 				t.Errorf("failed to create new client. Host expected: %s, got: %s", host, c.host)
 			}
-			if c.cto != DefaultTimeout {
+			if c.connTimeout != DefaultTimeout {
 				t.Errorf("failed to create new client. Timeout expected: %s, got: %s", DefaultTimeout.String(),
-					c.cto.String())
+					c.connTimeout.String())
 			}
 			if c.port != DefaultPort {
 				t.Errorf("failed to create new client. Port expected: %d, got: %d", DefaultPort, c.port)
@@ -205,8 +205,8 @@ func TestWithTimeout(t *testing.T) {
 				t.Errorf("failed to create new client: %s", err)
 				return
 			}
-			if c.cto != tt.want {
+			if c.connTimeout != tt.want {
-				t.Errorf("failed to set custom timeout. Want: %d, got: %d", tt.want, c.cto)
+				t.Errorf("failed to set custom timeout. Want: %d, got: %d", tt.want, c.connTimeout)
 			}
 		})
 	}
@@ -345,8 +345,8 @@ func TestSetSSL(t *testing.T) {
 				return
 			}
 			c.SetSSL(tt.value)
-			if c.ssl != tt.value {
+			if c.useSSL != tt.value {
-				t.Errorf("failed to set SSL setting. Got: %t, want: %t", c.ssl, tt.value)
+				t.Errorf("failed to set SSL setting. Got: %t, want: %t", c.useSSL, tt.value)
 			}
 		})
 	}
@@ -374,8 +374,8 @@ func TestClient_SetSSLPort(t *testing.T) {
 				return
 			}
 			c.SetSSLPort(tt.value, tt.fb)
-			if c.ssl != tt.value {
+			if c.useSSL != tt.value {
-				t.Errorf("failed to set SSL setting. Got: %t, want: %t", c.ssl, tt.value)
+				t.Errorf("failed to set SSL setting. Got: %t, want: %t", c.useSSL, tt.value)
 			}
 			if c.port != tt.port {
 				t.Errorf("failed to set SSLPort, wanted port: %d, got: %d", c.port, tt.port)
@@ -460,8 +460,8 @@ func TestSetSMTPAuth(t *testing.T) {
 				return
 			}
 			c.SetSMTPAuth(tt.value)
-			if string(c.satype) != tt.want {
+			if string(c.smtpAuthType) != tt.want {
-				t.Errorf("failed to set SMTP auth type. Expected %s, got: %s", tt.want, string(c.satype))
+				t.Errorf("failed to set SMTP auth type. Expected %s, got: %s", tt.want, string(c.smtpAuthType))
 			}
 		})
 	}
@@ -590,10 +590,10 @@ func TestSetSMTPAuthCustom(t *testing.T) {
 				return
 			}
 			c.SetSMTPAuthCustom(tt.value)
-			if c.sa == nil {
+			if c.smtpAuth == nil {
 				t.Errorf("failed to set custom SMTP auth method. SMTP Auth method is empty")
 			}
-			p, _, err := c.sa.Start(&si)
+			p, _, err := c.smtpAuth.Start(&si)
 			if err != nil {
 				t.Errorf("SMTP Auth Start() method returned error: %s", err)
 			}
@@ -615,10 +615,10 @@ func TestClient_DialWithContext(t *testing.T) {
 		t.Errorf("failed to dial with context: %s", err)
 		return
 	}
-	if c.co == nil {
+	if c.connection == nil {
 		t.Errorf("DialWithContext didn't fail but no connection found.")
 	}
-	if c.sc == nil {
+	if c.smtpClient == nil {
 		t.Errorf("DialWithContext didn't fail but no SMTP client found.")
 	}
 	if err := c.Close(); err != nil {
@@ -640,10 +640,10 @@ func TestClient_DialWithContext_Fallback(t *testing.T) {
 		t.Errorf("failed to dial with context: %s", err)
 		return
 	}
-	if c.co == nil {
+	if c.connection == nil {
 		t.Errorf("DialWithContext didn't fail but no connection found.")
 	}
-	if c.sc == nil {
+	if c.smtpClient == nil {
 		t.Errorf("DialWithContext didn't fail but no SMTP client found.")
 	}
 	if err := c.Close(); err != nil {
@@ -670,10 +670,10 @@ func TestClient_DialWithContext_Debug(t *testing.T) {
 		t.Errorf("failed to dial with context: %s", err)
 		return
 	}
-	if c.co == nil {
+	if c.connection == nil {
 		t.Errorf("DialWithContext didn't fail but no connection found.")
 	}
-	if c.sc == nil {
+	if c.smtpClient == nil {
 		t.Errorf("DialWithContext didn't fail but no SMTP client found.")
 	}
 	c.SetDebugLog(true)
@@ -694,10 +694,10 @@ func TestClient_DialWithContext_Debug_custom(t *testing.T) {
 		t.Errorf("failed to dial with context: %s", err)
 		return
 	}
-	if c.co == nil {
+	if c.connection == nil {
 		t.Errorf("DialWithContext didn't fail but no connection found.")
 	}
-	if c.sc == nil {
+	if c.smtpClient == nil {
 		t.Errorf("DialWithContext didn't fail but no SMTP client found.")
 	}
 	c.SetDebugLog(true)
@@ -714,7 +714,7 @@ func TestClient_DialWithContextInvalidHost(t *testing.T) {
 	if err != nil {
 		t.Skipf("failed to create test client: %s. Skipping tests", err)
 	}
-	c.co = nil
+	c.connection = nil
 	c.host = "invalid.addr"
 	ctx := context.Background()
 	if err := c.DialWithContext(ctx); err == nil {
@@ -730,7 +730,7 @@ func TestClient_DialWithContextInvalidHELO(t *testing.T) {
 	if err != nil {
 		t.Skipf("failed to create test client: %s. Skipping tests", err)
 	}
-	c.co = nil
+	c.connection = nil
 	c.helo = ""
 	ctx := context.Background()
 	if err := c.DialWithContext(ctx); err == nil {
@@ -762,7 +762,7 @@ func TestClient_checkConn(t *testing.T) {
 	if err != nil {
 		t.Skipf("failed to create test client: %s. Skipping tests", err)
 	}
-	c.co = nil
+	c.connection = nil
 	if err := c.checkConn(); err == nil {
 		t.Errorf("connCheck() should fail but succeeded")
 	}
@@ -799,10 +799,10 @@ func TestClient_DialWithContextOptions(t *testing.T) {
 				return
 			}
 			if !tt.sf {
-				if c.co == nil && !tt.sf {
+				if c.connection == nil && !tt.sf {
 					t.Errorf("DialWithContext didn't fail but no connection found.")
 				}
-				if c.sc == nil && !tt.sf {
+				if c.smtpClient == nil && !tt.sf {
 					t.Errorf("DialWithContext didn't fail but no SMTP client found.")
 				}
 				if err := c.Reset(); err != nil {
@@ -1002,16 +1002,16 @@ func TestClient_DialSendCloseBroken(t *testing.T) {
 				return
 			}
 			if tt.closestart {
-				_ = c.sc.Close()
+				_ = c.smtpClient.Close()
-				_ = c.co.Close()
+				_ = c.connection.Close()
 			}
 			if err := c.Send(m); err != nil && !tt.sf {
 				t.Errorf("Send() failed: %s", err)
 				return
 			}
 			if tt.closeearly {
-				_ = c.sc.Close()
+				_ = c.smtpClient.Close()
-				_ = c.co.Close()
+				_ = c.connection.Close()
 			}
 			if err := c.Close(); err != nil && !tt.sf {
 				t.Errorf("Close() failed: %s", err)
@@ -1062,16 +1062,16 @@ func TestClient_DialSendCloseBrokenWithDSN(t *testing.T) {
 				return
 			}
 			if tt.closestart {
-				_ = c.sc.Close()
+				_ = c.smtpClient.Close()
-				_ = c.co.Close()
+				_ = c.connection.Close()
 			}
 			if err := c.Send(m); err != nil && !tt.sf {
 				t.Errorf("Send() failed: %s", err)
 				return
 			}
 			if tt.closeearly {
-				_ = c.sc.Close()
+				_ = c.smtpClient.Close()
-				_ = c.co.Close()
+				_ = c.connection.Close()
 			}
 			if err := c.Close(); err != nil && !tt.sf {
 				t.Errorf("Close() failed: %s", err)

file.go

@@ -23,17 +23,17 @@ type File struct {
 }
 
 // WithFileName sets the filename of the File
-func WithFileName(n string) FileOption {
+func WithFileName(name string) FileOption {
 	return func(f *File) {
-		f.Name = n
+		f.Name = name
 	}
 }
 
 // WithFileDescription sets an optional file description of the File that will be
 // added as Content-Description part
-func WithFileDescription(d string) FileOption {
+func WithFileDescription(description string) FileOption {
 	return func(f *File) {
-		f.Desc = d
+		f.Desc = description
 	}
 }
 
@@ -41,12 +41,12 @@ func WithFileDescription(d string) FileOption {
 // Base64 encoding but there might be exceptions, where this might come handy.
 // Please note that quoted-printable should never be used for attachments/embeds. If this
 // is provided as argument, the function will automatically override back to Base64
-func WithFileEncoding(e Encoding) FileOption {
+func WithFileEncoding(encoding Encoding) FileOption {
 	return func(f *File) {
-		if e == EncodingQP {
+		if encoding == EncodingQP {
 			return
 		}
-		f.Enc = e
+		f.Enc = encoding
 	}
 }
 
@@ -56,19 +56,19 @@ func WithFileEncoding(e Encoding) FileOption {
 // could not be guessed. In some cases, however, it might be needed to force
 // this to a specific type. For such situations this override method can
 // be used
-func WithFileContentType(t ContentType) FileOption {
+func WithFileContentType(contentType ContentType) FileOption {
 	return func(f *File) {
-		f.ContentType = t
+		f.ContentType = contentType
 	}
 }
 
 // setHeader sets header fields to a File
-func (f *File) setHeader(h Header, v string) {
+func (f *File) setHeader(header Header, value string) {
-	f.Header.Set(string(h), v)
+	f.Header.Set(string(header), value)
 }
 
 // getHeader return header fields of a File
-func (f *File) getHeader(h Header) (string, bool) {
+func (f *File) getHeader(header Header) (string, bool) {
-	v := f.Header.Get(string(h))
+	v := f.Header.Get(string(header))
 	return v, v != ""
 }

log/jsonlog.go

@@ -15,68 +15,68 @@ import (
 
 // JSONlog is the default structured JSON logger that satisfies the Logger interface
 type JSONlog struct {
-	l   Level
+	level Level
 	log   *slog.Logger
 }
 
 // NewJSON returns a new JSONlog type that satisfies the Logger interface
-func NewJSON(o io.Writer, l Level) *JSONlog {
+func NewJSON(output io.Writer, level Level) *JSONlog {
-	lo := slog.HandlerOptions{}
+	logOpts := slog.HandlerOptions{}
-	switch l {
+	switch level {
 	case LevelDebug:
-		lo.Level = slog.LevelDebug
+		logOpts.Level = slog.LevelDebug
 	case LevelInfo:
-		lo.Level = slog.LevelInfo
+		logOpts.Level = slog.LevelInfo
 	case LevelWarn:
-		lo.Level = slog.LevelWarn
+		logOpts.Level = slog.LevelWarn
 	case LevelError:
-		lo.Level = slog.LevelError
+		logOpts.Level = slog.LevelError
 	default:
-		lo.Level = slog.LevelDebug
+		logOpts.Level = slog.LevelDebug
 	}
-	lh := slog.NewJSONHandler(o, &lo)
+	logHandler := slog.NewJSONHandler(output, &logOpts)
 	return &JSONlog{
-		l:   l,
+		level: level,
-		log: slog.New(lh),
+		log:   slog.New(logHandler),
 	}
 }
 
 // Debugf logs a debug message via the structured JSON logger
-func (l *JSONlog) Debugf(lo Log) {
+func (l *JSONlog) Debugf(log Log) {
-	if l.l >= LevelDebug {
+	if l.level >= LevelDebug {
 		l.log.WithGroup(DirString).With(
-			slog.String(DirFromString, lo.directionFrom()),
+			slog.String(DirFromString, log.directionFrom()),
-			slog.String(DirToString, lo.directionTo()),
+			slog.String(DirToString, log.directionTo()),
-		).Debug(fmt.Sprintf(lo.Format, lo.Messages...))
+		).Debug(fmt.Sprintf(log.Format, log.Messages...))
 	}
 }
 
 // Infof logs a info message via the structured JSON logger
-func (l *JSONlog) Infof(lo Log) {
+func (l *JSONlog) Infof(log Log) {
-	if l.l >= LevelInfo {
+	if l.level >= LevelInfo {
 		l.log.WithGroup(DirString).With(
-			slog.String(DirFromString, lo.directionFrom()),
+			slog.String(DirFromString, log.directionFrom()),
-			slog.String(DirToString, lo.directionTo()),
+			slog.String(DirToString, log.directionTo()),
-		).Info(fmt.Sprintf(lo.Format, lo.Messages...))
+		).Info(fmt.Sprintf(log.Format, log.Messages...))
 	}
 }
 
 // Warnf logs a warn message via the structured JSON logger
-func (l *JSONlog) Warnf(lo Log) {
+func (l *JSONlog) Warnf(log Log) {
-	if l.l >= LevelWarn {
+	if l.level >= LevelWarn {
 		l.log.WithGroup(DirString).With(
-			slog.String(DirFromString, lo.directionFrom()),
+			slog.String(DirFromString, log.directionFrom()),
-			slog.String(DirToString, lo.directionTo()),
+			slog.String(DirToString, log.directionTo()),
-		).Warn(fmt.Sprintf(lo.Format, lo.Messages...))
+		).Warn(fmt.Sprintf(log.Format, log.Messages...))
 	}
 }
 
 // Errorf logs a warn message via the structured JSON logger
-func (l *JSONlog) Errorf(lo Log) {
+func (l *JSONlog) Errorf(log Log) {
-	if l.l >= LevelError {
+	if l.level >= LevelError {
 		l.log.WithGroup(DirString).With(
-			slog.String(DirFromString, lo.directionFrom()),
+			slog.String(DirFromString, log.directionFrom()),
-			slog.String(DirToString, lo.directionTo()),
+			slog.String(DirToString, log.directionTo()),
-		).Error(fmt.Sprintf(lo.Format, lo.Messages...))
+		).Error(fmt.Sprintf(log.Format, log.Messages...))
 	}
 }

log/jsonlog_test.go

@@ -30,8 +30,8 @@ type jsonDir struct {
 func TestNewJSON(t *testing.T) {
 	var b bytes.Buffer
 	l := NewJSON(&b, LevelDebug)
-	if l.l != LevelDebug {
+	if l.level != LevelDebug {
-		t.Error("Expected level to be LevelDebug, got ", l.l)
+		t.Error("Expected level to be LevelDebug, got ", l.level)
 	}
 	if l.log == nil {
 		t.Error("logger not initialized")
@@ -81,7 +81,7 @@ func TestJSONDebugf(t *testing.T) {
 	}
 
 	b.Reset()
-	l.l = LevelInfo
+	l.level = LevelInfo
 	l.Debugf(Log{Direction: DirServerToClient, Format: "test %s", Messages: []interface{}{"foo"}})
 	if b.String() != "" {
 		t.Error("Debug message was not expected to be logged")
@@ -131,7 +131,7 @@ func TestJSONDebugf_WithDefault(t *testing.T) {
 	}
 
 	b.Reset()
-	l.l = LevelInfo
+	l.level = LevelInfo
 	l.Debugf(Log{Direction: DirServerToClient, Format: "test %s", Messages: []interface{}{"foo"}})
 	if b.String() != "" {
 		t.Error("Debug message was not expected to be logged")
@@ -181,7 +181,7 @@ func TestJSONInfof(t *testing.T) {
 	}
 
 	b.Reset()
-	l.l = LevelWarn
+	l.level = LevelWarn
 	l.Infof(Log{Direction: DirServerToClient, Format: "test %s", Messages: []interface{}{"foo"}})
 	if b.String() != "" {
 		t.Error("Info message was not expected to be logged")
@@ -231,7 +231,7 @@ func TestJSONWarnf(t *testing.T) {
 	}
 
 	b.Reset()
-	l.l = LevelError
+	l.level = LevelError
 	l.Warnf(Log{Direction: DirServerToClient, Format: "test %s", Messages: []interface{}{"foo"}})
 	if b.String() != "" {
 		t.Error("Warn message was not expected to be logged")
@@ -281,7 +281,7 @@ func TestJSONErrorf(t *testing.T) {
 	}
 
 	b.Reset()
-	l.l = -99
+	l.level = -99
 	l.Errorf(Log{Direction: DirServerToClient, Format: "test %s", Messages: []interface{}{"foo"}})
 	if b.String() != "" {
 		t.Error("Error message was not expected to be logged")

log/stdlog.go

@@ -12,7 +12,7 @@ import (
 
 // Stdlog is the default logger that satisfies the Logger interface
 type Stdlog struct {
-	l     Level
+	level Level
 	err   *log.Logger
 	warn  *log.Logger
 	info  *log.Logger
@@ -24,45 +24,45 @@ type Stdlog struct {
 const CallDepth = 2
 
 // New returns a new Stdlog type that satisfies the Logger interface
-func New(o io.Writer, l Level) *Stdlog {
+func New(output io.Writer, level Level) *Stdlog {
 	lf := log.Lmsgprefix | log.LstdFlags
 	return &Stdlog{
-		l:     l,
+		level: level,
-		err:   log.New(o, "ERROR: ", lf),
+		err:   log.New(output, "ERROR: ", lf),
-		warn:  log.New(o, " WARN: ", lf),
+		warn:  log.New(output, " WARN: ", lf),
-		info:  log.New(o, " INFO: ", lf),
+		info:  log.New(output, " INFO: ", lf),
-		debug: log.New(o, "DEBUG: ", lf),
+		debug: log.New(output, "DEBUG: ", lf),
 	}
 }
 
 // Debugf performs a Printf() on the debug logger
-func (l *Stdlog) Debugf(lo Log) {
+func (l *Stdlog) Debugf(log Log) {
-	if l.l >= LevelDebug {
+	if l.level >= LevelDebug {
-		f := fmt.Sprintf("%s %s", lo.directionPrefix(), lo.Format)
+		format := fmt.Sprintf("%s %s", log.directionPrefix(), log.Format)
-		_ = l.debug.Output(CallDepth, fmt.Sprintf(f, lo.Messages...))
+		_ = l.debug.Output(CallDepth, fmt.Sprintf(format, log.Messages...))
 	}
 }
 
 // Infof performs a Printf() on the info logger
-func (l *Stdlog) Infof(lo Log) {
+func (l *Stdlog) Infof(log Log) {
-	if l.l >= LevelInfo {
+	if l.level >= LevelInfo {
-		f := fmt.Sprintf("%s %s", lo.directionPrefix(), lo.Format)
+		format := fmt.Sprintf("%s %s", log.directionPrefix(), log.Format)
-		_ = l.info.Output(CallDepth, fmt.Sprintf(f, lo.Messages...))
+		_ = l.info.Output(CallDepth, fmt.Sprintf(format, log.Messages...))
 	}
 }
 
 // Warnf performs a Printf() on the warn logger
-func (l *Stdlog) Warnf(lo Log) {
+func (l *Stdlog) Warnf(log Log) {
-	if l.l >= LevelWarn {
+	if l.level >= LevelWarn {
-		f := fmt.Sprintf("%s %s", lo.directionPrefix(), lo.Format)
+		format := fmt.Sprintf("%s %s", log.directionPrefix(), log.Format)
-		_ = l.warn.Output(CallDepth, fmt.Sprintf(f, lo.Messages...))
+		_ = l.warn.Output(CallDepth, fmt.Sprintf(format, log.Messages...))
 	}
 }
 
 // Errorf performs a Printf() on the error logger
-func (l *Stdlog) Errorf(lo Log) {
+func (l *Stdlog) Errorf(log Log) {
-	if l.l >= LevelError {
+	if l.level >= LevelError {
-		f := fmt.Sprintf("%s %s", lo.directionPrefix(), lo.Format)
+		format := fmt.Sprintf("%s %s", log.directionPrefix(), log.Format)
-		_ = l.err.Output(CallDepth, fmt.Sprintf(f, lo.Messages...))
+		_ = l.err.Output(CallDepth, fmt.Sprintf(format, log.Messages...))
 	}
 }

log/stdlog_test.go

@@ -13,8 +13,8 @@ import (
 func TestNew(t *testing.T) {
 	var b bytes.Buffer
 	l := New(&b, LevelDebug)
-	if l.l != LevelDebug {
+	if l.level != LevelDebug {
-		t.Error("Expected level to be LevelDebug, got ", l.l)
+		t.Error("Expected level to be LevelDebug, got ", l.level)
 	}
 	if l.err == nil || l.warn == nil || l.info == nil || l.debug == nil {
 		t.Error("Loggers not initialized")
@@ -37,7 +37,7 @@ func TestDebugf(t *testing.T) {
 	}
 
 	b.Reset()
-	l.l = LevelInfo
+	l.level = LevelInfo
 	l.Debugf(Log{Direction: DirServerToClient, Format: "test %s", Messages: []interface{}{"foo"}})
 	if b.String() != "" {
 		t.Error("Debug message was not expected to be logged")
@@ -60,7 +60,7 @@ func TestInfof(t *testing.T) {
 	}
 
 	b.Reset()
-	l.l = LevelWarn
+	l.level = LevelWarn
 	l.Infof(Log{Direction: DirServerToClient, Format: "test %s", Messages: []interface{}{"foo"}})
 	if b.String() != "" {
 		t.Error("Info message was not expected to be logged")
@@ -83,7 +83,7 @@ func TestWarnf(t *testing.T) {
 	}
 
 	b.Reset()
-	l.l = LevelError
+	l.level = LevelError
 	l.Warnf(Log{Direction: DirServerToClient, Format: "test %s", Messages: []interface{}{"foo"}})
 	if b.String() != "" {
 		t.Error("Warn message was not expected to be logged")
@@ -106,7 +106,7 @@ func TestErrorf(t *testing.T) {
 	}
 
 	b.Reset()
-	l.l = LevelError - 1
+	l.level = LevelError - 1
 	l.Errorf(Log{Direction: DirServerToClient, Format: "test %s", Messages: []interface{}{"foo"}})
 	if b.String() != "" {
 		t.Error("Error message was not expected to be logged")

msg_test.go

@@ -1251,7 +1251,7 @@ func TestMsg_SetBodyString(t *testing.T) {
 			}
 			part := m.parts[0]
 			res := bytes.Buffer{}
-			if _, err := part.w(&res); err != nil && !tt.sf {
+			if _, err := part.writeFunc(&res); err != nil && !tt.sf {
 				t.Errorf("WriteFunc of part failed: %s", err)
 			}
 			if res.String() != tt.want {
@@ -1286,7 +1286,7 @@ func TestMsg_AddAlternativeString(t *testing.T) {
 			}
 			apart := m.parts[1]
 			res := bytes.Buffer{}
-			if _, err := apart.w(&res); err != nil && !tt.sf {
+			if _, err := apart.writeFunc(&res); err != nil && !tt.sf {
 				t.Errorf("WriteFunc of part failed: %s", err)
 			}
 			if res.String() != tt.want {
@@ -3174,7 +3174,7 @@ func TestMsg_checkUserAgent(t *testing.T) {
 		{
 			name:               "check default user agent",
 			noDefaultUserAgent: false,
-			wantUserAgent:      "go-mail v0.4.1 // https://github.com/wneessen/go-mail",
+			wantUserAgent:      fmt.Sprintf("go-mail v%s // https://github.com/wneessen/go-mail", VERSION),
 			sf:                 false,
 		},
 		{
@@ -3211,3 +3211,11 @@ func TestMsg_checkUserAgent(t *testing.T) {
 		})
 	}
 }
+
+// TestNewMsgWithMIMEVersion tests WithMIMEVersion and Msg.SetMIMEVersion
+func TestNewMsgWithNoDefaultUserAgent(t *testing.T) {
+	m := NewMsg(WithNoDefaultUserAgent())
+	if m.noDefaultUserAgent != true {
+		t.Errorf("WithNoDefaultUserAgent() failed. Expected: %t, got: %t", true, false)
+	}
+}

msgwriter.go

@@ -35,237 +35,241 @@ const DoubleNewLine = "\r\n\r\n"
 
 // msgWriter handles the I/O to the io.WriteCloser of the SMTP client
 type msgWriter struct {
-	c   Charset
+	bytesWritten    int64
-	d   int8
+	charset         Charset
-	en  mime.WordEncoder
+	depth           int8
+	encoder         mime.WordEncoder
 	err             error
-	mpw [3]*multipart.Writer
+	multiPartWriter [3]*multipart.Writer
-	n   int64
+	partWriter      io.Writer
-	pw  io.Writer
+	writer          io.Writer
-	w   io.Writer
 }
 
 // Write implements the io.Writer interface for msgWriter
-func (mw *msgWriter) Write(p []byte) (int, error) {
+func (mw *msgWriter) Write(payload []byte) (int, error) {
 	if mw.err != nil {
 		return 0, fmt.Errorf("failed to write due to previous error: %w", mw.err)
 	}
 
 	var n int
-	n, mw.err = mw.w.Write(p)
+	n, mw.err = mw.writer.Write(payload)
-	mw.n += int64(n)
+	mw.bytesWritten += int64(n)
 	return n, mw.err
 }
 
 // writeMsg formats the message and sends it to its io.Writer
-func (mw *msgWriter) writeMsg(m *Msg) {
+func (mw *msgWriter) writeMsg(msg *Msg) {
-	m.addDefaultHeader()
+	msg.addDefaultHeader()
-	m.checkUserAgent()
+	msg.checkUserAgent()
-	mw.writeGenHeader(m)
+	mw.writeGenHeader(msg)
-	mw.writePreformattedGenHeader(m)
+	mw.writePreformattedGenHeader(msg)
 
 	// Set the FROM header (or envelope FROM if FROM is empty)
-	hf := true
+	hasFrom := true
-	f, ok := m.addrHeader[HeaderFrom]
+	from, ok := msg.addrHeader[HeaderFrom]
-	if !ok || (len(f) == 0 || f == nil) {
+	if !ok || (len(from) == 0 || from == nil) {
-		f, ok = m.addrHeader[HeaderEnvelopeFrom]
+		from, ok = msg.addrHeader[HeaderEnvelopeFrom]
-		if !ok || (len(f) == 0 || f == nil) {
+		if !ok || (len(from) == 0 || from == nil) {
-			hf = false
+			hasFrom = false
 		}
 	}
-	if hf && (len(f) > 0 && f[0] != nil) {
+	if hasFrom && (len(from) > 0 && from[0] != nil) {
-		mw.writeHeader(Header(HeaderFrom), f[0].String())
+		mw.writeHeader(Header(HeaderFrom), from[0].String())
 	}
 
 	// Set the rest of the address headers
-	for _, t := range []AddrHeader{HeaderTo, HeaderCc} {
+	for _, to := range []AddrHeader{HeaderTo, HeaderCc} {
-		if al, ok := m.addrHeader[t]; ok {
+		if addresses, ok := msg.addrHeader[to]; ok {
-			var v []string
+			var val []string
-			for _, a := range al {
+			for _, addr := range addresses {
-				v = append(v, a.String())
+				val = append(val, addr.String())
 			}
-			mw.writeHeader(Header(t), v...)
+			mw.writeHeader(Header(to), val...)
 		}
 	}
 
-	if m.hasMixed() {
+	if msg.hasMixed() {
-		mw.startMP("mixed", m.boundary)
+		mw.startMP("mixed", msg.boundary)
 		mw.writeString(DoubleNewLine)
 	}
-	if m.hasRelated() {
+	if msg.hasRelated() {
-		mw.startMP("related", m.boundary)
+		mw.startMP("related", msg.boundary)
 		mw.writeString(DoubleNewLine)
 	}
-	if m.hasAlt() {
+	if msg.hasAlt() {
-		mw.startMP(MIMEAlternative, m.boundary)
+		mw.startMP(MIMEAlternative, msg.boundary)
 		mw.writeString(DoubleNewLine)
 	}
-	if m.hasPGPType() {
+	if msg.hasPGPType() {
-		switch m.pgptype {
+		switch msg.pgptype {
 		case PGPEncrypt:
-			mw.startMP(`encrypted; protocol="application/pgp-encrypted"`, m.boundary)
+			mw.startMP(`encrypted; protocol="application/pgp-encrypted"`,
+				msg.boundary)
 		case PGPSignature:
-			mw.startMP(`signed; protocol="application/pgp-signature";`, m.boundary)
+			mw.startMP(`signed; protocol="application/pgp-signature";`,
+				msg.boundary)
+		default:
 		}
 		mw.writeString(DoubleNewLine)
 	}
 
-	for _, p := range m.parts {
+	for _, part := range msg.parts {
-		if !p.del {
+		if !part.isDeleted {
-			mw.writePart(p, m.charset)
+			mw.writePart(part, msg.charset)
 		}
 	}
 
-	if m.hasAlt() {
+	if msg.hasAlt() {
 		mw.stopMP()
 	}
 
 	// Add embeds
-	mw.addFiles(m.embeds, false)
+	mw.addFiles(msg.embeds, false)
-	if m.hasRelated() {
+	if msg.hasRelated() {
 		mw.stopMP()
 	}
 
 	// Add attachments
-	mw.addFiles(m.attachments, true)
+	mw.addFiles(msg.attachments, true)
-	if m.hasMixed() {
+	if msg.hasMixed() {
 		mw.stopMP()
 	}
 }
 
 // writeGenHeader writes out all generic headers to the msgWriter
-func (mw *msgWriter) writeGenHeader(m *Msg) {
+func (mw *msgWriter) writeGenHeader(msg *Msg) {
-	gk := make([]string, 0, len(m.genHeader))
+	keys := make([]string, 0, len(msg.genHeader))
-	for k := range m.genHeader {
+	for key := range msg.genHeader {
-		gk = append(gk, string(k))
+		keys = append(keys, string(key))
 	}
-	sort.Strings(gk)
+	sort.Strings(keys)
-	for _, k := range gk {
+	for _, key := range keys {
-		mw.writeHeader(Header(k), m.genHeader[Header(k)]...)
+		mw.writeHeader(Header(key), msg.genHeader[Header(key)]...)
 	}
 }
 
 // writePreformatedHeader writes out all preformated generic headers to the msgWriter
-func (mw *msgWriter) writePreformattedGenHeader(m *Msg) {
+func (mw *msgWriter) writePreformattedGenHeader(msg *Msg) {
-	for k, v := range m.preformHeader {
+	for key, val := range msg.preformHeader {
-		mw.writeString(fmt.Sprintf("%s: %s%s", k, v, SingleNewLine))
+		mw.writeString(fmt.Sprintf("%s: %s%s", key, val, SingleNewLine))
 	}
 }
 
 // startMP writes a multipart beginning
-func (mw *msgWriter) startMP(mt MIMEType, b string) {
+func (mw *msgWriter) startMP(mimeType MIMEType, boundary string) {
-	mp := multipart.NewWriter(mw)
+	multiPartWriter := multipart.NewWriter(mw)
-	if b != "" {
+	if boundary != "" {
-		mw.err = mp.SetBoundary(b)
+		mw.err = multiPartWriter.SetBoundary(boundary)
 	}
 
-	ct := fmt.Sprintf("multipart/%s;\r\n boundary=%s", mt, mp.Boundary())
+	contentType := fmt.Sprintf("multipart/%s;\r\n boundary=%s", mimeType,
-	mw.mpw[mw.d] = mp
+		multiPartWriter.Boundary())
+	mw.multiPartWriter[mw.depth] = multiPartWriter
 
-	if mw.d == 0 {
+	if mw.depth == 0 {
-		mw.writeString(fmt.Sprintf("%s: %s", HeaderContentType, ct))
+		mw.writeString(fmt.Sprintf("%s: %s", HeaderContentType, contentType))
 	}
-	if mw.d > 0 {
+	if mw.depth > 0 {
-		mw.newPart(map[string][]string{"Content-Type": {ct}})
+		mw.newPart(map[string][]string{"Content-Type": {contentType}})
 	}
-	mw.d++
+	mw.depth++
 }
 
 // stopMP closes the multipart
 func (mw *msgWriter) stopMP() {
-	if mw.d > 0 {
+	if mw.depth > 0 {
-		mw.err = mw.mpw[mw.d-1].Close()
+		mw.err = mw.multiPartWriter[mw.depth-1].Close()
-		mw.d--
+		mw.depth--
 	}
 }
 
 // addFiles adds the attachments/embeds file content to the mail body
-func (mw *msgWriter) addFiles(fl []*File, a bool) {
+func (mw *msgWriter) addFiles(files []*File, isAttachment bool) {
-	for _, f := range fl {
+	for _, file := range files {
-		e := EncodingB64
+		encoding := EncodingB64
-		if _, ok := f.getHeader(HeaderContentType); !ok {
+		if _, ok := file.getHeader(HeaderContentType); !ok {
-			mt := mime.TypeByExtension(filepath.Ext(f.Name))
+			mimeType := mime.TypeByExtension(filepath.Ext(file.Name))
-			if mt == "" {
+			if mimeType == "" {
-				mt = "application/octet-stream"
+				mimeType = "application/octet-stream"
 			}
-			if f.ContentType != "" {
+			if file.ContentType != "" {
-				mt = string(f.ContentType)
+				mimeType = string(file.ContentType)
 			}
-			f.setHeader(HeaderContentType, fmt.Sprintf(`%s; name="%s"`, mt,
+			file.setHeader(HeaderContentType, fmt.Sprintf(`%s; name="%s"`, mimeType,
-				mw.en.Encode(mw.c.String(), f.Name)))
+				mw.encoder.Encode(mw.charset.String(), file.Name)))
 		}
 
-		if _, ok := f.getHeader(HeaderContentTransferEnc); !ok {
+		if _, ok := file.getHeader(HeaderContentTransferEnc); !ok {
-			if f.Enc != "" {
+			if file.Enc != "" {
-				e = f.Enc
+				encoding = file.Enc
 			}
-			f.setHeader(HeaderContentTransferEnc, string(e))
+			file.setHeader(HeaderContentTransferEnc, string(encoding))
 		}
 
-		if f.Desc != "" {
+		if file.Desc != "" {
-			if _, ok := f.getHeader(HeaderContentDescription); !ok {
+			if _, ok := file.getHeader(HeaderContentDescription); !ok {
-				f.setHeader(HeaderContentDescription, f.Desc)
+				file.setHeader(HeaderContentDescription, file.Desc)
 			}
 		}
 
-		if _, ok := f.getHeader(HeaderContentDisposition); !ok {
+		if _, ok := file.getHeader(HeaderContentDisposition); !ok {
-			d := "inline"
+			disposition := "inline"
-			if a {
+			if isAttachment {
-				d = "attachment"
+				disposition = "attachment"
 			}
-			f.setHeader(HeaderContentDisposition, fmt.Sprintf(`%s; filename="%s"`, d,
+			file.setHeader(HeaderContentDisposition, fmt.Sprintf(`%s; filename="%s"`,
-				mw.en.Encode(mw.c.String(), f.Name)))
+				disposition, mw.encoder.Encode(mw.charset.String(), file.Name)))
 		}
 
-		if !a {
+		if !isAttachment {
-			if _, ok := f.getHeader(HeaderContentID); !ok {
+			if _, ok := file.getHeader(HeaderContentID); !ok {
-				f.setHeader(HeaderContentID, fmt.Sprintf("<%s>", f.Name))
+				file.setHeader(HeaderContentID, fmt.Sprintf("<%s>", file.Name))
 			}
 		}
-		if mw.d == 0 {
+		if mw.depth == 0 {
-			for h, v := range f.Header {
+			for header, val := range file.Header {
-				mw.writeHeader(Header(h), v...)
+				mw.writeHeader(Header(header), val...)
 			}
 			mw.writeString(SingleNewLine)
 		}
-		if mw.d > 0 {
+		if mw.depth > 0 {
-			mw.newPart(f.Header)
+			mw.newPart(file.Header)
 		}
 
 		if mw.err == nil {
-			mw.writeBody(f.Writer, e)
+			mw.writeBody(file.Writer, encoding)
 		}
 	}
 }
 
 // newPart creates a new MIME multipart io.Writer and sets the partwriter to it
-func (mw *msgWriter) newPart(h map[string][]string) {
+func (mw *msgWriter) newPart(header map[string][]string) {
-	mw.pw, mw.err = mw.mpw[mw.d-1].CreatePart(h)
+	mw.partWriter, mw.err = mw.multiPartWriter[mw.depth-1].CreatePart(header)
 }
 
 // writePart writes the corresponding part to the Msg body
-func (mw *msgWriter) writePart(p *Part, cs Charset) {
+func (mw *msgWriter) writePart(part *Part, charset Charset) {
-	pcs := p.cset
+	partCharset := part.charset
-	if pcs.String() == "" {
+	if partCharset.String() == "" {
-		pcs = cs
+		partCharset = charset
 	}
-	ct := fmt.Sprintf("%s; charset=%s", p.ctype, pcs)
+	contentType := fmt.Sprintf("%s; charset=%s", part.contentType, partCharset)
-	cte := p.enc.String()
+	contentTransferEnc := part.encoding.String()
-	if mw.d == 0 {
+	if mw.depth == 0 {
-		mw.writeHeader(HeaderContentType, ct)
+		mw.writeHeader(HeaderContentType, contentType)
-		mw.writeHeader(HeaderContentTransferEnc, cte)
+		mw.writeHeader(HeaderContentTransferEnc, contentTransferEnc)
 		mw.writeString(SingleNewLine)
 	}
-	if mw.d > 0 {
+	if mw.depth > 0 {
-		mh := textproto.MIMEHeader{}
+		mimeHeader := textproto.MIMEHeader{}
-		if p.desc != "" {
+		if part.description != "" {
-			mh.Add(string(HeaderContentDescription), p.desc)
+			mimeHeader.Add(string(HeaderContentDescription), part.description)
 		}
-		mh.Add(string(HeaderContentType), ct)
+		mimeHeader.Add(string(HeaderContentType), contentType)
-		mh.Add(string(HeaderContentTransferEnc), cte)
+		mimeHeader.Add(string(HeaderContentTransferEnc), contentTransferEnc)
-		mw.newPart(mh)
+		mw.newPart(mimeHeader)
 	}
-	mw.writeBody(p.w, p.enc)
+	mw.writeBody(part.writeFunc, part.encoding)
 }
 
 // writeString writes a string into the msgWriter's io.Writer interface
@@ -274,102 +278,103 @@ func (mw *msgWriter) writeString(s string) {
 		return
 	}
 	var n int
-	n, mw.err = io.WriteString(mw.w, s)
+	n, mw.err = io.WriteString(mw.writer, s)
-	mw.n += int64(n)
+	mw.bytesWritten += int64(n)
 }
 
 // writeHeader writes a header into the msgWriter's io.Writer
-func (mw *msgWriter) writeHeader(k Header, vl ...string) {
+func (mw *msgWriter) writeHeader(key Header, values ...string) {
-	wbuf := bytes.Buffer{}
+	buffer := strings.Builder{}
-	cl := MaxHeaderLength - 2
+	charLength := MaxHeaderLength - 2
-	wbuf.WriteString(string(k))
+	buffer.WriteString(string(key))
-	cl -= len(k)
+	charLength -= len(key)
-	if len(vl) == 0 {
+	if len(values) == 0 {
-		wbuf.WriteString(":\r\n")
+		buffer.WriteString(":\r\n")
 		return
 	}
-	wbuf.WriteString(": ")
+	buffer.WriteString(": ")
-	cl -= 2
+	charLength -= 2
 
-	fs := strings.Join(vl, ", ")
+	fullValueStr := strings.Join(values, ", ")
-	sfs := strings.Split(fs, " ")
+	words := strings.Split(fullValueStr, " ")
-	for i, v := range sfs {
+	for i, val := range words {
-		if cl-len(v) <= 1 {
+		if charLength-len(val) <= 1 {
-			wbuf.WriteString(fmt.Sprintf("%s ", SingleNewLine))
+			buffer.WriteString(fmt.Sprintf("%s ", SingleNewLine))
-			cl = MaxHeaderLength - 3
+			charLength = MaxHeaderLength - 3
 		}
-		wbuf.WriteString(v)
+		buffer.WriteString(val)
-		if i < len(sfs)-1 {
+		if i < len(words)-1 {
-			wbuf.WriteString(" ")
+			buffer.WriteString(" ")
-			cl -= 1
+			charLength -= 1
 		}
-		cl -= len(v)
+		charLength -= len(val)
 	}
 
-	bufs := wbuf.String()
+	bufferString := buffer.String()
-	bufs = strings.ReplaceAll(bufs, fmt.Sprintf(" %s", SingleNewLine), SingleNewLine)
+	bufferString = strings.ReplaceAll(bufferString, fmt.Sprintf(" %s", SingleNewLine),
-	mw.writeString(bufs)
+		SingleNewLine)
+	mw.writeString(bufferString)
 	mw.writeString("\r\n")
 }
 
 // writeBody writes an io.Reader into an io.Writer using provided Encoding
-func (mw *msgWriter) writeBody(f func(io.Writer) (int64, error), e Encoding) {
+func (mw *msgWriter) writeBody(writeFunc func(io.Writer) (int64, error), encoding Encoding) {
-	var w io.Writer
+	var writer io.Writer
-	var ew io.WriteCloser
+	var encodedWriter io.WriteCloser
 	var n int64
 	var err error
-	if mw.d == 0 {
+	if mw.depth == 0 {
-		w = mw.w
+		writer = mw.writer
 	}
-	if mw.d > 0 {
+	if mw.depth > 0 {
-		w = mw.pw
+		writer = mw.partWriter
 	}
-	wbuf := bytes.Buffer{}
+	writeBuffer := bytes.Buffer{}
-	lb := Base64LineBreaker{}
+	lineBreaker := Base64LineBreaker{}
-	lb.out = &wbuf
+	lineBreaker.out = &writeBuffer
 
-	switch e {
+	switch encoding {
 	case EncodingQP:
-		ew = quotedprintable.NewWriter(&wbuf)
+		encodedWriter = quotedprintable.NewWriter(&writeBuffer)
 	case EncodingB64:
-		ew = base64.NewEncoder(base64.StdEncoding, &lb)
+		encodedWriter = base64.NewEncoder(base64.StdEncoding, &lineBreaker)
 	case NoEncoding:
-		_, err = f(&wbuf)
+		_, err = writeFunc(&writeBuffer)
 		if err != nil {
 			mw.err = fmt.Errorf("bodyWriter function: %w", err)
 		}
-		n, err = io.Copy(w, &wbuf)
+		n, err = io.Copy(writer, &writeBuffer)
 		if err != nil && mw.err == nil {
 			mw.err = fmt.Errorf("bodyWriter io.Copy: %w", err)
 		}
-		if mw.d == 0 {
+		if mw.depth == 0 {
-			mw.n += n
+			mw.bytesWritten += n
 		}
 		return
 	default:
-		ew = quotedprintable.NewWriter(w)
+		encodedWriter = quotedprintable.NewWriter(writer)
 	}
 
-	_, err = f(ew)
+	_, err = writeFunc(encodedWriter)
 	if err != nil {
 		mw.err = fmt.Errorf("bodyWriter function: %w", err)
 	}
-	err = ew.Close()
+	err = encodedWriter.Close()
 	if err != nil && mw.err == nil {
 		mw.err = fmt.Errorf("bodyWriter close encoded writer: %w", err)
 	}
-	err = lb.Close()
+	err = lineBreaker.Close()
 	if err != nil && mw.err == nil {
 		mw.err = fmt.Errorf("bodyWriter close linebreaker: %w", err)
 	}
-	n, err = io.Copy(w, &wbuf)
+	n, err = io.Copy(writer, &writeBuffer)
 	if err != nil && mw.err == nil {
 		mw.err = fmt.Errorf("bodyWriter io.Copy: %w", err)
 	}
 
 	// Since the part writer uses the WriteTo() method, we don't need to add the
 	// bytes twice
-	if mw.d == 0 {
+	if mw.depth == 0 {
-		mw.n += n
+		mw.bytesWritten += n
 	}
 }

msgwriter_test.go

@@ -28,7 +28,7 @@ func (bw *brokenWriter) Write([]byte) (int, error) {
 // TestMsgWriter_Write tests the WriteTo() method of the msgWriter
 func TestMsgWriter_Write(t *testing.T) {
 	bw := &brokenWriter{}
-	mw := &msgWriter{w: bw, c: CharsetUTF8, en: mime.QEncoding}
+	mw := &msgWriter{writer: bw, charset: CharsetUTF8, encoder: mime.QEncoding}
 	_, err := mw.Write([]byte("test"))
 	if err == nil {
 		t.Errorf("msgWriter WriteTo() with brokenWriter should fail, but didn't")
@@ -55,7 +55,7 @@ func TestMsgWriter_writeMsg(t *testing.T) {
 	m.SetBodyString(TypeTextPlain, "This is the body")
 	m.AddAlternativeString(TypeTextHTML, "This is the alternative body")
 	buf := bytes.Buffer{}
-	mw := &msgWriter{w: &buf, c: CharsetUTF8, en: mime.QEncoding}
+	mw := &msgWriter{writer: &buf, charset: CharsetUTF8, encoder: mime.QEncoding}
 	mw.writeMsg(m)
 	ms := buf.String()
 
@@ -134,7 +134,7 @@ func TestMsgWriter_writeMsg_PGP(t *testing.T) {
 	m.Subject("This is a subject")
 	m.SetBodyString(TypeTextPlain, "This is the body")
 	buf := bytes.Buffer{}
-	mw := &msgWriter{w: &buf, c: CharsetUTF8, en: mime.QEncoding}
+	mw := &msgWriter{writer: &buf, charset: CharsetUTF8, encoder: mime.QEncoding}
 	mw.writeMsg(m)
 	ms := buf.String()
 	if !strings.Contains(ms, `encrypted; protocol="application/pgp-encrypted"`) {
@@ -147,7 +147,7 @@ func TestMsgWriter_writeMsg_PGP(t *testing.T) {
 	m.Subject("This is a subject")
 	m.SetBodyString(TypeTextPlain, "This is the body")
 	buf = bytes.Buffer{}
-	mw = &msgWriter{w: &buf, c: CharsetUTF8, en: mime.QEncoding}
+	mw = &msgWriter{writer: &buf, charset: CharsetUTF8, encoder: mime.QEncoding}
 	mw.writeMsg(m)
 	ms = buf.String()
 	if !strings.Contains(ms, `signed; protocol="application/pgp-signature"`) {

part.go

@@ -14,18 +14,18 @@ type PartOption func(*Part)
 
 // Part is a part of the Msg
 type Part struct {
-	ctype ContentType
+	contentType ContentType
-	cset  Charset
+	charset     Charset
-	desc  string
+	description string
-	enc   Encoding
+	encoding    Encoding
-	del   bool
+	isDeleted   bool
-	w     func(io.Writer) (int64, error)
+	writeFunc   func(io.Writer) (int64, error)
 }
 
 // GetContent executes the WriteFunc of the Part and returns the content as byte slice
 func (p *Part) GetContent() ([]byte, error) {
 	var b bytes.Buffer
-	if _, err := p.w(&b); err != nil {
+	if _, err := p.writeFunc(&b); err != nil {
 		return nil, err
 	}
 	return b.Bytes(), nil
@@ -33,83 +33,83 @@ func (p *Part) GetContent() ([]byte, error) {
 
 // GetCharset returns the currently set Charset of the Part
 func (p *Part) GetCharset() Charset {
-	return p.cset
+	return p.charset
 }
 
 // GetContentType returns the currently set ContentType of the Part
 func (p *Part) GetContentType() ContentType {
-	return p.ctype
+	return p.contentType
 }
 
 // GetEncoding returns the currently set Encoding of the Part
 func (p *Part) GetEncoding() Encoding {
-	return p.enc
+	return p.encoding
 }
 
 // GetWriteFunc returns the currently set WriterFunc of the Part
 func (p *Part) GetWriteFunc() func(io.Writer) (int64, error) {
-	return p.w
+	return p.writeFunc
 }
 
 // GetDescription returns the currently set Content-Description of the Part
 func (p *Part) GetDescription() string {
-	return p.desc
+	return p.description
 }
 
 // SetContent overrides the content of the Part with the given string
-func (p *Part) SetContent(c string) {
+func (p *Part) SetContent(content string) {
-	buf := bytes.NewBufferString(c)
+	buffer := bytes.NewBufferString(content)
-	p.w = writeFuncFromBuffer(buf)
+	p.writeFunc = writeFuncFromBuffer(buffer)
 }
 
 // SetContentType overrides the ContentType of the Part
-func (p *Part) SetContentType(c ContentType) {
+func (p *Part) SetContentType(contentType ContentType) {
-	p.ctype = c
+	p.contentType = contentType
 }
 
 // SetCharset overrides the Charset of the Part
-func (p *Part) SetCharset(c Charset) {
+func (p *Part) SetCharset(charset Charset) {
-	p.cset = c
+	p.charset = charset
 }
 
 // SetEncoding creates a new mime.WordEncoder based on the encoding setting of the message
-func (p *Part) SetEncoding(e Encoding) {
+func (p *Part) SetEncoding(encoding Encoding) {
-	p.enc = e
+	p.encoding = encoding
 }
 
 // SetDescription overrides the Content-Description of the Part
-func (p *Part) SetDescription(d string) {
+func (p *Part) SetDescription(description string) {
-	p.desc = d
+	p.description = description
 }
 
 // SetWriteFunc overrides the WriteFunc of the Part
-func (p *Part) SetWriteFunc(w func(io.Writer) (int64, error)) {
+func (p *Part) SetWriteFunc(writeFunc func(io.Writer) (int64, error)) {
-	p.w = w
+	p.writeFunc = writeFunc
 }
 
 // Delete removes the current part from the parts list of the Msg by setting the
-// del flag to true. The msgWriter will skip it then
+// isDeleted flag to true. The msgWriter will skip it then
 func (p *Part) Delete() {
-	p.del = true
+	p.isDeleted = true
 }
 
 // WithPartCharset overrides the default Part charset
-func WithPartCharset(c Charset) PartOption {
+func WithPartCharset(charset Charset) PartOption {
 	return func(p *Part) {
-		p.cset = c
+		p.charset = charset
 	}
 }
 
 // WithPartEncoding overrides the default Part encoding
-func WithPartEncoding(e Encoding) PartOption {
+func WithPartEncoding(encoding Encoding) PartOption {
 	return func(p *Part) {
-		p.enc = e
+		p.encoding = encoding
 	}
 }
 
 // WithPartContentDescription overrides the default Part Content-Description
-func WithPartContentDescription(d string) PartOption {
+func WithPartContentDescription(description string) PartOption {
 	return func(p *Part) {
-		p.desc = d
+		p.description = description
 	}
 }

part_test.go

@@ -31,15 +31,15 @@ func TestPartEncoding(t *testing.T) {
 				t.Errorf("newPart() WithPartEncoding() failed: no part returned")
 				return
 			}
-			if part.enc.String() != tt.want {
+			if part.encoding.String() != tt.want {
 				t.Errorf("newPart() WithPartEncoding() failed: expected encoding: %s, got: %s", tt.want,
-					part.enc.String())
+					part.encoding.String())
 			}
-			part.enc = ""
+			part.encoding = ""
 			part.SetEncoding(tt.enc)
-			if part.enc.String() != tt.want {
+			if part.encoding.String() != tt.want {
 				t.Errorf("newPart() SetEncoding() failed: expected encoding: %s, got: %s", tt.want,
-					part.enc.String())
+					part.encoding.String())
 			}
 		})
 	}
@@ -64,9 +64,9 @@ func TestWithPartCharset(t *testing.T) {
 				t.Errorf("newPart() WithPartCharset() failed: no part returned")
 				return
 			}
-			if part.cset.String() != tt.want {
+			if part.charset.String() != tt.want {
 				t.Errorf("newPart() WithPartCharset() failed: expected charset: %s, got: %s",
-					tt.want, part.cset.String())
+					tt.want, part.charset.String())
 			}
 		})
 	}
@@ -89,14 +89,14 @@ func TestPart_WithPartContentDescription(t *testing.T) {
 				t.Errorf("newPart() WithPartContentDescription() failed: no part returned")
 				return
 			}
-			if part.desc != tt.desc {
+			if part.description != tt.desc {
 				t.Errorf("newPart() WithPartContentDescription() failed: expected: %s, got: %s", tt.desc,
-					part.desc)
+					part.description)
 			}
-			part.desc = ""
+			part.description = ""
 			part.SetDescription(tt.desc)
-			if part.desc != tt.desc {
+			if part.description != tt.desc {
-				t.Errorf("newPart() SetDescription() failed: expected: %s, got: %s", tt.desc, part.desc)
+				t.Errorf("newPart() SetDescription() failed: expected: %s, got: %s", tt.desc, part.description)
 			}
 		})
 	}
@@ -236,7 +236,7 @@ func TestPart_GetContentBroken(t *testing.T) {
 		t.Errorf("failed: %s", err)
 		return
 	}
-	pl[0].w = func(io.Writer) (int64, error) {
+	pl[0].writeFunc = func(io.Writer) (int64, error) {
 		return 0, fmt.Errorf("broken")
 	}
 	_, err = pl[0].GetContent()
@@ -314,8 +314,8 @@ func TestPart_SetDescription(t *testing.T) {
 		t.Errorf("Part.GetDescription failed. Expected empty description but got: %s", pd)
 	}
 	pl[0].SetDescription(d)
-	if pl[0].desc != d {
+	if pl[0].description != d {
-		t.Errorf("Part.SetDescription failed. Expected desc to be: %s, got: %s", d, pd)
+		t.Errorf("Part.SetDescription failed. Expected description to be: %s, got: %s", d, pd)
 	}
 	pd = pl[0].GetDescription()
 	if pd != d {
@@ -334,8 +334,8 @@ func TestPart_Delete(t *testing.T) {
 		return
 	}
 	pl[0].Delete()
-	if !pl[0].del {
+	if !pl[0].isDeleted {
-		t.Errorf("Delete failed. Expected: %t, got: %t", true, pl[0].del)
+		t.Errorf("Delete failed. Expected: %t, got: %t", true, pl[0].isDeleted)
 	}
 }
 

random.go

@@ -22,54 +22,53 @@ const (
 	letterIdxMax  = 63 / letterIdxBits   // # of letter indices fitting in 63 bits
 )
 
-// randomStringSecure returns a random, n long string of characters. The character set is based
+// randomStringSecure returns a random, string of length characters. This method uses the
-// on the s (special chars) and h (human readable) boolean arguments. This method uses the
 // crypto/random package and therfore is cryptographically secure
-func randomStringSecure(n int) (string, error) {
+func randomStringSecure(length int) (string, error) {
-	rs := strings.Builder{}
+	randString := strings.Builder{}
-	rs.Grow(n)
+	randString.Grow(length)
-	crl := len(cr)
+	charRangeLength := len(cr)
 
-	rp := make([]byte, 8)
+	randPool := make([]byte, 8)
-	_, err := rand.Read(rp)
+	_, err := rand.Read(randPool)
 	if err != nil {
-		return rs.String(), err
+		return randString.String(), err
 	}
-	for i, c, r := n-1, binary.BigEndian.Uint64(rp), letterIdxMax; i >= 0; {
+	for idx, char, rest := length-1, binary.BigEndian.Uint64(randPool), letterIdxMax; idx >= 0; {
-		if r == 0 {
+		if rest == 0 {
-			_, err := rand.Read(rp)
+			_, err = rand.Read(randPool)
 			if err != nil {
-				return rs.String(), err
+				return randString.String(), err
 			}
-			c, r = binary.BigEndian.Uint64(rp), letterIdxMax
+			char, rest = binary.BigEndian.Uint64(randPool), letterIdxMax
 		}
-		if idx := int(c & letterIdxMask); idx < crl {
+		if i := int(char & letterIdxMask); i < charRangeLength {
-			rs.WriteByte(cr[idx])
+			randString.WriteByte(cr[i])
-			i--
+			idx--
 		}
-		c >>= letterIdxBits
+		char >>= letterIdxBits
-		r--
+		rest--
 	}
 
-	return rs.String(), nil
+	return randString.String(), nil
 }
 
-// randNum returns a random number with a maximum value of n
+// randNum returns a random number with a maximum value of length
-func randNum(n int) (int, error) {
+func randNum(length int) (int, error) {
-	if n <= 0 {
+	if length <= 0 {
-		return 0, fmt.Errorf("provided number is <= 0: %d", n)
+		return 0, fmt.Errorf("provided number is <= 0: %d", length)
 	}
-	mbi := big.NewInt(int64(n))
+	length64 := big.NewInt(int64(length))
-	if !mbi.IsUint64() {
+	if !length64.IsUint64() {
-		return 0, fmt.Errorf("big.NewInt() generation returned negative value: %d", mbi)
+		return 0, fmt.Errorf("big.NewInt() generation returned negative value: %d", length64)
 	}
-	rn64, err := rand.Int(rand.Reader, mbi)
+	randNum64, err := rand.Int(rand.Reader, length64)
 	if err != nil {
 		return 0, err
 	}
-	rn := int(rn64.Int64())
+	randomNum := int(randNum64.Int64())
-	if rn < 0 {
+	if randomNum < 0 {
-		return 0, fmt.Errorf("generated random number does not fit as int64: %d", rn64)
+		return 0, fmt.Errorf("generated random number does not fit as int64: %d", randNum64)
 	}
-	return rn, nil
+	return randomNum, nil
 }

reader.go

@@ -10,8 +10,8 @@ import (
 
 // Reader is a type that implements the io.Reader interface for a Msg
 type Reader struct {
-	buf []byte // contents are the bytes buf[off : len(buf)]
+	buffer []byte // contents are the bytes buffer[offset : len(buffer)]
-	off int    // read at &buf[off], write at &buf[len(buf)]
+	offset int    // read at &buffer[offset], write at &buffer[len(buffer)]
 	err    error  // initialization error
 }
 
@@ -21,28 +21,28 @@ func (r *Reader) Error() error {
 }
 
 // Read reads the length of p of the Msg buffer to satisfy the io.Reader interface
-func (r *Reader) Read(p []byte) (n int, err error) {
+func (r *Reader) Read(payload []byte) (n int, err error) {
 	if r.err != nil {
 		return 0, r.err
 	}
-	if r.empty() || r.buf == nil {
+	if r.empty() || r.buffer == nil {
 		r.Reset()
-		if len(p) == 0 {
+		if len(payload) == 0 {
 			return 0, nil
 		}
 		return 0, io.EOF
 	}
-	n = copy(p, r.buf[r.off:])
+	n = copy(payload, r.buffer[r.offset:])
-	r.off += n
+	r.offset += n
 	return n, err
 }
 
 // Reset resets the Reader buffer to be empty, but it retains the underlying storage
 // for use by future writes.
 func (r *Reader) Reset() {
-	r.buf = r.buf[:0]
+	r.buffer = r.buffer[:0]
-	r.off = 0
+	r.offset = 0
 }
 
 // empty reports whether the unread portion of the Reader buffer is empty.
-func (r *Reader) empty() bool { return len(r.buf) <= r.off }
+func (r *Reader) empty() bool { return len(r.buffer) <= r.offset }

reader_test.go

@@ -65,7 +65,7 @@ func TestReader_Read_error(t *testing.T) {
 
 // TestReader_Read_empty tests the Reader.Read method with an empty buffer
 func TestReader_Read_empty(t *testing.T) {
-	r := Reader{buf: []byte{}}
+	r := Reader{buffer: []byte{}}
 	p := make([]byte, 1)
 	p[0] = 'a'
 	_, err := r.Read(p)
@@ -76,7 +76,7 @@ func TestReader_Read_empty(t *testing.T) {
 
 // TestReader_Read_nil tests the Reader.Read method with a nil buffer
 func TestReader_Read_nil(t *testing.T) {
-	r := Reader{buf: nil, off: -10}
+	r := Reader{buffer: nil, offset: -10}
 	p := make([]byte, 0)
 	_, err := r.Read(p)
 	if err != nil && !errors.Is(err, io.EOF) {

senderror.go

@@ -71,34 +71,34 @@ func (e *SendError) Error() string {
 		return "unknown reason"
 	}
 
-	var em strings.Builder
+	var errMessage strings.Builder
-	em.WriteString(e.Reason.String())
+	errMessage.WriteString(e.Reason.String())
 	if len(e.errlist) > 0 {
-		em.WriteRune(':')
+		errMessage.WriteRune(':')
 		for i := range e.errlist {
-			em.WriteRune(' ')
+			errMessage.WriteRune(' ')
-			em.WriteString(e.errlist[i].Error())
+			errMessage.WriteString(e.errlist[i].Error())
 			if i != len(e.errlist)-1 {
-				em.WriteString(", ")
+				errMessage.WriteString(", ")
 			}
 		}
 	}
 	if len(e.rcpt) > 0 {
-		em.WriteString(", affected recipient(s): ")
+		errMessage.WriteString(", affected recipient(s): ")
 		for i := range e.rcpt {
-			em.WriteString(e.rcpt[i])
+			errMessage.WriteString(e.rcpt[i])
 			if i != len(e.rcpt)-1 {
-				em.WriteString(", ")
+				errMessage.WriteString(", ")
 			}
 		}
 	}
-	return em.String()
+	return errMessage.String()
 }
 
 // Is implements the errors.Is functionality and compares the SendErrReason
-func (e *SendError) Is(et error) bool {
+func (e *SendError) Is(errType error) bool {
 	var t *SendError
-	if errors.As(et, &t) && t != nil {
+	if errors.As(errType, &t) && t != nil {
 		return e.Reason == t.Reason && e.isTemp == t.isTemp
 	}
 	return false
@@ -143,6 +143,6 @@ func (r SendErrReason) String() string {
 
 // isTempError checks the given SMTP error and returns true if the given error is of temporary nature
 // and should be retried
-func isTempError(e error) bool {
+func isTempError(err error) bool {
-	return e.Error()[0] == '4'
+	return err.Error()[0] == '4'
 }

tls.go

@@ -8,17 +8,17 @@ package mail
 type TLSPolicy int
 
 const (
-	// TLSMandatory requires that the connection cto the server is
+	// TLSMandatory requires that the connection to the server is
 	// encrypting using STARTTLS. If the server does not support STARTTLS
 	// the connection will be terminated with an error
 	TLSMandatory TLSPolicy = iota
 
-	// TLSOpportunistic tries cto establish an encrypted connection via the
+	// TLSOpportunistic tries to establish an encrypted connection via the
 	// STARTTLS protocol. If the server does not support this, it will fall
-	// back cto non-encrypted plaintext transmission
+	// back to non-encrypted plaintext transmission
 	TLSOpportunistic
 
-	// NoTLS forces the transaction cto be not encrypted
+	// NoTLS forces the transaction to be not encrypted
 	NoTLS
 )