class ReplyMode < EditMessageMode
REPLY_TYPES = [:sender, :recipient, :list, :all, :user]
TYPE_DESCRIPTIONS = {
- :sender => "Reply to sender",
- :recipient => "Reply to recipient",
- :all => "Reply to all",
- :list => "Reply to mailing list",
- :user => "Customized reply"
+ :sender => "Sender",
+ :recipient => "Recipient",
+ :all => "All",
+ :list => "Mailing list",
+ :user => "Customized"
}
- register_keymap do |k|
- k.add :move_cursor_right, "Move cursor to the right", :right
- k.add :move_cursor_left, "Move cursor to the left", :left
- end
-
- def initialize message
- super 2, :twiddles => false
+ 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
## 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)
-
- from =
- if @m.recipient_email
- AccountManager.account_for(@m.recipient_email)
- else
- (@m.to + @m.cc).find { |p| AccountManager.is_account? p }
- end || AccountManager.default_account
+ body = reply_body_lines message
+
+ ## 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
- #from_email = @m.recipient_email || from.email
- from_email = from.email
+ ## 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, if the original email had an envelope-to header, try and use
+ ## it, and look up the corresponding name form the list of accounts.
+ ##
+ ## 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 @m.recipient_email && (a = AccountManager.account_for(@m.recipient_email))
+ Person.new a.name, @m.recipient_email
+ ## otherwise, try and find an account somewhere in the list of to's
+ ## and cc's.
+ elsif(b = (@m.to + @m.cc).find { |p| AccountManager.is_account? p })
+ b
+ ## if all else fails, use the default
+ else
+ AccountManager.default_account
+ end
- ## ignore reply-to for list messages because it's typically set to
- ## the list address anyways
+ ## 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[:sender] = {
- "From" => "#{from.name} <#{from_email}>",
- "To" => [to.full_address],
- } unless AccountManager.is_account? to
-
@headers[:recipient] = {
- "From" => "#{from.name} <#{from_email}>",
"To" => cc.map { |p| p.full_address },
- } unless cc.empty? || @m.is_list_message?
+ } 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], } if !AccountManager.is_account?(to) || !useful_recipient
- @headers[:user] = {
- "From" => "#{from.name} <#{from_email}>",
- }
+ @headers[:user] = {}
+ not_me_ccs = cc.select { |p| !AccountManager.is_account?(p) }
@headers[:all] = {
- "From" => "#{from.name} <#{from_email}>",
"To" => [to.full_address],
- "Cc" => cc.map { |p| p.full_address },
- } unless cc.empty?
+ "Cc" => not_me_ccs.map { |p| p.full_address },
+ } unless not_me_ccs.empty?
@headers[:list] = {
- "From" => "#{from.name} <#{from_email}>",
"To" => [@m.list_address.full_address],
} if @m.is_list_message?
refs = gen_references
- mid = gen_message_id
+
@headers.each do |k, v|
@headers[k] = {
- "To" => "",
- "Cc" => "",
- "Bcc" => "",
- "In-Reply-To" => "<#{@m.id}>",
+ "From" => from.full_address,
+ "To" => [],
+ "Cc" => [],
+ "Bcc" => [],
+ "In-reply-to" => "<#{@m.id}>",
"Subject" => Message.reify_subj(@m.subj),
- "Message-Id" => mid,
"References" => refs,
}.merge v
end
- @type_labels = REPLY_TYPES.select { |t| @headers.member?(t) }
- @selected_type =
- if @m.is_list_message?
+ 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
+ end)
- regen_text
- end
-
- def lines; @text.length + 2; end
- def [] i
- case i
- when 0
- lame = []
- @type_labels.each do |t|
- lame << [(t == @selected_type ? :none_highlight : :none),
- "#{TYPE_DESCRIPTIONS[t]}"]
- lame << [:none, " "]
- end
- lame + [[:none, ""]]
- when 1
- ""
- else
- @text[i - 2]
+ @headers.each do |k, v|
+ HookManager.run "before-edit", :header => v, :body => body
end
+
+ super :header => @headers[@type_selector.val], :body => body, :twiddles => false
+ add_selector @type_selector
end
protected
- def body; @body + sig_lines; end
- def header; @headers[@selected_type]; end
+ def move_cursor_right
+ super
+ if @headers[@type_selector.val] != self.header
+ self.header = @headers[@type_selector.val]
+ update
+ end
+ end
+
+ def move_cursor_left
+ super
+ if @headers[@type_selector.val] != self.header
+ self.header = @headers[@type_selector.val]
+ update
+ end
+ end
def reply_body_lines m
- lines = ["Excerpts from #{@m.from.name}'s message of #{@m.date}:"] +
- m.basic_body_lines.map { |l| "> #{l}" }
- lines.pop while lines.last !~ /[:alpha:]/
+ 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 handle_new_text new_header, new_body
- @body = new_body
-
- if new_header.size != header.size ||
- header.any? { |k, v| new_header[k] != v }
- #raise "nhs: #{new_header.size} hs: #{header.size} new: #{new_header.inspect} old: #{header.inspect}"
- @selected_type = :user
- @headers[:user] = new_header
- end
+ def default_attribution m
+ "Excerpts from #{@m.from.name}'s message of #{@m.date}:"
end
- def regen_text
- @text = header_lines(header - NON_EDITABLE_HEADERS) + [""] + body
+ def handle_new_text new_header, new_body
+ old_header = @headers[@type_selector.val]
+ if new_header.size != old_header.size || old_header.any? { |k, v| new_header[k] != v }
+ @type_selector.set_to :user
+ self.header = @headers[:user] = new_header
+ update
+ end
end
def gen_references
(@m.refs + [@m.id]).map { |x| "<#{x}>" }.join(" ")
end
-
- def move_cursor_left
- i = @type_labels.index @selected_type
- @selected_type = @type_labels[(i - 1) % @type_labels.length]
- update
- end
- def move_cursor_right
- i = @type_labels.index @selected_type
- @selected_type = @type_labels[(i + 1) % @type_labels.length]
- update
+ def edit_field field
+ edited_field = super
+ if edited_field && edited_field != "Subject"
+ @type_selector.set_to :user
+ update
+ end
end
end
projects / sup / blobdiff