|
a979cf3d
|
2021-11-17T22:19:47
|
|
c99: change single bit flags to unsigned
|
|
|
7dcc29fc
|
2021-10-22T22:51:59
|
|
Make enum in src,tests and examples C90 compliant by removing trailing comma.
|
|
95117d47
|
2021-10-31T09:45:46
|
|
path: separate git-specific path functions from util
Introduce `git_fs_path`, which operates on generic filesystem paths.
`git_path` will be kept for only git-specific path functionality (for
example, checking for `.git` in a path).
|
|
f0e693b1
|
2021-09-07T17:53:49
|
|
str: introduce `git_str` for internal, `git_buf` is external
libgit2 has two distinct requirements that were previously solved by
`git_buf`. We require:
1. A general purpose string class that provides a number of utility APIs
for manipulating data (eg, concatenating, truncating, etc).
2. A structure that we can use to return strings to callers that they
can take ownership of.
By using a single class (`git_buf`) for both of these purposes, we have
confused the API to the point that refactorings are difficult and
reasoning about correctness is also difficult.
Move the utility class `git_buf` to be called `git_str`: this represents
its general purpose, as an internal string buffer class. The name also
is an homage to Junio Hamano ("gitstr").
The public API remains `git_buf`, and has a much smaller footprint. It
is generally only used as an "out" param with strict requirements that
follow the documentation. (Exceptions exist for some legacy APIs to
avoid breaking callers unnecessarily.)
Utility functions exist to convert a user-specified `git_buf` to a
`git_str` so that we can call internal functions, then converting it
back again.
|
|
|
ef03e150
|
2021-08-29T10:14:01
|
|
rebase: deprecate signing_cb
The signing callback should not be used; instead, callers should provide
a commit_create_cb, perform the signing and commit creation themselves.
|
|
|
d3bdf33b
|
2021-08-29T09:36:01
|
|
rebase: introduce git_commit_create_cb
Introduce a new mechanism for `git_rebase_commit` for callers to
customize the experience. Instead of assuming that we produce the
commit for them, provide a commit creation callback that allows callers
to produce the commit themselves and return the resulting commit id.
|
|
|
690ff9cd
|
2020-04-05T19:17:58
|
|
rebase: use GIT_ASSERT
|
|
c6184f0c
|
2020-06-08T21:07:36
|
|
tree-wide: do not compile deprecated functions with hard deprecation
When compiling libgit2 with -DDEPRECATE_HARD, we add a preprocessor
definition `GIT_DEPRECATE_HARD` which causes the "git2/deprecated.h"
header to be empty. As a result, no function declarations are made
available to callers, but the implementations are still available to
link against. This has the problem that function declarations also
aren't visible to the implementations, meaning that the symbol's
visibility will not be set up correctly. As a result, the resulting
library may not expose those deprecated symbols at all on some platforms
and thus cause linking errors.
Fix the issue by conditionally compiling deprecated functions, only.
While it becomes impossible to link against such a library in case one
uses deprecated functions, distributors of libgit2 aren't expected to
pass -DDEPRECATE_HARD anyway. Instead, users of libgit2 should manually
define GIT_DEPRECATE_HARD to hide deprecated functions. Using "real"
hard deprecation still makes sense in the context of CI to test we don't
use deprecated symbols ourselves and in case a dependant uses libgit2 in
a vendored way and knows it won't ever use any of the deprecated symbols
anyway.
|
|
|
df3063ea
|
2020-01-18T14:04:44
|
|
rebase: update enum type name for consistency
libgit2 does not use `type_t` suffixes as it's redundant; thus, rename
`git_rebase_type_t` to `git_rebase_t` for consistency.
|
|
|
b0692d6b
|
2019-08-09T09:01:56
|
|
Merge pull request #4913 from implausible/feature/signing-rebase-commits
Add sign capability to git_rebase_commit
|
|
39bc514f
|
2019-07-02T09:57:54
|
|
rebase: always use git_commit_create_with_signature
This simplifies the flow of rebase_commit__create because it doesn't have to juggle 2 different commit flows (one with signature and one without).
|
|
|
3b8a6f43
|
2019-07-02T09:48:08
|
|
fixup: Leverage git_error_set_after_callback_function
|
|
|
b4a173b5
|
2019-05-20T07:12:36
|
|
rebase: use size_t for path length
|
|
|
0b5ba0d7
|
2019-06-06T16:36:23
|
|
Rename opt init functions to `options_init`
In libgit2 nomenclature, when we need to verb a direct object, we name
a function `git_directobject_verb`. Thus, if we need to init an options
structure named `git_foo_options`, then the name of the function that
does that should be `git_foo_options_init`.
The previous names of `git_foo_init_options` is close - it _sounds_ as
if it's initializing the options of a `foo`, but in fact
`git_foo_options` is its own noun that should be respected.
Deprecate the old names; they'll now call directly to the new ones.
|
|
e215f475
|
2019-04-21T21:36:36
|
|
rebase: orig_head and onto accessors
The rebase struct stores fields with information about the current
rebase process, which were not accessible via a public interface.
Accessors for getting the `orig_head` and `onto` branch
names and object ids have been added.
|
|
|
3d8c54be
|
2019-02-21T09:27:16
|
|
Clear error before calling signing_cb, set error if one has not been set
We should clear the error before calling the signing_cb to allow the signing_cb to set its own errors. If the CB did not provide an error, we should set our own generic error before exiting rebase_commit__create
|
|
|
372694fe
|
2019-02-20T09:02:02
|
|
Set git_error when signing_cb returns an error code
|
|
|
0d06bf48
|
2019-01-24T08:42:25
|
|
fixup: More generic signing_cb for future flexibility
In the case that we want to build merge + commit, cherrypick + commit, or even just build a commit with signing callback, `git_rebase_commit_signature_cb` particular callback should be made more generic. We also renamed `signature_cb` to `signing_cb` to improve clarity on the purpose of the callback (build a difference between a git_signature and the act of signing).
So we've ended up with `git_commit_signing_cb`.
|
|
|
578cc029
|
2019-01-14T17:03:49
|
|
Single callback for commit signing in rebase w/ git_buf
Reduces the number of callbacks for signing a commit during a rebase operation to just one callback. That callback has 2 out git_buf parameters for signature and signature field. We use git_buf here, because we cannot make any assumptions about the heap allocator a user of the library might be using.
|
|
|
546e40c9
|
2019-01-11T09:16:58
|
|
Add signing callbacks for git_rebase_commit in git_rebase_options
2 callbacks have been added to git_rebase_options, git_rebase_commit_signature_cb and git_rebase_commit_signature_field_cb. When git_rebase_commit_signature_cb is present in git_rebase_options, it will be called whenever git_rebase_commit is performed, giving an opportunity to sign the commit. The signing procedure can be skipped if the callback specifies passthrough as the error. The git_rebase_commit_signature_field_cb will only be called if the other callback is present or did not passthrough, and it provides means to specify which field a signature is for.
Git_rebase_options was chosen as the home for these callbacks as it keeps backwards compatibility with the current rebase api.
|
|
|
f673e232
|
2018-12-27T13:47:34
|
|
git_error: use new names in internal APIs and usage
Move to the `git_error` name in the internal API for error-related
functions.
|
|
|
168fe39b
|
2018-11-28T14:26:57
|
|
object_type: use new enumeration names
Use the new object_type enumeration names within the codebase.
|
|
|
2613fbb2
|
2018-10-18T11:58:14
|
|
global: replace remaining use of `git__strtol32`
Replace remaining uses of the `git__strtol32` function. While these uses
are all safe as the strings were either sanitized or from a trusted
source, we want to remove `git__strtol32` altogether to avoid future
misuse.
|
|
|
ecf4f33a
|
2018-02-08T11:14:48
|
|
Convert usage of `git_buf_free` to new `git_buf_dispose`
|
|
cdd0bc2f
|
2018-03-26T18:44:13
|
|
checkout: change default strategy to SAFE
As per #4200, our default is quite surprising to users that expect checkout to just "do the thing".
|
|
|
0c7f49dd
|
2017-06-30T13:39:01
|
|
Make sure to always include "common.h" first
Next to including several files, our "common.h" header also declares
various macros which are then used throughout the project. As such, we
have to make sure to always include this file first in all
implementation files. Otherwise, we might encounter problems or even
silent behavioural differences due to macros or defines not being
defined as they should be. So in fact, our header and implementation
files should make sure to always include "common.h" first.
This commit does so by establishing a common include pattern. Header
files inside of "src" will now always include "common.h" as its first
other file, separated by a newline from all the other includes to make
it stand out as special. There are two cases for the implementation
files. If they do have a matching header file, they will always include
this one first, leading to "common.h" being transitively included as
first file. If they do not have a matching header file, they instead
include "common.h" as first file themselves.
This fixes the outlined problems and will become our standard practice
for header and source files inside of the "src/" from now on.
|
|
|
6fd6c678
|
2017-03-22T20:29:22
|
|
Merge pull request #4030 from libgit2/ethomson/fsync
fsync all the things
|
|
2270ca9f
|
2017-03-03T13:27:47
|
|
rebase: ignore untracked files in submodules
An untracked file in a submodule should not prevent a rebase from
starting. Even if the submodule's SHA is changed, and that file would
conflict with a new tracked file, it's still OK to start the rebase
and discover the conflict later.
Signed-off-by: David Turner <dturner@twosigma.com>
|
|
|
5a747e0c
|
2016-12-27T23:07:07
|
|
git_futils_writebuffer: default only when flags==0
Only use defaults for `git_futils_writebuffer` when flags == 0, lest
(1 << 31) be treated as the defaults.
|
|
|
84f56cb0
|
2016-11-04T11:59:52
|
|
repository: rename `path_repository` and `path_gitlink`
The `path_repository` variable is actually confusing to think
about, as it is not always clear what the repository actually is.
It may either be the path to the folder containing worktree and
.git directory, the path to .git itself, a worktree or something
entirely different. Actually, the intent of the variable is to
hold the path to the gitdir, which is either the .git directory
or the bare repository.
Rename the variable to `gitdir` to avoid confusion. While at it,
also rename `path_gitlink` to `gitlink` to improve consistency.
|
|
|
909d5494
|
2016-12-29T12:25:15
|
|
giterr_set: consistent error messages
Error messages should be sentence fragments, and therefore:
1. Should not begin with a capital letter,
2. Should not conclude with punctuation, and
3. Should not end a sentence and begin a new one
|
|
f928c69a
|
2016-12-29T12:54:26
|
|
rebase: check the result code of rebase_init_merge
|
|
|
4db1fc7e
|
2016-12-01T23:06:41
|
|
git_rebase_init: correctly handle detached HEAD
git_rebase_finish relies on head_detached being set, but
rebase_init_merge was only setting it when branch->ref_name was unset.
But branch->ref_name would be set to "HEAD" in the case of detached
HEAD being either implicitly (NULL) or explicitly passed to
git_rebase_init.
|
|
3cc5ec94
|
2016-10-05T12:57:53
|
|
rebase: don't ask for time sorting
`git-rebase--merge` does not ask for time sorting, but uses the default. We now
produce the same default time-ordered output as git, so make us of that since
it's not always the same output as our time sorting.
|
|
|
4505a42a
|
2016-05-26T12:42:43
|
|
rebase: change assertion to avoid
It looks like we're getting the operation and not doing anything
with it, when in fact we are asserting that it's not null. Simply
assert that we are within the operation boundary instead of using
the `git_array_get` macro to do this for us.
|
|
|
9a363d1b
|
2016-05-03T15:29:50
|
|
rebase: handle no common ancestor for inmemory
|
|
|
1f84caf0
|
2016-04-21T18:16:37
|
|
rebase: correctly finish rebasing detached heads
When rebasing with IDs, we do not return to the `branch`,
we remain in a detached HEAD state.
|
|
|
badc7283
|
2016-04-21T17:29:19
|
|
rebase: handle detached HEADs in `init`
When `init`ing a rebase from a detached HEAD, be sure to remember
that we were in a detached HEAD state so that we can correctly
`abort` the object that we just created.
|
|
|
2afb6fa4
|
2016-02-22T16:05:13
|
|
rebase: plug memory leak in `rebase_alloc`
Convert `rebase_alloc` to use our usual error propagation
patterns, that is accept an out-parameter and return an error
code that is to be checked by the caller. This allows us to use
the GITERR_CHECK_ALLOC macro, which helps static analysis.
|
|
|
f28bae0c
|
2016-02-15T17:16:00
|
|
rebase: persist a single in-memory index
When performing an in-memory rebase, keep a single index for the
duration, so that callers have the expected index lifecycle and
do not hold on to an index that is free'd out from under them.
|
|
|
a202e0d4
|
2016-02-11T10:11:21
|
|
rebase: allow custom merge_options
Allow callers of rebase to specify custom merge options. This may
allow custom conflict resolution, or failing fast when conflicts
are detected.
|
|
|
ee667307
|
2016-02-11T10:48:48
|
|
rebase: introduce inmemory rebasing
Introduce the ability to rebase in-memory or in a bare repository.
When `rebase_options.inmemory` is specified, the resultant `git_rebase`
session will not be persisted to disk. Callers may still analyze
the rebase operations, resolve any conflicts against the in-memory
index and create the commits. Neither `HEAD` nor the working
directory will be updated during this process.
|
|
768f8be3
|
2015-06-30T19:00:41
|
|
Fix #3094 - improve use of portable size_t/ssize_t format specifiers.
The header src/cc-compat.h defines portable format specifiers PRIuZ, PRIdZ, and PRIxZ. The original report highlighted the need to use these specifiers in examples/network/fetch.c. For this commit, I checked all C source and header files not in deps/ and transitioned to the appropriate format specifier where appropriate.
|
|
|
02980bdc
|
2015-06-09T16:53:07
|
|
Initialize a few variables
Coverity complains about the git_rawobj ones because we use a loop in
which we keep remembering the old version, and we end up copying our
object as the base, so we want to have the data pointer be NULL.
|
|
94c988f6
|
2015-04-20T17:19:08
|
|
rebase: include checkout opts within rebase opts
|
|
|
f3a199dd
|
2015-03-17T15:53:04
|
|
rebase: init and open take a rebase_options
`git_rebase_init` and `git_rebase_open` should take a
`git_rebase_options` and use it for future rebase operations on
that `rebase` object.
|
|
|
5ae38538
|
2015-03-17T11:47:16
|
|
rebase: take `checkout_options` where appropriate
|
|
|
eaf0d688
|
2015-03-17T17:53:07
|
|
rebase: block rebase_commit with unstaged changes
|
|
|
30640aa9
|
2015-03-17T10:04:08
|
|
rebase: identify a rebase that has not started
In `git_rebase_operation_current()`, indicate when a rebase has not
started (with `GIT_REBASE_NO_OPERATION`) rather than conflating that
with the first operation being in-progress.
|
|
|
fe21d708
|
2015-03-04T00:29:37
|
|
Plug a few leaks
|
|
|
23a17803
|
2015-01-07T14:16:50
|
|
reset: remove reflog message override
This function is meant to simulate what git does in the reset command,
so we should include the reflog message in that.
|
|
|
659cf202
|
2015-01-07T12:23:05
|
|
Remove the signature from ref-modifying functions
The signature for the reflog is not something which changes
dynamically. Almost all uses will be NULL, since we want for the
repository's default identity to be used, making it noise.
In order to allow for changing the identity, we instead provide
git_repository_set_ident() and git_repository_ident() which allow a user
to override the choice of signature.
|
|
|
3cbaa587
|
2015-02-27T04:39:54
|
|
rebase: check alloc result
|
|
|
a291790a
|
2015-02-15T05:18:01
|
|
Merge pull request #2831 from ethomson/merge_lock
merge: lock index during the merge (not just checkout)
|
|
|
41fae48d
|
2015-02-03T22:31:10
|
|
indexwriter: an indexwriter for repo operations
Provide git_indexwriter_init_for_operation for the common locking
pattern in merge, rebase, revert and cherry-pick.
|
|
|
be8404a7
|
2015-02-03T21:51:48
|
|
merge-like operations: lock index while working
|
|
|
ffbd51ed
|
2015-02-13T11:38:00
|
|
rebase: `CHECKOUT_SAFE` instead of `FORCE`
Switch to a standard branch-switching pattern of a `SAFE` checkout,
then updating `HEAD`.
|
|
|
49b8293c
|
2015-02-13T11:20:32
|
|
rebase: allow `NULL` branch to indicate `HEAD`
Don't require the branch to rebase, if given `NULL`, simply look up
`HEAD`.
|
|
|
92e87dd7
|
2015-02-13T10:44:19
|
|
rebase: provide NULL `exec` on non-EXEC operations
Users may want to try to pay attention to the `exec` field on all
rebase operations.
|
|
02eb1495
|
2015-02-12T15:32:52
|
|
Check rebase options version on public entry points
|
|
|
3dbd9a0e
|
2014-12-24T11:43:38
|
|
Check the result of git_buf_joinpath
|
|
|
6f73e026
|
2014-12-24T11:42:50
|
|
Plug some leaks
|
|
|
21083a71
|
2014-12-06T03:12:04
|
|
notes: move the notes name argument
Make it consistent between git_note_create() and git_note_remote() by
putting it after the repository.
|
|
|
979645a7
|
2014-10-04T20:17:26
|
|
rebase: updates based on PR comments
|
|
|
18b00406
|
2014-10-03T19:02:29
|
|
s/git_merge_head/git_annotated_commit
Rename git_merge_head to git_annotated_commit, as it becomes used
in more operations than just merge.
|
|
|
796b03bd
|
2014-10-03T20:47:48
|
|
rebase: clean up some warnings and memory leaks
|
|
|
e69737d7
|
2014-09-11T16:46:46
|
|
rebase: oid member of operation should be const
|
|
|
ed2c06a6
|
2014-09-11T16:47:20
|
|
git_rebase: iterators for operations
|
|
|
f152f8ac
|
2014-08-26T16:18:46
|
|
rebase: preload all operations
|
|
|
b6b636a7
|
2014-08-25T13:29:50
|
|
rebase: init/open a git_rebase object
|
|
|
18b439b9
|
2014-08-23T18:19:34
|
|
git_rebase_next: provide info about the operation
|
|
|
5ae9d296
|
2014-07-21T12:25:03
|
|
git_rebase_finish: rewrite notes when finishing rebase
|
|
|
a612a25f
|
2014-07-18T18:22:54
|
|
git_rebase_commit: write HEAD's reflog appropriately
|
|
|
517644cc
|
2014-07-18T17:19:10
|
|
Introduce git_rebase_finish to complete a rebase
|
|
|
93a7004c
|
2014-07-18T14:50:06
|
|
git_rebase_commit: drop already-picked commits
Already cherry-picked commits should not be re-included. If all changes
included in a commit exist in the upstream, then we should error with
GIT_EAPPLIED.
|
|
|
a35a9890
|
2014-07-17T18:25:03
|
|
Introduce git_rebase_commit
Commit the current patch of a rebase process.
|
|
|
443d5674
|
2014-07-17T11:59:01
|
|
git_rebase_next: write conflicts nicely during rebase
|
|
|
950a7091
|
2014-07-15T10:23:10
|
|
Introduce git_rebase_next
`git_rebase_next` will apply the next patch (or cherry-pick)
operation, leaving the results checked out in the index / working
directory so that consumers can resolve any conflicts, as appropriate.
|
|
|
4fe84d62
|
2014-07-14T15:19:19
|
|
Introduce git_rebase_abort
Abort an in-progress rebase and move the working directory and
repository back to the ORIG_HEAD state.
|
|
|
867a36f3
|
2014-07-14T14:35:01
|
|
Introduce git_rebase to set up a rebase session
Introduce `git_rebase` to set up a rebase session that can
then be continued. Immediately, only merge-type rebase is
supported.
|