mournmail 0.1.1 → 1.0.0

data/lib/mournmail/faces.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Textbringer
   Face.define :seen, foreground: "blue"
   Face.define :deleted, foreground: "green"

data/lib/mournmail/mail_encoded_word_patch.rb

@@ -0,0 +1,71 @@
+require "mail"
+
+module Mournmail
+  module MailEncodedWordPatch
+    private
+
+    def fold(prepend = 0) # :nodoc:
+      charset = normalized_encoding
+      decoded_string = decoded.to_s
+      if charset != "UTF-8" ||
+          decoded_string.ascii_only? ||
+          !decoded_string.respond_to?(:encoding) ||
+          decoded_string.encoding != Encoding::UTF_8 ||
+          Regexp.new('\p{Han}|\p{Hiragana}|\p{Katakana}') !~ decoded_string
+        # Use Q encoding
+        return super(prepend)
+      end
+      words = decoded_string.split(/[ \t]/)
+      folded_lines   = []
+      b_encoding_extra_size = "=?#{charset}?B??=".bytesize
+      while !words.empty?
+        limit = 78 - prepend
+        line = +""
+        fold_line = false
+        while !fold_line && !words.empty?
+          word = words.first
+          s = (line.empty? ? "" : " ").dup
+          if word.ascii_only?
+            s << word
+            break if !line.empty? && line.bytesize + s.bytesize > limit
+            words.shift
+            if prepend + line.bytesize + s.bytesize > 998
+              words.unshift(s.slice!(998 - prepend .. -1))
+              fold_line = true
+            end
+          else
+            words.shift
+            encoded_text = base64_encode(word)
+            min_size = line.bytesize + s.bytesize + b_encoding_extra_size
+            new_size = min_size + encoded_text.bytesize
+            if new_size > limit
+              n = ((limit - min_size) * 3.0 / 4.0).floor
+              if n <= 0
+                words.unshift(word) if !line.empty?
+                break
+              end
+              truncated = word.byteslice(0, n).scrub("")
+              rest = word.byteslice(truncated.bytesize,
+                                    word.bytesize - truncated.bytesize)
+              words.unshift(rest)
+              encoded_text = base64_encode(truncated)
+              fold_line = true
+            end
+            encoded_word = "=?#{charset}?B?#{encoded_text}?="
+            s << encoded_word
+          end
+          line << s
+        end
+        folded_lines << line
+        prepend = 1 # Space will be prepended
+      end
+      folded_lines
+    end
+
+    def base64_encode(word)
+      Mail::Encodings::Base64.encode(word).gsub(/[\r\n]/, "")
+    end
+  end
+end
+
+Mail::UnstructuredField.prepend(Mournmail::MailEncodedWordPatch)

data/lib/mournmail/message_mode.rb

@@ -1,4 +1,5 @@
-# frozen_string_literal: true
+require "uri"
+require "mime/types"
 
 using Mournmail::MessageRendering
 
@@ -7,18 +8,23 @@ module Mournmail
     MESSAGE_MODE_MAP = Keymap.new
     MESSAGE_MODE_MAP.define_key("\C-m", :message_open_link_or_part_command)
     MESSAGE_MODE_MAP.define_key("s", :message_save_part_command)
+    MESSAGE_MODE_MAP.define_key("\t", :message_next_link_or_part_command)
 
     # See http://nihongo.jp/support/mail_guide/dev_guide.txt
-    URI_REGEXP = /(https?|ftp):\/\/[^ 　\t\n>)"]*[^] 　\t\n>.,:)"]+/
+    MAILTO_REGEXP = URI.regexp("mailto")
+    URI_REGEXP = /(https?|ftp):\/\/[^ 　\t\n>)"]*[^\] 　\t\n>.,:)"]+|#{MAILTO_REGEXP}/
+    MIME_REGEXP = /^\[(([0-9.]+) [A-Za-z._\-]+\/[A-Za-z._\-]+.*|PGP\/MIME .*)\]$/
+    URI_OR_MIME_REGEXP = /#{URI_REGEXP}|#{MIME_REGEXP}/
 
     define_syntax :field_name, /^[A-Za-z\-]+: /
     define_syntax :quotation, /^>.*/
-    define_syntax :mime_part, /^\[([0-9.]+) [A-Za-z._\-]+\/[A-Za-z._\-]+.*\]$/
+    define_syntax :mime_part, MIME_REGEXP
     define_syntax :link, URI_REGEXP
 
     def initialize(buffer)
       super(buffer)
       buffer.keymap = MESSAGE_MODE_MAP
+      @attached_file = nil
     end
 
     define_local_command(:message_open_link_or_part,
@@ -45,6 +51,18 @@ module Mournmail
       end
     end
 
+    define_local_command(:message_next_link_or_part,
+                         doc: "Go to the next link or MIME part.") do
+      if @buffer.looking_at?(URI_OR_MIME_REGEXP)
+        @buffer.forward_char
+      end
+      if @buffer.re_search_forward(URI_OR_MIME_REGEXP, raise_error: false)
+        goto_char(@buffer.match_beginning(0))
+      else
+        @buffer.beginning_of_buffer
+      end
+    end
+
     private
 
     def current_part
@@ -53,7 +71,7 @@ module Mournmail
         if @buffer.looking_at?(/\[([0-9.]+) .*\]/)
           index = match_string(1)
           indices = index.split(".").map(&:to_i)
-          Mournmail.current_mail.dig_part(*indices)
+          @buffer[:mournmail_mail].dig_part(*indices)
         else
           nil
         end
@@ -62,8 +80,8 @@ module Mournmail
 
     def part_file_name(part)
       file_name =
-        part["content-disposition"]&.parameters&.[]("filename") ||
-        part["content-type"]&.parameters&.[]("name") ||
+        (part["content-disposition"]&.parameters&.[]("filename") rescue nil) ||
+        (part["content-type"]&.parameters&.[]("name") rescue nil) ||
         part_default_file_name(part)
       decoded_file_name = Mail::Encodings.decode_encode(file_name, :decode)
       if /\A([A-Za-z0-9_\-]+)'(?:[A-Za-z0-9_\-])*'(.*)/ =~ decoded_file_name
@@ -74,7 +92,12 @@ module Mournmail
     end
 
     def part_default_file_name(part)
-      base_name = part.cid.gsub(/[^A-Za-z0-9_\-]/, "_")
+      base_name =
+        begin
+          part.cid.gsub(/[^A-Za-z0-9_\-]/, "_")
+        rescue NoMethodError
+          "mournmail"
+        end
       ext = part_extension(part)
       if ext
         base_name + "." + ext
@@ -111,22 +134,44 @@ module Mournmail
       else
         file_name = "mournmail"
       end
-      f = Tempfile.open(file_name)
-      f.write(part.decoded)
-      f.close
-      if ext == "txt"
-        find_file(f.path)
+      @attached_file = Tempfile.open(file_name, binmode: true)
+      s = part.decoded
+      if part.content_type == "text/html"
+        s = s.sub(/<meta http-equiv="content-type".*?>/i, "")
+      elsif part.charset
+        s = s.encode(part.charset)
+      end
+      @attached_file.write(s)
+      @attached_file.close
+      if part.main_type == "text" && part.sub_type != "html"
+        find_file(@attached_file.path)
       else
         background do
-          system(*CONFIG[:mournmail_file_open_comamnd], f.path,
+          system(*CONFIG[:mournmail_file_open_comamnd], @attached_file.path,
                  out: File::NULL, err: File::NULL)
         end
       end
     end
 
     def open_uri(uri)
-      system(*CONFIG[:mournmail_link_open_comamnd], uri,
-             out: File::NULL, err: File::NULL)
+      case uri
+      when /\Amailto:/
+        u = URI.parse(uri)
+        if u.headers.assoc("subject")
+          re = /^To:\s*\nSubject:\s*\n/
+        else
+          re = /^To:\s*\n/
+        end
+        Commands.mail
+        beginning_of_buffer
+        re_search_forward(re)
+        replace_match("")
+        insert u.to_mailtext.sub(/\n\n\z/, "")
+        end_of_buffer
+      else
+        system(*CONFIG[:mournmail_link_open_comamnd], uri,
+               out: File::NULL, err: File::NULL)
+      end
     end
   end
 end

data/lib/mournmail/message_rendering.rb

@@ -1,7 +1,5 @@
-# frozen_string_literal: true
-
 require "mail"
-require "mail-iso-2022-jp"
+require "html2text"
 
 module Mournmail
   module MessageRendering
@@ -10,9 +8,9 @@ module Mournmail
         render_header + "\n" + render_body(indices)
       end
 
-      def render_header
-        CONFIG[:mournmail_display_header_fields].map { |name|
-          val = self[name]
+      def render_header(fields = CONFIG[:mournmail_display_header_fields])
+        fields.map { |name|
+          val = self[name]&.to_s&.gsub(/\t/, " ")
           val ? "#{name}: #{val}\n" : ""
         }.join
       end        
@@ -20,28 +18,68 @@ module Mournmail
       def render_body(indices = [])
         if HAVE_MAIL_GPG && encrypted?
           mail = decrypt(verify: true)
-          return mail.render_body(indices)
+          if mail.signatures.empty?
+            sig = ""
+          else
+            sig = "[PGP/MIME signature]\n" +
+              signature_of(mail)
+          end
+          return "[PGP/MIME encrypted message]\n" + mail.render(indices) + sig
         end
         if multipart?
           parts.each_with_index.map { |part, i|
-            part.render([*indices, i])
+            no_content = sub_type == "alternative" && i > 0
+            part.render([*indices, i], no_content)
           }.join
-        else
-          s = body.decoded
-          if /\Autf-8\z/i =~ charset
-            s.force_encoding(Encoding::UTF_8).scrub("?")
+        elsif main_type.nil? || main_type == "text"
+          s = Mournmail.to_utf8(body.decoded, charset)
+          if sub_type == "html"
+            "[0 text/html]\n" + Html2Text.convert(s)
           else
-            s.encode(Encoding::UTF_8, charset, replace: "?")
-          end.gsub(/\r\n/, "\n")
+            s
+          end
+        else
+          type = Mail::Encodings.decode_encode(self["content-type"].to_s,
+                                               :decode) rescue
+            "broken/type; error=\"#{$!} (#{$!.class})\""
+          "[0 #{type}]\n"
         end + pgp_signature
       end
 
+      def render_text(indices = [])
+        if HAVE_MAIL_GPG && encrypted?
+          mail = decrypt(verify: true)
+          return mail.render_text(indices)
+        end
+        if multipart?
+          parts.each_with_index.map { |part, i|
+            if sub_type == "alternative" && i > 0
+              ""
+            else
+              part.render_text([*indices, i])
+            end
+          }.join("\n")
+        elsif main_type.nil? || main_type == "text"
+          s = Mournmail.to_utf8(body.decoded, charset)
+          if sub_type == "html"
+            Html2Text.convert(s)
+          else
+            s
+          end
+        else
+          ""
+        end
+      end
+
       def dig_part(i, *rest_indices)
         if HAVE_MAIL_GPG && encrypted?
           mail = decrypt(verify: true)
           return mail.dig_part(i, *rest_indices)
         end
-        part = parts[i]
+        if i == 0
+          return self
+        end
+        part = parts[i - 1]
         if rest_indices.empty?
           part
         else
@@ -54,31 +92,71 @@ module Mournmail
       def pgp_signature 
         if HAVE_MAIL_GPG && signed?
           verified = verify
-          validity = verified.signature_valid? ? "Good" : "Bad"
-          from = verified.signatures.map { |sig|
-            sig.from rescue sig.fingerprint
-          }.join(", ")
-          "#{validity} signature from #{from}\n"
+          signature_of(verified)
         else
           ""
         end
       end
+
+      def signature_of(m)
+        validity = m.signature_valid? ? "Good" : "Bad"
+        from = m.signatures.map { |sig|
+          sig.from rescue sig.fingerprint
+        }.join(", ")
+        s = "#{validity} signature from #{from}"
+        message(s)
+        s + "\n"
+      end
     end
 
     refine ::Mail::Part do
-      def render(indices)
-        index = indices.join(".")
+      def render(indices, no_content = false)
+        index = indices.map { |i| i + 1 }.join(".")
         type = Mail::Encodings.decode_encode(self["content-type"].to_s,
-                                             :decode)
-        "[#{index} #{type}]\n" + render_content(indices)
+                                             :decode) rescue
+          "broken/type; error=\"#{$!} (#{$!.class})\""
+        "[#{index} #{type}]\n" +
+          render_content(indices, no_content)
+      end
+
+      def render_text(indices)
+        if multipart?
+          parts.each_with_index.map { |part, i|
+            if sub_type == "alternative" && i > 0
+              ""
+            else
+              part.render_text([*indices, i])
+            end
+          }.join("\n")
+        else
+          if main_type == "message" && sub_type == "rfc822"
+            mail = Mail.new(body.raw_source)
+            mail.render_header(CONFIG[:mournmail_quote_header_fields]) +
+              "\n" + mail.render_text(indices)
+          elsif attachment?
+            ""
+          else
+            if main_type == "text"
+              if sub_type == "html"
+                Html2Text.convert(decoded).sub(/(?<!\n)\z/, "\n")
+              else
+                decoded.sub(/(?<!\n)\z/, "\n").gsub(/\r\n/, "\n")
+              end
+            else
+              ""
+            end
+          end
+        end
+      rescue => e
+        ""
       end
 
       def dig_part(i, *rest_indices)
         if main_type == "message" && sub_type == "rfc822"
-          mail = Mail.new(body.raw_source)
+          mail = Mail.new(body.to_s)
           mail.dig_part(i, *rest_indices)
         else
-          part = parts[i]
+          part = parts[i - 1]
           if rest_indices.empty?
             part
           else
@@ -89,23 +167,33 @@ module Mournmail
 
       private
 
-      def render_content(indices)
+      def render_content(indices, no_content)
         if multipart?
           parts.each_with_index.map { |part, i|
-            part.render([*indices, i])
+            part.render([*indices, i],
+                        no_content || sub_type == "alternative" && i > 0)
           }.join
-        elsif main_type == "message" && sub_type == "rfc822"
-          mail = Mail.new(body.raw_source)
-          mail.render(indices)
-        elsif self["content-disposition"]&.disposition_type == "attachment"
-          ""
         else
-          if main_type == "text" && sub_type == "plain"
-            decoded.sub(/(?<!\n)\z/, "\n").gsub(/\r\n/, "\n")
-          else
+          return "" if no_content
+          if main_type == "message" && sub_type == "rfc822"
+            mail = Mail.new(body.raw_source)
+            mail.render(indices)
+          elsif attachment?
             ""
+          else
+            if main_type == "text"
+              if sub_type == "html"
+                Html2Text.convert(decoded).sub(/(?<!\n)\z/, "\n")
+              else
+                decoded.sub(/(?<!\n)\z/, "\n").gsub(/\r\n/, "\n")
+              end
+            else
+              ""
+            end
           end
         end
+      rescue => e
+        "Broken part: #{e} (#{e.class})"
       end
     end
   end

data/lib/mournmail/search_result_mode.rb

@@ -0,0 +1,143 @@
+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)
+    SEARCH_RESULT_MODE_MAP.define_key("@", :summary_change_account_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? || message._key.nil?
+          raise EditorError, "No message found"
+        end
+        mail = Mail.new(Mournmail.read_mail_cache(message._key))
+        foreground 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