♻️ Restructure rust API

Author: chrisjsewell

crates/analyzer/src/analyze.rs

@@ -6,11 +6,7 @@ pub mod module;
 pub mod struct_;
 pub mod type_;
 
-pub use self::crate_::{analyze_crate, Crate};
-pub use self::enum_::{Enum, Variant};
-pub use self::module::Module;
-pub use self::struct_::{Field, Struct};
-pub use self::type_::TypeSegment;
+pub use self::crate_::analyze_crate;
 
 /// Extracts the docstring from an object's attributes
 ///

crates/analyzer/src/analyze/crate_.rs

@@ -2,7 +2,7 @@
 use anyhow::{Context, Result};
 use serde::{Deserialize, Serialize};
 
-use super::{Enum, Module, Struct};
+use crate::data_model::{Crate, Enum, Module, Struct};
 
 pub fn analyze_crate(path: &str) -> Result<AnalysisResult> {
     // make the path absolute
@@ -154,18 +154,6 @@ pub struct AnalysisResult {
     pub enums: Vec<Enum>,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
-/// Representation of a crate
-///
-/// .. req:: Represent a crate
-///     :id: RUST006
-///     :tags: rust
-///     :status: in-progress
-pub struct Crate {
-    pub name: String,
-    pub version: String,
-}
-
 #[derive(Debug, Deserialize)]
 struct CargoToml {
     package: Package,

crates/analyzer/src/analyze/enum_.rs

@@ -1,24 +1,10 @@
 //! Analyze enums
 use quote::quote;
-use serde::{Deserialize, Serialize};
 use syn::ItemEnum;
 
-use super::{docstring_from_attrs, struct_::Field};
+use crate::data_model::{Enum, Field, Variant};
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
-/// Representation of a Enum
-///
-/// .. req:: Represent an enum
-///     :id: RUST003
-///     :tags: rust
-///     :status: in-progress
-pub struct Enum {
-    /// The fully qualified name of the enum
-    pub path: Vec<String>,
-    /// The docstring of the enum
-    pub docstring: String,
-    pub variants: Vec<Variant>,
-}
+use super::docstring_from_attrs;
 
 impl Enum {
     /// Fully qualified name of the variant
@@ -43,17 +29,6 @@ impl Enum {
     }
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
-/// Representation of a Enum variant
-pub struct Variant {
-    /// 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 {

crates/analyzer/src/analyze/module.rs

@@ -2,27 +2,11 @@
 use std::path::Path;
 
 use anyhow::Result;
-use serde::{Deserialize, Serialize};
 use syn::parse_file;
 
-use super::{docstring_from_attrs, enum_::Enum, struct_::Struct};
+use crate::data_model::{Enum, Module, Struct};
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
-/// Representation of a module
-///
-/// .. req:: Represent a module
-///     :id: RUST005
-///     :tags: rust
-///     :status: in-progress
-pub struct Module {
-    /// The path to the module file
-    pub file: Option<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>,
-}
+use super::docstring_from_attrs;
 
 impl Module {
     /// Fully qualified name of the variant

crates/analyzer/src/analyze/struct_.rs

@@ -1,26 +1,9 @@
 //! Analyze structs
-use serde::{Deserialize, Serialize};
 use syn::{ItemStruct, Visibility};
 
-use super::{
-    docstring_from_attrs,
-    type_::{convert_type, TypeSegment},
-};
+use crate::data_model::{Field, Struct};
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
-/// Representation of a Struct
-///
-/// .. req:: Represent a struct
-///     :id: RUST004
-///     :tags: rust
-///     :status: in-progress
-pub struct Struct {
-    /// The fully qualified name of the struct
-    pub path: Vec<String>,
-    /// The docstring of the struct
-    pub docstring: String,
-    pub fields: Vec<Field>,
-}
+use super::{docstring_from_attrs, type_::convert_type};
 
 impl Struct {
     /// Fully qualified name of the variant
@@ -50,18 +33,6 @@ impl Struct {
     }
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
-/// Representation of a Struct or Enum field
-pub struct Field {
-    /// The fully qualified name of the field.
-    ///
-    /// Note, for fields of tuple structs, the final component is the index of the field
-    pub path: Vec<String>,
-    /// The docstring of the field
-    pub docstring: String,
-    pub type_: Vec<TypeSegment>,
-}
-
 impl Field {
     /// Extract the relevant information from the AST
     pub fn parse(parent: &[&str], position: usize, ast: &syn::Field) -> Self {

crates/analyzer/src/analyze/type_.rs

@@ -1,15 +1,7 @@
 //! Analyze types
 use quote::quote;
-use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
-/// A segment of a type signature
-///
-/// Types are split into segments to allow for identification of referenceable elements
-pub enum TypeSegment {
-    String(String),
-    Path(String),
-}
+use crate::data_model::TypeSegment;
 
 impl From<&str> for TypeSegment {
     fn from(s: &str) -> Self {

crates/analyzer/src/data_model.rs

@@ -0,0 +1,96 @@
+//! Data model for the analyzer
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+/// Representation of a crate
+///
+/// .. req:: Represent a crate
+///     :id: RUST003
+///     :tags: rust
+///     :status: in-progress
+pub struct Crate {
+    pub name: String,
+    pub version: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+/// Representation of a module
+///
+/// .. req:: Represent a module
+///     :id: RUST004
+///     :tags: rust
+///     :status: in-progress
+pub struct Module {
+    /// The path to the module file
+    pub file: Option<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>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+/// Representation of a Struct
+///
+/// .. req:: Represent a struct
+///     :id: RUST005
+///     :tags: rust
+///     :status: in-progress
+pub struct Struct {
+    /// The fully qualified name of the struct
+    pub path: Vec<String>,
+    /// The docstring of the struct
+    pub docstring: String,
+    pub fields: Vec<Field>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+/// Representation of a Enum
+///
+/// .. req:: Represent an enum
+///     :id: RUST006
+///     :tags: rust
+///     :status: in-progress
+pub struct Enum {
+    /// The fully qualified name of the enum
+    pub path: Vec<String>,
+    /// The docstring of the enum
+    pub docstring: String,
+    pub variants: Vec<Variant>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+/// Representation of a Enum variant
+pub struct Variant {
+    /// 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>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+/// Representation of a Struct or Enum field
+pub struct Field {
+    /// The fully qualified name of the field.
+    ///
+    /// Note, for fields of tuple structs, the final component is the index of the field
+    pub path: Vec<String>,
+    /// The docstring of the field
+    pub docstring: String,
+    pub type_: TypeSignature,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+/// A segment of a type signature
+///
+/// Types are split into segments to allow for easy identification of referenceable elements
+pub enum TypeSegment {
+    String(String),
+    Path(String),
+}
+
+/// A representation of a type signature
+pub type TypeSignature = Vec<TypeSegment>;

crates/analyzer/src/lib.rs

@@ -9,3 +9,4 @@
 //!
 //!     We need to be able to analyze a rust package and extract the necessary information from it.
 pub mod analyze;
+pub mod data_model;

crates/py_binding/src/objects.rs renamed to crates/py_binding/src/data_model.rs

@@ -1,6 +1,8 @@
+//! Mapping of the analyzer data model to pyo3 classes
+
 use pyo3::prelude::*;
 
-use analyzer::analyze;
+use analyzer::data_model;
 
 #[pyclass]
 #[derive(Clone)]
@@ -27,8 +29,8 @@ impl Crate {
     }
 }
 
-impl From<analyze::Crate> for Crate {
-    fn from(crate_: analyze::Crate) -> Self {
+impl From<data_model::Crate> for Crate {
+    fn from(crate_: data_model::Crate) -> Self {
         Crate {
             name: crate_.name,
             version: crate_.version,
@@ -63,8 +65,8 @@ impl Module {
     }
 }
 
-impl From<analyze::Module> for Module {
-    fn from(module: analyze::Module) -> Self {
+impl From<data_model::Module> for Module {
+    fn from(module: data_model::Module) -> Self {
         Module {
             file: module.file,
             path: module.path,
@@ -100,8 +102,8 @@ impl Field {
     }
 }
 
-impl From<analyze::Field> for Field {
-    fn from(field: analyze::Field) -> Self {
+impl From<data_model::Field> for Field {
+    fn from(field: data_model::Field) -> Self {
         Field {
             path: field.path,
             docstring: field.docstring,
@@ -137,8 +139,8 @@ impl Struct {
     }
 }
 
-impl From<analyze::Struct> for Struct {
-    fn from(module: analyze::Struct) -> Self {
+impl From<data_model::Struct> for Struct {
+    fn from(module: data_model::Struct) -> Self {
         Struct {
             path: module.path,
             docstring: module.docstring,
@@ -174,8 +176,8 @@ impl Enum {
     }
 }
 
-impl From<analyze::Enum> for Enum {
-    fn from(module: analyze::Enum) -> Self {
+impl From<data_model::Enum> for Enum {
+    fn from(module: data_model::Enum) -> Self {
         Enum {
             path: module.path,
             docstring: module.docstring,
@@ -212,8 +214,8 @@ impl Variant {
     }
 }
 
-impl From<analyze::Variant> for Variant {
-    fn from(var: analyze::Variant) -> Self {
+impl From<data_model::Variant> for Variant {
+    fn from(var: data_model::Variant) -> Self {
         Variant {
             path: var.path,
             docstring: var.docstring,
@@ -244,14 +246,14 @@ impl TypeSegment {
     }
 }
 
-impl From<analyze::TypeSegment> for TypeSegment {
-    fn from(field: analyze::TypeSegment) -> Self {
+impl From<data_model::TypeSegment> for TypeSegment {
+    fn from(field: data_model::TypeSegment) -> Self {
         match field {
-            analyze::TypeSegment::Path(content) => TypeSegment {
+            data_model::TypeSegment::Path(content) => TypeSegment {
                 content,
                 is_path: true,
             },
-            analyze::TypeSegment::String(content) => TypeSegment {
+            data_model::TypeSegment::String(content) => TypeSegment {
                 content,
                 is_path: false,
             },