This is a Ruby tree! It shows every object from the Ruby Programming Language in a tree format.

pathmap 

        # String.pathmap

(from gem rake-13.0.6)
---
    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 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,class}X.class")

returns:

    "class/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"

This String extension comes from Rake

This is MURDOC! A Ruby documentation browser inspired by Smalltalk-80. It allows you to learn about Ruby by browsing through its class hierarchies, and see any of its methods.