Class | String
In: | lib/rake.rb
Parent: | Object

User defined methods to be added to String.

### Methods

ext pathmap pathmap_explode pathmap_partial pathmap_replace

### 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.

`ext` is a user added method for the String class.

[Source]

        # 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:

- %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 separater 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 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"

[Source]

         # 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`.

[Source]

        # 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.

[Source]

         # 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…’.

[Source]

         # 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

[Validate]