Datasets:

semeru

/

code-text-go

like 2

Follow

Semeru Lab 7

[ "func", "SetContextRequestID", "(", "ctx", "context", ".", "Context", ",", "reqID", "string", ")", "context", ".", "Context", "{", "return", "context", ".", "WithValue", "(", "ctx", ",", "reqIDKey", ",", "reqID", ")", "\n", "}" ]

[ "SetContextRequestID", "sets", "a", "request", "ID", "in", "the", "given", "context", "and", "returns", "a", "new", "context", "." ]

[ "func", "NewAdaptiveSampler", "(", "maxSamplingRate", ",", "sampleSize", "int", ")", "Sampler", "{", "if", "maxSamplingRate", "<=", "0", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "sampleSize", "<=", "0", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "&", "adaptiveSampler", "{", "lastRate", ":", "adaptiveUpperBoundInt", ",", "// samples all until initial count reaches sample size", "maxSamplingRate", ":", "maxSamplingRate", ",", "sampleSize", ":", "uint32", "(", "sampleSize", ")", ",", "start", ":", "time", ".", "Now", "(", ")", ",", "}", "\n", "}" ]

[ "NewAdaptiveSampler", "computes", "the", "interval", "for", "sampling", "for", "tracing", "middleware", ".", "it", "can", "also", "be", "used", "by", "non", "-", "web", "go", "routines", "to", "trace", "internal", "API", "calls", ".", "maxSamplingRate", "is", "the", "desired", "maximum", "sampling", "rate", "in", "requests", "per", "second", ".", "sampleSize", "sets", "the", "number", "of", "requests", "between", "two", "adjustments", "of", "the", "sampling", "rate", "when", "MaxSamplingRate", "is", "set", ".", "the", "sample", "rate", "cannot", "be", "adjusted", "until", "the", "sample", "size", "is", "reached", "at", "least", "once", "." ]

[ "func", "(", "s", "*", "adaptiveSampler", ")", "Sample", "(", ")", "bool", "{", "// adjust sampling rate whenever sample size is reached.", "var", "currentRate", "int", "\n", "if", "atomic", ".", "AddUint32", "(", "&", "s", ".", "counter", ",", "1", ")", "==", "s", ".", "sampleSize", "{", "// exact match prevents", "atomic", ".", "StoreUint32", "(", "&", "s", ".", "counter", ",", "0", ")", "// race is ok", "\n", "s", ".", "Lock", "(", ")", "\n", "{", "d", ":=", "time", ".", "Since", "(", "s", ".", "start", ")", ".", "Seconds", "(", ")", "\n", "r", ":=", "float64", "(", "s", ".", "sampleSize", ")", "/", "d", "\n", "currentRate", "=", "int", "(", "(", "float64", "(", "s", ".", "maxSamplingRate", ")", "*", "adaptiveUpperBoundFloat", ")", "/", "r", ")", "\n", "if", "currentRate", ">", "adaptiveUpperBoundInt", "{", "currentRate", "=", "adaptiveUpperBoundInt", "\n", "}", "else", "if", "currentRate", "<", "1", "{", "currentRate", "=", "1", "\n", "}", "\n", "s", ".", "start", "=", "time", ".", "Now", "(", ")", "\n", "}", "\n", "s", ".", "Unlock", "(", ")", "\n", "atomic", ".", "StoreInt64", "(", "&", "s", ".", "lastRate", ",", "int64", "(", "currentRate", ")", ")", "\n", "}", "else", "{", "currentRate", "=", "int", "(", "atomic", ".", "LoadInt64", "(", "&", "s", ".", "lastRate", ")", ")", "\n", "}", "\n\n", "// currentRate is never zero.", "return", "currentRate", "==", "adaptiveUpperBoundInt", "||", "rand", ".", "Intn", "(", "adaptiveUpperBoundInt", ")", "<", "currentRate", "\n", "}" ]

[ "Sample", "implementation", "for", "adaptive", "rate" ]

[ "func", "(", "s", "fixedSampler", ")", "Sample", "(", ")", "bool", "{", "samplingPercent", ":=", "int", "(", "s", ")", "\n", "return", "samplingPercent", ">", "0", "&&", "(", "samplingPercent", "==", "100", "||", "rand", ".", "Intn", "(", "100", ")", "<", "samplingPercent", ")", "\n", "}" ]

[ "Sample", "implementation", "for", "fixed", "percentage" ]

[ "func", "NewImport", "(", "name", ",", "path", "string", ")", "*", "ImportSpec", "{", "return", "&", "ImportSpec", "{", "Name", ":", "name", ",", "Path", ":", "path", "}", "\n", "}" ]

[ "NewImport", "creates", "an", "import", "spec", "." ]

[ "func", "(", "s", "*", "ImportSpec", ")", "Code", "(", ")", "string", "{", "if", "len", "(", "s", ".", "Name", ")", ">", "0", "{", "return", "fmt", ".", "Sprintf", "(", "`%s \"%s\"`", ",", "s", ".", "Name", ",", "s", ".", "Path", ")", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "`\"%s\"`", ",", "s", ".", "Path", ")", "\n", "}" ]

[ "Code", "returns", "the", "Go", "import", "statement", "for", "the", "ImportSpec", "." ]

[ "func", "appendImports", "(", "i", ",", "a", "[", "]", "*", "ImportSpec", ")", "[", "]", "*", "ImportSpec", "{", "for", "_", ",", "v", ":=", "range", "a", "{", "contains", ":=", "false", "\n", "for", "_", ",", "att", ":=", "range", "i", "{", "if", "att", ".", "Path", "==", "v", ".", "Path", "{", "contains", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n", "if", "contains", "!=", "true", "{", "i", "=", "append", "(", "i", ",", "v", ")", "\n", "}", "\n", "}", "\n", "return", "i", "\n", "}" ]

[ "appendImports", "appends", "two", "ImportSpec", "slices", "and", "preserves", "uniqueness" ]

[ "func", "NewJSONSchema", "(", ")", "*", "JSONSchema", "{", "js", ":=", "JSONSchema", "{", "Properties", ":", "make", "(", "map", "[", "string", "]", "*", "JSONSchema", ")", ",", "Definitions", ":", "make", "(", "map", "[", "string", "]", "*", "JSONSchema", ")", ",", "}", "\n", "return", "&", "js", "\n", "}" ]

[ "NewJSONSchema", "instantiates", "a", "new", "JSON", "schema", "." ]

[ "func", "APISchema", "(", "api", "*", "design", ".", "APIDefinition", ")", "*", "JSONSchema", "{", "api", ".", "IterateResources", "(", "func", "(", "r", "*", "design", ".", "ResourceDefinition", ")", "error", "{", "GenerateResourceDefinition", "(", "api", ",", "r", ")", "\n", "return", "nil", "\n", "}", ")", "\n", "scheme", ":=", "\"", "\"", "\n", "if", "len", "(", "api", ".", "Schemes", ")", ">", "0", "{", "scheme", "=", "api", ".", "Schemes", "[", "0", "]", "\n", "}", "\n", "u", ":=", "url", ".", "URL", "{", "Scheme", ":", "scheme", ",", "Host", ":", "api", ".", "Host", "}", "\n", "href", ":=", "u", ".", "String", "(", ")", "\n", "links", ":=", "[", "]", "*", "JSONLink", "{", "{", "Href", ":", "href", ",", "Rel", ":", "\"", "\"", ",", "}", ",", "{", "Href", ":", "\"", "\"", ",", "Method", ":", "\"", "\"", ",", "Rel", ":", "\"", "\"", ",", "TargetSchema", ":", "&", "JSONSchema", "{", "Schema", ":", "SchemaRef", ",", "AdditionalProperties", ":", "true", ",", "}", ",", "}", ",", "}", "\n", "s", ":=", "JSONSchema", "{", "ID", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "href", ")", ",", "Title", ":", "api", ".", "Title", ",", "Description", ":", "api", ".", "Description", ",", "Type", ":", "JSONObject", ",", "Definitions", ":", "Definitions", ",", "Properties", ":", "propertiesFromDefs", "(", "Definitions", ",", "\"", "\"", ")", ",", "Links", ":", "links", ",", "}", "\n", "return", "&", "s", "\n", "}" ]

[ "APISchema", "produces", "the", "API", "JSON", "hyper", "schema", "." ]

[ "func", "GenerateResourceDefinition", "(", "api", "*", "design", ".", "APIDefinition", ",", "r", "*", "design", ".", "ResourceDefinition", ")", "{", "s", ":=", "NewJSONSchema", "(", ")", "\n", "s", ".", "Description", "=", "r", ".", "Description", "\n", "s", ".", "Type", "=", "JSONObject", "\n", "s", ".", "Title", "=", "r", ".", "Name", "\n", "Definitions", "[", "r", ".", "Name", "]", "=", "s", "\n", "if", "mt", ",", "ok", ":=", "api", ".", "MediaTypes", "[", "r", ".", "MediaType", "]", ";", "ok", "{", "for", "_", ",", "v", ":=", "range", "mt", ".", "Views", "{", "buildMediaTypeSchema", "(", "api", ",", "mt", ",", "v", ".", "Name", ",", "s", ")", "\n", "}", "\n", "}", "\n", "r", ".", "IterateActions", "(", "func", "(", "a", "*", "design", ".", "ActionDefinition", ")", "error", "{", "var", "requestSchema", "*", "JSONSchema", "\n", "if", "a", ".", "Payload", "!=", "nil", "{", "requestSchema", "=", "TypeSchema", "(", "api", ",", "a", ".", "Payload", ")", "\n", "requestSchema", ".", "Description", "=", "a", ".", "Name", "+", "\"", "\"", "\n", "}", "\n", "if", "a", ".", "Params", "!=", "nil", "{", "params", ":=", "design", ".", "DupAtt", "(", "a", ".", "Params", ")", "\n", "// We don't want to keep the path params, these are defined inline in the href", "for", "_", ",", "r", ":=", "range", "a", ".", "Routes", "{", "for", "_", ",", "p", ":=", "range", "r", ".", "Params", "(", ")", "{", "delete", "(", "params", ".", "Type", ".", "ToObject", "(", ")", ",", "p", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "var", "targetSchema", "*", "JSONSchema", "\n", "var", "identifier", "string", "\n", "for", "_", ",", "resp", ":=", "range", "a", ".", "Responses", "{", "if", "mt", ",", "ok", ":=", "api", ".", "MediaTypes", "[", "resp", ".", "MediaType", "]", ";", "ok", "{", "if", "identifier", "==", "\"", "\"", "{", "identifier", "=", "mt", ".", "Identifier", "\n", "}", "else", "{", "identifier", "=", "\"", "\"", "\n", "}", "\n", "if", "targetSchema", "==", "nil", "{", "targetSchema", "=", "TypeSchema", "(", "api", ",", "mt", ")", "\n", "}", "else", "if", "targetSchema", ".", "AnyOf", "==", "nil", "{", "firstSchema", ":=", "targetSchema", "\n", "targetSchema", "=", "NewJSONSchema", "(", ")", "\n", "targetSchema", ".", "AnyOf", "=", "[", "]", "*", "JSONSchema", "{", "firstSchema", ",", "TypeSchema", "(", "api", ",", "mt", ")", "}", "\n", "}", "else", "{", "targetSchema", ".", "AnyOf", "=", "append", "(", "targetSchema", ".", "AnyOf", ",", "TypeSchema", "(", "api", ",", "mt", ")", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "for", "i", ",", "r", ":=", "range", "a", ".", "Routes", "{", "link", ":=", "JSONLink", "{", "Title", ":", "a", ".", "Name", ",", "Rel", ":", "a", ".", "Name", ",", "Href", ":", "toSchemaHref", "(", "api", ",", "r", ")", ",", "Method", ":", "r", ".", "Verb", ",", "Schema", ":", "requestSchema", ",", "TargetSchema", ":", "targetSchema", ",", "MediaType", ":", "identifier", ",", "}", "\n", "if", "i", "==", "0", "{", "if", "ca", ":=", "a", ".", "Parent", ".", "CanonicalAction", "(", ")", ";", "ca", "!=", "nil", "{", "if", "ca", ".", "Name", "==", "a", ".", "Name", "{", "link", ".", "Rel", "=", "\"", "\"", "\n", "}", "\n", "}", "\n", "}", "\n", "s", ".", "Links", "=", "append", "(", "s", ".", "Links", ",", "&", "link", ")", "\n", "}", "\n", "return", "nil", "\n", "}", ")", "\n", "}" ]

[ "GenerateResourceDefinition", "produces", "the", "JSON", "schema", "corresponding", "to", "the", "given", "API", "resource", ".", "It", "stores", "the", "results", "in", "cachedSchema", "." ]

[ "func", "MediaTypeRef", "(", "api", "*", "design", ".", "APIDefinition", ",", "mt", "*", "design", ".", "MediaTypeDefinition", ",", "view", "string", ")", "string", "{", "projected", ",", "_", ",", "err", ":=", "mt", ".", "Project", "(", "view", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "mt", ".", "Identifier", ",", "err", ")", ")", "// bug", "\n", "}", "\n", "if", "_", ",", "ok", ":=", "Definitions", "[", "projected", ".", "TypeName", "]", ";", "!", "ok", "{", "GenerateMediaTypeDefinition", "(", "api", ",", "projected", ",", "\"", "\"", ")", "\n", "}", "\n", "ref", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "projected", ".", "TypeName", ")", "\n", "return", "ref", "\n", "}" ]

[ "MediaTypeRef", "produces", "the", "JSON", "reference", "to", "the", "media", "type", "definition", "with", "the", "given", "view", "." ]

[ "func", "TypeRef", "(", "api", "*", "design", ".", "APIDefinition", ",", "ut", "*", "design", ".", "UserTypeDefinition", ")", "string", "{", "if", "_", ",", "ok", ":=", "Definitions", "[", "ut", ".", "TypeName", "]", ";", "!", "ok", "{", "GenerateTypeDefinition", "(", "api", ",", "ut", ")", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "ut", ".", "TypeName", ")", "\n", "}" ]

[ "TypeRef", "produces", "the", "JSON", "reference", "to", "the", "type", "definition", "." ]

[ "func", "GenerateMediaTypeDefinition", "(", "api", "*", "design", ".", "APIDefinition", ",", "mt", "*", "design", ".", "MediaTypeDefinition", ",", "view", "string", ")", "{", "if", "_", ",", "ok", ":=", "Definitions", "[", "mt", ".", "TypeName", "]", ";", "ok", "{", "return", "\n", "}", "\n", "s", ":=", "NewJSONSchema", "(", ")", "\n", "s", ".", "Title", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "mt", ".", "Identifier", ")", "\n", "Definitions", "[", "mt", ".", "TypeName", "]", "=", "s", "\n", "buildMediaTypeSchema", "(", "api", ",", "mt", ",", "view", ",", "s", ")", "\n", "}" ]

[ "GenerateMediaTypeDefinition", "produces", "the", "JSON", "schema", "corresponding", "to", "the", "given", "media", "type", "and", "given", "view", "." ]

[ "func", "GenerateTypeDefinition", "(", "api", "*", "design", ".", "APIDefinition", ",", "ut", "*", "design", ".", "UserTypeDefinition", ")", "{", "if", "_", ",", "ok", ":=", "Definitions", "[", "ut", ".", "TypeName", "]", ";", "ok", "{", "return", "\n", "}", "\n", "s", ":=", "NewJSONSchema", "(", ")", "\n", "s", ".", "Title", "=", "ut", ".", "TypeName", "\n", "Definitions", "[", "ut", ".", "TypeName", "]", "=", "s", "\n", "buildAttributeSchema", "(", "api", ",", "s", ",", "ut", ".", "AttributeDefinition", ")", "\n", "}" ]

[ "GenerateTypeDefinition", "produces", "the", "JSON", "schema", "corresponding", "to", "the", "given", "type", "." ]

[ "func", "TypeSchema", "(", "api", "*", "design", ".", "APIDefinition", ",", "t", "design", ".", "DataType", ")", "*", "JSONSchema", "{", "s", ":=", "NewJSONSchema", "(", ")", "\n", "switch", "actual", ":=", "t", ".", "(", "type", ")", "{", "case", "design", ".", "Primitive", ":", "if", "name", ":=", "actual", ".", "Name", "(", ")", ";", "name", "!=", "\"", "\"", "{", "s", ".", "Type", "=", "JSONType", "(", "actual", ".", "Name", "(", ")", ")", "\n", "}", "\n", "switch", "actual", ".", "Kind", "(", ")", "{", "case", "design", ".", "UUIDKind", ":", "s", ".", "Format", "=", "\"", "\"", "\n", "case", "design", ".", "DateTimeKind", ":", "s", ".", "Format", "=", "\"", "\"", "\n", "case", "design", ".", "NumberKind", ":", "s", ".", "Format", "=", "\"", "\"", "\n", "case", "design", ".", "IntegerKind", ":", "s", ".", "Format", "=", "\"", "\"", "\n", "}", "\n", "case", "*", "design", ".", "Array", ":", "s", ".", "Type", "=", "JSONArray", "\n", "s", ".", "Items", "=", "NewJSONSchema", "(", ")", "\n", "buildAttributeSchema", "(", "api", ",", "s", ".", "Items", ",", "actual", ".", "ElemType", ")", "\n", "case", "design", ".", "Object", ":", "s", ".", "Type", "=", "JSONObject", "\n", "for", "n", ",", "at", ":=", "range", "actual", "{", "prop", ":=", "NewJSONSchema", "(", ")", "\n", "buildAttributeSchema", "(", "api", ",", "prop", ",", "at", ")", "\n", "s", ".", "Properties", "[", "n", "]", "=", "prop", "\n", "}", "\n", "case", "*", "design", ".", "Hash", ":", "s", ".", "Type", "=", "JSONObject", "\n", "s", ".", "AdditionalProperties", "=", "true", "\n", "case", "*", "design", ".", "UserTypeDefinition", ":", "s", ".", "Ref", "=", "TypeRef", "(", "api", ",", "actual", ")", "\n", "case", "*", "design", ".", "MediaTypeDefinition", ":", "// Use \"default\" view by default", "s", ".", "Ref", "=", "MediaTypeRef", "(", "api", ",", "actual", ",", "design", ".", "DefaultView", ")", "\n", "}", "\n", "return", "s", "\n", "}" ]

[ "TypeSchema", "produces", "the", "JSON", "schema", "corresponding", "to", "the", "given", "data", "type", "." ]

[ "func", "(", "s", "*", "JSONSchema", ")", "Merge", "(", "other", "*", "JSONSchema", ")", "{", "items", ":=", "s", ".", "createMergeItems", "(", "other", ")", "\n", "for", "_", ",", "v", ":=", "range", "items", "{", "if", "v", ".", "needed", "&&", "v", ".", "b", "!=", "nil", "{", "reflect", ".", "Indirect", "(", "reflect", ".", "ValueOf", "(", "v", ".", "a", ")", ")", ".", "Set", "(", "reflect", ".", "ValueOf", "(", "v", ".", "b", ")", ")", "\n", "}", "\n", "}", "\n\n", "for", "n", ",", "p", ":=", "range", "other", ".", "Properties", "{", "if", "_", ",", "ok", ":=", "s", ".", "Properties", "[", "n", "]", ";", "!", "ok", "{", "if", "s", ".", "Properties", "==", "nil", "{", "s", ".", "Properties", "=", "make", "(", "map", "[", "string", "]", "*", "JSONSchema", ")", "\n", "}", "\n", "s", ".", "Properties", "[", "n", "]", "=", "p", "\n", "}", "\n", "}", "\n\n", "for", "n", ",", "d", ":=", "range", "other", ".", "Definitions", "{", "if", "_", ",", "ok", ":=", "s", ".", "Definitions", "[", "n", "]", ";", "!", "ok", "{", "s", ".", "Definitions", "[", "n", "]", "=", "d", "\n", "}", "\n", "}", "\n\n", "for", "_", ",", "l", ":=", "range", "other", ".", "Links", "{", "s", ".", "Links", "=", "append", "(", "s", ".", "Links", ",", "l", ")", "\n", "}", "\n\n", "for", "_", ",", "r", ":=", "range", "other", ".", "Required", "{", "s", ".", "Required", "=", "append", "(", "s", ".", "Required", ",", "r", ")", "\n", "}", "\n", "}" ]

[ "Merge", "does", "a", "two", "level", "deep", "merge", "of", "other", "into", "s", "." ]

[ "func", "(", "s", "*", "JSONSchema", ")", "Dup", "(", ")", "*", "JSONSchema", "{", "js", ":=", "JSONSchema", "{", "ID", ":", "s", ".", "ID", ",", "Description", ":", "s", ".", "Description", ",", "Schema", ":", "s", ".", "Schema", ",", "Type", ":", "s", ".", "Type", ",", "DefaultValue", ":", "s", ".", "DefaultValue", ",", "Title", ":", "s", ".", "Title", ",", "Media", ":", "s", ".", "Media", ",", "ReadOnly", ":", "s", ".", "ReadOnly", ",", "PathStart", ":", "s", ".", "PathStart", ",", "Links", ":", "s", ".", "Links", ",", "Ref", ":", "s", ".", "Ref", ",", "Enum", ":", "s", ".", "Enum", ",", "Format", ":", "s", ".", "Format", ",", "Pattern", ":", "s", ".", "Pattern", ",", "Minimum", ":", "s", ".", "Minimum", ",", "Maximum", ":", "s", ".", "Maximum", ",", "MinLength", ":", "s", ".", "MinLength", ",", "MaxLength", ":", "s", ".", "MaxLength", ",", "MinItems", ":", "s", ".", "MinItems", ",", "MaxItems", ":", "s", ".", "MaxItems", ",", "Required", ":", "s", ".", "Required", ",", "AdditionalProperties", ":", "s", ".", "AdditionalProperties", ",", "}", "\n", "for", "n", ",", "p", ":=", "range", "s", ".", "Properties", "{", "js", ".", "Properties", "[", "n", "]", "=", "p", ".", "Dup", "(", ")", "\n", "}", "\n", "if", "s", ".", "Items", "!=", "nil", "{", "js", ".", "Items", "=", "s", ".", "Items", ".", "Dup", "(", ")", "\n", "}", "\n", "for", "n", ",", "d", ":=", "range", "s", ".", "Definitions", "{", "js", ".", "Definitions", "[", "n", "]", "=", "d", ".", "Dup", "(", ")", "\n", "}", "\n", "return", "&", "js", "\n", "}" ]

[ "Dup", "creates", "a", "shallow", "clone", "of", "the", "given", "schema", "." ]

[ "func", "buildAttributeSchema", "(", "api", "*", "design", ".", "APIDefinition", ",", "s", "*", "JSONSchema", ",", "at", "*", "design", ".", "AttributeDefinition", ")", "*", "JSONSchema", "{", "if", "at", ".", "View", "!=", "\"", "\"", "{", "inner", ":=", "NewJSONSchema", "(", ")", "\n", "inner", ".", "Ref", "=", "MediaTypeRef", "(", "api", ",", "at", ".", "Type", ".", "(", "*", "design", ".", "MediaTypeDefinition", ")", ",", "at", ".", "View", ")", "\n", "s", ".", "Merge", "(", "inner", ")", "\n", "return", "s", "\n", "}", "\n", "s", ".", "Merge", "(", "TypeSchema", "(", "api", ",", "at", ".", "Type", ")", ")", "\n", "if", "s", ".", "Ref", "!=", "\"", "\"", "{", "// Ref is exclusive with other fields", "return", "s", "\n", "}", "\n", "s", ".", "DefaultValue", "=", "toStringMap", "(", "at", ".", "DefaultValue", ")", "\n", "s", ".", "Description", "=", "at", ".", "Description", "\n", "s", ".", "Example", "=", "at", ".", "GenerateExample", "(", "api", ".", "RandomGenerator", "(", ")", ",", "nil", ")", "\n", "s", ".", "ReadOnly", "=", "at", ".", "IsReadOnly", "(", ")", "\n", "val", ":=", "at", ".", "Validation", "\n", "if", "val", "==", "nil", "{", "return", "s", "\n", "}", "\n", "s", ".", "Enum", "=", "val", ".", "Values", "\n", "s", ".", "Format", "=", "val", ".", "Format", "\n", "s", ".", "Pattern", "=", "val", ".", "Pattern", "\n", "if", "val", ".", "Minimum", "!=", "nil", "{", "s", ".", "Minimum", "=", "val", ".", "Minimum", "\n", "}", "\n", "if", "val", ".", "Maximum", "!=", "nil", "{", "s", ".", "Maximum", "=", "val", ".", "Maximum", "\n", "}", "\n", "if", "val", ".", "MinLength", "!=", "nil", "{", "switch", "{", "case", "at", ".", "Type", ".", "IsArray", "(", ")", ":", "s", ".", "MinItems", "=", "val", ".", "MinLength", "\n", "default", ":", "s", ".", "MinLength", "=", "val", ".", "MinLength", "\n", "}", "\n", "}", "\n", "if", "val", ".", "MaxLength", "!=", "nil", "{", "switch", "{", "case", "at", ".", "Type", ".", "IsArray", "(", ")", ":", "s", ".", "MaxItems", "=", "val", ".", "MaxLength", "\n", "default", ":", "s", ".", "MaxLength", "=", "val", ".", "MaxLength", "\n", "}", "\n", "}", "\n", "s", ".", "Required", "=", "val", ".", "Required", "\n", "return", "s", "\n", "}" ]

[ "buildAttributeSchema", "initializes", "the", "given", "JSON", "schema", "that", "corresponds", "to", "the", "given", "attribute", "." ]

[ "func", "toSchemaHref", "(", "api", "*", "design", ".", "APIDefinition", ",", "r", "*", "design", ".", "RouteDefinition", ")", "string", "{", "params", ":=", "r", ".", "Params", "(", ")", "\n", "args", ":=", "make", "(", "[", "]", "interface", "{", "}", ",", "len", "(", "params", ")", ")", "\n", "for", "i", ",", "p", ":=", "range", "params", "{", "args", "[", "i", "]", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "p", ")", "\n", "}", "\n", "tmpl", ":=", "design", ".", "WildcardRegex", ".", "ReplaceAllLiteralString", "(", "r", ".", "FullPath", "(", ")", ",", "\"", "\"", ")", "\n", "return", "fmt", ".", "Sprintf", "(", "tmpl", ",", "args", "...", ")", "\n", "}" ]

[ "toSchemaHref", "produces", "a", "href", "that", "replaces", "the", "path", "wildcards", "with", "JSON", "schema", "references", "when", "appropriate", "." ]

[ "func", "propertiesFromDefs", "(", "definitions", "map", "[", "string", "]", "*", "JSONSchema", ",", "path", "string", ")", "map", "[", "string", "]", "*", "JSONSchema", "{", "res", ":=", "make", "(", "map", "[", "string", "]", "*", "JSONSchema", ",", "len", "(", "definitions", ")", ")", "\n", "for", "n", ":=", "range", "definitions", "{", "if", "n", "==", "\"", "\"", "{", "continue", "\n", "}", "\n", "s", ":=", "NewJSONSchema", "(", ")", "\n", "s", ".", "Ref", "=", "path", "+", "n", "\n", "res", "[", "n", "]", "=", "s", "\n", "}", "\n", "return", "res", "\n", "}" ]

[ "propertiesFromDefs", "creates", "a", "Properties", "map", "referencing", "the", "given", "definitions", "under", "the", "given", "path", "." ]

[ "func", "buildMediaTypeSchema", "(", "api", "*", "design", ".", "APIDefinition", ",", "mt", "*", "design", ".", "MediaTypeDefinition", ",", "view", "string", ",", "s", "*", "JSONSchema", ")", "{", "s", ".", "Media", "=", "&", "JSONMedia", "{", "Type", ":", "mt", ".", "Identifier", "}", "\n", "projected", ",", "linksUT", ",", "err", ":=", "mt", ".", "Project", "(", "view", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "mt", ".", "Identifier", ",", "err", ")", ")", "// bug", "\n", "}", "\n", "if", "linksUT", "!=", "nil", "{", "links", ":=", "linksUT", ".", "Type", ".", "ToObject", "(", ")", "\n", "lnames", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "links", ")", ")", "\n", "i", ":=", "0", "\n", "for", "n", ":=", "range", "links", "{", "lnames", "[", "i", "]", "=", "n", "\n", "i", "++", "\n", "}", "\n", "sort", ".", "Strings", "(", "lnames", ")", "\n", "for", "_", ",", "ln", ":=", "range", "lnames", "{", "var", "(", "att", "=", "links", "[", "ln", "]", "\n", "lmt", "=", "att", ".", "Type", ".", "(", "*", "design", ".", "MediaTypeDefinition", ")", "\n", "r", "=", "lmt", ".", "Resource", "\n", "href", "string", "\n", ")", "\n", "if", "r", "!=", "nil", "{", "href", "=", "toSchemaHref", "(", "api", ",", "r", ".", "CanonicalAction", "(", ")", ".", "Routes", "[", "0", "]", ")", "\n", "}", "\n", "sm", ":=", "NewJSONSchema", "(", ")", "\n", "sm", ".", "Ref", "=", "MediaTypeRef", "(", "api", ",", "lmt", ",", "\"", "\"", ")", "\n", "s", ".", "Links", "=", "append", "(", "s", ".", "Links", ",", "&", "JSONLink", "{", "Title", ":", "ln", ",", "Rel", ":", "ln", ",", "Description", ":", "att", ".", "Description", ",", "Href", ":", "href", ",", "Method", ":", "\"", "\"", ",", "TargetSchema", ":", "sm", ",", "MediaType", ":", "lmt", ".", "Identifier", ",", "}", ")", "\n", "}", "\n", "}", "\n", "buildAttributeSchema", "(", "api", ",", "s", ",", "projected", ".", "AttributeDefinition", ")", "\n", "}" ]

[ "buildMediaTypeSchema", "initializes", "s", "as", "the", "JSON", "schema", "representing", "mt", "for", "the", "given", "view", "." ]

[ "func", "(", "decoder", "*", "HTTPDecoder", ")", "Decode", "(", "v", "interface", "{", "}", ",", "body", "io", ".", "Reader", ",", "contentType", "string", ")", "error", "{", "now", ":=", "time", ".", "Now", "(", ")", "\n", "defer", "MeasureSince", "(", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "contentType", "}", ",", "now", ")", "\n", "var", "p", "*", "decoderPool", "\n", "if", "contentType", "==", "\"", "\"", "{", "// Default to JSON", "contentType", "=", "\"", "\"", "\n", "}", "else", "{", "if", "mediaType", ",", "_", ",", "err", ":=", "mime", ".", "ParseMediaType", "(", "contentType", ")", ";", "err", "==", "nil", "{", "contentType", "=", "mediaType", "\n", "}", "\n", "}", "\n", "p", "=", "decoder", ".", "pools", "[", "contentType", "]", "\n", "if", "p", "==", "nil", "{", "p", "=", "decoder", ".", "pools", "[", "\"", "\"", "]", "\n", "}", "\n", "if", "p", "==", "nil", "{", "return", "nil", "\n", "}", "\n\n", "// the decoderPool will handle whether or not a pool is actually in use", "d", ":=", "p", ".", "Get", "(", "body", ")", "\n", "defer", "p", ".", "Put", "(", "d", ")", "\n", "return", "d", ".", "Decode", "(", "v", ")", "\n", "}" ]

[ "Decode", "uses", "registered", "Decoders", "to", "unmarshal", "a", "body", "based", "on", "the", "contentType", "." ]

[ "func", "(", "decoder", "*", "HTTPDecoder", ")", "Register", "(", "f", "DecoderFunc", ",", "contentTypes", "...", "string", ")", "{", "p", ":=", "newDecodePool", "(", "f", ")", "\n\n", "for", "_", ",", "contentType", ":=", "range", "contentTypes", "{", "mediaType", ",", "_", ",", "err", ":=", "mime", ".", "ParseMediaType", "(", "contentType", ")", "\n", "if", "err", "!=", "nil", "{", "mediaType", "=", "contentType", "\n", "}", "\n", "decoder", ".", "pools", "[", "mediaType", "]", "=", "p", "\n", "}", "\n", "}" ]

[ "Register", "sets", "a", "specific", "decoder", "to", "be", "used", "for", "the", "specified", "content", "types", ".", "If", "a", "decoder", "is", "already", "registered", "it", "is", "overwritten", "." ]

[ "func", "newDecodePool", "(", "f", "DecoderFunc", ")", "*", "decoderPool", "{", "// get a new decoder and type assert to see if it can be reset", "d", ":=", "f", "(", "nil", ")", "\n", "rd", ",", "ok", ":=", "d", ".", "(", "ResettableDecoder", ")", "\n\n", "p", ":=", "&", "decoderPool", "{", "fn", ":", "f", "}", "\n\n", "// if the decoder can be reset, create a pool and put the typed decoder in", "if", "ok", "{", "p", ".", "pool", "=", "&", "sync", ".", "Pool", "{", "New", ":", "func", "(", ")", "interface", "{", "}", "{", "return", "f", "(", "nil", ")", "}", ",", "}", "\n", "p", ".", "pool", ".", "Put", "(", "rd", ")", "\n", "}", "\n\n", "return", "p", "\n", "}" ]

[ "newDecodePool", "checks", "to", "see", "if", "the", "DecoderFunc", "returns", "reusable", "decoders", "and", "if", "so", "creates", "a", "pool", "." ]

[ "func", "(", "p", "*", "decoderPool", ")", "Get", "(", "r", "io", ".", "Reader", ")", "Decoder", "{", "if", "p", ".", "pool", "==", "nil", "{", "return", "p", ".", "fn", "(", "r", ")", "\n", "}", "\n\n", "d", ":=", "p", ".", "pool", ".", "Get", "(", ")", ".", "(", "ResettableDecoder", ")", "\n", "d", ".", "Reset", "(", "r", ")", "\n", "return", "d", "\n", "}" ]

[ "Get", "returns", "an", "already", "reset", "Decoder", "from", "the", "pool", "or", "creates", "a", "new", "one", "if", "necessary", "." ]

[ "func", "(", "encoder", "*", "HTTPEncoder", ")", "Encode", "(", "v", "interface", "{", "}", ",", "resp", "io", ".", "Writer", ",", "accept", "string", ")", "error", "{", "now", ":=", "time", ".", "Now", "(", ")", "\n", "if", "accept", "==", "\"", "\"", "{", "accept", "=", "\"", "\"", "\n", "}", "\n", "var", "contentType", "string", "\n", "for", "_", ",", "t", ":=", "range", "encoder", ".", "contentTypes", "{", "if", "accept", "==", "\"", "\"", "||", "accept", "==", "t", "{", "contentType", "=", "accept", "\n", "break", "\n", "}", "\n", "}", "\n", "defer", "MeasureSince", "(", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "contentType", "}", ",", "now", ")", "\n", "p", ":=", "encoder", ".", "pools", "[", "contentType", "]", "\n", "if", "p", "==", "nil", "&&", "contentType", "!=", "\"", "\"", "{", "p", "=", "encoder", ".", "pools", "[", "\"", "\"", "]", "\n", "}", "\n", "if", "p", "==", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "contentType", ")", "\n", "}", "\n\n", "// the encoderPool will handle whether or not a pool is actually in use", "e", ":=", "p", ".", "Get", "(", "resp", ")", "\n", "if", "err", ":=", "e", ".", "Encode", "(", "v", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "p", ".", "Put", "(", "e", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "Encode", "uses", "the", "registered", "encoders", "and", "given", "content", "type", "to", "marshal", "and", "write", "the", "given", "value", "using", "the", "given", "writer", "." ]

[ "func", "(", "encoder", "*", "HTTPEncoder", ")", "Register", "(", "f", "EncoderFunc", ",", "contentTypes", "...", "string", ")", "{", "p", ":=", "newEncodePool", "(", "f", ")", "\n", "for", "_", ",", "contentType", ":=", "range", "contentTypes", "{", "mediaType", ",", "_", ",", "err", ":=", "mime", ".", "ParseMediaType", "(", "contentType", ")", "\n", "if", "err", "!=", "nil", "{", "mediaType", "=", "contentType", "\n", "}", "\n", "encoder", ".", "pools", "[", "mediaType", "]", "=", "p", "\n", "}", "\n\n", "// Rebuild a unique index of registered content encoders to be used in EncodeResponse", "encoder", ".", "contentTypes", "=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "encoder", ".", "pools", ")", ")", "\n", "for", "contentType", ":=", "range", "encoder", ".", "pools", "{", "encoder", ".", "contentTypes", "=", "append", "(", "encoder", ".", "contentTypes", ",", "contentType", ")", "\n", "}", "\n", "}" ]

[ "Register", "sets", "a", "specific", "encoder", "to", "be", "used", "for", "the", "specified", "content", "types", ".", "If", "an", "encoder", "is", "already", "registered", "it", "is", "overwritten", "." ]

[ "func", "newEncodePool", "(", "f", "EncoderFunc", ")", "*", "encoderPool", "{", "// get a new encoder and type assert to see if it can be reset", "e", ":=", "f", "(", "nil", ")", "\n", "re", ",", "ok", ":=", "e", ".", "(", "ResettableEncoder", ")", "\n\n", "p", ":=", "&", "encoderPool", "{", "fn", ":", "f", "}", "\n\n", "// if the encoder can be reset, create a pool and put the typed encoder in", "if", "ok", "{", "p", ".", "pool", "=", "&", "sync", ".", "Pool", "{", "New", ":", "func", "(", ")", "interface", "{", "}", "{", "return", "f", "(", "nil", ")", "}", ",", "}", "\n", "p", ".", "pool", ".", "Put", "(", "re", ")", "\n", "}", "\n\n", "return", "p", "\n", "}" ]

[ "newEncodePool", "checks", "to", "see", "if", "the", "EncoderFactory", "returns", "reusable", "encoders", "and", "if", "so", "creates", "a", "pool", "." ]

[ "func", "(", "p", "*", "encoderPool", ")", "Get", "(", "w", "io", ".", "Writer", ")", "Encoder", "{", "if", "p", ".", "pool", "==", "nil", "{", "return", "p", ".", "fn", "(", "w", ")", "\n", "}", "\n\n", "e", ":=", "p", ".", "pool", ".", "Get", "(", ")", ".", "(", "ResettableEncoder", ")", "\n", "e", ".", "Reset", "(", "w", ")", "\n", "return", "e", "\n", "}" ]

[ "Get", "returns", "an", "already", "reset", "Encoder", "from", "the", "pool", "or", "creates", "a", "new", "one", "if", "necessary", "." ]

[ "func", "(", "s", "*", "SecuritySchemeDefinition", ")", "Validate", "(", ")", "error", "{", "_", ",", "err", ":=", "url", ".", "Parse", "(", "s", ".", "TokenURL", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "s", ".", "TokenURL", ",", "err", ")", "\n", "}", "\n", "_", ",", "err", "=", "url", ".", "Parse", "(", "s", ".", "AuthorizationURL", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "s", ".", "AuthorizationURL", ",", "err", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Validate", "ensures", "that", "TokenURL", "and", "AuthorizationURL", "are", "valid", "URLs", "." ]

[ "func", "(", "s", "*", "SecuritySchemeDefinition", ")", "Finalize", "(", ")", "{", "tu", ",", "_", ":=", "url", ".", "Parse", "(", "s", ".", "TokenURL", ")", "// validated in Validate", "\n", "au", ",", "_", ":=", "url", ".", "Parse", "(", "s", ".", "AuthorizationURL", ")", "// validated in Validate", "\n", "tokenOK", ":=", "s", ".", "TokenURL", "==", "\"", "\"", "||", "tu", ".", "IsAbs", "(", ")", "\n", "authOK", ":=", "s", ".", "AuthorizationURL", "==", "\"", "\"", "||", "au", ".", "IsAbs", "(", ")", "\n", "if", "tokenOK", "&&", "authOK", "{", "return", "\n", "}", "\n", "var", "scheme", "string", "\n", "if", "len", "(", "Design", ".", "Schemes", ")", ">", "0", "{", "scheme", "=", "Design", ".", "Schemes", "[", "0", "]", "\n", "}", "\n", "if", "!", "tokenOK", "{", "tu", ".", "Scheme", "=", "scheme", "\n", "tu", ".", "Host", "=", "Design", ".", "Host", "\n", "s", ".", "TokenURL", "=", "tu", ".", "String", "(", ")", "\n", "}", "\n", "if", "!", "authOK", "{", "au", ".", "Scheme", "=", "scheme", "\n", "au", ".", "Host", "=", "Design", ".", "Host", "\n", "s", ".", "AuthorizationURL", "=", "au", ".", "String", "(", ")", "\n", "}", "\n", "}" ]

[ "Finalize", "makes", "the", "TokenURL", "and", "AuthorizationURL", "complete", "if", "needed", "." ]

[ "func", "NewDecoder", "(", "r", "io", ".", "Reader", ")", "goa", ".", "Decoder", "{", "return", "codec", ".", "NewDecoder", "(", "r", ",", "&", "Handle", ")", "\n", "}" ]

[ "NewDecoder", "returns", "a", "cbor", "decoder", "." ]

[ "func", "NewEncoder", "(", "w", "io", ".", "Writer", ")", "goa", ".", "Encoder", "{", "return", "codec", ".", "NewEncoder", "(", "w", ",", "&", "Handle", ")", "\n", "}" ]

[ "NewEncoder", "returns", "a", "cbor", "encoder", "." ]

[ "func", "(", "s", "*", "BasicSigner", ")", "Sign", "(", "req", "*", "http", ".", "Request", ")", "error", "{", "if", "s", ".", "Username", "!=", "\"", "\"", "&&", "s", ".", "Password", "!=", "\"", "\"", "{", "req", ".", "SetBasicAuth", "(", "s", ".", "Username", ",", "s", ".", "Password", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Sign", "adds", "the", "basic", "auth", "header", "to", "the", "request", "." ]

[ "func", "(", "s", "*", "APIKeySigner", ")", "Sign", "(", "req", "*", "http", ".", "Request", ")", "error", "{", "if", "s", ".", "KeyName", "==", "\"", "\"", "{", "s", ".", "KeyName", "=", "\"", "\"", "\n", "}", "\n", "if", "s", ".", "Format", "==", "\"", "\"", "{", "s", ".", "Format", "=", "\"", "\"", "\n", "}", "\n", "name", ":=", "s", ".", "KeyName", "\n", "format", ":=", "s", ".", "Format", "\n", "val", ":=", "fmt", ".", "Sprintf", "(", "format", ",", "s", ".", "KeyValue", ")", "\n", "if", "s", ".", "SignQuery", "&&", "val", "!=", "\"", "\"", "{", "query", ":=", "req", ".", "URL", ".", "Query", "(", ")", "\n", "query", ".", "Set", "(", "name", ",", "val", ")", "\n", "req", ".", "URL", ".", "RawQuery", "=", "query", ".", "Encode", "(", ")", "\n", "}", "else", "{", "req", ".", "Header", ".", "Set", "(", "name", ",", "val", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Sign", "adds", "the", "API", "key", "header", "to", "the", "request", "." ]

[ "func", "(", "s", "*", "JWTSigner", ")", "Sign", "(", "req", "*", "http", ".", "Request", ")", "error", "{", "return", "signFromSource", "(", "s", ".", "TokenSource", ",", "req", ")", "\n", "}" ]

[ "Sign", "adds", "the", "JWT", "auth", "header", "." ]

[ "func", "signFromSource", "(", "source", "TokenSource", ",", "req", "*", "http", ".", "Request", ")", "error", "{", "token", ",", "err", ":=", "source", ".", "Token", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "!", "token", ".", "Valid", "(", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "token", ".", "SetAuthHeader", "(", "req", ")", "\n", "return", "nil", "\n", "}" ]

[ "signFromSource", "generates", "a", "token", "using", "the", "given", "source", "and", "uses", "it", "to", "sign", "the", "request", "." ]

[ "func", "(", "t", "*", "StaticToken", ")", "SetAuthHeader", "(", "r", "*", "http", ".", "Request", ")", "{", "typ", ":=", "t", ".", "Type", "\n", "if", "typ", "==", "\"", "\"", "{", "typ", "=", "\"", "\"", "\n", "}", "\n", "r", ".", "Header", ".", "Set", "(", "\"", "\"", ",", "typ", "+", "\"", "\"", "+", "t", ".", "Value", ")", "\n", "}" ]

[ "SetAuthHeader", "sets", "the", "Authorization", "header", "to", "r", "." ]

[ "func", "init", "(", ")", "{", "var", "err", "error", "\n", "fn", ":=", "template", ".", "FuncMap", "{", "\"", "\"", ":", "Tabs", ",", "\"", "\"", ":", "func", "(", "a", ",", "b", "int", ")", "int", "{", "return", "a", "+", "b", "}", ",", "\"", "\"", ":", "Goify", ",", "\"", "\"", ":", "GoTypeRef", ",", "\"", "\"", ":", "GoTypeName", ",", "\"", "\"", ":", "transformAttribute", ",", "\"", "\"", ":", "transformArray", ",", "\"", "\"", ":", "transformHash", ",", "\"", "\"", ":", "transformObject", ",", "\"", "\"", ":", "typeName", ",", "}", "\n", "if", "transformT", ",", "err", "=", "template", ".", "New", "(", "\"", "\"", ")", ".", "Funcs", "(", "fn", ")", ".", "Parse", "(", "transformTmpl", ")", ";", "err", "!=", "nil", "{", "panic", "(", "err", ")", "// bug", "\n", "}", "\n", "if", "transformArrayT", ",", "err", "=", "template", ".", "New", "(", "\"", "\"", ")", ".", "Funcs", "(", "fn", ")", ".", "Parse", "(", "transformArrayTmpl", ")", ";", "err", "!=", "nil", "{", "panic", "(", "err", ")", "// bug", "\n", "}", "\n", "if", "transformHashT", ",", "err", "=", "template", ".", "New", "(", "\"", "\"", ")", ".", "Funcs", "(", "fn", ")", ".", "Parse", "(", "transformHashTmpl", ")", ";", "err", "!=", "nil", "{", "panic", "(", "err", ")", "// bug", "\n", "}", "\n", "if", "transformObjectT", ",", "err", "=", "template", ".", "New", "(", "\"", "\"", ")", ".", "Funcs", "(", "fn", ")", ".", "Parse", "(", "transformObjectTmpl", ")", ";", "err", "!=", "nil", "{", "panic", "(", "err", ")", "// bug", "\n", "}", "\n", "}" ]

[ "Initialize", "all", "templates" ]

[ "func", "goTypeDefObject", "(", "obj", "design", ".", "Object", ",", "def", "*", "design", ".", "AttributeDefinition", ",", "tabs", "int", ",", "jsonTags", ",", "private", "bool", ")", "string", "{", "var", "buffer", "bytes", ".", "Buffer", "\n", "buffer", ".", "WriteString", "(", "\"", "\\n", "\"", ")", "\n", "keys", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "obj", ")", ")", "\n", "i", ":=", "0", "\n", "for", "n", ":=", "range", "obj", "{", "keys", "[", "i", "]", "=", "n", "\n", "i", "++", "\n", "}", "\n", "sort", ".", "Strings", "(", "keys", ")", "\n", "for", "_", ",", "name", ":=", "range", "keys", "{", "WriteTabs", "(", "&", "buffer", ",", "tabs", "+", "1", ")", "\n", "field", ":=", "obj", "[", "name", "]", "\n", "typedef", ":=", "GoTypeDef", "(", "field", ",", "tabs", "+", "1", ",", "jsonTags", ",", "private", ")", "\n", "if", "(", "private", "&&", "field", ".", "Type", ".", "IsPrimitive", "(", ")", "&&", "!", "def", ".", "IsInterface", "(", "name", ")", ")", "||", "field", ".", "Type", ".", "IsObject", "(", ")", "||", "def", ".", "IsPrimitivePointer", "(", "name", ")", "{", "typedef", "=", "\"", "\"", "+", "typedef", "\n", "}", "\n", "fname", ":=", "GoifyAtt", "(", "field", ",", "name", ",", "true", ")", "\n", "var", "tags", "string", "\n", "if", "jsonTags", "{", "tags", "=", "attributeTags", "(", "def", ",", "field", ",", "name", ",", "private", ")", "\n", "}", "\n", "desc", ":=", "obj", "[", "name", "]", ".", "Description", "\n", "if", "desc", "!=", "\"", "\"", "{", "desc", "=", "strings", ".", "Replace", "(", "desc", ",", "\"", "\\n", "\"", ",", "\"", "\\n", "\\t", "\"", ",", "-", "1", ")", "\n", "desc", "=", "fmt", ".", "Sprintf", "(", "\"", "\\n", "\\t", "\"", ",", "desc", ")", "\n", "}", "\n", "buffer", ".", "WriteString", "(", "fmt", ".", "Sprintf", "(", "\"", "\\n", "\"", ",", "desc", ",", "fname", ",", "typedef", ",", "tags", ")", ")", "\n", "}", "\n", "WriteTabs", "(", "&", "buffer", ",", "tabs", ")", "\n", "buffer", ".", "WriteString", "(", "\"", "\"", ")", "\n", "return", "buffer", ".", "String", "(", ")", "\n", "}" ]

[ "goTypeDefObject", "returns", "the", "Go", "code", "that", "defines", "a", "Go", "struct", "." ]

[ "func", "attributeTags", "(", "parent", ",", "att", "*", "design", ".", "AttributeDefinition", ",", "name", "string", ",", "private", "bool", ")", "string", "{", "var", "elems", "[", "]", "string", "\n", "keys", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "att", ".", "Metadata", ")", ")", "\n", "i", ":=", "0", "\n", "for", "k", ":=", "range", "att", ".", "Metadata", "{", "keys", "[", "i", "]", "=", "k", "\n", "i", "++", "\n", "}", "\n", "sort", ".", "Strings", "(", "keys", ")", "\n", "for", "_", ",", "key", ":=", "range", "keys", "{", "val", ":=", "att", ".", "Metadata", "[", "key", "]", "\n", "if", "strings", ".", "HasPrefix", "(", "key", ",", "\"", "\"", ")", "{", "name", ":=", "key", "[", "11", ":", "]", "\n", "value", ":=", "strings", ".", "Join", "(", "val", ",", "\"", "\"", ")", "\n", "elems", "=", "append", "(", "elems", ",", "fmt", ".", "Sprintf", "(", "\"", "\\\"", "\\\"", "\"", ",", "name", ",", "value", ")", ")", "\n", "}", "\n", "}", "\n", "if", "len", "(", "elems", ")", ">", "0", "{", "return", "\"", "\"", "+", "strings", ".", "Join", "(", "elems", ",", "\"", "\"", ")", "+", "\"", "\"", "\n", "}", "\n", "// Default algorithm", "var", "omit", "string", "\n", "if", "private", "||", "(", "!", "parent", ".", "IsRequired", "(", "name", ")", "&&", "!", "parent", ".", "HasDefaultValue", "(", "name", ")", ")", "{", "omit", "=", "\"", "\"", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\\\"", "\\\"", "\\\"", "\\\"", "\\\"", "\\\"", "\\\"", "\\\"", "\"", ",", "name", ",", "omit", ",", "name", ",", "omit", ",", "name", ",", "omit", ",", "name", ",", "omit", ")", "\n", "}" ]

[ "attributeTags", "computes", "the", "struct", "field", "tags", "." ]

[ "func", "GoNativeType", "(", "t", "design", ".", "DataType", ")", "string", "{", "switch", "actual", ":=", "t", ".", "(", "type", ")", "{", "case", "design", ".", "Primitive", ":", "switch", "actual", ".", "Kind", "(", ")", "{", "case", "design", ".", "BooleanKind", ":", "return", "\"", "\"", "\n", "case", "design", ".", "IntegerKind", ":", "return", "\"", "\"", "\n", "case", "design", ".", "NumberKind", ":", "return", "\"", "\"", "\n", "case", "design", ".", "StringKind", ":", "return", "\"", "\"", "\n", "case", "design", ".", "DateTimeKind", ":", "return", "\"", "\"", "\n", "case", "design", ".", "UUIDKind", ":", "return", "\"", "\"", "\n", "case", "design", ".", "AnyKind", ":", "return", "\"", "\"", "\n", "case", "design", ".", "FileKind", ":", "return", "\"", "\"", "\n", "default", ":", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "actual", ")", ")", "\n", "}", "\n", "case", "*", "design", ".", "Array", ":", "return", "\"", "\"", "+", "GoNativeType", "(", "actual", ".", "ElemType", ".", "Type", ")", "\n", "case", "design", ".", "Object", ":", "return", "\"", "\"", "\n", "case", "*", "design", ".", "Hash", ":", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "GoNativeType", "(", "actual", ".", "KeyType", ".", "Type", ")", ",", "GoNativeType", "(", "actual", ".", "ElemType", ".", "Type", ")", ")", "\n", "case", "*", "design", ".", "MediaTypeDefinition", ":", "return", "GoNativeType", "(", "actual", ".", "Type", ")", "\n", "case", "*", "design", ".", "UserTypeDefinition", ":", "return", "GoNativeType", "(", "actual", ".", "Type", ")", "\n", "default", ":", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "actual", ")", ")", "\n", "}", "\n", "}" ]

[ "GoNativeType", "returns", "the", "Go", "built", "-", "in", "type", "from", "which", "instances", "of", "t", "can", "be", "initialized", "." ]

[ "func", "GoTypeDesc", "(", "t", "design", ".", "DataType", ",", "upper", "bool", ")", "string", "{", "switch", "actual", ":=", "t", ".", "(", "type", ")", "{", "case", "*", "design", ".", "UserTypeDefinition", ":", "if", "actual", ".", "Description", "!=", "\"", "\"", "{", "return", "strings", ".", "Replace", "(", "actual", ".", "Description", ",", "\"", "\\n", "\"", ",", "\"", "\\n", "\"", ",", "-", "1", ")", "\n", "}", "\n\n", "return", "Goify", "(", "actual", ".", "TypeName", ",", "upper", ")", "+", "\"", "\"", "\n", "case", "*", "design", ".", "MediaTypeDefinition", ":", "if", "actual", ".", "Description", "!=", "\"", "\"", "{", "return", "strings", ".", "Replace", "(", "actual", ".", "Description", ",", "\"", "\\n", "\"", ",", "\"", "\\n", "\"", ",", "-", "1", ")", "\n", "}", "\n", "name", ":=", "Goify", "(", "actual", ".", "TypeName", ",", "upper", ")", "\n", "if", "actual", ".", "View", "!=", "\"", "\"", "{", "name", "+=", "Goify", "(", "actual", ".", "View", ",", "true", ")", "\n", "}", "\n\n", "switch", "elem", ":=", "actual", ".", "UserTypeDefinition", ".", "AttributeDefinition", ".", "Type", ".", "(", "type", ")", "{", "case", "*", "design", ".", "Array", ":", "elemName", ":=", "GoTypeName", "(", "elem", ".", "ElemType", ".", "Type", ",", "nil", ",", "0", ",", "!", "upper", ")", "\n", "if", "actual", ".", "View", "!=", "\"", "\"", "{", "elemName", "+=", "Goify", "(", "actual", ".", "View", ",", "true", ")", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "name", ",", "elemName", ")", "\n", "default", ":", "return", "name", "+", "\"", "\"", "\n", "}", "\n", "default", ":", "return", "\"", "\"", "\n", "}", "\n", "}" ]

[ "GoTypeDesc", "returns", "the", "description", "of", "a", "type", ".", "If", "no", "description", "is", "defined", "for", "the", "type", "one", "will", "be", "generated", "." ]

[ "func", "removeTrailingInvalid", "(", "runes", "[", "]", "rune", ")", "[", "]", "rune", "{", "valid", ":=", "len", "(", "runes", ")", "-", "1", "\n", "for", ";", "valid", ">=", "0", "&&", "!", "validIdentifier", "(", "runes", "[", "valid", "]", ")", ";", "valid", "--", "{", "}", "\n\n", "return", "runes", "[", "0", ":", "valid", "+", "1", "]", "\n", "}" ]

[ "removeTrailingInvalid", "removes", "trailing", "invalid", "identifiers", "from", "runes", "." ]

[ "func", "removeInvalidAtIndex", "(", "i", "int", ",", "runes", "[", "]", "rune", ")", "[", "]", "rune", "{", "valid", ":=", "i", "\n", "for", ";", "valid", "<", "len", "(", "runes", ")", "&&", "!", "validIdentifier", "(", "runes", "[", "valid", "]", ")", ";", "valid", "++", "{", "}", "\n\n", "return", "append", "(", "runes", "[", ":", "i", "]", ",", "runes", "[", "valid", ":", "]", "...", ")", "\n", "}" ]

[ "removeInvalidAtIndex", "removes", "consecutive", "invalid", "identifiers", "from", "runes", "starting", "at", "index", "i", "." ]

[ "func", "Goify", "(", "str", "string", ",", "firstUpper", "bool", ")", "string", "{", "runes", ":=", "[", "]", "rune", "(", "str", ")", "\n\n", "// remove trailing invalid identifiers (makes code below simpler)", "runes", "=", "removeTrailingInvalid", "(", "runes", ")", "\n\n", "w", ",", "i", ":=", "0", ",", "0", "// index of start of word, scan", "\n", "for", "i", "+", "1", "<=", "len", "(", "runes", ")", "{", "eow", ":=", "false", "// whether we hit the end of a word", "\n\n", "// remove leading invalid identifiers", "runes", "=", "removeInvalidAtIndex", "(", "i", ",", "runes", ")", "\n\n", "if", "i", "+", "1", "==", "len", "(", "runes", ")", "{", "eow", "=", "true", "\n", "}", "else", "if", "!", "validIdentifier", "(", "runes", "[", "i", "]", ")", "{", "// get rid of it", "runes", "=", "append", "(", "runes", "[", ":", "i", "]", ",", "runes", "[", "i", "+", "1", ":", "]", "...", ")", "\n", "}", "else", "if", "runes", "[", "i", "+", "1", "]", "==", "'_'", "{", "// underscore; shift the remainder forward over any run of underscores", "eow", "=", "true", "\n", "n", ":=", "1", "\n", "for", "i", "+", "n", "+", "1", "<", "len", "(", "runes", ")", "&&", "runes", "[", "i", "+", "n", "+", "1", "]", "==", "'_'", "{", "n", "++", "\n", "}", "\n", "copy", "(", "runes", "[", "i", "+", "1", ":", "]", ",", "runes", "[", "i", "+", "n", "+", "1", ":", "]", ")", "\n", "runes", "=", "runes", "[", ":", "len", "(", "runes", ")", "-", "n", "]", "\n", "}", "else", "if", "unicode", ".", "IsLower", "(", "runes", "[", "i", "]", ")", "&&", "!", "unicode", ".", "IsLower", "(", "runes", "[", "i", "+", "1", "]", ")", "{", "// lower->non-lower", "eow", "=", "true", "\n", "}", "\n", "i", "++", "\n", "if", "!", "eow", "{", "continue", "\n", "}", "\n\n", "// [w,i] is a word.", "word", ":=", "string", "(", "runes", "[", "w", ":", "i", "]", ")", "\n", "// is it one of our initialisms?", "if", "u", ":=", "strings", ".", "ToUpper", "(", "word", ")", ";", "commonInitialisms", "[", "u", "]", "{", "if", "firstUpper", "{", "u", "=", "strings", ".", "ToUpper", "(", "u", ")", "\n", "}", "else", "if", "w", "==", "0", "{", "u", "=", "strings", ".", "ToLower", "(", "u", ")", "\n", "}", "\n\n", "// All the common initialisms are ASCII,", "// so we can replace the bytes exactly.", "copy", "(", "runes", "[", "w", ":", "]", ",", "[", "]", "rune", "(", "u", ")", ")", "\n", "}", "else", "if", "w", ">", "0", "&&", "strings", ".", "ToLower", "(", "word", ")", "==", "word", "{", "// already all lowercase, and not the first word, so uppercase the first character.", "runes", "[", "w", "]", "=", "unicode", ".", "ToUpper", "(", "runes", "[", "w", "]", ")", "\n", "}", "else", "if", "w", "==", "0", "&&", "strings", ".", "ToLower", "(", "word", ")", "==", "word", "&&", "firstUpper", "{", "runes", "[", "w", "]", "=", "unicode", ".", "ToUpper", "(", "runes", "[", "w", "]", ")", "\n", "}", "\n", "if", "w", "==", "0", "&&", "!", "firstUpper", "{", "runes", "[", "w", "]", "=", "unicode", ".", "ToLower", "(", "runes", "[", "w", "]", ")", "\n", "}", "\n", "//advance to next word", "w", "=", "i", "\n", "}", "\n\n", "return", "fixReserved", "(", "string", "(", "runes", ")", ")", "\n", "}" ]

[ "Goify", "makes", "a", "valid", "Go", "identifier", "out", "of", "any", "string", ".", "It", "does", "that", "by", "removing", "any", "non", "letter", "and", "non", "digit", "character", "and", "by", "making", "sure", "the", "first", "character", "is", "a", "letter", "or", "_", ".", "Goify", "produces", "a", "CamelCase", "version", "of", "the", "string", "if", "firstUpper", "is", "true", "the", "first", "character", "of", "the", "identifier", "is", "uppercase", "otherwise", "it", "s", "lowercase", "." ]

[ "func", "validIdentifier", "(", "r", "rune", ")", "bool", "{", "return", "unicode", ".", "IsLetter", "(", "r", ")", "||", "unicode", ".", "IsDigit", "(", "r", ")", "\n", "}" ]

[ "validIdentifier", "returns", "true", "if", "the", "rune", "is", "a", "letter", "or", "number" ]

[ "func", "GoTypeTransformName", "(", "source", ",", "target", "*", "design", ".", "UserTypeDefinition", ",", "suffix", "string", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "Goify", "(", "source", ".", "TypeName", ",", "true", ")", ",", "Goify", "(", "target", ".", "TypeName", ",", "true", ")", ",", "Goify", "(", "suffix", ",", "true", ")", ")", "\n", "}" ]

[ "GoTypeTransformName", "generates", "a", "valid", "Go", "identifer", "that", "is", "adequate", "for", "naming", "the", "type", "transform", "function", "that", "creates", "an", "instance", "of", "the", "data", "structure", "described", "by", "target", "from", "an", "instance", "of", "the", "data", "strucuture", "described", "by", "source", "." ]

[ "func", "WriteTabs", "(", "buf", "*", "bytes", ".", "Buffer", ",", "count", "int", ")", "{", "for", "i", ":=", "0", ";", "i", "<", "count", ";", "i", "++", "{", "buf", ".", "WriteByte", "(", "'\\t'", ")", "\n", "}", "\n", "}" ]

[ "WriteTabs", "is", "a", "helper", "function", "that", "writes", "count", "tabulation", "characters", "to", "buf", "." ]

[ "func", "RunTemplate", "(", "tmpl", "*", "template", ".", "Template", ",", "data", "interface", "{", "}", ")", "string", "{", "var", "b", "bytes", ".", "Buffer", "\n", "err", ":=", "tmpl", ".", "Execute", "(", "&", "b", ",", "data", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "// should never happen, bug if it does.", "\n", "}", "\n", "return", "b", ".", "String", "(", ")", "\n", "}" ]

[ "RunTemplate", "executs", "the", "given", "template", "with", "the", "given", "input", "and", "returns", "the", "rendered", "string", "." ]

[ "func", "toSlice", "(", "val", "[", "]", "interface", "{", "}", ")", "string", "{", "elems", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "val", ")", ")", "\n", "for", "i", ",", "v", ":=", "range", "val", "{", "elems", "[", "i", "]", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "v", ")", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "strings", ".", "Join", "(", "elems", ",", "\"", "\"", ")", ")", "\n", "}" ]

[ "toSlice", "returns", "Go", "code", "that", "represents", "the", "given", "slice", "." ]

[ "func", "typeName", "(", "att", "*", "design", ".", "AttributeDefinition", ")", "(", "name", "string", ")", "{", "if", "ut", ",", "ok", ":=", "att", ".", "Type", ".", "(", "*", "design", ".", "UserTypeDefinition", ")", ";", "ok", "{", "name", "=", "Goify", "(", "ut", ".", "TypeName", ",", "true", ")", "\n", "}", "else", "if", "mt", ",", "ok", ":=", "att", ".", "Type", ".", "(", "*", "design", ".", "MediaTypeDefinition", ")", ";", "ok", "{", "name", "=", "Goify", "(", "mt", ".", "TypeName", ",", "true", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "typeName", "returns", "the", "type", "name", "of", "the", "given", "attribute", "if", "it", "is", "a", "named", "type", "empty", "string", "otherwise", "." ]

[ "func", "NewID", "(", ")", "string", "{", "b", ":=", "make", "(", "[", "]", "byte", ",", "8", ")", "\n", "rand", ".", "Read", "(", "b", ")", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "b", ")", "\n", "}" ]

[ "NewID", "is", "a", "span", "ID", "creation", "algorithm", "which", "produces", "values", "that", "are", "compatible", "with", "AWS", "X", "-", "Ray", "." ]

[ "func", "NewTraceID", "(", ")", "string", "{", "b", ":=", "make", "(", "[", "]", "byte", ",", "12", ")", "\n", "rand", ".", "Read", "(", "b", ")", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "1", ",", "time", ".", "Now", "(", ")", ".", "Unix", "(", ")", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "b", ")", ")", "\n", "}" ]

[ "NewTraceID", "is", "a", "trace", "ID", "creation", "algorithm", "which", "produces", "values", "that", "are", "compatible", "with", "AWS", "X", "-", "Ray", "." ]

[ "func", "WithSegment", "(", "ctx", "context", ".", "Context", ",", "s", "*", "Segment", ")", "context", ".", "Context", "{", "return", "context", ".", "WithValue", "(", "ctx", ",", "segKey", ",", "s", ")", "\n", "}" ]

[ "WithSegment", "creates", "a", "context", "containing", "the", "given", "segment", ".", "Use", "ContextSegment", "to", "retrieve", "it", "." ]

[ "func", "ContextSegment", "(", "ctx", "context", ".", "Context", ")", "*", "Segment", "{", "if", "s", ":=", "ctx", ".", "Value", "(", "segKey", ")", ";", "s", "!=", "nil", "{", "return", "s", ".", "(", "*", "Segment", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "ContextSegment", "extracts", "the", "segment", "set", "in", "the", "context", "with", "WithSegment", "." ]

[ "func", "newSegment", "(", "ctx", "context", ".", "Context", ",", "traceID", ",", "name", "string", ",", "req", "*", "http", ".", "Request", ",", "c", "net", ".", "Conn", ")", "*", "Segment", "{", "var", "(", "spanID", "=", "middleware", ".", "ContextSpanID", "(", "ctx", ")", "\n", "parentID", "=", "middleware", ".", "ContextParentSpanID", "(", "ctx", ")", "\n", ")", "\n\n", "s", ":=", "NewSegment", "(", "name", ",", "traceID", ",", "spanID", ",", "c", ")", "\n", "s", ".", "RecordRequest", "(", "req", ",", "\"", "\"", ")", "\n\n", "if", "parentID", "!=", "\"", "\"", "{", "s", ".", "ParentID", "=", "parentID", "\n", "}", "\n\n", "return", "s", "\n", "}" ]

[ "newSegment", "creates", "a", "new", "segment", "for", "the", "incoming", "request", "." ]

[ "func", "periodicallyRedialingConn", "(", "ctx", "context", ".", "Context", ",", "renewPeriod", "time", ".", "Duration", ",", "dial", "func", "(", ")", "(", "net", ".", "Conn", ",", "error", ")", ")", "(", "func", "(", ")", "net", ".", "Conn", ",", "error", ")", "{", "var", "(", "err", "error", "\n\n", "// guard access to c", "mu", "sync", ".", "RWMutex", "\n", "c", "net", ".", "Conn", "\n", ")", "\n\n", "// get an initial connection", "if", "c", ",", "err", "=", "dial", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// periodically re-dial", "go", "func", "(", ")", "{", "ticker", ":=", "time", ".", "NewTicker", "(", "renewPeriod", ")", "\n", "for", "{", "select", "{", "case", "<-", "ticker", ".", "C", ":", "newConn", ",", "err", ":=", "dial", "(", ")", "\n", "if", "err", "!=", "nil", "{", "continue", "// we don't have anything better to replace `c` with", "\n", "}", "\n", "mu", ".", "Lock", "(", ")", "\n", "c", "=", "newConn", "\n", "mu", ".", "Unlock", "(", ")", "\n", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "\n", "}", "\n", "}", "\n", "}", "(", ")", "\n\n", "return", "func", "(", ")", "net", ".", "Conn", "{", "mu", ".", "RLock", "(", ")", "\n", "defer", "mu", ".", "RUnlock", "(", ")", "\n", "return", "c", "\n", "}", ",", "nil", "\n", "}" ]

[ "periodicallyRedialingConn", "creates", "a", "goroutine", "to", "periodically", "re", "-", "dial", "a", "connection", "so", "the", "hostname", "can", "be", "re", "-", "resolved", "if", "the", "IP", "changes", ".", "Returns", "a", "func", "that", "provides", "the", "latest", "Conn", "value", "." ]

[ "func", "buildView", "(", "name", "string", ",", "mt", "*", "design", ".", "MediaTypeDefinition", ",", "at", "*", "design", ".", "AttributeDefinition", ")", "(", "*", "design", ".", "ViewDefinition", ",", "error", ")", "{", "if", "at", ".", "Type", "==", "nil", "||", "!", "at", ".", "Type", ".", "IsObject", "(", ")", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "o", ":=", "at", ".", "Type", ".", "ToObject", "(", ")", "\n", "if", "o", "!=", "nil", "{", "mto", ":=", "mt", ".", "Type", ".", "ToObject", "(", ")", "\n", "if", "mto", "==", "nil", "{", "mto", "=", "mt", ".", "Type", ".", "ToArray", "(", ")", ".", "ElemType", ".", "Type", ".", "ToObject", "(", ")", "\n", "}", "\n", "for", "n", ",", "cat", ":=", "range", "o", "{", "if", "existing", ",", "ok", ":=", "mto", "[", "n", "]", ";", "ok", "{", "dup", ":=", "design", ".", "DupAtt", "(", "existing", ")", "\n", "dup", ".", "View", "=", "cat", ".", "View", "\n", "o", "[", "n", "]", "=", "dup", "\n", "}", "else", "if", "n", "!=", "\"", "\"", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "n", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "&", "design", ".", "ViewDefinition", "{", "AttributeDefinition", ":", "at", ",", "Name", ":", "name", ",", "Parent", ":", "mt", ",", "}", ",", "nil", "\n", "}" ]

[ "buildView", "builds", "a", "view", "definition", "given", "an", "attribute", "and", "a", "corresponding", "media", "type", "." ]

[ "func", "ContextRequiredScopes", "(", "ctx", "context", ".", "Context", ")", "[", "]", "string", "{", "if", "s", ":=", "ctx", ".", "Value", "(", "securityScopesKey", ")", ";", "s", "!=", "nil", "{", "return", "s", ".", "(", "[", "]", "string", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "ContextRequiredScopes", "extracts", "the", "security", "scopes", "from", "the", "given", "context", ".", "This", "should", "be", "used", "in", "auth", "handlers", "to", "validate", "that", "the", "required", "scopes", "are", "present", "in", "the", "JWT", "or", "OAuth2", "token", "." ]

[ "func", "WithRequiredScopes", "(", "ctx", "context", ".", "Context", ",", "scopes", "[", "]", "string", ")", "context", ".", "Context", "{", "return", "context", ".", "WithValue", "(", "ctx", ",", "securityScopesKey", ",", "scopes", ")", "\n", "}" ]

[ "WithRequiredScopes", "builds", "a", "context", "containing", "the", "given", "required", "scopes", "." ]

[ "func", "GET", "(", "path", "string", ",", "dsl", "...", "func", "(", ")", ")", "*", "design", ".", "RouteDefinition", "{", "route", ":=", "&", "design", ".", "RouteDefinition", "{", "Verb", ":", "\"", "\"", ",", "Path", ":", "path", "}", "\n", "if", "len", "(", "dsl", ")", "!=", "0", "{", "if", "!", "dslengine", ".", "Execute", "(", "dsl", "[", "0", "]", ",", "route", ")", "{", "return", "nil", "\n", "}", "\n", "}", "\n", "return", "route", "\n", "}" ]

[ "GET", "is", "used", "as", "an", "argument", "to", "Routing", "GET", "creates", "a", "route", "using", "the", "GET", "HTTP", "method", "." ]

[ "func", "newAttribute", "(", "baseMT", "string", ")", "*", "design", ".", "AttributeDefinition", "{", "var", "base", "design", ".", "DataType", "\n", "if", "mt", ":=", "design", ".", "Design", ".", "MediaTypeWithIdentifier", "(", "baseMT", ")", ";", "mt", "!=", "nil", "{", "base", "=", "mt", ".", "Type", "\n", "}", "\n", "return", "&", "design", ".", "AttributeDefinition", "{", "Reference", ":", "base", "}", "\n", "}" ]

[ "newAttribute", "creates", "a", "new", "attribute", "definition", "using", "the", "media", "type", "with", "the", "given", "identifier", "as", "base", "type", "." ]

[ "func", "WSWrite", "(", "ws", "*", "websocket", ".", "Conn", ")", "{", "scanner", ":=", "bufio", ".", "NewScanner", "(", "os", ".", "Stdin", ")", "\n", "for", "scanner", ".", "Scan", "(", ")", "{", "t", ":=", "scanner", ".", "Text", "(", ")", "\n", "ws", ".", "Write", "(", "[", "]", "byte", "(", "t", ")", ")", "\n", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "t", ")", "\n", "}", "\n", "}" ]

[ "WSWrite", "sends", "STDIN", "lines", "to", "a", "websocket", "server", "." ]

[ "func", "WSRead", "(", "ws", "*", "websocket", ".", "Conn", ")", "{", "msg", ":=", "make", "(", "[", "]", "byte", ",", "512", ")", "\n", "for", "{", "n", ",", "err", ":=", "ws", ".", "Read", "(", "msg", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Fatal", "(", "err", ")", "\n", "}", "\n", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "msg", "[", ":", "n", "]", ")", "\n", "}", "\n", "}" ]

[ "WSRead", "reads", "from", "a", "websocket", "and", "print", "the", "read", "messages", "to", "STDOUT", "." ]

[ "func", "NewGenerator", "(", "genfunc", "string", ",", "imports", "[", "]", "*", "codegen", ".", "ImportSpec", ",", "flags", "map", "[", "string", "]", "string", ",", "customflags", "[", "]", "string", ")", "(", "*", "Generator", ",", "error", ")", "{", "var", "(", "outDir", ",", "designPkgPath", "string", "\n", "debug", "bool", "\n", ")", "\n\n", "if", "o", ",", "ok", ":=", "flags", "[", "\"", "\"", "]", ";", "ok", "{", "outDir", "=", "o", "\n", "}", "\n", "if", "d", ",", "ok", ":=", "flags", "[", "\"", "\"", "]", ";", "ok", "{", "designPkgPath", "=", "d", "\n", "}", "\n", "if", "d", ",", "ok", ":=", "flags", "[", "\"", "\"", "]", ";", "ok", "{", "var", "err", "error", "\n", "debug", ",", "err", "=", "strconv", ".", "ParseBool", "(", "d", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n\n", "return", "&", "Generator", "{", "Genfunc", ":", "genfunc", ",", "Imports", ":", "imports", ",", "Flags", ":", "flags", ",", "CustomFlags", ":", "customflags", ",", "OutDir", ":", "outDir", ",", "DesignPkgPath", ":", "designPkgPath", ",", "debug", ":", "debug", ",", "}", ",", "nil", "\n", "}" ]

[ "NewGenerator", "returns", "a", "meta", "generator", "that", "can", "run", "an", "actual", "Generator", "given", "its", "factory", "method", "and", "command", "line", "flags", "." ]

[ "func", "(", "m", "*", "Generator", ")", "Generate", "(", ")", "(", "[", "]", "string", ",", "error", ")", "{", "// Sanity checks", "if", "m", ".", "OutDir", "==", "\"", "\"", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "m", ".", "DesignPkgPath", "==", "\"", "\"", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Create output directory", "if", "err", ":=", "os", ".", "MkdirAll", "(", "m", ".", "OutDir", ",", "0755", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Create temporary workspace used for generation", "wd", ",", "err", ":=", "os", ".", "Getwd", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "tmpDir", ",", "err", ":=", "ioutil", ".", "TempDir", "(", "wd", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "if", "_", ",", "ok", ":=", "err", ".", "(", "*", "os", ".", "PathError", ")", ";", "ok", "{", "err", "=", "fmt", ".", "Errorf", "(", "`invalid output directory path \"%s\"`", ",", "m", ".", "OutDir", ")", "\n", "}", "\n", "return", "nil", ",", "err", "\n", "}", "\n", "defer", "func", "(", ")", "{", "if", "!", "m", ".", "debug", "{", "os", ".", "RemoveAll", "(", "tmpDir", ")", "\n", "}", "\n", "}", "(", ")", "\n", "if", "m", ".", "debug", "{", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "tmpDir", ")", "\n", "}", "\n\n", "pkgSourcePath", ",", "err", ":=", "codegen", ".", "PackageSourcePath", "(", "m", ".", "DesignPkgPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "pkgName", ",", "err", ":=", "codegen", ".", "PackageName", "(", "pkgSourcePath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Generate tool source code.", "pkgPath", ":=", "filepath", ".", "Join", "(", "tmpDir", ",", "pkgName", ")", "\n", "p", ",", "err", ":=", "codegen", ".", "PackageFor", "(", "pkgPath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "m", ".", "generateToolSourceCode", "(", "p", ")", "\n\n", "// Compile and run generated tool.", "if", "m", ".", "debug", "{", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", ",", "strings", ".", "Join", "(", "os", ".", "Environ", "(", ")", ",", "\"", "\\n", "\"", ")", ")", "\n", "}", "\n", "genbin", ",", "err", ":=", "p", ".", "Compile", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "m", ".", "spawn", "(", "genbin", ")", "\n", "}" ]

[ "Generate", "compiles", "and", "runs", "the", "generator", "and", "returns", "the", "generated", "filenames", "." ]

[ "func", "(", "m", "*", "Generator", ")", "spawn", "(", "genbin", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "var", "args", "[", "]", "string", "\n", "for", "k", ",", "v", ":=", "range", "m", ".", "Flags", "{", "if", "k", "==", "\"", "\"", "{", "continue", "\n", "}", "\n", "args", "=", "append", "(", "args", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "k", ",", "v", ")", ")", "\n", "}", "\n", "sort", ".", "Strings", "(", "args", ")", "\n", "args", "=", "append", "(", "args", ",", "\"", "\"", "+", "version", ".", "String", "(", ")", ")", "\n", "args", "=", "append", "(", "args", ",", "m", ".", "CustomFlags", "...", ")", "\n", "cmd", ":=", "exec", ".", "Command", "(", "genbin", ",", "args", "...", ")", "\n", "out", ",", "err", ":=", "cmd", ".", "CombinedOutput", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\\n", "\"", ",", "err", ",", "string", "(", "out", ")", ")", "\n", "}", "\n", "res", ":=", "strings", ".", "Split", "(", "string", "(", "out", ")", ",", "\"", "\\n", "\"", ")", "\n", "for", "(", "len", "(", "res", ")", ">", "0", ")", "&&", "(", "res", "[", "len", "(", "res", ")", "-", "1", "]", "==", "\"", "\"", ")", "{", "res", "=", "res", "[", ":", "len", "(", "res", ")", "-", "1", "]", "\n", "}", "\n", "return", "res", ",", "nil", "\n", "}" ]

[ "spawn", "runs", "the", "compiled", "generator", "using", "the", "arguments", "initialized", "by", "Kingpin", "when", "parsing", "the", "command", "line", "." ]

[ "func", "init", "(", ")", "{", "// algorithm taken from https://github.com/zenazn/goji/blob/master/web/middleware/request_id.go#L44-L50", "var", "buf", "[", "12", "]", "byte", "\n", "var", "b64", "string", "\n", "for", "len", "(", "b64", ")", "<", "10", "{", "rand", ".", "Read", "(", "buf", "[", ":", "]", ")", "\n", "b64", "=", "base64", ".", "StdEncoding", ".", "EncodeToString", "(", "buf", "[", ":", "]", ")", "\n", "b64", "=", "strings", ".", "NewReplacer", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", ".", "Replace", "(", "b64", ")", "\n", "}", "\n", "reqPrefix", "=", "string", "(", "b64", "[", "0", ":", "10", "]", ")", "\n", "}" ]

[ "Initialize", "common", "prefix", "on", "process", "startup", "." ]

[ "func", "Logger", "(", "ctx", "context", ".", "Context", ")", "log15", ".", "Logger", "{", "logger", ":=", "goa", ".", "ContextLogger", "(", "ctx", ")", "\n", "if", "a", ",", "ok", ":=", "logger", ".", "(", "*", "adapter", ")", ";", "ok", "{", "return", "a", ".", "Logger", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Logger", "returns", "the", "log15", "logger", "stored", "in", "the", "given", "context", "if", "any", "nil", "otherwise", "." ]

[ "func", "(", "a", "*", "adapter", ")", "Info", "(", "msg", "string", ",", "data", "...", "interface", "{", "}", ")", "{", "a", ".", "Logger", ".", "Info", "(", "msg", ",", "data", "...", ")", "\n", "}" ]

[ "Info", "logs", "informational", "messages", "using", "log15", "." ]

[ "func", "(", "a", "*", "adapter", ")", "Error", "(", "msg", "string", ",", "data", "...", "interface", "{", "}", ")", "{", "a", ".", "Logger", ".", "Error", "(", "msg", ",", "data", "...", ")", "\n", "}" ]

[ "Error", "logs", "error", "messages", "using", "log15", "." ]

[ "func", "(", "r", "*", "routeInfo", ")", "DifferentWildcards", "(", "other", "*", "routeInfo", ")", "(", "res", "[", "]", "[", "2", "]", "*", "wildCardInfo", ")", "{", "for", "i", ",", "wc", ":=", "range", "other", ".", "Wildcards", "{", "if", "r", ".", "Wildcards", "[", "i", "]", ".", "Name", "!=", "wc", ".", "Name", "{", "res", "=", "append", "(", "res", ",", "[", "2", "]", "*", "wildCardInfo", "{", "r", ".", "Wildcards", "[", "i", "]", ",", "wc", "}", ")", "\n", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "DifferentWildcards", "returns", "the", "list", "of", "wildcards", "in", "other", "that", "have", "a", "different", "name", "from", "the", "wildcard", "in", "target", "at", "the", "same", "position", "." ]

[ "func", "(", "cors", "*", "CORSDefinition", ")", "Validate", "(", ")", "*", "dslengine", ".", "ValidationErrors", "{", "verr", ":=", "new", "(", "dslengine", ".", "ValidationErrors", ")", "\n", "if", "!", "cors", ".", "Regexp", "&&", "strings", ".", "Count", "(", "cors", ".", "Origin", ",", "\"", "\"", ")", ">", "1", "{", "verr", ".", "Add", "(", "cors", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "cors", ".", "Regexp", "{", "_", ",", "err", ":=", "regexp", ".", "Compile", "(", "cors", ".", "Origin", ")", "\n", "if", "err", "!=", "nil", "{", "verr", ".", "Add", "(", "cors", ",", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "return", "verr", "\n", "}" ]

[ "Validate", "makes", "sure", "the", "CORS", "definition", "origin", "is", "valid", "." ]

[ "func", "(", "enc", "*", "EncodingDefinition", ")", "Validate", "(", ")", "*", "dslengine", ".", "ValidationErrors", "{", "verr", ":=", "new", "(", "dslengine", ".", "ValidationErrors", ")", "\n", "if", "len", "(", "enc", ".", "MIMETypes", ")", "==", "0", "{", "verr", ".", "Add", "(", "enc", ",", "\"", "\"", ")", "\n", "return", "verr", "\n", "}", "\n", "for", "_", ",", "m", ":=", "range", "enc", ".", "MIMETypes", "{", "_", ",", "_", ",", "err", ":=", "mime", ".", "ParseMediaType", "(", "m", ")", "\n", "if", "err", "!=", "nil", "{", "verr", ".", "Add", "(", "enc", ",", "\"", "\"", ",", "m", ",", "err", ")", "\n", "}", "\n", "}", "\n", "if", "len", "(", "enc", ".", "PackagePath", ")", ">", "0", "{", "rel", ":=", "filepath", ".", "FromSlash", "(", "enc", ".", "PackagePath", ")", "\n", "dir", ",", "err", ":=", "os", ".", "Getwd", "(", ")", "\n", "if", "err", "!=", "nil", "{", "verr", ".", "Add", "(", "enc", ",", "\"", "\"", ",", "err", ")", "\n", "return", "verr", "\n", "}", "\n", "_", ",", "err", "=", "build", ".", "Default", ".", "Import", "(", "rel", ",", "dir", ",", "build", ".", "FindOnly", ")", "\n", "if", "err", "!=", "nil", "{", "verr", ".", "Add", "(", "enc", ",", "\"", "\"", ",", "enc", ".", "PackagePath", ",", "err", ")", "\n", "return", "verr", "\n", "}", "\n", "}", "else", "{", "for", "_", ",", "m", ":=", "range", "enc", ".", "MIMETypes", "{", "if", "_", ",", "ok", ":=", "KnownEncoders", "[", "m", "]", ";", "!", "ok", "{", "knownMIMETypes", ":=", "make", "(", "[", "]", "string", ",", "len", "(", "KnownEncoders", ")", ")", "\n", "i", ":=", "0", "\n", "for", "k", ":=", "range", "KnownEncoders", "{", "knownMIMETypes", "[", "i", "]", "=", "k", "\n", "i", "++", "\n", "}", "\n", "sort", ".", "Strings", "(", "knownMIMETypes", ")", "\n", "verr", ".", "Add", "(", "enc", ",", "\"", "\"", ",", "strings", ".", "Join", "(", "knownMIMETypes", ",", "\"", "\"", ")", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "if", "enc", ".", "Function", "!=", "\"", "\"", "&&", "enc", ".", "PackagePath", "==", "\"", "\"", "{", "verr", ".", "Add", "(", "enc", ",", "\"", "\"", ")", "\n", "}", "\n", "return", "verr", "\n", "}" ]

[ "Validate", "validates", "the", "encoding", "MIME", "type", "and", "Go", "package", "path", "if", "set", "." ]

[ "func", "(", "f", "*", "FileServerDefinition", ")", "Validate", "(", ")", "*", "dslengine", ".", "ValidationErrors", "{", "verr", ":=", "new", "(", "dslengine", ".", "ValidationErrors", ")", "\n", "if", "f", ".", "FilePath", "==", "\"", "\"", "{", "verr", ".", "Add", "(", "f", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "f", ".", "RequestPath", "==", "\"", "\"", "{", "verr", ".", "Add", "(", "f", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "f", ".", "Parent", "==", "nil", "{", "verr", ".", "Add", "(", "f", ",", "\"", "\"", ")", "\n", "}", "\n", "matches", ":=", "WildcardRegex", ".", "FindAllString", "(", "f", ".", "RequestPath", ",", "-", "1", ")", "\n", "if", "len", "(", "matches", ")", "==", "1", "{", "if", "!", "strings", ".", "HasSuffix", "(", "f", ".", "RequestPath", ",", "matches", "[", "0", "]", ")", "{", "verr", ".", "Add", "(", "f", ",", "\"", "\"", ",", "f", ".", "RequestPath", ")", "\n", "}", "\n", "}", "\n", "if", "len", "(", "matches", ")", ">", "2", "{", "verr", ".", "Add", "(", "f", ",", "\"", "\"", ")", "\n", "}", "\n\n", "return", "verr", ".", "AsError", "(", ")", "\n", "}" ]

[ "Validate", "checks", "the", "file", "server", "is", "properly", "initialized", "." ]

[ "func", "LogInfo", "(", "ctx", "context", ".", "Context", ",", "msg", "string", ",", "keyvals", "...", "interface", "{", "}", ")", "{", "if", "l", ":=", "ctx", ".", "Value", "(", "logKey", ")", ";", "l", "!=", "nil", "{", "if", "logger", ",", "ok", ":=", "l", ".", "(", "LogAdapter", ")", ";", "ok", "{", "logger", ".", "Info", "(", "msg", ",", "keyvals", "...", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "LogInfo", "extracts", "the", "logger", "from", "the", "given", "context", "and", "calls", "Info", "on", "it", ".", "This", "is", "intended", "for", "code", "that", "needs", "portable", "logging", "such", "as", "the", "internal", "code", "of", "goa", "and", "middleware", ".", "User", "code", "should", "use", "the", "log", "adapters", "instead", "." ]

[ "func", "LogError", "(", "ctx", "context", ".", "Context", ",", "msg", "string", ",", "keyvals", "...", "interface", "{", "}", ")", "{", "if", "l", ":=", "ctx", ".", "Value", "(", "logKey", ")", ";", "l", "!=", "nil", "{", "if", "logger", ",", "ok", ":=", "l", ".", "(", "LogAdapter", ")", ";", "ok", "{", "logger", ".", "Error", "(", "msg", ",", "keyvals", "...", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "LogError", "extracts", "the", "logger", "from", "the", "given", "context", "and", "calls", "Error", "on", "it", ".", "This", "is", "intended", "for", "code", "that", "needs", "portable", "logging", "such", "as", "the", "internal", "code", "of", "goa", "and", "middleware", ".", "User", "code", "should", "use", "the", "log", "adapters", "instead", "." ]

[ "func", "(", "lrw", "*", "loggingResponseWriter", ")", "Write", "(", "buf", "[", "]", "byte", ")", "(", "int", ",", "error", ")", "{", "goa", ".", "LogInfo", "(", "lrw", ".", "ctx", ",", "\"", "\"", ",", "\"", "\"", ",", "string", "(", "buf", ")", ")", "\n", "return", "lrw", ".", "ResponseWriter", ".", "Write", "(", "buf", ")", "\n", "}" ]

[ "Write", "will", "write", "raw", "data", "to", "logger", "and", "response", "writer", "." ]

[ "func", "LogResponse", "(", ")", "goa", ".", "Middleware", "{", "return", "func", "(", "h", "goa", ".", "Handler", ")", "goa", ".", "Handler", "{", "return", "func", "(", "ctx", "context", ".", "Context", ",", "rw", "http", ".", "ResponseWriter", ",", "req", "*", "http", ".", "Request", ")", "error", "{", "// chain a new logging writer to the current response writer.", "resp", ":=", "goa", ".", "ContextResponse", "(", "ctx", ")", "\n", "resp", ".", "SwitchWriter", "(", "&", "loggingResponseWriter", "{", "ResponseWriter", ":", "resp", ".", "SwitchWriter", "(", "nil", ")", ",", "ctx", ":", "ctx", ",", "}", ")", "\n\n", "// next", "return", "h", "(", "ctx", ",", "rw", ",", "req", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "LogResponse", "creates", "a", "response", "logger", "middleware", ".", "Only", "Logs", "the", "raw", "response", "data", "without", "accumulating", "any", "statistics", "." ]

[ "func", "init", "(", ")", "{", "design", ".", "Design", "=", "design", ".", "NewAPIDefinition", "(", ")", "\n", "design", ".", "GeneratedMediaTypes", "=", "make", "(", "design", ".", "MediaTypeRoot", ")", "\n", "design", ".", "ProjectedMediaTypes", "=", "make", "(", "design", ".", "MediaTypeRoot", ")", "\n", "dslengine", ".", "Register", "(", "design", ".", "Design", ")", "\n", "dslengine", ".", "Register", "(", "design", ".", "GeneratedMediaTypes", ")", "\n", "}" ]

[ "Setup", "API", "DSL", "roots", "." ]

[ "func", "NewDecoder", "(", "r", "io", ".", "Reader", ")", "goa", ".", "Decoder", "{", "return", "&", "ProtoDecoder", "{", "pBuf", ":", "proto", ".", "NewBuffer", "(", "nil", ")", ",", "bBuf", ":", "&", "bytes", ".", "Buffer", "{", "}", ",", "r", ":", "r", ",", "}", "\n", "}" ]

[ "NewDecoder", "returns", "a", "new", "proto", ".", "Decoder", "that", "satisfies", "goa", ".", "Decoder" ]

[ "func", "(", "dec", "*", "ProtoDecoder", ")", "Decode", "(", "v", "interface", "{", "}", ")", "error", "{", "msg", ",", "ok", ":=", "v", ".", "(", "proto", ".", "Message", ")", "\n", "if", "!", "ok", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "var", "err", "error", "\n\n", "// derekperkins TODO: pipe reader directly to proto.Buffer", "if", "_", ",", "err", "=", "dec", ".", "bBuf", ".", "ReadFrom", "(", "dec", ".", "r", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "dec", ".", "pBuf", ".", "SetBuf", "(", "dec", ".", "bBuf", ".", "Bytes", "(", ")", ")", "\n\n", "return", "dec", ".", "pBuf", ".", "Unmarshal", "(", "msg", ")", "\n", "}" ]

[ "Decode", "unmarshals", "an", "io", ".", "Reader", "into", "proto", ".", "Message", "v" ]

[ "func", "(", "dec", "*", "ProtoDecoder", ")", "Reset", "(", "r", "io", ".", "Reader", ")", "{", "dec", ".", "pBuf", ".", "Reset", "(", ")", "\n", "dec", ".", "bBuf", ".", "Reset", "(", ")", "\n", "dec", ".", "r", "=", "r", "\n", "}" ]

[ "Reset", "stores", "the", "new", "reader", "and", "resets", "its", "bytes", ".", "Buffer", "and", "proto", ".", "Buffer" ]

[ "func", "NewEncoder", "(", "w", "io", ".", "Writer", ")", "goa", ".", "Encoder", "{", "return", "&", "ProtoEncoder", "{", "pBuf", ":", "proto", ".", "NewBuffer", "(", "nil", ")", ",", "w", ":", "w", ",", "}", "\n", "}" ]

[ "NewEncoder", "returns", "a", "new", "proto", ".", "Encoder", "that", "satisfies", "goa", ".", "Encoder" ]

[ "func", "(", "enc", "*", "ProtoEncoder", ")", "Encode", "(", "v", "interface", "{", "}", ")", "error", "{", "msg", ",", "ok", ":=", "v", ".", "(", "proto", ".", "Message", ")", "\n", "if", "!", "ok", "{", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "var", "err", "error", "\n\n", "// derekperkins TODO: pipe marshal directly to writer", "if", "err", "=", "enc", ".", "pBuf", ".", "Marshal", "(", "msg", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "_", ",", "err", "=", "enc", ".", "w", ".", "Write", "(", "enc", ".", "pBuf", ".", "Bytes", "(", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Encode", "marshals", "a", "proto", ".", "Message", "and", "writes", "it", "to", "an", "io", ".", "Writer" ]

[ "func", "(", "enc", "*", "ProtoEncoder", ")", "Reset", "(", "w", "io", ".", "Writer", ")", "{", "enc", ".", "pBuf", ".", "Reset", "(", ")", "\n", "enc", ".", "w", "=", "w", "\n", "}" ]

[ "Reset", "stores", "the", "new", "writer", "and", "resets", "its", "proto", ".", "Buffer" ]

[ "func", "NewFinalizer", "(", ")", "*", "Finalizer", "{", "var", "(", "f", "=", "&", "Finalizer", "{", "seen", ":", "make", "(", "map", "[", "*", "design", ".", "AttributeDefinition", "]", "map", "[", "*", "design", ".", "AttributeDefinition", "]", "*", "bytes", ".", "Buffer", ")", "}", "\n", "err", "error", "\n", ")", "\n", "fm", ":=", "template", ".", "FuncMap", "{", "\"", "\"", ":", "Tabs", ",", "\"", "\"", ":", "Goify", ",", "\"", "\"", ":", "GoTypeRef", ",", "\"", "\"", ":", "Add", ",", "\"", "\"", ":", "f", ".", "Code", ",", "}", "\n", "f", ".", "assignmentT", ",", "err", "=", "template", ".", "New", "(", "\"", "\"", ")", ".", "Funcs", "(", "fm", ")", ".", "Parse", "(", "assignmentTmpl", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "f", ".", "arrayAssignmentT", ",", "err", "=", "template", ".", "New", "(", "\"", "\"", ")", ".", "Funcs", "(", "fm", ")", ".", "Parse", "(", "arrayAssignmentTmpl", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n", "return", "f", "\n", "}" ]

[ "NewFinalizer", "instantiates", "a", "finalize", "code", "generator", "." ]

[ "func", "(", "f", "*", "Finalizer", ")", "Code", "(", "att", "*", "design", ".", "AttributeDefinition", ",", "target", "string", ",", "depth", "int", ")", "string", "{", "buf", ":=", "f", ".", "recurse", "(", "att", ",", "att", ",", "target", ",", "depth", ")", "\n", "return", "buf", ".", "String", "(", ")", "\n", "}" ]

[ "Code", "produces", "Go", "code", "that", "sets", "the", "default", "values", "for", "fields", "recursively", "for", "the", "given", "attribute", "." ]

[ "func", "PrintVal", "(", "t", "design", ".", "DataType", ",", "val", "interface", "{", "}", ")", "string", "{", "switch", "{", "case", "t", ".", "IsPrimitive", "(", ")", ":", "// For primitive types, simply print the value", "s", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "val", ")", "\n", "switch", "t", "{", "case", "design", ".", "Number", ":", "v", ":=", "val", "\n", "if", "i", ",", "ok", ":=", "val", ".", "(", "int", ")", ";", "ok", "{", "v", "=", "float64", "(", "i", ")", "\n", "}", "\n", "s", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "v", ")", "\n", "case", "design", ".", "DateTime", ":", "s", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "s", ")", "\n", "}", "\n", "return", "s", "\n", "case", "t", ".", "IsHash", "(", ")", ":", "// The input is a hash", "h", ":=", "t", ".", "ToHash", "(", ")", "\n", "hval", ":=", "val", ".", "(", "map", "[", "interface", "{", "}", "]", "interface", "{", "}", ")", "\n", "if", "len", "(", "hval", ")", "==", "0", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "GoTypeName", "(", "t", ",", "nil", ",", "0", ",", "false", ")", ")", "\n", "}", "\n", "var", "buffer", "bytes", ".", "Buffer", "\n", "buffer", ".", "WriteString", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "GoTypeName", "(", "t", ",", "nil", ",", "0", ",", "false", ")", ")", ")", "\n", "for", "k", ",", "v", ":=", "range", "hval", "{", "buffer", ".", "WriteString", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "PrintVal", "(", "h", ".", "KeyType", ".", "Type", ",", "k", ")", ",", "PrintVal", "(", "h", ".", "ElemType", ".", "Type", ",", "v", ")", ")", ")", "\n", "}", "\n", "buffer", ".", "Truncate", "(", "buffer", ".", "Len", "(", ")", "-", "2", ")", "// remove \", \"", "\n", "buffer", ".", "WriteString", "(", "\"", "\"", ")", "\n", "return", "buffer", ".", "String", "(", ")", "\n", "case", "t", ".", "IsArray", "(", ")", ":", "// Input is an array", "a", ":=", "t", ".", "ToArray", "(", ")", "\n", "aval", ":=", "val", ".", "(", "[", "]", "interface", "{", "}", ")", "\n", "if", "len", "(", "aval", ")", "==", "0", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "GoTypeName", "(", "t", ",", "nil", ",", "0", ",", "false", ")", ")", "\n", "}", "\n", "var", "buffer", "bytes", ".", "Buffer", "\n", "buffer", ".", "WriteString", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "GoTypeName", "(", "t", ",", "nil", ",", "0", ",", "false", ")", ")", ")", "\n", "for", "_", ",", "e", ":=", "range", "aval", "{", "buffer", ".", "WriteString", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "PrintVal", "(", "a", ".", "ElemType", ".", "Type", ",", "e", ")", ")", ")", "\n", "}", "\n", "buffer", ".", "Truncate", "(", "buffer", ".", "Len", "(", ")", "-", "2", ")", "// remove \", \"", "\n", "buffer", ".", "WriteString", "(", "\"", "\"", ")", "\n", "return", "buffer", ".", "String", "(", ")", "\n", "default", ":", "// shouldn't happen as the value's compatibility is already checked.", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "PrintVal", "prints", "the", "given", "value", "corresponding", "to", "the", "given", "data", "type", ".", "The", "value", "is", "already", "checked", "for", "the", "compatibility", "with", "the", "data", "type", "." ]

[ "func", "(", "a", "*", "adapter", ")", "Info", "(", "msg", "string", ",", "data", "...", "interface", "{", "}", ")", "{", "ctx", ":=", "[", "]", "interface", "{", "}", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "msg", "}", "\n", "ctx", "=", "append", "(", "ctx", ",", "data", "...", ")", "\n", "a", ".", "Logger", ".", "Log", "(", "ctx", "...", ")", "\n", "}" ]

[ "Info", "logs", "informational", "messages", "using", "go", "-", "kit", "." ]

[ "func", "(", "a", "*", "adapter", ")", "New", "(", "data", "...", "interface", "{", "}", ")", "goa", ".", "LogAdapter", "{", "return", "&", "adapter", "{", "Logger", ":", "log", ".", "With", "(", "a", ".", "Logger", ",", "data", "...", ")", "}", "\n", "}" ]

[ "New", "instantiates", "a", "new", "logger", "from", "the", "given", "context", "." ]

[ "func", "encodingDefinition", "(", ")", "(", "*", "design", ".", "EncodingDefinition", ",", "bool", ")", "{", "e", ",", "ok", ":=", "dslengine", ".", "CurrentDefinition", "(", ")", ".", "(", "*", "design", ".", "EncodingDefinition", ")", "\n", "if", "!", "ok", "{", "dslengine", ".", "IncompatibleDSL", "(", ")", "\n", "}", "\n", "return", "e", ",", "ok", "\n", "}" ]

[ "encodingDefinition", "returns", "true", "and", "current", "context", "if", "it", "is", "an", "EncodingDefinition", "nil", "and", "false", "otherwise", "." ]

[ "func", "contactDefinition", "(", ")", "(", "*", "design", ".", "ContactDefinition", ",", "bool", ")", "{", "a", ",", "ok", ":=", "dslengine", ".", "CurrentDefinition", "(", ")", ".", "(", "*", "design", ".", "ContactDefinition", ")", "\n", "if", "!", "ok", "{", "dslengine", ".", "IncompatibleDSL", "(", ")", "\n", "}", "\n", "return", "a", ",", "ok", "\n", "}" ]

[ "contactDefinition", "returns", "true", "and", "current", "context", "if", "it", "is", "an", "ContactDefinition", "nil", "and", "false", "otherwise", "." ]

[ "func", "licenseDefinition", "(", ")", "(", "*", "design", ".", "LicenseDefinition", ",", "bool", ")", "{", "l", ",", "ok", ":=", "dslengine", ".", "CurrentDefinition", "(", ")", ".", "(", "*", "design", ".", "LicenseDefinition", ")", "\n", "if", "!", "ok", "{", "dslengine", ".", "IncompatibleDSL", "(", ")", "\n", "}", "\n", "return", "l", ",", "ok", "\n", "}" ]

[ "licenseDefinition", "returns", "true", "and", "current", "context", "if", "it", "is", "an", "APIDefinition", "nil", "and", "false", "otherwise", "." ]

[ "func", "docsDefinition", "(", ")", "(", "*", "design", ".", "DocsDefinition", ",", "bool", ")", "{", "a", ",", "ok", ":=", "dslengine", ".", "CurrentDefinition", "(", ")", ".", "(", "*", "design", ".", "DocsDefinition", ")", "\n", "if", "!", "ok", "{", "dslengine", ".", "IncompatibleDSL", "(", ")", "\n", "}", "\n", "return", "a", ",", "ok", "\n", "}" ]

[ "docsDefinition", "returns", "true", "and", "current", "context", "if", "it", "is", "a", "DocsDefinition", "nil", "and", "false", "otherwise", "." ]

[ "func", "mediaTypeDefinition", "(", ")", "(", "*", "design", ".", "MediaTypeDefinition", ",", "bool", ")", "{", "m", ",", "ok", ":=", "dslengine", ".", "CurrentDefinition", "(", ")", ".", "(", "*", "design", ".", "MediaTypeDefinition", ")", "\n", "if", "!", "ok", "{", "dslengine", ".", "IncompatibleDSL", "(", ")", "\n", "}", "\n", "return", "m", ",", "ok", "\n", "}" ]

[ "mediaTypeDefinition", "returns", "true", "and", "current", "context", "if", "it", "is", "a", "MediaTypeDefinition", "nil", "and", "false", "otherwise", "." ]

[ "func", "typeDefinition", "(", ")", "(", "*", "design", ".", "UserTypeDefinition", ",", "bool", ")", "{", "m", ",", "ok", ":=", "dslengine", ".", "CurrentDefinition", "(", ")", ".", "(", "*", "design", ".", "UserTypeDefinition", ")", "\n", "if", "!", "ok", "{", "dslengine", ".", "IncompatibleDSL", "(", ")", "\n", "}", "\n", "return", "m", ",", "ok", "\n", "}" ]

[ "typeDefinition", "returns", "true", "and", "current", "context", "if", "it", "is", "a", "UserTypeDefinition", "nil", "and", "false", "otherwise", "." ]

[ "func", "resourceDefinition", "(", ")", "(", "*", "design", ".", "ResourceDefinition", ",", "bool", ")", "{", "r", ",", "ok", ":=", "dslengine", ".", "CurrentDefinition", "(", ")", ".", "(", "*", "design", ".", "ResourceDefinition", ")", "\n", "if", "!", "ok", "{", "dslengine", ".", "IncompatibleDSL", "(", ")", "\n", "}", "\n", "return", "r", ",", "ok", "\n", "}" ]

[ "resourceDefinition", "returns", "true", "and", "current", "context", "if", "it", "is", "a", "ResourceDefinition", "nil", "and", "false", "otherwise", "." ]

[ "func", "corsDefinition", "(", ")", "(", "*", "design", ".", "CORSDefinition", ",", "bool", ")", "{", "cors", ",", "ok", ":=", "dslengine", ".", "CurrentDefinition", "(", ")", ".", "(", "*", "design", ".", "CORSDefinition", ")", "\n", "if", "!", "ok", "{", "dslengine", ".", "IncompatibleDSL", "(", ")", "\n", "}", "\n", "return", "cors", ",", "ok", "\n", "}" ]

[ "corsDefinition", "returns", "true", "and", "current", "context", "if", "it", "is", "a", "CORSDefinition", "nil", "And", "false", "otherwise", "." ]