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

2011944

use warnings;

39

361

39

1104

4

39

165

use strict;

39

59

39

652

5

6

39

13974

use HTML::Lint::Error;

39

86

39

1496

7

39

13876

use HTML::Lint::Parser ();

39

100

39

731

8

9

39

207

use HTML::Entities ();

39

56

39

22987

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.30

18

19

=cut

20

21

our $VERSION = '2.30';

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

26513

my $class = shift;

87

43

109

my %args = @_;

88

89

43

182

my $self = {

90

_errors => [],

91

_types => [],

92

};

93

43

115

bless $self, $class;

94

95

43

159

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

96

2

6

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

1

3

97

2

2

delete $args{only_types};

98

}

99

43

142

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

43

118

return $self;

}

=head2 $lint->parser()

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

=cut

sub parser {

902

925

my $self = shift;

902

1401

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

47

428

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

91

223

47

293

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

}

902

2915

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

2389

my $self = shift;

668

894

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

668

912

$self->{_parse_called} = 1;

668

999

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

3

$self->{_parse_called} = 1;

1

4

$self->eof;

1

32

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

165

my $self = shift;

43

76

my $rc;

43

134

my $parser = $self->parser;

43

176

if ( $parser ) {

43

295

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

43

105

delete $self->{_parser};

43

101

$self->{_eof_called} = 1;

}

43

1061

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

208

my $self = shift;

46

221

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

1

3

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

}

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

3

7

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

}

46

108

if ( wantarray ) {

38

61

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

38

137

}

else {

8

10

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

8

26

}

}

=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

10

$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

7

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

137

my $self = shift;

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

95

201

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

95

142

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

95

190

95

270

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

87

112

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

87

165

}

95

240

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

13258

my $self = shift;

36

65

my $file = shift;

36

113

delete $self->{_parser};

36

67

delete $self->{_parse_called};

36

57

delete $self->{_eof_called};

36

98

$self->{_file} = $file;

36

80

$self->{_line} = 0;

36

63

$self->{_column} = 0;

36

75

$self->{_first_seen} = {};

36

81

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;