Datasets:

---

semeru

/

code-text-go

like 3

Follow

Semeru Lab 8

[ "func", "(", "d", "*", "Decoder", ")", "Decode", "(", "config", "*", "Config", ")", "error", "{", "cb", ":=", "func", "(", "s", "string", ",", "ss", "string", ",", "k", "string", ",", "v", "string", ",", "bv", "bool", ")", "error", "{", "if", "ss", "==", "\"", "\"", "&&", "k", "==", "\"", "\"", "{", "config", ".", "Section", "(", "s", ")", "\n", "return", "nil", "\n", "}", "\n\n", "if", "ss", "!=", "\"", "\"", "&&", "k", "==", "\"", "\"", "{", "config", ".", "Section", "(", "s", ")", ".", "Subsection", "(", "ss", ")", "\n", "return", "nil", "\n", "}", "\n\n", "config", ".", "AddOption", "(", "s", ",", "ss", ",", "k", ",", "v", ")", "\n", "return", "nil", "\n", "}", "\n", "return", "gcfg", ".", "ReadWithCallback", "(", "d", ",", "cb", ")", "\n", "}" ]

[ "Decode", "reads", "the", "whole", "config", "from", "its", "input", "and", "stores", "it", "in", "the", "value", "pointed", "to", "by", "config", "." ]

[ "func", "(", "s", "Status", ")", "File", "(", "path", "string", ")", "*", "FileStatus", "{", "if", "_", ",", "ok", ":=", "(", "s", ")", "[", "path", "]", ";", "!", "ok", "{", "s", "[", "path", "]", "=", "&", "FileStatus", "{", "Worktree", ":", "Untracked", ",", "Staging", ":", "Untracked", "}", "\n", "}", "\n\n", "return", "s", "[", "path", "]", "\n", "}" ]

[ "File", "returns", "the", "FileStatus", "for", "a", "given", "path", "if", "the", "FileStatus", "doesn", "t", "exists", "a", "new", "FileStatus", "is", "added", "to", "the", "map", "using", "the", "path", "as", "key", "." ]

[ "func", "(", "s", "Status", ")", "IsUntracked", "(", "path", "string", ")", "bool", "{", "stat", ",", "ok", ":=", "(", "s", ")", "[", "filepath", ".", "ToSlash", "(", "path", ")", "]", "\n", "return", "ok", "&&", "stat", ".", "Worktree", "==", "Untracked", "\n", "}" ]

[ "IsUntracked", "checks", "if", "file", "for", "given", "path", "is", "Untracked" ]

[ "func", "(", "s", "Status", ")", "IsClean", "(", ")", "bool", "{", "for", "_", ",", "status", ":=", "range", "s", "{", "if", "status", ".", "Worktree", "!=", "Unmodified", "||", "status", ".", "Staging", "!=", "Unmodified", "{", "return", "false", "\n", "}", "\n", "}", "\n\n", "return", "true", "\n", "}" ]

[ "IsClean", "returns", "true", "if", "all", "the", "files", "are", "in", "Unmodified", "status", "." ]

[ "func", "(", "r", "*", "Repository", ")", "DeleteObject", "(", "hash", "plumbing", ".", "Hash", ")", "error", "{", "los", ",", "ok", ":=", "r", ".", "Storer", ".", "(", "storer", ".", "LooseObjectStorer", ")", "\n", "if", "!", "ok", "{", "return", "ErrLooseObjectsNotSupported", "\n", "}", "\n\n", "return", "los", ".", "DeleteLooseObject", "(", "hash", ")", "\n", "}" ]

[ "DeleteObject", "deletes", "an", "object", "from", "a", "repository", ".", "The", "type", "conveniently", "matches", "PruneHandler", "." ]

[ "func", "main", "(", ")", "{", "CheckArgs", "(", "\"", "\"", ",", "\"", "\"", ")", "\n\n", "path", ":=", "os", ".", "Args", "[", "1", "]", "\n", "revision", ":=", "os", ".", "Args", "[", "2", "]", "\n\n", "// We instantiate a new repository targeting the given path (the .git folder)", "r", ",", "err", ":=", "git", ".", "PlainOpen", "(", "path", ")", "\n", "CheckIfError", "(", "err", ")", "\n\n", "// Resolve revision into a sha1 commit, only some revisions are resolved", "// look at the doc to get more details", "Info", "(", "\"", "\"", ",", "revision", ")", "\n\n", "h", ",", "err", ":=", "r", ".", "ResolveRevision", "(", "plumbing", ".", "Revision", "(", "revision", ")", ")", "\n\n", "CheckIfError", "(", "err", ")", "\n\n", "fmt", ".", "Println", "(", "h", ".", "String", "(", ")", ")", "\n", "}" ]

[ "Example", "how", "to", "resolve", "a", "revision", "into", "its", "commit", "counterpart" ]

[ "func", "(", "c", "*", "client", ")", "NewUploadPackSession", "(", "ep", "*", "transport", ".", "Endpoint", ",", "auth", "transport", ".", "AuthMethod", ")", "(", "transport", ".", "UploadPackSession", ",", "error", ")", "{", "return", "c", ".", "newSession", "(", "transport", ".", "UploadPackServiceName", ",", "ep", ",", "auth", ")", "\n", "}" ]

[ "NewUploadPackSession", "creates", "a", "new", "UploadPackSession", "." ]

[ "func", "(", "c", "*", "client", ")", "NewReceivePackSession", "(", "ep", "*", "transport", ".", "Endpoint", ",", "auth", "transport", ".", "AuthMethod", ")", "(", "transport", ".", "ReceivePackSession", ",", "error", ")", "{", "return", "c", ".", "newSession", "(", "transport", ".", "ReceivePackServiceName", ",", "ep", ",", "auth", ")", "\n", "}" ]

[ "NewReceivePackSession", "creates", "a", "new", "ReceivePackSession", "." ]

[ "func", "(", "s", "*", "session", ")", "AdvertisedReferences", "(", ")", "(", "*", "packp", ".", "AdvRefs", ",", "error", ")", "{", "if", "s", ".", "advRefs", "!=", "nil", "{", "return", "s", ".", "advRefs", ",", "nil", "\n", "}", "\n\n", "ar", ":=", "packp", ".", "NewAdvRefs", "(", ")", "\n", "if", "err", ":=", "ar", ".", "Decode", "(", "s", ".", "Stdout", ")", ";", "err", "!=", "nil", "{", "if", "err", ":=", "s", ".", "handleAdvRefDecodeError", "(", "err", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "transport", ".", "FilterUnsupportedCapabilities", "(", "ar", ".", "Capabilities", ")", "\n", "s", ".", "advRefs", "=", "ar", "\n", "return", "ar", ",", "nil", "\n", "}" ]

[ "AdvertisedReferences", "retrieves", "the", "advertised", "references", "from", "the", "server", "." ]

[ "func", "(", "s", "*", "session", ")", "UploadPack", "(", "ctx", "context", ".", "Context", ",", "req", "*", "packp", ".", "UploadPackRequest", ")", "(", "*", "packp", ".", "UploadPackResponse", ",", "error", ")", "{", "if", "req", ".", "IsEmpty", "(", ")", "{", "return", "nil", ",", "transport", ".", "ErrEmptyUploadPackRequest", "\n", "}", "\n\n", "if", "err", ":=", "req", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "_", ",", "err", ":=", "s", ".", "AdvertisedReferences", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "s", ".", "packRun", "=", "true", "\n\n", "in", ":=", "s", ".", "StdinContext", "(", "ctx", ")", "\n", "out", ":=", "s", ".", "StdoutContext", "(", "ctx", ")", "\n\n", "if", "err", ":=", "uploadPack", "(", "in", ",", "out", ",", "req", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "r", ",", "err", ":=", "ioutil", ".", "NonEmptyReader", "(", "out", ")", "\n", "if", "err", "==", "ioutil", ".", "ErrEmptyReader", "{", "if", "c", ",", "ok", ":=", "s", ".", "Stdout", ".", "(", "io", ".", "Closer", ")", ";", "ok", "{", "_", "=", "c", ".", "Close", "(", ")", "\n", "}", "\n\n", "return", "nil", ",", "transport", ".", "ErrEmptyUploadPackRequest", "\n", "}", "\n\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "rc", ":=", "ioutil", ".", "NewReadCloser", "(", "r", ",", "s", ")", "\n", "return", "DecodeUploadPackResponse", "(", "rc", ",", "req", ")", "\n", "}" ]

[ "UploadPack", "performs", "a", "request", "to", "the", "server", "to", "fetch", "a", "packfile", ".", "A", "reader", "is", "returned", "with", "the", "packfile", "content", ".", "The", "reader", "must", "be", "closed", "after", "reading", "." ]

[ "func", "uploadPack", "(", "w", "io", ".", "WriteCloser", ",", "r", "io", ".", "Reader", ",", "req", "*", "packp", ".", "UploadPackRequest", ")", "error", "{", "// TODO support multi_ack mode", "// TODO support multi_ack_detailed mode", "// TODO support acks for common objects", "// TODO build a proper state machine for all these processing options", "if", "err", ":=", "req", ".", "UploadRequest", ".", "Encode", "(", "w", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "if", "err", ":=", "req", ".", "UploadHaves", ".", "Encode", "(", "w", ",", "true", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "if", "err", ":=", "sendDone", "(", "w", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "if", "err", ":=", "w", ".", "Close", "(", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "uploadPack", "implements", "the", "git", "-", "upload", "-", "pack", "protocol", "." ]

[ "func", "DecodeUploadPackResponse", "(", "r", "io", ".", "ReadCloser", ",", "req", "*", "packp", ".", "UploadPackRequest", ")", "(", "*", "packp", ".", "UploadPackResponse", ",", "error", ",", ")", "{", "res", ":=", "packp", ".", "NewUploadPackResponse", "(", "req", ")", "\n", "if", "err", ":=", "res", ".", "Decode", "(", "r", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "res", ",", "nil", "\n", "}" ]

[ "DecodeUploadPackResponse", "decodes", "r", "into", "a", "new", "packp", ".", "UploadPackResponse" ]

[ "func", "(", "w", "*", "Worktree", ")", "Pull", "(", "o", "*", "PullOptions", ")", "error", "{", "return", "w", ".", "PullContext", "(", "context", ".", "Background", "(", ")", ",", "o", ")", "\n", "}" ]

[ "Pull", "incorporates", "changes", "from", "a", "remote", "repository", "into", "the", "current", "branch", ".", "Returns", "nil", "if", "the", "operation", "is", "successful", "NoErrAlreadyUpToDate", "if", "there", "are", "no", "changes", "to", "be", "fetched", "or", "an", "error", ".", "Pull", "only", "supports", "merges", "where", "the", "can", "be", "resolved", "as", "a", "fast", "-", "forward", "." ]

[ "func", "(", "w", "*", "Worktree", ")", "PullContext", "(", "ctx", "context", ".", "Context", ",", "o", "*", "PullOptions", ")", "error", "{", "if", "err", ":=", "o", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "remote", ",", "err", ":=", "w", ".", "r", ".", "Remote", "(", "o", ".", "RemoteName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "fetchHead", ",", "err", ":=", "remote", ".", "fetch", "(", "ctx", ",", "&", "FetchOptions", "{", "RemoteName", ":", "o", ".", "RemoteName", ",", "Depth", ":", "o", ".", "Depth", ",", "Auth", ":", "o", ".", "Auth", ",", "Progress", ":", "o", ".", "Progress", ",", "Force", ":", "o", ".", "Force", ",", "}", ")", "\n\n", "updated", ":=", "true", "\n", "if", "err", "==", "NoErrAlreadyUpToDate", "{", "updated", "=", "false", "\n", "}", "else", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "ref", ",", "err", ":=", "storer", ".", "ResolveReference", "(", "fetchHead", ",", "o", ".", "ReferenceName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "head", ",", "err", ":=", "w", ".", "r", ".", "Head", "(", ")", "\n", "if", "err", "==", "nil", "{", "if", "!", "updated", "&&", "head", ".", "Hash", "(", ")", "==", "ref", ".", "Hash", "(", ")", "{", "return", "NoErrAlreadyUpToDate", "\n", "}", "\n\n", "ff", ",", "err", ":=", "isFastForward", "(", "w", ".", "r", ".", "Storer", ",", "head", ".", "Hash", "(", ")", ",", "ref", ".", "Hash", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "!", "ff", "{", "return", "ErrNonFastForwardUpdate", "\n", "}", "\n", "}", "\n\n", "if", "err", "!=", "nil", "&&", "err", "!=", "plumbing", ".", "ErrReferenceNotFound", "{", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "w", ".", "updateHEAD", "(", "ref", ".", "Hash", "(", ")", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "w", ".", "Reset", "(", "&", "ResetOptions", "{", "Mode", ":", "MergeReset", ",", "Commit", ":", "ref", ".", "Hash", "(", ")", ",", "}", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "o", ".", "RecurseSubmodules", "!=", "NoRecurseSubmodules", "{", "return", "w", ".", "updateSubmodules", "(", "&", "SubmoduleUpdateOptions", "{", "RecurseSubmodules", ":", "o", ".", "RecurseSubmodules", ",", "Auth", ":", "o", ".", "Auth", ",", "}", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "PullContext", "incorporates", "changes", "from", "a", "remote", "repository", "into", "the", "current", "branch", ".", "Returns", "nil", "if", "the", "operation", "is", "successful", "NoErrAlreadyUpToDate", "if", "there", "are", "no", "changes", "to", "be", "fetched", "or", "an", "error", ".", "Pull", "only", "supports", "merges", "where", "the", "can", "be", "resolved", "as", "a", "fast", "-", "forward", ".", "The", "provided", "Context", "must", "be", "non", "-", "nil", ".", "If", "the", "context", "expires", "before", "the", "operation", "is", "complete", "an", "error", "is", "returned", ".", "The", "context", "only", "affects", "to", "the", "transport", "operations", "." ]

[ "func", "(", "w", "*", "Worktree", ")", "Checkout", "(", "opts", "*", "CheckoutOptions", ")", "error", "{", "if", "err", ":=", "opts", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "opts", ".", "Create", "{", "if", "err", ":=", "w", ".", "createBranch", "(", "opts", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "c", ",", "err", ":=", "w", ".", "getCommitFromCheckoutOptions", "(", "opts", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "ro", ":=", "&", "ResetOptions", "{", "Commit", ":", "c", ",", "Mode", ":", "MergeReset", "}", "\n", "if", "opts", ".", "Force", "{", "ro", ".", "Mode", "=", "HardReset", "\n", "}", "\n\n", "if", "!", "opts", ".", "Hash", ".", "IsZero", "(", ")", "&&", "!", "opts", ".", "Create", "{", "err", "=", "w", ".", "setHEADToCommit", "(", "opts", ".", "Hash", ")", "\n", "}", "else", "{", "err", "=", "w", ".", "setHEADToBranch", "(", "opts", ".", "Branch", ",", "c", ")", "\n", "}", "\n\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "w", ".", "Reset", "(", "ro", ")", "\n", "}" ]

[ "Checkout", "switch", "branches", "or", "restore", "working", "tree", "files", "." ]

[ "func", "(", "w", "*", "Worktree", ")", "Reset", "(", "opts", "*", "ResetOptions", ")", "error", "{", "if", "err", ":=", "opts", ".", "Validate", "(", "w", ".", "r", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "opts", ".", "Mode", "==", "MergeReset", "{", "unstaged", ",", "err", ":=", "w", ".", "containsUnstagedChanges", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "unstaged", "{", "return", "ErrUnstagedChanges", "\n", "}", "\n", "}", "\n\n", "if", "err", ":=", "w", ".", "setHEADCommit", "(", "opts", ".", "Commit", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "opts", ".", "Mode", "==", "SoftReset", "{", "return", "nil", "\n", "}", "\n\n", "t", ",", "err", ":=", "w", ".", "getTreeFromCommitHash", "(", "opts", ".", "Commit", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "opts", ".", "Mode", "==", "MixedReset", "||", "opts", ".", "Mode", "==", "MergeReset", "||", "opts", ".", "Mode", "==", "HardReset", "{", "if", "err", ":=", "w", ".", "resetIndex", "(", "t", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "if", "opts", ".", "Mode", "==", "MergeReset", "||", "opts", ".", "Mode", "==", "HardReset", "{", "if", "err", ":=", "w", ".", "resetWorktree", "(", "t", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Reset", "the", "worktree", "to", "a", "specified", "state", "." ]

[ "func", "(", "w", "*", "Worktree", ")", "Submodule", "(", "name", "string", ")", "(", "*", "Submodule", ",", "error", ")", "{", "l", ",", "err", ":=", "w", ".", "Submodules", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "for", "_", ",", "m", ":=", "range", "l", "{", "if", "m", ".", "Config", "(", ")", ".", "Name", "==", "name", "{", "return", "m", ",", "nil", "\n", "}", "\n", "}", "\n\n", "return", "nil", ",", "ErrSubmoduleNotFound", "\n", "}" ]

[ "Submodule", "returns", "the", "submodule", "with", "the", "given", "name" ]

[ "func", "(", "w", "*", "Worktree", ")", "Submodules", "(", ")", "(", "Submodules", ",", "error", ")", "{", "l", ":=", "make", "(", "Submodules", ",", "0", ")", "\n", "m", ",", "err", ":=", "w", ".", "readGitmodulesFile", "(", ")", "\n", "if", "err", "!=", "nil", "||", "m", "==", "nil", "{", "return", "l", ",", "err", "\n", "}", "\n\n", "c", ",", "err", ":=", "w", ".", "r", ".", "Config", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "for", "_", ",", "s", ":=", "range", "m", ".", "Submodules", "{", "l", "=", "append", "(", "l", ",", "w", ".", "newSubmodule", "(", "s", ",", "c", ".", "Submodules", "[", "s", ".", "Name", "]", ")", ")", "\n", "}", "\n\n", "return", "l", ",", "nil", "\n", "}" ]

[ "Submodules", "returns", "all", "the", "available", "submodules" ]

[ "func", "(", "w", "*", "Worktree", ")", "Clean", "(", "opts", "*", "CleanOptions", ")", "error", "{", "s", ",", "err", ":=", "w", ".", "Status", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "root", ":=", "\"", "\"", "\n", "files", ",", "err", ":=", "w", ".", "Filesystem", ".", "ReadDir", "(", "root", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "w", ".", "doClean", "(", "s", ",", "opts", ",", "root", ",", "files", ")", "\n", "}" ]

[ "Clean", "the", "worktree", "by", "removing", "untracked", "files", ".", "An", "empty", "dir", "could", "be", "removed", "-", "this", "is", "what", "git", "clean", "-", "f", "-", "d", ".", "does", "." ]

[ "func", "(", "w", "*", "Worktree", ")", "Grep", "(", "opts", "*", "GrepOptions", ")", "(", "[", "]", "GrepResult", ",", "error", ")", "{", "if", "err", ":=", "opts", ".", "Validate", "(", "w", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Obtain commit hash from options (CommitHash or ReferenceName).", "var", "commitHash", "plumbing", ".", "Hash", "\n", "// treeName contains the value of TreeName in GrepResult.", "var", "treeName", "string", "\n\n", "if", "opts", ".", "ReferenceName", "!=", "\"", "\"", "{", "ref", ",", "err", ":=", "w", ".", "r", ".", "Reference", "(", "opts", ".", "ReferenceName", ",", "true", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "commitHash", "=", "ref", ".", "Hash", "(", ")", "\n", "treeName", "=", "opts", ".", "ReferenceName", ".", "String", "(", ")", "\n", "}", "else", "if", "!", "opts", ".", "CommitHash", ".", "IsZero", "(", ")", "{", "commitHash", "=", "opts", ".", "CommitHash", "\n", "treeName", "=", "opts", ".", "CommitHash", ".", "String", "(", ")", "\n", "}", "\n\n", "// Obtain a tree from the commit hash and get a tracked files iterator from", "// the tree.", "tree", ",", "err", ":=", "w", ".", "getTreeFromCommitHash", "(", "commitHash", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "fileiter", ":=", "tree", ".", "Files", "(", ")", "\n\n", "return", "findMatchInFiles", "(", "fileiter", ",", "treeName", ",", "opts", ")", "\n", "}" ]

[ "Grep", "performs", "grep", "on", "a", "worktree", "." ]

[ "func", "findMatchInFiles", "(", "fileiter", "*", "object", ".", "FileIter", ",", "treeName", "string", ",", "opts", "*", "GrepOptions", ")", "(", "[", "]", "GrepResult", ",", "error", ")", "{", "var", "results", "[", "]", "GrepResult", "\n\n", "err", ":=", "fileiter", ".", "ForEach", "(", "func", "(", "file", "*", "object", ".", "File", ")", "error", "{", "var", "fileInPathSpec", "bool", "\n\n", "// When no pathspecs are provided, search all the files.", "if", "len", "(", "opts", ".", "PathSpecs", ")", "==", "0", "{", "fileInPathSpec", "=", "true", "\n", "}", "\n\n", "// Check if the file name matches with the pathspec. Break out of the", "// loop once a match is found.", "for", "_", ",", "pathSpec", ":=", "range", "opts", ".", "PathSpecs", "{", "if", "pathSpec", "!=", "nil", "&&", "pathSpec", ".", "MatchString", "(", "file", ".", "Name", ")", "{", "fileInPathSpec", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n\n", "// If the file does not match with any of the pathspec, skip it.", "if", "!", "fileInPathSpec", "{", "return", "nil", "\n", "}", "\n\n", "grepResults", ",", "err", ":=", "findMatchInFile", "(", "file", ",", "treeName", ",", "opts", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "results", "=", "append", "(", "results", ",", "grepResults", "...", ")", "\n\n", "return", "nil", "\n", "}", ")", "\n\n", "return", "results", ",", "err", "\n", "}" ]

[ "findMatchInFiles", "takes", "a", "FileIter", "worktree", "name", "and", "GrepOptions", "and", "returns", "a", "slice", "of", "GrepResult", "containing", "the", "result", "of", "regex", "pattern", "matching", "in", "content", "of", "all", "the", "files", "." ]

[ "func", "findMatchInFile", "(", "file", "*", "object", ".", "File", ",", "treeName", "string", ",", "opts", "*", "GrepOptions", ")", "(", "[", "]", "GrepResult", ",", "error", ")", "{", "var", "grepResults", "[", "]", "GrepResult", "\n\n", "content", ",", "err", ":=", "file", ".", "Contents", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "grepResults", ",", "err", "\n", "}", "\n\n", "// Split the file content and parse line-by-line.", "contentByLine", ":=", "strings", ".", "Split", "(", "content", ",", "\"", "\\n", "\"", ")", "\n", "for", "lineNum", ",", "cnt", ":=", "range", "contentByLine", "{", "addToResult", ":=", "false", "\n\n", "// Match the patterns and content. Break out of the loop once a", "// match is found.", "for", "_", ",", "pattern", ":=", "range", "opts", ".", "Patterns", "{", "if", "pattern", "!=", "nil", "&&", "pattern", ".", "MatchString", "(", "cnt", ")", "{", "// Add to result only if invert match is not enabled.", "if", "!", "opts", ".", "InvertMatch", "{", "addToResult", "=", "true", "\n", "break", "\n", "}", "\n", "}", "else", "if", "opts", ".", "InvertMatch", "{", "// If matching fails, and invert match is enabled, add to", "// results.", "addToResult", "=", "true", "\n", "break", "\n", "}", "\n", "}", "\n\n", "if", "addToResult", "{", "grepResults", "=", "append", "(", "grepResults", ",", "GrepResult", "{", "FileName", ":", "file", ".", "Name", ",", "LineNumber", ":", "lineNum", "+", "1", ",", "Content", ":", "cnt", ",", "TreeName", ":", "treeName", ",", "}", ")", "\n", "}", "\n", "}", "\n\n", "return", "grepResults", ",", "nil", "\n", "}" ]

[ "findMatchInFile", "takes", "a", "single", "File", "worktree", "name", "and", "GrepOptions", "and", "returns", "a", "slice", "of", "GrepResult", "containing", "the", "result", "of", "regex", "pattern", "matching", "in", "the", "given", "file", "." ]

[ "func", "(", "a", "*", "AdvRefs", ")", "Encode", "(", "w", "io", ".", "Writer", ")", "error", "{", "e", ":=", "newAdvRefsEncoder", "(", "w", ")", "\n", "return", "e", ".", "Encode", "(", "a", ")", "\n", "}" ]

[ "Encode", "writes", "the", "AdvRefs", "encoding", "to", "a", "writer", ".", "All", "the", "payloads", "will", "end", "with", "a", "newline", "character", ".", "Capabilities", "references", "and", "shallows", "are", "written", "in", "alphabetical", "order", "except", "for", "peeled", "references", "that", "always", "follow", "their", "corresponding", "references", "." ]

[ "func", "newFile", "(", "name", ",", "contents", "string", ")", "(", "*", "file", ",", "error", ")", "{", "if", "name", "==", "\"", "\"", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "&", "file", "{", "name", ":", "name", ",", "contents", ":", "contents", ",", "}", ",", "nil", "\n", "}" ]

[ "newFile", "returns", "a", "noder", "representing", "a", "file", "with", "the", "given", "contents", "." ]

[ "func", "(", "f", "*", "file", ")", "Hash", "(", ")", "[", "]", "byte", "{", "if", "f", ".", "hash", "==", "nil", "{", "h", ":=", "fnv", ".", "New64a", "(", ")", "\n", "h", ".", "Write", "(", "[", "]", "byte", "(", "f", ".", "contents", ")", ")", "// it nevers returns an error.", "\n", "f", ".", "hash", "=", "h", ".", "Sum", "(", "nil", ")", "\n", "}", "\n\n", "return", "f", ".", "hash", "\n", "}" ]

[ "The", "hash", "of", "a", "file", "is", "just", "its", "contents", ".", "Empty", "files", "will", "have", "the", "fnv64", "basis", "offset", "as", "its", "hash", "." ]

[ "func", "Init", "(", "s", "storage", ".", "Storer", ",", "worktree", "billy", ".", "Filesystem", ")", "(", "*", "Repository", ",", "error", ")", "{", "if", "err", ":=", "initStorer", "(", "s", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "r", ":=", "newRepository", "(", "s", ",", "worktree", ")", "\n", "_", ",", "err", ":=", "r", ".", "Reference", "(", "plumbing", ".", "HEAD", ",", "false", ")", "\n", "switch", "err", "{", "case", "plumbing", ".", "ErrReferenceNotFound", ":", "case", "nil", ":", "return", "nil", ",", "ErrRepositoryAlreadyExists", "\n", "default", ":", "return", "nil", ",", "err", "\n", "}", "\n\n", "h", ":=", "plumbing", ".", "NewSymbolicReference", "(", "plumbing", ".", "HEAD", ",", "plumbing", ".", "Master", ")", "\n", "if", "err", ":=", "s", ".", "SetReference", "(", "h", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "worktree", "==", "nil", "{", "r", ".", "setIsBare", "(", "true", ")", "\n", "return", "r", ",", "nil", "\n", "}", "\n\n", "return", "r", ",", "setWorktreeAndStoragePaths", "(", "r", ",", "worktree", ")", "\n", "}" ]

[ "Init", "creates", "an", "empty", "git", "repository", "based", "on", "the", "given", "Storer", "and", "worktree", ".", "The", "worktree", "Filesystem", "is", "optional", "if", "nil", "a", "bare", "repository", "is", "created", ".", "If", "the", "given", "storer", "is", "not", "empty", "ErrRepositoryAlreadyExists", "is", "returned" ]

[ "func", "Clone", "(", "s", "storage", ".", "Storer", ",", "worktree", "billy", ".", "Filesystem", ",", "o", "*", "CloneOptions", ")", "(", "*", "Repository", ",", "error", ")", "{", "return", "CloneContext", "(", "context", ".", "Background", "(", ")", ",", "s", ",", "worktree", ",", "o", ")", "\n", "}" ]

[ "Clone", "a", "repository", "into", "the", "given", "Storer", "and", "worktree", "Filesystem", "with", "the", "given", "options", "if", "worktree", "is", "nil", "a", "bare", "repository", "is", "created", ".", "If", "the", "given", "storer", "is", "not", "empty", "ErrRepositoryAlreadyExists", "is", "returned", ".", "The", "provided", "Context", "must", "be", "non", "-", "nil", ".", "If", "the", "context", "expires", "before", "the", "operation", "is", "complete", "an", "error", "is", "returned", ".", "The", "context", "only", "affects", "to", "the", "transport", "operations", "." ]

[ "func", "CloneContext", "(", "ctx", "context", ".", "Context", ",", "s", "storage", ".", "Storer", ",", "worktree", "billy", ".", "Filesystem", ",", "o", "*", "CloneOptions", ",", ")", "(", "*", "Repository", ",", "error", ")", "{", "r", ",", "err", ":=", "Init", "(", "s", ",", "worktree", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "r", ",", "r", ".", "clone", "(", "ctx", ",", "o", ")", "\n", "}" ]

[ "CloneContext", "a", "repository", "into", "the", "given", "Storer", "and", "worktree", "Filesystem", "with", "the", "given", "options", "if", "worktree", "is", "nil", "a", "bare", "repository", "is", "created", ".", "If", "the", "given", "storer", "is", "not", "empty", "ErrRepositoryAlreadyExists", "is", "returned", ".", "The", "provided", "Context", "must", "be", "non", "-", "nil", ".", "If", "the", "context", "expires", "before", "the", "operation", "is", "complete", "an", "error", "is", "returned", ".", "The", "context", "only", "affects", "to", "the", "transport", "operations", "." ]

[ "func", "PlainOpenWithOptions", "(", "path", "string", ",", "o", "*", "PlainOpenOptions", ")", "(", "*", "Repository", ",", "error", ")", "{", "dot", ",", "wt", ",", "err", ":=", "dotGitToOSFilesystems", "(", "path", ",", "o", ".", "DetectDotGit", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "_", ",", "err", ":=", "dot", ".", "Stat", "(", "\"", "\"", ")", ";", "err", "!=", "nil", "{", "if", "os", ".", "IsNotExist", "(", "err", ")", "{", "return", "nil", ",", "ErrRepositoryNotExists", "\n", "}", "\n\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "s", ":=", "filesystem", ".", "NewStorage", "(", "dot", ",", "cache", ".", "NewObjectLRUDefault", "(", ")", ")", "\n\n", "return", "Open", "(", "s", ",", "wt", ")", "\n", "}" ]

[ "PlainOpenWithOptions", "opens", "a", "git", "repository", "from", "the", "given", "path", "with", "specific", "options", ".", "See", "PlainOpen", "for", "more", "info", "." ]

[ "func", "(", "r", "*", "Repository", ")", "Remote", "(", "name", "string", ")", "(", "*", "Remote", ",", "error", ")", "{", "cfg", ",", "err", ":=", "r", ".", "Storer", ".", "Config", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "c", ",", "ok", ":=", "cfg", ".", "Remotes", "[", "name", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "ErrRemoteNotFound", "\n", "}", "\n\n", "return", "newRemote", "(", "r", ".", "Storer", ",", "c", ")", ",", "nil", "\n", "}" ]

[ "Remote", "return", "a", "remote", "if", "exists" ]

[ "func", "(", "r", "*", "Repository", ")", "Remotes", "(", ")", "(", "[", "]", "*", "Remote", ",", "error", ")", "{", "cfg", ",", "err", ":=", "r", ".", "Storer", ".", "Config", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "remotes", ":=", "make", "(", "[", "]", "*", "Remote", ",", "len", "(", "cfg", ".", "Remotes", ")", ")", "\n\n", "var", "i", "int", "\n", "for", "_", ",", "c", ":=", "range", "cfg", ".", "Remotes", "{", "remotes", "[", "i", "]", "=", "newRemote", "(", "r", ".", "Storer", ",", "c", ")", "\n", "i", "++", "\n", "}", "\n\n", "return", "remotes", ",", "nil", "\n", "}" ]

[ "Remotes", "returns", "a", "list", "with", "all", "the", "remotes" ]

[ "func", "(", "r", "*", "Repository", ")", "CreateRemote", "(", "c", "*", "config", ".", "RemoteConfig", ")", "(", "*", "Remote", ",", "error", ")", "{", "if", "err", ":=", "c", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "remote", ":=", "newRemote", "(", "r", ".", "Storer", ",", "c", ")", "\n\n", "cfg", ",", "err", ":=", "r", ".", "Storer", ".", "Config", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "_", ",", "ok", ":=", "cfg", ".", "Remotes", "[", "c", ".", "Name", "]", ";", "ok", "{", "return", "nil", ",", "ErrRemoteExists", "\n", "}", "\n\n", "cfg", ".", "Remotes", "[", "c", ".", "Name", "]", "=", "c", "\n", "return", "remote", ",", "r", ".", "Storer", ".", "SetConfig", "(", "cfg", ")", "\n", "}" ]

[ "CreateRemote", "creates", "a", "new", "remote" ]

[ "func", "(", "r", "*", "Repository", ")", "CreateRemoteAnonymous", "(", "c", "*", "config", ".", "RemoteConfig", ")", "(", "*", "Remote", ",", "error", ")", "{", "if", "err", ":=", "c", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "c", ".", "Name", "!=", "\"", "\"", "{", "return", "nil", ",", "ErrAnonymousRemoteName", "\n", "}", "\n\n", "remote", ":=", "newRemote", "(", "r", ".", "Storer", ",", "c", ")", "\n\n", "return", "remote", ",", "nil", "\n", "}" ]

[ "CreateRemoteAnonymous", "creates", "a", "new", "anonymous", "remote", ".", "c", ".", "Name", "must", "be", "anonymous", ".", "It", "s", "used", "like", "git", "fetch", "git" ]

[ "func", "(", "r", "*", "Repository", ")", "DeleteRemote", "(", "name", "string", ")", "error", "{", "cfg", ",", "err", ":=", "r", ".", "Storer", ".", "Config", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "_", ",", "ok", ":=", "cfg", ".", "Remotes", "[", "name", "]", ";", "!", "ok", "{", "return", "ErrRemoteNotFound", "\n", "}", "\n\n", "delete", "(", "cfg", ".", "Remotes", ",", "name", ")", "\n", "return", "r", ".", "Storer", ".", "SetConfig", "(", "cfg", ")", "\n", "}" ]

[ "DeleteRemote", "delete", "a", "remote", "from", "the", "repository", "and", "delete", "the", "config" ]

[ "func", "(", "r", "*", "Repository", ")", "Branch", "(", "name", "string", ")", "(", "*", "config", ".", "Branch", ",", "error", ")", "{", "cfg", ",", "err", ":=", "r", ".", "Storer", ".", "Config", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "b", ",", "ok", ":=", "cfg", ".", "Branches", "[", "name", "]", "\n", "if", "!", "ok", "{", "return", "nil", ",", "ErrBranchNotFound", "\n", "}", "\n\n", "return", "b", ",", "nil", "\n", "}" ]

[ "Branch", "return", "a", "Branch", "if", "exists" ]

[ "func", "(", "r", "*", "Repository", ")", "CreateBranch", "(", "c", "*", "config", ".", "Branch", ")", "error", "{", "if", "err", ":=", "c", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "cfg", ",", "err", ":=", "r", ".", "Storer", ".", "Config", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "_", ",", "ok", ":=", "cfg", ".", "Branches", "[", "c", ".", "Name", "]", ";", "ok", "{", "return", "ErrBranchExists", "\n", "}", "\n\n", "cfg", ".", "Branches", "[", "c", ".", "Name", "]", "=", "c", "\n", "return", "r", ".", "Storer", ".", "SetConfig", "(", "cfg", ")", "\n", "}" ]

[ "CreateBranch", "creates", "a", "new", "Branch" ]

[ "func", "(", "r", "*", "Repository", ")", "DeleteBranch", "(", "name", "string", ")", "error", "{", "cfg", ",", "err", ":=", "r", ".", "Storer", ".", "Config", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "_", ",", "ok", ":=", "cfg", ".", "Branches", "[", "name", "]", ";", "!", "ok", "{", "return", "ErrBranchNotFound", "\n", "}", "\n\n", "delete", "(", "cfg", ".", "Branches", ",", "name", ")", "\n", "return", "r", ".", "Storer", ".", "SetConfig", "(", "cfg", ")", "\n", "}" ]

[ "DeleteBranch", "delete", "a", "Branch", "from", "the", "repository", "and", "delete", "the", "config" ]

[ "func", "(", "r", "*", "Repository", ")", "CreateTag", "(", "name", "string", ",", "hash", "plumbing", ".", "Hash", ",", "opts", "*", "CreateTagOptions", ")", "(", "*", "plumbing", ".", "Reference", ",", "error", ")", "{", "rname", ":=", "plumbing", ".", "ReferenceName", "(", "path", ".", "Join", "(", "\"", "\"", ",", "\"", "\"", ",", "name", ")", ")", "\n\n", "_", ",", "err", ":=", "r", ".", "Storer", ".", "Reference", "(", "rname", ")", "\n", "switch", "err", "{", "case", "nil", ":", "// Tag exists, this is an error", "return", "nil", ",", "ErrTagExists", "\n", "case", "plumbing", ".", "ErrReferenceNotFound", ":", "// Tag missing, available for creation, pass this", "default", ":", "// Some other error", "return", "nil", ",", "err", "\n", "}", "\n\n", "var", "target", "plumbing", ".", "Hash", "\n", "if", "opts", "!=", "nil", "{", "target", ",", "err", "=", "r", ".", "createTagObject", "(", "name", ",", "hash", ",", "opts", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "else", "{", "target", "=", "hash", "\n", "}", "\n\n", "ref", ":=", "plumbing", ".", "NewHashReference", "(", "rname", ",", "target", ")", "\n", "if", "err", "=", "r", ".", "Storer", ".", "SetReference", "(", "ref", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "ref", ",", "nil", "\n", "}" ]

[ "CreateTag", "creates", "a", "tag", ".", "If", "opts", "is", "included", "the", "tag", "is", "an", "annotated", "tag", "otherwise", "a", "lightweight", "tag", "is", "created", "." ]

[ "func", "(", "r", "*", "Repository", ")", "DeleteTag", "(", "name", "string", ")", "error", "{", "_", ",", "err", ":=", "r", ".", "Tag", "(", "name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "r", ".", "Storer", ".", "RemoveReference", "(", "plumbing", ".", "ReferenceName", "(", "path", ".", "Join", "(", "\"", "\"", ",", "\"", "\"", ",", "name", ")", ")", ")", "\n", "}" ]

[ "DeleteTag", "deletes", "a", "tag", "from", "the", "repository", "." ]

[ "func", "(", "r", "*", "Repository", ")", "clone", "(", "ctx", "context", ".", "Context", ",", "o", "*", "CloneOptions", ")", "error", "{", "if", "err", ":=", "o", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "c", ":=", "&", "config", ".", "RemoteConfig", "{", "Name", ":", "o", ".", "RemoteName", ",", "URLs", ":", "[", "]", "string", "{", "o", ".", "URL", "}", ",", "Fetch", ":", "r", ".", "cloneRefSpec", "(", "o", ")", ",", "}", "\n\n", "if", "_", ",", "err", ":=", "r", ".", "CreateRemote", "(", "c", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "ref", ",", "err", ":=", "r", ".", "fetchAndUpdateReferences", "(", "ctx", ",", "&", "FetchOptions", "{", "RefSpecs", ":", "c", ".", "Fetch", ",", "Depth", ":", "o", ".", "Depth", ",", "Auth", ":", "o", ".", "Auth", ",", "Progress", ":", "o", ".", "Progress", ",", "Tags", ":", "o", ".", "Tags", ",", "RemoteName", ":", "o", ".", "RemoteName", ",", "}", ",", "o", ".", "ReferenceName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "r", ".", "wt", "!=", "nil", "&&", "!", "o", ".", "NoCheckout", "{", "w", ",", "err", ":=", "r", ".", "Worktree", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "head", ",", "err", ":=", "r", ".", "Head", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "w", ".", "Reset", "(", "&", "ResetOptions", "{", "Mode", ":", "MergeReset", ",", "Commit", ":", "head", ".", "Hash", "(", ")", ",", "}", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "o", ".", "RecurseSubmodules", "!=", "NoRecurseSubmodules", "{", "if", "err", ":=", "w", ".", "updateSubmodules", "(", "&", "SubmoduleUpdateOptions", "{", "RecurseSubmodules", ":", "o", ".", "RecurseSubmodules", ",", "Auth", ":", "o", ".", "Auth", ",", "}", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "}", "\n\n", "if", "err", ":=", "r", ".", "updateRemoteConfigIfNeeded", "(", "o", ",", "c", ",", "ref", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "ref", ".", "Name", "(", ")", ".", "IsBranch", "(", ")", "{", "branchRef", ":=", "ref", ".", "Name", "(", ")", "\n", "branchName", ":=", "strings", ".", "Split", "(", "string", "(", "branchRef", ")", ",", "\"", "\"", ")", "[", "1", "]", "\n\n", "b", ":=", "&", "config", ".", "Branch", "{", "Name", ":", "branchName", ",", "Merge", ":", "branchRef", ",", "}", "\n", "if", "o", ".", "RemoteName", "==", "\"", "\"", "{", "b", ".", "Remote", "=", "\"", "\"", "\n", "}", "else", "{", "b", ".", "Remote", "=", "o", ".", "RemoteName", "\n", "}", "\n", "if", "err", ":=", "r", ".", "CreateBranch", "(", "b", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Clone", "clones", "a", "remote", "repository" ]

[ "func", "(", "r", "*", "Repository", ")", "Fetch", "(", "o", "*", "FetchOptions", ")", "error", "{", "return", "r", ".", "FetchContext", "(", "context", ".", "Background", "(", ")", ",", "o", ")", "\n", "}" ]

[ "Fetch", "fetches", "references", "along", "with", "the", "objects", "necessary", "to", "complete", "their", "histories", "from", "the", "remote", "named", "as", "FetchOptions", ".", "RemoteName", ".", "Returns", "nil", "if", "the", "operation", "is", "successful", "NoErrAlreadyUpToDate", "if", "there", "are", "no", "changes", "to", "be", "fetched", "or", "an", "error", "." ]

[ "func", "(", "r", "*", "Repository", ")", "FetchContext", "(", "ctx", "context", ".", "Context", ",", "o", "*", "FetchOptions", ")", "error", "{", "if", "err", ":=", "o", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "remote", ",", "err", ":=", "r", ".", "Remote", "(", "o", ".", "RemoteName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "remote", ".", "FetchContext", "(", "ctx", ",", "o", ")", "\n", "}" ]

[ "FetchContext", "fetches", "references", "along", "with", "the", "objects", "necessary", "to", "complete", "their", "histories", "from", "the", "remote", "named", "as", "FetchOptions", ".", "RemoteName", ".", "Returns", "nil", "if", "the", "operation", "is", "successful", "NoErrAlreadyUpToDate", "if", "there", "are", "no", "changes", "to", "be", "fetched", "or", "an", "error", ".", "The", "provided", "Context", "must", "be", "non", "-", "nil", ".", "If", "the", "context", "expires", "before", "the", "operation", "is", "complete", "an", "error", "is", "returned", ".", "The", "context", "only", "affects", "to", "the", "transport", "operations", "." ]

[ "func", "(", "r", "*", "Repository", ")", "PushContext", "(", "ctx", "context", ".", "Context", ",", "o", "*", "PushOptions", ")", "error", "{", "if", "err", ":=", "o", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "remote", ",", "err", ":=", "r", ".", "Remote", "(", "o", ".", "RemoteName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "remote", ".", "PushContext", "(", "ctx", ",", "o", ")", "\n", "}" ]

[ "PushContext", "performs", "a", "push", "to", "the", "remote", ".", "Returns", "NoErrAlreadyUpToDate", "if", "the", "remote", "was", "already", "up", "-", "to", "-", "date", "from", "the", "remote", "named", "as", "FetchOptions", ".", "RemoteName", ".", "The", "provided", "Context", "must", "be", "non", "-", "nil", ".", "If", "the", "context", "expires", "before", "the", "operation", "is", "complete", "an", "error", "is", "returned", ".", "The", "context", "only", "affects", "to", "the", "transport", "operations", "." ]

[ "func", "(", "r", "*", "Repository", ")", "Log", "(", "o", "*", "LogOptions", ")", "(", "object", ".", "CommitIter", ",", "error", ")", "{", "fn", ":=", "commitIterFunc", "(", "o", ".", "Order", ")", "\n", "if", "fn", "==", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "o", ".", "Order", ")", "\n", "}", "\n\n", "var", "(", "it", "object", ".", "CommitIter", "\n", "err", "error", "\n", ")", "\n", "if", "o", ".", "All", "{", "it", ",", "err", "=", "r", ".", "logAll", "(", "fn", ")", "\n", "}", "else", "{", "it", ",", "err", "=", "r", ".", "log", "(", "o", ".", "From", ",", "fn", ")", "\n", "}", "\n\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "o", ".", "FileName", "!=", "nil", "{", "// for `git log --all` also check parent (if the next commit comes from the real parent)", "it", "=", "r", ".", "logWithFile", "(", "*", "o", ".", "FileName", ",", "it", ",", "o", ".", "All", ")", "\n", "}", "\n\n", "return", "it", ",", "nil", "\n", "}" ]

[ "Log", "returns", "the", "commit", "history", "from", "the", "given", "LogOptions", "." ]

[ "func", "(", "r", "*", "Repository", ")", "Branches", "(", ")", "(", "storer", ".", "ReferenceIter", ",", "error", ")", "{", "refIter", ",", "err", ":=", "r", ".", "Storer", ".", "IterReferences", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "storer", ".", "NewReferenceFilteredIter", "(", "func", "(", "r", "*", "plumbing", ".", "Reference", ")", "bool", "{", "return", "r", ".", "Name", "(", ")", ".", "IsBranch", "(", ")", "\n", "}", ",", "refIter", ")", ",", "nil", "\n", "}" ]

[ "Branches", "returns", "all", "the", "References", "that", "are", "Branches", "." ]

[ "func", "(", "r", "*", "Repository", ")", "TreeObject", "(", "h", "plumbing", ".", "Hash", ")", "(", "*", "object", ".", "Tree", ",", "error", ")", "{", "return", "object", ".", "GetTree", "(", "r", ".", "Storer", ",", "h", ")", "\n", "}" ]

[ "TreeObject", "return", "a", "Tree", "with", "the", "given", "hash", ".", "If", "not", "found", "plumbing", ".", "ErrObjectNotFound", "is", "returned" ]

[ "func", "(", "r", "*", "Repository", ")", "TreeObjects", "(", ")", "(", "*", "object", ".", "TreeIter", ",", "error", ")", "{", "iter", ",", "err", ":=", "r", ".", "Storer", ".", "IterEncodedObjects", "(", "plumbing", ".", "TreeObject", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "object", ".", "NewTreeIter", "(", "r", ".", "Storer", ",", "iter", ")", ",", "nil", "\n", "}" ]

[ "TreeObjects", "returns", "an", "unsorted", "TreeIter", "with", "all", "the", "trees", "in", "the", "repository" ]

[ "func", "(", "r", "*", "Repository", ")", "CommitObject", "(", "h", "plumbing", ".", "Hash", ")", "(", "*", "object", ".", "Commit", ",", "error", ")", "{", "return", "object", ".", "GetCommit", "(", "r", ".", "Storer", ",", "h", ")", "\n", "}" ]

[ "CommitObject", "return", "a", "Commit", "with", "the", "given", "hash", ".", "If", "not", "found", "plumbing", ".", "ErrObjectNotFound", "is", "returned", "." ]

[ "func", "(", "r", "*", "Repository", ")", "CommitObjects", "(", ")", "(", "object", ".", "CommitIter", ",", "error", ")", "{", "iter", ",", "err", ":=", "r", ".", "Storer", ".", "IterEncodedObjects", "(", "plumbing", ".", "CommitObject", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "object", ".", "NewCommitIter", "(", "r", ".", "Storer", ",", "iter", ")", ",", "nil", "\n", "}" ]

[ "CommitObjects", "returns", "an", "unsorted", "CommitIter", "with", "all", "the", "commits", "in", "the", "repository", "." ]

[ "func", "(", "r", "*", "Repository", ")", "BlobObject", "(", "h", "plumbing", ".", "Hash", ")", "(", "*", "object", ".", "Blob", ",", "error", ")", "{", "return", "object", ".", "GetBlob", "(", "r", ".", "Storer", ",", "h", ")", "\n", "}" ]

[ "BlobObject", "returns", "a", "Blob", "with", "the", "given", "hash", ".", "If", "not", "found", "plumbing", ".", "ErrObjectNotFound", "is", "returned", "." ]

[ "func", "(", "r", "*", "Repository", ")", "BlobObjects", "(", ")", "(", "*", "object", ".", "BlobIter", ",", "error", ")", "{", "iter", ",", "err", ":=", "r", ".", "Storer", ".", "IterEncodedObjects", "(", "plumbing", ".", "BlobObject", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "object", ".", "NewBlobIter", "(", "r", ".", "Storer", ",", "iter", ")", ",", "nil", "\n", "}" ]

[ "BlobObjects", "returns", "an", "unsorted", "BlobIter", "with", "all", "the", "blobs", "in", "the", "repository", "." ]

[ "func", "(", "r", "*", "Repository", ")", "TagObject", "(", "h", "plumbing", ".", "Hash", ")", "(", "*", "object", ".", "Tag", ",", "error", ")", "{", "return", "object", ".", "GetTag", "(", "r", ".", "Storer", ",", "h", ")", "\n", "}" ]

[ "TagObject", "returns", "a", "Tag", "with", "the", "given", "hash", ".", "If", "not", "found", "plumbing", ".", "ErrObjectNotFound", "is", "returned", ".", "This", "method", "only", "returns", "annotated", "Tags", "no", "lightweight", "Tags", "." ]

[ "func", "(", "r", "*", "Repository", ")", "TagObjects", "(", ")", "(", "*", "object", ".", "TagIter", ",", "error", ")", "{", "iter", ",", "err", ":=", "r", ".", "Storer", ".", "IterEncodedObjects", "(", "plumbing", ".", "TagObject", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "object", ".", "NewTagIter", "(", "r", ".", "Storer", ",", "iter", ")", ",", "nil", "\n", "}" ]

[ "TagObjects", "returns", "a", "unsorted", "TagIter", "that", "can", "step", "through", "all", "of", "the", "annotated", "tags", "in", "the", "repository", "." ]

[ "func", "(", "r", "*", "Repository", ")", "Object", "(", "t", "plumbing", ".", "ObjectType", ",", "h", "plumbing", ".", "Hash", ")", "(", "object", ".", "Object", ",", "error", ")", "{", "obj", ",", "err", ":=", "r", ".", "Storer", ".", "EncodedObject", "(", "t", ",", "h", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "object", ".", "DecodeObject", "(", "r", ".", "Storer", ",", "obj", ")", "\n", "}" ]

[ "Object", "returns", "an", "Object", "with", "the", "given", "hash", ".", "If", "not", "found", "plumbing", ".", "ErrObjectNotFound", "is", "returned", "." ]

[ "func", "(", "r", "*", "Repository", ")", "Objects", "(", ")", "(", "*", "object", ".", "ObjectIter", ",", "error", ")", "{", "iter", ",", "err", ":=", "r", ".", "Storer", ".", "IterEncodedObjects", "(", "plumbing", ".", "AnyObject", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "object", ".", "NewObjectIter", "(", "r", ".", "Storer", ",", "iter", ")", ",", "nil", "\n", "}" ]

[ "Objects", "returns", "an", "unsorted", "ObjectIter", "with", "all", "the", "objects", "in", "the", "repository", "." ]

[ "func", "(", "r", "*", "Repository", ")", "Head", "(", ")", "(", "*", "plumbing", ".", "Reference", ",", "error", ")", "{", "return", "storer", ".", "ResolveReference", "(", "r", ".", "Storer", ",", "plumbing", ".", "HEAD", ")", "\n", "}" ]

[ "Head", "returns", "the", "reference", "where", "HEAD", "is", "pointing", "to", "." ]

[ "func", "(", "r", "*", "Repository", ")", "Reference", "(", "name", "plumbing", ".", "ReferenceName", ",", "resolved", "bool", ")", "(", "*", "plumbing", ".", "Reference", ",", "error", ")", "{", "if", "resolved", "{", "return", "storer", ".", "ResolveReference", "(", "r", ".", "Storer", ",", "name", ")", "\n", "}", "\n\n", "return", "r", ".", "Storer", ".", "Reference", "(", "name", ")", "\n", "}" ]

[ "Reference", "returns", "the", "reference", "for", "a", "given", "reference", "name", ".", "If", "resolved", "is", "true", "any", "symbolic", "reference", "will", "be", "resolved", "." ]

[ "func", "(", "r", "*", "Repository", ")", "Worktree", "(", ")", "(", "*", "Worktree", ",", "error", ")", "{", "if", "r", ".", "wt", "==", "nil", "{", "return", "nil", ",", "ErrIsBareRepository", "\n", "}", "\n\n", "return", "&", "Worktree", "{", "r", ":", "r", ",", "Filesystem", ":", "r", ".", "wt", "}", ",", "nil", "\n", "}" ]

[ "Worktree", "returns", "a", "worktree", "based", "on", "the", "given", "fs", "if", "nil", "the", "default", "worktree", "will", "be", "used", "." ]

[ "func", "(", "r", "*", "Repository", ")", "createNewObjectPack", "(", "cfg", "*", "RepackConfig", ")", "(", "h", "plumbing", ".", "Hash", ",", "err", "error", ")", "{", "ow", ":=", "newObjectWalker", "(", "r", ".", "Storer", ")", "\n", "err", "=", "ow", ".", "walkAllRefs", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "h", ",", "err", "\n", "}", "\n", "objs", ":=", "make", "(", "[", "]", "plumbing", ".", "Hash", ",", "0", ",", "len", "(", "ow", ".", "seen", ")", ")", "\n", "for", "h", ":=", "range", "ow", ".", "seen", "{", "objs", "=", "append", "(", "objs", ",", "h", ")", "\n", "}", "\n", "pfw", ",", "ok", ":=", "r", ".", "Storer", ".", "(", "storer", ".", "PackfileWriter", ")", "\n", "if", "!", "ok", "{", "return", "h", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "wc", ",", "err", ":=", "pfw", ".", "PackfileWriter", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "h", ",", "err", "\n", "}", "\n", "defer", "ioutil", ".", "CheckClose", "(", "wc", ",", "&", "err", ")", "\n", "scfg", ",", "err", ":=", "r", ".", "Storer", ".", "Config", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "h", ",", "err", "\n", "}", "\n", "enc", ":=", "packfile", ".", "NewEncoder", "(", "wc", ",", "r", ".", "Storer", ",", "cfg", ".", "UseRefDeltas", ")", "\n", "h", ",", "err", "=", "enc", ".", "Encode", "(", "objs", ",", "scfg", ".", "Pack", ".", "Window", ")", "\n", "if", "err", "!=", "nil", "{", "return", "h", ",", "err", "\n", "}", "\n\n", "// Delete the packed, loose objects.", "if", "los", ",", "ok", ":=", "r", ".", "Storer", ".", "(", "storer", ".", "LooseObjectStorer", ")", ";", "ok", "{", "err", "=", "los", ".", "ForEachObjectHash", "(", "func", "(", "hash", "plumbing", ".", "Hash", ")", "error", "{", "if", "ow", ".", "isSeen", "(", "hash", ")", "{", "err", "=", "los", ".", "DeleteLooseObject", "(", "hash", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "h", ",", "err", "\n", "}", "\n", "}", "\n\n", "return", "h", ",", "err", "\n", "}" ]

[ "createNewObjectPack", "is", "a", "helper", "for", "RepackObjects", "taking", "care", "of", "creating", "a", "new", "pack", ".", "It", "is", "used", "so", "the", "the", "PackfileWriter", "deferred", "close", "has", "the", "right", "scope", "." ]

[ "func", "(", "r", "*", "ReferenceUpdateRequest", ")", "Encode", "(", "w", "io", ".", "Writer", ")", "error", "{", "if", "err", ":=", "r", ".", "validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "e", ":=", "pktline", ".", "NewEncoder", "(", "w", ")", "\n\n", "if", "err", ":=", "r", ".", "encodeShallow", "(", "e", ",", "r", ".", "Shallow", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "err", ":=", "r", ".", "encodeCommands", "(", "e", ",", "r", ".", "Commands", ",", "r", ".", "Capabilities", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "r", ".", "Packfile", "!=", "nil", "{", "if", "_", ",", "err", ":=", "io", ".", "Copy", "(", "w", ",", "r", ".", "Packfile", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "r", ".", "Packfile", ".", "Close", "(", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Encode", "writes", "the", "ReferenceUpdateRequest", "encoding", "to", "the", "stream", "." ]

[ "func", "(", "b", "*", "Branch", ")", "Validate", "(", ")", "error", "{", "if", "b", ".", "Name", "==", "\"", "\"", "{", "return", "errBranchEmptyName", "\n", "}", "\n\n", "if", "b", ".", "Merge", "!=", "\"", "\"", "&&", "!", "b", ".", "Merge", ".", "IsBranch", "(", ")", "{", "return", "errBranchInvalidMerge", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Validate", "validates", "fields", "of", "branch" ]

[ "func", "main", "(", ")", "{", "CheckArgs", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "url", ":=", "os", ".", "Args", "[", "1", "]", "\n", "directory", ":=", "os", ".", "Args", "[", "2", "]", "\n\n", "// Clone the given repository to the given directory", "Info", "(", "\"", "\"", ",", "url", ",", "directory", ")", "\n\n", "stop", ":=", "make", "(", "chan", "os", ".", "Signal", ",", "1", ")", "\n", "signal", ".", "Notify", "(", "stop", ",", "os", ".", "Interrupt", ")", "\n\n", "// The context is the mechanism used by go-git, to support deadlines and", "// cancellation signals.", "ctx", ",", "cancel", ":=", "context", ".", "WithCancel", "(", "context", ".", "Background", "(", ")", ")", "\n", "defer", "cancel", "(", ")", "// cancel when we are finished consuming integers", "\n\n", "go", "func", "(", ")", "{", "<-", "stop", "\n", "Warning", "(", "\"", "\\n", "\"", ")", "\n", "cancel", "(", ")", "\n", "}", "(", ")", "\n\n", "Warning", "(", "\"", "\"", ")", "\n\n", "// Using PlainCloneContext we can provide to a context, if the context", "// is cancelled, the clone operation stops gracefully.", "_", ",", "err", ":=", "git", ".", "PlainCloneContext", "(", "ctx", ",", "directory", ",", "false", ",", "&", "git", ".", "CloneOptions", "{", "URL", ":", "url", ",", "Progress", ":", "os", ".", "Stdout", ",", "}", ")", "\n\n", "// If the context was cancelled, an error is returned.", "CheckIfError", "(", "err", ")", "\n", "}" ]

[ "Graceful", "cancellation", "example", "of", "a", "basic", "git", "operation", "such", "as", "Clone", "." ]

[ "func", "ReadUntil", "(", "r", "io", ".", "Reader", ",", "delim", "byte", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "if", "bufr", ",", "ok", ":=", "r", ".", "(", "*", "bufio", ".", "Reader", ")", ";", "ok", "{", "return", "ReadUntilFromBufioReader", "(", "bufr", ",", "delim", ")", "\n", "}", "\n\n", "var", "buf", "[", "1", "]", "byte", "\n", "value", ":=", "make", "(", "[", "]", "byte", ",", "0", ",", "16", ")", "\n", "for", "{", "if", "_", ",", "err", ":=", "io", ".", "ReadFull", "(", "r", ",", "buf", "[", ":", "]", ")", ";", "err", "!=", "nil", "{", "if", "err", "==", "io", ".", "EOF", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "buf", "[", "0", "]", "==", "delim", "{", "return", "value", ",", "nil", "\n", "}", "\n\n", "value", "=", "append", "(", "value", ",", "buf", "[", "0", "]", ")", "\n", "}", "\n", "}" ]

[ "ReadUntil", "reads", "from", "r", "untin", "delim", "is", "found" ]

[ "func", "ReadUntilFromBufioReader", "(", "r", "*", "bufio", ".", "Reader", ",", "delim", "byte", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "value", ",", "err", ":=", "r", ".", "ReadBytes", "(", "delim", ")", "\n", "if", "err", "!=", "nil", "||", "len", "(", "value", ")", "==", "0", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "value", "[", ":", "len", "(", "value", ")", "-", "1", "]", ",", "nil", "\n", "}" ]

[ "ReadUntilFromBufioReader", "is", "like", "bufio", ".", "ReadBytes", "but", "drops", "the", "delimiter", "from", "the", "result", "." ]

[ "func", "ReadUint64", "(", "r", "io", ".", "Reader", ")", "(", "uint64", ",", "error", ")", "{", "var", "v", "uint64", "\n", "if", "err", ":=", "binary", ".", "Read", "(", "r", ",", "binary", ".", "BigEndian", ",", "&", "v", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "return", "v", ",", "nil", "\n", "}" ]

[ "ReadUint64", "reads", "8", "bytes", "and", "returns", "them", "as", "a", "BigEndian", "uint32" ]

[ "func", "ReadUint32", "(", "r", "io", ".", "Reader", ")", "(", "uint32", ",", "error", ")", "{", "var", "v", "uint32", "\n", "if", "err", ":=", "binary", ".", "Read", "(", "r", ",", "binary", ".", "BigEndian", ",", "&", "v", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "return", "v", ",", "nil", "\n", "}" ]

[ "ReadUint32", "reads", "4", "bytes", "and", "returns", "them", "as", "a", "BigEndian", "uint32" ]

[ "func", "ReadUint16", "(", "r", "io", ".", "Reader", ")", "(", "uint16", ",", "error", ")", "{", "var", "v", "uint16", "\n", "if", "err", ":=", "binary", ".", "Read", "(", "r", ",", "binary", ".", "BigEndian", ",", "&", "v", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "return", "v", ",", "nil", "\n", "}" ]

[ "ReadUint16", "reads", "2", "bytes", "and", "returns", "them", "as", "a", "BigEndian", "uint16" ]

[ "func", "ReadHash", "(", "r", "io", ".", "Reader", ")", "(", "plumbing", ".", "Hash", ",", "error", ")", "{", "var", "h", "plumbing", ".", "Hash", "\n", "if", "err", ":=", "binary", ".", "Read", "(", "r", ",", "binary", ".", "BigEndian", ",", "h", "[", ":", "]", ")", ";", "err", "!=", "nil", "{", "return", "plumbing", ".", "ZeroHash", ",", "err", "\n", "}", "\n\n", "return", "h", ",", "nil", "\n", "}" ]

[ "ReadHash", "reads", "a", "plumbing", ".", "Hash", "from", "r" ]

[ "func", "DiffTree", "(", "fromTree", ",", "toTree", "noder", ".", "Noder", ",", "hashEqual", "noder", ".", "Equal", ")", "(", "Changes", ",", "error", ")", "{", "return", "DiffTreeContext", "(", "context", ".", "Background", "(", ")", ",", "fromTree", ",", "toTree", ",", "hashEqual", ")", "\n", "}" ]

[ "DiffTree", "calculates", "the", "list", "of", "changes", "between", "two", "merkletries", ".", "It", "uses", "the", "provided", "hashEqual", "callback", "to", "compare", "noders", "." ]

[ "func", "DiffTreeContext", "(", "ctx", "context", ".", "Context", ",", "fromTree", ",", "toTree", "noder", ".", "Noder", ",", "hashEqual", "noder", ".", "Equal", ")", "(", "Changes", ",", "error", ")", "{", "ret", ":=", "NewChanges", "(", ")", "\n\n", "ii", ",", "err", ":=", "newDoubleIter", "(", "fromTree", ",", "toTree", ",", "hashEqual", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "for", "{", "select", "{", "case", "<-", "ctx", ".", "Done", "(", ")", ":", "return", "nil", ",", "ErrCanceled", "\n", "default", ":", "}", "\n\n", "from", ":=", "ii", ".", "from", ".", "current", "\n", "to", ":=", "ii", ".", "to", ".", "current", "\n\n", "switch", "r", ":=", "ii", ".", "remaining", "(", ")", ";", "r", "{", "case", "noMoreNoders", ":", "return", "ret", ",", "nil", "\n", "case", "onlyFromRemains", ":", "if", "err", "=", "ret", ".", "AddRecursiveDelete", "(", "from", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "err", "=", "ii", ".", "nextFrom", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "case", "onlyToRemains", ":", "if", "err", "=", "ret", ".", "AddRecursiveInsert", "(", "to", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "err", "=", "ii", ".", "nextTo", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "case", "bothHaveNodes", ":", "if", "err", "=", "diffNodes", "(", "&", "ret", ",", "ii", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "default", ":", "panic", "(", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "r", ")", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "DiffTree", "calculates", "the", "list", "of", "changes", "between", "two", "merkletries", ".", "It", "uses", "the", "provided", "hashEqual", "callback", "to", "compare", "noders", ".", "Error", "will", "be", "returned", "if", "context", "expires", "Provided", "context", "must", "be", "non", "nil" ]

[ "func", "NewStorage", "(", ")", "*", "Storage", "{", "return", "&", "Storage", "{", "ReferenceStorage", ":", "make", "(", "ReferenceStorage", ")", ",", "ConfigStorage", ":", "ConfigStorage", "{", "}", ",", "ShallowStorage", ":", "ShallowStorage", "{", "}", ",", "ObjectStorage", ":", "ObjectStorage", "{", "Objects", ":", "make", "(", "map", "[", "plumbing", ".", "Hash", "]", "plumbing", ".", "EncodedObject", ")", ",", "Commits", ":", "make", "(", "map", "[", "plumbing", ".", "Hash", "]", "plumbing", ".", "EncodedObject", ")", ",", "Trees", ":", "make", "(", "map", "[", "plumbing", ".", "Hash", "]", "plumbing", ".", "EncodedObject", ")", ",", "Blobs", ":", "make", "(", "map", "[", "plumbing", ".", "Hash", "]", "plumbing", ".", "EncodedObject", ")", ",", "Tags", ":", "make", "(", "map", "[", "plumbing", ".", "Hash", "]", "plumbing", ".", "EncodedObject", ")", ",", "}", ",", "ModuleStorage", ":", "make", "(", "ModuleStorage", ")", ",", "}", "\n", "}" ]

[ "NewStorage", "returns", "a", "new", "Storage", "base", "on", "memory" ]

[ "func", "NewFSObject", "(", "hash", "plumbing", ".", "Hash", ",", "finalType", "plumbing", ".", "ObjectType", ",", "offset", "int64", ",", "contentSize", "int64", ",", "index", "idxfile", ".", "Index", ",", "fs", "billy", ".", "Filesystem", ",", "path", "string", ",", "cache", "cache", ".", "Object", ",", ")", "*", "FSObject", "{", "return", "&", "FSObject", "{", "hash", ":", "hash", ",", "offset", ":", "offset", ",", "size", ":", "contentSize", ",", "typ", ":", "finalType", ",", "index", ":", "index", ",", "fs", ":", "fs", ",", "path", ":", "path", ",", "cache", ":", "cache", ",", "}", "\n", "}" ]

[ "NewFSObject", "creates", "a", "new", "filesystem", "object", "." ]

[ "func", "(", "o", "*", "FSObject", ")", "Reader", "(", ")", "(", "io", ".", "ReadCloser", ",", "error", ")", "{", "obj", ",", "ok", ":=", "o", ".", "cache", ".", "Get", "(", "o", ".", "hash", ")", "\n", "if", "ok", "&&", "obj", "!=", "o", "{", "reader", ",", "err", ":=", "obj", ".", "Reader", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "reader", ",", "nil", "\n", "}", "\n\n", "f", ",", "err", ":=", "o", ".", "fs", ".", "Open", "(", "o", ".", "path", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "p", ":=", "NewPackfileWithCache", "(", "o", ".", "index", ",", "nil", ",", "f", ",", "o", ".", "cache", ")", "\n", "r", ",", "err", ":=", "p", ".", "getObjectContent", "(", "o", ".", "offset", ")", "\n", "if", "err", "!=", "nil", "{", "_", "=", "f", ".", "Close", "(", ")", "\n", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "err", ":=", "f", ".", "Close", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "r", ",", "nil", "\n", "}" ]

[ "Reader", "implements", "the", "plumbing", ".", "EncodedObject", "interface", "." ]

[ "func", "GetTag", "(", "s", "storer", ".", "EncodedObjectStorer", ",", "h", "plumbing", ".", "Hash", ")", "(", "*", "Tag", ",", "error", ")", "{", "o", ",", "err", ":=", "s", ".", "EncodedObject", "(", "plumbing", ".", "TagObject", ",", "h", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "DecodeTag", "(", "s", ",", "o", ")", "\n", "}" ]

[ "GetTag", "gets", "a", "tag", "from", "an", "object", "storer", "and", "decodes", "it", "." ]

[ "func", "(", "t", "*", "Tag", ")", "Decode", "(", "o", "plumbing", ".", "EncodedObject", ")", "(", "err", "error", ")", "{", "if", "o", ".", "Type", "(", ")", "!=", "plumbing", ".", "TagObject", "{", "return", "ErrUnsupportedObject", "\n", "}", "\n\n", "t", ".", "Hash", "=", "o", ".", "Hash", "(", ")", "\n\n", "reader", ",", "err", ":=", "o", ".", "Reader", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "ioutil", ".", "CheckClose", "(", "reader", ",", "&", "err", ")", "\n\n", "r", ":=", "bufPool", ".", "Get", "(", ")", ".", "(", "*", "bufio", ".", "Reader", ")", "\n", "defer", "bufPool", ".", "Put", "(", "r", ")", "\n", "r", ".", "Reset", "(", "reader", ")", "\n", "for", "{", "var", "line", "[", "]", "byte", "\n", "line", ",", "err", "=", "r", ".", "ReadBytes", "(", "'\\n'", ")", "\n", "if", "err", "!=", "nil", "&&", "err", "!=", "io", ".", "EOF", "{", "return", "err", "\n", "}", "\n\n", "line", "=", "bytes", ".", "TrimSpace", "(", "line", ")", "\n", "if", "len", "(", "line", ")", "==", "0", "{", "break", "// Start of message", "\n", "}", "\n\n", "split", ":=", "bytes", ".", "SplitN", "(", "line", ",", "[", "]", "byte", "{", "' '", "}", ",", "2", ")", "\n", "switch", "string", "(", "split", "[", "0", "]", ")", "{", "case", "\"", "\"", ":", "t", ".", "Target", "=", "plumbing", ".", "NewHash", "(", "string", "(", "split", "[", "1", "]", ")", ")", "\n", "case", "\"", "\"", ":", "t", ".", "TargetType", ",", "err", "=", "plumbing", ".", "ParseObjectType", "(", "string", "(", "split", "[", "1", "]", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "case", "\"", "\"", ":", "t", ".", "Name", "=", "string", "(", "split", "[", "1", "]", ")", "\n", "case", "\"", "\"", ":", "t", ".", "Tagger", ".", "Decode", "(", "split", "[", "1", "]", ")", "\n", "}", "\n\n", "if", "err", "==", "io", ".", "EOF", "{", "return", "nil", "\n", "}", "\n", "}", "\n\n", "data", ",", "err", ":=", "stdioutil", ".", "ReadAll", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "var", "pgpsig", "bool", "\n", "// Check if data contains PGP signature.", "if", "bytes", ".", "Contains", "(", "data", ",", "[", "]", "byte", "(", "beginpgp", ")", ")", "{", "// Split the lines at newline.", "messageAndSig", ":=", "bytes", ".", "Split", "(", "data", ",", "[", "]", "byte", "(", "\"", "\\n", "\"", ")", ")", "\n\n", "for", "_", ",", "l", ":=", "range", "messageAndSig", "{", "if", "pgpsig", "{", "if", "bytes", ".", "Contains", "(", "l", ",", "[", "]", "byte", "(", "endpgp", ")", ")", "{", "t", ".", "PGPSignature", "+=", "endpgp", "+", "\"", "\\n", "\"", "\n", "break", "\n", "}", "else", "{", "t", ".", "PGPSignature", "+=", "string", "(", "l", ")", "+", "\"", "\\n", "\"", "\n", "}", "\n", "continue", "\n", "}", "\n\n", "// Check if it's the beginning of a PGP signature.", "if", "bytes", ".", "Contains", "(", "l", ",", "[", "]", "byte", "(", "beginpgp", ")", ")", "{", "t", ".", "PGPSignature", "+=", "beginpgp", "+", "\"", "\\n", "\"", "\n", "pgpsig", "=", "true", "\n", "continue", "\n", "}", "\n\n", "t", ".", "Message", "+=", "string", "(", "l", ")", "+", "\"", "\\n", "\"", "\n", "}", "\n", "}", "else", "{", "t", ".", "Message", "=", "string", "(", "data", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "Decode", "transforms", "a", "plumbing", ".", "EncodedObject", "into", "a", "Tag", "struct", "." ]

[ "func", "(", "t", "*", "Tag", ")", "Encode", "(", "o", "plumbing", ".", "EncodedObject", ")", "error", "{", "return", "t", ".", "encode", "(", "o", ",", "true", ")", "\n", "}" ]

[ "Encode", "transforms", "a", "Tag", "into", "a", "plumbing", ".", "EncodedObject", "." ]

[ "func", "(", "t", "*", "Tag", ")", "Commit", "(", ")", "(", "*", "Commit", ",", "error", ")", "{", "if", "t", ".", "TargetType", "!=", "plumbing", ".", "CommitObject", "{", "return", "nil", ",", "ErrUnsupportedObject", "\n", "}", "\n\n", "o", ",", "err", ":=", "t", ".", "s", ".", "EncodedObject", "(", "plumbing", ".", "CommitObject", ",", "t", ".", "Target", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "DecodeCommit", "(", "t", ".", "s", ",", "o", ")", "\n", "}" ]

[ "Commit", "returns", "the", "commit", "pointed", "to", "by", "the", "tag", ".", "If", "the", "tag", "points", "to", "a", "different", "type", "of", "object", "ErrUnsupportedObject", "will", "be", "returned", "." ]

[ "func", "(", "t", "*", "Tag", ")", "Tree", "(", ")", "(", "*", "Tree", ",", "error", ")", "{", "switch", "t", ".", "TargetType", "{", "case", "plumbing", ".", "CommitObject", ":", "c", ",", "err", ":=", "t", ".", "Commit", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "c", ".", "Tree", "(", ")", "\n", "case", "plumbing", ".", "TreeObject", ":", "return", "GetTree", "(", "t", ".", "s", ",", "t", ".", "Target", ")", "\n", "default", ":", "return", "nil", ",", "ErrUnsupportedObject", "\n", "}", "\n", "}" ]

[ "Tree", "returns", "the", "tree", "pointed", "to", "by", "the", "tag", ".", "If", "the", "tag", "points", "to", "a", "commit", "object", "the", "tree", "of", "that", "commit", "will", "be", "returned", ".", "If", "the", "tag", "does", "not", "point", "to", "a", "commit", "or", "tree", "object", "ErrUnsupportedObject", "will", "be", "returned", "." ]

[ "func", "(", "t", "*", "Tag", ")", "Blob", "(", ")", "(", "*", "Blob", ",", "error", ")", "{", "if", "t", ".", "TargetType", "!=", "plumbing", ".", "BlobObject", "{", "return", "nil", ",", "ErrUnsupportedObject", "\n", "}", "\n\n", "return", "GetBlob", "(", "t", ".", "s", ",", "t", ".", "Target", ")", "\n", "}" ]

[ "Blob", "returns", "the", "blob", "pointed", "to", "by", "the", "tag", ".", "If", "the", "tag", "points", "to", "a", "different", "type", "of", "object", "ErrUnsupportedObject", "will", "be", "returned", "." ]

[ "func", "(", "t", "*", "Tag", ")", "Object", "(", ")", "(", "Object", ",", "error", ")", "{", "o", ",", "err", ":=", "t", ".", "s", ".", "EncodedObject", "(", "t", ".", "TargetType", ",", "t", ".", "Target", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "DecodeObject", "(", "t", ".", "s", ",", "o", ")", "\n", "}" ]

[ "Object", "returns", "the", "object", "pointed", "to", "by", "the", "tag", "." ]

[ "func", "(", "t", "*", "Tag", ")", "String", "(", ")", "string", "{", "obj", ",", "_", ":=", "t", ".", "Object", "(", ")", "\n\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\\n", "\\n", "\\n", "\\n", "\\n", "\"", ",", "plumbing", ".", "TagObject", ",", "t", ".", "Name", ",", "t", ".", "Tagger", ".", "String", "(", ")", ",", "t", ".", "Tagger", ".", "When", ".", "Format", "(", "DateFormat", ")", ",", "t", ".", "Message", ",", "objectAsString", "(", "obj", ")", ",", ")", "\n", "}" ]

[ "String", "returns", "the", "meta", "information", "contained", "in", "the", "tag", "as", "a", "formatted", "string", "." ]

[ "func", "(", "t", "*", "Tag", ")", "Verify", "(", "armoredKeyRing", "string", ")", "(", "*", "openpgp", ".", "Entity", ",", "error", ")", "{", "keyRingReader", ":=", "strings", ".", "NewReader", "(", "armoredKeyRing", ")", "\n", "keyring", ",", "err", ":=", "openpgp", ".", "ReadArmoredKeyRing", "(", "keyRingReader", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "// Extract signature.", "signature", ":=", "strings", ".", "NewReader", "(", "t", ".", "PGPSignature", ")", "\n\n", "encoded", ":=", "&", "plumbing", ".", "MemoryObject", "{", "}", "\n", "// Encode tag components, excluding signature and get a reader object.", "if", "err", ":=", "t", ".", "EncodeWithoutSignature", "(", "encoded", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "er", ",", "err", ":=", "encoded", ".", "Reader", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "openpgp", ".", "CheckArmoredDetachedSignature", "(", "keyring", ",", "er", ",", "signature", ")", "\n", "}" ]

[ "Verify", "performs", "PGP", "verification", "of", "the", "tag", "with", "a", "provided", "armored", "keyring", "and", "returns", "openpgp", ".", "Entity", "associated", "with", "verifying", "key", "on", "success", "." ]

[ "func", "(", "iter", "*", "TagIter", ")", "Next", "(", ")", "(", "*", "Tag", ",", "error", ")", "{", "obj", ",", "err", ":=", "iter", ".", "EncodedObjectIter", ".", "Next", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "DecodeTag", "(", "iter", ".", "s", ",", "obj", ")", "\n", "}" ]

[ "Next", "moves", "the", "iterator", "to", "the", "next", "tag", "and", "returns", "a", "pointer", "to", "it", ".", "If", "there", "are", "no", "more", "tags", "it", "returns", "io", ".", "EOF", "." ]

[ "func", "(", "iter", "*", "TagIter", ")", "ForEach", "(", "cb", "func", "(", "*", "Tag", ")", "error", ")", "error", "{", "return", "iter", ".", "EncodedObjectIter", ".", "ForEach", "(", "func", "(", "obj", "plumbing", ".", "EncodedObject", ")", "error", "{", "t", ",", "err", ":=", "DecodeTag", "(", "iter", ".", "s", ",", "obj", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "cb", "(", "t", ")", "\n", "}", ")", "\n", "}" ]

[ "ForEach", "call", "the", "cb", "function", "for", "each", "tag", "contained", "on", "this", "iter", "until", "an", "error", "happens", "or", "the", "end", "of", "the", "iter", "is", "reached", ".", "If", "ErrStop", "is", "sent", "the", "iteration", "is", "stop", "but", "no", "error", "is", "returned", ".", "The", "iterator", "is", "closed", "." ]

[ "func", "NewScanner", "(", "r", "io", ".", "Reader", ")", "*", "Scanner", "{", "_", ",", "ok", ":=", "r", ".", "(", "io", ".", "ReadSeeker", ")", "\n\n", "crc", ":=", "crc32", ".", "NewIEEE", "(", ")", "\n", "return", "&", "Scanner", "{", "r", ":", "newScannerReader", "(", "r", ",", "crc", ")", ",", "crc", ":", "crc", ",", "IsSeekable", ":", "ok", ",", "}", "\n", "}" ]

[ "NewScanner", "returns", "a", "new", "Scanner", "based", "on", "a", "reader", "if", "the", "given", "reader", "implements", "io", ".", "ReadSeeker", "the", "Scanner", "will", "be", "also", "Seekable" ]

[ "func", "(", "s", "*", "Scanner", ")", "readSignature", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "var", "sig", "=", "make", "(", "[", "]", "byte", ",", "4", ")", "\n", "if", "_", ",", "err", ":=", "io", ".", "ReadFull", "(", "s", ".", "r", ",", "sig", ")", ";", "err", "!=", "nil", "{", "return", "[", "]", "byte", "{", "}", ",", "err", "\n", "}", "\n\n", "return", "sig", ",", "nil", "\n", "}" ]

[ "readSignature", "reads", "an", "returns", "the", "signature", "field", "in", "the", "packfile", "." ]

[ "func", "(", "s", "*", "Scanner", ")", "isValidSignature", "(", "sig", "[", "]", "byte", ")", "bool", "{", "return", "bytes", ".", "Equal", "(", "sig", ",", "signature", ")", "\n", "}" ]

[ "isValidSignature", "returns", "if", "sig", "is", "a", "valid", "packfile", "signature", "." ]

[ "func", "(", "s", "*", "Scanner", ")", "SeekObjectHeader", "(", "offset", "int64", ")", "(", "*", "ObjectHeader", ",", "error", ")", "{", "// if seeking we assume that you are not interested in the header", "if", "s", ".", "version", "==", "0", "{", "s", ".", "version", "=", "VersionSupported", "\n", "}", "\n\n", "if", "_", ",", "err", ":=", "s", ".", "r", ".", "Seek", "(", "offset", ",", "io", ".", "SeekStart", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "h", ",", "err", ":=", "s", ".", "nextObjectHeader", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "h", ".", "Offset", "=", "offset", "\n", "return", "h", ",", "nil", "\n", "}" ]

[ "SeekObjectHeader", "seeks", "to", "specified", "offset", "and", "returns", "the", "ObjectHeader", "for", "the", "next", "object", "in", "the", "reader" ]

[ "func", "(", "s", "*", "Scanner", ")", "NextObjectHeader", "(", ")", "(", "*", "ObjectHeader", ",", "error", ")", "{", "if", "err", ":=", "s", ".", "doPending", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "offset", ",", "err", ":=", "s", ".", "r", ".", "Seek", "(", "0", ",", "io", ".", "SeekCurrent", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "h", ",", "err", ":=", "s", ".", "nextObjectHeader", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "h", ".", "Offset", "=", "offset", "\n", "return", "h", ",", "nil", "\n", "}" ]

[ "NextObjectHeader", "returns", "the", "ObjectHeader", "for", "the", "next", "object", "in", "the", "reader" ]

[ "func", "(", "s", "*", "Scanner", ")", "nextObjectHeader", "(", ")", "(", "*", "ObjectHeader", ",", "error", ")", "{", "s", ".", "r", ".", "Flush", "(", ")", "\n", "s", ".", "crc", ".", "Reset", "(", ")", "\n\n", "h", ":=", "&", "ObjectHeader", "{", "}", "\n", "s", ".", "pendingObject", "=", "h", "\n\n", "var", "err", "error", "\n", "h", ".", "Offset", ",", "err", "=", "s", ".", "r", ".", "Seek", "(", "0", ",", "io", ".", "SeekCurrent", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "h", ".", "Type", ",", "h", ".", "Length", ",", "err", "=", "s", ".", "readObjectTypeAndLength", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "switch", "h", ".", "Type", "{", "case", "plumbing", ".", "OFSDeltaObject", ":", "no", ",", "err", ":=", "binary", ".", "ReadVariableWidthInt", "(", "s", ".", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "h", ".", "OffsetReference", "=", "h", ".", "Offset", "-", "no", "\n", "case", "plumbing", ".", "REFDeltaObject", ":", "var", "err", "error", "\n", "h", ".", "Reference", ",", "err", "=", "binary", ".", "ReadHash", "(", "s", ".", "r", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "}", "\n\n", "return", "h", ",", "nil", "\n", "}" ]

[ "nextObjectHeader", "returns", "the", "ObjectHeader", "for", "the", "next", "object", "in", "the", "reader", "without", "the", "Offset", "field" ]

[ "func", "(", "s", "*", "Scanner", ")", "readObjectTypeAndLength", "(", ")", "(", "plumbing", ".", "ObjectType", ",", "int64", ",", "error", ")", "{", "t", ",", "c", ",", "err", ":=", "s", ".", "readType", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "t", ",", "0", ",", "err", "\n", "}", "\n\n", "l", ",", "err", ":=", "s", ".", "readLength", "(", "c", ")", "\n\n", "return", "t", ",", "l", ",", "err", "\n", "}" ]

[ "ReadObjectTypeAndLength", "reads", "and", "returns", "the", "object", "type", "and", "the", "length", "field", "from", "an", "object", "entry", "in", "a", "packfile", "." ]

[ "func", "(", "s", "*", "Scanner", ")", "readLength", "(", "first", "byte", ")", "(", "int64", ",", "error", ")", "{", "length", ":=", "int64", "(", "first", "&", "maskFirstLength", ")", "\n\n", "c", ":=", "first", "\n", "shift", ":=", "firstLengthBits", "\n", "var", "err", "error", "\n", "for", "c", "&", "maskContinue", ">", "0", "{", "if", "c", ",", "err", "=", "s", ".", "r", ".", "ReadByte", "(", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "length", "+=", "int64", "(", "c", "&", "maskLength", ")", "<<", "shift", "\n", "shift", "+=", "lengthBits", "\n", "}", "\n\n", "return", "length", ",", "nil", "\n", "}" ]

[ "the", "length", "is", "codified", "in", "the", "last", "4", "bits", "of", "the", "first", "byte", "and", "in", "the", "last", "7", "bits", "of", "subsequent", "bytes", ".", "Last", "byte", "has", "a", "0", "MSB", "." ]

[ "func", "(", "s", "*", "Scanner", ")", "NextObject", "(", "w", "io", ".", "Writer", ")", "(", "written", "int64", ",", "crc32", "uint32", ",", "err", "error", ")", "{", "s", ".", "pendingObject", "=", "nil", "\n", "written", ",", "err", "=", "s", ".", "copyObject", "(", "w", ")", "\n\n", "s", ".", "r", ".", "Flush", "(", ")", "\n", "crc32", "=", "s", ".", "crc", ".", "Sum32", "(", ")", "\n", "s", ".", "crc", ".", "Reset", "(", ")", "\n\n", "return", "\n", "}" ]

[ "NextObject", "writes", "the", "content", "of", "the", "next", "object", "into", "the", "reader", "returns", "the", "number", "of", "bytes", "written", "the", "CRC32", "of", "the", "content", "and", "an", "error", "if", "any" ]

[ "func", "(", "s", "*", "Scanner", ")", "copyObject", "(", "w", "io", ".", "Writer", ")", "(", "n", "int64", ",", "err", "error", ")", "{", "zr", ":=", "zlibReaderPool", ".", "Get", "(", ")", ".", "(", "io", ".", "ReadCloser", ")", "\n", "defer", "zlibReaderPool", ".", "Put", "(", "zr", ")", "\n\n", "if", "err", "=", "zr", ".", "(", "zlib", ".", "Resetter", ")", ".", "Reset", "(", "s", ".", "r", ",", "nil", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "defer", "ioutil", ".", "CheckClose", "(", "zr", ",", "&", "err", ")", "\n", "buf", ":=", "byteSlicePool", ".", "Get", "(", ")", ".", "(", "[", "]", "byte", ")", "\n", "n", ",", "err", "=", "io", ".", "CopyBuffer", "(", "w", ",", "zr", ",", "buf", ")", "\n", "byteSlicePool", ".", "Put", "(", "buf", ")", "\n", "return", "\n", "}" ]

[ "ReadRegularObject", "reads", "and", "write", "a", "non", "-", "deltified", "object", "from", "it", "zlib", "stream", "in", "an", "object", "entry", "in", "the", "packfile", "." ]

[ "func", "(", "s", "*", "Scanner", ")", "SeekFromStart", "(", "offset", "int64", ")", "(", "previous", "int64", ",", "err", "error", ")", "{", "// if seeking we assume that you are not interested in the header", "if", "s", ".", "version", "==", "0", "{", "s", ".", "version", "=", "VersionSupported", "\n", "}", "\n\n", "previous", ",", "err", "=", "s", ".", "r", ".", "Seek", "(", "0", ",", "io", ".", "SeekCurrent", ")", "\n", "if", "err", "!=", "nil", "{", "return", "-", "1", ",", "err", "\n", "}", "\n\n", "_", ",", "err", "=", "s", ".", "r", ".", "Seek", "(", "offset", ",", "io", ".", "SeekStart", ")", "\n", "return", "previous", ",", "err", "\n", "}" ]

[ "SeekFromStart", "sets", "a", "new", "offset", "from", "start", "returns", "the", "old", "position", "before", "the", "change", "." ]

[ "func", "(", "s", "*", "Scanner", ")", "Checksum", "(", ")", "(", "plumbing", ".", "Hash", ",", "error", ")", "{", "err", ":=", "s", ".", "discardObjectIfNeeded", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "plumbing", ".", "ZeroHash", ",", "err", "\n", "}", "\n\n", "return", "binary", ".", "ReadHash", "(", "s", ".", "r", ")", "\n", "}" ]

[ "Checksum", "returns", "the", "checksum", "of", "the", "packfile" ]

[ "func", "(", "s", "*", "Scanner", ")", "Close", "(", ")", "error", "{", "buf", ":=", "byteSlicePool", ".", "Get", "(", ")", ".", "(", "[", "]", "byte", ")", "\n", "_", ",", "err", ":=", "io", ".", "CopyBuffer", "(", "stdioutil", ".", "Discard", ",", "s", ".", "r", ",", "buf", ")", "\n", "byteSlicePool", ".", "Put", "(", "buf", ")", "\n", "return", "err", "\n", "}" ]

[ "Close", "reads", "the", "reader", "until", "io", ".", "EOF" ]

[ "func", "(", "r", "*", "scannerReader", ")", "Seek", "(", "offset", "int64", ",", "whence", "int", ")", "(", "int64", ",", "error", ")", "{", "var", "err", "error", "\n\n", "if", "seeker", ",", "ok", ":=", "r", ".", "reader", ".", "(", "io", ".", "ReadSeeker", ")", ";", "!", "ok", "{", "if", "whence", "!=", "io", ".", "SeekCurrent", "||", "offset", "!=", "0", "{", "return", "-", "1", ",", "ErrSeekNotSupported", "\n", "}", "\n", "}", "else", "{", "if", "whence", "==", "io", ".", "SeekCurrent", "&&", "offset", "==", "0", "{", "return", "r", ".", "offset", ",", "nil", "\n", "}", "\n\n", "r", ".", "offset", ",", "err", "=", "seeker", ".", "Seek", "(", "offset", ",", "whence", ")", "\n", "r", ".", "rbuf", ".", "Reset", "(", "r", ".", "reader", ")", "\n", "}", "\n\n", "return", "r", ".", "offset", ",", "err", "\n", "}" ]

[ "Seek", "seeks", "to", "a", "location", ".", "If", "the", "underlying", "reader", "is", "not", "an", "io", ".", "ReadSeeker", "then", "only", "whence", "=", "io", ".", "SeekCurrent", "is", "supported", "any", "other", "operation", "fails", "." ]

[ "func", "(", "c", "*", "BufferLRU", ")", "Put", "(", "key", "int64", ",", "slice", "[", "]", "byte", ")", "{", "c", ".", "mut", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "mut", ".", "Unlock", "(", ")", "\n\n", "if", "c", ".", "cache", "==", "nil", "{", "c", ".", "actualSize", "=", "0", "\n", "c", ".", "cache", "=", "make", "(", "map", "[", "int64", "]", "*", "list", ".", "Element", ",", "1000", ")", "\n", "c", ".", "ll", "=", "list", ".", "New", "(", ")", "\n", "}", "\n\n", "bufSize", ":=", "FileSize", "(", "len", "(", "slice", ")", ")", "\n", "if", "ee", ",", "ok", ":=", "c", ".", "cache", "[", "key", "]", ";", "ok", "{", "oldBuf", ":=", "ee", ".", "Value", ".", "(", "buffer", ")", "\n", "// in this case bufSize is a delta: new size - old size", "bufSize", "-=", "FileSize", "(", "len", "(", "oldBuf", ".", "Slice", ")", ")", "\n", "c", ".", "ll", ".", "MoveToFront", "(", "ee", ")", "\n", "ee", ".", "Value", "=", "buffer", "{", "key", ",", "slice", "}", "\n", "}", "else", "{", "if", "bufSize", ">", "c", ".", "MaxSize", "{", "return", "\n", "}", "\n", "ee", ":=", "c", ".", "ll", ".", "PushFront", "(", "buffer", "{", "key", ",", "slice", "}", ")", "\n", "c", ".", "cache", "[", "key", "]", "=", "ee", "\n", "}", "\n\n", "c", ".", "actualSize", "+=", "bufSize", "\n", "for", "c", ".", "actualSize", ">", "c", ".", "MaxSize", "{", "last", ":=", "c", ".", "ll", ".", "Back", "(", ")", "\n", "lastObj", ":=", "last", ".", "Value", ".", "(", "buffer", ")", "\n", "lastSize", ":=", "FileSize", "(", "len", "(", "lastObj", ".", "Slice", ")", ")", "\n\n", "c", ".", "ll", ".", "Remove", "(", "last", ")", "\n", "delete", "(", "c", ".", "cache", ",", "lastObj", ".", "Key", ")", "\n", "c", ".", "actualSize", "-=", "lastSize", "\n", "}", "\n", "}" ]

[ "Put", "puts", "a", "buffer", "into", "the", "cache", ".", "If", "the", "buffer", "is", "already", "in", "the", "cache", "it", "will", "be", "marked", "as", "used", ".", "Otherwise", "it", "will", "be", "inserted", ".", "A", "buffers", "might", "be", "evicted", "to", "make", "room", "for", "the", "new", "one", "." ]

[ "func", "(", "c", "*", "BufferLRU", ")", "Clear", "(", ")", "{", "c", ".", "mut", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "mut", ".", "Unlock", "(", ")", "\n\n", "c", ".", "ll", "=", "nil", "\n", "c", ".", "cache", "=", "nil", "\n", "c", ".", "actualSize", "=", "0", "\n", "}" ]

[ "Clear", "the", "content", "of", "this", "buffer", "cache", "." ]