olemd/mail2couch
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions

feat: complete code formatting and linting compliance

Browse source 
- Fix all Rust clippy warnings with targeted #[allow] attributes for justified cases
- Implement server-side IMAP SEARCH keyword filtering in Go implementation
- Add graceful fallback from server-side to client-side filtering when IMAP server lacks SEARCH support
- Ensure both implementations use identical filtering logic for consistent results
- Complete comprehensive testing of filtering and attachment handling functionality
- Verify production readiness with proper linting standards for both Go and Rust

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Ole-Morten Duesund 2025-08-05 19:20:22 +02:00
commit 6c387abfbb
13 changed files with 851 additions and 432 deletions
Download patch file Download diff file Expand all files Collapse all files

6
go/config/config.go
View file

@ -45,6 +45,12 @@ type MessageFilter struct {
RecipientKeywords []string `json:"recipientKeywords,omitempty"` // Filter by keywords in recipient addresses
}
// HasKeywordFilters checks if this filter has any keyword-based filters that can use IMAP SEARCH
func (mf *MessageFilter) HasKeywordFilters() bool {
return len(mf.SubjectKeywords) > 0 || len(mf.SenderKeywords) > 0
// Note: RecipientKeywords not included as IMAP SEARCH doesn't have a reliable TO field search
}
func LoadConfig(path string) (*Config, error) {
configFile, err := os.Open(path)
if err != nil {

258
go/mail/imap.go
View file

@ -85,12 +85,12 @@ func (c *ImapClient) ListMailboxes() ([]string, error) {
// ListFilteredMailboxes lists mailboxes matching the given folder filters using IMAP LIST
func (c *ImapClient) ListFilteredMailboxes(filter *config.FolderFilter) ([]string, error) {
var allMailboxes []string
// If no include patterns, get all mailboxes
if len(filter.Include) == 0 {
return c.ListMailboxes()
}
// Use IMAP LIST with each include pattern to let the server filter
seen := make(map[string]bool)
for _, pattern := range filter.Include {
@ -100,7 +100,7 @@ func (c *ImapClient) ListFilteredMailboxes(filter *config.FolderFilter) ([]strin
log.Printf("Failed to list mailboxes with pattern '%s': %v", pattern, err)
continue
}
for _, info := range infos {
if !seen[info.Mailbox] {
allMailboxes = append(allMailboxes, info.Mailbox)
@ -108,12 +108,12 @@ func (c *ImapClient) ListFilteredMailboxes(filter *config.FolderFilter) ([]strin
}
}
}
// Apply exclude filters client-side (IMAP LIST doesn't support exclusion)
if len(filter.Exclude) == 0 {
return allMailboxes, nil
}
var filteredMailboxes []string
for _, mailbox := range allMailboxes {
excluded := false
@ -127,7 +127,7 @@ func (c *ImapClient) ListFilteredMailboxes(filter *config.FolderFilter) ([]strin
filteredMailboxes = append(filteredMailboxes, mailbox)
}
}
return filteredMailboxes, nil
}
@ -137,25 +137,25 @@ func (c *ImapClient) matchesImapPattern(pattern, name string) bool {
if pattern == name {
return true
}
// Handle simple prefix wildcard: "Work*" should match "Work/Projects"
if strings.HasSuffix(pattern, "*") && !strings.Contains(pattern[:len(pattern)-1], "*") {
prefix := strings.TrimSuffix(pattern, "*")
return strings.HasPrefix(name, prefix)
}
// Handle simple suffix wildcard: "*Temp" should match "Work/Temp"
// Handle simple suffix wildcard: "*Temp" should match "Work/Temp"
if strings.HasPrefix(pattern, "*") && !strings.Contains(pattern[1:], "*") {
suffix := strings.TrimPrefix(pattern, "*")
return strings.HasSuffix(name, suffix)
}
// Handle contains wildcard: "*Temp*" should match "Work/Temp/Archive"
if strings.HasPrefix(pattern, "*") && strings.HasSuffix(pattern, "*") {
middle := strings.Trim(pattern, "*")
return strings.Contains(name, middle)
}
// For other patterns, fall back to basic string comparison
return false
}
@ -201,15 +201,63 @@ func (c *ImapClient) GetMessages(mailbox string, since *time.Time, maxMessages i
}
uidCmd.Close()
// Determine which messages to fetch based on since date
// Determine which messages to fetch based on filtering criteria
var seqSet imap.SeqSet
if since != nil {
// Use IMAP SEARCH to find messages since the specified date
searchCriteria := &imap.SearchCriteria{
Since: *since,
}
// Use advanced search with keyword filtering when available
if messageFilter != nil && messageFilter.HasKeywordFilters() {
log.Printf("Using IMAP SEARCH with keyword filters")
uids, err := c.searchMessagesAdvanced(since, messageFilter)
if err != nil {
log.Printf("Advanced IMAP SEARCH failed, falling back to simple search: %v", err)
// Fall back to simple date-based search or fetch all
if since != nil {
searchCriteria := &imap.SearchCriteria{Since: *since}
searchCmd := c.Search(searchCriteria, nil)
searchResults, err := searchCmd.Wait()
if err != nil {
log.Printf("Simple IMAP SEARCH also failed, fetching recent messages: %v", err)
numToFetch := mbox.NumMessages
if maxMessages > 0 && int(numToFetch) > maxMessages {
numToFetch = uint32(maxMessages)
}
seqSet.AddRange(mbox.NumMessages-numToFetch+1, mbox.NumMessages)
} else {
searchSeqNums := searchResults.AllSeqNums()
if len(searchSeqNums) == 0 {
return []*Message{}, currentUIDs, nil
}
for _, seqNum := range searchSeqNums {
seqSet.AddNum(seqNum)
}
}
} else {
numToFetch := mbox.NumMessages
if maxMessages > 0 && int(numToFetch) > maxMessages {
numToFetch = uint32(maxMessages)
}
if numToFetch > 0 {
seqSet.AddRange(mbox.NumMessages-numToFetch+1, mbox.NumMessages)
}
}
} else {
// Use results from advanced search
if len(uids) == 0 {
return []*Message{}, currentUIDs, nil
}
// Limit results if maxMessages is specified
if maxMessages > 0 && len(uids) > maxMessages {
uids = uids[len(uids)-maxMessages:]
}
for _, uid := range uids {
seqSet.AddNum(uid)
}
}
} else if since != nil {
// Use simple IMAP SEARCH for date filtering only
searchCriteria := &imap.SearchCriteria{Since: *since}
searchCmd := c.Search(searchCriteria, nil)
searchResults, err := searchCmd.Wait()
if err != nil {
@ -237,7 +285,7 @@ func (c *ImapClient) GetMessages(mailbox string, since *time.Time, maxMessages i
}
}
} else {
// No since date specified, fetch recent messages up to maxMessages
// No filtering - fetch recent messages up to maxMessages
numToFetch := mbox.NumMessages
if maxMessages > 0 && int(numToFetch) > maxMessages {
numToFetch = uint32(maxMessages)
@ -274,8 +322,8 @@ func (c *ImapClient) GetMessages(mailbox string, since *time.Time, maxMessages i
continue
}
// Apply message-level keyword filtering
if messageFilter != nil && !c.ShouldProcessMessage(parsedMsg, messageFilter) {
// Apply message-level keyword filtering (only for keywords not handled by IMAP SEARCH)
if messageFilter != nil && !c.ShouldProcessMessage(parsedMsg, messageFilter, messageFilter.HasKeywordFilters()) {
continue // Skip this message due to keyword filter
}
@ -289,6 +337,137 @@ func (c *ImapClient) GetMessages(mailbox string, since *time.Time, maxMessages i
return messages, currentUIDs, nil
}
// buildOrChain creates a nested OR chain for multiple keywords
// Example: ["A", "B", "C"] becomes: A OR (B OR C)
func buildOrChain(keywords []string, headerKey string) *imap.SearchCriteria {
if len(keywords) == 0 {
return &imap.SearchCriteria{}
}
if len(keywords) == 1 {
return &imap.SearchCriteria{
Header: []imap.SearchCriteriaHeaderField{{
Key: headerKey,
Value: keywords[0],
}},
}
}
// For multiple keywords, build nested OR structure
// Start with the last keyword
result := &imap.SearchCriteria{
Header: []imap.SearchCriteriaHeaderField{{
Key: headerKey,
Value: keywords[len(keywords)-1],
}},
}
// Build the chain backwards: each previous keyword becomes "keyword OR result"
for i := len(keywords) - 2; i >= 0; i-- {
keyword := keywords[i]
keywordCriteria := &imap.SearchCriteria{
Header: []imap.SearchCriteriaHeaderField{{
Key: headerKey,
Value: keyword,
}},
}
result = &imap.SearchCriteria{
Or: [][2]imap.SearchCriteria{{
*keywordCriteria,
*result,
}},
}
}
return result
}
// searchMessagesAdvanced performs IMAP SEARCH with keyword filtering
// Returns sequence numbers of messages matching the search criteria
func (c *ImapClient) searchMessagesAdvanced(since *time.Time, messageFilter *config.MessageFilter) ([]uint32, error) {
// Build search criteria using structured approach
searchCriteria := &imap.SearchCriteria{}
// Add date filter
if since != nil {
searchCriteria.Since = *since
}
// Add subject keyword filters (use OR logic for multiple subject keywords)
if len(messageFilter.SubjectKeywords) > 0 {
if len(messageFilter.SubjectKeywords) == 1 {
// Single subject keyword - add to main criteria
searchCriteria.Header = append(searchCriteria.Header, imap.SearchCriteriaHeaderField{
Key: "Subject",
Value: messageFilter.SubjectKeywords[0],
})
} else {
// Multiple subject keywords - need to create a chain of OR conditions
// Build a nested OR structure: (A OR (B OR (C OR D)))
subjectCriteria := buildOrChain(messageFilter.SubjectKeywords, "Subject")
if len(searchCriteria.Header) > 0 || !searchCriteria.Since.IsZero() {
// Combine with existing criteria
searchCriteria.And(subjectCriteria)
} else {
*searchCriteria = *subjectCriteria
}
}
}
// Add sender keyword filters (use OR logic for multiple sender keywords)
if len(messageFilter.SenderKeywords) > 0 {
if len(messageFilter.SenderKeywords) == 1 {
// Single sender keyword - add to main criteria
searchCriteria.Header = append(searchCriteria.Header, imap.SearchCriteriaHeaderField{
Key: "From",
Value: messageFilter.SenderKeywords[0],
})
} else {
// Multiple sender keywords - need to create a chain of OR conditions
senderCriteria := buildOrChain(messageFilter.SenderKeywords, "From")
// Always use AND to combine with existing criteria
searchCriteria.And(senderCriteria)
}
}
// Add recipient keyword filters (use OR logic for multiple recipient keywords)
if len(messageFilter.RecipientKeywords) > 0 {
if len(messageFilter.RecipientKeywords) == 1 {
// Single recipient keyword - add to main criteria
searchCriteria.Header = append(searchCriteria.Header, imap.SearchCriteriaHeaderField{
Key: "To",
Value: messageFilter.RecipientKeywords[0],
})
} else {
// Multiple recipient keywords - need to create a chain of OR conditions
recipientCriteria := buildOrChain(messageFilter.RecipientKeywords, "To")
// Always use AND to combine with existing criteria
searchCriteria.And(recipientCriteria)
}
}
log.Printf("Using IMAP SEARCH with keyword filters (subject: %v, sender: %v, recipient: %v)",
messageFilter.SubjectKeywords, messageFilter.SenderKeywords, messageFilter.RecipientKeywords)
// Execute search
searchCmd := c.Search(searchCriteria, nil)
searchResults, err := searchCmd.Wait()
if err != nil {
return nil, fmt.Errorf("advanced search failed: %w", err)
}
// Convert results to sequence numbers
seqNums := searchResults.AllSeqNums()
var uids []uint32
for _, seqNum := range seqNums {
uids = append(uids, seqNum)
}
log.Printf("Found %d messages matching advanced search criteria", len(uids))
return uids, nil
}
// parseMessage parses an IMAP fetch response into our Message struct
func (c *ImapClient) parseMessage(fetchMsg *imapclient.FetchMessageData) (*Message, error) {
msg := &Message{
@ -458,27 +637,30 @@ func (c *ImapClient) parseMessagePart(entity *message.Entity, msg *Message) erro
return nil
}
// ShouldProcessMessage checks if a message should be processed based on keyword filters
func (c *ImapClient) ShouldProcessMessage(msg *Message, filter *config.MessageFilter) bool {
// Check subject keywords
if len(filter.SubjectKeywords) > 0 {
if !c.containsAnyKeyword(strings.ToLower(msg.Subject), filter.SubjectKeywords) {
return false
}
}
// Check sender keywords
if len(filter.SenderKeywords) > 0 {
senderMatch := false
for _, sender := range msg.From {
if c.containsAnyKeyword(strings.ToLower(sender), filter.SenderKeywords) {
senderMatch = true
break
// serverSideFiltered indicates if subject/sender keywords were already filtered server-side via IMAP SEARCH
func (c *ImapClient) ShouldProcessMessage(msg *Message, filter *config.MessageFilter, serverSideFiltered bool) bool {
// Skip subject and sender keyword checks if already filtered server-side
if !serverSideFiltered {
// Check subject keywords
if len(filter.SubjectKeywords) > 0 {
if !c.containsAnyKeyword(strings.ToLower(msg.Subject), filter.SubjectKeywords) {
return false
}
}
if !senderMatch {
return false
// Check sender keywords
if len(filter.SenderKeywords) > 0 {
senderMatch := false
for _, sender := range msg.From {
if c.containsAnyKeyword(strings.ToLower(sender), filter.SenderKeywords) {
senderMatch = true
break
}
}
if !senderMatch {
return false
}
}
}

4
go/main.go
View file

@ -152,7 +152,7 @@ func processImapSource(source *config.MailSource, couchClient *couch.Client, dbN
continue
}
} else {
fmt.Printf(" DRY-RUN: Would sync mailbox %s with %d current UIDs (mode: %s)\n",
fmt.Printf(" DRY-RUN: Would sync mailbox %s with %d current UIDs (mode: %s)\n",
mailbox, len(currentUIDs), source.Mode)
}
@ -200,7 +200,7 @@ func processImapSource(source *config.MailSource, couchClient *couch.Client, dbN
fmt.Printf(" DRY-RUN: Would store %d messages from %s\n", len(messages), mailbox)
// Show sample of what would be stored
if len(docs) > 0 {
fmt.Printf(" DRY-RUN: Sample message ID: %s (Subject: %s)\n",
fmt.Printf(" DRY-RUN: Sample message ID: %s (Subject: %s)\n",
docs[0].ID, docs[0].Subject)
}
}