Crate appstream

Source
Expand description

§Appstream

AppStream is a cross-distro effort for enhancing the metadata available about software components in the Linux and free-software ecosystem. One of the project’s goals is to make building software-center applications possible, and make interaction with the package sources of a distribution smarter. AppStream provides specifications for meta-information which is shipped by upstream projects and can be consumed by other software. The meta-information includes data which is interesting to display in software centers and is mainly useful for end-users, as well as descriptions about the public interfaces a software component provides, which is mainly useful for developers, 3rd-party software installers and for automatically installing missing components on a distribution, for example missing firmware or mimetype-handlers.

Specifications: https://www.freedesktop.org/software/appstream/docs/

This crate aimes to provide an easy and sane Rust parser of Appstream using xmltree

§Examples

use appstream::{Component, ParseError};
use appstream::builders::{ComponentBuilder, ReleaseBuilder};
use appstream::TranslatableString;
use appstream::enums::{Provide, ProjectUrl};
use url::Url;
use chrono::{Utc, TimeZone};
use std::convert::TryFrom;

fn main() -> Result<(), ParseError> {

    let xml = r"<?xml version='1.0' encoding='UTF-8'?>
                    <component>
                        <id>com.example.foobar</id>
                        <name>Foo Bar</name>
                        <summary>A foo-ish bar</summary>
                        <url type='homepage'>http://www.example.org</url>
                        <metadata_license>CC0-1.0</metadata_license>
                         
                        <provides>
                          <library>libfoobar.so.2</library>
                          <font>foo.ttf</font>
                          <binary>foobar</binary>
                        </provides>
                        <releases>
                          <release version='1.2' date='2015-02-16'/>
                        </releases>
                        <developer_name>FooBar Team</developer_name>
                    </component>";
    let element = xmltree::Element::parse(xml.as_bytes())?;
    let c1 = Component::try_from(&element)?;

    let c2 = ComponentBuilder::default()
        .id("com.example.foobar".into())
        .name(TranslatableString::with_default("Foo Bar"))
        .metadata_license("CC0-1.0".into())
        .summary(TranslatableString::with_default("A foo-ish bar"))
        .url(ProjectUrl::Homepage(
            Url::parse("http://www.example.org")?,
        ))
        .developer_name(TranslatableString::with_default("FooBar Team"))
        .provide(Provide::Library("libfoobar.so.2".into()))
        .provide(Provide::Font("foo.ttf".into()))
        .provide(Provide::Binary("foobar".into()))
        .release(
            ReleaseBuilder::new("1.2")
                .date(Utc.ymd(2015, 2, 16).and_hms_milli(0, 0, 0, 0))
                .build(),
        )
        .build();

    assert_eq!(c1, c2);
     
    Ok(())
}

The library can parse a collection of components as well

use appstream::{Collection, Component, ParseError};

fn main() -> Result<(), ParseError> {
    let collection = Collection::from_path("/var/lib/flatpak/appstream/flathub/x86_64/active/appstream.xml".into())?;
    #[cfg(feature="gzip")]
    let collection = Collection::from_gzipped("/var/lib/flatpak/appstream/flathub/x86_64/active/appstream.xml.gz".into())?;
    // Find a specific application by id
    println!("{:#?}", collection.find_by_id("org.gnome.design.Contrast".into()));

    // Find the list of gedit plugins
    collection.components.iter()
        .filter(|c| c.extends.contains(&"org.gnome.gedit".into()))
        .collect::<Vec<&Component>>();

    Ok(())
}

Re-exports§

pub use url;
pub use xmltree;

Modules§

builders
Various helpers to build any appstream type.
enums
Various enumerations used in the appstream types.

Structs§

AppId
Unique identifier of a component. It should be reverse-DNS name.
Artifact
Defines the release artifacts, whether it’s the source-code or the binary distribution. See <releases/>.
Collection
A collection is a wrapper around multiple components at once. Provided by the source of the components (a repository). See Collection Metadata.
Component
A component is wrapper around a metainfo.xml file or previously an appdata.xml file. It describes an application to the various stores out there on Linux.
ContentRating
Defines an Open Age Rating service. See OARS for more information.
Image
A screenshot image. See <screenshots/>.
Language
Defines how well a language is supported by the component. It provides access to a the locale and the percentage of the translation completion.
License
A SPDX license. See the list of commonly found licenses https://spdx.org/licenses/.
MarkupTranslatableString
A wrapper around a translable string that can contains markup.
Release
Represents the metainformation that defines a Release. See <releases/>.
Screenshot
Defines a visual representation of the Component. See <screenshots/>.
TranslatableList
A wrapper around a list of strings that are translatable.
TranslatableString
A wrapper around a translatable string.
Video
A screenshot video. See <screenshots/>.

Enums§

ParseError
Error happened during the parsing process.