VFS::Gnome - Gnome Virtual Filesystem for Perl

  use VFS::Gnome;

  vfsopen(*IN, "<http://www.piersharding.com") or die $!;
  # dont forget the * when using strict
  print while (<IN>);
  close IN;

  http://developer.gnome.org/doc/API/gnome-vfs/ and perldoc Tie::Handle

package VFS::Gnome;
use strict;
require 5.006;
use Carp;
require DynaLoader;
require Exporter;
use vars qw(@ISA $VERSION @EXPORT_OK $RUN_ONCE);
$VERSION = '0.05';
@ISA = qw(DynaLoader Exporter);

use Data::Dumper;

sub dl_load_flags { 0x01 }
VFS::Gnome->bootstrap($VERSION);


# export the open command, and initialise gnome-vfs
my @export_ok = ("vfsopen", "vfsexists", "vfsstat", "vfsmove", "vfsunlink", "vfsopendir" );
sub import {

  my ( $caller ) = caller;

  no strict 'refs';
  foreach my $sub ( @export_ok ){
    *{"${caller}::${sub}"} = \&{$sub};
  }

  # initialise the vfs engine
  do_vfs_init();

}

# open a file handle with vfs
sub vfsopen {

  my ( $caller ) = caller;
  my $handle = shift;
  $handle =~ s/.*:://;
  no strict 'refs';
  return tie *{"${caller}::${handle}"}, __PACKAGE__, @_;

}

# open a directory handle with vfs
sub vfsopendir {

  my ( $caller ) = caller;
  my $handle = shift;
  $handle =~ s/.*:://;
  no strict 'refs';
  return tie *{"${caller}::${handle}"}, __PACKAGE__, @_;

}

# check that the uri exists
sub vfsexists {

  my $uri = shift;
  return do_vfs_exists($uri);

}

# get posix style stats on uri
sub vfsstat {

  my $uri = shift;
  my $stats = do_vfs_stat($uri);
  if (ref($stats)){
    return @{$stats};
  } else {
    return $stats;
  }

}

# move one uri to another
sub vfsmove {

  my ($furi, $turi) = @_;
  die "from uri($furi) does not exist\n"
     unless vfsexists($furi);
  die "to uri does not exist\n"
     unless $turi;
  return do_vfs_move($furi, $turi);

}

# unlink/delete a given uri
sub vfsunlink {

  my $uri = shift;
  die "uri($uri) to delete does not exist\n"
     unless vfsexists($uri);
  return do_vfs_unlink($uri);

}


# instantiate the tied object
sub TIEHANDLE {

  my $caller = (caller(1))[3];
  $caller =~ s/.*:://;
  my $class = shift;
  my $file = shift;

  # determine if this is a file or directory call
  if ($caller eq 'vfsopen'){
    my ($meth, $uri) = $file =~ /^([\<\>]+)(.*?)$/;

    die "No file open method specified - $file\n"
      unless $meth;
    die "no open method/file name specified - $file\n"
      unless $uri;
    die "open method unsupported - $file\n"
      unless $meth eq '<' or $meth eq '>' or $meth eq '>>';

    my $self = { 'uri' => $file, 
                 'type' => 'file',
                 'rows' => [],
                 'buffer' => "",
                 'eof' => undef,
                 'nline' => $/,
                 'handle' => 
		   do_vfs_open($uri, $meth =~ />/ ? 1 : 0, $meth eq '>>' ? 1 : 0)
	       };
    bless($self, $class);
    return $self;
  } elsif ($caller eq 'vfsopendir'){

    my $self = { 'uri' => $file, 
                 'type' => 'dir',
                 'rows' => [],
                 'buffer' => "",
                 'eof' => undef,
                 'handle' => do_vfs_dir_open($file)
	       };
    bless($self, $class);
    return $self;
  }

  # the TIE fails
  return undef;

}


# read next buffer of a vfs file handle
sub READLINE {

  my $self = shift;

  if ( $self->{'type'} eq 'file' ){
    if ($self->{'nline'} ne $/){
        $self->{'buffer'} = join("",@{$self->{'rows'}});
        $self->{'rows'} = [];
        $self->{'nline'} = $/;
    }

    # Find the next available record
    my $buf = "";
    # return the rest of the file
    if ( wantarray() ){
        $self->{'buffer'} .= $buf
	    while ($buf = do_vfs_read($self->{'handle'}));
        @{$self->{'rows'}} = split(/$self->{nline}/, $self->{'buffer'}, -1);
        for (my $i = 0; $i < @{$self->{'rows'}} - 1; $i++){
          $self->{'rows'}->[$i] .= $self->{'nline'};
  	}
        $self->{'buffer'} = undef;
	$self->{'eof'} = 1;
	my $last = $self->{'rows'}->[-1];
	pop@{$self->{'rows'}} unless defined($last);
	return @{$self->{'rows'}};
     
    # get the next record
    } else {
      while ( ! $self->{'eof'} && scalar @{$self->{'rows'}} < 1  ){
        $buf =  do_vfs_read($self->{'handle'});
        # drop out if we are at the end of the file
        if ( ! defined($buf) ){
          $self->{'eof'} = 1;
          @{$self->{'rows'}}  = ( $self->{'buffer'} );
	  last;
	}

	# ok - we got some
        $self->{'buffer'} .= $buf;
        if ( $self->{'buffer'} =~ /$self->{nline}/s ){
          @{$self->{'rows'}} = split(/$self->{nline}/, $self->{'buffer'}, -1);
	  $self->{'buffer'} = pop(@{$self->{'rows'}});
          foreach (@{$self->{'rows'}}){
            $_ .= $self->{'nline'};
  	  }
          last;
        }
      }
      return @{$self->{'rows'}} ? shift(@{$self->{'rows'}}) : undef;
    }

  } elsif ( $self->{'type'} eq 'dir' ){
      # return a list of directories if in array context
      if (wantarray()){
       my @dir = ();
       while (my $dir = do_vfs_dir_read_next($self->{'handle'}) ){
         push(@dir, $dir->[-1]);
       }
       $self->{'eof'} = 1;
       return @dir;
      } else {
        # in scalar - return the next directory entry in stat format
        my $dirent = do_vfs_dir_read_next($self->{'handle'});
	$self->{'eof'} = 1 unless defined($dirent);
	return $dirent;
      }
  }

}


sub EOF {
 
  my $self = shift;
  # you dont do this with a directory
  return undef if $self->{'type'} eq 'dir';
  return $self->{'eof'};

}


sub BINMODE {
 die "not finished!";

}


sub UNTIE {
 die "not finished!";

}


sub DESTROY {
 #die "not finished!";

}


# print to a vfs file handle
sub PRINT {

  my $self = shift;
  # you dont do this with a directory
  return undef if $self->{'type'} eq 'dir';
  my $buffer = join("",@_);
  return do_vfs_write($self->{'handle'}, $buffer);

}


# close a vfs file handle
sub CLOSE {

  my $self = shift;
  if ($self->{'type'} eq 'dir'){
    die "Directory Close failed \n" unless do_vfs_dir_close($self->{'handle'});
  } elsif ($self->{'type'} eq 'file'){
    die "Close failed \n" unless do_vfs_close($self->{'handle'});
  }

}


#==============================================================================

1;