module MailParser::Loose

Constants

HEADER_PARSER

Public Instance Methods

_conv(str, opt) click to toggle source
# File lib/mailparser/loose.rb, line 344
def _conv(str, opt)
  cv = opt[:charset_converter]
  cs = opt[:output_charset]
  cv && cs ? cv.call(cs, cs, str) : str
end
mailbox_list(str, opt) click to toggle source

parse Mailbox type field @param [String] str @param [Hash] opt options @return [Array<MailParser::RFC2822::Mailbox>]

# File lib/mailparser/loose.rb, line 228
def mailbox_list(str, opt)
  ret = []
  split_by(Tokenizer.token(str), ",").each do |m|
    if a1 = m.index("<") and a2 = m.rindex(">") and a2 > a1 then
      display_name = m[0..a1-1].join(" ")
      if opt[:decode_mime_header] then
        display_name = RFC2047.decode(display_name, opt)
      end
      mailaddr = _conv(m[a1+1..a2-1].join, opt)
      local_part, domain = mailaddr.split(/@/, 2)
      ret << RFC2822::Mailbox.new(RFC2822::AddrSpec.new(local_part, domain), _conv(display_name, opt))
    else
      local_part, domain = _conv(m.join, opt).split(/@/, 2)
      ret << RFC2822::Mailbox.new(RFC2822::AddrSpec.new(local_part, domain))
    end
  end
  return ret
end
msg_id_list(str, opt={}) click to toggle source

parse MsgId type field @param [String] str @return [Array<MailParser::RFC2822::MsgId>]

# File lib/mailparser/loose.rb, line 250
def msg_id_list(str, opt={})
  ret = []
  flag = false
  msgid = nil
  Tokenizer.token(str).each do |m|
    case m
    when "<"
      unless flag
        flag = true
        msgid = ""
      end
    when ">"
      if flag
        flag = false
        ret << RFC2822::MsgId.new(_conv(msgid, opt))
      end
    else
      msgid << m if flag
    end
  end
  if ret.empty?
    ret = str.split.map{|s| RFC2822::MsgId.new(_conv(s, opt))}
  end
  return ret
end
parse(hname, hbody, opt={}) click to toggle source

@param [String] hname @param [String] hbody @param [Hash] opt options @return [header field value]

# File lib/mailparser/loose.rb, line 47
def parse(hname, hbody, opt={})
  if HEADER_PARSER.key? hname then
    return method(HEADER_PARSER[hname]).call(hbody, opt)
  else
    r = hbody.gsub(/\s+/, " ")
    if opt[:decode_mime_header] then
      return RFC2047.decode(r, opt)
    else
      return r
    end
  end
end
parse_content_disposition(str, opt={}) click to toggle source

parse Content-Disposition field @param [String] str @param [Hash] opt options @return [MailParser::RFC2183::ContentDispositoin]

# File lib/mailparser/loose.rb, line 194
def parse_content_disposition(str, opt={})
  token = split_by(Tokenizer.token(str), ";")
  type = token.empty? ? '' : token.shift.join
  params = {}
  token.each do |param|
    pn, pv = param.join.split(/=/, 2)
    params[pn.to_s] = _conv(pv.to_s.gsub(/\A"|"\z/,""), opt)
  end
  RFC2183::ContentDisposition.new(_conv(type, opt), params)
end
parse_content_transfer_encoding(str, opt={}) click to toggle source

parse Content-Transfer-Encoding field @param [String] str @param [Hash] opt options @return [MailParser::RFC2045::ContentTransferEncoding]

# File lib/mailparser/loose.rb, line 178
def parse_content_transfer_encoding(str, opt={})
  RFC2045::ContentTransferEncoding.new(_conv(Tokenizer.token(str).first.to_s, opt))
end
parse_content_type(str, opt={}) click to toggle source

parse Content-Type field @param [String] str @param [Hash] opt options @return [MailParser::RFC2045::ContentType]

# File lib/mailparser/loose.rb, line 159
def parse_content_type(str, opt={})
  token = split_by(Tokenizer.token(str), ";")
  type, subtype = token.empty? ? nil : token.shift.join.split("/", 2)
  params = {}
  token.each do |param|
    pn, pv = param.join.split(/=/, 2)
    params[pn.to_s] = _conv(pv.to_s.gsub(/\A"|"\z/,""), opt)
  end
  type = "text" if type.nil? or type.empty?
  if subtype.nil? or subtype.empty?
    subtype = type == "text" ? "plain" : ""
  end
  RFC2045::ContentType.new(_conv(type, opt), _conv(subtype, opt), params)
end
parse_date(str, opt={}) click to toggle source

parse Date field @param [String] str @param [Hash] opt options @return [MailParser::RFC2822::DateTime]

# File lib/mailparser/loose.rb, line 64
def parse_date(str, opt={})
  begin
    t = Time.rfc2822(str) rescue Time.parse(str)
  rescue
    t = Time.now
  end
  year = t.year > 9999 ? 9999 : t.year
  return RFC2822::DateTime.new(year, t.month, t.day, t.hour, t.min, t.sec, t.utc_offset)
end
parse_mailbox(str, opt={}) click to toggle source

parse Sender,Resent-Sender field @param [String] str @param [Hash] opt options @return [MailParser::RFC2822::Mailbox]

# File lib/mailparser/loose.rb, line 86
def parse_mailbox(str, opt={})
  mailbox_list(str, opt)[0]
end
parse_mailbox_list(str, opt={}) click to toggle source

parse From, To,Cc field @param [String] str @param [Hash] opt options @return [Array<MailParser::RFC2822::Mailbox>]

# File lib/mailparser/loose.rb, line 78
def parse_mailbox_list(str, opt={})
  mailbox_list(str, opt)
end
parse_mime_version(str, opt={}) click to toggle source

parse Mime-Version field @param [String] str @param [Hash] opt options @return [String]

# File lib/mailparser/loose.rb, line 186
def parse_mime_version(str, opt={})
  _conv(Tokenizer.token(str).join, opt)
end
parse_msg_id(str, opt={}) click to toggle source

parse Message-Id, Resent-Message-Id field @param [String] str @param [Hash] opt options @return [MailParser::RFC2822::MsgId]

# File lib/mailparser/loose.rb, line 94
def parse_msg_id(str, opt={})
  msg_id_list(str, opt)[0]
end
parse_msg_id_list(str, opt={}) click to toggle source

parse In-Reply-To, References field @param [String] str @param [Hash] opt options @return [MailParser::RFC2822::MsgIdList]

# File lib/mailparser/loose.rb, line 102
def parse_msg_id_list(str, opt={})
  msg_id_list(str, opt)
end
parse_phrase_list(str, opt={}) click to toggle source

parse Keywords field @param [String] str @param [Hash] opt options @return [Array<String>]

# File lib/mailparser/loose.rb, line 110
def parse_phrase_list(str, opt={})
  s = split_by(Tokenizer.token(str), ",")
  s.map!{|i| i.join(" ")}
  if opt[:decode_mime_header] then
    s.map!{|i| RFC2047.decode(i, opt)}
  end
  s.map{|_| _conv(_, opt)}
end
parse_received(str, opt={}) click to toggle source

parse Received field @param [String] str @param [Hash] opt options @return [MailParser::RFC2822::Received]

# File lib/mailparser/loose.rb, line 131
def parse_received(str, opt={})
  a = split_by(Tokenizer.token_received(str), ";")
  date = a.length > 1 ? parse_date(a.last.join(" ")) : RFC2822::DateTime.now
  name_val = {}
  i = 0
  v = ""
  unless a.empty?
    while i < a[0].length do
      if a[0][i] =~ /\A[a-z0-9]+\z/i then
        v = a[0][i+1]
        name_val[a[0][i].downcase] = v
        i += 1
      else
        v << a[0][i]
      end
      i += 1
    end
  end
  name_val.keys.each do |k|
    name_val[k] = _conv(name_val[k], opt)
  end
  RFC2822::Received.new(name_val, date)
end
parse_return_path(str, opt={}) click to toggle source

parse Return-Path field @param [String] str @param [Hash] opt options @return [Array<MailParser::RFC2822::ReturnPath>]

# File lib/mailparser/loose.rb, line 123
def parse_return_path(str, opt={})
  mailbox_list(str, opt)[0]
end
split_by(array, delim) click to toggle source

split arry by delim @param [Array] array @param [Object] delim @return [Array<Array>]

# File lib/mailparser/loose.rb, line 209
def split_by(array, delim)
  ret = []
  a = []
  array.each do |i|
    if i == delim then
      ret << a
      a = []
    else
      a << i
    end
  end
  ret << a unless a.empty?
  return ret
end