Class: String

Inherits:
Object
  • Object
show all
Defined in:
lib/fat_core/string.rb

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.random(size = 8) ⇒ Object

[View source]

117
118
119
 
# File 'lib/fat_core/string.rb', line 117

def self.random(size = 8)
  ('a'..'z').cycle.take(size).shuffle.join
end

Instance Method Details

#as_string ⇒ Object

[View source]

80
81
82
 
# File 'lib/fat_core/string.rb', line 80

def as_string
  self
end

#as_sym ⇒ Object

Convert to symbol “Hello World” -> :hello_world

[View source]

75
76
77
78
 
# File 'lib/fat_core/string.rb', line 75

def as_sym
  strip.squeeze(' ').gsub(/\s+/, '_').
    gsub(/[^_A-Za-z0-9]/, '').downcase.to_sym
end

#colorize(text, color_code) ⇒ Object

[View source]

198
 
# File 'lib/fat_core/string.rb', line 198

def colorize(text, color_code)  "#{color_code}#{text}\001\e[0m\002" end

#console_blink ⇒ Object

[View source]

196
 
# File 'lib/fat_core/string.rb', line 196

def console_blink;        colorize(self, "\001\e[5m\002");  end

#console_blue ⇒ Object

[View source]

190
 
# File 'lib/fat_core/string.rb', line 190

def console_blue;         colorize(self, "\001\e[1m\e[34m\002");  end

#console_bold ⇒ Object

[View source]

195
 
# File 'lib/fat_core/string.rb', line 195

def console_bold;         colorize(self, "\001\e[1m\002");  end

#console_dark_blue ⇒ Object

[View source]

191
 
# File 'lib/fat_core/string.rb', line 191

def console_dark_blue;    colorize(self, "\001\e[34m\002");       end

#console_dark_green ⇒ Object

[View source]

187
 
# File 'lib/fat_core/string.rb', line 187

def console_dark_green;   colorize(self, "\001\e[32m\002");       end

#console_dark_red ⇒ Object

[View source]

185
 
# File 'lib/fat_core/string.rb', line 185

def console_dark_red;     colorize(self, "\001\e[31m\002");       end

#console_dark_yellow ⇒ Object

[View source]

189
 
# File 'lib/fat_core/string.rb', line 189

def console_dark_yellow;  colorize(self, "\001\e[33m\002");       end

#console_def ⇒ Object

[View source]

194
 
# File 'lib/fat_core/string.rb', line 194

def console_def;          colorize(self, "\001\e[1m\002");  end

#console_green ⇒ Object

[View source]

186
 
# File 'lib/fat_core/string.rb', line 186

def console_green;        colorize(self, "\001\e[1m\e[32m\002");  end

#console_purple ⇒ Object

[View source]

192
 
# File 'lib/fat_core/string.rb', line 192

def console_purple;       colorize(self, "\001\e[1m\e[35m\002");  end

#console_red ⇒ Object

Thanks to Eugene at stackoverflow for the following. stackoverflow.com/questions/8806643/

colorized-output-breaks-linewrapping-with-readline

These color strings without confusing readline about the length of the prompt string in the shell. (Unlike the rainbow routines)

[View source]

184
 
# File 'lib/fat_core/string.rb', line 184

def console_red;          colorize(self, "\001\e[1m\e[31m\002");  end

#console_yellow ⇒ Object

[View source]

188
 
# File 'lib/fat_core/string.rb', line 188

def console_yellow;       colorize(self, "\001\e[1m\e[33m\002");  end

#digdate2iso ⇒ Object

Convert a string with an all-digit date to an iso string E.g., “20090923” -> “2009-09-23”

[View source]

123
124
125
 
# File 'lib/fat_core/string.rb', line 123

def digdate2iso
  self.sub(/(\d\d\d\d)(\d\d)(\d\d)/, '\1-\2-\3')
end

#distance(other, block_size: 1, max_distance: 10) ⇒ Object

[View source]

4
5
6
7
8
9
10
11
 
# File 'lib/fat_core/string.rb', line 4

def distance(other, block_size: 1, max_distance: 10)
  dl = DamerauLevenshtein
  # NOTE: DL 'gives up after' max_distance, so the distance function
  # will return max_distance+1 if the distance is bigger than that.
  # Here we subtract 1 so the max_distance also becomes the max
  # return value.
  dl.distance(self, other, block_size, max_distance-1)
end

#entitle ⇒ Object

[View source]

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

def entitle
  self.dup.entitle!
end

#entitle! ⇒ Object

[View source]

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
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
 
# File 'lib/fat_core/string.rb', line 127

def entitle!
  little_words = %w[ a an the and or in on under of from as by to ]
  newwords = []
  words = split(/\s+/)
  first_word = true
  num_words = words.length
  words.each_with_index do |w, k|
    last_word = (k + 1 == num_words)
    if w =~ %r[c/o]i
      # Care of
      newwords.push("c/o")
    elsif w =~ %r[^p\.?o\.?$]i
      # Post office
      newwords.push("P.O.")
    elsif w =~ %r[^[0-9]+(st|nd|rd|th)$]i
      # Ordinals
      newwords.push(w.downcase)
    elsif w =~ %r[^(cr|dr|st|rd|ave|pk|cir)$]i
      # Common abbrs to capitalize
      newwords.push(w.capitalize)
    elsif w =~ %r[^(us|ne|se|rr)$]i
      # Common 2-letter abbrs to upcase
      newwords.push(w.upcase)
    elsif w =~ %r[^[0-9].*$]i
      # Other runs starting with numbers,
      # like 3-A
      newwords.push(w.upcase)
    elsif w =~ %r[^(N|S|E|W|NE|NW|SE|SW)$]i
      # Compass directions all caps
      newwords.push(w.upcase)
    elsif w =~ %r[^[^aeiouy]*$]i && w.size > 2
      # All consonants and at least 3 chars, probably abbr
      newwords.push(w.upcase)
    elsif w =~ %r[^(\w+)-(\w+)$]i
      # Hypenated double word
      newwords.push($1.capitalize + '-' + $2.capitalize)
    elsif little_words.include?(w.downcase)
      # Only capitalize at beginning or end
      newwords.push((first_word or last_word) ? w.capitalize : w.downcase)
    else
      # All else
      newwords.push(w.capitalize)
    end
    first_word = false
  end
  self[0..-1] = newwords.join(' ')
end

#fuzzy_match(other) ⇒ Object

See if self contains colon- or space-separated words that include the colon- or space-separated words of other. Return the matched portion of self. Other cannot be a regex embedded in a string.

[View source]

16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
# File 'lib/fat_core/string.rb', line 16

def fuzzy_match(other)
  # Remove periods, commas, and apostrophes
  other = other.gsub(/[\*.,']/, '')
  target = self.gsub(/[\*.,']/, '')
  matched_text = nil
  matchers = other.split(/[: ]+/)
  regexp_string = matchers.map {|m| ".*?#{Regexp.escape(m)}.*?"}.join('[: ]')
  regexp_string.sub!(/^\.\*\?/, '')
  regexp_string.sub!(/\.\*\?$/, '')
  regexp = /#{regexp_string}/i
  if match = regexp.match(target)
    matched_text = match[0]
  else
    matched_text = nil
  end
  matched_text
end

#matches_with(str) ⇒ Object

Here are instance methods for the class that includes Matchable This tries to convert the receiver object into a string, then matches against the given matcher, either via regex or a fuzzy string matcher.

[View source]

38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/fat_core/string.rb', line 38

def matches_with(str)
  if str.nil?
    nil
  elsif str =~ /^\s*\//
    re = str.to_regexp
    if self.to_s =~ re
      $&
    else
      nil
    end
  else
    self.to_s.fuzzy_match(str)
  end
end

#tex_quote ⇒ Object

[View source]

102
103
104
105
106
107
108
109
110
111
112
113
114
115
 
# File 'lib/fat_core/string.rb', line 102

def tex_quote
  r = self.dup
  r = r.gsub(/[{]/, 'XzXzXobXzXzX')
  r = r.gsub(/[}]/, 'XzXzXcbXzXzX')
  r = r.gsub(/\\/, '\textbackslash{}')
  r = r.gsub(/\^/, '\textasciicircum{}')
  r = r.gsub(/~/, '\textasciitilde{}')
  r = r.gsub(/\|/, '\textbar{}')
  r = r.gsub(/\</, '\textless{}')
  r = r.gsub(/\>/, '\textgreater{}')
  r = r.gsub(/([_$&%#])/) { |m| '\\' + m }
  r = r.gsub('XzXzXobXzXzX', '\\{')
  r = r.gsub('XzXzXcbXzXzX', '\\}')
end

#to_regexp ⇒ Object

Convert a string of the form ‘/…/Iixm’ to a regular expression. However, make the regular expression case-insensitive by default and extend the modifier syntax to allow ‘/I’ to indicate case-sensitive.

[View source]

56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 
# File 'lib/fat_core/string.rb', line 56

def to_regexp
  if self =~ /^\s*\/([^\/]*)\/([Iixm]*)\s*$/
    body = $1
    opts = $2
    flags = Regexp::IGNORECASE
    unless opts.blank?
      flags = 0 if opts.include?('I')
      flags |= Regexp::IGNORECASE if opts.include?('i')
      flags |= Regexp::EXTENDED if opts.include?('x')
      flags |= Regexp::MULTILINE if opts.include?('m')
    end
    flags = nil if flags == 0
    Regexp.new(body, flags)
  else
    Regexp.new(self)
  end
end

#wrap(width = 70, hang = 0) ⇒ Object

[View source]

84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
 
# File 'lib/fat_core/string.rb', line 84

def wrap(width=70, hang=0)
  offset = 0
  trip = 1
  result = ''
  while (s = slice(offset, width))
    offset += width
    if trip == 1
      width -= hang
    else
      s = (' ' * hang) + s
    end
    result << s + "\n"
    trip += 1
  end
  # Remove the final newline before exiting
  result.strip
end