Class: String

Inherits:
Object show all
Defined in:
lib/m_string.rb

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.pluralize_word(num, vals = ["is", "are"]) ⇒ Object

Returns “is” or “are” based on the number, i.e. “i=6; There #isare(i) #i topics here.”



130
131
132
133
 
# File 'lib/m_string.rb', line 130

def self.pluralize_word(num, vals = ["is", "are"])
  return vals[0] if num.to_i==1
  return vals[1]
end

.randomize(length = 10) ⇒ Object 



217
218
219
220
221
222
 
# File 'lib/m_string.rb', line 217

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



148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
 
# File 'lib/m_string.rb', line 148

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 



179
180
181
 
# File 'lib/m_string.rb', line 179

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

#capitalize_all_words ⇒ Object 



239
240
241
 
# File 'lib/m_string.rb', line 239

def capitalize_all_words
  self.gsub(/\b\w/) {|s| s.upcase}
end

#capitalize_all_words! ⇒ Object 



243
244
245
 
# File 'lib/m_string.rb', line 243

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

#ends_with?(x) ⇒ Boolean

Returns:

  • (Boolean) 


125
126
127
 
# File 'lib/m_string.rb', line 125

def ends_with?(x)
  self.match(/#{x}$/) ? true : false
end

#equal_ignore_case(x) ⇒ Object 



196
197
198
 
# File 'lib/m_string.rb', line 196

def equal_ignore_case(x)
  self.downcase == x.downcase if !x.nil?
end

#h_url ⇒ Object 



200
201
202
203
204
205
206
207
208
209
210
211
 
# File 'lib/m_string.rb', line 200

def h_url
  x = ""
  word_size = 5
  while x.blank?
    x = self.gsub(/([^ a-zA-Z0-9_-]+)/n, '').tr(' ', '-').gsub(/--/, '-').downcase#.truncate(100, "")
    x = x.split('-').collect {|word| word if word.size >= word_size}.compact[0..3].join("-")
    x = x.truncate(100, "")
    word_size -= 1
    return self if word_size == -1
  end
  x
end

#h_url! ⇒ Object 



213
214
215
 
# File 'lib/m_string.rb', line 213

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

#hexdigest ⇒ Object 



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

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

#hexdigest! ⇒ Object 



192
193
194
 
# File 'lib/m_string.rb', line 192

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

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



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
 
# File 'lib/m_string.rb', line 4

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) 


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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
 
# File 'lib/m_string.rb', line 39

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

#remove(val) ⇒ Object 



135
136
137
 
# File 'lib/m_string.rb', line 135

def remove(val)
  gsub(val, '')
end

#remove!(val) ⇒ Object 



139
140
141
 
# File 'lib/m_string.rb', line 139

def remove!(val)
  gsub!(val, '')
end

#sql_safe_str ⇒ Object

keep adding on to this whenever it becomes apparent that unsafe strings could get passed through into the database



267
268
269
270
271
 
# File 'lib/m_string.rb', line 267

def sql_safe_str
  if !self.nil?
    self.gsub(/[\']/, "\'\'")
  end
end

#sql_safe_str! ⇒ Object 



273
274
275
 
# File 'lib/m_string.rb', line 273

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

#starts_with?(x) ⇒ Boolean

Returns:

  • (Boolean) 


121
122
123
 
# File 'lib/m_string.rb', line 121

def starts_with?(x)
  self.match(/^#{x}/) ? true : false
end

#to_h ⇒ Object 



183
184
185
 
# File 'lib/m_string.rb', line 183

def to_h
  self.underscore.split('_').join(' ').humanize
end

#truncate(length = 30, truncate_string = "...") ⇒ Object 



224
225
226
227
228
229
230
231
232
233
 
# File 'lib/m_string.rb', line 224

def truncate(length = 30, truncate_string = "...")
  if self.nil? then return end
  l = length - truncate_string.length
  if $KCODE == "NONE"
    self.length > length ? self[0...l] + truncate_string : self
  else
    chars = self.split(//)
    chars.length > length ? chars[0...l].join + truncate_string : self
  end
end

#truncate!(length = 30, truncate_string = "...") ⇒ Object 



235
236
237
 
# File 'lib/m_string.rb', line 235

def truncate!(length = 30, truncate_string = "...")
  self.replace(self.truncate(length, truncate_string))
end

#underscore ⇒ Object 



112
113
114
115
116
117
118
119
 
# File 'lib/m_string.rb', line 112

def underscore
  camel_cased_word = self.dup
  camel_cased_word.to_s.gsub(/::/, '/').
    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
    gsub(/([a-z\d])([A-Z])/,'\1_\2').
    tr("-", "_").
    downcase
end