## appropriately.
class Message
SNIPPET_LEN = 80
+ WRAP_LEN = 80 # wrap at this width
RE_PATTERN = /^((re|re[\[\(]\d[\]\)]):\s*)+/i
## some utility methods
attr_reader :lines
def initialize lines
## do some wrapping
- @lines = lines.map { |l| l.chomp.wrap 80 }.flatten
+ @lines = lines.map { |l| l.chomp.wrap WRAP_LEN }.flatten
end
end
attr_reader :id, :date, :from, :subj, :refs, :replytos, :to, :source,
:cc, :bcc, :labels, :list_address, :recipient_email, :replyto,
- :source_info, :status
+ :source_info
- bool_reader :dirty
+ bool_reader :dirty, :source_marked_read
## if you specify a :header, will use values from that. otherwise, will try and
## load the header from the source.
@source = opts[:source] or raise ArgumentError, "source can't be nil"
@source_info = opts[:source_info] or raise ArgumentError, "source_info can't be nil"
@snippet = opts[:snippet] || ""
+ @have_snippet = !opts[:snippet].nil?
@labels = opts[:labels] || []
@dirty = false
nil
end
- @recipient_email = header["delivered-to"]
- @status = header["status"]
+ @recipient_email = header["envelope-to"] || header["x-original-to"] || header["delivered-to"]
+ @source_marked_read = header["status"] == "RO"
end
private :read_header
def broken?; @source.broken?; end
- def snippet; @snippet || to_chunks && @snippet; end
+ def snippet; @snippet || chunks && @snippet; end
def is_list_message?; !@list_address.nil?; end
def is_draft?; DraftLoader === @source; end
def draft_filename
end
## this is called when the message body needs to actually be loaded.
- def to_chunks
+ def chunks
@chunks ||=
if @source.broken?
[Text.new(error_message(@source.broken_msg.split("\n")))]
else
begin
+ ## we need to re-read the header because it contains information
+ ## that we don't store in the index. actually i think it's just
+ ## the mailing list address (if any), so this is kinda overkill.
+ ## i could just store that in the index, but i think there might
+ ## be other things like that in the future, and i'd rather not
+ ## bloat the index.
read_header @source.load_header(@source_info)
message_to_chunks @source.load_message(@source_info)
- rescue SourceError => e
+ rescue SourceError, SocketError, MessageFormatError => e
[Text.new(error_message(e.message))]
end
end
<<EOS
#@snippet...
-***********
-** ERROR **
-***********
-
-An error occurred while loading this message. It is possible that the source
-has changed, or (in the case of remote sources) is down.
+***********************************************************************
+* An error occurred while loading this message. It is possible that *
+* the source has changed, or (in the case of remote sources) is down. *
+***********************************************************************
The error message was:
#{msg}
begin
@source.raw_header @source_info
rescue SourceError => e
- [Text.new(error_message(e.message))]
+ error_message e.message
end
end
begin
@source.raw_full_message @source_info
rescue SourceError => e
- [Text.new(error_message(e.message))]
+ error_message(e.message)
end
end
to.map { |p| "#{p.name} #{p.email}" },
cc.map { |p| "#{p.name} #{p.email}" },
bcc.map { |p| "#{p.name} #{p.email}" },
- to_chunks.select { |c| c.is_a? Text }.map { |c| c.lines },
+ chunks.select { |c| c.is_a? Text }.map { |c| c.lines },
Message.normalize_subj(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
+ chunks.find_all { |c| c.is_a?(Text) || c.is_a?(Quote) }.map { |c| c.lines }.flatten
end
def basic_header_lines
ret = [] <<
case m.header.content_type
when "text/plain", nil
- raise MessageFormatError, "no message body before decode (source #@source info #@source_info)" unless
- m.body
- body = m.decode or raise MessageFormatError, "no message body"
+ m.body && body = m.decode or raise MessageFormatError, "for some bizarre reason, RubyMail was unable to parse this message."
text_to_chunks body.normalize_whitespace.split("\n")
when /^multipart\//
nil
## 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 = []
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) < MAX_SIG_DISTANCE
elsif line =~ BLOCK_QUOTE_PATTERN
newstate = :block_quote
end
+
if newstate
chunks << Text.new(chunk_lines) unless chunk_lines.empty?
chunk_lines = [line]
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) < MAX_SIG_DISTANCE
else
newstate = :text
end
+
if newstate
if chunk_lines.empty?
# nothing
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*$/
+ if !@have_snippet && state == :text && (@snippet.nil? || @snippet.length < SNIPPET_LEN) && line !~ /[=\*#_-]{3,}/ && line !~ /^\s*$/
@snippet += " " unless @snippet.empty?
@snippet += line.gsub(/^\s+/, "").gsub(/[\r\n]/, "").gsub(/\s+/, " ")
@snippet = @snippet[0 ... SNIPPET_LEN].chomp
projects / sup / blobdiff