✨ Initial addition of functions (#16)

Author: chrisjsewell

crates/analyzer/src/analyze.rs

@@ -2,6 +2,7 @@
 
 pub mod crate_;
 pub mod enum_;
+pub mod function;
 pub mod module;
 pub mod struct_;
 pub mod type_;

crates/analyzer/src/analyze/crate_.rs

@@ -2,7 +2,7 @@
 use anyhow::{Context, Result};
 use serde::{Deserialize, Serialize};
 
-use crate::data_model::{Crate, Enum, Module, Struct};
+use crate::data_model::{Crate, Enum, Function, Module, Struct};
 
 pub fn analyze_crate(path: &str) -> Result<AnalysisResult> {
     // make the path absolute
@@ -56,15 +56,10 @@ pub fn analyze_crate(path: &str) -> Result<AnalysisResult> {
         )));
     };
 
-    let mut result = AnalysisResult {
-        crate_: Crate {
-            name: crate_name,
-            version: cargo_toml.package.version.clone(),
-        },
-        modules: vec![],
-        structs: vec![],
-        enums: vec![],
-    };
+    let mut result = AnalysisResult::new(Crate {
+        name: crate_name,
+        version: cargo_toml.package.version.clone(),
+    });
 
     // check existence of the root module
     let root_module = path.join(to_root);
@@ -74,7 +69,7 @@ pub fn analyze_crate(path: &str) -> Result<AnalysisResult> {
 
     // read the top-level module
     let content = std::fs::read_to_string(&root_module)?;
-    let (module, structs, enums) =
+    let (module, structs, enums, functions) =
         Module::parse(Some(&root_module), &[&result.crate_.name], &content).context(format!(
             "Error parsing module {}",
             root_module.to_string_lossy()
@@ -94,6 +89,7 @@ pub fn analyze_crate(path: &str) -> Result<AnalysisResult> {
     result.modules.push(module);
     result.structs.extend(structs);
     result.enums.extend(enums);
+    result.functions.extend(functions);
 
     // recursively find/read the public sub-modules
     let mut read_modules = vec![];
@@ -121,7 +117,7 @@ pub fn analyze_crate(path: &str) -> Result<AnalysisResult> {
 
         let content = std::fs::read_to_string(&module_path)?;
         let path: Vec<String> = [&parent[..], &[module_name]].concat();
-        let (module, structs, enums) = Module::parse(
+        let (module, structs, enums, functions) = Module::parse(
             Some(&module_path),
             &path.iter().map(|s| s.as_str()).collect::<Vec<&str>>(),
             &content,
@@ -140,6 +136,7 @@ pub fn analyze_crate(path: &str) -> Result<AnalysisResult> {
         result.modules.push(module);
         result.structs.extend(structs);
         result.enums.extend(enums);
+        result.functions.extend(functions);
     }
 
     Ok(result)
@@ -152,6 +149,19 @@ pub struct AnalysisResult {
     pub modules: Vec<Module>,
     pub structs: Vec<Struct>,
     pub enums: Vec<Enum>,
+    pub functions: Vec<Function>,
+}
+
+impl AnalysisResult {
+    pub fn new(crate_: Crate) -> Self {
+        Self {
+            crate_,
+            modules: vec![],
+            structs: vec![],
+            enums: vec![],
+            functions: vec![],
+        }
+    }
 }
 
 #[derive(Debug, Deserialize)]
@@ -308,6 +318,7 @@ mod tests {
               - DummyEnum2
             docstring: The enum2 docstring
             variants: []
+        functions: []
         "###);
 
         Ok(())

crates/analyzer/src/analyze/function.rs

@@ -1 +1,42 @@
+use crate::data_model::Function;
 
+use super::docstring_from_attrs;
+
+impl Function {
+    /// Fully qualified name of the variant
+    pub fn path_str(&self) -> String {
+        self.path.join("::")
+    }
+    pub fn parse(parent: &[&str], ast: &syn::ItemFn) -> Self {
+        let name = ast.sig.ident.to_string();
+        let path: Vec<&str> = parent.iter().copied().chain(Some(name.as_str())).collect();
+        let docstring = docstring_from_attrs(&ast.attrs);
+        Self {
+            path: path.iter().map(|s| s.to_string()).collect(),
+            docstring,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use insta::assert_yaml_snapshot;
+
+    #[test]
+    fn test_function_parse() {
+        let item: syn::ItemFn = syn::parse_quote! {
+            /// This is a docstring
+            pub fn my_function() {}
+        };
+        let func = Function::parse(&["my_module"], &item);
+        assert_yaml_snapshot!(func, @r###"
+        ---
+        path:
+          - my_module
+          - my_function
+        docstring: This is a docstring
+        "###);
+    }
+}

crates/analyzer/src/analyze/macro.rs

@@ -4,7 +4,7 @@ use std::path::Path;
 use anyhow::Result;
 use syn::parse_file;
 
-use crate::data_model::{Enum, Module, Struct};
+use crate::data_model::{Enum, Function, Module, Struct};
 
 use super::docstring_from_attrs;
 
@@ -18,7 +18,7 @@ impl Module {
         file: Option<&Path>,
         path: &[&str],
         content: &str,
-    ) -> Result<(Self, Vec<Struct>, Vec<Enum>)> {
+    ) -> Result<(Self, Vec<Struct>, Vec<Enum>, Vec<Function>)> {
         let syntax = parse_file(content)?;
         let mut mod_ = Self {
             file: file.map(|f| f.to_string_lossy().to_string()), // TODO better way to serialize the path, also ?
@@ -29,6 +29,7 @@ impl Module {
 
         let mut structs = vec![];
         let mut enums = vec![];
+        let mut functions = vec![];
 
         for item in syntax.items {
             // TODO traits, functions, impls, et
@@ -51,11 +52,17 @@ impl Module {
                         enums.push(enum_);
                     }
                 }
+                syn::Item::Fn(fn_item) => {
+                    if let syn::Visibility::Public(_) = fn_item.vis {
+                        let function = Function::parse(path, fn_item);
+                        functions.push(function);
+                    }
+                }
                 _ => {}
             }
         }
 
-        Ok((mod_, structs, enums))
+        Ok((mod_, structs, enums, functions))
     }
 
     pub fn to_json(&self) -> String {
@@ -99,6 +106,7 @@ pub enum MyEnum {
                 docstring: ""
                 discriminant: ~
                 fields: []
+        - []
         "###);
     }
 }

crates/analyzer/src/analyze/module.rs

@@ -83,6 +83,16 @@ pub struct Field {
     pub type_: TypeSignature,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
+/// Representation of a function
+pub struct Function {
+    /// The fully qualified name of the function.
+    pub path: Vec<String>,
+    /// The docstring of the function
+    pub docstring: String,
+    // TODO signature
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 /// A segment of a type signature
 ///

crates/analyzer/src/analyze/trait.rs

@@ -260,3 +260,37 @@ impl From<data_model::TypeSegment> for TypeSegment {
         }
     }
 }
+
+#[pyclass]
+#[derive(Clone)]
+/// pyo3 representation of a function
+pub struct Function {
+    #[pyo3(get)]
+    pub path: Vec<String>,
+    #[pyo3(get)]
+    pub docstring: String,
+}
+
+#[pymethods]
+impl Function {
+    pub fn __repr__(&self) -> String {
+        format!("Function({:?})", self.path_str())
+    }
+    #[getter]
+    pub fn path_str(&self) -> String {
+        self.path.join("::")
+    }
+    #[getter]
+    pub fn name(&self) -> String {
+        self.path.last().unwrap().clone()
+    }
+}
+
+impl From<data_model::Function> for Function {
+    fn from(field: data_model::Function) -> Self {
+        Function {
+            path: field.path,
+            docstring: field.docstring,
+        }
+    }
+}

crates/analyzer/src/analyze/variable.rs

@@ -2,9 +2,9 @@
 
 use pyo3::{exceptions::PyIOError, prelude::*};
 
-use analyzer::data_model as analyze_model;
+use analyzer::data_model::{self as analyze_model};
 
-use crate::data_model::{Crate, Enum, Module, Struct};
+use crate::data_model::{Crate, Enum, Function, Module, Struct};
 
 fn read_file(path: &std::path::Path) -> PyResult<String> {
     match std::fs::read_to_string(path) {
@@ -90,6 +90,20 @@ pub fn load_enum(cache_path: &str, full_name: &str) -> PyResult<Option<Enum>> {
     Ok(Some(enum_.into()))
 }
 
+#[pyfunction]
+/// load a function from the cache, if it exists
+pub fn load_function(cache_path: &str, full_name: &str) -> PyResult<Option<Function>> {
+    let path = std::path::Path::new(cache_path)
+        .join("functions")
+        .join(format!("{}.json", full_name));
+    if !path.exists() {
+        return Ok(None);
+    }
+    let contents = read_file(&path)?;
+    let func: analyze_model::Function = deserialize_object(full_name, &contents)?;
+    Ok(Some(func.into()))
+}
+
 /// Check if a path is a child of a given parent, and return the fully qualified name of the child.
 fn is_child(path: &std::path::PathBuf, parent: &Vec<String>) -> Option<String> {
     let name = match path.file_stem() {
@@ -178,6 +192,28 @@ pub fn load_child_enums(cache_path: &str, parent: Vec<String>) -> PyResult<Vec<E
     Ok(enums)
 }
 
+#[pyfunction]
+/// load all function from the cache that are children of the given parent
+pub fn load_child_functions(cache_path: &str, parent: Vec<String>) -> PyResult<Vec<Function>> {
+    let path = std::path::Path::new(cache_path).join("functions");
+    if !path.exists() {
+        return Ok(vec![]);
+    }
+    let mut funcs = vec![];
+    for entry in std::fs::read_dir(path)? {
+        let entry = entry?;
+        let path = entry.path();
+        if path.is_file() {
+            if let Some(name) = is_child(&path, &parent) {
+                let contents = read_file(&path)?;
+                let func: analyze_model::Function = deserialize_object(&name, &contents)?;
+                funcs.push(func.into());
+            }
+        }
+    }
+    Ok(funcs)
+}
+
 /// Check if a path is an ancestor of a given parent, and return the fully qualified name of the child.
 fn is_ancestor(
     path: &std::path::PathBuf,