Function bodies 69 total

test_save_load_with_experiments function · rust · L106-L127 (22 LOC)

src/persistence.rs

    fn test_save_load_with_experiments() {
        let dir = tempfile::tempdir().unwrap();
        let mut g = AmureGraph::new();

        let mut n = Node::new("hypothesis with experiments".into());
        n.experiments.push(crate::node::Experiment {
            id: uuid::Uuid::new_v4(),
            kind: crate::node::ExperimentKind::Universe,
            target: "BTC,ETH".into(),
            result: serde_json::json!({"IR": 0.5}),
            verdict: crate::node::Verdict::Support,
            note: Some("good".into()),
        });
        let id = n.id;
        g.add_node(n);

        g.save(dir.path()).unwrap();
        let g2 = AmureGraph::load(dir.path()).unwrap();
        let loaded = g2.get_node(&id).unwrap();
        assert_eq!(loaded.experiments.len(), 1);
        assert_eq!(loaded.experiments[0].target, "BTC,ETH");
    }

default function · rust · L37-L45 (9 LOC)

src/search.rs

    fn default() -> Self {
        Self {
            top_k: 10,
            max_hops: 2,
            include_decline: false,
            mmr_lambda: 0.7,
            status_filter: None,
        }
    }

search function · rust · L49-L104 (56 LOC)

src/search.rs

pub fn search(
    graph: &AmureGraph,
    opts: &SearchOptions,
    query_embedding: Option<&[f32]>,
) -> Vec<SearchResult> {
    // No embedding → no results (no keyword fallback)
    let q_emb = match query_embedding {
        Some(emb) => emb,
        None => return Vec::new(),
    };

    // Step 1: Cosine similarity against all non-Draft nodes
    let mut emb_scored: Vec<(Uuid, f64)> = graph.nodes.iter()
        .filter(|(_, node)| node.status != NodeStatus::Draft)
        .filter(|(_, node)| opts.include_decline || node.status != NodeStatus::Decline)
        .filter_map(|(id, node)| {
            let emb = node.embedding.as_ref()?;
            let sim = cosine_similarity(q_emb, emb);
            if sim > 0.1 { Some((*id, sim)) } else { None }
        })
        .collect();
    emb_scored.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
    emb_scored.truncate(opts.top_k * 3);

    // Step 2: Graph walk from entry points
    let candidates = graph_walk(

search_balanced function · rust · L107-L139 (33 LOC)

src/search.rs

pub fn search_balanced(
    graph: &AmureGraph,
    n: usize,
    query_embedding: Option<&[f32]>,
) -> Vec<SearchResult> {
    let q_emb = match query_embedding {
        Some(emb) => emb,
        None => return Vec::new(),
    };

    // Get Accept results
    let accept_opts = SearchOptions {
        top_k: n,
        include_decline: false,
        status_filter: Some("Accept".to_string()),
        ..Default::default()
    };
    let accept_results = search(graph, &accept_opts, Some(q_emb));

    // Get Decline results
    let decline_opts = SearchOptions {
        top_k: n,
        include_decline: true,
        status_filter: Some("Decline".to_string()),
        ..Default::default()
    };
    let decline_results = search(graph, &decline_opts, Some(q_emb));

    let mut results = Vec::new();
    results.extend(accept_results);
    results.extend(decline_results);
    results
}

make_node_with_embedding function · rust · L243-L249 (7 LOC)

src/search.rs

    fn make_node_with_embedding(statement: &str, emb: Vec<f32>, status: NodeStatus) -> Node {
        let mut n = Node::new(statement.into());
        n.status = status;
        n.embedding = Some(emb);
        n
    }

build_test_graph function · rust · L250-L280 (31 LOC)

src/search.rs

    fn build_test_graph() -> AmureGraph {
        let mut g = AmureGraph::new();

        g.add_node(make_node_with_embedding(
            "OI 변화량은 momentum의 선행지표다",
            vec![1.0, 0.0, 0.0],
            NodeStatus::Accept,
        ));

        g.add_node(make_node_with_embedding(
            "funding rate 극단값은 mean reversion 시그널이다",
            vec![0.0, 1.0, 0.0],
            NodeStatus::Accept,
        ));

        g.add_node(make_node_with_embedding(
            "OI 감소는 디레버리징의 시그널이다",
            vec![0.9, 0.1, 0.0],
            NodeStatus::Decline,
        ));

        // Draft node — should never appear in results
        g.add_node(make_node_with_embedding(
            "Draft hypothesis",
            vec![1.0, 0.0, 0.0],
            NodeStatus::Draft,
        ));

        g
    }

test_search_returns_empty_without_embedding function · rust · L283-L287 (5 LOC)

src/search.rs

    fn test_search_returns_empty_without_embedding() {
        let g = build_test_graph();
        let results = search(&g, &SearchOptions::default(), None);
        assert!(results.is_empty());
    }

Same scanner, your repo: https://repobility.com — Repobility

test_search_basic function · rust · L290-L297 (8 LOC)

src/search.rs

    fn test_search_basic() {
        let g = build_test_graph();
        let query_emb = vec![1.0, 0.0, 0.0];
        let results = search(&g, &SearchOptions::default(), Some(&query_emb));
        assert!(!results.is_empty());
        // First result should be the OI hypothesis (highest cosine similarity)
        assert!(results[0].statement.contains("OI"));
    }

test_search_excludes_draft function · rust · L300-L305 (6 LOC)

src/search.rs

    fn test_search_excludes_draft() {
        let g = build_test_graph();
        let query_emb = vec![1.0, 0.0, 0.0];
        let results = search(&g, &SearchOptions { top_k: 20, include_decline: true, ..Default::default() }, Some(&query_emb));
        assert!(results.iter().all(|r| r.status != "Draft"));
    }

test_search_excludes_decline_by_default function · rust · L308-L313 (6 LOC)

src/search.rs

    fn test_search_excludes_decline_by_default() {
        let g = build_test_graph();
        let query_emb = vec![1.0, 0.0, 0.0];
        let results = search(&g, &SearchOptions::default(), Some(&query_emb));
        assert!(results.iter().all(|r| r.status != "Decline"));
    }

test_search_includes_decline_when_requested function · rust · L316-L322 (7 LOC)

src/search.rs

    fn test_search_includes_decline_when_requested() {
        let g = build_test_graph();
        let query_emb = vec![1.0, 0.0, 0.0];
        let results = search(&g, &SearchOptions { include_decline: true, ..Default::default() }, Some(&query_emb));
        let has_decline = results.iter().any(|r| r.status == "Decline");
        assert!(has_decline);
    }

test_balanced_search function · rust · L325-L334 (10 LOC)

src/search.rs

    fn test_balanced_search() {
        let g = build_test_graph();
        let query_emb = vec![1.0, 0.0, 0.0];
        let results = search_balanced(&g, 5, Some(&query_emb));
        // Should have results from both Accept and Decline
        let has_accept = results.iter().any(|r| r.status == "Accept");
        let has_decline = results.iter().any(|r| r.status == "Decline");
        assert!(has_accept);
        assert!(has_decline);
    }

dashboard function · rust · L80-L83 (4 LOC)

src/server.rs

async fn dashboard() -> Html<&'static str> {
    Html(DASHBOARD)
}

node_json function · rust · L541-L567 (27 LOC)

src/server.rs

fn node_json(n: &Node) -> serde_json::Value {
    let experiments: Vec<serde_json::Value> = n.experiments.iter().map(|exp| {
        serde_json::json!({
            "id": exp.id,
            "kind": format!("{:?}", exp.kind),
            "target": exp.target,
            "result": exp.result,
            "verdict": format!("{:?}", exp.verdict),
            "note": exp.note,
        })
    }).collect();

    serde_json::json!({
        "id": n.id,
        "kind": format!("{:?}", n.kind),
        "statement": n.statement,
        "abstract_": n.abstract_,
        "discussion": n.discussion,
        "status": format!("{:?}", n.status),
        "experiments": experiments,
        "n_experiments": n.experiments.len(),
        "created_at": n.created_at.to_rfc3339(),
        "updated_at": n.updated_at.to_rfc3339(),
        "has_embedding": n.embedding.is_some(),
    })
}

edge_json function · rust · L568-L574 (7 LOC)

src/server.rs

fn edge_json(e: &Edge) -> serde_json::Value {
    serde_json::json!({
        "id": e.id, "source": e.source, "target": e.target,
        "kind": format!("{:?}", e.kind), "reason": e.reason,
    })
}

Repobility (the analyzer behind this table) · https://repobility.com

parse_node_status function · rust · L575-L583 (9 LOC)

src/server.rs

fn parse_node_status(s: &str) -> NodeStatus {
    match s {
        "Draft" | "draft" => NodeStatus::Draft,
        "Accept" | "accept" | "Accepted" | "accepted" => NodeStatus::Accept,
        "Decline" | "decline" | "Declined" | "declined" | "Rejected" | "rejected" => NodeStatus::Decline,
        _ => NodeStatus::Draft,
    }
}

parse_edge_kind function · rust · L584-L593 (10 LOC)

src/server.rs

fn parse_edge_kind(s: &str) -> EdgeKind {
    match s {
        "Reference" | "reference" => EdgeKind::Reference,
        "Superset" | "superset" => EdgeKind::Superset,
        "Subset" | "subset" => EdgeKind::Subset,
        "Orthogonal" | "orthogonal" => EdgeKind::Orthogonal,
        _ => EdgeKind::Reference,
    }
}

parse_experiment_kind function · rust · L594-L603 (10 LOC)

src/server.rs

fn parse_experiment_kind(s: &str) -> ExperimentKind {
    match s {
        "Universe" | "universe" => ExperimentKind::Universe,
        "Regime" | "regime" => ExperimentKind::Regime,
        "Temporal" | "temporal" => ExperimentKind::Temporal,
        "Combo" | "combo" => ExperimentKind::Combo,
        _ => ExperimentKind::Universe,
    }
}

parse_verdict function · rust · L604-L611 (8 LOC)

src/server.rs

fn parse_verdict(s: &str) -> Verdict {
    match s {
        "Support" | "support" => Verdict::Support,
        "Rebut" | "rebut" => Verdict::Rebut,
        _ => Verdict::Support,
    }
}

‹ prevpage 2 / 2