mime 0.1

data/lib/mime/content_types.rb

@@ -0,0 +1,96 @@
+module MIME
+
+  #
+  # Handles MIME content type detection using file name extension.
+  #
+  # === See Also
+  #
+  # * http://w3schools.com/media/media_mimeref.asp for more content types
+  # * rubygem MIME::Types for extensive content type lookup
+  #
+  module ContentTypes
+
+    #
+    # Content types are in the form of <em>media-type/sub-type</em>. Each
+    # content type has one or more file extentions associated with it.
+    #
+    # The content types below are listed in alphabetical order and the
+    # extention arrays are in order of preference.
+    #
+    # The following content types were stolen from the NGiNX webserver. NGiNX
+    # is great server, check it out at http://nginx.net.
+    #
+    CONTENT_TYPES = {
+      'application/atom+xml'            => %w(atom),
+      'application/java-archive'        => %w(jar war ear),
+      'application/mac-binhex40'        => %w(hqx),
+      'application/msword'              => %w(doc),
+      'application/octet-stream'        => %w(bin exe dll deb dmg eot iso img msi msp msm),
+      'application/pdf'                 => %w(pdf),
+      'application/postscript'          => %w(ps eps ai),
+      'application/rtf'                 => %w(rtf),
+      'application/vnd.ms-excel'        => %w(xls),
+      'application/vnd.ms-powerpoint'   => %w(ppt),
+      'application/vnd.wap.wmlc'        => %w(wmlc),
+      'application/vnd.wap.xhtml+xml'   => %w(xhtml),
+      'application/x-cocoa'             => %w(cco),
+      'application/x-java-archive-diff' => %w(jardiff),
+      'application/x-java-jnlp-file'    => %w(jnlp),
+      'application/x-javascript'        => %w(js),
+      'application/x-makeself'          => %w(run),
+      'application/x-perl'              => %w(pl pm),
+      'application/x-pilot'             => %w(prc pdb),
+      'application/x-rar-compressed'    => %w(rar),
+      'application/x-redhat-package-manager' => %w(rpm),
+      'application/x-sea'               => %w(sea),
+      'application/x-shockwave-flash'   => %w(swf),
+      'application/x-stuffit'           => %w(sit),
+      'application/x-tcl'               => %w(tcl tk),
+      'application/x-x509-ca-cert'      => %w(crt pem der),
+      'application/x-xpinstall'         => %w(xpi),
+      'application/zip'                 => %w(zip),
+
+      'audio/midi'                      => %w(mid midi kar),
+      'audio/mpeg'                      => %w(mp3),
+      'audio/x-realaudio'               => %w(ra),
+
+      'image/gif'                       => %w(gif),
+      'image/jpeg'                      => %w(jpg jpeg),
+      'image/png'                       => %w(png),
+      'image/tiff'                      => %w(tif tiff),
+      'image/vnd.wap.wbmp'              => %w(wbmp),
+      'image/x-icon'                    => %w(ico),
+      'image/x-jng'                     => %w(jng),
+      'image/x-ms-bmp'                  => %w(bmp),
+      'image/svg+xml'                   => %w(svg),
+
+      'text/css'                        => %w(css),
+      'text/html'                       => %w(html htm shtml),
+      'text/mathml'                     => %w(mml),
+      'text/plain'                      => %w(txt),
+      'text/x-component'                => %w(htc),
+      'text/xml'                        => %w(xml rss),
+
+      'video/3gpp'                      => %w(3gpp 3gp),
+      'video/mpeg'                      => %w(mpeg mpg),
+      'video/quicktime'                 => %w(mov),
+      'video/x-flv'                     => %w(flv),
+      'video/x-mng'                     => %w(mng),
+      'video/x-ms-asf'                  => %w(asx asf),
+      'video/x-ms-wmv'                  => %w(wmv),
+      'video/x-msvideo'                 => %w(avi)
+    }
+
+    #
+    # Return the MIME content type of the +file+ path or object.
+    #
+    def file_type file
+      filename = file.respond_to?(:path) ? file.path : file
+      extension = File.extname(filename)[1..-1] # array index removes period
+      typ_exts = CONTENT_TYPES.find {|type, extentions| extentions.include? extension}
+      typ_exts ? typ_exts.first : typ_exts      # returns +type+ from above or nil
+    end
+
+  end
+
+end

data/lib/mime/discrete_media_factory.rb

@@ -0,0 +1,69 @@
+module MIME
+
+  #
+  # Class object used only for initializing derived DiscreteMediaType objects.
+  #
+  class DiscreteMediaFactory
+
+    class << self
+
+      include ContentTypes
+
+      #
+      # Creates a corresponding DiscreteMediaType subclass object for the given
+      # +file+ based on +file+'s filename extension. +file+ can be a file path
+      # or File object.
+      #
+      # +content_type+ can be specified in order to override the auto detected
+      # content type. If the +content_type+ cannot be detected, an
+      # UnknownContentError exception will be raised.
+      #
+      # Creates and sets the singleton method +path+ on the created object. The
+      # +path+ method is utilized by other methods in the MIME library,
+      # therefore, eliminating redundant and explicit filename assignments.
+      #
+      # ==== Comparison Example
+      #
+      #  entity1 = open('/tmp/file1.txt')
+      #  entity2 = DiscreteMediaFactory.create('/tmp/file2.txt')
+      #
+      #  mixed_msg = Multipart::Mixed.new
+      #  mixed_msg.attach_entity(entity1.read, entity.path)
+      #  mixed_msg.attach_entity(entity2) # no path needed
+      #
+      def create file, content_type = nil
+        if file.is_a? File
+          cntnt = file.read
+          ctype = content_type || file_type(file.path)
+          fname = file.path
+        else
+          cntnt = IO.read(file)
+          ctype = content_type || file_type(file)
+          fname = file
+        end
+
+        raise UnknownContentError  unless ctype
+
+        media_obj = 
+          case ctype.match(/^(\w+)\//)[1]
+          when 'application'; ApplicationMedia.new(cntnt, ctype)
+          when 'audio'      ; AudioMedia.new(cntnt, ctype)
+          when 'image'      ; ImageMedia.new(cntnt, ctype)
+          when 'text'       ; TextMedia.new(cntnt, ctype)
+          when 'video'      ; VideoMedia.new(cntnt, ctype)
+          end
+
+        class << media_obj;  attr_accessor :path  end
+        media_obj.path = fname
+        media_obj
+      end
+
+    end
+
+    def initialize
+      AbstractClassError.no_instantiation self, DiscreteMediaFactory
+    end
+
+  end
+
+end

data/lib/mime/discrete_media_type.rb

@@ -0,0 +1,79 @@
+module MIME
+
+  #
+  # Discrete media types must be handled by non-MIME mechanisms; they are
+  # opaque to MIME processors. Therefore, the body of a DiscreteMediaType
+  # object does not need further MIME processing.
+  #
+  # This class is abstract.
+  #
+  class DiscreteMediaType < MediaType
+
+    def initialize body, content_type = 'application/octet-stream'
+      AbstractClassError.no_instantiation(self, DiscreteMediaType)
+      super
+    end
+
+  end
+
+  #
+  # ApplicationMedia is intended for discrete data that is to be processed by
+  # some type of application program. The body contains information which must
+  # be processed by an application before it is viewable or usable by a user.
+  #
+  # ApplicationMedia is the catch all class. If your content cannot be
+  # identified as another DiscreteMediaType, then it is application media.
+  #
+  # See DiscreteMediaType.new for initialization parameters.
+  #
+  class ApplicationMedia < DiscreteMediaType
+  end
+
+  #
+  # AudioMedia is intended for discrete audio content. The content subtype
+  # indicates the specific audio format.
+  #
+  # See DiscreteMediaType.new for initialization parameters.
+  #
+  class AudioMedia < DiscreteMediaType
+  end
+
+  #
+  # ImageMedia is intented for discrete image content. The content subtype
+  # indicates the specific image format.
+  #
+  # See DiscreteMediaType.new for initialization parameters.
+  #
+  class ImageMedia < DiscreteMediaType
+  end
+
+  #
+  # TextMedia is intended for content which is principally textual in form.  
+  #
+  class TextMedia < DiscreteMediaType
+    
+    #
+    # Return a new TextMedia object containing +body+ with the content type of
+    # +content_type+.
+    #
+    # To specify the character set of +body+, a _charset_ parameter may be
+    # appended to +content_type+ using a semi-colon delimiter.
+    #
+    def initialize body, content_type = 'text/plain; charset=us-ascii'
+      super
+    end
+
+  end
+
+  #
+  # VideoMedia is intended for discrete video content. The content subtype
+  # indicates the specific video format. The RFC describes video media as
+  # content that contains a time-varying-picture image, possibly with color and
+  # coordinated sound.
+  #
+  # See DiscreteMediaType.new for initialization parameters.
+  #
+  class VideoMedia < DiscreteMediaType
+  end
+
+end

data/lib/mime/error.rb

@@ -0,0 +1,32 @@
+module MIME
+
+  #
+  # General purpose MIME errors.
+  #
+  class Error < StandardError ; end
+
+  #
+  # Undetectable MIME content type error.
+  #
+  class UnknownContentError < Error ; end
+
+  #
+  # Abstract class object initialization error. Many classes in the MIME
+  # library are abstract and will raise this error.
+  #
+  class AbstractClassError < Error
+
+    #
+    # A helper method for detecting the intialization of an object in an
+    # abstract class. +myself+ must always be *self* and +klass+ is the
+    # abstract class object.
+    #
+    def self.no_instantiation myself, klass
+      if myself.class == klass
+        raise AbstractClassError.new('cannot construct abstract class')
+      end
+    end
+
+  end
+
+end

data/lib/mime/header_container.rb

@@ -0,0 +1,34 @@
+module MIME
+
+  #
+  # Storage for RFC 2822 headers.
+  #
+  class HeaderContainer
+
+    #
+    # Return a new header container object.
+    #
+    def initialize
+      @headers = Hash.new
+    end
+
+    #
+    # Convert all headers to their string equivalents and join them using the
+    # RFC 2822 CRLF line separator.
+    #
+    def to_s
+      @headers.collect do |name, value|
+        "#{name}: #{value}"
+      end.join("\r\n")
+    end
+
+    #
+    # Add the +name+/+value+ pair to the header container.
+    #
+    def add name, value
+      @headers.store(name, value)
+    end
+
+  end
+
+end

data/lib/mime/headers/internet.rb

@@ -0,0 +1,90 @@
+module MIME
+  module Headers
+
+    #
+    # The RFC 2822 Internet message header fields.
+    #
+    module Internet
+
+      attr_reader :date, :from, :to
+      attr_reader :cc, :bcc, :reply_to, :message_id
+      attr_reader :comments, :keywords, :subject
+
+
+      #
+      # Required Headers
+      #
+
+      def date= date
+        @date = date
+        headers.add('Date', @date)
+      end
+
+      def from= list
+        @from = stringify_email_list(list)
+        headers.add('From', @from)
+      end
+
+      def to= list
+        @to = stringify_email_list(list)
+        headers.add('To', @to)
+      end
+
+
+      #
+      # Optional Headers
+      #
+
+      def cc= list
+        @cc = stringify_email_list(list)
+        headers.add('Cc', @cc)
+      end
+
+      def bcc= list
+        @bcc = stringify_email_list(list)
+        headers.add('Bcc', @bcc)
+      end
+
+      def reply_to= list
+        @reply_to = stringify_email_list(list)
+        headers.add('Reply-To', @reply_to)
+      end
+
+      #
+      # The message +id+ must contain an embedded "@" symbol. An example +id+
+      # might be <em>some-unique-id@domain.com</em>.
+      #
+      def message_id= id
+        @message_id = "<#{id}>"
+        headers.add('Message-ID', @message_id)
+      end
+
+      def comments= comments
+        @comments = comments
+        headers.add('Comments', @comments)
+      end
+
+      def keywords= keywords
+        @keywords = keywords
+        headers.add('Keywords', @keywords)
+      end
+
+      def subject= subject
+        @subject = subject
+        headers.add('Subject', @subject)
+      end
+
+
+      private
+
+      #
+      # +list+ may be a single email address or a Hash of _email_ => _name_
+      # pairs. Set _name_ to nil when it is unknown.
+      #
+      def stringify_email_list list
+        list.map {|email, name| name ? "#{name} <#{email}>" : email}.join(', ')
+      end
+
+    end
+  end
+end

data/lib/mime/headers/mime.rb

@@ -0,0 +1,118 @@
+module MIME
+  module Headers
+
+    #
+    # The RFC 2045 MIME message header fields.
+    #
+    module MIME
+
+      attr_reader :mime_version,
+        :content_description,
+        :content_disposition,
+        :content_id,
+        :content_transfer_encoding,
+        :content_type
+
+
+      #
+      # Describes the content, which can be useful for non-MIME clients.
+      #
+      def content_description= description
+        @content_description = description
+        headers.add('Content-Description', description)
+      end
+
+      #
+      # Specifies the disposition of the content relative to its enclosing
+      # message. Valid values for +disposition+ are _inline_ and _attachment_.
+      # Parameters can also be specified here; see the RFC for details.
+      #
+      # RFC 2183 Communicating Presentation Information in Internet Messages.
+      #
+      def content_disposition= disposition
+        @content_disposition = disposition
+        headers.add('Content-Disposition', disposition)
+      end
+
+      #
+      # Globally unique ID that identifies a top-level message or message
+      # entity. Content IDs can be used for referencing or caching purposes.
+      #
+      def content_id= id
+        @content_id = id
+        headers.add('Content-ID', "<#{id}>")
+      end
+
+      #
+      # The mechanism used for encoding the top-level message content.
+      #
+      # Common Encoding Mechanisms
+      # 1. 7bit
+      # 2. 8bit
+      # 3. binary
+      # 4. quoted-printable
+      # 5. base64
+      #
+      def content_transfer_encoding= encoding
+        @content_transfer_encoding = encoding
+        headers.add('Content-Transfer-Encoding', encoding)
+      end
+
+      #
+      # Specifies the media type and subtype of the content. +type+ will have
+      # the form <em>media-type/subtype</em>.
+      #
+      # Common Content Types
+      # 1. application/octet-stream
+      # 2. audio/mpeg
+      # 3. image/jpeg
+      # 4. text/plain
+      # 5. video/mpeg
+      #
+      def content_type= type
+        @content_type = type
+        headers.add('Content-Type', type)
+      end
+
+      #
+      # Currently only version 1.0 exists.
+      #
+      def mime_version= version
+        @mime_version = version
+        headers.add('MIME-Version', version)
+      end
+
+      protected
+
+      #
+      # +type+ is the disposition type of either "inline" or "attachment".
+      # +params+ is a Hash with zero or more of the following keys:
+      #
+      #   * filename          => name of file
+      #   * creation-date     => RFC2822 data-time
+      #   * modification-date => RFC2822 data-time 
+      #   * read-date         => RFC2822 data-time
+      #   * size              => file size in octets
+      #
+      # The values for the *-date keys may use Time::rfc2822.
+      #
+      def set_content_disposition type, params = {}
+        disposition = type
+
+        if params['filename']
+          params['filename'] = File.basename(params['filename'])
+        elsif self.respond_to?(:path)
+          params['filename'] = File.basename(self.path)
+        end
+
+        params.each do |name, value|
+          disposition << %Q[; #{name}="#{value}"]  if value
+        end
+
+        self.content_disposition = disposition
+      end
+
+    end
+
+  end
+end