weavatrix-parse 0.3.5

Dependency-free source tokenizer and structural extractor for repository intelligence
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use super::extract;
use crate::facts::{DeclarationKind, ImportBinding};

#[test]
fn methods_belong_to_their_class_and_indentation_closes_scopes() {
    let source = "class Service:\n\
         \x20   def run(self):\n\
         \x20       return self.helper()\n\
         \x20   def helper(self):\n\
         \x20       return 1\n\
         \n\
         def module_level():\n\
         \x20   return Service()\n";
    let facts = extract(source);
    let declared = facts
        .declarations
        .iter()
        .map(|item| (item.name.as_str(), item.kind, item.owner.as_deref()))
        .collect::<Vec<_>>();
    assert_eq!(
        declared,
        [
            ("Service", DeclarationKind::Class, None),
            ("run", DeclarationKind::Method, Some("Service")),
            ("helper", DeclarationKind::Method, Some("Service")),
            ("module_level", DeclarationKind::Function, None),
        ],
        "dedenting to column one leaves the class"
    );
}

#[test]
fn a_docstring_is_text_even_when_it_looks_like_code() {
    let source = "def real():\n\
         \x20   \"\"\"\n\
         \x20   def fake():\n\
         \x20       import nothing\n\
         \x20   \"\"\"\n\
         \x20   return 1\n";
    let facts = extract(source);
    assert_eq!(
        facts
            .declarations
            .iter()
            .map(|item| item.name.as_str())
            .collect::<Vec<_>>(),
        ["real"],
        "the definition inside the docstring is not a declaration"
    );
    assert!(
        facts.imports.is_empty(),
        "the import inside the docstring is not a dependency"
    );
}

#[test]
fn reads_the_import_forms_python_writes() {
    let source = "import os\n\
         import pkg.module\n\
         import json, time\n\
         import numpy as np\n\
         from .relative import thing as local_thing\n\
         from ..parent.pkg import other\n";
    let imports = extract(source).imports;
    let specifiers = imports
        .iter()
        .map(|import| import.specifier.as_str())
        .collect::<Vec<_>>();
    assert_eq!(
        specifiers,
        [
            "os",
            "pkg.module",
            "json",
            "time",
            "numpy",
            ".relative",
            "..parent.pkg",
        ]
    );
    let numpy = imports
        .iter()
        .find(|import| import.specifier == "numpy")
        .expect("numpy import");
    assert_eq!(numpy.names, ["np"]);
    assert_eq!(
        numpy.bindings,
        [ImportBinding {
            imported: "numpy".to_owned(),
            local: "np".to_owned(),
        }]
    );
    let relative = imports
        .iter()
        .find(|import| import.specifier == ".relative")
        .expect("relative import");
    assert_eq!(relative.names, ["local_thing"]);
    assert_eq!(
        relative.bindings,
        [ImportBinding {
            imported: "thing".to_owned(),
            local: "local_thing".to_owned(),
        }]
    );
}

#[test]
fn underscore_names_are_not_exported() {
    let facts = extract("def public():\n    pass\ndef _private():\n    pass\n");
    let exported = facts
        .declarations
        .iter()
        .map(|item| (item.name.as_str(), item.exported))
        .collect::<Vec<_>>();
    assert_eq!(exported, [("public", true), ("_private", false)]);
}

#[test]
fn f_string_expressions_keep_calls_and_ignore_literal_text() {
    let facts = extract(
        "def path(selector):\n    return f\"/{resolve_target(selector)} resolve_target {{literal}}\"\n",
    );
    let calls = facts
        .references
        .iter()
        .filter(|reference| reference.kind == crate::facts::ReferenceKind::Call)
        .collect::<Vec<_>>();

    assert_eq!(calls.len(), 1, "only executable interpolation is a call");
    assert_eq!(calls[0].name, "resolve_target");
    assert_eq!(calls[0].owner.as_deref(), Some("path"));
    assert_eq!(calls[0].span.line, 2);
}