[PATCH] Rename and extend read_tree_with_tree_or_commit_sha1
[git/git.git] / checkout-cache.c
1 /*
2 * Check-out files from the "current cache directory"
3 *
4 * Copyright (C) 2005 Linus Torvalds
5 *
6 * Careful: order of argument flags does matter. For example,
7 *
8 * checkout-cache -a -f file.c
9 *
10 * Will first check out all files listed in the cache (but not
11 * overwrite any old ones), and then force-checkout "file.c" a
12 * second time (ie that one _will_ overwrite any old contents
13 * with the same filename).
14 *
15 * Also, just doing "checkout-cache" does nothing. You probably
16 * meant "checkout-cache -a". And if you want to force it, you
17 * want "checkout-cache -f -a".
18 *
19 * Intuitiveness is not the goal here. Repeatability is. The
20 * reason for the "no arguments means no work" thing is that
21 * from scripts you are supposed to be able to do things like
22 *
23 * find . -name '*.h' -print0 | xargs -0 checkout-cache -f --
24 *
25 * which will force all existing *.h files to be replaced with
26 * their cached copies. If an empty command line implied "all",
27 * then this would force-refresh everything in the cache, which
28 * was not the point.
29 *
30 * Oh, and the "--" is just a good idea when you know the rest
31 * will be filenames. Just so that you wouldn't have a filename
32 * of "-a" causing problems (not possible in the above example,
33 * but get used to it in scripting!).
34 */
35 #include "cache.h"
36
37 static int force = 0, quiet = 0, not_new = 0;
38
39 static void create_directories(const char *path)
40 {
41 int len = strlen(path);
42 char *buf = xmalloc(len + 1);
43 const char *slash = path;
44
45 while ((slash = strchr(slash+1, '/')) != NULL) {
46 len = slash - path;
47 memcpy(buf, path, len);
48 buf[len] = 0;
49 mkdir(buf, 0755);
50 }
51 }
52
53 static int create_file(const char *path, unsigned int mode)
54 {
55 int fd;
56
57 mode = (mode & 0100) ? 0777 : 0666;
58 fd = open(path, O_WRONLY | O_TRUNC | O_CREAT, mode);
59 if (fd < 0) {
60 if (errno == ENOENT) {
61 create_directories(path);
62 fd = open(path, O_WRONLY | O_TRUNC | O_CREAT, mode);
63 }
64 }
65 return fd;
66 }
67
68 static int write_entry(struct cache_entry *ce, const char *path)
69 {
70 int fd;
71 void *new;
72 unsigned long size;
73 long wrote;
74 char type[20];
75
76 new = read_sha1_file(ce->sha1, type, &size);
77 if (!new || strcmp(type, "blob")) {
78 return error("checkout-cache: unable to read sha1 file of %s (%s)",
79 path, sha1_to_hex(ce->sha1));
80 }
81 fd = create_file(path, ntohl(ce->ce_mode));
82 if (fd < 0) {
83 free(new);
84 return error("checkout-cache: unable to create %s (%s)",
85 path, strerror(errno));
86 }
87 wrote = write(fd, new, size);
88 close(fd);
89 free(new);
90 if (wrote != size)
91 return error("checkout-cache: unable to write %s", path);
92 return 0;
93 }
94
95 static int checkout_entry(struct cache_entry *ce, const char *base_dir)
96 {
97 struct stat st;
98 static char path[MAXPATHLEN+1];
99 int len = strlen(base_dir);
100
101 memcpy(path, base_dir, len);
102 strcpy(path + len, ce->name);
103
104 if (!stat(path, &st)) {
105 unsigned changed = cache_match_stat(ce, &st);
106 if (!changed)
107 return 0;
108 if (!force) {
109 if (!quiet)
110 fprintf(stderr, "checkout-cache: %s already exists\n", path);
111 return 0;
112 }
113
114 /*
115 * We unlink the old file, to get the new one with the
116 * right permissions (including umask, which is nasty
117 * to emulate by hand - much easier to let the system
118 * just do the right thing)
119 */
120 unlink(path);
121 } else if (not_new)
122 return 0;
123 return write_entry(ce, path);
124 }
125
126 static int checkout_file(const char *name, const char *base_dir)
127 {
128 int pos = cache_name_pos(name, strlen(name));
129 if (pos < 0) {
130 if (!quiet) {
131 pos = -pos - 1;
132 fprintf(stderr,
133 "checkout-cache: %s is %s.\n",
134 name,
135 (pos < active_nr &&
136 !strcmp(active_cache[pos]->name, name)) ?
137 "unmerged" : "not in the cache");
138 }
139 return -1;
140 }
141 return checkout_entry(active_cache[pos], base_dir);
142 }
143
144 static int checkout_all(const char *base_dir)
145 {
146 int i;
147
148 for (i = 0; i < active_nr ; i++) {
149 struct cache_entry *ce = active_cache[i];
150 if (ce_stage(ce))
151 continue;
152 if (checkout_entry(ce, base_dir) < 0)
153 return -1;
154 }
155 return 0;
156 }
157
158 int main(int argc, char **argv)
159 {
160 int i, force_filename = 0;
161 const char *base_dir = "";
162
163 if (read_cache() < 0) {
164 die("invalid cache");
165 }
166
167 for (i = 1; i < argc; i++) {
168 const char *arg = argv[i];
169 if (!force_filename) {
170 if (!strcmp(arg, "-a")) {
171 checkout_all(base_dir);
172 continue;
173 }
174 if (!strcmp(arg, "--")) {
175 force_filename = 1;
176 continue;
177 }
178 if (!strcmp(arg, "-f")) {
179 force = 1;
180 continue;
181 }
182 if (!strcmp(arg, "-q")) {
183 quiet = 1;
184 continue;
185 }
186 if (!strcmp(arg, "-n")) {
187 not_new = 1;
188 continue;
189 }
190 if (!memcmp(arg, "--prefix=", 9)) {
191 base_dir = arg+9;
192 continue;
193 }
194 }
195 checkout_file(arg, base_dir);
196 }
197 return 0;
198 }