mirror of
https://github.com/amix/vimrc
synced 2025-07-06 16:05:01 +08:00
Removed vim-go
This commit is contained in:
Amir Salihefendic
@ -1,401 +0,0 @@
|
||||
# shorthand variable declaration
|
||||
snippet :
|
||||
abbr v := value
|
||||
${1} := ${0}
|
||||
# anonymous function
|
||||
snippet anon
|
||||
abbr fn := func() { ... }
|
||||
${1:fn} := func() {
|
||||
${0}
|
||||
}
|
||||
# append
|
||||
snippet ap
|
||||
abbr append(slice, value)
|
||||
append(${1:slice}, ${0:value})
|
||||
# append assign
|
||||
snippet ap=
|
||||
abbr slice = append(slice, value)
|
||||
${1:slice} = append($1, ${0:value})
|
||||
# break
|
||||
snippet br
|
||||
abbr break
|
||||
break
|
||||
# channel
|
||||
snippet ch
|
||||
abbr chan Type
|
||||
chan ${0:int}
|
||||
# case
|
||||
snippet case
|
||||
abbr case ...:
|
||||
case ${1:value}:
|
||||
${0}
|
||||
# constant
|
||||
snippet con
|
||||
abbr const XXX Type = ...
|
||||
const ${1:NAME} ${2:Type} = ${0:0}
|
||||
# constants
|
||||
snippet cons
|
||||
abbr const ( ... )
|
||||
const (
|
||||
${1:NAME} ${2:Type} = ${3:value}
|
||||
${0}
|
||||
)
|
||||
# constants with iota
|
||||
snippet iota
|
||||
abbr const ( ... = iota )
|
||||
const (
|
||||
${1:NAME} ${2:Type} = iota
|
||||
${0}
|
||||
)
|
||||
# continue
|
||||
snippet cn
|
||||
abbr continue
|
||||
continue
|
||||
# default case
|
||||
snippet default
|
||||
abbr default: ...
|
||||
default:
|
||||
${0}
|
||||
|
||||
# defer
|
||||
snippet df
|
||||
abbr defer someFunction()
|
||||
defer ${1:func}(${2})
|
||||
${0}
|
||||
snippet def
|
||||
abbr defer func() { ... }
|
||||
defer func() {
|
||||
${0}
|
||||
}()
|
||||
# defer recover
|
||||
snippet defr
|
||||
defer func() {
|
||||
if err := recover(); err != nil {
|
||||
${0}
|
||||
}
|
||||
}()
|
||||
# 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}
|
||||
# import
|
||||
snippet import
|
||||
abbr import ( ... )
|
||||
import (
|
||||
"${1:package}"
|
||||
)
|
||||
# full interface snippet
|
||||
snippet interface
|
||||
abbr interface I { ... }
|
||||
type ${1:Interface} interface {
|
||||
${2:/* TODO: add methods */}
|
||||
}
|
||||
# if condition
|
||||
snippet if
|
||||
abbr if ... { ... }
|
||||
if ${1:condition} {
|
||||
${0}
|
||||
}
|
||||
# else snippet
|
||||
abbr else { ... }
|
||||
snippet else
|
||||
else {
|
||||
${0}
|
||||
}
|
||||
|
||||
# if inline error
|
||||
snippet ife
|
||||
abbr if err := ...; err != nil { ... }
|
||||
if err := ${1:condition}; err != nil {
|
||||
${0}
|
||||
}
|
||||
|
||||
# error snippet
|
||||
snippet errn
|
||||
abbr if err != nil { return err }
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
${0}
|
||||
# error snippet in TestFunc
|
||||
snippet errt
|
||||
abbr if err != nil { t.Fatal(err) }
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
# error snippet in log.Fatal
|
||||
snippet errl
|
||||
abbr if err != nil { log.Fatal(err) }
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
||||
# error snippet with two return values
|
||||
snippet errn,
|
||||
abbr if err != nil { return [...], err }
|
||||
if err != nil {
|
||||
return ${1:nil}, err
|
||||
}
|
||||
${0}
|
||||
|
||||
# error snippet handle and return
|
||||
snippet errh
|
||||
abbr if err != nil { ... return }
|
||||
if err != nil {
|
||||
${1}
|
||||
return
|
||||
}
|
||||
${0}
|
||||
|
||||
# error snippet with panic
|
||||
snippet errp
|
||||
abbr if err != nil { panic(...) }
|
||||
if err != nil {
|
||||
panic(${1})
|
||||
}
|
||||
${0}
|
||||
|
||||
# json snippet
|
||||
snippet json
|
||||
abbr \`json:key\`
|
||||
\`json:"${1:keyName}"\`
|
||||
|
||||
# yaml snippet
|
||||
snippet yaml
|
||||
abbr \`yaml:key\`
|
||||
\`yaml:"${1:keyName}"\`
|
||||
|
||||
# fallthrough
|
||||
snippet ft
|
||||
abbr fallthrough
|
||||
fallthrough
|
||||
# for loop
|
||||
snippet for
|
||||
abbr for ... { ... }
|
||||
for ${1} {
|
||||
${0}
|
||||
}
|
||||
# for integer loop
|
||||
snippet fori
|
||||
abbr for 0..N-1 { ... }
|
||||
for ${1:i} := 0; $1 < ${2:N}; $1++ {
|
||||
${0}
|
||||
}
|
||||
# for range loop
|
||||
snippet forr
|
||||
abbr for k, v := range items { ... }
|
||||
for ${2:k}, ${3:v} := range ${1} {
|
||||
${0}
|
||||
}
|
||||
# function
|
||||
snippet func
|
||||
abbr func function(...) [error] { ... }
|
||||
func ${1:function}(${2}) ${3:error }{
|
||||
${0}
|
||||
}
|
||||
# Fmt Printf debug
|
||||
snippet ff
|
||||
abbr fmt.Printf(...)
|
||||
fmt.Printf("${1} = %+v\n", $1)
|
||||
${0}
|
||||
# Fmt Println debug
|
||||
snippet fn
|
||||
abbr fmt.Println(...)
|
||||
fmt.Println("${1}")
|
||||
# Fmt Errorf
|
||||
snippet fe
|
||||
abbr fmt.Errorf(...)
|
||||
fmt.Errorf("${1}")
|
||||
# log printf
|
||||
snippet lf
|
||||
abbr log.Printf(...)
|
||||
log.Printf("${1} = %+v\n", $1)
|
||||
# log println
|
||||
snippet ln
|
||||
abbr log.Println(...)
|
||||
log.Println("${1}")
|
||||
# make
|
||||
snippet make
|
||||
abbr make(Type, size)
|
||||
make(${1:[]string}, ${2:0})${0}
|
||||
# map
|
||||
snippet map
|
||||
abbr map[Type]Type
|
||||
map[${1:string}]${0:int}
|
||||
# main()
|
||||
snippet main
|
||||
abbr func main() { ... }
|
||||
options head
|
||||
func main() {
|
||||
${0}
|
||||
}
|
||||
# method
|
||||
snippet meth
|
||||
abbr func (self Type) Method(...) [error] { ... }
|
||||
regexp /^meth/
|
||||
func (${1:self} ${2:Type}) ${3:Do}(${4}) ${5:error }{
|
||||
${0}
|
||||
}
|
||||
# ok
|
||||
snippet ok
|
||||
abbr if !ok { ... }
|
||||
if !ok {
|
||||
${0}
|
||||
}
|
||||
# package
|
||||
snippet package
|
||||
abbr package ...
|
||||
// Package $1 provides ${2:...}
|
||||
package ${1:main}
|
||||
${0}
|
||||
# panic
|
||||
snippet panic
|
||||
alias pn
|
||||
abbr panic("...")
|
||||
panic("${0}")
|
||||
# return
|
||||
snippet return
|
||||
alias rt
|
||||
abbr return ...
|
||||
return ${0}
|
||||
# select
|
||||
snippet select
|
||||
abbr select { case a := <-chan: ... }
|
||||
select {
|
||||
case ${1:v1} := <-${2:chan1}
|
||||
${0}
|
||||
}
|
||||
# struct
|
||||
snippet st
|
||||
abbr type T struct { ... }
|
||||
type ${1:Type} struct {
|
||||
${0}
|
||||
}
|
||||
# switch
|
||||
snippet switch
|
||||
abbr switch x { ... }
|
||||
switch ${1:var} {
|
||||
case ${2:value1}:
|
||||
${0}
|
||||
}
|
||||
# sprintf
|
||||
snippet sp
|
||||
abbr fmt.Sprintf(...)
|
||||
fmt.Sprintf("%${1:s}", ${2:var})
|
||||
# goroutine named function
|
||||
snippet go
|
||||
abbr go someFunc(...)
|
||||
go ${1:funcName}(${0})
|
||||
# goroutine anonymous function
|
||||
snippet gof
|
||||
abbr go func(...) { ... }(...)
|
||||
go func(${1}) {
|
||||
${3:/* TODO */}
|
||||
}(${2})
|
||||
# test function
|
||||
snippet test
|
||||
abbr func TestXYZ(t *testing.T) { ... }
|
||||
func Test${1:Function}(t *testing.T) {
|
||||
${0}
|
||||
}
|
||||
# test table snippet
|
||||
snippet tt
|
||||
abbr var test = {...}{...} for {t.Run(){...}}
|
||||
var tests = []struct {
|
||||
name string
|
||||
expected string
|
||||
given string
|
||||
}{
|
||||
{"${2}", "${3}", "${4}",},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
tt := tt
|
||||
t.Run(tt.name, func(t *testing.T){
|
||||
actual := ${1:Function}(tt.given)
|
||||
if actual != tt.expected {
|
||||
t.Errorf("given(%s): expected %s, actual %s", tt.given, tt.expected, actual)
|
||||
}
|
||||
})
|
||||
}
|
||||
# test server
|
||||
snippet tsrv
|
||||
abbr ts := httptest.NewServer(...)
|
||||
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
fmt.Fprintln(w, ${1:`response`})
|
||||
}))
|
||||
defer ts.Close()
|
||||
|
||||
//Use testing server url (type string) somewhere
|
||||
${0:someUrl} = ts.URL
|
||||
# test error
|
||||
snippet ter
|
||||
abbr if err != nil { t.Errorf(...) }
|
||||
if err != nil {
|
||||
t.Errorf("${1}")
|
||||
}
|
||||
# test fatal error
|
||||
snippet terf
|
||||
abbr if err != nil { t.Fatalf(...) }
|
||||
if err != nil {
|
||||
t.Fatalf("${1}")
|
||||
}
|
||||
# test example
|
||||
snippet example
|
||||
func Example${1:Method}() {
|
||||
${0}
|
||||
// Output:
|
||||
}
|
||||
# test benchmark
|
||||
snippet benchmark
|
||||
func Benchmark${1:Method}(b *testing.B) {
|
||||
for i := 0; i < b.N; i++ {
|
||||
${0}
|
||||
}
|
||||
}
|
||||
# variable declaration
|
||||
snippet var
|
||||
abbr var x Type [= ...]
|
||||
var ${1:x} ${2:Type}${3: = ${0:value\}}
|
||||
# variables declaration
|
||||
snippet vars
|
||||
abbr var ( ... )
|
||||
var (
|
||||
${1:x} ${2:Type}${3: = ${0:value\}}
|
||||
)
|
||||
# equals fails the test if exp is not equal to act.
|
||||
snippet eq
|
||||
abbr 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()
|
||||
}
|
||||
|
||||
snippet hf
|
||||
abbr http.HandlerFunc
|
||||
func ${1:handler}(w http.ResponseWriter, r *http.Request) {
|
||||
${0:fmt.Fprintf(w, "hello world")}
|
||||
}
|
||||
|
||||
snippet hhf
|
||||
abbr mux.HandleFunc(...)
|
||||
${1:http}.HandleFunc("${2:/}", func(w http.ResponseWriter, r *http.Request) {
|
||||
${0:fmt.Fprintf(w, "hello world")}
|
||||
})
|
||||
Reference in New Issue
Block a user