src/ecoli_node_str.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright 2016, Olivier MATZ <zer0@droids-corp.org>
   3  */
   4
   5 #include <stdio.h>
   6 #include <stdlib.h>
   7 #include <string.h>
   8 #include <errno.h>
   9
  10 #include <ecoli_log.h>
  11 #include <ecoli_malloc.h>
  12 #include <ecoli_test.h>
  13 #include <ecoli_strvec.h>
  14 #include <ecoli_node.h>
  15 #include <ecoli_config.h>
  16 #include <ecoli_parse.h>
  17 #include <ecoli_complete.h>
  18 #include <ecoli_node_str.h>
  19
  20 EC_LOG_TYPE_REGISTER(node_str);
  21
  22 struct ec_node_str {
  23         char *string;
  24         unsigned len;
  25 };
  26
  27 static int
  28 ec_node_str_parse(const struct ec_node *node,
  29                 struct ec_pnode *state,
  30                 const struct ec_strvec *strvec)
  31 {
  32         struct ec_node_str *priv = ec_node_priv(node);
  33         const char *str;
  34
  35         (void)state;
  36
  37         if (priv->string == NULL) {
  38                 errno = EINVAL;
  39                 return -1;
  40         }
  41
  42         if (ec_strvec_len(strvec) == 0)
  43                 return EC_PARSE_NOMATCH;
  44
  45         str = ec_strvec_val(strvec, 0);
  46         if (strcmp(str, priv->string) != 0)
  47                 return EC_PARSE_NOMATCH;
  48
  49         return 1;
  50 }
  51
  52 static int
  53 ec_node_str_complete(const struct ec_node *node,
  54                 struct ec_comp *comp,
  55                 const struct ec_strvec *strvec)
  56 {
  57         struct ec_node_str *priv = ec_node_priv(node);
  58         const char *str;
  59         size_t n = 0;
  60
  61         if (ec_strvec_len(strvec) != 1)
  62                 return 0;
  63
  64         /* XXX startswith ? */
  65         str = ec_strvec_val(strvec, 0);
  66         for (n = 0; n < priv->len; n++) {
  67                 if (str[n] != priv->string[n])
  68                         break;
  69         }
  70
  71         /* no completion */
  72         if (str[n] != '\0')
  73                 return EC_PARSE_NOMATCH;
  74
  75         if (ec_comp_add_item(comp, node, NULL, EC_COMP_FULL,
  76                                         str, priv->string) < 0)
  77                 return -1;
  78
  79         return 0;
  80 }
  81
  82 static const char *ec_node_str_desc(const struct ec_node *node)
  83 {
  84         struct ec_node_str *priv = ec_node_priv(node);
  85
  86         return priv->string;
  87 }
  88
  89 static void ec_node_str_free_priv(struct ec_node *node)
  90 {
  91         struct ec_node_str *priv = ec_node_priv(node);
  92
  93         ec_free(priv->string);
  94 }
  95
  96 static const struct ec_config_schema ec_node_str_schema[] = {
  97         {
  98                 .key = "string",
  99                 .desc = "The string to match.",
 100                 .type = EC_CONFIG_TYPE_STRING,
 101         },
 102         {
 103                 .type = EC_CONFIG_TYPE_NONE,
 104         },
 105 };
 106
 107 static int ec_node_str_set_config(struct ec_node *node,
 108                                 const struct ec_config *config)
 109 {
 110         struct ec_node_str *priv = ec_node_priv(node);
 111         const struct ec_config *value = NULL;
 112         char *s = NULL;
 113
 114         value = ec_config_dict_get(config, "string");
 115         if (value == NULL) {
 116                 errno = EINVAL;
 117                 goto fail;
 118         }
 119
 120         s = ec_strdup(value->string);
 121         if (s == NULL)
 122                 goto fail;
 123
 124         ec_free(priv->string);
 125         priv->string = s;
 126         priv->len = strlen(priv->string);
 127
 128         return 0;
 129
 130 fail:
 131         ec_free(s);
 132         return -1;
 133 }
 134
 135 static struct ec_node_type ec_node_str_type = {
 136         .name = "str",
 137         .schema = ec_node_str_schema,
 138         .set_config = ec_node_str_set_config,
 139         .parse = ec_node_str_parse,
 140         .complete = ec_node_str_complete,
 141         .desc = ec_node_str_desc,
 142         .size = sizeof(struct ec_node_str),
 143         .free_priv = ec_node_str_free_priv,
 144 };
 145
 146 EC_NODE_TYPE_REGISTER(ec_node_str_type);
 147
 148 int ec_node_str_set_str(struct ec_node *node, const char *str)
 149 {
 150         struct ec_config *config = NULL;
 151         int ret;
 152
 153         if (ec_node_check_type(node, &ec_node_str_type) < 0)
 154                 goto fail;
 155
 156         if (str == NULL) {
 157                 errno = EINVAL;
 158                 goto fail;
 159         }
 160
 161         config = ec_config_dict();
 162         if (config == NULL)
 163                 goto fail;
 164
 165         ret = ec_config_dict_set(config, "string", ec_config_string(str));
 166         if (ret < 0)
 167                 goto fail;
 168
 169         ret = ec_node_set_config(node, config);
 170         config = NULL;
 171         if (ret < 0)
 172                 goto fail;
 173
 174         return 0;
 175
 176 fail:
 177         ec_config_free(config);
 178         return -1;
 179 }
 180
 181 struct ec_node *ec_node_str(const char *id, const char *str)
 182 {
 183         struct ec_node *node = NULL;
 184
 185         node = ec_node_from_type(&ec_node_str_type, id);
 186         if (node == NULL)
 187                 goto fail;
 188
 189         if (ec_node_str_set_str(node, str) < 0)
 190                 goto fail;
 191
 192         return node;
 193
 194 fail:
 195         ec_node_free(node);
 196         return NULL;
 197 }
 198
 199 /* LCOV_EXCL_START */
 200 static int ec_node_str_testcase(void)
 201 {
 202         struct ec_node *node;
 203         int testres = 0;
 204
 205         node = ec_node_str(EC_NO_ID, "foo");
 206         if (node == NULL) {
 207                 EC_LOG(EC_LOG_ERR, "cannot create node\n");
 208                 return -1;
 209         }
 210         testres |= EC_TEST_CHECK(!strcmp(ec_node_desc(node), "foo"),
 211                 "Invalid node description.");
 212         testres |= EC_TEST_CHECK_PARSE(node, 1, "foo");
 213         testres |= EC_TEST_CHECK_PARSE(node, 1, "foo", "bar");
 214         testres |= EC_TEST_CHECK_PARSE(node, -1, "foobar");
 215         testres |= EC_TEST_CHECK_PARSE(node, -1, " foo");
 216         testres |= EC_TEST_CHECK_PARSE(node, -1, "");
 217         ec_node_free(node);
 218
 219         node = ec_node_str(EC_NO_ID, "Здравствуйте");
 220         if (node == NULL) {
 221                 EC_LOG(EC_LOG_ERR, "cannot create node\n");
 222                 return -1;
 223         }
 224         testres |= EC_TEST_CHECK_PARSE(node, 1, "Здравствуйте");
 225         testres |= EC_TEST_CHECK_PARSE(node, 1, "Здравствуйте",
 226                 "John!");
 227         testres |= EC_TEST_CHECK_PARSE(node, -1, "foo");
 228         testres |= EC_TEST_CHECK_PARSE(node, -1, "");
 229         ec_node_free(node);
 230
 231         /* an empty string node always matches */
 232         node = ec_node_str(EC_NO_ID, "");
 233         if (node == NULL) {
 234                 EC_LOG(EC_LOG_ERR, "cannot create node\n");
 235                 return -1;
 236         }
 237         testres |= EC_TEST_CHECK_PARSE(node, 1, "");
 238         testres |= EC_TEST_CHECK_PARSE(node, 1, "", "foo");
 239         testres |= EC_TEST_CHECK_PARSE(node, -1, "foo");
 240         ec_node_free(node);
 241
 242         /* test completion */
 243         node = ec_node_str(EC_NO_ID, "foo");
 244         if (node == NULL) {
 245                 EC_LOG(EC_LOG_ERR, "cannot create node\n");
 246                 return -1;
 247         }
 248         testres |= EC_TEST_CHECK_COMPLETE(node,
 249                 EC_VA_END,
 250                 EC_VA_END);
 251         testres |= EC_TEST_CHECK_COMPLETE(node,
 252                 "", EC_VA_END,
 253                 "foo", EC_VA_END);
 254         testres |= EC_TEST_CHECK_COMPLETE(node,
 255                 "f", EC_VA_END,
 256                 "foo", EC_VA_END);
 257         testres |= EC_TEST_CHECK_COMPLETE(node,
 258                 "foo", EC_VA_END,
 259                 "foo", EC_VA_END);
 260         testres |= EC_TEST_CHECK_COMPLETE(node,
 261                 "x", EC_VA_END,
 262                 EC_VA_END);
 263         ec_node_free(node);
 264
 265         return testres;
 266 }
 267 /* LCOV_EXCL_STOP */
 268
 269 static struct ec_test ec_node_str_test = {
 270         .name = "node_str",
 271         .test = ec_node_str_testcase,
 272 };
 273
 274 EC_TEST_REGISTER(ec_node_str_test);