Provided by: libbadger-perl_0.16-2_all 
NAME
Badger::Filesystem::Path - generic filesystem path object
SYNOPSIS
# using Badger::Filesytem constructor subroutine
use Badger::Filesystem 'Path';
# use native OS-specific paths:
$path = Path('/path/to/something');
# or generic OS-independant paths
$path = Path('path', 'to', 'something');
# manual object construction
use Badger::Filesystem::Path;
# positional arguments
$path = Badger::Filesystem::Path->new('/path/to/something');
$path = Badger::Filesystem::Path->new(['path', 'to', 'something']);
# named parameters
$path = Badger::Filesystem::Path->new(
path => '/path/to/something'
);
$path = Badger::Filesystem::Path->new(
path => ['path', 'to', 'something']
);
# path inspection methods
$path->path; # current path
$path->base; # parent directory or path itself
$path->parent; # directory object for base
$path->extension # filename .XXX extension
$path->basename # filename without .XXX extension
$path->is_absolute; # path is absolute
$path->is_relative; # path is relative
$path->exists; # returns true/false
$path->must_exist; # throws error if not
@stats = $path->stat; # returns list
$stats = $path->stat; # returns list ref
# path translation methods
$path->relative; # relative to cwd
$path->relative($base); # relative to $base
$path->absolute; # relative to filesystem root
$path->definitive; # physical file location
$path->collapse; # resolve '.' and '..' in $path
# path comparison methods
$path->above($another_path); # $path is ancestor of $another_path
$path->below($another_path); # $path is descendant of $another_path
INTRODUCTION
This is the documentation for the "Badger::Filesystem::Path" module. It defines a base
class object for the Badger::Filesystem::File and Badger::Filesystem::Directory objects
which inherit (and in some cases redefine) the methods described below.
In other words, you should read this documentation first if you're working with
Badger::Filesystem::File or Badger::Filesystem::Directory objects.
DESCRIPTION
The "Badger::Filesystem::Path" module defines a base class object for representing paths
in a real or virtual file system.
You can create a generic path object (e.g. to represent a path that doesn't relate to a
specific file or directory in a file system), using the "Path" constructor method in
Badger::Filesystem.
use Badger::Filesystem 'Path';
my $path = Path('/path/to/something');
However in most cases you'll want to create a file or directory subclass object. The
easiest way to do that is like this:
use Badger::Filesystem 'File Path';
my $file = File('/path/to/file');
my $dir = Dir('/path/to/dir');
If you're concerned about portability to other operating systems and/or file systems, then
you can specify paths as a list or reference to a list of component names.
my $file = File('path', 'to', 'file');
my $dir = Dir(['path', 'to', 'dir']);
METHODS
new($path)
Constructor method to create a new "Badger::Filesystem::Path" object. The path can be
specified as a single positional argument, either as a text string or reference to list of
path components.
# single text string
$path = Badger::Filesystem::Path->new('/path/to/something');
# reference to list
$path = Badger::Filesystem::Path->new(['path', 'to', 'something']);
It can also be specified as a "path" named parameter.
# named parameter list
$path = Badger::Filesystem::Path->new(
path => '/path/to/something'
);
# reference to hash of named parameter(s)
$path = Badger::Filesystem::Path->new({
path => '/path/to/something'
});
The constructor method also recognises the "filesystem" named parameter which can contain
a reference to the Badger::Filesystem object or class that created it. In most cases you
can rely on the Badger::Filesystem to create path objects for you, using either the path()
method, or the Path() subroutine.
use Badger::Filesystem 'FS Path';
# FS is alias for 'Badger::Filesystem'
# Path() is constructor subrooutine
my $path;
# using the path() method
$path = FS->path('/path/to/something');
$path = FS->path('path', 'to', 'something');
$path = FS->path(['path', 'to', 'something']);
# using the Path() subroutine
$path = Path('/path/to/something');
$path = Path('path', 'to', 'something');
$path = Path(['path', 'to', 'something']);
The examples that follow will use the "Path()" constructor subroutine.
init(\%config)
Default initialisation method which subclasses (e.g. Badger::Filesystem::Directory and
Badger::Filesystem::File) can redefine.
path()
This method returns the path as a text string. It is called automatically whenever the
path object is stringified.
is_absolute()
Returns true if the path is absolute, false if not.
is_relative()
Returns true if the path is relative, false if not.
absolute($base)
Returns an absolute representation of the path, relative to the $base path passed as an
argument, or the current working directory if $base is not specified.
# assume cwd is /foo/bar,
my $path = Path('/baz/bam');
print $path->absolute; # /foo/bar/baz/bam
print $path->absolute('/wiz'); # /wiz/baz/bam
relative($base)
Returns a relative representation of the path, relative to the $base path passed as an
argument, or the current working directory if $base is not specified.
# assume cwd is /foo/bar,
my $path = Path('/foo/bar/baz/bam');
print $path->relative; # /baz/bam
print $path->relative('/foo'); # /bar/baz/bam
definitive()
Returns the definitive representation of the path which in most cases will be the same as
the absolute() path.
However, if you're using a virtual filesystem, then the definitive path will include the
virtual root directory, whereas a the absolute path will not.
my $vfs = Badger::Filesystem::Virtual->new( root => '/my/vfs' );
my $path = $vfs->file('/foo/bar');
print $path->absolute; # /foo/bar
print $path->definitive; # /my/vfs/foo/bar
canonical()
This method returns the canonical representation of the path. In most cases this is the
same as the absolute path (in fact the base class aliases the "canonical()" method
directly to the absolute() method).
print Path('foo')->canonical; # /your/current/path/foo
print Path('/foo/bar')->canonical; # /foo/bar
print Path('/foo/bar/')->canonical; # /foo/bar
print Path('/foo/bar.txt')->canonical; # /foo/bar.txt
Note that the "Badger::Filesystem::Path" base class will remove any trailing slashes (or
whatever the appropriate directory separator is for your filesystem) from the end of an
absolute path.
In the case of directories, implemented by the Badger::Filesystem::Directory subclass, a
trailing slash (or relevant separator for your filesystem) will be added.
print Dir('/foo/bar')->canonical; # /foo/bar/
This is done by delegation to the slash_directory() method in Badger::Filesystem.
collapse()
Reduces the path to its simplest form by resolving and removing any "." (current
directory) and ".." (parent directory) components (or whatever the corresponding tokens
are for the current and parent directories of your filesystem).
my $path = Path('/foo/bar/../baz')->collapse;
print $path; # /foo/baz
See the collapse_dir() method in Badger::Filesystem for further information.
above($child)
Returns true if the path is "above" the $child path passed as an argument. Formally, we
say that the path is an ancestor of $child meaning that it is the parent directory, or
grand-parent, or great-grand-parent, and so on.
my $parent = Path('/foo/bar');
my $child = Path('/foo/bar/baz');
$parent->above($child); # true
This is implemented as a simple prefix match. That is, the parent path must appear at the
start of the child path. Consequently, this method will not account for symbolic links or
other similar filesystem features, and it may not work properly on systems that don't
follow this convention (although there are none that I'm aware of).
below($parent)
Returns true if the path is "below" the $parent path passed as an argument. Formally, we
say that the path is a descendant of $parent meaning that it is an immediate sub-
directory, or sub-sub-directory, and so on.
my $parent = Path('/foo/bar');
my $child = Path('/foo/bar/baz');
$child->below($parent); # true
Like above(), this is implemented using a simple prefix match.
base()
Returns the base directory of a path. For Badger::Filesystem::Path and
Badger::Filesystem::Directory objects, this method will return the complete path.
print Path('/foo/bar')->base; # /foo/bar
print Directory('/foo/bar')->base; # /foo/bar
However the Badger::Filesystem::File module returns the parent directory in which the file
is located.
print File('/foo/bar')->base; # /foo
parent($skip_generations) / up($skip_generations)
Returns a Badger::Filesystem::Directory object representing the parent directory for a
path.
Path->('/foo/bar')->parent; # path object for /foo
A numerical argument can be provided to indicate the number of generation you want to
skip. A value of 0 is the same as providing no argument - it returns the parent. A value
of 1 skips the parent and returns the grand-parent, and so on.
Path->('/foo/bar/baz/bam')->parent(2); # path object for /foo
The root directory will be returned if you try to skip too many generations.
Path->('/foo/bar/baz/bam')->parent(20); # path object for /
path_up()
This returns a text string representing the parent of a path. If the path contains
multiple items (e.g. '/foo/bar' or 'foo/bar') then the last item will be removed (e.g.
resulting in '/foo' or 'foo' respectively). If an absolute path contains one item or none
(e.g. '/foo' or '/') then the root directory ('/') will be returned. A relative path with
only one item (e.g. 'foo') is assumed to be relative to the current working directory
which will be returned (e.g. '/path/to/current/dir').
exists()
Returns true if the path exists in the filesystem (e.g. as a file, directory, or some
other entry), or false if not.
if ($path->exists) {
print "$path already exists\n";
}
else {
print "Creating $path\n";
# ...etc...
}
must_exist($create)
Checks that the path exists (by calling exists()) and throws an error if it doesn't.
$path->must_exist; # no need to check return value
The $create flag can be set to have it attempt to create() itself if it doesn't already
exist. However, this only makes sense for file and directory subclasses and not base
class paths.
$dir->must_exist(1); # create if it doesn't
create()
In the base class this will method will throw an error. You can't physically create an
abstract path unless you know what kind of concrete entity (e.g. file or directory) it
maps onto. In other words, the create() method will only work for the
Badger::Filesystem::File and Badger::Filesystem::Directory subclasses.
$path->create; # FAIL
$dir->create; # OK
$file->create; # OK
chmod($perms)
This method changes the file permissions on a file or directory.
$file->chmod(0775);
stat()
Performs a filesystem "stat" on the path and returns a list (in list context), or a
reference to a list (in scalar context) containing the 13 information elements.
@list = $path->stat; # list context
$list = $path->stat; # scalar context
A summary of the fields is shown below. See "perldoc -f stat" for complete details. Each
of the individual fields can also be accessed via their own methods, also listed in the
table.
Field Method Description
------------------------------------------------------------------------
0 device() device number of filesystem
1 inoode() inode number
2 mode() file mode (type and permissions)
3 links() number of (hard) links to the file
4 user() numeric user ID of file’s owner
5 group() numeric group ID of file’s owner
6 device_type() the device identifier (special files only)
7 size() total size of file, in bytes
8 atime() last access time in seconds since the epoch
9 mtime() last modify time in seconds since the epoch
10 ctime() inode change time in seconds since the epoch (*)
11 block_size() preferred block size for file system I/O
12 blocks() actual number of blocks allocated
In addition to those that are returned by Perl's inbuilt "stat" function, this method
returns four additional flags.
13 readable() file is readable by current process
14 writeable() file is writeable by current process
15 executable() file is executable by current process
16 owner() file is owned by current process
stats()
A wrapper around the stat() method which caches the results to avoid making repeated
filesystem calls.
@list = $path->stats; # list context
$list = $path->stats; # scalar context
Note that the accessed(), created() and modified() methods also cache the
Badger::Timestamp objects they create to represent the access, creation and modification
times respectively.
restat()
Clears any cached values stored by the stats(), accessed(), created() and modified()
methods and calls stats() to reload (and re-cache) the data from a stat() call.
device()
Returns the device number for the file. See stat().
inode()
Returns the inode number for the file. See stat().
mode()
Returns the file mode for the file. Note that this contains both the file type and
permissions. See stat().
permissions() / perms()
Returns the file permissions. This is equivalent to "$file->mode & 0777".
links()
Returns the number of hard links to the file. See stat().
user()
Returns the numeric user ID of the file's owner. See stat().
group()
Returns the numeric group ID of the file's group. See stat().
device_type()
Returns the device identifier (for special files only). See stat().
size()
Returns the total size of the file in bytes. See stat().
atime()
Returns the time (in seconds since the epoch) that the file was last accessed. See
stat().
accessed()
Returns a Badger::Timestamp object for the atime() value. This object will auto-stringify
to produce an ISO-8601 formatted date. You can also call various methods to access
different parts of the time and/or date.
print $file->accessed; # 2009/04/20 16:25:00
print $file->accessed->date; # 2009/04/20
print $file->accessed->year; # 2009
mtime()
Returns the time (in seconds since the epoch) that the file was last modified. See
stat().
modified()
Returns a Badger::Timestamp object for the mtime() value.
print $file->modified; # 2009/04/20 16:25:00
print $file->modified->time; # 16:25:0
print $file->modified->hour; # 16
ctime()
Returns the time (in seconds since the epoch) that the file was created. See stat().
created()
Returns a Badger::Timestamp object for the ctime() value.
print $file->created; # 2009/04/20 16:25:00
print $file->created->date; # 2009/04/20
print $file->created->time; # 16:25:00
block_size()
Returns the preferred block size for file system I/O on the file. See stat().
blocks()
Returns the actual number of blocks allocated to the file. See stat().
readable()
Returns a true value if the file is readable by the current user (i.e. the owner of the
current process), false if not. See stat().
writeable()
Returns a true value if the file is writeable by the current user (i.e. the owner of the
current process), false if not. See stat().
executable()
Returns a true value if the file is executable by the current user (i.e. the owner of the
current process), false if not. See stat().
owner()
Returns a true value if the file is owned by the current user (i.e. the owner of the
current process), false if not. See stat().
filesystem()
Returns a reference to a Badger::Filesystem object, or the name of the filesystem class
(e.g. Badger::Filesystem or a subclass) that created the path object. If this is
undefined then the default value defined in the $FILESYSTEM class variable is returned.
Unless you've changed it, or re-defined it in a subclass, this value will be
"Badger::Filesystem".
The end result is that you can use the "filesystem" method to access a Badger::Filesystem
object or class through which you can perform other filesystem related operations. This
is used internally by a number of method.
# access filesystem via existing path
$path->filesystem->dir('/a/new/directory/object');
# same as
Badger::Filesystem->dir('/a/new/directory/object');
visit($visitor)
Entry point for a filesystem visitor to visit a filesystem path. A reference to a
Badger::Filesystem::Visitor object (or subclass) should be passed as the first argument.
use Badger::Filesystem::Visitor;
my $visitor = Badger::Filesystem::Visitor->new( recurse => 1 );
$path->visit($visitor);
Alternately, a list or reference to a hash array of named parameters may be provided.
These will be used to instantiate a new Badger::Filesystem::Visitor object (via the
Badger::Filesystem visitor() method) which will then be applied to the path. If no
arguments are passed then a visitor is created with a default configuration.
# either list of named params
$path->visit( recurse => 1 );
# or reference to hash array
$path->visit({ recurse => 1});
The method then calls the visitor visit() passing $self as an argument to begin the visit.
accept($visitor)
This method is called to dispatch a visitor to the correct method for a filesystem object.
In the Badger::Filesystem::Path base class, it calls the visitor visit_path() method,
passing the $self object reference as an argument. Subclasses redefine this method to call
other visitor methods.
enter($visitor)
This is a special case of the accept() method which subclasses (e.g. directory) use to
differentiate between the initial entry point of a visitor and subsequent visits to
directories contained therein. In the base class it simply delegates to the accept()
method.
collect(\%params)
This is a short-cut to call the visit() method and then the collect() method on the
Badger::Filesystem::Visitor object returned.
# short form
my @items = $path->collect( files => 1, dirs => 0 );
# long form
my @items = $path->visit( files => 1, dirs => 0 )->collect;
metadata() / meta()
This method allows you to associate metadata with a path. The method accepts multiple
arguments to set metadata:
$path->metadata( title => 'An Example', author => 'Arthur Dent' );
It also accepts a single argument to fetch a metadata item:
print $path->metadata('author'); # Arthur Dent
You can also call it without arguments. The method returns a reference to a hash array of
metadata items.
my $meta = $path->metadata;
print $meta->{ author }; # Arthur Dent
STUB METHODS
The following methods serve little or no purpose in the "Badger::Filesystem::Path" base
class. They are redefined by the "Badger::Filesystem::Directory" and
"Badger::Filesystem::File" modules to do the right thing.
is_file()
This method always returns false in the "Badger::Filesystem::Path" base class. The
"Badger::Filesystem::File" subclass redefines this to return true. NOTE: this may be
changed to examine the filesystem and return true if the path references a file.
is_directory() / is_dir()
This method always returns false in the "Badger::Filesystem::Path" base class. The
"Badger::Filesystem::Directory" subclass redefines this to return true. NOTE: this may be
changed to examine the filesystem and return true if the path references a file.
volume() / vol()
Returns any volume defined as part of the path. This method does nothing in the
"Badger::Filesystem::Path" base class.
directory() / dir()
Returns the directory portion of a path. This method does nothing in the
"Badger::Filesystem::Path" base class.
name()
Returns the file name portion of a path. This method does nothing in the
"Badger::Filesystem::Path" base class.
extension() / ext()
Returns any file extension portion following the final "." in the path. This works in the
"Badger::Filesystem::Path" base class by looking at the full path.
print Path('/foo/bar.txt')->extension; # txt
basename() / base_name()
Returns the filename without the file extension following the final "." in the path. This
works (for some definition of "works") in the "Badger::Filesystem::Path" base class by
looking at the path name(), if defined, or the full "path" if not. Note that this will
produce unexpected results in some cases due to the fact that the base class does not
define a value for name(). e.g.
print Path('/foo/bar.txt')->basename; # /foo/bar
However, in most cases you would be using this through a Badger::Filesystem::File subclass
which will product the correct results.
print File('/foo/bar.txt')->basename; # bar
AUTHOR
Andy Wardley <http://wardley.org/>
COPYRIGHT
Copyright (C) 2005-2009 Andy Wardley. All rights reserved.
ACKNOWLEDGEMENTS
The "Badger::Filesystem" modules are built around a number of existing Perl modules,
including File::Spec, File::Path, Cwd, IO::File, IO::Dir and draw heavily on ideas in
Path::Class.
Please see the ACKNOWLEDGEMENTS in Badger::Filesystem for further information.
SEE ALSO
Badger::Filesystem, Badger::Filesystem::File, Badger::Filesystem::Directory,
Badger::Filesystem::Visitor.