tank_core/

util.rs

use proc_macro2::TokenStream;
use quote::{ToTokens, quote};
use std::{borrow::Cow, cmp::min, ffi::CString};
use syn::Path;

#[derive(Clone)]
/// Polymorphic iterator adapter returning items from either variant.
pub enum EitherIterator<A, B>
where
    A: Iterator,
    B: Iterator<Item = A::Item>,
{
    Left(A),
    Right(B),
}
impl<A, B> Iterator for EitherIterator<A, B>
where
    A: Iterator,
    B: Iterator<Item = A::Item>,
{
    type Item = A::Item;
    fn next(&mut self) -> Option<Self::Item> {
        match self {
            EitherIterator::Left(a) => a.next(),
            EitherIterator::Right(b) => b.next(),
        }
    }
}

/// Quote a `Cow<T>` preserving borrowed vs owned status for generated code.
pub fn quote_cow<T: ToOwned + ToTokens + ?Sized>(value: &Cow<T>) -> TokenStream
where
    <T as ToOwned>::Owned: ToTokens,
{
    match value {
        Cow::Borrowed(v) => quote! { ::std::borrow::Cow::Borrowed(#v) },
        Cow::Owned(v) => quote! { ::std::borrow::Cow::Borrowed(#v) },
    }
}

/// Quote an `Option<T>` into tokens.
pub fn quote_option<T: ToTokens>(value: &Option<T>) -> TokenStream {
    match value {
        None => quote! { None },
        Some(v) => quote! { Some(#v) },
    }
}

/// Determine if the trailing segments of a `syn::Path` match the expected identifiers.
pub fn matches_path(path: &Path, expect: &[&str]) -> bool {
    let len = min(path.segments.len(), expect.len());
    path.segments
        .iter()
        .rev()
        .take(len)
        .map(|v| &v.ident)
        .eq(expect.iter().rev().take(len))
}

/// Write an iterator of items separated by a delimiter into a string.
pub fn separated_by<T, F>(
    out: &mut String,
    values: impl IntoIterator<Item = T>,
    mut f: F,
    separator: &str,
) where
    F: FnMut(&mut String, T),
{
    let mut len = out.len();
    for v in values {
        if out.len() > len {
            out.push_str(separator);
        }
        len = out.len();
        f(out, v);
    }
}

/// Convenience wrapper converting into a `CString`, panicking on interior NUL.
pub fn as_c_string<S: Into<Vec<u8>>>(str: S) -> CString {
    CString::new(str.into()).expect("Expected a valid C string")
}

/// Consume a prefix of `input` while the predicate returns true, returning that slice.
pub fn consume_while<'s>(input: &mut &'s str, predicate: impl FnMut(&char) -> bool) -> &'s str {
    let len = input.chars().take_while(predicate).count();
    if len == 0 {
        return "";
    }
    let result = &input[..len];
    *input = &input[len..];
    result
}

#[macro_export]
/// Conditionally wrap a generated fragment in parentheses.
///
/// This is used by SQL writers where certain precedence or grouping must be
/// preserved only under specific syntactic circumstances (for example nested
/// joins or composite boolean expressions). It evaluates `$v` exactly once,
/// writing surrounding `(` `)` into the mutable output buffer `$out` iff
/// `$cond` is true.
///
/// # Examples
/// ```rust
/// # use tank_core::possibly_parenthesized;
/// let mut out = String::new();
/// let cond = true;
/// possibly_parenthesized!(out, cond, { out.push_str("A OR B"); });
/// assert_eq!(out, "(A OR B)");
/// ```
macro_rules! possibly_parenthesized {
    ($out:ident, $cond:expr, $v:expr) => {
        if $cond {
            $out.push('(');
            $v;
            $out.push(')');
        } else {
            $v;
        }
    };
}

#[macro_export]
/// Truncate a long string (typically a SQL query) for logging and error
/// messages purpose, preserving a newline terminator.
///
/// Returns a `format_args!` that yields at most 497 characters from the start
/// of the input followed by `...` when truncation occurred. Chosen length keeps
/// messages concise while retaining useful context near the beginning of a
/// query. Trailing whitespace is trimmed.
///
/// # Examples
/// ```rust
/// # use tank_core::truncate_long;
/// let short = "SELECT 1";
/// assert_eq!(format!("{}", truncate_long!(short)), "SELECT 1\n");
/// let long = format!("SELECT {}", "X".repeat(600));
/// let logged = format!("{}", truncate_long!(long));
/// assert!(logged.starts_with("SELECT "));
/// assert!(logged.ends_with("...\n"));
/// ```
macro_rules! truncate_long {
    ($query:expr) => {
        format_args!(
            "{}{}\n",
            &$query[..::std::cmp::min($query.len(), 497)].trim_end(),
            if $query.len() > 497 { "..." } else { "" },
        )
    };
}

/// Sends the value through the channel and logs in case of error.
#[macro_export]
macro_rules! send_value {
    ($tx:ident, $value:expr) => {{
        if let Err(e) = $tx.send($value) {
            log::error!("{:#}", e);
        }
    }};
}

/// Incrementally accumulates tokens from a speculative parse stream until one
/// of the supplied parsers succeeds.
///
/// Each `$parser` is invoked against a forked cursor so failures do not
/// advance the main stream. When a parser succeeds its result is stored and
/// the loop terminates. If none succeed before the input is exhausted, the
/// macro returns all consumed tokens and a tuple of `None` results.
///
/// Returns `(accumulated_tokens, (parser1_result, parser2_result, ...))` with
/// exactly one `Some(T)` (the first successful parser) or all `None` when no
/// parser matched.
///
/// Useful for parsing sequences like `lhs JOIN rhs ON condition` where the
/// boundary between components is context-sensitive.
#[macro_export]
macro_rules! take_until {
    ($original:expr, $($parser:expr),+ $(,)?) => {{
        let macro_local_input = $original.fork();
        let mut macro_local_result = (
            TokenStream::new(),
            ($({
                let _ = $parser;
                None
            }),+),
        );
        loop {
            if macro_local_input.is_empty() {
                break;
            }
            let mut parsed = false;
            let produced = ($({
                let attempt = macro_local_input.fork();
                if let Ok(content) = ($parser)(&attempt) {
                    macro_local_input.advance_to(&attempt);
                    parsed = true;
                    Some(content)
                } else {
                    None
                }
            }),+);
            if parsed {
                macro_local_result.1 = produced;
                break;
            }
            macro_local_result.0.append(macro_local_input.parse::<TokenTree>()?);
        }
        $original.advance_to(&macro_local_input);
        macro_local_result
    }};
}

#[macro_export]
/// Implement the `Executor` trait for a transaction wrapper type by
/// delegating each operation to an underlying connection object.
///
/// This reduces boilerplate across driver implementations. The macro expands
/// into an `impl Executor for $transaction<'c>` with forwarding methods for
/// `prepare`, `run`, `fetch`, `execute`, and `append`.
///
/// Parameters:
/// * `$driver`: concrete driver type.
/// * `$transaction`: transaction wrapper type (generic over lifetime `'c`).
/// * `$connection`: field name on the transaction pointing to the connection.
///
/// # Examples
/// ```rust
/// # use tank_core::impl_executor_transaction;
/// # struct MyDriver;
/// # struct Conn { /* ... */ }
/// # struct Tx<'c> { connection: &'c Conn }
/// // impl_executor_transaction!(MyDriver, Tx, connection);
/// ```
macro_rules! impl_executor_transaction {
    ($driver:ty, $transaction:ident, $connection:ident) => {
        impl<'c> ::tank_core::Executor for $transaction<'c> {
            type Driver = $driver;

            fn driver(&self) -> &Self::Driver {
                self.$connection.driver()
            }

            fn prepare(
                &mut self,
                query: String,
            ) -> impl Future<Output = ::tank_core::Result<::tank_core::Query<Self::Driver>>> + Send
            {
                self.$connection.prepare(query)
            }

            fn run(
                &mut self,
                query: ::tank_core::Query<Self::Driver>,
            ) -> impl ::tank_core::stream::Stream<
                Item = ::tank_core::Result<::tank_core::QueryResult>,
            > + Send {
                self.$connection.run(query)
            }

            fn fetch<'s>(
                &'s mut self,
                query: ::tank_core::Query<Self::Driver>,
            ) -> impl ::tank_core::stream::Stream<
                Item = ::tank_core::Result<::tank_core::RowLabeled>,
            > + Send
            + 's {
                self.$connection.fetch(query)
            }

            fn execute(
                &mut self,
                query: ::tank_core::Query<Self::Driver>,
            ) -> impl Future<Output = ::tank_core::Result<::tank_core::RowsAffected>> + Send {
                self.$connection.execute(query)
            }

            fn append<'a, E, It>(
                &mut self,
                entities: It,
            ) -> impl Future<Output = ::tank_core::Result<::tank_core::RowsAffected>> + Send
            where
                E: ::tank_core::Entity + 'a,
                It: IntoIterator<Item = &'a E> + Send,
            {
                self.$connection.append(entities)
            }
        }
    };
}