Class: String

Inherits:
Object show all
Defined in:
lib/mail/core_extensions/string.rb,
lib/mail/core_extensions/shellwords.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

US_ASCII_REGEXP =

Provides all strings with the Ruby 1.9 method of .ascii_only? and returns true or false

%Q{\x00-\x7f}

Instance Method Summary collapse

Instance Method Details

#ascii_only? ⇒ Boolean

Returns:

  • (Boolean) 


19
20
21
 
# File 'lib/mail/core_extensions/string.rb', line 19

def ascii_only?
  !(self =~ /[^#{US_ASCII_REGEXP}]/)
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) 


11
12
13
 
# File 'lib/mail/core_extensions/string.rb', line 11

def blank?
  self !~ /\S/
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) 


24
25
26
 
# File 'lib/mail/core_extensions/string.rb', line 24

def not_ascii_only?
  !ascii_only?
end

#shellescape ⇒ Object

call-seq:

str.shellescape => string

Escapes str so that it can be safely used in a Bourne shell command line. See Shellwords::shellescape for details.



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

def shellescape
  Shellwords.escape(self)
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 



3
4
5
 
# File 'lib/mail/core_extensions/string.rb', line 3

def to_crlf
  gsub(/\n|\r\n|\r/) { "\r\n" }
end

#to_lf ⇒ Object 



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

def to_lf
  gsub(/\n|\r\n|\r/) { "\n" }
end