src/ActiveDoc/CommandLineInterface.pm

#
# CommandLineInterface.pm
#
# Originally Written by Christopher Williams
#
# Description
# Do all the setting up required for the UserQuery based on an input hash
# --- defaults taken from activedoc configuration setup
#
# Interface
# ---------
# new(CommandObjName, UserInterface)  : A new CommandLineInterface object
#                                       define userinterface for any CL querys
# setcommand(name,level,optionref)   : Add a command to recognise at the given
#                                       level(>0) of the parse. Associate an
#                                       optionhash with it (see parseoptions)
# setbase(optionref)                : set options for the base level
# parseoptions(@args)           : Parse a set of arguments for options/commands
#                                 retunrs number of commands levels found
# command(level)                : return the command given on the command line
#                                 at a given level
# allowedcommands(level)        : return list of allowed commands for level
# getargs(level)                : return a list of arguments corresponding
#                                 to a given level of command
# commandlevel()                : return the number of found commands
# parse(@args)                  : Hand it the args and it will setup dochandler
#                                 after calling the parse() method on the 
#                                 CommandObj
#
# - private interface -------------------------------
# getoptions(command, level)    : return the optionhash for a given command
# parsecmdoptions(optionhashref, \@args) : parse the options, setting the 
#                                       UserQuery
#                                      appropriately as indicated by optionhash
#                                      The option hash ref should have the
#                                       format as given in example below
#                                       $ohr={
#                                               '-I'=> [ qw(dir >>) ], 
#                                               '-g'=> [ qw(debug true) ] }
#                                       ( >> means take next argument as value)
# 

package ActiveDoc::CommandLineInterface;
use ActiveDoc::UserQuery;
use ActiveDoc::DOChandler;
require 5.001;

sub new {
        my $class=shift;
        $self={};
        bless $self, $class;
        $self->init(@_);
        return $self;
}

# --------------- Support Routines --------------------
sub init {
        my $self=shift;
        my $file=shift;
        my $UI=shift;

        # Set up a User Query Object
        $self->{UI}=$UI;
        $self->{UserQuery}=ActiveDoc::UserQuery->new($self->{UI});
        $self->_defaults(); # set up some minimal defaults

        # Set up our command handling object
        eval "require $file" ;
        die $@ if $@;
        $self->{Commands}=$file->new($self);
        
        $self->{errormessg}="Error : ";
}

sub parse {
        my $self=shift;
        my @args=@_;

        # Get all parameters into UserQuery
        $self->parseoptions(@_);

        # Initialise the DocHandler with what weve got so  far
        $self->{dochandler}=ActiveDoc::DOChandler->new($self->{UserQuery});

        $self->{Commands}->parse(@_);

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

        die $self->{errormessg}.$string."\n";
}


# --------------- Interface routines --------------------


sub parsecmdoptions {
        my $self=shift;
        my $optionhashref=shift;
        my $argref=shift;

        my $option;

        $option=shift @$argref;

        while ( defined $option ) {
          # deal with options
          if ( $option=~/^\-/ ) {
           if ( ! exists $$optionhashref{$option} ) {
                $self->error("Unknown Option $option");
           }
           else {
                # take next word as argument -- indicate by >
                if ( $$optionhashref{$option}[1]=~/^\>\>/ ) {
                   $self->{UserQuery}->setparam($$optionhashref{$option}[0],
                        (shift @$argref));
                } 
                else { # simply set value as in hashref
                   $self->{UserQuery}->setparam($$optionhashref{$option}[0],
                                        $$optionhashref{$option}[1]);
                }
           }
          }
          else { # deal with commands
                unshift @$argref, $option;
                last;
          }
          $option=shift @$argref;
        } # end while  
}

sub parseoptions {
        my $self=shift;
        my @args=@_;

        my $command;
        my $commandhashref;
        my $level;

        $command='_base';

        # base level
        $level=0;
        $commandhashref=$self->getoptions($command, $level);
        $self->parsecmdoptions($commandhashref, \@args);
        @{$self->{"_arg_0"}}=();

        
        $self->{arglev}=$level;
        $level++;
        
        while ( ( $#args >= 0) && ( $level <= $#{$self->{commands}}) ) {
          $arg=shift @args;
          if ( exists ${$self->{commands}[$level]}{$arg} ) {
                $self->{UserQuery}->setparam("_cmd_$level", $arg);
                $commandhashref=$self->getoptions($arg, $level);
                $self->parsecmdoptions($commandhashref, \@args);
                $self->{arglev}=$level;
                @{$self->{"_arg_$self->{arglev}"}}=(); #initialise new arg array
                $level++;
          }
          else { 
                # must be an argument to the last command
                push @{$self->{"_arg_$self->{arglev}"}} , $arg;
          }
        }
        # add any futher arguments to last argumentlist
        push @{$self->{"_arg_$self->{arglev}"}} , @args;
        return $self->{arglev};
}

sub commandlevel {
        my $self=shift;
        return $self->{arglev};
}

sub allowedcommands {
        my $self=shift;
        my $level=shift;

        return keys %{$self->{commands}[$level]};
}

sub getargs {
        my $self=shift;
        my $level=shift;

        return @{$self->{"_arg_$level"}};
}

sub getoptions {
        my $self=shift;
        my $name=shift;
        my $level=shift;

        return ${$self->{commands}[$level]}{$name};
}

sub setcommand {
        my $self=shift;
        my $name=shift;
        my $level=shift;
        my $optionref=shift;
        my $commandref=shift;

        ${$self->{commands}[$level]}{$name}=$optionref;
}


sub setbase {
        my $self=shift;
        my $optionref=shift;

        $self->setcommand("_base", 0 , $optionref);
}

sub command {
        my $self=shift;
        my $level=shift;

        return $self->{UserQuery}->getparam("_cmd_$level");
}

#
# Minimum defaults for a simple Dochandler Bootstrap
#
sub _defaults {
        my $self=shift;
        $self->{UserQuery}->setparam('cache', "/tmp");
}
Revision:	1.3
Committed:	Mon Sep 20 16:27:57 1999 UTC (25 years, 7 months ago) by williamc
Content type:	text/plain
Branch:	MAIN
Changes since 1.2:	+50 -12 lines
Log Message:	Basic Working Level
#	User	Rev	Content
1	williamc	1.1	#
2			# CommandLineInterface.pm
3			#
4			# Originally Written by Christopher Williams
5			#
6			# Description
7	williamc	1.3	# Do all the setting up required for the UserQuery based on an input hash
8	williamc	1.1	# --- defaults taken from activedoc configuration setup
9			#
10			# Interface
11			# ---------
12	williamc	1.3	# new(CommandObjName, UserInterface) : A new CommandLineInterface object
13	williamc	1.1	# define userinterface for any CL querys
14	williamc	1.2	# setcommand(name,level,optionref) : Add a command to recognise at the given
15			# level(>0) of the parse. Associate an
16			# optionhash with it (see parseoptions)
17			# setbase(optionref) : set options for the base level
18			# parseoptions(@args) : Parse a set of arguments for options/commands
19			# retunrs number of commands levels found
20			# command(level) : return the command given on the command line
21			# at a given level
22	williamc	1.3	# allowedcommands(level) : return list of allowed commands for level
23	williamc	1.2	# getargs(level) : return a list of arguments corresponding
24			# to a given level of command
25			# commandlevel() : return the number of found commands
26	williamc	1.3	# parse(@args) : Hand it the args and it will setup dochandler
27			# after calling the parse() method on the
28			# CommandObj
29	williamc	1.2	#
30			# - private interface -------------------------------
31			# getoptions(command, level) : return the optionhash for a given command
32			# parsecmdoptions(optionhashref, \@args) : parse the options, setting the
33			# UserQuery
34	williamc	1.1	# appropriately as indicated by optionhash
35			# The option hash ref should have the
36			# format as given in example below
37			# $ohr={
38			# '-I'=> [ qw(dir >>) ],
39			# '-g'=> [ qw(debug true) ] }
40			# ( >> means take next argument as value)
41	williamc	1.2	#
42	williamc	1.1
43			package ActiveDoc::CommandLineInterface;
44			use ActiveDoc::UserQuery;
45	williamc	1.3	use ActiveDoc::DOChandler;
46	williamc	1.1	require 5.001;
47
48			sub new {
49			my $class=shift;
50			$self={};
51			bless $self, $class;
52			$self->init(@_);
53			return $self;
54			}
55
56			# --------------- Support Routines --------------------
57			sub init {
58			my $self=shift;
59	williamc	1.3	my $file=shift;
60	williamc	1.1	my $UI=shift;
61
62	williamc	1.3	# Set up a User Query Object
63	williamc	1.1	$self->{UI}=$UI;
64	williamc	1.3	$self->{UserQuery}=ActiveDoc::UserQuery->new($self->{UI});
65			$self->_defaults(); # set up some minimal defaults
66	williamc	1.1
67	williamc	1.3	# Set up our command handling object
68			eval "require $file" ;
69			die $@ if $@;
70			$self->{Commands}=$file->new($self);
71
72	williamc	1.1	$self->{errormessg}="Error : ";
73			}
74
75	williamc	1.3	sub parse {
76			my $self=shift;
77			my @args=@_;
78
79			# Get all parameters into UserQuery
80			$self->parseoptions(@_);
81
82			# Initialise the DocHandler with what weve got so far
83			$self->{dochandler}=ActiveDoc::DOChandler->new($self->{UserQuery});
84	williamc	1.1
85	williamc	1.3	$self->{Commands}->parse(@_);
86
87			}
88
89	williamc	1.1	sub error {
90			my $self=shift;
91			my $string=shift;
92
93			die $self->{errormessg}.$string."\n";
94			}
95
96
97			# --------------- Interface routines --------------------
98
99
100	williamc	1.2	sub parsecmdoptions {
101	williamc	1.1	my $self=shift;
102			my $optionhashref=shift;
103	williamc	1.2	my $argref=shift;
104	williamc	1.1
105			my $option;
106
107	williamc	1.2	$option=shift @$argref;
108	williamc	1.1
109			while ( defined $option ) {
110			# deal with options
111			if ( $option=~/^\-/ ) {
112			if ( ! exists $$optionhashref{$option} ) {
113			$self->error("Unknown Option $option");
114			}
115			else {
116			# take next word as argument -- indicate by >
117			if ( $$optionhashref{$option}[1]=~/^\>\>/ ) {
118	williamc	1.3	$self->{UserQuery}->setparam($$optionhashref{$option}[0],
119	williamc	1.2	(shift @$argref));
120	williamc	1.1	}
121			else { # simply set value as in hashref
122	williamc	1.3	$self->{UserQuery}->setparam($$optionhashref{$option}[0],
123	williamc	1.1	$$optionhashref{$option}[1]);
124			}
125			}
126			}
127			else { # deal with commands
128	williamc	1.2	unshift @$argref, $option;
129	williamc	1.1	last;
130			}
131	williamc	1.2	$option=shift @$argref;
132	williamc	1.1	} # end while
133			}
134
135	williamc	1.2	sub parseoptions {
136			my $self=shift;
137			my @args=@_;
138
139			my $command;
140			my $commandhashref;
141			my $level;
142
143			$command='_base';
144
145			# base level
146			$level=0;
147			$commandhashref=$self->getoptions($command, $level);
148			$self->parsecmdoptions($commandhashref, \@args);
149			@{$self->{"_arg_0"}}=();
150
151
152			$self->{arglev}=$level;
153			$level++;
154
155			while ( ( $#args >= 0) && ( $level <= $#{$self->{commands}}) ) {
156			$arg=shift @args;
157			if ( exists ${$self->{commands}[$level]}{$arg} ) {
158	williamc	1.3	$self->{UserQuery}->setparam("_cmd_$level", $arg);
159	williamc	1.2	$commandhashref=$self->getoptions($arg, $level);
160			$self->parsecmdoptions($commandhashref, \@args);
161			$self->{arglev}=$level;
162			@{$self->{"_arg_$self->{arglev}"}}=(); #initialise new arg array
163			$level++;
164			}
165			else {
166			# must be an argument to the last command
167			push @{$self->{"_arg_$self->{arglev}"}} , $arg;
168			}
169			}
170			# add any futher arguments to last argumentlist
171			push @{$self->{"_arg_$self->{arglev}"}} , @args;
172			return $self->{arglev};
173			}
174
175			sub commandlevel {
176			my $self=shift;
177			return $self->{arglev};
178			}
179
180	williamc	1.3	sub allowedcommands {
181			my $self=shift;
182			my $level=shift;
183
184			return keys %{$self->{commands}[$level]};
185			}
186
187	williamc	1.2	sub getargs {
188			my $self=shift;
189			my $level=shift;
190
191			return @{$self->{"_arg_$level"}};
192			}
193
194			sub getoptions {
195			my $self=shift;
196			my $name=shift;
197			my $level=shift;
198
199			return ${$self->{commands}[$level]}{$name};
200			}
201
202			sub setcommand {
203			my $self=shift;
204			my $name=shift;
205			my $level=shift;
206			my $optionref=shift;
207	williamc	1.3	my $commandref=shift;
208	williamc	1.2
209			${$self->{commands}[$level]}{$name}=$optionref;
210			}
211
212	williamc	1.3
213	williamc	1.2	sub setbase {
214			my $self=shift;
215			my $optionref=shift;
216
217			$self->setcommand("_base", 0 , $optionref);
218			}
219
220			sub command {
221			my $self=shift;
222			my $level=shift;
223
224	williamc	1.3	return $self->{UserQuery}->getparam("_cmd_$level");
225			}
226
227			#
228			# Minimum defaults for a simple Dochandler Bootstrap
229			#
230			sub _defaults {
231			my $self=shift;
232			$self->{UserQuery}->setparam('cache', "/tmp");
233	williamc	1.2	}