in reply to Framing my scripts

If you're not afraid of objects, you can put the "wrapper" stuff in a base class which calls different_stuff(), which is always overridden by a subclass. You can then break up the wrapper stuff into various pieces, and the subclasses can override any other parts they like. Then an individual script would instantiate the subclass and invoke some main() or something.

Otherwise, you might take the wrapper stuff and stick it in a module that your individual scripts use. They can pass in a code ref to their own functionality. It might look like this: 

use My::Wrapper qw(wrap);

sub hello_world {
    my %params = %{shift()};
    my $q = $params{q};   # etc.

    # different stuff here
}

wrap( \&hello_world );

[download]

Inside wrap... 

sub wrap {
    my ( $code_ref ) = @_;

    # blah blah
    $code_ref->({ q => $q,
                  T => \%T,
                  # etc.
                });
    # blah blah
}

[download]

Replies are listed 'Best First'.
Re^2: Framing my scripts
by Spidy (Chaplain) on Jul 27, 2007 at 02:41 UTC

    This looks like a really cool way to do what I'm looking for, except...I don't quite understand it.

    Let's say I have 2 scripts I want to implement this way; one will print "Hello World", and the other will print "Foo Bar". How would I set that up using your method?

    Thanks,

    Spidy
    website army
[reply]

      In "Hello World": 

      use My::Wrapper qw( wrap );

wrap( \&hello_world );

sub hello_world {
    my %params = %{shift()};
    my $T_ref = $params{T};

    $T_ref->{msg} = "Hello World";

    return;
}

      [download]

      In "Foo Bar": 

      use My::Wrapper qw( wrap );

wrap( \&foo_bar );

sub foo_bar {
    my %params = %{shift()};
    my $T_ref = $params{T};

    $T_ref->{msg} = "Foo Bar";

    return;
}

      [download]

      Then the main module. 

      package My::Wrapper;

use strict;
use warnings;

use Exporter 'import';
@EXPORT_OK = qw( wrap );

use DBI;
use CGI;
use CGI::Carp qw(fatalsToBrowser warningsToBrowser);
use HTML::Template;
use HTML::Entities;

use lib 'code';
use config;

## Security
$CGI::DISABLE_UPLOADS = 1;    # no uploads!
$CGI::POST_MAX = 512*1024;    # max 512k post

sub wrap {
    my ( $code_ref ) = @_;

    my $template = templates::loadTemplate('template');
    my %T;
    my $innerTemplate;
    my $q = new CGI;
    my $c;

    $code_ref->({ q => $q,
                  T => \%T,
                  # etc.
                });

     ## Filling in the template here
    if($innerTemplate) {
    # load the template in, put it into %T.
    my $template = templates::loadTemplate('$innerTemplate');
    $template->param($T{innerContent}) if $T{innerContent};
    $T{content} = $template->output();
    }

    print $q->header();
    $template->param(%T);
    print $template->output();
}

      [download]

      I don't know anything about your template, and I'm not sure what I can deduce from what you've posted. If you want each script to have its own template, then you have to let the wrapped function give that back to the wrapper somehow. You could do this by having a special element in %T or have the wrapped code pass out a hash ref with whatever it wants to supply.

      Also, it's important to note that the above code is not tested or anything. When I do this sort of thing myself, I use objects. In that case, I don't go passing things around; the object just sets its own attributes for communication.

[reply]
[d/l]
[select]

        Excellent advice and presentation++

        Actually HTML::Template forces you to do such a 2-stage transformation.

        If you want to avoid that, you could also use the HTML::Template-compatible HTML::Template::Compiled from tinita, which allows you to specify the innerContent by an additional TMPL-command, see HTC:INCLUDE

        It will expand the embedded template(s) first and do the other template processing on the resulting joined template.

        Not a big issue, but I like the feature.

[reply]
[d/l]
[select]

In Section Seekers of Perl Wisdom