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/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 { }

 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

 view release on metacpan or  search on metacpan

Kakasi.pm  view on Meta::CPAN

}

sub new{
    my $thingy = shift;
    my $class = ref $thingy ? ref $thingy : $thingy;
    my $self = bless {} => $class;
    @_ and $self->set(@_);
    return $self
}

my %k2p = 

 view release on metacpan or  search on metacpan

lib/Text/Markup.pm  view on Meta::CPAN

sub format_matchers { %REGEX_FOR }

sub new {
    my $class = shift;
    bless { default_encoding => 'UTF-8', @_ } => $class;
}

sub parse {
    my $self = shift;
    my %p = @_;

 view release on metacpan or  search on metacpan

Repository.pm  view on Meta::CPAN

# Instantiates a new instance.  There is very little setup here;
# all the work (adding paths, etc) is handled by add_path.
#
sub new {
    my $class = shift;
    my $self = bless [ { }, [ ], \@_, ] => $class;
    $self->add_path(@_);

    return $self;
}

 view release on metacpan or  search on metacpan

TemplateFill.pm  view on Meta::CPAN

		'StartPageTag'	=>	' ',		# Which tag to use to auto start a page, undef doesn't work - space is dodge
		'EndPageTag'	=>	' ',		# Which tag to use to auto end a page
		'CalcHandle'	=>	$CalcHandle,	# For calculations
	);

	return bless \%template => $class;
}

# Set an option in the %template.
sub SetOpt {
	my $self = shift @_;

 view release on metacpan or  search on metacpan

lib/Text/WordDiff.pm  view on Meta::CPAN

package Text::WordDiff::Base;

sub new {
    my ($class, $opts) = @_;
    return bless { %{$opts} } => $class;
}


sub file_header  {
    my $self = shift;

 view release on metacpan or  search on metacpan

t/900_bugs/033_ex_safe_render.t  view on Meta::CPAN

use Test::More;
use File::Temp qw(tempdir);

{
    package MyCounter;
    sub new { my $class = shift;bless {@_} => $class }
    sub incr  { shift->{count}++ }
    sub decr  { shift->{count}-- }
    sub count { shift->{count} }
}

 view release on metacpan or  search on metacpan

lib/Tie/Amazon/S3.pm  view on Meta::CPAN

    my $list = $self->{BUCKET}->list_all or $self->s3_croak;
    map { $key{$_} => sub { $self->{BUCKET}->get_key($_)
                                or $self->s3_croak; } }
        @{ $list->{keys} };
    $self->{KEYS} = \%key;
    bless $self => $class;
}

=head2 STORE

Store some scalar into an S3 bucket (Perl hash) key.

 view release on metacpan or  search on metacpan

lib/Tie/Counter.pm  view on Meta::CPAN

sub TIESCALAR {
    my $class     =   shift;
    my $value     =   shift;  #  ?? 0;  # Would have been nice....
       $value     =   0 unless defined $value;
    bless \$value => $class;
}

sub FETCH     {
    ${+shift} ++;
}

 view release on metacpan or  search on metacpan

lib/Tie/FlipFlop.pm  view on Meta::CPAN

sub TIESCALAR {
    my $class = shift;
    do {require Carp;
        Carp::croak ("Incorrect number of arguments");
    } unless 2 == @_;
    bless [reverse @_] => $class;
}

sub FETCH     {
    my $state = shift;
     (@$state = reverse @$state) [0]

 view release on metacpan or  search on metacpan

Google.pm  view on Meta::CPAN

# results are keyed by query.
# ----------------------------------------------------------------------
sub new {
    my ($class, $type, $KEY, $query, $options) = @_;
    $options = { } unless defined $options && ref($options) eq 'HASH';
    my $self = bless [ $KEY, $type, $query, $options, { }, undef, ] => $class;

    # Is $KEY actually a file?
    # I do this in DBD::google as well; perhaps there I should submit
    # a patch to Aaron so that Net::Google can do this directly.
    if (-e $KEY) {

 view release on metacpan or  search on metacpan

Persistent.pm  view on Meta::CPAN

# main workhorse
#
sub _new {
  my ($class, $type, $file, $mode, $other) = @_;
  my $self = [];
  bless $self => $class;
  $mode = lc($mode);
  $self->[1]  = $type;		# keep for easier DESTROY
  $self->[2]  = $file;		# must be given
  $self->[3]  = $mode || 'r';	# mode defaults to read-only
  $self->[4]  = $Autosync;      # default to global

 view release on metacpan or  search on metacpan

lib/Tie/Pick.pm  view on Meta::CPAN

sub TIESCALAR {
    my $class  =   shift;
    do { require Carp;
         Carp::croak ("tie needs more arguments")
    } unless @_;
    bless [@_] => $class;
}

sub FETCH     {
    my $values = shift;
    return undef unless @$values;

 view release on metacpan or  search on metacpan

lib/Tie/Reduce.pm  view on Meta::CPAN

	no warnings 'uninitialized';
	if (ref($coderef) ne 'CODE') {
		require Carp;
		Carp::croak("Expected coderef; got $coderef");
	}
	bless [$initial_value, $coderef] => $class;
}

sub get_value {
	$_[0][0];
}

 view release on metacpan or  search on metacpan

lib/Tie/SaveLater.pm  view on Meta::CPAN

	    if $types2check{$type} and !$self->isa($type);
    }else{
	$self = 
	    { HASH => {}, ARRAY => [], SCALAR => \do{ my $scalar }}->{$type};
    }
    bless $self => $class.'::'.$type;
    $DEBUG and carp sprintf("tied $filename => 0x%x", 0+$self);
    @_ and $self->options(@_);
    $self->_regobj($filename);
    $self;
}

 view release on metacpan or  search on metacpan

lib/Tie/Symbol.pm  view on Meta::CPAN

    my $classname = ref $class || $class;

    my $self = { ns => "$namespace", };

    bless $self => $classname;
}

sub FETCH {
    my ( $self, $name, $force ) = @_;
    return $self->{$name} if ( not $force and scalar caller eq __PACKAGE__ );

 view release on metacpan or  search on metacpan

lib/Time/Duration/Object.pm  view on Meta::CPAN

#pod =cut

sub new {
	my ($class, $duration) = @_;
	return unless defined $duration;
	bless \$duration => $class;
}

#pod =head2 C< seconds >
#pod
#pod This returns the number of seconds in the duration (i.e., the argument you