Crate appstream[−][src]

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/>.