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 list | docstring stringlengths 6 2.61k | docstring_tokens list | 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",
".",
"(",
"*",
"respon... | // 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",
... | // 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",... | // 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",
"... | 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",
... | // 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",
"==... | // 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",
",",
"\"",
"\"",
",",
"\"",
"\""... | // 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",
"(",
")"... | // 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",
"ret... | // 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",
... | // 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"... | // 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",
"=",
... | // 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"... | // 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",... | // 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",
".",
"... | // 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"... | // 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",
"(",
")",
"\... | // 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",
"{",
"s... | // 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... | // 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",
... | // 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",... | 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",
"(",
"\... | // 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:... | // 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",
".",... | // 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",
"(",
"\""... | // 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",
".",
"T... | // 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 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",
")",
"... | // 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",
".... | // 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",
":",
"defa... | // 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",
":",
"d... | // 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",
"}",
"\... | // 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",
".",
... | // 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 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",
".",
"Spri... | // 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",
".",
"Ru... | // 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... | // 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",
"(... | // 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",
... | // 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",
".",
... | // 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"... | // 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... | // 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",
"(",
")",
";"... | // 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",
".",
"t... | // 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",
"// V... | // 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"... | 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",... | // 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",
"i... | 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",
... | // 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",
... | // 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",
"{",
"}",
"{... | // 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",
"}",
"{",
"}",
"\... | // 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",
"{",
"Statu... | // 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"... | // 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... | // 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... | // 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",
"}",
... | // 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",
"(",
"\"",
"\"",
",",
"[",
"]... | // 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",
".",
"La... | // 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"... | // 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",
"}",
"\... | // 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",... | // 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",
... | // 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",
":=",... | // 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",... | // 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",
... | // 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",... | // 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"... | // 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",
",",
"\"",
"\"",
","... | // 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",
")",
... | // 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",
":=",
"&",... | // 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",
"}",
... | // 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.",
"clea... | // 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'",
")",
"|... | // 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",
... | // 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",
... | // 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",
"... | // 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 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",
"=",
"... | // 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",
".",
"ReplaceAllStrin... | // 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",
"{",
"f... | // 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",
"(",
... | // 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",
... | // 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",
... | // 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",
"(",... | // 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",
... | // 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",
"!=... | // 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",
... | // 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",
"}",
... | // 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",
"... | // 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",
"... | // 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"... | // 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.