CPAN::PackageDetails::Entries - Handle the collection of records of 02packages.details.txt.gz

	http://github.com/briandfoy/cpan-packagedetails

package CPAN::PackageDetails::Entries;
use strict;
use warnings;

use vars qw($VERSION);
$VERSION = '0.25';

use Carp;

sub DESTROY { }

sub new { 
	my( $class, %args ) = @_;
	
	my %hash = ( 
		entry_class              => 'CPAN::PackageDetails::Entry',
		allow_packages_only_once => 1,
		columns                  => [],
		entries                  => {},
		%args
		);
		
	$hash{max_widths} = [ (0) x @{ $hash{columns} } ];
	
	bless \%hash, $_[0] 
	}

sub entry_class { $_[0]->{entry_class} }

sub columns { @{ $_[0]->{columns} } };

sub column_index_for
	{
	my( $self, $column ) = @_;
	
	
	my $index = grep {  
		$self->{columns}[$_] eq $column
		} 0 .. @{ $self->columns };
		
	return unless defined $index;
	return $index;
	}
	

sub count 
	{ 
	my $self = shift;
	
	my $count = 0;
	foreach my $package ( keys %{ $self->{entries} } )
		{
		$count += keys %{ $self->{entries}{$package} };
		}
		
	return $count;
	}

sub entries { $_[0]->{entries} }

sub allow_packages_only_once
	{	
	$_[0]->{allow_packages_only_once} = $_[1] if defined $_[1];
	
	$_[0]->{allow_packages_only_once};
	}
	

sub add_entry
	{
	my( $self, %args ) = @_;

	$self->_mark_as_dirty;
	
	# The column name has a space in it, but that looks weird in a 
	# hash constructor and I keep doing it wrong. If I type "package_name"
	# I'll just make it work.
	if( exists $args{package_name} )
		{
		$args{'package name'} = $args{package_name};
		delete $args{package_name};
		}
	
	$args{'version'} = 'undef' unless defined $args{'version'};
	
	unless( defined $args{'package name'} )
		{
		croak "No 'package name' parameter!";
		return;
		}

	unless( $args{'package name'} =~ m/
				^
				[A-Za-z0-9_]+
				(?: 
						(?:\::|')
						[A-Za-z0-9_]+
				)*
				\z
				/x )
		{
		croak "Package name [$args{'package name'}] looks suspicious. Not adding it!";
		return;
		}
		
	if( $self->allow_packages_only_once and $self->already_added( $args{'package name'} ) )
		{
		croak "$args{'package name'} was already added to CPAN::PackageDetails!";
		return;
		}
	
	# should check for allowed columns here
	$self->{entries}{
		$args{'package name'}
		}{$args{'version'}
			} = $self->entry_class->new( %args );
	}

sub _mark_as_dirty
	{
	delete $_[0]->{sorted};
	}

sub already_added { exists $_[0]->{entries}{$_[1]} }

sub as_string
	{
	my( $self ) = @_;
	
	my $string;
	
	my( $return ) = $self->as_unique_sorted_list;
	
	foreach my $entry ( @$return )
		{
		$string .= $entry->as_string( $self->columns );
		}
	
	$string || '';
	}

sub VERSION_PM () { 9 }
sub as_unique_sorted_list
	{
	my( $self ) = @_;

	unless( ref $self->{sorted} eq ref [] )
		{
		$self->{sorted} = [];
		
		my %Seen;

		my( $k1, $k2 ) = ( $self->columns )[0,1];

		my $e = $self->entries;

		# We only want the latest versions of everything:
		foreach my $package ( sort keys %$e )
			{
			my $entries = $e->{$package};
			eval {
				eval { require version } or die "Could not load version.pm!";
				die "Your version of the version module doesn't handle the parse method!"
					unless version->can('parse');
				} or croak( {
					message         => $@,
					have_version    => eval { version->VERSION },
					need_version    => 0.74,
					inc             => [ @INC ],
					error           => VERSION_PM,
					} 
				);
				
			my( $highest_version ) =
				sort { version->parse($b) <=> version->parse($a) }
				keys %$entries;

			push @{ $self->{sorted} }, $entries->{$highest_version};
			}
		}
	
	my $return = wantarray ? 
		$self->{sorted} 
			:
		scalar  @{ $self->{sorted} };
	
	return $return;
	}

1;