sup 0.0.1

data/doc/Philosophy.txt

@@ -0,0 +1,59 @@
+Must an email client have a philosophy? I think so. For many people,
+it is our primary means of communication. Something so important
+should warrant a little thought.
+
+So 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 350 megs and Mutt sits there for 60 seconds while it opens
+it. Keeping up with the all the new traffic is painful, even with
+Mutt's excellent threading features, just because there's so much of
+it. A single thread can span several pages.  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 for the better!). I saw that
+thread-centrism had many advantages over message-centrism.
+
+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 using GMail. Of course, I don't ultimately like using
+GMail, which is why I created Sup in the first place.
+
+Sup is based on the following principles, which I learned from GMail:
+
+- An immediately accessible and fast search capability over the
+  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.
+
+- 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.
+
+Sup is also based on many ideas from mutt (and Emacs and vi!), having
+to do with the fantastic productivity of a console- and key-based
+application, and the usefulness of multiple buffers, etc., and the
+necessity of handling multiple email accounts, but these features form
+less of the philosophy and more of the general usefulness of Sup.
+
+

data/doc/TODO

@@ -0,0 +1,31 @@
+forward attachments
+tab completion on labels, contacts
+within-buffer search
+contact selector in edit-message-mode
+undo
+maybe: filters
+maybe: rangefilter on the initial inbox to only consider the most recent 1000 messages
+select all, starred, to me, etc
+editing of arbitrary messages
+annotations on messages
+
+x word wrap
+x background indexing
+x auto-insertion of draft messages
+x drafts
+x sent messages loader
+x search: from
+x contacts
+x tagging for group operations
+x view: starred, to me, etc
+x pull in messages by subject as well in load_thread_for_
+x reply+compose+forward
+x resize
+x buffer respawns
+x readline
+x "loading" message
+x search: body, to/from, tags (requires: readline)
+x highlighting/different color stuff
+x config: your email, sendmail, etc
+x status: to/from_you, cc_you_others
+x status: new/not, important

data/lib/sup.rb

@@ -0,0 +1,141 @@
+require 'rubygems'
+require 'yaml'
+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 nil.id and
+  ## i want it to throw an exception
+  def id 
+    raise "wrong id called"
+  end
+end
+
+module Redwood
+  VERSION = "0.0.1"
+
+  BASE_DIR   = 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")
+  CONTACT_FN = File.join(BASE_DIR, "contacts.txt")
+  DRAFT_DIR  = File.join(BASE_DIR, "drafts")
+  SENT_FN    = File.join(BASE_DIR, "sent.mbox")
+
+  YAML_DOMAIN = "masanjin.net"
+  YAML_DATE = "2006-10-01"
+
+## one-stop shop for yamliciousness
+
+  def register_yaml klass, props
+    vars = props.map { |p| "@#{p}" }
+    path = klass.name.gsub(/::/, "/")
+    
+    klass.instance_eval do
+      define_method(:to_yaml_properties) { vars }
+      define_method(:to_yaml_type) { "!#{YAML_DOMAIN},#{YAML_DATE}/#{path}" }
+    end
+
+    YAML.add_domain_type("#{YAML_DOMAIN},#{YAML_DATE}", path) do |type, val|
+      klass.new(*props.map { |p| val[p] })
+    end
+  end
+
+  def save_yaml_obj object, fn, compress=false
+    if compress
+      Zlib::GzipWriter.open(fn) { |f| f.puts object.to_yaml }
+    else
+      File.open(fn, "w") { |f| f.puts object.to_yaml }
+    end
+  end
+
+  def load_yaml_obj fn, compress=false
+    if File.exists? fn
+      if compress
+        Zlib::GzipReader.open(fn) { |f| YAML::load f }
+      else
+        YAML::load_file fn
+      end
+    end
+  end
+
+  module_function :register_yaml, :save_yaml_obj, :load_yaml_obj
+end
+
+## set up default configuration file
+
+if File.exists? Redwood::CONFIG_FN
+  $config = Redwood::load_yaml_obj Redwood::CONFIG_FN
+else
+  $config = {
+    :accounts => {
+      :default => {
+        :name => "Your Name Here",
+        :email => "your.email.here@domain.tld",
+        :alternates => [],
+        :sendmail => "/usr/sbin/sendmail -oem -ti",
+        :sig_file => File.join(ENV["HOME"], ".signature")
+      }
+    },
+    :editor => ENV["EDITOR"] || "/usr/bin/vi",
+  }
+  begin
+    FileUtils.mkdir_p Redwood::BASE_DIR
+    Redwood::save_yaml_obj $config, Redwood::CONFIG_FN
+  rescue StandardError => e
+    $stderr.puts "warning: #{e.message}"
+  end
+end
+
+require "sup/util"
+require "sup/update"
+require "sup/message"
+require "sup/mbox"
+require "sup/person"
+require "sup/account"
+require "sup/thread"
+require "sup/index"
+require "sup/textfield"
+require "sup/buffer"
+require "sup/keymap"
+require "sup/mode"
+require "sup/colormap"
+require "sup/label"
+require "sup/contact"
+require "sup/tagger"
+require "sup/draft"
+require "sup/poll"
+require "sup/modes/scroll-mode"
+require "sup/modes/text-mode"
+require "sup/modes/line-cursor-mode"
+require "sup/modes/help-mode"
+require "sup/modes/edit-message-mode"
+require "sup/modes/compose-mode"
+require "sup/modes/resume-mode"
+require "sup/modes/forward-mode"
+require "sup/modes/reply-mode"
+require "sup/modes/label-list-mode"
+require "sup/modes/contact-list-mode"
+require "sup/modes/thread-view-mode"
+require "sup/modes/thread-index-mode"
+require "sup/modes/label-search-results-mode"
+require "sup/modes/search-results-mode"
+require "sup/modes/person-search-results-mode"
+require "sup/modes/inbox-mode"
+require "sup/modes/buffer-list-mode"
+require "sup/modes/log-mode"
+require "sup/modes/poll-mode"
+require "sup/logger"
+require "sup/sent"
+
+module Redwood
+  def log s; Logger.log s; end
+  module_function :log
+end
+
+$:.each do |base|
+  d = File.join base, "sup/share/modes/"
+  Redwood::Mode.load_all_modes d if File.directory? d
+end

data/lib/sup/account.rb

@@ -0,0 +1,53 @@
+module Redwood
+
+class Account < Person
+  attr_accessor :sendmail, :sig_file
+
+  def initialize h
+    super h[:name], h[:email]
+    @sendmail = h[:sendmail]
+    @sig_file = h[:signature]
+  end
+end
+
+class AccountManager
+  include Singleton
+
+  attr_accessor :default_account
+
+  def initialize accounts
+    @email_map = {}
+    @alternate_map = {}
+    @accounts = {}
+    @default_account = nil
+
+    accounts.each { |k, v| add_account v, k == :default }
+
+    self.class.i_am_the_instance self
+  end
+
+  def user_accounts; @accounts.keys; end
+  def user_emails; (@email_map.keys + @alternate_map.keys).uniq.select { |e| String === e }; end
+
+  def add_account hash, default=false
+    email = hash[:email]
+
+    next if @email_map.member? email
+    a = Account.new hash
+    @accounts[a] = true
+    @email_map[email] = a
+    hash[:alternates].each { |aa| @alternate_map[aa] = a }
+    if default
+      raise ArgumentError, "multiple default accounts" if @default_account
+      @default_account = a 
+    end
+  end
+
+  def is_account? p; @accounts.member? p; end
+  def account_for email
+    @email_map[email] || @alternate_map[email] || @alternate_map.argfind { |k, v| k === email && v }
+  end
+  def is_account_email? email; !account_for(email).nil?; end
+end
+
+end

data/lib/sup/buffer.rb

@@ -0,0 +1,391 @@
+require 'thread'
+
+module Ncurses
+  def rows
+    lame, lamer = [], []
+    stdscr.getmaxyx lame, lamer
+    lame.first
+  end
+
+  def cols
+    lame, lamer = [], []
+    stdscr.getmaxyx lame, lamer
+    lamer.first
+  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
+  ## ALL THREAD ACTIVITY. as in, no threads anywhere will run while
+  ## it's waiting for input. ok, fine, so we wrap it in a select. Of
+  ## course we also rely on Ncurses.getch to tell us when an xterm
+  ## resize has occurred, which select won't catch, so we won't
+  ## resize outselves after a sigwinch until the user hits a key.
+  ## and installing our own sigwinch handler means that the screen
+  ## size returned by getmaxyx() DOESN'T UPDATE! and Kernel#trap
+  ## RETURNS NIL as the previous handler! 
+  ##
+  ## so basically, resizing with multi-threaded ruby Ncurses
+  ## applications will always be broken.
+  ##
+  ## i've coined a new word for this: lametarded.
+  def nonblocking_getch
+    if IO.select([$stdin], nil, nil, nil)
+      Ncurses.getch
+    else
+      nil
+    end
+  end
+
+  module_function :rows, :cols, :nonblocking_getch
+
+  KEY_CANCEL = "\a"[0] # ctrl-g
+end
+
+module Redwood
+
+class Buffer
+  attr_reader :mode, :x, :y, :width, :height, :title
+  bool_reader :dirty
+
+  def initialize window, mode, width, height, opts={}
+    @w = window
+    @mode = mode
+    @dirty = true
+    @focus = false
+    @title = opts[:title] || ""
+    @x, @y, @width, @height = 0, 0, width, height
+  end
+
+  def content_height; @height - 1; end
+  def content_width; @width; end
+
+  def resize rows, cols
+    @width = cols
+    @height = rows
+    mode.resize rows, cols
+  end
+
+  def redraw
+    draw if @dirty
+    draw_status
+    commit
+  end
+  def mark_dirty; @dirty = true; end
+
+  def commit
+    @dirty = false
+    @w.noutrefresh
+  end
+
+  def draw
+    @mode.draw
+    draw_status
+    commit
+  end
+
+  ## s nil means a blank line!
+  def write y, x, s, opts={}
+    return if x >= @width || y >= @height
+
+    @w.attrset Colormap.color_for(opts[:color] || :none, opts[:highlight])
+    s ||= ""
+    maxl = @width - x
+    @w.mvaddstr y, x, s[0 ... maxl]
+    unless s.length >= maxl || opts[:no_fill]
+      @w.mvaddstr(y, x + s.length, " " * (maxl - s.length))
+    end
+  end
+
+  def clear
+    @w.clear
+  end
+
+  def draw_status
+    write @height - 1, 0, " [#{mode.name}] #{title}   #{mode.status}",
+      :color => :status_color
+  end
+
+  def focus
+    @focus = true
+    @dirty = true
+    @mode.focus
+  end
+
+  def blur
+    @focus = false
+    @dirty = true
+    @mode.blur
+  end
+end
+
+class BufferManager
+  include Singleton
+
+  attr_reader :focus_buf
+
+  def initialize
+    @name_map = {}
+    @buffers = []
+    @focus_buf = nil
+    @dirty = true
+    @minibuf_stack = []
+    @textfields = {}
+    @flash = nil
+    @shelled_out = false
+
+    self.class.i_am_the_instance self
+  end
+
+  def buffers; @name_map.to_a; end
+
+  def focus_on 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
+    @focus_buf.focus
+  end
+
+  def raise_to_front buf
+    raise ArgumentError, "buffer not on stack: #{buf.inspect}" unless
+      @buffers.member? buf
+    @buffers.delete buf
+    @buffers.push buf
+    focus_on buf
+    @dirty = true
+  end
+
+  def roll_buffers
+    raise_to_front @buffers.first
+  end
+
+  def roll_buffers_backwards
+    return unless @buffers.length > 1
+    raise_to_front @buffers[@buffers.length - 2]
+  end
+
+  def handle_input c
+    @focus_buf && @focus_buf.mode.handle_input(c)
+  end
+
+  def exists? n; @name_map.member? n; end
+  def [] n; @name_map[n]; end
+  def []= n, b
+    raise ArgumentError, "duplicate buffer name" if b && @name_map.member?(n)
+    @name_map[n] = b
+  end
+
+  def completely_redraw_screen
+    return if @shelled_out
+    Ncurses.clear
+    @dirty = true
+    draw_screen
+  end
+
+  def handle_resize
+    return if @shelled_out
+    rows, cols = Ncurses.rows, Ncurses.cols
+    @buffers.each { |b| b.resize rows - 1, cols }
+    completely_redraw_screen
+    flash "resized to #{rows}x#{cols}"
+  end
+
+  def draw_screen skip_minibuf=false
+    return if @shelled_out
+
+    ## 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?
+    end
+    ## quick hack
+    true && (@dirty ? @buffers.last.draw : @buffers.last.redraw)
+    
+    draw_minibuf unless skip_minibuf
+    @dirty = false
+    Ncurses.doupdate
+  end
+
+  ## gets the mode from the block, which is only called if the buffer
+  ## doesn't already exist. this is useful in the case that generating
+  ## the mode is expensive, as it often is.
+  def spawn_unless_exists title, opts={}
+    if @name_map.member? title
+      Redwood::log "buffer '#{title}' already exists, raising to front"
+      raise_to_front @name_map[title]
+    else
+      mode = yield
+      spawn title, mode, opts
+    end
+    @name_map[title]
+  end
+
+  def spawn title, mode, opts={}
+    realtitle = title
+    num = 2
+    while @name_map.member? realtitle
+      realtitle = "#{title} #{num}"
+      num += 1
+    end
+
+    Redwood::log "spawning buffer \"#{realtitle}\""
+    width = opts[:width] || Ncurses.cols
+    height = opts[:height] || Ncurses.rows - 1
+
+    ## since we are currently only doing multiple full-screen modes,
+    ## use stdscr for each window. once we become more sophisticated,
+    ## we may need to use a new Ncurses::WINDOW
+    ##
+    ## 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
+    if opts[:hidden]
+      @buffers.unshift b
+      focus_on b unless @focus_buf
+    else
+      @buffers.push b
+      raise_to_front b
+    end
+    b
+  end
+
+  def kill_all_buffers
+    kill_buffer @buffers.first until @buffers.empty?
+  end
+
+  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
+    @name_map.delete buf.title
+    @focus_buf = nil if @focus_buf == buf
+    if @buffers.empty?
+      ## TODO: something intelligent here
+      ## for now I will simply prohibit killing the inbox buffer.
+    else
+      raise_to_front @buffers.last
+    end
+  end
+
+  def ask domain, question, default=nil
+    @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
+    ## nightmare. jesus christ. the exact sequence of ncurses events
+    ## 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
+    tf.position_cursor
+    Ncurses.refresh
+
+    ret = nil
+    while tf.handle_input(Ncurses.nonblocking_getch); end
+
+    ret = tf.value
+    tf.deactivate
+    @dirty = true
+
+    ret
+  end
+
+  ## some pretty lame code in here!
+  def ask_getch question, accept=nil
+    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
+
+    ret = nil
+    done = false
+    until done
+      key = Ncurses.nonblocking_getch
+      if key == Ncurses::KEY_CANCEL
+        done = true
+      elsif (accept && accept.member?(key)) || !accept
+        ret = key
+        done = true
+      end
+    end
+
+    Ncurses.curs_set 0
+    erase_flash
+    draw_screen
+    Ncurses.curs_set 0
+
+    ret
+  end
+
+  def ask_yes_or_no question
+    [?y, ?Y].member? ask_getch(question, "ynYN")
+  end
+
+  def draw_minibuf
+    s = @flash || @minibuf_stack.reverse.find { |x| x } || ""
+
+    Ncurses.attrset Colormap.color_for(:none)
+    Ncurses.mvaddstr Ncurses.rows - 1, 0, s + (" " * [Ncurses.cols - s.length,
+                                                      0].max)
+  end
+
+  def say s, id=nil
+    id ||= @minibuf_stack.length
+    @minibuf_stack[id] = s
+    unless @shelled_out
+      draw_minibuf
+      Ncurses.refresh
+    end
+    id
+  end
+
+  def erase_flash; @flash = nil; end
+
+  def flash s
+    @flash = s
+    unless @shelled_out
+      draw_minibuf
+      Ncurses.refresh
+    end
+  end
+
+  def clear id
+    @minibuf_stack[id] = nil
+    if id == @minibuf_stack.length - 1
+      id.downto(0) do |i|
+        break unless @minibuf_stack[i].nil?
+        @minibuf_stack.delete_at i
+      end
+    end
+    unless @shelled_out
+      draw_minibuf
+      Ncurses.refresh
+    end
+  end
+
+  def shell_out command
+    @shelled_out = true
+    Ncurses.endwin
+    system command
+    Ncurses.refresh
+    Ncurses.curs_set 0
+    @shelled_out = false
+  end
+end
+end