repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
sequence | docstring
stringlengths 6
2.61k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 85
252
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
goadesign/goa | design/definitions.go | SetReadOnly | func (a *AttributeDefinition) SetReadOnly() {
if a.Metadata == nil {
a.Metadata = map[string][]string{}
}
a.Metadata["swagger:read-only"] = nil
} | go | func (a *AttributeDefinition) SetReadOnly() {
if a.Metadata == nil {
a.Metadata = map[string][]string{}
}
a.Metadata["swagger:read-only"] = nil
} | [
"func",
"(",
"a",
"*",
"AttributeDefinition",
")",
"SetReadOnly",
"(",
")",
"{",
"if",
"a",
".",
"Metadata",
"==",
"nil",
"{",
"a",
".",
"Metadata",
"=",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
"{",
"}",
"\n",
"}",
"\n",
"a",
".",
"Metadata",
"[",
"\"",
"\"",
"]",
"=",
"nil",
"\n",
"}"
] | // SetReadOnly sets the attribute's ReadOnly field as true. | [
"SetReadOnly",
"sets",
"the",
"attribute",
"s",
"ReadOnly",
"field",
"as",
"true",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/design/definitions.go#L1152-L1157 | train |
goadesign/goa | design/definitions.go | Merge | func (a *AttributeDefinition) Merge(other *AttributeDefinition) *AttributeDefinition {
if other == nil {
return a
}
if a == nil {
return other
}
left := a.Type.(Object)
right := other.Type.(Object)
if left == nil || right == nil {
panic("cannot merge non object attributes") // bug
}
for n, v := range right {
left[n] = v
}
if other.Validation != nil && len(other.Validation.Required) > 0 {
if a.Validation == nil {
a.Validation = &dslengine.ValidationDefinition{}
}
for _, r := range other.Validation.Required {
a.Validation.Required = append(a.Validation.Required, r)
}
}
return a
} | go | func (a *AttributeDefinition) Merge(other *AttributeDefinition) *AttributeDefinition {
if other == nil {
return a
}
if a == nil {
return other
}
left := a.Type.(Object)
right := other.Type.(Object)
if left == nil || right == nil {
panic("cannot merge non object attributes") // bug
}
for n, v := range right {
left[n] = v
}
if other.Validation != nil && len(other.Validation.Required) > 0 {
if a.Validation == nil {
a.Validation = &dslengine.ValidationDefinition{}
}
for _, r := range other.Validation.Required {
a.Validation.Required = append(a.Validation.Required, r)
}
}
return a
} | [
"func",
"(",
"a",
"*",
"AttributeDefinition",
")",
"Merge",
"(",
"other",
"*",
"AttributeDefinition",
")",
"*",
"AttributeDefinition",
"{",
"if",
"other",
"==",
"nil",
"{",
"return",
"a",
"\n",
"}",
"\n",
"if",
"a",
"==",
"nil",
"{",
"return",
"other",
"\n",
"}",
"\n",
"left",
":=",
"a",
".",
"Type",
".",
"(",
"Object",
")",
"\n",
"right",
":=",
"other",
".",
"Type",
".",
"(",
"Object",
")",
"\n",
"if",
"left",
"==",
"nil",
"||",
"right",
"==",
"nil",
"{",
"panic",
"(",
"\"",
"\"",
")",
"// bug",
"\n",
"}",
"\n",
"for",
"n",
",",
"v",
":=",
"range",
"right",
"{",
"left",
"[",
"n",
"]",
"=",
"v",
"\n",
"}",
"\n",
"if",
"other",
".",
"Validation",
"!=",
"nil",
"&&",
"len",
"(",
"other",
".",
"Validation",
".",
"Required",
")",
">",
"0",
"{",
"if",
"a",
".",
"Validation",
"==",
"nil",
"{",
"a",
".",
"Validation",
"=",
"&",
"dslengine",
".",
"ValidationDefinition",
"{",
"}",
"\n",
"}",
"\n",
"for",
"_",
",",
"r",
":=",
"range",
"other",
".",
"Validation",
".",
"Required",
"{",
"a",
".",
"Validation",
".",
"Required",
"=",
"append",
"(",
"a",
".",
"Validation",
".",
"Required",
",",
"r",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"a",
"\n",
"}"
] | // Merge merges the argument attributes into the target and returns the target overriding existing
// attributes with identical names.
// This only applies to attributes of type Object and Merge panics if the
// argument or the target is not of type Object. | [
"Merge",
"merges",
"the",
"argument",
"attributes",
"into",
"the",
"target",
"and",
"returns",
"the",
"target",
"overriding",
"existing",
"attributes",
"with",
"identical",
"names",
".",
"This",
"only",
"applies",
"to",
"attributes",
"of",
"type",
"Object",
"and",
"Merge",
"panics",
"if",
"the",
"argument",
"or",
"the",
"target",
"is",
"not",
"of",
"type",
"Object",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/design/definitions.go#L1243-L1267 | train |
goadesign/goa | design/definitions.go | Inherit | func (a *AttributeDefinition) Inherit(parent *AttributeDefinition, seen ...map[*AttributeDefinition]struct{}) {
if !a.shouldInherit(parent) {
return
}
a.inheritValidations(parent)
a.inheritRecursive(parent, seen...)
} | go | func (a *AttributeDefinition) Inherit(parent *AttributeDefinition, seen ...map[*AttributeDefinition]struct{}) {
if !a.shouldInherit(parent) {
return
}
a.inheritValidations(parent)
a.inheritRecursive(parent, seen...)
} | [
"func",
"(",
"a",
"*",
"AttributeDefinition",
")",
"Inherit",
"(",
"parent",
"*",
"AttributeDefinition",
",",
"seen",
"...",
"map",
"[",
"*",
"AttributeDefinition",
"]",
"struct",
"{",
"}",
")",
"{",
"if",
"!",
"a",
".",
"shouldInherit",
"(",
"parent",
")",
"{",
"return",
"\n",
"}",
"\n\n",
"a",
".",
"inheritValidations",
"(",
"parent",
")",
"\n",
"a",
".",
"inheritRecursive",
"(",
"parent",
",",
"seen",
"...",
")",
"\n",
"}"
] | // Inherit merges the properties of existing target type attributes with the argument's.
// The algorithm is recursive so that child attributes are also merged. | [
"Inherit",
"merges",
"the",
"properties",
"of",
"existing",
"target",
"type",
"attributes",
"with",
"the",
"argument",
"s",
".",
"The",
"algorithm",
"is",
"recursive",
"so",
"that",
"child",
"attributes",
"are",
"also",
"merged",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/design/definitions.go#L1271-L1278 | train |
goadesign/goa | design/definitions.go | Finalize | func (r *ResponseDefinition) Finalize() {
if r.Type == nil {
return
}
if r.MediaType != "" && r.MediaType != "text/plain" {
return
}
mt, ok := r.Type.(*MediaTypeDefinition)
if !ok {
return
}
r.MediaType = mt.Identifier
} | go | func (r *ResponseDefinition) Finalize() {
if r.Type == nil {
return
}
if r.MediaType != "" && r.MediaType != "text/plain" {
return
}
mt, ok := r.Type.(*MediaTypeDefinition)
if !ok {
return
}
r.MediaType = mt.Identifier
} | [
"func",
"(",
"r",
"*",
"ResponseDefinition",
")",
"Finalize",
"(",
")",
"{",
"if",
"r",
".",
"Type",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"if",
"r",
".",
"MediaType",
"!=",
"\"",
"\"",
"&&",
"r",
".",
"MediaType",
"!=",
"\"",
"\"",
"{",
"return",
"\n",
"}",
"\n",
"mt",
",",
"ok",
":=",
"r",
".",
"Type",
".",
"(",
"*",
"MediaTypeDefinition",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"\n",
"}",
"\n",
"r",
".",
"MediaType",
"=",
"mt",
".",
"Identifier",
"\n",
"}"
] | // Finalize sets the response media type from its type if the type is a media type and no media
// type is already specified. | [
"Finalize",
"sets",
"the",
"response",
"media",
"type",
"from",
"its",
"type",
"if",
"the",
"type",
"is",
"a",
"media",
"type",
"and",
"no",
"media",
"type",
"is",
"already",
"specified",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/design/definitions.go#L1405-L1417 | train |
goadesign/goa | design/definitions.go | Dup | func (r *ResponseDefinition) Dup() *ResponseDefinition {
res := ResponseDefinition{
Name: r.Name,
Status: r.Status,
Description: r.Description,
MediaType: r.MediaType,
ViewName: r.ViewName,
}
if r.Headers != nil {
res.Headers = DupAtt(r.Headers)
}
return &res
} | go | func (r *ResponseDefinition) Dup() *ResponseDefinition {
res := ResponseDefinition{
Name: r.Name,
Status: r.Status,
Description: r.Description,
MediaType: r.MediaType,
ViewName: r.ViewName,
}
if r.Headers != nil {
res.Headers = DupAtt(r.Headers)
}
return &res
} | [
"func",
"(",
"r",
"*",
"ResponseDefinition",
")",
"Dup",
"(",
")",
"*",
"ResponseDefinition",
"{",
"res",
":=",
"ResponseDefinition",
"{",
"Name",
":",
"r",
".",
"Name",
",",
"Status",
":",
"r",
".",
"Status",
",",
"Description",
":",
"r",
".",
"Description",
",",
"MediaType",
":",
"r",
".",
"MediaType",
",",
"ViewName",
":",
"r",
".",
"ViewName",
",",
"}",
"\n",
"if",
"r",
".",
"Headers",
"!=",
"nil",
"{",
"res",
".",
"Headers",
"=",
"DupAtt",
"(",
"r",
".",
"Headers",
")",
"\n",
"}",
"\n",
"return",
"&",
"res",
"\n",
"}"
] | // Dup returns a copy of the response definition. | [
"Dup",
"returns",
"a",
"copy",
"of",
"the",
"response",
"definition",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/design/definitions.go#L1420-L1432 | train |
goadesign/goa | design/definitions.go | Merge | func (r *ResponseDefinition) Merge(other *ResponseDefinition) {
if other == nil {
return
}
if r.Name == "" {
r.Name = other.Name
}
if r.Status == 0 {
r.Status = other.Status
}
if r.Description == "" {
r.Description = other.Description
}
if r.MediaType == "" {
r.MediaType = other.MediaType
r.ViewName = other.ViewName
}
if other.Headers != nil {
otherHeaders := other.Headers.Type.ToObject()
if len(otherHeaders) > 0 {
if r.Headers == nil {
r.Headers = &AttributeDefinition{Type: Object{}}
}
headers := r.Headers.Type.ToObject()
for n, h := range otherHeaders {
if _, ok := headers[n]; !ok {
headers[n] = h
}
}
}
}
} | go | func (r *ResponseDefinition) Merge(other *ResponseDefinition) {
if other == nil {
return
}
if r.Name == "" {
r.Name = other.Name
}
if r.Status == 0 {
r.Status = other.Status
}
if r.Description == "" {
r.Description = other.Description
}
if r.MediaType == "" {
r.MediaType = other.MediaType
r.ViewName = other.ViewName
}
if other.Headers != nil {
otherHeaders := other.Headers.Type.ToObject()
if len(otherHeaders) > 0 {
if r.Headers == nil {
r.Headers = &AttributeDefinition{Type: Object{}}
}
headers := r.Headers.Type.ToObject()
for n, h := range otherHeaders {
if _, ok := headers[n]; !ok {
headers[n] = h
}
}
}
}
} | [
"func",
"(",
"r",
"*",
"ResponseDefinition",
")",
"Merge",
"(",
"other",
"*",
"ResponseDefinition",
")",
"{",
"if",
"other",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"if",
"r",
".",
"Name",
"==",
"\"",
"\"",
"{",
"r",
".",
"Name",
"=",
"other",
".",
"Name",
"\n",
"}",
"\n",
"if",
"r",
".",
"Status",
"==",
"0",
"{",
"r",
".",
"Status",
"=",
"other",
".",
"Status",
"\n",
"}",
"\n",
"if",
"r",
".",
"Description",
"==",
"\"",
"\"",
"{",
"r",
".",
"Description",
"=",
"other",
".",
"Description",
"\n",
"}",
"\n",
"if",
"r",
".",
"MediaType",
"==",
"\"",
"\"",
"{",
"r",
".",
"MediaType",
"=",
"other",
".",
"MediaType",
"\n",
"r",
".",
"ViewName",
"=",
"other",
".",
"ViewName",
"\n",
"}",
"\n",
"if",
"other",
".",
"Headers",
"!=",
"nil",
"{",
"otherHeaders",
":=",
"other",
".",
"Headers",
".",
"Type",
".",
"ToObject",
"(",
")",
"\n",
"if",
"len",
"(",
"otherHeaders",
")",
">",
"0",
"{",
"if",
"r",
".",
"Headers",
"==",
"nil",
"{",
"r",
".",
"Headers",
"=",
"&",
"AttributeDefinition",
"{",
"Type",
":",
"Object",
"{",
"}",
"}",
"\n",
"}",
"\n",
"headers",
":=",
"r",
".",
"Headers",
".",
"Type",
".",
"ToObject",
"(",
")",
"\n",
"for",
"n",
",",
"h",
":=",
"range",
"otherHeaders",
"{",
"if",
"_",
",",
"ok",
":=",
"headers",
"[",
"n",
"]",
";",
"!",
"ok",
"{",
"headers",
"[",
"n",
"]",
"=",
"h",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Merge merges other into target. Only the fields of target that are not already set are merged. | [
"Merge",
"merges",
"other",
"into",
"target",
".",
"Only",
"the",
"fields",
"of",
"target",
"that",
"are",
"not",
"already",
"set",
"are",
"merged",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/design/definitions.go#L1435-L1466 | train |
goadesign/goa | design/definitions.go | PathParams | func (a *ActionDefinition) PathParams() *AttributeDefinition {
obj := make(Object)
allParams := a.AllParams().Type.ToObject()
for _, r := range a.Routes {
for _, p := range r.Params() {
if _, ok := obj[p]; !ok {
obj[p] = allParams[p]
}
}
}
return &AttributeDefinition{Type: obj}
} | go | func (a *ActionDefinition) PathParams() *AttributeDefinition {
obj := make(Object)
allParams := a.AllParams().Type.ToObject()
for _, r := range a.Routes {
for _, p := range r.Params() {
if _, ok := obj[p]; !ok {
obj[p] = allParams[p]
}
}
}
return &AttributeDefinition{Type: obj}
} | [
"func",
"(",
"a",
"*",
"ActionDefinition",
")",
"PathParams",
"(",
")",
"*",
"AttributeDefinition",
"{",
"obj",
":=",
"make",
"(",
"Object",
")",
"\n",
"allParams",
":=",
"a",
".",
"AllParams",
"(",
")",
".",
"Type",
".",
"ToObject",
"(",
")",
"\n",
"for",
"_",
",",
"r",
":=",
"range",
"a",
".",
"Routes",
"{",
"for",
"_",
",",
"p",
":=",
"range",
"r",
".",
"Params",
"(",
")",
"{",
"if",
"_",
",",
"ok",
":=",
"obj",
"[",
"p",
"]",
";",
"!",
"ok",
"{",
"obj",
"[",
"p",
"]",
"=",
"allParams",
"[",
"p",
"]",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"&",
"AttributeDefinition",
"{",
"Type",
":",
"obj",
"}",
"\n",
"}"
] | // PathParams returns the path parameters of the action across all its routes. | [
"PathParams",
"returns",
"the",
"path",
"parameters",
"of",
"the",
"action",
"across",
"all",
"its",
"routes",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/design/definitions.go#L1491-L1502 | train |
goadesign/goa | design/definitions.go | AllParams | func (a *ActionDefinition) AllParams() *AttributeDefinition {
var res *AttributeDefinition
if a.Params != nil {
res = DupAtt(a.Params)
} else {
res = &AttributeDefinition{Type: Object{}}
}
if a.HasAbsoluteRoutes() {
return res
}
res = res.Merge(a.Parent.Params)
if p := a.Parent.Parent(); p != nil {
res = res.Merge(p.CanonicalAction().PathParams())
} else {
res = res.Merge(a.Parent.PathParams())
}
return res.Merge(Design.Params)
} | go | func (a *ActionDefinition) AllParams() *AttributeDefinition {
var res *AttributeDefinition
if a.Params != nil {
res = DupAtt(a.Params)
} else {
res = &AttributeDefinition{Type: Object{}}
}
if a.HasAbsoluteRoutes() {
return res
}
res = res.Merge(a.Parent.Params)
if p := a.Parent.Parent(); p != nil {
res = res.Merge(p.CanonicalAction().PathParams())
} else {
res = res.Merge(a.Parent.PathParams())
}
return res.Merge(Design.Params)
} | [
"func",
"(",
"a",
"*",
"ActionDefinition",
")",
"AllParams",
"(",
")",
"*",
"AttributeDefinition",
"{",
"var",
"res",
"*",
"AttributeDefinition",
"\n",
"if",
"a",
".",
"Params",
"!=",
"nil",
"{",
"res",
"=",
"DupAtt",
"(",
"a",
".",
"Params",
")",
"\n",
"}",
"else",
"{",
"res",
"=",
"&",
"AttributeDefinition",
"{",
"Type",
":",
"Object",
"{",
"}",
"}",
"\n",
"}",
"\n",
"if",
"a",
".",
"HasAbsoluteRoutes",
"(",
")",
"{",
"return",
"res",
"\n",
"}",
"\n",
"res",
"=",
"res",
".",
"Merge",
"(",
"a",
".",
"Parent",
".",
"Params",
")",
"\n",
"if",
"p",
":=",
"a",
".",
"Parent",
".",
"Parent",
"(",
")",
";",
"p",
"!=",
"nil",
"{",
"res",
"=",
"res",
".",
"Merge",
"(",
"p",
".",
"CanonicalAction",
"(",
")",
".",
"PathParams",
"(",
")",
")",
"\n",
"}",
"else",
"{",
"res",
"=",
"res",
".",
"Merge",
"(",
"a",
".",
"Parent",
".",
"PathParams",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"res",
".",
"Merge",
"(",
"Design",
".",
"Params",
")",
"\n",
"}"
] | // AllParams returns the path and query string parameters of the action across all its routes. | [
"AllParams",
"returns",
"the",
"path",
"and",
"query",
"string",
"parameters",
"of",
"the",
"action",
"across",
"all",
"its",
"routes",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/design/definitions.go#L1505-L1522 | train |
goadesign/goa | design/definitions.go | HasAbsoluteRoutes | func (a *ActionDefinition) HasAbsoluteRoutes() bool {
for _, r := range a.Routes {
if !r.IsAbsolute() {
return false
}
}
return true
} | go | func (a *ActionDefinition) HasAbsoluteRoutes() bool {
for _, r := range a.Routes {
if !r.IsAbsolute() {
return false
}
}
return true
} | [
"func",
"(",
"a",
"*",
"ActionDefinition",
")",
"HasAbsoluteRoutes",
"(",
")",
"bool",
"{",
"for",
"_",
",",
"r",
":=",
"range",
"a",
".",
"Routes",
"{",
"if",
"!",
"r",
".",
"IsAbsolute",
"(",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] | // HasAbsoluteRoutes returns true if all the action routes are absolute. | [
"HasAbsoluteRoutes",
"returns",
"true",
"if",
"all",
"the",
"action",
"routes",
"are",
"absolute",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/design/definitions.go#L1525-L1532 | train |
goadesign/goa | design/definitions.go | CanonicalScheme | func (a *ActionDefinition) CanonicalScheme() string {
if a.WebSocket() {
for _, s := range a.EffectiveSchemes() {
if s == "wss" {
return s
}
}
return "ws"
}
for _, s := range a.EffectiveSchemes() {
if s == "https" {
return s
}
}
return "http"
} | go | func (a *ActionDefinition) CanonicalScheme() string {
if a.WebSocket() {
for _, s := range a.EffectiveSchemes() {
if s == "wss" {
return s
}
}
return "ws"
}
for _, s := range a.EffectiveSchemes() {
if s == "https" {
return s
}
}
return "http"
} | [
"func",
"(",
"a",
"*",
"ActionDefinition",
")",
"CanonicalScheme",
"(",
")",
"string",
"{",
"if",
"a",
".",
"WebSocket",
"(",
")",
"{",
"for",
"_",
",",
"s",
":=",
"range",
"a",
".",
"EffectiveSchemes",
"(",
")",
"{",
"if",
"s",
"==",
"\"",
"\"",
"{",
"return",
"s",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"for",
"_",
",",
"s",
":=",
"range",
"a",
".",
"EffectiveSchemes",
"(",
")",
"{",
"if",
"s",
"==",
"\"",
"\"",
"{",
"return",
"s",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
"\n",
"}"
] | // CanonicalScheme returns the preferred scheme for making requests. Favor secure schemes. | [
"CanonicalScheme",
"returns",
"the",
"preferred",
"scheme",
"for",
"making",
"requests",
".",
"Favor",
"secure",
"schemes",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/design/definitions.go#L1535-L1550 | train |
goadesign/goa | design/definitions.go | EffectiveSchemes | func (a *ActionDefinition) EffectiveSchemes() []string {
// Compute the schemes
schemes := a.Schemes
if len(schemes) == 0 {
res := a.Parent
schemes = res.Schemes
parent := res.Parent()
for len(schemes) == 0 && parent != nil {
schemes = parent.Schemes
parent = parent.Parent()
}
if len(schemes) == 0 {
schemes = Design.Schemes
}
}
return schemes
} | go | func (a *ActionDefinition) EffectiveSchemes() []string {
// Compute the schemes
schemes := a.Schemes
if len(schemes) == 0 {
res := a.Parent
schemes = res.Schemes
parent := res.Parent()
for len(schemes) == 0 && parent != nil {
schemes = parent.Schemes
parent = parent.Parent()
}
if len(schemes) == 0 {
schemes = Design.Schemes
}
}
return schemes
} | [
"func",
"(",
"a",
"*",
"ActionDefinition",
")",
"EffectiveSchemes",
"(",
")",
"[",
"]",
"string",
"{",
"// Compute the schemes",
"schemes",
":=",
"a",
".",
"Schemes",
"\n",
"if",
"len",
"(",
"schemes",
")",
"==",
"0",
"{",
"res",
":=",
"a",
".",
"Parent",
"\n",
"schemes",
"=",
"res",
".",
"Schemes",
"\n",
"parent",
":=",
"res",
".",
"Parent",
"(",
")",
"\n",
"for",
"len",
"(",
"schemes",
")",
"==",
"0",
"&&",
"parent",
"!=",
"nil",
"{",
"schemes",
"=",
"parent",
".",
"Schemes",
"\n",
"parent",
"=",
"parent",
".",
"Parent",
"(",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"schemes",
")",
"==",
"0",
"{",
"schemes",
"=",
"Design",
".",
"Schemes",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"schemes",
"\n",
"}"
] | // EffectiveSchemes return the URL schemes that apply to the action. Looks recursively into action
// resource, parent resources and API. | [
"EffectiveSchemes",
"return",
"the",
"URL",
"schemes",
"that",
"apply",
"to",
"the",
"action",
".",
"Looks",
"recursively",
"into",
"action",
"resource",
"parent",
"resources",
"and",
"API",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/design/definitions.go#L1554-L1570 | train |
goadesign/goa | design/definitions.go | Finalize | func (a *ActionDefinition) Finalize() {
// Inherit security scheme
if a.Security == nil {
a.Security = a.Parent.Security // ResourceDefinition
if a.Security == nil {
a.Security = Design.Security
}
}
if a.Security != nil && a.Security.Scheme.Kind == NoSecurityKind {
a.Security = nil
}
if a.Payload != nil {
a.Payload.Finalize()
}
a.mergeResponses()
a.initImplicitParams()
a.initQueryParams()
} | go | func (a *ActionDefinition) Finalize() {
// Inherit security scheme
if a.Security == nil {
a.Security = a.Parent.Security // ResourceDefinition
if a.Security == nil {
a.Security = Design.Security
}
}
if a.Security != nil && a.Security.Scheme.Kind == NoSecurityKind {
a.Security = nil
}
if a.Payload != nil {
a.Payload.Finalize()
}
a.mergeResponses()
a.initImplicitParams()
a.initQueryParams()
} | [
"func",
"(",
"a",
"*",
"ActionDefinition",
")",
"Finalize",
"(",
")",
"{",
"// Inherit security scheme",
"if",
"a",
".",
"Security",
"==",
"nil",
"{",
"a",
".",
"Security",
"=",
"a",
".",
"Parent",
".",
"Security",
"// ResourceDefinition",
"\n",
"if",
"a",
".",
"Security",
"==",
"nil",
"{",
"a",
".",
"Security",
"=",
"Design",
".",
"Security",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"a",
".",
"Security",
"!=",
"nil",
"&&",
"a",
".",
"Security",
".",
"Scheme",
".",
"Kind",
"==",
"NoSecurityKind",
"{",
"a",
".",
"Security",
"=",
"nil",
"\n",
"}",
"\n\n",
"if",
"a",
".",
"Payload",
"!=",
"nil",
"{",
"a",
".",
"Payload",
".",
"Finalize",
"(",
")",
"\n",
"}",
"\n\n",
"a",
".",
"mergeResponses",
"(",
")",
"\n",
"a",
".",
"initImplicitParams",
"(",
")",
"\n",
"a",
".",
"initQueryParams",
"(",
")",
"\n",
"}"
] | // Finalize inherits security scheme and action responses from parent and top level design. | [
"Finalize",
"inherits",
"security",
"scheme",
"and",
"action",
"responses",
"from",
"parent",
"and",
"top",
"level",
"design",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/design/definitions.go#L1588-L1608 | train |
goadesign/goa | design/definitions.go | UserTypes | func (a *ActionDefinition) UserTypes() map[string]*UserTypeDefinition {
types := make(map[string]*UserTypeDefinition)
allp := a.AllParams().Type.ToObject()
if a.Payload != nil {
allp["__payload__"] = &AttributeDefinition{Type: a.Payload}
}
for n, ut := range UserTypes(allp) {
types[n] = ut
}
for _, r := range a.Responses {
if mt := Design.MediaTypeWithIdentifier(r.MediaType); mt != nil {
types[mt.TypeName] = mt.UserTypeDefinition
for n, ut := range UserTypes(mt.UserTypeDefinition) {
types[n] = ut
}
}
}
if len(types) == 0 {
return nil
}
return types
} | go | func (a *ActionDefinition) UserTypes() map[string]*UserTypeDefinition {
types := make(map[string]*UserTypeDefinition)
allp := a.AllParams().Type.ToObject()
if a.Payload != nil {
allp["__payload__"] = &AttributeDefinition{Type: a.Payload}
}
for n, ut := range UserTypes(allp) {
types[n] = ut
}
for _, r := range a.Responses {
if mt := Design.MediaTypeWithIdentifier(r.MediaType); mt != nil {
types[mt.TypeName] = mt.UserTypeDefinition
for n, ut := range UserTypes(mt.UserTypeDefinition) {
types[n] = ut
}
}
}
if len(types) == 0 {
return nil
}
return types
} | [
"func",
"(",
"a",
"*",
"ActionDefinition",
")",
"UserTypes",
"(",
")",
"map",
"[",
"string",
"]",
"*",
"UserTypeDefinition",
"{",
"types",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"UserTypeDefinition",
")",
"\n",
"allp",
":=",
"a",
".",
"AllParams",
"(",
")",
".",
"Type",
".",
"ToObject",
"(",
")",
"\n",
"if",
"a",
".",
"Payload",
"!=",
"nil",
"{",
"allp",
"[",
"\"",
"\"",
"]",
"=",
"&",
"AttributeDefinition",
"{",
"Type",
":",
"a",
".",
"Payload",
"}",
"\n",
"}",
"\n",
"for",
"n",
",",
"ut",
":=",
"range",
"UserTypes",
"(",
"allp",
")",
"{",
"types",
"[",
"n",
"]",
"=",
"ut",
"\n",
"}",
"\n",
"for",
"_",
",",
"r",
":=",
"range",
"a",
".",
"Responses",
"{",
"if",
"mt",
":=",
"Design",
".",
"MediaTypeWithIdentifier",
"(",
"r",
".",
"MediaType",
")",
";",
"mt",
"!=",
"nil",
"{",
"types",
"[",
"mt",
".",
"TypeName",
"]",
"=",
"mt",
".",
"UserTypeDefinition",
"\n",
"for",
"n",
",",
"ut",
":=",
"range",
"UserTypes",
"(",
"mt",
".",
"UserTypeDefinition",
")",
"{",
"types",
"[",
"n",
"]",
"=",
"ut",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"len",
"(",
"types",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"types",
"\n",
"}"
] | // UserTypes returns all the user types used by the action payload and parameters. | [
"UserTypes",
"returns",
"all",
"the",
"user",
"types",
"used",
"by",
"the",
"action",
"payload",
"and",
"parameters",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/design/definitions.go#L1611-L1632 | train |
goadesign/goa | design/definitions.go | IterateHeaders | func (a *ActionDefinition) IterateHeaders(it HeaderIterator) error {
mergedHeaders := a.Parent.Headers.Merge(a.Headers)
isRequired := func(name string) bool {
// header required in either the Resource or Action scope?
return a.Parent.Headers.IsRequired(name) || a.Headers.IsRequired(name)
}
return iterateHeaders(mergedHeaders, isRequired, it)
} | go | func (a *ActionDefinition) IterateHeaders(it HeaderIterator) error {
mergedHeaders := a.Parent.Headers.Merge(a.Headers)
isRequired := func(name string) bool {
// header required in either the Resource or Action scope?
return a.Parent.Headers.IsRequired(name) || a.Headers.IsRequired(name)
}
return iterateHeaders(mergedHeaders, isRequired, it)
} | [
"func",
"(",
"a",
"*",
"ActionDefinition",
")",
"IterateHeaders",
"(",
"it",
"HeaderIterator",
")",
"error",
"{",
"mergedHeaders",
":=",
"a",
".",
"Parent",
".",
"Headers",
".",
"Merge",
"(",
"a",
".",
"Headers",
")",
"\n\n",
"isRequired",
":=",
"func",
"(",
"name",
"string",
")",
"bool",
"{",
"// header required in either the Resource or Action scope?",
"return",
"a",
".",
"Parent",
".",
"Headers",
".",
"IsRequired",
"(",
"name",
")",
"||",
"a",
".",
"Headers",
".",
"IsRequired",
"(",
"name",
")",
"\n",
"}",
"\n\n",
"return",
"iterateHeaders",
"(",
"mergedHeaders",
",",
"isRequired",
",",
"it",
")",
"\n",
"}"
] | // IterateHeaders iterates over the resource-level and action-level headers,
// calling the given iterator passing in each response sorted in alphabetical order.
// Iteration stops if an iterator returns an error and in this case IterateHeaders returns that
// error. | [
"IterateHeaders",
"iterates",
"over",
"the",
"resource",
"-",
"level",
"and",
"action",
"-",
"level",
"headers",
"calling",
"the",
"given",
"iterator",
"passing",
"in",
"each",
"response",
"sorted",
"in",
"alphabetical",
"order",
".",
"Iteration",
"stops",
"if",
"an",
"iterator",
"returns",
"an",
"error",
"and",
"in",
"this",
"case",
"IterateHeaders",
"returns",
"that",
"error",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/design/definitions.go#L1638-L1647 | train |
goadesign/goa | design/definitions.go | mergeResponses | func (a *ActionDefinition) mergeResponses() {
for name, resp := range a.Parent.Responses {
if _, ok := a.Responses[name]; !ok {
if a.Responses == nil {
a.Responses = make(map[string]*ResponseDefinition)
}
a.Responses[name] = resp.Dup()
}
}
for name, resp := range a.Responses {
resp.Finalize()
if pr, ok := a.Parent.Responses[name]; ok {
resp.Merge(pr)
}
if ar, ok := Design.Responses[name]; ok {
resp.Merge(ar)
}
if dr, ok := Design.DefaultResponses[name]; ok {
resp.Merge(dr)
}
}
} | go | func (a *ActionDefinition) mergeResponses() {
for name, resp := range a.Parent.Responses {
if _, ok := a.Responses[name]; !ok {
if a.Responses == nil {
a.Responses = make(map[string]*ResponseDefinition)
}
a.Responses[name] = resp.Dup()
}
}
for name, resp := range a.Responses {
resp.Finalize()
if pr, ok := a.Parent.Responses[name]; ok {
resp.Merge(pr)
}
if ar, ok := Design.Responses[name]; ok {
resp.Merge(ar)
}
if dr, ok := Design.DefaultResponses[name]; ok {
resp.Merge(dr)
}
}
} | [
"func",
"(",
"a",
"*",
"ActionDefinition",
")",
"mergeResponses",
"(",
")",
"{",
"for",
"name",
",",
"resp",
":=",
"range",
"a",
".",
"Parent",
".",
"Responses",
"{",
"if",
"_",
",",
"ok",
":=",
"a",
".",
"Responses",
"[",
"name",
"]",
";",
"!",
"ok",
"{",
"if",
"a",
".",
"Responses",
"==",
"nil",
"{",
"a",
".",
"Responses",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"ResponseDefinition",
")",
"\n",
"}",
"\n",
"a",
".",
"Responses",
"[",
"name",
"]",
"=",
"resp",
".",
"Dup",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"for",
"name",
",",
"resp",
":=",
"range",
"a",
".",
"Responses",
"{",
"resp",
".",
"Finalize",
"(",
")",
"\n",
"if",
"pr",
",",
"ok",
":=",
"a",
".",
"Parent",
".",
"Responses",
"[",
"name",
"]",
";",
"ok",
"{",
"resp",
".",
"Merge",
"(",
"pr",
")",
"\n",
"}",
"\n",
"if",
"ar",
",",
"ok",
":=",
"Design",
".",
"Responses",
"[",
"name",
"]",
";",
"ok",
"{",
"resp",
".",
"Merge",
"(",
"ar",
")",
"\n",
"}",
"\n",
"if",
"dr",
",",
"ok",
":=",
"Design",
".",
"DefaultResponses",
"[",
"name",
"]",
";",
"ok",
"{",
"resp",
".",
"Merge",
"(",
"dr",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // mergeResponses merges the parent resource and design responses. | [
"mergeResponses",
"merges",
"the",
"parent",
"resource",
"and",
"design",
"responses",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/design/definitions.go#L1669-L1690 | train |
goadesign/goa | design/definitions.go | initImplicitParams | func (a *ActionDefinition) initImplicitParams() {
for _, ro := range a.Routes {
for _, wc := range ro.Params() {
found := false
search := func(params *AttributeDefinition) {
if params == nil {
return
}
att, ok := params.Type.ToObject()[wc]
if ok {
if a.Params == nil {
a.Params = &AttributeDefinition{Type: Object{}}
}
a.Params.Type.ToObject()[wc] = att
found = true
}
}
search(a.Params)
parent := a.Parent
for !found && parent != nil {
bp := parent.Params
parent = parent.Parent()
search(bp)
}
if found {
continue
}
search(Design.Params)
if found {
continue
}
if a.Params == nil {
a.Params = &AttributeDefinition{Type: Object{}}
}
a.Params.Type.ToObject()[wc] = &AttributeDefinition{Type: String}
}
}
} | go | func (a *ActionDefinition) initImplicitParams() {
for _, ro := range a.Routes {
for _, wc := range ro.Params() {
found := false
search := func(params *AttributeDefinition) {
if params == nil {
return
}
att, ok := params.Type.ToObject()[wc]
if ok {
if a.Params == nil {
a.Params = &AttributeDefinition{Type: Object{}}
}
a.Params.Type.ToObject()[wc] = att
found = true
}
}
search(a.Params)
parent := a.Parent
for !found && parent != nil {
bp := parent.Params
parent = parent.Parent()
search(bp)
}
if found {
continue
}
search(Design.Params)
if found {
continue
}
if a.Params == nil {
a.Params = &AttributeDefinition{Type: Object{}}
}
a.Params.Type.ToObject()[wc] = &AttributeDefinition{Type: String}
}
}
} | [
"func",
"(",
"a",
"*",
"ActionDefinition",
")",
"initImplicitParams",
"(",
")",
"{",
"for",
"_",
",",
"ro",
":=",
"range",
"a",
".",
"Routes",
"{",
"for",
"_",
",",
"wc",
":=",
"range",
"ro",
".",
"Params",
"(",
")",
"{",
"found",
":=",
"false",
"\n",
"search",
":=",
"func",
"(",
"params",
"*",
"AttributeDefinition",
")",
"{",
"if",
"params",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"att",
",",
"ok",
":=",
"params",
".",
"Type",
".",
"ToObject",
"(",
")",
"[",
"wc",
"]",
"\n",
"if",
"ok",
"{",
"if",
"a",
".",
"Params",
"==",
"nil",
"{",
"a",
".",
"Params",
"=",
"&",
"AttributeDefinition",
"{",
"Type",
":",
"Object",
"{",
"}",
"}",
"\n",
"}",
"\n",
"a",
".",
"Params",
".",
"Type",
".",
"ToObject",
"(",
")",
"[",
"wc",
"]",
"=",
"att",
"\n",
"found",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"search",
"(",
"a",
".",
"Params",
")",
"\n",
"parent",
":=",
"a",
".",
"Parent",
"\n",
"for",
"!",
"found",
"&&",
"parent",
"!=",
"nil",
"{",
"bp",
":=",
"parent",
".",
"Params",
"\n",
"parent",
"=",
"parent",
".",
"Parent",
"(",
")",
"\n",
"search",
"(",
"bp",
")",
"\n",
"}",
"\n",
"if",
"found",
"{",
"continue",
"\n",
"}",
"\n",
"search",
"(",
"Design",
".",
"Params",
")",
"\n",
"if",
"found",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"a",
".",
"Params",
"==",
"nil",
"{",
"a",
".",
"Params",
"=",
"&",
"AttributeDefinition",
"{",
"Type",
":",
"Object",
"{",
"}",
"}",
"\n",
"}",
"\n",
"a",
".",
"Params",
".",
"Type",
".",
"ToObject",
"(",
")",
"[",
"wc",
"]",
"=",
"&",
"AttributeDefinition",
"{",
"Type",
":",
"String",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // initImplicitParams creates params for path segments that don't have one. | [
"initImplicitParams",
"creates",
"params",
"for",
"path",
"segments",
"that",
"don",
"t",
"have",
"one",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/design/definitions.go#L1693-L1730 | train |
goadesign/goa | design/definitions.go | initQueryParams | func (a *ActionDefinition) initQueryParams() {
// 3. Compute QueryParams from Params and set all path params as non zero attributes
if params := a.AllParams(); params != nil {
queryParams := DupAtt(params)
queryParams.Type = Dup(queryParams.Type)
if a.Params == nil {
a.Params = &AttributeDefinition{Type: Object{}}
}
a.Params.NonZeroAttributes = make(map[string]bool)
for _, route := range a.Routes {
pnames := route.Params()
for _, pname := range pnames {
a.Params.NonZeroAttributes[pname] = true
delete(queryParams.Type.ToObject(), pname)
if queryParams.Validation != nil {
req := queryParams.Validation.Required
for i, n := range req {
if n == pname {
queryParams.Validation.Required = append(req[:i], req[i+1:]...)
break
}
}
}
}
}
a.QueryParams = queryParams
}
} | go | func (a *ActionDefinition) initQueryParams() {
// 3. Compute QueryParams from Params and set all path params as non zero attributes
if params := a.AllParams(); params != nil {
queryParams := DupAtt(params)
queryParams.Type = Dup(queryParams.Type)
if a.Params == nil {
a.Params = &AttributeDefinition{Type: Object{}}
}
a.Params.NonZeroAttributes = make(map[string]bool)
for _, route := range a.Routes {
pnames := route.Params()
for _, pname := range pnames {
a.Params.NonZeroAttributes[pname] = true
delete(queryParams.Type.ToObject(), pname)
if queryParams.Validation != nil {
req := queryParams.Validation.Required
for i, n := range req {
if n == pname {
queryParams.Validation.Required = append(req[:i], req[i+1:]...)
break
}
}
}
}
}
a.QueryParams = queryParams
}
} | [
"func",
"(",
"a",
"*",
"ActionDefinition",
")",
"initQueryParams",
"(",
")",
"{",
"// 3. Compute QueryParams from Params and set all path params as non zero attributes",
"if",
"params",
":=",
"a",
".",
"AllParams",
"(",
")",
";",
"params",
"!=",
"nil",
"{",
"queryParams",
":=",
"DupAtt",
"(",
"params",
")",
"\n",
"queryParams",
".",
"Type",
"=",
"Dup",
"(",
"queryParams",
".",
"Type",
")",
"\n",
"if",
"a",
".",
"Params",
"==",
"nil",
"{",
"a",
".",
"Params",
"=",
"&",
"AttributeDefinition",
"{",
"Type",
":",
"Object",
"{",
"}",
"}",
"\n",
"}",
"\n",
"a",
".",
"Params",
".",
"NonZeroAttributes",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"bool",
")",
"\n",
"for",
"_",
",",
"route",
":=",
"range",
"a",
".",
"Routes",
"{",
"pnames",
":=",
"route",
".",
"Params",
"(",
")",
"\n",
"for",
"_",
",",
"pname",
":=",
"range",
"pnames",
"{",
"a",
".",
"Params",
".",
"NonZeroAttributes",
"[",
"pname",
"]",
"=",
"true",
"\n",
"delete",
"(",
"queryParams",
".",
"Type",
".",
"ToObject",
"(",
")",
",",
"pname",
")",
"\n",
"if",
"queryParams",
".",
"Validation",
"!=",
"nil",
"{",
"req",
":=",
"queryParams",
".",
"Validation",
".",
"Required",
"\n",
"for",
"i",
",",
"n",
":=",
"range",
"req",
"{",
"if",
"n",
"==",
"pname",
"{",
"queryParams",
".",
"Validation",
".",
"Required",
"=",
"append",
"(",
"req",
"[",
":",
"i",
"]",
",",
"req",
"[",
"i",
"+",
"1",
":",
"]",
"...",
")",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"a",
".",
"QueryParams",
"=",
"queryParams",
"\n",
"}",
"\n",
"}"
] | // initQueryParams extract the query parameters from the action params. | [
"initQueryParams",
"extract",
"the",
"query",
"parameters",
"from",
"the",
"action",
"params",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/design/definitions.go#L1733-L1760 | train |
goadesign/goa | design/definitions.go | Finalize | func (f *FileServerDefinition) Finalize() {
// Make sure request path starts with a "/" so codegen can rely on it.
if !strings.HasPrefix(f.RequestPath, "/") {
f.RequestPath = "/" + f.RequestPath
}
// Inherit security
if f.Security == nil {
f.Security = f.Parent.Security // ResourceDefinition
if f.Security == nil {
f.Security = Design.Security
}
}
if f.Security != nil && f.Security.Scheme.Kind == NoSecurityKind {
f.Security = nil
}
} | go | func (f *FileServerDefinition) Finalize() {
// Make sure request path starts with a "/" so codegen can rely on it.
if !strings.HasPrefix(f.RequestPath, "/") {
f.RequestPath = "/" + f.RequestPath
}
// Inherit security
if f.Security == nil {
f.Security = f.Parent.Security // ResourceDefinition
if f.Security == nil {
f.Security = Design.Security
}
}
if f.Security != nil && f.Security.Scheme.Kind == NoSecurityKind {
f.Security = nil
}
} | [
"func",
"(",
"f",
"*",
"FileServerDefinition",
")",
"Finalize",
"(",
")",
"{",
"// Make sure request path starts with a \"/\" so codegen can rely on it.",
"if",
"!",
"strings",
".",
"HasPrefix",
"(",
"f",
".",
"RequestPath",
",",
"\"",
"\"",
")",
"{",
"f",
".",
"RequestPath",
"=",
"\"",
"\"",
"+",
"f",
".",
"RequestPath",
"\n",
"}",
"\n",
"// Inherit security",
"if",
"f",
".",
"Security",
"==",
"nil",
"{",
"f",
".",
"Security",
"=",
"f",
".",
"Parent",
".",
"Security",
"// ResourceDefinition",
"\n",
"if",
"f",
".",
"Security",
"==",
"nil",
"{",
"f",
".",
"Security",
"=",
"Design",
".",
"Security",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"f",
".",
"Security",
"!=",
"nil",
"&&",
"f",
".",
"Security",
".",
"Scheme",
".",
"Kind",
"==",
"NoSecurityKind",
"{",
"f",
".",
"Security",
"=",
"nil",
"\n",
"}",
"\n",
"}"
] | // Finalize inherits security scheme from parent and top level design. | [
"Finalize",
"inherits",
"security",
"scheme",
"from",
"parent",
"and",
"top",
"level",
"design",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/design/definitions.go#L1773-L1788 | train |
goadesign/goa | design/definitions.go | Attribute | func (l *LinkDefinition) Attribute() *AttributeDefinition {
p := l.Parent.ToObject()
if p == nil {
return nil
}
att, _ := p[l.Name]
return att
} | go | func (l *LinkDefinition) Attribute() *AttributeDefinition {
p := l.Parent.ToObject()
if p == nil {
return nil
}
att, _ := p[l.Name]
return att
} | [
"func",
"(",
"l",
"*",
"LinkDefinition",
")",
"Attribute",
"(",
")",
"*",
"AttributeDefinition",
"{",
"p",
":=",
"l",
".",
"Parent",
".",
"ToObject",
"(",
")",
"\n",
"if",
"p",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"att",
",",
"_",
":=",
"p",
"[",
"l",
".",
"Name",
"]",
"\n\n",
"return",
"att",
"\n",
"}"
] | // Attribute returns the linked attribute. | [
"Attribute",
"returns",
"the",
"linked",
"attribute",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/design/definitions.go#L1817-L1825 | train |
goadesign/goa | design/definitions.go | MediaType | func (l *LinkDefinition) MediaType() *MediaTypeDefinition {
att := l.Attribute()
mt, _ := att.Type.(*MediaTypeDefinition)
return mt
} | go | func (l *LinkDefinition) MediaType() *MediaTypeDefinition {
att := l.Attribute()
mt, _ := att.Type.(*MediaTypeDefinition)
return mt
} | [
"func",
"(",
"l",
"*",
"LinkDefinition",
")",
"MediaType",
"(",
")",
"*",
"MediaTypeDefinition",
"{",
"att",
":=",
"l",
".",
"Attribute",
"(",
")",
"\n",
"mt",
",",
"_",
":=",
"att",
".",
"Type",
".",
"(",
"*",
"MediaTypeDefinition",
")",
"\n",
"return",
"mt",
"\n",
"}"
] | // MediaType returns the media type of the linked attribute. | [
"MediaType",
"returns",
"the",
"media",
"type",
"of",
"the",
"linked",
"attribute",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/design/definitions.go#L1828-L1832 | train |
goadesign/goa | design/definitions.go | FullPath | func (r *RouteDefinition) FullPath() string {
if r.IsAbsolute() {
return httppath.Clean(r.Path[1:])
}
var base string
if r.Parent != nil && r.Parent.Parent != nil {
base = r.Parent.Parent.FullPath()
}
joinedPath := path.Join(base, r.Path)
if strings.HasSuffix(r.Path, "/") {
//add slash removed by Join back again (it may be important for routing)
joinedPath += "/"
}
return httppath.Clean(joinedPath)
} | go | func (r *RouteDefinition) FullPath() string {
if r.IsAbsolute() {
return httppath.Clean(r.Path[1:])
}
var base string
if r.Parent != nil && r.Parent.Parent != nil {
base = r.Parent.Parent.FullPath()
}
joinedPath := path.Join(base, r.Path)
if strings.HasSuffix(r.Path, "/") {
//add slash removed by Join back again (it may be important for routing)
joinedPath += "/"
}
return httppath.Clean(joinedPath)
} | [
"func",
"(",
"r",
"*",
"RouteDefinition",
")",
"FullPath",
"(",
")",
"string",
"{",
"if",
"r",
".",
"IsAbsolute",
"(",
")",
"{",
"return",
"httppath",
".",
"Clean",
"(",
"r",
".",
"Path",
"[",
"1",
":",
"]",
")",
"\n",
"}",
"\n",
"var",
"base",
"string",
"\n",
"if",
"r",
".",
"Parent",
"!=",
"nil",
"&&",
"r",
".",
"Parent",
".",
"Parent",
"!=",
"nil",
"{",
"base",
"=",
"r",
".",
"Parent",
".",
"Parent",
".",
"FullPath",
"(",
")",
"\n",
"}",
"\n\n",
"joinedPath",
":=",
"path",
".",
"Join",
"(",
"base",
",",
"r",
".",
"Path",
")",
"\n",
"if",
"strings",
".",
"HasSuffix",
"(",
"r",
".",
"Path",
",",
"\"",
"\"",
")",
"{",
"//add slash removed by Join back again (it may be important for routing)",
"joinedPath",
"+=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"return",
"httppath",
".",
"Clean",
"(",
"joinedPath",
")",
"\n",
"}"
] | // FullPath returns the action full path computed by concatenating the API and resource base paths
// with the action specific path. | [
"FullPath",
"returns",
"the",
"action",
"full",
"path",
"computed",
"by",
"concatenating",
"the",
"API",
"and",
"resource",
"base",
"paths",
"with",
"the",
"action",
"specific",
"path",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/design/definitions.go#L1861-L1877 | train |
goadesign/goa | middleware/log_request.go | from | func from(req *http.Request) string {
if f := req.Header.Get("X-Forwarded-For"); f != "" {
return f
}
f := req.RemoteAddr
ip, _, err := net.SplitHostPort(f)
if err != nil {
return f
}
return ip
} | go | func from(req *http.Request) string {
if f := req.Header.Get("X-Forwarded-For"); f != "" {
return f
}
f := req.RemoteAddr
ip, _, err := net.SplitHostPort(f)
if err != nil {
return f
}
return ip
} | [
"func",
"from",
"(",
"req",
"*",
"http",
".",
"Request",
")",
"string",
"{",
"if",
"f",
":=",
"req",
".",
"Header",
".",
"Get",
"(",
"\"",
"\"",
")",
";",
"f",
"!=",
"\"",
"\"",
"{",
"return",
"f",
"\n",
"}",
"\n",
"f",
":=",
"req",
".",
"RemoteAddr",
"\n",
"ip",
",",
"_",
",",
"err",
":=",
"net",
".",
"SplitHostPort",
"(",
"f",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"f",
"\n",
"}",
"\n",
"return",
"ip",
"\n",
"}"
] | // from makes a best effort to compute the request client IP. | [
"from",
"makes",
"a",
"best",
"effort",
"to",
"compute",
"the",
"request",
"client",
"IP",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/middleware/log_request.go#L121-L131 | train |
goadesign/goa | service.go | Use | func (service *Service) Use(m Middleware) {
service.middleware = append(service.middleware, m)
} | go | func (service *Service) Use(m Middleware) {
service.middleware = append(service.middleware, m)
} | [
"func",
"(",
"service",
"*",
"Service",
")",
"Use",
"(",
"m",
"Middleware",
")",
"{",
"service",
".",
"middleware",
"=",
"append",
"(",
"service",
".",
"middleware",
",",
"m",
")",
"\n",
"}"
] | // Use adds a middleware to the service wide middleware chain.
// goa comes with a set of commonly used middleware, see the middleware package.
// Controller specific middleware should be mounted using the Controller struct Use method instead. | [
"Use",
"adds",
"a",
"middleware",
"to",
"the",
"service",
"wide",
"middleware",
"chain",
".",
"goa",
"comes",
"with",
"a",
"set",
"of",
"commonly",
"used",
"middleware",
"see",
"the",
"middleware",
"package",
".",
"Controller",
"specific",
"middleware",
"should",
"be",
"mounted",
"using",
"the",
"Controller",
"struct",
"Use",
"method",
"instead",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/service.go#L181-L183 | train |
goadesign/goa | service.go | WithLogger | func (service *Service) WithLogger(logger LogAdapter) {
service.Context = WithLogger(service.Context, logger)
} | go | func (service *Service) WithLogger(logger LogAdapter) {
service.Context = WithLogger(service.Context, logger)
} | [
"func",
"(",
"service",
"*",
"Service",
")",
"WithLogger",
"(",
"logger",
"LogAdapter",
")",
"{",
"service",
".",
"Context",
"=",
"WithLogger",
"(",
"service",
".",
"Context",
",",
"logger",
")",
"\n",
"}"
] | // WithLogger sets the logger used internally by the service and by Log. | [
"WithLogger",
"sets",
"the",
"logger",
"used",
"internally",
"by",
"the",
"service",
"and",
"by",
"Log",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/service.go#L186-L188 | train |
goadesign/goa | service.go | LogInfo | func (service *Service) LogInfo(msg string, keyvals ...interface{}) {
LogInfo(service.Context, msg, keyvals...)
} | go | func (service *Service) LogInfo(msg string, keyvals ...interface{}) {
LogInfo(service.Context, msg, keyvals...)
} | [
"func",
"(",
"service",
"*",
"Service",
")",
"LogInfo",
"(",
"msg",
"string",
",",
"keyvals",
"...",
"interface",
"{",
"}",
")",
"{",
"LogInfo",
"(",
"service",
".",
"Context",
",",
"msg",
",",
"keyvals",
"...",
")",
"\n",
"}"
] | // LogInfo logs the message and values at odd indeces using the keys at even indeces of the keyvals slice. | [
"LogInfo",
"logs",
"the",
"message",
"and",
"values",
"at",
"odd",
"indeces",
"using",
"the",
"keys",
"at",
"even",
"indeces",
"of",
"the",
"keyvals",
"slice",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/service.go#L191-L193 | train |
goadesign/goa | service.go | LogError | func (service *Service) LogError(msg string, keyvals ...interface{}) {
LogError(service.Context, msg, keyvals...)
} | go | func (service *Service) LogError(msg string, keyvals ...interface{}) {
LogError(service.Context, msg, keyvals...)
} | [
"func",
"(",
"service",
"*",
"Service",
")",
"LogError",
"(",
"msg",
"string",
",",
"keyvals",
"...",
"interface",
"{",
"}",
")",
"{",
"LogError",
"(",
"service",
".",
"Context",
",",
"msg",
",",
"keyvals",
"...",
")",
"\n",
"}"
] | // LogError logs the error and values at odd indeces using the keys at even indeces of the keyvals slice. | [
"LogError",
"logs",
"the",
"error",
"and",
"values",
"at",
"odd",
"indeces",
"using",
"the",
"keys",
"at",
"even",
"indeces",
"of",
"the",
"keyvals",
"slice",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/service.go#L196-L198 | train |
goadesign/goa | service.go | Serve | func (service *Service) Serve(l net.Listener) error {
return service.Server.Serve(l)
} | go | func (service *Service) Serve(l net.Listener) error {
return service.Server.Serve(l)
} | [
"func",
"(",
"service",
"*",
"Service",
")",
"Serve",
"(",
"l",
"net",
".",
"Listener",
")",
"error",
"{",
"return",
"service",
".",
"Server",
".",
"Serve",
"(",
"l",
")",
"\n",
"}"
] | // Serve accepts incoming HTTP connections on the listener l, invoking the service mux handler for each. | [
"Serve",
"accepts",
"incoming",
"HTTP",
"connections",
"on",
"the",
"listener",
"l",
"invoking",
"the",
"service",
"mux",
"handler",
"for",
"each",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/service.go#L215-L217 | train |
goadesign/goa | service.go | NewController | func (service *Service) NewController(name string) *Controller {
return &Controller{
Name: name,
Service: service,
Context: context.WithValue(service.Context, ctrlKey, name),
MaxRequestBodyLength: 1073741824, // 1 GB
FileSystem: func(dir string) http.FileSystem {
return http.Dir(dir)
},
}
} | go | func (service *Service) NewController(name string) *Controller {
return &Controller{
Name: name,
Service: service,
Context: context.WithValue(service.Context, ctrlKey, name),
MaxRequestBodyLength: 1073741824, // 1 GB
FileSystem: func(dir string) http.FileSystem {
return http.Dir(dir)
},
}
} | [
"func",
"(",
"service",
"*",
"Service",
")",
"NewController",
"(",
"name",
"string",
")",
"*",
"Controller",
"{",
"return",
"&",
"Controller",
"{",
"Name",
":",
"name",
",",
"Service",
":",
"service",
",",
"Context",
":",
"context",
".",
"WithValue",
"(",
"service",
".",
"Context",
",",
"ctrlKey",
",",
"name",
")",
",",
"MaxRequestBodyLength",
":",
"1073741824",
",",
"// 1 GB",
"FileSystem",
":",
"func",
"(",
"dir",
"string",
")",
"http",
".",
"FileSystem",
"{",
"return",
"http",
".",
"Dir",
"(",
"dir",
")",
"\n",
"}",
",",
"}",
"\n",
"}"
] | // NewController returns a controller for the given resource. This method is mainly intended for
// use by the generated code. User code shouldn't have to call it directly. | [
"NewController",
"returns",
"a",
"controller",
"for",
"the",
"given",
"resource",
".",
"This",
"method",
"is",
"mainly",
"intended",
"for",
"use",
"by",
"the",
"generated",
"code",
".",
"User",
"code",
"shouldn",
"t",
"have",
"to",
"call",
"it",
"directly",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/service.go#L221-L231 | train |
goadesign/goa | service.go | Send | func (service *Service) Send(ctx context.Context, code int, body interface{}) error {
r := ContextResponse(ctx)
if r == nil {
return fmt.Errorf("no response data in context")
}
r.WriteHeader(code)
return service.EncodeResponse(ctx, body)
} | go | func (service *Service) Send(ctx context.Context, code int, body interface{}) error {
r := ContextResponse(ctx)
if r == nil {
return fmt.Errorf("no response data in context")
}
r.WriteHeader(code)
return service.EncodeResponse(ctx, body)
} | [
"func",
"(",
"service",
"*",
"Service",
")",
"Send",
"(",
"ctx",
"context",
".",
"Context",
",",
"code",
"int",
",",
"body",
"interface",
"{",
"}",
")",
"error",
"{",
"r",
":=",
"ContextResponse",
"(",
"ctx",
")",
"\n",
"if",
"r",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"r",
".",
"WriteHeader",
"(",
"code",
")",
"\n",
"return",
"service",
".",
"EncodeResponse",
"(",
"ctx",
",",
"body",
")",
"\n",
"}"
] | // Send serializes the given body matching the request Accept header against the service
// encoders. It uses the default service encoder if no match is found. | [
"Send",
"serializes",
"the",
"given",
"body",
"matching",
"the",
"request",
"Accept",
"header",
"against",
"the",
"service",
"encoders",
".",
"It",
"uses",
"the",
"default",
"service",
"encoder",
"if",
"no",
"match",
"is",
"found",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/service.go#L235-L242 | train |
goadesign/goa | service.go | ServeFiles | func (service *Service) ServeFiles(path, filename string) error {
ctrl := service.NewController("FileServer")
return ctrl.ServeFiles(path, filename)
} | go | func (service *Service) ServeFiles(path, filename string) error {
ctrl := service.NewController("FileServer")
return ctrl.ServeFiles(path, filename)
} | [
"func",
"(",
"service",
"*",
"Service",
")",
"ServeFiles",
"(",
"path",
",",
"filename",
"string",
")",
"error",
"{",
"ctrl",
":=",
"service",
".",
"NewController",
"(",
"\"",
"\"",
")",
"\n",
"return",
"ctrl",
".",
"ServeFiles",
"(",
"path",
",",
"filename",
")",
"\n",
"}"
] | // ServeFiles create a "FileServer" controller and calls ServerFiles on it. | [
"ServeFiles",
"create",
"a",
"FileServer",
"controller",
"and",
"calls",
"ServerFiles",
"on",
"it",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/service.go#L245-L248 | train |
goadesign/goa | service.go | DecodeRequest | func (service *Service) DecodeRequest(req *http.Request, v interface{}) error {
body, contentType := req.Body, req.Header.Get("Content-Type")
defer body.Close()
if err := service.Decoder.Decode(v, body, contentType); err != nil {
return fmt.Errorf("failed to decode request body with content type %#v: %s", contentType, err)
}
return nil
} | go | func (service *Service) DecodeRequest(req *http.Request, v interface{}) error {
body, contentType := req.Body, req.Header.Get("Content-Type")
defer body.Close()
if err := service.Decoder.Decode(v, body, contentType); err != nil {
return fmt.Errorf("failed to decode request body with content type %#v: %s", contentType, err)
}
return nil
} | [
"func",
"(",
"service",
"*",
"Service",
")",
"DecodeRequest",
"(",
"req",
"*",
"http",
".",
"Request",
",",
"v",
"interface",
"{",
"}",
")",
"error",
"{",
"body",
",",
"contentType",
":=",
"req",
".",
"Body",
",",
"req",
".",
"Header",
".",
"Get",
"(",
"\"",
"\"",
")",
"\n",
"defer",
"body",
".",
"Close",
"(",
")",
"\n\n",
"if",
"err",
":=",
"service",
".",
"Decoder",
".",
"Decode",
"(",
"v",
",",
"body",
",",
"contentType",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"contentType",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // DecodeRequest uses the HTTP decoder to unmarshal the request body into the provided value based
// on the request Content-Type header. | [
"DecodeRequest",
"uses",
"the",
"HTTP",
"decoder",
"to",
"unmarshal",
"the",
"request",
"body",
"into",
"the",
"provided",
"value",
"based",
"on",
"the",
"request",
"Content",
"-",
"Type",
"header",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/service.go#L252-L261 | train |
goadesign/goa | service.go | EncodeResponse | func (service *Service) EncodeResponse(ctx context.Context, v interface{}) error {
accept := ContextRequest(ctx).Header.Get("Accept")
return service.Encoder.Encode(v, ContextResponse(ctx), accept)
} | go | func (service *Service) EncodeResponse(ctx context.Context, v interface{}) error {
accept := ContextRequest(ctx).Header.Get("Accept")
return service.Encoder.Encode(v, ContextResponse(ctx), accept)
} | [
"func",
"(",
"service",
"*",
"Service",
")",
"EncodeResponse",
"(",
"ctx",
"context",
".",
"Context",
",",
"v",
"interface",
"{",
"}",
")",
"error",
"{",
"accept",
":=",
"ContextRequest",
"(",
"ctx",
")",
".",
"Header",
".",
"Get",
"(",
"\"",
"\"",
")",
"\n",
"return",
"service",
".",
"Encoder",
".",
"Encode",
"(",
"v",
",",
"ContextResponse",
"(",
"ctx",
")",
",",
"accept",
")",
"\n",
"}"
] | // EncodeResponse uses the HTTP encoder to marshal and write the response body based on the request
// Accept header. | [
"EncodeResponse",
"uses",
"the",
"HTTP",
"encoder",
"to",
"marshal",
"and",
"write",
"the",
"response",
"body",
"based",
"on",
"the",
"request",
"Accept",
"header",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/service.go#L265-L268 | train |
goadesign/goa | service.go | ServeFiles | func (ctrl *Controller) ServeFiles(path, filename string) error {
if strings.Contains(path, ":") {
return fmt.Errorf("path may only include wildcards that match the entire end of the URL (e.g. *filepath)")
}
LogInfo(ctrl.Context, "mount file", "name", filename, "route", fmt.Sprintf("GET %s", path))
handler := func(ctx context.Context, rw http.ResponseWriter, req *http.Request) error {
if !ContextResponse(ctx).Written() {
return ctrl.FileHandler(path, filename)(ctx, rw, req)
}
return nil
}
ctrl.Service.Mux.Handle("GET", path, ctrl.MuxHandler("serve", handler, nil))
return nil
} | go | func (ctrl *Controller) ServeFiles(path, filename string) error {
if strings.Contains(path, ":") {
return fmt.Errorf("path may only include wildcards that match the entire end of the URL (e.g. *filepath)")
}
LogInfo(ctrl.Context, "mount file", "name", filename, "route", fmt.Sprintf("GET %s", path))
handler := func(ctx context.Context, rw http.ResponseWriter, req *http.Request) error {
if !ContextResponse(ctx).Written() {
return ctrl.FileHandler(path, filename)(ctx, rw, req)
}
return nil
}
ctrl.Service.Mux.Handle("GET", path, ctrl.MuxHandler("serve", handler, nil))
return nil
} | [
"func",
"(",
"ctrl",
"*",
"Controller",
")",
"ServeFiles",
"(",
"path",
",",
"filename",
"string",
")",
"error",
"{",
"if",
"strings",
".",
"Contains",
"(",
"path",
",",
"\"",
"\"",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"LogInfo",
"(",
"ctrl",
".",
"Context",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"filename",
",",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"path",
")",
")",
"\n",
"handler",
":=",
"func",
"(",
"ctx",
"context",
".",
"Context",
",",
"rw",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
")",
"error",
"{",
"if",
"!",
"ContextResponse",
"(",
"ctx",
")",
".",
"Written",
"(",
")",
"{",
"return",
"ctrl",
".",
"FileHandler",
"(",
"path",
",",
"filename",
")",
"(",
"ctx",
",",
"rw",
",",
"req",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"ctrl",
".",
"Service",
".",
"Mux",
".",
"Handle",
"(",
"\"",
"\"",
",",
"path",
",",
"ctrl",
".",
"MuxHandler",
"(",
"\"",
"\"",
",",
"handler",
",",
"nil",
")",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // ServeFiles replies to the request with the contents of the named file or directory. See
// FileHandler for details. | [
"ServeFiles",
"replies",
"to",
"the",
"request",
"with",
"the",
"contents",
"of",
"the",
"named",
"file",
"or",
"directory",
".",
"See",
"FileHandler",
"for",
"details",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/service.go#L272-L285 | train |
goadesign/goa | service.go | Use | func (ctrl *Controller) Use(m Middleware) {
ctrl.middleware = append(ctrl.middleware, m)
} | go | func (ctrl *Controller) Use(m Middleware) {
ctrl.middleware = append(ctrl.middleware, m)
} | [
"func",
"(",
"ctrl",
"*",
"Controller",
")",
"Use",
"(",
"m",
"Middleware",
")",
"{",
"ctrl",
".",
"middleware",
"=",
"append",
"(",
"ctrl",
".",
"middleware",
",",
"m",
")",
"\n",
"}"
] | // Use adds a middleware to the controller.
// Service-wide middleware should be added via the Service Use method instead. | [
"Use",
"adds",
"a",
"middleware",
"to",
"the",
"controller",
".",
"Service",
"-",
"wide",
"middleware",
"should",
"be",
"added",
"via",
"the",
"Service",
"Use",
"method",
"instead",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/service.go#L289-L291 | train |
goadesign/goa | goagen/gen_controller/generator.go | NewGenerator | func NewGenerator(options ...Option) *Generator {
g := &Generator{}
for _, option := range options {
option(g)
}
return g
} | go | func NewGenerator(options ...Option) *Generator {
g := &Generator{}
for _, option := range options {
option(g)
}
return g
} | [
"func",
"NewGenerator",
"(",
"options",
"...",
"Option",
")",
"*",
"Generator",
"{",
"g",
":=",
"&",
"Generator",
"{",
"}",
"\n\n",
"for",
"_",
",",
"option",
":=",
"range",
"options",
"{",
"option",
"(",
"g",
")",
"\n",
"}",
"\n\n",
"return",
"g",
"\n",
"}"
] | //NewGenerator returns an initialized instance of a JavaScript Client Generator | [
"NewGenerator",
"returns",
"an",
"initialized",
"instance",
"of",
"a",
"JavaScript",
"Client",
"Generator"
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/goagen/gen_controller/generator.go#L18-L26 | train |
goadesign/goa | goagen/gen_controller/generator.go | Generate | func (g *Generator) Generate() (_ []string, err error) {
if g.API == nil {
return nil, fmt.Errorf("missing API definition, make sure design is properly initialized")
}
go utils.Catch(nil, func() { g.Cleanup() })
defer func() {
if err != nil {
g.Cleanup()
}
}()
if g.AppPkg == "" {
g.AppPkg = "app"
}
g.smartenPkg()
elems := strings.Split(g.AppPkg, "/")
pkgName := elems[len(elems)-1]
codegen.Reserved[pkgName] = true
err = g.API.IterateResources(func(r *design.ResourceDefinition) error {
var (
filename string
err error
)
if g.Resource == "" || g.Resource == r.Name {
filename, err = genmain.GenerateController(g.Force, g.Regen, g.AppPkg, g.OutDir, g.Pkg, r.Name, r)
}
if err != nil {
return err
}
g.genfiles = append(g.genfiles, filename)
return nil
})
if err != nil {
return nil, err
}
return g.genfiles, err
} | go | func (g *Generator) Generate() (_ []string, err error) {
if g.API == nil {
return nil, fmt.Errorf("missing API definition, make sure design is properly initialized")
}
go utils.Catch(nil, func() { g.Cleanup() })
defer func() {
if err != nil {
g.Cleanup()
}
}()
if g.AppPkg == "" {
g.AppPkg = "app"
}
g.smartenPkg()
elems := strings.Split(g.AppPkg, "/")
pkgName := elems[len(elems)-1]
codegen.Reserved[pkgName] = true
err = g.API.IterateResources(func(r *design.ResourceDefinition) error {
var (
filename string
err error
)
if g.Resource == "" || g.Resource == r.Name {
filename, err = genmain.GenerateController(g.Force, g.Regen, g.AppPkg, g.OutDir, g.Pkg, r.Name, r)
}
if err != nil {
return err
}
g.genfiles = append(g.genfiles, filename)
return nil
})
if err != nil {
return nil, err
}
return g.genfiles, err
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"Generate",
"(",
")",
"(",
"_",
"[",
"]",
"string",
",",
"err",
"error",
")",
"{",
"if",
"g",
".",
"API",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"go",
"utils",
".",
"Catch",
"(",
"nil",
",",
"func",
"(",
")",
"{",
"g",
".",
"Cleanup",
"(",
")",
"}",
")",
"\n\n",
"defer",
"func",
"(",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"g",
".",
"Cleanup",
"(",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"if",
"g",
".",
"AppPkg",
"==",
"\"",
"\"",
"{",
"g",
".",
"AppPkg",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"g",
".",
"smartenPkg",
"(",
")",
"\n",
"elems",
":=",
"strings",
".",
"Split",
"(",
"g",
".",
"AppPkg",
",",
"\"",
"\"",
")",
"\n",
"pkgName",
":=",
"elems",
"[",
"len",
"(",
"elems",
")",
"-",
"1",
"]",
"\n",
"codegen",
".",
"Reserved",
"[",
"pkgName",
"]",
"=",
"true",
"\n\n",
"err",
"=",
"g",
".",
"API",
".",
"IterateResources",
"(",
"func",
"(",
"r",
"*",
"design",
".",
"ResourceDefinition",
")",
"error",
"{",
"var",
"(",
"filename",
"string",
"\n",
"err",
"error",
"\n",
")",
"\n",
"if",
"g",
".",
"Resource",
"==",
"\"",
"\"",
"||",
"g",
".",
"Resource",
"==",
"r",
".",
"Name",
"{",
"filename",
",",
"err",
"=",
"genmain",
".",
"GenerateController",
"(",
"g",
".",
"Force",
",",
"g",
".",
"Regen",
",",
"g",
".",
"AppPkg",
",",
"g",
".",
"OutDir",
",",
"g",
".",
"Pkg",
",",
"r",
".",
"Name",
",",
"r",
")",
"\n",
"}",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"g",
".",
"genfiles",
"=",
"append",
"(",
"g",
".",
"genfiles",
",",
"filename",
")",
"\n\n",
"return",
"nil",
"\n",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"g",
".",
"genfiles",
",",
"err",
"\n",
"}"
] | // Generate produces the skeleton controller service factory. | [
"Generate",
"produces",
"the",
"skeleton",
"controller",
"service",
"factory",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/goagen/gen_controller/generator.go#L70-L112 | train |
goadesign/goa | goagen/gen_controller/generator.go | Cleanup | func (g *Generator) Cleanup() {
for _, f := range g.genfiles {
os.Remove(f)
}
g.genfiles = nil
} | go | func (g *Generator) Cleanup() {
for _, f := range g.genfiles {
os.Remove(f)
}
g.genfiles = nil
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"Cleanup",
"(",
")",
"{",
"for",
"_",
",",
"f",
":=",
"range",
"g",
".",
"genfiles",
"{",
"os",
".",
"Remove",
"(",
"f",
")",
"\n",
"}",
"\n",
"g",
".",
"genfiles",
"=",
"nil",
"\n",
"}"
] | // Cleanup removes all the files generated by this generator during the last invokation of Generate. | [
"Cleanup",
"removes",
"all",
"the",
"files",
"generated",
"by",
"this",
"generator",
"during",
"the",
"last",
"invokation",
"of",
"Generate",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/goagen/gen_controller/generator.go#L139-L144 | train |
goadesign/goa | context.go | WithAction | func WithAction(ctx context.Context, action string) context.Context {
return context.WithValue(ctx, actionKey, action)
} | go | func WithAction(ctx context.Context, action string) context.Context {
return context.WithValue(ctx, actionKey, action)
} | [
"func",
"WithAction",
"(",
"ctx",
"context",
".",
"Context",
",",
"action",
"string",
")",
"context",
".",
"Context",
"{",
"return",
"context",
".",
"WithValue",
"(",
"ctx",
",",
"actionKey",
",",
"action",
")",
"\n",
"}"
] | // WithAction creates a context with the given action name. | [
"WithAction",
"creates",
"a",
"context",
"with",
"the",
"given",
"action",
"name",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/context.go#L70-L72 | train |
goadesign/goa | context.go | WithLogger | func WithLogger(ctx context.Context, logger LogAdapter) context.Context {
return context.WithValue(ctx, logKey, logger)
} | go | func WithLogger(ctx context.Context, logger LogAdapter) context.Context {
return context.WithValue(ctx, logKey, logger)
} | [
"func",
"WithLogger",
"(",
"ctx",
"context",
".",
"Context",
",",
"logger",
"LogAdapter",
")",
"context",
".",
"Context",
"{",
"return",
"context",
".",
"WithValue",
"(",
"ctx",
",",
"logKey",
",",
"logger",
")",
"\n",
"}"
] | // WithLogger sets the request context logger and returns the resulting new context. | [
"WithLogger",
"sets",
"the",
"request",
"context",
"logger",
"and",
"returns",
"the",
"resulting",
"new",
"context",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/context.go#L75-L77 | train |
goadesign/goa | context.go | WithError | func WithError(ctx context.Context, err error) context.Context {
return context.WithValue(ctx, errKey, err)
} | go | func WithError(ctx context.Context, err error) context.Context {
return context.WithValue(ctx, errKey, err)
} | [
"func",
"WithError",
"(",
"ctx",
"context",
".",
"Context",
",",
"err",
"error",
")",
"context",
".",
"Context",
"{",
"return",
"context",
".",
"WithValue",
"(",
"ctx",
",",
"errKey",
",",
"err",
")",
"\n",
"}"
] | // WithError creates a context with the given error. | [
"WithError",
"creates",
"a",
"context",
"with",
"the",
"given",
"error",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/context.go#L91-L93 | train |
goadesign/goa | context.go | ContextController | func ContextController(ctx context.Context) string {
if c := ctx.Value(ctrlKey); c != nil {
return c.(string)
}
return "<unknown>"
} | go | func ContextController(ctx context.Context) string {
if c := ctx.Value(ctrlKey); c != nil {
return c.(string)
}
return "<unknown>"
} | [
"func",
"ContextController",
"(",
"ctx",
"context",
".",
"Context",
")",
"string",
"{",
"if",
"c",
":=",
"ctx",
".",
"Value",
"(",
"ctrlKey",
")",
";",
"c",
"!=",
"nil",
"{",
"return",
"c",
".",
"(",
"string",
")",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
"\n",
"}"
] | // ContextController extracts the controller name from the given context. | [
"ContextController",
"extracts",
"the",
"controller",
"name",
"from",
"the",
"given",
"context",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/context.go#L96-L101 | train |
goadesign/goa | context.go | ContextAction | func ContextAction(ctx context.Context) string {
if a := ctx.Value(actionKey); a != nil {
return a.(string)
}
return "<unknown>"
} | go | func ContextAction(ctx context.Context) string {
if a := ctx.Value(actionKey); a != nil {
return a.(string)
}
return "<unknown>"
} | [
"func",
"ContextAction",
"(",
"ctx",
"context",
".",
"Context",
")",
"string",
"{",
"if",
"a",
":=",
"ctx",
".",
"Value",
"(",
"actionKey",
")",
";",
"a",
"!=",
"nil",
"{",
"return",
"a",
".",
"(",
"string",
")",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
"\n",
"}"
] | // ContextAction extracts the action name from the given context. | [
"ContextAction",
"extracts",
"the",
"action",
"name",
"from",
"the",
"given",
"context",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/context.go#L104-L109 | train |
goadesign/goa | context.go | ContextRequest | func ContextRequest(ctx context.Context) *RequestData {
if r := ctx.Value(reqKey); r != nil {
return r.(*RequestData)
}
return nil
} | go | func ContextRequest(ctx context.Context) *RequestData {
if r := ctx.Value(reqKey); r != nil {
return r.(*RequestData)
}
return nil
} | [
"func",
"ContextRequest",
"(",
"ctx",
"context",
".",
"Context",
")",
"*",
"RequestData",
"{",
"if",
"r",
":=",
"ctx",
".",
"Value",
"(",
"reqKey",
")",
";",
"r",
"!=",
"nil",
"{",
"return",
"r",
".",
"(",
"*",
"RequestData",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // ContextRequest extracts the request data from the given context. | [
"ContextRequest",
"extracts",
"the",
"request",
"data",
"from",
"the",
"given",
"context",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/context.go#L112-L117 | train |
goadesign/goa | context.go | ContextResponse | func ContextResponse(ctx context.Context) *ResponseData {
if r := ctx.Value(respKey); r != nil {
return r.(*ResponseData)
}
return nil
} | go | func ContextResponse(ctx context.Context) *ResponseData {
if r := ctx.Value(respKey); r != nil {
return r.(*ResponseData)
}
return nil
} | [
"func",
"ContextResponse",
"(",
"ctx",
"context",
".",
"Context",
")",
"*",
"ResponseData",
"{",
"if",
"r",
":=",
"ctx",
".",
"Value",
"(",
"respKey",
")",
";",
"r",
"!=",
"nil",
"{",
"return",
"r",
".",
"(",
"*",
"ResponseData",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // ContextResponse extracts the response data from the given context. | [
"ContextResponse",
"extracts",
"the",
"response",
"data",
"from",
"the",
"given",
"context",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/context.go#L120-L125 | train |
goadesign/goa | context.go | ContextLogger | func ContextLogger(ctx context.Context) LogAdapter {
if v := ctx.Value(logKey); v != nil {
return v.(LogAdapter)
}
return nil
} | go | func ContextLogger(ctx context.Context) LogAdapter {
if v := ctx.Value(logKey); v != nil {
return v.(LogAdapter)
}
return nil
} | [
"func",
"ContextLogger",
"(",
"ctx",
"context",
".",
"Context",
")",
"LogAdapter",
"{",
"if",
"v",
":=",
"ctx",
".",
"Value",
"(",
"logKey",
")",
";",
"v",
"!=",
"nil",
"{",
"return",
"v",
".",
"(",
"LogAdapter",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // ContextLogger extracts the logger from the given context. | [
"ContextLogger",
"extracts",
"the",
"logger",
"from",
"the",
"given",
"context",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/context.go#L128-L133 | train |
goadesign/goa | context.go | ContextError | func ContextError(ctx context.Context) error {
if err := ctx.Value(errKey); err != nil {
return err.(error)
}
return nil
} | go | func ContextError(ctx context.Context) error {
if err := ctx.Value(errKey); err != nil {
return err.(error)
}
return nil
} | [
"func",
"ContextError",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"if",
"err",
":=",
"ctx",
".",
"Value",
"(",
"errKey",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
".",
"(",
"error",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // ContextError extracts the error from the given context. | [
"ContextError",
"extracts",
"the",
"error",
"from",
"the",
"given",
"context",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/context.go#L136-L141 | train |
goadesign/goa | context.go | SwitchWriter | func (r *ResponseData) SwitchWriter(rw http.ResponseWriter) http.ResponseWriter {
rwo := r.ResponseWriter
r.ResponseWriter = rw
return rwo
} | go | func (r *ResponseData) SwitchWriter(rw http.ResponseWriter) http.ResponseWriter {
rwo := r.ResponseWriter
r.ResponseWriter = rw
return rwo
} | [
"func",
"(",
"r",
"*",
"ResponseData",
")",
"SwitchWriter",
"(",
"rw",
"http",
".",
"ResponseWriter",
")",
"http",
".",
"ResponseWriter",
"{",
"rwo",
":=",
"r",
".",
"ResponseWriter",
"\n",
"r",
".",
"ResponseWriter",
"=",
"rw",
"\n",
"return",
"rwo",
"\n",
"}"
] | // SwitchWriter overrides the underlying response writer. It returns the response
// writer that was previously set. | [
"SwitchWriter",
"overrides",
"the",
"underlying",
"response",
"writer",
".",
"It",
"returns",
"the",
"response",
"writer",
"that",
"was",
"previously",
"set",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/context.go#L145-L149 | train |
goadesign/goa | context.go | WriteHeader | func (r *ResponseData) WriteHeader(status int) {
go IncrCounter([]string{"goa", "response", strconv.Itoa(status)}, 1.0)
r.Status = status
r.ResponseWriter.WriteHeader(status)
} | go | func (r *ResponseData) WriteHeader(status int) {
go IncrCounter([]string{"goa", "response", strconv.Itoa(status)}, 1.0)
r.Status = status
r.ResponseWriter.WriteHeader(status)
} | [
"func",
"(",
"r",
"*",
"ResponseData",
")",
"WriteHeader",
"(",
"status",
"int",
")",
"{",
"go",
"IncrCounter",
"(",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
",",
"strconv",
".",
"Itoa",
"(",
"status",
")",
"}",
",",
"1.0",
")",
"\n",
"r",
".",
"Status",
"=",
"status",
"\n",
"r",
".",
"ResponseWriter",
".",
"WriteHeader",
"(",
"status",
")",
"\n",
"}"
] | // WriteHeader records the response status code and calls the underlying writer. | [
"WriteHeader",
"records",
"the",
"response",
"status",
"code",
"and",
"calls",
"the",
"underlying",
"writer",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/context.go#L157-L161 | train |
goadesign/goa | context.go | Write | func (r *ResponseData) Write(b []byte) (int, error) {
if !r.Written() {
r.WriteHeader(http.StatusOK)
}
r.Length += len(b)
return r.ResponseWriter.Write(b)
} | go | func (r *ResponseData) Write(b []byte) (int, error) {
if !r.Written() {
r.WriteHeader(http.StatusOK)
}
r.Length += len(b)
return r.ResponseWriter.Write(b)
} | [
"func",
"(",
"r",
"*",
"ResponseData",
")",
"Write",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"if",
"!",
"r",
".",
"Written",
"(",
")",
"{",
"r",
".",
"WriteHeader",
"(",
"http",
".",
"StatusOK",
")",
"\n",
"}",
"\n",
"r",
".",
"Length",
"+=",
"len",
"(",
"b",
")",
"\n",
"return",
"r",
".",
"ResponseWriter",
".",
"Write",
"(",
"b",
")",
"\n",
"}"
] | // Write records the amount of data written and calls the underlying writer. | [
"Write",
"records",
"the",
"amount",
"of",
"data",
"written",
"and",
"calls",
"the",
"underlying",
"writer",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/context.go#L164-L170 | train |
goadesign/goa | goagen/gen_main/generator.go | funcMap | func funcMap(appPkg string, actionImpls map[string]string) template.FuncMap {
return template.FuncMap{
"tempvar": tempvar,
"okResp": okResp,
"targetPkg": func() string { return appPkg },
"actionBody": func(name string) string {
body, ok := actionImpls[name]
if !ok {
return defaultActionBody
}
return body
},
"printResp": func(name string) bool {
_, ok := actionImpls[name]
return !ok
},
}
} | go | func funcMap(appPkg string, actionImpls map[string]string) template.FuncMap {
return template.FuncMap{
"tempvar": tempvar,
"okResp": okResp,
"targetPkg": func() string { return appPkg },
"actionBody": func(name string) string {
body, ok := actionImpls[name]
if !ok {
return defaultActionBody
}
return body
},
"printResp": func(name string) bool {
_, ok := actionImpls[name]
return !ok
},
}
} | [
"func",
"funcMap",
"(",
"appPkg",
"string",
",",
"actionImpls",
"map",
"[",
"string",
"]",
"string",
")",
"template",
".",
"FuncMap",
"{",
"return",
"template",
".",
"FuncMap",
"{",
"\"",
"\"",
":",
"tempvar",
",",
"\"",
"\"",
":",
"okResp",
",",
"\"",
"\"",
":",
"func",
"(",
")",
"string",
"{",
"return",
"appPkg",
"}",
",",
"\"",
"\"",
":",
"func",
"(",
"name",
"string",
")",
"string",
"{",
"body",
",",
"ok",
":=",
"actionImpls",
"[",
"name",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"defaultActionBody",
"\n",
"}",
"\n",
"return",
"body",
"\n",
"}",
",",
"\"",
"\"",
":",
"func",
"(",
"name",
"string",
")",
"bool",
"{",
"_",
",",
"ok",
":=",
"actionImpls",
"[",
"name",
"]",
"\n",
"return",
"!",
"ok",
"\n",
"}",
",",
"}",
"\n",
"}"
] | // funcMap creates the funcMap used to render the controller code. | [
"funcMap",
"creates",
"the",
"funcMap",
"used",
"to",
"render",
"the",
"controller",
"code",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/goagen/gen_main/generator.go#L380-L397 | train |
goadesign/goa | middleware/gzip/middleware.go | AddContentTypes | func AddContentTypes(types ...string) Option {
return func(c *options) error {
dst := make([]string, len(c.contentTypes)+len(types))
copy(dst, c.contentTypes)
copy(dst[len(c.contentTypes):], types)
c.contentTypes = dst
return nil
}
} | go | func AddContentTypes(types ...string) Option {
return func(c *options) error {
dst := make([]string, len(c.contentTypes)+len(types))
copy(dst, c.contentTypes)
copy(dst[len(c.contentTypes):], types)
c.contentTypes = dst
return nil
}
} | [
"func",
"AddContentTypes",
"(",
"types",
"...",
"string",
")",
"Option",
"{",
"return",
"func",
"(",
"c",
"*",
"options",
")",
"error",
"{",
"dst",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"c",
".",
"contentTypes",
")",
"+",
"len",
"(",
"types",
")",
")",
"\n",
"copy",
"(",
"dst",
",",
"c",
".",
"contentTypes",
")",
"\n",
"copy",
"(",
"dst",
"[",
"len",
"(",
"c",
".",
"contentTypes",
")",
":",
"]",
",",
"types",
")",
"\n",
"c",
".",
"contentTypes",
"=",
"dst",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // AddContentTypes allows to specify specific content types to encode.
// Adds to previous content types. | [
"AddContentTypes",
"allows",
"to",
"specify",
"specific",
"content",
"types",
"to",
"encode",
".",
"Adds",
"to",
"previous",
"content",
"types",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/middleware/gzip/middleware.go#L168-L176 | train |
goadesign/goa | middleware/gzip/middleware.go | AddStatusCodes | func AddStatusCodes(codes ...int) Option {
return func(c *options) error {
dst := make(map[int]struct{}, len(c.statusCodes)+len(codes))
for code := range c.statusCodes {
dst[code] = struct{}{}
}
for _, code := range codes {
c.statusCodes[code] = struct{}{}
}
return nil
}
} | go | func AddStatusCodes(codes ...int) Option {
return func(c *options) error {
dst := make(map[int]struct{}, len(c.statusCodes)+len(codes))
for code := range c.statusCodes {
dst[code] = struct{}{}
}
for _, code := range codes {
c.statusCodes[code] = struct{}{}
}
return nil
}
} | [
"func",
"AddStatusCodes",
"(",
"codes",
"...",
"int",
")",
"Option",
"{",
"return",
"func",
"(",
"c",
"*",
"options",
")",
"error",
"{",
"dst",
":=",
"make",
"(",
"map",
"[",
"int",
"]",
"struct",
"{",
"}",
",",
"len",
"(",
"c",
".",
"statusCodes",
")",
"+",
"len",
"(",
"codes",
")",
")",
"\n",
"for",
"code",
":=",
"range",
"c",
".",
"statusCodes",
"{",
"dst",
"[",
"code",
"]",
"=",
"struct",
"{",
"}",
"{",
"}",
"\n",
"}",
"\n",
"for",
"_",
",",
"code",
":=",
"range",
"codes",
"{",
"c",
".",
"statusCodes",
"[",
"code",
"]",
"=",
"struct",
"{",
"}",
"{",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // AddStatusCodes allows to specify specific content types to encode.
// All content types that has the supplied prefixes are compressed. | [
"AddStatusCodes",
"allows",
"to",
"specify",
"specific",
"content",
"types",
"to",
"encode",
".",
"All",
"content",
"types",
"that",
"has",
"the",
"supplied",
"prefixes",
"are",
"compressed",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/middleware/gzip/middleware.go#L194-L205 | train |
goadesign/goa | middleware/gzip/middleware.go | MinSize | func MinSize(n int) Option {
return func(c *options) error {
if n <= 0 {
c.minSize = 0
return nil
}
c.minSize = n
return nil
}
} | go | func MinSize(n int) Option {
return func(c *options) error {
if n <= 0 {
c.minSize = 0
return nil
}
c.minSize = n
return nil
}
} | [
"func",
"MinSize",
"(",
"n",
"int",
")",
"Option",
"{",
"return",
"func",
"(",
"c",
"*",
"options",
")",
"error",
"{",
"if",
"n",
"<=",
"0",
"{",
"c",
".",
"minSize",
"=",
"0",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"c",
".",
"minSize",
"=",
"n",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // MinSize will set a minimum size for compression. | [
"MinSize",
"will",
"set",
"a",
"minimum",
"size",
"for",
"compression",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/middleware/gzip/middleware.go#L225-L234 | train |
goadesign/goa | middleware/gzip/middleware.go | IgnoreRange | func IgnoreRange(b bool) Option {
return func(c *options) error {
c.ignoreRange = b
return nil
}
} | go | func IgnoreRange(b bool) Option {
return func(c *options) error {
c.ignoreRange = b
return nil
}
} | [
"func",
"IgnoreRange",
"(",
"b",
"bool",
")",
"Option",
"{",
"return",
"func",
"(",
"c",
"*",
"options",
")",
"error",
"{",
"c",
".",
"ignoreRange",
"=",
"b",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}"
] | // IgnoreRange will set make the compressor ignore Range requests.
// Range requests are incompatible with compressed content,
// so if this is set to true "Range" headers will be ignored.
// If set to false, compression is disabled for all requests with Range header. | [
"IgnoreRange",
"will",
"set",
"make",
"the",
"compressor",
"ignore",
"Range",
"requests",
".",
"Range",
"requests",
"are",
"incompatible",
"with",
"compressed",
"content",
"so",
"if",
"this",
"is",
"set",
"to",
"true",
"Range",
"headers",
"will",
"be",
"ignored",
".",
"If",
"set",
"to",
"false",
"compression",
"is",
"disabled",
"for",
"all",
"requests",
"with",
"Range",
"header",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/middleware/gzip/middleware.go#L240-L245 | train |
goadesign/goa | middleware/gzip/middleware.go | Middleware | func Middleware(level int, o ...Option) goa.Middleware {
opts := options{
ignoreRange: true,
minSize: 256,
contentTypes: defaultContentTypes,
}
opts.statusCodes = make(map[int]struct{}, len(defaultStatusCodes))
for _, v := range defaultStatusCodes {
opts.statusCodes[v] = struct{}{}
}
for _, opt := range o {
err := opt(&opts)
if err != nil {
panic(err)
}
}
gzipPool := sync.Pool{
New: func() interface{} {
gz, err := gzip.NewWriterLevel(ioutil.Discard, level)
if err != nil {
panic(err)
}
return gz
},
}
return func(h goa.Handler) goa.Handler {
return func(ctx context.Context, rw http.ResponseWriter, req *http.Request) (err error) {
// Skip compression if the client doesn't accept gzip encoding, is
// requesting a WebSocket or the data is already compressed.
if !strings.Contains(req.Header.Get(headerAcceptEncoding), encodingGzip) ||
len(req.Header.Get(headerSecWebSocketKey)) > 0 ||
rw.Header().Get(headerContentEncoding) == encodingGzip ||
(!opts.ignoreRange && req.Header.Get(headerRange) != "") {
return h(ctx, rw, req)
}
// Set the appropriate gzip headers.
resp := goa.ContextResponse(ctx)
// Get the original http.ResponseWriter
w := resp.SwitchWriter(nil)
// Wrap the original http.ResponseWriter with our gzipResponseWriter
grw := &gzipResponseWriter{
ResponseWriter: w,
pool: &gzipPool,
statusCode: http.StatusOK,
o: opts,
}
// Set the new http.ResponseWriter
resp.SwitchWriter(grw)
// We cannot do ranges, if possibly gzipped responses.
req.Header.Del("Range")
// Call the next handler supplying the gzipResponseWriter instead of
// the original.
err = h(ctx, rw, req)
if err != nil {
return
}
// Check for uncompressed data
if grw.buf.Len() > 0 {
w.Header().Set(headerContentLength, strconv.Itoa(grw.buf.Len()))
w.WriteHeader(grw.statusCode)
_, err = w.Write(grw.buf.Bytes())
return
}
// Flush compressor.
if grw.gzw != nil {
if err = grw.gzw.Close(); err != nil {
return
}
gzipPool.Put(grw.gzw)
return
}
// No writes, set status code.
if grw.shouldCompress == nil {
w.WriteHeader(grw.statusCode)
}
return
}
}
} | go | func Middleware(level int, o ...Option) goa.Middleware {
opts := options{
ignoreRange: true,
minSize: 256,
contentTypes: defaultContentTypes,
}
opts.statusCodes = make(map[int]struct{}, len(defaultStatusCodes))
for _, v := range defaultStatusCodes {
opts.statusCodes[v] = struct{}{}
}
for _, opt := range o {
err := opt(&opts)
if err != nil {
panic(err)
}
}
gzipPool := sync.Pool{
New: func() interface{} {
gz, err := gzip.NewWriterLevel(ioutil.Discard, level)
if err != nil {
panic(err)
}
return gz
},
}
return func(h goa.Handler) goa.Handler {
return func(ctx context.Context, rw http.ResponseWriter, req *http.Request) (err error) {
// Skip compression if the client doesn't accept gzip encoding, is
// requesting a WebSocket or the data is already compressed.
if !strings.Contains(req.Header.Get(headerAcceptEncoding), encodingGzip) ||
len(req.Header.Get(headerSecWebSocketKey)) > 0 ||
rw.Header().Get(headerContentEncoding) == encodingGzip ||
(!opts.ignoreRange && req.Header.Get(headerRange) != "") {
return h(ctx, rw, req)
}
// Set the appropriate gzip headers.
resp := goa.ContextResponse(ctx)
// Get the original http.ResponseWriter
w := resp.SwitchWriter(nil)
// Wrap the original http.ResponseWriter with our gzipResponseWriter
grw := &gzipResponseWriter{
ResponseWriter: w,
pool: &gzipPool,
statusCode: http.StatusOK,
o: opts,
}
// Set the new http.ResponseWriter
resp.SwitchWriter(grw)
// We cannot do ranges, if possibly gzipped responses.
req.Header.Del("Range")
// Call the next handler supplying the gzipResponseWriter instead of
// the original.
err = h(ctx, rw, req)
if err != nil {
return
}
// Check for uncompressed data
if grw.buf.Len() > 0 {
w.Header().Set(headerContentLength, strconv.Itoa(grw.buf.Len()))
w.WriteHeader(grw.statusCode)
_, err = w.Write(grw.buf.Bytes())
return
}
// Flush compressor.
if grw.gzw != nil {
if err = grw.gzw.Close(); err != nil {
return
}
gzipPool.Put(grw.gzw)
return
}
// No writes, set status code.
if grw.shouldCompress == nil {
w.WriteHeader(grw.statusCode)
}
return
}
}
} | [
"func",
"Middleware",
"(",
"level",
"int",
",",
"o",
"...",
"Option",
")",
"goa",
".",
"Middleware",
"{",
"opts",
":=",
"options",
"{",
"ignoreRange",
":",
"true",
",",
"minSize",
":",
"256",
",",
"contentTypes",
":",
"defaultContentTypes",
",",
"}",
"\n",
"opts",
".",
"statusCodes",
"=",
"make",
"(",
"map",
"[",
"int",
"]",
"struct",
"{",
"}",
",",
"len",
"(",
"defaultStatusCodes",
")",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"defaultStatusCodes",
"{",
"opts",
".",
"statusCodes",
"[",
"v",
"]",
"=",
"struct",
"{",
"}",
"{",
"}",
"\n",
"}",
"\n",
"for",
"_",
",",
"opt",
":=",
"range",
"o",
"{",
"err",
":=",
"opt",
"(",
"&",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"gzipPool",
":=",
"sync",
".",
"Pool",
"{",
"New",
":",
"func",
"(",
")",
"interface",
"{",
"}",
"{",
"gz",
",",
"err",
":=",
"gzip",
".",
"NewWriterLevel",
"(",
"ioutil",
".",
"Discard",
",",
"level",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"gz",
"\n",
"}",
",",
"}",
"\n",
"return",
"func",
"(",
"h",
"goa",
".",
"Handler",
")",
"goa",
".",
"Handler",
"{",
"return",
"func",
"(",
"ctx",
"context",
".",
"Context",
",",
"rw",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
")",
"(",
"err",
"error",
")",
"{",
"// Skip compression if the client doesn't accept gzip encoding, is",
"// requesting a WebSocket or the data is already compressed.",
"if",
"!",
"strings",
".",
"Contains",
"(",
"req",
".",
"Header",
".",
"Get",
"(",
"headerAcceptEncoding",
")",
",",
"encodingGzip",
")",
"||",
"len",
"(",
"req",
".",
"Header",
".",
"Get",
"(",
"headerSecWebSocketKey",
")",
")",
">",
"0",
"||",
"rw",
".",
"Header",
"(",
")",
".",
"Get",
"(",
"headerContentEncoding",
")",
"==",
"encodingGzip",
"||",
"(",
"!",
"opts",
".",
"ignoreRange",
"&&",
"req",
".",
"Header",
".",
"Get",
"(",
"headerRange",
")",
"!=",
"\"",
"\"",
")",
"{",
"return",
"h",
"(",
"ctx",
",",
"rw",
",",
"req",
")",
"\n",
"}",
"\n\n",
"// Set the appropriate gzip headers.",
"resp",
":=",
"goa",
".",
"ContextResponse",
"(",
"ctx",
")",
"\n\n",
"// Get the original http.ResponseWriter",
"w",
":=",
"resp",
".",
"SwitchWriter",
"(",
"nil",
")",
"\n\n",
"// Wrap the original http.ResponseWriter with our gzipResponseWriter",
"grw",
":=",
"&",
"gzipResponseWriter",
"{",
"ResponseWriter",
":",
"w",
",",
"pool",
":",
"&",
"gzipPool",
",",
"statusCode",
":",
"http",
".",
"StatusOK",
",",
"o",
":",
"opts",
",",
"}",
"\n\n",
"// Set the new http.ResponseWriter",
"resp",
".",
"SwitchWriter",
"(",
"grw",
")",
"\n\n",
"// We cannot do ranges, if possibly gzipped responses.",
"req",
".",
"Header",
".",
"Del",
"(",
"\"",
"\"",
")",
"\n\n",
"// Call the next handler supplying the gzipResponseWriter instead of",
"// the original.",
"err",
"=",
"h",
"(",
"ctx",
",",
"rw",
",",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"// Check for uncompressed data",
"if",
"grw",
".",
"buf",
".",
"Len",
"(",
")",
">",
"0",
"{",
"w",
".",
"Header",
"(",
")",
".",
"Set",
"(",
"headerContentLength",
",",
"strconv",
".",
"Itoa",
"(",
"grw",
".",
"buf",
".",
"Len",
"(",
")",
")",
")",
"\n",
"w",
".",
"WriteHeader",
"(",
"grw",
".",
"statusCode",
")",
"\n",
"_",
",",
"err",
"=",
"w",
".",
"Write",
"(",
"grw",
".",
"buf",
".",
"Bytes",
"(",
")",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"// Flush compressor.",
"if",
"grw",
".",
"gzw",
"!=",
"nil",
"{",
"if",
"err",
"=",
"grw",
".",
"gzw",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"gzipPool",
".",
"Put",
"(",
"grw",
".",
"gzw",
")",
"\n",
"return",
"\n",
"}",
"\n",
"// No writes, set status code.",
"if",
"grw",
".",
"shouldCompress",
"==",
"nil",
"{",
"w",
".",
"WriteHeader",
"(",
"grw",
".",
"statusCode",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Middleware encodes the response using Gzip encoding and sets all the
// appropriate headers. If the Content-Type is not set, it will be set by
// calling http.DetectContentType on the data being written. | [
"Middleware",
"encodes",
"the",
"response",
"using",
"Gzip",
"encoding",
"and",
"sets",
"all",
"the",
"appropriate",
"headers",
".",
"If",
"the",
"Content",
"-",
"Type",
"is",
"not",
"set",
"it",
"will",
"be",
"set",
"by",
"calling",
"http",
".",
"DetectContentType",
"on",
"the",
"data",
"being",
"written",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/middleware/gzip/middleware.go#L250-L336 | train |
goadesign/goa | middleware/gzip/middleware.go | shouldCompress | func (o options) shouldCompress(contentType string, statusCode int) bool {
// If contentTypes is nil we handle all content types.
if len(o.contentTypes) > 0 {
ct := strings.ToLower(contentType)
ct = strings.Split(ct, ";")[0]
found := false
for _, v := range o.contentTypes {
if strings.HasPrefix(ct, v) {
found = true
break
}
}
if !found {
return false
}
}
if len(o.statusCodes) > 0 {
_, ok := o.statusCodes[statusCode]
if !ok {
return false
}
}
return true
} | go | func (o options) shouldCompress(contentType string, statusCode int) bool {
// If contentTypes is nil we handle all content types.
if len(o.contentTypes) > 0 {
ct := strings.ToLower(contentType)
ct = strings.Split(ct, ";")[0]
found := false
for _, v := range o.contentTypes {
if strings.HasPrefix(ct, v) {
found = true
break
}
}
if !found {
return false
}
}
if len(o.statusCodes) > 0 {
_, ok := o.statusCodes[statusCode]
if !ok {
return false
}
}
return true
} | [
"func",
"(",
"o",
"options",
")",
"shouldCompress",
"(",
"contentType",
"string",
",",
"statusCode",
"int",
")",
"bool",
"{",
"// If contentTypes is nil we handle all content types.",
"if",
"len",
"(",
"o",
".",
"contentTypes",
")",
">",
"0",
"{",
"ct",
":=",
"strings",
".",
"ToLower",
"(",
"contentType",
")",
"\n",
"ct",
"=",
"strings",
".",
"Split",
"(",
"ct",
",",
"\"",
"\"",
")",
"[",
"0",
"]",
"\n",
"found",
":=",
"false",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"o",
".",
"contentTypes",
"{",
"if",
"strings",
".",
"HasPrefix",
"(",
"ct",
",",
"v",
")",
"{",
"found",
"=",
"true",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"!",
"found",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"len",
"(",
"o",
".",
"statusCodes",
")",
">",
"0",
"{",
"_",
",",
"ok",
":=",
"o",
".",
"statusCodes",
"[",
"statusCode",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"true",
"\n",
"}"
] | // returns true if we've been configured to compress the specific content type. | [
"returns",
"true",
"if",
"we",
"ve",
"been",
"configured",
"to",
"compress",
"the",
"specific",
"content",
"type",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/middleware/gzip/middleware.go#L339-L363 | train |
goadesign/goa | middleware/xray/transport.go | RoundTrip | func (t *xrayTransport) RoundTrip(req *http.Request) (*http.Response, error) {
s := ContextSegment(req.Context())
if s == nil {
return t.wrapped.RoundTrip(req)
}
sub := s.NewSubsegment(req.URL.Host)
defer sub.Close()
sub.RecordRequest(req, "remote")
resp, err := t.wrapped.RoundTrip(req)
if err != nil {
sub.RecordError(err)
} else {
sub.RecordResponse(resp)
}
return resp, err
} | go | func (t *xrayTransport) RoundTrip(req *http.Request) (*http.Response, error) {
s := ContextSegment(req.Context())
if s == nil {
return t.wrapped.RoundTrip(req)
}
sub := s.NewSubsegment(req.URL.Host)
defer sub.Close()
sub.RecordRequest(req, "remote")
resp, err := t.wrapped.RoundTrip(req)
if err != nil {
sub.RecordError(err)
} else {
sub.RecordResponse(resp)
}
return resp, err
} | [
"func",
"(",
"t",
"*",
"xrayTransport",
")",
"RoundTrip",
"(",
"req",
"*",
"http",
".",
"Request",
")",
"(",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"s",
":=",
"ContextSegment",
"(",
"req",
".",
"Context",
"(",
")",
")",
"\n",
"if",
"s",
"==",
"nil",
"{",
"return",
"t",
".",
"wrapped",
".",
"RoundTrip",
"(",
"req",
")",
"\n",
"}",
"\n\n",
"sub",
":=",
"s",
".",
"NewSubsegment",
"(",
"req",
".",
"URL",
".",
"Host",
")",
"\n",
"defer",
"sub",
".",
"Close",
"(",
")",
"\n\n",
"sub",
".",
"RecordRequest",
"(",
"req",
",",
"\"",
"\"",
")",
"\n\n",
"resp",
",",
"err",
":=",
"t",
".",
"wrapped",
".",
"RoundTrip",
"(",
"req",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"sub",
".",
"RecordError",
"(",
"err",
")",
"\n",
"}",
"else",
"{",
"sub",
".",
"RecordResponse",
"(",
"resp",
")",
"\n",
"}",
"\n\n",
"return",
"resp",
",",
"err",
"\n",
"}"
] | // RoundTrip wraps the original RoundTripper.RoundTrip to create xray tracing segments | [
"RoundTrip",
"wraps",
"the",
"original",
"RoundTripper",
".",
"RoundTrip",
"to",
"create",
"xray",
"tracing",
"segments"
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/middleware/xray/transport.go#L26-L46 | train |
goadesign/goa | middleware.go | handlerToMiddleware | func handlerToMiddleware(m Handler) Middleware {
return func(h Handler) Handler {
return func(ctx context.Context, rw http.ResponseWriter, req *http.Request) error {
if err := m(ctx, rw, req); err != nil {
return err
}
return h(ctx, rw, req)
}
}
} | go | func handlerToMiddleware(m Handler) Middleware {
return func(h Handler) Handler {
return func(ctx context.Context, rw http.ResponseWriter, req *http.Request) error {
if err := m(ctx, rw, req); err != nil {
return err
}
return h(ctx, rw, req)
}
}
} | [
"func",
"handlerToMiddleware",
"(",
"m",
"Handler",
")",
"Middleware",
"{",
"return",
"func",
"(",
"h",
"Handler",
")",
"Handler",
"{",
"return",
"func",
"(",
"ctx",
"context",
".",
"Context",
",",
"rw",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
")",
"error",
"{",
"if",
"err",
":=",
"m",
"(",
"ctx",
",",
"rw",
",",
"req",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"h",
"(",
"ctx",
",",
"rw",
",",
"req",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // handlerToMiddleware creates a middleware from a raw handler.
// The middleware calls the handler and either breaks the middleware chain if the handler returns
// an error by also returning the error or calls the next handler in the chain otherwise. | [
"handlerToMiddleware",
"creates",
"a",
"middleware",
"from",
"a",
"raw",
"handler",
".",
"The",
"middleware",
"calls",
"the",
"handler",
"and",
"either",
"breaks",
"the",
"middleware",
"chain",
"if",
"the",
"handler",
"returns",
"an",
"error",
"by",
"also",
"returning",
"the",
"error",
"or",
"calls",
"the",
"next",
"handler",
"in",
"the",
"chain",
"otherwise",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/middleware.go#L59-L68 | train |
goadesign/goa | middleware.go | httpHandlerToMiddleware | func httpHandlerToMiddleware(m http.HandlerFunc) Middleware {
return func(h Handler) Handler {
return func(ctx context.Context, rw http.ResponseWriter, req *http.Request) error {
m.ServeHTTP(rw, req)
return h(ctx, rw, req)
}
}
} | go | func httpHandlerToMiddleware(m http.HandlerFunc) Middleware {
return func(h Handler) Handler {
return func(ctx context.Context, rw http.ResponseWriter, req *http.Request) error {
m.ServeHTTP(rw, req)
return h(ctx, rw, req)
}
}
} | [
"func",
"httpHandlerToMiddleware",
"(",
"m",
"http",
".",
"HandlerFunc",
")",
"Middleware",
"{",
"return",
"func",
"(",
"h",
"Handler",
")",
"Handler",
"{",
"return",
"func",
"(",
"ctx",
"context",
".",
"Context",
",",
"rw",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
")",
"error",
"{",
"m",
".",
"ServeHTTP",
"(",
"rw",
",",
"req",
")",
"\n",
"return",
"h",
"(",
"ctx",
",",
"rw",
",",
"req",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // httpHandlerToMiddleware creates a middleware from a http.HandlerFunc.
// The middleware calls the ServerHTTP method exposed by the http handler and then calls the next
// middleware in the chain. | [
"httpHandlerToMiddleware",
"creates",
"a",
"middleware",
"from",
"a",
"http",
".",
"HandlerFunc",
".",
"The",
"middleware",
"calls",
"the",
"ServerHTTP",
"method",
"exposed",
"by",
"the",
"http",
"handler",
"and",
"then",
"calls",
"the",
"next",
"middleware",
"in",
"the",
"chain",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/middleware.go#L73-L80 | train |
goadesign/goa | goagen/codegen/workspace.go | NewWorkspace | func NewWorkspace(prefix string) (*Workspace, error) {
dir, err := ioutil.TempDir("", prefix)
if err != nil {
return nil, err
}
// create workspace layout
os.MkdirAll(filepath.Join(dir, "src"), 0755)
os.MkdirAll(filepath.Join(dir, "pkg"), 0755)
os.MkdirAll(filepath.Join(dir, "bin"), 0755)
// setup GOPATH
gopath := envOr("GOPATH", build.Default.GOPATH)
os.Setenv("GOPATH", fmt.Sprintf("%s%c%s", dir, os.PathListSeparator, gopath))
// we're done
return &Workspace{Path: dir, gopath: gopath}, nil
} | go | func NewWorkspace(prefix string) (*Workspace, error) {
dir, err := ioutil.TempDir("", prefix)
if err != nil {
return nil, err
}
// create workspace layout
os.MkdirAll(filepath.Join(dir, "src"), 0755)
os.MkdirAll(filepath.Join(dir, "pkg"), 0755)
os.MkdirAll(filepath.Join(dir, "bin"), 0755)
// setup GOPATH
gopath := envOr("GOPATH", build.Default.GOPATH)
os.Setenv("GOPATH", fmt.Sprintf("%s%c%s", dir, os.PathListSeparator, gopath))
// we're done
return &Workspace{Path: dir, gopath: gopath}, nil
} | [
"func",
"NewWorkspace",
"(",
"prefix",
"string",
")",
"(",
"*",
"Workspace",
",",
"error",
")",
"{",
"dir",
",",
"err",
":=",
"ioutil",
".",
"TempDir",
"(",
"\"",
"\"",
",",
"prefix",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"// create workspace layout",
"os",
".",
"MkdirAll",
"(",
"filepath",
".",
"Join",
"(",
"dir",
",",
"\"",
"\"",
")",
",",
"0755",
")",
"\n",
"os",
".",
"MkdirAll",
"(",
"filepath",
".",
"Join",
"(",
"dir",
",",
"\"",
"\"",
")",
",",
"0755",
")",
"\n",
"os",
".",
"MkdirAll",
"(",
"filepath",
".",
"Join",
"(",
"dir",
",",
"\"",
"\"",
")",
",",
"0755",
")",
"\n\n",
"// setup GOPATH",
"gopath",
":=",
"envOr",
"(",
"\"",
"\"",
",",
"build",
".",
"Default",
".",
"GOPATH",
")",
"\n",
"os",
".",
"Setenv",
"(",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"dir",
",",
"os",
".",
"PathListSeparator",
",",
"gopath",
")",
")",
"\n\n",
"// we're done",
"return",
"&",
"Workspace",
"{",
"Path",
":",
"dir",
",",
"gopath",
":",
"gopath",
"}",
",",
"nil",
"\n",
"}"
] | // NewWorkspace returns a newly created temporary Go workspace.
// Use Delete to delete the corresponding temporary directory when done. | [
"NewWorkspace",
"returns",
"a",
"newly",
"created",
"temporary",
"Go",
"workspace",
".",
"Use",
"Delete",
"to",
"delete",
"the",
"corresponding",
"temporary",
"directory",
"when",
"done",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/goagen/codegen/workspace.go#L84-L100 | train |
goadesign/goa | goagen/codegen/workspace.go | WorkspaceFor | func WorkspaceFor(source string) (*Workspace, error) {
gopaths := envOr("GOPATH", build.Default.GOPATH)
// We use absolute paths so that in particular on Windows the case gets normalized
sourcePath, err := filepath.Abs(source)
if err != nil {
sourcePath = source
}
if os.Getenv("GO111MODULE") != "on" { // GOPATH mode
for _, gp := range filepath.SplitList(gopaths) {
gopath, err := filepath.Abs(gp)
if err != nil {
gopath = gp
}
if filepath.HasPrefix(sourcePath, gopath) {
return &Workspace{
gopath: gopaths,
isModuleMode: false,
Path: gopath,
}, nil
}
}
}
if os.Getenv("GO111MODULE") != "off" { // Module mode
root, _ := findModuleRoot(sourcePath, "", false)
if root != "" {
return &Workspace{
gopath: gopaths,
isModuleMode: true,
Path: root,
}, nil
}
}
return nil, fmt.Errorf(`Go source file "%s" not in Go workspace, adjust GOPATH %s or use modules`, source, gopaths)
} | go | func WorkspaceFor(source string) (*Workspace, error) {
gopaths := envOr("GOPATH", build.Default.GOPATH)
// We use absolute paths so that in particular on Windows the case gets normalized
sourcePath, err := filepath.Abs(source)
if err != nil {
sourcePath = source
}
if os.Getenv("GO111MODULE") != "on" { // GOPATH mode
for _, gp := range filepath.SplitList(gopaths) {
gopath, err := filepath.Abs(gp)
if err != nil {
gopath = gp
}
if filepath.HasPrefix(sourcePath, gopath) {
return &Workspace{
gopath: gopaths,
isModuleMode: false,
Path: gopath,
}, nil
}
}
}
if os.Getenv("GO111MODULE") != "off" { // Module mode
root, _ := findModuleRoot(sourcePath, "", false)
if root != "" {
return &Workspace{
gopath: gopaths,
isModuleMode: true,
Path: root,
}, nil
}
}
return nil, fmt.Errorf(`Go source file "%s" not in Go workspace, adjust GOPATH %s or use modules`, source, gopaths)
} | [
"func",
"WorkspaceFor",
"(",
"source",
"string",
")",
"(",
"*",
"Workspace",
",",
"error",
")",
"{",
"gopaths",
":=",
"envOr",
"(",
"\"",
"\"",
",",
"build",
".",
"Default",
".",
"GOPATH",
")",
"\n",
"// We use absolute paths so that in particular on Windows the case gets normalized",
"sourcePath",
",",
"err",
":=",
"filepath",
".",
"Abs",
"(",
"source",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"sourcePath",
"=",
"source",
"\n",
"}",
"\n",
"if",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"!=",
"\"",
"\"",
"{",
"// GOPATH mode",
"for",
"_",
",",
"gp",
":=",
"range",
"filepath",
".",
"SplitList",
"(",
"gopaths",
")",
"{",
"gopath",
",",
"err",
":=",
"filepath",
".",
"Abs",
"(",
"gp",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"gopath",
"=",
"gp",
"\n",
"}",
"\n",
"if",
"filepath",
".",
"HasPrefix",
"(",
"sourcePath",
",",
"gopath",
")",
"{",
"return",
"&",
"Workspace",
"{",
"gopath",
":",
"gopaths",
",",
"isModuleMode",
":",
"false",
",",
"Path",
":",
"gopath",
",",
"}",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"!=",
"\"",
"\"",
"{",
"// Module mode",
"root",
",",
"_",
":=",
"findModuleRoot",
"(",
"sourcePath",
",",
"\"",
"\"",
",",
"false",
")",
"\n",
"if",
"root",
"!=",
"\"",
"\"",
"{",
"return",
"&",
"Workspace",
"{",
"gopath",
":",
"gopaths",
",",
"isModuleMode",
":",
"true",
",",
"Path",
":",
"root",
",",
"}",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"`Go source file \"%s\" not in Go workspace, adjust GOPATH %s or use modules`",
",",
"source",
",",
"gopaths",
")",
"\n",
"}"
] | // WorkspaceFor returns the Go workspace for the given Go source file. | [
"WorkspaceFor",
"returns",
"the",
"Go",
"workspace",
"for",
"the",
"given",
"Go",
"source",
"file",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/goagen/codegen/workspace.go#L103-L136 | train |
goadesign/goa | goagen/codegen/workspace.go | Delete | func (w *Workspace) Delete() {
if w.gopath != "" {
os.Setenv("GOPATH", w.gopath)
}
os.RemoveAll(w.Path)
} | go | func (w *Workspace) Delete() {
if w.gopath != "" {
os.Setenv("GOPATH", w.gopath)
}
os.RemoveAll(w.Path)
} | [
"func",
"(",
"w",
"*",
"Workspace",
")",
"Delete",
"(",
")",
"{",
"if",
"w",
".",
"gopath",
"!=",
"\"",
"\"",
"{",
"os",
".",
"Setenv",
"(",
"\"",
"\"",
",",
"w",
".",
"gopath",
")",
"\n",
"}",
"\n",
"os",
".",
"RemoveAll",
"(",
"w",
".",
"Path",
")",
"\n",
"}"
] | // Delete deletes the workspace temporary directory. | [
"Delete",
"deletes",
"the",
"workspace",
"temporary",
"directory",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/goagen/codegen/workspace.go#L139-L144 | train |
goadesign/goa | goagen/codegen/workspace.go | Reset | func (w *Workspace) Reset() error {
d, err := os.Open(w.Path)
if err != nil {
return err
}
defer d.Close()
names, err := d.Readdirnames(-1)
if err != nil {
return err
}
for _, name := range names {
err = os.RemoveAll(filepath.Join(w.Path, name))
if err != nil {
return err
}
}
return nil
} | go | func (w *Workspace) Reset() error {
d, err := os.Open(w.Path)
if err != nil {
return err
}
defer d.Close()
names, err := d.Readdirnames(-1)
if err != nil {
return err
}
for _, name := range names {
err = os.RemoveAll(filepath.Join(w.Path, name))
if err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"w",
"*",
"Workspace",
")",
"Reset",
"(",
")",
"error",
"{",
"d",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"w",
".",
"Path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"d",
".",
"Close",
"(",
")",
"\n",
"names",
",",
"err",
":=",
"d",
".",
"Readdirnames",
"(",
"-",
"1",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"for",
"_",
",",
"name",
":=",
"range",
"names",
"{",
"err",
"=",
"os",
".",
"RemoveAll",
"(",
"filepath",
".",
"Join",
"(",
"w",
".",
"Path",
",",
"name",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Reset removes all content from the workspace. | [
"Reset",
"removes",
"all",
"content",
"from",
"the",
"workspace",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/goagen/codegen/workspace.go#L147-L164 | train |
goadesign/goa | goagen/codegen/workspace.go | PackageFor | func PackageFor(source string) (*Package, error) {
w, err := WorkspaceFor(source)
if err != nil {
return nil, err
}
basepath := filepath.Join(w.Path, "src") // GOPATH mode.
if w.isModuleMode {
basepath = w.Path // Module mode.
}
path, err := filepath.Rel(basepath, filepath.Dir(source))
if err != nil {
return nil, err
}
return &Package{Workspace: w, Path: filepath.ToSlash(path)}, nil
} | go | func PackageFor(source string) (*Package, error) {
w, err := WorkspaceFor(source)
if err != nil {
return nil, err
}
basepath := filepath.Join(w.Path, "src") // GOPATH mode.
if w.isModuleMode {
basepath = w.Path // Module mode.
}
path, err := filepath.Rel(basepath, filepath.Dir(source))
if err != nil {
return nil, err
}
return &Package{Workspace: w, Path: filepath.ToSlash(path)}, nil
} | [
"func",
"PackageFor",
"(",
"source",
"string",
")",
"(",
"*",
"Package",
",",
"error",
")",
"{",
"w",
",",
"err",
":=",
"WorkspaceFor",
"(",
"source",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"basepath",
":=",
"filepath",
".",
"Join",
"(",
"w",
".",
"Path",
",",
"\"",
"\"",
")",
"// GOPATH mode.",
"\n",
"if",
"w",
".",
"isModuleMode",
"{",
"basepath",
"=",
"w",
".",
"Path",
"// Module mode.",
"\n",
"}",
"\n",
"path",
",",
"err",
":=",
"filepath",
".",
"Rel",
"(",
"basepath",
",",
"filepath",
".",
"Dir",
"(",
"source",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"Package",
"{",
"Workspace",
":",
"w",
",",
"Path",
":",
"filepath",
".",
"ToSlash",
"(",
"path",
")",
"}",
",",
"nil",
"\n",
"}"
] | // PackageFor returns the package for the given source file. | [
"PackageFor",
"returns",
"the",
"package",
"for",
"the",
"given",
"source",
"file",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/goagen/codegen/workspace.go#L178-L192 | train |
goadesign/goa | goagen/codegen/workspace.go | Abs | func (p *Package) Abs() string {
elem := "src" // GOPATH mode.
if p.Workspace.isModuleMode {
elem = "" // Module mode.
}
return filepath.Join(p.Workspace.Path, elem, p.Path)
} | go | func (p *Package) Abs() string {
elem := "src" // GOPATH mode.
if p.Workspace.isModuleMode {
elem = "" // Module mode.
}
return filepath.Join(p.Workspace.Path, elem, p.Path)
} | [
"func",
"(",
"p",
"*",
"Package",
")",
"Abs",
"(",
")",
"string",
"{",
"elem",
":=",
"\"",
"\"",
"// GOPATH mode.",
"\n",
"if",
"p",
".",
"Workspace",
".",
"isModuleMode",
"{",
"elem",
"=",
"\"",
"\"",
"// Module mode.",
"\n",
"}",
"\n",
"return",
"filepath",
".",
"Join",
"(",
"p",
".",
"Workspace",
".",
"Path",
",",
"elem",
",",
"p",
".",
"Path",
")",
"\n",
"}"
] | // Abs returns the absolute path to the package source directory | [
"Abs",
"returns",
"the",
"absolute",
"path",
"to",
"the",
"package",
"source",
"directory"
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/goagen/codegen/workspace.go#L195-L201 | train |
goadesign/goa | goagen/codegen/workspace.go | CreateSourceFile | func (p *Package) CreateSourceFile(name string) (*SourceFile, error) {
os.RemoveAll(filepath.Join(p.Abs(), name))
return p.OpenSourceFile(name)
} | go | func (p *Package) CreateSourceFile(name string) (*SourceFile, error) {
os.RemoveAll(filepath.Join(p.Abs(), name))
return p.OpenSourceFile(name)
} | [
"func",
"(",
"p",
"*",
"Package",
")",
"CreateSourceFile",
"(",
"name",
"string",
")",
"(",
"*",
"SourceFile",
",",
"error",
")",
"{",
"os",
".",
"RemoveAll",
"(",
"filepath",
".",
"Join",
"(",
"p",
".",
"Abs",
"(",
")",
",",
"name",
")",
")",
"\n",
"return",
"p",
".",
"OpenSourceFile",
"(",
"name",
")",
"\n",
"}"
] | // CreateSourceFile creates a Go source file in the given package. If the file
// already exists it is overwritten. | [
"CreateSourceFile",
"creates",
"a",
"Go",
"source",
"file",
"in",
"the",
"given",
"package",
".",
"If",
"the",
"file",
"already",
"exists",
"it",
"is",
"overwritten",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/goagen/codegen/workspace.go#L205-L208 | train |
goadesign/goa | goagen/codegen/workspace.go | OpenSourceFile | func (p *Package) OpenSourceFile(name string) (*SourceFile, error) {
f := &SourceFile{Name: name, Package: p}
file, err := os.OpenFile(f.Abs(), os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644)
if err != nil {
return nil, err
}
f.osFile = file
return f, nil
} | go | func (p *Package) OpenSourceFile(name string) (*SourceFile, error) {
f := &SourceFile{Name: name, Package: p}
file, err := os.OpenFile(f.Abs(), os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644)
if err != nil {
return nil, err
}
f.osFile = file
return f, nil
} | [
"func",
"(",
"p",
"*",
"Package",
")",
"OpenSourceFile",
"(",
"name",
"string",
")",
"(",
"*",
"SourceFile",
",",
"error",
")",
"{",
"f",
":=",
"&",
"SourceFile",
"{",
"Name",
":",
"name",
",",
"Package",
":",
"p",
"}",
"\n",
"file",
",",
"err",
":=",
"os",
".",
"OpenFile",
"(",
"f",
".",
"Abs",
"(",
")",
",",
"os",
".",
"O_CREATE",
"|",
"os",
".",
"O_APPEND",
"|",
"os",
".",
"O_WRONLY",
",",
"0644",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"f",
".",
"osFile",
"=",
"file",
"\n",
"return",
"f",
",",
"nil",
"\n",
"}"
] | // OpenSourceFile opens an existing file to append to it. If the file does not
// exist OpenSourceFile creates it. | [
"OpenSourceFile",
"opens",
"an",
"existing",
"file",
"to",
"append",
"to",
"it",
".",
"If",
"the",
"file",
"does",
"not",
"exist",
"OpenSourceFile",
"creates",
"it",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/goagen/codegen/workspace.go#L212-L220 | train |
goadesign/goa | goagen/codegen/workspace.go | Compile | func (p *Package) Compile(bin string) (string, error) {
gobin, err := exec.LookPath("go")
if err != nil {
return "", fmt.Errorf(`failed to find a go compiler, looked in "%s"`, os.Getenv("PATH"))
}
if runtime.GOOS == "windows" {
bin += ".exe"
}
c := exec.Cmd{
Path: gobin,
Args: []string{gobin, "build", "-o", bin},
Dir: p.Abs(),
}
out, err := c.CombinedOutput()
if err != nil {
if len(out) > 0 {
return "", fmt.Errorf(string(out))
}
return "", fmt.Errorf("failed to compile %s: %s", bin, err)
}
return filepath.Join(p.Abs(), bin), nil
} | go | func (p *Package) Compile(bin string) (string, error) {
gobin, err := exec.LookPath("go")
if err != nil {
return "", fmt.Errorf(`failed to find a go compiler, looked in "%s"`, os.Getenv("PATH"))
}
if runtime.GOOS == "windows" {
bin += ".exe"
}
c := exec.Cmd{
Path: gobin,
Args: []string{gobin, "build", "-o", bin},
Dir: p.Abs(),
}
out, err := c.CombinedOutput()
if err != nil {
if len(out) > 0 {
return "", fmt.Errorf(string(out))
}
return "", fmt.Errorf("failed to compile %s: %s", bin, err)
}
return filepath.Join(p.Abs(), bin), nil
} | [
"func",
"(",
"p",
"*",
"Package",
")",
"Compile",
"(",
"bin",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"gobin",
",",
"err",
":=",
"exec",
".",
"LookPath",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"`failed to find a go compiler, looked in \"%s\"`",
",",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
")",
"\n",
"}",
"\n",
"if",
"runtime",
".",
"GOOS",
"==",
"\"",
"\"",
"{",
"bin",
"+=",
"\"",
"\"",
"\n",
"}",
"\n",
"c",
":=",
"exec",
".",
"Cmd",
"{",
"Path",
":",
"gobin",
",",
"Args",
":",
"[",
"]",
"string",
"{",
"gobin",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"bin",
"}",
",",
"Dir",
":",
"p",
".",
"Abs",
"(",
")",
",",
"}",
"\n",
"out",
",",
"err",
":=",
"c",
".",
"CombinedOutput",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"len",
"(",
"out",
")",
">",
"0",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"string",
"(",
"out",
")",
")",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"bin",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"filepath",
".",
"Join",
"(",
"p",
".",
"Abs",
"(",
")",
",",
"bin",
")",
",",
"nil",
"\n",
"}"
] | // Compile compiles a package and returns the path to the compiled binary. | [
"Compile",
"compiles",
"a",
"package",
"and",
"returns",
"the",
"path",
"to",
"the",
"compiled",
"binary",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/goagen/codegen/workspace.go#L223-L244 | train |
goadesign/goa | goagen/codegen/workspace.go | SourceFileFor | func SourceFileFor(path string) (*SourceFile, error) {
absPath, err := filepath.Abs(path)
if err != nil {
absPath = path
}
p, err := PackageFor(absPath)
if err != nil {
return nil, err
}
return p.OpenSourceFile(filepath.Base(absPath))
} | go | func SourceFileFor(path string) (*SourceFile, error) {
absPath, err := filepath.Abs(path)
if err != nil {
absPath = path
}
p, err := PackageFor(absPath)
if err != nil {
return nil, err
}
return p.OpenSourceFile(filepath.Base(absPath))
} | [
"func",
"SourceFileFor",
"(",
"path",
"string",
")",
"(",
"*",
"SourceFile",
",",
"error",
")",
"{",
"absPath",
",",
"err",
":=",
"filepath",
".",
"Abs",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"absPath",
"=",
"path",
"\n",
"}",
"\n",
"p",
",",
"err",
":=",
"PackageFor",
"(",
"absPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"p",
".",
"OpenSourceFile",
"(",
"filepath",
".",
"Base",
"(",
"absPath",
")",
")",
"\n",
"}"
] | // SourceFileFor returns a SourceFile for the file at the given path. | [
"SourceFileFor",
"returns",
"a",
"SourceFile",
"for",
"the",
"file",
"at",
"the",
"given",
"path",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/goagen/codegen/workspace.go#L247-L257 | train |
goadesign/goa | goagen/codegen/workspace.go | WriteHeader | func (f *SourceFile) WriteHeader(title, pack string, imports []*ImportSpec) error {
ctx := map[string]interface{}{
"Title": title,
"ToolVersion": version.String(),
"Pkg": pack,
"Imports": imports,
}
if err := headerTmpl.Execute(f, ctx); err != nil {
return fmt.Errorf("failed to generate contexts: %s", err)
}
return nil
} | go | func (f *SourceFile) WriteHeader(title, pack string, imports []*ImportSpec) error {
ctx := map[string]interface{}{
"Title": title,
"ToolVersion": version.String(),
"Pkg": pack,
"Imports": imports,
}
if err := headerTmpl.Execute(f, ctx); err != nil {
return fmt.Errorf("failed to generate contexts: %s", err)
}
return nil
} | [
"func",
"(",
"f",
"*",
"SourceFile",
")",
"WriteHeader",
"(",
"title",
",",
"pack",
"string",
",",
"imports",
"[",
"]",
"*",
"ImportSpec",
")",
"error",
"{",
"ctx",
":=",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"",
"\"",
":",
"title",
",",
"\"",
"\"",
":",
"version",
".",
"String",
"(",
")",
",",
"\"",
"\"",
":",
"pack",
",",
"\"",
"\"",
":",
"imports",
",",
"}",
"\n",
"if",
"err",
":=",
"headerTmpl",
".",
"Execute",
"(",
"f",
",",
"ctx",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // WriteHeader writes the generic generated code header. | [
"WriteHeader",
"writes",
"the",
"generic",
"generated",
"code",
"header",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/goagen/codegen/workspace.go#L260-L271 | train |
goadesign/goa | goagen/codegen/workspace.go | Close | func (f *SourceFile) Close() {
if err := f.osFile.Close(); err != nil {
panic(err) // bug
}
} | go | func (f *SourceFile) Close() {
if err := f.osFile.Close(); err != nil {
panic(err) // bug
}
} | [
"func",
"(",
"f",
"*",
"SourceFile",
")",
"Close",
"(",
")",
"{",
"if",
"err",
":=",
"f",
".",
"osFile",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"// bug",
"\n",
"}",
"\n",
"}"
] | // Close closes the underlying OS file. | [
"Close",
"closes",
"the",
"underlying",
"OS",
"file",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/goagen/codegen/workspace.go#L280-L284 | train |
goadesign/goa | goagen/codegen/workspace.go | FormatCode | func (f *SourceFile) FormatCode() error {
// Parse file into AST
fset := token.NewFileSet()
file, err := parser.ParseFile(fset, f.Abs(), nil, parser.ParseComments)
if err != nil {
content, _ := ioutil.ReadFile(f.Abs())
var buf bytes.Buffer
scanner.PrintError(&buf, err)
return fmt.Errorf("%s\n========\nContent:\n%s", buf.String(), content)
}
// Clean unused imports
imports := astutil.Imports(fset, file)
for _, group := range imports {
for _, imp := range group {
path := strings.Trim(imp.Path.Value, `"`)
if !astutil.UsesImport(file, path) {
if imp.Name != nil {
astutil.DeleteNamedImport(fset, file, imp.Name.Name, path)
} else {
astutil.DeleteImport(fset, file, path)
}
}
}
}
ast.SortImports(fset, file)
// Open file to be written
w, err := os.OpenFile(f.Abs(), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, os.ModePerm)
if err != nil {
return err
}
defer w.Close()
// Write formatted code without unused imports
return format.Node(w, fset, file)
} | go | func (f *SourceFile) FormatCode() error {
// Parse file into AST
fset := token.NewFileSet()
file, err := parser.ParseFile(fset, f.Abs(), nil, parser.ParseComments)
if err != nil {
content, _ := ioutil.ReadFile(f.Abs())
var buf bytes.Buffer
scanner.PrintError(&buf, err)
return fmt.Errorf("%s\n========\nContent:\n%s", buf.String(), content)
}
// Clean unused imports
imports := astutil.Imports(fset, file)
for _, group := range imports {
for _, imp := range group {
path := strings.Trim(imp.Path.Value, `"`)
if !astutil.UsesImport(file, path) {
if imp.Name != nil {
astutil.DeleteNamedImport(fset, file, imp.Name.Name, path)
} else {
astutil.DeleteImport(fset, file, path)
}
}
}
}
ast.SortImports(fset, file)
// Open file to be written
w, err := os.OpenFile(f.Abs(), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, os.ModePerm)
if err != nil {
return err
}
defer w.Close()
// Write formatted code without unused imports
return format.Node(w, fset, file)
} | [
"func",
"(",
"f",
"*",
"SourceFile",
")",
"FormatCode",
"(",
")",
"error",
"{",
"// Parse file into AST",
"fset",
":=",
"token",
".",
"NewFileSet",
"(",
")",
"\n",
"file",
",",
"err",
":=",
"parser",
".",
"ParseFile",
"(",
"fset",
",",
"f",
".",
"Abs",
"(",
")",
",",
"nil",
",",
"parser",
".",
"ParseComments",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"content",
",",
"_",
":=",
"ioutil",
".",
"ReadFile",
"(",
"f",
".",
"Abs",
"(",
")",
")",
"\n",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"scanner",
".",
"PrintError",
"(",
"&",
"buf",
",",
"err",
")",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\\n",
"\\n",
"\\n",
"\"",
",",
"buf",
".",
"String",
"(",
")",
",",
"content",
")",
"\n",
"}",
"\n",
"// Clean unused imports",
"imports",
":=",
"astutil",
".",
"Imports",
"(",
"fset",
",",
"file",
")",
"\n",
"for",
"_",
",",
"group",
":=",
"range",
"imports",
"{",
"for",
"_",
",",
"imp",
":=",
"range",
"group",
"{",
"path",
":=",
"strings",
".",
"Trim",
"(",
"imp",
".",
"Path",
".",
"Value",
",",
"`\"`",
")",
"\n",
"if",
"!",
"astutil",
".",
"UsesImport",
"(",
"file",
",",
"path",
")",
"{",
"if",
"imp",
".",
"Name",
"!=",
"nil",
"{",
"astutil",
".",
"DeleteNamedImport",
"(",
"fset",
",",
"file",
",",
"imp",
".",
"Name",
".",
"Name",
",",
"path",
")",
"\n",
"}",
"else",
"{",
"astutil",
".",
"DeleteImport",
"(",
"fset",
",",
"file",
",",
"path",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"ast",
".",
"SortImports",
"(",
"fset",
",",
"file",
")",
"\n",
"// Open file to be written",
"w",
",",
"err",
":=",
"os",
".",
"OpenFile",
"(",
"f",
".",
"Abs",
"(",
")",
",",
"os",
".",
"O_WRONLY",
"|",
"os",
".",
"O_CREATE",
"|",
"os",
".",
"O_TRUNC",
",",
"os",
".",
"ModePerm",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"w",
".",
"Close",
"(",
")",
"\n",
"// Write formatted code without unused imports",
"return",
"format",
".",
"Node",
"(",
"w",
",",
"fset",
",",
"file",
")",
"\n",
"}"
] | // FormatCode performs the equivalent of "goimports -w" on the source file. | [
"FormatCode",
"performs",
"the",
"equivalent",
"of",
"goimports",
"-",
"w",
"on",
"the",
"source",
"file",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/goagen/codegen/workspace.go#L287-L320 | train |
goadesign/goa | goagen/codegen/workspace.go | Abs | func (f *SourceFile) Abs() string {
return filepath.Join(f.Package.Abs(), f.Name)
} | go | func (f *SourceFile) Abs() string {
return filepath.Join(f.Package.Abs(), f.Name)
} | [
"func",
"(",
"f",
"*",
"SourceFile",
")",
"Abs",
"(",
")",
"string",
"{",
"return",
"filepath",
".",
"Join",
"(",
"f",
".",
"Package",
".",
"Abs",
"(",
")",
",",
"f",
".",
"Name",
")",
"\n",
"}"
] | // Abs returne the source file absolute filename | [
"Abs",
"returne",
"the",
"source",
"file",
"absolute",
"filename"
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/goagen/codegen/workspace.go#L323-L325 | train |
goadesign/goa | goagen/codegen/workspace.go | ExecuteTemplate | func (f *SourceFile) ExecuteTemplate(name, source string, funcMap template.FuncMap, data interface{}) error {
tmpl, err := template.New(name).Funcs(DefaultFuncMap).Funcs(funcMap).Parse(source)
if err != nil {
panic(err) // bug
}
return tmpl.Execute(f, data)
} | go | func (f *SourceFile) ExecuteTemplate(name, source string, funcMap template.FuncMap, data interface{}) error {
tmpl, err := template.New(name).Funcs(DefaultFuncMap).Funcs(funcMap).Parse(source)
if err != nil {
panic(err) // bug
}
return tmpl.Execute(f, data)
} | [
"func",
"(",
"f",
"*",
"SourceFile",
")",
"ExecuteTemplate",
"(",
"name",
",",
"source",
"string",
",",
"funcMap",
"template",
".",
"FuncMap",
",",
"data",
"interface",
"{",
"}",
")",
"error",
"{",
"tmpl",
",",
"err",
":=",
"template",
".",
"New",
"(",
"name",
")",
".",
"Funcs",
"(",
"DefaultFuncMap",
")",
".",
"Funcs",
"(",
"funcMap",
")",
".",
"Parse",
"(",
"source",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"// bug",
"\n",
"}",
"\n",
"return",
"tmpl",
".",
"Execute",
"(",
"f",
",",
"data",
")",
"\n",
"}"
] | // ExecuteTemplate executes the template and writes the output to the file. | [
"ExecuteTemplate",
"executes",
"the",
"template",
"and",
"writes",
"the",
"output",
"to",
"the",
"file",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/goagen/codegen/workspace.go#L328-L334 | train |
goadesign/goa | goagen/codegen/workspace.go | PackagePath | func PackagePath(path string) (string, error) {
absPath, err := filepath.Abs(path)
if err != nil {
absPath = path
}
gopaths := filepath.SplitList(envOr("GOPATH", build.Default.GOPATH))
if os.Getenv("GO111MODULE") != "on" { // GOPATH mode
for _, gopath := range gopaths {
if gp, err := filepath.Abs(gopath); err == nil {
gopath = gp
}
if filepath.HasPrefix(absPath, gopath) {
base := filepath.FromSlash(gopath + "/src")
rel, err := filepath.Rel(base, absPath)
return filepath.ToSlash(rel), err
}
}
}
if os.Getenv("GO111MODULE") != "off" { // Module mode
root, file := findModuleRoot(absPath, "", false)
if root != "" {
content, err := ioutil.ReadFile(filepath.Join(root, file))
if err == nil {
p := modulePath(content)
base := filepath.FromSlash(root)
rel, err := filepath.Rel(base, absPath)
return filepath.ToSlash(filepath.Join(p, rel)), err
}
}
}
return "", fmt.Errorf("%s does not contain a Go package", absPath)
} | go | func PackagePath(path string) (string, error) {
absPath, err := filepath.Abs(path)
if err != nil {
absPath = path
}
gopaths := filepath.SplitList(envOr("GOPATH", build.Default.GOPATH))
if os.Getenv("GO111MODULE") != "on" { // GOPATH mode
for _, gopath := range gopaths {
if gp, err := filepath.Abs(gopath); err == nil {
gopath = gp
}
if filepath.HasPrefix(absPath, gopath) {
base := filepath.FromSlash(gopath + "/src")
rel, err := filepath.Rel(base, absPath)
return filepath.ToSlash(rel), err
}
}
}
if os.Getenv("GO111MODULE") != "off" { // Module mode
root, file := findModuleRoot(absPath, "", false)
if root != "" {
content, err := ioutil.ReadFile(filepath.Join(root, file))
if err == nil {
p := modulePath(content)
base := filepath.FromSlash(root)
rel, err := filepath.Rel(base, absPath)
return filepath.ToSlash(filepath.Join(p, rel)), err
}
}
}
return "", fmt.Errorf("%s does not contain a Go package", absPath)
} | [
"func",
"PackagePath",
"(",
"path",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"absPath",
",",
"err",
":=",
"filepath",
".",
"Abs",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"absPath",
"=",
"path",
"\n",
"}",
"\n",
"gopaths",
":=",
"filepath",
".",
"SplitList",
"(",
"envOr",
"(",
"\"",
"\"",
",",
"build",
".",
"Default",
".",
"GOPATH",
")",
")",
"\n",
"if",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"!=",
"\"",
"\"",
"{",
"// GOPATH mode",
"for",
"_",
",",
"gopath",
":=",
"range",
"gopaths",
"{",
"if",
"gp",
",",
"err",
":=",
"filepath",
".",
"Abs",
"(",
"gopath",
")",
";",
"err",
"==",
"nil",
"{",
"gopath",
"=",
"gp",
"\n",
"}",
"\n",
"if",
"filepath",
".",
"HasPrefix",
"(",
"absPath",
",",
"gopath",
")",
"{",
"base",
":=",
"filepath",
".",
"FromSlash",
"(",
"gopath",
"+",
"\"",
"\"",
")",
"\n",
"rel",
",",
"err",
":=",
"filepath",
".",
"Rel",
"(",
"base",
",",
"absPath",
")",
"\n",
"return",
"filepath",
".",
"ToSlash",
"(",
"rel",
")",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"!=",
"\"",
"\"",
"{",
"// Module mode",
"root",
",",
"file",
":=",
"findModuleRoot",
"(",
"absPath",
",",
"\"",
"\"",
",",
"false",
")",
"\n",
"if",
"root",
"!=",
"\"",
"\"",
"{",
"content",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"filepath",
".",
"Join",
"(",
"root",
",",
"file",
")",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"p",
":=",
"modulePath",
"(",
"content",
")",
"\n",
"base",
":=",
"filepath",
".",
"FromSlash",
"(",
"root",
")",
"\n",
"rel",
",",
"err",
":=",
"filepath",
".",
"Rel",
"(",
"base",
",",
"absPath",
")",
"\n",
"return",
"filepath",
".",
"ToSlash",
"(",
"filepath",
".",
"Join",
"(",
"p",
",",
"rel",
")",
")",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"absPath",
")",
"\n",
"}"
] | // PackagePath returns the Go package path for the directory that lives under the given absolute
// file path. | [
"PackagePath",
"returns",
"the",
"Go",
"package",
"path",
"for",
"the",
"directory",
"that",
"lives",
"under",
"the",
"given",
"absolute",
"file",
"path",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/goagen/codegen/workspace.go#L338-L369 | train |
goadesign/goa | goagen/codegen/workspace.go | PackageSourcePath | func PackageSourcePath(pkg string) (string, error) {
buildCtx := build.Default
buildCtx.GOPATH = envOr("GOPATH", build.Default.GOPATH) // Reevaluate each time to be nice to tests
wd, err := os.Getwd()
if err != nil {
wd = "."
}
p, err := buildCtx.Import(pkg, wd, 0)
if err != nil {
return "", err
}
return p.Dir, nil
} | go | func PackageSourcePath(pkg string) (string, error) {
buildCtx := build.Default
buildCtx.GOPATH = envOr("GOPATH", build.Default.GOPATH) // Reevaluate each time to be nice to tests
wd, err := os.Getwd()
if err != nil {
wd = "."
}
p, err := buildCtx.Import(pkg, wd, 0)
if err != nil {
return "", err
}
return p.Dir, nil
} | [
"func",
"PackageSourcePath",
"(",
"pkg",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"buildCtx",
":=",
"build",
".",
"Default",
"\n",
"buildCtx",
".",
"GOPATH",
"=",
"envOr",
"(",
"\"",
"\"",
",",
"build",
".",
"Default",
".",
"GOPATH",
")",
"// Reevaluate each time to be nice to tests",
"\n",
"wd",
",",
"err",
":=",
"os",
".",
"Getwd",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"wd",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"p",
",",
"err",
":=",
"buildCtx",
".",
"Import",
"(",
"pkg",
",",
"wd",
",",
"0",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"return",
"p",
".",
"Dir",
",",
"nil",
"\n",
"}"
] | // PackageSourcePath returns the absolute path to the given package source. | [
"PackageSourcePath",
"returns",
"the",
"absolute",
"path",
"to",
"the",
"given",
"package",
"source",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/goagen/codegen/workspace.go#L372-L384 | train |
goadesign/goa | goagen/codegen/workspace.go | PackageName | func PackageName(path string) (string, error) {
fset := token.NewFileSet()
pkgs, err := parser.ParseDir(fset, path, nil, parser.PackageClauseOnly)
if err != nil {
return "", err
}
var pkgNames []string
for n := range pkgs {
if !strings.HasSuffix(n, "_test") {
pkgNames = append(pkgNames, n)
}
}
if len(pkgNames) > 1 {
return "", fmt.Errorf("more than one Go package found in %s (%s)",
path, strings.Join(pkgNames, ","))
}
if len(pkgNames) == 0 {
return "", fmt.Errorf("no Go package found in %s", path)
}
return pkgNames[0], nil
} | go | func PackageName(path string) (string, error) {
fset := token.NewFileSet()
pkgs, err := parser.ParseDir(fset, path, nil, parser.PackageClauseOnly)
if err != nil {
return "", err
}
var pkgNames []string
for n := range pkgs {
if !strings.HasSuffix(n, "_test") {
pkgNames = append(pkgNames, n)
}
}
if len(pkgNames) > 1 {
return "", fmt.Errorf("more than one Go package found in %s (%s)",
path, strings.Join(pkgNames, ","))
}
if len(pkgNames) == 0 {
return "", fmt.Errorf("no Go package found in %s", path)
}
return pkgNames[0], nil
} | [
"func",
"PackageName",
"(",
"path",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"fset",
":=",
"token",
".",
"NewFileSet",
"(",
")",
"\n",
"pkgs",
",",
"err",
":=",
"parser",
".",
"ParseDir",
"(",
"fset",
",",
"path",
",",
"nil",
",",
"parser",
".",
"PackageClauseOnly",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"var",
"pkgNames",
"[",
"]",
"string",
"\n",
"for",
"n",
":=",
"range",
"pkgs",
"{",
"if",
"!",
"strings",
".",
"HasSuffix",
"(",
"n",
",",
"\"",
"\"",
")",
"{",
"pkgNames",
"=",
"append",
"(",
"pkgNames",
",",
"n",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"len",
"(",
"pkgNames",
")",
">",
"1",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"path",
",",
"strings",
".",
"Join",
"(",
"pkgNames",
",",
"\"",
"\"",
")",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"pkgNames",
")",
"==",
"0",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"path",
")",
"\n",
"}",
"\n",
"return",
"pkgNames",
"[",
"0",
"]",
",",
"nil",
"\n",
"}"
] | // PackageName returns the name of a package at the given path | [
"PackageName",
"returns",
"the",
"name",
"of",
"a",
"package",
"at",
"the",
"given",
"path"
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/goagen/codegen/workspace.go#L387-L407 | train |
goadesign/goa | goagen/codegen/helpers.go | CheckVersion | func CheckVersion(ver string) error {
compat, err := version.Compatible(ver)
if err != nil {
return err
}
if !compat {
return fmt.Errorf("version mismatch: using goagen %s to generate code that compiles with goa %s",
ver, version.String())
}
return nil
} | go | func CheckVersion(ver string) error {
compat, err := version.Compatible(ver)
if err != nil {
return err
}
if !compat {
return fmt.Errorf("version mismatch: using goagen %s to generate code that compiles with goa %s",
ver, version.String())
}
return nil
} | [
"func",
"CheckVersion",
"(",
"ver",
"string",
")",
"error",
"{",
"compat",
",",
"err",
":=",
"version",
".",
"Compatible",
"(",
"ver",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"!",
"compat",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"ver",
",",
"version",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // CheckVersion returns an error if the ver is empty, contains an incorrect value or
// a version number that is not compatible with the version of this repo. | [
"CheckVersion",
"returns",
"an",
"error",
"if",
"the",
"ver",
"is",
"empty",
"contains",
"an",
"incorrect",
"value",
"or",
"a",
"version",
"number",
"that",
"is",
"not",
"compatible",
"with",
"the",
"version",
"of",
"this",
"repo",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/goagen/codegen/helpers.go#L18-L28 | train |
goadesign/goa | goagen/codegen/helpers.go | CommandLine | func CommandLine() string {
// We don't use the full path to the tool so that running goagen multiple times doesn't
// end up creating different command line comments (because of the temporary directory it
// runs in).
var param string
if len(os.Args) > 1 {
args := make([]string, len(os.Args)-1)
gopaths := filepath.SplitList(envOr("GOPATH", build.Default.GOPATH))
for i, a := range os.Args[1:] {
for _, p := range gopaths {
p = "=" + p
if strings.Contains(a, p) {
args[i] = strings.Replace(a, p, "=$(GOPATH)", 1)
break
}
}
if args[i] == "" {
args[i] = a
}
}
param = strings.Join(args, " ")
}
rawcmd := filepath.Base(os.Args[0])
// Remove possible .exe suffix to not create different ouptut just because
// you ran goagen on Windows.
rawcmd = strings.TrimSuffix(rawcmd, ".exe")
cmd := fmt.Sprintf("$ %s %s", rawcmd, param)
return strings.Replace(cmd, " --", "\n\t--", -1)
} | go | func CommandLine() string {
// We don't use the full path to the tool so that running goagen multiple times doesn't
// end up creating different command line comments (because of the temporary directory it
// runs in).
var param string
if len(os.Args) > 1 {
args := make([]string, len(os.Args)-1)
gopaths := filepath.SplitList(envOr("GOPATH", build.Default.GOPATH))
for i, a := range os.Args[1:] {
for _, p := range gopaths {
p = "=" + p
if strings.Contains(a, p) {
args[i] = strings.Replace(a, p, "=$(GOPATH)", 1)
break
}
}
if args[i] == "" {
args[i] = a
}
}
param = strings.Join(args, " ")
}
rawcmd := filepath.Base(os.Args[0])
// Remove possible .exe suffix to not create different ouptut just because
// you ran goagen on Windows.
rawcmd = strings.TrimSuffix(rawcmd, ".exe")
cmd := fmt.Sprintf("$ %s %s", rawcmd, param)
return strings.Replace(cmd, " --", "\n\t--", -1)
} | [
"func",
"CommandLine",
"(",
")",
"string",
"{",
"// We don't use the full path to the tool so that running goagen multiple times doesn't",
"// end up creating different command line comments (because of the temporary directory it",
"// runs in).",
"var",
"param",
"string",
"\n\n",
"if",
"len",
"(",
"os",
".",
"Args",
")",
">",
"1",
"{",
"args",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"os",
".",
"Args",
")",
"-",
"1",
")",
"\n",
"gopaths",
":=",
"filepath",
".",
"SplitList",
"(",
"envOr",
"(",
"\"",
"\"",
",",
"build",
".",
"Default",
".",
"GOPATH",
")",
")",
"\n",
"for",
"i",
",",
"a",
":=",
"range",
"os",
".",
"Args",
"[",
"1",
":",
"]",
"{",
"for",
"_",
",",
"p",
":=",
"range",
"gopaths",
"{",
"p",
"=",
"\"",
"\"",
"+",
"p",
"\n",
"if",
"strings",
".",
"Contains",
"(",
"a",
",",
"p",
")",
"{",
"args",
"[",
"i",
"]",
"=",
"strings",
".",
"Replace",
"(",
"a",
",",
"p",
",",
"\"",
"\"",
",",
"1",
")",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"args",
"[",
"i",
"]",
"==",
"\"",
"\"",
"{",
"args",
"[",
"i",
"]",
"=",
"a",
"\n",
"}",
"\n",
"}",
"\n",
"param",
"=",
"strings",
".",
"Join",
"(",
"args",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"rawcmd",
":=",
"filepath",
".",
"Base",
"(",
"os",
".",
"Args",
"[",
"0",
"]",
")",
"\n",
"// Remove possible .exe suffix to not create different ouptut just because",
"// you ran goagen on Windows.",
"rawcmd",
"=",
"strings",
".",
"TrimSuffix",
"(",
"rawcmd",
",",
"\"",
"\"",
")",
"\n\n",
"cmd",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"rawcmd",
",",
"param",
")",
"\n",
"return",
"strings",
".",
"Replace",
"(",
"cmd",
",",
"\"",
"\"",
",",
"\"",
"\\n",
"\\t",
"\"",
",",
"-",
"1",
")",
"\n",
"}"
] | // CommandLine return the command used to run this process. | [
"CommandLine",
"return",
"the",
"command",
"used",
"to",
"run",
"this",
"process",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/goagen/codegen/helpers.go#L31-L61 | train |
goadesign/goa | goagen/codegen/helpers.go | Indent | func Indent(s, prefix string) string {
return string(IndentBytes([]byte(s), []byte(prefix)))
} | go | func Indent(s, prefix string) string {
return string(IndentBytes([]byte(s), []byte(prefix)))
} | [
"func",
"Indent",
"(",
"s",
",",
"prefix",
"string",
")",
"string",
"{",
"return",
"string",
"(",
"IndentBytes",
"(",
"[",
"]",
"byte",
"(",
"s",
")",
",",
"[",
"]",
"byte",
"(",
"prefix",
")",
")",
")",
"\n",
"}"
] | // Indent inserts prefix at the beginning of each non-empty line of s. The
// end-of-line marker is NL. | [
"Indent",
"inserts",
"prefix",
"at",
"the",
"beginning",
"of",
"each",
"non",
"-",
"empty",
"line",
"of",
"s",
".",
"The",
"end",
"-",
"of",
"-",
"line",
"marker",
"is",
"NL",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/goagen/codegen/helpers.go#L90-L92 | train |
goadesign/goa | goagen/codegen/helpers.go | IndentBytes | func IndentBytes(b, prefix []byte) []byte {
var res []byte
bol := true
for _, c := range b {
if bol && c != '\n' {
res = append(res, prefix...)
}
res = append(res, c)
bol = c == '\n'
}
return res
} | go | func IndentBytes(b, prefix []byte) []byte {
var res []byte
bol := true
for _, c := range b {
if bol && c != '\n' {
res = append(res, prefix...)
}
res = append(res, c)
bol = c == '\n'
}
return res
} | [
"func",
"IndentBytes",
"(",
"b",
",",
"prefix",
"[",
"]",
"byte",
")",
"[",
"]",
"byte",
"{",
"var",
"res",
"[",
"]",
"byte",
"\n",
"bol",
":=",
"true",
"\n",
"for",
"_",
",",
"c",
":=",
"range",
"b",
"{",
"if",
"bol",
"&&",
"c",
"!=",
"'\\n'",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"prefix",
"...",
")",
"\n",
"}",
"\n",
"res",
"=",
"append",
"(",
"res",
",",
"c",
")",
"\n",
"bol",
"=",
"c",
"==",
"'\\n'",
"\n",
"}",
"\n",
"return",
"res",
"\n",
"}"
] | // IndentBytes inserts prefix at the beginning of each non-empty line of b.
// The end-of-line marker is NL. | [
"IndentBytes",
"inserts",
"prefix",
"at",
"the",
"beginning",
"of",
"each",
"non",
"-",
"empty",
"line",
"of",
"b",
".",
"The",
"end",
"-",
"of",
"-",
"line",
"marker",
"is",
"NL",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/goagen/codegen/helpers.go#L96-L107 | train |
goadesign/goa | goagen/codegen/helpers.go | Tabs | func Tabs(depth int) string {
var tabs string
for i := 0; i < depth; i++ {
tabs += "\t"
}
// return fmt.Sprintf("%d%s", depth, tabs)
return tabs
} | go | func Tabs(depth int) string {
var tabs string
for i := 0; i < depth; i++ {
tabs += "\t"
}
// return fmt.Sprintf("%d%s", depth, tabs)
return tabs
} | [
"func",
"Tabs",
"(",
"depth",
"int",
")",
"string",
"{",
"var",
"tabs",
"string",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"depth",
";",
"i",
"++",
"{",
"tabs",
"+=",
"\"",
"\\t",
"\"",
"\n",
"}",
"\n",
"//\treturn fmt.Sprintf(\"%d%s\", depth, tabs)",
"return",
"tabs",
"\n",
"}"
] | // Tabs returns a string made of depth tab characters. | [
"Tabs",
"returns",
"a",
"string",
"made",
"of",
"depth",
"tab",
"characters",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/goagen/codegen/helpers.go#L110-L117 | train |
goadesign/goa | goagen/codegen/helpers.go | CanonicalTemplate | func CanonicalTemplate(r *design.ResourceDefinition) string {
return design.WildcardRegex.ReplaceAllLiteralString(r.URITemplate(), "/%v")
} | go | func CanonicalTemplate(r *design.ResourceDefinition) string {
return design.WildcardRegex.ReplaceAllLiteralString(r.URITemplate(), "/%v")
} | [
"func",
"CanonicalTemplate",
"(",
"r",
"*",
"design",
".",
"ResourceDefinition",
")",
"string",
"{",
"return",
"design",
".",
"WildcardRegex",
".",
"ReplaceAllLiteralString",
"(",
"r",
".",
"URITemplate",
"(",
")",
",",
"\"",
"\"",
")",
"\n",
"}"
] | // CanonicalTemplate returns the resource URI template as a format string suitable for use in the
// fmt.Printf function family. | [
"CanonicalTemplate",
"returns",
"the",
"resource",
"URI",
"template",
"as",
"a",
"format",
"string",
"suitable",
"for",
"use",
"in",
"the",
"fmt",
".",
"Printf",
"function",
"family",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/goagen/codegen/helpers.go#L124-L126 | train |
goadesign/goa | goagen/codegen/helpers.go | CanonicalParams | func CanonicalParams(r *design.ResourceDefinition) []string {
var params []string
if ca := r.CanonicalAction(); ca != nil {
if len(ca.Routes) > 0 {
params = ca.Routes[0].Params()
}
for i, p := range params {
params[i] = Goify(p, false)
}
}
return params
} | go | func CanonicalParams(r *design.ResourceDefinition) []string {
var params []string
if ca := r.CanonicalAction(); ca != nil {
if len(ca.Routes) > 0 {
params = ca.Routes[0].Params()
}
for i, p := range params {
params[i] = Goify(p, false)
}
}
return params
} | [
"func",
"CanonicalParams",
"(",
"r",
"*",
"design",
".",
"ResourceDefinition",
")",
"[",
"]",
"string",
"{",
"var",
"params",
"[",
"]",
"string",
"\n",
"if",
"ca",
":=",
"r",
".",
"CanonicalAction",
"(",
")",
";",
"ca",
"!=",
"nil",
"{",
"if",
"len",
"(",
"ca",
".",
"Routes",
")",
">",
"0",
"{",
"params",
"=",
"ca",
".",
"Routes",
"[",
"0",
"]",
".",
"Params",
"(",
")",
"\n",
"}",
"\n",
"for",
"i",
",",
"p",
":=",
"range",
"params",
"{",
"params",
"[",
"i",
"]",
"=",
"Goify",
"(",
"p",
",",
"false",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"params",
"\n",
"}"
] | // CanonicalParams returns the list of parameter names needed to build the canonical href to the
// resource. It returns nil if the resource does not have a canonical action. | [
"CanonicalParams",
"returns",
"the",
"list",
"of",
"parameter",
"names",
"needed",
"to",
"build",
"the",
"canonical",
"href",
"to",
"the",
"resource",
".",
"It",
"returns",
"nil",
"if",
"the",
"resource",
"does",
"not",
"have",
"a",
"canonical",
"action",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/goagen/codegen/helpers.go#L130-L141 | train |
goadesign/goa | goagen/codegen/helpers.go | SnakeCase | func SnakeCase(name string) string {
for u, l := range toLower {
name = strings.Replace(name, u, l, -1)
}
var b bytes.Buffer
var lastUnderscore bool
ln := len(name)
if ln == 0 {
return ""
}
b.WriteRune(unicode.ToLower(rune(name[0])))
for i := 1; i < ln; i++ {
r := rune(name[i])
nextIsLower := false
if i < ln-1 {
n := rune(name[i+1])
nextIsLower = unicode.IsLower(n) && unicode.IsLetter(n)
}
if unicode.IsUpper(r) {
if !lastUnderscore && nextIsLower {
b.WriteRune('_')
lastUnderscore = true
}
b.WriteRune(unicode.ToLower(r))
} else {
b.WriteRune(r)
lastUnderscore = false
}
}
return b.String()
} | go | func SnakeCase(name string) string {
for u, l := range toLower {
name = strings.Replace(name, u, l, -1)
}
var b bytes.Buffer
var lastUnderscore bool
ln := len(name)
if ln == 0 {
return ""
}
b.WriteRune(unicode.ToLower(rune(name[0])))
for i := 1; i < ln; i++ {
r := rune(name[i])
nextIsLower := false
if i < ln-1 {
n := rune(name[i+1])
nextIsLower = unicode.IsLower(n) && unicode.IsLetter(n)
}
if unicode.IsUpper(r) {
if !lastUnderscore && nextIsLower {
b.WriteRune('_')
lastUnderscore = true
}
b.WriteRune(unicode.ToLower(r))
} else {
b.WriteRune(r)
lastUnderscore = false
}
}
return b.String()
} | [
"func",
"SnakeCase",
"(",
"name",
"string",
")",
"string",
"{",
"for",
"u",
",",
"l",
":=",
"range",
"toLower",
"{",
"name",
"=",
"strings",
".",
"Replace",
"(",
"name",
",",
"u",
",",
"l",
",",
"-",
"1",
")",
"\n",
"}",
"\n",
"var",
"b",
"bytes",
".",
"Buffer",
"\n",
"var",
"lastUnderscore",
"bool",
"\n",
"ln",
":=",
"len",
"(",
"name",
")",
"\n",
"if",
"ln",
"==",
"0",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"b",
".",
"WriteRune",
"(",
"unicode",
".",
"ToLower",
"(",
"rune",
"(",
"name",
"[",
"0",
"]",
")",
")",
")",
"\n",
"for",
"i",
":=",
"1",
";",
"i",
"<",
"ln",
";",
"i",
"++",
"{",
"r",
":=",
"rune",
"(",
"name",
"[",
"i",
"]",
")",
"\n",
"nextIsLower",
":=",
"false",
"\n",
"if",
"i",
"<",
"ln",
"-",
"1",
"{",
"n",
":=",
"rune",
"(",
"name",
"[",
"i",
"+",
"1",
"]",
")",
"\n",
"nextIsLower",
"=",
"unicode",
".",
"IsLower",
"(",
"n",
")",
"&&",
"unicode",
".",
"IsLetter",
"(",
"n",
")",
"\n",
"}",
"\n",
"if",
"unicode",
".",
"IsUpper",
"(",
"r",
")",
"{",
"if",
"!",
"lastUnderscore",
"&&",
"nextIsLower",
"{",
"b",
".",
"WriteRune",
"(",
"'_'",
")",
"\n",
"lastUnderscore",
"=",
"true",
"\n",
"}",
"\n",
"b",
".",
"WriteRune",
"(",
"unicode",
".",
"ToLower",
"(",
"r",
")",
")",
"\n",
"}",
"else",
"{",
"b",
".",
"WriteRune",
"(",
"r",
")",
"\n",
"lastUnderscore",
"=",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"b",
".",
"String",
"(",
")",
"\n",
"}"
] | // SnakeCase produces the snake_case version of the given CamelCase string. | [
"SnakeCase",
"produces",
"the",
"snake_case",
"version",
"of",
"the",
"given",
"CamelCase",
"string",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/goagen/codegen/helpers.go#L147-L177 | train |
goadesign/goa | goagen/codegen/helpers.go | KebabCase | func KebabCase(name string) string {
name = SnakeCase(name)
return strings.Replace(name, "_", "-", -1)
} | go | func KebabCase(name string) string {
name = SnakeCase(name)
return strings.Replace(name, "_", "-", -1)
} | [
"func",
"KebabCase",
"(",
"name",
"string",
")",
"string",
"{",
"name",
"=",
"SnakeCase",
"(",
"name",
")",
"\n",
"return",
"strings",
".",
"Replace",
"(",
"name",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"-",
"1",
")",
"\n",
"}"
] | // KebabCase produces the kebab-case version of the given CamelCase string. | [
"KebabCase",
"produces",
"the",
"kebab",
"-",
"case",
"version",
"of",
"the",
"given",
"CamelCase",
"string",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/goagen/codegen/helpers.go#L180-L183 | train |
goadesign/goa | design/random.go | NewRandomGenerator | func NewRandomGenerator(seed string) *RandomGenerator {
hasher := md5.New()
hasher.Write([]byte(seed))
sint := int64(binary.BigEndian.Uint64(hasher.Sum(nil)))
source := rand.NewSource(sint)
ran := rand.New(source)
faker := &faker.Faker{
Language: "end",
Dict: faker.Dict["en"],
Rand: ran,
}
return &RandomGenerator{
Seed: seed,
faker: faker,
rand: ran,
}
} | go | func NewRandomGenerator(seed string) *RandomGenerator {
hasher := md5.New()
hasher.Write([]byte(seed))
sint := int64(binary.BigEndian.Uint64(hasher.Sum(nil)))
source := rand.NewSource(sint)
ran := rand.New(source)
faker := &faker.Faker{
Language: "end",
Dict: faker.Dict["en"],
Rand: ran,
}
return &RandomGenerator{
Seed: seed,
faker: faker,
rand: ran,
}
} | [
"func",
"NewRandomGenerator",
"(",
"seed",
"string",
")",
"*",
"RandomGenerator",
"{",
"hasher",
":=",
"md5",
".",
"New",
"(",
")",
"\n",
"hasher",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"seed",
")",
")",
"\n",
"sint",
":=",
"int64",
"(",
"binary",
".",
"BigEndian",
".",
"Uint64",
"(",
"hasher",
".",
"Sum",
"(",
"nil",
")",
")",
")",
"\n",
"source",
":=",
"rand",
".",
"NewSource",
"(",
"sint",
")",
"\n",
"ran",
":=",
"rand",
".",
"New",
"(",
"source",
")",
"\n",
"faker",
":=",
"&",
"faker",
".",
"Faker",
"{",
"Language",
":",
"\"",
"\"",
",",
"Dict",
":",
"faker",
".",
"Dict",
"[",
"\"",
"\"",
"]",
",",
"Rand",
":",
"ran",
",",
"}",
"\n",
"return",
"&",
"RandomGenerator",
"{",
"Seed",
":",
"seed",
",",
"faker",
":",
"faker",
",",
"rand",
":",
"ran",
",",
"}",
"\n",
"}"
] | // NewRandomGenerator returns a random value generator seeded from the given string value. | [
"NewRandomGenerator",
"returns",
"a",
"random",
"value",
"generator",
"seeded",
"from",
"the",
"given",
"string",
"value",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/design/random.go#L24-L40 | train |
goadesign/goa | design/random.go | DateTime | func (r *RandomGenerator) DateTime() time.Time {
// Use a constant max value to make sure the same pseudo random
// values get generated for a given API.
max := time.Date(2016, time.July, 11, 23, 0, 0, 0, time.UTC).Unix()
unix := r.rand.Int63n(max)
return time.Unix(unix, 0).UTC()
} | go | func (r *RandomGenerator) DateTime() time.Time {
// Use a constant max value to make sure the same pseudo random
// values get generated for a given API.
max := time.Date(2016, time.July, 11, 23, 0, 0, 0, time.UTC).Unix()
unix := r.rand.Int63n(max)
return time.Unix(unix, 0).UTC()
} | [
"func",
"(",
"r",
"*",
"RandomGenerator",
")",
"DateTime",
"(",
")",
"time",
".",
"Time",
"{",
"// Use a constant max value to make sure the same pseudo random",
"// values get generated for a given API.",
"max",
":=",
"time",
".",
"Date",
"(",
"2016",
",",
"time",
".",
"July",
",",
"11",
",",
"23",
",",
"0",
",",
"0",
",",
"0",
",",
"time",
".",
"UTC",
")",
".",
"Unix",
"(",
")",
"\n",
"unix",
":=",
"r",
".",
"rand",
".",
"Int63n",
"(",
"max",
")",
"\n",
"return",
"time",
".",
"Unix",
"(",
"unix",
",",
"0",
")",
".",
"UTC",
"(",
")",
"\n",
"}"
] | // DateTime produces a random date. | [
"DateTime",
"produces",
"a",
"random",
"date",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/design/random.go#L54-L60 | train |
goadesign/goa | design/random.go | File | func (r *RandomGenerator) File() string {
return fmt.Sprintf("%sjpg", r.faker.Sentence(1, false))
} | go | func (r *RandomGenerator) File() string {
return fmt.Sprintf("%sjpg", r.faker.Sentence(1, false))
} | [
"func",
"(",
"r",
"*",
"RandomGenerator",
")",
"File",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"r",
".",
"faker",
".",
"Sentence",
"(",
"1",
",",
"false",
")",
")",
"\n",
"}"
] | // File produces a random file. | [
"File",
"produces",
"a",
"random",
"file",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/design/random.go#L78-L80 | train |
goadesign/goa | version/version.go | String | func String() string {
return "v" + strconv.Itoa(Major) + "." + strconv.Itoa(Minor) + "." + strconv.Itoa(Build)
} | go | func String() string {
return "v" + strconv.Itoa(Major) + "." + strconv.Itoa(Minor) + "." + strconv.Itoa(Build)
} | [
"func",
"String",
"(",
")",
"string",
"{",
"return",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"Major",
")",
"+",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"Minor",
")",
"+",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"Build",
")",
"\n",
"}"
] | // String returns the complete version number. | [
"String",
"returns",
"the",
"complete",
"version",
"number",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/version/version.go#L19-L21 | train |
goadesign/goa | version/version.go | Compatible | func Compatible(v string) (bool, error) {
if len(v) < 5 {
return false, fmt.Errorf("invalid version string format %#v", v)
}
v = v[1:]
elems := strings.Split(v, ".")
if len(elems) != 3 {
return false, fmt.Errorf("version not of the form Major.Minor.Build %#v", v)
}
mj, err := strconv.Atoi(elems[0])
if err != nil {
return false, fmt.Errorf("invalid major version number %#v, must be number", elems[0])
}
return mj == Major, nil
} | go | func Compatible(v string) (bool, error) {
if len(v) < 5 {
return false, fmt.Errorf("invalid version string format %#v", v)
}
v = v[1:]
elems := strings.Split(v, ".")
if len(elems) != 3 {
return false, fmt.Errorf("version not of the form Major.Minor.Build %#v", v)
}
mj, err := strconv.Atoi(elems[0])
if err != nil {
return false, fmt.Errorf("invalid major version number %#v, must be number", elems[0])
}
return mj == Major, nil
} | [
"func",
"Compatible",
"(",
"v",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"if",
"len",
"(",
"v",
")",
"<",
"5",
"{",
"return",
"false",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"v",
")",
"\n",
"}",
"\n",
"v",
"=",
"v",
"[",
"1",
":",
"]",
"\n",
"elems",
":=",
"strings",
".",
"Split",
"(",
"v",
",",
"\"",
"\"",
")",
"\n",
"if",
"len",
"(",
"elems",
")",
"!=",
"3",
"{",
"return",
"false",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"v",
")",
"\n",
"}",
"\n",
"mj",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"elems",
"[",
"0",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"elems",
"[",
"0",
"]",
")",
"\n",
"}",
"\n",
"return",
"mj",
"==",
"Major",
",",
"nil",
"\n",
"}"
] | // Compatible returns true if Major matches the major version of the given version string.
// It returns an error if the given string is not a valid version string. | [
"Compatible",
"returns",
"true",
"if",
"Major",
"matches",
"the",
"major",
"version",
"of",
"the",
"given",
"version",
"string",
".",
"It",
"returns",
"an",
"error",
"if",
"the",
"given",
"string",
"is",
"not",
"a",
"valid",
"version",
"string",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/version/version.go#L25-L39 | train |
goadesign/goa | uuid/uuid_js.go | FromString | func FromString(input string) (u UUID, err error) {
err = u.UnmarshalText([]byte(input))
return
} | go | func FromString(input string) (u UUID, err error) {
err = u.UnmarshalText([]byte(input))
return
} | [
"func",
"FromString",
"(",
"input",
"string",
")",
"(",
"u",
"UUID",
",",
"err",
"error",
")",
"{",
"err",
"=",
"u",
".",
"UnmarshalText",
"(",
"[",
"]",
"byte",
"(",
"input",
")",
")",
"\n",
"return",
"\n",
"}"
] | // FromString returns UUID parsed from string input.
// Input is expected in a form accepted by UnmarshalText. | [
"FromString",
"returns",
"UUID",
"parsed",
"from",
"string",
"input",
".",
"Input",
"is",
"expected",
"in",
"a",
"form",
"accepted",
"by",
"UnmarshalText",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/uuid/uuid_js.go#L22-L25 | train |
goadesign/goa | goagen/codegen/publicizer.go | RecursivePublicizer | func RecursivePublicizer(att *design.AttributeDefinition, source, target string, depth int) string {
var publications []string
if o := att.Type.ToObject(); o != nil {
if ds, ok := att.Type.(design.DataStructure); ok {
att = ds.Definition()
}
o.IterateAttributes(func(n string, catt *design.AttributeDefinition) error {
publication := Publicizer(
catt,
fmt.Sprintf("%s.%s", source, Goify(n, true)),
fmt.Sprintf("%s.%s", target, Goify(n, true)),
catt.Type.IsPrimitive() && !att.IsPrimitivePointer(n) && !att.IsInterface(n),
depth+1,
false,
)
publication = fmt.Sprintf("%sif %s.%s != nil {\n%s\n%s}",
Tabs(depth), source, Goify(n, true), publication, Tabs(depth))
publications = append(publications, publication)
return nil
})
}
return strings.Join(publications, "\n")
} | go | func RecursivePublicizer(att *design.AttributeDefinition, source, target string, depth int) string {
var publications []string
if o := att.Type.ToObject(); o != nil {
if ds, ok := att.Type.(design.DataStructure); ok {
att = ds.Definition()
}
o.IterateAttributes(func(n string, catt *design.AttributeDefinition) error {
publication := Publicizer(
catt,
fmt.Sprintf("%s.%s", source, Goify(n, true)),
fmt.Sprintf("%s.%s", target, Goify(n, true)),
catt.Type.IsPrimitive() && !att.IsPrimitivePointer(n) && !att.IsInterface(n),
depth+1,
false,
)
publication = fmt.Sprintf("%sif %s.%s != nil {\n%s\n%s}",
Tabs(depth), source, Goify(n, true), publication, Tabs(depth))
publications = append(publications, publication)
return nil
})
}
return strings.Join(publications, "\n")
} | [
"func",
"RecursivePublicizer",
"(",
"att",
"*",
"design",
".",
"AttributeDefinition",
",",
"source",
",",
"target",
"string",
",",
"depth",
"int",
")",
"string",
"{",
"var",
"publications",
"[",
"]",
"string",
"\n",
"if",
"o",
":=",
"att",
".",
"Type",
".",
"ToObject",
"(",
")",
";",
"o",
"!=",
"nil",
"{",
"if",
"ds",
",",
"ok",
":=",
"att",
".",
"Type",
".",
"(",
"design",
".",
"DataStructure",
")",
";",
"ok",
"{",
"att",
"=",
"ds",
".",
"Definition",
"(",
")",
"\n",
"}",
"\n",
"o",
".",
"IterateAttributes",
"(",
"func",
"(",
"n",
"string",
",",
"catt",
"*",
"design",
".",
"AttributeDefinition",
")",
"error",
"{",
"publication",
":=",
"Publicizer",
"(",
"catt",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"source",
",",
"Goify",
"(",
"n",
",",
"true",
")",
")",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"target",
",",
"Goify",
"(",
"n",
",",
"true",
")",
")",
",",
"catt",
".",
"Type",
".",
"IsPrimitive",
"(",
")",
"&&",
"!",
"att",
".",
"IsPrimitivePointer",
"(",
"n",
")",
"&&",
"!",
"att",
".",
"IsInterface",
"(",
"n",
")",
",",
"depth",
"+",
"1",
",",
"false",
",",
")",
"\n",
"publication",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\\n",
"\"",
",",
"Tabs",
"(",
"depth",
")",
",",
"source",
",",
"Goify",
"(",
"n",
",",
"true",
")",
",",
"publication",
",",
"Tabs",
"(",
"depth",
")",
")",
"\n",
"publications",
"=",
"append",
"(",
"publications",
",",
"publication",
")",
"\n",
"return",
"nil",
"\n",
"}",
")",
"\n",
"}",
"\n",
"return",
"strings",
".",
"Join",
"(",
"publications",
",",
"\"",
"\\n",
"\"",
")",
"\n",
"}"
] | // RecursivePublicizer produces code that copies fields from the private struct to the
// public struct | [
"RecursivePublicizer",
"produces",
"code",
"that",
"copies",
"fields",
"from",
"the",
"private",
"struct",
"to",
"the",
"public",
"struct"
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/goagen/codegen/publicizer.go#L49-L71 | train |
goadesign/goa | goagen/codegen/publicizer.go | Publicizer | func Publicizer(att *design.AttributeDefinition, sourceField, targetField string, dereference bool, depth int, init bool) string {
var publication string
data := map[string]interface{}{
"sourceField": sourceField,
"targetField": targetField,
"depth": depth,
"att": att,
"dereference": dereference,
"init": init,
}
switch {
case att.Type.IsPrimitive():
publication = RunTemplate(simplePublicizeT, data)
case att.Type.IsObject():
if _, ok := att.Type.(*design.MediaTypeDefinition); ok {
publication = RunTemplate(recursivePublicizeT, data)
} else if _, ok := att.Type.(*design.UserTypeDefinition); ok {
publication = RunTemplate(recursivePublicizeT, data)
} else {
publication = RunTemplate(objectPublicizeT, data)
}
case att.Type.IsArray():
// If the array element is primitive type, we can simply copy the elements over (i.e) []string
if att.Type.HasAttributes() {
data["elemType"] = att.Type.ToArray().ElemType
publication = RunTemplate(arrayPublicizeT, data)
} else {
publication = RunTemplate(simplePublicizeT, data)
}
case att.Type.IsHash():
if att.Type.HasAttributes() {
h := att.Type.ToHash()
data["keyType"] = h.KeyType
data["elemType"] = h.ElemType
publication = RunTemplate(hashPublicizeT, data)
} else {
publication = RunTemplate(simplePublicizeT, data)
}
}
return publication
} | go | func Publicizer(att *design.AttributeDefinition, sourceField, targetField string, dereference bool, depth int, init bool) string {
var publication string
data := map[string]interface{}{
"sourceField": sourceField,
"targetField": targetField,
"depth": depth,
"att": att,
"dereference": dereference,
"init": init,
}
switch {
case att.Type.IsPrimitive():
publication = RunTemplate(simplePublicizeT, data)
case att.Type.IsObject():
if _, ok := att.Type.(*design.MediaTypeDefinition); ok {
publication = RunTemplate(recursivePublicizeT, data)
} else if _, ok := att.Type.(*design.UserTypeDefinition); ok {
publication = RunTemplate(recursivePublicizeT, data)
} else {
publication = RunTemplate(objectPublicizeT, data)
}
case att.Type.IsArray():
// If the array element is primitive type, we can simply copy the elements over (i.e) []string
if att.Type.HasAttributes() {
data["elemType"] = att.Type.ToArray().ElemType
publication = RunTemplate(arrayPublicizeT, data)
} else {
publication = RunTemplate(simplePublicizeT, data)
}
case att.Type.IsHash():
if att.Type.HasAttributes() {
h := att.Type.ToHash()
data["keyType"] = h.KeyType
data["elemType"] = h.ElemType
publication = RunTemplate(hashPublicizeT, data)
} else {
publication = RunTemplate(simplePublicizeT, data)
}
}
return publication
} | [
"func",
"Publicizer",
"(",
"att",
"*",
"design",
".",
"AttributeDefinition",
",",
"sourceField",
",",
"targetField",
"string",
",",
"dereference",
"bool",
",",
"depth",
"int",
",",
"init",
"bool",
")",
"string",
"{",
"var",
"publication",
"string",
"\n",
"data",
":=",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"",
"\"",
":",
"sourceField",
",",
"\"",
"\"",
":",
"targetField",
",",
"\"",
"\"",
":",
"depth",
",",
"\"",
"\"",
":",
"att",
",",
"\"",
"\"",
":",
"dereference",
",",
"\"",
"\"",
":",
"init",
",",
"}",
"\n",
"switch",
"{",
"case",
"att",
".",
"Type",
".",
"IsPrimitive",
"(",
")",
":",
"publication",
"=",
"RunTemplate",
"(",
"simplePublicizeT",
",",
"data",
")",
"\n",
"case",
"att",
".",
"Type",
".",
"IsObject",
"(",
")",
":",
"if",
"_",
",",
"ok",
":=",
"att",
".",
"Type",
".",
"(",
"*",
"design",
".",
"MediaTypeDefinition",
")",
";",
"ok",
"{",
"publication",
"=",
"RunTemplate",
"(",
"recursivePublicizeT",
",",
"data",
")",
"\n",
"}",
"else",
"if",
"_",
",",
"ok",
":=",
"att",
".",
"Type",
".",
"(",
"*",
"design",
".",
"UserTypeDefinition",
")",
";",
"ok",
"{",
"publication",
"=",
"RunTemplate",
"(",
"recursivePublicizeT",
",",
"data",
")",
"\n",
"}",
"else",
"{",
"publication",
"=",
"RunTemplate",
"(",
"objectPublicizeT",
",",
"data",
")",
"\n",
"}",
"\n",
"case",
"att",
".",
"Type",
".",
"IsArray",
"(",
")",
":",
"// If the array element is primitive type, we can simply copy the elements over (i.e) []string",
"if",
"att",
".",
"Type",
".",
"HasAttributes",
"(",
")",
"{",
"data",
"[",
"\"",
"\"",
"]",
"=",
"att",
".",
"Type",
".",
"ToArray",
"(",
")",
".",
"ElemType",
"\n",
"publication",
"=",
"RunTemplate",
"(",
"arrayPublicizeT",
",",
"data",
")",
"\n",
"}",
"else",
"{",
"publication",
"=",
"RunTemplate",
"(",
"simplePublicizeT",
",",
"data",
")",
"\n",
"}",
"\n",
"case",
"att",
".",
"Type",
".",
"IsHash",
"(",
")",
":",
"if",
"att",
".",
"Type",
".",
"HasAttributes",
"(",
")",
"{",
"h",
":=",
"att",
".",
"Type",
".",
"ToHash",
"(",
")",
"\n",
"data",
"[",
"\"",
"\"",
"]",
"=",
"h",
".",
"KeyType",
"\n",
"data",
"[",
"\"",
"\"",
"]",
"=",
"h",
".",
"ElemType",
"\n",
"publication",
"=",
"RunTemplate",
"(",
"hashPublicizeT",
",",
"data",
")",
"\n",
"}",
"else",
"{",
"publication",
"=",
"RunTemplate",
"(",
"simplePublicizeT",
",",
"data",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"publication",
"\n",
"}"
] | // Publicizer publicizes a single attribute based on the type. | [
"Publicizer",
"publicizes",
"a",
"single",
"attribute",
"based",
"on",
"the",
"type",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/goagen/codegen/publicizer.go#L74-L114 | train |
goadesign/goa | middleware/security/jwt/resolver.go | NewResolver | func NewResolver(keys map[string][]Key, header string) (*GroupResolver, error) {
if header == "" {
return nil, ErrEmptyHeaderName
}
keyMap := make(map[string][]Key)
for name := range keys {
for _, keys := range keys[name] {
switch keys := keys.(type) {
case *rsa.PublicKey, *ecdsa.PublicKey, string, []byte:
keyMap[name] = append(keyMap[name], keys)
case []*rsa.PublicKey:
for _, key := range keys {
keyMap[name] = append(keyMap[name], key)
}
case []*ecdsa.PublicKey:
for _, key := range keys {
keyMap[name] = append(keyMap[name], key)
}
case [][]byte:
for _, key := range keys {
keyMap[name] = append(keyMap[name], key)
}
case []string:
for _, key := range keys {
keyMap[name] = append(keyMap[name], key)
}
default:
return nil, ErrInvalidKey
}
}
}
return &GroupResolver{
RWMutex: &sync.RWMutex{},
keyMap: keyMap,
keyHeader: header,
}, nil
} | go | func NewResolver(keys map[string][]Key, header string) (*GroupResolver, error) {
if header == "" {
return nil, ErrEmptyHeaderName
}
keyMap := make(map[string][]Key)
for name := range keys {
for _, keys := range keys[name] {
switch keys := keys.(type) {
case *rsa.PublicKey, *ecdsa.PublicKey, string, []byte:
keyMap[name] = append(keyMap[name], keys)
case []*rsa.PublicKey:
for _, key := range keys {
keyMap[name] = append(keyMap[name], key)
}
case []*ecdsa.PublicKey:
for _, key := range keys {
keyMap[name] = append(keyMap[name], key)
}
case [][]byte:
for _, key := range keys {
keyMap[name] = append(keyMap[name], key)
}
case []string:
for _, key := range keys {
keyMap[name] = append(keyMap[name], key)
}
default:
return nil, ErrInvalidKey
}
}
}
return &GroupResolver{
RWMutex: &sync.RWMutex{},
keyMap: keyMap,
keyHeader: header,
}, nil
} | [
"func",
"NewResolver",
"(",
"keys",
"map",
"[",
"string",
"]",
"[",
"]",
"Key",
",",
"header",
"string",
")",
"(",
"*",
"GroupResolver",
",",
"error",
")",
"{",
"if",
"header",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"ErrEmptyHeaderName",
"\n",
"}",
"\n",
"keyMap",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"[",
"]",
"Key",
")",
"\n",
"for",
"name",
":=",
"range",
"keys",
"{",
"for",
"_",
",",
"keys",
":=",
"range",
"keys",
"[",
"name",
"]",
"{",
"switch",
"keys",
":=",
"keys",
".",
"(",
"type",
")",
"{",
"case",
"*",
"rsa",
".",
"PublicKey",
",",
"*",
"ecdsa",
".",
"PublicKey",
",",
"string",
",",
"[",
"]",
"byte",
":",
"keyMap",
"[",
"name",
"]",
"=",
"append",
"(",
"keyMap",
"[",
"name",
"]",
",",
"keys",
")",
"\n",
"case",
"[",
"]",
"*",
"rsa",
".",
"PublicKey",
":",
"for",
"_",
",",
"key",
":=",
"range",
"keys",
"{",
"keyMap",
"[",
"name",
"]",
"=",
"append",
"(",
"keyMap",
"[",
"name",
"]",
",",
"key",
")",
"\n",
"}",
"\n",
"case",
"[",
"]",
"*",
"ecdsa",
".",
"PublicKey",
":",
"for",
"_",
",",
"key",
":=",
"range",
"keys",
"{",
"keyMap",
"[",
"name",
"]",
"=",
"append",
"(",
"keyMap",
"[",
"name",
"]",
",",
"key",
")",
"\n",
"}",
"\n",
"case",
"[",
"]",
"[",
"]",
"byte",
":",
"for",
"_",
",",
"key",
":=",
"range",
"keys",
"{",
"keyMap",
"[",
"name",
"]",
"=",
"append",
"(",
"keyMap",
"[",
"name",
"]",
",",
"key",
")",
"\n",
"}",
"\n",
"case",
"[",
"]",
"string",
":",
"for",
"_",
",",
"key",
":=",
"range",
"keys",
"{",
"keyMap",
"[",
"name",
"]",
"=",
"append",
"(",
"keyMap",
"[",
"name",
"]",
",",
"key",
")",
"\n",
"}",
"\n",
"default",
":",
"return",
"nil",
",",
"ErrInvalidKey",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"&",
"GroupResolver",
"{",
"RWMutex",
":",
"&",
"sync",
".",
"RWMutex",
"{",
"}",
",",
"keyMap",
":",
"keyMap",
",",
"keyHeader",
":",
"header",
",",
"}",
",",
"nil",
"\n",
"}"
] | // NewResolver returns a GroupResolver that uses the value of the request header with the given name
// to select the key group used for authorization. keys contains the initial set of key groups
// indexed by name. | [
"NewResolver",
"returns",
"a",
"GroupResolver",
"that",
"uses",
"the",
"value",
"of",
"the",
"request",
"header",
"with",
"the",
"given",
"name",
"to",
"select",
"the",
"key",
"group",
"used",
"for",
"authorization",
".",
"keys",
"contains",
"the",
"initial",
"set",
"of",
"key",
"groups",
"indexed",
"by",
"name",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/middleware/security/jwt/resolver.go#L41-L77 | train |
goadesign/goa | middleware/security/jwt/resolver.go | RemoveAllKeys | func (kr *GroupResolver) RemoveAllKeys() {
kr.Lock()
defer kr.Unlock()
kr.keyMap = make(map[string][]Key)
return
} | go | func (kr *GroupResolver) RemoveAllKeys() {
kr.Lock()
defer kr.Unlock()
kr.keyMap = make(map[string][]Key)
return
} | [
"func",
"(",
"kr",
"*",
"GroupResolver",
")",
"RemoveAllKeys",
"(",
")",
"{",
"kr",
".",
"Lock",
"(",
")",
"\n",
"defer",
"kr",
".",
"Unlock",
"(",
")",
"\n",
"kr",
".",
"keyMap",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"[",
"]",
"Key",
")",
"\n",
"return",
"\n",
"}"
] | // RemoveAllKeys removes all keys from the resolver. | [
"RemoveAllKeys",
"removes",
"all",
"keys",
"from",
"the",
"resolver",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/middleware/security/jwt/resolver.go#L117-L122 | train |
goadesign/goa | middleware/security/jwt/resolver.go | RemoveKeys | func (kr *GroupResolver) RemoveKeys(name string) {
kr.Lock()
defer kr.Unlock()
delete(kr.keyMap, name)
return
} | go | func (kr *GroupResolver) RemoveKeys(name string) {
kr.Lock()
defer kr.Unlock()
delete(kr.keyMap, name)
return
} | [
"func",
"(",
"kr",
"*",
"GroupResolver",
")",
"RemoveKeys",
"(",
"name",
"string",
")",
"{",
"kr",
".",
"Lock",
"(",
")",
"\n",
"defer",
"kr",
".",
"Unlock",
"(",
")",
"\n",
"delete",
"(",
"kr",
".",
"keyMap",
",",
"name",
")",
"\n",
"return",
"\n",
"}"
] | // RemoveKeys removes all keys from the resolver stored under the provided name. | [
"RemoveKeys",
"removes",
"all",
"keys",
"from",
"the",
"resolver",
"stored",
"under",
"the",
"provided",
"name",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/middleware/security/jwt/resolver.go#L125-L130 | train |
goadesign/goa | middleware/security/jwt/resolver.go | RemoveKey | func (kr *GroupResolver) RemoveKey(name string, key Key) {
kr.Lock()
defer kr.Unlock()
if keys, ok := kr.keyMap[name]; ok {
for i, keyItem := range keys {
if keyItem == key {
kr.keyMap[name] = append(keys[:i], keys[i+1:]...)
}
}
}
return
} | go | func (kr *GroupResolver) RemoveKey(name string, key Key) {
kr.Lock()
defer kr.Unlock()
if keys, ok := kr.keyMap[name]; ok {
for i, keyItem := range keys {
if keyItem == key {
kr.keyMap[name] = append(keys[:i], keys[i+1:]...)
}
}
}
return
} | [
"func",
"(",
"kr",
"*",
"GroupResolver",
")",
"RemoveKey",
"(",
"name",
"string",
",",
"key",
"Key",
")",
"{",
"kr",
".",
"Lock",
"(",
")",
"\n",
"defer",
"kr",
".",
"Unlock",
"(",
")",
"\n",
"if",
"keys",
",",
"ok",
":=",
"kr",
".",
"keyMap",
"[",
"name",
"]",
";",
"ok",
"{",
"for",
"i",
",",
"keyItem",
":=",
"range",
"keys",
"{",
"if",
"keyItem",
"==",
"key",
"{",
"kr",
".",
"keyMap",
"[",
"name",
"]",
"=",
"append",
"(",
"keys",
"[",
":",
"i",
"]",
",",
"keys",
"[",
"i",
"+",
"1",
":",
"]",
"...",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // RemoveKey removes only the provided key stored under the provided name from
// the resolver. | [
"RemoveKey",
"removes",
"only",
"the",
"provided",
"key",
"stored",
"under",
"the",
"provided",
"name",
"from",
"the",
"resolver",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/middleware/security/jwt/resolver.go#L134-L145 | train |
goadesign/goa | middleware/security/jwt/resolver.go | GetAllKeys | func (kr *GroupResolver) GetAllKeys() []Key {
kr.RLock()
defer kr.RUnlock()
var keys []Key
for name := range kr.keyMap {
for _, key := range kr.keyMap[name] {
keys = append(keys, key)
}
}
return keys
} | go | func (kr *GroupResolver) GetAllKeys() []Key {
kr.RLock()
defer kr.RUnlock()
var keys []Key
for name := range kr.keyMap {
for _, key := range kr.keyMap[name] {
keys = append(keys, key)
}
}
return keys
} | [
"func",
"(",
"kr",
"*",
"GroupResolver",
")",
"GetAllKeys",
"(",
")",
"[",
"]",
"Key",
"{",
"kr",
".",
"RLock",
"(",
")",
"\n",
"defer",
"kr",
".",
"RUnlock",
"(",
")",
"\n",
"var",
"keys",
"[",
"]",
"Key",
"\n",
"for",
"name",
":=",
"range",
"kr",
".",
"keyMap",
"{",
"for",
"_",
",",
"key",
":=",
"range",
"kr",
".",
"keyMap",
"[",
"name",
"]",
"{",
"keys",
"=",
"append",
"(",
"keys",
",",
"key",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"keys",
"\n",
"}"
] | // GetAllKeys returns a list of all the keys stored in the resolver. | [
"GetAllKeys",
"returns",
"a",
"list",
"of",
"all",
"the",
"keys",
"stored",
"in",
"the",
"resolver",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/middleware/security/jwt/resolver.go#L148-L158 | train |
goadesign/goa | middleware/security/jwt/resolver.go | GetKeys | func (kr *GroupResolver) GetKeys(name string) ([]Key, error) {
kr.RLock()
defer kr.RUnlock()
if keys, ok := kr.keyMap[name]; ok {
return keys, nil
}
return nil, ErrKeyDoesNotExist
} | go | func (kr *GroupResolver) GetKeys(name string) ([]Key, error) {
kr.RLock()
defer kr.RUnlock()
if keys, ok := kr.keyMap[name]; ok {
return keys, nil
}
return nil, ErrKeyDoesNotExist
} | [
"func",
"(",
"kr",
"*",
"GroupResolver",
")",
"GetKeys",
"(",
"name",
"string",
")",
"(",
"[",
"]",
"Key",
",",
"error",
")",
"{",
"kr",
".",
"RLock",
"(",
")",
"\n",
"defer",
"kr",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"keys",
",",
"ok",
":=",
"kr",
".",
"keyMap",
"[",
"name",
"]",
";",
"ok",
"{",
"return",
"keys",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"ErrKeyDoesNotExist",
"\n",
"}"
] | // GetKeys returns a list of all the keys stored in the resolver under the
// provided name. | [
"GetKeys",
"returns",
"a",
"list",
"of",
"all",
"the",
"keys",
"stored",
"in",
"the",
"resolver",
"under",
"the",
"provided",
"name",
"."
] | 90bd33edff1a4f17fab06d1f9e14e659075d1328 | https://github.com/goadesign/goa/blob/90bd33edff1a4f17fab06d1f9e14e659075d1328/middleware/security/jwt/resolver.go#L162-L169 | train |
Subsets and Splits