summaryrefslogtreecommitdiffstats
path: root/lib/gs-appstream.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--lib/gs-appstream.c2165
1 files changed, 2165 insertions, 0 deletions
diff --git a/lib/gs-appstream.c b/lib/gs-appstream.c
new file mode 100644
index 0000000..fa94a6e
--- /dev/null
+++ b/lib/gs-appstream.c
@@ -0,0 +1,2165 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
+ * vi:set noexpandtab tabstop=8 shiftwidth=8:
+ *
+ * Copyright (C) 2015-2017 Richard Hughes <richard@hughsie.com>
+ * Copyright (C) 2018-2019 Kalev Lember <klember@redhat.com>
+ *
+ * SPDX-License-Identifier: GPL-2.0+
+ */
+
+#include "config.h"
+
+#include <gnome-software.h>
+#include <locale.h>
+
+#include "gs-appstream.h"
+
+#define GS_APPSTREAM_MAX_SCREENSHOTS 5
+
+GsApp *
+gs_appstream_create_app (GsPlugin *plugin, XbSilo *silo, XbNode *component, GError **error)
+{
+ GsApp *app;
+ g_autoptr(GsApp) app_new = NULL;
+
+ /* The 'plugin' can be NULL, when creating app for --show-metainfo */
+ g_return_val_if_fail (XB_IS_SILO (silo), NULL);
+ g_return_val_if_fail (XB_IS_NODE (component), NULL);
+
+ app_new = gs_app_new (NULL);
+
+ /* refine enough to get the unique ID */
+ if (!gs_appstream_refine_app (plugin, app_new, silo, component,
+ GS_PLUGIN_REFINE_FLAGS_REQUIRE_ID,
+ error))
+ return NULL;
+
+ /* never add wildcard apps to the plugin cache, and only add to
+ * the cache if it’s available */
+ if (gs_app_has_quirk (app_new, GS_APP_QUIRK_IS_WILDCARD) || plugin == NULL)
+ return g_steal_pointer (&app_new);
+
+ if (plugin == NULL)
+ return g_steal_pointer (&app_new);
+
+ /* look for existing object */
+ app = gs_plugin_cache_lookup (plugin, gs_app_get_unique_id (app_new));
+ if (app != NULL)
+ return app;
+
+ /* use the temp object we just created */
+ gs_app_set_metadata (app_new, "GnomeSoftware::Creator",
+ gs_plugin_get_name (plugin));
+ gs_plugin_cache_add (plugin, NULL, app_new);
+ return g_steal_pointer (&app_new);
+}
+
+/* Helper function to do the equivalent of
+ * *node = xb_node_get_next (*node)
+ * but with correct reference counting, since xb_node_get_next() returns a new
+ * ref. */
+static void
+node_set_to_next (XbNode **node)
+{
+ g_autoptr(XbNode) next_node = NULL;
+
+ g_assert (node != NULL);
+ g_assert (*node != NULL);
+
+ next_node = xb_node_get_next (*node);
+ g_object_unref (*node);
+ *node = g_steal_pointer (&next_node);
+}
+
+/* Returns escaped text */
+static gchar *
+gs_appstream_format_description_text (XbNode *node)
+{
+ g_autoptr(GString) str = g_string_new (NULL);
+ const gchar *node_text;
+
+ if (node == NULL)
+ return NULL;
+
+ node_text = xb_node_get_text (node);
+ if (node_text != NULL && *node_text != '\0') {
+ g_autofree gchar *escaped = g_markup_escape_text (node_text, -1);
+ g_string_append (str, escaped);
+ }
+
+ for (g_autoptr(XbNode) n = xb_node_get_child (node); n != NULL; node_set_to_next (&n)) {
+ const gchar *start_elem = "", *end_elem = "";
+ g_autofree gchar *text = NULL;
+ if (g_strcmp0 (xb_node_get_element (n), "em") == 0) {
+ start_elem = "<i>";
+ end_elem = "</i>";
+ } else if (g_strcmp0 (xb_node_get_element (n), "code") == 0) {
+ start_elem = "<tt>";
+ end_elem = "</tt>";
+ }
+
+ /* These can be nested */
+ text = gs_appstream_format_description_text (n);
+ if (text != NULL) {
+ g_string_append_printf (str, "%s%s%s", start_elem, text, end_elem);
+ }
+
+ node_text = xb_node_get_tail (n);
+ if (node_text != NULL && *node_text != '\0') {
+ g_autofree gchar *escaped = g_markup_escape_text (node_text, -1);
+ g_string_append (str, escaped);
+ }
+ }
+
+ if (str->len == 0)
+ return NULL;
+
+ return g_string_free (g_steal_pointer (&str), FALSE);
+}
+
+static gchar *
+gs_appstream_format_description (XbNode *root, GError **error)
+{
+ g_autoptr(GString) str = g_string_new (NULL);
+
+ for (g_autoptr(XbNode) n = xb_node_get_child (root); n != NULL; node_set_to_next (&n)) {
+ /* support <p>, <em>, <code>, <ul>, <ol> and <li>, ignore all else */
+ if (g_strcmp0 (xb_node_get_element (n), "p") == 0) {
+ g_autofree gchar *escaped = gs_appstream_format_description_text (n);
+ /* Treat a self-closing paragraph (`<p/>`) as
+ * nonexistent. This is consistent with Firefox. */
+ if (escaped != NULL)
+ g_string_append_printf (str, "%s\n\n", escaped);
+ } else if (g_strcmp0 (xb_node_get_element (n), "ul") == 0) {
+ g_autoptr(GPtrArray) children = xb_node_get_children (n);
+
+ for (guint i = 0; i < children->len; i++) {
+ XbNode *nc = g_ptr_array_index (children, i);
+ if (g_strcmp0 (xb_node_get_element (nc), "li") == 0) {
+ g_autofree gchar *escaped = gs_appstream_format_description_text (nc);
+
+ /* Treat a self-closing `<li/>` as an empty
+ * list element (equivalent to `<li></li>`).
+ * This is consistent with Firefox. */
+ g_string_append_printf (str, " • %s\n",
+ (escaped != NULL) ? escaped : "");
+ }
+ }
+ g_string_append (str, "\n");
+ } else if (g_strcmp0 (xb_node_get_element (n), "ol") == 0) {
+ g_autoptr(GPtrArray) children = xb_node_get_children (n);
+ for (guint i = 0; i < children->len; i++) {
+ XbNode *nc = g_ptr_array_index (children, i);
+ if (g_strcmp0 (xb_node_get_element (nc), "li") == 0) {
+ g_autofree gchar *escaped = gs_appstream_format_description_text (nc);
+
+ /* Treat self-closing elements as with `<ul>` above. */
+ g_string_append_printf (str, " %u. %s\n",
+ i + 1,
+ (escaped != NULL) ? escaped : "");
+ }
+ }
+ g_string_append (str, "\n");
+ }
+ }
+
+ /* remove extra newlines */
+ while (str->len > 0 && str->str[str->len - 1] == '\n')
+ g_string_truncate (str, str->len - 1);
+
+ /* success */
+ return g_string_free (g_steal_pointer (&str), FALSE);
+}
+
+static gchar *
+gs_appstream_build_icon_prefix (XbNode *component)
+{
+ const gchar *origin;
+ const gchar *tmp;
+ gint npath;
+ g_auto(GStrv) path = NULL;
+ g_autoptr(XbNode) components = NULL;
+
+ /* no parent, e.g. AppData */
+ components = xb_node_get_parent (component);
+ if (components == NULL)
+ return NULL;
+
+ /* set explicitly */
+ tmp = xb_node_query_text (components, "info/icon-prefix", NULL);
+ if (tmp != NULL)
+ return g_strdup (tmp);
+
+ /* fall back to origin */
+ origin = xb_node_get_attr (components, "origin");
+ if (origin == NULL)
+ return NULL;
+
+ /* no metadata */
+ tmp = xb_node_query_text (components, "info/filename", NULL);
+ if (tmp == NULL)
+ return NULL;
+
+ /* check format */
+ path = g_strsplit (tmp, "/", -1);
+ npath = g_strv_length (path);
+ if (npath < 3 ||
+ !(g_strcmp0 (path[npath-2], "xmls") == 0 ||
+ g_strcmp0 (path[npath-2], "yaml") == 0 ||
+ g_strcmp0 (path[npath-2], "xml") == 0))
+ return NULL;
+
+ /* fix the new path */
+ g_free (path[npath-1]);
+ g_free (path[npath-2]);
+ path[npath-1] = g_strdup (origin);
+ path[npath-2] = g_strdup ("icons");
+ return g_strjoinv ("/", path);
+}
+
+/* This function is designed to do no disk or network I/O. */
+static AsIcon *
+gs_appstream_new_icon (XbNode *component, XbNode *n, AsIconKind icon_kind, guint sz)
+{
+ AsIcon *icon = as_icon_new ();
+ g_autofree gchar *icon_path = NULL;
+ as_icon_set_kind (icon, icon_kind);
+ switch (icon_kind) {
+ case AS_ICON_KIND_LOCAL:
+ as_icon_set_filename (icon, xb_node_get_text (n));
+ break;
+ case AS_ICON_KIND_REMOTE:
+ as_icon_set_url (icon, xb_node_get_text (n));
+ break;
+ default:
+ as_icon_set_name (icon, xb_node_get_text (n));
+ }
+ if (sz == 0) {
+ guint64 width = xb_node_get_attr_as_uint (n, "width");
+ if (width > 0 && width < G_MAXUINT)
+ sz = width;
+ }
+
+ if (sz > 0) {
+ as_icon_set_width (icon, sz);
+ as_icon_set_height (icon, sz);
+ }
+
+ if (icon_kind != AS_ICON_KIND_LOCAL && icon_kind != AS_ICON_KIND_REMOTE) {
+ /* add partial filename for now, we will compose the full one later */
+ icon_path = gs_appstream_build_icon_prefix (component);
+ as_icon_set_filename (icon, icon_path);
+ }
+ return icon;
+}
+
+static void
+app_add_icon (GsApp *app,
+ AsIcon *as_icon)
+{
+ g_autoptr(GIcon) icon = gs_icon_new_for_appstream_icon (as_icon);
+ if (icon != NULL)
+ gs_app_add_icon (app, icon);
+}
+
+static void
+traverse_component_icons (GsApp *app,
+ XbNode *component,
+ GPtrArray *icons)
+{
+ if (!icons)
+ return;
+
+ /* This code deliberately does *not* check that the icon files or theme
+ * icons exist, as that would mean doing disk I/O for all the apps in
+ * the appstream file, regardless of whether the calling code is
+ * actually going to use the icons. Better to add all the possible icons
+ * and let the calling code check which ones exist, if it needs to. */
+ for (guint i = 0; i < icons->len; i++) {
+ XbNode *icon_node = g_ptr_array_index (icons, i);
+ g_autoptr(AsIcon) icon = NULL;
+ const gchar *icon_kind_str = xb_node_get_attr (icon_node, "type");
+ AsIconKind icon_kind = as_icon_kind_from_string (icon_kind_str);
+
+ if (icon_kind == AS_ICON_KIND_UNKNOWN) {
+ g_debug ("unknown icon kind ‘%s’", icon_kind_str);
+ continue;
+ }
+
+ icon = gs_appstream_new_icon (component, icon_node, icon_kind, 0);
+ app_add_icon (app, icon);
+ }
+}
+
+static void
+traverse_components_xpath_for_icons (GsApp *app,
+ XbSilo *silo,
+ const gchar *xpath,
+ gboolean try_with_launchable)
+{
+ g_autoptr(GPtrArray) components = NULL;
+ g_autoptr(GError) local_error = NULL;
+
+ components = xb_silo_query (silo, xpath, 0, &local_error);
+ if (components) {
+ for (guint i = 0; i < components->len; i++) {
+ g_autoptr(GPtrArray) icons = NULL; /* (element-type XbNode) */
+ XbNode *component = g_ptr_array_index (components, i);
+ g_autofree gchar *xml = xb_node_export (component, 0, NULL);
+ icons = xb_node_query (component, "icon", 0, NULL);
+ traverse_component_icons (app, component, icons);
+
+ if (try_with_launchable && gs_app_get_icons (app) == NULL) {
+ const gchar *launchable_id = xb_node_query_text (component, "launchable[@type='desktop-id']", NULL);
+ if (launchable_id != NULL) {
+ g_autofree gchar *xpath2 = NULL;
+
+ /* Inherit the icon from the .desktop file */
+ xpath2 = g_strdup_printf ("/component[@type='desktop-application']/launchable[@type='desktop-id'][text()='%s']/..",
+ launchable_id);
+ traverse_components_xpath_for_icons (app, silo, xpath2, FALSE);
+ }
+ }
+ }
+ }
+}
+
+static void
+gs_appstream_refine_icon (GsApp *app,
+ XbSilo *silo,
+ XbNode *component)
+{
+ g_autoptr(GError) local_error = NULL;
+ g_autoptr(GPtrArray) icons = NULL; /* (element-type XbNode) */
+
+ icons = xb_node_query (component, "icon", 0, &local_error);
+ traverse_component_icons (app, component, icons);
+ g_clear_pointer (&icons, g_ptr_array_unref);
+
+ /* If no icon found, try to inherit the icon from the .desktop file */
+ if (gs_app_get_icons (app) == NULL) {
+ g_autofree gchar *xpath = NULL;
+ const gchar *launchable_id = xb_node_query_text (component, "launchable[@type='desktop-id']", NULL);
+ if (launchable_id != NULL) {
+ xpath = g_strdup_printf ("/component[@type='desktop-application']/launchable[@type='desktop-id'][text()='%s']/..",
+ launchable_id);
+ traverse_components_xpath_for_icons (app, silo, xpath, FALSE);
+ g_clear_pointer (&xpath, g_free);
+ }
+
+ xpath = g_strdup_printf ("/component[@type='desktop-application']/launchable[@type='desktop-id'][text()='%s']/..",
+ gs_app_get_id (app));
+ traverse_components_xpath_for_icons (app, silo, xpath, FALSE);
+ }
+}
+
+static gboolean
+gs_appstream_refine_add_addons (GsPlugin *plugin,
+ GsApp *app,
+ XbSilo *silo,
+ GError **error)
+{
+ g_autofree gchar *xpath = NULL;
+ g_autoptr(GError) error_local = NULL;
+ g_autoptr(GPtrArray) addons = NULL;
+ g_autoptr(GsAppList) addons_list = NULL;
+
+ /* get all components */
+ xpath = g_strdup_printf ("components/component/extends[text()='%s']/..",
+ gs_app_get_id (app));
+ addons = xb_silo_query (silo, xpath, 0, &error_local);
+ if (addons == NULL) {
+ if (g_error_matches (error_local, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
+ return TRUE;
+ g_propagate_error (error, g_steal_pointer (&error_local));
+ return FALSE;
+ }
+
+ addons_list = gs_app_list_new ();
+
+ for (guint i = 0; i < addons->len; i++) {
+ XbNode *addon = g_ptr_array_index (addons, i);
+ g_autoptr(GsApp) addon_app = NULL;
+
+ addon_app = gs_appstream_create_app (plugin, silo, addon, error);
+ if (addon_app == NULL)
+ return FALSE;
+
+ gs_app_list_add (addons_list, addon_app);
+ }
+
+ gs_app_add_addons (app, addons_list);
+
+ return TRUE;
+}
+
+static gboolean
+gs_appstream_refine_add_images (GsApp *app,
+ AsScreenshot *ss,
+ XbNode *screenshot,
+ gboolean *out_any_added,
+ GError **error)
+{
+ g_autoptr(GError) error_local = NULL;
+ g_autoptr(GPtrArray) images = NULL;
+
+ /* get all components */
+ images = xb_node_query (screenshot, "image", 0, &error_local);
+ if (images == NULL) {
+ if (g_error_matches (error_local, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
+ return TRUE;
+ g_propagate_error (error, g_steal_pointer (&error_local));
+ return FALSE;
+ }
+ for (guint i = 0; i < images->len; i++) {
+ XbNode *image = g_ptr_array_index (images, i);
+ g_autoptr(AsImage) im = as_image_new ();
+ as_image_set_height (im, xb_node_get_attr_as_uint (image, "height"));
+ as_image_set_width (im, xb_node_get_attr_as_uint (image, "width"));
+ as_image_set_kind (im, as_image_kind_from_string (xb_node_get_attr (image, "type")));
+ as_image_set_url (im, xb_node_get_text (image));
+ as_screenshot_add_image (ss, im);
+ }
+
+ *out_any_added = *out_any_added || images->len > 0;
+
+ /* success */
+ return TRUE;
+}
+
+static gboolean
+gs_appstream_refine_add_videos (GsApp *app,
+ AsScreenshot *ss,
+ XbNode *screenshot,
+ gboolean *out_any_added,
+ GError **error)
+{
+ g_autoptr(GError) error_local = NULL;
+ g_autoptr(GPtrArray) videos = NULL;
+
+ videos = xb_node_query (screenshot, "video", 0, &error_local);
+ if (videos == NULL) {
+ if (g_error_matches (error_local, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
+ return TRUE;
+ g_propagate_error (error, g_steal_pointer (&error_local));
+ return FALSE;
+ }
+ for (guint i = 0; i < videos->len; i++) {
+ XbNode *video = g_ptr_array_index (videos, i);
+ g_autoptr(AsVideo) vid = as_video_new ();
+ as_video_set_height (vid, xb_node_get_attr_as_uint (video, "height"));
+ as_video_set_width (vid, xb_node_get_attr_as_uint (video, "width"));
+ as_video_set_codec_kind (vid, as_video_codec_kind_from_string (xb_node_get_attr (video, "codec")));
+ as_video_set_container_kind (vid, as_video_container_kind_from_string (xb_node_get_attr (video, "container")));
+ as_video_set_url (vid, xb_node_get_text (video));
+ as_screenshot_add_video (ss, vid);
+ }
+
+ *out_any_added = *out_any_added || videos->len > 0;
+
+ return TRUE;
+}
+
+static gboolean
+gs_appstream_refine_add_screenshots (GsApp *app, XbNode *component, GError **error)
+{
+ g_autoptr(GError) error_local = NULL;
+ g_autoptr(GPtrArray) screenshots = NULL;
+
+ /* get all components */
+ screenshots = xb_node_query (component, "screenshots/screenshot", 0, &error_local);
+ if (screenshots == NULL) {
+ if (g_error_matches (error_local, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
+ return TRUE;
+ g_propagate_error (error, g_steal_pointer (&error_local));
+ return FALSE;
+ }
+ for (guint i = 0; i < screenshots->len; i++) {
+ XbNode *screenshot = g_ptr_array_index (screenshots, i);
+ g_autoptr(AsScreenshot) ss = as_screenshot_new ();
+ gboolean any_added = FALSE;
+ if (!gs_appstream_refine_add_images (app, ss, screenshot, &any_added, error) ||
+ !gs_appstream_refine_add_videos (app, ss, screenshot, &any_added, error))
+ return FALSE;
+ if (any_added)
+ gs_app_add_screenshot (app, ss);
+ }
+
+ /* FIXME: move into no refine flags section? */
+ if (screenshots ->len > 0)
+ gs_app_add_kudo (app, GS_APP_KUDO_HAS_SCREENSHOTS);
+
+ /* success */
+ return TRUE;
+}
+
+static gboolean
+gs_appstream_refine_add_provides (GsApp *app, XbNode *component, GError **error)
+{
+ g_autoptr(GError) error_local = NULL;
+ g_autoptr(GPtrArray) provides = NULL;
+
+ /* get all components */
+ provides = xb_node_query (component, "provides/*", 0, &error_local);
+ if (provides == NULL) {
+ if (g_error_matches (error_local, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
+ return TRUE;
+ g_propagate_error (error, g_steal_pointer (&error_local));
+ return FALSE;
+ }
+ for (guint i = 0; i < provides->len; i++) {
+ AsProvidedKind kind;
+ const gchar *element_name;
+ XbNode *provide = g_ptr_array_index (provides, i);
+ element_name = xb_node_get_element (provide);
+
+ /* try the simple case */
+ kind = as_provided_kind_from_string (element_name);
+ if (kind == AS_PROVIDED_KIND_UNKNOWN) {
+ /* try the complex cases */
+
+ if (g_strcmp0 (element_name, "library") == 0) {
+ kind = AS_PROVIDED_KIND_LIBRARY;
+ } else if (g_strcmp0 (element_name, "binary") == 0) {
+ kind = AS_PROVIDED_KIND_BINARY;
+ } else if (g_strcmp0 (element_name, "firmware") == 0) {
+ const gchar *fw_type = xb_node_get_attr (provide, "type");
+ if (g_strcmp0 (fw_type, "runtime") == 0)
+ kind = AS_PROVIDED_KIND_FIRMWARE_RUNTIME;
+ else if (g_strcmp0 (fw_type, "flashed") == 0)
+ kind = AS_PROVIDED_KIND_FIRMWARE_FLASHED;
+ } else if (g_strcmp0 (element_name, "python2") == 0) {
+ kind = AS_PROVIDED_KIND_PYTHON_2;
+ } else if (g_strcmp0 (element_name, "python3") == 0) {
+ kind = AS_PROVIDED_KIND_PYTHON;
+ } else if (g_strcmp0 (element_name, "dbus") == 0) {
+ const gchar *dbus_type = xb_node_get_attr (provide, "type");
+ if (g_strcmp0 (dbus_type, "system") == 0)
+ kind = AS_PROVIDED_KIND_DBUS_SYSTEM;
+ else if ((g_strcmp0 (dbus_type, "user") == 0) || (g_strcmp0 (dbus_type, "session") == 0))
+ kind = AS_PROVIDED_KIND_DBUS_USER;
+ }
+ }
+
+ if (kind == AS_PROVIDED_KIND_UNKNOWN ||
+ xb_node_get_text (provide) == NULL) {
+ /* give up */
+ g_warning ("ignoring unknown or empty provided item type: %s", element_name);
+ continue;
+ }
+
+ gs_app_add_provided_item (app,
+ kind,
+ xb_node_get_text (provide));
+ }
+
+ /* success */
+ return TRUE;
+}
+
+static guint64
+component_get_release_timestamp (XbNode *component)
+{
+ guint64 timestamp;
+ const gchar *date_str;
+
+ /* Spec says to prefer `timestamp` over `date` if both are provided:
+ * https://www.freedesktop.org/software/appstream/docs/chap-Metadata.html#tag-releases */
+ timestamp = xb_node_query_attr_as_uint (component, "releases/release", "timestamp", NULL);
+ date_str = xb_node_query_attr (component, "releases/release", "date", NULL);
+
+ if (timestamp != G_MAXUINT64) {
+ return timestamp;
+ } else if (date_str != NULL) {
+ g_autoptr(GDateTime) date = g_date_time_new_from_iso8601 (date_str, NULL);
+ if (date != NULL)
+ return g_date_time_to_unix (date);
+ }
+
+ /* Unknown. */
+ return G_MAXUINT64;
+}
+
+static gboolean
+gs_appstream_is_recent_release (XbNode *component)
+{
+ guint64 ts;
+ gint64 secs;
+
+ /* get newest release */
+ ts = component_get_release_timestamp (component);
+ if (ts == G_MAXUINT64)
+ return FALSE;
+
+ /* is last build less than one year ago? */
+ secs = (g_get_real_time () / G_USEC_PER_SEC) - ts;
+ return secs / (60 * 60 * 24) < 365;
+}
+
+static gboolean
+gs_appstream_copy_metadata (GsApp *app, XbNode *component, GError **error)
+{
+ g_autoptr(GError) error_local = NULL;
+ g_autoptr(GPtrArray) values = NULL;
+
+ /* get all components */
+ values = xb_node_query (component, "custom/value", 0, &error_local);
+ if (values == NULL) {
+ if (g_error_matches (error_local, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
+ return TRUE;
+ g_propagate_error (error, g_steal_pointer (&error_local));
+ return FALSE;
+ }
+ for (guint i = 0; i < values->len; i++) {
+ XbNode *value = g_ptr_array_index (values, i);
+ const gchar *key = xb_node_get_attr (value, "key");
+ if (key == NULL)
+ continue;
+ if (gs_app_get_metadata_item (app, key) != NULL)
+ continue;
+ gs_app_set_metadata (app, key, xb_node_get_text (value));
+ }
+ return TRUE;
+}
+
+static gboolean
+gs_appstream_refine_app_updates (GsApp *app,
+ XbSilo *silo,
+ XbNode *component,
+ GError **error)
+{
+ AsUrgencyKind urgency_best = AS_URGENCY_KIND_UNKNOWN;
+ g_autofree gchar *xpath = NULL;
+ g_autoptr(GError) error_local = NULL;
+ g_autoptr(GHashTable) installed = g_hash_table_new (g_str_hash, g_str_equal);
+ g_autoptr(GPtrArray) releases_inst = NULL;
+ g_autoptr(GPtrArray) releases = NULL;
+ g_autoptr(GPtrArray) updates_list = g_ptr_array_new ();
+
+ /* only for UPDATABLE apps */
+ if (!gs_app_is_updatable (app))
+ return TRUE;
+
+ /* find out which releases are already installed */
+ xpath = g_strdup_printf ("component/id[text()='%s']/../releases/*[@version]",
+ gs_app_get_id (app));
+ releases_inst = xb_silo_query (silo, xpath, 0, &error_local);
+ if (releases_inst == NULL) {
+ if (!g_error_matches (error_local, G_IO_ERROR, G_IO_ERROR_NOT_FOUND)) {
+ g_propagate_error (error, g_steal_pointer (&error_local));
+ return FALSE;
+ }
+ } else {
+ for (guint i = 0; i < releases_inst->len; i++) {
+ XbNode *release = g_ptr_array_index (releases_inst, i);
+ g_hash_table_insert (installed,
+ (gpointer) xb_node_get_attr (release, "version"),
+ (gpointer) release);
+ }
+ }
+ g_clear_error (&error_local);
+
+ /* get all components */
+ releases = xb_node_query (component, "releases/*", 0, &error_local);
+ if (releases == NULL) {
+ if (g_error_matches (error_local, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
+ return TRUE;
+ g_propagate_error (error, g_steal_pointer (&error_local));
+ return FALSE;
+ }
+ for (guint i = 0; i < releases->len; i++) {
+ XbNode *release = g_ptr_array_index (releases, i);
+ const gchar *version = xb_node_get_attr (release, "version");
+ g_autoptr(XbNode) description = NULL;
+ AsUrgencyKind urgency_tmp;
+
+ /* ignore releases with no version */
+ if (version == NULL)
+ continue;
+
+ /* already installed */
+ if (g_hash_table_lookup (installed, version) != NULL)
+ continue;
+
+ /* limit this to three versions backwards if there has never
+ * been a detected installed version */
+ if (g_hash_table_size (installed) == 0 && i >= 3)
+ break;
+
+ /* use the 'worst' urgency, e.g. critical over enhancement */
+ urgency_tmp = as_urgency_kind_from_string (xb_node_get_attr (release, "urgency"));
+ if (urgency_tmp > urgency_best)
+ urgency_best = urgency_tmp;
+
+ /* add updates with a description */
+ description = xb_node_query_first (release, "description", NULL);
+ if (description == NULL)
+ continue;
+ g_ptr_array_add (updates_list, release);
+ }
+
+ /* only set if known */
+ if (urgency_best != AS_URGENCY_KIND_UNKNOWN)
+ gs_app_set_update_urgency (app, urgency_best);
+
+ /* no prefix on each release */
+ if (updates_list->len == 1) {
+ XbNode *release = g_ptr_array_index (updates_list, 0);
+ g_autoptr(XbNode) n = NULL;
+ g_autofree gchar *desc = NULL;
+ n = xb_node_query_first (release, "description", NULL);
+ desc = gs_appstream_format_description (n, NULL);
+ gs_app_set_update_details_markup (app, desc);
+
+ /* get the descriptions with a version prefix */
+ } else if (updates_list->len > 1) {
+ const gchar *version = gs_app_get_version (app);
+ g_autoptr(GString) update_desc = g_string_new ("");
+ for (guint i = 0; i < updates_list->len; i++) {
+ XbNode *release = g_ptr_array_index (updates_list, i);
+ const gchar *release_version = xb_node_get_attr (release, "version");
+ g_autofree gchar *desc = NULL;
+ g_autoptr(XbNode) n = NULL;
+
+ /* skip the currently installed version and all below it */
+ if (version != NULL && as_vercmp_simple (version, release_version) >= 0)
+ continue;
+
+ n = xb_node_query_first (release, "description", NULL);
+ desc = gs_appstream_format_description (n, NULL);
+ g_string_append_printf (update_desc,
+ "Version %s:\n%s\n\n",
+ xb_node_get_attr (release, "version"),
+ desc);
+ }
+
+ /* remove trailing newlines */
+ if (update_desc->len > 2)
+ g_string_truncate (update_desc, update_desc->len - 2);
+ if (update_desc->len > 0)
+ gs_app_set_update_details_markup (app, update_desc->str);
+ }
+
+ /* if there is no already set update version use the newest */
+ if (gs_app_get_update_version (app) == NULL &&
+ updates_list->len > 0) {
+ XbNode *release = g_ptr_array_index (updates_list, 0);
+ gs_app_set_update_version (app, xb_node_get_attr (release, "version"));
+ }
+
+ /* success */
+ return TRUE;
+}
+
+static gboolean
+gs_appstream_refine_add_version_history (GsApp *app, XbNode *component, GError **error)
+{
+ g_autoptr(GError) error_local = NULL;
+ g_autoptr(GPtrArray) version_history = NULL; /* (element-type AsRelease) */
+ g_autoptr(GPtrArray) releases = NULL; /* (element-type XbNode) */
+
+ /* get all components */
+ releases = xb_node_query (component, "releases/*", 0, &error_local);
+ if (releases == NULL) {
+ if (g_error_matches (error_local, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
+ return TRUE;
+ g_propagate_error (error, g_steal_pointer (&error_local));
+ return FALSE;
+ }
+
+ version_history = g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref);
+ for (guint i = 0; i < releases->len; i++) {
+ XbNode *release_node = g_ptr_array_index (releases, i);
+ const gchar *version = xb_node_get_attr (release_node, "version");
+ g_autoptr(XbNode) description_node = NULL;
+ g_autofree gchar *description = NULL;
+ guint64 timestamp;
+ const gchar *date_str;
+ g_autoptr(AsRelease) release = NULL;
+ g_autofree char *timestamp_xpath = NULL;
+
+ /* ignore releases with no version */
+ if (version == NULL)
+ continue;
+
+ timestamp_xpath = g_strdup_printf ("releases/release[%u]", i+1);
+ timestamp = xb_node_query_attr_as_uint (component, timestamp_xpath, "timestamp", NULL);
+ date_str = xb_node_query_attr (component, timestamp_xpath, "date", NULL);
+
+ /* include updates with or without a description */
+ description_node = xb_node_query_first (release_node, "description", NULL);
+ if (description_node != NULL)
+ description = gs_appstream_format_description (description_node, NULL);
+
+ release = as_release_new ();
+ as_release_set_version (release, version);
+ if (timestamp != G_MAXUINT64)
+ as_release_set_timestamp (release, timestamp);
+ else if (date_str != NULL) /* timestamp takes precedence over date */
+ as_release_set_date (release, date_str);
+ if (description != NULL)
+ as_release_set_description (release, description, NULL);
+
+ g_ptr_array_add (version_history, g_steal_pointer (&release));
+ }
+
+ if (version_history->len > 0)
+ gs_app_set_version_history (app, version_history);
+
+ /* success */
+ return TRUE;
+}
+
+/**
+ * _gs_utils_locale_has_translations:
+ * @locale: A locale, e.g. `en_GB` or `uz_UZ.utf8@cyrillic`
+ *
+ * Looks up if the locale is likely to have translations.
+ *
+ * Returns: %TRUE if the locale should have translations
+ **/
+static gboolean
+_gs_utils_locale_has_translations (const gchar *locale)
+{
+ g_autofree gchar *locale_copy = g_strdup (locale);
+ gchar *separator;
+
+ /* Strip off the territory, codeset and modifier, if present. */
+ separator = strpbrk (locale_copy, "_.@");
+ if (separator != NULL)
+ *separator = '\0';
+
+ if (g_strcmp0 (locale_copy, "C") == 0)
+ return FALSE;
+ if (g_strcmp0 (locale_copy, "en") == 0)
+ return FALSE;
+ return TRUE;
+}
+
+static gboolean
+gs_appstream_origin_valid (const gchar *origin)
+{
+ if (origin == NULL)
+ return FALSE;
+ if (g_strcmp0 (origin, "") == 0)
+ return FALSE;
+ return TRUE;
+}
+
+static gboolean
+gs_appstream_is_valid_project_group (const gchar *project_group)
+{
+ if (project_group == NULL)
+ return FALSE;
+ return as_utils_is_desktop_environment (project_group);
+}
+
+static gboolean
+gs_appstream_refine_app_content_rating (GsApp *app,
+ XbNode *content_rating,
+ GError **error)
+{
+ g_autoptr(AsContentRating) cr = as_content_rating_new ();
+ g_autoptr(GError) error_local = NULL;
+ g_autoptr(GPtrArray) content_attributes = NULL;
+ const gchar *content_rating_kind = NULL;
+
+ /* get kind */
+ content_rating_kind = xb_node_get_attr (content_rating, "type");
+ /* we only really expect/support OARS 1.0 and 1.1 */
+ if (content_rating_kind == NULL ||
+ (g_strcmp0 (content_rating_kind, "oars-1.0") != 0 &&
+ g_strcmp0 (content_rating_kind, "oars-1.1") != 0)) {
+ return TRUE;
+ }
+
+ as_content_rating_set_kind (cr, content_rating_kind);
+
+ /* get attributes; no attributes being found (i.e.
+ * `<content_rating type="*"/>`) is OK: it means that all attributes have
+ * value `none`, as per the
+ * [OARS semantics](https://github.com/hughsie/oars/blob/HEAD/specification/oars-1.1.md) */
+ content_attributes = xb_node_query (content_rating, "content_attribute", 0, &error_local);
+ if (content_attributes == NULL &&
+ g_error_matches (error_local, G_IO_ERROR, G_IO_ERROR_NOT_FOUND)) {
+ g_clear_error (&error_local);
+ } else if (content_attributes == NULL) {
+ g_propagate_error (error, g_steal_pointer (&error_local));
+ return FALSE;
+ }
+
+ for (guint i = 0; content_attributes != NULL && i < content_attributes->len; i++) {
+ XbNode *content_attribute = g_ptr_array_index (content_attributes, i);
+ as_content_rating_add_attribute (cr,
+ xb_node_get_attr (content_attribute, "id"),
+ as_content_rating_value_from_string (xb_node_get_text (content_attribute)));
+ }
+
+ gs_app_set_content_rating (app, cr);
+ return TRUE;
+}
+
+static gboolean
+gs_appstream_refine_app_content_ratings (GsApp *app,
+ XbNode *component,
+ GError **error)
+{
+ g_autoptr(GPtrArray) content_ratings = NULL;
+ g_autoptr(GError) error_local = NULL;
+
+ /* find any content ratings */
+ content_ratings = xb_node_query (component, "content_rating", 0, &error_local);
+ if (content_ratings == NULL) {
+ if (g_error_matches (error_local, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
+ return TRUE;
+ g_propagate_error (error, g_steal_pointer (&error_local));
+ return FALSE;
+ }
+ for (guint i = 0; i < content_ratings->len; i++) {
+ XbNode *content_rating = g_ptr_array_index (content_ratings, i);
+ if (!gs_appstream_refine_app_content_rating (app, content_rating, error))
+ return FALSE;
+ }
+ return TRUE;
+}
+
+static gboolean
+gs_appstream_refine_app_relation (GsApp *app,
+ XbNode *relation_node,
+ AsRelationKind kind,
+ GError **error)
+{
+ /* Iterate over the children, which might be any combination of zero or
+ * more <id/>, <modalias/>, <kernel/>, <memory/>, <firmware/>,
+ * <control/> or <display_length/> elements. For the moment, we only
+ * support some of these. */
+ for (g_autoptr(XbNode) child = xb_node_get_child (relation_node); child != NULL; node_set_to_next (&child)) {
+ const gchar *item_kind = xb_node_get_element (child);
+ g_autoptr(AsRelation) relation = as_relation_new ();
+
+ as_relation_set_kind (relation, kind);
+
+ if (g_str_equal (item_kind, "control")) {
+ /* https://www.freedesktop.org/software/appstream/docs/chap-Metadata.html#tag-relations-control */
+ as_relation_set_item_kind (relation, AS_RELATION_ITEM_KIND_CONTROL);
+ as_relation_set_value_control_kind (relation, as_control_kind_from_string (xb_node_get_text (child)));
+ } else if (g_str_equal (item_kind, "display_length")) {
+ AsDisplayLengthKind display_length_kind;
+ const gchar *compare;
+
+ /* https://www.freedesktop.org/software/appstream/docs/chap-Metadata.html#tag-relations-display_length */
+ as_relation_set_item_kind (relation, AS_RELATION_ITEM_KIND_DISPLAY_LENGTH);
+
+ compare = xb_node_get_attr (child, "compare");
+ as_relation_set_compare (relation, (compare != NULL) ? as_relation_compare_from_string (compare) : AS_RELATION_COMPARE_GE);
+
+ display_length_kind = as_display_length_kind_from_string (xb_node_get_text (child));
+ if (display_length_kind != AS_DISPLAY_LENGTH_KIND_UNKNOWN) {
+ /* Ignore the `side` attribute */
+ as_relation_set_value_display_length_kind (relation, display_length_kind);
+ } else {
+ const gchar *side = xb_node_get_attr (child, "side");
+ as_relation_set_display_side_kind (relation, (side != NULL) ? as_display_side_kind_from_string (side) : AS_DISPLAY_SIDE_KIND_SHORTEST);
+ as_relation_set_value_px (relation, xb_node_get_text_as_uint (child));
+ }
+ } else {
+ g_debug ("Relation type ‘%s’ not currently supported for %s; ignoring",
+ item_kind, gs_app_get_id (app));
+ continue;
+ }
+
+ gs_app_add_relation (app, relation);
+ }
+
+ return TRUE;
+}
+
+static gboolean
+gs_appstream_refine_app_relations (GsApp *app,
+ XbNode *component,
+ GError **error)
+{
+ const struct {
+ const gchar *element_name;
+ AsRelationKind relation_kind;
+ } relation_types[] = {
+#if AS_CHECK_VERSION(0, 15, 0)
+ { "supports", AS_RELATION_KIND_SUPPORTS },
+#endif
+ { "recommends", AS_RELATION_KIND_RECOMMENDS },
+ { "requires", AS_RELATION_KIND_REQUIRES },
+ };
+
+ for (gsize i = 0; i < G_N_ELEMENTS (relation_types); i++) {
+ g_autoptr(GPtrArray) relations = NULL;
+ g_autoptr(GError) error_local = NULL;
+
+ /* find any instances of this @element_name */
+ relations = xb_node_query (component, relation_types[i].element_name, 0, &error_local);
+ if (relations == NULL &&
+ !g_error_matches (error_local, G_IO_ERROR, G_IO_ERROR_NOT_FOUND)) {
+ g_propagate_error (error, g_steal_pointer (&error_local));
+ return FALSE;
+ }
+
+ for (guint j = 0; relations != NULL && j < relations->len; j++) {
+ XbNode *relation = g_ptr_array_index (relations, j);
+ if (!gs_appstream_refine_app_relation (app, relation, relation_types[i].relation_kind, error))
+ return FALSE;
+ }
+ }
+
+ return TRUE;
+}
+
+gboolean
+gs_appstream_refine_app (GsPlugin *plugin,
+ GsApp *app,
+ XbSilo *silo,
+ XbNode *component,
+ GsPluginRefineFlags refine_flags,
+ GError **error)
+{
+ const gchar *tmp;
+ guint64 timestamp;
+ g_autoptr(GPtrArray) bundles = NULL;
+ g_autoptr(GPtrArray) launchables = NULL;
+ g_autoptr(XbNode) req = NULL;
+
+ /* The 'plugin' can be NULL, when creating app for --show-metainfo */
+ g_return_val_if_fail (GS_IS_APP (app), FALSE);
+ g_return_val_if_fail (XB_IS_SILO (silo), FALSE);
+ g_return_val_if_fail (XB_IS_NODE (component), FALSE);
+
+ /* is compatible */
+ req = xb_node_query_first (component,
+ "requires/id[@type='id']"
+ "[text()='org.gnome.Software.desktop']", NULL);
+ if (req != NULL) {
+ gint rc = as_vercmp_simple (xb_node_get_attr (req, "version"),
+ PACKAGE_VERSION);
+ if (rc > 0) {
+ g_set_error (error,
+ GS_PLUGIN_ERROR,
+ GS_PLUGIN_ERROR_NOT_SUPPORTED,
+ "not for this gnome-software");
+ return FALSE;
+ }
+ }
+
+ /* set id kind */
+ if (gs_app_get_kind (app) == AS_COMPONENT_KIND_UNKNOWN ||
+ gs_app_get_kind (app) == AS_COMPONENT_KIND_GENERIC) {
+ AsComponentKind kind;
+ tmp = xb_node_get_attr (component, "type");
+ kind = as_component_kind_from_string (tmp);
+ if (kind != AS_COMPONENT_KIND_UNKNOWN)
+ gs_app_set_kind (app, kind);
+ }
+
+ /* types we can never launch */
+ switch (gs_app_get_kind (app)) {
+ case AS_COMPONENT_KIND_ADDON:
+ case AS_COMPONENT_KIND_CODEC:
+ case AS_COMPONENT_KIND_DRIVER:
+ case AS_COMPONENT_KIND_FIRMWARE:
+ case AS_COMPONENT_KIND_FONT:
+ case AS_COMPONENT_KIND_GENERIC:
+ case AS_COMPONENT_KIND_INPUT_METHOD:
+ case AS_COMPONENT_KIND_LOCALIZATION:
+ case AS_COMPONENT_KIND_OPERATING_SYSTEM:
+ case AS_COMPONENT_KIND_RUNTIME:
+ case AS_COMPONENT_KIND_REPOSITORY:
+ gs_app_add_quirk (app, GS_APP_QUIRK_NOT_LAUNCHABLE);
+ break;
+ default:
+ break;
+ }
+
+ /* check if the special metadata affects the not-launchable quirk */
+ tmp = gs_app_get_metadata_item (app, "GnomeSoftware::quirks::not-launchable");
+ if (tmp != NULL) {
+ if (g_strcmp0 (tmp, "true") == 0)
+ gs_app_add_quirk (app, GS_APP_QUIRK_NOT_LAUNCHABLE);
+ else if (g_strcmp0 (tmp, "false") == 0)
+ gs_app_remove_quirk (app, GS_APP_QUIRK_NOT_LAUNCHABLE);
+ }
+
+ tmp = gs_app_get_metadata_item (app, "GnomeSoftware::quirks::hide-everywhere");
+ if (tmp != NULL) {
+ if (g_strcmp0 (tmp, "true") == 0)
+ gs_app_add_quirk (app, GS_APP_QUIRK_HIDE_EVERYWHERE);
+ else if (g_strcmp0 (tmp, "false") == 0)
+ gs_app_remove_quirk (app, GS_APP_QUIRK_HIDE_EVERYWHERE);
+ }
+
+ /* try to detect old-style AppStream 'override'
+ * files without the merge attribute */
+ if (xb_node_query_text (component, "name", NULL) == NULL &&
+ xb_node_query_text (component, "metadata_license", NULL) == NULL) {
+ gs_app_add_quirk (app, GS_APP_QUIRK_IS_WILDCARD);
+ }
+
+ /* set id */
+ tmp = xb_node_query_text (component, "id", NULL);
+ if (tmp != NULL && gs_app_get_id (app) == NULL)
+ gs_app_set_id (app, tmp);
+
+ /* set source */
+ tmp = xb_node_query_text (component, "info/filename", NULL);
+ if (tmp == NULL)
+ tmp = xb_node_query_text (component, "../info/filename", NULL);
+ if (tmp != NULL && gs_app_get_metadata_item (app, "appstream::source-file") == NULL) {
+ gs_app_set_metadata (app, "appstream::source-file", tmp);
+ }
+
+ /* set scope */
+ tmp = xb_node_query_text (component, "../info/scope", NULL);
+ if (tmp != NULL)
+ gs_app_set_scope (app, as_component_scope_from_string (tmp));
+
+ /* set content rating */
+ if (TRUE) {
+ if (!gs_appstream_refine_app_content_ratings (app, component, error))
+ return FALSE;
+ }
+
+ /* recommends/requires
+ * FIXME: Technically this could do with a more specific refine flag,
+ * but essentially the relations are used on the details page and so
+ * are the permissions. It would be good to eliminate refine flags at
+ * some point in the future. */
+ if (refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_PERMISSIONS) {
+ if (!gs_appstream_refine_app_relations (app, component, error))
+ return FALSE;
+ }
+
+ /* set name */
+ tmp = xb_node_query_text (component, "name", NULL);
+ if (tmp != NULL)
+ gs_app_set_name (app, GS_APP_QUALITY_HIGHEST, tmp);
+
+ /* set summary */
+ tmp = xb_node_query_text (component, "summary", NULL);
+ if (tmp != NULL)
+ gs_app_set_summary (app, GS_APP_QUALITY_HIGHEST, tmp);
+
+ /* add urls */
+ if (refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_URL) {
+ g_autoptr(GPtrArray) urls = NULL;
+ urls = xb_node_query (component, "url", 0, NULL);
+ if (urls != NULL) {
+ for (guint i = 0; i < urls->len; i++) {
+ XbNode *url = g_ptr_array_index (urls, i);
+ const gchar *kind = xb_node_get_attr (url, "type");
+ if (kind == NULL)
+ continue;
+ gs_app_set_url (app,
+ as_url_kind_from_string (kind),
+ xb_node_get_text (url));
+ }
+ }
+ }
+
+ /* add launchables */
+ launchables = xb_node_query (component, "launchable", 0, NULL);
+ if (launchables != NULL) {
+ for (guint i = 0; i < launchables->len; i++) {
+ XbNode *launchable = g_ptr_array_index (launchables, i);
+ const gchar *kind = xb_node_get_attr (launchable, "type");
+ if (g_strcmp0 (kind, "desktop-id") == 0) {
+ gs_app_set_launchable (app,
+ AS_LAUNCHABLE_KIND_DESKTOP_ID,
+ xb_node_get_text (launchable));
+ break;
+ } else if (g_strcmp0 (kind, "url") == 0) {
+ gs_app_set_launchable (app,
+ AS_LAUNCHABLE_KIND_URL,
+ xb_node_get_text (launchable));
+ }
+ }
+ }
+
+ /* set license */
+ if ((refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_LICENSE) > 0 &&
+ gs_app_get_license (app) == NULL) {
+ tmp = xb_node_query_text (component, "project_license", NULL);
+ if (tmp != NULL)
+ gs_app_set_license (app, GS_APP_QUALITY_HIGHEST, tmp);
+ }
+
+ /* set description */
+ if (refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_DESCRIPTION) {
+ g_autofree gchar *description = NULL;
+ g_autoptr(XbNode) n = xb_node_query_first (component, "description", NULL);
+ if (n != NULL)
+ description = gs_appstream_format_description (n, NULL);
+ if (description != NULL)
+ gs_app_set_description (app, GS_APP_QUALITY_HIGHEST, description);
+ }
+
+ /* set icon */
+ if ((refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_ICON) > 0 &&
+ gs_app_get_icons (app) == NULL)
+ gs_appstream_refine_icon (app, silo, component);
+
+ /* set categories */
+ if (refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_CATEGORIES) {
+ g_autoptr(GPtrArray) categories = NULL;
+ categories = xb_node_query (component, "categories/category", 0, NULL);
+ if (categories != NULL) {
+ for (guint i = 0; i < categories->len; i++) {
+ XbNode *category = g_ptr_array_index (categories, i);
+ gs_app_add_category (app, xb_node_get_text (category));
+
+ /* Special case: We used to use the `Blacklisted`
+ * category to hide apps from their .desktop
+ * file or appdata. We now use a quirk for that.
+ * This special case can be removed when all
+ * appstream files no longer use the `Blacklisted`
+ * category (including external-appstream files
+ * put together by distributions). */
+ if (g_strcmp0 (xb_node_get_text (category), "Blacklisted") == 0)
+ gs_app_add_quirk (app, GS_APP_QUIRK_HIDE_EVERYWHERE);
+ }
+ }
+ }
+
+ /* set project group */
+ if ((refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_PROJECT_GROUP) > 0 &&
+ gs_app_get_project_group (app) == NULL) {
+ tmp = xb_node_query_text (component, "project_group", NULL);
+ if (tmp != NULL && gs_appstream_is_valid_project_group (tmp))
+ gs_app_set_project_group (app, tmp);
+ }
+
+ /* set developer name */
+ if ((refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_DEVELOPER_NAME) > 0 &&
+ gs_app_get_developer_name (app) == NULL) {
+ tmp = xb_node_query_text (component, "developer_name", NULL);
+ if (tmp != NULL)
+ gs_app_set_developer_name (app, tmp);
+ }
+
+ /* set the release date */
+ timestamp = component_get_release_timestamp (component);
+ if (timestamp != G_MAXUINT64)
+ gs_app_set_release_date (app, timestamp);
+
+ /* set the version history */
+ if (!gs_appstream_refine_add_version_history (app, component, error))
+ return FALSE;
+
+ /* copy all the metadata */
+ if (!gs_appstream_copy_metadata (app, component, error))
+ return FALSE;
+
+ /* add bundles */
+ bundles = xb_node_query (component, "bundle", 0, NULL);
+ if (bundles != NULL && gs_app_get_sources(app)->len == 0) {
+ for (guint i = 0; i < bundles->len; i++) {
+ XbNode *bundle = g_ptr_array_index (bundles, i);
+ const gchar *kind = xb_node_get_attr (bundle, "type");
+ const gchar *bundle_id = xb_node_get_text (bundle);
+
+ if (bundle_id == NULL || kind == NULL)
+ continue;
+
+ gs_app_add_source (app, bundle_id);
+ gs_app_set_bundle_kind (app, as_bundle_kind_from_string (kind));
+
+ /* get the type/name/arch/branch */
+ if (gs_app_get_bundle_kind (app) == AS_BUNDLE_KIND_FLATPAK) {
+ g_auto(GStrv) split = g_strsplit (bundle_id, "/", -1);
+ if (g_strv_length (split) != 4) {
+ g_set_error (error,
+ GS_PLUGIN_ERROR,
+ GS_PLUGIN_ERROR_NOT_SUPPORTED,
+ "invalid ID %s for a flatpak ref",
+ bundle_id);
+ return FALSE;
+ }
+
+ /* we only need the branch for the unique ID */
+ gs_app_set_branch (app, split[3]);
+ }
+ }
+ }
+
+ /* add legacy package names */
+ if (gs_app_get_bundle_kind (app) == AS_BUNDLE_KIND_UNKNOWN) {
+ g_autoptr(GPtrArray) pkgnames = NULL;
+ pkgnames = xb_node_query (component, "pkgname", 0, NULL);
+ if (pkgnames != NULL && gs_app_get_sources(app)->len == 0) {
+ for (guint i = 0; i < pkgnames->len; i++) {
+ XbNode *pkgname = g_ptr_array_index (pkgnames, i);
+ tmp = xb_node_get_text (pkgname);
+ if (tmp != NULL && tmp[0] != '\0')
+ gs_app_add_source (app, tmp);
+ }
+ gs_app_set_bundle_kind (app, AS_BUNDLE_KIND_PACKAGE);
+ }
+ }
+
+ /* set origin */
+ tmp = xb_node_query_attr (component, "..", "origin", NULL);
+ if (gs_appstream_origin_valid (tmp)) {
+ gs_app_set_origin_appstream (app, tmp);
+
+ if (gs_app_get_origin (app) == NULL && (
+ gs_app_get_bundle_kind (app) == AS_BUNDLE_KIND_FLATPAK ||
+ gs_app_get_bundle_kind (app) == AS_BUNDLE_KIND_PACKAGE)) {
+ gs_app_set_origin (app, tmp);
+ }
+ }
+
+ /* set addons */
+ if ((refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_ADDONS) != 0 &&
+ plugin != NULL && silo != NULL) {
+ if (!gs_appstream_refine_add_addons (plugin, app, silo, error))
+ return FALSE;
+ }
+
+ /* set screenshots */
+ if ((refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_SCREENSHOTS) > 0 &&
+ gs_app_get_screenshots(app)->len == 0) {
+ if (!gs_appstream_refine_add_screenshots (app, component, error))
+ return FALSE;
+ }
+
+ /* set provides */
+ if (!gs_appstream_refine_add_provides (app, component, error))
+ return FALSE;
+
+ /* add kudos */
+ if (refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_KUDOS) {
+ g_autoptr(GPtrArray) kudos = NULL;
+ tmp = setlocale (LC_MESSAGES, NULL);
+ if (!_gs_utils_locale_has_translations (tmp)) {
+ gs_app_add_kudo (app, GS_APP_KUDO_MY_LANGUAGE);
+ } else {
+
+ g_autoptr(GString) xpath = g_string_new (NULL);
+ g_auto(GStrv) variants = g_get_locale_variants (tmp);
+
+ /* @variants includes @tmp */
+ for (gsize i = 0; variants[i] != NULL; i++)
+ xb_string_append_union (xpath, "languages/lang[(text()='%s') and (@percentage>50)]", variants[i]);
+
+ if (xb_node_query_text (component, xpath->str, NULL) != NULL)
+ gs_app_add_kudo (app, GS_APP_KUDO_MY_LANGUAGE);
+ }
+
+ /* Set this under the FLAGS_REQUIRE_KUDOS flag because it’s
+ * only useful in combination with KUDO_MY_LANGUAGE */
+ if (xb_node_query_text (component, "languages/lang", NULL) != NULL)
+ gs_app_set_has_translations (app, TRUE);
+
+ /* any keywords */
+ if (xb_node_query_text (component, "keywords/keyword", NULL) != NULL)
+ gs_app_add_kudo (app, GS_APP_KUDO_HAS_KEYWORDS);
+
+ /* HiDPI icon */
+ if (xb_node_query_text (component, "icon[@width='128']", NULL) != NULL)
+ gs_app_add_kudo (app, GS_APP_KUDO_HI_DPI_ICON);
+
+ /* was this application released recently */
+ if (gs_appstream_is_recent_release (component))
+ gs_app_add_kudo (app, GS_APP_KUDO_RECENT_RELEASE);
+
+ /* add a kudo to featured and popular apps */
+ if (xb_node_query_text (component, "kudos/kudo[text()='GnomeSoftware::popular']", NULL) != NULL)
+ gs_app_add_kudo (app, GS_APP_KUDO_FEATURED_RECOMMENDED);
+ if (xb_node_query_text (component, "categories/category[text()='Featured']", NULL) != NULL)
+ gs_app_add_kudo (app, GS_APP_KUDO_FEATURED_RECOMMENDED);
+ }
+
+ /* we have an origin in the XML */
+ if ((refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_ORIGIN) > 0 &&
+ gs_app_get_origin_appstream (app) == NULL) {
+ g_autoptr(XbNode) parent = xb_node_get_parent (component);
+ if (parent != NULL) {
+ tmp = xb_node_get_attr (parent, "origin");
+ if (gs_appstream_origin_valid (tmp))
+ gs_app_set_origin_appstream (app, tmp);
+ }
+ }
+
+ /* is there any update information */
+ if ((refine_flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_UPDATE_DETAILS) != 0 &&
+ silo != NULL) {
+ if (!gs_appstream_refine_app_updates (app,
+ silo,
+ component,
+ error))
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+typedef struct {
+ AsSearchTokenMatch match_value;
+ XbQuery *query;
+} GsAppstreamSearchHelper;
+
+static void
+gs_appstream_search_helper_free (GsAppstreamSearchHelper *helper)
+{
+ g_object_unref (helper->query);
+ g_free (helper);
+}
+
+static guint16
+gs_appstream_silo_search_component2 (GPtrArray *array, XbNode *component, const gchar *search)
+{
+ guint16 match_value = 0;
+
+ /* do searches */
+ for (guint i = 0; i < array->len; i++) {
+ g_autoptr(GPtrArray) n = NULL;
+ GsAppstreamSearchHelper *helper = g_ptr_array_index (array, i);
+#if LIBXMLB_CHECK_VERSION(0, 3, 0)
+ g_auto(XbQueryContext) context = XB_QUERY_CONTEXT_INIT ();
+ xb_value_bindings_bind_str (xb_query_context_get_bindings (&context), 0, search, NULL);
+ n = xb_node_query_with_context (component, helper->query, &context, NULL);
+#else
+ xb_query_bind_str (helper->query, 0, search, NULL);
+ n = xb_node_query_full (component, helper->query, NULL);
+#endif
+ if (n != NULL)
+ match_value |= helper->match_value;
+ }
+ return match_value;
+}
+
+static guint16
+gs_appstream_silo_search_component (GPtrArray *array, XbNode *component, const gchar * const *search)
+{
+ guint16 matches_sum = 0;
+
+ /* do *all* search keywords match */
+ for (guint i = 0; search[i] != NULL; i++) {
+ guint tmp = gs_appstream_silo_search_component2 (array, component, search[i]);
+ if (tmp == 0)
+ return 0;
+ matches_sum |= tmp;
+ }
+ return matches_sum;
+}
+
+typedef struct {
+ AsSearchTokenMatch match_value;
+ const gchar *xpath;
+} Query;
+
+static gboolean
+gs_appstream_do_search (GsPlugin *plugin,
+ XbSilo *silo,
+ const gchar * const *values,
+ const Query queries[],
+ GsAppList *list,
+ GCancellable *cancellable,
+ GError **error)
+{
+ g_autoptr(GError) error_local = NULL;
+ g_autoptr(GPtrArray) array = g_ptr_array_new_with_free_func ((GDestroyNotify) gs_appstream_search_helper_free);
+ g_autoptr(GPtrArray) components = NULL;
+ g_autoptr(GTimer) timer = g_timer_new ();
+
+ g_return_val_if_fail (GS_IS_PLUGIN (plugin), FALSE);
+ g_return_val_if_fail (XB_IS_SILO (silo), FALSE);
+ g_return_val_if_fail (values != NULL, FALSE);
+ g_return_val_if_fail (GS_IS_APP_LIST (list), FALSE);
+
+ /* add some weighted queries */
+ for (guint i = 0; queries[i].xpath != NULL; i++) {
+ g_autoptr(GError) error_query = NULL;
+ g_autoptr(XbQuery) query = xb_query_new (silo, queries[i].xpath, &error_query);
+ if (query != NULL) {
+ GsAppstreamSearchHelper *helper = g_new0 (GsAppstreamSearchHelper, 1);
+ helper->match_value = queries[i].match_value;
+ helper->query = g_steal_pointer (&query);
+ g_ptr_array_add (array, helper);
+ } else {
+ g_debug ("ignoring: %s", error_query->message);
+ }
+ }
+
+ /* get all components */
+ components = xb_silo_query (silo, "components/component", 0, &error_local);
+ if (components == NULL) {
+ if (g_error_matches (error_local, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
+ return TRUE;
+ g_propagate_error (error, g_steal_pointer (&error_local));
+ return FALSE;
+ }
+ for (guint i = 0; i < components->len; i++) {
+ XbNode *component = g_ptr_array_index (components, i);
+ guint16 match_value = gs_appstream_silo_search_component (array, component, values);
+ if (match_value != 0) {
+ g_autoptr(GsApp) app = gs_appstream_create_app (plugin, silo, component, error);
+ if (app == NULL)
+ return FALSE;
+ if (gs_app_has_quirk (app, GS_APP_QUIRK_IS_WILDCARD)) {
+ g_debug ("not returning wildcard %s",
+ gs_app_get_unique_id (app));
+ continue;
+ }
+ g_debug ("add %s", gs_app_get_unique_id (app));
+
+ /* The match value is used for prioritising results.
+ * Drop the ID token from it as it’s the highest
+ * numeric value but isn’t visible to the user in the
+ * UI, which leads to confusing results ordering. */
+ gs_app_set_match_value (app, match_value & (~AS_SEARCH_TOKEN_MATCH_ID));
+ gs_app_list_add (list, app);
+
+ if (gs_app_get_kind (app) == AS_COMPONENT_KIND_ADDON) {
+ g_autoptr(GPtrArray) extends = NULL;
+
+ /* add the parent app as a wildcard, to be refined later */
+ extends = xb_node_query (component, "extends", 0, NULL);
+ for (guint jj = 0; extends && jj < extends->len; jj++) {
+ XbNode *extend = g_ptr_array_index (extends, jj);
+ g_autoptr(GsApp) app2 = NULL;
+ const gchar *tmp;
+ app2 = gs_app_new (xb_node_get_text (extend));
+ gs_app_add_quirk (app2, GS_APP_QUIRK_IS_WILDCARD);
+ tmp = xb_node_query_attr (extend, "../..", "origin", NULL);
+ if (gs_appstream_origin_valid (tmp))
+ gs_app_set_origin_appstream (app2, tmp);
+ gs_app_list_add (list, app2);
+ }
+ }
+ }
+
+ if (g_cancellable_set_error_if_cancelled (cancellable, error))
+ return FALSE;
+ }
+ g_debug ("search took %fms", g_timer_elapsed (timer, NULL) * 1000);
+ return TRUE;
+}
+
+/* This tokenises and stems @values internally for comparison against the
+ * already-stemmed tokens in the libxmlb silo */
+gboolean
+gs_appstream_search (GsPlugin *plugin,
+ XbSilo *silo,
+ const gchar * const *values,
+ GsAppList *list,
+ GCancellable *cancellable,
+ GError **error)
+{
+ const Query queries[] = {
+ { AS_SEARCH_TOKEN_MATCH_MIMETYPE, "mimetypes/mimetype[text()~=stem(?)]" },
+ { AS_SEARCH_TOKEN_MATCH_PKGNAME, "pkgname[text()~=stem(?)]" },
+ { AS_SEARCH_TOKEN_MATCH_SUMMARY, "summary[text()~=stem(?)]" },
+ { AS_SEARCH_TOKEN_MATCH_NAME, "name[text()~=stem(?)]" },
+ { AS_SEARCH_TOKEN_MATCH_KEYWORD, "keywords/keyword[text()~=stem(?)]" },
+ { AS_SEARCH_TOKEN_MATCH_ID, "id[text()~=stem(?)]" },
+ { AS_SEARCH_TOKEN_MATCH_ID, "launchable[text()~=stem(?)]" },
+ { AS_SEARCH_TOKEN_MATCH_ORIGIN, "../components[@origin~=stem(?)]" },
+ { AS_SEARCH_TOKEN_MATCH_NONE, NULL }
+ };
+
+ return gs_appstream_do_search (plugin, silo, values, queries, list, cancellable, error);
+}
+
+gboolean
+gs_appstream_search_developer_apps (GsPlugin *plugin,
+ XbSilo *silo,
+ const gchar * const *values,
+ GsAppList *list,
+ GCancellable *cancellable,
+ GError **error)
+{
+ const Query queries[] = {
+ { AS_SEARCH_TOKEN_MATCH_PKGNAME, "developer_name[text()~=stem(?)]" },
+ { AS_SEARCH_TOKEN_MATCH_SUMMARY, "project_group[text()~=stem(?)]" },
+ { AS_SEARCH_TOKEN_MATCH_NONE, NULL }
+ };
+
+ return gs_appstream_do_search (plugin, silo, values, queries, list, cancellable, error);
+}
+
+gboolean
+gs_appstream_add_category_apps (GsPlugin *plugin,
+ XbSilo *silo,
+ GsCategory *category,
+ GsAppList *list,
+ GCancellable *cancellable,
+ GError **error)
+{
+ GPtrArray *desktop_groups;
+
+ g_return_val_if_fail (GS_IS_PLUGIN (plugin), FALSE);
+ g_return_val_if_fail (XB_IS_SILO (silo), FALSE);
+ g_return_val_if_fail (GS_IS_CATEGORY (category), FALSE);
+ g_return_val_if_fail (GS_IS_APP_LIST (list), FALSE);
+
+ desktop_groups = gs_category_get_desktop_groups (category);
+ if (desktop_groups->len == 0) {
+ g_warning ("no desktop_groups for %s", gs_category_get_id (category));
+ return TRUE;
+ }
+ for (guint j = 0; j < desktop_groups->len; j++) {
+ const gchar *desktop_group = g_ptr_array_index (desktop_groups, j);
+ g_autofree gchar *xpath = NULL;
+ g_auto(GStrv) split = g_strsplit (desktop_group, "::", -1);
+ g_autoptr(GPtrArray) components = NULL;
+ g_autoptr(GError) error_local = NULL;
+
+ /* generate query */
+ if (g_strv_length (split) == 1) {
+ xpath = g_strdup_printf ("components/component/categories/"
+ "category[text()='%s']/../..",
+ split[0]);
+ } else if (g_strv_length (split) == 2) {
+ xpath = g_strdup_printf ("components/component/categories/"
+ "category[text()='%s']/../"
+ "category[text()='%s']/../..",
+ split[0], split[1]);
+ }
+ components = xb_silo_query (silo, xpath, 0, &error_local);
+ if (components == NULL) {
+ if (g_error_matches (error_local, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
+ continue;
+ g_propagate_error (error, g_steal_pointer (&error_local));
+ return FALSE;
+ }
+
+ /* create app */
+ for (guint i = 0; i < components->len; i++) {
+ XbNode *component = g_ptr_array_index (components, i);
+ g_autoptr(GsApp) app = NULL;
+ const gchar *id = xb_node_query_text (component, "id", NULL);
+ if (id == NULL)
+ continue;
+ app = gs_app_new (id);
+ gs_app_set_metadata (app, "GnomeSoftware::Creator",
+ gs_plugin_get_name (plugin));
+ gs_app_add_quirk (app, GS_APP_QUIRK_IS_WILDCARD);
+ gs_app_list_add (list, app);
+ }
+
+ }
+ return TRUE;
+}
+
+static guint
+gs_appstream_count_component_for_groups (XbSilo *silo,
+ const gchar *desktop_group)
+{
+ guint limit = 10;
+ g_autofree gchar *xpath = NULL;
+ g_auto(GStrv) split = g_strsplit (desktop_group, "::", -1);
+ g_autoptr(GPtrArray) array = NULL;
+ g_autoptr(GError) error_local = NULL;
+
+ if (g_strv_length (split) == 1) { /* "all" group for a parent category */
+ xpath = g_strdup_printf ("components/component/categories/"
+ "category[text()='%s']/../..",
+ split[0]);
+ } else if (g_strv_length (split) == 2) {
+ xpath = g_strdup_printf ("components/component/categories/"
+ "category[text()='%s']/../"
+ "category[text()='%s']/../..",
+ split[0], split[1]);
+ } else {
+ return 0;
+ }
+
+ array = xb_silo_query (silo, xpath, limit, &error_local);
+ if (array == NULL) {
+ if (g_error_matches (error_local, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
+ return 0;
+ g_warning ("%s", error_local->message);
+ return 0;
+ }
+ return array->len;
+}
+
+/* we're not actually adding categories here, we're just setting the number of
+ * applications available in each category */
+gboolean
+gs_appstream_refine_category_sizes (XbSilo *silo,
+ GPtrArray *list,
+ GCancellable *cancellable,
+ GError **error)
+{
+ g_return_val_if_fail (XB_IS_SILO (silo), FALSE);
+ g_return_val_if_fail (list != NULL, FALSE);
+
+ for (guint j = 0; j < list->len; j++) {
+ GsCategory *parent = GS_CATEGORY (g_ptr_array_index (list, j));
+ GPtrArray *children = gs_category_get_children (parent);
+
+ for (guint i = 0; i < children->len; i++) {
+ GsCategory *cat = g_ptr_array_index (children, i);
+ GPtrArray *groups = gs_category_get_desktop_groups (cat);
+ for (guint k = 0; k < groups->len; k++) {
+ const gchar *group = g_ptr_array_index (groups, k);
+ guint cnt = gs_appstream_count_component_for_groups (silo, group);
+ if (cnt > 0) {
+ gs_category_increment_size (parent, cnt);
+ if (children->len > 1) {
+ /* Parent category has multiple groups, so increment
+ * each group's size too */
+ gs_category_increment_size (cat, cnt);
+ }
+ }
+ }
+ }
+ continue;
+ }
+ return TRUE;
+}
+
+gboolean
+gs_appstream_add_installed (GsPlugin *plugin,
+ XbSilo *silo,
+ GsAppList *list,
+ GCancellable *cancellable,
+ GError **error)
+{
+ g_autoptr(GPtrArray) components = NULL;
+ g_autoptr(GError) local_error = NULL;
+
+ g_return_val_if_fail (GS_IS_PLUGIN (plugin), FALSE);
+ g_return_val_if_fail (XB_IS_SILO (silo), FALSE);
+ g_return_val_if_fail (GS_IS_APP_LIST (list), FALSE);
+
+ /* get all installed appdata files (notice no 'components/' prefix...) */
+ components = xb_silo_query (silo, "component/description/..", 0, NULL);
+ if (components == NULL)
+ return TRUE;
+
+ for (guint i = 0; i < components->len; i++) {
+ XbNode *component = g_ptr_array_index (components, i);
+ g_autoptr(GsApp) app = gs_appstream_create_app (plugin, silo, component, error);
+ if (app == NULL)
+ return FALSE;
+
+ /* Can get cached GsApp, which has the state already updated */
+ if (gs_app_get_state (app) != GS_APP_STATE_UPDATABLE &&
+ gs_app_get_state (app) != GS_APP_STATE_UPDATABLE_LIVE)
+ gs_app_set_state (app, GS_APP_STATE_INSTALLED);
+ gs_app_set_scope (app, AS_COMPONENT_SCOPE_SYSTEM);
+ gs_app_list_add (list, app);
+ }
+
+ return TRUE;
+}
+
+gboolean
+gs_appstream_add_popular (XbSilo *silo,
+ GsAppList *list,
+ GCancellable *cancellable,
+ GError **error)
+{
+ g_autoptr(GError) error_local = NULL;
+ g_autoptr(GPtrArray) array = NULL;
+
+ g_return_val_if_fail (XB_IS_SILO (silo), FALSE);
+ g_return_val_if_fail (GS_IS_APP_LIST (list), FALSE);
+
+ /* find out how many packages are in each category */
+ array = xb_silo_query (silo,
+ "components/component/kudos/"
+ "kudo[text()='GnomeSoftware::popular']/../..",
+ 0, &error_local);
+ if (array == NULL) {
+ if (g_error_matches (error_local, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
+ return TRUE;
+ g_propagate_error (error, g_steal_pointer (&error_local));
+ return FALSE;
+ }
+ for (guint i = 0; i < array->len; i++) {
+ g_autoptr(GsApp) app = NULL;
+ XbNode *component = g_ptr_array_index (array, i);
+ const gchar *component_id = xb_node_query_text (component, "id", NULL);
+ if (component_id == NULL)
+ continue;
+ app = gs_app_new (component_id);
+ gs_app_add_quirk (app, GS_APP_QUIRK_IS_WILDCARD);
+ gs_app_list_add (list, app);
+ }
+ return TRUE;
+}
+
+gboolean
+gs_appstream_add_recent (GsPlugin *plugin,
+ XbSilo *silo,
+ GsAppList *list,
+ guint64 age,
+ GCancellable *cancellable,
+ GError **error)
+{
+ guint64 now = (guint64) g_get_real_time () / G_USEC_PER_SEC;
+ g_autofree gchar *xpath = NULL;
+ g_autoptr(GError) error_local = NULL;
+ g_autoptr(GPtrArray) array = NULL;
+
+ g_return_val_if_fail (GS_IS_PLUGIN (plugin), FALSE);
+ g_return_val_if_fail (XB_IS_SILO (silo), FALSE);
+ g_return_val_if_fail (GS_IS_APP_LIST (list), FALSE);
+
+ /* use predicate conditions to the max */
+ xpath = g_strdup_printf ("components/component/releases/"
+ "release[@timestamp>%" G_GUINT64_FORMAT "]/../..",
+ now - age);
+ array = xb_silo_query (silo, xpath, 0, &error_local);
+ if (array == NULL) {
+ if (g_error_matches (error_local, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
+ return TRUE;
+ g_propagate_error (error, g_steal_pointer (&error_local));
+ return FALSE;
+ }
+ for (guint i = 0; i < array->len; i++) {
+ XbNode *component = g_ptr_array_index (array, i);
+ g_autoptr(GsApp) app = gs_appstream_create_app (plugin, silo, component, error);
+ guint64 timestamp;
+ if (app == NULL)
+ return FALSE;
+ /* set the release date */
+ timestamp = component_get_release_timestamp (component);
+ if (timestamp != G_MAXUINT64)
+ gs_app_set_release_date (app, timestamp);
+ gs_app_list_add (list, app);
+ }
+ return TRUE;
+}
+
+gboolean
+gs_appstream_add_alternates (XbSilo *silo,
+ GsApp *app,
+ GsAppList *list,
+ GCancellable *cancellable,
+ GError **error)
+{
+ GPtrArray *sources = gs_app_get_sources (app);
+ g_autoptr(GError) error_local = NULL;
+ g_autoptr(GPtrArray) ids = NULL;
+ g_autoptr(GString) xpath = g_string_new (NULL);
+
+ g_return_val_if_fail (XB_IS_SILO (silo), FALSE);
+ g_return_val_if_fail (GS_IS_APP (app), FALSE);
+ g_return_val_if_fail (GS_IS_APP_LIST (list), FALSE);
+
+ /* probably a package we know nothing about */
+ if (gs_app_get_id (app) == NULL)
+ return TRUE;
+
+ /* actual ID */
+ xb_string_append_union (xpath, "components/component/id[text()='%s']",
+ gs_app_get_id (app));
+
+ /* new ID -> old ID */
+ xb_string_append_union (xpath, "components/component/id[text()='%s']/../provides/id",
+ gs_app_get_id (app));
+
+ /* old ID -> new ID */
+ xb_string_append_union (xpath, "components/component/provides/id[text()='%s']/../../id",
+ gs_app_get_id (app));
+
+ /* find apps that use the same pkgname */
+ for (guint j = 0; j < sources->len; j++) {
+ const gchar *source = g_ptr_array_index (sources, j);
+ g_autofree gchar *source_safe = xb_string_escape (source);
+ xb_string_append_union (xpath,
+ "components/component/pkgname[text()='%s']/../id",
+ source_safe);
+ }
+
+ /* do a big query, and return all the unique results */
+ ids = xb_silo_query (silo, xpath->str, 0, &error_local);
+ if (ids == NULL) {
+ if (g_error_matches (error_local, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
+ return TRUE;
+ g_propagate_error (error, g_steal_pointer (&error_local));
+ return FALSE;
+ }
+ for (guint i = 0; i < ids->len; i++) {
+ XbNode *n = g_ptr_array_index (ids, i);
+ g_autoptr(GsApp) app2 = NULL;
+ const gchar *tmp;
+ app2 = gs_app_new (xb_node_get_text (n));
+ gs_app_add_quirk (app2, GS_APP_QUIRK_IS_WILDCARD);
+
+ tmp = xb_node_query_attr (n, "../..", "origin", NULL);
+ if (gs_appstream_origin_valid (tmp))
+ gs_app_set_origin_appstream (app2, tmp);
+ gs_app_list_add (list, app2);
+ }
+ return TRUE;
+}
+
+static gboolean
+gs_appstream_add_featured_with_query (XbSilo *silo,
+ const gchar *query,
+ GsAppList *list,
+ GCancellable *cancellable,
+ GError **error)
+{
+ g_autoptr(GError) error_local = NULL;
+ g_autoptr(GPtrArray) array = NULL;
+
+ g_return_val_if_fail (XB_IS_SILO (silo), FALSE);
+ g_return_val_if_fail (GS_IS_APP_LIST (list), FALSE);
+
+ /* find out how many packages are in each category */
+ array = xb_silo_query (silo, query, 0, &error_local);
+ if (array == NULL) {
+ if (g_error_matches (error_local, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
+ return TRUE;
+ g_propagate_error (error, g_steal_pointer (&error_local));
+ return FALSE;
+ }
+ for (guint i = 0; i < array->len; i++) {
+ g_autoptr(GsApp) app = NULL;
+ XbNode *component = g_ptr_array_index (array, i);
+ const gchar *component_id = xb_node_query_text (component, "id", NULL);
+ if (component_id == NULL)
+ continue;
+ app = gs_app_new (component_id);
+ gs_app_add_quirk (app, GS_APP_QUIRK_IS_WILDCARD);
+ if (!gs_appstream_copy_metadata (app, component, error))
+ return FALSE;
+ gs_app_list_add (list, app);
+ }
+ return TRUE;
+}
+
+gboolean
+gs_appstream_add_featured (XbSilo *silo,
+ GsAppList *list,
+ GCancellable *cancellable,
+ GError **error)
+{
+ const gchar *query = "components/component/custom/value[@key='GnomeSoftware::FeatureTile']/../..|"
+ "components/component/custom/value[@key='GnomeSoftware::FeatureTile-css']/../..";
+ return gs_appstream_add_featured_with_query (silo, query, list, cancellable, error);
+}
+
+gboolean
+gs_appstream_add_deployment_featured (XbSilo *silo,
+ const gchar * const *deployments,
+ GsAppList *list,
+ GCancellable *cancellable,
+ GError **error)
+{
+ g_autoptr(GString) query = g_string_new (NULL);
+ g_return_val_if_fail (XB_IS_SILO (silo), FALSE);
+ g_return_val_if_fail (deployments != NULL, FALSE);
+ g_return_val_if_fail (GS_IS_APP_LIST (list), FALSE);
+ for (guint ii = 0; deployments[ii] != NULL; ii++) {
+ g_autofree gchar *escaped = xb_string_escape (deployments[ii]);
+ if (escaped != NULL && *escaped != '\0') {
+ xb_string_append_union (query,
+ "components/component/custom/value[@key='GnomeSoftware::DeploymentFeatured'][text()='%s']/../..",
+ escaped);
+ }
+ }
+ if (!query->len)
+ return TRUE;
+ return gs_appstream_add_featured_with_query (silo, query->str, list, cancellable, error);
+}
+
+gboolean
+gs_appstream_url_to_app (GsPlugin *plugin,
+ XbSilo *silo,
+ GsAppList *list,
+ const gchar *url,
+ GCancellable *cancellable,
+ GError **error)
+{
+ g_autofree gchar *path = NULL;
+ g_autofree gchar *scheme = NULL;
+ g_autofree gchar *xpath = NULL;
+ g_autoptr(GPtrArray) components = NULL;
+
+ g_return_val_if_fail (GS_IS_PLUGIN (plugin), FALSE);
+ g_return_val_if_fail (XB_IS_SILO (silo), FALSE);
+ g_return_val_if_fail (GS_IS_APP_LIST (list), FALSE);
+ g_return_val_if_fail (url != NULL, FALSE);
+
+ /* not us */
+ scheme = gs_utils_get_url_scheme (url);
+ if (g_strcmp0 (scheme, "appstream") != 0)
+ return TRUE;
+
+ path = gs_utils_get_url_path (url);
+ xpath = g_strdup_printf ("components/component/id[text()='%s']/..", path);
+ components = xb_silo_query (silo, xpath, 0, NULL);
+ if (components == NULL)
+ return TRUE;
+
+ for (guint i = 0; i < components->len; i++) {
+ XbNode *component = g_ptr_array_index (components, i);
+ g_autoptr(GsApp) app = NULL;
+ app = gs_appstream_create_app (plugin, silo, component, error);
+ if (app == NULL)
+ return FALSE;
+ gs_app_set_scope (app, AS_COMPONENT_SCOPE_SYSTEM);
+ gs_app_list_add (list, app);
+ }
+
+ return TRUE;
+}
+
+void
+gs_appstream_component_add_keyword (XbBuilderNode *component, const gchar *str)
+{
+ g_autoptr(XbBuilderNode) keyword = NULL;
+ g_autoptr(XbBuilderNode) keywords = NULL;
+
+ g_return_if_fail (XB_IS_BUILDER_NODE (component));
+ g_return_if_fail (str != NULL);
+
+ /* create <keywords> if it does not already exist */
+ keywords = xb_builder_node_get_child (component, "keywords", NULL);
+ if (keywords == NULL)
+ keywords = xb_builder_node_insert (component, "keywords", NULL);
+
+ /* create <keyword>str</keyword> if it does not already exist */
+ keyword = xb_builder_node_get_child (keywords, "keyword", str);
+ if (keyword == NULL) {
+ keyword = xb_builder_node_insert (keywords, "keyword", NULL);
+ xb_builder_node_set_text (keyword, str, -1);
+ }
+}
+
+void
+gs_appstream_component_add_provide (XbBuilderNode *component, const gchar *str)
+{
+ g_autoptr(XbBuilderNode) provide = NULL;
+ g_autoptr(XbBuilderNode) provides = NULL;
+
+ g_return_if_fail (XB_IS_BUILDER_NODE (component));
+ g_return_if_fail (str != NULL);
+
+ /* create <provides> if it does not already exist */
+ provides = xb_builder_node_get_child (component, "provides", NULL);
+ if (provides == NULL)
+ provides = xb_builder_node_insert (component, "provides", NULL);
+
+ /* create <id>str</id> if it does not already exist */
+ provide = xb_builder_node_get_child (provides, "id", str);
+ if (provide == NULL) {
+ provide = xb_builder_node_insert (provides, "id", NULL);
+ xb_builder_node_set_text (provide, str, -1);
+ }
+}
+
+void
+gs_appstream_component_add_category (XbBuilderNode *component, const gchar *str)
+{
+ g_autoptr(XbBuilderNode) category = NULL;
+ g_autoptr(XbBuilderNode) categories = NULL;
+
+ g_return_if_fail (XB_IS_BUILDER_NODE (component));
+ g_return_if_fail (str != NULL);
+
+ /* create <categories> if it does not already exist */
+ categories = xb_builder_node_get_child (component, "categories", NULL);
+ if (categories == NULL)
+ categories = xb_builder_node_insert (component, "categories", NULL);
+
+ /* create <category>str</category> if it does not already exist */
+ category = xb_builder_node_get_child (categories, "category", str);
+ if (category == NULL) {
+ category = xb_builder_node_insert (categories, "category", NULL);
+ xb_builder_node_set_text (category, str, -1);
+ }
+}
+
+void
+gs_appstream_component_add_icon (XbBuilderNode *component, const gchar *str)
+{
+ g_autoptr(XbBuilderNode) icon = NULL;
+
+ g_return_if_fail (XB_IS_BUILDER_NODE (component));
+ g_return_if_fail (str != NULL);
+
+ /* create <icon>str</icon> if it does not already exist */
+ icon = xb_builder_node_get_child (component, "icon", NULL);
+ if (icon == NULL) {
+ icon = xb_builder_node_insert (component, "icon",
+ "type", "stock",
+ NULL);
+ xb_builder_node_set_text (icon, str, -1);
+ }
+}
+
+void
+gs_appstream_component_add_extra_info (XbBuilderNode *component)
+{
+ const gchar *kind;
+
+ g_return_if_fail (XB_IS_BUILDER_NODE (component));
+
+ kind = xb_builder_node_get_attr (component, "type");
+
+ /* add the gnome-software-specific 'Addon' group and ensure they
+ * all have an icon set */
+ switch (as_component_kind_from_string (kind)) {
+ case AS_COMPONENT_KIND_WEB_APP:
+ gs_appstream_component_add_keyword (component, kind);
+ break;
+ case AS_COMPONENT_KIND_FONT:
+ gs_appstream_component_add_category (component, "Addon");
+ gs_appstream_component_add_category (component, "Font");
+ break;
+ case AS_COMPONENT_KIND_DRIVER:
+ gs_appstream_component_add_category (component, "Addon");
+ gs_appstream_component_add_category (component, "Driver");
+ gs_appstream_component_add_icon (component, "system-component-driver");
+ break;
+ case AS_COMPONENT_KIND_LOCALIZATION:
+ gs_appstream_component_add_category (component, "Addon");
+ gs_appstream_component_add_category (component, "Localization");
+ gs_appstream_component_add_icon (component, "system-component-language");
+ break;
+ case AS_COMPONENT_KIND_CODEC:
+ gs_appstream_component_add_category (component, "Addon");
+ gs_appstream_component_add_category (component, "Codec");
+ gs_appstream_component_add_icon (component, "system-component-codecs");
+ break;
+ case AS_COMPONENT_KIND_INPUT_METHOD:
+ gs_appstream_component_add_keyword (component, kind);
+ gs_appstream_component_add_category (component, "Addon");
+ gs_appstream_component_add_category (component, "InputSource");
+ gs_appstream_component_add_icon (component, "system-component-input-sources");
+ break;
+ case AS_COMPONENT_KIND_FIRMWARE:
+ gs_appstream_component_add_icon (component, "system-component-firmware");
+ break;
+ default:
+ break;
+ }
+}
+
+/* Resolve any media URIs which are actually relative
+ * paths against the media_baseurl property */
+void
+gs_appstream_component_fix_url (XbBuilderNode *component, const gchar *baseurl)
+{
+ const gchar *text;
+ g_autofree gchar *url = NULL;
+
+ g_return_if_fail (XB_IS_BUILDER_NODE (component));
+ g_return_if_fail (baseurl != NULL);
+
+ text = xb_builder_node_get_text (component);
+
+ if (text == NULL)
+ return;
+
+ if (g_str_has_prefix (text, "http:") ||
+ g_str_has_prefix (text, "https:"))
+ return;
+
+ url = g_strconcat (baseurl, "/", text, NULL);
+ xb_builder_node_set_text (component, url , -1);
+}