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;
|
|
|
|
}
|
|
|
|
}
|
2008-03-07 07:29:40 +00:00
|
|
|
return get_pathspec(prefix, result);
|
2006-07-26 01:52:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
setup: sanitize absolute and funny paths in get_pathspec()
The prefix_path() function called from get_pathspec() is
responsible for translating list of user-supplied pathspecs to
list of pathspecs that is relative to the root of the work
tree. When working inside a subdirectory, the user-supplied
pathspecs are taken to be relative to the current subdirectory.
Among special path components in pathspecs, we used to accept
and interpret only "." ("the directory", meaning a no-op) and
".." ("up one level") at the beginning. Everything else was
passed through as-is.
For example, if you are in Documentation/ directory of the
project, you can name Documentation/howto/maintain-git.txt as:
howto/maintain-git.txt
../Documentation/howto/maitain-git.txt
../././Documentation/howto/maitain-git.txt
but not as:
howto/./maintain-git.txt
$(pwd)/howto/maintain-git.txt
This patch updates prefix_path() in several ways:
- If the pathspec is not absolute, prefix (i.e. the current
subdirectory relative to the root of the work tree, with
terminating slash, if not empty) and the pathspec is
concatenated first and used in the next step. Otherwise,
that absolute pathspec is used in the next step.
- Then special path components "." (no-op) and ".." (up one
level) are interpreted to simplify the path. It is an error
to have too many ".." to cause the intermediate result to
step outside of the input to this step.
- If the original pathspec was not absolute, the result from
the previous step is the resulting "sanitized" pathspec.
Otherwise, the result from the previous step is still
absolute, and it is an error if it does not begin with the
directory that corresponds to the root of the work tree. The
directory is stripped away from the result and is returned.
- In any case, the resulting pathspec in the array
get_pathspec() returns omit the ones that caused errors.
With this patch, the last two examples also behave as expected.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-01-29 06:44:27 +00:00
|
|
|
dst_len = strlen(dst);
|
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,
|
setup: sanitize absolute and funny paths in get_pathspec()
The prefix_path() function called from get_pathspec() is
responsible for translating list of user-supplied pathspecs to
list of pathspecs that is relative to the root of the work
tree. When working inside a subdirectory, the user-supplied
pathspecs are taken to be relative to the current subdirectory.
Among special path components in pathspecs, we used to accept
and interpret only "." ("the directory", meaning a no-op) and
".." ("up one level") at the beginning. Everything else was
passed through as-is.
For example, if you are in Documentation/ directory of the
project, you can name Documentation/howto/maintain-git.txt as:
howto/maintain-git.txt
../Documentation/howto/maitain-git.txt
../././Documentation/howto/maitain-git.txt
but not as:
howto/./maintain-git.txt
$(pwd)/howto/maintain-git.txt
This patch updates prefix_path() in several ways:
- If the pathspec is not absolute, prefix (i.e. the current
subdirectory relative to the root of the work tree, with
terminating slash, if not empty) and the pathspec is
concatenated first and used in the next step. Otherwise,
that absolute pathspec is used in the next step.
- Then special path components "." (no-op) and ".." (up one
level) are interpreted to simplify the path. It is an error
to have too many ".." to cause the intermediate result to
step outside of the input to this step.
- If the original pathspec was not absolute, the result from
the previous step is the resulting "sanitized" pathspec.
Otherwise, the result from the previous step is still
absolute, and it is an error if it does not begin with the
directory that corresponds to the root of the work tree. The
directory is stripped away from the result and is returned.
- In any case, the resulting pathspec in the array
get_pathspec() returns omit the ones that caused errors.
With this patch, the last two examples also behave as expected.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-01-29 06:44:27 +00:00
|
|
|
path + length + 1);
|
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;
|
2008-05-21 19:04:34 +00:00
|
|
|
add_file_to_cache(path, verbose ? ADD_CACHE_VERBOSE : 0);
|
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;
|
|
|
|
}
|