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.”



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

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

.randomize(length = 10) ⇒ Object 



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

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



139
140
141
142
143
144
145
146
 
# File 'lib/m_string.rb', line 139

def breakify(every = 30)
  every = 1 if every < 1
  text = self
  brokentxt = text.gsub(/\S{#{every},}/) { |longword| longword.scan(/.{1,#{every}}/).join("<wbr/>") }
  #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 



148
149
150
 
# File 'lib/m_string.rb', line 148

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

#capitalize_all_words ⇒ Object 



208
209
210
 
# File 'lib/m_string.rb', line 208

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

#capitalize_all_words! ⇒ Object 



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

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

#ends_with?(x) ⇒ Boolean

Returns:

  • (Boolean) 


116
117
118
 
# File 'lib/m_string.rb', line 116

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

#equal_ignore_case(x) ⇒ Object 



165
166
167
 
# File 'lib/m_string.rb', line 165

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

#h_url ⇒ Object 



169
170
171
172
173
174
175
176
177
178
179
180
 
# File 'lib/m_string.rb', line 169

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 



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

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

#hexdigest ⇒ Object 



157
158
159
 
# File 'lib/m_string.rb', line 157

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

#hexdigest! ⇒ Object 



161
162
163
 
# File 'lib/m_string.rb', line 161

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

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



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

def linkify(enabled = true, options = {}, &block)
  text = self.dup
  m = text.match(/(\".*?\":\S*)/)
  until m.nil?
    y = m.to_s.strip
    t = y.match(/\"(.*)\"/).captures
    url = y.match(/\":(.*)/).captures
    break if t.to_s == "" or url.to_s == ""
    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>")
      else
        text.gsub!(y, t.to_s)
      end
    end
    m = text.match(/\s(\".*?\":\S*)/)
  end
  return text
end

#methodize ⇒ Object

Raises:

  • (NameError) 


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

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 



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

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

#remove!(val) ⇒ Object 



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

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



236
237
238
239
240
 
# File 'lib/m_string.rb', line 236

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

#sql_safe_str! ⇒ Object 



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

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

#starts_with?(x) ⇒ Boolean

Returns:

  • (Boolean) 


112
113
114
 
# File 'lib/m_string.rb', line 112

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

#to_h ⇒ Object 



152
153
154
 
# File 'lib/m_string.rb', line 152

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

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



193
194
195
196
197
198
199
200
201
202
 
# File 'lib/m_string.rb', line 193

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 



204
205
206
 
# File 'lib/m_string.rb', line 204

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

#underscore ⇒ Object 



103
104
105
106
107
108
109
110
 
# File 'lib/m_string.rb', line 103

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