cred: tighten username rules

The ssh-specific credentials allow the username to be missing. The idea
being that the ssh transport will then use the username provided in the
url, if it's available. There are two main issues with this.

The credential callback already knows what username was provided by the
url and needs to figure out whether it wants to ask the user for it or
it can reuse it, so passing NULL as the username means the credential
callback is suspicious.

The username provided in the url is not in fact used by the
transport. The only time it even considers it is for the user/pass
credential, which asserts the existence of a username in its
constructor. For the ssh-specific ones, it passes in the username stored
in the credential, which is NULL. The libssh2 macro we use runs strlen()
against this value (which is no different from what we would be doing
ourselves), so we then crash.

As the documentation doesn't suggest to leave out the username, assert
the need for a username in the code, which removes this buggy behavior
and removes implicit state.

git_cred_has_username() becomes a blacklist of credential types that do
not have a username. The only one at the moment is the 'default' one,
which is meant to call up some Microsoft magic.

Merge pull request #2108 from libgit2/rb/threadsafe-index-iterator

Make index iterator thread safe

cherry-pick: terminate the commit id string

We treat this as a NUL-terminated string, so make sure that we add the
terminator.

Some memory leak fixes

Fix broken logic for attr cache invalidation

The checks to see if files were out of date in the attibute cache
was wrong because the cache-breaker data wasn't getting stored
correctly.  Additionally, when the cache-breaker triggered, the
old file data was being leaked.

Lock attribute file while reparsing data

I don't love this approach, but achieving thread-safety for
attribute and ignore data while reloading files would require a
larger rewrite in order to avoid this.  If an attribute or ignore
file is out of date, this holds a lock on the file while we are
reloading the data so that another thread won't try to reload the
data at the same time.

Fix race checking for existing index items

In the threading tests, I was still seeing a race condition where
the same item could end up being inserted multiple times into the
index.  Preserving the sorted-ness of the index outside of the
`index_insert` call fixes the issue.

Fix tests with new attr cache code

Attribute file cache refactor

This is a big refactoring of the attribute file cache to be a bit
simpler which in turn makes it easier to enforce a lock around any
updates to the cache so that it can be used in a threaded env.
Tons of changes to the attributes and ignores code.

Minor tree cache speedups

While I was looking at the conflict cleanup code, I looked over at
the tree cache code, since we clear the tree cache for each entry
that gets removed and there is some redundancy there.  I made some
small tweaks to avoid extra calls to strchr and strlen in a few
circumstances.

Fix leak in git_index_conflict_cleanup

I introduced a leak into conflict cleanup by removing items from
inside the git_vector_remove_matching call.  This simplifies the
code to just use one common way for the two conflict cleanup APIs.

When an index has an active snapshot, removing an item can cause
an error (inserting into the deferred deletion vector), so I made
the git_index_conflict_cleanup API return an error code.  I felt
like this wasn't so bad since it is just like the other APIs.

I fixed up a couple of comments while I was changing the header.

Fix leak when using push and pop with ignores

The iterator pushes and pops ignores incrementally onto a list as
it traverses the directory structure so that it doesn't have to
constantly recheck which ignore files apply.  With the new ref
counting, it wasn't decrementing the refcount on the ignores that
it removed from the vector.

Fix refcount issues with mutex protected ignores

Some ignore files were not being freed from the cache.

Fix threading tests when threads disabled

Clean up index snapshot function naming

Clear up some of the various "find" functions and the snapshot
API naming to be things I like more.

Index locking and entry allocation changes

This makes the lock management on the index a little bit broader,
having a number of routines hold the lock across looking up the
item to be modified and actually making the modification.  Still
not true thread safety, but more pure index modifications are now
safe which allows the simple cases (such as starting up a diff
while index modifications are underway) safe enough to get the
snapshot without hitting allocation problems.

As part of this, I simplified the allocation of index entries to
use a flex array and just put the path at the end of the index
entry.  This makes every entry self-contained and makes it a
little easier to feel sure that pointers to strings aren't
being accidentally copied and freed while other references are
still being held.

Add diff threading tests and attr file cache locks

This adds a basic test of doing simultaneous diffs on multiple
threads and adds basic locking for the attr file cache because
that was the immediate problem that arose from these tests.

Decouple index iterator sort from index

This makes the index iterator honor the GIT_ITERATOR_IGNORE_CASE
and GIT_ITERATOR_DONT_IGNORE_CASE flags without modifying the
index data itself.  To take advantage of this, I had to export a
number of the internal index entry comparison functions.  I also
wrote some new tests to exercise the capability.

Add mutex around index entries changes

This surrounds any function that mutates the entries vector with
a mutex so it can be safely snapshotted.

Add index snapshot and use it for iterator

Add public diff print helpers

The usefulness of these helpers came up for me while debugging
some of the iterator changes that I was making, so since they
have also been requested (albeit indirectly) I thought I'd include
them.

Some index internals refactoring

Again, laying groundwork for some index iterator changes, this
contains a bunch of code refactorings for index internals that
should make it easier down the line to add locking around index
modifications.  Also this removes the redundant prefix_position
function and fixes some potential memory leaks.

Some vector utility tweaks

This is just laying some groundwork for internal index changes
that I'm working on.

Merge pull request #2261 from jacquesg/format-patch

Support for format-patch

Merge pull request #2270 from csware/fix_git_branch_t_enum

Add GIT_BRANCH_LOCAL_AND_REMOTE to git_branch_t enum

Add GIT_BRANCH_ALL to git_branch_t enum

git_branch_t is an enum so requesting GIT_BRANCH_LOCAL | GIT_BRANCH_REMOTE is not possible as it is not a member of the enum (at least VS2013 C++ complains about it).

This fixes a regression introduced in commit a667ca8298193b3103c1dbdcb1f6c527e6e99eb2 (PR #1946).

Signed-off-by: Sven Strickroth <email@cs-ware.de>

Merge pull request #2269 from libgit2/rb/fix-leading-slash-ignores

Fix core.excludesfile named .gitignore

Merge pull request #2235 from jacquesg/cherry-pick

Add cherry pick support

Added a test case for formatting a binary patch e-mail

Sanitize git_diff_format_email_options' summary parameter

It will form part of the subject line and should thus be one line.

Introduce git_diff_format_email and git_diff_commit_as_email

Introduce git_diff_get_stats, git_diff_stats_files_changed, git_diff_stats_insertions, git_diff_stats_deletions and git_diff_stats_to_buf

Added git_diff_stats test files

Fix core.excludesfile named .gitignore

Ignore rules with slashes in them are matched using FNM_PATHNAME
and use the path to the .gitignore file from the root of the
repository along with the path fragment (including slashes) in
the ignore file itself.  Unfortunately, the relative path to the
.gitignore file was being applied to the global core.excludesfile
if that was also named ".gitignore".

This fixes that with more precise matching and includes test for
ignore rules with leading slashes (which were the primary example
of this being broken in the real world).

This also backports an improvement to the file context logic from
the threadsafe-iterators branch where we don't rely on mutating
the key of the attribute file name to generate the context path.

Merge pull request #2264 from jacquesg/fix-warnings

Correct C90 warnings

Capture conflict information in MERGE_MSG for revert and merge

Added cherry pick tests

Added cherry-pick support

Introduce git_merge__extract_conflict_paths

Merge pull request #2262 from libgit2/rb/fix-ignore-pop

Fix bug popping ignore files during wd iteration

Correct C90 warnings

Fix const-correctness of git_patch_get_delta, git_patch_num_hunks, git_patch_num_lines_in_hunk

Added RFC2822 date format test cases

Introduce git__date_rfc2822_fmt. Allows for RFC2822 date headers

Fix bug popping ignore files during wd iteration

There were a couple bugs in popping ignore files during iteration
that could result in incorrect decisions be made and thus ignore
files below the root either not being loaded correctly or not
being popped at the right time.

One bug was an off-by-one in comparing the path of the gitignore
file with the path being exited during iteration.

The second bug was not correctly truncating the path being tracked
during traversal if there were no ignores on the list (i.e. when
you have no .gitignore at the root, but do have some in contained
directories).

Introduce git_buf_putcn

Allows for inserting the same character n amount of times

Merge pull request #2259 from libgit2/vmg/state-cleanup

Rewrite `state-cleanup`

Rewrite `git_repository__cleanup_files`

Merge pull request #2257 from libgit2/rb/fix-submodules-with-tracked-content

Update treatment of submodule-like directories with tracked content in the parent

Merge pull request #2258 from libgit2/jk/userdiff-cc

pull userdiff pattern updates from git.git

userdiff: update ada patterns

This is the moral equivalent of

  git/git@39a87a29ce364ed3337e535adce5973731ba2968

from Adrian Johnson <ajohnson@redneon.com>.

userdiff: update C/C++ patterns

This pulls upstream changes from:

  git/git@8a2e8da367f7175465118510b474ad365161d6b1

  git/git@abf8f9860248d8c213600974742f18dadaa8fbb5

  git/git@407e07f2a6f55e605fda9e90cb622887269f68b5

all by Johannes Sixt <j6t@kdbg.org>.

Update submodules with parent-tracked content

This updates how libgit2 treats submodule-like directories that
actually have tracked content inside of them.  This is a strange
corner case, but it seems that many people have abortive submodule
setups and then just went ahead and added the files into the
parent repository.  In this case, we should just treat the
submodule as if it was a normal directory.

Libgit2 will still try to skip over real submodules and contained
repositories that do not have tracked files inside them, but this
adds some new handling for cases where the apparently submodule
data is in conflict with the actual list of tracked files.

graph: handle not finding a merge base gracefully

git_merge_base() returns GIT_ENOTFOUND when it cannot find a merge
base. graph_desdendant_of() returns a boolean value (barring any
errors), so it needs to catch the NOTFOUND return value and convert it
into false, as not merge base means it cannot be a descendant.

Merge pull request #2256 from jacquesg/graph-descendant

Correct grouping of parentheses

Added a no path test for git_graph_descendant_of

Correct grouping of parentheses

git_graph_descendant_of was returning the result of an assignment

Merge pull request #2255 from libgit2/rb/fix-multiple-nfd-iconv-bug

Fix bug with multiple iconv conversions in one dir

vmg is always right

Fix bug with multiple iconv conversions in one dir

The internal buffer in the `git_path_iconv_t` structure was not
being reset before the calls to `iconv` were made to convert data,
so if there were multiple decomposed Unicode paths in a single
directory, paths after the first one were being appended to the
first instead of treated as independent data.

Update AUTHORS

git_repository_state_cleanup() should remove rebase-merge/, rebase-apply/ and BISECT_LOG

Merge pull request #2249 from libgit2/rb/starstar-fnmatch

Add support for ** matches in ignores

Fix fnmatch comment to be clearer

More ** tests for pattern rules

Merge pull request #2250 from jacquesg/vector-leak

Don't lose our elements when calling git_vector_set()

Don't lose our elements when calling git_vector_set()

Add support for ** matches in ignores

This is an experimental addition to add ** support to fnmatch
pattern matching in libgit2.  It needs more testing.

Merge pull request #2215 from libgit2/rb/submodule-cache-fixes

Improve submodule cache management

Merge pull request #2211 from Yogu/retry-renaming-config

Retry committing locked files on error

Test (and fix) the git_submodule_sync changes

I wrote this stuff a while ago and forgot to write tests.  Wanted
to do so now to wrap up the PR and immediately found problems.

Minor code cleanup

git_submodule_resolve_url supports relative urls

The base for the relative urls is determined as follows, with descending
priority:

- remote url of HEAD's remote tracking branch
- remote "origin"
- workdir

This follows git.git behaviour

Test git_submodule_add_setup with relative url

Merge pull request #2244 from jacquesg/const-correctness

Const correctness!

Const correctness!

Merge pull request #2238 from libgit2/cmn/upstream-for-unborn

Handle an upstream branch for an unborn one

Merge pull request #2239 from libgit2/vmg/clar-skip-test

Skip tests on Clar

remote: mark branch for-merge even if we're unborn

When the current branch is unborn, git will still mark the current
branch's upstream for-merge if there is an upstream configuration. The
only non-constrived case is cloning from an empty repository which then
gains history. origin's master should be marked for-merge.

In order to do this, we cannot use the high-level wrappers that expect a
reference, as we may not have one. Move over to the internal ones that
expect a reference name, which we do have.

remote: write tests for cloning from an empty repo

Cloning from an empty repo must set master's upstream to origin's
master, even if neither of them exist.

Fetching from a non-empty origin must then mark the master branch
for-merge. This currently fails.

Clar: skip tests

Merge pull request #2237 from mekishizufu/fix_return_value

Fix submodule_is_config_only's return value

checkout: Fix submodule_is_config_only's return value

Merge pull request #2230 from anuraggup/revwalk-merge-base

No need to find merge base.

Add warning when skipping blame test

Merge pull request #2231 from libgit2/fix-memory-index-doc-comment

Correct a stale reference to GIT_EBAREINDEX

Give the correct name for the function in the doc.

Per @carlosmn, git_index_add is now named git_index_add_bypath.

Merge pull request #2233 from libgit2/rb/fix-untracked-repo-status

Skip untracked contained repo contents even with gitlink files

Skip blame libgit2 test if not in libgit2 repo

One blame test replies on being run from within the libgit2
repository to leverage having a longer history to play with, but
some bundled versions of libgit2 don't have the whole libgit2
history.  This just skips that test if the repository can't be
opened.

New tests of status for repo inside repo

Fix skipping content of contained repos

When doing a diff for use in status, we should never show the
content of a git repository contained inside another one.  The
logic to do this was looking for a .git directory and so when a
gitlink plain .git file was used, it was failing to exclude the
directory content.

More tests and fix submodule index refresh

There was a little bug where the submodule cache thought that the
index date was out of date even when it wasn't that was resulting
in some extra scans of index data even when not needed.

Mostly this commit adds a bunch of new tests including adding and
removing submodules in the index and in the HEAD and seeing if we
can automatically pick them up when refreshing.

Correct a stale reference to GIT_EBAREINDEX

Remove most submodule reloads from tests

With the new submodule cache validity checks, we generally don't
need to call git_submodule_reload_all to have up-to-date submodule
data.  Some tests are still calling it where I want to actually
test that it can be called safely and doesn't break anything, but
mostly it is not needed.

This also expands some of the existing submodule tests to cover
some variants on the behavior that was already being tested.

Fix submodule accounting for name and path changes

Wrote tests that try adding, removing, and updating the name of
submodules which showed a number of problems with how we account
for changes when incrementally updating the submodule info.  Most
of these issues didn't exist before because reloading would always
blow away the old submodule data.

refspec: git_refspec_parse() does not exist

Minor submodule cache locking improvements

This improvement the management of the lock around submodule cache
updates slightly, using the lock to make sure that foreach can
safely make a snapshot of all existing submodules and making sure
that git_submodule_add_setup also grabs a lock before inserting
the new submodule.  Cache initialization / refresh should already
have been holding the lock correctly as it adds submodules.

Reinstate efficient submodule reloading

This makes it so that git_submodule_reload_all will actually only
reload changed items unless the `force` flag is used.

Use enums instead of bools for submodule options

When forcing cache flushes or reload, etc., it is easier to keep
track of intent using enums instead of plain bools.  Also, this
fixes a bug where the cache was not being properly refreshes by
a git_submodule_reload_all.

Make submodule refresh a bit smarter

This makes submodule cache refresh actually look at the timestamps
from the data sources for submodules and reload as needed if they
have changed since the last refresh.