Add MyST parsing

Author: chrisjsewell

crates/analyzer/src/analyze/crate_.rs

@@ -73,7 +73,7 @@ pub fn analyze_crate(path: &str) -> Result<AnalysisResult> {
 
     // read the top-level module
     let content = std::fs::read_to_string(&root_file)?;
-    let (module, structs, enums) = Module::parse(&crate_.name, &content).context(format!(
+    let (module, structs, enums) = Module::parse(&[&crate_.name], &content).context(format!(
         "Error parsing module {}",
         root_file.to_string_lossy()
     ))?;
@@ -85,7 +85,7 @@ pub fn analyze_crate(path: &str) -> Result<AnalysisResult> {
             (
                 root_file.parent().unwrap().to_path_buf(),
                 s.to_string(),
-                crate_.name.clone(),
+                vec![crate_.name.clone()],
             )
         })
         .collect::<Vec<_>>();
@@ -94,7 +94,7 @@ pub fn analyze_crate(path: &str) -> Result<AnalysisResult> {
 
     // recursively find/read the public sub-modules
     let mut read_modules = vec![];
-    while let Some((parent_dir, module_name, parent_ident)) = modules_to_read.pop() {
+    while let Some((parent_dir, module_name, parent)) = modules_to_read.pop() {
         let (module_path, submodule_dir) =
             if parent_dir.join(&module_name).with_extension("rs").exists() {
                 (
@@ -117,16 +117,20 @@ pub fn analyze_crate(path: &str) -> Result<AnalysisResult> {
         read_modules.push(module_path.clone());
 
         let content = std::fs::read_to_string(&module_path)?;
-        let path_name = format!("{}::{}", parent_ident, module_name);
-        let (module, structs, enums) = Module::parse(&path_name, &content).context(format!(
+        let path: Vec<String> = [&parent[..], &[module_name]].concat();
+        let (module, structs, enums) = Module::parse(
+            &path.iter().map(|s| s.as_str()).collect::<Vec<&str>>(),
+            &content,
+        )
+        .context(format!(
             "Error parsing module {}",
             module_path.to_string_lossy()
         ))?;
         modules_to_read.extend(
             module
                 .declarations
                 .iter()
-                .map(|s| (submodule_dir.clone(), s.to_string(), path_name.clone()))
+                .map(|s| (submodule_dir.clone(), s.to_string(), path.clone()))
                 .collect::<Vec<_>>(),
         );
         result_.modules.push(module);
@@ -256,30 +260,49 @@ mod tests {
 
         assert_yaml_snapshot!(crate_, @r###"
         ---
-        crates:
-          - name: my_crate
-            version: 0.1.0
-            docstring: The crate docstring
+        crate_:
+          name: my_crate
+          version: 0.1.0
+          docstring: The crate docstring
         modules:
-          - name: "my_crate::my_module"
+          - path:
+              - my_crate
+              - my_module
             docstring: The module docstring
             declarations:
               - my_submodule
-          - name: "my_crate::my_module::my_submodule"
+          - path:
+              - my_crate
+              - my_module
+              - my_submodule
             docstring: The sub-module docstring
             declarations: []
         structs:
-          - name: "my_crate::my_module::DummyStruct1"
+          - path:
+              - my_crate
+              - my_module
+              - DummyStruct1
             docstring: The struct1 docstring
             fields: []
-          - name: "my_crate::my_module::my_submodule::DummyStruct2"
+          - path:
+              - my_crate
+              - my_module
+              - my_submodule
+              - DummyStruct2
             docstring: The struct2 docstring
             fields: []
         enums:
-          - name: "my_crate::my_module::DummyEnum1"
+          - path:
+              - my_crate
+              - my_module
+              - DummyEnum1
             docstring: The enum1 docstring
             variants: []
-          - name: "my_crate::my_module::my_submodule::DummyEnum2"
+          - path:
+              - my_crate
+              - my_module
+              - my_submodule
+              - DummyEnum2
             docstring: The enum2 docstring
             variants: []
         "###);

crates/analyzer/src/analyze/enum_.rs

@@ -13,21 +13,30 @@ use super::{docstring_from_attrs, struct_::Field};
 ///     :tags: rust
 ///     :status: in-progress
 pub struct Enum {
-    /// The name of the enum
-    pub name: String,
+    /// The fully qualified name of the enum
+    pub path: Vec<String>,
     /// The docstring of the enum
     pub docstring: String,
     pub variants: Vec<Variant>,
 }
 
 impl Enum {
+    /// Fully qualified name of the variant
+    pub fn path_str(&self) -> String {
+        self.path.join("::")
+    }
     /// Extract the relevant information from the AST
-    pub fn parse(parent: &str, ast: &ItemEnum) -> Self {
-        let name = format!("{}::{}", parent, ast.ident);
+    pub fn parse(parent: &[&str], ast: &ItemEnum) -> Self {
+        let name = ast.ident.to_string();
+        let path: Vec<&str> = parent.iter().copied().chain(Some(name.as_str())).collect();
         let docstring = docstring_from_attrs(&ast.attrs);
-        let variants = ast.variants.iter().map(Variant::parse).collect::<Vec<_>>();
+        let variants = ast
+            .variants
+            .iter()
+            .map(|v| Variant::parse(&path, v))
+            .collect::<Vec<_>>();
         Self {
-            name,
+            path: path.iter().map(|s| s.to_string()).collect(),
             docstring,
             variants,
         }
@@ -37,26 +46,40 @@ impl Enum {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 /// Representation of a Enum variant
 pub struct Variant {
-    /// The name of the variant
-    pub name: String,
+    /// The fully qualified name of the variant
+    pub path: Vec<String>,
     /// The docstring of the variant
     pub docstring: String,
     pub discriminant: Option<String>, // TODO shouldn't just be a string
     pub fields: Vec<Field>,
 }
 
 impl Variant {
+    /// Fully qualified name of the variant
+    pub fn name(&self) -> String {
+        self.path.join("::")
+    }
     /// Extract the relevant information from the AST
-    pub fn parse(ast: &syn::Variant) -> Self {
+    pub fn parse(parent: &[&str], ast: &syn::Variant) -> Self {
         let name = ast.ident.to_string();
+        let path = parent
+            .iter()
+            .copied()
+            .chain(Some(name.as_str()))
+            .collect::<Vec<&str>>();
         let docstring = docstring_from_attrs(&ast.attrs);
         let discriminant = ast
             .discriminant
             .as_ref()
             .map(|(_, e)| quote! {#e}.to_string());
-        let fields = ast.fields.iter().map(Field::parse).collect::<Vec<_>>();
+        let fields = ast
+            .fields
+            .iter()
+            .enumerate()
+            .map(|(i, f)| Field::parse(&path, i, f))
+            .collect::<Vec<_>>();
         Self {
-            name,
+            path: path.iter().map(|s| s.to_string()).collect(),
             docstring,
             discriminant,
             fields,
@@ -89,33 +112,55 @@ mod tests {
                 },
             }
         };
-        let enum_ = Enum::parse("crate", &ast);
+        let enum_ = Enum::parse(&["crate"], &ast);
         assert_yaml_snapshot!(enum_, @r###"
         ---
-        name: "crate::MyEnum"
+        path:
+          - crate
+          - MyEnum
         docstring: "Multi-line\ndocstring"
         variants:
-          - name: MyVariant1
+          - path:
+              - crate
+              - MyEnum
+              - MyVariant1
             docstring: variant without fields
             discriminant: ~
             fields: []
-          - name: MyVariant2
+          - path:
+              - crate
+              - MyEnum
+              - MyVariant2
             docstring: variant with discriminant
             discriminant: "1"
             fields: []
-          - name: MyVariant3
+          - path:
+              - crate
+              - MyEnum
+              - MyVariant3
             docstring: variant with unnamed fields
             discriminant: ~
             fields:
-              - name: ~
+              - path:
+                  - crate
+                  - MyEnum
+                  - MyVariant3
+                  - "0"
                 docstring: ""
                 type_:
                   - Path: u8
-          - name: MyVariant3
+          - path:
+              - crate
+              - MyEnum
+              - MyVariant3
             docstring: variant with named fields
             discriminant: ~
             fields:
-              - name: field
+              - path:
+                  - crate
+                  - MyEnum
+                  - MyVariant3
+                  - field
                 docstring: field docstring
                 type_:
                   - Path: u8

crates/analyzer/src/analyze/module.rs

@@ -13,19 +13,23 @@ use super::{docstring_from_attrs, enum_::Enum, struct_::Struct};
 ///     :tags: rust
 ///     :status: in-progress
 pub struct Module {
-    pub name: String,
+    /// The fully qualified name of the module
+    pub path: Vec<String>,
     pub docstring: String,
     /// The public declarations in the module
     pub declarations: Vec<String>,
 }
 
 impl Module {
+    /// Fully qualified name of the variant
+    pub fn path_str(&self) -> String {
+        self.path.join("::")
+    }
     /// Extract the relevant information from the AST
-    pub fn parse(name: &str, content: &str) -> Result<(Self, Vec<Struct>, Vec<Enum>)> {
+    pub fn parse(path: &[&str], content: &str) -> Result<(Self, Vec<Struct>, Vec<Enum>)> {
         let syntax = parse_file(content)?;
-
         let mut mod_ = Self {
-            name: name.to_string(),
+            path: path.iter().map(|s| s.to_string()).collect(),
             docstring: docstring_from_attrs(&syntax.attrs),
             declarations: vec![],
         };
@@ -44,13 +48,13 @@ impl Module {
                 }
                 syn::Item::Struct(struct_item) => {
                     if let syn::Visibility::Public(_) = struct_item.vis {
-                        let struct_ = Struct::parse(name, struct_item);
+                        let struct_ = Struct::parse(path, struct_item);
                         structs.push(struct_);
                     }
                 }
                 syn::Item::Enum(enum_item) => {
                     if let syn::Visibility::Public(_) = enum_item.vis {
-                        let enum_ = Enum::parse(name, enum_item);
+                        let enum_ = Enum::parse(path, enum_item);
                         enums.push(enum_);
                     }
                 }
@@ -81,17 +85,23 @@ pub enum MyEnum {
     MyVariant1,
 }
 "###;
-        let mod_ = Module::parse("test", content).unwrap();
+        let mod_ = Module::parse(&["test"], content).unwrap();
         assert_yaml_snapshot!(mod_, @r###"
         ---
-        - name: test
+        - path:
+            - test
           docstring: "Multi-line\ndocstring"
           declarations: []
         - []
-        - - name: "test::MyEnum"
+        - - path:
+              - test
+              - MyEnum
             docstring: ""
             variants:
-              - name: MyVariant1
+              - path:
+                  - test
+                  - MyEnum
+                  - MyVariant1
                 docstring: ""
                 discriminant: ~
                 fields: []