imap_processor 1.3 → 1.5

data/lib/imap_processor/archive.rb

@@ -1,15 +1,17 @@
 require 'imap_processor'
+require "time"
 
 ##
 # Archives old mail on IMAP server by moving it to dated mailboxen.
 
 class IMAPProcessor::Archive < IMAPProcessor
-  attr_reader :list, :move
+  attr_reader :list, :move, :sep, :split
 
   def self.process_args(args)
     required_options = {
       :List => true,
       :Move => false,
+      :Split => false,
     }
 
     super __FILE__, args, required_options do |opts, options|
@@ -24,6 +26,17 @@ imap_archive archives old mail on IMAP server by moving it to dated mailboxen.
       opts.on("--[no-]move", "Move the messages (off by default)") do |move|
         options[:Move] = move
       end
+
+      opts.on("--[no-]split", "Split mailbox into multiple months (off by default)") do |move|
+        options[:Split] = move
+      end
+
+      opts.on("-s", "--sep SEPARATOR",
+              "Mailbox date separator character",
+              "Default: Read from ~/.#{@@opts_file_name}",
+              "Options file name: :Sep") do |sep|
+        options[:Sep] = sep
+      end
     end
   end
 
@@ -32,6 +45,8 @@ imap_archive archives old mail on IMAP server by moving it to dated mailboxen.
 
     @list = options[:List]
     @move = options[:Move]
+    @sep  = options[:Sep] || '.'
+    @split = options[:Split]
 
     connection = connect
 
@@ -40,7 +55,7 @@ imap_archive archives old mail on IMAP server by moving it to dated mailboxen.
 
   def the_first
     t = Time.now
-    the_first = Time.local(t.year, t.month, 1)
+    Time.local(t.year, t.month, 1)
   end
 
   def last_month
@@ -57,25 +72,55 @@ imap_archive archives old mail on IMAP server by moving it to dated mailboxen.
 
   def run
     @boxes.each do |mailbox|
-      destination = "#{mailbox}.#{last_month}"
-
       log "SELECT #{mailbox}"
-      response = imap.select mailbox
+      imap.select mailbox
 
-      search = make_search
+      uids_by_date = self.uids_by_date
 
-      log "SEARCH #{search.join ' '}"
-      uids = imap.search search
+      next if uids_by_date.empty?
 
-      next if uids.empty?
+      unless split then
+        today = Time.now
+        d = today - 86400 * today.day
+        latest = [d.year, d.month]
 
-      puts "#{uids.length} messages in #{mailbox}#{list ? ':' : ''}"
+        uids_by_date = {
+          latest => uids_by_date.values.flatten(1)
+        }
+      end
 
-      show_messages uids
+      uids_by_date.sort.each do |date, uids|
+        next if uids.empty?
+        destination = "#{mailbox}#{sep}%4d-%02d" % date
+        puts "#{destination}:"
+        puts
+        show_messages uids
+        move_messages uids, destination, false if move
+      end
 
-      move_messages uids, destination if move
+      log "EXPUNGE"
+      imap.expunge
     end
   end
 
-end
+  def uids_by_date
+    search = make_search
+    log "SEARCH #{search.join ' '}"
+    uids = imap.search search
+
+    return {} if uids.empty?
+
+    payload = imap.fetch(uids, 'BODY.PEEK[HEADER.FIELDS (DATE)]')
+
+    mail = Hash[uids.zip(payload).map { |uid, m|
+      date = m.attr["BODY[HEADER.FIELDS (DATE)]"].strip.split(/:\s*/, 2).last
+      date = Time.parse(date) rescue Time.now
+      [uid, date]
+    }]
 
+    mail.keys.group_by { |uid|
+      date = mail[uid]
+      [date.year, date.month]
+    }
+  end
+end

data/lib/imap_processor/cleanse.rb

@@ -0,0 +1,67 @@
+require 'imap_processor/client'
+
+##
+# Cleanse removes old messages from your IMAP mailboxes so you don't
+# have to!
+#
+# aka part one of my Plan for Total Email Domination.
+#
+# Cleanse doesn't remove messages you haven't read nor messages you've
+# flagged.
+
+class IMAPProcessor::Cleanse < IMAPProcessor::Client
+
+  ##
+  # Creates a new Cleanse from +options+.
+  #
+  # Options include:
+  #   +:Age+:: Delete messages older than this many days ago
+  #
+  # and all options from IMAPClient
+
+  def initialize(options)
+    super
+
+    @cleanse = options[:cleanse]
+    @boxes = @cleanse.keys
+  end
+
+  def self.process_args(args)
+    super __FILE__, args, {} do |opts, options|
+      opts.banner << <<-EOF
+imap_cleanse removes old messages from your IMAP mailboxes.
+      EOF
+    end
+  end
+
+  ##
+  # Removes read, unflagged messages from all selected mailboxes...
+
+  def run
+    super "Cleansing read, unflagged old messages",
+          [:Deleted] do
+      @imap.expunge
+      log "Expunged deleted messages"
+    end
+  end
+
+  private
+
+  ##
+  # Searches for read, unflagged messages older than :Age in the currently
+  # selected mailbox (see Net::IMAP#select).
+
+  def find_messages
+    mailbox = @boxes.find { |box| @mailbox =~ /#{box}/ } # TODO: needs more work
+    raise unless mailbox
+    age = @cleanse[mailbox]
+    before_date = (Time.now - 86400 * age).imapdate
+
+    search [
+      'NOT', 'NEW',
+      'NOT', 'FLAGGED',
+      'BEFORE', before_date
+    ], 'read, unflagged messages'
+  end
+
+end

data/lib/imap_processor/client.rb

@@ -0,0 +1,145 @@
+$TESTING = false unless defined? $TESTING
+# require 'net/imap'
+# require 'yaml'
+# require 'imap_sasl_plain'
+# require 'optparse'
+# require 'enumerator'
+
+require "imap_processor"
+
+##
+# This class only exists to transition from IMAPCleanse to imap_processor
+
+class IMAPProcessor::Client < IMAPProcessor
+
+  ##
+  # Creates a new IMAPClient from +options+.
+  #
+  # Options include:
+  #   +:Verbose+:: Verbose flag
+  #   +:Noop+:: Don't delete anything flag
+  #   +:Root+:: IMAP root path
+  #   +:Boxes+:: Comma-separated list of mailbox prefixes to search
+  #   +:Host+:: IMAP server
+  #   +:Port+:: IMAP server port
+  #   +:SSL+:: SSL flag
+  #   +:Username+:: IMAP username
+  #   +:Password+:: IMAP password
+  #   +:Auth+:: IMAP authentication type
+
+  def initialize(options)
+    super
+
+    @noop = options[:Noop]
+    @root = options[:Root]
+
+    root = @root
+    root += "/" unless root.empty?
+
+    connect options[:Host], options[:Port], options[:SSL],
+            options[:Username], options[:Password], options[:Auth]
+  end
+
+  ##
+  # Selects messages from mailboxes then marking them with +flags+.  If a
+  # block is given it is run after message marking.
+  #
+  # Unless :Noop was set, then it just prints out what it would do.
+  #
+  # Automatically called by IMAPClient::run
+
+  def run(message, flags)
+    log message
+
+    message_count = 0
+    mailboxes = find_mailboxes
+
+    mailboxes.each do |mailbox|
+      @mailbox = mailbox
+      @imap.select @mailbox
+      log "Selected #{@mailbox}"
+
+      messages = find_messages
+
+      next if messages.empty?
+
+      message_count += messages.length
+
+      unless @noop then
+        mark messages, flags
+      else
+        log "Noop - not marking"
+      end
+
+      yield messages if block_given?
+    end
+
+    log "Done. Found #{message_count} messages in #{mailboxes.length} mailboxes"
+  end
+
+  ##
+  # Connects to IMAP server +host+ at +port+ using ssl if +ssl+ is true then
+  # logs in as +username+ with +password+.  IMAPClient will really only work
+  # with PLAIN auth on SSL sockets, sorry.
+
+  def connect(host, port, ssl, username, password, auth = nil)
+    @imap = Net::IMAP.new host, port, ssl, nil, false
+    log "Connected to #{host}:#{port}"
+
+    if auth.nil? then
+      auth_caps = @imap.capability.select { |c| c =~ /^AUTH/ }
+      raise "Couldn't find a supported auth type" if auth_caps.empty?
+      auth = auth_caps.first.sub(/AUTH=/, '')
+    end
+
+    auth = auth.upcase
+    log "Trying #{auth} authentication"
+    @imap.authenticate auth, username, password
+    log "Logged in as #{username}"
+  end
+
+  ##
+  # Finds mailboxes with messages that were selected by the :Boxes option.
+
+  def find_mailboxes
+    mailboxes = @imap.list(@root, "*")
+
+    if mailboxes.nil? then
+      log "Found no mailboxes under #{@root.inspect}, you may have an incorrect root"
+      return []
+    end
+
+    mailboxes.reject! { |mailbox| mailbox.attr.include? :Noselect }
+    mailboxes.map! { |mailbox| mailbox.name }
+
+    @box_re = /^#{Regexp.escape @root}#{Regexp.union(*@boxes)}/
+
+    mailboxes.reject! { |mailbox| mailbox !~ @box_re }
+    mailboxes = mailboxes.sort_by { |m| m.downcase }
+    log "Found #{mailboxes.length} mailboxes to search:"
+    mailboxes.each { |mailbox| log "\t#{mailbox}" } if @verbose
+    return mailboxes
+  end
+
+  ##
+  # Searches for messages matching +query+ in the selected mailbox
+  # (see Net::IMAP#select).  Logs 'Scanning for +message+' before searching.
+
+  def search(query, message)
+    log "  Scanning for #{message}"
+    messages = @imap.search query
+    log "    Found #{messages.length} messages"
+    return messages
+  end
+
+  ##
+  # Marks +messages+ in the currently selected mailbox with +flags+
+  # (see Net::IMAP#store).
+
+  def mark(messages, flags)
+    messages.each_slice(500) do |chunk|
+      @imap.store chunk, '+FLAGS.SILENT', flags
+    end
+    log "Marked messages with flags"
+  end
+end

data/lib/imap_processor/flag.rb

@@ -0,0 +1,121 @@
+require 'imap_processor/client'
+
+##
+# Automatically flag your messages, yo!
+#
+# aka part two of my Plan for Total Email Domination.
+#
+# IMAPFlag flags messages you've responded to, messages you've written and
+# messages in response to messages you've written.
+#
+# If you unflag a message IMAPFlag is smart and doesn't re-flag it.
+#
+# I chose these settings because I find these messages interesting but don't
+# want to manually flag them.  Why should I do all the clicking when the
+# computer can do it for me?
+
+class IMAPProcessor::Flag < IMAPProcessor::Client
+
+  ##
+  # IMAP keyword for automatically flagged messages
+
+  AUTO_FLAG_KEYWORD = 'IMAPFLAG_AUTO_FLAGGED'
+
+  ##
+  # Message-Id query
+
+  MESSAGE_ID = 'HEADER.FIELDS (MESSAGE-ID)'
+
+  ##
+  # Creates a new IMAPFlag from +options+.
+  #
+  # Options include:
+  #   +:Email:: Email address used for sending email
+  #
+  # and all options from IMAPClient
+
+  def initialize(options)
+    super
+
+    @flag = options[:flag]
+    @boxes = @flag.keys
+  end
+
+  def self.process_args(args)
+    super __FILE__, args, {} do |opts, options|
+      opts.banner << <<-EOF
+imap_flag automatically flags your messages.
+      EOF
+    end
+  end
+
+  ##
+  # Removes read, unflagged messages from all selected mailboxes...
+
+  def run
+    super "Flagging messages", [:Flagged, AUTO_FLAG_KEYWORD]
+  end
+
+  ##
+  # Searches for messages I answered and messages I wrote.
+
+  def find_messages
+    @box = @boxes.find { |box| @mailbox =~ /#{box}/ } # TODO: needs more work
+    raise unless @box
+    @email = @flag[@box]
+    raise unless @email
+    return [answered_in_curr, wrote_in_curr, responses_in_curr].flatten
+  end
+
+  ##
+  # Answered messages in the selected mailbox.
+
+  def answered_in_curr
+    search [
+      'ANSWERED',
+      'NOT', 'FLAGGED',
+      'NOT', 'KEYWORD', AUTO_FLAG_KEYWORD
+    ], 'answered messages'
+  end
+
+  def all_email
+    @email.map { |e| "FROM #{e}" }.inject { |s,e| "OR #{s} #{e}" }
+  end
+
+  ##
+  # Messages I wrote in the selected mailbox.
+
+  def wrote_in_curr
+    search("#{self.all_email} NOT FLAGGED NOT KEYWORD AUTO_FLAG_KEYWORD",
+           "messages by #{@email.join(", ")}")
+  end
+
+  ##
+  # Messages in response to messages I wrote in the selected mailbox.
+
+  def responses_in_curr
+    log "  Scanning for responses to messages I wrote"
+    my_mail = @imap.search self.all_email
+
+    return [] if my_mail.empty?
+
+    msg_ids = @imap.fetch my_mail, "BODY.PEEK[#{MESSAGE_ID}]"
+    msg_ids.map! do |data|
+      data.attr["BODY[#{MESSAGE_ID}]"].split(':', 2).last.strip
+    end
+
+    messages = msg_ids.map do |id|
+      @imap.search([
+        'HEADER', 'In-Reply-To', id,
+        'NOT', 'FLAGGED',
+        'NOT', 'KEYWORD', AUTO_FLAG_KEYWORD
+      ])
+    end
+
+    messages.flatten!
+
+    log "    Found #{messages.length} messages"
+
+    return messages
+  end
+end