.\" -*- mode: troff; coding: utf-8 -*-
.\" Automatically generated by Pod::Man 5.0102 (Pod::Simple 3.45)
.\"
.\" Standard preamble:
.\" ========================================================================
.de Sp \" Vertical space (when we can't use .PP)
.if t .sp .5v
.if n .sp
..
.de Vb \" Begin verbatim text
.ft CW
.nf
.ne \\$1
..
.de Ve \" End verbatim text
.ft R
.fi
..
.\" \*(C` and \*(C' are quotes in nroff, nothing in troff, for use with C<>.
.ie n \{\
.    ds C` ""
.    ds C' ""
'br\}
.el\{\
.    ds C`
.    ds C'
'br\}
.\"
.\" Escape single quotes in literal strings from groff's Unicode transform.
.ie \n(.g .ds Aq \(aq
.el       .ds Aq '
.\"
.\" If the F register is >0, we'll generate index entries on stderr for
.\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index
.\" entries marked with X<> in POD.  Of course, you'll have to process the
.\" output yourself in some meaningful fashion.
.\"
.\" Avoid warning from groff about undefined register 'F'.
.de IX
..
.nr rF 0
.if \n(.g .if rF .nr rF 1
.if (\n(rF:(\n(.g==0)) \{\
.    if \nF \{\
.        de IX
.        tm Index:\\$1\t\\n%\t"\\$2"
..
.        if !\nF==2 \{\
.            nr % 0
.            nr F 2
.        \}
.    \}
.\}
.rr rF
.\" ========================================================================
.\"
.IX Title "Pod::POM 3"
.TH Pod::POM 3 2025-03-15 "perl v5.40.1" "User Contributed Perl Documentation"
.\" For nroff, turn off justification.  Always turn off hyphenation; it makes
.\" way too many mistakes in technical documents.
.if n .ad l
.nh
.SH NAME
Pod::POM \- POD Object Model
.SH SYNOPSIS
.IX Header "SYNOPSIS"
.Vb 1
\&    use Pod::POM;
\&
\&    my $parser = Pod::POM\->new(\e%options);
\&
\&    # parse from a text string
\&    my $pom = $parser\->parse_text($text)
\&        || die $parser\->error();
\&
\&    # parse from a file specified by name or filehandle
\&    my $pom = $parser\->parse_file($file)
\&        || die $parser\->error();
\&
\&    # parse from text or file 
\&    my $pom = $parser\->parse($text_or_file)
\&        || die $parser\->error();
\&
\&    # examine any warnings raised
\&    foreach my $warning ($parser\->warnings()) {
\&        warn $warning, "\en";
\&    }
\&
\&    # print table of contents using each =head1 title
\&    foreach my $head1 ($pom\->head1()) {
\&        print $head1\->title(), "\en";
\&    }
\&
\&    # print each section
\&    foreach my $head1 ($pom\->head1()) {
\&        print $head1\->title(), "\en";
\&        print $head1\->content();
\&    }
\&
\&    # print the entire document as HTML
\&    use Pod::POM::View::HTML;
\&    print Pod::POM::View::HTML\->print($pom);
\&
\&    # create custom view
\&    package My::View;
\&    use parent qw( Pod::POM::View::HTML );
\&
\&    sub view_head1 {
\&        my ($self, $item) = @_;
\&        return \*(Aq<h1>\*(Aq, 
\&               $item\->title\->present($self), 
\&               "</h1>\en",
\&               $item\->content\->present($self);
\&    }
\&    
\&    package main;
\&    print My::View\->print($pom);
.Ve
.SH DESCRIPTION
.IX Header "DESCRIPTION"
This module implements a parser to convert Pod documents into a simple
object model form known hereafter as the Pod Object Model.  The object
model is generated as a hierarchical tree of nodes, each of which
represents a different element of the original document.  The tree can
be walked manually and the nodes examined, printed or otherwise
manipulated.  In addition, Pod::POM supports and provides view objects
which can automatically traverse the tree, or section thereof, and
generate an output representation in one form or another.
.PP
Let's look at a typical Pod document by way of example.
.PP
.Vb 1
\&    =head1 NAME
\&
\&    My::Module \- just another My::Module
\&
\&    =head1 DESCRIPTION
\&
\&    This is My::Module, a deeply funky piece of Perl code.
\&
\&    =head2 METHODS
\&
\&    My::Module implements the following methods
\&
\&    =over 4
\&
\&    =item new(\e%config)
\&
\&    This is the constructor method.  It accepts the following 
\&    configuration options:
\&
\&    =over 4
\&
\&    =item name
\&
\&    The name of the thingy.
\&
\&    =item colour
\&
\&    The colour of the thingy.
\&
\&    =back
\&
\&    =item print()
\&
\&    This prints the thingy.
\&
\&    =back
\&
\&    =head1 AUTHOR
\&
\&    My::Module was written by me E<lt>me@here.orgE<gt>
.Ve
.PP
This document contains 3 main sections, NAME, DESCRIPTION and 
AUTHOR, each of which is delimited by an opening \f(CW\*(C`=head1\*(C'\fR tag.
NAME and AUTHOR each contain only a single line of text, but 
DESCRIPTION is more interesting.  It contains a line of text
followed by the \f(CW\*(C`=head2\*(C'\fR subsection, METHODS.  This contains
a line of text and a list extending from the \f(CW\*(C`=over 4\*(C'\fR to the 
final \f(CW\*(C`=back\*(C'\fR just before the AUTHOR section starts.  The list
contains 2 items, \f(CWnew(\e%config)\fR, which itself contains some 
text and a list of 2 items, and \f(CWprint()\fR.
.PP
Presented as plain text and using indentation to indicate the element 
nesting, the model then looks something like this :
.PP
.Vb 2
\&    NAME
\&        My::Module \- just another My::Module
\&
\&    DESCRIPTION
\&        This is My::Module, a deeply funky piece of Perl code.
\&
\&        METHODS
\&            My::Module implements the following methods
\&
\&            * new(\e%config)
\&                This is the constructor method.  It accepts the 
\&                following configuration options:
\&
\&                * name
\&                    The name of the thingy.
\&
\&                * colour
\&                    The colour of the thingy.
\&
\&            * item print()
\&                This prints the thingy.
\&
\&    AUTHOR
\&        My::Myodule was written by me <me@here.org>
.Ve
.PP
Those of you familiar with XML may prefer to think of it in the
following way:
.PP
.Vb 4
\&    <pod>
\&      <head1 title="NAME">
\&        <p>My::Module \- just another My::Module</p>
\&      </head1>
\&
\&      <head1 title="DESCRIPTION">
\&        <p>This is My::Module, a deeply funky piece of 
\&           Perl code.</p>
\&
\&        <head2 title="METHODS">
\&          <p>My::Module implements the following methods</p>
\&
\&          <over indent=4>
\&            <item title="item new(\e%config)">
\&              <p>This is the constructor method.  It accepts
\&                 the following configuration options:</p>
\&
\&              <over indent=4>
\&                <item title="name">
\&                  <p>The name of the thingy.</p>
\&                </item>
\&
\&                <item title="colour">
\&                  <p>The colour of the thingy.</p>
\&                </item>
\&              </over>
\&            </item>
\&
\&            <item title="print()">
\&              <p>This prints the thingy.</p>
\&            </item>
\&          </over>
\&        </head2>
\&      </head1>
\&
\&      <head1 title="AUTHOR">
\&        <p>My::Myodule was written by me &lt;me@here.org&gt;
\&      </head1>
\&    </pod>
.Ve
.PP
Notice how we can make certain assumptions about various elements.
For example, we can assume that any \f(CW\*(C`=head1\*(C'\fR section we find begins a
new section and implicitly ends any previous section.  Similarly, we
can assume an \f(CW\*(C`=item\*(C'\fR ends when the next one begins, and so on.  In
terms of the XML example shown above, we are saying that we're smart
enough to add a \f(CW\*(C`</head1>\*(C'\fR element to terminate any
previously opened \f(CW\*(C`<head1>\*(C'\fR when we find a new \f(CW\*(C`=head1\*(C'\fR tag
in the input document.
.PP
However you like to visualise the content, it all comes down to the
same underlying model.  The job of the Pod::POM module is to read an
input Pod document and build an object model to represent it in this
structured form.
.PP
Each node in the tree (i.e. element in the document) is represented
by a Pod::POM::Node::* object.  These encapsulate the attributes for
an element (such as the title for a \f(CW\*(C`=head1\*(C'\fR tag) and also act as
containers for further Pod::POM::Node::* objects representing the
content of the element.  Right down at the leaf nodes, we have simple
object types to represent formatted and verbatim text paragraphs and
other basic elements like these.
.SS "Parsing Pod"
.IX Subsection "Parsing Pod"
The Pod::POM module implements the methods parse_file($file),
parse_text($text) and parse($file_or_text) to parse Pod files and
input text.  They return a Pod::POM::Node::Pod object to represent the
root of the Pod Object Model, effectively the \f(CW\*(C`<pod>\*(C'\fR element
in the XML tree shown above.
.PP
.Vb 1
\&    use Pod::POM;
\&
\&    my $parser = Pod::POM\->new();
\&    my $pom = $parser\->parse_file($filename)
\&        || die $parser\->error();
.Ve
.PP
The \fBparse()\fR, \fBparse_text()\fR and \fBparse_file()\fR methods return
undef on error.  The \fBerror()\fR method can be called to retrieve the
error message generated.  Parsing a document may also generate
non-fatal warnings.  These can be retrieved via the \fBwarnings()\fR method
which returns a reference to a list when called in scalar context or a
list of warnings when called in list context.
.PP
.Vb 3
\&    foreach my $warn ($parser\->warnings()) {
\&        warn $warn, "\en";
\&    }
.Ve
.PP
Alternatively, the 'warn' configuration option can be set to have
warnings automatically raised via \f(CWwarn()\fR as they are encountered.
.PP
.Vb 1
\&    my $parser = Pod::POM\->new( warn => 1 );
.Ve
.SS "Walking the Object Model"
.IX Subsection "Walking the Object Model"
Having parsed a document into an object model, we can then select 
various items from it.  Each node implements methods (via AUTOLOAD)
which correspond to the attributes and content elements permitted
within in.
.PP
So to fetch the list of '=head1' sections within our parsed document,
we would do the following:
.PP
.Vb 1
\&    my $sections = $pom\->head1();
.Ve
.PP
Methods like this will return a list of further Pod::POM::Node::* 
objects when called in list context or a reference to a list when 
called in scalar context.  In the latter case, the list is blessed
into the Pod::POM::Node::Content class which gives it certain 
magical properties (more on that later).
.PP
Given the list of Pod::POM::Node::Head1 objects returned by the above,
we can print the title attributes of each like this:
.PP
.Vb 3
\&    foreach my $s (@$sections) {
\&        print $s\->title();
\&    }
.Ve
.PP
Let's look at the second section, DESCRIPTION.
.PP
.Vb 1
\&    my $desc = $sections\->[1];
.Ve
.PP
We can print the title of each subsection within it:
.PP
.Vb 3
\&    foreach my $ss ($desc\->head2()) {
\&        print $ss\->title();
\&    }
.Ve
.PP
Hopefully you're getting the idea by now, so here's a more studly
example to print the title for each item contained in the first list
within the METHODS section:
.PP
.Vb 3
\&    foreach my $item ($desc\->head2\->[0]\->over\->[0]\->item) {
\&        print $item\->title(), "\en";
\&    }
.Ve
.SS "Element Content"
.IX Subsection "Element Content"
This is all well and good if you know the precise structure of a 
document in advance.  For those more common cases when you don't,
each node that can contain other nodes provides a 'content' method
to return a complete list of all the other nodes that it contains.
The 'type' method can be called on any node to return its element
type (e.g. 'head1', 'head2', 'over', item', etc).
.PP
.Vb 10
\&    foreach my $item ($pom\->content()) {
\&        my $type = $item\->type();
\&        if ($type eq \*(Aqhead1\*(Aq) {
\&            ...
\&        }
\&        elsif ($type eq \*(Aqhead2\*(Aq) {
\&            ...
\&        }
\&        ...
\&    }
.Ve
.PP
The content for an element is represented by a reference to a list,
blessed into the Pod::POM::Node::Content class.  This provides some
magic in the form of an overloaded stringification operator which 
will automatically print the contents of the list if you print 
the object itself.  In plain English, or rather, in plain Perl,
this means you can do things like the following:
.PP
.Vb 4
\&    foreach my $head1 ($pom\->head1()) {
\&        print \*(Aq<h1>\*(Aq, $head1\->title(), "</h1>\en\en";
\&        print $head1\->content();
\&    }
\&
\&    # print all the root content
\&    foreach my $item ($pom\->content()) {
\&        print $item;
\&    }
\&
\&    # same as above
\&    print $pom\->content();
.Ve
.PP
In fact, all Pod::POM::Node::* objects provide this same magic, and
will attempt to Do The Right Thing to present themselves in the
appropriate manner when printed.  Thus, the following are all valid.
.PP
.Vb 7
\&    print $pom;                 # entire document
\&    print $pom\->content;        # content of document
\&    print $pom\->head1\->[0];     # just first section
\&    print $pom\->head1;          # print all sections
\&    foreach my $h1 ($pom\->head1()) {
\&        print $h1\->head2();     # print all subsections
\&    }
.Ve
.SS "Output Views"
.IX Subsection "Output Views"
To understand how the different elements go about presenting
themselves in "the appropriate manner", we must introduce the concept
of a view.  A view is quite simply a particular way of looking at the
model.  In real terms, we can think of a view as being some kind of
output type generated by a pod2whatever converter.  Notionally we can
think in terms of reading in an input document, building a Pod Object
Model, and then generating an HTML view of the document, and/or a
LaTeX view, a plain text view, and so on.
.PP
A view is represented in this case by an object class which contains
methods for displaying each of the different element types that could
be encountered in any Pod document.  There's a method for displaying
\&\f(CW\*(C`=head1\*(C'\fR sections (\fBview_head1()\fR), another method for displaying
\&\f(CW\*(C`=head2\*(C'\fR sections (\fBview_head2()\fR), one for \f(CW\*(C`=over\*(C'\fR (\fBview_over()\fR),
another for \f(CW\*(C`=item\*(C'\fR (\fBview_item()\fR) and so on.
.PP
If we happen to have a reference to a \f(CW$node\fR and we know it's a 'head1'
node, then we can directly call the right view method to have it
displayed properly:
.PP
.Vb 2
\&    $view = \*(AqPod::POM::View::HTML\*(Aq;
\&    $view\->view_head1($node);
.Ve
.PP
Thus our earlier example can be modified to be \fIslightly\fR less laborious
and \fImarginally\fR more flexible.
.PP
.Vb 10
\&    foreach my $node ($pom\->content) {
\&        my $type = $node\->type();
\&        if ($type eq \*(Aqhead1\*(Aq) {
\&            print $view\->view_head1($node);
\&        }
\&        elsif ($type eq \*(Aqhead2\*(Aq) {
\&            print $view\->view_head2($node);
\&        }
\&        ...
\&    }
.Ve
.PP
However, this is still far from ideal.  To make life easier, each
Pod::POM::Node::* class inherits (or possibly redefines) a
\&\f(CWpresent($view)\fR method from the Pod::POM::Node base class.  This method
expects a reference to a view object passed as an argument, and it
simply calls the appropriate \fBview_xxx()\fR method on the view object,
passing itself back as an argument.  In object parlance, this is known
as "double dispatch".  The beauty of it is that you don't need to know
what kind of node you have to be able to print it.  You simply pass
it a view object and leave it to work out the rest.
.PP
.Vb 3
\&    foreach my $node ($pom\->content) {
\&        print $node\->present($view);
\&    }
.Ve
.PP
If \f(CW$node\fR is a Pod::POM::Node::Head1 object, then the view_head1($node)
method gets called against the \f(CW$view\fR object.  Otherwise, if it's a
Pod::POM::Node::Head2 object, then the view_head2($node) method is
dispatched.  And so on, and so on, with each node knowing what it is
and where it's going as if determined by some genetically pre-programmed
instinct.  Fullfilling their destinies, so to speak.
.PP
Double dispatch allows us to do away with all the explicit type
checking and other nonsense and have the node objects themselves worry
about where they should be routed to.  At the cost of an extra method
call per node, we get programmer convenience, and that's usually 
a Good Thing.
.PP
Let's have a look at how the view and node classes might be
implemented.
.PP
.Vb 1
\&    package Pod::POM::View::HTML;
\&
\&    sub view_pod {
\&        my ($self, $node) = @_;
\&        return $node\->content\->present($self);
\&    }
\&
\&    sub view_head1 {
\&        my ($self, $node) = @_;
\&        return "<h1>", $node\->title\->present($self), "</h1>\en\en"
\&             . $node\->content\->present($self);
\&    }
\&
\&    sub view_head2 {
\&        my ($self, $node) = @_;
\&        return "<h2>", $node\->title\->present($self), "</h2>\en\en"
\&             . $node\->content\->present($self);
\&    }
\&
\&    ...
\&
\&    package Pod::POM::Node::Pod;
\&
\&    sub present {
\&        my ($self, $view) = @_;
\&        $view\->view_pod($self);
\&    }
\&
\&    package Pod::POM::Node::Head1;
\&
\&    sub present {
\&        my ($self, $view) = @_;
\&        $view\->view_head1($self);
\&    }
\&
\&    package Pod::POM::Node::Head2;
\&
\&    sub present {
\&        my ($self, $view) = @_;
\&        $view\->view_head2($self);
\&    }
\&
\&    ...
.Ve
.PP
Some of the view_xxx methods make calls back against the node objects
to display their attributes and/or content.  This is shown in, for
example, the \fBview_head1()\fR method above, where the method prints the
section title in \f(CW\*(C`<h1>\*(C'\fR...\f(CW\*(C`<h1>\*(C'\fR tags, followed by
the remaining section content.
.PP
Note that the \fBtitle()\fR attribute is printed by calling its \fBpresent()\fR
method, passing on the reference to the current view.  Similarly,
the content \fBpresent()\fR method is called giving it a chance to Do
The Right Thing to present itself correctly via the view object.
.PP
There's a good chance that the title attribute is going to be regular
text, so we might be tempted to simply print the title rather than 
call its present method.
.PP
.Vb 5
\&    sub view_head1 {
\&        my ($self, $node) = @_;
\&        # not recommended, prefer $node\->title\->present($self)
\&        return "<h1>", $node\->title(), "</h1>\en\en", ...
\&    }
.Ve
.PP
However, it is entirely valid for titles and other element attributes,
as well as regular, formatted text blocks to contain code sequences,
such like \f(CW\*(C`B<this>\*(C'\fR and \f(CW\*(C`I<this>\*(C'\fR.  These are used
to indicate different markup styles, mark external references or index
items, and so on.  What's more, they can be \f(CW\*(C`B<nested
I<indefinitely>>\*(C'\fR.  Pod::POM takes care of all this by
parsing such text, along with any embedded sequences, into Yet Another
Tree, the root node of which is a Pod::POM::Node::Text object,
possibly containing other Pod::POM::Node::Sequence objects.  When the
text is presented, the tree is automatically walked and relevant
callbacks made against the view for the different sequence types.  The
methods called against the view are all prefixed 'view_seq_', e.g.
\&'view_seq_bold', 'view_seq_italic'.
.PP
Now the real magic comes into effect.  You can define one view to
render bold/italic text in one style:
.PP
.Vb 2
\&    package My::View::Text;
\&    use parent qw( Pod::POM::View::Text );
\&
\&    sub view_seq_bold {
\&        my ($self, $text) = @_;
\&        return "*$text*";
\&    }
\&
\&    sub view_seq_italic {
\&        my ($self, $text) = @_;
\&        return "_$text_";
\&    }
.Ve
.PP
And another view to render it in a different style:
.PP
.Vb 2
\&    package My::View::HTML;
\&    use parent qw( Pod::POM::View::HTML );
\&
\&    sub view_seq_bold {
\&        my ($self, $text) = @_;
\&        return "<b>$text</b>";
\&    }
\&
\&    sub view_seq_italic {
\&        my ($self, $text) = @_;
\&        return "<i>$text</i>";
\&    }
.Ve
.PP
Then, you can easily view a Pod Object Model in either style:
.PP
.Vb 2
\&    my $text = \*(AqMy::View::Text\*(Aq;
\&    my $html = \*(AqMy::View::HTML\*(Aq;
\&
\&    print $pom\->present($text);
\&    print $pom\->present($html);
.Ve
.PP
And you can apply this technique to any node within the object
model.
.PP
.Vb 2
\&    print $pom\->head1\->[0]\->present($text);
\&    print $pom\->head1\->[0]\->present($html);
.Ve
.PP
In these examples, the view passed to the \fBpresent()\fR method has 
been a class name.  Thus, the view_xxx methods get called as 
class methods, as if written:
.PP
.Vb 1
\&    My::View::Text\->view_head1(...);
.Ve
.PP
If your view needs to maintain state then you can create a view object
and pass that to the \fBpresent()\fR method.
.PP
.Vb 2
\&    my $view = My::View\->new();
\&    $node\->present($view);
.Ve
.PP
In this case the view_xxx methods get called as object methods.
.PP
.Vb 8
\&    sub view_head1 {
\&        my ($self, $node) = @_;
\&        my $title = $node\->title();
\&        if ($title eq \*(AqNAME\*(Aq && ref $self) {
\&            $self\->{ title } = $title();
\&        }
\&        $self\->SUPER::view_head1($node);
\&    }
.Ve
.PP
Whenever you print a Pod::POM::Node::* object, or do anything to cause
Perl to stringify it (such as including it another quoted string "like
\&\f(CW$this\fR"), then its \fBpresent()\fR method is automatically called.  When
called without a view argument, the \fBpresent()\fR method uses the default
view specified in \f(CW$Pod::POM::DEFAULT_VIEW\fR, which is, by default,
\&'Pod::POM::View::Pod'.  This view regenerates the original Pod
document, although it should be noted that the output generated may
not be exactly the same as the input.  The parser is smart enough to
detect some common errors (e.g. not terminating an \f(CW\*(C`=over\*(C'\fR with a \f(CW\*(C`=back\*(C'\fR)
and correct them automatically.  Thus you might find a \f(CW\*(C`=back\*(C'\fR
correctly placed in the output, even if you forgot to add it to the 
input.  Such corrections raise non-fatal warnings which can later
be examined via the \fBwarnings()\fR method.
.PP
You can update the \f(CW$Pod::POM::DEFAULT_VIEW\fR package variable to set the 
default view, or call the \fBdefault_view()\fR method.  The \fBdefault_view()\fR 
method will automatically load any package you specify.  If setting
the package variable directly, you should ensure that any packages
required have been pre-loaded.
.PP
.Vb 2
\&    use My::View::HTML;
\&    $Pod::POM::DEFAULT_VIEW = \*(AqMy::View::HTML\*(Aq;
.Ve
.PP
or
.PP
.Vb 1
\&    Pod::POM\->default_view(\*(AqMy::View::HTML\*(Aq);
.Ve
.SS "Template Toolkit Views"
.IX Subsection "Template Toolkit Views"
One of the motivations for writing this module was to make it easier
to customise Pod documentation to your own look and feel or local
formatting conventions.  By clearly separating the content
(represented by the Pod Object Model) from the presentation style
(represented by one or more views) it becomes much easier to achieve
this.
.PP
The latest version of the Template Toolkit (2.06 at the time of
writing) provides a Pod plugin to interface to this module.  It also
implements a new (but experimental) VIEW directive which can be used
to build different presentation styles for converting Pod to other
formats.  The Template Toolkit is available from CPAN:
.PP
.Vb 1
\&    http://www.cpan.org/modules/by\-module/Template/
.Ve
.PP
Template Toolkit views are similar to the Pod::POM::View objects
described above, except that they allow the presentation style for
each Pod component to be written as a template file or block rather
than an object method.  The precise syntax and structure of the VIEW
directive is subject to change (given that it's still experimental),
but at present it can be used to define a view something like this:
.PP
.Vb 1
\&    [% VIEW myview %]
\&
\&       [% BLOCK view_head1 %]
\&          <h1>[% item.title.present(view) %]</h1>
\&          [% item.content.present(view) %]
\&       [% END %]
\& 
\&       [% BLOCK view_head2 %]
\&          <h2>[% item.title.present(view) %]</h2>
\&          [% item.content.present(view) %]
\&       [% END %]
\&
\&       ...
\&
\&    [% END %]
.Ve
.PP
A plugin is provided to interface to the Pod::POM module:
.PP
.Vb 2
\&    [% USE pod %]
\&    [% pom = pod.parse(\*(Aq/path/to/podfile\*(Aq) %]
.Ve
.PP
The returned Pod Object Model instance can then be navigated and
presented via the view in almost any way imaginable:
.PP
.Vb 6
\&    <h1>Table of Contents</h1>
\&    <ul>
\&    [% FOREACH section = pom.head1 %]
\&       <li>[% section.title.present(view) %]
\&    [% END %]
\&    </ul>
\&
\&    <hr>
\&
\&    [% FOREACH section = pom.head1 %]
\&       [% section.present(myview) %]
\&    [% END %]
.Ve
.PP
You can either pass a reference to the VIEW (myview) to the 
\&\fBpresent()\fR method of a Pod::POM node:
.PP
.Vb 1
\&    [% pom.present(myview) %]       # present entire document
.Ve
.PP
Or alternately call the \fBprint()\fR method on the VIEW, passing the 
Pod::POM node as an argument:
.PP
.Vb 1
\&    [% myview.print(pom) %]
.Ve
.PP
Internally, the view calls the \fBpresent()\fR method on the node,
passing itself as an argument.  Thus it is equivalent to the 
previous example.
.PP
The Pod::POM node and the view conspire to "Do The Right Thing" to 
process the right template block for the node.  A reference to the
node is available within the template as the 'item' variable.
.PP
.Vb 4
\&   [% BLOCK view_head2 %]
\&      <h2>[% item.title.present(view) %]</h2>
\&      [% item.content.present(view) %]
\&   [% END %]
.Ve
.PP
The Template Toolkit documentation contains further information on
defining and using views.  However, as noted above, this may be
subject to change or incomplete pending further development of the 
VIEW directive.
.SH METHODS
.IX Header "METHODS"
.SS new(\e%config)
.IX Subsection "new(%config)"
Constructor method which instantiates and returns a new Pod::POM 
parser object.
.PP
.Vb 1
\&    use Pod::POM;
\&
\&    my $parser = Pod::POM\->new();
.Ve
.PP
A reference to a hash array of configuration options may be passed as
an argument.
.PP
.Vb 1
\&    my $parser = Pod::POM\->new( { warn => 1 } );
.Ve
.PP
For convenience, configuration options can also be passed as a list of
(key => value) pairs.
.PP
.Vb 1
\&    my $parser = Pod::POM\->new( warn => 1 );
.Ve
.PP
The following configuration options are defined:
.IP code 4
.IX Item "code"
This option can be set to have all non-Pod parts of the input document
stored within the object model as 'code' elements, represented by 
objects of the Pod::POM::Node::Code class.  It is disabled by default
and code sections are ignored.
.Sp
.Vb 2
\&    my $parser = Pod::POM\->new( code => 1 );
\&    my $podpom = $parser\->parse(\e*DATA);
\&
\&    foreach my $code ($podpom\->code()) {
\&        print "<pre>$code</pre>\en";
\&    }
\&
\&    _\|_DATA_\|_
\&    This is some program code.
\&
\&    =head1 NAME
\&
\&    ...
.Ve
.Sp
This will generate the output:
.Sp
.Vb 1
\&    <pre>This is some program code.</pre>
.Ve
.Sp
Note that code elements are stored within the POM element in which
they are encountered.  For example, the code element below embedded
within between Pod sections is stored in the array which can be
retrieved by calling \f(CW\*(C`$podpom\->head1\->[0]\->code()\*(C'\fR.
.Sp
.Vb 1
\&    =head1 NAME
\&
\&    My::Module::Name;
\&
\&    =cut
\&
\&    Some program code embedded in Pod.
\&
\&    =head1 SYNOPSIS
\&
\&    ...
.Ve
.IP warn 4
.IX Item "warn"
Non-fatal warnings encountered while parsing a Pod document are stored 
internally and subsequently available via the \fBwarnings()\fR method.
.Sp
.Vb 2
\&    my $parser = Pod::POM\->new();
\&    my $podpom = $parser\->parse_file($filename);
\&
\&    foreach my $warning ($parser\->warnings()) {
\&        warn $warning, "\en";
\&    }
.Ve
.Sp
The 'warn' option can be set to have warnings raised automatically 
via \f(CWwarn()\fR as and when they are encountered.
.Sp
.Vb 2
\&    my $parser = Pod::POM\->new( warn => 1 );
\&    my $podpom = $parser\->parse_file($filename);
.Ve
.Sp
If the configuration value is specified as a subroutine reference then
the code will be called each time a warning is raised, passing the
warning message as an argument.
.Sp
.Vb 4
\&    sub my_warning {
\&        my $msg = shift;
\&        warn $msg, "\en";
\&    };
\&
\&    my $parser = Pod::POM\->new( warn => \e&my_warning );
\&    my $podpom = $parser\->parse_file($filename);
.Ve
.IP meta 4
.IX Item "meta"
The 'meta' option can be set to allow \f(CW\*(C`=meta\*(C'\fR tags within the Pod
document.
.Sp
.Vb 2
\&    my $parser = Pod::POM\->new( meta => 1 );
\&    my $podpom = $parser\->parse_file($filename);
.Ve
.Sp
This is an experimental feature which is not part of standard
POD.  For example:
.Sp
.Vb 1
\&    =meta author Andy Wardley
.Ve
.Sp
These are made available as metadata items within the root
node of the parsed POM.
.Sp
.Vb 1
\&    my $author = $podpom\->metadata(\*(Aqauthor\*(Aq);
.Ve
.Sp
See the METADATA section below for further information.
.SS parse_file($file)
.IX Subsection "parse_file($file)"
Parses the file specified by name or reference to a file handle.
Returns a reference to a Pod::POM::Node::Pod object which represents
the root node of the Pod Object Model on success.  On error, undef
is returned and the error message generated can be retrieved by calling
\&\fBerror()\fR.
.PP
.Vb 2
\&    my $podpom = $parser\->parse_file($filename)
\&        || die $parser\->error();
\&
\&    my $podpom = $parser\->parse_file(\e*STDIN)
\&        || die $parser\->error();
.Ve
.PP
Any warnings encountered can be examined by calling the 
\&\fBwarnings()\fR method.
.PP
.Vb 3
\&    foreach my $warn ($parser\->warnings()) {
\&        warn $warn, "\en";
\&    }
.Ve
.SS parse_text($text)
.IX Subsection "parse_text($text)"
Parses the Pod text string passed as an argument into a Pod Object
Model, as per \fBparse_file()\fR.
.SS parse($text_or_$file)
.IX Subsection "parse($text_or_$file)"
General purpose method which attempts to Do The Right Thing in calling
\&\fBparse_file()\fR or \fBparse_text()\fR according to the argument passed.
.PP
A hash reference can be passed as an argument that contains a 'text'
or 'file' key and corresponding value.
.PP
.Vb 2
\&    my $podpom = $parser\->parse({ file => $filename })
\&        || die $parser\->error();
.Ve
.PP
Otherwise, the argument can be a reference to an input handle which is
passed off to \fBparse_file()\fR.
.PP
.Vb 2
\&    my $podpom = $parser\->parse(\e*DATA)
\&        || die $parser\->error();
.Ve
.PP
If the argument is a text string that looks like Pod text (i.e. it
contains '=' at the start of any line) then it is passed to \fBparse_text()\fR.
.PP
.Vb 2
\&    my $podpom = $parser\->parse($podtext)
\&        || die $parser\->error();
.Ve
.PP
Otherwise it is assumed to be a filename and is passed to \fBparse_file()\fR.
.PP
.Vb 2
\&    my $podpom = $parser\->parse($podfile)
\&        || die $parser\->error();
.Ve
.SH "NODE TYPES, ATTRIBUTES AND ELEMENTS"
.IX Header "NODE TYPES, ATTRIBUTES AND ELEMENTS"
This section lists the different nodes that may be present in a Pod Object
Model.  These are implemented as Pod::POM::Node::* object instances 
(e.g. head1 => Pod::POM::Node::Head1).  To present a node, a view should
implement a method which corresponds to the node name prefixed by 'view_'
(e.g. head1 => \fBview_head1()\fR).
.IP pod 4
.IX Item "pod"
The \f(CW\*(C`pod\*(C'\fR node is used to represent the root node of the Pod Object Model.
.Sp
Content elements: head1, head2, head3, head4, over, begin, for,
verbatim, text, code.
.IP head1 4
.IX Item "head1"
A \f(CW\*(C`head1\*(C'\fR node contains the Pod content from a \f(CW\*(C`=head1\*(C'\fR tag up to the 
next \f(CW\*(C`=head1\*(C'\fR tag or the end of the file.
.Sp
Attributes: title
.Sp
Content elements: head2, head3, head4, over, begin, for, verbatim, text, code.
.IP head2 4
.IX Item "head2"
A \f(CW\*(C`head2\*(C'\fR node contains the Pod content from a \f(CW\*(C`=head2\*(C'\fR tag up to the 
next \f(CW\*(C`=head1\*(C'\fR or \f(CW\*(C`=head2\*(C'\fR tag or the end of the file.
.Sp
Attributes: title
.Sp
Content elements: head3, head4, over, begin, for, verbatim, text, code.
.IP head3 4
.IX Item "head3"
A \f(CW\*(C`head3\*(C'\fR node contains the Pod content from a \f(CW\*(C`=head3\*(C'\fR tag up to the 
next \f(CW\*(C`=head1\*(C'\fR, \f(CW\*(C`=head2\*(C'\fR or \f(CW\*(C`=head3\*(C'\fR tag or the end of the file.
.Sp
Attributes: title
.Sp
Content elements: head4, over, begin, for, verbatim, text, code.
.IP head4 4
.IX Item "head4"
A \f(CW\*(C`head4\*(C'\fR node contains the Pod content from a \f(CW\*(C`=head4\*(C'\fR tag up to the 
next \f(CW\*(C`=head1\*(C'\fR, \f(CW\*(C`=head2\*(C'\fR, \f(CW\*(C`=head3\*(C'\fR or \f(CW\*(C`=head4\*(C'\fR tag or the end of the file.
.Sp
Attributes: title
.Sp
Content elements: over, begin, for, verbatim, text, code.
.IP over 4
.IX Item "over"
The \f(CW\*(C`over\*(C'\fR node encloses the Pod content in a list starting at an \f(CW\*(C`=over\*(C'\fR 
tag and continuing up to the matching \f(CW\*(C`=back\*(C'\fR tag.  Lists may be nested 
indefinitely.
.Sp
Attributes: indent (default: 4)
.Sp
Content elements: over, item, begin, for, verbatim, text, code.
.IP item 4
.IX Item "item"
The \f(CW\*(C`item\*(C'\fR node encloses the Pod content in a list item starting at an 
\&\f(CW\*(C`=item\*(C'\fR tag and continuing up to the next \f(CW\*(C`=item\*(C'\fR tag or a \f(CW\*(C`=back\*(C'\fR tag
which terminates the list.
.Sp
Attributes: title (default: *)
.Sp
Content elements: over, begin, for, verbatim, text, code.
.IP begin 4
.IX Item "begin"
A \f(CW\*(C`begin\*(C'\fR node encloses the Pod content in a conditional block starting 
with a \f(CW\*(C`=begin\*(C'\fR tag and continuing up to the next \f(CW\*(C`=end\*(C'\fR tag.
.Sp
Attributes: format
.Sp
Content elements: verbatim, text, code.
.IP for 4
.IX Item "for"
A \f(CW\*(C`for\*(C'\fR node contains a single paragraph containing text relevant to a 
particular format.
.Sp
Attributes: format, text
.IP verbatim 4
.IX Item "verbatim"
A \f(CW\*(C`verbatim\*(C'\fR node contains a verbatim text paragraph which is prefixed by
whitespace in the source Pod document (i.e. indented).
.Sp
Attributes: text
.IP text 4
.IX Item "text"
A \f(CW\*(C`text\*(C'\fR node contains a regular text paragraph.  This may include 
embedded inline sequences.
.Sp
Attributes: text
.IP code 4
.IX Item "code"
A \f(CW\*(C`code\*(C'\fR node contains Perl code which is by default, not considered to be 
part of a Pod document.  The \f(CW\*(C`code\*(C'\fR configuration option must be set for
Pod::POM to generate code blocks, otherwise they are ignored.
.Sp
Attributes: text
.SH "INLINE SEQUENCES"
.IX Header "INLINE SEQUENCES"
Embedded sequences are permitted within regular text blocks (i.e. not
verbatim) and title attributes.  To present these sequences, a view
should implement methods corresponding to the sequence name, prefixed
by 'view_seq_' (e.g. bold => \fBview_seq_bold()\fR).
.IP code 4
.IX Item "code"
Code extract, e.g. C<my code>
.IP bold 4
.IX Item "bold"
Bold text, e.g. B<bold text>
.IP italic 4
.IX Item "italic"
Italic text, e.g. I<italic text>
.IP link 4
.IX Item "link"
A link (cross reference), e.g. L<My::Module>
.IP space 4
.IX Item "space"
Text contains non-breaking space, e.g.S<Buffy The Vampire Slayer>
.IP file 4
.IX Item "file"
A filename, e.g. F</etc/lilo.conf>
.IP index 4
.IX Item "index"
An index entry, e.g. X<Angel>
.IP zero 4
.IX Item "zero"
A zero-width character, e.g. Z<>
.IP entity 4
.IX Item "entity"
An entity escape, e.g. E<lt>
.SH "BUNDLED MODULES AND TOOLS"
.IX Header "BUNDLED MODULES AND TOOLS"
The Pod::POM module distribution includes a number of sample view
objects for rendering Pod Object Models into particular formats.  These
are incomplete and may require some further work, but serve at present to 
illustrate the principal and can be used as the basis for your own view
objects.
.IP Pod::POM::View::Pod 4
.IX Item "Pod::POM::View::Pod"
Regenerates the model as Pod.
.IP Pod::POM::View::Text 4
.IX Item "Pod::POM::View::Text"
Presents the model as plain text.
.IP Pod::POM::View::HTML 4
.IX Item "Pod::POM::View::HTML"
Presents the model as HTML.
.PP
A script is provided for converting Pod documents to other format by
using the view objects provided.  The \f(CW\*(C`pom2\*(C'\fR script should be called 
with two arguments, the first specifying the output format, the second
the input filename.  e.g.
.PP
.Vb 2
\&    $ pom2 text My/Module.pm > README
\&    $ pom2 html My/Module.pm > ~/public_html/My/Module.html
.Ve
.PP
You can also create symbolic links to the script if you prefer and 
leave it to determine the output format from its own name.
.PP
.Vb 4
\&    $ ln \-s pom2 pom2text       
\&    $ ln \-s pom2 pom2html
\&    $ pom2text My/Module.pm > README
\&    $ pom2html My/Module.pm > ~/public_html/My/Module.html
.Ve
.PP
The distribution also contains a trivial script, \f(CW\*(C`podlint\*(C'\fR
(previously \f(CW\*(C`pomcheck\*(C'\fR), which checks a Pod document for
well-formedness by simply parsing it into a Pod Object Model with
warnings enabled.  Warnings are printed to STDERR.
.PP
.Vb 1
\&    $ podlint My/Module.pm
.Ve
.PP
The \f(CW\*(C`\-f\*(C'\fR option can be set to have the script attempt to fix any problems
it encounters.  The regenerated Pod output is printed to STDOUT.
.PP
.Vb 1
\&    $ podlint \-f My/Module.pm > newfile
.Ve
.SH METADATA
.IX Header "METADATA"
This module includes support for an experimental new \f(CW\*(C`=meta\*(C'\fR tag.  This
is disabled by default but can be enabled by loading Pod::POM with the 
\&\f(CW\*(C`meta\*(C'\fR option.
.PP
.Vb 1
\&    use Pod::POM qw( meta );
.Ve
.PP
Alternately, you can specify the \f(CW\*(C`meta\*(C'\fR option to be any true value when 
you instantiate a Pod::POM parser:
.PP
.Vb 2
\&    my $parser = Pod::POM\->new( meta => 1 );
\&    my $pom    = $parser\->parse_file($filename);
.Ve
.PP
Any \f(CW\*(C`=meta\*(C'\fR tags in the document will be stored as metadata items in the 
root node of the Pod model created.
.PP
For example:
.PP
.Vb 1
\&    =meta module Foo::Bar
\&
\&    =meta author Andy Wardley
.Ve
.PP
You can then access these items via the \fBmetadata()\fR method.
.PP
.Vb 2
\&    print "module: ", $pom\->metadata(\*(Aqmodule\*(Aq), "\en";
\&    print "author: ", $pom\->metadata(\*(Aqauthor\*(Aq), "\en";
.Ve
.PP
or
.PP
.Vb 3
\&    my $metadata = $pom\->metadata();
\&    print "module: $metadata\->{ module }\en";
\&    print "author: $metadata\->{ author }\en";
.Ve
.PP
Please note that this is an experimental feature which is not supported by
other POD processors and is therefore likely to be most incompatible.  Use
carefully.
.SH AUTHOR
.IX Header "AUTHOR"
Andy Wardley <abw@kfs.org>
.PP
Andrew Ford <A.Ford@ford\-mason.co.uk> (co-maintainer as of 03/2009)
.SH COPYRIGHT
.IX Header "COPYRIGHT"
Copyright (C) 2000\-2009 Andy Wardley.  All Rights Reserved.
.PP
This module is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.
.SH "SEE ALSO"
.IX Header "SEE ALSO"
For the definitive reference on Pod, see perlpod.
.PP
For an overview of Pod::POM internals and details relating to subclassing
of POM nodes, see Pod::POM::Node.
.PP
There are numerous other fine Pod modules available from CPAN which
perform conversion from Pod to other formats.  In many cases these are
likely to be faster and quite possibly more reliable and/or complete
than this module.  But as far as I know, there aren't any that offer
the same kind of flexibility in being able to customise the generated
output.  But don't take my word for it \- see your local CPAN site for
further details:
.PP
.Vb 1
\&    http://www.cpan.org/modules/by\-module/Pod/
.Ve