test/html-webhacc/cc.cgi

#!/usr/bin/perl
use strict;
use utf8;

use lib qw[/home/httpd/html/www/markup/html/whatpm
           /home/wakaba/work/manakai2/lib];
use CGI::Carp qw[fatalsToBrowser];
use Scalar::Util qw[refaddr];
use Time::HiRes qw/time/;

sub htescape ($) {
  my $s = $_[0];
  $s =~ s/&/&amp;/g;
  $s =~ s/</&lt;/g;
  $s =~ s/>/&gt;/g;
  $s =~ s/"/&quot;/g;
  $s =~ s{([\x00-\x09\x0B-\x1F\x7F-\xA0\x{FEFF}\x{FFFC}-\x{FFFF}])}{
    sprintf '<var>U+%04X</var>', ord $1;
  }ge;
  return $s;
} # htescape

  my @nav;
  my %time;
  require Message::DOM::DOMImplementation;
  my $dom = Message::DOM::DOMImplementation->new;
{
  use Message::CGI::HTTP;
  my $http = Message::CGI::HTTP->new;

  if ($http->get_meta_variable ('PATH_INFO') ne '/') {
    print STDOUT "Status: 404 Not Found\nContent-Type: text/plain; charset=us-ascii\n\n400";
    exit;
  }

  binmode STDOUT, ':utf8';
  $| = 1;

  load_text_catalog ('en'); ## TODO: conneg

  print STDOUT qq[Content-Type: text/html; charset=utf-8

<!DOCTYPE html>
<html lang="en">
<head>
<title>Web Document Conformance Checker (BETA)</title>
<link rel="stylesheet" href="../cc-style.css" type="text/css">
</head>
<body>
<h1><a href="../cc-interface">Web Document Conformance Checker</a> 
(<em>beta</em>)</h1>
];

  $| = 0;
  my $input = get_input_document ($http, $dom);
  my $char_length = 0;

  print qq[
<div id="document-info" class="section">
<dl>
<dt>Request URI</dt>
    <dd><code class="URI" lang="">&lt;<a href="@{[htescape $input->{request_uri}]}">@{[htescape $input->{request_uri}]}</a>&gt;</code></dd>
<dt>Document URI</dt>
    <dd><code class="URI" lang="">&lt;<a href="@{[htescape $input->{uri}]}" id=anchor-document-uri>@{[htescape $input->{uri}]}</a>&gt;</code>
    <script>
      document.title = '<'
          + document.getElementById ('anchor-document-uri').href + '> \\u2014 '
          + document.title;
    </script></dd>
]; # no </dl> yet
  push @nav, ['#document-info' => 'Information'];

if (defined $input->{s}) {
  $char_length = length $input->{s};

  print STDOUT qq[
<dt>Base URI</dt>
    <dd><code class="URI" lang="">&lt;<a href="@{[htescape $input->{base_uri}]}">@{[htescape $input->{base_uri}]}</a>&gt;</code></dd>
<dt>Internet Media Type</dt>
    <dd><code class="MIME" lang="en">@{[htescape $input->{media_type}]}</code>
    @{[$input->{media_type_overridden} ? '<em>(overridden)</em>' : defined $input->{official_type} ? $input->{media_type} eq $input->{official_type} ? '' : '<em>(sniffed; official type is: <code class=MIME lang=en>'.htescape ($input->{official_type}).'</code>)' : '<em>(sniffed)</em>']}</dd>
<dt>Character Encoding</dt>
    <dd>@{[defined $input->{charset} ? '<code class="charset" lang="en">'.htescape ($input->{charset}).'</code>' : '(none)']}
    @{[$input->{charset_overridden} ? '<em>(overridden)</em>' : '']}</dd>
<dt>Length</dt>
    <dd>$char_length byte@{[$char_length == 1 ? '' : 's']}</dd>
</dl>
</div>
];

  $input->{id_prefix} = '';
  #$input->{nested} = 0;
  my $result = {conforming_min => 1, conforming_max => 1};
  check_and_print ($input => $result);
  print_result_section ($result);
} else {
  print STDOUT qq[</dl></div>];
  print_result_input_error_section ($input);
}

  print STDOUT qq[
<ul class="navigation" id="nav-items">
];
  for (@nav) {
    print STDOUT qq[<li><a href="$_->[0]">$_->[1]</a></li>];
  }
  print STDOUT qq[
</ul>
</body>
</html>
];

  for (qw/decode parse parse_html parse_xml parse_manifest
          check check_manifest/) {
    next unless defined $time{$_};
    open my $file, '>>', ".cc-$_.txt" or die ".cc-$_.txt: $!";
    print $file $char_length, "\t", $time{$_}, "\n";
  }

exit;
}

sub add_error ($$$) {
  my ($layer, $err, $result) = @_;
  if (defined $err->{level}) {
    if ($err->{level} eq 's') {
      $result->{$layer}->{should}++;
      $result->{$layer}->{score_min} -= 2;
      $result->{conforming_min} = 0;
    } elsif ($err->{level} eq 'w' or $err->{level} eq 'g') {
      $result->{$layer}->{warning}++;
    } elsif ($err->{level} eq 'u' or $err->{level} eq 'unsupported') {
      $result->{$layer}->{unsupported}++;
      $result->{unsupported} = 1;
    } else {
      $result->{$layer}->{must}++;
      $result->{$layer}->{score_max} -= 2;
      $result->{$layer}->{score_min} -= 2;
      $result->{conforming_min} = 0;
      $result->{conforming_max} = 0;
    }
  } else {
    $result->{$layer}->{must}++;
    $result->{$layer}->{score_max} -= 2;
    $result->{$layer}->{score_min} -= 2;
    $result->{conforming_min} = 0;
    $result->{conforming_max} = 0;
  }
} # add_error

sub check_and_print ($$) {
  my ($input, $result) = @_;

  print_http_header_section ($input, $result);

  my $doc;
  my $el;
  my $cssom;
  my $manifest;
  my @subdoc;

  if ($input->{media_type} eq 'text/html') {
    ($doc, $el) = print_syntax_error_html_section ($input, $result);
    print_source_string_section
        ($input,
         \($input->{s}),
         $input->{charset} || $doc->input_encoding);
  } elsif ({
            'text/xml' => 1,
            'application/atom+xml' => 1,
            'application/rss+xml' => 1,
            'application/svg+xml' => 1,
            'application/xhtml+xml' => 1,
            'application/xml' => 1,
           }->{$input->{media_type}}) {
    ($doc, $el) = print_syntax_error_xml_section ($input, $result);
    print_source_string_section ($input,
                                 \($input->{s}),
                                 $doc->input_encoding);
  } elsif ($input->{media_type} eq 'text/css') {
    $cssom = print_syntax_error_css_section ($input, $result);
    print_source_string_section
        ($input, \($input->{s}),
         $cssom->manakai_input_encoding);
  } elsif ($input->{media_type} eq 'text/cache-manifest') {
## TODO: MUST be text/cache-manifest
    $manifest = print_syntax_error_manifest_section ($input, $result);
    print_source_string_section ($input, \($input->{s}),
                                 'utf-8');
  } else {
    ## TODO: Change HTTP status code??
    print_result_unknown_type_section ($input, $result);
  }

  if (defined $doc or defined $el) {
    $doc->document_uri ($input->{uri});
    $doc->manakai_entity_base_uri ($input->{base_uri});
    print_structure_dump_dom_section ($input, $doc, $el);
    my $elements = print_structure_error_dom_section
        ($input, $doc, $el, $result, sub {
          push @subdoc, shift;
        });
    print_table_section ($input, $elements->{table}) if @{$elements->{table}};
    print_listing_section ({
      id => 'identifiers', label => 'IDs', heading => 'Identifiers',
    }, $input, $elements->{id}) if keys %{$elements->{id}};
    print_listing_section ({
      id => 'terms', label => 'Terms', heading => 'Terms',
    }, $input, $elements->{term}) if keys %{$elements->{term}};
    print_listing_section ({
      id => 'classes', label => 'Classes', heading => 'Classes',
    }, $input, $elements->{class}) if keys %{$elements->{class}};
  } elsif (defined $cssom) {
    print_structure_dump_cssom_section ($input, $cssom);
    ## TODO: CSSOM validation
  } elsif (defined $manifest) {
    print_structure_dump_manifest_section ($input, $manifest);
    print_structure_error_manifest_section ($input, $manifest, $result);
  }

  my $id_prefix = 0;
  for my $subinput (@subdoc) {
    $subinput->{id_prefix} = 'subdoc-' . ++$id_prefix;
    $subinput->{nested} = 1;
    $subinput->{base_uri} = $subinput->{container_node}->base_uri
        unless defined $subinput->{base_uri};
    my $ebaseuri = htescape ($subinput->{base_uri});
    push @nav, ['#' . $subinput->{id_prefix} => 'Sub #' . $id_prefix];
    print STDOUT qq[<div id="$subinput->{id_prefix}" class=section>
      <h2>Subdocument #$id_prefix</h2>

      <dl>
      <dt>Internet Media Type</dt>
        <dd><code class="MIME" lang="en">@{[htescape $subinput->{media_type}]}</code>
      <dt>Container Node</dt>
        <dd>@{[get_node_link ($input, $subinput->{container_node})]}</dd>
      <dt>Base <abbr title="Uniform Resource Identifiers">URI</abbr></dt>
        <dd><code class=URI>&lt;<a href="$ebaseuri">$ebaseuri</a>></code></dd>
      </dl>];              

    $subinput->{id_prefix} .= '-';
    check_and_print ($subinput => $result);

    print STDOUT qq[</div>];
  }
} # check_and_print

sub print_http_header_section ($$) {
  my ($input, $result) = @_;
  return unless defined $input->{header_status_code} or
      defined $input->{header_status_text} or
      @{$input->{header_field} or []};
  
  push @nav, ['#source-header' => 'HTTP Header'] unless $input->{nested};
  print STDOUT qq[<div id="$input->{id_prefix}source-header" class="section">
<h2>HTTP Header</h2>

<p><strong>Note</strong>: Due to the limitation of the
network library in use, the content of this section might
not be the real header.</p>

<table><tbody>
];

  if (defined $input->{header_status_code}) {
    print STDOUT qq[<tr><th scope="row">Status code</th>];
    print STDOUT qq[<td><code>@{[htescape ($input->{header_status_code})]}</code></td></tr>];
  }
  if (defined $input->{header_status_text}) {
    print STDOUT qq[<tr><th scope="row">Status text</th>];
    print STDOUT qq[<td><code>@{[htescape ($input->{header_status_text})]}</code></td></tr>];
  }
  
  for (@{$input->{header_field}}) {
    print STDOUT qq[<tr><th scope="row"><code>@{[htescape ($_->[0])]}</code></th>];
    print STDOUT qq[<td><code>@{[htescape ($_->[1])]}</code></td></tr>];
  }

  print STDOUT qq[</tbody></table></div>];
} # print_http_header_section

sub print_syntax_error_html_section ($$) {
  my ($input, $result) = @_;
  
  require Encode;
  require Whatpm::HTML;
  
  print STDOUT qq[
<div id="$input->{id_prefix}parse-errors" class="section">
<h2>Parse Errors</h2>

<dl>];
  push @nav, ['#parse-errors' => 'Parse Error'] unless $input->{nested};

  my $onerror = sub {
    my (%opt) = @_;
    my ($type, $cls, $msg) = get_text ($opt{type}, $opt{level});
    if ($opt{column} > 0) {
      print STDOUT qq[<dt class="$cls"><a href="#$input->{id_prefix}line-$opt{line}">Line $opt{line}</a> column $opt{column}</dt>\n];
    } else {
      $opt{line} = $opt{line} - 1 || 1;
      print STDOUT qq[<dt class="$cls"><a href="#$input->{id_prefix}line-$opt{line}">Line $opt{line}</a></dt>\n];
    }
    $type =~ tr/ /-/;
    $type =~ s/\|/%7C/g;
    $msg .= qq[ [<a href="../error-description#@{[htescape ($type)]}">Description</a>]];
    print STDOUT qq[<dd class="$cls">], get_error_level_label (\%opt);
    print STDOUT qq[$msg</dd>\n];

    add_error ('syntax', \%opt => $result);
  };

  my $doc = $dom->create_document;
  my $el;
  my $inner_html_element = $input->{inner_html_element};
  if (defined $inner_html_element and length $inner_html_element) {
    $input->{charset} ||= 'windows-1252'; ## TODO: for now.
    my $time1 = time;
    my $t = Encode::decode ($input->{charset}, $input->{s});
    $time{decode} = time - $time1;
    
    $el = $doc->create_element_ns
        ('http://www.w3.org/1999/xhtml', [undef, $inner_html_element]);
    $time1 = time;
    Whatpm::HTML->set_inner_html ($el, $t, $onerror);
    $time{parse} = time - $time1;
  } else {
    my $time1 = time;
    Whatpm::HTML->parse_byte_string
        ($input->{charset}, $input->{s} => $doc, $onerror);
    $time{parse_html} = time - $time1;
  }
  $doc->manakai_charset ($input->{official_charset})
      if defined $input->{official_charset};
  
  print STDOUT qq[</dl></div>];

  return ($doc, $el);
} # print_syntax_error_html_section

sub print_syntax_error_xml_section ($$) {
  my ($input, $result) = @_;
  
  require Message::DOM::XMLParserTemp;
  
  print STDOUT qq[
<div id="$input->{id_prefix}parse-errors" class="section">
<h2>Parse Errors</h2>

<dl>];
  push @nav, ['#parse-errors' => 'Parse Error'] unless $input->{prefix};

  my $onerror = sub {
    my $err = shift;
    my $line = $err->location->line_number;
    print STDOUT qq[<dt><a href="#$input->{id_prefix}line-$line">Line $line</a> column ];
    print STDOUT $err->location->column_number, "</dt><dd>";
    print STDOUT htescape $err->text, "</dd>\n";

    add_error ('syntax', {type => $err->text,
                level => [
                          $err->SEVERITY_FATAL_ERROR => 'm',
                          $err->SEVERITY_ERROR => 'm',
                          $err->SEVERITY_WARNING => 's',
                         ]->[$err->severity]} => $result);

    return 1;
  };

  my $time1 = time;
  open my $fh, '<', \($input->{s});
  my $doc = Message::DOM::XMLParserTemp->parse_byte_stream
      ($fh => $dom, $onerror, charset => $input->{charset});
  $time{parse_xml} = time - $time1;
  $doc->manakai_charset ($input->{official_charset})
      if defined $input->{official_charset};

  print STDOUT qq[</dl></div>];

  return ($doc, undef);
} # print_syntax_error_xml_section

sub get_css_parser () {
  our $CSSParser;
  return $CSSParser if $CSSParser;

  require Whatpm::CSS::Parser;
  my $p = Whatpm::CSS::Parser->new;

#  if ($parse_mode eq 'q') {
#    $p->{unitless_px} = 1;
#    $p->{hashless_color} = 1;
#  }

  $p->{prop}->{$_} = 1 for qw/
    background background-attachment background-color background-image
    background-position background-position-x background-position-y
    background-repeat border border-bottom border-bottom-color
    border-bottom-style border-bottom-width border-collapse border-color
    border-left border-left-color
    border-left-style border-left-width border-right border-right-color
    border-right-style border-right-width
    border-spacing -manakai-border-spacing-x -manakai-border-spacing-y
    border-style border-top border-top-color border-top-style border-top-width
    border-width bottom
    caption-side clear clip color content counter-increment counter-reset
    cursor direction display empty-cells float font
    font-family font-size font-size-adjust font-stretch
    font-style font-variant font-weight height left
    letter-spacing line-height
    list-style list-style-image list-style-position list-style-type
    margin margin-bottom margin-left margin-right margin-top marker-offset
    marks max-height max-width min-height min-width opacity -moz-opacity
    orphans outline outline-color outline-style outline-width overflow
    overflow-x overflow-y
    padding padding-bottom padding-left padding-right padding-top
    page page-break-after page-break-before page-break-inside
    position quotes right size table-layout
    text-align text-decoration text-indent text-transform
    top unicode-bidi vertical-align visibility white-space width widows
    word-spacing z-index
  /;
  $p->{prop_value}->{display}->{$_} = 1 for qw/
    block clip inline inline-block inline-table list-item none
    table table-caption table-cell table-column table-column-group
    table-header-group table-footer-group table-row table-row-group
    compact marker
  /;
  $p->{prop_value}->{position}->{$_} = 1 for qw/
    absolute fixed relative static
  /;
  $p->{prop_value}->{float}->{$_} = 1 for qw/
    left right none
  /;
  $p->{prop_value}->{clear}->{$_} = 1 for qw/
    left right none both
  /;
  $p->{prop_value}->{direction}->{ltr} = 1;
  $p->{prop_value}->{direction}->{rtl} = 1;
  $p->{prop_value}->{marks}->{crop} = 1;
  $p->{prop_value}->{marks}->{cross} = 1;
  $p->{prop_value}->{'unicode-bidi'}->{$_} = 1 for qw/
    normal bidi-override embed
  /;
  for my $prop_name (qw/overflow overflow-x overflow-y/) {
    $p->{prop_value}->{$prop_name}->{$_} = 1 for qw/
      visible hidden scroll auto -webkit-marquee -moz-hidden-unscrollable
    /;
  }
  $p->{prop_value}->{visibility}->{$_} = 1 for qw/
    visible hidden collapse
  /;
  $p->{prop_value}->{'list-style-type'}->{$_} = 1 for qw/
    disc circle square decimal decimal-leading-zero
    lower-roman upper-roman lower-greek lower-latin
    upper-latin armenian georgian lower-alpha upper-alpha none
    hebrew cjk-ideographic hiragana katakana hiragana-iroha
    katakana-iroha
  /;
  $p->{prop_value}->{'list-style-position'}->{outside} = 1;
  $p->{prop_value}->{'list-style-position'}->{inside} = 1;
  $p->{prop_value}->{'page-break-before'}->{$_} = 1 for qw/
    auto always avoid left right
  /;
  $p->{prop_value}->{'page-break-after'}->{$_} = 1 for qw/
    auto always avoid left right
  /;
  $p->{prop_value}->{'page-break-inside'}->{auto} = 1;
  $p->{prop_value}->{'page-break-inside'}->{avoid} = 1;
  $p->{prop_value}->{'background-repeat'}->{$_} = 1 for qw/
    repeat repeat-x repeat-y no-repeat
  /;
  $p->{prop_value}->{'background-attachment'}->{scroll} = 1;
  $p->{prop_value}->{'background-attachment'}->{fixed} = 1;
  $p->{prop_value}->{'font-size'}->{$_} = 1 for qw/
    xx-small x-small small medium large x-large xx-large
    -manakai-xxx-large -webkit-xxx-large
    larger smaller
  /;
  $p->{prop_value}->{'font-style'}->{normal} = 1;
  $p->{prop_value}->{'font-style'}->{italic} = 1;
  $p->{prop_value}->{'font-style'}->{oblique} = 1;
  $p->{prop_value}->{'font-variant'}->{normal} = 1;
  $p->{prop_value}->{'font-variant'}->{'small-caps'} = 1;
  $p->{prop_value}->{'font-stretch'}->{$_} = 1 for
      qw/normal wider narrower ultra-condensed extra-condensed
        condensed semi-condensed semi-expanded expanded
        extra-expanded ultra-expanded/;
  $p->{prop_value}->{'text-align'}->{$_} = 1 for qw/
    left right center justify begin end
  /;
  $p->{prop_value}->{'text-transform'}->{$_} = 1 for qw/
    capitalize uppercase lowercase none
  /;
  $p->{prop_value}->{'white-space'}->{$_} = 1 for qw/
    normal pre nowrap pre-line pre-wrap
  /;
  $p->{prop_value}->{'text-decoration'}->{$_} = 1 for qw/
    none blink underline overline line-through
  /;
  $p->{prop_value}->{'caption-side'}->{$_} = 1 for qw/
    top bottom left right
  /;
  $p->{prop_value}->{'table-layout'}->{auto} = 1;
  $p->{prop_value}->{'table-layout'}->{fixed} = 1;
  $p->{prop_value}->{'border-collapse'}->{collapase} = 1;
  $p->{prop_value}->{'border-collapse'}->{separate} = 1;
  $p->{prop_value}->{'empty-cells'}->{show} = 1;
  $p->{prop_value}->{'empty-cells'}->{hide} = 1;
  $p->{prop_value}->{cursor}->{$_} = 1 for qw/
    auto crosshair default pointer move e-resize ne-resize nw-resize n-resize
    se-resize sw-resize s-resize w-resize text wait help progress
  /;
  for my $prop (qw/border-top-style border-left-style
                   border-bottom-style border-right-style outline-style/) {
    $p->{prop_value}->{$prop}->{$_} = 1 for qw/
      none hidden dotted dashed solid double groove ridge inset outset
    /;
  }
  for my $prop (qw/color background-color
                   border-bottom-color border-left-color border-right-color
                   border-top-color border-color/) {
    $p->{prop_value}->{$prop}->{transparent} = 1;
    $p->{prop_value}->{$prop}->{flavor} = 1;
    $p->{prop_value}->{$prop}->{'-manakai-default'} = 1;
  }
  $p->{prop_value}->{'outline-color'}->{invert} = 1;
  $p->{prop_value}->{'outline-color'}->{'-manakai-invert-or-currentcolor'} = 1;
  $p->{pseudo_class}->{$_} = 1 for qw/
    active checked disabled empty enabled first-child first-of-type
    focus hover indeterminate last-child last-of-type link only-child
    only-of-type root target visited
    lang nth-child nth-last-child nth-of-type nth-last-of-type not
    -manakai-contains -manakai-current
  /;
  $p->{pseudo_element}->{$_} = 1 for qw/
    after before first-letter first-line
  /;

  return $CSSParser = $p;
} # get_css_parser

sub print_syntax_error_css_section ($$) {
  my ($input, $result) = @_;

  print STDOUT qq[
<div id="$input->{id_prefix}parse-errors" class="section">
<h2>Parse Errors</h2>

<dl>];
  push @nav, ['#parse-errors' => 'Parse Error'] unless $input->{nested};

  my $p = get_css_parser ();
  $p->{onerror} = sub {
    my (%opt) = @_;
    my ($type, $cls, $msg) = get_text ($opt{type}, $opt{level});
    if ($opt{token}) {
      print STDOUT qq[<dt class="$cls"><a href="#$input->{id_prefix}line-$opt{token}->{line}">Line $opt{token}->{line}</a> column $opt{token}->{column}];
    } else {
      print STDOUT qq[<dt class="$cls">Unknown location];
    }
    if (defined $opt{value}) {
      print STDOUT qq[ (<code>@{[htescape ($opt{value})]}</code>)];
    } elsif (defined $opt{token}) {
      print STDOUT qq[ (<code>@{[htescape (Whatpm::CSS::Tokenizer->serialize_token ($opt{token}))]}</code>)];
    }
    $type =~ tr/ /-/;
    $type =~ s/\|/%7C/g;
    $msg .= qq[ [<a href="../error-description#@{[htescape ($type)]}">Description</a>]];
    print STDOUT qq[<dd class="$cls">], get_error_level_label (\%opt);
    print STDOUT qq[$msg</dd>\n];

    add_error ('syntax', \%opt => $result);
  };
  $p->{href} = $input->{uri};
  $p->{base_uri} = $input->{base_uri};

  my $s = \$input->{s};
  my $charset;
  unless ($input->{is_char_string}) {
    require Encode;
    if (defined $input->{charset}) {## TODO: IANA->Perl
      $charset = $input->{charset};
      $s = \(Encode::decode ($input->{charset}, $$s));
    } else {
      ## TODO: charset detection
      $s = \(Encode::decode ($charset = 'utf-8', $$s));
    }
  }
  
  my $cssom = $p->parse_char_string ($$s);
  $cssom->manakai_input_encoding ($charset) if defined $charset;

  print STDOUT qq[</dl></div>];

  return $cssom;
} # print_syntax_error_css_section

sub print_syntax_error_manifest_section ($$) {
  my ($input, $result) = @_;

  require Whatpm::CacheManifest;

  print STDOUT qq[
<div id="$input->{id_prefix}parse-errors" class="section">
<h2>Parse Errors</h2>

<dl>];