Class: String

Inherits:
Object show all
Defined in:
lib/mail/core_extensions/string.rb,
lib/mail/core_extensions/string/access.rb,
lib/mail/core_extensions/string/multibyte.rb

Overview

This is an almost cut and paste from ActiveSupport v3.0.6, copied in here so that Mail itself does not depend on ActiveSupport to avoid versioning conflicts

Constant Summary collapse

CRLF_REGEX =

This 1.9 only regex can save a reasonable amount of time (~20%) by not matching “rn” so the string is returned unchanged in the common case.

/\n|\r\n|\r/
MATCH_NON_US_ASCII = 
/[^\x00-\x7f]/

Instance Method Summary collapse

Instance Method Details

#ascii_only? ⇒ Boolean

Backport from Ruby 1.9 checks for non-us-ascii characters.

Returns:

  • (Boolean) 


29
30
31
 
# File 'lib/mail/core_extensions/string.rb', line 29

def ascii_only?
  self !~ MATCH_NON_US_ASCII
end

#at(position) ⇒ Object

Returns the character at the position treating the string as an array (where 0 is the first character).

Examples:

"hello".at(0)  # => "h"
"hello".at(4)  # => "o"
"hello".at(10) # => ERROR if < 1.9, nil in 1.9



16
17
18
 
# File 'lib/mail/core_extensions/string/access.rb', line 16

def at(position)
  mb_chars[position, 1].to_s
end

#blank? ⇒ Boolean

Returns:

  • (Boolean) 


22
23
24
 
# File 'lib/mail/core_extensions/string.rb', line 22

def blank?
  self !~ /\S/
end

#constantize ⇒ Object

:nodoc:



123
124
125
126
127
128
129
130
131
132
 
# File 'lib/mail/core_extensions/string/access.rb', line 123

def constantize
  names = self.split('::')
  names.shift if names.empty? || names.first.empty?

  constant = Object
  names.each do |name|
    constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
  end
  constant
end

#first(limit = 1) ⇒ Object

Returns the first character of the string or the first limit characters.

Examples:

"hello".first     # => "h"
"hello".first(2)  # => "he"
"hello".first(10) # => "hello"



46
47
48
49
50
51
52
53
54
 
# File 'lib/mail/core_extensions/string/access.rb', line 46

def first(limit = 1)
  if limit == 0
    ''
  elsif limit >= size
    self
  else
    mb_chars[0...limit].to_s
  end
end

#from(position) ⇒ Object

Returns the remaining of the string from the position treating the string as an array (where 0 is the first character).

Examples:

"hello".from(0)  # => "hello"
"hello".from(2)  # => "llo"
"hello".from(10) # => "" if < 1.9, nil in 1.9



26
27
28
 
# File 'lib/mail/core_extensions/string/access.rb', line 26

def from(position)
  mb_chars[position..-1].to_s
end

#is_utf8? ⇒ Boolean

Returns true if the string has UTF-8 semantics (a String used for purely byte resources is unlikely to have them), returns false otherwise.

Returns:

  • (Boolean) 


53
54
55
56
57
58
59
60
61
62
 
# File 'lib/mail/core_extensions/string/multibyte.rb', line 53

def is_utf8? #:nodoc
  case encoding
  when Encoding::UTF_8
    valid_encoding?
  when Encoding::ASCII_8BIT, Encoding::US_ASCII
    dup.force_encoding(Encoding::UTF_8).valid_encoding?
  else
    false
  end
end

#last(limit = 1) ⇒ Object

Returns the last character of the string or the last limit characters.

Examples:

"hello".last     # => "o"
"hello".last(2)  # => "lo"
"hello".last(10) # => "hello"



62
63
64
65
66
67
68
69
70
 
# File 'lib/mail/core_extensions/string/access.rb', line 62

def last(limit = 1)
  if limit == 0
    ''
  elsif limit >= size
    self
  else
    mb_chars[(-limit)..-1].to_s
  end
end

#mb_chars ⇒ Object

Multibyte proxy

mb_chars is a multibyte safe proxy for string methods.

In Ruby 1.8 and older it creates and returns an instance of the Mail::Multibyte::Chars class which encapsulates the original string. A Unicode safe version of all the String methods are defined on this proxy class. If the proxy class doesn’t respond to a certain method, it’s forwarded to the encapsuled string.

name = 'Claus Müller'
name.reverse # => "rell??M sualC"
name.length  # => 13

name.mb_chars.reverse.to_s # => "rellüM sualC"
name.mb_chars.length       # => 12

In Ruby 1.9 and newer mb_chars returns self because String is (mostly) encoding aware. This means that it becomes easy to run one version of your code on multiple Ruby versions.

Method chaining

All the methods on the Chars proxy which normally return a string will return a Chars object. This allows method chaining on the result of any of these methods.

name.mb_chars.reverse.length # => 12

Interoperability and configuration

The Chars object tries to be as interchangeable with String objects as possible: sorting and comparing between String and Char work like expected. The bang! methods change the internal string representation in the Chars object. Interoperability problems can be resolved easily with a to_s call.

For more information about the methods defined on the Chars proxy see Mail::Multibyte::Chars. For information about how to change the default Multibyte behaviour see Mail::Multibyte.



45
46
47
48
49
50
51
 
# File 'lib/mail/core_extensions/string/multibyte.rb', line 45

def mb_chars
  if Mail::Multibyte.proxy_class.consumes?(self)
    Mail::Multibyte.proxy_class.new(self)
  else
    self
  end
end

#not_ascii_only? ⇒ Boolean

Returns:

  • (Boolean) 


36
37
38
 
# File 'lib/mail/core_extensions/string.rb', line 36

def not_ascii_only?
  !ascii_only?
end

#to(position) ⇒ Object

Returns the beginning of the string up to the position treating the string as an array (where 0 is the first character).

Examples:

"hello".to(0)  # => "h"
"hello".to(2)  # => "hel"
"hello".to(10) # => "hello"



36
37
38
 
# File 'lib/mail/core_extensions/string/access.rb', line 36

def to(position)
  mb_chars[0..position].to_s
end

#to_crlf ⇒ Object 



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

def to_crlf
  to_str.gsub(CRLF_REGEX, "\r\n")
end

#to_lf ⇒ Object 



17
18
19
 
# File 'lib/mail/core_extensions/string.rb', line 17

def to_lf
  to_str.gsub(/\r\n|\r/, "\n")
end