1Term::Shell(3) User Contributed Perl Documentation Term::Shell(3)
2
6 Term::Shell - A simple command-line shell framework.
7
9 version 0.10
10
12 package MyShell;
13 use base qw(Term::Shell);
14 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 sub run_command2 { print "command 2!\n"; }
24 package main;
26 my $shell = MyShell->new;
27 $shell->cmdloop;
28
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 The base class comes with two commands pre-defined: exit and help.
35 To write a shell with an "exec" command, do something like this:
37 package MyShell;
39 use base qw(Term::Shell); # or manually edit @MyShell::ISA.
40 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 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
55 version 0.10
56
58 How do you bring your shell to life? Assuming the package "MyShell"
59 contains your actions, just do this:
60 use MyShell;
62 my $shell = MyShell->new;
63 # Setup code here (if you wish)
65 # Invoke the shell
67 $shell->cmdloop;
68 # Cleanup code here (if you wish)
70 Most people put the setup code in the shell itself, so you can usually
72 get away with this:
73 use MyShell;
75 MyShell->new->cmdloop;
76 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 package main;
83 MyShell->new->cmdloop;
84 package MyShell;
86 use base qw(Term::Shell);
87 # Actions here
89 Adding commands to your shell is just as easy, if not easier.
91
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 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 1. run_foo()
104 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 The method is called with the Term::Shell object as its first
109 argument, followed by any arguments the user typed in.
110 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 2. help_foo()
116 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 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 If you do not provide a "help_foo()" method, typing 'help foo'
127 produces an error message.
128 3. smry_foo()
130 Should return a one-line summary of "foo", to be displayed in the
132 help screen.
133 This method is called with the Term::Shell object as its first
135 argument, and no other arguments.
136 If you do not provide a "smry_foo()" method, then the string
138 'undocumented' is used instead.
139 4. comp_foo()
141 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 This method is called with the Term::Shell object as its first
148 argument, followed by the three arguments:
149 1. $word
151 The word the user is trying to complete.
153 2. $line
155 The line as typed by the user so far.
157 3. $start
159 The offset into $line where $word starts.
161 If you do not provide "comp_foo()", Term::Shell will always return
163 no completions for "foo".
164 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 5. alias_foo()
173 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 6. catch_run()
179 catch_help()
181 catch_comp()
183 catch_smry()
185 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 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 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 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 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 package MyShell;
210 use base qw(Term::Shell);
211 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 sub init {
222 my $o = shift;
223 $o->add_handlers("run_fuzz", "run_foozle");
224 }
225 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
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 1. remove_commands()
239 Removes all handlers associated with the given command (or list of
241 commands).
242 For example, Term::Shell comes with two commands ("exit" and
244 "help") implemented with seven handlers:
245 1. smry_exit()
247 2. help_exit()
249 3. run_exit()
251 4. smry_help()
253 5. help_help()
255 6. comp_help()
257 7. run_help()
259 If you want to create a shell that doesn't implement the "help"
261 command, your code might look something like this example:
262 package MyShell;
264 use base qw(Term::Shell);
265 sub init {
267 my $o = shift;
268 $o->remove_commands("help");
269 }
270 # ... define more handlers here ...
272 2. remove_handlers()
274 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 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 package MyShell;
285 use base qw(Term::Shell);
286 sub init {
288 my $o = shift;
289 $o->remove_handlers("help_exit");
290 }
291 # ... define more handlers here ...
293 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 shell> help
300 Unknown command 'help'; type 'help' for a list of commands.
301 Here's the innocuous looking code:
303 package MyShell;
305 use base qw(Term::Shell);
306 sub init {
308 my $o = shift;
309 $o->remove_commands("help");
310 }
311 MyShell->new->cmdloop;
313 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 1. msg_unknown_cmd()
320 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 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 2. msg_ambiguous_cmd()
334 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 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
352 Shell classes can use any of the methods in this list. Any other
353 methods in Term::Shell may change.
354 1. new()
356 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 my $sh = Term::Shell->new(@arbitrary_args);
362 2. cmd()
364 cmd($txt);
366 Invokes $txt as if it had been typed in at the prompt.
368 $sh->cmd("echo 1 2 3");
370 3. cmdloop()
372 mainloop()
374 Repeatedly prompts the user, reads a line, parses it, and invokes a
376 handler. Uses "cmd()" internally.
377 MyShell->new->cmdloop;
379 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 4. init()
386 fini()
388 Do any initialization or cleanup you need at shell creation
390 (init()) and destruction (fini()) by defining these methods.
391 No parameters are passed.
393 5. preloop()
395 postloop()
397 Do any initialization or cleanup you need at shell startup
399 (preloop()) and shutdown (postloop()) by defining these methods.
400 No parameters are passed.
402 6. precmd()
404 postcmd()
406 Do any initialization or cleanup before and after calling each
408 handler.
409 The parameters are:
411 1. $handler
413 A reference to the name of the handler that is about to be
415 executed.
416 Passed by reference so you can control which handler will be
418 called.
419 2. $cmd
421 A reference to the command as the user typed it.
423 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 3. $args
429 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 sub precmd {
435 my $o = shift;
436 my ($handler, $cmd, @args) = @_;
437 # ...
438 }
439 7. stoploop()
441 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 my $sh = MyShell->new;
447 $sh->cmdloop; # an interactive session
448 $sh->cmdloop; # prompts the user again
449 Term::Shell's built-in run_exit() command just calls stoploop().
451 8. idle()
453 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 package MyShell;
460 use base qw(Term::Shell);
461 sub init {
463 my $o = shift;
464 $o->{API}{check_idle} = 0.1; # 10/s
465 }
466 sub idle {
468 print "Idle!\n";
469 }
470 9. prompt_str()
472 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 package MyShell;
478 use base qw(Term::Shell);
479 sub prompt_str { "search> " }
481 10. prompt()
483 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 The prompt() method takes the following parameters:
490 1. $prompt
492 The prompt to display to the user. This can be any string you
494 want.
495 2. $default
497 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 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 3. $completions
507 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 4. $casei
514 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 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 11. cmd_prefix()
525 cmd_suffix()
527 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 12. page()
533 page($txt)
535 Prints $txt through a pager, prompting the user to press a key for
537 the next screen full of text.
538 13. line()
540 line_parsed()
542 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 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 14. run()
554 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 It needs the name of the action to run and any arguments to pass to
561 the handler.
562 Term::Shell uses this method internally to invoke command handlers.
564 15. help()
566 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 Term::Shell uses this method internally to invoke help handlers.
572 16. summary()
574 If you want to get the summary text of an action, use summary(). It
576 needs the name of the action.
577 Term::Shell uses this method internally to display the help page.
579 17. possible_actions()
581 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 There are several arguments, but you probably won't use them all in
588 the simple cases:
589 1. $needle
591 The (possible incomplete) word to try to match against the list
593 of actions (the haystack).
594 2. $type
596 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 3. $strip
603 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 If you do not specify this argument, it uses '0' (the default
611 is not to strip the results).
612 4. $haystack
614 You can pass in a reference to a list of strings here. Each
616 string will be compared with $needle.
617 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 18. print_pairs()
623 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 There are lots of parameters, but most of them are optional:
630 1. $keys
632 A reference to a list of keys to print.
634 2. $values
636 A reference to a list of values to print.
638 3. $sep
640 The string used to separate the keys and values. If omitted, ':
642 ' is used.
643 4. $left
645 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 5. $ind
651 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 6. $len
658 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 7. $wrap
666 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 8. $cols
672 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 19. term()
679 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 20. process_esc()
686 This method may be overridden to provide shell-like escaping of
688 backslashes inside quoted strings. It accepts two parameters:
689 1. $c
691 The character which was escaped by a backslash.
693 2. $quote
695 The quote character used to delimit this string. Either """ or
697 "'".
698 This method should return the string which should replace the
700 backslash and the escaped character.
701 By default, process_esc() uses escaping rules similar to Perl's
703 single-quoted string:
704 1. Escaped backslashes return backslashes. The string "123\\456"
706 returns "123\456".
707 2. Escaped quote characters return the quote character (to allow
709 quote characters in strings). The string "abc\"def" returns
710 "abc"def".
711 3. All other backslashes are returned verbatim. The string
713 "123\456" returns "123\456".
714 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 21. add_handlers()
720 See "Adding Commands to Your Shell" for information on
722 add_handlers().
723 22. remove_commands()
725 remove_handlers()
727 See "Removing Commands from Your Shell" for information on
729 remove_handlers().
730
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 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 This section will describe all the Term::Shell object "API" attributes:
743 The args Attribute
745 This an array reference containing any arguments passed to the
746 Term::Shell constructor.
747 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 Defaults to true on MSWin32, and false on other platforms.
754 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 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 name
767 The name of the command, as typed by the user.
768 found
770 The a boolean value indicating whether a handler could be found.
771 handler
773 The full name of the handler, if found.
774 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 The following example shows a case where "run_foo()" calls "run_add()",
780 and prints its return value (in this case, 42).
781 sub run_foo {
783 my $o = shift;
784 my $sum = $o->run("add", 21, 21);
785 print "21 + 21 = ", $sum, "\n";
786 }
787 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 At the end of run_foo(), $o->{API}{command}{run}{handler} contains the
797 string "run_add".
798 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 Defaults to true.
806 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 The script Attribute
813 The name of the script that invoked your shell.
814 The version Attribute
816 The version of Term::Shell you are running under.
817
819 There are bound to be some bugs lurking about.
820 If you find bugs, please send them to "NEILW@cpan.org".
822
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 For more information about the underlying formatter used by
829 print_pairs(), see Text::Autoformat.
830 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
837 Neil Watkiss (NEILW@cpan.org)
838
840 Copyright (c) 2001, Neil Watkiss. All Rights Reserved.
841 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 See http://www.perl.com/perl/misc/Artistic.html
846
848 Shlomi Fish <shlomif@cpan.org>
849
851 This software is copyright (c) 2001 by Neil Watkiss.
852 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
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 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
865 Perldoc
866 You can find documentation for this module with the perldoc command.
867 perldoc Term::Shell
869 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 · MetaCPAN
876 A modern, open-source CPAN search engine, useful to view POD in
878 HTML format.
879 <https://metacpan.org/release/Term-Shell>
881 · Search CPAN
883 The default CPAN search engine, useful to view POD in HTML format.
885 <http://search.cpan.org/dist/Term-Shell>
887 · RT: CPAN's Bug Tracker
889 The RT ( Request Tracker ) website is the default bug/issue
891 tracking system for CPAN.
892 <https://rt.cpan.org/Public/Dist/Display.html?Name=Term-Shell>
894 · AnnoCPAN
896 The AnnoCPAN is a website that allows community annotations of Perl
898 module documentation.
899 <http://annocpan.org/dist/Term-Shell>
901 · CPAN Ratings
903 The CPAN Ratings is a website that allows community ratings and
905 reviews of Perl modules.
906 <http://cpanratings.perl.org/d/Term-Shell>
908 · CPANTS
910 The CPANTS is a website that analyzes the Kwalitee ( code metrics )
912 of a distribution.
913 <http://cpants.cpanauthors.org/dist/Term-Shell>
915 · CPAN Testers
917 The CPAN Testers is a network of smoke testers who run automated
919 tests on uploaded CPAN distributions.
920 <http://www.cpantesters.org/distro/T/Term-Shell>
922 · CPAN Testers Matrix
924 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 <http://matrix.cpantesters.org/?dist=Term-Shell>
930 · CPAN Testers Dependencies
932 The CPAN Testers Dependencies is a website that shows a chart of
934 the test results of all dependencies for a distribution.
935 <http://deps.cpantesters.org/?module=Term::Shell>
937 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 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 <https://github.com/shlomif/Term-Shell>
951 git clone git://git@github.com:shlomif/Term-Shell.git
953perl v5.28.1 2019-02-02 Term::Shell(3)