api documentation
[protos/libecoli.git] / 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);