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.17 by williamc, Thu Jan 20 18:47:41 2000 UTC vs.
Revision 1.25.2.1.2.8 by williamc, Mon Aug 28 07:23:36 2000 UTC

#	Line 7 | Line 7
7		#
8		# Interface
9		# ---------
10	<	# new(ActiveConfig[,options])           : A new ActiveDoc object
10	>	# new(ActiveStore)              : 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	<	# 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
15	>	# parent()         : return the object ref of the calling parent
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
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
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
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;
45	<	use ActiveDoc::ActiveConfig;
29	>	use ActiveDoc::SimpleURLDoc;
30		use ActiveDoc::PreProcessedFile;
31	<	use ObjectUtilities::StorableObject;
48	<	use URL::URLhandler;
31	>	use Utilities::Verbose;
32
33	<	@ISA = qw(ObjectUtilities::StorableObject);
33	>	@ISA = qw(ActiveDoc::SimpleURLDoc 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 ( @_ ) {
43	<	$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(@_);
39	>	$self->{Ostore}=shift;
40	>	$self->cache($self->{Ostore}->cache());
41	>	$self->{dbstore}=$self->{Ostore};
42	>	$self->_initdoc("doc",@_);
43	>	#       $self->{switch}=ActiveDoc::SimpleURLDoc->new($self->{cache});
44		return $self;
85	–
86	–	}
87	–
88	–	# ----- parse related routines --------------
89	–	sub parse {
90	–	my $self=shift;
91	–	$parselabel=shift;
92	–
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	–	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	–	$self->{parsers}{$parselabel}=ActiveDoc::Parse->new();
119	–	$self->{parsers}{$parselabel}->addignoretags();
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;
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);
45		}
46
47		sub url {
48		my $self=shift;
49		# get file & preprocess
50	<	if ( @_  ) {$self->{File}=$self->getfile(shift)}
51	<	$self->{File}->url();
52	<	}
53	<
54	<	sub copydocconfig {
55	<	my $self=shift;
56	<	my $ActiveDoc=shift;
57	<
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 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	<	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	<	}
50	>	if ( @_  ) {
51	>	$self->{origurl}=shift;
52	>	$self->{File}=$self->getfile($self->{origurl});
53	>	$self->filetoparse($self->{File}->ProcessedFile());
54	>	$self->verbose("url downloaded to ".$self->{File}->ProcessedFile());
55	>	}
56	>	if ( defined $self->{File} ) {
57	>	return $self->{File}->url();
58		}
59	<	return $par;
59	>	else { return "undefined"; }
60		}
61
62	<	sub getfile() {
62	>	sub getfile {
63		my $self=shift;
64		my $origurl=shift;
65
66		my $fileref;
67	<	my ($url, $file)=$self->{urlhandler}->get($origurl);
67	>	my ($url, $file);
68	>	if ( 0 ) {
69	>	$self->verbose("Forced download of $origurl");
70	>	($url, $file)=$self->urldownload($origurl);
71	>	}
72	>	else {
73	>	$self->verbose("Attempting to get $origurl");
74	>	($url, $file)=$self->urlget($origurl);
75	>	}
76		# do we already have an appropriate object?
77	<	($fileref)=$self->config()->find($url);
240	<	#undef $fileref;
77	>	($fileref)=$self->{dbstore}->find($url);
78		if (  defined $fileref ) {
79	<	print "found $url in database ----\n";
79	>	$self->verbose("Found $url in database");
80		$fileref->update();
81		}
82		else {
83		if ( $file eq "" ) {
84		$self->parseerror("Unable to get $origurl");
85		}
86	<	#-- set up a new preprocess file
87	<	print "Making a new file $url----\n";
88	<	$fileref=ActiveDoc::PreProcessedFile->new($self->config());
86	>	# -- set up a new preprocess file
87	>	$self->verbose("Making a new preprocessed file $url");
88	>	$fileref=ActiveDoc::PreProcessedFile->new($self->{Ostore});
89	>	#$fileref->cache($self->{cache});
90		$fileref->url($url);
91		$fileref->update();
92		}
#	Line 260 | Line 98 | sub activatedoc {
98		my $url=shift;
99
100		# first get a preprocessed copy of the file
101	<	#       my $fileob=$self->getfile($url);
101	>	my $fileobj=$self->getfile($url);
102
103	<	# now parse it for the <DocType> tag
104	<	my $tempdoc=ActiveDoc::ActiveDoc->new($self->config());
105	<	$tempdoc->{urlhandler}=$self->{urlhandler};
106	<	my $fullurl=$tempdoc->url($url);
107	<	$url=$fullurl;
108	<	$tempdoc->{doctypefound}=0;
109	<	$tempdoc->newparse("doctype");
110	<	$tempdoc->addtag("doctype","Doc", \&Doc_Start, $tempdoc,
273	<	"", $tempdoc, "", $tempdoc);
274	<	$tempdoc->parse("doctype");
275	<
276	<	if ( ! defined $tempdoc->{docobject} ) {
277	<	print "No <Doc type=> Specified in ".$url."\n";
278	<	exit 1;
103	>	# now parse it for the <Doc> tag
104	>	my $tempdoc=ActiveDoc::SimpleURLDoc->new($self->{cache});
105	>	$tempdoc->filetoparse($fileobj->ProcessFile());
106	>	my ($doctype,$docversion)=$tempdoc->doctype();
107	>	undef $tempdoc;
108	>
109	>	if ( ! defined $doctype ) {
110	>	$self->parseerror("No <Doc type=> Specified in ".$url);
111		}
112	+	$self->verbose("doctype required is $doctype $docversion");
113	+
114		# Set up a new object of the specified type
115	<	eval "require $tempdoc->{docobject}";
115	>	eval "require $doctype";
116		die $@ if $@;
117	<	my $newobj=$tempdoc->{docobject}->new($self->config());
284	<	undef $tempdoc;
117	>	my $newobj=$doctype->new($self->{Ostore}, $url);
118		$newobj->url($url);
119	<	$newobj->_initparse();
119	>	#$newobj->parent($self);
120		return $newobj;
121		}
122
123	<	sub _initparse {
123	>	sub parent {
124		my $self=shift;
125
126	<	$self->parse("init");
126	>	@_?$self->{parent}=shift
127	>	:$self->{parent};
128		}
295	–	# -------- Error Handling and Error services --------------
129
130	<	sub error {
298	<	my $self=shift;
299	<	my $string=shift;
300	<
301	<	die $string."\n";
302	<	}
130	>	# -------- Error Handling and Error services --------------
131
132		sub parseerror {
133		my $self=shift;
134		my $string=shift;
135
136	<	($line, $file)=$self->line();
137	<	print "Parse Error in ".$file->url().", line ".
136	>	if ( $self->currentparsename() eq "" ) {
137	>	$self->error($string);
138	>	}
139	>	elsif ( ! defined $self->{File} ) {
140	>	print "Parse Error in ".$self->filenameref()." line "
141	>	.$self->{currentparser}->line()."\n";
142	>	print $string."\n";
143	>	}
144	>	else {
145	>	($line, $file)=$self->line();
146	>	print "Parse Error in ".$file->url().", line ".
147		$line."\n";
148	<	print $string."\n";
149	<	die;
150	<	}
314	<
315	<	sub checktag {
316	<	my $self=shift;
317	<	my $tagname=shift;
318	<	my $hashref=shift;
319	<	my $param=shift;
320	<
321	<	if ( ! exists $$hashref{$param} ) {
322	<	$self->parseerror("Incomplete Tag <$tagname> : $param required");
323	<	}
148	>	print $string."\n";
149	>	}
150	>	exit;
151		}
152
153		sub line {
154		my $self=shift;
155	+	my $parseline;
156	+
157	+	if ( @_ ) {
158	+	$parseline=shift;
159	+	}
160	+	else {
161	+	$parseline=$self->{currentparser}->line();
162	+	}
163
164		my ($line, $fileobj)=
165	<	$self->{File}->realline($self->{currentparser}->line());
165	>	$self->{File}->realline($parseline);
166		return ($line, $fileobj);
167		}
168
#	Line 344 | Line 179 | sub file {
179		$self->{File}->file();
180		}
181
182	<	# --------------- Initialisation Methods ---------------------------
182	>	sub ProcessFile {
183	>	my $self=shift;
184
185	<	sub init {
350	<	# Dummy Routine - override for derived classes
185	>	return $self->{File}->ProcessedFile();
186		}
187
353	–	# ------------------- Tag Routines -----------------------------------
188		#
189	<	# Base - for setting url bases
189	>	# Delegate all else to the switch
190		#
191	<	sub Base_start {
192	<	my $self=shift;
359	<	my $name=shift;
360	<	my $hashref=shift;
191	>	#sub AUTOLOAD {
192	>	#        my $self=shift;
193
194	<	$self->checktag($name, $hashref, 'type' );
195	<	$self->checktag($name, $hashref, 'base' );
364	<
365	<	# Keep track of base tags
366	<	push @{$self->{basestack}}, $$hashref{"type"};
367	<	# Set the base
368	<	$self->{urlhandler}->setbase($$hashref{"type"},$hashref);
369	<	}
194	>	# dont propogate destroy methods
195	>	#        return if $AUTOLOAD=~/::DESTROY/;
196
197	<	sub Base_end {
198	<	my $self=shift;
199	<	my $name=shift;
200	<	my $type;
197	>	# remove this package name
198	>	#        ($name=$AUTOLOAD)=~s/ActiveDoc::ActiveDoc:://;
199	>
200	>	# pass the message to SimpleDoc
201	>	#        $self->{switch}->$name(@_);
202	>	#}
203
376	–	if ( $#{$self->{basestack}} == -1 ) {
377	–	print "Parse Error : unmatched </".$name."> on line ".
378	–	$self->line()."\n";
379	–	die;
380	–	}
381	–	else {
382	–	$type = pop @{$self->{basestack}};
383	–	$self->{urlhandler}->unsetbase($type);
384	–	}
385	–	}
204
205	+	# ------------------- Tag Routines -----------------------------------
206		sub Doc_Start {
207		my $self=shift;
208		my $name=shift;
#	Line 395 | Line 214 | sub Doc_Start {
214		$self->{docobject}=$$hashref{'type'};
215		}
216		}
398	–
399	–	sub userinterface {
400	–	my $self=shift;
401	–	@_?$self->{userinterface}=shift
402	–	:$self->{userinterface}
403	–	}

Diff Legend

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