eloquent / pathogen Goto Github PK

Retrieves a single atom at a given index.

Also should probably accept negative indices.

See http://en.wikipedia.org/wiki/Path_(computing)#UNC_in_Windows

It's a common use case for paths to use ~ or ~user to indicate home directories. Pathogen should have a system for dealing with these cases.

Some things that probably need to happen:

1. FileSystemPathFactoryInterface includes methods to get the current working directory, and system temporary directory. It probably needs to be expanded to have methods to get the current home directory, and the home directory of a specified user. They should always internally use the 'platform' path factory - this just ensures that they are Windows paths on Windows, and Unix-style on anything else.
2. A new resolver at FileSystem\Resolver\HomeDirectoryResolver that implements the newly refactored PathResolverInterface and uses an instance of PlatformFileSystemPathFactory to produce home directory paths using the new methods created in 1. This resolver could probably cache home directory lookups, I assume they're unlikely to change at runtime.

This task could be tackled at the same time as #36.

BoundPathResolverInterface is not the best name. There are other circumstances where a path may need to be resolved without need of a base path (against the environment, for example).

Perhaps the interfaces should be PathResolverInterface for something that simply accepts a path and returns a resolved path with no need for other parameters, and BasePathResolverInterface for the type that takes a base path to resolve against.

Is it currently possible to do a "reverse resolving"? Get relative subdirectory path from base path and absolute path?

$basePath = '/var/www/';
$absolutePath = FileSystemPath::fromString('/var/www/project/public/index.php');
$relativePath = $absolutePath->getRelativePath($basePath);
// project/public/index.php

The github landing page for pathogen displays the dev branch and it's outdated documentation. Example: the ::fromString(...) calls we're removed some time ago, but are the main instantiation method shown on the front page's readme. Thanks!

Yes, this really is a thing. Example:

D:.\foo

means .\foo relative to the current working directory for D: drive. Windows paths have a current working directory per drive it seems. Fortunately (or unfortunately), there is no way to retrieve the CWD for a drive other than the current one via PHP.

So, in combination with #30, a few things need to happen to improve Windows path support:

• Relative Windows paths need to store an optional drive
• Relative Windows paths need an additional property to mark them as 'absolute, but driveless'
• Absolute Windows paths need to make the drive mandatory
• A custom Windows path resolver needs to be implemented to handle the drive-related logic. Something like:
  • If the path is absolute, return immediately.
  • If the relative path is 'driveless absolute', set the drive to the current drive and return.
  • If the relative path has a drive, and it's different to the current drive, resolve against the root of the drive specified in the path.
  • Resolve all other cases against the CWD.

Complimentary methods that convert between relative and absolute, without any resolution logic.

The previous version simply took a static 'working directory' path that never changed. Pretty useless. This version needs to implement the recently refactored PathResolverInterface and fetch the current working directory from a PlatformFileSystemPathFactory on each resolution. Closely tied to #33.

• contains()
• startsWith()
• endsWith()
• matches() (see fnmatch())
• matchesRegex()
• nameContains()
• nameStartsWith()
• nameMatches() (see fnmatch())
• nameMatchesRegex()

@darianbrown Any interest in giving this one a go?

For example, '/foo/bar/qux/doom' relative to '/foo/bar/baz/doom' currently returns '../qux'.

After some discussion, it seems to be the consensus that an absolute path should always have a drive letter, otherwise it's not truly absolute, but relative to the current drive.