quickshell/quickshell-docs
2
1
Fork 0
Code Issues Activity

feat: signal support

Browse source 
also ran formatter
This commit is contained in:
outfoxxed 2024-02-18 17:38:55 -08:00
parent 0981ac7345
commit 3fc1aa19fd
Signed by: outfoxxed
GPG key ID: 4C88A185FB89301E
6 changed files with 392 additions and 149 deletions
Download patch file Download diff file Expand all files Collapse all files

121
typegen/src/resolver.rs
View file

@ -1,24 +1,35 @@
use std::collections::HashMap;
use crate::{outform::{self, Flag, PropertyType}, typespec::{FnParam, Function, Property, TypeSpec}};
use crate::{
outform::{self, Flag, PropertyType},
typespec::{FnParam, Function, Property, Signal, TypeSpec},
};
pub fn resolve_types(module: &str, typespec: TypeSpec) -> anyhow::Result<HashMap<String, outform::TypeInfo>> {
pub fn resolve_types(
module: &str,
typespec: TypeSpec,
) -> anyhow::Result<HashMap<String, outform::TypeInfo>> {
let mut outtypes = HashMap::new();
let types = typespec.typemap.iter()
.filter(|type_| type_.module.as_ref().map(|v| v as &str) == Some(module));
let findqmltype = |cname: &str| typespec.typemap
let types = typespec
.typemap
.iter()
.find(|type_| type_.cname == cname);
.filter(|type_| type_.module.as_ref().map(|v| v as &str) == Some(module));
let findqmltype = |cname: &str| typespec.typemap.iter().find(|type_| type_.cname == cname);
for mapping in types {
let Some(class) = typespec.classes.iter().find(|class| class.name == mapping.cname) else {
let Some(class) = typespec
.classes
.iter()
.find(|class| class.name == mapping.cname)
else {
continue
};
let mut properties = Vec::<&Property>::new();
let mut functions = Vec::<&Function>::new();
let mut signals = Vec::<&Signal>::new();
// the first superclass availible from QML
let mut superclass = &class.superclass;
@ -29,12 +40,16 @@ pub fn resolve_types(module: &str, typespec: TypeSpec) -> anyhow::Result<HashMap
break outform::Type::resolve(type_.module.as_ref().map(|v| v as &str), &type_.name)
}
let superctype = typespec.classes.iter().find(|class| &class.name == superclass);
let superctype = typespec
.classes
.iter()
.find(|class| &class.name == superclass);
match superctype {
Some(superctype) => {
properties.extend(superctype.properties.iter());
functions.extend(superctype.functions.iter());
signals.extend(superctype.signals.iter());
superclass = &superctype.superclass;
},
None => break outform::Type::unknown(),
@ -42,19 +57,23 @@ pub fn resolve_types(module: &str, typespec: TypeSpec) -> anyhow::Result<HashMap
};
fn qmlparamtype(ctype: &str, typespec: &TypeSpec) -> outform::Type {
let qtype = typespec.typemap
let qtype = typespec
.typemap
.iter()
.find(|type_| &type_.cname == ctype)
.map(|type_| (&type_.module, &type_.name))
.or_else(|| {
typespec.enums
typespec
.enums
.iter()
.find(|type_| type_.cname.as_ref().map(|v| v as &str) == Some(ctype))
.map(|type_| (&type_.module, &type_.name))
});
match qtype {
Some((module, name)) => outform::Type::resolve(module.as_ref().map(|v| v as &str), &name),
Some((module, name)) => {
outform::Type::resolve(module.as_ref().map(|v| v as &str), &name)
},
None => outform::Type::unknown(),
}
}
@ -78,15 +97,16 @@ pub fn resolve_types(module: &str, typespec: TypeSpec) -> anyhow::Result<HashMap
flags
};
let gadget = typespec.gadgets.iter()
.find(|gadget| gadget.cname == ctype);
let gadget = typespec.gadgets.iter().find(|gadget| gadget.cname == ctype);
match gadget {
Some(gadget) => outform::Property {
type_: PropertyType::Gadget(
gadget.properties.iter()
gadget
.properties
.iter()
.map(|prop| (prop.name.clone(), solveprop(prop, typespec).type_))
.collect()
.collect(),
),
details: prop.details.clone(),
flags,
@ -131,7 +151,23 @@ pub fn resolve_types(module: &str, typespec: TypeSpec) -> anyhow::Result<HashMap
ret: qmlparamtype(&func.ret, typespec),
name: func.name.clone(),
details: func.details.clone(),
params: func.params.iter().map(|FnParam { type_, name }| (name.clone(), qmlparamtype(type_, typespec))).collect(),
params: func
.params
.iter()
.map(|FnParam { type_, name }| (name.clone(), qmlparamtype(type_, typespec)))
.collect(),
}
}
fn solvesignal(func: &Signal, typespec: &TypeSpec) -> outform::Signal {
outform::Signal {
name: func.name.clone(),
details: func.details.clone(),
params: func
.params
.iter()
.map(|FnParam { type_, name }| (name.clone(), qmlparamtype(type_, typespec)))
.collect(),
}
}
@ -141,15 +177,23 @@ pub fn resolve_types(module: &str, typespec: TypeSpec) -> anyhow::Result<HashMap
functions.extend(class.functions.iter());
functions.sort_by(|a, b| Ord::cmp(&a.name, &b.name));
let properties = properties.iter().map(|prop| (
prop.name.clone(),
solveprop(prop, &typespec)
)).collect::<HashMap<_, _>>();
signals.extend(class.signals.iter());
signals.sort_by(|a, b| Ord::cmp(&a.name, &b.name));
let functions = functions.iter().map(|func| (
func.name.clone(),
solvefunc(func, &typespec)
)).collect::<HashMap<_, _>>();
let properties = properties
.iter()
.map(|prop| (prop.name.clone(), solveprop(prop, &typespec)))
.collect::<HashMap<_, _>>();
let functions = functions
.iter()
.map(|func| (func.name.clone(), solvefunc(func, &typespec)))
.collect::<HashMap<_, _>>();
let signals = signals
.iter()
.map(|signal| (signal.name.clone(), solvesignal(signal, &typespec)))
.collect::<HashMap<_, _>>();
let type_ = outform::ClassInfo {
superclass,
@ -168,6 +212,7 @@ pub fn resolve_types(module: &str, typespec: TypeSpec) -> anyhow::Result<HashMap
},
properties,
functions,
signals,
};
outtypes.insert(mapping.name.clone(), outform::TypeInfo::Class(type_));
@ -175,16 +220,22 @@ pub fn resolve_types(module: &str, typespec: TypeSpec) -> anyhow::Result<HashMap
for enum_ in typespec.enums {
if enum_.module.as_ref().map(|v| v as &str) == Some(module) {
outtypes.insert(enum_.name, outform::TypeInfo::Enum(outform::EnumInfo {
description: enum_.description,
details: enum_.details,
variants: enum_.varaints.into_iter().map(|variant| (
variant.name,
outform::Variant {
details: variant.details,
},
)).collect(),
}));
outtypes.insert(
enum_.name,
outform::TypeInfo::Enum(outform::EnumInfo {
description: enum_.description,
details: enum_.details,
variants: enum_
.varaints
.into_iter()
.map(|variant| {
(variant.name, outform::Variant {
details: variant.details,
})
})
.collect(),
}),
);
}
}