kbaum-mail 2.1.2.1

data/Rakefile

@@ -0,0 +1,72 @@
+environment = File.expand_path('../../vendor/gems/environment')
+if File.exist?("#{environment}.rb")
+  require environment
+end
+
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'rake/testtask'
+require 'spec/rake/spectask'
+require 'cucumber/rake/task'
+require 'bundler'
+
+spec = Gem::Specification.new do |s|
+  s.name        = "kbaum-mail"
+  s.version     = "2.1.2.1"
+  s.author      = "Mike Lindsaar"
+  s.email       = "raasdnil@gmail.com"
+  s.homepage    = "http://github.com/mikel/mail"
+  s.description = "A really Ruby Mail handler."
+  s.summary     = "Mail provides a nice Ruby DSL for making, sending and reading emails."
+
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README.rdoc", "CHANGELOG.rdoc", "TODO.rdoc"]
+
+  s.add_dependency('activesupport', ">= 2.3.4")
+  s.add_dependency('mime-types')
+
+  s.require_path = 'lib'
+  s.files = %w(README.rdoc Rakefile TODO.rdoc) + Dir.glob("lib/**/*")
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+    pkg.gem_spec = spec
+end
+
+task :default => :spec
+Cucumber::Rake::Task.new do |t|
+  t.cucumber_opts = "spec/features --format pretty"
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |t|
+  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.warning = true
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.spec_opts = %w(--backtrace --diff --color)
+  t.libs << "#{File.dirname(__FILE__)}/spec"
+  t.libs << "#{File.dirname(__FILE__)}/spec/mail"
+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
+
+# load custom rake tasks
+Dir["#{File.dirname(__FILE__)}/lib/tasks/**/*.rake"].sort.each { |ext| load ext }

data/TODO.rdoc

@@ -0,0 +1,19 @@
+== Not really in any order:
+
+* Make body, part, field, header, message all responding correctly to :encoded
+  and :decoded messages.  And remove ":to_s" as a method on these
+  classes.  Encoded needs to return the field, encoded, ready to send in the
+  mail system, that is, US-ASCII.  Decoded needs to return the field decoded ready to
+  view.  :to_s is (unfortunately) ambiguous in this case.  Maybe return a warning 
+  with :to_s and say "please use encoded or decoded instead" or :to_s returns
+  "Showing you the encoded view by default, call :decoded to see the decoded view"
+
+* Refactor out the multibyte and string handling.  Make ActiveSupport a dependancy
+
+* Clean up the relationship between message, parts and bodies.  Need to make sure
+  once parsed, that a body knows what encoding it is, for example.
+
+* Cleanup the treetop parsers......... do I _really_ need that many entrance files?
+
+* Simplify the relationship of Headers and Fields.  Doing too much of the Field work
+  in the Header class on instantiating fields.  Header should just say "Field, do it!"

data/lib/mail.rb

@@ -0,0 +1,113 @@
+# encoding: utf-8
+module Mail # :doc:
+
+  require 'date'
+
+  require 'active_support'
+
+  # Have to handle ActiveSupport 2.3 and 3.0
+  # Following two lines make sure that HashWithIndifferentAccess is available
+  # regardless of having activesupport 3 or 2.3 loaded
+  require 'active_support/core_ext/hash/indifferent_access'
+
+  require 'mail/vendor/treetop'
+
+  require 'uri'
+  require 'net/smtp'
+  require 'mime/types'
+
+  if RUBY_VERSION <= '1.8.6'
+    begin
+      require 'tlsmail'
+    rescue LoadError
+      raise "You need to install tlsmail if you are using ruby <= 1.8.6"
+    end
+  end
+
+  if RUBY_VERSION >= "1.9.1"
+    require 'mail/version_specific/ruby_1_9.rb'
+    RubyVer = Mail::Ruby19
+  else
+    require 'mail/version_specific/ruby_1_8.rb'
+    RubyVer = Mail::Ruby18
+  end
+
+  require 'mail/version'
+
+  begin
+    require 'active_support/core_ext/object/blank'
+  rescue LoadError
+    # Unneeded for Active Support <= 3.0.pre
+  end
+
+  require 'mail/core_extensions/nil'
+  require 'mail/core_extensions/string'
+
+  require 'mail/patterns'
+  require 'mail/utilities'
+  require 'mail/configuration'
+  require 'mail/network/delivery_methods/smtp'
+  require 'mail/network/delivery_methods/file_delivery'
+  require 'mail/network/delivery_methods/sendmail'
+  require 'mail/network/delivery_methods/test_mailer'
+  require 'mail/network/retriever_methods/pop3'
+  require 'mail/network/retriever_methods/imap'
+
+  require 'mail/message'
+  require 'mail/part'
+  require 'mail/header'
+  require 'mail/parts_list'
+  require 'mail/attachments_list'
+  require 'mail/body'
+  require 'mail/field'
+  require 'mail/field_list'
+
+  # Load in all common header fields modules
+  require 'mail/fields/common/address_container'
+  require 'mail/fields/common/common_address'
+  require 'mail/fields/common/common_date'
+  require 'mail/fields/common/common_field'
+  require 'mail/fields/common/common_message_id'
+  require 'mail/fields/common/parameter_hash'
+
+  require 'mail/fields/structured_field'
+  require 'mail/fields/unstructured_field'
+  require 'mail/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 content_location ]
+  
+  parsers.each do |parser|
+    begin
+      # Try requiring the pre-compiled ruby version first
+      require "mail/parsers/#{parser}"
+    rescue LoadError
+      # Otherwise, get treetop to compile and load it
+      Treetop.load("mail/parsers/#{parser}")
+    end
+  end
+
+  # Load in all header field elements
+  elems = Dir.glob(File.join(File.dirname(__FILE__), 'mail', 'elements', '*.rb'))
+  elems.each do |elem|
+    require "mail/elements/#{File.basename(elem, '.rb')}"
+  end
+  
+  # Load in all header fields
+  fields = Dir.glob(File.join(File.dirname(__FILE__), 'mail', 'fields', '*.rb'))
+  fields.each do |field|
+    require "mail/fields/#{File.basename(field, '.rb')}"
+  end
+  
+  # Load in all transfer encodings
+  elems = Dir.glob(File.join(File.dirname(__FILE__), 'mail', 'encodings', '*.rb'))
+  elems.each do |elem|
+    require "mail/encodings/#{File.basename(elem, '.rb')}"
+  end
+  
+  # Finally... require all the Mail.methods
+  require File.join('mail', 'mail')
+
+end

data/lib/mail/attachments_list.rb

@@ -0,0 +1,76 @@
+module Mail
+  class AttachmentsList < Array
+    
+    def initialize(parts_list)
+      @parts_list = parts_list
+      parts_list.map { |p|
+        if p.parts.empty?
+          p if p.attachment?
+        else
+          p.attachments
+        end
+      }.flatten.compact.each { |a| self << a }
+      self
+    end
+    
+    # Returns the attachment by filename or at index.
+    # 
+    # mail.attachments['test.png'] = File.read('test.png')
+    # mail.attachments['test.jpg'] = File.read('test.jpg')
+    # 
+    # mail.attachments['test.png'].filename #=> 'test.png'
+    # mail.attachments[1].filename          #=> 'test.jpg'
+    def [](index_value)
+      if index_value.is_a?(Fixnum)
+        self.fetch(index_value)
+      else
+        self.select { |a| a.filename == index_value }.first
+      end
+    end
+
+    def []=(name, value)
+      default_values = { :content_type => "#{set_mime_type(name)}; filename=\"#{name}\"",
+                         :content_transfer_encoding => 'Base64',
+                         :content_disposition => "attachment; filename=\"#{name}\"" }
+
+      if value.is_a?(Hash)
+
+        default_values[:body] = value.delete(:content) if value[:content]
+
+        default_values[:body] = value.delete(:data) if value[:data]
+
+        # Only force encode base64 if the user has not specified an encoding
+        if value[:transfer_encoding]
+          default_values[:content_transfer_encoding] = value.delete(:transfer_encoding)
+        elsif value[:encoding]
+          default_values[:content_transfer_encoding] = value.delete(:encoding)
+        else
+          default_values[:body] = Mail::Encodings::Base64.encode(default_values[:body])
+        end
+
+        if value[:mime_type]
+          default_values[:content_type] = value.delete(:mime_type)
+        end
+
+        hash = default_values.merge(value)
+      else
+        default_values[:body] = Mail::Encodings::Base64.encode(value)
+        hash = default_values
+      end
+
+      @parts_list << Part.new(hash)
+    end
+    
+    def set_mime_type(filename)
+      # Have to do this because MIME::Types is not Ruby 1.9 safe yet
+      if RUBY_VERSION >= '1.9'
+        new_file = String.new(filename).force_encoding(Encoding::BINARY)
+        ext = new_file.split('.'.force_encoding(Encoding::BINARY)).last
+        filename = "file.#{ext}".force_encoding('US-ASCII')
+      end
+      @mime_type = MIME::Types.type_for(filename).first
+    end
+    
+  end
+end
+

data/lib/mail/body.rb

@@ -0,0 +1,243 @@
+# 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 = '')
+      @boundary = nil
+      @preamble = nil
+      @epilogue = nil
+      @part_sort_order = [ "text/plain", "text/enriched", "text/html" ]
+      @parts = Mail::PartsList.new
+      if string.blank?
+        @raw_source = ''
+      else
+        # Do join first incase we have been given an Array in Ruby 1.9
+        if string.respond_to?(:join)
+          @raw_source = string.join('')
+        elsif string.respond_to?(:to_s)
+          @raw_source = string.to_s
+        else
+          raise "You can only assign a string or an object that responds_to? :join or :to_s to a body."
+        end
+      end
+      @encoding = nil
+      set_charset
+    end
+    
+    # Matches this body with another body.  Also matches the decoded value of this
+    # body with a string.
+    # 
+    # Examples:
+    # 
+    #   body = Mail::Body.new('The body')
+    #   body == body #=> true
+    #   
+    #   body = Mail::Body.new('The body')
+    #   body == 'The body' #=> true
+    #   
+    #   body = Mail::Body.new("VGhlIGJvZHk=\n")
+    #   body.encoding = 'base64'
+    #   body == "The body" #=> true
+    def ==(other)
+      if other.class == String
+        self.decoded == other
+      else
+        super
+      end
+    end
+    
+    # Accepts a string and performs a regular expression against the decoded text
+    # 
+    # Examples:
+    # 
+    #   body = Mail::Body.new('The body')
+    #   body =~ /The/ #=> 0
+    #   
+    #   body = Mail::Body.new("VGhlIGJvZHk=\n")
+    #   body.encoding = 'base64'
+    #   body =~ /The/ #=> 0
+    def =~(regexp)
+      self.decoded =~ regexp
+    end
+    
+    # Accepts a string and performs a regular expression against the decoded text
+    # 
+    # Examples:
+    # 
+    #   body = Mail::Body.new('The body')
+    #   body.match(/The/) #=> #<MatchData "The">
+    #   
+    #   body = Mail::Body.new("VGhlIGJvZHk=\n")
+    #   body.encoding = 'base64'
+    #   body.match(/The/) #=> #<MatchData "The">
+    def match(regexp)
+      self.decoded.match(regexp)
+    end
+
+    # Allows you to set the sort order of the parts, overriding the default sort order.
+    # Defaults to 'text/plain', then 'text/enriched', then 'text/html' with any other content
+    # type coming after.
+    def set_sort_order(order)
+      @part_sort_order = order
+    end
+    
+    # Allows you to sort the parts according to the default sort order, or the sort order you
+    # set with :set_sort_order.
+    #
+    # sort_parts! is also called from :encode, so there is no need for you to call this explicitly
+    def sort_parts!
+      @parts.each do |p|
+        p.body.set_sort_order(@part_sort_order)
+        @parts.sort!(@part_sort_order)
+        p.body.sort_parts!
+      end
+#      @parts.sort!(@part_sort_order)
+    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?
+        self.sort_parts!
+        encoded_parts = parts.map { |p| p.encoded }
+        ([preamble] + encoded_parts).join(crlf_boundary) + end_boundary + epilogue.to_s
+      else
+        raw_source.to_crlf
+      end
+    end
+    
+    def decoded
+      if encoding.nil? || !Encodings.defined?(encoding)
+        raw_source.to_lf
+      else
+        Encodings.get_encoding(encoding).decode(raw_source)
+      end
+    end
+    
+    def to_s
+      decoded
+    end
+    
+    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 = Mail::PartsList.new[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[1...-1].to_a.each { |part| @parts << 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