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.23 by williamc, Wed Feb 23 14:53:28 2000 UTC vs.
Revision 1.25.2.1.2.2 by williamc, Mon Aug 21 15:19:49 2000 UTC

#	Line 7 | Line 7
7		#
8		# Interface
9		# ---------
10	<	# new(ActiveConfig[,options])           : A new ActiveDoc object
10	>	# new(cache,dbstore)            : A new ActiveDoc object
11		# url()         : Return/set the docs url - essential
12		# file()        : Return the local filename of document
13		# ProcessFile() : Return the filename of PreProcessed document
14		#
15	–	# parse(parselabel): Parse the document file for the given parse level
15		# 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
16		# getfile(url)  : get a processedfile object given a url
17		# activatedoc(url) : Return the object ref for a doc described by the given url
28	–	#                    -- 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
33	–	# userinterface()       : Return the defaullt userinterface
34	–	# 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
18		#
19		# -- error methods --
20		# error(string)       : Report an general error to the user
21		# parseerror(string)  : Report an error during parsing a file
22	<	# line()              : Return the current line number of the document
23	<	#                       and the ProcessedFileObj it is in
24	<	#
25	<	# -- support for inheriting classes
47	<	# _saveactivedoc(filehandle)
48	<	# _restoreactivedoc(filehandle)
22	>	# line([linenumber])     : Return the line number of the document
23	>	#                       and the ProcessedFileObj it is in corresponding to the
24	>	#                       supplied number of the expanded document
25	>	#                       If no number supplied - the currentparse number will be #                       used
26
27		package ActiveDoc::ActiveDoc;
28		require 5.004;
29	<	use ActiveDoc::Parse;
53	<	use ActiveDoc::ActiveConfig;
29	>	use ActiveDoc::SimpleURLDoc;
30		use ActiveDoc::PreProcessedFile;
31	<	use ObjectUtilities::StorableObject;
56	<	use URL::URLhandler;
31	>	use Utilities::Verbose;
32
33	<	@ISA = qw(ObjectUtilities::StorableObject);
33	>	@ISA = qw(Utilities::Verbose);
34
35		sub new {
36		my $class=shift;
37	<	$self={};
37	>	my $self={};
38		bless $self, $class;
39	<	$self->config(shift);
40	<
41	<	# have some override options been passed
42	<	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(@_);
39	>	$self->{cache}=shift;
40	>	$self->{dbstore}=shift;
41	>	$self->_initdoc("doc",@_);
42	>	#       $self->{switch}=ActiveDoc::SimpleURLDoc->new($self->{cache});
43		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	–	print "Cannot parse - file not known\n";
127	–	}
128	–	}
129	–
130	–	sub currentparsename {
131	–	my $self=shift;
132	–	@_?$self->{currentparsename}=shift
133	–	:$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	–	}
187	–
188	–	sub addurltags {
189	–	my $self=shift;
190	–	my $parselabel=shift;
191	–
192	–	$self->{parsers}{$parselabel}->
193	–	addtag("Base", \&Base_start, $self, "", $self,
194	–	\&Base_end, $self);
44		}
45
46		sub url {
#	Line 201 | Line 50 | sub url {
50		$self->{File}=$self->getfile(shift);
51		$self->verbose("url downloaded to $self->{File}");
52		}
53	<	$self->{File}->url();
54	<	}
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");
53	>	if ( defined $self->{File} ) {
54	>	return $self->{File}->url();
55		}
56	<	}
226	<
227	<	sub config {
228	<	my $self=shift;
229	<	@_?$self->{ActiveConfig}=shift
230	<	: $self->{ActiveConfig};
231	<	}
232	<
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(@_);
56	>	else { return "undefined"; }
57		}
58
59		sub getfile {
#	Line 276 | Line 62 | sub getfile {
62
63		my $fileref;
64		my ($url, $file);
65	<	if ( (defined ($it=$self->option('url_update'))) &&
280	<	( $it eq "1" || $origurl=~/^$it/ )) {
65	>	if ( 0 ) {
66		$self->verbose("Forced download of $origurl");
67	<	($url, $file)=$self->{urlhandler}->download($origurl);
67	>	($url, $file)=$self->urldownload($origurl);
68		}
69		else {
70		$self->verbose("Attempting to get $origurl");
71	<	($url, $file)=$self->{urlhandler}->get($origurl);
71	>	($url, $file)=$self->urlget($origurl);
72		}
73		# do we already have an appropriate object?
74	<	($fileref)=$self->config()->find($url);
290	<	#undef $fileref;
74	>	($fileref)=$self->{dbstore}->find($url);
75		if (  defined $fileref ) {
76		$self->verbose("Found $url in database");
77		$fileref->update();
#	Line 296 | Line 80 | sub getfile {
80		if ( $file eq "" ) {
81		$self->parseerror("Unable to get $origurl");
82		}
83	<	#-- set up a new preprocess file
83	>	# -- set up a new preprocess file
84		$self->verbose("Making a new preprocessed file $url");
85	<	$fileref=ActiveDoc::PreProcessedFile->new($self->config());
85	>	$fileref=ActiveDoc::PreProcessedFile->new($self->{cache},
86	>	$self->{dbstore});
87		$fileref->url($url);
88		$fileref->update();
89		}
#	Line 310 | Line 95 | sub activatedoc {
95		my $url=shift;
96
97		# first get a preprocessed copy of the file
98	<	#       my $fileob=$self->getfile($url);
98	>	my $fileobj=$self->getfile($url);
99
100	<	# now parse it for the <DocType> tag
101	<	my $tempdoc=ActiveDoc::ActiveDoc->new($self->config());
102	<	$tempdoc->{urlhandler}=$self->{urlhandler};
103	<	my $fullurl=$tempdoc->url($url);
104	<	$url=$fullurl;
105	<	$tempdoc->{doctypefound}=0;
106	<	$tempdoc->newparse("doctype");
107	<	$tempdoc->addtag("doctype","Doc", \&Doc_Start, $tempdoc,
323	<	"", $tempdoc, "", $tempdoc);
324	<	$tempdoc->parse("doctype");
325	<
326	<	if ( ! defined $tempdoc->{docobject} ) {
327	<	print "No <Doc type=> Specified in ".$url."\n";
328	<	exit 1;
100	>	# now parse it for the <Doc> tag
101	>	my $tempdoc=ActiveDoc::SimpleURLDoc->new($self->{cache});
102	>	$tempdoc->filetoparse($fileobj->ProcessFile());
103	>	my ($doctype,$docversion)=$tempdoc->doctype();
104	>	undef $tempdoc;
105	>
106	>	if ( ! defined $doctype ) {
107	>	$self->parseerror("No <Doc type=> Specified in ".$url);
108		}
109	+	$self->verbose("doctype required is $doctype $docversion");
110	+
111		# Set up a new object of the specified type
112	<	eval "require $tempdoc->{docobject}";
112	>	eval "require $doctype";
113		die $@ if $@;
114	<	my $newobj=$tempdoc->{docobject}->new($self->config());
334	<	undef $tempdoc;
114	>	my $newobj=$doctype->new($self->{cache},$self->{dbstore});
115		$newobj->url($url);
116		$newobj->parent($self);
337	–	$newobj->_initparse();
117		return $newobj;
118		}
119
#	Line 345 | Line 124 | sub parent {
124		:$self->{parent};
125		}
126
348	–	sub _initparse {
349	–	my $self=shift;
350	–
351	–	$self->parse("init");
352	–	}
127		# -------- Error Handling and Error services --------------
128
355	–	sub error {
356	–	my $self=shift;
357	–	my $string=shift;
358	–
359	–	die $string."\n";
360	–	}
361	–
129		sub parseerror {
130		my $self=shift;
131		my $string=shift;
#	Line 375 | Line 142 | sub parseerror {
142		}
143		}
144
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	–
145		sub line {
146		my $self=shift;
147	+	my $parseline;
148	+
149	+	if ( @_ ) {
150	+	$parseline=shift;
151	+	}
152	+	else {
153	+	$parseline=$self->{currentparser}->line();
154	+	}
155
156		my ($line, $fileobj)=
157	<	$self->{File}->realline($self->{currentparser}->line());
157	>	$self->{File}->realline($parseline);
158		return ($line, $fileobj);
159		}
160
#	Line 413 | Line 177 | sub ProcessFile {
177		return $self->{File}->ProcessedFile();
178		}
179
416	–	# --------------- Initialisation Methods ---------------------------
417	–
418	–	sub init {
419	–	# Dummy Routine - override for derived classes
420	–	}
421	–
422	–	# ------------------- Tag Routines -----------------------------------
180		#
181	<	# Base - for setting url bases
181	>	# Delegate all else to the switch
182		#
183	<	sub Base_start {
184	<	my $self=shift;
428	<	my $name=shift;
429	<	my $hashref=shift;
183	>	#sub AUTOLOAD {
184	>	#        my $self=shift;
185
186	<	$self->checktag($name, $hashref, 'type' );
187	<	$self->checktag($name, $hashref, 'base' );
433	<
434	<	# Keep track of base tags
435	<	push @{$self->{basestack}}, $$hashref{"type"};
436	<	# Set the base
437	<	$self->{urlhandler}->setbase($$hashref{"type"},$hashref);
438	<	}
186	>	# dont propogate destroy methods
187	>	#        return if $AUTOLOAD=~/::DESTROY/;
188
189	<	sub Base_end {
190	<	my $self=shift;
442	<	my $name=shift;
443	<	my $type;
189	>	# remove this package name
190	>	#        ($name=$AUTOLOAD)=~s/ActiveDoc::ActiveDoc:://;
191
192	<	if ( $#{$self->{basestack}} == -1 ) {
193	<	$self->parseerror("Parse Error : unmatched </$name>");
194	<	}
448	<	else {
449	<	$type = pop @{$self->{basestack}};
450	<	$self->{urlhandler}->unsetbase($type);
451	<	}
452	<	}
192	>	# pass the message to SimpleDoc
193	>	#        $self->{switch}->$name(@_);
194	>	#}
195
196	+
197	+	# ------------------- Tag Routines -----------------------------------
198		sub Doc_Start {
199		my $self=shift;
200		my $name=shift;
#	Line 462 | Line 206 | sub Doc_Start {
206		$self->{docobject}=$$hashref{'type'};
207		}
208		}
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