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.1 by williamc, Fri Aug 20 09:09:28 1999 UTC vs.
Revision 1.15 by williamc, Thu Jan 20 18:18:45 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, ObjectStoreCont): create a new object based on a file and
11	<	#                                 associate with the given ObjectStoreCont
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
10	>	# new(ActiveConfig[,options])           : 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.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	>	# have some override options been passed
59	>	if ( @_ ) {
60	>	$self->basequery(shift);
61	>	}
62	>	else {
63	>	# --- is there a starter document?
64	>	my $basedoc=$self->config()->basedoc();
65	>	if ( defined $basedoc ) {
66	>	$self->copydocquery($basedoc);
67	>	}
68	>	else {
69	>	$self->error("Error : No base doc found");
70	>	}
71	>	}
72	>	$self->_init2();
73	>	}
74	>
75	>	sub _init2 {
76
77	+	my $self=shift;
78	+	# A URL handler per document
79	+	$self->{urlhandler}=URL::URLhandler->new($self->config()->cache());
80
81	<	package ActiveDoc;
82	<	use BaseTags;
83	<	use DOChandler;
84	<	use ObjectStoreCont;
81	>	# A default UserInterface
82	>	$self->{userinterface}=ActiveDoc::SimpleUserInterface->new();
83	>	$self->init(@_);
84	>	return $self;
85
86	<	@ISA = qw (BaseTags);
86	>	}
87
88	<	# Initialise
89	<	sub _init {
88	>	# ----- parse related routines --------------
89	>	sub parse {
90		my $self=shift;
91	<	my $OC=shift;
91	>	$parselabel=shift;
92
93	<	$self->_addurl();
94	<	$self->{OC}=$OC;
95	<	$self->{treenode)=TreeNode->new();
96	<	$self->{includeOS}=$self->{OC}->newStore();
97	<	$self->{dochandler}=DOChandler->new($self->{includeOS});
98	<	# Add the minimal functionality tag - feel free to override
99	<	$self->{tags}->addtag("Include", \&Include_Start, "", "");
93	>	my $file=$self->file();
94	>	if ( $file ) {
95	>	if ( exists $self->{parsers}{$parselabel} ) {
96	>	$self->{currentparsename}=$parselabel;
97	>	$self->{currentparser}=$self->{parsers}{$parselabel};
98	>	$self->{parsers}{$parselabel}->parse($file,@_);
99	>	delete $self->{currentparser};
100	>	$self->{currentparsename}="";
101	>	}
102	>	}
103	>	else {
104	>	print "Cannot parse - file not known\n";
105	>	}
106		}
107
108	<	#
109	<	# Include mechanism
110	<	#
111	<	sub include {
112	<	my $self=shift;
113	<	my $url=shift;
114	<	my $obj;
108	>	sub currentparsename {
109	>	my $self=shift;
110	>	@_?$self->{currentparsename}=shift
111	>	:$self->{currentparsename};
112	>	}
113	>
114	>	sub newparse {
115	>	my $self=shift;
116	>	my $parselabel=shift;
117
118	<	$obj=$self->{dochandler}->newdoc($url);
119	<	# Now Extend our tree
120	<	$self->{treenode}->grow($obj->treenode());
51	<	return $obj;
118	>	$self->{parsers}{$parselabel}=ActiveDoc::Parse->new();
119	>	$self->{parsers}{$parselabel}->addignoretags();
120	>	$self->{parsers}{$parselabel}->addgrouptags();
121		}
122
123	<	sub treenode {
123	>	sub cleartags {
124		my $self=shift;
125	<	return $self->treenode;
125	>	my $parselabel=shift;
126	>
127	>	$self->{parsers}{$parselabel}->cleartags();
128		}
129
130	<	sub getincludeObjectStore {
131	<	my $self=shift;
132	<	return $self->{includeOS};
130	>
131	>	sub includeparse {
132	>	my $self=shift;
133	>	my $parselabel=shift;
134	>	my $remoteparselabel=shift;
135	>	my $activedoc=shift;
136	>
137	>	# Some error trapping
138	>	if ( ! exists $self->{parsers}{$parselabel} ) {
139	>	$self->error("Unknown local parse name specified");
140	>	}
141	>	if ( ! exists $activedoc->{parsers}{$remoteparselabel} ) {
142	>	$self->error("Unknown parse name specified in remote obj $activedoc");
143	>	}
144	>
145	>	#
146	>	my $rp=$activedoc->{parsers}{$remoteparselabel};
147	>	$self->{parsers}{$parselabel}->includeparse($rp);
148	>	}
149	>
150	>	sub addtag {
151	>	my $self=shift;
152	>	my $parselabel=shift;
153	>	if ( $#_ != 6 ) {
154	>	$self->error("Incorrect addtags specification\n".
155	>	"called with :\n@_ \n");
156	>	}
157	>	$self->{parsers}{$parselabel}->addtag(@_);
158	>	}
159	>
160	>	sub addurltags {
161	>	my $self=shift;
162	>	my $parselabel=shift;
163	>
164	>	$self->{parsers}{$parselabel}->
165	>	addtag("Base", \&Base_start, $self, "", $self,
166	>	\&Base_end, $self);
167	>	}
168	>
169	>	sub url {
170	>	my $self=shift;
171	>	# get file & preprocess
172	>	if ( @_  ) {$self->{File}=$self->getfile(shift)}
173	>	$self->{File}->url();
174	>	}
175	>
176	>	sub copydocconfig {
177	>	my $self=shift;
178	>	my $ActiveDoc=shift;
179	>
180	>	$self->config($ActiveDoc->config());
181	>
182	>	}
183	>
184	>	sub copydocquery {
185	>	my $self=shift;
186	>	my $ActiveDoc=shift;
187	>
188	>	$self->basequery($ActiveDoc->basequery());
189		}
190
191	<	sub find($) {
191	>	sub config {
192		my $self=shift;
193	+	@_?$self->{ActiveConfig}=shift
194	+	: $self->{ActiveConfig};
195	+	}
196	+
197	+	sub basequery {
198	+	my $self=shift;
199	+	@_ ? $self->{Query}=shift
200	+	: $self->{Query};
201	+	}
202	+
203	+	sub option {
204	+	my $self=shift;
205	+	my $param=shift;
206	+	if ( defined $self->basequery()) {
207	+	return $self->basequery()->getparam($param);
208	+	}
209	+	else {
210	+	return $undef;
211	+	}
212	+	}
213	+
214	+	sub requestoption {
215	+	my $self=shift;
216	+	my $param=shift;
217		my $string=shift;
218
219	<	$self->{treenode}->find($string);
219	>	my $par=undef;
220	>	if ( defined $self->basequery()) {
221	>	$par=$self->basequery()->getparam($param);
222	>	while ( ! defined $par ) {
223	>	$self->basequery()->querytype( $param, "basic");
224	>	$self->basequery()->querymessage( $param, $string);
225	>	$self->userinterface()->askuser($self->basequery());
226	>	$par=$self->basequery()->getparam($param);
227	>	}
228	>	}
229	>	return $par;
230		}
231
232	<	# ------------------------ Tag Routines ------------------------------
233	<	#
234	<	# A default Include tag
235	<	#
236	<	sub Include_Start {
237	<	my $returnval;
238	<	# Just call the basic - this is only a default wrapper for the
239	<	# <INCLUDE> tag assuming with no futher processing of the DOCObjref
240	<	$returnval=_includetag(@_)
241	<	# dont return anything if its a basic tag
232	>	sub getfile() {
233	>	my $self=shift;
234	>	my $origurl=shift;
235	>
236	>	my $fileref;
237	>	my ($url, $file)=$self->{urlhandler}->get($origurl);
238	>	# do we already have an appropriate object?
239	>	($fileref)=$self->config()->find($url);
240	>	#undef $fileref;
241	>	if (  defined $fileref ) {
242	>	print "found $url in database ----\n";
243	>	$fileref->update();
244	>	}
245	>	else {
246	>	if ( $file eq "" ) {
247	>	$self->parseerror("Unable to get $origurl");
248	>	}
249	>	#-- set up a new preprocess file
250	>	print "Making a new file $url----\n";
251	>	$fileref=ActiveDoc::PreProcessedFile->new($self->config());
252	>	$fileref->url($url);
253	>	$fileref->update();
254	>	}
255	>	return $fileref;
256	>	}
257	>
258	>	sub activatedoc {
259	>	my $self=shift;
260	>	my $url=shift;
261	>
262	>	# first get a preprocessed copy of the file
263	>	#       my $fileob=$self->getfile($url);
264	>
265	>	# now parse it for the <DocType> tag
266	>	my $tempdoc=ActiveDoc::ActiveDoc->new($self->config());
267	>	$tempdoc->url($url);
268	>	$tempdoc->{doctypefound}=0;
269	>	$tempdoc->newparse("doctype");
270	>	$tempdoc->addtag("doctype","Doc", \&Doc_Start, $tempdoc,
271	>	"", $tempdoc, "", $tempdoc);
272	>	$tempdoc->parse("doctype");
273	>
274	>	if ( ! defined $tempdoc->{docobject} ) {
275	>	print "No <Doc type=> Specified in ".$url."\n";
276	>	exit 1;
277	>	}
278	>	# Set up a new object of the specified type
279	>	eval "require $tempdoc->{docobject}";
280	>	die $@ if $@;
281	>	my $newobj=$tempdoc->{docobject}->new($self->config());
282	>	undef $tempdoc;
283	>	$newobj->url($url);
284	>	$newobj->_initparse();
285	>	return $newobj;
286	>	}
287	>
288	>	sub _initparse {
289	>	my $self=shift;
290	>
291	>	$self->parse("init");
292	>	}
293	>	# -------- Error Handling and Error services --------------
294	>
295	>	sub error {
296	>	my $self=shift;
297	>	my $string=shift;
298	>
299	>	die $string."\n";
300	>	}
301	>
302	>	sub parseerror {
303	>	my $self=shift;
304	>	my $string=shift;
305	>
306	>	($line, $file)=$self->line();
307	>	print "Parse Error in ".$file->url().", line ".
308	>	$line."\n";
309	>	print $string."\n";
310	>	die;
311	>	}
312	>
313	>	sub checktag {
314	>	my $self=shift;
315	>	my $tagname=shift;
316	>	my $hashref=shift;
317	>	my $param=shift;
318	>
319	>	if ( ! exists $$hashref{$param} ) {
320	>	$self->parseerror("Incomplete Tag <$tagname> : $param required");
321	>	}
322	>	}
323	>
324	>	sub line {
325	>	my $self=shift;
326	>
327	>	my ($line, $fileobj)=
328	>	$self->{File}->realline($self->{currentparser}->line());
329	>	return ($line, $fileobj);
330	>	}
331	>
332	>	sub tagstartline {
333	>	my $self=shift;
334	>	my ($line, $fileobj)=$self->{File}->line(
335	>	$self->{currentparser}->tagstartline());
336	>	return ($line, $fileobj);
337	>	}
338	>
339	>	sub file {
340	>	my $self=shift;
341	>
342	>	$self->{File}->file();
343	>	}
344	>
345	>	# --------------- Initialisation Methods ---------------------------
346	>
347	>	sub init {
348	>	# Dummy Routine - override for derived classes
349		}
350
351	<	# ----------------------- Support Routines ---------------------------
351	>	# ------------------- Tag Routines -----------------------------------
352		#
353	<	# the real workings of the include tag returns the ref
353	>	# Base - for setting url bases
354		#
355	<	sub _includetag {
355	>	sub Base_start {
356		my $self=shift;
357		my $name=shift;
358		my $hashref=shift;
359
360	<	$self->{switch}->checkparam( $name, "ref");
361	<	$url=$$hashref{'ref'};
362	<	return $self->include($url);
360	>	$self->checktag($name, $hashref, 'type' );
361	>	$self->checktag($name, $hashref, 'base' );
362	>
363	>	# Keep track of base tags
364	>	push @{$self->{basestack}}, $$hashref{"type"};
365	>	# Set the base
366	>	print "BASE SET for ".$$hashref{"type"}."\n";
367	>	$self->{urlhandler}->setbase($$hashref{"type"},$hashref);
368	>	print "BASE SET for ".$$hashref{"type"}."\n";
369	>
370	>	}
371	>
372	>	sub Base_end {
373	>	my $self=shift;
374	>	my $name=shift;
375	>	my $type;
376	>
377	>	if ( $#{$self->{basestack}} == -1 ) {
378	>	print "Parse Error : unmatched </".$name."> on line ".
379	>	$self->line()."\n";
380	>	die;
381	>	}
382	>	else {
383	>	$type = pop @{$self->{basestack}};
384	>	$self->{urlhandler}->unsetbase($type);
385	>	}
386	>	}
387	>
388	>	sub Doc_Start {
389	>	my $self=shift;
390	>	my $name=shift;
391	>	my $hashref=shift;
392	>
393	>	$self->checktag($name, $hashref, "type");
394	>	$self->{doctypefound}++;
395	>	if ( $self->{doctypefound} == 1 ) { # only take first doctype
396	>	$self->{docobject}=$$hashref{'type'};
397	>	}
398		}
399
400	+	sub userinterface {
401	+	my $self=shift;
402	+	@_?$self->{userinterface}=shift
403	+	:$self->{userinterface}
404	+	}

Diff Legend

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