Redmine

#--

# Copyright (c) 1998-2003 Minero Aoki <aamine@loveruby.net>

#

# Permission is hereby granted, free of charge, to any person obtaining

# a copy of this software and associated documentation files (the

# "Software"), to deal in the Software without restriction, including

# without limitation the rights to use, copy, modify, merge, publish,

# distribute, sublicense, and/or sell copies of the Software, and to

# permit persons to whom the Software is furnished to do so, subject to

# the following conditions:

#

# The above copyright notice and this permission notice shall be

# included in all copies or substantial portions of the Software.

#

# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE

# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

#

# Note: Originally licensed under LGPL v2+. Using MIT license for Rails

# with permission of Minero Aoki.

#++

require 'tmail/encode'

require 'tmail/address'

require 'tmail/parser'

require 'tmail/config'

require 'tmail/utils'

#:startdoc:

module TMail

  # Provides methods to handle and manipulate headers in the email

  class HeaderField

    include TextUtils

    class << self

      alias newobj new

      def new( name, body, conf = DEFAULT_CONFIG )

        klass = FNAME_TO_CLASS[name.downcase] || UnstructuredHeader

        klass.newobj body, conf

      end

      # Returns a HeaderField object matching the header you specify in the "name" param.

      # Requires an initialized TMail::Port to be passed in.

      #

      # The method searches the header of the Port you pass into it to find a match on

      # the header line you pass.  Once a match is found, it will unwrap the matching line

      # as needed to return an initialized HeaderField object.

      #

      # If you want to get the Envelope sender of the email object, pass in "EnvelopeSender",

      # if you want the From address of the email itself, pass in 'From'.

      #

      # This is because a mailbox doesn't have the : after the From that designates the

      # beginning of the envelope sender (which can be different to the from address of 

      # the email)

      #

      # Other fields can be passed as normal, "Reply-To", "Received" etc.

      #

      # Note: Change of behaviour in 1.2.1 => returns nil if it does not find the specified

      # header field, otherwise returns an instantiated object of the correct header class

      # 

      # For example:

      #   port = TMail::FilePort.new("/test/fixtures/raw_email_simple")

      #   h = TMail::HeaderField.new_from_port(port, "From")

      #   h.addrs.to_s #=> "Mikel Lindsaar <mikel@nowhere.com>"

      #   h = TMail::HeaderField.new_from_port(port, "EvelopeSender")

      #   h.addrs.to_s #=> "mike@anotherplace.com.au"

      #   h = TMail::HeaderField.new_from_port(port, "SomeWeirdHeaderField")

      #   h #=> nil

      def new_from_port( port, name, conf = DEFAULT_CONFIG )

        if name == "EnvelopeSender"

          name = "From"

          re = Regexp.new('\A(From) ', 'i')

        else

          re = Regexp.new('\A(' + Regexp.quote(name) + '):', 'i')

        end

        str = nil

        port.ropen {|f|

            f.each do |line|

              if m = re.match(line)            then str = m.post_match.strip

              elsif str and /\A[\t ]/ === line then str << ' ' << line.strip

              elsif /\A-*\s*\z/ === line       then break

              elsif str                        then break

              end

            end

        }

        new(name, str, Config.to_config(conf)) if str

      end

      def internal_new( name, conf )

        FNAME_TO_CLASS[name].newobj('', conf, true)

      end

    end   # class << self

    def initialize( body, conf, intern = false )

      @body = body

      @config = conf

      @illegal = false

      @parsed = false

      if intern

        @parsed = true

        parse_init

      end

    end

    def inspect

      "#<#{self.class} #{@body.inspect}>"

    end

    def illegal?

      @illegal

    end

    def empty?

      ensure_parsed

      return true if @illegal

      isempty?

    end

    private

    def ensure_parsed

      return if @parsed

      @parsed = true

      parse

    end

    # defabstract parse

    # end

    def clear_parse_status

      @parsed = false

      @illegal = false

    end

    public

    def body

      ensure_parsed

      v = Decoder.new(s = '')

      do_accept v

      v.terminate

      s

    end

    def body=( str )

      @body = str

      clear_parse_status

    end

    include StrategyInterface

    def accept( strategy )

      ensure_parsed

      do_accept strategy

      strategy.terminate

    end

    # abstract do_accept

  end

  class UnstructuredHeader < HeaderField

    def body

      ensure_parsed

      @body

    end

    def body=( arg )

      ensure_parsed

      @body = arg

    end

    private

    def parse_init

    end

    def parse

      @body = Decoder.decode(@body.gsub(/\n|\r\n|\r/, ''))

    end

    def isempty?

      not @body

    end

    def do_accept( strategy )

      strategy.text @body

    end

  end

  class StructuredHeader < HeaderField

    def comments

      ensure_parsed

      if @comments[0]

        [Decoder.decode(@comments[0])]

      else

        @comments

      end

    end

    private

    def parse

      save = nil

      begin

        parse_init

        do_parse

      rescue SyntaxError

        if not save and mime_encoded? @body

          save = @body

          @body = Decoder.decode(save)

          retry

        elsif save

          @body = save

        end

        @illegal = true

        raise if @config.strict_parse?

      end

    end

    def parse_init

      @comments = []

      init

    end

    def do_parse

      quote_boundary

      quote_unquoted_name

      quote_unquoted_bencode

      obj = Parser.parse(self.class::PARSE_TYPE, @body, @comments)

      set obj if obj

    end

  end

  class DateTimeHeader < StructuredHeader

    PARSE_TYPE = :DATETIME

    def date

      ensure_parsed

      @date

    end

    def date=( arg )

      ensure_parsed

      @date = arg

    end

    private

    def init

      @date = nil

    end

    def set( t )

      @date = t

    end

    def isempty?

      not @date

    end

    def do_accept( strategy )

      strategy.meta time2str(@date)

    end

  end

  class AddressHeader < StructuredHeader

    PARSE_TYPE = :MADDRESS

    def addrs

      ensure_parsed

      @addrs

    end

    private

    def init

      @addrs = []

    end

    def set( a )

      @addrs = a

    end

    def isempty?

      @addrs.empty?

    end

    def do_accept( strategy )

      first = true

      @addrs.each do |a|

        if first

          first = false

        else

          strategy.meta ',' #strategy.puts_meta ','

          strategy.space

        end

        a.accept strategy

      end

      @comments.each do |c|

        strategy.space

        strategy.meta '('

        strategy.text c

        strategy.meta ')'

      end

    end

  end

  class ReturnPathHeader < AddressHeader

    PARSE_TYPE = :RETPATH

    def addr

      addrs()[0]

    end

    def spec

      a = addr() or return nil

      a.spec

    end

    def routes

      a = addr() or return nil

      a.routes

    end

    private

    def do_accept( strategy )

      a = addr()

      strategy.meta '<'

      unless a.routes.empty?

        strategy.meta a.routes.map {|i| '@' + i }.join(',')

        strategy.meta ':'

      end

      spec = a.spec

      strategy.meta spec if spec

      strategy.meta '>'

    end

  end

  class SingleAddressHeader < AddressHeader

    def addr

      addrs()[0]

    end

    private

    def do_accept( strategy )

      a = addr()

      a.accept strategy

      @comments.each do |c|

        strategy.space

        strategy.meta '('

        strategy.text c

        strategy.meta ')'

      end

    end

  end

  class MessageIdHeader < StructuredHeader

    def id

      ensure_parsed

      @id

    end

    def id=( arg )

      ensure_parsed

      @id = arg

    end

    private

    def init

      @id = nil

    end

    def isempty?

      not @id

    end

    def do_parse

      @id = @body.slice(MESSAGE_ID) or

              raise SyntaxError, "wrong Message-ID format: #{@body}"

    end

    def do_accept( strategy )

      strategy.meta @id

    end

  end

  class ReferencesHeader < StructuredHeader

    def refs

      ensure_parsed

      @refs

    end

    def each_id

      self.refs.each do |i|

        yield i if MESSAGE_ID === i

      end

    end

    def ids

      ensure_parsed

      @ids

    end

    def each_phrase

      self.refs.each do |i|

        yield i unless MESSAGE_ID === i

      end

    end

    def phrases

      ret = []

      each_phrase {|i| ret.push i }

      ret

    end

    private

    def init

      @refs = []

      @ids = []

    end

    def isempty?

      @ids.empty?

    end

    def do_parse

      str = @body

      while m = MESSAGE_ID.match(str)

        pre = m.pre_match.strip

        @refs.push pre unless pre.empty?

        @refs.push s = m[0]

        @ids.push s

        str = m.post_match

      end

      str = str.strip

      @refs.push str unless str.empty?

    end

    def do_accept( strategy )

      first = true

      @ids.each do |i|

        if first

          first = false

        else

          strategy.space

        end

        strategy.meta i

      end

    end

  end

  class ReceivedHeader < StructuredHeader

    PARSE_TYPE = :RECEIVED

    def from

      ensure_parsed

      @from

    end

    def from=( arg )

      ensure_parsed

      @from = arg

    end

    def by

      ensure_parsed

      @by

    end

    def by=( arg )

      ensure_parsed

      @by = arg

    end

    def via

      ensure_parsed

      @via

    end

    def via=( arg )

      ensure_parsed

      @via = arg

    end

    def with

      ensure_parsed

      @with

    end

    def id

      ensure_parsed

      @id

    end

    def id=( arg )

      ensure_parsed

      @id = arg

    end

    def _for

      ensure_parsed

      @_for

    end

    def _for=( arg )

      ensure_parsed

      @_for = arg

    end

    def date

      ensure_parsed

      @date

    end

    def date=( arg )

      ensure_parsed

      @date = arg

    end

    private

    def init

      @from = @by = @via = @with = @id = @_for = nil

      @with = []

      @date = nil

    end

    def set( args )

      @from, @by, @via, @with, @id, @_for, @date = *args

    end

    def isempty?

      @with.empty? and not (@from or @by or @via or @id or @_for or @date)

    end

    def do_accept( strategy )

      list = []

      list.push 'from '  + @from       if @from

      list.push 'by '    + @by         if @by

      list.push 'via '   + @via        if @via

      @with.each do |i|

        list.push 'with ' + i

      end

      list.push 'id '    + @id         if @id

      list.push 'for <'  + @_for + '>' if @_for

      first = true

      list.each do |i|

        strategy.space unless first

        strategy.meta i

        first = false

      end

      if @date

        strategy.meta ';'

        strategy.space

        strategy.meta time2str(@date)

      end

    end

  end

  class KeywordsHeader < StructuredHeader

    PARSE_TYPE = :KEYWORDS

    def keys

      ensure_parsed

      @keys

    end

    private

    def init

      @keys = []

    end

    def set( a )

      @keys = a

    end

    def isempty?

      @keys.empty?

    end

    def do_accept( strategy )

      first = true

      @keys.each do |i|

        if first

          first = false

        else

          strategy.meta ','

        end

        strategy.meta i

      end

    end

  end

  class EncryptedHeader < StructuredHeader

    PARSE_TYPE = :ENCRYPTED

    def encrypter

      ensure_parsed

      @encrypter

    end

    def encrypter=( arg )

      ensure_parsed

      @encrypter = arg

    end

    def keyword

      ensure_parsed

      @keyword

    end

    def keyword=( arg )

      ensure_parsed

      @keyword = arg

    end

    private

    def init

      @encrypter = nil

      @keyword = nil

    end

    def set( args )

      @encrypter, @keyword = args

    end

    def isempty?

      not (@encrypter or @keyword)

    end

    def do_accept( strategy )

      if @key

        strategy.meta @encrypter + ','

        strategy.space

        strategy.meta @keyword

      else

        strategy.meta @encrypter

      end

    end

  end

  class MimeVersionHeader < StructuredHeader

    PARSE_TYPE = :MIMEVERSION

    def major

      ensure_parsed

      @major

    end

    def major=( arg )

      ensure_parsed

      @major = arg

    end

    def minor

      ensure_parsed

      @minor

    end

    def minor=( arg )

      ensure_parsed

      @minor = arg

    end

    def version

      sprintf('%d.%d', major, minor)

    end

    private

    def init

      @major = nil

      @minor = nil

    end

    def set( args )

      @major, @minor = *args

    end

    def isempty?

      not (@major or @minor)

    end

    def do_accept( strategy )

      strategy.meta sprintf('%d.%d', @major, @minor)

    end

  end

  class ContentTypeHeader < StructuredHeader

    PARSE_TYPE = :CTYPE

    def main_type

      ensure_parsed

      @main

    end

    def main_type=( arg )

      ensure_parsed

      @main = arg.downcase

    end

    def sub_type

      ensure_parsed

      @sub

    end

    def sub_type=( arg )

      ensure_parsed

      @sub = arg.downcase

    end

    def content_type

      ensure_parsed

      @sub ? sprintf('%s/%s', @main, @sub) : @main

    end

    def params

      ensure_parsed

      unless @params.blank?

        @params.each do |k, v|

          @params[k] = unquote(v)

        end

      end

      @params

    end

    def []( key )

      ensure_parsed

      @params and unquote(@params[key])

    end

    def []=( key, val )

      ensure_parsed

      (@params ||= {})[key] = val

    end

    private

    def init

      @main = @sub = @params = nil

    end

    def set( args )

      @main, @sub, @params = *args

    end

    def isempty?

      not (@main or @sub)

    end

    def do_accept( strategy )

      if @sub

        strategy.meta sprintf('%s/%s', @main, @sub)

      else

        strategy.meta @main

      end

      @params.each do |k,v|

        if v

          strategy.meta ';'

          strategy.space

          strategy.kv_pair k, unquote(v)

        end

      end

    end

  end

  class ContentTransferEncodingHeader < StructuredHeader

    PARSE_TYPE = :CENCODING

    def encoding

      ensure_parsed

      @encoding

    end

    def encoding=( arg )

      ensure_parsed

      @encoding = arg

    end

    private

    def init

      @encoding = nil

    end

    def set( s )

      @encoding = s

    end

    def isempty?

      not @encoding

    end

    def do_accept( strategy )

      strategy.meta @encoding.capitalize

    end

  end

  class ContentDispositionHeader < StructuredHeader

    PARSE_TYPE = :CDISPOSITION

    def disposition

      ensure_parsed

      @disposition

    end

    def disposition=( str )

      ensure_parsed

      @disposition = str.downcase

    end

    def params

      ensure_parsed

      unless @params.blank?

        @params.each do |k, v|

          @params[k] = unquote(v)

        end

      end

      @params

    end

    def []( key )

      ensure_parsed

      @params and unquote(@params[key])

    end

    def []=( key, val )

      ensure_parsed

      (@params ||= {})[key] = val

    end

    private

    def init

      @disposition = @params = nil

    end

    def set( args )

      @disposition, @params = *args

    end

    def isempty?

      not @disposition and (not @params or @params.empty?)

    end

    def do_accept( strategy )

      strategy.meta @disposition

      @params.each do |k,v|

        strategy.meta ';'

        strategy.space

        strategy.kv_pair k, unquote(v)

      end

    end

  end

  class HeaderField   # redefine

    FNAME_TO_CLASS = {

      'date'                      => DateTimeHeader,

      'resent-date'               => DateTimeHeader,

      'to'                        => AddressHeader,

      'cc'                        => AddressHeader,

      'bcc'                       => AddressHeader,

      'from'                      => AddressHeader,

      'reply-to'                  => AddressHeader,

      'resent-to'                 => AddressHeader,

      'resent-cc'                 => AddressHeader,

      'resent-bcc'                => AddressHeader,

      'resent-from'               => AddressHeader,

      'resent-reply-to'           => AddressHeader,

      'sender'                    => SingleAddressHeader,

      'resent-sender'             => SingleAddressHeader,

      'return-path'               => ReturnPathHeader,

      'message-id'                => MessageIdHeader,

      'resent-message-id'         => MessageIdHeader,

      'in-reply-to'               => ReferencesHeader,

      'received'                  => ReceivedHeader,

      'references'                => ReferencesHeader,

      'keywords'                  => KeywordsHeader,

      'encrypted'                 => EncryptedHeader,

      'mime-version'              => MimeVersionHeader,

      'content-type'              => ContentTypeHeader,

      'content-transfer-encoding' => ContentTransferEncodingHeader,

      'content-disposition'       => ContentDispositionHeader,

      'content-id'                => MessageIdHeader,

      'subject'                   => UnstructuredHeader,

      'comments'                  => UnstructuredHeader,

      'content-description'       => UnstructuredHeader

    }

  end

end   # module TMail