view release on metacpan or search on metacpan
lib/Tangram/Expr/CursorObject.pm view on Meta::CPAN
my $classes = $schema->{classes};
$schema->check_class($class);
my @tables;
my $table_hash = { };
my $self = bless { storage => $storage, tables => \@tables, class => $class,
table_hash => $table_hash }, $pkg;
my %seen;
for my $part ($storage->{engine}->get_parts($schema->classdef($class))) {
view release on metacpan or search on metacpan
lib/Taskwarrior/Kusarigama/Wrapper/Exception.pm view on Meta::CPAN
# ABSTRACT: Exception class for Taskwarrior::Kusarigama::Wrapper
$Taskwarrior::Kusarigama::Wrapper::Exception::VERSION = '0.12.0';
use strict;
use warnings;
sub new { my $class = shift; bless { @_ } => $class }
use overload (
q("") => '_stringify',
fallback => 1,
);
view release on metacpan or search on metacpan
lib/App/LiquidTidy.pm view on Meta::CPAN
use Template::Liquid;
use Template::LiquidX::Tidy::Tag::include;
use Template::LiquidX::Tidy::Tag::post_url;
sub new ($class, $args) {
bless $args => $class
}
sub run ($self) {
die "No file name specified\n" unless $self->{file};
my $fh;
view release on metacpan or search on metacpan
lib/Term/Caca/Bitmap.pm view on Meta::CPAN
use Term::Caca;
sub new {
my ($class, $bpp, $w, $h, $pitch, $rmask, $gmask, $bmask, $amask) = @_;
my $self = Term::Caca::_create_bitmap($bpp, $w, $h, $pitch, $rmask, $gmask, $bmask, $amask);
return bless($self => $class);
}
sub set_palette {
my ($self, $red, $green, $blue, $alpha) = @_;
return Term::Caca::_set_bitmap_palette($self, $red, $green, $blue, $alpha);
view release on metacpan or search on metacpan
Interact.pm view on Meta::CPAN
}
sub new {
my $class = shift;
my $self = bless {} => $class;
my $args = $self->process_args( @_ );
for (keys %{ $args }) {
$self->{$_} = $args->{$_};
}
return $self;
view release on metacpan or search on metacpan
lib/Term/Screen/Uni.pm view on Meta::CPAN
{ $self->{'handler'} = eval 'use Term::Screen; return Term::Screen->new();'; };
if (!defined($self->{'handler'}))
{ croak("Can not create Term::Screen handler: ".$@); };
return bless $self => $class;
};
1;
__END__
view release on metacpan or search on metacpan
lib/Term/Screen/Win32.pm view on Meta::CPAN
$self->{'console'}->Mode(ENABLE_PROCESSED_INPUT);
at($self, 0, 0);
%{$self->{'def_key'}} = %def_key;
return bless $self => $class;
};
sub cleanup
{
$_[0]->normal();
view release on metacpan or search on metacpan
lib/Term/Scroller.pm view on Meta::CPAN
defined(my $pid = fork) or croak "unable to fork: $!";
# Parent: Return the new scroller
if ($pid) {
bless $pty => $class;
${*$pty}{'term_scroller_pid'} = $pid;
return $pty;
}
################################################
view release on metacpan or search on metacpan
lib/Test/AutoMock/Mock/TieArray.pm view on Meta::CPAN
use warnings;
sub TIEARRAY {
my ($class, $manager) = @_;
bless \$manager => $class;
}
sub FETCH {
my ($self, $key) = @_;
my $manager = $$self;
view release on metacpan or search on metacpan
lib/Test/CVE.pm view on Meta::CPAN
$self{meta_yml} ||= "META.yml";
$self{make_pl} ||= "Makefile.PL";
$self{build_pl} ||= "Build.PL";
$self{CVE} = {};
ref $self{want} or $self{want} = [ $self{want} ]; # new->(want => "Foo")
my $obj = bless \%self => $class;
$obj->skip ($self{skip} // "CVE.SKIP");
return $obj;
} # new
sub skip {
view release on metacpan or search on metacpan
lib/App/Prove/State/Result.pm view on Meta::CPAN
my ( $class, $arg_for ) = @_;
$arg_for ||= {};
my %instance_data = %$arg_for; # shallow copy
$instance_data{version} = $class->state_version;
my $tests = delete $instance_data{tests} || {};
my $self = bless \%instance_data => $class;
$self->_initialize($tests);
return $self;
}
sub _initialize {
view release on metacpan or search on metacpan
lib/Test/Mock/Guard.pm view on Meta::CPAN
++$stash->{$class_name}->{$method_name}->{called_count};
&$mocked_method;
}, $prototype);
}
}
return bless { restore => $restore, object => $object } => $class;
}
sub call_count {
my ($self, $klass, $method_name) = @_;
view release on metacpan or search on metacpan
lib/Test/Mock/Object/Chain.pm view on Meta::CPAN
my $last = pop @$chain;
while ( my $method = pop @$chain ) {
$last = _add_link( $method => $last );
}
return blessed $last ? $last : bless $last => $class;
}
sub _add_link {
my ( $method, $value ) = @_;
my $class = __PACKAGE__;
lib/Test/Mock/Object/Chain.pm view on Meta::CPAN
else {
croak("Aref components in method chains must be [\$link, $value]");
}
}
else {
return bless { $method => $value } => $class;
}
}
sub AUTOLOAD {
my $self = shift;
view release on metacpan or search on metacpan
lib/Test/Ranger.pm view on Meta::CPAN
if ( (reftype $self)->array ) {
$self = Test::Ranger::List->new($self);
}
else {
bless ($self => $class);
$self->init();
};
return $self;
}; ## new
view release on metacpan or search on metacpan
lib/Test/Reporter/Transport/HTTPGateway.pm view on Meta::CPAN
my ($class, $url, $key) = @_;
die "invalid gateway URL: must be absolute http or https URL"
unless $url =~ /\Ahttps?:/i;
bless { gateway => $url, key => $key } => $class;
}
sub send {
my ($self, $report) = @_;
view release on metacpan or search on metacpan
Fallback.pm view on Meta::CPAN
$args{'__metabase'} = Test::Reporter::Transport::Metabase->new( map { $_ => $args{$_} } grep { $args{$_} } @metabase_allowed_args );
$args{'max_files'} = $MAX_FILES unless $args{'max_files'};
return bless \%args => $class;
}
sub send {
my ($self, $report) = @_;
view release on metacpan or search on metacpan
lib/Test/Reporter/Transport/Metabase.pm view on Meta::CPAN
for my $k ( keys %args ) {
Carp::confess __PACKAGE__ . " unknown argument '$k'\n"
unless grep { $k eq $_ } @allowed_args;
}
return bless \%args => $class;
}
#--------------------------------------------------------------------------#
# send
#--------------------------------------------------------------------------#
view release on metacpan or search on metacpan
lib/Test/Reporter/Transport/Net/SMTP/Authen.pm view on Meta::CPAN
print STDERR "\to conf commit\n";
}
sub new {
my ($class, @args) = @_;
bless { args => \@args } => $class;
}
sub _net_class {
my ($self) = @_;
my $class = ref $self ? ref $self : $self;
view release on metacpan or search on metacpan
lib/Test/Reporter/Transport/Socket.pm view on Meta::CPAN
if ( ref $args{host} eq 'ARRAY' and !scalar @{ $args{host} } ) {
Carp::confess __PACKAGE__ . " requires 'host' argument to have elements if it is an arrayref\n";
}
return bless \%args => $class;
}
sub send {
my ($self, $report) = @_;
view release on metacpan or search on metacpan
lib/Test/Reporter/Transport/File.pm view on Meta::CPAN
my ($class, $dir) = @_;
die "target directory '$dir' doesn't exist or can't be written to"
unless -d $dir && -w $dir;
return bless { dir => $dir } => $class;
}
sub send {
my ($self, $report) = @_;
$report->dir( $self->{dir} );
view release on metacpan or search on metacpan
lib/Test/SharedObject/Lock.pm view on Meta::CPAN
sub new {
my ($class, $shared) = @_;
open my $fh, '+<:raw', $shared->{file} or die "failed to open temporary file: $shared->{file}: $!"; # uncoverable branch
flock $fh, LOCK_EX;
return bless { fh => $fh } => $class;
}
sub fh { shift->{fh} }
sub DESTROY {
view release on metacpan or search on metacpan
lib/Test/Unit/Lite.pm view on Meta::CPAN
sub new {
my ($class) = @_;
$class = ref $class if ref $class;
my $self = {};
return bless $self => $class;
}
sub set_up { }
sub tear_down { }
lib/Test/Unit/Lite.pm view on Meta::CPAN
'errors' => 0,
'failures' => 0,
'passes' => 0,
};
return bless $self => $class;
}
sub messages {
my ($self) = @_;
return $self->{messages};
lib/Test/Unit/Lite.pm view on Meta::CPAN
my $self = {
'name' => defined $name ? $name : 'Test suite',
'units' => [],
};
return bless $self => $class;
}
sub new {
my ($class, $test) = @_;
lib/Test/Unit/Lite.pm view on Meta::CPAN
else {
require Carp;
Carp::croak(sprintf("usage: %s->new([CLASSNAME | TEST])\n", __PACKAGE__));
}
return bless $self => $class;
}
sub name {
return $_[0]->{name};
}
lib/Test/Unit/Lite.pm view on Meta::CPAN
my $self = {
'suite' => undef,
'fh_out' => $fh_out,
'fh_err' => $fh_err,
};
return bless $self => $class;
}
sub fh_out {
my ($self) = @_;
return $self->{fh_out};
view release on metacpan or search on metacpan
lib/Test/Unit/Assertion/CodeRef.pm view on Meta::CPAN
sub new {
my $class = shift;
my $code = shift;
croak "$class\::new needs a CODEREF" unless ref($code) eq 'CODE';
bless \$code => $class;
}
sub do_assertion {
my $self = shift;
my $possible_object = $_[0];
view release on metacpan or search on metacpan
t/04-return-value-capturing.t view on Meta::CPAN
{
package ValueHolder;
sub new {
my ($class, $value) = @_;
my $self = bless {} => $class;
$self->set_attr($value);
return $self;
}
sub set_attr {
my ($self, $value) = @_;
view release on metacpan or search on metacpan
lib/Test/WriteVariants.pm view on Meta::CPAN
sub new
{
my ($class, %args) = @_;
my $self = bless {} => $class;
for my $attribute (qw(allow_dir_overwrite allow_file_overwrite))
{
next unless exists $args{$attribute};
$self->$attribute(delete $args{$attribute});
view release on metacpan or search on metacpan
lib/Text/Bidi.pm view on Meta::CPAN
my $self = {
tie_byte => 'Text::Bidi::Array::Byte',
tie_long => 'Text::Bidi::Array::Long',
@_
};
bless $self => $class
}
sub tie_byte {
my $self = shift;
view release on metacpan or search on metacpan
lib/Text/CSV/Simple.pm view on Meta::CPAN
=cut
sub new {
my $class = shift;
return bless { _parser => Text::CSV_XS->new(@_), } => $class;
}
sub _parser { shift->{_parser} }
sub _file {
view release on metacpan or search on metacpan
lib/Text/CSV_PP/Simple.pm view on Meta::CPAN
use Text::CSV_PP;
use IO::File;
sub new {
my $class = shift;
return bless { _parser => Text::CSV_PP->new(@_), } => $class;
}
sub field_map {
my $self = shift;
if (@_) {
view release on metacpan or search on metacpan
lib/Text/FrontMatter/YAML.pm view on Meta::CPAN
=cut
sub new {
my $class = shift;
my $self = {};
bless $self => $class;
my %args = @_;
# make sure we get something to init with
unless (
view release on metacpan or search on metacpan
lib/Text/Index.pm view on Meta::CPAN
};
$self->{keywords}{$_->[0]} = $clone;
}
}
return bless $self => $class;
}
=item add_page
Adds a page to the index object. The page is expected to be