_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q16400 | SetVolume | train | func (c *Client) SetVolume(volume int) error {
return c.Command("setvol %d", volume).OK()
} | go | {
"resource": ""
} |
q16401 | PlaylistInfo | train | func (c *Client) PlaylistInfo(start, end int) ([]Attrs, error) {
var cmd *Command
switch {
case start < 0 && end < 0:
// Request all playlist items.
cmd = c.Command("playlistinfo")
case start >= 0 && end >= 0:
// Request this range of playlist items.
cmd = c.Command("playlistinfo %d:%d", start, end)
case start >= 0 && end < 0:
// Request the single playlist item at this position.
cmd = c.Command("playlistinfo %d", start)
case start < 0 && end >= 0:
return nil, errors.New("negative start index")
default:
panic("unreachable")
}
return cmd.AttrsList("file")
} | go | {
"resource": ""
} |
q16402 | SetPriority | train | func (c *Client) SetPriority(priority, start, end int) error {
switch {
case start < 0 && end < 0:
return errors.New("negative start and end index")
case start >= 0 && end >= 0:
// Update the prio for this range of playlist items.
return c.Command("prio %d %d:%d", priority, start, end).OK()
case start >= 0 && end < 0:
// Update the prio for a single playlist item at this position.
return c.Command("prio %d %d", priority, start).OK()
case start < 0 && end >= 0:
return errors.New("negative start index")
default:
panic("unreachable")
}
} | go | {
"resource": ""
} |
q16403 | SetPriorityID | train | func (c *Client) SetPriorityID(priority, id int) error {
return c.Command("prioid %d %d", priority, id).OK()
} | go | {
"resource": ""
} |
q16404 | Delete | train | func (c *Client) Delete(start, end int) error {
if start < 0 {
return errors.New("negative start index")
}
if end < 0 {
return c.Command("delete %d", start).OK()
}
return c.Command("delete %d:%d", start, end).OK()
} | go | {
"resource": ""
} |
q16405 | Move | train | func (c *Client) Move(start, end, position int) error {
if start < 0 {
return errors.New("negative start index")
}
if end < 0 {
return c.Command("move %d %d", start, position).OK()
}
return c.Command("move %d:%d %d", start, end, position).OK()
} | go | {
"resource": ""
} |
q16406 | MoveID | train | func (c *Client) MoveID(songid, position int) error {
return c.Command("moveid %d %d", songid, position).OK()
} | go | {
"resource": ""
} |
q16407 | Search | train | func (c *Client) Search(args ...string) ([]Attrs, error) {
return c.Command("search " + quoteArgs(args)).AttrsList("file")
} | go | {
"resource": ""
} |
q16408 | EnableOutput | train | func (c *Client) EnableOutput(id int) error {
return c.Command("enableoutput %d", id).OK()
} | go | {
"resource": ""
} |
q16409 | DisableOutput | train | func (c *Client) DisableOutput(id int) error {
return c.Command("disableoutput %d", id).OK()
} | go | {
"resource": ""
} |
q16410 | PlaylistContents | train | func (c *Client) PlaylistContents(name string) ([]Attrs, error) {
return c.Command("listplaylistinfo %s", name).AttrsList("file")
} | go | {
"resource": ""
} |
q16411 | PlaylistLoad | train | func (c *Client) PlaylistLoad(name string, start, end int) error {
if start < 0 || end < 0 {
return c.Command("load %s", name).OK()
}
return c.Command("load %s %d:%d", name, start, end).OK()
} | go | {
"resource": ""
} |
q16412 | PlaylistAdd | train | func (c *Client) PlaylistAdd(name string, uri string) error {
return c.Command("playlistadd %s %s", name, uri).OK()
} | go | {
"resource": ""
} |
q16413 | PlaylistClear | train | func (c *Client) PlaylistClear(name string) error {
return c.Command("playlistclear %s", name).OK()
} | go | {
"resource": ""
} |
q16414 | PlaylistMove | train | func (c *Client) PlaylistMove(name string, id, pos int) error {
return c.Command("playlistmove %s %d %d", name, id, pos).OK()
} | go | {
"resource": ""
} |
q16415 | PlaylistRename | train | func (c *Client) PlaylistRename(name, newName string) error {
return c.Command("rename %s %s", name, newName).OK()
} | go | {
"resource": ""
} |
q16416 | PlaylistRemove | train | func (c *Client) PlaylistRemove(name string) error {
return c.Command("rm %s", name).OK()
} | go | {
"resource": ""
} |
q16417 | PlaylistSave | train | func (c *Client) PlaylistSave(name string) error {
return c.Command("save %s", name).OK()
} | go | {
"resource": ""
} |
q16418 | StickerFind | train | func (c *Client) StickerFind(uri string, name string) ([]string, []Sticker, error) {
attrs, err := c.Command("sticker find song %s %s", uri, name).AttrsList("file")
if err != nil {
return nil, nil, err
}
files := make([]string, len(attrs))
stks := make([]Sticker, len(attrs))
for i, attr := range attrs {
if _, ok := attr["file"]; !ok {
return nil, nil, textproto.ProtocolError("file attribute not found")
}
if _, ok := attr["sticker"]; !ok {
return nil, nil, textproto.ProtocolError("sticker attribute not found")
}
files[i] = attr["file"]
stk, err := parseSticker(attr["sticker"])
if err != nil {
return nil, nil, err
}
stks[i] = *stk
}
return files, stks, nil
} | go | {
"resource": ""
} |
q16419 | StickerGet | train | func (c *Client) StickerGet(uri string, name string) (*Sticker, error) {
attrs, err := c.Command("sticker get song %s %s", uri, name).Attrs()
if err != nil {
return nil, err
}
attr, ok := attrs["sticker"]
if !ok {
return nil, textproto.ProtocolError("sticker not found")
}
stk, err := parseSticker(attr)
if stk == nil {
return nil, err
}
return stk, nil
} | go | {
"resource": ""
} |
q16420 | StickerList | train | func (c *Client) StickerList(uri string) ([]Sticker, error) {
attrs, err := c.Command("sticker list song %s", uri).AttrsList("sticker")
if err != nil {
return nil, err
}
stks := make([]Sticker, len(attrs))
for i, attr := range attrs {
s, ok := attr["sticker"]
if !ok {
return nil, textproto.ProtocolError("sticker attribute not found")
}
stk, err := parseSticker(s)
if err != nil {
return nil, err
}
stks[i] = *stk
}
return stks, nil
} | go | {
"resource": ""
} |
q16421 | StickerSet | train | func (c *Client) StickerSet(uri string, name string, value string) error {
return c.Command("sticker set song %s %s %s", uri, name, value).OK()
} | go | {
"resource": ""
} |
q16422 | Value | train | func (pa *PromisedAttrs) Value() (Attrs, error) {
if !pa.computed {
return nil, errors.New("value has not been computed yet")
}
return pa.attrs, nil
} | go | {
"resource": ""
} |
q16423 | Value | train | func (pi *PromisedID) Value() (int, error) {
if *pi == -1 {
return -1, errors.New("value has not been computed yet")
}
return (int)(*pi), nil
} | go | {
"resource": ""
} |
q16424 | CurrentSong | train | func (cl *CommandList) CurrentSong() *PromisedAttrs {
pa := newPromisedAttrs()
cl.cmdQ.PushBack(&command{"currentsong", pa, cmdAttrReturn})
return pa
} | go | {
"resource": ""
} |
q16425 | PlayID | train | func (cl *CommandList) PlayID(id int) {
if id < 0 {
cl.cmdQ.PushBack(&command{"playid", nil, cmdNoReturn})
} else {
cl.cmdQ.PushBack(&command{fmt.Sprintf("playid %d", id), nil, cmdNoReturn})
}
} | go | {
"resource": ""
} |
q16426 | SetVolume | train | func (cl *CommandList) SetVolume(volume int) {
cl.cmdQ.PushBack(&command{fmt.Sprintf("setvol %d", volume), nil, cmdNoReturn})
} | go | {
"resource": ""
} |
q16427 | SetPriority | train | func (cl *CommandList) SetPriority(priority, start, end int) error {
if start < 0 {
return errors.New("negative start index")
}
if end < 0 {
cl.cmdQ.PushBack(&command{fmt.Sprintf("prio %d %d", priority, start), nil, cmdNoReturn})
} else {
cl.cmdQ.PushBack(&command{fmt.Sprintf("prio %d %d:%d", priority, start, end), nil, cmdNoReturn})
}
return nil
} | go | {
"resource": ""
} |
q16428 | SetPriorityID | train | func (cl *CommandList) SetPriorityID(priority, id int) {
cl.cmdQ.PushBack(&command{fmt.Sprintf("prioid %d %d", priority, id), nil, cmdNoReturn})
} | go | {
"resource": ""
} |
q16429 | MoveID | train | func (cl *CommandList) MoveID(songid, position int) {
cl.cmdQ.PushBack(&command{fmt.Sprintf("moveid %d %d", songid, position), nil, cmdNoReturn})
} | go | {
"resource": ""
} |
q16430 | PlaylistLoad | train | func (cl *CommandList) PlaylistLoad(name string, start, end int) {
if start < 0 || end < 0 {
cl.cmdQ.PushBack(&command{fmt.Sprintf("load %s", quote(name)), nil, cmdNoReturn})
} else {
cl.cmdQ.PushBack(&command{fmt.Sprintf("load %s %d:%d", quote(name), start, end), nil, cmdNoReturn})
}
} | go | {
"resource": ""
} |
q16431 | End | train | func (cl *CommandList) End() error {
// Tell MPD to start an OK command list:
beginID, beginErr := cl.client.cmd("command_list_ok_begin")
if beginErr != nil {
return beginErr
}
cl.client.text.StartResponse(beginID)
cl.client.text.EndResponse(beginID)
// Ensure the queue is cleared regardless.
defer cl.cmdQ.Init()
// Issue all of the queued up commands in the list:
for e := cl.cmdQ.Front(); e != nil; e = e.Next() {
cmdID, cmdErr := cl.client.cmd(e.Value.(*command).cmd)
if cmdErr != nil {
return cmdErr
}
cl.client.text.StartResponse(cmdID)
cl.client.text.EndResponse(cmdID)
}
// Tell MPD to end the command list and do the operations.
endID, endErr := cl.client.cmd("command_list_end")
if endErr != nil {
return endErr
}
cl.client.text.StartResponse(endID)
defer cl.client.text.EndResponse(endID)
// Get the responses back and check for errors:
for e := cl.cmdQ.Front(); e != nil; e = e.Next() {
switch e.Value.(*command).typeOf {
case cmdNoReturn:
if err := cl.client.readOKLine("list_OK"); err != nil {
return err
}
case cmdAttrReturn:
a, aErr := cl.client.readAttrs("list_OK")
if aErr != nil {
return aErr
}
pa := e.Value.(*command).promise.(*PromisedAttrs)
pa.attrs = a
pa.computed = true
case cmdIDReturn:
a, aErr := cl.client.readAttrs("list_OK")
if aErr != nil {
return aErr
}
rid, ridErr := strconv.Atoi(a["Id"])
if ridErr != nil {
return ridErr
}
*(e.Value.(*command).promise.(*PromisedID)) = PromisedID(rid)
}
}
// Finalize the command list with the last OK:
return cl.client.readOKLine("OK")
} | go | {
"resource": ""
} |
q16432 | Command | train | func (c *Client) Command(format string, args ...interface{}) *Command {
for i := range args {
switch s := args[i].(type) {
case Quoted: // ignore
case string:
args[i] = quote(s)
}
}
return &Command{
client: c,
cmd: fmt.Sprintf(format, args...),
}
} | go | {
"resource": ""
} |
q16433 | OK | train | func (cmd *Command) OK() error {
id, err := cmd.client.cmd(cmd.cmd)
if err != nil {
return err
}
cmd.client.text.StartResponse(id)
defer cmd.client.text.EndResponse(id)
return cmd.client.readOKLine("OK")
} | go | {
"resource": ""
} |
q16434 | Attrs | train | func (cmd *Command) Attrs() (Attrs, error) {
id, err := cmd.client.cmd(cmd.cmd)
if err != nil {
return nil, err
}
cmd.client.text.StartResponse(id)
defer cmd.client.text.EndResponse(id)
return cmd.client.readAttrs("OK")
} | go | {
"resource": ""
} |
q16435 | AttrsList | train | func (cmd *Command) AttrsList(startKey string) ([]Attrs, error) {
id, err := cmd.client.cmd(cmd.cmd)
if err != nil {
return nil, err
}
cmd.client.text.StartResponse(id)
defer cmd.client.text.EndResponse(id)
return cmd.client.readAttrsList(startKey)
} | go | {
"resource": ""
} |
q16436 | Strings | train | func (cmd *Command) Strings(key string) ([]string, error) {
id, err := cmd.client.cmd(cmd.cmd)
if err != nil {
return nil, err
}
cmd.client.text.StartResponse(id)
defer cmd.client.text.EndResponse(id)
return cmd.client.readList(key)
} | go | {
"resource": ""
} |
q16437 | OnCount | train | func (l DebugListener) OnCount(name string, enabled bool) {
fmt.Printf("Counted '%s' as enabled? %v\n", name, enabled)
} | go | {
"resource": ""
} |
q16438 | WithRefreshInterval | train | func WithRefreshInterval(refreshInterval time.Duration) ConfigOption {
return func(o *configOption) {
o.refreshInterval = refreshInterval
}
} | go | {
"resource": ""
} |
q16439 | WithMetricsInterval | train | func WithMetricsInterval(metricsInterval time.Duration) ConfigOption {
return func(o *configOption) {
o.metricsInterval = metricsInterval
}
} | go | {
"resource": ""
} |
q16440 | WithHttpClient | train | func WithHttpClient(client *http.Client) ConfigOption {
return func(o *configOption) {
o.httpClient = client
}
} | go | {
"resource": ""
} |
q16441 | WithCustomHeaders | train | func WithCustomHeaders(headers http.Header) ConfigOption {
return func(o *configOption) {
o.customHeaders = headers
}
} | go | {
"resource": ""
} |
q16442 | WithContext | train | func WithContext(ctx context.Context) FeatureOption {
return func(opts *featureOption) {
opts.ctx = &ctx
}
} | go | {
"resource": ""
} |
q16443 | IsEnabled | train | func IsEnabled(feature string, options ...FeatureOption) bool {
return defaultClient.IsEnabled(feature, options...)
} | go | {
"resource": ""
} |
q16444 | IsEnabled | train | func (uc Client) IsEnabled(feature string, options ...FeatureOption) (enabled bool) {
defer func() {
uc.metrics.count(feature, enabled)
}()
f := uc.repository.getToggle(feature)
var opts featureOption
for _, o := range options {
o(&opts)
}
if f == nil {
if opts.fallback != nil {
return *opts.fallback
}
return false
}
if !f.Enabled {
return false
}
for _, s := range f.Strategies {
foundStrategy := uc.getStrategy(s.Name)
if foundStrategy == nil {
// TODO: warnOnce missingStrategy
continue
}
if foundStrategy.IsEnabled(s.Parameters, opts.ctx) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q16445 | Close | train | func (uc *Client) Close() error {
uc.repository.Close()
uc.metrics.Close()
uc.closed <- true
return nil
} | go | {
"resource": ""
} |
q16446 | Allowable | train | func Allowable(pattern string) (min, max string) {
if pattern == "" || pattern[0] == '*' {
return "", ""
}
minb := make([]byte, 0, len(pattern))
maxb := make([]byte, 0, len(pattern))
var wild bool
for i := 0; i < len(pattern); i++ {
if pattern[i] == '*' {
wild = true
break
}
if pattern[i] == '?' {
minb = append(minb, 0)
maxb = append(maxb, maxRuneBytes...)
} else {
minb = append(minb, pattern[i])
maxb = append(maxb, pattern[i])
}
}
if wild {
r, n := utf8.DecodeLastRune(maxb)
if r != utf8.RuneError {
if r < utf8.MaxRune {
r++
if r > 0x7f {
b := make([]byte, 4)
nn := utf8.EncodeRune(b, r)
maxb = append(maxb[:len(maxb)-n], b[:nn]...)
} else {
maxb = append(maxb[:len(maxb)-n], byte(r))
}
}
}
}
return string(minb), string(maxb)
} | go | {
"resource": ""
} |
q16447 | IsPattern | train | func IsPattern(str string) bool {
for i := 0; i < len(str); i++ {
if str[i] == '*' || str[i] == '?' {
return true
}
}
return false
} | go | {
"resource": ""
} |
q16448 | MarshalJSON | train | func (o Operation) MarshalJSON() ([]byte, error) {
type OpAlias Operation
switch o.Op {
case "select":
where := o.Where
if where == nil {
where = make([]interface{}, 0, 0)
}
return json.Marshal(&struct {
Where []interface{} `json:"where"`
OpAlias
}{
Where: where,
OpAlias: (OpAlias)(o),
})
default:
return json.Marshal(&struct {
OpAlias
}{
OpAlias: (OpAlias)(o),
})
}
} | go | {
"resource": ""
} |
q16449 | MarshalJSON | train | func (o OvsMap) MarshalJSON() ([]byte, error) {
var ovsMap, innerMap []interface{}
ovsMap = append(ovsMap, "map")
for key, val := range o.GoMap {
var mapSeg []interface{}
mapSeg = append(mapSeg, key)
mapSeg = append(mapSeg, val)
innerMap = append(innerMap, mapSeg)
}
ovsMap = append(ovsMap, innerMap)
return json.Marshal(ovsMap)
} | go | {
"resource": ""
} |
q16450 | UnmarshalJSON | train | func (o *OvsMap) UnmarshalJSON(b []byte) (err error) {
var oMap []interface{}
o.GoMap = make(map[interface{}]interface{})
if err := json.Unmarshal(b, &oMap); err == nil && len(oMap) > 1 {
innerSlice := oMap[1].([]interface{})
for _, val := range innerSlice {
f := val.([]interface{})
o.GoMap[f[0]] = f[1]
}
}
return err
} | go | {
"resource": ""
} |
q16451 | NewOvsMap | train | func NewOvsMap(goMap interface{}) (*OvsMap, error) {
v := reflect.ValueOf(goMap)
if v.Kind() != reflect.Map {
return nil, errors.New("OvsMap supports only Go Map types")
}
genMap := make(map[interface{}]interface{})
keys := v.MapKeys()
for _, key := range keys {
genMap[key.Interface()] = v.MapIndex(key).Interface()
}
return &OvsMap{genMap}, nil
} | go | {
"resource": ""
} |
q16452 | NewOvsSet | train | func NewOvsSet(goSlice interface{}) (*OvsSet, error) {
v := reflect.ValueOf(goSlice)
if v.Kind() != reflect.Slice {
return nil, errors.New("OvsSet supports only Go Slice types")
}
var ovsSet []interface{}
for i := 0; i < v.Len(); i++ {
ovsSet = append(ovsSet, v.Index(i).Interface())
}
return &OvsSet{ovsSet}, nil
} | go | {
"resource": ""
} |
q16453 | MarshalJSON | train | func (o OvsSet) MarshalJSON() ([]byte, error) {
var oSet []interface{}
oSet = append(oSet, "set")
oSet = append(oSet, o.GoSet)
return json.Marshal(oSet)
} | go | {
"resource": ""
} |
q16454 | UnmarshalJSON | train | func (o *OvsSet) UnmarshalJSON(b []byte) (err error) {
var oSet []interface{}
if err = json.Unmarshal(b, &oSet); err == nil && len(oSet) > 1 {
innerSet := oSet[1].([]interface{})
for _, val := range innerSet {
goVal, err := ovsSliceToGoNotation(val)
if err == nil {
o.GoSet = append(o.GoSet, goVal)
}
}
}
return err
} | go | {
"resource": ""
} |
q16455 | UnmarshalJSON | train | func (r *Row) UnmarshalJSON(b []byte) (err error) {
r.Fields = make(map[string]interface{})
var raw map[string]interface{}
err = json.Unmarshal(b, &raw)
for key, val := range raw {
val, err = ovsSliceToGoNotation(val)
if err != nil {
return err
}
r.Fields[key] = val
}
return err
} | go | {
"resource": ""
} |
q16456 | Print | train | func (schema DatabaseSchema) Print(w io.Writer) {
fmt.Fprintf(w, "%s, (%s)\n", schema.Name, schema.Version)
for table, tableSchema := range schema.Tables {
fmt.Fprintf(w, "\t %s\n", table)
for column, columnSchema := range tableSchema.Columns {
fmt.Fprintf(w, "\t\t %s => %v\n", column, columnSchema)
}
}
} | go | {
"resource": ""
} |
q16457 | validateOperations | train | func (schema DatabaseSchema) validateOperations(operations ...Operation) bool {
for _, op := range operations {
table, ok := schema.Tables[op.Table]
if ok {
for column := range op.Row {
if _, ok := table.Columns[column]; !ok {
return false
}
}
for _, row := range op.Rows {
for column := range row {
if _, ok := table.Columns[column]; !ok {
return false
}
}
}
for _, column := range op.Columns {
if _, ok := table.Columns[column]; !ok {
return false
}
}
} else {
return false
}
}
return true
} | go | {
"resource": ""
} |
q16458 | NewTransactArgs | train | func NewTransactArgs(database string, operations ...Operation) []interface{} {
dbSlice := make([]interface{}, 1)
dbSlice[0] = database
opsSlice := make([]interface{}, len(operations))
for i, d := range operations {
opsSlice[i] = d
}
ops := append(dbSlice, opsSlice...)
return ops
} | go | {
"resource": ""
} |
q16459 | NewMonitorArgs | train | func NewMonitorArgs(database string, value interface{}, requests map[string]MonitorRequest) []interface{} {
return []interface{}{database, value, requests}
} | go | {
"resource": ""
} |
q16460 | MarshalJSON | train | func (u UUID) MarshalJSON() ([]byte, error) {
var uuidSlice []string
err := u.validateUUID()
if err == nil {
uuidSlice = []string{"uuid", u.GoUUID}
} else {
uuidSlice = []string{"named-uuid", u.GoUUID}
}
return json.Marshal(uuidSlice)
} | go | {
"resource": ""
} |
q16461 | UnmarshalJSON | train | func (u *UUID) UnmarshalJSON(b []byte) (err error) {
var ovsUUID []string
if err := json.Unmarshal(b, &ovsUUID); err == nil {
u.GoUUID = ovsUUID[1]
}
return err
} | go | {
"resource": ""
} |
q16462 | ConnectUsingProtocol | train | func ConnectUsingProtocol(protocol string, target string) (*OvsdbClient, error) {
conn, err := net.Dial(protocol, target)
if err != nil {
return nil, err
}
c := rpc2.NewClientWithCodec(jsonrpc.NewJSONCodec(conn))
c.Handle("echo", echo)
c.Handle("update", update)
go c.Run()
go handleDisconnectNotification(c)
ovs := newOvsdbClient(c)
// Process Async Notifications
dbs, err := ovs.ListDbs()
if err == nil {
for _, db := range dbs {
schema, err := ovs.GetSchema(db)
if err == nil {
ovs.Schema[db] = *schema
} else {
return nil, err
}
}
}
return ovs, nil
} | go | {
"resource": ""
} |
q16463 | Connect | train | func Connect(ipAddr string, port int) (*OvsdbClient, error) {
if ipAddr == "" {
ipAddr = DefaultAddress
}
if port <= 0 {
port = DefaultPort
}
target := fmt.Sprintf("%s:%d", ipAddr, port)
return ConnectUsingProtocol("tcp", target)
} | go | {
"resource": ""
} |
q16464 | ConnectWithUnixSocket | train | func ConnectWithUnixSocket(socketFile string) (*OvsdbClient, error) {
if _, err := os.Stat(socketFile); os.IsNotExist(err) {
return nil, errors.New("Invalid socket file")
}
return ConnectUsingProtocol("unix", socketFile)
} | go | {
"resource": ""
} |
q16465 | Register | train | func (ovs *OvsdbClient) Register(handler NotificationHandler) {
ovs.handlersMutex.Lock()
defer ovs.handlersMutex.Unlock()
ovs.handlers = append(ovs.handlers, handler)
} | go | {
"resource": ""
} |
q16466 | getHandlerIndex | train | func getHandlerIndex(handler NotificationHandler, handlers []NotificationHandler) (int, error) {
for i, h := range handlers {
if reflect.DeepEqual(h, handler) {
return i, nil
}
}
return -1, errors.New("Handler not found")
} | go | {
"resource": ""
} |
q16467 | Unregister | train | func (ovs *OvsdbClient) Unregister(handler NotificationHandler) error {
ovs.handlersMutex.Lock()
defer ovs.handlersMutex.Unlock()
i, err := getHandlerIndex(handler, ovs.handlers)
if err != nil {
return err
}
ovs.handlers = append(ovs.handlers[:i], ovs.handlers[i+1:]...)
return nil
} | go | {
"resource": ""
} |
q16468 | Init | train | func (e *AutoEscapeExtension) Init(env *stick.Env) error {
env.Visitors = append(env.Visitors, &autoEscapeVisitor{})
env.Filters["escape"] = func(ctx stick.Context, val stick.Value, args ...stick.Value) stick.Value {
ct := "html"
if len(args) > 0 {
ct = stick.CoerceString(args[0])
}
if sval, ok := val.(stick.SafeValue); ok {
if sval.IsSafe(ct) {
return val
}
}
escfn, ok := e.Escapers[ct]
if !ok {
// TODO: Communicate error, no escaper for the specified content type.
return val
}
return stick.NewSafeValue(escfn(stick.CoerceString(val)), ct)
}
return nil
} | go | {
"resource": ""
} |
q16469 | NewAutoEscapeExtension | train | func NewAutoEscapeExtension() *AutoEscapeExtension {
return &AutoEscapeExtension{
Escapers: map[string]Escaper{
"html": escape.HTML,
"html_attr": escape.HTMLAttribute,
"js": escape.JS,
"css": escape.CSS,
"url": escape.URLQueryParam,
},
}
} | go | {
"resource": ""
} |
q16470 | push | train | func (v *autoEscapeVisitor) push(name string) {
v.stack = append(v.stack, name)
} | go | {
"resource": ""
} |
q16471 | pop | train | func (v *autoEscapeVisitor) pop() {
v.stack = v.stack[0 : len(v.stack)-1]
} | go | {
"resource": ""
} |
q16472 | newState | train | func newState(name string, out io.Writer, ctx map[string]Value, env *Env) *state {
return &state{
out: out,
node: nil,
name: name,
meta: &metadata{make(map[string]string)},
blocks: make([]map[string]*parse.BlockNode, 0),
macros: make(map[string]*parse.MacroNode),
env: env,
scope: &scopeStack{[]map[string]Value{ctx}},
}
} | go | {
"resource": ""
} |
q16473 | push | train | func (s *scopeStack) push() {
s.scopes = append(s.scopes, make(map[string]Value))
} | go | {
"resource": ""
} |
q16474 | pop | train | func (s *scopeStack) pop() {
s.scopes = s.scopes[0 : len(s.scopes)-1]
} | go | {
"resource": ""
} |
q16475 | All | train | func (s *scopeStack) All() map[string]Value {
res := make(map[string]Value)
for _, scope := range s.scopes {
for k, v := range scope {
res[k] = v
}
}
return res
} | go | {
"resource": ""
} |
q16476 | getBlock | train | func (s *state) getBlock(name string) *parse.BlockNode {
for _, blocks := range s.blocks {
if block, ok := blocks[name]; ok {
return block
}
}
return nil
} | go | {
"resource": ""
} |
q16477 | walkChild | train | func (s *state) walkChild(node parse.Node) error {
switch node := node.(type) {
case *parse.BodyNode:
for _, c := range node.All() {
err := s.walkChild(c)
if err != nil {
return err
}
}
case *parse.UseNode:
return s.walkUseNode(node)
}
return nil
} | go | {
"resource": ""
} |
q16478 | walkIncludeNode | train | func (s *state) walkIncludeNode(node *parse.IncludeNode) (tpl string, ctx map[string]Value, err error) {
ctx = make(map[string]Value)
v, err := s.evalExpr(node.Tpl)
if err != nil {
return "", nil, err
}
tpl = CoerceString(v)
var with Value
if n := node.With; n != nil {
with, err = s.evalExpr(n)
// TODO: Assert "with" is a hash?
if err != nil {
return "", nil, err
}
}
if !node.Only {
ctx = s.scope.All()
}
if with != nil {
if with, ok := with.(map[string]Value); ok {
for k, v := range with {
ctx[k] = v
}
}
}
return tpl, ctx, err
} | go | {
"resource": ""
} |
q16479 | execute | train | func execute(name string, out io.Writer, ctx map[string]Value, env *Env) error {
if ctx == nil {
ctx = make(map[string]Value)
}
s := newState(name, out, ctx, env)
tree, err := s.env.load(name)
if err != nil {
return err
}
s.blocks = append(s.blocks, tree.Blocks())
err = s.walk(tree.Root())
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q16480 | load | train | func (env *Env) load(name string) (*parse.Tree, error) {
tpl, err := env.Loader.Load(name)
if err != nil {
return nil, err
}
tree := parse.NewNamedTree(name, tpl.Contents())
tree.Visitors = append(tree.Visitors, env.Visitors...)
err = tree.Parse()
if err != nil {
return nil, err
}
return tree, nil
} | go | {
"resource": ""
} |
q16481 | HTML | train | func HTML(in string) string {
var out = &bytes.Buffer{}
for _, c := range in {
if c == 34 {
// "
out.WriteString(""")
} else if c == 38 {
// &
out.WriteString("&")
} else if c == 39 {
// '
out.WriteString("'")
} else if c == 60 {
// <
out.WriteString("<")
} else if c == 62 {
// >
out.WriteString(">")
} else {
// UTF-8
out.WriteRune(c)
}
}
return out.String()
} | go | {
"resource": ""
} |
q16482 | HTMLAttribute | train | func HTMLAttribute(in string) string {
var out = &bytes.Buffer{}
for _, c := range in {
if (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || (c >= 48 && c <= 57) || (c >= 44 && c <= 46) || c == 95 {
// a-zA-Z0-9,.-_
out.WriteRune(c)
} else if c == 34 {
// "
out.WriteString(""")
} else if c == 38 {
// &
out.WriteString("&")
} else if c == 60 {
// <
out.WriteString("<")
} else if c == 62 {
// >
out.WriteString(">")
} else if c <= 31 && c != 9 && c != 10 && c != 13 {
// Non-whitespace
out.WriteString("�")
} else {
// UTF-8
fmt.Fprintf(out, "&#%d;", c)
}
}
return out.String()
} | go | {
"resource": ""
} |
q16483 | JS | train | func JS(in string) string {
var out = &bytes.Buffer{}
for _, c := range in {
if (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || (c >= 48 && c <= 57) || c == 44 || c == 46 || c == 95 {
// a-zA-Z0-9,._
out.WriteRune(c)
} else {
// UTF-8
fmt.Fprintf(out, "\\u%04X", c)
}
}
return out.String()
} | go | {
"resource": ""
} |
q16484 | URLQueryParam | train | func URLQueryParam(in string) string {
var out = &bytes.Buffer{}
var c byte
for i := 0; i < len(in); i++ {
c = in[i]
if (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || (c >= 48 && c <= 57) || c == 45 || c == 46 || c == 126 || c == 95 {
// a-zA-Z0-9-._~
out.WriteByte(c)
} else {
// UTF-8
fmt.Fprintf(out, "%%%02X", c)
}
}
return out.String()
} | go | {
"resource": ""
} |
q16485 | parseTag | train | func (t *Tree) parseTag() (Node, error) {
name, err := t.expect(tokenName)
if err != nil {
return nil, err
}
switch name.value {
case "extends":
return parseExtends(t, name.Pos)
case "block":
return parseBlock(t, name.Pos)
case "if", "elseif":
return parseIf(t, name.Pos)
case "for":
return parseFor(t, name.Pos)
case "include":
return parseInclude(t, name.Pos)
case "embed":
return parseEmbed(t, name.Pos)
case "use":
return parseUse(t, name.Pos)
case "set":
return parseSet(t, name.Pos)
case "do":
return parseDo(t, name.Pos)
case "filter":
return parseFilter(t, name.Pos)
case "macro":
return parseMacro(t, name.Pos)
case "import":
return parseImport(t, name.Pos)
case "from":
return parseFrom(t, name.Pos)
default:
return nil, newUnexpectedTokenError(name)
}
} | go | {
"resource": ""
} |
q16486 | parseUntilEndTag | train | func (t *Tree) parseUntilEndTag(name string, start Pos) (*BodyNode, error) {
tok := t.peek()
if tok.tokenType == tokenEOF {
return nil, newUnclosedTagError(name, start)
}
n, err := t.parseUntilTag(start, "end"+name)
if err != nil {
return nil, err
}
_, err = t.expect(tokenTagClose)
if err != nil {
return nil, err
}
return n, nil
} | go | {
"resource": ""
} |
q16487 | parseUntilTag | train | func (t *Tree) parseUntilTag(start Pos, names ...string) (*BodyNode, error) {
n := NewBodyNode(start)
for {
switch tok := t.peek(); tok.tokenType {
case tokenEOF:
return n, newUnexpectedEOFError(tok)
case tokenTagOpen:
t.next()
tok, err := t.expect(tokenName)
if err != nil {
return n, err
}
if contains(names, tok.value) {
return n, nil
}
t.backup3()
o, err := t.parse()
if err != nil {
return n, err
}
n.Append(o)
default:
o, err := t.parse()
if err != nil {
return n, err
}
n.Append(o)
}
}
} | go | {
"resource": ""
} |
q16488 | parseInclude | train | func parseInclude(t *Tree, start Pos) (Node, error) {
expr, with, only, err := parseIncludeOrEmbed(t)
if err != nil {
return nil, err
}
return NewIncludeNode(expr, with, only, start), nil
} | go | {
"resource": ""
} |
q16489 | parseEmbed | train | func parseEmbed(t *Tree, start Pos) (Node, error) {
expr, with, only, err := parseIncludeOrEmbed(t)
if err != nil {
return nil, err
}
t.pushBlockStack()
for {
tok := t.nextNonSpace()
if tok.tokenType == tokenEOF {
return nil, newUnclosedTagError("embed", start)
} else if tok.tokenType == tokenTagOpen {
tok, err := t.expect(tokenName)
if err != nil {
return nil, err
}
if tok.value == "endembed" {
t.next()
_, err := t.expect(tokenTagClose)
if err != nil {
return nil, err
}
break
} else if tok.value == "block" {
n, err := parseBlock(t, start)
if err != nil {
return nil, err
}
if _, ok := n.(*BlockNode); !ok {
return nil, newUnexpectedTokenError(tok)
}
} else {
return nil, newUnexpectedValueError(tok, "endembed or block")
}
}
}
blockRefs := t.popBlockStack()
return NewEmbedNode(expr, with, only, blockRefs, start), nil
} | go | {
"resource": ""
} |
q16490 | NewNamedTree | train | func NewNamedTree(name string, input io.Reader) *Tree {
return &Tree{
lex: newLexer(input),
root: NewModuleNode(name),
blocks: []map[string]*BlockNode{make(map[string]*BlockNode)},
macros: make(map[string]*MacroNode),
unread: make([]token, 0),
read: make([]token, 0),
Name: name,
Visitors: make([]NodeVisitor, 0),
}
} | go | {
"resource": ""
} |
q16491 | Blocks | train | func (t *Tree) Blocks() map[string]*BlockNode {
return t.blocks[len(t.blocks)-1]
} | go | {
"resource": ""
} |
q16492 | peek | train | func (t *Tree) peek() token {
tok := t.next()
t.backup()
return tok
} | go | {
"resource": ""
} |
q16493 | peekNonSpace | train | func (t *Tree) peekNonSpace() token {
var next token
for {
next = t.next()
if next.tokenType != tokenWhitespace {
t.backup()
return next
}
}
} | go | {
"resource": ""
} |
q16494 | backup | train | func (t *Tree) backup() {
var tok token
tok, t.read = t.read[len(t.read)-1], t.read[:len(t.read)-1]
t.unread = append(t.unread, tok)
} | go | {
"resource": ""
} |
q16495 | next | train | func (t *Tree) next() token {
var tok token
if len(t.unread) > 0 {
tok, t.unread = t.unread[len(t.unread)-1], t.unread[:len(t.unread)-1]
} else {
tok = t.lex.nextToken()
}
t.read = append(t.read, tok)
return tok
} | go | {
"resource": ""
} |
q16496 | nextNonSpace | train | func (t *Tree) nextNonSpace() token {
var next token
for {
next = t.next()
if next.tokenType != tokenWhitespace || next.tokenType == tokenEOF {
return next
}
}
} | go | {
"resource": ""
} |
q16497 | expect | train | func (t *Tree) expect(typs ...tokenType) (token, error) {
tok := t.nextNonSpace()
for _, typ := range typs {
if tok.tokenType == typ {
return tok, nil
}
}
return tok, newUnexpectedTokenError(tok, typs...)
} | go | {
"resource": ""
} |
q16498 | expectValue | train | func (t *Tree) expectValue(typ tokenType, val string) (token, error) {
tok, err := t.expect(typ)
if err != nil {
return tok, err
}
if tok.value != val {
return tok, newUnexpectedValueError(tok, val)
}
return tok, nil
} | go | {
"resource": ""
} |
q16499 | enter | train | func (t *Tree) enter(n Node) {
for _, v := range t.Visitors {
v.Enter(n)
}
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.