ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

root/cvsroot/COMP/SCRAM/src/ActiveDoc/ActiveDoc.pm

Comparing COMP/SCRAM/src/ActiveDoc/ActiveDoc.pm (file contents):
Revision 1.5 by williamc, Wed Sep 29 07:47:06 1999 UTC vs.
Revision 1.14 by williamc, Tue Jan 18 18:30:10 2000 UTC

#	Line 1 | Line 1
1		#
2	<	# The base functionality for the ActiveDocument - inherits from Basetags
2	>	# ActiveDoc.pm
3	>	#
4	>	# Originally Written by Christopher Williams
5	>	#
6	>	# Description
7		#
4	–	# Inherits from BaseTags
5	–	# --------
8		# Interface
9		# ---------
10	<	# new(filename, DOChandler): create a new object based on a file and
11	<	#                                 associate with a base DOChandler
12	<	# parse()                       : parse the input file
13	<	# include(url) : Activate include file mechanism, returns the object ref if OK
14	<	# treenode()   : return the associated TreeNode object reference
15	<	# getincludeObjectStore : Return a pointer to the ObectStore that contains all
16	<	#                         included objects
17	<	# find(string)  : find the object reference related to string in the associated
18	<	#                 tree. Mechanism for getting object references
19	<	# _addgroup()   : Add group functionality to document
20	<	# parseerror(String) : Report an error to the user
21	<	# userinterface()       : return the default User Interface object
22	<	# checktag($hashref, param , tagname) : Check a hash returned from switcher
23	<	#                                       for a given parameter
10	>	# new()         : A new ActiveDoc object
11	>	# url()         : Return/set the docs url - essential
12	>	# file()        : Return the local filename of document
13	>	#
14	>	# parse(parselabel): Parse the document file for the given parse level
15	>	# newparse(parselabel) : Create a new parse type
16	>	# addtag(parselabel,tagname,start,obj,text,obj,end,obj)
17	>	#                               : Add tags to the parse given by label
18	>	# checktag(tagname, hashref, param) : check for existence of param in
19	>	#                                       hashref from a tag call
20	>	# includeparse(local_parsename, objparsename, activedoc) : copy the parse from
21	>	#                                                       one object to another
22	>	# currentparsename([name]) : get/set current parse name
23	>	# newdoc(file)  : Return an new object of the appropriate type
24	>	# getfile(url)  : get a processedfile object given a url
25	>	# activatedoc(url) : Return the object ref for a doc described by the given url
26	>	#                    -- any parse called "init" will also be run
27	>	# config([ActiveConfig]) : Set up/return Configuration for the document
28	>	# basequery([ActiveConfig]) : Set up/return UserQuery for the doc
29	>	# copydocconfig(ActiveDoc) : Copy the basic configuration from the ActiveDoc
30	>	# copydocquery(ActiveDoc) : Copy the basicquery from the ActiveDoc
31	>	# userinterface()       : Return the defaullt userinterface
32	>	# option(var)           : return the value of the option var
33	>	# requestoption("message") : Ask the user to supply a value for an option
34	>	#                            if it dosnt already exist
35	>	#
36	>	# -- error methods --
37	>	# error(string)       : Report an general error to the user
38	>	# parseerror(string)  : Report an error during parsing a file
39	>	# line()              : Return the current line number of the document
40	>	#                       and the ProcessedFileObj it is in
41
42		package ActiveDoc::ActiveDoc;
43	<	require 5.001;
44	<	use ActiveDoc::DOChandler;
45	<	use ActiveDoc::TreeNode;
46	<	use ActiveDoc::UserQuery;
47	<	use ObjectStoreCont;
48	<
49	<	@ISA = qw(ActiveDoc::BaseTags);
50	<
51	<	# Initialise
52	<	sub _init {
53	<	my $self=shift;
54	<	my $DOChandler=shift;
55	<	my $OC=shift;
56	<
57	<	$self->_addurl();
58	<	$self->{urlhandler}->setcache($DOChandler->defaultcache());
59	<	$self->{treenode}=ActiveDoc::TreeNode->new();
60	<	$self->{dochandler}=$DOChandler;
61	<	$self->{UserQuery}=$DOChandler->{UserQuery};
62	<	$self->{tags}->addtag("Use", \&Use_Start, "", "");
63	<	# Add the minimal functionality tag - feel free to override
64	<	$self->{tags}->addtag("Include", \&Include_Start, "", "");
65	<	$self->init();
43	>	require 5.004;
44	>	use ActiveDoc::Parse;
45	>	use ActiveDoc::ActiveConfig;
46	>	use ActiveDoc::PreProcessedFile;
47	>	use ObjectUtilities::StorableObject;
48	>	use URL::URLhandler;
49	>
50	>	@ISA = qw(ObjectUtilities::StorableObject);
51	>
52	>	sub new {
53	>	my $class=shift;
54	>	$self={};
55	>	bless $self, $class;
56	>	$self->config(shift);
57	>
58	>	# --- is there a starter document?
59	>	my $basedoc=$self->config()->basedoc();
60	>	if ( defined $basedoc ) {
61	>	$self->copydocquery($basedoc);
62	>	}
63	>	else {
64	>	$self->error("Error : No base doc found");
65	>	}
66	>	$self->_init2();
67		}
68
69	<	sub init {
70	<	# Dummy Routine - override for derrived classes
69	>	sub _init2 {
70	>
71	>	my $self=shift;
72	>	# A URL handler per document
73	>	$self->{urlhandler}=URL::URLhandler->new($self->config()->cache());
74	>
75	>	# A default UserInterface
76	>	$self->{userinterface}=ActiveDoc::SimpleUserInterface->new();
77	>	$self->init(@_);
78	>	return $self;
79	>
80		}
81	<	#
82	<	# use mechanism
83	<	#
84	<	sub include {
85	<	my $self=shift;
86	<	my $url=shift;
87	<	my $linkfile=shift;
88	<	my $filename;
89	<	my $obj;
90	<
91	<	$file=$self->{urlhandler}->get($url);
92	<	if ( ( defined $linkfile) && ( $linkfile ne "" ) ) {
93	<	$filename=$file."/".$linkfile;
81	>
82	>	# ----- parse related routines --------------
83	>	sub parse {
84	>	my $self=shift;
85	>	$parselabel=shift;
86	>
87	>	my $file=$self->file();
88	>	if ( $file ) {
89	>	if ( exists $self->{parsers}{$parselabel} ) {
90	>	$self->{currentparsename}=$parselabel;
91	>	$self->{currentparser}=$self->{parsers}{$parselabel};
92	>	$self->{parsers}{$parselabel}->parse($file,@_);
93	>	delete $self->{currentparser};
94	>	$self->{currentparsename}="";
95	>	}
96		}
97		else {
98	<	$filename=$file;
98	>	print "Cannot parse - file not known\n";
99		}
100	<	$obj=$self->{dochandler}->newdoc($filename);
100	>	}
101
102	<	# Now Extend our tree
103	<	$self->{treenode}->grow($obj->treenode());
104	<	return $obj;
102	>	sub currentparsename {
103	>	my $self=shift;
104	>	@_?$self->{currentparsename}=shift
105	>	:$self->{currentparsename};
106		}
107
108	<	sub userinterface {
108	>	sub newparse {
109		my $self=shift;
110	<	return $self->{dochandler}->{UserInterface};
110	>	my $parselabel=shift;
111	>
112	>	$self->{parsers}{$parselabel}=ActiveDoc::Parse->new();
113	>	$self->{parsers}{$parselabel}->addignoretags();
114	>	$self->{parsers}{$parselabel}->addgrouptags();
115		}
116
117	<	sub treenode {
117	>	sub cleartags {
118		my $self=shift;
119	<	return $self->{treenode};
119	>	my $parselabel=shift;
120	>
121	>	$self->{parsers}{$parselabel}->cleartags();
122		}
123
124	<	sub getincludeObjectStore {
125	<	my $self=shift;
126	<	return $self->{includeOS};
124	>
125	>	sub includeparse {
126	>	my $self=shift;
127	>	my $parselabel=shift;
128	>	my $remoteparselabel=shift;
129	>	my $activedoc=shift;
130	>
131	>	# Some error trapping
132	>	if ( ! exists $self->{parsers}{$parselabel} ) {
133	>	$self->error("Unknown local parse name specified");
134	>	}
135	>	if ( ! exists $activedoc->{parsers}{$remoteparselabel} ) {
136	>	$self->error("Unknown parse name specified in remote obj $activedoc");
137	>	}
138	>
139	>	#
140	>	my $rp=$activedoc->{parsers}{$remoteparselabel};
141	>	$self->{parsers}{$parselabel}->includeparse($rp);
142	>	}
143	>
144	>	sub addtag {
145	>	my $self=shift;
146	>	my $parselabel=shift;
147	>	if ( $#_ != 6 ) {
148	>	$self->error("Incorrect addtags specification\n".
149	>	"called with :\n@_ \n");
150	>	}
151	>	$self->{parsers}{$parselabel}->addtag(@_);
152	>	}
153	>
154	>	sub addurltags {
155	>	my $self=shift;
156	>	my $parselabel=shift;
157	>
158	>	$self->{parsers}{$parselabel}->
159	>	addtag("Base", \&Base_start, $self, "", $self,
160	>	\&Base_end, $self);
161	>	}
162	>
163	>	sub url {
164	>	my $self=shift;
165	>	# get file & preprocess
166	>	if ( @_  ) {$self->{File}=$self->getfile(shift)}
167	>	$self->{File}->url();
168	>	}
169	>
170	>	sub copydocconfig {
171	>	my $self=shift;
172	>	my $ActiveDoc=shift;
173	>
174	>	$self->config($ActiveDoc->config());
175	>
176	>	}
177	>
178	>	sub copydocquery {
179	>	my $self=shift;
180	>	my $ActiveDoc=shift;
181	>
182	>	$self->basequery($ActiveDoc->basequery());
183	>	}
184	>
185	>	sub config {
186	>	my $self=shift;
187	>	@_?$self->{ActiveConfig}=shift
188	>	: $self->{ActiveConfig};
189	>	}
190	>
191	>	sub basequery {
192	>	my $self=shift;
193	>	@_ ? $self->{Query}=shift
194	>	: $self->{Query};
195	>	}
196	>
197	>	sub option {
198	>	my $self=shift;
199	>	my $param=shift;
200	>	$self->basequery()->getparam($param);
201		}
202
203	<	sub find($) {
203	>	sub requestoption {
204		my $self=shift;
205	+	my $param=shift;
206		my $string=shift;
94	–	my $tn;
207
208	<	$tn=$self->{treenode}->find($string);
209	<	if ( $tn eq "" ) {
210	<	$self->parseerror("Unable to find $string");
208	>	my $par=$self->basequery()->getparam($param);
209	>	while ( ! defined $par ) {
210	>	$self->basequery()->querytype( $param, "basic");
211	>	$self->basequery()->querymessage( $param, $string);
212	>	$self->userinterface()->askuser($self->basequery());
213	>	$par=$self->basequery()->getparam('ActiveConfigdir');
214	>	}
215	>	return $par;
216	>	}
217	>
218	>	sub getfile() {
219	>	my $self=shift;
220	>	my $origurl=shift;
221	>
222	>	my $fileref;
223	>	my ($url, $file)=$self->{urlhandler}->get($origurl);
224	>	# do we already have an appropriate object?
225	>	($fileref)=$self->config()->find($url);
226	>	#undef $fileref;
227	>	if (  defined $fileref ) {
228	>	print "found $url in database ----\n";
229	>	$fileref->update();
230		}
231	<	return $tn->associate();
231	>	else {
232	>	if ( $file eq "" ) {
233	>	$self->parseerror("Unable to get $origurl");
234	>	}
235	>	#-- set up a new preprocess file
236	>	print "Making a new file $url----\n";
237	>	$fileref=ActiveDoc::PreProcessedFile->new($self->config());
238	>	$fileref->url($url);
239	>	$fileref->update();
240	>	}
241	>	return $fileref;
242		}
243
244	<	sub line {
244	>	sub activatedoc {
245		my $self=shift;
246	<	return $self->{switch}->line();
246	>	my $url=shift;
247	>
248	>	# first get a preprocessed copy of the file
249	>	#       my $fileob=$self->getfile($url);
250	>
251	>	# now parse it for the <DocType> tag
252	>	my $tempdoc=ActiveDoc::ActiveDoc->new($self->config());
253	>	$tempdoc->url($url);
254	>	$tempdoc->{doctypefound}=0;
255	>	$tempdoc->newparse("doctype");
256	>	$tempdoc->addtag("doctype","Doc", \&Doc_Start, $tempdoc,
257	>	"", $tempdoc, "", $tempdoc);
258	>	$tempdoc->parse("doctype");
259	>
260	>	if ( ! defined $tempdoc->{docobject} ) {
261	>	print "No <Doc type=> Specified in ".$url."\n";
262	>	exit 1;
263	>	}
264	>	# Set up a new object of the specified type
265	>	eval "require $tempdoc->{docobject}";
266	>	die $@ if $@;
267	>	my $newobj=$tempdoc->{docobject}->new($self->config());
268	>	undef $tempdoc;
269	>	$newobj->url($url);
270	>	$newobj->_initparse();
271	>	return $newobj;
272		}
273
274	<	sub error {
274	>	sub _initparse {
275		my $self=shift;
110	–	my $string=shift;
276
277	<	die $string."\n";
277	>	$self->parse("init");
278	>	}
279	>	# -------- Error Handling and Error services --------------
280	>
281	>	sub error {
282	>	my $self=shift;
283	>	my $string=shift;
284
285	+	die $string."\n";
286		}
287	+
288		sub parseerror {
289	<	my $self=shift;
290	<	my $string=shift;
289	>	my $self=shift;
290	>	my $string=shift;
291
292	<	print "Parse Error in $self->{url}, line ".
293	<	$self->line()."\n";
294	<	print $string."\n";
295	<	die;
292	>	($line, $file)=$self->line();
293	>	print "Parse Error in ".$file->url().", line ".
294	>	$line."\n";
295	>	print $string."\n";
296	>	die;
297		}
298
299		sub checktag {
300	+	my $self=shift;
301	+	my $tagname=shift;
302	+	my $hashref=shift;
303	+	my $param=shift;
304	+
305	+	if ( ! exists $$hashref{$param} ) {
306	+	$self->parseerror("Incomplete Tag <$tagname> : $param required");
307	+	}
308	+	}
309	+
310	+	sub line {
311		my $self=shift;
127	–	my $hashref=shift;
128	–	my $param=shift;
129	–	my $tagname=shift;
312
313	<	if ( ! exists $$hashref{$param} ) {
314	<	$self->parseerror("Incomplete Tag <$tagname> : $param required");
315	<	}
313	>	my ($line, $fileobj)=
314	>	$self->{File}->realline($self->{currentparser}->line());
315	>	return ($line, $fileobj);
316		}
317
318	<	# ------------------------ Tag Routines ------------------------------
318	>	sub tagstartline {
319	>	my $self=shift;
320	>	my ($line, $fileobj)=$self->{File}->line(
321	>	$self->{currentparser}->tagstartline());
322	>	return ($line, $fileobj);
323	>	}
324	>
325	>	sub file {
326	>	my $self=shift;
327	>
328	>	$self->{File}->file();
329	>	}
330	>
331	>	# --------------- Initialisation Methods ---------------------------
332	>
333	>	sub init {
334	>	# Dummy Routine - override for derived classes
335	>	}
336	>
337	>	# ------------------- Tag Routines -----------------------------------
338		#
339	<	# The Include tag
339	>	# Base - for setting url bases
340		#
341	+	sub Base_start {
342	+	my $self=shift;
343	+	my $name=shift;
344	+	my $hashref=shift;
345
346	<	sub Include_Start {
346	>	$self->checktag($name, $hashref, 'type' );
347	>	$self->checktag($name, $hashref, 'base' );
348	>
349	>	# Keep track of base tags
350	>	push @{$self->{basestack}}, $$hashref{"type"};
351	>	# Set the base
352	>	$self->{urlhandler}->setbase($$hashref{"type"},$hashref);
353	>
354	>	}
355	>
356	>	sub Base_end {
357	>	my $self=shift;
358	>	my $name=shift;
359	>	my $type;
360	>
361	>	if ( $#{$self->{basestack}} == -1 ) {
362	>	print "Parse Error : unmatched </".$name."> on line ".
363	>	$self->line()."\n";
364	>	die;
365	>	}
366	>	else {
367	>	$type = pop @{$self->{basestack}};
368	>	$self->{urlhandler}->unsetbase($type);
369	>	}
370	>	}
371	>
372	>	sub Doc_Start {
373		my $self=shift;
374		my $name=shift;
375		my $hashref=shift;
376	<
377	<	$self->{switch}->checkparam( $name, "ref");
378	<	print "<Include> tag not yet implemented\n";
379	<	#        $self->include($$hashref{'ref'},$$hashref{'linkdoc'});
376	>
377	>	$self->checktag($name, $hashref, "type");
378	>	$self->{doctypefound}++;
379	>	if ( $self->{doctypefound} == 1 ) { # only take first doctype
380	>	$self->{docobject}=$$hashref{'type'};
381	>	}
382		}
383
384	<	sub Use_Start {
384	>	sub userinterface {
385		my $self=shift;
386	<	my $name=shift;
387	<	my $hashref=shift;
155	<
156	<	print "<Use> tag not yet implemented\n";
386	>	@_?$self->{userinterface}=shift
387	>	:$self->{userinterface}
388		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines