NAME

Badger::Filesystem::Path - generic fileystem 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

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.

	Global
`s`	Focus search bar
`?`	Bring up this help dialog

	GitHub
`g` `p`	Go to pull requests
`g` `i`	go to github issues (only if github is preferred repository)

	POD
`g` `a`	Go to author
`g` `c`	Go to changes
`g` `i`	Go to issues
`g` `d`	Go to dist
`g` `r`	Go to repository/SCM
`g` `s`	Go to source
`g` `b`	Go to file browse

	Search terms
module: (e.g. module:Plugin)
distribution: (e.g. distribution:Dancer auth)
author: (e.g. author:SONGMU Redis)
version: (e.g. version:1.00)