view release on metacpan or  search on metacpan

lib/Module/Starter/TOSHIOITO.pm  view on Meta::CPAN

sub _ensure_dir {
    my ($self, @dirpaths) = @_;
    my $dir = File::Spec->catdir($self->{basedir}, @dirpaths);
    if (not -d $dir) {
        local @ARGV = $dir;
        mkpath();
        $self->progress("Created $dir");
    }
}

 view release on metacpan or  search on metacpan

lib/Modulino/Demo.pm  view on Meta::CPAN

sub doc {
	say "Running as docs";

	my $data = do {
		local( @ARGV, $/ ) = __FILE__;
		<>;
		};

	my $package = __PACKAGE__;
	$data =~ s/__PACKAGE__/$package/;

 view release on metacpan or  search on metacpan

t/01-use.t  view on Meta::CPAN

use MogileFS::Server;
use MogileFS::Config;

{
    local @ARGV = qw/--skipconfig --plugins MultiHook/;

    eval {
        MogileFS::Config->load_config;
    };
    ok(!$@);

 view release on metacpan or  search on metacpan

ppport.h  view on Meta::CPAN

  $rv;
}

sub usage
{
  my($usage) = do { local(@ARGV,$/)=($0); <> } =~ /^=head\d$HS+SYNOPSIS\s*^(.*?)\s*^=/ms;
  my %M = ( 'I' => '*' );
  $usage =~ s/^\s*perl\s+\S+/$^X $0/;
  $usage =~ s/([A-Z])<([^>]+)>/$M{$1}$2$M{$1}/g;

  print <<ENDUSAGE;

 view release on metacpan or  search on metacpan

lib/Mojo/Weixin/Plugin/Perldoc.pm  view on Meta::CPAN

            $msg->allow_plugin(0);
            return if $msg->from eq "bot";
            my($p,$v) = ("-$1",$2);
            $client->spawn(
                cmd  =>sub{
                    local @ARGV=($p,$v);
                    require 5;
                    exit(Pod::Perldoc->run());
                },
                exec_timeout => 5,
                exit_cb => sub {

 view release on metacpan or  search on metacpan

lib/Mojolicious/Command/generate/lexicon.pm  view on Meta::CPAN

    $language ||= 'Skeleton';

    my $behavior = '';

    local @ARGV = @_ if @_;

    my $result = GetOptions(
        "behavior|b:s{1,1}" => \$behavior,
        'verbose|v:1'       => \$verbose,
    );

 view release on metacpan or  search on metacpan

lib/Mojolicious/Command/nopaste/Service.pm  view on Meta::CPAN

  my ($self, @files) = @_;
  @files = @{ $self->files } unless @files;

  my $content = do {
    local $/;
    local @ARGV = @files;
    decode 'UTF-8', <>;
  };

  # Remove trailing newline as some sites won't do it for us
  chomp $content;

 view release on metacpan or  search on metacpan

t/basic.t  view on Meta::CPAN

ok eval "require Mojolicious::Command::static; 1", "load Mojolicious::Command::static";

# Make sure @ARGV is not changed
{
  local $ENV{MOJO_MODE};
  local @ARGV = qw(-m production -x whatever);
  require Mojolicious::Commands;
}

my $t = Test::Mojo->new;
my $commands = Mojolicious::Commands->new;

 view release on metacpan or  search on metacpan

lib/Mojolicious/Plugin/AssetPack/Pipe/ElmLang.pm  view on Meta::CPAN

            
            push @args , $file->path->to_string;

            $self->run(\@args, undef, undef);

            my $js = do { local(@ARGV, $/) = $tmp; <> };

            $asset->content($store->save(\$js, $attrs))->FROM_JSON($attrs);
        }
    );
}

 view release on metacpan or  search on metacpan

lib/iniweb.pm  view on Meta::CPAN

sub import {
	$ENV{PERL_MINIWEB_ROOT}       //= '.';
	$ENV{PERL_MINIWEB_DIR_INDEX}  //= 'index.html:index.htm';

	local @ARGV = 'daemon';
	my %opts = (
		root       => $ENV{PERL_MINIWEB_ROOT},
		dir_index  => [ split ':', $ENV{PERL_MINIWEB_DIR_INDEX} ],
	);
	a->plugin( DirectoryServer => %opts )->start;

 view release on metacpan or  search on metacpan

xt/compat/commands.t  view on Meta::CPAN

use File::Temp 'tempdir';

# Make sure @ARGV is not changed
{
  local $ENV{MOJO_MODE};
  local @ARGV = qw(-m production -x whatever);
  require Mojolicious::Commands;
  is $ENV{MOJO_MODE}, 'production', 'right mode';
  is_deeply \@ARGV, [qw(-m production -x whatever)], 'unchanged';
}

 view release on metacpan or  search on metacpan

t/mojo/util.t  view on Meta::CPAN

  getopt $array, 'h' => \my $flag, 'w|whatever=s' => \my $whatever;
  ok $flag, 'flag has been set';
  is $whatever, 'Whatever!', 'right string';
  is_deeply $array, ['stuff'], 'right structure';
  {
    local @ARGV = ('--charset', 'UTF-16', 'test');
    getopt 'c|charset=s' => \my @charset;
    is_deeply \@charset, ['UTF-16'], 'right structure';
    is_deeply \@ARGV,    ['test'],   'right structure';
  }
};

 view release on metacpan or  search on metacpan

ppport.h  view on Meta::CPAN

  $rv;
}

sub usage
{
  my($usage) = do { local(@ARGV,$/)=($0); <> } =~ /^=head\d$HS+SYNOPSIS\s*^(.*?)\s*^=/ms;
  my %M = ( 'I' => '*' );
  $usage =~ s/^\s*perl\s+\S+/$^X $0/;
  $usage =~ s/([A-Z])<([^>]+)>/$M{$1}$2$M{$1}/g;

  print <<ENDUSAGE;

 view release on metacpan or  search on metacpan

lib/MooX/Cmd/Tester.pm  view on Meta::CPAN

    my ($stdout, $stderr, $merged, $ok) = _capture_merged
    {
        eval {
            local $TEST_IN_PROGRESS = 1;
            local @ARGV             = @$argv;

            my $tb = $CLASS->builder();

            $cmd = ref $app ? $app : $app->new_with_cmd;
            ref $app and $app = ref $app;

 view release on metacpan or  search on metacpan

t/testmxopt.pm  view on Meta::CPAN

my @cfg_files = map { ("--config-files", File::Spec->catfile($cwd, qw(calc etc), $_)) }
  qw(operands.json small-operands.json large-operands.json);

SCOPE:
{
    local @ARGV = qw(--config-prefix calc-operands);
    my $adder = oCalc::add->new_with_options;
    ok(defined($adder->a), "read \"a\" from add config");
    ok(defined($adder->b), "read \"b\" from add config");
    cmp_ok($adder->execute, "==", 5, "read right adder config");
    ok(Moo::Role::does_role($adder, "MooX::ConfigFromFile::Role"), "Applying MooX::ConfigFromFile::Role to oCalc::add");
}

SCOPE:
{
    local @ARGV = qw(--config-prefix operands);
    my $subber = oCalc::sub->new_with_options;
    ok(defined($subber->a), "read \"a\" from sub config");
    ok(defined($subber->b), "read \"b\" from sub config");
    cmp_ok($subber->execute, "==", 17, "read right subber config");
    ok(Moo::Role::does_role($subber, "MooX::ConfigFromFile::Role"), "Applying MooX::ConfigFromFile::Role to oCalc::sub");
}

SCOPE:
{
    local @ARGV = @cfg_files[0 .. 1];
    my $mul = oCalc::mul->new_with_options;
    is($mul->a, 21,, "read \"a\" from mul config");
    is($mul->b, 4,   "read \"b\" from mul config");
    cmp_ok($mul->execute, "==", 84, "read right mul config");
}

SCOPE:
{
    local @ARGV = @cfg_files[2 .. 3];
    my $mul = oCalc::mul->new_with_options;
    is($mul->a, 21,, "keep \"a\" from first mul config");
    is($mul->b, 4,   "keep \"b\" from first mul config");
    cmp_ok($mul->execute, "==", 84, "read right mul config");
}

SCOPE:
{
    local @ARGV = @cfg_files[2 .. 3];
    my $div = oCalc::div->new_with_options;
    is($div->a, 30,, "read \"a\" from small div config");
    is($div->b, 6,   "read \"b\" from small div config");
    cmp_ok($div->execute, "==", 5, "read right div config");
}

SCOPE:
{
    local @ARGV = @cfg_files[4 .. 5];
    my $div = oCalc::div->new_with_options;
    is($div->a, 666,, "read \"a\" from large div config");
    is($div->b, 222,  "read \"b\" from large div config");
    cmp_ok($div->execute, "==", 3, "read right div config");
}

 view release on metacpan or  search on metacpan

t/basic.t  view on Meta::CPAN

}

my $options_argv;

{
  local @ARGV;
  @ARGV = ( qw/
    --opt
    test_string
    / );
  $options_argv = My::Test::Class->new_with_options;

 view release on metacpan or  search on metacpan

lib/MooX/Options/Role.pm  view on Meta::CPAN

    }

    my ( $options, $has_to_split, $all_options )
        = _options_prepare_descriptive( \%options_data );

    local @ARGV = @ARGV if $options_config{protect_argv};
    @ARGV = _options_fix_argv( \%options_data, $has_to_split, $all_options );

    my @flavour;
    if ( defined $options_config{flavour} ) {
        push @flavour, { getopt_conf => $options_config{flavour} };

 view release on metacpan or  search on metacpan

t/30-create_crypted_password.t  view on Meta::CPAN

my $secret_file = catfile($tmp_dir, 'password.private');

note('Create crypted file');
{
    local $ENV{PERL5LIB} = 'lib';
    local @ARGV = (
        '--file-name'  => $secret_file,
        '--cipher-key' => $cipher_key,
        '--password'   => $secret,
    );
    do "bin/create_crypted_password";

 view release on metacpan or  search on metacpan

ppport.h  view on Meta::CPAN

  $rv || 0;
}

sub usage
{
  my($usage) = do { local(@ARGV,$/)=($0); <> } =~ /^=head\d$HS+SYNOPSIS\s*^(.*?)\s*^=/ms;
  my %M = ( 'I' => '*' );
  $usage =~ s/^\s*perl\s+\S+/$^X $0/;
  $usage =~ s/([A-Z])<([^>]+)>/$M{$1}$2$M{$1}/g;

  print <<ENDUSAGE;

 view release on metacpan or  search on metacpan

lib/MooseX/App/ParsedArgv.pm  view on Meta::CPAN

 my $option = $self->consume($type);
 OR
 my $option = $self->consume();

Returns the first option/parameter of the local @ARGV that has not yet been
consumed as a L<MooseX::App::ParsedArgv::Element> object.

=head2 elements

Returns all parsed options and parameters.

 view release on metacpan or  search on metacpan

inc/Perl/Tidy.pm  view on Meta::CPAN

            prefilter             => undef,
            postfilter            => undef,
        );

        # don't overwrite callers ARGV
        local @ARGV = @ARGV;

        my %input_hash = @_;

        if ( my @bad_keys = grep { !exists $defaults{$_} } keys %input_hash ) {
            local $" = ')(';

 view release on metacpan or  search on metacpan

lib/MooseX/Getopt/Defanged.pm  view on Meta::CPAN

        map { $_->get_full_specification($type_metadata) } @option_attributes;

    my $parse_worked;

    {
        local @ARGV = @{$argv_ref};

        open my $stderr_handle, '>', \$stderr;
        $parse_worked = _getopt_invoke_getopt_long_while_handling_exceptions(
            $parser, $stderr_handle, \%option_values, \@specification_strings,
        );

 view release on metacpan or  search on metacpan

t/01_basic.t  view on Meta::CPAN

throws_ok {
    MyTestClass->new_with_options();
} qr/First parameter ins't Getopt::Kingpin instance/, 'kingpin instance';

{
    local @ARGV = ();

    my $kingpin = Getopt::Kingpin->new();

    exits_nonzero {
        MyTestClass->new_with_options($kingpin);
    } 'missing required options';

}

{
    local @ARGV = ($0);

    my $kingpin = Getopt::Kingpin->new();

    my $my = MyTestClass->new_with_options($kingpin);

    is($my->input_file, $0, 'required input_file');
    is($my->lines, 10, 'default lines');
}

{
    local @ARGV = ($0, '--lines', 100);

    my $kingpin = Getopt::Kingpin->new();

    my $my = MyTestClass->new_with_options($kingpin);

 view release on metacpan or  search on metacpan

lib/MooseX/Getopt/Basic.pm  view on Meta::CPAN

    my $constructor_params = ( @params == 1 ? $params[0] : {@params} );

    my $config_from_file;
    if($class->meta->does_role('MooseX::ConfigFromFile')) {
        local @ARGV = @ARGV;

        # just get the configfile arg now out of @ARGV; the rest of the args
        # will be fetched later
        my $configfile;
        my $opt_parser = Getopt::Long::Parser->new( config => [ qw( no_auto_help pass_through no_auto_version ) ] );

 view release on metacpan or  search on metacpan

lib/MooseX/Runnable/Invocation/Scheme/MooseX/Getopt.pm  view on Meta::CPAN

};

around create_instance => sub {
    my ($next, $self, $class, @args) = @_;

    local @ARGV = @args; # ugly!
    my $instance = $class->name->new_with_options();

    my $more_args = $instance->extra_argv;

    return ($instance, @$more_args);