git.oblomov.eu Git - git/blob - list-objects-filter-options.c

   1 #include "cache.h"
   2 #include "commit.h"
   3 #include "config.h"
   4 #include "revision.h"
   5 #include "argv-array.h"
   6 #include "list-objects.h"
   7 #include "list-objects-filter.h"
   8 #include "list-objects-filter-options.h"
   9 #include "url.h"
  10
  11 static int parse_combine_filter(
  12         struct list_objects_filter_options *filter_options,
  13         const char *arg,
  14         struct strbuf *errbuf);
  15
  16 /*
  17  * Parse value of the argument to the "filter" keyword.
  18  * On the command line this looks like:
  19  *       --filter=<arg>
  20  * and in the pack protocol as:
  21  *       "filter" SP <arg>
  22  *
  23  * The filter keyword will be used by many commands.
  24  * See Documentation/rev-list-options.txt for allowed values for <arg>.
  25  *
  26  * Capture the given arg as the "filter_spec".  This can be forwarded to
  27  * subordinate commands when necessary (although it's better to pass it through
  28  * expand_list_objects_filter_spec() first).  We also "intern" the arg for the
  29  * convenience of the current command.
  30  */
  31 static int gently_parse_list_objects_filter(
  32         struct list_objects_filter_options *filter_options,
  33         const char *arg,
  34         struct strbuf *errbuf)
  35 {
  36         const char *v0;
  37
  38         if (filter_options->choice)
  39                 BUG("filter_options already populated");
  40
  41         if (!strcmp(arg, "blob:none")) {
  42                 filter_options->choice = LOFC_BLOB_NONE;
  43                 return 0;
  44
  45         } else if (skip_prefix(arg, "blob:limit=", &v0)) {
  46                 if (git_parse_ulong(v0, &filter_options->blob_limit_value)) {
  47                         filter_options->choice = LOFC_BLOB_LIMIT;
  48                         return 0;
  49                 }
  50
  51         } else if (skip_prefix(arg, "tree:", &v0)) {
  52                 if (!git_parse_ulong(v0, &filter_options->tree_exclude_depth)) {
  53                         strbuf_addstr(errbuf, _("expected 'tree:<depth>'"));
  54                         return 1;
  55                 }
  56                 filter_options->choice = LOFC_TREE_DEPTH;
  57                 return 0;
  58
  59         } else if (skip_prefix(arg, "sparse:oid=", &v0)) {
  60                 struct object_context oc;
  61                 struct object_id sparse_oid;
  62
  63                 /*
  64                  * Try to parse <oid-expression> into an OID for the current
  65                  * command, but DO NOT complain if we don't have the blob or
  66                  * ref locally.
  67                  */
  68                 if (!get_oid_with_context(the_repository, v0, GET_OID_BLOB,
  69                                           &sparse_oid, &oc))
  70                         filter_options->sparse_oid_value = oiddup(&sparse_oid);
  71                 filter_options->choice = LOFC_SPARSE_OID;
  72                 return 0;
  73
  74         } else if (skip_prefix(arg, "sparse:path=", &v0)) {
  75                 if (errbuf) {
  76                         strbuf_addstr(
  77                                 errbuf,
  78                                 _("sparse:path filters support has been dropped"));
  79                 }
  80                 return 1;
  81
  82         } else if (skip_prefix(arg, "combine:", &v0)) {
  83                 return parse_combine_filter(filter_options, v0, errbuf);
  84
  85         }
  86         /*
  87          * Please update _git_fetch() in git-completion.bash when you
  88          * add new filters
  89          */
  90
  91         strbuf_addf(errbuf, _("invalid filter-spec '%s'"), arg);
  92
  93         memset(filter_options, 0, sizeof(*filter_options));
  94         return 1;
  95 }
  96
  97 static const char *RESERVED_NON_WS = "~`!@#$^&*()[]{}\\;'\",<>?";
  98
  99 static int has_reserved_character(
 100         struct strbuf *sub_spec, struct strbuf *errbuf)
 101 {
 102         const char *c = sub_spec->buf;
 103         while (*c) {
 104                 if (*c <= ' ' || strchr(RESERVED_NON_WS, *c)) {
 105                         strbuf_addf(
 106                                 errbuf,
 107                                 _("must escape char in sub-filter-spec: '%c'"),
 108                                 *c);
 109                         return 1;
 110                 }
 111                 c++;
 112         }
 113
 114         return 0;
 115 }
 116
 117 static int parse_combine_subfilter(
 118         struct list_objects_filter_options *filter_options,
 119         struct strbuf *subspec,
 120         struct strbuf *errbuf)
 121 {
 122         size_t new_index = filter_options->sub_nr++;
 123         char *decoded;
 124         int result;
 125
 126         ALLOC_GROW(filter_options->sub, filter_options->sub_nr,
 127                    filter_options->sub_alloc);
 128         memset(&filter_options->sub[new_index], 0,
 129                sizeof(*filter_options->sub));
 130
 131         decoded = url_percent_decode(subspec->buf);
 132
 133         result = has_reserved_character(subspec, errbuf) ||
 134                 gently_parse_list_objects_filter(
 135                         &filter_options->sub[new_index], decoded, errbuf);
 136
 137         free(decoded);
 138         return result;
 139 }
 140
 141 static int parse_combine_filter(
 142         struct list_objects_filter_options *filter_options,
 143         const char *arg,
 144         struct strbuf *errbuf)
 145 {
 146         struct strbuf **subspecs = strbuf_split_str(arg, '+', 0);
 147         size_t sub;
 148         int result = 0;
 149
 150         if (!subspecs[0]) {
 151                 strbuf_addstr(errbuf, _("expected something after combine:"));
 152                 result = 1;
 153                 goto cleanup;
 154         }
 155
 156         for (sub = 0; subspecs[sub] && !result; sub++) {
 157                 if (subspecs[sub + 1]) {
 158                         /*
 159                          * This is not the last subspec. Remove trailing "+" so
 160                          * we can parse it.
 161                          */
 162                         size_t last = subspecs[sub]->len - 1;
 163                         assert(subspecs[sub]->buf[last] == '+');
 164                         strbuf_remove(subspecs[sub], last, 1);
 165                 }
 166                 result = parse_combine_subfilter(
 167                         filter_options, subspecs[sub], errbuf);
 168         }
 169
 170         filter_options->choice = LOFC_COMBINE;
 171
 172 cleanup:
 173         strbuf_list_free(subspecs);
 174         if (result) {
 175                 list_objects_filter_release(filter_options);
 176                 memset(filter_options, 0, sizeof(*filter_options));
 177         }
 178         return result;
 179 }
 180
 181 int parse_list_objects_filter(struct list_objects_filter_options *filter_options,
 182                               const char *arg)
 183 {
 184         struct strbuf buf = STRBUF_INIT;
 185         if (filter_options->choice)
 186                 die(_("multiple filter-specs cannot be combined"));
 187         filter_options->filter_spec = strdup(arg);
 188         if (gently_parse_list_objects_filter(filter_options, arg, &buf))
 189                 die("%s", buf.buf);
 190         return 0;
 191 }
 192
 193 int opt_parse_list_objects_filter(const struct option *opt,
 194                                   const char *arg, int unset)
 195 {
 196         struct list_objects_filter_options *filter_options = opt->value;
 197
 198         if (unset || !arg) {
 199                 list_objects_filter_set_no_filter(filter_options);
 200                 return 0;
 201         }
 202
 203         return parse_list_objects_filter(filter_options, arg);
 204 }
 205
 206 void expand_list_objects_filter_spec(
 207         const struct list_objects_filter_options *filter,
 208         struct strbuf *expanded_spec)
 209 {
 210         strbuf_init(expanded_spec, strlen(filter->filter_spec));
 211         if (filter->choice == LOFC_BLOB_LIMIT)
 212                 strbuf_addf(expanded_spec, "blob:limit=%lu",
 213                             filter->blob_limit_value);
 214         else if (filter->choice == LOFC_TREE_DEPTH)
 215                 strbuf_addf(expanded_spec, "tree:%lu",
 216                             filter->tree_exclude_depth);
 217         else
 218                 strbuf_addstr(expanded_spec, filter->filter_spec);
 219 }
 220
 221 void list_objects_filter_release(
 222         struct list_objects_filter_options *filter_options)
 223 {
 224         size_t sub;
 225
 226         if (!filter_options)
 227                 return;
 228         free(filter_options->filter_spec);
 229         free(filter_options->sparse_oid_value);
 230         for (sub = 0; sub < filter_options->sub_nr; sub++)
 231                 list_objects_filter_release(&filter_options->sub[sub]);
 232         free(filter_options->sub);
 233         memset(filter_options, 0, sizeof(*filter_options));
 234 }
 235
 236 void partial_clone_register(
 237         const char *remote,
 238         const struct list_objects_filter_options *filter_options)
 239 {
 240         /*
 241          * Record the name of the partial clone remote in the
 242          * config and in the global variable -- the latter is
 243          * used throughout to indicate that partial clone is
 244          * enabled and to expect missing objects.
 245          */
 246         if (repository_format_partial_clone &&
 247             *repository_format_partial_clone &&
 248             strcmp(remote, repository_format_partial_clone))
 249                 die(_("cannot change partial clone promisor remote"));
 250
 251         git_config_set("core.repositoryformatversion", "1");
 252         git_config_set("extensions.partialclone", remote);
 253
 254         repository_format_partial_clone = xstrdup(remote);
 255
 256         /*
 257          * Record the initial filter-spec in the config as
 258          * the default for subsequent fetches from this remote.
 259          */
 260         core_partial_clone_filter_default =
 261                 xstrdup(filter_options->filter_spec);
 262         git_config_set("core.partialclonefilter",
 263                        core_partial_clone_filter_default);
 264 }
 265
 266 void partial_clone_get_default_filter_spec(
 267         struct list_objects_filter_options *filter_options)
 268 {
 269         struct strbuf errbuf = STRBUF_INIT;
 270
 271         /*
 272          * Parse default value, but silently ignore it if it is invalid.
 273          */
 274         if (!core_partial_clone_filter_default)
 275                 return;
 276
 277         filter_options->filter_spec = strdup(core_partial_clone_filter_default);
 278         gently_parse_list_objects_filter(filter_options,
 279                                          core_partial_clone_filter_default,
 280                                          &errbuf);
 281         strbuf_release(&errbuf);
 282 }