1Term::Shell(3)        User Contributed Perl Documentation       Term::Shell(3)
2
3
4

NAME

6       Term::Shell - A simple command-line shell framework.
7

VERSION

9       version 0.10
10

SYNOPSIS

12           package MyShell;
13           use base qw(Term::Shell);
14
15           sub run_command1  { print "command 1!\n"; }
16           sub smry_command1 { "what does command1 do?" }
17           sub help_command1 {
18               <<'END';
19           Help on 'command1', whatever that may be...
20           END
21           }
22
23           sub run_command2 { print "command 2!\n"; }
24
25           package main;
26           my $shell = MyShell->new;
27           $shell->cmdloop;
28

DESCRIPTION

30       Term::Shell lets you write simple command-line shells. All the boring
31       details like command-line parsing, terminal handling, and tab
32       completion are handled for you.
33
34       The base class comes with two commands pre-defined: exit and help.
35
36       To write a shell with an "exec" command, do something like this:
37
38          package MyShell;
39          use base qw(Term::Shell); # or manually edit @MyShell::ISA.
40
41          sub run_exec {
42              my ($o, $cmd, @args) = @_;
43              if ($cmd ne $0) {
44                  print "I'm sorry you're leaving us...\n";
45              }
46              exec $cmd, @args;
47              exit 1;
48          }
49
50       When Term::Shell needs to handle the "exec" command, it will invoke
51       this method. That's all there is to it! You write handlers, and
52       Term::Shell handles the gory details.
53

VERSION

55       version 0.10
56

Using Term::Shell Shells

58       How do you bring your shell to life? Assuming the package "MyShell"
59       contains your actions, just do this:
60
61          use MyShell;
62          my $shell = MyShell->new;
63
64          # Setup code here (if you wish)
65
66          # Invoke the shell
67          $shell->cmdloop;
68
69          # Cleanup code here (if you wish)
70
71       Most people put the setup code in the shell itself, so you can usually
72       get away with this:
73
74          use MyShell;
75          MyShell->new->cmdloop;
76
77       It's that simple! All the actions and command handlers go in
78       "MyShell.pm", and your main program is simple. In fact, it's so simple
79       that some people like to write both the actions and the invocation in
80       the same file:
81
82          package main;
83          MyShell->new->cmdloop;
84
85          package MyShell;
86          use base qw(Term::Shell);
87
88          # Actions here
89
90       Adding commands to your shell is just as easy, if not easier.
91

Adding Commands to Your Shell

93       For every command "foo", Term::Shell needs a method called "run_foo()",
94       where 'foo' is what the user will type in. The method will be called
95       with the Term::Shell object as the first parameter, followed by any
96       arguments the user typed after the command.
97
98       Several prefixes other than "run_" are supported; each prefix tells
99       Term::Shell to call that handler under different circumstances. The
100       following list enumerates all the "special" prefixes. Term::Shell will
101       ignore any method that doesn't start with a prefix listed here.
102
103       1.  run_foo()
104
105           Adds the command "foo" to the list of supported commands. The
106           method's return value is saved by Term::Shell, but is not used.
107
108           The method is called with the Term::Shell object as its first
109           argument, followed by any arguments the user typed in.
110
111           Special case: if you provide a method "run_()", Term::Shell will
112           call it whenever the user enters a blank line. A blank line is
113           anything which matches the regular expression "/^\s*$/".
114
115       2.  help_foo()
116
117           Adds the command "foo" to the list of help topics. This means the
118           user may enter 'help foo' and get a help screen. It should return a
119           single string to be displayed to the user.
120
121           The method is called with the Term::Shell object as its first
122           argument, followed by any arguments the user typed in after 'help
123           foo'. You can implement hierarchical help documents by using the
124           arguments.
125
126           If you do not provide a "help_foo()" method, typing 'help foo'
127           produces an error message.
128
129       3.  smry_foo()
130
131           Should return a one-line summary of "foo", to be displayed in the
132           help screen.
133
134           This method is called with the Term::Shell object as its first
135           argument, and no other arguments.
136
137           If you do not provide a "smry_foo()" method, then the string
138           'undocumented' is used instead.
139
140       4.  comp_foo()
141
142           Provides custom tab-completion for "foo". That means if the user
143           types 'foo ' and then hits <TAB>, this method will be called. It
144           should return an array reference containing a list of possible
145           completions.
146
147           This method is called with the Term::Shell object as its first
148           argument, followed by the three arguments:
149
150           1.  $word
151
152               The word the user is trying to complete.
153
154           2.  $line
155
156               The line as typed by the user so far.
157
158           3.  $start
159
160               The offset into $line where $word starts.
161
162           If you do not provide "comp_foo()", Term::Shell will always return
163           no completions for "foo".
164
165           Special case: if you provide "comp_()", Term::Shell will call it
166           when the user is trying to complete the name of a command.
167           Term::Shell provides a default "comp_()" method, which completes
168           the actions that you have written handlers for. If you want to
169           provide tab-completion for commands that do not have handlers,
170           override "comp_()".
171
172       5.  alias_foo()
173
174           Returns a list of aliases for "foo". When one of the aliases is
175           used instead of "foo", the corresponding handler for "foo" is
176           called.
177
178       6.  catch_run()
179
180           catch_help()
181
182           catch_comp()
183
184           catch_smry()
185
186           Called when an undefined action is entered by the user. Normally
187           when the user enters an unrecognized command, Term::Shell will
188           print an error message and continue.
189
190           This method is called with the Term::Shell object, the command
191           typed by the user, and then the arguments which would normally be
192           passed to the real handler.
193
194           The "catch_" methods may do anything the original function would
195           have done.  If you want, you can implement all the commands in it,
196           but that means you're doing more work than you have to. Be lazy.
197
198   When you want something done right...
199       You sometimes have to do it yourself. Introducing add_handlers().
200       Naturally, it adds a handler to the list of defined handlers in the
201       shell.
202
203       Term::Shell can't always find the commands you want to implement by
204       searching the inheritance tree. Having an AUTOLOAD() method, for
205       instance, will break this system. In that situation, you may wish to
206       tell Term::Shell about the extra commands available using
207       add_handlers():
208
209          package MyShell;
210          use base qw(Term::Shell);
211
212          sub AUTOLOAD {
213              if ($AUTOLOAD =~ /::run_fuzz$/) {
214                  # code for 'fuzz' command
215              }
216              elsif ($AUTOLOAD =~ /::run_foozle$/) {
217                  # code for 'foozle' command
218              }
219          }
220
221          sub init {
222              my $o = shift;
223              $o->add_handlers("run_fuzz", "run_foozle");
224          }
225
226       There are other ways to do this. You could write a "catch_run" routine
227       and do the same thing from there. You'd have to override "comp_" so
228       that it would complete on "foozle" and "fuzz". The advantage to this
229       method is that it adds the methods to the list of commands, so they
230       show up in the help menu and you get completion for free.
231

Removing Commands from Your Shell

233       You're probably thinking "just don't write them". But remember, you can
234       inherit from another shell class, and that parent may define commands
235       you want to disable. Term::Shell provides a simple method to make
236       itself forget about commands it already knows about:
237
238       1.  remove_commands()
239
240           Removes all handlers associated with the given command (or list of
241           commands).
242
243           For example, Term::Shell comes with two commands ("exit" and
244           "help") implemented with seven handlers:
245
246           1.  smry_exit()
247
248           2.  help_exit()
249
250           3.  run_exit()
251
252           4.  smry_help()
253
254           5.  help_help()
255
256           6.  comp_help()
257
258           7.  run_help()
259
260           If you want to create a shell that doesn't implement the "help"
261           command, your code might look something like this example:
262
263              package MyShell;
264              use base qw(Term::Shell);
265
266              sub init {
267                  my $o = shift;
268                  $o->remove_commands("help");
269              }
270
271              # ... define more handlers here ...
272
273       2.  remove_handlers()
274
275           Removes the given handler (or handlers) from the list of defined
276           commands. You have to specify a full handler name, including the
277           'run_' prefix. You can obviously specify any of the other prefixes
278           too.
279
280           If you wanted to remove the help for the "exit" command, but
281           preserve the command itself, your code might look something like
282           this:
283
284              package MyShell;
285              use base qw(Term::Shell);
286
287              sub init {
288                  my $o = shift;
289                  $o->remove_handlers("help_exit");
290              }
291
292              # ... define more handlers here ...
293
294   Cover Your Tracks
295       If you do remove built in commands, you should be careful not to let
296       Term::Shell print references to them. Messages like this are guaranteed
297       to confuse people who use your shell:
298
299          shell> help
300          Unknown command 'help'; type 'help' for a list of commands.
301
302       Here's the innocuous looking code:
303
304          package MyShell;
305          use base qw(Term::Shell);
306
307          sub init {
308              my $o = shift;
309              $o->remove_commands("help");
310          }
311
312          MyShell->new->cmdloop;
313
314       The problem is that Term::Shell has to print an error message, and by
315       default it tells the user to use the "help" command to see what's
316       available. If you remove the "help" command, you still have to clean up
317       after yourself and tell Term::Shell to change its error messages:
318
319       1.  msg_unknown_cmd()
320
321           Called when the user has entered an unrecognized command, and no
322           action was available to satisfy it. It receives the object and the
323           command typed by the user as its arguments. It should return an
324           error message; by default, it is defined thusly:
325
326              sub msg_unknown_cmd {
327                  my ($o, $cmd) = @_;
328                  <<END;
329              Unknown command '$cmd'; type 'help' for a list of commands.
330              END
331              }
332
333       2.  msg_ambiguous_cmd()
334
335           Called when the user has entered a command for which more than
336           handler exists.  (For example, if both "quit" and "query" are
337           commands, then "qu" is an ambiguous command, because it could be
338           either.) It receives the object, the command, and the possible
339           commands which could complete it. It should return an error
340           message; by default it is defined thusly:
341
342              sub msg_ambiguous_cmd {
343                  my ($o, $cmd, @c) = @_;
344                  local $" = "\n\t";
345                  <<END;
346              Ambiguous command '$cmd': possible commands:
347                      @c
348              END
349              }
350

The Term::Shell API

352       Shell classes can use any of the methods in this list. Any other
353       methods in Term::Shell may change.
354
355       1.  new()
356
357           Creates a new Term::Shell object. It currently does not use its
358           arguments. The arguments are saved in '$o->{API}{args}', in case
359           you want to use them later.
360
361              my $sh = Term::Shell->new(@arbitrary_args);
362
363       2.  cmd()
364
365              cmd($txt);
366
367           Invokes $txt as if it had been typed in at the prompt.
368
369              $sh->cmd("echo 1 2 3");
370
371       3.  cmdloop()
372
373           mainloop()
374
375           Repeatedly prompts the user, reads a line, parses it, and invokes a
376           handler.  Uses "cmd()" internally.
377
378              MyShell->new->cmdloop;
379
380           mainloop() is a synonym for cmdloop(), provided for backwards
381           compatibility.  Earlier (unreleased) versions of Term::Shell have
382           only provided mainloop().  All documentation and examples use
383           cmdloop() instead.
384
385       4.  init()
386
387           fini()
388
389           Do any initialization or cleanup you need at shell creation
390           (init()) and destruction (fini()) by defining these methods.
391
392           No parameters are passed.
393
394       5.  preloop()
395
396           postloop()
397
398           Do any initialization or cleanup you need at shell startup
399           (preloop()) and shutdown (postloop()) by defining these methods.
400
401           No parameters are passed.
402
403       6.  precmd()
404
405           postcmd()
406
407           Do any initialization or cleanup before and after calling each
408           handler.
409
410           The parameters are:
411
412           1.  $handler
413
414               A reference to the name of the handler that is about to be
415               executed.
416
417               Passed by reference so you can control which handler will be
418               called.
419
420           2.  $cmd
421
422               A reference to the command as the user typed it.
423
424               Passed by reference so you can set the command. (If the handler
425               is a "catch_" command, it can be fooled into thinking the user
426               typed some other command, for example.)
427
428           3.  $args
429
430               The arguments as typed by the user. This is passed as an array
431               reference so that you can manipulate the arguments received by
432               the handler.
433
434              sub precmd {
435                  my $o = shift;
436                  my ($handler, $cmd, @args) = @_;
437                  # ...
438              }
439
440       7.  stoploop()
441
442           Sets a flag in the Term::Shell object that breaks out of cmdloop().
443           Note that cmdloop() resets this flag each time you call it, so code
444           like this will work:
445
446              my $sh = MyShell->new;
447              $sh->cmdloop;    # an interactive session
448              $sh->cmdloop;    # prompts the user again
449
450           Term::Shell's built-in run_exit() command just calls stoploop().
451
452       8.  idle()
453
454           If you set "check_idle" to a non-zero number (see "The Term::Shell
455           Object") then this method is called every "check_idle" seconds. The
456           idle() method defined in Term::Shell does nothing -- it exists only
457           to be redefined in subclasses.
458
459              package MyShell;
460              use base qw(Term::Shell);
461
462              sub init {
463                  my $o = shift;
464                  $o->{API}{check_idle} = 0.1; # 10/s
465              }
466
467              sub idle {
468                  print "Idle!\n";
469              }
470
471       9.  prompt_str()
472
473           Returns a string to be used as the prompt. prompt_str() is called
474           just before calling the readline() method of Term::ReadLine. If you
475           do not override this method, the string `shell> ' is used.
476
477              package MyShell;
478              use base qw(Term::Shell);
479
480              sub prompt_str { "search> " }
481
482       10. prompt()
483
484           Term::Shell provides this method for convenience. It's common for a
485           handler to ask the user for more information. This method makes it
486           easy to provide the user with a different prompt and custom
487           completions provided by you.
488
489           The prompt() method takes the following parameters:
490
491           1.  $prompt
492
493               The prompt to display to the user. This can be any string you
494               want.
495
496           2.  $default
497
498               The default value to provide. If the user enters a blank line
499               (all whitespace characters) then the this value will be
500               returned.
501
502               Note: unlike ExtUtils::MakeMaker's prompt(), Term::Shell's
503               prompt() does not modify $prompt to indicate the $default
504               response. You have to do that yourself.
505
506           3.  $completions
507
508               An optional list of completion values. When the user hits
509               <TAB>, Term::Shell prints the completions which match what
510               they've typed so far. Term::Shell does not enforce that the
511               user's response is one of these values.
512
513           4.  $casei
514
515               An optional boolean value which indicates whether the
516               completions should be matched case-insensitively or not. A true
517               value indicates that "FoO" and "foo" should be considered the
518               same.
519
520           prompt() returns the unparsed line to give you maximum flexibility.
521           If you need the line parsed, use the line_parsed() method on the
522           return value.
523
524       11. cmd_prefix()
525
526           cmd_suffix()
527
528           These methods should return a prefix and suffix for commands,
529           respectively.  For instance, an IRC client will have a prefix of
530           "/". Most shells have an empty prefix and suffix.
531
532       12. page()
533
534              page($txt)
535
536           Prints $txt through a pager, prompting the user to press a key for
537           the next screen full of text.
538
539       13. line()
540
541           line_parsed()
542
543           Although "run_foo()" is called with the parsed arguments from the
544           command-line, you may wish to see the raw command-line. This is
545           available through the line() method. If you want to retrieve the
546           parsed line again, use line_parsed().
547
548           line_parsed() accepts an optional string parameter: the line to
549           parse. If you have your own line to parse, you can pass it to
550           line_parsed() and get back a list of arguments. This is useful
551           inside completion methods, since you don't get a parsed list there.
552
553       14. run()
554
555           If you want to run another handler from within a handler, and you
556           have pre-parsed arguments, use run() instead of cmd(). cmd() parses
557           its parameter, whereas run() takes each element as a separate
558           parameter.
559
560           It needs the name of the action to run and any arguments to pass to
561           the handler.
562
563           Term::Shell uses this method internally to invoke command handlers.
564
565       15. help()
566
567           If you want to get the raw text of a help message, use help(). It
568           needs the name of the help topic and any arguments to pass to the
569           handler.
570
571           Term::Shell uses this method internally to invoke help handlers.
572
573       16. summary()
574
575           If you want to get the summary text of an action, use summary(). It
576           needs the name of the action.
577
578           Term::Shell uses this method internally to display the help page.
579
580       17. possible_actions()
581
582           You will probably want this method in comp_foo().
583           possible_actions() takes a word and a list, and returns a list of
584           possible matches. Term::Shell uses this method internally to decide
585           which handler to run when the user enters a command.
586
587           There are several arguments, but you probably won't use them all in
588           the simple cases:
589
590           1.  $needle
591
592               The (possible incomplete) word to try to match against the list
593               of actions (the haystack).
594
595           2.  $type
596
597               The type with which to prefix $action. This is useful when
598               completing a real action -- you have to specify whether you
599               want it to look for "run_" or "help_" or something else. If you
600               leave it blank, it will use $action without prefixing it.
601
602           3.  $strip
603
604               If you pass in a true value here, possible_actions() will
605               remove an initial $type from the beginning of each result
606               before returning the results. This is useful if you want to
607               know what the possible "run_" commands are, but you don't want
608               to have the "run_" in the final result.
609
610               If you do not specify this argument, it uses '0' (the default
611               is not to strip the results).
612
613           4.  $haystack
614
615               You can pass in a reference to a list of strings here. Each
616               string will be compared with $needle.
617
618               If you do not specify this argument, it uses the list of
619               handlers. This is how Term::Shell matches commands typed in by
620               the user with command handlers written by you.
621
622       18. print_pairs()
623
624           This overloaded beast is used whenever Term::Shell wants to print a
625           set of keys and values. It handles wrapping long values, indenting
626           the whole thing, inserting the separator between the key and value,
627           and all the rest.
628
629           There are lots of parameters, but most of them are optional:
630
631           1.  $keys
632
633               A reference to a list of keys to print.
634
635           2.  $values
636
637               A reference to a list of values to print.
638
639           3.  $sep
640
641               The string used to separate the keys and values. If omitted, ':
642               ' is used.
643
644           4.  $left
645
646               The justification to be used to line up the keys. If true, the
647               keys will be left-justified. If false or omitted, the keys will
648               be right-justified.
649
650           5.  $ind
651
652               A string used to indent the whole paragraph. Internally,
653               print_pairs() uses length(), so you shouldn't use tabs in the
654               indent string. If omitted, the empty string is used (no
655               indent).
656
657           6.  $len
658
659               An integer which describes the minimum length of the keys.
660               Normally, print_pairs() calculates the longest key and assigns
661               the column width to be as wide as the longest key plus the
662               separator. You can force the column width to be larger using
663               $len. If omitted, 0 is used.
664
665           7.  $wrap
666
667               A boolean which indicates whether the value should be text-
668               wrapped using Text::Autoformat. Text is only ever wrapped if it
669               contains at least one space.  If omitted, 0 is used.
670
671           8.  $cols
672
673               An integer describing the number of columns available on the
674               current terminal.  Normally 78 is used, or the environment
675               variable COLUMNS, but you can override the number here to
676               simulate a right-indent.
677
678       19. term()
679
680           Returns the underlying "Term::ReadLine" object used to interact
681           with the user. You can do powerful things with this object; in
682           particular, you will cripple Term::Shell's completion scheme if you
683           change the completion callback function.
684
685       20. process_esc()
686
687           This method may be overridden to provide shell-like escaping of
688           backslashes inside quoted strings. It accepts two parameters:
689
690           1.  $c
691
692               The character which was escaped by a backslash.
693
694           2.  $quote
695
696               The quote character used to delimit this string. Either """ or
697               "'".
698
699           This method should return the string which should replace the
700           backslash and the escaped character.
701
702           By default, process_esc() uses escaping rules similar to Perl's
703           single-quoted string:
704
705           1.  Escaped backslashes return backslashes. The string "123\\456"
706               returns "123\456".
707
708           2.  Escaped quote characters return the quote character (to allow
709               quote characters in strings). The string "abc\"def" returns
710               "abc"def".
711
712           3.  All other backslashes are returned verbatim. The string
713               "123\456" returns "123\456".
714
715           Term::Shell's quote characters cannot be overridden, unless you
716           override line_parsed(): they are """ or "'". This may change in a
717           future version of Term::Shell.
718
719       21. add_handlers()
720
721           See "Adding Commands to Your Shell" for information on
722           add_handlers().
723
724       22. remove_commands()
725
726           remove_handlers()
727
728           See "Removing Commands from Your Shell" for information on
729           remove_handlers().
730

The Term::Shell Object

732       Term::Shell creates a hash based Perl object. The object contains
733       information like what handlers it found, the underlying Term::ReadLine
734       object, and any arguments passed to the constructor.
735
736       This hash is broken into several subhashes. The only two subhashes that
737       a Shell should ever use are $o->{API} and $o->{SHELL}. The first one
738       contains all the information that Term::Shell has gathered for you. The
739       second one is a private area where your Shell can freely store data
740       that it might need later on.
741
742       This section will describe all the Term::Shell object "API" attributes:
743
744   The args Attribute
745       This an array reference containing any arguments passed to the
746       Term::Shell constructor.
747
748   The case_ignore Attribute
749       This boolean controls whether commands should be matched without regard
750       to case. If this is true, then typing "FoO" will have the same effect
751       as typing "foo".
752
753       Defaults to true on MSWin32, and false on other platforms.
754
755   The class Attribute
756       The class of the object. This is probably the package containing the
757       definition of your shell, but if someone subclasses your shell, it's
758       their class.
759
760   The command Attribute
761       Whenever Term::Shell invokes an action, it stores information about the
762       action in the "command" attribute. Information about the last "run"
763       action to be invoked is stored in $o->{API}{command}{run}. The
764       information itself is stored in a subhash containing these fields:
765
766       name
767           The name of the command, as typed by the user.
768
769       found
770           The a boolean value indicating whether a handler could be found.
771
772       handler
773           The full name of the handler, if found.
774
775       Note that this facility only stores information about the last action
776       to be executed. It's good enough for retrieving the information about
777       the last handler which ran, but not for much else.
778
779       The following example shows a case where "run_foo()" calls "run_add()",
780       and prints its return value (in this case, 42).
781
782          sub run_foo {
783              my $o = shift;
784              my $sum = $o->run("add", 21, 21);
785              print "21 + 21 = ", $sum, "\n";
786          }
787
788          sub run_add {
789              my $o = shift;
790              my $sum = 0;
791              $sum += $_ for @_;
792              print "add(): sum = $sum\n";
793              return $sum;
794          }
795
796       At the end of run_foo(), $o->{API}{command}{run}{handler} contains the
797       string "run_add".
798
799   The match_uniq Attribute
800       This boolean controls whether the user can type in only enough of the
801       command to make it unambiguous. If true, then if the shell has the
802       commands "foo" and "bar" defined, the user can type "f" to run "foo",
803       and "b" to run "bar".
804
805       Defaults to true.
806
807   The readline Attribute
808       Which Term::ReadLine module is being used. Currently, this is always
809       one of "Term::ReadLine::Stub", "Term::ReadLine::Perl", or
810       "Term::ReadLine::Gnu".
811
812   The script Attribute
813       The name of the script that invoked your shell.
814
815   The version Attribute
816       The version of Term::Shell you are running under.
817

BUGS AND DEFICIENCIES

819       There are bound to be some bugs lurking about.
820
821       If you find bugs, please send them to "NEILW@cpan.org".
822

SEE ALSO

824       For more information about the underlying ReadLine module, see
825       Term::ReadLine. You may also want to look at Term::ReadLine::Gnu and
826       Term::ReadLine::Perl.
827
828       For more information about the underlying formatter used by
829       print_pairs(), see Text::Autoformat.
830
831       The API for Term::Shell was inspired by (gasp!) a Python package called
832       "cmd". For more information about this package, please look in the
833       Python Library Reference, either in your Python distribution or at
834       http://www.python.org/doc/current/lib/module-cmd.html
835

AUTHOR

837       Neil Watkiss (NEILW@cpan.org)
838
840       Copyright (c) 2001, Neil Watkiss. All Rights Reserved.
841
842       All Rights Reserved. This module is free software. It may be used,
843       redistributed and/or modified under the same terms as Perl itself.
844
845       See http://www.perl.com/perl/misc/Artistic.html
846

AUTHOR

848       Shlomi Fish <shlomif@cpan.org>
849
851       This software is copyright (c) 2001 by Neil Watkiss.
852
853       This is free software; you can redistribute it and/or modify it under
854       the same terms as the Perl 5 programming language system itself.
855

BUGS

857       Please report any bugs or feature requests on the bugtracker website
858       <http://rt.cpan.org/NoAuth/Bugs.html?Dist=Term-Shell> or by email to
859       bug-term-shell@rt.cpan.org <mailto:bug-term-shell@rt.cpan.org>.
860
861       When submitting a bug or request, please include a test-file or a patch
862       to an existing test-file that illustrates the bug or desired feature.
863

SUPPORT

865   Perldoc
866       You can find documentation for this module with the perldoc command.
867
868         perldoc Term::Shell
869
870   Websites
871       The following websites have more information about this module, and may
872       be of help to you. As always, in addition to those websites please use
873       your favorite search engine to discover more resources.
874
875       ·   MetaCPAN
876
877           A modern, open-source CPAN search engine, useful to view POD in
878           HTML format.
879
880           <https://metacpan.org/release/Term-Shell>
881
882       ·   Search CPAN
883
884           The default CPAN search engine, useful to view POD in HTML format.
885
886           <http://search.cpan.org/dist/Term-Shell>
887
888       ·   RT: CPAN's Bug Tracker
889
890           The RT ( Request Tracker ) website is the default bug/issue
891           tracking system for CPAN.
892
893           <https://rt.cpan.org/Public/Dist/Display.html?Name=Term-Shell>
894
895       ·   AnnoCPAN
896
897           The AnnoCPAN is a website that allows community annotations of Perl
898           module documentation.
899
900           <http://annocpan.org/dist/Term-Shell>
901
902       ·   CPAN Ratings
903
904           The CPAN Ratings is a website that allows community ratings and
905           reviews of Perl modules.
906
907           <http://cpanratings.perl.org/d/Term-Shell>
908
909       ·   CPANTS
910
911           The CPANTS is a website that analyzes the Kwalitee ( code metrics )
912           of a distribution.
913
914           <http://cpants.cpanauthors.org/dist/Term-Shell>
915
916       ·   CPAN Testers
917
918           The CPAN Testers is a network of smoke testers who run automated
919           tests on uploaded CPAN distributions.
920
921           <http://www.cpantesters.org/distro/T/Term-Shell>
922
923       ·   CPAN Testers Matrix
924
925           The CPAN Testers Matrix is a website that provides a visual
926           overview of the test results for a distribution on various
927           Perls/platforms.
928
929           <http://matrix.cpantesters.org/?dist=Term-Shell>
930
931       ·   CPAN Testers Dependencies
932
933           The CPAN Testers Dependencies is a website that shows a chart of
934           the test results of all dependencies for a distribution.
935
936           <http://deps.cpantesters.org/?module=Term::Shell>
937
938   Bugs / Feature Requests
939       Please report any bugs or feature requests by email to "bug-term-shell
940       at rt.cpan.org", or through the web interface at
941       <https://rt.cpan.org/Public/Bug/Report.html?Queue=Term-Shell>. You will
942       be automatically notified of any progress on the request by the system.
943
944   Source Code
945       The code is open to the world, and available for you to hack on. Please
946       feel free to browse it and play with it, or whatever. If you want to
947       contribute patches, please send me a diff or prod me to pull from your
948       repository :)
949
950       <https://github.com/shlomif/Term-Shell>
951
952         git clone git://git@github.com:shlomif/Term-Shell.git
953
954
955
956perl v5.28.1                      2019-02-02                    Term::Shell(3)
Impressum