Badger::Filesystem::Path
- NAME
- SYNOPSIS
- INTRODUCTION
- DESCRIPTION
- METHODS
- new($path)
- init(\%config)
- path()
- is_absolute()
- is_relative()
- absolute($base)
- relative($base)
- definitive()
- canonical()
- collapse()
- above($child)
- below($parent)
- base()
- parent($skip_generations) / up($skip_generations)
- path_up()
- exists()
- must_exist($create)
- create()
- chmod($perms)
- stat()
- stats()
- restat()
- device()
- inode()
- mode()
- permissions() / perms()
- links()
- user()
- group()
- device_type()
- size()
- atime()
- accessed()
- mtime()
- modified()
- ctime()
- created()
- block_size()
- blocks()
- readable()
- writeable()
- executable()
- owner()
- filesystem()
- visit($visitor)
- accept($visitor)
- enter($visitor)
- collect(\%params)
- metadata() / meta()
- STUB METHODS
- is_file()
- is_directory() / is_dir()
- volume() / vol()
- directory() / dir()
- name()
- extension() / ext()
- basename() / base_name()
- AUTHOR
- COPYRIGHT
- ACKNOWLEDGEMENTS
- SEE ALSO
# 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
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.
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']);
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.
Default initialisation method which subclasses (e.g. Badger::Filesystem::Directory and Badger::Filesystem::File) can redefine.
This method returns the path as a text string. It is called automatically whenever the path object is stringified.
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
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
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
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.
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.
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).
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.
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
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 /
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').
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... }
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
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
This method changes the file permissions on a file or directory.
$file->chmod(0775);
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
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.
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.
Returns the file mode for the file. Note that this contains both the file type and permissions. See stat().
Returns the file permissions. This is equivalent to $file->mode
& 0777
.
Returns the time (in seconds since the epoch) that the file was last accessed. See stat().
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
Returns the time (in seconds since the epoch) that the file was last modified. See stat().
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
Returns the time (in seconds since the epoch) that the file was created. See stat().
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
Returns the preferred block size for file system I/O on the file. See stat().
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().
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().
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().
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().
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');
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.
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.
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;
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
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.
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.
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.
Returns any volume defined as part of the path. This method does nothing
in the Badger::Filesystem::Path
base class.
Returns the directory portion of a path. This method does nothing in the
Badger::Filesystem::Path
base class.
Returns the file name portion of a path. This method does nothing in the
Badger::Filesystem::Path
base class.
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
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
Andy Wardley http://wardley.org/
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.