Result:
found more than 817 distributions - search limited to the first 2001 files matching your query
( run in 1.883 )
App-DBBrowser
view release on metacpan or search on metacpan
lib/App/DBBrowser.pm view on Meta::CPAN
s_back => '<<',
ok => '-OK-',
menu_addition => '%%',
info_thsd_sep => ',',
};
$info->{tc_default} = { hide_cursor => 0, clear_screen => 1, page => 2, keep => 8, undef => $info->{s_back}, prompt => 'Your choice:' }; ##
$info->{tcu_default} = { hide_cursor => 0, clear_screen => 1, page => 2, keep => 8, confirm => $info->{ok}, back => $info->{s_back} };
$info->{tf_default} = { hide_cursor => 2, clear_screen => 1, page => 2, keep => 8, auto_up => 1, skip_items => qr/^\s*\z/ };
$info->{tr_default} = { hide_cursor => 2, clear_screen => 1, page => 2, history => [ 0 .. 1000 ] };
$info->{lyt_h} = { order => 0, alignment => 2 };
$info->{lyt_v} = { undef => $info->{_back}, layout => 2 };
lib/App/DBBrowser.pm view on Meta::CPAN
else {
my $menu_plugins = [ undef, map( "- $_", @$available_plugins ) ];
# Choose
my $idx_plugin = $tc->choose(
$menu_plugins,
{ %{$sf->{i}{lyt_v}}, prompt => 'DB Plugin: ', index => 1, default => $old_idx_plugin,
undef => $sf->{i}{_quit} }
);
if ( defined $idx_plugin ) {
$plugin = $menu_plugins->[$idx_plugin];
}
lib/App/DBBrowser.pm view on Meta::CPAN
$back = $skipped_menus ? $sf->{i}{_quit} : $sf->{i}{_back};
}
else {
$back = $skipped_menus ? $sf->{i}{quit} : $sf->{i}{back};
}
my $prompt = 'Choose Database:';
my $menu_db = [ undef, @databases ];
# Choose
my $idx_db = $tc->choose(
$menu_db,
{ %{$sf->{i}{lyt_v}}, prompt => $prompt, index => 1, default => $old_idx_db, undef => $back }
);
if ( defined $idx_db ) {
$db = $menu_db->[$idx_db];
}
if ( ! defined $db ) {
lib/App/DBBrowser.pm view on Meta::CPAN
$schema = ( @$user_schemas, @$sys_schemas )[0]; # to preserve unstringified `undef`
$skipped_menus++ if $skipped_menus == 2;
}
else {
my $back = $skipped_menus == 2 ? $sf->{i}{_quit} : $sf->{i}{_back};
my $prompt = $db_string . ':';
my $menu_schema = [ undef, @schemas ];
# Choose
my $idx_sch = $tc->choose(
$menu_schema,
{ %{$sf->{i}{lyt_v}}, prompt => $prompt, index => 1, default => $old_idx_sch, undef => $back }
);
if ( defined $idx_sch ) {
$schema = $menu_schema->[$idx_sch];
}
if ( ! defined $schema ) {
lib/App/DBBrowser.pm view on Meta::CPAN
push @$menu_table, $from_union if $sf->{o}{enable}{union};
my $back = $skipped_menus == 3 ? $sf->{i}{_quit} : $sf->{i}{_back};
# Choose
my $idx_tbl = $tc->choose(
$menu_table,
{ %{$sf->{i}{lyt_v}}, prompt => '', index => 1, default => $old_idx_tbl, undef => $back }
);
if ( defined $idx_tbl ) {
$table_key = $menu_table->[$idx_tbl];
}
if ( ! defined $table_key ) {
App-DWG-Sort
view release on metacpan or search on metacpan
inc/Module/Install/Makefile.pm view on Meta::CPAN
sub Makefile { $_[0] }
my %seen = ();
sub prompt {
shift;
# Infinite loop protection
my @c = caller();
if ( ++$seen{"$c[1]|$c[2]|$_[0]"} > 3 ) {
die "Caught an potential prompt infinite loop ($c[1]|$c[2]|$_[0])";
}
# In automated testing or non-interactive session, always use defaults
if ( ($ENV{AUTOMATED_TESTING} or -! -t STDIN) and ! $ENV{PERL_MM_USE_DEFAULT} ) {
local $ENV{PERL_MM_USE_DEFAULT} = 1;
goto &ExtUtils::MakeMaker::prompt;
} else {
goto &ExtUtils::MakeMaker::prompt;
}
}
# Store a cleaned up version of the MakeMaker version,
# since we need to behave differently in a variety of
App-Daemon
view release on metacpan or search on metacpan
# ... some code here
This will fork a child, terminate the parent and detach the child from
the terminal. Issued from the command line, the program above will
continue to run the code following the detach() call but return to the
shell prompt immediately.
=head1 AUTHOR
2008, Mike Schilli <cpan@perlmeister.com>
App-Dazz
view release on metacpan or search on metacpan
lib/App/Dazz/Command/overlap.pm view on Meta::CPAN
}
my $cmd;
$cmd
.= "HPC.daligner $basename -M16 -T$opt->{parallel} -e$opt->{idt} -l$opt->{len} -s$opt->{len} -mdust";
$cmd .= " | sed 's/ -vS / -S /'"; # don't show LAcheck prompts
$cmd .= " | bash";
App::Dazz::Common::exec_cmd( $cmd, { verbose => $opt->{verbose}, } );
if ( defined $block_number and $block_number > 1 ) {
$cmd = "LAcat $basename.\@.las > $basename.las";
App-Devel-MAT-Explorer-GTK
view release on metacpan or search on metacpan
lib/App/Devel/MAT/Explorer/GTK/Shell.pm view on Meta::CPAN
Devel::MAT->VERSION( '0.35' ); # Commandable::Invocation
# The perl bindings don't make this very easy
use constant PANGO_WEIGHT_BOLD => 700;
my ( $pmat, $buffer, $textview, $endmark, $scrolledwindow, $prompt );
my ( @styletags, $errortag, $svtag, $valuetag, $symboltag );
sub build_widget
{
my $class = shift;
lib/App/Devel/MAT/Explorer/GTK/Shell.pm view on Meta::CPAN
$endmark = $buffer->create_mark( 'end', $buffer->get_end_iter, FALSE );
$vbox->pack_start( my $hbox = Gtk2::HBox->new, FALSE, FALSE, 0 );
$prompt = Gtk2::Label->new( "pmat>" );
$hbox->pack_start( $prompt, FALSE, FALSE, 0 );
my $entry = Gtk2::Entry->new;
$hbox->pack_start( $entry, TRUE, TRUE, 0 );
lib/App/Devel/MAT/Explorer/GTK/Shell.pm view on Meta::CPAN
my $err = $@;
chomp $err;
append_output( "ERR: $err\n", $errortag );
};
$prompt->set_text( sprintf "pmat%s>", Devel::MAT::Tool::more->can_more ? " [more]" : "" );
}
my $linefeed_pending;
sub append_output
App-Diskd
view release on metacpan or search on metacpan
lib/App/Diskd.pm view on Meta::CPAN
# This function discards the SocketFactory object since its purpose
# has been fulfilled. It then creates two new objects: a ReadWrite
# wheel to talk with the socket, and a ReadLine wheel to talk with the
# console. POE::Wheel::ReadLine was named after Term::ReadLine, by
# the way. Once socket_connected() has set us up the wheels, it calls
# ReadLine's get() method to prompt the user for input.
sub socket_connected {
my ($heap, $socket) = @_[HEAP, ARG0];
delete $heap->{connect_wheel};
$heap->{io_wheel} = POE::Wheel::ReadWrite->new(
Handle => $socket,
App-DocKnot
view release on metacpan or search on metacpan
t/data/generate/pam-krb5/docknot.yaml view on Meta::CPAN
module with Solaris login (at least on Solaris 8 and 9), you will
probably also need to add `retain_after_close` to the PAM configuration
to avoid having the user's credentials deleted before they are logged
in.
The Solaris Kerberos library reportedly does not support prompting for a
password change of an expired account during authentication. Supporting
password change for expired accounts on Solaris with native Kerberos may
therefore require setting the `defer_pwchange` or `force_pwchange`
option for selected login applications. See the description and
warnings about that option in the pam_krb5(5) man page.
t/data/generate/pam-krb5/docknot.yaml view on Meta::CPAN
Some configuration options may be put in the `krb5.conf` file used by
your Kerberos libraries (usually `/etc/krb5.conf` or
`/usr/local/etc/krb5.conf`) instead or in addition to the PAM
configuration. See the man page for more details.
The Kerberos library, via pam-krb5, will prompt the user to change their
password if their password is expired, but when using OpenSSH, this will
only work when `ChallengeResponseAuthentication` is enabled. Unless
this option is enabled, OpenSSH doesn't pass PAM messages to the user
and can only respond to a simple password prompt.
If you are using MIT Kerberos, be aware that users whose passwords are
expired will not be prompted to change their password unless the KDC
configuration for your realm in `[realms]` in `krb5.conf` contains a
`master_kdc` setting or, if using DNS SRV records, you have a DNS entry
for `_kerberos-master` as well as `_kerberos`.
- title: Debugging
body: |
t/data/generate/pam-krb5/docknot.yaml view on Meta::CPAN
`pam_chauthtok` has to create a ticket cache. We however don't want it
to do this for the normal password change (`passwd`) case.
What we do is set a flag in our PAM data structure saying that we're
processing an expired password, and `pam_chauthtok`, if it sees that
flag, redoes the authentication with password prompting disabled after
it finishes changing the password.
Unfortunately, when handling password changes this way, `pam_chauthtok`
will always have to prompt the user for their current password again
even though they just typed it. This is because the saved
authentication tokens are cleared after `pam_authenticate` returns, for
security reasons. We could hack around this by saving the password in
our PAM data structure, but this would let the application gain access
to it (exactly what the clearing is intended to prevent) and breaks a
App-Dochazka-CLI
view release on metacpan or search on metacpan
config/CLI_Config.pm view on Meta::CPAN
# Main configuration file
# -----------------------------------
# DOCHAZKA_REST_LOGIN_NICK
# nick to use when we authenticate ourselves to the App::Dochazka::REST server
# when this is set to '' or undef, App::Dochazka::CLI will prompt for it
set( 'DOCHAZKA_REST_LOGIN_NICK', undef );
# DOCHAZKA_REST_LOGIN_NICK
# password to use when we authenticate ourselves to the App::Dochazka::REST server
# when this is set to '' or undef, App::Dochazka::CLI will prompt for a password
# WARNING: PUTTING YOUR PASSWORD HERE MAY BE CONVENIENT, BUT IS PROBABLY UNSAFE
set( 'DOCHAZKA_REST_LOGIN_PASSWORD', undef );
# MREST_CLI_COOKIE_JAR
# default location of the cookie jar
App-Dochazka-REST
view release on metacpan or search on metacpan
lib/App/Dochazka/REST.pm view on Meta::CPAN
In Dochazka, administrators are employees with special powers. Certain
REST/CLI functions are available only to administrators.
=item * B<CLI client> --
CLI stands for Command-Line Interface. The CLI client is the Perl script
that is run when an employee types C<dochazka> at the bash prompt.
=item * B<REST server> --
REST stands for ... . The REST server is a collection of Perl modules
running on a server at the site.
App-Donburi
view release on metacpan or search on metacpan
inc/Module/Install/Makefile.pm view on Meta::CPAN
sub Makefile { $_[0] }
my %seen = ();
sub prompt {
shift;
# Infinite loop protection
my @c = caller();
if ( ++$seen{"$c[1]|$c[2]|$_[0]"} > 3 ) {
die "Caught an potential prompt infinite loop ($c[1]|$c[2]|$_[0])";
}
# In automated testing or non-interactive session, always use defaults
if ( ($ENV{AUTOMATED_TESTING} or -! -t STDIN) and ! $ENV{PERL_MM_USE_DEFAULT} ) {
local $ENV{PERL_MM_USE_DEFAULT} = 1;
goto &ExtUtils::MakeMaker::prompt;
} else {
goto &ExtUtils::MakeMaker::prompt;
}
}
# Store a cleaned up version of the MakeMaker version,
# since we need to behave differently in a variety of
App-DrivePlayer
view release on metacpan or search on metacpan
```
google_restapi_oauth_token_creator
```
Follow the prompts. The token is stored at `~/.config/drive_player/token.dat` by default.
### 4. Add music folders
Open **File → Manage Folders** and add the Google Drive folder ID (the last
path component of the folder's Drive URL) and a display name.
App-DualLivedList
view release on metacpan or search on metacpan
inc/Module/Install/Makefile.pm view on Meta::CPAN
sub Makefile { $_[0] }
my %seen = ();
sub prompt {
shift;
# Infinite loop protection
my @c = caller();
if ( ++$seen{"$c[1]|$c[2]|$_[0]"} > 3 ) {
die "Caught an potential prompt infinite loop ($c[1]|$c[2]|$_[0])";
}
# In automated testing or non-interactive session, always use defaults
if ( ($ENV{AUTOMATED_TESTING} or -! -t STDIN) and ! $ENV{PERL_MM_USE_DEFAULT} ) {
local $ENV{PERL_MM_USE_DEFAULT} = 1;
goto &ExtUtils::MakeMaker::prompt;
} else {
goto &ExtUtils::MakeMaker::prompt;
}
}
# Store a cleaned up version of the MakeMaker version,
# since we need to behave differently in a variety of
App-DuckPAN
view release on metacpan or search on metacpan
lib/App/DuckPAN.pm view on Meta::CPAN
},
];
}
sub get_reply {
my ( $self, $prompt, %params ) = @_;
my $return = $self->term->get_reply( prompt => $prompt, %params );
Encode::_utf8_on($return);
return $return;
}
sub ask_yn {
my ( $self, $prompt, %params ) = @_;
return $self->term->ask_yn( prompt => $prompt, %params );
}
has http => (
is => 'ro',
builder => 1,
App-EUMM-Migrate
view release on metacpan or search on metacpan
eumm-migrate.pl view on Meta::CPAN
App::EUMM::Migrate
eumm-migrate is a tool to migrate from ExtUtils::MakeMaker to Module::Build.
It executes Makefile.PL with fake ExtUtils::MakeMaker and rewrites all parameters for
WriteMakefile into corresponding params of Module::Build->new. Calls to 'prompt' are also
intercepted and corresponding 'prompt' is written to Build.PL. All other info should be ported
manually.
Just run eumm-migrate.pl in directory with Makefile.PL. If you use Github, Internet connection
is recommended.
eumm-migrate.pl view on Meta::CPAN
package #hide from PAUSE
ExtUtils::MakeMaker;
our $VERSION=6.56;
use Exporter;
our @ISA=qw/Exporter/;
our @EXPORT=qw/prompt WriteMakefile/;
#our @EXPORT_OK=qw/prompt WriteMakefile/;
use Data::Dumper;
use File::Slurp;
use Perl::Meta;
my @prompts;
sub prompt ($;$) { ## no critic
my($mess, $def) = @_;
push @prompts,[$mess, $def];
}
#our $writefile_data;
sub WriteMakefile {
eumm-migrate.pl view on Meta::CPAN
}
}
$result{auto_configure_requires}=0;
open my $out,'>','Build.PL';
my $prompts_str='';
if (@prompts) {
$prompts_str.="die 'please write prompt handling code';\n";
foreach my $p (@prompts) {
my($mess, $def) = @$p;
$prompts_str.="Module::Build->prompt(q{$mess},q{$def});\n";
}
$prompts_str.="\n";
}
my $str;
{ local $Data::Dumper::Indent=1;local $Data::Dumper::Terse=1;
$str=Data::Dumper->Dump([\%result], []);
$str=~s/^\{[\x0A\x0D]+//s;
eumm-migrate.pl view on Meta::CPAN
use strict;
use Module::Build;
#created by eumm-migrate.pl
EOT
print $out $prompts_str;
print $out <<'EOT';
my $build = Module::Build->new(
EOT
print $out $str;
print $out <<'EOT';
App-EditorTools
view release on metacpan or search on metacpan
lib/App/EditorTools/Vim.pod view on Meta::CPAN
EditorToolsMenu - Brings up a menu to choose the following routines
=item ,pL
RenameVariable - Placing the cursor over a variable and pressing this
mapping will prompt for a new variable name, then rename all occurrences
of the varialbe within that lexical scope to the new name.
See L<App::EditorTools> for more.
=item ,pI
IntroduceTemporaryVariable - Selecting a range of text and pressing this
mapping will prompt for a new variable name, then add a new statement
declaring the variable and setting it the the highlighted expression, and
finally replace the currently highlighted text with a reference to the
variable.
See L<App::EditorTools> for more.
App-Egaz
view release on metacpan or search on metacpan
&& Rscript -e 'install.packages("ggplot2", repos="http://cran.rstudio.com")' \
&& Rscript -e 'install.packages("scales", repos="http://cran.rstudio.com")' \
&& Rscript -e 'install.packages("gridExtra", repos="http://cran.rstudio.com")' \
&& Rscript -e 'install.packages("readr", repos="http://cran.rstudio.com")' \
&& Rscript -e 'install.packages("ape", repos="http://cran.rstudio.com")' \
&& Rscript -e 'library(extrafont); font_import(prompt = FALSE); fonts();' \
&& rm -fr $(brew --cache)/*
WORKDIR /home/linuxbrew/App-Egaz
ADD . .
App-ElasticSearch-Utilities
view release on metacpan or search on metacpan
lib/App/ElasticSearch/Utilities.pm view on Meta::CPAN
: $ENV{USER};
# Prompt for the password
$auth{password} ||= defined $netrc ? $netrc->password
: (es_pass_exec($host,$auth{username},$meta{'password-exec'})
|| prompt(sprintf "Password for '%s' at '%s': ", $auth{username}, $host)
);
# Store
$_auth_cache{$host} = \%auth;
return @auth{qw(username password)};
lib/App/ElasticSearch/Utilities.pm view on Meta::CPAN
The username is selected by going through these mechanisms until one is found:
--http-username
'http-username' in /etc/es-utils.yml or ~/.es-utils.yml
Netrc element matching the hostname of the request
CLI::Helpers prompt()
Once the username has been resolved, the following mechanisms are tried in order:
Netrc element matching the hostname of the request
Password executable defined by --password-exec
'password-exec' in /etc/es-utils.yml, ~/.es-utils.yml
CLI::Helpers prompt()
=head2 Password Exec
It is B<BAD> practice to specify passwords as a command line argument, or store it in a plaintext
file. There are cases where this may be necessary, but it is not recommended. The best method for securing your
lib/App/ElasticSearch/Utilities.pm view on Meta::CPAN
http-username: bob
password-exec: /home/bob/bin/get-passwd.sh
=head3 CLI::Helpers and Password Prompting
If all the fails to yield a password, the last resort is to use CLI::Helpers::prompt() to ask the user for their
password. If the user is using version 1.1 or higher of CLI::Helpers, this call will turn off echo and readline magic
for the password prompt.
=head1 INDEX SELECTION ARGUMENTS
=over
App-Env-Login
view release on metacpan or search on metacpan
inc/Module/Install/Makefile.pm view on Meta::CPAN
sub Makefile { $_[0] }
my %seen = ();
sub prompt {
shift;
# Infinite loop protection
my @c = caller();
if ( ++$seen{"$c[1]|$c[2]|$_[0]"} > 3 ) {
die "Caught an potential prompt infinite loop ($c[1]|$c[2]|$_[0])";
}
# In automated testing or non-interactive session, always use defaults
if ( ($ENV{AUTOMATED_TESTING} or -! -t STDIN) and ! $ENV{PERL_MM_USE_DEFAULT} ) {
local $ENV{PERL_MM_USE_DEFAULT} = 1;
goto &ExtUtils::MakeMaker::prompt;
} else {
goto &ExtUtils::MakeMaker::prompt;
}
}
# Store a cleaned up version of the MakeMaker version,
# since we need to behave differently in a variety of
App-EvalServerAdvanced-REPL
view release on metacpan or search on metacpan
lib/App/EvalServerAdvanced/REPL.pm view on Meta::CPAN
our $VERSION = '0.004';
# ABSTRACT: Example client for App::EvalServerAdvanced
sub fake_prompt {
my $prompt = shift;
my @rl_term_set = @Term::ReadLine::TermCap::rl_term_set;
print $rl_term_set[3], $rl_term_set[0], $prompt, $rl_term_set[1], $rl_term_set[2];
}
sub start_repl {
my (@args) = @_;
lib/App/EvalServerAdvanced/REPL.pm view on Meta::CPAN
print "\n"; # go to a new line
my $eseq = $message->sequence;
if (!$message->{canceled}) {
my $lines = $message->get_contents;
print $rl_term_set[3], "$eseq < ", $lines, "\n\n";
fake_prompt("$seq> ");
} else {
print $rl_term_set[3],"\n$eseq was canceled\n";
fake_prompt("$seq> ");
}
} elsif (ref($message) =~ /Warning$/) {
my $eseq = $message->sequence;
my $warning = $message->message;
print $rl_term_set[3],"\nWARN <$eseq> ", $warning, "\n";
fake_prompt("$seq> ");
} else {
die "Unhandled message: ". Dumper($message);
}
}
App-EventStreamr
view release on metacpan or search on metacpan
lib/App/EventStreamr/Config.pm view on Meta::CPAN
method configure() {
say "Welcome to the EventStreamr config utility\n";
my $answer = $self->prompt(
"It will clear the current config, is this ok? y/n",
"n",
);
exit 1 if ($answer =~ /n/i);
lib/App/EventStreamr/Config.pm view on Meta::CPAN
} else {
say "Config failed to write";
}
# TODO: Stream Configuration
#$answer = undef;
#$answer = $self->prompt(
# "Stream - stream to configured service y/n: ",
# "y",
#);
#push(@{$self->{roles}}, "stream") if ($answer =~ /y/i);
}
method configure_mixer() {
my $answer = $self->prompt(
"Mixer - Video mixer interface y/n",
"y",
);
if ($answer =~ /y/i) {
lib/App/EventStreamr/Config.pm view on Meta::CPAN
$self->configure_recordpath();
}
}
method configure_ingest() {
my $answer = $self->prompt(
"Ingest - audio/video ingest y/n",
"y",
);
if ($answer =~ /y/i) {
lib/App/EventStreamr/Config.pm view on Meta::CPAN
$self->update_devices();
$self->devices([]);
foreach my $device (@{$self->{available_devices}{array}}) {
my $ingest = $self->prompt(
"Enable '".$device->{name}."' for ingest",
"y",
);
push(@{$self->devices}, $device) if ($ingest =~ /y/i);
}
lib/App/EventStreamr/Config.pm view on Meta::CPAN
}
method configure_remote_mixer() {
# TODO: Setting config like this is terrible,
# figure out how to do it better
my $answer = $self->prompt(
"host - switching host",
"127.0.0.1",
);
$self->{mixer}{host} = $answer ;
$answer = $self->prompt(
"port - switching port",
"1234",
);
$self->{mixer}{port} = $answer;
}
method configure_backend() {
my $answer = $self->prompt(
"backend - DVswitch|GSTswitch",
$self->backend,
);
if ($answer =~ /gst/i) {
$self->backend('GSTswitch');
lib/App/EventStreamr/Config.pm view on Meta::CPAN
}
method configure_recordpath() {
say '$room + $date can be used as variables in the path and';
say 'will correctly be set and created at run time';
my $answer = $self->prompt(
"recordpath - ",
'/tmp/$room/$date',
);
$self->record_path($answer);
}
method configure_room() {
my $answer = $self->prompt(
"Room - For record path and controller",
$self->room,
);
$self->room($answer);
}
method prompt($question,$default?) { # inspired from here: http://alvinalexander.com/perl/edu/articles/pl010005
if ($default) {
print $question, " [", $default, "]: ";
} else {
print $question, ": ";
$default = "";
App-FargateStack
view release on metacpan or search on metacpan
lib/App/FargateStack/Builder/Utils.pm view on Meta::CPAN
}
########################################################################
sub confirm {
########################################################################
my ( $prompt, @args ) = @_;
print sprintf "$prompt [y/N] ", @args;
chomp( my $answer = <STDIN> );
return $answer =~ /^y(es)?$/xsmi;
}
App-Fasops
view release on metacpan or search on metacpan
- Improve command refine following guides provided by Mario Roy.
0.4.5 2016-05-24 22:33:02 CST
- Better prompts
0.4.4 2016-05-24 08:36:40 CST
- Clean prompts
0.4.3 2016-05-21 19:47:58 CST
- Parallelize command refine
App-Fetchware
view release on metacpan or search on metacpan
lib/App/Fetchware.pm view on Meta::CPAN
download_lookup_url
get_mirrors
get_verification
get_filter_option
append_to_fetchwarefile
prompt_for_other_options
append_options_to_fetchwarefile
edit_manually
)],
OVERRIDE_NEW_INSTALL => [qw(
ask_to_install_now_to_test_fetchwarefile
lib/App/Fetchware.pm view on Meta::CPAN
###BUGALERT### Ask to parrallelize make with make_options???
###BUGALERT### Verify prefix is writable by current user, who will
#presumably be the user who will install the package now and later.
###BUGALERT### Ask user for a prefix if their running nonroot???
vmsg 'Prompting for other options that may be needed.';
my $other_options_hashref = prompt_for_other_options($term,
temp_dir => {
prompt => <<EOP,
What temp_dir configuration option would you like?
EOP
print_me => <<EOP
temp_dir is the directory where fetchware creates a temporary directory that
stores all of the temporary files it creates while it is building your software.
The default directory is /tmp on Unix systems and C:\\temp on Windows systems.
EOP
},
user => {
prompt => <<EOP,
What user configuration option would you like?
EOP
print_me => <<EOP
user specifies what user fetchware will drop priveleges to on Unix systems
capable of doing so. This allows fetchware to download files from the internet
lib/App/Fetchware.pm view on Meta::CPAN
thing that is run as root is 'make install' or whatever this package's
install_commands configuratio option is.
EOP
},
prefix => {
prompt => <<EOP,
What prefix configuration option would you like?
EOP
print_me => <<EOP
prefix specifies the base path that will be used to install this software. The
default is /usr/local, which is acceptable for most unix users. Please note that
this difective only works for software packages that use GNU AutoTools, software
that uses ./configure --prefix=<your prefix will go here> to change the prefix.
EOP
},
configure_options => {
prompt => <<EOP,
What configure_options configuration option would you like?
EOP
print_me => <<EOP
configure_options specifies what options fetchware should add when it configures
this software package for you. A list of possible options can be obtained by
lib/App/Fetchware.pm view on Meta::CPAN
AutoTools based software distributions, ones that use ./configure to configure
the software.
EOP
},
make_options => {
prompt => <<EOP,
What make_options configuration option would you like?
EOP
print_me => <<EOP
make_options specifies what options fetchware will pass to make when make is run
to compile, perhaps test, and install your software package. They are simpley
lib/App/Fetchware.pm view on Meta::CPAN
},
###BUGALERT### Create a config sub called build_system that takes args like
#AutoTools, cmake, MakeMaker, Module::Build, and so on that will use the default
#build commands of whatever system this option specifies.
build_commands => {
prompt => <<EOP,
What build_commands configuration option would you like?
EOP
print_me => <<EOP
build_commands specifies what commands fetchware will run to compile your
software package. Fetchware's default is simply 'make', which is good for most
lib/App/Fetchware.pm view on Meta::CPAN
single quotes with a comma between them:
'./configure', 'make'
EOP
},
install_commands => {
prompt => <<EOP,
What install_commands configuration option would you like?
EOP
print_me => <<EOP
install_commands specifies what commands fetchware will run to install your
software package. Fetchware's default is simply 'make install', which is good
lib/App/Fetchware.pm view on Meta::CPAN
build commands in single quotes with a comma between them:
'make test', 'make install'
EOP
},
uninstall_commands => {
prompt => <<EOP,
What uninstall_commands configuration option would you like?
EOP
print_me => <<EOP,
uninstall_commands specifes what commands fetchware will run to uninstall your
software pacakge. The default is 'make uninstall,' which works for some GNU
lib/App/Fetchware.pm view on Meta::CPAN
then please specify it using uninstall_commands so fetchware can uninstall it.
EOP
},
lookup_method => {
prompt => <<EOP,
What lookup_method configuration option would you like?
EOP
print_me => <<EOP
lookup_method specifies what how fetchware determines if a new version of your
software package is available. The available algorithms are 'timstamp' and
lib/App/Fetchware.pm view on Meta::CPAN
lowest, and then picks the highest version of your software package. The default
is try 'timestamp' and if that doesn't work, then try 'versionstring'.
EOP
},
gpg_keys_url => {
prompt => <<EOP,
What gpg_keys_url configuration option would you like?
EOP
print_me => <<EOP
gpg_keys_url specifies a url similar to lookup_url in that it should specify a
directory instead a specific file. It is used to download KEYS files, which
contain your program author's gpg keys to import into gpg.
EOP
},
gpg_sig_url => {
prompt => <<EOP,
What gpg_sig_url configuration option would you like?
EOP
print_me => <<EOP
gpg_sig_url specifies a url similar to lookup_url in that it should specify a
directory instead a specific file. It is used to download gpg signatures to
verify your software package.
EOP
},
sha1_url => {
prompt => <<EOP,
What sha1_url configuration option would you like?
EOP
print_me => <<EOP
sha1_url specifies a url similar to lookup_url in that it should specify a
directory instead of a specific file. It is separate from lookup_url, because
lib/App/Fetchware.pm view on Meta::CPAN
vendor's server, because checksums are easily replaced on a mirror by a hacker
if the mirror gets hacked.
EOP
},
md5_url => {
prompt => <<EOP,
What md5_url configuration option would you like?
EOP
print_me => <<EOP,
md5_url specifies a url similar to lookup_url in that it should specify a
directory instead of a specific file. It is separate from lookup_url, because
lib/App/Fetchware.pm view on Meta::CPAN
vendor's server, because checksums are easily replaced on a mirror by a hacker
if the mirror gets hacked.
EOP
},
verify_method => {
prompt => <<EOP,
What verify_method configuration option would you like?
EOP
print_me => <<EOP,
verify_method specifies what method of verification fetchware should use to
ensure the software you have downloaded has not been tampered with. The default
lib/App/Fetchware.pm view on Meta::CPAN
},
###BUGALERT### replace no_install config su with a command line option that
#would be the opposite of --force???
# Nah! Leave it! Just create a command line option for it too!
no_install => {
prompt => <<EOP,
Would you like to enable the no_install configuration option?
EOP
###BUGALERT### no_install is not currently implemented properly!!!
print_me => <<EOP
no_install is a true or false option, whoose acceptable values include 1
lib/App/Fetchware.pm view on Meta::CPAN
EOP
###BUGALERT### Add support for a check regex, so that I can ensure
#that what the user enters will be either true or false!!!
},
verify_failure_ok => {
prompt => <<EOP,
Would you like to enable the verify_failure_ok configuration option?
EOP
print_me => <<EOP
verify_failure_ok is a true or false option, whoose acceptable values include 1
or 0, true or falue, On or Off. It's default value is false, but if you enable
lib/App/Fetchware.pm view on Meta::CPAN
option, because it makes it possible for fetchware to install source code that
may have been tampered with.
EOP
},
users_keyring => {
prompt => <<EOP,
Would you like to enable users_keyring configuration option?
EOP
print_me => <<EOP
users_keyring when enabled causes fetchware to use the user who calls
fetchware's gpg keyring instead of fetchware's own gpg keyring. Useful for
lib/App/Fetchware.pm view on Meta::CPAN
specified is [$fetchwarefile_name]. Please specify this option, and try again.
EOD
if (not defined $fetchwarefile_name_value) {
$fetchwarefile_name_value = $term->get_reply(
prompt => q{What would you like to name this specific Fetchwarefile? },
print_me => $what_a_fetchwarefile_name_is,
# This option requires a name, so just pressing return, which would
# yield undef is not acceptable. We need an actual value, so check
# the value to ensure that it is defined.
allow => sub { defined shift @_ ? return 1 : return 0 }
lib/App/Fetchware.pm view on Meta::CPAN
sub get_lookup_url {
my $term = shift;
# prompt for lookup_url.
my $lookup_url = $term->get_reply(
print_me => <<EOP,
Fetchware's heart and soul is its lookup_url. This is the configuration option
that tells fetchware where to check what the latest version of your program is.
This version number is then parsed out of the HTTP/FTP/local directory listing,
lib/App/Fetchware.pm view on Meta::CPAN
* ftp://a.url/downloads/program.tar.gz -> ftp://a.url/downloads/
5. Press enter to access the directory listing on your Application's mirror
site.
6. If the directory listing in either FTP or HTTP format is displayed in
your browser, then Fetchware's default, built-in lookup fuctionality will
probably work properly. Copy and paste this URL into the prompt below, and
Fetchware will download and analyze your lookup_url to see if it will work
properly. If you do not end up with a browser directory listing, then
please see Fetchware's documentation using perldoc App::Fetchware.
EOP
prompt => q{What is your application's lookup_url? },
allow => qr!(ftp|http|file)://!);
return $lookup_url;
}
lib/App/Fetchware.pm view on Meta::CPAN
The mirror should be a URL in standard browser format such as [ftp://a.mirror/].
FTP, HTTP, and local file:// mirrors are supported. All other formats are not
supported.
EOP
prompt => 'Please enter the URL of your mirror: ',
allow => qr!^(ftp|http|file)://!,
);
# Append mirror to $fetchwarefile.
push @mirrors, $mirror;
lib/App/Fetchware.pm view on Meta::CPAN
In addition to the one required mirror that you must define in order for
fetchware to function properly, you may specify additonal mirros that fetchware
will use if the mirror you've already specified is unreachable or download
attempts using that mirror fail.
EOP
prompt => 'Would you like to add any additional mirrors? ',
default => 'n',
)
) {
# Prompt for first mirror outside loop, because if you just hit enter or
# type done, then the above text will be appended to your fetchwarefile,
# but you'll be able to skip actually adding a mirror.
my $first_mirror = $term->get_reply(
prompt => 'Type in URL of mirror or done to continue: ',
allow => qr!^(ftp|http|file)://!,
);
# Append $first_mirror to $fetchwarefile.
push @mirrors, $first_mirror;
while (1) {
my $mirror_or_done = $term->get_reply(
prompt => 'Type in URL of mirror or done to continue: ',
default => 'done',
allow => qr!(^(ftp|http|file)://)|done!,
);
if ($mirror_or_done eq 'done') {
last;
lib/App/Fetchware.pm view on Meta::CPAN
EOM
# Since autoconfiguration of KEYS failed, try asking the user if
# they would like to import the author's key themselves into their
# own keyring and have fetchware use that.
if (
$term->ask_yn(prompt =>
q{Would you like to import the author's key yourself after fetchware completes? },
default => 'n',
print_me => <<EOP,
Automatic KEYS file discovery failed. Fetchware needs the author's keys to
download and import into its own keyring, or you may specify the option
lib/App/Fetchware.pm view on Meta::CPAN
# would be detected and prevented with proper verification enabled.
# Ask user if they would like to continue installing fetchware even if
# verification fails, and then enable the verify_failure_ok option.
if (
$term->ask_yn(prompt => <<EOP,
Would you like fetchware to ignore the fact that it is unable to verify the
authenticity of any downloads it makes? Are you ok with possibly downloading
viruses, worms, rootkits, or any other malware, and installing it possibly even
as root?
EOP
lib/App/Fetchware.pm view on Meta::CPAN
msg <<EOS;
* The lookup_url you gave fetchware includes a CURRENT_IS or a LATEST_IS file
that tells fetchware and regular users what the latest version is. Because of
this we can be reasonable sure that a filter option is not needed, so I'll skip
asking for one. You can provide one later if you need to provide one, when
fetchware prompts you for any custom options you may want to use.
EOS
} else {
# There is a CURRENT_IS_<ver_num> or LATEST_IS_<ver_num> file that tells
# you what the latest version is.
###BUGALERT### Why is this line in both sections of the if statement??? Inside
lib/App/Fetchware.pm view on Meta::CPAN
filter option, but that should only be needed for advanced users. See perldoc
fetchware.
EOA
# Prompt for the needed filter option.
$filter = $term->get_reply(
prompt => <<EOP,
[Just press enter or return to skip adding a filter option]
What does fetchware need your filter option to be?
EOP
print_me => $what_a_filter_is,
);
lib/App/Fetchware.pm view on Meta::CPAN
return {filter => $filter};
}
sub prompt_for_other_options {
my $term = shift;
my %option_description = @_;
my %answered_option;
if (
$term->ask_yn(prompt =>
q{Would you like to add extra configuration options to your fetchwarefile?},
default => 'n',
print_me => <<EOP,
Fetchware has many different configuration options that allow you to control its
behavior, and even change its behavior if needed to customize fetchware for any
lib/App/Fetchware.pm view on Meta::CPAN
my @options = keys %option_description;
my @config_file_options_to_provide = $term->get_reply(
print_me => <<EOP,
Below is a listing of Fetchware's available configuration options.
EOP
prompt => <<EOP,
Please answer with a space seperated list of the number before the configuration
file options that you would like to add to your configuration file?
EOP
choices => \@options,
multi => 1,
lib/App/Fetchware.pm view on Meta::CPAN
for my $config_file_option (@config_file_options_to_provide) {
$answered_option{$config_file_option} = $term->get_reply(
print_me => $option_description{$config_file_option}->{print_me},
prompt => $option_description{$config_file_option}->{prompt},
);
}
}
return \%answered_option;
}
lib/App/Fetchware.pm view on Meta::CPAN
If you would like to cancel any edits you have made, and use the automagically
generated Fetchwarefile, just delete the entire contents of the file, and save
an empty file.
EOP
prompt => q{Would you like to edit your automagically generated Fetchwarefile manually? },
default => 'n',
)
) {
my ($fh, $fetchwarefile_filename) =
tempfile('Fetchwarefile-XXXXXXXXX', TMPDIR => 1);
lib/App/Fetchware.pm view on Meta::CPAN
close $fh;
# Ask what editor to use if EDITOR environment variable is not set.
my $editor = $ENV{EDITOR} || do {
$term->get_reply(prompt => <<EOP,
What text editor would you like to use?
EOP
print_me => <<EOP
The Environment variable EDITOR is not set. This is used by fetchware and other
programs to determine what program fetchware should use to edit your
lib/App/Fetchware.pm view on Meta::CPAN
It is recommended that fetchware go ahead and install the package based on the
Fetchwarefile that fetchware has created for you. If you don't want to install
it now, then enter 'no', but if you want to test your Fetchwarefile now, and
install it, then please enter 'yes' or just press <Enter>.
EOP
prompt => q{Would you like to install the package you just created a Fetchwarefile for? },
default => 'y',
)
) {
# Create a temp Fetchwarefile to store the autogenerated configuration.
lib/App/Fetchware.pm view on Meta::CPAN
# Get a name for the Fetchwarefile that does not already exist.
if (-e $fetchwarefile_filename) {
while (1) {
$fetchwarefile_filename = $term->get_reply(
prompt => <<EOP,
What would you like your new Fetchwarefile's filename to be?
EOP
print_me => <<EOP
Fetchware by default uses the program name you specified at the beginning of
running fetchware new plus a '.Fetchwarefile' extension to name your
lib/App/Fetchware.pm view on Meta::CPAN
=item L<new()'s OVERRIDE_NEW export tag.|new() API REFERENCE>
The export tag exports all of the helper subroutines new() uses to implement its
functionality. Some like get_lookup_url(), get_verification(), and
get_filter_option() are quite specific to App::Fetchware, but extension_name,
fetchwarefile_name(), opening_message(), prompt_for_other_options(), and
edit_manually() are nice and generic, and should be appropriate for any
Fetchware extension.
=item L<new_install()'s OVERRIDE_NEW_INSTALL export tag.|new_install() API REFERENCE>
lib/App/Fetchware.pm view on Meta::CPAN
If a filter was provided by the user than it is returned as a hashref with
C<filter> as the key for use with append_options_to_fetchwarefile(), or for
further analysis by extension authors.
=head3 prompt_for_other_options()
prompt_for_other_options($term,
temp_dir => {
prompt => <<EOP,
What temp_dir configuration option would you like?
EOP
print_me => <<EOP
temp_dir is the directory where fetchware creates a temporary directory that
stores all of the temporary files it creates while it is building your software.
lib/App/Fetchware.pm view on Meta::CPAN
...
);
Accepts a Term::Readline/Term::UI object as an argument to use to ask the user
questions, and a gigantic hash of hashes in list form. The hash of hashes,
%option_description, argument incluedes the C<prompt> and C<print_me> options
that are then passed through to Term::UI to ask the user what argument they want
for each specified option in the %option_description hash.
The user's answers are tallied up an returned as a hash reference.
App-FileDedup
view release on metacpan or search on metacpan
lib/App/FileDedup.pm view on Meta::CPAN
is => 'ro',
isa => Bool,
default => 0,
cmd_aliases => [qw(n)],
cmd_flag => 'dont-ask',
documentation => 'Purge files without an interactive prompt; off by default',
);
option 'group' => (
is => 'ro',
isa => Bool,
App-FilterUtils
view release on metacpan or search on metacpan
[MinimumPerlFast]
[Test::Version]
[GitHub::Create]
prompt = 1
org = athreef
[Test::NoTabs]
[Test::EOL]
App-Followme
view release on metacpan or search on metacpan
lib/App/Followme/UploadFtp.pm view on Meta::CPAN
=back
=head1 CONFIGURATION
The follow parameters are used from the configuration. In addition, the package
will prompt for and save the user name and password.
=over 4
=item ftp_debug
App-ForExample
view release on metacpan or search on metacpan
inc/Module/AutoInstall.pm view on Meta::CPAN
$AllDeps = 1;
}
}
}
# overrides MakeMaker's prompt() to automatically accept the default choice
sub _prompt {
goto &ExtUtils::MakeMaker::prompt unless $AcceptDefault;
my ( $prompt, $default ) = @_;
my $y = ( $default =~ /^[Yy]/ );
print $prompt, ' [', ( $y ? 'Y' : 'y' ), '/', ( $y ? 'n' : 'N' ), '] ';
print "$default\n";
return $default;
}
# the workhorse
inc/Module/AutoInstall.pm view on Meta::CPAN
map { +{@args}->{$_} }
grep { /^[^\-]/ or /^-core$/i } keys %{ +{@args} }
)[0]
);
# We want to know if we're under CPAN early to avoid prompting, but
# if we aren't going to try and install anything anyway then skip the
# check entirely since we don't want to have to load (and configure)
# an old CPAN just for a cosmetic message
$UnderCPAN = _check_lock(1) unless $SkipInstall;
inc/Module/AutoInstall.pm view on Meta::CPAN
!$SkipInstall
and (
$CheckOnly
or ($mandatory and $UnderCPAN)
or $AllDeps
or _prompt(
qq{==> Auto-install the }
. ( @required / 2 )
. ( $mandatory ? ' mandatory' : ' optional' )
. qq{ module(s) from CPAN?},
$default ? 'y' : 'n',
inc/Module/AutoInstall.pm view on Meta::CPAN
elsif ( !$SkipInstall
and $default
and $mandatory
and
_prompt( qq{==> The module(s) are mandatory! Really skip?}, 'n', )
=~ /^[Nn]/ )
{
push( @Missing, @required );
$DisabledTests{$_} = 1 for map { glob($_) } @skiptests;
}
inc/Module/AutoInstall.pm view on Meta::CPAN
return
if defined( _version_check( _load($class), $ver ) ); # no need to upgrade
if (
_prompt( "==> A newer version of $class ($ver) is required. Install?",
'y' ) =~ /^[Nn]/
)
{
die "*** Please install $class $ver manually.\n";
}
inc/Module/AutoInstall.pm view on Meta::CPAN
# check if we're connected to some host, using inet_aton
sub _connected_to {
my $site = shift;
return (
( _load('Socket') and Socket::inet_aton($site) ) or _prompt(
qq(
*** Your host cannot resolve the domain name '$site', which
probably means the Internet connections are unavailable.
==> Should we try to install the required module(s) anyway?), 'n'
) =~ /^[Yy]/
inc/Module/AutoInstall.pm view on Meta::CPAN
*** You are not allowed to write to the directory '$path';
the installation may fail due to insufficient permissions.
.
if (
eval '$>' and lc(`sudo -V`) =~ /version/ and _prompt(
qq(
==> Should we try to re-execute the autoinstall process with 'sudo'?),
((-t STDIN) ? 'y' : 'n')
) =~ /^[Yy]/
)
inc/Module/AutoInstall.pm view on Meta::CPAN
print << ".";
*** The 'sudo' command exited with error! Resuming...
.
}
return _prompt(
qq(
==> Should we try to install the required module(s) anyway?), 'n'
) =~ /^[Yy]/;
}
App-Fotagger
view release on metacpan or search on metacpan
Makefile.PL view on Meta::CPAN
unless (eval "use Module::Build::Compat 0.02; 1" ) {
print "This module requires Module::Build to install itself.\n";
require ExtUtils::MakeMaker;
my $yn = ExtUtils::MakeMaker::prompt
(' Install Module::Build now from CPAN?', 'y');
unless ($yn =~ /^y/i) {
die " *** Cannot install without Module::Build. Exiting ...\n";
}
App-Framework-Lite
view release on metacpan or search on metacpan
inc/Module/Install/Makefile.pm view on Meta::CPAN
sub Makefile { $_[0] }
my %seen = ();
sub prompt {
shift;
# Infinite loop protection
my @c = caller();
if ( ++$seen{"$c[1]|$c[2]|$_[0]"} > 3 ) {
die "Caught an potential prompt infinite loop ($c[1]|$c[2]|$_[0])";
}
# In automated testing or non-interactive session, always use defaults
if ( ($ENV{AUTOMATED_TESTING} or -! -t STDIN) and ! $ENV{PERL_MM_USE_DEFAULT} ) {
local $ENV{PERL_MM_USE_DEFAULT} = 1;
goto &ExtUtils::MakeMaker::prompt;
} else {
goto &ExtUtils::MakeMaker::prompt;
}
}
# Store a cleaned up version of the MakeMaker version,
# since we need to behave differently in a variety of
App-Framework
view release on metacpan or search on metacpan
inc/Module/Install/Makefile.pm view on Meta::CPAN
sub Makefile { $_[0] }
my %seen = ();
sub prompt {
shift;
# Infinite loop protection
my @c = caller();
if ( ++$seen{"$c[1]|$c[2]|$_[0]"} > 3 ) {
die "Caught an potential prompt infinite loop ($c[1]|$c[2]|$_[0])";
}
# In automated testing or non-interactive session, always use defaults
if ( ($ENV{AUTOMATED_TESTING} or -! -t STDIN) and ! $ENV{PERL_MM_USE_DEFAULT} ) {
local $ENV{PERL_MM_USE_DEFAULT} = 1;
goto &ExtUtils::MakeMaker::prompt;
} else {
goto &ExtUtils::MakeMaker::prompt;
}
}
# Store a cleaned up version of the MakeMaker version,
# since we need to behave differently in a variety of
( run in 1.883 second using v1.01-cache-2.11-cpan-6aa56a78535 )