2009-02-02 05:12:44 +00:00
|
|
|
/*
|
|
|
|
* Builtin "git replace"
|
|
|
|
*
|
|
|
|
* Copyright (c) 2008 Christian Couder <chriscool@tuxfamily.org>
|
|
|
|
*
|
2013-06-18 17:44:58 +00:00
|
|
|
* Based on builtin/tag.c by Kristian Høgsberg <krh@redhat.com>
|
2009-02-02 05:12:44 +00:00
|
|
|
* and Carlos Rica <jasampler@gmail.com> that was itself based on
|
|
|
|
* git-tag.sh and mktag.c by Linus Torvalds.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "cache.h"
|
2017-06-14 18:07:36 +00:00
|
|
|
#include "config.h"
|
2009-02-02 05:12:44 +00:00
|
|
|
#include "builtin.h"
|
|
|
|
#include "refs.h"
|
|
|
|
#include "parse-options.h"
|
2014-04-26 20:00:57 +00:00
|
|
|
#include "run-command.h"
|
2018-04-12 00:21:10 +00:00
|
|
|
#include "object-store.h"
|
|
|
|
#include "repository.h"
|
2014-07-19 15:01:14 +00:00
|
|
|
#include "tag.h"
|
2009-02-02 05:12:44 +00:00
|
|
|
|
|
|
|
static const char * const git_replace_usage[] = {
|
2012-08-20 12:32:36 +00:00
|
|
|
N_("git replace [-f] <object> <replacement>"),
|
2014-05-17 12:16:38 +00:00
|
|
|
N_("git replace [-f] --edit <object>"),
|
2014-07-19 15:01:08 +00:00
|
|
|
N_("git replace [-f] --graft <commit> [<parent>...]"),
|
2018-04-28 22:44:35 +00:00
|
|
|
N_("git replace [-f] --convert-graft-file"),
|
2012-08-20 12:32:36 +00:00
|
|
|
N_("git replace -d <object>..."),
|
2013-12-11 07:46:10 +00:00
|
|
|
N_("git replace [--format=<format>] [-l [<pattern>]]"),
|
2009-02-02 05:12:44 +00:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2013-12-28 11:00:05 +00:00
|
|
|
enum replace_format {
|
2014-06-24 09:43:07 +00:00
|
|
|
REPLACE_FORMAT_SHORT,
|
|
|
|
REPLACE_FORMAT_MEDIUM,
|
|
|
|
REPLACE_FORMAT_LONG
|
2013-12-28 11:00:05 +00:00
|
|
|
};
|
2013-12-11 07:46:10 +00:00
|
|
|
|
|
|
|
struct show_data {
|
|
|
|
const char *pattern;
|
2013-12-28 11:00:05 +00:00
|
|
|
enum replace_format format;
|
2013-12-11 07:46:10 +00:00
|
|
|
};
|
|
|
|
|
2018-08-20 18:24:19 +00:00
|
|
|
static int show_reference(struct repository *r, const char *refname,
|
|
|
|
const struct object_id *oid,
|
2009-02-02 05:12:44 +00:00
|
|
|
int flag, void *cb_data)
|
|
|
|
{
|
2013-12-11 07:46:10 +00:00
|
|
|
struct show_data *data = cb_data;
|
|
|
|
|
2017-06-22 21:38:08 +00:00
|
|
|
if (!wildmatch(data->pattern, refname, 0)) {
|
2013-12-28 11:00:05 +00:00
|
|
|
if (data->format == REPLACE_FORMAT_SHORT)
|
2013-12-11 07:46:10 +00:00
|
|
|
printf("%s\n", refname);
|
2013-12-28 11:00:05 +00:00
|
|
|
else if (data->format == REPLACE_FORMAT_MEDIUM)
|
2015-05-25 18:38:44 +00:00
|
|
|
printf("%s -> %s\n", refname, oid_to_hex(oid));
|
2013-12-28 11:00:05 +00:00
|
|
|
else { /* data->format == REPLACE_FORMAT_LONG */
|
2015-05-25 18:38:44 +00:00
|
|
|
struct object_id object;
|
2013-12-11 07:46:10 +00:00
|
|
|
enum object_type obj_type, repl_type;
|
2009-02-02 05:12:44 +00:00
|
|
|
|
sha1_name: convert get_sha1* to get_oid*
Now that all the callers of get_sha1 directly or indirectly use struct
object_id, rename the functions starting with get_sha1 to start with
get_oid. Convert the internals in sha1_name.c to use struct object_id
as well, and eliminate explicit length checks where possible. Convert a
use of 40 in get_oid_basic to GIT_SHA1_HEXSZ.
Outside of sha1_name.c and cache.h, this transition was made with the
following semantic patch:
@@
expression E1, E2;
@@
- get_sha1(E1, E2.hash)
+ get_oid(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1(E1, E2->hash)
+ get_oid(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_committish(E1, E2.hash)
+ get_oid_committish(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_committish(E1, E2->hash)
+ get_oid_committish(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_treeish(E1, E2.hash)
+ get_oid_treeish(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_treeish(E1, E2->hash)
+ get_oid_treeish(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_commit(E1, E2.hash)
+ get_oid_commit(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_commit(E1, E2->hash)
+ get_oid_commit(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_tree(E1, E2.hash)
+ get_oid_tree(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_tree(E1, E2->hash)
+ get_oid_tree(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_blob(E1, E2.hash)
+ get_oid_blob(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_blob(E1, E2->hash)
+ get_oid_blob(E1, E2)
@@
expression E1, E2, E3, E4;
@@
- get_sha1_with_context(E1, E2, E3.hash, E4)
+ get_oid_with_context(E1, E2, &E3, E4)
@@
expression E1, E2, E3, E4;
@@
- get_sha1_with_context(E1, E2, E3->hash, E4)
+ get_oid_with_context(E1, E2, E3, E4)
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-07-13 23:49:28 +00:00
|
|
|
if (get_oid(refname, &object))
|
2018-07-21 07:49:25 +00:00
|
|
|
return error(_("failed to resolve '%s' as a valid ref"), refname);
|
2013-12-11 07:46:10 +00:00
|
|
|
|
2018-08-20 18:24:19 +00:00
|
|
|
obj_type = oid_object_info(r, &object, NULL);
|
|
|
|
repl_type = oid_object_info(r, oid, NULL);
|
2013-12-11 07:46:10 +00:00
|
|
|
|
2018-02-14 18:59:24 +00:00
|
|
|
printf("%s (%s) -> %s (%s)\n", refname, type_name(obj_type),
|
|
|
|
oid_to_hex(oid), type_name(repl_type));
|
2013-12-11 07:46:10 +00:00
|
|
|
}
|
|
|
|
}
|
2009-02-02 05:12:44 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-12-11 07:46:10 +00:00
|
|
|
static int list_replace_refs(const char *pattern, const char *format)
|
2009-02-02 05:12:44 +00:00
|
|
|
{
|
2013-12-11 07:46:10 +00:00
|
|
|
struct show_data data;
|
|
|
|
|
2009-02-02 05:12:44 +00:00
|
|
|
if (pattern == NULL)
|
|
|
|
pattern = "*";
|
2013-12-11 07:46:10 +00:00
|
|
|
data.pattern = pattern;
|
|
|
|
|
|
|
|
if (format == NULL || *format == '\0' || !strcmp(format, "short"))
|
2013-12-28 11:00:05 +00:00
|
|
|
data.format = REPLACE_FORMAT_SHORT;
|
2013-12-11 07:46:10 +00:00
|
|
|
else if (!strcmp(format, "medium"))
|
2013-12-28 11:00:05 +00:00
|
|
|
data.format = REPLACE_FORMAT_MEDIUM;
|
|
|
|
else if (!strcmp(format, "long"))
|
|
|
|
data.format = REPLACE_FORMAT_LONG;
|
2019-02-16 11:24:41 +00:00
|
|
|
/*
|
|
|
|
* Please update _git_replace() in git-completion.bash when
|
|
|
|
* you add new format
|
|
|
|
*/
|
2013-12-11 07:46:10 +00:00
|
|
|
else
|
2018-07-21 07:49:25 +00:00
|
|
|
return error(_("invalid replace format '%s'\n"
|
|
|
|
"valid formats are 'short', 'medium' and 'long'"),
|
2018-04-28 22:44:26 +00:00
|
|
|
format);
|
2009-02-02 05:12:44 +00:00
|
|
|
|
2018-04-12 00:21:10 +00:00
|
|
|
for_each_replace_ref(the_repository, show_reference, (void *)&data);
|
2009-02-02 05:12:44 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
typedef int (*each_replace_name_fn)(const char *name, const char *ref,
|
2017-02-21 23:47:30 +00:00
|
|
|
const struct object_id *oid);
|
2009-02-02 05:12:44 +00:00
|
|
|
|
|
|
|
static int for_each_replace_name(const char **argv, each_replace_name_fn fn)
|
|
|
|
{
|
2012-11-13 10:34:11 +00:00
|
|
|
const char **p, *full_hex;
|
2017-03-28 19:46:30 +00:00
|
|
|
struct strbuf ref = STRBUF_INIT;
|
|
|
|
size_t base_len;
|
2009-02-02 05:12:44 +00:00
|
|
|
int had_error = 0;
|
2017-02-21 23:47:30 +00:00
|
|
|
struct object_id oid;
|
2009-02-02 05:12:44 +00:00
|
|
|
|
2017-03-28 19:46:30 +00:00
|
|
|
strbuf_addstr(&ref, git_replace_ref_base);
|
|
|
|
base_len = ref.len;
|
|
|
|
|
2009-02-02 05:12:44 +00:00
|
|
|
for (p = argv; *p; p++) {
|
2017-02-21 23:47:30 +00:00
|
|
|
if (get_oid(*p, &oid)) {
|
2018-07-21 07:49:19 +00:00
|
|
|
error("failed to resolve '%s' as a valid ref", *p);
|
2009-02-02 05:12:44 +00:00
|
|
|
had_error = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2017-03-28 19:46:30 +00:00
|
|
|
|
|
|
|
strbuf_setlen(&ref, base_len);
|
|
|
|
strbuf_addstr(&ref, oid_to_hex(&oid));
|
|
|
|
full_hex = ref.buf + base_len;
|
|
|
|
|
2017-10-15 22:06:56 +00:00
|
|
|
if (read_ref(ref.buf, &oid)) {
|
2018-07-21 07:49:25 +00:00
|
|
|
error(_("replace ref '%s' not found"), full_hex);
|
2009-02-02 05:12:44 +00:00
|
|
|
had_error = 1;
|
|
|
|
continue;
|
|
|
|
}
|
2017-03-28 19:46:30 +00:00
|
|
|
if (fn(full_hex, ref.buf, &oid))
|
2009-02-02 05:12:44 +00:00
|
|
|
had_error = 1;
|
|
|
|
}
|
2017-04-18 04:56:54 +00:00
|
|
|
strbuf_release(&ref);
|
2009-02-02 05:12:44 +00:00
|
|
|
return had_error;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int delete_replace_ref(const char *name, const char *ref,
|
2017-02-21 23:47:30 +00:00
|
|
|
const struct object_id *oid)
|
2009-02-02 05:12:44 +00:00
|
|
|
{
|
2017-10-15 22:06:50 +00:00
|
|
|
if (delete_ref(NULL, ref, oid, 0))
|
2009-02-02 05:12:44 +00:00
|
|
|
return 1;
|
2018-07-21 07:49:25 +00:00
|
|
|
printf_ln(_("Deleted replace ref '%s'"), name);
|
2009-02-02 05:12:44 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-04-28 22:44:26 +00:00
|
|
|
static int check_ref_valid(struct object_id *object,
|
2017-02-21 23:47:30 +00:00
|
|
|
struct object_id *prev,
|
2017-03-28 19:46:30 +00:00
|
|
|
struct strbuf *ref,
|
2014-05-17 12:16:35 +00:00
|
|
|
int force)
|
|
|
|
{
|
2017-03-28 19:46:30 +00:00
|
|
|
strbuf_reset(ref);
|
|
|
|
strbuf_addf(ref, "%s%s", git_replace_ref_base, oid_to_hex(object));
|
|
|
|
if (check_refname_format(ref->buf, 0))
|
2018-07-21 07:49:25 +00:00
|
|
|
return error(_("'%s' is not a valid ref name"), ref->buf);
|
2017-03-28 19:46:30 +00:00
|
|
|
|
2017-10-15 22:06:56 +00:00
|
|
|
if (read_ref(ref->buf, prev))
|
2017-02-21 23:47:30 +00:00
|
|
|
oidclr(prev);
|
2014-05-17 12:16:35 +00:00
|
|
|
else if (!force)
|
2018-07-21 07:49:25 +00:00
|
|
|
return error(_("replace ref '%s' already exists"), ref->buf);
|
2018-04-28 22:44:26 +00:00
|
|
|
return 0;
|
2014-05-17 12:16:35 +00:00
|
|
|
}
|
|
|
|
|
2017-02-21 23:47:30 +00:00
|
|
|
static int replace_object_oid(const char *object_ref,
|
|
|
|
struct object_id *object,
|
2014-04-26 20:00:56 +00:00
|
|
|
const char *replace_ref,
|
2017-02-21 23:47:30 +00:00
|
|
|
struct object_id *repl,
|
2014-04-26 20:00:56 +00:00
|
|
|
int force)
|
2009-02-02 05:12:53 +00:00
|
|
|
{
|
2017-02-21 23:47:30 +00:00
|
|
|
struct object_id prev;
|
replace: forbid replacing an object with one of a different type
Users replacing an object with one of a different type were not
prevented to do so, even if it was obvious, and stated in the doc,
that bad things would result from doing that.
To avoid mistakes, it is better to just forbid that though.
If -f option, which means '--force', is used, we can allow an object
to be replaced with one of a different type, as the user should know
what (s)he is doing.
If one object is replaced with one of a different type, the only way
to keep the history valid is to also replace all the other objects
that point to the replaced object. That's because:
* Annotated tags contain the type of the tagged object.
* The tree/parent lines in commits must be a tree and commits, resp.
* The object types referred to by trees are specified in the 'mode'
field:
100644 and 100755 blob
160000 commit
040000 tree
(these are the only valid modes)
* Blobs don't point at anything.
The doc will be updated in a later patch.
Acked-by: Philip Oakley <philipoakley@iee.org>
Signed-off-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-09-06 05:10:53 +00:00
|
|
|
enum object_type obj_type, repl_type;
|
2017-03-28 19:46:30 +00:00
|
|
|
struct strbuf ref = STRBUF_INIT;
|
2014-04-16 22:32:29 +00:00
|
|
|
struct ref_transaction *transaction;
|
|
|
|
struct strbuf err = STRBUF_INIT;
|
2018-04-28 22:44:26 +00:00
|
|
|
int res = 0;
|
2009-02-02 05:12:53 +00:00
|
|
|
|
2018-04-25 18:20:59 +00:00
|
|
|
obj_type = oid_object_info(the_repository, object, NULL);
|
|
|
|
repl_type = oid_object_info(the_repository, repl, NULL);
|
replace: forbid replacing an object with one of a different type
Users replacing an object with one of a different type were not
prevented to do so, even if it was obvious, and stated in the doc,
that bad things would result from doing that.
To avoid mistakes, it is better to just forbid that though.
If -f option, which means '--force', is used, we can allow an object
to be replaced with one of a different type, as the user should know
what (s)he is doing.
If one object is replaced with one of a different type, the only way
to keep the history valid is to also replace all the other objects
that point to the replaced object. That's because:
* Annotated tags contain the type of the tagged object.
* The tree/parent lines in commits must be a tree and commits, resp.
* The object types referred to by trees are specified in the 'mode'
field:
100644 and 100755 blob
160000 commit
040000 tree
(these are the only valid modes)
* Blobs don't point at anything.
The doc will be updated in a later patch.
Acked-by: Philip Oakley <philipoakley@iee.org>
Signed-off-by: Christian Couder <chriscool@tuxfamily.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2013-09-06 05:10:53 +00:00
|
|
|
if (!force && obj_type != repl_type)
|
2018-07-21 07:49:25 +00:00
|
|
|
return error(_("Objects must be of the same type.\n"
|
|
|
|
"'%s' points to a replaced object of type '%s'\n"
|
|
|
|
"while '%s' points to a replacement object of "
|
|
|
|
"type '%s'."),
|
2018-04-28 22:44:26 +00:00
|
|
|
object_ref, type_name(obj_type),
|
|
|
|
replace_ref, type_name(repl_type));
|
|
|
|
|
|
|
|
if (check_ref_valid(object, &prev, &ref, force)) {
|
|
|
|
strbuf_release(&ref);
|
|
|
|
return -1;
|
|
|
|
}
|
2009-02-02 05:12:53 +00:00
|
|
|
|
2014-04-16 22:32:29 +00:00
|
|
|
transaction = ref_transaction_begin(&err);
|
|
|
|
if (!transaction ||
|
2017-10-15 22:06:53 +00:00
|
|
|
ref_transaction_update(transaction, ref.buf, repl, &prev,
|
2015-02-17 17:00:15 +00:00
|
|
|
0, NULL, &err) ||
|
2014-04-30 19:22:42 +00:00
|
|
|
ref_transaction_commit(transaction, &err))
|
2018-04-28 22:44:26 +00:00
|
|
|
res = error("%s", err.buf);
|
2009-02-02 05:12:53 +00:00
|
|
|
|
2014-04-16 22:32:29 +00:00
|
|
|
ref_transaction_free(transaction);
|
2017-03-28 19:46:30 +00:00
|
|
|
strbuf_release(&ref);
|
2018-04-28 22:44:26 +00:00
|
|
|
return res;
|
2009-02-02 05:12:53 +00:00
|
|
|
}
|
|
|
|
|
2014-04-26 20:00:56 +00:00
|
|
|
static int replace_object(const char *object_ref, const char *replace_ref, int force)
|
|
|
|
{
|
2017-02-21 23:47:30 +00:00
|
|
|
struct object_id object, repl;
|
2014-04-26 20:00:56 +00:00
|
|
|
|
2017-02-21 23:47:30 +00:00
|
|
|
if (get_oid(object_ref, &object))
|
2018-07-21 07:49:25 +00:00
|
|
|
return error(_("failed to resolve '%s' as a valid ref"),
|
2018-04-28 22:44:26 +00:00
|
|
|
object_ref);
|
2017-02-21 23:47:30 +00:00
|
|
|
if (get_oid(replace_ref, &repl))
|
2018-07-21 07:49:25 +00:00
|
|
|
return error(_("failed to resolve '%s' as a valid ref"),
|
2018-04-28 22:44:26 +00:00
|
|
|
replace_ref);
|
2014-04-26 20:00:56 +00:00
|
|
|
|
2017-02-21 23:47:30 +00:00
|
|
|
return replace_object_oid(object_ref, &object, replace_ref, &repl, force);
|
2014-04-26 20:00:56 +00:00
|
|
|
}
|
|
|
|
|
2014-04-26 20:00:57 +00:00
|
|
|
/*
|
2014-06-24 09:46:31 +00:00
|
|
|
* Write the contents of the object named by "sha1" to the file "filename".
|
|
|
|
* If "raw" is true, then the object's raw contents are printed according to
|
|
|
|
* "type". Otherwise, we pretty-print the contents for human editing.
|
2014-04-26 20:00:57 +00:00
|
|
|
*/
|
2018-04-28 22:44:26 +00:00
|
|
|
static int export_object(const struct object_id *oid, enum object_type type,
|
2014-06-24 09:46:31 +00:00
|
|
|
int raw, const char *filename)
|
2014-04-26 20:00:57 +00:00
|
|
|
{
|
2014-08-19 19:09:35 +00:00
|
|
|
struct child_process cmd = CHILD_PROCESS_INIT;
|
2014-04-26 20:00:57 +00:00
|
|
|
int fd;
|
|
|
|
|
|
|
|
fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
|
|
|
|
if (fd < 0)
|
2018-07-21 07:49:25 +00:00
|
|
|
return error_errno(_("unable to open %s for writing"), filename);
|
2014-04-26 20:00:57 +00:00
|
|
|
|
2020-07-28 20:24:27 +00:00
|
|
|
strvec_push(&cmd.args, "--no-replace-objects");
|
|
|
|
strvec_push(&cmd.args, "cat-file");
|
2014-06-24 09:46:31 +00:00
|
|
|
if (raw)
|
2020-07-28 20:24:27 +00:00
|
|
|
strvec_push(&cmd.args, type_name(type));
|
2014-06-24 09:46:31 +00:00
|
|
|
else
|
2020-07-28 20:24:27 +00:00
|
|
|
strvec_push(&cmd.args, "-p");
|
|
|
|
strvec_push(&cmd.args, oid_to_hex(oid));
|
2014-04-26 20:00:57 +00:00
|
|
|
cmd.git_cmd = 1;
|
|
|
|
cmd.out = fd;
|
|
|
|
|
|
|
|
if (run_command(&cmd))
|
2018-07-21 07:49:25 +00:00
|
|
|
return error(_("cat-file reported failure"));
|
2018-04-28 22:44:26 +00:00
|
|
|
return 0;
|
2014-04-26 20:00:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Read a previously-exported (and possibly edited) object back from "filename",
|
|
|
|
* interpreting it as "type", and writing the result to the object database.
|
|
|
|
* The sha1 of the written object is returned via sha1.
|
|
|
|
*/
|
2018-04-28 22:44:26 +00:00
|
|
|
static int import_object(struct object_id *oid, enum object_type type,
|
2014-06-24 09:46:31 +00:00
|
|
|
int raw, const char *filename)
|
2014-04-26 20:00:57 +00:00
|
|
|
{
|
|
|
|
int fd;
|
|
|
|
|
|
|
|
fd = open(filename, O_RDONLY);
|
|
|
|
if (fd < 0)
|
2018-07-21 07:49:25 +00:00
|
|
|
return error_errno(_("unable to open %s for reading"), filename);
|
2014-04-26 20:00:57 +00:00
|
|
|
|
2014-06-24 09:46:31 +00:00
|
|
|
if (!raw && type == OBJ_TREE) {
|
2014-04-26 20:00:57 +00:00
|
|
|
const char *argv[] = { "mktree", NULL };
|
2014-08-19 19:09:35 +00:00
|
|
|
struct child_process cmd = CHILD_PROCESS_INIT;
|
2014-04-26 20:00:57 +00:00
|
|
|
struct strbuf result = STRBUF_INIT;
|
|
|
|
|
|
|
|
cmd.argv = argv;
|
|
|
|
cmd.git_cmd = 1;
|
|
|
|
cmd.in = fd;
|
|
|
|
cmd.out = -1;
|
|
|
|
|
2018-04-28 22:44:26 +00:00
|
|
|
if (start_command(&cmd)) {
|
|
|
|
close(fd);
|
2018-07-21 07:49:25 +00:00
|
|
|
return error(_("unable to spawn mktree"));
|
2018-04-28 22:44:26 +00:00
|
|
|
}
|
2014-04-26 20:00:57 +00:00
|
|
|
|
2019-08-18 20:04:02 +00:00
|
|
|
if (strbuf_read(&result, cmd.out, the_hash_algo->hexsz + 1) < 0) {
|
2018-07-21 07:49:25 +00:00
|
|
|
error_errno(_("unable to read from mktree"));
|
2018-04-28 22:44:26 +00:00
|
|
|
close(fd);
|
|
|
|
close(cmd.out);
|
|
|
|
return -1;
|
|
|
|
}
|
2014-04-26 20:00:57 +00:00
|
|
|
close(cmd.out);
|
|
|
|
|
2018-04-28 22:44:26 +00:00
|
|
|
if (finish_command(&cmd)) {
|
|
|
|
strbuf_release(&result);
|
2018-07-21 07:49:25 +00:00
|
|
|
return error(_("mktree reported failure"));
|
2018-04-28 22:44:26 +00:00
|
|
|
}
|
|
|
|
if (get_oid_hex(result.buf, oid) < 0) {
|
|
|
|
strbuf_release(&result);
|
2018-07-21 07:49:25 +00:00
|
|
|
return error(_("mktree did not return an object name"));
|
2018-04-28 22:44:26 +00:00
|
|
|
}
|
2014-04-26 20:00:57 +00:00
|
|
|
|
|
|
|
strbuf_release(&result);
|
|
|
|
} else {
|
|
|
|
struct stat st;
|
|
|
|
int flags = HASH_FORMAT_CHECK | HASH_WRITE_OBJECT;
|
|
|
|
|
2018-04-28 22:44:26 +00:00
|
|
|
if (fstat(fd, &st) < 0) {
|
2018-07-21 07:49:25 +00:00
|
|
|
error_errno(_("unable to fstat %s"), filename);
|
2018-04-28 22:44:26 +00:00
|
|
|
close(fd);
|
|
|
|
return -1;
|
|
|
|
}
|
2019-01-24 08:29:12 +00:00
|
|
|
if (index_fd(the_repository->index, oid, fd, &st, type, NULL, flags) < 0)
|
2018-07-21 07:49:25 +00:00
|
|
|
return error(_("unable to write object to database"));
|
2014-04-26 20:00:57 +00:00
|
|
|
/* index_fd close()s fd for us */
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* No need to close(fd) here; both run-command and index-fd
|
|
|
|
* will have done it for us.
|
|
|
|
*/
|
2018-04-28 22:44:26 +00:00
|
|
|
return 0;
|
2014-04-26 20:00:57 +00:00
|
|
|
}
|
|
|
|
|
2014-06-24 09:46:31 +00:00
|
|
|
static int edit_and_replace(const char *object_ref, int force, int raw)
|
2014-04-26 20:00:57 +00:00
|
|
|
{
|
2018-04-28 22:44:26 +00:00
|
|
|
char *tmpfile;
|
2014-04-26 20:00:57 +00:00
|
|
|
enum object_type type;
|
2018-02-14 18:59:59 +00:00
|
|
|
struct object_id old_oid, new_oid, prev;
|
2017-03-28 19:46:30 +00:00
|
|
|
struct strbuf ref = STRBUF_INIT;
|
2014-04-26 20:00:57 +00:00
|
|
|
|
2018-02-14 18:59:59 +00:00
|
|
|
if (get_oid(object_ref, &old_oid) < 0)
|
2018-07-21 07:49:25 +00:00
|
|
|
return error(_("not a valid object name: '%s'"), object_ref);
|
2014-04-26 20:00:57 +00:00
|
|
|
|
2018-04-25 18:20:59 +00:00
|
|
|
type = oid_object_info(the_repository, &old_oid, NULL);
|
2014-04-26 20:00:57 +00:00
|
|
|
if (type < 0)
|
2018-07-21 07:49:25 +00:00
|
|
|
return error(_("unable to get object type for %s"),
|
2018-04-28 22:44:26 +00:00
|
|
|
oid_to_hex(&old_oid));
|
2014-04-26 20:00:57 +00:00
|
|
|
|
2018-04-28 22:44:26 +00:00
|
|
|
if (check_ref_valid(&old_oid, &prev, &ref, force)) {
|
|
|
|
strbuf_release(&ref);
|
|
|
|
return -1;
|
|
|
|
}
|
2017-03-28 19:46:30 +00:00
|
|
|
strbuf_release(&ref);
|
2014-05-17 12:16:36 +00:00
|
|
|
|
2018-04-28 22:44:26 +00:00
|
|
|
tmpfile = git_pathdup("REPLACE_EDITOBJ");
|
|
|
|
if (export_object(&old_oid, type, raw, tmpfile)) {
|
|
|
|
free(tmpfile);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (launch_editor(tmpfile, NULL, NULL) < 0) {
|
|
|
|
free(tmpfile);
|
2018-07-21 07:49:25 +00:00
|
|
|
return error(_("editing object file failed"));
|
2018-04-28 22:44:26 +00:00
|
|
|
}
|
|
|
|
if (import_object(&new_oid, type, raw, tmpfile)) {
|
|
|
|
free(tmpfile);
|
|
|
|
return -1;
|
|
|
|
}
|
2014-04-26 20:00:57 +00:00
|
|
|
free(tmpfile);
|
|
|
|
|
convert "oidcmp() == 0" to oideq()
Using the more restrictive oideq() should, in the long run,
give the compiler more opportunities to optimize these
callsites. For now, this conversion should be a complete
noop with respect to the generated code.
The result is also perhaps a little more readable, as it
avoids the "zero is equal" idiom. Since it's so prevalent in
C, I think seasoned programmers tend not to even notice it
anymore, but it can sometimes make for awkward double
negations (e.g., we can drop a few !!oidcmp() instances
here).
This patch was generated almost entirely by the included
coccinelle patch. This mechanical conversion should be
completely safe, because we check explicitly for cases where
oidcmp() is compared to 0, which is what oideq() is doing
under the hood. Note that we don't have to catch "!oidcmp()"
separately; coccinelle's standard isomorphisms make sure the
two are treated equivalently.
I say "almost" because I did hand-edit the coccinelle output
to fix up a few style violations (it mostly keeps the
original formatting, but sometimes unwraps long lines).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-08-28 21:22:40 +00:00
|
|
|
if (oideq(&old_oid, &new_oid))
|
2018-07-21 07:49:25 +00:00
|
|
|
return error(_("new object is the same as the old one: '%s'"), oid_to_hex(&old_oid));
|
2014-05-17 12:16:34 +00:00
|
|
|
|
2018-02-14 18:59:59 +00:00
|
|
|
return replace_object_oid(object_ref, &old_oid, "replacement", &new_oid, force);
|
2014-04-26 20:00:57 +00:00
|
|
|
}
|
|
|
|
|
2018-04-28 22:44:26 +00:00
|
|
|
static int replace_parents(struct strbuf *buf, int argc, const char **argv)
|
2014-07-19 15:01:08 +00:00
|
|
|
{
|
|
|
|
struct strbuf new_parents = STRBUF_INIT;
|
|
|
|
const char *parent_start, *parent_end;
|
|
|
|
int i;
|
2019-08-18 20:04:02 +00:00
|
|
|
const unsigned hexsz = the_hash_algo->hexsz;
|
2014-07-19 15:01:08 +00:00
|
|
|
|
|
|
|
/* find existing parents */
|
|
|
|
parent_start = buf->buf;
|
2019-08-18 20:04:02 +00:00
|
|
|
parent_start += hexsz + 6; /* "tree " + "hex sha1" + "\n" */
|
2014-07-19 15:01:08 +00:00
|
|
|
parent_end = parent_start;
|
|
|
|
|
|
|
|
while (starts_with(parent_end, "parent "))
|
2019-08-18 20:04:02 +00:00
|
|
|
parent_end += hexsz + 8; /* "parent " + "hex sha1" + "\n" */
|
2014-07-19 15:01:08 +00:00
|
|
|
|
|
|
|
/* prepare new parents */
|
|
|
|
for (i = 0; i < argc; i++) {
|
2017-02-21 23:47:30 +00:00
|
|
|
struct object_id oid;
|
2019-03-31 13:46:58 +00:00
|
|
|
struct commit *commit;
|
|
|
|
|
2018-04-28 22:44:26 +00:00
|
|
|
if (get_oid(argv[i], &oid) < 0) {
|
|
|
|
strbuf_release(&new_parents);
|
2018-07-21 07:49:19 +00:00
|
|
|
return error(_("not a valid object name: '%s'"),
|
2018-04-28 22:44:26 +00:00
|
|
|
argv[i]);
|
|
|
|
}
|
2019-03-31 13:46:58 +00:00
|
|
|
commit = lookup_commit_reference(the_repository, &oid);
|
|
|
|
if (!commit) {
|
2018-04-28 22:44:26 +00:00
|
|
|
strbuf_release(&new_parents);
|
2019-03-31 13:46:58 +00:00
|
|
|
return error(_("could not parse %s as a commit"), argv[i]);
|
2018-04-28 22:44:26 +00:00
|
|
|
}
|
2019-03-31 13:46:58 +00:00
|
|
|
strbuf_addf(&new_parents, "parent %s\n", oid_to_hex(&commit->object.oid));
|
2014-07-19 15:01:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* replace existing parents with new ones */
|
|
|
|
strbuf_splice(buf, parent_start - buf->buf, parent_end - parent_start,
|
|
|
|
new_parents.buf, new_parents.len);
|
|
|
|
|
|
|
|
strbuf_release(&new_parents);
|
2018-04-28 22:44:26 +00:00
|
|
|
return 0;
|
2014-07-19 15:01:08 +00:00
|
|
|
}
|
|
|
|
|
2014-07-19 15:01:14 +00:00
|
|
|
struct check_mergetag_data {
|
|
|
|
int argc;
|
|
|
|
const char **argv;
|
|
|
|
};
|
|
|
|
|
2018-04-25 09:54:04 +00:00
|
|
|
static int check_one_mergetag(struct commit *commit,
|
2014-07-19 15:01:14 +00:00
|
|
|
struct commit_extra_header *extra,
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
struct check_mergetag_data *mergetag_data = (struct check_mergetag_data *)data;
|
|
|
|
const char *ref = mergetag_data->argv[0];
|
2017-02-21 23:47:30 +00:00
|
|
|
struct object_id tag_oid;
|
2014-07-19 15:01:14 +00:00
|
|
|
struct tag *tag;
|
|
|
|
int i;
|
|
|
|
|
2020-01-30 20:32:22 +00:00
|
|
|
hash_object_file(the_hash_algo, extra->value, extra->len,
|
|
|
|
type_name(OBJ_TAG), &tag_oid);
|
2018-06-29 01:22:03 +00:00
|
|
|
tag = lookup_tag(the_repository, &tag_oid);
|
2014-07-19 15:01:14 +00:00
|
|
|
if (!tag)
|
2018-04-28 22:44:26 +00:00
|
|
|
return error(_("bad mergetag in commit '%s'"), ref);
|
2018-06-29 01:22:04 +00:00
|
|
|
if (parse_tag_buffer(the_repository, tag, extra->value, extra->len))
|
2018-04-28 22:44:26 +00:00
|
|
|
return error(_("malformed mergetag in commit '%s'"), ref);
|
2014-07-19 15:01:14 +00:00
|
|
|
|
|
|
|
/* iterate over new parents */
|
|
|
|
for (i = 1; i < mergetag_data->argc; i++) {
|
2015-11-10 02:22:28 +00:00
|
|
|
struct object_id oid;
|
sha1_name: convert get_sha1* to get_oid*
Now that all the callers of get_sha1 directly or indirectly use struct
object_id, rename the functions starting with get_sha1 to start with
get_oid. Convert the internals in sha1_name.c to use struct object_id
as well, and eliminate explicit length checks where possible. Convert a
use of 40 in get_oid_basic to GIT_SHA1_HEXSZ.
Outside of sha1_name.c and cache.h, this transition was made with the
following semantic patch:
@@
expression E1, E2;
@@
- get_sha1(E1, E2.hash)
+ get_oid(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1(E1, E2->hash)
+ get_oid(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_committish(E1, E2.hash)
+ get_oid_committish(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_committish(E1, E2->hash)
+ get_oid_committish(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_treeish(E1, E2.hash)
+ get_oid_treeish(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_treeish(E1, E2->hash)
+ get_oid_treeish(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_commit(E1, E2.hash)
+ get_oid_commit(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_commit(E1, E2->hash)
+ get_oid_commit(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_tree(E1, E2.hash)
+ get_oid_tree(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_tree(E1, E2->hash)
+ get_oid_tree(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_blob(E1, E2.hash)
+ get_oid_blob(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_blob(E1, E2->hash)
+ get_oid_blob(E1, E2)
@@
expression E1, E2, E3, E4;
@@
- get_sha1_with_context(E1, E2, E3.hash, E4)
+ get_oid_with_context(E1, E2, &E3, E4)
@@
expression E1, E2, E3, E4;
@@
- get_sha1_with_context(E1, E2, E3->hash, E4)
+ get_oid_with_context(E1, E2, E3, E4)
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-07-13 23:49:28 +00:00
|
|
|
if (get_oid(mergetag_data->argv[i], &oid) < 0)
|
2018-07-21 07:49:19 +00:00
|
|
|
return error(_("not a valid object name: '%s'"),
|
2018-04-28 22:44:26 +00:00
|
|
|
mergetag_data->argv[i]);
|
2019-09-05 19:59:42 +00:00
|
|
|
if (oideq(get_tagged_oid(tag), &oid))
|
2018-04-25 09:54:04 +00:00
|
|
|
return 0; /* found */
|
2014-07-19 15:01:14 +00:00
|
|
|
}
|
|
|
|
|
2018-04-28 22:44:26 +00:00
|
|
|
return error(_("original commit '%s' contains mergetag '%s' that is "
|
|
|
|
"discarded; use --edit instead of --graft"), ref,
|
|
|
|
oid_to_hex(&tag_oid));
|
2014-07-19 15:01:14 +00:00
|
|
|
}
|
|
|
|
|
2018-04-25 09:54:04 +00:00
|
|
|
static int check_mergetags(struct commit *commit, int argc, const char **argv)
|
2014-07-19 15:01:14 +00:00
|
|
|
{
|
|
|
|
struct check_mergetag_data mergetag_data;
|
|
|
|
|
|
|
|
mergetag_data.argc = argc;
|
|
|
|
mergetag_data.argv = argv;
|
2018-04-25 09:54:04 +00:00
|
|
|
return for_each_mergetag(check_one_mergetag, commit, &mergetag_data);
|
2014-07-19 15:01:14 +00:00
|
|
|
}
|
|
|
|
|
2018-04-28 22:44:32 +00:00
|
|
|
static int create_graft(int argc, const char **argv, int force, int gentle)
|
2014-07-19 15:01:08 +00:00
|
|
|
{
|
2018-02-14 18:59:59 +00:00
|
|
|
struct object_id old_oid, new_oid;
|
2014-07-19 15:01:08 +00:00
|
|
|
const char *old_ref = argv[0];
|
|
|
|
struct commit *commit;
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
const char *buffer;
|
|
|
|
unsigned long size;
|
|
|
|
|
2018-02-14 18:59:59 +00:00
|
|
|
if (get_oid(old_ref, &old_oid) < 0)
|
2018-07-21 07:49:19 +00:00
|
|
|
return error(_("not a valid object name: '%s'"), old_ref);
|
2018-06-29 01:21:58 +00:00
|
|
|
commit = lookup_commit_reference(the_repository, &old_oid);
|
2018-04-28 22:44:26 +00:00
|
|
|
if (!commit)
|
|
|
|
return error(_("could not parse %s"), old_ref);
|
2014-07-19 15:01:08 +00:00
|
|
|
|
|
|
|
buffer = get_commit_buffer(commit, &size);
|
|
|
|
strbuf_add(&buf, buffer, size);
|
|
|
|
unuse_commit_buffer(commit, buffer);
|
|
|
|
|
2018-04-28 22:44:26 +00:00
|
|
|
if (replace_parents(&buf, argc - 1, &argv[1]) < 0) {
|
|
|
|
strbuf_release(&buf);
|
|
|
|
return -1;
|
|
|
|
}
|
2014-07-19 15:01:08 +00:00
|
|
|
|
2014-07-19 15:01:12 +00:00
|
|
|
if (remove_signature(&buf)) {
|
2018-07-21 07:49:19 +00:00
|
|
|
warning(_("the original commit '%s' has a gpg signature"), old_ref);
|
2014-07-19 15:01:12 +00:00
|
|
|
warning(_("the signature will be removed in the replacement commit!"));
|
|
|
|
}
|
|
|
|
|
2018-04-28 22:44:26 +00:00
|
|
|
if (check_mergetags(commit, argc, argv)) {
|
|
|
|
strbuf_release(&buf);
|
|
|
|
return -1;
|
|
|
|
}
|
2014-07-19 15:01:14 +00:00
|
|
|
|
2018-04-28 22:44:26 +00:00
|
|
|
if (write_object_file(buf.buf, buf.len, commit_type, &new_oid)) {
|
|
|
|
strbuf_release(&buf);
|
|
|
|
return error(_("could not write replacement commit for: '%s'"),
|
|
|
|
old_ref);
|
|
|
|
}
|
2014-07-19 15:01:08 +00:00
|
|
|
|
|
|
|
strbuf_release(&buf);
|
|
|
|
|
2019-03-31 13:46:59 +00:00
|
|
|
if (oideq(&commit->object.oid, &new_oid)) {
|
2018-04-28 22:44:32 +00:00
|
|
|
if (gentle) {
|
2019-03-31 13:46:59 +00:00
|
|
|
warning(_("graft for '%s' unnecessary"),
|
|
|
|
oid_to_hex(&commit->object.oid));
|
2018-04-28 22:44:32 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2019-03-31 13:46:59 +00:00
|
|
|
return error(_("new commit is the same as the old one: '%s'"),
|
|
|
|
oid_to_hex(&commit->object.oid));
|
2018-04-28 22:44:32 +00:00
|
|
|
}
|
2014-07-19 15:01:08 +00:00
|
|
|
|
2019-03-31 13:46:59 +00:00
|
|
|
return replace_object_oid(old_ref, &commit->object.oid,
|
|
|
|
"replacement", &new_oid, force);
|
2014-07-19 15:01:08 +00:00
|
|
|
}
|
|
|
|
|
2018-04-28 22:44:35 +00:00
|
|
|
static int convert_graft_file(int force)
|
|
|
|
{
|
2018-06-29 17:24:33 +00:00
|
|
|
const char *graft_file = get_graft_file(the_repository);
|
2018-04-28 22:44:35 +00:00
|
|
|
FILE *fp = fopen_or_warn(graft_file, "r");
|
|
|
|
struct strbuf buf = STRBUF_INIT, err = STRBUF_INIT;
|
2020-07-28 20:24:27 +00:00
|
|
|
struct strvec args = STRVEC_INIT;
|
2018-04-28 22:44:35 +00:00
|
|
|
|
|
|
|
if (!fp)
|
|
|
|
return -1;
|
|
|
|
|
2018-11-27 20:12:55 +00:00
|
|
|
advice_graft_file_deprecated = 0;
|
2018-04-28 22:44:35 +00:00
|
|
|
while (strbuf_getline(&buf, fp) != EOF) {
|
|
|
|
if (*buf.buf == '#')
|
|
|
|
continue;
|
|
|
|
|
2020-07-28 20:24:27 +00:00
|
|
|
strvec_split(&args, buf.buf);
|
2018-04-28 22:44:35 +00:00
|
|
|
if (args.argc && create_graft(args.argc, args.argv, force, 1))
|
|
|
|
strbuf_addf(&err, "\n\t%s", buf.buf);
|
2020-07-28 20:24:27 +00:00
|
|
|
strvec_clear(&args);
|
2018-04-28 22:44:35 +00:00
|
|
|
}
|
|
|
|
fclose(fp);
|
|
|
|
|
|
|
|
strbuf_release(&buf);
|
|
|
|
|
|
|
|
if (!err.len)
|
|
|
|
return unlink_or_warn(graft_file);
|
|
|
|
|
|
|
|
warning(_("could not convert the following graft(s):\n%s"), err.buf);
|
|
|
|
strbuf_release(&err);
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2009-02-02 05:12:44 +00:00
|
|
|
int cmd_replace(int argc, const char **argv, const char *prefix)
|
|
|
|
{
|
2014-04-26 20:00:55 +00:00
|
|
|
int force = 0;
|
2014-06-24 09:46:31 +00:00
|
|
|
int raw = 0;
|
2013-12-11 07:46:10 +00:00
|
|
|
const char *format = NULL;
|
2014-04-26 20:00:55 +00:00
|
|
|
enum {
|
|
|
|
MODE_UNSPECIFIED = 0,
|
|
|
|
MODE_LIST,
|
|
|
|
MODE_DELETE,
|
2014-04-26 20:00:57 +00:00
|
|
|
MODE_EDIT,
|
2014-07-19 15:01:08 +00:00
|
|
|
MODE_GRAFT,
|
2018-04-28 22:44:35 +00:00
|
|
|
MODE_CONVERT_GRAFT_FILE,
|
2014-04-26 20:00:55 +00:00
|
|
|
MODE_REPLACE
|
|
|
|
} cmdmode = MODE_UNSPECIFIED;
|
2009-02-02 05:12:44 +00:00
|
|
|
struct option options[] = {
|
2014-04-26 20:00:55 +00:00
|
|
|
OPT_CMDMODE('l', "list", &cmdmode, N_("list replace refs"), MODE_LIST),
|
|
|
|
OPT_CMDMODE('d', "delete", &cmdmode, N_("delete replace refs"), MODE_DELETE),
|
2014-04-26 20:00:57 +00:00
|
|
|
OPT_CMDMODE('e', "edit", &cmdmode, N_("edit existing object"), MODE_EDIT),
|
2014-07-19 15:01:08 +00:00
|
|
|
OPT_CMDMODE('g', "graft", &cmdmode, N_("change a commit's parents"), MODE_GRAFT),
|
2018-04-28 22:44:35 +00:00
|
|
|
OPT_CMDMODE(0, "convert-graft-file", &cmdmode, N_("convert existing graft file"), MODE_CONVERT_GRAFT_FILE),
|
2018-02-09 11:02:13 +00:00
|
|
|
OPT_BOOL_F('f', "force", &force, N_("replace the ref if it exists"),
|
|
|
|
PARSE_OPT_NOCOMPLETE),
|
2014-06-24 09:46:31 +00:00
|
|
|
OPT_BOOL(0, "raw", &raw, N_("do not pretty-print contents for --edit")),
|
2013-12-11 07:46:10 +00:00
|
|
|
OPT_STRING(0, "format", &format, N_("format"), N_("use this format")),
|
2009-02-02 05:12:44 +00:00
|
|
|
OPT_END()
|
|
|
|
};
|
|
|
|
|
2018-07-18 20:45:20 +00:00
|
|
|
read_replace_refs = 0;
|
2016-04-20 06:38:03 +00:00
|
|
|
git_config(git_default_config, NULL);
|
2013-12-11 07:46:12 +00:00
|
|
|
|
2009-02-02 05:12:58 +00:00
|
|
|
argc = parse_options(argc, argv, prefix, options, git_replace_usage, 0);
|
2009-02-02 05:12:44 +00:00
|
|
|
|
2014-04-26 20:00:55 +00:00
|
|
|
if (!cmdmode)
|
|
|
|
cmdmode = argc ? MODE_REPLACE : MODE_LIST;
|
2014-04-26 20:00:54 +00:00
|
|
|
|
2014-04-26 20:00:55 +00:00
|
|
|
if (format && cmdmode != MODE_LIST)
|
2018-07-21 07:49:25 +00:00
|
|
|
usage_msg_opt(_("--format cannot be used when not listing"),
|
2013-12-11 07:46:10 +00:00
|
|
|
git_replace_usage, options);
|
|
|
|
|
2014-07-19 15:01:08 +00:00
|
|
|
if (force &&
|
|
|
|
cmdmode != MODE_REPLACE &&
|
|
|
|
cmdmode != MODE_EDIT &&
|
2018-04-28 22:44:35 +00:00
|
|
|
cmdmode != MODE_GRAFT &&
|
|
|
|
cmdmode != MODE_CONVERT_GRAFT_FILE)
|
2018-07-21 07:49:25 +00:00
|
|
|
usage_msg_opt(_("-f only makes sense when writing a replacement"),
|
2009-02-02 05:13:06 +00:00
|
|
|
git_replace_usage, options);
|
2009-02-02 05:12:53 +00:00
|
|
|
|
2014-06-24 09:46:31 +00:00
|
|
|
if (raw && cmdmode != MODE_EDIT)
|
2018-07-21 07:49:25 +00:00
|
|
|
usage_msg_opt(_("--raw only makes sense with --edit"),
|
2014-06-24 09:46:31 +00:00
|
|
|
git_replace_usage, options);
|
|
|
|
|
2014-04-26 20:00:55 +00:00
|
|
|
switch (cmdmode) {
|
|
|
|
case MODE_DELETE:
|
2009-02-02 05:12:44 +00:00
|
|
|
if (argc < 1)
|
2018-07-21 07:49:25 +00:00
|
|
|
usage_msg_opt(_("-d needs at least one argument"),
|
2009-02-02 05:13:06 +00:00
|
|
|
git_replace_usage, options);
|
2009-02-02 05:12:44 +00:00
|
|
|
return for_each_replace_name(argv, delete_replace_ref);
|
|
|
|
|
2014-04-26 20:00:55 +00:00
|
|
|
case MODE_REPLACE:
|
2009-02-02 05:12:53 +00:00
|
|
|
if (argc != 2)
|
2018-07-21 07:49:25 +00:00
|
|
|
usage_msg_opt(_("bad number of arguments"),
|
2009-02-02 05:13:06 +00:00
|
|
|
git_replace_usage, options);
|
2009-02-02 05:12:53 +00:00
|
|
|
return replace_object(argv[0], argv[1], force);
|
|
|
|
|
2014-04-26 20:00:57 +00:00
|
|
|
case MODE_EDIT:
|
|
|
|
if (argc != 1)
|
2018-07-21 07:49:25 +00:00
|
|
|
usage_msg_opt(_("-e needs exactly one argument"),
|
2014-04-26 20:00:57 +00:00
|
|
|
git_replace_usage, options);
|
2014-06-24 09:46:31 +00:00
|
|
|
return edit_and_replace(argv[0], force, raw);
|
2014-04-26 20:00:57 +00:00
|
|
|
|
2014-07-19 15:01:08 +00:00
|
|
|
case MODE_GRAFT:
|
|
|
|
if (argc < 1)
|
2018-07-21 07:49:25 +00:00
|
|
|
usage_msg_opt(_("-g needs at least one argument"),
|
2014-07-19 15:01:08 +00:00
|
|
|
git_replace_usage, options);
|
2018-04-28 22:44:32 +00:00
|
|
|
return create_graft(argc, argv, force, 0);
|
2014-07-19 15:01:08 +00:00
|
|
|
|
2018-04-28 22:44:35 +00:00
|
|
|
case MODE_CONVERT_GRAFT_FILE:
|
|
|
|
if (argc != 0)
|
2018-07-21 07:49:25 +00:00
|
|
|
usage_msg_opt(_("--convert-graft-file takes no argument"),
|
2018-04-28 22:44:35 +00:00
|
|
|
git_replace_usage, options);
|
|
|
|
return !!convert_graft_file(force);
|
2014-07-19 15:01:08 +00:00
|
|
|
|
2014-04-26 20:00:55 +00:00
|
|
|
case MODE_LIST:
|
|
|
|
if (argc > 1)
|
2018-07-21 07:49:25 +00:00
|
|
|
usage_msg_opt(_("only one pattern can be given with -l"),
|
2014-04-26 20:00:55 +00:00
|
|
|
git_replace_usage, options);
|
|
|
|
return list_replace_refs(argv[0], format);
|
2009-02-02 05:12:44 +00:00
|
|
|
|
2014-04-26 20:00:55 +00:00
|
|
|
default:
|
2018-04-25 09:54:06 +00:00
|
|
|
BUG("invalid cmdmode %d", (int)cmdmode);
|
2014-04-26 20:00:55 +00:00
|
|
|
}
|
2009-02-02 05:12:44 +00:00
|
|
|
}
|