view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
if ( my $code = $sym->{$pwd} ) {
# Delegate back to parent dirs
goto &$code unless $cwd eq $pwd;
}
unless ($$sym =~ s/([^:]+)$//) {
# XXX: it looks like we can't retrieve the missing function
# via $$sym (usually $main::AUTOLOAD) in this case.
# I'm still wondering if we should slurp Makefile.PL to
# get some context or not ...
my ($package, $file, $line) = caller;
die <<"EOT";
view release on metacpan or search on metacpan
lib/App/LXC/Container/Data/Debian.pm view on Meta::CPAN
sub package_of($$)
{
my ($self, $file) = @_;
$self->SUPER::package_of($file);
local $_;
# TODO: looks like pipe with redirection in shell never fails:
# uncoverable branch true
open my $dpkg, '-|', SEARCH . $file . ' 2>/dev/null'
or fatal('internal_error__1',
'error calling ' . SEARCH . $file . ': '. $!);
# escape special characters in file name:
view release on metacpan or search on metacpan
use App::Lazyd;
use YAML::Tiny;
unless (-f "$ENV{HOME}/.lazyd") {
die <<USAGE;
Please add a ~/.lazyd config file looks like this
username: foo
password: foo31337
USAGE
view release on metacpan or search on metacpan
lib/App/Lingua/BO/Wylie/Transliteration.pm view on Meta::CPAN
This merging process can be seen as building "ligatures", of which even more exist.
As we have seen, the vocal symbols (for all vocals except 'a', which is inherent)
need to be added in the proper places.
For the rest of the symbols that can be added, the scheme looks the following:
b s g r u b s
| | | | | | |
1 2 3 4 5 6 7
view release on metacpan or search on metacpan
lib/App/LintPrereqs.pm view on Meta::CPAN
use File::Which;
use Filename::Backup qw(check_backup_filename);
use IPC::System::Options 'system', -log=>1;
use Module::CoreList::More;
use Proc::ChildError qw(explain_child_error);
use Scalar::Util 'looks_like_number';
use Sort::Sub qw(prereq_ala_perlancar);
use Version::Util qw(version_gt version_ne);
our %SPEC;
require Exporter;
lib/App/LintPrereqs.pm view on Meta::CPAN
} else {
log_trace("Will assume perl %s (from running interpreter's \$^V)",
$^V);
if ($^V =~ /^v(\d+)\.(\d+)\.(\d+)/) {
$perlv = sprintf("%d\.%03d%03d", $1, $2, $3)+0;
} elsif (looks_like_number($^V)) {
$perlv = $^V;
} else {
return [500, "Can't parse \$^V ($^V)"];
}
}
view release on metacpan or search on metacpan
lib/App/ListRevDeps.pm view on Meta::CPAN
};
my @res;
for (ref($mod) eq 'ARRAY' ? @$mod : $mod) {
my $dist;
# if it already looks like a dist, skip an API call
if (/-/) {
$dist = $_;
} else {
my $modinfo = $chi->compute(
"metacpan-mod-$_", $ce, sub {
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
if ( my $code = $sym->{$pwd} ) {
# Delegate back to parent dirs
goto &$code unless $cwd eq $pwd;
}
unless ($$sym =~ s/([^:]+)$//) {
# XXX: it looks like we can't retrieve the missing function
# via $$sym (usually $main::AUTOLOAD) in this case.
# I'm still wondering if we should slurp Makefile.PL to
# get some context or not ...
my ($package, $file, $line) = caller;
die <<"EOT";
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
if ( my $code = $sym->{$pwd} ) {
# Delegate back to parent dirs
goto &$code unless $cwd eq $pwd;
}
unless ($$sym =~ s/([^:]+)$//) {
# XXX: it looks like we can't retrieve the missing function
# via $$sym (usually $main::AUTOLOAD) in this case.
# I'm still wondering if we should slurp Makefile.PL to
# get some context or not ...
my ($package, $file, $line) = caller;
die <<"EOT";
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
if ( my $code = $sym->{$pwd} ) {
# Delegate back to parent dirs
goto &$code unless $cwd eq $pwd;
}
unless ($$sym =~ s/([^:]+)$//) {
# XXX: it looks like we can't retrieve the missing function
# via $$sym (usually $main::AUTOLOAD) in this case.
# I'm still wondering if we should slurp Makefile.PL to
# get some context or not ...
my ($package, $file, $line) = caller;
die <<"EOT";
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
if ( my $code = $sym->{$pwd} ) {
# Delegate back to parent dirs
goto &$code unless $cwd eq $pwd;
}
unless ($$sym =~ s/([^:]+)$//) {
# XXX: it looks like we can't retrieve the missing function
# via $$sym (usually $main::AUTOLOAD) in this case.
# I'm still wondering if we should slurp Makefile.PL to
# get some context or not ...
my ($package, $file, $line) = caller;
die <<"EOT";
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
if ( my $code = $sym->{$pwd} ) {
# Delegate back to parent dirs
goto &$code unless $cwd eq $pwd;
}
unless ($$sym =~ s/([^:]+)$//) {
# XXX: it looks like we can't retrieve the missing function
# via $$sym (usually $main::AUTOLOAD) in this case.
# I'm still wondering if we should slurp Makefile.PL to
# get some context or not ...
my ($package, $file, $line) = caller;
die <<"EOT";
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
if ( my $code = $sym->{$pwd} ) {
# Delegate back to parent dirs
goto &$code unless $cwd eq $pwd;
}
unless ($$sym =~ s/([^:]+)$//) {
# XXX: it looks like we can't retrieve the missing function
# via $$sym (usually $main::AUTOLOAD) in this case.
# I'm still wondering if we should slurp Makefile.PL to
# get some context or not ...
my ($package, $file, $line) = caller;
die <<"EOT";
view release on metacpan or search on metacpan
share/js/core/ajax.js view on Meta::CPAN
// The success and failure callbacks can be null or undefined, in which case App::MFILE::WWW will
// just display the status text in the #result div (i.e., the line at the bottom of the frame).
// If your AJAX calls needs any other handling than this, you need to provide at least a success
// callback.
//
// In all cases except login/logout, the MFILE AJAX Object looks like this:
// {
// "method": any HTTP method accepted by the backend server
// "path": valid path to backend server resource
// "body": content body to be sent to backend server (can be null)
// }
view release on metacpan or search on metacpan
lib/App/MHFS.pm view on Meta::CPAN
use strict; use warnings;
use feature 'say';
use POSIX ":sys_wait_h";
use IO::Poll qw(POLLIN POLLOUT POLLHUP);
use Time::HiRes qw( usleep clock_gettime CLOCK_REALTIME CLOCK_MONOTONIC);
use Scalar::Util qw(looks_like_number);
use Data::Dumper;
use Devel::Peek;
#use Devel::Refcount qw( refcount );
use constant POLLRDHUP => 0;
lib/App/MHFS.pm view on Meta::CPAN
use IO::Socket::INET;
use Errno qw(EINTR EIO :POSIX);
use Fcntl qw(:seek :mode);
use File::stat;
use IO::Poll qw(POLLIN POLLOUT POLLHUP);
use Scalar::Util qw(looks_like_number weaken);
use Data::Dumper;
use Carp;
$SIG{ __DIE__ } = sub { Carp::confess( @_ ) };
sub new {
lib/App/MHFS.pm view on Meta::CPAN
package MHFS::FD::Reader {
use strict; use warnings;
use feature 'say';
use Time::HiRes qw( usleep clock_gettime CLOCK_MONOTONIC);
use IO::Poll qw(POLLIN POLLOUT POLLHUP);
use Scalar::Util qw(looks_like_number weaken);
sub new {
my ($class, $process, $fd, $func) = @_;
my %self = ('time' => clock_gettime(CLOCK_MONOTONIC), 'process' => $process, 'fd' => $fd, 'onReadReady' => $func);
say "PID " . $self{'process'}{'pid'} . 'FD ' . $self{'fd'};
weaken($self{'process'});
lib/App/MHFS.pm view on Meta::CPAN
package MHFS::FD::Writer {
use strict; use warnings;
use feature 'say';
use Time::HiRes qw( usleep clock_gettime CLOCK_MONOTONIC);
use IO::Poll qw(POLLIN POLLOUT POLLHUP);
use Scalar::Util qw(looks_like_number weaken);
sub new {
my ($class, $process, $fd, $func) = @_;
my %self = ('time' => clock_gettime(CLOCK_MONOTONIC), 'process' => $process, 'fd' => $fd, 'onWriteReady' => $func);
say "PID " . $self{'process'}{'pid'} . 'FD ' . $self{'fd'};
weaken($self{'process'});
lib/App/MHFS.pm view on Meta::CPAN
use IO::Poll qw(POLLIN POLLOUT POLLHUP);
use Errno qw(EINTR EIO :POSIX);
use Fcntl qw(:seek :mode);
use File::stat;
use IPC::Open3;
use Scalar::Util qw(looks_like_number weaken);
use Data::Dumper;
use Devel::Peek;
use Carp;
$SIG{ __DIE__ } = sub { Carp::confess( @_ ) };
lib/App/MHFS.pm view on Meta::CPAN
use Devel::Peek;
use Fcntl ':mode';
use File::stat;
use File::Basename;
use File::Path qw(make_path);
use Scalar::Util qw(looks_like_number);
MHFS::Util->import();
BEGIN {
if( ! (eval "use JSON; 1")) {
eval "use JSON::PP; 1" or die "No implementation of JSON available";
warn __PACKAGE__.": Using PurePerl version of JSON (JSON::PP)";
lib/App/MHFS.pm view on Meta::CPAN
use Encode qw(decode encode);
use URI::Escape;
use Storable qw(dclone);
use Fcntl ':mode';
use Time::HiRes qw( usleep clock_gettime CLOCK_REALTIME CLOCK_MONOTONIC);
use Scalar::Util qw(looks_like_number weaken);
use POSIX qw/ceil/;
use Storable qw( freeze thaw);
#use ExtUtils::testlib;
use FindBin;
use File::Spec;
lib/App/MHFS.pm view on Meta::CPAN
use feature 'say';
use Data::Dumper;
use feature 'state';
use Encode;
use URI::Escape;
use Scalar::Util qw(looks_like_number weaken);
use File::stat;
MHFS::Util->import();
BEGIN {
if( ! (eval "use JSON; 1")) {
eval "use JSON::PP; 1" or die "No implementation of JSON available";
view release on metacpan or search on metacpan
lib/App/MaMGal/EntryFactory.pm view on Meta::CPAN
my $path = shift;
# Do some path mangling in two special cases:
if ($path eq '.') {
# discover current directory name, so that it looks nice in
# listings, and we know where to ascend when retracting towards
# root directory
$path = Cwd::abs_path($path);
} elsif ($path eq '/') {
# mangle the path so that the following regular expression
view release on metacpan or search on metacpan
examples/rfc/README.pod view on Meta::CPAN
suitable for use in an EPUB, clean up the HTML file with this script in the
directory I<< examples/rfc >>.
bin/finish-htmlrfc.pl download/rfc2328.html > clean/rfc2328.html
This HTML-RFC looks exactly as the plain text version and is only suitable for
ebook readers with big screen because it does use the C<< <pre> >> tag to
render the text.
The alternative is to take the plaintext RFC and convert it like this
view release on metacpan or search on metacpan
lib/App/MarkFiles.pm view on Meta::CPAN
home directory. Once marked, files can be copied, moved, listed, or passed as
parameters to arbitrary shell commands.
This originated as a simple tool for collecting files from one or more
directories and moving or copying them to another. A basic usage pattern
looks something like this:
$ cd ~/screenshots
$ mark add foo.png
$ cd ~/blog/files/screenshots
$ mark mv
view release on metacpan or search on metacpan
lib/App/Math/Tutor/Cmd/Unit/Cmd/Cast.pm view on Meta::CPAN
use MooX::Options;
use Carp qw(croak);
use File::ShareDir ();
use Template ();
use Scalar::Util qw(looks_like_number);
has template_filename => (
is => "ro",
default => "twocols"
);
view release on metacpan or search on metacpan
lib/App/MechaCPAN/Deploy.pm view on Meta::CPAN
open my $snap_fh, '<', $file;
if ( my $line = <$snap_fh> !~ $snapshot_re )
{
die "File doesn't looks like a carton snapshot: $file";
}
my @stack = ($result);
my $prefix = '';
while ( my $line = <$snap_fh> )
view release on metacpan or search on metacpan
lib/App/MediaWiki2Git.pm view on Meta::CPAN
my $fn = $pagename;
write_file($fn, { atomic => 1 }, delete $props->{'*'});
my $author;
if ($props->{user} =~ m{^[0-9.:]+$}) {
# user looks like an IP address.
# exists $props->{anon} # looks promising, but broken in early
# revs (made with early mediawiki?)
$author = $self->anon2author($props->{user});
} else {
$author = sprintf('%s <%s>', ($props->{user}) x 2);
}
view release on metacpan or search on metacpan
lib/App/Memcached/CLI/Main.pm view on Meta::CPAN
sub parse_args {
my $class = shift;
my %params; # will be passed to new()
if (defined $ARGV[0] and looks_like_addr($ARGV[0])) {
$params{addr} = shift @ARGV;
}
GetOptions(
\my %opts, 'addr|a=s', 'timeout|t=i',
'debug|d', 'help|h', 'man',
view release on metacpan or search on metacpan
lib/App/Memcached/Tool/CLI.pm view on Meta::CPAN
sub parse_args {
my $class = shift;
my %params; # will be passed to new()
if (defined $ARGV[0] and looks_like_addr($ARGV[0])) {
$params{addr} = shift @ARGV;
}
if (defined $ARGV[0] and first { $_ eq $ARGV[0] } MODES()) {
$params{mode} = shift @ARGV;
}
view release on metacpan or search on metacpan
inc/Module/Install.pm view on Meta::CPAN
if ( my $code = $sym->{$pwd} ) {
# Delegate back to parent dirs
goto &$code unless $cwd eq $pwd;
}
unless ($$sym =~ s/([^:]+)$//) {
# XXX: it looks like we can't retrieve the missing function
# via $$sym (usually $main::AUTOLOAD) in this case.
# I'm still wondering if we should slurp Makefile.PL to
# get some context or not ...
my ($package, $file, $line) = caller;
die <<"EOT";
view release on metacpan or search on metacpan
t/025_sequence_api.t view on Meta::CPAN
my $r = request $url;
is($r->code, 200, "200 GET $url" );
ok($r->content !~ m/Bio::BLAST::Database::Seq/);
like($r->content, qr/^>LE_HBa0001A15_T7_30 Chromat_file:Le-HBa001_A15-T7\.ab1 SGN_GSS_ID:30 \(vector and quality trimmed\)/, 'got the correct desc line back');
like($r->content, qr/$seq/, 'looks like the same FASTA');
is(length($r->content),596, 'got non-zero content length') or diag $r->content;
}
{
basic_test('/api/sequence/id/1/LE_HBa0001A15_T7_30.txt');
view release on metacpan or search on metacpan
lib/App/MiseEnPlace.pm view on Meta::CPAN
sub _load_configs {
my( $self ) = shift;
unless ( -e $self->config_file() ) {
say "Whoops, it looks like you don't have a " . $self->config_file() . " file yet.";
say "Please review the documentation, create one, and try again.";
exit;
}
my $base_config = _load_config_file( $self->config_file() );
view release on metacpan or search on metacpan
<li><a href="bar.html" >bar</a></li>
<li><a href="baz.html" >baz</a></li>
</ul>
</div>
Each menu item looks like this: [% item label1 some_text %]. If it is called as
[% menu label1 %] it will produce some_text, and all double curly brackets {{ }}
are simply stripped, but the text between them remains.
If it is called with a different name, say [% menu label2 %] the curly brackets
and the text between them are stripped.
view release on metacpan or search on metacpan
lib/App/MtAws/Command/DownloadInventory.pm view on Meta::CPAN
my ($R) = fork_engine->{parent_worker}->process_task($ft, undef);
my $attachmentref = $R->{inventory_raw_ref};
my $inventory_type = $R->{inventory_type};
# here we can have response from both JobList or Inventory output..
# JobList looks like 'response' => '{"JobList":[],"Marker":null}'
# Inventory retriebal has key 'ArchiveList'
# TODO: implement it more clear way on level of Job/Tasks object
croak if -s binaryfilename $options->{'new-journal'}; # TODO: fix race condition between this and opening file
if ($R && $attachmentref) { # $attachmentref can be SCALAR REF or can be undef
$j->open_for_write();
view release on metacpan or search on metacpan
How to gather:
Look at P9Y::ProcessTable
Yah, this looks good:
#!/usr/local/toolsx/bin/perl
use Modern::Perl;
use Data::Dumper;
use P9Y::ProcessTable;
view release on metacpan or search on metacpan
lib/App/MultiModule/API.pm view on Meta::CPAN
package App::MultiModule::API;
$App::MultiModule::API::VERSION = '1.171870';
use strict;use warnings;
use Data::Dumper;
use Sereal::Encoder qw(encode_sereal);
use Sereal::Decoder qw(looks_like_sereal decode_sereal);
=head2 new
Constructor
lib/App/MultiModule/API.pm view on Meta::CPAN
open my $fh, '<', $file_path or die "failed to open $file_path for reading: $!";
while(<$fh>) {
$f .= $_;
}
close $fh or die "failed to close $file_path: $!";
if(looks_like_sereal($f)) {
$ret = decode_sereal $f or die 'returned false';
} else {
$ret = do $file_path or die "failed to deserialize $file_path: $@";
}
};
view release on metacpan or search on metacpan
lib/App/Munner.pm view on Meta::CPAN
To run munner, you will need a YAML format of config file.
The config file name is munner.yml
It looks like this:
---------------------------
base_dir: "... base directory to find the app ..."
apps:
web-frontend: