dball-mail 2.2.9.1

data/lib/mail/elements/address.rb

@@ -0,0 +1,306 @@
+# encoding: utf-8
+module Mail
+  class Address
+    
+    include Mail::Utilities
+    
+    # Mail::Address handles all email addresses in Mail.  It takes an email address string
+    # and parses it, breaking it down into it's component parts and allowing you to get the
+    # address, comments, display name, name, local part, domain part and fully formatted
+    # address.
+    # 
+    # Mail::Address requires a correctly formatted email address per RFC2822 or RFC822.  It
+    # handles all obsolete versions including obsolete domain routing on the local part.
+    # 
+    #  a = Address.new('Mikel Lindsaar (My email address) <mikel@test.lindsaar.net>')
+    #  a.format       #=> 'Mikel Lindsaar <mikel@test.lindsaar.net> (My email address)'
+    #  a.address      #=> 'mikel@test.lindsaar.net'
+    #  a.display_name #=> 'Mikel Lindsaar'
+    #  a.local        #=> 'mikel'
+    #  a.domain       #=> 'test.lindsaar.net'
+    #  a.comments     #=> ['My email address']
+    #  a.to_s         #=> 'Mikel Lindsaar <mikel@test.lindsaar.net> (My email address)'
+    def initialize(value = nil)
+      @output_type = nil
+      @tree = nil
+      @raw_text = value
+      case
+      when value.nil?
+        @parsed = false
+        return
+      else
+        parse(value)
+      end
+    end
+    
+    # Returns the raw imput of the passed in string, this is before it is passed
+    # by the parser.
+    def raw
+      @raw_text
+    end
+
+    # Returns a correctly formatted address for the email going out.  If given
+    # an incorrectly formatted address as input, Mail::Address will do it's best
+    # to format it correctly.  This includes quoting display names as needed and
+    # putting the address in angle brackets etc.
+    #
+    #  a = Address.new('Mikel Lindsaar (My email address) <mikel@test.lindsaar.net>')
+    #  a.format #=> 'Mikel Lindsaar <mikel@test.lindsaar.net> (My email address)'
+    def format
+      parse unless @parsed
+      case
+      when tree.nil?
+        ''
+      when display_name
+        [quote_phrase(display_name), "<#{address}>", format_comments].compact.join(" ")
+      else
+        [address, format_comments].compact.join(" ")
+      end
+    end
+
+    # Returns the address that is in the address itself.  That is, the 
+    # local@domain string, without any angle brackets or the like.
+    # 
+    #  a = Address.new('Mikel Lindsaar (My email address) <mikel@test.lindsaar.net>')
+    #  a.address #=> 'mikel@test.lindsaar.net'
+    def address
+      parse unless @parsed
+      domain ? "#{local}@#{domain}" : local
+    end
+    
+    # Provides a way to assign an address to an already made Mail::Address object.
+    # 
+    #  a = Address.new
+    #  a.address = 'Mikel Lindsaar (My email address) <mikel@test.lindsaar.net>'
+    #  a.address #=> 'mikel@test.lindsaar.net'
+    def address=(value)
+      parse(value)
+    end
+    
+    # Returns the display name of the email address passed in.
+    # 
+    #  a = Address.new('Mikel Lindsaar (My email address) <mikel@test.lindsaar.net>')
+    #  a.display_name #=> 'Mikel Lindsaar'
+    def display_name
+      parse unless @parsed
+      @display_name ||= get_display_name
+      Encodings.decode_encode(@display_name.to_s, @output_type) if @display_name
+    end
+    
+    # Provides a way to assign a display name to an already made Mail::Address object.
+    # 
+    #  a = Address.new
+    #  a.address = 'mikel@test.lindsaar.net'
+    #  a.display_name = 'Mikel Lindsaar'
+    #  a.format #=> 'Mikel Lindsaar <mikel@test.lindsaar.net>'
+    def display_name=( str )
+      @display_name = str
+    end
+
+    # Returns the local part (the left hand side of the @ sign in the email address) of
+    # the address
+    # 
+    #  a = Address.new('Mikel Lindsaar (My email address) <mikel@test.lindsaar.net>')
+    #  a.local #=> 'mikel'
+    def local
+      parse unless @parsed
+      "#{obs_domain_list}#{get_local.strip}" if get_local
+    end
+
+    # Returns the domain part (the right hand side of the @ sign in the email address) of
+    # the address
+    # 
+    #  a = Address.new('Mikel Lindsaar (My email address) <mikel@test.lindsaar.net>')
+    #  a.domain #=> 'test.lindsaar.net'
+    def domain
+      parse unless @parsed
+      strip_all_comments(get_domain) if get_domain
+    end
+    
+    # Returns an array of comments that are in the email, or an empty array if there
+    # are no comments
+    # 
+    #  a = Address.new('Mikel Lindsaar (My email address) <mikel@test.lindsaar.net>')
+    #  a.comments #=> ['My email address']
+    def comments
+      parse unless @parsed
+      if get_comments.empty?
+        nil
+      else
+        get_comments.map { |c| c.squeeze(" ") }
+      end
+    end
+    
+    # Sometimes an address will not have a display name, but might have the name
+    # as a comment field after the address.  This returns that name if it exists.
+    # 
+    #  a = Address.new('mikel@test.lindsaar.net (Mikel Lindsaar)')
+    #  a.name #=> 'Mikel Lindsaar'
+    def name
+      parse unless @parsed
+      get_name
+    end
+    
+    # Returns the format of the address, or returns nothing
+    # 
+    #  a = Address.new('Mikel Lindsaar (My email address) <mikel@test.lindsaar.net>')
+    #  a.format #=> 'Mikel Lindsaar <mikel@test.lindsaar.net> (My email address)'
+    def to_s
+      parse unless @parsed
+      format
+    end
+    
+    # Shows the Address object basic details, including the Address
+    #  a = Address.new('Mikel (My email) <mikel@test.lindsaar.net>')
+    #  a.inspect #=> "#<Mail::Address:14184910 Address: |Mikel <mikel@test.lindsaar.net> (My email)| >"
+    def inspect
+      parse unless @parsed
+      "#<#{self.class}:#{self.object_id} Address: |#{to_s}| >"
+    end
+    
+    def encoded
+      @output_type = :encode
+      format
+    end
+    
+    def decoded
+      @output_type = :decode
+      format
+    end
+
+    private
+    
+    def parse(value = nil)
+      @parsed = true
+      case
+      when value.nil?
+        nil
+      when value.class == String
+        self.tree = Mail::AddressList.new(value).address_nodes.first
+      else
+        self.tree = value
+      end
+    end
+    
+    
+    def get_domain
+      if tree.respond_to?(:angle_addr)
+        @domain_text ||= tree.angle_addr.addr_spec.domain.text_value.strip
+      elsif tree.respond_to?(:domain)
+        @domain_text ||= tree.domain.text_value.strip
+      elsif tree.respond_to?(:addr_spec)
+        tree.addr_spec.domain.text_value.strip
+      else
+        nil
+      end
+    end
+
+    def strip_all_comments(string)
+      unless comments.blank?
+        comments.each do |comment|
+          string = string.gsub("(#{comment})", '')
+        end
+      end
+      string.strip
+    end
+
+    def strip_domain_comments(value)
+      unless comments.blank?
+        comments.each do |comment|
+          if get_domain && get_domain.include?("(#{comment})")
+            value = value.gsub("(#{comment})", '')
+          end
+        end
+      end
+      value.to_s.strip
+    end
+    
+    def get_comments
+      if tree.respond_to?(:comments)
+        @comments = tree.comments.map { |c| unparen(c.text_value.to_str) } 
+      else
+        @comments = []
+      end
+    end
+    
+    def get_display_name
+      if tree.respond_to?(:display_name)
+        name = unquote(tree.display_name.text_value.strip)
+        str = strip_all_comments(name.to_s)
+      elsif comments
+        if domain
+          str = strip_domain_comments(format_comments)
+        else
+          str = nil
+        end
+      else
+        nil
+      end
+      
+      if str.blank?
+        nil
+      else
+        str
+      end
+    end
+    
+    def get_name
+      if display_name
+        str = display_name
+      else
+        if comments
+          comment_text = comments.join(' ').squeeze(" ")
+          str = "(#{comment_text})"
+        end
+      end
+
+      if str.blank?
+        nil
+      else
+        unparen(str)
+      end
+    end
+    
+    # Provides access to the Treetop parse tree for this address
+    def tree
+      @tree
+    end
+    
+    def tree=(value)
+      @tree = value
+    end
+    
+    def format_comments
+      if comments
+        comment_text = comments.map {|c| escape_paren(c) }.join(' ').squeeze(" ")
+        @format_comments ||= "(#{comment_text})"
+      else
+        nil
+      end
+    end
+   
+    def obs_domain_list
+      if tree.respond_to?(:angle_addr)
+        obs = tree.angle_addr.elements.select { |e| e.respond_to?(:obs_domain_list) }
+        !obs.empty? ? obs.first.text_value : nil
+      else
+        nil
+      end
+    end
+    
+    def get_local
+      case
+      when tree.respond_to?(:local_dot_atom_text)
+        tree.local_dot_atom_text.text_value
+      when tree.respond_to?(:angle_addr)
+        tree.angle_addr.addr_spec.local_part.text_value
+      when tree.respond_to?(:addr_spec)
+        tree.addr_spec.local_part.text_value
+      else
+        tree ? tree.local_part.text_value : nil
+      end
+    end
+    
+ 
+  end
+end

data/lib/mail/elements/address_list.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+module Mail
+  class AddressList # :nodoc:
+    
+    # Mail::AddressList is the class that parses To, From and other address fields from
+    # emails passed into Mail.
+    # 
+    # AddressList provides a way to query the groups and mailbox lists of the passed in
+    # string.
+    # 
+    # It can supply all addresses in an array, or return each address as an address object.
+    # 
+    # Mail::AddressList requires a correctly formatted group or mailbox list per RFC2822 or
+    # RFC822.  It also handles all obsolete versions in those RFCs.
+    # 
+    #  list = 'ada@test.lindsaar.net, My Group: mikel@test.lindsaar.net, Bob <bob@test.lindsaar.net>;'
+    #  a = AddressList.new(list)
+    #  a.addresses    #=> [#<Mail::Address:14943130 Address: |ada@test.lindsaar.net...
+    #  a.group_names  #=> ["My Group"]
+    def initialize(string)
+      if string.blank?
+        @address_nodes = []
+        return self
+      end
+      parser = Mail::AddressListsParser.new
+      if tree = parser.parse(string)
+        @address_nodes = tree.addresses
+      else
+        raise Mail::Field::ParseError, "AddressListsParser can not parse |#{string}|\nReason was: #{parser.failure_reason}\n"
+      end
+    end
+    
+    # Returns a list of address objects from the parsed line
+    def addresses
+      @addresses ||= get_addresses.map do |address_tree|
+        Mail::Address.new(address_tree)
+      end
+    end
+    
+    # Returns a list of all recipient syntax trees that are not part of a group
+    def individual_recipients # :nodoc:
+      @individual_recipients ||= @address_nodes - group_recipients
+    end
+    
+    # Returns a list of all recipient syntax trees that are part of a group
+    def group_recipients # :nodoc:
+      @group_recipients ||= @address_nodes.select { |an| an.respond_to?(:group_name) }
+    end
+    
+    # Returns the names as an array of strings of all groups
+    def group_names # :nodoc:
+      group_recipients.map { |g| g.group_name.text_value }
+    end
+    
+    # Returns a list of address syntax trees
+    def address_nodes # :nodoc:
+      @address_nodes
+    end
+    
+    private
+    
+    def get_addresses
+      (individual_recipients + group_recipients.map { |g| get_group_addresses(g) }).flatten
+    end
+    
+    def get_group_addresses(g)
+      if g.group_list.respond_to?(:addresses)
+        g.group_list.addresses
+      else
+        []
+      end
+    end
+  end
+end

data/lib/mail/elements/content_disposition_element.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+module Mail
+  class ContentDispositionElement # :nodoc:
+    
+    include Mail::Utilities
+    
+    def initialize( string )
+      parser = Mail::ContentDispositionParser.new
+      if tree = parser.parse(cleaned(string))
+        @disposition_type = tree.disposition_type.text_value.downcase
+        @parameters = tree.parameters
+      else
+        raise Mail::Field::ParseError, "ContentDispositionElement can not parse |#{string}|\nReason was: #{parser.failure_reason}\n"
+      end
+    end
+    
+    def disposition_type
+      @disposition_type
+    end
+    
+    def parameters
+      @parameters
+    end
+    
+    def cleaned(string)
+      string =~ /(.+);\s*$/ ? $1 : string
+    end
+    
+  end
+end

data/lib/mail/elements/content_location_element.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+module Mail
+  class ContentLocationElement # :nodoc:
+    
+    include Mail::Utilities
+    
+    def initialize( string )
+      parser = Mail::ContentLocationParser.new
+      if tree = parser.parse(string)
+        @location = tree.location.text_value
+      else
+        raise Mail::Field::ParseError, "ContentLocationElement can not parse |#{string}|\nReason was: #{parser.failure_reason}\n"
+      end
+    end
+    
+    def location
+      @location
+    end
+    
+    def to_s(*args)
+      location.to_s
+    end
+    
+  end
+end

data/lib/mail/elements/content_transfer_encoding_element.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+module Mail
+  class ContentTransferEncodingElement
+    
+    include Mail::Utilities
+    
+    def initialize( string )
+      parser = Mail::ContentTransferEncodingParser.new
+      case
+      when string.blank?
+        @encoding = ''
+      when tree = parser.parse(string.to_s.downcase)
+        @encoding = tree.encoding.text_value
+      else
+        raise Mail::Field::ParseError, "ContentTransferEncodingElement can not parse |#{string}|\nReason was: #{parser.failure_reason}\n"
+      end
+    end
+    
+    def encoding
+      @encoding
+    end
+    
+  end
+end

data/lib/mail/elements/content_type_element.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+module Mail
+  class ContentTypeElement # :nodoc:
+    
+    include Mail::Utilities
+    
+    def initialize( string )
+      parser = Mail::ContentTypeParser.new
+      if tree = parser.parse(cleaned(string))
+        @main_type = tree.main_type.text_value.downcase
+        @sub_type = tree.sub_type.text_value.downcase
+        @parameters = tree.parameters
+      else
+        raise Mail::Field::ParseError, "ContentTypeElement can not parse |#{string}|\nReason was: #{parser.failure_reason}\n"
+      end
+    end
+    
+    def main_type
+      @main_type
+    end
+    
+    def sub_type
+      @sub_type
+    end
+    
+    def parameters
+      @parameters
+    end
+    
+    def cleaned(string)
+      string =~ /(.+);\s*$/ ? $1 : string
+    end
+    
+  end
+end

data/lib/mail/elements/date_time_element.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+module Mail
+  class DateTimeElement # :nodoc:
+    
+    include Mail::Utilities
+    
+    def initialize( string )
+      parser = Mail::DateTimeParser.new
+      if tree = parser.parse(string)
+        @date_string = tree.date.text_value
+        @time_string = tree.time.text_value
+      else
+        raise Mail::Field::ParseError, "DateTimeElement can not parse |#{string}|\nReason was: #{parser.failure_reason}\n"
+      end
+    end
+    
+    def date_string
+      @date_string
+    end
+    
+    def time_string
+      @time_string
+    end
+    
+  end
+end

data/lib/mail/elements/envelope_from_element.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+module Mail
+  class EnvelopeFromElement
+    
+    include Mail::Utilities
+    
+    def initialize( string )
+      parser = Mail::EnvelopeFromParser.new
+      if @tree = parser.parse(string)
+        @address = tree.addr_spec.text_value.strip
+        @date_time = ::DateTime.parse("#{tree.ctime_date.text_value}")
+      else
+        raise Mail::Field::ParseError, "EnvelopeFromElement can not parse |#{string}|\nReason was: #{parser.failure_reason}\n"
+      end
+    end
+    
+    def tree
+      @tree
+    end
+    
+    def date_time
+      @date_time
+    end
+    
+    def address
+      @address
+    end
+    
+    def to_s(*args)
+      "#{@info}; #{@date_time.to_s(*args)}"
+    end
+    
+  end
+end

data/lib/mail/elements/message_ids_element.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+module Mail
+  class MessageIdsElement
+    
+    include Mail::Utilities
+    
+    def initialize(string)
+      parser = Mail::MessageIdsParser.new
+      if tree = parser.parse(string)
+        @message_ids = tree.message_ids.map { |msg_id| clean_msg_id(msg_id.text_value) }
+      else
+        raise Mail::Field::ParseError, "MessageIdsElement can not parse |#{string}|\nReason was: #{parser.failure_reason}\n"
+      end
+    end
+    
+    def message_ids
+      @message_ids
+    end
+    
+    def message_id
+      @message_ids.first
+    end
+    
+    def clean_msg_id( val )
+      val =~ /.*<(.*)>.*/ ; $1
+    end
+
+  end
+end

data/lib/mail/elements/mime_version_element.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+module Mail
+  class MimeVersionElement
+    
+    include Mail::Utilities
+    
+    def initialize( string )
+      parser = Mail::MimeVersionParser.new
+      if tree = parser.parse(string)
+        @major = tree.major.text_value
+        @minor = tree.minor.text_value
+      else
+        raise Mail::Field::ParseError, "MimeVersionElement can not parse |#{string}|\nReason was: #{parser.failure_reason}\n"
+      end
+    end
+    
+    def major
+      @major
+    end
+    
+    def minor
+      @minor
+    end
+    
+  end
+end

data/lib/mail/elements/phrase_list.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+module Mail
+  class PhraseList
+    
+    include Mail::Utilities
+    
+    def initialize(string)
+      parser = Mail::PhraseListsParser.new
+      if tree = parser.parse(string)
+        @phrases = tree.phrases
+      else
+        raise Mail::Field::ParseError, "PhraseList can not parse |#{string}|\nReason was: #{parser.failure_reason}\n"
+      end
+    end
+    
+    def phrases
+      @phrases.map { |p| unquote(p.text_value) }
+    end
+
+  end
+end

data/lib/mail/elements/received_element.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+module Mail
+  class ReceivedElement
+    
+    include Mail::Utilities
+    
+    def initialize( string )
+      parser = Mail::ReceivedParser.new
+      if tree = parser.parse(string)
+        @date_time = ::DateTime.parse("#{tree.date_time.date.text_value} #{tree.date_time.time.text_value}")
+        @info = tree.name_val_list.text_value
+      else
+        raise Mail::Field::ParseError, "ReceivedElement can not parse |#{string}|\nReason was: #{parser.failure_reason}\n"
+      end
+    end
+    
+    def date_time
+      @date_time
+    end
+    
+    def info
+      @info
+    end
+    
+    def to_s(*args)
+      "#{@info}; #{@date_time.to_s(*args)}"
+    end
+    
+  end
+end

data/lib/mail/elements.rb

@@ -0,0 +1,14 @@
+module Mail
+  autoload :Address, 'mail/elements/address'
+  autoload :AddressList, 'mail/elements/address_list'
+  autoload :ContentDispositionElement, 'mail/elements/content_disposition_element'
+  autoload :ContentLocationElement, 'mail/elements/content_location_element'
+  autoload :ContentTransferEncodingElement, 'mail/elements/content_transfer_encoding_element'
+  autoload :ContentTypeElement, 'mail/elements/content_type_element'
+  autoload :DateTimeElement, 'mail/elements/date_time_element'
+  autoload :EnvelopeFromElement, 'mail/elements/envelope_from_element'
+  autoload :MessageIdsElement, 'mail/elements/message_ids_element'
+  autoload :MimeVersionElement, 'mail/elements/mime_version_element'
+  autoload :PhraseList, 'mail/elements/phrase_list'
+  autoload :ReceivedElement, 'mail/elements/received_element'
+end