git-check-attr: Normalize paths
[git] / builtin / check-attr.c
1 #include "builtin.h"
2 #include "cache.h"
3 #include "attr.h"
4 #include "quote.h"
5 #include "parse-options.h"
6
7 static int all_attrs;
8 static int stdin_paths;
9 static const char * const check_attr_usage[] = {
10 "git check-attr [-a | --all | attr...] [--] pathname...",
11 "git check-attr --stdin [-a | --all | attr...] < <list-of-paths>",
12 NULL
13 };
14
15 static int null_term_line;
16
17 static const struct option check_attr_options[] = {
18         OPT_BOOLEAN('a', "all", &all_attrs, "report all attributes set on file"),
19         OPT_BOOLEAN(0 , "stdin", &stdin_paths, "read file names from stdin"),
20         OPT_BOOLEAN('z', NULL, &null_term_line,
21                 "input paths are terminated by a null character"),
22         OPT_END()
23 };
24
25 static void output_attr(int cnt, struct git_attr_check *check,
26         const char *file)
27 {
28         int j;
29         for (j = 0; j < cnt; j++) {
30                 const char *value = check[j].value;
31
32                 if (ATTR_TRUE(value))
33                         value = "set";
34                 else if (ATTR_FALSE(value))
35                         value = "unset";
36                 else if (ATTR_UNSET(value))
37                         value = "unspecified";
38
39                 quote_c_style(file, NULL, stdout, 0);
40                 printf(": %s: %s\n", git_attr_name(check[j].attr), value);
41         }
42 }
43
44 static void check_attr(const char *prefix, int cnt,
45         struct git_attr_check *check, const char *file)
46 {
47         char *full_path =
48                 prefix_path(prefix, prefix ? strlen(prefix) : 0, file);
49         if (check != NULL) {
50                 if (git_check_attr(full_path, cnt, check))
51                         die("git_check_attr died");
52                 output_attr(cnt, check, file);
53         } else {
54                 if (git_all_attrs(full_path, &cnt, &check))
55                         die("git_all_attrs died");
56                 output_attr(cnt, check, file);
57                 free(check);
58         }
59         free(full_path);
60 }
61
62 static void check_attr_stdin_paths(const char *prefix, int cnt,
63         struct git_attr_check *check)
64 {
65         struct strbuf buf, nbuf;
66         int line_termination = null_term_line ? 0 : '\n';
67
68         strbuf_init(&buf, 0);
69         strbuf_init(&nbuf, 0);
70         while (strbuf_getline(&buf, stdin, line_termination) != EOF) {
71                 if (line_termination && buf.buf[0] == '"') {
72                         strbuf_reset(&nbuf);
73                         if (unquote_c_style(&nbuf, buf.buf, NULL))
74                                 die("line is badly quoted");
75                         strbuf_swap(&buf, &nbuf);
76                 }
77                 check_attr(prefix, cnt, check, buf.buf);
78                 maybe_flush_or_die(stdout, "attribute to stdout");
79         }
80         strbuf_release(&buf);
81         strbuf_release(&nbuf);
82 }
83
84 static NORETURN void error_with_usage(const char *msg)
85 {
86         error("%s", msg);
87         usage_with_options(check_attr_usage, check_attr_options);
88 }
89
90 int cmd_check_attr(int argc, const char **argv, const char *prefix)
91 {
92         struct git_attr_check *check;
93         int cnt, i, doubledash, filei;
94
95         argc = parse_options(argc, argv, prefix, check_attr_options,
96                              check_attr_usage, PARSE_OPT_KEEP_DASHDASH);
97
98         if (read_cache() < 0) {
99                 die("invalid cache");
100         }
101
102         doubledash = -1;
103         for (i = 0; doubledash < 0 && i < argc; i++) {
104                 if (!strcmp(argv[i], "--"))
105                         doubledash = i;
106         }
107
108         /* Process --all and/or attribute arguments: */
109         if (all_attrs) {
110                 if (doubledash >= 1)
111                         error_with_usage("Attributes and --all both specified");
112
113                 cnt = 0;
114                 filei = doubledash + 1;
115         } else if (doubledash == 0) {
116                 error_with_usage("No attribute specified");
117         } else if (doubledash < 0) {
118                 if (!argc)
119                         error_with_usage("No attribute specified");
120
121                 if (stdin_paths) {
122                         /* Treat all arguments as attribute names. */
123                         cnt = argc;
124                         filei = argc;
125                 } else {
126                         /* Treat exactly one argument as an attribute name. */
127                         cnt = 1;
128                         filei = 1;
129                 }
130         } else {
131                 cnt = doubledash;
132                 filei = doubledash + 1;
133         }
134
135         /* Check file argument(s): */
136         if (stdin_paths) {
137                 if (filei < argc)
138                         error_with_usage("Can't specify files with --stdin");
139         } else {
140                 if (filei >= argc)
141                         error_with_usage("No file specified");
142         }
143
144         if (all_attrs) {
145                 check = NULL;
146         } else {
147                 check = xcalloc(cnt, sizeof(*check));
148                 for (i = 0; i < cnt; i++) {
149                         const char *name;
150                         struct git_attr *a;
151                         name = argv[i];
152                         a = git_attr(name);
153                         if (!a)
154                                 return error("%s: not a valid attribute name",
155                                         name);
156                         check[i].attr = a;
157                 }
158         }
159
160         if (stdin_paths)
161                 check_attr_stdin_paths(prefix, cnt, check);
162         else {
163                 for (i = filei; i < argc; i++)
164                         check_attr(prefix, cnt, check, argv[i]);
165                 maybe_flush_or_die(stdout, "attribute to stdout");
166         }
167         return 0;
168 }