NAME

HTML::Make - A flexible HTML generator

SYNOPSIS

# Make a table.
use HTML::Make;
my $table = HTML::Make->new ('table');
# Can add elements as text
$table->add_text ('<tr><th>Item<th>Cost');
my %items = (
    compressor => 12800,
    heater => 'free',
    camera => 1080,
);
for my $k (sort keys %items) {
    # Add an element using "push". The return value is the new element.
    my $tr = $table->push ('tr');
    # Can add element to $tr using "push"
    $tr->push ('td', text => $k);
    # Can also make a new element then "push" it.
    my $td = HTML::Make->new ('td', text => $items{$k},
                              attr => {style => 'padding:1em'});
    $tr->push ($td);
}
# Get the output
print $table->text ();

produces output

<table>
<tr><th>Item<th>Cost<tr>
<td>camera</td>
<td style="padding:1em">1080</td>
</tr>
<tr>
<td>compressor</td>
<td style="padding:1em">12800</td>
</tr>
<tr>
<td>heater</td>
<td style="padding:1em">free</td>
</tr>
</table>

As HTML, this looks like

(This example is included as synopsis.pl in the distribution.)

VERSION

This documents HTML::Make version 0.08 corresponding to git commit cc23bdd13c59915f224ff99c85faa582e259cb86 released on Fri Jan 6 08:52:42 2017 +0900.

DESCRIPTION

HTML::Make is an HTML generator. It generates HTML fragments, such as HTML lists or tables, rather than complete HTML pages.

METHODS

new

my $element = HTML::Make->new ('li');

Make a new HTML element of the specified type.

To add attributes to the element, use

my $element = HTML::Make->new ('li', attr => {class => 'biglist'});

To add text,

my $element = HTML::Make->new ('li', text => "White punks on dope");

Both attributes and text may be added:

my $element = HTML::Make->new ('li', attr => {id => 'ok'}, text => 'OK');

HTML::Make checks the element against a list of known HTML tags from "HTML::Valid::Tagset", and warns if the first argument is not on this list. To switch off this behaviour and allow arbitrary tags, use the nocheck option:

use HTML::Make;
my $freaky = HTML::Make->new ('freaky', nocheck => 1);
$freaky->push ('franky', nocheck => 1, text => 'Visible man');
print $freaky->text ();

produces output

<freaky><franky>Visible man</franky>
</freaky>

As HTML, this looks like

(This example is included as nocheck.pl in the distribution.)

add_attr

$obj->add_attr (class => 'buggles');

Add attributes to $obj. The following adds a class "beano" to the "li" element:

use HTML::Make;
my $obj = HTML::Make->new ('li');
$obj->add_attr (class => 'beano');
print $obj->text ();

produces output

<li class="beano"></li>

As HTML, this looks like

(This example is included as li-class-beano.pl in the distribution.)

This issues a warning of the form "Overwriting attribute 'class' for 'p'" if the object already contains an attribute of the specified type.

use HTML::Make;
my $p = HTML::Make->new ('p', attr => {class => 'big'});
$p->add_attr (class => 'small');

produces output

Overwriting attribute 'class' for 'p' tag at /usr/home/ben/projects/html-make/examples/p-double-class.pl line 6.

As HTML, this looks like

(This example is included as p-double-class.pl in the distribution.)

This also issues a warning if the attribute is not valid for the tag, according to "tag_attr_ok" in HTML::Valid::Tagset. This is restricted to what is valid in HTML5.

add_text

$element->add_text ('buggles');

Add text to $element. For example,

my $element = HTML::Make->new ('p');
$element->add_text ('peanuts');
print $element->text ();
# <p>peanuts</p>

The text may contain HTML elements:

my $element = HTML::Make->new ('p');
$element->add_text ('peanuts <i>eggs</i>');
print $element->text ();
# <p>peanuts <i>eggs</i></p>

The return value is the added text object.

push

my $child = $element->push ('tag');

Add child element of type <tag> to $element and return the result as a new HTML::Make object. For example,

use utf8;
use HTML::Make;
my $table = HTML::Make->new ('table');
my $row = $table->push ('tr');
my $cell = $row->push ('td', text => 'Cell');
print $table->text ();

produces output

<table>
<tr>
<td>Cell</td>
</tr>
</table>

As HTML, this looks like

(This example is included as table.pl in the distribution.)

An object created with HTML::Make may also be pushed:

use utf8;
use HTML::Make;
my @colours = (
    daidai => 0xEE7800,
    murasaki => 0x884898,
    kimidori => 0xB9C42F,
    kogecha => 0x6A4D32,
    uguisuiro => 0x838B0D,
);
my $ul = HTML::Make->new ('ul');
while (@colours) {
    my $colour = shift @colours;
    my $rgb = shift @colours;
    # Here we make a new element and then push it into $ul, rather
    # than using the return value of $ul->push ().
    my $li = HTML::Make->new (
        'li', text => $colour,
        attr => {
            style => sprintf ("background: #%06X", $rgb),
        });
    $ul->push ($li);
}
print $ul->text ();

produces output

<ul>
<li style="background: #EE7800">daidai</li>
<li style="background: #884898">murasaki</li>
<li style="background: #B9C42F">kimidori</li>
<li style="background: #6A4D32">kogecha</li>
<li style="background: #838B0D">uguisuiro</li>
</ul>

As HTML, this looks like

• daidai
• murasaki
• kimidori
• kogecha
• uguisuiro

(This example is included as push-new.pl in the distribution.)

See also Make a list of colours with HTML::Make.

It's also possible to add all of the same arguments as "new", for example

$element->push ('a', attr => {href => 'http://www.example.org/'});

This warns if you add some types of elements to possibly inappropriate parent elements. For example if you add an <li> tag to a <tr> it reacts like this:

use HTML::Make;
my $tr = HTML::Make->new ('tr');
$tr->push ('li');

produces output

Pushing non-table element <li> to a table row at /usr/home/ben/projects/html-make/examples/push-li-to-tr.pl line 6.

As HTML, this looks like

my $tag = $obj->opening_tag ();

$element->text ();

my @elements = $obj->multiply ('li', \@contents);

use HTML::Make;
my $ol = HTML::Make->new ('ol');
$ol->multiply ('li', ['one', 'two', 'three']);
print $ol->text ();

<ol>
<li>one</li>
<li>two</li>
<li>three</li>
</ol>

use utf8;
use JSON::Parse 'parse_json';
use HTML::Make;
my $json =<<EOF;
{"words":[{"j_pron_only":"パイプ","word":"pipe"},{"word":"cutting","j_pron_only":"カティング"},{"word":"implement","j_pron_only":"インプリムント"}]}
EOF
my $p = parse_json ($json);
my $html = json_to_html ($p);
print $html->text ();
exit;

sub json_to_html
{
    my ($input) = @_;
    my $element;
    if (ref $input eq 'ARRAY') {
        $element = HTML::Make->new ('ol');
        for my $k (@$input) {
            my $li = $element->push ('li');
            $li->push (json_to_html ($k));
        }
    }
    elsif (ref $input eq 'HASH') {
        $element = HTML::Make->new ('table');
        for my $k (sort keys %$input) {
            my $tr = $element->push ('tr');
            $tr->push ('th', text => $k);
            my $td = $tr->push ('td');
            $td->push (json_to_html ($input->{$k}));
        }
    }
    else {
        $element = HTML::Make->new ('span', text => $input);
    }
    return $element;
}

<table>
<tr>
<th>words</th>
<td><ol>
<li><table>
<tr>
<th>j_pron_only</th>
<td><span>パイプ</span>
</td>
</tr>
<tr>
<th>word</th>
<td><span>pipe</span>
</td>
</tr>
</table>
</li>
<li><table>
<tr>
<th>j_pron_only</th>
<td><span>カティング</span>
</td>
</tr>
<tr>
<th>word</th>
<td><span>cutting</span>
</td>
</tr>
</table>
</li>
<li><table>
<tr>
<th>j_pron_only</th>
<td><span>インプリムント</span>
</td>
</tr>
<tr>
<th>word</th>
<td><span>implement</span>
</td>
</tr>
</table>
</li>
</ol>
</td>
</tr>
</table>