gogs / git Goto Github PK

https://github.com/dominikh/go-tools/unused yields:

repo_history_handlers.go:7:6: func commitRootComparator is unused (U1000)
repo_object.go:91:25: func (*Repository).objectType is unused (U1000)
tree.go:36:16: func (*Tree).walk is unused (U1000)
tree.go:41:16: func (*Tree)._walk is unused (U1000)
tree_entry.go:63:2: field commited is unused (U1000)

Some of them look like they should be public, especially func (*Tree).walk. I always wondered what the TreeWalkCallback was for...

// ci is *git.Commit
for _, e := range ci.ListEntries() {
if e.IsDir() || strings.HasPrefix(e.Name(), ".") {
continue
}
rc, err := e.Blob().Data()
// e.Blob().Data() will deference a nil pointer, while e.Blob() is okay.
}

This is caused by this PR #8.

Hello there,
just a quick question... Do I understand correctly that this is Git implementation in GoLang?

Thanks.

Rich

I really find it hard to debug this library. I really would like to track errors with https://github.com/pkg/errors/ .
This way we can annotate where a function call came from and can print stack traces if necessary. Otherwise this just behaves like normal errors.

Operations only work on repos that have 'loose' refs to tags i.e. have not been GC'd. Probably also goes for packed heads/remotes

Seems like a Sisyphean task; why keep pushing the boulder up the mountain?

Hi.
I am currently rewriting last bits of library that use git binary invocation and found that searchCommits will look only for 100 commits. Should I copy that behavior or remove limit?

Hiya, right now there are a bunch of errors.New(fmt.Sprintf(...)) all over the code, and the string is often dynamic so it makes it hard to compare conditions programmatically.

For instance, when an object is not found: https://github.com/gogits/git/blob/16f4de6a9d8a6695826ef4118f58dff85174b335/repo_object.go#L81

I propose we pull out at least the more common errors into package variables so that the conditions can be compared against. We can still make the Error() messages dynamically generated, so the output will stay the same.

(Happy to work on a PR for this, just let me know!)

It would be nice to have some mechanism for resolving
symbolic ref names such as "HEAD" or "origin".

AFAICS the only way currently is to open the relevant
files in git to find the commit numbers.

But perhaps I've missed something and there is. If so,
perhaps better docs might help.

Ideally it would be great to have a function that
could resolve all of the various syntax described in
gitrevisions(7).

I found that after upgrading to Go 1.7, repo.GetCommitOfBranch(branch) started returning an EOF and not the commit sha1 that I expected.

https://github.com/gogits/git/blob/564c5fe86bbef8589421582b69657cc08c4c85fb/repo_utils.go#L306

I dug in and found that simply removing the error check fixes this, which matches up with the release notes below.

In previous releases of Go, if Reader's Read method were asked for zero bytes with no data remaining, it would return a count of 0 and no error. Now it returns a count of 0 and the error io.EOF