yerba 0.7.5 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d03e5cb5c88654843c8c86735f91d1e550e81282ccd1c0db8813527c4b4f9898
-  data.tar.gz: 805516b5ce364c09dab736e562f4a09d312d70b75ceb2c9e22a9e63fad45eb6d
+  metadata.gz: ef6a9038318ee4d534952892c7893d4deffc0980da76ad2967996ade55c5c4ed
+  data.tar.gz: 4c8ae4131876cbbefdfe0ab13bb2c8624161f07332e05dea0287f4a5eb313040
 SHA512:
-  metadata.gz: 9cb2ace3f935a023bdd938cde43010f158efc18fce052a7fe5780cf3f9362779d0bc66a463f60453586b24e0b2e6b2ed180cf7d71d2f99095b57d0eb2adc92d8
-  data.tar.gz: a4946b677d5b05d2741a09749e540056376dc2d2724f12bc383d722974638576bfdf022a9a02587c75b4167d9d9ae644ddcb45ed6d3f86167423c8d7263c7ba3
+  metadata.gz: c8bbc570ef74e8ec8b63cf97ed16d3cd1497ad9d7a77a9b09ace07b3418c9e8f592bcccad2929f33341ecb547411ea2cb3387f905963b86bd5c37e324ff5931f
+  data.tar.gz: 751785bf9a917245bf914e30cbf0b2bbcf1608be37c3a3d573a94e1f27fbab8fc245d2fc16efae0582e22e670aa5437975fda12bf8075ec15fc6249f697f0dd3

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`
@@ -539,6 +544,7 @@ Available pipeline steps:
 - `directives` Add or remove the document start marker (`---`), with optional `max` validation
 - `unique` Find or remove duplicate items in a sequence
 - `schema` Validate against a JSON schema (with optional `path` for scoping)
+- `final_newline` Enforce exact number of trailing newlines (`count: 1` by default, strips extras)
 
 This makes it easy to enforce project-wide YAML conventions in CI:
 
@@ -700,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
@@ -828,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:
@@ -892,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.5"
+  VERSION = "0.8.0"
 end

data/rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "yerba"
-version = "0.7.5"
+version = "0.8.0"
 edition = "2021"
 authors = ["Marco Roth <marco.roth@intergga.ch>"]
 description = "YAML Editing and Refactoring with Better Accuracy"

data/rust/src/commands/get.rs

@@ -62,6 +62,16 @@ impl Args {
       condition.clone()
     });
 
+    if let Some(condition) = &normalized_condition {
+      if let Err(error) = yerba::validate_item_condition(condition) {
+        use super::color::*;
+
+        eprintln!("{RED}Error:{RESET} {}", 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);
@@ -114,7 +124,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 +139,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())
       };

data/rust/src/commands/rename.rs

@@ -8,15 +8,15 @@ use super::{output, parse_file, resolve_files, run_op};
 static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
   colorize_examples(indoc! {r#"
     yerba rename config.yml "database.host" "database.hostname"
-    yerba rename config.yml "database.host" "hostname"
-    yerba rename config.yml "database.host" "settings.db_host"
     yerba rename videos.yml "[0].old_name" "[0].name"
+    yerba rename config.yml "database.host" "settings.db_host"  # moves the key to another map
+    yerba rename config.yml "database.host" "hostname"          # moves the key to the document root
   "#})
 });
 
 #[derive(clap::Args)]
 #[command(
-  about = "Rename a key in a map (preserves value and position)",
+  about = "Rename a key, or move it to another map (the destination is a full selector path)",
   arg_required_else_help = true,
   after_help = EXAMPLES.as_str()
 )]

data/rust/src/commands/set.rs

@@ -42,6 +42,16 @@ impl Args {
   pub fn run(self) {
     let parent_path = self.selector.rsplit_once('.').map(|(parent, _)| parent).unwrap_or("");
 
+    if let Some(condition) = &self.condition {
+      if let Err(error) = yerba::validate_condition(condition) {
+        use super::color::*;
+
+        eprintln!("{RED}Error:{RESET} {}", error);
+
+        std::process::exit(1);
+      }
+    }
+
     for resolved_file in resolve_files(&self.file) {
       let mut document = parse_file(&resolved_file);
 
@@ -50,7 +60,7 @@ impl Args {
       } else if self.if_missing {
         !document.exists(&self.selector)
       } else if let Some(condition) = &self.condition {
-        document.evaluate_condition(parent_path, condition)
+        document.evaluate_condition(parent_path, condition).unwrap_or(false)
       } else {
         true
       };

data/rust/src/document/condition.rs

@@ -1,29 +1,83 @@
 use super::*;
 
+const CONDITION_OPERATORS: &str = "expected `<selector> <operator> <value>`, where operator is one of ==, !=, contains, not_contains";
+
+pub fn validate_condition(condition: &str) -> Result<(), YerbaError> {
+  let trimmed = condition.trim();
+
+  if trimmed.is_empty() {
+    return Err(YerbaError::InvalidCondition(condition.to_string(), "condition is empty".to_string()));
+  }
+
+  let Some((left, _operator, _right)) = parse_condition(trimmed) else {
+    return Err(YerbaError::InvalidCondition(condition.to_string(), CONDITION_OPERATORS.to_string()));
+  };
+
+  if crate::selector::Selector::parse(&left).is_empty() {
+    return Err(YerbaError::InvalidCondition(
+      condition.to_string(),
+      "condition is missing a selector on the left of the operator".to_string(),
+    ));
+  }
+
+  Ok(())
+}
+
+pub fn validate_item_condition(condition: &str) -> Result<(), YerbaError> {
+  validate_condition(condition)?;
+
+  let trimmed = condition.trim();
+
+  let Some((left, _operator, _right)) = parse_condition(trimmed) else {
+    return Ok(());
+  };
+
+  if !crate::selector::Selector::parse(&left).is_relative() {
+    return Err(YerbaError::InvalidCondition(
+      condition.to_string(),
+      format!(
+        "selector \"{}\" is absolute, but this condition is tested against each item, so it must be relative and start with `.` — did you mean \".{}\"?",
+        left.trim(),
+        left.trim()
+      ),
+    ));
+  }
+
+  Ok(())
+}
+
 impl Document {
-  pub fn filter(&self, dot_path: &str, condition: &str) -> Vec<yaml_serde::Value> {
-    self
-      .navigate_all_compact(dot_path)
-      .iter()
-      .filter(|node| self.evaluate_condition_on_node(node, condition))
-      .map(node_to_yaml_value)
-      .collect()
+  pub fn filter(&self, dot_path: &str, condition: &str) -> Result<Vec<yaml_serde::Value>, YerbaError> {
+    validate_item_condition(condition)?;
+
+    Ok(
+      self
+        .navigate_all_compact(dot_path)
+        .iter()
+        .filter(|node| self.evaluate_condition_on_node(node, condition))
+        .map(node_to_yaml_value)
+        .collect(),
+    )
   }
 
-  pub fn filter_with_selectors(&self, dot_path: &str, condition: &str) -> Vec<(yaml_serde::Value, String, usize)> {
+  pub fn filter_with_selectors(&self, dot_path: &str, condition: &str) -> Result<Vec<(yaml_serde::Value, String, usize)>, YerbaError> {
+    validate_item_condition(condition)?;
+
     let source = self.source_text();
 
-    self
-      .navigate_all_compact(dot_path)
-      .iter()
-      .filter(|node| self.evaluate_condition_on_node(node, condition))
-      .map(|node| {
-        let offset: usize = node.text_range().start().into();
-        let line = line_at(&source, offset);
-
-        (node_to_yaml_value(node), super::get::node_selector(node), line)
-      })
-      .collect()
+    Ok(
+      self
+        .navigate_all_compact(dot_path)
+        .iter()
+        .filter(|node| self.evaluate_condition_on_node(node, condition))
+        .map(|node| {
+          let offset: usize = node.text_range().start().into();
+          let line = line_at(&source, offset);
+
+          (node_to_yaml_value(node), super::get::node_selector(node), line)
+        })
+        .collect(),
+    )
   }
 
   pub(super) fn evaluate_condition_on_node(&self, node: &SyntaxNode, condition: &str) -> bool {
@@ -84,31 +138,32 @@ impl Document {
     }
   }
 
-  pub fn evaluate_condition(&self, parent_path: &str, condition: &str) -> bool {
+  pub fn evaluate_condition(&self, parent_path: &str, condition: &str) -> Result<bool, YerbaError> {
+    if parent_path.is_empty() {
+      validate_condition(condition)?;
+    } else {
+      validate_item_condition(condition)?;
+    }
+
     let condition = condition.trim();
 
     let (left, operator, right) = match parse_condition(condition) {
       Some(parts) => parts,
-      None => return false,
+      None => return Ok(false),
     };
 
     let path = crate::selector::Selector::parse(&left);
+    let path_string = path.to_selector_string();
 
-    let full_path = if path.is_relative() {
-      let path_string = path.to_selector_string();
-
-      if parent_path.is_empty() {
-        path_string
-      } else {
-        format!("{}.{}", parent_path, path_string)
-      }
+    let full_path = if parent_path.is_empty() {
+      path_string
     } else {
-      path.to_selector_string()
+      format!("{}.{}", parent_path, path_string)
     };
 
     let has_brackets = crate::selector::Selector::parse(&full_path).has_brackets();
 
-    match operator {
+    let result = match operator {
       "==" => {
         if has_brackets {
           self.get_all(&full_path).iter().any(|value| value == &right)
@@ -150,6 +205,8 @@ impl Document {
         }
       }
       _ => false,
-    }
+    };
+
+    Ok(result)
   }
 }