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.25 by williamc, Wed Mar 29 09:45:47 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 207 | Line 57 | sub url {
57		else { return "undefined"; }
58		}
59
210	–	sub copydocconfig {
211	–	my $self=shift;
212	–	my $ActiveDoc=shift;
213	–
214	–	$self->config($ActiveDoc->config());
215	–
216	–	}
217	–
218	–	sub copydocquery {
219	–	my $self=shift;
220	–	my $ActiveDoc=shift;
221	–
222	–	if ( defined $ActiveDoc->basequery() ) {
223	–	$self->basequery($ActiveDoc->basequery());
224	–	}
225	–	else {
226	–	$self->error("Cannot copy basequery - undefined");
227	–	}
228	–	}
229	–
60		sub config {
61		my $self=shift;
62		@_?$self->{ActiveConfig}=shift
63		: $self->{ActiveConfig};
64		}
65
236	–	sub basequery {
237	–	my $self=shift;
238	–	@_?$self->{Query}=shift
239	–	:$self->{Query};
240	–	}
241	–
242	–	sub option {
243	–	my $self=shift;
244	–	my $param=shift;
245	–	if ( defined $self->basequery()) {
246	–	return $self->basequery()->getparam($param);
247	–	}
248	–	else {
249	–	return $undef;
250	–	}
251	–	}
252	–
253	–	sub requestoption {
254	–	my $self=shift;
255	–	my $param=shift;
256	–	my $string=shift;
257	–
258	–	my $par=undef;
259	–	if ( defined $self->basequery()) {
260	–	$par=$self->basequery()->getparam($param);
261	–	while ( ! defined $par ) {
262	–	$self->basequery()->querytype( $param, "basic");
263	–	$self->basequery()->querymessage( $param, $string);
264	–	$self->userinterface()->askuser($self->basequery());
265	–	$par=$self->basequery()->getparam($param);
266	–	}
267	–	}
268	–	return $par;
269	–	}
270	–
271	–	sub askuser {
272	–	my $self=shift;
273	–	return $self->userinterface()->askuser(@_);
274	–	}
275	–
66		sub getfile {
67		my $self=shift;
68		my $origurl=shift;
#	Line 337 | Line 127 | sub activatedoc {
127		undef $tempdoc;
128		$newobj->url($url);
129		$newobj->parent($self);
340	–	$newobj->_initparse();
130		return $newobj;
131		}
132
#	Line 348 | Line 137 | sub parent {
137		:$self->{parent};
138		}
139
351	–	sub _initparse {
352	–	my $self=shift;
353	–
354	–	$self->parse("init");
355	–	}
140		# -------- Error Handling and Error services --------------
141
142		sub error {
#	Line 378 | Line 162 | sub parseerror {
162		}
163		}
164
381	–	sub checktag {
382	–	my $self=shift;
383	–	my $tagname=shift;
384	–	my $hashref=shift;
385	–	my $param=shift;
386	–
387	–	if ( ! exists $$hashref{$param} ) {
388	–	$self->parseerror("Incomplete Tag <$tagname> : $param required");
389	–	}
390	–	}
391	–
165		sub line {
166		my $self=shift;
167
#	Line 465 | Line 238 | sub Doc_Start {
238		$self->{docobject}=$$hashref{'type'};
239		}
240		}
468	–
469	–	sub userinterface {
470	–	my $self=shift;
471	–	@_?$self->{userinterface}=shift
472	–	:$self->{userinterface}
473	–	}
474	–
475	–	sub _saveactivedoc {
476	–	my $self=shift;
477	–	my $fh=shift;
478	–	print "Storing $self\n";
479	–	print $fh $self->url()."\n";
480	–	}
481	–
482	–	sub _restoreactivedoc {
483	–	my $self=shift;
484	–	my $fh=shift;
485	–
486	–	my $url=<$fh>;
487	–	chomp $url;
488	–	$self->url($url);
489	–	}

Diff Legend

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