ViewVC Help
View File | Revision Log | Show Annotations | Root Listing
root/cvsroot/COMP/SCRAM/src/ActiveDoc/ActiveDoc.pm
(Generate patch)

Comparing COMP/SCRAM/src/ActiveDoc/ActiveDoc.pm (file contents):
Revision 1.12 by williamc, Fri Jan 14 18:01:03 2000 UTC vs.
Revision 1.22 by williamc, Mon Feb 21 17:36:33 2000 UTC

# Line 7 | Line 7
7   #
8   # Interface
9   # ---------
10 < # new()         : A new ActiveDoc object
10 > # new(ActiveConfig[,options])           : 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
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
# Line 20 | Line 22
22   # includeparse(local_parsename, objparsename, activedoc) : copy the parse from
23   #                                                       one object to another
24   # currentparsename([name]) : get/set current parse name
23 # newdoc(file)  : Return an new object of the appropriate type
25   # getfile(url)  : get a processedfile object given a url
26   # activatedoc(url) : Return the object ref for a doc described by the given url
27 + #                    -- any parse called "init" will also be run
28   # config([ActiveConfig]) : Set up/return Configuration for the document
29   # basequery([ActiveConfig]) : Set up/return UserQuery for the doc
30   # copydocconfig(ActiveDoc) : Copy the basic configuration from the ActiveDoc
31   # copydocquery(ActiveDoc) : Copy the basicquery from the ActiveDoc
32   # userinterface()       : Return the defaullt userinterface
33 < # options(var)          : return the value of the option var
33 > # option(var)           : return the value of the option var ( or undef )
34 > # requestoption("message") : Ask the user to supply a value for an option
35 > #                            if it dosnt already exist
36 > # askuser(Query)        : send a query object to the userinterface
37 > # verbose(string)       : Print string in verbosity mode
38   #
39   # -- error methods --
40   # error(string)       : Report an general error to the user
# Line 51 | Line 57 | sub new {
57          $self={};
58          bless $self, $class;
59          $self->config(shift);
60 <        
60 >
61 >        # have some override options been passed
62 >        if ( @_ ) {
63 >           $self->basequery(shift);
64 >        }
65 >        else {
66 >           # --- is there a starter document?
67 >           my $basedoc=$self->config()->basedoc();
68 >           if ( defined $basedoc ) {
69 >             $self->copydocquery($basedoc);
70 >             $self->verbose("Initialising from $basedoc");
71 >           }
72 >           else {
73 >             $self->error("ActiveDoc Error : No base doc found");
74 >           }
75 >        }
76 >        $self->verbose("New ActiveDoc (".ref($self).") Created");
77 >        $self->_init2();
78 > }
79 >
80 > sub _init2 {
81 >
82 >        my $self=shift;
83          # A URL handler per document
84          $self->{urlhandler}=URL::URLhandler->new($self->config()->cache());
85  
# Line 59 | Line 87 | sub new {
87          $self->{userinterface}=ActiveDoc::SimpleUserInterface->new();
88          $self->init(@_);
89          return $self;
90 +
91 + }
92 +
93 + sub verbose {
94 +        my $self=shift;
95 +        my $string=shift;
96 +
97 +        if ( $self->option('verbose_all') ||
98 +                        $self->option('verbose_'.ref($self)) ) {
99 +          print ">".ref($self)."($self) : \n->".$string."\n";
100 +        }
101   }
102  
103   # ----- parse related routines --------------
# Line 66 | Line 105 | sub parse {
105          my $self=shift;
106          $parselabel=shift;
107  
108 <        my $file=$self->file();
108 >        my $file=$self->ProcessFile();
109          if ( $file ) {
110 <          $self->{currentparsename}=$parselabel;
111 <          $self->{currentparser}=$self->{parsers}{$parselabel};
112 <          $self->{parsers}{$parselabel}->parse($file,@_);
113 <          delete $self->{currentparser};
114 <          $self->{currentparsename}="";
110 >          if ( exists $self->{parsers}{$parselabel} ) {
111 >            $self->verbose("Parsing $parselabel in file $file");
112 >            $self->{currentparsename}=$parselabel;
113 >            $self->{currentparser}=$self->{parsers}{$parselabel};
114 >            $self->{parsers}{$parselabel}->parse($file,@_);
115 >            delete $self->{currentparser};
116 >            $self->{currentparsename}="";
117 >            $self->verbose("Parse $parselabel Complete");
118 >          }
119          }
120          else {
121            print "Cannot parse - file not known\n";
# Line 94 | Line 137 | sub newparse {
137          $self->{parsers}{$parselabel}->addgrouptags();
138   }
139  
140 + sub cleartags {
141 +        my $self=shift;
142 +        my $parselabel=shift;
143 +
144 +        $self->{parsers}{$parselabel}->cleartags();
145 + }
146 +
147 +
148   sub includeparse {
149          my $self=shift;
150          my $parselabel=shift;
# Line 135 | Line 186 | sub addurltags {
186   sub url {
187          my $self=shift;
188          # get file & preprocess
189 <        if ( @_  ) {$self->{File}=$self->getfile(shift)}
189 >        if ( @_  ) {
190 >                $self->{File}=$self->getfile(shift);
191 >                $self->verbose("url downloaded to $self->{File}");
192 >        }
193          $self->{File}->url();
194   }
195  
# Line 151 | Line 205 | sub copydocquery {
205          my $self=shift;
206          my $ActiveDoc=shift;
207  
208 <         $self->basequery($ActiveDoc->basequery());
208 >        if ( defined $ActiveDoc->basequery() ) {
209 >          $self->basequery($ActiveDoc->basequery());
210 >        }
211 >        else {
212 >          $self->error("Cannot copy basequery - undefined");
213 >        }
214   }
215  
216   sub config {
# Line 162 | Line 221 | sub config {
221  
222   sub basequery {
223          my $self=shift;
224 <        @_ ? $self->{Query}=shift
225 <           : $self->{Query};
224 >        @_?$self->{Query}=shift
225 >           :$self->{Query};
226   }
227  
228 < sub options {
228 > sub option {
229          my $self=shift;
230          my $param=shift;
231 <        $self->basequery()->getparam('option_'.$param);
231 >        if ( defined $self->basequery()) {
232 >                return $self->basequery()->getparam($param);
233 >        }
234 >        else {
235 >                return $undef;
236 >        }
237   }
238  
239 < sub getfile() {
239 > sub requestoption {
240 >        my $self=shift;
241 >        my $param=shift;
242 >        my $string=shift;
243 >
244 >        my $par=undef;
245 >        if ( defined $self->basequery()) {
246 >        $par=$self->basequery()->getparam($param);
247 >        while ( ! defined $par ) {
248 >          $self->basequery()->querytype( $param, "basic");
249 >          $self->basequery()->querymessage( $param, $string);
250 >          $self->userinterface()->askuser($self->basequery());
251 >          $par=$self->basequery()->getparam($param);
252 >        }
253 >        }
254 >        return $par;
255 > }
256 >
257 > sub askuser {
258 >        my $self=shift;
259 >        return $self->userinterface()->askuser(@_);
260 > }
261 >
262 > sub getfile {
263          my $self=shift;
264          my $origurl=shift;
265  
266          my $fileref;
267 <        my ($url, $file)=$self->{urlhandler}->get($origurl);
267 >        my ($url, $file);
268 >        if ( (defined ($it=$self->option('url_update'))) &&
269 >                ( $it eq "1" || $origurl=~/^$it/ )) {
270 >             $self->verbose("Forced download of $origurl");
271 >             ($url, $file)=$self->{urlhandler}->download($origurl);
272 >        }
273 >        else {
274 >           $self->verbose("Attempting to get $origurl");
275 >           ($url, $file)=$self->{urlhandler}->get($origurl);
276 >        }
277          # do we already have an appropriate object?
278          ($fileref)=$self->config()->find($url);
279          #undef $fileref;
280          if (  defined $fileref ) {
281 <         print "found $url in database ----\n";
281 >         $self->verbose("Found $url in database");
282           $fileref->update();
283          }
284          else {
# Line 190 | Line 286 | sub getfile() {
286             $self->parseerror("Unable to get $origurl");
287           }
288           #-- set up a new preprocess file
289 <         print "Making a new file $url----\n";
289 >         $self->verbose("Making a new preprocessed file $url");
290           $fileref=ActiveDoc::PreProcessedFile->new($self->config());
291           $fileref->url($url);
292           $fileref->update();
# Line 203 | Line 299 | sub activatedoc {
299          my $url=shift;
300  
301          # first get a preprocessed copy of the file
302 <        my $fileob=$self->getfile($url);
302 > #       my $fileob=$self->getfile($url);
303  
304          # now parse it for the <DocType> tag
305 <        $self->{doctypefound}=0;
306 <        $self->newparse("doctype");
307 <        $self->addtag("doctype","Doc", \&Doc_Start, $self,
308 <                                          "", $self, "", $self);
309 <        $self->parse("doctype");
305 >        my $tempdoc=ActiveDoc::ActiveDoc->new($self->config());
306 >        $tempdoc->{urlhandler}=$self->{urlhandler};
307 >        my $fullurl=$tempdoc->url($url);
308 >        $url=$fullurl;
309 >        $tempdoc->{doctypefound}=0;
310 >        $tempdoc->newparse("doctype");
311 >        $tempdoc->addtag("doctype","Doc", \&Doc_Start, $tempdoc,
312 >                                          "", $tempdoc, "", $tempdoc);
313 >        $tempdoc->parse("doctype");
314  
315 <        if ( ! defined $self->{docobject} ) {
316 <          print "No <Doc type=> Specified in ".$fileob->url()."\n";
315 >        if ( ! defined $tempdoc->{docobject} ) {
316 >          print "No <Doc type=> Specified in ".$url."\n";
317            exit 1;
318          }
319          # Set up a new object of the specified type
320 <        my $newobj=$self->{docobject}->new($self->config());
320 >        eval "require $tempdoc->{docobject}";
321 >        die $@ if $@;
322 >        my $newobj=$tempdoc->{docobject}->new($self->config());
323 >        undef $tempdoc;
324          $newobj->url($url);
325 +        $newobj->parent($self);
326 +        $newobj->_initparse();
327          return $newobj;
328   }
329  
330 + sub parent {
331 +        my $self=shift;
332 +
333 +        @_?$self->{parent}=shift
334 +          :$self->{parent};
335 + }
336 +
337 + sub _initparse {
338 +        my $self=shift;
339 +
340 +        $self->parse("init");
341 + }
342   # -------- Error Handling and Error services --------------
343  
344   sub error {
# Line 235 | Line 352 | sub parseerror {
352          my $self=shift;
353          my $string=shift;
354  
355 <        ($line, $file)=$self->line();
356 <        print "Parse Error in ".$file->url().", line ".
355 >        if ( $self->currentparsename() eq "" ) {
356 >                $self->error($string);
357 >        }
358 >        else {
359 >         ($line, $file)=$self->line();
360 >         print "Parse Error in ".$file->url().", line ".
361                                          $line."\n";
362 <        print $string."\n";
363 <        die;
362 >         print $string."\n";
363 >         exit;
364 >        }
365   }
366  
367   sub checktag {
# Line 274 | Line 396 | sub file {
396          $self->{File}->file();
397   }
398  
399 + sub ProcessFile {
400 +        my $self=shift;
401 +
402 +        return $self->{File}->ProcessedFile();
403 + }
404 +
405   # --------------- Initialisation Methods ---------------------------
406  
407   sub init {
# Line 296 | Line 424 | sub Base_start {
424          push @{$self->{basestack}}, $$hashref{"type"};
425          # Set the base
426          $self->{urlhandler}->setbase($$hashref{"type"},$hashref);
299
427   }
428  
429   sub Base_end {
# Line 305 | Line 432 | sub Base_end {
432          my $type;
433  
434          if ( $#{$self->{basestack}} == -1 ) {
435 <                print "Parse Error : unmatched </".$name."> on line ".
309 <                        $self->line()."\n";
310 <                die;
435 >                $self->parseerror("Parse Error : unmatched </$name>");
436          }
437          else {
438            $type = pop @{$self->{basestack}};

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines