test-path-utils.c

   1 #include "cache.h"
   2 #include "string-list.h"
   3
   4 /*
   5  * A "string_list_each_func_t" function that normalizes an entry from
   6  * GIT_CEILING_DIRECTORIES.  If the path is unusable for some reason,
   7  * die with an explanation.
   8  */
   9 static int normalize_ceiling_entry(struct string_list_item *item, void *unused)
  10 {
  11         const char *ceil = item->string;
  12         int len = strlen(ceil);
  13         char buf[PATH_MAX+1];
  14
  15         if (len == 0)
  16                 die("Empty path is not supported");
  17         if (len > PATH_MAX)
  18                 die("Path \"%s\" is too long", ceil);
  19         if (!is_absolute_path(ceil))
  20                 die("Path \"%s\" is not absolute", ceil);
  21         if (normalize_path_copy(buf, ceil) < 0)
  22                 die("Path \"%s\" could not be normalized", ceil);
  23         len = strlen(buf);
  24         if (len > 1 && buf[len-1] == '/')
  25                 die("Normalized path \"%s\" ended with slash", buf);
  26         free(item->string);
  27         item->string = xstrdup(buf);
  28         return 1;
  29 }
  30
  31 static void normalize_argv_string(const char **var, const char *input)
  32 {
  33         if (!strcmp(input, "<null>"))
  34                 *var = NULL;
  35         else if (!strcmp(input, "<empty>"))
  36                 *var = "";
  37         else
  38                 *var = input;
  39
  40         if (*var && (**var == '<' || **var == '('))
  41                 die("Bad value: %s\n", input);
  42 }
  43
  44 int main(int argc, char **argv)
  45 {
  46         if (argc == 3 && !strcmp(argv[1], "normalize_path_copy")) {
  47                 char *buf = xmalloc(PATH_MAX + 1);
  48                 int rv = normalize_path_copy(buf, argv[2]);
  49                 if (rv)
  50                         buf = "++failed++";
  51                 puts(buf);
  52                 return 0;
  53         }
  54
  55         if (argc >= 2 && !strcmp(argv[1], "real_path")) {
  56                 while (argc > 2) {
  57                         puts(real_path(argv[2]));
  58                         argc--;
  59                         argv++;
  60                 }
  61                 return 0;
  62         }
  63
  64         if (argc >= 2 && !strcmp(argv[1], "absolute_path")) {
  65                 while (argc > 2) {
  66                         puts(absolute_path(argv[2]));
  67                         argc--;
  68                         argv++;
  69                 }
  70                 return 0;
  71         }
  72
  73         if (argc == 4 && !strcmp(argv[1], "longest_ancestor_length")) {
  74                 int len;
  75                 struct string_list ceiling_dirs = STRING_LIST_INIT_DUP;
  76                 char *path = xstrdup(argv[2]);
  77
  78                 /*
  79                  * We have to normalize the arguments because under
  80                  * Windows, bash mangles arguments that look like
  81                  * absolute POSIX paths or colon-separate lists of
  82                  * absolute POSIX paths into DOS paths (e.g.,
  83                  * "/foo:/foo/bar" might be converted to
  84                  * "D:\Src\msysgit\foo;D:\Src\msysgit\foo\bar"),
  85                  * whereas longest_ancestor_length() requires paths
  86                  * that use forward slashes.
  87                  */
  88                 if (normalize_path_copy(path, path))
  89                         die("Path \"%s\" could not be normalized", argv[2]);
  90                 string_list_split(&ceiling_dirs, argv[3], PATH_SEP, -1);
  91                 filter_string_list(&ceiling_dirs, 0,
  92                                    normalize_ceiling_entry, NULL);
  93                 len = longest_ancestor_length(path, &ceiling_dirs);
  94                 string_list_clear(&ceiling_dirs, 0);
  95                 free(path);
  96                 printf("%d\n", len);
  97                 return 0;
  98         }
  99
 100         if (argc >= 4 && !strcmp(argv[1], "prefix_path")) {
 101                 char *prefix = argv[2];
 102                 int prefix_len = strlen(prefix);
 103                 int nongit_ok;
 104                 setup_git_directory_gently(&nongit_ok);
 105                 while (argc > 3) {
 106                         puts(prefix_path(prefix, prefix_len, argv[3]));
 107                         argc--;
 108                         argv++;
 109                 }
 110                 return 0;
 111         }
 112
 113         if (argc == 4 && !strcmp(argv[1], "strip_path_suffix")) {
 114                 char *prefix = strip_path_suffix(argv[2], argv[3]);
 115                 printf("%s\n", prefix ? prefix : "(null)");
 116                 return 0;
 117         }
 118
 119         if (argc == 3 && !strcmp(argv[1], "print_path")) {
 120                 puts(argv[2]);
 121                 return 0;
 122         }
 123
 124         if (argc == 4 && !strcmp(argv[1], "relative_path")) {
 125                 struct strbuf sb = STRBUF_INIT;
 126                 const char *in, *prefix, *rel;
 127                 normalize_argv_string(&in, argv[2]);
 128                 normalize_argv_string(&prefix, argv[3]);
 129                 rel = relative_path(in, prefix, &sb);
 130                 if (!rel)
 131                         puts("(null)");
 132                 else
 133                         puts(strlen(rel) > 0 ? rel : "(empty)");
 134                 strbuf_release(&sb);
 135                 return 0;
 136         }
 137
 138         fprintf(stderr, "%s: unknown function name: %s\n", argv[0],
 139                 argv[1] ? argv[1] : "(there was none)");
 140         return 1;
 141 }