src/ActiveDoc/ActiveDoc.pm

#
# ActiveDoc.pm
#
# Originally Written by Christopher Williams
#
# Description
#
# Interface
# ---------
# new()         : A new ActiveDoc object
# url()         : Return/set the docs url - essential
# file()        : Return the local filename of document
#
# parse(parselabel): Parse the document file for the given parse level
# newparse(parselabel) : Create a new parse type
# addtag(parselabel,tagname,start,obj,text,obj,end,obj)
#                               : Add tags to the parse given by label
# newdoc(file)  : Return an new object of the appropriate type
# getfile(url)  : get a processedfile object given a url
# config([ActiveConfig]) : Set up/return Configuration for the document
# basequery([ActiveConfig]) : Set up/return UserQuery for the doc
# copydocconfig(ActiveDoc) : Copy the basic configuration from the ActiveDoc
# copydocquery(ActiveDoc) : Copy the basicquery from the ActiveDoc
#
# -- error methods --
# error(string)       : Report an general error to the user
# parseerror(string)  : Report an error during parsing a file
# line()              : Return the current line number of the document
#                       and the ProcessedFileObj it is in

package ActiveDoc::ActiveDoc;
require 5.004;
use ActiveDoc::Parse;
use ActiveDoc::ActiveConfig;
use ActiveDoc::PreProcessedFile;
use ObjectUtilities::ObjectBase;
use URL::URLhandler;

@ISA = qw(ObjectUtilities::ObjectBase);

sub new {
        my $class=shift;
        $self={};
        bless $self, $class;
        $self->config(shift);
        
        # A URL handler per document
        $self->{urlhandler}=URL::URLhandler->new($self->config()->cache());

        $self->init(@_);
        return $self;
}

# ----- parse related routines --------------
sub parse {
        my $self=shift;
        $parselabel=shift;

        my $file=$self->file();
        print "Parse called on file $file\n";
        if ( $file ) {
          $self->{parsers}{$parselabel}->parse($file,@_);
        }
        else {
          print "Cannot parse - file not known\n";
        }
}

sub newparse {
        my $self=shift;
        my $parselabel=shift;

        $self->{parsers}{$parselabel}=ActiveDoc::Parse->new();
        $self->{parsers}{$parselabel}->addignoretags();
        $self->{parsers}{$parselabel}->addgrouptags();
}

sub addtag {
        my $self=shift;
        my $parselabel=shift;
        if ( $#_ != 6 ) {
                $self->error("Incorrect addtags specification\n".
                                "called with :\n@_ \n");
        }
        $self->{parsers}{$parselabel}->addtag(@_);
}

sub addurltags {
        my $self=shift;
        my $parselabel=shift;
        
        $self->{parsers}{$parselabel}->
                addtag("Base", \&Base_start, $self, "", $self,
                        \&Base_end, $self);
}

sub url {
        my $self=shift;
        @_ ?$self->{File}=$self->getfile(shift)
            : $self->{File};
}

sub copydocconfig {
        my $self=shift;
        my $ActiveDoc=shift;
        
        $self->config($ActiveDoc->config());

}

sub copydocquery {
        my $self=shift;
        my $ActiveDoc=shift;

         $self->basequery($ActiveDoc->basequery());
}

sub config {
        my $self=shift;
        @_?$self->{ActiveConfig}=shift
           : $self->{ActiveConfig};
}

sub basequery {
        my $self=shift;
        @_ ? $self->{UserQuery}=shift
           : $self->{UserQuery};
}

sub getfile() {
        my $self=shift;
        my $origurl=shift; 

        my $fileref;
        print "GETFILE called\n";
        my ($url, $file)=$self->{urlhandler}->get($origurl);
        # do we already have an appropriate object?
        #my ($fileref)=$self->config()->find("__preprocessed",$url);
        undef $fileref;
        if (  defined $fileref ) {
         print "found $url in database ----\n";
         $fileref->update();
        }
        else {
         if ( $file eq "" ) {
           $self->parseerror("Unable to get $origurl");
         }
         #-- set up a new preprocess file
         print "Making a new file $url----\n";
         $fileref=ActiveDoc::PreProcessedFile->new($self->config());
         $fileref->url($url);
         $fileref->update();
         $self->config()->store($fileref,"__preprocessed",$url);
        }
        print "---------- returning".$fileref."\n";
        return $fileref;
}

# -------- Error Handling and Error services --------------

sub error {
        my $self=shift;
        my $string=shift;

        die $string."\n";
}

sub parseerror {
        my $self=shift;
        my $string=shift;

        ($line, $file)=$self->line();
        print "Parse Error in ".$file->url().", line ".
                                        $line."\n";
        print $string."\n";
        die;
}

sub checktag {
        my $self=shift;
        my $tagname=shift;
        my $hashref=shift;
        my $param=shift;

        if ( ! exists $$hashref{$param} ) {
          $self->parseerror("Incomplete Tag <$tagname> : $param required");
        }
}

sub line {
        $self=shift;
        my ($line, $fileobj)=
                $self->{Processedfile}->line($self->{switch}->line());
        return ($line, $fileobj);
}

sub file {
        my $self=shift;

        $self->{PPf}->file();
}

# --------------- Initialisation Methods ---------------------------

sub preprocess_init {
        my $self=shift;
        $self->{PPfile}=PreProcessedFile->new($self->config());
}

sub init {
        # Dummy Routine - override for derived classes
}

# ------------------- Tag Routines -----------------------------------
#
# Base - for setting url bases
#
sub Base_start {
        my $self=shift;
        my $name=shift;
        my $hashref=shift;

        $self->checktag($name, $hashref, 'type' );
        $self->checktag($name, $hashref, 'base' );
       
        # Keep track of base tags
        push @{$self->{basestack}}, $$hashref{"type"};
        # Set the base
        $self->{urlhandler}->setbase($$hashref{"type"},$hashref);

}

sub Base_end {
        my $self=shift;
        my $name=shift;
        my $type;

        if ( $#{$self->{basestack}} == -1 ) {
                print "Parse Error : unmatched </".$name."> on line ".
                        $self->line()."\n";
                die;
        }
        else {
          $type = pop @{$self->{basestack}};
          $self->{urlhandler}->unsetbase($type);
        }
}
Revision:	1.6
Committed:	Fri Nov 19 15:27:46 1999 UTC (25 years, 5 months ago) by williamc
Content type:	text/plain
Branch:	MAIN
Changes since 1.5:	+198 -108 lines
Log Message:	getfile working reasonably - without database lookups at least
#	User	Rev	Content
1	williamc	1.1	#
2	williamc	1.6	# ActiveDoc.pm
3			#
4			# Originally Written by Christopher Williams
5			#
6			# Description
7	williamc	1.1	#
8			# Interface
9			# ---------
10	williamc	1.6	# new() : A new ActiveDoc object
11			# url() : Return/set the docs url - essential
12			# file() : Return the local filename of document
13			#
14			# 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			# newdoc(file) : Return an new object of the appropriate type
19			# getfile(url) : get a processedfile object given a url
20			# config([ActiveConfig]) : Set up/return Configuration for the document
21			# basequery([ActiveConfig]) : Set up/return UserQuery for the doc
22			# copydocconfig(ActiveDoc) : Copy the basic configuration from the ActiveDoc
23			# copydocquery(ActiveDoc) : Copy the basicquery from the ActiveDoc
24			#
25			# -- error methods --
26			# error(string) : Report an general error to the user
27			# parseerror(string) : Report an error during parsing a file
28			# line() : Return the current line number of the document
29			# and the ProcessedFileObj it is in
30	williamc	1.2
31			package ActiveDoc::ActiveDoc;
32	williamc	1.6	require 5.004;
33			use ActiveDoc::Parse;
34			use ActiveDoc::ActiveConfig;
35			use ActiveDoc::PreProcessedFile;
36			use ObjectUtilities::ObjectBase;
37			use URL::URLhandler;
38
39			@ISA = qw(ObjectUtilities::ObjectBase);
40
41			sub new {
42			my $class=shift;
43			$self={};
44			bless $self, $class;
45			$self->config(shift);
46
47			# A URL handler per document
48			$self->{urlhandler}=URL::URLhandler->new($self->config()->cache());
49
50			$self->init(@_);
51			return $self;
52			}
53
54			# ----- parse related routines --------------
55			sub parse {
56			my $self=shift;
57			$parselabel=shift;
58
59			my $file=$self->file();
60			print "Parse called on file $file\n";
61			if ( $file ) {
62			$self->{parsers}{$parselabel}->parse($file,@_);
63			}
64			else {
65			print "Cannot parse - file not known\n";
66			}
67	williamc	1.1	}
68
69	williamc	1.6	sub newparse {
70			my $self=shift;
71			my $parselabel=shift;
72
73			$self->{parsers}{$parselabel}=ActiveDoc::Parse->new();
74			$self->{parsers}{$parselabel}->addignoretags();
75			$self->{parsers}{$parselabel}->addgrouptags();
76	williamc	1.2	}
77	williamc	1.6
78			sub addtag {
79			my $self=shift;
80			my $parselabel=shift;
81			if ( $#_ != 6 ) {
82			$self->error("Incorrect addtags specification\n".
83			"called with :\n@_ \n");
84	williamc	1.4	}
85	williamc	1.6	$self->{parsers}{$parselabel}->addtag(@_);
86			}
87	williamc	1.2
88	williamc	1.6	sub addurltags {
89			my $self=shift;
90			my $parselabel=shift;
91
92			$self->{parsers}{$parselabel}->
93			addtag("Base", \&Base_start, $self, "", $self,
94			\&Base_end, $self);
95	williamc	1.1	}
96
97	williamc	1.6	sub url {
98	williamc	1.2	my $self=shift;
99	williamc	1.6	@_ ?$self->{File}=$self->getfile(shift)
100			: $self->{File};
101	williamc	1.2	}
102
103	williamc	1.6	sub copydocconfig {
104	williamc	1.1	my $self=shift;
105	williamc	1.6	my $ActiveDoc=shift;
106
107			$self->config($ActiveDoc->config());
108
109	williamc	1.1	}
110
111	williamc	1.6	sub copydocquery {
112			my $self=shift;
113			my $ActiveDoc=shift;
114
115			$self->basequery($ActiveDoc->basequery());
116	williamc	1.1	}
117
118	williamc	1.6	sub config {
119	williamc	1.1	my $self=shift;
120	williamc	1.6	@_?$self->{ActiveConfig}=shift
121			: $self->{ActiveConfig};
122			}
123	williamc	1.1
124	williamc	1.6	sub basequery {
125			my $self=shift;
126			@_ ? $self->{UserQuery}=shift
127			: $self->{UserQuery};
128	williamc	1.2	}
129
130	williamc	1.6	sub getfile() {
131	williamc	1.3	my $self=shift;
132	williamc	1.6	my $origurl=shift;
133
134			my $fileref;
135			print "GETFILE called\n";
136			my ($url, $file)=$self->{urlhandler}->get($origurl);
137			# do we already have an appropriate object?
138			#my ($fileref)=$self->config()->find("__preprocessed",$url);
139			undef $fileref;
140			if ( defined $fileref ) {
141			print "found $url in database ----\n";
142			$fileref->update();
143			}
144			else {
145			if ( $file eq "" ) {
146			$self->parseerror("Unable to get $origurl");
147			}
148			#-- set up a new preprocess file
149			print "Making a new file $url----\n";
150			$fileref=ActiveDoc::PreProcessedFile->new($self->config());
151			$fileref->url($url);
152			$fileref->update();
153			$self->config()->store($fileref,"__preprocessed",$url);
154			}
155			print "---------- returning".$fileref."\n";
156			return $fileref;
157	williamc	1.3	}
158
159	williamc	1.6	# -------- Error Handling and Error services --------------
160
161	williamc	1.3	sub error {
162	williamc	1.6	my $self=shift;
163			my $string=shift;
164
165			die $string."\n";
166			}
167
168			sub parseerror {
169			my $self=shift;
170			my $string=shift;
171
172			($line, $file)=$self->line();
173			print "Parse Error in ".$file->url().", line ".
174			$line."\n";
175			print $string."\n";
176			die;
177			}
178
179			sub checktag {
180			my $self=shift;
181			my $tagname=shift;
182			my $hashref=shift;
183			my $param=shift;
184	williamc	1.3
185	williamc	1.6	if ( ! exists $$hashref{$param} ) {
186			$self->parseerror("Incomplete Tag <$tagname> : $param required");
187			}
188			}
189	williamc	1.3
190	williamc	1.6	sub line {
191			$self=shift;
192			my ($line, $fileobj)=
193			$self->{Processedfile}->line($self->{switch}->line());
194			return ($line, $fileobj);
195	williamc	1.3	}
196	williamc	1.6
197			sub file {
198	williamc	1.2	my $self=shift;
199
200	williamc	1.6	$self->{PPf}->file();
201	williamc	1.2	}
202
203	williamc	1.6	# --------------- Initialisation Methods ---------------------------
204
205			sub preprocess_init {
206	williamc	1.2	my $self=shift;
207	williamc	1.6	$self->{PPfile}=PreProcessedFile->new($self->config());
208			}
209	williamc	1.2
210	williamc	1.6	sub init {
211			# Dummy Routine - override for derived classes
212	williamc	1.1	}
213
214	williamc	1.6	# ------------------- Tag Routines -----------------------------------
215	williamc	1.1	#
216	williamc	1.6	# Base - for setting url bases
217	williamc	1.1	#
218	williamc	1.6	sub Base_start {
219			my $self=shift;
220			my $name=shift;
221			my $hashref=shift;
222	williamc	1.2
223	williamc	1.6	$self->checktag($name, $hashref, 'type' );
224			$self->checktag($name, $hashref, 'base' );
225
226			# Keep track of base tags
227			push @{$self->{basestack}}, $$hashref{"type"};
228			# Set the base
229			$self->{urlhandler}->setbase($$hashref{"type"},$hashref);
230	williamc	1.2
231	williamc	1.1	}
232
233	williamc	1.6	sub Base_end {
234			my $self=shift;
235	williamc	1.1	my $name=shift;
236	williamc	1.6	my $type;
237	williamc	1.1
238	williamc	1.6	if ( $#{$self->{basestack}} == -1 ) {
239			print "Parse Error : unmatched </".$name."> on line ".
240			$self->line()."\n";
241			die;
242			}
243			else {
244			$type = pop @{$self->{basestack}};
245			$self->{urlhandler}->unsetbase($type);
246			}
247	williamc	1.1	}