Module: Mail::Utilities

Includes:
Patterns
Included in:
Address, ContentDispositionElement, ContentLocationElement, ContentTransferEncodingElement, ContentTypeElement, DateTimeElement, Encodings, EnvelopeFromElement, Header, Message, MessageIdsElement, MimeVersionElement, ParameterHash, PhraseList, ReceivedElement, StructuredField, UnstructuredField
Defined in:
lib/mail/utilities.rb

Constant Summary

Constants included from Patterns

Patterns::ATOM_UNSAFE, Patterns::CONTROL_CHAR, Patterns::CRLF, Patterns::FIELD_BODY, Patterns::FIELD_LINE, Patterns::FIELD_NAME, Patterns::FIELD_SPLIT, Patterns::FWS, Patterns::HEADER_LINE, Patterns::PHRASE_UNSAFE, Patterns::QP_SAFE, Patterns::QP_UNSAFE, Patterns::TEXT, Patterns::TOKEN_UNSAFE, Patterns::WSP

Instance Method Summary collapse

Instance Method Details

#atom_safe?(str) ⇒ Boolean

Returns true if the string supplied is free from characters not allowed as an ATOM



7
8
9
 
# File 'lib/mail/utilities.rb', line 7

def atom_safe?( str )
  not ATOM_UNSAFE === str
end

#bracket(str) ⇒ Object

Wraps a string in angle brackets and escapes any that are in the string itself

Example:

bracket( 'This is a string' ) #=> '<This is a string>'



101
102
103
 
# File 'lib/mail/utilities.rb', line 101

def bracket( str )
  RubyVer.bracket( str )
end

#capitalize_field(str) ⇒ Object

Capitalizes a string that is joined by hyphens correctly.

Example:

string = 'resent-from-field'
capitalize_field( string ) #=> 'Resent-From-Field'



155
156
157
 
# File 'lib/mail/utilities.rb', line 155

def capitalize_field( str )
  str.to_s.split("-").map { |v| v.capitalize }.join("-")
end

#constantize(str) ⇒ Object

Takes an underscored word and turns it into a class name

Example:

constantize("hello") #=> "Hello"
constantize("hello-there") #=> "HelloThere"
constantize("hello-there-mate") #=> "HelloThereMate"



166
167
168
 
# File 'lib/mail/utilities.rb', line 166

def constantize( str )
  str.to_s.split(/[-_]/).map { |v| v.capitalize }.to_s
end

#dasherize(str) ⇒ Object

Swaps out all underscores (_) for hyphens (-) good for stringing from symbols a field name.

Example:

string = :resent_from_field
dasherize ( string ) #=> 'resent_from_field'



177
178
179
 
# File 'lib/mail/utilities.rb', line 177

def dasherize( str )
  str.to_s.gsub('_', '-')
end

#dquote(str) ⇒ Object

Wraps supplied string in double quotes and applies -escaping as necessary, unless it is already wrapped.

Example:

string = 'This is a string'
dquote(string) #=> '"This is a string"'

string = 'This is "a string"'
dquote(string #=> '"This is \"a string\"'



54
55
56
 
# File 'lib/mail/utilities.rb', line 54

def dquote( str )
  '"' + unquote(str).gsub(/[\\"]/n) {|s| '\\' + s } + '"'
end

#escape_paren(str) ⇒ Object

Escape parenthesies in a string

Example:

str = 'This is (a) string'
escape_paren( str ) #=> 'This is \(a\) string'



122
123
124
 
# File 'lib/mail/utilities.rb', line 122

def escape_paren( str )
  RubyVer.escape_paren( str )
end

#map_lines(str, &block) ⇒ Object 



194
195
196
197
198
199
200
 
# File 'lib/mail/utilities.rb', line 194

def map_lines( str, &block )
  results = []
  str.each_line do |line|
    results << yield(line)
  end
  results
end

#map_with_index(enum, &block) ⇒ Object 



202
203
204
205
206
207
208
 
# File 'lib/mail/utilities.rb', line 202

def map_with_index( enum, &block )
  results = []
  enum.each_with_index do |token, i|
    results[i] = yield(token, i)
  end
  results
end

#match_to_s(obj1, obj2) ⇒ Object

Matches two objects with their to_s values case insensitively

Example:

obj2 = "This_is_An_object"
obj1 = :this_IS_an_object
match_to_s( obj1, obj2 ) #=> true



145
146
147
 
# File 'lib/mail/utilities.rb', line 145

def match_to_s( obj1, obj2 )
  obj1.to_s.casecmp(obj2.to_s) == 0
end

#paren(str) ⇒ Object

Wraps a string in parenthesis and escapes any that are in the string itself.

Example:

paren( 'This is a string' ) #=> '(This is a string)'



81
82
83
 
# File 'lib/mail/utilities.rb', line 81

def paren( str )
  RubyVer.paren( str )
end

#quote_atom(str) ⇒ Object

If the string supplied has ATOM unsafe characters in it, will return the string quoted in double quotes, otherwise returns the string unmodified



13
14
15
 
# File 'lib/mail/utilities.rb', line 13

def quote_atom( str )
  atom_safe?( str ) ? str : dquote(str)
end

#quote_phrase(str) ⇒ Object

If the string supplied has PHRASE unsafe characters in it, will return the string quoted in double quotes, otherwise returns the string unmodified



19
20
21
22
23
24
25
26
27
28
29
30
31
 
# File 'lib/mail/utilities.rb', line 19

def quote_phrase( str )
  if RUBY_VERSION >= '1.9'
    original_encoding = str.encoding
    str.force_encoding('ASCII-8BIT')
    if (PHRASE_UNSAFE === str)
      dquote(str).force_encoding(original_encoding)
    else
      str.force_encoding(original_encoding)
    end
  else
    (PHRASE_UNSAFE === str) ? dquote(str) : str
  end
end

#quote_token(str) ⇒ Object

If the string supplied has TOKEN unsafe characters in it, will return the string quoted in double quotes, otherwise returns the string unmodified



40
41
42
 
# File 'lib/mail/utilities.rb', line 40

def quote_token( str )
  token_safe?( str ) ? str : dquote(str)
end

#token_safe?(str) ⇒ Boolean

Returns true if the string supplied is free from characters not allowed as a TOKEN



34
35
36
 
# File 'lib/mail/utilities.rb', line 34

def token_safe?( str )
  not TOKEN_UNSAFE === str
end

#unbracket(str) ⇒ Object

Unwraps a string from being wrapped in parenthesis

Example:

str = '<This is a string>'
unbracket( str ) #=> 'This is a string'



111
112
113
114
 
# File 'lib/mail/utilities.rb', line 111

def unbracket( str )
  match = str.match(/^\<(.*?)\>$/)
  match ? match[1] : str
end

#underscoreize(str) ⇒ Object

Swaps out all hyphens (-) for underscores (_) good for stringing to symbols a field name.

Example:

string = :resent_from_field
underscoreize ( string ) #=> 'resent_from_field'



188
189
190
 
# File 'lib/mail/utilities.rb', line 188

def underscoreize( str )
  str.to_s.downcase.gsub('-', '_')
end

#unparen(str) ⇒ Object

Unwraps a string from being wrapped in parenthesis

Example:

str = '(This is a string)'
unparen( str ) #=> 'This is a string'



91
92
93
94
 
# File 'lib/mail/utilities.rb', line 91

def unparen( str )
  match = str.match(/^\((.*?)\)$/)
  match ? match[1] : str
end

#unquote(str) ⇒ Object

Unwraps supplied string from inside double quotes and removes any -escaping.

Example:

string = '"This is a string"'
unquote(string) #=> 'This is a string'

string = '"This is \"a string\""'
unqoute(string) #=> 'This is "a string"'



68
69
70
71
72
73
74
 
# File 'lib/mail/utilities.rb', line 68

def unquote( str )
  if str =~ /^"(.*?)"$/
    $1.gsub(/\\(.)/, '\1')
  else
    str
  end
end

#uri_escape(str) ⇒ Object 



126
127
128
 
# File 'lib/mail/utilities.rb', line 126

def uri_escape( str )
  uri_parser.escape(str)
end

#uri_parser ⇒ Object 



134
135
136
 
# File 'lib/mail/utilities.rb', line 134

def uri_parser
  @uri_parser ||= URI.const_defined?(:Parser) ? URI::Parser.new : URI
end

#uri_unescape(str) ⇒ Object 



130
131
132
 
# File 'lib/mail/utilities.rb', line 130

def uri_unescape( str )
  uri_parser.unescape(str)
end