Tie::Filesystem - request for review

[erikharrison]

It's been awhile, so pardon if this should go in Meditations.

I've been tinkering around with writing a filemanager in Perl for a while. For implementing basic functionality the abstraction that kept coming to me was to see the filesystem as a hash of hashes and scalars. The following tie is a first cut at that.

package Tie::Filesystem;

use warnings;
use strict;

our $DIR_SEP = '/';

sub TIEHASH {
  my $class = shift;
  my $root  = shift || '/';
  
  bless {root => $root}, $class;
}

sub FETCH {
  my $self = shift;
  my $leaf = shift;
  
  my $pathname = $self->{'root'} . $DIR_SEP . $leaf;
  
  return undef unless -e $pathname;
  
  if (-d $pathname) {
    my %dir;
    tie %dir, 'Tie::Filesystem', $pathname;
    return \%dir;
  }
  
  return $pathname; #in the future, possibly return something useful
}

sub EXISTS {
  my $self = shift;
  my $leaf = shift;
  
  return -e ($self-{'root'} .  $DIR_SEP . $leaf);
}

sub FIRSTKEY {
  my $self = shift;
  
  opendir DIR, $self->{'root'} or return undef;
  $self->{'dir_handle'} = \*DIR; #This magic allows NEXTKEY to work al
+most sanely;
  
  return readdir DIR;
}

sub NEXTKEY {
  my $self = shift;
  my $dir = $self->{'dir_handle'};
  return undef unless $dir;
  
  my $entry = readdir $$dir;
  closedir $$dir unless $entry;
  
  return $entry;
}

1;

The first bit of Perl I've written in a long while follows. It passes my preliminary test code, but I'm sure it's full of bugs and gotchas. I'm hoping some of y'all could give it a look, and tell me what you think. Specifically, are there any obvious bugs, and what feature would seem useful extensions of the current behavior?

[Aragorn]

To make it nice and portable, consider using File::Spec (or its functional sibling File::Spec::Functions. Using that, you don't have to have the DIR_SEP variable, as you can use catdir. For example:

my $pathname = $self->{'root'} . $DIR_SEP . $leaf;

becomes

my $pathname = catdir($self->{'root'}, $leaf);

Also

return -e ($self-{'root'} .  $DIR_SEP . $leaf);

will probably not do what you expect. New testcase ;-)

Arjen

[BrowserUk]

On the surface, this looks vaguely similar to Tie::Dir?

[erikharrison]

Similar. The difference is that Tie::Dir returns a stat for the value of each key. Tie::Filesystem returns another tied hash for directories. I haven't decided what to return in for files yet.

use Tie::Filesytem;

tie %root, Tie::Filesystem;

print "Perl Found!" if exists $root{usr}->{bin}{perl};

[jepri]

You mean like a filehandle or a scalar? I'd like to be able to open a data file with $root->{tmp}->{data.txt}.

The idea of just reading and writing a file by assigning to a hash is very tempting, although getting a filehandle back might be better if it has to be passed to other functions.

If you add either, I could see myself using it heavily, not the least because it would allow me to transparently fake a filesystem. VFS perl style. Woo hoo!

[trialmonkey]

I have some XML data that's hierarcically orgainzed and stored within the filesystem. Each data file is relatively small. Slurping and writing the data back out using a hash assignment would make for a nice interface to my data.

A feature that allowed me to return a list of files filtered by access or change time would be also be useful.