To install this module, you can either use cpan (which automates the
process for you) or manually run the following commands:
perl Makefile.PL
make
make test
make install
If you are on a windows box you should use 'nmake' rather than 'make'.
Feel free to email me at yha@cpan.org if you have problems installing this
module or if you have any other comments or questions. Module documentation
follows.
---------------------------------------------------------------------------
NAME
Pod::Clipper - Extract blocks of POD from a text document
SYNOPSIS
use Pod::Clipper;
my $clipper = Pod::Clipper->new({ data => $data });
my $all_blocks = $clipper->all;
foreach (@{$all_blocks}) {
# do something with $_->data
if ($_->is_pod) {
# POD block. do something with the POD data...
# e.g. convert it to HTML
}
else {
# non-POD block (code etc). do something else with it...
# e.g. syntax-highlight it
}
}
DESCRIPTION
This module allows you to divide a document/string into POD and non-POD
blocks of text. This is useful for extracting POD data (or code) from a
"mixed" document, like most perl modules on CPAN.
POD data is identified as per the perlpodspec manpage. Invalid POD is
simply ignored. The only case for this is if a line matched "/\A=cut/"
without a starting POD command (e.g. "=head1, =head2," etc). That line
will be completely ignored. If you want such lines to be included as
part of the non-POD blocks, set "ignore_invalid_pod" to false.
Please note that "Pod::Clipper" doesn't check the POD data itself for
validity. For example, you may have a mismatched bracket in your POD
like "C<<mismatched>". "Pod::Clipper" only cares about the POD commands
that mark the beginning and end of your blocks (i.e. where these blocks
should be *clipped*). It doesn't care about the actual POD data. Hence,
the only case for invalid POD that "Pod::Clipper" can detect is if you
have a dangling "=cut" command (explained in the previous paragraph and
below).
By default, leading and trailing whitespace characters are ignored. To
change this, set "ignore_whitespace" to false. You can also use
"ignore_leading_whitespace" and "ignore_trailing_whitespace" for more
control. See below.
METHODS
new
This is the "Pod::Clipper" constructor. As with many perl modules,
configuration options are passed as a hash reference. The available
options are:
data
The data you want to process into POD and non-POD blocks. This is a
required option.
from_file
If this option is set (to true), "data" is treated as a filename and
your data is pulled from there. If an error occurs (file doesn't
exist etc), an exception will be thrown.
eval { my $c = Pod::Clipper->new({ data => 'Test.pm', from_file => 1 }); };
if ($@) {
# some IO error occurred. the caught error string ($@) is set to
# whatever perl passed in $! after open() failed
}
newline_seq
The *line separator* that should be used. The default newline
sequence used to separate lines is "\n". In most cases this will do
the right thing (perl treats "\n" differently depending on what
platform it is running on -- see binmode(1)). However, sometimes you
may want to use a different newline sequence. For example, you're
running a script on *nix and trying to read a file that was created
on Windows. In that case, set newline_seq to "\r\n" in order to get
the correct results. If you're running perl 5.10.x or newer, you can
use "\R" as your newline sequence and everything should magically
work regardless of where the file was created and what platform perl
is running on.
append_newline
By default, "Pod::Clipper" excludes the last newline character in
each block. For example, if you have the following:
# line 1
# line 2
=pod
test
=cut
"Pod::Clipper" would divide the text above into these two blocks:
# line 1
# line 2 <--- block ends here (no newline)
and
=pod
test
=cut <--- block ends here (no newline)
If you set "append_newline" to true, you would get the following
blocks instead:
# line 1
# line 2
<--- block ends here
and
=pod
test
=cut
<--- block ends here
Please remember that (the last line of) your data may not
necessarily end with a newline character, so setting
"append_newline" to true may tack an extra one to the last block.
ignore_whitespace
Ignore leading and trailing whitespace characters in your data.
Default is true.
ignore_leading_whitespace
Ignore leading whitespace characters in your data. If
"ignore_whitespace" is set (to true) this option will be ignored.
ignore_trailing_whitespace
Ignore trailing whitespace characters in your data. If
"ignore_whitespace" is set (to true) this option will be ignored.
ignore_invalid_pod
Defaults to true which completely ignores "dangling" "=cut" commands
in the data. Setting this option to false causes such lines to be
treated as non-POD text.
Each of the options listed above also have an accessor/mutator method by
the same name. For example:
my $data = $clipper->data; # get
$clipper->data($new_data); # set
rebuild
If you want to resuse the same "Pod::Clipper" object for a different
document/string, make sure to call "rebuild()" after you update your
data and other parameters so that "all(), pod()," and "non_pod()" return
the correct results. For example:
$clipper->data($new_data);
$clipper->ignore_whitespace(0);
$clipper->rebuild; # parse $new_data and build the new blocks
# $clipper->all now reflects the new data
all
This method returns an array reference to all blocks, i.e. the POD and
non-POD ones. The order of these blocks as they appear in the original
data is preserved.
pod
Same as "all()", but returns only the POD blocks.
non_pod
Same as "all()", but returns only the non-POD blocks.
BUGS
There are no known bugs. If you find one, please report it to me at the
email address listed below. Any other suggestions or comments are also
welcome.
AUTHOR
Yousef H. Alhashemi <yha@cpan.org>
COPYRIGHT
This program is free software; you can redistribute it and/or modify it
under the same terms as Perl itself.
The full text of the license can be found in the LICENSE file included
with this module.
SEE ALSO
Pod::Clipper::Block