439 lines
7.4 KiB
Plaintext
439 lines
7.4 KiB
Plaintext
# Snippets for Go
|
|
|
|
priority -10
|
|
|
|
# shorthand variable declaration
|
|
snippet : "v := value"
|
|
${1} := ${0}
|
|
endsnippet
|
|
|
|
# anonymous function
|
|
snippet anon "fn := func() { ... }"
|
|
${1:fn} := func() {
|
|
${2:${VISUAL}}
|
|
}
|
|
${0}
|
|
endsnippet
|
|
|
|
# append
|
|
snippet ap "append(slice, value)"
|
|
append(${1:slice}, ${0:value})
|
|
endsnippet
|
|
|
|
# append assignment
|
|
snippet ap= "a = append(a, value)"
|
|
${1:slice} = append($1, ${0:value})
|
|
endsnippet
|
|
|
|
# break
|
|
snippet br "break"
|
|
break
|
|
endsnippet
|
|
|
|
# channel
|
|
snippet ch "chan Type"
|
|
chan ${0:int}
|
|
endsnippet
|
|
|
|
# case
|
|
snippet case "case ...:"
|
|
case ${1:value}:
|
|
${0:${VISUAL}}
|
|
endsnippet
|
|
|
|
# constant
|
|
snippet con "const XXX Type = ..."
|
|
const ${1:NAME} ${2:Type} = ${0:0}
|
|
endsnippet
|
|
|
|
# constants
|
|
snippet cons "const ( ... )"
|
|
const (
|
|
${1:NAME} ${2:Type} = ${3:value}
|
|
${0}
|
|
)
|
|
endsnippet
|
|
|
|
# constants with iota
|
|
snippet iota "const ( ... = iota )"
|
|
const (
|
|
${1:NAME} ${2:Type} = iota
|
|
${0}
|
|
)
|
|
endsnippet
|
|
|
|
# continue
|
|
snippet cn "continue"
|
|
continue
|
|
endsnippet
|
|
|
|
# default case
|
|
snippet default "default: ..."
|
|
default:
|
|
${0:${VISUAL}}
|
|
endsnippet
|
|
|
|
# defer
|
|
snippet df "defer someFunction()"
|
|
defer ${1:func}(${2})
|
|
${0}
|
|
endsnippet
|
|
|
|
snippet def "defer func() { ... }"
|
|
defer func() {
|
|
${0:${VISUAL}}
|
|
}()
|
|
endsnippet
|
|
|
|
# defer recover
|
|
snippet defr
|
|
defer func() {
|
|
if err := recover(); err != nil {
|
|
${0:${VISUAL}}
|
|
}
|
|
}()
|
|
endsnippet
|
|
|
|
# gpl
|
|
snippet gpl
|
|
/*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
* Copyright (C) ${1:Author}, `strftime("%Y")`
|
|
*/
|
|
${0}
|
|
endsnippet
|
|
|
|
# import
|
|
snippet import "import ( ... )"
|
|
import (
|
|
"${1:package}"
|
|
)
|
|
endsnippet
|
|
|
|
# full interface snippet
|
|
snippet interface "interface I { ... }"
|
|
type ${1:Interface} interface {
|
|
${2:/* TODO: add methods */}
|
|
}
|
|
endsnippet
|
|
|
|
# if condition
|
|
snippet if "if ... { ... }"
|
|
if ${1:condition} {
|
|
${0:${VISUAL}}
|
|
}
|
|
endsnippet
|
|
|
|
# else snippet
|
|
snippet else
|
|
else {
|
|
${0:${VISUAL}}
|
|
}
|
|
endsnippet
|
|
|
|
# error snippet
|
|
snippet errn "Error return " !b
|
|
if err != nil {
|
|
return err
|
|
}
|
|
${0}
|
|
endsnippet
|
|
|
|
# error multiple return
|
|
snippet errn, "Error return with two return values" !b
|
|
if err != nil {
|
|
return ${1:nil}, err
|
|
}
|
|
${0}
|
|
endsnippet
|
|
|
|
# error panic
|
|
snippet errp "Error panic" !b
|
|
if err != nil {
|
|
panic(${1})
|
|
}
|
|
${0}
|
|
endsnippet
|
|
|
|
# error test
|
|
snippet errt "Error test fatal " !b
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
${0}
|
|
endsnippet
|
|
|
|
# error handle
|
|
snippet errh "Error handle and return" !b
|
|
if err != nil {
|
|
${1}
|
|
return
|
|
}
|
|
${0}
|
|
endsnippet
|
|
|
|
# json field tag
|
|
snippet json "\`json:key\`"
|
|
\`json:"${1:`!v go#util#snippetcase(matchstr(getline("."), '\w\+'))`}"\`
|
|
endsnippet
|
|
|
|
# fallthrough
|
|
snippet ft "fallthrough"
|
|
fallthrough
|
|
endsnippet
|
|
|
|
# for loop
|
|
snippet for "for ... { ... }"
|
|
for ${1} {
|
|
${0:${VISUAL}}
|
|
}
|
|
endsnippet
|
|
|
|
# for integer loop
|
|
snippet fori "for 0..N-1 { ... }"
|
|
for ${1:i} := 0; $1 < ${2:N}; $1++ {
|
|
${0:${VISUAL}}
|
|
}
|
|
endsnippet
|
|
|
|
# for range loop
|
|
snippet forr "for k, v := range items { ... }"
|
|
for ${2:k}, ${3:v} := range ${1} {
|
|
${0:${VISUAL}}
|
|
}
|
|
endsnippet
|
|
|
|
# function
|
|
snippet func "func Function(...) [error] { ... }"
|
|
func ${1:name}(${2:params})${3/(.+)/ /}`!p opening_par(snip, 3)`$3`!p closing_par(snip, 3)` {
|
|
${0:${VISUAL}}
|
|
}
|
|
endsnippet
|
|
|
|
# Fmt Printf debug
|
|
snippet ff "fmt.Printf(...)"
|
|
fmt.Printf("${1:${VISUAL}} = %+v\n", $1)
|
|
endsnippet
|
|
|
|
# Fmt Println debug
|
|
snippet fn "fmt.Println(...)"
|
|
fmt.Println("${1:${VISUAL}}")
|
|
endsnippet
|
|
|
|
# log printf
|
|
snippet lf "log.Printf(...)"
|
|
log.Printf("${1:${VISUAL}} = %+v\n", $1)
|
|
endsnippet
|
|
|
|
# log println
|
|
snippet ln "log.Println(...)"
|
|
log.Println("${1:${VISUAL}}")
|
|
endsnippet
|
|
|
|
# make
|
|
snippet make "make(Type, size)"
|
|
make(${1:[]string}, ${2:0})${0}
|
|
endsnippet
|
|
|
|
# map
|
|
snippet map "map[Type]Type"
|
|
map[${1:string}]${0:int}
|
|
endsnippet
|
|
|
|
# main()
|
|
snippet main "func main() { ... }"
|
|
func main() {
|
|
${0:${VISUAL}}
|
|
}
|
|
endsnippet
|
|
|
|
# method
|
|
snippet meth "func (self Type) Method(...) [error] { ... }"
|
|
func (${1:receiver} ${2:type}) ${3:name}(${4:params})${5/(.+)/ /}`!p opening_par(snip, 5)`$5`!p closing_par(snip, 5)` {
|
|
${0:${VISUAL}}
|
|
}
|
|
endsnippet
|
|
|
|
# ok
|
|
snippet ok "if !ok { ... }"
|
|
if !ok {
|
|
${0:${VISUAL}}
|
|
}
|
|
endsnippet
|
|
|
|
# package
|
|
snippet package "package ..."
|
|
// Package $1 provides ${2:...}
|
|
package ${1:main}
|
|
${0}
|
|
endsnippet
|
|
|
|
# panic
|
|
snippet pn "panic()"
|
|
panic("${0:msg}")
|
|
endsnippet
|
|
|
|
# return
|
|
snippet rt "return"
|
|
return ${0:${VISUAL}}
|
|
endsnippet
|
|
|
|
# select
|
|
snippet select "select { case a := <-chan: ... }"
|
|
select {
|
|
case ${1:v1} := <-${2:chan1}
|
|
${0}
|
|
}
|
|
endsnippet
|
|
|
|
# struct
|
|
snippet st "type T struct { ... }"
|
|
type ${1:Type} struct {
|
|
${0}
|
|
}
|
|
endsnippet
|
|
|
|
# switch
|
|
snippet switch "switch x { ... }"
|
|
switch ${1:var} {
|
|
case ${2:value1}:
|
|
${0}
|
|
}
|
|
endsnippet
|
|
|
|
# sprintf
|
|
snippet sp "fmt.Sprintf(...)"
|
|
fmt.Sprintf("%${1:s}", ${2:var})
|
|
endsnippet
|
|
|
|
# goroutine named function
|
|
snippet go "go someFunc(...)"
|
|
go ${1:funcName}(${0})
|
|
endsnippet
|
|
|
|
# goroutine anonymous function
|
|
snippet gof "go func() { ... }()"
|
|
go func() {
|
|
${1:${VISUAL}}
|
|
}()
|
|
${0}
|
|
endsnippet
|
|
|
|
# test function
|
|
snippet test "func TestXYZ(t *testing.T) { ... }"
|
|
func Test${1:Function}(t *testing.T) {
|
|
${0:${VISUAL}}
|
|
}
|
|
endsnippet
|
|
|
|
snippet hf "http.HandlerFunc" !b
|
|
func ${1:handler}(w http.ResponseWriter, r *http.Request) {
|
|
${0:fmt.Fprintf(w, "hello world")}
|
|
}
|
|
endsnippet
|
|
|
|
snippet hhf "mux.HandleFunc" !b
|
|
${1:http}.HandleFunc("${2:/}", func(w http.ResponseWriter, r *http.Request) {
|
|
${0:fmt.Fprintf(w, "hello world")}
|
|
})
|
|
endsnippet
|
|
|
|
# quick test server
|
|
snippet tsrv "httptest.NewServer"
|
|
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
fmt.Fprintln(w, ${1:`response`})
|
|
}))
|
|
defer ts.Close()
|
|
|
|
${0:someUrl} = ts.URL
|
|
endsnippet
|
|
|
|
# test error handling
|
|
snippet ter "if err != nil { t.Errorf(...) }"
|
|
if err != nil {
|
|
t.Errorf("${0:message}")
|
|
}
|
|
endsnippet
|
|
|
|
# test fatal error
|
|
snippet terf "if err != nil { t.Fatalf(...) }"
|
|
if err != nil {
|
|
t.Fatalf("${0:message}")
|
|
}
|
|
endsnippet
|
|
|
|
snippet example "func ExampleXYZ() { ... }"
|
|
func Example${1:Method}() {
|
|
${0:${VISUAL}}
|
|
// Output:
|
|
}
|
|
endsnippet
|
|
|
|
snippet benchmark "func BenchmarkXYZ(b *testing.B) { ... }"
|
|
func Benchmark${1:Method}(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
${0:${VISUAL}}
|
|
}
|
|
}
|
|
endsnippet
|
|
|
|
# variable declaration
|
|
snippet var "var x Type [= ...]"
|
|
var ${1:x} ${2:Type}${3: = ${0:value}}
|
|
endsnippet
|
|
|
|
# variables declaration
|
|
snippet vars "var ( ... )"
|
|
var (
|
|
${1:x} ${2:Type}${3: = ${0:value}}
|
|
)
|
|
endsnippet
|
|
|
|
# equals fails the test if exp is not equal to act.
|
|
snippet eq "equals: test two identifiers with DeepEqual"
|
|
if !reflect.DeepEqual(${1:expected}, ${2:actual}) {
|
|
_, file, line, _ := runtime.Caller(0)
|
|
fmt.Printf("%s:%d:\n\n\texp: %#v\n\n\tgot: %#v\n\n", filepath.Base(file), line, $1, $2)
|
|
t.FailNow()
|
|
}
|
|
endsnippet
|
|
|
|
global !p
|
|
|
|
import re
|
|
|
|
# Automatically wrap return types with parentheses
|
|
|
|
def return_values(s):
|
|
# remove everything wrapped in parentheses
|
|
s = re.sub("\(.*?\)|\([^)]*$", "", s)
|
|
return len(s.split(","))
|
|
|
|
def opening_par(snip, pos):
|
|
if return_values(t[pos]) > 1 and not t[pos].startswith("("):
|
|
snip.rv = "("
|
|
else:
|
|
snip.rv = ""
|
|
|
|
def closing_par(snip, pos):
|
|
if return_values(t[pos]) > 1:
|
|
snip.rv = ")"
|
|
else:
|
|
snip.rv = ""
|
|
|
|
endglobal
|
|
|
|
# vim:ft=snippets:
|