yerba 0.9.2-aarch64-linux-gnu → 0.10.0-aarch64-linux-gnu

data/rust/src/json.rs

@@ -1,5 +1,63 @@
 use crate::selector::{Selector, SelectorSegment};
 
+/// Serializes `value` as JSON, writing non-finite floats as `NaN`, `Infinity` and `-Infinity`
+/// (which Ruby's `JSON.parse` reads with `allow_nan: true`) instead of dropping them to `null`.
+pub fn yaml_to_json_string_allowing_nan(value: &yaml_serde::Value) -> String {
+  let mut output = String::new();
+  write_json_allowing_nan(value, &mut output);
+  output
+}
+
+fn write_json_allowing_nan(value: &yaml_serde::Value, output: &mut String) {
+  match value {
+    yaml_serde::Value::Number(number) if number.is_nan() => output.push_str("NaN"),
+    yaml_serde::Value::Number(number) if number.is_infinite() => output.push_str(if number.as_f64().is_some_and(f64::is_sign_negative) {
+      "-Infinity"
+    } else {
+      "Infinity"
+    }),
+
+    yaml_serde::Value::Sequence(sequence) => {
+      output.push('[');
+
+      for (index, item) in sequence.iter().enumerate() {
+        if index > 0 {
+          output.push(',');
+        }
+
+        write_json_allowing_nan(item, output);
+      }
+
+      output.push(']');
+    }
+
+    yaml_serde::Value::Mapping(mapping) => {
+      output.push('{');
+
+      for (index, (key, item)) in mapping.iter().enumerate() {
+        if index > 0 {
+          output.push(',');
+        }
+
+        let key = match key {
+          yaml_serde::Value::String(string) => string.clone(),
+          _ => format!("{:?}", key),
+        };
+
+        output.push_str(&serde_json::Value::String(key).to_string());
+        output.push(':');
+        write_json_allowing_nan(item, output);
+      }
+
+      output.push('}');
+    }
+
+    yaml_serde::Value::Tagged(tagged) => write_json_allowing_nan(&tagged.value, output),
+
+    _ => output.push_str(&yaml_to_json(value).to_string()),
+  }
+}
+
 pub fn yaml_to_json(value: &yaml_serde::Value) -> serde_json::Value {
   match value {
     yaml_serde::Value::Null => serde_json::Value::Null,
@@ -8,6 +66,8 @@ pub fn yaml_to_json(value: &yaml_serde::Value) -> serde_json::Value {
     yaml_serde::Value::Number(number) => {
       if let Some(integer) = number.as_i64() {
         serde_json::Value::Number(integer.into())
+      } else if let Some(integer) = number.as_u64() {
+        serde_json::Value::Number(integer.into())
       } else if let Some(float) = number.as_f64() {
         serde_json::json!(float)
       } else {
@@ -77,9 +137,9 @@ pub fn resolve_select_field(value: &yaml_serde::Value, field: &str) -> serde_jso
           }
         }
 
-        SelectorSegment::Index(index) => {
+        SelectorSegment::Index(_) | SelectorSegment::IndexFromEnd(_) => {
           if let yaml_serde::Value::Sequence(sequence) = current {
-            if let Some(item) = sequence.get(*index) {
+            if let Some(item) = segment.sequence_index(sequence.len()).and_then(|index| sequence.get(index)) {
               next_values.push(item.clone());
             }
           }

data/rust/src/lib.rs

@@ -22,7 +22,8 @@ pub use quote_style::{KeyStyle, QuoteStyle};
 pub use selector::Selector;
 pub use syntax::{
   detect_yaml_type, escape_double_quoted, is_control_character, is_flow_collection, is_inline_scalar_safe, is_plain_safe, is_plain_safe_in_flow,
-  is_quoted_scalar, is_single_quotable, needs_quoting, needs_quoting_in_flow, quote_scalar, quote_scalar_styled, ScalarValue, YerbaValueType,
+  is_quoted_scalar, is_single_quotable, needs_quoting, needs_quoting_in_flow, quote_scalar, quote_scalar_styled, resolve_plain_scalar, PlainScalar,
+  ScalarValue, YerbaValueType,
 };
 pub use validation::{find_control_characters, ControlCharacter};
 pub use yaml_writer::json_to_yaml_text;

data/rust/src/main.rs

@@ -17,9 +17,10 @@ static HELP: LazyLock<String> = LazyLock::new(|| {
   commands::colorize_help(indoc! {r#"
     Selectors:
       key                  A single key          "database.host"
-      key.nested           Nested key path       "database.settings.pool"
+      key.nested           Nested keys           "database.settings.pool"
       []                   All items in array    "[].title"
       [N]                  Item at index         "[0].title"
+      [-N]                 Item from the end     "[-1].title"
       *                    All values in a map   "database.*"
       [].key[].nested      Nested array access   "[].speakers[].name"
 

data/rust/src/selector.rs

@@ -23,6 +23,17 @@ pub enum SelectorSegment {
   AllItems,
   AllKeys,
   Index(usize),
+  IndexFromEnd(usize),
+}
+
+impl SelectorSegment {
+  pub(crate) fn sequence_index(&self, length: usize) -> Option<usize> {
+    match self {
+      SelectorSegment::Index(index) => (*index < length).then_some(*index),
+      SelectorSegment::IndexFromEnd(offset) => (*offset <= length).then(|| length - offset),
+      _ => None,
+    }
+  }
 }
 
 impl Selector {
@@ -59,14 +70,17 @@ impl Selector {
   }
 
   pub fn ends_with_bracket(&self) -> bool {
-    matches!(self.segments().last(), Some(SelectorSegment::AllItems | SelectorSegment::Index(_)))
+    matches!(
+      self.segments().last(),
+      Some(SelectorSegment::AllItems | SelectorSegment::Index(_) | SelectorSegment::IndexFromEnd(_))
+    )
   }
 
   pub fn has_brackets(&self) -> bool {
     self
       .segments()
       .iter()
-      .any(|s| matches!(s, SelectorSegment::AllItems | SelectorSegment::Index(_)))
+      .any(|s| matches!(s, SelectorSegment::AllItems | SelectorSegment::Index(_) | SelectorSegment::IndexFromEnd(_)))
   }
 
   pub fn has_wildcard(&self) -> bool {
@@ -88,7 +102,7 @@ impl Selector {
 
     let last_bracket = segments
       .iter()
-      .rposition(|s| matches!(s, SelectorSegment::AllItems | SelectorSegment::Index(_)));
+      .rposition(|s| matches!(s, SelectorSegment::AllItems | SelectorSegment::Index(_) | SelectorSegment::IndexFromEnd(_)));
 
     match last_bracket {
       Some(position) => {
@@ -110,7 +124,9 @@ impl Selector {
   pub fn split_at_first_bracket(&self) -> (Selector, Selector) {
     let segments = self.segments();
 
-    let first_bracket = segments.iter().position(|s| matches!(s, SelectorSegment::AllItems | SelectorSegment::Index(_)));
+    let first_bracket = segments
+      .iter()
+      .position(|s| matches!(s, SelectorSegment::AllItems | SelectorSegment::Index(_) | SelectorSegment::IndexFromEnd(_)));
 
     match first_bracket {
       Some(position) => {
@@ -178,13 +194,17 @@ impl Selector {
         SelectorSegment::Index(i) => {
           result.push_str(&format!("[{}]", i));
         }
+
+        SelectorSegment::IndexFromEnd(i) => {
+          result.push_str(&format!("[-{}]", i));
+        }
       }
     }
 
     result
   }
 
-  pub fn parent_path(&self) -> String {
+  pub fn parent_selector(&self) -> String {
     let segments = self.segments();
 
     if segments.len() <= 1 {
@@ -212,8 +232,10 @@ fn parse_segments(input: &str) -> Vec<SelectorSegment> {
 
         if inner.is_empty() {
           segments.push(SelectorSegment::AllItems);
-        } else if let Ok(index) = inner.parse::<usize>() {
-          segments.push(SelectorSegment::Index(index));
+        } else if let Some(index) = parse_index(inner) {
+          segments.push(index);
+        } else {
+          segments.push(SelectorSegment::Key(rest[..=close].to_string()));
         }
 
         rest = &rest[close + 1..];
@@ -222,6 +244,8 @@ fn parse_segments(input: &str) -> Vec<SelectorSegment> {
           rest = &rest[1..];
         }
       } else {
+        segments.push(SelectorSegment::Key(rest.to_string()));
+
         break;
       }
     } else {
@@ -266,3 +290,20 @@ fn parse_segments(input: &str) -> Vec<SelectorSegment> {
 
   segments
 }
+
+fn parse_index(input: &str) -> Option<SelectorSegment> {
+  if input.bytes().all(|byte| byte.is_ascii_digit()) {
+    return Some(SelectorSegment::Index(input.parse::<usize>().unwrap_or(usize::MAX)));
+  }
+
+  let digits = input.strip_prefix('-')?;
+
+  if digits.is_empty() || !digits.bytes().all(|byte| byte.is_ascii_digit()) {
+    return None;
+  }
+
+  match digits.parse::<usize>().unwrap_or(usize::MAX) {
+    0 => Some(SelectorSegment::Index(0)),
+    offset => Some(SelectorSegment::IndexFromEnd(offset)),
+  }
+}