sup 0.17.0 → 0.18.0

data/doc/Hooks.txt

@@ -0,0 +1,79 @@
+Sup's Hook System
+-----------------
+
+Sup can be easily customized via its hook system, which allows custom
+user code to be injected into Sup's execution path by "hooking" the
+code onto pre-defined events. When those events occur, the code is
+executed.
+
+To see which hooks are available, simply run sup -l. Each hook sits in
+a file in ~/.sup/hooks/. Hooks are written in Ruby, and require no
+class or method definitions, just the executable code itself.
+
+Information passes from Sup to the hook code via Ruby variables
+(actually method calls), and from the hook code back to Sup via a
+return value. The values of variables persists across calls to the
+same hook, but is NOT available to other hooks. To make the value of a
+variable available to other hooks, use the get and set methods.  Each
+hook description lists the variables and return value expected, if
+any.
+
+The following special functions are available to hooks:
+* say msg
+  Displays the string msg to the user at the bottom of the screen.
+* log msg
+  Adds the string msg to the log, which the user can access via the
+  buffer list.
+* ask_yes_or_no question
+  Prompts the user with the string question for a yes or no
+  response. Returns true if the user answered yes, false otherwise.
+* get key
+  Gets the cross-hook value associated with key (which is typically a
+  string). If there is no value for a given key, nil is returned.
+* set key value
+  Sets the cross-hook value associated with key to value. key is
+  typically a string, while value can be whatever type it needs to be,
+  including nil.
+
+Some example hooks:
+
+before-poll:
+  ## runs fetchmail before polling
+  if (@last_fetchmail_time || Time.now) < Time.now - 60
+    say "Running fetchmail..."
+    system "fetchmail >& /dev/null"
+    say "Done running fetchmail."
+  end
+  @last_fetchmail_time = Time.now
+
+
+mime-decode:
+  ## Please read:
+  https://github.com/sup-heliotrope/sup/wiki/Viewing-Attachments for
+  some security concerns on opening attachments.
+
+  ## turn text/html attachments into plain text, unless they are part
+  ## of a multipart/alternative pair
+  require 'shellwords'
+  unless sibling_types.member? "text/plain"
+    case content_type
+    when "text/html"
+      `/usr/bin/w3m -dump -T #{content_type} #{Shellwords.escape filename}`
+    end
+  end
+
+startup:
+  ## runs a background task
+  @bgtask_pid = fork
+  if @bgtask_pid
+    set 'bgtask_pid' @bgtask_pid
+    Process.detach(@bgtask_pid) # so we don't have to wait on it when we go to kill it
+  else
+    exec "background-task args 2&>1 >> /tmp/logfile"
+  end
+
+after-poll:
+  ## kills the background task after the first poll
+  @bgtask_pid = get 'bgtask_pid'
+  Process.kill("TERM", @bgtask_pid) unless @bgtask_pid == nil
+  set 'bgtask_pid' nil

data/doc/Philosophy.txt

@@ -0,0 +1,69 @@
+Should an email client have a philosophy? For many people, email is
+one of our primary means of communication, and email archives are an
+integral part of our long-term memory. Something so important ought to
+warrant a little thought.
+
+Here's Sup's philosophy.
+
+Using "traditional" email clients today is increasingly problematic.
+Anyone who's on a high-traffic mailing list knows this. My ruby-talk
+folder is 430 megs and Mutt sits there for 60 seconds while it opens
+it. Keeping up with the all the new traffic is impossible, even with
+Mutt's excellent threading features, simply because there's so much of
+it. A single thread can span several pages in the folder index view
+alone! And Mutt is probably the fastest, most mailing-list aware email
+client out there. God help me if I try and use Thunderbird.
+
+The problem with traditional clients like Mutt is that they deal with
+individual pieces of email. This places a high mental cost on the user
+for each incoming email, by forcing them to ask: Should I keep this
+email, or delete it? If I keep it, where should I file it? I've spent
+the last 10 years of my life laboriously hand-filing every email
+message I received and feeling a mild sense of panic every time an
+email was both "from Mom" and "about school". The massive amounts of
+email that many people receive, and the cheap cost of storage, have
+made these questions both more costly and less useful to answer.
+
+Contrast that with using Gmail. As a long-time Mutt user, I was blown
+away when I first saw someone use Gmail. They treated their email
+differently from how I ever had. They never filed email and they never
+deleted it. They relied on an immediate, global, full-text search, and
+thread-level tagging, to do everything I'd ever done with Mutt, but
+with a trivial cost to the user at message receipt time.
+
+From Gmail I learned that making certain operations quantitatively
+easier (namely, search) resulted in a qualitative improvement in
+usage. I also learned how thread-centrism was advantageous over
+message-centrism when message volume was high: most of the time, a
+message and its context deserve the same treatment. I think it's to
+the Gmail designers' credit that they started with a somewhat ad-hoc
+idea (hey, we're really good at search engines, so maybe we can build
+an email client on top of one) and managed to build something that was
+actually better than everything else out there. At least, that's how I
+imagine in happened. Maybe they knew what they were doing from the
+start.
+
+Unfortunately, there's a lot to Gmail I can't tolerate (top posting,
+HTML mail, one-level threads, and ads come to mind, never mind the
+fact that it's not FOSS). Thus Sup was born.
+
+Sup is based on the following principles, which I stole directly from
+Gmail:
+
+- An immediately accessible and fast search capability over the entire
+  email archive eliminates most of the need for folders, and most of
+  the necessity of deleting email.
+
+- Labels eliminate what little need for folders search doesn't cover.
+
+- A thread-centric approach to the UI is much more in line with how
+  people operate than dealing with individual messages is. In the vast
+  majority of cases, a message and its context should be subject to
+  the same treatment.
+
+Sup is also based on many ideas from mutt and Emacs and vi, having to
+do with the fantastic productivity of a console- and keyboard-based
+application, the usefulness of multiple buffers, the necessity of
+handling multiple email accounts, etc. But those are just details!
+
+Try it and let me know what you think.

data/lib/sup/colormap.rb

@@ -50,6 +50,7 @@ class Colormap
     :quote => { :fg => "yellow", :bg => "default" },
     :sig => { :fg => "yellow", :bg => "default" },
     :to_me => { :fg => "green", :bg => "default" },
+    :with_attachment => { :fg => "green", :bg => "default" },
     :starred => { :fg => "yellow", :bg => "default", :attrs => ["bold"] },
     :starred_patina => { :fg => "yellow", :bg => "green", :attrs => ["bold"] },
     :alternate_starred_patina => { :fg => "yellow", :bg => "blue", :attrs => ["bold"] },
@@ -190,6 +191,11 @@ class Colormap
       Redwood::load_yaml_obj Redwood::COLOR_FN
     end
 
+    ## Set attachment sybmol to sane default for existing colorschemes
+    if user_colors and user_colors.has_key? :to_me 
+      user_colors[:with_attachment] = user_colors[:to_me] unless user_colors.has_key? :with_attachment
+    end
+
     Colormap::DEFAULT_COLORS.merge(user_colors||{}).each_pair do |k, v|
       fg = begin
         Ncurses.const_get "COLOR_#{v[:fg].to_s.upcase}"

data/lib/sup/modes/thread_index_mode.rb

@@ -236,6 +236,13 @@ EOS
     update
   end
 
+  def handle_killed_update sender, m
+    t = @ts_mutex.synchronize { @ts.thread_for m }
+    return unless t
+    hide_thread t
+    update
+  end
+
   def handle_spammed_update sender, m
     t = @ts_mutex.synchronize { @ts.thread_for m }
     return unless t
@@ -247,6 +254,10 @@ EOS
     add_or_unhide m
   end
 
+  def handle_unkilled_update sender, m
+    add_or_unhide m
+  end
+
   def undo
     UndoManager.undo
   end
@@ -979,7 +990,7 @@ protected
       from +
       [
       [:size_widget_color, size_widget_text],
-      [:to_me_color, t.labels.member?(:attachment) ? "@" : " "],
+      [:with_attachment_color , t.labels.member?(:attachment) ? "@" : " "],
       [:to_me_color, directly_participated ? ">" : (participated ? '+' : " ")],
     ] +
       (t.labels - @hidden_labels).sort_by {|x| x.to_s}.map {

data/lib/sup/modes/thread_view_mode.rb

@@ -78,11 +78,13 @@ EOS
 
     k.add :archive_and_next, "Archive this thread, kill buffer, and view next", 'a'
     k.add :delete_and_next, "Delete this thread, kill buffer, and view next", 'd'
+    k.add :kill_and_next, "Kill this thread, kill buffer, and view next", '&'
     k.add :toggle_wrap, "Toggle wrapping of text", 'w'
 
     k.add_multi "(a)rchive/(d)elete/mark as (s)pam/mark as u(N)read:", '.' do |kk|
       kk.add :archive_and_kill, "Archive this thread and kill buffer", 'a'
       kk.add :delete_and_kill, "Delete this thread and kill buffer", 'd'
+      kk.add :kill_and_kill, "Kill this thread and kill buffer", '&'
       kk.add :spam_and_kill, "Mark this thread as spam and kill buffer", 's'
       kk.add :unread_and_kill, "Mark this thread as unread and kill buffer", 'N'
       kk.add :do_nothing_and_kill, "Just kill this buffer", '.'
@@ -91,6 +93,7 @@ EOS
     k.add_multi "(a)rchive/(d)elete/mark as (s)pam/mark as u(N)read/do (n)othing:", ',' do |kk|
       kk.add :archive_and_next, "Archive this thread, kill buffer, and view next", 'a'
       kk.add :delete_and_next, "Delete this thread, kill buffer, and view next", 'd'
+      kk.add :kill_and_next, "Kill this thread, kill buffer, and view next", '&'
       kk.add :spam_and_next, "Mark this thread as spam, kill buffer, and view next", 's'
       kk.add :unread_and_next, "Mark this thread as unread, kill buffer, and view next", 'N'
       kk.add :do_nothing_and_next, "Kill buffer, and view next", 'n', ','
@@ -99,6 +102,7 @@ EOS
     k.add_multi "(a)rchive/(d)elete/mark as (s)pam/mark as u(N)read/do (n)othing:", ']' do |kk|
       kk.add :archive_and_prev, "Archive this thread, kill buffer, and view previous", 'a'
       kk.add :delete_and_prev, "Delete this thread, kill buffer, and view previous", 'd'
+      kk.add :kill_and_prev, "Kill this thread, kill buffer, and view previous", '&'
       kk.add :spam_and_prev, "Mark this thread as spam, kill buffer, and view previous", 's'
       kk.add :unread_and_prev, "Mark this thread as unread, kill buffer, and view previous", 'N'
       kk.add :do_nothing_and_prev, "Kill buffer, and view previous", 'n', ']'
@@ -581,18 +585,21 @@ EOS
   def archive_and_kill; archive_and_then :kill end
   def spam_and_kill; spam_and_then :kill end
   def delete_and_kill; delete_and_then :kill end
+  def kill_and_kill; kill_and_then :kill end
   def unread_and_kill; unread_and_then :kill end
   def do_nothing_and_kill; do_nothing_and_then :kill end
 
   def archive_and_next; archive_and_then :next end
   def spam_and_next; spam_and_then :next end
   def delete_and_next; delete_and_then :next end
+  def kill_and_next; kill_and_then :next end
   def unread_and_next; unread_and_then :next end
   def do_nothing_and_next; do_nothing_and_then :next end
 
   def archive_and_prev; archive_and_then :prev end
   def spam_and_prev; spam_and_then :prev end
   def delete_and_prev; delete_and_then :prev end
+  def kill_and_prev; kill_and_then :prev end
   def unread_and_prev; unread_and_then :prev end
   def do_nothing_and_prev; do_nothing_and_then :prev end
 
@@ -635,6 +642,19 @@ EOS
     end
   end
 
+  def kill_and_then op
+    dispatch op do
+      @thread.apply_label :killed
+      UpdateManager.relay self, :killed, @thread.first
+      Index.save_thread @thread
+      UndoManager.register "killed 1 thread" do
+        @thread.remove_label :killed
+        Index.save_thread @thread
+        UpdateManager.relay self, :unkilled, @thread.first
+      end
+    end
+  end
+
   def unread_and_then op
     dispatch op do
       @thread.apply_label :unread

data/lib/sup/version.rb

@@ -1,3 +1,3 @@
 module Redwood
-  VERSION = "0.17.0"
+  VERSION = "0.18.0"
 end

data/sup.gemspec

@@ -0,0 +1,55 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+require 'sup/version'
+
+Gem::Specification.new do |s|
+  s.name = "sup"
+  s.version = ENV["REL"] || (::Redwood::VERSION == "git" ? "999" : ::Redwood::VERSION)
+  s.date = Time.now.strftime "%Y-%m-%d"
+  s.authors = ["William Morgan", "Gaute Hope", "Hamish Downer", "Matthieu Rakotojaona"]
+  s.email   = "sup-talk@rubyforge.org"
+  s.summary = "A console-based email client with the best features of GMail, mutt and Emacs"
+  s.homepage = "http://supmua.org"
+  s.license = 'GPL-2'
+  s.description = <<-DESC
+    Sup is a console-based email client for people with a lot of email.
+
+    * GMail-like thread-centered archiving, tagging and muting
+    * Handling mail from multiple mbox and Maildir sources
+    * Blazing fast full-text search with a rich query language
+    * Multiple accounts - pick the right one when sending mail
+    * Ruby-programmable hooks
+    * Automatically tracking recent contacts
+DESC
+  s.post_install_message = <<-EOF
+SUP: If you are upgrading Sup from before version 0.14.0: Please
+   run `sup-psych-ify-config-files` to migrate from 0.13.
+
+   Check https://github.com/sup-heliotrope/sup/wiki/Migration-0.13-to-0.14
+   for more detailed and up-to-date instructions.
+  EOF
+
+  s.files         = `git ls-files -z`.split("\x0")
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+
+  s.required_ruby_version = '>= 1.9.3'
+
+  s.add_runtime_dependency "xapian-ruby", "~> 1.2.15"
+  s.add_runtime_dependency "ncursesw", "~> 1.4.0"
+  s.add_runtime_dependency "rmail-sup", "~> 1.0.1"
+  s.add_runtime_dependency "highline"
+  s.add_runtime_dependency "trollop", ">= 1.12"
+  s.add_runtime_dependency "lockfile"
+  s.add_runtime_dependency "mime-types", "~> 1.0"
+  s.add_runtime_dependency "locale", "~> 2.0"
+  s.add_runtime_dependency "chronic", "~> 0.9.1"
+  s.add_runtime_dependency "unicode", "~> 0.4.4"
+
+  s.add_development_dependency "bundler", "~> 1.3"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "minitest", "~> 4.7"
+  s.add_development_dependency "rr", "~> 1.0.5"
+  s.add_development_dependency "gpgme", ">= 2.0.2"
+end

data/test/dummy_source.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/ruby
+
+require 'sup'
+require 'stringio'
+require 'rmail'
+require 'uri'
+
+module Redwood
+
+class DummySource < Source
+
+  attr_accessor :messages
+
+  def initialize uri, last_date=nil, usual=true, archived=false, id=nil, labels=[]
+    super uri, usual, archived, id
+    @messages = nil
+  end
+
+  def start_offset
+    0
+  end
+
+  def end_offset
+    # should contain the number of test messages -1
+    return @messages ? @messages.length - 1 : 0
+  end
+
+  def load_header offset
+    Source.parse_raw_email_header StringIO.new(raw_header(offset))
+  end
+
+  def load_message offset
+    RMail::Parser.read raw_message(offset)
+  end
+
+  def raw_header offset
+    ret = ""
+    f = StringIO.new(@messages[offset])
+    until f.eof? || (l = f.gets) =~ /^$/
+      ret += l
+    end
+    ret
+  end
+
+  def raw_message offset
+    @messages[offset]
+  end
+
+  def each_raw_message_line offset
+    ret = ""
+    f = StringIO.new(@messages[offset])
+    until f.eof?
+      yield f.gets
+    end
+  end
+end
+
+end
+
+# vim:noai:ts=2:sw=2:
+

data/test/gnupg_test_home/gpg.conf

@@ -0,0 +1 @@
+default-key 789E7011

data/test/gnupg_test_home/sup-test-2@foo.bar.asc

@@ -0,0 +1,20 @@
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+Version: GnuPG v2.0.20 (GNU/Linux)
+
+mI0EUgi0fAEEAOLAcQW96NEUSB7YE/la8X56jGW5BMX3aAixOF8LvOwMBbUK1T+U
+0H2PGIrXVcYyHcPqWRpRahbsIAldBqzffPlzMa+aqJaB1xKkNruxSoIzwPdidZMe
+l0Dxz2FDsoXD0KPyWnAYhGmQyz2MFpZxu2tlYqvwWVW//XGnk/KHvIXbABEBAAG0
+PlN1cCBUZXN0IFJlY2VpdmVyIChUZXN0IHJlY2VpdmVyIGZvciBTdXApIDxzdXAt
+dGVzdC0yQGZvby5iYXI+iL8EEwECACkFAlIItHwCGwMFCQHhM4AHCwkIBwMCAQYV
+CAIJCgsEFgIDAQIeAQIXgAAKCRAsABl+cWpykMMVBADHkQPgTz0CqKKp3k+z3dbm
+ocmI4tYNn1dOkDQqyfoBTfs6L3g4j5OE2UrguntRYyg5oon+uO5d18CQ5dY0sCw/
+o5IwyzTrxI8IocbtZvBdSb+XjLndynGuIQoqaJq9i6n1V4klFHVOna8Q9JstLfRX
+H1d4xPhnvKcaDDx/NV3X/biNBFIItHwBBADBpb43MpkrUWlg7HWJ1ZfOlxnOxrJ3
+Gz9WFNV06UbcZEuFKA/vHRjM6gWzUn5903FLuCWu3eBrq5xQfWipbp187PmocpoG
+skJ6gosLs1fMYRBjv2VbG9xJVKdKJMjqZw5FUpXKAaHr8P9jN6g2STQrbeQ8CVUK
+h7zOWRXAXSKUgwARAQABiKUEGAECAA8FAlIItHwCGwwFCQHhM4AACgkQLAAZfnFq
+cpDV1QQAzcxFXznEX92DjWxWRC7gRHgIsQk9WJnDzjtnDjSWCp3H85qeTZGZrn9W
+NoneV/S5Y7K3Mkceh4rFaANQ3zx4b05y1LFt5N/lPwIe5VB0vcPumtZum2fSGfpK
+nTXvzelcWcm2aGyUSaWvOkntWKEEt1kB5Oq6EtZoRZLMzAxLd7s=
+=aKsV
+-----END PGP PUBLIC KEY BLOCK-----

data/test/integration/test_label_service.rb

@@ -0,0 +1,18 @@
+require "test_helper"
+
+require "sup/service/label_service"
+
+require "tmpdir"
+
+describe Redwood::LabelService do
+  let(:tmpdir) { Dir.mktmpdir }
+  after do
+    require "fileutils"
+    FileUtils.remove_entry_secure @tmpdir unless @tmpdir.nil?
+  end
+
+  describe "#add_labels" do
+    # Integration tests are hard to write at this moment :(
+    it "add labels to all messages matching the query"
+  end
+end