Datasets:

---

CM

/

codexglue_code2text_go

like 1

[ "func", "HasCatchAllInRootRoute", "(", "apiDef", "*", "raml", ".", "APIDefinition", ")", "bool", "{", "rootCatchAllRoute", ":=", "\"", "\"", "+", "CatchAllRoute", "\n", "for", "endpoint", ":=", "range", "apiDef", ".", "Resources", "{", "if", "endpoint", "==", "rootCatchAllRoute", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "HasCatchAllInRootRoute", "returns", "true", "if", "the", "given", "raml", "api", "definition", "has", "catch", "all", "route", "as", "root", "endpoint" ]

[ "func", "(", "c", "goramldir", ")", "doReqWithBody", "(", "method", ",", "urlStr", "string", ",", "data", "interface", "{", "}", ",", "headers", ",", "queryParams", "map", "[", "string", "]", "interface", "{", "}", ")", "(", "*", "http", ".", "Response", ",", "error", ")", "{", "body", ",", "err", ":=", "encodeBody", "(", "data", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "c", ".", "doReq", "(", "method", ",", "urlStr", ",", "body", ",", "headers", ",", "queryParams", ")", "\n", "}" ]

[ "do", "HTTP", "request", "with", "request", "body" ]

[ "func", "(", "c", "goramldir", ")", "doReqNoBody", "(", "method", ",", "urlStr", "string", ",", "headers", ",", "queryParams", "map", "[", "string", "]", "interface", "{", "}", ")", "(", "*", "http", ".", "Response", ",", "error", ")", "{", "return", "c", ".", "doReq", "(", "method", ",", "urlStr", ",", "nil", ",", "headers", ",", "queryParams", ")", "\n", "}" ]

[ "do", "http", "request", "without", "request", "body" ]

[ "func", "GenerateDocs", "(", "apiDef", "*", "raml", ".", "APIDefinition", ",", "format", ",", "output", "string", ")", "error", "{", "switch", "format", "{", "case", "formatMarkdown", ":", "md", ":=", "&", "markdownDocs", "{", "api", ":", "apiDef", ",", "output", ":", "output", ",", "}", "\n", "return", "md", ".", "generate", "(", ")", "\n", "default", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "format", ")", "\n", "}", "\n", "}" ]

[ "GenerateDocs", "generate", "markdown", "docs", "from", "RAML", "specs" ]

[ "func", "(", "m", "Method", ")", "VerbTitle", "(", ")", "string", "{", "return", "strings", ".", "Title", "(", "strings", ".", "ToLower", "(", "m", ".", "verb", ")", ")", "\n", "}" ]

[ "VerbTitle", "returns", "HTTP", "Verb", "of", "this", "method", "in", "title", "format" ]

[ "func", "(", "s", "*", "Struct", ")", "Generate", "(", "dir", "string", ")", "error", "{", "if", "s", ".", "Enum", "!=", "nil", "{", "return", "s", ".", "Enum", ".", "generate", "(", "dir", ")", "\n", "}", "\n\n", "if", "err", ":=", "s", ".", "generateEnums", "(", "dir", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "filename", ":=", "filepath", ".", "Join", "(", "dir", ",", "s", ".", "Name", "+", "\"", "\"", ")", "\n", "return", "commons", ".", "GenerateFile", "(", "s", ",", "\"", "\"", ",", "\"", "\"", ",", "filename", ",", "true", ")", "\n", "}" ]

[ "Generate", "generates", "struct", "code" ]

[ "func", "(", "s", "*", "Struct", ")", "generateEnums", "(", "dir", "string", ")", "error", "{", "for", "_", ",", "f", ":=", "range", "s", ".", "Fields", "{", "if", "f", ".", "Enum", "==", "nil", "{", "continue", "\n", "}", "\n", "if", "err", ":=", "f", ".", "Enum", ".", "generate", "(", "dir", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "generate", "all", "enums", "contained", "in", "this", "struct" ]

[ "func", "NewJSONSchema", "(", "t", "Type", ",", "name", "string", ")", "JSONSchema", "{", "typ", ":=", "t", ".", "TypeString", "(", ")", "\n", "if", "typ", "==", "\"", "\"", "||", "t", ".", "Type", "==", "nil", "{", "typ", "=", "\"", "\"", "\n", "}", "\n\n", "return", "NewJSONSchemaFromProps", "(", "&", "t", ",", "t", ".", "Properties", ",", "typ", ",", "name", ")", "\n", "}" ]

[ "NewJSONSchema", "creates", "JSON", "schema", "from", "an", "raml", "type" ]

[ "func", "NewJSONSchemaFromProps", "(", "t", "*", "Type", ",", "properties", "map", "[", "string", "]", "interface", "{", "}", ",", "typ", ",", "name", "string", ")", "JSONSchema", "{", "var", "required", "[", "]", "string", "\n\n", "if", "isTypeArray", "(", "typ", ")", "{", "return", "newArraySchema", "(", "t", ",", "typ", ",", "name", ")", "\n", "}", "\n\n", "props", ":=", "make", "(", "map", "[", "string", "]", "property", ",", "len", "(", "properties", ")", ")", "\n", "for", "name", ":=", "range", "properties", "{", "rp", ":=", "t", ".", "GetProperty", "(", "name", ")", "\n", "if", "!", "isPropTypeSupported", "(", "rp", ")", "{", "continue", "\n", "}", "\n\n", "p", ":=", "newProperty", "(", "rp", ")", "\n", "props", "[", "p", ".", "Name", "]", "=", "p", "\n", "if", "p", ".", "Required", "{", "required", "=", "append", "(", "required", ",", "p", ".", "Name", ")", "\n", "}", "\n", "}", "\n\n", "// we need it to be sorted for testing purpose", "sort", ".", "Strings", "(", "required", ")", "\n", "js", ":=", "JSONSchema", "{", "Schema", ":", "schemaVer", ",", "Name", ":", "name", ",", "Type", ":", "typ", ",", "T", ":", "t", ",", "Properties", ":", "props", ",", "Required", ":", "required", ",", "}", "\n", "if", "js", ".", "T", "==", "nil", "{", "js", ".", "T", "=", "&", "Type", "{", "Type", ":", "typ", ",", "Properties", ":", "properties", ",", "}", "\n", "}", "\n", "return", "js", "\n", "}" ]

[ "NewJSONSchemaFromProps", "creates", "json", "schmema", "from", "a", "map", "of", "properties" ]

[ "func", "(", "js", "*", "JSONSchema", ")", "Inherit", "(", "parents", "[", "]", "JSONSchema", ")", "{", "// inherit `properties` and `required`", "// only inherit if the property name not exist in", "// child properties", "oriProps", ":=", "map", "[", "string", "]", "interface", "{", "}", "{", "}", "\n", "for", "name", ",", "prop", ":=", "range", "js", ".", "Properties", "{", "oriProps", "[", "name", "]", "=", "prop", "\n", "}", "\n\n", "for", "_", ",", "parent", ":=", "range", "parents", "{", "for", "name", ",", "prop", ":=", "range", "parent", ".", "Properties", "{", "if", "_", ",", "exist", ":=", "oriProps", "[", "name", "]", ";", "!", "exist", "{", "js", ".", "Properties", "[", "name", "]", "=", "prop", "\n", "}", "\n", "}", "\n", "for", "_", ",", "name", ":=", "range", "parent", ".", "Required", "{", "if", "_", ",", "exist", ":=", "oriProps", "[", "name", "]", ";", "!", "exist", "{", "if", "!", "js", ".", "isRequired", "(", "name", ")", "{", "js", ".", "Required", "=", "append", "(", "js", ".", "Required", ",", "name", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n\n", "}" ]

[ "Inherit", "inherits", "JSON", "schema", "from", "the", "parents" ]

[ "func", "(", "js", "*", "JSONSchema", ")", "RAMLProperties", "(", ")", "map", "[", "string", "]", "interface", "{", "}", "{", "js", ".", "PostUnmarshal", "(", ")", "\n", "props", ":=", "map", "[", "string", "]", "interface", "{", "}", "{", "}", "\n", "for", "name", ",", "prop", ":=", "range", "js", ".", "Properties", "{", "props", "[", "name", "]", "=", "prop", ".", "toRAMLProperty", "(", ")", "\n", "}", "\n", "return", "props", "\n", "}" ]

[ "RAMLProperties", "returns", "all", "raml", "property", "of", "this", "JSON", "schema" ]

[ "func", "NewSanicServer", "(", "apiDef", "*", "raml", ".", "APIDefinition", ",", "apiDocsDir", ",", "targetDir", "string", ",", "withMain", "bool", ",", "libRootURLs", "[", "]", "string", ")", "*", "SanicServer", "{", "var", "prs", "[", "]", "pythonResource", "\n", "for", "_", ",", "rd", ":=", "range", "getServerResourcesDefs", "(", "apiDef", ")", "{", "pr", ":=", "newResource", "(", "rd", ",", "apiDef", ",", "serverKindSanic", ")", "\n", "prs", "=", "append", "(", "prs", ",", "pr", ")", "\n", "}", "\n\n", "// TODO : get rid of this global variables", "globAPIDef", "=", "apiDef", "\n", "globLibRootURLs", "=", "libRootURLs", "\n\n", "templates", ":=", "templates", "(", "serverKindSanic", ")", "\n\n", "return", "&", "SanicServer", "{", "APIDef", ":", "apiDef", ",", "Title", ":", "apiDef", ".", "Title", ",", "apiDocsDir", ":", "apiDocsDir", ",", "withMain", ":", "withMain", ",", "ResourcesDef", ":", "prs", ",", "Template", ":", "templates", ",", "targetDir", ":", "targetDir", ",", "}", "\n", "}" ]

[ "NewSanicServer", "creates", "new", "sanic", "server", "from", "an", "RAML", "file" ]

[ "func", "newObjectFromType", "(", "t", "raml", ".", "Type", ",", "name", "string", ")", "object", "{", "obj", ":=", "newObject", "(", "name", ",", "t", ".", "Description", ",", "t", ".", "Properties", ")", "\n", "obj", ".", "T", "=", "t", "\n", "obj", ".", "handleAdvancedType", "(", ")", "\n", "return", "obj", "\n", "}" ]

[ "create", "new", "object", "from", "an", "RAML", "type" ]

[ "func", "(", "o", "*", "object", ")", "generate", "(", "dir", "string", ")", "error", "{", "o", ".", "handleAdvancedType", "(", ")", "\n\n", "// generate enums", "for", "_", ",", "f", ":=", "range", "o", ".", "Fields", "{", "if", "f", ".", "Enum", "!=", "nil", "{", "if", "err", ":=", "f", ".", "Enum", ".", "generate", "(", "dir", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "}", "\n\n", "if", "o", ".", "Enum", "!=", "nil", "{", "return", "o", ".", "Enum", ".", "generate", "(", "dir", ")", "\n", "}", "\n", "filename", ":=", "filepath", ".", "Join", "(", "dir", ",", "o", ".", "Name", "(", ")", "+", "\"", "\"", ")", "\n", "if", "err", ":=", "commons", ".", "GenerateFile", "(", "o", ",", "\"", "\"", ",", "\"", "\"", ",", "filename", ",", "true", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "generate", "nim", "object", "representation" ]

[ "func", "(", "o", "*", "object", ")", "handleAdvancedType", "(", ")", "{", "strType", ":=", "o", ".", "T", ".", "TypeString", "(", ")", "\n\n", "parents", ",", "isMultipleInheritance", ":=", "o", ".", "T", ".", "MultipleInheritance", "(", ")", "\n", "switch", "{", "case", "isMultipleInheritance", ":", "//multiple inheritance", "o", ".", "inherit", "(", "parents", ")", "\n", "case", "o", ".", "T", ".", "IsEnum", "(", ")", ":", "o", ".", "makeEnum", "(", ")", "\n", "case", "strType", "==", "\"", "\"", "||", "strType", "==", "\"", "\"", ":", "// plain type", "case", "o", ".", "T", ".", "IsArray", "(", ")", ":", "o", ".", "makeArray", "(", "strType", ")", "\n", "}", "\n", "}" ]

[ "handle", "RAML", "advanced", "data", "type" ]

[ "func", "objectRegistered", "(", "objName", "string", ")", "(", "string", ",", "bool", ")", "{", "objName", "=", "extractTypeName", "(", "objName", ")", "\n", "_", ",", "ok", ":=", "objectsRegister", "[", "objName", "]", "\n", "return", "objName", ",", "ok", "\n", "}" ]

[ "check", "if", "an", "object", "named", "objName", "has", "been", "generated" ]

[ "func", "extractTypeName", "(", "tip", "string", ")", "string", "{", "// trim all spaces", "tip", "=", "strings", ".", "TrimSpace", "(", "tip", ")", "\n\n", "// detect array", "if", "strings", ".", "Index", "(", "tip", ",", "\"", "\"", ")", "<", "0", "{", "return", "tip", "\n", "}", "\n\n", "// find type inside square bracket", "inBracket", ":=", "reSquareBracket", ".", "FindString", "(", "tip", ")", "\n", "if", "inBracket", "==", "\"", "\"", "{", "return", "tip", "\n", "}", "\n", "last", ":=", "strings", ".", "LastIndex", "(", "inBracket", ",", "\"", "\"", ")", "\n", "inBracket", "=", "inBracket", "[", "last", "+", "1", ":", "]", "\n", "return", "strings", ".", "TrimSuffix", "(", "inBracket", ",", "\"", "\"", ")", "\n", "}" ]

[ "extract", "type", "name", "from", "potentially", "complex", "type", "declaration" ]

[ "func", "(", "cs", "ClientService", ")", "libImportPaths", "(", ")", "map", "[", "string", "]", "struct", "{", "}", "{", "ip", ":=", "map", "[", "string", "]", "struct", "{", "}", "{", "}", "\n\n", "var", "needImportGoraml", "bool", "\n", "// methods", "for", "_", ",", "gm", ":=", "range", "cs", ".", "Methods", "{", "for", "lib", ":=", "range", "gm", ".", "libImported", "(", "globRootImportPath", ")", "{", "ip", "[", "lib", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n", "if", "!", "needImportGoraml", "{", "needImportGoraml", "=", "gm", ".", "needImportGoraml", "(", ")", "\n", "}", "\n", "}", "\n", "if", "needImportGoraml", "{", "ip", "[", "`\"`", "+", "joinImportPath", "(", "globRootImportPath", ",", "\"", "\"", ")", "+", "`\"`", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n", "return", "ip", "\n", "}" ]

[ "LibImportPaths", "returns", "all", "imported", "lib" ]

[ "func", "newGoLibrary", "(", "name", "string", ",", "lib", "*", "raml", ".", "Library", ",", "parentDir", ",", "rootTargetDir", "string", ",", "libRootURLs", "[", "]", "string", ")", "*", "goLibrary", "{", "gl", ":=", "&", "goLibrary", "{", "Library", ":", "lib", ",", "PackageName", ":", "commons", ".", "NormalizePkgName", "(", "name", ")", ",", "parentDir", ":", "parentDir", ",", "rootTargetDir", ":", "rootTargetDir", ",", "libRootURLs", ":", "libRootURLs", ",", "name", ":", "name", ",", "}", "\n", "return", "gl", "\n", "}" ]

[ "create", "new", "library", "instance" ]

[ "func", "(", "gl", "*", "goLibrary", ")", "targetDir", "(", ")", "string", "{", "baseDir", ":=", "gl", ".", "parentDir", "\n", "if", "libraries", ".", "IsRemote", "(", "gl", ".", "Filename", ")", "{", "baseDir", "=", "gl", ".", "rootTargetDir", "\n", "}", "\n\n", "fileDir", ":=", "goLibPackageDir", "(", "gl", ".", "name", ",", "libraries", ".", "StripLibRootURL", "(", "gl", ".", "Filename", ",", "gl", ".", "libRootURLs", ")", ")", "\n\n", "return", "filepath", ".", "Join", "(", "baseDir", ",", "fileDir", ")", "\n", "}" ]

[ "target", "dir", "of", "this", "go", "library" ]

[ "func", "libImportPath", "(", "rootImportPath", ",", "typ", "string", ",", "libRootURLs", "[", "]", "string", ")", "string", "{", "// all library use '.',", "// return nothing if it is not a library", "if", "strings", ".", "Index", "(", "typ", ",", "\"", "\"", ")", "<", "0", "{", "return", "\"", "\"", "\n", "}", "\n\n", "if", "strings", ".", "Index", "(", "typ", ",", "\"", "\"", ")", ">=", "0", "{", "return", "`\"encoding/json\"`", "\n", "}", "\n\n", "// library name in the current document", "libName", ":=", "strings", ".", "Split", "(", "typ", ",", "\"", "\"", ")", "[", "0", "]", "\n\n", "if", "libName", "==", "\"", "\"", "{", "// special package name, reserved for goraml", "return", "fmt", ".", "Sprintf", "(", "`\"%s\"`", ",", "joinImportPath", "(", "rootImportPath", ",", "\"", "\"", ")", ")", "\n", "}", "\n\n", "// raml file of this lib", "libDir", ",", "libFile", ":=", "globAPIDef", ".", "FindLibFile", "(", "commons", ".", "DenormalizePkgName", "(", "libName", ")", ")", "\n\n", "if", "libFile", "==", "\"", "\"", "{", "return", "\"", "\"", "\n", "}", "\n\n", "libPath", ":=", "libraries", ".", "JoinPath", "(", "libDir", ",", "libFile", ",", "libRootURLs", ")", "\n\n", "importPath", ":=", "joinImportPath", "(", "rootImportPath", ",", "path", ".", "Join", "(", "goLibPackageDir", "(", "libName", ",", "libPath", ")", ",", "typeDir", ")", ")", "\n", "return", "aliasLibTypeImportPath", "(", "importPath", ")", "\n", "}" ]

[ "get", "library", "import", "path", "from", "a", "type" ]

[ "func", "goLibPackageDir", "(", "name", ",", "filename", "string", ")", "string", "{", "dir", ":=", "filepath", ".", "Join", "(", "filepath", ".", "Dir", "(", "filename", ")", ",", "name", ")", "\n\n", "// escape last dir element", "elems", ":=", "strings", ".", "Split", "(", "dir", ",", "\"", "\"", ")", "\n", "elems", "[", "len", "(", "elems", ")", "-", "1", "]", "=", "commons", ".", "NormalizeIdentifier", "(", "elems", "[", "len", "(", "elems", ")", "-", "1", "]", ")", "\n", "return", "strings", ".", "Join", "(", "elems", ",", "\"", "\"", ")", "\n", "}" ]

[ "returns", "Go", "package", "directory", "of", "a", "library", "name", "is", "library", "name", ".", "filename", "is", "library", "file", "name", ".", "for", "the", "rule", "see", "comment", "of", "type", "goLibrary", "struct" ]

[ "func", "(", "gcm", "clientMethod", ")", "ReturnTypes", "(", ")", "string", "{", "var", "types", "[", "]", "string", "\n", "for", "_", ",", "resp", ":=", "range", "gcm", ".", "SuccessRespBodyTypes", "(", ")", "{", "types", "=", "append", "(", "types", ",", "resp", ".", "Type", "(", ")", ")", "\n", "}", "\n", "types", "=", "append", "(", "types", ",", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", "}", "...", ")", "\n\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "strings", ".", "Join", "(", "types", ",", "\"", "\"", ")", ")", "\n", "}" ]

[ "ReturnTypes", "returns", "all", "types", "returned", "by", "this", "method" ]

[ "func", "NewClient", "(", "apiDef", "*", "raml", ".", "APIDefinition", ",", "dir", "string", ")", "Client", "{", "return", "Client", "{", "APIDef", ":", "apiDef", ",", "Dir", ":", "dir", ",", "}", "\n", "}" ]

[ "NewClient", "creates", "a", "new", "Nim", "client" ]

[ "func", "(", "c", "*", "Client", ")", "Generate", "(", ")", "error", "{", "rs", ":=", "getAllResources", "(", "c", ".", "APIDef", ",", "false", ")", "\n\n", "if", "err", ":=", "generateAllObjects", "(", "c", ".", "APIDef", ",", "c", ".", "Dir", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "// services files", "if", "err", ":=", "c", ".", "generateServices", "(", "rs", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "c", ".", "generateSecurity", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "// main client file", "if", "err", ":=", "c", ".", "generateMain", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Generate", "generates", "all", "Nim", "client", "files" ]

[ "func", "clientName", "(", "apiDef", "*", "raml", ".", "APIDefinition", ")", "string", "{", "splt", ":=", "strings", ".", "Split", "(", "apiDef", ".", "Title", ",", "\"", "\"", ")", "\n", "return", "\"", "\"", "+", "strings", ".", "ToLower", "(", "splt", "[", "0", "]", ")", "\n", "}" ]

[ "returns", "client", "name", "of", "an", "API", "definition" ]

[ "func", "(", "gr", "*", "goResource", ")", "generateInterfaceFile", "(", "directory", "string", ")", "error", "{", "filename", ":=", "directory", "+", "\"", "\"", "+", "strings", ".", "ToLower", "(", "gr", ".", "Name", ")", "+", "\"", "\"", "\n", "return", "commons", ".", "GenerateFile", "(", "gr", ",", "resourceIfTemplate", ",", "\"", "\"", ",", "filename", ",", "true", ")", "\n", "}" ]

[ "generate", "interface", "file", "of", "a", "resource" ]

[ "func", "(", "gr", "*", "goResource", ")", "generateAPIImplementations", "(", "dir", "string", ")", "error", "{", "// generate the main API impl file, which only contains struct", "mainCtx", ":=", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "gr", ".", "PackageName", ",", "\"", "\"", ":", "gr", ".", "Name", ",", "\"", "\"", ":", "gr", ".", "Endpoint", ",", "}", "\n\n", "mainFile", ":=", "filepath", ".", "Join", "(", "dir", ",", "strings", ".", "ToLower", "(", "gr", ".", "Name", ")", "+", "\"", "\"", ")", "\n", "if", "err", ":=", "commons", ".", "GenerateFile", "(", "mainCtx", ",", "\"", "\"", ",", "\"", "\"", ",", "mainFile", "+", "\"", "\"", ",", "false", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// generate per methods file", "for", "_", ",", "sm", ":=", "range", "gr", ".", "Methods", "{", "ctx", ":=", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "sm", ",", "\"", "\"", ":", "gr", ".", "Name", ",", "\"", "\"", ":", "gr", ".", "PackageName", ",", "}", "\n", "filename", ":=", "mainFile", "+", "\"", "\"", "+", "sm", ".", "MethodName", "+", "\"", "\"", "\n", "if", "err", ":=", "commons", ".", "GenerateFile", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ",", "filename", ",", "false", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "generate", "API", "implementation", "in", "one", "file", "per", "method", "mode" ]

[ "func", "(", "gr", "goResource", ")", "InterfaceImportPaths", "(", ")", "[", "]", "string", "{", "ip", ":=", "map", "[", "string", "]", "struct", "{", "}", "{", "\"", "\"", ":", "struct", "{", "}", "{", "}", ",", "\"", "\"", ":", "struct", "{", "}", "{", "}", ",", "}", "\n\n", "for", "_", ",", "gm", ":=", "range", "gr", ".", "Methods", "{", "// if has middleware, we need to import middleware helper library", "if", "len", "(", "gm", ".", "Middlewares", ")", ">", "0", "{", "ip", "[", "\"", "\"", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n", "for", "_", ",", "sb", ":=", "range", "gm", ".", "SecuredBy", "{", "if", "lib", ":=", "libImportPath", "(", "globRootImportPath", ",", "sb", ".", "Name", ",", "globLibRootURLs", ")", ";", "lib", "!=", "\"", "\"", "{", "ip", "[", "lib", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "// return sorted array for predictable order", "// we need it for unit test to always return same order", "return", "commons", ".", "MapToSortedStrings", "(", "ip", ")", "\n", "}" ]

[ "InterfaceImportPaths", "returns", "all", "packages", "imported", "by", "this", "resource", "interface", "file" ]

[ "func", "(", "gr", "goResource", ")", "APILibImportPaths", "(", ")", "[", "]", "string", "{", "ip", ":=", "map", "[", "string", "]", "struct", "{", "}", "{", "}", "\n\n", "// methods", "for", "_", ",", "gm", ":=", "range", "gr", ".", "Methods", "{", "for", "_", ",", "v", ":=", "range", "gm", ".", "Imports", "(", ")", "{", "ip", "[", "v", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n", "}", "\n\n", "// return sorted array for predictable order", "// we need it for unit test to always return same order", "return", "commons", ".", "MapToSortedStrings", "(", "ip", ")", "\n", "}" ]

[ "APIImportPaths", "returns", "all", "packages", "that", "need", "to", "be", "imported", "by", "the", "API", "implementation" ]

[ "func", "NewServer", "(", "kind", "string", ",", "apiDef", "*", "raml", ".", "APIDefinition", ",", "apiDocsDir", ",", "targetDir", "string", ",", "withMain", "bool", ",", "libRootURLs", "[", "]", "string", ")", "generator", ".", "Server", "{", "switch", "kind", "{", "case", "\"", "\"", ",", "serverKindFlask", ":", "return", "NewFlaskServer", "(", "apiDef", ",", "apiDocsDir", ",", "targetDir", ",", "withMain", ",", "libRootURLs", ",", "false", ")", "\n", "case", "serverKindGeventFlask", ":", "return", "NewFlaskServer", "(", "apiDef", ",", "apiDocsDir", ",", "targetDir", ",", "true", ",", "libRootURLs", ",", "true", ")", "\n", "case", "serverKindSanic", ":", "return", "NewSanicServer", "(", "apiDef", ",", "apiDocsDir", ",", "targetDir", ",", "withMain", ",", "libRootURLs", ")", "\n\n", "default", ":", "log", ".", "Fatalf", "(", "\"", "\"", ",", "kind", ")", "\n", "return", "nil", "\n", "}", "\n", "}" ]

[ "NewServer", "creates", "a", "new", "python", "server" ]

[ "func", "NewClient", "(", "apiDef", "*", "raml", ".", "APIDefinition", ",", "kind", "string", ",", "unmarshallResponse", "bool", ")", "Client", "{", "services", ":=", "map", "[", "string", "]", "*", "service", "{", "}", "\n", "for", "uri", ",", "res", ":=", "range", "apiDef", ".", "Resources", "{", "rd", ":=", "resource", ".", "New", "(", "apiDef", ",", "&", "res", ",", "commons", ".", "NormalizeURITitle", "(", "apiDef", ".", "Title", ")", ",", "false", ")", "\n", "services", "[", "uri", "]", "=", "newService", "(", "uri", ",", "&", "rd", ",", "unmarshallResponse", ")", "\n", "}", "\n", "switch", "kind", "{", "case", "\"", "\"", ":", "kind", "=", "clientNameRequests", "\n", "case", "clientNameRequests", ",", "clientNameAiohttp", ",", "clientNameGeventRequests", ":", "default", ":", "log", ".", "Fatalf", "(", "\"", "\"", ",", "kind", ")", "\n", "}", "\n\n", "c", ":=", "Client", "{", "Name", ":", "commons", ".", "NormalizeURI", "(", "apiDef", ".", "Title", ")", ",", "APIDef", ":", "apiDef", ",", "BaseURI", ":", "apiDef", ".", "BaseURI", ",", "Services", ":", "services", ",", "Kind", ":", "kind", ",", "UnmarshallResponse", ":", "unmarshallResponse", ",", "}", "\n", "if", "strings", ".", "Index", "(", "c", ".", "BaseURI", ",", "\"", "\"", ")", ">", "0", "{", "c", ".", "BaseURI", "=", "strings", ".", "Replace", "(", "c", ".", "BaseURI", ",", "\"", "\"", ",", "apiDef", ".", "Version", ",", "-", "1", ")", "\n", "}", "\n", "c", ".", "initTemplates", "(", ")", "\n", "c", ".", "Securities", "=", "getClientSecurityDefs", "(", "apiDef", ".", "SecuritySchemes", ",", "c", ".", "Template", ")", "\n\n", "return", "c", "\n", "}" ]

[ "NewClient", "creates", "a", "python", "Client" ]

[ "func", "(", "c", "Client", ")", "Generate", "(", "dir", "string", ")", "error", "{", "globAPIDef", "=", "c", ".", "APIDef", "\n\n", "// generate helper", "if", "err", ":=", "commons", ".", "GenerateFile", "(", "nil", ",", "\"", "\"", ",", "\"", "\"", ",", "filepath", ".", "Join", "(", "dir", ",", "\"", "\"", ")", ",", "true", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// generate http client", "if", "err", ":=", "commons", ".", "GenerateFile", "(", "nil", ",", "c", ".", "Template", ".", "httpClientFile", ",", "c", ".", "Template", ".", "httpClientName", ",", "filepath", ".", "Join", "(", "dir", ",", "\"", "\"", ")", ",", "true", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "c", ".", "generateServices", "(", "dir", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "c", ".", "generateSecurity", "(", "dir", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// python classes", "classes", ",", "err", ":=", "GenerateAllClasses", "(", "c", ".", "APIDef", ",", "dir", ",", "false", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// helper for python classes", "if", "err", ":=", "commons", ".", "GenerateFile", "(", "nil", ",", "\"", "\"", ",", "\"", "\"", ",", "filepath", ".", "Join", "(", "dir", ",", "\"", "\"", ")", ",", "true", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "c", ".", "UnmarshallResponse", "{", "if", "err", ":=", "commons", ".", "GenerateFile", "(", "nil", ",", "\"", "\"", ",", "\"", "\"", ",", "filepath", ".", "Join", "(", "dir", ",", "\"", "\"", ")", ",", "true", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "err", ":=", "commons", ".", "GenerateFile", "(", "nil", ",", "\"", "\"", ",", "\"", "\"", ",", "filepath", ".", "Join", "(", "dir", ",", "\"", "\"", ")", ",", "true", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "sort", ".", "Strings", "(", "classes", ")", "\n", "c", ".", "Classes", "=", "classes", "\n", "return", "commons", ".", "GenerateFile", "(", "c", ",", "c", ".", "Template", ".", "initFile", ",", "c", ".", "Template", ".", "initName", ",", "filepath", ".", "Join", "(", "dir", ",", "\"", "\"", ")", ",", "true", ")", "\n", "}" ]

[ "Generate", "generates", "python", "client", "library", "files" ]

[ "func", "(", "s", "*", "Server", ")", "generateServerResources", "(", "dir", "string", ")", "(", "[", "]", "*", "goResource", ",", "error", ")", "{", "var", "serverResources", "[", "]", "*", "goResource", "\n\n", "resources", ":=", "s", ".", "apiDef", ".", "Resources", "\n\n", "// sort the keys, so we have resource sorted by keys.", "// the generated code actually don't need it to be sorted.", "// but test fixture need it", "var", "keys", "[", "]", "string", "\n", "for", "k", ":=", "range", "resources", "{", "keys", "=", "append", "(", "keys", ",", "k", ")", "\n", "}", "\n", "sort", ".", "Strings", "(", "keys", ")", "\n\n", "// create resource def", "var", "err", "error", "\n", "for", "_", ",", "endpoint", ":=", "range", "keys", "{", "r", ":=", "resources", "[", "endpoint", "]", "\n", "rd", ":=", "resource", ".", "New", "(", "s", ".", "apiDef", ",", "&", "r", ",", "endpoint", ",", "true", ")", "\n", "pkgName", ":=", "strings", ".", "ToLower", "(", "commons", ".", "NormalizeIdentifier", "(", "rd", ".", "Name", ")", ")", "\n", "gr", ":=", "newGoResource", "(", "&", "rd", ",", "pkgName", ")", "\n", "err", "=", "gr", ".", "generate", "(", "&", "r", ",", "endpoint", ",", "dir", ",", "s", ".", "libsRootURLs", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "serverResources", "=", "append", "(", "serverResources", ",", "gr", ")", "\n", "}", "\n", "return", "serverResources", ",", "nil", "\n", "}" ]

[ "generate", "Server", "s", "Go", "representation", "of", "RAML", "resources" ]

[ "func", "NormalizeURITitle", "(", "URI", "string", ")", "string", "{", "s", ":=", "strings", ".", "Title", "(", "doNormalizeURI", "(", "URI", ")", ")", "\n", "return", "strings", ".", "Replace", "(", "s", ",", "\"", "\"", ",", "\"", "\"", ",", "-", "1", ")", "\n\n", "}" ]

[ "NormalizeURITitle", "does", "NormalizeURI", "with", "first", "character", "in", "upper", "case" ]

[ "func", "ParseDescription", "(", "desc", "string", ")", "[", "]", "string", "{", "if", "desc", "==", "\"", "\"", "{", "return", "nil", "\n", "}", "\n", "// we need to trim it because our parser usually give", "// space after last newline", "desc", "=", "strings", ".", "TrimSpace", "(", "desc", ")", "\n\n", "if", "desc", "==", "\"", "\"", "{", "return", "[", "]", "string", "{", "}", "\n", "}", "\n\n", "return", "strings", ".", "Split", "(", "desc", ",", "\"", "\\n", "\"", ")", "\n", "}" ]

[ "ParseDescription", "create", "string", "slice", "from", "an", "RAML", "description", ".", "each", "element", "is", "a", "description", "line" ]

[ "func", "GenerateFile", "(", "data", "interface", "{", "}", ",", "tmplFile", ",", "tmplName", ",", "filename", "string", ",", "override", "bool", ")", "error", "{", "if", "!", "override", "&&", "isFileExist", "(", "filename", ")", "{", "log", ".", "Infof", "(", "\"", "\"", ",", "filename", ")", "\n", "return", "nil", "\n", "}", "\n\n", "if", "err", ":=", "checkCreateDir", "(", "filepath", ".", "Dir", "(", "filename", ")", ")", ";", "err", "!=", "nil", "{", "}", "\n\n", "// pass Go function to template", "funcMap", ":=", "template", ".", "FuncMap", "{", "\"", "\"", ":", "strings", ".", "ToLower", ",", "}", "\n\n", "// all template files path is relative to current directory (./)", "// while go-bindata files exist in templates directory", "tmplFile", "=", "strings", ".", "Replace", "(", "tmplFile", ",", "\"", "\"", ",", "\"", "\"", ",", "-", "1", ")", "\n\n", "byteData", ",", "err", ":=", "templates", ".", "Asset", "(", "tmplFile", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "t", ",", "err", ":=", "template", ".", "New", "(", "tmplName", ")", ".", "Funcs", "(", "funcMap", ")", ".", "Parse", "(", "string", "(", "byteData", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "f", ",", "err", ":=", "os", ".", "Create", "(", "filename", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "f", ".", "Close", "(", ")", "\n\n", "log", ".", "Infof", "(", "\"", "\"", ",", "filename", ")", "\n", "if", "err", ":=", "t", ".", "ExecuteTemplate", "(", "f", ",", "tmplName", ",", "data", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "switch", "{", "case", "strings", ".", "HasSuffix", "(", "filename", ",", "\"", "\"", ")", ":", "return", "runGoFmt", "(", "filename", ")", "\n", "case", "strings", ".", "HasSuffix", "(", "filename", ",", "\"", "\"", ")", ":", "return", "runAutoPep8", "(", "filename", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "GenerateFile", "generates", "file", "from", "a", "template", ".", "if", "file", "already", "exist", "and", "override", "==", "false", "file", "won", "t", "be", "regenerated", "funcMap", "=", "this", "parameter", "is", "used", "for", "passing", "go", "function", "to", "the", "template" ]

[ "func", "MapToSortedStrings", "(", "m", "map", "[", "string", "]", "struct", "{", "}", ")", "[", "]", "string", "{", "ss", ":=", "[", "]", "string", "{", "}", "\n", "for", "k", ":=", "range", "m", "{", "ss", "=", "append", "(", "ss", ",", "k", ")", "\n", "}", "\n", "sort", ".", "Strings", "(", "ss", ")", "\n", "return", "ss", "\n", "}" ]

[ "MapToSortedStrings", "returns", "sorted", "string", "arrays", "from", "a", "map" ]

[ "func", "runGoFmt", "(", "filePath", "string", ")", "error", "{", "args", ":=", "[", "]", "string", "{", "\"", "\"", ",", "filePath", ",", "}", "\n\n", "if", "out", ",", "err", ":=", "exec", ".", "Command", "(", "\"", "\"", ",", "args", "...", ")", ".", "CombinedOutput", "(", ")", ";", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "\"", "\\n", "\"", ",", "filePath", ",", "string", "(", "out", ")", ")", "\n", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "run", "go", "fmt", "command", "to", "a", "file" ]

[ "func", "AtoiOrPanic", "(", "str", "string", ")", "int", "{", "i", ",", "err", ":=", "strconv", ".", "Atoi", "(", "str", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Fatalf", "(", "\"", "\"", ",", "str", ",", "err", ")", "\n", "}", "\n", "return", "i", "\n", "}" ]

[ "AtoiOrPanic", "convert", "a", "string", "to", "int", "and", "panic", "if", "failed" ]

[ "func", "IsStrInArray", "(", "arr", "[", "]", "string", ",", "str", "string", ")", "bool", "{", "for", "_", ",", "s", ":=", "range", "arr", "{", "if", "str", "==", "s", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "IsStrInArray", "check", "if", "a", "string", "str", "is", "part", "of", "array", "arr" ]

[ "func", "(", "e", "*", "enum", ")", "FieldsStr", "(", ")", "string", "{", "var", "names", "[", "]", "string", "\n", "for", "_", ",", "f", ":=", "range", "e", ".", "Fields", "{", "names", "=", "append", "(", "names", ",", "f", ".", "Name", ")", "\n", "}", "\n", "return", "strings", ".", "Join", "(", "names", ",", "\"", "\"", ")", "\n", "}" ]

[ "FieldsStr", "is", "a", "string", "representation", "of", "all", "the", "fields" ]

[ "func", "(", "ep", "Endpoint", ")", "ResourceName", "(", ")", "string", "{", "name", ":=", "ep", ".", "Addr", "\n", "splt", ":=", "strings", ".", "Split", "(", "name", ",", "\"", "\"", ")", "\n", "if", "len", "(", "splt", ")", ">", "0", "{", "name", "=", "splt", "[", "0", "]", "\n", "}", "\n", "return", "strings", ".", "TrimSuffix", "(", "strings", ".", "TrimPrefix", "(", "name", ",", "\"", "\"", ")", ",", "\"", "\"", ")", "\n", "}" ]

[ "ResourceName", "returns", "resource", "name", "of", "an", "endpoint" ]

[ "func", "PascalCaseTypeName", "(", "tip", "TypeInBody", ")", "string", "{", "methodName", ":=", "commons", ".", "SnackCaseServerMethodName", "(", "tip", ".", "Endpoint", ".", "Method", ".", "DisplayName", ",", "tip", ".", "Endpoint", ".", "Verb", ",", "tip", ".", "Endpoint", ".", "Resource", ")", "\n", "suffix", ":=", "commons", ".", "ReqBodySuffix", "\n", "if", "tip", ".", "ReqResp", "==", "HTTPResponse", "{", "suffix", "=", "commons", ".", "RespBodySuffix", "\n", "}", "\n", "return", "casee", ".", "ToPascalCase", "(", "methodName", "+", "suffix", ")", "\n", "}" ]

[ "PascalCaseTypeName", "generates", "pascalcase", "type", "name", "from", "snackcase", "method", "name" ]

[ "func", "(", "r", "*", "Resource", ")", "inheritResourceType", "(", "resourceTypes", "map", "[", "string", "]", "ResourceType", ",", "apiDef", "*", "APIDefinition", ")", "error", "{", "// get resource type object to inherit", "rt", ",", "err", ":=", "r", ".", "getResourceType", "(", "resourceTypes", ")", "\n", "if", "rt", "==", "nil", "||", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// initialize dicts", "dicts", ":=", "initResourceTypeDicts", "(", "r", ",", "r", ".", "Type", ".", "Parameters", ")", "\n\n", "r", ".", "Description", "=", "substituteParams", "(", "r", ".", "Description", ",", "rt", ".", "Description", ",", "dicts", ")", "\n\n", "// uri parameters", "if", "len", "(", "r", ".", "URIParameters", ")", "==", "0", "{", "r", ".", "URIParameters", "=", "map", "[", "string", "]", "NamedParameter", "{", "}", "\n", "}", "\n", "for", "name", ",", "up", ":=", "range", "rt", ".", "URIParameters", "{", "p", ",", "ok", ":=", "r", ".", "URIParameters", "[", "name", "]", "\n", "if", "!", "ok", "{", "p", "=", "NamedParameter", "{", "}", "\n", "}", "\n", "p", ".", "inherit", "(", "up", ",", "dicts", ")", "\n", "r", ".", "URIParameters", "[", "name", "]", "=", "p", "\n", "}", "\n\n", "// methods", "r", ".", "inheritMethods", "(", "rt", ",", "apiDef", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "inherit", "from", "a", "resource", "type" ]

[ "func", "(", "r", "*", "Resource", ")", "inheritMethods", "(", "rt", "*", "ResourceType", ",", "apiDef", "*", "APIDefinition", ")", "{", "// inherit all methods from resource type", "// if it doesn't have the methods, we create it", "for", "_", ",", "rtm", ":=", "range", "rt", ".", "methods", "{", "m", ":=", "r", ".", "MethodByName", "(", "rtm", ".", "Name", ")", "\n", "if", "m", "==", "nil", "{", "m", "=", "newMethod", "(", "rtm", ".", "Name", ")", "\n", "r", ".", "assignMethod", "(", "m", ",", "m", ".", "Name", ")", "\n", "}", "\n", "m", ".", "resourceTypeName", "=", "r", ".", "Type", ".", "Name", "\n", "m", ".", "inheritFromResourceType", "(", "r", ",", "rtm", ",", "rt", ",", "apiDef", ")", "\n", "}", "\n\n", "// inherit optional methods if only the resource also has the method", "for", "_", ",", "rtm", ":=", "range", "rt", ".", "optionalMethods", "{", "m", ":=", "r", ".", "MethodByName", "(", "rtm", ".", "Name", ")", "\n", "if", "m", "==", "nil", "{", "continue", "\n", "}", "\n", "m", ".", "resourceTypeName", "=", "r", ".", "Type", ".", "Name", "\n", "m", ".", "inheritFromResourceType", "(", "r", ",", "rtm", ",", "rt", ",", "apiDef", ")", "\n", "}", "\n\n", "}" ]

[ "inherit", "methods", "inherits", "all", "methods", "based", "on", "it", "s", "resource", "type" ]

[ "func", "(", "r", "*", "Resource", ")", "getResourceType", "(", "resourceTypes", "map", "[", "string", "]", "ResourceType", ")", "(", "*", "ResourceType", ",", "error", ")", "{", "// check if it's specify a resource type to inherit", "if", "r", ".", "Type", "==", "nil", "||", "r", ".", "Type", ".", "Name", "==", "\"", "\"", "{", "return", "nil", ",", "nil", "\n", "}", "\n\n", "// get resource type from array of resource type map", "for", "k", ",", "rt", ":=", "range", "resourceTypes", "{", "if", "k", "==", "r", ".", "Type", ".", "Name", "{", "return", "&", "rt", ",", "nil", "\n", "}", "\n", "}", "\n", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "r", ".", "Type", ".", "Name", ")", "\n", "}" ]

[ "get", "resource", "type", "from", "which", "this", "resource", "will", "inherit" ]

[ "func", "(", "r", "*", "Resource", ")", "setMethods", "(", "traitsMap", "map", "[", "string", "]", "Trait", ",", "apiDef", "*", "APIDefinition", ")", "{", "if", "r", ".", "Get", "!=", "nil", "{", "r", ".", "Get", ".", "postProcess", "(", "r", ",", "\"", "\"", ",", "traitsMap", ",", "apiDef", ")", "\n", "}", "\n", "if", "r", ".", "Post", "!=", "nil", "{", "r", ".", "Post", ".", "postProcess", "(", "r", ",", "\"", "\"", ",", "traitsMap", ",", "apiDef", ")", "\n", "}", "\n", "if", "r", ".", "Put", "!=", "nil", "{", "r", ".", "Put", ".", "postProcess", "(", "r", ",", "\"", "\"", ",", "traitsMap", ",", "apiDef", ")", "\n", "}", "\n", "if", "r", ".", "Patch", "!=", "nil", "{", "r", ".", "Patch", ".", "postProcess", "(", "r", ",", "\"", "\"", ",", "traitsMap", ",", "apiDef", ")", "\n", "}", "\n", "if", "r", ".", "Head", "!=", "nil", "{", "r", ".", "Head", ".", "postProcess", "(", "r", ",", "\"", "\"", ",", "traitsMap", ",", "apiDef", ")", "\n", "}", "\n", "if", "r", ".", "Delete", "!=", "nil", "{", "r", ".", "Delete", ".", "postProcess", "(", "r", ",", "\"", "\"", ",", "traitsMap", ",", "apiDef", ")", "\n", "}", "\n", "if", "r", ".", "Options", "!=", "nil", "{", "r", ".", "Options", ".", "postProcess", "(", "r", ",", "\"", "\"", ",", "traitsMap", ",", "apiDef", ")", "\n", "}", "\n", "}" ]

[ "set", "methods", "set", "all", "methods", "name", "and", "add", "it", "to", "Methods", "slice" ]

[ "func", "(", "r", "*", "Resource", ")", "MethodByName", "(", "name", "string", ")", "*", "Method", "{", "switch", "name", "{", "case", "\"", "\"", ":", "return", "r", ".", "Get", "\n", "case", "\"", "\"", ":", "return", "r", ".", "Post", "\n", "case", "\"", "\"", ":", "return", "r", ".", "Put", "\n", "case", "\"", "\"", ":", "return", "r", ".", "Patch", "\n", "case", "\"", "\"", ":", "return", "r", ".", "Head", "\n", "case", "\"", "\"", ":", "return", "r", ".", "Delete", "\n", "case", "\"", "\"", ":", "return", "r", ".", "Options", "\n", "default", ":", "return", "nil", "\n", "}", "\n", "}" ]

[ "MethodByName", "return", "resource", "s", "method", "by", "it", "s", "name" ]

[ "func", "substituteParams", "(", "toReplace", ",", "words", "string", ",", "dicts", "map", "[", "string", "]", "interface", "{", "}", ")", "string", "{", "// non empty scalar node remain unchanged", "// except it has double chevron bracket", "if", "toReplace", "!=", "\"", "\"", "&&", "(", "strings", ".", "Index", "(", "toReplace", ",", "\"", "\"", ")", "<", "0", "&&", "strings", ".", "Index", "(", "toReplace", ",", "\"", "\"", ")", "<", "0", ")", "{", "return", "toReplace", "\n", "}", "\n", "if", "words", "==", "\"", "\"", "{", "return", "toReplace", "\n", "}", "\n\n", "removeParamBracket", ":=", "func", "(", "param", "string", ")", "string", "{", "param", "=", "strings", ".", "TrimSpace", "(", "param", ")", "\n", "return", "param", "[", "2", ":", "len", "(", "param", ")", "-", "2", "]", "\n", "}", "\n\n", "// search params", "params", ":=", "dcRe", ".", "FindAllString", "(", "words", ",", "-", "1", ")", "\n\n", "// substitute the params", "for", "_", ",", "p", ":=", "range", "params", "{", "pVal", ",", "ok", ":=", "getParamValue", "(", "removeParamBracket", "(", "p", ")", ",", "dicts", ")", "\n", "if", "!", "ok", "{", "// only replace if param is found", "continue", "\n", "}", "\n", "words", "=", "strings", ".", "Replace", "(", "words", ",", "p", ",", "pVal", ",", "-", "1", ")", "\n", "}", "\n", "return", "words", "\n", "}" ]

[ "substituteParams", "substitute", "all", "params", "inside", "double", "chevron", "to", "the", "correct", "value", "param", "value", "will", "be", "obtained", "from", "dicts", "map" ]

[ "func", "getParamValue", "(", "param", "string", ",", "dicts", "map", "[", "string", "]", "interface", "{", "}", ")", "(", "string", ",", "bool", ")", "{", "// split between inflectors and real param", "// real param and each inflector is seperated by `|`", "cleanParam", ",", "inflectors", ":=", "func", "(", ")", "(", "string", ",", "string", ")", "{", "arr", ":=", "strings", ".", "SplitN", "(", "param", ",", "\"", "\"", ",", "2", ")", "\n", "if", "len", "(", "arr", ")", "!=", "2", "{", "return", "param", ",", "\"", "\"", "\n", "}", "\n", "return", "strings", ".", "TrimSpace", "(", "arr", "[", "0", "]", ")", ",", "strings", ".", "TrimSpace", "(", "arr", "[", "1", "]", ")", "\n", "}", "(", ")", "\n\n", "// get the value", "val", ",", "ok", ":=", "func", "(", ")", "(", "string", ",", "bool", ")", "{", "// get from type parameters", "val", ",", "ok", ":=", "dicts", "[", "cleanParam", "]", "\n", "if", "!", "ok", "{", "return", "\"", "\"", ",", "false", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "val", ")", ",", "true", "\n", "}", "(", ")", "\n", "if", "!", "ok", "{", "return", "\"", "\"", ",", "false", "\n", "}", "\n\n", "// inflect the value if needed", "if", "inflectors", "!=", "\"", "\"", "{", "for", "_", ",", "inflector", ":=", "range", "strings", ".", "Split", "(", "inflectors", ",", "\"", "\"", ")", "{", "inflector", "=", "strings", ".", "TrimSpace", "(", "inflector", ")", "\n", "var", "ok", "bool", "\n", "val", ",", "ok", "=", "doInflect", "(", "val", ",", "inflector", ")", "\n", "if", "!", "ok", "{", "log", ".", "Fatalf", "(", "\"", "\"", "+", "inflector", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "val", ",", "true", "\n", "}" ]

[ "get", "value", "of", "a", "resource", "type", "param", "return", "false", "if", "not", "exists" ]

[ "func", "NewServer", "(", "apiDef", "*", "raml", ".", "APIDefinition", ",", "apiDocsDir", "string", ",", "targetDir", "string", ")", "*", "Server", "{", "resources", ":=", "getServerResourcesDefs", "(", "apiDef", ")", "\n", "return", "&", "Server", "{", "apiDef", ":", "apiDef", ",", "apiDocsDir", ":", "apiDocsDir", ",", "TargetDir", ":", "targetDir", ",", "Resources", ":", "resources", ",", "}", "\n", "}" ]

[ "NewServer", "creates", "a", "new", "tarantool", "server" ]

[ "func", "(", "s", "*", "Server", ")", "generateMain", "(", ")", "error", "{", "filename", ":=", "path", ".", "Join", "(", "s", ".", "TargetDir", ",", "\"", "\"", ")", "\n", "return", "commons", ".", "GenerateFile", "(", "s", ",", "\"", "\"", ",", "\"", "\"", ",", "filename", ",", "true", ")", "\n", "}" ]

[ "generateMain", "generates", "the", "main", "server", "file" ]

[ "func", "(", "s", "*", "Server", ")", "generateResources", "(", ")", "error", "{", "var", "allMethods", "[", "]", "method", "\n\n", "for", "_", ",", "resource", ":=", "range", "s", ".", "Resources", "{", "filename", ":=", "path", ".", "Join", "(", "s", ".", "TargetDir", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "strings", ".", "ToLower", "(", "resource", ".", "Name", ")", ")", "+", "\"", "\"", ")", "\n\n", "if", "err", ":=", "commons", ".", "GenerateFile", "(", "resource", ",", "\"", "\"", ",", "\"", "\"", ",", "filename", ",", "true", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "for", "_", ",", "method", ":=", "range", "resource", ".", "Methods", "{", "allMethods", "=", "append", "(", "allMethods", ",", "*", "method", ")", "\n", "filename", ":=", "path", ".", "Join", "(", "s", ".", "TargetDir", ",", "handlersDir", ",", "method", ".", "Handler", "(", ")", "+", "\"", "\"", ")", "\n\n", "// generate method handler file", "if", "err", ":=", "commons", ".", "GenerateFile", "(", "method", ",", "\"", "\"", ",", "\"", "\"", ",", "filename", ",", "false", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "}", "\n\n", "methods", ":=", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "allMethods", ",", "}", "\n\n", "// Generate handlers file", "filename", ":=", "path", ".", "Join", "(", "s", ".", "TargetDir", ",", "handlersDir", ",", "\"", "\"", ")", "\n", "return", "commons", ".", "GenerateFile", "(", "methods", ",", "\"", "\"", ",", "\"", "\"", ",", "filename", ",", "true", ")", "\n", "}" ]

[ "generateResources", "generates", "all", "resource", "apis", "and", "end", "point", "handlers" ]

[ "func", "(", "pf", "*", "field", ")", "setType", "(", "apiDef", "*", "raml", ".", "APIDefinition", ",", "t", ",", "items", "string", ")", "{", "pt", ":=", "toPythonType", "(", "t", ")", "\n", "if", "pt", "!=", "nil", "{", "pf", ".", "Type", "=", "pt", ".", "name", "\n", "if", "pt", ".", "importName", "!=", "\"", "\"", "{", "pf", ".", "addImport", "(", "apiDef", ",", "pt", ".", "importModule", ",", "pt", ".", "importName", ")", "\n", "}", "\n", "return", "// type already set, no need to go down", "\n", "}", "\n\n", "ramlType", ":=", "raml", ".", "Type", "{", "Type", ":", "t", ",", "Items", ":", "items", ",", "}", "\n", "// other types that need some processing", "switch", "{", "case", "ramlType", ".", "IsBidimensiArray", "(", ")", ":", "// bidimensional array", "log", ".", "Info", "(", "\"", "\"", ")", "\n", "case", "ramlType", ".", "IsArray", "(", ")", ":", "// array", "pf", ".", "IsList", "=", "true", "\n", "pf", ".", "setType", "(", "apiDef", ",", "ramlType", ".", "ArrayType", "(", ")", ",", "\"", "\"", ")", "\n", "case", "strings", ".", "HasSuffix", "(", "t", ",", "\"", "\"", ")", ":", "// map", "log", ".", "Info", "(", "\"", "\"", ")", "\n", "case", "ramlType", ".", "IsUnion", "(", ")", ":", "// send the list of union types to the template", "unionTypes", ",", "_", ":=", "ramlType", ".", "Union", "(", ")", "\n", "for", "_", ",", "typename", ":=", "range", "unionTypes", "{", "if", "v", ",", "ok", ":=", "typeMap", "[", "typename", "]", ";", "ok", "{", "switch", "typename", "{", "case", "\"", "\"", ":", "pf", ".", "addImport", "(", "apiDef", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "case", "\"", "\"", ":", "pf", ".", "addImport", "(", "apiDef", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "case", "\"", "\"", ":", "pf", ".", "addImport", "(", "apiDef", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "default", ":", "pf", ".", "addImport", "(", "apiDef", ",", "\"", "\"", "+", "typename", ",", "typename", ")", "\n", "}", "\n", "pf", ".", "UnionTypes", "=", "append", "(", "pf", ".", "UnionTypes", ",", "v", ")", "\n", "}", "\n\n", "pf", ".", "Type", "=", "t", "\n", "}", "\n", "case", "strings", ".", "Index", "(", "t", ",", "\"", "\"", ")", ">", "1", ":", "pf", ".", "Type", "=", "t", "[", "strings", ".", "Index", "(", "t", ",", "\"", "\"", ")", "+", "1", ":", "]", "\n", "default", ":", "pf", ".", "Type", "=", "t", "\n", "pf", ".", "addImport", "(", "apiDef", ",", "\"", "\"", "+", "t", ",", "t", ")", "\n", "}", "\n", "}" ]

[ "convert", "from", "raml", "Type", "to", "python", "type" ]

[ "func", "Get", "(", "typ", ",", "format", "string", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "switch", "typ", "{", "case", "\"", "\"", ":", "return", "get", "(", "\"", "\"", ")", "\n", "case", "\"", "\"", ":", "return", "get", "(", "\"", "\"", ")", "\n", "case", "\"", "\"", ":", "return", "get", "(", "\"", "\"", ")", "\n", "case", "\"", "\"", ":", "if", "format", "==", "\"", "\"", "||", "strings", ".", "ToUpper", "(", "format", ")", "==", "\"", "\"", "{", "return", "get", "(", "\"", "\"", ")", "\n", "}", "else", "if", "strings", ".", "ToUpper", "(", "format", ")", "==", "\"", "\"", "{", "return", "get", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "return", "[", "]", "byte", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "typ", ",", "format", ")", "\n", "}" ]

[ "Get", "gets", "Go", "code", "of", "a", "specific", "RAML", "Date", "type", "The", "code", "returned", "is", "without", "package", "date", "line" ]

[ "func", "(", "apiDef", "*", "APIDefinition", ")", "FindLibFile", "(", "name", "string", ")", "(", "string", ",", "string", ")", "{", "// search in it's document", "if", "filename", ",", "ok", ":=", "apiDef", ".", "Uses", "[", "name", "]", ";", "ok", "{", "return", "\"", "\"", ",", "filename", "\n", "}", "\n\n", "// search in included libraries", "for", "_", ",", "lib", ":=", "range", "apiDef", ".", "Libraries", "{", "if", "filename", ",", "ok", ":=", "lib", ".", "Uses", "[", "name", "]", ";", "ok", "{", "return", "filepath", ".", "Dir", "(", "lib", ".", "Filename", ")", ",", "filename", "\n", "}", "\n", "}", "\n", "return", "\"", "\"", ",", "\"", "\"", "\n", "}" ]

[ "FindLibFile", "find", "lbrary", "dir", "and", "file", "by", "it", "s", "name", "we", "also", "search", "from", "included", "library" ]

[ "func", "(", "apiDef", "*", "APIDefinition", ")", "GetSecurityScheme", "(", "name", "string", ")", "(", "SecurityScheme", ",", "bool", ")", "{", "var", "ss", "SecurityScheme", "\n", "var", "ok", "bool", "\n\n", "// split library name by '.'", "// if there is '.', it means we need to look from the library", "splitted", ":=", "strings", ".", "Split", "(", "strings", ".", "TrimSpace", "(", "name", ")", ",", "\"", "\"", ")", "\n\n", "switch", "len", "(", "splitted", ")", "{", "case", "1", ":", "ss", ",", "ok", "=", "apiDef", ".", "SecuritySchemes", "[", "name", "]", "\n", "case", "2", ":", "var", "l", "*", "Library", "\n", "l", ",", "ok", "=", "apiDef", ".", "Libraries", "[", "splitted", "[", "0", "]", "]", "\n", "if", "!", "ok", "{", "return", "ss", ",", "false", "\n", "}", "\n", "ss", ",", "ok", "=", "l", ".", "SecuritySchemes", "[", "splitted", "[", "1", "]", "]", "\n", "}", "\n", "return", "ss", ",", "ok", "\n", "}" ]

[ "GetSecurityScheme", "gets", "security", "scheme", "by", "it", "s", "name", "it", "also", "search", "in", "included", "library" ]

[ "func", "(", "apiDef", "*", "APIDefinition", ")", "createType", "(", "name", "string", ",", "tip", "interface", "{", "}", ",", "inputProps", "map", "[", "interface", "{", "}", "]", "interface", "{", "}", ")", "bool", "{", "created", ":=", "false", "\n", "// check that there is no type with this name", "if", "_", ",", "exist", ":=", "apiDef", ".", "Types", "[", "name", "]", ";", "exist", "{", "return", "created", "\n", "}", "\n\n", "// convert the inputProps to properties", "props", ":=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n\n", "for", "k", ",", "p", ":=", "range", "inputProps", "{", "name", ",", "ok", ":=", "k", ".", "(", "string", ")", "\n", "if", "!", "ok", "{", "panic", "(", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "k", ")", ")", "\n", "}", "\n", "props", "[", "name", "]", "=", "p", "\n", "}", "\n\n", "t", ":=", "Type", "{", "Name", ":", "name", ",", "Type", ":", "tip", ",", "Properties", ":", "props", ",", "}", "\n", "apiDef", ".", "Types", "[", "name", "]", "=", "t", "\n", "created", "=", "true", "\n", "return", "created", "\n", "}" ]

[ "create", "new", "type" ]

[ "func", "IsJSONString", "(", "s", "string", ")", "bool", "{", "s", "=", "strings", ".", "TrimSpace", "(", "s", ")", "\n", "return", "strings", ".", "HasPrefix", "(", "s", ",", "\"", "\"", ")", "&&", "strings", ".", "HasSuffix", "(", "s", ",", "\"", "\"", ")", "\n", "}" ]

[ "IsJSONString", "returns", "true", "if", "a", "string", "is", "a", "JSON", "string" ]

[ "func", "(", "gs", "*", "goSecurity", ")", "generate", "(", "dir", "string", ")", "error", "{", "fileName", ":=", "path", ".", "Join", "(", "dir", ",", "\"", "\"", "+", "gs", ".", "Name", "+", "\"", "\"", ")", "\n", "return", "commons", ".", "GenerateFile", "(", "gs", ",", "\"", "\"", ",", "\"", "\"", ",", "fileName", ",", "true", ")", "\n", "}" ]

[ "generate", "Go", "representation", "of", "a", "security", "scheme", "it", "implemented", "as", "struct", "based", "middleware" ]

[ "func", "newClass", "(", "apiDef", "*", "raml", ".", "APIDefinition", ",", "T", "raml", ".", "Type", ",", "name", "string", ",", "description", "string", ",", "properties", "map", "[", "string", "]", "interface", "{", "}", ",", "capnp", "bool", ")", "class", "{", "pc", ":=", "class", "{", "name", ":", "name", ",", "Description", ":", "commons", ".", "ParseDescription", "(", "description", ")", ",", "Fields", ":", "map", "[", "string", "]", "field", "{", "}", ",", "T", ":", "T", ",", "Capnp", ":", "capnp", ",", "imports", ":", "make", "(", "map", "[", "string", "]", "struct", "{", "}", ")", ",", "}", "\n\n", "if", "pc", ".", "T", ".", "IsAlias", "(", ")", "{", "return", "pc", "\n", "}", "\n\n", "// initialize the fields", "types", ":=", "globAPIDef", ".", "Types", "\n\n", "typeHierarchy", ":=", "getTypeHierarchy", "(", "name", ",", "T", ",", "types", ")", "\n", "ramlTypes", ":=", "make", "(", "[", "]", "raml", ".", "Type", ",", "0", ")", "\n", "for", "_", ",", "v", ":=", "range", "typeHierarchy", "{", "for", "_", ",", "iv", ":=", "range", "v", "{", "ramlTypes", "=", "append", "(", "ramlTypes", ",", "iv", ")", "\n", "}", "\n", "}", "\n", "mergedProps", ":=", "getTypeProperties", "(", "ramlTypes", ")", "\n", "for", "k", ",", "v", ":=", "range", "properties", "{", "prop", ":=", "raml", ".", "ToProperty", "(", "k", ",", "v", ")", "\n", "mergedProps", "[", "k", "]", "=", "prop", "\n", "}", "\n\n", "for", "propName", ",", "propInterface", ":=", "range", "mergedProps", "{", "op", ":=", "objectProperties", "(", "propName", ",", "propInterface", ")", "\n", "field", ",", "err", ":=", "newField", "(", "name", ",", "apiDef", ",", "T", ",", "propName", ",", "propInterface", ",", "types", ",", "op", ",", "typeHierarchy", ")", "\n", "if", "err", "!=", "nil", "{", "continue", "\n", "}", "\n\n", "pc", ".", "Fields", "[", "field", ".", "Name", "]", "=", "field", "\n", "}", "\n\n", "return", "pc", "\n", "}" ]

[ "create", "a", "python", "class", "representations" ]

[ "func", "ChildProperties", "(", "Properties", "map", "[", "string", "]", "interface", "{", "}", ")", "[", "]", "raml", ".", "Property", "{", "props", ":=", "make", "(", "[", "]", "raml", ".", "Property", ",", "0", ")", "\n\n", "for", "propName", ",", "propInterface", ":=", "range", "Properties", "{", "props", "=", "append", "(", "props", ",", "raml", ".", "ToProperty", "(", "propName", ",", "propInterface", ")", ")", "\n", "}", "\n\n", "return", "props", "\n", "}" ]

[ "ChildProperties", "returns", "child", "properties", "of", "a", "property" ]

[ "func", "(", "pc", "*", "class", ")", "generate", "(", "dir", ",", "template", ",", "name", "string", ")", "(", "[", "]", "string", ",", "error", ")", "{", "fileName", ":=", "filepath", ".", "Join", "(", "dir", ",", "pc", ".", "Name", "(", ")", "+", "\"", "\"", ")", "\n\n", "if", "pc", ".", "AliasOf", "!=", "\"", "\"", "{", "return", "[", "]", "string", "{", "pc", ".", "Name", "(", ")", "}", ",", "commons", ".", "GenerateFile", "(", "pc", ",", "\"", "\"", ",", "\"", "\"", ",", "fileName", ",", "true", ")", "\n", "}", "\n\n", "// generate enums", "typeNames", ":=", "make", "(", "[", "]", "string", ",", "0", ")", "\n", "for", "_", ",", "f", ":=", "range", "pc", ".", "Fields", "{", "if", "f", ".", "Enum", "!=", "nil", "{", "typeNames", "=", "append", "(", "typeNames", ",", "f", ".", "Enum", ".", "Name", ")", "\n", "if", "err", ":=", "f", ".", "Enum", ".", "generate", "(", "dir", ")", ";", "err", "!=", "nil", "{", "return", "typeNames", ",", "err", "\n", "}", "\n", "}", "\n", "}", "\n\n", "if", "pc", ".", "Enum", "!=", "nil", "{", "typeNames", "=", "append", "(", "typeNames", ",", "pc", ".", "Enum", ".", "Name", ")", "\n", "return", "typeNames", ",", "pc", ".", "Enum", ".", "generate", "(", "dir", ")", "\n", "}", "\n\n", "typeNames", "=", "append", "(", "typeNames", ",", "pc", ".", "Name", "(", ")", ")", "\n", "return", "typeNames", ",", "commons", ".", "GenerateFile", "(", "pc", ",", "template", ",", "name", ",", "fileName", ",", "true", ")", "\n", "}" ]

[ "generate", "a", "python", "class", "file" ]

[ "func", "(", "pc", "*", "class", ")", "Imports", "(", ")", "[", "]", "string", "{", "for", "_", ",", "field", ":=", "range", "pc", ".", "Fields", "{", "for", "_", ",", "imp", ":=", "range", "field", ".", "imports", "{", "// do not import ourself", "if", "imp", ".", "Name", "==", "pc", ".", "Name", "(", ")", "{", "continue", "\n", "}", "\n", "pc", ".", "addImport", "(", "imp", ".", "Module", ",", "imp", ".", "Name", ")", "\n", "}", "\n", "}", "\n\n", "return", "commons", ".", "MapToSortedStrings", "(", "pc", ".", "imports", ")", "\n", "}" ]

[ "return", "list", "of", "import", "statements" ]

[ "func", "GenerateAllClasses", "(", "apiDef", "*", "raml", ".", "APIDefinition", ",", "dir", "string", ",", "capnp", "bool", ")", "(", "[", "]", "string", ",", "error", ")", "{", "// array of tip that need to be generated in the end of this", "// process. because it needs other object to be registered first", "delayedMI", ":=", "[", "]", "string", "{", "}", "// delayed multiple inheritance", "\n", "template", ":=", "\"", "\"", "\n", "templateName", ":=", "\"", "\"", "\n\n", "names", ":=", "[", "]", "string", "{", "}", "\n", "for", "name", ",", "t", ":=", "range", "types", ".", "AllTypes", "(", "apiDef", ",", "\"", "\"", ")", "{", "var", "errGen", "error", "\n", "var", "results", "[", "]", "string", "\n", "switch", "tip", ":=", "t", ".", "Type", ".", "(", "type", ")", "{", "case", "string", ":", "rt", ":=", "raml", ".", "Type", "{", "Type", ":", "tip", ",", "}", "\n", "if", "rt", ".", "IsMultipleInheritance", "(", ")", "{", "delayedMI", "=", "append", "(", "delayedMI", ",", "tip", ")", "\n", "}", "\n", "case", "types", ".", "TypeInBody", ":", "newTipName", ":=", "types", ".", "PascalCaseTypeName", "(", "tip", ")", "\n", "pc", ":=", "newClass", "(", "apiDef", ",", "raml", ".", "Type", "{", "Type", ":", "\"", "\"", "}", ",", "newTipName", ",", "\"", "\"", ",", "tip", ".", "Properties", ",", "capnp", ")", "\n", "results", ",", "errGen", "=", "pc", ".", "generate", "(", "dir", ",", "template", ",", "templateName", ")", "\n", "case", "raml", ".", "Type", ":", "if", "name", "==", "\"", "\"", "{", "continue", "\n", "}", "\n", "pc", ":=", "newClassFromType", "(", "apiDef", ",", "tip", ",", "name", ",", "capnp", ")", "\n", "results", ",", "errGen", "=", "pc", ".", "generate", "(", "dir", ",", "template", ",", "templateName", ")", "\n", "}", "\n\n", "if", "errGen", "!=", "nil", "{", "return", "names", ",", "errGen", "\n", "}", "\n", "names", "=", "append", "(", "names", ",", "results", "...", ")", "\n", "}", "\n\n", "for", "_", ",", "tip", ":=", "range", "delayedMI", "{", "rt", ":=", "raml", ".", "Type", "{", "Type", ":", "tip", ",", "}", "\n", "if", "parents", ",", "isMult", ":=", "rt", ".", "MultipleInheritance", "(", ")", ";", "isMult", "{", "pc", ":=", "newClassFromType", "(", "apiDef", ",", "rt", ",", "strings", ".", "Join", "(", "parents", ",", "\"", "\"", ")", ",", "capnp", ")", "\n", "results", ",", "err", ":=", "pc", ".", "generate", "(", "dir", ",", "template", ",", "templateName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "names", ",", "err", "\n", "}", "\n", "names", "=", "append", "(", "names", ",", "results", "...", ")", "\n", "}", "\n\n", "}", "\n", "return", "names", ",", "nil", "\n\n", "}" ]

[ "generate", "all", "python", "classes", "from", "a", "RAML", "document" ]

[ "func", "newFieldDef", "(", "apiDef", "*", "raml", ".", "APIDefinition", ",", "structName", "string", ",", "prop", "raml", ".", "Property", ",", "pkg", "string", ")", "fieldDef", "{", "var", "(", "fieldType", "=", "prop", ".", "TypeString", "(", ")", "// the field type", "\n", "basicType", "=", "commons", ".", "GetBasicType", "(", "fieldType", ")", "// basic type of the field type", "\n", ")", "\n\n", "// for the types, check first if it is user defined type", "if", "_", ",", "ok", ":=", "apiDef", ".", "Types", "[", "basicType", "]", ";", "ok", "{", "titledType", ":=", "strings", ".", "Title", "(", "basicType", ")", "\n\n", "// check if it is a recursive type", "if", "titledType", "==", "strings", ".", "Title", "(", "structName", ")", "{", "titledType", "=", "\"", "\"", "+", "titledType", "// add `pointer`, otherwise compiler will complain", "\n", "}", "\n\n", "// use strings.Replace instead of simple assignment because the fieldType", "// might be an array", "fieldType", "=", "strings", ".", "Replace", "(", "fieldType", ",", "basicType", ",", "titledType", ",", "1", ")", "\n", "}", "\n", "fieldType", "=", "convertToGoType", "(", "fieldType", ",", "prop", ".", "Items", ".", "Type", ")", "\n\n", "fd", ":=", "fieldDef", "{", "Name", ":", "formatFieldName", "(", "prop", ".", "Name", ")", ",", "fieldType", ":", "fieldType", ",", "IsOmitted", ":", "!", "prop", ".", "Required", ",", "}", "\n\n", "fd", ".", "buildValidators", "(", "prop", ")", "\n\n", "if", "prop", ".", "IsEnum", "(", ")", "{", "fd", ".", "Enum", "=", "newEnum", "(", "structName", ",", "prop", ",", "pkg", ",", "false", ")", "\n", "fd", ".", "fieldType", "=", "fd", ".", "Enum", ".", "Name", "\n", "}", "\n\n", "return", "fd", "\n", "}" ]

[ "newFieldDef", "creates", "new", "struct", "field", "from", "raml", "property", "." ]

[ "func", "formatFieldName", "(", "name", "string", ")", "string", "{", "var", "formatted", "string", "\n", "for", "_", ",", "v", ":=", "range", "strings", ".", "Split", "(", "name", ",", "\"", "\"", ")", "{", "formatted", "+=", "strings", ".", "Title", "(", "v", ")", "\n", "}", "\n", "return", "formatted", "\n", "}" ]

[ "format", "struct", "s", "field", "name", "-", "Title", "it", "-", "replace", "-", "with", "camel", "case", "version" ]

[ "func", "(", "sm", "*", "serverMethod", ")", "setup", "(", "apiDef", "*", "raml", ".", "APIDefinition", ",", "r", "*", "raml", ".", "Resource", ",", "rd", "*", "resource", ".", "Resource", ",", "resourceParams", "[", "]", "string", ")", "error", "{", "sm", ".", "MethodName", "=", "commons", ".", "SnackCaseServerMethodName", "(", "sm", ".", "DisplayName", ",", "sm", ".", "Verb", "(", ")", ",", "r", ")", "\n\n", "if", "commons", ".", "HasJSONBody", "(", "&", "(", "sm", ".", "Bodies", ")", ")", "{", "// TODO : make it to call proper func", "sm", ".", "reqBody", "=", "casee", ".", "ToPascalCase", "(", "sm", ".", "MethodName", "+", "commons", ".", "ReqBodySuffix", ")", "\n", "}", "\n\n", "sm", ".", "Params", "=", "strings", ".", "Join", "(", "resourceParams", ",", "\"", "\"", ")", "\n", "sm", ".", "Endpoint", "=", "strings", ".", "Replace", "(", "sm", ".", "Endpoint", ",", "\"", "\"", ",", "\"", "\"", ",", "-", "1", ")", "\n", "sm", ".", "Endpoint", "=", "strings", ".", "Replace", "(", "sm", ".", "Endpoint", ",", "\"", "\"", ",", "\"", "\"", ",", "-", "1", ")", "\n\n", "// security middlewares", "for", "_", ",", "v", ":=", "range", "sm", ".", "SecuredBy", "{", "if", "!", "security", ".", "ValidateScheme", "(", "v", ".", "Name", ",", "apiDef", ")", "{", "continue", "\n", "}", "\n", "// oauth2 middleware", "m", ",", "err", ":=", "newPythonOauth2Middleware", "(", "v", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "sm", ".", "MiddlewaresArr", "=", "append", "(", "sm", ".", "MiddlewaresArr", ",", "m", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "setup", "sets", "all", "needed", "variables" ]

[ "func", "NewFlaskServer", "(", "apiDef", "*", "raml", ".", "APIDefinition", ",", "apiDocsDir", ",", "targetDir", "string", ",", "withMain", "bool", ",", "libRootURLs", "[", "]", "string", ",", "gevent", "bool", ")", "*", "FlaskServer", "{", "// TODO : get rid of this global variables", "globAPIDef", "=", "apiDef", "\n", "globLibRootURLs", "=", "libRootURLs", "\n\n", "// generates resource", "var", "prs", "[", "]", "pythonResource", "\n", "for", "_", ",", "rd", ":=", "range", "getServerResourcesDefs", "(", "apiDef", ")", "{", "pr", ":=", "newResource", "(", "rd", ",", "apiDef", ",", "serverKindFlask", ")", "\n", "prs", "=", "append", "(", "prs", ",", "pr", ")", "\n", "}", "\n\n", "templates", ":=", "templates", "(", "serverKindFlask", ")", "\n\n", "return", "&", "FlaskServer", "{", "APIDef", ":", "apiDef", ",", "Title", ":", "apiDef", ".", "Title", ",", "apiDocsDir", ":", "apiDocsDir", ",", "WithMain", ":", "withMain", ",", "ResourcesDef", ":", "prs", ",", "Gevent", ":", "gevent", ",", "Template", ":", "templates", ",", "targetDir", ":", "targetDir", ",", "}", "\n", "}" ]

[ "NewFlaskServer", "creates", "new", "flask", "server", "from", "an", "RAML", "file" ]

[ "func", "initTraitDicts", "(", "r", "*", "Resource", ",", "m", "*", "Method", ",", "dicts", "map", "[", "string", "]", "interface", "{", "}", ")", "map", "[", "string", "]", "interface", "{", "}", "{", "dicts", "=", "initResourceTypeDicts", "(", "r", ",", "dicts", ")", "\n", "dicts", "[", "\"", "\"", "]", "=", "strings", ".", "ToLower", "(", "m", ".", "Name", ")", "\n", "return", "dicts", "\n", "}" ]

[ "init", "trait", "dicts", "trait", "dicts", "contain", "current", "trait", "parameters", "that", "is", "currently", "applied", "to", "a", "method" ]

[ "func", "NewServer", "(", "apiDef", "*", "raml", ".", "APIDefinition", ",", "packageName", ",", "apiDocsDir", ",", "rootImportPath", "string", ",", "withMain", "bool", ",", "targetDir", "string", ",", "libsRootURLs", "[", "]", "string", ")", "*", "Server", "{", "// global variables", "rootImportPath", "=", "setRootImportPath", "(", "rootImportPath", ",", "targetDir", ")", "\n", "globAPIDef", "=", "apiDef", "\n", "globRootImportPath", "=", "rootImportPath", "\n", "globLibRootURLs", "=", "libsRootURLs", "\n\n", "return", "&", "Server", "{", "apiDef", ":", "apiDef", ",", "PackageName", ":", "packageName", ",", "apiDocsDir", ":", "apiDocsDir", ",", "withMain", ":", "withMain", ",", "RootImportPath", ":", "rootImportPath", ",", "TargetDir", ":", "targetDir", ",", "libsRootURLs", ":", "libsRootURLs", ",", "}", "\n", "}" ]

[ "NewServer", "creates", "a", "new", "Golang", "server" ]

[ "func", "(", "gs", "*", "Server", ")", "Generate", "(", ")", "error", "{", "if", "err", ":=", "commons", ".", "CheckDuplicatedTitleTypes", "(", "gs", ".", "apiDef", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "gs", ".", "RootImportPath", "==", "\"", "\"", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "// helper package", "gh", ":=", "goramlHelper", "{", "rootImportPath", ":", "gs", ".", "RootImportPath", ",", "packageName", ":", "\"", "\"", ",", "packageDir", ":", "\"", "\"", ",", "}", "\n", "if", "err", ":=", "gh", ".", "generate", "(", "gs", ".", "TargetDir", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "generateAllStructs", "(", "gs", ".", "apiDef", ",", "gs", ".", "TargetDir", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// security scheme", "if", "err", ":=", "generateSecurity", "(", "gs", ".", "apiDef", ".", "SecuritySchemes", ",", "gs", ".", "TargetDir", ",", "gs", ".", "PackageName", ")", ";", "err", "!=", "nil", "{", "log", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n\n", "// genereate resources", "rds", ",", "err", ":=", "gs", ".", "generateServerResources", "(", "gs", ".", "TargetDir", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "gs", ".", "ResourcesDef", "=", "rds", "\n\n", "// libraries", "if", "err", ":=", "generateLibraries", "(", "gs", ".", "apiDef", ".", "Libraries", ",", "gs", ".", "TargetDir", ",", "gs", ".", "libsRootURLs", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// routes", "if", "err", ":=", "commons", ".", "GenerateFile", "(", "gs", ",", "\"", "\"", ",", "\"", "\"", ",", "filepath", ".", "Join", "(", "gs", ".", "TargetDir", ",", "\"", "\"", ")", ",", "true", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// generate main", "if", "gs", ".", "withMain", "{", "// HTML front page", "if", "err", ":=", "commons", ".", "GenerateFile", "(", "gs", ",", "\"", "\"", ",", "\"", "\"", ",", "filepath", ".", "Join", "(", "gs", ".", "TargetDir", ",", "\"", "\"", ")", ",", "false", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "// main file", "return", "commons", ".", "GenerateFile", "(", "gs", ",", "\"", "\"", ",", "\"", "\"", ",", "filepath", ".", "Join", "(", "gs", ".", "TargetDir", ",", "\"", "\"", ")", ",", "true", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Generate", "implements", "codegen", ".", "Server", ".", "Generate", "interface" ]

[ "func", "NewClient", "(", "apiDef", "*", "raml", ".", "APIDefinition", ",", "packageName", ",", "rootImportPath", ",", "targetDir", "string", ",", "libsRootURLs", "[", "]", "string", ")", "(", "Client", ",", "error", ")", "{", "// rootImportPath only needed if we use libraries", "if", "rootImportPath", "==", "\"", "\"", "&&", "len", "(", "apiDef", ".", "Libraries", ")", ">", "0", "{", "return", "Client", "{", "}", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// TODO : get rid of this global variable", "rootImportPath", "=", "setRootImportPath", "(", "rootImportPath", ",", "targetDir", ")", "\n", "globRootImportPath", "=", "rootImportPath", "\n", "globAPIDef", "=", "apiDef", "\n", "globLibRootURLs", "=", "libsRootURLs", "\n\n", "// creates client services objects", "services", ":=", "map", "[", "string", "]", "*", "ClientService", "{", "}", "\n", "for", "endpoint", ",", "res", ":=", "range", "apiDef", ".", "Resources", "{", "rd", ":=", "resource", ".", "New", "(", "apiDef", ",", "&", "res", ",", "commons", ".", "NormalizeURITitle", "(", "endpoint", ")", ",", "true", ")", "\n", "services", "[", "endpoint", "]", "=", "newClientService", "(", "endpoint", ",", "packageName", ",", "&", "rd", ")", "\n", "}", "\n\n", "// creates client object", "client", ":=", "Client", "{", "apiDef", ":", "apiDef", ",", "Name", ":", "commons", ".", "NormalizeIdentifier", "(", "commons", ".", "NormalizeURI", "(", "apiDef", ".", "Title", ")", ")", ",", "BaseURI", ":", "apiDef", ".", "BaseURI", ",", "libraries", ":", "apiDef", ".", "Libraries", ",", "PackageName", ":", "packageName", ",", "RootImportPath", ":", "rootImportPath", ",", "Services", ":", "services", ",", "TargetDir", ":", "targetDir", ",", "libsRootURLs", ":", "libsRootURLs", ",", "}", "\n\n", "if", "strings", ".", "Index", "(", "client", ".", "BaseURI", ",", "\"", "\"", ")", ">", "0", "{", "client", ".", "BaseURI", "=", "strings", ".", "Replace", "(", "client", ".", "BaseURI", ",", "\"", "\"", ",", "apiDef", ".", "Version", ",", "-", "1", ")", "\n", "}", "\n", "return", "client", ",", "nil", "\n", "}" ]

[ "NewClient", "creates", "a", "new", "Golang", "client" ]

[ "func", "(", "gc", "Client", ")", "Generate", "(", ")", "error", "{", "if", "err", ":=", "commons", ".", "CheckDuplicatedTitleTypes", "(", "gc", ".", "apiDef", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "// helper package", "gh", ":=", "goramlHelper", "{", "packageName", ":", "\"", "\"", ",", "packageDir", ":", "\"", "\"", ",", "}", "\n", "if", "err", ":=", "gh", ".", "generate", "(", "gc", ".", "TargetDir", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// generate struct", "if", "err", ":=", "generateAllStructs", "(", "gc", ".", "apiDef", ",", "gc", ".", "TargetDir", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// libraries", "if", "err", ":=", "generateLibraries", "(", "gc", ".", "libraries", ",", "gc", ".", "TargetDir", ",", "gc", ".", "libsRootURLs", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "gc", ".", "generateHelperFile", "(", "gc", ".", "TargetDir", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "gc", ".", "generateSecurity", "(", "gc", ".", "TargetDir", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "gc", ".", "generateServices", "(", "gc", ".", "TargetDir", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "gc", ".", "generateClientFile", "(", "gc", ".", "TargetDir", ")", "\n", "}" ]

[ "Generate", "generates", "all", "Go", "client", "files" ]

[ "func", "(", "gc", "*", "Client", ")", "generateHelperFile", "(", "dir", "string", ")", "error", "{", "fileName", ":=", "filepath", ".", "Join", "(", "dir", ",", "\"", "\"", ")", "\n", "return", "commons", ".", "GenerateFile", "(", "gc", ",", "\"", "\"", ",", "\"", "\"", ",", "fileName", ",", "true", ")", "\n", "}" ]

[ "generate", "Go", "client", "helper" ]

[ "func", "(", "gc", "*", "Client", ")", "generateClientFile", "(", "dir", "string", ")", "error", "{", "fileName", ":=", "filepath", ".", "Join", "(", "dir", ",", "\"", "\"", "+", "strings", ".", "ToLower", "(", "gc", ".", "Name", ")", "+", "\"", "\"", ")", "\n", "return", "commons", ".", "GenerateFile", "(", "gc", ",", "\"", "\"", ",", "\"", "\"", ",", "fileName", ",", "true", ")", "\n", "}" ]

[ "generate", "Go", "client", "lib", "file" ]

[ "func", "(", "f", "field", ")", "EscapedName", "(", ")", "string", "{", "name", ":=", "f", ".", "Name", "\n", "if", "_", ",", "ok", ":=", "nimKeywords", "[", "name", "]", ";", "!", "ok", "{", "return", "name", "\n", "}", "\n", "return", "\"", "\"", "+", "name", "+", "\"", "\"", "\n", "}" ]

[ "EscapedName", "produces", "escaped", "name", "of", "Nim", "keyword", "or", "return", "as", "is", "if", "it", "is", "not", "Nim", "keyword" ]

[ "func", "(", "rt", "*", "ResourceType", ")", "setMethods", "(", "traitsMap", "map", "[", "string", "]", "Trait", ",", "apiDef", "*", "APIDefinition", ")", "{", "if", "rt", ".", "Get", "!=", "nil", "{", "rt", ".", "Get", ".", "Name", "=", "\"", "\"", "\n", "rt", ".", "Get", ".", "inheritFromTraits", "(", "nil", ",", "append", "(", "rt", ".", "Is", ",", "rt", ".", "Get", ".", "Is", "...", ")", ",", "traitsMap", ",", "apiDef", ")", "\n", "rt", ".", "methods", "=", "append", "(", "rt", ".", "methods", ",", "rt", ".", "Get", ")", "\n", "}", "\n", "if", "rt", ".", "Post", "!=", "nil", "{", "rt", ".", "Post", ".", "Name", "=", "\"", "\"", "\n", "rt", ".", "Post", ".", "inheritFromTraits", "(", "nil", ",", "append", "(", "rt", ".", "Is", ",", "rt", ".", "Post", ".", "Is", "...", ")", ",", "traitsMap", ",", "apiDef", ")", "\n", "rt", ".", "methods", "=", "append", "(", "rt", ".", "methods", ",", "rt", ".", "Post", ")", "\n", "}", "\n", "if", "rt", ".", "Put", "!=", "nil", "{", "rt", ".", "Put", ".", "Name", "=", "\"", "\"", "\n", "rt", ".", "Put", ".", "inheritFromTraits", "(", "nil", ",", "append", "(", "rt", ".", "Is", ",", "rt", ".", "Put", ".", "Is", "...", ")", ",", "traitsMap", ",", "apiDef", ")", "\n", "rt", ".", "methods", "=", "append", "(", "rt", ".", "methods", ",", "rt", ".", "Put", ")", "\n", "}", "\n", "if", "rt", ".", "Patch", "!=", "nil", "{", "rt", ".", "Patch", ".", "Name", "=", "\"", "\"", "\n", "rt", ".", "Patch", ".", "inheritFromTraits", "(", "nil", ",", "append", "(", "rt", ".", "Is", ",", "rt", ".", "Patch", ".", "Is", "...", ")", ",", "traitsMap", ",", "apiDef", ")", "\n", "rt", ".", "methods", "=", "append", "(", "rt", ".", "methods", ",", "rt", ".", "Patch", ")", "\n", "}", "\n", "if", "rt", ".", "Head", "!=", "nil", "{", "rt", ".", "Head", ".", "Name", "=", "\"", "\"", "\n", "rt", ".", "Head", ".", "inheritFromTraits", "(", "nil", ",", "append", "(", "rt", ".", "Is", ",", "rt", ".", "Head", ".", "Is", "...", ")", ",", "traitsMap", ",", "apiDef", ")", "\n", "rt", ".", "methods", "=", "append", "(", "rt", ".", "methods", ",", "rt", ".", "Head", ")", "\n", "}", "\n", "if", "rt", ".", "Delete", "!=", "nil", "{", "rt", ".", "Delete", ".", "Name", "=", "\"", "\"", "\n", "rt", ".", "Delete", ".", "inheritFromTraits", "(", "nil", ",", "append", "(", "rt", ".", "Is", ",", "rt", ".", "Delete", ".", "Is", "...", ")", ",", "traitsMap", ",", "apiDef", ")", "\n", "rt", ".", "methods", "=", "append", "(", "rt", ".", "methods", ",", "rt", ".", "Delete", ")", "\n", "}", "\n", "if", "rt", ".", "Options", "!=", "nil", "{", "rt", ".", "Options", ".", "Name", "=", "\"", "\"", "\n", "rt", ".", "Options", ".", "inheritFromTraits", "(", "nil", ",", "append", "(", "rt", ".", "Is", ",", "rt", ".", "Options", ".", "Is", "...", ")", ",", "traitsMap", ",", "apiDef", ")", "\n", "rt", ".", "methods", "=", "append", "(", "rt", ".", "methods", ",", "rt", ".", "Options", ")", "\n", "}", "\n", "}" ]

[ "set", "methods", "set", "all", "methods", "name", "and", "add", "it", "to", "methods", "slice" ]

[ "func", "(", "rt", "*", "ResourceType", ")", "setOptionalMethods", "(", ")", "{", "if", "rt", ".", "OptionalGet", "!=", "nil", "{", "rt", ".", "OptionalGet", ".", "Name", "=", "\"", "\"", "\n", "rt", ".", "optionalMethods", "=", "append", "(", "rt", ".", "optionalMethods", ",", "rt", ".", "OptionalGet", ")", "\n", "}", "\n", "if", "rt", ".", "OptionalPost", "!=", "nil", "{", "rt", ".", "OptionalPost", ".", "Name", "=", "\"", "\"", "\n", "rt", ".", "optionalMethods", "=", "append", "(", "rt", ".", "optionalMethods", ",", "rt", ".", "OptionalPost", ")", "\n", "}", "\n", "if", "rt", ".", "OptionalPut", "!=", "nil", "{", "rt", ".", "OptionalPut", ".", "Name", "=", "\"", "\"", "\n", "rt", ".", "optionalMethods", "=", "append", "(", "rt", ".", "optionalMethods", ",", "rt", ".", "OptionalPut", ")", "\n", "}", "\n", "if", "rt", ".", "OptionalPatch", "!=", "nil", "{", "rt", ".", "OptionalPatch", ".", "Name", "=", "\"", "\"", "\n", "rt", ".", "optionalMethods", "=", "append", "(", "rt", ".", "optionalMethods", ",", "rt", ".", "OptionalPatch", ")", "\n", "}", "\n", "if", "rt", ".", "OptionalHead", "!=", "nil", "{", "rt", ".", "OptionalHead", ".", "Name", "=", "\"", "\"", "\n", "rt", ".", "optionalMethods", "=", "append", "(", "rt", ".", "optionalMethods", ",", "rt", ".", "OptionalHead", ")", "\n", "}", "\n", "if", "rt", ".", "OptionalDelete", "!=", "nil", "{", "rt", ".", "OptionalDelete", ".", "Name", "=", "\"", "\"", "\n", "rt", ".", "optionalMethods", "=", "append", "(", "rt", ".", "optionalMethods", ",", "rt", ".", "OptionalDelete", ")", "\n", "}", "\n", "if", "rt", ".", "OptionalOptions", "!=", "nil", "{", "rt", ".", "OptionalOptions", ".", "Name", "=", "\"", "\"", "\n", "rt", ".", "optionalMethods", "=", "append", "(", "rt", ".", "optionalMethods", ",", "rt", ".", "OptionalOptions", ")", "\n", "}", "\n", "}" ]

[ "setOptionalMethods", "set", "name", "of", "all", "optional", "methods", "and", "add", "it", "to", "optionalMethods", "slice" ]

[ "func", "mergeTypeName", "(", "name", ",", "rtName", "string", ",", "apiDef", "*", "APIDefinition", ")", "string", "{", "if", "apiDef", "==", "nil", "{", "log", ".", "Warning", "(", "\"", "\"", ")", "\n", "return", "name", "\n", "}", "\n\n", "// check if this resource type is in library", "splt", ":=", "strings", ".", "Split", "(", "rtName", ",", "\"", "\"", ")", "\n", "if", "len", "(", "splt", ")", "<", "2", "{", "// if not in library, we need to do nothing", "return", "name", "\n", "}", "\n\n", "// get the library object from API definition root object", "libName", ":=", "splt", "[", "0", "]", "\n", "lib", ",", "ok", ":=", "apiDef", ".", "Libraries", "[", "libName", "]", "\n", "if", "!", "ok", "{", "return", "name", "\n", "}", "\n\n", "// type not exist in the library", "if", "_", ",", "ok", ":=", "lib", ".", "Types", "[", "name", "]", ";", "!", "ok", "{", "return", "name", "\n", "}", "\n\n", "return", "strings", ".", "Join", "(", "[", "]", "string", "{", "libName", ",", "name", "}", ",", "\"", "\"", ")", "\n", "}" ]

[ "merge", "name", "of", "type", "with", "resource", "type", "name", "." ]

[ "func", "(", "command", "*", "ServerCommand", ")", "Execute", "(", ")", "error", "{", "var", "apiDocsDir", "string", "\n\n", "log", ".", "Infof", "(", "\"", "\"", ",", "command", ".", "Language", ")", "\n\n", "if", "!", "command", ".", "NoAPIDocs", "{", "apiDocsDir", "=", "\"", "\"", "\n", "}", "\n\n", "cs", ":=", "codegen", ".", "Server", "{", "RAMLFile", ":", "command", ".", "RamlFile", ",", "Kind", ":", "command", ".", "Kind", ",", "Dir", ":", "command", ".", "Dir", ",", "PackageName", ":", "command", ".", "PackageName", ",", "Lang", ":", "command", ".", "Language", ",", "APIDocsDir", ":", "apiDocsDir", ",", "RootImportPath", ":", "command", ".", "ImportPath", ",", "WithMain", ":", "!", "command", ".", "NoMainGeneration", ",", "LibRootURLs", ":", "strings", ".", "Split", "(", "command", ".", "LibRootURLs", ",", "\"", "\"", ")", ",", "}", "\n", "return", "cs", ".", "Generate", "(", ")", "\n", "}" ]

[ "Execute", "generates", "a", "Go", "server", "from", "an", "RAML", "specification" ]

[ "func", "NewAPIError", "(", "resp", "*", "http", ".", "Response", ",", "data", "interface", "{", "}", ")", "error", "{", "// read response body", "b", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "resp", ".", "Body", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// creates object", "goramlErr", ":=", "APIError", "{", "Code", ":", "resp", ".", "StatusCode", ",", "RawMessage", ":", "b", ",", "}", "\n\n", "// no need to parse in case of `data` is nil", "if", "data", "==", "nil", "{", "return", "goramlErr", "\n", "}", "\n\n", "// parse based on content type", "switch", "resp", ".", "Header", ".", "Get", "(", "\"", "\"", ")", "{", "case", "\"", "\"", ":", "err", "=", "json", ".", "Unmarshal", "(", "b", ",", "data", ")", "\n", "case", "\"", "\"", ":", "_", ",", "err", "=", "fmt", ".", "Sscanf", "(", "string", "(", "b", ")", ",", "\"", "\"", ",", "data", ")", "\n", "default", ":", "return", "goramlErr", "\n", "}", "\n\n", "if", "err", "==", "nil", "{", "goramlErr", ".", "Message", "=", "data", "\n", "}", "\n", "return", "goramlErr", "\n", "}" ]

[ "NewAPIError", "creates", "new", "APIError", "object", ".", "If", "data", "is", "nil", "it", "raw", "message", "won", "t", "be", "parsed", "." ]

[ "func", "(", "pr", "*", "pythonResource", ")", "setMiddlewares", "(", ")", "{", "for", "_", ",", "pm", ":=", "range", "pr", ".", "Methods", "{", "for", "_", ",", "m", ":=", "range", "pm", ".", "MiddlewaresArr", "{", "pr", ".", "addMiddleware", "(", "m", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "set", "middlewares", "to", "import" ]

[ "func", "getParentsObjs", "(", "parents", "[", "]", "string", ")", "[", "]", "raml", ".", "JSONSchema", "{", "objs", ":=", "[", "]", "raml", ".", "JSONSchema", "{", "}", "\n", "for", "_", ",", "p", ":=", "range", "parents", "{", "if", "v", ",", "ok", ":=", "jsObjects", "[", "p", "]", ";", "ok", "{", "objs", "=", "append", "(", "objs", ",", "v", ")", "\n", "}", "\n", "}", "\n", "return", "objs", "\n", "}" ]

[ "get", "JSON", "schema", "objects", "from", "array", "of", "JSON", "schema", "name" ]

[ "func", "jsArrayName", "(", "tip", "string", ")", "string", "{", "if", "!", "commons", ".", "IsArrayType", "(", "tip", ")", "{", "// make sure it is an array", "return", "tip", "\n", "}", "\n", "return", "\"", "\"", "+", "commons", ".", "GetBasicType", "(", "tip", ")", "\n", "}" ]

[ "return", "jsonschema", "name", "of", "new", "schema", "that", "created", "from", "an", "array" ]

[ "func", "(", "js", "jsonSchema", ")", "Generate", "(", "dir", "string", ")", "error", "{", "if", "js", ".", "Alias", ".", "Builtin", "{", "return", "nil", "// plain builtin type can't be a JSON", "\n", "}", "\n\n", "filename", ":=", "filepath", ".", "Join", "(", "dir", ",", "js", ".", "filename", "(", ")", ")", "\n", "ctx", ":=", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "js", ".", "String", "(", ")", ",", "}", "\n", "return", "commons", ".", "GenerateFile", "(", "ctx", ",", "\"", "\"", ",", "\"", "\"", ",", "filename", ",", "true", ")", "\n", "}" ]

[ "Generate", "generates", "a", "json", "file", "of", "this", "schema" ]

[ "func", "IsRemote", "(", "path", "string", ")", "bool", "{", "return", "strings", ".", "HasPrefix", "(", "path", ",", "\"", "\"", ")", "||", "strings", ".", "HasPrefix", "(", "path", ",", "\"", "\"", ")", "\n", "}" ]

[ "IsRemote", "returns", "true", "if", "this", "library", "is", "on", "the", "remote", "url" ]

[ "func", "StripLibRootURL", "(", "libFile", "string", ",", "libRootURLs", "[", "]", "string", ")", "string", "{", "if", "!", "IsRemote", "(", "libFile", ")", "{", "return", "libFile", "\n", "}", "\n", "for", "_", ",", "root", ":=", "range", "libRootURLs", "{", "if", "strings", ".", "HasPrefix", "(", "libFile", ",", "root", ")", "{", "libFile", "=", "strings", ".", "TrimPrefix", "(", "libFile", ",", "root", ")", "\n", "libFile", "=", "strings", ".", "TrimPrefix", "(", "libFile", ",", "\"", "\"", ")", "\n", "break", "\n", "}", "\n", "}", "\n", "return", "libFile", "\n", "}" ]

[ "StripLibRootURL", "strips", "root", "URL", "from", "library", "path" ]

[ "func", "setRootImportPath", "(", "importPath", ",", "targetDir", "string", ")", "string", "{", "// use import path if not empty", "if", "len", "(", "importPath", ")", ">", "0", "{", "return", "importPath", "\n", "}", "\n\n", "// get GOPATH dir", "gopath", ",", "err", ":=", "filepath", ".", "Abs", "(", "os", ".", "Getenv", "(", "\"", "\"", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "gopath", "=", "filepath", ".", "Join", "(", "gopath", ",", "\"", "\"", ")", "\n\n", "// get absolute target dir", "absTargetDir", ",", "err", ":=", "filepath", ".", "Abs", "(", "targetDir", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "\"", "\"", "+", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n\n", "// panic if user doesn't specify import path and target dir", "// not under GOPATH.", "if", "!", "strings", ".", "HasPrefix", "(", "absTargetDir", ",", "gopath", ")", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// set import path", "newImportPath", ",", "err", ":=", "filepath", ".", "Rel", "(", "gopath", ",", "absTargetDir", ")", "\n", "if", "err", "!=", "nil", "{", "panic", "(", "\"", "\"", "+", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n\n", "// re-join because otherwise windows will use `\\`", "return", "path", ".", "Join", "(", "strings", ".", "Split", "(", "newImportPath", ",", "string", "(", "filepath", ".", "Separator", ")", ")", "...", ")", "\n", "}" ]

[ "try", "to", "set", "root", "import", "path", "based", "on", "target", "dir", "-", "do", "nothing", "if", "user", "specify", "import", "path", "-", "if", "target", "dir", "is", "under", "GOPATH", "set", "it", "to", "the", "target", "dir" ]

[ "func", "addPackage", "(", "pkgName", ",", "typeStr", "string", ")", "string", "{", "if", "typeStr", "==", "\"", "\"", "{", "return", "\"", "\"", "\n", "}", "\n\n", "// we can't use raml package to get basic type and decide whether it is array", "// or not because in this phase the type is already Go type, not RAML type", "switch", "{", "case", "strings", ".", "HasPrefix", "(", "typeStr", ",", "\"", "\"", ")", ":", "// bidimensi array", "return", "\"", "\"", "+", "addPackage", "(", "pkgName", ",", "strings", ".", "TrimPrefix", "(", "typeStr", ",", "\"", "\"", ")", ")", "\n", "case", "strings", ".", "HasPrefix", "(", "typeStr", ",", "\"", "\"", ")", ":", "// array array", "return", "\"", "\"", "+", "addPackage", "(", "pkgName", ",", "strings", ".", "TrimPrefix", "(", "typeStr", ",", "\"", "\"", ")", ")", "\n", "default", ":", "return", "aliasPackage", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "pkgName", ",", "typeStr", ")", ")", "\n", "}", "\n", "}" ]

[ "add", "package", "name", "to", "the", "request", "and", "response", "body" ]

[ "func", "(", "m", "method", ")", "FailedRespBodyTypes", "(", ")", "(", "resps", "[", "]", "respBody", ")", "{", "for", "_", ",", "resp", ":=", "range", "m", ".", "RespBodyTypes", "(", ")", "{", "if", "resp", ".", "Code", "<", "200", "||", "resp", ".", "Code", ">=", "300", "{", "resps", "=", "append", "(", "resps", ",", "resp", ")", "\n", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "FailedRespBodyTypes", "return", "all", "response", "body", "that", "considered", "a", "failed", "response", "i", ".", "e", ".", "non", "2xx", "status", "code" ]

[ "func", "(", "m", "method", ")", "needImportGoramlTypes", "(", ")", "bool", "{", "pkgPrefix", ":=", "typePackage", "+", "\"", "\"", "\n", "needImport", ":=", "func", "(", "typeStr", "string", ")", "bool", "{", "switch", "{", "case", "strings", ".", "HasPrefix", "(", "typeStr", ",", "\"", "\"", "+", "pkgPrefix", ")", ":", "return", "true", "\n", "case", "strings", ".", "HasPrefix", "(", "typeStr", ",", "\"", "\"", "+", "pkgPrefix", ")", ":", "return", "true", "\n", "case", "strings", ".", "HasPrefix", "(", "typeStr", ",", "pkgPrefix", ")", ":", "return", "true", "\n", "default", ":", "return", "false", "\n", "}", "\n", "}", "\n", "if", "needImport", "(", "m", ".", "ReqBody", "(", ")", ")", "{", "return", "true", "\n", "}", "\n", "for", "_", ",", "resp", ":=", "range", "m", ".", "RespBodyTypes", "(", ")", "{", "if", "needImport", "(", "resp", ".", "Type", "(", ")", ")", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "returns", "true", "if", "need", "to", "import", "goraml", "generated", "types" ]

[ "func", "getOauth2MwrHandler", "(", "ss", "raml", ".", "DefinitionChoice", ")", "(", "string", ",", "error", ")", "{", "// construct security scopes", "quotedScopes", ",", "err", ":=", "security", ".", "GetQuotedScopes", "(", "ss", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "scopesArgs", ":=", "strings", ".", "Join", "(", "quotedScopes", ",", "\"", "\"", ")", "\n\n", "// middleware name", "// need to handle case where it reside in different package", "var", "packageName", "string", "\n", "name", ":=", "ss", ".", "Name", "\n\n", "if", "splitted", ":=", "strings", ".", "Split", "(", "name", ",", "\"", "\"", ")", ";", "len", "(", "splitted", ")", "==", "2", "{", "packageName", "=", "splitted", "[", "0", "]", "\n", "name", "=", "splitted", "[", "1", "]", "\n", "}", "\n", "mwr", ":=", "fmt", ".", "Sprintf", "(", "`NewOauth2%vMiddleware([]string{%v}).Handler`", ",", "name", ",", "scopesArgs", ")", "\n", "if", "packageName", "!=", "\"", "\"", "{", "mwr", "=", "packageName", "+", "\"", "\"", "+", "mwr", "\n", "}", "\n", "return", "mwr", ",", "nil", "\n", "}" ]

[ "get", "oauth2", "middleware", "handler", "from", "a", "security", "scheme" ]

[ "func", "copyLibrariesFiles", "(", "uses", "map", "[", "string", "]", "string", ",", "libs", "map", "[", "string", "]", "*", "raml", ".", "Library", ",", "ramlFile", ",", "dir", "string", ",", "libRootURLs", "[", "]", "string", ")", "error", "{", "baseDir", ":=", "filepath", ".", "Dir", "(", "ramlFile", ")", "\n", "// copy library files", "for", "_", ",", "path", ":=", "range", "uses", "{", "if", "err", ":=", "copyFile", "(", "baseDir", ",", "path", ",", "dir", ",", "libRootURLs", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "// do it recursively", "for", "_", ",", "l", ":=", "range", "libs", "{", "if", "err", ":=", "copyLibrariesFiles", "(", "l", ".", "Uses", ",", "l", ".", "Libraries", ",", "filepath", ".", "Join", "(", "baseDir", ",", "l", ".", "Filename", ")", ",", "filepath", ".", "Join", "(", "dir", ",", "filepath", ".", "Dir", "(", "l", ".", "Filename", ")", ")", ",", "libRootURLs", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "copy", "all", "library", "files", "to", "apidocs", "directory" ]

[ "func", "copyFile", "(", "sourceDir", ",", "sourceFile", ",", "destDir", "string", ",", "libRootURLs", "[", "]", "string", ")", "error", "{", "var", "source", "io", ".", "Reader", "\n\n", "if", "strings", ".", "HasPrefix", "(", "sourceFile", ",", "\"", "\"", ")", "||", "strings", ".", "HasPrefix", "(", "sourceFile", ",", "\"", "\"", ")", "{", "resp", ",", "err", ":=", "http", ".", "Get", "(", "sourceFile", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "resp", ".", "Body", ".", "Close", "(", ")", "\n", "source", "=", "resp", ".", "Body", "\n", "}", "else", "{", "sourceFile", ",", "err", ":=", "os", ".", "Open", "(", "filepath", ".", "Join", "(", "sourceDir", ",", "sourceFile", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "source", "=", "sourceFile", "\n", "}", "\n\n", "dest", ":=", "filepath", ".", "Join", "(", "destDir", ",", "libraries", ".", "StripLibRootURL", "(", "sourceFile", ",", "libRootURLs", ")", ")", "\n\n", "// create target dir if needed", "if", "err", ":=", "os", ".", "MkdirAll", "(", "filepath", ".", "Dir", "(", "dest", ")", ",", "0777", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// creaate dest file", "destFile", ",", "err", ":=", "os", ".", "OpenFile", "(", "dest", ",", "os", ".", "O_CREATE", "|", "os", ".", "O_RDWR", ",", "0666", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "_", ",", "err", "=", "io", ".", "Copy", "(", "destFile", ",", "source", ")", "\n", "return", "err", "\n", "}" ]

[ "copy", "file", "from", "source", "to", "dest" ]

[ "func", "extract", "(", "dir", "string", ")", "error", "{", "// create dir if needed", "if", "_", ",", "err", ":=", "os", ".", "Stat", "(", "dir", ")", ";", "os", ".", "IsNotExist", "(", "err", ")", "{", "if", "err", ":=", "os", ".", "MkdirAll", "(", "dir", ",", "0777", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "return", "unzip", "(", "\"", "\"", ",", "dir", ")", "\n", "}" ]

[ "Extract", "extracts", "API", "docs", "data", "to", "specified", "path" ]

[ "func", "(", "tib", "*", "TypeInBody", ")", "Body", "(", ")", "raml", ".", "Bodies", "{", "if", "tib", ".", "ReqResp", "==", "HTTPRequest", "{", "return", "tib", ".", "Endpoint", ".", "Method", ".", "Bodies", "\n", "}", "\n", "for", "code", ",", "resp", ":=", "range", "tib", ".", "Endpoint", ".", "Method", ".", "Responses", "{", "if", "code", "==", "tib", ".", "RespCode", "{", "return", "resp", ".", "Bodies", "\n", "}", "\n", "}", "\n", "panic", "(", "\"", "\"", "+", "tib", ".", "Endpoint", ".", "Verb", "+", "\"", "\"", "+", "tib", ".", "Endpoint", ".", "Addr", ")", "\n", "}" ]

[ "Body", "returns", "raml", ".", "Bodies", "from", "TypeInBody", "object" ]

[ "func", "AllTypes", "(", "apiDef", "*", "raml", ".", "APIDefinition", ",", "pkgName", "string", ")", "map", "[", "string", "]", "TypeTask", "{", "mtt", ":=", "map", "[", "string", "]", "TypeTask", "{", "}", "\n\n", "// from types", "for", "name", ",", "tip", ":=", "range", "apiDef", ".", "Types", "{", "mtt", "[", "name", "]", "=", "TypeTask", "{", "Type", ":", "tip", ",", "Pkg", ":", "pkgName", ",", "Name", ":", "name", ",", "}", "\n", "}", "\n\n", "for", "_", ",", "endpoints", ":=", "range", "getAllEndpoints", "(", "apiDef", ")", "{", "for", "_", ",", "ep", ":=", "range", "endpoints", "{", "tts", ":=", "getTypesOfEndpoint", "(", "ep", ",", "pkgName", ")", "\n", "for", "_", ",", "tt", ":=", "range", "tts", "{", "mtt", "[", "tt", ".", "Name", "]", "=", "tt", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "mtt", "\n", "}" ]

[ "AllTypes", "returns", "all", "TypeTask", "that", "need", "to", "be", "generated", "by", "the", "code", "generator" ]

[ "func", "singleLineNewType", "(", "tip", "string", ")", "bool", "{", "rt", ":=", "raml", ".", "Type", "{", "Type", ":", "tip", ",", "}", "\n", "if", "rt", ".", "IsMultipleInheritance", "(", ")", "{", "return", "true", "\n", "}", "\n", "if", "rt", ".", "IsUnion", "(", ")", "{", "return", "true", "\n", "}", "\n", "if", "rt", ".", "IsArray", "(", ")", "{", "return", "true", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "single", "line", "type", "definition", "that", "need", "to", "be", "defined", "as", "a", "new", "type" ]