2006-07-26 01:52:35 +00:00
|
|
|
/*
|
|
|
|
* "git mv" builtin command
|
|
|
|
*
|
|
|
|
* Copyright (C) 2006 Johannes Schindelin
|
|
|
|
*/
|
|
|
|
#include "cache.h"
|
|
|
|
#include "builtin.h"
|
|
|
|
#include "dir.h"
|
|
|
|
#include "cache-tree.h"
|
|
|
|
#include "path-list.h"
|
2007-10-07 12:19:33 +00:00
|
|
|
#include "parse-options.h"
|
2006-07-26 01:52:35 +00:00
|
|
|
|
2007-10-07 12:19:33 +00:00
|
|
|
static const char * const builtin_mv_usage[] = {
|
|
|
|
"git-mv [options] <source>... <destination>",
|
|
|
|
NULL
|
|
|
|
};
|
2006-07-26 01:52:35 +00:00
|
|
|
|
|
|
|
static const char **copy_pathspec(const char *prefix, const char **pathspec,
|
|
|
|
int count, int base_name)
|
|
|
|
{
|
2006-08-16 08:44:02 +00:00
|
|
|
int i;
|
2006-07-26 01:52:35 +00:00
|
|
|
const char **result = xmalloc((count + 1) * sizeof(const char *));
|
|
|
|
memcpy(result, pathspec, count * sizeof(const char *));
|
|
|
|
result[count] = NULL;
|
2006-08-16 08:44:02 +00:00
|
|
|
for (i = 0; i < count; i++) {
|
|
|
|
int length = strlen(result[i]);
|
|
|
|
if (length > 0 && result[i][length - 1] == '/') {
|
2007-09-15 22:32:36 +00:00
|
|
|
result[i] = xmemdupz(result[i], length - 1);
|
2006-08-16 08:44:02 +00:00
|
|
|
}
|
|
|
|
if (base_name) {
|
2006-07-26 01:52:35 +00:00
|
|
|
const char *last_slash = strrchr(result[i], '/');
|
|
|
|
if (last_slash)
|
|
|
|
result[i] = last_slash + 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return get_pathspec(prefix, result);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void show_list(const char *label, struct path_list *list)
|
|
|
|
{
|
|
|
|
if (list->nr > 0) {
|
|
|
|
int i;
|
|
|
|
printf("%s", label);
|
|
|
|
for (i = 0; i < list->nr; i++)
|
|
|
|
printf("%s%s", i > 0 ? ", " : "", list->items[i].path);
|
|
|
|
putchar('\n');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-07-26 17:47:54 +00:00
|
|
|
static const char *add_slash(const char *path)
|
|
|
|
{
|
|
|
|
int len = strlen(path);
|
|
|
|
if (path[len - 1] != '/') {
|
|
|
|
char *with_slash = xmalloc(len + 2);
|
|
|
|
memcpy(with_slash, path, len);
|
2006-08-08 19:21:33 +00:00
|
|
|
with_slash[len++] = '/';
|
|
|
|
with_slash[len] = 0;
|
2006-07-26 17:47:54 +00:00
|
|
|
return with_slash;
|
|
|
|
}
|
|
|
|
return path;
|
|
|
|
}
|
|
|
|
|
2006-07-26 01:52:35 +00:00
|
|
|
static struct lock_file lock_file;
|
|
|
|
|
2006-07-29 08:54:54 +00:00
|
|
|
int cmd_mv(int argc, const char **argv, const char *prefix)
|
2006-07-26 01:52:35 +00:00
|
|
|
{
|
2007-10-07 12:19:33 +00:00
|
|
|
int i, newfd;
|
2006-07-26 01:52:35 +00:00
|
|
|
int verbose = 0, show_only = 0, force = 0, ignore_errors = 0;
|
2007-10-07 12:19:33 +00:00
|
|
|
struct option builtin_mv_options[] = {
|
|
|
|
OPT__DRY_RUN(&show_only),
|
|
|
|
OPT_BOOLEAN('f', NULL, &force, "force move/rename even if target exists"),
|
|
|
|
OPT_BOOLEAN('k', NULL, &ignore_errors, "skip move/rename errors"),
|
|
|
|
OPT_END(),
|
|
|
|
};
|
2006-07-26 01:52:35 +00:00
|
|
|
const char **source, **destination, **dest_path;
|
2006-07-26 17:47:54 +00:00
|
|
|
enum update_mode { BOTH = 0, WORKING_DIRECTORY, INDEX } *modes;
|
2006-07-26 01:52:35 +00:00
|
|
|
struct stat st;
|
|
|
|
struct path_list overwritten = {NULL, 0, 0, 0};
|
|
|
|
struct path_list src_for_dst = {NULL, 0, 0, 0};
|
|
|
|
struct path_list added = {NULL, 0, 0, 0};
|
|
|
|
struct path_list deleted = {NULL, 0, 0, 0};
|
|
|
|
struct path_list changed = {NULL, 0, 0, 0};
|
|
|
|
|
|
|
|
git_config(git_default_config);
|
|
|
|
|
_GIT_INDEX_OUTPUT: allow plumbing to output to an alternative index file.
When defined, this allows plumbing commands that update the
index (add, apply, checkout-index, merge-recursive, mv,
read-tree, rm, update-index, and write-tree) to write their
resulting index to an alternative index file while holding a
lock to the original index file. With this, git-commit that
jumps the index does not have to make an extra copy of the index
file, and more importantly, it can do the update while holding
the lock on the index.
However, I think the interface to let an environment variable
specify the output is a mistake, as shown in the documentation.
If a curious user has the environment variable set to something
other than the file GIT_INDEX_FILE points at, almost everything
will break. This should instead be a command line parameter to
tell these plumbing commands to write the result in the named
file, to prevent stupid mistakes.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-04-01 06:09:02 +00:00
|
|
|
newfd = hold_locked_index(&lock_file, 1);
|
2006-07-26 01:52:35 +00:00
|
|
|
if (read_cache() < 0)
|
|
|
|
die("index file corrupt");
|
|
|
|
|
2007-10-07 12:19:33 +00:00
|
|
|
argc = parse_options(argc, argv, builtin_mv_options, builtin_mv_usage, 0);
|
|
|
|
if (--argc < 1)
|
|
|
|
usage_with_options(builtin_mv_usage, builtin_mv_options);
|
2006-07-26 01:52:35 +00:00
|
|
|
|
2007-10-07 12:19:33 +00:00
|
|
|
source = copy_pathspec(prefix, argv, argc, 0);
|
|
|
|
modes = xcalloc(argc, sizeof(enum update_mode));
|
|
|
|
dest_path = copy_pathspec(prefix, argv + argc, 1, 0);
|
2006-07-26 01:52:35 +00:00
|
|
|
|
2006-08-18 10:42:39 +00:00
|
|
|
if (dest_path[0][0] == '\0')
|
|
|
|
/* special case: "." was normalized to "" */
|
2007-10-07 12:19:33 +00:00
|
|
|
destination = copy_pathspec(dest_path[0], argv, argc, 1);
|
2006-08-18 10:42:39 +00:00
|
|
|
else if (!lstat(dest_path[0], &st) &&
|
2006-07-26 17:47:54 +00:00
|
|
|
S_ISDIR(st.st_mode)) {
|
|
|
|
dest_path[0] = add_slash(dest_path[0]);
|
2007-10-07 12:19:33 +00:00
|
|
|
destination = copy_pathspec(dest_path[0], argv, argc, 1);
|
2006-07-26 17:47:54 +00:00
|
|
|
} else {
|
2007-10-07 12:19:33 +00:00
|
|
|
if (argc != 1)
|
|
|
|
usage_with_options(builtin_mv_usage, builtin_mv_options);
|
2006-07-26 01:52:35 +00:00
|
|
|
destination = dest_path;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Checking */
|
2007-10-07 12:19:33 +00:00
|
|
|
for (i = 0; i < argc; i++) {
|
2006-08-19 14:52:21 +00:00
|
|
|
const char *src = source[i], *dst = destination[i];
|
|
|
|
int length, src_is_dir;
|
2006-07-26 01:52:35 +00:00
|
|
|
const char *bad = NULL;
|
|
|
|
|
|
|
|
if (show_only)
|
2006-08-19 14:52:21 +00:00
|
|
|
printf("Checking rename of '%s' to '%s'\n", src, dst);
|
2006-07-26 01:52:35 +00:00
|
|
|
|
2006-08-19 14:52:21 +00:00
|
|
|
length = strlen(src);
|
|
|
|
if (lstat(src, &st) < 0)
|
2006-07-26 01:52:35 +00:00
|
|
|
bad = "bad source";
|
2006-08-19 14:52:21 +00:00
|
|
|
else if (!strncmp(src, dst, length) &&
|
|
|
|
(dst[length] == 0 || dst[length] == '/')) {
|
2006-08-16 08:44:02 +00:00
|
|
|
bad = "can not move directory into itself";
|
2006-08-19 14:52:21 +00:00
|
|
|
} else if ((src_is_dir = S_ISDIR(st.st_mode))
|
|
|
|
&& lstat(dst, &st) == 0)
|
|
|
|
bad = "cannot move directory over file";
|
|
|
|
else if (src_is_dir) {
|
2006-12-03 19:42:47 +00:00
|
|
|
const char *src_w_slash = add_slash(src);
|
|
|
|
int len_w_slash = length + 1;
|
2006-08-19 14:52:21 +00:00
|
|
|
int first, last;
|
2006-07-26 17:47:54 +00:00
|
|
|
|
|
|
|
modes[i] = WORKING_DIRECTORY;
|
|
|
|
|
2006-12-03 19:42:47 +00:00
|
|
|
first = cache_name_pos(src_w_slash, len_w_slash);
|
2006-07-26 17:47:54 +00:00
|
|
|
if (first >= 0)
|
2006-12-03 19:42:47 +00:00
|
|
|
die ("Huh? %.*s is in index?",
|
|
|
|
len_w_slash, src_w_slash);
|
2006-07-26 17:47:54 +00:00
|
|
|
|
|
|
|
first = -1 - first;
|
|
|
|
for (last = first; last < active_nr; last++) {
|
|
|
|
const char *path = active_cache[last]->name;
|
2006-12-03 19:42:47 +00:00
|
|
|
if (strncmp(path, src_w_slash, len_w_slash))
|
2006-07-26 17:47:54 +00:00
|
|
|
break;
|
|
|
|
}
|
2006-12-03 19:42:47 +00:00
|
|
|
free((char *)src_w_slash);
|
2006-07-26 17:47:54 +00:00
|
|
|
|
|
|
|
if (last - first < 1)
|
|
|
|
bad = "source directory is empty";
|
2006-08-19 14:52:21 +00:00
|
|
|
else {
|
|
|
|
int j, dst_len;
|
2006-07-26 17:47:54 +00:00
|
|
|
|
|
|
|
if (last - first > 0) {
|
2006-08-26 14:16:18 +00:00
|
|
|
source = xrealloc(source,
|
2007-10-07 12:19:33 +00:00
|
|
|
(argc + last - first)
|
2006-07-26 17:47:54 +00:00
|
|
|
* sizeof(char *));
|
2006-08-26 14:16:18 +00:00
|
|
|
destination = xrealloc(destination,
|
2007-10-07 12:19:33 +00:00
|
|
|
(argc + last - first)
|
2006-07-26 17:47:54 +00:00
|
|
|
* sizeof(char *));
|
2006-08-26 14:16:18 +00:00
|
|
|
modes = xrealloc(modes,
|
2007-10-07 12:19:33 +00:00
|
|
|
(argc + last - first)
|
2006-07-26 17:47:54 +00:00
|
|
|
* sizeof(enum update_mode));
|
|
|
|
}
|
|
|
|
|
2006-08-19 14:52:21 +00:00
|
|
|
dst = add_slash(dst);
|
|
|
|
dst_len = strlen(dst) - 1;
|
2006-07-26 17:47:54 +00:00
|
|
|
|
|
|
|
for (j = 0; j < last - first; j++) {
|
|
|
|
const char *path =
|
|
|
|
active_cache[first + j]->name;
|
2007-10-07 12:19:33 +00:00
|
|
|
source[argc + j] = path;
|
|
|
|
destination[argc + j] =
|
2006-08-19 14:52:21 +00:00
|
|
|
prefix_path(dst, dst_len,
|
|
|
|
path + length);
|
2007-10-07 12:19:33 +00:00
|
|
|
modes[argc + j] = INDEX;
|
2006-07-26 17:47:54 +00:00
|
|
|
}
|
2007-10-07 12:19:33 +00:00
|
|
|
argc += last - first;
|
2006-07-26 17:47:54 +00:00
|
|
|
}
|
2006-08-19 14:52:21 +00:00
|
|
|
} else if (lstat(dst, &st) == 0) {
|
2006-07-26 01:52:35 +00:00
|
|
|
bad = "destination exists";
|
|
|
|
if (force) {
|
|
|
|
/*
|
|
|
|
* only files can overwrite each other:
|
|
|
|
* check both source and destination
|
|
|
|
*/
|
|
|
|
if (S_ISREG(st.st_mode)) {
|
|
|
|
fprintf(stderr, "Warning: %s;"
|
|
|
|
" will overwrite!\n",
|
|
|
|
bad);
|
|
|
|
bad = NULL;
|
2006-08-19 14:52:21 +00:00
|
|
|
path_list_insert(dst, &overwritten);
|
2006-07-26 01:52:35 +00:00
|
|
|
} else
|
|
|
|
bad = "Cannot overwrite";
|
|
|
|
}
|
2006-08-19 14:52:21 +00:00
|
|
|
} else if (cache_name_pos(src, length) < 0)
|
2006-07-26 01:52:35 +00:00
|
|
|
bad = "not under version control";
|
2006-08-19 14:52:21 +00:00
|
|
|
else if (path_list_has_path(&src_for_dst, dst))
|
|
|
|
bad = "multiple sources for the same target";
|
|
|
|
else
|
|
|
|
path_list_insert(dst, &src_for_dst);
|
2006-07-26 01:52:35 +00:00
|
|
|
|
|
|
|
if (bad) {
|
|
|
|
if (ignore_errors) {
|
2007-10-07 12:19:33 +00:00
|
|
|
if (--argc > 0) {
|
2006-07-26 01:52:35 +00:00
|
|
|
memmove(source + i, source + i + 1,
|
2007-10-07 12:19:33 +00:00
|
|
|
(argc - i) * sizeof(char *));
|
2006-07-26 01:52:35 +00:00
|
|
|
memmove(destination + i,
|
|
|
|
destination + i + 1,
|
2007-10-07 12:19:33 +00:00
|
|
|
(argc - i) * sizeof(char *));
|
2006-07-26 01:52:35 +00:00
|
|
|
}
|
|
|
|
} else
|
2006-07-26 17:47:54 +00:00
|
|
|
die ("%s, source=%s, destination=%s",
|
2006-08-19 14:52:21 +00:00
|
|
|
bad, src, dst);
|
2006-07-26 01:52:35 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-10-07 12:19:33 +00:00
|
|
|
for (i = 0; i < argc; i++) {
|
2006-08-19 14:52:21 +00:00
|
|
|
const char *src = source[i], *dst = destination[i];
|
|
|
|
enum update_mode mode = modes[i];
|
2006-07-26 01:52:35 +00:00
|
|
|
if (show_only || verbose)
|
2006-08-19 14:52:21 +00:00
|
|
|
printf("Renaming %s to %s\n", src, dst);
|
|
|
|
if (!show_only && mode != INDEX &&
|
|
|
|
rename(src, dst) < 0 && !ignore_errors)
|
|
|
|
die ("renaming %s failed: %s", src, strerror(errno));
|
|
|
|
|
|
|
|
if (mode == WORKING_DIRECTORY)
|
2006-07-26 17:47:54 +00:00
|
|
|
continue;
|
|
|
|
|
2006-08-19 14:52:21 +00:00
|
|
|
if (cache_name_pos(src, strlen(src)) >= 0) {
|
|
|
|
path_list_insert(src, &deleted);
|
2006-07-26 01:52:35 +00:00
|
|
|
|
|
|
|
/* destination can be a directory with 1 file inside */
|
2006-08-19 14:52:21 +00:00
|
|
|
if (path_list_has_path(&overwritten, dst))
|
|
|
|
path_list_insert(dst, &changed);
|
2006-07-26 01:52:35 +00:00
|
|
|
else
|
2006-08-19 14:52:21 +00:00
|
|
|
path_list_insert(dst, &added);
|
2006-07-26 01:52:35 +00:00
|
|
|
} else
|
2006-08-19 14:52:21 +00:00
|
|
|
path_list_insert(dst, &added);
|
2006-07-26 01:52:35 +00:00
|
|
|
}
|
|
|
|
|
2007-10-07 12:19:33 +00:00
|
|
|
if (show_only) {
|
2006-07-26 01:52:35 +00:00
|
|
|
show_list("Changed : ", &changed);
|
|
|
|
show_list("Adding : ", &added);
|
|
|
|
show_list("Deleting : ", &deleted);
|
|
|
|
} else {
|
|
|
|
for (i = 0; i < changed.nr; i++) {
|
|
|
|
const char *path = changed.items[i].path;
|
2006-08-23 10:39:13 +00:00
|
|
|
int j = cache_name_pos(path, strlen(path));
|
|
|
|
struct cache_entry *ce = active_cache[j];
|
2006-07-26 01:52:35 +00:00
|
|
|
|
2006-08-23 10:39:13 +00:00
|
|
|
if (j < 0)
|
2006-07-26 01:52:35 +00:00
|
|
|
die ("Huh? Cache entry for %s unknown?", path);
|
|
|
|
refresh_cache_entry(ce, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < added.nr; i++) {
|
|
|
|
const char *path = added.items[i].path;
|
2007-04-02 05:14:40 +00:00
|
|
|
add_file_to_cache(path, verbose);
|
2006-07-26 01:52:35 +00:00
|
|
|
}
|
|
|
|
|
2007-09-14 03:33:11 +00:00
|
|
|
for (i = 0; i < deleted.nr; i++)
|
|
|
|
remove_file_from_cache(deleted.items[i].path);
|
2006-07-26 01:52:35 +00:00
|
|
|
|
|
|
|
if (active_cache_changed) {
|
|
|
|
if (write_cache(newfd, active_cache, active_nr) ||
|
_GIT_INDEX_OUTPUT: allow plumbing to output to an alternative index file.
When defined, this allows plumbing commands that update the
index (add, apply, checkout-index, merge-recursive, mv,
read-tree, rm, update-index, and write-tree) to write their
resulting index to an alternative index file while holding a
lock to the original index file. With this, git-commit that
jumps the index does not have to make an extra copy of the index
file, and more importantly, it can do the update while holding
the lock on the index.
However, I think the interface to let an environment variable
specify the output is a mistake, as shown in the documentation.
If a curious user has the environment variable set to something
other than the file GIT_INDEX_FILE points at, almost everything
will break. This should instead be a command line parameter to
tell these plumbing commands to write the result in the named
file, to prevent stupid mistakes.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-04-01 06:09:02 +00:00
|
|
|
commit_locked_index(&lock_file))
|
2006-07-26 01:52:35 +00:00
|
|
|
die("Unable to write new index file");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|