vim-snippets/snippets/perl.snippets

# #!/usr/bin/perl
snippet #!
	#!/usr/bin/perl

# Hash Pointer
snippet .
	 =>
# Function
snippet sub
	sub ${1:function_name} {
		${2:#body ...}
	}
# Conditional
snippet if
	if (${1}) {
		${2:# body...}
	}
# Conditional if..else
snippet ife
	if (${1}) {
		${2:# body...}
	}
	else {
		${3:# else...}
	}
# Conditional if..elsif..else
snippet ifee
	if (${1}) {
		${2:# body...}
	}
	elsif (${3}) {
		${4:# elsif...}
	}
	else {
		${5:# else...}
	}
# Conditional One-line
snippet xif
	${1:expression} if ${2:condition};${3}
# Unless conditional
snippet unless
	unless (${1}) {
		${2:# body...}
	}
# Unless conditional One-line
snippet xunless
	${1:expression} unless ${2:condition};${3}
# Try/Except
snippet eval
	local $@;
	eval {
		${1:# do something risky...}
	};
	if (my $e = $@) {
		${2:# handle failure...}
	}
# While Loop
snippet wh
	while (${1}) {
		${2:# body...}
	}
# While Loop One-line
snippet xwh
	${1:expression} while ${2:condition};${3}
# C-style For Loop
snippet cfor
	for (my $${2:var} = 0; $$2 < ${1:count}; $$2${3:++}) {
		${4:# body...}
	}
# For loop one-line
snippet xfor
	${1:expression} for @${2:array};${3}
# Foreach Loop
snippet for
	foreach my $${1:x} (@${2:array}) {
		${3:# body...}
	}
# Foreach Loop One-line
snippet fore
	${1:expression} foreach @${2:array};${3}
# Package
snippet cl
	package ${1:ClassName};

	use base qw(${2:ParentClass});

	sub new {
		my $class = shift;
		$class = ref $class if ref $class;
		my $self = bless {}, $class;
		$self;
	}

	1;${3}
# Read File
snippet slurp
	my $${1:var} = do { local $/; open my $file, '<', "${2:file}"; <$file> };
	${3}


# strict warnings
snippet strwar
	use strict;
	use warnings;


# standard versioning with perlcritic bypass
snippet vers
	## no critic
	our $VERSION = '${1:version}';
	eval $VERSION;
	## use critic


# new 'switch' like feature
snippet switch
	use feature 'switch';



# Anonymous subroutine
snippet asub
	sub { 
	 	${1:# body }
	}



# Begin block
snippet begin
	BEGIN {
		${1:# begin body}
	}

# call package function with some parameter
snippet pkgmv  
	__PACKAGE__->${1:package_method}(${2:var})

# call package function without a parameter
snippet pkgm  
	__PACKAGE__->${1:package_method}()

# call package "get_" function without a parameter
snippet pkget  
	__PACKAGE__->get_${1:package_method}()

# call package function with a parameter
snippet pkgetv  
	__PACKAGE__->get_${1:package_method}(${2:var})

# complex regex
snippet qrx
	qr/
	     ${1:regex}
	/xms

#simpler regex
snippet qr/
	qr/${1:regex}/x

#given
snippet given
	given ($${1:var}) { 
		${2:# cases}
		${3:# default}
	} 

# switch-like case
snippet when
	when (${1:case}) {
		${2:# body}
	}

# hash slice
snippet hslice
	@{ ${1:hash}  }{ ${2:array} }



# map
snippet map
	map {  ${2: body }    }  ${1: @array } ;



# Pod stub
snippet ppod
	=head1 NAME

	${1:ClassName} - ${2:ShortDesc}

	=head1 SYNOPSIS
	
	  use $1;

	  ${3:# synopsis...}

	=head1 DESCRIPTION

	${4:# longer description...}


	=head1 INTERFACE

	
	=head1 DEPENDENCIES


	=head1 SEE ALSO


# Heading for a subroutine stub
snippet psub
	=head2 ${1:MethodName}

	${2:Summary....}

# Heading for inline subroutine pod
snippet psubi
	=head2 ${1:MethodName}

	${2:Summary...}


	=cut


# Subroutine signature
snippet parg
	=over 2

	=item
	Arguments

	
	=over 3

	=item
	C<${1:DataStructure}>

	  ${2:Sample}


	=back


	=item
	Return

	=over 3


	=item
	C<${3:...return data}>


	=back
	


	=back



# Moose package
snippet moosecl
	package ${1:ClassName};
	
	use Moose;
	#extends '${2:# ParentClass}';

	${6:# body of class}

	1;


	__END__

	=head1 NAME

	$1 - ${3:ShortDesc}

	=head1 SYNOPSIS

	${4:# synopsis...}

	=head1 DESCRIPTION

	${5:# longer description...}


# Moose has
snippet has
	has ${1:attribute} => (
		is	=> '${2:ro|rw}',
		isa 	=> '${3:Str|Int|HashRef|ArrayRef|etc}',
		default => ${4:defaultvalue}
		,${5:# other attributes}
	);


# override
snippet override
	override ${1:attribute} => sub {
		${2:# my $self = shift;};
		${3:# my ($self,$args) = @_;};
	};


# use test classes
snippet tuse
	use Test::More;
	use Test::Deep ();
	use Test::Exception;

# local test lib
snippet tlib
	use lib qw{ ./t/lib };

#test methods
snippet tmeths
	$ENV{TEST_METHOD} = '${1:regex}';

# runtestclass
snippet trunner
	use ${1:test_class};
	$1->runtests();

# Test::Class-style test
snippet tsub
	sub t${1:number}_${2:test_case} :Test(${3:num_of_tests}) {
		my $self = shift;
		${4:#  body}
		
	}

# Test::Routine-style test
snippet trsub
	test ${1:test_name} => { description => '${2:Description of test.}'} => sub {
		my ($self) = @_;
		${3:# test code}
	};

#prep test method
snippet tprep
	sub prep${1:number}_${2:test_case} :Test(startup) {
		my $self = shift;
		${4:#  body}
	}
# cause failures to print stack trace
snippet debug_trace
	use Carp; # 'verbose';
	# cloak "die"
	# warn "warning"
	$SIG{'__DIE__'} = sub {
		require Carp; Carp::confess
	};