@matheusbsbs / matheus-bagliano / commits / aa4ed402c9
Fork 0

Add 'filter' attribute and external filter driver definition.

The interface is similar to the custom low-level merge drivers. First you configure your filter driver by defining 'filter.<name>.*' variables in the configuration. filter.<name>.clean filter command to run upon checkin filter.<name>.smudge filter command to run upon checkout Then you assign filter attribute to each path, whose name matches the custom filter driver's name. Example: (in .gitattributes) *.c filter=indent (in config) [filter "indent"] clean = indent smudge = cat Signed-off-by: Junio C Hamano <junkio@cox.net>

Junio C Hamano committed Apr 21, 2007 at 03:14 UTC aa4ed402c9721170fde2e9e43c3825562070e65e
3 files changed +282 -3
Documentation/gitattributes.txt
+39
@@ -156,6 +156,45 @@ In the check-out codepath, the blob content is first converted
156 with `crlf`, and then `ident`.
157
158
159 +`filter`
160 +^^^^^^^^
161 +
162 +A `filter` attribute can be set to a string value. This names
163 +filter driver specified in the configuration.
164 +
165 +A filter driver consists of `clean` command and `smudge`
166 +command, either of which can be left unspecified. Upon
167 +checkout, when `smudge` command is specified, the command is fed
168 +the blob object from its standard input, and its standard output
169 +is used to update the worktree file. Similarly, `clean` command
170 +is used to convert the contents of worktree file upon checkin.
171 +
172 +Missing filter driver definition in the config is not an error
173 +but makes the filter a no-op passthru.
174 +
175 +The content filtering is done to massage the content into a
176 +shape that is more convenient for the platform, filesystem, and
177 +the user to use. The keyword here is "more convenient" and not
178 +"turning something unusable into usable". In other words, it is
179 +"hanging yourself because we gave you a long rope" if your
180 +project uses filtering mechanism in such a way that it makes
181 +your project unusable unless the checkout is done with a
182 +specific filter in effect.
183 +
184 +
185 +Interaction between checkin/checkout attributes
186 +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
187 +
188 +In the check-in codepath, the worktree file is first converted
189 +with `filter` driver (if specified and corresponding driver
190 +defined), then the result is processed with `ident` (if
191 +specified), and then finally with `crlf` (again, if specified
192 +and applicable).
193 +
194 +In the check-out codepath, the blob content is first converted
195 +with `crlf`, and then `ident` and fed to `filter`.
196 +
197 +
198 Generating diff text
199 ~~~~~~~~~~~~~~~~~~~~
200
convert.c
+234 -3
@@ -201,17 +201,212 @@ static char *crlf_to_worktree(const char *path, const char *src, unsigned long *
201 return buffer;
202 }
203
204 +static int filter_buffer(const char *path, const char *src,
205 + unsigned long size, const char *cmd)
206 +{
207 + /*
208 + * Spawn cmd and feed the buffer contents through its stdin.
209 + */
210 + struct child_process child_process;
211 + int pipe_feed[2];
212 + int write_err, status;
213 +
214 + memset(&child_process, 0, sizeof(child_process));
215 +
216 + if (pipe(pipe_feed) < 0) {
217 + error("cannot create pipe to run external filter %s", cmd);
218 + return 1;
219 + }
220 +
221 + child_process.pid = fork();
222 + if (child_process.pid < 0) {
223 + error("cannot fork to run external filter %s", cmd);
224 + close(pipe_feed[0]);
225 + close(pipe_feed[1]);
226 + return 1;
227 + }
228 + if (!child_process.pid) {
229 + dup2(pipe_feed[0], 0);
230 + close(pipe_feed[0]);
231 + close(pipe_feed[1]);
232 + execlp("sh", "sh", "-c", cmd, NULL);
233 + return 1;
234 + }
235 + close(pipe_feed[0]);
236 +
237 + write_err = (write_in_full(pipe_feed[1], src, size) < 0);
238 + if (close(pipe_feed[1]))
239 + write_err = 1;
240 + if (write_err)
241 + error("cannot feed the input to external filter %s", cmd);
242 +
243 + status = finish_command(&child_process);
244 + if (status)
245 + error("external filter %s failed %d", cmd, -status);
246 + return (write_err || status);
247 +}
248 +
249 +static char *apply_filter(const char *path, const char *src,
250 + unsigned long *sizep, const char *cmd)
251 +{
252 + /*
253 + * Create a pipeline to have the command filter the buffer's
254 + * contents.
255 + *
256 + * (child --> cmd) --> us
257 + */
258 + const int SLOP = 4096;
259 + int pipe_feed[2];
260 + int status;
261 + char *dst;
262 + unsigned long dstsize, dstalloc;
263 + struct child_process child_process;
264 +
265 + if (!cmd)
266 + return NULL;
267 +
268 + memset(&child_process, 0, sizeof(child_process));
269 +
270 + if (pipe(pipe_feed) < 0) {
271 + error("cannot create pipe to run external filter %s", cmd);
272 + return NULL;
273 + }
274 +
275 + fflush(NULL);
276 + child_process.pid = fork();
277 + if (child_process.pid < 0) {
278 + error("cannot fork to run external filter %s", cmd);
279 + close(pipe_feed[0]);
280 + close(pipe_feed[1]);
281 + return NULL;
282 + }
283 + if (!child_process.pid) {
284 + dup2(pipe_feed[1], 1);
285 + close(pipe_feed[0]);
286 + close(pipe_feed[1]);
287 + exit(filter_buffer(path, src, *sizep, cmd));
288 + }
289 + close(pipe_feed[1]);
290 +
291 + dstalloc = *sizep;
292 + dst = xmalloc(dstalloc);
293 + dstsize = 0;
294 +
295 + while (1) {
296 + ssize_t numread = xread(pipe_feed[0], dst + dstsize,
297 + dstalloc - dstsize);
298 +
299 + if (numread <= 0) {
300 + if (!numread)
301 + break;
302 + error("read from external filter %s failed", cmd);
303 + free(dst);
304 + dst = NULL;
305 + break;
306 + }
307 + dstsize += numread;
308 + if (dstalloc <= dstsize + SLOP) {
309 + dstalloc = dstsize + SLOP;
310 + dst = xrealloc(dst, dstalloc);
311 + }
312 + }
313 + if (close(pipe_feed[0])) {
314 + error("read from external filter %s failed", cmd);
315 + free(dst);
316 + dst = NULL;
317 + }
318 +
319 + status = finish_command(&child_process);
320 + if (status) {
321 + error("external filter %s failed %d", cmd, -status);
322 + free(dst);
323 + dst = NULL;
324 + }
325 +
326 + if (dst)
327 + *sizep = dstsize;
328 + return dst;
329 +}
330 +
331 +static struct convert_driver {
332 + const char *name;
333 + struct convert_driver *next;
334 + char *smudge;
335 + char *clean;
336 +} *user_convert, **user_convert_tail;
337 +
338 +static int read_convert_config(const char *var, const char *value)
339 +{
340 + const char *ep, *name;
341 + int namelen;
342 + struct convert_driver *drv;
343 +
344 + /*
345 + * External conversion drivers are configured using
346 + * "filter.<name>.variable".
347 + */
348 + if (prefixcmp(var, "filter.") || (ep = strrchr(var, '.')) == var + 6)
349 + return 0;
350 + name = var + 7;
351 + namelen = ep - name;
352 + for (drv = user_convert; drv; drv = drv->next)
353 + if (!strncmp(drv->name, name, namelen) && !drv->name[namelen])
354 + break;
355 + if (!drv) {
356 + char *namebuf;
357 + drv = xcalloc(1, sizeof(struct convert_driver));
358 + namebuf = xmalloc(namelen + 1);
359 + memcpy(namebuf, name, namelen);
360 + namebuf[namelen] = 0;
361 + drv->name = namebuf;
362 + drv->next = NULL;
363 + *user_convert_tail = drv;
364 + user_convert_tail = &(drv->next);
365 + }
366 +
367 + ep++;
368 +
369 + /*
370 + * filter.<name>.smudge and filter.<name>.clean specifies
371 + * the command line:
372 + *
373 + * command-line
374 + *
375 + * The command-line will not be interpolated in any way.
376 + */
377 +
378 + if (!strcmp("smudge", ep)) {
379 + if (!value)
380 + return error("%s: lacks value", var);
381 + drv->smudge = strdup(value);
382 + return 0;
383 + }
384 +
385 + if (!strcmp("clean", ep)) {
386 + if (!value)
387 + return error("%s: lacks value", var);
388 + drv->clean = strdup(value);
389 + return 0;
390 + }
391 + return 0;
392 +}
393 +
394 static void setup_convert_check(struct git_attr_check *check)
395 {
396 static struct git_attr *attr_crlf;
397 static struct git_attr *attr_ident;
398 + static struct git_attr *attr_filter;
399
400 if (!attr_crlf) {
401 attr_crlf = git_attr("crlf", 4);
402 attr_ident = git_attr("ident", 5);
403 + attr_filter = git_attr("filter", 6);
404 + user_convert_tail = &user_convert;
405 + git_config(read_convert_config);
406 }
407 check[0].attr = attr_crlf;
408 check[1].attr = attr_ident;
409 + check[2].attr = attr_filter;
410 }
411
412 static int count_ident(const char *cp, unsigned long size)
@@ -367,6 +562,20 @@ static int git_path_check_crlf(const char *path, struct git_attr_check *check)
562 return CRLF_GUESS;
563 }
564
565 +static struct convert_driver *git_path_check_convert(const char *path,
566 + struct git_attr_check *check)
567 +{
568 + const char *value = check->value;
569 + struct convert_driver *drv;
570 +
571 + if (ATTR_TRUE(value) || ATTR_FALSE(value) || ATTR_UNSET(value))
572 + return NULL;
573 + for (drv = user_convert; drv; drv = drv->next)
574 + if (!strcmp(value, drv->name))
575 + return drv;
576 + return NULL;
577 +}
578 +
579 static int git_path_check_ident(const char *path, struct git_attr_check *check)
580 {
581 const char *value = check->value;
@@ -376,18 +585,29 @@ static int git_path_check_ident(const char *path, struct git_attr_check *check)
585
586 char *convert_to_git(const char *path, const char *src, unsigned long *sizep)
587 {
379 - struct git_attr_check check[2];
588 + struct git_attr_check check[3];
589 int crlf = CRLF_GUESS;
590 int ident = 0;
591 + char *filter = NULL;
592 char *buf, *buf2;
593
594 setup_convert_check(check);
595 if (!git_checkattr(path, ARRAY_SIZE(check), check)) {
596 + struct convert_driver *drv;
597 crlf = git_path_check_crlf(path, check + 0);
598 ident = git_path_check_ident(path, check + 1);
599 + drv = git_path_check_convert(path, check + 2);
600 + if (drv && drv->clean)
601 + filter = drv->clean;
602 }
603
390 - buf = crlf_to_git(path, src, sizep, crlf);
604 + buf = apply_filter(path, src, sizep, filter);
605 +
606 + buf2 = crlf_to_git(path, buf ? buf : src, sizep, crlf);
607 + if (buf2) {
608 + free(buf);
609 + buf = buf2;
610 + }
611
612 buf2 = ident_to_git(path, buf ? buf : src, sizep, ident);
613 if (buf2) {
@@ -400,15 +620,20 @@ char *convert_to_git(const char *path, const char *src, unsigned long *sizep)
620
621 char *convert_to_working_tree(const char *path, const char *src, unsigned long *sizep)
622 {
403 - struct git_attr_check check[2];
623 + struct git_attr_check check[3];
624 int crlf = CRLF_GUESS;
625 int ident = 0;
626 + char *filter = NULL;
627 char *buf, *buf2;
628
629 setup_convert_check(check);
630 if (!git_checkattr(path, ARRAY_SIZE(check), check)) {
631 + struct convert_driver *drv;
632 crlf = git_path_check_crlf(path, check + 0);
633 ident = git_path_check_ident(path, check + 1);
634 + drv = git_path_check_convert(path, check + 2);
635 + if (drv && drv->smudge)
636 + filter = drv->smudge;
637 }
638
639 buf = ident_to_worktree(path, src, sizep, ident);
@@ -419,5 +644,11 @@ char *convert_to_working_tree(const char *path, const char *src, unsigned long *
644 buf = buf2;
645 }
646
647 + buf2 = apply_filter(path, buf ? buf : src, sizep, filter);
648 + if (buf2) {
649 + free(buf);
650 + buf = buf2;
651 + }
652 +
653 return buf;
654 }
t/t0021-conversion.sh
+9
@@ -4,8 +4,17 @@ test_description='blob conversion via gitattributes'
4
5 . ./test-lib.sh
6
7 +cat <<\EOF >rot13.sh
8 +tr '[a-zA-Z]' '[n-za-mN-ZA-M]'
9 +EOF
10 +chmod +x rot13.sh
11 +
12 test_expect_success setup '
13 + git config filter.rot13.smudge ./rot13.sh &&
14 + git config filter.rot13.clean ./rot13.sh &&
15 +
16 {
17 + echo "*.t filter=rot13"
18 echo "*.i ident"
19 } >.gitattributes &&
20