641 lines
11 KiB
Text
641 lines
11 KiB
Text
snippet <?
|
|
<?php
|
|
|
|
${0}
|
|
snippet ec
|
|
echo ${0};
|
|
snippet <?e
|
|
<?php echo ${0} ?>
|
|
# this one is for php5.4
|
|
snippet <?=
|
|
<?=${0}?>
|
|
snippet ?=
|
|
<?= ${0} ?>
|
|
snippet ?
|
|
<?php ${0} ?>
|
|
snippet ?f
|
|
<?php foreach ($${1:vars} as $${2:$var}): ?>
|
|
${0}
|
|
<?php endforeach ?>
|
|
snippet ?i
|
|
<?php if ($${1:var}): ?>
|
|
${0}
|
|
<?php endif ?>
|
|
snippet ns
|
|
namespace ${1:Foo\Bar\Baz};
|
|
${0}
|
|
snippet use
|
|
use ${1:Foo\Bar\Baz};
|
|
${0}
|
|
snippet c
|
|
class ${1:`vim_snippets#Filename()`}
|
|
{
|
|
${0}
|
|
}
|
|
snippet i
|
|
interface ${1:`vim_snippets#Filename()`}
|
|
{
|
|
${0}
|
|
}
|
|
snippet t.
|
|
$this->
|
|
snippet f
|
|
function ${1}(${3})
|
|
{
|
|
${0}
|
|
}
|
|
# method
|
|
snippet m
|
|
${1:protected} function ${2:foo}()
|
|
{
|
|
${0}
|
|
}
|
|
# setter method
|
|
snippet sm
|
|
/**
|
|
* Sets the value of ${1:foo}
|
|
*
|
|
* @param ${2:$1} $$1 ${3:description}
|
|
*
|
|
* @return ${4:`vim_snippets#Filename()`}
|
|
*/
|
|
${5:public} function set${6:$2}(${7:$2 }$$1)
|
|
{
|
|
$this->${8:$1} = $$1;
|
|
return $this;
|
|
}
|
|
# getter method
|
|
snippet gm
|
|
/**
|
|
* Gets the value of ${1:foo}
|
|
*
|
|
* @return ${2:$1}
|
|
*/
|
|
${3:public} function get${4:$2}()
|
|
{
|
|
return $this->${5:$1};
|
|
}
|
|
#setter
|
|
snippet $s
|
|
${1:$foo}->set${2:Bar}(${0});
|
|
#getter
|
|
snippet $g
|
|
${1:$foo}->get${0:Bar}();
|
|
|
|
# Tertiary conditional
|
|
snippet =?:
|
|
$${1:foo} = ${2:true} ? ${3:a} : ${0};
|
|
snippet ?:
|
|
${1:true} ? ${2:a} : ${0}
|
|
|
|
snippet C
|
|
$_COOKIE['${1:variable}']
|
|
snippet E
|
|
$_ENV['${1:variable}']
|
|
snippet F
|
|
$_FILES['${1:variable}']
|
|
snippet G
|
|
$_GET['${1:variable}']
|
|
snippet P
|
|
$_POST['${1:variable}']
|
|
snippet R
|
|
$_REQUEST['${1:variable}']
|
|
snippet S
|
|
$_SERVER['${1:variable}']
|
|
snippet SS
|
|
$_SESSION['${1:variable}']
|
|
|
|
# the following are old ones
|
|
snippet inc
|
|
include '${1:file}';
|
|
snippet inc1
|
|
include_once '${1:file}';
|
|
snippet req
|
|
require '${1:file}';
|
|
snippet req1
|
|
require_once '${1:file}';
|
|
# Start Docblock
|
|
snippet /*
|
|
/**
|
|
* ${0}
|
|
*/
|
|
# Class - post doc
|
|
snippet doc_cp
|
|
/**
|
|
* ${1:undocumented class}
|
|
*
|
|
* @package ${2:default}
|
|
* @subpackage ${3:default}
|
|
* @author ${4:`g:snips_author`}
|
|
*/
|
|
# Class Variable - post doc
|
|
snippet doc_vp
|
|
/**
|
|
* ${1:undocumented class variable}
|
|
*
|
|
* @var ${2:string}
|
|
*/
|
|
# Class Variable
|
|
snippet doc_v
|
|
/**
|
|
* ${3:undocumented class variable}
|
|
*
|
|
* @var ${4:string}
|
|
*/
|
|
${1:var} $${2};
|
|
# Class
|
|
snippet doc_c
|
|
/**
|
|
* ${3:undocumented class}
|
|
*
|
|
* @package ${4:default}
|
|
* @subpackage ${5:default}
|
|
* @author ${6:`g:snips_author`}
|
|
*/
|
|
${1:}class ${2:}
|
|
{
|
|
${0}
|
|
} // END $1class $2
|
|
# Constant Definition - post doc
|
|
snippet doc_dp
|
|
/**
|
|
* ${1:undocumented constant}
|
|
*/
|
|
# Constant Definition
|
|
snippet doc_d
|
|
/**
|
|
* ${3:undocumented constant}
|
|
*/
|
|
define(${1}, ${2});
|
|
# Function - post doc
|
|
snippet doc_fp
|
|
/**
|
|
* ${1:undocumented function}
|
|
*
|
|
* @return ${2:void}
|
|
* @author ${3:`g:snips_author`}
|
|
*/
|
|
# Function signature
|
|
snippet doc_s
|
|
/**
|
|
* ${4:undocumented function}
|
|
*
|
|
* @return ${5:void}
|
|
* @author ${6:`g:snips_author`}
|
|
*/
|
|
${1}function ${2}(${3});
|
|
# Function
|
|
snippet doc_f
|
|
/**
|
|
* ${4:undocumented function}
|
|
*
|
|
* @return ${5:void}
|
|
* @author ${6:`g:snips_author`}
|
|
*/
|
|
${1}function ${2}(${3})
|
|
{${0}
|
|
}
|
|
# Header
|
|
snippet doc_h
|
|
/**
|
|
* ${1}
|
|
*
|
|
* @author ${2:`g:snips_author`}
|
|
* @version ${3:$Id$}
|
|
* @copyright ${4:$2}, `strftime('%d %B, %Y')`
|
|
* @package ${0:default}
|
|
*/
|
|
|
|
# Interface
|
|
snippet interface
|
|
/**
|
|
* ${2:undocumented class}
|
|
*
|
|
* @package ${3:default}
|
|
* @author ${4:`g:snips_author`}
|
|
*/
|
|
interface ${1:`vim_snippets#Filename()`}
|
|
{
|
|
${0}
|
|
}
|
|
# Trait
|
|
snippet trait
|
|
/**
|
|
* ${2:undocumented class}
|
|
*
|
|
* @package ${3:default}
|
|
* @author ${4:`g:snips_author`}
|
|
*/
|
|
trait ${1:`vim_snippets#Filename()`}
|
|
{
|
|
${0}
|
|
}
|
|
# class ...
|
|
snippet class
|
|
/**
|
|
* ${1}
|
|
*/
|
|
class ${2:`vim_snippets#Filename()`}
|
|
{
|
|
${3}
|
|
/**
|
|
* ${4}
|
|
*/
|
|
${5:public} function ${6:__construct}(${7:argument})
|
|
{
|
|
${0}
|
|
}
|
|
}
|
|
snippet nc
|
|
namespace ${1:`substitute(substitute(expand("%:h"), '\v^\w+\/(\u)', '\1', ''), '\/', '\\\', 'g')`};
|
|
|
|
${2:abstract }class ${3:`vim_snippets#Filename()`}
|
|
{
|
|
${0}
|
|
}
|
|
# define(...)
|
|
snippet def
|
|
define('${1}'${2});
|
|
# defined(...)
|
|
snippet def?
|
|
${1}defined('${2}')
|
|
snippet wh
|
|
while (${1:/* condition */}) {
|
|
${0}
|
|
}
|
|
# do ... while
|
|
snippet do
|
|
do {
|
|
${0}
|
|
} while (${1:/* condition */});
|
|
snippet if
|
|
if (${1:/* condition */}) {
|
|
${0}
|
|
}
|
|
snippet ifn
|
|
if (!${1:/* condition */}) {
|
|
${2}
|
|
}
|
|
snippet ifil
|
|
<?php if (${1:/* condition */}): ?>
|
|
${0}
|
|
<?php endif; ?>
|
|
snippet ife
|
|
if (${1:/* condition */}) {
|
|
${2}
|
|
} else {
|
|
${3}
|
|
}
|
|
${0}
|
|
snippet ifeil
|
|
<?php if (${1:/* condition */}): ?>
|
|
${2:<!-- html... -->}
|
|
<?php else: ?>
|
|
${3:<!-- html... -->}
|
|
<?php endif; ?>
|
|
${0}
|
|
snippet el
|
|
else {
|
|
${0}
|
|
}
|
|
snippet eif
|
|
elseif (${1}) {
|
|
${0}
|
|
}
|
|
snippet switch
|
|
switch ($${1:variable}) {
|
|
case '${2:value}':
|
|
${3}
|
|
break;
|
|
${0}
|
|
default:
|
|
${4}
|
|
break;
|
|
}
|
|
snippet case
|
|
case '${1:value}':
|
|
${2}
|
|
break;
|
|
snippet for
|
|
for ($${2:i} = 0; $$2 < ${1:count}; $$2${3:++}) {
|
|
${0}
|
|
}
|
|
snippet foreach
|
|
foreach ($${1:variable} as $${2:value}) {
|
|
${0}
|
|
}
|
|
snippet foreachil
|
|
<?php foreach ($${1:variable} as $${2:value}): ?>
|
|
${0:<!-- html... -->}
|
|
<?php endforeach; ?>
|
|
snippet foreachk
|
|
foreach ($${1:variable} as $${2:key} => $${3:value}) {
|
|
${0}
|
|
}
|
|
snippet foreachkil
|
|
<?php foreach ($${1:variable} as $${2:key} => $${3:value}): ?>
|
|
${0:<!-- html... -->}
|
|
<?php endforeach; ?>
|
|
# $... = array (...)
|
|
snippet array b
|
|
$${1:arrayName} = array('${2}' => ${3});
|
|
snippet try
|
|
try {
|
|
${0}
|
|
} catch (${1:Exception} $e) {
|
|
}
|
|
# lambda with closure
|
|
snippet lambda
|
|
${1:static }function (${2:args}) use (${3:&$x, $y /*put vars in scope (closure) */}) {
|
|
${0}
|
|
};
|
|
# pre_dump();
|
|
snippet pd
|
|
echo '<pre>'; var_dump(${0}); echo '</pre>';
|
|
# pre_dump(); die();
|
|
snippet pdd
|
|
echo '<pre>'; var_dump(${1}); echo '</pre>'; die(${0:});
|
|
snippet vd
|
|
var_dump(${0});
|
|
snippet vdd
|
|
var_dump(${1}); die(${0:});
|
|
snippet pr
|
|
print_r(${0});
|
|
snippet prs
|
|
print_r(${0}, 1);
|
|
snippet vdf
|
|
error_log(print_r($${1:foo}, true), 3, '${2:/tmp/debug.log}');
|
|
snippet http_redirect
|
|
header ("HTTP/1.1 301 Moved Permanently");
|
|
header ("Location: ".URL);
|
|
exit();
|
|
# Getters & Setters
|
|
snippet gs
|
|
/**
|
|
* Gets the value of ${1:foo}
|
|
*
|
|
* @return ${2:$1}
|
|
*/
|
|
public function get${3:$2}()
|
|
{
|
|
return $this->${4:$1};
|
|
}
|
|
|
|
/**
|
|
* Sets the value of $1
|
|
*
|
|
* @param $2 $$1 ${5:description}
|
|
*
|
|
* @return ${6:`vim_snippets#Filename()`}
|
|
*/
|
|
public function set$3(${7:$2 }$$1)
|
|
{
|
|
$this->$4 = $$1;
|
|
return $this;
|
|
}
|
|
# anotation, get, and set, useful for doctrine
|
|
snippet ags
|
|
/**
|
|
* ${1:description}
|
|
*
|
|
* @${0}
|
|
*/
|
|
${2:protected} $${3:foo};
|
|
|
|
public function get${4:$3}()
|
|
{
|
|
return $this->$3;
|
|
}
|
|
|
|
public function set$4(${5:$4 }$${6:$3})
|
|
{
|
|
$this->$3 = $$6;
|
|
return $this;
|
|
}
|
|
snippet rett
|
|
return true;
|
|
snippet retf
|
|
return false;
|
|
snippet am
|
|
$${1:foo} = array_map(function($${2:v}) {
|
|
${0}
|
|
return $$2;
|
|
}, $$1);
|
|
snippet aw
|
|
array_walk($${1:foo}, function(&$${2:v}, $${3:k}) {
|
|
$$2 = ${0};
|
|
});
|
|
|
|
# static var assign once
|
|
snippet static_var
|
|
static $${1} = null;
|
|
if (is_null($$1)){
|
|
$$1 = ${2};
|
|
}
|
|
|
|
snippet CSVWriter
|
|
<?php
|
|
|
|
class CSVWriter {
|
|
public function __construct($file_or_handle, $sep = "\t", $quot = '"'){
|
|
$args = func_get_args();
|
|
$mode = isset($opts['mode']) ? $opts['mode'] : 'w';
|
|
|
|
$this->f =
|
|
is_string($file_or_handle)
|
|
? fopen($file_or_handle, $mode)
|
|
: $file_or_handle;
|
|
|
|
$this->fputcsv_args = array($this->f, null, $sep, $quot);
|
|
|
|
if (!$this->f) throw new Exception('bad file descriptor');
|
|
}
|
|
|
|
public function write($row){
|
|
$this->fputcsv_args[1] =& $row;
|
|
call_user_func_array('fputcsv', $this->fputcsv_args);
|
|
}
|
|
|
|
public function close(){
|
|
if (!is_null($this->f))
|
|
fclose($this->f);
|
|
$this->f = null;
|
|
}
|
|
|
|
public function __destruct(){
|
|
$this->close();
|
|
}
|
|
|
|
}
|
|
|
|
snippet CSVIterator
|
|
|
|
// http://snipplr.com/view.php?codeview&id=1986 // modified
|
|
class CSVIterator implements Iterator
|
|
{
|
|
private $f;
|
|
private $curr;
|
|
private $rowCounter;
|
|
|
|
/* opts keys:
|
|
* row_size
|
|
* escape
|
|
* enclosure
|
|
* delimiter
|
|
*/
|
|
public function __construct( $file_or_handle, $opts = array(4096, ',') )
|
|
{
|
|
$d = function($n) use(&$opts){ return isset($opts[$n]) ? $opts[$n] : false; };
|
|
|
|
$this->combine = $d('combine');
|
|
$this->headers = $d('headers');
|
|
$this->headerCheckFunction = $d('header_check_function');
|
|
|
|
$this->f =
|
|
is_string($file_or_handle)
|
|
? fopen( $file_or_handle, 'r' )
|
|
: $file_or_handle;
|
|
if (!$this->f) throw new Exception('bad file descriptor');
|
|
$this->fgetcsv_args = array(
|
|
$this->f,
|
|
isset($opts['row_size']) ? $opts['row_size'] : 4096,
|
|
isset($opts['delimiter']) ? $opts['delimiter'] : ',',
|
|
isset($opts['enclosure']) ? $opts['enclosure'] : '"',
|
|
isset($opts['escape']) ? $opts['escape'] : '\\',
|
|
);
|
|
$this->start();
|
|
}
|
|
|
|
protected function readRow(){
|
|
$this->curr = call_user_func_array('fgetcsv', $this->fgetcsv_args );
|
|
$this->rowCounter++;
|
|
if ($this->rowCounter == 1){
|
|
$this->processHeader();
|
|
} elseif ($this->curr) {
|
|
$this->processRow();
|
|
}
|
|
}
|
|
|
|
public function processHeader(){
|
|
if ($this->headers || $this->combine){
|
|
$this->header = $this->curr;
|
|
if ($this->headerCheckFunction){
|
|
$f = $this->headerCheckFunction;
|
|
$f($this->header);
|
|
}
|
|
$this->readRow();
|
|
}
|
|
}
|
|
|
|
public function processRow(){
|
|
if ($this->combine)
|
|
$this->curr = array_combine($this->header, $this->curr);
|
|
}
|
|
|
|
public function start(){
|
|
$this->rowCounter = 0;
|
|
rewind( $this->f );
|
|
$this->readRow();
|
|
}
|
|
|
|
public function rewind()
|
|
{
|
|
$this->start();
|
|
}
|
|
|
|
public function current()
|
|
{
|
|
$curr = $this->curr;
|
|
$this->readRow();
|
|
return $curr;
|
|
}
|
|
|
|
public function key()
|
|
{
|
|
return $this->rowCounter;
|
|
}
|
|
|
|
public function next()
|
|
{
|
|
return $this->curr;
|
|
}
|
|
|
|
public function valid(){
|
|
if( !$this->next() )
|
|
{
|
|
fclose( $this->f );
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
} // end class
|
|
|
|
snippet is
|
|
isset($1{VISUAL})
|
|
|
|
# phpunit
|
|
snippet ase
|
|
$this->assertEquals(${1:expected}, ${2:actual});
|
|
|
|
snippet asne
|
|
$this->assertNotEquals(${1:expected}, ${2:actual});
|
|
|
|
snippet asf
|
|
$this->assertFalse(${1:Something});
|
|
|
|
snippet ast
|
|
$this->assertTrue(${1:Something});
|
|
|
|
snippet asfex
|
|
$this->assertFileExists(${1:path/to/file});
|
|
|
|
snippet asfnex
|
|
$this->assertFileNotExists(${1:path/to/file});
|
|
|
|
snippet ascon
|
|
$this->assertContains(${1:Search Value}, ${2:Array or Iterator});
|
|
|
|
snippet ashk
|
|
$this->assertArrayHasKey(${1:key}, ${2:array});
|
|
|
|
snippet asnhk
|
|
this->assertArrayNotHasKey(${1:value}, ${2:array});
|
|
|
|
snippet ascha
|
|
$this->assertClassHasAttribute('${1:Attribute Name}', '${2:ClassName}');
|
|
|
|
snippet asi
|
|
$this->assertInstanceOf(${1:expected}, ${2:actual});
|
|
|
|
snippet tc
|
|
public function test${1:name_of_the_test}()
|
|
{
|
|
${0:code}
|
|
}
|
|
snippet te
|
|
throw new ${1:Exception}("${2:Error Processing Request}");
|
|
|
|
snippet fpc "file_put_contents" b
|
|
file_put_contents(${1:file}, ${2:content}${3:, FILE_APPEND});$0
|
|
|
|
snippet sr "str_replace"
|
|
str_replace(${1:search}, ${2:replace}, ${3:subject})$0
|
|
|
|
snippet ia "in_array"
|
|
in_array(${1:needle}, ${2:haystack})$0
|
|
|
|
snippet is "isset"
|
|
isset(${1:var})$0
|
|
|
|
snippet isa "isset array"
|
|
isset($${1:array}[${2:key}])$0
|
|
|
|
snippet in "is_null"
|
|
is_null($${1:var})$0
|
|
|
|
snippet fe "file_exists"
|
|
file_exists(${1:file})$0
|
|
|
|
snippet id "is_dir"
|
|
is_dir(${1:path})$0
|