static gboolean parse_reviews (GsPlugin *plugin, JsonParser *parser, GsApp *app, GCancellable *cancellable, GError **error) { GsAuth *auth; JsonArray *array; const gchar *consumer_key = NULL; guint i; auth = gs_plugin_get_auth_by_id (plugin, "ubuntuone"); if (auth != NULL) consumer_key = gs_auth_get_metadata_item (auth, "consumer-key"); if (!JSON_NODE_HOLDS_ARRAY (json_parser_get_root (parser))) return FALSE; array = json_node_get_array (json_parser_get_root (parser)); for (i = 0; i < json_array_get_length (array); i++) { g_autoptr(AsReview) review = NULL; /* Read in from JSON... (skip bad entries) */ review = as_review_new (); if (parse_review (review, consumer_key, json_array_get_element (array, i))) gs_app_add_review (app, review); } return TRUE; }
/** * json_reader_count_elements: * @reader: a #JsonReader * * Counts the elements of the current position, if @reader is * positioned on an array * * Return value: the number of elements, or -1. In case of failure * the #JsonReader is set in an error state * * Since: 0.12 */ gint json_reader_count_elements (JsonReader *reader) { JsonReaderPrivate *priv; g_return_val_if_fail (JSON_IS_READER (reader), -1); priv = reader->priv; if (priv->current_node == NULL) { json_reader_set_error (reader, JSON_READER_ERROR_INVALID_NODE, _("No node available at the current position")); return -1; } if (!JSON_NODE_HOLDS_ARRAY (priv->current_node)) { json_reader_set_error (reader, JSON_READER_ERROR_NO_ARRAY, _("The current position holds a '%s' and not an array"), json_node_type_get_name (JSON_NODE_TYPE (priv->current_node))); return -1; } return json_array_get_length (json_node_get_array (priv->current_node)); }
/** * wbl_string_set_union_dependencies: * @set: (transfer floating): a #WblStringSet * @dependencies: a JSON object mapping property names to arrays of property * names (or to object instances) * * Calculate the transitive union of the dependencies of the elements of an * initial @set and return it as a new #WblStringSet. @dependencies is treated * as a map of property names to dependencies; the function essentially * calculates * output = set ∪ ⋃_{d ϵ output} dependencies(d) * * Complexity: O(S * D) in the size S of @set and number D of @dependencies keys * Returns: the transitive dependency set of @set * Since: 0.2.0 */ WblStringSet * wbl_string_set_union_dependencies (WblStringSet *set, JsonObject *dependencies) { WblStringSet *output = NULL; guint old_output_size; g_return_val_if_fail (_wbl_string_set_is_valid (set), NULL); g_return_val_if_fail (dependencies != NULL, NULL); output = _wbl_string_set_new (); wbl_string_set_ref_sink (set); do { GHashTableIter iter; const gchar *property_name; old_output_size = g_hash_table_size (output->set); g_hash_table_iter_init (&iter, set->set); while (g_hash_table_iter_next (&iter, (gpointer *) &property_name, NULL)) { JsonNode *dependency_value; guint i, len; /* Add the dependency key. */ _wbl_string_set_add (output, property_name); /* See if there are any values associated with the * dependency key. */ dependency_value = json_object_get_member (dependencies, property_name); /* Ignore schema dependencies; we only care about * property dependencies, for which we add all * dependent properties. */ if (dependency_value != NULL && JSON_NODE_HOLDS_ARRAY (dependency_value)) { JsonArray *array; array = json_node_get_array (dependency_value); for (i = 0, len = json_array_get_length (array); i < len; i++) { _wbl_string_set_add (output, json_array_get_string_element (array, i)); } } } } while (old_output_size != g_hash_table_size (output->set)); wbl_string_set_unref (set); output->state |= STATE_IMMUTABLE; return output; }
/* This function is synchronous! Blocking once at startup seems pretty * reasonable and allows us to avoid any complexity re. races */ static void mex_queue_model_load (MexQueueModel *model) { JsonParser *parser; gchar *filename; GError *error = NULL; JsonNode *root; JsonArray *array; gint i = 0; filename = _queue_file_name (); if (!g_file_test (filename, G_FILE_TEST_EXISTS)) { g_free (filename); return; } parser = json_parser_new (); if (!json_parser_load_from_file (parser, filename, &error)) { g_warning (G_STRLOC ": error populating from file: %s", error->message); g_clear_error (&error); goto out; } root = json_parser_get_root (parser); if (!JSON_NODE_HOLDS_ARRAY (root)) { g_warning (G_STRLOC ": JSON data not of expected format!"); goto out; } array = json_node_get_array (root); for (i = 0; i < json_array_get_length (array); i++) { MexContent *content; JsonNode *node; node = json_array_get_element (array, i); content = (MexContent *)json_gobject_deserialize (MEX_TYPE_PROGRAM, node); mex_model_add_content (MEX_MODEL (model), content); } out: g_free (filename); g_object_unref (parser); }
/** * json_reader_is_array: * @reader: a #JsonReader * * Checks whether the @reader is currently on an array * * Return value: %TRUE if the #JsonReader is on an array, and %FALSE * otherwise * * Since: 0.12 */ gboolean json_reader_is_array (JsonReader *reader) { g_return_val_if_fail (JSON_IS_READER (reader), FALSE); json_reader_return_val_if_error_set (reader, FALSE); if (reader->priv->current_node == NULL) return FALSE; return JSON_NODE_HOLDS_ARRAY (reader->priv->current_node); }
void cockpit_package_dump (void) { GHashTable *listing; GHashTable *by_name; GHashTableIter iter; CockpitPackage *package; GList *names, *l; const gchar *prefix; JsonArray *array; guint i; listing = cockpit_package_listing (NULL); by_name = g_hash_table_new (g_str_hash, g_str_equal); g_hash_table_iter_init (&iter, listing); while (g_hash_table_iter_next (&iter, NULL, (gpointer *)&package)) g_hash_table_replace (by_name, package->name, package); names = g_hash_table_get_keys (by_name); names = g_list_sort (names, (GCompareFunc)strcmp); for (l = names; l != NULL; l = g_list_next (l)) { package = g_hash_table_lookup (by_name, l->data); g_print ("%s: %s\n", package->name, package->directory); if (package->checksum) g_print (" checksum: %s\n", package->checksum); if (package->alias) { prefix = " alias: "; if (JSON_NODE_HOLDS_ARRAY (package->alias)) { array = json_node_get_array (package->alias); for (i = 0; i < json_array_get_length (array); i++) { g_print ("%s%s\n", prefix, json_array_get_string_element (array, i)); prefix = " "; } } else { g_print ("%s%s\n", prefix, json_node_get_string (package->alias)); } } } g_list_free (names); g_hash_table_unref (by_name); g_hash_table_unref (listing); }
static void snra_json_node_into_val (JsonNode *element_node, GValue *v) { if (JSON_NODE_HOLDS_OBJECT (element_node)) { GstStructure *child = snra_json_to_gst_structure (element_node); g_value_init (v, GST_TYPE_STRUCTURE); gst_value_set_structure (v, child); } else if (JSON_NODE_HOLDS_ARRAY (element_node)) { JsonArray *arr = json_node_get_array (element_node); g_value_init (v, GST_TYPE_ARRAY); json_array_foreach_element (arr, (JsonArrayForeach) snra_json_array_add_to_val, v); } else { json_node_get_value (element_node, v); } }
/** * json_reader_count_elements: * @reader: a #JsonReader * * Counts the elements of the current position, if @reader is * positioned on an array * * Return value: the number of elements, or -1. In case of failure * the #JsonReader is set in an error state * * Since: 0.12 */ gint json_reader_count_elements (JsonReader *reader) { JsonReaderPrivate *priv; g_return_val_if_fail (JSON_IS_READER (reader), -1); priv = reader->priv; if (priv->current_node == NULL) return -1; if (!JSON_NODE_HOLDS_ARRAY (priv->current_node)) return -1; return json_array_get_length (json_node_get_array (priv->current_node)); }
static void show_obj_value (gpointer data, gpointer p) { JsonNode *node = data; struct jsdata *jsd = p; if (JSON_NODE_HOLDS_ARRAY(node)) { fprintf(stderr, " show_obj_value: got array!\n"); } if (node != NULL && !*jsd->err) { *jsd->err = output_json_node_value(node, jsd->prn); if (!*jsd->err) { *jsd->n_objects += 1; pputc(jsd->prn, '\n'); } } }
/** * json_object_get_array_member: * @object: a #JsonObject * @member_name: the name of the member * * Convenience function that retrieves the array * stored in @member_name of @object * * See also: json_object_get_member() * * Return value: (transfer none): the array inside the object's member * * Since: 0.8 */ JsonArray * json_object_get_array_member (JsonObject *object, const gchar *member_name) { JsonNode *node; g_return_val_if_fail (object != NULL, NULL); g_return_val_if_fail (member_name != NULL, NULL); node = object_get_member_internal (object, member_name); g_return_val_if_fail (node != NULL, NULL); g_return_val_if_fail (JSON_NODE_HOLDS_ARRAY (node) || JSON_NODE_HOLDS_NULL (node), NULL); if (JSON_NODE_HOLDS_NULL (node)) return NULL; return json_node_get_array (node); }
/** * json_array_get_array_element: * @array: a #JsonArray * @index_: the index of the element to retrieve * * Conveniently retrieves the array from the element at @index_ * inside @array * * See also: json_array_get_element(), json_node_get_array() * * Return value: (transfer none): the array * * Since: 0.8 */ JsonArray * json_array_get_array_element (JsonArray *array, guint index_) { JsonNode *node; g_return_val_if_fail (array != NULL, NULL); g_return_val_if_fail (index_ < array->elements->len, NULL); node = g_ptr_array_index (array->elements, index_); g_return_val_if_fail (node != NULL, NULL); g_return_val_if_fail (JSON_NODE_HOLDS_ARRAY (node) || JSON_NODE_HOLDS_NULL (node), NULL); if (JSON_NODE_HOLDS_NULL (node)) return NULL; return json_node_get_array (node); }
/** * json_array_get_null_element: * @array: a #JsonArray * @index_: the index of the element to retrieve * * Conveniently retrieves whether the element at @index_ is set to null * * See also: json_array_get_element(), JSON_NODE_TYPE(), %JSON_NODE_NULL * * Return value: %TRUE if the element is null * * Since: 0.8 */ gboolean json_array_get_null_element (JsonArray *array, guint index_) { JsonNode *node; g_return_val_if_fail (array != NULL, FALSE); g_return_val_if_fail (index_ < array->elements->len, FALSE); node = g_ptr_array_index (array->elements, index_); g_return_val_if_fail (node != NULL, FALSE); if (JSON_NODE_HOLDS_NULL (node)) return TRUE; if (JSON_NODE_HOLDS_ARRAY (node)) return json_node_get_array (node) == NULL; if (JSON_NODE_HOLDS_OBJECT (node)) return json_node_get_object (node) == NULL; return FALSE; }
static gboolean parse_histogram (const gchar *text, Histogram *histogram) { g_autoptr(JsonParser) parser = NULL; JsonArray *array; /* Histogram is a five element JSON array, e.g. "[1, 3, 5, 8, 4]" */ parser = json_parser_new (); if (!json_parser_load_from_data (parser, text, -1, NULL)) return FALSE; if (!JSON_NODE_HOLDS_ARRAY (json_parser_get_root (parser))) return FALSE; array = json_node_get_array (json_parser_get_root (parser)); if (json_array_get_length (array) != 5) return FALSE; histogram->one_star_count = (guint64) json_array_get_int_element (array, 0); histogram->two_star_count = (guint64) json_array_get_int_element (array, 1); histogram->three_star_count = (guint64) json_array_get_int_element (array, 2); histogram->four_star_count = (guint64) json_array_get_int_element (array, 3); histogram->five_star_count = (guint64) json_array_get_int_element (array, 4); return TRUE; }
/** * json_object_get_null_member: * @object: a #JsonObject * @member_name: the name of the member * * Convenience function that checks whether the value * stored in @member_name of @object is null * * See also: json_object_get_member() * * Return value: %TRUE if the value is null * * Since: 0.8 */ gboolean json_object_get_null_member (JsonObject *object, const gchar *member_name) { JsonNode *node; g_return_val_if_fail (object != NULL, FALSE); g_return_val_if_fail (member_name != NULL, FALSE); node = object_get_member_internal (object, member_name); g_return_val_if_fail (node != NULL, FALSE); if (JSON_NODE_HOLDS_NULL (node)) return TRUE; if (JSON_NODE_HOLDS_OBJECT (node)) return json_node_get_object (node) == NULL; if (JSON_NODE_HOLDS_ARRAY (node)) return json_node_get_array (node) == NULL; return FALSE; }
static gboolean parse_review_entries (GsPlugin *plugin, JsonParser *parser, GError **error) { JsonArray *array; guint i; if (!JSON_NODE_HOLDS_ARRAY (json_parser_get_root (parser))) return FALSE; array = json_node_get_array (json_parser_get_root (parser)); for (i = 0; i < json_array_get_length (array); i++) { const gchar *package_name; Histogram histogram; /* Read in from JSON... (skip bad entries) */ if (!parse_review_entry (json_array_get_element (array, i), &package_name, &histogram)) continue; /* ...write into the database (abort everything if can't write) */ if (!set_package_stats (plugin, package_name, &histogram, error)) return FALSE; } return TRUE; }
/** * json_reader_read_element: * @reader: a #JsonReader * @index_: the index of the element * * Advances the cursor of @reader to the element @index_ of the array * or the object at the current position. * * You can use the json_reader_get_value* family of functions to retrieve * the value of the element; for instance: * * |[ * json_reader_read_element (reader, 0); * int_value = json_reader_get_int_value (reader); * ]| * * After reading the value, json_reader_end_element() should be called to * reposition the cursor inside the #JsonReader, e.g.: * * |[ * json_reader_read_element (reader, 1); * str_value = json_reader_get_string_value (reader); * json_reader_end_element (reader); * * json_reader_read_element (reader, 2); * str_value = json_reader_get_string_value (reader); * json_reader_end_element (reader); * ]| * * If @reader is not currently on an array or an object, or if the @index_ is * bigger than the size of the array or the object, the #JsonReader will be * put in an error state until json_reader_end_element() is called. * * Return value: %TRUE on success, and %FALSE otherwise * * Since: 0.12 */ gboolean json_reader_read_element (JsonReader *reader, guint index_) { JsonReaderPrivate *priv; g_return_val_if_fail (JSON_READER (reader), FALSE); json_reader_return_val_if_error_set (reader, FALSE); priv = reader->priv; if (priv->current_node == NULL) priv->current_node = priv->root; if (!(JSON_NODE_HOLDS_ARRAY (priv->current_node) || JSON_NODE_HOLDS_OBJECT (priv->current_node))) return json_reader_set_error (reader, JSON_READER_ERROR_NO_ARRAY, "The current node is of type '%s', but " "an array or an object was expected.", json_node_type_name (priv->current_node)); switch (json_node_get_node_type (priv->current_node)) { case JSON_NODE_ARRAY: { JsonArray *array = json_node_get_array (priv->current_node); if (index_ >= json_array_get_length (array)) return json_reader_set_error (reader, JSON_READER_ERROR_INVALID_INDEX, "The index '%d' is greater than the size " "of the array at the current position.", index_); priv->previous_node = priv->current_node; priv->current_node = json_array_get_element (array, index_); } break; case JSON_NODE_OBJECT: { JsonObject *object = json_node_get_object (priv->current_node); GList *members; const gchar *name; if (index_ >= json_object_get_size (object)) return json_reader_set_error (reader, JSON_READER_ERROR_INVALID_INDEX, "The index '%d' is greater than the size " "of the object at the current position.", index_); priv->previous_node = priv->current_node; g_free (priv->current_member); members = json_object_get_members (object); name = g_list_nth_data (members, index_); priv->current_node = json_object_get_member (object, name); priv->current_member = g_strdup (name); g_list_free (members); } break; default: g_assert_not_reached (); return FALSE; } return TRUE; }
static int real_json_get (JsonParser *parser, const char *pathstr, int *n_objects, PRN *prn) { GError *gerr = NULL; JsonNode *match, *node; JsonPath *path; GType ntype; double x; int err = 0; *n_objects = 0; node = json_parser_get_root(parser); path = json_path_new(); if (!json_path_compile(path, pathstr, &gerr)) { if (gerr != NULL) { gretl_errmsg_sprintf("Failed to compile JsonPath: %s", gerr->message); g_error_free(gerr); } else { gretl_errmsg_set("Failed to compile JsonPath"); } g_object_unref(path); return E_DATA; } match = json_path_match(path, node); if (match == NULL) { /* FIXME : maybe return empty string? */ g_object_unref(path); return E_DATA; } /* in case we get floating-point output */ gretl_push_c_numeric_locale(); if (JSON_NODE_HOLDS_ARRAY(match)) { JsonArray *array; array = json_node_get_array(match); node = json_array_get_element(array, 0); repeat: if (node == NULL) { gretl_errmsg_set("Failed to match JsonPath"); ntype = 0; } else { ntype = json_node_get_value_type(node); } if (!handled_type(ntype)) { if (JSON_NODE_HOLDS_ARRAY(node)) { array = json_node_get_array(node); node = json_array_get_element(array, 0); goto repeat; } else { gretl_errmsg_sprintf("Unhandled array type '%s'", g_type_name(ntype)); err = E_DATA; } } else { int i, n = json_array_get_length(array); for (i=0; i<n; i++) { node = json_array_get_element(array, i); if (ntype == G_TYPE_STRING) { pputs(prn, json_node_get_string(node)); } else { x = json_node_get_double(node); pprintf(prn, "%.15g", x); } if (n > 1) { pputc(prn, '\n'); } } *n_objects = n; } } else { ntype = json_node_get_value_type(match); if (!handled_type(ntype)) { gretl_errmsg_sprintf("Unhandled object type '%s'", g_type_name(ntype)); err = E_DATA; } else { if (ntype == G_TYPE_STRING) { pputs(prn, json_node_get_string(match)); } else { x = json_node_get_double(match); pprintf(prn, "%.15g", x); } *n_objects = 1; } } gretl_pop_c_numeric_locale(); json_node_free(match); g_object_unref(path); return err; }
static int real_json_get (JsonParser *parser, const char *pathstr, int *n_objects, PRN *prn) { GError *gerr = NULL; JsonNode *match, *node; JsonPath *path; GType ntype; int err = 0; *n_objects = 0; node = json_parser_get_root(parser); if (node == NULL || json_node_is_null(node)) { gretl_errmsg_set("jsonget: got null root node"); return E_DATA; } path = json_path_new(); if (!json_path_compile(path, pathstr, &gerr)) { if (gerr != NULL) { gretl_errmsg_sprintf("jsonget: failed to compile JsonPath: %s", gerr->message); g_error_free(gerr); } else { gretl_errmsg_set("jsonget: failed to compile JsonPath"); } g_object_unref(path); return E_DATA; } match = json_path_match(path, node); if (null_node(match)) { /* FIXME : maybe return empty string? */ g_object_unref(path); return E_DATA; } /* in case we get floating-point output */ gretl_push_c_numeric_locale(); if (JSON_NODE_HOLDS_ARRAY(match)) { JsonArray *array = json_node_get_array(match); int len = 0, index = 0; if (non_empty_array(array)) { len = json_array_get_length(array); node = json_array_get_element(array, index); } else { node = NULL; } repeat: if (null_node(node)) { gretl_errmsg_set("jsonget: failed to match JsonPath"); ntype = 0; err = E_DATA; goto bailout; } else { ntype = json_node_get_value_type(node); } if (node != NULL && !handled_type(ntype)) { if (JSON_NODE_HOLDS_ARRAY(node)) { /* recurse on array type */ array = json_node_get_array(node); if (non_empty_array(array)) { node = json_array_get_element(array, 0); goto repeat; } } else if (json_node_get_node_type(node) == JSON_NODE_OBJECT) { err = excavate_json_object(node, n_objects, prn); if (!err) { if (index < len - 1) { node = json_array_get_element(array, ++index); goto repeat; } } } else { gretl_errmsg_sprintf("jsonget: unhandled array type '%s'", g_type_name(ntype)); err = E_DATA; } } else if (array != NULL) { int i, n = json_array_get_length(array); for (i=0; i<n && !err; i++) { node = json_array_get_element(array, i); err = output_json_node_value(node, prn); if (!err) { *n_objects += 1; if (n > 1) { pputc(prn, '\n'); } } } } } else { /* not an array-holding node */ err = output_json_node_value(match, prn); if (!err) { *n_objects += 1; } } bailout: gretl_pop_c_numeric_locale(); json_node_free(match); g_object_unref(path); return err; }
static gboolean catch_resource_group_api_parse_objects (CatchResourceGroup *group, JsonNode *result, guint *result_offset, guint *n_resources, GError **error) { CatchResourceGroupPrivate *priv; CatchResource *resource; JsonObject *obj; JsonArray *array; JsonNode *element; gboolean set_first_page = FALSE; gboolean ret = FALSE; GType resource_type; guint i; guint length; guint offset = 0; ENTRY; g_return_val_if_fail(CATCH_IS_RESOURCE_GROUP(group), FALSE); g_return_val_if_fail(result != NULL, FALSE); priv = group->priv; g_object_freeze_notify(G_OBJECT(group)); if (!JSON_NODE_HOLDS_OBJECT(result) || !(obj = json_node_get_object(result)) || !json_object_has_member(obj, "objects") || !JSON_NODE_HOLDS_ARRAY(json_object_get_member(obj, "objects")) || !(array = json_object_get_array_member(obj, "objects"))) { g_set_error(error, CATCH_API_ERROR, CATCH_API_ERROR_BAD_RESPONSE, _("The resonse did not contain the objects array.")); GOTO(failure); } if (json_object_has_member(obj, "count") && JSON_NODE_HOLDS_VALUE(json_object_get_member(obj, "count"))) { priv->count = json_object_get_int_member(obj, "count"); set_first_page = TRUE; g_object_notify(G_OBJECT(group), "count"); } if (json_object_has_member(obj, "offset") && JSON_NODE_HOLDS_VALUE(json_object_get_member(obj, "offset"))) { offset = json_object_get_int_member(obj, "offset"); } length = json_array_get_length(array); for (i = 0; i < length; i++) { element = json_array_get_element(array, i); if (!(resource_type = object_peek_type(element))) { g_set_error(error, CATCH_API_ERROR, CATCH_API_ERROR_BAD_RESPONSE, _("The JSON object did not contain a \"type\" field.")); GOTO(failure); } resource = g_object_new(resource_type, NULL); g_assert(CATCH_IS_RESOURCE(resource)); if (!catch_resource_load_from_json(resource, element, error)) { g_object_unref(resource); GOTO(failure); } catch_resource_group_set_resource(CATCH_RESOURCE_GROUP(group), offset + i, resource); g_object_unref(resource); } if (set_first_page) { priv->first_page_size = length; } if (result_offset) { *result_offset = offset; } if (n_resources) { *n_resources = length; } ret = TRUE; failure: g_object_thaw_notify(G_OBJECT(group)); RETURN(ret); }
GHashTable * cockpit_package_listing (JsonArray **json) { JsonArray *root = NULL; GHashTable *listing; CockpitPackage *package; GHashTable *ids; JsonObject *object; JsonArray *id; GList *names, *l; GList *packages; const gchar *name; JsonNode *node; JsonArray *array; guint i, length; listing = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, cockpit_package_unref); build_package_listing (listing); /* Add aliases to the listing */ packages = g_hash_table_get_values (listing); packages = g_list_sort (packages, compar_packages); g_list_foreach (packages, (GFunc)cockpit_package_ref, NULL); for (l = packages; l != NULL; l = g_list_next (l)) { package = l->data; node = json_object_get_member (package->manifest, "alias"); if (node) { /* * Process and remove "alias" from the manifest, as it results in * confusing and duplicated information for the front end. */ package->alias = node = json_node_copy (node); json_object_remove_member (package->manifest, "alias"); if (JSON_NODE_HOLDS_ARRAY (node)) { array = json_node_get_array (node); length = json_array_get_length (array); for (i = 0; i < length; i++) add_alias_to_listing (listing, package, json_array_get_element (array, i)); } else { add_alias_to_listing (listing, package, node); } } } g_list_free_full (packages, (GDestroyNotify)cockpit_package_unref); /* Now wrap up the checksums */ finish_checksums (listing); /* Add checksums to the listing */ packages = g_hash_table_get_values (listing); g_list_foreach (packages, (GFunc)cockpit_package_ref, NULL); for (l = packages; l != NULL; l = g_list_next (l)) { package = l->data; if (package->checksum && !g_hash_table_contains (listing, package->checksum)) { g_hash_table_replace (listing, package->checksum, cockpit_package_ref (package)); g_debug ("%s: package has checksum: %s", package->name, package->checksum); } } g_list_free_full (packages, (GDestroyNotify)cockpit_package_unref); /* Build JSON packages block */ if (json) { *json = root = json_array_new (); ids = g_hash_table_new (g_direct_hash, g_direct_equal); names = g_hash_table_get_keys (listing); names = g_list_sort (names, (GCompareFunc)strcmp); for (l = names; l != NULL; l = g_list_next (l)) { name = l->data; package = g_hash_table_lookup (listing, name); id = g_hash_table_lookup (ids, package); if (!id) { object = json_object_new (); id = json_array_new(); /* The actual package name always comes first */ json_object_set_array_member (object, "id", id); json_array_add_string_element (id, package->name); g_hash_table_insert (ids, package, id); json_object_set_object_member (object, "manifest", json_object_ref (package->manifest)); json_array_add_object_element (root, object); } /* Other ways to refer to the package */ if (!g_str_equal (name, package->name)) json_array_add_string_element (id, name); } g_list_free (names); g_hash_table_destroy (ids); } return listing; }
static void ide_compile_commands_load_worker (GTask *task, gpointer source_object, gpointer task_data, GCancellable *cancellable) { IdeCompileCommands *self = source_object; GFile *gfile = task_data; g_autoptr(JsonParser) parser = NULL; g_autoptr(GError) error = NULL; g_autoptr(GHashTable) info_by_file = NULL; g_autoptr(GHashTable) directories_by_path = NULL; g_autoptr(GPtrArray) vala_info = NULL; g_autofree gchar *contents = NULL; JsonNode *root; JsonArray *ar; gsize len = 0; guint n_items; IDE_ENTRY; g_assert (G_IS_TASK (task)); g_assert (IDE_IS_COMPILE_COMMANDS (self)); g_assert (G_IS_FILE (gfile)); g_assert (!cancellable || G_IS_CANCELLABLE (cancellable)); parser = json_parser_new (); if (!g_file_load_contents (gfile, cancellable, &contents, &len, NULL, &error) || !json_parser_load_from_data (parser, contents, len, &error)) { g_task_return_error (task, g_steal_pointer (&error)); IDE_EXIT; } if (NULL == (root = json_parser_get_root (parser)) || !JSON_NODE_HOLDS_ARRAY (root) || NULL == (ar = json_node_get_array (root))) { g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_INVALID_DATA, "Failed to extract commands, invalid json"); IDE_EXIT; } info_by_file = g_hash_table_new_full (g_file_hash, (GEqualFunc)g_file_equal, NULL, compile_info_free); directories_by_path = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, g_object_unref); vala_info = g_ptr_array_new_with_free_func (compile_info_free); n_items = json_array_get_length (ar); for (guint i = 0; i < n_items; i++) { CompileInfo *info; JsonNode *item; JsonNode *value; JsonObject *obj; GFile *dir; const gchar *directory = NULL; const gchar *file = NULL; const gchar *command = NULL; item = json_array_get_element (ar, i); /* Skip past this node if its invalid for some reason, so we * can try to be tolerante of errors created by broken tooling. */ if (item == NULL || !JSON_NODE_HOLDS_OBJECT (item) || NULL == (obj = json_node_get_object (item))) continue; if (json_object_has_member (obj, "file") && NULL != (value = json_object_get_member (obj, "file")) && JSON_NODE_HOLDS_VALUE (value)) file = json_node_get_string (value); if (json_object_has_member (obj, "directory") && NULL != (value = json_object_get_member (obj, "directory")) && JSON_NODE_HOLDS_VALUE (value)) directory = json_node_get_string (value); if (json_object_has_member (obj, "command") && NULL != (value = json_object_get_member (obj, "command")) && JSON_NODE_HOLDS_VALUE (value)) command = json_node_get_string (value); /* Ignore items that are missing something or other */ if (file == NULL || command == NULL || directory == NULL) continue; /* Try to reduce the number of GFile we have for directories */ if (NULL == (dir = g_hash_table_lookup (directories_by_path, directory))) { dir = g_file_new_for_path (directory); g_hash_table_insert (directories_by_path, (gchar *)directory, dir); } info = g_slice_new (CompileInfo); info->file = g_file_resolve_relative_path (dir, file); info->directory = g_object_ref (dir); info->command = g_strdup (command); g_hash_table_replace (info_by_file, info->file, info); /* * We might need to keep a special copy of this for resolving .vala * builds which won't be able ot be matched based on the filename. We * keep all of them around right now in case we want to later on find * the closest match based on directory. */ if (g_str_has_suffix (file, ".vala")) { info = g_slice_new (CompileInfo); info->file = g_file_resolve_relative_path (dir, file); info->directory = g_object_ref (dir); info->command = g_strdup (command); g_ptr_array_add (vala_info, info); } } self->info_by_file = g_steal_pointer (&info_by_file); self->vala_info = g_steal_pointer (&vala_info); g_task_return_boolean (task, TRUE); IDE_EXIT; }
END_TEST START_TEST(test_anitomy_parser_sample_data) { AnitomyElements* elements; JsonObject* data = json_array_get_object_element(sample_array, _i); const char* fname; fname = json_object_get_string_member(data, "file_name"); anitomy_parse(anitomy, fname); elements = anitomy_elements(anitomy); //TODO: Handle arrays if (json_object_has_member(data, "anime_title")) { const char* actual = json_object_get_string_member(data, "anime_title"); char* parsed = anitomy_elements_get(elements, ANITOMY_ELEMENT_ANIME_TITLE); ck_assert_msg(strcmp(actual, parsed) == 0, "Failed anime title: actual = %s, parsed = %s, filename = %s", actual, parsed, fname); free(parsed); } if (json_object_has_member(data, "file_checksum")) { const char* actual = json_object_get_string_member(data, "file_checksum"); char* parsed = anitomy_elements_get(elements, ANITOMY_ELEMENT_FILE_CHECKSUM); ck_assert_msg(strcmp(actual, parsed) == 0, "Failed file checksum: actual = %s, parsed = %s, filename = %s", actual, parsed, fname); free(parsed); } if (json_object_has_member(data, "file_extension")) { const char* actual = json_object_get_string_member(data, "file_extension"); char* parsed = anitomy_elements_get(elements, ANITOMY_ELEMENT_FILE_EXTENSION); ck_assert_msg(strcmp(actual, parsed) == 0, "Failed file extension: actual = %s, parsed = %s, filename = %s", actual, parsed, fname); free(parsed); } if (json_object_has_member(data, "release_group") && !JSON_NODE_HOLDS_ARRAY(json_object_get_member(data, "release_group"))) { const char* actual = json_object_get_string_member(data, "release_group"); char* parsed = anitomy_elements_get(elements, ANITOMY_ELEMENT_RELEASE_GROUP); ck_assert_msg(strcmp(actual, parsed) == 0, "Failed release group: actual = %s, parsed = %s, filename = %s", actual, parsed, fname); free(parsed); } if (json_object_has_member(data, "anime_year")) { const char* actual = json_object_get_string_member(data, "anime_year"); char* parsed = anitomy_elements_get(elements, ANITOMY_ELEMENT_ANIME_YEAR); ck_assert_msg(strcmp(actual, parsed) == 0, "Failed anime year: actual = %s, parsed = %s, filename = %s", actual, parsed, fname); free(parsed); } if (json_object_has_member(data, "episode_title")) { const char* actual = json_object_get_string_member(data, "episode_title"); char* parsed = anitomy_elements_get(elements, ANITOMY_ELEMENT_EPISODE_TITLE); ck_assert_msg(strcmp(actual, parsed) == 0, "Failed episode title: actual = %s, parsed = %s, filename = %s", actual, parsed, fname); free(parsed); } if (json_object_has_member(data, "video_resolution")) { const char* actual = json_object_get_string_member(data, "video_resolution"); char* parsed = anitomy_elements_get(elements, ANITOMY_ELEMENT_VIDEO_RESOLUTION); ck_assert_msg(strcmp(actual, parsed) == 0, "Failed video resolution: actual = %s, parsed = %s, filename = %s", actual, parsed, fname); free(parsed); } if (json_object_has_member(data, "source")) { const char* actual = json_object_get_string_member(data, "source"); char* parsed = anitomy_elements_get(elements, ANITOMY_ELEMENT_SOURCE); ck_assert_msg(strcmp(actual, parsed) == 0, "Failed source: actual = %s, parsed = %s, filename = %s", actual, parsed, fname); free(parsed); } if (json_object_has_member(data, "audio_term") && !JSON_NODE_HOLDS_ARRAY(json_object_get_member(data, "audio_term"))) { const char* actual = json_object_get_string_member(data, "audio_term"); char* parsed = anitomy_elements_get(elements, ANITOMY_ELEMENT_AUDIO_TERM); ck_assert_msg(strcmp(actual, parsed) == 0, "Failed audio term: actual = %s, parsed = %s, filename = %s", actual, parsed, fname); free(parsed); } if (json_object_has_member(data, "video_term") && !JSON_NODE_HOLDS_ARRAY(json_object_get_member(data, "video_term"))) { const char* actual = json_object_get_string_member(data, "video_term"); char* parsed = anitomy_elements_get(elements, ANITOMY_ELEMENT_VIDEO_TERM); ck_assert_msg(strcmp(actual, parsed) == 0, "Failed video term: actual = %s, parsed = %s, filename = %s", actual, parsed, fname); free(parsed); } }
static void postal_http_handle_v1_notify (UrlRouter *router, SoupServer *server, SoupMessage *message, const gchar *path, GHashTable *params, GHashTable *query, SoupClientContext *client, gpointer user_data) { PostalNotification *notif; const gchar *collapse_key = NULL; const gchar *str; PostalHttp *http = user_data; JsonObject *aps; JsonObject *c2dm; JsonObject *gcm; JsonObject *object; JsonArray *devices; JsonArray *users; GPtrArray *devices_ptr; GPtrArray *users_ptr; JsonNode *node; GError *error = NULL; guint count; guint i; g_assert(SOUP_IS_SERVER(server)); g_assert(SOUP_IS_MESSAGE(message)); g_assert(path); g_assert(client); g_assert(POSTAL_IS_HTTP(http)); if (message->method != SOUP_METHOD_POST) { soup_message_set_status(message, SOUP_STATUS_METHOD_NOT_ALLOWED); return; } soup_server_pause_message(server, message); if (!(node = postal_http_parse_body(message, &error))) { postal_http_reply_error(http, message, error); g_error_free(error); return; } if (!JSON_NODE_HOLDS_OBJECT(node) || !(object = json_node_get_object(node)) || !json_object_has_member(object, "aps") || !(node = json_object_get_member(object, "aps")) || !JSON_NODE_HOLDS_OBJECT(node) || !(aps = json_object_get_object_member(object, "aps")) || !json_object_has_member(object, "c2dm") || !(node = json_object_get_member(object, "c2dm")) || !JSON_NODE_HOLDS_OBJECT(node) || !(c2dm = json_object_get_object_member(object, "c2dm")) || !json_object_has_member(object, "gcm") || !(node = json_object_get_member(object, "gcm")) || !JSON_NODE_HOLDS_OBJECT(node) || !(gcm = json_object_get_object_member(object, "gcm")) || !json_object_has_member(object, "users") || !(node = json_object_get_member(object, "users")) || !JSON_NODE_HOLDS_ARRAY(node) || !(users = json_object_get_array_member(object, "users")) || !json_object_has_member(object, "devices") || !(node = json_object_get_member(object, "devices")) || !JSON_NODE_HOLDS_ARRAY(node) || !(devices = json_object_get_array_member(object, "devices"))) { error = g_error_new(postal_json_error_quark(), 0, "Missing or invalid fields in JSON payload."); postal_http_reply_error(http, message, error); json_node_free(node); g_error_free(error); return; } if (json_object_has_member(object, "collapse_key") && (node = json_object_get_member(object, "collapse_key")) && JSON_NODE_HOLDS_VALUE(node)) { collapse_key = json_node_get_string(node); } notif = g_object_new(POSTAL_TYPE_NOTIFICATION, "aps", aps, "c2dm", c2dm, "collapse-key", collapse_key, "gcm", gcm, NULL); count = json_array_get_length(users); users_ptr = g_ptr_array_sized_new(count); for (i = 0; i < count; i++) { node = json_array_get_element(users, i); if (json_node_get_value_type(node) == G_TYPE_STRING) { str = json_node_get_string(node); g_ptr_array_add(users_ptr, (gchar *)str); } } g_ptr_array_add(users_ptr, NULL); count = json_array_get_length(devices); devices_ptr = g_ptr_array_sized_new(count); g_ptr_array_set_free_func(devices_ptr, g_free); for (i = 0; i < count; i++) { node = json_array_get_element(devices, i); if (json_node_get_value_type(node) == G_TYPE_STRING) { str = json_node_get_string(node); g_ptr_array_add(devices_ptr, g_strdup(str)); } } g_ptr_array_add(devices_ptr, NULL); postal_service_notify(http->priv->service, notif, (gchar **)users_ptr->pdata, (gchar **)devices_ptr->pdata, NULL, /* TODO: Cancellable/Timeout? */ postal_http_notify_cb, g_object_ref(message)); g_ptr_array_unref(devices_ptr); g_ptr_array_unref(users_ptr); json_node_free(node); g_object_unref(notif); }
static gboolean catch_resource_group_api_parse_activities (CatchResourceGroup *group, JsonNode *result, guint *result_offset, guint *n_resources, GError **error) { CatchResourceGroupPrivate *priv; CatchResource *resource; JsonObject *obj; JsonArray *array; JsonNode *element; gboolean set_first_page = FALSE; gboolean ret = FALSE; guint i; guint length; guint offset = 0; ENTRY; g_return_val_if_fail(CATCH_IS_RESOURCE_GROUP(group), FALSE); g_return_val_if_fail(result != NULL, FALSE); priv = group->priv; g_object_freeze_notify(G_OBJECT(group)); if (!JSON_NODE_HOLDS_OBJECT(result) || !(obj = json_node_get_object(result)) || !json_object_has_member(obj, "activities") || !JSON_NODE_HOLDS_ARRAY(json_object_get_member(obj, "activities")) || !(array = json_object_get_array_member(obj, "activities"))) { g_set_error(error, CATCH_API_ERROR, CATCH_API_ERROR_BAD_RESPONSE, _("The resonse was invalid.")); GOTO(failure); } if (json_object_has_member(obj, "count") && JSON_NODE_HOLDS_VALUE(json_object_get_member(obj, "count"))) { priv->count = json_object_get_int_member(obj, "count"); set_first_page = TRUE; g_object_notify_by_pspec(G_OBJECT(group), gParamSpecs[PROP_COUNT]); } if (json_object_has_member(obj, "offset") && JSON_NODE_HOLDS_VALUE(json_object_get_member(obj, "offset"))) { offset = json_object_get_int_member(obj, "offset"); } length = json_array_get_length(array); for (i = 0; i < length; i++) { element = json_array_get_element(array, i); resource = g_object_new(CATCH_TYPE_ACTIVITY, NULL); if (!catch_resource_load_from_json(resource, element, error)) { g_object_unref(resource); GOTO(failure); } catch_resource_group_set_resource(CATCH_RESOURCE_GROUP(group), offset + i, resource); g_object_unref(resource); } if (set_first_page) { priv->first_page_size = length; } if (result_offset) { *result_offset = offset; } if (n_resources) { *n_resources = length; } ret = TRUE; failure: g_object_thaw_notify(G_OBJECT(group)); RETURN(ret); }
static void push_gcm_client_deliver_cb (SoupSession *session, SoupMessage *message, gpointer user_data) { GSimpleAsyncResult *simple = user_data; const gchar *str; JsonObject *obj; JsonParser *p = NULL; JsonArray *ar; JsonNode *root; JsonNode *node; gboolean removed; GError *error = NULL; GList *list; gsize length; guint i; ENTRY; g_assert(SOUP_IS_SESSION(session)); g_assert(SOUP_IS_MESSAGE(message)); g_assert(G_IS_SIMPLE_ASYNC_RESULT(simple)); switch (message->status_code) { case SOUP_STATUS_OK: break; case SOUP_STATUS_BAD_REQUEST: /* * TODO: Log that there was a JSON encoding error likely. */ break; case SOUP_STATUS_UNAUTHORIZED: g_simple_async_result_set_error(simple, SOUP_HTTP_ERROR, message->status_code, _("GCM request unauthorized.")); GOTO(failure); default: if (SOUP_STATUS_IS_SERVER_ERROR(message->status_code) && (str = soup_message_headers_get_one(message->response_headers, "Retry-After"))) { /* * TODO: Implement exponential back-off. */ } g_simple_async_result_set_error(simple, SOUP_HTTP_ERROR, message->status_code, _("Unknown failure occurred.")); break; } if (!message->response_body->data || !message->response_body->length) { g_simple_async_result_set_error(simple, SOUP_HTTP_ERROR, SOUP_STATUS_IO_ERROR, _("No data was received from GCM.")); GOTO(failure); } p = json_parser_new(); if (!json_parser_load_from_data(p, message->response_body->data, message->response_body->length, &error)) { g_simple_async_result_take_error(simple, error); GOTO(failure); } list = g_object_get_data(G_OBJECT(simple), "identities"); if ((root = json_parser_get_root(p)) && JSON_NODE_HOLDS_OBJECT(root) && (obj = json_node_get_object(root)) && json_object_has_member(obj, "results") && (node = json_object_get_member(obj, "results")) && JSON_NODE_HOLDS_ARRAY(node) && (ar = json_node_get_array(node))) { length = json_array_get_length(ar); for (i = 0; i < length && list; i++, list = list->next) { /* * TODO: Handle the case that the device_token has been renamed. */ removed = FALSE; if ((obj = json_array_get_object_element(ar, i)) && json_object_has_member(obj, "error") && (node = json_object_get_member(obj, "error")) && JSON_NODE_HOLDS_VALUE(node) && (str = json_node_get_string(node))) { if (!g_strcmp0(str, "MissingRegistration")) { removed = TRUE; } else if (!g_strcmp0(str, "InvalidRegistration")) { removed = TRUE; } else if (!g_strcmp0(str, "MismatchSenderId")) { } else if (!g_strcmp0(str, "NotRegistered")) { removed = TRUE; } else if (!g_strcmp0(str, "MessageTooBig")) { } else if (!g_strcmp0(str, "InvalidDataKey")) { } else if (!g_strcmp0(str, "InvalidTtl")) { } if (removed) { g_assert(PUSH_IS_GCM_IDENTITY(list->data)); g_signal_emit(session, gSignals[IDENTITY_REMOVED], 0, list->data); } } } } g_simple_async_result_set_op_res_gboolean(simple, TRUE); failure: g_simple_async_result_complete_in_idle(simple); g_object_unref(simple); if (p) { g_object_unref(p); } EXIT; }
static void ide_langserv_rename_provider_rename_cb (GObject *object, GAsyncResult *result, gpointer user_data) { IdeLangservClient *client = (IdeLangservClient *)object; IdeLangservRenameProvider *self; g_autoptr(JsonNode) return_value = NULL; g_autoptr(GError) error = NULL; g_autoptr(GTask) task = user_data; g_autoptr(GPtrArray) ret = NULL; JsonObject *changes_by_uri = NULL; JsonObjectIter iter; const gchar *uri; IdeContext *context; JsonNode *changes; IDE_ENTRY; g_assert (IDE_IS_LANGSERV_CLIENT (client)); g_assert (G_IS_ASYNC_RESULT (result)); g_assert (G_IS_TASK (task)); self = g_task_get_source_object (task); g_assert (IDE_IS_LANGSERV_RENAME_PROVIDER (self)); if (!ide_langserv_client_call_finish (client, result, &return_value, &error)) { g_task_return_error (task, g_steal_pointer (&error)); IDE_EXIT; } if (!JCON_EXTRACT (return_value, "changes", JCONE_OBJECT (changes_by_uri))) IDE_EXIT; context = ide_object_get_context (IDE_OBJECT (self)); ret = g_ptr_array_new_with_free_func (g_object_unref); json_object_iter_init (&iter, changes_by_uri); while (json_object_iter_next (&iter, &uri, &changes)) { g_autoptr(GFile) gfile = g_file_new_for_uri (uri); g_autoptr(IdeFile) ifile = ide_file_new (context, gfile); JsonArray *array; guint length; if (!JSON_NODE_HOLDS_ARRAY (changes)) continue; array = json_node_get_array (changes); length = json_array_get_length (array); for (guint i = 0; i < length; i++) { JsonNode *change = json_array_get_element (array, i); g_autoptr(IdeSourceLocation) begin_location = NULL; g_autoptr(IdeSourceLocation) end_location = NULL; g_autoptr(IdeSourceRange) range = NULL; g_autoptr(IdeProjectEdit) edit = NULL; const gchar *new_text = NULL; gboolean success; struct { gint line; gint column; } begin, end; success = JCON_EXTRACT (change, "range", "{", "start", "{", "line", JCONE_INT (begin.line), "character", JCONE_INT (begin.column), "}", "end", "{", "line", JCONE_INT (end.line), "character", JCONE_INT (end.column), "}", "}", "newText", JCONE_STRING (new_text) ); if (!success) continue; begin_location = ide_source_location_new (ifile, begin.line, begin.column, 0); end_location = ide_source_location_new (ifile, end.line, end.column, 0); range = ide_source_range_new (begin_location, end_location); edit = g_object_new (IDE_TYPE_PROJECT_EDIT, "range", range, "replacement", new_text, NULL); g_ptr_array_add (ret, g_steal_pointer (&edit)); } } g_task_return_pointer (task, g_steal_pointer (&ret), (GDestroyNotify)g_ptr_array_unref); IDE_EXIT; }