pogmommy/eww
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

generally finished XML implementation. TODO: error handling, remove old code

Browse source
This commit is contained in:
elkowar 2020-10-03 13:27:16 +02:00
parent d1c991ba92
commit 50b8840c5b
8 changed files with 297 additions and 146 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
Cargo.lock generated
View file

@ -334,6 +334,7 @@ dependencies = [
"hocon",
"hotwatch",
"ipc-channel",
"itertools",
"maplit",
"num",
"pretty_assertions",

1
Cargo.toml
View file

@ -29,6 +29,7 @@ crossbeam-channel = "0.4"
num = "0.3"
stoppable_thread = "0.2"
roxmltree = "0.13"
itertools = "0.9"
#thiserror = "1.0"

213
src/config/element.rs
View file

@ -14,32 +14,23 @@ pub struct WidgetDefinition {
}
impl WidgetDefinition {
pub fn from_xml(xml: roxmltree::Node) -> Result<Self> {
if !xml.is_element() {
bail!("Tried to parse element of type {:?} as Widget definition", xml.node_type());
} else if xml.tag_name().name().to_lowercase() != "def" {
pub fn from_xml_element(xml: XmlElement) -> Result<Self> {
if xml.tag_name() != "def" {
bail!(
"Illegal element: only <def> may be used in definition block, but found '{}'",
xml.tag_name().name()
);
} else if xml.children().count() != 1 {
bail!(
"Widget definition '{}' needs to contain exactly one element",
xml.tag_name().name()
xml.as_tag_string()
);
}
let size: Option<Result<_>> = xml
.child("size")
.ok()
.map(|node| Ok((node.attr("x")?.parse()?, node.attr("y")?.parse()?)));
Ok(WidgetDefinition {
name: xml.try_attribute("name")?.to_owned(),
size: if let Some(node) = xml.children().find(|child| child.tag_name().name() == "size") {
Some((node.try_attribute("x")?.parse()?, node.try_attribute("y")?.parse()?))
} else {
None
},
// we can unwrap here, because we previously verified that there is exactly one child
structure: WidgetUse::from_xml(xml.first_child().unwrap())?,
name: xml.attr("name")?.to_owned(),
size: size.transpose()?,
structure: WidgetUse::from_xml_node(xml.only_child()?)?,
})
}
@ -72,35 +63,19 @@ pub struct WidgetUse {
}
impl WidgetUse {
pub fn from_xml(xml: roxmltree::Node) -> Result<Self> {
match xml.node_type() {
roxmltree::NodeType::Text => Ok(WidgetUse::simple_text(AttrValue::parse_string(
xml.text()
.context("couldn't get text from node")?
.trim_matches('\n')
.trim()
.to_owned(),
))),
roxmltree::NodeType::Element => {
let widget_name = xml.tag_name();
let attrs = xml
pub fn from_xml_node(xml: XmlNode) -> Result<Self> {
match xml {
XmlNode::Text(text) => Ok(WidgetUse::simple_text(AttrValue::parse_string(text.text()))),
XmlNode::Element(elem) => Ok(WidgetUse {
name: elem.tag_name().to_string(),
children: elem.children().map(WidgetUse::from_xml_node).collect::<Result<_>>()?,
attrs: elem
.attributes()
.iter()
.map(|attr| (attr.name().to_owned(), AttrValue::parse_string(attr.value().to_owned())))
.collect::<HashMap<_, _>>();
let children = xml
.children()
.filter(|child| !child.is_comment())
.filter(|child| !(child.is_text() && child.text().unwrap().trim().trim_matches('\n').is_empty()))
.map(|child| WidgetUse::from_xml(child))
.collect::<Result<_>>()?;
Ok(WidgetUse {
name: widget_name.name().to_string(),
attrs,
children,
})
}
_ => Err(anyhow!("Tried to parse node of type {:?} as widget use", xml.node_type())),
.collect::<HashMap<_, _>>(),
}),
XmlNode::Ignored(_) => Err(anyhow!("Failed to parse node {:?} as widget use", xml)),
}
}
}
@ -186,80 +161,80 @@ pub fn parse_widget_use_children(children: Hocon) -> Result<Vec<WidgetUse>> {
}
}
#[cfg(test)]
mod test {
use super::*;
use maplit::hashmap;
use pretty_assertions::assert_eq;
//#[cfg(test)]
//mod test {
//use super::*;
//use maplit::hashmap;
//use pretty_assertions::assert_eq;
#[test]
fn test_parse_widget_use() {
let input_complex = r#"{
widget_name: {
value: "test"
children: [
{ child: {} }
{ child: { children: ["hi"] } }
]
}
}"#;
let expected = WidgetUse {
name: "widget_name".to_string(),
children: vec![
WidgetUse::new("child".to_string(), vec![]),
WidgetUse::new(
"child".to_string(),
vec![WidgetUse::simple_text(AttrValue::Concrete(PrimitiveValue::String(
"hi".to_string(),
)))],
),
],
attrs: hashmap! { "value".to_string() => AttrValue::Concrete(PrimitiveValue::String("test".to_string()))},
};
assert_eq!(
WidgetUse::parse_hocon(parse_hocon(input_complex).unwrap().clone()).unwrap(),
expected
);
}
//#[test]
//fn test_parse_widget_use() {
//let input_complex = r#"{
//widget_name: {
//value: "test"
//children: [
//{ child: {} }
//{ child: { children: ["hi"] } }
//]
//}
//}"#;
//let expected = WidgetUse {
//name: "widget_name".to_string(),
//children: vec![
//WidgetUse::new("child".to_string(), vec![]),
//WidgetUse::new(
//"child".to_string(),
//vec![WidgetUse::simple_text(AttrValue::Concrete(PrimitiveValue::String(
//"hi".to_string(),
//)))],
//),
//],
//attrs: hashmap! { "value".to_string() => AttrValue::Concrete(PrimitiveValue::String("test".to_string()))},
//};
//assert_eq!(
//WidgetUse::parse_hocon(parse_hocon(input_complex).unwrap().clone()).unwrap(),
//expected
//);
//}
#[test]
fn test_parse_widget_definition() {
let input_complex = r#"{
structure: { foo: {} }
}"#;
let expected = WidgetDefinition {
name: "widget_name".to_string(),
structure: WidgetUse::new("foo".to_string(), vec![]),
size: None,
};
assert_eq!(
WidgetDefinition::parse_hocon("widget_name".to_string(), &parse_hocon(input_complex).unwrap()).unwrap(),
expected
);
}
//#[test]
//fn test_parse_widget_definition() {
//let input_complex = r#"{
//structure: { foo: {} }
//}"#;
//let expected = WidgetDefinition {
//name: "widget_name".to_string(),
//structure: WidgetUse::new("foo".to_string(), vec![]),
//size: None,
//};
//assert_eq!(
//WidgetDefinition::parse_hocon("widget_name".to_string(), &parse_hocon(input_complex).unwrap()).unwrap(),
//expected
//);
//}
#[test]
fn test_parse_widget_use_xml() {
let input = r#"
<widget_name attr1="hi" attr2="12">
<child_widget/>
foo
</widget_name>
"#;
let document = roxmltree::Document::parse(input).unwrap();
let xml = document.root_element().clone();
//#[test]
//fn test_parse_widget_use_xml() {
//let input = r#"
//<widget_name attr1="hi" attr2="12">
//<child_widget/>
//foo
//</widget_name>
//"#;
//let document = roxmltree::Document::parse(input).unwrap();
//let xml = document.root_element().clone();
let expected = WidgetUse {
name: "widget_name".to_owned(),
attrs: hashmap! {
"attr1".to_owned() => AttrValue::Concrete(PrimitiveValue::String("hi".to_owned())),
"attr2".to_owned() => AttrValue::Concrete(PrimitiveValue::Number(12f64)),
},
children: vec![
WidgetUse::new("child_widget".to_owned(), Vec::new()),
WidgetUse::simple_text(AttrValue::Concrete(PrimitiveValue::String("foo".to_owned()))),
],
};
assert_eq!(expected, WidgetUse::from_xml(xml).unwrap());
}
}
//let expected = WidgetUse {
//name: "widget_name".to_owned(),
//attrs: hashmap! {
//"attr1".to_owned() => AttrValue::Concrete(PrimitiveValue::String("hi".to_owned())),
//"attr2".to_owned() => AttrValue::Concrete(PrimitiveValue::Number(12f64)),
//},
//children: vec![
//WidgetUse::new("child_widget".to_owned(), Vec::new()),
//WidgetUse::simple_text(AttrValue::Concrete(PrimitiveValue::String("foo".to_owned()))),
//],
//};
//assert_eq!(expected, WidgetUse::from_xml(xml).unwrap());
//}
//}

54
src/config/mod.rs
View file

@ -34,48 +34,50 @@ impl EwwConfig {
pub fn read_from_file<P: AsRef<std::path::Path>>(path: P) -> Result<Self> {
let content = std::fs::read_to_string(path)?;
let document = roxmltree::Document::parse(&content)?;
EwwConfig::from_xml(document.root_element())
EwwConfig::from_xml_element(XmlNode::from(document.root_element()).as_element()?)
}
pub fn from_xml(xml: roxmltree::Node) -> Result<Self> {
pub fn from_xml_element(xml: XmlElement) -> Result<Self> {
let definitions = xml
.find_child_with_tag("definitions")?
.children()
.child("definitions")?
.child_elements()
.map(|child| {
let def = WidgetDefinition::from_xml(child)?;
let def = WidgetDefinition::from_xml_element(child)?;
Ok((def.name.clone(), def))
})
.collect::<Result<HashMap<_, _>>>()
.context("error parsing widget definitions")?;
let windows = xml
.find_child_with_tag("windows")?
.children()
.map(|child| Ok((child.try_attribute("name")?.to_owned(), EwwWindowDefinition::from_xml(child)?)))
.child("windows")?
.child_elements()
.map(|child| Ok((child.attr("name")?.to_owned(), EwwWindowDefinition::from_xml_element(child)?)))
.collect::<Result<HashMap<_, _>>>()
.context("error parsing window definitions")?;
let default_vars = xml
.find_child_with_tag("variables")
.child("variables")
.ok()
.map(|variables_node| {
variables_node
.children()
.child_elements()
.map(|child| {
Some((
child.tag_name().name().to_owned(),
PrimitiveValue::parse_string(child.text()?.trim_matches('\n').trim()),
Ok((
child.tag_name().to_owned(),
PrimitiveValue::parse_string(&child.only_child()?.as_text()?.text()),
))
})
.collect::<Option<HashMap<_, _>>>()
.collect::<Result<HashMap<_, _>>>()
})
.unwrap_or_default()
.context("error parsing default variable value")?;
.transpose()
.context("error parsing default variable value")?
.unwrap_or_default();
Ok(EwwConfig {
Ok(dbg!(EwwConfig {
widgets: definitions,
windows,
default_vars,
})
}))
}
pub fn from_hocon(hocon: &Hocon) -> Result<Self> {
@ -131,20 +133,20 @@ pub struct EwwWindowDefinition {
}
impl EwwWindowDefinition {
pub fn from_xml(xml: roxmltree::Node) -> Result<Self> {
if xml.tag_name().name() != "window" {
pub fn from_xml_element(xml: XmlElement) -> Result<Self> {
if xml.tag_name() != "window" {
bail!(
"Only <window> tags are valid window definitions, but found {}",
xml.tag_name().name()
xml.as_tag_string()
);
}
let size_node = xml.find_child_with_tag("size")?;
let size = (size_node.try_attribute("x")?.parse()?, size_node.try_attribute("y")?.parse()?);
let pos_node = xml.find_child_with_tag("pos")?;
let position = (pos_node.try_attribute("x")?.parse()?, pos_node.try_attribute("y")?.parse()?);
let size_node = xml.child("size")?;
let size = (size_node.attr("x")?.parse()?, size_node.attr("y")?.parse()?);
let pos_node = xml.child("pos")?;
let position = (pos_node.attr("x")?.parse()?, pos_node.attr("y")?.parse()?);
let widget = WidgetUse::from_xml(xml.find_child_with_tag("widget")?)?;
let widget = WidgetUse::from_xml_node(xml.child("widget")?.only_child()?)?;
Ok(EwwWindowDefinition { position, size, widget })
}

145
src/config/xml_ext.rs
View file

@ -1,5 +1,8 @@
use crate::util::StringExt;
use anyhow::*;
use extend::ext;
use itertools::Itertools;
use std::fmt;
#[ext(pub)]
impl<'a, 'b> roxmltree::Node<'a, 'b> {
@ -17,3 +20,145 @@ impl<'a, 'b> roxmltree::Node<'a, 'b> {
.with_context(|| anyhow!("attribute '{}' missing from '{}'", key, self.tag_name().name()))
}
}
#[derive(Debug)]
pub enum XmlNode<'a, 'b> {
Element(XmlElement<'a, 'b>),
Text(XmlText<'a, 'b>),
Ignored(roxmltree::Node<'a, 'b>),
}
impl<'a, 'b> fmt::Display for XmlNode<'a, 'b> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
XmlNode::Text(text) => write!(f, "{}", text),
XmlNode::Element(elem) => write!(f, "{}", elem),
XmlNode::Ignored(node) => write!(f, "{:?}", node),
}
}
}
#[derive(Debug)]
pub struct XmlElement<'a, 'b>(roxmltree::Node<'a, 'b>);
impl<'a, 'b> fmt::Display for XmlElement<'a, 'b> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let children = self
.children()
.map(|child| format!("{}", child))
.map(|x| x.lines().map(|line| format!(" {}", line)).join("\n"))
.join("\n");
write!(f, "{}{}</{}>", self.as_tag_string(), children, self.tag_name())
}
}
#[derive(Debug)]
pub struct XmlText<'a, 'b>(roxmltree::Node<'a, 'b>);
impl<'a, 'b> fmt::Display for XmlText<'a, 'b> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "Text({})", self.0.text().unwrap_or_default())
}
}
impl<'a, 'b> XmlNode<'a, 'b> {
pub fn as_text(self) -> Result<XmlText<'a, 'b>> {
match self {
XmlNode::Text(text) => Ok(text),
_ => Err(anyhow!("'{}' is not a text node", self)),
}
}
pub fn as_element(self) -> Result<XmlElement<'a, 'b>> {
match self {
XmlNode::Element(element) => Ok(element),
_ => Err(anyhow!("'{}' is not an element node", self)),
}
}
}
impl<'a, 'b> XmlText<'a, 'b> {
pub fn text(&self) -> String {
self.0.text().unwrap_or_default().trim_lines().trim_matches('\n').to_owned()
}
}
impl<'a, 'b> XmlElement<'a, 'b> {
pub fn as_tag_string(&self) -> String {
let attrs = self
.attributes()
.iter()
.map(|attr| format!("{}=\"{}\"", attr.name(), attr.value()))
.join(" ");
format!("<{} {}>", self.tag_name(), attrs)
}
pub fn tag_name(&self) -> &str {
self.0.tag_name().name()
}
pub fn child(&self, tagname: &str) -> Result<XmlElement> {
self.child_elements()
.find(|child| child.tag_name() == tagname)
.with_context(|| anyhow!("child element '{}' missing from {}", tagname, self.as_tag_string()))
}
pub fn children(&self) -> impl Iterator<Item = XmlNode> {
self.0
.children()
.filter(|child| child.is_element() || (child.is_text() && !child.text().unwrap_or_default().is_blank()))
.map(XmlNode::from)
}
pub fn child_elements(&self) -> impl Iterator<Item = XmlElement> {
self.0.children().filter(|child| child.is_element()).map(XmlElement)
}
pub fn attributes(&self) -> &[roxmltree::Attribute] {
self.0.attributes()
}
pub fn attr(&self, key: &str) -> Result<&str> {
self.0
.attribute(key)
.with_context(|| anyhow!("'{}' missing attribute '{}'", self.as_tag_string(), key))
}
pub fn only_child(&self) -> Result<XmlNode> {
let mut children_iter = self.children();
let only_child = children_iter
.next()
.context(anyhow!("'{}' had no children", self.as_tag_string()))?;
if children_iter.next().is_some() {
bail!("'{}' had more than one child", &self);
}
Ok(only_child)
}
pub fn only_child_element(&self) -> Result<XmlElement> {
Ok(self.only_child()?.as_element()?)
}
}
impl<'a, 'b> From<XmlElement<'a, 'b>> for XmlNode<'a, 'b> {
fn from(elem: XmlElement<'a, 'b>) -> Self {
XmlNode::Element(elem)
}
}
impl<'a, 'b> From<XmlText<'a, 'b>> for XmlNode<'a, 'b> {
fn from(elem: XmlText<'a, 'b>) -> Self {
XmlNode::Text(elem)
}
}
impl<'a, 'b> From<roxmltree::Node<'a, 'b>> for XmlNode<'a, 'b> {
fn from(node: roxmltree::Node<'a, 'b>) -> Self {
if node.is_text() {
XmlNode::Text(XmlText(node))
} else if node.is_element() | node.is_root() {
XmlNode::Element(XmlElement(node))
} else {
XmlNode::Ignored(node)
}
}
}

1
src/eww_state.rs
View file

@ -63,6 +63,7 @@ impl EwwState {
// get value from local
self.resolve(local_env, &value, set_value)
} else {
eprintln!("WARN: unknown variable '{}' was referenced", name);
false
}
}

15
src/util.rs
View file

@ -1,5 +1,7 @@
use anyhow::*;
use extend::ext;
use grass;
use itertools::Itertools;
use std::path::Path;
pub fn parse_scss_from_file<P: AsRef<Path>>(path: P) -> Result<String> {
@ -7,3 +9,16 @@ pub fn parse_scss_from_file<P: AsRef<Path>>(path: P) -> Result<String> {
grass::from_string(scss_content, &grass::Options::default())
.map_err(|err| anyhow!("encountered SCSS parsing error: {:?}", err))
}
#[ext(pub, name = StringExt)]
impl<T: AsRef<str>> T {
/// check if the string is empty after removing all linebreaks and trimming whitespace
fn is_blank(self) -> bool {
self.as_ref().replace('\n', "").trim().is_empty()
}
/// trim all lines in a string
fn trim_lines(self) -> String {
self.as_ref().lines().map(|line| line.trim()).join("\n")
}
}

13
src/widgets/widget_definitions.rs
View file

@ -58,6 +58,7 @@ pub(super) fn widget_to_gtk_widget(bargs: &mut BuilderArgs) -> Result<Option<gtk
"image" => build_gtk_image(bargs)?.upcast(),
"button" => build_gtk_button(bargs)?.upcast(),
"label" => build_gtk_label(bargs)?.upcast(),
"text" => build_gtk_text(bargs)?.upcast(),
_ => return Ok(None),
};
Ok(Some(gtk_widget))
@ -107,11 +108,21 @@ fn build_gtk_layout(bargs: &mut BuilderArgs) -> Result<gtk::Box> {
fn build_gtk_label(bargs: &mut BuilderArgs) -> Result<gtk::Label> {
let gtk_widget = gtk::Label::new(None);
resolve!(bargs, gtk_widget, {
resolve_str => "text" = 10.0 => |v| gtk_widget.set_text(&v),
resolve_str => "text" => |v| gtk_widget.set_text(&v),
});
Ok(gtk_widget)
}
fn build_gtk_text(bargs: &mut BuilderArgs) -> Result<gtk::Label> {
let text = bargs.widget.children.first().unwrap().get_attr("text")?;
let gtk_widget = gtk::Label::new(None);
bargs.eww_state.resolve_str(
bargs.local_env,
text,
glib::clone!(@strong gtk_widget => move |v| gtk_widget.set_text(&v)),
);
Ok(gtk_widget)
}
fn parse_orientation(o: &str) -> gtk::Orientation {
match o {
"vertical" | "v" => gtk::Orientation::Vertical,