Implement conditions on tag

A condition is formed by:
    <tag> <op> <value>

<tag> is the normal yambar tag. <op> is one of '==', '!=', '<', '<=', '>', or
'>='. <value> is what you wish to compare it to.

'boolean' tags must be used directly. They falsehood is matched with '~':

    <tag>
    ~<tag>

Finally, to match an empty string, one must use ' "" ':
    <tag> <op> ""

doc/yambar-modules-foreign-toplevel.5.scd

@@ -67,10 +67,9 @@ bar:
     - foreign-toplevel:
         content:
           map:
-            tag: activated
-            values:
-              false: {empty: {}}
-              true:
+            conditions:
+              (activated == false): {empty: {}}
+              (activated == true):
                 - string: {text: "{app-id}: {title}"}
 ```
 

doc/yambar-modules-i3.5.scd

@@ -102,10 +102,9 @@ bar:
         content:
           "":
             map:
-              tag: state
               default: {string: {text: "{name}"}}
-              values:
-                focused: {string: {text: "{name}*"}}
+              conditions:
+                (state == focused): {string: {text: "{name}*"}}
           current: { string: {text: "{application}: {title}"}}
 ```
 

doc/yambar-modules-removables.5.scd

@@ -74,13 +74,12 @@ bar:
     - removables:
         content:
           map:
-            tag: mounted
-            values:
-              false:
+            conditions:
+              (mounted == false):
                 string:
                   on-click: udisksctl mount -b {device}
                   text: "{label}"
-              true:
+              (mounted == true):
                 string:
                   on-click: udisksctl unmount -b {device}
                   text: "{label}"

doc/yambar-modules-river.5.scd

@@ -79,10 +79,9 @@ bar:
         title: {string: { text: "{seat} - {title}" }}
         content:
           map:
-            tag: occupied
-            values:
-              false: {empty: {}}
-              true:
+            conditions:
+              (occupied == false): {empty: {}}
+              (occupied == true):
                 string:
                   margin: 5
                   text: "{id}: {state}"

doc/yambar-modules-script.5.scd

@@ -133,10 +133,9 @@ bar:
             title|string|{{title}}
         content:
           map:
-            tag: status
-            values:
-              Paused: {empty: {}}
-              Playing:
+            conditions:
+              (status == Paused): {empty: {}}
+              (status == Playing):
                 content: {string: {text: "{artist} - {title}"}}
 ```
 

doc/yambar-modules.5.scd

@@ -68,20 +68,17 @@ in red.
 ```
 content:
   map:
-    tag: carrier
-    values:
-      false: {empty: {}}
-      true:
+    conditions:
+      (carrier == false): {empty: {}}
+      (carrier == true):
         map:
-          tag: state
           default: {string: {text: , font: *awesome, foreground: ffffff66}}
-          values:
-            up:
+          conditions:
+            (state == up):
               map:
-                tag: ipv4
                 default: {string: {text: , font: *awesome}}
-                values:
-                  "": {string: {text: , font: *awesome, foreground: ffffff66}}
+                conditions:
+                  (ipv4 == ""): {string: {text: , font: *awesome, foreground: ffffff66}}
 ```
 
 ## Use yaml anchors

doc/yambar-particles.5.scd

@@ -208,7 +208,37 @@ content:
 # MAP
 
 This particle maps the values of a specific tag to different
-particles. In addition to explicit tag values, you can also specify a
+particles based on conditions. A condition takes the form of:
+
+<tag> <operation> <value>
+
+Where <tag> is the tag you would like to map, <operation> is one of:
+
+[-  ==
+:- !=
+:- >=
+:- >
+:- <=
+:- <
+
+and <value> is the value you would like to compare it to. Conditions
+may be chained together using either '&&' or '||':
+
+<condition1> && <condition2>
+
+You may surround the *whole expression* with parenthesis to make it
+more readable:
+
+(<condition1> && <condition2>)
+
+Note that "nested" conditions are *NOT* supported. That is, something
+like (<condition1> && (<condition2> || <condition3>)) will *NOT* work.
+
+Furthermore, *conditions are evaluated with a strcmp*. This means
+some odd behaviour may arise if prefixes (such as zeroes) are added
+to numerical constants.
+
+In addition to explicit tag values, you can also specify a
 default/fallback particle.
 
 ## CONFIGURATION
@@ -217,34 +247,29 @@ default/fallback particle.
 :[ *Type*
 :[ *Req*
 :[ *Description*
-|  tag
-:  string
-:  yes
-:  The tag (name of) which values should be mapped
-|  values
+|  conditions
 :  associative array
 :  yes
-:  An associative array of tag values mapped to particles
+:  An associative array  of conditions (see above) mapped to particles
 |  default
 :  particle
 :  no
-:  Default particle to use, when tag's value does not match any of the
-   mapped values.
+:  Default particle to use, none of the conditions are true
 
 ## EXAMPLES
 
 ```
 content:
   map:
-    tag: tag_name
     default:
       string:
         text: this is the default particle; the tag's value is now {tag_name}
-    values:
-      one_value:
+	# Note, below, how the parenthesis are optional
+    conditions:
+      (tag == one_value):
         string:
           text: tag's value is now one_value
-      another_value:
+      tag == another_value:
         string:
           text: tag's value is now another_value
 

particles/map.c

@@ -1,5 +1,6 @@
 #include <stdlib.h>
 #include <string.h>
+#include <errno.h>
 #include <assert.h>
 
 #define LOG_MODULE "map"
@@ -10,13 +11,218 @@
 #include "../plugin.h"
 #include "dynlist.h"
 
+enum map_op{
+    MAP_OP_EQ,
+    MAP_OP_NE,
+    MAP_OP_LE,
+    MAP_OP_LT,
+    MAP_OP_GE,
+    MAP_OP_GT,
+    /* The next two are for bool types */
+    MAP_OP_SELF,
+    MAP_OP_NOT,
+};
+
+struct map_condition {
+    char *tag;
+    enum map_op op;
+    char *value;
+};
+
+static char *
+trim(char *s)
+{
+    while (*s == ' ')
+        s++;
+
+    char *end = s + strlen(s) - 1;
+    while (*end == ' ') {
+        *end = '\0';
+        end--;
+    }
+
+    return s;
+}
+
+bool
+int_condition(const long tag_value, const long cond_value, enum map_op op)
+{
+    switch (op) {
+    case MAP_OP_EQ: return tag_value == cond_value;
+    case MAP_OP_NE: return tag_value != cond_value;
+    case MAP_OP_LE: return tag_value <= cond_value;
+    case MAP_OP_LT: return tag_value < cond_value;
+    case MAP_OP_GE: return tag_value >= cond_value;
+    case MAP_OP_GT: return tag_value > cond_value;
+    default: return false;
+    }
+}
+
+bool
+float_condition(const double tag_value, const double cond_value, enum map_op op)
+{
+    switch (op) {
+    case MAP_OP_EQ: return tag_value == cond_value;
+    case MAP_OP_NE: return tag_value != cond_value;
+    case MAP_OP_LE: return tag_value <= cond_value;
+    case MAP_OP_LT: return tag_value < cond_value;
+    case MAP_OP_GE: return tag_value >= cond_value;
+    case MAP_OP_GT: return tag_value > cond_value;
+    default: return false;
+    }
+}
+
+bool
+str_condition(const char* tag_value, const char* cond_value, enum map_op op)
+{
+    switch (op) {
+    case MAP_OP_EQ: return strcmp(tag_value, cond_value) == 0;
+    case MAP_OP_NE: return strcmp(tag_value, cond_value) != 0;
+    case MAP_OP_LE: return strcmp(tag_value, cond_value) <= 0;
+    case MAP_OP_LT: return strcmp(tag_value, cond_value) < 0;
+    case MAP_OP_GE: return strcmp(tag_value, cond_value) >= 0;
+    case MAP_OP_GT: return strcmp(tag_value, cond_value) > 0;
+    default: return false;
+    }
+}
+
+bool
+eval_map_condition(const struct map_condition* map_cond, const struct tag_set *tags)
+{
+    const struct tag *tag = tag_for_name(tags, map_cond->tag);
+    if (tag == NULL) {
+        LOG_WARN("tag %s not found", map_cond->tag);
+        return false;
+    }
+
+    switch (tag->type(tag)) {
+    case TAG_TYPE_INT: {
+        errno = 0;
+        char *end;
+        const long cond_value = strtol(map_cond->value, &end, 0);
+
+        if (errno==ERANGE) {
+            LOG_WARN("value %s is too large", map_cond->value);
+            return false;
+        } else if (*end != '\0') {
+            LOG_WARN("failed to parse %s into int", map_cond->value);
+            return false;
+        }
+
+        const long tag_value = tag->as_int(tag);
+        return int_condition(tag_value, cond_value, map_cond->op);
+    }
+    case TAG_TYPE_FLOAT: {
+        errno = 0;
+        char *end;
+        const double cond_value = strtod(map_cond->value, &end);
+
+        if (errno==ERANGE) {
+            LOG_WARN("value %s is too large", map_cond->value);
+            return false;
+        } else if (*end != '\0') {
+            LOG_WARN("failed to parse %s into float", map_cond->value);
+            return false;
+        }
+
+        const double tag_value = tag->as_float(tag);
+        return float_condition(tag_value, cond_value, map_cond->op);
+    }
+    case TAG_TYPE_BOOL:
+        if (map_cond->op == MAP_OP_SELF)
+            return tag->as_bool(tag);
+        else if (map_cond->op == MAP_OP_NOT)
+            return !tag->as_bool(tag);
+        else {
+            LOG_WARN("boolean tag '%s' should be used directly", map_cond->tag);
+            return false;
+        }
+    case TAG_TYPE_STRING: {
+        const char* tag_value = tag->as_string(tag);
+        return str_condition(tag_value, map_cond->value, map_cond->op);
+    }
+    }
+    return false;
+}
+
+struct map_condition*
+map_condition_from_str(const char *str)
+{
+    struct map_condition *cond = malloc(sizeof(*cond));
+
+    /* This strdup is just to discard the 'const' qualifier */
+    char *str_cpy = strdup(str);
+    char *op_str = strpbrk(str_cpy, "=!<>~");
+
+    /* we've already checked things in the verify functions, so these should all work */
+    char *tag = str_cpy;
+    char *value = NULL;
+
+    if (op_str == NULL) {
+        cond->tag = strdup(trim(tag));
+        cond->op = MAP_OP_SELF;
+        cond->value = NULL;
+        free(str_cpy);
+        return cond;
+    }
+
+    switch (op_str[0]) {
+        case '=':
+            cond->op = MAP_OP_EQ;
+            value = op_str + 2;
+            break;
+        case '!':
+            cond->op = MAP_OP_NE;
+            value = op_str + 2;
+            break;
+        case '<':
+            if (op_str[1] == '=') {
+                cond->op = MAP_OP_LE;
+                value = op_str + 2;
+            } else {
+                cond->op = MAP_OP_LT;
+                value = op_str + 1;
+            }
+            break;
+        case '>':
+            if (op_str[1] == '=') {
+                cond->op = MAP_OP_GE;
+                value = op_str + 2;
+            } else {
+                cond->op = MAP_OP_GT;
+                value = op_str + 1;
+            }
+            break;
+        case '~':
+            tag = op_str + 1;
+            cond->op = MAP_OP_NOT;
+            break;
+    }
+
+    /* NULL terminate the tag value */
+    op_str[0] = '\0';
+
+    cond->tag = strdup(trim(tag));
+    cond->value = value != NULL ? strdup(trim(value)) : NULL;
+
+    free(str_cpy);
+    return cond;
+}
+
+void
+free_map_condition(struct map_condition* mc)
+{
+    free(mc->tag);
+    free(mc->value);
+    free(mc);
+}
+
 struct particle_map {
-    const char *tag_value;
+    struct map_condition *condition;
     struct particle *particle;
 };
 
 struct private {
-    char *tag;
     struct particle *default_particle;
     struct particle_map *map;
     size_t count;
@@ -92,21 +298,12 @@ static struct exposable *
 instantiate(const struct particle *particle, const struct tag_set *tags)
 {
     const struct private *p = particle->private;
-    const struct tag *tag = tag_for_name(tags, p->tag);
-
-    if (tag == NULL) {
-        return p->default_particle != NULL
-            ? p->default_particle->instantiate(p->default_particle, tags)
-            : dynlist_exposable_new(NULL, 0, 0, 0);
-    }
-
-    const char *tag_value = tag->as_string(tag);
     struct particle *pp = NULL;
 
     for (size_t i = 0; i < p->count; i++) {
         const struct particle_map *e = &p->map[i];
 
-        if (strcmp(e->tag_value, tag_value) != 0)
+        if (!eval_map_condition(e->condition, tags))
             continue;
 
         pp = e->particle;
@@ -144,28 +341,25 @@ particle_destroy(struct particle *particle)
     for (size_t i = 0; i < p->count; i++) {
         struct particle *pp = p->map[i].particle;
         pp->destroy(pp);
-        free((char *)p->map[i].tag_value);
+        free_map_condition(p->map[i].condition);
     }
 
     free(p->map);
-    free(p->tag);
     free(p);
     particle_default_destroy(particle);
 }
 
 static struct particle *
-map_new(struct particle *common, const char *tag,
-        const struct particle_map particle_map[], size_t count,
-        struct particle *default_particle)
+map_new(struct particle *common, const struct particle_map particle_map[],
+        size_t count, struct particle *default_particle)
 {
     struct private *priv = calloc(1, sizeof(*priv));
-    priv->tag = strdup(tag);
     priv->default_particle = default_particle;
     priv->count = count;
     priv->map = malloc(count * sizeof(priv->map[0]));
 
     for (size_t i = 0; i < count; i++) {
-        priv->map[i].tag_value = strdup(particle_map[i].tag_value);
+        priv->map[i].condition = particle_map[i].condition;
         priv->map[i].particle = particle_map[i].particle;
     }
 
@@ -176,7 +370,103 @@ map_new(struct particle *common, const char *tag,
 }
 
 static bool
-verify_map_values(keychain_t *chain, const struct yml_node *node)
+verify_map_condition_syntax(keychain_t *chain, const struct yml_node *node,
+        const char *line)
+{
+    /* We need this strdup to discard the 'const' qualifier */
+    char *cond = strdup(line);
+    char *op_str = strpbrk(cond, " =!<>~");
+    if (op_str == NULL) {
+        char *tag = trim(cond);
+        if (tag[0] == '\0')
+            goto syntax_fail_missing_tag;
+
+        free(cond);
+        return true;
+    }
+    op_str = trim(op_str);
+
+    char *tag = cond;
+    char *value = NULL;
+
+    switch (op_str[0]) {
+    case '=':
+        if (op_str[1] != '=')
+            goto syntax_fail_invalid_op;
+
+        value = op_str + 2;
+        break;
+
+    case '!':
+        if (op_str[1] != '=')
+            goto syntax_fail_invalid_op;
+
+        value = op_str + 2;
+        break;
+
+    case '<':
+        if (op_str[1] == '=')
+            value = op_str + 2;
+        else
+            value = op_str + 1;
+        break;
+
+    case '>':
+        if (op_str[1] == '=')
+            value = op_str + 2;
+        else
+            value = op_str + 1;
+        break;
+
+    case '~':
+        tag = op_str + 1;
+        if (strpbrk(tag, " =!<>~") != NULL)
+            goto syntax_fail_bad_not;
+        value = NULL;
+        break;
+    default:
+        goto syntax_fail_invalid_op;
+    }
+
+    /* NULL terminate the tag value */
+    op_str[0] = '\0';
+
+    tag = trim(tag);
+    if (tag[0] == '\0')
+        goto syntax_fail_missing_tag;
+
+    value = value != NULL ? trim(value) : NULL;
+
+    if (value != NULL && value[0] == '\0')
+        goto syntax_fail_missing_value;
+
+    free(cond);
+    return true;
+
+syntax_fail_invalid_op:
+    LOG_ERR("%s: \"%s\" invalid operator", conf_err_prefix(chain, node), line);
+    goto err;
+
+syntax_fail_missing_tag:
+    LOG_ERR("%s: \"%s\" missing tag", conf_err_prefix(chain, node), line);
+    goto err;
+
+syntax_fail_missing_value:
+    LOG_ERR("%s: \"%s\" missing value", conf_err_prefix(chain, node), line);
+    goto err;
+
+syntax_fail_bad_not:
+    LOG_ERR("%s: \"%s\" '~' cannot be used with other operators",
+            conf_err_prefix(chain, node), line);
+    goto err;
+
+err:
+    free(cond);
+    return false;
+}
+
+static bool
+verify_map_conditions(keychain_t *chain, const struct yml_node *node)
 {
     if (!yml_is_dict(node)) {
         LOG_ERR(
@@ -195,6 +485,9 @@ verify_map_values(keychain_t *chain, const struct yml_node *node)
             return false;
         }
 
+        if (!verify_map_condition_syntax(chain, it.key, key))
+            return false;
+
         if (!conf_verify_particle(chain_push(chain, key), it.value))
             return false;
 
@@ -207,11 +500,10 @@ verify_map_values(keychain_t *chain, const struct yml_node *node)
 static struct particle *
 from_conf(const struct yml_node *node, struct particle *common)
 {
-    const struct yml_node *tag = yml_get_value(node, "tag");
-    const struct yml_node *values = yml_get_value(node, "values");
+    const struct yml_node *conditions = yml_get_value(node, "conditions");
     const struct yml_node *def = yml_get_value(node, "default");
 
-    struct particle_map particle_map[yml_dict_length(values)];
+    struct particle_map particle_map[yml_dict_length(conditions)];
 
     struct conf_inherit inherited = {
         .font = common->font,
@@ -220,28 +512,25 @@ from_conf(const struct yml_node *node, struct particle *common)
     };
 
     size_t idx = 0;
-    for (struct yml_dict_iter it = yml_dict_iter(values);
+    for (struct yml_dict_iter it = yml_dict_iter(conditions);
          it.key != NULL;
          yml_dict_next(&it), idx++)
     {
-        particle_map[idx].tag_value = yml_value_as_string(it.key);
+        particle_map[idx].condition = map_condition_from_str(yml_value_as_string(it.key));
         particle_map[idx].particle = conf_to_particle(it.value, inherited);
     }
 
     struct particle *default_particle = def != NULL
         ? conf_to_particle(def, inherited) : NULL;
 
-    return map_new(
-        common, yml_value_as_string(tag), particle_map, yml_dict_length(values),
-        default_particle);
+    return map_new(common, particle_map, yml_dict_length(conditions), default_particle);
 }
 
 static bool
 verify_conf(keychain_t *chain, const struct yml_node *node)
 {
     static const struct attr_info attrs[] = {
-        {"tag", true, &conf_verify_string},
-        {"values", true, &verify_map_values},
+        {"conditions", true, &verify_map_conditions},
         {"default", false, &conf_verify_particle},
         PARTICLE_COMMON_ATTRS,
     };

tag.c

@@ -32,6 +32,30 @@ tag_name(const struct tag *tag)
     return priv->name;
 }
 
+static enum tag_type
+bool_type(const struct tag *tag)
+{
+    return TAG_TYPE_BOOL;
+}
+
+static enum tag_type
+int_type(const struct tag *tag)
+{
+    return TAG_TYPE_INT;
+}
+
+static enum tag_type
+float_type(const struct tag *tag)
+{
+    return TAG_TYPE_FLOAT;
+}
+
+static enum tag_type
+string_type(const struct tag *tag)
+{
+    return TAG_TYPE_STRING;
+}
+
 static long
 unimpl_min_max(const struct tag *tag)
 {
@@ -264,6 +288,7 @@ tag_new_int_realtime(struct module *owner, const char *name, long value,
     tag->owner = owner;
     tag->destroy = &destroy_int_and_float;
     tag->name = &tag_name;
+    tag->type = &int_type;
     tag->min = &int_min;
     tag->max = &int_max;
     tag->realtime = &int_realtime;
@@ -287,6 +312,7 @@ tag_new_bool(struct module *owner, const char *name, bool value)
     tag->owner = owner;
     tag->destroy = &destroy_int_and_float;
     tag->name = &tag_name;
+    tag->type = &bool_type;
     tag->min = &unimpl_min_max;
     tag->max = &unimpl_min_max;
     tag->realtime = &no_realtime;
@@ -310,6 +336,7 @@ tag_new_float(struct module *owner, const char *name, double value)
     tag->owner = owner;
     tag->destroy = &destroy_int_and_float;
     tag->name = &tag_name;
+    tag->type = &float_type;
     tag->min = &unimpl_min_max;
     tag->max = &unimpl_min_max;
     tag->realtime = &no_realtime;
@@ -333,6 +360,7 @@ tag_new_string(struct module *owner, const char *name, const char *value)
     tag->owner = owner;
     tag->destroy = &destroy_string;
     tag->name = &tag_name;
+    tag->type = &string_type;
     tag->min = &unimpl_min_max;
     tag->max = &unimpl_min_max;
     tag->realtime = &no_realtime;

tag.h

@@ -3,6 +3,13 @@
 #include <stddef.h>
 #include <stdbool.h>
 
+enum tag_type {
+    TAG_TYPE_BOOL,
+    TAG_TYPE_INT,
+    TAG_TYPE_FLOAT,
+    TAG_TYPE_STRING,
+};
+
 enum tag_realtime_unit {
     TAG_REALTIME_NONE,
     TAG_REALTIME_SECS,
@@ -17,6 +24,7 @@ struct tag {
 
     void (*destroy)(struct tag *tag);
     const char *(*name)(const struct tag *tag);
+    enum tag_type (*type)(const struct tag *tag);
     const char *(*as_string)(const struct tag *tag);
     long (*as_int)(const struct tag *tag);
     bool (*as_bool)(const struct tag *tag);

test/full-conf-good.yml

@@ -62,10 +62,9 @@ bar:
     - clock:
         content:
           map:
-            tag: date
             default: {string: {text: default value}}
-            values:
-              1234: {string: {text: specific value}}
+            conditions:
+              date == 1234: {string: {text: specific value}}
     - clock:
         content:
           progress-bar: