/[pub]/test/html-webhacc/cc.cgi
Suika

Diff of /test/html-webhacc/cc.cgi

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.54 by wakaba, Sun Jul 20 16:53:10 2008 UTC revision 1.59 by wakaba, Mon Jul 21 12:56:33 2008 UTC
# Line 1  Line 1 
1  #!/usr/bin/perl  #!/usr/bin/perl
2  use strict;  use strict;
 use utf8;  
3    
4  use lib qw[/home/httpd/html/www/markup/html/whatpm  use lib qw[/home/httpd/html/www/markup/html/whatpm
5             /home/wakaba/work/manakai2/lib];             /home/wakaba/work/manakai2/lib];
6  use CGI::Carp qw[fatalsToBrowser];  use CGI::Carp qw[fatalsToBrowser];
 use Scalar::Util qw[refaddr];  
7    
8    require WebHACC::Input;    require WebHACC::Input;
   require WebHACC::Result;  
   require WebHACC::Output;  
9    
 my $out;  
   
   require Message::DOM::DOMImplementation;  
   my $dom = Message::DOM::DOMImplementation->new;  
10  {  {
11    use Message::CGI::HTTP;    require Message::CGI::HTTP;
12    my $http = Message::CGI::HTTP->new;    my $http = Message::CGI::HTTP->new;
13    
14      require WebHACC::Output;
15      my $out = WebHACC::Output->new;
16      $out->handle (*STDOUT);
17      $out->set_utf8;
18    
19    if ($http->get_meta_variable ('PATH_INFO') ne '/') {    if ($http->get_meta_variable ('PATH_INFO') ne '/') {
20      print STDOUT "Status: 404 Not Found\nContent-Type: text/plain; charset=us-ascii\n\n400";      $out->http_error (404);
21      exit;      exit;
22    }    }
     
   load_text_catalog ('en'); ## TODO: conneg  
23    
24    $out = WebHACC::Output->new;    ## TODO: We need real conneg support...
25    $out->handle (*STDOUT);    my $primary_language = 'en';
26    $out->set_utf8;    if ($ENV{HTTP_ACCEPT_LANGUAGE} =~ /ja/) {
27        $primary_language = 'ja';
28      }
29      $out->load_text_catalog ($primary_language);
30      
31    $out->set_flush;    $out->set_flush;
32    $out->html (qq[Content-Type: text/html; charset=utf-8    $out->http_header;
33      $out->html_header;
34  <!DOCTYPE html>    $out->unset_flush;
 <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>  
 ]);  
35    
36    my $input = get_input_document ($http, $dom);    my $input = get_input_document ($http);
37    $out->input ($input);    $out->input ($input);
   $out->unset_flush;  
38    
39    my $char_length = 0;    require WebHACC::Result;
40      my $result = WebHACC::Result->new;
41      $result->output ($out);
42      $result->{conforming_min} = 1;
43      $result->{conforming_max} = 1;
44    
45    $out->start_section (id => 'document-info', title => 'Information');    $out->html ('<script src="../cc-script.js"></script>');
   $out->html (qq[<dl>  
 <dt>Request URL</dt>  
     <dd>]);  
   $out->url ($input->{request_uri});  
   $out->html (q[<dt>Document URL<!-- HTML5 document's address? -->  
     <dd>]);  
   $out->url ($input->{uri}, id => 'anchor-document-url');  
   $out->html (q[  
     <script>  
       document.title = '<'  
           + document.getElementById ('anchor-document-url').href + '> \\u2014 '  
           + document.title;  
     </script>]);  
   ## NOTE: no </dl> yet  
   
   if (defined $input->{s}) {  
     $char_length = length $input->{s};  
   
     $out->html (qq[<dt>Base URI<dd>]);  
     $out->url ($input->{base_uri});  
     $out->html (qq[<dt>Internet Media Type</dt>  
     <dd><code class="MIME" lang="en">]);  
     $out->text ($input->{media_type});  
     $out->html (qq[</code> ]);  
     if ($input->{media_type_overridden}) {  
       $out->html ('<em>(overridden)</em>');  
     } elsif (defined $input->{official_type}) {  
       if ($input->{media_type} eq $input->{official_type}) {  
         #  
       } else {  
         $out->html ('<em>(sniffed; official type is: <code class=MIME lang=en>');  
         $out->text ($input->{official_type});  
         $out->html ('</code>)');  
       }  
     } else {  
       $out->html ('<em>(sniffed)</em>');  
     }  
     $out->html (q[<dt>Character Encoding<dd>]);  
     if (defined $input->{charset}) {  
       $out->html ('<code class="charset" lang="en">');  
       $out->text ($input->{charset});  
       $out->html ('</code>');  
     } else {  
       $out->text ('(none)');  
     }  
     $out->html (' <em>overridden</em>') if $input->{charset_overridden};  
     $out->html (qq[  
 <dt>Length</dt>  
     <dd>$char_length byte@{[$char_length == 1 ? '' : 's']}</dd>  
 </dl>  
   
 <script src="../cc-script.js"></script>  
 ]);  
     $out->end_section;  
   
     my $result = WebHACC::Result->new;  
     $result->output ($out);  
     $result->{conforming_min} = 1;  
     $result->{conforming_max} = 1;  
     check_and_print ($input => $result => $out);  
     $result->generate_result_section;  
   } else {  
     $out->html ('</dl>');  
     $out->end_section;  
46    
47      my $result = WebHACC::Result->new;    check_and_print ($input => $result => $out);
48      $result->output ($out);    
49      $result->{conforming_min} = 0;    $result->generate_result_section;
     $result->{conforming_max} = 1;  
   
     $input->generate_transfer_sections ($result);  
     $result->generate_result_section;  
   }  
50    
51    $out->nav_list;    $out->nav_list;
52    
# Line 134  sub check_and_print ($$$) { Line 58  sub check_and_print ($$$) {
58    my $original_input = $out->input;    my $original_input = $out->input;
59    $out->input ($input);    $out->input ($input);
60    
61      $input->generate_info_section ($result);
62    
63    $input->generate_transfer_sections ($result);    $input->generate_transfer_sections ($result);
64    
65    my @subdoc;    unless (defined $input->{s}) {
66        $result->{conforming_min} = 0;
67        return;
68      }
69    
70    my $checker_class = {    my $checker_class = {
71      'text/cache-manifest' => 'WebHACC::Language::CacheManifest',      'text/cache-manifest' => 'WebHACC::Language::CacheManifest',
# Line 169  sub check_and_print ($$$) { Line 98  sub check_and_print ($$$) {
98    $checker->generate_syntax_error_section;    $checker->generate_syntax_error_section;
99    $checker->generate_source_string_section;    $checker->generate_source_string_section;
100    
101      my @subdoc;
102    $checker->onsubdoc (sub {    $checker->onsubdoc (sub {
103      push @subdoc, shift;      push @subdoc, shift;
104    });    });
# Line 177  sub check_and_print ($$$) { Line 107  sub check_and_print ($$$) {
107    $checker->generate_structure_error_section;    $checker->generate_structure_error_section;
108    $checker->generate_additional_sections;    $checker->generate_additional_sections;
109    
 =pod  
   
   if (defined $doc or defined $el) {  
   
     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}};  
     
     print_rdf_section ($input, $elements->{rdf}) if @{$elements->{rdf}};  
   }  
   
 =cut  
   
110    my $id_prefix = 0;    my $id_prefix = 0;
111    for my $_subinput (@subdoc) {    for my $_subinput (@subdoc) {
112      my $subinput = WebHACC::Input->new;      my $subinput = WebHACC::Input::Subdocument->new (++$id_prefix);
113      $subinput->{$_} = $_subinput->{$_} for keys %$_subinput;      $subinput->{$_} = $_subinput->{$_} for keys %$_subinput;
     $subinput->id_prefix ('subdoc-' . ++$id_prefix);  
     $subinput->nested (1);  
114      $subinput->{base_uri} = $subinput->{container_node}->base_uri      $subinput->{base_uri} = $subinput->{container_node}->base_uri
115          unless defined $subinput->{base_uri};          unless defined $subinput->{base_uri};
116      my $ebaseuri = htescape ($subinput->{base_uri});      $subinput->{parent_input} = $input;
     $out->start_section (id => $subinput->id_prefix,  
                          title => qq[Subdocument #$id_prefix]);  
     print STDOUT qq[  
       <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>];                
117    
118      $subinput->{id_prefix} .= '-';      $subinput->start_section ($result);
119      check_and_print ($subinput => $result => $out);      check_and_print ($subinput => $result => $out);
120        $subinput->end_section ($result);
     $out->end_section;  
121    }    }
122    
123    $out->input ($original_input);    $out->input ($original_input);
124  } # check_and_print  } # check_and_print
125    
126  sub print_table_section ($$) {  sub get_input_document ($) {
127    my ($input, $tables) = @_;    my $http = shift;
     
 #  push @nav, [qq[#$input->{id_prefix}tables] => 'Tables']  
 #      unless $input->{nested};  
   print STDOUT qq[  
 <div id="$input->{id_prefix}tables" class="section">  
 <h2>Tables</h2>  
   
 <!--[if IE]><script type="text/javascript" src="../excanvas.js"></script><![endif]-->  
 <script src="../table-script.js" type="text/javascript"></script>  
 <noscript>  
 <p><em>Structure of tables are visualized here if scripting is enabled.</em></p>  
 </noscript>  
 ];  
     
   require JSON;  
     
   my $i = 0;  
   for my $table (@$tables) {  
     $i++;  
     print STDOUT qq[<div class="section" id="$input->{id_prefix}table-$i"><h3>] .  
         get_node_link ($input, $table->{element}) . q[</h3>];  
   
     delete $table->{element};  
   
     for (@{$table->{column_group}}, @{$table->{column}}, $table->{caption},  
          @{$table->{row}}) {  
       next unless $_;  
       delete $_->{element};  
     }  
       
     for (@{$table->{row_group}}) {  
       next unless $_;  
       next unless $_->{element};  
       $_->{type} = $_->{element}->manakai_local_name;  
       delete $_->{element};  
     }  
       
     for (@{$table->{cell}}) {  
       next unless $_;  
       for (@{$_}) {  
         next unless $_;  
         for (@$_) {  
           $_->{id} = refaddr $_->{element} if defined $_->{element};  
           delete $_->{element};  
           $_->{is_header} = $_->{is_header} ? 1 : 0;  
         }  
       }  
     }  
           
     print STDOUT '</div><script type="text/javascript">tableToCanvas (';  
     print STDOUT JSON::objToJson ($table);  
     print STDOUT qq[, document.getElementById ('$input->{id_prefix}table-$i')];  
     print STDOUT qq[, '$input->{id_prefix}');</script>];  
   }  
     
   print STDOUT qq[</div>];  
 } # print_table_section  
   
 sub print_listing_section ($$$) {  
   my ($opt, $input, $ids) = @_;  
     
 #  push @nav, ['#' . $input->{id_prefix} . $opt->{id} => $opt->{label}]  
 #      unless $input->{nested};  
   print STDOUT qq[  
 <div id="$input->{id_prefix}$opt->{id}" class="section">  
 <h2>$opt->{heading}</h2>  
   
 <dl>  
 ];  
   for my $id (sort {$a cmp $b} keys %$ids) {  
     print STDOUT qq[<dt><code>@{[htescape $id]}</code></dt>];  
     for (@{$ids->{$id}}) {  
       print STDOUT qq[<dd>].get_node_link ($input, $_).qq[</dd>];  
     }  
   }  
   print STDOUT qq[</dl></div>];  
 } # print_listing_section  
   
   
 sub print_rdf_section ($$$) {  
   my ($input, $rdfs) = @_;  
     
 #  push @nav, ['#' . $input->{id_prefix} . 'rdf' => 'RDF']  
 #      unless $input->{nested};  
   print STDOUT qq[  
 <div id="$input->{id_prefix}rdf" class="section">  
 <h2>RDF Triples</h2>  
   
 <dl>];  
   my $i = 0;  
   for my $rdf (@$rdfs) {  
     print STDOUT qq[<dt id="$input->{id_prefix}rdf-@{[$i++]}">];  
     print STDOUT get_node_link ($input, $rdf->[0]);  
     print STDOUT qq[<dd><dl>];  
     for my $triple (@{$rdf->[1]}) {  
       print STDOUT '<dt>' . get_node_link ($input, $triple->[0]) . '<dd>';  
       print STDOUT get_rdf_resource_html ($triple->[1]);  
       print STDOUT ' ';  
       print STDOUT get_rdf_resource_html ($triple->[2]);  
       print STDOUT ' ';  
       print STDOUT get_rdf_resource_html ($triple->[3]);  
     }  
     print STDOUT qq[</dl>];  
   }  
   print STDOUT qq[</dl></div>];  
 } # print_rdf_section  
   
 sub get_rdf_resource_html ($) {  
   my $resource = shift;  
   if (defined $resource->{uri}) {  
     my $euri = htescape ($resource->{uri});  
     return '<code class=uri>&lt;<a href="' . $euri . '">' . $euri .  
         '</a>></code>';  
   } elsif (defined $resource->{bnodeid}) {  
     return htescape ('_:' . $resource->{bnodeid});  
   } elsif ($resource->{nodes}) {  
     return '(rdf:XMLLiteral)';  
   } elsif (defined $resource->{value}) {  
     my $elang = htescape (defined $resource->{language}  
                               ? $resource->{language} : '');  
     my $r = qq[<q lang="$elang">] . htescape ($resource->{value}) . '</q>';  
     if (defined $resource->{datatype}) {  
       my $euri = htescape ($resource->{datatype});  
       $r .= '^^<code class=uri>&lt;<a href="' . $euri . '">' . $euri .  
           '</a>></code>';  
     } elsif (length $resource->{language}) {  
       $r .= '@' . htescape ($resource->{language});  
     }  
     return $r;  
   } else {  
     return '??';  
   }  
 } # get_rdf_resource_html  
   
 {  
   my $Msg = {};  
   
 sub load_text_catalog ($) {  
 #  my $self = shift;  
   my $lang = shift; # MUST be a canonical lang name  
   open my $file, '<:utf8', "cc-msg.$lang.txt"  
       or die "$0: cc-msg.$lang.txt: $!";  
   while (<$file>) {  
     if (s/^([^;]+);([^;]*);//) {  
       my ($type, $cls, $msg) = ($1, $2, $_);  
       $msg =~ tr/\x0D\x0A//d;  
       $Msg->{$type} = [$cls, $msg];  
     }  
   }  
 } # load_text_catalog  
   
 sub get_text ($;$$) {  
 #  my $self = shift;  
   my ($type, $level, $node) = @_;  
   $type = $level . ':' . $type if defined $level;  
   $level = 'm' unless defined $level;  
   my @arg;  
   {  
     if (defined $Msg->{$type}) {  
       my $msg = $Msg->{$type}->[1];  
       $msg =~ s{<var>\$([0-9]+)</var>}{  
         defined $arg[$1] ? ($arg[$1]) : '(undef)';  
       }ge;                 ##BUG: ^ must be escaped  
       $msg =~ s{<var>{\@([A-Za-z0-9:_.-]+)}</var>}{  
         UNIVERSAL::can ($node, 'get_attribute_ns')  
             ?  ($node->get_attribute_ns (undef, $1)) : ''  
       }ge; ## BUG: ^ must be escaped  
       $msg =~ s{<var>{\@}</var>}{        ## BUG: v must be escaped  
         UNIVERSAL::can ($node, 'value') ? ($node->value) : ''  
       }ge;  
       $msg =~ s{<var>{local-name}</var>}{  
         UNIVERSAL::can ($node, 'manakai_local_name')  
           ? ($node->manakai_local_name) : ''  
       }ge;  ## BUG: ^ must be escaped  
       $msg =~ s{<var>{element-local-name}</var>}{  
         (UNIVERSAL::can ($node, 'owner_element') and  
          $node->owner_element)  
           ?  ($node->owner_element->manakai_local_name)  
           : '' ## BUG: ^ must be escaped  
       }ge;  
       return ($type, 'level-' . $level . ' ' . $Msg->{$type}->[0], $msg);  
     } elsif ($type =~ s/:([^:]*)$//) {  
       unshift @arg, $1;  
       redo;  
     }  
   }  
   return ($type, 'level-'.$level, ($_[0]));  
                                  ## BUG: ^ must be escaped  
 } # get_text  
128    
129  }    require Message::DOM::DOMImplementation;
130      my $dom = Message::DOM::DOMImplementation->new;
 sub get_input_document ($$) {  
   my ($http, $dom) = @_;  
131    
132    require Encode;    require Encode;
133    my $request_uri = Encode::decode ('utf-8', $http->get_parameter ('uri'));    my $request_uri = Encode::decode ('utf-8', $http->get_parameter ('uri'));
Legend:
Removed from v.1.54  
changed lines
  Added in v.1.59
admin@suikawiki.org
 ViewVC Help
Powered by ViewVC 1.1.24