Class String |
|
User defined methods to be added to String.
Methods |
Public Instance methods |
ext(newext='') |
Replace the file extension with newext. If there is no extenson on the string, append the new extension to the end. If the new extension is not given, or is the empty string, remove any existing extension.
# File lib/rake.rb, line 82 82: def ext(newext='') 83: return self.dup if ['.', '..'].include? self 84: if newext != '' 85: newext = (newext =~ /^\./) ? newext : ("." + newext) 86: end 87: dup.sub!(%r(([^/\\])\.[^./\\]*$)) { $1 + newext } || self + newext 88: end
pathmap(spec=nil, &block) |
Map the path according to the given specification. The specification controls the details of the mapping. The following special patterns are recognized:
The %d specifier can also have a numeric prefix (e.g. ’%2d’). If the number is positive, only return (up to) n directories in the path, starting from the left hand side. If n is negative, return (up to) |n| directories from the right hand side of the path.
Examples:
'a/b/c/d/file.txt'.pathmap("%2d") => 'a/b' 'a/b/c/d/file.txt'.pathmap("%-2d") => 'c/d'
Also the %d, %p, $f, $n, %x, and %X operators can take a pattern/replacement argument to perform simple string substititions on a particular part of the path. The pattern and replacement are speparated by a comma and are enclosed by curly braces. The replacement spec comes after the % character but before the operator letter. (e.g. "%{old,new}d"). Muliple replacement specs should be separated by semi-colons (e.g. "%{old,new;src,bin}d").
Regular expressions may be used for the pattern, and back refs may be used in the replacement text. Curly braces, commas and semi-colons are excluded from both the pattern and replacement text (let‘s keep parsing reasonable).
For example:
"src/org/onestepback/proj/A.java".pathmap("%{^src,bin}X.class")
returns:
"bin/org/onestepback/proj/A.class"
If the replacement text is ’*’, then a block may be provided to perform some arbitrary calculation for the replacement.
For example:
"/path/to/file.TXT".pathmap("%X%{.*,*}x") { |ext| ext.downcase }
Returns:
"/path/to/file.txt"
# File lib/rake.rb, line 202 202: def pathmap(spec=nil, &block) 203: return self if spec.nil? 204: result = '' 205: spec.scan(/%\{[^}]*\}-?\d*[sdpfnxX%]|%-?\d+d|%.|[^%]+/) do |frag| 206: case frag 207: when '%f' 208: result << File.basename(self) 209: when '%n' 210: result << File.basename(self).ext 211: when '%d' 212: result << File.dirname(self) 213: when '%x' 214: result << $1 if self =~ /[^\/](\.[^.]+)$/ 215: when '%X' 216: if self =~ /^(.+[^\/])(\.[^.]+)$/ 217: result << $1 218: else 219: result << self 220: end 221: when '%p' 222: result << self 223: when '%s' 224: result << (File::ALT_SEPARATOR || File::SEPARATOR) 225: when '%-' 226: # do nothing 227: when '%%' 228: result << "%" 229: when /%(-?\d+)d/ 230: result << pathmap_partial($1.to_i) 231: when /^%\{([^}]*)\}(\d*[dpfnxX])/ 232: patterns, operator = $1, $2 233: result << pathmap('%' + operator).pathmap_replace(patterns, &block) 234: when /^%/ 235: fail ArgumentError, "Unknown pathmap specifier #{frag} in '#{spec}'" 236: else 237: result << frag 238: end 239: end 240: result 241: end
pathmap_explode() |
Explode a path into individual components. Used by pathmap.
# File lib/rake.rb, line 93 93: def pathmap_explode 94: head, tail = File.split(self) 95: return [self] if head == self 96: return [tail] if head == '.' || tail == '/' 97: return [head, tail] if head == '/' 98: return head.pathmap_explode + [tail] 99: end
pathmap_partial(n) |
Extract a partial path from the path. Include n directories from the front end (left hand side) if n is positive. Include |n| directories from the back end (right hand side) if n is negative.
# File lib/rake.rb, line 105 105: def pathmap_partial(n) 106: target = File.dirname(self) 107: dirs = target.pathmap_explode 108: if n > 0 109: File.join(dirs[0...n]) 110: elsif n < 0 111: partial = dirs[n..-1] 112: if partial.nil? || partial.empty? 113: target 114: else 115: File.join(partial) 116: end 117: else 118: "." 119: end 120: end
pathmap_replace(patterns, &block) |
Preform the pathmap replacement operations on the given path. The patterns take the form ‘pat1,rep1;pat2,rep2…’.
# File lib/rake.rb, line 125 125: def pathmap_replace(patterns, &block) 126: result = self 127: patterns.split(';').each do |pair| 128: pattern, replacement = pair.split(',') 129: pattern = Regexp.new(pattern) 130: if replacement == '*' && block_given? 131: result = result.sub(pattern, &block) 132: elsif replacement 133: result = result.sub(pattern, replacement) 134: else 135: result = result.sub(pattern, '') 136: end 137: end 138: result 139: end