Something like this ?

#!/usr/bin/perl

# https://perlmonks.org/?node_id=1224600

use strict;
use warnings;
use Data::Dump 'dd';

my $data = <<'END';
interface XYZ
  given param1 -> child of "interface XYZ"
  given param2 -> child of "interface XYZ"
    given param2.1 -> child of "given param2"
      given param2.1.1 -> child of "given param2.1"
      given param2.1.2 -> child of "given param2.1"
    given param2.2 -> child of "given param2"
  given param3 -> child of "interface XYZ"
  given param4 -> child of "interface XYZ"
interface SECOND
  given param5 -> child of "interface SECOND"
END

my $struct = buildstruct($data);
dd $struct;

sub buildstruct
  {
  my $block = shift;
  my @answers;
  while( $block =~ /^( *)(.*)\n((?:\1 +.*\n)*)/gm )
    {
    my ($head, $rest) = ($2, $3);
    $head =~ s/ ->.*//;
    push @answers, $rest ? { $head => buildstruct($rest) } : $head;
    }
  \@answers;
  }
[download]

Outputs:

[
  {
    "interface XYZ" => [
      "given param1",
      {
        "given param2" => [
          { "given param2.1" => ["given param2.1.1", "given param2.1.2
+"] },
          "given param2.2",
        ],
      },
      "given param3",
      "given param4",
    ],
  },
  { "interface SECOND" => ["given param5"] },
]
[download]

Or do I completely misunderstand what you're asking for ?

This is exactly what I was looking for. In just one pass ... This is impressive. I tried it out in my code and this works flawlessly against a whole router config. I think I'd like to add a logic to capture parents without a child on the first level and push them in a separate array or in an arrayref inside the structure, but all I can say is WOW. Could you please explain the regex in the while loop ? Otherwhise, I get that you're using the ternary operator to dig deeper ... this solves my challenge in a single line. Respect !

Same code with expanded regex with comments

#!/usr/bin/perl

# https://perlmonks.org/?node_id=1224600

use strict;
use warnings;
use Data::Dump 'dd';

my $data = <<'END';
interface XYZ
  given param1 -> child of "interface XYZ"
  given param2 -> child of "interface XYZ"
    given param2.1 -> child of "given param2"
      given param2.1.1 -> child of "given param2.1"
      given param2.1.2 -> child of "given param2.1"
    given param2.2 -> child of "given param2"
  given param3 -> child of "interface XYZ"
  given param4 -> child of "interface XYZ"
interface SECOND
  given param5 -> child of "interface SECOND"
END

my $struct = buildstruct($data);
dd $struct;

sub buildstruct
  {
  my $block = shift;
  my @answers;
  while( $block =~ /^ # make sure to start at beginning of a line (wit
+h m)
      (\ *)           # match leading spaces of header line
      (.*)            # match rest of line, save as head
      \n              # and match the newline
      (
      (?:             # match all following lines with
        \1            # same whitespace as head
        \ +           # plus at least one more space ( i.e. indented )
        .*\n          # contents to be looked at later
      )*              # as many as possible
      )               # save as rest
      /gmx )          # global, multiline, and extra whitespace
    {
    my ($head, $rest) = ($2, $3);
    $head =~ s/ ->.*//;
    push @answers, $rest ? { $head => buildstruct($rest) } : $head;
    }
  \@answers;
  }
[download]

I hope this helps :)

The regex matches each line, gets the indentation space string, then also matches all following lines that are indented that much plus at least one more space.

> In just one pass ...

not really, it's recursive.

This solution is one-pass.

Cheers Rolf
_{(addicted to the Perl Programming Language :)
Wikisyntax for the Monastery FootballPerl is like chess, only without the dice}

Some time back I had to do something similar. While I am not able to pull example code at the moment, what I did was basically the following:

1. 1. Read each line from the config into a file.
   2. Keep a count of the number of leading spaces on each line in a hash.
2. Compute the greatest common factor (gcf) of the non-zero leading space counts.

I then processed the array of entries using the ( number of leading spaces / GCF ) value to determine indentation level.

Hope that helps.

It's a similar problem, in your case @path should hold references of the current parent containers.

The parsed indentation level gives you the index for @path.

Either add the current element to the correct parent container or expand path.

HTH

I think the following code is self explaining

use strict;
use warnings;
use Data::Dump qw/pp dd/;


my @parse;
my @path;

my $last_level=0;
$path[$last_level] = \@parse;



while (my $line = <DATA> ) {
    # pp
    my($white,$key,undef,$content) =
      $line =~ /^
                (\s*)                   # indent
                (.*?)                   # key
                (
                    \s*->\s*            # ignore arrow
                    (.*)
                )?                      # optional group
                $/x;

    my $level = length($white) / 2;

    # pp [$white, $key,$level,$last_level];

    die "indent-level $level too big (last level was $last_level)!"
      if $level > $last_level+1;


    my @children;

    push
      @{$path[$level]},
      # {
      #  $key => {
      #           children => \@children,
      #           # level => $level,
      #           # content => $content,
      #          }
      # };
        {
         $key => \@children      # terse output
        };

    $path[$level+1] = \@children;
    $last_level = $level;

}

warn "Output: " , pp \@parse;


__DATA__
interface XYZ
  given param1 -> child of "interface XYZ"
  given param2 -> child of "interface XYZ"
    given param2.1 -> child of "given param2"
    given param2.2 -> child of "given param2"
      given param2.2.1 -> child of "given param2.2"
  given param3 -> child of "interface XYZ"
[download]

I extended your input to cover the case of a bigger indent gap.

Output: [
  {
    "interface XYZ" => [
      { "given param1" => [] },
      {
        "given param2" => [
          { "given param2.1" => [] },
          { "given param2.2" => [{ "given param2.2.1" => [] }] },
        ],
      },
      { "given param3" => [] },
    ],
  },
] at d:/tmp/parse_indent.pl line 55, <DATA> line 7.
[download]

you can uncomment various code sections to play with debug output and different data-structure patterns YMMV.

Cheers Rolf
_{(addicted to the Perl Programming Language :)
Wikisyntax for the Monastery FootballPerl is like chess, only without the dice}

update

Some people prefer to avoid empty "children" arrays for leafs-nodes.

In this case avoid an empty default array and let $path[$level] point to an upper container where you check for existence of an entry for children.

extending the code should be straight forward.

Crossposted from stackoverflow. Crossposting is ok, but it is considered polite to inform about it so that efforts are not duplicated.

Thanks for the info Corion. You're absolutely right. The discussion in StackOverflow got very technical so I decided to post here to seek wisdom :)

So, you're saying that you came to the Monastery to gain wisdom from people that aren't as technical ;)

I'm very much just kidding. Your question was well laid out and understandable, ++.

What about Cisco::Reconfig? Sure, i‘m aware that i guessed once more. Regards, Karl

Hi Karl, I've played a little with Cisco::Reconfig and I'm still not sure why I didn't enjoyed it as much as it was promising ... In fact this is exactly when I decided I should start working on a general parser to get context by indentation (node - child relation). And I needed something that would work with all the vendors too, so I thought it might be easier to write rules based on the vendor, only when necessary. Accessing the data structure was unfriendly and I would have had to build a config file around it to address my needs ... Well, thanks for the suggestion anyways, it's always good to evaluate many options. Luc