Recursively search nested hash/array structures

[mp]

I've done a fair amount of searching on google, perlmonks, and cpan for this but have not turned up much, except Data::DRef and Data::Walker. Data::Walker provides a file-system-ish interface command line interfce for manual examination of data structures, but does not provide methods for searching the structures. Data::DRef does not appear to have "search" methods to locate keys recursively, but I will continue look more closely at it.

I have a nested data structure (hash at the top level, then mixture of hashes and arrays at lower levels, arbitrarily deep) that is read from a config file (Config::General).

I need a way to recursively search this data structure for particular hash keys, so that I can alter the data associated with them. For example, certain entries should always have a reference to an anonymous array, so I need to recursively search for a particular key, and wherever found, wrap it's value in an anonymous array if it is not already an array.

So, for example, given:

{
  a => {
    b => 3,
  }
  b => 123,
  c => {
    b => [
      123,
      456,
      789,
    ],
  },
  d => [
    b => 456,
  ],
}

I need something that can find all occurrences of 'b' in this data structure, so that I can examine them and change them all to array references like this:

{
  a => {
    b => [
      3,
    ]
  }
  b => [
    123,
  ],
  c => {
    b => [
      123,
      456,
      789,
    ],
  },
  d => [
    b => [
      456,
    ],
  ],
}

Similar functionality to what I need exists in File::Find, File::Find::Rule, HTML::TreeBuilder (especially it's look_down method), but these all target either filesystem or file traversal rather than perl data structure traversal.

In the interest of avoiding reinventing a wheel that I'm sure exists somewhere, but I've been unable to find, has anyone found a CPAN module to do this sort of thing?

[Joost]

Maybe Data::Rmap is what you want. see treemap.

[mp]

Thank you. Data::Rmap was exactly what I needed. The example script below converts every value corresponding to a key of 'b' to an array unless it already is an array.

use strict;
use warnings;
use Data::Rmap qw(rmap_hash);
use Data::Dumper;
$Data::Dumper::Sortkeys = 1;
$Data::Dumper::Indent = 1;

my $data = {
  a => {
    b => 1,
    x => 3,
  },
  b => 1,
  c => {
    d => [
      {  b => 3 },
      {  b => [5, 6, 7] },
      {  x => 3},
    ],
  },
};
my $key = 'b';
my @to_fix = rmap_hash { 
    exists($_->{$key}) && (ref($_->{$key}) ne "ARRAY") 
    ? $_ : () 
} $data;
for my $h(@to_fix) {
  $h->{$key} = [ $h->{$key} ];
}
warn Dumper($data);

Output:

$VAR1 = {
  'a' => {
    'b' => [
      1
    ],
    'x' => 3
  },
  'b' => [
    1
  ],
  'c' => {
    'd' => [
      {
        'b' => [
          3
        ]
      },
      {
        'b' => [
          5,
          6,
          7
        ]
      },
      {
        'x' => 3
      }
    ]
  }
};

[simonm]

I don't know of anything that will do this for you.

You might want to start with another piece of code that fully traverses a nested data structure, and then alter it to perform your specific behavior.

[mp]

Thanks for the quick response. Since you are the author of Data::DRef, I'll take your response to also mean that Data::Dref doesn't have anything that will do this. Initially I had thought that its 'index_by_drefs' sub might allow locating the keys easily, but after some experimentation with it, I can't get it to do that.

The code you referenced in Clone::PP looks relatively straightforward, so I will start there, if no other leads turn up.

[Roy Johnson]

Seems like a Data::Find module would be a nifty parallel to File::Find. But have you seen Data::Search? It looks like it might be able to do what you want.