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
listlengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
listlengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
146,500 |
BurntSushi/toml
|
lex.go
|
lexDatetime
|
func lexDatetime(lx *lexer) stateFn {
r := lx.next()
if isDigit(r) {
return lexDatetime
}
switch r {
case '-', 'T', ':', '.', 'Z', '+':
return lexDatetime
}
lx.backup()
lx.emit(itemDatetime)
return lx.pop()
}
|
go
|
func lexDatetime(lx *lexer) stateFn {
r := lx.next()
if isDigit(r) {
return lexDatetime
}
switch r {
case '-', 'T', ':', '.', 'Z', '+':
return lexDatetime
}
lx.backup()
lx.emit(itemDatetime)
return lx.pop()
}
|
[
"func",
"lexDatetime",
"(",
"lx",
"*",
"lexer",
")",
"stateFn",
"{",
"r",
":=",
"lx",
".",
"next",
"(",
")",
"\n",
"if",
"isDigit",
"(",
"r",
")",
"{",
"return",
"lexDatetime",
"\n",
"}",
"\n",
"switch",
"r",
"{",
"case",
"'-'",
",",
"'T'",
",",
"':'",
",",
"'.'",
",",
"'Z'",
",",
"'+'",
":",
"return",
"lexDatetime",
"\n",
"}",
"\n\n",
"lx",
".",
"backup",
"(",
")",
"\n",
"lx",
".",
"emit",
"(",
"itemDatetime",
")",
"\n",
"return",
"lx",
".",
"pop",
"(",
")",
"\n",
"}"
] |
// lexDatetime consumes a Datetime, to a first approximation.
// The parser validates that it matches one of the accepted formats.
|
[
"lexDatetime",
"consumes",
"a",
"Datetime",
"to",
"a",
"first",
"approximation",
".",
"The",
"parser",
"validates",
"that",
"it",
"matches",
"one",
"of",
"the",
"accepted",
"formats",
"."
] |
3012a1dbe2e4bd1391d42b32f0577cb7bbc7f005
|
https://github.com/BurntSushi/toml/blob/3012a1dbe2e4bd1391d42b32f0577cb7bbc7f005/lex.go#L772-L785
|
146,501 |
BurntSushi/toml
|
encode.go
|
NewEncoder
|
func NewEncoder(w io.Writer) *Encoder {
return &Encoder{
w: bufio.NewWriter(w),
Indent: " ",
}
}
|
go
|
func NewEncoder(w io.Writer) *Encoder {
return &Encoder{
w: bufio.NewWriter(w),
Indent: " ",
}
}
|
[
"func",
"NewEncoder",
"(",
"w",
"io",
".",
"Writer",
")",
"*",
"Encoder",
"{",
"return",
"&",
"Encoder",
"{",
"w",
":",
"bufio",
".",
"NewWriter",
"(",
"w",
")",
",",
"Indent",
":",
"\"",
"\"",
",",
"}",
"\n",
"}"
] |
// NewEncoder returns a TOML encoder that encodes Go values to the io.Writer
// given. By default, a single indentation level is 2 spaces.
|
[
"NewEncoder",
"returns",
"a",
"TOML",
"encoder",
"that",
"encodes",
"Go",
"values",
"to",
"the",
"io",
".",
"Writer",
"given",
".",
"By",
"default",
"a",
"single",
"indentation",
"level",
"is",
"2",
"spaces",
"."
] |
3012a1dbe2e4bd1391d42b32f0577cb7bbc7f005
|
https://github.com/BurntSushi/toml/blob/3012a1dbe2e4bd1391d42b32f0577cb7bbc7f005/encode.go#L56-L61
|
146,502 |
bluele/gcache
|
lru.go
|
evict
|
func (c *LRUCache) evict(count int) {
for i := 0; i < count; i++ {
ent := c.evictList.Back()
if ent == nil {
return
} else {
c.removeElement(ent)
}
}
}
|
go
|
func (c *LRUCache) evict(count int) {
for i := 0; i < count; i++ {
ent := c.evictList.Back()
if ent == nil {
return
} else {
c.removeElement(ent)
}
}
}
|
[
"func",
"(",
"c",
"*",
"LRUCache",
")",
"evict",
"(",
"count",
"int",
")",
"{",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"count",
";",
"i",
"++",
"{",
"ent",
":=",
"c",
".",
"evictList",
".",
"Back",
"(",
")",
"\n",
"if",
"ent",
"==",
"nil",
"{",
"return",
"\n",
"}",
"else",
"{",
"c",
".",
"removeElement",
"(",
"ent",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// evict removes the oldest item from the cache.
|
[
"evict",
"removes",
"the",
"oldest",
"item",
"from",
"the",
"cache",
"."
] |
79ae3b2d8680cbc7ad3dba9db66b8a648575221c
|
https://github.com/bluele/gcache/blob/79ae3b2d8680cbc7ad3dba9db66b8a648575221c/lru.go#L174-L183
|
146,503 |
bluele/gcache
|
arc.go
|
Has
|
func (c *ARC) Has(key interface{}) bool {
c.mu.RLock()
defer c.mu.RUnlock()
now := time.Now()
return c.has(key, &now)
}
|
go
|
func (c *ARC) Has(key interface{}) bool {
c.mu.RLock()
defer c.mu.RUnlock()
now := time.Now()
return c.has(key, &now)
}
|
[
"func",
"(",
"c",
"*",
"ARC",
")",
"Has",
"(",
"key",
"interface",
"{",
"}",
")",
"bool",
"{",
"c",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"defer",
"c",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"now",
":=",
"time",
".",
"Now",
"(",
")",
"\n",
"return",
"c",
".",
"has",
"(",
"key",
",",
"&",
"now",
")",
"\n",
"}"
] |
// Has checks if key exists in cache
|
[
"Has",
"checks",
"if",
"key",
"exists",
"in",
"cache"
] |
79ae3b2d8680cbc7ad3dba9db66b8a648575221c
|
https://github.com/bluele/gcache/blob/79ae3b2d8680cbc7ad3dba9db66b8a648575221c/arc.go#L267-L272
|
146,504 |
bluele/gcache
|
arc.go
|
Keys
|
func (c *ARC) Keys() []interface{} {
keys := []interface{}{}
for _, k := range c.keys() {
_, err := c.GetIFPresent(k)
if err == nil {
keys = append(keys, k)
}
}
return keys
}
|
go
|
func (c *ARC) Keys() []interface{} {
keys := []interface{}{}
for _, k := range c.keys() {
_, err := c.GetIFPresent(k)
if err == nil {
keys = append(keys, k)
}
}
return keys
}
|
[
"func",
"(",
"c",
"*",
"ARC",
")",
"Keys",
"(",
")",
"[",
"]",
"interface",
"{",
"}",
"{",
"keys",
":=",
"[",
"]",
"interface",
"{",
"}",
"{",
"}",
"\n",
"for",
"_",
",",
"k",
":=",
"range",
"c",
".",
"keys",
"(",
")",
"{",
"_",
",",
"err",
":=",
"c",
".",
"GetIFPresent",
"(",
"k",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"keys",
"=",
"append",
"(",
"keys",
",",
"k",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"keys",
"\n",
"}"
] |
// Keys returns a slice of the keys in the cache.
|
[
"Keys",
"returns",
"a",
"slice",
"of",
"the",
"keys",
"in",
"the",
"cache",
"."
] |
79ae3b2d8680cbc7ad3dba9db66b8a648575221c
|
https://github.com/bluele/gcache/blob/79ae3b2d8680cbc7ad3dba9db66b8a648575221c/arc.go#L329-L338
|
146,505 |
bluele/gcache
|
arc.go
|
GetALL
|
func (c *ARC) GetALL() map[interface{}]interface{} {
m := make(map[interface{}]interface{})
for _, k := range c.keys() {
v, err := c.GetIFPresent(k)
if err == nil {
m[k] = v
}
}
return m
}
|
go
|
func (c *ARC) GetALL() map[interface{}]interface{} {
m := make(map[interface{}]interface{})
for _, k := range c.keys() {
v, err := c.GetIFPresent(k)
if err == nil {
m[k] = v
}
}
return m
}
|
[
"func",
"(",
"c",
"*",
"ARC",
")",
"GetALL",
"(",
")",
"map",
"[",
"interface",
"{",
"}",
"]",
"interface",
"{",
"}",
"{",
"m",
":=",
"make",
"(",
"map",
"[",
"interface",
"{",
"}",
"]",
"interface",
"{",
"}",
")",
"\n",
"for",
"_",
",",
"k",
":=",
"range",
"c",
".",
"keys",
"(",
")",
"{",
"v",
",",
"err",
":=",
"c",
".",
"GetIFPresent",
"(",
"k",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"m",
"[",
"k",
"]",
"=",
"v",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"m",
"\n",
"}"
] |
// GetALL returns all key-value pairs in the cache.
|
[
"GetALL",
"returns",
"all",
"key",
"-",
"value",
"pairs",
"in",
"the",
"cache",
"."
] |
79ae3b2d8680cbc7ad3dba9db66b8a648575221c
|
https://github.com/bluele/gcache/blob/79ae3b2d8680cbc7ad3dba9db66b8a648575221c/arc.go#L341-L350
|
146,506 |
bluele/gcache
|
lfu.go
|
Set
|
func (c *LFUCache) Set(key, value interface{}) error {
c.mu.Lock()
defer c.mu.Unlock()
_, err := c.set(key, value)
return err
}
|
go
|
func (c *LFUCache) Set(key, value interface{}) error {
c.mu.Lock()
defer c.mu.Unlock()
_, err := c.set(key, value)
return err
}
|
[
"func",
"(",
"c",
"*",
"LFUCache",
")",
"Set",
"(",
"key",
",",
"value",
"interface",
"{",
"}",
")",
"error",
"{",
"c",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"_",
",",
"err",
":=",
"c",
".",
"set",
"(",
"key",
",",
"value",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// Set a new key-value pair
|
[
"Set",
"a",
"new",
"key",
"-",
"value",
"pair"
] |
79ae3b2d8680cbc7ad3dba9db66b8a648575221c
|
https://github.com/bluele/gcache/blob/79ae3b2d8680cbc7ad3dba9db66b8a648575221c/lfu.go#L34-L39
|
146,507 |
bluele/gcache
|
lfu.go
|
SetWithExpire
|
func (c *LFUCache) SetWithExpire(key, value interface{}, expiration time.Duration) error {
c.mu.Lock()
defer c.mu.Unlock()
item, err := c.set(key, value)
if err != nil {
return err
}
t := c.clock.Now().Add(expiration)
item.(*lfuItem).expiration = &t
return nil
}
|
go
|
func (c *LFUCache) SetWithExpire(key, value interface{}, expiration time.Duration) error {
c.mu.Lock()
defer c.mu.Unlock()
item, err := c.set(key, value)
if err != nil {
return err
}
t := c.clock.Now().Add(expiration)
item.(*lfuItem).expiration = &t
return nil
}
|
[
"func",
"(",
"c",
"*",
"LFUCache",
")",
"SetWithExpire",
"(",
"key",
",",
"value",
"interface",
"{",
"}",
",",
"expiration",
"time",
".",
"Duration",
")",
"error",
"{",
"c",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"item",
",",
"err",
":=",
"c",
".",
"set",
"(",
"key",
",",
"value",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"t",
":=",
"c",
".",
"clock",
".",
"Now",
"(",
")",
".",
"Add",
"(",
"expiration",
")",
"\n",
"item",
".",
"(",
"*",
"lfuItem",
")",
".",
"expiration",
"=",
"&",
"t",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Set a new key-value pair with an expiration time
|
[
"Set",
"a",
"new",
"key",
"-",
"value",
"pair",
"with",
"an",
"expiration",
"time"
] |
79ae3b2d8680cbc7ad3dba9db66b8a648575221c
|
https://github.com/bluele/gcache/blob/79ae3b2d8680cbc7ad3dba9db66b8a648575221c/lfu.go#L42-L53
|
146,508 |
bluele/gcache
|
lfu.go
|
Get
|
func (c *LFUCache) Get(key interface{}) (interface{}, error) {
v, err := c.get(key, false)
if err == KeyNotFoundError {
return c.getWithLoader(key, true)
}
return v, err
}
|
go
|
func (c *LFUCache) Get(key interface{}) (interface{}, error) {
v, err := c.get(key, false)
if err == KeyNotFoundError {
return c.getWithLoader(key, true)
}
return v, err
}
|
[
"func",
"(",
"c",
"*",
"LFUCache",
")",
"Get",
"(",
"key",
"interface",
"{",
"}",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"v",
",",
"err",
":=",
"c",
".",
"get",
"(",
"key",
",",
"false",
")",
"\n",
"if",
"err",
"==",
"KeyNotFoundError",
"{",
"return",
"c",
".",
"getWithLoader",
"(",
"key",
",",
"true",
")",
"\n",
"}",
"\n",
"return",
"v",
",",
"err",
"\n",
"}"
] |
// Get a value from cache pool using key if it exists.
// If it dose not exists key and has LoaderFunc,
// generate a value using `LoaderFunc` method returns value.
|
[
"Get",
"a",
"value",
"from",
"cache",
"pool",
"using",
"key",
"if",
"it",
"exists",
".",
"If",
"it",
"dose",
"not",
"exists",
"key",
"and",
"has",
"LoaderFunc",
"generate",
"a",
"value",
"using",
"LoaderFunc",
"method",
"returns",
"value",
"."
] |
79ae3b2d8680cbc7ad3dba9db66b8a648575221c
|
https://github.com/bluele/gcache/blob/79ae3b2d8680cbc7ad3dba9db66b8a648575221c/lfu.go#L102-L108
|
146,509 |
bluele/gcache
|
lfu.go
|
evict
|
func (c *LFUCache) evict(count int) {
entry := c.freqList.Front()
for i := 0; i < count; {
if entry == nil {
return
} else {
for item, _ := range entry.Value.(*freqEntry).items {
if i >= count {
return
}
c.removeItem(item)
i++
}
entry = entry.Next()
}
}
}
|
go
|
func (c *LFUCache) evict(count int) {
entry := c.freqList.Front()
for i := 0; i < count; {
if entry == nil {
return
} else {
for item, _ := range entry.Value.(*freqEntry).items {
if i >= count {
return
}
c.removeItem(item)
i++
}
entry = entry.Next()
}
}
}
|
[
"func",
"(",
"c",
"*",
"LFUCache",
")",
"evict",
"(",
"count",
"int",
")",
"{",
"entry",
":=",
"c",
".",
"freqList",
".",
"Front",
"(",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"count",
";",
"{",
"if",
"entry",
"==",
"nil",
"{",
"return",
"\n",
"}",
"else",
"{",
"for",
"item",
",",
"_",
":=",
"range",
"entry",
".",
"Value",
".",
"(",
"*",
"freqEntry",
")",
".",
"items",
"{",
"if",
"i",
">=",
"count",
"{",
"return",
"\n",
"}",
"\n",
"c",
".",
"removeItem",
"(",
"item",
")",
"\n",
"i",
"++",
"\n",
"}",
"\n",
"entry",
"=",
"entry",
".",
"Next",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// evict removes the least frequence item from the cache.
|
[
"evict",
"removes",
"the",
"least",
"frequence",
"item",
"from",
"the",
"cache",
"."
] |
79ae3b2d8680cbc7ad3dba9db66b8a648575221c
|
https://github.com/bluele/gcache/blob/79ae3b2d8680cbc7ad3dba9db66b8a648575221c/lfu.go#L198-L214
|
146,510 |
bluele/gcache
|
stats.go
|
HitRate
|
func (st *stats) HitRate() float64 {
hc, mc := st.HitCount(), st.MissCount()
total := hc + mc
if total == 0 {
return 0.0
}
return float64(hc) / float64(total)
}
|
go
|
func (st *stats) HitRate() float64 {
hc, mc := st.HitCount(), st.MissCount()
total := hc + mc
if total == 0 {
return 0.0
}
return float64(hc) / float64(total)
}
|
[
"func",
"(",
"st",
"*",
"stats",
")",
"HitRate",
"(",
")",
"float64",
"{",
"hc",
",",
"mc",
":=",
"st",
".",
"HitCount",
"(",
")",
",",
"st",
".",
"MissCount",
"(",
")",
"\n",
"total",
":=",
"hc",
"+",
"mc",
"\n",
"if",
"total",
"==",
"0",
"{",
"return",
"0.0",
"\n",
"}",
"\n",
"return",
"float64",
"(",
"hc",
")",
"/",
"float64",
"(",
"total",
")",
"\n",
"}"
] |
// HitRate returns rate for cache hitting
|
[
"HitRate",
"returns",
"rate",
"for",
"cache",
"hitting"
] |
79ae3b2d8680cbc7ad3dba9db66b8a648575221c
|
https://github.com/bluele/gcache/blob/79ae3b2d8680cbc7ad3dba9db66b8a648575221c/stats.go#L46-L53
|
146,511 |
bluele/gcache
|
cache.go
|
load
|
func (c *baseCache) load(key interface{}, cb func(interface{}, *time.Duration, error) (interface{}, error), isWait bool) (interface{}, bool, error) {
v, called, err := c.loadGroup.Do(key, func() (v interface{}, e error) {
defer func() {
if r := recover(); r != nil {
e = fmt.Errorf("Loader panics: %v", r)
}
}()
return cb(c.loaderExpireFunc(key))
}, isWait)
if err != nil {
return nil, called, err
}
return v, called, nil
}
|
go
|
func (c *baseCache) load(key interface{}, cb func(interface{}, *time.Duration, error) (interface{}, error), isWait bool) (interface{}, bool, error) {
v, called, err := c.loadGroup.Do(key, func() (v interface{}, e error) {
defer func() {
if r := recover(); r != nil {
e = fmt.Errorf("Loader panics: %v", r)
}
}()
return cb(c.loaderExpireFunc(key))
}, isWait)
if err != nil {
return nil, called, err
}
return v, called, nil
}
|
[
"func",
"(",
"c",
"*",
"baseCache",
")",
"load",
"(",
"key",
"interface",
"{",
"}",
",",
"cb",
"func",
"(",
"interface",
"{",
"}",
",",
"*",
"time",
".",
"Duration",
",",
"error",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
",",
"isWait",
"bool",
")",
"(",
"interface",
"{",
"}",
",",
"bool",
",",
"error",
")",
"{",
"v",
",",
"called",
",",
"err",
":=",
"c",
".",
"loadGroup",
".",
"Do",
"(",
"key",
",",
"func",
"(",
")",
"(",
"v",
"interface",
"{",
"}",
",",
"e",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"r",
":=",
"recover",
"(",
")",
";",
"r",
"!=",
"nil",
"{",
"e",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"r",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"return",
"cb",
"(",
"c",
".",
"loaderExpireFunc",
"(",
"key",
")",
")",
"\n",
"}",
",",
"isWait",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"called",
",",
"err",
"\n",
"}",
"\n",
"return",
"v",
",",
"called",
",",
"nil",
"\n",
"}"
] |
// load a new value using by specified key.
|
[
"load",
"a",
"new",
"value",
"using",
"by",
"specified",
"key",
"."
] |
79ae3b2d8680cbc7ad3dba9db66b8a648575221c
|
https://github.com/bluele/gcache/blob/79ae3b2d8680cbc7ad3dba9db66b8a648575221c/cache.go#L192-L205
|
146,512 |
bitly/oauth2_proxy
|
options.go
|
secretBytes
|
func secretBytes(secret string) []byte {
b, err := base64.URLEncoding.DecodeString(addPadding(secret))
if err == nil {
return []byte(addPadding(string(b)))
}
return []byte(secret)
}
|
go
|
func secretBytes(secret string) []byte {
b, err := base64.URLEncoding.DecodeString(addPadding(secret))
if err == nil {
return []byte(addPadding(string(b)))
}
return []byte(secret)
}
|
[
"func",
"secretBytes",
"(",
"secret",
"string",
")",
"[",
"]",
"byte",
"{",
"b",
",",
"err",
":=",
"base64",
".",
"URLEncoding",
".",
"DecodeString",
"(",
"addPadding",
"(",
"secret",
")",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"return",
"[",
"]",
"byte",
"(",
"addPadding",
"(",
"string",
"(",
"b",
")",
")",
")",
"\n",
"}",
"\n",
"return",
"[",
"]",
"byte",
"(",
"secret",
")",
"\n",
"}"
] |
// secretBytes attempts to base64 decode the secret, if that fails it treats the secret as binary
|
[
"secretBytes",
"attempts",
"to",
"base64",
"decode",
"the",
"secret",
"if",
"that",
"fails",
"it",
"treats",
"the",
"secret",
"as",
"binary"
] |
fa2771998a98a5bfdfa3c3503757668ac4f1c8ec
|
https://github.com/bitly/oauth2_proxy/blob/fa2771998a98a5bfdfa3c3503757668ac4f1c8ec/options.go#L329-L335
|
146,513 |
bitly/oauth2_proxy
|
providers/internal_util.go
|
stripParam
|
func stripParam(param, endpoint string) string {
u, err := url.Parse(endpoint)
if err != nil {
log.Printf("error attempting to strip %s: %s", param, err)
return endpoint
}
if u.RawQuery != "" {
values, err := url.ParseQuery(u.RawQuery)
if err != nil {
log.Printf("error attempting to strip %s: %s", param, err)
return u.String()
}
if val := values.Get(param); val != "" {
values.Set(param, val[:(len(val)/2)]+"...")
u.RawQuery = values.Encode()
return u.String()
}
}
return endpoint
}
|
go
|
func stripParam(param, endpoint string) string {
u, err := url.Parse(endpoint)
if err != nil {
log.Printf("error attempting to strip %s: %s", param, err)
return endpoint
}
if u.RawQuery != "" {
values, err := url.ParseQuery(u.RawQuery)
if err != nil {
log.Printf("error attempting to strip %s: %s", param, err)
return u.String()
}
if val := values.Get(param); val != "" {
values.Set(param, val[:(len(val)/2)]+"...")
u.RawQuery = values.Encode()
return u.String()
}
}
return endpoint
}
|
[
"func",
"stripParam",
"(",
"param",
",",
"endpoint",
"string",
")",
"string",
"{",
"u",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"endpoint",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"param",
",",
"err",
")",
"\n",
"return",
"endpoint",
"\n",
"}",
"\n\n",
"if",
"u",
".",
"RawQuery",
"!=",
"\"",
"\"",
"{",
"values",
",",
"err",
":=",
"url",
".",
"ParseQuery",
"(",
"u",
".",
"RawQuery",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"param",
",",
"err",
")",
"\n",
"return",
"u",
".",
"String",
"(",
")",
"\n",
"}",
"\n\n",
"if",
"val",
":=",
"values",
".",
"Get",
"(",
"param",
")",
";",
"val",
"!=",
"\"",
"\"",
"{",
"values",
".",
"Set",
"(",
"param",
",",
"val",
"[",
":",
"(",
"len",
"(",
"val",
")",
"/",
"2",
")",
"]",
"+",
"\"",
"\"",
")",
"\n",
"u",
".",
"RawQuery",
"=",
"values",
".",
"Encode",
"(",
")",
"\n",
"return",
"u",
".",
"String",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"endpoint",
"\n",
"}"
] |
// stripParam generalizes the obfuscation of a particular
// query parameter - typically 'access_token' or 'client_secret'
// The parameter's second half is replaced by '...' and returned
// as part of the encoded query parameters.
// If the target parameter isn't found, the endpoint is returned
// unmodified.
|
[
"stripParam",
"generalizes",
"the",
"obfuscation",
"of",
"a",
"particular",
"query",
"parameter",
"-",
"typically",
"access_token",
"or",
"client_secret",
"The",
"parameter",
"s",
"second",
"half",
"is",
"replaced",
"by",
"...",
"and",
"returned",
"as",
"part",
"of",
"the",
"encoded",
"query",
"parameters",
".",
"If",
"the",
"target",
"parameter",
"isn",
"t",
"found",
"the",
"endpoint",
"is",
"returned",
"unmodified",
"."
] |
fa2771998a98a5bfdfa3c3503757668ac4f1c8ec
|
https://github.com/bitly/oauth2_proxy/blob/fa2771998a98a5bfdfa3c3503757668ac4f1c8ec/providers/internal_util.go#L24-L46
|
146,514 |
bitly/oauth2_proxy
|
providers/internal_util.go
|
validateToken
|
func validateToken(p Provider, access_token string, header http.Header) bool {
if access_token == "" || p.Data().ValidateURL == nil {
return false
}
endpoint := p.Data().ValidateURL.String()
if len(header) == 0 {
params := url.Values{"access_token": {access_token}}
endpoint = endpoint + "?" + params.Encode()
}
resp, err := api.RequestUnparsedResponse(endpoint, header)
if err != nil {
log.Printf("GET %s", stripToken(endpoint))
log.Printf("token validation request failed: %s", err)
return false
}
body, _ := ioutil.ReadAll(resp.Body)
resp.Body.Close()
log.Printf("%d GET %s %s", resp.StatusCode, stripToken(endpoint), body)
if resp.StatusCode == 200 {
return true
}
log.Printf("token validation request failed: status %d - %s", resp.StatusCode, body)
return false
}
|
go
|
func validateToken(p Provider, access_token string, header http.Header) bool {
if access_token == "" || p.Data().ValidateURL == nil {
return false
}
endpoint := p.Data().ValidateURL.String()
if len(header) == 0 {
params := url.Values{"access_token": {access_token}}
endpoint = endpoint + "?" + params.Encode()
}
resp, err := api.RequestUnparsedResponse(endpoint, header)
if err != nil {
log.Printf("GET %s", stripToken(endpoint))
log.Printf("token validation request failed: %s", err)
return false
}
body, _ := ioutil.ReadAll(resp.Body)
resp.Body.Close()
log.Printf("%d GET %s %s", resp.StatusCode, stripToken(endpoint), body)
if resp.StatusCode == 200 {
return true
}
log.Printf("token validation request failed: status %d - %s", resp.StatusCode, body)
return false
}
|
[
"func",
"validateToken",
"(",
"p",
"Provider",
",",
"access_token",
"string",
",",
"header",
"http",
".",
"Header",
")",
"bool",
"{",
"if",
"access_token",
"==",
"\"",
"\"",
"||",
"p",
".",
"Data",
"(",
")",
".",
"ValidateURL",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"endpoint",
":=",
"p",
".",
"Data",
"(",
")",
".",
"ValidateURL",
".",
"String",
"(",
")",
"\n",
"if",
"len",
"(",
"header",
")",
"==",
"0",
"{",
"params",
":=",
"url",
".",
"Values",
"{",
"\"",
"\"",
":",
"{",
"access_token",
"}",
"}",
"\n",
"endpoint",
"=",
"endpoint",
"+",
"\"",
"\"",
"+",
"params",
".",
"Encode",
"(",
")",
"\n",
"}",
"\n",
"resp",
",",
"err",
":=",
"api",
".",
"RequestUnparsedResponse",
"(",
"endpoint",
",",
"header",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"stripToken",
"(",
"endpoint",
")",
")",
"\n",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"false",
"\n",
"}",
"\n\n",
"body",
",",
"_",
":=",
"ioutil",
".",
"ReadAll",
"(",
"resp",
".",
"Body",
")",
"\n",
"resp",
".",
"Body",
".",
"Close",
"(",
")",
"\n",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"resp",
".",
"StatusCode",
",",
"stripToken",
"(",
"endpoint",
")",
",",
"body",
")",
"\n\n",
"if",
"resp",
".",
"StatusCode",
"==",
"200",
"{",
"return",
"true",
"\n",
"}",
"\n",
"log",
".",
"Printf",
"(",
"\"",
"\"",
",",
"resp",
".",
"StatusCode",
",",
"body",
")",
"\n",
"return",
"false",
"\n",
"}"
] |
// validateToken returns true if token is valid
|
[
"validateToken",
"returns",
"true",
"if",
"token",
"is",
"valid"
] |
fa2771998a98a5bfdfa3c3503757668ac4f1c8ec
|
https://github.com/bitly/oauth2_proxy/blob/fa2771998a98a5bfdfa3c3503757668ac4f1c8ec/providers/internal_util.go#L49-L74
|
146,515 |
bitly/oauth2_proxy
|
logging_handler.go
|
writeLogLine
|
func (h loggingHandler) writeLogLine(username, upstream string, req *http.Request, url url.URL, ts time.Time, status int, size int) {
if username == "" {
username = "-"
}
if upstream == "" {
upstream = "-"
}
if url.User != nil && username == "-" {
if name := url.User.Username(); name != "" {
username = name
}
}
client := req.Header.Get("X-Real-IP")
if client == "" {
client = req.RemoteAddr
}
if c, _, err := net.SplitHostPort(client); err == nil {
client = c
}
duration := float64(time.Now().Sub(ts)) / float64(time.Second)
h.logTemplate.Execute(h.writer, logMessageData{
Client: client,
Host: req.Host,
Protocol: req.Proto,
RequestDuration: fmt.Sprintf("%0.3f", duration),
RequestMethod: req.Method,
RequestURI: fmt.Sprintf("%q", url.RequestURI()),
ResponseSize: fmt.Sprintf("%d", size),
StatusCode: fmt.Sprintf("%d", status),
Timestamp: ts.Format("02/Jan/2006:15:04:05 -0700"),
Upstream: upstream,
UserAgent: fmt.Sprintf("%q", req.UserAgent()),
Username: username,
})
h.writer.Write([]byte("\n"))
}
|
go
|
func (h loggingHandler) writeLogLine(username, upstream string, req *http.Request, url url.URL, ts time.Time, status int, size int) {
if username == "" {
username = "-"
}
if upstream == "" {
upstream = "-"
}
if url.User != nil && username == "-" {
if name := url.User.Username(); name != "" {
username = name
}
}
client := req.Header.Get("X-Real-IP")
if client == "" {
client = req.RemoteAddr
}
if c, _, err := net.SplitHostPort(client); err == nil {
client = c
}
duration := float64(time.Now().Sub(ts)) / float64(time.Second)
h.logTemplate.Execute(h.writer, logMessageData{
Client: client,
Host: req.Host,
Protocol: req.Proto,
RequestDuration: fmt.Sprintf("%0.3f", duration),
RequestMethod: req.Method,
RequestURI: fmt.Sprintf("%q", url.RequestURI()),
ResponseSize: fmt.Sprintf("%d", size),
StatusCode: fmt.Sprintf("%d", status),
Timestamp: ts.Format("02/Jan/2006:15:04:05 -0700"),
Upstream: upstream,
UserAgent: fmt.Sprintf("%q", req.UserAgent()),
Username: username,
})
h.writer.Write([]byte("\n"))
}
|
[
"func",
"(",
"h",
"loggingHandler",
")",
"writeLogLine",
"(",
"username",
",",
"upstream",
"string",
",",
"req",
"*",
"http",
".",
"Request",
",",
"url",
"url",
".",
"URL",
",",
"ts",
"time",
".",
"Time",
",",
"status",
"int",
",",
"size",
"int",
")",
"{",
"if",
"username",
"==",
"\"",
"\"",
"{",
"username",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"if",
"upstream",
"==",
"\"",
"\"",
"{",
"upstream",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"if",
"url",
".",
"User",
"!=",
"nil",
"&&",
"username",
"==",
"\"",
"\"",
"{",
"if",
"name",
":=",
"url",
".",
"User",
".",
"Username",
"(",
")",
";",
"name",
"!=",
"\"",
"\"",
"{",
"username",
"=",
"name",
"\n",
"}",
"\n",
"}",
"\n\n",
"client",
":=",
"req",
".",
"Header",
".",
"Get",
"(",
"\"",
"\"",
")",
"\n",
"if",
"client",
"==",
"\"",
"\"",
"{",
"client",
"=",
"req",
".",
"RemoteAddr",
"\n",
"}",
"\n\n",
"if",
"c",
",",
"_",
",",
"err",
":=",
"net",
".",
"SplitHostPort",
"(",
"client",
")",
";",
"err",
"==",
"nil",
"{",
"client",
"=",
"c",
"\n",
"}",
"\n\n",
"duration",
":=",
"float64",
"(",
"time",
".",
"Now",
"(",
")",
".",
"Sub",
"(",
"ts",
")",
")",
"/",
"float64",
"(",
"time",
".",
"Second",
")",
"\n\n",
"h",
".",
"logTemplate",
".",
"Execute",
"(",
"h",
".",
"writer",
",",
"logMessageData",
"{",
"Client",
":",
"client",
",",
"Host",
":",
"req",
".",
"Host",
",",
"Protocol",
":",
"req",
".",
"Proto",
",",
"RequestDuration",
":",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"duration",
")",
",",
"RequestMethod",
":",
"req",
".",
"Method",
",",
"RequestURI",
":",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"url",
".",
"RequestURI",
"(",
")",
")",
",",
"ResponseSize",
":",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"size",
")",
",",
"StatusCode",
":",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"status",
")",
",",
"Timestamp",
":",
"ts",
".",
"Format",
"(",
"\"",
"\"",
")",
",",
"Upstream",
":",
"upstream",
",",
"UserAgent",
":",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"req",
".",
"UserAgent",
"(",
")",
")",
",",
"Username",
":",
"username",
",",
"}",
")",
"\n\n",
"h",
".",
"writer",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"\"",
"\\n",
"\"",
")",
")",
"\n",
"}"
] |
// Log entry for req similar to Apache Common Log Format.
// ts is the timestamp with which the entry should be logged.
// status, size are used to provide the response HTTP status and size.
|
[
"Log",
"entry",
"for",
"req",
"similar",
"to",
"Apache",
"Common",
"Log",
"Format",
".",
"ts",
"is",
"the",
"timestamp",
"with",
"which",
"the",
"entry",
"should",
"be",
"logged",
".",
"status",
"size",
"are",
"used",
"to",
"provide",
"the",
"response",
"HTTP",
"status",
"and",
"size",
"."
] |
fa2771998a98a5bfdfa3c3503757668ac4f1c8ec
|
https://github.com/bitly/oauth2_proxy/blob/fa2771998a98a5bfdfa3c3503757668ac4f1c8ec/logging_handler.go#L120-L160
|
146,516 |
bitly/oauth2_proxy
|
cookie/cookies.go
|
SignedValue
|
func SignedValue(seed string, key string, value string, now time.Time) string {
encodedValue := base64.URLEncoding.EncodeToString([]byte(value))
timeStr := fmt.Sprintf("%d", now.Unix())
sig := cookieSignature(seed, key, encodedValue, timeStr)
cookieVal := fmt.Sprintf("%s|%s|%s", encodedValue, timeStr, sig)
return cookieVal
}
|
go
|
func SignedValue(seed string, key string, value string, now time.Time) string {
encodedValue := base64.URLEncoding.EncodeToString([]byte(value))
timeStr := fmt.Sprintf("%d", now.Unix())
sig := cookieSignature(seed, key, encodedValue, timeStr)
cookieVal := fmt.Sprintf("%s|%s|%s", encodedValue, timeStr, sig)
return cookieVal
}
|
[
"func",
"SignedValue",
"(",
"seed",
"string",
",",
"key",
"string",
",",
"value",
"string",
",",
"now",
"time",
".",
"Time",
")",
"string",
"{",
"encodedValue",
":=",
"base64",
".",
"URLEncoding",
".",
"EncodeToString",
"(",
"[",
"]",
"byte",
"(",
"value",
")",
")",
"\n",
"timeStr",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"now",
".",
"Unix",
"(",
")",
")",
"\n",
"sig",
":=",
"cookieSignature",
"(",
"seed",
",",
"key",
",",
"encodedValue",
",",
"timeStr",
")",
"\n",
"cookieVal",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"encodedValue",
",",
"timeStr",
",",
"sig",
")",
"\n",
"return",
"cookieVal",
"\n",
"}"
] |
// SignedValue returns a cookie that is signed and can later be checked with Validate
|
[
"SignedValue",
"returns",
"a",
"cookie",
"that",
"is",
"signed",
"and",
"can",
"later",
"be",
"checked",
"with",
"Validate"
] |
fa2771998a98a5bfdfa3c3503757668ac4f1c8ec
|
https://github.com/bitly/oauth2_proxy/blob/fa2771998a98a5bfdfa3c3503757668ac4f1c8ec/cookie/cookies.go#L53-L59
|
146,517 |
bitly/oauth2_proxy
|
cookie/cookies.go
|
NewCipher
|
func NewCipher(secret []byte) (*Cipher, error) {
c, err := aes.NewCipher(secret)
if err != nil {
return nil, err
}
return &Cipher{Block: c}, err
}
|
go
|
func NewCipher(secret []byte) (*Cipher, error) {
c, err := aes.NewCipher(secret)
if err != nil {
return nil, err
}
return &Cipher{Block: c}, err
}
|
[
"func",
"NewCipher",
"(",
"secret",
"[",
"]",
"byte",
")",
"(",
"*",
"Cipher",
",",
"error",
")",
"{",
"c",
",",
"err",
":=",
"aes",
".",
"NewCipher",
"(",
"secret",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"Cipher",
"{",
"Block",
":",
"c",
"}",
",",
"err",
"\n",
"}"
] |
// NewCipher returns a new aes Cipher for encrypting cookie values
|
[
"NewCipher",
"returns",
"a",
"new",
"aes",
"Cipher",
"for",
"encrypting",
"cookie",
"values"
] |
fa2771998a98a5bfdfa3c3503757668ac4f1c8ec
|
https://github.com/bitly/oauth2_proxy/blob/fa2771998a98a5bfdfa3c3503757668ac4f1c8ec/cookie/cookies.go#L88-L94
|
146,518 |
bitly/oauth2_proxy
|
cookie/cookies.go
|
Encrypt
|
func (c *Cipher) Encrypt(value string) (string, error) {
ciphertext := make([]byte, aes.BlockSize+len(value))
iv := ciphertext[:aes.BlockSize]
if _, err := io.ReadFull(rand.Reader, iv); err != nil {
return "", fmt.Errorf("failed to create initialization vector %s", err)
}
stream := cipher.NewCFBEncrypter(c.Block, iv)
stream.XORKeyStream(ciphertext[aes.BlockSize:], []byte(value))
return base64.StdEncoding.EncodeToString(ciphertext), nil
}
|
go
|
func (c *Cipher) Encrypt(value string) (string, error) {
ciphertext := make([]byte, aes.BlockSize+len(value))
iv := ciphertext[:aes.BlockSize]
if _, err := io.ReadFull(rand.Reader, iv); err != nil {
return "", fmt.Errorf("failed to create initialization vector %s", err)
}
stream := cipher.NewCFBEncrypter(c.Block, iv)
stream.XORKeyStream(ciphertext[aes.BlockSize:], []byte(value))
return base64.StdEncoding.EncodeToString(ciphertext), nil
}
|
[
"func",
"(",
"c",
"*",
"Cipher",
")",
"Encrypt",
"(",
"value",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"ciphertext",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"aes",
".",
"BlockSize",
"+",
"len",
"(",
"value",
")",
")",
"\n",
"iv",
":=",
"ciphertext",
"[",
":",
"aes",
".",
"BlockSize",
"]",
"\n",
"if",
"_",
",",
"err",
":=",
"io",
".",
"ReadFull",
"(",
"rand",
".",
"Reader",
",",
"iv",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"stream",
":=",
"cipher",
".",
"NewCFBEncrypter",
"(",
"c",
".",
"Block",
",",
"iv",
")",
"\n",
"stream",
".",
"XORKeyStream",
"(",
"ciphertext",
"[",
"aes",
".",
"BlockSize",
":",
"]",
",",
"[",
"]",
"byte",
"(",
"value",
")",
")",
"\n",
"return",
"base64",
".",
"StdEncoding",
".",
"EncodeToString",
"(",
"ciphertext",
")",
",",
"nil",
"\n",
"}"
] |
// Encrypt a value for use in a cookie
|
[
"Encrypt",
"a",
"value",
"for",
"use",
"in",
"a",
"cookie"
] |
fa2771998a98a5bfdfa3c3503757668ac4f1c8ec
|
https://github.com/bitly/oauth2_proxy/blob/fa2771998a98a5bfdfa3c3503757668ac4f1c8ec/cookie/cookies.go#L97-L107
|
146,519 |
bitly/oauth2_proxy
|
cookie/cookies.go
|
Decrypt
|
func (c *Cipher) Decrypt(s string) (string, error) {
encrypted, err := base64.StdEncoding.DecodeString(s)
if err != nil {
return "", fmt.Errorf("failed to decrypt cookie value %s", err)
}
if len(encrypted) < aes.BlockSize {
return "", fmt.Errorf("encrypted cookie value should be "+
"at least %d bytes, but is only %d bytes",
aes.BlockSize, len(encrypted))
}
iv := encrypted[:aes.BlockSize]
encrypted = encrypted[aes.BlockSize:]
stream := cipher.NewCFBDecrypter(c.Block, iv)
stream.XORKeyStream(encrypted, encrypted)
return string(encrypted), nil
}
|
go
|
func (c *Cipher) Decrypt(s string) (string, error) {
encrypted, err := base64.StdEncoding.DecodeString(s)
if err != nil {
return "", fmt.Errorf("failed to decrypt cookie value %s", err)
}
if len(encrypted) < aes.BlockSize {
return "", fmt.Errorf("encrypted cookie value should be "+
"at least %d bytes, but is only %d bytes",
aes.BlockSize, len(encrypted))
}
iv := encrypted[:aes.BlockSize]
encrypted = encrypted[aes.BlockSize:]
stream := cipher.NewCFBDecrypter(c.Block, iv)
stream.XORKeyStream(encrypted, encrypted)
return string(encrypted), nil
}
|
[
"func",
"(",
"c",
"*",
"Cipher",
")",
"Decrypt",
"(",
"s",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"encrypted",
",",
"err",
":=",
"base64",
".",
"StdEncoding",
".",
"DecodeString",
"(",
"s",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"encrypted",
")",
"<",
"aes",
".",
"BlockSize",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
"+",
"\"",
"\"",
",",
"aes",
".",
"BlockSize",
",",
"len",
"(",
"encrypted",
")",
")",
"\n",
"}",
"\n\n",
"iv",
":=",
"encrypted",
"[",
":",
"aes",
".",
"BlockSize",
"]",
"\n",
"encrypted",
"=",
"encrypted",
"[",
"aes",
".",
"BlockSize",
":",
"]",
"\n",
"stream",
":=",
"cipher",
".",
"NewCFBDecrypter",
"(",
"c",
".",
"Block",
",",
"iv",
")",
"\n",
"stream",
".",
"XORKeyStream",
"(",
"encrypted",
",",
"encrypted",
")",
"\n\n",
"return",
"string",
"(",
"encrypted",
")",
",",
"nil",
"\n",
"}"
] |
// Decrypt a value from a cookie to it's original string
|
[
"Decrypt",
"a",
"value",
"from",
"a",
"cookie",
"to",
"it",
"s",
"original",
"string"
] |
fa2771998a98a5bfdfa3c3503757668ac4f1c8ec
|
https://github.com/bitly/oauth2_proxy/blob/fa2771998a98a5bfdfa3c3503757668ac4f1c8ec/cookie/cookies.go#L110-L128
|
146,520 |
bitly/oauth2_proxy
|
providers/provider_default.go
|
GetLoginURL
|
func (p *ProviderData) GetLoginURL(redirectURI, state string) string {
var a url.URL
a = *p.LoginURL
params, _ := url.ParseQuery(a.RawQuery)
params.Set("redirect_uri", redirectURI)
params.Set("approval_prompt", p.ApprovalPrompt)
params.Add("scope", p.Scope)
params.Set("client_id", p.ClientID)
params.Set("response_type", "code")
params.Add("state", state)
a.RawQuery = params.Encode()
return a.String()
}
|
go
|
func (p *ProviderData) GetLoginURL(redirectURI, state string) string {
var a url.URL
a = *p.LoginURL
params, _ := url.ParseQuery(a.RawQuery)
params.Set("redirect_uri", redirectURI)
params.Set("approval_prompt", p.ApprovalPrompt)
params.Add("scope", p.Scope)
params.Set("client_id", p.ClientID)
params.Set("response_type", "code")
params.Add("state", state)
a.RawQuery = params.Encode()
return a.String()
}
|
[
"func",
"(",
"p",
"*",
"ProviderData",
")",
"GetLoginURL",
"(",
"redirectURI",
",",
"state",
"string",
")",
"string",
"{",
"var",
"a",
"url",
".",
"URL",
"\n",
"a",
"=",
"*",
"p",
".",
"LoginURL",
"\n",
"params",
",",
"_",
":=",
"url",
".",
"ParseQuery",
"(",
"a",
".",
"RawQuery",
")",
"\n",
"params",
".",
"Set",
"(",
"\"",
"\"",
",",
"redirectURI",
")",
"\n",
"params",
".",
"Set",
"(",
"\"",
"\"",
",",
"p",
".",
"ApprovalPrompt",
")",
"\n",
"params",
".",
"Add",
"(",
"\"",
"\"",
",",
"p",
".",
"Scope",
")",
"\n",
"params",
".",
"Set",
"(",
"\"",
"\"",
",",
"p",
".",
"ClientID",
")",
"\n",
"params",
".",
"Set",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"params",
".",
"Add",
"(",
"\"",
"\"",
",",
"state",
")",
"\n",
"a",
".",
"RawQuery",
"=",
"params",
".",
"Encode",
"(",
")",
"\n",
"return",
"a",
".",
"String",
"(",
")",
"\n",
"}"
] |
// GetLoginURL with typical oauth parameters
|
[
"GetLoginURL",
"with",
"typical",
"oauth",
"parameters"
] |
fa2771998a98a5bfdfa3c3503757668ac4f1c8ec
|
https://github.com/bitly/oauth2_proxy/blob/fa2771998a98a5bfdfa3c3503757668ac4f1c8ec/providers/provider_default.go#L81-L93
|
146,521 |
bitly/oauth2_proxy
|
providers/provider_default.go
|
CookieForSession
|
func (p *ProviderData) CookieForSession(s *SessionState, c *cookie.Cipher) (string, error) {
return s.EncodeSessionState(c)
}
|
go
|
func (p *ProviderData) CookieForSession(s *SessionState, c *cookie.Cipher) (string, error) {
return s.EncodeSessionState(c)
}
|
[
"func",
"(",
"p",
"*",
"ProviderData",
")",
"CookieForSession",
"(",
"s",
"*",
"SessionState",
",",
"c",
"*",
"cookie",
".",
"Cipher",
")",
"(",
"string",
",",
"error",
")",
"{",
"return",
"s",
".",
"EncodeSessionState",
"(",
"c",
")",
"\n",
"}"
] |
// CookieForSession serializes a session state for storage in a cookie
|
[
"CookieForSession",
"serializes",
"a",
"session",
"state",
"for",
"storage",
"in",
"a",
"cookie"
] |
fa2771998a98a5bfdfa3c3503757668ac4f1c8ec
|
https://github.com/bitly/oauth2_proxy/blob/fa2771998a98a5bfdfa3c3503757668ac4f1c8ec/providers/provider_default.go#L96-L98
|
146,522 |
bitly/oauth2_proxy
|
providers/provider_default.go
|
SessionFromCookie
|
func (p *ProviderData) SessionFromCookie(v string, c *cookie.Cipher) (s *SessionState, err error) {
return DecodeSessionState(v, c)
}
|
go
|
func (p *ProviderData) SessionFromCookie(v string, c *cookie.Cipher) (s *SessionState, err error) {
return DecodeSessionState(v, c)
}
|
[
"func",
"(",
"p",
"*",
"ProviderData",
")",
"SessionFromCookie",
"(",
"v",
"string",
",",
"c",
"*",
"cookie",
".",
"Cipher",
")",
"(",
"s",
"*",
"SessionState",
",",
"err",
"error",
")",
"{",
"return",
"DecodeSessionState",
"(",
"v",
",",
"c",
")",
"\n",
"}"
] |
// SessionFromCookie deserializes a session from a cookie value
|
[
"SessionFromCookie",
"deserializes",
"a",
"session",
"from",
"a",
"cookie",
"value"
] |
fa2771998a98a5bfdfa3c3503757668ac4f1c8ec
|
https://github.com/bitly/oauth2_proxy/blob/fa2771998a98a5bfdfa3c3503757668ac4f1c8ec/providers/provider_default.go#L101-L103
|
146,523 |
mattn/go-sqlite3
|
_example/custom_func/main.go
|
xor
|
func xor(xs ...int64) int64 {
var ret int64
for _, x := range xs {
ret ^= x
}
return ret
}
|
go
|
func xor(xs ...int64) int64 {
var ret int64
for _, x := range xs {
ret ^= x
}
return ret
}
|
[
"func",
"xor",
"(",
"xs",
"...",
"int64",
")",
"int64",
"{",
"var",
"ret",
"int64",
"\n",
"for",
"_",
",",
"x",
":=",
"range",
"xs",
"{",
"ret",
"^=",
"x",
"\n",
"}",
"\n",
"return",
"ret",
"\n",
"}"
] |
// Computes the bitwise exclusive-or of all its arguments
|
[
"Computes",
"the",
"bitwise",
"exclusive",
"-",
"or",
"of",
"all",
"its",
"arguments"
] |
5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3
|
https://github.com/mattn/go-sqlite3/blob/5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3/_example/custom_func/main.go#L19-L25
|
146,524 |
mattn/go-sqlite3
|
sqlite3_trace.go
|
popTraceMapping
|
func popTraceMapping(connHandle uintptr) (TraceConfig, bool) {
traceMapLock.Lock()
defer traceMapLock.Unlock()
entryCopy, found := traceMap[connHandle]
if found {
delete(traceMap, connHandle)
fmt.Printf("Pop handle 0x%x: deleted trace config %v.\n", connHandle, entryCopy.config)
}
return entryCopy.config, found
}
|
go
|
func popTraceMapping(connHandle uintptr) (TraceConfig, bool) {
traceMapLock.Lock()
defer traceMapLock.Unlock()
entryCopy, found := traceMap[connHandle]
if found {
delete(traceMap, connHandle)
fmt.Printf("Pop handle 0x%x: deleted trace config %v.\n", connHandle, entryCopy.config)
}
return entryCopy.config, found
}
|
[
"func",
"popTraceMapping",
"(",
"connHandle",
"uintptr",
")",
"(",
"TraceConfig",
",",
"bool",
")",
"{",
"traceMapLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"traceMapLock",
".",
"Unlock",
"(",
")",
"\n\n",
"entryCopy",
",",
"found",
":=",
"traceMap",
"[",
"connHandle",
"]",
"\n",
"if",
"found",
"{",
"delete",
"(",
"traceMap",
",",
"connHandle",
")",
"\n",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"connHandle",
",",
"entryCopy",
".",
"config",
")",
"\n",
"}",
"\n",
"return",
"entryCopy",
".",
"config",
",",
"found",
"\n",
"}"
] |
// 'pop' = get and delete from map before returning the value to the caller
|
[
"pop",
"=",
"get",
"and",
"delete",
"from",
"map",
"before",
"returning",
"the",
"value",
"to",
"the",
"caller"
] |
5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3
|
https://github.com/mattn/go-sqlite3/blob/5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3/sqlite3_trace.go#L229-L239
|
146,525 |
mattn/go-sqlite3
|
backup.go
|
Backup
|
func (c *SQLiteConn) Backup(dest string, conn *SQLiteConn, src string) (*SQLiteBackup, error) {
destptr := C.CString(dest)
defer C.free(unsafe.Pointer(destptr))
srcptr := C.CString(src)
defer C.free(unsafe.Pointer(srcptr))
if b := C.sqlite3_backup_init(c.db, destptr, conn.db, srcptr); b != nil {
bb := &SQLiteBackup{b: b}
runtime.SetFinalizer(bb, (*SQLiteBackup).Finish)
return bb, nil
}
return nil, c.lastError()
}
|
go
|
func (c *SQLiteConn) Backup(dest string, conn *SQLiteConn, src string) (*SQLiteBackup, error) {
destptr := C.CString(dest)
defer C.free(unsafe.Pointer(destptr))
srcptr := C.CString(src)
defer C.free(unsafe.Pointer(srcptr))
if b := C.sqlite3_backup_init(c.db, destptr, conn.db, srcptr); b != nil {
bb := &SQLiteBackup{b: b}
runtime.SetFinalizer(bb, (*SQLiteBackup).Finish)
return bb, nil
}
return nil, c.lastError()
}
|
[
"func",
"(",
"c",
"*",
"SQLiteConn",
")",
"Backup",
"(",
"dest",
"string",
",",
"conn",
"*",
"SQLiteConn",
",",
"src",
"string",
")",
"(",
"*",
"SQLiteBackup",
",",
"error",
")",
"{",
"destptr",
":=",
"C",
".",
"CString",
"(",
"dest",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"destptr",
")",
")",
"\n",
"srcptr",
":=",
"C",
".",
"CString",
"(",
"src",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"srcptr",
")",
")",
"\n\n",
"if",
"b",
":=",
"C",
".",
"sqlite3_backup_init",
"(",
"c",
".",
"db",
",",
"destptr",
",",
"conn",
".",
"db",
",",
"srcptr",
")",
";",
"b",
"!=",
"nil",
"{",
"bb",
":=",
"&",
"SQLiteBackup",
"{",
"b",
":",
"b",
"}",
"\n",
"runtime",
".",
"SetFinalizer",
"(",
"bb",
",",
"(",
"*",
"SQLiteBackup",
")",
".",
"Finish",
")",
"\n",
"return",
"bb",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"c",
".",
"lastError",
"(",
")",
"\n",
"}"
] |
// Backup make backup from src to dest.
|
[
"Backup",
"make",
"backup",
"from",
"src",
"to",
"dest",
"."
] |
5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3
|
https://github.com/mattn/go-sqlite3/blob/5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3/backup.go#L28-L40
|
146,526 |
mattn/go-sqlite3
|
backup.go
|
Close
|
func (b *SQLiteBackup) Close() error {
ret := C.sqlite3_backup_finish(b.b)
// sqlite3_backup_finish() never fails, it just returns the
// error code from previous operations, so clean up before
// checking and returning an error
b.b = nil
runtime.SetFinalizer(b, nil)
if ret != 0 {
return Error{Code: ErrNo(ret)}
}
return nil
}
|
go
|
func (b *SQLiteBackup) Close() error {
ret := C.sqlite3_backup_finish(b.b)
// sqlite3_backup_finish() never fails, it just returns the
// error code from previous operations, so clean up before
// checking and returning an error
b.b = nil
runtime.SetFinalizer(b, nil)
if ret != 0 {
return Error{Code: ErrNo(ret)}
}
return nil
}
|
[
"func",
"(",
"b",
"*",
"SQLiteBackup",
")",
"Close",
"(",
")",
"error",
"{",
"ret",
":=",
"C",
".",
"sqlite3_backup_finish",
"(",
"b",
".",
"b",
")",
"\n\n",
"// sqlite3_backup_finish() never fails, it just returns the",
"// error code from previous operations, so clean up before",
"// checking and returning an error",
"b",
".",
"b",
"=",
"nil",
"\n",
"runtime",
".",
"SetFinalizer",
"(",
"b",
",",
"nil",
")",
"\n\n",
"if",
"ret",
"!=",
"0",
"{",
"return",
"Error",
"{",
"Code",
":",
"ErrNo",
"(",
"ret",
")",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Close close backup.
|
[
"Close",
"close",
"backup",
"."
] |
5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3
|
https://github.com/mattn/go-sqlite3/blob/5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3/backup.go#L72-L85
|
146,527 |
mattn/go-sqlite3
|
sqlite3_context.go
|
ResultBool
|
func (c *SQLiteContext) ResultBool(b bool) {
if b {
c.ResultInt(1)
} else {
c.ResultInt(0)
}
}
|
go
|
func (c *SQLiteContext) ResultBool(b bool) {
if b {
c.ResultInt(1)
} else {
c.ResultInt(0)
}
}
|
[
"func",
"(",
"c",
"*",
"SQLiteContext",
")",
"ResultBool",
"(",
"b",
"bool",
")",
"{",
"if",
"b",
"{",
"c",
".",
"ResultInt",
"(",
"1",
")",
"\n",
"}",
"else",
"{",
"c",
".",
"ResultInt",
"(",
"0",
")",
"\n",
"}",
"\n",
"}"
] |
// ResultBool sets the result of an SQL function.
|
[
"ResultBool",
"sets",
"the",
"result",
"of",
"an",
"SQL",
"function",
"."
] |
5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3
|
https://github.com/mattn/go-sqlite3/blob/5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3/sqlite3_context.go#L41-L47
|
146,528 |
mattn/go-sqlite3
|
error.go
|
Extend
|
func (err ErrNo) Extend(by int) ErrNoExtended {
return ErrNoExtended(int(err) | (by << 8))
}
|
go
|
func (err ErrNo) Extend(by int) ErrNoExtended {
return ErrNoExtended(int(err) | (by << 8))
}
|
[
"func",
"(",
"err",
"ErrNo",
")",
"Extend",
"(",
"by",
"int",
")",
"ErrNoExtended",
"{",
"return",
"ErrNoExtended",
"(",
"int",
"(",
"err",
")",
"|",
"(",
"by",
"<<",
"8",
")",
")",
"\n",
"}"
] |
// Extend return extended errno.
|
[
"Extend",
"return",
"extended",
"errno",
"."
] |
5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3
|
https://github.com/mattn/go-sqlite3/blob/5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3/error.go#L65-L67
|
146,529 |
mattn/go-sqlite3
|
error.go
|
Error
|
func (err ErrNoExtended) Error() string {
return Error{Code: ErrNo(C.int(err) & ErrNoMask), ExtendedCode: err}.Error()
}
|
go
|
func (err ErrNoExtended) Error() string {
return Error{Code: ErrNo(C.int(err) & ErrNoMask), ExtendedCode: err}.Error()
}
|
[
"func",
"(",
"err",
"ErrNoExtended",
")",
"Error",
"(",
")",
"string",
"{",
"return",
"Error",
"{",
"Code",
":",
"ErrNo",
"(",
"C",
".",
"int",
"(",
"err",
")",
"&",
"ErrNoMask",
")",
",",
"ExtendedCode",
":",
"err",
"}",
".",
"Error",
"(",
")",
"\n",
"}"
] |
// Error return error message that is extended code.
|
[
"Error",
"return",
"error",
"message",
"that",
"is",
"extended",
"code",
"."
] |
5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3
|
https://github.com/mattn/go-sqlite3/blob/5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3/error.go#L70-L72
|
146,530 |
mattn/go-sqlite3
|
sqlite3_opt_vtable.go
|
mPrintf
|
func mPrintf(format, arg string) *C.char {
cf := C.CString(format)
defer C.free(unsafe.Pointer(cf))
ca := C.CString(arg)
defer C.free(unsafe.Pointer(ca))
return C._sqlite3_mprintf(cf, ca)
}
|
go
|
func mPrintf(format, arg string) *C.char {
cf := C.CString(format)
defer C.free(unsafe.Pointer(cf))
ca := C.CString(arg)
defer C.free(unsafe.Pointer(ca))
return C._sqlite3_mprintf(cf, ca)
}
|
[
"func",
"mPrintf",
"(",
"format",
",",
"arg",
"string",
")",
"*",
"C",
".",
"char",
"{",
"cf",
":=",
"C",
".",
"CString",
"(",
"format",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cf",
")",
")",
"\n",
"ca",
":=",
"C",
".",
"CString",
"(",
"arg",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"ca",
")",
")",
"\n",
"return",
"C",
".",
"_sqlite3_mprintf",
"(",
"cf",
",",
"ca",
")",
"\n",
"}"
] |
// mPrintf is a utility wrapper around sqlite3_mprintf
|
[
"mPrintf",
"is",
"a",
"utility",
"wrapper",
"around",
"sqlite3_mprintf"
] |
5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3
|
https://github.com/mattn/go-sqlite3/blob/5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3/sqlite3_opt_vtable.go#L340-L346
|
146,531 |
mattn/go-sqlite3
|
sqlite3.go
|
Version
|
func Version() (libVersion string, libVersionNumber int, sourceID string) {
libVersion = C.GoString(C.sqlite3_libversion())
libVersionNumber = int(C.sqlite3_libversion_number())
sourceID = C.GoString(C.sqlite3_sourceid())
return libVersion, libVersionNumber, sourceID
}
|
go
|
func Version() (libVersion string, libVersionNumber int, sourceID string) {
libVersion = C.GoString(C.sqlite3_libversion())
libVersionNumber = int(C.sqlite3_libversion_number())
sourceID = C.GoString(C.sqlite3_sourceid())
return libVersion, libVersionNumber, sourceID
}
|
[
"func",
"Version",
"(",
")",
"(",
"libVersion",
"string",
",",
"libVersionNumber",
"int",
",",
"sourceID",
"string",
")",
"{",
"libVersion",
"=",
"C",
".",
"GoString",
"(",
"C",
".",
"sqlite3_libversion",
"(",
")",
")",
"\n",
"libVersionNumber",
"=",
"int",
"(",
"C",
".",
"sqlite3_libversion_number",
"(",
")",
")",
"\n",
"sourceID",
"=",
"C",
".",
"GoString",
"(",
"C",
".",
"sqlite3_sourceid",
"(",
")",
")",
"\n",
"return",
"libVersion",
",",
"libVersionNumber",
",",
"sourceID",
"\n",
"}"
] |
// Version returns SQLite library version information.
|
[
"Version",
"returns",
"SQLite",
"library",
"version",
"information",
"."
] |
5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3
|
https://github.com/mattn/go-sqlite3/blob/5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3/sqlite3.go#L234-L239
|
146,532 |
mattn/go-sqlite3
|
sqlite3.go
|
Commit
|
func (tx *SQLiteTx) Commit() error {
_, err := tx.c.exec(context.Background(), "COMMIT", nil)
if err != nil && err.(Error).Code == C.SQLITE_BUSY {
// sqlite3 will leave the transaction open in this scenario.
// However, database/sql considers the transaction complete once we
// return from Commit() - we must clean up to honour its semantics.
tx.c.exec(context.Background(), "ROLLBACK", nil)
}
return err
}
|
go
|
func (tx *SQLiteTx) Commit() error {
_, err := tx.c.exec(context.Background(), "COMMIT", nil)
if err != nil && err.(Error).Code == C.SQLITE_BUSY {
// sqlite3 will leave the transaction open in this scenario.
// However, database/sql considers the transaction complete once we
// return from Commit() - we must clean up to honour its semantics.
tx.c.exec(context.Background(), "ROLLBACK", nil)
}
return err
}
|
[
"func",
"(",
"tx",
"*",
"SQLiteTx",
")",
"Commit",
"(",
")",
"error",
"{",
"_",
",",
"err",
":=",
"tx",
".",
"c",
".",
"exec",
"(",
"context",
".",
"Background",
"(",
")",
",",
"\"",
"\"",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"err",
".",
"(",
"Error",
")",
".",
"Code",
"==",
"C",
".",
"SQLITE_BUSY",
"{",
"// sqlite3 will leave the transaction open in this scenario.",
"// However, database/sql considers the transaction complete once we",
"// return from Commit() - we must clean up to honour its semantics.",
"tx",
".",
"c",
".",
"exec",
"(",
"context",
".",
"Background",
"(",
")",
",",
"\"",
"\"",
",",
"nil",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] |
// Commit transaction.
|
[
"Commit",
"transaction",
"."
] |
5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3
|
https://github.com/mattn/go-sqlite3/blob/5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3/sqlite3.go#L436-L445
|
146,533 |
mattn/go-sqlite3
|
sqlite3.go
|
Rollback
|
func (tx *SQLiteTx) Rollback() error {
_, err := tx.c.exec(context.Background(), "ROLLBACK", nil)
return err
}
|
go
|
func (tx *SQLiteTx) Rollback() error {
_, err := tx.c.exec(context.Background(), "ROLLBACK", nil)
return err
}
|
[
"func",
"(",
"tx",
"*",
"SQLiteTx",
")",
"Rollback",
"(",
")",
"error",
"{",
"_",
",",
"err",
":=",
"tx",
".",
"c",
".",
"exec",
"(",
"context",
".",
"Background",
"(",
")",
",",
"\"",
"\"",
",",
"nil",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// Rollback transaction.
|
[
"Rollback",
"transaction",
"."
] |
5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3
|
https://github.com/mattn/go-sqlite3/blob/5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3/sqlite3.go#L448-L451
|
146,534 |
mattn/go-sqlite3
|
sqlite3.go
|
AutoCommit
|
func (c *SQLiteConn) AutoCommit() bool {
c.mu.Lock()
defer c.mu.Unlock()
return int(C.sqlite3_get_autocommit(c.db)) != 0
}
|
go
|
func (c *SQLiteConn) AutoCommit() bool {
c.mu.Lock()
defer c.mu.Unlock()
return int(C.sqlite3_get_autocommit(c.db)) != 0
}
|
[
"func",
"(",
"c",
"*",
"SQLiteConn",
")",
"AutoCommit",
"(",
")",
"bool",
"{",
"c",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"int",
"(",
"C",
".",
"sqlite3_get_autocommit",
"(",
"c",
".",
"db",
")",
")",
"!=",
"0",
"\n",
"}"
] |
// AutoCommit return which currently auto commit or not.
|
[
"AutoCommit",
"return",
"which",
"currently",
"auto",
"commit",
"or",
"not",
"."
] |
5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3
|
https://github.com/mattn/go-sqlite3/blob/5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3/sqlite3.go#L742-L746
|
146,535 |
mattn/go-sqlite3
|
sqlite3.go
|
Query
|
func (c *SQLiteConn) Query(query string, args []driver.Value) (driver.Rows, error) {
list := make([]namedValue, len(args))
for i, v := range args {
list[i] = namedValue{
Ordinal: i + 1,
Value: v,
}
}
return c.query(context.Background(), query, list)
}
|
go
|
func (c *SQLiteConn) Query(query string, args []driver.Value) (driver.Rows, error) {
list := make([]namedValue, len(args))
for i, v := range args {
list[i] = namedValue{
Ordinal: i + 1,
Value: v,
}
}
return c.query(context.Background(), query, list)
}
|
[
"func",
"(",
"c",
"*",
"SQLiteConn",
")",
"Query",
"(",
"query",
"string",
",",
"args",
"[",
"]",
"driver",
".",
"Value",
")",
"(",
"driver",
".",
"Rows",
",",
"error",
")",
"{",
"list",
":=",
"make",
"(",
"[",
"]",
"namedValue",
",",
"len",
"(",
"args",
")",
")",
"\n",
"for",
"i",
",",
"v",
":=",
"range",
"args",
"{",
"list",
"[",
"i",
"]",
"=",
"namedValue",
"{",
"Ordinal",
":",
"i",
"+",
"1",
",",
"Value",
":",
"v",
",",
"}",
"\n",
"}",
"\n",
"return",
"c",
".",
"query",
"(",
"context",
".",
"Background",
"(",
")",
",",
"query",
",",
"list",
")",
"\n",
"}"
] |
// Query implements Queryer.
|
[
"Query",
"implements",
"Queryer",
"."
] |
5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3
|
https://github.com/mattn/go-sqlite3/blob/5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3/sqlite3.go#L817-L826
|
146,536 |
mattn/go-sqlite3
|
sqlite3.go
|
Begin
|
func (c *SQLiteConn) Begin() (driver.Tx, error) {
return c.begin(context.Background())
}
|
go
|
func (c *SQLiteConn) Begin() (driver.Tx, error) {
return c.begin(context.Background())
}
|
[
"func",
"(",
"c",
"*",
"SQLiteConn",
")",
"Begin",
"(",
")",
"(",
"driver",
".",
"Tx",
",",
"error",
")",
"{",
"return",
"c",
".",
"begin",
"(",
"context",
".",
"Background",
"(",
")",
")",
"\n",
"}"
] |
// Begin transaction.
|
[
"Begin",
"transaction",
"."
] |
5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3
|
https://github.com/mattn/go-sqlite3/blob/5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3/sqlite3.go#L861-L863
|
146,537 |
mattn/go-sqlite3
|
sqlite3.go
|
Close
|
func (c *SQLiteConn) Close() error {
rv := C.sqlite3_close_v2(c.db)
if rv != C.SQLITE_OK {
return c.lastError()
}
deleteHandles(c)
c.mu.Lock()
c.db = nil
c.mu.Unlock()
runtime.SetFinalizer(c, nil)
return nil
}
|
go
|
func (c *SQLiteConn) Close() error {
rv := C.sqlite3_close_v2(c.db)
if rv != C.SQLITE_OK {
return c.lastError()
}
deleteHandles(c)
c.mu.Lock()
c.db = nil
c.mu.Unlock()
runtime.SetFinalizer(c, nil)
return nil
}
|
[
"func",
"(",
"c",
"*",
"SQLiteConn",
")",
"Close",
"(",
")",
"error",
"{",
"rv",
":=",
"C",
".",
"sqlite3_close_v2",
"(",
"c",
".",
"db",
")",
"\n",
"if",
"rv",
"!=",
"C",
".",
"SQLITE_OK",
"{",
"return",
"c",
".",
"lastError",
"(",
")",
"\n",
"}",
"\n",
"deleteHandles",
"(",
"c",
")",
"\n",
"c",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"c",
".",
"db",
"=",
"nil",
"\n",
"c",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"runtime",
".",
"SetFinalizer",
"(",
"c",
",",
"nil",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Close the connection.
|
[
"Close",
"the",
"connection",
"."
] |
5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3
|
https://github.com/mattn/go-sqlite3/blob/5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3/sqlite3.go#L1650-L1661
|
146,538 |
mattn/go-sqlite3
|
sqlite3.go
|
Prepare
|
func (c *SQLiteConn) Prepare(query string) (driver.Stmt, error) {
return c.prepare(context.Background(), query)
}
|
go
|
func (c *SQLiteConn) Prepare(query string) (driver.Stmt, error) {
return c.prepare(context.Background(), query)
}
|
[
"func",
"(",
"c",
"*",
"SQLiteConn",
")",
"Prepare",
"(",
"query",
"string",
")",
"(",
"driver",
".",
"Stmt",
",",
"error",
")",
"{",
"return",
"c",
".",
"prepare",
"(",
"context",
".",
"Background",
"(",
")",
",",
"query",
")",
"\n",
"}"
] |
// Prepare the query string. Return a new statement.
|
[
"Prepare",
"the",
"query",
"string",
".",
"Return",
"a",
"new",
"statement",
"."
] |
5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3
|
https://github.com/mattn/go-sqlite3/blob/5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3/sqlite3.go#L1673-L1675
|
146,539 |
mattn/go-sqlite3
|
sqlite3.go
|
Close
|
func (s *SQLiteStmt) Close() error {
s.mu.Lock()
defer s.mu.Unlock()
if s.closed {
return nil
}
s.closed = true
if !s.c.dbConnOpen() {
return errors.New("sqlite statement with already closed database connection")
}
rv := C.sqlite3_finalize(s.s)
s.s = nil
if rv != C.SQLITE_OK {
return s.c.lastError()
}
runtime.SetFinalizer(s, nil)
return nil
}
|
go
|
func (s *SQLiteStmt) Close() error {
s.mu.Lock()
defer s.mu.Unlock()
if s.closed {
return nil
}
s.closed = true
if !s.c.dbConnOpen() {
return errors.New("sqlite statement with already closed database connection")
}
rv := C.sqlite3_finalize(s.s)
s.s = nil
if rv != C.SQLITE_OK {
return s.c.lastError()
}
runtime.SetFinalizer(s, nil)
return nil
}
|
[
"func",
"(",
"s",
"*",
"SQLiteStmt",
")",
"Close",
"(",
")",
"error",
"{",
"s",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"s",
".",
"closed",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"s",
".",
"closed",
"=",
"true",
"\n",
"if",
"!",
"s",
".",
"c",
".",
"dbConnOpen",
"(",
")",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"rv",
":=",
"C",
".",
"sqlite3_finalize",
"(",
"s",
".",
"s",
")",
"\n",
"s",
".",
"s",
"=",
"nil",
"\n",
"if",
"rv",
"!=",
"C",
".",
"SQLITE_OK",
"{",
"return",
"s",
".",
"c",
".",
"lastError",
"(",
")",
"\n",
"}",
"\n",
"runtime",
".",
"SetFinalizer",
"(",
"s",
",",
"nil",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Close the statement.
|
[
"Close",
"the",
"statement",
"."
] |
5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3
|
https://github.com/mattn/go-sqlite3/blob/5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3/sqlite3.go#L1737-L1754
|
146,540 |
mattn/go-sqlite3
|
sqlite3.go
|
Query
|
func (s *SQLiteStmt) Query(args []driver.Value) (driver.Rows, error) {
list := make([]namedValue, len(args))
for i, v := range args {
list[i] = namedValue{
Ordinal: i + 1,
Value: v,
}
}
return s.query(context.Background(), list)
}
|
go
|
func (s *SQLiteStmt) Query(args []driver.Value) (driver.Rows, error) {
list := make([]namedValue, len(args))
for i, v := range args {
list[i] = namedValue{
Ordinal: i + 1,
Value: v,
}
}
return s.query(context.Background(), list)
}
|
[
"func",
"(",
"s",
"*",
"SQLiteStmt",
")",
"Query",
"(",
"args",
"[",
"]",
"driver",
".",
"Value",
")",
"(",
"driver",
".",
"Rows",
",",
"error",
")",
"{",
"list",
":=",
"make",
"(",
"[",
"]",
"namedValue",
",",
"len",
"(",
"args",
")",
")",
"\n",
"for",
"i",
",",
"v",
":=",
"range",
"args",
"{",
"list",
"[",
"i",
"]",
"=",
"namedValue",
"{",
"Ordinal",
":",
"i",
"+",
"1",
",",
"Value",
":",
"v",
",",
"}",
"\n",
"}",
"\n",
"return",
"s",
".",
"query",
"(",
"context",
".",
"Background",
"(",
")",
",",
"list",
")",
"\n",
"}"
] |
// Query the statement with arguments. Return records.
|
[
"Query",
"the",
"statement",
"with",
"arguments",
".",
"Return",
"records",
"."
] |
5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3
|
https://github.com/mattn/go-sqlite3/blob/5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3/sqlite3.go#L1826-L1835
|
146,541 |
mattn/go-sqlite3
|
sqlite3.go
|
Exec
|
func (s *SQLiteStmt) Exec(args []driver.Value) (driver.Result, error) {
list := make([]namedValue, len(args))
for i, v := range args {
list[i] = namedValue{
Ordinal: i + 1,
Value: v,
}
}
return s.exec(context.Background(), list)
}
|
go
|
func (s *SQLiteStmt) Exec(args []driver.Value) (driver.Result, error) {
list := make([]namedValue, len(args))
for i, v := range args {
list[i] = namedValue{
Ordinal: i + 1,
Value: v,
}
}
return s.exec(context.Background(), list)
}
|
[
"func",
"(",
"s",
"*",
"SQLiteStmt",
")",
"Exec",
"(",
"args",
"[",
"]",
"driver",
".",
"Value",
")",
"(",
"driver",
".",
"Result",
",",
"error",
")",
"{",
"list",
":=",
"make",
"(",
"[",
"]",
"namedValue",
",",
"len",
"(",
"args",
")",
")",
"\n",
"for",
"i",
",",
"v",
":=",
"range",
"args",
"{",
"list",
"[",
"i",
"]",
"=",
"namedValue",
"{",
"Ordinal",
":",
"i",
"+",
"1",
",",
"Value",
":",
"v",
",",
"}",
"\n",
"}",
"\n",
"return",
"s",
".",
"exec",
"(",
"context",
".",
"Background",
"(",
")",
",",
"list",
")",
"\n",
"}"
] |
// Exec execute the statement with arguments. Return result object.
|
[
"Exec",
"execute",
"the",
"statement",
"with",
"arguments",
".",
"Return",
"result",
"object",
"."
] |
5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3
|
https://github.com/mattn/go-sqlite3/blob/5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3/sqlite3.go#L1881-L1890
|
146,542 |
mattn/go-sqlite3
|
sqlite3.go
|
Close
|
func (rc *SQLiteRows) Close() error {
rc.s.mu.Lock()
if rc.s.closed || rc.closed {
rc.s.mu.Unlock()
return nil
}
rc.closed = true
if rc.done != nil {
close(rc.done)
}
if rc.cls {
rc.s.mu.Unlock()
return rc.s.Close()
}
rv := C.sqlite3_reset(rc.s.s)
if rv != C.SQLITE_OK {
rc.s.mu.Unlock()
return rc.s.c.lastError()
}
rc.s.mu.Unlock()
return nil
}
|
go
|
func (rc *SQLiteRows) Close() error {
rc.s.mu.Lock()
if rc.s.closed || rc.closed {
rc.s.mu.Unlock()
return nil
}
rc.closed = true
if rc.done != nil {
close(rc.done)
}
if rc.cls {
rc.s.mu.Unlock()
return rc.s.Close()
}
rv := C.sqlite3_reset(rc.s.s)
if rv != C.SQLITE_OK {
rc.s.mu.Unlock()
return rc.s.c.lastError()
}
rc.s.mu.Unlock()
return nil
}
|
[
"func",
"(",
"rc",
"*",
"SQLiteRows",
")",
"Close",
"(",
")",
"error",
"{",
"rc",
".",
"s",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"if",
"rc",
".",
"s",
".",
"closed",
"||",
"rc",
".",
"closed",
"{",
"rc",
".",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"rc",
".",
"closed",
"=",
"true",
"\n",
"if",
"rc",
".",
"done",
"!=",
"nil",
"{",
"close",
"(",
"rc",
".",
"done",
")",
"\n",
"}",
"\n",
"if",
"rc",
".",
"cls",
"{",
"rc",
".",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"rc",
".",
"s",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"rv",
":=",
"C",
".",
"sqlite3_reset",
"(",
"rc",
".",
"s",
".",
"s",
")",
"\n",
"if",
"rv",
"!=",
"C",
".",
"SQLITE_OK",
"{",
"rc",
".",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"rc",
".",
"s",
".",
"c",
".",
"lastError",
"(",
")",
"\n",
"}",
"\n",
"rc",
".",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Close the rows.
|
[
"Close",
"the",
"rows",
"."
] |
5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3
|
https://github.com/mattn/go-sqlite3/blob/5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3/sqlite3.go#L1928-L1949
|
146,543 |
mattn/go-sqlite3
|
sqlite3.go
|
Columns
|
func (rc *SQLiteRows) Columns() []string {
rc.s.mu.Lock()
defer rc.s.mu.Unlock()
if rc.s.s != nil && rc.nc != len(rc.cols) {
rc.cols = make([]string, rc.nc)
for i := 0; i < rc.nc; i++ {
rc.cols[i] = C.GoString(C.sqlite3_column_name(rc.s.s, C.int(i)))
}
}
return rc.cols
}
|
go
|
func (rc *SQLiteRows) Columns() []string {
rc.s.mu.Lock()
defer rc.s.mu.Unlock()
if rc.s.s != nil && rc.nc != len(rc.cols) {
rc.cols = make([]string, rc.nc)
for i := 0; i < rc.nc; i++ {
rc.cols[i] = C.GoString(C.sqlite3_column_name(rc.s.s, C.int(i)))
}
}
return rc.cols
}
|
[
"func",
"(",
"rc",
"*",
"SQLiteRows",
")",
"Columns",
"(",
")",
"[",
"]",
"string",
"{",
"rc",
".",
"s",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"rc",
".",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"rc",
".",
"s",
".",
"s",
"!=",
"nil",
"&&",
"rc",
".",
"nc",
"!=",
"len",
"(",
"rc",
".",
"cols",
")",
"{",
"rc",
".",
"cols",
"=",
"make",
"(",
"[",
"]",
"string",
",",
"rc",
".",
"nc",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"rc",
".",
"nc",
";",
"i",
"++",
"{",
"rc",
".",
"cols",
"[",
"i",
"]",
"=",
"C",
".",
"GoString",
"(",
"C",
".",
"sqlite3_column_name",
"(",
"rc",
".",
"s",
".",
"s",
",",
"C",
".",
"int",
"(",
"i",
")",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"rc",
".",
"cols",
"\n",
"}"
] |
// Columns return column names.
|
[
"Columns",
"return",
"column",
"names",
"."
] |
5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3
|
https://github.com/mattn/go-sqlite3/blob/5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3/sqlite3.go#L1952-L1962
|
146,544 |
mattn/go-sqlite3
|
sqlite3.go
|
DeclTypes
|
func (rc *SQLiteRows) DeclTypes() []string {
rc.s.mu.Lock()
defer rc.s.mu.Unlock()
return rc.declTypes()
}
|
go
|
func (rc *SQLiteRows) DeclTypes() []string {
rc.s.mu.Lock()
defer rc.s.mu.Unlock()
return rc.declTypes()
}
|
[
"func",
"(",
"rc",
"*",
"SQLiteRows",
")",
"DeclTypes",
"(",
")",
"[",
"]",
"string",
"{",
"rc",
".",
"s",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"rc",
".",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"return",
"rc",
".",
"declTypes",
"(",
")",
"\n",
"}"
] |
// DeclTypes return column types.
|
[
"DeclTypes",
"return",
"column",
"types",
"."
] |
5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3
|
https://github.com/mattn/go-sqlite3/blob/5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3/sqlite3.go#L1975-L1979
|
146,545 |
mattn/go-sqlite3
|
sqlite3_func_crypt.go
|
CryptEncoderSSHA1
|
func CryptEncoderSSHA1(salt string) func(pass []byte, hash interface{}) []byte {
return func(pass []byte, hash interface{}) []byte {
s := []byte(salt)
p := append(pass, s...)
h := sha1.Sum(p)
return h[:]
}
}
|
go
|
func CryptEncoderSSHA1(salt string) func(pass []byte, hash interface{}) []byte {
return func(pass []byte, hash interface{}) []byte {
s := []byte(salt)
p := append(pass, s...)
h := sha1.Sum(p)
return h[:]
}
}
|
[
"func",
"CryptEncoderSSHA1",
"(",
"salt",
"string",
")",
"func",
"(",
"pass",
"[",
"]",
"byte",
",",
"hash",
"interface",
"{",
"}",
")",
"[",
"]",
"byte",
"{",
"return",
"func",
"(",
"pass",
"[",
"]",
"byte",
",",
"hash",
"interface",
"{",
"}",
")",
"[",
"]",
"byte",
"{",
"s",
":=",
"[",
"]",
"byte",
"(",
"salt",
")",
"\n",
"p",
":=",
"append",
"(",
"pass",
",",
"s",
"...",
")",
"\n",
"h",
":=",
"sha1",
".",
"Sum",
"(",
"p",
")",
"\n",
"return",
"h",
"[",
":",
"]",
"\n",
"}",
"\n",
"}"
] |
// CryptEncoderSSHA1 encodes a password with SHA1 with the
// configured salt.
|
[
"CryptEncoderSSHA1",
"encodes",
"a",
"password",
"with",
"SHA1",
"with",
"the",
"configured",
"salt",
"."
] |
5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3
|
https://github.com/mattn/go-sqlite3/blob/5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3/sqlite3_func_crypt.go#L60-L67
|
146,546 |
mattn/go-sqlite3
|
sqlite3_func_crypt.go
|
CryptEncoderSHA256
|
func CryptEncoderSHA256(pass []byte, hash interface{}) []byte {
h := sha256.Sum256(pass)
return h[:]
}
|
go
|
func CryptEncoderSHA256(pass []byte, hash interface{}) []byte {
h := sha256.Sum256(pass)
return h[:]
}
|
[
"func",
"CryptEncoderSHA256",
"(",
"pass",
"[",
"]",
"byte",
",",
"hash",
"interface",
"{",
"}",
")",
"[",
"]",
"byte",
"{",
"h",
":=",
"sha256",
".",
"Sum256",
"(",
"pass",
")",
"\n",
"return",
"h",
"[",
":",
"]",
"\n",
"}"
] |
// CryptEncoderSHA256 encodes a password with SHA256
|
[
"CryptEncoderSHA256",
"encodes",
"a",
"password",
"with",
"SHA256"
] |
5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3
|
https://github.com/mattn/go-sqlite3/blob/5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3/sqlite3_func_crypt.go#L70-L73
|
146,547 |
mattn/go-sqlite3
|
sqlite3_func_crypt.go
|
CryptEncoderSSHA256
|
func CryptEncoderSSHA256(salt string) func(pass []byte, hash interface{}) []byte {
return func(pass []byte, hash interface{}) []byte {
s := []byte(salt)
p := append(pass, s...)
h := sha256.Sum256(p)
return h[:]
}
}
|
go
|
func CryptEncoderSSHA256(salt string) func(pass []byte, hash interface{}) []byte {
return func(pass []byte, hash interface{}) []byte {
s := []byte(salt)
p := append(pass, s...)
h := sha256.Sum256(p)
return h[:]
}
}
|
[
"func",
"CryptEncoderSSHA256",
"(",
"salt",
"string",
")",
"func",
"(",
"pass",
"[",
"]",
"byte",
",",
"hash",
"interface",
"{",
"}",
")",
"[",
"]",
"byte",
"{",
"return",
"func",
"(",
"pass",
"[",
"]",
"byte",
",",
"hash",
"interface",
"{",
"}",
")",
"[",
"]",
"byte",
"{",
"s",
":=",
"[",
"]",
"byte",
"(",
"salt",
")",
"\n",
"p",
":=",
"append",
"(",
"pass",
",",
"s",
"...",
")",
"\n",
"h",
":=",
"sha256",
".",
"Sum256",
"(",
"p",
")",
"\n",
"return",
"h",
"[",
":",
"]",
"\n",
"}",
"\n",
"}"
] |
// CryptEncoderSSHA256 encodes a password with SHA256
// with the configured salt
|
[
"CryptEncoderSSHA256",
"encodes",
"a",
"password",
"with",
"SHA256",
"with",
"the",
"configured",
"salt"
] |
5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3
|
https://github.com/mattn/go-sqlite3/blob/5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3/sqlite3_func_crypt.go#L77-L84
|
146,548 |
mattn/go-sqlite3
|
sqlite3_func_crypt.go
|
CryptEncoderSHA384
|
func CryptEncoderSHA384(pass []byte, hash interface{}) []byte {
h := sha512.Sum384(pass)
return h[:]
}
|
go
|
func CryptEncoderSHA384(pass []byte, hash interface{}) []byte {
h := sha512.Sum384(pass)
return h[:]
}
|
[
"func",
"CryptEncoderSHA384",
"(",
"pass",
"[",
"]",
"byte",
",",
"hash",
"interface",
"{",
"}",
")",
"[",
"]",
"byte",
"{",
"h",
":=",
"sha512",
".",
"Sum384",
"(",
"pass",
")",
"\n",
"return",
"h",
"[",
":",
"]",
"\n",
"}"
] |
// CryptEncoderSHA384 encodes a password with SHA384
|
[
"CryptEncoderSHA384",
"encodes",
"a",
"password",
"with",
"SHA384"
] |
5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3
|
https://github.com/mattn/go-sqlite3/blob/5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3/sqlite3_func_crypt.go#L87-L90
|
146,549 |
mattn/go-sqlite3
|
sqlite3_func_crypt.go
|
CryptEncoderSSHA384
|
func CryptEncoderSSHA384(salt string) func(pass []byte, hash interface{}) []byte {
return func(pass []byte, hash interface{}) []byte {
s := []byte(salt)
p := append(pass, s...)
h := sha512.Sum384(p)
return h[:]
}
}
|
go
|
func CryptEncoderSSHA384(salt string) func(pass []byte, hash interface{}) []byte {
return func(pass []byte, hash interface{}) []byte {
s := []byte(salt)
p := append(pass, s...)
h := sha512.Sum384(p)
return h[:]
}
}
|
[
"func",
"CryptEncoderSSHA384",
"(",
"salt",
"string",
")",
"func",
"(",
"pass",
"[",
"]",
"byte",
",",
"hash",
"interface",
"{",
"}",
")",
"[",
"]",
"byte",
"{",
"return",
"func",
"(",
"pass",
"[",
"]",
"byte",
",",
"hash",
"interface",
"{",
"}",
")",
"[",
"]",
"byte",
"{",
"s",
":=",
"[",
"]",
"byte",
"(",
"salt",
")",
"\n",
"p",
":=",
"append",
"(",
"pass",
",",
"s",
"...",
")",
"\n",
"h",
":=",
"sha512",
".",
"Sum384",
"(",
"p",
")",
"\n",
"return",
"h",
"[",
":",
"]",
"\n",
"}",
"\n",
"}"
] |
// CryptEncoderSSHA384 encodes a password with SHA384
// with the configured salt
|
[
"CryptEncoderSSHA384",
"encodes",
"a",
"password",
"with",
"SHA384",
"with",
"the",
"configured",
"salt"
] |
5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3
|
https://github.com/mattn/go-sqlite3/blob/5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3/sqlite3_func_crypt.go#L94-L101
|
146,550 |
mattn/go-sqlite3
|
sqlite3_func_crypt.go
|
CryptEncoderSHA512
|
func CryptEncoderSHA512(pass []byte, hash interface{}) []byte {
h := sha512.Sum512(pass)
return h[:]
}
|
go
|
func CryptEncoderSHA512(pass []byte, hash interface{}) []byte {
h := sha512.Sum512(pass)
return h[:]
}
|
[
"func",
"CryptEncoderSHA512",
"(",
"pass",
"[",
"]",
"byte",
",",
"hash",
"interface",
"{",
"}",
")",
"[",
"]",
"byte",
"{",
"h",
":=",
"sha512",
".",
"Sum512",
"(",
"pass",
")",
"\n",
"return",
"h",
"[",
":",
"]",
"\n",
"}"
] |
// CryptEncoderSHA512 encodes a password with SHA512
|
[
"CryptEncoderSHA512",
"encodes",
"a",
"password",
"with",
"SHA512"
] |
5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3
|
https://github.com/mattn/go-sqlite3/blob/5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3/sqlite3_func_crypt.go#L104-L107
|
146,551 |
mattn/go-sqlite3
|
sqlite3_func_crypt.go
|
CryptEncoderSSHA512
|
func CryptEncoderSSHA512(salt string) func(pass []byte, hash interface{}) []byte {
return func(pass []byte, hash interface{}) []byte {
s := []byte(salt)
p := append(pass, s...)
h := sha512.Sum512(p)
return h[:]
}
}
|
go
|
func CryptEncoderSSHA512(salt string) func(pass []byte, hash interface{}) []byte {
return func(pass []byte, hash interface{}) []byte {
s := []byte(salt)
p := append(pass, s...)
h := sha512.Sum512(p)
return h[:]
}
}
|
[
"func",
"CryptEncoderSSHA512",
"(",
"salt",
"string",
")",
"func",
"(",
"pass",
"[",
"]",
"byte",
",",
"hash",
"interface",
"{",
"}",
")",
"[",
"]",
"byte",
"{",
"return",
"func",
"(",
"pass",
"[",
"]",
"byte",
",",
"hash",
"interface",
"{",
"}",
")",
"[",
"]",
"byte",
"{",
"s",
":=",
"[",
"]",
"byte",
"(",
"salt",
")",
"\n",
"p",
":=",
"append",
"(",
"pass",
",",
"s",
"...",
")",
"\n",
"h",
":=",
"sha512",
".",
"Sum512",
"(",
"p",
")",
"\n",
"return",
"h",
"[",
":",
"]",
"\n",
"}",
"\n",
"}"
] |
// CryptEncoderSSHA512 encodes a password with SHA512
// with the configured salt
|
[
"CryptEncoderSSHA512",
"encodes",
"a",
"password",
"with",
"SHA512",
"with",
"the",
"configured",
"salt"
] |
5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3
|
https://github.com/mattn/go-sqlite3/blob/5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3/sqlite3_func_crypt.go#L111-L118
|
146,552 |
mattn/go-sqlite3
|
sqlite3_go18.go
|
Ping
|
func (c *SQLiteConn) Ping(ctx context.Context) error {
if c.db == nil {
return errors.New("Connection was closed")
}
return nil
}
|
go
|
func (c *SQLiteConn) Ping(ctx context.Context) error {
if c.db == nil {
return errors.New("Connection was closed")
}
return nil
}
|
[
"func",
"(",
"c",
"*",
"SQLiteConn",
")",
"Ping",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"if",
"c",
".",
"db",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Ping implement Pinger.
|
[
"Ping",
"implement",
"Pinger",
"."
] |
5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3
|
https://github.com/mattn/go-sqlite3/blob/5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3/sqlite3_go18.go#L19-L24
|
146,553 |
mattn/go-sqlite3
|
sqlite3_go18.go
|
PrepareContext
|
func (c *SQLiteConn) PrepareContext(ctx context.Context, query string) (driver.Stmt, error) {
return c.prepare(ctx, query)
}
|
go
|
func (c *SQLiteConn) PrepareContext(ctx context.Context, query string) (driver.Stmt, error) {
return c.prepare(ctx, query)
}
|
[
"func",
"(",
"c",
"*",
"SQLiteConn",
")",
"PrepareContext",
"(",
"ctx",
"context",
".",
"Context",
",",
"query",
"string",
")",
"(",
"driver",
".",
"Stmt",
",",
"error",
")",
"{",
"return",
"c",
".",
"prepare",
"(",
"ctx",
",",
"query",
")",
"\n",
"}"
] |
// PrepareContext implement ConnPrepareContext.
|
[
"PrepareContext",
"implement",
"ConnPrepareContext",
"."
] |
5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3
|
https://github.com/mattn/go-sqlite3/blob/5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3/sqlite3_go18.go#L45-L47
|
146,554 |
mattn/go-sqlite3
|
sqlite3_go18.go
|
BeginTx
|
func (c *SQLiteConn) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, error) {
return c.begin(ctx)
}
|
go
|
func (c *SQLiteConn) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, error) {
return c.begin(ctx)
}
|
[
"func",
"(",
"c",
"*",
"SQLiteConn",
")",
"BeginTx",
"(",
"ctx",
"context",
".",
"Context",
",",
"opts",
"driver",
".",
"TxOptions",
")",
"(",
"driver",
".",
"Tx",
",",
"error",
")",
"{",
"return",
"c",
".",
"begin",
"(",
"ctx",
")",
"\n",
"}"
] |
// BeginTx implement ConnBeginTx.
|
[
"BeginTx",
"implement",
"ConnBeginTx",
"."
] |
5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3
|
https://github.com/mattn/go-sqlite3/blob/5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3/sqlite3_go18.go#L50-L52
|
146,555 |
mattn/go-sqlite3
|
sqlite3_load_extension.go
|
LoadExtension
|
func (c *SQLiteConn) LoadExtension(lib string, entry string) error {
rv := C.sqlite3_enable_load_extension(c.db, 1)
if rv != C.SQLITE_OK {
return errors.New(C.GoString(C.sqlite3_errmsg(c.db)))
}
clib := C.CString(lib)
defer C.free(unsafe.Pointer(clib))
centry := C.CString(entry)
defer C.free(unsafe.Pointer(centry))
rv = C.sqlite3_load_extension(c.db, clib, centry, nil)
if rv != C.SQLITE_OK {
return errors.New(C.GoString(C.sqlite3_errmsg(c.db)))
}
rv = C.sqlite3_enable_load_extension(c.db, 0)
if rv != C.SQLITE_OK {
return errors.New(C.GoString(C.sqlite3_errmsg(c.db)))
}
return nil
}
|
go
|
func (c *SQLiteConn) LoadExtension(lib string, entry string) error {
rv := C.sqlite3_enable_load_extension(c.db, 1)
if rv != C.SQLITE_OK {
return errors.New(C.GoString(C.sqlite3_errmsg(c.db)))
}
clib := C.CString(lib)
defer C.free(unsafe.Pointer(clib))
centry := C.CString(entry)
defer C.free(unsafe.Pointer(centry))
rv = C.sqlite3_load_extension(c.db, clib, centry, nil)
if rv != C.SQLITE_OK {
return errors.New(C.GoString(C.sqlite3_errmsg(c.db)))
}
rv = C.sqlite3_enable_load_extension(c.db, 0)
if rv != C.SQLITE_OK {
return errors.New(C.GoString(C.sqlite3_errmsg(c.db)))
}
return nil
}
|
[
"func",
"(",
"c",
"*",
"SQLiteConn",
")",
"LoadExtension",
"(",
"lib",
"string",
",",
"entry",
"string",
")",
"error",
"{",
"rv",
":=",
"C",
".",
"sqlite3_enable_load_extension",
"(",
"c",
".",
"db",
",",
"1",
")",
"\n",
"if",
"rv",
"!=",
"C",
".",
"SQLITE_OK",
"{",
"return",
"errors",
".",
"New",
"(",
"C",
".",
"GoString",
"(",
"C",
".",
"sqlite3_errmsg",
"(",
"c",
".",
"db",
")",
")",
")",
"\n",
"}",
"\n\n",
"clib",
":=",
"C",
".",
"CString",
"(",
"lib",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"clib",
")",
")",
"\n",
"centry",
":=",
"C",
".",
"CString",
"(",
"entry",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"centry",
")",
")",
"\n\n",
"rv",
"=",
"C",
".",
"sqlite3_load_extension",
"(",
"c",
".",
"db",
",",
"clib",
",",
"centry",
",",
"nil",
")",
"\n",
"if",
"rv",
"!=",
"C",
".",
"SQLITE_OK",
"{",
"return",
"errors",
".",
"New",
"(",
"C",
".",
"GoString",
"(",
"C",
".",
"sqlite3_errmsg",
"(",
"c",
".",
"db",
")",
")",
")",
"\n",
"}",
"\n\n",
"rv",
"=",
"C",
".",
"sqlite3_enable_load_extension",
"(",
"c",
".",
"db",
",",
"0",
")",
"\n",
"if",
"rv",
"!=",
"C",
".",
"SQLITE_OK",
"{",
"return",
"errors",
".",
"New",
"(",
"C",
".",
"GoString",
"(",
"C",
".",
"sqlite3_errmsg",
"(",
"c",
".",
"db",
")",
")",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// LoadExtension load the sqlite3 extension.
|
[
"LoadExtension",
"load",
"the",
"sqlite3",
"extension",
"."
] |
5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3
|
https://github.com/mattn/go-sqlite3/blob/5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3/sqlite3_load_extension.go#L48-L70
|
146,556 |
mattn/go-sqlite3
|
sqlite3_opt_userauth.go
|
AuthEnabled
|
func (c *SQLiteConn) AuthEnabled() (exists bool) {
rv := c.authEnabled()
if rv == 1 {
exists = true
}
return
}
|
go
|
func (c *SQLiteConn) AuthEnabled() (exists bool) {
rv := c.authEnabled()
if rv == 1 {
exists = true
}
return
}
|
[
"func",
"(",
"c",
"*",
"SQLiteConn",
")",
"AuthEnabled",
"(",
")",
"(",
"exists",
"bool",
")",
"{",
"rv",
":=",
"c",
".",
"authEnabled",
"(",
")",
"\n",
"if",
"rv",
"==",
"1",
"{",
"exists",
"=",
"true",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// AuthEnabled checks if the database is protected by user authentication
|
[
"AuthEnabled",
"checks",
"if",
"the",
"database",
"is",
"protected",
"by",
"user",
"authentication"
] |
5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3
|
https://github.com/mattn/go-sqlite3/blob/5994cc52dfa89a4ee21ac891b06fbc1ea02c52d3/sqlite3_opt_userauth.go#L268-L275
|
146,557 |
gliderlabs/registrator
|
consul/consul.go
|
Ping
|
func (r *ConsulAdapter) Ping() error {
status := r.client.Status()
leader, err := status.Leader()
if err != nil {
return err
}
log.Println("consul: current leader ", leader)
return nil
}
|
go
|
func (r *ConsulAdapter) Ping() error {
status := r.client.Status()
leader, err := status.Leader()
if err != nil {
return err
}
log.Println("consul: current leader ", leader)
return nil
}
|
[
"func",
"(",
"r",
"*",
"ConsulAdapter",
")",
"Ping",
"(",
")",
"error",
"{",
"status",
":=",
"r",
".",
"client",
".",
"Status",
"(",
")",
"\n",
"leader",
",",
"err",
":=",
"status",
".",
"Leader",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"log",
".",
"Println",
"(",
"\"",
"\"",
",",
"leader",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Ping will try to connect to consul by attempting to retrieve the current leader.
|
[
"Ping",
"will",
"try",
"to",
"connect",
"to",
"consul",
"by",
"attempting",
"to",
"retrieve",
"the",
"current",
"leader",
"."
] |
da90d170da9dd7e1a8d9a13429d44686dc3d118f
|
https://github.com/gliderlabs/registrator/blob/da90d170da9dd7e1a8d9a13429d44686dc3d118f/consul/consul.go#L69-L78
|
146,558 |
orcaman/concurrent-map
|
concurrent_map.go
|
New
|
func New() ConcurrentMap {
m := make(ConcurrentMap, SHARD_COUNT)
for i := 0; i < SHARD_COUNT; i++ {
m[i] = &ConcurrentMapShared{items: make(map[string]interface{})}
}
return m
}
|
go
|
func New() ConcurrentMap {
m := make(ConcurrentMap, SHARD_COUNT)
for i := 0; i < SHARD_COUNT; i++ {
m[i] = &ConcurrentMapShared{items: make(map[string]interface{})}
}
return m
}
|
[
"func",
"New",
"(",
")",
"ConcurrentMap",
"{",
"m",
":=",
"make",
"(",
"ConcurrentMap",
",",
"SHARD_COUNT",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"SHARD_COUNT",
";",
"i",
"++",
"{",
"m",
"[",
"i",
"]",
"=",
"&",
"ConcurrentMapShared",
"{",
"items",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"}",
"\n",
"}",
"\n",
"return",
"m",
"\n",
"}"
] |
// Creates a new concurrent map.
|
[
"Creates",
"a",
"new",
"concurrent",
"map",
"."
] |
2693aad1ed7517c2bb5b3a42cb8fde88b941d89d
|
https://github.com/orcaman/concurrent-map/blob/2693aad1ed7517c2bb5b3a42cb8fde88b941d89d/concurrent_map.go#L21-L27
|
146,559 |
orcaman/concurrent-map
|
concurrent_map.go
|
GetShard
|
func (m ConcurrentMap) GetShard(key string) *ConcurrentMapShared {
return m[uint(fnv32(key))%uint(SHARD_COUNT)]
}
|
go
|
func (m ConcurrentMap) GetShard(key string) *ConcurrentMapShared {
return m[uint(fnv32(key))%uint(SHARD_COUNT)]
}
|
[
"func",
"(",
"m",
"ConcurrentMap",
")",
"GetShard",
"(",
"key",
"string",
")",
"*",
"ConcurrentMapShared",
"{",
"return",
"m",
"[",
"uint",
"(",
"fnv32",
"(",
"key",
")",
")",
"%",
"uint",
"(",
"SHARD_COUNT",
")",
"]",
"\n",
"}"
] |
// GetShard returns shard under given key
|
[
"GetShard",
"returns",
"shard",
"under",
"given",
"key"
] |
2693aad1ed7517c2bb5b3a42cb8fde88b941d89d
|
https://github.com/orcaman/concurrent-map/blob/2693aad1ed7517c2bb5b3a42cb8fde88b941d89d/concurrent_map.go#L30-L32
|
146,560 |
orcaman/concurrent-map
|
concurrent_map.go
|
Set
|
func (m ConcurrentMap) Set(key string, value interface{}) {
// Get map shard.
shard := m.GetShard(key)
shard.Lock()
shard.items[key] = value
shard.Unlock()
}
|
go
|
func (m ConcurrentMap) Set(key string, value interface{}) {
// Get map shard.
shard := m.GetShard(key)
shard.Lock()
shard.items[key] = value
shard.Unlock()
}
|
[
"func",
"(",
"m",
"ConcurrentMap",
")",
"Set",
"(",
"key",
"string",
",",
"value",
"interface",
"{",
"}",
")",
"{",
"// Get map shard.",
"shard",
":=",
"m",
".",
"GetShard",
"(",
"key",
")",
"\n",
"shard",
".",
"Lock",
"(",
")",
"\n",
"shard",
".",
"items",
"[",
"key",
"]",
"=",
"value",
"\n",
"shard",
".",
"Unlock",
"(",
")",
"\n",
"}"
] |
// Sets the given value under the specified key.
|
[
"Sets",
"the",
"given",
"value",
"under",
"the",
"specified",
"key",
"."
] |
2693aad1ed7517c2bb5b3a42cb8fde88b941d89d
|
https://github.com/orcaman/concurrent-map/blob/2693aad1ed7517c2bb5b3a42cb8fde88b941d89d/concurrent_map.go#L44-L50
|
146,561 |
orcaman/concurrent-map
|
concurrent_map.go
|
Upsert
|
func (m ConcurrentMap) Upsert(key string, value interface{}, cb UpsertCb) (res interface{}) {
shard := m.GetShard(key)
shard.Lock()
v, ok := shard.items[key]
res = cb(ok, v, value)
shard.items[key] = res
shard.Unlock()
return res
}
|
go
|
func (m ConcurrentMap) Upsert(key string, value interface{}, cb UpsertCb) (res interface{}) {
shard := m.GetShard(key)
shard.Lock()
v, ok := shard.items[key]
res = cb(ok, v, value)
shard.items[key] = res
shard.Unlock()
return res
}
|
[
"func",
"(",
"m",
"ConcurrentMap",
")",
"Upsert",
"(",
"key",
"string",
",",
"value",
"interface",
"{",
"}",
",",
"cb",
"UpsertCb",
")",
"(",
"res",
"interface",
"{",
"}",
")",
"{",
"shard",
":=",
"m",
".",
"GetShard",
"(",
"key",
")",
"\n",
"shard",
".",
"Lock",
"(",
")",
"\n",
"v",
",",
"ok",
":=",
"shard",
".",
"items",
"[",
"key",
"]",
"\n",
"res",
"=",
"cb",
"(",
"ok",
",",
"v",
",",
"value",
")",
"\n",
"shard",
".",
"items",
"[",
"key",
"]",
"=",
"res",
"\n",
"shard",
".",
"Unlock",
"(",
")",
"\n",
"return",
"res",
"\n",
"}"
] |
// Insert or Update - updates existing element or inserts a new one using UpsertCb
|
[
"Insert",
"or",
"Update",
"-",
"updates",
"existing",
"element",
"or",
"inserts",
"a",
"new",
"one",
"using",
"UpsertCb"
] |
2693aad1ed7517c2bb5b3a42cb8fde88b941d89d
|
https://github.com/orcaman/concurrent-map/blob/2693aad1ed7517c2bb5b3a42cb8fde88b941d89d/concurrent_map.go#L59-L67
|
146,562 |
orcaman/concurrent-map
|
concurrent_map.go
|
SetIfAbsent
|
func (m ConcurrentMap) SetIfAbsent(key string, value interface{}) bool {
// Get map shard.
shard := m.GetShard(key)
shard.Lock()
_, ok := shard.items[key]
if !ok {
shard.items[key] = value
}
shard.Unlock()
return !ok
}
|
go
|
func (m ConcurrentMap) SetIfAbsent(key string, value interface{}) bool {
// Get map shard.
shard := m.GetShard(key)
shard.Lock()
_, ok := shard.items[key]
if !ok {
shard.items[key] = value
}
shard.Unlock()
return !ok
}
|
[
"func",
"(",
"m",
"ConcurrentMap",
")",
"SetIfAbsent",
"(",
"key",
"string",
",",
"value",
"interface",
"{",
"}",
")",
"bool",
"{",
"// Get map shard.",
"shard",
":=",
"m",
".",
"GetShard",
"(",
"key",
")",
"\n",
"shard",
".",
"Lock",
"(",
")",
"\n",
"_",
",",
"ok",
":=",
"shard",
".",
"items",
"[",
"key",
"]",
"\n",
"if",
"!",
"ok",
"{",
"shard",
".",
"items",
"[",
"key",
"]",
"=",
"value",
"\n",
"}",
"\n",
"shard",
".",
"Unlock",
"(",
")",
"\n",
"return",
"!",
"ok",
"\n",
"}"
] |
// Sets the given value under the specified key if no value was associated with it.
|
[
"Sets",
"the",
"given",
"value",
"under",
"the",
"specified",
"key",
"if",
"no",
"value",
"was",
"associated",
"with",
"it",
"."
] |
2693aad1ed7517c2bb5b3a42cb8fde88b941d89d
|
https://github.com/orcaman/concurrent-map/blob/2693aad1ed7517c2bb5b3a42cb8fde88b941d89d/concurrent_map.go#L70-L80
|
146,563 |
orcaman/concurrent-map
|
concurrent_map.go
|
Get
|
func (m ConcurrentMap) Get(key string) (interface{}, bool) {
// Get shard
shard := m.GetShard(key)
shard.RLock()
// Get item from shard.
val, ok := shard.items[key]
shard.RUnlock()
return val, ok
}
|
go
|
func (m ConcurrentMap) Get(key string) (interface{}, bool) {
// Get shard
shard := m.GetShard(key)
shard.RLock()
// Get item from shard.
val, ok := shard.items[key]
shard.RUnlock()
return val, ok
}
|
[
"func",
"(",
"m",
"ConcurrentMap",
")",
"Get",
"(",
"key",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"bool",
")",
"{",
"// Get shard",
"shard",
":=",
"m",
".",
"GetShard",
"(",
"key",
")",
"\n",
"shard",
".",
"RLock",
"(",
")",
"\n",
"// Get item from shard.",
"val",
",",
"ok",
":=",
"shard",
".",
"items",
"[",
"key",
"]",
"\n",
"shard",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"val",
",",
"ok",
"\n",
"}"
] |
// Get retrieves an element from map under given key.
|
[
"Get",
"retrieves",
"an",
"element",
"from",
"map",
"under",
"given",
"key",
"."
] |
2693aad1ed7517c2bb5b3a42cb8fde88b941d89d
|
https://github.com/orcaman/concurrent-map/blob/2693aad1ed7517c2bb5b3a42cb8fde88b941d89d/concurrent_map.go#L83-L91
|
146,564 |
orcaman/concurrent-map
|
concurrent_map.go
|
Count
|
func (m ConcurrentMap) Count() int {
count := 0
for i := 0; i < SHARD_COUNT; i++ {
shard := m[i]
shard.RLock()
count += len(shard.items)
shard.RUnlock()
}
return count
}
|
go
|
func (m ConcurrentMap) Count() int {
count := 0
for i := 0; i < SHARD_COUNT; i++ {
shard := m[i]
shard.RLock()
count += len(shard.items)
shard.RUnlock()
}
return count
}
|
[
"func",
"(",
"m",
"ConcurrentMap",
")",
"Count",
"(",
")",
"int",
"{",
"count",
":=",
"0",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"SHARD_COUNT",
";",
"i",
"++",
"{",
"shard",
":=",
"m",
"[",
"i",
"]",
"\n",
"shard",
".",
"RLock",
"(",
")",
"\n",
"count",
"+=",
"len",
"(",
"shard",
".",
"items",
")",
"\n",
"shard",
".",
"RUnlock",
"(",
")",
"\n",
"}",
"\n",
"return",
"count",
"\n",
"}"
] |
// Count returns the number of elements within the map.
|
[
"Count",
"returns",
"the",
"number",
"of",
"elements",
"within",
"the",
"map",
"."
] |
2693aad1ed7517c2bb5b3a42cb8fde88b941d89d
|
https://github.com/orcaman/concurrent-map/blob/2693aad1ed7517c2bb5b3a42cb8fde88b941d89d/concurrent_map.go#L94-L103
|
146,565 |
orcaman/concurrent-map
|
concurrent_map.go
|
Has
|
func (m ConcurrentMap) Has(key string) bool {
// Get shard
shard := m.GetShard(key)
shard.RLock()
// See if element is within shard.
_, ok := shard.items[key]
shard.RUnlock()
return ok
}
|
go
|
func (m ConcurrentMap) Has(key string) bool {
// Get shard
shard := m.GetShard(key)
shard.RLock()
// See if element is within shard.
_, ok := shard.items[key]
shard.RUnlock()
return ok
}
|
[
"func",
"(",
"m",
"ConcurrentMap",
")",
"Has",
"(",
"key",
"string",
")",
"bool",
"{",
"// Get shard",
"shard",
":=",
"m",
".",
"GetShard",
"(",
"key",
")",
"\n",
"shard",
".",
"RLock",
"(",
")",
"\n",
"// See if element is within shard.",
"_",
",",
"ok",
":=",
"shard",
".",
"items",
"[",
"key",
"]",
"\n",
"shard",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"ok",
"\n",
"}"
] |
// Looks up an item under specified key
|
[
"Looks",
"up",
"an",
"item",
"under",
"specified",
"key"
] |
2693aad1ed7517c2bb5b3a42cb8fde88b941d89d
|
https://github.com/orcaman/concurrent-map/blob/2693aad1ed7517c2bb5b3a42cb8fde88b941d89d/concurrent_map.go#L106-L114
|
146,566 |
orcaman/concurrent-map
|
concurrent_map.go
|
Remove
|
func (m ConcurrentMap) Remove(key string) {
// Try to get shard.
shard := m.GetShard(key)
shard.Lock()
delete(shard.items, key)
shard.Unlock()
}
|
go
|
func (m ConcurrentMap) Remove(key string) {
// Try to get shard.
shard := m.GetShard(key)
shard.Lock()
delete(shard.items, key)
shard.Unlock()
}
|
[
"func",
"(",
"m",
"ConcurrentMap",
")",
"Remove",
"(",
"key",
"string",
")",
"{",
"// Try to get shard.",
"shard",
":=",
"m",
".",
"GetShard",
"(",
"key",
")",
"\n",
"shard",
".",
"Lock",
"(",
")",
"\n",
"delete",
"(",
"shard",
".",
"items",
",",
"key",
")",
"\n",
"shard",
".",
"Unlock",
"(",
")",
"\n",
"}"
] |
// Remove removes an element from the map.
|
[
"Remove",
"removes",
"an",
"element",
"from",
"the",
"map",
"."
] |
2693aad1ed7517c2bb5b3a42cb8fde88b941d89d
|
https://github.com/orcaman/concurrent-map/blob/2693aad1ed7517c2bb5b3a42cb8fde88b941d89d/concurrent_map.go#L117-L123
|
146,567 |
orcaman/concurrent-map
|
concurrent_map.go
|
Pop
|
func (m ConcurrentMap) Pop(key string) (v interface{}, exists bool) {
// Try to get shard.
shard := m.GetShard(key)
shard.Lock()
v, exists = shard.items[key]
delete(shard.items, key)
shard.Unlock()
return v, exists
}
|
go
|
func (m ConcurrentMap) Pop(key string) (v interface{}, exists bool) {
// Try to get shard.
shard := m.GetShard(key)
shard.Lock()
v, exists = shard.items[key]
delete(shard.items, key)
shard.Unlock()
return v, exists
}
|
[
"func",
"(",
"m",
"ConcurrentMap",
")",
"Pop",
"(",
"key",
"string",
")",
"(",
"v",
"interface",
"{",
"}",
",",
"exists",
"bool",
")",
"{",
"// Try to get shard.",
"shard",
":=",
"m",
".",
"GetShard",
"(",
"key",
")",
"\n",
"shard",
".",
"Lock",
"(",
")",
"\n",
"v",
",",
"exists",
"=",
"shard",
".",
"items",
"[",
"key",
"]",
"\n",
"delete",
"(",
"shard",
".",
"items",
",",
"key",
")",
"\n",
"shard",
".",
"Unlock",
"(",
")",
"\n",
"return",
"v",
",",
"exists",
"\n",
"}"
] |
// Pop removes an element from the map and returns it
|
[
"Pop",
"removes",
"an",
"element",
"from",
"the",
"map",
"and",
"returns",
"it"
] |
2693aad1ed7517c2bb5b3a42cb8fde88b941d89d
|
https://github.com/orcaman/concurrent-map/blob/2693aad1ed7517c2bb5b3a42cb8fde88b941d89d/concurrent_map.go#L146-L154
|
146,568 |
orcaman/concurrent-map
|
concurrent_map.go
|
IterBuffered
|
func (m ConcurrentMap) IterBuffered() <-chan Tuple {
chans := snapshot(m)
total := 0
for _, c := range chans {
total += cap(c)
}
ch := make(chan Tuple, total)
go fanIn(chans, ch)
return ch
}
|
go
|
func (m ConcurrentMap) IterBuffered() <-chan Tuple {
chans := snapshot(m)
total := 0
for _, c := range chans {
total += cap(c)
}
ch := make(chan Tuple, total)
go fanIn(chans, ch)
return ch
}
|
[
"func",
"(",
"m",
"ConcurrentMap",
")",
"IterBuffered",
"(",
")",
"<-",
"chan",
"Tuple",
"{",
"chans",
":=",
"snapshot",
"(",
"m",
")",
"\n",
"total",
":=",
"0",
"\n",
"for",
"_",
",",
"c",
":=",
"range",
"chans",
"{",
"total",
"+=",
"cap",
"(",
"c",
")",
"\n",
"}",
"\n",
"ch",
":=",
"make",
"(",
"chan",
"Tuple",
",",
"total",
")",
"\n",
"go",
"fanIn",
"(",
"chans",
",",
"ch",
")",
"\n",
"return",
"ch",
"\n",
"}"
] |
// IterBuffered returns a buffered iterator which could be used in a for range loop.
|
[
"IterBuffered",
"returns",
"a",
"buffered",
"iterator",
"which",
"could",
"be",
"used",
"in",
"a",
"for",
"range",
"loop",
"."
] |
2693aad1ed7517c2bb5b3a42cb8fde88b941d89d
|
https://github.com/orcaman/concurrent-map/blob/2693aad1ed7517c2bb5b3a42cb8fde88b941d89d/concurrent_map.go#L178-L187
|
146,569 |
orcaman/concurrent-map
|
concurrent_map.go
|
snapshot
|
func snapshot(m ConcurrentMap) (chans []chan Tuple) {
chans = make([]chan Tuple, SHARD_COUNT)
wg := sync.WaitGroup{}
wg.Add(SHARD_COUNT)
// Foreach shard.
for index, shard := range m {
go func(index int, shard *ConcurrentMapShared) {
// Foreach key, value pair.
shard.RLock()
chans[index] = make(chan Tuple, len(shard.items))
wg.Done()
for key, val := range shard.items {
chans[index] <- Tuple{key, val}
}
shard.RUnlock()
close(chans[index])
}(index, shard)
}
wg.Wait()
return chans
}
|
go
|
func snapshot(m ConcurrentMap) (chans []chan Tuple) {
chans = make([]chan Tuple, SHARD_COUNT)
wg := sync.WaitGroup{}
wg.Add(SHARD_COUNT)
// Foreach shard.
for index, shard := range m {
go func(index int, shard *ConcurrentMapShared) {
// Foreach key, value pair.
shard.RLock()
chans[index] = make(chan Tuple, len(shard.items))
wg.Done()
for key, val := range shard.items {
chans[index] <- Tuple{key, val}
}
shard.RUnlock()
close(chans[index])
}(index, shard)
}
wg.Wait()
return chans
}
|
[
"func",
"snapshot",
"(",
"m",
"ConcurrentMap",
")",
"(",
"chans",
"[",
"]",
"chan",
"Tuple",
")",
"{",
"chans",
"=",
"make",
"(",
"[",
"]",
"chan",
"Tuple",
",",
"SHARD_COUNT",
")",
"\n",
"wg",
":=",
"sync",
".",
"WaitGroup",
"{",
"}",
"\n",
"wg",
".",
"Add",
"(",
"SHARD_COUNT",
")",
"\n",
"// Foreach shard.",
"for",
"index",
",",
"shard",
":=",
"range",
"m",
"{",
"go",
"func",
"(",
"index",
"int",
",",
"shard",
"*",
"ConcurrentMapShared",
")",
"{",
"// Foreach key, value pair.",
"shard",
".",
"RLock",
"(",
")",
"\n",
"chans",
"[",
"index",
"]",
"=",
"make",
"(",
"chan",
"Tuple",
",",
"len",
"(",
"shard",
".",
"items",
")",
")",
"\n",
"wg",
".",
"Done",
"(",
")",
"\n",
"for",
"key",
",",
"val",
":=",
"range",
"shard",
".",
"items",
"{",
"chans",
"[",
"index",
"]",
"<-",
"Tuple",
"{",
"key",
",",
"val",
"}",
"\n",
"}",
"\n",
"shard",
".",
"RUnlock",
"(",
")",
"\n",
"close",
"(",
"chans",
"[",
"index",
"]",
")",
"\n",
"}",
"(",
"index",
",",
"shard",
")",
"\n",
"}",
"\n",
"wg",
".",
"Wait",
"(",
")",
"\n",
"return",
"chans",
"\n",
"}"
] |
// Returns a array of channels that contains elements in each shard,
// which likely takes a snapshot of `m`.
// It returns once the size of each buffered channel is determined,
// before all the channels are populated using goroutines.
|
[
"Returns",
"a",
"array",
"of",
"channels",
"that",
"contains",
"elements",
"in",
"each",
"shard",
"which",
"likely",
"takes",
"a",
"snapshot",
"of",
"m",
".",
"It",
"returns",
"once",
"the",
"size",
"of",
"each",
"buffered",
"channel",
"is",
"determined",
"before",
"all",
"the",
"channels",
"are",
"populated",
"using",
"goroutines",
"."
] |
2693aad1ed7517c2bb5b3a42cb8fde88b941d89d
|
https://github.com/orcaman/concurrent-map/blob/2693aad1ed7517c2bb5b3a42cb8fde88b941d89d/concurrent_map.go#L193-L213
|
146,570 |
orcaman/concurrent-map
|
concurrent_map.go
|
fanIn
|
func fanIn(chans []chan Tuple, out chan Tuple) {
wg := sync.WaitGroup{}
wg.Add(len(chans))
for _, ch := range chans {
go func(ch chan Tuple) {
for t := range ch {
out <- t
}
wg.Done()
}(ch)
}
wg.Wait()
close(out)
}
|
go
|
func fanIn(chans []chan Tuple, out chan Tuple) {
wg := sync.WaitGroup{}
wg.Add(len(chans))
for _, ch := range chans {
go func(ch chan Tuple) {
for t := range ch {
out <- t
}
wg.Done()
}(ch)
}
wg.Wait()
close(out)
}
|
[
"func",
"fanIn",
"(",
"chans",
"[",
"]",
"chan",
"Tuple",
",",
"out",
"chan",
"Tuple",
")",
"{",
"wg",
":=",
"sync",
".",
"WaitGroup",
"{",
"}",
"\n",
"wg",
".",
"Add",
"(",
"len",
"(",
"chans",
")",
")",
"\n",
"for",
"_",
",",
"ch",
":=",
"range",
"chans",
"{",
"go",
"func",
"(",
"ch",
"chan",
"Tuple",
")",
"{",
"for",
"t",
":=",
"range",
"ch",
"{",
"out",
"<-",
"t",
"\n",
"}",
"\n",
"wg",
".",
"Done",
"(",
")",
"\n",
"}",
"(",
"ch",
")",
"\n",
"}",
"\n",
"wg",
".",
"Wait",
"(",
")",
"\n",
"close",
"(",
"out",
")",
"\n",
"}"
] |
// fanIn reads elements from channels `chans` into channel `out`
|
[
"fanIn",
"reads",
"elements",
"from",
"channels",
"chans",
"into",
"channel",
"out"
] |
2693aad1ed7517c2bb5b3a42cb8fde88b941d89d
|
https://github.com/orcaman/concurrent-map/blob/2693aad1ed7517c2bb5b3a42cb8fde88b941d89d/concurrent_map.go#L216-L229
|
146,571 |
orcaman/concurrent-map
|
concurrent_map.go
|
IterCb
|
func (m ConcurrentMap) IterCb(fn IterCb) {
for idx := range m {
shard := (m)[idx]
shard.RLock()
for key, value := range shard.items {
fn(key, value)
}
shard.RUnlock()
}
}
|
go
|
func (m ConcurrentMap) IterCb(fn IterCb) {
for idx := range m {
shard := (m)[idx]
shard.RLock()
for key, value := range shard.items {
fn(key, value)
}
shard.RUnlock()
}
}
|
[
"func",
"(",
"m",
"ConcurrentMap",
")",
"IterCb",
"(",
"fn",
"IterCb",
")",
"{",
"for",
"idx",
":=",
"range",
"m",
"{",
"shard",
":=",
"(",
"m",
")",
"[",
"idx",
"]",
"\n",
"shard",
".",
"RLock",
"(",
")",
"\n",
"for",
"key",
",",
"value",
":=",
"range",
"shard",
".",
"items",
"{",
"fn",
"(",
"key",
",",
"value",
")",
"\n",
"}",
"\n",
"shard",
".",
"RUnlock",
"(",
")",
"\n",
"}",
"\n",
"}"
] |
// Callback based iterator, cheapest way to read
// all elements in a map.
|
[
"Callback",
"based",
"iterator",
"cheapest",
"way",
"to",
"read",
"all",
"elements",
"in",
"a",
"map",
"."
] |
2693aad1ed7517c2bb5b3a42cb8fde88b941d89d
|
https://github.com/orcaman/concurrent-map/blob/2693aad1ed7517c2bb5b3a42cb8fde88b941d89d/concurrent_map.go#L251-L260
|
146,572 |
orcaman/concurrent-map
|
concurrent_map.go
|
MarshalJSON
|
func (m ConcurrentMap) MarshalJSON() ([]byte, error) {
// Create a temporary map, which will hold all item spread across shards.
tmp := make(map[string]interface{})
// Insert items to temporary map.
for item := range m.IterBuffered() {
tmp[item.Key] = item.Val
}
return json.Marshal(tmp)
}
|
go
|
func (m ConcurrentMap) MarshalJSON() ([]byte, error) {
// Create a temporary map, which will hold all item spread across shards.
tmp := make(map[string]interface{})
// Insert items to temporary map.
for item := range m.IterBuffered() {
tmp[item.Key] = item.Val
}
return json.Marshal(tmp)
}
|
[
"func",
"(",
"m",
"ConcurrentMap",
")",
"MarshalJSON",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"// Create a temporary map, which will hold all item spread across shards.",
"tmp",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n\n",
"// Insert items to temporary map.",
"for",
"item",
":=",
"range",
"m",
".",
"IterBuffered",
"(",
")",
"{",
"tmp",
"[",
"item",
".",
"Key",
"]",
"=",
"item",
".",
"Val",
"\n",
"}",
"\n",
"return",
"json",
".",
"Marshal",
"(",
"tmp",
")",
"\n",
"}"
] |
//Reviles ConcurrentMap "private" variables to json marshal.
|
[
"Reviles",
"ConcurrentMap",
"private",
"variables",
"to",
"json",
"marshal",
"."
] |
2693aad1ed7517c2bb5b3a42cb8fde88b941d89d
|
https://github.com/orcaman/concurrent-map/blob/2693aad1ed7517c2bb5b3a42cb8fde88b941d89d/concurrent_map.go#L294-L303
|
146,573 |
golang/example
|
gotypes/weave.go
|
include
|
func include(file, tag string) (string, error) {
f, err := os.Open(file)
if err != nil {
return "", err
}
defer f.Close()
startre, err := regexp.Compile("!\\+" + tag + "$")
if err != nil {
return "", err
}
endre, err := regexp.Compile("!\\-" + tag + "$")
if err != nil {
return "", err
}
var text bytes.Buffer
in := bufio.NewScanner(f)
var on bool
for in.Scan() {
line := in.Text()
switch {
case startre.MatchString(line):
on = true
case endre.MatchString(line):
on = false
case on:
text.WriteByte('\t')
text.WriteString(line)
text.WriteByte('\n')
}
}
if text.Len() == 0 {
return "", fmt.Errorf("no lines of %s matched tag %q", file, tag)
}
return text.String(), nil
}
|
go
|
func include(file, tag string) (string, error) {
f, err := os.Open(file)
if err != nil {
return "", err
}
defer f.Close()
startre, err := regexp.Compile("!\\+" + tag + "$")
if err != nil {
return "", err
}
endre, err := regexp.Compile("!\\-" + tag + "$")
if err != nil {
return "", err
}
var text bytes.Buffer
in := bufio.NewScanner(f)
var on bool
for in.Scan() {
line := in.Text()
switch {
case startre.MatchString(line):
on = true
case endre.MatchString(line):
on = false
case on:
text.WriteByte('\t')
text.WriteString(line)
text.WriteByte('\n')
}
}
if text.Len() == 0 {
return "", fmt.Errorf("no lines of %s matched tag %q", file, tag)
}
return text.String(), nil
}
|
[
"func",
"include",
"(",
"file",
",",
"tag",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"f",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"file",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"defer",
"f",
".",
"Close",
"(",
")",
"\n\n",
"startre",
",",
"err",
":=",
"regexp",
".",
"Compile",
"(",
"\"",
"\\\\",
"\"",
"+",
"tag",
"+",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"endre",
",",
"err",
":=",
"regexp",
".",
"Compile",
"(",
"\"",
"\\\\",
"\"",
"+",
"tag",
"+",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"text",
"bytes",
".",
"Buffer",
"\n",
"in",
":=",
"bufio",
".",
"NewScanner",
"(",
"f",
")",
"\n",
"var",
"on",
"bool",
"\n",
"for",
"in",
".",
"Scan",
"(",
")",
"{",
"line",
":=",
"in",
".",
"Text",
"(",
")",
"\n",
"switch",
"{",
"case",
"startre",
".",
"MatchString",
"(",
"line",
")",
":",
"on",
"=",
"true",
"\n",
"case",
"endre",
".",
"MatchString",
"(",
"line",
")",
":",
"on",
"=",
"false",
"\n",
"case",
"on",
":",
"text",
".",
"WriteByte",
"(",
"'\\t'",
")",
"\n",
"text",
".",
"WriteString",
"(",
"line",
")",
"\n",
"text",
".",
"WriteByte",
"(",
"'\\n'",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"text",
".",
"Len",
"(",
")",
"==",
"0",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"file",
",",
"tag",
")",
"\n",
"}",
"\n",
"return",
"text",
".",
"String",
"(",
")",
",",
"nil",
"\n",
"}"
] |
// include processes an included file, and returns the included text.
// Only lines between those matching !+tag and !-tag will be returned.
// This is true even if tag=="".
|
[
"include",
"processes",
"an",
"included",
"file",
"and",
"returns",
"the",
"included",
"text",
".",
"Only",
"lines",
"between",
"those",
"matching",
"!",
"+",
"tag",
"and",
"!",
"-",
"tag",
"will",
"be",
"returned",
".",
"This",
"is",
"true",
"even",
"if",
"tag",
"==",
"."
] |
46695d81d1fae905a270fb7db8a4d11a334562fe
|
https://github.com/golang/example/blob/46695d81d1fae905a270fb7db8a4d11a334562fe/gotypes/weave.go#L105-L141
|
146,574 |
golang/example
|
gotypes/weave.go
|
cleanListing
|
func cleanListing(text string) string {
lines := strings.Split(text, "\n")
// remove minimum number of leading tabs from all non-blank lines
tabs := 999
for i, line := range lines {
if strings.TrimSpace(line) == "" {
lines[i] = ""
} else {
if n := leadingTabs(line); n < tabs {
tabs = n
}
}
}
for i, line := range lines {
if line != "" {
line := line[tabs:]
lines[i] = line // remove leading tabs
}
}
// remove leading blank lines
for len(lines) > 0 && lines[0] == "" {
lines = lines[1:]
}
// remove trailing blank lines
for len(lines) > 0 && lines[len(lines)-1] == "" {
lines = lines[:len(lines)-1]
}
return strings.Join(lines, "\n")
}
|
go
|
func cleanListing(text string) string {
lines := strings.Split(text, "\n")
// remove minimum number of leading tabs from all non-blank lines
tabs := 999
for i, line := range lines {
if strings.TrimSpace(line) == "" {
lines[i] = ""
} else {
if n := leadingTabs(line); n < tabs {
tabs = n
}
}
}
for i, line := range lines {
if line != "" {
line := line[tabs:]
lines[i] = line // remove leading tabs
}
}
// remove leading blank lines
for len(lines) > 0 && lines[0] == "" {
lines = lines[1:]
}
// remove trailing blank lines
for len(lines) > 0 && lines[len(lines)-1] == "" {
lines = lines[:len(lines)-1]
}
return strings.Join(lines, "\n")
}
|
[
"func",
"cleanListing",
"(",
"text",
"string",
")",
"string",
"{",
"lines",
":=",
"strings",
".",
"Split",
"(",
"text",
",",
"\"",
"\\n",
"\"",
")",
"\n\n",
"// remove minimum number of leading tabs from all non-blank lines",
"tabs",
":=",
"999",
"\n",
"for",
"i",
",",
"line",
":=",
"range",
"lines",
"{",
"if",
"strings",
".",
"TrimSpace",
"(",
"line",
")",
"==",
"\"",
"\"",
"{",
"lines",
"[",
"i",
"]",
"=",
"\"",
"\"",
"\n",
"}",
"else",
"{",
"if",
"n",
":=",
"leadingTabs",
"(",
"line",
")",
";",
"n",
"<",
"tabs",
"{",
"tabs",
"=",
"n",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"for",
"i",
",",
"line",
":=",
"range",
"lines",
"{",
"if",
"line",
"!=",
"\"",
"\"",
"{",
"line",
":=",
"line",
"[",
"tabs",
":",
"]",
"\n",
"lines",
"[",
"i",
"]",
"=",
"line",
"// remove leading tabs",
"\n",
"}",
"\n",
"}",
"\n\n",
"// remove leading blank lines",
"for",
"len",
"(",
"lines",
")",
">",
"0",
"&&",
"lines",
"[",
"0",
"]",
"==",
"\"",
"\"",
"{",
"lines",
"=",
"lines",
"[",
"1",
":",
"]",
"\n",
"}",
"\n",
"// remove trailing blank lines",
"for",
"len",
"(",
"lines",
")",
">",
"0",
"&&",
"lines",
"[",
"len",
"(",
"lines",
")",
"-",
"1",
"]",
"==",
"\"",
"\"",
"{",
"lines",
"=",
"lines",
"[",
":",
"len",
"(",
"lines",
")",
"-",
"1",
"]",
"\n",
"}",
"\n",
"return",
"strings",
".",
"Join",
"(",
"lines",
",",
"\"",
"\\n",
"\"",
")",
"\n",
"}"
] |
// cleanListing removes entirely blank leading and trailing lines from
// text, and removes n leading tabs.
|
[
"cleanListing",
"removes",
"entirely",
"blank",
"leading",
"and",
"trailing",
"lines",
"from",
"text",
"and",
"removes",
"n",
"leading",
"tabs",
"."
] |
46695d81d1fae905a270fb7db8a4d11a334562fe
|
https://github.com/golang/example/blob/46695d81d1fae905a270fb7db8a4d11a334562fe/gotypes/weave.go#L151-L181
|
146,575 |
golang/example
|
gotypes/typeandvalue/main.go
|
nodeString
|
func nodeString(n ast.Node) string {
var buf bytes.Buffer
format.Node(&buf, fset, n)
return buf.String()
}
|
go
|
func nodeString(n ast.Node) string {
var buf bytes.Buffer
format.Node(&buf, fset, n)
return buf.String()
}
|
[
"func",
"nodeString",
"(",
"n",
"ast",
".",
"Node",
")",
"string",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"format",
".",
"Node",
"(",
"&",
"buf",
",",
"fset",
",",
"n",
")",
"\n",
"return",
"buf",
".",
"String",
"(",
")",
"\n",
"}"
] |
// nodeString formats a syntax tree in the style of gofmt.
|
[
"nodeString",
"formats",
"a",
"syntax",
"tree",
"in",
"the",
"style",
"of",
"gofmt",
"."
] |
46695d81d1fae905a270fb7db8a4d11a334562fe
|
https://github.com/golang/example/blob/46695d81d1fae905a270fb7db8a4d11a334562fe/gotypes/typeandvalue/main.go#L61-L65
|
146,576 |
golang/example
|
gotypes/typeandvalue/main.go
|
mode
|
func mode(tv types.TypeAndValue) string {
s := ""
if tv.IsVoid() {
s += ",void"
}
if tv.IsType() {
s += ",type"
}
if tv.IsBuiltin() {
s += ",builtin"
}
if tv.IsValue() {
s += ",value"
}
if tv.IsNil() {
s += ",nil"
}
if tv.Addressable() {
s += ",addressable"
}
if tv.Assignable() {
s += ",assignable"
}
if tv.HasOk() {
s += ",ok"
}
return s[1:]
}
|
go
|
func mode(tv types.TypeAndValue) string {
s := ""
if tv.IsVoid() {
s += ",void"
}
if tv.IsType() {
s += ",type"
}
if tv.IsBuiltin() {
s += ",builtin"
}
if tv.IsValue() {
s += ",value"
}
if tv.IsNil() {
s += ",nil"
}
if tv.Addressable() {
s += ",addressable"
}
if tv.Assignable() {
s += ",assignable"
}
if tv.HasOk() {
s += ",ok"
}
return s[1:]
}
|
[
"func",
"mode",
"(",
"tv",
"types",
".",
"TypeAndValue",
")",
"string",
"{",
"s",
":=",
"\"",
"\"",
"\n",
"if",
"tv",
".",
"IsVoid",
"(",
")",
"{",
"s",
"+=",
"\"",
"\"",
"\n",
"}",
"\n",
"if",
"tv",
".",
"IsType",
"(",
")",
"{",
"s",
"+=",
"\"",
"\"",
"\n",
"}",
"\n",
"if",
"tv",
".",
"IsBuiltin",
"(",
")",
"{",
"s",
"+=",
"\"",
"\"",
"\n",
"}",
"\n",
"if",
"tv",
".",
"IsValue",
"(",
")",
"{",
"s",
"+=",
"\"",
"\"",
"\n",
"}",
"\n",
"if",
"tv",
".",
"IsNil",
"(",
")",
"{",
"s",
"+=",
"\"",
"\"",
"\n",
"}",
"\n",
"if",
"tv",
".",
"Addressable",
"(",
")",
"{",
"s",
"+=",
"\"",
"\"",
"\n",
"}",
"\n",
"if",
"tv",
".",
"Assignable",
"(",
")",
"{",
"s",
"+=",
"\"",
"\"",
"\n",
"}",
"\n",
"if",
"tv",
".",
"HasOk",
"(",
")",
"{",
"s",
"+=",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"s",
"[",
"1",
":",
"]",
"\n",
"}"
] |
// mode returns a string describing the mode of an expression.
|
[
"mode",
"returns",
"a",
"string",
"describing",
"the",
"mode",
"of",
"an",
"expression",
"."
] |
46695d81d1fae905a270fb7db8a4d11a334562fe
|
https://github.com/golang/example/blob/46695d81d1fae905a270fb7db8a4d11a334562fe/gotypes/typeandvalue/main.go#L68-L95
|
146,577 |
golang/example
|
outyet/main.go
|
NewServer
|
func NewServer(version, url string, period time.Duration) *Server {
s := &Server{version: version, url: url, period: period}
go s.poll()
return s
}
|
go
|
func NewServer(version, url string, period time.Duration) *Server {
s := &Server{version: version, url: url, period: period}
go s.poll()
return s
}
|
[
"func",
"NewServer",
"(",
"version",
",",
"url",
"string",
",",
"period",
"time",
".",
"Duration",
")",
"*",
"Server",
"{",
"s",
":=",
"&",
"Server",
"{",
"version",
":",
"version",
",",
"url",
":",
"url",
",",
"period",
":",
"period",
"}",
"\n",
"go",
"s",
".",
"poll",
"(",
")",
"\n",
"return",
"s",
"\n",
"}"
] |
// NewServer returns an initialized outyet server.
|
[
"NewServer",
"returns",
"an",
"initialized",
"outyet",
"server",
"."
] |
46695d81d1fae905a270fb7db8a4d11a334562fe
|
https://github.com/golang/example/blob/46695d81d1fae905a270fb7db8a4d11a334562fe/outyet/main.go#L70-L74
|
146,578 |
golang/example
|
outyet/main.go
|
poll
|
func (s *Server) poll() {
for !isTagged(s.url) {
pollSleep(s.period)
}
s.mu.Lock()
s.yes = true
s.mu.Unlock()
pollDone()
}
|
go
|
func (s *Server) poll() {
for !isTagged(s.url) {
pollSleep(s.period)
}
s.mu.Lock()
s.yes = true
s.mu.Unlock()
pollDone()
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"poll",
"(",
")",
"{",
"for",
"!",
"isTagged",
"(",
"s",
".",
"url",
")",
"{",
"pollSleep",
"(",
"s",
".",
"period",
")",
"\n",
"}",
"\n",
"s",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"s",
".",
"yes",
"=",
"true",
"\n",
"s",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"pollDone",
"(",
")",
"\n",
"}"
] |
// poll polls the change URL for the specified period until the tag exists.
// Then it sets the Server's yes field true and exits.
|
[
"poll",
"polls",
"the",
"change",
"URL",
"for",
"the",
"specified",
"period",
"until",
"the",
"tag",
"exists",
".",
"Then",
"it",
"sets",
"the",
"Server",
"s",
"yes",
"field",
"true",
"and",
"exits",
"."
] |
46695d81d1fae905a270fb7db8a4d11a334562fe
|
https://github.com/golang/example/blob/46695d81d1fae905a270fb7db8a4d11a334562fe/outyet/main.go#L78-L86
|
146,579 |
golang/example
|
outyet/main.go
|
isTagged
|
func isTagged(url string) bool {
pollCount.Add(1)
r, err := http.Head(url)
if err != nil {
log.Print(err)
pollError.Set(err.Error())
pollErrorCount.Add(1)
return false
}
return r.StatusCode == http.StatusOK
}
|
go
|
func isTagged(url string) bool {
pollCount.Add(1)
r, err := http.Head(url)
if err != nil {
log.Print(err)
pollError.Set(err.Error())
pollErrorCount.Add(1)
return false
}
return r.StatusCode == http.StatusOK
}
|
[
"func",
"isTagged",
"(",
"url",
"string",
")",
"bool",
"{",
"pollCount",
".",
"Add",
"(",
"1",
")",
"\n",
"r",
",",
"err",
":=",
"http",
".",
"Head",
"(",
"url",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Print",
"(",
"err",
")",
"\n",
"pollError",
".",
"Set",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"pollErrorCount",
".",
"Add",
"(",
"1",
")",
"\n",
"return",
"false",
"\n",
"}",
"\n",
"return",
"r",
".",
"StatusCode",
"==",
"http",
".",
"StatusOK",
"\n",
"}"
] |
// isTagged makes an HTTP HEAD request to the given URL and reports whether it
// returned a 200 OK response.
|
[
"isTagged",
"makes",
"an",
"HTTP",
"HEAD",
"request",
"to",
"the",
"given",
"URL",
"and",
"reports",
"whether",
"it",
"returned",
"a",
"200",
"OK",
"response",
"."
] |
46695d81d1fae905a270fb7db8a4d11a334562fe
|
https://github.com/golang/example/blob/46695d81d1fae905a270fb7db8a4d11a334562fe/outyet/main.go#L96-L106
|
146,580 |
golang/example
|
outyet/main.go
|
ServeHTTP
|
func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
hitCount.Add(1)
s.mu.RLock()
data := struct {
URL string
Version string
Yes bool
}{
s.url,
s.version,
s.yes,
}
s.mu.RUnlock()
err := tmpl.Execute(w, data)
if err != nil {
log.Print(err)
}
}
|
go
|
func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
hitCount.Add(1)
s.mu.RLock()
data := struct {
URL string
Version string
Yes bool
}{
s.url,
s.version,
s.yes,
}
s.mu.RUnlock()
err := tmpl.Execute(w, data)
if err != nil {
log.Print(err)
}
}
|
[
"func",
"(",
"s",
"*",
"Server",
")",
"ServeHTTP",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"hitCount",
".",
"Add",
"(",
"1",
")",
"\n",
"s",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"data",
":=",
"struct",
"{",
"URL",
"string",
"\n",
"Version",
"string",
"\n",
"Yes",
"bool",
"\n",
"}",
"{",
"s",
".",
"url",
",",
"s",
".",
"version",
",",
"s",
".",
"yes",
",",
"}",
"\n",
"s",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"err",
":=",
"tmpl",
".",
"Execute",
"(",
"w",
",",
"data",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Print",
"(",
"err",
")",
"\n",
"}",
"\n",
"}"
] |
// ServeHTTP implements the HTTP user interface.
|
[
"ServeHTTP",
"implements",
"the",
"HTTP",
"user",
"interface",
"."
] |
46695d81d1fae905a270fb7db8a4d11a334562fe
|
https://github.com/golang/example/blob/46695d81d1fae905a270fb7db8a4d11a334562fe/outyet/main.go#L109-L126
|
146,581 |
golang/example
|
gotypes/lookup/lookup.go
|
main
|
func main() {
fset := token.NewFileSet()
f, err := parser.ParseFile(fset, "hello.go", hello, parser.ParseComments)
if err != nil {
log.Fatal(err) // parse error
}
conf := types.Config{Importer: importer.Default()}
pkg, err := conf.Check("cmd/hello", fset, []*ast.File{f}, nil)
if err != nil {
log.Fatal(err) // type error
}
// Each comment contains a name.
// Look up that name in the innermost scope enclosing the comment.
for _, comment := range f.Comments {
pos := comment.Pos()
name := strings.TrimSpace(comment.Text())
fmt.Printf("At %s,\t%q = ", fset.Position(pos), name)
inner := pkg.Scope().Innermost(pos)
if _, obj := inner.LookupParent(name, pos); obj != nil {
fmt.Println(obj)
} else {
fmt.Println("not found")
}
}
}
|
go
|
func main() {
fset := token.NewFileSet()
f, err := parser.ParseFile(fset, "hello.go", hello, parser.ParseComments)
if err != nil {
log.Fatal(err) // parse error
}
conf := types.Config{Importer: importer.Default()}
pkg, err := conf.Check("cmd/hello", fset, []*ast.File{f}, nil)
if err != nil {
log.Fatal(err) // type error
}
// Each comment contains a name.
// Look up that name in the innermost scope enclosing the comment.
for _, comment := range f.Comments {
pos := comment.Pos()
name := strings.TrimSpace(comment.Text())
fmt.Printf("At %s,\t%q = ", fset.Position(pos), name)
inner := pkg.Scope().Innermost(pos)
if _, obj := inner.LookupParent(name, pos); obj != nil {
fmt.Println(obj)
} else {
fmt.Println("not found")
}
}
}
|
[
"func",
"main",
"(",
")",
"{",
"fset",
":=",
"token",
".",
"NewFileSet",
"(",
")",
"\n",
"f",
",",
"err",
":=",
"parser",
".",
"ParseFile",
"(",
"fset",
",",
"\"",
"\"",
",",
"hello",
",",
"parser",
".",
"ParseComments",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatal",
"(",
"err",
")",
"// parse error",
"\n",
"}",
"\n\n",
"conf",
":=",
"types",
".",
"Config",
"{",
"Importer",
":",
"importer",
".",
"Default",
"(",
")",
"}",
"\n",
"pkg",
",",
"err",
":=",
"conf",
".",
"Check",
"(",
"\"",
"\"",
",",
"fset",
",",
"[",
"]",
"*",
"ast",
".",
"File",
"{",
"f",
"}",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatal",
"(",
"err",
")",
"// type error",
"\n",
"}",
"\n\n",
"// Each comment contains a name.",
"// Look up that name in the innermost scope enclosing the comment.",
"for",
"_",
",",
"comment",
":=",
"range",
"f",
".",
"Comments",
"{",
"pos",
":=",
"comment",
".",
"Pos",
"(",
")",
"\n",
"name",
":=",
"strings",
".",
"TrimSpace",
"(",
"comment",
".",
"Text",
"(",
")",
")",
"\n",
"fmt",
".",
"Printf",
"(",
"\"",
"\\t",
"\"",
",",
"fset",
".",
"Position",
"(",
"pos",
")",
",",
"name",
")",
"\n",
"inner",
":=",
"pkg",
".",
"Scope",
"(",
")",
".",
"Innermost",
"(",
"pos",
")",
"\n",
"if",
"_",
",",
"obj",
":=",
"inner",
".",
"LookupParent",
"(",
"name",
",",
"pos",
")",
";",
"obj",
"!=",
"nil",
"{",
"fmt",
".",
"Println",
"(",
"obj",
")",
"\n",
"}",
"else",
"{",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
//!-input
//!+main
|
[
"!",
"-",
"input",
"!",
"+",
"main"
] |
46695d81d1fae905a270fb7db8a4d11a334562fe
|
https://github.com/golang/example/blob/46695d81d1fae905a270fb7db8a4d11a334562fe/gotypes/lookup/lookup.go#L36-L62
|
146,582 |
golang/example
|
gotypes/implements/main.go
|
main
|
func main() {
// Parse one file.
fset := token.NewFileSet()
f, err := parser.ParseFile(fset, "input.go", input, 0)
if err != nil {
log.Fatal(err) // parse error
}
conf := types.Config{Importer: importer.Default()}
pkg, err := conf.Check("hello", fset, []*ast.File{f}, nil)
if err != nil {
log.Fatal(err) // type error
}
//!+implements
// Find all named types at package level.
var allNamed []*types.Named
for _, name := range pkg.Scope().Names() {
if obj, ok := pkg.Scope().Lookup(name).(*types.TypeName); ok {
allNamed = append(allNamed, obj.Type().(*types.Named))
}
}
// Test assignability of all distinct pairs of
// named types (T, U) where U is an interface.
for _, T := range allNamed {
for _, U := range allNamed {
if T == U || !types.IsInterface(U) {
continue
}
if types.AssignableTo(T, U) {
fmt.Printf("%s satisfies %s\n", T, U)
} else if !types.IsInterface(T) &&
types.AssignableTo(types.NewPointer(T), U) {
fmt.Printf("%s satisfies %s\n", types.NewPointer(T), U)
}
}
}
//!-implements
}
|
go
|
func main() {
// Parse one file.
fset := token.NewFileSet()
f, err := parser.ParseFile(fset, "input.go", input, 0)
if err != nil {
log.Fatal(err) // parse error
}
conf := types.Config{Importer: importer.Default()}
pkg, err := conf.Check("hello", fset, []*ast.File{f}, nil)
if err != nil {
log.Fatal(err) // type error
}
//!+implements
// Find all named types at package level.
var allNamed []*types.Named
for _, name := range pkg.Scope().Names() {
if obj, ok := pkg.Scope().Lookup(name).(*types.TypeName); ok {
allNamed = append(allNamed, obj.Type().(*types.Named))
}
}
// Test assignability of all distinct pairs of
// named types (T, U) where U is an interface.
for _, T := range allNamed {
for _, U := range allNamed {
if T == U || !types.IsInterface(U) {
continue
}
if types.AssignableTo(T, U) {
fmt.Printf("%s satisfies %s\n", T, U)
} else if !types.IsInterface(T) &&
types.AssignableTo(types.NewPointer(T), U) {
fmt.Printf("%s satisfies %s\n", types.NewPointer(T), U)
}
}
}
//!-implements
}
|
[
"func",
"main",
"(",
")",
"{",
"// Parse one file.",
"fset",
":=",
"token",
".",
"NewFileSet",
"(",
")",
"\n",
"f",
",",
"err",
":=",
"parser",
".",
"ParseFile",
"(",
"fset",
",",
"\"",
"\"",
",",
"input",
",",
"0",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatal",
"(",
"err",
")",
"// parse error",
"\n",
"}",
"\n",
"conf",
":=",
"types",
".",
"Config",
"{",
"Importer",
":",
"importer",
".",
"Default",
"(",
")",
"}",
"\n",
"pkg",
",",
"err",
":=",
"conf",
".",
"Check",
"(",
"\"",
"\"",
",",
"fset",
",",
"[",
"]",
"*",
"ast",
".",
"File",
"{",
"f",
"}",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatal",
"(",
"err",
")",
"// type error",
"\n",
"}",
"\n\n",
"//!+implements",
"// Find all named types at package level.",
"var",
"allNamed",
"[",
"]",
"*",
"types",
".",
"Named",
"\n",
"for",
"_",
",",
"name",
":=",
"range",
"pkg",
".",
"Scope",
"(",
")",
".",
"Names",
"(",
")",
"{",
"if",
"obj",
",",
"ok",
":=",
"pkg",
".",
"Scope",
"(",
")",
".",
"Lookup",
"(",
"name",
")",
".",
"(",
"*",
"types",
".",
"TypeName",
")",
";",
"ok",
"{",
"allNamed",
"=",
"append",
"(",
"allNamed",
",",
"obj",
".",
"Type",
"(",
")",
".",
"(",
"*",
"types",
".",
"Named",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Test assignability of all distinct pairs of",
"// named types (T, U) where U is an interface.",
"for",
"_",
",",
"T",
":=",
"range",
"allNamed",
"{",
"for",
"_",
",",
"U",
":=",
"range",
"allNamed",
"{",
"if",
"T",
"==",
"U",
"||",
"!",
"types",
".",
"IsInterface",
"(",
"U",
")",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"types",
".",
"AssignableTo",
"(",
"T",
",",
"U",
")",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"T",
",",
"U",
")",
"\n",
"}",
"else",
"if",
"!",
"types",
".",
"IsInterface",
"(",
"T",
")",
"&&",
"types",
".",
"AssignableTo",
"(",
"types",
".",
"NewPointer",
"(",
"T",
")",
",",
"U",
")",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"types",
".",
"NewPointer",
"(",
"T",
")",
",",
"U",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"//!-implements",
"}"
] |
//!-input
|
[
"!",
"-",
"input"
] |
46695d81d1fae905a270fb7db8a4d11a334562fe
|
https://github.com/golang/example/blob/46695d81d1fae905a270fb7db8a4d11a334562fe/gotypes/implements/main.go#L29-L67
|
146,583 |
golang/example
|
template/main.go
|
indexHandler
|
func indexHandler(w http.ResponseWriter, r *http.Request) {
data := &Index{
Title: "Image gallery",
Body: "Welcome to the image gallery.",
}
for name, img := range images {
data.Links = append(data.Links, Link{
URL: "/image/" + name,
Title: img.Title,
})
}
if err := indexTemplate.Execute(w, data); err != nil {
log.Println(err)
}
}
|
go
|
func indexHandler(w http.ResponseWriter, r *http.Request) {
data := &Index{
Title: "Image gallery",
Body: "Welcome to the image gallery.",
}
for name, img := range images {
data.Links = append(data.Links, Link{
URL: "/image/" + name,
Title: img.Title,
})
}
if err := indexTemplate.Execute(w, data); err != nil {
log.Println(err)
}
}
|
[
"func",
"indexHandler",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"data",
":=",
"&",
"Index",
"{",
"Title",
":",
"\"",
"\"",
",",
"Body",
":",
"\"",
"\"",
",",
"}",
"\n",
"for",
"name",
",",
"img",
":=",
"range",
"images",
"{",
"data",
".",
"Links",
"=",
"append",
"(",
"data",
".",
"Links",
",",
"Link",
"{",
"URL",
":",
"\"",
"\"",
"+",
"name",
",",
"Title",
":",
"img",
".",
"Title",
",",
"}",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"indexTemplate",
".",
"Execute",
"(",
"w",
",",
"data",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Println",
"(",
"err",
")",
"\n",
"}",
"\n",
"}"
] |
// indexHandler is an HTTP handler that serves the index page.
|
[
"indexHandler",
"is",
"an",
"HTTP",
"handler",
"that",
"serves",
"the",
"index",
"page",
"."
] |
46695d81d1fae905a270fb7db8a4d11a334562fe
|
https://github.com/golang/example/blob/46695d81d1fae905a270fb7db8a4d11a334562fe/template/main.go#L55-L69
|
146,584 |
golang/example
|
template/main.go
|
imageHandler
|
func imageHandler(w http.ResponseWriter, r *http.Request) {
data, ok := images[strings.TrimPrefix(r.URL.Path, "/image/")]
if !ok {
http.NotFound(w, r)
return
}
if err := imageTemplate.Execute(w, data); err != nil {
log.Println(err)
}
}
|
go
|
func imageHandler(w http.ResponseWriter, r *http.Request) {
data, ok := images[strings.TrimPrefix(r.URL.Path, "/image/")]
if !ok {
http.NotFound(w, r)
return
}
if err := imageTemplate.Execute(w, data); err != nil {
log.Println(err)
}
}
|
[
"func",
"imageHandler",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"data",
",",
"ok",
":=",
"images",
"[",
"strings",
".",
"TrimPrefix",
"(",
"r",
".",
"URL",
".",
"Path",
",",
"\"",
"\"",
")",
"]",
"\n",
"if",
"!",
"ok",
"{",
"http",
".",
"NotFound",
"(",
"w",
",",
"r",
")",
"\n",
"return",
"\n",
"}",
"\n",
"if",
"err",
":=",
"imageTemplate",
".",
"Execute",
"(",
"w",
",",
"data",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Println",
"(",
"err",
")",
"\n",
"}",
"\n",
"}"
] |
// imageHandler is an HTTP handler that serves the image pages.
|
[
"imageHandler",
"is",
"an",
"HTTP",
"handler",
"that",
"serves",
"the",
"image",
"pages",
"."
] |
46695d81d1fae905a270fb7db8a4d11a334562fe
|
https://github.com/golang/example/blob/46695d81d1fae905a270fb7db8a4d11a334562fe/template/main.go#L82-L91
|
146,585 |
kardianos/govendor
|
context/label.go
|
FindLabel
|
func FindLabel(version string, labels []Label) Label {
list := make([]*labelAnalysis, 0, 6)
exact := strings.HasPrefix(version, "=")
version = strings.TrimPrefix(version, "=")
for _, label := range labels {
if exact {
if label.Text == version {
return label
}
continue
}
if !strings.HasPrefix(label.Text, version) {
continue
}
remain := strings.TrimPrefix(label.Text, version)
if len(remain) > 0 {
next := remain[0]
// The stated version must either be the full label,
// followed by a "." or "-".
if next != '.' && next != '-' {
continue
}
}
list = append(list, &labelAnalysis{
Label: label,
Groups: make([]labelGroup, 0, 3),
})
}
if len(list) == 0 {
return Label{Source: LabelNone}
}
buf := &bytes.Buffer{}
for _, item := range list {
item.fillSections(buf)
buf.Reset()
}
sort.Sort(labelAnalysisList(list))
return list[0].Label
}
|
go
|
func FindLabel(version string, labels []Label) Label {
list := make([]*labelAnalysis, 0, 6)
exact := strings.HasPrefix(version, "=")
version = strings.TrimPrefix(version, "=")
for _, label := range labels {
if exact {
if label.Text == version {
return label
}
continue
}
if !strings.HasPrefix(label.Text, version) {
continue
}
remain := strings.TrimPrefix(label.Text, version)
if len(remain) > 0 {
next := remain[0]
// The stated version must either be the full label,
// followed by a "." or "-".
if next != '.' && next != '-' {
continue
}
}
list = append(list, &labelAnalysis{
Label: label,
Groups: make([]labelGroup, 0, 3),
})
}
if len(list) == 0 {
return Label{Source: LabelNone}
}
buf := &bytes.Buffer{}
for _, item := range list {
item.fillSections(buf)
buf.Reset()
}
sort.Sort(labelAnalysisList(list))
return list[0].Label
}
|
[
"func",
"FindLabel",
"(",
"version",
"string",
",",
"labels",
"[",
"]",
"Label",
")",
"Label",
"{",
"list",
":=",
"make",
"(",
"[",
"]",
"*",
"labelAnalysis",
",",
"0",
",",
"6",
")",
"\n\n",
"exact",
":=",
"strings",
".",
"HasPrefix",
"(",
"version",
",",
"\"",
"\"",
")",
"\n",
"version",
"=",
"strings",
".",
"TrimPrefix",
"(",
"version",
",",
"\"",
"\"",
")",
"\n\n",
"for",
"_",
",",
"label",
":=",
"range",
"labels",
"{",
"if",
"exact",
"{",
"if",
"label",
".",
"Text",
"==",
"version",
"{",
"return",
"label",
"\n",
"}",
"\n",
"continue",
"\n",
"}",
"\n",
"if",
"!",
"strings",
".",
"HasPrefix",
"(",
"label",
".",
"Text",
",",
"version",
")",
"{",
"continue",
"\n",
"}",
"\n",
"remain",
":=",
"strings",
".",
"TrimPrefix",
"(",
"label",
".",
"Text",
",",
"version",
")",
"\n",
"if",
"len",
"(",
"remain",
")",
">",
"0",
"{",
"next",
":=",
"remain",
"[",
"0",
"]",
"\n",
"// The stated version must either be the full label,",
"// followed by a \".\" or \"-\".",
"if",
"next",
"!=",
"'.'",
"&&",
"next",
"!=",
"'-'",
"{",
"continue",
"\n",
"}",
"\n",
"}",
"\n",
"list",
"=",
"append",
"(",
"list",
",",
"&",
"labelAnalysis",
"{",
"Label",
":",
"label",
",",
"Groups",
":",
"make",
"(",
"[",
"]",
"labelGroup",
",",
"0",
",",
"3",
")",
",",
"}",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"list",
")",
"==",
"0",
"{",
"return",
"Label",
"{",
"Source",
":",
"LabelNone",
"}",
"\n",
"}",
"\n\n",
"buf",
":=",
"&",
"bytes",
".",
"Buffer",
"{",
"}",
"\n",
"for",
"_",
",",
"item",
":=",
"range",
"list",
"{",
"item",
".",
"fillSections",
"(",
"buf",
")",
"\n",
"buf",
".",
"Reset",
"(",
")",
"\n",
"}",
"\n",
"sort",
".",
"Sort",
"(",
"labelAnalysisList",
"(",
"list",
")",
")",
"\n",
"return",
"list",
"[",
"0",
"]",
".",
"Label",
"\n",
"}"
] |
// FindLabel matches a single label from a list of labels, given a version.
// If the returning label.Source is LabelNone, then no labels match.
//
// Labels are first broken into sections separated by "-". Shortest wins.
// If they have the same number of above sections, then they are compared
// further. Number sequences are treated as numbers. Numbers do not need a
// separator. The "." is a break point as well.
|
[
"FindLabel",
"matches",
"a",
"single",
"label",
"from",
"a",
"list",
"of",
"labels",
"given",
"a",
"version",
".",
"If",
"the",
"returning",
"label",
".",
"Source",
"is",
"LabelNone",
"then",
"no",
"labels",
"match",
".",
"Labels",
"are",
"first",
"broken",
"into",
"sections",
"separated",
"by",
"-",
".",
"Shortest",
"wins",
".",
"If",
"they",
"have",
"the",
"same",
"number",
"of",
"above",
"sections",
"then",
"they",
"are",
"compared",
"further",
".",
"Number",
"sequences",
"are",
"treated",
"as",
"numbers",
".",
"Numbers",
"do",
"not",
"need",
"a",
"separator",
".",
"The",
".",
"is",
"a",
"break",
"point",
"as",
"well",
"."
] |
d0fd0db8a43d4b87c2ce416f60ae78407f3f3c62
|
https://github.com/kardianos/govendor/blob/d0fd0db8a43d4b87c2ce416f60ae78407f3f3c62/context/label.go#L199-L240
|
146,586 |
kardianos/govendor
|
context/version.go
|
isVersion
|
func isVersion(s string) bool {
hasPunct := false
onlyNumber := true
onlyHexLetter := true
for _, r := range s {
isNumber := unicode.IsNumber(r)
isLetter := unicode.IsLetter(r)
hasPunct = hasPunct || unicode.IsPunct(r)
onlyNumber = onlyNumber && isNumber
if isLetter {
low := unicode.ToLower(r)
onlyHexLetter = onlyHexLetter && low <= 'f'
}
}
if hasPunct {
return true
}
if !onlyHexLetter {
return true
}
num, err := strconv.ParseInt(s, 10, 64)
if err == nil {
if num > 100 {
return false // numeric revision.
}
}
if len(s) > 5 && onlyHexLetter {
return false // hex revision
}
return true
}
|
go
|
func isVersion(s string) bool {
hasPunct := false
onlyNumber := true
onlyHexLetter := true
for _, r := range s {
isNumber := unicode.IsNumber(r)
isLetter := unicode.IsLetter(r)
hasPunct = hasPunct || unicode.IsPunct(r)
onlyNumber = onlyNumber && isNumber
if isLetter {
low := unicode.ToLower(r)
onlyHexLetter = onlyHexLetter && low <= 'f'
}
}
if hasPunct {
return true
}
if !onlyHexLetter {
return true
}
num, err := strconv.ParseInt(s, 10, 64)
if err == nil {
if num > 100 {
return false // numeric revision.
}
}
if len(s) > 5 && onlyHexLetter {
return false // hex revision
}
return true
}
|
[
"func",
"isVersion",
"(",
"s",
"string",
")",
"bool",
"{",
"hasPunct",
":=",
"false",
"\n",
"onlyNumber",
":=",
"true",
"\n",
"onlyHexLetter",
":=",
"true",
"\n",
"for",
"_",
",",
"r",
":=",
"range",
"s",
"{",
"isNumber",
":=",
"unicode",
".",
"IsNumber",
"(",
"r",
")",
"\n",
"isLetter",
":=",
"unicode",
".",
"IsLetter",
"(",
"r",
")",
"\n\n",
"hasPunct",
"=",
"hasPunct",
"||",
"unicode",
".",
"IsPunct",
"(",
"r",
")",
"\n",
"onlyNumber",
"=",
"onlyNumber",
"&&",
"isNumber",
"\n\n",
"if",
"isLetter",
"{",
"low",
":=",
"unicode",
".",
"ToLower",
"(",
"r",
")",
"\n",
"onlyHexLetter",
"=",
"onlyHexLetter",
"&&",
"low",
"<=",
"'f'",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"hasPunct",
"{",
"return",
"true",
"\n",
"}",
"\n",
"if",
"!",
"onlyHexLetter",
"{",
"return",
"true",
"\n",
"}",
"\n\n",
"num",
",",
"err",
":=",
"strconv",
".",
"ParseInt",
"(",
"s",
",",
"10",
",",
"64",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"if",
"num",
">",
"100",
"{",
"return",
"false",
"// numeric revision.",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"s",
")",
">",
"5",
"&&",
"onlyHexLetter",
"{",
"return",
"false",
"// hex revision",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] |
// IsVersion returns true if the string is a version.
|
[
"IsVersion",
"returns",
"true",
"if",
"the",
"string",
"is",
"a",
"version",
"."
] |
d0fd0db8a43d4b87c2ce416f60ae78407f3f3c62
|
https://github.com/kardianos/govendor/blob/d0fd0db8a43d4b87c2ce416f60ae78407f3f3c62/context/version.go#L13-L47
|
146,587 |
kardianos/govendor
|
context/path.go
|
isStdLib
|
func (ctx *Context) isStdLib(importPath string) (yes bool, err error) {
if importPath == "builtin" || importPath == "unsafe" || importPath == "C" {
yes = true
return
}
dir := filepath.Join(ctx.Goroot, importPath)
fi, _ := os.Stat(dir)
if fi == nil {
return
}
if !fi.IsDir() {
return
}
yes, err = hasGoFileInFolder(dir)
return
}
|
go
|
func (ctx *Context) isStdLib(importPath string) (yes bool, err error) {
if importPath == "builtin" || importPath == "unsafe" || importPath == "C" {
yes = true
return
}
dir := filepath.Join(ctx.Goroot, importPath)
fi, _ := os.Stat(dir)
if fi == nil {
return
}
if !fi.IsDir() {
return
}
yes, err = hasGoFileInFolder(dir)
return
}
|
[
"func",
"(",
"ctx",
"*",
"Context",
")",
"isStdLib",
"(",
"importPath",
"string",
")",
"(",
"yes",
"bool",
",",
"err",
"error",
")",
"{",
"if",
"importPath",
"==",
"\"",
"\"",
"||",
"importPath",
"==",
"\"",
"\"",
"||",
"importPath",
"==",
"\"",
"\"",
"{",
"yes",
"=",
"true",
"\n",
"return",
"\n",
"}",
"\n\n",
"dir",
":=",
"filepath",
".",
"Join",
"(",
"ctx",
".",
"Goroot",
",",
"importPath",
")",
"\n",
"fi",
",",
"_",
":=",
"os",
".",
"Stat",
"(",
"dir",
")",
"\n",
"if",
"fi",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"if",
"!",
"fi",
".",
"IsDir",
"(",
")",
"{",
"return",
"\n",
"}",
"\n\n",
"yes",
",",
"err",
"=",
"hasGoFileInFolder",
"(",
"dir",
")",
"\n",
"return",
"\n",
"}"
] |
// Import path is in GOROOT or is a special package.
|
[
"Import",
"path",
"is",
"in",
"GOROOT",
"or",
"is",
"a",
"special",
"package",
"."
] |
d0fd0db8a43d4b87c2ce416f60ae78407f3f3c62
|
https://github.com/kardianos/govendor/blob/d0fd0db8a43d4b87c2ce416f60ae78407f3f3c62/context/path.go#L16-L33
|
146,588 |
kardianos/govendor
|
context/path.go
|
findImportDir
|
func (ctx *Context) findImportDir(relative, importPath string) (dir, gopath string, err error) {
if importPath == "builtin" || importPath == "unsafe" || importPath == "C" {
return filepath.Join(ctx.Goroot, importPath), ctx.Goroot, nil
}
if len(relative) != 0 {
rel := relative
for {
look := filepath.Join(rel, ctx.VendorDiscoverFolder, importPath)
nextRel := filepath.Join(rel, "..")
if rel == nextRel {
break
}
rel = nextRel
fi, err := os.Stat(look)
if os.IsNotExist(err) {
continue
}
if err != nil {
continue
}
if !fi.IsDir() {
continue
}
for _, gopath = range ctx.GopathList {
if pathos.FileHasPrefix(look, gopath) {
hasGo, err := hasGoFileInFolder(look)
if err != nil {
return "", "", err
}
if hasGo {
return look, gopath, nil
}
}
}
}
}
for _, gopath = range ctx.GopathList {
dir := filepath.Join(gopath, importPath)
fi, err := os.Stat(dir)
if os.IsNotExist(err) {
continue
}
if fi == nil {
continue
}
if !fi.IsDir() {
continue
}
return dir, gopath, nil
}
return "", "", ErrNotInGOPATH{importPath}
}
|
go
|
func (ctx *Context) findImportDir(relative, importPath string) (dir, gopath string, err error) {
if importPath == "builtin" || importPath == "unsafe" || importPath == "C" {
return filepath.Join(ctx.Goroot, importPath), ctx.Goroot, nil
}
if len(relative) != 0 {
rel := relative
for {
look := filepath.Join(rel, ctx.VendorDiscoverFolder, importPath)
nextRel := filepath.Join(rel, "..")
if rel == nextRel {
break
}
rel = nextRel
fi, err := os.Stat(look)
if os.IsNotExist(err) {
continue
}
if err != nil {
continue
}
if !fi.IsDir() {
continue
}
for _, gopath = range ctx.GopathList {
if pathos.FileHasPrefix(look, gopath) {
hasGo, err := hasGoFileInFolder(look)
if err != nil {
return "", "", err
}
if hasGo {
return look, gopath, nil
}
}
}
}
}
for _, gopath = range ctx.GopathList {
dir := filepath.Join(gopath, importPath)
fi, err := os.Stat(dir)
if os.IsNotExist(err) {
continue
}
if fi == nil {
continue
}
if !fi.IsDir() {
continue
}
return dir, gopath, nil
}
return "", "", ErrNotInGOPATH{importPath}
}
|
[
"func",
"(",
"ctx",
"*",
"Context",
")",
"findImportDir",
"(",
"relative",
",",
"importPath",
"string",
")",
"(",
"dir",
",",
"gopath",
"string",
",",
"err",
"error",
")",
"{",
"if",
"importPath",
"==",
"\"",
"\"",
"||",
"importPath",
"==",
"\"",
"\"",
"||",
"importPath",
"==",
"\"",
"\"",
"{",
"return",
"filepath",
".",
"Join",
"(",
"ctx",
".",
"Goroot",
",",
"importPath",
")",
",",
"ctx",
".",
"Goroot",
",",
"nil",
"\n",
"}",
"\n",
"if",
"len",
"(",
"relative",
")",
"!=",
"0",
"{",
"rel",
":=",
"relative",
"\n",
"for",
"{",
"look",
":=",
"filepath",
".",
"Join",
"(",
"rel",
",",
"ctx",
".",
"VendorDiscoverFolder",
",",
"importPath",
")",
"\n",
"nextRel",
":=",
"filepath",
".",
"Join",
"(",
"rel",
",",
"\"",
"\"",
")",
"\n",
"if",
"rel",
"==",
"nextRel",
"{",
"break",
"\n",
"}",
"\n",
"rel",
"=",
"nextRel",
"\n",
"fi",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"look",
")",
"\n",
"if",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"!",
"fi",
".",
"IsDir",
"(",
")",
"{",
"continue",
"\n",
"}",
"\n",
"for",
"_",
",",
"gopath",
"=",
"range",
"ctx",
".",
"GopathList",
"{",
"if",
"pathos",
".",
"FileHasPrefix",
"(",
"look",
",",
"gopath",
")",
"{",
"hasGo",
",",
"err",
":=",
"hasGoFileInFolder",
"(",
"look",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"if",
"hasGo",
"{",
"return",
"look",
",",
"gopath",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"}",
"\n",
"for",
"_",
",",
"gopath",
"=",
"range",
"ctx",
".",
"GopathList",
"{",
"dir",
":=",
"filepath",
".",
"Join",
"(",
"gopath",
",",
"importPath",
")",
"\n",
"fi",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"dir",
")",
"\n",
"if",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"fi",
"==",
"nil",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"!",
"fi",
".",
"IsDir",
"(",
")",
"{",
"continue",
"\n",
"}",
"\n\n",
"return",
"dir",
",",
"gopath",
",",
"nil",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
",",
"\"",
"\"",
",",
"ErrNotInGOPATH",
"{",
"importPath",
"}",
"\n",
"}"
] |
// findImportDir finds the absolute directory. If rel is empty vendor folders
// are not looked in.
|
[
"findImportDir",
"finds",
"the",
"absolute",
"directory",
".",
"If",
"rel",
"is",
"empty",
"vendor",
"folders",
"are",
"not",
"looked",
"in",
"."
] |
d0fd0db8a43d4b87c2ce416f60ae78407f3f3c62
|
https://github.com/kardianos/govendor/blob/d0fd0db8a43d4b87c2ce416f60ae78407f3f3c62/context/path.go#L37-L90
|
146,589 |
kardianos/govendor
|
context/path.go
|
findImportPath
|
func (ctx *Context) findImportPath(dir string) (importPath, gopath string, err error) {
dirResolved, err := filepath.EvalSymlinks(dir)
if err != nil {
return "", "", err
}
dirs := make([]string, 1)
dirs = append(dirs, dir)
if dir != dirResolved {
dirs = append(dirs, dirResolved)
}
for _, gopath := range ctx.GopathList {
for _, dir := range dirs {
if pathos.FileHasPrefix(dir, gopath) || pathos.FileStringEquals(dir, gopath) {
importPath = pathos.FileTrimPrefix(dir, gopath)
importPath = pathos.SlashToImportPath(importPath)
return importPath, gopath, nil
}
}
}
return "", "", ErrNotInGOPATH{dir}
}
|
go
|
func (ctx *Context) findImportPath(dir string) (importPath, gopath string, err error) {
dirResolved, err := filepath.EvalSymlinks(dir)
if err != nil {
return "", "", err
}
dirs := make([]string, 1)
dirs = append(dirs, dir)
if dir != dirResolved {
dirs = append(dirs, dirResolved)
}
for _, gopath := range ctx.GopathList {
for _, dir := range dirs {
if pathos.FileHasPrefix(dir, gopath) || pathos.FileStringEquals(dir, gopath) {
importPath = pathos.FileTrimPrefix(dir, gopath)
importPath = pathos.SlashToImportPath(importPath)
return importPath, gopath, nil
}
}
}
return "", "", ErrNotInGOPATH{dir}
}
|
[
"func",
"(",
"ctx",
"*",
"Context",
")",
"findImportPath",
"(",
"dir",
"string",
")",
"(",
"importPath",
",",
"gopath",
"string",
",",
"err",
"error",
")",
"{",
"dirResolved",
",",
"err",
":=",
"filepath",
".",
"EvalSymlinks",
"(",
"dir",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"dirs",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"1",
")",
"\n",
"dirs",
"=",
"append",
"(",
"dirs",
",",
"dir",
")",
"\n",
"if",
"dir",
"!=",
"dirResolved",
"{",
"dirs",
"=",
"append",
"(",
"dirs",
",",
"dirResolved",
")",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"gopath",
":=",
"range",
"ctx",
".",
"GopathList",
"{",
"for",
"_",
",",
"dir",
":=",
"range",
"dirs",
"{",
"if",
"pathos",
".",
"FileHasPrefix",
"(",
"dir",
",",
"gopath",
")",
"||",
"pathos",
".",
"FileStringEquals",
"(",
"dir",
",",
"gopath",
")",
"{",
"importPath",
"=",
"pathos",
".",
"FileTrimPrefix",
"(",
"dir",
",",
"gopath",
")",
"\n",
"importPath",
"=",
"pathos",
".",
"SlashToImportPath",
"(",
"importPath",
")",
"\n",
"return",
"importPath",
",",
"gopath",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
",",
"\"",
"\"",
",",
"ErrNotInGOPATH",
"{",
"dir",
"}",
"\n",
"}"
] |
// findImportPath takes a absolute directory and returns the import path and go path.
|
[
"findImportPath",
"takes",
"a",
"absolute",
"directory",
"and",
"returns",
"the",
"import",
"path",
"and",
"go",
"path",
"."
] |
d0fd0db8a43d4b87c2ce416f60ae78407f3f3c62
|
https://github.com/kardianos/govendor/blob/d0fd0db8a43d4b87c2ce416f60ae78407f3f3c62/context/path.go#L93-L114
|
146,590 |
kardianos/govendor
|
context/path.go
|
RemovePackage
|
func RemovePackage(path, root string, tree bool) error {
// Ensure the path is empty of files.
dir, err := os.Open(path)
if err != nil {
if os.IsNotExist(err) {
return nil
}
return err
}
// Remove package files.
fl, err := dir.Readdir(-1)
dir.Close()
if err != nil {
return err
}
for _, fi := range fl {
fullPath := filepath.Join(path, fi.Name())
if fi.IsDir() {
if tree {
// If tree == true then remove sub-directories too.
err = os.RemoveAll(fullPath)
if err != nil {
return err
}
}
continue
}
err = os.Remove(fullPath)
if err != nil {
return err
}
}
// Remove empty parent folders.
// Ignore errors here.
for i := 0; i <= looplimit; i++ {
if pathos.FileStringEquals(path, root) {
return nil
}
dir, err := os.Open(path)
if err != nil {
// fmt.Fprintf(os.Stderr, "Failedd to open directory %q: %v\n", path, err)
return nil
}
fl, err := dir.Readdir(1)
dir.Close()
if err != nil && err != io.EOF {
// fmt.Fprintf(os.Stderr, "Failedd to list directory %q: %v\n", path, err)
return nil
}
if len(fl) > 0 {
allAreLicense := true
for _, fi := range fl {
if !isLicenseFile(fi.Name()) {
allAreLicense = false
break
}
}
if !allAreLicense {
return nil
}
}
err = os.RemoveAll(path)
if err != nil {
// fmt.Fprintf(os.Stderr, "Failedd to remove empty directory %q: %v\n", path, err)
return nil
}
nextPath := filepath.Clean(filepath.Join(path, ".."))
// Check for root.
if nextPath == path {
return nil
}
path = nextPath
}
panic("removePackage() remove parent folders")
}
|
go
|
func RemovePackage(path, root string, tree bool) error {
// Ensure the path is empty of files.
dir, err := os.Open(path)
if err != nil {
if os.IsNotExist(err) {
return nil
}
return err
}
// Remove package files.
fl, err := dir.Readdir(-1)
dir.Close()
if err != nil {
return err
}
for _, fi := range fl {
fullPath := filepath.Join(path, fi.Name())
if fi.IsDir() {
if tree {
// If tree == true then remove sub-directories too.
err = os.RemoveAll(fullPath)
if err != nil {
return err
}
}
continue
}
err = os.Remove(fullPath)
if err != nil {
return err
}
}
// Remove empty parent folders.
// Ignore errors here.
for i := 0; i <= looplimit; i++ {
if pathos.FileStringEquals(path, root) {
return nil
}
dir, err := os.Open(path)
if err != nil {
// fmt.Fprintf(os.Stderr, "Failedd to open directory %q: %v\n", path, err)
return nil
}
fl, err := dir.Readdir(1)
dir.Close()
if err != nil && err != io.EOF {
// fmt.Fprintf(os.Stderr, "Failedd to list directory %q: %v\n", path, err)
return nil
}
if len(fl) > 0 {
allAreLicense := true
for _, fi := range fl {
if !isLicenseFile(fi.Name()) {
allAreLicense = false
break
}
}
if !allAreLicense {
return nil
}
}
err = os.RemoveAll(path)
if err != nil {
// fmt.Fprintf(os.Stderr, "Failedd to remove empty directory %q: %v\n", path, err)
return nil
}
nextPath := filepath.Clean(filepath.Join(path, ".."))
// Check for root.
if nextPath == path {
return nil
}
path = nextPath
}
panic("removePackage() remove parent folders")
}
|
[
"func",
"RemovePackage",
"(",
"path",
",",
"root",
"string",
",",
"tree",
"bool",
")",
"error",
"{",
"// Ensure the path is empty of files.",
"dir",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"// Remove package files.",
"fl",
",",
"err",
":=",
"dir",
".",
"Readdir",
"(",
"-",
"1",
")",
"\n",
"dir",
".",
"Close",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"for",
"_",
",",
"fi",
":=",
"range",
"fl",
"{",
"fullPath",
":=",
"filepath",
".",
"Join",
"(",
"path",
",",
"fi",
".",
"Name",
"(",
")",
")",
"\n",
"if",
"fi",
".",
"IsDir",
"(",
")",
"{",
"if",
"tree",
"{",
"// If tree == true then remove sub-directories too.",
"err",
"=",
"os",
".",
"RemoveAll",
"(",
"fullPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"continue",
"\n",
"}",
"\n",
"err",
"=",
"os",
".",
"Remove",
"(",
"fullPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Remove empty parent folders.",
"// Ignore errors here.",
"for",
"i",
":=",
"0",
";",
"i",
"<=",
"looplimit",
";",
"i",
"++",
"{",
"if",
"pathos",
".",
"FileStringEquals",
"(",
"path",
",",
"root",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"dir",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// fmt.Fprintf(os.Stderr, \"Failedd to open directory %q: %v\\n\", path, err)",
"return",
"nil",
"\n",
"}",
"\n\n",
"fl",
",",
"err",
":=",
"dir",
".",
"Readdir",
"(",
"1",
")",
"\n",
"dir",
".",
"Close",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"err",
"!=",
"io",
".",
"EOF",
"{",
"// fmt.Fprintf(os.Stderr, \"Failedd to list directory %q: %v\\n\", path, err)",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"len",
"(",
"fl",
")",
">",
"0",
"{",
"allAreLicense",
":=",
"true",
"\n",
"for",
"_",
",",
"fi",
":=",
"range",
"fl",
"{",
"if",
"!",
"isLicenseFile",
"(",
"fi",
".",
"Name",
"(",
")",
")",
"{",
"allAreLicense",
"=",
"false",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"!",
"allAreLicense",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"err",
"=",
"os",
".",
"RemoveAll",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// fmt.Fprintf(os.Stderr, \"Failedd to remove empty directory %q: %v\\n\", path, err)",
"return",
"nil",
"\n",
"}",
"\n",
"nextPath",
":=",
"filepath",
".",
"Clean",
"(",
"filepath",
".",
"Join",
"(",
"path",
",",
"\"",
"\"",
")",
")",
"\n",
"// Check for root.",
"if",
"nextPath",
"==",
"path",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"path",
"=",
"nextPath",
"\n",
"}",
"\n",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}"
] |
// RemovePackage removes the specified folder files. If folder is empty when
// done (no nested folders, remove the folder and any empty parent folders.
|
[
"RemovePackage",
"removes",
"the",
"specified",
"folder",
"files",
".",
"If",
"folder",
"is",
"empty",
"when",
"done",
"(",
"no",
"nested",
"folders",
"remove",
"the",
"folder",
"and",
"any",
"empty",
"parent",
"folders",
"."
] |
d0fd0db8a43d4b87c2ce416f60ae78407f3f3c62
|
https://github.com/kardianos/govendor/blob/d0fd0db8a43d4b87c2ce416f60ae78407f3f3c62/context/path.go#L158-L235
|
146,591 |
kardianos/govendor
|
internal/gt/vcs.go
|
Setup
|
func (h *HttpHandler) Setup() VcsHandle {
vcs := h.newer(h)
vcs.create()
h.g.onClean(vcs.remove)
h.handles[vcs.pkg()] = vcs
return vcs
}
|
go
|
func (h *HttpHandler) Setup() VcsHandle {
vcs := h.newer(h)
vcs.create()
h.g.onClean(vcs.remove)
h.handles[vcs.pkg()] = vcs
return vcs
}
|
[
"func",
"(",
"h",
"*",
"HttpHandler",
")",
"Setup",
"(",
")",
"VcsHandle",
"{",
"vcs",
":=",
"h",
".",
"newer",
"(",
"h",
")",
"\n",
"vcs",
".",
"create",
"(",
")",
"\n",
"h",
".",
"g",
".",
"onClean",
"(",
"vcs",
".",
"remove",
")",
"\n\n",
"h",
".",
"handles",
"[",
"vcs",
".",
"pkg",
"(",
")",
"]",
"=",
"vcs",
"\n",
"return",
"vcs",
"\n",
"}"
] |
// Setup returns type with Remove function that can be defer'ed.
|
[
"Setup",
"returns",
"type",
"with",
"Remove",
"function",
"that",
"can",
"be",
"defer",
"ed",
"."
] |
d0fd0db8a43d4b87c2ce416f60ae78407f3f3c62
|
https://github.com/kardianos/govendor/blob/d0fd0db8a43d4b87c2ce416f60ae78407f3f3c62/internal/gt/vcs.go#L65-L72
|
146,592 |
kardianos/govendor
|
context/resolve.go
|
loadPackage
|
func (ctx *Context) loadPackage() error {
ctx.loaded = true
ctx.dirty = false
ctx.statusCache = nil
ctx.Package = make(map[string]*Package, len(ctx.Package))
// We following the root symlink only in case the root of the repo is symlinked into the GOPATH
// This could happen during on some CI that didn't checkout into the GOPATH
rootdir, err := filepath.EvalSymlinks(ctx.RootDir)
if err != nil {
return err
}
err = filepath.Walk(rootdir, func(path string, info os.FileInfo, err error) error {
if info == nil {
return err
}
if !info.IsDir() {
// We replace the directory path (followed by the symlink), to the real go repo package name/path
// ex : replace "<somewhere>/govendor.source.repo" to "github.com/kardianos/govendor"
path = strings.Replace(path, rootdir, ctx.RootDir, 1)
_, err = ctx.addFileImports(path, ctx.RootGopath)
return err
}
name := info.Name()
// Still go into "_workspace" to aid godep migration.
if name == "_workspace" {
return nil
}
switch name[0] {
case '.', '_':
return filepath.SkipDir
}
switch name {
case "testdata", "node_modules":
return filepath.SkipDir
}
return nil
})
if err != nil {
return err
}
// Finally, set any unset status.
return ctx.determinePackageStatus()
}
|
go
|
func (ctx *Context) loadPackage() error {
ctx.loaded = true
ctx.dirty = false
ctx.statusCache = nil
ctx.Package = make(map[string]*Package, len(ctx.Package))
// We following the root symlink only in case the root of the repo is symlinked into the GOPATH
// This could happen during on some CI that didn't checkout into the GOPATH
rootdir, err := filepath.EvalSymlinks(ctx.RootDir)
if err != nil {
return err
}
err = filepath.Walk(rootdir, func(path string, info os.FileInfo, err error) error {
if info == nil {
return err
}
if !info.IsDir() {
// We replace the directory path (followed by the symlink), to the real go repo package name/path
// ex : replace "<somewhere>/govendor.source.repo" to "github.com/kardianos/govendor"
path = strings.Replace(path, rootdir, ctx.RootDir, 1)
_, err = ctx.addFileImports(path, ctx.RootGopath)
return err
}
name := info.Name()
// Still go into "_workspace" to aid godep migration.
if name == "_workspace" {
return nil
}
switch name[0] {
case '.', '_':
return filepath.SkipDir
}
switch name {
case "testdata", "node_modules":
return filepath.SkipDir
}
return nil
})
if err != nil {
return err
}
// Finally, set any unset status.
return ctx.determinePackageStatus()
}
|
[
"func",
"(",
"ctx",
"*",
"Context",
")",
"loadPackage",
"(",
")",
"error",
"{",
"ctx",
".",
"loaded",
"=",
"true",
"\n",
"ctx",
".",
"dirty",
"=",
"false",
"\n",
"ctx",
".",
"statusCache",
"=",
"nil",
"\n",
"ctx",
".",
"Package",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"Package",
",",
"len",
"(",
"ctx",
".",
"Package",
")",
")",
"\n",
"// We following the root symlink only in case the root of the repo is symlinked into the GOPATH",
"// This could happen during on some CI that didn't checkout into the GOPATH",
"rootdir",
",",
"err",
":=",
"filepath",
".",
"EvalSymlinks",
"(",
"ctx",
".",
"RootDir",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"err",
"=",
"filepath",
".",
"Walk",
"(",
"rootdir",
",",
"func",
"(",
"path",
"string",
",",
"info",
"os",
".",
"FileInfo",
",",
"err",
"error",
")",
"error",
"{",
"if",
"info",
"==",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"!",
"info",
".",
"IsDir",
"(",
")",
"{",
"// We replace the directory path (followed by the symlink), to the real go repo package name/path",
"// ex : replace \"<somewhere>/govendor.source.repo\" to \"github.com/kardianos/govendor\"",
"path",
"=",
"strings",
".",
"Replace",
"(",
"path",
",",
"rootdir",
",",
"ctx",
".",
"RootDir",
",",
"1",
")",
"\n",
"_",
",",
"err",
"=",
"ctx",
".",
"addFileImports",
"(",
"path",
",",
"ctx",
".",
"RootGopath",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"name",
":=",
"info",
".",
"Name",
"(",
")",
"\n",
"// Still go into \"_workspace\" to aid godep migration.",
"if",
"name",
"==",
"\"",
"\"",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"switch",
"name",
"[",
"0",
"]",
"{",
"case",
"'.'",
",",
"'_'",
":",
"return",
"filepath",
".",
"SkipDir",
"\n",
"}",
"\n",
"switch",
"name",
"{",
"case",
"\"",
"\"",
",",
"\"",
"\"",
":",
"return",
"filepath",
".",
"SkipDir",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"// Finally, set any unset status.",
"return",
"ctx",
".",
"determinePackageStatus",
"(",
")",
"\n",
"}"
] |
// loadPackage sets up the context with package information and
// is called before any initial operation is performed.
|
[
"loadPackage",
"sets",
"up",
"the",
"context",
"with",
"package",
"information",
"and",
"is",
"called",
"before",
"any",
"initial",
"operation",
"is",
"performed",
"."
] |
d0fd0db8a43d4b87c2ce416f60ae78407f3f3c62
|
https://github.com/kardianos/govendor/blob/d0fd0db8a43d4b87c2ce416f60ae78407f3f3c62/context/resolve.go#L36-L78
|
146,593 |
kardianos/govendor
|
vcs/vcs.go
|
RegisterVCS
|
func RegisterVCS(vcs Vcs) {
registerSync.Lock()
defer registerSync.Unlock()
vcsRegistry = append(vcsRegistry, vcs)
}
|
go
|
func RegisterVCS(vcs Vcs) {
registerSync.Lock()
defer registerSync.Unlock()
vcsRegistry = append(vcsRegistry, vcs)
}
|
[
"func",
"RegisterVCS",
"(",
"vcs",
"Vcs",
")",
"{",
"registerSync",
".",
"Lock",
"(",
")",
"\n",
"defer",
"registerSync",
".",
"Unlock",
"(",
")",
"\n\n",
"vcsRegistry",
"=",
"append",
"(",
"vcsRegistry",
",",
"vcs",
")",
"\n",
"}"
] |
// RegisterVCS adds a new VCS to use.
|
[
"RegisterVCS",
"adds",
"a",
"new",
"VCS",
"to",
"use",
"."
] |
d0fd0db8a43d4b87c2ce416f60ae78407f3f3c62
|
https://github.com/kardianos/govendor/blob/d0fd0db8a43d4b87c2ce416f60ae78407f3f3c62/vcs/vcs.go#L38-L43
|
146,594 |
kardianos/govendor
|
vcs/vcs.go
|
FindVcs
|
func FindVcs(root, packageDir string) (info *VcsInfo, err error) {
if !filepath.IsAbs(root) {
return nil, nil
}
if !filepath.IsAbs(packageDir) {
return nil, nil
}
path := packageDir
for i := 0; i <= looplimit; i++ {
for _, vcs := range vcsRegistry {
info, err = vcs.Find(path)
if err != nil {
return nil, err
}
if info != nil {
return info, nil
}
}
nextPath := filepath.Clean(filepath.Join(path, ".."))
// Check for root.
if nextPath == path {
return nil, nil
}
if !pathos.FileHasPrefix(nextPath, root) {
return nil, nil
}
path = nextPath
}
panic("loop limit")
}
|
go
|
func FindVcs(root, packageDir string) (info *VcsInfo, err error) {
if !filepath.IsAbs(root) {
return nil, nil
}
if !filepath.IsAbs(packageDir) {
return nil, nil
}
path := packageDir
for i := 0; i <= looplimit; i++ {
for _, vcs := range vcsRegistry {
info, err = vcs.Find(path)
if err != nil {
return nil, err
}
if info != nil {
return info, nil
}
}
nextPath := filepath.Clean(filepath.Join(path, ".."))
// Check for root.
if nextPath == path {
return nil, nil
}
if !pathos.FileHasPrefix(nextPath, root) {
return nil, nil
}
path = nextPath
}
panic("loop limit")
}
|
[
"func",
"FindVcs",
"(",
"root",
",",
"packageDir",
"string",
")",
"(",
"info",
"*",
"VcsInfo",
",",
"err",
"error",
")",
"{",
"if",
"!",
"filepath",
".",
"IsAbs",
"(",
"root",
")",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"if",
"!",
"filepath",
".",
"IsAbs",
"(",
"packageDir",
")",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"path",
":=",
"packageDir",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<=",
"looplimit",
";",
"i",
"++",
"{",
"for",
"_",
",",
"vcs",
":=",
"range",
"vcsRegistry",
"{",
"info",
",",
"err",
"=",
"vcs",
".",
"Find",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"info",
"!=",
"nil",
"{",
"return",
"info",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n\n",
"nextPath",
":=",
"filepath",
".",
"Clean",
"(",
"filepath",
".",
"Join",
"(",
"path",
",",
"\"",
"\"",
")",
")",
"\n",
"// Check for root.",
"if",
"nextPath",
"==",
"path",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"if",
"!",
"pathos",
".",
"FileHasPrefix",
"(",
"nextPath",
",",
"root",
")",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"path",
"=",
"nextPath",
"\n",
"}",
"\n",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}"
] |
// FindVcs determines the version control information given a package dir and
// lowest root dir.
|
[
"FindVcs",
"determines",
"the",
"version",
"control",
"information",
"given",
"a",
"package",
"dir",
"and",
"lowest",
"root",
"dir",
"."
] |
d0fd0db8a43d4b87c2ce416f60ae78407f3f3c62
|
https://github.com/kardianos/govendor/blob/d0fd0db8a43d4b87c2ce416f60ae78407f3f3c62/vcs/vcs.go#L49-L79
|
146,595 |
kardianos/govendor
|
migrate/migrate.go
|
MigrateWD
|
func MigrateWD(from From) error {
wd, err := os.Getwd()
if err != nil {
return err
}
return Migrate(from, wd)
}
|
go
|
func MigrateWD(from From) error {
wd, err := os.Getwd()
if err != nil {
return err
}
return Migrate(from, wd)
}
|
[
"func",
"MigrateWD",
"(",
"from",
"From",
")",
"error",
"{",
"wd",
",",
"err",
":=",
"os",
".",
"Getwd",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"Migrate",
"(",
"from",
",",
"wd",
")",
"\n",
"}"
] |
// Migrate from the given system using the current working directory.
|
[
"Migrate",
"from",
"the",
"given",
"system",
"using",
"the",
"current",
"working",
"directory",
"."
] |
d0fd0db8a43d4b87c2ce416f60ae78407f3f3c62
|
https://github.com/kardianos/govendor/blob/d0fd0db8a43d4b87c2ce416f60ae78407f3f3c62/migrate/migrate.go#L30-L36
|
146,596 |
kardianos/govendor
|
migrate/migrate.go
|
SystemList
|
func SystemList() []string {
list := make([]string, 0, len(registered))
for key := range registered {
list = append(list, string(key))
}
sort.Strings(list)
return list
}
|
go
|
func SystemList() []string {
list := make([]string, 0, len(registered))
for key := range registered {
list = append(list, string(key))
}
sort.Strings(list)
return list
}
|
[
"func",
"SystemList",
"(",
")",
"[",
"]",
"string",
"{",
"list",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"registered",
")",
")",
"\n",
"for",
"key",
":=",
"range",
"registered",
"{",
"list",
"=",
"append",
"(",
"list",
",",
"string",
"(",
"key",
")",
")",
"\n",
"}",
"\n",
"sort",
".",
"Strings",
"(",
"list",
")",
"\n",
"return",
"list",
"\n",
"}"
] |
// SystemList list available migration systems.
|
[
"SystemList",
"list",
"available",
"migration",
"systems",
"."
] |
d0fd0db8a43d4b87c2ce416f60ae78407f3f3c62
|
https://github.com/kardianos/govendor/blob/d0fd0db8a43d4b87c2ce416f60ae78407f3f3c62/migrate/migrate.go#L39-L46
|
146,597 |
kardianos/govendor
|
migrate/migrate.go
|
Migrate
|
func Migrate(from From, root string) error {
sys, found := registered[from]
if !found {
return ErrNoSuchSystem{
NotExist: string(from),
Has: SystemList(),
}
}
sys, err := sys.Check(root)
if err != nil {
return err
}
if sys == nil {
return errors.New("Root not found.")
}
return sys.Migrate(root)
}
|
go
|
func Migrate(from From, root string) error {
sys, found := registered[from]
if !found {
return ErrNoSuchSystem{
NotExist: string(from),
Has: SystemList(),
}
}
sys, err := sys.Check(root)
if err != nil {
return err
}
if sys == nil {
return errors.New("Root not found.")
}
return sys.Migrate(root)
}
|
[
"func",
"Migrate",
"(",
"from",
"From",
",",
"root",
"string",
")",
"error",
"{",
"sys",
",",
"found",
":=",
"registered",
"[",
"from",
"]",
"\n",
"if",
"!",
"found",
"{",
"return",
"ErrNoSuchSystem",
"{",
"NotExist",
":",
"string",
"(",
"from",
")",
",",
"Has",
":",
"SystemList",
"(",
")",
",",
"}",
"\n",
"}",
"\n",
"sys",
",",
"err",
":=",
"sys",
".",
"Check",
"(",
"root",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"sys",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"sys",
".",
"Migrate",
"(",
"root",
")",
"\n",
"}"
] |
// Migrate from the given system using the given root.
|
[
"Migrate",
"from",
"the",
"given",
"system",
"using",
"the",
"given",
"root",
"."
] |
d0fd0db8a43d4b87c2ce416f60ae78407f3f3c62
|
https://github.com/kardianos/govendor/blob/d0fd0db8a43d4b87c2ce416f60ae78407f3f3c62/migrate/migrate.go#L49-L65
|
146,598 |
kardianos/govendor
|
run/run.go
|
Run
|
func Run(w io.Writer, appArgs []string, ask prompt.Prompt) (help.HelpMessage, error) {
r := &runner{}
return r.run(w, appArgs, ask)
}
|
go
|
func Run(w io.Writer, appArgs []string, ask prompt.Prompt) (help.HelpMessage, error) {
r := &runner{}
return r.run(w, appArgs, ask)
}
|
[
"func",
"Run",
"(",
"w",
"io",
".",
"Writer",
",",
"appArgs",
"[",
"]",
"string",
",",
"ask",
"prompt",
".",
"Prompt",
")",
"(",
"help",
".",
"HelpMessage",
",",
"error",
")",
"{",
"r",
":=",
"&",
"runner",
"{",
"}",
"\n",
"return",
"r",
".",
"run",
"(",
"w",
",",
"appArgs",
",",
"ask",
")",
"\n",
"}"
] |
// Run is isoloated from main and os.Args to help with testing.
// Shouldn't directly print to console, just write through w.
|
[
"Run",
"is",
"isoloated",
"from",
"main",
"and",
"os",
".",
"Args",
"to",
"help",
"with",
"testing",
".",
"Shouldn",
"t",
"directly",
"print",
"to",
"console",
"just",
"write",
"through",
"w",
"."
] |
d0fd0db8a43d4b87c2ce416f60ae78407f3f3c62
|
https://github.com/kardianos/govendor/blob/d0fd0db8a43d4b87c2ce416f60ae78407f3f3c62/run/run.go#L42-L45
|
146,599 |
kardianos/govendor
|
context/license.go
|
licenseWalk
|
func licenseWalk(root, startIn string, found func(folder, name string) error) error {
folder := startIn
for i := 0; i <= looplimit; i++ {
dir, err := os.Open(folder)
if err != nil {
return err
}
fl, err := dir.Readdir(-1)
dir.Close()
if err != nil {
return err
}
for _, fi := range fl {
name := fi.Name()
if name[0] == '.' {
continue
}
if fi.IsDir() {
continue
}
if !isLicenseFile(name) {
continue
}
err = found(folder, name)
if err != nil {
return err
}
}
if len(folder) <= len(root) {
return nil
}
nextFolder := filepath.Clean(filepath.Join(folder, ".."))
if nextFolder == folder {
return nil
}
folder = nextFolder
}
panic("licenseFind loop limit")
}
|
go
|
func licenseWalk(root, startIn string, found func(folder, name string) error) error {
folder := startIn
for i := 0; i <= looplimit; i++ {
dir, err := os.Open(folder)
if err != nil {
return err
}
fl, err := dir.Readdir(-1)
dir.Close()
if err != nil {
return err
}
for _, fi := range fl {
name := fi.Name()
if name[0] == '.' {
continue
}
if fi.IsDir() {
continue
}
if !isLicenseFile(name) {
continue
}
err = found(folder, name)
if err != nil {
return err
}
}
if len(folder) <= len(root) {
return nil
}
nextFolder := filepath.Clean(filepath.Join(folder, ".."))
if nextFolder == folder {
return nil
}
folder = nextFolder
}
panic("licenseFind loop limit")
}
|
[
"func",
"licenseWalk",
"(",
"root",
",",
"startIn",
"string",
",",
"found",
"func",
"(",
"folder",
",",
"name",
"string",
")",
"error",
")",
"error",
"{",
"folder",
":=",
"startIn",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<=",
"looplimit",
";",
"i",
"++",
"{",
"dir",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"folder",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"fl",
",",
"err",
":=",
"dir",
".",
"Readdir",
"(",
"-",
"1",
")",
"\n",
"dir",
".",
"Close",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"for",
"_",
",",
"fi",
":=",
"range",
"fl",
"{",
"name",
":=",
"fi",
".",
"Name",
"(",
")",
"\n",
"if",
"name",
"[",
"0",
"]",
"==",
"'.'",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"fi",
".",
"IsDir",
"(",
")",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"!",
"isLicenseFile",
"(",
"name",
")",
"{",
"continue",
"\n",
"}",
"\n\n",
"err",
"=",
"found",
"(",
"folder",
",",
"name",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"folder",
")",
"<=",
"len",
"(",
"root",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"nextFolder",
":=",
"filepath",
".",
"Clean",
"(",
"filepath",
".",
"Join",
"(",
"folder",
",",
"\"",
"\"",
")",
")",
"\n\n",
"if",
"nextFolder",
"==",
"folder",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"folder",
"=",
"nextFolder",
"\n",
"}",
"\n",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}"
] |
// licenseWalk starts in a folder and searches up the folder tree
// for license like files. Found files are reported to the found function.
|
[
"licenseWalk",
"starts",
"in",
"a",
"folder",
"and",
"searches",
"up",
"the",
"folder",
"tree",
"for",
"license",
"like",
"files",
".",
"Found",
"files",
"are",
"reported",
"to",
"the",
"found",
"function",
"."
] |
d0fd0db8a43d4b87c2ce416f60ae78407f3f3c62
|
https://github.com/kardianos/govendor/blob/d0fd0db8a43d4b87c2ce416f60ae78407f3f3c62/context/license.go#L110-L153
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.