SYNOPSIS

package Pod::SomeFormatter;
use Pod::Simple;
@ISA = qw(Pod::Simple);
$VERSION = '1.01';
use strict;
sub _handle_element_start {
my($parser, $element_name, $attr_hash_r) = @_;
...
}
sub _handle_element_end {
my($parser, $element_name, $attr_hash_r) = @_;
# NOTE: $attr_hash_r is only present when $element_name is "over" or "begin"
# The remaining code excerpts will mostly ignore this $attr_hash_r, as it is
# mostly useless. It is documented where "over-*" and "begin" events are
# documented.
...
}
sub _handle_text {
my($parser, $text) = @_;
...
}
1;

DESCRIPTION

The zeroeth step in writing a Pod formatter is to make sure that there isn't already a decent one in CPAN. See <http://search.cpan.org/>, and run a search on the name of the format you want to render to. Also consider joining the Pod People list <http://lists.perl.org/showlist.cgi?name=pod-people> and asking whether anyone has a formatter for that format --- maybe someone cobbled one together but just hasn't released it.

The first step in writing a Pod processor is to read perlpodspec, which contains information on writing a Pod parser (which has been largely taken care of by Pod::Simple), but also a lot of requirements and recommendations for writing a formatter.

The second step is to actually learn the format you're planning to format to --- or at least as much as you need to know to represent Pod, which probably isn't much.

The third step is to pick which of Pod::Simple's interfaces you want to use:

Pod::Simple

The basic Pod::Simple interface that uses "_handle_element_start()", "_handle_element_end()" and "_handle_text()".

Pod::Simple::Methody

The Pod::Simple::Methody interface is event-based, similar to that of HTML::Parser or XML::Parser's ``Handlers''.

Pod::Simple::PullParser

Pod::Simple::PullParser provides a token-stream interface, sort of like HTML::TokeParser's interface.

Pod::Simple::SimpleTree

Pod::Simple::SimpleTree provides a simple tree interface, rather like XML::Parser's ``Tree'' interface. Users familiar with XML handling will be comfortable with this interface. Users interested in outputting XML, should look into the modules that produce an XML representation of the Pod stream, notably Pod::Simple::XMLOutStream; you can feed the output of such a class to whatever XML parsing system you are most at home with.

The last step is to write your code based on how the events (or tokens, or tree-nodes, or the XML, or however you're parsing) will map to constructs in the output format. Also be sure to consider how to escape text nodes containing arbitrary text, and what to do with text nodes that represent preformatted text (from verbatim sections).

Events

In the following section, we use XML to represent the event structure associated with a particular construct. That is, TODO

"$parser->_handle_element_start( element_name, attr_hashref )"

"$parser->_handle_element_end(

element_name )"

"$parser->_handle_text(

text_string )"

TODO describe

events with an element_name of Document

Parsing a document produces this event structure:

  <Document start_line="543">
        ...all events...
  </Document>

The value of the start_line attribute will be the line number of the first Pod directive in the document.

If there is no Pod in the given document, then the event structure will be this:

  <Document contentless="1" start_line="543">
  </Document>

In that case, the value of the start_line attribute will not be meaningful; under current implementations, it will probably be the line number of the last line in the file.

        <Para start_line="543">
          ...all events in this paragraph...
        </Para>

  The value of the I<start_line> attribute will be the
  line number of the start of the paragraph.

        <Para start_line="129">
          The value of the
          <I>
                start_line
          </I>
           attribute will be the line number of the first Pod directive
          in the document.
        </Para>

          <B>
                ...stuff...
          </B>

          <S>
                ...stuff...
          </S>

          <X>
                ...stuff...
          </X>

  <L content-implicit="yes" raw="that_url" to="that_url" type="url">
        that_url
  </L>

  L<http://www.perl.com/CPAN/authors/>

  <L content-implicit="yes" raw="http://www.perl.com/CPAN/authors/" to="http://www.perl.com/CPAN/authors/" type="url">
        http://www.perl.com/CPAN/authors/
  </L>

  <L content-implicit="yes" raw="manpage(section)" to="manpage(section)" type="man">
        manpage(section)
  </L>

  L<crontab(5)>

  <L content-implicit="yes" raw="crontab(5)" to="crontab(5)" type="man">
        crontab(5)
  </L>

  L<crontab(5)/"ENVIRONMENT">

  <L content-implicit="yes" raw="crontab(5)/&quot;ENVIRONMENT&quot;" section="ENVIRONMENT" to="crontab(5)" type="man">
        "ENVIRONMENT" in crontab(5)
  </L>

  L<hell itself!|crontab(5)>

  <L raw="hell itself!|crontab(5)" to="crontab(5)" type="man">
        hell itself!
  </L>

  <L content-implicit="yes" raw="podpage" to="podpage" type="pod">
        podpage
  </L>

  L<Net::Ping>

  <L content-implicit="yes" raw="Net::Ping" to="Net::Ping" type="pod">
        Net::Ping
  </L>

  L<Perl Error Messages|perldiag>

  <L raw="Perl Error Messages|perldiag" to="perldiag" type="pod">
        Perl Error Messages
  </L>

  L</"Member Data">

  <L content-implicit="yes" raw="/&quot;Member Data&quot;" section="Member Data" type="pod">
        "Member Data"
  </L>

  L<the various attributes|/"Member Data">

  <L raw="the various attributes|/&quot;Member Data&quot;" section="Member Data" type="pod">
        the various attributes
  </L>

  L<perlsyn/"Basic BLOCKs and Switch Statements">

  <L content-implicit="yes" raw="perlsyn/&quot;Basic BLOCKs and Switch Statements&quot;" section="Basic BLOCKs and Switch Statements" to="perlsyn" type="pod">
        "Basic BLOCKs and Switch Statements" in perlsyn
  </L>

  L<SWITCH statements|perlsyn/"Basic BLOCKs and Switch Statements">

  <L raw="SWITCH statements|perlsyn/&quot;Basic BLOCKs and Switch Statements&quot;" section="Basic BLOCKs and Switch Statements" to="perlsyn" type="pod">
        SWITCH statements
  </L>

  L</"Member Data">
  L<"Member Data">
  L</Member Data>
  L<Member Data>    [deprecated syntax]

  <L content-implicit="yes" raw="$depends_on_syntax" section="Member Data" type="pod">
        &#34;Member Data&#34;
  </L>

  L<click B<here>|page/About the C<-M> switch>
  <L raw="click B<here>|page/About the C<-M> switch" section="About the -M switch" to="page" type="pod">
        click B<here>
  </L>

  <Verbatim start_line="543" xml:space="preserve">
        ...text...
  </Verbatim>

  <head1>
        ...stuff...
  </head1>

  =head1 Options to C<new> et al.

  <head1 start_line="543">
        Options to
        <C>
          new
        </C>
         et al.
  </head1>

  <over-bullet indent="4" start_line="543">
        <item-bullet start_line="545">
          ...Stuff...
        </item-bullet>
        ...more item-bullets...
  </over-bullet fake-closer="1">

  =over
  =item *
  Something
  =back

  =over
  =item *
  Gasp! An unclosed =over block!

  =over
  =item *
  Stuff
  =item *
  Bar I<baz>!
  =back

  <over-bullet indent="4" start_line="10">
        <item-bullet start_line="12">
          Stuff
        </item-bullet>
        <item-bullet start_line="14">
          Bar <I>baz</I>!
        </item-bullet>
  </over-bullet>

  <over-number indent="4" start_line="543">
        <item-number number="1" start_line="545">
          ...Stuff...
        </item-number>
        ...more item-number...
  </over-bullet>

  <over-text indent="4" start_line="543">
        <item-text>
          ...stuff...
        </item-text>
        ...stuff (generally Para or Verbatim elements)...
        <item-text>
        ...more item-text and/or stuff...
  </over-text>

  =over
  =item Foo
  Stuff
  =item Bar I<baz>!
  Quux
  =back

  <over-text indent="4" start_line="20">
        <item-text start_line="22">
          Foo
        </item-text>
        <Para start_line="24">
          Stuff
        </Para>
        <item-text start_line="26">
          Bar
                <I>
                  baz
                </I>
          !
        </item-text>
        <Para start_line="28">
          Quux
        </Para>
  </over-text>

  <over-block indent="4" start_line="543">
        ...stuff (generally Para or Verbatim elements)...
  </over-block>

  =over
  For cutting off our trade with all parts of the world
  For transporting us beyond seas to be tried for pretended offenses
  He is at this time transporting large armies of foreign mercenaries to
  complete the works of death, desolation and tyranny, already begun with
  circumstances of cruelty and perfidy scarcely paralleled in the most
  barbarous ages, and totally unworthy the head of a civilized nation.
  =back

  <over-block indent="4" start_line="2">
        <Para start_line="4">
          For cutting off our trade with all parts of the world
        </Para>
        <Para start_line="6">
          For transporting us beyond seas to be tried for pretended offenses
        </Para>
        <Para start_line="8">
          He is at this time transporting large armies of [...more text...]
        </Para>
  </over-block>

  <over-empty indent="4" start_line="543">
  </over-empty>

  =over
  =over
  =back
  =back

  <over-block indent="4" start_line="1">
        <over-empty indent="4" start_line="3">
        </over-empty>
  </over-block>

More Pod::Simple Methods

"$parser->accept_targets( SOMEVALUE )"

As the parser sees sections like:

        =for html  <img src="fig1.jpg">

or

        =begin html
          <img src="fig1.jpg">
        =end html

...the parser will ignore these sections unless your subclass has specified that it wants to see sections targeted to ``html'' (or whatever the formatter name is).

If you want to process all sections, even if they're not targeted for you, call this before you start parsing:

  $parser->accept_targets('*');

"$parser->accept_targets_as_text( SOMEVALUE )"

This is like accept_targets, except that it specifies also that the content of sections for this target should be treated as Pod text even if the target name in "=for

targetname`` doesn't start with a '':".

At time of writing, I don't think you'll need to use this.

"$parser->accept_codes( Codename, Codename... )"

This tells the parser that you accept additional formatting codes, beyond just the standard ones (I B C L F S X, plus the two weird ones you don't actually see in the parse tree, Z and E). For example, to also accept codes ``N'', ``R'', and ``W'':

        $parser->accept_codes( qw( N R W ) );

TODO: document how this interacts with =extend, and long element names

"$parser->accept_directive_as_data( directive_name )"

"$parser->accept_directive_as_verbatim(

directive_name )"

"$parser->accept_directive_as_processed(

directive_name )"

In the unlikely situation that you need to tell the parser that you will accept additional directives (``=foo'' things), you need to first set the parser to treat its content as data (i.e., not really processed at all), or as verbatim (mostly just expanding tabs), or as processed text (parsing formatting codes like B<...>).

For example, to accept a new directive ``=method'', you'd presumably use:

        $parser->accept_directive_as_processed("method");

so that you could have Pod lines like:

        =method I<$whatever> thing B<um>

Making up your own directives breaks compatibility with other Pod formatters, in a way that using "=for target ..." lines doesn't; however, you may find this useful if you're making a Pod superset format where you don't need to worry about compatibility.

"$parser->nbsp_for_S( BOOLEAN );"

Setting this attribute to a true value (and by default it is false) will turn ``S<...>'' sequences into sequences of words separated by "\xA0"

(non-breaking space) characters. For example, it will take this:

        I like S<Dutch apple pie>, don't you?

and treat it as if it were:

        I like DutchE<nbsp>appleE<nbsp>pie, don't you?

This is handy for output formats that don't have anything quite like an ``S<...>'' code, but which do have a code for non-breaking space.

There is currently no method for going the other way; but I can probably provide one upon request.

"$parser->version_report()"

This returns a string reporting the $VERSION value from your module (and its classname) as well as the $VERSION value of Pod::Simple. Note that perlpodspec requires output formats (wherever possible) to note this detail in a comment in the output format. For example, for some kind of SGML output format:

        print OUT "<!-- \n", $parser->version_report, "\n -->";

"$parser->pod_para_count()"

This returns the count of Pod paragraphs seen so far.

"$parser->line_count()"

This is the current line number being parsed. But you might find the ``line_number'' event attribute more accurate, when it is present.

"$parser->nix_X_codes( SOMEVALUE )"

This attribute, when set to a true value (and it is false by default) ignores any ``X<...>'' sequences in the document being parsed. Many formats don't actually use the content of these codes, so have no reason to process them.

"$parser->keep_encoding_directive(

SOMEVALUE )"

This attribute, when set to a true value (it is false by default) will keep "=encoding"

and its content in the event structure. Most formats don't actually need to process the content of an "=encoding" directive, even when this directive sets the encoding and the processor makes use of the encoding information. Indeed, it is possible to know the encoding without processing the directive content.

"$parser->merge_text( SOMEVALUE )"

This attribute, when set to a true value (and it is false by default) makes sure that only one event (or token, or node) will be created for any single contiguous sequence of text. For example, consider this somewhat contrived example:

        I just LOVE Z<>hotE<32>apple pie!

When that is parsed and events are about to be called on it, it may actually seem to be four different text events, one right after another: one event for ``I just LOVE '', one for ``hot'', one for `` '', and one for ``apple pie!''. But if you have merge_text on, then you're guaranteed that it will be fired as one text event: ``I just LOVE hot apple pie!''.

"$parser->code_handler( CODE_REF )"

This specifies code that should be called when a code line is seen (i.e., a line outside of the Pod). Normally this is undef, meaning that no code should be called. If you provide a routine, it should start out like this:

        sub get_code_line {  # or whatever you'll call it
          my($line, $line_number, $parser) = @_;
          ...
        }

Note, however, that sometimes the Pod events aren't processed in exactly the same order as the code lines are --- i.e., if you have a file with Pod, then code, then more Pod, sometimes the code will be processed (via whatever you have code_handler call) before the all of the preceding Pod has been processed.

"$parser->cut_handler( CODE_REF )"

This is just like the code_handler attribute, except that it's for ``=cut'' lines, not code lines. The same caveats apply. ``=cut'' lines are unlikely to be interesting, but this is included for completeness.

"$parser->pod_handler(

CODE_REF )"

This is just like the code_handler attribute, except that it's for ``=pod'' lines, not code lines. The same caveats apply. ``=pod'' lines are unlikely to be interesting, but this is included for completeness.

"$parser->whiteline_handler(

CODE_REF )"

This is just like the code_handler attribute, except that it's for lines that are seemingly blank but have whitespace (`` '' and/or ``\t'') on them, not code lines. The same caveats apply. These lines are unlikely to be interesting, but this is included for completeness.

"$parser->whine(

linenumber, complaint string )"

This notes a problem in the Pod, which will be reported in the ``Pod Errors'' section of the document and/or sent to

STDERR, depending on the values of the attributes "no_whining", "no_errata_section", and "complain_stderr".

"$parser->scream( linenumber, complaint string )"

This notes an error like "whine"

does, except that it is not suppressible with "no_whining". This should be used only for very serious errors.

"$parser->source_dead(1)"

This aborts parsing of the current document, by switching on the flag that indicates that EOF has been seen. In particularly drastic cases, you might want to do this. It's rather nicer than just calling "die"!

"$parser->hide_line_numbers( SOMEVALUE )"

Some subclasses that indiscriminately dump event attributes (well, except for ones beginning with ``~'') can use this object attribute for refraining to dump the ``start_line'' attribute.

"$parser->no_whining(

SOMEVALUE )"

This attribute, if set to true, will suppress reports of non-fatal error messages. The default value is false, meaning that complaints

are reported. How they get reported depends on the values of the attributes "no_errata_section" and "complain_stderr".

"$parser->no_errata_section( SOMEVALUE )"

This attribute, if set to true, will suppress generation of an errata section. The default value is false --- i.e., an errata section will be generated.

"$parser->complain_stderr(

SOMEVALUE )"

This attribute, if set to true will send complaints to

STDERR. The default value is false --- i.e., complaints do not go to STDERR.

"$parser->bare_output(

SOMEVALUE )"

Some formatter subclasses use this as a flag for whether output should have prologue and epilogue code omitted. For example, setting this to true for an

HTML formatter class should omit the ``<html><head><title>...</title><body>...'' prologue and the ``</body></html>'' epilogue.

If you want to set this to true, you should probably also set "no_whining" or at least "no_errata_section" to true.

"$parser->preserve_whitespace( SOMEVALUE )"

If you set this attribute to a true value, the parser will try to preserve whitespace in the output. This means that such formatting conventions as two spaces after periods will be preserved by the parser. This is primarily useful for output formats that treat whitespace as significant (such as text or *roff, but not

HTML).

"$parser->parse_empty_lists(

SOMEVALUE )"

If this attribute is set to true, the parser will not ignore empty "=over"

/"=back" blocks. The type of "=over" will be empty, documented above, ``events with an element_name of over-empty''.

SUPPORT

This module is managed in an open GitHub repository, <https://github.com/perl-pod/pod-simple/>. Feel free to fork and contribute, or to clone <git://github.com/perl-pod/pod-simple.git> and send patches!

Patches against Pod::Simple are welcome. Please send bug reports to <[email protected]>.

COPYRIGHT AND DISCLAIMERS

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

This program is distributed in the hope that it will be useful, but without any warranty; without even the implied warranty of merchantability or fitness for a particular purpose.

AUTHOR

Pod::Simple is maintained by:

• Allison Randal "[email protected]"
• Hans Dieter Pearcey "[email protected]"
• David E. Wheeler "[email protected]"