src/BuildSystem/Requirements.pm

# Requirements Doc - just to get ordering info
#
# Interface
# ---------
# new(ActiveStore,url[,arch])     : new requirements doc
# setup(toolbox): set up the requirements into the specified toolbox object
# download(toolbox)    : download description files (into toolbox cache)
# tools()       : Return list of ALL requirements (ordered)
# selectedtools() : Return list of only those tools selected
# version(tool) : return the version of a given tool
# toolurl(tool)     : return the url of a given tool
# getreqforarch(arch) : Return a RequirementsObject corresponding to the
#                       specified architecture
# toolcomment(tool,version) : return the comment string for the specified tool
# distributionurl(tool,version) : return the dist info url for the tool

package BuildSystem::Requirements;
use ActiveDoc::ActiveDoc;
use Utilities::Verbose;

require 5.004;
@ISA=qw(Utilities::Verbose);

sub new
   {
   my $class=shift;
   my $self={};
   bless $self, $class;
   $self->{dbstore}=shift;
   $self->{file}=shift;
   $self->{cache}=$self->{dbstore}->cache();

   if ( @_ )
      {
      $self->arch(shift);
      }
   $self->verbose("Initialising a new Requirements Doc");
   $self->{mydocversion}="2.0";
   # Counter for downloaded tools: zero it here. It will
   # be auto-incremented as each tool is selected:
   $self->{selectcounter}=0;
   
   $self->{Arch}=1;
   push @{$self->{ARCHBLOCK}}, $self->{Arch};
   $self->init($self->{file});
   return $self;
   }

sub toolmanager
   {
   my $self=shift;
   
   @_ ? $self->{toolmanagerobject} = shift
      : $self->{toolmanagerobject};
   
   }

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

sub url
   {
   my $self=shift;
   
   if ( @_ )
      {
      $self->{file}=shift;
      }
   return $self->{file};
   }

sub tools
   {
   my $self=shift;
   return @{$self->{tools}};
   }

sub toolcomment
   {
   my $self=shift;
   my $tool=shift;
   my $version=shift;
   
   return $self->{reqtext}{$tool}{$version};
   }

sub distributionurl
   {
   my $self=shift;
   my $tool=shift;
   my $version=shift;
   
   return ( defined $self->{dist}{$tool}{$version})?
      $self->{dist}{$tool}{$version}:undef;
   }

sub version
   {
   my $self=shift;
   my $tool=shift;
   return $self->{'version'}{$tool};
   }

sub toolurl
   {
   my $self=shift;
   my $tool=shift;
   return $self->{'url'}{$tool};
   }

sub init
   {
   my $self=shift;
   my $url=shift;
   
   my $switch=ActiveDoc::ActiveDoc->new($self->{dbstore});
   $switch->verbosity($self->verbosity());
   $switch->url($url);
   $switch->newparse("ordering");
   $switch->addbasetags("ordering");
   
   $switch->addtag("ordering","Architecture",
                   \&Arch_Start,$self,
                   "", $self,
                   \&Arch_End, $self);
   $switch->addtag("ordering","select",
                   \&select_start,$self,
                   "", $self,
                   "", $self);
   $switch->grouptag("Architecture","ordering");
   $switch->addtag("ordering","require",
                   \&require_start,$self,
                   \&require_text, $self,
                   \&require_end, $self);
   
   $self->{reqcontext}=0;
   $self->{switch}=$switch;
   undef $self->{restrictstack};
   @{$self->{tools}}=();
   
   my($doctype,$docversion)=$switch->doctype();
   # -- for backwards compatability only parse if we have a docversion
   #    defined (SFA: I think this is pretty much out of date):
   if ( defined $docversion )
      { 
      if ($docversion eq $self->{mydocversion})
         {
         @{$self->{ArchStack}}=();
         $self->verbose("Initial Document Parse");
         $self->{switch}->parse("ordering");
         $self->configversion($switch->{configurl}->param('version'));
         }
      else
         {
         $self->verbose("wrong doc version - not parsing");
         }
      }
   else
      {
      $self->verbose("wrong doc type - not parsing");
      }
   }

sub arch
   {
   my $self=shift;
   # $self->arch is the SCRAM_ARCH value:
   if ( @_ )
      {
      $self->{arch}=shift;
      }
   else
      {
      if ( ! defined $self->{arch} )
         {
         $self->{arch}="";
         }
      }
   return $self->{arch};
   }

sub archlist
   {
   my $self=shift;
   return @{$self->{ArchStack}};
   }

sub getreqforarch
   {
   my $self=shift;
   my $arch=shift;
   
   if ( ! defined $self->{reqsforarch}{$arch} )
      {
      $self->{reqsforarch}{$arch}=
         BuildSystem::Requirements->new($self->{dbstore},$self->{file},
                                        $arch);
      }
   return $self->{reqsforarch}{$arch};
   }

sub download
   {
   my $self=shift;
   my $tool;
   $| = 1; # Unbuffer the output

   print  "Downloading tool descriptions....","\n";
   print  " ";
   foreach $tool ( $self->tools() )
      {
      print "#";
      $self->verbose("Downloading ".$self->toolurl($tool));
      # get into the cache:
      $self->{switch}->urlget($self->toolurl($tool));
      }
   print "\nDone.","\n";
   # So now add the list of downloaded tools, and which were
   # selected, to tool cache:
   print "Tool info cached locally.","\n","\n";

   # Now copy required info from this object to ToolManager (ToolCache):
   $self->toolmanager()->downloadedtools($self->{tools});
   $self->toolmanager()->defaultversions($self->{version});
   $self->toolmanager()->toolurls($self->{url});
   $self->toolmanager()->selected($self->{selected});
   }

sub _autoselect
   {
   my $self=shift;
   if ( @_ )
      {
      $self->{autoselect}=shift;
      }
   # -- default is true
   return ((defined $self->{autoselect})?$self->{autoselect}:1);
   }

sub require_start
   {
   my $self=shift;
   my $name=shift;
   my $hashref=shift;
   
   $self->{switch}->checktag( $name, $hashref, 'version');
   $self->{switch}->checktag( $name, $hashref, 'name');
   $self->{switch}->checktag( $name, $hashref, 'url');
   
   if ( $self->{reqcontext} == 1 )
      {
      $self->{switch}->parseerror(
                                  "Open new $name context without previous </$name>");
      }
   $self->{reqcontext}=1;
   $$hashref{'name'}=~tr[A-Z][a-z];
   
   # Add protection so that architecture tags are obeyed during download:
   if ( $self->{Arch} )
      {
      # Add tool to the tool array:
      push @{$self->{tools}}, $$hashref{'name'};
      
      # If the tool already has an entry, modify the version string to
      # include both versions. The versions can later be separated and
      # parsed as normal:
      if (defined $self->{version}{$$hashref{'name'}})
         {
         # Don't need an extra entry for this tool onto tool array:
         pop @{$self->{tools}}, $$hashref{'name'};
         # Modify the version string to append the other tool version.
         # Separate using a colon:
         my $newversion=$self->{version}{$$hashref{'name'}}.":".$$hashref{'version'};
         $self->{version}{$$hashref{'name'}}=$newversion;
         }
      else
         {
         $self->{version}{$$hashref{'name'}}=$$hashref{'version'};
         }
      # -- make sure the full url is taken
      my $urlobj=$self->{switch}->expandurl($$hashref{'url'});
      $self->{url}{$$hashref{'name'}}=$urlobj->url();

      $self->{creqtool}=$$hashref{'name'};
      $self->{creqversion}=$$hashref{'version'};
      $self->{reqtext}{$self->{creqtool}}{$self->{creqversion}}="";
      }
   }

sub require_text
   {
   my $self=shift;
   my $name=shift;
   my $string=shift;
   
   chomp $string;
   $self->{reqtext}{$self->{creqtool}}{$self->{creqversion}}=
      $self->{reqtext}{$self->{creqtool}}{$self->{creqversion}}.
      $string;  
   }

sub require_end
   {
   my $self=shift;
   my $name=shift;
   
   if ( $self->{reqcontext} != 1 )
      {
      $self->{switch}->parseerror("No matching tag for </$name>");
      }
   else
      {
      $self->{reqcontext}=0;
      }
   }

sub select_start
   {
   my $self=shift;
   my $name=shift;
   my $hashref=shift;

   $self->{switch}->checktag( $name, $hashref, 'name');
   $$hashref{'name'}=~tr[A-Z][a-z];
   if ( $self->{Arch} )
      {
      $self->verbose("Selecting ".$$hashref{'name'});
      # Increment counter:
      $self->{selectcounter}++;
      $self->{selected}{$$hashref{'name'}}=$self->{selectcounter};
      }
   }

sub Arch_Start
   {
   my $self=shift;
   my $name=shift;
   my $hashref=shift;
   
   # Check the architecture tag:
   $self->{switch}->checktag($name, $hashref,'name');   
   ( ($self->arch()=~/$$hashref{name}.*/) )? ($self->{Arch}=1)
      : ($self->{Arch}=0);
   
   $self->verbose(($self->{Arch}?"OK":"skipping")." ".$$hashref{name});
   push @{$self->{ARCHBLOCK}}, $self->{Arch};
   push @{$self->{ArchStack}}, $$hashref{'name'};
   }

sub Arch_End
   {
   my $self=shift;
   my $name=shift;
   pop @{$self->{ARCHBLOCK}};
   $self->{Arch}=$self->{ARCHBLOCK}[$#{$self->{ARCHBLOCK}}];
   }

sub disttag
   {
   my $self=shift;
   my $name=shift;
   my $hashref=shift;
   
   if ( exists $$hashref{'url'} )
      {
      $self->{dist}{$self->{creqtool}}{$self->{creqversion}}=
         $$hashref{'url'};
      }
   }
Revision:	1.20
Committed:	Fri Dec 10 13:41:37 2004 UTC (20 years, 5 months ago) by sashby
Content type:	text/plain
Branch:	MAIN
CVS Tags:	V1_0_0
Changes since 1.19:	+263 -420 lines
Log Message:	Merged V1_0 branch to HEAD
#	User	Rev	Content
1	williamc	1.2	# Requirements Doc - just to get ordering info
2			#
3			# Interface
4			# ---------
5			# new(ActiveStore,url[,arch]) : new requirements doc
6			# setup(toolbox): set up the requirements into the specified toolbox object
7			# download(toolbox) : download description files (into toolbox cache)
8			# tools() : Return list of ALL requirements (ordered)
9			# selectedtools() : Return list of only those tools selected
10			# version(tool) : return the version of a given tool
11			# toolurl(tool) : return the url of a given tool
12			# getreqforarch(arch) : Return a RequirementsObject corresponding to the
13			# specified architecture
14			# toolcomment(tool,version) : return the comment string for the specified tool
15			# distributionurl(tool,version) : return the dist info url for the tool
16
17			package BuildSystem::Requirements;
18			use ActiveDoc::ActiveDoc;
19			use Utilities::Verbose;
20
21			require 5.004;
22			@ISA=qw(Utilities::Verbose);
23
24	sashby	1.20	sub new
25			{
26			my $class=shift;
27			my $self={};
28			bless $self, $class;
29			$self->{dbstore}=shift;
30			$self->{file}=shift;
31			$self->{cache}=$self->{dbstore}->cache();
32
33			if ( @_ )
34			{
35			$self->arch(shift);
36			}
37			$self->verbose("Initialising a new Requirements Doc");
38			$self->{mydocversion}="2.0";
39			# Counter for downloaded tools: zero it here. It will
40			# be auto-incremented as each tool is selected:
41			$self->{selectcounter}=0;
42
43			$self->{Arch}=1;
44			push @{$self->{ARCHBLOCK}}, $self->{Arch};
45			$self->init($self->{file});
46			return $self;
47			}
48
49			sub toolmanager
50			{
51			my $self=shift;
52
53			@_ ? $self->{toolmanagerobject} = shift
54			: $self->{toolmanagerobject};
55
56			}
57	williamc	1.2
58	sashby	1.20	sub configversion
59	sashby	1.7	{
60			my $self=shift;
61	sashby	1.20	@_ ? $self->{configversion} = shift
62			: $self->{configversion};
63			}
64	sashby	1.7
65	sashby	1.20	sub url
66			{
67			my $self=shift;
68
69			if ( @_ )
70	sashby	1.7	{
71	sashby	1.20	$self->{file}=shift;
72	sashby	1.7	}
73	sashby	1.20	return $self->{file};
74			}
75
76			sub tools
77			{
78			my $self=shift;
79			return @{$self->{tools}};
80			}
81
82			sub toolcomment
83			{
84			my $self=shift;
85			my $tool=shift;
86			my $version=shift;
87
88			return $self->{reqtext}{$tool}{$version};
89			}
90
91			sub distributionurl
92			{
93			my $self=shift;
94			my $tool=shift;
95			my $version=shift;
96
97			return ( defined $self->{dist}{$tool}{$version})?
98			$self->{dist}{$tool}{$version}:undef;
99	sashby	1.7	}
100	williamc	1.2
101	sashby	1.20	sub version
102			{
103			my $self=shift;
104			my $tool=shift;
105			return $self->{'version'}{$tool};
106			}
107	williamc	1.2
108	sashby	1.20	sub toolurl
109			{
110			my $self=shift;
111			my $tool=shift;
112			return $self->{'url'}{$tool};
113			}
114	sashby	1.11
115	sashby	1.20	sub init
116	sashby	1.8	{
117	sashby	1.11	my $self=shift;
118	sashby	1.20	my $url=shift;
119
120			my $switch=ActiveDoc::ActiveDoc->new($self->{dbstore});
121			$switch->verbosity($self->verbosity());
122			$switch->url($url);
123			$switch->newparse("ordering");
124			$switch->addbasetags("ordering");
125	sashby	1.11
126	sashby	1.20	$switch->addtag("ordering","Architecture",
127			\&Arch_Start,$self,
128			"", $self,
129			\&Arch_End, $self);
130			$switch->addtag("ordering","select",
131			\&select_start,$self,
132			"", $self,
133			"", $self);
134			$switch->grouptag("Architecture","ordering");
135			$switch->addtag("ordering","require",
136			\&require_start,$self,
137			\&require_text, $self,
138			\&require_end, $self);
139	sashby	1.11
140	sashby	1.20	$self->{reqcontext}=0;
141			$self->{switch}=$switch;
142			undef $self->{restrictstack};
143			@{$self->{tools}}=();
144	sashby	1.11
145	sashby	1.20	my($doctype,$docversion)=$switch->doctype();
146			# -- for backwards compatability only parse if we have a docversion
147			# defined (SFA: I think this is pretty much out of date):
148			if ( defined $docversion )
149			{
150			if ($docversion eq $self->{mydocversion})
151	sashby	1.11	{
152	sashby	1.20	@{$self->{ArchStack}}=();
153			$self->verbose("Initial Document Parse");
154			$self->{switch}->parse("ordering");
155			$self->configversion($switch->{configurl}->param('version'));
156	sashby	1.11	}
157			else
158			{
159	sashby	1.20	$self->verbose("wrong doc version - not parsing");
160	sashby	1.11	}
161			}
162			else
163			{
164	sashby	1.20	$self->verbose("wrong doc type - not parsing");
165			}
166			}
167
168			sub arch
169			{
170			my $self=shift;
171			# $self->arch is the SCRAM_ARCH value:
172			if ( @_ )
173			{
174			$self->{arch}=shift;
175			}
176			else
177			{
178			if ( ! defined $self->{arch} )
179	sashby	1.11	{
180	sashby	1.20	$self->{arch}="";
181	sashby	1.11	}
182			}
183	sashby	1.20	return $self->{arch};
184	sashby	1.11	}
185
186	sashby	1.20	sub archlist
187			{
188			my $self=shift;
189			return @{$self->{ArchStack}};
190			}
191	sashby	1.11
192	sashby	1.20	sub getreqforarch
193	sashby	1.11	{
194	sashby	1.8	my $self=shift;
195	sashby	1.20	my $arch=shift;
196	sashby	1.11
197	sashby	1.20	if ( ! defined $self->{reqsforarch}{$arch} )
198	sashby	1.8	{
199	sashby	1.20	$self->{reqsforarch}{$arch}=
200			BuildSystem::Requirements->new($self->{dbstore},$self->{file},
201			$arch);
202	sashby	1.8	}
203	sashby	1.20	return $self->{reqsforarch}{$arch};
204	sashby	1.8	}
205	sashby	1.11
206	sashby	1.13	sub download
207			{
208			my $self=shift;
209			my $tool;
210			$\| = 1; # Unbuffer the output
211
212			print "Downloading tool descriptions....","\n";
213			print " ";
214			foreach $tool ( $self->tools() )
215			{
216			print "#";
217			$self->verbose("Downloading ".$self->toolurl($tool));
218	sashby	1.20	# get into the cache:
219	sashby	1.13	$self->{switch}->urlget($self->toolurl($tool));
220			}
221	sashby	1.20	print "\nDone.","\n";
222			# So now add the list of downloaded tools, and which were
223			# selected, to tool cache:
224			print "Tool info cached locally.","\n","\n";
225
226			# Now copy required info from this object to ToolManager (ToolCache):
227			$self->toolmanager()->downloadedtools($self->{tools});
228			$self->toolmanager()->defaultversions($self->{version});
229			$self->toolmanager()->toolurls($self->{url});
230			$self->toolmanager()->selected($self->{selected});
231	sashby	1.13	}
232	williamc	1.2
233	sashby	1.20	sub _autoselect
234			{
235			my $self=shift;
236			if ( @_ )
237			{
238			$self->{autoselect}=shift;
239			}
240			# -- default is true
241			return ((defined $self->{autoselect})?$self->{autoselect}:1);
242			}
243	williamc	1.2
244	sashby	1.20	sub require_start
245	sashby	1.8	{
246			my $self=shift;
247			my $name=shift;
248			my $hashref=shift;
249	sashby	1.20
250			$self->{switch}->checktag( $name, $hashref, 'version');
251	sashby	1.8	$self->{switch}->checktag( $name, $hashref, 'name');
252	sashby	1.20	$self->{switch}->checktag( $name, $hashref, 'url');
253
254			if ( $self->{reqcontext} == 1 )
255			{
256			$self->{switch}->parseerror(
257			"Open new $name context without previous </$name>");
258			}
259			$self->{reqcontext}=1;
260	sashby	1.8	$$hashref{'name'}=~tr[A-Z][a-z];
261	sashby	1.20
262			# Add protection so that architecture tags are obeyed during download:
263	sashby	1.8	if ( $self->{Arch} )
264			{
265	sashby	1.20	# Add tool to the tool array:
266			push @{$self->{tools}}, $$hashref{'name'};
267
268			# If the tool already has an entry, modify the version string to
269			# include both versions. The versions can later be separated and
270			# parsed as normal:
271			if (defined $self->{version}{$$hashref{'name'}})
272			{
273			# Don't need an extra entry for this tool onto tool array:
274			pop @{$self->{tools}}, $$hashref{'name'};
275			# Modify the version string to append the other tool version.
276			# Separate using a colon:
277			my $newversion=$self->{version}{$$hashref{'name'}}.":".$$hashref{'version'};
278			$self->{version}{$$hashref{'name'}}=$newversion;
279			}
280			else
281			{
282			$self->{version}{$$hashref{'name'}}=$$hashref{'version'};
283			}
284			# -- make sure the full url is taken
285			my $urlobj=$self->{switch}->expandurl($$hashref{'url'});
286			$self->{url}{$$hashref{'name'}}=$urlobj->url();
287
288			$self->{creqtool}=$$hashref{'name'};
289			$self->{creqversion}=$$hashref{'version'};
290			$self->{reqtext}{$self->{creqtool}}{$self->{creqversion}}="";
291			}
292			}
293
294			sub require_text
295			{
296			my $self=shift;
297			my $name=shift;
298			my $string=shift;
299
300			chomp $string;
301			$self->{reqtext}{$self->{creqtool}}{$self->{creqversion}}=
302			$self->{reqtext}{$self->{creqtool}}{$self->{creqversion}}.
303			$string;
304			}
305
306			sub require_end
307			{
308			my $self=shift;
309			my $name=shift;
310
311			if ( $self->{reqcontext} != 1 )
312			{
313			$self->{switch}->parseerror("No matching tag for </$name>");
314			}
315			else
316			{
317			$self->{reqcontext}=0;
318	sashby	1.8	}
319			}
320
321	sashby	1.20	sub select_start
322	sashby	1.8	{
323			my $self=shift;
324			my $name=shift;
325			my $hashref=shift;
326	sashby	1.20
327	sashby	1.8	$self->{switch}->checktag( $name, $hashref, 'name');
328			$$hashref{'name'}=~tr[A-Z][a-z];
329			if ( $self->{Arch} )
330			{
331	sashby	1.20	$self->verbose("Selecting ".$$hashref{'name'});
332			# Increment counter:
333			$self->{selectcounter}++;
334			$self->{selected}{$$hashref{'name'}}=$self->{selectcounter};
335	sashby	1.8	}
336			}
337	williamc	1.2
338	sashby	1.14	sub Arch_Start
339			{
340			my $self=shift;
341			my $name=shift;
342			my $hashref=shift;
343	sashby	1.20
344	sashby	1.14	# Check the architecture tag:
345	sashby	1.20	$self->{switch}->checktag($name, $hashref,'name');
346			( ($self->arch()=~/$$hashref{name}.*/) )? ($self->{Arch}=1)
347			: ($self->{Arch}=0);
348	sashby	1.19
349	sashby	1.14	$self->verbose(($self->{Arch}?"OK":"skipping")." ".$$hashref{name});
350			push @{$self->{ARCHBLOCK}}, $self->{Arch};
351			push @{$self->{ArchStack}}, $$hashref{'name'};
352			}
353	williamc	1.2
354	sashby	1.20	sub Arch_End
355			{
356			my $self=shift;
357			my $name=shift;
358			pop @{$self->{ARCHBLOCK}};
359			$self->{Arch}=$self->{ARCHBLOCK}[$#{$self->{ARCHBLOCK}}];
360			}
361
362			sub disttag
363			{
364			my $self=shift;
365			my $name=shift;
366			my $hashref=shift;
367
368			if ( exists $$hashref{'url'} )
369			{
370			$self->{dist}{$self->{creqtool}}{$self->{creqversion}}=
371			$$hashref{'url'};
372			}
373			}