smail-mime 0.0.6

data/lib/smail/mime/coding_extensions.rb

@@ -0,0 +1,192 @@
+#require 'jcode'
+require 'iconv'
+
+# Extensions to the String library for encoding and decoding of MIME data.
+class String
+
+  # Returns true if the string consists entirely of whitespace.
+  # (The empty string will return false.)
+  def is_space?
+    return Regexp.new('\A\s+\Z', Regexp::MULTILINE).match(self) != nil
+  end
+
+  # Returns true if the string contains only valid ASCII characters
+  # (i.e. nothing over ASCII 127).
+  def is_ascii?
+      self.length == self.tr("\200-\377", '').length
+  end
+    
+  # Returns this string encoded as base64 as defined in RFC2045, section 6.8.
+  def encode_base64
+    [self].pack("m*")
+  end
+
+  # Performs encode_base64 in place, and returns the string.
+  def encode_base64!
+    self.replace(self.encode_base64)
+  end
+  
+  # Returns this string decoded from base64 as defined in RFC2045, section 6.8.
+  def decode_base64
+    #self.unpack("m*").first
+    # This should be the above line but due to a bug in the ruby base64 decoder
+    # it will only decode base64 where the lines are in multiples of 4, this is
+    # contrary to RFC2045 which says that all characters other than the 65 used
+    # are to be ignored. Currently we remove all the other characters but it 
+    # might be better to use it's advice to only remove line breaks and white
+    # space
+    self.tr("^A-Za-z0-9+/=", "").unpack("m*").first
+  end
+
+  # Performs decode_base64 in place, and returns the string.
+  def decode_base64!
+    self.replace(self.decode_base64)
+  end
+
+  # Returns this string encoded as quoted-printable as defined in RFC2045, section 6.7.
+  def encode_quoted_printable
+    result = [self].pack("M*")
+    # Ruby's quoted printable encoding uses soft line breaks to buffer spaces
+    # at the end of lines, rather than encoding them with =20. We fix this.
+    result.gsub!(/( +)=\n\n/) { "=20" * $1.length + "\n" }
+    # Ruby's quoted printable encode puts a soft line break on the end of any
+    # string that doesn't already end in a hard line break, so we have to
+    # clean it up.
+    result.gsub!(/=\n\Z/, '')
+    result
+  end
+
+  # Performs encode_quoted_printable in place, and returns the string.
+  def encode_quoted_printable!
+    self.replace(self.encode_quoted_printable)
+  end
+  
+  # Returns this string decoded from quoted-printable as defined in RFC2045, section 6.7.
+  def decode_quoted_printable
+    self.unpack("M*").first
+  end
+  
+  # Performs decode_quoted_printable in place, and returns the string.
+  def decode_quoted_printable!
+    self.replace(self.decode_quoted_printable)
+  end
+  
+  # Guesses whether this string is encoded in base64 or quoted-printable.
+  #
+  # Returns either :base64 or :quoted_printable
+  def guess_mime_encoding
+    # Grab the first line and have a guess?
+    # A multiple of 4 and no characters that aren't in base64 ?
+    # Need to allow for = at end of base64 string
+    squashed = self.tr("\r\n\s", '').strip.sub(/=*\Z/, '')
+    if squashed.length.remainder(4) == 0 && squashed.count("^A-Za-z0-9+/") == 0
+        :base64
+    else
+        :quoted_printable
+    end
+    # or should we just try both and see what works?
+  end
+  
+  # Returns the MIME encoding that is likely to produce the shortest
+  # encoded string, either :none, :base64, or :quoted_printable.
+  def best_mime_encoding
+    if self.is_ascii?
+      :none
+    elsif self.length > (self.mb_chars.length * 1.1)
+      :base64
+    else
+      :quoted_printable
+    end
+  end
+  
+  # Decodes this string according to method, where method is
+  # :base64, :quoted_printable, or :none.
+  #
+  # If method is not supplied or is nil, guess_mime_encoding is used to
+  # try to pick an appropriate method.
+  #
+  # Method can also be a string: 'q', 'quoted-printable', 'b', or 'base64'
+  # This lets you pass in methods directly from Content-Transfer-Encoding
+  # headers, or from RFC2047 words. Matching is case-insensitive.
+  def decode_mime(method = nil)
+    method ||= guess_mime_encoding
+    method = method.downcase if method.kind_of?(String)
+    case method
+      when :none
+        self
+      when :base64, 'b', 'base64'
+        self.decode_base64
+      when :quoted_printable, 'q', 'quoted-printable'
+        self.decode_quoted_printable
+      else
+        raise ArgumentError, "Bad MIME encoding"
+    end
+  end
+  
+  # Performs decode_mime in place, and returns the string.
+  def decode_mime!(method = nil)
+    self.replace(self.decode_mime(method))
+  end
+
+  # Converts this string to to_charset from from_charset using Iconv.
+  #
+  # Because there are cases where charsets are encoded incorrectly on the 'net
+  # we also allow for them and attempt to fix them up here. If conversion
+  # ultimately fails we remove all characters 0x80 and above, replacing them
+  # with ! symbols and effectively making it a US-ASCII (and therefore UTF-8)
+  # string.
+  def iconv(to_charset, from_charset)
+    failed = false
+    begin
+      converted = Iconv.new(to_charset, from_charset).iconv(self)
+    rescue Iconv::IllegalSequence
+      case from_charset.downcase
+        when 'us-ascii'
+          # Some mailers do not send a charset when it should be CP1252,
+          # the default Windows Latin charset
+          begin
+            converted = Iconv.new(to_charset, 'cp1252').iconv(self)
+          rescue Iconv::IllegalSequence
+            failed = true
+          end
+        when 'ks_c_5601-1987'
+          # Microsoft products erroneously use this for what should be CP949
+          # see http://tagunov.tripod.com/cjk.html
+          begin
+            converted = Iconv.new(to_charset, 'cp949').iconv(self)
+          rescue Iconv::IllegalSequence, Iconv::InvalidCharacter
+            failed = true
+          end
+        else
+          failed = true
+      end
+    rescue Iconv::InvalidCharacter
+      if self =~ /\n$/
+        # Some messages can come in with a superfluous new line on the end,
+        # which screws up the encoding. (ISO-2022-JP for example.)
+        begin
+          converted = Iconv.new(to_charset, 'iso-2022-jp').iconv(self.chomp) + "\n"
+        rescue Iconv::InvalidCharacter
+          converted = self.tr("\200-\377", "\041")
+        end
+      else
+        converted = self.tr("\200-\377", "\041")
+      end
+    end
+
+    if failed
+      begin
+        converted = Iconv.new(to_charset + '//IGNORE', from_charset).iconv(self)
+      rescue Iconv::InvalidCharacter
+        converted = self.tr("\200-\377", "\041")
+      end
+    end
+
+    converted
+  end
+
+  def iconv!(to_charset, from_charset)
+    self.replace(self.iconv(to_charset, from_charset))
+  end
+
+end

data/lib/smail/mime/content_fields.rb

@@ -0,0 +1,189 @@
+class SMail #:nodoc:
+  class MIME < SMail
+    class ContentField
+      class << self
+      end
+
+      attr_accessor :type_raw # The raw type as parsed from the message.
+      attr_reader :params
+
+      def initialize(text = nil)
+        @params = Params.new
+        unless text.nil?
+          (@type_raw, params_raw) = SMail::MIME.decode_content_field(text)
+          @params.replace(params_raw)
+        end
+      end
+
+      # Returns the type as a lower case string
+      def type
+        @type_raw.nil? ? @type_raw : @type_raw.downcase
+      end
+
+      def type=(text)
+        @type_raw = text
+      end
+
+      # Returns the Content Field as a string suitable for inclusion in an email header.
+      def to_s
+        "#{@type_raw}#{self.params.to_s}"
+      end
+
+      class Params < Hash
+        class << self
+          # FIXME: These two should probably be moved
+          def needs_quoting?(text)
+            false # FIXME
+          end
+
+          def quote(text)
+            "\"#{text}\"" # FIXME
+          end
+        end
+
+        def to_s
+          if self.empty?
+            return ""
+          else
+            pairs = []
+            self.each do |key, value|
+              pair = key + '='
+              if SMail::MIME::ContentField::Params.needs_quoting?(value)
+                pair << SMail::MIME::ContentField::Params.quote(value)
+              else
+                pair << value
+              end
+              pairs << pair
+            end
+          end
+          '; ' + pairs.join('; ')
+        end
+      end
+    end # ContentField
+
+    # An object representing a Content-Disposition header as specified in RFC2183.
+    class ContentDisposition < ContentField
+
+      # Is this an inline part??
+      def inline?
+        type == 'inline'
+      end
+
+      # Is this an attachment part?
+      def attachment?
+        type == "attachment"
+      end
+
+      # Returns the filename if specified
+      def filename
+        self.params['filename']
+      end
+
+      # Returns the creation date if available or nil.
+      def creation_date
+        self.params['creation-date'] # FIXME: parse as a date?
+      end
+
+      # Returns the modification date if available or nil.
+      def modification_date
+        self.params['modification-date'] # FIXME: parse as a date?
+      end
+
+      # Returns the read date if available or nil.
+      def read_date
+        self.params['read-date'] # FIXME: parse as a date?
+      end
+
+      # Returns the size if available or nil.
+      def size
+        self.params['size']
+      end
+
+      # FIXME: add all the other parameters specified in RFC2183, also add setters
+
+      # Returns the Content-Disposition as a string suitable for inclusion in an email
+      # header. If no disposition type is specified it will default to a disposition
+      # type of 'attachment'.
+      def to_s
+        "#{self.type_raw || 'attachment'}#{self.params.to_s}"
+      end
+
+    end # ContentDisposition
+
+    class ContentType < ContentField
+
+      attr_accessor :media_type_raw, :media_subtype_raw
+
+      def initialize(text = nil)
+        super(text)
+        self.type = @type_raw
+      end
+
+      # Returns the media type
+      def media_type
+        @media_type_raw.nil? ? @media_type_raw : @media_type_raw.downcase
+      end
+
+      # Set the media type
+      def media_type=(text)
+        @media_type_raw = text
+      end
+
+      # Returns the media subtype
+      def media_subtype
+        @media_subtype.nil? ? @media_subtype_raw : @media_subtype_raw.downcase
+      end
+
+      # Set the media subtype
+      def media_subtype=(text)
+        @media_subtype_raw = text
+      end
+
+      # Returns the media 'type/subtype' as a lower case string.
+      def type
+        # Default to 'text/plain'
+        if @media_type_raw.nil? or @media_subtype_raw.nil?
+          'text/plain'
+        else
+          "#{@media_type_raw}/#{@media_subtype_raw}".downcase
+        end
+      end
+
+      # Set the media 'type/subtype' together
+      def type=(text = nil)
+        unless text.nil?
+          @type_raw = text # keep this inherited accessor in sync
+          (@media_type_raw, @media_subtype_raw) = text.split('/', 2)
+        end
+      end
+
+      # Is this a composite media type as specified in section 5.1 of RFC 2045.
+      #
+      # Note extension tokens are permitted to be composite but will always be seen
+      # as discrete by this code.
+      def composite?
+        media_type == 'message' or media_type == 'multipart'
+      end
+
+      # Is this a discrete media type as specified in section 5.1 of RFC 2045.
+      #
+      # Note extension tokens are permitted to be composite but will always be seen
+      # as discrete by this code.
+      def discrete?
+        !composite?
+      end
+
+      # Returns the full Content-Type header as a string suitable for inclusion in an
+      # email header. If either of the media type or subtype are not specified it will
+      # default to 'text/plain; charset=us-ascii'.
+      def to_s
+        # Default to 'text/plain; charset=us-ascii'
+        if @media_type_raw.nil? or @media_subtype_raw.nil?
+          'text/plain; charset=us-ascii'
+        else
+          "#{@media_type_raw}/#{@media_subtype_raw}#{self.params.to_s}"
+        end
+      end
+    end # ContentType
+  end
+end

data/lib/smail/mime/date.rb

@@ -0,0 +1,13 @@
+class SMail #:nodoc:
+  class MIME < SMail
+    # We inherit from DateTime in order to make its to_s method return an RFC2822
+    # compliant date string.
+    class Date < DateTime
+      # Return an RFC2822 compliant date string suitable for use in the Date header.
+      def to_s
+        # This should meet RFC2822 requirements
+        self.strftime('%a, %e %b %Y %H:%M:%S %z').gsub(/\s+/, ' ')
+      end
+    end
+  end
+end

data/lib/smail/mime/header.rb

@@ -0,0 +1,190 @@
+require 'strscan'
+
+class SMail #:nodoc:
+  class MIME < SMail
+
+    PATTERN_RFC2047_FIELD = '(.*?)(=\?(?:[^?]+)\?(?:.)\?(?:[^?]*)\?=)(.*)'
+
+    class << self
+      # Parses a Content-* header and returns the bits.
+      #
+      # Given the contents of a header field such as
+      #
+      #   text/plain; charset=US-ASCII
+      #
+      # this will return:
+      #
+      #   [ 'text', 'plain', { 'charset' => 'US-ASCII' } ]
+      #
+      # The type and the keys of the hash are all converted to lower case.
+      #
+      # This parses Content-Type and Content-Disposition headers according to
+      # the description of the Content-Type header in section 5.1 of RFC2045.
+      #
+      # It also handles continuations and character sets in parameter values
+      # as described in sections 3 and 4 of RFC2231.
+      def decode_content_field(text)
+        s = StringScanner.new(text)
+
+        type = s.scan(/[^;]*/)
+        s.skip(/;\s*/)
+
+        params   = {}
+        charsets = {}
+        while key = s.scan(/[^=]+/)
+          s.skip(/=/)
+          if s.skip(/"/)
+            # Deal with quoted parameters.
+            value = s.scan(/(\\.|[^"])*/)
+            s.skip(/"/)
+            value.gsub!(/\\(.)/, '\1')
+          else
+            value = s.scan(/[^;\s]+/)
+          end
+
+          is_encoded = false
+          if key =~ /^(.*)\*$/
+            key = $1
+            is_encoded = true
+          end
+
+          is_continued = false
+          if key =~ /^(.*)\*[0-9]+$/
+            key = $1
+            is_continued = true
+          end
+
+          if is_encoded
+            # Deal with character sets and languages.
+            if value =~ /^([^']*)'([^']*)'(.*)$/
+              charsets[key] = ($1 or 'US-ASCII')
+              value = $3
+            end
+            value.gsub!(/%([[:xdigit:]]{2})/) { $1.hex.chr }
+            value.iconv!(charsets[key], 'UTF-8')
+          end
+
+          if is_continued and params[key]
+            # Deal with parameter continuations.
+            params[key] << value
+          else
+            params[key] = value
+          end
+
+          s.skip(/\s*;?\s*/) # skip any whitespace before and after a semicolon
+        end
+
+        # Some mail clients (I'm looking at you Becky!) don't use RFC2231 parameter
+        # value character set information but instead encode the parameters as
+        # RFC2047 fields, so lets cycle through them and try to decode, this should
+        # not do any harm if they don't have encoded fields
+        params.each_key {|key|
+          params[key] = self.decode_field(params[key])
+        }
+
+        [type, params]
+      end
+
+      # Decodes any RFC2047 words in a string and returns the string as UTF-8.
+      # Uses our iconv to deal with common encoding problems
+      def decode_field(text)
+        return nil if text.nil?
+        result = ''
+        while text =~ Regexp.new(PATTERN_RFC2047_FIELD, Regexp::MULTILINE)
+          prefix, encoded, text = $1, $2, $3
+          result << prefix unless prefix =~ Regexp.new('\A\s*\Z', Regexp::MULTILINE)
+          result << decode_word(encoded)
+        end
+        result << text
+        result
+      end
+
+      # Decodes an RFC2047 word to a UTF-8 string.
+      # Uses our iconv to deal with common encoding problems
+      def decode_word(text)
+        return text unless text =~ /=\?([^?]+)\?(.)\?([^?]*)\?=/
+          
+        charset, method, encoded_string = $1, $2, $3
+          
+        # Strip out the RFC2231 language specification if there is one.
+        charset  = $1 if charset =~ /^([^\*]+)\*?(.*)$/
+            
+        # Quoted-printable in RFC2047 substitutes spaces with underscores.
+        encoded_string.tr!('_', ' ') if method.downcase == 'q'
+        
+        encoded_string.decode_mime(method).iconv('utf-8', charset)
+      end
+
+      # Takes the given UTF-8 string, converts it the given character set, and
+      # encodes it as an RFC2047 style field.
+      #
+      # All arguments after text are optional. If a method is not supplied,
+      # the String.best_mime_encoding method is used to pick one. The charset
+      # defaults to UTF-8, and the line length to 66 characters.
+      def encode_field(text, method = nil, charset = 'UTF-8', line_length = 66)
+        return '' if text.nil?
+        method ||= text.best_mime_encoding
+        method = method.downcase if method.kind_of?(String)
+        case method
+          when :none
+            text
+          when :base64, 'b', 'base64'
+            encode_base64_field(text, charset, line_length)
+          when :quoted_printable, 'q', 'quoted-printable'
+            encode_quoted_printable_field(text, charset, line_length)
+          else
+            raise ArgumentError, "Bad MIME encoding"
+        end
+      end
+
+      def encode_quoted_printable_field(text, charset = 'UTF-8', line_length = 66) #:nodoc:
+        charset.upcase!
+        encoded_line_length = line_length - (charset.length + 7)
+  
+        iconv        = Iconv.new(charset, 'UTF-8')
+        encoded_text = ''
+        word         = ''
+        text.each_char do |char|
+          char = iconv.iconv(char)
+          # RFC2047 has its own ideas about quoted-printable encoding.
+          char.encode_quoted_printable!
+          char = case char
+            when "_":  "=5F"
+            when " ":  "_"
+            when "?":  "=3F"
+            when "\t": "=09"
+            else char
+          end
+          if word.length + char.length > encoded_line_length
+            encoded_text << "=?#{charset}?Q?#{word}?=\n "
+            word = ''
+          end
+          word << char
+        end
+        encoded_text << "=?#{charset}?Q?#{word}?="
+        encoded_text
+      end
+
+      def encode_base64_field(text, charset = 'UTF-8', line_length = 66) #:nodoc:
+        charset.upcase!
+        unencoded_line_length = (line_length - (charset.length + 7)) / 4 * 3
+  
+        iconv        = Iconv.new(charset, 'UTF-8')
+        encoded_text = ''
+        word         = ''
+        text.each_char do |char|
+          char = iconv.iconv(char)
+          if word.length + char.length > unencoded_line_length
+            encoded_text << "=?#{charset}?B?#{word.encode_base64.chomp}?=\n "
+            word = ''
+          end
+          word << char
+        end
+        encoded_text << "=?#{charset}?B?#{word.encode_base64.chomp}?="
+        encoded_text
+      end
+
+    end # self
+  end
+          
+end

data/lib/smail/mime/mime.rb

@@ -0,0 +1,257 @@
+class SMail
+  class MIME < SMail
+    class << self
+    end
+
+    attr_accessor :parts, :preamble, :epilogue
+    attr_reader :content_type, :boundary
+
+    def initialize(text = '')
+      super(text)
+      self.content_type = self.header('content-type')
+      fill_parts
+    end
+
+    # Returns the size of the message in bytes.
+    def size
+      self.to_s.length
+    end
+
+    # Sets the content type
+    def content_type=(content_type)
+      case content_type
+        when SMail::MIME::ContentType
+          @content_type = content_type
+        when String
+          self.content_type = SMail::MIME::ContentType.new(content_type)
+        when nil
+          self.content_type = SMail::MIME::ContentType.new
+        else
+          raise ArgumentError
+      end
+    end
+
+    # Is this a multipart message
+    def multipart?
+      @content_type.composite?
+    end
+
+    # Returns the MIME-Version as a string (unlikely to be anything but '1.0')
+    def version
+      self.header('mime-version') || '1.0'
+    end
+
+    # Returns the subject in UTF-8
+    def subject
+      SMail::MIME.decode_field(subject_raw)
+    end
+
+    # Sets the subject, performs any necessary encoding
+    def subject=(text)
+      self.subject_raw = SMail::MIME.encode_field(text)
+    end
+
+    # Returns the raw potentially MIME encoded subject
+    def subject_raw
+      self.header('subject')
+    end
+
+    # Set the subject directly, any necessary MIME encoding is up to the caller
+    def subject_raw=(text)
+      self.header_set('subject', text)
+    end
+
+    # Returns the date from the Date header as a DateTime object.
+    def date
+      date = self.header('date')
+      return nil unless date
+      SMail::MIME::Date.parse(date)
+      #(year, month, day, hour, minute, second, timezone, weekday) = ParseDate.parsedate(date)
+      #Time.gm(second, minute, hour, day, month, year, weekday, nil, nil, timezone)
+    end
+
+
+    # Returns the raw body of the email including all parts
+    alias body_raw body
+
+    # Returns the body decoded and converted to UTF-8 if necessary, if this is is a 
+    # multipart message this is not what you suspect
+    def body
+      if self.multipart? # what if it is message/rfc822 ?
+        @preamble 
+      else
+        # decode
+        case self.header('content-transfer-encoding')
+          when 'quoted-printable'
+            body = @body.decode_quoted_printable
+          when 'base64'
+            body = @body.decode_base64
+          else
+            # matches nil when there is no header or an unrecognised encoding
+            body = @body
+        end
+        
+        # convert to UTF-8 if text
+        if self.content_type.media_type == 'text'
+          charset = self.content_type.params['charset'] || 'us-ascii'
+          body.iconv!('utf-8', charset)
+        end
+
+        body
+      end
+    end
+
+    # Returns a string description of the MIME structure of this message.
+    #
+    # This is useful for debugging and testing. The returned string is
+    # formatted as shown in the following example:
+    #   multipart/mixed
+    #     multipart/alternative
+    #       text/plain
+    #       multipart/related
+    #         text/html
+    #         image/gif
+    #     application/octet-stream
+    def describe_mime_structure(depth = 0)
+      result = ('  '*depth) + self.content_type.type + "\n"
+      if self.multipart?
+        self.parts.each do |part|
+          result << part.describe_mime_structure(depth+1)
+        end
+      end
+      result.chomp! if depth == 0
+      result
+    end
+
+    # Pulls out any body parts matching the given MIME types and puts them
+    # into an array.
+    #
+    # This is useful for pulling out parts in the appropriate order for
+    # rendering. For example calling:
+    #   message.flatten_body('text/plain', /^application\/.*$)
+    # should return all the text parts and attached files in the order in
+    # which they appear in the original message.
+    #
+    # The various multipart subtypes are handled sensibly. For example,
+    # for multipart/alternative messages, the best matching part (i.e. the
+    # last part consisting entirely of the given types) is used.
+    def flatten_body(*types)
+      types = types.flatten
+      if self.multipart?
+        case self.content_type.type
+          when 'multipart/alternative'
+            part = self.parts.reverse.find {|part| part.consists_of_mime_types?(types) }
+            part ? part.flatten_body(types) : []
+          when 'multipart/mixed', 'multipart/related'
+            # FIXME: For multipart/related, this should look for a start parameter and try that first.    
+            parts = self.parts.collect {|part| part.flatten_body(types) }
+            parts.flatten
+          when 'multipart/signed'
+            self.parts.first.flatten_body(types)
+          when 'multipart/appledouble'
+            self.parts[1].flatten_body(types)
+          else
+            # FIXME: should we also have an entry for message/rfc822 etc.
+            []
+        end
+      else
+        self.consists_of_mime_types?(types) ? [self] : []
+      end
+    end
+
+    # Returns true if the message consists entirely of the given mime types.
+    #
+    # For single part messages this is simple: the Content-Type of the
+    # message must by one of the supplied types.
+    #
+    # For multipart messages it gets a bit more complicated. We try to
+    # make sure that the message can be entirely decomposed into
+    # just the supplied types.
+    #
+    # The rules are as follows:
+    # [multipart/alternative]
+    #   At least one sub-part must consist of the given types. 
+    # [multipart/mixed]
+    #   All sub-parts must consist of the given types.
+    # [multipart/related]
+    #   The root part (usually the first part) must consist of the
+    #   given types.
+    # [multipart/signed]
+    #   The first part must consist of the given types.
+    # [multipart/appledouble]
+    #   The second part must consist of the given types. (See RFC 1740.)
+    def consists_of_mime_types?(*types)
+      types = types.flatten
+      type = self.content_type.type
+
+      if self.multipart?
+        case type
+          when 'multipart/alternative'
+            self.parts.any? {|part| part.consists_of_mime_types?(types) }
+          when 'multipart/mixed'
+            self.parts.all? {|part| part.consists_of_mime_types?(types) }
+          when 'multipart/related'
+            # FIXME: This should look for a start parameter and try that first.
+            self.parts.first.consists_of_mime_types?(types)
+          when 'multipart/signed'
+            self.parts.first.consists_of_mime_types?(types)
+          when 'multipart/appledouble'
+            self.parts[1].consists_of_mime_types?(types)
+          when 'message/rfc822', 'message/rfc2822'
+            self.parts.first.consists_of_mime_types?(types)
+          else
+            false
+        end
+      else
+        types.any? {|t| t === type }
+      end
+    end
+
+
+
+private
+
+    def fill_parts
+      if self.content_type.discrete?
+        parts_single_part
+      else
+        parts_multipart
+      end
+    end
+
+    def parts_single_part
+      @parts = []
+    end
+
+    def parts_multipart
+      @parts = []
+      @boundary = self.content_type.params['boundary']
+
+      if self.content_type.type == 'message/rfc822' or self.content_type.type == 'message/rfc2822'
+        @parts << SMail::MIME.new(@body)
+        return @parts
+      end
+
+      return parts_single_part unless @boundary
+
+      #alias body_raw body # FIXME: does this work?
+
+      epilogue_re = Regexp.new("^--#{Regexp.escape(@boundary)}--\s*\r?$", Regexp::MULTILINE)
+      (body, @epilogue) = @body.split(epilogue_re, 2)
+      @epilogue.lstrip! unless @epilogue.nil?
+
+      bits_re = Regexp.new("^--#{Regexp.escape(@boundary)}\s*\r?$", Regexp::MULTILINE)
+      bits = body.split(bits_re)
+
+      @preamble = bits.shift # FIXME is this OK? or better to see a header in the first line?
+
+      bits.each do |bit|
+        bit.lstrip!
+        @parts << SMail::MIME.new(bit)
+      end
+        
+      @parts
+    end
+
+  end
+end

data/lib/smail/mime/version.rb

@@ -0,0 +1,11 @@
+class SMail
+  class MIME
+    module VERSION #:nodoc:
+      MAJOR = 0
+      MINOR = 0
+      TINY  = 5
+
+      STRING = [MAJOR, MINOR, TINY].join('.')
+    end
+  end
+end

data/lib/smail/mime.rb

@@ -0,0 +1,4 @@
+require 'smail'
+require 'active_support'
+
+Dir[File.join(File.dirname(__FILE__), 'mime/**/*.rb')].sort.each { |lib| require lib }

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification 
+name: smail-mime
+version: !ruby/object:Gem::Version 
+  version: 0.0.6
+platform: ruby
+authors: 
+- Matthew Walker
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-17 00:00:00 +11:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: smail
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.0.5
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.5
+    version: 
+description: 
+email: matthew@walker.wattle.id.au
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/smail/mime.rb
+- lib/smail/mime/coding_extensions.rb
+- lib/smail/mime/content_fields.rb
+- lib/smail/mime/date.rb
+- lib/smail/mime/header.rb
+- lib/smail/mime/mime.rb
+- lib/smail/mime/version.rb
+has_rdoc: true
+homepage: http://github.com/mwalker/smail-mime
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A simple MIME email parser
+test_files: []
+