gio-macros: Add #[dbus_interface] macro

Author: tautropfli

examples/gio_dbus_register_object/hello_world.rs

@@ -0,0 +1,37 @@
+use gio::DBusCallFlags;
+use std::time::Duration;
+
+#[gio::dbus_interface(
+    name = "com.github.gtk_rs.examples.HelloWorld",
+    type_name = "GtkRustHelloWorld",
+    emits_changed_signal = "true",
+    // crate = gio,
+)]
+pub(crate) trait HelloWorld {
+    #[deprecated]
+    fn hello(&self, name: String) -> String;
+
+    #[dbus(name = "Hello2", out_args("name", "effective_delay"))]
+    fn hello_with_delay(&self, name: String, delay: u32) -> (String, u32);
+
+    #[dbus(no_reply)]
+    fn no_greeting(&self, name: String);
+
+    #[dbus(property, get, name = "Name")]
+    fn last_greeted_name(&self) -> String;
+
+    #[dbus(property, get)]
+    #[deprecated]
+    fn count(&self) -> i64;
+
+    #[dbus(signal)]
+    fn greeted(&self, name: String);
+}
+
+async fn hello_tau(iface: &HelloWorld) -> Result<String, glib::Error> {
+    iface
+        .hello("Tau".to_owned())
+        .timeout(Duration::from_secs(5))
+        .flags(DBusCallFlags::ALLOW_INTERACTIVE_AUTHORIZATION)
+        .await
+}

examples/gio_dbus_register_object/main.rs

@@ -1,5 +1,7 @@
 use gio::prelude::*;
 
+mod hello_world;
+
 glib::wrapper! {
     pub struct SampleApplication(ObjectSubclass<imp::SampleApplication>)
         @extends gio::Application,

gio-macros/src/dbus_interface/attributes/argument.rs

@@ -0,0 +1,30 @@
+// Take a look at the license at the top of the repository in the LICENSE file.
+
+use crate::dbus_interface::attributes::ATTRIBUTE_NAME;
+use syn::{Attribute, LitStr};
+
+pub(crate) struct DBusMethodArgumentAttribute {
+    pub(crate) name: Option<LitStr>,
+}
+
+impl DBusMethodArgumentAttribute {
+    pub(crate) fn parse(attrs: &[Attribute]) -> syn::Result<Self> {
+        let mut name: Option<LitStr> = None;
+        for attr in attrs {
+            if attr.path().is_ident(ATTRIBUTE_NAME) {
+                attr.parse_nested_meta(|meta| {
+                    if meta.path.is_ident("name") {
+                        name = Some(meta.value()?.parse()?);
+                        Ok(())
+                    } else {
+                        Err(meta.error(format!(
+                            "unknown attribute `{}`. Possible attributes are `name`",
+                            meta.path.get_ident().unwrap(),
+                        )))
+                    }
+                })?;
+            }
+        }
+        Ok(Self { name })
+    }
+}

gio-macros/src/dbus_interface/attributes/dbus_interface.rs

@@ -0,0 +1,70 @@
+// Take a look at the license at the top of the repository in the LICENSE file.
+
+use crate::dbus_interface::attributes::EmitsChangedSignal;
+use proc_macro2::TokenStream;
+use syn::spanned::Spanned;
+use syn::{LitStr, Path};
+
+/// The `#[dbus_interface(...)]` attribute.
+pub(crate) struct DBusInterfaceAttribute {
+    pub(crate) name: LitStr,
+    pub(crate) type_name: Option<LitStr>,
+    pub(crate) crate_: Option<Path>,
+    pub(crate) emits_changed_signal: Option<EmitsChangedSignal>,
+    pub(crate) generate_proxy: bool,
+    pub(crate) generate_skeleton: bool,
+}
+
+impl DBusInterfaceAttribute {
+    pub(crate) fn parse(attr: TokenStream) -> syn::Result<Self> {
+        let span = attr.span();
+        let mut name: Option<LitStr> = None;
+        let mut type_name: Option<LitStr> = None;
+        let mut crate_: Option<Path> = None;
+        let mut emits_changed_signal: Option<EmitsChangedSignal> = None;
+        let mut generate_proxy = false;
+        let mut generate_skeleton = false;
+        let p = syn::meta::parser(|meta| {
+            if meta.path.is_ident("name") {
+                name = Some(meta.value()?.parse()?);
+                Ok(())
+            } else if meta.path.is_ident("type_name") {
+                type_name = Some(meta.value()?.parse()?);
+                Ok(())
+            } else if meta.path.is_ident("crate") {
+                crate_ = Some(meta.value()?.parse()?);
+                Ok(())
+            } else if meta.path.is_ident("emits_changed_signal") {
+                emits_changed_signal = Some(meta.value()?.parse()?);
+                Ok(())
+            } else if meta.path.is_ident("proxy") {
+                generate_proxy = true;
+                Ok(())
+            } else if meta.path.is_ident("skeleton") {
+                generate_skeleton = true;
+                Ok(())
+            } else {
+                Err(meta.error(format!(
+                    "unknown attribute `{}`. Possible attributes are `name`, `type_name`, `crate`, `emits_changed_signal`",
+                    meta.path.get_ident().unwrap(),
+                )))
+            }
+        });
+        syn::parse::Parser::parse2(p, attr)?;
+
+        let Some(name) = name else {
+            return Err(syn::Error::new(
+                span,
+                "attribute `#[dbus_interface(name = ...)]` must be specified",
+            ));
+        };
+        Ok(Self {
+            name,
+            type_name,
+            crate_,
+            emits_changed_signal,
+            generate_proxy,
+            generate_skeleton,
+        })
+    }
+}

gio-macros/src/dbus_interface/attributes/emits_changed_signal.rs

@@ -0,0 +1,45 @@
+// Take a look at the license at the top of the repository in the LICENSE file.
+
+use proc_macro2::Span;
+use syn::LitStr;
+use syn::parse::Parse;
+
+#[derive(Clone)]
+pub(crate) struct EmitsChangedSignal {
+    pub(crate) kind: EmitsChangedSignalKind,
+    pub(crate) span: Span,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub(crate) enum EmitsChangedSignalKind {
+    True,
+    Invalidates,
+    Const,
+    False,
+}
+
+impl Parse for EmitsChangedSignal {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        use EmitsChangedSignalKind::*;
+        let lit: LitStr = input.parse()?;
+        let value = lit.value();
+        let kind = match value.as_str() {
+            "true" => True,
+            "invalidates" => Invalidates,
+            "const" => Const,
+            "false" => False,
+            _ => {
+                return Err(syn::Error::new(
+                    lit.span(),
+                    format!(
+                        "unknown value {value:?}. Possible values are \"true\", \"invalidates\", \"const\", \"false\""
+                    ),
+                ));
+            }
+        };
+        Ok(EmitsChangedSignal {
+            kind,
+            span: lit.span(),
+        })
+    }
+}

gio-macros/src/dbus_interface/attributes/item.rs

@@ -0,0 +1,200 @@
+// Take a look at the license at the top of the repository in the LICENSE file.
+
+use crate::dbus_interface::attributes::{ATTRIBUTE_NAME, EmitsChangedSignal};
+use proc_macro2::Span;
+use syn::punctuated::Punctuated;
+use syn::{Attribute, LitStr, Meta, Token, parenthesized};
+
+/// The attribute placed on an `fn` item in the `#[dbus_interface]` trait.
+pub(crate) enum DBusItemAttribute {
+    /// `#[dbus(...)]`
+    Method(DBusItemAttributeMethod),
+    /// `#[dbus(signal, ...)]`
+    Signal(DBusItemAttributeSignal),
+    /// `#[dbus(property, ...)]
+    Property(DBusItemAttributeProperty),
+}
+
+pub(crate) struct DBusItemAttributeMethod {
+    pub(crate) name: Option<LitStr>,
+    pub(crate) out_args: Option<Punctuated<LitStr, Token![,]>>,
+    pub(crate) no_reply: bool,
+}
+
+pub(crate) struct DBusItemAttributeSignal {
+    pub(crate) name: Option<LitStr>,
+}
+
+pub(crate) struct DBusItemAttributeProperty {
+    pub(crate) name: Option<LitStr>,
+    pub(crate) access: DBusPropertyAccess,
+    pub(crate) emits_changed_signal: Option<EmitsChangedSignal>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum DBusPropertyAccess {
+    Read,
+    Write,
+    ReadWrite,
+}
+
+impl DBusPropertyAccess {
+    pub(crate) fn or(self, other: DBusPropertyAccess) -> Self {
+        if self == other {
+            self
+        } else {
+            DBusPropertyAccess::ReadWrite
+        }
+    }
+}
+
+impl DBusItemAttribute {
+    pub(crate) fn parse(attrs: &[Attribute], span: Span) -> syn::Result<Self> {
+        let tag = DBusItemAttributeTag::parse(attrs)?;
+        match tag {
+            None => DBusItemAttributeMethod::parse(attrs).map(Self::Method),
+            Some(DBusItemAttributeTag::Signal) => {
+                DBusItemAttributeSignal::parse(attrs).map(Self::Signal)
+            }
+            Some(DBusItemAttributeTag::Property) => {
+                DBusItemAttributeProperty::parse(attrs, span).map(Self::Property)
+            }
+        }
+    }
+}
+
+impl DBusItemAttributeMethod {
+    fn parse(attrs: &[Attribute]) -> syn::Result<Self> {
+        let mut name: Option<LitStr> = None;
+        let mut out_args: Option<Punctuated<LitStr, Token![,]>> = None;
+        let mut no_reply = false;
+        for attr in attrs {
+            if attr.path().is_ident(ATTRIBUTE_NAME) {
+                attr.parse_nested_meta(|meta| {
+                    if meta.path.is_ident("name") {
+                        name = Some(meta.value()?.parse()?);
+                        Ok(())
+                    } else if meta.path.is_ident("out_args") {
+                        let content;
+                        parenthesized!(content in meta.input);
+                        out_args = Some(content.call(Punctuated::parse_terminated)?);
+                        Ok(())
+                    } else if meta.path.is_ident("no_reply") {
+                        no_reply = true;
+                        Ok(())
+                    } else {
+                        Err(meta.error(format!(
+                            "unknown attribute `{}`. Possible attributes are `name`, `out_args`, `no_reply`",
+                            meta.path.get_ident().unwrap(),
+                        )))
+                    }
+                })?;
+            }
+        }
+        Ok(Self {
+            name,
+            out_args,
+            no_reply,
+        })
+    }
+}
+
+impl DBusItemAttributeSignal {
+    fn parse(attrs: &[Attribute]) -> syn::Result<Self> {
+        let mut name: Option<LitStr> = None;
+        for attr in attrs {
+            if attr.path().is_ident(ATTRIBUTE_NAME) {
+                attr.parse_nested_meta(|meta| {
+                    if meta.path.is_ident("signal") {
+                        Ok(())
+                    } else if meta.path.is_ident("name") {
+                        name = Some(meta.value()?.parse()?);
+                        Ok(())
+                    } else {
+                        Err(meta.error(format!(
+                            "unknown attribute `{}`. Possible attributes are `name`",
+                            meta.path.get_ident().unwrap(),
+                        )))
+                    }
+                })?;
+            }
+        }
+        Ok(Self { name })
+    }
+}
+
+impl DBusItemAttributeProperty {
+    fn parse(attrs: &[Attribute], span: Span) -> syn::Result<Self> {
+        let mut name: Option<LitStr> = None;
+        let mut access: Option<DBusPropertyAccess> = None;
+        let mut emits_changed_signal: Option<EmitsChangedSignal> = None;
+        for attr in attrs {
+            if attr.path().is_ident(ATTRIBUTE_NAME) {
+                attr.parse_nested_meta(|meta| {
+                    if meta.path.is_ident("property") {
+                        Ok(())
+                    } else if meta.path.is_ident("name") {
+                        name = Some(meta.value()?.parse()?);
+                        Ok(())
+                    } else if meta.path.is_ident("get") {
+                        access = Some(access
+                            .unwrap_or(DBusPropertyAccess::Read)
+                            .or(DBusPropertyAccess::Read));
+                        Ok(())
+                    } else if meta.path.is_ident("set") {
+                        access = Some(access
+                            .unwrap_or(DBusPropertyAccess::Write)
+                            .or(DBusPropertyAccess::Write));
+                        Ok(())
+                    } else if meta.path.is_ident("emits_changed_signal") {
+                        emits_changed_signal = Some(meta.value()?.parse()?);
+                        Ok(())
+                    } else {
+                        Err(meta.error(format!(
+                            "unknown attribute `{}`. Possible attributes are `name`, `get`, `set`, `emits_changed_signal`",
+                            meta.path.get_ident().unwrap(),
+                        )))
+                    }
+                })?;
+            }
+        }
+        let Some(access) = access else {
+            return Err(syn::Error::new(
+                span,
+                "either the attribute `get` or `set` attribute (or both) must be specified",
+            ));
+        };
+        Ok(Self {
+            name,
+            access,
+            emits_changed_signal,
+        })
+    }
+}
+
+enum DBusItemAttributeTag {
+    Signal,
+    Property,
+}
+
+impl DBusItemAttributeTag {
+    pub(crate) fn parse(attrs: &[Attribute]) -> syn::Result<Option<Self>> {
+        let mut tag = None;
+        for attr in attrs {
+            if attr.path().is_ident(ATTRIBUTE_NAME) {
+                let nested =
+                    attr.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?;
+                if let Some(first_nested) = nested.first() {
+                    if first_nested.path().is_ident("signal") {
+                        tag = Some(Self::Signal);
+                        first_nested.require_path_only()?;
+                    } else if first_nested.path().is_ident("property") {
+                        tag = Some(Self::Property);
+                        first_nested.require_path_only()?;
+                    }
+                }
+            }
+        }
+        Ok(tag)
+    }
+}