yerba 0.7.6 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8388badb1c673c2f6815631a955f731b1699ed4f6aea305a73519e2f231d63c
-  data.tar.gz: dc153bff8304870d85e4631e794d04a4ec107d93fc8a7b8738845e2b3ead7133
+  metadata.gz: a769e82895bc0bea8b8e25391f39cdbf8e915a46d524efd05af951738b4b046a
+  data.tar.gz: 83d41f698f888f6065729b8adb5e6646e14b9832871eafde6af2fa60bfd4b862
 SHA512:
-  metadata.gz: be8d6ee312803ab9fca14e5d3a692fcc601354144918d5e7ef9237348ec8a51be42ffec4cef0bef9a5a680477c8344578118b29f094dd9202944292db54683fd
-  data.tar.gz: 77f14d190d24bfbabc069a8ba015c813ff525564cc5c18767d9a6806f546526bd53555eeabff25e64da2bbbd6dc08a82f72b8443e75ac61250c0751bcc8755c7
+  metadata.gz: 64e3fe5431316bc5faf03187419f234f52c9d8f04710d06afdd6bf13dc5342a80dadae3a4345ee610f4f307976d45520f0cc6b4bcc7a7959e21a9902ae071343
+  data.tar.gz: 3f12d6fa79ed13905bca60481eb3a87caffa46fd8205b6a9d56a8fcf250ce708698e218a4cec7126294940eb6ce8f44e02abf445144c12b9f39ad16f417a1da7

data/README.md

@@ -47,7 +47,7 @@ Use `yerba` as a library in your Rust project:
 
 ```toml
 [dependencies]
-yerba = "0.7"
+yerba = "0.8"
 ```
 
 ```rust
@@ -96,8 +96,11 @@ Selectors let you address any node in a YAML document:
 | `key.nested`      | Nested key path     | `"database.settings.pool"` |
 | `[]`              | All items in array  | `"[].title"`               |
 | `[N]`             | Item at index       | `"[0].title"`              |
+| `*`               | All values in a map | `"database.*"`             |
 | `[].key[].nested` | Nested array access | `"[].speakers[].name"`     |
 
+`[]` and `*` are the same idea applied to the two collection types: `[]` matches every item of a sequence, `*` matches every value of a map. Both can be combined with the other patterns, as in `"[].*"` or `"*.city"`.
+
 ### Conditions
 
 Conditions filter which items a command operates on:
@@ -109,6 +112,8 @@ Conditions filter which items a command operates on:
 | `.key contains val`     | Substring or member | `".title contains Ruby"`     |
 | `.key not_contains val` | Negated contains    | `".title not_contains test"` |
 
+The selector is relative to each item and starts with `.`. A condition that is malformed, or that uses an absolute selector where each item is tested, is rejected rather than matching nothing, so a typo is an error instead of a command that quietly does nothing.
+
 ---
 
 ### `get`
@@ -701,6 +706,12 @@ Set all matching nodes at once with `all: true`:
 document.set("[].description", "", all: true)
 ```
 
+Setting a scalar over a key whose value is a collection replaces the collection:
+
+```ruby
+document.root["venue"] = "none"  # => venue: none
+```
+
 Insert new keys with positional control:
 
 ```ruby
@@ -829,6 +840,24 @@ document["database"].collection_style = :flow  # => database: {host: localhost,
 document["database"].collection_style = :block # => database:\n  host: localhost\n  port: 5432
 ```
 
+Flow collections are read and iterated like block ones, and their scalars can be
+changed in place:
+
+```ruby
+document = Yerba::Document.parse("tags: [ruby, rails]\n")
+
+document["tags"].map(&:value)   # => ["ruby", "rails"]
+document["tags[1]"].value = "crystal"  # => tags: [ruby, crystal]
+```
+
+Adding or removing entries is not supported yet, and raises rather than
+reformatting the collection. Switch to block style first:
+
+```ruby
+document["tags"].collection_style = :block
+document.delete("tags[0]")
+```
+
 ### Sequence Indent
 
 Control whether sequence items are indented under their key or at the same level:
@@ -893,17 +922,52 @@ document.locations("[].speakers[]")
 
 ### Wildcard Access
 
-When `[]` receives a wildcard selector (containing `[]`), it returns an array of nodes instead of a single node:
+When `[]` receives a wildcard selector, it returns an array of nodes instead of a single node. `[]` matches every item of a sequence and `*` matches every value of a map:
 
 ```ruby
 document["[].title"]       # => [Yerba::Scalar, Yerba::Scalar, ...]
 document["[].speakers[]"]  # => [Yerba::Scalar, Yerba::Scalar, ...]
 document["items[].name"]   # => [Yerba::Scalar, Yerba::Scalar, ...]
 
+document["database.*"]     # => [Yerba::Scalar, Yerba::Scalar, ...]
+document["*"]              # => every value of the root map
+document["[].*"]           # => every value of every item
+
 document["[].title"].each { |scalar| puts scalar.value }
 document["[].title"].each { |scalar| scalar.value = "Updated" }
 ```
 
+Each node knows the key it belongs to, which is how a map value can be traced back to its name:
+
+```ruby
+document["database.*"].map { |node| [node.key.value, node.value] }
+# => [["host", "localhost"], ["port", 5432]]
+```
+
+`get_all` resolves the same selectors in a single walk of the document, rather than looking each node up separately. It is the faster choice when reading many nodes, and returns nodes that are still connected to the document:
+
+```ruby
+document.get_all("[].title")     # => [Yerba::Scalar, Yerba::Scalar, ...]
+document.get_all("database.*")   # => [Yerba::Scalar, Yerba::Scalar, ...]
+
+document.get_all("[].title").first.value = "Updated"
+document.save!
+```
+
+Reading values rather than nodes keeps a positional `nil` where a branch does not match, while resolving nodes skips it:
+
+```ruby
+document.value_at("*.city")            # => [nil, "Berlin", nil]
+document.get_all("*.city").map(&:value) # => ["Berlin"]
+```
+
+Wildcards address more than one node, so they cannot be written through. `set`, `insert` and `delete` raise rather than change every match at once:
+
+```ruby
+document.set("database.*", "x")  # => raises Yerba::Error
+document.delete("database.*")    # => raises Yerba::Error
+```
+
 ### Collections
 
 Operate on multiple files matching a glob pattern:

data/ext/yerba/include/yerba.h

@@ -89,6 +89,10 @@ char *yerba_document_selectors(const struct Document *document);
 
 char *yerba_document_resolve_selectors(const struct Document *document, const char *path);
 
+bool yerba_selector_has_wildcard(const char *path);
+
+char *yerba_document_keys(const struct Document *document, const char *path);
+
 char *yerba_document_get_quote_style(const struct Document *document, const char *path);
 
 struct YerbaResult yerba_document_set_quote_style(struct Document *document,
@@ -107,6 +111,8 @@ struct YerbaResult yerba_document_set_sequence_indent(struct Document *document,
                                                       const char *path,
                                                       const char *style);
 
+char *yerba_validate_condition(const char *condition, bool item_context);
+
 bool yerba_document_evaluate_condition(const struct Document *document,
                                        const char *parent_path,
                                        const char *condition);
@@ -213,6 +219,8 @@ void yerba_get_result_free(struct YerbaGetResult result);
 
 struct YerbaTypedList yerba_glob_get(const char *glob_pattern, const char *path);
 
+struct YerbaTypedList yerba_document_get_all(const struct Document *document, const char *path);
+
 struct YerbaTypedList yerba_glob_find(const char *glob_pattern,
                                       const char *path,
                                       const char *condition,

data/ext/yerba/yerba.c

@@ -98,6 +98,19 @@ static VALUE typed_value_to_ruby(YerbaTypedValue typed_value) {
   return result;
 }
 
+static void check_condition(const char *condition, bool item_context) {
+  if (!condition) return;
+
+  char *error = yerba_validate_condition(condition, item_context);
+
+  if (!error) return;
+
+  VALUE message = make_utf8_string(error);
+  yerba_string_free(error);
+
+  rb_raise(rb_eError, "%s", StringValueCStr(message));
+}
+
 static int should_proceed(struct Document *document, VALUE opts) {
   if (NIL_P(opts)) return 1;
   VALUE v_condition = rb_hash_aref(opts, ID2SYM(rb_intern("condition")));
@@ -106,6 +119,8 @@ static int should_proceed(struct Document *document, VALUE opts) {
   VALUE v_path = rb_hash_aref(opts, ID2SYM(rb_intern("condition_path")));
   const char *parent_path = NIL_P(v_path) ? "" : StringValueCStr(v_path);
 
+  check_condition(StringValueCStr(v_condition), parent_path[0] != '\0');
+
   return yerba_document_evaluate_condition(document, parent_path, StringValueCStr(v_condition));
 }
 
@@ -256,8 +271,7 @@ static VALUE document_bracket(VALUE self, VALUE path) {
 
   const char *selector = StringValueCStr(path);
 
-  /* Wildcard: resolve to concrete selectors and return array of nodes */
-  if (strstr(selector, "[]") != NULL) {
+  if (yerba_selector_has_wildcard(selector)) {
     char *json = yerba_document_resolve_selectors(document, selector);
 
     if (!json) return rb_ary_new();
@@ -338,6 +352,19 @@ static VALUE document_selectors(VALUE self) {
   return rb_funcall(rb_path2class("JSON"), rb_intern("parse"), 1, json_string);
 }
 
+/* document.keys_at(selector) → ["host", "port", ...] */
+static VALUE document_keys_at(VALUE self, VALUE path) {
+  struct Document *document = get_document(self);
+  char *json = yerba_document_keys(document, StringValueCStr(path));
+
+  if (!json) return rb_ary_new();
+
+  VALUE json_string = make_utf8_string(json);
+  yerba_string_free(json);
+
+  return rb_funcall(rb_path2class("JSON"), rb_intern("parse"), 1, json_string);
+}
+
 /* document.locations(selector) → [Yerba::Location, ...] */
 static VALUE document_locations(VALUE self, VALUE path) {
   struct Document *document = get_document(self);
@@ -508,6 +535,8 @@ static VALUE document_condition_p(int argc, VALUE *argv, VALUE self) {
 
   struct Document *document = get_document(self);
 
+  check_condition(StringValueCStr(condition), parent_path[0] != '\0');
+
   return yerba_document_evaluate_condition(document, parent_path, StringValueCStr(condition)) ? Qtrue : Qfalse;
 }
 
@@ -528,6 +557,9 @@ static VALUE document_find(int argc, VALUE *argv, VALUE self) {
   }
 
   struct Document *document = get_document(self);
+
+  check_condition(condition, true);
+
   char *json = yerba_document_find(document, StringValueCStr(path), condition, select);
 
   if (!json) return rb_ary_new();
@@ -959,12 +991,7 @@ static VALUE document_path(VALUE self) {
   return rb_iv_get(self, "@path");
 }
 
-/* Collection.get(glob, selector) → [Yerba::Scalar|Map|Sequence, ...] */
-static VALUE collection_s_get(VALUE self, VALUE pattern, VALUE path) {
-  (void) self;
-
-  YerbaTypedList result = yerba_glob_get(StringValueCStr(pattern), StringValueCStr(path));
-
+static VALUE located_list_to_ruby(YerbaTypedList result, VALUE document) {
   if (!result.json) return rb_ary_new();
 
   VALUE json_string = make_utf8_string(result.json);
@@ -992,6 +1019,23 @@ static VALUE collection_s_get(VALUE self, VALUE pattern, VALUE path) {
     if (!NIL_P(file_path)) rb_hash_aset(kwargs, ID2SYM(rb_intern("file_path")), file_path);
     if (!NIL_P(line)) rb_hash_aset(kwargs, ID2SYM(rb_intern("line")), line);
     if (!NIL_P(location)) rb_hash_aset(kwargs, ID2SYM(rb_intern("location")), location);
+    if (!NIL_P(document)) rb_hash_aset(kwargs, ID2SYM(rb_intern("document")), document);
+
+    VALUE key_name = rb_hash_aref(item, rb_str_new_cstr("key_name"));
+
+    if (!NIL_P(key_name)) {
+      VALUE key_location = rb_hash_aref(item, rb_str_new_cstr("key_location"));
+      VALUE key_kwargs = rb_hash_new();
+
+      rb_hash_aset(key_kwargs, ID2SYM(rb_intern("selector")), Qnil);
+      rb_hash_aset(key_kwargs, ID2SYM(rb_intern("value")), key_name);
+      if (!NIL_P(key_location)) rb_hash_aset(key_kwargs, ID2SYM(rb_intern("location")), key_location);
+
+      VALUE key_args[1] = { key_kwargs };
+      VALUE key = rb_funcallv_kw(rb_path2class("Yerba::Scalar"), rb_intern("from"), 1, key_args, RB_PASS_KEYWORDS);
+
+      rb_hash_aset(kwargs, ID2SYM(rb_intern("key")), key);
+    }
 
     if (strcmp(type_str, "scalar") == 0) {
       VALUE text = rb_hash_aref(item, rb_str_new_cstr("text"));
@@ -1015,6 +1059,20 @@ static VALUE collection_s_get(VALUE self, VALUE pattern, VALUE path) {
   return array;
 }
 
+/* Collection.get(glob, selector) → [Yerba::Scalar|Map|Sequence, ...] */
+static VALUE collection_s_get(VALUE self, VALUE pattern, VALUE path) {
+  (void) self;
+
+  return located_list_to_ruby(yerba_glob_get(StringValueCStr(pattern), StringValueCStr(path)), Qnil);
+}
+
+/* document.get_all(selector) → [Yerba::Scalar|Map|Sequence, ...] */
+static VALUE document_get_all(VALUE self, VALUE path) {
+  struct Document *document = get_document(self);
+
+  return located_list_to_ruby(yerba_document_get_all(document, StringValueCStr(path)), self);
+}
+
 /* Collection.find(glob, path, condition: nil, select: nil) */
 static VALUE collection_s_find(int argc, VALUE *argv, VALUE self) {
   (void)self;
@@ -1032,6 +1090,8 @@ static VALUE collection_s_find(int argc, VALUE *argv, VALUE self) {
     if (!NIL_P(v_select)) select = StringValueCStr(v_select);
   }
 
+  check_condition(condition, true);
+
   YerbaTypedList result = yerba_glob_find(StringValueCStr(pattern), StringValueCStr(path), condition, select);
 
   if (!result.json) return rb_ary_new();
@@ -1080,9 +1140,11 @@ void Init_yerba(void) {
   rb_define_method(rb_cDocument, "[]", document_bracket, 1);
   rb_define_method(rb_cDocument, "node_at", document_bracket, 1);
   rb_define_method(rb_cDocument, "value_at", document_get_value, 1);
+  rb_define_method(rb_cDocument, "get_all", document_get_all, 1);
   rb_define_method(rb_cDocument, "location", document_location, -1);
   rb_define_method(rb_cDocument, "locations", document_locations, 1);
   rb_define_method(rb_cDocument, "selectors", document_selectors, 0);
+  rb_define_method(rb_cDocument, "keys_at", document_keys_at, 1);
   rb_define_method(rb_cDocument, "resolve_selectors", document_resolve_selectors, 1);
   rb_define_method(rb_cDocument, "get_quote_style", document_get_quote_style, 1);
   rb_define_method(rb_cDocument, "set_quote_style", document_set_quote_style, 2);

data/lib/yerba/map.rb

@@ -77,24 +77,29 @@ module Yerba
     end
 
     def keys
-      if connected?
-        results = document.find(@selector)
-        return [] unless results.is_a?(Array) && results.first.is_a?(Hash)
+      return @data.keys unless connected?
 
-        results.first.keys
-      else
-        @data.keys
-      end
+      document.keys_at(@selector)
     end
 
     def each(&)
       return enum_for(:each) unless block_given?
 
-      if connected?
-        keys.each { |key| yield key, self[key] }
-      else
+      unless connected?
         @data.each(&)
+        return self
       end
+
+      names = keys
+      values = document.get_all(@selector.empty? ? "*" : "#{@selector}.*")
+
+      if values.length == names.length && values.all?(&:key)
+        values.each { |value| yield value.key.value, value }
+      else
+        names.each { |key| yield key, self[key] }
+      end
+
+      self
     end
 
     def fetch(key)

data/lib/yerba/node.rb

@@ -36,10 +36,10 @@ module Yerba
         instance
       end
 
-      def from(file_path:, selector:, line: nil, location: nil, **attributes)
+      def from(selector:, file_path: nil, line: nil, location: nil, document: nil, key: nil, **attributes)
         instance = allocate
 
-        instance.send(:init_node, nil, selector, coerce_location(location), nil, file_path, line)
+        instance.send(:init_node, document, selector, coerce_location(location), key, file_path, line)
         instance.send(:init_from, **attributes) if instance.respond_to?(:init_from, true)
 
         instance

data/lib/yerba/sequence.rb

@@ -90,10 +90,22 @@ module Yerba
       self
     end
 
-    def each
+    def each(&)
       return enum_for(:each) unless block_given?
 
+      if connected?
+        items = document.get_all("#{@selector}[]")
+
+        if items.length == length
+          items.each(&)
+
+          return self
+        end
+      end
+
       length.times { |index| yield self[index] }
+
+      self
     end
 
     def find_by(selector = nil, value = nil, **criteria)

data/lib/yerba/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Yerba
-  VERSION = "0.7.6"
+  VERSION = "0.8.1"
 end

data/rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "yerba"
-version = "0.7.6"
+version = "0.8.1"
 edition = "2021"
 authors = ["Marco Roth <marco.roth@intergga.ch>"]
 description = "YAML Editing and Refactoring with Better Accuracy"
@@ -18,21 +18,30 @@ crate-type = ["cdylib", "staticlib", "rlib"]
 [[bin]]
 name = "yerba"
 path = "src/main.rs"
+required-features = ["cli"]
+
+[features]
+default = ["cli"]
+cli = ["dep:clap", "dep:indoc", "dep:anstyle-query", "glob", "schema"]
+glob = ["dep:glob", "dep:rayon"]
+schema = ["dep:jsonschema"]
 
 [dependencies]
 yaml_parser = "0.3"
 rowan = "0.16"
-glob = "0.3"
+glob = { version = "0.3", optional = true }
 serde = { version = "1", features = ["derive"] }
 yaml_serde = "0.10"
 serde_json = { version = "1", features = ["preserve_order"] }
-clap = { version = "4", features = ["derive"] }
-indoc = "2"
-rayon = "1"
-jsonschema = "0.29"
+clap = { version = "4", features = ["derive"], optional = true }
+anstyle-query = { version = "1", optional = true }
+indoc = { version = "2", optional = true }
+rayon = { version = "1", optional = true }
+jsonschema = { version = "0.29", default-features = false, optional = true }
 
 [build-dependencies]
 cbindgen = "0.28"
 
 [dev-dependencies]
+indoc = "2"
 tempfile = "3"

data/rust/src/commands/blank_lines.rs

@@ -37,9 +37,9 @@ impl Args {
     } else if let Ok(count) = self.first.parse::<usize>() {
       ("", count)
     } else {
-      use super::color::*;
+      use super::ui;
 
-      eprintln!("{RED}Error:{RESET} expected a number for blank line count, got '{}'", self.first);
+      eprintln!("{} expected a number for blank line count, got '{}'", ui::failure("Error:"), self.first);
 
       std::process::exit(1);
     };

data/rust/src/commands/directives.rs

@@ -1,3 +1,4 @@
+use super::ui;
 use std::sync::LazyLock;
 
 use indoc::indoc;
@@ -35,14 +36,13 @@ pub struct Args {
 impl Args {
   pub fn run(self) {
     if !self.ensure && !self.remove {
-      use super::color::*;
-      eprintln!("{RED}Error:{RESET} specify --ensure or --remove");
+      use super::ui;
+      eprintln!("{} specify --ensure or --remove", ui::failure("Error:"));
       std::process::exit(1);
     }
 
     if self.ensure && self.remove {
-      use super::color::*;
-      eprintln!("{RED}Error:{RESET} --ensure and --remove are mutually exclusive");
+      eprintln!("{} --ensure and --remove are mutually exclusive", ui::failure("Error:"));
       std::process::exit(1);
     }
 

data/rust/src/commands/get.rs

@@ -1,3 +1,4 @@
+use super::ui;
 use std::process;
 use std::sync::LazyLock;
 
@@ -62,6 +63,16 @@ impl Args {
       condition.clone()
     });
 
+    if let Some(condition) = &normalized_condition {
+      if let Err(error) = yerba::validate_item_condition(condition) {
+        use super::ui;
+
+        eprintln!("{} {}", ui::failure("Error:"), error);
+
+        process::exit(1);
+      }
+    }
+
     let search_path_string = search_path.to_selector_string();
     let mut all_results: Vec<serde_json::Value> = Vec::new();
     let files = resolve_files(&self.file);
@@ -75,9 +86,7 @@ impl Args {
           continue;
         }
 
-        use super::color::*;
-
-        eprintln!("{RED}Error:{RESET} selector \"{}\" not found in {}", self.selector, self.file);
+        eprintln!("{} selector \"{}\" not found in {}", ui::failure("Error:"), self.selector, self.file);
 
         show_similar_selectors(&self.file, &document, &self.selector);
         process::exit(1);
@@ -100,8 +109,7 @@ impl Args {
               break;
             }
 
-            use super::color::*;
-            eprintln!("{RED}Error:{RESET} select field \"{}\" not found in {}", field.trim(), self.file);
+            eprintln!("{} select field \"{}\" not found in {}", ui::failure("Error:"), field.trim(), self.file);
             show_similar_selectors(&self.file, &document, &full_selector);
             process::exit(1);
           }
@@ -114,7 +122,7 @@ impl Args {
 
       let (values, selectors, lines): (Vec<yaml_serde::Value>, Vec<String>, Vec<usize>) = if select_fields.is_some() {
         if let Some(condition) = &normalized_condition {
-          let triples = document.filter_with_selectors(&search_path_string, condition);
+          let triples = document.filter_with_selectors(&search_path_string, condition).unwrap_or_default();
           let (values, rest): (Vec<_>, Vec<_>) = triples.into_iter().map(|(v, s, l)| (v, (s, l))).unzip();
           let (selectors, lines): (Vec<_>, Vec<_>) = rest.into_iter().unzip();
 
@@ -129,7 +137,7 @@ impl Args {
           (values, selectors, lines)
         }
       } else if let Some(condition) = &normalized_condition {
-        (document.filter(&search_path_string, condition), Vec::new(), Vec::new())
+        (document.filter(&search_path_string, condition).unwrap_or_default(), Vec::new(), Vec::new())
       } else {
         (document.get_values(&search_path_string), Vec::new(), Vec::new())
       };
@@ -180,10 +188,9 @@ impl Args {
     }
 
     if is_glob && all_results.is_empty() && normalized_condition.is_none() {
-      use super::color::*;
-
       eprintln!(
-        "{RED}Error:{RESET} selector \"{}\" not found in any of the {} files matching \"{}\"",
+        "{} selector \"{}\" not found in any of the {} files matching \"{}\"",
+        ui::failure("Error:"),
         self.selector,
         files.len(),
         self.file

data/rust/src/commands/init.rs

@@ -3,13 +3,13 @@ use std::process;
 
 use indoc::indoc;
 
-use super::color::*;
+use super::ui;
 
 pub fn run() {
   let filename = "Yerbafile";
 
   if Path::new(filename).exists() {
-    eprintln!("🧉 {YELLOW}{BOLD}Yerbafile already exists.{RESET}");
+    eprintln!("🧉 {}", ui::pending("Yerbafile already exists."));
     process::exit(1);
   }
 
@@ -81,9 +81,9 @@ pub fn run() {
   "#};
 
   std::fs::write(filename, content).unwrap_or_else(|error| {
-    eprintln!("{RED}Error:{RESET} writing Yerbafile: {}", error);
+    eprintln!("{} writing Yerbafile: {}", ui::failure("Error:"), error);
     process::exit(1);
   });
 
-  eprintln!("🧉 {GREEN}{BOLD}Created Yerbafile{RESET}");
+  eprintln!("🧉 {}", ui::success("Created Yerbafile"));
 }

data/rust/src/commands/insert.rs

@@ -1,3 +1,4 @@
+use super::ui;
 use std::sync::LazyLock;
 
 use indoc::indoc;
@@ -28,6 +29,7 @@ static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
 pub struct Args {
   file: String,
   selector: String,
+  #[arg(allow_hyphen_values = true)]
   value: Option<String>,
   #[arg(long, help = "Read value from a file (use - for stdin)")]
   from: Option<String>,
@@ -49,8 +51,8 @@ impl Args {
         let mut buffer = String::new();
 
         std::io::stdin().read_to_string(&mut buffer).unwrap_or_else(|error| {
-          use super::color::*;
-          eprintln!("{RED}Error:{RESET} reading stdin: {}", error);
+          use super::ui;
+          eprintln!("{} reading stdin: {}", ui::failure("Error:"), error);
 
           std::process::exit(1);
         });
@@ -59,8 +61,7 @@ impl Args {
       } else {
         std::fs::read_to_string(&from_path)
           .unwrap_or_else(|error| {
-            use super::color::*;
-            eprintln!("{RED}Error:{RESET} reading {}: {}", from_path, error);
+            eprintln!("{} reading {}: {}", ui::failure("Error:"), from_path, error);
             std::process::exit(1);
           })
           .trim()
@@ -69,8 +70,7 @@ impl Args {
     } else if let Some(val) = self.value {
       val
     } else {
-      use super::color::*;
-      eprintln!("{RED}Error:{RESET} either a value argument or --from is required");
+      eprintln!("{} either a value argument or --from is required", ui::failure("Error:"));
 
       std::process::exit(1);
     };

data/rust/src/commands/location.rs

@@ -28,13 +28,13 @@ pub struct Args {
 
 impl Args {
   pub fn run(self) {
-    use super::color::*;
+    use super::ui;
 
     let document = parse_file(&self.file);
     let info = document.get_node_info(&self.selector);
 
     if info.location.start_line == 0 && info.location.end_line == 0 {
-      eprintln!("{RED}Error:{RESET} selector \"{}\" not found in {}", self.selector, self.file);
+      eprintln!("{} selector \"{}\" not found in {}", ui::failure("Error:"), self.selector, self.file);
 
       super::show_similar_selectors(&self.file, &document, &self.selector);
       process::exit(1);

data/rust/src/commands/mate.rs

@@ -1,12 +1,12 @@
-use super::color::*;
+use super::ui;
 
 pub fn run() {
-  let g = GREEN;
-  let b = BOLD;
-  let d = DIM;
-  let i = "\x1b[3m"; // italic
-  let y = YELLOW;
-  let r = RESET;
+  let g = ui::raw::green();
+  let b = ui::raw::bold();
+  let d = ui::raw::dim();
+  let i = ui::raw::italic();
+  let y = ui::raw::yellow();
+  let r = ui::raw::reset();
   let hr = format!("    {d}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}\u{2500}{r}");
 
   println!();