mournmail 0.1.0

data/lib/mournmail/summary.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+
+require "time"
+require "fileutils"
+require "monitor"
+
+module Mournmail
+  class Summary
+    attr_reader :items, :last_uid
+
+    include MonitorMixin
+
+    def self.cache_path(mailbox)
+      File.expand_path("cache/#{mailbox}/.summary",
+                       CONFIG[:mournmail_directory])
+    end
+
+    def self.load(mailbox)
+      File.open(cache_path(mailbox)) { |f|
+        f.flock(File::LOCK_SH)
+        Marshal.load(f)
+      }
+    end
+
+    def self.load_or_new(mailbox)
+      load(mailbox)
+    rescue Errno::ENOENT
+      new(mailbox)
+    end
+
+    def initialize(mailbox)
+      super()
+      @mailbox = mailbox
+      @items = []
+      @message_id_table = {}
+      @uid_table = {}
+      @last_uid = nil
+    end
+
+    DUMPABLE_VARIABLES = [
+      :@mailbox,
+      :@items,
+      :@message_id_table,
+      :@uid_table,
+      :@last_uid
+    ]
+
+    def marshal_dump
+      DUMPABLE_VARIABLES.each_with_object({}) { |var, h|
+        h[var] = instance_variable_get(var)
+      }
+    end
+
+    def marshal_load(data)
+      mon_initialize
+      data.each do |var, val|
+        instance_variable_set(var, val)
+      end
+    end
+
+    def add_item(item, message_id, in_reply_to)
+      synchronize do
+        parent = @message_id_table[in_reply_to]
+        if parent
+          parent.add_reply(item)
+        else
+          @items.push(item)
+        end
+        if message_id
+          @message_id_table[message_id] = item
+        end
+        @uid_table[item.uid] = item
+        @last_uid = item.uid
+      end
+    end
+
+    def delete_item_if(&block)
+      synchronize do
+        @items = @items.flat_map { |item|
+          item.delete_reply_if(&block)
+          if yield(item)
+            item.replies
+          else
+            [item]
+          end
+        }
+      end
+    end
+
+    def [](uid)
+      synchronize do
+        @uid_table[uid]
+      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)
+        end
+      end
+    end
+
+    def to_s
+      synchronize do
+        items.each_with_object(String.new) do |item, s|
+          s << item.to_s
+        end
+      end
+    end
+  end
+  
+  class SummaryItem
+    attr_reader :uid, :date, :from, :subject, :flags
+    attr_reader :replies
+    
+    def initialize(uid, date, from, subject, flags)
+      @uid = uid
+      @date = date
+      @from = from
+      @subject = subject
+      @flags = flags
+      @line = nil
+      @replies = []
+    end
+    
+    def add_reply(reply)
+      @replies << reply
+    end
+
+    def delete_reply_if(&block)
+      @replies = @replies.flat_map { |reply|
+        reply.delete_reply_if(&block)
+        if yield(reply)
+          reply.replies
+        else
+          [reply]
+        end
+      }
+    end
+    
+    def to_s(limit = 78, from_limit = 16, level = 0)
+      @line ||= format_line(limit, from_limit, level)
+      return @line if @replies.empty?
+      s = @line.dup
+      child_level = level + 1
+      @replies.each do |reply|
+        s << reply.to_s(limit, from_limit, child_level)
+      end
+      s
+    end
+
+    def set_flag(flag, update_server: true)
+      if !@flags.include?(flag)
+        update_flag("+", flag, update_server: update_server)
+      end
+    end
+
+    def unset_flag(flag, update_server: true)
+      if @flags.include?(flag)
+        update_flag("-", flag, update_server: update_server)
+      end
+    end
+
+    def toggle_flag(flag, update_server: true)
+      sign = @flags.include?(flag) ? "-" : "+"
+      update_flag(sign, flag, update_server: update_server)
+    end
+
+    def flags_char
+      format_flags(@flags)
+    end
+    
+    private
+
+    def format_line(limit = 78, from_limit = 16, level = 0)
+      space = "  " * (level < 8 ? level : 8)
+      s = String.new
+      s << format("%s %s%s %s[ %s ] ",
+                  @uid, format_flags(@flags), format_date(@date), space,
+                  ljust(format_from(@from), from_limit))
+      s << ljust(decode_eword(@subject.to_s), limit - Buffer.display_width(s))
+      s << "\n"
+      s
+    end
+    
+    def ljust(s, n)
+      width = 0
+      str = String.new
+      s.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 format_flags(flags)
+      if flags.include?(:Deleted)
+        "d"
+      elsif flags.include?(:Flagged)
+        "$"
+      elsif flags.include?(:Answered)
+        "a"
+      elsif !flags.include?(:Seen)
+        "u"
+      else
+        " "
+      end
+    end
+    
+    def format_date(date)
+      (Time.parse(date) rescue Time.at(0)).localtime.strftime("%m/%d %H:%M")
+    end
+    
+    def format_from(from)
+      addr = from&.[](0)
+      if addr.nil? || addr.mailbox.nil?
+        return "Unknown sender"
+      end
+      mailbox = Mournmail.escape_binary(addr.mailbox)
+      host = Mournmail.escape_binary(addr.host.to_s)
+      if addr.name
+        "#{decode_eword(addr.name)} <#{mailbox}@#{host}>"
+      else
+        "#{mailbox}@#{host}"
+      end
+    end 
+    
+    def decode_eword(s)
+      Mournmail.decode_eword(s)
+    end
+
+    def update_flag(sign, flag, update_server: true)
+      if update_server
+        Mournmail.imap_connect do |imap|
+          data = imap.uid_store(@uid, "#{sign}FLAGS", [flag]).first
+          @flags = data.attr["FLAGS"]
+        end
+      else
+        case
+        when "+"
+          @flags.push(flag)
+        when "-"
+          @flags.delete(flag)
+        end
+      end
+      if @line
+        s = format("%s %s", @uid, format_flags(@flags))
+        @line.sub!(/^\d+ ./, s)
+      end
+    end
+  end
+end

data/lib/mournmail/summary_mode.rb

@@ -0,0 +1,303 @@
+# frozen_string_literal: true
+
+require "tempfile"
+
+using Mournmail::MessageRendering
+
+module Mournmail
+  class SummaryMode < Textbringer::Mode
+    SUMMARY_MODE_MAP = Keymap.new
+    SUMMARY_MODE_MAP.define_key("s", :mournmail_summary_sync)
+    SUMMARY_MODE_MAP.define_key(" ", :summary_read_command)
+    SUMMARY_MODE_MAP.define_key(:backspace, :summary_scroll_down_command)
+    SUMMARY_MODE_MAP.define_key("\C-h", :summary_scroll_down_command)
+    SUMMARY_MODE_MAP.define_key("\C-?", :summary_scroll_down_command)
+    SUMMARY_MODE_MAP.define_key("n", :summary_next_command)
+    SUMMARY_MODE_MAP.define_key("w", :summary_write_command)
+    SUMMARY_MODE_MAP.define_key("a", :summary_reply_command)
+    SUMMARY_MODE_MAP.define_key("A", :summary_reply_command)
+    SUMMARY_MODE_MAP.define_key("f", :summary_forward_command)
+    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("v", :summary_view_source_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)
+
+    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)
+      buffer.keymap = SUMMARY_MODE_MAP
+    end
+
+    define_local_command(:summary_read, doc: "Read a mail.") do
+      uid = scroll_up_or_next_uid
+      return if uid.nil?
+      Mournmail.background do
+        mailbox = Mournmail.current_mailbox
+        mail = Mail.new(Mournmail.read_mail(mailbox, uid))
+        message = mail.render
+        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
+          mark_as_seen(uid)
+          Mournmail.current_uid = uid
+          Mournmail.current_mail = mail
+        end
+      end
+    end
+
+    define_local_command(:summary_scroll_down,
+                         doc: "Scroll down the current message.") do
+      uid = selected_uid
+      if uid == Mournmail.current_uid
+        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(:summary_next,
+                         doc: "Display the next mail.") do
+      next_message
+      summary_read
+    end
+
+    define_local_command(:summary_write,
+                         doc: "Write a new mail.") do
+      Window.current = Mournmail.message_window
+      Commands.mail
+    end
+
+    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))
+        body = mail.render_body
+        next_tick do
+          Window.current = Mournmail.message_window
+          Commands.mail(run_hooks: false)
+          if reply_all
+            insert(mail.from&.join(", "))
+            cc_addrs = [mail.reply_to, mail.to, mail.cc].flat_map { |addrs|
+              addrs || []
+            }.uniq.reject { |addr|
+              mail.from&.include?(addr)
+            }
+            insert("\nCc: " + cc_addrs.join(", "))
+          else
+            insert(mail.reply_to&.join(", ") || mail.from&.join(", "))
+          end
+          re_search_forward(/^Subject: /)
+          subject = mail["subject"].to_s
+          if /\Are:/i !~ subject
+            insert("Re: ")
+          end
+          insert(subject)
+          if mail['message-id']
+            insert("\nIn-Reply-To: #{mail['message-id']}")
+          end
+          end_of_buffer
+          push_mark
+          insert(<<~EOF + body.gsub(/^/, "> "))
+        
+        
+        On #{mail['date']}
+        #{mail['from']} wrote:
+      EOF
+          exchange_point_and_mark
+          run_hooks(:mournmail_draft_setup_hook)
+        end
+      end
+    end
+
+    define_local_command(:summary_forward,
+                         doc: "Forward the current message.") do
+      uid = selected_uid
+      summary = Mournmail.current_summary
+      item = summary[uid]
+      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}")
+      re_search_backward(/^To: /)
+      end_of_line
+    end
+
+    define_local_command(:summary_toggle_seen,
+                         doc: "Toggle Seen.") do
+      toggle_flag(selected_uid, :Seen)
+    end
+
+    define_local_command(:summary_toggle_flagged,
+                         doc: "Toggle Flagged.") do
+      toggle_flag(selected_uid, :Flagged)
+    end
+
+    define_local_command(:summary_toggle_deleted,
+                         doc: <<~EOD) do
+        Toggle Deleted.  Type `x` to expunge deleted messages.
+      EOD
+      toggle_flag(selected_uid, :Deleted)
+    end
+
+    define_local_command(:summary_expunge,
+                         doc: <<~EOD) do
+        Expunge deleted messages.
+      EOD
+      buffer = Buffer.current
+      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)
+        end
+        summary_text = summary.to_s
+        summary.save
+        next_tick do
+          buffer.read_only_edit do
+            buffer.clear
+            buffer.insert(summary_text)
+          end
+          message("Expunged messages")
+        end
+      end
+    end
+
+    define_local_command(:summary_view_source,
+                         doc: "View source of a mail.") do
+      uid = selected_uid
+      Mournmail.background do
+        mailbox = Mournmail.current_mailbox
+        source = Mournmail.read_mail(mailbox, uid)
+        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.file_format = :dos
+            source_buffer.beginning_of_buffer
+          end
+          window = Mournmail.message_window
+          window.buffer = source_buffer
+        end
+      end
+    end
+
+    private
+
+    def selected_uid
+      uid = @buffer.save_excursion {
+        @buffer.beginning_of_line
+        if !@buffer.looking_at?(/\d+/)
+          Mournmail.current_mail = nil
+          Mournmail.current_uid = nil
+          raise EditorError, "No message found"
+        end
+        match_string(0).to_i
+      }
+    end
+
+    def scroll_up_or_next_uid
+      begin
+        uid = selected_uid
+        if uid == Mournmail.current_uid
+          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
+        uid
+      rescue RangeError # may be raised by scroll_up
+        next_message
+        retry
+      end
+    end
+
+    def mark_as_seen(uid)
+      summary_item = Mournmail.current_summary[uid]
+      if summary_item && !summary_item.flags.include?(:Seen)
+        summary_item.set_flag(:Seen, update_server: false)
+        Mournmail.current_summary.save
+        update_flags(summary_item)
+      end
+    end
+
+    def toggle_flag(uid, flag)
+      summary_item = Mournmail.current_summary[uid]
+      if summary_item
+        Mournmail.background do
+          summary_item.toggle_flag(flag)
+          Mournmail.current_summary.save
+          next_tick do
+            update_flags(summary_item)
+          end
+        end
+      end
+    end
+
+    def update_flags(summary_item)
+      @buffer.read_only_edit do
+        @buffer.save_excursion do
+          @buffer.beginning_of_buffer
+          uid = summary_item.uid
+          flags_char = summary_item.flags_char
+          if @buffer.re_search_forward(/^#{uid} ./)
+            @buffer.replace_match("#{uid} #{flags_char}")
+          end
+        end
+      end
+    end
+
+    def next_message
+      @buffer.end_of_line
+      if @buffer.end_of_buffer?
+        raise EditorError, "No more mail"
+      end
+      begin
+        @buffer.re_search_forward(/^\d+ u/)
+      rescue SearchError
+        @buffer.forward_line
+      end
+    end
+  end
+end

data/lib/mournmail/utils.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require "mail"
+require "mail-iso-2022-jp"
+require "net/imap"
+require "time"
+require "fileutils"
+require "timeout"
+
+module Mournmail
+  begin
+    require "mail-gpg"
+    HAVE_MAIL_GPG = true
+  rescue LoadError
+    HAVE_MAIL_GPG = false
+  end
+
+  def self.define_variable(name, value = nil)
+    var_name = "@" + name.to_s
+    if !instance_variable_defined?(var_name)
+      instance_variable_set(var_name, value)
+    end
+    singleton_class.send(:attr_accessor, name)
+  end
+
+  define_variable :current_mailbox
+  define_variable :current_summary
+  define_variable :current_uid
+  define_variable :current_mail
+  define_variable :background_thread
+
+  def self.background
+    if background_thread&.alive?
+      raise EditorError, "Background thread already running"
+    end
+    self.background_thread = Utils.background {
+      begin
+        yield
+      ensure
+        self.background_thread = nil
+      end
+    }
+  end
+
+  def self.message_window
+    if Window.list.size == 1
+      split_window
+      shrink_window(Window.current.lines - 8)
+    end
+    windows = Window.list
+    i = (windows.index(Window.current) + 1) % windows.size
+    windows[i]
+  end
+
+  def self.back_to_summary
+    summary_window = Window.list.find { |window|
+      window.buffer.name == "*summary*"
+    }
+    if summary_window
+      Window.current = summary_window
+    end
+  end
+
+  def self.escape_binary(s)
+    s.b.gsub(/[\x80-\xff]/n) { |c|
+      "<%02X>" % c.ord
+    }
+  end
+
+  def self.decode_eword(s)
+    Mail::Encodings.decode_encode(s, :decode).
+      encode(Encoding::UTF_8, replace: "?").gsub(/[\t\n]/, " ")
+  rescue Encoding::CompatibilityError, Encoding::UndefinedConversionError
+    escape_binary(s)
+  end
+
+  @imap = nil
+  @imap_mutex = Mutex.new
+
+  def self.imap_connect
+    @imap_mutex.synchronize do
+      if @imap.nil? || @imap.disconnected?
+        Timeout.timeout(CONFIG[:mournmail_imap_connect_timeout]) do
+          @imap = Net::IMAP.new(CONFIG[:mournmail_imap_host],
+                                CONFIG[:mournmail_imap_options])
+          @imap.authenticate(CONFIG[:mournmail_imap_options][:auth_type] ||
+                             "PLAIN",
+                             CONFIG[:mournmail_imap_options][:user_name],
+                             CONFIG[:mournmail_imap_options][:password])
+          if Mournmail.current_mailbox
+            @imap.select(Mournmail.current_mailbox)
+          end
+        end
+      end
+      yield(@imap)
+    end
+  rescue IOError, Errno::ECONNRESET
+    imap_disconnect
+    raise
+  end
+
+  def self.imap_disconnect
+    @imap_mutex.synchronize do
+      if @imap
+        @imap.disconnect rescue nil
+        @imap = nil
+      end
+    end
+  end
+
+  def self.fetch_summary(mailbox, all: false)
+    imap_connect do |imap|
+      imap.select(mailbox)
+      if all
+        summary = Mournmail::Summary.new(mailbox)
+      else
+        summary = Mournmail::Summary.load_or_new(mailbox)
+      end
+      first_uid = (summary.last_uid || 0) + 1
+      data = imap.uid_fetch(first_uid..-1, ["UID", "ENVELOPE", "FLAGS"])
+      summary.synchronize do
+        data&.each do |i|
+          uid = i.attr["UID"]
+          next if summary[uid]
+          env = i.attr["ENVELOPE"]
+          flags = i.attr["FLAGS"]
+          item = Mournmail::SummaryItem.new(uid, env.date, env.from,
+                                            env.subject, flags)
+          summary.add_item(item, env.message_id, env.in_reply_to)
+        end
+      end
+      summary
+    end
+  end
+
+  def self.read_mail(mailbox, uid)
+    path = File.expand_path("cache/#{mailbox}/#{uid}",
+                            CONFIG[:mournmail_directory])
+    begin
+      File.open(path) do |f|
+        f.flock(File::LOCK_SH)
+        f.read
+      end
+    rescue Errno::ENOENT
+      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[]"]
+        FileUtils.mkdir_p(File.dirname(path))
+        File.open(path, "w", 0600) do |f|
+          f.flock(File::LOCK_EX)
+          f.write(s)
+        end
+        s
+      end
+    end
+  end
+end