pub mod doc;
pub mod go;
pub mod pydoc;
pub mod python;
pub mod rust;
use crate::models::Language;
use serde::{Deserialize, Serialize};
pub const EXTRACTOR_VERSION: u32 = 5;
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
pub struct ApiFile {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub module_doc: Option<DocComment>,
pub items: Vec<ApiItem>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub mod_decls: Vec<ModDecl>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub reexports: Vec<ReExport>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub package: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub exports: Option<Vec<String>>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum ApiKind {
Module,
Function,
Method,
Struct,
Class,
Enum,
Variant,
Field,
Trait,
TypeAlias,
AssociatedType,
Const,
Static,
Macro,
Union,
Interface,
}
impl ApiKind {
pub fn is_type(&self) -> bool {
matches!(
self,
ApiKind::Struct
| ApiKind::Class
| ApiKind::Enum
| ApiKind::Trait
| ApiKind::Union
| ApiKind::Interface
)
}
pub fn label(&self) -> &'static str {
match self {
ApiKind::Module => "module",
ApiKind::Function => "fn",
ApiKind::Method => "method",
ApiKind::Struct => "struct",
ApiKind::Class => "class",
ApiKind::Enum => "enum",
ApiKind::Variant => "variant",
ApiKind::Field => "field",
ApiKind::Trait => "trait",
ApiKind::TypeAlias => "type",
ApiKind::AssociatedType => "associated type",
ApiKind::Const => "const",
ApiKind::Static => "static",
ApiKind::Macro => "macro",
ApiKind::Union => "union",
ApiKind::Interface => "interface",
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "type", content = "scope", rename_all = "kebab-case")]
pub enum Visibility {
Public,
Restricted(String),
Private,
Inherited,
}
impl Visibility {
pub fn is_public(&self) -> bool {
matches!(self, Visibility::Public | Visibility::Inherited)
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ApiItem {
pub name: String,
pub kind: ApiKind,
pub visibility: Visibility,
pub signature: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub sig: Option<SigParts>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub doc: Option<DocComment>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub attrs: Vec<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub deprecated: Option<Deprecation>,
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
pub hidden: bool,
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
pub test_only: bool,
pub start_line: u32,
pub end_line: u32,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub trait_impl: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub self_type: Option<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub members: Vec<ApiItem>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
pub struct SigParts {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub generics: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub receiver: Option<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub params: Vec<Param>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub returns: Option<String>,
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
pub is_async: bool,
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
pub is_unsafe: bool,
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
pub is_const: bool,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Param {
pub name: String,
pub ty: String,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Deprecation {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub since: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub note: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
pub struct DocComment {
pub markdown: String,
pub summary: String,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub sections: Vec<(String, String)>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub examples: Vec<CodeExample>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub links: Vec<String>,
pub start_line: u32,
pub end_line: u32,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CodeExample {
pub lang: String,
pub code: String,
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
pub doctest: bool,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ModDecl {
pub name: String,
pub visibility: Visibility,
pub inline: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub path_attr: Option<String>,
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
pub test_only: bool,
pub line: u32,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ReExport {
pub path: String,
pub name: String,
pub visibility: Visibility,
pub line: u32,
}
pub fn has_extractor(language: Language) -> bool {
matches!(language, Language::Rust | Language::Go | Language::Python)
}
pub fn extract(language: Language, source: &str) -> Option<ApiFile> {
match language {
Language::Rust => rust::extract(source).ok(),
Language::Go => go::extract(source).ok(),
Language::Python => python::extract(source).ok(),
_ => None,
}
}
pub(crate) fn collapse_ws(s: &str) -> String {
let mut out = String::with_capacity(s.len());
let mut space = false;
for c in s.chars() {
if c.is_whitespace() {
space = true;
} else {
if space && !out.is_empty() {
out.push(' ');
}
space = false;
out.push(c);
}
}
out
}