yerba 0.8.0-arm-linux-gnu → 0.8.1-arm-linux-gnu

data/rust/src/commands/sort.rs

@@ -1,3 +1,4 @@
+use super::ui;
 use std::process;
 use std::sync::LazyLock;
 
@@ -53,14 +54,14 @@ fn is_explicit_reorder(orders: &[String]) -> bool {
 
 impl Args {
   pub fn run(self) {
-    use super::color::*;
+    use super::ui;
 
     if self.by.is_empty() && self.order.is_empty() && self.selector.is_none() {
       let document = parse_file(&self.file);
 
-      eprintln!("{RED}Error:{RESET} specify a selector, --by, or --order");
+      eprintln!("{} specify a selector, --by, or --order", ui::failure("Error:"));
       eprintln!();
-      eprintln!("  {BOLD}Examples:{RESET}");
+      eprintln!("  {}", ui::strong("Examples:"));
       eprintln!("    yerba sort \"{}\" \"tags\"", self.file);
       eprintln!("    yerba sort \"{}\" --by \".title\" --order asc", self.file);
       eprintln!();
@@ -80,10 +81,8 @@ impl Args {
   }
 
   fn show_values(self) {
-    use super::color::*;
-
     if self.by.len() != 1 {
-      eprintln!("{RED}Error:{RESET} --order is required when using --by");
+      eprintln!("{} --order is required when using --by", ui::failure("Error:"));
       process::exit(1);
     }
 
@@ -94,14 +93,14 @@ impl Args {
     let (labels, context_values, selector_display) = self.resolve_labels(&document, by, selector, &items_selector);
 
     let context_hint = if self.context.is_empty() {
-      format!("\n\n  {DIM}Add --context \".field\" to show additional fields alongside values{RESET}")
+      format!("\n\n  {}", ui::subtle("Add --context \".field\" to show additional fields alongside values"))
     } else {
       String::new()
     };
 
-    eprintln!("{RED}Error:{RESET} --order is required when using --by");
+    eprintln!("{} --order is required when using --by", ui::failure("Error:"));
     eprintln!();
-    eprintln!("  {BOLD}Current values (by {by}):{RESET}");
+    eprintln!("  {}", ui::strong(format!("Current values (by {}):", by)));
 
     for (index, label) in labels.iter().enumerate() {
       let context = context_values.get(index).map(|c| c.as_slice()).unwrap_or(&[]);
@@ -113,22 +112,20 @@ impl Args {
 
     eprintln!("{context_hint}");
     eprintln!();
-    eprintln!("  {BOLD}To sort alphabetically:{RESET}");
+    eprintln!("  {}", ui::strong("To sort alphabetically:"));
     eprintln!("    yerba sort \"{}\"{selector_display} --by \"{by}\" --order asc", self.file);
     eprintln!("    yerba sort \"{}\"{selector_display} --by \"{by}\" --order desc", self.file);
     eprintln!();
-    eprintln!("  {BOLD}To reorder explicitly:{RESET}");
+    eprintln!("  {}", ui::strong("To reorder explicitly:"));
     eprintln!("    yerba sort \"{}\"{selector_display} --by \"{by}\" --order \"{csv}\"", self.file);
     eprintln!();
-    eprintln!("  {BOLD}To move individual items:{RESET}");
+    eprintln!("  {}", ui::strong("To move individual items:"));
     eprintln!("    yerba move \"{}\"{selector_display} <item> --before/--after <target>", self.file);
 
     process::exit(1);
   }
 
   fn run_sort(self) {
-    use super::color::*;
-
     let selector = self.selector.as_deref().unwrap_or("");
 
     let sort_fields: Vec<yerba::SortField> = if self.by.is_empty() {
@@ -145,7 +142,7 @@ impl Args {
             Some("desc" | "descending") => yerba::SortField::desc(field),
             Some("asc" | "ascending") | None => yerba::SortField::asc(field),
             Some(other) => {
-              eprintln!("{RED}Error:{RESET} invalid sort direction \"{other}\". Use \"asc\" or \"desc\"");
+              eprintln!("{} invalid sort direction \"{other}\". Use \"asc\" or \"desc\"", ui::failure("Error:"));
               process::exit(1);
             }
           }
@@ -161,7 +158,7 @@ impl Args {
 
         match document.get_value(&first_item_selector) {
           Some(first) if first.is_mapping() => {
-            eprintln!("{RED}Error:{RESET} --by is required to sort a sequence of maps");
+            eprintln!("{} --by is required to sort a sequence of maps", ui::failure("Error:"));
             eprintln!();
 
             let selectors = document.selectors();
@@ -175,7 +172,7 @@ impl Args {
               .collect();
 
             if !fields.is_empty() {
-              eprintln!("  {BOLD}Available fields:{RESET}");
+              eprintln!("  {}", ui::strong("Available fields:"));
 
               for field in &fields {
                 let short = field.rsplit_once('.').map(|(_, f)| f).unwrap_or(field);
@@ -187,9 +184,9 @@ impl Args {
           }
 
           None if selector.is_empty() => {
-            eprintln!("{RED}Error:{RESET} no sequence found at root level in {}", resolved_file);
+            eprintln!("{} no sequence found at root level in {}", ui::failure("Error:"), resolved_file);
             eprintln!();
-            eprintln!("  {DIM}Specify a selector for the sequence to sort:{RESET}");
+            eprintln!("  {}", ui::subtle("Specify a selector for the sequence to sort:"));
             eprintln!("    yerba sort \"{}\" \"<selector>\"", self.file);
             eprintln!();
 
@@ -209,16 +206,14 @@ impl Args {
   }
 
   fn run_reorder(self) {
-    use super::color::*;
-
     if self.by.len() != 1 {
-      eprintln!("{RED}Error:{RESET} explicit --order requires exactly one --by field");
+      eprintln!("{} explicit --order requires exactly one --by field", ui::failure("Error:"));
 
       process::exit(1);
     }
 
     if self.order.len() != 1 {
-      eprintln!("{RED}Error:{RESET} explicit --order must be a single comma-separated list");
+      eprintln!("{} explicit --order must be a single comma-separated list", ui::failure("Error:"));
 
       process::exit(1);
     }
@@ -236,17 +231,17 @@ impl Args {
     let duplicates: Vec<&String> = labels.iter().filter(|label| !seen.insert(label.as_str())).collect();
 
     if !duplicates.is_empty() {
-      eprintln!("{RED}Error:{RESET} --order requires unique values for {by}, but found duplicates");
+      eprintln!("{} --order requires unique values for {by}, but found duplicates", ui::failure("Error:"));
       eprintln!();
-      eprintln!("  {BOLD}Duplicate values:{RESET}");
+      eprintln!("  {}", ui::strong("Duplicate values:"));
 
       for label in &duplicates {
         eprintln!("    {label}");
       }
 
       eprintln!();
-      eprintln!("  {DIM}Use \"yerba sort\" with --by instead to sort by field, or");
-      eprintln!("  choose a --by field with unique values (e.g. \".id\"){RESET}");
+      eprintln!("  {}", ui::subtle("Use \"yerba sort\" with --by instead to sort by field, or"));
+      eprintln!("  {}", ui::subtle("choose a --by field with unique values (e.g. \".id\")"));
 
       process::exit(1);
     }
@@ -256,16 +251,19 @@ impl Args {
     if !values_with_commas.is_empty() {
       let selector_display = if selector.is_empty() { String::new() } else { format!(" \"{selector}\"") };
 
-      eprintln!("{RED}Error:{RESET} some values for {by} contain commas, which conflicts with --order parsing");
+      eprintln!(
+        "{} some values for {by} contain commas, which conflicts with --order parsing",
+        ui::failure("Error:")
+      );
       eprintln!();
-      eprintln!("  {BOLD}Values with commas:{RESET}");
+      eprintln!("  {}", ui::strong("Values with commas:"));
 
       for label in &values_with_commas {
         eprintln!("    {label}");
       }
 
       eprintln!();
-      eprintln!("  {BOLD}Use yerba move to reorder individual items instead:{RESET}");
+      eprintln!("  {}", ui::strong("Use yerba move to reorder individual items instead:"));
       eprintln!("    yerba move \"{}\"{selector_display} <item> --before/--after <target>", self.file);
 
       process::exit(1);
@@ -277,28 +275,26 @@ impl Args {
     match document.reorder_items(container, by, &desired_order) {
       Ok(()) => output(&self.file, &document, self.dry_run),
       Err(error) => {
-        eprintln!("{RED}Error:{RESET} {}", error);
+        eprintln!("{} {}", ui::failure("Error:"), error);
         process::exit(1);
       }
     }
   }
 
   fn resolve_labels(&self, document: &yerba::Document, by: &str, selector: &str, items_selector: &str) -> (Vec<String>, Vec<Vec<String>>, String) {
-    use super::color::*;
-
     let items = document.get_values(items_selector);
 
     if items.is_empty() {
       if selector.is_empty() {
-        eprintln!("{RED}Error:{RESET} no sequence found at root level");
+        eprintln!("{} no sequence found at root level", ui::failure("Error:"));
         eprintln!();
-        eprintln!("  {DIM}If the file is a map, specify which sequence to sort:{RESET}");
+        eprintln!("  {}", ui::subtle("If the file is a map, specify which sequence to sort:"));
         eprintln!("    yerba sort \"{}\" \"<selector>\" --by \"{by}\" --order asc", self.file);
         eprintln!();
 
         super::show_similar_selectors(&self.file, document, "[]");
       } else {
-        eprintln!("{RED}Error:{RESET} no sequence found at selector: {selector}");
+        eprintln!("{} no sequence found at selector: {selector}", ui::failure("Error:"));
 
         super::show_similar_selectors(&self.file, document, selector);
       }
@@ -316,7 +312,7 @@ impl Args {
       };
 
       if !document.exists(&by_selector) {
-        eprintln!("{RED}Error:{RESET} field \"{by}\" not found in items");
+        eprintln!("{} field \"{by}\" not found in items", ui::failure("Error:"));
 
         super::show_similar_selectors(&self.file, document, &by_selector);
 
@@ -367,17 +363,15 @@ impl Args {
   }
 
   fn format_label_line(&self, index: usize, label: &str, context: &[String]) -> String {
-    use super::color::*;
-
     if context.is_empty() {
-      format!("{DIM}[{index}]{RESET} {label}")
+      format!("{} {}", ui::subtle(format!("[{}]", index)), label)
     } else {
       let context = context.iter().filter(|c| !c.is_empty()).cloned().collect::<Vec<_>>().join(", ");
 
       if context.is_empty() {
-        format!("{DIM}[{index}]{RESET} {label}")
+        format!("{} {}", ui::subtle(format!("[{}]", index)), label)
       } else {
-        format!("{DIM}[{index}]{RESET} {label}  {DIM}{context}{RESET}")
+        format!("{} {}  {}", ui::subtle(format!("[{}]", index)), label, ui::subtle(context))
       }
     }
   }

data/rust/src/commands/sort_keys.rs

@@ -1,3 +1,4 @@
+use super::ui;
 use std::process;
 use std::sync::LazyLock;
 
@@ -41,8 +42,7 @@ impl Args {
       let document = parse_file(resolved_file);
 
       if let Err(error) = document.validate_sort_keys(&self.selector, &key_order) {
-        use super::color::*;
-        eprintln!("{RED}Error in {}{RESET}: {}", resolved_file, error);
+        eprintln!("{}: {}", ui::failure(format!("Error in {}", resolved_file)), error);
         has_errors = true;
       }
     }

data/rust/src/commands/ui.rs

@@ -0,0 +1,157 @@
+use std::io::IsTerminal;
+use std::sync::OnceLock;
+
+fn colored() -> bool {
+  static COLORED: OnceLock<bool> = OnceLock::new();
+
+  *COLORED.get_or_init(|| {
+    if std::env::var_os("NO_COLOR").is_some() {
+      return false;
+    }
+
+    if std::env::var_os("CLICOLOR_FORCE").is_some_and(|value| value != "0") {
+      return true;
+    }
+
+    std::io::stderr().is_terminal() || super::is_github_actions()
+  })
+}
+
+#[derive(Clone, Copy)]
+pub struct Color(&'static str);
+
+pub const GREEN: Color = Color("32");
+pub const YELLOW: Color = Color("33");
+pub const RED: Color = Color("31");
+pub const CYAN: Color = Color("36");
+
+pub struct Style {
+  color: Option<Color>,
+  bold: bool,
+  dim: bool,
+}
+
+impl Style {
+  pub const fn plain() -> Self {
+    Style {
+      color: None,
+      bold: false,
+      dim: false,
+    }
+  }
+
+  pub const fn fg(color: Color) -> Self {
+    Style {
+      color: Some(color),
+      bold: false,
+      dim: false,
+    }
+  }
+
+  pub const fn bold(mut self) -> Self {
+    self.bold = true;
+    self
+  }
+
+  pub const fn dim(mut self) -> Self {
+    self.dim = true;
+    self
+  }
+
+  pub fn paint(&self, text: impl std::fmt::Display) -> String {
+    if !colored() {
+      return text.to_string();
+    }
+
+    let mut codes: Vec<&str> = Vec::new();
+
+    if self.bold {
+      codes.push("1");
+    }
+
+    if self.dim {
+      codes.push("2");
+    }
+
+    if let Some(color) = &self.color {
+      codes.push(color.0);
+    }
+
+    if codes.is_empty() {
+      return text.to_string();
+    }
+
+    format!("\x1b[{}m{}\x1b[0m", codes.join(";"), text)
+  }
+}
+
+pub fn success(text: impl std::fmt::Display) -> String {
+  Style::fg(GREEN).bold().paint(text)
+}
+
+pub fn pending(text: impl std::fmt::Display) -> String {
+  Style::fg(YELLOW).bold().paint(text)
+}
+
+pub fn failure(text: impl std::fmt::Display) -> String {
+  Style::fg(RED).bold().paint(text)
+}
+
+pub fn muted(text: impl std::fmt::Display) -> String {
+  Style::fg(CYAN).paint(text)
+}
+
+pub fn subtle(text: impl std::fmt::Display) -> String {
+  Style::plain().dim().paint(text)
+}
+
+pub fn strong(text: impl std::fmt::Display) -> String {
+  Style::plain().bold().paint(text)
+}
+
+pub fn banner() -> String {
+  format!("🧉 {} {}", Style::fg(GREEN).bold().paint("yerba"), subtle(format!("v{}", yerba::version())))
+}
+
+pub const INDENT: &str = "   ";
+pub const STATUS_INDENT: &str = "  ";
+
+pub mod glyph {
+  pub const OK: &str = "✓";
+  pub const PENDING: &str = "~";
+  pub const FAIL: &str = "✗";
+}
+
+pub mod raw {
+  fn sequence(code: &'static str) -> &'static str {
+    if super::colored() {
+      code
+    } else {
+      ""
+    }
+  }
+
+  pub fn green() -> &'static str {
+    sequence("\x1b[32m")
+  }
+
+  pub fn yellow() -> &'static str {
+    sequence("\x1b[33m")
+  }
+
+  pub fn bold() -> &'static str {
+    sequence("\x1b[1m")
+  }
+
+  pub fn dim() -> &'static str {
+    sequence("\x1b[2m")
+  }
+
+  pub fn italic() -> &'static str {
+    sequence("\x1b[3m")
+  }
+
+  pub fn reset() -> &'static str {
+    sequence("\x1b[0m")
+  }
+}

data/rust/src/commands/unique.rs

@@ -37,7 +37,7 @@ pub struct Args {
 
 impl Args {
   pub fn run(self) {
-    use super::color::*;
+    use super::ui;
 
     let selector = self.selector.as_deref().unwrap_or("");
     let by = self.by.as_deref().unwrap_or(".");
@@ -50,20 +50,20 @@ impl Args {
           let noun = if duplicates.len() == 1 { "duplicate" } else { "duplicates" };
 
           if duplicates.is_empty() {
-            eprintln!("{GREEN}No duplicates found{RESET} in {}", resolved_file);
+            eprintln!("{} in {}", ui::success("No duplicates found"), resolved_file);
           } else if self.remove {
-            eprintln!("{YELLOW}Removed {} {noun}{RESET} from {}", duplicates.len(), resolved_file);
+            eprintln!("{} from {}", ui::pending(format!("Removed {} {noun}", duplicates.len())), resolved_file);
 
             for duplicate in &duplicates {
-              eprintln!("  {DIM}line {}: {} == {}{RESET}", duplicate.line, by, duplicate.value);
+              eprintln!("  {}", ui::subtle(format!("line {}: {} == {}", duplicate.line, by, duplicate.value)));
             }
 
             output(&resolved_file, &document, self.dry_run);
           } else {
-            eprintln!("{RED}Found {} {noun}{RESET} in {}", duplicates.len(), resolved_file);
+            eprintln!("{} in {}", ui::failure(format!("Found {} {noun}", duplicates.len())), resolved_file);
 
             for duplicate in &duplicates {
-              eprintln!("  {DIM}line {}: {} == {}{RESET}", duplicate.line, by, duplicate.value);
+              eprintln!("  {}", ui::subtle(format!("line {}: {} == {}", duplicate.line, by, duplicate.value)));
             }
 
             process::exit(1);
@@ -71,7 +71,7 @@ impl Args {
         }
 
         Err(error) => {
-          eprintln!("{RED}Error:{RESET} {}", error);
+          eprintln!("{} {}", ui::failure("Error:"), error);
           process::exit(1);
         }
       }

data/rust/src/commands/version.rs

@@ -1,8 +1,18 @@
-use super::color::*;
+use super::ui;
 
 pub fn run() {
-  println!("🧉 {BOLD}yerba{RESET} {DIM}v{}{RESET}", yerba::version());
+  println!("{}", ui::banner());
   println!(
-    "   {BOLD}Y{RESET}{DIM}AML{RESET} {BOLD}E{RESET}{DIM}diting and{RESET} {BOLD}R{RESET}{DIM}efactoring with{RESET} {BOLD}B{RESET}{DIM}etter{RESET} {BOLD}A{RESET}{DIM}ccuracy{RESET}"
+    "   {}{} {}{} {}{} {}{} {}{}",
+    ui::strong("Y"),
+    ui::subtle("AML"),
+    ui::strong("E"),
+    ui::subtle("diting and"),
+    ui::strong("R"),
+    ui::subtle("efactoring with"),
+    ui::strong("B"),
+    ui::subtle("etter"),
+    ui::strong("A"),
+    ui::subtle("ccuracy")
   );
 }

data/rust/src/document/insert.rs

@@ -570,6 +570,10 @@ impl Document {
     let is_block_value = value.contains('\n') || value.starts_with("- ");
 
     if !is_block_value {
+      if !crate::syntax::is_valid_inline_value(value) {
+        return format!("{}: {}", key, crate::syntax::quote_if_needed(value));
+      }
+
       return format!("{}: {}", key, value);
     }
 

data/rust/src/document/mod.rs

@@ -1,13 +1,17 @@
 mod condition;
-pub use condition::{validate_condition, validate_item_condition};
 mod delete;
 mod get;
 mod insert;
-mod schema;
 mod set;
 mod sort;
-pub mod style;
 mod unique;
+
+#[cfg(feature = "schema")]
+mod schema;
+
+pub mod style;
+
+pub use condition::{validate_condition, validate_item_condition};
 pub use unique::DuplicateInfo;
 
 use crate::syntax::YerbaValueType;

data/rust/src/document/set.rs

@@ -1,5 +1,13 @@
 use super::*;
 
+fn scalar_replacement_text(value: &str, kind: SyntaxKind) -> String {
+  if kind == SyntaxKind::PLAIN_SCALAR && !crate::syntax::is_inline_scalar_safe(value) {
+    return format_scalar_value(value, SyntaxKind::DOUBLE_QUOTED_SCALAR);
+  }
+
+  format_scalar_value(value, kind)
+}
+
 fn holds_collection(node: &SyntaxNode) -> bool {
   node.descendants().any(|descendant| {
     matches!(
@@ -84,7 +92,7 @@ impl Document {
 
     let scalar_token = find_scalar_token(&current_node).ok_or_else(|| YerbaError::SelectorNotFound(dot_path.to_string()))?;
 
-    let new_text = format_scalar_value(value, scalar_token.kind());
+    let new_text = scalar_replacement_text(value, scalar_token.kind());
 
     self.replace_token(&scalar_token, &new_text)
   }
@@ -107,7 +115,7 @@ impl Document {
           edits.push((span.range, replacement_text(&span, value)));
         }
       } else if let Some(scalar_token) = find_scalar_token(&node) {
-        edits.push((scalar_token.text_range(), format_scalar_value(value, scalar_token.kind())));
+        edits.push((scalar_token.text_range(), scalar_replacement_text(value, scalar_token.kind())));
       }
     }
 

data/rust/src/error.rs

@@ -10,6 +10,7 @@ pub enum YerbaError {
   IndexOutOfBounds(usize, usize),
   UnknownKeys(Vec<String>),
   DuplicateValues(Vec<crate::DuplicateInfo>),
+  #[cfg(feature = "schema")]
   SchemaValidation(Vec<crate::schema::ValidationError>),
   DuplicateKey {
     key: String,
@@ -78,6 +79,7 @@ impl std::fmt::Display for YerbaError {
         write!(f, "index {} out of bounds (length {})", index, length)
       }
 
+      #[cfg(feature = "schema")]
       YerbaError::SchemaValidation(errors) => {
         let details: Vec<String> = errors.iter().map(|error| error.to_string()).collect();
 
@@ -137,6 +139,7 @@ impl GitHubAnnotations for YerbaError {
         })
         .collect(),
 
+      #[cfg(feature = "schema")]
       YerbaError::SchemaValidation(errors) => errors
         .iter()
         .map(|error| GitHubAnnotation {

data/rust/src/ffi.rs

@@ -746,6 +746,7 @@ pub unsafe extern "C" fn yerba_document_blank_lines(document: *mut Document, pat
 }
 
 /// Caller must free with yerba_string_free.
+#[cfg(feature = "schema")]
 #[no_mangle]
 pub unsafe extern "C" fn yerba_document_validate_schema(document: *const Document, schema_json: *const c_char, selector: *const c_char) -> *mut c_char {
   let document = &*document;
@@ -784,6 +785,7 @@ pub unsafe extern "C" fn yerba_document_validate_schema(document: *const Documen
 }
 
 /// Caller must free with yerba_string_free.
+#[cfg(feature = "cli")]
 #[no_mangle]
 pub unsafe extern "C" fn yerba_yerbafile_find(directory: *const c_char) -> *mut c_char {
   let start = if directory.is_null() {
@@ -803,6 +805,7 @@ pub unsafe extern "C" fn yerba_yerbafile_find(directory: *const c_char) -> *mut
   }
 }
 
+#[cfg(feature = "cli")]
 #[no_mangle]
 pub unsafe extern "C" fn yerba_document_apply_yerbafile(document: *mut Document, file_path: *const c_char, yerbafile_path: *const c_char) -> YerbaResult {
   let document = &mut *document;
@@ -924,6 +927,7 @@ fn located_nodes_to_list(nodes: &[crate::LocatedNode]) -> YerbaTypedList {
   }
 }
 
+#[cfg(feature = "glob")]
 #[no_mangle]
 pub unsafe extern "C" fn yerba_glob_get(glob_pattern: *const c_char, path: *const c_char) -> YerbaTypedList {
   let pattern = CStr::from_ptr(glob_pattern).to_str().unwrap_or("");
@@ -940,6 +944,7 @@ pub unsafe extern "C" fn yerba_document_get_all(document: *const Document, path:
   located_nodes_to_list(&document.get_all_located(selector_string))
 }
 
+#[cfg(feature = "glob")]
 #[no_mangle]
 pub unsafe extern "C" fn yerba_glob_find(glob_pattern: *const c_char, path: *const c_char, condition: *const c_char, select: *const c_char) -> YerbaTypedList {
   let pattern = CStr::from_ptr(glob_pattern).to_str().unwrap_or("");

data/rust/src/lib.rs

@@ -4,10 +4,12 @@ pub mod error;
 pub mod ffi;
 pub mod json;
 mod quote_style;
+#[cfg(feature = "schema")]
 pub mod schema;
 pub mod selector;
 mod syntax;
 mod yaml_writer;
+#[cfg(feature = "cli")]
 pub mod yerbafile;
 
 pub use document::style::StyleEnforcement;
@@ -17,8 +19,12 @@ pub use document::{
 pub use error::YerbaError;
 pub use quote_style::{KeyStyle, QuoteStyle};
 pub use selector::Selector;
-pub use syntax::{detect_yaml_type, ScalarValue, YerbaValueType};
+pub use syntax::{
+  detect_yaml_type, is_flow_collection, is_inline_scalar_safe, is_plain_safe, is_plain_safe_in_flow, is_quoted_scalar, is_raw_yaml_text, is_valid_inline_value,
+  needs_quoting, needs_quoting_in_flow, quote_if_needed, ScalarValue, YerbaValueType,
+};
 pub use yaml_writer::json_to_yaml_text;
+#[cfg(feature = "cli")]
 pub use yerbafile::Yerbafile;
 
 pub fn version() -> &'static str {
@@ -33,6 +39,7 @@ pub fn parse_file(path: impl AsRef<std::path::Path>) -> Result<Document, YerbaEr
   Document::parse_file(path)
 }
 
+#[cfg(feature = "glob")]
 pub fn glob_get(pattern: &str, selector: &str) -> Vec<document::LocatedNode> {
   use rayon::prelude::*;
 
@@ -55,6 +62,7 @@ pub fn glob_get(pattern: &str, selector: &str) -> Vec<document::LocatedNode> {
     .collect()
 }
 
+#[cfg(feature = "glob")]
 pub fn glob_find(pattern: &str, selector: &str, condition: Option<&str>, select: Option<&str>) -> Result<Vec<serde_json::Value>, YerbaError> {
   use rayon::prelude::*;