manakai/bin/dis2rdf.pl

#!/usr/bin/perl -w 
use strict;

use Getopt::Long;
use Pod::Usage;
my %Opt;
GetOptions (
  'for=s' => \$Opt{For},
  'help' => \$Opt{help},
  'no-undef-check' => \$Opt{no_undef_check},
  'output-class' => \$Opt{output_class},
  'output-for' => \$Opt{output_for},
  'output-local-class' => \$Opt{output_local_class},
  'output-module' => \$Opt{output_module},
) or pod2usage (2);
if ($Opt{help}) {
  pod2usage (0);
  exit;
}

BEGIN {
require 'manakai/genlib.pl';
require 'manakai/dis.pl';
}
sub n3_literal ($) {
  my $s = shift;
  qq<"$s">;
}
our $State;
our $result = new manakai::n3;

$Opt{file_name} = shift;

$State->{DefaultFor} = $Opt{For};

my $source = dis_load_module_file (module_file_name => $Opt{file_name},
                                   For => $Opt{For},
                                   use_default_for => 1);
$State->{for_def_required}->{$State->{DefaultFor}} ||= 1;

dis_check_undef_type_and_for ()
  unless $Opt{no_undef_check};

my $primary = $result->get_new_anon_id;
$result->add_triple ($primary =>ExpandedURI q<d:module>=> $State->{module})
                if $Opt{output_module};
$result->add_triple ($primary =>ExpandedURI q<d:DefaultFor> => $State->{DefaultFor})
                if $Opt{output_for};

if ($Opt{output_module}) {
for (keys %{$State->{Module}}) {
  my $mod = $State->{Module}->{$_};
  if ($_ eq $mod->{URI}) {
    $result->add_triple ($mod->{URI} =>ExpandedURI q<rdf:type>=>
                         ExpandedURI q<d:Module>);
    $result->add_triple ($mod->{URI} =>ExpandedURI q<d:Name>=>
                         n3_literal $mod->{Name});
    $result->add_triple ($mod->{URI} =>ExpandedURI q<d:NameURI>=>
                         $mod->{NameURI});
    $result->add_triple ($mod->{URI} =>ExpandedURI q<d:ModuleGroup>=>
                         $mod->{ModuleGroup});
    $result->add_triple ($mod->{URI} =>ExpandedURI q<d:FileName>=>
                         n3_literal $mod->{FileName})
      if defined $mod->{FileName};
    $result->add_triple ($mod->{URI} =>ExpandedURI q<d:Namespace>=>
                         $mod->{Namespace});
    for (@{$mod->{require_module}||[]}) {
      $result->add_triple ($mod->{URI} =>ExpandedURI q<d:Require>=> $_);
    }
    for (keys %{$mod->{For}}) {
      $result->add_triple ($mod->{URI} =>ExpandedURI q<d:For>=> $_);
    }
    for (keys %{$mod->{ISA}}) {
      $result->add_triple ($mod->{URI} =>ExpandedURI q<rdfs:subClassOf>=> $_);
    }
  } else {
    $result->add_triple ($_ =>ExpandedURI q<owl:sameAs>=> $mod->{URI});
  }
}}

if ($Opt{output_for}) {
for (keys %{$State->{For}}) {
  my $mod = $State->{For}->{$_};
  if ($_ eq $mod->{URI}) {
    $result->add_triple ($mod->{URI} =>ExpandedURI q<rdf:type>=>
                         ExpandedURI q<d:For>);
    $result->add_triple ($mod->{URI} =>ExpandedURI q<d:NameURI>=> $mod->{URI});
    $result->add_triple ($mod->{URI} =>ExpandedURI q<d:FullName>=>
                         n3_literal $mod->{FullName});
    for (keys %{$mod->{ISA}}) {
      $result->add_triple ($mod->{URI} =>ExpandedURI q<rdfs:subClassOf>=> $_);
    }
    for (keys %{$mod->{Implement}}) {
      $result->add_triple ($mod->{URI} =>ExpandedURI q<d:Implement>=> $_);
    }
  } else {
    $result->add_triple ($_ =>ExpandedURI q<owl:sameAs>=> $mod->{URI});
  }
}}

if ($Opt{output_class}) {
  sub class_to_rdf ($;%);
  sub class_to_rdf ($;%) {
    my ($mod, %opt) = @_;
    return unless defined $mod->{Name};
    if ((defined $mod->{URI} and $opt{key} eq $mod->{URI}) or
        not defined $mod->{URI}) {
      my $uri = defined $mod->{URI} ? $mod->{URI} : $result->get_new_anon_id;
      $result->add_triple ($uri =>ExpandedURI q<d:Name>=>
                           n3_literal $mod->{Name}) if length $mod->{Name};
      $result->add_triple ($uri =>ExpandedURI q<d:NameURI>=> $mod->{NameURI})
        if defined $mod->{NameURI};
      $result->add_triple ($uri =>ExpandedURI q<d:parentClass>=>
                           $opt{parent_class_uri})
        if defined $opt{parent_class_uri};
      for (keys %{$mod->{Type}}) {
        $result->add_triple ($uri =>ExpandedURI q<rdf:type>=> $_);
      }
      for (keys %{$mod->{ISA}}) {
        $result->add_triple ($uri =>ExpandedURI q<rdfs:subClassOf>=> $_);
      }
      for (keys %{$mod->{Implement}}) {
        $result->add_triple ($uri =>ExpandedURI q<d:Implement>=> $_);
      }
      if ($Opt{output_local_class}) {
        for (keys %{$mod->{Class}}) {
          class_to_rdf ($mod->{Class}->{$_}, parent_class => $mod,
                        parent_class_uri => $uri,
                        key => $_);
        }
      }
    } else { ## Alias URI
      $result->add_triple ($_ =>ExpandedURI q<owl:sameAs>=> $mod->{URI});
    }
  }
  for (keys %{$State->{Type}}) {
    class_to_rdf ($State->{Type}->{$_}, key => $_);
  }
}

print $result->stringify_as_xml;

package manakai::n3;
sub new ($) {
  bless {triple => [], anon => 0}, shift;
}

sub get_new_anon_id ($) {
  my ($self) = @_;
  return sprintf '_:r%d', $self->{anon}++;
}

sub add_triple ($$$$) {
  my ($self, $s =>$p=> $o) = @_;
  push @{$self->{triple}}, [$s =>$p=> $o];
}

sub stringify ($) {
  my ($self) = @_;
  return join "\n", (map {"$_."} map {
    sprintf '%s %s %s', map {
      $_ =~ /^[_"]/ ? $_ : "<$_>"
    } @{$_}[0, 1, 2];
  } @{$self->{triple}}), '';
}

sub stringify_as_xml ($) {
  my ($self) = @_;
  use RDF::Notation3::XML;
  my $notation3 = RDF::Notation3::XML->new;
  $notation3->parse_string ($self->stringify);
  my $xml = $notation3->get_string;
  $xml =~ s/\brdf:nodeID="_:/rdf:nodeID="/g;
#  $xml =~ s/^<\?xml version="1.0" encoding="utf-8"\?>\s*//;
  $xml;
}

1;

__END__

=head1 NAME

dis2rdf.pl - dis to RDF converter

=head1 SYNOPSIS

  $ perl dis2rdf.pl input.dis [options...] > output.rdf

=head1 DESCRIPTION

This script generates a RDF graph from a "dis" file.

=over 4

=item I<input.dis>

The "dis" file from which a RDF graph is generated.

=item I<output.rdf>

An RDF/XML entity is outputed.

=item C<--output-module>

Show the relationship of modules.

=item C<--output-type>

Show the relationship of types.

=item C<--output-for>

Show the relationship of "for"s.

=cut

=head1 LICENSE

Copyright 2004 Wakaba <w@suika.fam.cx>.  All rights reserved.

This program is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.

Note that the copyright holder(s) of this script does not claim 
any rights for materials outputed by this script, although 
some of its part comes from this script.  The copyright 
holder(s) of source document should define their license terms.

=cut
1	wakaba	1.1	#!/usr/bin/perl -w
2			use strict;
3
4			use Getopt::Long;
5			use Pod::Usage;
6			my %Opt;
7			GetOptions (
8			'for=s' => \$Opt{For},
9			'help' => \$Opt{help},
10	wakaba	1.2	'no-undef-check' => \$Opt{no_undef_check},
11			'output-class' => \$Opt{output_class},
12	wakaba	1.1	'output-for' => \$Opt{output_for},
13	wakaba	1.2	'output-local-class' => \$Opt{output_local_class},
14	wakaba	1.1	'output-module' => \$Opt{output_module},
15			) or pod2usage (2);
16			if ($Opt{help}) {
17			pod2usage (0);
18			exit;
19			}
20
21			BEGIN {
22			require 'manakai/genlib.pl';
23			require 'manakai/dis.pl';
24			}
25			sub n3_literal ($) {
26			my $s = shift;
27			qq<"$s">;
28			}
29			our $State;
30			our $result = new manakai::n3;
31
32			$Opt{file_name} = shift;
33
34			$State->{DefaultFor} = $Opt{For};
35	wakaba	1.2
36	wakaba	1.1	my $source = dis_load_module_file (module_file_name => $Opt{file_name},
37	wakaba	1.2	For => $Opt{For},
38	wakaba	1.1	use_default_for => 1);
39			$State->{for_def_required}->{$State->{DefaultFor}} \|\|= 1;
40
41	wakaba	1.2	dis_check_undef_type_and_for ()
42			unless $Opt{no_undef_check};
43	wakaba	1.1
44			my $primary = $result->get_new_anon_id;
45			$result->add_triple ($primary =>ExpandedURI q<d:module>=> $State->{module})
46			if $Opt{output_module};
47			$result->add_triple ($primary =>ExpandedURI q<d:DefaultFor> => $State->{DefaultFor})
48			if $Opt{output_for};
49
50			if ($Opt{output_module}) {
51			for (keys %{$State->{Module}}) {
52			my $mod = $State->{Module}->{$_};
53	wakaba	1.2	if ($_ eq $mod->{URI}) {
54			$result->add_triple ($mod->{URI} =>ExpandedURI q<rdf:type>=>
55			ExpandedURI q<d:Module>);
56			$result->add_triple ($mod->{URI} =>ExpandedURI q<d:Name>=>
57	wakaba	1.1	n3_literal $mod->{Name});
58	wakaba	1.2	$result->add_triple ($mod->{URI} =>ExpandedURI q<d:NameURI>=>
59			$mod->{NameURI});
60			$result->add_triple ($mod->{URI} =>ExpandedURI q<d:ModuleGroup>=>
61			$mod->{ModuleGroup});
62			$result->add_triple ($mod->{URI} =>ExpandedURI q<d:FileName>=>
63	wakaba	1.1	n3_literal $mod->{FileName})
64			if defined $mod->{FileName};
65	wakaba	1.2	$result->add_triple ($mod->{URI} =>ExpandedURI q<d:Namespace>=>
66			$mod->{Namespace});
67	wakaba	1.1	for (@{$mod->{require_module}\|\|[]}) {
68	wakaba	1.2	$result->add_triple ($mod->{URI} =>ExpandedURI q<d:Require>=> $_);
69			}
70			for (keys %{$mod->{For}}) {
71			$result->add_triple ($mod->{URI} =>ExpandedURI q<d:For>=> $_);
72			}
73			for (keys %{$mod->{ISA}}) {
74			$result->add_triple ($mod->{URI} =>ExpandedURI q<rdfs:subClassOf>=> $_);
75	wakaba	1.1	}
76			} else {
77	wakaba	1.2	$result->add_triple ($_ =>ExpandedURI q<owl:sameAs>=> $mod->{URI});
78	wakaba	1.1	}
79			}}
80
81			if ($Opt{output_for}) {
82			for (keys %{$State->{For}}) {
83			my $mod = $State->{For}->{$_};
84	wakaba	1.2	if ($_ eq $mod->{URI}) {
85			$result->add_triple ($mod->{URI} =>ExpandedURI q<rdf:type>=>
86			ExpandedURI q<d:For>);
87			$result->add_triple ($mod->{URI} =>ExpandedURI q<d:NameURI>=> $mod->{URI});
88			$result->add_triple ($mod->{URI} =>ExpandedURI q<d:FullName>=>
89			n3_literal $mod->{FullName});
90			for (keys %{$mod->{ISA}}) {
91			$result->add_triple ($mod->{URI} =>ExpandedURI q<rdfs:subClassOf>=> $_);
92	wakaba	1.1	}
93	wakaba	1.2	for (keys %{$mod->{Implement}}) {
94			$result->add_triple ($mod->{URI} =>ExpandedURI q<d:Implement>=> $_);
95	wakaba	1.1	}
96			} else {
97	wakaba	1.2	$result->add_triple ($_ =>ExpandedURI q<owl:sameAs>=> $mod->{URI});
98	wakaba	1.1	}
99			}}
100
101	wakaba	1.2	if ($Opt{output_class}) {
102			sub class_to_rdf ($;%);
103			sub class_to_rdf ($;%) {
104			my ($mod, %opt) = @_;
105			return unless defined $mod->{Name};
106			if ((defined $mod->{URI} and $opt{key} eq $mod->{URI}) or
107			not defined $mod->{URI}) {
108			my $uri = defined $mod->{URI} ? $mod->{URI} : $result->get_new_anon_id;
109			$result->add_triple ($uri =>ExpandedURI q<d:Name>=>
110			n3_literal $mod->{Name}) if length $mod->{Name};
111			$result->add_triple ($uri =>ExpandedURI q<d:NameURI>=> $mod->{NameURI})
112			if defined $mod->{NameURI};
113			$result->add_triple ($uri =>ExpandedURI q<d:parentClass>=>
114			$opt{parent_class_uri})
115			if defined $opt{parent_class_uri};
116			for (keys %{$mod->{Type}}) {
117			$result->add_triple ($uri =>ExpandedURI q<rdf:type>=> $_);
118			}
119			for (keys %{$mod->{ISA}}) {
120			$result->add_triple ($uri =>ExpandedURI q<rdfs:subClassOf>=> $_);
121			}
122			for (keys %{$mod->{Implement}}) {
123			$result->add_triple ($uri =>ExpandedURI q<d:Implement>=> $_);
124			}
125			if ($Opt{output_local_class}) {
126			for (keys %{$mod->{Class}}) {
127			class_to_rdf ($mod->{Class}->{$_}, parent_class => $mod,
128			parent_class_uri => $uri,
129			key => $_);
130			}
131			}
132			} else { ## Alias URI
133			$result->add_triple ($_ =>ExpandedURI q<owl:sameAs>=> $mod->{URI});
134	wakaba	1.1	}
135			}
136	wakaba	1.2	for (keys %{$State->{Type}}) {
137			class_to_rdf ($State->{Type}->{$_}, key => $_);
138			}
139			}
140	wakaba	1.1
141			print $result->stringify_as_xml;
142
143			package manakai::n3;
144			sub new ($) {
145			bless {triple => [], anon => 0}, shift;
146			}
147
148			sub get_new_anon_id ($) {
149			my ($self) = @_;
150			return sprintf '_:r%d', $self->{anon}++;
151			}
152
153			sub add_triple ($$$$) {
154			my ($self, $s =>$p=> $o) = @_;
155			push @{$self->{triple}}, [$s =>$p=> $o];
156			}
157
158			sub stringify ($) {
159			my ($self) = @_;
160			return join "\n", (map {"$_."} map {
161			sprintf '%s %s %s', map {
162			$_ =~ /^[_"]/ ? $_ : "<$_>"
163			} @{$_}[0, 1, 2];
164			} @{$self->{triple}}), '';
165			}
166
167			sub stringify_as_xml ($) {
168			my ($self) = @_;
169			use RDF::Notation3::XML;
170			my $notation3 = RDF::Notation3::XML->new;
171			$notation3->parse_string ($self->stringify);
172	wakaba	1.2	my $xml = $notation3->get_string;
173			$xml =~ s/\brdf:nodeID="_:/rdf:nodeID="/g;
174			# $xml =~ s/^<\?xml version="1.0" encoding="utf-8"\?>\s*//;
175			$xml;
176	wakaba	1.1	}
177
178			1;
179
180			__END__
181
182			=head1 NAME
183
184			dis2rdf.pl - dis to RDF converter
185
186			=head1 SYNOPSIS
187
188			$ perl dis2rdf.pl input.dis [options...] > output.rdf
189
190			=head1 DESCRIPTION
191
192			This script generates a RDF graph from a "dis" file.
193
194			=over 4
195
196			=item I<input.dis>
197
198			The "dis" file from which a RDF graph is generated.
199
200			=item I<output.rdf>
201
202			An RDF/XML entity is outputed.
203
204			=item C<--output-module>
205
206			Show the relationship of modules.
207
208			=item C<--output-type>
209
210			Show the relationship of types.
211
212			=item C<--output-for>
213
214			Show the relationship of "for"s.
215
216			=cut
217
218			=head1 LICENSE
219
220			Copyright 2004 Wakaba <w@suika.fam.cx>. All rights reserved.
221
222			This program is free software; you can redistribute it and/or
223			modify it under the same terms as Perl itself.
224
225			Note that the copyright holder(s) of this script does not claim
226			any rights for materials outputed by this script, although
227			some of its part comes from this script. The copyright
228			holder(s) of source document should define their license terms.
229
230			=cut