view release on metacpan or search on metacpan
lib/App/Music/ChordPro/Wx/Main.pm view on Meta::CPAN
use Encode qw(decode_utf8);
our $VERSION = $App::Music::ChordPro::Wx::VERSION;
sub new {
my $self = bless $_[0]->SUPER::new(), __PACKAGE__;
Wx::Event::EVT_IDLE($self, $self->can('OnIdle'));
$self;
}
view release on metacpan or search on metacpan
lib/ChordPro/Chords/Parser.pm view on Meta::CPAN
return $info;
}
sub chord_display ( $self ) {
$self->SUPER::chord_display
( $::config->{"chord-formats"}->{common}
// $::config->{settings}->{"chord-format"}
// "%{name}" );
}
lib/ChordPro/Chords/Parser.pm view on Meta::CPAN
return $res;
}
sub chord_display ( $self ) {
$self->SUPER::chord_display
( $::config->{"chord-formats"}->{nashville}
// "%{name}" );
}
# Key name.
lib/ChordPro/Chords/Parser.pm view on Meta::CPAN
return $res;
}
sub chord_display ( $self ) {
$self->SUPER::chord_display
( $::config->{"chord-formats"}->{roman}
// "%{name}" );
}
# Key name.
lib/ChordPro/Chords/Parser.pm view on Meta::CPAN
our @ISA = 'ChordPro::Chord::Base';
use ChordPro::Symbols qw( strum );
sub new( $pkg, $data ) {
my $self = $pkg->SUPER::new( $data );
my $fmt = strum( $data->{name} );
unless ( defined $fmt ) {
warn("Unknown strum: $data->{name}\n");
$self->{format} = "";
}
view release on metacpan or search on metacpan
lib/App/Muter.pm view on Meta::CPAN
$App::Muter::Backend::Chunked::VERSION = '0.003000';
our @ISA = qw/App::Muter::Backend/;
sub new {
my ($class, $args, %opts) = @_;
my $self = $class->SUPER::new($args, %opts);
$self->{chunk} = '';
$self->{enchunksize} = $opts{enchunksize} || $opts{chunksize};
$self->{dechunksize} = $opts{dechunksize} || $opts{chunksize};
return $self;
}
lib/App/Muter.pm view on Meta::CPAN
$App::Muter::Backend::ChunkedDecode::VERSION = '0.003000';
our @ISA = qw/App::Muter::Backend/;
sub new {
my ($class, $args, %opts) = @_;
my $self = $class->SUPER::new($args, %opts);
$self->{chunk} = '';
$self->{regexp} = $opts{regexp};
return $self;
}
lib/App/Muter.pm view on Meta::CPAN
our @ISA = qw/App::Muter::Backend::Chunked/;
sub new {
my ($class, $args, %opts) = @_;
my $nl = (grep { $_ eq 'mime' } @$args) ? "\n" : '';
my $self = $class->SUPER::new(
$args, %opts,
enchunksize => $nl ? 57 : 3,
dechunksize => 4
);
$self->{nl} = $nl;
lib/App/Muter.pm view on Meta::CPAN
}
sub decode {
my ($self, $data) = @_;
$data = $self->{dxfrm}->($data);
return $self->SUPER::decode($self->_filter($data));
}
sub decode_chunk {
my (undef, $data) = @_;
return MIME::Base64::decode($data);
lib/App/Muter.pm view on Meta::CPAN
$App::Muter::Backend::Hex::VERSION = '0.003000';
our @ISA = qw/App::Muter::Backend::Chunked/;
sub new {
my ($class, $args, %opts) = @_;
my $self = $class->SUPER::new(
$args, %opts,
enchunksize => 1,
dechunksize => 2
);
$self->{upper} = 1 if defined $args->[0] && $args->[0] eq 'upper';
return $self;
}
sub metadata {
my $self = shift;
my $meta = $self->SUPER::metadata;
return {
%$meta,
args => {
upper => 'Use uppercase letters',
lower => 'Use lowercase letters',
lib/App/Muter.pm view on Meta::CPAN
$App::Muter::Backend::Base16::VERSION = '0.003000';
our @ISA = qw/App::Muter::Backend::Hex/;
sub new {
my ($class, $args, %opts) = @_;
my $self = $class->SUPER::new(['upper'], %opts);
return $self;
}
sub metadata {
my $self = shift;
my $meta = $self->SUPER::metadata;
delete $meta->{args};
return $meta;
}
App::Muter::Registry->instance->register(__PACKAGE__);
lib/App/Muter.pm view on Meta::CPAN
$App::Muter::Backend::Base32::VERSION = '0.003000';
our @ISA = qw/App::Muter::Backend::Chunked/;
sub new {
my ($class, @args) = @_;
my $self = $class->SUPER::new(@args, enchunksize => 5, dechunksize => 8);
$self->{ftr} =
sub { my $val = shift; $val =~ tr/\x00-\x1f/A-Z2-7/; return $val };
$self->{rtr} =
sub { my $val = shift; $val =~ tr/A-Z2-7/\x00-\x1f/; return $val };
$self->{func} = 'base32';
lib/App/Muter.pm view on Meta::CPAN
return $result;
}
sub metadata {
my $self = shift;
my $meta = $self->SUPER::metadata;
return {
%$meta,
args => {
'manual' => 'Disable use of MIME::Base32',
}
lib/App/Muter.pm view on Meta::CPAN
$App::Muter::Backend::Base32Hex::VERSION = '0.003000';
our @ISA = qw/App::Muter::Backend::Base32/;
sub new {
my ($class, @args) = @_;
my $self = $class->SUPER::new(@args);
$self->{ftr} =
sub { my $val = shift; $val =~ tr/\x00-\x1f/0-9A-V/; return $val };
$self->{rtr} =
sub { my $val = shift; $val =~ tr/0-9A-V/\x00-\x1f/; return $val };
$self->{func} = 'base32hex';
lib/App/Muter.pm view on Meta::CPAN
$App::Muter::Backend::URI::VERSION = '0.003000';
our @ISA = qw/App::Muter::Backend::ChunkedDecode/;
sub new {
my ($class, $args, %opts) = @_;
my $self = $class->SUPER::new($args, %opts, regexp => qr/^(.*)(%.?)$/s);
my $lower = grep { $_ eq 'lower' } @$args;
$self->{chunk} = '';
$self->{format} = '%%%02' . ($lower ? 'x' : 'X');
$self->{form} = grep { $_ eq 'form' } @$args;
return $self;
}
sub metadata {
my $self = shift;
my $meta = $self->SUPER::metadata;
return {
%$meta,
args => {
'upper' => 'Use uppercase letters',
'lower' => 'Use lowercase letters',
lib/App/Muter.pm view on Meta::CPAN
$App::Muter::Backend::Form::VERSION = '0.003000';
our @ISA = qw/App::Muter::Backend::URI/;
sub encode_chunk {
my ($self, $data) = @_;
$data = $self->SUPER::encode_chunk($data);
$data =~ s/%20/+/g;
return $data;
}
sub decode_chunk {
my ($self, $data) = @_;
$data =~ tr/+/ /;
return $self->SUPER::decode_chunk($data);
}
App::Muter::Registry->instance->register(__PACKAGE__);
package App::Muter::Backend::XML;
$App::Muter::Backend::XML::VERSION = '0.003000';
our @ISA = qw/App::Muter::Backend::ChunkedDecode/;
sub new {
my ($class, $args, %opts) = @_;
my $self = $class->SUPER::new($args, %opts, regexp => qr/^(.*)(&[^;]*)$/);
no warnings 'qw'; ## no critic (ProhibitNoWarnings)
my $maps = {
default => [qw/quot amp apos lt gt/],
html => [qw/quot amp #x27 lt gt/],
hex => [qw/#x22 #x26 #x27 #x3c #x3e/],
lib/App/Muter.pm view on Meta::CPAN
return $self;
}
sub metadata {
my $self = shift;
my $meta = $self->SUPER::metadata;
return {
%$meta,
args => {
default => 'Use XML entity names',
html => 'Use HTML-friendly entity names for XML entities',
lib/App/Muter.pm view on Meta::CPAN
our @ISA = qw/App::Muter::Backend::ChunkedDecode/;
sub new {
my ($class, $args, %opts) = @_;
my $self =
$class->SUPER::new($args, %opts, regexp => qr/\A(.*)(=[^\n]?)\z/);
$self->{curlen} = 0;
$self->{smtp} = 1 if grep { $_ eq 'smtp' } @$args;
return $self;
}
lib/App/Muter.pm view on Meta::CPAN
return $data;
}
sub metadata {
my $self = shift;
my $meta = $self->SUPER::metadata;
return {
%$meta,
args => {
smtp => 'Encode "." and "From " at beginning of line',
}
lib/App/Muter.pm view on Meta::CPAN
$App::Muter::Backend::Vis::VERSION = '0.003000';
our @ISA = qw/App::Muter::Backend::ChunkedDecode/;
sub new {
my ($class, $args, %opts) = @_;
my $self = $class->SUPER::new($args, %opts,
regexp => qr/\A(.*?[^^\\-])?(\\.{0,3})\z/);
$self->_setup_maps(map { $_ => 1 } @$args);
$self->{chunk} = '';
return $self;
}
lib/App/Muter.pm view on Meta::CPAN
$self->{chunk} = "\0";
}
else {
$self->{chunk} = '';
}
return $self->SUPER::encode($data);
}
sub encode_chunk {
my ($self, $data) = @_;
my $result = join('', map { $self->{map}[$_] } unpack('C*', $data));
lib/App/Muter.pm view on Meta::CPAN
$data);
}
sub metadata {
my $self = shift;
my $meta = $self->SUPER::metadata;
return {
%$meta,
args => {
sp => 'Encode space',
space => 'Encode space',
lib/App/Muter.pm view on Meta::CPAN
$App::Muter::Backend::Ascii85::VERSION = '0.003000';
our @ISA = qw/App::Muter::Backend::Chunked/;
sub new {
my ($class, @args) = @_;
my $self = $class->SUPER::new(@args, enchunksize => 4, dechunksize => 5);
$self->{start} = '';
return $self;
}
sub encode {
my ($self, $data) = @_;
return '' unless length $data;
my $prefix = defined $self->{start} ? '<~' : '';
$self->{start} = undef;
return $prefix . $self->SUPER::encode($data);
}
sub encode_final {
my ($self, $data) = @_;
return $self->SUPER::encode_final($data) .
(defined $self->{start} ? '' : '~>');
}
sub _encode_seq {
my ($x, $flag) = @_;
lib/App/Muter.pm view on Meta::CPAN
my $hashes = {};
sub new {
my ($class, $args, @args) = @_;
my ($hash) = @$args;
my $self = $class->SUPER::new($args, @args);
$self->{hash} = $hashes->{$hash}->();
return $self;
}
sub encode {
lib/App/Muter.pm view on Meta::CPAN
return $self->{hash}->digest;
}
sub metadata {
my ($self, $data) = @_;
my $meta = $self->SUPER::metadata;
$meta->{args} = {map { $_ => "Use the $_ hash algorithm" } keys %$hashes};
return $meta;
}
sub register_hash {
view release on metacpan or search on metacpan
lib/App/NDTools/NDDiff.pm view on Meta::CPAN
sub arg_opts {
my $self = shift;
return (
$self->SUPER::arg_opts(),
'A!' => \$self->{OPTS}->{diff}->{A},
'N!' => \$self->{OPTS}->{diff}->{N},
'O!' => \$self->{OPTS}->{diff}->{O},
'R!' => \$self->{OPTS}->{diff}->{R},
'U!' => \$self->{OPTS}->{diff}->{U},
lib/App/NDTools/NDDiff.pm view on Meta::CPAN
}
sub configure {
my $self = shift;
$self->SUPER::configure();
$self->{OPTS}->{colors} = $self->{TTY}
unless (defined $self->{OPTS}->{colors});
# resolve colors
lib/App/NDTools/NDDiff.pm view on Meta::CPAN
sub defaults {
my $self = shift;
my $out = {
%{$self->SUPER::defaults()},
'ctx-text' => 3,
'diff' => {
'A' => 1,
'N' => 1,
'O' => 1,
view release on metacpan or search on metacpan
bin/navegante view on Meta::CPAN
sub new {
my($class)=shift;
ref($class)
and $class=ref($class);
my($self)=$class->SUPER::new( yyversion => '1.05',
yystates =>
[
{#State 0
DEFAULT => -19,
GOTOS => {
view release on metacpan or search on metacpan
lib/App/Netdisco/Builder.pm view on Meta::CPAN
# Also force Module::Build to refresh its internal version property
# so the generated META files use the new bumped value.
$self->{properties}{dist_version}
= Module::Metadata->new_from_file('lib/App/Netdisco.pm')->version;
$self->SUPER::ACTION_distmeta(@_);
}
sub ACTION_python {
my $self = shift;
require App::Netdisco::Util::Python;
$self->do_system( App::Netdisco::Util::Python::py_install() );
}
sub ACTION_install {
my $self = shift;
$self->SUPER::ACTION_install;
$self->ACTION_python;
}
1;
view release on metacpan or search on metacpan
lib/App/NoPAN/Installer/Configure.pm view on Meta::CPAN
sub build {
my ($self, $nopan) = @_;
$self->shell_exec('autoreconf -i')
unless -e 'configure';
$self->shell_exec('./configure');
$self->SUPER::build($nopan);
}
1;
view release on metacpan or search on metacpan
lib/App/Nopaste/Service/AnyPastebin.pm view on Meta::CPAN
$mech->{__username} = $args{username}
if exists($args{username}) && $args{username};
$mech->{__password} = $args{password}
if exists($args{password}) && $args{password};
return $self->SUPER::get($mech => @_);
}
sub post_content {
my ($self, %args) = @_;
view release on metacpan or search on metacpan
lib/App/Nopaste/Service/Linode.pm view on Meta::CPAN
my %args = @_;
$args{username} ||= 'no';
$args{password} ||= 'spam';
return $self->SUPER::get($mech => %args);
}
sub post_content {
my ($self, %args) = @_;
my $content = $self->SUPER::post_content(%args);
# On p.linode.com the code2 parameter is called code2z for some
# reason.
$content->{code2z} = delete $content->{code2};
view release on metacpan or search on metacpan
1.02 Fri Jan 29 09:52:00 2010
- Change namespace from CGI::Office::* to App::Office::* after discussion with Matt Trout
1.01 Thu Jan 7 15:39:00 2010
- Add MANIFEST and MYMETA.yml
- Change call from SUPER::cgiapp to global_prerun to match other CGI-Office-* modules
1.00 Thu Dec 31 10:48:00 2009
- Rename from Local::Contacts.
- Remove Apache-specific code.
- Split into N controllers, using CGI::Application::Dispatch.
view release on metacpan or search on metacpan
lib/App/Oozie/Deploy/Template/ttree.pm view on Meta::CPAN
our $VERSION = '0.020'; # VERSION
sub new {
my($class, $log_collector, @pass_through) = @_;
my $self = $class->SUPER::new(
@pass_through,
);
$self->{log_collector} = $log_collector;
return $self;
}
sub run {
my($self, @args) = @_;
local @ARGV = @args;
return $self->SUPER::run();
}
sub emit_warn {
my($self, $msg) = @_;
return$self->{log_collector}->(
view release on metacpan or search on metacpan
lib/App/OpenHAP/Tasmota/Device.pm view on Meta::CPAN
use constant SENSOR_TYPES =>
qw(DS18B20 DHT11 DHT22 AM2301 BME280 BMP280 SHT3X SI7021);
sub new ( $class, %args )
{
my $self = $class->SUPER::new(%args);
$self->{mqtt_topic} = $args{mqtt_topic};
$self->{mqtt_client} = $args{mqtt_client};
$self->{relay_index} = $args{relay_index} // 0; # 0 = no index
$self->{availability} = AVAILABILITY_UNKNOWN;
lib/App/OpenHAP/Tasmota/Device.pm view on Meta::CPAN
return $self;
}
# $self->subscribe_mqtt():
# Subscribe to all standard Tasmota topics.
# Subclasses must call SUPER::subscribe_mqtt() first.
sub subscribe_mqtt ($self)
{
return unless $self->{mqtt_client}->is_connected();
Fugu::Log->default->debug(
view release on metacpan or search on metacpan
lib/App/PDFLibrarian/QueryDialog/impl.pm view on Meta::CPAN
sub new {
my ($class, $pdffile, $query_db_name, $query_value, $query_values, $error_message) = @_;
# create dialog
my $self = $class->SUPER::new(undef, -1, "Import - PDFLibrarian", &Wx::wxDefaultPosition, &Wx::wxDefaultSize, wxDIALOG_NO_PARENT | wxDEFAULT_DIALOG_STYLE);
# set dialog icon
my $icon = Wx::ArtProvider::GetIcon(Wx::ArtProvider::wxART_QUESTION, Wx::ArtProvider::wxART_CMN_DIALOG);
$self->SetIcon($icon);
view release on metacpan or search on metacpan
lib/App/PLab/Calibrations.pm view on Meta::CPAN
sub win_inidefaults
{
my $w = $_[0];
my @rc = $w-> rect;
return (
$w-> SUPER::win_inidefaults,
XCalibration => 1.0,
YCalibration => 1.0,
);
}
lib/App/PLab/Calibrations.pm view on Meta::CPAN
tabs => [ @nbpages, 'Calibrations'],
pageCount => scalar(@nbpages) + 1,
);
my $pg = $nb-> pageCount;
$w-> SUPER::opt_propcreate( $dlg, $nb, $nbpages);
# Calibrations
my %spinPrf = (
size => [ 265, 20],
min => 0.0001,
max => 10,
lib/App/PLab/Calibrations.pm view on Meta::CPAN
}
sub opt_proppush
{
my ( $w, $dlg, $nb, $nbpages) = @_;
$w-> SUPER::opt_proppush( $dlg, $nb, $nbpages);
# Calibrations
$nbpages-> XC-> value($w->{ini}->{XCalibration});
$nbpages-> YC-> value($w->{ini}->{YCalibration});
}
sub opt_proppop
{
my ( $w, $dlg, $nb, $nbpages, $mr) = @_;
$w-> SUPER::opt_proppop( $dlg, $nb, $nbpages, $mr);
# Calibrations
if ( $mr) {
my ( $xc, $yc) = ( $nbpages-> XC->value, $nbpages-> YC->value);
$w-> modified( 1) if
$w->{ini}->{XCalibration} != $xc ||
view release on metacpan or search on metacpan
lib/App/PS1.pm view on Meta::CPAN
},
);
sub new {
my ($class, $params) = @_;
my $self = $class->SUPER::new($params);
$self->safe( $ENV{UNICODE_UNSAFE} ) if !defined $self->safe;
$self->theme("default") if !defined $self->theme;
$theme{ $self->theme } ||= {};
view release on metacpan or search on metacpan
lib/App/PerlShell/LexPersist.pm view on Meta::CPAN
$params{$_} = $cfg{$_};
}
}
}
my $self = $class->SUPER::new(@_);
$self->{package} = $package;
# following line avoids ugly error if first command in shell is
# $var = ... without the "my"
$PACKAGE = $package;
lib/App/PerlShell/LexPersist.pm view on Meta::CPAN
\$App::PerlShell::LexPersist::PACKAGE = __PACKAGE__;
}
END_PERL
# Hand off to the parent version
return $self->SUPER::prepare( $code, @_ );
}
# Modifications to the package are tracked at compile-time
sub compile {
my $self = shift;
my $sub = $self->SUPER::compile(@_);
# Save the package state
$self->set_package($PACKAGE);
return $sub;
view release on metacpan or search on metacpan
code => q{
sub ACTION_docs {
use Pod::Select;
my $self = shift;
podselect({ -output => 'README.pod' }, 'lib/App/PhotoDB.pm');
return $self->SUPER::ACTION_docs;
}
}
);
my $builder = $class->new(
view release on metacpan or search on metacpan
script/pick view on Meta::CPAN
#}
#
#sub _init_read {
# my $self = shift;
#
# $self->SUPER::_init_read;
# $self->{_res} = {};
# $self->{_merge} = undef;
# $self->{_num_seen_section_lines} = 0;
# $self->{_cur_section} = $self->{default_section};
# $self->{_arrayified} = {};
view release on metacpan or search on metacpan
sub ACTION_author_test
{
my $self = shift;
local $self->{properties}{test_files} = 'xt/author/*.t' ;
$self->SUPER::ACTION_test();
}
sub ACTION_dist
{
my $self = shift;
{
print "git not found, 'Changes' will not be generated from git log!\n" ;
}
}
$self->SUPER::ACTION_test() ;
#~ $self->ACTION_author_test() ;
$self->SUPER::ACTION_dist();
};
EOC
;
view release on metacpan or search on metacpan
#---------------------------------
sub ACTION_build {
my ($s) = @_;
$s->_readme();
$s->SUPER::ACTION_build;
}
# Only for the maintainer on "Build build".
sub _readme {
my ($s) = @_;
sub ACTION_install {
my ($s) = @_;
$s->_clear_cache;
$s->_check_for_source_command if os_type eq "Unix";
$s->SUPER::ACTION_install;
}
sub ACTION_clean {
my ($s) = @_;
$s->_clear_cache;
$s->SUPER::ACTION_clean;
}
sub ACTION_test {
my ($s) = @_;
$s->_clear_cache;
$s->SUPER::ACTION_test;
}
sub _clear_cache {
my $home = $ENV{HOME} // $ENV{USERPROFILE} // $ENV{LOGDIR};
for ( glob qq("$home/.cache/my_pod*.cache") ) {
view release on metacpan or search on metacpan
lib/App/Pods2Site/SiteBuilder/BasicFramesTreeTOC.pm view on Meta::CPAN
sub new
{
my $class = shift;
my $self = $class->SUPER::new(@_);
$self->{maxtocdepth} = -1;
return $self;
}
view release on metacpan or search on metacpan
lib/App/Presto/ShellUI.pm view on Meta::CPAN
$self->arg_processor->process($args);
1;
} or do {
warn "Error preparsing args @$args: $@";
};
return $self->SUPER::call_command(@_);
}
sub ornaments {
shift->{term}->ornaments(@_);
}
view release on metacpan or search on metacpan
lib/PrimaX/InputHistory.pm view on Meta::CPAN
# This has the standard profile of an InputLine widget, except that it knows
# about navigation keys and other things useful for the History.
sub profile_default
{
my %def = %{$_[ 0]-> SUPER::profile_default};
# These lines are somewhat patterned from the Prima example called 'editor'
my @acc = (
# Navigation scrolls through the command history
['Previous Line', 'Up', kb::Up, sub {$_[0]->move_line(-1)}]
lib/PrimaX/InputHistory.pm view on Meta::CPAN
# This stage initializes the inputline. I believe this is the appropriate stage
# for (1) setting the properties above (2) loading the history file data, and
# (3) connecting to the output widget.
sub init {
my $self = shift;
my %profile = $self->SUPER::init(@_);
foreach ( qw(pageLines promptFormat currentLine outputWidget storeType) ) {
$self->{$_} = $profile{$_};
}
# Store the history and revisions:
view release on metacpan or search on metacpan
lib/TAP/Parser/Iterator/Stream/Selectable.pm view on Meta::CPAN
my ( $self, $args ) = @_;
unless ( $args->{handle} ) {
die "handle argument must be specified.\n";
}
my $chunk_size = delete $args->{_chunk_size} || 65536;
return unless ( $self->SUPER::_initialize( $args->{handle} ) );
$self->{out} = $args->{handle};
$self->{err} = $args->{handle};
$self->{sel} = IO::Select->new( $args->{handle} );
$self->{pid} = '';
$self->{exit} = undef;
view release on metacpan or search on metacpan
lib/App/Prove/Elasticsearch/Harness.pm view on Meta::CPAN
# inject parser_class as Test::Rail::Parser.
sub new {
my $class = shift;
my $arg_for = shift;
$arg_for->{parser_class} = 'App::Prove::Elasticsearch::Parser';
my $self = $class->SUPER::new($arg_for);
return $self;
}
sub make_parser {
my ($self, $job) = @_;
my $args = $self->SUPER::_get_parser_args($job);
my @relevant_keys =
qw{SERVER_HOST SERVER_PORT CLIENT_INDEXER CLIENT_BLAMER CLIENT_VERSIONER CLIENT_PLATFORMER CLIENT_AUTODISCOVER};
my @keys_filtered = grep {
my $subj = $_;
lib/App/Prove/Elasticsearch/Harness.pm view on Meta::CPAN
$km =~ s/_/./g;
$args->{$km} = $ENV{$key};
$self->{$km} = $ENV{$key};
}
$self->SUPER::_make_callback('parser_args', $args, $job->as_array_ref);
my $parser = $self->SUPER::_construct($self->SUPER::parser_class, $args);
$self->SUPER::_make_callback('made_parser', $parser, $job->as_array_ref);
my $session =
$self->SUPER::formatter->open_test($job->description, $parser);
return ($parser, $session);
}
sub runtests {
lib/App/Prove/Elasticsearch/Harness.pm view on Meta::CPAN
if ($ENV{CLIENT_AUTODISCOVER}) {
my $searcher = $self->_require_deps();
@tests = $self->_filter_tests_with_results($searcher, @tests);
}
return $self->SUPER::runtests(@tests);
}
sub _filter_tests_with_results {
my ($self, $searcher, @tests) = @_;
my $indexer = $ENV{CLIENT_INDEXER};
view release on metacpan or search on metacpan
lib/TAP/Harness/Metrics.pm view on Meta::CPAN
}
sub new {
my ($ref,@opt)=@_;
my $class=ref($ref)||$ref;
my $self=$class->SUPER::new(@opt);
while(my ($k,$v)=each(%options)) { $$self{$k}=$v }
if($$self{type} eq 'module') {
$$self{modulef}=verifyCallback($$self{module},$$self{f});
if(my $cfg=$$self{module}->can('configureHarness')) {
my %config=&$cfg();
lib/TAP/Harness/Metrics.pm view on Meta::CPAN
return $self;
}
sub make_parser {
my ($self,@args)=@_;
my ($parser,$session)=$self->SUPER::make_parser(@args);
$parser->configure(callback=>sub { $self->save(@_) });
return ($parser,$session);
}
sub import {
view release on metacpan or search on metacpan
lib/TAP/Harness/MultipleConfig.pm view on Meta::CPAN
my ($filenames) = @_;
my $config = ConfigCache->get_config_by_filename($filenames->[0]);
ConfigCache->push_configs($config);
},
};
$self->SUPER::new($params);
}
1;
__END__
view release on metacpan or search on metacpan
lib/App/Prove/Plugin/MySQLPool.pm view on Meta::CPAN
my $share_file = $ENV{ PERL_APP_PROVE_PLUGIN_MYSQLPOOL_SHARE_FILE }
or return;
Test::mysqld::Pool->new( share_file => $share_file )->dealloc_unused;
$self->SUPER::close_test(@_);
}
}
{
package TAP::Formatter::MySQLPool;
use parent 'TAP::Formatter::Console';
sub open_test {
my $self = shift;
bless $self->SUPER::open_test(@_), 'TAP::Formatter::MySQLPool::Session';
}
}
1;
__END__
view release on metacpan or search on metacpan
lib/App/Prove/Plugin/TraceUse.pm view on Meta::CPAN
my $fn = "$tf";
## add the traceuse option
$_[0]->{switches} = ["-d:TraceUse=hidecore,output:$fn"];
my $obj = $self->SUPER::new(@_);
$obj->{collected_dependencies} = [];
my $trace_use_sub = sub {
view release on metacpan or search on metacpan
inc/Module/Build/My.pm view on Meta::CPAN
if ($args{from} =~ /\bscript\/.*\.pl$/ and $args{to_dir}) {
my (undef, undef, $file) = File::Spec->splitpath($args{from});
$file =~ s/\.pl$//;
$args{to} = File::Spec->catfile($args{to_dir}, $file);
delete $args{to_dir};
return $self->SUPER::copy_if_modified(%args);
}
return $self->SUPER::copy_if_modified(%args);
};
$self->SUPER::process_script_files;
}
1;