mournmail 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bce6a83b1d41699944c7440f0737318437931a7e
+  data.tar.gz: 592a006b174161b564ce302739e19382ef07fda9
+SHA512:
+  metadata.gz: bda483a4723883895517a781308ee8305fc60bc5fab09e6c8ef3181ab770d04304a7f72ccc0b85f23cfa198ae1574ba5ec80c6c9fa961c7a7c17e1da31dc0dd0
+  data.tar.gz: 79f6879cc3b2737855a3dac77768bda6b440a0303400daa7c8085ae4fb0639c440e6ec0246cfcfc8f4bbefecf8dab6657c57291120e162ee3700f8d88262d939

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in mournmail.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Shugo Maeda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,64 @@
+# Mournmail
+
+Mournmail is a message user agent for
+[Textbringer](https://github.com/shugo/textbringer).
+
+## Installation
+
+    $ gem install mournmail
+
+## Configuration
+
+```ruby
+# The default value of From:
+CONFIG[:mournmail_from] = "Shugo Maeda <shugo@example.com>"
+# The default charset
+CONFIG[:mournmail_charset] = "ISO-2022-JP"
+# The delivery method for Mail#delivery_method
+CONFIG[:mournmail_delivery_method] = :smtp
+# The options for Mail#delivery_method
+CONFIG[:mournmail_delivery_options] = {
+  :address => "smtp.example.com",
+  :port => 465,
+  :domain => Socket.gethostname,
+  :user_name => "shugo",
+  :password => File.read("/path/to/smtp_passwd").chomp,
+  :authentication => "login",
+  :tls => true,
+  :ca_file => "/path/to/cacert.pem"
+}
+# The host for Net::IMAP#new
+CONFIG[:mournmail_imap_host] = "imap.example.com"
+# The options for Net::IMAP.new and
+# Net::IMAP#authenticate (auth_type, user_name, and password)
+CONFIG[:mournmail_imap_options] = {
+  ssl: {
+    :ca_file => File.expand_path("/path/to/cacert.pem")
+  },
+  auth_type: "PLAIN",
+  user_name: "shugo",
+  password: File.read("/path/to/imap_passwd").chomp
+}
+```
+
+## Usage
+
+Type `M-x mail` to send a mail.
+
+Type `M-x mournmail` to visit INBOX.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/shugo/mournmail.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "mournmail"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/mournmail/commands.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+define_command(:mournmail, doc: "Start mournmail.") do
+  mournmail_visit_mailbox("INBOX")
+end
+
+define_command(:mournmail_visit_mailbox, doc: "Start mournmail.") do
+  |mailbox = read_from_minibuffer("Visit mailbox: ", default: "INBOX")|
+  mournmail_summary_sync(mailbox)
+end
+
+define_command(:mournmail_summary_sync, doc: "Sync summary.") do
+  |mailbox = (Mournmail.current_mailbox || "INBOX"),
+    all = current_prefix_arg|
+  message("Syncing #{mailbox} in background...")
+  Mournmail.background do
+    summary = Mournmail.fetch_summary(mailbox, all: all)
+    summary_text = summary.to_s
+    summary.save
+    next_tick do
+      buffer = Buffer.find_or_new("*summary*", undo_limit: 0,
+                                  read_only: true)
+      buffer.apply_mode(Mournmail::SummaryMode)
+      buffer.read_only_edit do
+        buffer.clear
+        buffer.insert(summary_text)
+      end
+      switch_to_buffer(buffer)
+      Mournmail.current_mailbox = mailbox
+      Mournmail.current_summary = summary
+      Mournmail.current_mail = nil
+      Mournmail.current_uid = nil
+      message("Syncing #{mailbox} in background... Done")
+      begin
+        buffer.beginning_of_buffer
+        buffer.re_search_forward(/^\d+ u/)
+      rescue SearchError
+        buffer.end_of_buffer
+        buffer.re_search_backward(/^\d+ /, raise_error: false)
+      end
+      summary_read_command
+    end
+  end
+end
+
+define_command(:mournmail_quit, doc: "Quit mournmail.") do
+  th = Mournmail.background_thread
+  if th
+    return unless yes_or_no?("A background process is running. Kill it?")
+    th.kill
+  end
+  delete_other_windows
+  if buffer = Buffer["*summary*"]
+    kill_buffer(buffer)
+  end
+  if buffer = Buffer["*message*"]
+    kill_buffer(buffer)
+  end
+  Mournmail.background do
+    Mournmail.imap_disconnect
+  end
+  Mournmail.current_mailbox = nil
+  Mournmail.current_summary = nil
+  Mournmail.current_mail = nil
+  Mournmail.current_uid = nil
+end
+
+define_command(:mail, doc: "Write a new mail.") do
+  |run_hooks: true|
+  buffer = Buffer.new_buffer("*draft*")
+  switch_to_buffer(buffer)
+  draft_mode
+  insert <<~EOF
+    From: #{CONFIG[:mournmail_from]}
+    To: 
+    Subject: 
+    User-Agent: Mournmail/#{Mournmail::VERSION} Textbringer/#{Textbringer::VERSION} Ruby/#{RUBY_VERSION}
+    --text follows this line--
+  EOF
+  re_search_backward(/^To:/)
+  end_of_line
+  if run_hooks
+    run_hooks(:mournmail_draft_setup_hook)
+  end
+end

data/lib/mournmail/config.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Textbringer
+  CONFIG[:mournmail_directory] = File.expand_path("~/.mournmail")
+  CONFIG[:mournmail_from] = ""
+  CONFIG[:mournmail_delivery_method] = :smtp
+  CONFIG[:mournmail_delivery_options] = {}
+  CONFIG[:mournmail_charset] = "utf-8"
+  CONFIG[:mournmail_save_directory] = "/tmp"
+  CONFIG[:mournmail_display_header_fields] = [
+    "Subject",
+    "Date",
+    "From",
+    "To",
+    "Cc",
+    "Reply-To",
+    "User-Agent",
+    "X-Mailer",
+    "Content-Type"
+  ]
+  CONFIG[:mournmail_imap_connect_timeout] = 10
+  CONFIG[:mournmail_file_open_comamnd] = "xdg-open"
+  CONFIG[:mournmail_link_open_comamnd] = "xdg-open"
+  CONFIG[:mournmail_outbox] = nil
+  CONFIG[:mournmail_addresses_path] = File.expand_path("~/.addresses")
+end

data/lib/mournmail/draft_mode.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Mournmail
+  class DraftMode < Textbringer::Mode
+    MAIL_MODE_MAP = Keymap.new
+    MAIL_MODE_MAP.define_key("\C-c\C-c", :draft_send_command)
+    MAIL_MODE_MAP.define_key("\C-c\C-k", :draft_kill_command)
+    MAIL_MODE_MAP.define_key("\C-c\C-x\C-i", :draft_attach_file_command)
+    MAIL_MODE_MAP.define_key("\t", :draft_complete_or_insert_tab_command)
+
+    define_syntax :field_name, /^[A-Za-z\-]+: /
+    define_syntax :quotation, /^>.*/
+    define_syntax :header_end, /^--text follows this line--$/
+
+    def initialize(buffer)
+      super(buffer)
+      buffer.keymap = MAIL_MODE_MAP
+    end
+
+    define_local_command(:draft_send,
+                         doc: "Send a mail and exit from mail buffer.") do
+      unless y_or_n?("Send this mail?")
+        return
+      end
+      s = @buffer.to_s
+      charset = CONFIG[:mournmail_charset]
+      begin
+        s.encode(charset)
+      rescue Encoding::UndefinedConversionError
+        charset = "utf-8"
+      end
+      m = Mail.new(charset: charset)
+      header, body = s.split(/^--text follows this line--\n/, 2)
+      attached_files = []
+      attached_messages = []
+      header.scan(/^([!-9;-~]+):[ \t]*(.*(?:\n[ \t].*)*)\n/) do |name, val|
+        case name
+        when "Attached-File"
+          attached_files.push(val.strip)
+        when "Attached-Message"
+          attached_messages.push(val.strip)
+        else
+          m[name] = val
+        end
+      end
+      if body.empty?
+        return if !yes_or_no?("Body is empty.  Really send?")
+      else
+        if attached_files.empty? && attached_messages.empty?
+          m.body = body
+        else
+          part = Mail::Part.new(content_type: "text/plain", body: body)
+          part.charset = charset
+          m.body << part
+        end
+      end
+      attached_files.each do |file|
+        m.add_file(file)
+      end
+      m.delivery_method(CONFIG[:mournmail_delivery_method],
+                        CONFIG[:mournmail_delivery_options])
+      bury_buffer(@buffer)
+      background do
+        begin
+          if !attached_messages.empty?
+            attached_messages.each do |attached_message|
+              mailbox, uid = attached_message.strip.split("/")
+              s = Mournmail.read_mail(mailbox, uid.to_i)
+              part = Mail::Part.new(content_type: "message/rfc822", body: s)
+              m.body << part
+            end
+          end
+          m.deliver!
+          Mournmail.imap_connect do |imap|
+            outbox = CONFIG[:mournmail_outbox]
+            if outbox
+              imap.append(outbox, m.to_s, [:Seen])
+            end
+          end
+          next_tick do
+            kill_buffer(@buffer, force: true)
+            Mournmail.back_to_summary
+            message("Mail sent.")
+          end
+        rescue Exception
+          next_tick do
+            switch_to_buffer(@buffer)
+          end
+          raise
+        end
+      end
+    end
+    
+    define_local_command(:draft_kill, doc: "Kill the draft buffer.") do
+      if yes_or_no?("Kill current draft?")
+        kill_buffer(@buffer, force: true)
+        Mournmail.back_to_summary
+      end
+    end
+    
+    define_local_command(:draft_attach_file, doc: "Attach a file.") do
+      |file_name = read_file_name("Attach file: ")|
+      @buffer.save_excursion do
+        @buffer.beginning_of_buffer
+        @buffer.re_search_forward(/^--text follows this line--$/)
+        @buffer.beginning_of_line
+        @buffer.insert("Attached-File: #{file_name}\n")
+      end
+    end
+    
+    define_local_command(:draft_complete_or_insert_tab,
+                         doc: "Complete a mail address or insert a tab.") do
+      is_address_field = @buffer.save_excursion {
+        @buffer.beginning_of_line
+        @buffer.looking_at?(/(To|Cc|Bcc):/i)
+      }
+      if is_address_field
+        end_pos = @buffer.point
+        @buffer.skip_re_backward(/[^ :,]/)
+        start_pos = @buffer.point
+        s = @buffer.substring(start_pos, end_pos)
+        if !s.empty?
+          re = /^(.*")?#{Regexp.quote(s)}.*/
+          line = File.read(CONFIG[:mournmail_addresses_path]).slice(re)
+          if line
+            addr = line.slice(/^\S+/)
+            @buffer.delete_region(start_pos, end_pos)
+            @buffer.insert(addr)
+          else
+            @buffer.goto_char(end_pos)
+            message("No match")
+          end
+        end
+      else
+        @buffer.insert("\t")
+      end
+    end
+  end
+end

data/lib/mournmail/faces.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Textbringer
+  Face.define :seen, foreground: "blue"
+  Face.define :deleted, foreground: "green"
+  Face.define :answered, foreground: "blue"
+  Face.define :unseen, bold: true
+  Face.define :flagged, foreground: "yellow", bold: true
+  Face.define :field_name, foreground: "magenta", bold: true
+  Face.define :quotation, foreground: "yellow"
+  Face.define :header_end, foreground: "yellow"
+  Face.define :mime_part, foreground: "blue", bold: true
+end

data/lib/mournmail/message_mode.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+using Mournmail::MessageRendering
+
+module Mournmail
+  class MessageMode < Textbringer::Mode
+    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)
+
+    # See http://nihongo.jp/support/mail_guide/dev_guide.txt
+    URI_REGEXP = /(https?|ftp):\/\/[^ 　\t\n>)"]*[^] 　\t\n>.,:)"]+/
+
+    define_syntax :field_name, /^[A-Za-z\-]+: /
+    define_syntax :quotation, /^>.*/
+    define_syntax :mime_part, /^\[([0-9.]+) [A-Za-z._\-]+\/[A-Za-z._\-]+.*\]$/
+    define_syntax :link, URI_REGEXP
+
+    def initialize(buffer)
+      super(buffer)
+      buffer.keymap = MESSAGE_MODE_MAP
+    end
+
+    define_local_command(:message_open_link_or_part,
+                         doc: "Open a link or part.") do
+      part = current_part
+      if part
+        open_part(part)
+      else
+        uri = current_uri
+        if uri
+          open_uri(uri)
+        end
+      end
+    end
+
+    define_local_command(:message_save_part, doc: "Save the current part.") do
+      part = current_part
+      return if part.nil?
+      default_path = File.expand_path(part_file_name(part),
+                                      CONFIG[:mournmail_save_directory])
+      path = read_file_name("Save: ", default: default_path)
+      if !File.exist?(path) || yes_or_no?("File exists; overwrite?")
+        File.write(path, part.decoded)
+      end
+    end
+
+    private
+
+    def current_part
+      @buffer.save_excursion do
+        @buffer.beginning_of_line
+        if @buffer.looking_at?(/\[([0-9.]+) .*\]/)
+          index = match_string(1)
+          indices = index.split(".").map(&:to_i)
+          Mournmail.current_mail.dig_part(*indices)
+        else
+          nil
+        end
+      end
+    end
+
+    def part_file_name(part)
+      file_name =
+        part["content-disposition"]&.parameters&.[]("filename") ||
+        part["content-type"]&.parameters&.[]("name") ||
+        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
+        $2.encode("utf-8", $1)
+      else
+        decoded_file_name
+      end
+    end
+
+    def part_default_file_name(part)
+      base_name = part.cid.gsub(/[^A-Za-z0-9_\-]/, "_")
+      ext = part_extension(part)
+      if ext
+        base_name + "." + ext
+      else
+        base_name
+      end
+    end
+
+    def part_extension(part)
+      mime_type = part["content-type"].string
+      MIME::Types[mime_type]&.first&.preferred_extension
+    end
+
+    def current_uri
+      @buffer.save_excursion do
+        pos = @buffer.point
+        @buffer.beginning_of_line
+        pos2 = @buffer.re_search_forward(URI_REGEXP, raise_error: false)
+        if pos2 && match_beginning(0) <= pos && pos < match_end(0)
+          match_string(0)
+        else
+          nil
+        end
+      end
+    end
+
+    def open_part(part)
+      if part.multipart?
+        raise EditorError, "Can't open a multipart entity."
+      end
+      ext = part_file_name(part).slice(/\.([^.]+)\z/, 1)
+      if ext
+        file_name = ["mournmail", "." + ext]
+      else
+        file_name = "mournmail"
+      end
+      f = Tempfile.open(file_name)
+      f.write(part.decoded)
+      f.close
+      if ext == "txt"
+        find_file(f.path)
+      else
+        background do
+          system(*CONFIG[:mournmail_file_open_comamnd], f.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)
+    end
+  end
+end

data/lib/mournmail/message_rendering.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "mail"
+require "mail-iso-2022-jp"
+
+module Mournmail
+  module MessageRendering
+    refine ::Mail::Message do
+      def render(indices = [])
+        render_header + "\n" + render_body(indices)
+      end
+
+      def render_header
+        CONFIG[:mournmail_display_header_fields].map { |name|
+          val = self[name]
+          val ? "#{name}: #{val}\n" : ""
+        }.join
+      end        
+
+      def render_body(indices = [])
+        if HAVE_MAIL_GPG && encrypted?
+          mail = decrypt(verify: true)
+          return mail.render_body(indices)
+        end
+        if multipart?
+          parts.each_with_index.map { |part, i|
+            part.render([*indices, i])
+          }.join
+        else
+          s = body.decoded
+          if /\Autf-8\z/i =~ charset
+            s.force_encoding(Encoding::UTF_8).scrub("?")
+          else
+            s.encode(Encoding::UTF_8, charset, replace: "?")
+          end.gsub(/\r\n/, "\n")
+        end + pgp_signature
+      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 rest_indices.empty?
+          part
+        else
+          part.dig_part(*rest_indices)
+        end
+      end
+
+      private
+
+      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"
+        else
+          ""
+        end
+      end
+    end
+
+    refine ::Mail::Part do
+      def render(indices)
+        index = indices.join(".")
+        type = Mail::Encodings.decode_encode(self["content-type"].to_s,
+                                             :decode)
+        "[#{index} #{type}]\n" + render_content(indices)
+      end
+
+      def dig_part(i, *rest_indices)
+        if main_type == "message" && sub_type == "rfc822"
+          mail = Mail.new(body.raw_source)
+          mail.dig_part(i, *rest_indices)
+        else
+          part = parts[i]
+          if rest_indices.empty?
+            part
+          else
+            part.dig_part(*rest_indices)
+          end
+        end
+      end
+
+      private
+
+      def render_content(indices)
+        if multipart?
+          parts.each_with_index.map { |part, i|
+            part.render([*indices, i])
+          }.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
+            ""
+          end
+        end
+      end
+    end
+  end
+end