1pub mod doc;
12pub mod go;
13pub mod pydoc;
14pub mod python;
15pub mod rust;
16
17use crate::models::Language;
18use serde::{Deserialize, Serialize};
19
20pub const EXTRACTOR_VERSION: u32 = 5;
22
23#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
25pub struct ApiFile {
26 #[serde(default, skip_serializing_if = "Option::is_none")]
28 pub module_doc: Option<DocComment>,
29 pub items: Vec<ApiItem>,
31 #[serde(default, skip_serializing_if = "Vec::is_empty")]
33 pub mod_decls: Vec<ModDecl>,
34 #[serde(default, skip_serializing_if = "Vec::is_empty")]
36 pub reexports: Vec<ReExport>,
37 #[serde(default, skip_serializing_if = "Option::is_none")]
39 pub package: Option<String>,
40 #[serde(default, skip_serializing_if = "Option::is_none")]
42 pub exports: Option<Vec<String>>,
43}
44
45#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
46#[serde(rename_all = "kebab-case")]
47pub enum ApiKind {
48 Module,
49 Function,
50 Method,
51 Struct,
52 Class,
54 Enum,
55 Variant,
56 Field,
57 Trait,
58 TypeAlias,
59 AssociatedType,
60 Const,
61 Static,
62 Macro,
63 Union,
64 Interface,
66}
67
68impl ApiKind {
69 pub fn is_type(&self) -> bool {
72 matches!(
73 self,
74 ApiKind::Struct
75 | ApiKind::Class
76 | ApiKind::Enum
77 | ApiKind::Trait
78 | ApiKind::Union
79 | ApiKind::Interface
80 )
81 }
82
83 pub fn label(&self) -> &'static str {
84 match self {
85 ApiKind::Module => "module",
86 ApiKind::Function => "fn",
87 ApiKind::Method => "method",
88 ApiKind::Struct => "struct",
89 ApiKind::Class => "class",
90 ApiKind::Enum => "enum",
91 ApiKind::Variant => "variant",
92 ApiKind::Field => "field",
93 ApiKind::Trait => "trait",
94 ApiKind::TypeAlias => "type",
95 ApiKind::AssociatedType => "associated type",
96 ApiKind::Const => "const",
97 ApiKind::Static => "static",
98 ApiKind::Macro => "macro",
99 ApiKind::Union => "union",
100 ApiKind::Interface => "interface",
101 }
102 }
103}
104
105#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
106#[serde(tag = "type", content = "scope", rename_all = "kebab-case")]
107pub enum Visibility {
108 Public,
110 Restricted(String),
112 Private,
114 Inherited,
116}
117
118impl Visibility {
119 pub fn is_public(&self) -> bool {
120 matches!(self, Visibility::Public | Visibility::Inherited)
121 }
122}
123
124#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
126pub struct ApiItem {
127 pub name: String,
128 pub kind: ApiKind,
129 pub visibility: Visibility,
130 pub signature: String,
132 #[serde(default, skip_serializing_if = "Option::is_none")]
133 pub sig: Option<SigParts>,
134 #[serde(default, skip_serializing_if = "Option::is_none")]
135 pub doc: Option<DocComment>,
136 #[serde(default, skip_serializing_if = "Vec::is_empty")]
138 pub attrs: Vec<String>,
139 #[serde(default, skip_serializing_if = "Option::is_none")]
140 pub deprecated: Option<Deprecation>,
141 #[serde(default, skip_serializing_if = "std::ops::Not::not")]
143 pub hidden: bool,
144 #[serde(default, skip_serializing_if = "std::ops::Not::not")]
146 pub test_only: bool,
147 pub start_line: u32,
149 pub end_line: u32,
150 #[serde(default, skip_serializing_if = "Option::is_none")]
152 pub trait_impl: Option<String>,
153 #[serde(default, skip_serializing_if = "Option::is_none")]
155 pub self_type: Option<String>,
156 #[serde(default, skip_serializing_if = "Vec::is_empty")]
158 pub members: Vec<ApiItem>,
159}
160
161#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
162pub struct SigParts {
163 #[serde(default, skip_serializing_if = "Option::is_none")]
164 pub generics: Option<String>,
165 #[serde(default, skip_serializing_if = "Option::is_none")]
167 pub receiver: Option<String>,
168 #[serde(default, skip_serializing_if = "Vec::is_empty")]
169 pub params: Vec<Param>,
170 #[serde(default, skip_serializing_if = "Option::is_none")]
171 pub returns: Option<String>,
172 #[serde(default, skip_serializing_if = "std::ops::Not::not")]
173 pub is_async: bool,
174 #[serde(default, skip_serializing_if = "std::ops::Not::not")]
175 pub is_unsafe: bool,
176 #[serde(default, skip_serializing_if = "std::ops::Not::not")]
177 pub is_const: bool,
178}
179
180#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
181pub struct Param {
182 pub name: String,
183 pub ty: String,
184}
185
186#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
187pub struct Deprecation {
188 #[serde(default, skip_serializing_if = "Option::is_none")]
189 pub since: Option<String>,
190 #[serde(default, skip_serializing_if = "Option::is_none")]
191 pub note: Option<String>,
192}
193
194#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
196pub struct DocComment {
197 pub markdown: String,
199 pub summary: String,
201 #[serde(default, skip_serializing_if = "Vec::is_empty")]
203 pub sections: Vec<(String, String)>,
204 #[serde(default, skip_serializing_if = "Vec::is_empty")]
206 pub examples: Vec<CodeExample>,
207 #[serde(default, skip_serializing_if = "Vec::is_empty")]
209 pub links: Vec<String>,
210 pub start_line: u32,
212 pub end_line: u32,
213}
214
215#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
216pub struct CodeExample {
217 pub lang: String,
218 pub code: String,
219 #[serde(default, skip_serializing_if = "std::ops::Not::not")]
221 pub doctest: bool,
222}
223
224#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
226pub struct ModDecl {
227 pub name: String,
228 pub visibility: Visibility,
229 pub inline: bool,
231 #[serde(default, skip_serializing_if = "Option::is_none")]
233 pub path_attr: Option<String>,
234 #[serde(default, skip_serializing_if = "std::ops::Not::not")]
235 pub test_only: bool,
236 pub line: u32,
237}
238
239#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
242pub struct ReExport {
243 pub path: String,
246 pub name: String,
248 pub visibility: Visibility,
249 pub line: u32,
250}
251
252pub fn has_extractor(language: Language) -> bool {
254 matches!(language, Language::Rust | Language::Go | Language::Python)
255}
256
257pub fn extract(language: Language, source: &str) -> Option<ApiFile> {
259 match language {
260 Language::Rust => rust::extract(source).ok(),
261 Language::Go => go::extract(source).ok(),
262 Language::Python => python::extract(source).ok(),
263 _ => None,
264 }
265}
266
267pub(crate) fn collapse_ws(s: &str) -> String {
269 let mut out = String::with_capacity(s.len());
270 let mut space = false;
271 for c in s.chars() {
272 if c.is_whitespace() {
273 space = true;
274 } else {
275 if space && !out.is_empty() {
276 out.push(' ');
277 }
278 space = false;
279 out.push(c);
280 }
281 }
282 out
283}