yerba 0.10.0-arm-linux-gnu → 0.10.1-arm-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7789ff3de901f30948a18b6cfd0c212338cc61745571c00d831f06b11e6ba20e
-  data.tar.gz: 56b6aeb3fa2581196fc1263757938de9e91293e1e0ec41688ceeddf5ecb514b8
+  metadata.gz: 42897dffe011fcd43e99b7a67d1de70053e906cf3a3653537d2badf2163cc5fe
+  data.tar.gz: d3c63fa95e77e6b66c2994d72477e82579e9e86643fd29517d94d2377848b8ea
 SHA512:
-  metadata.gz: 260346f5d5148442585ec2b000a83c12c807213d0d1a34b3e607ff881f3a8514820cfa895a3591bc042590ac50553f5236af132a7bb32ae34ba817cb96f6f04f
-  data.tar.gz: 0f3658ebc475a23e90af6b70682dee1502994c6fcb9fc48fd266d7dfbb164b975af6e5ed8da07dc68c9c0d54b077af483700bd55f8b43848875260ba84f867b4
+  metadata.gz: 13b1ba3cd623e233181ddb6282e792a431b7fdba77b00342d1b1c0a7fe8e6d7f97b6db887d9880c537122421f0fbef8b5d0a2bc23719a4847e9d15dfccf7eada
+  data.tar.gz: 122d6d4d6cefa4a5ed626d90a03b9eac73d5d5715bf46292c61b500844b771a8c8a77dc19a8d5adda027a2014559d7574069b2ef01f100058d9712c60861e3a0

data/README.md

@@ -300,6 +300,17 @@ yerba sort videos.yml --by ".date" --order desc --by ".title"
 yerba sort videos.yml "[].speakers" --by ".name"
 ```
 
+Items without a value for a sort field sort as an empty value, so they come first. Use `--missing` to decide what happens to them instead:
+
+- `first` or `last` puts a missing value before or after the present ones, comparing one field at a time like SQL's `NULLS FIRST` and `NULLS LAST`. Sorted by `.date` and `.start_time`, a talk without a time goes first or last within its date.
+- `keep` leaves items with a missing value where they are and sorts the other items around them.
+- `skip` leaves the whole sequence unsorted if any item has a missing value.
+
+
+```bash
+yerba sort videos.yml --by ".date" --by ".start_time" --missing keep
+```
+
 Use `--order` with a comma-separated list to specify an explicit custom order. All items must be listed:
 
 ```bash
@@ -582,6 +593,8 @@ pipeline:
 
 rules:
   - files: "data/**/videos.yml"
+    exclude:
+      - "data/archive/**/videos.yml"
     pipeline:
       - quote_style:
           selector: "[].speakers"
@@ -607,7 +620,7 @@ rules:
           by: name
 ```
 
-Rules and steps take a `selector` to scope them. `path` is still accepted as the older name for it.
+Rules and steps take a `selector` to scope them. `path` is still accepted as the older name for it. A rule's `exclude` takes a glob or a list of globs for files the rule skips.
 
 Available pipeline steps:
 
@@ -615,7 +628,7 @@ Available pipeline steps:
 - `collection_style` Enforce flow or block style on collections
 - `sequence_indent` Enforce compact or indented sequence style
 - `sort_keys` Reorder keys to match a predefined list
-- `sort` Sort sequence items by field(s), `by: ".date,.start_time"` or `by: ".date .start_time"` for tie-breakers
+- `sort` Sort sequence items by field(s), `by: ".date,.start_time"` or `by: ".date .start_time"` for tie-breakers, and `missing: first`, `last`, `keep` or `skip` for items without a value
 - `blank_lines` Enforce blank lines between sequence entries, optionally limited to named map keys with `before` and to non-empty values with `skip_empty`
 - `set` Set a value (supports conditions, and `plain: true` for YAML literals)
 - `insert` Insert a new key or sequence item (`plain: true` for YAML literals and fragments)
@@ -916,6 +929,12 @@ The `by:` option accepts symbols, strings, or dot-prefixed strings (`:name`, `"n
 
 The `order:` option is `:asc`, `:desc`, or an explicit order of values as an Array or comma-separated String.
 
+The `missing:` option decides what happens to items without a value for a sort field: `:first` or `:last` put the missing value before or after the present ones for each field, `:keep` leaves those items in place and sorts the others into the remaining positions, and `:skip` leaves the sequence unsorted if any value is missing. Without it, a missing value sorts as an empty string.
+
+```ruby
+document.sort(by: [:date, :start_time], missing: :keep)
+```
+
 ### Querying
 
 Find and filter items in sequences with `find_by`, `where`, and `pluck`:

data/ext/yerba/include/yerba.h

@@ -211,7 +211,8 @@ struct YerbaResult yerba_document_rename(struct Document *document,
 struct YerbaResult yerba_document_sort(struct Document *document,
                                        const char *selector,
                                        const char *by,
-                                       bool case_sensitive);
+                                       bool case_sensitive,
+                                       const char *missing);
 
 struct YerbaResult yerba_document_reorder(struct Document *document,
                                           const char *selector,

data/ext/yerba/yerba.c

@@ -902,10 +902,11 @@ static VALUE document_rename(VALUE self, VALUE source, VALUE destination) {
   return self;
 }
 
-/* document.sort(selector = "", by: nil, order: nil, case_sensitive: false)
+/* document.sort(selector = "", by: nil, order: nil, case_sensitive: false, missing: nil)
  *
  * by:    a field, several fields separated by commas or spaces, or an Array of fields
  * order: :asc, :desc, or an explicit order of values (Array or comma-separated String)
+ * missing: :first, :last, :keep or :skip, for items without a value for a sort field
  */
 static VALUE document_sort(int argc, VALUE *argv, VALUE self) {
   VALUE selector, opts;
@@ -917,6 +918,7 @@ static VALUE document_sort(int argc, VALUE *argv, VALUE self) {
   VALUE order_csv = Qnil;
   bool descending = false;
   bool case_sensitive = false;
+  VALUE missing_value = Qnil;
 
   if (!NIL_P(opts)) {
     VALUE v_by = rb_hash_aref(opts, ID2SYM(rb_intern("by")));
@@ -947,11 +949,20 @@ static VALUE document_sort(int argc, VALUE *argv, VALUE self) {
     if (RTEST(v_case_sensitive)) {
       case_sensitive = true;
     }
+
+    VALUE v_missing = rb_hash_aref(opts, ID2SYM(rb_intern("missing")));
+
+    if (SYMBOL_P(v_missing)) {
+      missing_value = rb_sym2str(v_missing);
+    } else if (!NIL_P(v_missing)) {
+      missing_value = rb_obj_as_string(v_missing);
+    }
   }
 
   struct Document *document = get_document(self);
   const char *path_string = StringValueCStr(selector);
   const char *by = NIL_P(by_value) ? NULL : StringValueCStr(by_value);
+  const char *missing = NIL_P(missing_value) ? NULL : StringValueCStr(missing_value);
 
   if (!NIL_P(order_csv)) {
     YerbaResult result = yerba_document_reorder(document, path_string, by ? by : ".", StringValueCStr(order_csv));
@@ -970,11 +981,12 @@ static VALUE document_sort(int argc, VALUE *argv, VALUE self) {
     by = StringValueCStr(by_with_order);
   }
 
-  YerbaResult result = yerba_document_sort(document, path_string, by, case_sensitive);
+  YerbaResult result = yerba_document_sort(document, path_string, by, case_sensitive, missing);
   check_result(result);
 
   RB_GC_GUARD(by_value);
   RB_GC_GUARD(by_with_order);
+  RB_GC_GUARD(missing_value);
 
   return self;
 }

data/lib/yerba/sequence.rb

@@ -268,8 +268,8 @@ module Yerba
       self
     end
 
-    def sort(by: nil, order: nil, case_sensitive: false)
-      document&.sort(@selector, by: by, order: order, case_sensitive: case_sensitive)
+    def sort(by: nil, order: nil, case_sensitive: false, missing: nil)
+      document&.sort(@selector, by: by, order: order, case_sensitive: case_sensitive, missing: missing)
 
       self
     end

data/lib/yerba/version.rb

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

data/rust/Cargo.lock

@@ -1431,7 +1431,7 @@ dependencies = [
 
 [[package]]
 name = "yerba"
-version = "0.10.0"
+version = "0.10.1"
 dependencies = [
  "anstyle-query",
  "cbindgen",

data/rust/Cargo.toml

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

data/rust/src/commands/sort.rs

@@ -12,6 +12,7 @@ static EXAMPLES: LazyLock<String> = LazyLock::new(|| {
     yerba sort config.yml "tags"
     yerba sort videos.yml --by ".title"
     yerba sort videos.yml --by ".date" --order desc --by ".title"
+    yerba sort videos.yml --by ".date" --by ".start_time" --missing keep
     yerba sort videos.yml "[].speakers" --by ".name"
     yerba sort videos.yml "[]" --by ".id" --order "talk-3,talk-1,talk-2"
     yerba sort speakers.yml "[]" --by ".name" --order "Charlie,Alice,Bob"
@@ -40,6 +41,9 @@ pub struct Args {
   /// Case-sensitive sort (default: case-insensitive)
   #[arg(long)]
   case_sensitive: bool,
+  /// Items without a value for a sort field: first, last, keep (stay in place) or skip (leave the sequence unsorted)
+  #[arg(long)]
+  missing: Option<yerba::SortMissing>,
   #[arg(long)]
   dry_run: bool,
 }
@@ -199,7 +203,7 @@ impl Args {
         }
       }
 
-      if document.sort_items(selector, &sort_fields, self.case_sensitive).is_ok() {
+      if document.sort_items_with(selector, &sort_fields, self.case_sensitive, self.missing).is_ok() {
         output(&resolved_file, &document, self.dry_run);
       }
     }

data/rust/src/document/mod.rs

@@ -116,6 +116,29 @@ impl SortField {
   }
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum SortMissing {
+  First,
+  Last,
+  Keep,
+  Skip,
+}
+
+impl std::str::FromStr for SortMissing {
+  type Err = String;
+
+  fn from_str(input: &str) -> Result<Self, Self::Err> {
+    match input {
+      "first" => Ok(SortMissing::First),
+      "last" => Ok(SortMissing::Last),
+      "keep" => Ok(SortMissing::Keep),
+      "skip" => Ok(SortMissing::Skip),
+      _ => Err(format!("unknown missing: {} (expected first, last, keep or skip)", input)),
+    }
+  }
+}
+
 #[repr(C)]
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum NodeType {
@@ -849,6 +872,7 @@ pub(crate) fn navigate_from_node(node: &SyntaxNode, selector: &str) -> Vec<Synta
 pub(crate) struct EntryGroup {
   pub(crate) separator: String,
   pub(crate) preceding: String,
+  pub(crate) gap: String,
   pub(crate) body: String,
 }
 
@@ -857,7 +881,7 @@ impl EntryGroup {
     if self.preceding.is_empty() {
       self.body.clone()
     } else {
-      format!("{}\n{}", self.preceding, self.body)
+      format!("{}{}{}", self.preceding, self.gap, self.body)
     }
   }
 }
@@ -892,15 +916,17 @@ fn collect_entry_groups(parent: &SyntaxNode) -> Vec<EntryGroup> {
       let entry_text = child.as_node().unwrap().text().to_string();
 
       if groups.is_empty() {
-        let preceding = buffer.trim_start_matches('\n').to_string();
+        let (preceding, gap) = split_gap(buffer.trim_start_matches('\n'));
 
         groups.push(EntryGroup {
           separator: String::new(),
           preceding,
+          gap,
           body: entry_text,
         });
       } else {
         let (trailing, separator, preceding) = split_at_blank_line(&buffer);
+        let (preceding, gap) = split_gap(&preceding);
 
         if let Some(last) = groups.last_mut() {
           last.body.push_str(&trailing);
@@ -909,6 +935,7 @@ fn collect_entry_groups(parent: &SyntaxNode) -> Vec<EntryGroup> {
         groups.push(EntryGroup {
           separator,
           preceding,
+          gap,
           body: entry_text,
         });
       }
@@ -947,7 +974,7 @@ fn split_at_blank_line(text: &str) -> (String, String, String) {
     let rest = &text[position..];
     let content_start = rest.len() - rest.trim_start_matches('\n').len();
     let separator = rest[..content_start].to_string();
-    let preceding = rest[content_start..].trim_end_matches(['\n', ' ', '\t']).to_string();
+    let preceding = rest[content_start..].to_string();
 
     (trailing, separator, preceding)
   } else {
@@ -955,8 +982,16 @@ fn split_at_blank_line(text: &str) -> (String, String, String) {
   }
 }
 
-pub(crate) fn collect_preceding_sibling_comments(parent: &SyntaxNode) -> (String, Option<rowan::TextSize>) {
-  let mut comments: Vec<String> = Vec::new();
+fn split_gap(text: &str) -> (String, String) {
+  let content = text.trim_end_matches(['\n', ' ', '\t']);
+  let newlines = text[content.len()..].matches('\n').count().max(1);
+
+  (content.to_string(), "\n".repeat(newlines))
+}
+
+pub(crate) fn collect_preceding_sibling_comments(parent: &SyntaxNode) -> (String, String, Option<rowan::TextSize>) {
+  let mut comments: Vec<(String, usize)> = Vec::new();
+  let mut newlines = 0;
   let mut earliest_start = None;
   let mut node = parent.clone();
 
@@ -967,10 +1002,11 @@ pub(crate) fn collect_preceding_sibling_comments(parent: &SyntaxNode) -> (String
       match element {
         rowan::NodeOrToken::Token(token) => {
           if token.kind() == SyntaxKind::COMMENT {
-            comments.push(token.text().to_string());
+            comments.push((token.text().to_string(), newlines));
+            newlines = 0;
             earliest_start = Some(token.text_range().start());
           } else if token.kind() == SyntaxKind::WHITESPACE {
-            // Keep looking past whitespace
+            newlines += token.text().matches('\n').count();
           } else {
             break;
           }
@@ -984,7 +1020,7 @@ pub(crate) fn collect_preceding_sibling_comments(parent: &SyntaxNode) -> (String
       };
     }
 
-    if !comments.is_empty() {
+    if !comments.is_empty() || sibling.is_some() {
       break;
     }
 
@@ -996,21 +1032,37 @@ pub(crate) fn collect_preceding_sibling_comments(parent: &SyntaxNode) -> (String
     }
   }
 
+  let gap = "\n".repeat(comments.first().map_or(1, |(_, newlines)| (*newlines).max(1)));
+
   comments.reverse();
-  (comments.join("\n"), earliest_start)
+
+  let text = comments
+    .iter()
+    .enumerate()
+    .map(|(index, (comment, newlines))| {
+      if index + 1 < comments.len() {
+        format!("{}{}", comment, "\n".repeat((*newlines).max(1)))
+      } else {
+        comment.clone()
+      }
+    })
+    .collect();
+
+  (text, gap, earliest_start)
 }
 
 pub(crate) fn collect_groups_with_range(parent: &SyntaxNode) -> (Vec<EntryGroup>, TextRange) {
   let mut groups = collect_entry_groups(parent);
 
-  let (sibling_comments, earliest_start) = collect_preceding_sibling_comments(parent);
+  let (sibling_comments, sibling_gap, earliest_start) = collect_preceding_sibling_comments(parent);
 
   if !sibling_comments.is_empty() {
     if let Some(first) = groups.first_mut() {
       if first.preceding.is_empty() {
         first.preceding = sibling_comments;
+        first.gap = sibling_gap;
       } else {
-        first.preceding = format!("{}\n{}", sibling_comments, first.preceding);
+        first.preceding = format!("{}{}{}", sibling_comments, sibling_gap, first.preceding);
       }
     }
   }
@@ -1050,7 +1102,7 @@ pub(crate) fn rebuild_from_groups(groups: &[EntryGroup], indent: &str, preserve_
         if group.preceding.is_empty() {
           format!("{}{}{}", separator, indent, group.body)
         } else {
-          format!("{}{}\n{}{}", separator, group.preceding, indent, group.body)
+          format!("{}{}{}{}{}", separator, group.preceding, group.gap, indent, group.body)
         }
       }
     })

data/rust/src/document/sort.rs

@@ -225,8 +225,12 @@ impl Document {
   }
 
   pub fn sort_items(&mut self, selector: &str, sort_fields: &[SortField], case_sensitive: bool) -> Result<(), YerbaError> {
+    self.sort_items_with(selector, sort_fields, case_sensitive, None)
+  }
+
+  pub fn sort_items_with(&mut self, selector: &str, sort_fields: &[SortField], case_sensitive: bool, missing: Option<SortMissing>) -> Result<(), YerbaError> {
     if selector.contains("[].") {
-      return self.sort_each_items(selector, sort_fields, case_sensitive);
+      return self.sort_each_items(selector, sort_fields, case_sensitive, missing);
     }
 
     let current_node = self.navigate(selector)?;
@@ -236,13 +240,13 @@ impl Document {
       None => return Ok(()),
     };
 
-    match sort_sequence_edit(&sequence, sort_fields, case_sensitive) {
+    match sort_sequence_edit(&sequence, sort_fields, case_sensitive, missing) {
       Some(edit) => self.apply_edits(vec![edit]),
       None => Ok(()),
     }
   }
 
-  fn sort_each_items(&mut self, selector: &str, sort_fields: &[SortField], case_sensitive: bool) -> Result<(), YerbaError> {
+  fn sort_each_items(&mut self, selector: &str, sort_fields: &[SortField], case_sensitive: bool, missing: Option<SortMissing>) -> Result<(), YerbaError> {
     let (parent_selector, child_selector) = if let Some(last_bracket) = selector.rfind("[].") {
       (&selector[..last_bracket + 2], &selector[last_bracket + 3..])
     } else {
@@ -265,7 +269,7 @@ impl Document {
           None => continue,
         };
 
-        if let Some(edit) = sort_sequence_edit(&sequence, sort_fields, case_sensitive) {
+        if let Some(edit) = sort_sequence_edit(&sequence, sort_fields, case_sensitive, missing) {
           edits.push(edit);
         }
       }
@@ -398,7 +402,7 @@ fn sort_map_edit(map: &BlockMap, key_order: &[&str]) -> Option<(TextRange, Strin
   Some((range, rebuild_from_groups(&sorted_groups, &indent, false)))
 }
 
-fn sort_sequence_edit(sequence: &BlockSeq, sort_fields: &[SortField], case_sensitive: bool) -> Option<(TextRange, String)> {
+fn sort_sequence_edit(sequence: &BlockSeq, sort_fields: &[SortField], case_sensitive: bool, missing: Option<SortMissing>) -> Option<(TextRange, String)> {
   let entries: Vec<_> = sequence.entries().collect();
 
   if entries.len() <= 1 {
@@ -415,7 +419,30 @@ fn sort_sequence_edit(sequence: &BlockSeq, sort_fields: &[SortField], case_sensi
 
   let original_bodies: Vec<String> = sortable.iter().map(|(_, group)| group.body.clone()).collect();
 
-  sortable.sort_by(|(values_a, _), (values_b, _)| compare_sort_values(values_a, values_b, sort_fields, case_sensitive));
+  let compare = |(values_a, _): &(Vec<String>, EntryGroup), (values_b, _): &(Vec<String>, EntryGroup)| {
+    compare_sort_values(values_a, values_b, sort_fields, case_sensitive, missing)
+  };
+
+  let is_absent = |(values, _): &(Vec<String>, EntryGroup)| values.iter().any(|value| value.is_empty());
+
+  match missing {
+    Some(SortMissing::Skip) if sortable.iter().any(is_absent) => return None,
+    Some(SortMissing::Keep) => {
+      let absent_positions: Vec<bool> = sortable.iter().map(is_absent).collect();
+      let (absent, mut present): (Vec<_>, Vec<_>) = sortable.into_iter().partition(is_absent);
+
+      present.sort_by(compare);
+
+      let mut present = present.into_iter();
+      let mut absent = absent.into_iter();
+
+      sortable = absent_positions
+        .iter()
+        .filter_map(|is_absent| if *is_absent { absent.next() } else { present.next() })
+        .collect();
+    }
+    _ => sortable.sort_by(compare),
+  }
 
   let sorted_bodies: Vec<String> = sortable.iter().map(|(_, group)| group.body.clone()).collect();
 
@@ -449,7 +476,13 @@ fn entry_sort_values(entry: &yaml_parser::ast::BlockSeqEntry, sort_fields: &[Sor
     .collect()
 }
 
-fn compare_sort_values(values_a: &[String], values_b: &[String], sort_fields: &[SortField], case_sensitive: bool) -> std::cmp::Ordering {
+fn compare_sort_values(
+  values_a: &[String],
+  values_b: &[String],
+  sort_fields: &[SortField],
+  case_sensitive: bool,
+  missing: Option<SortMissing>,
+) -> std::cmp::Ordering {
   let compare = |value_a: &String, value_b: &String| {
     if case_sensitive {
       value_a.cmp(value_b)
@@ -458,7 +491,19 @@ fn compare_sort_values(values_a: &[String], values_b: &[String], sort_fields: &[
     }
   };
 
+  let missing_ordering = |value_a: &String, value_b: &String| match (missing, value_a.is_empty(), value_b.is_empty()) {
+    (Some(SortMissing::First), true, false) => Some(std::cmp::Ordering::Less),
+    (Some(SortMissing::First), false, true) => Some(std::cmp::Ordering::Greater),
+    (Some(SortMissing::Last), true, false) => Some(std::cmp::Ordering::Greater),
+    (Some(SortMissing::Last), false, true) => Some(std::cmp::Ordering::Less),
+    _ => None,
+  };
+
   for (index, field) in sort_fields.iter().enumerate().take(values_a.len()) {
+    if let Some(ordering) = missing_ordering(&values_a[index], &values_b[index]) {
+      return ordering;
+    }
+
     let ordering = compare(&values_a[index], &values_b[index]);
     let ordering = if field.ascending { ordering } else { ordering.reverse() };
 
@@ -468,7 +513,7 @@ fn compare_sort_values(values_a: &[String], values_b: &[String], sort_fields: &[
   }
 
   if sort_fields.is_empty() && !values_a.is_empty() && !values_b.is_empty() {
-    return compare(&values_a[0], &values_b[0]);
+    return missing_ordering(&values_a[0], &values_b[0]).unwrap_or_else(|| compare(&values_a[0], &values_b[0]));
   }
 
   std::cmp::Ordering::Equal

data/rust/src/ffi.rs

@@ -811,7 +811,13 @@ pub unsafe extern "C" fn yerba_document_rename(document: *mut Document, source:
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn yerba_document_sort(document: *mut Document, selector: *const c_char, by: *const c_char, case_sensitive: bool) -> YerbaResult {
+pub unsafe extern "C" fn yerba_document_sort(
+  document: *mut Document,
+  selector: *const c_char,
+  by: *const c_char,
+  case_sensitive: bool,
+  missing: *const c_char,
+) -> YerbaResult {
   let document = &mut *document;
   let selector_string = CStr::from_ptr(selector).to_str().unwrap_or("");
 
@@ -822,7 +828,16 @@ pub unsafe extern "C" fn yerba_document_sort(document: *mut Document, selector:
     None => vec![],
   };
 
-  match document.sort_items(selector_string, &sort_fields, case_sensitive) {
+  let missing = if missing.is_null() {
+    None
+  } else {
+    match CStr::from_ptr(missing).to_str().unwrap_or("").parse::<crate::SortMissing>() {
+      Ok(missing) => Some(missing),
+      Err(error) => return YerbaResult::err(&error),
+    }
+  };
+
+  match document.sort_items_with(selector_string, &sort_fields, case_sensitive, missing) {
     Ok(()) => YerbaResult::ok(),
     Err(e) => YerbaResult::err(&e.to_string()),
   }

data/rust/src/lib.rs

@@ -15,7 +15,8 @@ pub mod yerbafile;
 
 pub use document::style::{BlankLineOptions, StyleEnforcement};
 pub use document::{
-  collect_selectors, validate_condition, validate_item_condition, Document, DuplicateInfo, InsertPosition, LocatedNode, Location, NodeInfo, NodeType, SortField,
+  collect_selectors, validate_condition, validate_item_condition, Document, DuplicateInfo, InsertPosition, LocatedNode, Location, NodeInfo, NodeType,
+  SortField, SortMissing,
 };
 pub use error::YerbaError;
 pub use quote_style::{KeyStyle, QuoteStyle};

data/rust/src/yerbafile.rs

@@ -22,12 +22,44 @@ pub struct Yerbafile {
 #[derive(Debug, Clone, Deserialize)]
 pub struct Rule {
   pub files: String,
+  #[serde(default, deserialize_with = "string_or_list")]
+  pub exclude: Vec<String>,
   #[serde(default)]
   #[serde(alias = "path")]
   pub selector: Option<String>,
   pub pipeline: Vec<PipelineStep>,
 }
 
+impl Rule {
+  pub fn matches(&self, file: &str) -> bool {
+    matches_glob(&self.files, file) && !self.excludes(file)
+  }
+
+  pub fn excludes(&self, file: &str) -> bool {
+    self.exclude.iter().any(|pattern| matches_glob(pattern, file))
+  }
+}
+
+fn matches_glob(pattern: &str, file: &str) -> bool {
+  glob::Pattern::new(pattern)
+    .map(|pattern| pattern.matches(file) || pattern.matches_path(Path::new(file)))
+    .unwrap_or(false)
+}
+
+fn string_or_list<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<Vec<String>, D::Error> {
+  #[derive(Deserialize)]
+  #[serde(untagged)]
+  enum StringOrList {
+    String(String),
+    List(Vec<String>),
+  }
+
+  Ok(match StringOrList::deserialize(deserializer)? {
+    StringOrList::String(string) => vec![string],
+    StringOrList::List(list) => list,
+  })
+}
+
 #[derive(Debug, Clone)]
 pub enum PipelineStep {
   SortKeys(SortKeysConfig),
@@ -57,6 +89,8 @@ pub struct SortConfig {
   pub by: Option<String>,
   #[serde(default)]
   pub case_sensitive: bool,
+  #[serde(default)]
+  pub missing: Option<crate::SortMissing>,
 }
 
 #[derive(Debug, Clone, Deserialize)]
@@ -391,10 +425,8 @@ impl Yerbafile {
           continue;
         }
 
-        if let Ok(pattern) = glob::Pattern::new(&rule.files) {
-          if pattern.matches(file_path) || pattern.matches_path(Path::new(file_path)) {
-            return Some(config.order.clone());
-          }
+        if rule.matches(file_path) {
+          return Some(config.order.clone());
         }
       }
     }
@@ -421,7 +453,11 @@ impl Yerbafile {
         }
       };
 
-      let file_strings: Vec<String> = files.iter().map(|path| path.to_string_lossy().to_string()).collect();
+      let file_strings: Vec<String> = files
+        .iter()
+        .map(|path| path.to_string_lossy().to_string())
+        .filter(|file| !rule.excludes(file))
+        .collect();
 
       let file_results: Vec<RuleResult> = file_strings
         .par_iter()
@@ -526,11 +562,7 @@ impl Yerbafile {
     let mut ran_global = false;
 
     for rule in &self.rules {
-      if let Ok(pattern) = glob::Pattern::new(&rule.files) {
-        if !pattern.matches(file) && !pattern.matches_path(Path::new(file)) {
-          continue;
-        }
-      } else {
+      if !rule.matches(file) {
         continue;
       }
 
@@ -642,14 +674,8 @@ impl Yerbafile {
     }
 
     for rule in &self.rules {
-      if !match_path.is_empty() {
-        if let Ok(pattern) = glob::Pattern::new(&rule.files) {
-          if !pattern.matches(match_path) && !pattern.matches_path(Path::new(match_path)) {
-            continue;
-          }
-        } else {
-          continue;
-        }
+      if !match_path.is_empty() && !rule.matches(match_path) {
+        continue;
       }
 
       let base_selector = rule.selector.as_deref();
@@ -873,7 +899,7 @@ fn execute_step(document: &mut Document, step: &PipelineStep, base_selector: Opt
       let full_selector = resolve_step_selector(base_selector, config.selector.as_deref());
       let sort_fields = config.by.as_deref().map(crate::SortField::parse_list).unwrap_or_default();
 
-      document.sort_items(&full_selector, &sort_fields, config.case_sensitive)
+      document.sort_items_with(&full_selector, &sort_fields, config.case_sensitive, config.missing)
     }
 
     PipelineStep::Directives(config) => {

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yerba
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.10.1
 platform: arm-linux-gnu
 authors:
 - Marco Roth