Removed vim-go

sources_non_forked/vim-go/gosnippets/UltiSnips/go.snippets

@@ -1,485 +0,0 @@
-# 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}, `!v 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
-
-# if inline error
-snippet ife "If with inline erro"
-if err := ${1:condition}; err != nil {
-	${0:${VISUAL}}
-}
-endsnippet
-
-# error snippet
-snippet errn "Error return" !b
-if err != nil {
-	return err
-}
-${0}
-endsnippet
-
-# error log snippet
-snippet errl "Error with log.Fatal(err)" !b
-if err != nil {
-	log.Fatal(err)
-}
-${0}
-endsnippet
-
-# error multiple return
-snippet errn, "Error return with two return values" !b
-if err != nil {
-	return ${1:nil}, ${2: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
-
-# yaml field tag
-snippet yaml "\`yaml:key\`"
-\`yaml:"${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
-
-# Fmt Errorf debug
-snippet fe "fmt.Errorf(...)"
-fmt.Errorf("${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
-
-# test table snippet
-snippet tt
-var tests = []struct {
-	name string
-	expected string
-	given string
-}{
-	{"${1}", "${2}", "${3}",},
-}
-for _, tt := range tests {
-	tt := tt
-	t.Run(tt.name, func(t *testing.T){
-		actual := ${0:${VISUAL}}(tt.given)
-		if actual != tt.expected {
-				t.Errorf("$0(%s): expected %s, actual %s", tt.given, tt.expected, actual)
-		}
-
-	})
-}
-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: