+++ /dev/null
-#--
-# 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
- 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.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, 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
projects / feedcatcher.git / blobdiff