Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "ByType", "(", "t", "Type", ")", "Filter", "{", "return", "func", "(", "a", "Artifact", ")", "bool", "{", "return", "a", ".", "Type", "==", "t", "\n", "}", "\n", "}" ]

[ "ByType", "is", "a", "predefined", "filter", "that", "filters", "by", "the", "given", "type" ]

[ "func", "ByIDs", "(", "ids", "...", "string", ")", "Filter", "{", "var", "filters", "=", "make", "(", "[", "]", "Filter", ",", "0", ",", "len", "(", "ids", ")", ")", "\n", "for", "_", ",", "id", ":=", "range", "ids", "{", "id", ":=", "id", "\n", "filters", "=", "append", "(", "filters", ",", "func", "(", "a", "Artifact", ")", "bool", "{", "return", "a", ".", "ExtraOr", "(", "\"", "\"", ",", "\"", "\"", ")", "==", "id", "\n", "}", ")", "\n", "}", "\n", "return", "Or", "(", "filters", "...", ")", "\n", "}" ]

[ "ByIDs", "filter", "artifacts", "by", "an", "ID", "extra", "field", "." ]

[ "func", "Or", "(", "filters", "...", "Filter", ")", "Filter", "{", "return", "func", "(", "a", "Artifact", ")", "bool", "{", "for", "_", ",", "f", ":=", "range", "filters", "{", "if", "f", "(", "a", ")", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}", "\n", "}" ]

[ "Or", "performs", "an", "OR", "between", "all", "given", "filters" ]

[ "func", "(", "artifacts", "*", "Artifacts", ")", "Filter", "(", "filter", "Filter", ")", "Artifacts", "{", "var", "result", "=", "New", "(", ")", "\n", "for", "_", ",", "a", ":=", "range", "artifacts", ".", "items", "{", "if", "filter", "(", "a", ")", "{", "result", ".", "items", "=", "append", "(", "result", ".", "items", ",", "a", ")", "\n", "}", "\n", "}", "\n", "return", "result", "\n", "}" ]

[ "Filter", "filters", "the", "artifact", "list", "returning", "a", "new", "instance", ".", "There", "are", "some", "pre", "-", "defined", "filters", "but", "anything", "of", "the", "Type", "Filter", "is", "accepted", ".", "You", "can", "compose", "filters", "by", "using", "the", "And", "and", "Or", "filters", "." ]

[ "func", "(", "Pipe", ")", "Default", "(", "ctx", "*", "context", ".", "Context", ")", "error", "{", "cfg", ":=", "&", "ctx", ".", "Config", ".", "Sign", "\n", "if", "cfg", ".", "Cmd", "==", "\"", "\"", "{", "cfg", ".", "Cmd", "=", "\"", "\"", "\n", "}", "\n", "if", "cfg", ".", "Signature", "==", "\"", "\"", "{", "cfg", ".", "Signature", "=", "\"", "\"", "\n", "}", "\n", "if", "len", "(", "cfg", ".", "Args", ")", "==", "0", "{", "cfg", ".", "Args", "=", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", "}", "\n", "}", "\n", "if", "cfg", ".", "Artifacts", "==", "\"", "\"", "{", "cfg", ".", "Artifacts", "=", "\"", "\"", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Default", "sets", "the", "Pipes", "defaults", "." ]

[ "func", "(", "Pipe", ")", "Run", "(", "ctx", "*", "context", ".", "Context", ")", "error", "{", "if", "ctx", ".", "SkipSign", "{", "return", "pipe", ".", "ErrSkipSignEnabled", "\n", "}", "\n\n", "switch", "ctx", ".", "Config", ".", "Sign", ".", "Artifacts", "{", "case", "\"", "\"", ":", "return", "sign", "(", "ctx", ",", "ctx", ".", "Artifacts", ".", "Filter", "(", "artifact", ".", "ByType", "(", "artifact", ".", "Checksum", ")", ")", ".", "List", "(", ")", ")", "\n", "case", "\"", "\"", ":", "return", "sign", "(", "ctx", ",", "ctx", ".", "Artifacts", ".", "Filter", "(", "artifact", ".", "Or", "(", "artifact", ".", "ByType", "(", "artifact", ".", "UploadableArchive", ")", ",", "artifact", ".", "ByType", "(", "artifact", ".", "UploadableBinary", ")", ",", "artifact", ".", "ByType", "(", "artifact", ".", "Checksum", ")", ",", "artifact", ".", "ByType", "(", "artifact", ".", "LinuxPackage", ")", ",", ")", ")", ".", "List", "(", ")", ")", "\n", "case", "\"", "\"", ":", "return", "pipe", ".", "ErrSkipSignEnabled", "\n", "default", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ctx", ".", "Config", ".", "Sign", ".", "Artifacts", ")", "\n", "}", "\n", "}" ]

[ "Run", "executes", "the", "Pipe", "." ]

[ "func", "Register", "(", "lang", "string", ",", "builder", "Builder", ")", "{", "lock", ".", "Lock", "(", ")", "\n", "builders", "[", "lang", "]", "=", "builder", "\n", "lock", ".", "Unlock", "(", ")", "\n", "}" ]

[ "Register", "registers", "a", "builder", "to", "a", "given", "lang" ]

[ "func", "(", "*", "Builder", ")", "WithDefaults", "(", "build", "config", ".", "Build", ")", "config", ".", "Build", "{", "if", "build", ".", "Main", "==", "\"", "\"", "{", "build", ".", "Main", "=", "\"", "\"", "\n", "}", "\n", "if", "len", "(", "build", ".", "Goos", ")", "==", "0", "{", "build", ".", "Goos", "=", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", "}", "\n", "}", "\n", "if", "len", "(", "build", ".", "Goarch", ")", "==", "0", "{", "build", ".", "Goarch", "=", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", "}", "\n", "}", "\n", "if", "len", "(", "build", ".", "Goarm", ")", "==", "0", "{", "build", ".", "Goarm", "=", "[", "]", "string", "{", "\"", "\"", "}", "\n", "}", "\n", "if", "len", "(", "build", ".", "Ldflags", ")", "==", "0", "{", "build", ".", "Ldflags", "=", "[", "]", "string", "{", "\"", "\"", "}", "\n", "}", "\n", "if", "len", "(", "build", ".", "Targets", ")", "==", "0", "{", "build", ".", "Targets", "=", "matrix", "(", "build", ")", "\n", "}", "\n", "return", "build", "\n", "}" ]

[ "WithDefaults", "sets", "the", "defaults", "for", "a", "golang", "build", "and", "returns", "it" ]

[ "func", "(", "*", "Builder", ")", "Build", "(", "ctx", "*", "context", ".", "Context", ",", "build", "config", ".", "Build", ",", "options", "api", ".", "Options", ")", "error", "{", "if", "err", ":=", "checkMain", "(", "build", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "target", ",", "err", ":=", "newBuildTarget", "(", "options", ".", "Target", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "var", "cmd", "=", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", "}", "\n\n", "var", "env", "=", "append", "(", "ctx", ".", "Env", ".", "Strings", "(", ")", ",", "build", ".", "Env", "...", ")", "\n", "env", "=", "append", "(", "env", ",", "target", ".", "Env", "(", ")", "...", ")", "\n\n", "flags", ",", "err", ":=", "processFlags", "(", "ctx", ",", "env", ",", "build", ".", "Flags", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "cmd", "=", "append", "(", "cmd", ",", "flags", "...", ")", "\n\n", "asmflags", ",", "err", ":=", "processFlags", "(", "ctx", ",", "env", ",", "build", ".", "Asmflags", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "cmd", "=", "append", "(", "cmd", ",", "asmflags", "...", ")", "\n\n", "gcflags", ",", "err", ":=", "processFlags", "(", "ctx", ",", "env", ",", "build", ".", "Gcflags", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "cmd", "=", "append", "(", "cmd", ",", "gcflags", "...", ")", "\n\n", "ldflags", ",", "err", ":=", "processFlags", "(", "ctx", ",", "env", ",", "build", ".", "Ldflags", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "cmd", "=", "append", "(", "cmd", ",", "ldflags", "...", ")", "\n\n", "cmd", "=", "append", "(", "cmd", ",", "\"", "\"", ",", "options", ".", "Path", ",", "build", ".", "Main", ")", "\n", "if", "err", ":=", "run", "(", "ctx", ",", "cmd", ",", "env", ")", ";", "err", "!=", "nil", "{", "return", "errors", ".", "Wrapf", "(", "err", ",", "\"", "\"", ",", "options", ".", "Target", ")", "\n", "}", "\n", "ctx", ".", "Artifacts", ".", "Add", "(", "artifact", ".", "Artifact", "{", "Type", ":", "artifact", ".", "Binary", ",", "Path", ":", "options", ".", "Path", ",", "Name", ":", "options", ".", "Name", ",", "Goos", ":", "target", ".", "os", ",", "Goarch", ":", "target", ".", "arch", ",", "Goarm", ":", "target", ".", "arm", ",", "Extra", ":", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "build", ".", "Binary", ",", "\"", "\"", ":", "options", ".", "Ext", ",", "\"", "\"", ":", "build", ".", "ID", ",", "}", ",", "}", ")", "\n", "return", "nil", "\n", "}" ]

[ "Build", "builds", "a", "golang", "build" ]

[ "func", "(", "Pipe", ")", "Publish", "(", "ctx", "*", "context", ".", "Context", ")", "error", "{", "var", "images", "=", "ctx", ".", "Artifacts", ".", "Filter", "(", "artifact", ".", "ByType", "(", "artifact", ".", "PublishableDockerImage", ")", ")", ".", "List", "(", ")", "\n", "for", "_", ",", "image", ":=", "range", "images", "{", "if", "err", ":=", "dockerPush", "(", "ctx", ",", "image", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Publish", "the", "docker", "images" ]

[ "func", "link", "(", "src", ",", "dest", "string", ")", "error", "{", "return", "filepath", ".", "Walk", "(", "src", ",", "func", "(", "path", "string", ",", "info", "os", ".", "FileInfo", ",", "err", "error", ")", "error", "{", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "// We have the following:", "// - src = \"a/b\"", "// - dest = \"dist/linuxamd64/b\"", "// - path = \"a/b/c.txt\"", "// So we join \"a/b\" with \"c.txt\" and use it as the destination.", "var", "dst", "=", "filepath", ".", "Join", "(", "dest", ",", "strings", ".", "Replace", "(", "path", ",", "src", ",", "\"", "\"", ",", "1", ")", ")", "\n", "log", ".", "WithFields", "(", "log", ".", "Fields", "{", "\"", "\"", ":", "path", ",", "\"", "\"", ":", "dst", ",", "}", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "if", "info", ".", "IsDir", "(", ")", "{", "return", "os", ".", "MkdirAll", "(", "dst", ",", "info", ".", "Mode", "(", ")", ")", "\n", "}", "\n", "return", "os", ".", "Link", "(", "path", ",", "dst", ")", "\n", "}", ")", "\n", "}" ]

[ "walks", "the", "src", "recreating", "dirs", "and", "hard", "-", "linking", "files" ]

[ "func", "Logging", "(", "title", "string", ",", "next", "Action", ",", "padding", "Padding", ")", "Action", "{", "return", "func", "(", "ctx", "*", "context", ".", "Context", ")", "error", "{", "defer", "func", "(", ")", "{", "cli", ".", "Default", ".", "Padding", "=", "int", "(", "DefaultInitialPadding", ")", "\n", "}", "(", ")", "\n", "cli", ".", "Default", ".", "Padding", "=", "int", "(", "padding", ")", "\n", "log", ".", "Infof", "(", "color", ".", "New", "(", "color", ".", "Bold", ")", ".", "Sprint", "(", "strings", ".", "ToUpper", "(", "title", ")", ")", ")", "\n", "cli", ".", "Default", ".", "Padding", "=", "int", "(", "padding", "+", "DefaultInitialPadding", ")", "\n", "return", "next", "(", "ctx", ")", "\n", "}", "\n", "}" ]

[ "Logging", "pretty", "prints", "the", "given", "action", "and", "its", "title", ".", "You", "can", "have", "different", "padding", "levels", "by", "providing", "different", "initial", "paddings", ".", "The", "middleware", "will", "print", "the", "title", "in", "the", "given", "padding", "and", "the", "action", "logs", "in", "padding", "+", "default", "padding", ".", "The", "default", "padding", "in", "the", "log", "library", "is", "3", ".", "The", "middleware", "always", "resets", "to", "the", "default", "padding", "." ]

[ "func", "Load", "(", "file", "string", ")", "(", "config", "Project", ",", "err", "error", ")", "{", "f", ",", "err", ":=", "os", ".", "Open", "(", "file", ")", "// #nosec", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "log", ".", "WithField", "(", "\"", "\"", ",", "file", ")", ".", "Info", "(", "\"", "\"", ")", "\n", "return", "LoadReader", "(", "f", ")", "\n", "}" ]

[ "Load", "config", "file" ]

[ "func", "LoadReader", "(", "fd", "io", ".", "Reader", ")", "(", "config", "Project", ",", "err", "error", ")", "{", "data", ",", "err", ":=", "ioutil", ".", "ReadAll", "(", "fd", ")", "\n", "if", "err", "!=", "nil", "{", "return", "config", ",", "err", "\n", "}", "\n", "err", "=", "yaml", ".", "UnmarshalStrict", "(", "data", ",", "&", "config", ")", "\n", "log", ".", "WithField", "(", "\"", "\"", ",", "config", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "config", ",", "err", "\n", "}" ]

[ "LoadReader", "config", "via", "io", ".", "Reader" ]

[ "func", "New", "(", "file", "*", "os", ".", "File", ")", "Archive", "{", "if", "strings", ".", "HasSuffix", "(", "file", ".", "Name", "(", ")", ",", "\"", "\"", ")", "{", "return", "targz", ".", "New", "(", "file", ")", "\n", "}", "\n", "if", "strings", ".", "HasSuffix", "(", "file", ".", "Name", "(", ")", ",", "\"", "\"", ")", "{", "return", "gzip", ".", "New", "(", "file", ")", "\n", "}", "\n", "if", "strings", ".", "HasSuffix", "(", "file", ".", "Name", "(", ")", ",", "\"", "\"", ")", "{", "return", "zip", ".", "New", "(", "file", ")", "\n", "}", "\n", "return", "targz", ".", "New", "(", "file", ")", "\n", "}" ]

[ "New", "archive", "." ]

[ "func", "initProject", "(", "filename", "string", ")", "error", "{", "if", "_", ",", "err", ":=", "os", ".", "Stat", "(", "filename", ")", ";", "!", "os", ".", "IsNotExist", "(", "err", ")", "{", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "filename", ")", "\n", "}", "\n", "log", ".", "Infof", "(", "color", ".", "New", "(", "color", ".", "Bold", ")", ".", "Sprintf", "(", "\"", "\"", ",", "filename", ")", ")", "\n", "return", "ioutil", ".", "WriteFile", "(", "filename", ",", "[", "]", "byte", "(", "static", ".", "ExampleConfig", ")", ",", "0644", ")", "\n", "}" ]

[ "InitProject", "creates", "an", "example", "goreleaser", ".", "yml", "in", "the", "current", "directory" ]

[ "func", "New", "(", "target", "io", ".", "Writer", ")", "Archive", "{", "gw", ":=", "gzip", ".", "NewWriter", "(", "target", ")", "\n", "return", "Archive", "{", "gw", ":", "gw", ",", "}", "\n", "}" ]

[ "New", "gz", "archive" ]

[ "func", "(", "e", "Env", ")", "Strings", "(", ")", "[", "]", "string", "{", "var", "result", "=", "make", "(", "[", "]", "string", ",", "0", ",", "len", "(", "e", ")", ")", "\n", "for", "k", ",", "v", ":=", "range", "e", "{", "result", "=", "append", "(", "result", ",", "k", "+", "\"", "\"", "+", "v", ")", "\n", "}", "\n", "return", "result", "\n", "}" ]

[ "Strings", "returns", "the", "current", "environment", "as", "a", "list", "of", "strings", "suitable", "for", "os", "executions", "." ]

[ "func", "NewWithTimeout", "(", "config", "config", ".", "Project", ",", "timeout", "time", ".", "Duration", ")", "(", "*", "Context", ",", "ctx", ".", "CancelFunc", ")", "{", "ctx", ",", "cancel", ":=", "ctx", ".", "WithTimeout", "(", "ctx", ".", "Background", "(", ")", ",", "timeout", ")", "\n", "return", "Wrap", "(", "ctx", ",", "config", ")", ",", "cancel", "\n", "}" ]

[ "NewWithTimeout", "new", "context", "with", "the", "given", "timeout" ]

[ "func", "Wrap", "(", "ctx", "ctx", ".", "Context", ",", "config", "config", ".", "Project", ")", "*", "Context", "{", "return", "&", "Context", "{", "Context", ":", "ctx", ",", "Config", ":", "config", ",", "Env", ":", "splitEnv", "(", "append", "(", "os", ".", "Environ", "(", ")", ",", "config", ".", "Env", "...", ")", ")", ",", "Parallelism", ":", "4", ",", "Artifacts", ":", "artifact", ".", "New", "(", ")", ",", "}", "\n", "}" ]

[ "Wrap", "wraps", "an", "existing", "context" ]

[ "func", "IsRepo", "(", ")", "bool", "{", "out", ",", "err", ":=", "Run", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "return", "err", "==", "nil", "&&", "strings", ".", "TrimSpace", "(", "out", ")", "==", "\"", "\"", "\n", "}" ]

[ "IsRepo", "returns", "true", "if", "current", "folder", "is", "a", "git", "repository" ]

[ "func", "Run", "(", "args", "...", "string", ")", "(", "string", ",", "error", ")", "{", "// TODO: use exex.CommandContext here and refactor.", "var", "extraArgs", "=", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "}", "\n", "args", "=", "append", "(", "extraArgs", ",", "args", "...", ")", "\n", "/* #nosec */", "var", "cmd", "=", "exec", ".", "Command", "(", "\"", "\"", ",", "args", "...", ")", "\n", "log", ".", "WithField", "(", "\"", "\"", ",", "args", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "bts", ",", "err", ":=", "cmd", ".", "CombinedOutput", "(", ")", "\n", "log", ".", "WithField", "(", "\"", "\"", ",", "string", "(", "bts", ")", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "errors", ".", "New", "(", "string", "(", "bts", ")", ")", "\n", "}", "\n", "return", "string", "(", "bts", ")", ",", "nil", "\n", "}" ]

[ "Run", "runs", "a", "git", "command", "and", "returns", "its", "output", "or", "errors" ]

[ "func", "Clean", "(", "output", "string", ",", "err", "error", ")", "(", "string", ",", "error", ")", "{", "output", "=", "strings", ".", "Replace", "(", "strings", ".", "Split", "(", "output", ",", "\"", "\\n", "\"", ")", "[", "0", "]", ",", "\"", "\"", ",", "\"", "\"", ",", "-", "1", ")", "\n", "if", "err", "!=", "nil", "{", "err", "=", "errors", ".", "New", "(", "strings", ".", "TrimSuffix", "(", "err", ".", "Error", "(", ")", ",", "\"", "\\n", "\"", ")", ")", "\n", "}", "\n", "return", "output", ",", "err", "\n", "}" ]

[ "Clean", "the", "output" ]

[ "func", "(", "Pipe", ")", "Publish", "(", "ctx", "*", "context", ".", "Context", ")", "error", "{", "client", ",", "err", ":=", "client", ".", "NewGitHub", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "doRun", "(", "ctx", ",", "client", ")", "\n", "}" ]

[ "Publish", "brew", "formula" ]

[ "func", "NewGitHub", "(", "ctx", "*", "context", ".", "Context", ")", "(", "Client", ",", "error", ")", "{", "ts", ":=", "oauth2", ".", "StaticTokenSource", "(", "&", "oauth2", ".", "Token", "{", "AccessToken", ":", "ctx", ".", "Token", "}", ",", ")", "\n", "httpClient", ":=", "oauth2", ".", "NewClient", "(", "ctx", ",", "ts", ")", "\n", "base", ":=", "httpClient", ".", "Transport", ".", "(", "*", "oauth2", ".", "Transport", ")", ".", "Base", "\n", "// nolint: govet", "if", "&", "base", "!=", "nil", "{", "base", "=", "http", ".", "DefaultTransport", "\n", "}", "\n", "// nolint: gosec", "base", ".", "(", "*", "http", ".", "Transport", ")", ".", "TLSClientConfig", "=", "&", "tls", ".", "Config", "{", "InsecureSkipVerify", ":", "ctx", ".", "Config", ".", "GitHubURLs", ".", "SkipTLSVerify", ",", "}", "\n", "httpClient", ".", "Transport", ".", "(", "*", "oauth2", ".", "Transport", ")", ".", "Base", "=", "base", "\n", "client", ":=", "github", ".", "NewClient", "(", "httpClient", ")", "\n", "if", "ctx", ".", "Config", ".", "GitHubURLs", ".", "API", "!=", "\"", "\"", "{", "api", ",", "err", ":=", "url", ".", "Parse", "(", "ctx", ".", "Config", ".", "GitHubURLs", ".", "API", ")", "\n", "if", "err", "!=", "nil", "{", "return", "&", "githubClient", "{", "}", ",", "err", "\n", "}", "\n", "upload", ",", "err", ":=", "url", ".", "Parse", "(", "ctx", ".", "Config", ".", "GitHubURLs", ".", "Upload", ")", "\n", "if", "err", "!=", "nil", "{", "return", "&", "githubClient", "{", "}", ",", "err", "\n", "}", "\n", "client", ".", "BaseURL", "=", "api", "\n", "client", ".", "UploadURL", "=", "upload", "\n", "}", "\n\n", "return", "&", "githubClient", "{", "client", ":", "client", "}", ",", "nil", "\n", "}" ]

[ "NewGitHub", "returns", "a", "github", "client", "implementation" ]

[ "func", "(", "Pipe", ")", "Publish", "(", "ctx", "*", "context", ".", "Context", ")", "error", "{", "if", "len", "(", "ctx", ".", "Config", ".", "S3", ")", "==", "0", "{", "return", "pipe", ".", "Skip", "(", "\"", "\"", ")", "\n", "}", "\n", "var", "g", "=", "semerrgroup", ".", "New", "(", "ctx", ".", "Parallelism", ")", "\n", "for", "_", ",", "conf", ":=", "range", "ctx", ".", "Config", ".", "S3", "{", "conf", ":=", "conf", "\n", "g", ".", "Go", "(", "func", "(", ")", "error", "{", "return", "upload", "(", "ctx", ",", "conf", ")", "\n", "}", ")", "\n", "}", "\n", "return", "g", ".", "Wait", "(", ")", "\n", "}" ]

[ "Publish", "to", "S3" ]

[ "func", "Defaults", "(", "puts", "[", "]", "config", ".", "Put", ")", "error", "{", "for", "i", ":=", "range", "puts", "{", "defaults", "(", "&", "puts", "[", "i", "]", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Defaults", "sets", "default", "configuration", "options", "on", "Put", "structs" ]

[ "func", "CheckConfig", "(", "ctx", "*", "context", ".", "Context", ",", "put", "*", "config", ".", "Put", ",", "kind", "string", ")", "error", "{", "if", "put", ".", "Target", "==", "\"", "\"", "{", "return", "misconfigured", "(", "kind", ",", "put", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "put", ".", "Name", "==", "\"", "\"", "{", "return", "misconfigured", "(", "kind", ",", "put", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "put", ".", "Mode", "!=", "ModeArchive", "&&", "put", ".", "Mode", "!=", "ModeBinary", "{", "return", "misconfigured", "(", "kind", ",", "put", ",", "\"", "\"", ")", "\n", "}", "\n\n", "envName", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "strings", ".", "ToUpper", "(", "kind", ")", ",", "strings", ".", "ToUpper", "(", "put", ".", "Name", ")", ")", "\n", "if", "_", ",", "ok", ":=", "ctx", ".", "Env", "[", "envName", "]", ";", "!", "ok", "{", "return", "misconfigured", "(", "kind", ",", "put", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "envName", ")", ")", "\n", "}", "\n\n", "if", "put", ".", "TrustedCerts", "!=", "\"", "\"", "&&", "!", "x509", ".", "NewCertPool", "(", ")", ".", "AppendCertsFromPEM", "(", "[", "]", "byte", "(", "put", ".", "TrustedCerts", ")", ")", "{", "return", "misconfigured", "(", "kind", ",", "put", ",", "\"", "\"", ")", "\n", "}", "\n\n", "return", "nil", "\n\n", "}" ]

[ "CheckConfig", "validates", "a", "Put", "configuration", "returning", "a", "descriptive", "error", "when", "appropriate" ]

[ "func", "Upload", "(", "ctx", "*", "context", ".", "Context", ",", "puts", "[", "]", "config", ".", "Put", ",", "kind", "string", ",", "check", "ResponseChecker", ")", "error", "{", "if", "ctx", ".", "SkipPublish", "{", "return", "pipe", ".", "ErrSkipPublishEnabled", "\n", "}", "\n\n", "// Handle every configured put", "for", "_", ",", "put", ":=", "range", "puts", "{", "put", ":=", "put", "\n", "filters", ":=", "[", "]", "artifact", ".", "Filter", "{", "}", "\n", "if", "put", ".", "Checksum", "{", "filters", "=", "append", "(", "filters", ",", "artifact", ".", "ByType", "(", "artifact", ".", "Checksum", ")", ")", "\n", "}", "\n", "if", "put", ".", "Signature", "{", "filters", "=", "append", "(", "filters", ",", "artifact", ".", "ByType", "(", "artifact", ".", "Signature", ")", ")", "\n", "}", "\n", "// We support two different modes", "//\t- \"archive\": Upload all artifacts", "//\t- \"binary\": Upload only the raw binaries", "switch", "v", ":=", "strings", ".", "ToLower", "(", "put", ".", "Mode", ")", ";", "v", "{", "case", "ModeArchive", ":", "filters", "=", "append", "(", "filters", ",", "artifact", ".", "ByType", "(", "artifact", ".", "UploadableArchive", ")", ",", "artifact", ".", "ByType", "(", "artifact", ".", "LinuxPackage", ")", ",", ")", "\n", "case", "ModeBinary", ":", "filters", "=", "append", "(", "filters", ",", "artifact", ".", "ByType", "(", "artifact", ".", "UploadableBinary", ")", ")", "\n", "default", ":", "err", ":=", "fmt", ".", "Errorf", "(", "\"", "\\\"", "\\\"", "\"", ",", "kind", ",", "v", ")", "\n", "log", ".", "WithFields", "(", "log", ".", "Fields", "{", "kind", ":", "put", ".", "Name", ",", "\"", "\"", ":", "v", ",", "}", ")", ".", "Error", "(", "err", ".", "Error", "(", ")", ")", "\n", "return", "err", "\n", "}", "\n", "if", "err", ":=", "uploadWithFilter", "(", "ctx", ",", "&", "put", ",", "artifact", ".", "Or", "(", "filters", "...", ")", ",", "kind", ",", "check", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Upload", "does", "the", "actual", "uploading", "work" ]

[ "func", "uploadAsset", "(", "ctx", "*", "context", ".", "Context", ",", "put", "*", "config", ".", "Put", ",", "artifact", "artifact", ".", "Artifact", ",", "kind", "string", ",", "check", "ResponseChecker", ")", "error", "{", "envBase", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "strings", ".", "ToUpper", "(", "kind", ")", ",", "strings", ".", "ToUpper", "(", "put", ".", "Name", ")", ")", "\n", "username", ":=", "put", ".", "Username", "\n", "if", "username", "==", "\"", "\"", "{", "// username not configured: using env", "username", "=", "ctx", ".", "Env", "[", "envBase", "+", "\"", "\"", "]", "\n", "}", "\n", "secret", ":=", "ctx", ".", "Env", "[", "envBase", "+", "\"", "\"", "]", "\n\n", "// Generate the target url", "targetURL", ",", "err", ":=", "resolveTargetTemplate", "(", "ctx", ",", "put", ",", "artifact", ")", "\n", "if", "err", "!=", "nil", "{", "msg", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "kind", ")", "\n", "log", ".", "WithField", "(", "\"", "\"", ",", "put", ".", "Name", ")", ".", "WithError", "(", "err", ")", ".", "Error", "(", "msg", ")", "\n", "return", "errors", ".", "Wrap", "(", "err", ",", "msg", ")", "\n", "}", "\n\n", "// Handle the artifact", "asset", ",", "err", ":=", "assetOpen", "(", "kind", ",", "&", "artifact", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "asset", ".", "ReadCloser", ".", "Close", "(", ")", "// nolint: errcheck", "\n\n", "// The target url needs to contain the artifact name", "if", "!", "strings", ".", "HasSuffix", "(", "targetURL", ",", "\"", "\"", ")", "{", "targetURL", "+=", "\"", "\"", "\n", "}", "\n", "targetURL", "+=", "artifact", ".", "Name", "\n\n", "var", "headers", "=", "map", "[", "string", "]", "string", "{", "}", "\n", "if", "put", ".", "ChecksumHeader", "!=", "\"", "\"", "{", "sum", ",", "err", ":=", "artifact", ".", "Checksum", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "headers", "[", "put", ".", "ChecksumHeader", "]", "=", "sum", "\n", "}", "\n\n", "_", ",", "err", "=", "uploadAssetToServer", "(", "ctx", ",", "put", ",", "targetURL", ",", "username", ",", "secret", ",", "headers", ",", "asset", ",", "check", ")", "\n", "if", "err", "!=", "nil", "{", "msg", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "kind", ")", "\n", "log", ".", "WithError", "(", "err", ")", ".", "WithFields", "(", "log", ".", "Fields", "{", "\"", "\"", ":", "put", ".", "Name", ",", "\"", "\"", ":", "username", ",", "}", ")", ".", "Error", "(", "msg", ")", "\n", "return", "errors", ".", "Wrap", "(", "err", ",", "msg", ")", "\n", "}", "\n\n", "log", ".", "WithFields", "(", "log", ".", "Fields", "{", "\"", "\"", ":", "put", ".", "Name", ",", "\"", "\"", ":", "put", ".", "Mode", ",", "}", ")", ".", "Info", "(", "\"", "\"", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "uploadAsset", "uploads", "file", "to", "target", "and", "logs", "all", "actions" ]

[ "func", "uploadAssetToServer", "(", "ctx", "*", "context", ".", "Context", ",", "put", "*", "config", ".", "Put", ",", "target", ",", "username", ",", "secret", "string", ",", "headers", "map", "[", "string", "]", "string", ",", "a", "*", "asset", ",", "check", "ResponseChecker", ")", "(", "*", "h", ".", "Response", ",", "error", ")", "{", "req", ",", "err", ":=", "newUploadRequest", "(", "target", ",", "username", ",", "secret", ",", "headers", ",", "a", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "executeHTTPRequest", "(", "ctx", ",", "put", ",", "req", ",", "check", ")", "\n", "}" ]

[ "uploadAssetToServer", "uploads", "the", "asset", "file", "to", "target" ]

[ "func", "newUploadRequest", "(", "target", ",", "username", ",", "secret", "string", ",", "headers", "map", "[", "string", "]", "string", ",", "a", "*", "asset", ")", "(", "*", "h", ".", "Request", ",", "error", ")", "{", "req", ",", "err", ":=", "h", ".", "NewRequest", "(", "h", ".", "MethodPut", ",", "target", ",", "a", ".", "ReadCloser", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "req", ".", "ContentLength", "=", "a", ".", "Size", "\n", "req", ".", "SetBasicAuth", "(", "username", ",", "secret", ")", "\n\n", "for", "k", ",", "v", ":=", "range", "headers", "{", "req", ".", "Header", ".", "Add", "(", "k", ",", "v", ")", "\n", "}", "\n\n", "return", "req", ",", "err", "\n", "}" ]

[ "newUploadRequest", "creates", "a", "new", "h", ".", "Request", "for", "uploading" ]

[ "func", "executeHTTPRequest", "(", "ctx", "*", "context", ".", "Context", ",", "put", "*", "config", ".", "Put", ",", "req", "*", "h", ".", "Request", ",", "check", "ResponseChecker", ")", "(", "*", "h", ".", "Response", ",", "error", ")", "{", "client", ",", "err", ":=", "getHTTPClient", "(", "put", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "log", ".", "Debugf", "(", "\"", "\"", ",", "req", ".", "Method", ",", "req", ".", "URL", ",", "req", ".", "Header", ")", "\n", "resp", ",", "err", ":=", "client", ".", "Do", "(", "req", ")", "\n", "if", "err", "!=", "nil", "{", "// If we got an error, and the context has been canceled,", "// the context's error is probably more useful.", "select", "{", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "nil", ",", "ctx", ".", "Err", "(", ")", "\n", "default", ":", "}", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "defer", "resp", ".", "Body", ".", "Close", "(", ")", "// nolint: errcheck", "\n\n", "err", "=", "check", "(", "resp", ")", "\n", "if", "err", "!=", "nil", "{", "// even though there was an error, we still return the response", "// in case the caller wants to inspect it further", "return", "resp", ",", "err", "\n", "}", "\n\n", "return", "resp", ",", "err", "\n", "}" ]

[ "executeHTTPRequest", "processes", "the", "http", "call", "with", "respect", "of", "context", "ctx" ]

[ "func", "resolveTargetTemplate", "(", "ctx", "*", "context", ".", "Context", ",", "put", "*", "config", ".", "Put", ",", "artifact", "artifact", ".", "Artifact", ")", "(", "string", ",", "error", ")", "{", "data", ":=", "targetData", "{", "Version", ":", "ctx", ".", "Version", ",", "Tag", ":", "ctx", ".", "Git", ".", "CurrentTag", ",", "ProjectName", ":", "ctx", ".", "Config", ".", "ProjectName", ",", "}", "\n\n", "if", "put", ".", "Mode", "==", "ModeBinary", "{", "data", ".", "Os", "=", "replace", "(", "ctx", ".", "Config", ".", "Archive", ".", "Replacements", ",", "artifact", ".", "Goos", ")", "\n", "data", ".", "Arch", "=", "replace", "(", "ctx", ".", "Config", ".", "Archive", ".", "Replacements", ",", "artifact", ".", "Goarch", ")", "\n", "data", ".", "Arm", "=", "replace", "(", "ctx", ".", "Config", ".", "Archive", ".", "Replacements", ",", "artifact", ".", "Goarm", ")", "\n", "}", "\n\n", "var", "out", "bytes", ".", "Buffer", "\n", "t", ",", "err", ":=", "template", ".", "New", "(", "ctx", ".", "Config", ".", "ProjectName", ")", ".", "Parse", "(", "put", ".", "Target", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "err", "=", "t", ".", "Execute", "(", "&", "out", ",", "data", ")", "\n", "return", "out", ".", "String", "(", ")", ",", "err", "\n", "}" ]

[ "resolveTargetTemplate", "returns", "the", "resolved", "target", "template", "with", "replaced", "variables", "Those", "variables", "can", "be", "replaced", "by", "the", "given", "context", "goos", "goarch", "goarm", "and", "more" ]

[ "func", "NewEnhancedArchive", "(", "a", "archive", ".", "Archive", ",", "wrap", "string", ")", "archive", ".", "Archive", "{", "return", "EnhancedArchive", "{", "a", ":", "a", ",", "wrap", ":", "wrap", ",", "files", ":", "map", "[", "string", "]", "string", "{", "}", ",", "}", "\n", "}" ]

[ "NewEnhancedArchive", "enhances", "a", "pre", "-", "existing", "archive", ".", "Archive", "instance", "with", "this", "pipe", "specifics", "." ]

[ "func", "(", "d", "EnhancedArchive", ")", "Add", "(", "name", ",", "path", "string", ")", "error", "{", "name", "=", "strings", ".", "Replace", "(", "filepath", ".", "Join", "(", "d", ".", "wrap", ",", "name", ")", ",", "\"", "\\\\", "\"", ",", "\"", "\"", ",", "-", "1", ")", "\n", "log", ".", "Debugf", "(", "\"", "\"", ",", "path", ",", "name", ")", "\n", "if", "_", ",", "ok", ":=", "d", ".", "files", "[", "name", "]", ";", "ok", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "name", ")", "\n", "}", "\n", "d", ".", "files", "[", "name", "]", "=", "path", "\n", "return", "d", ".", "a", ".", "Add", "(", "name", ",", "path", ")", "\n", "}" ]

[ "Add", "adds", "a", "file" ]

[ "func", "Notice", "(", "property", "string", ")", "{", "cli", ".", "Default", ".", "Padding", "+=", "3", "\n", "defer", "func", "(", ")", "{", "cli", ".", "Default", ".", "Padding", "-=", "3", "\n", "}", "(", ")", "\n", "// replaces . and _ with -", "url", ":=", "baseURL", "+", "strings", ".", "NewReplacer", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", ")", ".", "Replace", "(", "property", ")", "\n", "log", ".", "Warn", "(", "color", ".", "New", "(", "color", ".", "Bold", ",", "color", ".", "FgHiYellow", ")", ".", "Sprintf", "(", "\"", "\"", ",", "property", ",", "url", ",", ")", ")", "\n", "}" ]

[ "Notice", "warns", "the", "user", "about", "the", "deprecation", "of", "the", "given", "property" ]

[ "func", "New", "(", "target", "io", ".", "Writer", ")", "Archive", "{", "return", "Archive", "{", "z", ":", "zip", ".", "NewWriter", "(", "target", ")", ",", "}", "\n", "}" ]

[ "New", "zip", "archive" ]

[ "func", "(", "a", "Archive", ")", "Add", "(", "name", ",", "path", "string", ")", "(", "err", "error", ")", "{", "file", ",", "err", ":=", "os", ".", "Open", "(", "path", ")", "// #nosec", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "defer", "file", ".", "Close", "(", ")", "// nolint: errcheck", "\n", "info", ",", "err", ":=", "file", ".", "Stat", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "if", "info", ".", "IsDir", "(", ")", "{", "return", "\n", "}", "\n", "header", ",", "err", ":=", "zip", ".", "FileInfoHeader", "(", "info", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "header", ".", "Name", "=", "name", "\n", "header", ".", "Method", "=", "zip", ".", "Deflate", "\n", "w", ",", "err", ":=", "a", ".", "z", ".", "CreateHeader", "(", "header", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "_", ",", "err", "=", "io", ".", "Copy", "(", "w", ",", "file", ")", "\n", "return", "err", "\n", "}" ]

[ "Add", "a", "file", "to", "the", "zip", "archive" ]

[ "func", "(", "Pipe", ")", "Default", "(", "ctx", "*", "context", ".", "Context", ")", "error", "{", "if", "ctx", ".", "Config", ".", "ProjectName", "==", "\"", "\"", "{", "ctx", ".", "Config", ".", "ProjectName", "=", "ctx", ".", "Config", ".", "Release", ".", "GitHub", ".", "Name", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Default", "set", "project", "defaults" ]

[ "func", "(", "t", "*", "Template", ")", "WithEnvS", "(", "envs", "[", "]", "string", ")", "*", "Template", "{", "var", "result", "=", "map", "[", "string", "]", "string", "{", "}", "\n", "for", "_", ",", "env", ":=", "range", "envs", "{", "var", "parts", "=", "strings", ".", "SplitN", "(", "env", ",", "\"", "\"", ",", "2", ")", "\n", "result", "[", "parts", "[", "0", "]", "]", "=", "parts", "[", "1", "]", "\n", "}", "\n", "return", "t", ".", "WithEnv", "(", "result", ")", "\n", "}" ]

[ "WithEnvS", "overrides", "template", "s", "env", "field", "with", "the", "given", "KEY", "=", "VALUE", "list", "of", "environment", "variables" ]

[ "func", "(", "t", "*", "Template", ")", "WithEnv", "(", "e", "map", "[", "string", "]", "string", ")", "*", "Template", "{", "t", ".", "fields", "[", "env", "]", "=", "e", "\n", "return", "t", "\n", "}" ]

[ "WithEnv", "overrides", "template", "s", "env", "field", "with", "the", "given", "environment", "map" ]

[ "func", "(", "t", "*", "Template", ")", "WithArtifact", "(", "a", "artifact", ".", "Artifact", ",", "replacements", "map", "[", "string", "]", "string", ")", "*", "Template", "{", "var", "bin", "=", "a", ".", "Extra", "[", "binary", "]", "\n", "if", "bin", "==", "nil", "{", "bin", "=", "t", ".", "fields", "[", "projectName", "]", "\n", "}", "\n", "t", ".", "fields", "[", "os", "]", "=", "replace", "(", "replacements", ",", "a", ".", "Goos", ")", "\n", "t", ".", "fields", "[", "arch", "]", "=", "replace", "(", "replacements", ",", "a", ".", "Goarch", ")", "\n", "t", ".", "fields", "[", "arm", "]", "=", "replace", "(", "replacements", ",", "a", ".", "Goarm", ")", "\n", "t", ".", "fields", "[", "binary", "]", "=", "bin", ".", "(", "string", ")", "\n", "t", ".", "fields", "[", "artifactName", "]", "=", "a", ".", "Name", "\n", "return", "t", "\n", "}" ]

[ "WithArtifact", "populates", "fields", "from", "the", "artifact", "and", "replacements" ]

[ "func", "(", "t", "*", "Template", ")", "Apply", "(", "s", "string", ")", "(", "string", ",", "error", ")", "{", "var", "out", "bytes", ".", "Buffer", "\n", "tmpl", ",", "err", ":=", "template", ".", "New", "(", "\"", "\"", ")", ".", "Option", "(", "\"", "\"", ")", ".", "Funcs", "(", "template", ".", "FuncMap", "{", "\"", "\"", ":", "func", "(", "s", "string", ")", "string", "{", "return", "time", ".", "Now", "(", ")", ".", "UTC", "(", ")", ".", "Format", "(", "s", ")", "\n", "}", ",", "}", ")", ".", "Parse", "(", "s", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n\n", "err", "=", "tmpl", ".", "Execute", "(", "&", "out", ",", "t", ".", "fields", ")", "\n", "return", "out", ".", "String", "(", ")", ",", "err", "\n", "}" ]

[ "Apply", "applies", "the", "given", "string", "against", "the", "fields", "stored", "in", "the", "template", "." ]

[ "func", "(", "Pipe", ")", "Publish", "(", "ctx", "*", "context", ".", "Context", ")", "error", "{", "c", ",", "err", ":=", "client", ".", "NewGitHub", "(", "ctx", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "doPublish", "(", "ctx", ",", "c", ")", "\n", "}" ]

[ "Publish", "github", "release" ]

[ "func", "New", "(", "size", "int", ")", "*", "Group", "{", "return", "&", "Group", "{", "ch", ":", "make", "(", "chan", "bool", ",", "size", ")", ",", "g", ":", "errgroup", ".", "Group", "{", "}", ",", "}", "\n", "}" ]

[ "New", "returns", "a", "new", "Group", "of", "a", "given", "size", "." ]

[ "func", "(", "s", "*", "Group", ")", "Go", "(", "fn", "func", "(", ")", "error", ")", "{", "s", ".", "g", ".", "Go", "(", "func", "(", ")", "error", "{", "s", ".", "ch", "<-", "true", "\n", "defer", "func", "(", ")", "{", "<-", "s", ".", "ch", "\n", "}", "(", ")", "\n", "return", "fn", "(", ")", "\n", "}", ")", "\n", "}" ]

[ "Go", "execs", "one", "function", "respecting", "the", "group", "and", "semaphore", "." ]

[ "func", "(", "a", "Archive", ")", "Close", "(", ")", "error", "{", "if", "err", ":=", "a", ".", "tw", ".", "Close", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "a", ".", "gw", ".", "Close", "(", ")", "\n", "}" ]

[ "Close", "all", "closeables" ]

[ "func", "New", "(", "target", "io", ".", "Writer", ")", "Archive", "{", "gw", ":=", "gzip", ".", "NewWriter", "(", "target", ")", "\n", "tw", ":=", "tar", ".", "NewWriter", "(", "gw", ")", "\n", "return", "Archive", "{", "gw", ":", "gw", ",", "tw", ":", "tw", ",", "}", "\n", "}" ]

[ "New", "tar", ".", "gz", "archive" ]

[ "func", "(", "meta", "Meta", ")", "GetSetter", "(", ")", "func", "(", "resource", "interface", "{", "}", ",", "metaValue", "*", "MetaValue", ",", "context", "*", "qor", ".", "Context", ")", "{", "return", "meta", ".", "Setter", "\n", "}" ]

[ "GetSetter", "get", "setter", "from", "meta" ]

[ "func", "(", "meta", "*", "Meta", ")", "SetSetter", "(", "fc", "func", "(", "resource", "interface", "{", "}", ",", "metaValue", "*", "MetaValue", ",", "context", "*", "qor", ".", "Context", ")", ")", "{", "meta", ".", "Setter", "=", "fc", "\n", "}" ]

[ "SetSetter", "set", "setter", "to", "meta" ]

[ "func", "(", "meta", "*", "Meta", ")", "GetFormattedValuer", "(", ")", "func", "(", "interface", "{", "}", ",", "*", "qor", ".", "Context", ")", "interface", "{", "}", "{", "if", "meta", ".", "FormattedValuer", "!=", "nil", "{", "return", "meta", ".", "FormattedValuer", "\n", "}", "\n", "return", "meta", ".", "Valuer", "\n", "}" ]

[ "GetFormattedValuer", "get", "formatted", "valuer", "from", "meta" ]

[ "func", "(", "meta", "Meta", ")", "HasPermission", "(", "mode", "roles", ".", "PermissionMode", ",", "context", "*", "qor", ".", "Context", ")", "bool", "{", "if", "meta", ".", "Permission", "==", "nil", "{", "return", "true", "\n", "}", "\n", "var", "roles", "=", "[", "]", "interface", "{", "}", "{", "}", "\n", "for", "_", ",", "role", ":=", "range", "context", ".", "Roles", "{", "roles", "=", "append", "(", "roles", ",", "role", ")", "\n", "}", "\n", "return", "meta", ".", "Permission", ".", "HasPermission", "(", "mode", ",", "roles", "...", ")", "\n", "}" ]

[ "HasPermission", "check", "has", "permission", "or", "not" ]

[ "func", "(", "meta", "*", "Meta", ")", "PreInitialize", "(", ")", "error", "{", "if", "meta", ".", "Name", "==", "\"", "\"", "{", "utils", ".", "ExitWithMsg", "(", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "meta", ")", ")", "\n", "}", "else", "if", "meta", ".", "FieldName", "==", "\"", "\"", "{", "meta", ".", "FieldName", "=", "meta", ".", "Name", "\n", "}", "\n\n", "// parseNestedField used to handle case like Profile.Name", "var", "parseNestedField", "=", "func", "(", "value", "reflect", ".", "Value", ",", "name", "string", ")", "(", "reflect", ".", "Value", ",", "string", ")", "{", "fields", ":=", "strings", ".", "Split", "(", "name", ",", "\"", "\"", ")", "\n", "value", "=", "reflect", ".", "Indirect", "(", "value", ")", "\n", "for", "_", ",", "field", ":=", "range", "fields", "[", ":", "len", "(", "fields", ")", "-", "1", "]", "{", "value", "=", "value", ".", "FieldByName", "(", "field", ")", "\n", "}", "\n\n", "return", "value", ",", "fields", "[", "len", "(", "fields", ")", "-", "1", "]", "\n", "}", "\n\n", "var", "getField", "=", "func", "(", "fields", "[", "]", "*", "gorm", ".", "StructField", ",", "name", "string", ")", "*", "gorm", ".", "StructField", "{", "for", "_", ",", "field", ":=", "range", "fields", "{", "if", "field", ".", "Name", "==", "name", "||", "field", ".", "DBName", "==", "name", "{", "return", "field", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", "\n\n", "var", "nestedField", "=", "strings", ".", "Contains", "(", "meta", ".", "FieldName", ",", "\"", "\"", ")", "\n", "var", "scope", "=", "&", "gorm", ".", "Scope", "{", "Value", ":", "meta", ".", "BaseResource", ".", "GetResource", "(", ")", ".", "Value", "}", "\n", "if", "nestedField", "{", "subModel", ",", "name", ":=", "parseNestedField", "(", "reflect", ".", "ValueOf", "(", "meta", ".", "BaseResource", ".", "GetResource", "(", ")", ".", "Value", ")", ",", "meta", ".", "FieldName", ")", "\n", "meta", ".", "FieldStruct", "=", "getField", "(", "scope", ".", "New", "(", "subModel", ".", "Interface", "(", ")", ")", ".", "GetStructFields", "(", ")", ",", "name", ")", "\n", "}", "else", "{", "meta", ".", "FieldStruct", "=", "getField", "(", "scope", ".", "GetStructFields", "(", ")", ",", "meta", ".", "FieldName", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "PreInitialize", "when", "will", "be", "run", "before", "initialize", "used", "to", "fill", "some", "basic", "necessary", "information" ]

[ "func", "(", "meta", "*", "Meta", ")", "Initialize", "(", ")", "error", "{", "// Set Valuer for Meta", "if", "meta", ".", "Valuer", "==", "nil", "{", "setupValuer", "(", "meta", ",", "meta", ".", "FieldName", ",", "meta", ".", "GetBaseResource", "(", ")", ".", "NewStruct", "(", ")", ")", "\n", "}", "\n\n", "if", "meta", ".", "Valuer", "==", "nil", "{", "utils", ".", "ExitWithMsg", "(", "\"", "\"", ",", "meta", ".", "FieldName", ",", "reflect", ".", "TypeOf", "(", "meta", ".", "BaseResource", ".", "GetResource", "(", ")", ".", "Value", ")", ")", "\n", "}", "\n\n", "// Set Setter for Meta", "if", "meta", ".", "Setter", "==", "nil", "{", "setupSetter", "(", "meta", ",", "meta", ".", "FieldName", ",", "meta", ".", "GetBaseResource", "(", ")", ".", "NewStruct", "(", ")", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Initialize", "initialize", "meta", "will", "set", "valuer", "setter", "if", "haven", "t", "configure", "it" ]

[ "func", "(", "res", "*", "Resource", ")", "CallFindOne", "(", "result", "interface", "{", "}", ",", "metaValues", "*", "MetaValues", ",", "context", "*", "qor", ".", "Context", ")", "error", "{", "return", "res", ".", "FindOneHandler", "(", "result", ",", "metaValues", ",", "context", ")", "\n", "}" ]

[ "CallFindOne", "call", "find", "one", "method" ]

[ "func", "(", "res", "*", "Resource", ")", "CallFindMany", "(", "result", "interface", "{", "}", ",", "context", "*", "qor", ".", "Context", ")", "error", "{", "return", "res", ".", "FindManyHandler", "(", "result", ",", "context", ")", "\n", "}" ]

[ "CallFindMany", "call", "find", "many", "method" ]

[ "func", "(", "res", "*", "Resource", ")", "CallSave", "(", "result", "interface", "{", "}", ",", "context", "*", "qor", ".", "Context", ")", "error", "{", "return", "res", ".", "SaveHandler", "(", "result", ",", "context", ")", "\n", "}" ]

[ "CallSave", "call", "save", "method" ]

[ "func", "(", "res", "*", "Resource", ")", "CallDelete", "(", "result", "interface", "{", "}", ",", "context", "*", "qor", ".", "Context", ")", "error", "{", "return", "res", ".", "DeleteHandler", "(", "result", ",", "context", ")", "\n", "}" ]

[ "CallDelete", "call", "delete", "method" ]

[ "func", "(", "res", "*", "Resource", ")", "ToPrimaryQueryParams", "(", "primaryValue", "string", ",", "context", "*", "qor", ".", "Context", ")", "(", "string", ",", "[", "]", "interface", "{", "}", ")", "{", "if", "primaryValue", "!=", "\"", "\"", "{", "scope", ":=", "context", ".", "GetDB", "(", ")", ".", "NewScope", "(", "res", ".", "Value", ")", "\n\n", "// multiple primary fields", "if", "len", "(", "res", ".", "PrimaryFields", ")", ">", "1", "{", "if", "primaryValueStrs", ":=", "strings", ".", "Split", "(", "primaryValue", ",", "\"", "\"", ")", ";", "len", "(", "primaryValueStrs", ")", "==", "len", "(", "res", ".", "PrimaryFields", ")", "{", "sqls", ":=", "[", "]", "string", "{", "}", "\n", "primaryValues", ":=", "[", "]", "interface", "{", "}", "{", "}", "\n", "for", "idx", ",", "field", ":=", "range", "res", ".", "PrimaryFields", "{", "sqls", "=", "append", "(", "sqls", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "scope", ".", "QuotedTableName", "(", ")", ",", "scope", ".", "Quote", "(", "field", ".", "DBName", ")", ")", ")", "\n", "primaryValues", "=", "append", "(", "primaryValues", ",", "primaryValueStrs", "[", "idx", "]", ")", "\n", "}", "\n\n", "return", "strings", ".", "Join", "(", "sqls", ",", "\"", "\"", ")", ",", "primaryValues", "\n", "}", "\n", "}", "\n\n", "// fallback to first configured primary field", "if", "len", "(", "res", ".", "PrimaryFields", ")", ">", "0", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "scope", ".", "QuotedTableName", "(", ")", ",", "scope", ".", "Quote", "(", "res", ".", "PrimaryFields", "[", "0", "]", ".", "DBName", ")", ")", ",", "[", "]", "interface", "{", "}", "{", "primaryValue", "}", "\n", "}", "\n\n", "// if no configured primary fields found", "if", "primaryField", ":=", "scope", ".", "PrimaryField", "(", ")", ";", "primaryField", "!=", "nil", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "scope", ".", "QuotedTableName", "(", ")", ",", "scope", ".", "Quote", "(", "primaryField", ".", "DBName", ")", ")", ",", "[", "]", "interface", "{", "}", "{", "primaryValue", "}", "\n", "}", "\n", "}", "\n\n", "return", "\"", "\"", ",", "[", "]", "interface", "{", "}", "{", "}", "\n", "}" ]

[ "ToPrimaryQueryParams", "generate", "query", "params", "based", "on", "primary", "key", "multiple", "primary", "value", "are", "linked", "with", "a", "comma" ]

[ "func", "(", "res", "*", "Resource", ")", "ToPrimaryQueryParamsFromMetaValue", "(", "metaValues", "*", "MetaValues", ",", "context", "*", "qor", ".", "Context", ")", "(", "string", ",", "[", "]", "interface", "{", "}", ")", "{", "var", "(", "sqls", "[", "]", "string", "\n", "primaryValues", "[", "]", "interface", "{", "}", "\n", "scope", "=", "context", ".", "GetDB", "(", ")", ".", "NewScope", "(", "res", ".", "Value", ")", "\n", ")", "\n\n", "if", "metaValues", "!=", "nil", "{", "for", "_", ",", "field", ":=", "range", "res", ".", "PrimaryFields", "{", "if", "metaField", ":=", "metaValues", ".", "Get", "(", "field", ".", "Name", ")", ";", "metaField", "!=", "nil", "{", "sqls", "=", "append", "(", "sqls", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "scope", ".", "QuotedTableName", "(", ")", ",", "scope", ".", "Quote", "(", "field", ".", "DBName", ")", ")", ")", "\n", "primaryValues", "=", "append", "(", "primaryValues", ",", "utils", ".", "ToString", "(", "metaField", ".", "Value", ")", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "strings", ".", "Join", "(", "sqls", ",", "\"", "\"", ")", ",", "primaryValues", "\n", "}" ]

[ "ToPrimaryQueryParamsFromMetaValue", "generate", "query", "params", "based", "on", "MetaValues" ]

[ "func", "ConvertJSONToMetaValues", "(", "reader", "io", ".", "Reader", ",", "metaors", "[", "]", "Metaor", ")", "(", "*", "MetaValues", ",", "error", ")", "{", "var", "(", "err", "error", "\n", "values", "=", "map", "[", "string", "]", "interface", "{", "}", "{", "}", "\n", "decoder", "=", "json", ".", "NewDecoder", "(", "reader", ")", "\n", ")", "\n\n", "if", "err", "=", "decoder", ".", "Decode", "(", "&", "values", ")", ";", "err", "==", "nil", "{", "return", "convertMapToMetaValues", "(", "values", ",", "metaors", ")", "\n", "}", "\n", "return", "nil", ",", "err", "\n", "}" ]

[ "ConvertJSONToMetaValues", "convert", "json", "to", "meta", "values" ]

[ "func", "Decode", "(", "context", "*", "qor", ".", "Context", ",", "result", "interface", "{", "}", ",", "res", "Resourcer", ")", "error", "{", "var", "errors", "qor", ".", "Errors", "\n", "var", "err", "error", "\n", "var", "metaValues", "*", "MetaValues", "\n", "metaors", ":=", "res", ".", "GetMetas", "(", "[", "]", "string", "{", "}", ")", "\n\n", "if", "strings", ".", "Contains", "(", "context", ".", "Request", ".", "Header", ".", "Get", "(", "\"", "\"", ")", ",", "\"", "\"", ")", "{", "metaValues", ",", "err", "=", "ConvertJSONToMetaValues", "(", "context", ".", "Request", ".", "Body", ",", "metaors", ")", "\n", "context", ".", "Request", ".", "Body", ".", "Close", "(", ")", "\n", "}", "else", "{", "metaValues", ",", "err", "=", "ConvertFormToMetaValues", "(", "context", ".", "Request", ",", "metaors", ",", "\"", "\"", ")", "\n", "}", "\n\n", "errors", ".", "AddError", "(", "err", ")", "\n", "errors", ".", "AddError", "(", "DecodeToResource", "(", "res", ",", "result", ",", "metaValues", ",", "context", ")", ".", "Start", "(", ")", ")", "\n", "return", "errors", "\n", "}" ]

[ "Decode", "decode", "context", "to", "result", "according", "to", "resource", "definition" ]

[ "func", "DecodeToResource", "(", "res", "Resourcer", ",", "result", "interface", "{", "}", ",", "metaValues", "*", "MetaValues", ",", "context", "*", "qor", ".", "Context", ")", "*", "processor", "{", "return", "&", "processor", "{", "Resource", ":", "res", ",", "Result", ":", "result", ",", "Context", ":", "context", ",", "MetaValues", ":", "metaValues", "}", "\n", "}" ]

[ "DecodeToResource", "decode", "meta", "values", "to", "resource", "result" ]

[ "func", "(", "processor", "*", "processor", ")", "Initialize", "(", ")", "error", "{", "err", ":=", "processor", ".", "Resource", ".", "CallFindOne", "(", "processor", ".", "Result", ",", "processor", ".", "MetaValues", ",", "processor", ".", "Context", ")", "\n", "processor", ".", "checkSkipLeft", "(", "err", ")", "\n", "return", "err", "\n", "}" ]

[ "Initialize", "initialize", "a", "processor" ]

[ "func", "(", "processor", "*", "processor", ")", "Validate", "(", ")", "error", "{", "var", "errs", "qor", ".", "Errors", "\n", "if", "processor", ".", "checkSkipLeft", "(", ")", "{", "return", "nil", "\n", "}", "\n\n", "for", "_", ",", "v", ":=", "range", "processor", ".", "Resource", ".", "GetResource", "(", ")", ".", "Validators", "{", "if", "errs", ".", "AddError", "(", "v", ".", "Handler", "(", "processor", ".", "Result", ",", "processor", ".", "MetaValues", ",", "processor", ".", "Context", ")", ")", ";", "!", "errs", ".", "HasError", "(", ")", "{", "if", "processor", ".", "checkSkipLeft", "(", "errs", ".", "GetErrors", "(", ")", "...", ")", "{", "break", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "errs", "\n", "}" ]

[ "Validate", "run", "validators" ]

[ "func", "(", "processor", "*", "processor", ")", "Start", "(", ")", "error", "{", "var", "errs", "qor", ".", "Errors", "\n", "processor", ".", "Initialize", "(", ")", "\n", "if", "errs", ".", "AddError", "(", "processor", ".", "Validate", "(", ")", ")", ";", "!", "errs", ".", "HasError", "(", ")", "{", "errs", ".", "AddError", "(", "processor", ".", "Commit", "(", ")", ")", "\n", "}", "\n", "if", "errs", ".", "HasError", "(", ")", "{", "return", "errs", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Start", "start", "processor" ]

[ "func", "(", "processor", "*", "processor", ")", "Commit", "(", ")", "error", "{", "var", "errs", "qor", ".", "Errors", "\n", "errs", ".", "AddError", "(", "processor", ".", "decode", "(", ")", "...", ")", "\n", "if", "processor", ".", "checkSkipLeft", "(", "errs", ".", "GetErrors", "(", ")", "...", ")", "{", "return", "nil", "\n", "}", "\n\n", "for", "_", ",", "p", ":=", "range", "processor", ".", "Resource", ".", "GetResource", "(", ")", ".", "Processors", "{", "if", "err", ":=", "p", ".", "Handler", "(", "processor", ".", "Result", ",", "processor", ".", "MetaValues", ",", "processor", ".", "Context", ")", ";", "err", "!=", "nil", "{", "if", "processor", ".", "checkSkipLeft", "(", "err", ")", "{", "break", "\n", "}", "\n", "errs", ".", "AddError", "(", "err", ")", "\n", "}", "\n", "}", "\n", "return", "errs", "\n", "}" ]

[ "Commit", "commit", "data", "into", "result" ]

[ "func", "ParamsMatch", "(", "source", "string", ",", "pth", "string", ")", "(", "url", ".", "Values", ",", "string", ",", "bool", ")", "{", "var", "(", "i", ",", "j", "int", "\n", "p", "=", "make", "(", "url", ".", "Values", ")", "\n", "ext", "=", "path", ".", "Ext", "(", "pth", ")", "\n", ")", "\n\n", "pth", "=", "strings", ".", "TrimSuffix", "(", "pth", ",", "ext", ")", "\n\n", "if", "ext", "!=", "\"", "\"", "{", "p", ".", "Add", "(", "\"", "\"", ",", "strings", ".", "TrimPrefix", "(", "ext", ",", "\"", "\"", ")", ")", "\n", "}", "\n\n", "for", "i", "<", "len", "(", "pth", ")", "{", "switch", "{", "case", "j", ">=", "len", "(", "source", ")", ":", "if", "source", "!=", "\"", "\"", "&&", "len", "(", "source", ")", ">", "0", "&&", "source", "[", "len", "(", "source", ")", "-", "1", "]", "==", "'/'", "{", "return", "p", ",", "pth", "[", ":", "i", "]", ",", "true", "\n", "}", "\n\n", "if", "source", "==", "\"", "\"", "&&", "pth", "==", "\"", "\"", "{", "return", "p", ",", "pth", ",", "true", "\n", "}", "\n", "return", "p", ",", "pth", "[", ":", "i", "]", ",", "false", "\n", "case", "source", "[", "j", "]", "==", "':'", ":", "var", "name", ",", "val", "string", "\n", "var", "nextc", "byte", "\n\n", "name", ",", "nextc", ",", "j", "=", "match", "(", "source", ",", "isAlnum", ",", "j", "+", "1", ")", "\n", "val", ",", "_", ",", "i", "=", "match", "(", "pth", ",", "matchPart", "(", "nextc", ")", ",", "i", ")", "\n\n", "if", "(", "j", "<", "len", "(", "source", ")", ")", "&&", "source", "[", "j", "]", "==", "'['", "{", "var", "index", "int", "\n", "if", "idx", ":=", "strings", ".", "Index", "(", "source", "[", "j", ":", "]", ",", "\"", "\"", ")", ";", "idx", ">", "0", "{", "index", "=", "idx", "\n", "}", "else", "if", "source", "[", "len", "(", "source", ")", "-", "1", "]", "==", "']'", "{", "index", "=", "len", "(", "source", ")", "-", "j", "-", "1", "\n", "}", "\n\n", "if", "index", ">", "0", "{", "match", ":=", "strings", ".", "TrimSuffix", "(", "strings", ".", "TrimPrefix", "(", "source", "[", "j", ":", "j", "+", "index", "+", "1", "]", ",", "\"", "\"", ")", ",", "\"", "\"", ")", "\n", "if", "reg", ",", "err", ":=", "regexp", ".", "Compile", "(", "\"", "\"", "+", "match", "+", "\"", "\"", ")", ";", "err", "==", "nil", "&&", "reg", ".", "MatchString", "(", "val", ")", "{", "j", "=", "j", "+", "index", "+", "1", "\n", "}", "else", "{", "return", "nil", ",", "\"", "\"", ",", "false", "\n", "}", "\n", "}", "\n", "}", "\n\n", "p", ".", "Add", "(", "\"", "\"", "+", "name", ",", "val", ")", "\n", "case", "pth", "[", "i", "]", "==", "source", "[", "j", "]", ":", "i", "++", "\n", "j", "++", "\n", "default", ":", "return", "nil", ",", "\"", "\"", ",", "false", "\n", "}", "\n", "}", "\n\n", "if", "j", "!=", "len", "(", "source", ")", "{", "if", "(", "len", "(", "source", ")", "==", "j", "+", "1", ")", "&&", "source", "[", "j", "]", "==", "'/'", "{", "return", "p", ",", "pth", ",", "true", "\n", "}", "\n\n", "return", "nil", ",", "\"", "\"", ",", "false", "\n", "}", "\n", "return", "p", ",", "pth", ",", "true", "\n", "}" ]

[ "ParamsMatch", "match", "string", "by", "param" ]

[ "func", "(", "errs", "*", "Errors", ")", "AddError", "(", "errors", "...", "error", ")", "{", "for", "_", ",", "err", ":=", "range", "errors", "{", "if", "err", "!=", "nil", "{", "if", "e", ",", "ok", ":=", "err", ".", "(", "errorsInterface", ")", ";", "ok", "{", "errs", ".", "errors", "=", "append", "(", "errs", ".", "errors", ",", "e", ".", "GetErrors", "(", ")", "...", ")", "\n", "}", "else", "{", "errs", ".", "errors", "=", "append", "(", "errs", ".", "errors", ",", "err", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "AddError", "add", "error", "to", "Errors", "struct" ]

[ "func", "New", "(", "value", "interface", "{", "}", ")", "*", "Resource", "{", "var", "(", "name", "=", "utils", ".", "HumanizeString", "(", "utils", ".", "ModelType", "(", "value", ")", ".", "Name", "(", ")", ")", "\n", "res", "=", "&", "Resource", "{", "Value", ":", "value", ",", "Name", ":", "name", "}", "\n", ")", "\n\n", "res", ".", "FindOneHandler", "=", "res", ".", "findOneHandler", "\n", "res", ".", "FindManyHandler", "=", "res", ".", "findManyHandler", "\n", "res", ".", "SaveHandler", "=", "res", ".", "saveHandler", "\n", "res", ".", "DeleteHandler", "=", "res", ".", "deleteHandler", "\n", "res", ".", "SetPrimaryFields", "(", ")", "\n", "return", "res", "\n", "}" ]

[ "New", "initialize", "qor", "resource" ]

[ "func", "(", "res", "*", "Resource", ")", "SetPrimaryFields", "(", "fields", "...", "string", ")", "error", "{", "scope", ":=", "gorm", ".", "Scope", "{", "Value", ":", "res", ".", "Value", "}", "\n", "res", ".", "PrimaryFields", "=", "nil", "\n\n", "if", "len", "(", "fields", ")", ">", "0", "{", "for", "_", ",", "fieldName", ":=", "range", "fields", "{", "if", "field", ",", "ok", ":=", "scope", ".", "FieldByName", "(", "fieldName", ")", ";", "ok", "{", "res", ".", "PrimaryFields", "=", "append", "(", "res", ".", "PrimaryFields", ",", "field", ".", "StructField", ")", "\n", "}", "else", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "fieldName", ",", "res", ".", "Name", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", "\n\n", "if", "primaryField", ":=", "scope", ".", "PrimaryField", "(", ")", ";", "primaryField", "!=", "nil", "{", "res", ".", "PrimaryFields", "=", "[", "]", "*", "gorm", ".", "StructField", "{", "primaryField", ".", "StructField", "}", "\n", "return", "nil", "\n", "}", "\n\n", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "res", ".", "Name", ")", "\n", "}" ]

[ "SetPrimaryFields", "set", "primary", "fields" ]

[ "func", "(", "res", "*", "Resource", ")", "AddValidator", "(", "validator", "*", "Validator", ")", "{", "for", "idx", ",", "v", ":=", "range", "res", ".", "Validators", "{", "if", "v", ".", "Name", "==", "validator", ".", "Name", "{", "res", ".", "Validators", "[", "idx", "]", "=", "validator", "\n", "return", "\n", "}", "\n", "}", "\n\n", "res", ".", "Validators", "=", "append", "(", "res", ".", "Validators", ",", "validator", ")", "\n", "}" ]

[ "AddValidator", "add", "validator", "to", "resource", "it", "will", "invoked", "when", "creating", "updating", "and", "will", "rollback", "the", "change", "if", "validator", "return", "any", "error" ]

[ "func", "(", "res", "*", "Resource", ")", "AddProcessor", "(", "processor", "*", "Processor", ")", "{", "for", "idx", ",", "p", ":=", "range", "res", ".", "Processors", "{", "if", "p", ".", "Name", "==", "processor", ".", "Name", "{", "res", ".", "Processors", "[", "idx", "]", "=", "processor", "\n", "return", "\n", "}", "\n", "}", "\n", "res", ".", "Processors", "=", "append", "(", "res", ".", "Processors", ",", "processor", ")", "\n", "}" ]

[ "AddProcessor", "add", "processor", "to", "resource", "it", "is", "used", "to", "process", "data", "before", "creating", "updating", "will", "rollback", "the", "change", "if", "it", "return", "any", "error" ]

[ "func", "(", "res", "*", "Resource", ")", "NewStruct", "(", ")", "interface", "{", "}", "{", "if", "res", ".", "Value", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "return", "reflect", ".", "New", "(", "utils", ".", "Indirect", "(", "reflect", ".", "ValueOf", "(", "res", ".", "Value", ")", ")", ".", "Type", "(", ")", ")", ".", "Interface", "(", ")", "\n", "}" ]

[ "NewStruct", "initialize", "a", "struct", "for", "the", "Resource" ]

[ "func", "(", "res", "*", "Resource", ")", "NewSlice", "(", ")", "interface", "{", "}", "{", "if", "res", ".", "Value", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "sliceType", ":=", "reflect", ".", "SliceOf", "(", "reflect", ".", "TypeOf", "(", "res", ".", "Value", ")", ")", "\n", "slice", ":=", "reflect", ".", "MakeSlice", "(", "sliceType", ",", "0", ",", "0", ")", "\n", "slicePtr", ":=", "reflect", ".", "New", "(", "sliceType", ")", "\n", "slicePtr", ".", "Elem", "(", ")", ".", "Set", "(", "slice", ")", "\n", "return", "slicePtr", ".", "Interface", "(", ")", "\n", "}" ]

[ "NewSlice", "initialize", "a", "slice", "of", "struct", "for", "the", "Resource" ]

[ "func", "(", "res", "*", "Resource", ")", "HasPermission", "(", "mode", "roles", ".", "PermissionMode", ",", "context", "*", "qor", ".", "Context", ")", "bool", "{", "if", "res", "==", "nil", "||", "res", ".", "Permission", "==", "nil", "{", "return", "true", "\n", "}", "\n\n", "var", "roles", "=", "[", "]", "interface", "{", "}", "{", "}", "\n", "for", "_", ",", "role", ":=", "range", "context", ".", "Roles", "{", "roles", "=", "append", "(", "roles", ",", "role", ")", "\n", "}", "\n", "return", "res", ".", "Permission", ".", "HasPermission", "(", "mode", ",", "roles", "...", ")", "\n", "}" ]

[ "HasPermission", "check", "permission", "of", "resource" ]

[ "func", "(", "mvs", "MetaValues", ")", "Get", "(", "name", "string", ")", "*", "MetaValue", "{", "for", "_", ",", "mv", ":=", "range", "mvs", ".", "Values", "{", "if", "mv", ".", "Name", "==", "name", "{", "return", "mv", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Get", "get", "meta", "value", "from", "MetaValues", "with", "name" ]

[ "func", "GOPATH", "(", ")", "[", "]", "string", "{", "paths", ":=", "strings", ".", "Split", "(", "os", ".", "Getenv", "(", "\"", "\"", ")", ",", "string", "(", "os", ".", "PathListSeparator", ")", ")", "\n", "if", "len", "(", "paths", ")", "==", "0", "{", "fmt", ".", "Println", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "paths", "\n", "}" ]

[ "GOPATH", "return", "GOPATH", "from", "env" ]

[ "func", "SetCookie", "(", "cookie", "http", ".", "Cookie", ",", "context", "*", "qor", ".", "Context", ")", "{", "cookie", ".", "HttpOnly", "=", "true", "\n\n", "// set https cookie", "if", "context", ".", "Request", "!=", "nil", "&&", "context", ".", "Request", ".", "URL", ".", "Scheme", "==", "\"", "\"", "{", "cookie", ".", "Secure", "=", "true", "\n", "}", "\n\n", "// set default path", "if", "cookie", ".", "Path", "==", "\"", "\"", "{", "cookie", ".", "Path", "=", "\"", "\"", "\n", "}", "\n\n", "http", ".", "SetCookie", "(", "context", ".", "Writer", ",", "&", "cookie", ")", "\n", "}" ]

[ "SetCookie", "set", "cookie", "for", "context" ]

[ "func", "Stringify", "(", "object", "interface", "{", "}", ")", "string", "{", "if", "obj", ",", "ok", ":=", "object", ".", "(", "interface", "{", "Stringify", "(", ")", "string", "\n", "}", ")", ";", "ok", "{", "return", "obj", ".", "Stringify", "(", ")", "\n", "}", "\n\n", "scope", ":=", "gorm", ".", "Scope", "{", "Value", ":", "object", "}", "\n", "for", "_", ",", "column", ":=", "range", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", "}", "{", "if", "field", ",", "ok", ":=", "scope", ".", "FieldByName", "(", "column", ")", ";", "ok", "{", "if", "field", ".", "Field", ".", "IsValid", "(", ")", "{", "result", ":=", "field", ".", "Field", ".", "Interface", "(", ")", "\n", "if", "valuer", ",", "ok", ":=", "result", ".", "(", "driver", ".", "Valuer", ")", ";", "ok", "{", "if", "result", ",", "err", ":=", "valuer", ".", "Value", "(", ")", ";", "err", "==", "nil", "{", "return", "fmt", ".", "Sprint", "(", "result", ")", "\n", "}", "\n", "}", "\n", "return", "fmt", ".", "Sprint", "(", "result", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "if", "scope", ".", "PrimaryField", "(", ")", "!=", "nil", "{", "if", "scope", ".", "PrimaryKeyZero", "(", ")", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "scope", ".", "GetModelStruct", "(", ")", ".", "ModelType", ".", "Name", "(", ")", ",", "scope", ".", "PrimaryKeyValue", "(", ")", ")", "\n", "}", "\n\n", "return", "fmt", ".", "Sprint", "(", "reflect", ".", "Indirect", "(", "reflect", ".", "ValueOf", "(", "object", ")", ")", ".", "Interface", "(", ")", ")", "\n", "}" ]

[ "Stringify", "stringify", "any", "data", "if", "it", "is", "a", "struct", "will", "try", "to", "use", "its", "Name", "Title", "Code", "field", "else", "will", "use", "its", "primary", "key" ]

[ "func", "ExitWithMsg", "(", "msg", "interface", "{", "}", ",", "value", "...", "interface", "{", "}", ")", "{", "fmt", ".", "Printf", "(", "\"", "\\n", "\"", "+", "filenameWithLineNum", "(", ")", "+", "\"", "\\n", "\"", "+", "fmt", ".", "Sprint", "(", "msg", ")", "+", "\"", "\\n", "\"", ",", "value", "...", ")", "\n", "debug", ".", "PrintStack", "(", ")", "\n", "}" ]

[ "ExitWithMsg", "debug", "error", "messages", "and", "print", "stack" ]

[ "func", "FileServer", "(", "dir", "http", ".", "Dir", ")", "http", ".", "Handler", "{", "return", "http", ".", "HandlerFunc", "(", "func", "(", "w", "http", ".", "ResponseWriter", ",", "r", "*", "http", ".", "Request", ")", "{", "p", ":=", "path", ".", "Join", "(", "string", "(", "dir", ")", ",", "r", ".", "URL", ".", "Path", ")", "\n", "if", "f", ",", "err", ":=", "os", ".", "Stat", "(", "p", ")", ";", "err", "==", "nil", "&&", "!", "f", ".", "IsDir", "(", ")", "{", "http", ".", "ServeFile", "(", "w", ",", "r", ",", "p", ")", "\n", "return", "\n", "}", "\n\n", "http", ".", "NotFound", "(", "w", ",", "r", ")", "\n", "}", ")", "\n", "}" ]

[ "FileServer", "file", "server", "that", "disabled", "file", "listing" ]

[ "func", "SortFormKeys", "(", "strs", "[", "]", "string", ")", "{", "sort", ".", "Slice", "(", "strs", ",", "func", "(", "i", ",", "j", "int", ")", "bool", "{", "// true for first", "str1", ":=", "strs", "[", "i", "]", "\n", "str2", ":=", "strs", "[", "j", "]", "\n", "matched1", ":=", "replaceIdxRegexp", ".", "FindAllStringIndex", "(", "str1", ",", "-", "1", ")", "\n", "matched2", ":=", "replaceIdxRegexp", ".", "FindAllStringIndex", "(", "str2", ",", "-", "1", ")", "\n\n", "for", "x", ":=", "0", ";", "x", "<", "len", "(", "matched1", ")", ";", "x", "++", "{", "prefix1", ":=", "str1", "[", ":", "matched1", "[", "x", "]", "[", "0", "]", "]", "\n", "prefix2", ":=", "str2", "\n\n", "if", "len", "(", "matched2", ")", ">=", "x", "+", "1", "{", "prefix2", "=", "str2", "[", ":", "matched2", "[", "x", "]", "[", "0", "]", "]", "\n", "}", "\n\n", "if", "prefix1", "!=", "prefix2", "{", "return", "strings", ".", "Compare", "(", "prefix1", ",", "prefix2", ")", "<", "0", "\n", "}", "\n\n", "if", "len", "(", "matched2", ")", "<", "x", "+", "1", "{", "return", "false", "\n", "}", "\n\n", "number1", ":=", "str1", "[", "matched1", "[", "x", "]", "[", "0", "]", ":", "matched1", "[", "x", "]", "[", "1", "]", "]", "\n", "number2", ":=", "str2", "[", "matched2", "[", "x", "]", "[", "0", "]", ":", "matched2", "[", "x", "]", "[", "1", "]", "]", "\n\n", "if", "number1", "!=", "number2", "{", "if", "len", "(", "number1", ")", "!=", "len", "(", "number2", ")", "{", "return", "len", "(", "number1", ")", "<", "len", "(", "number2", ")", "\n", "}", "\n", "return", "strings", ".", "Compare", "(", "number1", ",", "number2", ")", "<", "0", "\n", "}", "\n", "}", "\n\n", "return", "strings", ".", "Compare", "(", "str1", ",", "str2", ")", "<", "0", "\n", "}", ")", "\n", "}" ]

[ "SortFormKeys", "sort", "form", "keys" ]

[ "func", "Indirect", "(", "v", "reflect", ".", "Value", ")", "reflect", ".", "Value", "{", "for", "v", ".", "Kind", "(", ")", "==", "reflect", ".", "Ptr", "{", "v", "=", "reflect", ".", "Indirect", "(", "v", ")", "\n", "}", "\n", "return", "v", "\n", "}" ]

[ "Indirect", "returns", "last", "value", "that", "v", "points", "to" ]

[ "func", "SliceUniq", "(", "s", "[", "]", "string", ")", "[", "]", "string", "{", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "s", ")", ";", "i", "++", "{", "for", "i2", ":=", "i", "+", "1", ";", "i2", "<", "len", "(", "s", ")", ";", "i2", "++", "{", "if", "s", "[", "i", "]", "==", "s", "[", "i2", "]", "{", "// delete", "s", "=", "append", "(", "s", "[", ":", "i2", "]", ",", "s", "[", "i2", "+", "1", ":", "]", "...", ")", "\n", "i2", "--", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "s", "\n", "}" ]

[ "SliceUniq", "removes", "duplicate", "values", "in", "given", "slice" ]

[ "func", "NewValue", "(", "t", "reflect", ".", "Type", ")", "(", "v", "reflect", ".", "Value", ")", "{", "v", "=", "reflect", ".", "New", "(", "t", ")", "\n", "ov", ":=", "v", "\n", "for", "t", ".", "Kind", "(", ")", "==", "reflect", ".", "Ptr", "{", "v", "=", "v", ".", "Elem", "(", ")", "\n", "t", "=", "t", ".", "Elem", "(", ")", "\n", "e", ":=", "reflect", ".", "New", "(", "t", ")", "\n", "v", ".", "Set", "(", "e", ")", "\n", "}", "\n\n", "if", "e", ":=", "v", ".", "Elem", "(", ")", ";", "e", ".", "Kind", "(", ")", "==", "reflect", ".", "Map", "&&", "e", ".", "IsNil", "(", ")", "{", "v", ".", "Elem", "(", ")", ".", "Set", "(", "reflect", ".", "MakeMap", "(", "v", ".", "Elem", "(", ")", ".", "Type", "(", ")", ")", ")", "\n", "}", "\n", "return", "ov", "\n", "}" ]

[ "NewValue", "new", "struct", "value", "with", "reflect", "type" ]

[ "func", "ToArray", "(", "value", "interface", "{", "}", ")", "(", "values", "[", "]", "string", ")", "{", "switch", "value", ":=", "value", ".", "(", "type", ")", "{", "case", "[", "]", "string", ":", "values", "=", "[", "]", "string", "{", "}", "\n", "for", "_", ",", "v", ":=", "range", "value", "{", "if", "v", "!=", "\"", "\"", "{", "values", "=", "append", "(", "values", ",", "v", ")", "\n", "}", "\n", "}", "\n", "case", "[", "]", "interface", "{", "}", ":", "for", "_", ",", "v", ":=", "range", "value", "{", "values", "=", "append", "(", "values", ",", "fmt", ".", "Sprint", "(", "v", ")", ")", "\n", "}", "\n", "default", ":", "if", "value", ":=", "fmt", ".", "Sprint", "(", "value", ")", ";", "value", "!=", "\"", "\"", "{", "values", "=", "[", "]", "string", "{", "value", "}", "\n", "}", "\n", "}", "\n", "return", "\n", "}" ]

[ "ToArray", "get", "array", "from", "value", "will", "ignore", "blank", "string", "to", "convert", "it", "to", "array" ]

[ "func", "ToString", "(", "value", "interface", "{", "}", ")", "string", "{", "if", "v", ",", "ok", ":=", "value", ".", "(", "[", "]", "string", ")", ";", "ok", "{", "for", "_", ",", "s", ":=", "range", "v", "{", "if", "s", "!=", "\"", "\"", "{", "return", "s", "\n", "}", "\n", "}", "\n", "return", "\"", "\"", "\n", "}", "else", "if", "v", ",", "ok", ":=", "value", ".", "(", "string", ")", ";", "ok", "{", "return", "v", "\n", "}", "else", "if", "v", ",", "ok", ":=", "value", ".", "(", "[", "]", "interface", "{", "}", ")", ";", "ok", "{", "for", "_", ",", "s", ":=", "range", "v", "{", "if", "fmt", ".", "Sprint", "(", "s", ")", "!=", "\"", "\"", "{", "return", "fmt", ".", "Sprint", "(", "s", ")", "\n", "}", "\n", "}", "\n", "return", "\"", "\"", "\n", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "value", ")", "\n", "}" ]

[ "ToString", "get", "string", "from", "value", "if", "passed", "value", "is", "a", "slice", "will", "use", "the", "first", "element" ]

[ "func", "ToInt", "(", "value", "interface", "{", "}", ")", "int64", "{", "if", "result", ":=", "ToString", "(", "value", ")", ";", "result", "==", "\"", "\"", "{", "return", "0", "\n", "}", "else", "if", "i", ",", "err", ":=", "strconv", ".", "ParseInt", "(", "result", ",", "10", ",", "64", ")", ";", "err", "==", "nil", "{", "return", "i", "\n", "}", "else", "{", "panic", "(", "\"", "\"", "+", "result", ")", "\n", "}", "\n", "}" ]

[ "ToInt", "get", "int", "from", "value", "if", "passed", "value", "is", "empty", "string", "result", "will", "be", "0" ]

[ "func", "ToUint", "(", "value", "interface", "{", "}", ")", "uint64", "{", "if", "result", ":=", "ToString", "(", "value", ")", ";", "result", "==", "\"", "\"", "{", "return", "0", "\n", "}", "else", "if", "i", ",", "err", ":=", "strconv", ".", "ParseUint", "(", "result", ",", "10", ",", "64", ")", ";", "err", "==", "nil", "{", "return", "i", "\n", "}", "else", "{", "panic", "(", "\"", "\"", "+", "result", ")", "\n", "}", "\n", "}" ]

[ "ToUint", "get", "uint", "from", "value", "if", "passed", "value", "is", "empty", "string", "result", "will", "be", "0" ]

[ "func", "ToFloat", "(", "value", "interface", "{", "}", ")", "float64", "{", "if", "result", ":=", "ToString", "(", "value", ")", ";", "result", "==", "\"", "\"", "{", "return", "0", "\n", "}", "else", "if", "i", ",", "err", ":=", "strconv", ".", "ParseFloat", "(", "result", ",", "64", ")", ";", "err", "==", "nil", "{", "return", "i", "\n", "}", "else", "{", "panic", "(", "\"", "\"", "+", "result", ")", "\n", "}", "\n", "}" ]

[ "ToFloat", "get", "float", "from", "value", "if", "passed", "value", "is", "empty", "string", "result", "will", "be", "0" ]

[ "func", "NewARC", "(", "size", "int", ")", "(", "*", "ARCCache", ",", "error", ")", "{", "// Create the sub LRUs", "b1", ",", "err", ":=", "simplelru", ".", "NewLRU", "(", "size", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "b2", ",", "err", ":=", "simplelru", ".", "NewLRU", "(", "size", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "t1", ",", "err", ":=", "simplelru", ".", "NewLRU", "(", "size", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "t2", ",", "err", ":=", "simplelru", ".", "NewLRU", "(", "size", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Initialize the ARC", "c", ":=", "&", "ARCCache", "{", "size", ":", "size", ",", "p", ":", "0", ",", "t1", ":", "t1", ",", "b1", ":", "b1", ",", "t2", ":", "t2", ",", "b2", ":", "b2", ",", "}", "\n", "return", "c", ",", "nil", "\n", "}" ]

[ "NewARC", "creates", "an", "ARC", "of", "the", "given", "size" ]

[ "func", "(", "c", "*", "ARCCache", ")", "replace", "(", "b2ContainsKey", "bool", ")", "{", "t1Len", ":=", "c", ".", "t1", ".", "Len", "(", ")", "\n", "if", "t1Len", ">", "0", "&&", "(", "t1Len", ">", "c", ".", "p", "||", "(", "t1Len", "==", "c", ".", "p", "&&", "b2ContainsKey", ")", ")", "{", "k", ",", "_", ",", "ok", ":=", "c", ".", "t1", ".", "RemoveOldest", "(", ")", "\n", "if", "ok", "{", "c", ".", "b1", ".", "Add", "(", "k", ",", "nil", ")", "\n", "}", "\n", "}", "else", "{", "k", ",", "_", ",", "ok", ":=", "c", ".", "t2", ".", "RemoveOldest", "(", ")", "\n", "if", "ok", "{", "c", ".", "b2", ".", "Add", "(", "k", ",", "nil", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "replace", "is", "used", "to", "adaptively", "evict", "from", "either", "T1", "or", "T2", "based", "on", "the", "current", "learned", "value", "of", "P" ]

[ "func", "(", "c", "*", "ARCCache", ")", "Len", "(", ")", "int", "{", "c", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "c", ".", "lock", ".", "RUnlock", "(", ")", "\n", "return", "c", ".", "t1", ".", "Len", "(", ")", "+", "c", ".", "t2", ".", "Len", "(", ")", "\n", "}" ]

[ "Len", "returns", "the", "number", "of", "cached", "entries" ]

[ "func", "(", "c", "*", "ARCCache", ")", "Keys", "(", ")", "[", "]", "interface", "{", "}", "{", "c", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "c", ".", "lock", ".", "RUnlock", "(", ")", "\n", "k1", ":=", "c", ".", "t1", ".", "Keys", "(", ")", "\n", "k2", ":=", "c", ".", "t2", ".", "Keys", "(", ")", "\n", "return", "append", "(", "k1", ",", "k2", "...", ")", "\n", "}" ]

[ "Keys", "returns", "all", "the", "cached", "keys" ]

[ "func", "(", "c", "*", "ARCCache", ")", "Remove", "(", "key", "interface", "{", "}", ")", "{", "c", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "lock", ".", "Unlock", "(", ")", "\n", "if", "c", ".", "t1", ".", "Remove", "(", "key", ")", "{", "return", "\n", "}", "\n", "if", "c", ".", "t2", ".", "Remove", "(", "key", ")", "{", "return", "\n", "}", "\n", "if", "c", ".", "b1", ".", "Remove", "(", "key", ")", "{", "return", "\n", "}", "\n", "if", "c", ".", "b2", ".", "Remove", "(", "key", ")", "{", "return", "\n", "}", "\n", "}" ]

[ "Remove", "is", "used", "to", "purge", "a", "key", "from", "the", "cache" ]

[ "func", "New2QParams", "(", "size", "int", ",", "recentRatio", "float64", ",", "ghostRatio", "float64", ")", "(", "*", "TwoQueueCache", ",", "error", ")", "{", "if", "size", "<=", "0", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "recentRatio", "<", "0.0", "||", "recentRatio", ">", "1.0", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "ghostRatio", "<", "0.0", "||", "ghostRatio", ">", "1.0", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Determine the sub-sizes", "recentSize", ":=", "int", "(", "float64", "(", "size", ")", "*", "recentRatio", ")", "\n", "evictSize", ":=", "int", "(", "float64", "(", "size", ")", "*", "ghostRatio", ")", "\n\n", "// Allocate the LRUs", "recent", ",", "err", ":=", "simplelru", ".", "NewLRU", "(", "size", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "frequent", ",", "err", ":=", "simplelru", ".", "NewLRU", "(", "size", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "recentEvict", ",", "err", ":=", "simplelru", ".", "NewLRU", "(", "evictSize", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Initialize the cache", "c", ":=", "&", "TwoQueueCache", "{", "size", ":", "size", ",", "recentSize", ":", "recentSize", ",", "recent", ":", "recent", ",", "frequent", ":", "frequent", ",", "recentEvict", ":", "recentEvict", ",", "}", "\n", "return", "c", ",", "nil", "\n", "}" ]

[ "New2QParams", "creates", "a", "new", "TwoQueueCache", "using", "the", "provided", "parameter", "values", "." ]

[ "func", "(", "c", "*", "TwoQueueCache", ")", "ensureSpace", "(", "recentEvict", "bool", ")", "{", "// If we have space, nothing to do", "recentLen", ":=", "c", ".", "recent", ".", "Len", "(", ")", "\n", "freqLen", ":=", "c", ".", "frequent", ".", "Len", "(", ")", "\n", "if", "recentLen", "+", "freqLen", "<", "c", ".", "size", "{", "return", "\n", "}", "\n\n", "// If the recent buffer is larger than", "// the target, evict from there", "if", "recentLen", ">", "0", "&&", "(", "recentLen", ">", "c", ".", "recentSize", "||", "(", "recentLen", "==", "c", ".", "recentSize", "&&", "!", "recentEvict", ")", ")", "{", "k", ",", "_", ",", "_", ":=", "c", ".", "recent", ".", "RemoveOldest", "(", ")", "\n", "c", ".", "recentEvict", ".", "Add", "(", "k", ",", "nil", ")", "\n", "return", "\n", "}", "\n\n", "// Remove from the frequent list otherwise", "c", ".", "frequent", ".", "RemoveOldest", "(", ")", "\n", "}" ]

[ "ensureSpace", "is", "used", "to", "ensure", "we", "have", "space", "in", "the", "cache" ]

[ "func", "(", "c", "*", "TwoQueueCache", ")", "Keys", "(", ")", "[", "]", "interface", "{", "}", "{", "c", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "c", ".", "lock", ".", "RUnlock", "(", ")", "\n", "k1", ":=", "c", ".", "frequent", ".", "Keys", "(", ")", "\n", "k2", ":=", "c", ".", "recent", ".", "Keys", "(", ")", "\n", "return", "append", "(", "k1", ",", "k2", "...", ")", "\n", "}" ]

[ "Keys", "returns", "a", "slice", "of", "the", "keys", "in", "the", "cache", ".", "The", "frequently", "used", "keys", "are", "first", "in", "the", "returned", "slice", "." ]