mournmail 0.1.1 → 0.2.0

data/lib/mournmail/utils.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
 require "mail"
-require "mail-iso-2022-jp"
 require "net/imap"
 require "time"
+require "tempfile"
 require "fileutils"
 require "timeout"
+require "digest"
+require "groonga"
 
 module Mournmail
   begin
@@ -15,23 +17,37 @@ module Mournmail
     HAVE_MAIL_GPG = false
   end
 
-  def self.define_variable(name, value = nil)
+  def self.define_variable(name, initial_value: nil, attr: nil)
     var_name = "@" + name.to_s
     if !instance_variable_defined?(var_name)
-      instance_variable_set(var_name, value)
+      instance_variable_set(var_name, initial_value)
+    end
+    case attr
+    when :accessor
+      singleton_class.send(:attr_accessor, name)
+    when :reader
+      singleton_class.send(:attr_reader, name)
+    when :writer
+      singleton_class.send(:attr_writer, name)
     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
+  define_variable :current_mailbox, attr: :accessor
+  define_variable :current_summary, attr: :accessor
+  define_variable :current_uid, attr: :accessor
+  define_variable :current_mail, attr: :accessor
+  define_variable :background_thread, attr: :accessor
+  define_variable :keep_alive_thread, attr: :accessor
+  define_variable :imap
+  define_variable :imap_mutex, initial_value: Mutex.new
+  define_variable :mailboxes, initial_value: []
+  define_variable :current_account
+  define_variable :account_config
+  define_variable :groonga_db
 
-  def self.background
+  def self.background(skip_if_busy: false)
     if background_thread&.alive?
-      raise EditorError, "Background thread already running"
+      return if skip_if_busy
     end
     self.background_thread = Utils.background {
       begin
@@ -42,6 +58,33 @@ module Mournmail
     }
   end
 
+  def self.start_keep_alive_thread
+    if keep_alive_thread
+      raise EditorError, "Keep alive thread already running"
+    end
+    self.keep_alive_thread = Thread.start {
+      loop do
+        sleep(CONFIG[:mournmail_keep_alive_interval])
+        background(skip_if_busy: true) do
+          begin
+            imap_connect do |imap|
+              imap.noop
+            end
+          rescue => e
+            message("Error in IMAP NOOP: #{e.class}: #{e.message}")
+          end
+        end
+      end
+    }
+  end
+
+  def self.stop_keep_alive_thread
+    if keep_alive_thread
+      keep_alive_thread&.kill
+      self.keep_alive_thread = nil
+    end
+  end
+
   def self.message_window
     if Window.list.size == 1
       split_window
@@ -74,19 +117,46 @@ module Mournmail
     escape_binary(s)
   end
 
-  @imap = nil
-  @imap_mutex = Mutex.new
+  def self.current_account
+    init_current_account
+    @current_account
+  end
+
+  def self.account_config
+    init_current_account
+    @account_config
+  end
+
+  def self.init_current_account
+    if @current_account.nil?
+      @current_account, @account_config = CONFIG[:mournmail_accounts].first
+    end
+  end
+
+  def self.current_account=(name)
+    unless CONFIG[:mournmail_accounts].key?(name)
+      raise ArgumentError, "No such account: #{name}"
+    end
+    @current_account = name
+    @account_config = CONFIG[:mournmail_accounts][name]
+  end
 
   def self.imap_connect
     @imap_mutex.synchronize do
+      if keep_alive_thread.nil?
+        start_keep_alive_thread
+      end
       if @imap.nil? || @imap.disconnected?
+        conf = account_config
         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])
+          @imap = Net::IMAP.new(conf[:imap_host],
+                                conf[:imap_options])
+          @imap.authenticate(conf[:imap_options][:auth_type] || "PLAIN",
+                             conf[:imap_options][:user_name],
+                             conf[:imap_options][:password])
+          @mailboxes = @imap.list("", "*").map { |mbox|
+            Net::IMAP.decode_utf7(mbox.name)
+          }
           if Mournmail.current_mailbox
             @imap.select(Mournmail.current_mailbox)
           end
@@ -101,6 +171,7 @@ module Mournmail
 
   def self.imap_disconnect
     @imap_mutex.synchronize do
+      stop_keep_alive_thread
       if @imap
         @imap.disconnect rescue nil
         @imap = nil
@@ -116,6 +187,17 @@ module Mournmail
       else
         summary = Mournmail::Summary.load_or_new(mailbox)
       end
+      uidvalidity = imap.responses["UIDVALIDITY"].last
+      if summary.uidvalidity.nil?
+        summary.uidvalidity = uidvalidity
+      elsif uidvalidity && uidvalidity != summary.uidvalidity
+        clear = next_tick {
+          yes_or_no?("UIDVALIDITY has been changed; Clear cache?")
+        }
+        if clear
+          summary = Mournmail::Summary.new(mailbox)
+        end
+      end
       first_uid = (summary.last_uid || 0) + 1
       data = imap.uid_fetch(first_uid..-1, ["UID", "ENVELOPE", "FLAGS"])
       summary.synchronize do
@@ -134,33 +216,192 @@ module Mournmail
   end
 
   def self.mailbox_cache_path(mailbox)
-    dir = CONFIG[:mournmail_directory]
-    host = CONFIG[:mournmail_imap_host]
-    File.expand_path("cache/#{host}/#{mailbox}", dir)
+    File.expand_path("cache/#{current_account}/mailboxes/#{mailbox}",
+                     CONFIG[:mournmail_directory])
+  end
+
+  def self.mail_cache_path(cache_id)
+    dir = cache_id[0, 2]
+    File.expand_path("cache/#{current_account}/mails/#{dir}/#{cache_id}",
+                     CONFIG[:mournmail_directory])
   end
 
-  def self.read_mail(mailbox, uid)
-    path = File.join(mailbox_cache_path(mailbox), uid.to_s)
+  def self.read_mail_cache(cache_id)
+    path = Mournmail.mail_cache_path(cache_id)
+    File.read(path)
+  end
+
+  def self.write_mail_cache(s)
+    header = s.slice(/.*\r\n\r\n/m)
+    cache_id = Digest::SHA256.hexdigest(header)
+    path = mail_cache_path(cache_id)
+    dir = File.dirname(path)
+    base = File.basename(path)
     begin
-      File.open(path) do |f|
-        f.flock(File::LOCK_SH)
-        [f.read, false]
+      f = Tempfile.create(["#{base}-", ".tmp"], dir)
+      begin
+        f.write(s)
+      ensure
+        f.close
       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}"
+      FileUtils.mkdir_p(File.dirname(path))
+      retry
+    end
+    File.rename(f.path, path)
+    cache_id
+  end
+
+  def self.index_mail(cache_id, mail)
+    messages_db = Groonga["Messages"]
+    unless messages_db.has_key?(cache_id)
+      thread_id = find_thread_id(mail, messages_db)
+      list_id = (mail["List-Id"] || mail["X-ML-Name"])
+      messages_db.add(cache_id,
+                      message_id: header_text(mail.message_id),
+                      thread_id: header_text(thread_id),
+                      date: mail.date&.to_time,
+                      subject: header_text(mail.subject),
+                      from: header_text(mail["From"]),
+                      to: header_text(mail["To"]),
+                      cc: header_text(mail["Cc"]),
+                      list_id: header_text(list_id),
+                      body: body_text(mail))
+    end
+  end
+
+  class << self
+    private
+
+    def find_thread_id(mail, messages_db)
+      references = Array(mail.references) | Array(mail.in_reply_to)
+      if references.empty?
+        mail.message_id
+      else
+        parent = messages_db.select { |m|
+          references.inject(nil) { |cond, ref|
+            if cond.nil?
+              m.message_id == ref
+            else
+              cond | (m.message_id == ref)
+            end
+          }
+        }.first
+        if parent
+          parent.thread_id
+        else
+          mail.message_id
         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
+    end
+
+    def header_text(s)
+      force_utf8(s.to_s)
+    end
+    
+    def body_text(mail)
+      if mail.multipart?
+        mail.parts.map { |part|
+          part_text(part)
+        }.join("\n")
+      else
+        s = mail.body.decoded
+        to_utf8(s, mail.charset).gsub(/\r\n/, "\n")
+      end
+    rescue
+      ""
+    end
+    
+    def part_text(part)
+      if part.multipart?
+        part.parts.map { |part|
+          part_text(part)
+        }.join("\n")
+      elsif part.main_type == "message" && part.sub_type == "rfc822"
+        mail = Mail.new(part.body.raw_source)
+        body_text(mail)
+      elsif part.attachment?
+        force_utf8(part.filename.to_s)
+      else
+        if part.main_type == "text" && part.sub_type == "plain"
+          force_utf8(part.decoded).sub(/(?<!\n)\z/, "\n").gsub(/\r\n/, "\n")
+        else
+          ""
         end
-        [s, true]
       end
+    rescue
+      ""
+    end
+  end
+
+  def self.read_mailbox_name(prompt, **opts)
+    f = ->(s) {
+      complete_for_minibuffer(s, @mailboxes)
+    }
+    mailbox = read_from_minibuffer(prompt, completion_proc: f, **opts)
+    Net::IMAP.encode_utf7(mailbox)
+  end
+
+  def self.force_utf8(s)
+    s.force_encoding(Encoding::UTF_8).scrub("?")
+  end
+
+  def self.to_utf8(s, charset)
+    if /\Autf-8\z/i =~ charset
+      force_utf8(s)
+    else
+      begin
+        s.encode(Encoding::UTF_8, charset, replace: "?")
+      rescue Encoding::ConverterNotFoundError
+        force_utf8(s)
+      end
+    end.gsub(/\r\n/, "\n")
+  end
+
+  def self.open_groonga_db
+    db_path = File.expand_path("groonga/#{current_account}/messages.db",
+                               CONFIG[:mournmail_directory])
+    if File.exist?(db_path)
+      @groonga_db = Groonga::Database.open(db_path)
+    else
+      @groonga_db = create_groonga_db(db_path)
+    end
+  end
+
+  def self.create_groonga_db(db_path)
+    FileUtils.mkdir_p(File.dirname(db_path), mode: 0700)
+    db = Groonga::Database.create(path: db_path)
+
+    Groonga::Schema.create_table("Messages", :type => :hash) do |table|
+      table.short_text("message_id")
+      table.short_text("thread_id")
+      table.time("date")
+      table.short_text("subject")
+      table.short_text("from")
+      table.short_text("to")
+      table.short_text("cc")
+      table.short_text("list_id")
+      table.text("body")
+    end
+    
+    Groonga::Schema.create_table("Terms",
+                                 type: :patricia_trie,
+                                 normalizer: :NormalizerAuto,
+                                 default_tokenizer: "TokenBigram") do |table|
+      table.index("Messages.subject")
+      table.index("Messages.from")
+      table.index("Messages.to")
+      table.index("Messages.cc")
+      table.index("Messages.list_id")
+      table.index("Messages.body")
+    end
+
+    db
+  end
+
+  def self.close_groonga_db
+    if @groonga_db
+      @groonga_db.close
     end
   end
 end

data/lib/mournmail/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mournmail
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/mournmail.gemspec

@@ -23,7 +23,7 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency "textbringer"
   spec.add_runtime_dependency "mail"
-  spec.add_runtime_dependency "mail-iso-2022-jp"
+  spec.add_runtime_dependency "rroonga"
 
   spec.add_development_dependency "bundler", "~> 1.14"
   spec.add_development_dependency "rake", "~> 10.0"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mournmail
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Shugo Maeda
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-09-18 00:00:00.000000000 Z
+date: 2018-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: textbringer
@@ -39,7 +39,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: mail-iso-2022-jp
+  name: rroonga
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -99,8 +99,10 @@ files:
 - lib/mournmail/config.rb
 - lib/mournmail/draft_mode.rb
 - lib/mournmail/faces.rb
+- lib/mournmail/mail_encoded_word_patch.rb
 - lib/mournmail/message_mode.rb
 - lib/mournmail/message_rendering.rb
+- lib/mournmail/search_result_mode.rb
 - lib/mournmail/summary.rb
 - lib/mournmail/summary_mode.rb
 - lib/mournmail/utils.rb
@@ -127,9 +129,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: A message user agent for Textbringer.
 test_files: []
-has_rdoc: