view release on metacpan or  search on metacpan

lib/Vim/Helper/Plugin.pm  view on Meta::CPAN

    _gen_accessor( $caller, $_ ) for keys %config_keys;
}

sub new {
    my $class = shift;
    return bless {} => $class;
}

sub args  { {} }
sub opts  { {} }
sub vimrc { "" }

 view release on metacpan or  search on metacpan

WSDLTest.pm  view on Meta::CPAN

sub new {
	my $class = shift;
	my $param = shift;
	my $self = { 'param1' => $param->{param1},
	             'param2' => $param->{param2} };
	return bless $self => $class;
}


# test1($msg)
#

 view release on metacpan or  search on metacpan

lib/WSRF/Lite.pm  view on Meta::CPAN

				ref $_[1]                                    ? return $_[1]
				  : Carp::croak $_[0]->transport->is_success ? $_[1]
				  : $_[0]->transport->status;
			},
		};
		bless $self => $class;
		$self->on_nonserialized(    $self->on_nonserialized
								 || $self->serializer->on_nonserialized );
		SOAP::Trace::objects('()');
	}

 view release on metacpan or  search on metacpan

lib/WWW/Connpass/Event/Participant.pm  view on Meta::CPAN

use strict;
use warnings;

sub new {
    my $class = shift;
    bless {@_} => $class;
}

sub answer {
    my ($self, $index) = @_;
    return $self->{"answer_$index"};

 view release on metacpan or  search on metacpan

lib/WWW/Deezer.pm  view on Meta::CPAN

        debug   => 0,
    };

    $self->{ua}->agent("WWW::Deezer v".$VERSION);

    bless $self => $class;
    return $self;
}

sub album {
    my ($self, $p) = @_;

 view release on metacpan or  search on metacpan

lib/WWW/Mechanize/PhantomJS.pm  view on Meta::CPAN

    if ( $@ ) {
        kill 9, delete $options{ pid } if $options{ kill_pid };
        die $@;
    }

     my $self= bless \%options => $class;

     $self->eval_in_phantomjs(<<'JS');
         var page= this;
         page.errors= [];
         page.alerts= [];

 view release on metacpan or  search on metacpan

lib/WWW/Moviepilot.pm  view on Meta::CPAN

=cut

sub new {
    my ($class, $args) = @_;
    my $self = bless {} => $class;
    $self->{api_key} = $args->{api_key} || croak "api_key is missing at " . __PACKAGE__ . "->new()";
    $self->{host}    = $args->{host}    || 'www.moviepilot.de';
    $self->{ua}      = $args->{ua}      || LWP::UserAgent->new;

    $self->{host} = 'http://' . $self->{host} unless $self->{host} =~ m{^http://};

 view release on metacpan or  search on metacpan

lib/WWW/PGXN.pm  view on Meta::CPAN

our $VERSION = v0.13.0;

sub new {
    my($class, %params) = @_;
    my $self = bless {} => $class;
    for my $key (qw(url proxy)) {
        $self->$key($params{$key}) if exists $params{$key}
    }
    return $self;
}

 view release on metacpan or  search on metacpan

lib/WWW/StreamSend.pm  view on Meta::CPAN

        xs  => XML::Simple->new,
    };

    $self->{ua}->agent("Mozilla/5.0");

    bless $self => $class;
    return $self;
}

sub get_emails {
    my ($self) = @_;

 view release on metacpan or  search on metacpan

lib/WebService/Bluga/Webthumb.pm  view on Meta::CPAN

    if (exists $params{cache_dir} && ! exists $params{cache_url_stub}) {
        croak "Must supply cache_url_stub if you supply cache_dir";
    }

    my $self = \%params;
    bless $self => $class;

    $self->{ua} = LWP::UserAgent->new(
        agent => __PACKAGE__ . '/' . $VERSION,
        timeout => $params{timeout} || 3,
    );

 view release on metacpan or  search on metacpan

inc/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/WebSocket/Version.pm  view on Meta::CPAN

    my $req  = shift( @_ ) || return( $self->error( "No WebSocket::Request object was provided." ) );
    return( $self->error( "Object provided (", overload::StrVal( $req ), ") is not a WebSocket::Request object." ) ) if( !$self->_is_a( $req, 'WebSocket::Request' ) );
    my $h = $req->headers || return( $self->error( "Unable to find the WebSocket::Headers object." ) );
    unless( ref( $self ) )
    {
        $self = bless( {} => $class )->SUPER::init( @_ );
    }
    my $new;
    # From version 4 onward
    if( $h->header( 'Sec-WebSocket-Version' )->length ||
        $h->header( 'Sec-WebSocket-Key' )->length )

 view release on metacpan or  search on metacpan

lib/Weewar.pm  view on Meta::CPAN

{ package Weewar::UA;
  use base 'LWP::UserAgent';
  sub new {
      my ($class, $args) = @_;
      $args ||= {};
      bless $args => $class;
  }
  sub get_basic_credentials {
      my $self = shift;
      return unless $self->{username};
      return (map {$self->{$_}} qw/username password/);

 view release on metacpan or  search on metacpan

lib/Win32/Wlan.pm  view on Meta::CPAN

                }
                $args{interface} = $interfaces[0];
            }
        }
    }
    bless \%args => $class;
};


sub DESTROY {
    my ($self) = @_;

 view release on metacpan or  search on metacpan

lib/Workflow/Factory.pm  view on Meta::CPAN

    my $log = get_logger(__PACKAGE__);
    unless ( $INSTANCES{$class} ) {
        $log->debug( "Creating empty instance of '$class' factory for ",
                     "singleton use" );
        my $instance = bless {} => $class;
        $instance->init();
        $INSTANCES{$class} = $instance;
    }
    return $INSTANCES{$class};
}

 view release on metacpan or  search on metacpan

lib/XML/DOMBacked.pm  view on Meta::CPAN

}

sub new {
  my $class = shift;
  my $self  = {};
  bless $self => $class;
  my $init  = eval { $self->init( @_ ) };
  if (!$init) {
    my $mesg = "could not initialise object";
    if ( $@ ) { $mesg .= ': ' . $@ }
    die $mesg;

 view release on metacpan or  search on metacpan

lib/XML/DT/Sequence.pm  view on Meta::CPAN

=cut

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

sub break {
    my $self = shift;
    $self->{BREAK} = 1;

 view release on metacpan or  search on metacpan

lib/XML/Parser/LiteCopy.pm  view on Meta::CPAN

sub new {
    my $class = shift;

    return $class if ref $class;
    my $self = bless {} => $class;

    my %parameters = @_;
    $self->setHandlers(); # clear first
    $self->setHandlers(%{$parameters{Handlers} || {}});

 view release on metacpan or  search on metacpan

lib/XML/Parser/Lite.pm  view on Meta::CPAN

sub new {
    my $class = shift;

    return $class if ref $class;
    my $self = bless {} => $class;

    my %parameters = @_;
    $self->setHandlers(); # clear first
    $self->setHandlers(%{$parameters{Handlers} || {}});

 view release on metacpan or  search on metacpan

lib/XML/Smart/HTMLParser.pm  view on Meta::CPAN

sub new { 
  my $this = shift ;
  my $class = ref($this) || $this ;
  return $this if ref $this ;

  $this = bless {} => $class ;
  
  _unset_sig_warn() ;
  my %args = @_ ;
  _reset_sig_warn() ;
  $this->setHandlers(%args) ;

 view release on metacpan or  search on metacpan

lib/XMLRPC/Test.pm  view on Meta::CPAN

package My::PingPong; # we'll use this package in our tests

sub new {
  my $self = shift;
  my $class = ref($self) || $self;
  bless {_num=>shift} => $class;
}

sub next {
  my $self = shift;
  $self->{_num}++;

 view release on metacpan or  search on metacpan

lib/XS/Framework/Manual/SVAPI/Stash.pod  view on Meta::CPAN

This C<bless> method version works somewhat similiar to the following Perl
construction

    my $class = ...;
    my $obj = ...;
    return bless $obj => $class;

i.e. if C<what> is already an object, it is blessed into the C<Stash>,
otherwise new C<RV*> created from the C<what> argument, and the
blessed object returned.

 view release on metacpan or  search on metacpan

lib/ZMachine/ZSCII.pm  view on Meta::CPAN

      if exists $guts->{zscii_for}{ $unicode_char };

    $guts->{zscii_for}{ $unicode_char } = $zscii_char;
  }

  my $self = bless $guts => $class;

  # The default alphabet is entirely made up of characters that are the same in
  # Unicode and ZSCII.  If a user wants to put "extra characters" into the
  # alphabet table, though, the alphabet should contain ZSCII values.  When
  # we're building a ZMachine::ZSCII using the contents of the story file's

 view release on metacpan or  search on metacpan

local/lib/perl5/App/Cmd/Command.pm  view on Meta::CPAN

#pod
#pod =cut

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

#pod =method execute
#pod
#pod   $command_plugin->execute(\%opt, \@args);

 view release on metacpan or  search on metacpan

lib/aliased/factory.pm  view on Meta::CPAN

=cut

my $new_factory = sub {
  my $class = shift;
  bless \(shift) => $class;
};

my $err;

my $load = sub {

 view release on metacpan or  search on metacpan

lib/Net/Delicious/Simple.pm  view on Meta::CPAN

	return unless my $del = Net::Delicious->new({
    %$config,
    updates => File::Temp::tempdir(CLEANUP => 1),
  });

	bless { del => $del } => $class;
}

=head2 tags

This returns all of your tags, in a list.

 view release on metacpan or  search on metacpan

lib/Git/Deploy/Hook.pm  view on Meta::CPAN

use strict;
use warnings FATAL => "all";

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

1;

 view release on metacpan or  search on metacpan

lib/macro.pm  view on Meta::CPAN

}

sub new :method{
	my($class) = @_;

	return bless {} => $class;
}

sub defmacro :method{
	my $self = shift;

 view release on metacpan or  search on metacpan

lib/ModPerl/CScan.pm  view on Meta::CPAN

        "$Cpp->{cppstdin} $Defines $addincludes $Cpp->{cppflags} $filename |" :
        "echo '\#include \"$filename\"' | $Cpp->{cppstdin} $Defines $addincludes $Cpp->{cppflags} $Cpp->{cppminus} | grep -v '^#' |";
    #my $cmd = "echo '\#include <$filename>' | $Cpp->{cppstdin} $Defines $addincludes $Cpp->{cppflags} $Cpp->{cppminus} |";

    (open($sym, $cmd) or die "Cannot open pipe from `$cmd': $!")
      and bless $sym => $class;
}

sub text {
  my $class = shift;
  my $filter = shift;

 view release on metacpan or  search on metacpan

Porting/corelist-perldelta.pl  view on Meta::CPAN

  use Pod::Simple::SimpleTree;

  sub new {
    my ($class, $input) = @_;

    my $self = bless {} => $class;

    my $parsed_pod = Pod::Simple::SimpleTree->new->parse_file($input)->root;
    splice @{ $parsed_pod }, 0, 2; # we don't care about the document structure,
                                   # just the nodes within it