Data::Digest - Objects that represent a digest values

  $digest = Data::Digest->new(
      'MD5.d41d8cd98f00b204e9800998ecf8427e'
  );

  $digest = Data::Digest->new(
      'SHA-256' => '47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU',
  );

  $digest->matches( \$data );
  $digest->matches( $filename );

  # Two-argument digest constructor
  $digest = Data::Digest->new(
      'SHA-256' => '47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU',
  );

  # One-argument digest constructor
  $digest = Data::Digest->new(
      'MD5.d41d8cd98f00b204e9800998ecf8427e'
  );

  print $digest->as_string . "\n";
  > MD5.d41d8cd98f00b204e9800998ecf8427e

  # Check the digest against something
  $digest->matches( $filename  );
  $digest->matches( $io_handle );
  $digest->matches( \$string   );

package Data::Digest;

use 5.005;
use strict;
use Carp         ();
use Digest       ();
use IO::File     ();
use Params::Util qw{_STRING _SCALAR0 _INSTANCE};

use vars qw{$VERSION};
BEGIN {
	$VERSION = '1.04';
}

# For all supported digest types, provide the expected lengths of the digest
# in each format in bits.
# These will be used to help generate the regular expressions used to
# validate the input strings.
my %DIGEST = (
	'MD5' => {
		bits      => 128,
		digest    => 16,
		hexdigest => 32,
		b64digest => 22,
	},
	'SHA-1' => {
		bits      => 160,
		digest    => 20,
		hexdigest => 40,
		b64digest => 27,
	},
	'SHA-256' => {
		bits      => 256,
		digest    => 32,
		hexdigest => 64,
		b64digest => 43,
	},
	'SHA-512' => {
		bits      => 512,
		digest    => 64,
		hexdigest => 128,
		b64digest => 86,
	},
);





#####################################################################
# Constructor and Accessors

sub new {
	my $class = shift;
	my ($driver, $digest, $method) = ();
	if ( @_ == 1 and _STRING($_[0]) ) {
		if ( $_[0] =~ /^(\w+(?:-\d+)?)\.(\S+)$/ ) {
			$driver = $1;
			$digest = $2;
		} else {
			Carp::croak("Unrecognised or unsupported Data::Digest string");
		}
	} elsif ( @_ == 2 and _STRING($_[0]) and _STRING($_[1]) ) {
		$driver = $_[0];
		$digest = $_[1];
	} else {
		Carp::croak("Missing or invalid params provided to Data::Digest constructor");
	}

	# Check the digest values
	my $len = $DIGEST{$driver}
		or Carp::croak("Invalid or unsupported digest type '$driver'.");

	# Check the digest content to find the method
	if ( length $digest == $len->{digest} ) {
		$method = 'digest';
	} elsif ( length $digest == $len->{hexdigest} and $digest !~ /[^0-9a-f]/ ) {
		$method = 'hexdigest';
	} elsif ( length $digest == $len->{b64digest} and $digest !~ /[^\w\+\/]/ ) {
		$method = 'b64digest';
	} else {
		Carp::croak("Digest string is not a recognised $driver");
	}

	# Create the object
	my $self = bless {
		driver => $driver,
		digest => $digest,
		method => $method,
	}, $class;

	return $self;
}

sub driver {
	$_[0]->{driver};
}

sub digest {
	$_[0]->{digest};
}





#####################################################################
# Main Methods

sub as_string {
	$_[0]->driver . '.' . $_[0]->digest;
}

sub matches {
	my $self = shift;
	return $self->_matches_file(shift)   if _STRING($_[0]);
	return $self->_matches_scalar(shift) if _SCALAR0($_[0]);
	return $self->_matches_handle(shift) if _INSTANCE($_[0], 'IO::Handle');
	Carp::croak("Did not provide a valid data value to check digest against");
}

sub _matches_scalar {
	my ($self, $scalar_ref) = @_;

	# Generate the digest for the string
	my $method = $self->{method};
	my $digest = $self->_digest->add($$scalar_ref)->$method();

	return ($self->digest eq $digest);
}

sub _matches_file {
	my ($self, $file) = @_;

	# Check the filename
	-f $file or Carp::croak("File '$file' does not exist");
	-r $file or Carp::croak("No permissions to read '$file'");

	# Load and generate the digest for the file
	my $handle = IO::File->new($file)
		or Carp::croak("Failed to load '$file': $!");
	return $self->_matches_handle($handle);
}

sub _matches_handle {
	my ($self, $handle) = @_;

	# Generate the digest for the handle
	my $method = $self->{method};
	my $digest = $self->_digest->addfile($handle)->$method();

	return ($self->digest eq $digest);
}

sub _digest {
	my $self = shift;
	Digest->new($self->driver)
		or die("Failed to create Digest object");
}

1;