Pod::Simple::Subclassing -- write a formatter as a Pod::Simple subclass

  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) = @_;
    ...
  }

  sub _handle_text {
    my($parser, $text) = @_;
    ...
  }
  1;

This document is about using Pod::Simple to write a Pod processor, generally a Pod formatter. If you just want to know about using an existing Pod formatter, instead see its documentation and see also the docs in Pod::Simple.

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 notes 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 the basic interface via Pod::Simple or Pod::Simple::Methody is event-based, sort of like HTML::Parser's interface, or sort of like XML::Parser's Handlers interface), but Pod::Simple::PullParser provides a token-stream interface, sort of like HTML::TokeParser's interface; Pod::Simple::SimpleTree provides a simple tree interface, rather like XML::Parser's Tree interface. Users familiar with XML-handling will find one of these styles relatively familiar; but if you would be even more at home with XML, there are classes 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 sure to consider how to escape text nodes containing arbitrary text, and also what to do with text nodes that represent preformatted text (from verbatim sections).

TODO intro... mention that events are supplied for implicits, like for missing >'s

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

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.

events with an element_name of Para

Parsing a plain (non-verbatim, non-directive, non-data) paragraph in a Pod document produces this event structure:

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

The value of the start_line attribute will be the line number of the start of the paragraph. For example, parsing this paragraph of Pod:

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

produces this event structure:

    <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>

events with an element_name of B, C, F, or I.

Parsing a B<...> formatting code (or of course any of its semantically identical syntactic variants B<< ... >>, or B<<<< ... >>>>, etc.) produces this event structure:

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

Currently, there are no attributes conveyed. Parsing C, F, or I codes produce the same structure, with only a different element name. If your parser object has been set to accept other formatting codes, then they will be presented like these B/C/F/I codes i.e., without any attributes.

events with an element_name of S

Normally, parsing an S<...> sequence produces this event structure, just as if it were a B/C/F/I code:

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

However, Pod::Simple (and presumably all derived parsers) offers the CWnbsp_for_S option which, if enabled, will suppress all S events, and instead change all spaces in the content to non-breaking spaces. This is intended for formatters that output to a format that has no code that means the same as S<...>, but which has a code/character that means non-breaking space.

events with an element_name of X

Normally, parsing an X<...> sequence produces this event structure, just as if it were a B/C/F/I code:

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

However, Pod::Simple (and presumably all derived parsers) offers the CWnix_X_codes option which, if enabled, will suppress all X events and ignore their content. For formatters/processors that don't use X events, this is presumably quite useful.

events with an element_name of L

Because the L<...> is the most complex construct in the language, it should not surprise you that the events it generates are the most complex in the language. Most of complexity is hidden away in the attribute values, so for those of you writing a Pod formatter that produces a non-hypertextual format, you can just ignore the attributes and treat an L event structure like a formatting element that (presumably) doesn't actually produce a change in formatting. That is, the content of the L event structure (as opposed to its attributes) is always what text should be displayed. There are, at first glance, three kinds of L links: URL, man, and pod. When a L<some_url> code is parsed, it produces this event structure:

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

The CWtype="url" attribute is always specified for this type of L code. For example, this Pod source:

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

produces this event structure:

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

When a L<manpage(section)> code is parsed (and these are fairly rare and not terribly useful), it produces this event structure:

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

The CWtype="man" attribute is always specified for this type of L code. For example, this Pod source:

  L<crontab(5)>

produces this event structure:

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

In the rare cases where a man page link has a specified, that text appears in a section attribute. For example, this Pod source:

  L<crontab(5)/"ENVIRONMENT">

will produce this event structure:

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

In the rare case where the Pod document has code like L<sometext|manpage(section)>, then the sometext will appear as the content of the element, the manpage(section) text will appear only as the value of the to attribute, and there will be no CWcontent-implicit="yes" attribute (whose presence means that the Pod parser had to infer what text should appear as the link text as opposed to cases where that attribute is absent, which means that the Pod parser did not have to infer the link text, because that L code explicitly specified some link text.) For example, this Pod source:

  L<hell itself!|crontab(5)>

will produce this event structure:

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

The last type of L structure is for links to/within Pod documents. It is the most complex because it can have a to attribute, or a section attribute, or both. The CWtype="pod" attribute is always specified for this type of L code. In the most common case, the simple case of a L<podpage> code produces this event structure:

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

For example, this Pod source:

  L<Net::Ping>

produces this event structure:

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

In cases where there is link-text explicitly specified, it is to be found in the content of the element (and not the attributes), just as with the L<sometext|manpage(section)> case discussed above. For example, this Pod source:

  L<Perl Error Messages|perldiag>

produces this event structure:

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

In cases of links to a section in the current Pod document, there is a section attribute instead of a to attribute. For example, this Pod source:

  L</"Member Data">

produces this event structure:

  <L content-implicit="yes" section="Member Data" type="pod">
    "Member Data"
  </L>

As another example, this Pod source:

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

produces this event structure:

  <L section="Member Data" type="pod">
    the various attributes
  </L>

In cases of links to a section in a different Pod document, there are both a section attribute and a to attribute. For example, this Pod source:

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

produces this event structure:

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

As another example, this Pod source:

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

produces this event structure:

  <L section="Basic BLOCKs and Switch Statements" to="perlsyn" type="pod">
    SWITCH statements
  </L>

Incidentally, note that we do not distinguish between these syntaxes:

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

That is, they all produce the same event structure, namely:

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

events with an element_name of E or Z

While there are Pod codes E<...> and Z<>, these do not produce any E or Z events that is, there are no such events as E or Z.

events with an element_name of Verbatim

When a Pod verbatim paragraph (AKA codeblock) is parsed, it produces this event structure:

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

The value of the start_line attribute will be the line number of the first line of this verbatim block. The xml:space attribute is always present, and always has the value preserve. The text content will have tabs already expanded.

events with an element_name of head1 .. head4

When a =head1 ... directive is parsed, it produces this event structure:

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

For example, a directive consisting of this:

  =head1 Options to C<new> et al.

will produce this event structure:

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

=head2 thru =head4 directives are the same, except for the element names in the event structure.

events with an element_name of over-bullet

When an "=over ... =back" block is parsed where the items are a bulletted list, it will produce this event structure:

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

The value of the indent attribute is whatever value is after the =over directive, as in =over 8. If no such value is specified in the directive, then the indent attribute has the value 4. For example, this Pod source:

  =over

  =item *

  Stuff

  =item *

  Bar I<baz>!

  =back

produces this event structure:

  <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>

events with an element_name of over-number

When an "=over ... =back" block is parsed where the items are a numbered list, it will produce this event structure:

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

This is like the over-bullet event structure; but note that the contents are item-number instead of item-bullet, and note that they will have a number attribute, which some formatters/processors may ignore (since, for example, there's no need for it in HTML when producing an <UL><LI>...</LI>...</UL> structure), but which any processor may use. Note that the values for the number attributes of item-number elements in a given over-number area will start at 1 and go up by one each time. If the Pod source doesn't follow that order (even though it really should should!), whatever numbers it has will be ignored (with the correct values being put in the number attributes), and an error message might be issued to the user.

events with an element_name of over-text

These events are are somewhat unlike the other over-* structures, as far as what their contents are. When an "=over ... =back block is parsed where the items are a list of text subheadings", it will produce this event structure:

  <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>

The indent attribute is as with the other over-* events. For example, this Pod source:

  =over

  =item Foo

  Stuff

  =item Bar I<baz>!

  Quux

  =back

produces this event structure:

  <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>

events with an element_name of over-block

These events are are somewhat unlike the other over-* structures, as far as what their contents are. When an "=over ... =back" block is parsed where there are no items, it will produce this event structure:

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

The indent attribute is as with the other over-* events. For example, this Pod source:

  =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.

  =cut

will produce this event structure:

  <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>

events with an element_name of item-bullet

See events with an element_name of over-bullet, above.

events with an element_name of item-number

See events with an element_name of over-number, above.

events with an element_name of item-text

See events with an element_name of over-text, above.

events with an element_name of for

TODO...

events with an element_name of Data

TODO...

Pod::Simple provides a lot of methods that aren't generally interesting to the end user of an existing Pod formatter, but some of which you might find useful in writing a Pod formatter. They are listed below. The first several methods (the accept_* methods) are for declaring the capabilites of your parser, notably what CW=for CItargetnameCW sections it's interested in, what extra N<...> codes it accepts beyond the ones described in the perlpod. As the parser sees sections like:

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

    =begin html

      <img src="fig1.jpg">

    =end html

  $parser->accept_targets('*');

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

    $parser->accept_directive_as_processed("method");

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

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

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

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

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

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

Pod::Simple event-based Pod-parsing framework

Pod::Simple::Methody like Pod::Simple, but each sort of event calls its own method (like CWstart_head3)

Pod::Simple::PullParser a Pod-parsing framework like Pod::Simple, but with a token-stream interface

Pod::Simple::SimpleTree a Pod-parsing framework like Pod::Simple, but with a tree interface

Pod::Simple::Checker a simple Pod::Simple subclass that reads documents, and then makes a plaintext report of any errors found in the document

Pod::Simple::DumpAsXML for dumping Pod documents as tidily indented XML, showing each event on its own line

Pod::Simple::XMLOutStream dumps a Pod document as XML (without introducing extra whitespace as Pod::Simple::DumpAsXML does).

Pod::Simple::DumpAsText for dumping Pod documents as tidily indented text, showing each event on its own line

Pod::Simple::LinkSection class for objects representing the values of the TODO and TODO attributes of L<...> elements

Pod::Escapes the module the Pod::Simple uses for evaluating E<...> content

Pod::Simple::Text a simple plaintext formatter for Pod

Pod::Simple::TextContent like Pod::Simple::Text, but makes no effort for indent or wrap the text being formatted

perlpod

perlpodspec

perldoc

Copyright (c) 2002 Sean M. Burke. All rights reserved.

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.

Sean M. Burke CWsburke@cpan.org