sup 0.19.0

data/lib/sup/modes/line_cursor_mode.rb

@@ -0,0 +1,203 @@
+module Redwood
+
+## extends ScrollMode to have a line-based cursor.
+class LineCursorMode < ScrollMode
+  register_keymap do |k|
+    ## overwrite scrollmode binding on arrow keys for cursor movement
+    ## but j and k still scroll!
+    k.add :cursor_down, "Move cursor down one line", :down, 'j'
+    k.add :cursor_up, "Move cursor up one line", :up, 'k'
+    k.add :select, "Select this item", :enter
+  end
+
+  attr_reader :curpos
+
+  def initialize opts={}
+    @cursor_top = @curpos = opts.delete(:skip_top_rows) || 0
+    @load_more_callbacks = []
+    @load_more_q = Queue.new
+    @load_more_thread = ::Thread.new do
+      while true
+        e = @load_more_q.pop
+        @load_more_callbacks.each { |c| c.call e }
+        sleep 0.5
+        @load_more_q.pop until @load_more_q.empty?
+      end
+    end
+
+    super opts
+  end
+
+  def cleanup
+    @load_more_thread.kill
+    super
+  end
+
+  def draw
+    super
+    set_status
+  end
+
+protected
+
+  ## callbacks when the cursor is asked to go beyond the bottom
+  def to_load_more &b
+    @load_more_callbacks << b
+  end
+
+  def draw_line ln, opts={}
+    if ln == @curpos
+      super ln, :highlight => true, :debug => opts[:debug], :color => :text_color
+    else
+      super ln, :color => :text_color
+    end
+  end
+
+  def ensure_mode_validity
+    super
+    raise @curpos.inspect unless @curpos.is_a?(Integer)
+    c = @curpos.clamp topline, botline - 1
+    c = @cursor_top if c < @cursor_top
+    buffer.mark_dirty unless c == @curpos
+    @curpos = c
+  end
+
+  def set_cursor_pos p
+    return if @curpos == p
+    @curpos = p.clamp @cursor_top, lines
+    buffer.mark_dirty
+    set_status
+  end
+
+  ## override search behavior to be cursor-based. this is a stupid
+  ## implementation and should be made better. TODO: improve.
+  def search_goto_line line
+    page_down while line >= botline
+    page_up while line < topline
+    set_cursor_pos line
+  end
+
+  def search_start_line; @curpos end
+
+  def line_down # overwrite scrollmode
+    super
+    call_load_more_callbacks([topline + buffer.content_height - lines, 10].max) if topline + buffer.content_height > lines
+    set_cursor_pos topline if @curpos < topline
+  end
+
+  def line_up # overwrite scrollmode
+    super
+    set_cursor_pos botline - 1 if @curpos > botline - 1
+  end
+
+  def cursor_down
+    call_load_more_callbacks buffer.content_height if @curpos >= lines - [buffer.content_height/2,1].max
+    return false unless @curpos < lines - 1
+
+    if $config[:continuous_scroll] and (@curpos == botline - 3 and @curpos < lines - 3)
+      # load more lines, one at a time.
+      jump_to_line topline + 1
+      @curpos += 1
+      unless buffer.dirty?
+        draw_line @curpos - 1
+        draw_line @curpos
+        set_status
+        buffer.commit
+      end
+    elsif @curpos >= botline - 1
+      page_down
+      set_cursor_pos topline
+    else
+      @curpos += 1
+      unless buffer.dirty?
+        draw_line @curpos - 1
+        draw_line @curpos
+        set_status
+        buffer.commit
+      end
+    end
+    true
+  end
+
+  def cursor_up
+    return false unless @curpos > @cursor_top
+
+    if $config[:continuous_scroll] and (@curpos == topline + 2)
+      jump_to_line topline - 1
+      @curpos -= 1
+      unless buffer.dirty?
+        draw_line @curpos + 1
+        draw_line @curpos
+        set_status
+        buffer.commit
+      end
+    elsif @curpos == topline
+      old_topline = topline
+      page_up
+      set_cursor_pos [old_topline - 1, topline].max
+    else
+      @curpos -= 1
+      unless buffer.dirty?
+        draw_line @curpos + 1
+        draw_line @curpos
+        set_status
+        buffer.commit
+      end
+    end
+    true
+  end
+
+  def page_up # overwrite
+    if topline <= @cursor_top
+      set_cursor_pos @cursor_top
+    else
+      relpos = @curpos - topline
+      super
+      set_cursor_pos topline + relpos
+    end
+  end
+
+  ## more complicated than one might think. three behaviors.
+  def page_down
+    ## if we're on the last page, and it's not a full page, just move
+    ## the cursor down to the bottom and assume we can't load anything
+    ## else via the callbacks.
+    if topline > lines - buffer.content_height
+      set_cursor_pos(lines - 1)
+
+    ## if we're on the last page, and it's a full page, try and load
+    ## more lines via the callbacks and then shift the page down
+    elsif topline == lines - buffer.content_height
+      call_load_more_callbacks buffer.content_height
+      super
+
+    ## otherwise, just move down
+    else
+      relpos = @curpos - topline
+      super
+      set_cursor_pos [topline + relpos, lines - 1].min
+    end
+  end
+
+  def jump_to_start
+    super
+    set_cursor_pos @cursor_top
+  end
+
+  def jump_to_end
+    super if topline < (lines - buffer.content_height)
+    set_cursor_pos(lines - 1)
+  end
+
+private
+
+  def set_status
+    l = lines
+    @status = l > 0 ? "line #{@curpos + 1} of #{l}" : ""
+  end
+
+  def call_load_more_callbacks size
+    @load_more_q.push size if $config[:load_more_threads_when_scrolling]
+  end
+end
+end

data/lib/sup/modes/log_mode.rb

@@ -0,0 +1,57 @@
+require 'stringio'
+module Redwood
+
+## a variant of text mode that allows the user to automatically follow text,
+## and respawns when << is called if necessary.
+
+class LogMode < TextMode
+  register_keymap do |k|
+    k.add :toggle_follow, "Toggle follow mode", 'f'
+  end
+
+  ## if buffer_name is supplied, this mode will spawn a buffer
+  ## upon receiving the << message. otherwise, it will act like
+  ## a regular buffer.
+  def initialize autospawn_buffer_name=nil
+    @follow = true
+    @autospawn_buffer_name = autospawn_buffer_name
+    @on_kill = []
+    super()
+  end
+
+  ## register callbacks for when the buffer is killed
+  def on_kill &b; @on_kill << b end
+
+  def toggle_follow
+    @follow = !@follow
+    if @follow
+      jump_to_line(lines - buffer.content_height + 1) # leave an empty line at bottom
+    end
+    buffer.mark_dirty
+  end
+
+  def << s
+    if buffer.nil? && @autospawn_buffer_name
+      BufferManager.spawn @autospawn_buffer_name, self, :hidden => true, :system => true
+    end
+
+    s.split("\n").each { |l| super(l + "\n") } # insane. different << semantics.
+
+    if @follow
+      follow_top = lines - buffer.content_height + 1
+      jump_to_line follow_top if topline < follow_top
+    end
+  end
+
+  def status
+    super + " (follow: #@follow)"
+  end
+
+  def cleanup
+    @on_kill.each { |cb| cb.call self }
+    self.text = ""
+    super
+  end
+end
+
+end

data/lib/sup/modes/person_search_results_mode.rb

@@ -0,0 +1,12 @@
+module Redwood
+
+class PersonSearchResultsMode < ThreadIndexMode
+  def initialize people
+    @people = people
+    super [], { :participants => @people }
+  end
+
+  def is_relevant? m; @people.any? { |p| m.from == p }; end
+end
+
+end

data/lib/sup/modes/poll_mode.rb

@@ -0,0 +1,19 @@
+module Redwood
+
+class PollMode < LogMode
+  def initialize
+    @new = true
+    super "poll for new messages"
+  end
+
+  def poll
+    unless @new
+      @new = false
+      self << "\n"
+    end
+    self << "Poll started at #{Time.now}\n"
+    PollManager.do_poll { |s| self << (s + "\n") }
+  end
+end
+
+end

data/lib/sup/modes/reply_mode.rb

@@ -0,0 +1,228 @@
+module Redwood
+
+class ReplyMode < EditMessageMode
+  REPLY_TYPES = [:sender, :recipient, :list, :all, :user]
+  TYPE_DESCRIPTIONS = {
+    :sender => "Sender",
+    :recipient => "Recipient",
+    :all => "All",
+    :list => "Mailing list",
+    :user => "Customized"
+  }
+
+  HookManager.register "attribution", <<EOS
+Generates an attribution ("Excerpts from Joe Bloggs's message of Fri Jan 11 09:54:32 -0500 2008:").
+Variables:
+  message: a message object representing the message being replied to
+    (useful values include message.from.name and message.date)
+Return value:
+  A string containing the text of the quote line (can be multi-line)
+EOS
+
+  HookManager.register "reply-from", <<EOS
+Selects a default address for the From: header of a new reply.
+Variables:
+  message: a message object representing the message being replied to
+    (useful values include message.recipient_email, message.to, and message.cc)
+Return value:
+  A Person to be used as the default for the From: header, or nil to use the
+  default behavior.
+EOS
+
+  HookManager.register "reply-to", <<EOS
+Set the default reply-to mode.
+Variables:
+  modes: array of valid modes to choose from, which will be a subset of
+             [:#{REPLY_TYPES * ', :'}]
+         The default behavior is equivalent to
+             ([:list, :sender, :recipent] & modes)[0]
+Return value:
+  The reply mode you desire, or nil to use the default behavior.
+EOS
+
+  def initialize message, type_arg=nil
+    @m = message
+    @edited = false
+
+    ## it's important to put this early because it forces a read of
+    ## the full headers (most importantly the list-post header, if
+    ## any)
+    body = reply_body_lines message
+    @body_orig = body
+
+    ## first, determine the address at which we received this email. this will
+    ## become our From: address in the reply.
+    hook_reply_from = HookManager.run "reply-from", :message => @m
+
+    ## sanity check that selection is a Person (or we'll fail below)
+    ## don't check that it's an Account, though; assume they know what they're
+    ## doing.
+    if hook_reply_from && !(hook_reply_from.is_a? Person)
+      info "reply-from returned non-Person, using default from."
+      hook_reply_from = nil
+    end
+
+    ## determine the from address of a reply.
+    ## if we have a value from a hook, use it.
+    from = if hook_reply_from
+      hook_reply_from
+    ## otherwise, try and find an account somewhere in the list of to's
+    ## and cc's and look up the corresponding name form the list of accounts.
+    ## if this does not succeed use the recipient_email (=envelope-to) instead.
+    ## this is for the case where mail is received from a mailing lists (so the
+    ## To: is the list id itself). if the user subscribes via a particular
+    ## alias, we want to use that alias in the reply.
+    elsif(b = (@m.to.collect {|t| t.email} + @m.cc.collect {|c| c.email} + [@m.recipient_email] ).find { |p| AccountManager.is_account_email? p })
+      a = AccountManager.account_for(b)
+      Person.new a.name, b
+    ## if all else fails, use the default
+    else
+      AccountManager.default_account
+    end
+
+    ## now, determine to: and cc: addressess. we ignore reply-to for list
+    ## messages because it's typically set to the list address, which we
+    ## explicitly treat with reply type :list
+    to = @m.is_list_message? ? @m.from : (@m.replyto || @m.from)
+
+    ## next, cc:
+    cc = (@m.to + @m.cc - [from, to]).uniq
+
+    ## one potential reply type is "reply to recipient". this only happens
+    ## in certain cases:
+    ## if there's no cc, then the sender is the person you want to reply
+    ## to. if it's a list message, then the list address is. otherwise,
+    ## the cc contains a recipient.
+    useful_recipient = !(cc.empty? || @m.is_list_message?)
+
+    @headers = {}
+    @headers[:recipient] = {
+      "To" => cc.map { |p| p.full_address },
+      "Cc" => [],
+    } if useful_recipient
+
+    ## typically we don't want to have a reply-to-sender option if the sender
+    ## is a user account. however, if the cc is empty, it's a message to
+    ## ourselves, so for the lack of any other options, we'll add it.
+    @headers[:sender] = {
+      "To" => [to.full_address],
+      "Cc" => [],
+    } if !AccountManager.is_account?(to) || !useful_recipient
+
+    @headers[:user] = {
+      "To" => [],
+      "Cc" => [],
+    }
+
+    not_me_ccs = cc.select { |p| !AccountManager.is_account?(p) }
+    @headers[:all] = {
+      "To" => [to.full_address],
+      "Cc" => not_me_ccs.map { |p| p.full_address },
+    } unless not_me_ccs.empty?
+
+    @headers[:list] = {
+      "To" => [@m.list_address.full_address],
+      "Cc" => [],
+    } if @m.is_list_message?
+
+    refs = gen_references
+
+    types = REPLY_TYPES.select { |t| @headers.member?(t) }
+    @type_selector = HorizontalSelector.new "Reply to:", types, types.map { |x| TYPE_DESCRIPTIONS[x] }
+
+    hook_reply = HookManager.run "reply-to", :modes => types
+
+    @type_selector.set_to(
+      if types.include? type_arg
+        type_arg
+      elsif types.include? hook_reply
+        hook_reply
+      elsif @m.is_list_message?
+        :list
+      elsif @headers.member? :sender
+        :sender
+      else
+        :recipient
+      end)
+
+    headers_full = {
+      "From" => from.full_address,
+      "Bcc" => [],
+      "In-reply-to" => "<#{@m.id}>",
+      "Subject" => Message.reify_subj(@m.subj),
+      "References" => refs,
+    }.merge @headers[@type_selector.val]
+
+    HookManager.run "before-edit", :header => headers_full, :body => body
+
+    super :header => headers_full, :body => body, :twiddles => false
+    add_selector @type_selector
+  end
+
+protected
+
+  def move_cursor_right
+    super
+    if @headers[@type_selector.val] != self.header
+      self.header = self.header.merge @headers[@type_selector.val]
+      rerun_crypto_selector_hook
+      update
+    end
+  end
+
+  def move_cursor_left
+    super
+    if @headers[@type_selector.val] != self.header
+      self.header = self.header.merge @headers[@type_selector.val]
+      rerun_crypto_selector_hook
+      update
+    end
+  end
+
+  def reply_body_lines m
+    attribution = HookManager.run("attribution", :message => m) || default_attribution(m)
+    lines = attribution.split("\n") + m.quotable_body_lines.map { |l| "> #{l}" }
+    lines.pop while lines.last =~ /^\s*$/
+    lines
+  end
+
+  def default_attribution m
+    "Excerpts from #{@m.from.name}'s message of #{@m.date}:"
+  end
+
+  def handle_new_text new_header, new_body
+    if new_body != @body_orig
+      @body_orig = new_body
+      @edited = true
+    end
+    old_header = @headers[@type_selector.val]
+    if old_header.any? { |k, v| new_header[k] != v }
+      @type_selector.set_to :user
+      self.header["To"] = @headers[:user]["To"] = new_header["To"]
+      self.header["Cc"] = @headers[:user]["Cc"] = new_header["Cc"]
+      update
+    end
+  end
+
+  def gen_references
+    (@m.refs + [@m.id]).map { |x| "<#{x}>" }.join(" ")
+  end
+
+  def edit_field field
+    edited_field = super
+    if edited_field and (field == "To" or field == "Cc")
+      @type_selector.set_to :user
+      @headers[:user]["To"] = self.header["To"]
+      @headers[:user]["Cc"] = self.header["Cc"]
+      update
+    end
+  end
+
+  def send_message
+    return unless super # super returns true if the mail has been sent
+    @m.add_label :replied
+    Index.save_message @m
+  end
+end
+
+end