id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
sequence | docstring
stringlengths 6
2.61k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
12,000 | drone/routes | exp/routes/helper.go | ServeTemplate | func ServeTemplate(w http.ResponseWriter, name string, data map[string]interface{}) {
// cast the writer to the resposneWriter, get the router
r := w.(*responseWriter).Router
r.RLock()
defer r.RUnlock()
if data == nil {
data = map[string]interface{}{}
}
// append global params to the template
for k, v := range r.params {
data[k] = v
}
var buf bytes.Buffer
if err := r.views.ExecuteTemplate(&buf, name, data); err != nil {
panic(err)
return
}
// set the content length, type, etc
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write(buf.Bytes())
} | go | func ServeTemplate(w http.ResponseWriter, name string, data map[string]interface{}) {
// cast the writer to the resposneWriter, get the router
r := w.(*responseWriter).Router
r.RLock()
defer r.RUnlock()
if data == nil {
data = map[string]interface{}{}
}
// append global params to the template
for k, v := range r.params {
data[k] = v
}
var buf bytes.Buffer
if err := r.views.ExecuteTemplate(&buf, name, data); err != nil {
panic(err)
return
}
// set the content length, type, etc
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Write(buf.Bytes())
} | [
"func",
"ServeTemplate",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"name",
"string",
",",
"data",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"{",
"// cast the writer to the resposneWriter, get the router",
"r",
":=",
"w",
".",
"(",
"*",
"responseWriter",
")",
".",
"Router",
"\n\n",
"r",
".",
"RLock",
"(",
")",
"\n",
"defer",
"r",
".",
"RUnlock",
"(",
")",
"\n\n",
"if",
"data",
"==",
"nil",
"{",
"data",
"=",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"}",
"\n",
"}",
"\n\n",
"// append global params to the template",
"for",
"k",
",",
"v",
":=",
"range",
"r",
".",
"params",
"{",
"data",
"[",
"k",
"]",
"=",
"v",
"\n",
"}",
"\n\n",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"if",
"err",
":=",
"r",
".",
"views",
".",
"ExecuteTemplate",
"(",
"&",
"buf",
",",
"name",
",",
"data",
")",
";",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"// set the content length, type, etc",
"w",
".",
"Header",
"(",
")",
".",
"Set",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"w",
".",
"Write",
"(",
"buf",
".",
"Bytes",
"(",
")",
")",
"\n",
"}"
] | // ServeTemplate applies the named template to the specified data map and
// writes the output to the http.ResponseWriter. | [
"ServeTemplate",
"applies",
"the",
"named",
"template",
"to",
"the",
"specified",
"data",
"map",
"and",
"writes",
"the",
"output",
"to",
"the",
"http",
".",
"ResponseWriter",
"."
] | 853bef2b231162bb7b09355720416d3af1510d88 | https://github.com/drone/routes/blob/853bef2b231162bb7b09355720416d3af1510d88/exp/routes/helper.go#L66-L91 |
12,001 | drone/routes | exp/routes/helper.go | Error | func Error(w http.ResponseWriter, code int) {
http.Error(w, http.StatusText(code), code)
} | go | func Error(w http.ResponseWriter, code int) {
http.Error(w, http.StatusText(code), code)
} | [
"func",
"Error",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"code",
"int",
")",
"{",
"http",
".",
"Error",
"(",
"w",
",",
"http",
".",
"StatusText",
"(",
"code",
")",
",",
"code",
")",
"\n",
"}"
] | // Error will terminate the http Request with the specified error code. | [
"Error",
"will",
"terminate",
"the",
"http",
"Request",
"with",
"the",
"specified",
"error",
"code",
"."
] | 853bef2b231162bb7b09355720416d3af1510d88 | https://github.com/drone/routes/blob/853bef2b231162bb7b09355720416d3af1510d88/exp/routes/helper.go#L94-L96 |
12,002 | drone/routes | exp/cookie/authcookie/authcookie.go | NewSinceNow | func NewSinceNow(login string, dur time.Duration, secret []byte) string {
return New(login, time.Now().Add(dur), secret)
} | go | func NewSinceNow(login string, dur time.Duration, secret []byte) string {
return New(login, time.Now().Add(dur), secret)
} | [
"func",
"NewSinceNow",
"(",
"login",
"string",
",",
"dur",
"time",
".",
"Duration",
",",
"secret",
"[",
"]",
"byte",
")",
"string",
"{",
"return",
"New",
"(",
"login",
",",
"time",
".",
"Now",
"(",
")",
".",
"Add",
"(",
"dur",
")",
",",
"secret",
")",
"\n",
"}"
] | // NewSinceNow returns a signed authetication cookie for the given login,
// duration since current time, and secret key. | [
"NewSinceNow",
"returns",
"a",
"signed",
"authetication",
"cookie",
"for",
"the",
"given",
"login",
"duration",
"since",
"current",
"time",
"and",
"secret",
"key",
"."
] | 853bef2b231162bb7b09355720416d3af1510d88 | https://github.com/drone/routes/blob/853bef2b231162bb7b09355720416d3af1510d88/exp/cookie/authcookie/authcookie.go#L98-L100 |
12,003 | drone/routes | exp/cookie/authcookie/authcookie.go | Login | func Login(cookie string, secret []byte) string {
l, exp, err := Parse(cookie, secret)
if err != nil || exp.Before(time.Now()) {
return ""
}
return l
} | go | func Login(cookie string, secret []byte) string {
l, exp, err := Parse(cookie, secret)
if err != nil || exp.Before(time.Now()) {
return ""
}
return l
} | [
"func",
"Login",
"(",
"cookie",
"string",
",",
"secret",
"[",
"]",
"byte",
")",
"string",
"{",
"l",
",",
"exp",
",",
"err",
":=",
"Parse",
"(",
"cookie",
",",
"secret",
")",
"\n",
"if",
"err",
"!=",
"nil",
"||",
"exp",
".",
"Before",
"(",
"time",
".",
"Now",
"(",
")",
")",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"l",
"\n",
"}"
] | // Login returns a valid login extracted from the given cookie and verified
// using the given secret key. If verification fails or the cookie expired,
// the function returns an empty string. | [
"Login",
"returns",
"a",
"valid",
"login",
"extracted",
"from",
"the",
"given",
"cookie",
"and",
"verified",
"using",
"the",
"given",
"secret",
"key",
".",
"If",
"verification",
"fails",
"or",
"the",
"cookie",
"expired",
"the",
"function",
"returns",
"an",
"empty",
"string",
"."
] | 853bef2b231162bb7b09355720416d3af1510d88 | https://github.com/drone/routes/blob/853bef2b231162bb7b09355720416d3af1510d88/exp/cookie/authcookie/authcookie.go#L148-L154 |
12,004 | drone/routes | exp/context/context.go | Get | func Get(r *http.Request) *Context {
// get the context bound to the http.Request
if v, ok := r.Body.(*wrapper); ok {
return v.context
}
// create a new context
c := Context{ }
c.Params = make(Params)
c.Values = make(Values)
c.req = r
// wrap the request and bind the context
wrapper := wrap(r)
wrapper.context = &c
return &c
} | go | func Get(r *http.Request) *Context {
// get the context bound to the http.Request
if v, ok := r.Body.(*wrapper); ok {
return v.context
}
// create a new context
c := Context{ }
c.Params = make(Params)
c.Values = make(Values)
c.req = r
// wrap the request and bind the context
wrapper := wrap(r)
wrapper.context = &c
return &c
} | [
"func",
"Get",
"(",
"r",
"*",
"http",
".",
"Request",
")",
"*",
"Context",
"{",
"// get the context bound to the http.Request",
"if",
"v",
",",
"ok",
":=",
"r",
".",
"Body",
".",
"(",
"*",
"wrapper",
")",
";",
"ok",
"{",
"return",
"v",
".",
"context",
"\n",
"}",
"\n\n",
"// create a new context",
"c",
":=",
"Context",
"{",
"}",
"\n",
"c",
".",
"Params",
"=",
"make",
"(",
"Params",
")",
"\n",
"c",
".",
"Values",
"=",
"make",
"(",
"Values",
")",
"\n",
"c",
".",
"req",
"=",
"r",
"\n\n",
"// wrap the request and bind the context",
"wrapper",
":=",
"wrap",
"(",
"r",
")",
"\n",
"wrapper",
".",
"context",
"=",
"&",
"c",
"\n",
"return",
"&",
"c",
"\n",
"}"
] | // Retruns the Context associated with the http.Request. | [
"Retruns",
"the",
"Context",
"associated",
"with",
"the",
"http",
".",
"Request",
"."
] | 853bef2b231162bb7b09355720416d3af1510d88 | https://github.com/drone/routes/blob/853bef2b231162bb7b09355720416d3af1510d88/exp/context/context.go#L21-L38 |
12,005 | drone/routes | exp/context/context.go | Get | func (p Params) Get(key string) string {
if p == nil {
return ""
}
return p[key]
} | go | func (p Params) Get(key string) string {
if p == nil {
return ""
}
return p[key]
} | [
"func",
"(",
"p",
"Params",
")",
"Get",
"(",
"key",
"string",
")",
"string",
"{",
"if",
"p",
"==",
"nil",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"p",
"[",
"key",
"]",
"\n",
"}"
] | // Get gets the first value associated with the given key. If there are
// no values associated with the key, Get returns the empty string. | [
"Get",
"gets",
"the",
"first",
"value",
"associated",
"with",
"the",
"given",
"key",
".",
"If",
"there",
"are",
"no",
"values",
"associated",
"with",
"the",
"key",
"Get",
"returns",
"the",
"empty",
"string",
"."
] | 853bef2b231162bb7b09355720416d3af1510d88 | https://github.com/drone/routes/blob/853bef2b231162bb7b09355720416d3af1510d88/exp/context/context.go#L78-L83 |
12,006 | drone/routes | exp/context/context.go | GetStr | func (v Values) GetStr(key interface{}) interface{} {
if v == nil { return "" }
val := v.Get(key)
if val == nil { return "" }
str, ok := val.(string)
if !ok { return "" }
return str
} | go | func (v Values) GetStr(key interface{}) interface{} {
if v == nil { return "" }
val := v.Get(key)
if val == nil { return "" }
str, ok := val.(string)
if !ok { return "" }
return str
} | [
"func",
"(",
"v",
"Values",
")",
"GetStr",
"(",
"key",
"interface",
"{",
"}",
")",
"interface",
"{",
"}",
"{",
"if",
"v",
"==",
"nil",
"{",
"return",
"\"",
"\"",
"}",
"\n",
"val",
":=",
"v",
".",
"Get",
"(",
"key",
")",
"\n",
"if",
"val",
"==",
"nil",
"{",
"return",
"\"",
"\"",
"}",
"\n\n",
"str",
",",
"ok",
":=",
"val",
".",
"(",
"string",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"\"",
"\"",
"}",
"\n",
"return",
"str",
"\n",
"}"
] | // GetStr gets the value associated with the given key in string format.
// If there are no values associated with the key, Get returns an
// empty string. | [
"GetStr",
"gets",
"the",
"value",
"associated",
"with",
"the",
"given",
"key",
"in",
"string",
"format",
".",
"If",
"there",
"are",
"no",
"values",
"associated",
"with",
"the",
"key",
"Get",
"returns",
"an",
"empty",
"string",
"."
] | 853bef2b231162bb7b09355720416d3af1510d88 | https://github.com/drone/routes/blob/853bef2b231162bb7b09355720416d3af1510d88/exp/context/context.go#L113-L122 |
12,007 | drone/routes | exp/router/routes.go | FilterPath | func (r *Router) FilterPath(path string, filter http.HandlerFunc) {
pattern := path
pattern = strings.Replace(pattern, "*", "(.+)", -1)
pattern = strings.Replace(pattern, "**", "([^/]+)", -1)
regex := regexp.MustCompile(pattern)
r.Filter(func(w http.ResponseWriter, req *http.Request) {
if regex.MatchString(req.URL.Path) { filter(w, req) }
})
} | go | func (r *Router) FilterPath(path string, filter http.HandlerFunc) {
pattern := path
pattern = strings.Replace(pattern, "*", "(.+)", -1)
pattern = strings.Replace(pattern, "**", "([^/]+)", -1)
regex := regexp.MustCompile(pattern)
r.Filter(func(w http.ResponseWriter, req *http.Request) {
if regex.MatchString(req.URL.Path) { filter(w, req) }
})
} | [
"func",
"(",
"r",
"*",
"Router",
")",
"FilterPath",
"(",
"path",
"string",
",",
"filter",
"http",
".",
"HandlerFunc",
")",
"{",
"pattern",
":=",
"path",
"\n",
"pattern",
"=",
"strings",
".",
"Replace",
"(",
"pattern",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"-",
"1",
")",
"\n",
"pattern",
"=",
"strings",
".",
"Replace",
"(",
"pattern",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"-",
"1",
")",
"\n",
"regex",
":=",
"regexp",
".",
"MustCompile",
"(",
"pattern",
")",
"\n",
"r",
".",
"Filter",
"(",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
")",
"{",
"if",
"regex",
".",
"MatchString",
"(",
"req",
".",
"URL",
".",
"Path",
")",
"{",
"filter",
"(",
"w",
",",
"req",
")",
"}",
"\n",
"}",
")",
"\n",
"}"
] | // FilterPath adds the middleware filter iff the path matches the request. | [
"FilterPath",
"adds",
"the",
"middleware",
"filter",
"iff",
"the",
"path",
"matches",
"the",
"request",
"."
] | 853bef2b231162bb7b09355720416d3af1510d88 | https://github.com/drone/routes/blob/853bef2b231162bb7b09355720416d3af1510d88/exp/router/routes.go#L142-L150 |
12,008 | drone/routes | exp/router/routes.go | Hijack | func (w *responseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
return w.writer.(http.Hijacker).Hijack()
} | go | func (w *responseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
return w.writer.(http.Hijacker).Hijack()
} | [
"func",
"(",
"w",
"*",
"responseWriter",
")",
"Hijack",
"(",
")",
"(",
"net",
".",
"Conn",
",",
"*",
"bufio",
".",
"ReadWriter",
",",
"error",
")",
"{",
"return",
"w",
".",
"writer",
".",
"(",
"http",
".",
"Hijacker",
")",
".",
"Hijack",
"(",
")",
"\n",
"}"
] | // The Hijacker interface is implemented by ResponseWriters that allow an
// HTTP handler to take over the connection. | [
"The",
"Hijacker",
"interface",
"is",
"implemented",
"by",
"ResponseWriters",
"that",
"allow",
"an",
"HTTP",
"handler",
"to",
"take",
"over",
"the",
"connection",
"."
] | 853bef2b231162bb7b09355720416d3af1510d88 | https://github.com/drone/routes/blob/853bef2b231162bb7b09355720416d3af1510d88/exp/router/routes.go#L239-L241 |
12,009 | cryptix/wav | writer.go | NewWriter | func (file File) NewWriter(out output) (wr *Writer, err error) {
if file.Channels != 1 {
err = fmt.Errorf("sorry, only mono currently")
return
}
wr = &Writer{}
wr.output = out
wr.sampleBuf = bufio.NewWriter(out)
wr.options = file
// write header when close to get correct number of samples
_, err = wr.Seek(12, os.SEEK_SET)
if err != nil {
return
}
// fmt.Fprintf(wr, "%s", tokenChunkFmt)
n, err := wr.output.Write(tokenChunkFmt[:])
if err != nil {
return
}
wr.bytesWritten += n
chunkFmt := riffChunkFmt{
LengthOfHeader: 16,
AudioFormat: 1,
NumChannels: file.Channels,
SampleRate: file.SampleRate,
BytesPerSec: uint32(file.Channels) * file.SampleRate * uint32(file.SignificantBits) / 8,
BytesPerBloc: file.SignificantBits / 8 * file.Channels,
BitsPerSample: file.SignificantBits,
}
err = binary.Write(wr.output, binary.LittleEndian, chunkFmt)
if err != nil {
return
}
wr.bytesWritten += 20 //sizeof riffChunkFmt
n, err = wr.output.Write(tokenData[:])
if err != nil {
return
}
wr.bytesWritten += n
// leave space for the data size
_, err = wr.Seek(4, os.SEEK_CUR)
if err != nil {
return
}
return
} | go | func (file File) NewWriter(out output) (wr *Writer, err error) {
if file.Channels != 1 {
err = fmt.Errorf("sorry, only mono currently")
return
}
wr = &Writer{}
wr.output = out
wr.sampleBuf = bufio.NewWriter(out)
wr.options = file
// write header when close to get correct number of samples
_, err = wr.Seek(12, os.SEEK_SET)
if err != nil {
return
}
// fmt.Fprintf(wr, "%s", tokenChunkFmt)
n, err := wr.output.Write(tokenChunkFmt[:])
if err != nil {
return
}
wr.bytesWritten += n
chunkFmt := riffChunkFmt{
LengthOfHeader: 16,
AudioFormat: 1,
NumChannels: file.Channels,
SampleRate: file.SampleRate,
BytesPerSec: uint32(file.Channels) * file.SampleRate * uint32(file.SignificantBits) / 8,
BytesPerBloc: file.SignificantBits / 8 * file.Channels,
BitsPerSample: file.SignificantBits,
}
err = binary.Write(wr.output, binary.LittleEndian, chunkFmt)
if err != nil {
return
}
wr.bytesWritten += 20 //sizeof riffChunkFmt
n, err = wr.output.Write(tokenData[:])
if err != nil {
return
}
wr.bytesWritten += n
// leave space for the data size
_, err = wr.Seek(4, os.SEEK_CUR)
if err != nil {
return
}
return
} | [
"func",
"(",
"file",
"File",
")",
"NewWriter",
"(",
"out",
"output",
")",
"(",
"wr",
"*",
"Writer",
",",
"err",
"error",
")",
"{",
"if",
"file",
".",
"Channels",
"!=",
"1",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"wr",
"=",
"&",
"Writer",
"{",
"}",
"\n",
"wr",
".",
"output",
"=",
"out",
"\n",
"wr",
".",
"sampleBuf",
"=",
"bufio",
".",
"NewWriter",
"(",
"out",
")",
"\n",
"wr",
".",
"options",
"=",
"file",
"\n\n",
"// write header when close to get correct number of samples",
"_",
",",
"err",
"=",
"wr",
".",
"Seek",
"(",
"12",
",",
"os",
".",
"SEEK_SET",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"// fmt.Fprintf(wr, \"%s\", tokenChunkFmt)",
"n",
",",
"err",
":=",
"wr",
".",
"output",
".",
"Write",
"(",
"tokenChunkFmt",
"[",
":",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"wr",
".",
"bytesWritten",
"+=",
"n",
"\n\n",
"chunkFmt",
":=",
"riffChunkFmt",
"{",
"LengthOfHeader",
":",
"16",
",",
"AudioFormat",
":",
"1",
",",
"NumChannels",
":",
"file",
".",
"Channels",
",",
"SampleRate",
":",
"file",
".",
"SampleRate",
",",
"BytesPerSec",
":",
"uint32",
"(",
"file",
".",
"Channels",
")",
"*",
"file",
".",
"SampleRate",
"*",
"uint32",
"(",
"file",
".",
"SignificantBits",
")",
"/",
"8",
",",
"BytesPerBloc",
":",
"file",
".",
"SignificantBits",
"/",
"8",
"*",
"file",
".",
"Channels",
",",
"BitsPerSample",
":",
"file",
".",
"SignificantBits",
",",
"}",
"\n\n",
"err",
"=",
"binary",
".",
"Write",
"(",
"wr",
".",
"output",
",",
"binary",
".",
"LittleEndian",
",",
"chunkFmt",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"wr",
".",
"bytesWritten",
"+=",
"20",
"//sizeof riffChunkFmt",
"\n\n",
"n",
",",
"err",
"=",
"wr",
".",
"output",
".",
"Write",
"(",
"tokenData",
"[",
":",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"wr",
".",
"bytesWritten",
"+=",
"n",
"\n\n",
"// leave space for the data size",
"_",
",",
"err",
"=",
"wr",
".",
"Seek",
"(",
"4",
",",
"os",
".",
"SEEK_CUR",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // NewWriter creates a new WaveWriter and writes the header to it | [
"NewWriter",
"creates",
"a",
"new",
"WaveWriter",
"and",
"writes",
"the",
"header",
"to",
"it"
] | 8bdace674401f0bd3b63c65479b6a6ff1f9d5e44 | https://github.com/cryptix/wav/blob/8bdace674401f0bd3b63c65479b6a6ff1f9d5e44/writer.go#L27-L80 |
12,010 | cryptix/wav | writer.go | WriteInt32 | func (w *Writer) WriteInt32(sample int32) error {
err := binary.Write(w.sampleBuf, binary.LittleEndian, sample)
if err != nil {
return err
}
w.bytesWritten += 4
return err
} | go | func (w *Writer) WriteInt32(sample int32) error {
err := binary.Write(w.sampleBuf, binary.LittleEndian, sample)
if err != nil {
return err
}
w.bytesWritten += 4
return err
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"WriteInt32",
"(",
"sample",
"int32",
")",
"error",
"{",
"err",
":=",
"binary",
".",
"Write",
"(",
"w",
".",
"sampleBuf",
",",
"binary",
".",
"LittleEndian",
",",
"sample",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"w",
".",
"bytesWritten",
"+=",
"4",
"\n\n",
"return",
"err",
"\n",
"}"
] | // WriteInt32 writes the sample to the file using the binary package | [
"WriteInt32",
"writes",
"the",
"sample",
"to",
"the",
"file",
"using",
"the",
"binary",
"package"
] | 8bdace674401f0bd3b63c65479b6a6ff1f9d5e44 | https://github.com/cryptix/wav/blob/8bdace674401f0bd3b63c65479b6a6ff1f9d5e44/writer.go#L83-L92 |
12,011 | cryptix/wav | writer.go | Close | func (w *Writer) Close() error {
if err := w.sampleBuf.Flush(); err != nil {
return err
}
_, err := w.Seek(0, os.SEEK_SET)
if err != nil {
return err
}
header := riffHeader{
ChunkSize: uint32(w.bytesWritten + 8),
}
copy(header.Ftype[:], tokenRiff[:])
copy(header.ChunkFormat[:], tokenWaveFormat[:])
err = binary.Write(w.output, binary.LittleEndian, header)
if err != nil {
return err
}
// write data chunk size
_, err = w.Seek(0x28, os.SEEK_SET)
if err != nil {
return err
}
// write chunk size
err = binary.Write(w.output, binary.LittleEndian, int32(w.bytesWritten))
if err != nil {
return err
}
return w.output.Close()
} | go | func (w *Writer) Close() error {
if err := w.sampleBuf.Flush(); err != nil {
return err
}
_, err := w.Seek(0, os.SEEK_SET)
if err != nil {
return err
}
header := riffHeader{
ChunkSize: uint32(w.bytesWritten + 8),
}
copy(header.Ftype[:], tokenRiff[:])
copy(header.ChunkFormat[:], tokenWaveFormat[:])
err = binary.Write(w.output, binary.LittleEndian, header)
if err != nil {
return err
}
// write data chunk size
_, err = w.Seek(0x28, os.SEEK_SET)
if err != nil {
return err
}
// write chunk size
err = binary.Write(w.output, binary.LittleEndian, int32(w.bytesWritten))
if err != nil {
return err
}
return w.output.Close()
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"Close",
"(",
")",
"error",
"{",
"if",
"err",
":=",
"w",
".",
"sampleBuf",
".",
"Flush",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"_",
",",
"err",
":=",
"w",
".",
"Seek",
"(",
"0",
",",
"os",
".",
"SEEK_SET",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"header",
":=",
"riffHeader",
"{",
"ChunkSize",
":",
"uint32",
"(",
"w",
".",
"bytesWritten",
"+",
"8",
")",
",",
"}",
"\n",
"copy",
"(",
"header",
".",
"Ftype",
"[",
":",
"]",
",",
"tokenRiff",
"[",
":",
"]",
")",
"\n",
"copy",
"(",
"header",
".",
"ChunkFormat",
"[",
":",
"]",
",",
"tokenWaveFormat",
"[",
":",
"]",
")",
"\n\n",
"err",
"=",
"binary",
".",
"Write",
"(",
"w",
".",
"output",
",",
"binary",
".",
"LittleEndian",
",",
"header",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// write data chunk size",
"_",
",",
"err",
"=",
"w",
".",
"Seek",
"(",
"0x28",
",",
"os",
".",
"SEEK_SET",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// write chunk size",
"err",
"=",
"binary",
".",
"Write",
"(",
"w",
".",
"output",
",",
"binary",
".",
"LittleEndian",
",",
"int32",
"(",
"w",
".",
"bytesWritten",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"w",
".",
"output",
".",
"Close",
"(",
")",
"\n",
"}"
] | // Close corrects the filesize information in the header | [
"Close",
"corrects",
"the",
"filesize",
"information",
"in",
"the",
"header"
] | 8bdace674401f0bd3b63c65479b6a6ff1f9d5e44 | https://github.com/cryptix/wav/blob/8bdace674401f0bd3b63c65479b6a6ff1f9d5e44/writer.go#L117-L151 |
12,012 | cryptix/wav | reader.go | NewReader | func NewReader(rd io.ReadSeeker, size int64) (wav *Reader, err error) {
if size > maxSize {
return nil, ErrInputToLarge
}
wav = new(Reader)
wav.input = rd
wav.size = size
err = wav.parseHeaders()
if err != nil {
return nil, err
}
wav.samplesRead = 0
return wav, nil
} | go | func NewReader(rd io.ReadSeeker, size int64) (wav *Reader, err error) {
if size > maxSize {
return nil, ErrInputToLarge
}
wav = new(Reader)
wav.input = rd
wav.size = size
err = wav.parseHeaders()
if err != nil {
return nil, err
}
wav.samplesRead = 0
return wav, nil
} | [
"func",
"NewReader",
"(",
"rd",
"io",
".",
"ReadSeeker",
",",
"size",
"int64",
")",
"(",
"wav",
"*",
"Reader",
",",
"err",
"error",
")",
"{",
"if",
"size",
">",
"maxSize",
"{",
"return",
"nil",
",",
"ErrInputToLarge",
"\n",
"}",
"\n\n",
"wav",
"=",
"new",
"(",
"Reader",
")",
"\n",
"wav",
".",
"input",
"=",
"rd",
"\n",
"wav",
".",
"size",
"=",
"size",
"\n\n",
"err",
"=",
"wav",
".",
"parseHeaders",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"wav",
".",
"samplesRead",
"=",
"0",
"\n\n",
"return",
"wav",
",",
"nil",
"\n",
"}"
] | // NewReader returns a new WAV reader wrapper | [
"NewReader",
"returns",
"a",
"new",
"WAV",
"reader",
"wrapper"
] | 8bdace674401f0bd3b63c65479b6a6ff1f9d5e44 | https://github.com/cryptix/wav/blob/8bdace674401f0bd3b63c65479b6a6ff1f9d5e44/reader.go#L50-L67 |
12,013 | cryptix/wav | reader.go | GetFile | func (wav Reader) GetFile() File {
return File{
SampleRate: wav.chunkFmt.SampleRate,
Channels: wav.chunkFmt.NumChannels,
SignificantBits: wav.chunkFmt.BitsPerSample,
BytesPerSecond: wav.chunkFmt.BytesPerSec,
AudioFormat: wav.chunkFmt.AudioFormat,
NumberOfSamples: wav.numSamples,
SoundSize: wav.dataBlocSize,
Duration: wav.duration,
Canonical: wav.canonical && !wav.extraChunk,
}
} | go | func (wav Reader) GetFile() File {
return File{
SampleRate: wav.chunkFmt.SampleRate,
Channels: wav.chunkFmt.NumChannels,
SignificantBits: wav.chunkFmt.BitsPerSample,
BytesPerSecond: wav.chunkFmt.BytesPerSec,
AudioFormat: wav.chunkFmt.AudioFormat,
NumberOfSamples: wav.numSamples,
SoundSize: wav.dataBlocSize,
Duration: wav.duration,
Canonical: wav.canonical && !wav.extraChunk,
}
} | [
"func",
"(",
"wav",
"Reader",
")",
"GetFile",
"(",
")",
"File",
"{",
"return",
"File",
"{",
"SampleRate",
":",
"wav",
".",
"chunkFmt",
".",
"SampleRate",
",",
"Channels",
":",
"wav",
".",
"chunkFmt",
".",
"NumChannels",
",",
"SignificantBits",
":",
"wav",
".",
"chunkFmt",
".",
"BitsPerSample",
",",
"BytesPerSecond",
":",
"wav",
".",
"chunkFmt",
".",
"BytesPerSec",
",",
"AudioFormat",
":",
"wav",
".",
"chunkFmt",
".",
"AudioFormat",
",",
"NumberOfSamples",
":",
"wav",
".",
"numSamples",
",",
"SoundSize",
":",
"wav",
".",
"dataBlocSize",
",",
"Duration",
":",
"wav",
".",
"duration",
",",
"Canonical",
":",
"wav",
".",
"canonical",
"&&",
"!",
"wav",
".",
"extraChunk",
",",
"}",
"\n",
"}"
] | // GetFile returns File | [
"GetFile",
"returns",
"File"
] | 8bdace674401f0bd3b63c65479b6a6ff1f9d5e44 | https://github.com/cryptix/wav/blob/8bdace674401f0bd3b63c65479b6a6ff1f9d5e44/reader.go#L217-L229 |
12,014 | cryptix/wav | reader.go | Reset | func (wav *Reader) Reset() (err error) {
_, err = wav.input.Seek(int64(wav.firstSamplePos), os.SEEK_SET)
if err == nil {
wav.samplesRead = 0
}
return
} | go | func (wav *Reader) Reset() (err error) {
_, err = wav.input.Seek(int64(wav.firstSamplePos), os.SEEK_SET)
if err == nil {
wav.samplesRead = 0
}
return
} | [
"func",
"(",
"wav",
"*",
"Reader",
")",
"Reset",
"(",
")",
"(",
"err",
"error",
")",
"{",
"_",
",",
"err",
"=",
"wav",
".",
"input",
".",
"Seek",
"(",
"int64",
"(",
"wav",
".",
"firstSamplePos",
")",
",",
"os",
".",
"SEEK_SET",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"wav",
".",
"samplesRead",
"=",
"0",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // Reset the wavReader | [
"Reset",
"the",
"wavReader"
] | 8bdace674401f0bd3b63c65479b6a6ff1f9d5e44 | https://github.com/cryptix/wav/blob/8bdace674401f0bd3b63c65479b6a6ff1f9d5e44/reader.go#L237-L244 |
12,015 | cryptix/wav | reader.go | GetDumbReader | func (wav Reader) GetDumbReader() (r io.Reader, err error) {
// move reader to the first sample
_, err = wav.input.Seek(int64(wav.firstSamplePos), os.SEEK_SET)
if err != nil {
return nil, err
}
return wav.input, nil
} | go | func (wav Reader) GetDumbReader() (r io.Reader, err error) {
// move reader to the first sample
_, err = wav.input.Seek(int64(wav.firstSamplePos), os.SEEK_SET)
if err != nil {
return nil, err
}
return wav.input, nil
} | [
"func",
"(",
"wav",
"Reader",
")",
"GetDumbReader",
"(",
")",
"(",
"r",
"io",
".",
"Reader",
",",
"err",
"error",
")",
"{",
"// move reader to the first sample",
"_",
",",
"err",
"=",
"wav",
".",
"input",
".",
"Seek",
"(",
"int64",
"(",
"wav",
".",
"firstSamplePos",
")",
",",
"os",
".",
"SEEK_SET",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"wav",
".",
"input",
",",
"nil",
"\n",
"}"
] | // GetDumbReader gives you a std io.Reader, starting from the first sample. usefull for piping data. | [
"GetDumbReader",
"gives",
"you",
"a",
"std",
"io",
".",
"Reader",
"starting",
"from",
"the",
"first",
"sample",
".",
"usefull",
"for",
"piping",
"data",
"."
] | 8bdace674401f0bd3b63c65479b6a6ff1f9d5e44 | https://github.com/cryptix/wav/blob/8bdace674401f0bd3b63c65479b6a6ff1f9d5e44/reader.go#L247-L255 |
12,016 | cryptix/wav | reader.go | ReadSample | func (wav *Reader) ReadSample() (n int32, err error) {
s, err := wav.ReadRawSample()
if err != nil {
return 0, err
}
switch wav.bytesPerSample {
case 1:
n = int32(s[0])
case 2:
n = int32(s[0]) + int32(s[1])<<8
case 3:
n = int32(s[0]) + int32(s[1])<<8 + int32(s[2])<<16
case 4:
n = int32(s[0]) + int32(s[1])<<8 + int32(s[2])<<16 + int32(s[3])<<24
default:
n = 0
err = fmt.Errorf("Unhandled bytesPerSample! b:%d", wav.bytesPerSample)
}
return
} | go | func (wav *Reader) ReadSample() (n int32, err error) {
s, err := wav.ReadRawSample()
if err != nil {
return 0, err
}
switch wav.bytesPerSample {
case 1:
n = int32(s[0])
case 2:
n = int32(s[0]) + int32(s[1])<<8
case 3:
n = int32(s[0]) + int32(s[1])<<8 + int32(s[2])<<16
case 4:
n = int32(s[0]) + int32(s[1])<<8 + int32(s[2])<<16 + int32(s[3])<<24
default:
n = 0
err = fmt.Errorf("Unhandled bytesPerSample! b:%d", wav.bytesPerSample)
}
return
} | [
"func",
"(",
"wav",
"*",
"Reader",
")",
"ReadSample",
"(",
")",
"(",
"n",
"int32",
",",
"err",
"error",
")",
"{",
"s",
",",
"err",
":=",
"wav",
".",
"ReadRawSample",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"switch",
"wav",
".",
"bytesPerSample",
"{",
"case",
"1",
":",
"n",
"=",
"int32",
"(",
"s",
"[",
"0",
"]",
")",
"\n",
"case",
"2",
":",
"n",
"=",
"int32",
"(",
"s",
"[",
"0",
"]",
")",
"+",
"int32",
"(",
"s",
"[",
"1",
"]",
")",
"<<",
"8",
"\n",
"case",
"3",
":",
"n",
"=",
"int32",
"(",
"s",
"[",
"0",
"]",
")",
"+",
"int32",
"(",
"s",
"[",
"1",
"]",
")",
"<<",
"8",
"+",
"int32",
"(",
"s",
"[",
"2",
"]",
")",
"<<",
"16",
"\n",
"case",
"4",
":",
"n",
"=",
"int32",
"(",
"s",
"[",
"0",
"]",
")",
"+",
"int32",
"(",
"s",
"[",
"1",
"]",
")",
"<<",
"8",
"+",
"int32",
"(",
"s",
"[",
"2",
"]",
")",
"<<",
"16",
"+",
"int32",
"(",
"s",
"[",
"3",
"]",
")",
"<<",
"24",
"\n",
"default",
":",
"n",
"=",
"0",
"\n",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"wav",
".",
"bytesPerSample",
")",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // ReadSample returns the parsed sample bytes as integers | [
"ReadSample",
"returns",
"the",
"parsed",
"sample",
"bytes",
"as",
"integers"
] | 8bdace674401f0bd3b63c65479b6a6ff1f9d5e44 | https://github.com/cryptix/wav/blob/8bdace674401f0bd3b63c65479b6a6ff1f9d5e44/reader.go#L279-L300 |
12,017 | cryptix/wav | reader.go | ReadSampleEvery | func (wav *Reader) ReadSampleEvery(every uint32, average int) (samples []int32, err error) {
// Reset any other readers
err = wav.Reset()
if err != nil {
return
}
var n int32
var total int
total = int(wav.numSamples / every)
for total >= 0 {
total = total - 1
n, err = wav.ReadSample()
if err != nil {
return
}
// lets average the samples for better accuracy
// if average > 0 {
// var sum = n
// fmt.Println(n)
// for i := 1; i < average; i++ {
// n, err = wav.ReadSample()
// if err != nil {
// return
// }
// fmt.Println(n)
// sum += n
// }
// fmt.Println("Sum:", sum, "/", int32(average), sum/int32(average))
// n = sum / int32(average)
// }
// Median seems to reflect better than average
if average > 0 {
var sum = make([]int, average)
sum[0] = int(n)
for i := 1; i < average; i++ {
n, err = wav.ReadSample()
if err != nil {
return
}
sum[i] = int(n)
}
sort.Ints(sum)
// fmt.Println("Sum:", sum, "[", average/2, "] = ", sum[average/2])
n = int32(sum[average/2])
}
samples = append(samples, n)
_, err = wav.input.Seek(int64(every), os.SEEK_CUR)
if err != nil {
return
}
}
return
} | go | func (wav *Reader) ReadSampleEvery(every uint32, average int) (samples []int32, err error) {
// Reset any other readers
err = wav.Reset()
if err != nil {
return
}
var n int32
var total int
total = int(wav.numSamples / every)
for total >= 0 {
total = total - 1
n, err = wav.ReadSample()
if err != nil {
return
}
// lets average the samples for better accuracy
// if average > 0 {
// var sum = n
// fmt.Println(n)
// for i := 1; i < average; i++ {
// n, err = wav.ReadSample()
// if err != nil {
// return
// }
// fmt.Println(n)
// sum += n
// }
// fmt.Println("Sum:", sum, "/", int32(average), sum/int32(average))
// n = sum / int32(average)
// }
// Median seems to reflect better than average
if average > 0 {
var sum = make([]int, average)
sum[0] = int(n)
for i := 1; i < average; i++ {
n, err = wav.ReadSample()
if err != nil {
return
}
sum[i] = int(n)
}
sort.Ints(sum)
// fmt.Println("Sum:", sum, "[", average/2, "] = ", sum[average/2])
n = int32(sum[average/2])
}
samples = append(samples, n)
_, err = wav.input.Seek(int64(every), os.SEEK_CUR)
if err != nil {
return
}
}
return
} | [
"func",
"(",
"wav",
"*",
"Reader",
")",
"ReadSampleEvery",
"(",
"every",
"uint32",
",",
"average",
"int",
")",
"(",
"samples",
"[",
"]",
"int32",
",",
"err",
"error",
")",
"{",
"// Reset any other readers",
"err",
"=",
"wav",
".",
"Reset",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"var",
"n",
"int32",
"\n",
"var",
"total",
"int",
"\n",
"total",
"=",
"int",
"(",
"wav",
".",
"numSamples",
"/",
"every",
")",
"\n",
"for",
"total",
">=",
"0",
"{",
"total",
"=",
"total",
"-",
"1",
"\n\n",
"n",
",",
"err",
"=",
"wav",
".",
"ReadSample",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"// lets average the samples for better accuracy",
"// if average > 0 {",
"// \tvar sum = n",
"// \tfmt.Println(n)",
"// \tfor i := 1; i < average; i++ {",
"// \t\tn, err = wav.ReadSample()",
"// \t\tif err != nil {",
"// \t\t\treturn",
"// \t\t}",
"// \t\tfmt.Println(n)",
"// \t\tsum += n",
"// \t}",
"// \tfmt.Println(\"Sum:\", sum, \"/\", int32(average), sum/int32(average))",
"// \tn = sum / int32(average)",
"// }",
"// Median seems to reflect better than average",
"if",
"average",
">",
"0",
"{",
"var",
"sum",
"=",
"make",
"(",
"[",
"]",
"int",
",",
"average",
")",
"\n",
"sum",
"[",
"0",
"]",
"=",
"int",
"(",
"n",
")",
"\n",
"for",
"i",
":=",
"1",
";",
"i",
"<",
"average",
";",
"i",
"++",
"{",
"n",
",",
"err",
"=",
"wav",
".",
"ReadSample",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"sum",
"[",
"i",
"]",
"=",
"int",
"(",
"n",
")",
"\n",
"}",
"\n",
"sort",
".",
"Ints",
"(",
"sum",
")",
"\n",
"// fmt.Println(\"Sum:\", sum, \"[\", average/2, \"] = \", sum[average/2])",
"n",
"=",
"int32",
"(",
"sum",
"[",
"average",
"/",
"2",
"]",
")",
"\n",
"}",
"\n\n",
"samples",
"=",
"append",
"(",
"samples",
",",
"n",
")",
"\n\n",
"_",
",",
"err",
"=",
"wav",
".",
"input",
".",
"Seek",
"(",
"int64",
"(",
"every",
")",
",",
"os",
".",
"SEEK_CUR",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // ReadSampleEvery returns the parsed sample bytes as integers every X samples | [
"ReadSampleEvery",
"returns",
"the",
"parsed",
"sample",
"bytes",
"as",
"integers",
"every",
"X",
"samples"
] | 8bdace674401f0bd3b63c65479b6a6ff1f9d5e44 | https://github.com/cryptix/wav/blob/8bdace674401f0bd3b63c65479b6a6ff1f9d5e44/reader.go#L303-L363 |
12,018 | marusama/semaphore | semaphore.go | New | func New(limit int) Semaphore {
if limit <= 0 {
panic("semaphore limit must be greater than 0")
}
broadcastCh := make(chan struct{})
return &semaphore{
state: uint64(limit) << 32,
broadcastCh: broadcastCh,
}
} | go | func New(limit int) Semaphore {
if limit <= 0 {
panic("semaphore limit must be greater than 0")
}
broadcastCh := make(chan struct{})
return &semaphore{
state: uint64(limit) << 32,
broadcastCh: broadcastCh,
}
} | [
"func",
"New",
"(",
"limit",
"int",
")",
"Semaphore",
"{",
"if",
"limit",
"<=",
"0",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"broadcastCh",
":=",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
"\n",
"return",
"&",
"semaphore",
"{",
"state",
":",
"uint64",
"(",
"limit",
")",
"<<",
"32",
",",
"broadcastCh",
":",
"broadcastCh",
",",
"}",
"\n",
"}"
] | // New initializes a new instance of the Semaphore, specifying the maximum number of concurrent entries. | [
"New",
"initializes",
"a",
"new",
"instance",
"of",
"the",
"Semaphore",
"specifying",
"the",
"maximum",
"number",
"of",
"concurrent",
"entries",
"."
] | 6952cef993b28a4d0871600e08bfcf2f2b1207a0 | https://github.com/marusama/semaphore/blob/6952cef993b28a4d0871600e08bfcf2f2b1207a0/semaphore.go#L65-L74 |
12,019 | njern/gonexmo | ip.go | IsTrustedIP | func IsTrustedIP(ipStr string) bool {
ip := net.ParseIP(ipStr)
for _, net := range subnets {
if net.Contains(ip) {
return true
}
}
return false
} | go | func IsTrustedIP(ipStr string) bool {
ip := net.ParseIP(ipStr)
for _, net := range subnets {
if net.Contains(ip) {
return true
}
}
return false
} | [
"func",
"IsTrustedIP",
"(",
"ipStr",
"string",
")",
"bool",
"{",
"ip",
":=",
"net",
".",
"ParseIP",
"(",
"ipStr",
")",
"\n\n",
"for",
"_",
",",
"net",
":=",
"range",
"subnets",
"{",
"if",
"net",
".",
"Contains",
"(",
"ip",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // IsTrustedIP returns true if the provided IP address came from
// a trusted Nexmo server. | [
"IsTrustedIP",
"returns",
"true",
"if",
"the",
"provided",
"IP",
"address",
"came",
"from",
"a",
"trusted",
"Nexmo",
"server",
"."
] | b4d503a6ab5333f9c47f2301f84fd0afadb83f5c | https://github.com/njern/gonexmo/blob/b4d503a6ab5333f9c47f2301f84fd0afadb83f5c/ip.go#L25-L34 |
12,020 | njern/gonexmo | server.go | NewDeliveryHandler | func NewDeliveryHandler(out chan *DeliveryReceipt, verifyIPs bool) http.HandlerFunc {
return func(w http.ResponseWriter, req *http.Request) {
if verifyIPs {
// Check if the request came from Nexmo
host, _, err := net.SplitHostPort(req.RemoteAddr)
if !IsTrustedIP(host) || err != nil {
http.Error(w, "", http.StatusInternalServerError)
return
}
}
var err error
// Check if the query is empty. If it is, it's just Nexmo
// making sure our service is up, so we don't want to return
// an error.
if req.URL.RawQuery == "" {
return
}
req.ParseForm()
// Decode the form data
m := new(DeliveryReceipt)
m.To = req.FormValue("to")
m.NetworkCode = req.FormValue("network-code")
m.MessageID = req.FormValue("messageId")
m.MSISDN = req.FormValue("msisdn")
m.Status = req.FormValue("status")
m.ErrorCode = req.FormValue("err-code")
m.Price = req.FormValue("price")
m.ClientReference = req.FormValue("client-ref")
t, err := url.QueryUnescape(req.FormValue("scts"))
if err != nil {
http.Error(w, "", http.StatusInternalServerError)
return
}
// Convert the timestamp to a time.Time.
timestamp, err := time.Parse("0601021504", t)
if err != nil {
http.Error(w, "", http.StatusInternalServerError)
return
}
m.SCTS = timestamp
t, err = url.QueryUnescape(req.FormValue("message-timestamp"))
if err != nil {
http.Error(w, "", http.StatusInternalServerError)
return
}
// Convert the timestamp to a time.Time.
timestamp, err = time.Parse("2006-01-02 15:04:05", t)
if err != nil {
http.Error(w, "", http.StatusInternalServerError)
return
}
m.Timestamp = timestamp
// Pass it out on the chan
out <- m
}
} | go | func NewDeliveryHandler(out chan *DeliveryReceipt, verifyIPs bool) http.HandlerFunc {
return func(w http.ResponseWriter, req *http.Request) {
if verifyIPs {
// Check if the request came from Nexmo
host, _, err := net.SplitHostPort(req.RemoteAddr)
if !IsTrustedIP(host) || err != nil {
http.Error(w, "", http.StatusInternalServerError)
return
}
}
var err error
// Check if the query is empty. If it is, it's just Nexmo
// making sure our service is up, so we don't want to return
// an error.
if req.URL.RawQuery == "" {
return
}
req.ParseForm()
// Decode the form data
m := new(DeliveryReceipt)
m.To = req.FormValue("to")
m.NetworkCode = req.FormValue("network-code")
m.MessageID = req.FormValue("messageId")
m.MSISDN = req.FormValue("msisdn")
m.Status = req.FormValue("status")
m.ErrorCode = req.FormValue("err-code")
m.Price = req.FormValue("price")
m.ClientReference = req.FormValue("client-ref")
t, err := url.QueryUnescape(req.FormValue("scts"))
if err != nil {
http.Error(w, "", http.StatusInternalServerError)
return
}
// Convert the timestamp to a time.Time.
timestamp, err := time.Parse("0601021504", t)
if err != nil {
http.Error(w, "", http.StatusInternalServerError)
return
}
m.SCTS = timestamp
t, err = url.QueryUnescape(req.FormValue("message-timestamp"))
if err != nil {
http.Error(w, "", http.StatusInternalServerError)
return
}
// Convert the timestamp to a time.Time.
timestamp, err = time.Parse("2006-01-02 15:04:05", t)
if err != nil {
http.Error(w, "", http.StatusInternalServerError)
return
}
m.Timestamp = timestamp
// Pass it out on the chan
out <- m
}
} | [
"func",
"NewDeliveryHandler",
"(",
"out",
"chan",
"*",
"DeliveryReceipt",
",",
"verifyIPs",
"bool",
")",
"http",
".",
"HandlerFunc",
"{",
"return",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
")",
"{",
"if",
"verifyIPs",
"{",
"// Check if the request came from Nexmo",
"host",
",",
"_",
",",
"err",
":=",
"net",
".",
"SplitHostPort",
"(",
"req",
".",
"RemoteAddr",
")",
"\n",
"if",
"!",
"IsTrustedIP",
"(",
"host",
")",
"||",
"err",
"!=",
"nil",
"{",
"http",
".",
"Error",
"(",
"w",
",",
"\"",
"\"",
",",
"http",
".",
"StatusInternalServerError",
")",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n\n",
"var",
"err",
"error",
"\n",
"// Check if the query is empty. If it is, it's just Nexmo",
"// making sure our service is up, so we don't want to return",
"// an error.",
"if",
"req",
".",
"URL",
".",
"RawQuery",
"==",
"\"",
"\"",
"{",
"return",
"\n",
"}",
"\n\n",
"req",
".",
"ParseForm",
"(",
")",
"\n",
"// Decode the form data",
"m",
":=",
"new",
"(",
"DeliveryReceipt",
")",
"\n\n",
"m",
".",
"To",
"=",
"req",
".",
"FormValue",
"(",
"\"",
"\"",
")",
"\n",
"m",
".",
"NetworkCode",
"=",
"req",
".",
"FormValue",
"(",
"\"",
"\"",
")",
"\n",
"m",
".",
"MessageID",
"=",
"req",
".",
"FormValue",
"(",
"\"",
"\"",
")",
"\n",
"m",
".",
"MSISDN",
"=",
"req",
".",
"FormValue",
"(",
"\"",
"\"",
")",
"\n",
"m",
".",
"Status",
"=",
"req",
".",
"FormValue",
"(",
"\"",
"\"",
")",
"\n",
"m",
".",
"ErrorCode",
"=",
"req",
".",
"FormValue",
"(",
"\"",
"\"",
")",
"\n",
"m",
".",
"Price",
"=",
"req",
".",
"FormValue",
"(",
"\"",
"\"",
")",
"\n",
"m",
".",
"ClientReference",
"=",
"req",
".",
"FormValue",
"(",
"\"",
"\"",
")",
"\n\n",
"t",
",",
"err",
":=",
"url",
".",
"QueryUnescape",
"(",
"req",
".",
"FormValue",
"(",
"\"",
"\"",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"http",
".",
"Error",
"(",
"w",
",",
"\"",
"\"",
",",
"http",
".",
"StatusInternalServerError",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"// Convert the timestamp to a time.Time.",
"timestamp",
",",
"err",
":=",
"time",
".",
"Parse",
"(",
"\"",
"\"",
",",
"t",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"http",
".",
"Error",
"(",
"w",
",",
"\"",
"\"",
",",
"http",
".",
"StatusInternalServerError",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"m",
".",
"SCTS",
"=",
"timestamp",
"\n\n",
"t",
",",
"err",
"=",
"url",
".",
"QueryUnescape",
"(",
"req",
".",
"FormValue",
"(",
"\"",
"\"",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"http",
".",
"Error",
"(",
"w",
",",
"\"",
"\"",
",",
"http",
".",
"StatusInternalServerError",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"// Convert the timestamp to a time.Time.",
"timestamp",
",",
"err",
"=",
"time",
".",
"Parse",
"(",
"\"",
"\"",
",",
"t",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"http",
".",
"Error",
"(",
"w",
",",
"\"",
"\"",
",",
"http",
".",
"StatusInternalServerError",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"m",
".",
"Timestamp",
"=",
"timestamp",
"\n\n",
"// Pass it out on the chan",
"out",
"<-",
"m",
"\n",
"}",
"\n\n",
"}"
] | // NewDeliveryHandler creates a new http.HandlerFunc that can be used to listen
// for delivery receipts from the Nexmo server. Any receipts received will be
// decoded nad passed to the out chan. | [
"NewDeliveryHandler",
"creates",
"a",
"new",
"http",
".",
"HandlerFunc",
"that",
"can",
"be",
"used",
"to",
"listen",
"for",
"delivery",
"receipts",
"from",
"the",
"Nexmo",
"server",
".",
"Any",
"receipts",
"received",
"will",
"be",
"decoded",
"nad",
"passed",
"to",
"the",
"out",
"chan",
"."
] | b4d503a6ab5333f9c47f2301f84fd0afadb83f5c | https://github.com/njern/gonexmo/blob/b4d503a6ab5333f9c47f2301f84fd0afadb83f5c/server.go#L109-L175 |
12,021 | njern/gonexmo | ussd.go | Send | func (c *USSD) Send(msg *USSDMessage) (*MessageResponse, error) {
if len(msg.From) <= 0 {
return nil, errors.New("Invalid From field specified")
}
if len(msg.To) <= 0 {
return nil, errors.New("Invalid To field specified")
}
if len(msg.ClientReference) > 40 {
return nil, errors.New("Client reference too long")
}
var messageResponse *MessageResponse
values := make(url.Values)
if len(msg.Text) <= 0 {
return nil, errors.New("Invalid message text")
}
// TODO(inhies): UTF8 and URL encode before setting
values.Set("text", msg.Text)
if !c.client.useOauth {
values.Set("api_key", c.client.apiKey)
values.Set("api_secret", c.client.apiSecret)
}
if msg.StatusReportRequired {
values.Set("status_report_req", "1")
}
if msg.ClientReference != "" {
values.Set("client_ref", msg.ClientReference)
}
if msg.NetworkCode != "" {
values.Set("network-code", msg.NetworkCode)
}
var endpoint string
if msg.Prompt {
endpoint = "/ussd-prompt/json"
} else {
endpoint = "/ussd/json"
}
values.Set("to", msg.To)
values.Set("from", msg.From)
valuesReader := bytes.NewReader([]byte(values.Encode()))
var r *http.Request
r, _ = http.NewRequest("POST", apiRoot+endpoint, valuesReader)
r.Header.Add("Accept", "application/json")
r.Header.Add("Content-Type", "application/x-www-form-urlencoded")
resp, err := c.client.HTTPClient.Do(r)
if err != nil {
return nil, err
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
err = json.Unmarshal(body, &messageResponse)
if err != nil {
return nil, err
}
return messageResponse, nil
} | go | func (c *USSD) Send(msg *USSDMessage) (*MessageResponse, error) {
if len(msg.From) <= 0 {
return nil, errors.New("Invalid From field specified")
}
if len(msg.To) <= 0 {
return nil, errors.New("Invalid To field specified")
}
if len(msg.ClientReference) > 40 {
return nil, errors.New("Client reference too long")
}
var messageResponse *MessageResponse
values := make(url.Values)
if len(msg.Text) <= 0 {
return nil, errors.New("Invalid message text")
}
// TODO(inhies): UTF8 and URL encode before setting
values.Set("text", msg.Text)
if !c.client.useOauth {
values.Set("api_key", c.client.apiKey)
values.Set("api_secret", c.client.apiSecret)
}
if msg.StatusReportRequired {
values.Set("status_report_req", "1")
}
if msg.ClientReference != "" {
values.Set("client_ref", msg.ClientReference)
}
if msg.NetworkCode != "" {
values.Set("network-code", msg.NetworkCode)
}
var endpoint string
if msg.Prompt {
endpoint = "/ussd-prompt/json"
} else {
endpoint = "/ussd/json"
}
values.Set("to", msg.To)
values.Set("from", msg.From)
valuesReader := bytes.NewReader([]byte(values.Encode()))
var r *http.Request
r, _ = http.NewRequest("POST", apiRoot+endpoint, valuesReader)
r.Header.Add("Accept", "application/json")
r.Header.Add("Content-Type", "application/x-www-form-urlencoded")
resp, err := c.client.HTTPClient.Do(r)
if err != nil {
return nil, err
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
err = json.Unmarshal(body, &messageResponse)
if err != nil {
return nil, err
}
return messageResponse, nil
} | [
"func",
"(",
"c",
"*",
"USSD",
")",
"Send",
"(",
"msg",
"*",
"USSDMessage",
")",
"(",
"*",
"MessageResponse",
",",
"error",
")",
"{",
"if",
"len",
"(",
"msg",
".",
"From",
")",
"<=",
"0",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"msg",
".",
"To",
")",
"<=",
"0",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"msg",
".",
"ClientReference",
")",
">",
"40",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"var",
"messageResponse",
"*",
"MessageResponse",
"\n\n",
"values",
":=",
"make",
"(",
"url",
".",
"Values",
")",
"\n\n",
"if",
"len",
"(",
"msg",
".",
"Text",
")",
"<=",
"0",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// TODO(inhies): UTF8 and URL encode before setting",
"values",
".",
"Set",
"(",
"\"",
"\"",
",",
"msg",
".",
"Text",
")",
"\n\n",
"if",
"!",
"c",
".",
"client",
".",
"useOauth",
"{",
"values",
".",
"Set",
"(",
"\"",
"\"",
",",
"c",
".",
"client",
".",
"apiKey",
")",
"\n",
"values",
".",
"Set",
"(",
"\"",
"\"",
",",
"c",
".",
"client",
".",
"apiSecret",
")",
"\n",
"}",
"\n\n",
"if",
"msg",
".",
"StatusReportRequired",
"{",
"values",
".",
"Set",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"msg",
".",
"ClientReference",
"!=",
"\"",
"\"",
"{",
"values",
".",
"Set",
"(",
"\"",
"\"",
",",
"msg",
".",
"ClientReference",
")",
"\n",
"}",
"\n\n",
"if",
"msg",
".",
"NetworkCode",
"!=",
"\"",
"\"",
"{",
"values",
".",
"Set",
"(",
"\"",
"\"",
",",
"msg",
".",
"NetworkCode",
")",
"\n",
"}",
"\n\n",
"var",
"endpoint",
"string",
"\n",
"if",
"msg",
".",
"Prompt",
"{",
"endpoint",
"=",
"\"",
"\"",
"\n",
"}",
"else",
"{",
"endpoint",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"values",
".",
"Set",
"(",
"\"",
"\"",
",",
"msg",
".",
"To",
")",
"\n",
"values",
".",
"Set",
"(",
"\"",
"\"",
",",
"msg",
".",
"From",
")",
"\n\n",
"valuesReader",
":=",
"bytes",
".",
"NewReader",
"(",
"[",
"]",
"byte",
"(",
"values",
".",
"Encode",
"(",
")",
")",
")",
"\n",
"var",
"r",
"*",
"http",
".",
"Request",
"\n",
"r",
",",
"_",
"=",
"http",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"apiRoot",
"+",
"endpoint",
",",
"valuesReader",
")",
"\n\n",
"r",
".",
"Header",
".",
"Add",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"r",
".",
"Header",
".",
"Add",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n\n",
"resp",
",",
"err",
":=",
"c",
".",
"client",
".",
"HTTPClient",
".",
"Do",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"body",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"resp",
".",
"Body",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"body",
",",
"&",
"messageResponse",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"messageResponse",
",",
"nil",
"\n",
"}"
] | // Send the message using the specified USSD client. | [
"Send",
"the",
"message",
"using",
"the",
"specified",
"USSD",
"client",
"."
] | b4d503a6ab5333f9c47f2301f84fd0afadb83f5c | https://github.com/njern/gonexmo/blob/b4d503a6ab5333f9c47f2301f84fd0afadb83f5c/ussd.go#L33-L107 |
12,022 | njern/gonexmo | verify.go | MarshalJSON | func (m *VerifyMessageRequest) MarshalJSON() ([]byte, error) {
return json.Marshal(struct {
APIKey string `json:"api_key"`
APISecret string `json:"api_secret"`
VerifyMessageRequest
}{
APIKey: m.apiKey,
APISecret: m.apiSecret,
VerifyMessageRequest: *m,
})
} | go | func (m *VerifyMessageRequest) MarshalJSON() ([]byte, error) {
return json.Marshal(struct {
APIKey string `json:"api_key"`
APISecret string `json:"api_secret"`
VerifyMessageRequest
}{
APIKey: m.apiKey,
APISecret: m.apiSecret,
VerifyMessageRequest: *m,
})
} | [
"func",
"(",
"m",
"*",
"VerifyMessageRequest",
")",
"MarshalJSON",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"return",
"json",
".",
"Marshal",
"(",
"struct",
"{",
"APIKey",
"string",
"`json:\"api_key\"`",
"\n",
"APISecret",
"string",
"`json:\"api_secret\"`",
"\n",
"VerifyMessageRequest",
"\n",
"}",
"{",
"APIKey",
":",
"m",
".",
"apiKey",
",",
"APISecret",
":",
"m",
".",
"apiSecret",
",",
"VerifyMessageRequest",
":",
"*",
"m",
",",
"}",
")",
"\n",
"}"
] | // MarshalJSON returns a byte slice with the serialized JSON of the
// VerifyMessageRequest struct. | [
"MarshalJSON",
"returns",
"a",
"byte",
"slice",
"with",
"the",
"serialized",
"JSON",
"of",
"the",
"VerifyMessageRequest",
"struct",
"."
] | b4d503a6ab5333f9c47f2301f84fd0afadb83f5c | https://github.com/njern/gonexmo/blob/b4d503a6ab5333f9c47f2301f84fd0afadb83f5c/verify.go#L18-L28 |
12,023 | njern/gonexmo | verify.go | Send | func (c *Verification) Send(m *VerifyMessageRequest) (*VerifyMessageResponse, error) {
if len(m.Number) == 0 {
return nil, errors.New("Invalid Number field specified")
}
if len(m.Brand) == 0 {
return nil, errors.New("Invalid Brand field specified")
}
var verifyMessageResponse *VerifyMessageResponse
if !c.client.useOauth {
m.apiKey = c.client.apiKey
m.apiSecret = c.client.apiSecret
}
var r *http.Request
buf, err := json.Marshal(m)
if err != nil {
return nil, errors.New("invalid message struct - can not convert to JSON")
}
b := bytes.NewBuffer(buf)
r, err = http.NewRequest("POST", apiRootv2+"/verify/json", b)
if err != nil {
return nil, err
}
r.Header.Add("Accept", "application/json")
r.Header.Add("Content-Type", "application/json")
resp, err := c.client.HTTPClient.Do(r)
if err != nil {
return nil, err
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
err = json.Unmarshal(body, &verifyMessageResponse)
if err != nil {
return nil, err
}
return verifyMessageResponse, nil
} | go | func (c *Verification) Send(m *VerifyMessageRequest) (*VerifyMessageResponse, error) {
if len(m.Number) == 0 {
return nil, errors.New("Invalid Number field specified")
}
if len(m.Brand) == 0 {
return nil, errors.New("Invalid Brand field specified")
}
var verifyMessageResponse *VerifyMessageResponse
if !c.client.useOauth {
m.apiKey = c.client.apiKey
m.apiSecret = c.client.apiSecret
}
var r *http.Request
buf, err := json.Marshal(m)
if err != nil {
return nil, errors.New("invalid message struct - can not convert to JSON")
}
b := bytes.NewBuffer(buf)
r, err = http.NewRequest("POST", apiRootv2+"/verify/json", b)
if err != nil {
return nil, err
}
r.Header.Add("Accept", "application/json")
r.Header.Add("Content-Type", "application/json")
resp, err := c.client.HTTPClient.Do(r)
if err != nil {
return nil, err
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, err
}
err = json.Unmarshal(body, &verifyMessageResponse)
if err != nil {
return nil, err
}
return verifyMessageResponse, nil
} | [
"func",
"(",
"c",
"*",
"Verification",
")",
"Send",
"(",
"m",
"*",
"VerifyMessageRequest",
")",
"(",
"*",
"VerifyMessageResponse",
",",
"error",
")",
"{",
"if",
"len",
"(",
"m",
".",
"Number",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"m",
".",
"Brand",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"var",
"verifyMessageResponse",
"*",
"VerifyMessageResponse",
"\n\n",
"if",
"!",
"c",
".",
"client",
".",
"useOauth",
"{",
"m",
".",
"apiKey",
"=",
"c",
".",
"client",
".",
"apiKey",
"\n",
"m",
".",
"apiSecret",
"=",
"c",
".",
"client",
".",
"apiSecret",
"\n",
"}",
"\n\n",
"var",
"r",
"*",
"http",
".",
"Request",
"\n",
"buf",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"m",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"b",
":=",
"bytes",
".",
"NewBuffer",
"(",
"buf",
")",
"\n",
"r",
",",
"err",
"=",
"http",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"apiRootv2",
"+",
"\"",
"\"",
",",
"b",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"r",
".",
"Header",
".",
"Add",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"r",
".",
"Header",
".",
"Add",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n\n",
"resp",
",",
"err",
":=",
"c",
".",
"client",
".",
"HTTPClient",
".",
"Do",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n\n",
"body",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"resp",
".",
"Body",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"body",
",",
"&",
"verifyMessageResponse",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"verifyMessageResponse",
",",
"nil",
"\n",
"}"
] | // Send makes the actual HTTP request to the endpoint and returns the
// response. | [
"Send",
"makes",
"the",
"actual",
"HTTP",
"request",
"to",
"the",
"endpoint",
"and",
"returns",
"the",
"response",
"."
] | b4d503a6ab5333f9c47f2301f84fd0afadb83f5c | https://github.com/njern/gonexmo/blob/b4d503a6ab5333f9c47f2301f84fd0afadb83f5c/verify.go#L56-L103 |
12,024 | njern/gonexmo | sms.go | Send | func (c *SMS) Send(msg *SMSMessage) (*MessageResponse, error) {
if len(msg.From) <= 0 {
return nil, errors.New("Invalid From field specified")
}
if len(msg.To) <= 0 {
return nil, errors.New("Invalid To field specified")
}
if len(msg.ClientReference) > 40 {
return nil, errors.New("Client reference too long")
}
var messageResponse *MessageResponse
switch msg.Type {
case Text:
case Unicode:
if len(msg.Text) <= 0 {
return nil, errors.New("Invalid message text")
}
case Binary:
if len(msg.UDH) == 0 || len(msg.Body) == 0 {
return nil, errors.New("Invalid binary message")
}
case WAPPush:
if len(msg.URL) == 0 || len(msg.Title) == 0 {
return nil, errors.New("Invalid WAP Push parameters")
}
}
if !c.client.useOauth {
msg.apiKey = c.client.apiKey
msg.apiSecret = c.client.apiSecret
}
var r *http.Request
buf, err := json.Marshal(msg)
if err != nil {
return nil, errors.New("invalid message struct - unable to convert to JSON")
}
b := bytes.NewBuffer(buf)
r, _ = http.NewRequest("POST", apiRoot+"/sms/json", b)
r.Header.Add("Accept", "application/json")
r.Header.Add("Content-Type", "application/json")
resp, err := c.client.HTTPClient.Do(r)
if err != nil {
return nil, err
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
err = json.Unmarshal(body, &messageResponse)
if err != nil {
return nil, err
}
return messageResponse, nil
} | go | func (c *SMS) Send(msg *SMSMessage) (*MessageResponse, error) {
if len(msg.From) <= 0 {
return nil, errors.New("Invalid From field specified")
}
if len(msg.To) <= 0 {
return nil, errors.New("Invalid To field specified")
}
if len(msg.ClientReference) > 40 {
return nil, errors.New("Client reference too long")
}
var messageResponse *MessageResponse
switch msg.Type {
case Text:
case Unicode:
if len(msg.Text) <= 0 {
return nil, errors.New("Invalid message text")
}
case Binary:
if len(msg.UDH) == 0 || len(msg.Body) == 0 {
return nil, errors.New("Invalid binary message")
}
case WAPPush:
if len(msg.URL) == 0 || len(msg.Title) == 0 {
return nil, errors.New("Invalid WAP Push parameters")
}
}
if !c.client.useOauth {
msg.apiKey = c.client.apiKey
msg.apiSecret = c.client.apiSecret
}
var r *http.Request
buf, err := json.Marshal(msg)
if err != nil {
return nil, errors.New("invalid message struct - unable to convert to JSON")
}
b := bytes.NewBuffer(buf)
r, _ = http.NewRequest("POST", apiRoot+"/sms/json", b)
r.Header.Add("Accept", "application/json")
r.Header.Add("Content-Type", "application/json")
resp, err := c.client.HTTPClient.Do(r)
if err != nil {
return nil, err
}
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
err = json.Unmarshal(body, &messageResponse)
if err != nil {
return nil, err
}
return messageResponse, nil
} | [
"func",
"(",
"c",
"*",
"SMS",
")",
"Send",
"(",
"msg",
"*",
"SMSMessage",
")",
"(",
"*",
"MessageResponse",
",",
"error",
")",
"{",
"if",
"len",
"(",
"msg",
".",
"From",
")",
"<=",
"0",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"msg",
".",
"To",
")",
"<=",
"0",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"msg",
".",
"ClientReference",
")",
">",
"40",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"var",
"messageResponse",
"*",
"MessageResponse",
"\n\n",
"switch",
"msg",
".",
"Type",
"{",
"case",
"Text",
":",
"case",
"Unicode",
":",
"if",
"len",
"(",
"msg",
".",
"Text",
")",
"<=",
"0",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"case",
"Binary",
":",
"if",
"len",
"(",
"msg",
".",
"UDH",
")",
"==",
"0",
"||",
"len",
"(",
"msg",
".",
"Body",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"case",
"WAPPush",
":",
"if",
"len",
"(",
"msg",
".",
"URL",
")",
"==",
"0",
"||",
"len",
"(",
"msg",
".",
"Title",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"!",
"c",
".",
"client",
".",
"useOauth",
"{",
"msg",
".",
"apiKey",
"=",
"c",
".",
"client",
".",
"apiKey",
"\n",
"msg",
".",
"apiSecret",
"=",
"c",
".",
"client",
".",
"apiSecret",
"\n",
"}",
"\n\n",
"var",
"r",
"*",
"http",
".",
"Request",
"\n",
"buf",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"msg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"b",
":=",
"bytes",
".",
"NewBuffer",
"(",
"buf",
")",
"\n",
"r",
",",
"_",
"=",
"http",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"apiRoot",
"+",
"\"",
"\"",
",",
"b",
")",
"\n\n",
"r",
".",
"Header",
".",
"Add",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"r",
".",
"Header",
".",
"Add",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n\n",
"resp",
",",
"err",
":=",
"c",
".",
"client",
".",
"HTTPClient",
".",
"Do",
"(",
"r",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n\n",
"body",
",",
"_",
":=",
"ioutil",
".",
"ReadAll",
"(",
"resp",
".",
"Body",
")",
"\n\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"body",
",",
"&",
"messageResponse",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"messageResponse",
",",
"nil",
"\n",
"}"
] | // Send the message using the specified SMS client. | [
"Send",
"the",
"message",
"using",
"the",
"specified",
"SMS",
"client",
"."
] | b4d503a6ab5333f9c47f2301f84fd0afadb83f5c | https://github.com/njern/gonexmo/blob/b4d503a6ab5333f9c47f2301f84fd0afadb83f5c/sms.go#L181-L242 |
12,025 | yuin/gluamapper | gluamapper.go | NewMapper | func NewMapper(opt Option) *Mapper {
if opt.NameFunc == nil {
opt.NameFunc = ToUpperCamelCase
}
if opt.TagName == "" {
opt.TagName = "gluamapper"
}
return &Mapper{opt}
} | go | func NewMapper(opt Option) *Mapper {
if opt.NameFunc == nil {
opt.NameFunc = ToUpperCamelCase
}
if opt.TagName == "" {
opt.TagName = "gluamapper"
}
return &Mapper{opt}
} | [
"func",
"NewMapper",
"(",
"opt",
"Option",
")",
"*",
"Mapper",
"{",
"if",
"opt",
".",
"NameFunc",
"==",
"nil",
"{",
"opt",
".",
"NameFunc",
"=",
"ToUpperCamelCase",
"\n",
"}",
"\n",
"if",
"opt",
".",
"TagName",
"==",
"\"",
"\"",
"{",
"opt",
".",
"TagName",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"&",
"Mapper",
"{",
"opt",
"}",
"\n",
"}"
] | // NewMapper returns a new mapper. | [
"NewMapper",
"returns",
"a",
"new",
"mapper",
"."
] | d836955830e75240d46ce9f0e6d148d94f2e1d3a | https://github.com/yuin/gluamapper/blob/d836955830e75240d46ce9f0e6d148d94f2e1d3a/gluamapper.go#L31-L39 |
12,026 | yuin/gluamapper | gluamapper.go | Map | func (mapper *Mapper) Map(tbl *lua.LTable, st interface{}) error {
opt := mapper.Option
mp, ok := ToGoValue(tbl, opt).(map[interface{}]interface{})
if !ok {
return errors.New("arguments #1 must be a table, but got an array")
}
config := &mapstructure.DecoderConfig{
WeaklyTypedInput: true,
Result: st,
TagName: opt.TagName,
ErrorUnused: opt.ErrorUnused,
}
decoder, err := mapstructure.NewDecoder(config)
if err != nil {
return err
}
return decoder.Decode(mp)
} | go | func (mapper *Mapper) Map(tbl *lua.LTable, st interface{}) error {
opt := mapper.Option
mp, ok := ToGoValue(tbl, opt).(map[interface{}]interface{})
if !ok {
return errors.New("arguments #1 must be a table, but got an array")
}
config := &mapstructure.DecoderConfig{
WeaklyTypedInput: true,
Result: st,
TagName: opt.TagName,
ErrorUnused: opt.ErrorUnused,
}
decoder, err := mapstructure.NewDecoder(config)
if err != nil {
return err
}
return decoder.Decode(mp)
} | [
"func",
"(",
"mapper",
"*",
"Mapper",
")",
"Map",
"(",
"tbl",
"*",
"lua",
".",
"LTable",
",",
"st",
"interface",
"{",
"}",
")",
"error",
"{",
"opt",
":=",
"mapper",
".",
"Option",
"\n",
"mp",
",",
"ok",
":=",
"ToGoValue",
"(",
"tbl",
",",
"opt",
")",
".",
"(",
"map",
"[",
"interface",
"{",
"}",
"]",
"interface",
"{",
"}",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"config",
":=",
"&",
"mapstructure",
".",
"DecoderConfig",
"{",
"WeaklyTypedInput",
":",
"true",
",",
"Result",
":",
"st",
",",
"TagName",
":",
"opt",
".",
"TagName",
",",
"ErrorUnused",
":",
"opt",
".",
"ErrorUnused",
",",
"}",
"\n",
"decoder",
",",
"err",
":=",
"mapstructure",
".",
"NewDecoder",
"(",
"config",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"decoder",
".",
"Decode",
"(",
"mp",
")",
"\n",
"}"
] | // Map maps the lua table to the given struct pointer. | [
"Map",
"maps",
"the",
"lua",
"table",
"to",
"the",
"given",
"struct",
"pointer",
"."
] | d836955830e75240d46ce9f0e6d148d94f2e1d3a | https://github.com/yuin/gluamapper/blob/d836955830e75240d46ce9f0e6d148d94f2e1d3a/gluamapper.go#L42-L59 |
12,027 | yuin/gluamapper | gluamapper.go | Map | func Map(tbl *lua.LTable, st interface{}) error {
return NewMapper(Option{}).Map(tbl, st)
} | go | func Map(tbl *lua.LTable, st interface{}) error {
return NewMapper(Option{}).Map(tbl, st)
} | [
"func",
"Map",
"(",
"tbl",
"*",
"lua",
".",
"LTable",
",",
"st",
"interface",
"{",
"}",
")",
"error",
"{",
"return",
"NewMapper",
"(",
"Option",
"{",
"}",
")",
".",
"Map",
"(",
"tbl",
",",
"st",
")",
"\n",
"}"
] | // Map maps the lua table to the given struct pointer with default options. | [
"Map",
"maps",
"the",
"lua",
"table",
"to",
"the",
"given",
"struct",
"pointer",
"with",
"default",
"options",
"."
] | d836955830e75240d46ce9f0e6d148d94f2e1d3a | https://github.com/yuin/gluamapper/blob/d836955830e75240d46ce9f0e6d148d94f2e1d3a/gluamapper.go#L62-L64 |
12,028 | yuin/gluamapper | gluamapper.go | ToUpperCamelCase | func ToUpperCamelCase(s string) string {
return strings.ToUpper(string(s[0])) + camelre.ReplaceAllStringFunc(s[1:len(s)], func(s string) string { return strings.ToUpper(s[1:len(s)]) })
} | go | func ToUpperCamelCase(s string) string {
return strings.ToUpper(string(s[0])) + camelre.ReplaceAllStringFunc(s[1:len(s)], func(s string) string { return strings.ToUpper(s[1:len(s)]) })
} | [
"func",
"ToUpperCamelCase",
"(",
"s",
"string",
")",
"string",
"{",
"return",
"strings",
".",
"ToUpper",
"(",
"string",
"(",
"s",
"[",
"0",
"]",
")",
")",
"+",
"camelre",
".",
"ReplaceAllStringFunc",
"(",
"s",
"[",
"1",
":",
"len",
"(",
"s",
")",
"]",
",",
"func",
"(",
"s",
"string",
")",
"string",
"{",
"return",
"strings",
".",
"ToUpper",
"(",
"s",
"[",
"1",
":",
"len",
"(",
"s",
")",
"]",
")",
"}",
")",
"\n",
"}"
] | // ToUpperCamelCase is an Option.NameFunc that converts strings from snake case to upper camel case. | [
"ToUpperCamelCase",
"is",
"an",
"Option",
".",
"NameFunc",
"that",
"converts",
"strings",
"from",
"snake",
"case",
"to",
"upper",
"camel",
"case",
"."
] | d836955830e75240d46ce9f0e6d148d94f2e1d3a | https://github.com/yuin/gluamapper/blob/d836955830e75240d46ce9f0e6d148d94f2e1d3a/gluamapper.go#L74-L76 |
12,029 | yuin/gluamapper | gluamapper.go | ToGoValue | func ToGoValue(lv lua.LValue, opt Option) interface{} {
switch v := lv.(type) {
case *lua.LNilType:
return nil
case lua.LBool:
return bool(v)
case lua.LString:
return string(v)
case lua.LNumber:
return float64(v)
case *lua.LTable:
maxn := v.MaxN()
if maxn == 0 { // table
ret := make(map[interface{}]interface{})
v.ForEach(func(key, value lua.LValue) {
keystr := fmt.Sprint(ToGoValue(key, opt))
ret[opt.NameFunc(keystr)] = ToGoValue(value, opt)
})
return ret
} else { // array
ret := make([]interface{}, 0, maxn)
for i := 1; i <= maxn; i++ {
ret = append(ret, ToGoValue(v.RawGetInt(i), opt))
}
return ret
}
default:
return v
}
} | go | func ToGoValue(lv lua.LValue, opt Option) interface{} {
switch v := lv.(type) {
case *lua.LNilType:
return nil
case lua.LBool:
return bool(v)
case lua.LString:
return string(v)
case lua.LNumber:
return float64(v)
case *lua.LTable:
maxn := v.MaxN()
if maxn == 0 { // table
ret := make(map[interface{}]interface{})
v.ForEach(func(key, value lua.LValue) {
keystr := fmt.Sprint(ToGoValue(key, opt))
ret[opt.NameFunc(keystr)] = ToGoValue(value, opt)
})
return ret
} else { // array
ret := make([]interface{}, 0, maxn)
for i := 1; i <= maxn; i++ {
ret = append(ret, ToGoValue(v.RawGetInt(i), opt))
}
return ret
}
default:
return v
}
} | [
"func",
"ToGoValue",
"(",
"lv",
"lua",
".",
"LValue",
",",
"opt",
"Option",
")",
"interface",
"{",
"}",
"{",
"switch",
"v",
":=",
"lv",
".",
"(",
"type",
")",
"{",
"case",
"*",
"lua",
".",
"LNilType",
":",
"return",
"nil",
"\n",
"case",
"lua",
".",
"LBool",
":",
"return",
"bool",
"(",
"v",
")",
"\n",
"case",
"lua",
".",
"LString",
":",
"return",
"string",
"(",
"v",
")",
"\n",
"case",
"lua",
".",
"LNumber",
":",
"return",
"float64",
"(",
"v",
")",
"\n",
"case",
"*",
"lua",
".",
"LTable",
":",
"maxn",
":=",
"v",
".",
"MaxN",
"(",
")",
"\n",
"if",
"maxn",
"==",
"0",
"{",
"// table",
"ret",
":=",
"make",
"(",
"map",
"[",
"interface",
"{",
"}",
"]",
"interface",
"{",
"}",
")",
"\n",
"v",
".",
"ForEach",
"(",
"func",
"(",
"key",
",",
"value",
"lua",
".",
"LValue",
")",
"{",
"keystr",
":=",
"fmt",
".",
"Sprint",
"(",
"ToGoValue",
"(",
"key",
",",
"opt",
")",
")",
"\n",
"ret",
"[",
"opt",
".",
"NameFunc",
"(",
"keystr",
")",
"]",
"=",
"ToGoValue",
"(",
"value",
",",
"opt",
")",
"\n",
"}",
")",
"\n",
"return",
"ret",
"\n",
"}",
"else",
"{",
"// array",
"ret",
":=",
"make",
"(",
"[",
"]",
"interface",
"{",
"}",
",",
"0",
",",
"maxn",
")",
"\n",
"for",
"i",
":=",
"1",
";",
"i",
"<=",
"maxn",
";",
"i",
"++",
"{",
"ret",
"=",
"append",
"(",
"ret",
",",
"ToGoValue",
"(",
"v",
".",
"RawGetInt",
"(",
"i",
")",
",",
"opt",
")",
")",
"\n",
"}",
"\n",
"return",
"ret",
"\n",
"}",
"\n",
"default",
":",
"return",
"v",
"\n",
"}",
"\n",
"}"
] | // ToGoValue converts the given LValue to a Go object. | [
"ToGoValue",
"converts",
"the",
"given",
"LValue",
"to",
"a",
"Go",
"object",
"."
] | d836955830e75240d46ce9f0e6d148d94f2e1d3a | https://github.com/yuin/gluamapper/blob/d836955830e75240d46ce9f0e6d148d94f2e1d3a/gluamapper.go#L79-L108 |
12,030 | Songmu/prompter | funcs.go | Prompt | func Prompt(message, defaultAnswer string) string {
return (&Prompter{
Message: message,
Default: defaultAnswer,
}).Prompt()
} | go | func Prompt(message, defaultAnswer string) string {
return (&Prompter{
Message: message,
Default: defaultAnswer,
}).Prompt()
} | [
"func",
"Prompt",
"(",
"message",
",",
"defaultAnswer",
"string",
")",
"string",
"{",
"return",
"(",
"&",
"Prompter",
"{",
"Message",
":",
"message",
",",
"Default",
":",
"defaultAnswer",
",",
"}",
")",
".",
"Prompt",
"(",
")",
"\n",
"}"
] | // Prompt simple prompting | [
"Prompt",
"simple",
"prompting"
] | 9b5529e9ffd102d5a266d0e3b53526259c2c0b68 | https://github.com/Songmu/prompter/blob/9b5529e9ffd102d5a266d0e3b53526259c2c0b68/funcs.go#L9-L14 |
12,031 | Songmu/prompter | funcs.go | Password | func Password(message string) string {
return (&Prompter{
Message: message,
NoEcho: true,
}).Prompt()
} | go | func Password(message string) string {
return (&Prompter{
Message: message,
NoEcho: true,
}).Prompt()
} | [
"func",
"Password",
"(",
"message",
"string",
")",
"string",
"{",
"return",
"(",
"&",
"Prompter",
"{",
"Message",
":",
"message",
",",
"NoEcho",
":",
"true",
",",
"}",
")",
".",
"Prompt",
"(",
")",
"\n",
"}"
] | // Password asks password | [
"Password",
"asks",
"password"
] | 9b5529e9ffd102d5a266d0e3b53526259c2c0b68 | https://github.com/Songmu/prompter/blob/9b5529e9ffd102d5a266d0e3b53526259c2c0b68/funcs.go#L49-L54 |
12,032 | Songmu/prompter | funcs.go | Choose | func Choose(message string, choices []string, defaultChoice string) string {
return (&Prompter{
Message: message,
Choices: choices,
Default: defaultChoice,
}).Prompt()
} | go | func Choose(message string, choices []string, defaultChoice string) string {
return (&Prompter{
Message: message,
Choices: choices,
Default: defaultChoice,
}).Prompt()
} | [
"func",
"Choose",
"(",
"message",
"string",
",",
"choices",
"[",
"]",
"string",
",",
"defaultChoice",
"string",
")",
"string",
"{",
"return",
"(",
"&",
"Prompter",
"{",
"Message",
":",
"message",
",",
"Choices",
":",
"choices",
",",
"Default",
":",
"defaultChoice",
",",
"}",
")",
".",
"Prompt",
"(",
")",
"\n",
"}"
] | // Choose make a choice | [
"Choose",
"make",
"a",
"choice"
] | 9b5529e9ffd102d5a266d0e3b53526259c2c0b68 | https://github.com/Songmu/prompter/blob/9b5529e9ffd102d5a266d0e3b53526259c2c0b68/funcs.go#L57-L63 |
12,033 | Songmu/prompter | funcs.go | Regexp | func Regexp(message string, reg *regexp.Regexp, defaultAnswer string) string {
return (&Prompter{
Message: message,
Regexp: reg,
Default: defaultAnswer,
}).Prompt()
} | go | func Regexp(message string, reg *regexp.Regexp, defaultAnswer string) string {
return (&Prompter{
Message: message,
Regexp: reg,
Default: defaultAnswer,
}).Prompt()
} | [
"func",
"Regexp",
"(",
"message",
"string",
",",
"reg",
"*",
"regexp",
".",
"Regexp",
",",
"defaultAnswer",
"string",
")",
"string",
"{",
"return",
"(",
"&",
"Prompter",
"{",
"Message",
":",
"message",
",",
"Regexp",
":",
"reg",
",",
"Default",
":",
"defaultAnswer",
",",
"}",
")",
".",
"Prompt",
"(",
")",
"\n",
"}"
] | // Regexp checks the answer by regexp | [
"Regexp",
"checks",
"the",
"answer",
"by",
"regexp"
] | 9b5529e9ffd102d5a266d0e3b53526259c2c0b68 | https://github.com/Songmu/prompter/blob/9b5529e9ffd102d5a266d0e3b53526259c2c0b68/funcs.go#L66-L72 |
12,034 | Songmu/prompter | prompter.go | Prompt | func (p *Prompter) Prompt() string {
fmt.Print(p.msg())
if p.UseDefault || skip() {
return p.Default
}
input := ""
if p.NoEcho {
b, err := terminal.ReadPassword(int(os.Stdin.Fd()))
if err == nil {
input = string(b)
}
fmt.Print("\n")
} else {
scanner := bufio.NewScanner(os.Stdin)
ok := scanner.Scan()
if ok {
input = strings.TrimRight(scanner.Text(), "\r\n")
}
}
if input == "" {
input = p.Default
}
if !p.inputIsValid(input) {
fmt.Println(p.errorMsg())
return p.Prompt()
}
return input
} | go | func (p *Prompter) Prompt() string {
fmt.Print(p.msg())
if p.UseDefault || skip() {
return p.Default
}
input := ""
if p.NoEcho {
b, err := terminal.ReadPassword(int(os.Stdin.Fd()))
if err == nil {
input = string(b)
}
fmt.Print("\n")
} else {
scanner := bufio.NewScanner(os.Stdin)
ok := scanner.Scan()
if ok {
input = strings.TrimRight(scanner.Text(), "\r\n")
}
}
if input == "" {
input = p.Default
}
if !p.inputIsValid(input) {
fmt.Println(p.errorMsg())
return p.Prompt()
}
return input
} | [
"func",
"(",
"p",
"*",
"Prompter",
")",
"Prompt",
"(",
")",
"string",
"{",
"fmt",
".",
"Print",
"(",
"p",
".",
"msg",
"(",
")",
")",
"\n",
"if",
"p",
".",
"UseDefault",
"||",
"skip",
"(",
")",
"{",
"return",
"p",
".",
"Default",
"\n",
"}",
"\n",
"input",
":=",
"\"",
"\"",
"\n",
"if",
"p",
".",
"NoEcho",
"{",
"b",
",",
"err",
":=",
"terminal",
".",
"ReadPassword",
"(",
"int",
"(",
"os",
".",
"Stdin",
".",
"Fd",
"(",
")",
")",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"input",
"=",
"string",
"(",
"b",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Print",
"(",
"\"",
"\\n",
"\"",
")",
"\n",
"}",
"else",
"{",
"scanner",
":=",
"bufio",
".",
"NewScanner",
"(",
"os",
".",
"Stdin",
")",
"\n",
"ok",
":=",
"scanner",
".",
"Scan",
"(",
")",
"\n",
"if",
"ok",
"{",
"input",
"=",
"strings",
".",
"TrimRight",
"(",
"scanner",
".",
"Text",
"(",
")",
",",
"\"",
"\\r",
"\\n",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"input",
"==",
"\"",
"\"",
"{",
"input",
"=",
"p",
".",
"Default",
"\n",
"}",
"\n",
"if",
"!",
"p",
".",
"inputIsValid",
"(",
"input",
")",
"{",
"fmt",
".",
"Println",
"(",
"p",
".",
"errorMsg",
"(",
")",
")",
"\n",
"return",
"p",
".",
"Prompt",
"(",
")",
"\n",
"}",
"\n",
"return",
"input",
"\n",
"}"
] | // Prompt displays a prompt and returns answer | [
"Prompt",
"displays",
"a",
"prompt",
"and",
"returns",
"answer"
] | 9b5529e9ffd102d5a266d0e3b53526259c2c0b68 | https://github.com/Songmu/prompter/blob/9b5529e9ffd102d5a266d0e3b53526259c2c0b68/prompter.go#L34-L61 |
12,035 | gregdel/pushover | recipient.go | validate | func (r *Recipient) validate() error {
// Check empty token
if r.token == "" {
return ErrEmptyRecipientToken
}
// Check invalid token
if recipientRegexp.MatchString(r.token) == false {
return ErrInvalidRecipientToken
}
return nil
} | go | func (r *Recipient) validate() error {
// Check empty token
if r.token == "" {
return ErrEmptyRecipientToken
}
// Check invalid token
if recipientRegexp.MatchString(r.token) == false {
return ErrInvalidRecipientToken
}
return nil
} | [
"func",
"(",
"r",
"*",
"Recipient",
")",
"validate",
"(",
")",
"error",
"{",
"// Check empty token",
"if",
"r",
".",
"token",
"==",
"\"",
"\"",
"{",
"return",
"ErrEmptyRecipientToken",
"\n",
"}",
"\n\n",
"// Check invalid token",
"if",
"recipientRegexp",
".",
"MatchString",
"(",
"r",
".",
"token",
")",
"==",
"false",
"{",
"return",
"ErrInvalidRecipientToken",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Validates recipient token. | [
"Validates",
"recipient",
"token",
"."
] | 15d3fef406363e87c21b8ffa5dbe430bff13ac76 | https://github.com/gregdel/pushover/blob/15d3fef406363e87c21b8ffa5dbe430bff13ac76/recipient.go#L22-L33 |
12,036 | gregdel/pushover | request.go | do | func do(req *http.Request, resType interface{}, returnHeaders bool) error {
client := http.DefaultClient
// Send request
resp, err := client.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
// Only 500 errors will not respond a readable result
if resp.StatusCode >= http.StatusInternalServerError {
return ErrHTTPPushover
}
// Decode the JSON response
if err := json.NewDecoder(resp.Body).Decode(&resType); err != nil {
return err
}
// Check if the unmarshaled data is a response
r, ok := resType.(*Response)
if !ok {
return nil
}
// Check response status
if r.Status != 1 {
return r.Errors
}
// The headers are only returned when posting a new notification
if returnHeaders {
// Get app limits from headers
appLimits, err := newLimit(resp.Header)
if err != nil {
return err
}
r.Limit = appLimits
}
return nil
} | go | func do(req *http.Request, resType interface{}, returnHeaders bool) error {
client := http.DefaultClient
// Send request
resp, err := client.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
// Only 500 errors will not respond a readable result
if resp.StatusCode >= http.StatusInternalServerError {
return ErrHTTPPushover
}
// Decode the JSON response
if err := json.NewDecoder(resp.Body).Decode(&resType); err != nil {
return err
}
// Check if the unmarshaled data is a response
r, ok := resType.(*Response)
if !ok {
return nil
}
// Check response status
if r.Status != 1 {
return r.Errors
}
// The headers are only returned when posting a new notification
if returnHeaders {
// Get app limits from headers
appLimits, err := newLimit(resp.Header)
if err != nil {
return err
}
r.Limit = appLimits
}
return nil
} | [
"func",
"do",
"(",
"req",
"*",
"http",
".",
"Request",
",",
"resType",
"interface",
"{",
"}",
",",
"returnHeaders",
"bool",
")",
"error",
"{",
"client",
":=",
"http",
".",
"DefaultClient",
"\n\n",
"// Send request",
"resp",
",",
"err",
":=",
"client",
".",
"Do",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n\n",
"// Only 500 errors will not respond a readable result",
"if",
"resp",
".",
"StatusCode",
">=",
"http",
".",
"StatusInternalServerError",
"{",
"return",
"ErrHTTPPushover",
"\n",
"}",
"\n\n",
"// Decode the JSON response",
"if",
"err",
":=",
"json",
".",
"NewDecoder",
"(",
"resp",
".",
"Body",
")",
".",
"Decode",
"(",
"&",
"resType",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Check if the unmarshaled data is a response",
"r",
",",
"ok",
":=",
"resType",
".",
"(",
"*",
"Response",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// Check response status",
"if",
"r",
".",
"Status",
"!=",
"1",
"{",
"return",
"r",
".",
"Errors",
"\n",
"}",
"\n\n",
"// The headers are only returned when posting a new notification",
"if",
"returnHeaders",
"{",
"// Get app limits from headers",
"appLimits",
",",
"err",
":=",
"newLimit",
"(",
"resp",
".",
"Header",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"r",
".",
"Limit",
"=",
"appLimits",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // do is a generic function to send a request to the API. | [
"do",
"is",
"a",
"generic",
"function",
"to",
"send",
"a",
"request",
"to",
"the",
"API",
"."
] | 15d3fef406363e87c21b8ffa5dbe430bff13ac76 | https://github.com/gregdel/pushover/blob/15d3fef406363e87c21b8ffa5dbe430bff13ac76/request.go#L11-L53 |
12,037 | gregdel/pushover | response.go | String | func (r Response) String() string {
ret := fmt.Sprintf("Request id: %s\n", r.ID)
if r.Receipt != "" {
ret += fmt.Sprintf("Receipt: %s\n", r.Receipt)
}
if r.Limit != nil {
ret += fmt.Sprintf("Usage %d/%d messages\nNext reset : %s",
r.Limit.Remaining, r.Limit.Total, r.Limit.NextReset)
}
return ret
} | go | func (r Response) String() string {
ret := fmt.Sprintf("Request id: %s\n", r.ID)
if r.Receipt != "" {
ret += fmt.Sprintf("Receipt: %s\n", r.Receipt)
}
if r.Limit != nil {
ret += fmt.Sprintf("Usage %d/%d messages\nNext reset : %s",
r.Limit.Remaining, r.Limit.Total, r.Limit.NextReset)
}
return ret
} | [
"func",
"(",
"r",
"Response",
")",
"String",
"(",
")",
"string",
"{",
"ret",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\"",
",",
"r",
".",
"ID",
")",
"\n",
"if",
"r",
".",
"Receipt",
"!=",
"\"",
"\"",
"{",
"ret",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\"",
",",
"r",
".",
"Receipt",
")",
"\n",
"}",
"\n",
"if",
"r",
".",
"Limit",
"!=",
"nil",
"{",
"ret",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\"",
",",
"r",
".",
"Limit",
".",
"Remaining",
",",
"r",
".",
"Limit",
".",
"Total",
",",
"r",
".",
"Limit",
".",
"NextReset",
")",
"\n",
"}",
"\n",
"return",
"ret",
"\n",
"}"
] | // String represents a printable form of the response. | [
"String",
"represents",
"a",
"printable",
"form",
"of",
"the",
"response",
"."
] | 15d3fef406363e87c21b8ffa5dbe430bff13ac76 | https://github.com/gregdel/pushover/blob/15d3fef406363e87c21b8ffa5dbe430bff13ac76/response.go#L15-L25 |
12,038 | gregdel/pushover | message.go | NewMessageWithTitle | func NewMessageWithTitle(message, title string) *Message {
return &Message{Message: message, Title: title}
} | go | func NewMessageWithTitle(message, title string) *Message {
return &Message{Message: message, Title: title}
} | [
"func",
"NewMessageWithTitle",
"(",
"message",
",",
"title",
"string",
")",
"*",
"Message",
"{",
"return",
"&",
"Message",
"{",
"Message",
":",
"message",
",",
"Title",
":",
"title",
"}",
"\n",
"}"
] | // NewMessageWithTitle returns a simple new message with a title. | [
"NewMessageWithTitle",
"returns",
"a",
"simple",
"new",
"message",
"with",
"a",
"title",
"."
] | 15d3fef406363e87c21b8ffa5dbe430bff13ac76 | https://github.com/gregdel/pushover/blob/15d3fef406363e87c21b8ffa5dbe430bff13ac76/message.go#L49-L51 |
12,039 | gregdel/pushover | message.go | AddAttachment | func (m *Message) AddAttachment(attachment io.Reader) error {
m.attachment = attachment
return nil
} | go | func (m *Message) AddAttachment(attachment io.Reader) error {
m.attachment = attachment
return nil
} | [
"func",
"(",
"m",
"*",
"Message",
")",
"AddAttachment",
"(",
"attachment",
"io",
".",
"Reader",
")",
"error",
"{",
"m",
".",
"attachment",
"=",
"attachment",
"\n",
"return",
"nil",
"\n",
"}"
] | // AddAttachment adds an attachment to the message it's programmer's
// responsibility to close the reader. | [
"AddAttachment",
"adds",
"an",
"attachment",
"to",
"the",
"message",
"it",
"s",
"programmer",
"s",
"responsibility",
"to",
"close",
"the",
"reader",
"."
] | 15d3fef406363e87c21b8ffa5dbe430bff13ac76 | https://github.com/gregdel/pushover/blob/15d3fef406363e87c21b8ffa5dbe430bff13ac76/message.go#L55-L58 |
12,040 | gregdel/pushover | message.go | validate | func (m *Message) validate() error {
// Message should no be empty
if m.Message == "" {
return ErrMessageEmpty
}
// Validate message length
if utf8.RuneCountInString(m.Message) > MessageMaxLength {
return ErrMessageTooLong
}
// Validate Title field length
if utf8.RuneCountInString(m.Title) > MessageTitleMaxLength {
return ErrMessageTitleTooLong
}
// Validate URL field
if utf8.RuneCountInString(m.URL) > MessageURLMaxLength {
return ErrMessageURLTooLong
}
// Validate URL title field
if utf8.RuneCountInString(m.URLTitle) > MessageURLTitleMaxLength {
return ErrMessageURLTitleTooLong
}
// URLTitle should not be set with an empty URL
if m.URL == "" && m.URLTitle != "" {
return ErrEmptyURL
}
// Validate priorities
if m.Priority > PriorityEmergency || m.Priority < PriorityLowest {
return ErrInvalidPriority
}
// Validate emergency priority
if m.Priority == PriorityEmergency {
if m.Retry == 0 || m.Expire == 0 {
return ErrMissingEmergencyParameter
}
}
// Test device name
if m.DeviceName != "" {
if deviceNameRegexp.MatchString(m.DeviceName) == false {
return ErrInvalidDeviceName
}
}
return nil
} | go | func (m *Message) validate() error {
// Message should no be empty
if m.Message == "" {
return ErrMessageEmpty
}
// Validate message length
if utf8.RuneCountInString(m.Message) > MessageMaxLength {
return ErrMessageTooLong
}
// Validate Title field length
if utf8.RuneCountInString(m.Title) > MessageTitleMaxLength {
return ErrMessageTitleTooLong
}
// Validate URL field
if utf8.RuneCountInString(m.URL) > MessageURLMaxLength {
return ErrMessageURLTooLong
}
// Validate URL title field
if utf8.RuneCountInString(m.URLTitle) > MessageURLTitleMaxLength {
return ErrMessageURLTitleTooLong
}
// URLTitle should not be set with an empty URL
if m.URL == "" && m.URLTitle != "" {
return ErrEmptyURL
}
// Validate priorities
if m.Priority > PriorityEmergency || m.Priority < PriorityLowest {
return ErrInvalidPriority
}
// Validate emergency priority
if m.Priority == PriorityEmergency {
if m.Retry == 0 || m.Expire == 0 {
return ErrMissingEmergencyParameter
}
}
// Test device name
if m.DeviceName != "" {
if deviceNameRegexp.MatchString(m.DeviceName) == false {
return ErrInvalidDeviceName
}
}
return nil
} | [
"func",
"(",
"m",
"*",
"Message",
")",
"validate",
"(",
")",
"error",
"{",
"// Message should no be empty",
"if",
"m",
".",
"Message",
"==",
"\"",
"\"",
"{",
"return",
"ErrMessageEmpty",
"\n",
"}",
"\n\n",
"// Validate message length",
"if",
"utf8",
".",
"RuneCountInString",
"(",
"m",
".",
"Message",
")",
">",
"MessageMaxLength",
"{",
"return",
"ErrMessageTooLong",
"\n",
"}",
"\n\n",
"// Validate Title field length",
"if",
"utf8",
".",
"RuneCountInString",
"(",
"m",
".",
"Title",
")",
">",
"MessageTitleMaxLength",
"{",
"return",
"ErrMessageTitleTooLong",
"\n",
"}",
"\n\n",
"// Validate URL field",
"if",
"utf8",
".",
"RuneCountInString",
"(",
"m",
".",
"URL",
")",
">",
"MessageURLMaxLength",
"{",
"return",
"ErrMessageURLTooLong",
"\n",
"}",
"\n\n",
"// Validate URL title field",
"if",
"utf8",
".",
"RuneCountInString",
"(",
"m",
".",
"URLTitle",
")",
">",
"MessageURLTitleMaxLength",
"{",
"return",
"ErrMessageURLTitleTooLong",
"\n",
"}",
"\n\n",
"// URLTitle should not be set with an empty URL",
"if",
"m",
".",
"URL",
"==",
"\"",
"\"",
"&&",
"m",
".",
"URLTitle",
"!=",
"\"",
"\"",
"{",
"return",
"ErrEmptyURL",
"\n",
"}",
"\n\n",
"// Validate priorities",
"if",
"m",
".",
"Priority",
">",
"PriorityEmergency",
"||",
"m",
".",
"Priority",
"<",
"PriorityLowest",
"{",
"return",
"ErrInvalidPriority",
"\n",
"}",
"\n\n",
"// Validate emergency priority",
"if",
"m",
".",
"Priority",
"==",
"PriorityEmergency",
"{",
"if",
"m",
".",
"Retry",
"==",
"0",
"||",
"m",
".",
"Expire",
"==",
"0",
"{",
"return",
"ErrMissingEmergencyParameter",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Test device name",
"if",
"m",
".",
"DeviceName",
"!=",
"\"",
"\"",
"{",
"if",
"deviceNameRegexp",
".",
"MatchString",
"(",
"m",
".",
"DeviceName",
")",
"==",
"false",
"{",
"return",
"ErrInvalidDeviceName",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Validate the message values. | [
"Validate",
"the",
"message",
"values",
"."
] | 15d3fef406363e87c21b8ffa5dbe430bff13ac76 | https://github.com/gregdel/pushover/blob/15d3fef406363e87c21b8ffa5dbe430bff13ac76/message.go#L61-L112 |
12,041 | gregdel/pushover | message.go | toMap | func (m *Message) toMap(pToken, rToken string) map[string]string {
ret := map[string]string{
"token": pToken,
"user": rToken,
"message": m.Message,
"priority": strconv.Itoa(m.Priority),
}
if m.Title != "" {
ret["title"] = m.Title
}
if m.URL != "" {
ret["url"] = m.URL
}
if m.URLTitle != "" {
ret["url_title"] = m.URLTitle
}
if m.Sound != "" {
ret["sound"] = m.Sound
}
if m.DeviceName != "" {
ret["device"] = m.DeviceName
}
if m.Timestamp != 0 {
ret["timestamp"] = strconv.FormatInt(m.Timestamp, 10)
}
if m.HTML {
ret["html"] = "1"
}
if m.Priority == PriorityEmergency {
ret["retry"] = strconv.FormatFloat(m.Retry.Seconds(), 'f', -1, 64)
ret["expire"] = strconv.FormatFloat(m.Expire.Seconds(), 'f', -1, 64)
if m.CallbackURL != "" {
ret["callback"] = m.CallbackURL
}
}
return ret
} | go | func (m *Message) toMap(pToken, rToken string) map[string]string {
ret := map[string]string{
"token": pToken,
"user": rToken,
"message": m.Message,
"priority": strconv.Itoa(m.Priority),
}
if m.Title != "" {
ret["title"] = m.Title
}
if m.URL != "" {
ret["url"] = m.URL
}
if m.URLTitle != "" {
ret["url_title"] = m.URLTitle
}
if m.Sound != "" {
ret["sound"] = m.Sound
}
if m.DeviceName != "" {
ret["device"] = m.DeviceName
}
if m.Timestamp != 0 {
ret["timestamp"] = strconv.FormatInt(m.Timestamp, 10)
}
if m.HTML {
ret["html"] = "1"
}
if m.Priority == PriorityEmergency {
ret["retry"] = strconv.FormatFloat(m.Retry.Seconds(), 'f', -1, 64)
ret["expire"] = strconv.FormatFloat(m.Expire.Seconds(), 'f', -1, 64)
if m.CallbackURL != "" {
ret["callback"] = m.CallbackURL
}
}
return ret
} | [
"func",
"(",
"m",
"*",
"Message",
")",
"toMap",
"(",
"pToken",
",",
"rToken",
"string",
")",
"map",
"[",
"string",
"]",
"string",
"{",
"ret",
":=",
"map",
"[",
"string",
"]",
"string",
"{",
"\"",
"\"",
":",
"pToken",
",",
"\"",
"\"",
":",
"rToken",
",",
"\"",
"\"",
":",
"m",
".",
"Message",
",",
"\"",
"\"",
":",
"strconv",
".",
"Itoa",
"(",
"m",
".",
"Priority",
")",
",",
"}",
"\n\n",
"if",
"m",
".",
"Title",
"!=",
"\"",
"\"",
"{",
"ret",
"[",
"\"",
"\"",
"]",
"=",
"m",
".",
"Title",
"\n",
"}",
"\n\n",
"if",
"m",
".",
"URL",
"!=",
"\"",
"\"",
"{",
"ret",
"[",
"\"",
"\"",
"]",
"=",
"m",
".",
"URL",
"\n",
"}",
"\n\n",
"if",
"m",
".",
"URLTitle",
"!=",
"\"",
"\"",
"{",
"ret",
"[",
"\"",
"\"",
"]",
"=",
"m",
".",
"URLTitle",
"\n",
"}",
"\n\n",
"if",
"m",
".",
"Sound",
"!=",
"\"",
"\"",
"{",
"ret",
"[",
"\"",
"\"",
"]",
"=",
"m",
".",
"Sound",
"\n",
"}",
"\n\n",
"if",
"m",
".",
"DeviceName",
"!=",
"\"",
"\"",
"{",
"ret",
"[",
"\"",
"\"",
"]",
"=",
"m",
".",
"DeviceName",
"\n",
"}",
"\n\n",
"if",
"m",
".",
"Timestamp",
"!=",
"0",
"{",
"ret",
"[",
"\"",
"\"",
"]",
"=",
"strconv",
".",
"FormatInt",
"(",
"m",
".",
"Timestamp",
",",
"10",
")",
"\n",
"}",
"\n\n",
"if",
"m",
".",
"HTML",
"{",
"ret",
"[",
"\"",
"\"",
"]",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"if",
"m",
".",
"Priority",
"==",
"PriorityEmergency",
"{",
"ret",
"[",
"\"",
"\"",
"]",
"=",
"strconv",
".",
"FormatFloat",
"(",
"m",
".",
"Retry",
".",
"Seconds",
"(",
")",
",",
"'f'",
",",
"-",
"1",
",",
"64",
")",
"\n",
"ret",
"[",
"\"",
"\"",
"]",
"=",
"strconv",
".",
"FormatFloat",
"(",
"m",
".",
"Expire",
".",
"Seconds",
"(",
")",
",",
"'f'",
",",
"-",
"1",
",",
"64",
")",
"\n",
"if",
"m",
".",
"CallbackURL",
"!=",
"\"",
"\"",
"{",
"ret",
"[",
"\"",
"\"",
"]",
"=",
"m",
".",
"CallbackURL",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"ret",
"\n",
"}"
] | // Return a map filled with the relevant data. | [
"Return",
"a",
"map",
"filled",
"with",
"the",
"relevant",
"data",
"."
] | 15d3fef406363e87c21b8ffa5dbe430bff13ac76 | https://github.com/gregdel/pushover/blob/15d3fef406363e87c21b8ffa5dbe430bff13ac76/message.go#L115-L160 |
12,042 | gregdel/pushover | message.go | send | func (m *Message) send(pToken, rToken string) (*Response, error) {
url := fmt.Sprintf("%s/messages.json", APIEndpoint)
var f func(string, string, string) (*http.Request, error)
if m.attachment == nil {
// Use a multipart request if a file should be sent
f = m.urlEncodedRequest
} else {
// Use a url encoded request otherwise
f = m.multipartRequest
}
// Post the from and check the headers of the response
req, err := f(pToken, rToken, url)
if err != nil {
return nil, err
}
resp := &Response{}
if err := do(req, resp, true); err != nil {
return nil, err
}
return resp, nil
} | go | func (m *Message) send(pToken, rToken string) (*Response, error) {
url := fmt.Sprintf("%s/messages.json", APIEndpoint)
var f func(string, string, string) (*http.Request, error)
if m.attachment == nil {
// Use a multipart request if a file should be sent
f = m.urlEncodedRequest
} else {
// Use a url encoded request otherwise
f = m.multipartRequest
}
// Post the from and check the headers of the response
req, err := f(pToken, rToken, url)
if err != nil {
return nil, err
}
resp := &Response{}
if err := do(req, resp, true); err != nil {
return nil, err
}
return resp, nil
} | [
"func",
"(",
"m",
"*",
"Message",
")",
"send",
"(",
"pToken",
",",
"rToken",
"string",
")",
"(",
"*",
"Response",
",",
"error",
")",
"{",
"url",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"APIEndpoint",
")",
"\n\n",
"var",
"f",
"func",
"(",
"string",
",",
"string",
",",
"string",
")",
"(",
"*",
"http",
".",
"Request",
",",
"error",
")",
"\n",
"if",
"m",
".",
"attachment",
"==",
"nil",
"{",
"// Use a multipart request if a file should be sent",
"f",
"=",
"m",
".",
"urlEncodedRequest",
"\n",
"}",
"else",
"{",
"// Use a url encoded request otherwise",
"f",
"=",
"m",
".",
"multipartRequest",
"\n",
"}",
"\n\n",
"// Post the from and check the headers of the response",
"req",
",",
"err",
":=",
"f",
"(",
"pToken",
",",
"rToken",
",",
"url",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"resp",
":=",
"&",
"Response",
"{",
"}",
"\n",
"if",
"err",
":=",
"do",
"(",
"req",
",",
"resp",
",",
"true",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"resp",
",",
"nil",
"\n",
"}"
] | // Send sends the message using the pushover and the recipient tokens. | [
"Send",
"sends",
"the",
"message",
"using",
"the",
"pushover",
"and",
"the",
"recipient",
"tokens",
"."
] | 15d3fef406363e87c21b8ffa5dbe430bff13ac76 | https://github.com/gregdel/pushover/blob/15d3fef406363e87c21b8ffa5dbe430bff13ac76/message.go#L163-L187 |
12,043 | gregdel/pushover | message.go | multipartRequest | func (m *Message) multipartRequest(pToken, rToken, url string) (*http.Request, error) {
body := &bytes.Buffer{}
if m.attachment == nil {
return nil, ErrMissingAttachement
}
// Write the body as multipart form data
w := multipart.NewWriter(body)
// Write the file in the body
fw, err := w.CreateFormFile("attachment", "attachment")
if err != nil {
return nil, err
}
written, err := io.Copy(fw, m.attachment)
if err != nil {
return nil, err
}
if written > MessageMaxAttachementByte {
return nil, ErrMessageAttachementTooLarge
}
// Handle params
for k, v := range m.toMap(pToken, rToken) {
if err := w.WriteField(k, v); err != nil {
return nil, err
}
}
if err := w.Close(); err != nil {
return nil, err
}
req, err := http.NewRequest("POST", url, body)
if err != nil {
return nil, err
}
req.Header.Set("Content-Type", w.FormDataContentType())
return req, nil
} | go | func (m *Message) multipartRequest(pToken, rToken, url string) (*http.Request, error) {
body := &bytes.Buffer{}
if m.attachment == nil {
return nil, ErrMissingAttachement
}
// Write the body as multipart form data
w := multipart.NewWriter(body)
// Write the file in the body
fw, err := w.CreateFormFile("attachment", "attachment")
if err != nil {
return nil, err
}
written, err := io.Copy(fw, m.attachment)
if err != nil {
return nil, err
}
if written > MessageMaxAttachementByte {
return nil, ErrMessageAttachementTooLarge
}
// Handle params
for k, v := range m.toMap(pToken, rToken) {
if err := w.WriteField(k, v); err != nil {
return nil, err
}
}
if err := w.Close(); err != nil {
return nil, err
}
req, err := http.NewRequest("POST", url, body)
if err != nil {
return nil, err
}
req.Header.Set("Content-Type", w.FormDataContentType())
return req, nil
} | [
"func",
"(",
"m",
"*",
"Message",
")",
"multipartRequest",
"(",
"pToken",
",",
"rToken",
",",
"url",
"string",
")",
"(",
"*",
"http",
".",
"Request",
",",
"error",
")",
"{",
"body",
":=",
"&",
"bytes",
".",
"Buffer",
"{",
"}",
"\n\n",
"if",
"m",
".",
"attachment",
"==",
"nil",
"{",
"return",
"nil",
",",
"ErrMissingAttachement",
"\n",
"}",
"\n\n",
"// Write the body as multipart form data",
"w",
":=",
"multipart",
".",
"NewWriter",
"(",
"body",
")",
"\n\n",
"// Write the file in the body",
"fw",
",",
"err",
":=",
"w",
".",
"CreateFormFile",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"written",
",",
"err",
":=",
"io",
".",
"Copy",
"(",
"fw",
",",
"m",
".",
"attachment",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"written",
">",
"MessageMaxAttachementByte",
"{",
"return",
"nil",
",",
"ErrMessageAttachementTooLarge",
"\n",
"}",
"\n\n",
"// Handle params",
"for",
"k",
",",
"v",
":=",
"range",
"m",
".",
"toMap",
"(",
"pToken",
",",
"rToken",
")",
"{",
"if",
"err",
":=",
"w",
".",
"WriteField",
"(",
"k",
",",
"v",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"w",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"req",
",",
"err",
":=",
"http",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"url",
",",
"body",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"req",
".",
"Header",
".",
"Set",
"(",
"\"",
"\"",
",",
"w",
".",
"FormDataContentType",
"(",
")",
")",
"\n\n",
"return",
"req",
",",
"nil",
"\n",
"}"
] | // multipartRequest returns a new multipart POST request with a file attached. | [
"multipartRequest",
"returns",
"a",
"new",
"multipart",
"POST",
"request",
"with",
"a",
"file",
"attached",
"."
] | 15d3fef406363e87c21b8ffa5dbe430bff13ac76 | https://github.com/gregdel/pushover/blob/15d3fef406363e87c21b8ffa5dbe430bff13ac76/message.go#L190-L233 |
12,044 | gregdel/pushover | errors.go | Error | func (e Errors) Error() string {
ret := ""
if len(e) > 0 {
ret = fmt.Sprintf("Errors:\n")
ret += strings.Join(e, "\n")
}
return ret
} | go | func (e Errors) Error() string {
ret := ""
if len(e) > 0 {
ret = fmt.Sprintf("Errors:\n")
ret += strings.Join(e, "\n")
}
return ret
} | [
"func",
"(",
"e",
"Errors",
")",
"Error",
"(",
")",
"string",
"{",
"ret",
":=",
"\"",
"\"",
"\n",
"if",
"len",
"(",
"e",
")",
">",
"0",
"{",
"ret",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\"",
")",
"\n",
"ret",
"+=",
"strings",
".",
"Join",
"(",
"e",
",",
"\"",
"\\n",
"\"",
")",
"\n",
"}",
"\n",
"return",
"ret",
"\n",
"}"
] | // Error represents the error as a string. | [
"Error",
"represents",
"the",
"error",
"as",
"a",
"string",
"."
] | 15d3fef406363e87c21b8ffa5dbe430bff13ac76 | https://github.com/gregdel/pushover/blob/15d3fef406363e87c21b8ffa5dbe430bff13ac76/errors.go#L12-L19 |
12,045 | gregdel/pushover | receipt_details.go | UnmarshalJSON | func (r *ReceiptDetails) UnmarshalJSON(data []byte) error {
dataBytes := bytes.NewReader(data)
var aux struct {
ID string `json:"request"`
Status int `json:"status"`
Acknowledged intBool `json:"acknowledged"`
AcknowledgedBy string `json:"acknowledged_by"`
Expired intBool `json:"expired"`
CalledBack intBool `json:"called_back"`
AcknowledgedAt *timestamp `json:"acknowledged_at"`
LastDeliveredAt *timestamp `json:"last_delivered_at"`
ExpiresAt *timestamp `json:"expires_at"`
CalledBackAt *timestamp `json:"called_back_at"`
}
// Decode json into the aux struct
if err := json.NewDecoder(dataBytes).Decode(&aux); err != nil {
return err
}
// Set the RecipientDetails with the right types
r.Status = aux.Status
r.Acknowledged = bool(aux.Acknowledged)
r.AcknowledgedBy = aux.AcknowledgedBy
r.Expired = bool(aux.Expired)
r.CalledBack = bool(aux.CalledBack)
r.ID = aux.ID
r.AcknowledgedAt = aux.AcknowledgedAt.Time
r.LastDeliveredAt = aux.LastDeliveredAt.Time
r.ExpiresAt = aux.ExpiresAt.Time
r.CalledBackAt = aux.CalledBackAt.Time
return nil
} | go | func (r *ReceiptDetails) UnmarshalJSON(data []byte) error {
dataBytes := bytes.NewReader(data)
var aux struct {
ID string `json:"request"`
Status int `json:"status"`
Acknowledged intBool `json:"acknowledged"`
AcknowledgedBy string `json:"acknowledged_by"`
Expired intBool `json:"expired"`
CalledBack intBool `json:"called_back"`
AcknowledgedAt *timestamp `json:"acknowledged_at"`
LastDeliveredAt *timestamp `json:"last_delivered_at"`
ExpiresAt *timestamp `json:"expires_at"`
CalledBackAt *timestamp `json:"called_back_at"`
}
// Decode json into the aux struct
if err := json.NewDecoder(dataBytes).Decode(&aux); err != nil {
return err
}
// Set the RecipientDetails with the right types
r.Status = aux.Status
r.Acknowledged = bool(aux.Acknowledged)
r.AcknowledgedBy = aux.AcknowledgedBy
r.Expired = bool(aux.Expired)
r.CalledBack = bool(aux.CalledBack)
r.ID = aux.ID
r.AcknowledgedAt = aux.AcknowledgedAt.Time
r.LastDeliveredAt = aux.LastDeliveredAt.Time
r.ExpiresAt = aux.ExpiresAt.Time
r.CalledBackAt = aux.CalledBackAt.Time
return nil
} | [
"func",
"(",
"r",
"*",
"ReceiptDetails",
")",
"UnmarshalJSON",
"(",
"data",
"[",
"]",
"byte",
")",
"error",
"{",
"dataBytes",
":=",
"bytes",
".",
"NewReader",
"(",
"data",
")",
"\n",
"var",
"aux",
"struct",
"{",
"ID",
"string",
"`json:\"request\"`",
"\n",
"Status",
"int",
"`json:\"status\"`",
"\n",
"Acknowledged",
"intBool",
"`json:\"acknowledged\"`",
"\n",
"AcknowledgedBy",
"string",
"`json:\"acknowledged_by\"`",
"\n",
"Expired",
"intBool",
"`json:\"expired\"`",
"\n",
"CalledBack",
"intBool",
"`json:\"called_back\"`",
"\n",
"AcknowledgedAt",
"*",
"timestamp",
"`json:\"acknowledged_at\"`",
"\n",
"LastDeliveredAt",
"*",
"timestamp",
"`json:\"last_delivered_at\"`",
"\n",
"ExpiresAt",
"*",
"timestamp",
"`json:\"expires_at\"`",
"\n",
"CalledBackAt",
"*",
"timestamp",
"`json:\"called_back_at\"`",
"\n",
"}",
"\n\n",
"// Decode json into the aux struct",
"if",
"err",
":=",
"json",
".",
"NewDecoder",
"(",
"dataBytes",
")",
".",
"Decode",
"(",
"&",
"aux",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Set the RecipientDetails with the right types",
"r",
".",
"Status",
"=",
"aux",
".",
"Status",
"\n",
"r",
".",
"Acknowledged",
"=",
"bool",
"(",
"aux",
".",
"Acknowledged",
")",
"\n",
"r",
".",
"AcknowledgedBy",
"=",
"aux",
".",
"AcknowledgedBy",
"\n",
"r",
".",
"Expired",
"=",
"bool",
"(",
"aux",
".",
"Expired",
")",
"\n",
"r",
".",
"CalledBack",
"=",
"bool",
"(",
"aux",
".",
"CalledBack",
")",
"\n",
"r",
".",
"ID",
"=",
"aux",
".",
"ID",
"\n",
"r",
".",
"AcknowledgedAt",
"=",
"aux",
".",
"AcknowledgedAt",
".",
"Time",
"\n",
"r",
".",
"LastDeliveredAt",
"=",
"aux",
".",
"LastDeliveredAt",
".",
"Time",
"\n",
"r",
".",
"ExpiresAt",
"=",
"aux",
".",
"ExpiresAt",
".",
"Time",
"\n",
"r",
".",
"CalledBackAt",
"=",
"aux",
".",
"CalledBackAt",
".",
"Time",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // UnmarshalJSON is a custom unmarshal function to handle timestamps and
// boolean as int and convert them to the right type. | [
"UnmarshalJSON",
"is",
"a",
"custom",
"unmarshal",
"function",
"to",
"handle",
"timestamps",
"and",
"boolean",
"as",
"int",
"and",
"convert",
"them",
"to",
"the",
"right",
"type",
"."
] | 15d3fef406363e87c21b8ffa5dbe430bff13ac76 | https://github.com/gregdel/pushover/blob/15d3fef406363e87c21b8ffa5dbe430bff13ac76/receipt_details.go#L26-L59 |
12,046 | gregdel/pushover | pushover.go | validate | func (p *Pushover) validate() error {
// Check empty token
if p.token == "" {
return ErrEmptyToken
}
// Check invalid token
if tokenRegexp.MatchString(p.token) == false {
return ErrInvalidToken
}
return nil
} | go | func (p *Pushover) validate() error {
// Check empty token
if p.token == "" {
return ErrEmptyToken
}
// Check invalid token
if tokenRegexp.MatchString(p.token) == false {
return ErrInvalidToken
}
return nil
} | [
"func",
"(",
"p",
"*",
"Pushover",
")",
"validate",
"(",
")",
"error",
"{",
"// Check empty token",
"if",
"p",
".",
"token",
"==",
"\"",
"\"",
"{",
"return",
"ErrEmptyToken",
"\n",
"}",
"\n\n",
"// Check invalid token",
"if",
"tokenRegexp",
".",
"MatchString",
"(",
"p",
".",
"token",
")",
"==",
"false",
"{",
"return",
"ErrInvalidToken",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Validate Pushover token. | [
"Validate",
"Pushover",
"token",
"."
] | 15d3fef406363e87c21b8ffa5dbe430bff13ac76 | https://github.com/gregdel/pushover/blob/15d3fef406363e87c21b8ffa5dbe430bff13ac76/pushover.go#L105-L116 |
12,047 | gregdel/pushover | pushover.go | SendMessage | func (p *Pushover) SendMessage(message *Message, recipient *Recipient) (*Response, error) {
// Validate pushover
if err := p.validate(); err != nil {
return nil, err
}
// Validate recipient
if err := recipient.validate(); err != nil {
return nil, err
}
// Validate message
if err := message.validate(); err != nil {
return nil, err
}
return message.send(p.token, recipient.token)
} | go | func (p *Pushover) SendMessage(message *Message, recipient *Recipient) (*Response, error) {
// Validate pushover
if err := p.validate(); err != nil {
return nil, err
}
// Validate recipient
if err := recipient.validate(); err != nil {
return nil, err
}
// Validate message
if err := message.validate(); err != nil {
return nil, err
}
return message.send(p.token, recipient.token)
} | [
"func",
"(",
"p",
"*",
"Pushover",
")",
"SendMessage",
"(",
"message",
"*",
"Message",
",",
"recipient",
"*",
"Recipient",
")",
"(",
"*",
"Response",
",",
"error",
")",
"{",
"// Validate pushover",
"if",
"err",
":=",
"p",
".",
"validate",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Validate recipient",
"if",
"err",
":=",
"recipient",
".",
"validate",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Validate message",
"if",
"err",
":=",
"message",
".",
"validate",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"message",
".",
"send",
"(",
"p",
".",
"token",
",",
"recipient",
".",
"token",
")",
"\n",
"}"
] | // SendMessage is used to send message to a recipient. | [
"SendMessage",
"is",
"used",
"to",
"send",
"message",
"to",
"a",
"recipient",
"."
] | 15d3fef406363e87c21b8ffa5dbe430bff13ac76 | https://github.com/gregdel/pushover/blob/15d3fef406363e87c21b8ffa5dbe430bff13ac76/pushover.go#L119-L136 |
12,048 | gregdel/pushover | pushover.go | GetReceiptDetails | func (p *Pushover) GetReceiptDetails(receipt string) (*ReceiptDetails, error) {
url := fmt.Sprintf("%s/receipts/%s.json?token=%s", APIEndpoint, receipt, p.token)
if receipt == "" {
return nil, ErrEmptyReceipt
}
// Send request
resp, err := http.Get(url)
if err != nil {
return nil, err
}
// Decode the JSON response
var details *ReceiptDetails
if err = json.NewDecoder(resp.Body).Decode(&details); err != nil {
return nil, err
}
return details, nil
} | go | func (p *Pushover) GetReceiptDetails(receipt string) (*ReceiptDetails, error) {
url := fmt.Sprintf("%s/receipts/%s.json?token=%s", APIEndpoint, receipt, p.token)
if receipt == "" {
return nil, ErrEmptyReceipt
}
// Send request
resp, err := http.Get(url)
if err != nil {
return nil, err
}
// Decode the JSON response
var details *ReceiptDetails
if err = json.NewDecoder(resp.Body).Decode(&details); err != nil {
return nil, err
}
return details, nil
} | [
"func",
"(",
"p",
"*",
"Pushover",
")",
"GetReceiptDetails",
"(",
"receipt",
"string",
")",
"(",
"*",
"ReceiptDetails",
",",
"error",
")",
"{",
"url",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"APIEndpoint",
",",
"receipt",
",",
"p",
".",
"token",
")",
"\n\n",
"if",
"receipt",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"ErrEmptyReceipt",
"\n",
"}",
"\n\n",
"// Send request",
"resp",
",",
"err",
":=",
"http",
".",
"Get",
"(",
"url",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Decode the JSON response",
"var",
"details",
"*",
"ReceiptDetails",
"\n",
"if",
"err",
"=",
"json",
".",
"NewDecoder",
"(",
"resp",
".",
"Body",
")",
".",
"Decode",
"(",
"&",
"details",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"details",
",",
"nil",
"\n",
"}"
] | // GetReceiptDetails return detailed informations about a receipt. This is used
// used to check the acknowledged status of an Emergency notification. | [
"GetReceiptDetails",
"return",
"detailed",
"informations",
"about",
"a",
"receipt",
".",
"This",
"is",
"used",
"used",
"to",
"check",
"the",
"acknowledged",
"status",
"of",
"an",
"Emergency",
"notification",
"."
] | 15d3fef406363e87c21b8ffa5dbe430bff13ac76 | https://github.com/gregdel/pushover/blob/15d3fef406363e87c21b8ffa5dbe430bff13ac76/pushover.go#L140-L160 |
12,049 | gregdel/pushover | pushover.go | GetRecipientDetails | func (p *Pushover) GetRecipientDetails(recipient *Recipient) (*RecipientDetails, error) {
endpoint := fmt.Sprintf("%s/users/validate.json", APIEndpoint)
// Validate pushover
if err := p.validate(); err != nil {
return nil, err
}
// Validate recipient
if err := recipient.validate(); err != nil {
return nil, err
}
req, err := newURLEncodedRequest("POST", endpoint,
map[string]string{"token": p.token, "user": recipient.token})
if err != nil {
return nil, err
}
var response RecipientDetails
if err := do(req, &response, false); err != nil {
return nil, err
}
return &response, nil
} | go | func (p *Pushover) GetRecipientDetails(recipient *Recipient) (*RecipientDetails, error) {
endpoint := fmt.Sprintf("%s/users/validate.json", APIEndpoint)
// Validate pushover
if err := p.validate(); err != nil {
return nil, err
}
// Validate recipient
if err := recipient.validate(); err != nil {
return nil, err
}
req, err := newURLEncodedRequest("POST", endpoint,
map[string]string{"token": p.token, "user": recipient.token})
if err != nil {
return nil, err
}
var response RecipientDetails
if err := do(req, &response, false); err != nil {
return nil, err
}
return &response, nil
} | [
"func",
"(",
"p",
"*",
"Pushover",
")",
"GetRecipientDetails",
"(",
"recipient",
"*",
"Recipient",
")",
"(",
"*",
"RecipientDetails",
",",
"error",
")",
"{",
"endpoint",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"APIEndpoint",
")",
"\n\n",
"// Validate pushover",
"if",
"err",
":=",
"p",
".",
"validate",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Validate recipient",
"if",
"err",
":=",
"recipient",
".",
"validate",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"req",
",",
"err",
":=",
"newURLEncodedRequest",
"(",
"\"",
"\"",
",",
"endpoint",
",",
"map",
"[",
"string",
"]",
"string",
"{",
"\"",
"\"",
":",
"p",
".",
"token",
",",
"\"",
"\"",
":",
"recipient",
".",
"token",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"response",
"RecipientDetails",
"\n",
"if",
"err",
":=",
"do",
"(",
"req",
",",
"&",
"response",
",",
"false",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"response",
",",
"nil",
"\n",
"}"
] | // GetRecipientDetails allows to check if a recipient exists, if it's a group
// and the devices associated to this recipient. It returns an
// ErrInvalidRecipient if the recipient is not valid in the Pushover API. | [
"GetRecipientDetails",
"allows",
"to",
"check",
"if",
"a",
"recipient",
"exists",
"if",
"it",
"s",
"a",
"group",
"and",
"the",
"devices",
"associated",
"to",
"this",
"recipient",
".",
"It",
"returns",
"an",
"ErrInvalidRecipient",
"if",
"the",
"recipient",
"is",
"not",
"valid",
"in",
"the",
"Pushover",
"API",
"."
] | 15d3fef406363e87c21b8ffa5dbe430bff13ac76 | https://github.com/gregdel/pushover/blob/15d3fef406363e87c21b8ffa5dbe430bff13ac76/pushover.go#L165-L190 |
12,050 | gregdel/pushover | pushover.go | CancelEmergencyNotification | func (p *Pushover) CancelEmergencyNotification(receipt string) (*Response, error) {
endpoint := fmt.Sprintf("%s/receipts/%s/cancel.json", APIEndpoint, receipt)
req, err := newURLEncodedRequest("GET", endpoint, map[string]string{"token": p.token})
if err != nil {
return nil, err
}
response := &Response{}
if err := do(req, response, false); err != nil {
return nil, err
}
return response, nil
} | go | func (p *Pushover) CancelEmergencyNotification(receipt string) (*Response, error) {
endpoint := fmt.Sprintf("%s/receipts/%s/cancel.json", APIEndpoint, receipt)
req, err := newURLEncodedRequest("GET", endpoint, map[string]string{"token": p.token})
if err != nil {
return nil, err
}
response := &Response{}
if err := do(req, response, false); err != nil {
return nil, err
}
return response, nil
} | [
"func",
"(",
"p",
"*",
"Pushover",
")",
"CancelEmergencyNotification",
"(",
"receipt",
"string",
")",
"(",
"*",
"Response",
",",
"error",
")",
"{",
"endpoint",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"APIEndpoint",
",",
"receipt",
")",
"\n\n",
"req",
",",
"err",
":=",
"newURLEncodedRequest",
"(",
"\"",
"\"",
",",
"endpoint",
",",
"map",
"[",
"string",
"]",
"string",
"{",
"\"",
"\"",
":",
"p",
".",
"token",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"response",
":=",
"&",
"Response",
"{",
"}",
"\n",
"if",
"err",
":=",
"do",
"(",
"req",
",",
"response",
",",
"false",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"response",
",",
"nil",
"\n",
"}"
] | // CancelEmergencyNotification helps stop a notification retry in case of a
// notification with an Emergency priority before reaching the expiration time.
// It requires the response receipt in order to stop the right notification. | [
"CancelEmergencyNotification",
"helps",
"stop",
"a",
"notification",
"retry",
"in",
"case",
"of",
"a",
"notification",
"with",
"an",
"Emergency",
"priority",
"before",
"reaching",
"the",
"expiration",
"time",
".",
"It",
"requires",
"the",
"response",
"receipt",
"in",
"order",
"to",
"stop",
"the",
"right",
"notification",
"."
] | 15d3fef406363e87c21b8ffa5dbe430bff13ac76 | https://github.com/gregdel/pushover/blob/15d3fef406363e87c21b8ffa5dbe430bff13ac76/pushover.go#L195-L209 |
12,051 | johntdyer/slackrus | levels.go | LevelThreshold | func LevelThreshold(l logrus.Level) []logrus.Level {
for i := range AllLevels {
if AllLevels[i] == l {
return AllLevels[i:]
}
}
return []logrus.Level{}
} | go | func LevelThreshold(l logrus.Level) []logrus.Level {
for i := range AllLevels {
if AllLevels[i] == l {
return AllLevels[i:]
}
}
return []logrus.Level{}
} | [
"func",
"LevelThreshold",
"(",
"l",
"logrus",
".",
"Level",
")",
"[",
"]",
"logrus",
".",
"Level",
"{",
"for",
"i",
":=",
"range",
"AllLevels",
"{",
"if",
"AllLevels",
"[",
"i",
"]",
"==",
"l",
"{",
"return",
"AllLevels",
"[",
"i",
":",
"]",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"[",
"]",
"logrus",
".",
"Level",
"{",
"}",
"\n",
"}"
] | // LevelThreshold - Returns every logging level above and including the given parameter. | [
"LevelThreshold",
"-",
"Returns",
"every",
"logging",
"level",
"above",
"and",
"including",
"the",
"given",
"parameter",
"."
] | f7aae3243a0786c5a974bce71ed951c459876e64 | https://github.com/johntdyer/slackrus/blob/f7aae3243a0786c5a974bce71ed951c459876e64/levels.go#L18-L25 |
12,052 | oz/osdb | client.go | FileSearch | func (c *Client) FileSearch(path string, langs []string) (Subtitles, error) {
// Hash file, and other params values.
params, err := c.fileToSearchParams(path, langs)
if err != nil {
return nil, err
}
return c.SearchSubtitles(params)
} | go | func (c *Client) FileSearch(path string, langs []string) (Subtitles, error) {
// Hash file, and other params values.
params, err := c.fileToSearchParams(path, langs)
if err != nil {
return nil, err
}
return c.SearchSubtitles(params)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"FileSearch",
"(",
"path",
"string",
",",
"langs",
"[",
"]",
"string",
")",
"(",
"Subtitles",
",",
"error",
")",
"{",
"// Hash file, and other params values.",
"params",
",",
"err",
":=",
"c",
".",
"fileToSearchParams",
"(",
"path",
",",
"langs",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"c",
".",
"SearchSubtitles",
"(",
"params",
")",
"\n",
"}"
] | // FileSearch searches subtitles for a file and list of languages. | [
"FileSearch",
"searches",
"subtitles",
"for",
"a",
"file",
"and",
"list",
"of",
"languages",
"."
] | da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764 | https://github.com/oz/osdb/blob/da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764/client.go#L70-L77 |
12,053 | oz/osdb | client.go | IMDBSearchByID | func (c *Client) IMDBSearchByID(ids []string, langs []string) (Subtitles, error) {
// OSDB search params struct
params := []interface{}{
c.Token,
[]map[string]string{},
}
// Convert ids []string into a slice of map[string]string for search. Ouch!
for _, imdbID := range ids {
params[1] = append(
params[1].([]map[string]string),
map[string]string{
"imdbid": imdbID,
"sublanguageid": strings.Join(langs, ","),
},
)
}
return c.SearchSubtitles(¶ms)
} | go | func (c *Client) IMDBSearchByID(ids []string, langs []string) (Subtitles, error) {
// OSDB search params struct
params := []interface{}{
c.Token,
[]map[string]string{},
}
// Convert ids []string into a slice of map[string]string for search. Ouch!
for _, imdbID := range ids {
params[1] = append(
params[1].([]map[string]string),
map[string]string{
"imdbid": imdbID,
"sublanguageid": strings.Join(langs, ","),
},
)
}
return c.SearchSubtitles(¶ms)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"IMDBSearchByID",
"(",
"ids",
"[",
"]",
"string",
",",
"langs",
"[",
"]",
"string",
")",
"(",
"Subtitles",
",",
"error",
")",
"{",
"// OSDB search params struct",
"params",
":=",
"[",
"]",
"interface",
"{",
"}",
"{",
"c",
".",
"Token",
",",
"[",
"]",
"map",
"[",
"string",
"]",
"string",
"{",
"}",
",",
"}",
"\n\n",
"// Convert ids []string into a slice of map[string]string for search. Ouch!",
"for",
"_",
",",
"imdbID",
":=",
"range",
"ids",
"{",
"params",
"[",
"1",
"]",
"=",
"append",
"(",
"params",
"[",
"1",
"]",
".",
"(",
"[",
"]",
"map",
"[",
"string",
"]",
"string",
")",
",",
"map",
"[",
"string",
"]",
"string",
"{",
"\"",
"\"",
":",
"imdbID",
",",
"\"",
"\"",
":",
"strings",
".",
"Join",
"(",
"langs",
",",
"\"",
"\"",
")",
",",
"}",
",",
")",
"\n",
"}",
"\n\n",
"return",
"c",
".",
"SearchSubtitles",
"(",
"&",
"params",
")",
"\n",
"}"
] | // IMDBSearchByID searches subtitles that match some IMDB IDs. | [
"IMDBSearchByID",
"searches",
"subtitles",
"that",
"match",
"some",
"IMDB",
"IDs",
"."
] | da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764 | https://github.com/oz/osdb/blob/da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764/client.go#L80-L99 |
12,054 | oz/osdb | client.go | SearchSubtitles | func (c *Client) SearchSubtitles(params *[]interface{}) (Subtitles, error) {
res := struct {
Data Subtitles `xmlrpc:"data"`
}{}
if err := c.Call("SearchSubtitles", *params, &res); err != nil {
if strings.Contains(err.Error(), "type mismatch") {
return nil, err
}
}
return res.Data, nil
} | go | func (c *Client) SearchSubtitles(params *[]interface{}) (Subtitles, error) {
res := struct {
Data Subtitles `xmlrpc:"data"`
}{}
if err := c.Call("SearchSubtitles", *params, &res); err != nil {
if strings.Contains(err.Error(), "type mismatch") {
return nil, err
}
}
return res.Data, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"SearchSubtitles",
"(",
"params",
"*",
"[",
"]",
"interface",
"{",
"}",
")",
"(",
"Subtitles",
",",
"error",
")",
"{",
"res",
":=",
"struct",
"{",
"Data",
"Subtitles",
"`xmlrpc:\"data\"`",
"\n",
"}",
"{",
"}",
"\n\n",
"if",
"err",
":=",
"c",
".",
"Call",
"(",
"\"",
"\"",
",",
"*",
"params",
",",
"&",
"res",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"strings",
".",
"Contains",
"(",
"err",
".",
"Error",
"(",
")",
",",
"\"",
"\"",
")",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"res",
".",
"Data",
",",
"nil",
"\n",
"}"
] | // SearchSubtitles searches OSDB with your own parameters. | [
"SearchSubtitles",
"searches",
"OSDB",
"with",
"your",
"own",
"parameters",
"."
] | da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764 | https://github.com/oz/osdb/blob/da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764/client.go#L102-L113 |
12,055 | oz/osdb | client.go | IMDBSearch | func (c *Client) IMDBSearch(q string) (Movies, error) {
params := []interface{}{c.Token, q}
res := struct {
Status string `xmlrpc:"status"`
Data Movies `xmlrpc:"data"`
}{}
if err := c.Call("SearchMoviesOnIMDB", params, &res); err != nil {
return nil, err
}
if res.Status != StatusSuccess {
return nil, fmt.Errorf("SearchMoviesOnIMDB error: %s", res.Status)
}
return res.Data, nil
} | go | func (c *Client) IMDBSearch(q string) (Movies, error) {
params := []interface{}{c.Token, q}
res := struct {
Status string `xmlrpc:"status"`
Data Movies `xmlrpc:"data"`
}{}
if err := c.Call("SearchMoviesOnIMDB", params, &res); err != nil {
return nil, err
}
if res.Status != StatusSuccess {
return nil, fmt.Errorf("SearchMoviesOnIMDB error: %s", res.Status)
}
return res.Data, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"IMDBSearch",
"(",
"q",
"string",
")",
"(",
"Movies",
",",
"error",
")",
"{",
"params",
":=",
"[",
"]",
"interface",
"{",
"}",
"{",
"c",
".",
"Token",
",",
"q",
"}",
"\n",
"res",
":=",
"struct",
"{",
"Status",
"string",
"`xmlrpc:\"status\"`",
"\n",
"Data",
"Movies",
"`xmlrpc:\"data\"`",
"\n",
"}",
"{",
"}",
"\n",
"if",
"err",
":=",
"c",
".",
"Call",
"(",
"\"",
"\"",
",",
"params",
",",
"&",
"res",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"res",
".",
"Status",
"!=",
"StatusSuccess",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"res",
".",
"Status",
")",
"\n",
"}",
"\n",
"return",
"res",
".",
"Data",
",",
"nil",
"\n",
"}"
] | // IMDBSearch searches movies on IMDB. | [
"IMDBSearch",
"searches",
"movies",
"on",
"IMDB",
"."
] | da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764 | https://github.com/oz/osdb/blob/da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764/client.go#L116-L129 |
12,056 | oz/osdb | client.go | GetIMDBMovieDetails | func (c *Client) GetIMDBMovieDetails(id string) (*Movie, error) {
params := []interface{}{c.Token, id}
res := struct {
Status string `xmlrpc:"status"`
Data Movie `xmlrpc:"data"`
}{}
if err := c.Call("GetIMDBMovieDetails", params, &res); err != nil {
return nil, err
}
if res.Status != StatusSuccess {
return nil, fmt.Errorf("GetIMDBMovieDetails error: %s", res.Status)
}
return &res.Data, nil
} | go | func (c *Client) GetIMDBMovieDetails(id string) (*Movie, error) {
params := []interface{}{c.Token, id}
res := struct {
Status string `xmlrpc:"status"`
Data Movie `xmlrpc:"data"`
}{}
if err := c.Call("GetIMDBMovieDetails", params, &res); err != nil {
return nil, err
}
if res.Status != StatusSuccess {
return nil, fmt.Errorf("GetIMDBMovieDetails error: %s", res.Status)
}
return &res.Data, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GetIMDBMovieDetails",
"(",
"id",
"string",
")",
"(",
"*",
"Movie",
",",
"error",
")",
"{",
"params",
":=",
"[",
"]",
"interface",
"{",
"}",
"{",
"c",
".",
"Token",
",",
"id",
"}",
"\n",
"res",
":=",
"struct",
"{",
"Status",
"string",
"`xmlrpc:\"status\"`",
"\n",
"Data",
"Movie",
"`xmlrpc:\"data\"`",
"\n",
"}",
"{",
"}",
"\n",
"if",
"err",
":=",
"c",
".",
"Call",
"(",
"\"",
"\"",
",",
"params",
",",
"&",
"res",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"res",
".",
"Status",
"!=",
"StatusSuccess",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"res",
".",
"Status",
")",
"\n",
"}",
"\n",
"return",
"&",
"res",
".",
"Data",
",",
"nil",
"\n",
"}"
] | // GetIMDBMovieDetails fetches movie details from IMDB by ID. | [
"GetIMDBMovieDetails",
"fetches",
"movie",
"details",
"from",
"IMDB",
"by",
"ID",
"."
] | da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764 | https://github.com/oz/osdb/blob/da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764/client.go#L195-L208 |
12,057 | oz/osdb | client.go | DownloadSubtitlesByIds | func (c *Client) DownloadSubtitlesByIds(ids []int) ([]SubtitleFile, error) {
params := []interface{}{c.Token, ids}
res := struct {
Status string `xmlrpc:"status"`
Data []SubtitleFile `xmlrpc:"data"`
}{}
if err := c.Call("DownloadSubtitles", params, &res); err != nil {
return nil, err
}
if res.Status != StatusSuccess {
return nil, fmt.Errorf("DownloadSubtitles error: %s", res.Status)
}
return res.Data, nil
} | go | func (c *Client) DownloadSubtitlesByIds(ids []int) ([]SubtitleFile, error) {
params := []interface{}{c.Token, ids}
res := struct {
Status string `xmlrpc:"status"`
Data []SubtitleFile `xmlrpc:"data"`
}{}
if err := c.Call("DownloadSubtitles", params, &res); err != nil {
return nil, err
}
if res.Status != StatusSuccess {
return nil, fmt.Errorf("DownloadSubtitles error: %s", res.Status)
}
return res.Data, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"DownloadSubtitlesByIds",
"(",
"ids",
"[",
"]",
"int",
")",
"(",
"[",
"]",
"SubtitleFile",
",",
"error",
")",
"{",
"params",
":=",
"[",
"]",
"interface",
"{",
"}",
"{",
"c",
".",
"Token",
",",
"ids",
"}",
"\n",
"res",
":=",
"struct",
"{",
"Status",
"string",
"`xmlrpc:\"status\"`",
"\n",
"Data",
"[",
"]",
"SubtitleFile",
"`xmlrpc:\"data\"`",
"\n",
"}",
"{",
"}",
"\n",
"if",
"err",
":=",
"c",
".",
"Call",
"(",
"\"",
"\"",
",",
"params",
",",
"&",
"res",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"res",
".",
"Status",
"!=",
"StatusSuccess",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"res",
".",
"Status",
")",
"\n",
"}",
"\n",
"return",
"res",
".",
"Data",
",",
"nil",
"\n",
"}"
] | // DownloadSubtitlesByIds downloads subtitles by ID. | [
"DownloadSubtitlesByIds",
"downloads",
"subtitles",
"by",
"ID",
"."
] | da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764 | https://github.com/oz/osdb/blob/da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764/client.go#L211-L224 |
12,058 | oz/osdb | client.go | DownloadSubtitles | func (c *Client) DownloadSubtitles(subtitles Subtitles) ([]SubtitleFile, error) {
ids := make([]int, len(subtitles))
for i := range subtitles {
id, err := strconv.Atoi(subtitles[i].IDSubtitleFile)
if err != nil {
return nil, fmt.Errorf("malformed subtitle ID: %s", err)
}
ids[i] = id
}
subtitleFiles, err := c.DownloadSubtitlesByIds(ids)
if err != nil {
return nil, err
}
for i := range subtitleFiles {
encodingName := subtitles[i].SubEncoding
if encodingName != "" {
subtitleFiles[i].Encoding, err = encodingFromName(subtitles[i].SubEncoding)
if err != nil {
return nil, err
}
}
}
return subtitleFiles, nil
} | go | func (c *Client) DownloadSubtitles(subtitles Subtitles) ([]SubtitleFile, error) {
ids := make([]int, len(subtitles))
for i := range subtitles {
id, err := strconv.Atoi(subtitles[i].IDSubtitleFile)
if err != nil {
return nil, fmt.Errorf("malformed subtitle ID: %s", err)
}
ids[i] = id
}
subtitleFiles, err := c.DownloadSubtitlesByIds(ids)
if err != nil {
return nil, err
}
for i := range subtitleFiles {
encodingName := subtitles[i].SubEncoding
if encodingName != "" {
subtitleFiles[i].Encoding, err = encodingFromName(subtitles[i].SubEncoding)
if err != nil {
return nil, err
}
}
}
return subtitleFiles, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"DownloadSubtitles",
"(",
"subtitles",
"Subtitles",
")",
"(",
"[",
"]",
"SubtitleFile",
",",
"error",
")",
"{",
"ids",
":=",
"make",
"(",
"[",
"]",
"int",
",",
"len",
"(",
"subtitles",
")",
")",
"\n",
"for",
"i",
":=",
"range",
"subtitles",
"{",
"id",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"subtitles",
"[",
"i",
"]",
".",
"IDSubtitleFile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"ids",
"[",
"i",
"]",
"=",
"id",
"\n",
"}",
"\n\n",
"subtitleFiles",
",",
"err",
":=",
"c",
".",
"DownloadSubtitlesByIds",
"(",
"ids",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"for",
"i",
":=",
"range",
"subtitleFiles",
"{",
"encodingName",
":=",
"subtitles",
"[",
"i",
"]",
".",
"SubEncoding",
"\n",
"if",
"encodingName",
"!=",
"\"",
"\"",
"{",
"subtitleFiles",
"[",
"i",
"]",
".",
"Encoding",
",",
"err",
"=",
"encodingFromName",
"(",
"subtitles",
"[",
"i",
"]",
".",
"SubEncoding",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"subtitleFiles",
",",
"nil",
"\n",
"}"
] | // DownloadSubtitles downloads subtitles in bulk. | [
"DownloadSubtitles",
"downloads",
"subtitles",
"in",
"bulk",
"."
] | da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764 | https://github.com/oz/osdb/blob/da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764/client.go#L227-L253 |
12,059 | oz/osdb | client.go | Download | func (c *Client) Download(s *Subtitle) error {
return c.DownloadTo(s, s.SubFileName)
} | go | func (c *Client) Download(s *Subtitle) error {
return c.DownloadTo(s, s.SubFileName)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Download",
"(",
"s",
"*",
"Subtitle",
")",
"error",
"{",
"return",
"c",
".",
"DownloadTo",
"(",
"s",
",",
"s",
".",
"SubFileName",
")",
"\n",
"}"
] | // Download saves a subtitle file to disk, using the OSDB specified name. | [
"Download",
"saves",
"a",
"subtitle",
"file",
"to",
"disk",
"using",
"the",
"OSDB",
"specified",
"name",
"."
] | da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764 | https://github.com/oz/osdb/blob/da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764/client.go#L256-L258 |
12,060 | oz/osdb | client.go | DownloadTo | func (c *Client) DownloadTo(s *Subtitle, path string) (err error) {
// Download
files, err := c.DownloadSubtitles(Subtitles{*s})
if err != nil {
return
}
if len(files) == 0 {
return fmt.Errorf("No file match this subtitle ID")
}
// Save to disk.
r, err := files[0].Reader()
if err != nil {
return
}
defer r.Close()
w, err := os.Create(path)
if err != nil {
return
}
defer w.Close()
_, err = io.Copy(w, r)
return
} | go | func (c *Client) DownloadTo(s *Subtitle, path string) (err error) {
// Download
files, err := c.DownloadSubtitles(Subtitles{*s})
if err != nil {
return
}
if len(files) == 0 {
return fmt.Errorf("No file match this subtitle ID")
}
// Save to disk.
r, err := files[0].Reader()
if err != nil {
return
}
defer r.Close()
w, err := os.Create(path)
if err != nil {
return
}
defer w.Close()
_, err = io.Copy(w, r)
return
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"DownloadTo",
"(",
"s",
"*",
"Subtitle",
",",
"path",
"string",
")",
"(",
"err",
"error",
")",
"{",
"// Download",
"files",
",",
"err",
":=",
"c",
".",
"DownloadSubtitles",
"(",
"Subtitles",
"{",
"*",
"s",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"if",
"len",
"(",
"files",
")",
"==",
"0",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Save to disk.",
"r",
",",
"err",
":=",
"files",
"[",
"0",
"]",
".",
"Reader",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"defer",
"r",
".",
"Close",
"(",
")",
"\n\n",
"w",
",",
"err",
":=",
"os",
".",
"Create",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"defer",
"w",
".",
"Close",
"(",
")",
"\n\n",
"_",
",",
"err",
"=",
"io",
".",
"Copy",
"(",
"w",
",",
"r",
")",
"\n",
"return",
"\n",
"}"
] | // DownloadTo saves a subtitle file to the specified path. | [
"DownloadTo",
"saves",
"a",
"subtitle",
"file",
"to",
"the",
"specified",
"path",
"."
] | da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764 | https://github.com/oz/osdb/blob/da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764/client.go#L261-L286 |
12,061 | oz/osdb | client.go | Noop | func (c *Client) Noop() (err error) {
res := struct {
Status string `xmlrpc:"status"`
}{}
err = c.Call("NoOperation", []interface{}{c.Token}, &res)
if err == nil && res.Status != StatusSuccess {
err = fmt.Errorf("NoOp: %s", res.Status)
}
return
} | go | func (c *Client) Noop() (err error) {
res := struct {
Status string `xmlrpc:"status"`
}{}
err = c.Call("NoOperation", []interface{}{c.Token}, &res)
if err == nil && res.Status != StatusSuccess {
err = fmt.Errorf("NoOp: %s", res.Status)
}
return
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Noop",
"(",
")",
"(",
"err",
"error",
")",
"{",
"res",
":=",
"struct",
"{",
"Status",
"string",
"`xmlrpc:\"status\"`",
"\n",
"}",
"{",
"}",
"\n",
"err",
"=",
"c",
".",
"Call",
"(",
"\"",
"\"",
",",
"[",
"]",
"interface",
"{",
"}",
"{",
"c",
".",
"Token",
"}",
",",
"&",
"res",
")",
"\n",
"if",
"err",
"==",
"nil",
"&&",
"res",
".",
"Status",
"!=",
"StatusSuccess",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"res",
".",
"Status",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // Noop keeps a session alive. | [
"Noop",
"keeps",
"a",
"session",
"alive",
"."
] | da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764 | https://github.com/oz/osdb/blob/da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764/client.go#L341-L350 |
12,062 | oz/osdb | client.go | LogIn | func (c *Client) LogIn(user string, pass string, lang string) (err error) {
c.Login = user
c.Password = pass
c.Language = lang
args := []interface{}{user, pass, lang, c.UserAgent}
res := struct {
Status string `xmlrpc:"status"`
Token string `xmlrpc:"token"`
}{}
if err = c.Call("LogIn", args, &res); err != nil {
return
}
if res.Status != StatusSuccess {
return fmt.Errorf("Login: %s", res.Status)
}
c.Token = res.Token
return
} | go | func (c *Client) LogIn(user string, pass string, lang string) (err error) {
c.Login = user
c.Password = pass
c.Language = lang
args := []interface{}{user, pass, lang, c.UserAgent}
res := struct {
Status string `xmlrpc:"status"`
Token string `xmlrpc:"token"`
}{}
if err = c.Call("LogIn", args, &res); err != nil {
return
}
if res.Status != StatusSuccess {
return fmt.Errorf("Login: %s", res.Status)
}
c.Token = res.Token
return
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"LogIn",
"(",
"user",
"string",
",",
"pass",
"string",
",",
"lang",
"string",
")",
"(",
"err",
"error",
")",
"{",
"c",
".",
"Login",
"=",
"user",
"\n",
"c",
".",
"Password",
"=",
"pass",
"\n",
"c",
".",
"Language",
"=",
"lang",
"\n",
"args",
":=",
"[",
"]",
"interface",
"{",
"}",
"{",
"user",
",",
"pass",
",",
"lang",
",",
"c",
".",
"UserAgent",
"}",
"\n",
"res",
":=",
"struct",
"{",
"Status",
"string",
"`xmlrpc:\"status\"`",
"\n",
"Token",
"string",
"`xmlrpc:\"token\"`",
"\n",
"}",
"{",
"}",
"\n",
"if",
"err",
"=",
"c",
".",
"Call",
"(",
"\"",
"\"",
",",
"args",
",",
"&",
"res",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"if",
"res",
".",
"Status",
"!=",
"StatusSuccess",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"res",
".",
"Status",
")",
"\n",
"}",
"\n",
"c",
".",
"Token",
"=",
"res",
".",
"Token",
"\n",
"return",
"\n",
"}"
] | // LogIn to the API, and return a session token. | [
"LogIn",
"to",
"the",
"API",
"and",
"return",
"a",
"session",
"token",
"."
] | da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764 | https://github.com/oz/osdb/blob/da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764/client.go#L353-L371 |
12,063 | oz/osdb | client.go | fileToSearchParams | func (c *Client) fileToSearchParams(path string, langs []string) (*[]interface{}, error) {
// File size
file, err := os.Open(path)
if err != nil {
return nil, err
}
defer file.Close()
fi, err := file.Stat()
if err != nil {
return nil, err
}
size := fi.Size()
// File hash
h, err := HashFile(file)
if err != nil {
return nil, err
}
params := []interface{}{
c.Token,
[]struct {
Hash string `xmlrpc:"moviehash"`
Size int64 `xmlrpc:"moviebytesize"`
Langs string `xmlrpc:"sublanguageid"`
}{{
hashString(h),
size,
strings.Join(langs, ","),
}},
}
return ¶ms, nil
} | go | func (c *Client) fileToSearchParams(path string, langs []string) (*[]interface{}, error) {
// File size
file, err := os.Open(path)
if err != nil {
return nil, err
}
defer file.Close()
fi, err := file.Stat()
if err != nil {
return nil, err
}
size := fi.Size()
// File hash
h, err := HashFile(file)
if err != nil {
return nil, err
}
params := []interface{}{
c.Token,
[]struct {
Hash string `xmlrpc:"moviehash"`
Size int64 `xmlrpc:"moviebytesize"`
Langs string `xmlrpc:"sublanguageid"`
}{{
hashString(h),
size,
strings.Join(langs, ","),
}},
}
return ¶ms, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"fileToSearchParams",
"(",
"path",
"string",
",",
"langs",
"[",
"]",
"string",
")",
"(",
"*",
"[",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"// File size",
"file",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"file",
".",
"Close",
"(",
")",
"\n",
"fi",
",",
"err",
":=",
"file",
".",
"Stat",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"size",
":=",
"fi",
".",
"Size",
"(",
")",
"\n\n",
"// File hash",
"h",
",",
"err",
":=",
"HashFile",
"(",
"file",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"params",
":=",
"[",
"]",
"interface",
"{",
"}",
"{",
"c",
".",
"Token",
",",
"[",
"]",
"struct",
"{",
"Hash",
"string",
"`xmlrpc:\"moviehash\"`",
"\n",
"Size",
"int64",
"`xmlrpc:\"moviebytesize\"`",
"\n",
"Langs",
"string",
"`xmlrpc:\"sublanguageid\"`",
"\n",
"}",
"{",
"{",
"hashString",
"(",
"h",
")",
",",
"size",
",",
"strings",
".",
"Join",
"(",
"langs",
",",
"\"",
"\"",
")",
",",
"}",
"}",
",",
"}",
"\n",
"return",
"&",
"params",
",",
"nil",
"\n",
"}"
] | // Build query parameters for hash-based movie search. | [
"Build",
"query",
"parameters",
"for",
"hash",
"-",
"based",
"movie",
"search",
"."
] | da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764 | https://github.com/oz/osdb/blob/da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764/client.go#L383-L415 |
12,064 | oz/osdb | cmd/osdb/cmd/root.go | InitClient | func InitClient(lang string) (client *osdb.Client, err error) {
if client, err = osdb.NewClient(); err != nil {
return
}
if err = client.LogIn(os.Getenv("OSDB_LOGIN"), os.Getenv("OSDB_PASSWORD"), lang); err != nil {
return
}
return
} | go | func InitClient(lang string) (client *osdb.Client, err error) {
if client, err = osdb.NewClient(); err != nil {
return
}
if err = client.LogIn(os.Getenv("OSDB_LOGIN"), os.Getenv("OSDB_PASSWORD"), lang); err != nil {
return
}
return
} | [
"func",
"InitClient",
"(",
"lang",
"string",
")",
"(",
"client",
"*",
"osdb",
".",
"Client",
",",
"err",
"error",
")",
"{",
"if",
"client",
",",
"err",
"=",
"osdb",
".",
"NewClient",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"if",
"err",
"=",
"client",
".",
"LogIn",
"(",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
",",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
",",
"lang",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // InitClient returns a Client connected to OSDB API using env. vars OSDB_LOGIN,
// OSDB_PASSWORD. | [
"InitClient",
"returns",
"a",
"Client",
"connected",
"to",
"OSDB",
"API",
"using",
"env",
".",
"vars",
"OSDB_LOGIN",
"OSDB_PASSWORD",
"."
] | da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764 | https://github.com/oz/osdb/blob/da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764/cmd/osdb/cmd/root.go#L37-L45 |
12,065 | oz/osdb | subtitle.go | NewSubtitle | func NewSubtitle(moviePath string, subPath string, langID string) (s Subtitle, err error) {
s.subFilePath = subPath
s.SubLanguageID = langID
s.SubFileName = path.Base(subPath)
// Subs are identified using md5 hashes... ¬¬
subIO, err := os.Open(subPath)
if err != nil {
return
}
defer subIO.Close()
h := md5.New()
_, err = io.Copy(h, subIO)
if err != nil {
return
}
s.SubHash = fmt.Sprintf("%x", h.Sum(nil))
// Movie filename, byte-size, & hash.
s.MovieFileName = path.Base(moviePath)
movieIO, err := os.Open(moviePath)
if err != nil {
return
}
defer movieIO.Close()
stat, err := movieIO.Stat()
if err != nil {
return
}
s.MovieByteSize = strconv.FormatInt(stat.Size(), 10)
movieHash, err := HashFile(movieIO)
if err != nil {
return
}
s.MovieHash = fmt.Sprintf("%x", movieHash)
return
} | go | func NewSubtitle(moviePath string, subPath string, langID string) (s Subtitle, err error) {
s.subFilePath = subPath
s.SubLanguageID = langID
s.SubFileName = path.Base(subPath)
// Subs are identified using md5 hashes... ¬¬
subIO, err := os.Open(subPath)
if err != nil {
return
}
defer subIO.Close()
h := md5.New()
_, err = io.Copy(h, subIO)
if err != nil {
return
}
s.SubHash = fmt.Sprintf("%x", h.Sum(nil))
// Movie filename, byte-size, & hash.
s.MovieFileName = path.Base(moviePath)
movieIO, err := os.Open(moviePath)
if err != nil {
return
}
defer movieIO.Close()
stat, err := movieIO.Stat()
if err != nil {
return
}
s.MovieByteSize = strconv.FormatInt(stat.Size(), 10)
movieHash, err := HashFile(movieIO)
if err != nil {
return
}
s.MovieHash = fmt.Sprintf("%x", movieHash)
return
} | [
"func",
"NewSubtitle",
"(",
"moviePath",
"string",
",",
"subPath",
"string",
",",
"langID",
"string",
")",
"(",
"s",
"Subtitle",
",",
"err",
"error",
")",
"{",
"s",
".",
"subFilePath",
"=",
"subPath",
"\n",
"s",
".",
"SubLanguageID",
"=",
"langID",
"\n",
"s",
".",
"SubFileName",
"=",
"path",
".",
"Base",
"(",
"subPath",
")",
"\n",
"// Subs are identified using md5 hashes... ¬¬",
"subIO",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"subPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"defer",
"subIO",
".",
"Close",
"(",
")",
"\n",
"h",
":=",
"md5",
".",
"New",
"(",
")",
"\n",
"_",
",",
"err",
"=",
"io",
".",
"Copy",
"(",
"h",
",",
"subIO",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"s",
".",
"SubHash",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"h",
".",
"Sum",
"(",
"nil",
")",
")",
"\n\n",
"// Movie filename, byte-size, & hash.",
"s",
".",
"MovieFileName",
"=",
"path",
".",
"Base",
"(",
"moviePath",
")",
"\n",
"movieIO",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"moviePath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"defer",
"movieIO",
".",
"Close",
"(",
")",
"\n",
"stat",
",",
"err",
":=",
"movieIO",
".",
"Stat",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"s",
".",
"MovieByteSize",
"=",
"strconv",
".",
"FormatInt",
"(",
"stat",
".",
"Size",
"(",
")",
",",
"10",
")",
"\n",
"movieHash",
",",
"err",
":=",
"HashFile",
"(",
"movieIO",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"s",
".",
"MovieHash",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"movieHash",
")",
"\n",
"return",
"\n",
"}"
] | // NewSubtitle builds a Subtitle struct. | [
"NewSubtitle",
"builds",
"a",
"Subtitle",
"struct",
"."
] | da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764 | https://github.com/oz/osdb/blob/da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764/subtitle.go#L183-L218 |
12,066 | oz/osdb | subtitle.go | toTryUploadParams | func (subs *Subtitles) toTryUploadParams() (map[string]interface{}, error) {
subMap := map[string]interface{}{}
for i, s := range *subs {
key := "cd" + strconv.Itoa(i+1) // keys are cd1, cd2, ...
subMap[key] = s.toUploadParams()
}
return subMap, nil
} | go | func (subs *Subtitles) toTryUploadParams() (map[string]interface{}, error) {
subMap := map[string]interface{}{}
for i, s := range *subs {
key := "cd" + strconv.Itoa(i+1) // keys are cd1, cd2, ...
subMap[key] = s.toUploadParams()
}
return subMap, nil
} | [
"func",
"(",
"subs",
"*",
"Subtitles",
")",
"toTryUploadParams",
"(",
")",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"subMap",
":=",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"}",
"\n",
"for",
"i",
",",
"s",
":=",
"range",
"*",
"subs",
"{",
"key",
":=",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"i",
"+",
"1",
")",
"// keys are cd1, cd2, ...",
"\n",
"subMap",
"[",
"key",
"]",
"=",
"s",
".",
"toUploadParams",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"subMap",
",",
"nil",
"\n",
"}"
] | // Serialize Subtitle to OSDB's XMLRPC params when trying to upload. | [
"Serialize",
"Subtitle",
"to",
"OSDB",
"s",
"XMLRPC",
"params",
"when",
"trying",
"to",
"upload",
"."
] | da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764 | https://github.com/oz/osdb/blob/da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764/subtitle.go#L221-L229 |
12,067 | oz/osdb | subtitle.go | toUploadParams | func (subs *Subtitles) toUploadParams() (map[string]interface{}, error) {
langID := (*subs)[0].SubLanguageID
params := map[string]interface{}{}
params["baseinfo"] = map[string]string{
"sublanguageid": langID,
// FIXME add "idmovieimdb"
}
for i, s := range *subs {
key := "cd" + strconv.Itoa(i+1) // keys are cd1, cd2, ...
subParam := s.toUploadParams()
encoded, err := s.encodeFile()
if err != nil {
return nil, err
}
subParam["subcontent"] = encoded
params[key] = subParam
}
return params, nil
} | go | func (subs *Subtitles) toUploadParams() (map[string]interface{}, error) {
langID := (*subs)[0].SubLanguageID
params := map[string]interface{}{}
params["baseinfo"] = map[string]string{
"sublanguageid": langID,
// FIXME add "idmovieimdb"
}
for i, s := range *subs {
key := "cd" + strconv.Itoa(i+1) // keys are cd1, cd2, ...
subParam := s.toUploadParams()
encoded, err := s.encodeFile()
if err != nil {
return nil, err
}
subParam["subcontent"] = encoded
params[key] = subParam
}
return params, nil
} | [
"func",
"(",
"subs",
"*",
"Subtitles",
")",
"toUploadParams",
"(",
")",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"langID",
":=",
"(",
"*",
"subs",
")",
"[",
"0",
"]",
".",
"SubLanguageID",
"\n",
"params",
":=",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"}",
"\n\n",
"params",
"[",
"\"",
"\"",
"]",
"=",
"map",
"[",
"string",
"]",
"string",
"{",
"\"",
"\"",
":",
"langID",
",",
"// FIXME add \"idmovieimdb\"",
"}",
"\n\n",
"for",
"i",
",",
"s",
":=",
"range",
"*",
"subs",
"{",
"key",
":=",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"i",
"+",
"1",
")",
"// keys are cd1, cd2, ...",
"\n",
"subParam",
":=",
"s",
".",
"toUploadParams",
"(",
")",
"\n",
"encoded",
",",
"err",
":=",
"s",
".",
"encodeFile",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"subParam",
"[",
"\"",
"\"",
"]",
"=",
"encoded",
"\n",
"params",
"[",
"key",
"]",
"=",
"subParam",
"\n",
"}",
"\n\n",
"return",
"params",
",",
"nil",
"\n",
"}"
] | // Serialize Subtitle to OSDB's XMLRPC params when uploading. | [
"Serialize",
"Subtitle",
"to",
"OSDB",
"s",
"XMLRPC",
"params",
"when",
"uploading",
"."
] | da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764 | https://github.com/oz/osdb/blob/da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764/subtitle.go#L232-L253 |
12,068 | oz/osdb | osdb.go | NewClient | func NewClient() (*Client, error) {
osdbServer := os.Getenv("OSDB_SERVER")
if osdbServer == "" {
osdbServer = DefaultOSDBServer
}
rpc, err := xmlrpc.NewClient(osdbServer, nil)
if err != nil {
return nil, err
}
c := &Client{
UserAgent: DefaultUserAgent,
Client: rpc, // xmlrpc.Client
}
return c, nil
} | go | func NewClient() (*Client, error) {
osdbServer := os.Getenv("OSDB_SERVER")
if osdbServer == "" {
osdbServer = DefaultOSDBServer
}
rpc, err := xmlrpc.NewClient(osdbServer, nil)
if err != nil {
return nil, err
}
c := &Client{
UserAgent: DefaultUserAgent,
Client: rpc, // xmlrpc.Client
}
return c, nil
} | [
"func",
"NewClient",
"(",
")",
"(",
"*",
"Client",
",",
"error",
")",
"{",
"osdbServer",
":=",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"\n",
"if",
"osdbServer",
"==",
"\"",
"\"",
"{",
"osdbServer",
"=",
"DefaultOSDBServer",
"\n",
"}",
"\n",
"rpc",
",",
"err",
":=",
"xmlrpc",
".",
"NewClient",
"(",
"osdbServer",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"c",
":=",
"&",
"Client",
"{",
"UserAgent",
":",
"DefaultUserAgent",
",",
"Client",
":",
"rpc",
",",
"// xmlrpc.Client",
"}",
"\n\n",
"return",
"c",
",",
"nil",
"\n",
"}"
] | // NewClient allocates a new OSDB client. | [
"NewClient",
"allocates",
"a",
"new",
"OSDB",
"client",
"."
] | da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764 | https://github.com/oz/osdb/blob/da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764/osdb.go#L24-L40 |
12,069 | oz/osdb | osdb.go | Hash | func Hash(path string) (uint64, error) {
file, err := os.Open(path)
if err != nil {
return 0, err
}
defer file.Close()
return HashFile(file)
} | go | func Hash(path string) (uint64, error) {
file, err := os.Open(path)
if err != nil {
return 0, err
}
defer file.Close()
return HashFile(file)
} | [
"func",
"Hash",
"(",
"path",
"string",
")",
"(",
"uint64",
",",
"error",
")",
"{",
"file",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"defer",
"file",
".",
"Close",
"(",
")",
"\n",
"return",
"HashFile",
"(",
"file",
")",
"\n",
"}"
] | // Hash generates an OSDB hash for a file. | [
"Hash",
"generates",
"an",
"OSDB",
"hash",
"for",
"a",
"file",
"."
] | da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764 | https://github.com/oz/osdb/blob/da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764/osdb.go#L78-L85 |
12,070 | oz/osdb | osdb.go | readChunk | func readChunk(file *os.File, offset int64, buf []byte) (err error) {
n, err := file.ReadAt(buf, offset)
if err != nil {
return
}
if n != ChunkSize {
return fmt.Errorf("Invalid read %v", n)
}
return
} | go | func readChunk(file *os.File, offset int64, buf []byte) (err error) {
n, err := file.ReadAt(buf, offset)
if err != nil {
return
}
if n != ChunkSize {
return fmt.Errorf("Invalid read %v", n)
}
return
} | [
"func",
"readChunk",
"(",
"file",
"*",
"os",
".",
"File",
",",
"offset",
"int64",
",",
"buf",
"[",
"]",
"byte",
")",
"(",
"err",
"error",
")",
"{",
"n",
",",
"err",
":=",
"file",
".",
"ReadAt",
"(",
"buf",
",",
"offset",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"if",
"n",
"!=",
"ChunkSize",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"n",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // Read a chunk of a file at `offset` so as to fill `buf`. | [
"Read",
"a",
"chunk",
"of",
"a",
"file",
"at",
"offset",
"so",
"as",
"to",
"fill",
"buf",
"."
] | da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764 | https://github.com/oz/osdb/blob/da06ada9cdc1e2b177f0ff4f3a2ef52faf4fd764/osdb.go#L88-L97 |
12,071 | Shopify/goluago | util/debug.go | DumpFrame | func DumpFrame(l *lua.State, w io.Writer) (n int, err error) {
n, err = fmt.Fprintf(w, "top=%d, 'real (pseudo): val':\n", l.Top())
if err != nil {
return
}
var m int
for i, pseudo := 1, 0-l.Top(); i <= l.Top(); {
m, err = fmt.Fprintf(w, "\t %d (%d): %#v\n", i, pseudo, l.ToValue(i))
n += m
if err != nil {
return
}
i++
pseudo++
}
return
} | go | func DumpFrame(l *lua.State, w io.Writer) (n int, err error) {
n, err = fmt.Fprintf(w, "top=%d, 'real (pseudo): val':\n", l.Top())
if err != nil {
return
}
var m int
for i, pseudo := 1, 0-l.Top(); i <= l.Top(); {
m, err = fmt.Fprintf(w, "\t %d (%d): %#v\n", i, pseudo, l.ToValue(i))
n += m
if err != nil {
return
}
i++
pseudo++
}
return
} | [
"func",
"DumpFrame",
"(",
"l",
"*",
"lua",
".",
"State",
",",
"w",
"io",
".",
"Writer",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"n",
",",
"err",
"=",
"fmt",
".",
"Fprintf",
"(",
"w",
",",
"\"",
"\\n",
"\"",
",",
"l",
".",
"Top",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"var",
"m",
"int",
"\n",
"for",
"i",
",",
"pseudo",
":=",
"1",
",",
"0",
"-",
"l",
".",
"Top",
"(",
")",
";",
"i",
"<=",
"l",
".",
"Top",
"(",
")",
";",
"{",
"m",
",",
"err",
"=",
"fmt",
".",
"Fprintf",
"(",
"w",
",",
"\"",
"\\t",
"\\n",
"\"",
",",
"i",
",",
"pseudo",
",",
"l",
".",
"ToValue",
"(",
"i",
")",
")",
"\n",
"n",
"+=",
"m",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"i",
"++",
"\n",
"pseudo",
"++",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // DumpFrame writes the currently visible frames of the Lua stack in a
// human-readable way. | [
"DumpFrame",
"writes",
"the",
"currently",
"visible",
"frames",
"of",
"the",
"Lua",
"stack",
"in",
"a",
"human",
"-",
"readable",
"way",
"."
] | 88ed7d28bef691d37a08bf6e15d45048e56f2e95 | https://github.com/Shopify/goluago/blob/88ed7d28bef691d37a08bf6e15d45048e56f2e95/util/debug.go#L11-L28 |
12,072 | vincent-petithory/dataurl | dataurl.go | String | func (mt *MediaType) String() string {
var buf bytes.Buffer
for k, v := range mt.Params {
fmt.Fprintf(&buf, ";%s=%s", k, EscapeString(v))
}
return mt.ContentType() + (&buf).String()
} | go | func (mt *MediaType) String() string {
var buf bytes.Buffer
for k, v := range mt.Params {
fmt.Fprintf(&buf, ";%s=%s", k, EscapeString(v))
}
return mt.ContentType() + (&buf).String()
} | [
"func",
"(",
"mt",
"*",
"MediaType",
")",
"String",
"(",
")",
"string",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"mt",
".",
"Params",
"{",
"fmt",
".",
"Fprintf",
"(",
"&",
"buf",
",",
"\"",
"\"",
",",
"k",
",",
"EscapeString",
"(",
"v",
")",
")",
"\n",
"}",
"\n",
"return",
"mt",
".",
"ContentType",
"(",
")",
"+",
"(",
"&",
"buf",
")",
".",
"String",
"(",
")",
"\n",
"}"
] | // String implements the Stringer interface.
//
// Params values are escaped with the Escape function, rather than in a quoted string. | [
"String",
"implements",
"the",
"Stringer",
"interface",
".",
"Params",
"values",
"are",
"escaped",
"with",
"the",
"Escape",
"function",
"rather",
"than",
"in",
"a",
"quoted",
"string",
"."
] | 9a301d65acbb728fcc3ace14f45f511a4cfeea9c | https://github.com/vincent-petithory/dataurl/blob/9a301d65acbb728fcc3ace14f45f511a4cfeea9c/dataurl.go#L46-L52 |
12,073 | vincent-petithory/dataurl | dataurl.go | MarshalText | func (du *DataURL) MarshalText() ([]byte, error) {
buf := bytes.NewBuffer(nil)
if _, err := du.WriteTo(buf); err != nil {
return nil, err
}
return buf.Bytes(), nil
} | go | func (du *DataURL) MarshalText() ([]byte, error) {
buf := bytes.NewBuffer(nil)
if _, err := du.WriteTo(buf); err != nil {
return nil, err
}
return buf.Bytes(), nil
} | [
"func",
"(",
"du",
"*",
"DataURL",
")",
"MarshalText",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"buf",
":=",
"bytes",
".",
"NewBuffer",
"(",
"nil",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"du",
".",
"WriteTo",
"(",
"buf",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"buf",
".",
"Bytes",
"(",
")",
",",
"nil",
"\n",
"}"
] | // MarshalText writes du as a Data URL | [
"MarshalText",
"writes",
"du",
"as",
"a",
"Data",
"URL"
] | 9a301d65acbb728fcc3ace14f45f511a4cfeea9c | https://github.com/vincent-petithory/dataurl/blob/9a301d65acbb728fcc3ace14f45f511a4cfeea9c/dataurl.go#L154-L160 |
12,074 | vincent-petithory/dataurl | dataurl.go | DecodeString | func DecodeString(s string) (*DataURL, error) {
du := &DataURL{
MediaType: defaultMediaType(),
Encoding: EncodingASCII,
}
parser := &parser{
du: du,
l: lex(s),
}
if err := parser.parse(); err != nil {
return nil, err
}
return du, nil
} | go | func DecodeString(s string) (*DataURL, error) {
du := &DataURL{
MediaType: defaultMediaType(),
Encoding: EncodingASCII,
}
parser := &parser{
du: du,
l: lex(s),
}
if err := parser.parse(); err != nil {
return nil, err
}
return du, nil
} | [
"func",
"DecodeString",
"(",
"s",
"string",
")",
"(",
"*",
"DataURL",
",",
"error",
")",
"{",
"du",
":=",
"&",
"DataURL",
"{",
"MediaType",
":",
"defaultMediaType",
"(",
")",
",",
"Encoding",
":",
"EncodingASCII",
",",
"}",
"\n\n",
"parser",
":=",
"&",
"parser",
"{",
"du",
":",
"du",
",",
"l",
":",
"lex",
"(",
"s",
")",
",",
"}",
"\n",
"if",
"err",
":=",
"parser",
".",
"parse",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"du",
",",
"nil",
"\n",
"}"
] | // DecodeString decodes a Data URL scheme string. | [
"DecodeString",
"decodes",
"a",
"Data",
"URL",
"scheme",
"string",
"."
] | 9a301d65acbb728fcc3ace14f45f511a4cfeea9c | https://github.com/vincent-petithory/dataurl/blob/9a301d65acbb728fcc3ace14f45f511a4cfeea9c/dataurl.go#L245-L259 |
12,075 | vincent-petithory/dataurl | dataurl.go | Decode | func Decode(r io.Reader) (*DataURL, error) {
data, err := ioutil.ReadAll(r)
if err != nil {
return nil, err
}
return DecodeString(string(data))
} | go | func Decode(r io.Reader) (*DataURL, error) {
data, err := ioutil.ReadAll(r)
if err != nil {
return nil, err
}
return DecodeString(string(data))
} | [
"func",
"Decode",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"*",
"DataURL",
",",
"error",
")",
"{",
"data",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"DecodeString",
"(",
"string",
"(",
"data",
")",
")",
"\n",
"}"
] | // Decode decodes a Data URL scheme from a io.Reader. | [
"Decode",
"decodes",
"a",
"Data",
"URL",
"scheme",
"from",
"a",
"io",
".",
"Reader",
"."
] | 9a301d65acbb728fcc3ace14f45f511a4cfeea9c | https://github.com/vincent-petithory/dataurl/blob/9a301d65acbb728fcc3ace14f45f511a4cfeea9c/dataurl.go#L262-L268 |
12,076 | vincent-petithory/dataurl | dataurl.go | EncodeBytes | func EncodeBytes(data []byte) string {
mt := http.DetectContentType(data)
// http.DetectContentType may add spurious spaces between ; and a parameter.
// The canonical way is to not have them.
cleanedMt := strings.Replace(mt, "; ", ";", -1)
return New(data, cleanedMt).String()
} | go | func EncodeBytes(data []byte) string {
mt := http.DetectContentType(data)
// http.DetectContentType may add spurious spaces between ; and a parameter.
// The canonical way is to not have them.
cleanedMt := strings.Replace(mt, "; ", ";", -1)
return New(data, cleanedMt).String()
} | [
"func",
"EncodeBytes",
"(",
"data",
"[",
"]",
"byte",
")",
"string",
"{",
"mt",
":=",
"http",
".",
"DetectContentType",
"(",
"data",
")",
"\n",
"// http.DetectContentType may add spurious spaces between ; and a parameter.",
"// The canonical way is to not have them.",
"cleanedMt",
":=",
"strings",
".",
"Replace",
"(",
"mt",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"-",
"1",
")",
"\n\n",
"return",
"New",
"(",
"data",
",",
"cleanedMt",
")",
".",
"String",
"(",
")",
"\n",
"}"
] | // EncodeBytes encodes the data bytes into a Data URL string, using base 64 encoding.
//
// The media type of data is detected using http.DetectContentType. | [
"EncodeBytes",
"encodes",
"the",
"data",
"bytes",
"into",
"a",
"Data",
"URL",
"string",
"using",
"base",
"64",
"encoding",
".",
"The",
"media",
"type",
"of",
"data",
"is",
"detected",
"using",
"http",
".",
"DetectContentType",
"."
] | 9a301d65acbb728fcc3ace14f45f511a4cfeea9c | https://github.com/vincent-petithory/dataurl/blob/9a301d65acbb728fcc3ace14f45f511a4cfeea9c/dataurl.go#L273-L280 |
12,077 | vincent-petithory/dataurl | rfc2396.go | isUnreserved | func isUnreserved(c byte) bool {
return (c >= 'a' && c <= 'z') ||
(c >= 'A' && c <= 'Z') ||
(c >= '0' && c <= '9') ||
c == '-' ||
c == '_' ||
c == '.' ||
c == '!' ||
c == '~' ||
c == '*' ||
c == '\'' ||
c == '(' ||
c == ')'
} | go | func isUnreserved(c byte) bool {
return (c >= 'a' && c <= 'z') ||
(c >= 'A' && c <= 'Z') ||
(c >= '0' && c <= '9') ||
c == '-' ||
c == '_' ||
c == '.' ||
c == '!' ||
c == '~' ||
c == '*' ||
c == '\'' ||
c == '(' ||
c == ')'
} | [
"func",
"isUnreserved",
"(",
"c",
"byte",
")",
"bool",
"{",
"return",
"(",
"c",
">=",
"'a'",
"&&",
"c",
"<=",
"'z'",
")",
"||",
"(",
"c",
">=",
"'A'",
"&&",
"c",
"<=",
"'Z'",
")",
"||",
"(",
"c",
">=",
"'0'",
"&&",
"c",
"<=",
"'9'",
")",
"||",
"c",
"==",
"'-'",
"||",
"c",
"==",
"'_'",
"||",
"c",
"==",
"'.'",
"||",
"c",
"==",
"'!'",
"||",
"c",
"==",
"'~'",
"||",
"c",
"==",
"'*'",
"||",
"c",
"==",
"'\\''",
"||",
"c",
"==",
"'('",
"||",
"c",
"==",
"')'",
"\n",
"}"
] | // isUnreserved return true
// if the byte c is an unreserved char,
// as defined in RFC 2396. | [
"isUnreserved",
"return",
"true",
"if",
"the",
"byte",
"c",
"is",
"an",
"unreserved",
"char",
"as",
"defined",
"in",
"RFC",
"2396",
"."
] | 9a301d65acbb728fcc3ace14f45f511a4cfeea9c | https://github.com/vincent-petithory/dataurl/blob/9a301d65acbb728fcc3ace14f45f511a4cfeea9c/rfc2396.go#L37-L50 |
12,078 | vincent-petithory/dataurl | rfc2396.go | UnescapeToString | func UnescapeToString(s string) (string, error) {
b, err := Unescape(s)
return string(b), err
} | go | func UnescapeToString(s string) (string, error) {
b, err := Unescape(s)
return string(b), err
} | [
"func",
"UnescapeToString",
"(",
"s",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"b",
",",
"err",
":=",
"Unescape",
"(",
"s",
")",
"\n",
"return",
"string",
"(",
"b",
")",
",",
"err",
"\n",
"}"
] | // UnescapeToString is like Unescape, but returning
// a string. | [
"UnescapeToString",
"is",
"like",
"Unescape",
"but",
"returning",
"a",
"string",
"."
] | 9a301d65acbb728fcc3ace14f45f511a4cfeea9c | https://github.com/vincent-petithory/dataurl/blob/9a301d65acbb728fcc3ace14f45f511a4cfeea9c/rfc2396.go#L127-L130 |
12,079 | vincent-petithory/dataurl | lex.go | lexBeforeDataPrefix | func lexBeforeDataPrefix(l *lexer) stateFn {
if strings.HasPrefix(l.input[l.pos:], dataPrefix) {
return lexDataPrefix
}
return l.errorf("missing data prefix")
} | go | func lexBeforeDataPrefix(l *lexer) stateFn {
if strings.HasPrefix(l.input[l.pos:], dataPrefix) {
return lexDataPrefix
}
return l.errorf("missing data prefix")
} | [
"func",
"lexBeforeDataPrefix",
"(",
"l",
"*",
"lexer",
")",
"stateFn",
"{",
"if",
"strings",
".",
"HasPrefix",
"(",
"l",
".",
"input",
"[",
"l",
".",
"pos",
":",
"]",
",",
"dataPrefix",
")",
"{",
"return",
"lexDataPrefix",
"\n",
"}",
"\n",
"return",
"l",
".",
"errorf",
"(",
"\"",
"\"",
")",
"\n",
"}"
] | // start lexing by detecting data prefix | [
"start",
"lexing",
"by",
"detecting",
"data",
"prefix"
] | 9a301d65acbb728fcc3ace14f45f511a4cfeea9c | https://github.com/vincent-petithory/dataurl/blob/9a301d65acbb728fcc3ace14f45f511a4cfeea9c/lex.go#L204-L209 |
12,080 | vincent-petithory/dataurl | lex.go | lexDataPrefix | func lexDataPrefix(l *lexer) stateFn {
l.pos += len(dataPrefix)
l.emit(itemDataPrefix)
return lexAfterDataPrefix
} | go | func lexDataPrefix(l *lexer) stateFn {
l.pos += len(dataPrefix)
l.emit(itemDataPrefix)
return lexAfterDataPrefix
} | [
"func",
"lexDataPrefix",
"(",
"l",
"*",
"lexer",
")",
"stateFn",
"{",
"l",
".",
"pos",
"+=",
"len",
"(",
"dataPrefix",
")",
"\n",
"l",
".",
"emit",
"(",
"itemDataPrefix",
")",
"\n",
"return",
"lexAfterDataPrefix",
"\n",
"}"
] | // lex data prefix | [
"lex",
"data",
"prefix"
] | 9a301d65acbb728fcc3ace14f45f511a4cfeea9c | https://github.com/vincent-petithory/dataurl/blob/9a301d65acbb728fcc3ace14f45f511a4cfeea9c/lex.go#L212-L216 |
12,081 | ernesto-jimenez/gogen | exportdefault/generator.go | New | func New(pkg string, variable string) (*Generator, error) {
scope, docs, err := parsePackageSource(pkg)
if err != nil {
return nil, err
}
importer, funcs, err := analyzeCode(scope, docs, variable)
if err != nil {
return nil, err
}
return &Generator{
Name: docs.Name,
Imports: importer.Imports(),
funcs: funcs,
}, nil
} | go | func New(pkg string, variable string) (*Generator, error) {
scope, docs, err := parsePackageSource(pkg)
if err != nil {
return nil, err
}
importer, funcs, err := analyzeCode(scope, docs, variable)
if err != nil {
return nil, err
}
return &Generator{
Name: docs.Name,
Imports: importer.Imports(),
funcs: funcs,
}, nil
} | [
"func",
"New",
"(",
"pkg",
"string",
",",
"variable",
"string",
")",
"(",
"*",
"Generator",
",",
"error",
")",
"{",
"scope",
",",
"docs",
",",
"err",
":=",
"parsePackageSource",
"(",
"pkg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"importer",
",",
"funcs",
",",
"err",
":=",
"analyzeCode",
"(",
"scope",
",",
"docs",
",",
"variable",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"Generator",
"{",
"Name",
":",
"docs",
".",
"Name",
",",
"Imports",
":",
"importer",
".",
"Imports",
"(",
")",
",",
"funcs",
":",
"funcs",
",",
"}",
",",
"nil",
"\n",
"}"
] | // New initialises a new Generator for the corresponding package's variable
//
// Returns an error if the package or variable are invalid | [
"New",
"initialises",
"a",
"new",
"Generator",
"for",
"the",
"corresponding",
"package",
"s",
"variable",
"Returns",
"an",
"error",
"if",
"the",
"package",
"or",
"variable",
"are",
"invalid"
] | d7d4131e6607813977e78297a6060f360f056a97 | https://github.com/ernesto-jimenez/gogen/blob/d7d4131e6607813977e78297a6060f360f056a97/exportdefault/generator.go#L52-L68 |
12,082 | ernesto-jimenez/gogen | exportdefault/generator.go | Write | func (g *Generator) Write(w io.Writer) error {
buff := bytes.NewBuffer(nil)
// Generate header
if err := headerTpl.Execute(buff, g); err != nil {
return err
}
// Generate funcs
for _, fn := range g.funcs {
if g.Include != nil && !g.Include.MatchString(fn.Name) {
continue
}
if g.Exclude != nil && g.Exclude.MatchString(fn.Name) {
continue
}
fn.FuncNamePrefix = g.FuncNamePrefix
buff.Write([]byte("\n\n"))
if err := funcTpl.Execute(buff, &fn); err != nil {
return err
}
}
return cleanimports.Clean(w, buff.Bytes())
} | go | func (g *Generator) Write(w io.Writer) error {
buff := bytes.NewBuffer(nil)
// Generate header
if err := headerTpl.Execute(buff, g); err != nil {
return err
}
// Generate funcs
for _, fn := range g.funcs {
if g.Include != nil && !g.Include.MatchString(fn.Name) {
continue
}
if g.Exclude != nil && g.Exclude.MatchString(fn.Name) {
continue
}
fn.FuncNamePrefix = g.FuncNamePrefix
buff.Write([]byte("\n\n"))
if err := funcTpl.Execute(buff, &fn); err != nil {
return err
}
}
return cleanimports.Clean(w, buff.Bytes())
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"Write",
"(",
"w",
"io",
".",
"Writer",
")",
"error",
"{",
"buff",
":=",
"bytes",
".",
"NewBuffer",
"(",
"nil",
")",
"\n\n",
"// Generate header",
"if",
"err",
":=",
"headerTpl",
".",
"Execute",
"(",
"buff",
",",
"g",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Generate funcs",
"for",
"_",
",",
"fn",
":=",
"range",
"g",
".",
"funcs",
"{",
"if",
"g",
".",
"Include",
"!=",
"nil",
"&&",
"!",
"g",
".",
"Include",
".",
"MatchString",
"(",
"fn",
".",
"Name",
")",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"g",
".",
"Exclude",
"!=",
"nil",
"&&",
"g",
".",
"Exclude",
".",
"MatchString",
"(",
"fn",
".",
"Name",
")",
"{",
"continue",
"\n",
"}",
"\n",
"fn",
".",
"FuncNamePrefix",
"=",
"g",
".",
"FuncNamePrefix",
"\n",
"buff",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"\"",
"\\n",
"\\n",
"\"",
")",
")",
"\n",
"if",
"err",
":=",
"funcTpl",
".",
"Execute",
"(",
"buff",
",",
"&",
"fn",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"cleanimports",
".",
"Clean",
"(",
"w",
",",
"buff",
".",
"Bytes",
"(",
")",
")",
"\n",
"}"
] | // Write the generated code into the given io.Writer
//
// Returns an error if there is a problem generating the code | [
"Write",
"the",
"generated",
"code",
"into",
"the",
"given",
"io",
".",
"Writer",
"Returns",
"an",
"error",
"if",
"there",
"is",
"a",
"problem",
"generating",
"the",
"code"
] | d7d4131e6607813977e78297a6060f360f056a97 | https://github.com/ernesto-jimenez/gogen/blob/d7d4131e6607813977e78297a6060f360f056a97/exportdefault/generator.go#L73-L97 |
12,083 | ernesto-jimenez/gogen | imports/imports.go | AddImportsFrom | func (imp *imports) AddImportsFrom(t types.Type) {
switch el := t.(type) {
case *types.Basic:
case *types.Slice:
imp.AddImportsFrom(el.Elem())
case *types.Pointer:
imp.AddImportsFrom(el.Elem())
case *types.Named:
pkg := el.Obj().Pkg()
if pkg == nil {
return
}
if pkg.Name() == imp.currentpkg {
return
}
imp.imp[cleanImportPath(pkg.Path())] = pkg.Name()
case *types.Tuple:
for i := 0; i < el.Len(); i++ {
imp.AddImportsFrom(el.At(i).Type())
}
default:
}
} | go | func (imp *imports) AddImportsFrom(t types.Type) {
switch el := t.(type) {
case *types.Basic:
case *types.Slice:
imp.AddImportsFrom(el.Elem())
case *types.Pointer:
imp.AddImportsFrom(el.Elem())
case *types.Named:
pkg := el.Obj().Pkg()
if pkg == nil {
return
}
if pkg.Name() == imp.currentpkg {
return
}
imp.imp[cleanImportPath(pkg.Path())] = pkg.Name()
case *types.Tuple:
for i := 0; i < el.Len(); i++ {
imp.AddImportsFrom(el.At(i).Type())
}
default:
}
} | [
"func",
"(",
"imp",
"*",
"imports",
")",
"AddImportsFrom",
"(",
"t",
"types",
".",
"Type",
")",
"{",
"switch",
"el",
":=",
"t",
".",
"(",
"type",
")",
"{",
"case",
"*",
"types",
".",
"Basic",
":",
"case",
"*",
"types",
".",
"Slice",
":",
"imp",
".",
"AddImportsFrom",
"(",
"el",
".",
"Elem",
"(",
")",
")",
"\n",
"case",
"*",
"types",
".",
"Pointer",
":",
"imp",
".",
"AddImportsFrom",
"(",
"el",
".",
"Elem",
"(",
")",
")",
"\n",
"case",
"*",
"types",
".",
"Named",
":",
"pkg",
":=",
"el",
".",
"Obj",
"(",
")",
".",
"Pkg",
"(",
")",
"\n",
"if",
"pkg",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"if",
"pkg",
".",
"Name",
"(",
")",
"==",
"imp",
".",
"currentpkg",
"{",
"return",
"\n",
"}",
"\n",
"imp",
".",
"imp",
"[",
"cleanImportPath",
"(",
"pkg",
".",
"Path",
"(",
")",
")",
"]",
"=",
"pkg",
".",
"Name",
"(",
")",
"\n",
"case",
"*",
"types",
".",
"Tuple",
":",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"el",
".",
"Len",
"(",
")",
";",
"i",
"++",
"{",
"imp",
".",
"AddImportsFrom",
"(",
"el",
".",
"At",
"(",
"i",
")",
".",
"Type",
"(",
")",
")",
"\n",
"}",
"\n",
"default",
":",
"}",
"\n",
"}"
] | // AddImportsFrom adds imports used in the passed type | [
"AddImportsFrom",
"adds",
"imports",
"used",
"in",
"the",
"passed",
"type"
] | d7d4131e6607813977e78297a6060f360f056a97 | https://github.com/ernesto-jimenez/gogen/blob/d7d4131e6607813977e78297a6060f360f056a97/imports/imports.go#L22-L44 |
12,084 | ernesto-jimenez/gogen | imports/imports.go | New | func New(currentpkg string) Importer {
return &imports{
currentpkg: currentpkg,
imp: make(map[string]string),
}
} | go | func New(currentpkg string) Importer {
return &imports{
currentpkg: currentpkg,
imp: make(map[string]string),
}
} | [
"func",
"New",
"(",
"currentpkg",
"string",
")",
"Importer",
"{",
"return",
"&",
"imports",
"{",
"currentpkg",
":",
"currentpkg",
",",
"imp",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
",",
"}",
"\n",
"}"
] | // New initializes a new structure to track packages imported by the currentpkg | [
"New",
"initializes",
"a",
"new",
"structure",
"to",
"track",
"packages",
"imported",
"by",
"the",
"currentpkg"
] | d7d4131e6607813977e78297a6060f360f056a97 | https://github.com/ernesto-jimenez/gogen/blob/d7d4131e6607813977e78297a6060f360f056a97/imports/imports.go#L79-L84 |
12,085 | ernesto-jimenez/gogen | unmarshalmap/generator.go | NewGenerator | func NewGenerator(pkg, target string) (*Generator, error) {
var err error
if pkg == "" || pkg[0] == '.' {
pkg, err = filepath.Abs(filepath.Clean(pkg))
if err != nil {
return nil, err
}
pkg = gogenutil.StripGopath(pkg)
}
p, err := importer.Default().Import(pkg)
if err != nil {
return nil, err
}
obj := p.Scope().Lookup(target)
if obj == nil {
return nil, fmt.Errorf("struct %s missing", target)
}
if _, ok := obj.Type().Underlying().(*types.Struct); !ok {
return nil, fmt.Errorf("%s should be an struct, was %s", target, obj.Type().Underlying())
}
return &Generator{
targetName: target,
pkg: p,
target: obj.Type().Underlying().(*types.Struct),
}, nil
} | go | func NewGenerator(pkg, target string) (*Generator, error) {
var err error
if pkg == "" || pkg[0] == '.' {
pkg, err = filepath.Abs(filepath.Clean(pkg))
if err != nil {
return nil, err
}
pkg = gogenutil.StripGopath(pkg)
}
p, err := importer.Default().Import(pkg)
if err != nil {
return nil, err
}
obj := p.Scope().Lookup(target)
if obj == nil {
return nil, fmt.Errorf("struct %s missing", target)
}
if _, ok := obj.Type().Underlying().(*types.Struct); !ok {
return nil, fmt.Errorf("%s should be an struct, was %s", target, obj.Type().Underlying())
}
return &Generator{
targetName: target,
pkg: p,
target: obj.Type().Underlying().(*types.Struct),
}, nil
} | [
"func",
"NewGenerator",
"(",
"pkg",
",",
"target",
"string",
")",
"(",
"*",
"Generator",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"if",
"pkg",
"==",
"\"",
"\"",
"||",
"pkg",
"[",
"0",
"]",
"==",
"'.'",
"{",
"pkg",
",",
"err",
"=",
"filepath",
".",
"Abs",
"(",
"filepath",
".",
"Clean",
"(",
"pkg",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"pkg",
"=",
"gogenutil",
".",
"StripGopath",
"(",
"pkg",
")",
"\n",
"}",
"\n",
"p",
",",
"err",
":=",
"importer",
".",
"Default",
"(",
")",
".",
"Import",
"(",
"pkg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"obj",
":=",
"p",
".",
"Scope",
"(",
")",
".",
"Lookup",
"(",
"target",
")",
"\n",
"if",
"obj",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"target",
")",
"\n",
"}",
"\n",
"if",
"_",
",",
"ok",
":=",
"obj",
".",
"Type",
"(",
")",
".",
"Underlying",
"(",
")",
".",
"(",
"*",
"types",
".",
"Struct",
")",
";",
"!",
"ok",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"target",
",",
"obj",
".",
"Type",
"(",
")",
".",
"Underlying",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"&",
"Generator",
"{",
"targetName",
":",
"target",
",",
"pkg",
":",
"p",
",",
"target",
":",
"obj",
".",
"Type",
"(",
")",
".",
"Underlying",
"(",
")",
".",
"(",
"*",
"types",
".",
"Struct",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewGenerator initializes a Generator | [
"NewGenerator",
"initializes",
"a",
"Generator"
] | d7d4131e6607813977e78297a6060f360f056a97 | https://github.com/ernesto-jimenez/gogen/blob/d7d4131e6607813977e78297a6060f360f056a97/unmarshalmap/generator.go#L27-L52 |
12,086 | ernesto-jimenez/gogen | strconv/snake_case.go | SnakeCase | func SnakeCase(s string) string {
res := upper.ReplaceAllString(s, "_$1")
res = strings.ToLower(res)
res = under.ReplaceAllString(res, "_")
return strings.TrimFunc(res, func(r rune) bool {
return r == '_'
})
} | go | func SnakeCase(s string) string {
res := upper.ReplaceAllString(s, "_$1")
res = strings.ToLower(res)
res = under.ReplaceAllString(res, "_")
return strings.TrimFunc(res, func(r rune) bool {
return r == '_'
})
} | [
"func",
"SnakeCase",
"(",
"s",
"string",
")",
"string",
"{",
"res",
":=",
"upper",
".",
"ReplaceAllString",
"(",
"s",
",",
"\"",
"\"",
")",
"\n",
"res",
"=",
"strings",
".",
"ToLower",
"(",
"res",
")",
"\n",
"res",
"=",
"under",
".",
"ReplaceAllString",
"(",
"res",
",",
"\"",
"\"",
")",
"\n",
"return",
"strings",
".",
"TrimFunc",
"(",
"res",
",",
"func",
"(",
"r",
"rune",
")",
"bool",
"{",
"return",
"r",
"==",
"'_'",
"\n",
"}",
")",
"\n",
"}"
] | // SnakeCase converst camel case to snake case | [
"SnakeCase",
"converst",
"camel",
"case",
"to",
"snake",
"case"
] | d7d4131e6607813977e78297a6060f360f056a97 | https://github.com/ernesto-jimenez/gogen/blob/d7d4131e6607813977e78297a6060f360f056a97/strconv/snake_case.go#L14-L21 |
12,087 | ernesto-jimenez/gogen | specific/process.go | Process | func Process(pkg, outdir string, newType string, optset ...func(*Options)) error {
opts := DefaultOptions
for _, fn := range optset {
fn(&opts)
}
p, err := findPackage(pkg)
if err != nil {
return err
}
if outdir == "" {
outdir = path.Base(pkg)
}
if err := os.MkdirAll(outdir, os.ModePerm); err != nil {
return err
}
t := parseTargetType(newType)
files, err := processFiles(p, p.GoFiles, t)
if err != nil {
return err
}
if err := write(outdir, files); err != nil {
return err
}
if opts.SkipTestFiles {
return nil
}
files, err = processFiles(p, p.TestGoFiles, t)
if err != nil {
return err
}
return write(outdir, files)
} | go | func Process(pkg, outdir string, newType string, optset ...func(*Options)) error {
opts := DefaultOptions
for _, fn := range optset {
fn(&opts)
}
p, err := findPackage(pkg)
if err != nil {
return err
}
if outdir == "" {
outdir = path.Base(pkg)
}
if err := os.MkdirAll(outdir, os.ModePerm); err != nil {
return err
}
t := parseTargetType(newType)
files, err := processFiles(p, p.GoFiles, t)
if err != nil {
return err
}
if err := write(outdir, files); err != nil {
return err
}
if opts.SkipTestFiles {
return nil
}
files, err = processFiles(p, p.TestGoFiles, t)
if err != nil {
return err
}
return write(outdir, files)
} | [
"func",
"Process",
"(",
"pkg",
",",
"outdir",
"string",
",",
"newType",
"string",
",",
"optset",
"...",
"func",
"(",
"*",
"Options",
")",
")",
"error",
"{",
"opts",
":=",
"DefaultOptions",
"\n",
"for",
"_",
",",
"fn",
":=",
"range",
"optset",
"{",
"fn",
"(",
"&",
"opts",
")",
"\n",
"}",
"\n\n",
"p",
",",
"err",
":=",
"findPackage",
"(",
"pkg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"outdir",
"==",
"\"",
"\"",
"{",
"outdir",
"=",
"path",
".",
"Base",
"(",
"pkg",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"os",
".",
"MkdirAll",
"(",
"outdir",
",",
"os",
".",
"ModePerm",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"t",
":=",
"parseTargetType",
"(",
"newType",
")",
"\n\n",
"files",
",",
"err",
":=",
"processFiles",
"(",
"p",
",",
"p",
".",
"GoFiles",
",",
"t",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"write",
"(",
"outdir",
",",
"files",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"opts",
".",
"SkipTestFiles",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"files",
",",
"err",
"=",
"processFiles",
"(",
"p",
",",
"p",
".",
"TestGoFiles",
",",
"t",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"write",
"(",
"outdir",
",",
"files",
")",
"\n",
"}"
] | // Process creates a specific package from the generic specified in pkg | [
"Process",
"creates",
"a",
"specific",
"package",
"from",
"the",
"generic",
"specified",
"in",
"pkg"
] | d7d4131e6607813977e78297a6060f360f056a97 | https://github.com/ernesto-jimenez/gogen/blob/d7d4131e6607813977e78297a6060f360f056a97/specific/process.go#L28-L68 |
12,088 | ernesto-jimenez/gogen | automock/method.go | ParamTypes | func (m Method) ParamTypes() []string {
sig := m.signature()
types := m.listTypes(sig.Params())
n := len(types)
if n > 0 && sig.Variadic() {
types[n-1] = strings.Replace(types[n-1], "[]", "...", 1)
}
return types
} | go | func (m Method) ParamTypes() []string {
sig := m.signature()
types := m.listTypes(sig.Params())
n := len(types)
if n > 0 && sig.Variadic() {
types[n-1] = strings.Replace(types[n-1], "[]", "...", 1)
}
return types
} | [
"func",
"(",
"m",
"Method",
")",
"ParamTypes",
"(",
")",
"[",
"]",
"string",
"{",
"sig",
":=",
"m",
".",
"signature",
"(",
")",
"\n",
"types",
":=",
"m",
".",
"listTypes",
"(",
"sig",
".",
"Params",
"(",
")",
")",
"\n",
"n",
":=",
"len",
"(",
"types",
")",
"\n",
"if",
"n",
">",
"0",
"&&",
"sig",
".",
"Variadic",
"(",
")",
"{",
"types",
"[",
"n",
"-",
"1",
"]",
"=",
"strings",
".",
"Replace",
"(",
"types",
"[",
"n",
"-",
"1",
"]",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"1",
")",
"\n",
"}",
"\n",
"return",
"types",
"\n",
"}"
] | // ParamTypes returns the list of types for the params | [
"ParamTypes",
"returns",
"the",
"list",
"of",
"types",
"for",
"the",
"params"
] | d7d4131e6607813977e78297a6060f360f056a97 | https://github.com/ernesto-jimenez/gogen/blob/d7d4131e6607813977e78297a6060f360f056a97/automock/method.go#L18-L26 |
12,089 | ernesto-jimenez/gogen | automock/method.go | ReturnTypes | func (m Method) ReturnTypes() []string {
sig := m.signature()
return m.listTypes(sig.Results())
} | go | func (m Method) ReturnTypes() []string {
sig := m.signature()
return m.listTypes(sig.Results())
} | [
"func",
"(",
"m",
"Method",
")",
"ReturnTypes",
"(",
")",
"[",
"]",
"string",
"{",
"sig",
":=",
"m",
".",
"signature",
"(",
")",
"\n",
"return",
"m",
".",
"listTypes",
"(",
"sig",
".",
"Results",
"(",
")",
")",
"\n",
"}"
] | // ReturnTypes returns the list of types for the params | [
"ReturnTypes",
"returns",
"the",
"list",
"of",
"types",
"for",
"the",
"params"
] | d7d4131e6607813977e78297a6060f360f056a97 | https://github.com/ernesto-jimenez/gogen/blob/d7d4131e6607813977e78297a6060f360f056a97/automock/method.go#L29-L32 |
12,090 | ernesto-jimenez/gogen | automock/generator.go | NewGenerator | func NewGenerator(pkg, iface string) (*Generator, error) {
p, err := importer.DefaultWithTestFiles().Import(pkg)
if err != nil {
return nil, err
}
obj := p.Scope().Lookup(iface)
if obj == nil {
return nil, fmt.Errorf("interface %s missing", iface)
}
if !types.IsInterface(obj.Type()) {
return nil, fmt.Errorf("%s should be an interface, was %s", iface, obj.Type())
}
g := &Generator{
ifaceName: iface,
pkg: p,
iface: obj.Type().Underlying().(*types.Interface).Complete(),
}
g.SetTemplate(defaultMockTemplate)
return g, nil
} | go | func NewGenerator(pkg, iface string) (*Generator, error) {
p, err := importer.DefaultWithTestFiles().Import(pkg)
if err != nil {
return nil, err
}
obj := p.Scope().Lookup(iface)
if obj == nil {
return nil, fmt.Errorf("interface %s missing", iface)
}
if !types.IsInterface(obj.Type()) {
return nil, fmt.Errorf("%s should be an interface, was %s", iface, obj.Type())
}
g := &Generator{
ifaceName: iface,
pkg: p,
iface: obj.Type().Underlying().(*types.Interface).Complete(),
}
g.SetTemplate(defaultMockTemplate)
return g, nil
} | [
"func",
"NewGenerator",
"(",
"pkg",
",",
"iface",
"string",
")",
"(",
"*",
"Generator",
",",
"error",
")",
"{",
"p",
",",
"err",
":=",
"importer",
".",
"DefaultWithTestFiles",
"(",
")",
".",
"Import",
"(",
"pkg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"obj",
":=",
"p",
".",
"Scope",
"(",
")",
".",
"Lookup",
"(",
"iface",
")",
"\n",
"if",
"obj",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"iface",
")",
"\n",
"}",
"\n",
"if",
"!",
"types",
".",
"IsInterface",
"(",
"obj",
".",
"Type",
"(",
")",
")",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"iface",
",",
"obj",
".",
"Type",
"(",
")",
")",
"\n",
"}",
"\n",
"g",
":=",
"&",
"Generator",
"{",
"ifaceName",
":",
"iface",
",",
"pkg",
":",
"p",
",",
"iface",
":",
"obj",
".",
"Type",
"(",
")",
".",
"Underlying",
"(",
")",
".",
"(",
"*",
"types",
".",
"Interface",
")",
".",
"Complete",
"(",
")",
",",
"}",
"\n",
"g",
".",
"SetTemplate",
"(",
"defaultMockTemplate",
")",
"\n",
"return",
"g",
",",
"nil",
"\n",
"}"
] | // NewGenerator initializes a Generator that will mock the given interface from the specified package. | [
"NewGenerator",
"initializes",
"a",
"Generator",
"that",
"will",
"mock",
"the",
"given",
"interface",
"from",
"the",
"specified",
"package",
"."
] | d7d4131e6607813977e78297a6060f360f056a97 | https://github.com/ernesto-jimenez/gogen/blob/d7d4131e6607813977e78297a6060f360f056a97/automock/generator.go#L28-L47 |
12,091 | ernesto-jimenez/gogen | automock/generator.go | Methods | func (g Generator) Methods() []Method {
numMethods := g.iface.NumMethods()
methods := make([]Method, numMethods)
for i := 0; i < numMethods; i++ {
methods[i] = Method{&g, g.iface.Method(i)}
}
return methods
} | go | func (g Generator) Methods() []Method {
numMethods := g.iface.NumMethods()
methods := make([]Method, numMethods)
for i := 0; i < numMethods; i++ {
methods[i] = Method{&g, g.iface.Method(i)}
}
return methods
} | [
"func",
"(",
"g",
"Generator",
")",
"Methods",
"(",
")",
"[",
"]",
"Method",
"{",
"numMethods",
":=",
"g",
".",
"iface",
".",
"NumMethods",
"(",
")",
"\n",
"methods",
":=",
"make",
"(",
"[",
"]",
"Method",
",",
"numMethods",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"numMethods",
";",
"i",
"++",
"{",
"methods",
"[",
"i",
"]",
"=",
"Method",
"{",
"&",
"g",
",",
"g",
".",
"iface",
".",
"Method",
"(",
"i",
")",
"}",
"\n",
"}",
"\n",
"return",
"methods",
"\n",
"}"
] | // Methods returns information about all the methods required to satisfy the interface | [
"Methods",
"returns",
"information",
"about",
"all",
"the",
"methods",
"required",
"to",
"satisfy",
"the",
"interface"
] | d7d4131e6607813977e78297a6060f360f056a97 | https://github.com/ernesto-jimenez/gogen/blob/d7d4131e6607813977e78297a6060f360f056a97/automock/generator.go#L50-L57 |
12,092 | ernesto-jimenez/gogen | automock/generator.go | Package | func (g Generator) Package() string {
if g.namePkg != "" {
return g.namePkg
}
if g.inPkg {
return g.pkg.Name()
}
return "mocks"
} | go | func (g Generator) Package() string {
if g.namePkg != "" {
return g.namePkg
}
if g.inPkg {
return g.pkg.Name()
}
return "mocks"
} | [
"func",
"(",
"g",
"Generator",
")",
"Package",
"(",
")",
"string",
"{",
"if",
"g",
".",
"namePkg",
"!=",
"\"",
"\"",
"{",
"return",
"g",
".",
"namePkg",
"\n",
"}",
"\n",
"if",
"g",
".",
"inPkg",
"{",
"return",
"g",
".",
"pkg",
".",
"Name",
"(",
")",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
"\n",
"}"
] | // Package returns the name of the package containing the mock | [
"Package",
"returns",
"the",
"name",
"of",
"the",
"package",
"containing",
"the",
"mock"
] | d7d4131e6607813977e78297a6060f360f056a97 | https://github.com/ernesto-jimenez/gogen/blob/d7d4131e6607813977e78297a6060f360f056a97/automock/generator.go#L80-L88 |
12,093 | ernesto-jimenez/gogen | automock/generator.go | Imports | func (g Generator) Imports() map[string]string {
imports := imports.New(g.Package())
for _, m := range g.Methods() {
s := m.signature()
imports.AddImportsFrom(s.Params())
imports.AddImportsFrom(s.Results())
}
return imports.Imports()
} | go | func (g Generator) Imports() map[string]string {
imports := imports.New(g.Package())
for _, m := range g.Methods() {
s := m.signature()
imports.AddImportsFrom(s.Params())
imports.AddImportsFrom(s.Results())
}
return imports.Imports()
} | [
"func",
"(",
"g",
"Generator",
")",
"Imports",
"(",
")",
"map",
"[",
"string",
"]",
"string",
"{",
"imports",
":=",
"imports",
".",
"New",
"(",
"g",
".",
"Package",
"(",
")",
")",
"\n",
"for",
"_",
",",
"m",
":=",
"range",
"g",
".",
"Methods",
"(",
")",
"{",
"s",
":=",
"m",
".",
"signature",
"(",
")",
"\n",
"imports",
".",
"AddImportsFrom",
"(",
"s",
".",
"Params",
"(",
")",
")",
"\n",
"imports",
".",
"AddImportsFrom",
"(",
"s",
".",
"Results",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"imports",
".",
"Imports",
"(",
")",
"\n",
"}"
] | // Imports returns all the packages that have to be imported for the | [
"Imports",
"returns",
"all",
"the",
"packages",
"that",
"have",
"to",
"be",
"imported",
"for",
"the"
] | d7d4131e6607813977e78297a6060f360f056a97 | https://github.com/ernesto-jimenez/gogen/blob/d7d4131e6607813977e78297a6060f360f056a97/automock/generator.go#L100-L108 |
12,094 | ernesto-jimenez/gogen | automock/generator.go | Write | func (g Generator) Write(wr io.Writer) error {
var buf bytes.Buffer
if err := g.mockTmpl.Execute(&buf, g); err != nil {
return err
}
err := cleanimports.Clean(wr, buf.Bytes())
if err != nil {
err = GenerationError{
Err: err,
Code: buf.Bytes(),
}
}
return err
} | go | func (g Generator) Write(wr io.Writer) error {
var buf bytes.Buffer
if err := g.mockTmpl.Execute(&buf, g); err != nil {
return err
}
err := cleanimports.Clean(wr, buf.Bytes())
if err != nil {
err = GenerationError{
Err: err,
Code: buf.Bytes(),
}
}
return err
} | [
"func",
"(",
"g",
"Generator",
")",
"Write",
"(",
"wr",
"io",
".",
"Writer",
")",
"error",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"if",
"err",
":=",
"g",
".",
"mockTmpl",
".",
"Execute",
"(",
"&",
"buf",
",",
"g",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"err",
":=",
"cleanimports",
".",
"Clean",
"(",
"wr",
",",
"buf",
".",
"Bytes",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"err",
"=",
"GenerationError",
"{",
"Err",
":",
"err",
",",
"Code",
":",
"buf",
".",
"Bytes",
"(",
")",
",",
"}",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | // Write writes the generated code in the io.Writer | [
"Write",
"writes",
"the",
"generated",
"code",
"in",
"the",
"io",
".",
"Writer"
] | d7d4131e6607813977e78297a6060f360f056a97 | https://github.com/ernesto-jimenez/gogen/blob/d7d4131e6607813977e78297a6060f360f056a97/automock/generator.go#L121-L134 |
12,095 | ernesto-jimenez/gogen | automock/generator.go | CodeWithLineNumbers | func (err GenerationError) CodeWithLineNumbers() string {
var buf bytes.Buffer
scanner := bufio.NewScanner(bytes.NewReader(err.Code))
var i int
for scanner.Scan() {
i++
fmt.Fprintf(&buf, "%d: %s\n", i, scanner.Text())
}
return buf.String()
} | go | func (err GenerationError) CodeWithLineNumbers() string {
var buf bytes.Buffer
scanner := bufio.NewScanner(bytes.NewReader(err.Code))
var i int
for scanner.Scan() {
i++
fmt.Fprintf(&buf, "%d: %s\n", i, scanner.Text())
}
return buf.String()
} | [
"func",
"(",
"err",
"GenerationError",
")",
"CodeWithLineNumbers",
"(",
")",
"string",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"scanner",
":=",
"bufio",
".",
"NewScanner",
"(",
"bytes",
".",
"NewReader",
"(",
"err",
".",
"Code",
")",
")",
"\n",
"var",
"i",
"int",
"\n",
"for",
"scanner",
".",
"Scan",
"(",
")",
"{",
"i",
"++",
"\n",
"fmt",
".",
"Fprintf",
"(",
"&",
"buf",
",",
"\"",
"\\n",
"\"",
",",
"i",
",",
"scanner",
".",
"Text",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"buf",
".",
"String",
"(",
")",
"\n",
"}"
] | // CodeWithLineNumbers returns all the code including line numbers | [
"CodeWithLineNumbers",
"returns",
"all",
"the",
"code",
"including",
"line",
"numbers"
] | d7d4131e6607813977e78297a6060f360f056a97 | https://github.com/ernesto-jimenez/gogen/blob/d7d4131e6607813977e78297a6060f360f056a97/automock/generator.go#L147-L156 |
12,096 | tidwall/raft-fastlog | store.go | Close | func (b *FastLogStore) Close() error {
b.mu.Lock()
defer b.mu.Unlock()
if b.closed {
return ErrClosed
}
b.closed = true
if b.persist {
b.file.Sync()
b.file.Close()
}
return nil
} | go | func (b *FastLogStore) Close() error {
b.mu.Lock()
defer b.mu.Unlock()
if b.closed {
return ErrClosed
}
b.closed = true
if b.persist {
b.file.Sync()
b.file.Close()
}
return nil
} | [
"func",
"(",
"b",
"*",
"FastLogStore",
")",
"Close",
"(",
")",
"error",
"{",
"b",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"b",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"b",
".",
"closed",
"{",
"return",
"ErrClosed",
"\n",
"}",
"\n",
"b",
".",
"closed",
"=",
"true",
"\n",
"if",
"b",
".",
"persist",
"{",
"b",
".",
"file",
".",
"Sync",
"(",
")",
"\n",
"b",
".",
"file",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Close is used to gracefully close the DB connection. | [
"Close",
"is",
"used",
"to",
"gracefully",
"close",
"the",
"DB",
"connection",
"."
] | f798a12ed2b37c2b03b7d0b4631bd4051fc41644 | https://github.com/tidwall/raft-fastlog/blob/f798a12ed2b37c2b03b7d0b4631bd4051fc41644/store.go#L197-L209 |
12,097 | tidwall/raft-fastlog | store.go | GetLog | func (b *FastLogStore) GetLog(idx uint64, log *raft.Log) error {
b.mu.RLock()
defer b.mu.RUnlock()
if b.closed {
return ErrClosed
}
vlog := b.lvm[idx]
if vlog == nil {
return raft.ErrLogNotFound
}
*log = *vlog
return nil
} | go | func (b *FastLogStore) GetLog(idx uint64, log *raft.Log) error {
b.mu.RLock()
defer b.mu.RUnlock()
if b.closed {
return ErrClosed
}
vlog := b.lvm[idx]
if vlog == nil {
return raft.ErrLogNotFound
}
*log = *vlog
return nil
} | [
"func",
"(",
"b",
"*",
"FastLogStore",
")",
"GetLog",
"(",
"idx",
"uint64",
",",
"log",
"*",
"raft",
".",
"Log",
")",
"error",
"{",
"b",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"b",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"b",
".",
"closed",
"{",
"return",
"ErrClosed",
"\n",
"}",
"\n",
"vlog",
":=",
"b",
".",
"lvm",
"[",
"idx",
"]",
"\n",
"if",
"vlog",
"==",
"nil",
"{",
"return",
"raft",
".",
"ErrLogNotFound",
"\n",
"}",
"\n",
"*",
"log",
"=",
"*",
"vlog",
"\n",
"return",
"nil",
"\n",
"}"
] | // GetLog is used to retrieve a log from FastLogDB at a given index. | [
"GetLog",
"is",
"used",
"to",
"retrieve",
"a",
"log",
"from",
"FastLogDB",
"at",
"a",
"given",
"index",
"."
] | f798a12ed2b37c2b03b7d0b4631bd4051fc41644 | https://github.com/tidwall/raft-fastlog/blob/f798a12ed2b37c2b03b7d0b4631bd4051fc41644/store.go#L432-L444 |
12,098 | BurntSushi/ty | type-check.go | AssertType | func AssertType(v interface{}, t reflect.Type) reflect.Value {
rv := reflect.ValueOf(v)
tv := rv.Type()
if tv != t {
ppe("Value '%v' has type '%s' but expected '%s'.", v, tv, t)
}
return rv
} | go | func AssertType(v interface{}, t reflect.Type) reflect.Value {
rv := reflect.ValueOf(v)
tv := rv.Type()
if tv != t {
ppe("Value '%v' has type '%s' but expected '%s'.", v, tv, t)
}
return rv
} | [
"func",
"AssertType",
"(",
"v",
"interface",
"{",
"}",
",",
"t",
"reflect",
".",
"Type",
")",
"reflect",
".",
"Value",
"{",
"rv",
":=",
"reflect",
".",
"ValueOf",
"(",
"v",
")",
"\n",
"tv",
":=",
"rv",
".",
"Type",
"(",
")",
"\n",
"if",
"tv",
"!=",
"t",
"{",
"ppe",
"(",
"\"",
"\"",
",",
"v",
",",
"tv",
",",
"t",
")",
"\n",
"}",
"\n",
"return",
"rv",
"\n",
"}"
] | // AssertType panics with a `TypeError` if `v` does not have type `t`.
// Otherwise, it returns the `reflect.Value` of `v`. | [
"AssertType",
"panics",
"with",
"a",
"TypeError",
"if",
"v",
"does",
"not",
"have",
"type",
"t",
".",
"Otherwise",
"it",
"returns",
"the",
"reflect",
".",
"Value",
"of",
"v",
"."
] | 6add9cd6ad42d389d6ead1dde60b4ad71e46fd74 | https://github.com/BurntSushi/ty/blob/6add9cd6ad42d389d6ead1dde60b4ad71e46fd74/type-check.go#L331-L338 |
12,099 | BurntSushi/ty | fun/list.go | Range | func Range(start, end int) []int {
if end < start {
panic("range must have end greater than or equal to start")
}
r := make([]int, end-start)
for i := start; i < end; i++ {
r[i-start] = i
}
return r
} | go | func Range(start, end int) []int {
if end < start {
panic("range must have end greater than or equal to start")
}
r := make([]int, end-start)
for i := start; i < end; i++ {
r[i-start] = i
}
return r
} | [
"func",
"Range",
"(",
"start",
",",
"end",
"int",
")",
"[",
"]",
"int",
"{",
"if",
"end",
"<",
"start",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"r",
":=",
"make",
"(",
"[",
"]",
"int",
",",
"end",
"-",
"start",
")",
"\n",
"for",
"i",
":=",
"start",
";",
"i",
"<",
"end",
";",
"i",
"++",
"{",
"r",
"[",
"i",
"-",
"start",
"]",
"=",
"i",
"\n",
"}",
"\n",
"return",
"r",
"\n",
"}"
] | // Range generates a list of integers corresponding to every integer in
// the half-open interval [x, y).
//
// Range will panic if `end < start`. | [
"Range",
"generates",
"a",
"list",
"of",
"integers",
"corresponding",
"to",
"every",
"integer",
"in",
"the",
"half",
"-",
"open",
"interval",
"[",
"x",
"y",
")",
".",
"Range",
"will",
"panic",
"if",
"end",
"<",
"start",
"."
] | 6add9cd6ad42d389d6ead1dde60b4ad71e46fd74 | https://github.com/BurntSushi/ty/blob/6add9cd6ad42d389d6ead1dde60b4ad71e46fd74/fun/list.go#L294-L303 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.