Class: String

Inherits:
Object show all
Includes:
ActiveSupport::CoreExtensions::String::Inflections
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.”



88
89
90
91
 
# File 'lib/m_string.rb', line 88

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

.randomize(length = 10) ⇒ Object 



153
154
155
156
157
158
 
# File 'lib/m_string.rb', line 153

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



106
107
108
109
110
111
112
113
 
# File 'lib/m_string.rb', line 106

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 



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

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

#capitalize_all_words ⇒ Object 



175
176
177
 
# File 'lib/m_string.rb', line 175

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

#capitalize_all_words! ⇒ Object 



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

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

#ends_with?(x) ⇒ Boolean 



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

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

#equal_ignore_case(x) ⇒ Object 



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

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

#h_url ⇒ Object 



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

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 



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

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

#hexdigest ⇒ Object 



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

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

#hexdigest! ⇒ Object 



128
129
130
 
# File 'lib/m_string.rb', line 128

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

#methodize ⇒ Object

Raises:

  • (NameError) 


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

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 



93
94
95
 
# File 'lib/m_string.rb', line 93

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

#remove!(val) ⇒ Object 



97
98
99
 
# File 'lib/m_string.rb', line 97

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



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

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

#sql_safe_str! ⇒ Object 



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

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

#starts_with?(x) ⇒ Boolean 



79
80
81
 
# File 'lib/m_string.rb', line 79

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

#to_h ⇒ Object 



119
120
121
 
# File 'lib/m_string.rb', line 119

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

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



160
161
162
163
164
165
166
167
168
169
 
# File 'lib/m_string.rb', line 160

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 



171
172
173
 
# File 'lib/m_string.rb', line 171

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