sup 0.0.8 → 0.1

data/lib/sup/person.rb

@@ -5,42 +5,89 @@ class PersonManager
 
   def initialize fn
     @fn = fn
-    @names = {}
-    IO.readlines(fn).map { |l| l =~ /^(.*)?:\s+(\d+)\s+(.*)$/ && @names[$1] = [$2.to_i, $3] } if File.exists? fn
+    @@people = {}
+
+    ## read in stored people
+    IO.readlines(fn).map do |l|
+      l =~ /^(.*)?:\s+(\d+)\s+(.*)$/ or raise "can't parse: #{l}"
+      email, time, name = $1, $2, $3
+      @@people[email] = Person.new name, email, time, false
+    end if File.exists? fn
+
     self.class.i_am_the_instance self
   end
 
-  def name_for email; @names.member?(email) ? @names[email][1] : nil; end
-  def register email, name
-    return unless name
+  def save
+    File.open(@fn, "w") do |f|
+      @@people.each do |email, p|
+        f.puts "#{p.email}: #{p.timestamp} #{p.name}"
+      end
+    end
+  end
 
-    name = name.gsub(/^\s+|\s+$/, "").gsub(/\s+/, " ").gsub(/^['"]|['"]$/, "")
+  def self.people_for s, opts={}
+    return [] if s.nil?
+    s.split_on_commas.map { |ss| self.person_for ss, opts }
+  end
 
-    ## all else being equal, prefer longer names, unless the prior name
-    ## doesn't contain any capitalization
-    oldcount, oldname = @names[email]
-    @names[email] = [0, name] if oldname.nil? || oldname.length < name.length || (oldname !~ /[A-Z]/ && name =~ /[A-Z]/)
-    @names[email][0] = Time.now.to_i
+  def self.person_for s, opts={}
+    p = Person.from_address(s) or return nil
+    p.definitive = true if opts[:definitive]
+    register p
   end
+  
+  def self.register p
+    oldp = @@people[p.email]
 
-  def save; File.open(@fn, "w") { |f| @names.each { |email, (time, name)| f.puts "#{email}: #{time} #{name}" } }; end
-end
+    if oldp.nil? || p.better_than?(oldp)
+      @@people[p.email] = p
+    end
 
-class Person
-  @@email_map = {}
+    @@people[p.email].touch!
+    @@people[p.email]
+  end
+end
 
-  attr_accessor :name, :email
+## don't create these by hand. rather, go through personmanager, to
+## ensure uniqueness and overriding.
+class Person 
+  attr_accessor :name, :email, :timestamp
+  bool_accessor :definitive
 
-  def initialize name, email
+  def initialize name, email, timestamp=0, definitive=false
     raise ArgumentError, "email can't be nil" unless email
+    
+    if name
+      @name = name.gsub(/^\s+|\s+$/, "").gsub(/\s+/, " ")
+      if @name =~ /^(['"]\s*)(.*?)(\s*["'])$/
+        @name = $2
+      end
+    end
+
     @email = email.gsub(/^\s+|\s+$/, "").gsub(/\s+/, " ").downcase
-    PersonManager.register @email, name
-    @name = PersonManager.name_for @email
+    @definitive = definitive
+    @timestamp = timestamp
+  end
+
+  ## heuristic: whether the name attached to this email is "real", i.e. 
+  ## we should bother to store it.
+  def generic?
+    @email =~ /no\-?reply/
+  end
+
+  def better_than? o
+    return false if o.definitive? || generic?
+    return true if definitive?
+    o.name.nil? || (name && name.length > o.name.length && name =~ /[a-z]/)
   end
 
-  def == o; o && o.email == email; end
-  alias :eql? :==
-  def hash; [name, email].hash; end
+  def to_s; "#@name <#@email>" end
+
+  def touch!; @timestamp = Time.now.to_i end
+
+#   def == o; o && o.email == email; end
+#   alias :eql? :==
+#   def hash; [name, email].hash; end
 
   def shortname
     case @name
@@ -93,7 +140,7 @@ class Person
     end.downcase
   end
 
-  def self.for s
+  def self.from_address s
     return nil if s.nil?
 
     ## try and parse an email address and name
@@ -110,13 +157,7 @@ class Person
         [nil, s]
       end
 
-    @@email_map[email] ||= Person.new name, email
-  end
-
-  def self.for_several s
-    return [] if s.nil?
-
-    s.split_on_commas.map { |ss| self.for ss }
+    Person.new name, email
   end
 end
 

data/lib/sup/poll.rb

@@ -9,6 +9,7 @@ class PollManager
 
   def initialize
     @mutex = Mutex.new
+    @thread = nil
     @last_poll = nil
     
     self.class.i_am_the_instance self
@@ -29,8 +30,8 @@ class PollManager
     [num, numi]
   end
 
-  def start_thread
-    Redwood::reporting_thread do
+  def start
+    @thread = Redwood::reporting_thread do
       while true
         sleep DELAY / 2
         poll if @last_poll.nil? || (Time.now - @last_poll) >= DELAY
@@ -38,6 +39,11 @@ class PollManager
     end
   end
 
+  def stop
+    @thread.kill if @thread
+    @thread = nil
+  end
+
   def do_poll
     total_num = total_numi = 0
     @mutex.synchronize do
@@ -94,18 +100,21 @@ class PollManager
       
       source.each do |offset, labels|
         if source.has_errors?
-          Redwood::log "error loading messages from #{source}: #{source.broken_msg}"
+          Redwood::log "error loading messages from #{source}: #{source.error.message}"
           return
         end
       
         labels.each { |l| LabelManager << l }
-        labels += [:inbox] unless source.archived?
+        labels = labels + (source.archived? ? [] : [:inbox])
 
         begin
           m = Message.new :source => source, :source_info => offset, :labels => labels
           if m.source_marked_read?
             m.remove_label :unread
             labels.delete :unread
+          else
+            m.add_label :unread
+            labels << :unread
           end
 
           docid, entry = Index.load_entry_for_id m.id

data/lib/sup/rfc2047.rb

@@ -0,0 +1,61 @@
+## from: http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/101949
+
+# $Id: rfc2047.rb,v 1.4 2003/04/18 20:55:56 sam Exp $
+# MODIFIED slightly by William Morgan
+#
+# An implementation of RFC 2047 decoding.
+#
+# This module depends on the iconv library by Nobuyoshi Nakada, which I've 
+# heard may be distributed as a standard part of Ruby 1.8. Many thanks to him
+# for helping with building and using iconv.
+#
+# Thanks to "Josef 'Jupp' Schugt" <jupp / gmx.de> for pointing out an error with
+# stateful character sets.
+#
+# Copyright (c) Sam Roberts <sroberts / uniserve.com> 2004
+#
+# This file is distributed under the same terms as Ruby.
+
+require 'iconv'
+
+module Rfc2047
+  WORD = %r{=\?([!\#$%&'*+-/0-9A-Z\\^\`a-z{|}~]+)\?([BbQq])\?([!->@-~]+)\?=} # :nodoc: 'stupid ruby-mode
+  WORDSEQ = %r{(#{WORD.source})\s+(?=#{WORD.source})}
+
+  def Rfc2047.is_encoded? s; s =~ WORD end
+
+  # Decodes a string, +from+, containing RFC 2047 encoded words into a target
+  # character set, +target+. See iconv_open(3) for information on the
+  # supported target encodings. If one of the encoded words cannot be
+  # converted to the target encoding, it is left in its encoded form.
+  def Rfc2047.decode_to(target, from)
+    from = from.gsub(WORDSEQ, '\1')
+    out = from.gsub(WORD) do
+      |word|
+      charset, encoding, text = $1, $2, $3
+
+      # B64 or QP decode, as necessary:
+      case encoding
+        when 'b', 'B'
+          #puts text
+          text = text.unpack('m*')[0]
+          #puts text.dump
+
+        when 'q', 'Q'
+          # RFC 2047 has a variant of quoted printable where a ' ' character
+          # can be represented as an '_', rather than =32, so convert
+          # any of these that we find before doing the QP decoding.
+          text = text.tr("_", " ")
+          text = text.unpack('M*')[0]
+
+        # Don't need an else, because no other values can be matched in a
+        # WORD.
+      end
+
+      # Convert:
+      #
+      # Remember - Iconv.open(to, from)!
+      text = Iconv.iconv(target, charset, text).join
+    end
+  end
+end

data/lib/sup/sent.rb

@@ -30,18 +30,20 @@ class SentManager
 end
 
 class SentLoader < MBox::Loader
+  yaml_properties :cur_offset
+
   def initialize cur_offset=0
-    filename = Redwood::SENT_FN
-    File.open(filename, "w") { } unless File.exists? filename
-    super "mbox://" + filename, cur_offset, true, true
+    @filename = Redwood::SENT_FN
+    File.open(@filename, "w") { } unless File.exists? @filename
+    super "mbox://" + @filename, cur_offset, true, true
   end
 
+  def file_path; @filename end
+
   def uri; SentManager.source_name; end
   def to_s; SentManager.source_name; end
   def id; SentManager.source_id; end
   def labels; [:sent, :inbox]; end
 end
 
-Redwood::register_yaml(SentLoader, %w(cur_offset))
-
 end

data/lib/sup/source.rb

@@ -5,15 +5,15 @@ class OutOfSyncSourceError < SourceError; end
 class FatalSourceError < SourceError; end
 
 class Source
-  ## Implementing a new source is typically quite easy, because Sup
-  ## only needs to be able to:
+  ## Implementing a new source should be easy, because Sup only needs
+  ## to be able to:
   ##  1. See how many messages it contains
-  ##  2. Get an arbirtrary message
+  ##  2. Get an arbitrary message
   ##  3. (optional) see whether the source has marked it read or not
   ##
   ## In particular, Sup doesn't need to move messages, mark them as
-  ## read, delete them, or anything else. (Well, at some point it will
-  ## need to delete them, but that will be an optional capability.)
+  ## read, delete them, or anything else. (Well, it's nice to be able
+  ## to delete them, but that is optional.)
   ##
   ## On the other hand, Sup assumes that you can assign each message a
   ## unique integer id, such that newer messages have higher ids than
@@ -33,7 +33,8 @@ class Source
   ## - raw_header offset
   ## - raw_full_message offset
   ## - check
-  ## - next (or each, if you prefer)
+  ## - next (or each, if you prefer): should return a message and an
+  ##   array of labels.
   ##
   ## ... where "offset" really means unique id. (You can tell I
   ## started with mbox.)
@@ -46,7 +47,7 @@ class Source
   ## else (e.g. the imap server is down or the maildir is missing.)
   ##
   ## Finally, be sure the source is thread-safe, since it WILL be
-  ## pummeled from multiple threads at once.
+  ## pummelled from multiple threads at once.
   ##
   ## Examples for you to look at: mbox/loader.rb, imap.rb, and
   ## maildir.rb.
@@ -60,6 +61,8 @@ class Source
   attr_accessor :id
 
   def initialize uri, initial_offset=nil, usual=true, archived=false, id=nil
+    raise ArgumentError, "id must be an integer: #{id.inspect}" unless id.is_a? Fixnum if id
+
     @uri = uri
     @cur_offset = initial_offset
     @usual = usual
@@ -68,6 +71,8 @@ class Source
     @dirty = false
   end
 
+  def file_path; nil end
+
   def to_s; @uri.to_s; end
   def seek_to! o; self.cur_offset = o; end
   def reset!; seek_to! start_offset; end
@@ -97,6 +102,4 @@ protected
   end
 end
 
-Redwood::register_yaml(Source, %w(uri cur_offset usual archived id))
-
 end

data/lib/sup/suicide.rb

@@ -0,0 +1,36 @@
+module Redwood
+
+class SuicideManager
+  include Singleton
+
+  DELAY = 5
+
+  def initialize fn
+    @fn = fn
+    @die = false
+    @thread = nil
+    self.class.i_am_the_instance self
+    FileUtils.rm_f @fn
+  end
+
+  bool_reader :die
+
+  def start
+    @thread = Redwood::reporting_thread do
+      while true
+        sleep DELAY
+        if File.exists? @fn
+          FileUtils.rm_f @fn
+          @die = true
+        end
+      end
+    end
+  end
+
+  def stop
+    @thread.kill if @thread
+    @thread = nil
+  end
+end
+
+end

data/lib/sup/tagger.rb

@@ -12,23 +12,23 @@ class Tagger
   def drop_tag_for o; @tagged.delete o; end
 
   def apply_to_tagged
-    num_tagged = @tagged.map { |t| t ? 1 : 0 }.sum
+    targets = @tagged.select_by_value
+    num_tagged = targets.size
     if num_tagged == 0
-      BufferManager.flash "No tagged messages!"
+      BufferManager.flash "No tagged threads!"
       return
     end
 
-    noun = num_tagged == 1 ? "message" : "messages"
+    noun = num_tagged == 1 ? "thread" : "threads"
     c = BufferManager.ask_getch "apply to #{num_tagged} tagged #{noun}:"
     return if c.nil? # user cancelled
 
-    if(action = @mode.resolve_input c)
+    if(action = @mode.resolve_input(c))
       tagged_sym = "multi_#{action}".intern
       if @mode.respond_to? tagged_sym
-        targets = @tagged.select_by_value
         @mode.send tagged_sym, targets
       else
-        BufferManager.flash "That command cannot be applied to multiple messages."
+        BufferManager.flash "That command cannot be applied to multiple threads."
       end
     else
       BufferManager.flash "Unknown command #{c.to_character}."

data/lib/sup/textfield.rb

@@ -2,26 +2,47 @@ require 'curses'
 
 module Redwood
 
+## a fully-functional text field supporting completions, expansions,
+## history--everything!
+##
+## completion is done emacs-style, and mostly depends on outside
+## support, as we merely signal the existence of a new set of
+## completions to show (#new_completions?)  or that the current list
+## of completions should be rolled if they're too large to fill the
+## screen (#roll_completions?).
+##
+## in sup, completion support is implemented through BufferManager#ask
+## and CompletionMode.
 class TextField
-  attr_reader :value
-
   def initialize window, y, x, width
     @w, @x, @y = window, x, y
     @width = width
     @i = nil
     @history = []
+
+    @completion_block = nil
+    reset_completion_state
   end
 
-  def activate question, default=nil
+  bool_reader :new_completions, :roll_completions
+  attr_reader :completions
+
+  ## when the user presses enter, we store the value in @value and
+  ## clean up all the ncurses cruft. before @value is set, we can
+  ## get the current value from ncurses.
+  def value; @field ? get_cur_value : @value end
+
+  def activate question, default=nil, &block
     @question = question
     @value = nil
+    @completion_block = block
     @field = Ncurses::Form.new_field 1, @width - question.length,
                                      @y, @x + question.length, 0, 0
     @form = Ncurses::Form.new_form [@field]
 
     @history[@i = @history.size] = default || ""
     Ncurses::Form.post_form @form
-    @field.set_field_buffer 0, @history[@i]
+    set_cur_value @history[@i]
   end
 
   def position_cursor
@@ -33,24 +54,47 @@ class TextField
   end
 
   def deactivate
+    reset_completion_state
     @form.unpost_form
     @form.free_form
     @field.free_field
+    @field = nil
     Ncurses.curs_set 0
   end
 
   def handle_input c
-    if c == 10 # Ncurses::KEY_ENTER
-      Ncurses::Form.form_driver @form, Ncurses::Form::REQ_VALIDATION
-      @value = @history[@i] = @field.field_buffer(0).gsub(/^\s+|\s+$/, "").gsub(/\s+/, " ")
+    ## short-circuit exit paths
+    case c
+    when Ncurses::KEY_ENTER # submit!
+      @value = @history[@i] = get_cur_value
       return false
-    elsif c == Ncurses::KEY_CANCEL
+    when Ncurses::KEY_CANCEL # cancel
       @history.delete_at @i
       @i = @history.empty? ? nil : (@i - 1) % @history.size 
       @value = nil
       return false
+    when Ncurses::KEY_TAB # completion
+      return true unless @completion_block
+      if @completions.empty?
+        v = get_cur_value
+        c = @completion_block.call v
+        if c.size > 0
+          set_cur_value c.map { |full, short| full }.shared_prefix
+        end
+        if c.size > 1
+          @completions = c
+          @new_completions = true
+          @roll_completions = false
+        end
+      else
+        @new_completions = false
+        @roll_completions = true
+      end
+      return true
     end
 
+    reset_completion_state
+
     d =
       case c
       when Ncurses::KEY_LEFT
@@ -64,21 +108,39 @@ class TextField
       when ?\005
         Ncurses::Form::REQ_END_FIELD
       when Ncurses::KEY_UP
-        @history[@i] = @field.field_buffer(0)
+        @history[@i] = @field.field_buffer 0
         @i = (@i - 1) % @history.size
-        @field.set_field_buffer 0, @history[@i]
+        set_cur_value @history[@i]
       when Ncurses::KEY_DOWN
-        @history[@i] = @field.field_buffer(0)
+        @history[@i] = @field.field_buffer 0
         @i = (@i + 1) % @history.size
-        @field.set_field_buffer 0, @history[@i]
+        set_cur_value @history[@i]
       else
         c
       end
 
     Ncurses::Form.form_driver @form, d
-    Ncurses.refresh
-
     true
   end
+
+private
+
+  def reset_completion_state
+    @completions = []
+    @new_completions = @roll_completions = @clear_completions = false
+  end
+
+  ## ncurses inanity wrapper
+  def get_cur_value
+    Ncurses::Form.form_driver @form, Ncurses::Form::REQ_VALIDATION
+    @field.field_buffer(0).gsub(/^\s+|\s+$/, "").gsub(/\s+/, " ")
+  end
+  
+  ## ncurses inanity wrapper
+  def set_cur_value v
+    @field.set_field_buffer 0, v
+    Ncurses::Form.form_driver @form, Ncurses::Form::REQ_END_FIELD
+  end
+
 end
 end