Class: String

Inherits:
Object show all
Defined in:
lib/lite/ruby/string.rb,
lib/lite/ruby/safe/string.rb

Constant Summary collapse

TRANSLITERATIONS = 
YAML.load_file(
  File.expand_path('formats/string_transliterations.yml', File.dirname(__FILE__))
).freeze

Instance Method Summary collapse

Instance Method Details

#acronym ⇒ Object 



11
12
13
 
# File 'lib/lite/ruby/string.rb', line 11

def acronym
  gsub(/(([a-zA-Z0-9])([a-zA-Z0-9])*)./, '\\2') || self
end

#acronym! ⇒ Object 



15
16
17
 
# File 'lib/lite/ruby/string.rb', line 15

def acronym!
  replace(acronym)
end

#any?(*keys) ⇒ Boolean

Returns:

  • (Boolean) 


19
20
21
 
# File 'lib/lite/ruby/string.rb', line 19

def any?(*keys)
  keys.any? { |key| include?(key) }
end

#at(position) ⇒ Object 



5
6
7
 
# File 'lib/lite/ruby/safe/string.rb', line 5

def at(position)
  self[position]
end

#camelize(first_letter = :upper) ⇒ Object Also known as: camelcase 



9
10
11
12
13
14
15
 
# File 'lib/lite/ruby/safe/string.rb', line 9

def camelize(first_letter = :upper)
  case first_letter
  when :upper, true then modulize.gsub(/(\A|\s)([a-z])/) { $1 + $2.upcase }
  when :lower, false then modulize.gsub(/(\A|\s)([A-Z])/) { $1 + $2.downcase }
  else modulize
  end
end

#camelize!(first_letter = :upper) ⇒ Object Also known as: camelcase! 



23
24
25
 
# File 'lib/lite/ruby/string.rb', line 23

def camelize!(first_letter = :upper)
  replace(camelize(first_letter))
end

#capitalized? ⇒ Boolean

Returns:

  • (Boolean) 


27
28
29
 
# File 'lib/lite/ruby/string.rb', line 27

def capitalized?
  capitalize == self
end

#classify ⇒ Object 



17
18
19
20
21
22
 
# File 'lib/lite/ruby/safe/string.rb', line 17

def classify
  str = dup
  str.sub!(/.*\./, '')
  str.camelize!
  str || self
end

#classify! ⇒ Object 



31
32
33
 
# File 'lib/lite/ruby/string.rb', line 31

def classify!
  replace(classify)
end

#constantize ⇒ Object 



24
25
26
 
# File 'lib/lite/ruby/safe/string.rb', line 24

def constantize
  Object.const_get(camelize)
end

#dasherize ⇒ Object 



28
29
30
 
# File 'lib/lite/ruby/safe/string.rb', line 28

def dasherize
  underscore.tr('_', '-')
end

#dasherize! ⇒ Object 



35
36
37
 
# File 'lib/lite/ruby/string.rb', line 35

def dasherize!
  replace(dasherize)
end

#deconstantize ⇒ Object 



32
33
34
 
# File 'lib/lite/ruby/safe/string.rb', line 32

def deconstantize
  [0, rindex('::') || 0]
end

#deconstantize! ⇒ Object 



39
40
41
 
# File 'lib/lite/ruby/string.rb', line 39

def deconstantize!
  replace(deconstantize)
end

#dedupe(pattern) ⇒ Object 



43
44
45
 
# File 'lib/lite/ruby/string.rb', line 43

def dedupe(pattern)
  dup.dedupe!(pattern)
end

#dedupe!(pattern) ⇒ Object 



47
48
49
50
 
# File 'lib/lite/ruby/string.rb', line 47

def dedupe!(pattern)
  pattern.each_char { |char| gsub!(/#{Regexp.escape(char)}{2,}/, char) }
  self
end

#demodulize ⇒ Object 



36
37
38
 
# File 'lib/lite/ruby/safe/string.rb', line 36

def demodulize
  gsub(/^.*::/, '')
end

#demodulize! ⇒ Object 



52
53
54
 
# File 'lib/lite/ruby/string.rb', line 52

def demodulize!
  replace(demodulize)
end

#domain ⇒ Object 



56
57
58
59
60
 
# File 'lib/lite/ruby/string.rb', line 56

def domain
  return self unless self =~ %r{^(?:\w+://)?([^/?]+)(?:/|\?|$)}

  Regexp.last_match(1)
end

#downcase? ⇒ Boolean

Returns:

  • (Boolean) 


62
63
64
 
# File 'lib/lite/ruby/string.rb', line 62

def downcase?
  downcase == self
end

#each_word(&block) ⇒ Object 



66
67
68
 
# File 'lib/lite/ruby/string.rb', line 66

def each_word(&block)
  words.each(&block)
end

#ellipsize(ellipsize_at, options = {}) ⇒ Object 



70
71
72
73
74
75
76
77
 
# File 'lib/lite/ruby/string.rb', line 70

def ellipsize(ellipsize_at, options = {})
  return self if length <= ellipsize_at

  separator = options[:separator] || '...'
  offset = options[:offset] || 4

  "#{self[0, offset]}#{separator}#{self[-offset, offset]}"
end

#first(limit = 1) ⇒ Object 



40
41
42
43
44
45
46
47
48
 
# File 'lib/lite/ruby/safe/string.rb', line 40

def first(limit = 1)
  if limit.zero?
    ''
  elsif limit >= length
    self
  else
    to(limit - 1)
  end
end

#format(*args) ⇒ Object 



79
80
81
 
# File 'lib/lite/ruby/string.rb', line 79

def format(*args)
  super(self, *args.flatten)
end

#from(position) ⇒ Object 



50
51
52
 
# File 'lib/lite/ruby/safe/string.rb', line 50

def from(position)
  self[position..-1]
end

#headerize ⇒ Object 



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

def headerize
  squish.each_word(&:capitalize!).join(' ')
end

#headerize! ⇒ Object 



87
88
89
 
# File 'lib/lite/ruby/string.rb', line 87

def headerize!
  replace(headerize)
end

#humanize(capitalize: true) ⇒ Object 



54
55
56
57
58
59
60
61
62
63
 
# File 'lib/lite/ruby/safe/string.rb', line 54

def humanize(capitalize: true)
  str = dup
  str.underscore!
  str.delete_suffix!('_id')
  str.tr!('_', ' ')
  str.squish!
  str.gsub!(/([a-z\d]*)/i, &:downcase)
  str.gsub!(/\A\w/) { |s| capitalize ? s.upcase : s }
  str || self
end

#humanize!(capitalize: true) ⇒ Object 



91
92
93
 
# File 'lib/lite/ruby/string.rb', line 91

def humanize!(capitalize: true)
  replace(humanize(capitalize: capitalize))
end

#indent(amount, seperator = ' ') ⇒ Object 



65
66
67
 
# File 'lib/lite/ruby/safe/string.rb', line 65

def indent(amount, seperator = ' ')
  dup.indent!(amount, seperator)
end

#indent!(amount, seperator = ' ') ⇒ Object 



69
70
71
72
73
74
75
 
# File 'lib/lite/ruby/safe/string.rb', line 69

def indent!(amount, seperator = ' ')
  if amount >= 0
    gsub!(/^/, seperator * amount)
  else
    gsub!(/^#{Regexp.escape(seperator)}{0,#{-amount}}/, '')
  end
end

#index_all(pattern) ⇒ Object 



95
96
97
98
99
100
101
102
103
104
105
106
107
 
# File 'lib/lite/ruby/string.rb', line 95

def index_all(pattern)
  pattern = pattern.to_s if pattern.is_a?(Numeric)
  arr_indexes = []
  srch_index = rindex(pattern)

  while srch_index
    temp_string = self[0..(srch_index - 1)]
    arr_indexes << srch_index
    srch_index = srch_index.zero? ? nil : temp_string.rindex(pattern)
  end

  arr_indexes.reverse
end

#labelize(capitalize: true) ⇒ Object Also known as: labelcase 



109
110
111
 
# File 'lib/lite/ruby/string.rb', line 109

def labelize(capitalize: true)
  dup.labelize!(capitalize: capitalize)
end

#labelize!(capitalize: true) ⇒ Object Also known as: labelcase! 



113
114
115
116
117
118
119
120
 
# File 'lib/lite/ruby/string.rb', line 113

def labelize!(capitalize: true)
  underscore!
  tr!('_', ' ')
  squish!
  gsub!(/([a-z\d]*)/i, &:downcase)
  gsub!(/\A\w/) { |str| capitalize ? str.upcase : str }
  gsub!(/ id\z/, ' ID') || self
end

#last(limit = 1) ⇒ Object 



77
78
79
80
81
82
83
84
85
 
# File 'lib/lite/ruby/safe/string.rb', line 77

def last(limit = 1)
  if limit.zero?
    ''
  elsif limit >= length
    self
  else
    from(-limit)
  end
end

#lchomp(match) ⇒ Object 



122
123
124
 
# File 'lib/lite/ruby/string.rb', line 122

def lchomp(match)
  dup.lchomp!(match)
end

#lchomp!(match) ⇒ Object 



126
127
128
129
130
131
 
# File 'lib/lite/ruby/string.rb', line 126

def lchomp!(match)
  return self unless index(match)

  self[0...match.size] = ''
  self
end

#methodize ⇒ Object 



133
134
135
 
# File 'lib/lite/ruby/string.rb', line 133

def methodize
  dup.methodize!
end

#methodize! ⇒ Object 



137
138
139
140
141
142
143
 
# File 'lib/lite/ruby/string.rb', line 137

def methodize!
  gsub!(/([A-Z]+)([A-Z])/, '\1_\2')
  gsub!(/([a-z])([A-Z])/, '\1_\2')
  gsub!('/', '__')
  gsub!('::', '__')
  downcase! || self
end

#mixedcase? ⇒ Boolean

Returns:

  • (Boolean) 


156
157
158
 
# File 'lib/lite/ruby/string.rb', line 156

def mixedcase?
  !upcase? && !downcase?
end

#modulize ⇒ Object 



145
146
147
 
# File 'lib/lite/ruby/string.rb', line 145

def modulize
  dup.modulize!
end

#modulize! ⇒ Object 



149
150
151
152
153
154
 
# File 'lib/lite/ruby/string.rb', line 149

def modulize!
  gsub!(/__(.?)/) { "::#{$1.upcase}" }
  gsub!(%r{/(.?)}) { "::#{$1.upcase}" }
  gsub!(/(?:_+|-+)([a-z])/) { $1.upcase }
  gsub!(/(\A|\s)([a-z])/) { $1 + $2.upcase } || self
end

#non_possessive ⇒ Object 



160
161
162
 
# File 'lib/lite/ruby/string.rb', line 160

def non_possessive
  dup.non_possessive!
end

#non_possessive! ⇒ Object 



164
165
166
167
168
 
# File 'lib/lite/ruby/string.rb', line 164

def non_possessive!
  return self unless possessive?

  chomp!("'s") || chomp!("'") || self
end

#ordinal ⇒ Object 



170
171
172
 
# File 'lib/lite/ruby/string.rb', line 170

def ordinal
  to_i.ordinal
end

#ordinalize ⇒ Object 



174
175
176
 
# File 'lib/lite/ruby/string.rb', line 174

def ordinalize
  to_i.ordinalize
end

#parameterize(separator: '-') ⇒ Object 



87
88
89
90
91
92
93
 
# File 'lib/lite/ruby/safe/string.rb', line 87

def parameterize(separator: '-')
  str = dup
  str.underscore!
  str.gsub!(/\s+/, separator)
  str.downcase!
  str || self
end

#parameterize!(separator: '-') ⇒ Object 



178
179
180
 
# File 'lib/lite/ruby/string.rb', line 178

def parameterize!(separator: '-')
  replace(parameterize(separator: separator))
end

#pathize ⇒ Object 



182
183
184
 
# File 'lib/lite/ruby/string.rb', line 182

def pathize
  dup.pathize!
end

#pathize! ⇒ Object 



186
187
188
189
190
191
192
193
194
 
# File 'lib/lite/ruby/string.rb', line 186

def pathize!
  gsub!(/([A-Z]+)([A-Z])/, '\1_\2')
  gsub!(/([a-z])([A-Z])/, '\1_\2')
  gsub!('__', '/')
  gsub!('::', '/')
  gsub!(/\s+/, '')
  gsub!(/[?%*:|"<>.]+/, '')
  downcase! || self
end

#pollute(delimiter = '^--^--^') ⇒ Object 



196
197
198
 
# File 'lib/lite/ruby/string.rb', line 196

def pollute(delimiter = '^--^--^')
  chars.map { |chr| "#{chr}#{delimiter}" }.join
end

#pollute!(delimiter = '^--^--^') ⇒ Object 



200
201
202
 
# File 'lib/lite/ruby/string.rb', line 200

def pollute!(delimiter = '^--^--^')
  replace(pollute(delimiter))
end

#pop ⇒ Object 



204
205
206
 
# File 'lib/lite/ruby/string.rb', line 204

def pop
  self[-1]
end

#possessive ⇒ Object 



208
209
210
211
212
213
 
# File 'lib/lite/ruby/string.rb', line 208

def possessive
  return self if possessive?

  possession = end_with?('s') ? "'" : "'s"
  "#{self}#{possession}"
end

#possessive! ⇒ Object 



215
216
217
 
# File 'lib/lite/ruby/string.rb', line 215

def possessive!
  replace(possessive)
end

#possessive? ⇒ Boolean

Returns:

  • (Boolean) 


219
220
221
 
# File 'lib/lite/ruby/string.rb', line 219

def possessive?
  %w['s s'].any? { |pos| end_with?(pos) }
end

#push(string) ⇒ Object 



223
224
225
 
# File 'lib/lite/ruby/string.rb', line 223

def push(string)
  replace(concat(string))
end

#quote(type = :double, amount = nil) ⇒ Object

rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength



228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
 
# File 'lib/lite/ruby/string.rb', line 228

def quote(type = :double, amount = nil)
  if type.is_a?(Integer)
    tmp = amount
    amount = type
    type = tmp || :mixed
  else
    amount ||= 1
  end

  case type.to_s
  when "'", 'single', 's', '1'
    f = "'" * amount
    b = f
  when '"', 'double', 'd', '2'
    f = '"' * amount
    b = f
  when '`', 'back', 'backtick', 'b', '-1'
    f = '`' * amount
    b = f
  when "`'", 'bracket', 'sb'
    f = '`' * amount
    b = "'" * amount
  when "'\"", 'mixed', 'm', 'Integer'
    c = (amount.to_f / 2).to_i
    f = '"' * c
    b = f

    if amount.odd?
      f = "'#{f}"
      b += "'"
    end
  else
    raise ArgumentError, "Invalid quote type: #{type.inspect}"
  end

  "#{f}#{self}#{b}"
end

#quote!(type = :double, amount = nil) ⇒ Object

rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength



267
268
269
 
# File 'lib/lite/ruby/string.rb', line 267

def quote!(type = :double, amount = nil)
  replace(quote(type, amount))
end

#remove(*patterns) ⇒ Object 



95
96
97
 
# File 'lib/lite/ruby/safe/string.rb', line 95

def remove(*patterns)
  dup.remove!(*patterns)
end

#remove!(*patterns) ⇒ Object 



99
100
101
102
103
 
# File 'lib/lite/ruby/safe/string.rb', line 99

def remove!(*patterns)
  patterns.each_with_object(self) do |pat, str|
    pat.is_a?(Range) ? str.slice!(pat) : str.gsub!(pat, '')
  end
end

#remove_tags ⇒ Object 



271
272
273
 
# File 'lib/lite/ruby/string.rb', line 271

def remove_tags
  dup.remove_tags!
end

#remove_tags! ⇒ Object 



275
276
277
 
# File 'lib/lite/ruby/string.rb', line 275

def remove_tags!
  gsub!(%r{</?[^>]*>}, '') || self
end

#rotate(amount = 1) ⇒ Object 



279
280
281
 
# File 'lib/lite/ruby/string.rb', line 279

def rotate(amount = 1)
  dup.rotate!(amount)
end

#rotate!(amount = 1) ⇒ Object 



283
284
285
286
 
# File 'lib/lite/ruby/string.rb', line 283

def rotate!(amount = 1)
  amount += size if amount.negative?
  slice!(amount, size - amount) + slice!(0, amount)
end

#safe_encode(target_encoding, replacement = '') ⇒ Object

rubocop:disable Metrics/MethodLength



289
290
291
292
293
294
295
296
297
298
299
300
301
 
# File 'lib/lite/ruby/string.rb', line 289

def safe_encode(target_encoding, replacement = '')
  encode(target_encoding)
rescue Encoding::InvalidByteSequenceError
  force_encoding(target_encoding).scrub!(replacement)
rescue Encoding::UndefinedConversionError
  encode(
    target_encoding,
    invalid: :replace,
    undef: :replace,
    replace: replacement,
    UNIVERSAL_NEWLINE_DECORATOR: true
  )
end

#safe_encode!(target_encoding, replacement = '') ⇒ Object

rubocop:enable Metrics/MethodLength



304
305
306
 
# File 'lib/lite/ruby/string.rb', line 304

def safe_encode!(target_encoding, replacement = '')
  replace(safe_encode(target_encoding, replacement))
end

#sample(separator = ' ') ⇒ Object 



308
309
310
 
# File 'lib/lite/ruby/string.rb', line 308

def sample(separator = ' ')
  split(separator).sample
end

#sample!(separator = ' ') ⇒ Object 



312
313
314
 
# File 'lib/lite/ruby/string.rb', line 312

def sample!(separator = ' ')
  replace(sample(separator))
end

#shift(*patterns) ⇒ Object 



316
317
318
 
# File 'lib/lite/ruby/string.rb', line 316

def shift(*patterns)
  dup.shift!(*patterns)
end

#shift!(*patterns) ⇒ Object 



320
321
322
323
324
 
# File 'lib/lite/ruby/string.rb', line 320

def shift!(*patterns)
  return self[0] if patterns.empty?

  patterns.each_with_object(self) { |pat, str| str.sub!(pat, '') }
end

#shuffle(separator = '') ⇒ Object 



326
327
328
 
# File 'lib/lite/ruby/string.rb', line 326

def shuffle(separator = '')
  split(separator).shuffle.join
end

#shuffle!(separator = '') ⇒ Object 



330
331
332
 
# File 'lib/lite/ruby/string.rb', line 330

def shuffle!(separator = '')
  replace(shuffle(separator))
end

#sift(keep) ⇒ Object 



334
335
336
337
338
339
340
341
342
343
 
# File 'lib/lite/ruby/string.rb', line 334

def sift(keep)
  keep = case keep
         when String then keep.chars
         when Array then keep.map(&:to_s)
         when Range then keep.to_a.map(&:to_s)
         else raise TypeError, "Invalid parameter: #{keep.inspect}"
         end

  chars.keep_if { |chr| keep.include?(chr) }.join
end

#sift!(keep) ⇒ Object 



345
346
347
 
# File 'lib/lite/ruby/string.rb', line 345

def sift!(keep)
  replace(sift(keep))
end

#slugify ⇒ Object 



349
350
351
 
# File 'lib/lite/ruby/string.rb', line 349

def slugify
  dup.slugify!
end

#slugify! ⇒ Object 



353
354
355
356
357
358
359
 
# File 'lib/lite/ruby/string.rb', line 353

def slugify!
  gsub!(/[^\x00-\x7F]+/, '')
  gsub!(/[^\w \-]+/i, '')
  gsub!(/[ \-]+/i, '-')
  gsub!(/^-|-$/i, '')
  downcase! || self
end

#sort ⇒ Object 



361
362
363
 
# File 'lib/lite/ruby/string.rb', line 361

def sort
  chars.sort.join
end

#sort! ⇒ Object 



365
366
367
 
# File 'lib/lite/ruby/string.rb', line 365

def sort!
  replace(sort)
end

#squish ⇒ Object 



105
106
107
 
# File 'lib/lite/ruby/safe/string.rb', line 105

def squish
  dup.squish!
end

#squish! ⇒ Object 



109
110
111
112
 
# File 'lib/lite/ruby/safe/string.rb', line 109

def squish!
  strip!
  gsub!(/\s+/, ' ') || self
end

#titleize ⇒ Object Also known as: titlecase 



114
115
116
117
118
119
120
 
# File 'lib/lite/ruby/safe/string.rb', line 114

def titleize
  str = dup
  str.underscore!
  str.humanize!
  str.gsub!(/\b(?<!['’`])[a-z]/) { $&.capitalize }
  str || self
end

#titleize! ⇒ Object Also known as: titlecase! 



377
378
379
 
# File 'lib/lite/ruby/string.rb', line 377

def titleize!
  replace(titleize)
end

#to(position) ⇒ Object 



122
123
124
 
# File 'lib/lite/ruby/safe/string.rb', line 122

def to(position)
  self[0..position]
end

#to_time(form = :local) ⇒ Object Also known as: to_t

rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity rubocop:disable Metrics/MethodLength, Metrics/PerceivedComplexity



128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
 
# File 'lib/lite/ruby/safe/string.rb', line 128

def to_time(form = :local)
  parts = Date.parse(self, false)
  used_keys = i[year mon mday hour min sec sec_fraction offset]
  return if (parts.keys & used_keys).empty?

  now = Time.now
  time = Time.new(
    parts[:year] || now.year,
    parts[:mon] || now.month,
    parts[:mday] || now.day,
    parts[:hour] || 0,
    parts[:min] || 0,
    (parts[:sec] || 0) + (parts[:sec_fraction] || 0),
    parts[:offset] || (form == :utc ? 0 : nil)
  )

  form == :utc ? time.utc : time.to_time
end

#transliterize ⇒ Object 



369
370
371
 
# File 'lib/lite/ruby/string.rb', line 369

def transliterize
  TRANSLITERATIONS.each_with_object(dup) { |(k, v), s| s.gsub!(k, v) }
end

#transliterize! ⇒ Object 



373
374
375
 
# File 'lib/lite/ruby/string.rb', line 373

def transliterize!
  replace(transliterize)
end

#truncate(truncate_at, options = {}) ⇒ Object

rubocop:enable Metrics/MethodLength, Metrics/PerceivedComplexity rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity



149
150
151
152
153
154
155
156
157
 
# File 'lib/lite/ruby/safe/string.rb', line 149

def truncate(truncate_at, options = {})
  return self unless length > truncate_at

  omission = options[:omission] || '...'
  seperator = options[:separator]
  size_with_room_for_omission = truncate_at - omission.length
  stop = rindex(seperator || '', size_with_room_for_omission) if seperator
  "#{self[0, stop || size_with_room_for_omission]}#{omission}"
end

#truncate_words(words_count, options = {}) ⇒ Object 



159
160
161
162
163
164
165
 
# File 'lib/lite/ruby/safe/string.rb', line 159

def truncate_words(words_count, options = {})
  sep = options[:separator] || /\s+/
  sep = Regexp.escape(sep.to_s) unless sep.is_a?(Regexp)
  return dup unless self =~ /\A((?>.+?#{sep}){#{words_count - 1}}.+?)#{sep}.*/m

  $1 + (options[:omission] || '...')
end

#underscore ⇒ Object Also known as: snakecase 



167
168
169
170
171
172
173
174
175
176
 
# File 'lib/lite/ruby/safe/string.rb', line 167

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

#underscore! ⇒ Object Also known as: snakecase! 



385
386
387
 
# File 'lib/lite/ruby/string.rb', line 385

def underscore!
  replace(underscore)
end

#unpollute(delimiter = '^--^--^') ⇒ Object 



389
390
391
 
# File 'lib/lite/ruby/string.rb', line 389

def unpollute(delimiter = '^--^--^')
  dup.unpollute!(delimiter)
end

#unpollute!(delimiter = '^--^--^') ⇒ Object 



393
394
395
 
# File 'lib/lite/ruby/string.rb', line 393

def unpollute!(delimiter = '^--^--^')
  gsub!(delimiter, '') || self
end

#unquote ⇒ Object 



397
398
399
 
# File 'lib/lite/ruby/string.rb', line 397

def unquote
  dup.unquote!
end

#unquote! ⇒ Object 



401
402
403
404
405
406
407
408
409
 
# File 'lib/lite/ruby/string.rb', line 401

def unquote!
  [0, -1].each do |i|
    case self[i, 1]
    when "'", '"', '`' then self[i] = ''
    end
  end

  self
end

#unshift(*patterns) ⇒ Object 



411
412
413
414
 
# File 'lib/lite/ruby/string.rb', line 411

def unshift(*patterns)
  patterns.each_with_object('') { |pat, str| str << pat }
          .concat(self)
end

#unshift!(*patterns) ⇒ Object 



416
417
418
 
# File 'lib/lite/ruby/string.rb', line 416

def unshift!(*patterns)
  replace(unshift(*patterns))
end

#upcase? ⇒ Boolean

Returns:

  • (Boolean) 


381
382
383
 
# File 'lib/lite/ruby/string.rb', line 381

def upcase?
  upcase == self
end

#variablize ⇒ Object 



433
434
435
 
# File 'lib/lite/ruby/string.rb', line 433

def variablize
  "@#{gsub(/\W/, '_')}"
end

#variablize! ⇒ Object 



437
438
439
 
# File 'lib/lite/ruby/string.rb', line 437

def variablize!
  replace(variablize)
end

#words ⇒ Object 



420
421
422
 
# File 'lib/lite/ruby/string.rb', line 420

def words
  split(/\s+/)
end

#words_without_punctuation ⇒ Object 



424
425
426
427
428
429
430
431
 
# File 'lib/lite/ruby/string.rb', line 424

def words_without_punctuation
  str = dup
  str.gsub!(%r{[.?¿¡…!,:：;—"。？！、‘“”„«»〈〉《》，/\[\]]}, ' ')
  str.gsub!('- ', ' ')
  str.squeeze!(' ')
  str.strip!
  str.words
end