mournmail 0.1.1 → 0.2.0

data/lib/mournmail/search_result_mode.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+using Mournmail::MessageRendering
+
+module Mournmail
+  class SearchResultMode < Mournmail::SummaryMode
+    SEARCH_RESULT_MODE_MAP = Keymap.new
+    SEARCH_RESULT_MODE_MAP.define_key(" ", :summary_read_command)
+    SEARCH_RESULT_MODE_MAP.define_key(:backspace, :summary_scroll_down_command)
+    SEARCH_RESULT_MODE_MAP.define_key("\C-h", :summary_scroll_down_command)
+    SEARCH_RESULT_MODE_MAP.define_key("\C-?", :summary_scroll_down_command)
+    SEARCH_RESULT_MODE_MAP.define_key("w", :summary_write_command)
+    SEARCH_RESULT_MODE_MAP.define_key("a", :summary_reply_command)
+    SEARCH_RESULT_MODE_MAP.define_key("A", :summary_reply_command)
+    SEARCH_RESULT_MODE_MAP.define_key("f", :summary_forward_command)
+    SEARCH_RESULT_MODE_MAP.define_key("v", :summary_view_source_command)
+    SEARCH_RESULT_MODE_MAP.define_key("q", :search_result_close_command)
+    SEARCH_RESULT_MODE_MAP.define_key("k", :previous_line)
+    SEARCH_RESULT_MODE_MAP.define_key("j", :next_line)
+    SEARCH_RESULT_MODE_MAP.define_key("<", :previous_page_command)
+    SEARCH_RESULT_MODE_MAP.define_key(">", :next_page_command)
+    SEARCH_RESULT_MODE_MAP.define_key("/", :summary_search_command)
+    SEARCH_RESULT_MODE_MAP.define_key("t", :summary_show_thread_command)
+
+    def initialize(buffer)
+      super(buffer)
+      buffer.keymap = SEARCH_RESULT_MODE_MAP
+    end
+
+    define_local_command(:summary_read, doc: "Read a mail.") do
+      num = scroll_up_or_current_number
+      return if num.nil?
+      Mournmail.background do
+        message = @buffer[:messages][num]
+        if message.nil?
+          raise EditorError, "No message found"
+        end
+        mail = Mail.new(Mournmail.read_mail_cache(message._key))
+        next_tick do
+          show_message(mail)
+          @buffer[:message_number] = num
+        end
+      end
+    end
+
+    define_local_command(:summary_scroll_down,
+                         doc: "Scroll down the current message.") do
+      num = @buffer.current_line
+      if num == @buffer[:message_number]
+        window = Mournmail.message_window
+        if window.buffer.name == "*message*"
+          old_window = Window.current
+          begin
+            Window.current = window
+            scroll_down
+            return
+          ensure
+            Window.current = old_window
+          end
+        end
+      end
+    end
+
+    define_local_command(:search_result_close,
+                         doc: "Close the search result.") do
+      if @buffer.name == "*thread*"
+        buf = Buffer["*search result*"] || "*summary*"
+      else
+        buf = "*summary*"
+      end
+      kill_buffer(@buffer)
+      switch_to_buffer(buf)
+    end
+
+    define_local_command(:previous_page,
+                         doc: "Show the previous page.") do
+      messages = @buffer[:messages]
+      page = messages.current_page - 1
+      if page < 1
+        raise EditorError, "No more page."
+      end
+      summary_search(@buffer[:query], page)
+    end
+
+    define_local_command(:next_page,
+                         doc: "Show the next page.") do
+      messages = @buffer[:messages]
+      page = messages.current_page + 1
+      if page > messages.n_pages
+        raise EditorError, "No more page."
+      end
+      summary_search(@buffer[:query], page)
+    end
+
+    private
+
+    def scroll_up_or_current_number
+      begin
+        num = @buffer.current_line
+        if num == @buffer[:message_number]
+          window = Mournmail.message_window
+          if window.buffer.name == "*message*"
+            old_window = Window.current
+            begin
+              Window.current = window
+              scroll_up
+              return nil
+            ensure
+              Window.current = old_window
+            end
+          end
+        end
+        num
+      rescue RangeError # may be raised by scroll_up
+        next_message
+        retry
+      end
+    end
+
+    def read_current_mail
+      message = @buffer[:messages][@buffer.current_line]
+      if message.nil?
+        raise EditorError, "No message found"
+      end
+      [Mail.new(Mournmail.read_mail_cache(message._key)), false]
+    end
+
+    def next_message
+      @buffer.end_of_line
+      if @buffer.end_of_buffer?
+        raise EditorError, "No more mail"
+      end
+      @buffer.forward_line
+    end
+
+    def current_message
+      message = @buffer[:messages][@buffer.current_line]
+      if message.nil?
+        raise EditorError, "No message found"
+      end
+      message
+    end
+  end
+end

data/lib/mournmail/summary.rb

@@ -7,18 +7,39 @@ require "monitor"
 module Mournmail
   class Summary
     attr_reader :items, :last_uid
+    attr_accessor :uidvalidity
 
     include MonitorMixin
 
+    LOCK_OPERATIONS = Hash.new(:unknown_mode)
+    LOCK_OPERATIONS[:shared] = File::LOCK_SH
+    LOCK_OPERATIONS[:exclusive] = File::LOCK_EX
+
+    def self.lock_cache(mailbox, mode)
+      File.open(Summary.cache_lock_path(mailbox), "w", 0600) do |f|
+        f.flock(LOCK_OPERATIONS[mode])
+        yield
+      end
+    end
+
     def self.cache_path(mailbox)
       File.join(Mournmail.mailbox_cache_path(mailbox), ".summary")
     end
 
+    def self.cache_lock_path(mailbox)
+      cache_path(mailbox) + ".lock"
+    end
+
+    def self.cache_tmp_path(mailbox)
+      cache_path(mailbox) + ".tmp"
+    end
+
     def self.load(mailbox)
-      File.open(cache_path(mailbox)) { |f|
-        f.flock(File::LOCK_SH)
-        Marshal.load(f)
-      }
+      lock_cache(mailbox, :shared) do
+        File.open(cache_path(mailbox)) do |f|
+          Marshal.load(f)
+        end
+      end
     end
 
     def self.load_or_new(mailbox)
@@ -34,6 +55,7 @@ module Mournmail
       @message_id_table = {}
       @uid_table = {}
       @last_uid = nil
+      @uidvalidity = nil
     end
 
     DUMPABLE_VARIABLES = [
@@ -41,7 +63,8 @@ module Mournmail
       :@items,
       :@message_id_table,
       :@uid_table,
-      :@last_uid
+      :@last_uid,
+      :@uidvalidity
     ]
 
     def marshal_dump
@@ -92,13 +115,43 @@ module Mournmail
       end
     end
 
+    def read_mail(uid)
+      synchronize do
+        item = @uid_table[uid]
+        if item.cache_id
+          File.open(Mournmail.mail_cache_path(item.cache_id)) do |f|
+            [Mail.new(f.read), false]
+          end
+        else
+          Mournmail.imap_connect do |imap|
+            imap.select(@mailbox)
+            data = imap.uid_fetch(uid, "BODY[]")
+            if data.empty?
+              raise EditorError, "No such mail: #{uid}"
+            end
+            s = data[0].attr["BODY[]"]
+            mail = Mail.new(s)
+            if @mailbox != Mournmail.account_config[:spam_mailbox]
+              item.cache_id = Mournmail.write_mail_cache(s)
+              Mournmail.index_mail(item.cache_id, mail)
+            end
+            [mail, true]
+          end
+        end
+      end
+    end
+
     def save
       synchronize do
         path = Summary.cache_path(@mailbox)
         FileUtils.mkdir_p(File.dirname(path))
-        File.open(Summary.cache_path(@mailbox), "w", 0600) do |f|
-          f.flock(File::LOCK_EX)
-          Marshal.dump(self, f)
+        Summary.lock_cache(@mailbox, :exclusive) do
+          cache_path = Summary.cache_path(@mailbox)
+          tmp_path = Summary.cache_tmp_path(@mailbox)
+          File.open(tmp_path, "w", 0600) do |f|
+            Marshal.dump(self, f)
+          end
+          File.rename(tmp_path, cache_path)
         end
       end
     end
@@ -115,6 +168,7 @@ module Mournmail
   class SummaryItem
     attr_reader :uid, :date, :from, :subject, :flags
     attr_reader :replies
+    attr_accessor :cache_id
     
     def initialize(uid, date, from, subject, flags)
       @uid = uid
@@ -124,6 +178,7 @@ module Mournmail
       @flags = flags
       @line = nil
       @replies = []
+      @cache_id = nil
     end
     
     def add_reply(reply)

data/lib/mournmail/summary_mode.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "tempfile"
-
 using Mournmail::MessageRendering
 
 module Mournmail
@@ -20,18 +18,32 @@ module Mournmail
     SUMMARY_MODE_MAP.define_key("u", :summary_toggle_seen_command)
     SUMMARY_MODE_MAP.define_key("$", :summary_toggle_flagged_command)
     SUMMARY_MODE_MAP.define_key("d", :summary_toggle_deleted_command)
-    SUMMARY_MODE_MAP.define_key("x", :summary_expunge_command)
+    SUMMARY_MODE_MAP.define_key("x", :summary_toggle_mark_command)
+    SUMMARY_MODE_MAP.define_key("*a", :summary_mark_all_command)
+    SUMMARY_MODE_MAP.define_key("*n", :summary_unmark_all_command)
+    SUMMARY_MODE_MAP.define_key("*r", :summary_mark_read_command)
+    SUMMARY_MODE_MAP.define_key("*u", :summary_mark_unread_command)
+    SUMMARY_MODE_MAP.define_key("*s", :summary_mark_flagged_command)
+    SUMMARY_MODE_MAP.define_key("*t", :summary_mark_unflagged_command)
+    SUMMARY_MODE_MAP.define_key("y", :summary_archive_command)
+    SUMMARY_MODE_MAP.define_key("o", :summary_refile_command)
+    SUMMARY_MODE_MAP.define_key("p", :summary_prefetch_command)
+    SUMMARY_MODE_MAP.define_key("X", :summary_expunge_command)
     SUMMARY_MODE_MAP.define_key("v", :summary_view_source_command)
+    SUMMARY_MODE_MAP.define_key("M", :summary_merge_partial_command)
     SUMMARY_MODE_MAP.define_key("q", :mournmail_quit)
     SUMMARY_MODE_MAP.define_key("k", :previous_line)
     SUMMARY_MODE_MAP.define_key("j", :next_line)
     SUMMARY_MODE_MAP.define_key("m", :mournmail_visit_mailbox)
+    SUMMARY_MODE_MAP.define_key("/", :summary_search_command)
+    SUMMARY_MODE_MAP.define_key("t", :summary_show_thread_command)
+    SUMMARY_MODE_MAP.define_key("@", :summary_change_account_command)
 
-    define_syntax :seen, /^ *\d+  .*/
-    define_syntax :unseen, /^ *\d+ u.*/
-    define_syntax :flagged, /^ *\d+ \$.*/
-    define_syntax :deleted, /^ *\d+ d.*/
-    define_syntax :answered, /^ *\d+ a.*/
+    define_syntax :seen, /^ *\d+[ *] .*/
+    define_syntax :unseen, /^ *\d+[ *]u.*/
+    define_syntax :flagged, /^ *\d+[ *]\$.*/
+    define_syntax :deleted, /^ *\d+[ *]d.*/
+    define_syntax :answered, /^ *\d+[ *]a.*/
 
     def initialize(buffer)
       super(buffer)
@@ -41,22 +53,11 @@ module Mournmail
     define_local_command(:summary_read, doc: "Read a mail.") do
       uid = scroll_up_or_next_uid
       return if uid.nil?
+      summary = Mournmail.current_summary
       Mournmail.background do
-        mailbox = Mournmail.current_mailbox
-        s, fetched = Mournmail.read_mail(mailbox, uid)
-        mail = Mail.new(s)
-        message = mail.render
+        mail, fetched = summary.read_mail(uid)
         next_tick do
-          message_buffer = Buffer.find_or_new("*message*",
-                                              undo_limit: 0, read_only: true)
-          message_buffer.apply_mode(Mournmail::MessageMode)
-          message_buffer.read_only_edit do
-            message_buffer.clear
-            message_buffer.insert(message)
-            message_buffer.beginning_of_buffer
-          end
-          window = Mournmail.message_window
-          window.buffer = message_buffer
+          show_message(mail)
           mark_as_seen(uid, !fetched)
           Mournmail.current_uid = uid
           Mournmail.current_mail = mail
@@ -97,10 +98,8 @@ module Mournmail
     define_local_command(:summary_reply,
                          doc: "Reply to the current message.") do
       |reply_all = current_prefix_arg|
-      uid = selected_uid
       Mournmail.background do
-        mailbox = Mournmail.current_mailbox
-        mail = Mail.new(Mournmail.read_mail(mailbox, uid)[0])
+        mail = read_current_mail[0]
         body = mail.render_body
         next_tick do
           Window.current = Mournmail.message_window
@@ -117,13 +116,20 @@ module Mournmail
             insert(mail.reply_to&.join(", ") || mail.from&.join(", "))
           end
           re_search_forward(/^Subject: /)
-          subject = mail["subject"].to_s
+          subject = mail["subject"].to_s.gsub(/\t/, " ")
           if /\Are:/i !~ subject
             insert("Re: ")
           end
           insert(subject)
-          if mail['message-id']
-            insert("\nIn-Reply-To: #{mail['message-id']}")
+          references = mail.references ?
+            Array(mail.references) : Array(mail.in_reply_to)
+          if mail.message_id
+            insert("\nIn-Reply-To: <#{mail.message_id}>")
+            references.push(mail.message_id)
+          end
+          if !references.empty?
+            refs = references.map { |id| "<#{id}>" }.join(" ")
+            insert("\nReferences: " + refs)
           end
           end_of_buffer
           push_mark
@@ -141,14 +147,12 @@ module Mournmail
 
     define_local_command(:summary_forward,
                          doc: "Forward the current message.") do
-      uid = selected_uid
-      summary = Mournmail.current_summary
-      item = summary[uid]
+      message = current_message
       Window.current = Mournmail.message_window
       Commands.mail
       re_search_forward(/^Subject: /)
-      insert("Forward: " + Mournmail.decode_eword(item.subject))
-      insert("\nAttached-Message: #{Mournmail.current_mailbox}/#{uid}")
+      insert("Forward: " + message.subject)
+      insert("\nAttached-Message: #{message._key}")
       re_search_backward(/^To: /)
       end_of_line
     end
@@ -170,18 +174,72 @@ module Mournmail
       toggle_flag(selected_uid, :Deleted)
     end
 
+    define_local_command(:summary_toggle_mark, doc: "Toggle mark.") do
+      @buffer.read_only_edit do
+        @buffer.save_excursion do
+          @buffer.beginning_of_line
+          if @buffer.looking_at?(/( *\d+)([ *])/)
+            uid = @buffer.match_string(1)
+            old_mark = @buffer.match_string(2)
+            new_mark = old_mark == "*" ? " " : "*"
+            @buffer.replace_match(uid + new_mark)
+          end
+        end
+      end
+    end
+
+    define_local_command(:summary_mark_all, doc: "Mark all mails.") do
+      gsub_buffer(/^( *\d+) /, '\\1*')
+    end
+
+    define_local_command(:summary_unmark_all, doc: "Unmark all mails.") do
+      gsub_buffer(/^( *\d+)\*/, '\\1 ')
+    end
+
+    define_local_command(:summary_mark_read, doc: "Mark read mails.") do
+      gsub_buffer(/^( *\d+) ([^u])/, '\\1*\\2')
+    end
+
+    define_local_command(:summary_mark_unread, doc: "Mark unread mails.") do
+      gsub_buffer(/^( *\d+) u/, '\\1*u')
+    end
+
+    define_local_command(:summary_mark_flagged, doc: "Mark flagged mails.") do
+      gsub_buffer(/^( *\d+) \$/, '\\1*$')
+    end
+
+    define_local_command(:summary_mark_unflagged,
+                         doc: "Mark unflagged mails.") do
+      gsub_buffer(/^( *\d+) ([^$])/, '\\1*\\2')
+    end
+
     define_local_command(:summary_expunge,
                          doc: <<~EOD) do
         Expunge deleted messages.
       EOD
       buffer = Buffer.current
+      mailbox = Mournmail.current_mailbox
+      summary = Mournmail.current_summary
       Mournmail.background do
         Mournmail.imap_connect do |imap|
           imap.expunge
         end
-        summary = Mournmail.current_summary
         summary.delete_item_if do |item|
-          item.flags.include?(:Deleted)
+          if item.flags.include?(:Deleted)
+            if item.cache_id
+              begin
+                File.unlink(Mournmail.mail_cache_path(item.cache_id))
+              rescue Errno::ENOENT
+              end
+              begin
+                Groonga["Messages"].delete(item.cache_id)
+              rescue Groonga::InvalidArgument
+              end
+              true
+            end
+          else
+            false
+          end
         end
         summary_text = summary.to_s
         summary.save
@@ -199,15 +257,14 @@ module Mournmail
                          doc: "View source of a mail.") do
       uid = selected_uid
       Mournmail.background do
-        mailbox = Mournmail.current_mailbox
-        source, = Mournmail.read_mail(mailbox, uid)
+        mail, = read_current_mail
         next_tick do
           source_buffer = Buffer.find_or_new("*message-source*",
                                              file_encoding: "ascii-8bit",
                                              undo_limit: 0, read_only: true)
           source_buffer.read_only_edit do
             source_buffer.clear
-            source_buffer.insert(source.gsub(/\r\n/, "\n"))
+            source_buffer.insert(mail.raw_source.gsub(/\r\n/, "\n"))
             source_buffer.file_format = :dos
             source_buffer.beginning_of_buffer
           end
@@ -217,6 +274,190 @@ module Mournmail
       end
     end
 
+    define_local_command(:summary_merge_partial,
+                         doc: "Merge marked message/partial.") do
+      uids = []
+      @buffer.save_excursion do
+        @buffer.beginning_of_buffer
+        while @buffer.re_search_forward(/^( *\d+)\*/, raise_error: false)
+          uid = @buffer.match_string(0).to_i
+          # @buffer.replace_match(@buffer.match_string(0) + " ")
+          uids.push(uid)
+        end
+      end
+      summary = Mournmail.current_summary
+      Mournmail.background do
+        id = nil
+        total = nil
+        mails = uids.map { |uid|
+          summary.read_mail(uid)[0]
+        }.select { |mail|
+          mail.main_type == "message" &&
+            mail.sub_type == "partial" #&&
+            (id ||= mail["Content-Type"].parameters["id"]) ==
+            mail["Content-Type"].parameters["id"] &&
+            (total ||= mail["Content-Type"].parameters["total"]&.to_i)
+        }.sort_by { |mail|
+          mail["Content-Type"].parameters["number"].to_i
+        }
+        if mails.length != total
+          raise EditorError, "No enough messages (#{mails.length} of #{total})"
+        end
+        s = mails.map { |mail| mail.body.decoded }.join
+        mail = Mail.new(s)
+        next_tick do
+          show_message(mail)
+          Mournmail.current_uid = nil
+          Mournmail.current_mail = mail
+        end
+      end
+    end
+
+    define_local_command(:summary_archive,
+                         doc: "Archive marked mails.") do
+      archive_mailbox_format =
+        Mournmail.account_config[:archive_mailbox_format]
+      if archive_mailbox_format.nil?
+        raise EditorError, "No archive_mailbox_format in the current account"
+      end
+      uids = marked_uids
+      summary = Mournmail.current_summary
+      now = Time.now
+      if archive_mailbox_format == false
+        mailboxes = { nil => uids }
+      else
+        mailboxes = uids.map { |uid| summary[uid] }.group_by { |item|
+          t = Time.parse(item.date) rescue now
+          t.strftime(archive_mailbox_format)
+        }.transform_values { |items|
+          items.map(&:uid)
+        }
+      end
+      source_mailbox = Mournmail.current_mailbox
+      if mailboxes.key?(source_mailbox)
+        raise EditorError, "Can't archive mails in archive mailboxes"
+      end
+      Mournmail.background do
+        Mournmail.imap_connect do |imap|
+          mailboxes.each do |mailbox, item_uids|
+            if mailbox && !imap.list("", mailbox)
+              imap.create(mailbox)
+            end
+            refile_mails(imap, source_mailbox, item_uids, mailbox)
+          end
+          imap.expunge
+          delete_from_summary(summary, uids, "Archived messages")
+        end
+      end
+    end
+
+    define_local_command(:summary_refile,
+                         doc: "Refile marked mails.") do
+      |mailbox = Mournmail.read_mailbox_name("Refile mails: ")|
+      uids = marked_uids
+      summary = Mournmail.current_summary
+      source_mailbox = Mournmail.current_mailbox
+      if source_mailbox == mailbox
+        raise EditorError, "Can't refile to the same mailbox"
+      end
+      Mournmail.background do
+        Mournmail.imap_connect do |imap|
+          unless imap.list("", mailbox)
+            if next_tick! { yes_or_no?("#{mailbox} doesn't exist; Create?") }
+              imap.create(mailbox)
+            else
+              next
+            end
+          end
+          refile_mails(imap, source_mailbox, uids, mailbox)
+          delete_from_summary(summary, uids, "Refiled messages")
+        end
+      end
+    end
+
+    define_local_command(:summary_prefetch,
+                         doc: "Prefetch mails.") do
+      summary = Mournmail.current_summary
+      mailbox = Mournmail.current_mailbox
+      target_uids = @buffer.to_s.scan(/^ *\d+/).map { |s|
+        s.to_i
+      }.select { |uid|
+        summary[uid].cache_id.nil?
+      }
+      Mournmail.background do
+        Mournmail.imap_connect do |imap|
+          imap.select(mailbox)
+          count = 0
+          begin
+            target_uids.each_slice(20) do |uids|
+              data = imap.uid_fetch(uids, "BODY[]")
+              data.each do |i|
+                uid = i.attr["UID"]
+                s = i.attr["BODY[]"]
+                if s
+                  cache_id = Mournmail.write_mail_cache(s)
+                  if mailbox != Mournmail.account_config[:spam_mailbox]
+                    Mournmail.index_mail(cache_id, Mail.new(s))
+                  end
+                  summary[uid].cache_id = cache_id
+                end
+              end
+              count += uids.size
+              progress = (count.to_f * 100 / target_uids.size).round
+              next_tick do
+                message("Prefetching mails... #{progress}%", log: false)
+              end
+            end
+          ensure
+            summary.save
+          end
+        end
+        next_tick do
+          message("Done")
+        end
+      end
+    end
+    
+    define_local_command(:summary_search, doc: "Search mails.") do
+      |query = read_from_minibuffer("Search mail: ",
+                                    initial_value: @buffer[:query]),
+        page = 1|
+      Mournmail.background do
+        messages = Groonga["Messages"].select { |record|
+          record.match(query) { |match_record|
+            match_record.subject | match_record.body
+          }
+        }.paginate([["date", :desc]], page: page, size: 100)
+        next_tick do
+          show_search_result(messages, query: query)
+          message("Searched (#{messages.current_page}/#{messages.n_pages})")
+        end
+      end
+    end
+
+    define_local_command(:summary_show_thread,
+                         doc: "Show the thread of the current mail.") do
+      Mournmail.background do
+        message = current_message
+        messages = Groonga["Messages"].select { |m|
+          m.thread_id == message.thread_id
+        }.sort([["date", :asc]])
+        next_tick do
+          show_search_result(messages, buffer_name: "*thread*")
+          i = messages.find_index { |m| m._key == message._key }
+          Buffer.current.goto_line(i + 1)
+        end
+      end
+    end
+
+    define_local_command(:summary_change_account,
+                         doc: "Change the current account.") do
+      |account = read_account_name("Change account: ")|
+      mournmail_quit
+      Mournmail.current_account = account
+      mournmail
+    end
+
     private
 
     def selected_uid
@@ -231,6 +472,16 @@ module Mournmail
       }
     end
 
+    def marked_uids
+      @buffer.to_s.scan(/^ *\d+(?=\*)/).map(&:to_i)
+    end
+
+    def read_current_mail
+      summary = Mournmail.current_summary
+      uid = selected_uid
+      summary.read_mail(uid)
+    end
+
     def scroll_up_or_next_uid
       begin
         uid = selected_uid
@@ -254,6 +505,20 @@ module Mournmail
       end
     end
 
+    def show_message(mail)
+      message_buffer = Buffer.find_or_new("*message*",
+                                          undo_limit: 0, read_only: true)
+      message_buffer.apply_mode(Mournmail::MessageMode)
+      message_buffer.read_only_edit do
+        message_buffer.clear
+        message_buffer.insert(mail.render)
+        message_buffer.beginning_of_buffer
+      end
+      message_buffer[:mournmail_mail] = mail
+      window = Mournmail.message_window
+      window.buffer = message_buffer
+    end
+        
     def mark_as_seen(uid, update_server)
       summary_item = Mournmail.current_summary[uid]
       if summary_item && !summary_item.flags.include?(:Seen)
@@ -300,5 +565,108 @@ module Mournmail
         @buffer.forward_line
       end
     end
+
+    def gsub_buffer(re, s)
+      @buffer.read_only_edit do
+        s = @buffer.to_s.gsub(re, s)
+        @buffer.replace(s)
+      end
+    end
+
+    def show_search_result(messages,
+                           query: nil, buffer_name: "*search result*")
+      summary_text = messages.map { |m|
+        format("%s [ %s ] %s\n",
+               m.date.strftime("%m/%d %H:%M"),
+               ljust(m.from.to_s, 16),
+               ljust(m.subject.to_s, 45))
+      }.join
+      buffer = Buffer.find_or_new(buffer_name, undo_limit: 0,
+                                  read_only: true)
+      buffer.apply_mode(Mournmail::SearchResultMode)
+      buffer.read_only_edit do
+        buffer.clear
+        buffer.insert(summary_text)
+        buffer.beginning_of_buffer
+      end
+      buffer[:messages] = messages
+      buffer[:query] = query
+      switch_to_buffer(buffer)
+    end
+
+    def ljust(s, n)
+      width = 0
+      str = String.new
+      s.gsub(/\t/, " ").each_char do |c|
+        w = Buffer.display_width(c)
+        width += w
+        if width > n
+          width -= w
+          break
+        end
+        str.concat(c)
+        break if width == n
+      end
+      str + " " * (n - width)
+    end
+
+    def refile_mails(imap, src_mailbox, uids, dst_mailbox)
+      count = 0
+      uids.each_slice(100) do |uid_set|
+        if dst_mailbox
+          imap.uid_copy(uid_set, dst_mailbox) 
+        end
+        imap.uid_store(uid_set, "+FLAGS", [:Deleted])
+        count += uid_set.size
+        progress = (count.to_f * 100 / uids.size).round
+        next_tick do
+          if dst_mailbox
+            message("Refiling mails to #{dst_mailbox}... #{progress}%",
+                    log: false)
+          else
+            message("Deleting mails... #{progress}%", log: false)
+          end 
+        end
+      end
+      next_tick do
+        if dst_mailbox
+          message("Refiled mails to #{dst_mailbox}")
+        else
+          message("Deleted mails")
+        end
+      end
+    end
+
+    def current_message
+      uid = selected_uid
+      item = Mournmail.current_summary[uid]
+      message = Groonga["Messages"][item.cache_id]
+      if message.nil?
+        raise EditorError, "No message found"
+      end
+      message
+    end
+
+    def read_account_name(prompt, **opts)
+      f = ->(s) {
+        complete_for_minibuffer(s, CONFIG[:mournmail_accounts].keys)
+      }
+      read_from_minibuffer(prompt, completion_proc: f, **opts)
+    end
+
+    def delete_from_summary(summary, uids, msg)
+      summary.delete_item_if do |item|
+        uids.include?(item.uid)
+      end
+      summary_text = summary.to_s
+      summary.save
+      next_tick do
+        @buffer.read_only_edit do
+          @buffer.clear
+          @buffer.insert(summary_text)
+        end
+        message(msg)
+      end
+    end
   end
 end