internet_message 0.1

data/lib/internet_message/address.rb

@@ -0,0 +1,35 @@
+class InternetMessage
+  class Address
+
+    attr_reader :local_part, :domain
+
+    # @param [String] local_part local part of mail address
+    # @param [String] domain domain part of mail address
+    def initialize(local_part, domain)
+      @local_part, @domain = local_part, domain
+    end
+
+    # @return [String] mail address
+    def to_s
+      if @local_part =~ /\A[0-9a-zA-Z\!\#\$\%\'\*\+\-\/\=\?\^\_\`\{\|\}\~]+(\.[0-9a-zA-Z\!\#\$\%\'\*\+\-\/\=\?\^\_\`\{\|\}\~]+)*\z/n
+        l = @local_part
+      else
+        l = quote_string(@local_part)
+      end
+      "#{l}@#{@domain}"
+    end
+
+    # @private
+    def quote_string(s)
+      '"'+s.gsub(/[\\\"]/){"\\#{$&}"}+'"'
+    end
+
+    # Compare self to other. local_part and domain are case insensitive.
+    # @param [Address] other
+    # @return [true, false]
+    def ==(other)
+      other.is_a?(Address) && other.local_part.downcase == self.local_part.downcase && other.domain.downcase == self.domain.downcase
+    end
+
+  end
+end

data/lib/internet_message/content_attribute.rb

@@ -0,0 +1,54 @@
+class InternetMessage
+  # @private
+  module ContentAttribute
+    def self.parse_attribute(tokens)
+      attr = {}
+      until tokens.empty?
+        break unless tokens.size >= 4 && tokens[0].value == ';' && tokens[2].value == '='
+        attr[tokens[1].value.downcase] = tokens[3].value
+        tokens.shift 4
+      end
+
+      newattr = {}
+      h = Hash.new{|hash,k| hash[k] = []}
+      char_lang = {}
+      attr.each do |key, value|
+        case key
+        when /^([^\*]+)(\*0)?\*$/no
+          name, ord = $1, $2
+          char, lang, v = value.split(/\'/, 3)
+          char_lang[name] = [char, lang]
+          if v.nil?
+            v = lang || char
+          end
+          v = v.gsub(/%([0-9A-F][0-9A-F])/ni){$1.hex.chr}
+          if ord
+            h[name] << [0, v]
+          else
+            newattr[name] = v
+          end
+        when /^([^\*]+)\*([1-9]\d*)\*$/no
+          name, ord = $1, $2.to_i
+          v = value.gsub(/%([0-9A-F][0-9A-F])/ni){$1.hex.chr}
+          h[name] << [ord, v]
+        when /^([^\*]+)\*([0-9]\d*)$/no
+          name, ord = $1, $2.to_i
+          h[name] << [ord, value]
+        else
+          newattr[key] = value
+        end
+      end
+      h.each do |k, v|
+        newattr[k] = v.sort{|a,b| a[0]<=>b[0]}.map{|a| a[1]}.join
+      end
+      newattr.keys.each do |k|
+        v = newattr[k]
+        if char_lang.key? k
+          v.force_encoding(char_lang[k][0]) rescue nil
+        end
+        newattr[k] = v
+      end
+      return newattr
+    end
+  end
+end

data/lib/internet_message/content_disposition.rb

@@ -0,0 +1,37 @@
+require "#{File.dirname __FILE__}/tokenizer"
+require "#{File.dirname __FILE__}/content_attribute"
+
+class InternetMessage
+  class ContentDisposition
+
+    TOKEN_RE = /[0-9a-zA-Z\!\#\$\%\&\'\*\+\-\.\^\_\`\{\|\}\~]+/i
+
+    # @param [String, Array of Tokenizer] src
+    # @return [ContentDisposition]
+    def self.parse(src)
+      tokens = src.is_a?(String) ? Tokenizer.new(src, :token_re=>TOKEN_RE).tokenize : src.dup
+      tokens.delete_if{|t| t.type == :WSP or t.type == :COMMENT}
+      unless tokens.size >= 1 && tokens[0].type == :TOKEN
+        return nil
+      end
+      type = tokens[0].value
+      tokens.shift
+      ContentDisposition.new(type, ContentAttribute.parse_attribute(tokens))
+    end
+
+    attr_reader :type, :attribute
+
+    # @param [String] type
+    # @param [Hash] attribute
+    def initialize(type, attribute={})
+      @type, @attribute = type.downcase, attribute
+    end
+
+    # Compare self and other.
+    # @param [ContentDisposition] other
+    # @return [true, false]
+    def ==(other)
+      other.is_a?(ContentDisposition) && other.type == self.type && other.attribute == self.attribute
+    end
+  end
+end

data/lib/internet_message/content_type.rb

@@ -0,0 +1,38 @@
+require "#{File.dirname __FILE__}/tokenizer"
+require "#{File.dirname __FILE__}/content_attribute"
+
+class InternetMessage
+  class ContentType
+
+    TOKEN_RE = /[0-9a-zA-Z\!\#\$\%\&\'\*\+\-\.\^\_\`\{\|\}\~]+/i
+
+    # @param [String, Array of Tokenizer] src
+    # @return [ContentType]
+    def self.parse(src)
+      tokens = src.is_a?(String) ? Tokenizer.new(src, :token_re=>TOKEN_RE).tokenize : src.dup
+      tokens.delete_if{|t| t.type == :WSP or t.type == :COMMENT}
+      unless tokens.size >= 3 && tokens[0].type == :TOKEN && tokens[1].value == '/' && tokens[2].type == :TOKEN
+        return nil
+      end
+      type, subtype = tokens[0].value, tokens[2].value
+      tokens.shift 3
+      ContentType.new(type, subtype, ContentAttribute.parse_attribute(tokens))
+    end
+
+    attr_reader :type, :subtype, :attribute
+
+    # @param [String] type
+    # @param [String] subtype
+    # @param [Hash] attribute
+    def initialize(type, subtype, attribute={})
+      @type, @subtype, @attribute = type.downcase, subtype.downcase, attribute
+    end
+
+    # Compare self and other
+    # @param [ContentType] other
+    # @return [true, false]
+    def ==(other)
+      other.is_a?(ContentType) && other.type == self.type && other.subtype == self.subtype && other.attribute == self.attribute
+    end
+  end
+end

data/lib/internet_message/group.rb

@@ -0,0 +1,49 @@
+require "#{File.dirname __FILE__}/tokenizer"
+
+class InternetMessage
+  class Group
+    # @param [String, Array of Tokenizer] src
+    # @param [true, false] decode_mime_header Set true to decode MIME header (RFC2047).
+    # @return [Group]
+    def self.parse(src, decode_mime_header=nil)
+      tokens = src.is_a?(String) ? Tokenizer.new(src).tokenize : src.dup
+      tokens.delete_if{|t| t.type == :WSP or t.type == :COMMENT}
+      i = tokens.index(Token.new(:CHAR, ':'))
+      j = tokens.index(Token.new(:CHAR, ';')) || tokens.size
+      if i and i < j
+        disp_tokens = tokens[0..i-1]
+        display_name = i == 0 ? '' : decode_mime_header ? InternetMessage.decode_mime_header_words(disp_tokens) : disp_tokens.join(' ')
+        mailbox_list = Mailbox.parse_list(tokens[i+1..j-1], decode_mime_header)
+        Group.new(display_name, mailbox_list)
+      else
+        Group.new('', Mailbox.parse_list(tokens))
+      end
+    end
+
+    attr_reader :mailbox_list, :display_name
+
+    # @param [String] display_name
+    # @param [Array of Mailbox] mailbox_list
+    def initialize(display_name, mailbox_list)
+      @display_name, @mailbox_list = display_name, mailbox_list
+    end
+
+    # @private
+    def to_s
+      d = @display_name.split(/[ \t]+/).map do |w|
+        if w =~ /\A[0-9a-zA-Z\!\#\$\%\'\*\+\-\/\=\?\^\_\`\{\|\}\~]+\z/n
+          w
+        else
+          quote_string w
+        end
+      end.join(' ')
+      "#{d}: "+mailbox_list.join(', ')+';'
+    end
+
+    private
+
+    def quote_string(s)
+      '"'+s.gsub(/[\\\"]/){"\\#{$&}"}+'"'
+    end
+  end
+end

data/lib/internet_message/header_field.rb

@@ -0,0 +1,129 @@
+class InternetMessage
+  class HeaderField
+    attr_reader :name, :orig_value, :raw
+
+    # @param [String] name field name
+    # @param [MmapScanner] value field value
+    # @param [MmapScanner] raw field line
+    def initialize(name, value, raw)
+      @name, @orig_value, @raw = name, value, raw
+    end
+
+    # @return [String] value as String
+    def value
+      @orig_value.to_s
+    end
+
+    # @param [true, false] decode_mime_header Set true to decode MIME header (RFC2047).
+    # @return parsed value
+    def parse(decode_mime_header=nil)
+      case @name
+      when 'date', 'resent-date'
+        DateTime.parse(value.gsub(/\r?\n/, '')) rescue nil
+      when 'from', 'resent-from'
+        self.class.parse_mailboxlist(value, decode_mime_header)
+      when 'from', 'sender', 'resent-from', 'resent-sender'
+        Mailbox.parse(value, decode_mime_header)
+      when 'message-id', 'content-id', 'resent-message-id'
+        MessageId.parse(value)
+      when 'in-reply-to', 'references'
+        MessageId.parse_list(value)
+      when 'mime-version', 'content-transfer-encoding'
+        tokens = Tokenizer.new(value).tokenize2
+        tokens.empty? ? nil : tokens.join
+      when 'content-type'
+        ContentType.parse(value)
+      when 'content-disposition'
+        ContentDisposition.parse(value)
+      when 'reply-to', 'to', 'cc', 'bcc', 'resent-to', 'resent-cc', 'resent-bcc'
+        self.class.parse_addrlist(value, decode_mime_header)
+      when 'keywords'
+        self.class.parse_keywords(value, decode_mime_header)
+      when 'return-path'
+        self.class.parse_return_path(value)
+      when 'received'
+        Received.parse value
+      else
+        s = value.gsub(/\r?\n/, '')
+        decode_mime_header ? InternetMessage.decode_mime_header_str(s) : s
+      end
+    end
+
+    # @private
+    def self.parse_mailboxlist(str, decode_mime_header=nil)
+      ret = []
+      tokens = Tokenizer.new(str).tokenize2
+      until tokens.empty?
+        i = tokens.index(Token.new(:CHAR, ','))
+        if i == 0
+          tokens.shift
+          next
+        end
+        if i
+          ret.push Mailbox.parse(tokens.slice!(0..i-1), decode_mime_header)
+        else
+          ret.push Mailbox.parse(tokens, decode_mime_header)
+          tokens.clear
+        end
+      end
+      ret
+    end
+
+    # @private
+    def self.parse_addrlist(str, decode_mime_header=nil)
+      ret = []
+      tokens = Tokenizer.new(str).tokenize2
+      until tokens.empty?
+        i = tokens.index(Token.new(:CHAR, ','))
+        if i == 0
+          tokens.shift
+          next
+        end
+        j = tokens.index(Token.new(:CHAR, ':'))
+        if i && j && j < i || !i && j
+          i = tokens.index(Token.new(:CHAR, ';')) || -1
+          ret.push Group.parse(tokens.slice!(0..i), decode_mime_header)
+        elsif i
+          ret.push Mailbox.parse(tokens.slice!(0..i-1), decode_mime_header)
+        else
+          ret.push Mailbox.parse(tokens, decode_mime_header)
+          tokens.clear
+        end
+      end
+      ret
+    end
+
+    # @private
+    def self.parse_keywords(str, decode_mime_header=nil)
+      keys = []
+      tokens = Tokenizer.new(str).tokenize2
+      while true
+        i = tokens.index(Token.new(:CHAR, ','))
+        break unless i
+        if i > 0
+          key = decode_mime_header ? InternetMessage.decode_mime_header_words(tokens[0, i]) : tokens[0, i].join(' ')
+          keys.push key
+        end
+        tokens.shift i+1
+      end
+      unless tokens.empty?
+        key = decode_mime_header ? InternetMessage.decode_mime_header_words(tokens) : tokens.join(' ')
+        keys.push key
+      end
+      keys
+    end
+
+    # @private
+    def self.parse_return_path(str)
+      tokens = Tokenizer.new(str).tokenize2
+      i = tokens.index(Token.new(:CHAR, '<'))
+      return unless i
+      tokens.shift i+1
+      i = tokens.index(Token.new(:CHAR, '>'))
+      return unless i
+      tokens = tokens[0, i]
+      i = tokens.rindex(Token.new(:CHAR, '@'))
+      i && Address.new(tokens[0, i].join, tokens[i+1..-1].join)
+    end
+  end
+end

data/lib/internet_message/mailbox.rb

@@ -0,0 +1,102 @@
+require "#{File.dirname __FILE__}/tokenizer"
+require "#{File.dirname __FILE__}/address"
+
+class InternetMessage
+  class Mailbox
+    # @param [String, Array of Tokenizer] src
+    # @param [true, false] decode_mime_header Set true to decode MIME header (RFC2047).
+    # @return [Mailbox]
+    def self.parse(src, decode_mime_header=nil)
+      tokens = src.is_a?(String) ? Tokenizer.new(src).tokenize : src.dup
+      tokens.delete_if{|t| t.type == :WSP or t.type == :COMMENT}
+      if i = tokens.index(Token.new(:CHAR, '<'))
+        display_name = decode_mime_header ? InternetMessage.decode_mime_header_words(tokens[0..i-1]) : tokens[0..i-1].join(' ')
+        if j = tokens.index(Token.new(:CHAR, '>'))
+          tokens = tokens[i+1..j-1]
+        else
+          tokens = tokens[i+1..-1]
+        end
+      end
+      i = tokens.rindex(Token.new(:CHAR, '@'))
+      return unless i
+      local = i == 0 ? '' : tokens[0..i-1].join
+      domain = tokens[i+1..-1].join
+      Mailbox.new(Address.new(local, domain), display_name)
+    end
+
+    # @param [String, Array of Tokenizer] src
+    # @param [true, false] decode_mime_header Set true to decode MIME header (RFC2047).
+    # @return [Array of Mailbox]
+    def self.parse_list(src, decode_mime_header=nil)
+      tokens = src.is_a?(String) ? Tokenizer.new(src).tokenize : src.dup
+      ret = []
+      until tokens.empty?
+        i = tokens.index(Token.new(:CHAR, ','))
+        break unless i
+        if i > 0
+          ret.push self.parse(tokens.slice!(0, i), decode_mime_header)
+        end
+        tokens.shift
+      end
+      ret.push self.parse(tokens, decode_mime_header) unless tokens.empty?
+      ret
+    end
+
+    attr_reader :address, :display_name
+
+    # @overload initialize(addr, display_name=nil)
+    #   @param [Address] addr
+    #   @param [String] display_name
+    # @overload initialize(local_part, domain, display_name=nil)
+    #   @param [String] local_part
+    #   @param [String] domain
+    #   @param [String] display_name
+    def initialize(addr, *args)
+      if addr.is_a? Address and args.size <= 1
+        @address = addr
+        @display_name = args.first
+      elsif args.size >= 1 and args.size <= 2
+        @address = Address.new(addr, args[0])
+        @display_name = args[1]
+      else
+        raise ArgumentError
+      end
+    end
+
+    # @return [String] local_part
+    def local_part
+      @address.local_part
+    end
+
+    # @return [String] domain
+    def domain
+      @address.domain
+    end
+
+    # @private
+    def to_s
+      if @display_name
+        d = @display_name.split(/[ \t]+/).map do |w|
+          if w =~ /\A[0-9a-zA-Z\!\#\$\%\'\*\+\-\/\=\?\^\_\`\{\|\}\~]+\z/n
+            w
+          else
+            quote_string w
+          end
+        end.join(' ')
+        "#{d} <#{@address.to_s}>"
+      else
+        @address.to_s
+      end
+    end
+
+    private
+
+    def quote_string(s)
+      '"'+s.gsub(/[\\\"]/){"\\#{$&}"}+'"'
+    end
+
+    def ==(other)
+      other.is_a?(Mailbox) && other.address == self.address && other.display_name == self.display_name
+    end
+  end
+end

data/lib/internet_message/message_id.rb

@@ -0,0 +1,47 @@
+require "#{File.dirname __FILE__}/tokenizer"
+
+class InternetMessage
+  class MessageId
+    # @param [String, Array of Tokenizer] src
+    # @return [MessageId]
+    def self.parse(str)
+      tokens = Tokenizer.new(str).tokenize2
+      i = tokens.index(Token.new(:CHAR, '<'))
+      return unless i
+      tokens.shift i+1
+      i = tokens.index(Token.new(:CHAR, '>'))
+      return unless i
+      self.new tokens[0, i].join
+    end
+
+    # @param [String, Array of Tokenizer] src
+    # @return [Array of MessageId]
+    def self.parse_list(str)
+      tokens = Tokenizer.new(str).tokenize2
+      ret = []
+      while true
+        i = tokens.index(Token.new(:CHAR, '<'))
+        break unless i
+        tokens.shift i+1
+        i = tokens.index(Token.new(:CHAR, '>'))
+        break unless i
+        ret.push MessageId.new(tokens[0, i].join)
+      end
+      ret
+    end
+
+    attr_reader :msgid
+
+    # @param [String] msgid
+    def initialize(msgid)
+      @msgid = msgid
+    end
+
+    # Compare self to other
+    # @param [String] other
+    # @return [true, false]
+    def ==(other)
+      other.is_a?(MessageId) && other.msgid == self.msgid
+    end
+  end
+end

data/lib/internet_message/received.rb

@@ -0,0 +1,59 @@
+require 'date'
+require "#{File.dirname __FILE__}/tokenizer"
+
+class InternetMessage
+  class Received
+    # @param [String, Array of Tokenizer] src
+    # @return [Received]
+    def self.parse(src)
+      tokens = src.is_a?(String) ? Tokenizer.new(src).tokenize : src.dup
+      i = tokens.index(Token.new(:CHAR, ';'))
+      return unless i
+      date = DateTime.parse(tokens[i+1..-1].join) rescue nil
+      tokens = tokens[0, i]
+
+      list = tokens.inject([[]]){|r, t|
+        if t.type == :WSP or t.type == :COMMENT
+          r.push []
+        else
+          r.last.push t
+        end
+        r
+      }.reject(&:empty?)
+
+      while list.size >= 2
+        case list.shift.join.downcase
+        when 'from'
+          from = list.shift.join
+        when 'by'
+          by = list.shift.join
+        when 'via'
+          via = list.shift.join
+        when 'with'
+          with = list.shift.join
+        when 'id'
+          id = list.shift.join
+        when 'for'
+          m = Mailbox.parse(list.shift)
+          for_ = m && m.address
+        end
+      end
+      self.new(from, by, via, with, id, for_, date)
+    end
+
+    attr_reader :from, :by, :via, :with, :id, :for, :date
+
+    # @param [String] from
+    # @param [String] by
+    # @param [String] via
+    # @param [String] with
+    # @param [String] id
+    # @param [Mailbox] for_
+    # @param [DateTime] date
+    def initialize(from, by, via, with, id, for_, date)
+      @from, @by, @via, @with, @id, @for, @date =
+        from, by, via, with, id, for_, date
+    end
+
+  end
+end

data/lib/internet_message/tokenizer.rb

@@ -0,0 +1,61 @@
+require 'strscan'
+
+class InternetMessage
+  class Tokenizer
+    TOKEN_RE = /[0-9a-zA-Z\!\#\$\%\'\*\+\-\/\=\?\^\_\`\{\|\}\~\.]+/n
+
+    def initialize(s, opt={})
+      @ss = StringScanner.new(s.gsub(/\r?\n/, ''))
+      @token_re = opt[:token_re] || TOKEN_RE
+    end
+
+    def tokenize(opt={})
+      ret = []
+      until @ss.eos?
+        case
+        when s = @ss.scan(/[ \t]+/)
+          ret.push Token.new(:WSP, s) unless opt[:skip_wsp]
+        when s = @ss.scan(@token_re)
+          ret.push Token.new(:TOKEN, s)
+        when s = @ss.scan(/\"(\\.|[^\"])+\"/)
+          ret.push Token.new(:QUOTED, s.gsub(/\A\"|\"\z/,'').gsub(/\\(.)/){$1})
+        when @ss.check(/\(/)
+          comment = scan_comment
+          ret.push Token.new(:COMMENT, comment) unless opt[:skip_comment]
+        else
+          ret.push Token.new(:CHAR, @ss.scan(/./))
+        end
+      end
+      ret
+    end
+
+    def tokenize2
+      tokenize(:skip_wsp=>true, :skip_comment=>true)
+    end
+
+    def scan_comment
+      ret = []
+      @ss.scan(/\(/) or return ret
+      until @ss.scan(/\)/) or @ss.eos?
+        s = @ss.scan(/(\\.|[^\\\(\)])*/) and ret.push s.gsub(/\\(.)/){$1}
+        @ss.check(/\(/) and ret.push scan_comment
+      end
+      ret
+    end
+  end
+
+  class Token
+    attr_reader :type, :value
+
+    def initialize(type, value)
+      @type, @value = type, value
+    end
+
+    alias to_s value
+
+    def ==(other)
+      other.is_a?(self.class) && other.type == self.type && other.value == self.value
+    end
+  end
+
+end