Dean Arnold > PPI-HTML-CodeFolder > PPI::HTML::CodeFolder

Download:
PPI-HTML-CodeFolder-1.01.tar.gz

Dependencies

Annotate this POD

View/Report Bugs
Module Version: 1.01   Source  

NAME ^

PPI::HTML::CodeFolder - PPI::HTML Subclass providing code folding and compression

SYNOPSIS ^

    use strict;
    use File::Slurp ();
    use PPI;
    use PPI::HTML::CodeFolder;
    use CSS::Tiny;
    #
    # Get the file
    #
    my $file = shift @ARGV;
    $file    or die "File '$file' not provided";
    -f $file or die "File '$file' does not exist";
    #
    # Determine the output file
    #
    my $output = shift(@ARGV) || $file . '.html';
    my $foldjs = $output;
    $foldjs=~s/\.html/\.js/;
    my $foldcss = $output;
    $foldcss=~s/\.html/\.css/;
    #
    #    PPI the file
    #
    my $Document = PPI::Document->new( $file )
        or die "File '$file' could not be loaded as a document";
    #
    #    define our classname abbreviations
    #
    my %classabvs = qw(
    arrayindex ai
    backtick bt
    cast cs
    comment ct
    core co
    data dt
    double db
    end en
    heredoc hd
    heredoc_content hc
    heredoc_terminator ht
    interpolate ip
    keyword kw
    label lb
    line_number ln
    literal ll
    magic mg
    match mt
    number nm
    operator op
    pod pd
    pragma pg
    prototype pt
    readline rl
    regex re
    regexp re
    separator sp
    single sg
    structure st
    substitute su
    symbol sy
    transliterate tl
    word wd
    words wd
    );
    #
    #    define colors for the full classnames
    #
    my %tagcolors = (
    cast => '#339999',
    comment => '#008080',
    core => '#FF0000',
    double => '#999999',
    heredoc_content => '#FF0000',
    interpolate => '#999999',
    keyword => '#0000FF',
    line_number => '#666666',
    literal => '#999999',
    magic => '#0099FF',
    match => '#9900FF',
    number => '#990000',
    operator => '#DD7700',
    pod => '#008080',
    pragma => '#990000',
    regex => '#9900FF',
    single => '#999999',
    substitute => '#9900FF',
    transliterate => '#9900FF',
    word => '#999999',
    );
    #
    # Create the PPI::HTML::CodeFolder object
    #
    my $html = PPI::HTML::CodeFolder->new(
        line_numbers => 1,
        page         => 1,
        colors       => \%tagcolors,
        fold          => {
            POD           => 1,
            Comments      => 1,
            Heredocs      => 1,
            Imports       => 1,
            Abbreviate    => \%tagabvs,
            Javascript    => $jspath,
            Stylesheet    => $csspath,
            Expandable    => 1,
            },
        )
        or die "Failed to create HTML syntax highlighter";
    #
    #    collect stylesheet and javascript; we'll serve those
    #    separately
    #
    File::Slurp::write_file( $jspath, $html->foldJavascript());
    File::Slurp::write_file( $csspath, $html->foldCSS());
    #
    #   better still, just write them out
    #
    $html->writeJavascript($jspath) or die $@;
    $html->writeCSS($csspath) or die $@;
    #
    # Process the file
    #
    my $content = $html->html( $Document, $output )
        or die "Failed to generate HTML";

    File::Slurp::write_file( $output, $content );
    #
    #   write out a TOC
    #
    $html->writeTOC('toc.html') or die $@;

DESCRIPTION ^

A subclass of PPI::HTML that compresses the generated output by

The amount of compression that can be achieved varies signficantly, depending on the size and content of the source code. Gregarious modules with lots of commentary and POD can be significantly reduced. E.g., some simple benchmarks using the perl5b.pl source (on WinXP, Perl 5.8.6):

                 Original Source:    323,204
                PPI::HTML Output:  1,008,471
    PPI::HTML::CodeFolder Output:    608,118
           (w/ expandable folds)    

As always, YMMV.

Samples

Folded version of CodeFolder.pm

METHODS ^

$ppicf = PPI::HTML::CodeFolder->new( %args )

Same as the PPI::HTML constructor, with the addition of a fold parameter, which specifies a hashref of folding properties. If not specified, a default folding is applied (see individual fold properties below for default behavior). In addition, the PPI::HTML page property is always enabled.

NOTE that using the css parameter is strongly discouraged, as the folding alignment and tooltips are very sensitive to stylesheet changes. Instead, use the fold Stylesheet option (see below) to export the CSS to an external file, and directly edit it.

Folding Properties

Abbreviate => \%abbreviations | $boolean

Specifies a mapping of standard PPI::HTML class names to an alternate (presumably abbreviated) version. If a 'true' scalar is specified, enables abbreviation using the default mapping; if a 'false' scalar is specified, disables abbreviation. Default is to abbreviate.

The default abbreviation map is

    arrayindex         => ai
    backtick           => bt
    cast               => cs
    comment            => ct
    core               => co
    data               => dt
    double             => db
    end                => en
    heredoc            => hd
    heredoc_content    => hc
    heredoc_terminator => ht
    interpolate        => ip
    keyword            => kw
    label              => lb
    line_number        => ln
    literal            => ll
    magic              => mg
    match              => mt
    number             => nm
    operator           => op
    pod                => pd
    pragma             => pg
    prototype          => pt
    readline           => rl
    regex              => re
    regexp             => re
    separator          => sp
    single             => sg
    structure          => st
    substitute         => su
    symbol             => sy
    transliterate      => tl
    word               => wd
    words              => wd

Abbreviation helps compression due to the large number of <span> tags with class specifications in the output.

NOTE: any colormap provided to the constructor (via the color|colour parameter) must use the full classname, not the abbreviated name.

Comments => $boolean

If a true value, comment lines are folded. Default is to include comment lines.

Expandable => $boolean

If a true value, a hyperlink is provided in the margin for each folded source section which unfolds the source in place when clicked; once unfolded, the section can be refolded by clicking the hyperlinks next to the foldable source. Default is false (i.e., folded text is simply discarded).

Heredocs => $boolean

If a true value, embedded heredoc content is folded. Default is false.

Imports => $boolean

If a true value, 'use' and 'require' statements are folded. All statements which begin with 'use', including various pragmas, will be folded. Default is false.

Javascript => $filename

Causes the foldtip javascript to be linked by referencing the specified $filename, rather than embedded in the output HTML. Default is embedded; ignored if Expandable is false. Note that this does not write the specified file, but only uses the filename in the generated <script> tag.

MinFoldLines => $number

Specifies the minimum number of consecutive foldable lines (of any type) required to actually apply folding. Default is 4. E.g., a value of 4 means that 3 consecutive comment lines, followed by valid statement, will not be folded.

POD => $boolean

If a true value, POD lines are folded. Default is to include POD lines.

Stylesheet => $filename

Causes color and foldtip CSS to be linked by referencing the specified $filename, rather than embedded in the output HTML. Default is embedded. Note that this does not write the specified file, but only uses the filename in the generated <link> tag.

$html = $ppicf->html( $src [, $output [, $script ] ] )

Generate the code folded HTML output from $src, using the properties previously specified for $ppicf.

Anchors are added to both package and method declarations which may be used via hyperlinks (e.g., from a table of contents document) to scroll the declaration into view within a browser.

html() may be repeatedly called for different sources in order to accumulate a cross reference containing information for all the documents (e.g., to accumulate a single table of contents for a multi-module project).

Parameters are

$src (required)

Either a PPI::Document object, a scalar reference to the source as a string, or the filename of the source.

$output (optional)

The full pathname to the resulting HTML output, which is used for maintaining a cross reference to package and method declarations within the file. If not specified, and $src is a filename, defaults to "$src.html". Note the html() does not write out the document to $output, but only uses it for the cross reference (and any table of contents generated from it).

$script (optional)

A name used if $src is a script file (rather than a module definition). Script files might not include any explicit package or method declaration which would be mapped into the cross reference. By specifying this parameter, an entry for the script is forced into the cross reference, so that any "main" package methods within the script will be assigned to this script name. If not specified, and $src is not a filename, any methods outside of package declarations are assigned to the "main" package.

$javascript = $ppicf->foldJavascript()

Returns the Javascript required for foldtips as a string.

$css = $ppicf->foldCSS()

Returns the CSS required for the generated HTML as a string.

$rc = $ppicf->writeJavascript($path)

Writes out the Javascript required for foldtips to the file specified by $path. Returns 1 on success, or undef on failure, with an error message in $@.

$rc = $ppicf->writeCSS($path)

Writes out the CSS required for document to the file specified by $path. Returns 1 on success, or undef on failure, with an error message in $@.

$xref = $ppicf->getCrossReference()

For the prior processed source, returns the hashref mapping the package names within the source to a hashref of

        'URL' => <URL to anchored package definition statement>,
        'Methods' => {
                <method-name> => <URL to anchored method definition statement>,
        }

Note that the package mapping is cumulative, i.e., it is updated each time html() is called on the same PPI::HTML::CodeFolder instance. Also note that script files (i.e., "main" application files) use the script filename as the package name for any "main" package declarations or methods.

$toc = $ppicf->getTOC( $path [, Order => \@packages ] )

Return a table of contents HTML document derived from the current cross reference. Provides hyperlinks to declared packages and their methods in a form suitable for either embedding in a frame container, or for processing into a tree widget via HTML::ListToTree. $path specifies the pathname to which the TOC will be written, which is only used for properly rendering the hyperlinks. Order specifies an arrayref of package (or script file) names; the position of the names in the list determines the position of the package/script hyperlinks in the TOC document. Any packages/scripts not specified in Order list will be sorted alphabetically and appended after the Ordered items (if any).

Note that method hyperlinks in the TOC are ordered alphabetically under their parent package/script link.

$ppicf->writeTOC( $path [, Order => \@packages ] )

Calls getTOC() and writes the output to the specified $path.

$container = $ppicf->getFrameContainer( $title [, $home ] )

Renders an HTML frame container document to contain both a TOC and the rendered source code. $title is the title string for the document. $home specified the URL of a document initially loaded into the main frame (default none).

$ppicf->writeFrameContainer( $path, $title [, $home ] )

Calls getFrameContainer( $title [, $home ] ) and writes the resulting document to $path/index.html.

NOTES ^

SEE ALSO ^

PPI

PPI::HTML

TO DO ^

AUTHOR, COPYRIGHT, & LICENSE ^

Copyright(C) 2007, Dean Arnold, Presicient Corp., USA. All rights reserved.

Permission is granted to use this software under the terms of the Perl Artistic License.

syntax highlighting: