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.24 by williamc, Wed Mar 1 11:47:39 2000 UTC vs.
Revision 1.25.2.1 by williamc, Wed May 17 13:59:42 2000 UTC

#	Line 7 | Line 7
7		#
8		# Interface
9		# ---------
10	<	# new(ActiveConfig[,options])           : A new ActiveDoc object
10	>	# new()         : A new ActiveDoc object
11	>	# config([ActiveConfig]) :    Set up/return Configuration for the document
12		# url()         : Return/set the docs url - essential
13		# file()        : Return the local filename of document
14		# ProcessFile() : Return the filename of PreProcessed document
15		#
15	–	# parse(parselabel): Parse the document file for the given parse level
16		# parent()         : return the object ref of the calling parent
17	–	# newparse(parselabel) : Create a new parse type
18	–	# addtag(parselabel,tagname,start,obj,text,obj,end,obj)
19	–	#                               : Add tags to the parse given by label
20	–	# checktag(tagname, hashref, param) : check for existence of param in
21	–	#                                       hashref from a tag call
22	–	# includeparse(local_parsename, objparsename, activedoc) : copy the parse from
23	–	#                                                       one object to another
24	–	# currentparser() : return the current parser object
25	–	# currentparsename([name]) : get/set current parse name
17		# getfile(url)  : get a processedfile object given a url
18		# activatedoc(url) : Return the object ref for a doc described by the given url
19		#                    -- any parse called "init" will also be run
29	–	# config([ActiveConfig]) : Set up/return Configuration for the document
30	–	# basequery([ActiveConfig]) : Set up/return UserQuery for the doc
31	–	# copydocconfig(ActiveDoc) : Copy the basic configuration from the ActiveDoc
32	–	# copydocquery(ActiveDoc) : Copy the basicquery from the ActiveDoc
20		# userinterface()       : Return the defaullt userinterface
21		# option(var)           : return the value of the option var ( or undef )
35	–	# requestoption("message") : Ask the user to supply a value for an option
36	–	#                            if it dosnt already exist
37	–	# askuser(Query)        : send a query object to the userinterface
38	–	# verbose(string)       : Print string in verbosity mode
22		#
23	+	# addurltags(parse) : add the <base> tags to manage urls to parse
24		# -- error methods --
25		# error(string)       : Report an general error to the user
26		# parseerror(string)  : Report an error during parsing a file
27		# line()              : Return the current line number of the document
28		#                       and the ProcessedFileObj it is in
29		#
46	–	# -- support for inheriting classes
47	–	# _saveactivedoc(filehandle)
48	–	# _restoreactivedoc(filehandle)
30
31		package ActiveDoc::ActiveDoc;
32		require 5.004;
33	<	use ActiveDoc::Parse;
53	<	use ActiveDoc::ActiveConfig;
54	<	use ActiveDoc::PreProcessedFile;
55	<	use ObjectUtilities::StorableObject;
33	>	use ActiveDoc::SimpleDoc;
34		use URL::URLhandler;
35
36	<	@ISA = qw(ObjectUtilities::StorableObject);
59	<
60	<	sub new {
61	<	my $class=shift;
62	<	$self={};
63	<	bless $self, $class;
64	<	$self->config(shift);
65	<
66	<	# have some override options been passed
67	<	if ( @_ ) {
68	<	$self->basequery(shift);
69	<	}
70	<	else {
71	<	# --- is there a starter document?
72	<	my $basedoc=$self->config()->basedoc();
73	<	if ( defined $basedoc ) {
74	<	$self->copydocquery($basedoc);
75	<	$self->verbose("Initialising from $basedoc");
76	<	}
77	<	else {
78	<	$self->error("ActiveDoc Error : No base doc found");
79	<	}
80	<	}
81	<	$self->verbose("New ActiveDoc (".ref($self).") Created");
82	<	$self->_init2();
83	<	}
84	<
85	<	sub _init2 {
86	<
87	<	my $self=shift;
88	<	# A URL handler per document
89	<	$self->{urlhandler}=URL::URLhandler->new($self->config()->cache());
90	<
91	<	# A default UserInterface
92	<	$self->{userinterface}=ActiveDoc::SimpleUserInterface->new();
93	<	$self->init(@_);
94	<	return $self;
95	<
96	<	}
97	<
98	<	sub verbose {
99	<	my $self=shift;
100	<	my $string=shift;
101	<
102	<	if ( $self->option('verbose_all') ||
103	<	$self->option('verbose_'.ref($self)) ) {
104	<	print ">".ref($self)."($self) : \n->".$string."\n";
105	<	}
106	<	}
107	<
108	<	# ----- parse related routines --------------
109	<	sub parse {
110	<	my $self=shift;
111	<	$parselabel=shift;
112	<
113	<	my $file=$self->ProcessFile();
114	<	if ( $file ) {
115	<	if ( exists $self->{parsers}{$parselabel} ) {
116	<	$self->verbose("Parsing $parselabel in file $file");
117	<	$self->{currentparsename}=$parselabel;
118	<	$self->{currentparser}=$self->{parsers}{$parselabel};
119	<	$self->{parsers}{$parselabel}->parse($file,@_);
120	<	delete $self->{currentparser};
121	<	$self->{currentparsename}="";
122	<	$self->verbose("Parse $parselabel Complete");
123	<	}
124	<	}
125	<	else {
126	<	$self->error("Cannot parse $parselabel - file not known");
127	<	}
128	<	}
129	<
130	<	sub currentparsename {
131	<	my $self=shift;
132	<	@_?$self->{currentparsename}=shift
133	<	:(defined $self->{currentparsename}?$self->{currentparsename}:"");
134	<	}
135	<
136	<	sub currentparser {
137	<	my $self=shift;
138	<	return $self->{currentparser};
139	<	}
140	<
141	<
142	<	sub newparse {
143	<	my $self=shift;
144	<	my $parselabel=shift;
145	<
146	<	$self->{parsers}{$parselabel}=ActiveDoc::Parse->new();
147	<	$self->{parsers}{$parselabel}->addignoretags();
148	<	$self->{parsers}{$parselabel}->addgrouptags();
149	<	}
150	<
151	<	sub cleartags {
152	<	my $self=shift;
153	<	my $parselabel=shift;
154	<
155	<	$self->{parsers}{$parselabel}->cleartags();
156	<	}
157	<
158	<
159	<	sub includeparse {
160	<	my $self=shift;
161	<	my $parselabel=shift;
162	<	my $remoteparselabel=shift;
163	<	my $activedoc=shift;
164	<
165	<	# Some error trapping
166	<	if ( ! exists $self->{parsers}{$parselabel} ) {
167	<	$self->error("Unknown local parse name specified");
168	<	}
169	<	if ( ! exists $activedoc->{parsers}{$remoteparselabel} ) {
170	<	$self->error("Unknown parse name specified in remote obj $activedoc");
171	<	}
172	<
173	<	#
174	<	my $rp=$activedoc->{parsers}{$remoteparselabel};
175	<	$self->{parsers}{$parselabel}->includeparse($rp);
176	<	}
177	<
178	<	sub addtag {
179	<	my $self=shift;
180	<	my $parselabel=shift;
181	<	if ( $#_ != 6 ) {
182	<	$self->error("Incorrect addtags specification\n".
183	<	"called with :\n@_ \n");
184	<	}
185	<	$self->{parsers}{$parselabel}->addtag(@_);
186	<	}
36	>	@ISA = qw(ActiveDoc::SimpleDoc);
37
38		sub addurltags {
39		my $self=shift;
#	Line 201 | Line 51 | sub url {
51		$self->{File}=$self->getfile(shift);
52		$self->verbose("url downloaded to $self->{File}");
53		}
54	<	$self->{File}->url();
55	<	}
206	<
207	<	sub copydocconfig {
208	<	my $self=shift;
209	<	my $ActiveDoc=shift;
210	<
211	<	$self->config($ActiveDoc->config());
212	<
213	<	}
214	<
215	<	sub copydocquery {
216	<	my $self=shift;
217	<	my $ActiveDoc=shift;
218	<
219	<	if ( defined $ActiveDoc->basequery() ) {
220	<	$self->basequery($ActiveDoc->basequery());
221	<	}
222	<	else {
223	<	$self->error("Cannot copy basequery - undefined");
54	>	if ( defined $self->{File} ) {
55	>	return $self->{File}->url();
56		}
57	+	else { return "undefined"; }
58		}
59
60		sub config {
#	Line 230 | Line 63 | sub config {
63		: $self->{ActiveConfig};
64		}
65
233	–	sub basequery {
234	–	my $self=shift;
235	–	@_?$self->{Query}=shift
236	–	:$self->{Query};
237	–	}
238	–
239	–	sub option {
240	–	my $self=shift;
241	–	my $param=shift;
242	–	if ( defined $self->basequery()) {
243	–	return $self->basequery()->getparam($param);
244	–	}
245	–	else {
246	–	return $undef;
247	–	}
248	–	}
249	–
250	–	sub requestoption {
251	–	my $self=shift;
252	–	my $param=shift;
253	–	my $string=shift;
254	–
255	–	my $par=undef;
256	–	if ( defined $self->basequery()) {
257	–	$par=$self->basequery()->getparam($param);
258	–	while ( ! defined $par ) {
259	–	$self->basequery()->querytype( $param, "basic");
260	–	$self->basequery()->querymessage( $param, $string);
261	–	$self->userinterface()->askuser($self->basequery());
262	–	$par=$self->basequery()->getparam($param);
263	–	}
264	–	}
265	–	return $par;
266	–	}
267	–
268	–	sub askuser {
269	–	my $self=shift;
270	–	return $self->userinterface()->askuser(@_);
271	–	}
272	–
66		sub getfile {
67		my $self=shift;
68		my $origurl=shift;
#	Line 334 | Line 127 | sub activatedoc {
127		undef $tempdoc;
128		$newobj->url($url);
129		$newobj->parent($self);
337	–	$newobj->_initparse();
130		return $newobj;
131		}
132
#	Line 345 | Line 137 | sub parent {
137		:$self->{parent};
138		}
139
348	–	sub _initparse {
349	–	my $self=shift;
350	–
351	–	$self->parse("init");
352	–	}
140		# -------- Error Handling and Error services --------------
141
142		sub error {
#	Line 375 | Line 162 | sub parseerror {
162		}
163		}
164
378	–	sub checktag {
379	–	my $self=shift;
380	–	my $tagname=shift;
381	–	my $hashref=shift;
382	–	my $param=shift;
383	–
384	–	if ( ! exists $$hashref{$param} ) {
385	–	$self->parseerror("Incomplete Tag <$tagname> : $param required");
386	–	}
387	–	}
388	–
165		sub line {
166		my $self=shift;
167
#	Line 462 | Line 238 | sub Doc_Start {
238		$self->{docobject}=$$hashref{'type'};
239		}
240		}
465	–
466	–	sub userinterface {
467	–	my $self=shift;
468	–	@_?$self->{userinterface}=shift
469	–	:$self->{userinterface}
470	–	}
471	–
472	–	sub _saveactivedoc {
473	–	my $self=shift;
474	–	my $fh=shift;
475	–	print "Storing $self\n";
476	–	print $fh $self->url()."\n";
477	–	}
478	–
479	–	sub _restoreactivedoc {
480	–	my $self=shift;
481	–	my $fh=shift;
482	–
483	–	my $url=<$fh>;
484	–	chomp $url;
485	–	$self->url($url);
486	–	}

Diff Legend

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