Mac::Path::Util - convert between darwin and Mac paths

	use Mac::Path::Util;

	my $path     = Mac::Path::Util->new( "/Users/foo/file.txt" );
	my $mac_path = $path->mac_path;

	http://sourceforge.net/projects/brian-d-foy/

# $Id: Util.pm 2666 2008-08-15 14:33:04Z comdog $
package Mac::Path::Util;
use strict;

use warnings;
no warnings;

use base qw(Exporter);
use vars qw(@EXPORT_OK %EXPORT_TAGS $VERSION);

use Cwd qw(getcwd);
use Exporter;

@EXPORT_OK   = qw(DARWIN MACOS);
%EXPORT_TAGS = (
	'system' => [ qw(DARWIN MACOS) ],
	);
$VERSION = '0.26';

my $Startup;

use constant DARWIN    => 'darwin';
use constant MACOS     => 'macos';

use constant DONT_KNOW => "Don't know";
use constant BAD_PATH  => "Bad Path";

use constant TRUE      => 'true';
use constant FALSE     => 'false';

use constant LOCAL     => 'local';
use constant REMOTE    => 'remote';

use constant STARTUP   => 'Startup';

sub new
	{
	my $class = shift;
	my $path  = shift;
	my $args  = shift;

	my $type  = DONT_KNOW
		unless ( $args->{type} && ( $args->{type} eq DARWIN 
			or $args->{type} eq MACOS ) );

	my $self = {
		starting_path   => $path,
		type            => $type,
		path            => $path,
		use_carbon      => ( $^O eq 'darwin' or $^O =~ /MacOS/ ),
		};
	
	bless $self, $class;

	$self->{startup} = $args->{startup} || undef;

	$self->_identify;

	return if $self->{type} eq BAD_PATH;

	# we know that there is at least one colon in the path
	# if the type is MACOS
	if( $self->type eq MACOS )
		{
		$self->{mac_path} = $self->path;

		# absolute paths do not start with colons
		if( index( $self->path, 0, 1 ) ne ":" )
			{
			my( $volume )= $self->path =~ m/^(.+?):/g;

			$self->{volume} = $volume;
			}
		else
			{
			$self->{volume}  = $self->_get_startup;
			$self->{startup} = $self->volume 
				if $self->_is_startup( $self->{volume} ) eq TRUE;
			}
		}
	elsif( $self->type eq DARWIN )
		{
		$self->{darwin_path} = $self->path;

		if( index( $self->path, 0, 1 ) eq "/" )
			{
			$self->{volume} = $self->path =~ m|^/Volumes/(.*?)/?|g;
			}

		unless( defined $self->volume )
			{
			$self->{volume}  = $self->_get_startup;
			$self->{startup} = $self->volume 
				if $self->_is_startup( $self->{volume} ) eq TRUE;
			}
			
		$self->_darwin2mac;
		}


	return $self;
	}

sub type            { return $_[0]->{type}        }
sub path            { return $_[0]->{path}        }
sub volume          { return $_[0]->{volume}      }
sub startup         { return $_[0]->{startup}     }
sub mac_path        { return $_[0]->{mac_path}    }
sub darwin_path     { return $_[0]->{darwin_path} }

sub use_carbon
	{ 
	my $self = shift;
	
	$self->{use_carbon} = $_[0] ? 1 : 0;
	
	$self->clear_startup
	}

sub _d2m_trans
	{
	my $name = shift;

	$name =~ tr|/:|:/|;

	return $name;
	}

sub _darwin2mac
	{
	my $self = shift;

	my $name = $self->{starting_path};

	$self->{mac_path} = do {
		# is this a relative url?
		if(    substr( $name, 0, 1 ) ne "/" )
			{
			my $path = ":" . _d2m_trans( $name );
			$path;
			}
		# is this an absolute url with another Volume?
		elsif( $name =~ m|^/Volumes/([^/]+)(/.*)| )
			{
			my $volume = $1;
			my $path   = $2;

			$path = _d2m_trans( $path );

			my $abs = $volume .  $path;
			}
		# absolute path off of startup volume?
		elsif( substr( $name, 0, 1 ) eq "/" )
			{
			my $volume = $self->_get_startup;

			my $path = _d2m_trans( $name );

			my $abs = $volume . $path;
			}
		};

	return $self->{mac_path};
	}

sub _mac2darwin
	{
	my $self = shift;
	my $name = shift;

	$name =~ tr|/:|:/|;

	return $name;
	}

sub _identify
	{
	my $self = shift;

	my $colons = 0;
	my $slashes = 0;

	if ( defined $self->{starting_path} ) {
		$colons  = $self->{starting_path} =~ tr/://;
		$slashes = $self->{starting_path} =~ tr|/||;
	}

	if(    $colons == 0 and $slashes == 0 )
		{
		$self->{type} = DONT_KNOW;
		}
	elsif( $colons != 0 and $slashes == 0 )
		{
		$self->{type} = MACOS;
		}
	elsif( $colons == 0 and $slashes != 0 )
		{
		$self->{type} = DARWIN;
		}
	elsif( $colons != 0 and $slashes != 0 )
		{
		$self->{type} = DONT_KNOW;
		}

	}

sub clear_startup
	{
	my $self = shift;

	delete $self->{startup} if ref $self;
	$Startup = undef;
	}

sub _get_startup
	{
	my $self = shift;
	
	return $self->startup if defined $self->startup;
	return $Startup if defined $Startup;

	my $volume = do {
		if( $self->{use_carbon} and eval { require MacPerl } )
			{
			(my $volume = scalar MacPerl::Volumes()) =~ s/^.+?:(.+)$/$1/;
			$volume;
			}
		else
			{
			STARTUP;
			}
		};
		
	#print STDERR "I think the startup volume is [$volume]\n";

	$Startup = $self->{startup} = $volume;

	return $volume;
	}

sub _is_startup
	{
	my $self = shift;
	my $name = shift;

	$self->_get_startup unless defined $self->startup;
	
	$name eq $Startup ? TRUE : FALSE;
	}

"See why 1984 won't be like 1984";