sup 0.0.1

data/lib/sup/keymap.rb

@@ -0,0 +1,89 @@
+require "curses"
+
+module Redwood
+
+class Keymap
+  def initialize
+    @map = {}
+    @order = []
+    yield self if block_given?
+  end
+
+  def keysym_to_keycode k
+    case k
+    when :down: Curses::KEY_DOWN
+    when :up: Curses::KEY_UP
+    when :left: Curses::KEY_LEFT
+    when :right: Curses::KEY_RIGHT
+    when :page_down: Curses::KEY_NPAGE
+    when :page_up: Curses::KEY_PPAGE
+    when :backspace: Curses::KEY_BACKSPACE
+    when :home: Curses::KEY_HOME
+    when :end: Curses::KEY_END
+    when :ctrl_l: "\f"[0]
+    when :ctrl_g: "\a"[0]
+    when :tab: "\t"[0]
+    when :enter, :return: 10 #Curses::KEY_ENTER
+    else
+      if k.is_a?(String) && k.length == 1
+        k[0]
+      else
+        raise ArgumentError, "unknown key name '#{k}'"
+      end
+    end
+  end
+
+  def keysym_to_string k
+    case k
+    when :down: "<down arrow>"
+    when :up: "<up arrow>"
+    when :left: "<left arrow>"
+    when :right: "<right arrow>"
+    when :page_down: "<page down>"
+    when :page_up: "<page up>"
+    when :backspace: "<backspace>"
+    when :home: "<home>"
+    when :end: "<end>"
+    when :enter, :return: "<enter>"
+    when :ctrl_l: "ctrl-l"
+    when :ctrl_l: "ctrl-g"
+    when :tab: "tab"
+    when " ": "<space>"
+    else
+      if k.is_a?(String) && k.length == 1
+        k
+      else
+        raise ArgumentError, "unknown key name \"#{k}\""
+      end
+    end
+  end
+
+  def add action, help, *keys
+    entry = [action, help, keys]
+    @order << entry
+    keys.each do |k|
+      raise ArgumentError, "key #{k} already defined (action #{action})" if @map.include? k
+      kc = keysym_to_keycode k
+      @map[kc] = entry
+    end
+  end
+
+  def action_for kc
+    action, help, keys = @map[kc]
+    action
+  end
+
+  def keysyms; @map.values.map { |action, help, keys| keys }.flatten; end
+
+  def help_text except_for={}
+    lines = @order.map do |action, help, keys|
+      valid_keys = keys.select { |k| !except_for[k] }
+      next if valid_keys.empty?
+      [valid_keys.map { |k| keysym_to_string k }.join(", "), help]
+    end.compact
+    llen = lines.map { |a, b| a.length }.max
+    lines.map { |a, b| sprintf " %#{llen}s : %s", a, b }.join("\n")
+  end
+end
+
+end

data/lib/sup/label.rb

@@ -0,0 +1,41 @@
+module Redwood
+
+class LabelManager
+  include Singleton
+
+  ## all labels that have special meaning. user will be unable to
+  ## add/remove these via normal label mechanisms.
+  RESERVED_LABELS = [ :starred, :spam, :draft, :unread, :killed, :sent ]
+
+  ## labels which it nonetheless makes sense to search for by
+  LISTABLE_LABELS = [ :starred, :spam, :draft, :sent ]
+
+  ## labels that will never be displayed to the user
+  HIDDEN_LABELS = [ :starred, :unread ]
+
+  def initialize fn
+    @fn = fn
+    labels = 
+      if File.exists? fn
+        IO.readlines(fn).map { |x| x.chomp.intern }
+      else
+        []
+      end
+    @labels = {}
+    labels.each { |t| @labels[t] = true }
+
+    self.class.i_am_the_instance self
+  end
+
+  def user_labels; @labels.keys; end
+
+  def << t; @labels[t] = true unless @labels.member?(t) || RESERVED_LABELS.member?(t); end
+
+  def delete t; @labels.delete t; end
+
+  def save
+    File.open(@fn, "w") { |f| f.puts @labels.keys }
+  end
+end
+
+end

data/lib/sup/logger.rb

@@ -0,0 +1,42 @@
+module Redwood
+
+class Logger
+  @@instance = nil
+
+  attr_reader :buf
+
+  def initialize
+    raise "only one Log can be defined" if @@instance
+    @@instance = self
+    @mode = LogMode.new
+    @respawn = true
+    @spawning = false # to prevent infinite loops!
+  end
+
+  ## must be called if you want to see anything!
+  ## once called, will respawn if killed...
+  def make_buf
+    return if @mode.buffer || !BufferManager.instantiated? || !@respawn || @spawning
+    @spawning = true
+    @mode.text = ""
+    @mode.buffer = BufferManager.instance.spawn "<log>", @mode, :hidden => true
+    @spawning = false
+  end
+
+  def log s
+#    $stderr.puts s
+    @mode << "#{Time.now}: #{s}\n"
+    make_buf
+  end
+  
+  def self.method_missing m, *a
+    @@instance = Logger.new unless @@instance
+    @@instance.send m, *a
+  end
+
+  def self.buffer
+    @@instance.buf
+  end
+end
+
+end

data/lib/sup/mbox.rb

@@ -0,0 +1,51 @@
+require "sup/mbox/loader"
+
+module Redwood
+
+## some utility functions
+module MBox
+  BREAK_RE = /^From \S+@\S+/
+
+  def read_header f
+    header = {}
+    last = nil
+
+    ## i do it in this weird way because i am trying to speed things up
+    ## at load-message time.
+    while(line = f.gets)
+      case line
+      when /^From:\s+(.*)$/i: header[last = "From"] = $1
+      when /^To:\s+(.*)$/i: header[last = "To"] = $1
+      when /^Cc:\s+(.*)$/i: header[last = "Cc"] = $1
+      when /^Bcc:\s+(.*)$/i: header[last = "Bcc"] = $1
+      when /^Subject:\s+(.*)$/i: header[last = "Subject"] = $1
+      when /^Date:\s+(.*)$/i: header[last = "Date"] = $1
+      when /^Message-Id:\s+<(.*)>$/i: header[last = "Message-Id"] = $1
+      when /^References:\s+(.*)$/i: header[last = "References"] = $1
+      when /^In-Reply-To:\s+(.*)$/i: header[last = "In-Reply-To"] = $1
+      when /^List-Post:\s+(.*)$/i: header[last = "List-Post"] = $1
+      when /^Reply-To:\s+(.*)$/i: header[last = "Reply-To"] = $1
+      when /^Status:\s+(.*)$/i: header[last = "Status"] = $1
+      when /^Delivered-To:\s+(.*)$/i
+        header[last = "Delivered-To"] = $1 unless header["Delivered-To"]
+      when /^$/: break
+      when /:/: last = nil
+      else
+        header[last] += line.gsub(/^\s+/, "") if last
+      end
+    end
+    header
+  end
+  
+  def read_body f
+    body = []
+    f.each_line do |l|
+      break if l =~ BREAK_RE
+      body << l.chomp
+    end
+    body
+  end
+
+  module_function :read_header, :read_body
+end
+end

data/lib/sup/mbox/loader.rb

@@ -0,0 +1,116 @@
+require 'thread'
+require 'rmail'
+
+module Redwood
+module MBox
+
+class Error < StandardError; end
+
+class Loader
+  attr_reader :filename
+  bool_reader :usual, :archived, :read, :dirty
+  attr_accessor :id, :labels
+
+  ## end_offset is the last offsets within the file which we've read.
+  ## everything after that is considered new messages that haven't
+  ## been indexed.
+  def initialize filename, end_offset=0, usual=true, archived=false, id=nil
+    @filename = filename.gsub(%r(^mbox://), "")
+    @end_offset = end_offset
+    @dirty = false
+    @usual = usual
+    @archived = archived
+    @id = id
+    @mutex = Mutex.new
+    @f = File.open @filename
+    @labels = ([
+      :unread,
+      archived ? nil : :inbox,
+    ] +
+      if File.dirname(filename) =~ /\b(var|usr|spool)\b/
+        []
+      else
+        [File.basename(filename).intern] 
+      end).compact
+  end
+
+  def reset!; @end_offset = 0; @dirty = true; end
+  def == o; o.is_a?(Loader) && o.filename == filename; end
+  def to_s; "mbox://#{@filename}"; end
+
+  def is_source_for? s
+    @filename == s || self.to_s == s
+  end
+
+  def load_header offset=nil
+    header = nil
+    @mutex.synchronize do
+      @f.seek offset if offset
+      header = MBox::read_header @f
+    end
+    header
+  end
+
+  def load_message offset
+    ret = nil
+    @mutex.synchronize do
+      @f.seek offset
+      RMail::Mailbox::MBoxReader.new(@f).each_message do |input|
+        return RMail::Parser.read(input)
+      end
+    end
+  end
+
+  ## load the full header text
+  def load_header_text offset
+    ret = ""
+    @mutex.synchronize do
+      @f.seek offset
+      until @f.eof? || (l = @f.gets) =~ /^$/
+        ret += l
+      end
+    end
+    ret
+  end
+
+  def next
+    return nil if done?
+    @dirty = true
+    next_end_offset = @end_offset
+
+    @mutex.synchronize do
+      @f.seek @end_offset
+
+      @f.gets # skip the From separator
+      next_end_offset = @f.tell
+      while(line = @f.gets)
+        break if line =~ BREAK_RE
+        next_end_offset = @f.tell + 1
+      end
+    end
+
+    start_offset = @end_offset
+    @end_offset = next_end_offset
+
+    start_offset
+  end
+
+  def each
+    until @end_offset >= File.size(@f)
+      n = self.next
+      yield(n, labels) if n
+    end
+  end
+
+  def each_header
+    each { |offset, labels| yield offset, labels, load_header(offset) }
+  end
+
+  def done?; @end_offset >= File.size(@f); end 
+  def total; File.size @f; end
+end
+
+Redwood::register_yaml(Loader, %w(filename end_offset usual archived id))
+
+end
+end

data/lib/sup/message.rb

@@ -0,0 +1,302 @@
+require 'tempfile'
+require 'time'
+
+module Redwood
+
+class MessageFormatError < StandardError; end
+
+## a Message is what's threaded.
+##
+## it is also where the parsing for quotes and signatures is done, but
+## that should be moved out to a separate class at some point (because
+## i would like, for example, to be able to add in a ruby-talk
+## specific module that would detect and link to /ruby-talk:\d+/
+## sequences in the text of an email. (how sweet would that be?)
+##
+## TODO: integrate with user's addressbook to render names
+## appropriately.
+class Message
+  SNIPPET_LEN = 80
+  RE_PATTERN = /^((re|re[\[\(]\d[\]\)]):\s*)+/i
+    
+  ## some utility methods
+  class << self
+    def normalize_subj s; s.gsub(RE_PATTERN, ""); end
+    def subj_is_reply? s; s =~ RE_PATTERN; end
+    def reify_subj s; subj_is_reply?(s) ? s : "Re: " + s; end
+  end
+
+  class Attachment
+    attr_reader :content_type, :desc
+    def initialize content_type, desc, part
+      @content_type = content_type
+      @desc = desc
+      @part = part
+      @file = nil
+    end
+
+    def view!
+      unless @file
+        @file = Tempfile.new "redwood.attachment"
+        @file.print @part.decode
+        @file.close
+      end
+
+      ## TODO: handle unknown mime-types
+      system "/usr/bin/run-mailcap --action=view #{@content_type}:#{@file.path}"
+    end
+  end
+
+  class Text
+    attr_reader :lines
+    def initialize lines
+      ## do some wrapping
+      @lines = lines.map { |l| l.wrap 80 }.flatten
+    end
+  end
+
+  class Quote
+    attr_reader :lines
+    def initialize lines
+      @lines = lines
+    end
+  end
+
+  class Signature
+    attr_reader :lines
+    def initialize lines
+      @lines = lines
+    end
+  end
+
+  QUOTE_PATTERN = /^\s{0,4}[>|\}]/
+  BLOCK_QUOTE_PATTERN = /^-----\s*Original Message\s*----+$/
+  QUOTE_START_PATTERN = /(^\s*Excerpts from)|(^\s*In message )|(^\s*In article )|(^\s*Quoting )|((wrote|writes|said|says)\s*:\s*$)/
+  SIG_PATTERN = /(^-- ?$)|(^\s*----------+\s*$)|(^\s*_________+\s*$)/
+  SIG_DISTANCE = 15 # lines from the end
+  DEFAULT_SUBJECT = "(missing subject)"
+  DEFAULT_SENDER = "(missing sender)"
+
+  attr_reader :id, :date, :from, :subj, :refs, :replytos, :to, :source,
+              :cc, :bcc, :labels, :list_address, :recipient_email, :replyto,
+              :source_info, :mbox_status
+
+  bool_reader :dirty
+
+  def initialize source, source_info, labels, snippet=nil
+    @source = source
+    @source_info = source_info
+    @dirty = false
+    @snippet = snippet
+    @labels = labels
+
+    header = @source.load_header @source_info
+    header.each { |k, v| header[k.downcase] = v }
+
+    %w(message-id date).each do |f|
+      raise MessageFormatError, "no #{f} field in header #{header.inspect} (source #@source offset #@source_info)" unless header.include? f
+      raise MessageFormatError, "nil #{f} field in header #{header.inspect} (source #@source offset #@source_info)" unless header[f]
+    end
+
+    begin
+      @date = Time.parse header["date"]
+    rescue ArgumentError => e
+      raise MessageFormatError, "unparsable date #{header['date']}: #{e.message}"
+    end
+
+    if(@subj = header["subject"])
+      @subj = @subj.gsub(/\s+/, " ").gsub(/\s+$/, "")
+    else
+      @subj = DEFAULT_SUBJECT
+    end
+    @from = Person.for header["from"]
+    @to = Person.for_several header["to"]
+    @cc = Person.for_several header["cc"]
+    @bcc = Person.for_several header["bcc"]
+    @id = header["message-id"]
+    @refs = (header["references"] || "").scan(/<(.*?)>/).flatten
+    @replytos = (header["in-reply-to"] || "").scan(/<(.*?)>/).flatten
+    @replyto = Person.for header["reply-to"]
+    @list_address =
+      if header["list-post"]
+        @list_address = Person.for header["list-post"].gsub(/^<mailto:|>$/, "")
+      else
+        nil
+      end
+
+    @recipient_email = header["delivered-to"]
+    @mbox_status = header["status"]
+  end
+
+  def snippet
+    to_chunks unless @snippet
+    @snippet
+  end
+
+  def is_list_message?; !@list_address.nil?; end
+  def is_draft?; DraftLoader === @source; end
+  def draft_filename
+    raise "not a draft" unless is_draft?
+    @source.fn_for_offset @source_info
+  end
+
+  def save index
+    index.update_message self if @dirty
+    @dirty = false
+  end
+
+  def has_label? t; @labels.member? t; end
+  def add_label t
+    return if @labels.member? t
+    @labels.push t
+    @dirty = true
+  end
+  def remove_label t
+    return unless @labels.member? t
+    @labels.delete t
+    @dirty = true
+  end
+
+  def recipients
+    @to + @cc + @bcc
+  end
+
+  def labels= l
+    @labels = l
+    @dirty = true
+  end
+
+  def to_chunks
+    m = @source.load_message @source_info
+    message_to_chunks m
+  end
+
+  def header_text
+    @source.load_header_text @source_info
+  end
+
+  def content
+    [
+      from && from.longname,
+      to.map { |p| p.longname },
+      cc.map { |p| p.longname },
+      bcc.map { |p| p.longname },
+      to_chunks.select { |c| c.is_a? Text }.map { |c| c.lines },
+      subj,
+    ].flatten.compact.join " "
+  end
+
+  def basic_body_lines
+    to_chunks.find_all { |c| c.is_a?(Text) || c.is_a?(Quote) }.map { |c| c.lines }.flatten
+  end
+
+  def basic_header_lines
+    ["From: #{@from.full_address}"] +
+      (@to.empty? ? [] : ["To: " + @to.map { |p| p.full_address }.join(", ")]) +
+      (@cc.empty? ? [] : ["Cc: " + @cc.map { |p| p.full_address }.join(", ")]) +
+      (@bcc.empty? ? [] : ["Bcc: " + @bcc.map { |p| p.full_address }.join(", ")]) +
+      ["Date: #{@date.rfc822}",
+       "Subject: #{@subj}"]
+  end
+
+private
+
+  ## everything RubyMail-specific goes here.
+  def message_to_chunks m
+    ret = [] <<
+      case m.header.content_type
+      when "text/plain", nil
+        raise MessageFormatError, "no message body before decode" unless
+          m.body
+        body = m.decode or raise MessageFormatError, "no message body"
+        text_to_chunks body.gsub(/\t/, "    ").gsub(/\r/, "").split("\n")
+      when "multipart/alternative", "multipart/mixed"
+        nil
+      else
+        disp = m.header["Content-Disposition"] || ""
+        Attachment.new m.header.content_type, disp.gsub(/[\s\n]+/, " "), m
+      end
+    
+    m.each_part { |p| ret << message_to_chunks(p) } if m.multipart?
+    ret.compact.flatten
+  end
+
+  ## parse the lines of text into chunk objects.  the heuristics here
+  ## need tweaking in some nice manner. TODO: move these heuristics
+  ## into the classes themselves.
+
+  def text_to_chunks lines
+    state = :text # one of :text, :quote, or :sig
+    chunks = []
+    chunk_lines = []
+
+    lines.each_with_index do |line, i|
+      nextline = lines[(i + 1) ... lines.length].find { |l| l !~ /^\s*$/ } # skip blank lines
+      case state
+      when :text
+        newstate = nil
+        if line =~ QUOTE_PATTERN || (line =~ QUOTE_START_PATTERN && (nextline =~ QUOTE_PATTERN || nextline =~ QUOTE_START_PATTERN))
+          newstate = :quote
+        elsif line =~ SIG_PATTERN && (lines.length - i) < SIG_DISTANCE
+          newstate = :sig
+        elsif line =~ BLOCK_QUOTE_PATTERN
+          newstate = :block_quote
+        end
+        if newstate
+          chunks << Text.new(chunk_lines) unless chunk_lines.empty?
+          chunk_lines = [line]
+          state = newstate
+        else
+          chunk_lines << line
+        end
+      when :quote
+        newstate = nil
+        if line =~ QUOTE_PATTERN || line =~ QUOTE_START_PATTERN || line =~ /^\s*$/
+          chunk_lines << line
+        elsif line =~ SIG_PATTERN && (lines.length - i) < SIG_DISTANCE
+          newstate = :sig
+        else
+          newstate = :text
+        end
+        if newstate
+          if chunk_lines.empty?
+            # nothing
+          elsif chunk_lines.size == 1
+            chunks << Text.new(chunk_lines) # forget about one-line quotes
+          else
+            chunks << Quote.new(chunk_lines)
+          end
+          chunk_lines = [line]
+          state = newstate
+        end
+      when :block_quote
+        chunk_lines << line
+      when :sig
+        chunk_lines << line
+      end
+ 
+      if state == :text && (@snippet.nil? || @snippet.length < SNIPPET_LEN) &&
+          line !~ /[=\*#_-]{3,}/ && line !~ /^\s*$/
+        @snippet = (@snippet ? @snippet + " " : "") + line.gsub(/^\s+/, "").gsub(/[\r\n]/, "").gsub(/\s+/, " ")
+        @snippet = @snippet[0 ... SNIPPET_LEN]
+      end
+#      if @snippet.nil? && state == :text && (line.length > 40 ||
+#                                             line =~ /\S+.*[^,!:]\s*$/)
+#        @snippet = line.gsub(/^\s+/, "").gsub(/[\r\n]/, "")[0 .. 80]
+#      end
+    end
+
+    ## final object
+    case state
+    when :quote, :block_quote
+      chunks << Quote.new(chunk_lines) unless chunk_lines.empty?
+    when :text
+      chunks << Text.new(chunk_lines) unless chunk_lines.empty?
+    when :sig
+      chunks << Signature.new(chunk_lines) unless chunk_lines.empty?
+    end
+    chunks
+  end
+end
+
+end