WebHACC/Language/DOM.pm

package WebHACC::Language::DOM;
use strict;
require WebHACC::Language::Base;
push our @ISA, 'WebHACC::Language::Base';

use Scalar::Util qw[refaddr];

sub generate_structure_dump_section ($) {
  my $self = shift;
  
  my $out = $self->output;

  $out->start_section (role => 'tree');

  $out->start_tag ('ol', class => 'xoxo');

  my @node = ($self->{structure});
  while (@node) {
    my $child = shift @node;
    unless (ref $child) {
      $out->html ($child);
      next;
    }

    my $node_id = 'node-'.refaddr $child;
    my $nt = $child->node_type;
    if ($nt == $child->ELEMENT_NODE) {
      my $child_nsuri = $child->namespace_uri;
      $out->start_tag ('li', id => $node_id, class => 'tree-element');
      $out->start_tag ('code',
                       title => defined $child_nsuri ? $child_nsuri : '');
      $out->text ($child->tag_name); ## TODO: case
      $out->end_tag ('code');

      if ($child->has_attributes) {
        $out->start_tag ('ul', class => 'attributes');
        for my $attr (sort {$a->[0] cmp $b->[0]} map { [$_->name, $_->value, $_->namespace_uri, 'node-'.refaddr $_] }
                      @{$child->attributes}) {
          $out->start_tag ('li', id => $attr->[3], class => 'tree-attribute');
          $out->start_tag ('code',
                           title => defined $attr->[2] ? $attr->[2] : '');
          $out->html ($attr->[0]); ## ISSUE: case
          $out->end_tag ('code');
          $out->text (' = ');
          $out->start_tag ('q');
          $out->text ($attr->[1]); ## TODO: children
          $out->end_tag ('q');
        }
        $out->end_tag ('ul');
      }

      if ($child->has_child_nodes) {
        $out->start_tag ('ol', class => 'children');
        unshift @node, @{$child->child_nodes}, '</ol></li>';
      }
    } elsif ($nt == $child->TEXT_NODE) {
      $out->start_tag ('li', id => $node_id, class => 'tree-text');
      $out->start_tag ('q', lang => '');
      $out->text ($child->data);
      $out->end_tag ('q');
    } elsif ($nt == $child->CDATA_SECTION_NODE) {
      $out->start_tag ('li', id => $node_id, class => 'tree-cdata');
      $out->start_tag ('code');
      $out->text ('<![CDATA[');
      $out->end_tag ('code');
      $out->start_tag ('q', lang => '');
      $out->text ($child->data);
      $out->end_tag ('q');
      $out->start_tag ('code');
      $out->text (']]>');
      $out->end_tag ('code');
    } elsif ($nt == $child->COMMENT_NODE) {
      $out->start_tag ('li', id => $node_id, class => 'tree-cdata');
      $out->start_tag ('code');
      $out->text ('<!--');
      $out->end_tag ('code');
      $out->start_tag ('q', lang => '');
      $out->text ($child->data);
      $out->end_tag ('q');
      $out->start_tag ('code');
      $out->text ('-->');
      $out->end_tag ('code');
    } elsif ($nt == $child->DOCUMENT_NODE) {
      $out->start_tag ('li', id => $node_id, class => 'tree-document');
      $out->nl_text ('Document');

      $out->start_tag ('ul', class => 'attributes');
      
      my $cp = $child->manakai_charset;
      if (defined $cp) {
        $out->start_tag ('li');
        $out->nl_text ('manakaiCharset');
        $out->text (' = ');
        $out->code ($cp);
      }
      
      $out->start_tag ('li');
      $out->nl_text ('inputEncoding');
      $out->text (' = ');
      my $ie = $child->input_encoding;
      if (defined $ie) {
        $out->code ($ie);
        if ($child->manakai_has_bom) {
          $out->nl_text ('... with BOM');
        }
      } else {
        $out->html (qq[(<code>null</code>)]);
      }

      $out->start_tag ('li');
      $out->nl_text ('manakaiIsHTML:'.($child->manakai_is_html?1:0));

      $out->start_tag ('li');
      $out->nl_text ('manakaiCompatMode:'.$child->manakai_compat_mode);

      unless ($child->manakai_is_html) {
        $out->start_tag ('li');
        $out->nl_text ('xmlVersion');
        $out->text (' = ');
        $out->code ($child->xml_version);
        
        $out->start_tag ('li');
        $out->nl_text ('xmlEncoding');
        $out->text (' = ');
        if (defined $child->xml_encoding) {
          $out->code ($child->xml_encoding);
        } else {
          $out->html ('(<code>null</code>)');
        }

        $out->start_tag ('li');
        $out->nl_text ('xmlStandalone');
        $out->text (' = ');
        $out->code ($child->xml_standalone ? 'true' : 'false');
      }

      $out->end_tag ('ul');
      
      if ($child->has_child_nodes) {
        $out->start_tag ('ol', class => 'children');
        unshift @node, @{$child->child_nodes}, '</ol></li>';
      }
    } elsif ($nt == $child->DOCUMENT_TYPE_NODE) {
      $out->start_tag ('li', id => $node_id, class => 'tree-doctype');
      $out->code ('<!DOCTYPE>');
      $out->start_tag ('ul', class => 'attributes');

      $out->start_tag ('li', class => 'tree-doctype-name');
      $out->text ('Name = ');
      $out->code ($child->name);

      $out->start_tag ('li', class => 'tree-doctype-publicid');
      $out->text ('Public identifier = ');
      $out->code ($child->public_id);

      $out->start_tag ('li', class => 'tree-doctype-systemid');
      $out->text ('System identifier = ');
      $out->code ($child->system_id);

      $out->end_tag ('ul');
    } elsif ($nt == $child->PROCESSING_INSTRUCTION_NODE) {
      $out->start_tag ('li', id => $node_id, class => 'tree-id');
      $out->code ('<?');
      $out->code ($child->target);
      $out->text (' ');
      $out->code ($child->data);
      $out->code ('?>');
    } else { # error
      $out->start_tag ('li', id => $node_id, class => 'tree-unknown');
      $out->text ($child->node_type . ' ' . $child->node_name);
    }
  }
  $out->end_tag ('ol');

  $out->end_section;
} # generate_structure_dump_section

sub generate_structure_error_section ($) {
  my $self = shift;
  
  my $out = $self->output;
  $out->start_section (role => 'structure-errors');
  $out->start_error_list (role => 'structure-errors');

  my $input = $self->input;
  my $result = $self->result;

  require Whatpm::ContentChecker;
  my $onerror = sub {
    $result->add_error (@_, layer => 'structure');
  };

  my $onsubdoc = $self->onsubdoc;
  if ($self->{structure}->node_type == $self->{structure}->ELEMENT_NODE) {
    $self->{add_info} = Whatpm::ContentChecker->check_element
        ($self->{structure}, $onerror, $onsubdoc);
  } else {
    $self->{add_info} = Whatpm::ContentChecker->check_document
        ($self->{structure}, $onerror, $onsubdoc);
  }

  $out->end_error_list (role => 'structure-errors');
  $out->end_section;
} # generate_structure_error_section

sub generate_additional_sections ($) {
  my $self = shift;
  $self->SUPER::generate_additional_sections;

  $self->generate_table_section;

  $self->generate_listing_section (
      key => 'id', id => 'identifiers',
      short_title => 'IDs', title => 'Identifiers',
  );
  $self->generate_listing_section (
      key => 'term', id => 'terms',
      short_title => 'Terms', title => 'Terms',
  );
  $self->generate_listing_section (
      key => 'class', id => 'classes',
      short_title => 'Classes', title => 'Classes',
  );

  $self->generate_rdf_section;
} # generate_additional_sections

sub generate_table_section ($) {
  my $self = shift;

  my $tables = $self->{add_info}->{table} || [];
  return unless @$tables;

  my $out = $self->output;
  $out->start_section (id => 'tables', short_title => 'Tables',
                       title => 'Tables Section');

  $out->html (q[<!--[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++;
    my $index = $out->input->full_subdocument_index;
    $index = $index ? $index . '.' . $i : $i;
    $out->start_section (id => 'table-' . $i,
                         title => 'Table #',
                         text => $index);

    $out->start_tag ('dl');
    $out->dt ('Table Element');
    $out->start_tag ('dd');
    $out->node_link ($table->{element});
    $out->end_tag ('dl');
    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;
        }
      }
    }

    my $id_prefix = $self->input->id_prefix;
    $out->script (q[tableToCanvas (] .
        JSON::objToJson ($table) .
        q[, document.getElementById ('] . $id_prefix . 'table-' . $i . q[')] .
        q[, '] . $id_prefix . q[');]);

    $out->end_section;
  }

  $out->end_section;
} # generate_table_section

sub generate_listing_section ($%) {
  my $self = shift;
  my %opt = @_;

  my $list = $self->{add_info}->{$opt{key}} || {};
  return unless keys %$list;

  my $out = $self->output;

  $out->start_section (id => $opt{id},
                       title => $opt{title},
                       short_title => $opt{short_title});
  $out->start_tag ('dl');

  for my $id (sort {$a cmp $b} keys %$list) {
    $out->start_tag ('dt');
    $out->code ($id);
    for (@{$list->{$id}}) {
      $out->start_tag ('dd');
      $out->node_link ($_);
    }
  }

  $out->end_tag ('dl');
  $out->end_section;
} # generate_listing_section

my $generate_rdf_resource_html = sub ($$) {
  my ($resource, $out) = @_;

  if (defined $resource->{uri}) {
    $out->url ($resource->{uri});
  } elsif (defined $resource->{bnodeid}) {
    $out->text ('_:' . $resource->{bnodeid});
  } elsif ($resource->{nodes}) {
    $out->text ('(rdf:XMLLiteral)');
  } elsif (defined $resource->{value}) {
    $out->start_tag ('q',
                     lang => defined $resource->{language}
                         ? $resource->{language} : '');
    $out->text ($resource->{value});
    $out->end_tag ('q');

    if (defined $resource->{datatype}) {
      $out->text ('^^');
      $out->url ($resource->{datatype});
    } elsif (length $resource->{language}) {
      $out->text ('@' . $resource->{language});
    }
  } else {
    $out->text ('??'); ## NOTE: An error of the implementation.
  }
}; # $generate_rdf_resource_html

## TODO: Should we move this method to another module,
## such as Base or RDF?
sub generate_rdf_section ($) {
  my $self = shift;

  my $list = $self->{add_info}->{rdf} || [];
  return unless @$list;

  my $out = $self->output;
  $out->start_section (id => 'rdf', short_title => 'RDF',
                       title => 'RDF Triples');
  $out->start_tag ('dl');

  my $i = 0;
  for my $rdf (@$list) {
    $out->start_tag ('dt', id => 'rdf-' . $i++);
    $out->node_link ($rdf->[0]);
    $out->start_tag ('dd');
    $out->start_tag ('dl');
    for my $triple (@{$rdf->[1]}) {
      $out->start_tag ('dt');
      $out->node_link ($triple->[0]);
      $out->start_tag ('dd');
      $out->text ('Subject: ');
      $generate_rdf_resource_html->($triple->[1] => $out);
      $out->start_tag ('dd');
      $out->text ('Predicate: ');
      $generate_rdf_resource_html->($triple->[2] => $out);
      $out->start_tag ('dd');
      $out->text ('Object: ');
      $generate_rdf_resource_html->($triple->[3] => $out);
    }
    $out->end_tag ('dl');
  }
  $out->end_tag ('dl');
  $out->end_section;
} # generate_rdf_section

1;
1	wakaba	1.1	package WebHACC::Language::DOM;
2			use strict;
3			require WebHACC::Language::Base;
4			push our @ISA, 'WebHACC::Language::Base';
5
6			use Scalar::Util qw[refaddr];
7
8			sub generate_structure_dump_section ($) {
9			my $self = shift;
10
11			my $out = $self->output;
12
13	wakaba	1.3	$out->start_section (role => 'tree');
14	wakaba	1.1
15			$out->start_tag ('ol', class => 'xoxo');
16
17			my @node = ($self->{structure});
18			while (@node) {
19			my $child = shift @node;
20			unless (ref $child) {
21			$out->html ($child);
22			next;
23			}
24
25			my $node_id = 'node-'.refaddr $child;
26			my $nt = $child->node_type;
27			if ($nt == $child->ELEMENT_NODE) {
28			my $child_nsuri = $child->namespace_uri;
29			$out->start_tag ('li', id => $node_id, class => 'tree-element');
30			$out->start_tag ('code',
31			title => defined $child_nsuri ? $child_nsuri : '');
32			$out->text ($child->tag_name); ## TODO: case
33			$out->end_tag ('code');
34
35			if ($child->has_attributes) {
36			$out->start_tag ('ul', class => 'attributes');
37			for my $attr (sort {$a->[0] cmp $b->[0]} map { [$_->name, $_->value, $_->namespace_uri, 'node-'.refaddr $_] }
38			@{$child->attributes}) {
39			$out->start_tag ('li', id => $attr->[3], class => 'tree-attribute');
40			$out->start_tag ('code',
41			title => defined $attr->[2] ? $attr->[2] : '');
42			$out->html ($attr->[0]); ## ISSUE: case
43			$out->end_tag ('code');
44			$out->text (' = ');
45			$out->start_tag ('q');
46			$out->text ($attr->[1]); ## TODO: children
47			$out->end_tag ('q');
48			}
49			$out->end_tag ('ul');
50			}
51
52			if ($child->has_child_nodes) {
53			$out->start_tag ('ol', class => 'children');
54			unshift @node, @{$child->child_nodes}, '</ol></li>';
55			}
56			} elsif ($nt == $child->TEXT_NODE) {
57			$out->start_tag ('li', id => $node_id, class => 'tree-text');
58			$out->start_tag ('q', lang => '');
59			$out->text ($child->data);
60			$out->end_tag ('q');
61			} elsif ($nt == $child->CDATA_SECTION_NODE) {
62			$out->start_tag ('li', id => $node_id, class => 'tree-cdata');
63			$out->start_tag ('code');
64			$out->text ('<![CDATA[');
65			$out->end_tag ('code');
66			$out->start_tag ('q', lang => '');
67			$out->text ($child->data);
68			$out->end_tag ('q');
69			$out->start_tag ('code');
70			$out->text (']]>');
71			$out->end_tag ('code');
72			} elsif ($nt == $child->COMMENT_NODE) {
73			$out->start_tag ('li', id => $node_id, class => 'tree-cdata');
74			$out->start_tag ('code');
75			$out->text ('<!--');
76			$out->end_tag ('code');
77			$out->start_tag ('q', lang => '');
78			$out->text ($child->data);
79			$out->end_tag ('q');
80			$out->start_tag ('code');
81			$out->text ('-->');
82			$out->end_tag ('code');
83			} elsif ($nt == $child->DOCUMENT_NODE) {
84			$out->start_tag ('li', id => $node_id, class => 'tree-document');
85	wakaba	1.6	$out->nl_text ('Document');
86
87	wakaba	1.1	$out->start_tag ('ul', class => 'attributes');
88	wakaba	1.6
89	wakaba	1.1	my $cp = $child->manakai_charset;
90			if (defined $cp) {
91	wakaba	1.6	$out->start_tag ('li');
92			$out->nl_text ('manakaiCharset');
93			$out->text (' = ');
94			$out->code ($cp);
95	wakaba	1.1	}
96	wakaba	1.6
97			$out->start_tag ('li');
98			$out->nl_text ('inputEncoding');
99			$out->text (' = ');
100	wakaba	1.1	my $ie = $child->input_encoding;
101			if (defined $ie) {
102			$out->code ($ie);
103			if ($child->manakai_has_bom) {
104	wakaba	1.6	$out->nl_text ('... with BOM');
105	wakaba	1.1	}
106			} else {
107			$out->html (qq[(<code>null</code>)]);
108			}
109	wakaba	1.6
110			$out->start_tag ('li');
111			$out->nl_text ('manakaiIsHTML:'.($child->manakai_is_html?1:0));
112
113			$out->start_tag ('li');
114			$out->nl_text ('manakaiCompatMode:'.$child->manakai_compat_mode);
115
116	wakaba	1.1	unless ($child->manakai_is_html) {
117	wakaba	1.6	$out->start_tag ('li');
118			$out->nl_text ('xmlVersion');
119			$out->text (' = ');
120	wakaba	1.1	$out->code ($child->xml_version);
121	wakaba	1.6
122			$out->start_tag ('li');
123			$out->nl_text ('xmlEncoding');
124			$out->text (' = ');
125	wakaba	1.1	if (defined $child->xml_encoding) {
126			$out->code ($child->xml_encoding);
127			} else {
128	wakaba	1.6	$out->html ('(<code>null</code>)');
129	wakaba	1.1	}
130	wakaba	1.6
131			$out->start_tag ('li');
132			$out->nl_text ('xmlStandalone');
133			$out->text (' = ');
134			$out->code ($child->xml_standalone ? 'true' : 'false');
135	wakaba	1.1	}
136	wakaba	1.6
137	wakaba	1.1	$out->end_tag ('ul');
138	wakaba	1.6
139	wakaba	1.1	if ($child->has_child_nodes) {
140			$out->start_tag ('ol', class => 'children');
141			unshift @node, @{$child->child_nodes}, '</ol></li>';
142			}
143			} elsif ($nt == $child->DOCUMENT_TYPE_NODE) {
144			$out->start_tag ('li', id => $node_id, class => 'tree-doctype');
145			$out->code ('<!DOCTYPE>');
146			$out->start_tag ('ul', class => 'attributes');
147
148			$out->start_tag ('li', class => 'tree-doctype-name');
149			$out->text ('Name = ');
150			$out->code ($child->name);
151
152			$out->start_tag ('li', class => 'tree-doctype-publicid');
153			$out->text ('Public identifier = ');
154			$out->code ($child->public_id);
155
156			$out->start_tag ('li', class => 'tree-doctype-systemid');
157			$out->text ('System identifier = ');
158			$out->code ($child->system_id);
159
160			$out->end_tag ('ul');
161			} elsif ($nt == $child->PROCESSING_INSTRUCTION_NODE) {
162			$out->start_tag ('li', id => $node_id, class => 'tree-id');
163			$out->code ('<?');
164			$out->code ($child->target);
165			$out->text (' ');
166			$out->code ($child->data);
167			$out->code ('?>');
168			} else { # error
169			$out->start_tag ('li', id => $node_id, class => 'tree-unknown');
170			$out->text ($child->node_type . ' ' . $child->node_name);
171			}
172			}
173			$out->end_tag ('ol');
174
175			$out->end_section;
176			} # generate_structure_dump_section
177
178			sub generate_structure_error_section ($) {
179			my $self = shift;
180
181			my $out = $self->output;
182	wakaba	1.3	$out->start_section (role => 'structure-errors');
183			$out->start_error_list (role => 'structure-errors');
184	wakaba	1.1
185			my $input = $self->input;
186			my $result = $self->result;
187
188			require Whatpm::ContentChecker;
189			my $onerror = sub {
190	wakaba	1.2	$result->add_error (@_, layer => 'structure');
191	wakaba	1.1	};
192
193			my $onsubdoc = $self->onsubdoc;
194			if ($self->{structure}->node_type == $self->{structure}->ELEMENT_NODE) {
195			$self->{add_info} = Whatpm::ContentChecker->check_element
196			($self->{structure}, $onerror, $onsubdoc);
197			} else {
198			$self->{add_info} = Whatpm::ContentChecker->check_document
199			($self->{structure}, $onerror, $onsubdoc);
200			}
201
202	wakaba	1.3	$out->end_error_list (role => 'structure-errors');
203	wakaba	1.1	$out->end_section;
204			} # generate_structure_error_section
205	wakaba	1.3
206			sub generate_additional_sections ($) {
207			my $self = shift;
208			$self->SUPER::generate_additional_sections;
209	wakaba	1.4
210	wakaba	1.3	$self->generate_table_section;
211	wakaba	1.4
212			$self->generate_listing_section (
213			key => 'id', id => 'identifiers',
214			short_title => 'IDs', title => 'Identifiers',
215			);
216			$self->generate_listing_section (
217			key => 'term', id => 'terms',
218			short_title => 'Terms', title => 'Terms',
219			);
220			$self->generate_listing_section (
221			key => 'class', id => 'classes',
222			short_title => 'Classes', title => 'Classes',
223			);
224
225			$self->generate_rdf_section;
226	wakaba	1.3	} # generate_additional_sections
227
228			sub generate_table_section ($) {
229			my $self = shift;
230
231			my $tables = $self->{add_info}->{table} \|\| [];
232			return unless @$tables;
233
234			my $out = $self->output;
235	wakaba	1.6	$out->start_section (id => 'tables', short_title => 'Tables',
236			title => 'Tables Section');
237	wakaba	1.3
238			$out->html (q[<!--[if IE]><script type="text/javascript" src="../excanvas.js"></script><![endif]-->
239			<script src="../table-script.js" type="text/javascript"></script>
240			<noscript>
241			<p><em>Structure of tables are visualized here if scripting is enabled.</em></p>
242			</noscript>]);
243
244			require JSON;
245
246			my $i = 0;
247			for my $table (@$tables) {
248			$i++;
249	wakaba	1.5	my $index = $out->input->full_subdocument_index;
250			$index = $index ? $index . '.' . $i : $i;
251	wakaba	1.3	$out->start_section (id => 'table-' . $i,
252	wakaba	1.6	title => 'Table #',
253			text => $index);
254	wakaba	1.3
255			$out->start_tag ('dl');
256			$out->dt ('Table Element');
257			$out->start_tag ('dd');
258			$out->node_link ($table->{element});
259			$out->end_tag ('dl');
260			delete $table->{element};
261
262			for (@{$table->{column_group}}, @{$table->{column}}, $table->{caption},
263			@{$table->{row}}) {
264			next unless $_;
265			delete $_->{element};
266			}
267
268			for (@{$table->{row_group}}) {
269			next unless $_;
270			next unless $_->{element};
271			$_->{type} = $_->{element}->manakai_local_name;
272			delete $_->{element};
273			}
274
275			for (@{$table->{cell}}) {
276			next unless $_;
277			for (@{$_}) {
278			next unless $_;
279			for (@$_) {
280			$_->{id} = refaddr $_->{element} if defined $_->{element};
281			delete $_->{element};
282			$_->{is_header} = $_->{is_header} ? 1 : 0;
283			}
284			}
285			}
286
287			my $id_prefix = $self->input->id_prefix;
288			$out->script (q[tableToCanvas (] .
289			JSON::objToJson ($table) .
290			q[, document.getElementById ('] . $id_prefix . 'table-' . $i . q[')] .
291			q[, '] . $id_prefix . q[');]);
292
293			$out->end_section;
294			}
295
296			$out->end_section;
297	wakaba	1.4	} # generate_table_section
298	wakaba	1.3
299	wakaba	1.4	sub generate_listing_section ($%) {
300			my $self = shift;
301			my %opt = @_;
302	wakaba	1.3
303	wakaba	1.4	my $list = $self->{add_info}->{$opt{key}} \|\| {};
304			return unless keys %$list;
305	wakaba	1.3
306	wakaba	1.4	my $out = $self->output;
307	wakaba	1.3
308	wakaba	1.4	$out->start_section (id => $opt{id},
309			title => $opt{title},
310			short_title => $opt{short_title});
311			$out->start_tag ('dl');
312
313			for my $id (sort {$a cmp $b} keys %$list) {
314			$out->start_tag ('dt');
315			$out->code ($id);
316			for (@{$list->{$id}}) {
317			$out->start_tag ('dd');
318			$out->node_link ($_);
319	wakaba	1.3	}
320			}
321
322	wakaba	1.4	$out->end_tag ('dl');
323			$out->end_section;
324			} # generate_listing_section
325
326			my $generate_rdf_resource_html = sub ($$) {
327			my ($resource, $out) = @_;
328
329	wakaba	1.3	if (defined $resource->{uri}) {
330	wakaba	1.4	$out->url ($resource->{uri});
331	wakaba	1.3	} elsif (defined $resource->{bnodeid}) {
332	wakaba	1.4	$out->text ('_:' . $resource->{bnodeid});
333	wakaba	1.3	} elsif ($resource->{nodes}) {
334	wakaba	1.4	$out->text ('(rdf:XMLLiteral)');
335	wakaba	1.3	} elsif (defined $resource->{value}) {
336	wakaba	1.4	$out->start_tag ('q',
337			lang => defined $resource->{language}
338			? $resource->{language} : '');
339			$out->text ($resource->{value});
340			$out->end_tag ('q');
341
342	wakaba	1.3	if (defined $resource->{datatype}) {
343	wakaba	1.4	$out->text ('^^');
344			$out->url ($resource->{datatype});
345	wakaba	1.3	} elsif (length $resource->{language}) {
346	wakaba	1.4	$out->text ('@' . $resource->{language});
347	wakaba	1.3	}
348			} else {
349	wakaba	1.4	$out->text ('??'); ## NOTE: An error of the implementation.
350	wakaba	1.3	}
351	wakaba	1.4	}; # $generate_rdf_resource_html
352
353			## TODO: Should we move this method to another module,
354			## such as Base or RDF?
355			sub generate_rdf_section ($) {
356			my $self = shift;
357
358			my $list = $self->{add_info}->{rdf} \|\| [];
359			return unless @$list;
360
361			my $out = $self->output;
362			$out->start_section (id => 'rdf', short_title => 'RDF',
363			title => 'RDF Triples');
364			$out->start_tag ('dl');
365
366			my $i = 0;
367			for my $rdf (@$list) {
368			$out->start_tag ('dt', id => 'rdf-' . $i++);
369			$out->node_link ($rdf->[0]);
370			$out->start_tag ('dd');
371			$out->start_tag ('dl');
372			for my $triple (@{$rdf->[1]}) {
373			$out->start_tag ('dt');
374			$out->node_link ($triple->[0]);
375			$out->start_tag ('dd');
376			$out->text ('Subject: ');
377			$generate_rdf_resource_html->($triple->[1] => $out);
378			$out->start_tag ('dd');
379			$out->text ('Predicate: ');
380			$generate_rdf_resource_html->($triple->[2] => $out);
381			$out->start_tag ('dd');
382			$out->text ('Object: ');
383			$generate_rdf_resource_html->($triple->[3] => $out);
384			}
385			$out->end_tag ('dl');
386			}
387			$out->end_tag ('dl');
388			$out->end_section;
389			} # generate_rdf_section
390	wakaba	1.1
391			1;