honeymaker 0.12.3 → 0.12.5

data/crates/honeymaker/src/num.rs

@@ -0,0 +1,115 @@
+//! Decimal arithmetic the venue normalizers need. The Ruby binding supplies Ruby's own
+//! BigDecimal (exact legacy semantics: NaN, signed zero, division precision, ArgumentError); Rust
+//! callers use the bigdecimal crate.
+
+use bigdecimal::BigDecimal;
+use std::str::FromStr;
+
+pub trait Num: Sized {
+    type Error;
+    /// Legacy `BigDecimal(text)`.
+    fn parse(text: &str) -> Result<Self, Self::Error>;
+    /// Legacy `BigDecimal(value.to_s)`: the Ruby impl stringifies with Ruby's own `to_s`, so
+    /// arrays, hashes and non-finite Floats give Ruby's exact text and ArgumentError.
+    fn parse_to_s(v: &serde_json::Value) -> Result<Self, Self::Error>;
+    /// Legacy `BigDecimal(value)` on the parsed JSON object itself (no `to_s`): Integers and
+    /// Strings convert, a Float raises ("can't omit precision for a Float."), others raise.
+    fn parse_json(v: &serde_json::Value) -> Result<Self, Self::Error>;
+    fn string_op(
+        v: &serde_json::Value,
+        op: crate::semantics::StringOp<'_>,
+    ) -> Result<serde_json::Value, Self::Error>;
+    fn add(&self, other: &Self) -> Result<Self, Self::Error>;
+    fn sub(&self, other: &Self) -> Result<Self, Self::Error>;
+    fn div(&self, other: &Self) -> Result<Self, Self::Error>;
+    fn is_zero(&self) -> Result<bool, Self::Error>;
+}
+
+#[derive(Debug)]
+pub enum NormError<E> {
+    /// The payload doesn't have the documented shape.
+    Shape(String),
+    /// The decimal backend refused a value (Ruby impl: Ruby's own ArgumentError).
+    Num(E),
+}
+
+impl<E> From<String> for NormError<E> {
+    fn from(s: String) -> Self {
+        NormError::Shape(s)
+    }
+}
+
+impl<E> From<&str> for NormError<E> {
+    fn from(s: &str) -> Self {
+        NormError::Shape(s.to_string())
+    }
+}
+
+/// For Rust callers: finite decimals with Ruby's string grammar (spaces around, `_` between
+/// digits, d/D exponent). Non-finite values are errors here.
+impl Num for BigDecimal {
+    type Error = String;
+
+    fn parse(text: &str) -> Result<Self, String> {
+        let t = text.trim_matches(|c: char| c == ' ' || ('\t'..='\r').contains(&c));
+        static RE: std::sync::OnceLock<regex::Regex> = std::sync::OnceLock::new();
+        let re = RE.get_or_init(|| {
+            regex::Regex::new(
+                r"^[+-]?(?:\d+(?:_\d+)*)?(?:\.(?:\d+(?:_\d+)*)?)?(?:[eEdD][+-]?\d+)?$",
+            )
+            .unwrap()
+        });
+        if !re.is_match(t) || !t.bytes().any(|b| b.is_ascii_digit()) {
+            return Err(format!("invalid value for BigDecimal(): {text:?}"));
+        }
+        let mut s: String = t
+            .chars()
+            .filter(|&c| c != '_')
+            .map(|c| if c == 'd' || c == 'D' { 'e' } else { c })
+            .collect();
+        for (from, to) in [("-.", "-0."), ("+.", "+0."), (".e", ".0e"), (".E", ".0E")] {
+            s = s.replace(from, to);
+        }
+        if s.starts_with('.') {
+            s.insert(0, '0');
+        }
+        if s.ends_with('.') {
+            s.push('0');
+        }
+        BigDecimal::from_str(&s).map_err(|e| e.to_string())
+    }
+    fn parse_to_s(v: &serde_json::Value) -> Result<Self, String> {
+        Self::parse(&crate::semantics::to_s(v)?)
+    }
+    fn parse_json(v: &serde_json::Value) -> Result<Self, String> {
+        match v {
+            serde_json::Value::String(s) => Self::parse(s),
+            serde_json::Value::Number(n) if !n.to_string().contains(['.', 'e', 'E']) => {
+                Self::parse(&n.to_string())
+            }
+            serde_json::Value::Number(_) => Err("can't omit precision for a Float.".into()),
+            other => Err(format!("can't convert {other} into BigDecimal")),
+        }
+    }
+    fn string_op(
+        v: &serde_json::Value,
+        op: crate::semantics::StringOp<'_>,
+    ) -> Result<serde_json::Value, String> {
+        crate::semantics::string_op(v, op)
+    }
+    fn add(&self, o: &Self) -> Result<Self, String> {
+        Ok(self + o)
+    }
+    fn sub(&self, o: &Self) -> Result<Self, String> {
+        Ok(self - o)
+    }
+    fn div(&self, o: &Self) -> Result<Self, String> {
+        if o == &BigDecimal::from(0) {
+            return Err("divided by 0".into());
+        }
+        Ok((self / o).with_prec(34))
+    }
+    fn is_zero(&self) -> Result<bool, String> {
+        Ok(self == &BigDecimal::from(0))
+    }
+}

data/crates/honeymaker/src/semantics.rs

@@ -0,0 +1,100 @@
+//! The Ruby semantics venue code relies on, made explicit.
+
+use serde_json::Value;
+
+/// Key of the one-entry object the binding uses for a non-finite Ruby Float ("Infinity", "NaN").
+pub const RUBY_FLOAT: &str = "\u{0}ruby_float";
+
+/// Legacy `x.to_s` for a JSON value: String as is, numbers as their digits (the binding gives
+/// Ruby Floats their Float#to_s digits), nil → "", booleans → "true"/"false".
+pub fn to_s(v: &Value) -> Result<String, String> {
+    match v {
+        Value::String(s) => Ok(s.clone()),
+        Value::Number(n) => Ok(n.to_string()),
+        Value::Null => Ok(String::new()),
+        Value::Bool(b) => Ok(b.to_string()),
+        Value::Object(m) if m.len() == 1 => match m.get(RUBY_FLOAT) {
+            Some(Value::String(t)) => Ok(t.clone()),
+            _ => Err(format!("no to_s for {v}")),
+        },
+        other => Err(format!("no to_s for {other}")),
+    }
+}
+
+/// Ruby truthiness: everything except nil and false.
+pub fn truthy(v: Option<&Value>) -> bool {
+    !matches!(v, None | Some(Value::Null) | Some(Value::Bool(false)))
+}
+
+/// Lossless Ruby String: [bytes, Encoding#name]. Never interpret this object as a Hash.
+pub const RUBY_STRING: &str = "\u{0}ruby_string";
+
+pub fn is_string(v: &Value) -> bool {
+    v.is_string()
+        || v.as_object()
+            .is_some_and(|m| m.len() == 1 && m.contains_key(RUBY_STRING))
+}
+
+/// String operations whose encoding semantics belong to the embedding runtime.
+pub enum StringOp<'a> {
+    Index(&'a str),
+    Split(&'a str),
+    DowncaseSymbol,
+    Symbol,
+    First,
+}
+
+pub fn string_op(v: &Value, op: StringOp<'_>) -> Result<Value, String> {
+    let s = v.as_str().ok_or("expected a UTF-8 string")?;
+    Ok(match op {
+        StringOp::Index(key) => {
+            if s.contains(key) {
+                Value::from(key)
+            } else {
+                Value::Null
+            }
+        }
+        StringOp::Split(sep) => {
+            let mut parts: Vec<Value> = s.split(sep).map(Value::from).collect();
+            while parts.last().is_some_and(|v| v.as_str() == Some("")) {
+                parts.pop();
+            }
+            Value::Array(parts)
+        }
+        StringOp::DowncaseSymbol => {
+            Value::from(s.chars().flat_map(char::to_lowercase).collect::<String>())
+        }
+        StringOp::Symbol => v.clone(),
+        StringOp::First => s
+            .chars()
+            .next()
+            .map(|c| Value::from(c.to_string()))
+            .unwrap_or(Value::Null),
+    })
+}
+
+/// Equality to an ASCII venue token, including ASCII-compatible binary strings.
+pub fn string_eq(v: &Value, token: &str) -> bool {
+    if let Some(s) = v.as_str() {
+        return s == token;
+    }
+    v.get(RUBY_STRING)
+        .and_then(Value::as_array)
+        .is_some_and(|parts| {
+            parts[0].as_array().is_some_and(|bytes| {
+                bytes.len() == token.len()
+                    && bytes
+                        .iter()
+                        .zip(token.bytes())
+                        .all(|(v, b)| v.as_u64() == Some(b as u64))
+            })
+        })
+}
+
+/// Escape keys that serde_json cannot represent directly, including literal escape prefixes.
+pub const RUBY_KEY: &str = "\u{0}ruby_key:";
+pub fn object_key(key: &str) -> Value {
+    key.strip_prefix(RUBY_KEY)
+        .and_then(|s| serde_json::from_str(s).ok())
+        .unwrap_or_else(|| Value::from(key))
+}

data/crates/honeymaker/src/types.rs

@@ -0,0 +1,85 @@
+#[derive(Debug, Clone, PartialEq)]
+pub struct Balance<D> {
+    pub free: D,
+    pub locked: D,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum OrderStatus {
+    Open,
+    Closed,
+    Cancelled,
+    Failed,
+    Unknown,
+}
+
+impl OrderStatus {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            OrderStatus::Open => "open",
+            OrderStatus::Closed => "closed",
+            OrderStatus::Cancelled => "cancelled",
+            OrderStatus::Failed => "failed",
+            OrderStatus::Unknown => "unknown",
+        }
+    }
+}
+
+/// Legacy symbolizes whatever the venue sent, so a side that is neither buy nor sell survives.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Side {
+    Buy,
+    Sell,
+    Other(String),
+}
+
+impl Side {
+    pub fn from_venue(s: &str) -> Side {
+        match s {
+            "buy" => Side::Buy,
+            "sell" => Side::Sell,
+            other => Side::Other(other.to_string()),
+        }
+    }
+    pub fn as_str(&self) -> &str {
+        match self {
+            Side::Buy => "buy",
+            Side::Sell => "sell",
+            Side::Other(s) => s,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum OrderType {
+    Market,
+    Limit,
+    Unknown,
+}
+
+impl OrderType {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            OrderType::Market => "market",
+            OrderType::Limit => "limit",
+            OrderType::Unknown => "unknown",
+        }
+    }
+}
+
+/// Opaque, venue-formatted order id, stable for storage.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct OrderId(pub String);
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Order<D> {
+    pub id: OrderId,
+    pub status: OrderStatus,
+    pub side: Option<Side>,
+    pub order_type: OrderType,
+    pub price: Option<D>,
+    pub amount: Option<D>,
+    pub quote_amount: Option<D>,
+    pub amount_exec: D,
+    pub quote_amount_exec: D,
+}