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

2092717

use warnings;

39

394

39

1236

4

39

183

use strict;

39

65

39

741

5

6

39

14850

use HTML::Lint::Error;

39

89

39

1660

7

39

14918

use HTML::Lint::Parser ();

39

122

39

889

8

9

39

216

use HTML::Entities ();

39

100

39

24350

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.27_03

18

19

=cut

20

21

our $VERSION = '2.27_03';

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

26791

my $class = shift;

87

43

129

my %args = @_;

88

89

43

175

my $self = {

90

_errors => [],

91

_types => [],

92

};

93

43

113

bless $self, $class;

94

95

43

176

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

96

2

10

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

1

3

97

2

3

delete $args{only_types};

98

}

99

43

145

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

43

157

return $self;

}

=head2 $lint->parser()

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

=cut

sub parser {

902

1019

my $self = shift;

902

1482

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

47

470

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

91

245

47

303

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

}

902

3159

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

2632

my $self = shift;

668

936

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

668

993

$self->{_parse_called} = 1;

668

1031

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

6

my $self = shift;

1

3

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

1

3

$self->{_parse_called} = 1;

1

3

$self->eof;

1

24

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

193

my $self = shift;

43

96

my $rc;

43

144

my $parser = $self->parser;

43

181

if ( $parser ) {

43

359

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

43

107

delete $self->{_parser};

43

90

$self->{_eof_called} = 1;

}

43

1089

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

212

my $self = shift;

46

225

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

1

3

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

}

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

3

9

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

}

46

117

if ( wantarray ) {

38

64

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

38

145

}

else {

8

11

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

8

29

}

}

=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

5

my $self = shift;

3

12

$self->{_errors} = [];

3

7

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

10

my $self = shift;

5

13

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

5

10

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

140

my $self = shift;

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

95

226

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

95

170

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

95

205

95

280

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

87

123

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

87

181

}

95

225

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

13049

my $self = shift;

36

78

my $file = shift;

36

111

delete $self->{_parser};

36

71

delete $self->{_parse_called};

36

62

delete $self->{_eof_called};

36

81

$self->{_file} = $file;

36

88

$self->{_line} = 0;

36

81

$self->{_column} = 0;

36

80

$self->{_first_seen} = {};

36

76

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;