Merge branch 'jk/quarantine-received-objects'
[git] / t / helper / test-ref-store.c
1 #include "cache.h"
2 #include "refs.h"
3
4 static const char *notnull(const char *arg, const char *name)
5 {
6         if (!arg)
7                 die("%s required", name);
8         return arg;
9 }
10
11 static unsigned int arg_flags(const char *arg, const char *name)
12 {
13         return atoi(notnull(arg, name));
14 }
15
16 static const char **get_store(const char **argv, struct ref_store **refs)
17 {
18         const char *gitdir;
19
20         if (!argv[0]) {
21                 die("ref store required");
22         } else if (!strcmp(argv[0], "main")) {
23                 *refs = get_main_ref_store();
24         } else if (skip_prefix(argv[0], "submodule:", &gitdir)) {
25                 struct strbuf sb = STRBUF_INIT;
26                 int ret;
27
28                 ret = strbuf_git_path_submodule(&sb, gitdir, "objects/");
29                 if (ret)
30                         die("strbuf_git_path_submodule failed: %d", ret);
31                 add_to_alternates_memory(sb.buf);
32                 strbuf_release(&sb);
33
34                 *refs = get_submodule_ref_store(gitdir);
35         } else
36                 die("unknown backend %s", argv[0]);
37
38         if (!*refs)
39                 die("no ref store");
40
41         /* consume store-specific optional arguments if needed */
42
43         return argv + 1;
44 }
45
46
47 static int cmd_pack_refs(struct ref_store *refs, const char **argv)
48 {
49         unsigned int flags = arg_flags(*argv++, "flags");
50
51         return refs_pack_refs(refs, flags);
52 }
53
54 static int cmd_peel_ref(struct ref_store *refs, const char **argv)
55 {
56         const char *refname = notnull(*argv++, "refname");
57         unsigned char sha1[20];
58         int ret;
59
60         ret = refs_peel_ref(refs, refname, sha1);
61         if (!ret)
62                 puts(sha1_to_hex(sha1));
63         return ret;
64 }
65
66 static int cmd_create_symref(struct ref_store *refs, const char **argv)
67 {
68         const char *refname = notnull(*argv++, "refname");
69         const char *target = notnull(*argv++, "target");
70         const char *logmsg = *argv++;
71
72         return refs_create_symref(refs, refname, target, logmsg);
73 }
74
75 static int cmd_delete_refs(struct ref_store *refs, const char **argv)
76 {
77         unsigned int flags = arg_flags(*argv++, "flags");
78         struct string_list refnames = STRING_LIST_INIT_NODUP;
79
80         while (*argv)
81                 string_list_append(&refnames, *argv++);
82
83         return refs_delete_refs(refs, &refnames, flags);
84 }
85
86 static int cmd_rename_ref(struct ref_store *refs, const char **argv)
87 {
88         const char *oldref = notnull(*argv++, "oldref");
89         const char *newref = notnull(*argv++, "newref");
90         const char *logmsg = *argv++;
91
92         return refs_rename_ref(refs, oldref, newref, logmsg);
93 }
94
95 static int each_ref(const char *refname, const struct object_id *oid,
96                     int flags, void *cb_data)
97 {
98         printf("%s %s 0x%x\n", oid_to_hex(oid), refname, flags);
99         return 0;
100 }
101
102 static int cmd_for_each_ref(struct ref_store *refs, const char **argv)
103 {
104         const char *prefix = notnull(*argv++, "prefix");
105
106         return refs_for_each_ref_in(refs, prefix, each_ref, NULL);
107 }
108
109 static int cmd_resolve_ref(struct ref_store *refs, const char **argv)
110 {
111         unsigned char sha1[20];
112         const char *refname = notnull(*argv++, "refname");
113         int resolve_flags = arg_flags(*argv++, "resolve-flags");
114         int flags;
115         const char *ref;
116
117         ref = refs_resolve_ref_unsafe(refs, refname, resolve_flags,
118                                       sha1, &flags);
119         printf("%s %s 0x%x\n", sha1_to_hex(sha1), ref, flags);
120         return ref ? 0 : 1;
121 }
122
123 static int cmd_verify_ref(struct ref_store *refs, const char **argv)
124 {
125         const char *refname = notnull(*argv++, "refname");
126         struct strbuf err = STRBUF_INIT;
127         int ret;
128
129         ret = refs_verify_refname_available(refs, refname, NULL, NULL, &err);
130         if (err.len)
131                 puts(err.buf);
132         return ret;
133 }
134
135 static int cmd_for_each_reflog(struct ref_store *refs, const char **argv)
136 {
137         return refs_for_each_reflog(refs, each_ref, NULL);
138 }
139
140 static int each_reflog(struct object_id *old_oid, struct object_id *new_oid,
141                        const char *committer, unsigned long timestamp,
142                        int tz, const char *msg, void *cb_data)
143 {
144         printf("%s %s %s %lu %d %s\n",
145                oid_to_hex(old_oid), oid_to_hex(new_oid),
146                committer, timestamp, tz, msg);
147         return 0;
148 }
149
150 static int cmd_for_each_reflog_ent(struct ref_store *refs, const char **argv)
151 {
152         const char *refname = notnull(*argv++, "refname");
153
154         return refs_for_each_reflog_ent(refs, refname, each_reflog, refs);
155 }
156
157 static int cmd_for_each_reflog_ent_reverse(struct ref_store *refs, const char **argv)
158 {
159         const char *refname = notnull(*argv++, "refname");
160
161         return refs_for_each_reflog_ent_reverse(refs, refname, each_reflog, refs);
162 }
163
164 static int cmd_reflog_exists(struct ref_store *refs, const char **argv)
165 {
166         const char *refname = notnull(*argv++, "refname");
167
168         return !refs_reflog_exists(refs, refname);
169 }
170
171 static int cmd_create_reflog(struct ref_store *refs, const char **argv)
172 {
173         const char *refname = notnull(*argv++, "refname");
174         int force_create = arg_flags(*argv++, "force-create");
175         struct strbuf err = STRBUF_INIT;
176         int ret;
177
178         ret = refs_create_reflog(refs, refname, force_create, &err);
179         if (err.len)
180                 puts(err.buf);
181         return ret;
182 }
183
184 static int cmd_delete_reflog(struct ref_store *refs, const char **argv)
185 {
186         const char *refname = notnull(*argv++, "refname");
187
188         return refs_delete_reflog(refs, refname);
189 }
190
191 static int cmd_reflog_expire(struct ref_store *refs, const char **argv)
192 {
193         die("not supported yet");
194 }
195
196 static int cmd_delete_ref(struct ref_store *refs, const char **argv)
197 {
198         const char *msg = notnull(*argv++, "msg");
199         const char *refname = notnull(*argv++, "refname");
200         const char *sha1_buf = notnull(*argv++, "old-sha1");
201         unsigned int flags = arg_flags(*argv++, "flags");
202         unsigned char old_sha1[20];
203
204         if (get_sha1_hex(sha1_buf, old_sha1))
205                 die("not sha-1");
206
207         return refs_delete_ref(refs, msg, refname, old_sha1, flags);
208 }
209
210 static int cmd_update_ref(struct ref_store *refs, const char **argv)
211 {
212         const char *msg = notnull(*argv++, "msg");
213         const char *refname = notnull(*argv++, "refname");
214         const char *new_sha1_buf = notnull(*argv++, "old-sha1");
215         const char *old_sha1_buf = notnull(*argv++, "old-sha1");
216         unsigned int flags = arg_flags(*argv++, "flags");
217         unsigned char old_sha1[20];
218         unsigned char new_sha1[20];
219
220         if (get_sha1_hex(old_sha1_buf, old_sha1) ||
221             get_sha1_hex(new_sha1_buf, new_sha1))
222                 die("not sha-1");
223
224         return refs_update_ref(refs, msg, refname,
225                                new_sha1, old_sha1,
226                                flags, UPDATE_REFS_DIE_ON_ERR);
227 }
228
229 struct command {
230         const char *name;
231         int (*func)(struct ref_store *refs, const char **argv);
232 };
233
234 static struct command commands[] = {
235         { "pack-refs", cmd_pack_refs },
236         { "peel-ref", cmd_peel_ref },
237         { "create-symref", cmd_create_symref },
238         { "delete-refs", cmd_delete_refs },
239         { "rename-ref", cmd_rename_ref },
240         { "for-each-ref", cmd_for_each_ref },
241         { "resolve-ref", cmd_resolve_ref },
242         { "verify-ref", cmd_verify_ref },
243         { "for-each-reflog", cmd_for_each_reflog },
244         { "for-each-reflog-ent", cmd_for_each_reflog_ent },
245         { "for-each-reflog-ent-reverse", cmd_for_each_reflog_ent_reverse },
246         { "reflog-exists", cmd_reflog_exists },
247         { "create-reflog", cmd_create_reflog },
248         { "delete-reflog", cmd_delete_reflog },
249         { "reflog-expire", cmd_reflog_expire },
250         /*
251          * backend transaction functions can't be tested separately
252          */
253         { "delete-ref", cmd_delete_ref },
254         { "update-ref", cmd_update_ref },
255         { NULL, NULL }
256 };
257
258 int cmd_main(int argc, const char **argv)
259 {
260         struct ref_store *refs;
261         const char *func;
262         struct command *cmd;
263
264         setup_git_directory();
265
266         argv = get_store(argv + 1, &refs);
267
268         func = *argv++;
269         if (!func)
270                 die("ref function required");
271         for (cmd = commands; cmd->name; cmd++) {
272                 if (!strcmp(func, cmd->name))
273                         return cmd->func(refs, argv);
274         }
275         die("unknown function %s", func);
276         return 0;
277 }