v.net: Add JSON output support

vector/CMakeLists.txt

@@ -431,6 +431,7 @@ build_program_in_subdir(
   grass_dbmidriver
   grass_gis
   grass_vector
+  grass_parson
   ${LIBM})
 
 build_program_in_subdir(

vector/v.net/Makefile

@@ -3,7 +3,7 @@ MODULE_TOPDIR = ../..
 
 PGM=v.net
 
-LIBES = $(VECTORLIB) $(GISLIB) $(DBMILIB)
+LIBES = $(VECTORLIB) $(GISLIB) $(DBMILIB) $(PARSONLIB)
 DEPENDENCIES = $(VECTORDEP) $(GISDEP) $(DBMIDEP)
 EXTRA_INC = $(VECT_INC)
 EXTRA_CFLAGS = $(VECT_CFLAGS)

vector/v.net/args.c

@@ -9,6 +9,16 @@ void define_options(struct opt *opt)
 {
     char *desc;
 
+    opt->format = G_define_standard_option(G_OPT_F_FORMAT);
+    opt->format->key = "format";
+    if (!opt->format->description)
+        opt->format->description = _("Output format");
+    opt->format->descriptions = _("plain;Human readable text output;"
+                                  "json;JSON (JavaScript Object Notation)");
+    opt->format->options = "plain,json";
+    opt->format->answer = "plain";
+    opt->format->guisection = _("Print");
+
     opt->input = G_define_standard_option(G_OPT_V_INPUT);
     opt->input->required = NO;
     opt->input->label = _("Name of input vector line map (arcs)");
@@ -123,7 +133,7 @@ void define_options(struct opt *opt)
 }
 
 void parse_arguments(const struct opt *opt, int *afield, int *nfield,
-                     double *thresh, int *act)
+                     double *thresh, int *act, enum OutputFormat *format)
 {
     *afield = atoi(opt->afield_opt->answer);
     *nfield = atoi(opt->nfield_opt->answer);
@@ -144,6 +154,13 @@ void parse_arguments(const struct opt *opt, int *afield, int *nfield,
     else
         G_fatal_error(_("Unknown operation"));
 
+    if (strcmp(opt->format->answer, "json") == 0) {
+        *format = FORMAT_JSON;
+    }
+    else {
+        *format = FORMAT_PLAIN;
+    }
+
     if (*act == TOOL_NODES || *act == TOOL_CONNECT || *act == TOOL_REPORT ||
         *act == TOOL_NREPORT || *act == TOOL_TURNTABLE) {
         if (opt->input->answer == NULL)

vector/v.net/main.c

@@ -24,6 +24,7 @@
 #include <grass/vector.h>
 #include <grass/glocale.h>
 #include "proto.h"
+#include <grass/gjson.h>
 
 int main(int argc, char **argv)
 {
@@ -32,10 +33,10 @@ int main(int argc, char **argv)
     struct Map_info *In = NULL, *Out = NULL, *Points = NULL;
 
     FILE *file_arcs;
-
     int afield, nfield;
     int act;
     double thresh;
+    enum OutputFormat format;
 
     char message[4096];
 
@@ -53,7 +54,7 @@ int main(int argc, char **argv)
     if (G_parser(argc, argv))
         exit(EXIT_FAILURE);
 
-    parse_arguments(&opt, &afield, &nfield, &thresh, &act);
+    parse_arguments(&opt, &afield, &nfield, &thresh, &act, &format);
 
     In = Points = Out = NULL;
     file_arcs = NULL;
@@ -172,7 +173,7 @@ int main(int argc, char **argv)
         turntable(&opt);
     }
     else { /* report */
-        report(In, afield, nfield, act);
+        report(In, afield, nfield, act, format);
     }
 
     if (In)

vector/v.net/proto.h

@@ -13,14 +13,18 @@ struct opt {
     struct Option *file;
     struct Option *type;
     struct Flag *cats_flag, *snap_flag;
+    struct Option *format;
 };
 
+enum OutputFormat { FORMAT_PLAIN, FORMAT_JSON };
+
 /* arcs.c */
 int create_arcs(FILE *, struct Map_info *, struct Map_info *, int, int);
 
 /* argc.c */
 void define_options(struct opt *);
-void parse_arguments(const struct opt *, int *, int *, double *, int *);
+void parse_arguments(const struct opt *, int *, int *, double *, int *,
+                     enum OutputFormat *);
 
 /* connect.c */
 int connect_arcs(struct Map_info *, struct Map_info *, struct Map_info *, int,
@@ -30,6 +34,6 @@ int connect_arcs(struct Map_info *, struct Map_info *, struct Map_info *, int,
 int nodes(struct Map_info *, struct Map_info *, int, int);
 
 /* report.c */
-int report(struct Map_info *, int, int, int);
+int report(struct Map_info *, int, int, int, enum OutputFormat);
 
 void turntable(struct opt *);

vector/v.net/report.c

@@ -3,8 +3,10 @@
 #include <grass/vector.h>
 #include <grass/glocale.h>
 #include "proto.h"
+#include <grass/gjson.h>
 
-int report(struct Map_info *In, int afield, int nfield, int action)
+int report(struct Map_info *In, int afield, int nfield, int action,
+           enum OutputFormat format)
 {
     int i, j, line, nlines, ltype, node, nnodes;
     int cat_line, cat_node[2];
@@ -24,6 +26,14 @@ int report(struct Map_info *In, int afield, int nfield, int action)
     if (action == TOOL_REPORT) {
         struct boxlist *List;
 
+        G_JSON_Value *root_value = NULL;
+        G_JSON_Array *root_array = NULL;
+
+        if (format == FORMAT_JSON) {
+            root_value = G_json_value_init_array();
+            root_array = G_json_array(root_value);
+        }
+
         List = Vect_new_boxlist(0);
 
         /* For all lines find categories for points on nodes */
@@ -67,8 +77,32 @@ int report(struct Map_info *In, int afield, int nfield, int action)
                     G_warning(_("%d points found: %g %g %g line category: %d"),
                               nnodes, x, y, z, cat_line);
             }
-            fprintf(stdout, "%d %d %d\n", cat_line, cat_node[0], cat_node[1]);
+            if (format == FORMAT_JSON) {
+                G_JSON_Value *item_value = G_json_value_init_object();
+                G_JSON_Object *item_obj = G_json_object(item_value);
+
+                G_json_object_set_number(item_obj, "line_cat", cat_line);
+                G_json_object_set_number(item_obj, "start_node_cat",
+                                         cat_node[0]);
+                G_json_object_set_number(item_obj, "end_node_cat", cat_node[1]);
+
+                G_json_array_append_value(root_array, item_value);
+            }
+            else {
+                fprintf(stdout, "%d %d %d\n", cat_line, cat_node[0],
+                        cat_node[1]);
+            }
         }
+
+        if (format == FORMAT_JSON) {
+            char *json_str = G_json_serialize_to_string_pretty(root_value);
+            if (json_str) {
+                fprintf(stdout, "%s\n", json_str);
+            }
+            G_json_free_serialized_string(json_str);
+            G_json_value_free(root_value);
+        }
+
         Vect_destroy_boxlist(List);
     }
     else { /* node report */
@@ -77,6 +111,14 @@ int report(struct Map_info *In, int afield, int nfield, int action)
 
         List = Vect_new_list();
 
+        G_JSON_Value *root_val = NULL;
+        G_JSON_Array *root_arr = NULL;
+
+        if (format == FORMAT_JSON) {
+            root_val = G_json_value_init_array();
+            root_arr = G_json_array(root_val);
+        }
+
         for (i = 1; i <= nlines; i++) {
 
             if (Vect_get_line_type(In, i) != GV_POINT)
@@ -102,9 +144,19 @@ int report(struct Map_info *In, int afield, int nfield, int action)
                 for (j = 0; j < Cats->n_cats; j++) {
                     if (Cats->field[j] == nfield) {
                         int count = 0;
-
-                        fprintf(stdout, "%d ", Cats->cat[j]);
-
+                        G_JSON_Value *item_val =
+                            root_arr ? G_json_value_init_object() : NULL;
+                        G_JSON_Value *lines_val =
+                            root_arr ? G_json_value_init_array() : NULL;
+
+                        if (format == FORMAT_JSON) {
+                            G_json_object_set_number(
+                                G_json_value_get_object(item_val), "node_cat",
+                                Cats->cat[j]);
+                        }
+                        else {
+                            fprintf(stdout, "%d ", Cats->cat[j]);
+                        }
                         /* Loop through all lines */
                         for (k = 0; k < nelem; k++) {
                             elem = abs(Vect_get_node_line(In, node, k));
@@ -115,19 +167,39 @@ int report(struct Map_info *In, int afield, int nfield, int action)
                             /* Loop through all cats of line */
                             for (l = 0; l < Cats2->n_cats; l++) {
                                 if (Cats2->field[l] == afield) {
-                                    if (count > 0)
-                                        fprintf(stdout, ",");
-
-                                    fprintf(stdout, "%d", Cats2->cat[l]);
-                                    count++;
+                                    if (format == FORMAT_JSON)
+                                        G_json_array_append_number(
+                                            G_json_array(lines_val),
+                                            Cats2->cat[l]);
+                                    else {
+                                        if (count > 0)
+                                            fprintf(stdout, ",");
+                                        fprintf(stdout, "%d", Cats2->cat[l]);
+                                        count++;
+                                    }
                                 }
                             }
                         }
-                        fprintf(stdout, "\n");
+                        if (format == FORMAT_JSON) {
+                            G_json_object_set_value(
+                                G_json_value_get_object(item_val), "lines",
+                                lines_val);
+                            G_json_array_append_value(root_arr, item_val);
+                        }
+                        else
+                            fprintf(stdout, "\n");
                     }
                 }
             }
         }
+        if (format == FORMAT_JSON) {
+            char *s = G_json_serialize_to_string_pretty(root_val);
+            if (s) {
+                fprintf(stdout, "%s\n", s);
+                G_json_free_serialized_string(s);
+            }
+            G_json_value_free(root_val);
+        }
         Vect_destroy_list(List);
     }
     Vect_destroy_cats_struct(Cats);

vector/v.net/testsuite/test_v_net.py

@@ -1,16 +1,72 @@
 from grass.gunittest.case import TestCase
 from grass.gunittest.main import test
 from grass.script.core import read_command
+from grass.gunittest.gmodules import SimpleModule
+import json
 
 
 class TestVNet(TestCase):
     network = "test_vnet"
 
     def tearDown(self):
         """Remove viewshed map after each test method"""
-        # TODO: eventually, removing maps should be handled through testing framework functions
         self.runModule("g.remove", flags="f", type="vector", name=self.network)
 
+    def test_nreport_json_output(self):
+        """Verify that v.net nreport produces valid and accurate JSON output"""
+        self.runModule(
+            "v.net",
+            input="streets",
+            points="schools",
+            output=self.network,
+            operation="connect",
+            threshold=400,
+            flags="c",
+        )
+
+        vnet_module = SimpleModule(
+            "v.net",
+            input=self.network,
+            operation="nreport",
+            node_layer=2,
+            format="json",
+        )
+        self.assertModule(vnet_module)
+
+        actual_output = json.loads(vnet_module.outputs.stdout)
+
+        self.assertIsInstance(actual_output, list)
+        self.assertGreater(len(actual_output), 0, "The JSON output list is empty")
+
+        expected_keys = {"node_cat", "lines"}
+        self.assertEqual(set(actual_output[0].keys()), expected_keys)
+        self.assertIsInstance(actual_output[0]["node_cat"], int)
+        self.assertIsInstance(actual_output[0]["lines"], list)
+
+    def test_report_json_output(self):
+        """Verify that v.net report produces valid and accurate JSON output"""
+        vnet_module = SimpleModule(
+            "v.net",
+            input="streets_net",
+            operation="report",
+            arc_layer=1,
+            node_layer=2,
+            format="json",
+        )
+        self.assertModule(vnet_module)
+
+        actual_output = json.loads(vnet_module.outputs.stdout)
+
+        self.assertIsInstance(actual_output, list)
+        self.assertGreater(len(actual_output), 0, "The JSON output list is empty")
+
+        expected_keys = {"line_cat", "start_node_cat", "end_node_cat"}
+        self.assertEqual(set(actual_output[0].keys()), expected_keys)
+
+        for entry in actual_output[:10]:
+            for key in expected_keys:
+                self.assertIsInstance(entry[key], int)
+
     def test_nodes(self):
         """Test"""
         self.assertModule(