How much work do you wish to put in for this?

The most straightforward solution is to just require people to write:

\nBEGIN {init_foo()} foo();\n

However if you wish to, say, make foo{} do both, you can use [link|http://search.cpan.org/dist/Filter-Simple/lib/Filter/Simple.pm|Filter::Simple] to do it.

Be warned that Filter::Simple works through source filtering, and source filters always break. (Except with LISP.) Damian Conway is a very smart man, and Filter::Simple comes very, very close. But there are obscure syntactical constructs that Perl decides differently than he does, so there are cases that code_no_comments will get messed up. That is why I suggested using a syntax for your new construct that is not legal Perl. In which case you'll probably want to use [link|http://search.cpan.org/~abigail/Regexp-Common-2.120/lib/Regexp/Common.pm|Regexp::Common] to find the construct that you wish to replace.

(Alternately you can just make foo() do both. The expression will be much easier to write, but whoever maintains the program will want to kill you.)

BTW why do you want such a bizarre thing?

Cheers,
Ben

There are several ways to do this.

My inclination is to work from the right data structure. Something like this:

\nmy @actions = (\n  "Here is a description of foo.",\n  &foo,\n  "Here is a description of bar.",\n  &bar,\n);\n\nprint "This is a test program!  Here is the plan:\\n\\n";\nmy $count = 0;\nfor my $action (@actions) {\n  next if ref($action);\n  $count++;\n  print "Step $count:\\n$action\\n\\n";\n}\n\nprint "Let's go!";\n\n$count = 0;\nfor my $action (@actions) {\n  if (ref($action)) {\n    $action->(); # do it\n  }\n  else {\n    $count++;\n    print "\\n\\nStep $count:\\n$action";\n  }\n}\n\nsub foo {\n  # ...\n}\n\nsub bar {\n  # ...\n}\n

This works and avoids doing any cleverly deep magic. Unfortunately you do have to structure your program just so for it to work - you can't easily retrofit this onto an existing script.

You can also generalize this. For instance you could store an array of anonymous hash references, which have a description and a function attached. And then you could dynamically put together a test plan, describe it, then do it.

But if you want to go with your original strategy, then you can use Filter::Simple. The idea being that you can just use source filtering to design a construct that will build a data structure up front, print it, then emit messages later on. That would be something like this:

\n#### Filter/ShowSteps.pm #######\n\npackage Filter::ShowSteps;\n\nuse Filter::Simple;\n@ISA = 'Filter::Simple';\n\nuse strict;\n\nmy @steps;\n\nFILTER {\n  # Original code is passed in in $_.\n  # Modified code is whatever ends up in $_.\n\n  my $is_code = 1;\n  my @code;\n  for my $piece (split /\\n-----+\\n/, $_) {\n    if ($is_code) {\n      push @code, $piece;\n    }\n    else {\n      push @steps, $piece;\n      push @code, join "\\n",\n        "Filter::ShowSteps::show(<<'END_OF_COMMENT');",\n        $piece,\n        "END_OF_COMMENT";\n    }\n    $is_code = !$is_code;\n  }\n  $_ = join "\\n", @code;\n};\n\nsub show {\n  print "\\n", @_;\n}\n\nsub show_all {\n  print "$_\\n" for @steps;\n}\n\n1;\n\n#### some program #######\n\n#! /usr/bin/perl -w\nuse strict;\n\nuse Filter::ShowSteps;\n\nprint "This is a test program!  Here is the plan:\\n\\n";\n\nFilter::ShowSteps::show_all();\n\nprint "\\nNow here we go!\\n\\n";\n\n---------------------------\nThis is the first step.\n---------------------------\nprint "Do something.\\n";\n\n---------------------------\nThis is the second step.\n---------------------------\nprint "Do something else.\\n";\n

(I didn't mean to write your program for you, but I guess I did...)

Cheers,
Ben

But I wouldn't suggest going there.

If you're going to write normal Perl, write normal Perl. If you're not going to write normal Perl, make it look like it isn't normal Perl.

With source filters you can do what you're asking for. However your maintainance programmer will (or at least should) hunt you down with a blunt weapon. But consider something like this which has (modulo syntax) the exact same structure as your program:

\nEND {\n  # This is executed last, even though it appears first.\n  print "This test checks that widgets can mate with thingamaboobs\\n";\n  show_plan();\n  do_plan();\n}\n\nplan(\n  "create a gray widget",\n  sub {\n    ...\n  }\n);\n\nplan(\n  "create a red thigamaboob",\n  sub {\n    ...\n  }\n);\n\n...\n\n

This is easy to implement, does what you're asking for, and it is fairly obvious to the maintainance programmer how the magic works.

Incidentally if you're doing automatic unit tests, is there a good reason not to be using Test::More? Perl has good facilities for such test suites, you just have to use them. (Ignore this comment if the point of your test suite is to have someone look at the screen and manually review that what shows up matches what was supposed to show up.)

Cheers,
Ben