Free html rulez d00d software for linux

HTML::Scrubber is a Perl extension for scrubbing/sanitizing html.

SYNOPSIS

#!/usr/bin/perl -w
use HTML::Scrubber;
use strict;
#
my $html = q[

---

a => link
br =>

b => bold
u => UNDERLINE
];
#
my $scrubber = HTML::Scrubber->new( allow => [ qw[ p b i u hr br ] ] ); #
#
print $scrubber->scrub($html); #
#
$scrubber->deny( qw[ p b i u hr br ] ); #
#
print $scrubber->scrub($html); #
#

If you wanna "scrub" or "sanitize" html input in a reliable an flexible fashion, then this module is for you.

I wasnt satisfied with HTML::Sanitizer because it is based on HTML::TreeBuilder, so I thought Id write something similar that works directly with HTML::Parser.

HTML::Clean module cleans up HTML code for web browsers, not humans.

SYNOPSIS

use HTML::Clean;
$h = new HTML::Clean($filename); # or..
$h = new HTML::Clean($htmlcode);

$h->compat();
$h->strip();
$data = $h->data();
print $$data;

The HTML::Clean module encapsulates a number of common techniques for minimizing the size of HTML files. You can typically save between 10% and 50% of the size of a HTML file using these methods. It provides the following features:

Remove unneeded whitespace (begining of line, etc)
Remove unneeded META elements.
Remove HTML comments (except for styles, javascript and SSI)
Replace tags with equivilant shorter tags (< strong > --> < b >)
etc.

The entire proces is configurable, so you can pick and choose what you want to clean.

HTML::BBReverse is a Perl module to convert HTML to BBCode and back.

SYNOPSIS

use HTML::BBReverse

my $bbr = HTML::BBReverse->new();

# convert BBCode into HTML
my $html = $bbr->parse($bbcode);
# convert generated HTML back to BBCode
my $bbcode = $bbr->reverse($html);

HTML::BBReverse is a pure perl module for converting BBCode to HTML and is able to convert the generated HTML back to BBCode.

And why would you want to reverse the generated HTML? Well, when you have a nice dynamic website where you and/or visitors can post messages, and in those messages BBCode is used for markup. In normal cases, your website has a lot more pageviews than edits, and saving all those messages as HTML will be a lot faster than saving them as the original BBCode and parsing them to HTML for every visit.

So now all BBCode gets converted to HTML before it will be saved, but what if you want to edit a message? Just reverse the generated HTML back to BBCode, edit your message, and save it as HTML again.

HTML::Mail is a Perl extension for sending emails with embedded HTML and media.

SYNOPSIS

use HTML::Mail;

### initialisation
my $html_mail = HTML::Mail->new(
HTML => http://www.cpan.org,
Text => This is the text representation of the webpage http://www.cpan.org,
From => me@myhost.org,
To => you@yourhost.org,
Subject => CPAN webpage);

### Send the email ("inherited" from MIME::Lite)
$html_mail->send();

#### Remove text representation
$html_mail->set_Text();

### Rebuild the message and send
$html_mail->build->send;

### Serialise to file for later reuse
$html_mail->dump_file(/tmp/cpan_mail.data);

### Restore from file
my $restored = HTML::Mail->restore_file(/tmp/cpan_mail.data);

HTML::Mail is supposed to help with the task of sending emails with HTML and images (or other media) embedded or externally linked. It uses MIME::Lite for all MIME related jobs, HTML::Parser to find related files and change the URIs and LWP::UserAgent to retrieve the related files.

Email can be multipart/alternative if both HTML and Text content exist and multipart/related if there is only HTML content.

If all you want is to send text-only email, you probably wont find this module useful at all, or at best a huge overkill.

HTML::Sanitizer is a HTML Sanitizer.

SYNOPSIS

my $safe = new HTML::Sanitizer;

$safe->permit_only(
qw/ strong em /,
a => {
href => qr/^(?:http|ftp):/,
title => 1,
},
img => {
src => qr/^(?:http|ftp):/,
alt => 1,
},
b => HTML::Element->new(strong),
);

$sanitized = $safe->filter_html_fragment($evil_html);

# or

my $tree = HTML::TreeBuilder->new->parse_file($filename);
$safe->sanitize_tree($tree);

ABSTRACT

This module acts as a filter for HTML. It is not a validator, though it might be possible to write a validator-like tool with it. Its intended to strip out unwanted HTML elements and attributes and leave you with non-dangerous HTML code that you should be able to trust.

HTML::QuickTable is a Perl module to quickly create fairly complex HTML tables.

SYNOPSIS

use HTML::QuickTable;

my $qt = HTML::QuickTable->new(
table_width => 95%, # opt method 1
td => {bgcolor => gray}, # opt method 2
font_face => arial, # set font
font => {face => arial}, # same thing
labels => 1, # make top

HTML::CGIChecker is a Perl module to detect dangerous HTML code.

SYNOPSIS

use HTML::CGIChecker;

$feedback =
< TABLE CELLPADDING="2" >< TR >< TD >One column< /TD >< /TR >< /TABLE >< BR >
" Arrays & variables "

Dough > Hi, how are you ?

And now some Perl code:
< PRE >
print "< HTML >< BODY >< /BODY >< /HTML >";
< /PRE >
;

# create the $checker object

$checker = new HTML::CGIChecker (
mode => allow,
allowclasses => [ qw( tables images ) ],
allowtags => [ qw ( B I A U STRONG BR HR ) ],
jscript => 0,
html => 0,
pre => 1,
debug => 0,
err_tag => Tag {tag} is not allowed in {element}.
);

# Now you can use it to check any string using its checkHTML()
# method. It "remembers" its configuration, so you can reuse it.

($checked_feedback, $Warnings) =
$checker->checkHTML ($feedback);

# Process the results ...

if ($checked_feedback) {
# save $checked_feedback to the database ....
}
else {
# print the warnings ...
print join ("n", @{$Warnings});
}

The example above produces no warning messages and returns $feedback checked and properly HTML escaped. The only HTML "error" - the unescaped ">" bracket on the fourth line - is autocorrected. One warning message was overriden by a customized version. Potential warnings would not be HTML formatted and HTML safe, because the html parameter is not true.

HTML::Parser is a HTML parser class. Objects of the HTML::Parser class will recognize markup and separate it from plain text (alias data content) in HTML documents. As different kinds of markup and text are recognized, the corresponding event handlers are invoked.
HTML::Parser is not a generic SGML parser.

We have tried to make it able to deal with the HTML that is actually "out there", and it normally parses as closely as possible to the way the popular web browsers do it instead of strictly following one of the many HTML specifications from W3C. Where there is disagreement, there is often an option that you can enable to get the official behaviour.

The document to be parsed may be supplied in arbitrary chunks. This makes on-the-fly parsing as documents are received from the network possible.
If event driven parsing does not feel right for your application, you might want to use HTML::PullParser. This is an HTML::Parser subclass that allows a more conventional program structure.

SYNOPSIS:

use HTML::Parser ();

# Create parser object
$p = HTML::Parser->new( api_version => 3,
start_h => [&start, "tagname, attr"],
end_h => [&end, "tagname"],
marked_sections => 1,
);

# Parse document text chunk by chunk
$p->parse($chunk1);
$p->parse($chunk2);
#...
$p->eof; # signal end of document

# Parse directly from file
$p->parse_file("foo.html");
# or
open(my $fh, "<<less