Parent

Included Modules

Class/Module Index [+]

Quicksearch

TMail::Address

Class Address

Provides a complete handling library for email addresses. Can parse a string of an address directly or take in preformatted addresses themselves. Allows you to add and remove phrases from the front of the address and provides a compare function for email addresses.

Parsing and Handling a Valid Address:

Just pass the email address in as a string to Address.parse:

email = TMail::Address.parse('Mikel Lindsaar <mikel@lindsaar.net>')
#=> #<TMail::Address mikel@lindsaar.net>
email.address
#=> "mikel@lindsaar.net"
email.local
#=> "mikel"
email.domain
#=> "lindsaar.net"
email.name             # Aliased as phrase as well
#=> "Mikel Lindsaar"

Detecting an Invalid Address

If you want to check the syntactical validity of an email address, just pass it to Address.parse and catch any SyntaxError:

begin
  TMail::Address.parse("mikel   2@@@@@ me .com")
rescue TMail::SyntaxError
  puts("Invalid Email Address Detected")
else
  puts("Address is valid")
end
#=> "Invalid Email Address Detected"

Public Class Methods

new( local, domain ) click to toggle source

Address.new(local, domain)

Accepts:

  • local - Left of the at symbol

  • domain - Array of the domain split at the periods.

For example:

Address.new("mikel", ["lindsaar", "net"])
#=> "#<TMail::Address mikel@lindsaar.net>"
# File lib/tmail/address.rb, line 103
def initialize( local, domain )
  if domain
    domain.each do |s|
      raise SyntaxError, 'empty word in domain' if s.empty?
    end
  end
  
  # This is to catch an unquoted "@" symbol in the local part of the
  # address.  Handles addresses like <"@"@me.com> and makes sure they
  # stay like <"@"@me.com> (previously were becoming <@@me.com>)
  if local && (local.join == '@' || local.join =~ /\A[^"].*?@.*?[^"]\Z/)
    @local = "\"#{local.join}\""
  else
    @local = local
  end

  @domain = domain
  @name   = nil
  @routes = []
end
parse( str ) click to toggle source

Sometimes you need to parse an address, TMail can do it for you and provide you with a fairly robust method of detecting a valid address.

Takes in a string, returns a TMail::Address object.

Raises a TMail::SyntaxError on invalid email format

# File lib/tmail/address.rb, line 83
def Address.parse( str )
  Parser.parse :ADDRESS, str
end

Public Instance Methods

==( other ) click to toggle source

Provides == function to the email. Only checks the actual address and ignores the name/phrase component

For Example

addr1 = TMail::Address.parse("My Address <mikel@lindsaar.net>")
#=> "#<TMail::Address mikel@lindsaar.net>"
addr2 = TMail::Address.parse("Another <mikel@lindsaar.net>")
#=> "#<TMail::Address mikel@lindsaar.net>"
addr1 == addr2
#=> true
# File lib/tmail/address.rb, line 238
def ==( other )
  other.respond_to? :spec and self.spec == other.spec
end
Also aliased as: eql?
address() click to toggle source
Alias for: spec
domain() click to toggle source

Returns the domain part of the email address

For Example:

email = TMail::Address.parse("mikel@lindsaar.net")
email.local
#=> "lindsaar.net"
# File lib/tmail/address.rb, line 203
def domain
  return nil unless @domain
  join_domain(@domain)
end
dup() click to toggle source

Duplicates a TMail::Address object returning the duplicate

addr1 = TMail::Address.parse("mikel@lindsaar.net")
addr2 = addr1.dup
addr1.id == addr2.id
#=> false
# File lib/tmail/address.rb, line 260
def dup
  obj = self.class.new(@local.dup, @domain.dup)
  obj.name = @name.dup if @name
  obj.routes.replace @routes
  obj
end
eql?( other ) click to toggle source
Alias for: ==
hash() click to toggle source

Provides a unique hash value for this record against the local and domain parts, ignores the name/phrase value

email = TMail::Address.parse("mikel@lindsaar.net")
email.hash
#=> 18767598
# File lib/tmail/address.rb, line 250
def hash
  @local.hash ^ @domain.hash
end
local() click to toggle source

Returns the local part of the email address

For Example:

email = TMail::Address.parse("mikel@lindsaar.net")
email.local
#=> "mikel"
# File lib/tmail/address.rb, line 185
def local
  return nil unless @local
  return '""' if @local.size == 1 and @local[0].empty?
  # Check to see if it is an array before trying to map it
  if @local.respond_to?(:map)
    @local.map {|i| quote_atom(i) }.join('.')
  else
    quote_atom(@local)
  end
end
name() click to toggle source

Provides the name or 'phrase' of the email address.

For Example:

email = TMail::Address.parse("Mikel Lindsaar <mikel@lindsaar.net>")
email.name
#=> "Mikel Lindsaar"
# File lib/tmail/address.rb, line 131
def name
  @name
end
name=( str ) click to toggle source

Setter method for the name or phrase of the email

For Example:

email = TMail::Address.parse("mikel@lindsaar.net")
email.name
#=> nil
email.name = "Mikel Lindsaar"
email.to_s
#=> "Mikel Lindsaar <mikel@me.com>"
# File lib/tmail/address.rb, line 145
def name=( str )
  @name = str
  @name = nil if str and str.empty?
end
routes() click to toggle source

This is still here from RFC 822, and is now obsolete per RFC2822 Section 4.

"When interpreting addresses, the route portion SHOULD be ignored."

It is still here, so you can access it.

Routes return the route portion at the front of the email address, if any.

For Example:

email = TMail::Address.parse( "<@sa,@another:Mikel@me.com>")
=> #<TMail::Address Mikel@me.com>
email.to_s
=> "<@sa,@another:Mikel@me.com>"
email.routes
=> ["sa", "another"]
# File lib/tmail/address.rb, line 170
def routes
  @routes
end
spec() click to toggle source

Returns the full specific address itself

For Example:

email = TMail::Address.parse("mikel@lindsaar.net")
email.address
#=> "mikel@lindsaar.net"
# File lib/tmail/address.rb, line 215
def spec
  s = self.local
  d = self.domain
  if s and d
    s + '@' + d
  else
    s
  end
end
Also aliased as: address

[Validate]

Generated with the Darkfish Rdoc Generator 2.