mail 1.0.0

data/Rakefile

@@ -0,0 +1,38 @@
+require 'rake'
+require 'rake/rdoctask'
+require 'rake/testtask'
+require 'rubygems'
+require 'spec/rake/spectask'
+require 'cucumber/rake/task'
+
+task :default => :spec
+
+Cucumber::Rake::Task.new do |t|
+  t.cucumber_opts = "spec/features --format pretty"
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |t|
+  gem 'relevance-rcov', '>= 0.8.4.1'
+  t.spec_files = FileList['**/test/**/tc_*.rb', '**/spec/**/*_spec.rb']
+  t.rcov = true
+  t.rcov_opts = t.rcov_opts << ['--exclude', '/Library,/opt,/System']
+end
+
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_files = FileList['**/spec/**/*_spec.rb']
+end
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = '**/test/**/tc_*.rb'
+  t.verbose = true
+  t.warning = false
+end
+
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Mail'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/mail.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+module Mail # :doc:
+
+  require 'date'
+  
+  gem "treetop", ">= 1.4"
+  require 'treetop'
+
+  require 'net/smtp'
+  require 'mime/types'
+  require 'tlsmail' if RUBY_VERSION <= '1.8.6'
+
+  dir_name = File.join(File.dirname(__FILE__), 'mail')
+
+  if RUBY_VERSION >= "1.9.1"
+    require File.join(dir_name, 'version_specific', 'ruby_1_9.rb')
+    RubyVer = Mail::Ruby19
+  else
+    require File.join(dir_name, 'version_specific', 'ruby_1_8.rb')
+    require File.join(dir_name, 'version_specific', 'ruby_1_8_string.rb')
+    RubyVer = Mail::Ruby18
+  end
+
+  require File.join(dir_name, 'version')
+  require File.join(dir_name, 'core_extensions')
+  require File.join(dir_name, 'patterns')
+  require File.join(dir_name, 'utilities')
+  require File.join(dir_name, 'configuration')
+  require File.join(dir_name, 'network', 'deliverable')
+  require File.join(dir_name, 'network', 'retrievable')
+
+  require File.join(dir_name, 'message')
+  require File.join(dir_name, 'part')
+  require File.join(dir_name, 'header')
+  require File.join(dir_name, 'body')
+  require File.join(dir_name, 'field')
+  require File.join(dir_name, 'field_list')
+  require File.join(dir_name, 'attachment')
+
+  # Load in all common header fields modules
+  commons = Dir.glob(File.join(dir_name, 'fields', 'common', '*.rb'))
+  commons.each do |common|
+    require common
+  end
+
+  require File.join(dir_name, 'fields', 'structured_field')
+  require File.join(dir_name, 'fields', 'unstructured_field')
+  require File.join(dir_name, 'envelope')
+
+  parsers = %w[ rfc2822_obsolete rfc2822 address_lists phrase_lists
+                date_time received message_ids envelope_from rfc2045 
+                mime_version content_type content_disposition
+                content_transfer_encoding ]
+
+  parsers.each do |parser|
+    begin
+      # Try requiring the pre-compiled ruby version first
+      require File.join(dir_name, 'parsers', parser)
+    rescue LoadError
+      # Otherwise, get treetop to compile and load it
+      Treetop.load(File.join(dir_name, 'parsers', parser))
+    end
+  end
+  
+  # Load in all header field elements
+  elems = Dir.glob(File.join(dir_name, 'elements', '*.rb'))
+  elems.each do |elem|
+    require elem
+  end
+  
+  # Load in all header fields
+  fields = Dir.glob(File.join(dir_name, 'fields', '*.rb'))
+  fields.each do |field|
+    require field
+  end
+  
+  # Load in all transfer encodings
+  elems = Dir.glob(File.join(dir_name, 'encodings', '*.rb'))
+  elems.each do |elem|
+    require elem
+  end
+  
+  # Finally... require all the Mail.methods
+  require File.join(dir_name, 'mail')
+
+end

data/lib/mail/attachment.rb

@@ -0,0 +1,90 @@
+# encoding: utf-8
+module Mail
+  # An attachment is any data you want to attach to a mail message that is
+  # not part of the body and can be extracted to a file in it's own right
+  # 
+  # This includes images, sound files, text files, documents, anything really,
+  # the only requisite is that it has a file name and an encoding.
+  # 
+  # If you do not pass in an encoding when creating a new attachment, then
+  # Mail::Attachment will assume that the data you pass in is raw data and
+  # encode it with base64.
+  # 
+  # If you pass in an encoding, Mail::Attachment will assume that the data
+  # is encoded data and attempt to decode the data string with the encoding
+  # you supply.
+  # 
+  # So, raw data should be given in with no encoding, pre encoded data should
+  # be given with an encoding type.
+  # 
+  # Attachment will always encode with Base64, it's safe, it works, maybe in
+  # the future we will allow you to encode with different types.  If you really
+  # want to encode with a different encoder, then pre encode the data and pass
+  # it in with an encoding.  Mail::Attachment will happily initialize for you,
+  # however, if it doesn't understand the encoding, it will not decode for you
+  # and raise an error, but if you can encode it, we assume you know how to
+  # decode it, so just get back the encoded source (with #encoded) and then
+  # decode at your leisure.
+  class Attachment
+    
+    include Utilities
+    
+    # Raised when attempting to decode an unknown encoding type
+    class UnknownEncodingType < StandardError #:nodoc:
+    end
+    
+    def initialize(options_hash)
+      case
+      when options_hash[:data]
+        @filename = options_hash[:filename]
+        add_file(options_hash[:data], options_hash[:encoding])
+      when options_hash[:filename]
+        @filename = File.basename(options_hash[:filename])
+        data = File.read(options_hash[:filename])
+        add_file(data, options_hash[:encoding])
+      end
+      set_mime_type(@filename, options_hash[:mime_type])
+    end
+    
+    def filename
+      @filename
+    end
+    
+    def encoded
+      @encoded_data
+    end
+    
+    def decoded
+      if Mail::Encodings.defined?(@encoding)
+        Mail::Encodings.get_encoding(@encoding).decode(@encoded_data)
+      else
+        raise UnknownEncodingType, "Don't know how to decode #{@encoding}, please call #encoded and decode it yourself."
+      end
+    end
+    
+    def mime_type
+      @mime_type.to_s
+    end
+    
+    private
+    
+    def set_mime_type(filename, mime_type)
+      unless mime_type
+        @mime_type = MIME::Types.type_for(filename).first
+      else
+        @mime_type = mime_type
+      end
+    end
+    
+    def add_file(data, encoding)
+      if encoding # We are being given encoded data
+        @encoded_data = data
+        @encoding = encoding.to_s
+      else # this is raw data
+        @encoded_data = Mail::Encodings::Base64.encode(data)
+        @encoding = 'base64'
+      end
+    end
+    
+  end
+end

data/lib/mail/body.rb

@@ -0,0 +1,149 @@
+# encoding: utf-8
+module Mail
+  
+  # = Body
+  # 
+  # The body is where the text of the email is stored.  Mail treats the body
+  # as a single object.  The body itself has no information about boundaries
+  # used in the MIME standard, it just looks at it's content as either a single
+  # block of text, or (if it is a multipart message) as an array of blocks o text.
+  # 
+  # A body has to be told to split itself up into a multipart message by calling
+  # #split with the correct boundary.  This is because the body object has no way
+  # of knowing what the correct boundary is for itself (there could be many
+  # boundaries in a body in the case of a nested MIME text).
+  # 
+  # Once split is called, Mail::Body will slice itself up on this boundary,
+  # assigning anything that appears before the first part to the preamble, and
+  # anything that appears after the closing boundary to the epilogue, then
+  # each part gets initialized into a Mail::Part object.
+  # 
+  # The boundary that is used to split up the Body is also stored in the Body
+  # object for use on encoding itself back out to a string.  You can 
+  # overwrite this if it needs to be changed.
+  # 
+  # On encoding, the body will return the preamble, then each part joined by
+  # the boundary, followed by a closing boundary string and then the epilogue.
+  class Body
+
+    def initialize(string = '')
+      if string.blank?
+        @raw_source = ''
+      else
+        @raw_source = string
+      end
+      set_charset
+    end
+    
+    # Returns the raw source that the body was initialized with, without
+    # any tampering
+    def raw_source
+      @raw_source
+    end
+    
+    # Returns a US-ASCII 7-bit compliant body.  Right now just returns the
+    # raw source.  Need to implement
+    def encoded
+      if multipart?
+        encoded_parts = parts.map { |p| p.to_s }
+        ([preamble] + encoded_parts).join(crlf_boundary) + end_boundary + epilogue.to_s
+      else
+        raw_source
+      end
+    end
+    
+    alias :to_s :encoded
+
+    def charset
+      @charset
+    end
+    
+    def charset=( val )
+      @charset = val
+    end
+
+    def encoding
+      @encoding
+    end
+    
+    def encoding=( val )
+      @encoding = val
+    end
+
+    # Returns the preamble (any text that is before the first MIME boundary)
+    def preamble
+      @preamble
+    end
+
+    # Sets the preamble to a string (adds text before the first mime boundary)
+    def preamble=( val )
+      @preamble = val
+    end
+    
+    # Returns the epilogue (any text that is after the last MIME boundary)
+    def epilogue
+      @epilogue
+    end
+    
+    # Sets the epilogue to a string (adds text after the last mime boundary)
+    def epilogue=( val )
+      @epilogue = val
+    end
+    
+    # Returns true if there are parts defined in the body
+    def multipart?
+      true unless parts.empty?
+    end
+    
+    # Returns the boundary used by the body
+    def boundary
+      @boundary
+    end
+    
+    # Allows you to change the boundary of this Body object
+    def boundary=( val )
+      @boundary = val
+    end
+
+    def parts
+      @parts ||= []
+    end
+    
+    def <<( val )
+      if @parts
+        @parts << val
+      else
+        @parts = [val]
+      end
+    end
+    
+    def split!(boundary)
+      self.boundary = boundary
+      parts = raw_source.split("--#{boundary}")
+      # Make the preamble equal to the preamble (if any)
+      self.preamble = parts[0].to_s.strip
+      # Make the epilogue equal to the epilogue (if any)
+      self.epilogue = parts[-1].to_s.sub('--', '').strip
+      @parts = parts[1...-1].map { |part| Mail::Part.new(part) }
+      self
+    end
+    
+    def only_us_ascii?
+      !!raw_source.to_s.ascii_only?
+    end
+    
+    private
+    
+    def crlf_boundary
+      "\r\n\r\n--#{boundary}\r\n"
+    end
+    
+    def end_boundary
+      "\r\n\r\n--#{boundary}--\r\n"
+    end
+    
+    def set_charset
+      raw_source.ascii_only? ? @charset = 'US-ASCII' : @charset = nil
+    end
+  end
+end

data/lib/mail/configuration.rb

@@ -0,0 +1,90 @@
+# encoding: utf-8
+#
+# Thanks to Nicolas Fouché for this wrapper
+#
+require 'singleton'
+
+module Mail
+  
+  # The Configuration class is a Singleton used to hold the default
+  # configuration for all SMTP, POP3 and IMAP operations handled by Mail.
+  # See Mail.defaults for more information.
+  class Configuration
+    include Singleton
+    
+    # Creates a new Mail::Configuration object through .defaults
+    def defaults(&block)
+      if block_given?
+        instance_eval(&block)
+      end
+      self
+    end
+    
+    # Allows you to specify the SMTP Server by passing the hostname
+    # or IP Address as a String with an optional port number as a
+    # string or integer.
+    # 
+    # Defaults to 127.0.0.1 and port 25.
+    # 
+    # Example:
+    # 
+    #  Mail.defaults.do
+    #    smtp '127.0.0.1'
+    #  end
+    # 
+    #  Mail.defaults do
+    #    smtp '127.0.0.1', 25
+    #  end
+    def smtp(*args)
+      if args.size > 0
+        @smtp = [args[0], (args[1].to_i > 0 ? args[1] : 25)]
+      end
+      @smtp
+    end
+    
+    # Allows you to specify the POP3 Server by passing the hostname
+    # or IP Address as a String with an optional port number as a
+    # string or integer.
+    # 
+    # Defaults to 127.0.0.1 and port 110.
+    # 
+    # Example:
+    # 
+    #  Mail.defaults.do
+    #    pop3 '127.0.0.1'
+    #  end
+    # 
+    #  Mail.defaults do
+    #    pop3 '127.0.0.1', 110
+    #  end
+    def pop3(*args)
+      if args.size > 0
+        @pop3 = [args[0], (args[1].to_i > 0 ? args[1] : 110)]
+      end
+      @pop3
+    end
+    
+    # Pass in the username to use for POP3 or IMAP access
+    def user(value = nil)
+      value ? @user = value : @user
+    end
+    
+    def pass(value = nil)
+      value ? @pass = value : @pass
+    end
+    
+    def enable_tls
+      @tls = true
+    end
+    
+    def disable_tls
+      @tls = false
+    end
+    
+    def tls?
+      @tls || false
+    end
+    
+  end
+
+end