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.4 by williamc, Mon Sep 27 14:05:22 1999 UTC vs.
Revision 1.25.2.1.2.6 by williamc, Mon Aug 21 18:40:13 2000 UTC

#	Line 1 | Line 1
1		#
2	<	# The base functionality for the ActiveDocument - inherits from Basetags
2	>	# ActiveDoc.pm
3	>	#
4	>	# Originally Written by Christopher Williams
5	>	#
6	>	# Description
7		#
4	–	# Inherits from BaseTags
5	–	# --------
8		# Interface
9		# ---------
10	<	# new(filename, DOChandler): create a new object based on a file and
11	<	#                                 associate with a base DOChandler
12	<	# parse()                       : parse the input file
13	<	# include(url) : Activate include file mechanism, returns the object ref if OK
14	<	# treenode()   : return the associated TreeNode object reference
15	<	# getincludeObjectStore : Return a pointer to the ObectStore that contains all
16	<	#                         included objects
17	<	# find(string)  : find the object reference related to string in the associated
18	<	#                 tree. Mechanism for getting object references
19	<	# _addgroup()   : Add group functionality to document
20	<	# parseerror(String) : Report an error to the user
21	<	# userinterface()       : return the default User Interface object
22	<	# checktag($hashref, param , tagname) : Check a hash returned from switcher
23	<	#                                       for a given parameter
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	>	# 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
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([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.001;
29	<	use ActiveDoc::DOChandler;
30	<	use ActiveDoc::TreeNode;
31	<	use ActiveDoc::UserQuery;
32	<	use ObjectStoreCont;
33	<
34	<	@ISA = qw(BaseTags);
28	>	require 5.004;
29	>	use ActiveDoc::SimpleURLDoc;
30	>	use ActiveDoc::PreProcessedFile;
31	>	use Utilities::Verbose;
32	>
33	>	@ISA = qw(ActiveDoc::SimpleURLDoc Utilities::Verbose);
34	>
35	>	sub new {
36	>	my $class=shift;
37	>	my $self={};
38	>	bless $self, $class;
39	>	$self->cache(shift);
40	>	$self->{dbstore}=shift;
41	>	$self->_initdoc("doc",@_);
42	>	#       $self->{switch}=ActiveDoc::SimpleURLDoc->new($self->{cache});
43	>	return $self;
44	>	}
45	>
46	>	sub url {
47	>	my $self=shift;
48	>	# get file & preprocess
49	>	if ( @_  ) {
50	>	$self->{origurl}=shift;
51	>	$self->{File}=$self->getfile($self->{origurl});
52	>	$self->filetoparse($self->{File}->ProcessedFile());
53	>	$self->verbose("url downloaded to ".$self->{File}->ProcessedFile());
54	>	}
55	>	if ( defined $self->{File} ) {
56	>	return $self->{File}->url();
57	>	}
58	>	else { return "undefined"; }
59	>	}
60
61	<	# Initialise
33	<	sub _init {
61	>	sub getfile {
62		my $self=shift;
63	<	my $DOChandler=shift;
36	<	my $OC=shift;
37	<
38	<	$self->_addurl();
39	<	$self->{urlhandler}->setcache($DOChandler->defaultcache());
40	<	$self->{treenode}=ActiveDoc::TreeNode->new();
41	<	$self->{dochandler}=$DOChandler;
42	<	$self->{UserQuery}=$DOChandler->{UserQuery};
43	<	$self->{tags}->addtag("Use", \&Use_Start, "", "");
44	<	# Add the minimal functionality tag - feel free to override
45	<	$self->{tags}->addtag("Include", \&Include_Start, "", "");
46	<	$self->init();
47	<	}
63	>	my $origurl=shift;
64
65	<	sub init {
66	<	# Dummy Routine - override for derrived classes
67	<	}
68	<	#
69	<	# use mechanism
54	<	#
55	<	sub include {
56	<	my $self=shift;
57	<	my $url=shift;
58	<	my $linkfile=shift;
59	<	my $filename;
60	<	my $obj;
61	<
62	<	$file=$self->{urlhandler}->get($url);
63	<	if ( ( defined $linkfile) && ( $linkfile ne "" ) ) {
64	<	$filename=$file."/".$linkfile;
65	>	my $fileref;
66	>	my ($url, $file);
67	>	if ( 0 ) {
68	>	$self->verbose("Forced download of $origurl");
69	>	($url, $file)=$self->urldownload($origurl);
70		}
71		else {
72	<	$filename=$file;
72	>	$self->verbose("Attempting to get $origurl");
73	>	($url, $file)=$self->urlget($origurl);
74		}
75	<	$obj=$self->{dochandler}->newdoc($filename);
76	<
77	<	# Now Extend our tree
78	<	$self->{treenode}->grow($obj->treenode());
79	<	return $obj;
75	>	# do we already have an appropriate object?
76	>	($fileref)=$self->{dbstore}->find($url);
77	>	if (  defined $fileref ) {
78	>	$self->verbose("Found $url in database");
79	>	$fileref->update();
80	>	}
81	>	else {
82	>	if ( $file eq "" ) {
83	>	$self->parseerror("Unable to get $origurl");
84	>	}
85	>	# -- set up a new preprocess file
86	>	$self->verbose("Making a new preprocessed file $url");
87	>	$fileref=ActiveDoc::PreProcessedFile->new($self->{dbstore});
88	>	$fileref->cache($self->{cache});
89	>	$fileref->url($url);
90	>	$fileref->update();
91	>	}
92	>	return $fileref;
93		}
94
95	<	sub userinterface {
95	>	sub activatedoc {
96		my $self=shift;
97	<	return $self->{dochandler}->{UserInterface};
97	>	my $url=shift;
98	>
99	>	# first get a preprocessed copy of the file
100	>	my $fileobj=$self->getfile($url);
101	>
102	>	# now parse it for the <Doc> tag
103	>	my $tempdoc=ActiveDoc::SimpleURLDoc->new($self->{cache});
104	>	$tempdoc->filetoparse($fileobj->ProcessFile());
105	>	my ($doctype,$docversion)=$tempdoc->doctype();
106	>	undef $tempdoc;
107	>
108	>	if ( ! defined $doctype ) {
109	>	$self->parseerror("No <Doc type=> Specified in ".$url);
110	>	}
111	>	$self->verbose("doctype required is $doctype $docversion");
112	>
113	>	# Set up a new object of the specified type
114	>	eval "require $doctype";
115	>	die $@ if $@;
116	>	my $newobj=$doctype->new($self->{cache},$self->{dbstore});
117	>	$newobj->url($url);
118	>	$newobj->parent($self);
119	>	return $newobj;
120		}
121
122	<	sub treenode {
122	>	sub parent {
123		my $self=shift;
83	–	return $self->{treenode};
84	–	}
124
125	<	sub getincludeObjectStore {
126	<	my $self=shift;
88	<	return $self->{includeOS};
125	>	@_?$self->{parent}=shift
126	>	:$self->{parent};
127		}
128
129	<	sub find($) {
130	<	my $self=shift;
131	<	my $string=shift;
132	<	my $tn;
129	>	# -------- Error Handling and Error services --------------
130	>
131	>	sub parseerror {
132	>	my $self=shift;
133	>	my $string=shift;
134
135	<	$tn=$self->{treenode}->find($string);
136	<	if ( $tn eq "" ) {
98	<	$self->parseerror("Unable to find $string");
135	>	if ( $self->currentparsename() eq "" ) {
136	>	$self->error($string);
137		}
138	<	return $tn->associate();
138	>	elsif ( ! defined $self->{File} ) {
139	>	print "Parse Error in ".$self->filenameref()." line "
140	>	.$self->{currentparser}->line()."\n";
141	>	print $string."\n";
142	>	}
143	>	else {
144	>	($line, $file)=$self->line();
145	>	print "Parse Error in ".$file->url().", line ".
146	>	$line."\n";
147	>	print $string."\n";
148	>	}
149	>	exit;
150		}
151
152		sub line {
153		my $self=shift;
154	<	return $self->{switch}->line();
106	<	}
154	>	my $parseline;
155
156	<	sub error {
157	<	my $self=shift;
158	<	my $string=shift;
156	>	if ( @_ ) {
157	>	$parseline=shift;
158	>	}
159	>	else {
160	>	$parseline=$self->{currentparser}->line();
161	>	}
162
163	<	die $string."\n";
163	>	my ($line, $fileobj)=
164	>	$self->{File}->realline($parseline);
165	>	return ($line, $fileobj);
166	>	}
167
168	+	sub tagstartline {
169	+	my $self=shift;
170	+	my ($line, $fileobj)=$self->{File}->line(
171	+	$self->{currentparser}->tagstartline());
172	+	return ($line, $fileobj);
173		}
174	<	sub parseerror {
174	>
175	>	sub file {
176		my $self=shift;
117	–	my $string=shift;
177
178	<	print "Parse Error in $self->{url}, line ".
120	<	$self->line()."\n";
121	<	print $string."\n";
122	<	die;
178	>	$self->{File}->file();
179		}
180
181	<	sub checktag {
181	>	sub ProcessFile {
182		my $self=shift;
127	–	my $hashref=shift;
128	–	my $param=shift;
129	–	my $tagname=shift;
183
184	<	if ( ! exists $$hashref{$param} ) {
132	<	$self->parseerror("Incomplete Tag <$tagname> : $param required");
133	<	}
184	>	return $self->{File}->ProcessedFile();
185		}
186
136	–	# ------------------------ Tag Routines ------------------------------
187		#
188	<	# The Include tag
188	>	# Delegate all else to the switch
189		#
190	+	#sub AUTOLOAD {
191	+	#        my $self=shift;
192
193	<	sub Include_Start {
194	<	my $self=shift;
143	<	my $name=shift;
144	<	my $hashref=shift;
193	>	# dont propogate destroy methods
194	>	#        return if $AUTOLOAD=~/::DESTROY/;
195
196	<	$self->{switch}->checkparam( $name, "ref");
197	<	print "<Include> tag not yet implemented\n";
198	<	#        $self->include($$hashref{'ref'},$$hashref{'linkdoc'});
199	<	}
196	>	# remove this package name
197	>	#        ($name=$AUTOLOAD)=~s/ActiveDoc::ActiveDoc:://;
198	>
199	>	# pass the message to SimpleDoc
200	>	#        $self->{switch}->$name(@_);
201	>	#}
202
151	–	sub Use_Start {
152	–	my $self=shift;
153	–	my $name=shift;
154	–	my $hashref=shift;
203
204	<	print "<Use> tag not yet implemented\n";
204	>	# ------------------- Tag Routines -----------------------------------
205	>	sub Doc_Start {
206	>	my $self=shift;
207	>	my $name=shift;
208	>	my $hashref=shift;
209	>
210	>	$self->checktag($name, $hashref, "type");
211	>	$self->{doctypefound}++;
212	>	if ( $self->{doctypefound} == 1 ) { # only take first doctype
213	>	$self->{docobject}=$$hashref{'type'};
214	>	}
215		}

Diff Legend

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