WWW::Myspace::FriendChanges - Track additions/deletions to your friends list

	use WWW::Myspace;
    use WWW::Myspace::FriendChanges;

	my $myspace = new WWW::Myspace;

    my $foo = WWW::Myspace::FriendChanges->new( $myspace );

	OR

	my $foo = WWW::Myspace::FriendChanges->new( $myspace, $cache_file )

	# Get the list of deleted friends.
	@deleted_friends = $foo->deleted_friends;

	# Get the list of new friends
	@added_friends = $foo->added_friends;

	# Write the current friend list into the cache file.
	$foo->write_cache;

	my $cache_file = $friend_changes->cache_file;

	print $cache_file;

	Usage:

	use WWW::Myspace;
	use WWW::Myspace::FriendChanges;

	my $myspace = new WWW::Myspace;
	my $friend_changes = new FriendChanges( $myspace );

	my @deleted_friends = $friend_changes->deleted_friends;

    perldoc WWW::Myspace::FriendChanges

package WWW::Myspace::FriendChanges;

use warnings;
use strict;
use Carp;
use File::Spec::Functions;

our $VERSION = '0.04';

sub new {
	my $proto = shift;
	my $class = ref($proto) || $proto;
 	my $self  = {};
	bless ($self, $class);
 	$self->{myspace} = shift if @_;
 	$self->{cache_file} = shift if @_;
	return $self;
}

# _last_friends
# Internal method that reads the cache file into an internal hash.
# Sets $self->{last_friends} to a reference to a hash, the keys of which
# are friendIDs.
sub _last_friends {
	my $self = shift;
	
	my %last_friends = ();

	if ( -f $self->cache_file ) {
		open( CACHE, "<", $self->cache_file ) or croak "Can't open cache file.\n";
	} else {
		$self->{last_friends} = {};
		return;
	}
	
	foreach my $id ( <CACHE> ) {
		chomp $id;
		$last_friends{"$id"}++;
	}
	
	close CACHE;
	
	$self->{last_friends} = \%last_friends;

}

# _current_friends
# Internal convenience method to set the list of current friends.
# Sets $self->{current_friends} to a reference to a hash, the keys
# of which are friendIDs. (This makes comparisons easy and fast).
sub _current_friends {
	my $self = shift;

	my %friends = ();

	my @friends = $self->{myspace}->get_friends;
	die $self->{myspace}->error . "\n" if ( $self->{myspace}->error );

	foreach my $id ( @friends ) {
		$friends{"$id"}++;
	}

	$self->{current_friends} = \%friends;
}

sub set_cache_file {
	my $self = shift;

	$self->cache_file( @_ );

}

sub cache_file {
	my $self = shift;

	if ( @_ ) {
		$self->{cache_file} = shift;
		# Clear out the last_friends list
		$self->{last_friends} = undef;
	} elsif (! defined $self->{cache_file} ) {
		# Make the cache dir if it doesn't exist.
		$self->{myspace}->make_cache_dir;
		$self->{cache_file} = catfile( $self->{myspace}->cache_dir,
			'friend_cache' );
	}

	return $self->{cache_file};

}

sub write_cache {

	my $self = shift;

	open( CACHE, ">", $self->cache_file ) or croak "Can't open cache file.\n";
	
	foreach my $id ( keys( %{ $self->{current_friends} } ) ) {
		print CACHE "$id\n";
	}
	
	close CACHE;

}

sub deleted_friends {

	my $self = shift;

	my @deleted_friends = ();

	# Loop through the list of friends loaded from the cache file.
	# If theyre in that list, but not the current list, they deleted
	# themselves.
	unless ( defined $self->{deleted_friends} ) {
	
		unless ( defined $self->{last_friends} ) { $self->_last_friends }
		unless ( defined $self->{current_friends} ) { $self->_current_friends }
		
		# If they're in last_friends, but not in current friends, they deleted us.
		foreach my $id ( keys( %{ $self->{last_friends} } ) ) {
			unless ( ${ $self->{current_friends} }{"$id"} ) {
				push( @deleted_friends, $id );
			}
		}
		
		$self->{deleted_friends} = \@deleted_friends;
	}
	
	return ( @{ $self->{deleted_friends} } );
	
}

sub added_friends {
	my $self = shift;

	my @added_friends = ();
	
	# Loop through the list of current friends. If the friend is in
	# the current list but not the last list, they're a new add.
	unless ( defined $self->{added_friends} ) {
	
		unless ( defined $self->{last_friends} ) { $self->_last_friends }
		unless ( defined $self->{current_friends} ) { $self->_current_friends }

		# If they're in last_friends, but not in current friends, they deleted us.
		foreach my $id ( keys( %{ $self->{current_friends} } ) ) {
			unless ( ${ $self->{last_friends} }{"$id"} ) {
				push( @added_friends, $id );
			}
		}
		
		$self->{added_friends} = \@added_friends;
	}
	
	return ( @{ $self->{added_friends} } );

}

1; # End of WWW::Myspace::FriendChanges