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}" );
}
################ Chord objects: Roman ################
lib/ChordPro/Chords/Parser.pm view on Meta::CPAN
return $res;
}
sub chord_display ( $self ) {
$self->SUPER::chord_display
( $::config->{"chord-formats"}->{roman}
// "%{name}" );
}
################ Chord objects: Annotations ################
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;
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/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(@_);
}