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.1 by williamc, Fri Aug 20 09:09:28 1999 UTC vs.
Revision 1.25.2.1.2.8 by williamc, Mon Aug 28 07:23:36 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, ObjectStoreCont): create a new object based on a file and
11	<	#                                 associate with the given ObjectStoreCont
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
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	>	# 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.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->{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;
45	>	}
46
47	+	sub url {
48	+	my $self=shift;
49	+	# get file & preprocess
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	+	else { return "undefined"; }
60	+	}
61
62	<	package ActiveDoc;
63	<	use BaseTags;
64	<	use DOChandler;
22	<	use ObjectStoreCont;
62	>	sub getfile {
63	>	my $self=shift;
64	>	my $origurl=shift;
65
66	<	@ISA = qw (BaseTags);
66	>	my $fileref;
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->{dbstore}->find($url);
78	>	if (  defined $fileref ) {
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	>	$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	>	}
93	>	return $fileref;
94	>	}
95
96	<	# Initialise
27	<	sub _init {
96	>	sub activatedoc {
97		my $self=shift;
98	<	my $OC=shift;
98	>	my $url=shift;
99	>
100	>	# first get a preprocessed copy of the file
101	>	my $fileobj=$self->getfile($url);
102
103	<	$self->_addurl();
104	<	$self->{OC}=$OC;
105	<	$self->{treenode)=TreeNode->new();
106	<	$self->{includeOS}=$self->{OC}->newStore();
107	<	$self->{dochandler}=DOChandler->new($self->{includeOS});
108	<	# Add the minimal functionality tag - feel free to override
109	<	$self->{tags}->addtag("Include", \&Include_Start, "", "");
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 $doctype";
116	>	die $@ if $@;
117	>	my $newobj=$doctype->new($self->{Ostore}, $url);
118	>	$newobj->url($url);
119	>	#$newobj->parent($self);
120	>	return $newobj;
121		}
122
123	<	#
124	<	# Include mechanism
125	<	#
126	<	sub include {
123	>	sub parent {
124	>	my $self=shift;
125	>
126	>	@_?$self->{parent}=shift
127	>	:$self->{parent};
128	>	}
129	>
130	>	# -------- Error Handling and Error services --------------
131	>
132	>	sub parseerror {
133		my $self=shift;
134	<	my $url=shift;
46	<	my $obj;
134	>	my $string=shift;
135
136	<	$obj=$self->{dochandler}->newdoc($url);
137	<	# Now Extend our tree
138	<	$self->{treenode}->grow($obj->treenode());
139	<	return $obj;
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	>	}
150	>	exit;
151		}
152
153	<	sub treenode {
153	>	sub line {
154		my $self=shift;
155	<	return $self->treenode;
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($parseline);
166	>	return ($line, $fileobj);
167		}
168
169	<	sub getincludeObjectStore {
170	<	my $self=shift;
171	<	return $self->{includeOS};
169	>	sub tagstartline {
170	>	my $self=shift;
171	>	my ($line, $fileobj)=$self->{File}->line(
172	>	$self->{currentparser}->tagstartline());
173	>	return ($line, $fileobj);
174		}
175
176	<	sub find($) {
176	>	sub file {
177		my $self=shift;
66	–	my $string=shift;
178
179	<	$self->{treenode}->find($string);
179	>	$self->{File}->file();
180		}
181
182	<	# ------------------------ Tag Routines ------------------------------
183	<	#
184	<	# A default Include tag
185	<	#
75	<	sub Include_Start {
76	<	my $returnval;
77	<	# Just call the basic - this is only a default wrapper for the
78	<	# <INCLUDE> tag assuming with no futher processing of the DOCObjref
79	<	$returnval=_includetag(@_)
80	<	# dont return anything if its a basic tag
182	>	sub ProcessFile {
183	>	my $self=shift;
184	>
185	>	return $self->{File}->ProcessedFile();
186		}
187
83	–	# ----------------------- Support Routines ---------------------------
188		#
189	<	# the real workings of the include tag returns the ref
189	>	# Delegate all else to the switch
190		#
191	<	sub _includetag {
192	<	my $self=shift;
89	<	my $name=shift;
90	<	my $hashref=shift;
191	>	#sub AUTOLOAD {
192	>	#        my $self=shift;
193
194	<	$self->{switch}->checkparam( $name, "ref");
195	<	$url=$$hashref{'ref'};
196	<	return $self->include($url);
197	<	}
194	>	# dont propogate destroy methods
195	>	#        return if $AUTOLOAD=~/::DESTROY/;
196	>
197	>	# remove this package name
198	>	#        ($name=$AUTOLOAD)=~s/ActiveDoc::ActiveDoc:://;
199	>
200	>	# pass the message to SimpleDoc
201	>	#        $self->{switch}->$name(@_);
202	>	#}
203
204	+
205	+	# ------------------- Tag Routines -----------------------------------
206	+	sub Doc_Start {
207	+	my $self=shift;
208	+	my $name=shift;
209	+	my $hashref=shift;
210	+
211	+	$self->checktag($name, $hashref, "type");
212	+	$self->{doctypefound}++;
213	+	if ( $self->{doctypefound} == 1 ) { # only take first doctype
214	+	$self->{docobject}=$$hashref{'type'};
215	+	}
216	+	}

Diff Legend

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