Term-UI-0.50/0000755000175000017500000000000014103264524012205 5ustar bingosbingosTerm-UI-0.50/META.json0000664000175000017500000000247114103264524013634 0ustar bingosbingos{ "abstract" : "User interfaces via Term::ReadLine made easy", "author" : [ "Jos Boumans " ], "dynamic_config" : 1, "generated_by" : "ExtUtils::MakeMaker version 7.62, CPAN::Meta::Converter version 2.150010", "license" : [ "perl_5" ], "meta-spec" : { "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec", "version" : 2 }, "name" : "Term-UI", "no_index" : { "directory" : [ "t", "inc" ] }, "prereqs" : { "build" : { "requires" : { "ExtUtils::MakeMaker" : "0" } }, "configure" : { "requires" : { "ExtUtils::MakeMaker" : "0" } }, "runtime" : { "requires" : { "Locale::Maketext::Simple" : "0", "Log::Message::Simple" : "0", "Params::Check" : "0", "Term::ReadLine" : "0", "Test::More" : "0.31", "if" : "0", "parent" : "0" } } }, "release_status" : "stable", "resources" : { "repository" : { "type" : "git", "url" : "git://github.com/jib/term-ui.git", "web" : "https://github.com/jib/term-ui" } }, "version" : "0.50", "x_serialization_backend" : "JSON::PP version 4.06" } Term-UI-0.50/MANIFEST0000644000175000017500000000045414103264524013341 0ustar bingosbingosCHANGES lib/Term/UI.pm lib/Term/UI/History.pm Makefile.PL MANIFEST This list of files README t/00_load.t t/01_history.t t/02_ui.t META.yml Module YAML meta-data (added by MakeMaker) META.json Module JSON meta-data (added by MakeMaker) Term-UI-0.50/CHANGES0000644000175000017500000000431014103264424013175 0ustar bingosbingos0.50 Fri 6 Aug 17:52:26 BST 2021 * Fix number of tests to skip (Michal Josef Špaček) * Fix selecting the last choice (Valery Kalesnik) 0.48 Tue 3 Aug 19:13:22 BST 2021 * Allow to specify the preput argument for the Term::ReadLine::Gnu (Constantin Kulikov) * RT#134899 Regex metacharacters in the choices can cause breakage (Valery Kalesnik) * Better width for choice number field (Valery Kalesnik) * RT#68198 Better processing of 'default' holding numbers (Valery Kalesnik) * Modernisation of distribution and coding (Valery Kalesnik) 0.46 Mon May 25 18:47:04 BST 2015 * Fix test skip count for non-terminals (Alexandr Ciornii) 0.44 Mon May 25 12:09:17 BST 2015 * Fix multi-choice without defaults (Noel Maddy) 0.42 Thu Jan 2 12:32:18 GMT 2014 * Fix test skip count for non-terminals 0.40 Wed Jan 1 15:00:29 GMT 2014 * default can be expressed as an arrayref (Marc Popp) 0.38 Mon Sep 23 12:47:15 BST 2013 * Version bump to give ::History a version number 0.36 Wed Jun 5 23:04:06 BST 2013 * Documentation fixes (David Steinbrunner) 0.34 Tue Jan 22 12:19:40 GMT 2013 * deprecate usage added if the library is found in corelib location. Term::UI is leaving core with v5.20.0 0.32 Sat Nov 10 11:00:31 GMT 2012 * Add a delimiter to a prompt that doesn't have a default (Tommy Stanton) 0.30 Wed Dec 21 23:30:39 GMT 2011 * Resolve PAUSE indexer problems 0.28 Wed Dec 21 22:26:05 GMT 2011 * Apply Debian patches [rt.cpan.org #73400] 0.26 Wed Feb 9 15:06:32 GMT 2011 * Apply blead patch from Michael Stevens RT #65038 0.24 Wed Jan 12 13:16:01 GMT 2011 * Skip some tests if we are not on a terminal 0.22 Fri Jan 7 21:55:38 GMT 2011 * Apply blead patch from Peter Acklam 0.20 Fri Apr 24 15:59:40 CEST 2009 * Address: #45264 Patch for Term::UI; when get_reply is called without a default, term::ui would emit a warning. 0.18 Sun Nov 4 18:30:41 CET 2007 * Option parsing wasn't tolerant for cases where the string *only* contained options. This is now fixed. 0.16 Wed Oct 3 14:38:15 CEST 2007 * Option parsing went wrong with 'foo-bar' arguments, where it'd strip off -bar as an option. Fixed with look-aheads. 0.14 Fri Oct 20 17:42:11 CEST 2006 * Clean up test files to work nicer with perl core Term-UI-0.50/t/0000755000175000017500000000000014103264524012450 5ustar bingosbingosTerm-UI-0.50/t/01_history.t0000755000175000017500000000326214102302142014630 0ustar bingosbingos#!/usr/bin/env perl use strict; use warnings; BEGIN { chdir 't' if -d 't'; use File::Spec; use lib File::Spec->catdir( qw[.. lib] ); } use Test::More 'no_plan'; my $Class = 'Term::UI::History'; my $Func = 'history'; my $Verbose = 0; # print to STDOUT? ### test load & exports { use_ok( $Class ); for my $pkg ( $Class, __PACKAGE__ ) { can_ok( $pkg, $Func ); } } ### test string recording { history( $$, $Verbose ); my $str = $Class->history_as_string; ok( $str, "Message recorded" ); is( $str, $$, " With appropriate content" ); $Class->flush; ok( !$Class->history_as_string, " Stack flushed" ); } ### test filehandle printing SKIP: { my $file = "$$.tmp"; { open my $fh, ">$file" or skip "Could not open $file: $!", 6; ### declare twice for 'used only once' warning local $Term::UI::History::HISTORY_FH = $fh; local $Term::UI::History::HISTORY_FH = $fh; history( $$ ); close $fh; } my $str = $Class->history_as_string; ok( $str, "Message recorded" ); is( $str, $$, " With appropriate content" ); ### check file contents { ok( -e $file, "File $file exists" ); ok( -s $file, " File has size" ); open my $fh, $file or skip "Could not open $file: $!", 2; my $cont = do { local $/; <$fh> }; chomp $cont; is( $cont, $str, " File has same content" ); } $Class->flush; ### for VMS etc 1 while unlink $file; ok( ! -e $file, " File $file removed" ); } Term-UI-0.50/t/00_load.t0000755000175000017500000000047214102302142014045 0ustar bingosbingos#!/usr/bin/env perl use strict; use warnings; BEGIN { chdir 't' if -d 't'; use File::Spec; use lib File::Spec->catdir( qw[.. lib] ); } use Test::More 'tests' => 1; my $Class = 'Term::UI'; use_ok( $Class ); diag "Testing $Class " . $Class->VERSION . ", Perl $], $^X" unless $ENV{ 'PERL_CORE' }; Term-UI-0.50/t/02_ui.t0000755000175000017500000001201414103264232013550 0ustar bingosbingos#!/usr/bin/env perl ### Term::UI test suite ### use strict; use warnings; use lib qw[../lib lib]; use Test::More 'tests' => 23; use Term::ReadLine (); use_ok( 'Term::UI' ); ### make sure we can do this automatically ### $Term::UI::AUTOREPLY = $Term::UI::AUTOREPLY = 1; $Term::UI::VERBOSE = $Term::UI::VERBOSE = 0; # SKIP tests if we aren't on a terminal SKIP: { skip 'not on a terminal', 22 unless -t; ### enable warnings $^W = 1; ### perl core gets upset if we print stuff to STDOUT... if( $ENV{PERL_CORE} ) { *STDOUT_SAVE = *STDOUT_SAVE = *STDOUT; close *STDOUT; open *STDOUT, ">termui.$$" or diag("Could not open tempfile"); } END { close *STDOUT && unlink "termui.$$" if $ENV{PERL_CORE} } ### so T::RL doesn't go nuts over no console BEGIN{ $ENV{LINES}=25; $ENV{COLUMNS}=80; } my $term = Term::ReadLine->new('test') or diag "Could not create a new term. Dying", die; my $tmpl = { prompt => "What is your favourite colour?", choices => [qw|blue red green|], default => 'blue', }; { my $args = \%{ $tmpl }; is( $term->get_reply( %$args ), 'blue', q[Checking reply with defaults and choices] ); } { my $args = \%{ $tmpl }; delete $args->{choices}; is( $term->get_reply( %$args ), 'blue', q[Checking reply with defaults] ); } { my $args = \%{ $tmpl }; $args->{choices} = [qw|blue red green|], $args->{multi} = 1; delete $args->{default}; is_deeply( [ $term->get_reply( %$args ) ], [undef], q[Checking reply with multiple choices but no defaults] ); } { my $args = \%{ $tmpl }; $args->{choices} = [qw|blue red green|], $args->{multi} = 1; $args->{default} = [qw|blue red|]; is_deeply( [ $term->get_reply( %$args ) ], [qw|blue red|], q[Checking reply with multible defaults and choices] ); } { my $args = \%{ $tmpl }; delete $args->{choices}; $args->{multi} = 1; $args->{default} = [qw|blue red|]; is_deeply( [ $term->get_reply( %$args ) ], [qw|blue red|], q[Checking reply with multible defaults] ); } { my $args = { 'prompt' => "What is your favourite colour?", 'choices' => [ qw| blue red green [ | ], 'multi' => 1, 'default' => [ qw| blue red | ], }; is_deeply( [ $term->get_reply( %$args ) ], [ qw| blue red | ], q[Checking reply with multible defaults and choices (including a broken regex)], ); } { my $args = { prompt => 'Do you like cookies?', default => 'y', }; is( $term->ask_yn( %$args ), 1, q[Asking yes/no with 'yes' as default] ); } { my $args = { prompt => 'Do you like Python?', default => 'n', }; is( $term->ask_yn( %$args ), 0, q[Asking yes/no with 'no' as default] ); } # used to print: Use of uninitialized value in length at Term/UI.pm line 141. # [#13412] { my $args = { prompt => 'Uninit warning on empty default', }; my $warnings = ''; local $SIG{__WARN__} = sub { $warnings .= "@_" }; my $res = $term->get_reply( %$args ); ok( !$res, "Empty result on autoreply without default" ); is( $warnings, '', " No warnings with empty default" ); unlike( $warnings, qr|Term.UI|, " No warnings from Term::UI" ); } # used to print: Use of uninitialized value in string at Params/Check.pm # [#13412] { my $args = { prompt => 'Undef warning on failing allow', allow => sub { 0 }, }; my $warnings = ''; local $SIG{__WARN__} = sub { $warnings .= "@_" }; my $res = $term->get_reply( %$args ); ok( !$res, "Empty result on autoreply without default" ); is( $warnings, '', " No warnings with failing allow" ); unlike( $warnings, qr|Params.Check|, " No warnings from Params::Check" ); } #### test parse_options { my $str = q[command --no-foo --baz --bar=0 --quux=bleh ] . q[--option="some'thing" -one-dash -single=blah' foo bar-zot]; my $munged = 'command foo bar-zot'; my $expected = { foo => 0, baz => 1, bar => 0, quux => 'bleh', option => q[some'thing], 'one-dash' => 1, single => q[blah'], }; my ($href,$rest) = $term->parse_options( $str ); is_deeply($href, $expected, qq[Parsing options] ); is($rest, $munged, qq[Remaining unparsed string '$munged'] ); } ### more parse_options tests { my @map = ( [ 'x --update_source' => 'x', { update_source => 1 } ], [ '--update_source' => '', { update_source => 1 } ], ); for my $aref ( @map ) { my( $input, $munged, $expect ) = @$aref; my($href,$rest) = $term->parse_options( $input ); ok( $href, "Parsed '$input'" ); is_deeply( $href, $expect, " Options parsed correctly" ); is( $rest, $munged, " Command parsed correctly" ); } } } # End SKIP block Term-UI-0.50/lib/0000755000175000017500000000000014103264524012753 5ustar bingosbingosTerm-UI-0.50/lib/Term/0000755000175000017500000000000014103264524013662 5ustar bingosbingosTerm-UI-0.50/lib/Term/UI.pm0000644000175000017500000005475514103264260014552 0ustar bingosbingospackage Term::UI; $Term::UI::VERSION = '0.50'; use if $] > 5.017, 'deprecate'; use strict; use warnings; use Carp; use Params::Check qw[check allow]; use Term::ReadLine; use Locale::Maketext::Simple Style => 'gettext'; use Term::UI::History; our $AUTOREPLY; our $INVALID = loc( 'Invalid selection, please try again: ' ); our $VERBOSE = 1; push @Term::ReadLine::Stub::ISA, __PACKAGE__ unless grep { $_ eq __PACKAGE__ } @Term::ReadLine::Stub::ISA; =pod =head1 NAME Term::UI - Term::ReadLine UI made easy =head1 SYNOPSIS use Term::UI; use Term::ReadLine; my $term = Term::ReadLine->new('brand'); my $reply = $term->get_reply( prompt => 'What is your favourite colour?', choices => [qw|blue red green|], default => 'blue', ); my $bool = $term->ask_yn( prompt => 'Do you like cookies?', default => 'y', ); my $string = q[some_command -option --no-foo --quux='this thing']; my ($options,$munged_input) = $term->parse_options($string); ### don't have Term::UI issue warnings -- default is '1' $Term::UI::VERBOSE = 0; ### always pick the default (good for non-interactive terms) ### -- default is '0' $Term::UI::AUTOREPLY = 1; ### Retrieve the entire session as a printable string: $hist = Term::UI::History->history_as_string; $hist = $term->history_as_string; =head1 DESCRIPTION C is a transparent way of eliminating the overhead of having to format a question and then validate the reply, informing the user if the answer was not proper and re-issuing the question. Simply give it the question you want to ask, optionally with choices the user can pick from and a default and C will DWYM. For asking a yes or no question, there's even a shortcut. =head1 HOW IT WORKS C places itself at the back of the C C<@ISA> array, so you can call its functions through your term object. C uses C to record all interactions with the commandline. You can retrieve this history, or alter the filehandle the interaction is printed to. See the C manpage or the C for details. =head1 METHODS =head2 $reply = $term->get_reply( prompt => 'question?', [choices => \@list, default => $list[0], preput => "text to put as default user input", multi => BOOL, print_me => "extra text to print & record", allow => $ref] ); C asks a user a question, and then returns the reply to the caller. If the answer is invalid (more on that below), the question will be reposed, until a satisfactory answer has been entered. You have the option of providing a list of choices the user can pick from using the C argument. If the answer is not in the list of choices presented, the question will be reposed. If you provide a C answer, this will be returned when either C<$AUTOREPLY> is set to true, (see the C section further below), or when the user just hits C. The C argument allows to specify a text that will be inserted to the prompt line as the initial input which may be edited, deleted or accepted by the user. If you supply the empty string as the C argument then the C value will be preputted. It will only work if the underlying readline module provide support for it (now it is supported only by the C). You can indicate that the user is allowed to enter multiple answers by toggling the C flag. Note that a list of answers will then be returned to you, rather than a simple string. By specifying an C handler, you can yourself validate the answer a user gives. This can be any of the types that the Params::Check C function allows, so please refer to that manpage for details. Finally, you have the option of adding a C argument, which is simply printed before the prompt. It's printed to the same file handle as the rest of the questions, so you can use this to keep track of a full session of Q&A with the user, and retrieve it later using the C<< Term::UI->history_as_string >> function. See the C section for samples of how to use this function. =cut sub get_reply { my $term = shift; my %hash = @_; my $tmpl = { default => { default => undef, strict_type => 0 }, preput => { default => '', strict_type => 0 }, prompt => { default => '', strict_type => 1, required => 1 }, choices => { default => [], strict_type => 1 }, multi => { default => 0, allow => [0, 1] }, allow => { default => qr/.*/ }, print_me => { default => '', strict_type => 1 }, }; my $args = check( $tmpl, \%hash, $VERBOSE ) or ( carp( loc(q[Could not parse arguments]) ), return ); # Check for legacy default on multi=1 if ($args->{multi} and defined $args->{default} and ref($args->{default}) ne "ARRAY") { $args->{default} = [ $args->{default} ]; } ### add this to the prompt to indicate the default ### answer to the question if there is one. my $prompt_add; ### if you supplied several choices to pick from, ### we'll print them separately before the prompt if( @{$args->{choices}} ) { # clean up 'default' of items not in 'choices' if ( $args->{ 'default' } ) { if ( $args->{ 'multi' } ) { @{ $args->{ 'default' } } = grep { my $default = $_; grep $default eq $_, @{ $args->{ 'choices' } }; } @{ $args->{ 'default' } }; } else { delete $args->{ 'default' } unless grep $_ eq $args->{ 'default' }, @{ $args->{ 'choices' } } } } my $i; my $choices_width = length( sprintf( "%d", scalar @{ $args->{ 'choices' } } ) ); for my $choice ( @{$args->{choices}} ) { $i++; # the answer counter -- but humans start counting # at 1 :D ### so this choice is the default? add it to 'prompt_add' ### so we can construct a "foo? [DIGIT]" type prompt if (defined $args->{default}) { if ($args->{multi}) { push @$prompt_add, $i if grep { $_ eq $choice } @{ $args->{ 'default' } }; } else { $prompt_add = $i if ($choice eq $args->{default}); } } ### create a "DIGIT> choice" type line $args->{print_me} .= sprintf "\n%*s> %-s", $choices_width, $i, $choice; } $prompt_add = join(" ", @$prompt_add) if ( $prompt_add && $args->{multi} ); ### we listed some choices -- add another newline for ### pretty printing $args->{print_me} .= "\n" if $i; ### allowable answers are now equal to the choices listed $args->{allow} = $args->{choices}; ### no choices, but a default? set 'prompt_add' to the default ### to construct a 'foo? [DEFAULT]' type prompt } elsif ( defined $args->{default} ) { if ($args->{multi} and ref($args->{default}) eq "ARRAY") { $prompt_add = join(" ", @{$args->{default}}); } else { $prompt_add = $args->{default}; } } ### we set up the defaults, prompts etc, dispatch to the readline call return $term->_tt_readline( %$args, prompt_add => $prompt_add ); } =head2 $bool = $term->ask_yn( prompt => "your question", [default => (y|1,n|0), print_me => "extra text to print & record"] ) Asks a simple C or C question to the user, returning a boolean indicating C or C to the caller. The C answer will automatically returned, if the user hits C or if C<$AUTOREPLY> is set to true. See the C section further below. Also, you have the option of adding a C argument, which is simply printed before the prompt. It's printed to the same file handle as the rest of the questions, so you can use this to keep track of a full session of Q&A with the user, and retrieve it later using the C<< Term::UI->history_as_string >> function. See the C section for samples of how to use this function. =cut sub ask_yn { my $term = shift; my %hash = @_; my $tmpl = { default => { default => undef, allow => [qw|0 1 y n|], strict_type => 1 }, prompt => { default => '', required => 1, strict_type => 1 }, print_me => { default => '', strict_type => 1 }, multi => { default => 0, no_override => 1 }, choices => { default => [qw|y n|], no_override => 1 }, allow => { default => [qr/^y(?:es)?$/i, qr/^n(?:o)?$/i], no_override => 1 }, }; my $args = check( $tmpl, \%hash, $VERBOSE ) or return undef; ### uppercase the default choice, if there is one, to be added ### to the prompt in a 'foo? [Y/n]' type style. my $prompt_add; { my @list = @{$args->{choices}}; if( defined $args->{default} ) { ### if you supplied the default as a boolean, rather than y/n ### transform it to a y/n now $args->{default} = $args->{default} =~ /\d/ ? { 0 => 'n', 1 => 'y' }->{ $args->{default} } : $args->{default}; @list = map { lc $args->{default} eq lc $_ ? uc $args->{default} : $_ } @list; } $prompt_add .= join("/", @list); } my $rv = $term->_tt_readline( %$args, prompt_add => $prompt_add ); return $rv =~ /^y/i ? 1 : 0; } sub _tt_readline { my $term = shift; my %hash = @_; local $Params::Check::VERBOSE = 0; # why is this? local $| = 1; # print ASAP my ($default, $preput, $prompt, $choices, $multi, $allow, $prompt_add, $print_me); my $tmpl = { default => { default => undef, strict_type => 0, store => \$default }, preput => { default => undef, strict_type => 0, store => \$preput}, prompt => { default => '', strict_type => 1, required => 1, store => \$prompt }, choices => { default => [], strict_type => 1, store => \$choices }, multi => { default => 0, allow => [0, 1], store => \$multi }, allow => { default => qr/.*/, store => \$allow, }, prompt_add => { default => '', store => \$prompt_add, strict_type => 1 }, print_me => { default => '', store => \$print_me }, }; check( $tmpl, \%hash, $VERBOSE ) or return; ### prompts for Term::ReadLine can't be longer than one line, or ### it can display wonky on some terminals. history( $print_me ) if $print_me; my $preput_is_supported = $term->ReadLine eq "Term::ReadLine::Gnu" ? 1 : undef; $preput = undef unless $preput_is_supported; ### If we are using Term::ReadLine:Gnu we can preput default value if (defined $preput and $preput eq '') { # if preput is the empty string we preput default $preput = $prompt_add; # We don't need to double information in the prompt in that case $prompt_add = undef; } if ($prompt_add) { ### we might have to add a default value to the prompt, to ### show the user what will be picked by default: $prompt .= " [$prompt_add]: " ; } else { $prompt .= " : "; } ### are we in autoreply mode? if ($AUTOREPLY) { ### you used autoreply, but didn't provide a default! carp loc( q[You have '%1' set to true, but did not provide a default!], '$AUTOREPLY' ) if( !defined $default && $VERBOSE); ### print it out for visual feedback if ($multi and defined($default)) { history( join ' ', grep { defined } $prompt, @$default ); ### and return the default return @$default; } else { history( join ' ', grep { defined } $prompt, $default ); ### and return the default return $default; } } if ($multi and defined($default)) { $default = join(' ', @$default); } ### so, no AUTOREPLY, let's see what the user will answer LOOP: { ### annoying bug in T::R::Perl that mucks up lines with a \n ### in them; So split by \n, save the last line as the prompt ### and just print the rest { my @lines = split "\n", $prompt; $prompt = pop @lines; history( "$_\n" ) for @lines; } ### pose the question my $answer = defined $preput ? $term->readline($prompt, $preput) : $term->readline($prompt); $answer = $default unless length $answer; $term->addhistory( $answer ) if length $answer; ### add both prompt and answer to the history history( defined $answer ? "$prompt $answer" : "$prompt", 0 ); ### if we're allowed to give multiple answers, split ### the answer on whitespace my @answers = grep defined, $multi ? split(/\s+/, $answer) : ( $answer ); ### the return value list my @rv; if( @$choices ) { for my $answer (@answers) { ### a digit implies a multiple choice question, ### a non-digit is an open answer if ( $answer =~ /\D/ || ( $answer =~ /^\d+$/ && @$choices < $answer ) ) { push @rv, $answer if allow( $answer, $allow ); } else { ### remember, the answer digits are +1 compared to ### the choices, because humans want to start counting ### at 1, not at 0 push @rv, $choices->[ $answer - 1 ] if $answer > 0 && defined $choices->[ $answer - 1 ]; } } ### no fixed list of choices.. just check if the answers ### (or otherwise the default!) pass the allow handler } else { push @rv, grep { allow( $_, $allow ) } @answers; } ### if not all the answers made it to the return value list, ### at least one of them was an invalid answer -- make the ### user do it again if( (@rv != @answers) or (scalar(@$choices) and not scalar(@answers)) ) { $prompt = $INVALID; $prompt .= "[$prompt_add] " if $prompt_add; redo LOOP; ### otherwise just return the answer, or answers, depending ### on the multi setting } else { return $multi ? @rv : $rv[0]; } } } =head2 ($opts, $munged) = $term->parse_options( STRING ); C will convert all options given from an input string to a hash reference. If called in list context it will also return the part of the input string that it found no options in. Consider this example: my $str = q[command --no-foo --baz --bar=0 --quux=bleh ] . q[--option="some'thing" -one-dash -single=blah' arg]; my ($options,$munged) = $term->parse_options($str); ### $options would contain: ### $options = { 'foo' => 0, 'bar' => 0, 'one-dash' => 1, 'baz' => 1, 'quux' => 'bleh', 'single' => 'blah\'', 'option' => 'some\'thing' }; ### and this is the munged version of the input string, ### ie what's left of the input minus the options $munged = 'command arg'; As you can see, you can either use a single or a double C<-> to indicate an option. If you prefix an option with C and do not give it a value, it will be set to 0. If it has no prefix and no value, it will be set to 1. Otherwise, it will be set to its value. Note also that it can deal fine with single/double quoting issues. =cut sub parse_options { my $term = shift; my $input = shift; my $return = {}; ### there's probably a more elegant way to do this... ### while ( $input =~ s/(?:^|\s+)--?([-\w]+=("|').+?\2)(?=\Z|\s+)// or $input =~ s/(?:^|\s+)--?([-\w]+=\S+)(?=\Z|\s+)// or $input =~ s/(?:^|\s+)--?([-\w]+)(?=\Z|\s+)// ) { my $match = $1; if( $match =~ /^([-\w]+)=("|')(.+?)\2$/ ) { $return->{$1} = $3; } elsif( $match =~ /^([-\w]+)=(\S+)$/ ) { $return->{$1} = $2; } elsif( $match =~ /^no-?([-\w]+)$/i ) { $return->{$1} = 0; } elsif ( $match =~ /^([-\w]+)$/ ) { $return->{$1} = 1; } else { carp(loc(q[I do not understand option "%1"\n], $match)) if $VERBOSE; } } return wantarray ? ($return,$input) : $return; } =head2 $str = $term->history_as_string Convenience wrapper around C<< Term::UI::History->history_as_string >>. Consult the C man page for details. =cut sub history_as_string { return Term::UI::History->history_as_string }; 1; =head1 GLOBAL VARIABLES The behaviour of Term::UI can be altered by changing the following global variables: =head2 $Term::UI::VERBOSE This controls whether Term::UI will issue warnings and explanations as to why certain things may have failed. If you set it to 0, Term::UI will not output any warnings. The default is 1; =head2 $Term::UI::AUTOREPLY This will make every question be answered by the default, and warn if there was no default provided. This is particularly useful if your program is run in non-interactive mode. The default is 0; =head2 $Term::UI::INVALID This holds the string that will be printed when the user makes an invalid choice. You can override this string from your program if you, for example, wish to do localization. The default is C =head2 $Term::UI::History::HISTORY_FH This is the filehandle all the print statements from this module are being sent to. Please consult the C manpage for details. This defaults to C<*STDOUT>. =head1 EXAMPLES =head2 Basic get_reply sample ### ask a user (with an open question) for their favourite colour $reply = $term->get_reply( prompt => 'Your favourite colour? ); which would look like: Your favourite colour? and C<$reply> would hold the text the user typed. =head2 get_reply with choices ### now provide a list of choices, so the user has to pick one $reply = $term->get_reply( prompt => 'Your favourite colour?', choices => [qw|red green blue|] ); which would look like: 1> red 2> green 3> blue Your favourite colour? C<$reply> will hold one of the choices presented. C will repose the question if the user attempts to enter an answer that's not in the list of choices. The string presented is held in the C<$Term::UI::INVALID> variable (see the C section for details. =head2 get_reply with choices and default ### provide a sensible default option -- everyone loves blue! $reply = $term->get_reply( prompt => 'Your favourite colour?', choices => [qw|red green blue|], default => 'blue' ); which would look like: 1> red 2> green 3> blue Your favourite colour? [3]: Note the default answer after the prompt. A user can now just hit C (or set C<$Term::UI::AUTOREPLY> -- see the C section) and the sensible answer 'blue' will be returned. =head2 get_reply using print_me & multi ### allow the user to pick more than one colour and add an ### introduction text @reply = $term->get_reply( print_me => 'Tell us what colours you like', prompt => 'Your favourite colours?', choices => [qw|red green blue|], multi => 1 ); which would look like: Tell us what colours you like 1> red 2> green 3> blue Your favourite colours? An answer of C<3 2 1> would fill C<@reply> with C =head2 get_reply & allow ### pose an open question, but do a custom verification on ### the answer, which will only exit the question loop, if ### the answer matches the allow handler. $reply = $term->get_reply( prompt => "What is the magic number?", allow => 42 ); Unless the user now enters C<42>, the question will be reposed over and over again. You can use more sophisticated C handlers (even subroutines can be used). The C handler is implemented using C's C function. Check its manpage for details. =head2 an elaborate ask_yn sample ### ask a user if he likes cookies. Default to a sensible 'yes' ### and inform him first what cookies are. $bool = $term->ask_yn( prompt => 'Do you like cookies?', default => 'y', print_me => 'Cookies are LOVELY!!!' ); would print: Cookies are LOVELY!!! Do you like cookies? [Y/n]: If a user then simply hits C, agreeing with the default, C<$bool> would be set to C. (Simply hitting 'y' would also return C. Hitting 'n' would return C) We could later retrieve this interaction by printing out the Q&A history as follows: print $term->history_as_string; which would then print: Cookies are LOVELY!!! Do you like cookies? [Y/n]: y There's a chance we're doing this non-interactively, because a console is missing, the user indicated he just wanted the defaults, etc. In this case, simply setting C<$Term::UI::AUTOREPLY> to true, will return from every question with the default answer set for the question. Do note that if C is true, and no default is set, C will warn about this and return C. =head1 See Also C, C, C =head1 BUG REPORTS Please report bugs or other issues to Ebug-term-ui@rt.cpan.org. =head1 AUTHOR This module by Jos Boumans Ekane@cpan.orgE. =head1 COPYRIGHT This library is free software; you may redistribute and/or modify it under the same terms as Perl itself. =cut Term-UI-0.50/lib/Term/UI/0000755000175000017500000000000014103264524014177 5ustar bingosbingosTerm-UI-0.50/lib/Term/UI/History.pm0000644000175000017500000000513514103264273016203 0ustar bingosbingospackage Term::UI::History; $Term::UI::History::VERSION = '0.50'; use strict; use warnings; use parent qw! Exporter Log::Message::Simple !; use Log::Message 'private' => 0; our $HISTORY_FH = \ *STDOUT; our @EXPORT = qw[ history ]; my $log = Log::Message->new(); =pod =head1 NAME Term::UI::History - history function =head1 SYNOPSIS use Term::UI::History qw[history]; history("Some message"); ### retrieve the history in printable form $hist = Term::UI::History->history_as_string; ### redirect output local $Term::UI::History::HISTORY_FH = \*STDERR; =head1 DESCRIPTION This module provides the C function for C, printing and saving all the C interaction. Refer to the C manpage for details on usage from C. This module subclasses C. Refer to its manpage for additional functionality available via this package. =head1 FUNCTIONS =head2 history("message string" [,VERBOSE]) Records a message on the stack, and prints it to C (or actually C<$HISTORY_FH>, see the C section below), if the C option is true. The C option defaults to true. =cut sub history { my $msg = shift; $log ->store( 'message' => $msg, 'tag' => 'HISTORY', 'level' => 'history', 'extra' => [ @_ ], ); } sub history_as_string { my $class = shift; return join $/, map { $_->message } __PACKAGE__->stack; } { package # hide this from PAUSE Log::Message::Handlers; sub history { my $self = shift; my $verbose = shift; $verbose = 1 unless defined $verbose; # default to true ### so you don't want us to print the msg? ### return if defined $verbose && $verbose == 0; local $| = 1; my $old_fh = select $Term::UI::History::HISTORY_FH; print $self->message . "\n"; select $old_fh; return; } } =head1 GLOBAL VARIABLES =over 4 =item $HISTORY_FH This is the filehandle all the messages sent to C are being printed. This defaults to C<*STDOUT>. =back =head1 See Also C, C =head1 AUTHOR This module by Jos Boumans Ekane@cpan.orgE. =head1 COPYRIGHT This module is copyright (c) 2005 Jos Boumans Ekane@cpan.orgE. All rights reserved. This library is free software; you may redistribute and/or modify it under the same terms as Perl itself. =cut 1; # Local variables: # c-indentation-style: bsd # c-basic-offset: 4 # indent-tabs-mode: nil # End: # vim: expandtab shiftwidth=4: Term-UI-0.50/README0000644000175000017500000000172412260755607013102 0ustar bingosbingosThis is the README file for Term::UI. Please refer to 'perldoc Term::UI' after installation for details. ##################################################################### * Description Term::UI provides methods to ask both elaborate questions as well as simple yes/no questions via a Term::ReadLine interface using a template. It can also parse options per unix style. ##################################################################### * Installation Term::UI follows the standard perl module install process perl Makefile.PL make make test make install The module uses no C or XS parts, so no c-compiler is required. ###################################################################### AUTHOR This module by Jos Boumans . COPYRIGHT This module is copyright (c) 2002 Jos Boumans . All rights reserved. This library is free software; you may redistribute and/or modify it under the same terms as Perl itself. Term-UI-0.50/META.yml0000664000175000017500000000136114103264524013461 0ustar bingosbingos--- abstract: 'User interfaces via Term::ReadLine made easy' author: - 'Jos Boumans ' build_requires: ExtUtils::MakeMaker: '0' configure_requires: ExtUtils::MakeMaker: '0' dynamic_config: 1 generated_by: 'ExtUtils::MakeMaker version 7.62, CPAN::Meta::Converter version 2.150010' license: perl meta-spec: url: http://module-build.sourceforge.net/META-spec-v1.4.html version: '1.4' name: Term-UI no_index: directory: - t - inc requires: Locale::Maketext::Simple: '0' Log::Message::Simple: '0' Params::Check: '0' Term::ReadLine: '0' Test::More: '0.31' if: '0' parent: '0' resources: repository: git://github.com/jib/term-ui.git version: '0.50' x_serialization_backend: 'CPAN::Meta::YAML version 0.018' Term-UI-0.50/Makefile.PL0000644000175000017500000000426314102303361014154 0ustar bingosbingosuse ExtUtils::MakeMaker; use strict; WriteMakefile1( LICENSE => 'perl', META_MERGE => { "meta-spec" => { version => 2 }, resources => { repository => { type => 'git', web => 'https://github.com/jib/term-ui', url => 'git://github.com/jib/term-ui.git', }, }, }, NAME => 'Term::UI', VERSION_FROM => 'lib/Term/UI.pm', # finds $VERSION dist => { COMPRESS => 'gzip -9f', SUFFIX => 'gz' }, PREREQ_PM => { 'if' => 0, 'parent' => 0, 'Test::More' => 0.31, 'Params::Check' => 0, 'Term::ReadLine' => 0, 'Locale::Maketext::Simple' => 0, 'Log::Message::Simple' => 0, }, INSTALLDIRS => ( $] >= 5.009005 && $] < 5.012 ? 'perl' : 'site' ), AUTHOR => 'Jos Boumans ', ABSTRACT => 'User interfaces via Term::ReadLine made easy' ); sub WriteMakefile1 { #Written by Alexandr Ciornii, version 0.21. Added by eumm-upgrade. my %params=@_; my $eumm_version=$ExtUtils::MakeMaker::VERSION; $eumm_version=eval $eumm_version; die "EXTRA_META is deprecated" if exists $params{EXTRA_META}; die "License not specified" if not exists $params{LICENSE}; if ($params{BUILD_REQUIRES} and $eumm_version < 6.5503) { #EUMM 6.5502 has problems with BUILD_REQUIRES $params{PREREQ_PM}={ %{$params{PREREQ_PM} || {}} , %{$params{BUILD_REQUIRES}} }; delete $params{BUILD_REQUIRES}; } delete $params{CONFIGURE_REQUIRES} if $eumm_version < 6.52; delete $params{MIN_PERL_VERSION} if $eumm_version < 6.48; delete $params{META_MERGE} if $eumm_version < 6.46; delete $params{META_ADD} if $eumm_version < 6.46; delete $params{LICENSE} if $eumm_version < 6.31; delete $params{AUTHOR} if $] < 5.005; delete $params{ABSTRACT_FROM} if $] < 5.005; delete $params{BINARY_LOCATION} if $] < 5.005; WriteMakefile(%params); }