Recipe 12.16. Documenting Your Module with Pod
Author: Tom Christiansen & Nathan Torkington
Date: 1999-07-02T01:42:01Z

#

| Chapter 12 Packages, Libraries, and Modules |

## 12.16. Documenting Your Module with Pod

### Problem

You need to document your module, but don't know what format to use.

### Solution

Embed your documentation in the your module file using pod format.

### Discussion

Pod stands for plain old documentation. It's documentation embedded in your program using a very simple markup format. Programmers are notorious for writing the code first and the documentation never, so pod was designed to make writing documentation so easy that anyone can and will do so. Sometimes this even works.

When Perl is parsing your source code, a line starting with an equal sign (where a new statement is expected) says to ignore all text until it finds a line beginning with `=cut`, after which it will start parsing code again. This lets you mix code and documentation throughout your Perl program or module file. Since it's mostly plain text, type in your documentation as literal text, or nearly so. The translators try to be clever and make output-specific decisions so the programmer doesn't have to specifically format variable names, function calls, etc.

Along with Perl are shipped several translators that filter generic pod format into specific output styles. These include pod2man to change your pods into troff for use with the man program or for phototypesetting and printing; pod2html for creating web pages (which works even on non-Unix systems); and pod2text for plain ASCII. Other translators, like pod2ipf, pod2fm, pod2texi, pod2latex, and pod2ps, may also be available or can be found on CPAN.

Many books are written using proprietary word processors with limited scripting capabilities. Not this one! It was written in pod format using common text editors (vi for Tom, emacs for Nat) before being translated into troff for printing during technical review using a special translator written by Larry called pod2ora. The final book was produced by converting the pod source files to FrameMaker.

Although formally documented in perlpod (1), pod is probably easiest to learn by reading existing module files. If you started making your module using h2xs, then you already have the sample pods right there. The Makefile knows to convert these into man format and install those manpages so others can read them. Alternatively, the perldoc program can translate pods on the fly using pod2text.

Indented paragraphs will be left verbatim. Other paragraphs will be reformatted to fit the page. Only two kinds of markups are used in pod: paragraphs beginning with an equal sign and one or more words, and interior sequences starting with a single letter followed by text enclosed in angle brackets. Paragraph tags are for headers, list enumeration, and per-translator escapes. Angle bracket sequences are mainly used for font changes, such as selecting bold, italic, or constant-width fonts. Here's an example of an `=head2` pod directive and various bracket escapes for font changes:

    =head2 Discussion

    If we had a I<.h> file with function prototype declarations, we
    could include that, but since we're writing this one from scratch,
    we'll use the B<-c> flag to omit building code to translate any
    C<#define> symbols. The B<-n> flag says to create a module directory
    named I<FineTime/>, which will have the following files.

The `=for` escape introduces specific code that is only for a particular output filter. This book, for example, written mostly in pod, includes calls to the standard troff tools eqn, tbl, and pic. Here's an example of embedded eqn. Only translators that produce troff will heed this paragraph.

    =for troff
    .EQ
    log sub n (x) = { {log sub e (x)} over {log sub e (n)} }
    .EN

Pod can also create multiline comments. In C, the sequence `/*` `....` `*/` can comment out many lines of text all at once - there's no need to put a marker on each line. Since Perl ignores pod directives, use these for block commenting. The trick is to find a directive that the pod filters ignore. You could specify that a block is "for later" or "for nobody":

    =for later
    next if 1 .. ?^$?;
    s/^(.)/>$1/;
    s/(.{73})........*/$1<SNIP>/;

    =cut back to perl

or you could use a `=begin` and `=end` pair:

    =begin comment

    if (!open(FILE, $file)) {
        unless ($opt_q) {
            warn "$me: $file: $!\n";
            $Errors++;
        }
        next FILE;
    }

    $total = 0;
    $matches = 0;

    =end comment

### See Also

The section on "PODs: Embedded Documentation" in perlsyn (1), as well as perlpod (1), pod2man (1), pod2html (1), and pod2text (1)

12.15. Using h2xs to Make a Module with C Code |  | 12.17. Building and Installing a CPAN Module