sup 0.0.2 → 0.0.3

data/bin/sup-recover-sources

@@ -0,0 +1,100 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+
+$opts = {
+  :unusual => false,
+  :archive => false,
+  :scan_num => 10,
+}
+
+
+OPTIONPARSERSUCKS = "\n" + " " * 38
+OptionParser.new do |opts|
+  opts.banner = <<EOS
+Usage: sup-recover-sources [options] <source>+
+
+Rebuilds a lost sources.yaml file by reading messages from a list of
+sources and determining, for each source, the most prevalent
+'source_id' field of messages from that source in the index.
+
+The only non-deterministic component to this is that if the same
+message appears in multiple sources, those sources may be
+mis-diagnosed by this program.
+
+If the first N messages (--scan-num below) all have the same source_id
+in the index, the source will be added to sources.yaml. Otherwise, the
+distribution will be printed, and you will have to add it by hand.
+
+The offset pointer into the sources will be set to the end of the source,
+so you will have to run sup-import --rebuild for each new source after
+doing this.
+
+Options include:
+EOS
+
+  opts.on("--unusual", "Mark sources as 'unusual'. Only usual#{OPTIONPARSERSUCKS}sources will be polled by hand. Default:#{OPTIONPARSERSUCKS}#{$opts[:unusual]}.") { $opts[:unusual] = true }
+
+  opts.on("--archive", "Mark sources as 'archive'. New messages#{OPTIONPARSERSUCKS}from these sources will not appear in#{OPTIONPARSERSUCKS}the inbox. Default: #{$opts[:archive]}.") { $opts[:archive] = true }
+
+  opts.on("--scan-num N", Integer, "Number of messages to scan per source.#{OPTIONPARSERSUCKS}Default: #{$opts[:scan_num]}.") do |n|
+    $opts[:scan_num] = n
+  end
+
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+end.parse(ARGV)
+
+require "sup"
+puts "loading index..."
+index = Redwood::Index.new
+index.load
+puts "loaded index of #{index.size} messages"
+
+ARGV.each do |fn|
+  next if index.source_for fn
+
+  ## TODO: merge this code with the same snippet in import
+  source = 
+    case fn
+    when %r!^imaps?://!
+      print "Username for #{fn}: "
+      username = $stdin.gets.chomp
+      print "Password for #{fn} (warning: cleartext): "
+      password = $stdin.gets.chomp
+      Redwood::IMAP.new(fn, username, password, nil, !$opts[:unusual], $opts[:archive])
+    else
+      Redwood::MBox::Loader.new(fn, nil, !$opts[:unusual], $opts[:archive])
+    end
+
+  source_ids = {}
+  count = 0
+  source.each do |offset, labels|
+    begin
+      m = Redwood::Message.new :source => source, :source_info => offset
+      docid, entry = index.load_entry_for_id m.id
+      next unless entry
+      #puts "# #{source} #{offset} #{entry[:source_id]}"
+
+      source_ids[entry[:source_id]] = (source_ids[entry[:source_id]] || 0) + 1
+      count += 1
+      break if count == $opts[:scan_num]
+    rescue Redwood::MessageFormatError => e
+      puts "# #{e.message}"
+    end
+  end
+
+  if source_ids.size == 1
+    id = source_ids.keys.first.to_i
+    puts "assigned #{source} to #{source_ids.keys.first}"
+    source.id = id
+    source.seek_to! source.total
+    index.add_source source
+  else
+    puts ">> unable to determine #{source}: #{source_ids.inspect}"
+  end
+end
+
+index.save

data/doc/FAQ.txt

@@ -1,28 +1,23 @@
 Sup FAQ
 -------
 Q: What does Sup stand for?
-A: "What's up?".
 
-Q: How is Sup even possible?
-A: Sup is only possible through the hard work of Dave Balmain, the
-   author of ferret.
+A: It stands for "what's up?", which is more or less the question I'm
+   asking when I read my mail.
+
+Q: If you love GMail so much, why not just use it?
 
-   I started using Ferret when it was still slightly buggy, and it
-   seemed like every week Dave released a bugfix or a speed
-   improvement that directly affected sup. Ferret has become a
-   first-class piece of software, and it's due to the tremendous
-   amount of time and effort he's put in to it.
+A: I hate using a mouse, and I hate ads, and I hate non-programmability
+   and non-extensibility.
 
 Q: Why the console?
-A: As the millions (ok, hundreds) of mutt users will tell you, there are
-   many advantages to the console:
-   - You don't need web browser.
-   - Instantaneous interaction.
-   - A few keystrokes can accomplish the work of a hundred mouse
-     clicks.
+A: There are many advantages to the console. As any Unix user knows, a
+   few keystrokes can accomplish the work of a hundred mouse clicks.
+   Also, you don't need web browser, and you get instantaneous response
+   and a simple interface.
 
-Q: If you love GMail so much, why not just use it?
-A: I hate using a mouse, and I hate ads, and I hate non-programmability.
+   That said, a good Ajax programmer could probably replicate GMail
+   pretty easily using Sup as the backend.
 
 Q: How does Sup deal with spam?
 A: You can manually mark messages as spam, which prevents them from
@@ -38,3 +33,9 @@ A: That was Sup's original name. (Think pine, elm. Although I am a
    Maybe one day I'll do a huge search-and-replace on the code, but it
    doesn't seem that important at this point.
 
+Q: How is Sup possible?
+A: Sup is only possible through the hard work of Dave Balmain, the
+   author of ferret, which is the search engine behind Sup. Ferret is
+   really a first-class piece of software, and it's due to the
+   tremendous amount of time and effort he's put in to it.
+

data/doc/Philosophy.txt

@@ -11,31 +11,36 @@ it. Keeping up with the all the new traffic is painful, even with
 Mutt's excellent threading features, simply because there's so much of
 it---a single thread can span several pages, and God help you if you
 lag behind. And Mutt is probably the best email client out there in
-terms of threading and mailing list support.
-
-The principle problem with traditional clients is that they place 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?
-
-For example, 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.
-
-As a long-time Mutt user, when I watched people use GMail, I saw them
-use email differently from how I had ever used it. I saw that making
-certain operations quantitatively easier (namely, search) resulted in
-a qualitative difference in usage. And I saw that thread-centrism had
-many advantages over message-centrism, especially when volume was high.
+terms of threading and mailing list support. God help me if I try and
+throw Thunderbird at that.
+
+The principle problem with traditional clients is that they deal with
+individual pieces of email, and place 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.
+
+As a long-time Mutt user, when I first watched people use GMail, I saw
+them use email differently from how I had ever used it. I saw that
+making certain operations quantitatively easier (namely, search)
+resulted in a qualitative difference in usage: you don't have to worry
+about filing correctly, because you can always find things later by
+search. And I saw that thread-centrism had many advantages over
+message-centrism when message volume was high.
 
 So, in many ways, I believe GMail has taken the right approach to
 handle both of the factors above, and much of the inspiration for Sup
-was based on GMail. Ultimately, GMail wasn't right for me, which is
-why the idea for Sup was born.
+was based on GMail. 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 can we build an email client on top of one?) and
+managed to build something that was actually better than everything
+else out there. But ultimately, GMail wasn't right for me (see FAQ),
+which is why the idea for Sup was born.
 
 Sup is based on the following principles, which I more or less stole
 directly from GMail:
@@ -44,15 +49,17 @@ directly from GMail:
   entire email archive eliminates most of the need for folders,
   and eliminates the necessity of having to ever delete email.
 
-- Labels eliminate the remaining need for folders.
+- Labels eliminate what little need for folders that search doesn't
+  eliminate.
 
 - A thread-centric approach to the UI is much more in line with how
-  people operate than dealing with individual messages is. A message
-  and its content deserve the same treatment in the vast majority
-  of cases.
+  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.
 
+Give it a go and let me know what you think.

data/doc/TODO

@@ -1,3 +1,5 @@
+support for message-content modules such as ruby-talk:XXXXX detection
+use Net::SMTP
 search for other messages from author in thread-view-mode
 forward attachments
 tab completion on labels, contacts
@@ -12,7 +14,12 @@ annotations on messages
 gmail
 pop
 move sup-import argument handling to getopt or something
+mark individual messages as spam in thread-view-mode
 
+x move sup-import username/password prompts to highline
+x support different remote servers per user account
+x 'R' to quick-resume most recent draft
+x mbox+ssh
 x handle broken sources better
 x imap
 x word wrap

data/lib/sup.rb

@@ -4,23 +4,22 @@ require 'zlib'
 require 'thread'
 require 'fileutils'
 
-Thread.abort_on_exception = true # make debugging possible
-
 class Object
   ## this is for debugging purposes because i keep calling #id on the
   ## wrong object and i want it to throw an exception
   def id
-    raise "wrong id called"
+    raise "wrong id called on #{self.inspect}"
   end
 end
 
 module Redwood
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 
-  BASE_DIR   = File.join(ENV["HOME"], ".sup")
+  BASE_DIR   = ENV["SUP_BASE"] || File.join(ENV["HOME"], ".sup")
   CONFIG_FN  = File.join(BASE_DIR, "config.yaml")
   SOURCE_FN  = File.join(BASE_DIR, "sources.yaml")
   LABEL_FN   = File.join(BASE_DIR, "labels.txt")
+  PERSON_FN   = File.join(BASE_DIR, "people.txt")
   CONTACT_FN = File.join(BASE_DIR, "contacts.txt")
   DRAFT_DIR  = File.join(BASE_DIR, "drafts")
   SENT_FN    = File.join(BASE_DIR, "sent.mbox")
@@ -28,6 +27,20 @@ module Redwood
   YAML_DOMAIN = "masanjin.net"
   YAML_DATE = "2006-10-01"
 
+## record exceptions thrown in threads nicely
+  $exception = nil
+  def reporting_thread
+    ::Thread.new do
+      begin
+        yield
+      rescue Exception => e
+        $exception ||= e
+        raise
+      end
+    end
+  end
+  module_function :reporting_thread
+
 ## one-stop shop for yamliciousness
   def register_yaml klass, props
     vars = props.map { |p| "@#{p}" }
@@ -61,7 +74,24 @@ module Redwood
     end
   end
 
-  module_function :register_yaml, :save_yaml_obj, :load_yaml_obj
+  def start
+    Redwood::PersonManager.new Redwood::PERSON_FN
+    Redwood::SentManager.new Redwood::SENT_FN
+    Redwood::ContactManager.new Redwood::CONTACT_FN
+    Redwood::LabelManager.new Redwood::LABEL_FN
+    Redwood::AccountManager.new $config[:accounts]
+    Redwood::DraftManager.new Redwood::DRAFT_DIR
+    Redwood::UpdateManager.new
+    Redwood::PollManager.new
+  end
+
+  def finish
+    Redwood::LabelManager.save
+    Redwood::ContactManager.save
+    Redwood::PersonManager.save
+  end
+
+  module_function :register_yaml, :save_yaml_obj, :load_yaml_obj, :start, :finish
 end
 
 ## set up default configuration file

data/lib/sup/buffer.rb

@@ -13,6 +13,9 @@ module Ncurses
     lamer.first
   end
 
+  def mutex; @mutex ||= Mutex.new; end
+  def sync &b; mutex.synchronize &b; end
+
   ## aaahhh, user input. who would have though that such a simple
   ## idea would be SO FUCKING COMPLICATED?! because apparently
   ## Ncurses.getch (and Curses.getch), even in cbreak mode, BLOCKS
@@ -37,7 +40,7 @@ module Ncurses
     end
   end
 
-  module_function :rows, :cols, :nonblocking_getch
+  module_function :rows, :cols, :nonblocking_getch, :mutex, :sync
 
   KEY_CANCEL = "\a"[0] # ctrl-g
 end
@@ -60,9 +63,11 @@ class Buffer
   def content_height; @height - 1; end
   def content_width; @width; end
 
-  def resize rows, cols
+  def resize rows, cols 
+    return if cols == @width && rows == @height
     @width = cols
     @height = rows
+    @dirty = true
     mode.resize rows, cols
   end
 
@@ -71,6 +76,7 @@ class Buffer
     draw_status
     commit
   end
+
   def mark_dirty; @dirty = true; end
 
   def commit
@@ -132,7 +138,7 @@ class BufferManager
     @minibuf_stack = []
     @textfields = {}
     @flash = nil
-    @freeze = false
+    @shelled = false
 
     self.class.i_am_the_instance self
   end
@@ -140,8 +146,7 @@ class BufferManager
   def buffers; @name_map.to_a; end
 
   def focus_on buf
-    raise ArgumentError, "buffer not on stack: #{buf.inspect}" unless
-      @buffers.member? buf
+    raise ArgumentError, "buffer not on stack: #{buf.inspect}" unless @buffers.member? buf
     return if buf == @focus_buf 
     @focus_buf.blur if @focus_buf
     @focus_buf = buf
@@ -149,8 +154,7 @@ class BufferManager
   end
 
   def raise_to_front buf
-    raise ArgumentError, "buffer not on stack: #{buf.inspect}" unless
-      @buffers.member? buf
+    raise ArgumentError, "buffer not on stack: #{buf.inspect}" unless @buffers.member? buf
     @buffers.delete buf
     @buffers.push buf
     focus_on buf
@@ -178,36 +182,49 @@ class BufferManager
   end
 
   def completely_redraw_screen
-    return if @freeze
-    Ncurses.clear
-    @dirty = true
-    draw_screen
+    return if @shelled
+
+    Ncurses.sync do
+      @dirty = true
+      Ncurses.clear
+      draw_screen :sync => false
+    end
   end
 
   def handle_resize
-    return if @freeze
+    return if @shelled
     rows, cols = Ncurses.rows, Ncurses.cols
-    @buffers.each { |b| b.resize rows - 1, cols }
+    @buffers.each { |b| b.resize rows - minibuf_lines, cols }
     completely_redraw_screen
-    flash "resized to #{rows}x#{cols}"
+    flash "Resized to #{rows}x#{cols}"
   end
 
-  def draw_screen skip_minibuf=false
-    return if @freeze
+  def draw_screen opts={}
+    return if @shelled
+
+    Ncurses.mutex.lock unless opts[:sync] == false
 
     ## disabling this for the time being, to help with debugging
     ## (currently we only have one buffer visible at a time).
     ## TODO: reenable this if we allow multiple buffers
     false && @buffers.inject(@dirty) do |dirty, buf|
-      dirty ? buf.draw : buf.redraw
-      dirty || buf.dirty?
+      buf.resize Ncurses.rows - minibuf_lines, Ncurses.cols
+      @dirty ? buf.draw : buf.redraw
     end
+
     ## quick hack
-    true && (@dirty ? @buffers.last.draw : @buffers.last.redraw)
-    
-    draw_minibuf unless skip_minibuf
+    if true
+      buf = @buffers.last
+      buf.resize Ncurses.rows - minibuf_lines, Ncurses.cols
+      File.open("asdf.txt", "a") { |f| f.puts "dirty #@dirty, (re)drawing #{buf.mode.name}" }
+      @dirty ? buf.draw : buf.redraw
+    end
+
+    draw_minibuf :sync => false unless opts[:skip_minibuf]
     @dirty = false
     Ncurses.doupdate
+    Ncurses.refresh if opts[:refresh]
+    Ncurses.mutex.unlock unless opts[:sync] == false
   end
 
   ## gets the mode from the block, which is only called if the buffer
@@ -228,11 +245,10 @@ class BufferManager
     realtitle = title
     num = 2
     while @name_map.member? realtitle
-      realtitle = "#{title} #{num}"
+      realtitle = "#{title} <#{num}>"
       num += 1
     end
 
-    Redwood::log "spawning buffer \"#{realtitle}\""
     width = opts[:width] || Ncurses.cols
     height = opts[:height] || Ncurses.rows - 1
 
@@ -243,8 +259,6 @@ class BufferManager
     ## w = Ncurses::WINDOW.new(height, width, (opts[:top] || 0),
     ## (opts[:left] || 0))
     w = Ncurses.stdscr
-    raise "nil window" unless w
-    
     b = Buffer.new w, mode, width, height, :title => realtitle
     mode.buffer = b
     @name_map[realtitle] = b
@@ -264,7 +278,6 @@ class BufferManager
 
   def kill_buffer buf
     raise ArgumentError, "buffer not on stack: #{buf.inspect}" unless @buffers.member? buf
-    Redwood::log "killing buffer \"#{buf.title}\""
 
     buf.mode.cleanup
     @buffers.delete buf
@@ -279,8 +292,7 @@ class BufferManager
   end
 
   def ask domain, question, default=nil
-    @textfields[domain] ||= TextField.new Ncurses.stdscr, Ncurses.rows - 1, 0,
-                            Ncurses.cols
+    @textfields[domain] ||= TextField.new Ncurses.stdscr, Ncurses.rows - 1, 0, Ncurses.cols
     tf = @textfields[domain]
 
     ## this goddamn ncurses form shit is a fucking 1970's
@@ -288,19 +300,19 @@ class BufferManager
     ## that needs to happen in order to display a form and have the
     ## entire screen not disappear and have the cursor in the right
     ## place is TOO FUCKING COMPLICATED.
-    tf.activate question, default
-    @dirty = true
-    draw_screen true
+    Ncurses.sync do
+      tf.activate question, default
+      @dirty = true
+      draw_screen :skip_minibuf => true, :sync => false
+    end
 
     ret = nil
-    @freeze = true
     tf.position_cursor
-    Ncurses.refresh
+    Ncurses.sync { Ncurses.refresh }
     while tf.handle_input(Ncurses.nonblocking_getch); end
-    @freeze = false
 
     ret = tf.value
-    tf.deactivate
+    Ncurses.sync { tf.deactivate }
     @dirty = true
 
     ret
@@ -311,13 +323,15 @@ class BufferManager
     accept = accept.split(//).map { |x| x[0] } if accept
 
     flash question
-    Ncurses.curs_set 1
-    Ncurses.move Ncurses.rows - 1, question.length + 1
-    Ncurses.refresh
+    Ncurses.sync do
+      Ncurses.curs_set 1
+      Ncurses.move Ncurses.rows - 1, question.length + 1
+      Ncurses.refresh
+    end
 
     ret = nil
     done = false
-    @freeze = true
+    @shelled = true
     until done
       key = Ncurses.nonblocking_getch
       if key == Ncurses::KEY_CANCEL
@@ -327,11 +341,15 @@ class BufferManager
         done = true
       end
     end
-    @freeze = false
-    Ncurses.curs_set 0
-    erase_flash
-    draw_screen
-    Ncurses.curs_set 0
+
+    @shelled = false
+
+    Ncurses.sync do
+      Ncurses.curs_set 0
+      erase_flash
+      draw_screen :sync => false
+      Ncurses.curs_set 0
+    end
 
     ret
   end
@@ -348,20 +366,38 @@ class BufferManager
     end
   end
 
-  def draw_minibuf
-    s = @flash || @minibuf_stack.reverse.find { |x| x } || ""
+  def minibuf_lines; [(@flash ? 1 : 0) + @minibuf_stack.compact.size, 1].max; end
+  
+  def draw_minibuf opts={}
+    m = @minibuf_stack.compact
+    m << @flash if @flash
+    m << "" if m.empty?
 
+    Ncurses.mutex.lock unless opts[:sync] == false
     Ncurses.attrset Colormap.color_for(:none)
-    Ncurses.mvaddstr Ncurses.rows - 1, 0, s + (" " * [Ncurses.cols - s.length,
-                                                      0].max)
+    m.each_with_index do |s, i|
+      Ncurses.mvaddstr Ncurses.rows - i - 1, 0, s + (" " * [Ncurses.cols - s.length, 0].max)
+    end
+    Ncurses.refresh if opts[:refresh]
+    Ncurses.mutex.unlock unless opts[:sync] == false
   end
 
   def say s, id=nil
+    new_id = id.nil?
     id ||= @minibuf_stack.length
     @minibuf_stack[id] = s
-    unless @freeze
-      draw_screen
-      Ncurses.refresh
+    if new_id
+      draw_screen :refresh => true
+    else
+      draw_minibuf :refresh => true
+    end
+
+    if block_given?
+      begin
+        yield
+      ensure
+        clear id
+      end
     end
     id
   end
@@ -370,33 +406,32 @@ class BufferManager
 
   def flash s
     @flash = s
-    unless @freeze
-      draw_screen
-      Ncurses.refresh
-    end
+    draw_screen :refresh => true
   end
 
+  ## a little tricky because we can't just delete_at id because ids
+  ## are relative (they're positions into the array).
   def clear id
     @minibuf_stack[id] = nil
     if id == @minibuf_stack.length - 1
       id.downto(0) do |i|
-        break unless @minibuf_stack[i].nil?
+        break if @minibuf_stack[i]
         @minibuf_stack.delete_at i
       end
     end
-    unless @freeze
-      draw_screen
-      Ncurses.refresh
-    end
+
+    draw_screen :refresh => true
   end
 
   def shell_out command
-    @freeze = true
-    Ncurses.endwin
-    system command
-    Ncurses.refresh
-    Ncurses.curs_set 0
-    @freeze = false
+    @shelled = true
+    Ncurses.sync do
+      Ncurses.endwin
+      system command
+      Ncurses.refresh
+      Ncurses.curs_set 0
+    end
+    @shelled = false
   end
 end
 end