ferric-alpha-render 0.1.0

Native rendering for Ferric Alpha alphalens-style tear-sheet reports
Documentation
use chrono::{DateTime, TimeZone, Utc};
use ferric_alpha::{DisplayFormat, DisplayUnit, ReportColumnData, ReportTimeUnit};

use crate::{RenderError, RenderResult};

const EM_DASH: &str = "\u{2014}";

pub fn format_optional(value: Option<f64>, unit: DisplayUnit, decimals: u8) -> String {
    value.map_or_else(
        || EM_DASH.to_string(),
        |value| format_number(value, unit, decimals),
    )
}

pub fn format_number(value: f64, unit: DisplayUnit, decimals: u8) -> String {
    let decimals = usize::from(decimals);
    let scaled = normalize_negative_zero(match unit {
        DisplayUnit::Raw | DisplayUnit::Ratio | DisplayUnit::Count => value,
        DisplayUnit::DecimalReturn | DisplayUnit::Percent => value * 100.0,
        DisplayUnit::BasisPoints => value * 10_000.0,
    });

    match unit {
        DisplayUnit::DecimalReturn | DisplayUnit::Percent => format!("{scaled:.decimals$}%"),
        DisplayUnit::BasisPoints => format!("{scaled:.decimals$} bps"),
        DisplayUnit::Count if decimals == 0 => format!("{scaled:.0}"),
        _ => format!("{scaled:.decimals$}"),
    }
}

pub fn format_axis_value(value: f64, format: Option<&DisplayFormat>) -> String {
    match format {
        Some(format) => format_number(value, format.unit(), format.decimals()),
        None => format_number(value, DisplayUnit::Raw, 2),
    }
}

pub fn format_cell(data: &ReportColumnData, row: usize) -> RenderResult<String> {
    let out = match data {
        ReportColumnData::Boolean(values) => values
            .get(row)
            .copied()
            .flatten()
            .map_or_else(|| EM_DASH.to_string(), |value| value.to_string()),
        ReportColumnData::Int32(values) => values
            .get(row)
            .copied()
            .flatten()
            .map_or_else(|| EM_DASH.to_string(), |value| value.to_string()),
        ReportColumnData::Int64(values) => values
            .get(row)
            .copied()
            .flatten()
            .map_or_else(|| EM_DASH.to_string(), |value| value.to_string()),
        ReportColumnData::UInt32(values) => values
            .get(row)
            .copied()
            .flatten()
            .map_or_else(|| EM_DASH.to_string(), |value| value.to_string()),
        ReportColumnData::UInt64(values) => values
            .get(row)
            .copied()
            .flatten()
            .map_or_else(|| EM_DASH.to_string(), |value| value.to_string()),
        ReportColumnData::Float64(values) => values.get(row).copied().flatten().map_or_else(
            || EM_DASH.to_string(),
            |value| format_number(value, DisplayUnit::Raw, 2),
        ),
        ReportColumnData::String(values) => values
            .get(row)
            .and_then(Option::as_ref)
            .map_or_else(|| EM_DASH.to_string(), ToString::to_string),
        ReportColumnData::Datetime {
            values,
            time_unit,
            timezone,
        } => values.get(row).copied().flatten().map_or_else(
            || Ok(EM_DASH.to_string()),
            |value| format_datetime(value, *time_unit, timezone.as_deref()),
        )?,
    };
    Ok(out)
}

pub fn format_datetime(
    value: i64,
    time_unit: ReportTimeUnit,
    timezone: Option<&str>,
) -> RenderResult<String> {
    let utc = timestamp_to_utc(value, time_unit)?;
    let date = match timezone {
        Some(name) => {
            let tz = name
                .parse::<chrono_tz::Tz>()
                .map_err(|_| RenderError::InvalidContract {
                    reason: format!("unknown timezone {name}"),
                })?;
            utc.with_timezone(&tz).date_naive()
        }
        None => utc.date_naive(),
    };
    Ok(date.format("%Y-%m-%d").to_string())
}

fn timestamp_to_utc(value: i64, time_unit: ReportTimeUnit) -> RenderResult<DateTime<Utc>> {
    let (divisor, nanos_multiplier): (i64, i64) = match time_unit {
        ReportTimeUnit::Nanoseconds => (1_000_000_000, 1),
        ReportTimeUnit::Microseconds => (1_000_000, 1_000),
        ReportTimeUnit::Milliseconds => (1_000, 1_000_000),
    };
    let seconds = value.div_euclid(divisor);
    let nanos = value
        .rem_euclid(divisor)
        .checked_mul(nanos_multiplier)
        .ok_or_else(|| RenderError::InvalidContract {
            reason: "timestamp overflow".to_string(),
        })?;
    let nanos = u32::try_from(nanos).map_err(|_| RenderError::InvalidContract {
        reason: "timestamp overflow".to_string(),
    })?;
    Utc.timestamp_opt(seconds, nanos)
        .single()
        .ok_or_else(|| RenderError::InvalidContract {
            reason: "timestamp overflow".to_string(),
        })
}

fn normalize_negative_zero(value: f64) -> f64 {
    if value == 0.0 { 0.0 } else { value }
}