view release on metacpan or search on metacpan
lib/App/KGB/Change.pm view on Meta::CPAN
=cut
sub new {
my $class = shift;
my $self = $class->SUPER::new();
my $h = shift;
if ( ref($h) ) {
defined( $self->action( delete $h->{action} ) )
or confess "'action' is required";
view release on metacpan or search on metacpan
code => q{
sub ACTION_test_libs {
my $self = shift;
local @INC = @INC;
unshift @INC, 't/lib';
$self->SUPER::ACTION_test(@_);
}
},
)->new(%args);
$builder->create_build_script();
view release on metacpan or search on metacpan
kritika.fatpack view on Meta::CPAN
$fatpacked{"File/HomeDir.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'FILE_HOMEDIR';
package File::HomeDir;use 5.00503;use strict;use Carp ();use Config ();use File::Spec ();use File::Which ();use vars qw{$VERSION @ISA @EXPORT @EXPORT_OK $IMPLEMENTED_BY};BEGIN {$VERSION='0.05';require Exporter;@ISA=qw{Exporter};@EXPORT=qw{home};@EX...
FILE_HOMEDIR
$fatpacked{"File/HomeDir/Darwin.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'FILE_HOMEDIR_DARWIN';
package File::HomeDir::Darwin;use 5.00503;use strict;use Cwd ();use Carp ();use File::HomeDir::Unix ();use vars qw{$VERSION @ISA};BEGIN {$VERSION='0.05';@ISA='File::HomeDir::Unix'}sub my_home {my$class=shift;if (exists$ENV{HOME}and defined$ENV{HOME...
FILE_HOMEDIR_DARWIN
$fatpacked{"File/HomeDir/Darwin/Carbon.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'FILE_HOMEDIR_DARWIN_CARBON';
package File::HomeDir::Darwin::Carbon;use 5.00503;use strict;use Cwd ();use Carp ();use File::HomeDir::Darwin ();use vars qw{$VERSION @ISA};BEGIN {$VERSION='0.05';@ISA='File::HomeDir::Darwin';local $@;eval "use prefork 'Mac::Files'"}sub my_home {my...
FILE_HOMEDIR_DARWIN_CARBON
$fatpacked{"File/HomeDir/Darwin/Cocoa.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'FILE_HOMEDIR_DARWIN_COCOA';
package File::HomeDir::Darwin::Cocoa;use 5.00503;use strict;use Cwd ();use Carp ();use File::HomeDir::Darwin ();use vars qw{$VERSION @ISA};BEGIN {$VERSION='0.05';@ISA='File::HomeDir::Darwin';local $@;eval "use prefork 'Mac::SystemDirectory'"}sub my...
FILE_HOMEDIR_DARWIN_COCOA
$fatpacked{"File/HomeDir/Driver.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'FILE_HOMEDIR_DRIVER';
package File::HomeDir::Driver;use 5.00503;use strict;use Carp ();use vars qw{$VERSION};BEGIN {$VERSION='0.05'}sub my_home {Carp::croak("$_[0] does not implement compulsory method $_[1]")}1;
FILE_HOMEDIR_DRIVER
kritika.fatpack view on Meta::CPAN
$fatpacked{"Test/Deep/Array.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_ARRAY';
use strict;use warnings;package Test::Deep::Array;use Test::Deep::Ref;sub init {my$self=shift;my$val=shift;$self->{val}=$val}sub descend {my$self=shift;my$got=shift;my$exp=$self->{val};return 0 unless Test::Deep::descend($got,Test::Deep::arraylengt...
TEST_DEEP_ARRAY
$fatpacked{"Test/Deep/ArrayEach.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_ARRAYEACH';
use strict;use warnings;package Test::Deep::ArrayEach;use Test::Deep::Cmp;use Scalar::Util ();sub init {my$self=shift;my$val=shift;$self->{val}=$val}sub descend {my$self=shift;my$got=shift;return unless ref$got && Scalar::Util::reftype($got)eq 'ARR...
TEST_DEEP_ARRAYEACH
$fatpacked{"Test/Deep/ArrayElementsOnly.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_ARRAYELEMENTSONLY';
use strict;use warnings;package Test::Deep::ArrayElementsOnly;use Test::Deep::Ref;sub init {my$self=shift;my$val=shift;$self->{val}=$val}sub descend {my$self=shift;my$got=shift;my$exp=$self->{val};my$data=$self->data;for my$i (0..$#{$exp}){$data->{...
TEST_DEEP_ARRAYELEMENTSONLY
kritika.fatpack view on Meta::CPAN
$fatpacked{"Test/Deep/ArrayLengthOnly.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_ARRAYLENGTHONLY';
use strict;use warnings;package Test::Deep::ArrayLengthOnly;use Test::Deep::Ref;sub init {my$self=shift;my$val=shift;$self->{val}=$val}sub descend {my$self=shift;my$got=shift;my$len=$self->{val};return @$got==$len}sub render_stack {my$self=shift;my...
TEST_DEEP_ARRAYLENGTHONLY
$fatpacked{"Test/Deep/Blessed.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_BLESSED';
use strict;use warnings;package Test::Deep::Blessed;use Test::Deep::Cmp;use Scalar::Util qw(blessed);sub init {my$self=shift;my$val=shift;$self->{val}=$val}sub descend {my$self=shift;my$got=shift;my$exp=$self->{val};my$blessed=blessed($got);return ...
TEST_DEEP_BLESSED
$fatpacked{"Test/Deep/Boolean.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_BOOLEAN';
use strict;use warnings;package Test::Deep::Boolean;use Test::Deep::Cmp;sub init {my$self=shift;$self->{val}=shift()? 1 : 0}sub descend {my$self=shift;my$got=shift;return!($got xor $self->{val})}sub diag_message {my$self=shift;my$where=shift;return...
TEST_DEEP_BOOLEAN
kritika.fatpack view on Meta::CPAN
$error
EOM
TEST_DEEP_HASHKEYSONLY
$fatpacked{"Test/Deep/Ignore.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_IGNORE';
use strict;use warnings;package Test::Deep::Ignore;use Test::Deep::Cmp;my$Singleton=__PACKAGE__->SUPER::new;sub new {return$Singleton}sub descend {return 1}1;
TEST_DEEP_IGNORE
$fatpacked{"Test/Deep/Isa.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_ISA';
use strict;use warnings;package Test::Deep::Isa;use Test::Deep::Cmp;use Scalar::Util;sub init {my$self=shift;my$val=shift;$self->{val}=$val}sub descend {my$self=shift;my$got=shift;return Scalar::Util::blessed($got)? $got->isa($self->{val}): ref($go...
TEST_DEEP_ISA
$fatpacked{"Test/Deep/ListMethods.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_LISTMETHODS';
use strict;use warnings;package Test::Deep::ListMethods;use base 'Test::Deep::Methods';sub call_method {my$self=shift;return [$self->SUPER::call_method(@_)]}sub render_stack {my$self=shift;my$var=$self->SUPER::render_stack(@_);return "[$var]"}1;
TEST_DEEP_LISTMETHODS
$fatpacked{"Test/Deep/MM.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_MM';
use strict;use warnings;package Test::Deep::MM;sub import {my$self=shift;my ($pkg)=caller();my$mpkg=$pkg."::Methods";for my$attr (@_){if ($attr =~ /^[a-z]/){no strict 'refs';*{$mpkg."::$attr"}=\&{$attr}}else {my$get_name=$mpkg."::get$attr";my$set_n...
TEST_DEEP_MM
kritika.fatpack view on Meta::CPAN
expected : $exp
EOM
TEST_DEEP_NONE
$fatpacked{"Test/Deep/Number.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_NUMBER';
use strict;use warnings;package Test::Deep::Number;use Test::Deep::Cmp;use Scalar::Util;sub init {my$self=shift;$self->{val}=shift(@_)+ 0;$self->{tolerance}=shift}sub descend {my$self=shift;my$got=shift;$self->data->{got_string}=$got;{no warnings '...
TEST_DEEP_NUMBER
$fatpacked{"Test/Deep/Obj.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_OBJ';
use strict;use warnings;package Test::Deep::Obj;use Test::Deep::Cmp;use Scalar::Util;sub init {my$self=shift;my$val=shift;$self->{val}=$val}sub descend {my$self=shift;my$got=shift;return Scalar::Util::blessed($got)&& $got->isa($self->{val})}sub dia...
TEST_DEEP_OBJ
kritika.fatpack view on Meta::CPAN
$fatpacked{"Test/Deep/Ref.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_REF';
use strict;use warnings;package Test::Deep::Ref;use Test::Deep::Cmp;use Scalar::Util qw(blessed);sub test_class {my$self=shift;my$got=shift;my$exp=$self->{val};if ($Test::Deep::Snobby){return Test::Deep::descend($got,Test::Deep::blessed(blessed($ex...
TEST_DEEP_REF
$fatpacked{"Test/Deep/RefType.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_REFTYPE';
use strict;use warnings;package Test::Deep::RefType;use Test::Deep::Cmp;use Scalar::Util qw(reftype);sub init {my$self=shift;$self->{val}=shift}sub descend {my$self=shift;my$got=shift;my$exp=$self->{val};my$reftype=reftype($got);return Test::Deep::...
TEST_DEEP_REFTYPE
$fatpacked{"Test/Deep/Regexp.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_REGEXP';
use strict;use warnings;package Test::Deep::Regexp;use Test::Deep::Cmp;use Test::Deep::RegexpMatches;sub init {my$self=shift;my$val=shift;$val=ref$val ? $val : qr/$val/;$self->{val}=$val;if (my$matches=shift){$self->{matches}=Test::Deep::regexpmatc...
TEST_DEEP_REGEXP
kritika.fatpack view on Meta::CPAN
$fatpacked{"Test/Deep/Shallow.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_SHALLOW';
use strict;use warnings;package Test::Deep::Shallow;use Test::Deep::Cmp;use Scalar::Util qw(refaddr);sub init {my$self=shift;my$val=shift;$self->{val}=$val}sub descend {my$self=shift;my$got=shift;my$exp=$self->{val};my$ok;if (!defined$got and!defin...
TEST_DEEP_SHALLOW
$fatpacked{"Test/Deep/Stack.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_STACK';
use strict;use warnings;package Test::Deep::Stack;use Carp qw(confess);use Scalar::Util;use Test::Deep::MM qw(new init Stack Arrow);sub init {my$self=shift;$self->SUPER::init(@_);$self->setStack([])unless$self->getStack}sub push {my$self=shift;push...
TEST_DEEP_STACK
$fatpacked{"Test/Deep/String.pm"} = '#line '.(1+__LINE__).' "'.__FILE__."\"\n".<<'TEST_DEEP_STRING';
use strict;use warnings;package Test::Deep::String;use Test::Deep::Cmp;sub init {my$self=shift;$self->{val}=shift}sub descend {my$self=shift;my$got=shift()."";$self->data->{got}=$got;return$got eq $self->{val}}sub diag_message {my$self=shift;my$whe...
TEST_DEEP_STRING
view release on metacpan or search on metacpan
lib/App/LXC/Container/Data/Debian.pm view on Meta::CPAN
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
sub content_default_mounts($$@)
{
local $_ = shift;
my @output =
($_->SUPER::content_default_mounts(@_),
'',
'# Debian:',
'/etc/debian_version');
return @output
}
lib/App/LXC/Container/Data/Debian.pm view on Meta::CPAN
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
sub depends_on($$$)
{
my ($self, $package, $include) = @_;
$self->SUPER::depends_on($package, $include);
return () unless $self->_dpkg_status($package);
my @packages = ();
local $_;
# outer loop over all possible dependencies:
lib/App/LXC/Container/Data/Debian.pm view on Meta::CPAN
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
use constant SEARCH => 'dpkg-query --search ';
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',
lib/App/LXC/Container/Data/Debian.pm view on Meta::CPAN
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
use constant LISTFILES => 'dpkg-query --listfiles ';
sub paths_of($$)
{
my ($self, $package) = @_;
$self->SUPER::paths_of($package);
local $_;
# TODO: Better approach to get main architecture?
foreach ('', ':amd64', ':i386')
{
my $pa = $package . $_;
view release on metacpan or search on metacpan
Tickit/TextWidget.pm view on Meta::CPAN
our $VERSION = 0.01;
sub new {
my ($class, %args) = @_;
my $self = $class->SUPER::new(%args);
$self->{'_lines'} = [''];
$self->{'_width'} = 76;
return $self;
}
view release on metacpan or search on metacpan
lib/App/MBUtiny.pm view on Meta::CPAN
touch($self->{voidfile});
# Set DBI
$self->{_dbi} = undef;
return $self->SUPER::again;
}
sub excdir {shift->{excdir}}
sub objdir {shift->{objdir}}
sub rstdir {shift->{rstdir}}
sub getdbi {shift->{_dbi}}
view release on metacpan or search on metacpan
lib/MHFS/EventLoop/Poll/Linux.pm view on Meta::CPAN
use feature 'say';
use parent 'MHFS::EventLoop::Poll::Base';
use MHFS::EventLoop::Poll::Linux::Timer;
sub new {
my $class = shift;
my $self = $class->SUPER::new(@_);
$self->{'evp_timer'} = MHFS::EventLoop::Poll::Linux::Timer->new($self);
return $self;
};
sub add_timer {
my ($self, $start) = @_;
shift @_;
if($self->SUPER::add_timer(@_) == 0) {
say __PACKAGE__.": add_timer, updating linux timer to $start";
$self->{'evp_timer'}->settime_linux($start, 0);
}
};
sub requeue_timers {
my $self = shift @_;
$self->SUPER::requeue_timers(@_);
my ($timers, $current_time) = @_;
if(@{$self->{'timers'}}) {
my $start = $self->{'timers'}[0]{'desired'} - $current_time;
say __PACKAGE__.": requeue_timers, updating linux timer to $start";
$self->{'evp_timer'}->settime_linux($start, 0);
lib/MHFS/EventLoop/Poll/Linux.pm view on Meta::CPAN
}
else {
print "\n";
}
$self->SUPER::do_poll($loop_interval, $poll);
}
};
1;
view release on metacpan or search on metacpan
lib/App/MP4Meta/Film.pm view on Meta::CPAN
sub new {
my $class = shift;
my $args = shift;
my $self = $class->SUPER::new($args);
# Of course, its a movie, but this fixes the
# 'Home Video' problem in iTunes 11.
$self->{'media_type'} = 'Short Film';
view release on metacpan or search on metacpan
lib/App/MaMGal/Entry/Dir.pm view on Meta::CPAN
sub thumbnail_path { $_[0]->{base_name}.'/.mamgal-index.png' }
sub init
{
my $self = shift;
$self->SUPER::init(@_);
if ($self->{dir_name} eq '/' and ($self->{base_name} eq '/' or $self->{base_name} eq '.')) {
$self->{path_name} = '/';
$self->{base_name} = '/';
$self->{is_root} = 1;
} elsif (-e $self->child('.mamgal-root')) {
lib/App/MaMGal/Entry/Dir.pm view on Meta::CPAN
my $code = shift;
my $suffix = shift;
# TODO: this will be an issue when mamgal goes multi-threaded
my $tmp_name = $self->child('.mamgal-tmp');
my $full_name = $self->child($suffix);
$self->SUPER::_write_contents_to($code, $tmp_name, $full_name);
}
sub _side_length
{
my $self = shift;
lib/App/MaMGal/Entry/Dir.pm view on Meta::CPAN
sub containers
{
my $self = shift;
return if $self->is_root;
return $self->SUPER::containers(@_);
}
sub creation_time
{
my $self = shift;
lib/App/MaMGal/Entry/Dir.pm view on Meta::CPAN
}
$self->{cct} = [$oldest, $youngest];
return ($oldest, $youngest) if wantarray;
return $youngest;
}
return $self->SUPER::creation_time;
}
# Returns the most recent of:
# - this directory inode's modification time
# - all of interesting elements' content modification time
sub content_modification_time
{
my $self = shift;
my %opts = @_;
my $own = $self->SUPER::content_modification_time;
return $own if $opts{only_own};
my @elements;
if ($opts{consider_interesting_only}) {
@elements = $self->_all_interesting_elements;
} else {
view release on metacpan or search on metacpan
lib/App/Maisha.pm view on Meta::CPAN
#----------------------------------------------------------------------------
# Public API
sub new {
my $class = shift;
my $self = $class->SUPER::new();
my $config = $self->load_config(@_);
$self->config($config);
$self->setup();
$self;
}
view release on metacpan or search on metacpan
inc/File-ShareDir-Install/File/ShareDir/Install.pm view on Meta::CPAN
# Build the postamble section
sub postamble
{
my $self = shift;
my @ret; # = $self->SUPER::postamble( @_ );
foreach my $def ( @DIRS ) {
push @ret, __postamble_share_dir( $self, $def );
}
return join "\n", @ret;
}
view release on metacpan or search on metacpan
lib/App/MatrixClient/RoomTab.pm view on Meta::CPAN
{
my $self = shift;
if( $self->{typing_line} ) {
my @after = $self->{scroller}->pop;
$self->SUPER::append_line( @_ );
$self->{scroller}->push( @after );
}
else {
$self->SUPER::append_line( @_ );
}
}
sub set_typing_line
{
lib/App/MatrixClient/RoomTab.pm view on Meta::CPAN
$self->{scroller}->pop if delete $self->{typing_line};
# No timestamp
local $self->{timestamp_format};
$self->SUPER::append_line( $self->{typing_line} = $line ) if $line;
}
sub still_typing
{
my $self = shift;
view release on metacpan or search on metacpan
lib/App/MatrixTool/Command/client.pm view on Meta::CPAN
my $self = shift;
my ( $opts, @args ) = @_;
$self->{$_} //= $opts->{$_} for qw( server user_id user_id_parameter );
return $self->SUPER::run( @args );
}
sub do_json
{
my $self = shift;
view release on metacpan or search on metacpan
lib/App/Milter/Limit.pm view on Meta::CPAN
sub _new_instance {
my ($class, $driver) = @_;
croak "usage: new(driver)" unless defined $driver;
my $self = $class->SUPER::_new_instance();
$self->init($driver);
return $self;
}
view release on metacpan or search on metacpan
lib/App/Mimosa/Schema/BCS.pm view on Meta::CPAN
sub deploy {
local $SIG{__WARN__} = sub {
return if $_[0] =~ /^Ignoring relationship/;
warn @_;
};
shift->SUPER::deploy(@_);
}
1;
__END__
view release on metacpan or search on metacpan
contrib/Events.mom view on Meta::CPAN
### Constructor ###
###################
sub module_init {
my ($type) = @_;
my $self = $type->SUPER::module_init($type);
$self->{'events'} = {};
return $self;
};
view release on metacpan or search on metacpan
lib/App/Module/Template/Initialize.pm view on Meta::CPAN
#-------------------------------------------------------------------------------
sub _init {
my ($self, $arg) = @_;
# $self->SUPER::_init($arg);
return;
}
}
view release on metacpan or search on metacpan
lib/App/MojoSlides/Slides.pm view on Meta::CPAN
my $args;
if (@_==1) {
$args = { last => $_[0] } unless ref $_[0];
$args = { list => $_[0] } if ref $_[0] eq 'ARRAY';
}
return $class->SUPER::new($args ? $args : @_);
}
sub prev {
my ($self, $current) = @_;
return $current == $self->first ? $current : $current - 1;
view release on metacpan or search on metacpan
lib/App/MonM/Notifier.pm view on Meta::CPAN
};
sub new {
my $class = shift;
my %args = @_;
my $self = $class->SUPER::new(%args);
# Store
my $store_conf = hash($self->config->conf(NODE_NAME) || $self->config->conf(NODE_NAME_ALIAS));
$store_conf->{expires} = getExpireOffset(lvalue($store_conf, "expires") || lvalue($store_conf, "expire") || 0);
$store_conf->{maxtime} = getExpireOffset(lvalue($store_conf, "maxtime") || 0);
view release on metacpan or search on metacpan
lib/App/MonM.pm view on Meta::CPAN
my $NOTIFIER_LOADED = 1 unless $@;
$NOTIFIER_LOADED = 0 if $NOTIFIER_LOADED && (App::MonM::Notifier->VERSION * 1) < 1.04;
sub again {
my $self = shift;
$self->SUPER::again(); # CTK::App again first!!
# Datadir & Tempdir
if ($self->option("datadir")) {
# Prepare DataDir
preparedir( $self->datadir() ) or do {
view release on metacpan or search on metacpan
lib/App/Mowyw/Datasource/XML.pm view on Meta::CPAN
my $self = bless { OPTIONS => $opts, INDEX => 0 }, $class;
my $file = $opts->{file} or confess "Mandatory option 'file' is missing\n";
$opts->{source} = $self->_read_data($file);
# print Dumper $opts;
$self = $self->SUPER::new($opts);
return $self;
}
sub _read_data {
view release on metacpan or search on metacpan
lib/App/MtAws/HttpSegmentWriter.pm view on Meta::CPAN
sub new
{
my ($class, %args) = @_;
my $self = \%args;
bless $self, $class;
$self->SUPER::initialize();
$self->initialize();
return $self;
}
sub initialize
lib/App/MtAws/HttpSegmentWriter.pm view on Meta::CPAN
sub reinit
{
my $self = shift;
$self->{incr_position} = 0;
$self->{treehash} = App::MtAws::TreeHash->new();
$self->SUPER::reinit(@_);
}
sub treehash { shift->{treehash} }
sub _flush
lib/App/MtAws/HttpSegmentWriter.pm view on Meta::CPAN
}
sub finish
{
my ($self) = @_;
my @r = $self->SUPER::finish();
return @r;
}
package App::MtAws::HttpFileWriter;
lib/App/MtAws/HttpSegmentWriter.pm view on Meta::CPAN
sub new
{
my ($class, %args) = @_;
my $self = \%args;
bless $self, $class;
$self->SUPER::initialize();
$self->initialize();
return $self;
}
sub initialize
lib/App/MtAws/HttpSegmentWriter.pm view on Meta::CPAN
my $self = shift;
undef $self->{fh};
open_file($self->{fh}, $self->{tempfile}, mode => '+<', binary => 1) or confess "cant open file $self->{tempfile} $!";
binmode $self->{fh};
$self->{treehash} = App::MtAws::TreeHash->new();
$self->SUPER::reinit(@_);
}
sub treehash { shift->{treehash} }
sub _flush
lib/App/MtAws/HttpSegmentWriter.pm view on Meta::CPAN
}
sub finish
{
my ($self) = @_;
my @r = $self->SUPER::finish();
close $self->{fh} or confess;
return @r;
}
view release on metacpan or search on metacpan
lib/App/MultiLanguage/LDAP.pm view on Meta::CPAN
my $self = shift;
$self->{search_args} = \@_;
$self->_search;
$self->SUPER::parse();
}
sub _connect {
my $self = shift;
view release on metacpan or search on metacpan
lib/App/MultiModule/Collector.pm view on Meta::CPAN
sub new {
my $proto = shift;
my $class = ref($proto) || $proto;
my %args = @_;
$args{collector_name} = 'unknown' unless $args{collector_name};
# my $self = $class->SUPER::new();
my $self = {};
$self->{collector_name} = $args{collector_name};
bless ($self, $class);
return $self;
}
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
$self->do_system( App::Netdisco::Util::Python::py_install() );
}
sub ACTION_install {
my $self = shift;
$self->SUPER::ACTION_install;
$self->ACTION_python;
}
1;