@lix-js/sdk 0.6.0-preview.5 → 0.6.0

package/dist-engine-src/src/tracked_state/row_materialization.rs

@@ -1,275 +0,0 @@
-use crate::entity_pk::EntityPk;
-use crate::json_store::JsonRef;
-use crate::json_store::{JsonLoadRequestRef, JsonReadScopeRef, JsonStoreContext};
-use crate::storage::StorageRead;
-use crate::tracked_state::types::{TrackedStateIndexValue, TrackedStateKey};
-use crate::tracked_state::MaterializedTrackedStateRow;
-use crate::LixError;
-
-/// Materializes tracked-state index entries.
-///
-/// The durable tracked_state value is authoritative for scalar materialization
-/// fields and stores the JSON refs needed for payload hydration. Snapshot and
-/// metadata bytes are hydrated from grouped json_store loads only when the
-/// requested materialization needs them.
-pub(crate) async fn materialize_rows_from_index_entries<S>(
-    store: &S,
-    entries: Vec<(TrackedStateKey, TrackedStateIndexValue)>,
-    materialization: &TrackedRowMaterialization,
-) -> Result<Vec<MaterializedTrackedStateRow>, LixError>
-where
-    S: StorageRead + Send + Sync,
-{
-    if !materialization.snapshot_content && !materialization.metadata {
-        return Ok(entries
-            .into_iter()
-            .map(materialize_entry_without_json)
-            .collect());
-    }
-
-    let json_slots_per_row =
-        usize::from(materialization.snapshot_content) + usize::from(materialization.metadata);
-    let json_ref_capacity = entries.len().saturating_mul(json_slots_per_row);
-    let mut row_plans = Vec::with_capacity(entries.len());
-    let mut json_refs = Vec::with_capacity(json_ref_capacity);
-    let mut json_ref_localities = Vec::with_capacity(json_ref_capacity);
-    for (key, value) in entries {
-        let snapshot_ref_index = materialized_json_ref_index(
-            materialization.snapshot_content,
-            value.snapshot_ref,
-            &mut json_refs,
-            &mut json_ref_localities,
-        );
-        let metadata_ref_index = materialized_json_ref_index(
-            materialization.metadata,
-            value.metadata_ref,
-            &mut json_refs,
-            &mut json_ref_localities,
-        );
-        row_plans.push(TrackedRowMaterializationPlan {
-            entity_pk: key.entity_pk,
-            schema_key: key.schema_key,
-            file_id: key.file_id,
-            deleted: value.deleted,
-            created_at: value.created_at,
-            updated_at: value.updated_at,
-            change_id: value.change_id,
-            commit_id: value.commit_id,
-            snapshot_ref_index,
-            metadata_ref_index,
-        });
-    }
-
-    let mut json_values =
-        load_materialization_json_values(store, &json_refs, &json_ref_localities).await?;
-    row_plans
-        .into_iter()
-        .map(|plan| materialize_row_plan(plan, &json_refs, &mut json_values))
-        .collect()
-}
-
-fn materialize_entry_without_json(
-    (key, value): (TrackedStateKey, TrackedStateIndexValue),
-) -> MaterializedTrackedStateRow {
-    MaterializedTrackedStateRow {
-        entity_pk: key.entity_pk,
-        schema_key: key.schema_key,
-        file_id: key.file_id,
-        snapshot_content: None,
-        metadata: None,
-        deleted: value.deleted,
-        created_at: value.created_at,
-        updated_at: value.updated_at,
-        change_id: value.change_id,
-        commit_id: value.commit_id,
-    }
-}
-
-struct TrackedRowMaterializationPlan {
-    entity_pk: EntityPk,
-    schema_key: String,
-    file_id: Option<String>,
-    deleted: bool,
-    created_at: String,
-    updated_at: String,
-    change_id: String,
-    commit_id: String,
-    snapshot_ref_index: Option<usize>,
-    metadata_ref_index: Option<usize>,
-}
-
-fn materialized_json_ref_index(
-    include: bool,
-    json_ref: Option<JsonRef>,
-    json_refs: &mut Vec<JsonRef>,
-    json_ref_localities: &mut Vec<JsonRefLocality>,
-) -> Option<usize> {
-    if !include {
-        return None;
-    }
-    let index = json_refs.len();
-    json_refs.push(json_ref?);
-    json_ref_localities.push(JsonRefLocality);
-    Some(index)
-}
-
-struct JsonRefLocality;
-
-async fn load_materialization_json_values<S>(
-    store: &S,
-    json_refs: &[JsonRef],
-    json_ref_localities: &[JsonRefLocality],
-) -> Result<Vec<Option<Vec<u8>>>, LixError>
-where
-    S: StorageRead + Send + Sync,
-{
-    if json_refs.len() != json_ref_localities.len() {
-        return Err(LixError::new(
-            LixError::CODE_INTERNAL_ERROR,
-            "tracked_state materialization JSON refs and locality indexes diverged",
-        ));
-    }
-
-    let mut json_values = vec![None; json_refs.len()];
-    let mut out_of_band_indexes = Vec::new();
-    let mut out_of_band_refs = Vec::new();
-    for (index, json_ref) in json_refs.iter().copied().enumerate() {
-        let _locality = json_ref_localities.get(index).ok_or_else(|| {
-            LixError::new(
-                LixError::CODE_INTERNAL_ERROR,
-                "tracked_state materialization lost JSON locality index",
-            )
-        })?;
-        out_of_band_indexes.push(index);
-        out_of_band_refs.push(json_ref);
-    }
-
-    if !out_of_band_refs.is_empty() {
-        let values = JsonStoreContext::new()
-            .load_bytes_many(
-                store,
-                JsonLoadRequestRef {
-                    refs: &out_of_band_refs,
-                    scope: JsonReadScopeRef::OutOfBand,
-                },
-            )
-            .await?
-            .into_values();
-        for (index, value) in out_of_band_indexes.into_iter().zip(values) {
-            if value.is_some() {
-                json_values[index] = value;
-            }
-        }
-    }
-
-    Ok(json_values)
-}
-
-fn materialize_row_plan(
-    plan: TrackedRowMaterializationPlan,
-    json_refs: &[JsonRef],
-    json_values: &mut [Option<Vec<u8>>],
-) -> Result<MaterializedTrackedStateRow, LixError> {
-    Ok(MaterializedTrackedStateRow {
-        entity_pk: plan.entity_pk,
-        schema_key: plan.schema_key,
-        file_id: plan.file_id,
-        snapshot_content: materialized_json_string(
-            plan.snapshot_ref_index,
-            json_refs,
-            json_values,
-        )?,
-        metadata: materialized_json_string(plan.metadata_ref_index, json_refs, json_values)?,
-        deleted: plan.deleted,
-        created_at: plan.created_at,
-        updated_at: plan.updated_at,
-        change_id: plan.change_id,
-        commit_id: plan.commit_id,
-    })
-}
-
-fn materialized_json_string(
-    index: Option<usize>,
-    json_refs: &[JsonRef],
-    json_values: &mut [Option<Vec<u8>>],
-) -> Result<Option<String>, LixError> {
-    let Some(index) = index else {
-        return Ok(None);
-    };
-    let json_ref = json_refs.get(index).ok_or_else(|| {
-        LixError::new(
-            LixError::CODE_INTERNAL_ERROR,
-            "tracked_state materialization lost JSON ref index",
-        )
-    })?;
-    // Each row plan owns its materialized JSON slots. If this path starts
-    // deduplicating refs, duplicate consumers must clone intentionally.
-    let bytes = json_values
-        .get_mut(index)
-        .ok_or_else(|| {
-            LixError::new(
-                LixError::CODE_INTERNAL_ERROR,
-                "tracked_state materialization lost JSON value index",
-            )
-        })?
-        .take()
-        .ok_or_else(|| {
-            LixError::new(
-                LixError::CODE_INTERNAL_ERROR,
-                format!(
-                    "tracked_state materialization missing JSON payload '{}'",
-                    json_ref.to_hex()
-                ),
-            )
-        })?;
-    String::from_utf8(bytes).map(Some).map_err(|error| {
-        let utf8_error = error.utf8_error();
-        LixError::new(
-            LixError::CODE_INTERNAL_ERROR,
-            format!("tracked_state materialized JSON payload is not UTF-8: {utf8_error}"),
-        )
-    })
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub(crate) struct TrackedRowMaterialization {
-    pub(crate) snapshot_content: bool,
-    pub(crate) metadata: bool,
-}
-
-impl TrackedRowMaterialization {
-    pub(crate) fn full() -> Self {
-        Self {
-            snapshot_content: true,
-            metadata: true,
-        }
-    }
-
-    pub(crate) fn from_columns(columns: &[String]) -> Self {
-        if columns.is_empty() {
-            return Self::full();
-        }
-        Self {
-            snapshot_content: columns.iter().any(|column| column == "snapshot_content"),
-            metadata: columns.iter().any(|column| column == "metadata"),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn materialized_json_string_consumes_owned_payload_bytes() {
-        let json = br#"{"value":1}"#.to_vec();
-        let json_ref = JsonRef::for_content(&json);
-        let mut json_values = vec![Some(json)];
-
-        let materialized = materialized_json_string(Some(0), &[json_ref], &mut json_values)
-            .expect("json should materialize");
-
-        assert_eq!(materialized, Some(r#"{"value":1}"#.to_string()));
-        assert!(json_values[0].is_none());
-    }
-}

package/dist-engine-src/src/tracked_state/storage.rs

@@ -1,427 +0,0 @@
-use std::collections::HashMap;
-
-use crate::storage::{PointReadPlan, StorageRead, StorageSpace, StorageWriteSet};
-use crate::storage::{
-    StorageGetOptions, StorageKey, StorageProjectedValue, StorageSpaceId, StorageValue,
-};
-use crate::tracked_state::codec::PendingChunkWrite;
-use crate::tracked_state::types::{
-    TrackedStateCommitRoot, TrackedStateCommitRootParent, TrackedStateRootId,
-    TRACKED_STATE_HASH_BYTES,
-};
-use crate::LixError;
-use bytes::Bytes;
-
-pub(crate) const TRACKED_STATE_TREE_CHUNK_NAMESPACE: &'static str = "tracked_state.tree_chunk";
-pub(crate) const TRACKED_STATE_COMMIT_ROOT_NAMESPACE: &'static str = "tracked_state.commit_root";
-pub(crate) const TRACKED_STATE_TREE_CHUNK_SPACE: StorageSpace = StorageSpace::new(
-    StorageSpaceId(0x0004_0001),
-    TRACKED_STATE_TREE_CHUNK_NAMESPACE,
-);
-pub(crate) const TRACKED_STATE_COMMIT_ROOT_SPACE: StorageSpace = StorageSpace::new(
-    StorageSpaceId(0x0004_0004),
-    TRACKED_STATE_COMMIT_ROOT_NAMESPACE,
-);
-
-const COMMIT_ROOT_MAGIC: &[u8; 5] = b"LXTR1";
-
-async fn get_one(
-    store: &(impl StorageRead + ?Sized),
-    space: StorageSpace,
-    key: Vec<u8>,
-) -> Result<Option<Vec<u8>>, LixError> {
-    let result = PointReadPlan::new(space, &[StorageKey(Bytes::from(key))])
-        .materialize(store, StorageGetOptions::default())?;
-    Ok(result
-        .value
-        .into_iter()
-        .next()
-        .flatten()
-        .and_then(full_value))
-}
-
-pub(crate) async fn load_root(
-    store: &(impl StorageRead + ?Sized),
-    commit_id: &str,
-) -> Result<Option<TrackedStateRootId>, LixError> {
-    Ok(load_commit_root(store, commit_id)
-        .await?
-        .map(|metadata| metadata.root_id))
-}
-
-pub(crate) async fn load_commit_root(
-    store: &(impl StorageRead + ?Sized),
-    commit_id: &str,
-) -> Result<Option<TrackedStateCommitRoot>, LixError> {
-    let Some(bytes) = get_one(
-        store,
-        TRACKED_STATE_COMMIT_ROOT_SPACE,
-        commit_id.as_bytes().to_vec(),
-    )
-    .await?
-    else {
-        return Ok(None);
-    };
-    let metadata = decode_commit_root(&bytes)?;
-    if metadata.commit_id != commit_id {
-        return Err(LixError::new(
-            LixError::CODE_INTERNAL_ERROR,
-            format!(
-                "tracked_state commit_root key for commit '{commit_id}' contains root metadata for commit '{}'",
-                metadata.commit_id
-            ),
-        ));
-    }
-    Ok(Some(metadata))
-}
-
-pub(crate) fn stage_commit_root(
-    writes: &mut StorageWriteSet,
-    metadata: &TrackedStateCommitRoot,
-) -> Result<(), LixError> {
-    writes.put(
-        TRACKED_STATE_COMMIT_ROOT_SPACE,
-        key(metadata.commit_id.as_bytes().to_vec()),
-        value(encode_commit_root(metadata)?),
-    );
-    Ok(())
-}
-
-pub(crate) async fn read_chunk(
-    store: &(impl StorageRead + ?Sized),
-    hash: &[u8; TRACKED_STATE_HASH_BYTES],
-) -> Result<Option<Vec<u8>>, LixError> {
-    get_one(store, TRACKED_STATE_TREE_CHUNK_SPACE, hash.to_vec()).await
-}
-
-pub(crate) fn verify_chunk_hash(
-    expected: &[u8; TRACKED_STATE_HASH_BYTES],
-    bytes: &[u8],
-) -> Result<(), LixError> {
-    let actual = crate::tracked_state::codec::hash_bytes(bytes);
-    if &actual != expected {
-        return Err(LixError::new(
-            "LIX_ERROR_UNKNOWN",
-            "tracked-state chunk hash mismatch",
-        ));
-    }
-    Ok(())
-}
-
-pub(crate) fn stage_chunks(writes: &mut StorageWriteSet, chunks: &[PendingChunkWrite]) {
-    for chunk in chunks {
-        writes.put(
-            TRACKED_STATE_TREE_CHUNK_SPACE,
-            key(chunk.hash.to_vec()),
-            value(chunk.data.clone()),
-        );
-    }
-}
-
-#[derive(Debug, Default)]
-pub(crate) struct TrackedStateChunkOverlay {
-    chunks: HashMap<[u8; TRACKED_STATE_HASH_BYTES], Vec<u8>>,
-}
-
-impl TrackedStateChunkOverlay {
-    pub(crate) fn new() -> Self {
-        Self::default()
-    }
-
-    pub(crate) async fn read_chunk(
-        &self,
-        store: &(impl StorageRead + ?Sized),
-        hash: &[u8; TRACKED_STATE_HASH_BYTES],
-    ) -> Result<Option<Vec<u8>>, LixError> {
-        if let Some(bytes) = self.chunks.get(hash) {
-            return Ok(Some(bytes.clone()));
-        }
-        read_chunk(store, hash).await
-    }
-
-    pub(crate) fn stage_chunks(
-        &mut self,
-        writes: &mut StorageWriteSet,
-        chunks: &[PendingChunkWrite],
-    ) {
-        for chunk in chunks {
-            self.chunks.insert(chunk.hash, chunk.data.clone());
-        }
-        stage_chunks(writes, chunks);
-    }
-}
-
-fn key(bytes: Vec<u8>) -> StorageKey {
-    StorageKey(Bytes::from(bytes))
-}
-
-fn value(bytes: Vec<u8>) -> StorageValue {
-    StorageValue {
-        bytes: Bytes::from(bytes),
-    }
-}
-
-fn full_value(value: StorageProjectedValue) -> Option<Vec<u8>> {
-    match value {
-        StorageProjectedValue::FullValue(bytes) => Some(bytes.to_vec()),
-        StorageProjectedValue::KeyOnly => None,
-    }
-}
-
-fn encode_commit_root(metadata: &TrackedStateCommitRoot) -> Result<Vec<u8>, LixError> {
-    let mut out = Vec::new();
-    out.extend_from_slice(COMMIT_ROOT_MAGIC);
-    write_string(&mut out, &metadata.commit_id)?;
-    out.extend_from_slice(metadata.root_id.as_bytes());
-    write_u32(&mut out, metadata.parent_roots.len(), "parent root count")?;
-    for parent in &metadata.parent_roots {
-        write_string(&mut out, &parent.commit_id)?;
-        out.extend_from_slice(parent.root_id.as_bytes());
-    }
-    out.extend_from_slice(&metadata.changed_key_count.to_le_bytes());
-    out.extend_from_slice(&metadata.row_count_estimate.to_le_bytes());
-    out.extend_from_slice(&metadata.tree_height.to_le_bytes());
-    out.extend_from_slice(&metadata.primary_chunk_count.to_le_bytes());
-    out.extend_from_slice(&metadata.primary_chunk_bytes.to_le_bytes());
-    Ok(out)
-}
-
-fn decode_commit_root(bytes: &[u8]) -> Result<TrackedStateCommitRoot, LixError> {
-    let mut cursor = CommitRootCursor { bytes, offset: 0 };
-    cursor.expect_magic()?;
-    let commit_id = cursor.read_string("commit_id")?;
-    let root_id = cursor.read_root_id("root_id")?;
-    let parent_count = cursor.read_u32("parent root count")? as usize;
-    let mut parent_roots = Vec::with_capacity(parent_count);
-    for _ in 0..parent_count {
-        parent_roots.push(TrackedStateCommitRootParent {
-            commit_id: cursor.read_string("parent commit_id")?,
-            root_id: cursor.read_root_id("parent root_id")?,
-        });
-    }
-    let changed_key_count = cursor.read_u64("changed_key_count")?;
-    let row_count_estimate = cursor.read_u64("row_count_estimate")?;
-    let tree_height = cursor.read_u32("tree_height")?;
-    let primary_chunk_count = cursor.read_u64("primary_chunk_count")?;
-    let primary_chunk_bytes = cursor.read_u64("primary_chunk_bytes")?;
-    cursor.expect_end()?;
-    Ok(TrackedStateCommitRoot {
-        commit_id,
-        root_id,
-        parent_roots,
-        changed_key_count,
-        row_count_estimate,
-        tree_height,
-        primary_chunk_count,
-        primary_chunk_bytes,
-    })
-}
-
-fn write_string(out: &mut Vec<u8>, value: &str) -> Result<(), LixError> {
-    write_u32(out, value.len(), "string length")?;
-    out.extend_from_slice(value.as_bytes());
-    Ok(())
-}
-
-fn write_u32(out: &mut Vec<u8>, value: usize, field: &str) -> Result<(), LixError> {
-    let value = u32::try_from(value).map_err(|_| {
-        LixError::new(
-            LixError::CODE_INTERNAL_ERROR,
-            format!("tracked_state commit root metadata {field} exceeds u32"),
-        )
-    })?;
-    out.extend_from_slice(&value.to_le_bytes());
-    Ok(())
-}
-
-struct CommitRootCursor<'a> {
-    bytes: &'a [u8],
-    offset: usize,
-}
-
-impl CommitRootCursor<'_> {
-    fn expect_magic(&mut self) -> Result<(), LixError> {
-        let magic = self.read_exact(COMMIT_ROOT_MAGIC.len(), "magic")?;
-        if magic != COMMIT_ROOT_MAGIC {
-            return Err(LixError::new(
-                LixError::CODE_INTERNAL_ERROR,
-                "failed to decode tracked_state commit_root: bad magic",
-            ));
-        }
-        Ok(())
-    }
-
-    fn expect_end(&self) -> Result<(), LixError> {
-        if self.offset != self.bytes.len() {
-            return Err(LixError::new(
-                LixError::CODE_INTERNAL_ERROR,
-                "failed to decode tracked_state commit_root: trailing bytes",
-            ));
-        }
-        Ok(())
-    }
-
-    fn read_string(&mut self, field: &str) -> Result<String, LixError> {
-        let len = self.read_u32(field)? as usize;
-        let bytes = self.read_exact(len, field)?;
-        String::from_utf8(bytes.to_vec()).map_err(|error| {
-            LixError::new(
-                LixError::CODE_INTERNAL_ERROR,
-                format!("failed to decode tracked_state commit_root {field}: {error}"),
-            )
-        })
-    }
-
-    fn read_root_id(&mut self, field: &str) -> Result<TrackedStateRootId, LixError> {
-        let bytes = self.read_exact(TRACKED_STATE_HASH_BYTES, field)?;
-        TrackedStateRootId::from_slice(bytes)
-    }
-
-    fn read_u32(&mut self, field: &str) -> Result<u32, LixError> {
-        let bytes = self.read_exact(std::mem::size_of::<u32>(), field)?;
-        Ok(u32::from_le_bytes(bytes.try_into().expect("fixed u32")))
-    }
-
-    fn read_u64(&mut self, field: &str) -> Result<u64, LixError> {
-        let bytes = self.read_exact(std::mem::size_of::<u64>(), field)?;
-        Ok(u64::from_le_bytes(bytes.try_into().expect("fixed u64")))
-    }
-
-    fn read_exact(&mut self, len: usize, field: &str) -> Result<&[u8], LixError> {
-        let end = self.offset.checked_add(len).ok_or_else(|| {
-            LixError::new(
-                LixError::CODE_INTERNAL_ERROR,
-                format!("failed to decode tracked_state commit_root {field}: overflow"),
-            )
-        })?;
-        if end > self.bytes.len() {
-            return Err(LixError::new(
-                LixError::CODE_INTERNAL_ERROR,
-                format!("failed to decode tracked_state commit_root {field}: truncated"),
-            ));
-        }
-        let out = &self.bytes[self.offset..end];
-        self.offset = end;
-        Ok(out)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::collections::BTreeMap;
-    use std::fs;
-    use std::path::{Path, PathBuf};
-
-    use crate::binary_cas::kv::{
-        BINARY_CAS_CHUNK_SPACE, BINARY_CAS_MANIFEST_CHUNK_SPACE, BINARY_CAS_MANIFEST_SPACE,
-    };
-    use crate::changelog::{CHANGE_SPACE, COMMIT_CHANGE_REF_CHUNK_SPACE, COMMIT_SPACE};
-    use crate::json_store::store::JSON_SPACE;
-    use crate::untracked_state::storage::UNTRACKED_STATE_ROW_SPACE;
-
-    use super::{TRACKED_STATE_COMMIT_ROOT_SPACE, TRACKED_STATE_TREE_CHUNK_SPACE};
-
-    #[test]
-    fn native_storage_space_ids_are_unique_across_owner_layouts() {
-        let spaces = [
-            UNTRACKED_STATE_ROW_SPACE,
-            JSON_SPACE,
-            TRACKED_STATE_TREE_CHUNK_SPACE,
-            TRACKED_STATE_COMMIT_ROOT_SPACE,
-            BINARY_CAS_MANIFEST_SPACE,
-            BINARY_CAS_MANIFEST_CHUNK_SPACE,
-            BINARY_CAS_CHUNK_SPACE,
-            COMMIT_SPACE,
-            CHANGE_SPACE,
-            COMMIT_CHANGE_REF_CHUNK_SPACE,
-        ];
-        let mut seen = BTreeMap::new();
-        for space in spaces {
-            assert_eq!(
-                seen.insert(space.id, space.name),
-                None,
-                "storage space id {:?} is reused by {} and {}",
-                space.id,
-                seen.get(&space.id).copied().unwrap_or(space.name),
-                space.name
-            );
-        }
-    }
-
-    #[test]
-    fn production_tracked_state_sources_do_not_call_storage_batch_writer() {
-        let tracked_state_dir = Path::new(env!("CARGO_MANIFEST_DIR")).join("src/tracked_state");
-        let forbidden = ["write", "kv", "batch"].join("_");
-
-        for path in rust_sources(&tracked_state_dir) {
-            let source =
-                fs::read_to_string(&path).expect("tracked_state source should be readable");
-            for (line_number, line) in production_lines(&source) {
-                assert!(
-                    !line.contains(&forbidden),
-                    "production tracked_state source must stage into StorageWriteSet instead of calling {forbidden}: {}:{}",
-                    path.display(),
-                    line_number
-                );
-            }
-        }
-    }
-
-    fn rust_sources(dir: &Path) -> Vec<PathBuf> {
-        let mut sources = Vec::new();
-        for entry in fs::read_dir(dir).expect("tracked_state source dir should be readable") {
-            let path = entry
-                .expect("tracked_state source entry should be readable")
-                .path();
-            if path.is_dir() {
-                sources.extend(rust_sources(&path));
-            } else if path.extension().and_then(|extension| extension.to_str()) == Some("rs") {
-                sources.push(path);
-            }
-        }
-        sources
-    }
-
-    fn production_lines(source: &str) -> Vec<(usize, &str)> {
-        let mut lines = Vec::new();
-        let mut skipping_cfg_test_item = false;
-        let mut pending_cfg_test = false;
-        let mut item_started = false;
-        let mut brace_depth = 0i32;
-
-        for (index, line) in source.lines().enumerate() {
-            let trimmed = line.trim();
-            if trimmed == "#[cfg(test)]" {
-                pending_cfg_test = true;
-                continue;
-            }
-
-            if pending_cfg_test || skipping_cfg_test_item {
-                if pending_cfg_test && !item_started && trimmed.ends_with(';') {
-                    pending_cfg_test = false;
-                    continue;
-                }
-                let opens = line.matches('{').count() as i32;
-                let closes = line.matches('}').count() as i32;
-                if opens > 0 {
-                    item_started = true;
-                    skipping_cfg_test_item = true;
-                }
-                if item_started {
-                    brace_depth += opens - closes;
-                    if brace_depth <= 0 {
-                        pending_cfg_test = false;
-                        skipping_cfg_test_item = false;
-                        item_started = false;
-                        brace_depth = 0;
-                    }
-                }
-                continue;
-            }
-
-            lines.push((index + 1, line));
-        }
-
-        lines
-    }
-}