NAME

Tags::HTML - Tags helper abstract class.

SYNOPSIS

            

              
              
use Tags::HTML;
my $obj = Tags::HTML->new(%params);
$obj->cleanup(@params);
my $css_src_ar = $obj->css_src($css_link_ar);
$obj->init(@params);
my $script_js_ar = $obj->script_js($js_code_ar);
my $script_js_src_ar = $obj->script_js_src($js_link_ar);
$obj->prepare(@params);
$obj->process;
$obj->process_css;
            
          

METHODS

new

            

              
              
my $obj = Tags::HTML->new(%params);
            
          

Constructor.

Returns instance of class.

• css

  'CSS::Struct::Output' object for "process_css" processing.

  Default value is undef.

• no_css

  No CSS support flag. If this flag is set to 1, "process_css" don't process CSS style.

  Default value is 0.

• tags

  'Tags::Output' object for "process" processing.

  Default value is undef.

cleanup

            

              
              
$obj->cleanup(@params);
            
          

Process cleanup after page run.

Returns undef.

css_src

            

              
              
my $css_src_ar = $obj->css_src($css_link_ar);
            
          

Add CSS link to object.

$css_link_ar is reference to array of hashes with CSS information. CSS information is reference to hash with 'media' and 'link' keys.

Returns actual reference to array with CSS link info.

init

            

              
              
$obj->init(@params);
            
          

Process initialization in page run. It's useful in e.g. Plack::App::Tags::HTML.

Returns undef.

script_js

            

              
              
my $script_js_ar = $obj->script_js($js_code_ar);
            
          

Set/Get Javascript code array to object.

Returns reference to array with strings.

script_js_src

            

              
              
my $script_js_src_ar = $obj->script_js_src($js_link_ar);
            
          

Set/Get Javascript script link array to object.

Returns reference to array with strings.

prepare

            

              
              
$obj->prepare(@params);
            
          

Process initialization before page run. It's useful in e.g. Plack::App::Tags::HTML.

Returns undef.

process

            

              
              
$obj->process;
            
          

Process Tags structure.

Returns undef.

process_css

            

              
              
$obj->process_css;
            
          

Process CSS::Struct structure.

Returns undef.

process_js

            

              
              
$obj->process_js;
            
          

Process structure.

Returns undef.

ERRORS

            

              
              
new():
        From Class::Utils::set_params():
                Unknown parameter '%s'.
        Parameter 'css' must be a 'CSS::Struct::Output::*' class.
        Parameter 'tags' must be a 'Tags::Output::*' class.
process():
        Need to be implemented in inherited class in _process() method.
        Parameter 'tags' isn't defined.
process_css():
        Need to be implemented in inherited class in _process_css() method.
        Parameter 'css' isn't defined.
            
          

EXAMPLE1

            

              
              
use strict;
use warnings;
package Foo;
use base qw(Tags::HTML);
sub new {
        my ($class, @params) = @_;
        # No CSS support.
        push @params, 'no_css', 1;
        my $self = $class->SUPER::new(@params);
        # Object.
        return $self;
}
sub _cleanup {
        my $self = shift;
        delete $self->{'_dynamic_data'};
        delete $self->{'_static_data'};
        return;
}
sub _init {
        my ($self, @variables) = @_;
        $self->{'_dynamic_data'} = \@variables;
        return;
}
sub _prepare {
        my ($self, @variables) = @_;
        $self->{'_static_data'} = \@variables;
        return;
}
sub _process {
        my $self = shift;
        $self->{'tags'}->put(
                ['b', 'div'],
        );
        foreach my $variable (@{$self->{'_static_data'}}) {
                $self->{'tags'}->put(
                        ['b', 'div'],
                        ['a', 'class', 'static'],
                        ['d', $variable],
                        ['e', 'div'],
                );
        }
        foreach my $variable (@{$self->{'_dynamic_data'}}) {
                $self->{'tags'}->put(
                        ['b', 'div'],
                        ['a', 'class', 'dynamic'],
                        ['d', $variable],
                        ['e', 'div'],
                );
        }
        $self->{'tags'}->put(
                ['e', 'div'],
        );
        return;
}
package main;
use Tags::Output::Indent;
# Object.
my $tags = Tags::Output::Indent->new;
my $obj = Foo->new(
        'tags' => $tags,
);
# Init static data.
$obj->prepare('foo', 'bar');
# Init dynamic data.
$obj->init('baz', 'bax');
# Process.
$obj->process;
# Print out.
print "HTML\n";
print $tags->flush."\n";
# Output:
# HTML
# <div>
#   <div class="static">
#     foo
#   </div>
#   <div class="static">
#     bar
#   </div>
#   <div class="dynamic">
#     baz
#   </div>
#   <div class="dynamic">
#     bax
#   </div>
# </div>
            
          

EXAMPLE2

            

              
              
use strict;
use warnings;
package Foo;
use base qw(Tags::HTML);
sub _process {
        my ($self, $value) = @_;
        $self->{'tags'}->put(
                ['b', 'div'],
                ['d', $value],
                ['e', 'div'],
        );
        return;
}
sub _process_css {
        my ($self, $color) = @_;
        $self->{'css'}->put(
                ['s', 'div'],
                ['d', 'background-color', $color],
                ['e'],
        );
        return;
}
package main;
use CSS::Struct::Output::Indent;
use Tags::Output::Indent;
# Object.
my $css = CSS::Struct::Output::Indent->new;
my $tags = Tags::Output::Indent->new;
my $obj = Foo->new(
        'css' => $css,
        'tags' => $tags,
);
# Process indicator.
$obj->process_css('red');
$obj->process('value');
# Print out.
print "CSS\n";
print $css->flush."\n\n";
print "HTML\n";
print $tags->flush."\n";
# Output:
# CSS
# div {
#       background-color: red;
# }
#
# HTML
# <div>
#   value
# </div>
            
          

DEPENDENCIES

Class::Utils, Error::Pure, Scalar::Util.

SEE ALSO

Plack::App::Tags::HTML

Plack application for Tags::HTML objects.

Plack::Component::Tags::HTML

Plack component for Tags with HTML output.

REPOSITORY

https://github.com/michal-josef-spacek/Tags-HTML

AUTHOR

Michal Josef Špaček mailto:skim@cpan.org

http://skim.cz

LICENSE AND COPYRIGHT

© 2021-2024 Michal Josef Špaček

BSD 2-Clause License

VERSION

0.10

cpanm Tags::HTML

perl -MCPAN -e shell
install Tags::HTML