Class: String

Inherits:
Object show all
Includes:
Style
Defined in:
lib/extensions/string.rb

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.randomize(length = 10) ⇒ Object 



170
171
172
173
174
175
 
# File 'lib/extensions/string.rb', line 170

def self.randomize(length = 10)
  chars = ("A".."H").to_a + ("J".."N").to_a + ("P".."T").to_a + ("W".."Z").to_a + ("3".."9").to_a
  newpass = ""
  1.upto(length) { |i| newpass << chars[rand(chars.size-1)] }
  return newpass.upcase
end

Instance Method Details

#breakify(every = 30) ⇒ Object

makes long strings of unbroken characters wrap inside elements (hopefully! tested in Safari, Firefox, and IE for Windows) For documentation about this kind of workaround to this browser compatibility problem please see the following URL’s: www.quirksmode.org/oddsandends/wbr.html krijnhoetmer.nl/stuff/css/word-wrap-break-word/ note: if the txt has spaces, this will only try to break up runs of non-space characters longer than “every” characters



127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
 
# File 'lib/extensions/string.rb', line 127

def breakify(every = 30)
  every = 1 if every < 1
  text = self
  textile_regex = /([^\"]+\"):([^:]*:[\/\/]{0,1}[^ ]*)/
  long_regex = /\S{#{every},}/
  brokentxt = text.gsub(long_regex) do |longword|
    if longword =~ textile_regex #if the longword is a textile link...ignore and recheck for the link text only
      textile_link = textile_regex.match(longword)[0]
      link_text = textile_regex.match(longword)[1]

      if link_text[0].to_i == 34 #adds the double quote back if missing from above regex
        longword = link_text
      else
        textile_link = "\"" + textile_link
        longword = "\"" + link_text
      end

      if longword =~ long_regex #link text is long...allow break
        textile_link.scan(/.{1,#{every}}/).join("<wbr/>")
      else
        textile_link #the url is what triggered the match...so leave it alone
      end
    else
      longword.scan(/.{1,#{every}}/).join("<wbr/>") #no textile link matched
    end
  end
  #text = %Q[<span style='word-wrap:break-word;wbr:after{content:"\\00200B"}'>#{brokentxt}</span>]
  #brokentxt.gsub("<wbr/>", "<br />")
  brokentxt.gsub("<wbr/>", " ")
end

#breakify!(every = 30) ⇒ Object 



158
159
160
 
# File 'lib/extensions/string.rb', line 158

def breakify!(every = 30)
  self.replace(self.breakify(every))
end

#constantize ⇒ Object

Returns a constant of the string.

Examples:

"User".constantize # => User
"HomeController".constantize # => HomeController
"Mack::Configuration" # => Mack::Configuration



83
84
85
 
# File 'lib/extensions/string.rb', line 83

def constantize
  Module.instance_eval("::#{self}")
end

#hexdigest ⇒ Object 



162
163
164
 
# File 'lib/extensions/string.rb', line 162

def hexdigest
  Digest::SHA1.hexdigest(self.downcase)
end

#hexdigest! ⇒ Object 



166
167
168
 
# File 'lib/extensions/string.rb', line 166

def hexdigest!
  self.replace(self.hexdigest)
end

#linkify(enabled = true, options = {}, &block) ⇒ Object 



87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
# File 'lib/extensions/string.rb', line 87

def linkify(enabled = true, options = {}, &block)
  text = self.dup
  m = text.match(/\"([^"]+)\"\:([^:]+\:\S+)/)
  until m.nil?
    y = m.to_s
    t = m[1]
    url = m[2]

    # The code below handles punctuation or p tags being mistakenly added to the url when the link is at the end of a sentence or body
    url_punct_match = /\W*[&nbsp;]*[\<\/p\>]*$/.match(url)
    punct = ''
    if url_punct_match && url_punct_match[0] != ""
      url.chomp!(url_punct_match[0])
      punct = url_punct_match[0] unless url_punct_match == "="
    end

    if block_given?
      if enabled
        ret = yield t, url, options
        text.gsub!(y, ret)
      else
        text.gsub!(y, t.to_s)
      end
    else
      if enabled
        text.gsub!(y, "<a href=\"#{url}\" #{options.join("%s=\"%s\"", " ")}>#{t}</a>#{punct}")# punct places punctuation back into proper place
      else
        text.gsub!(y, t.to_s)
      end
    end
    m = text.match(/\"([^"]+)\"\:([^:]+\:\S+)/)
  end
  return text
end

#methodize ⇒ Object

Raises:

  • (NameError) 


4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
# File 'lib/extensions/string.rb', line 4

def methodize
  x = self
  
  # if we get down to a nil or an empty string raise an exception! 
  raise NameError.new("#{self} cannot be converted to a valid method name!") if x.nil? || x == ''
  
  # get rid of the big stuff in the front/back
  x.strip!
  
  # if we get down to a nil or an empty string raise an exception! 
  raise NameError.new("#{self} cannot be converted to a valid method name!") if x.nil? || x == ''
  
  x = x.underscore
  
  # get rid of spaces and make the _
  x.gsub!(' ', '_')
  # get rid of everything that isn't 'safe' a-z, 0-9, ?, !, =, _
  x.gsub!(/([^ a-zA-Z0-9\_\?\!\=]+)/n, '_')
  
  # if we get down to a nil or an empty string raise an exception! 
  raise NameError.new("#{self} cannot be converted to a valid method name!") if x.nil? || x == ''
  
  # condense multiple 'safe' non a-z chars to just one.
  # ie. ___ becomes _ !!!! becomes ! etc...
  [' ', '_', '?', '!', "="].each do |c|
    x.squeeze!(c)
  end
  
  # if we get down to a nil or an empty string raise an exception! 
  raise NameError.new("#{self} cannot be converted to a valid method name!") if x.nil? || x == ''
  
  #down case the whole thing
  x.downcase!
  
  # get rid of any characters at the beginning that aren't a-z
  while !x.match(/^[a-z]/)
    x.slice!(0)
    
    # if we get down to a nil or an empty string raise an exception! 
    raise NameError.new("#{self} cannot be converted to a valid method name!") if x.nil? || x == ''
  end
  
  # let's trim this bad boy down a bit now that we've cleaned it up, somewhat.
  # we should do this before cleaning up the end character, because it's possible to end up with a 
  # bad char at the end if you trim too late.
  x = x[0..100] if x.length > 100
  
  # get rid of any characters at the end that aren't safe
  while !x.match(/[a-z0-9\?\!\=]$/)
    x.slice!(x.length - 1)
    # if we get down to a nil or an empty string raise an exception! 
    raise NameError.new("#{self} cannot be converted to a valid method name!") if x.nil? || x == ''
  end
  
  # if we get down to a nil or an empty string raise an exception! 
  raise NameError.new("#{self} cannot be converted to a valid method name!") if x.nil? || x == ''
  
  # let's get rid of characters that don't belong in the 'middle' of the method.
  orig_middle = x[1..(x.length - 2)]
  n_middle = orig_middle.dup
  
  ['?', '!', "="].each do |c|
    n_middle.gsub!(c, "_")
  end
  
  # the previous gsub can leave us with multiple underscores that need cleaning up.
  n_middle.squeeze!("_")
  
  x.gsub!(orig_middle, n_middle)
  x.gsub!("_=", "=")
  x
end

#uri_escape ⇒ Object

Performs URI escaping so that you can construct proper query strings faster. Use this rather than the cgi.rb version since it’s faster. (Stolen from Camping).



180
181
182
183
184
 
# File 'lib/extensions/string.rb', line 180

def uri_escape
  self.gsub(/([^ a-zA-Z0-9_.-]+)/n) {
    '%'+$1.unpack('H2'*$1.size).join('%').upcase
  }.tr(' ', '+')
end

#uri_unescape ⇒ Object

Unescapes a URI escaped string. (Stolen from Camping).



187
188
189
190
191
 
# File 'lib/extensions/string.rb', line 187

def uri_unescape
  self.tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/n){
    [$1.delete('%')].pack('H*')
  }
end