Inline::Mason::OO - Inline OO Mason

Inline-Mason documentation Contained in the Inline-Mason distribution.

Index

Code Index:

NAME

Top

Inline::Mason::OO - Inline OO Mason

SYNOPSIS

Top

MY::Mason file:

    package MY::Mason;
    use Inline::Mason::OO;  # __CARDINALS__ will automatically loaded.
    # or
    # use Inline::Mason::OO qw(no_autoload);
    # to escape from loading __CARDINALS__
    our @ISA = qw(Inline::Mason::OO);

    1;
    __END__

    __CARDINALS__
    % my @cardinals = qw(eins zwei drei);
    <% join q/ /, @cardinals %>

My perl script:

    use MY::Mason
    my $m = new MY::Mason ('t/external_mason');
    print $m->HELLO();
    print $m->NIFTY(lang => 'Perl');
    print $m->CARDINALS();







    __END__

    __HELLO__
    % my $noun = 'World';
    Hello <% $noun %>!
    How are ya?

t/external_mason

    __NIFTY__
    <% $ARGS{lang} %> is nifty!

DESCRIPTION

Top

This module extends the power of Inline::Mason to an OO level. You may use it to build a module specific for generating documents, like help documentation, etc.

ON IMPORTING

On importing the module, by default, the inline-mason will be loaded. However, you can still pass 'no_autoload' stating that you don't want the module to automatically load inline-mason scripts dwelling in the module file.

    use Inline::Mason::OO qw(no_autoload);

Besides, you can call 'to_load_files' in the parent module, and the files will be loaded every time when you instantiate a new object.

    package MY::Mason;
    use Inline::Mason::OO;
    our @ISA = qw(Inline::Mason::OO);
    Inline::Mason::OO::to_load_files(@files);

    1;
    __END__

And, of course, you can do this superfluous and redundant action.

    package MY::Mason;
    use Inline::Mason::OO qw(no_autoload);
    our @ISA = qw(Inline::Mason::OO);
    Inline::Mason::OO::to_load_files(__FILE__);

    1;
    __END__

METHODS

new

The constructor takes a list of file's names in which mason scripts reside and will load them to the instance. The file where the constructor is called is always loaded by default.

load_mason

Create mason scripts in place, and you can pass a list of pairs.

Load mason script in place:

    my $m = new MY::Mason;
    $m->load_mason
    (
     BEATLES
     =>
     'Nothing\'s gonna change my <% $ARGS{what} %>',
     # ... ... ...
     );

    print $m->BEATLES(what => 'world');

load_file

Load an external file manually and explicitly.

    my $m = new MY::Mason;
    $m->load_file('external_mason.txt');

SEE ALSO

Top

Inline::Mason

COPYRIGHT AND LICENSE

Top

Copyright (C) 2004 by Yung-chung Lin (a.k.a. xern) <xern@cpan.org>

This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself

Inline-Mason documentation Contained in the Inline-Mason distribution. 
package Inline::Mason::OO;

use strict;
our $VERSION = '0.02';

use AutoLoader;
use Inline::Mason::Base;
our @EXPORT = qw(AUTOLOAD);
our @ISA = qw(Inline::Mason::Base AutoLoader);


use Text::MicroMason qw(execute);
use Inline::Files::Virtual;

our @files_to_load;
sub to_load_files {
    push @files_to_load, @_;
}

sub import {
    shift;
    my $no_autoload;
    foreach my $arg (@_){
	$no_autoload = 1 if($arg eq 'no_autoload');
    }
    to_load_files((caller(0))[1]) unless $no_autoload;
}

sub new {
    my $pkg = shift;
    my @file = @_;
    my $self = bless {} => $pkg;
    foreach my $f (grep{$_} @files_to_load, (caller(0))[1], @file){
	$self->load_file($f);
    }
    $self;
}


sub load_mason {
    my $self = shift;
    my %arg = @_;
    my ($pkg) = (caller(0))[0];
    no strict;
    while(my($marker, $content) = each %arg){
	die err_taboo($marker) if $taboo_word{$marker};
	$self->{template}{$marker} = $content if $content;
    }
}

sub load_file {
    my $self = shift;
    my $filename = shift;

    my @virtual_filenames = vf_load($filename, $file_marker) or die;
    local $/;
    foreach my $vfile (@virtual_filenames){
	my $marker = vf_marker($vfile);
	$marker =~ s/\n+//so;
	$marker =~ s/^__(.+?)__/$1/so;
	die err_taboo($marker) if $taboo_word{$marker};
	vf_open(my $F, $vfile) or die "$! ==> $marker";
	my $content = <$F>;
	$self->load_mason($marker, $content) if $content;
	vf_close $F;
    }
}

sub generate {
    my $self = shift;
    my $name = shift;
    my %args = @_;
    execute($template->{(caller(0))[0]}{$name}, %args);
}

sub DESTROY {
    my $self = shift;
    undef $self;
}

sub AUTOLOAD{
    use vars '$AUTOLOAD';
    $AUTOLOAD =~ /.+::(.+)/o;
    my $self = shift;
    my $pkg = (caller(0))[0];
    if(defined $self->{template}{$1}){
	execute($self->{template}{$1}, @_);
    }
    else {
	die "${pkg}::$1 does not exist.\n";
    }
}


1;
__END__
# Below is stub documentation for your module. You'd better edit it!