class String

Rake extension methods for String.

Public Instance Methods

ext(newext='') click to toggle source

Replace the file extension with newext. If there is no extension 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.

ext is a user added method for the String class.

   # File lib/rake/ext/string.rb
13 def ext(newext='')
14   return self.dup if ['.', '..'].include? self
15   if newext != ''
16     newext = (newext =~ /^\./) ? newext : ("." + newext)
17   end
18   self.chomp(File.extname(self)) << newext
19 end
pathmap(spec=nil, &block) click to toggle source

Map the path according to the given specification. The specification controls the details of the mapping. The following special patterns are recognized:

  • %p – The complete path.

  • %f – The base file name of the path, with its file extension, but without any directories.

  • %n – The file name of the path without its file extension.

  • %d – The directory list of the path.

  • %x – The file extension of the path. An empty string if there is no extension.

  • %X – Everything but the file extension.

  • %s – The alternate file separator if defined, otherwise use the standard file separator.

  • %% – A percent sign.

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 substitutions on a particular part of the path. The pattern and replacement are separated 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”). Multiple 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/ext/string.rb
129 def pathmap(spec=nil, &block)
130   return self if spec.nil?
131   result = ''
132   spec.scan(/%\{[^}]*\}-?\d*[sdpfnxX%]|%-?\d+d|%.|[^%]+/) do |frag|
133     case frag
134     when '%f'
135       result << File.basename(self)
136     when '%n'
137       result << File.basename(self).ext
138     when '%d'
139       result << File.dirname(self)
140     when '%x'
141       result << File.extname(self)
142     when '%X'
143       result << self.ext
144     when '%p'
145       result << self
146     when '%s'
147       result << (File::ALT_SEPARATOR || File::SEPARATOR)
148     when '%-'
149       # do nothing
150     when '%%'
151       result << "%"
152     when /%(-?\d+)d/
153       result << pathmap_partial($1.to_i)
154     when /^%\{([^}]*)\}(\d*[dpfnxX])/
155       patterns, operator = $1, $2
156       result << pathmap('%' + operator).pathmap_replace(patterns, &block)
157     when /^%/
158       fail ArgumentError, "Unknown pathmap specifier #{frag} in '#{spec}'"
159     else
160       result << frag
161     end
162   end
163   result
164 end
pathmap_explode() click to toggle source

Explode a path into individual components. Used by pathmap.

   # File lib/rake/ext/string.rb
24 def pathmap_explode
25   head, tail = File.split(self)
26   return [self] if head == self
27   return [tail] if head == '.' || tail == '/'
28   return [head, tail] if head == '/'
29   return head.pathmap_explode + [tail]
30 end
pathmap_partial(n) click to toggle source

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/ext/string.rb
36 def pathmap_partial(n)
37   dirs = File.dirname(self).pathmap_explode
38   partial_dirs =
39     if n > 0
40       dirs[0...n]
41     elsif n < 0
42       dirs.reverse[0...-n].reverse
43     else
44       "."
45     end
46   File.join(partial_dirs)
47 end
pathmap_replace(patterns, &block) click to toggle source

Preform the pathmap replacement operations on the given path. The patterns take the form 'pat1,rep1;pat2,rep2…'.

   # File lib/rake/ext/string.rb
52 def pathmap_replace(patterns, &block)
53   result = self
54   patterns.split(';').each do |pair|
55     pattern, replacement = pair.split(',')
56     pattern = Regexp.new(pattern)
57     if replacement == '*' && block_given?
58       result = result.sub(pattern, &block)
59     elsif replacement
60       result = result.sub(pattern, replacement)
61     else
62       result = result.sub(pattern, '')
63     end
64   end
65   result
66 end