sup 0.19.0

data/lib/sup/interactive_lock.rb

@@ -0,0 +1,89 @@
+require 'fileutils'
+
+module Redwood
+
+## wrap a nice interactive layer on top of anything that has a #lock method
+## which throws a LockError which responds to #user, #host, #mtim, #pname, and
+## #pid.
+
+module InteractiveLock
+  def pluralize number_of, kind; "#{number_of} #{kind}" + (number_of == 1 ? "" : "s") end
+
+  def time_ago_in_words time
+    secs = (Time.now - time).to_i
+    mins = secs / 60
+    time = if mins == 0
+      pluralize secs, "second"
+    else
+      pluralize mins, "minute"
+    end
+  end
+
+  DELAY = 5 # seconds
+
+  def lock_interactively stream=$stderr
+    begin
+      Index.lock
+    rescue Index::LockError => e
+      begin
+        Process.kill 0, e.pid.to_i # 0 signal test the existence of PID
+        stream.puts <<EOS
+  Error: the index is locked by another process! User '#{e.user}' on
+  host '#{e.host}' is running #{e.pname} with pid #{e.pid}.
+  The process was alive as of at least #{time_ago_in_words e.mtime} ago.
+
+EOS
+        stream.print "Should I ask that process to kill itself (y/n)? "
+        stream.flush
+        if $stdin.gets =~ /^\s*y(es)?\s*$/i
+          Process.kill "TERM", e.pid.to_i
+          sleep DELAY
+          stream.puts "Let's try that again."
+          begin
+            Index.lock
+          rescue Index::LockError => e
+            stream.puts "I couldn't lock the index. The lockfile might just be stale."
+            stream.print "Should I just remove it and continue? (y/n) "
+            stream.flush
+            if $stdin.gets =~ /^\s*y(es)?\s*$/i
+              begin
+                FileUtils.rm e.path
+              rescue Errno::ENOENT
+                stream.puts "The lockfile doesn't exists. We continue."
+              end
+              stream.puts "Let's try that one more time."
+              begin
+                Index.lock
+              rescue Index::LockError => e
+                stream.puts "I couldn't unlock the index."
+                return false
+              end
+              return true
+            end
+          end
+        end
+      rescue Errno::ESRCH # no such process
+        stream.puts "I couldn't lock the index. The lockfile might just be stale."
+        begin
+          FileUtils.rm e.path
+        rescue Errno::ENOENT
+          stream.puts "The lockfile doesn't exists. We continue."
+        end
+        stream.puts "Let's try that one more time."
+        begin
+          sleep DELAY
+          Index.lock
+        rescue Index::LockError => e
+          stream.puts "I couldn't unlock the index."
+          return false
+        end
+        return true
+      end
+      stream.puts "Sorry, couldn't unlock the index."
+      return false
+    end
+    return true
+  end
+end
+
+end

data/lib/sup/keymap.rb

@@ -0,0 +1,140 @@
+require 'sup/util/ncurses'
+
+module Redwood
+
+class Keymap
+
+  HookManager.register "keybindings", <<EOS
+Add custom keybindings.
+Methods:
+  modes: Hash from mode names to mode classes.
+  global_keymap: The top-level keymap.
+EOS
+
+  def initialize
+    @map = {}
+    @order = []
+    yield self if block_given?
+  end
+
+  def self.keysym_to_keycode k
+    case k
+    when :down then Ncurses::KEY_DOWN
+    when :up then Ncurses::KEY_UP
+    when :left then Ncurses::KEY_LEFT
+    when :right then Ncurses::KEY_RIGHT
+    when :page_down then Ncurses::KEY_NPAGE
+    when :page_up then Ncurses::KEY_PPAGE
+    when :backspace then Ncurses::KEY_BACKSPACE
+    when :home then Ncurses::KEY_HOME
+    when :end then Ncurses::KEY_END
+    when :ctrl_l then "\f".ord
+    when :ctrl_g then "\a".ord
+    when :tab then "\t".ord
+    when :enter, :return then 10 #Ncurses::KEY_ENTER
+    else
+      if k.is_a?(String) && k.length == 1
+        k.ord
+      else
+        raise ArgumentError, "unknown key name '#{k}'"
+      end
+    end
+  end
+
+  def self.keysym_to_string k
+    case k
+    when :down then "<down arrow>"
+    when :up then "<up arrow>"
+    when :left then "<left arrow>"
+    when :right then "<right arrow>"
+    when :page_down then "<page down>"
+    when :page_up then "<page up>"
+    when :backspace then "<backspace>"
+    when :home then "<home>"
+    when :end then "<end>"
+    when :enter, :return then "<enter>"
+    when :tab then "tab"
+    when " " then "<space>"
+    else
+      Ncurses::keyname(keysym_to_keycode(k))
+    end
+  end
+
+  def add action, help, *keys
+    entry = [action, help, keys]
+    @order << entry
+    keys.each do |k|
+      kc = Keymap.keysym_to_keycode k
+      raise ArgumentError, "key '#{k}' already defined (as #{@map[kc].first})" if @map.include? kc
+      @map[kc] = entry
+    end
+  end
+
+  def delete k
+    kc = Keymap.keysym_to_keycode(k)
+    return unless @map.member? kc
+    entry = @map.delete kc
+    keys = entry[2]
+    keys.delete k
+    @order.delete entry if keys.empty?
+  end
+
+  def add! action, help, *keys
+    keys.each { |k| delete k }
+    add action, help, *keys
+  end
+
+  def add_multi prompt, key
+    kc = Keymap.keysym_to_keycode(key)
+    if @map.member? kc
+      action = @map[kc].first
+      raise "existing action is not a keymap" unless action.is_a?(Keymap)
+      yield action
+    else
+      submap = Keymap.new
+      add submap, prompt, key
+      yield submap
+    end
+  end
+
+  def action_for kc
+    action, help, keys = @map[kc.code]
+    [action, help]
+  end
+
+  def has_key? k; @map[k.code] end
+
+  def keysyms; @map.values.map { |action, help, keys| keys }.flatten; end
+
+  def help_lines except_for={}, prefix=""
+    lines = [] # :(
+    @order.each do |action, help, keys|
+      valid_keys = keys.select { |k| !except_for[k] }
+      next if valid_keys.empty?
+      case action
+      when Symbol
+        lines << [valid_keys.map { |k| prefix + Keymap.keysym_to_string(k) }.join(", "), help]
+      when Keymap
+        lines += action.help_lines({}, prefix + Keymap.keysym_to_string(keys.first))
+      end
+    end.compact
+    lines
+  end
+
+  def help_text except_for={}
+    lines = help_lines except_for
+    llen = lines.max_of { |a, b| a.length }
+    lines.map { |a, b| sprintf " %#{llen}s : %s", a, b }.join("\n")
+  end
+
+  def self.run_hook global_keymap
+    modes = Hash[Mode.keymaps.map { |klass,keymap| [Mode.make_name(klass.name),klass] }]
+    locals = {
+      :modes => modes,
+      :global_keymap => global_keymap,
+    }
+    HookManager.run 'keybindings', locals
+  end
+end
+
+end

data/lib/sup/label.rb

@@ -0,0 +1,87 @@
+# encoding: utf-8
+
+module Redwood
+
+class LabelManager
+  include Redwood::Singleton
+
+  ## labels that have special semantics. user will be unable to
+  ## add/remove these via normal label mechanisms.
+  RESERVED_LABELS = [ :starred, :spam, :draft, :unread, :killed, :sent, :deleted, :inbox, :attachment, :forwarded, :replied ]
+
+  ## labels that will typically be hidden from the user
+  HIDDEN_RESERVED_LABELS = [ :starred, :unread, :attachment, :forwarded, :replied ]
+
+  def initialize fn
+    @fn = fn
+    labels =
+      if File.exists? fn
+        IO.readlines(fn).map { |x| x.chomp.intern }
+      else
+        []
+      end
+    @labels = {}
+    @new_labels = {}
+    @modified = false
+    labels.each { |t| @labels[t] = true }
+  end
+
+  def new_label? l; @new_labels.include?(l) end
+
+  ## all labels user-defined and system, ordered
+  ## nicely and converted to pretty strings. use #label_for to recover
+  ## the original label.
+  def all_labels
+    ## uniq's only necessary here because of certain upgrade issues
+    (RESERVED_LABELS + @labels.keys).uniq
+  end
+
+  ## all user-defined labels, ordered
+  ## nicely and converted to pretty strings. use #label_for to recover
+  ## the original label.
+  def user_defined_labels
+    @labels.keys
+  end
+
+  ## reverse the label->string mapping, for convenience!
+  def string_for l
+    if RESERVED_LABELS.include? l
+      l.to_s.capitalize
+    else
+      l.to_s
+    end
+  end
+
+  def label_for s
+    l = s.intern
+    l2 = s.downcase.intern
+    if RESERVED_LABELS.include? l2
+      l2
+    else
+      l
+    end
+  end
+
+  def << t
+    raise ArgumentError, "expecting a symbol" unless t.is_a? Symbol
+    unless @labels.member?(t) || RESERVED_LABELS.member?(t)
+      @labels[t] = true
+      @new_labels[t] = true
+      @modified = true
+    end
+  end
+
+  def delete t
+    if @labels.delete(t)
+      @modified = true
+    end
+  end
+
+  def save
+    return unless @modified
+    File.open(@fn, "w:UTF-8") { |f| f.puts @labels.keys.sort_by { |l| l.to_s } }
+    @new_labels = {}
+  end
+end
+
+end

data/lib/sup/logger.rb

@@ -0,0 +1,77 @@
+require "sup/util"
+require 'stringio'
+require 'thread'
+
+module Redwood
+
+## simple centralized logger. outputs to multiple sinks by calling << on them.
+## also keeps a record of all messages, so that adding a new sink will send all
+## previous messages to it by default.
+class Logger
+  include Redwood::Singleton
+
+  LEVELS = %w(debug info warn error) # in order!
+
+  def initialize level=nil
+    level ||= ENV["SUP_LOG_LEVEL"] || "info"
+    self.level = level
+    @mutex = Mutex.new
+    @buf = StringIO.new
+    @sinks = []
+  end
+
+  def level; LEVELS[@level] end
+  def level=(level); @level = LEVELS.index(level) || raise(ArgumentError, "invalid log level #{level.inspect}: should be one of #{LEVELS * ', '}"); end
+
+  def add_sink s, copy_current=true
+    @mutex.synchronize do
+      @sinks << s
+      s << @buf.string if copy_current
+    end
+  end
+
+  def remove_sink s; @mutex.synchronize { @sinks.delete s } end
+  def remove_all_sinks!; @mutex.synchronize { @sinks.clear } end
+  def clear!; @mutex.synchronize { @buf = StringIO.new } end
+
+  LEVELS.each_with_index do |l, method_level|
+    define_method(l) do |s|
+      if method_level >= @level
+        send_message format_message(l, Time.now, s)
+      end
+    end
+  end
+
+  ## send a message regardless of the current logging level
+  def force_message m; send_message format_message(nil, Time.now, m) end
+
+private
+
+  ## level can be nil!
+  def format_message level, time, msg
+    prefix = case level
+      when "warn"; "WARNING: "
+      when "error"; "ERROR: "
+      else ""
+    end
+    "[#{time.to_s}] #{prefix}#{msg.rstrip}\n"
+  end
+
+  ## actually distribute the message
+  def send_message m
+    @mutex.synchronize do
+      @sinks.each do |sink|
+        sink << m
+        sink.flush if sink.respond_to?(:flush) and level == "debug"
+      end
+      @buf << m
+    end
+  end
+end
+
+## include me to have top-level #debug, #info, etc. methods.
+module LogsStuff
+  Logger::LEVELS.each { |l| define_method(l) { |s| Logger.instance.send(l, s) } }
+end
+
+end

data/lib/sup/logger/singleton.rb

@@ -0,0 +1,10 @@
+# TODO: this is ugly. It's better to have a application singleton passed
+# down to lower level components instead of including logging methods in
+# class `Object'
+#
+# For now this is what we have to do.
+require "sup/logger"
+Redwood::Logger.init.add_sink $stderr
+class Object
+  include Redwood::LogsStuff
+end

data/lib/sup/maildir.rb

@@ -0,0 +1,257 @@
+require 'uri'
+require 'set'
+
+module Redwood
+
+class Maildir < Source
+  include SerializeLabelsNicely
+  MYHOSTNAME = Socket.gethostname
+
+  ## remind me never to use inheritance again.
+  yaml_properties :uri, :usual, :archived, :sync_back, :id, :labels
+  def initialize uri, usual=true, archived=false, sync_back=true, id=nil, labels=[]
+    super uri, usual, archived, id
+    @expanded_uri = Source.expand_filesystem_uri(uri)
+    uri = URI(@expanded_uri)
+
+    raise ArgumentError, "not a maildir URI" unless uri.scheme == "maildir"
+    raise ArgumentError, "maildir URI cannot have a host: #{uri.host}" if uri.host
+    raise ArgumentError, "maildir URI must have a path component" unless uri.path
+
+    @sync_back = sync_back
+    # sync by default if not specified
+    @sync_back = true if @sync_back.nil?
+
+    @dir = uri.path
+    @labels = Set.new(labels || [])
+    @mutex = Mutex.new
+    @ctimes = { 'cur' => Time.at(0), 'new' => Time.at(0) }
+  end
+
+  def file_path; @dir end
+  def self.suggest_labels_for path; [] end
+  def is_source_for? uri; super || (uri == @expanded_uri); end
+
+  def supported_labels?
+    [:draft, :starred, :forwarded, :replied, :unread, :deleted]
+  end
+
+  def sync_back_enabled?
+    @sync_back
+  end
+
+  def store_message date, from_email, &block
+    stored = false
+    new_fn = new_maildir_basefn + ':2,S'
+    Dir.chdir(@dir) do |d|
+      tmp_path = File.join(@dir, 'tmp', new_fn)
+      new_path = File.join(@dir, 'new', new_fn)
+      begin
+        sleep 2 if File.stat(tmp_path)
+
+        File.stat(tmp_path)
+      rescue Errno::ENOENT #this is what we want.
+        begin
+          File.open(tmp_path, 'wb') do |f|
+            yield f #provide a writable interface for the caller
+            f.fsync
+          end
+
+          File.safe_link tmp_path, new_path
+          stored = true
+        ensure
+          File.unlink tmp_path if File.exists? tmp_path
+        end
+      end #rescue Errno...
+    end #Dir.chdir
+
+    stored
+  end
+
+  def each_raw_message_line id
+    with_file_for(id) do |f|
+      until f.eof?
+        yield f.gets
+      end
+    end
+  end
+
+  def load_header id
+    with_file_for(id) { |f| parse_raw_email_header f }
+  end
+
+  def load_message id
+    with_file_for(id) { |f| RMail::Parser.read f }
+  end
+
+  def sync_back id, labels
+    synchronize do
+      debug "syncing back maildir message #{id} with flags #{labels.to_a}"
+      flags = maildir_reconcile_flags id, labels
+      maildir_mark_file id, flags
+    end
+  end
+
+  def raw_header id
+    ret = ""
+    with_file_for(id) do |f|
+      until f.eof? || (l = f.gets) =~ /^$/
+        ret += l
+      end
+    end
+    ret
+  end
+
+  def raw_message id
+    with_file_for(id) { |f| f.read }
+  end
+
+  ## XXX use less memory
+  def poll
+    added = []
+    deleted = []
+    updated = []
+    @ctimes.each do |d,prev_ctime|
+      subdir = File.join @dir, d
+      debug "polling maildir #{subdir}"
+      raise FatalSourceError, "#{subdir} not a directory" unless File.directory? subdir
+      ctime = File.ctime subdir
+      next if prev_ctime >= ctime
+      @ctimes[d] = ctime
+
+      old_ids = benchmark(:maildir_read_index) { Index.instance.enum_for(:each_source_info, self.id, "#{d}/").to_a }
+      new_ids = benchmark(:maildir_read_dir) { Dir.glob("#{subdir}/*").map { |x| File.join(d,File.basename(x)) }.sort }
+      added += new_ids - old_ids
+      deleted += old_ids - new_ids
+      debug "#{old_ids.size} in index, #{new_ids.size} in filesystem"
+    end
+
+    ## find updated mails by checking if an id is in both added and
+    ## deleted arrays, meaning that its flags changed or that it has
+    ## been moved, these ids need to be removed from added and deleted
+    add_to_delete = del_to_delete = []
+    map = Hash.new { |hash, key| hash[key] = [] }
+    deleted.each do |id_del|
+        map[maildir_data(id_del)[0]].push id_del
+    end
+    added.each do |id_add|
+        map[maildir_data(id_add)[0]].each do |id_del|
+          updated.push [ id_del, id_add ]
+          add_to_delete.push id_add
+          del_to_delete.push id_del
+        end
+    end
+    added -= add_to_delete
+    deleted -= del_to_delete
+    debug "#{added.size} added, #{deleted.size} deleted, #{updated.size} updated"
+    total_size = added.size+deleted.size+updated.size
+
+    added.each_with_index do |id,i|
+      yield :add,
+      :info => id,
+      :labels => @labels + maildir_labels(id) + [:inbox],
+      :progress => i.to_f/total_size
+    end
+
+    deleted.each_with_index do |id,i|
+      yield :delete,
+      :info => id,
+      :progress => (i.to_f+added.size)/total_size
+    end
+
+    updated.each_with_index do |id,i|
+      yield :update,
+      :old_info => id[0],
+      :new_info => id[1],
+      :labels => @labels + maildir_labels(id[1]),
+      :progress => (i.to_f+added.size+deleted.size)/total_size
+    end
+    nil
+  end
+
+  def labels? id
+    maildir_labels id
+  end
+
+  def maildir_labels id
+    (seen?(id) ? [] : [:unread]) +
+      (trashed?(id) ?  [:deleted] : []) +
+      (flagged?(id) ? [:starred] : []) +
+      (passed?(id) ? [:forwarded] : []) +
+      (replied?(id) ? [:replied] : []) +
+      (draft?(id) ? [:draft] : [])
+  end
+
+  def draft? id; maildir_data(id)[2].include? "D"; end
+  def flagged? id; maildir_data(id)[2].include? "F"; end
+  def passed? id; maildir_data(id)[2].include? "P"; end
+  def replied? id; maildir_data(id)[2].include? "R"; end
+  def seen? id; maildir_data(id)[2].include? "S"; end
+  def trashed? id; maildir_data(id)[2].include? "T"; end
+
+  def valid? id
+    File.exists? File.join(@dir, id)
+  end
+
+private
+
+  def new_maildir_basefn
+    Kernel::srand()
+    "#{Time.now.to_i.to_s}.#{$$}#{Kernel.rand(1000000)}.#{MYHOSTNAME}"
+  end
+
+  def with_file_for id
+    fn = File.join(@dir, id)
+    begin
+      File.open(fn, 'rb') { |f| yield f }
+    rescue SystemCallError, IOError => e
+      raise FatalSourceError, "Problem reading file for id #{id.inspect}: #{fn.inspect}: #{e.message}."
+    end
+  end
+
+  def maildir_data id
+    id = File.basename id
+    # Flags we recognize are DFPRST
+    id =~ %r{^([^:]+):([12]),([A-Za-z]*)$}
+    [($1 || id), ($2 || "2"), ($3 || "")]
+  end
+
+  def maildir_reconcile_flags id, labels
+      new_flags = Set.new( maildir_data(id)[2].each_char )
+
+      # Set flags based on labels for the six flags we recognize
+      if labels.member? :draft then new_flags.add?( "D" ) else new_flags.delete?( "D" ) end
+      if labels.member? :starred then new_flags.add?( "F" ) else new_flags.delete?( "F" ) end
+      if labels.member? :forwarded then new_flags.add?( "P" ) else new_flags.delete?( "P" ) end
+      if labels.member? :replied then new_flags.add?( "R" ) else new_flags.delete?( "R" ) end
+      if not labels.member? :unread then new_flags.add?( "S" ) else new_flags.delete?( "S" ) end
+      if labels.member? :deleted or labels.member? :killed then new_flags.add?( "T" ) else new_flags.delete?( "T" ) end
+
+      ## Flags must be stored in ASCII order according to Maildir
+      ## documentation
+      new_flags.to_a.sort.join
+  end
+
+  def maildir_mark_file orig_path, flags
+    @mutex.synchronize do
+      new_base = (flags.include?("S")) ? "cur" : "new"
+      md_base, md_ver, md_flags = maildir_data orig_path
+
+      return if md_flags == flags
+
+      new_loc = File.join new_base, "#{md_base}:#{md_ver},#{flags}"
+      orig_path = File.join @dir, orig_path
+      new_path  = File.join @dir, new_loc
+      tmp_path  = File.join @dir, "tmp", "#{md_base}:#{md_ver},#{flags}"
+
+      File.safe_link orig_path, tmp_path
+      File.unlink orig_path
+      File.safe_link tmp_path, new_path
+      File.unlink tmp_path
+
+      new_loc
+    end
+  end
+end
+
+end