Provided by: libbadger-perl_0.16-3_all bug

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.