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.7 by williamc, Tue Nov 23 17:20:40 1999 UTC vs.
Revision 1.15 by williamc, Thu Jan 20 18:18:45 2000 UTC

#	Line 7 | Line 7
7		#
8		# Interface
9		# ---------
10	<	# new()         : A new ActiveDoc object
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		#
#	Line 15 | Line 15
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
#	Line 33 | Line 44 | require 5.004;
44		use ActiveDoc::Parse;
45		use ActiveDoc::ActiveConfig;
46		use ActiveDoc::PreProcessedFile;
47	<	use ObjectUtilities::ObjectBase;
47	>	use ObjectUtilities::StorableObject;
48		use URL::URLhandler;
49
50	<	@ISA = qw(ObjectUtilities::ObjectBase);
50	>	@ISA = qw(ObjectUtilities::StorableObject);
51
52		sub new {
53		my $class=shift;
54		$self={};
55		bless $self, $class;
56		$self->config(shift);
57	<
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	+	# A default UserInterface
82	+	$self->{userinterface}=ActiveDoc::SimpleUserInterface->new();
83		$self->init(@_);
84		return $self;
85	+
86		}
87
88		# ----- parse related routines --------------
#	Line 58 | Line 92 | sub parse {
92
93		my $file=$self->file();
94		if ( $file ) {
95	<	$self->{currentparser}=$self->{parsers}{$parselabel};
96	<	$self->{parsers}{$parselabel}->parse($file,@_);
97	<	delete $self->{currentparser};
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	+	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;
#	Line 76 | Line 120 | sub newparse {
120		$self->{parsers}{$parselabel}->addgrouptags();
121		}
122
123	+	sub cleartags {
124	+	my $self=shift;
125	+	my $parselabel=shift;
126	+
127	+	$self->{parsers}{$parselabel}->cleartags();
128	+	}
129	+
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;
#	Line 97 | Line 168 | sub addurltags {
168
169		sub url {
170		my $self=shift;
171	<	@_ ?$self->{File}=$self->getfile(shift)
172	<	: $self->{File};
171	>	# get file & preprocess
172	>	if ( @_  ) {$self->{File}=$self->getfile(shift)}
173	>	$self->{File}->url();
174		}
175
176		sub copydocconfig {
#	Line 113 | Line 185 | sub copydocquery {
185		my $self=shift;
186		my $ActiveDoc=shift;
187
188	<	$self->basequery($ActiveDoc->basequery());
188	>	$self->basequery($ActiveDoc->basequery());
189		}
190
191		sub config {
#	Line 124 | Line 196 | sub config {
196
197		sub basequery {
198		my $self=shift;
199	<	@_ ? $self->{UserQuery}=shift
200	<	: $self->{UserQuery};
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	>	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		sub getfile() {
#	Line 154 | Line 255 | sub getfile() {
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 {
#	Line 187 | Line 323 | sub checktag {
323
324		sub line {
325		my $self=shift;
326	+
327		my ($line, $fileobj)=
328	<	$self->{PPfile}->line($self->{currentparser}->line());
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->{PPfile}->line(
334	>	my ($line, $fileobj)=$self->{File}->line(
335		$self->{currentparser}->tagstartline());
336		return ($line, $fileobj);
337		}
#	Line 202 | Line 339 | sub tagstartline {
339		sub file {
340		my $self=shift;
341
342	<	$self->{PPf}->file();
342	>	$self->{File}->file();
343		}
344
345		# --------------- Initialisation Methods ---------------------------
346
210	–	sub preprocess_init {
211	–	my $self=shift;
212	–	$self->{PPfile}=PreProcessedFile->new($self->config());
213	–	}
214	–
347		sub init {
348		# Dummy Routine - override for derived classes
349		}
#	Line 231 | Line 363 | sub Base_start {
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
#	Line 250 | Line 384 | sub Base_end {
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