vvv-engine 0.2.0

Composes vvv plugins into refactoring pipelines
Documentation
mod common;
use common::Fake;
use std::{path::Path, sync::Arc};
use vvv_engine::{
    ContextBudget, ContextOutcome, ContextQuery, ContextRelation, Engine, EngineError, Languages,
    MemoryVfs, NavigationQuery, Position, SourceAnchor, Span, Symbol, SymbolKind, Vfs, Workspace,
};

struct Fixture {
    engine: Engine,
    vfs: Arc<MemoryVfs>,
    source: String,
}
impl Fixture {
    fn new(tail: &str) -> Self {
        let source = format!("def Helper\ndef Root Helper {tail}");
        let symbols = vec![
            Symbol::plain(
                SymbolKind::Function,
                "Helper",
                Span::new(4, 10),
                Span::new(0, 10),
            ),
            Symbol::plain(
                SymbolKind::Function,
                "Root",
                Span::new(15, 19),
                Span::new(11, source.len()),
            ),
        ];
        let vfs = Arc::new(
            MemoryVfs::new()
                .with_file("/ws/package", "ws")
                .with_file("/ws/a.p", &source),
        );
        let engine = Engine::new(
            Workspace::new("/ws", vfs.clone()),
            Languages::new().with(Fake::default().with_symbols(symbols)),
        );
        Self {
            engine,
            vfs,
            source,
        }
    }
    fn query(&self, root: bool) -> ContextQuery {
        ContextQuery::new(NavigationQuery::at("a.p", Position::new(u32::from(root), 4)).origin)
    }
}
#[test]
fn exact_context_contains_direct_relationships_and_deterministic_versions() {
    let f = Fixture::new("body");
    let reply = f.query(true).execute(&f.engine).unwrap();
    assert!(matches!(reply.outcome, ContextOutcome::Resolved));
    assert_eq!(reply.items.len(), 2);
    assert_eq!(reply.items[0].relation, ContextRelation::Definition);
    assert_eq!(
        reply.items[1].relation,
        ContextRelation::ReferencedDefinition
    );
    assert_eq!(reply.items[1].via.as_ref().unwrap().span, Span::new(20, 26));
    assert_eq!(reply.items[1].text, "def Helper");
    for item in &reply.items {
        assert_eq!(item.excerpt.path.as_path(), Path::new("a.p"));
        assert_eq!(
            item.text,
            f.source[item.excerpt.span.start..item.excerpt.span.end]
        );
    }
    let again = f.query(true).execute(&f.engine).unwrap();
    assert_eq!(reply, again);
}
#[test]
fn incoming_context_is_confirmed_and_explicitly_same_spelling() {
    let f = Fixture::new("body");
    let mut query = f.query(false);
    query.references = true;
    let reply = query.execute(&f.engine).unwrap();
    assert!(reply.references_by_name);
    assert!(reply.items.iter().any(
        |item| item.relation == ContextRelation::Reference && item.text.starts_with("def Root")
    ));
}
#[test]
fn json_budget_counts_escaping_and_preserves_exact_unicode_excerpts() {
    let f = Fixture::new(&"é\"\\\n🙂".repeat(1500));
    for max_bytes in [1024, 1536, 2048, 8192] {
        let mut query = f.query(true);
        query.budget.max_bytes = max_bytes;
        let reply = query.execute(&f.engine).unwrap();
        assert!(serde_json::to_vec(&reply).unwrap().len() <= max_bytes);
        assert!(reply.omissions.byte_limit > 0);
        assert!(!reply.items.is_empty());
        for item in &reply.items {
            assert_eq!(
                item.text,
                f.source[item.excerpt.span.start..item.excerpt.span.end]
            );
        }
    }
}
#[test]
fn work_and_item_limits_report_omissions_and_invalid_limits_are_errors() {
    let f = Fixture::new("one two three");
    let mut query = f.query(true);
    query.budget = ContextBudget {
        max_items: 1,
        max_lookups: 1,
        ..ContextBudget::default()
    };
    let reply = query.execute(&f.engine).unwrap();
    assert_eq!(reply.items.len(), 1);
    assert!(reply.omissions.lookup_limit > 0);
    let mut query = f.query(true);
    query.budget.max_bytes = 0;
    assert!(matches!(
        query.execute(&f.engine),
        Err(EngineError::InvalidBudget)
    ));
}
#[test]
fn stale_context_origins_are_rejected_instead_of_relocated_by_name() {
    let f = Fixture::new("body");
    let reply = f.query(true).execute(&f.engine).unwrap();
    let origin = SourceAnchor {
        span: reply.items[0].target.name_span,
        ..reply.items[0].target.declaration.clone()
    };
    f.vfs
        .write(Path::new("/ws/a.p"), &(f.source.clone() + "changed"))
        .unwrap();
    let query = ContextQuery::new(NavigationQuery::occurrence(origin).origin);
    assert!(matches!(
        query.execute(&f.engine),
        Err(EngineError::StaleSource { .. })
    ));
}

#[test]
fn ambiguity_is_never_silently_narrowed_to_fit_a_budget() {
    let source = "def Root\n".repeat(20) + "Root";
    let engine = Engine::new(
        Workspace::new(
            "/ws",
            Arc::new(
                MemoryVfs::new()
                    .with_file("/ws/package", "ws")
                    .with_file("/ws/a.p", &source),
            ),
        ),
        Languages::new().with(Fake::default()),
    );
    let mut query = ContextQuery::new(NavigationQuery::at("a.p", Position::new(20, 0)).origin);
    let reply = query.clone().execute(&engine).unwrap();
    assert!(
        matches!(reply.outcome, ContextOutcome::Ambiguous { candidates } if candidates.len() == 20)
    );
    query.budget.max_bytes = 1024;
    assert!(matches!(
        query.execute(&engine),
        Err(EngineError::OutputLimit { .. })
    ));
}

#[test]
fn enclosing_body_is_opt_in_and_the_location_survives_paging() {
    use vvv_engine::{
        ContextPageQuery, ContinueQuery, PageBudget, PageReply, Selection, WorkBudget,
    };
    let source = "def Owner\n  def Method Owner\n";
    let method_start = source.find("def Method").unwrap();
    let symbols = vec![
        Symbol::plain(
            SymbolKind::Impl,
            "Owner",
            Span::new(4, 9),
            Span::new(0, source.len()),
        ),
        Symbol::plain(
            SymbolKind::Method,
            "Method",
            Span::new(method_start + 4, method_start + 10),
            Span::new(method_start, source.len() - 1),
        ),
    ];
    let engine = Engine::new(
        Workspace::new(
            "/ws",
            Arc::new(MemoryVfs::new().with_file("/ws/a.p", source)),
        ),
        Languages::new().with(Fake::default().with_symbols(symbols)),
    );
    let origin = NavigationQuery::at("a.p", Position::new(1, 7)).origin;
    let mut query = ContextQuery::new(origin.clone());
    let compact = query.clone().execute(&engine).unwrap();
    let enclosing = compact.enclosing.clone().unwrap();
    assert_eq!(enclosing.kind, SymbolKind::Impl);
    assert!(compact.items.iter().all(|item| item.target != enclosing));
    query.include_enclosing = true;
    let full = query.execute(&engine).unwrap();
    assert!(
        full.items
            .iter()
            .any(|i| i.target == enclosing && i.text == source)
    );
    for include_enclosing in [false, true] {
        let page = ContextPageQuery {
            detail: vvv_engine::ContextDetail::Body,
            origin: origin.clone(),
            selection: Selection::All,
            references: false,
            include_enclosing,
            page: PageBudget {
                max_items: 1,
                ..Default::default()
            },
            work: WorkBudget::default(),
        }
        .execute(&engine)
        .unwrap();
        let mut current = PageReply::Context(page);
        let mut owners = 0;
        loop {
            let PageReply::Context(page) = current else {
                panic!()
            };
            assert_eq!(page.enclosing, Some(enclosing.clone()));
            owners += page
                .items
                .iter()
                .filter(|i| i.item.target == enclosing)
                .count();
            let Some(cursor) = page.next_cursor else {
                break;
            };
            current = ContinueQuery {
                cursor,
                page: PageBudget::default(),
                work: None,
            }
            .execute(&engine)
            .unwrap();
        }
        assert_eq!(owners, usize::from(include_enclosing));
    }
}