Sounds like Data::Compare is broken. A quick peek at the source turned up exactly the type of broken code that I expected to see:

    if(ref($requires) ne 'ARRAY') {
[download]

So just fix Data::Compare. The fixes would probably be quite simple. The best fix is to change such things to:

    if(  ! eval { @$requires; 1 }  ) {  # Can't be used as an array re
+f
[download]

It is fine to use ref as a Boolean test. Any other uses of ref I simply can't recommend.

Note that the above trick doesn't work for CODE references so you have to resort to one of the second-best methods. I'd use the following:

*isa= UNIVERSAL::isa;
#...
    if(  isa( $ref, "CODE" )  ) {
[download]

Note that this test can fail in the case of overloaded objects that want to pretend to be CODE references but that didn't bother to push @ISA, "CODE"; in order to declare this intention (which seems a perfectly reasonable restriction to me). chromatic would surely cringe and moan upon seeing such code because surely $ref->isa("CODE") is what should be used (except, of course, that it is likely to die in many cases). eval { $ref->isa("CODE") } might be a possible alternative but I thought it had its own drawbacks even though I can't recall what they were. My preferred method can also produce false positives if somebody intentionally lies via push @ISA, "CODE"; which I also consider to be a perfectly reasonable feature (which can even be useful when writing unit tests, for example).

Looking at the code further, I see one spot that would be somewhat complex to fix because it assumes that a reference can only be of one type, which is not the case. But it would also simplify other parts of the code, because there would not have to be special code for looking under the covers of blessed references.

Actually, perhaps it would be best to leave the plug-in handling alone, despite the flawed assumptions present there. Replacing the flawed assumptions with proper handling when considering handlers for specific classes of objects would be quite complex and you don't need to fix plug-in support in order to fix the basic flaw in the module; thus making it work fine on DBM::Deep results.

Then the module becomes quite easy to fix (and the fixes still simplify some parts). The best route would probably be to write the following tiny helpers:

sub isArray  { eval { @{$_[0]}; 1 } }
sub isHash   { eval { %{$_[0]}; 1 } }
sub isScalar { eval { ${$_[0]}; 1 } }
sub isCode   { UNIVERSAL::isa( $_[0], "CODE" ) }
[download]

And then the less-tiny helper:

sub getCommonRefType
{
    my( $ref1, $ref2 )= @_;
    return "ARRAY"  if  isArray($ref1) && isArray($ref2);
    return "HASH"   if  isHash($ref1) && isHash($ref2);
    return "SCALAR" if  isScalar($ref1) && isScalar($ref2);
    return "";
}
[download]