File Coverage

blib/lib/HTML/Lint.pm

Criterion	Covered	Total	%
statement	81	81	100.0
branch	15	16	93.7
condition	3	3	100.0
subroutine	16	16	100.0
pod	10	10	100.0
total	125	126	99.2

line

stmt

bran

cond

sub

pod

time

code

1

package HTML::Lint;

2

3

39

1817661

use warnings;

39

360

39

1017

4

39

163

use strict;

39

49

39

697

5

6

39

12563

use HTML::Lint::Error;

39

76

39

1381

7

39

12512

use HTML::Lint::Parser ();

39

110

39

736

8

9

39

196

use HTML::Entities ();

39

55

39

21204

10

11

=head1 NAME

12

13

HTML::Lint - check for HTML errors in a string or file

14

15

=head1 VERSION

16

17

Version 2.32

18

19

=cut

20

21

our $VERSION = '2.32';

22

23

=head1 SYNOPSIS

24

25

my $lint = HTML::Lint->new;

26

$lint->only_types( HTML::Lint::Error::STRUCTURE );

27

28

# Parse lines of data.

29

$lint->newfile( $filename );

30

while ( my $line = <> ) {

31

$lint->parse( $line );

32

}

33

$lint->eof();

34

35

# Or, parse an entire file at once.

36

$lint->parse_file( $filename );

37

38

# Fetch the errors that the linter found.

39

my $error_count = $lint->errors;

40

41

foreach my $error ( $lint->errors ) {

42

print $error->as_string, "\n";

43

}

44

45

HTML::Lint also comes with a wrapper program called F that handles

46

linting from the command line:

47

48

$ weblint http://www.cnn.com/

49

http://www.cnn.com/ (395:83)

tag has no HEIGHT and WIDTH attributes.

50

http://www.cnn.com/ (395:83)

does not have ALT text defined

51

http://www.cnn.com/ (396:217) Unknown element

52

http://www.cnn.com/ (396:241) with no opening

53

http://www.cnn.com/ (842:7) target attribute in is repeated

54

55

And finally, you can also get L that passes any

56

mod_perl-generated code through HTML::Lint and get it dumped into your

57

Apache F.

58

59

[Mon Jun 3 14:03:31 2002] [warn] /foo.pl (1:45)

with no opening

60

[Mon Jun 3 14:03:31 2002] [warn] /foo.pl (1:49) Unknown element

61

[Mon Jun 3 14:03:31 2002] [warn] /foo.pl (1:56) Unknown attribute "x" for tag

62

63

=cut

64

65

=head1 METHODS

66

67

NOTE: Some of these methods mirror L's methods, but HTML::Lint

68

is not a subclass of HTML::Parser.

69

70

=head2 new()

71

72

Create an HTML::Lint object, which inherits from HTML::Parser.

73

You may pass the types of errors you want to check for in the

74

C parm.

75

76

my $lint = HTML::Lint->new( only_types => HTML::Lint::Error::STRUCTURE );

77

78

If you want more than one, you must pass an arrayref:

79

80

my $lint = HTML::Lint->new(

81

only_types => [HTML::Lint::Error::STRUCTURE, HTML::Lint::Error::FLUFF] );

82

83

=cut

84

85

sub new {

86

43

23668

my $class = shift;

87

43

115

my %args = @_;

88

89

43

174

my $self = {

90

_errors => [],

91

_types => [],

92

};

93

43

110

bless $self, $class;

94

95

43

164

if ( my $only = $args{only_types} ) {

96

2

9

$self->only_types( ref $only eq 'ARRAY' ? @{$only} : $only );

1

4

97

2

4

delete $args{only_types};

98

}

99

43

133

warn "Unknown argument $_\n" for keys %args;

43

116

return $self;

}

=head2 $lint->parser()

Returns the parser object for this object, creating one if necessary.

=cut

sub parser {

902

851

my $self = shift;

902

1358

if ( not $self->{_parser} ) {

47

449

$self->{_parser} = HTML::Lint::Parser->new( sub { $self->gripe( @_ ) } );

91

204

47

293

$self->{_parser}->ignore_elements( qw(script style) );

}

902

2735

return $self->{_parser};

}

=head2 $lint->parse( $text )

=head2 $lint->parse( $code_ref )

Passes in a chunk of HTML to be linted, either as a piece of text,

or a code reference.

See L's C method for details.

=cut

sub parse {

668

2569

my $self = shift;

668

876

my $rc = $self->parser->parse( @_ );

668

833

$self->{_parse_called} = 1;

668

929

return $rc;

}

=head2 $lint->parse_file( $file )

Analyzes HTML directly from a file. The C<$file> argument can be a filename,

an open file handle, or a reference to an open file handle.

See L's C method for details.

=cut

sub parse_file {

1

5

my $self = shift;

1

3

my $rc = $self->parser->parse_file( @_ );

1

2

$self->{_parse_called} = 1;

1

3

$self->eof;

1

31

return $rc;

}

=head2 $lint->eof()

Signals the end of a block of text getting passed in. This must be

called to make sure that all parsing is complete before looking at errors.

Any parameters (and there shouldn't be any) are passed through to

HTML::Parser's eof() method.

=cut

sub eof { ## no critic ( Subroutines::ProhibitBuiltinHomonyms )

43

163

my $self = shift;

43

103

my $rc;

43

120

my $parser = $self->parser;

43

166

if ( $parser ) {

43

265

$rc = $parser->eof(@_);

43

81

delete $self->{_parser};

43

134

$self->{_eof_called} = 1;

}

43

988

return $rc;

}

=head2 $lint->errors()

In list context, C returns all of the errors found in the

parsed text. Each error is an object of the type L.

In scalar context, it returns the number of errors found.

=cut

sub errors {

46

207

my $self = shift;

46

211

if ( !$self->{_parse_called} ) {

1

2

$self->gripe( 'api-parse-not-called' );

}

elsif ( !$self->{_eof_called} ) {

3

10

$self->gripe( 'api-eof-not-called' );

}

46

111

if ( wantarray ) {

38

57

return @{$self->{_errors}};

38

141

}

else {

8

14

return scalar @{$self->{_errors}};

8

24

}

}

=head2 $lint->clear_errors()

Clears the list of errors, in case you want to print and clear, print and clear.

=cut

sub clear_errors {

3

4

my $self = shift;

3

9

$self->{_errors} = [];

3

5

return;

}

=head2 $lint->only_types( $type1[, $type2...] )

Specifies to only want errors of a certain type.

$lint->only_types( HTML::Lint::Error::STRUCTURE );

Calling this without parameters makes the object return all possible

errors.

The error types are C, C and C.

See L for details on these types.

=cut

sub only_types {

5

11

my $self = shift;

5

11

$self->{_types} = [@_];

5

8

return;

}

=head2 $lint->gripe( $errcode, [$key1=>$val1, ...] )

Adds an error message, in the form of an L object,

to the list of error messages for the current object. The file,

line and column are automatically passed to the L

constructor, as well as whatever other key value pairs are passed.

For example:

$lint->gripe( 'attr-repeated', tag => $tag, attr => $attr );

Usually, the user of the object won't call this directly, but just

in case, here you go.

=cut

sub gripe {

95

116

my $self = shift;

my $error = HTML::Lint::Error->new(

95

208

$self->{_file}, $self->parser->{_line}, $self->parser->{_column}, @_ );

95

209

my @keeps = @{$self->{_types}};

95

193

95

275

if ( !@keeps || $error->is_type(@keeps) ) {

87

107

push( @{$self->{_errors}}, $error );

87

174

}

95

209

return;

}

=head2 $lint->newfile( $filename )

Call C whenever you switch to another file in a batch

of linting. Otherwise, the object thinks everything is from the

same file. Note that the list of errors is NOT cleared.

Note that I<$filename> does NOT need to match what's put into C

or C. It can be a description, a URL, or whatever.

You should call C even if you are only validating one file. If

you do not call C then your errors will not have a filename

attached to them.

=cut

sub newfile {

36

10355

my $self = shift;

36

70

my $file = shift;

36

115

delete $self->{_parser};

36

66

delete $self->{_parse_called};

36

63

delete $self->{_eof_called};

36

85

$self->{_file} = $file;

36

73

$self->{_line} = 0;

36

69

$self->{_column} = 0;

36

77

$self->{_first_seen} = {};

36

77

return $self->{_file};

} # newfile

1;

=head1 MODIFYING HTML::LINT'S BEHAVIOR

Sometimes you'll have HTML that for some reason cannot conform to

HTML::Lint's expectations. For those instances, you can use HTML

comments to modify HTML::Lint's behavior.

Say you have an image where for whatever reason you can't get

dimensions for the image. This HTML snippet:

causes this error:

foo.html (14:20)

tag has no HEIGHT and WIDTH attributes

But if for some reason you can't get those dimensions when you build

the page, you can at least stop HTML::Lint complaining about it.

If you want to turn off all HTML::Lint warnings for a block of code, use

And turn them back on with

You don't have to use "on" and "off". For "on", you can use "true"

or "1". For "off", you can use "0" or "false".

For a list of possible errors and their codes, see L,

or run F.

=head1 BUGS, WISHES AND CORRESPONDENCE

All bugs and requests are now being handled through GitHub.

https://github.com/petdance/html-lint/issues

DO NOT send bug reports to http://rt.cpan.org/ or http://code.google.com/

=head1 TODO

=over 4

=item * Check for attributes that require values

=item * s that have no rows.

364
365							=item * Form fields that aren't in a FORM
366
367							=item * DIVs with nothing in them.
368
369							=item * HEIGHT= that have percents in them.
370
371							=item * Check for goofy stuff like:
372
373							Hello Reader - Spanish Level 1 (K-3)
374
375							=back
376
377							=head1 COPYRIGHT & LICENSE
378
379							Copyright 2005-2018 Andy Lester.
380
381							This program is free software; you can redistribute it and/or modify it
382							under the terms of the Artistic License v2.0.
383
384							http://www.opensource.org/licenses/Artistic-2.0
385
386							Please note that these modules are not products of or supported by the
387							employers of the various contributors to the code.
388
389							=head1 AUTHOR
390
391							Andy Lester, andy at petdance.com
392
393							=cut
394
395							1;