looking-glass: better gi type inspection

looks up object keys through the GIRepository by GType.

Author: itzexor

files/usr/share/cinnamon/cinnamon-looking-glass/page_inspect.py

@@ -129,7 +129,7 @@ def pushInspectionElement(self):
             self.insert.set_sensitive(True)
 
     def updateInspector(self, path, objType, name, value, pushToStack=False):
-        if objType in ("array", "object"):
+        if objType in ("array", "object", "gobject", "gboxed"):
             if pushToStack:
                 self.pushInspectionElement()
 

js/ui/lookingGlass.js

@@ -4,6 +4,7 @@ const Cinnamon = imports.gi.Cinnamon;
 const Clutter = imports.gi.Clutter;
 const Cogl = imports.gi.Cogl;
 const Gio = imports.gi.Gio;
+const Gir = imports.gi.GIRepository;
 const GLib = imports.gi.GLib;
 const GObject = imports.gi.GObject;
 const Lang = imports.lang;
@@ -39,14 +40,24 @@ var commandHeader = 'const Clutter = imports.gi.Clutter; ' +
 const HISTORY_KEY = 'looking-glass-history';
 
 /* fake types for special cases:
- *  -"array": objects that pass Array.isArray() and should only show enumerable properties
- *  -"boxedproto": boxed prototypes throw an error on property access
- *  -"importer": objects that load modules on property access
+ *  -"array": Array() - should only show enumerable properties
+ *  -"gobject": gobject instance proxy - inspected via GIRepository
+ *  -"gboxed": gboxed instance proxy - inspected via GIRepository
+ *  -"prototype": prototypes for gobjects and gboxed objects - not inspectable
+ *  -"importer": file importers - load modules on property access,  not inspectable
  */
 
+
+// matches gi tostring patterns
+const GI_RE = /^\[(boxed|object) (instance|prototype) (?:proxy|of) GIName:([\w.]+) [^\r\n]+\]$/;
+
+// matches known importers
+const IMPORT_RE = /^\[(?:GjsFileImporter \w+|object GjsModule gi)\]$/;
+
 // returns [typeString, valueString] for any object
 function getObjInfo(o) {
     let type, value;
+
     if (o === null)
         type = "null";
     else if (o === undefined)
@@ -55,28 +66,34 @@ function getObjInfo(o) {
     if (type) {
         value = "[" + type + "]";
     } else {
-        // try to detect importers via their string representation
-        try {
-            value = o.toString();
-        } catch (e) {
-            if (e.message.includes("not an object instance - cannot convert to GObject*")) {
-                // work around Clutter.Actor.prototype.toString override not handling being
-                // called with the prototype itself as 'this'
-                value = GObject.Object.prototype.toString.call(o);
-            } else {
+        // try to detect detailed type via their string representation
+        if (o instanceof GObject.Object) {
+            // this works around Clutter.Actor.prototype.toString overrides
+            value = GObject.Object.prototype.toString.call(o);
+        } else {
+            try {
+                value = o.toString();
+            } catch (e) {
                 value = "[error getting value]";
             }
         }
 
         type = typeof(o);
-        if (type == "object") {
-            if (value.startsWith("[GjsFileImporter")
-                || value.startsWith("[object GjsModule gi")) {
+        if (type === "object") {
+            let matches = IMPORT_RE.test(value);
+            if (matches) {
                 type = "importer";
-            } else if (value.startsWith("[boxed prototype")) {
-                type = "boxedproto";
-            } else if (Array.isArray(o)) {
-                type = "array";
+            } else {
+                matches = GI_RE.exec(value);
+                if (matches) {
+                    if (matches[2] === "prototype") {
+                        type = "prototype";
+                    } else {
+                        type = `g${matches[1]}`;
+                    }
+                } else if (Array.isArray(o)) {
+                    type = "array";
+                }
             }
         }
 
@@ -90,10 +107,23 @@ function getObjInfo(o) {
 
 // returns an array of dictionaries conforming to the Inspect dbus schema
 function getObjKeysInfo(obj) {
+    let keys;
     let [type, ] = getObjInfo(obj);
-    if (!["array", "object"].includes(type))
+    if (["gobject", "gboxed"].includes(type))
+        keys = _giObjectGetKeys(obj, type);
+    else if (["array", "object"].includes(type))
+        keys = _jsObjectGetKeys(obj, type);
+    else
         return [];
 
+    return keys.map((k) => {
+        let [t, v] = getObjInfo(obj[k]);
+        return { name: k.toString(), type: t, value: v, shortValue: "" };
+    });
+}
+
+// get list of keys for js objects
+function _jsObjectGetKeys(obj, type) {
     let keys = new Set();
     let curProto = obj;
 
@@ -112,11 +142,60 @@ function getObjKeysInfo(obj) {
         curProto = Object.getPrototypeOf(curProto);
     }
 
+    return Array.from(keys);
+}
 
-    return Array.from(keys).map((k) => {
-        let [t, v] = getObjInfo(obj[k]);
-        return { name: k.toString(), type: t, value: v, shortValue: "" };
-    });
+// get list of keys for gboxed and gobject
+function _giObjectGetKeys(obj, type) {
+    let baseInfo = Gir.Repository.get_default().find_by_gtype(obj.constructor.$gtype);
+    if (type === "gboxed")
+        return _giStructInfoGetKeys(baseInfo);
+    else if (type === "gobject")
+        return _giObjectInfoGetKeys(baseInfo);
+    else
+        return [];
+}
+
+// get a list of fields and methods for a gi struct info
+function _giStructInfoGetKeys(info) {
+    let keys = [];
+    while (info) {
+        let n = Gir.struct_info_get_n_fields(info);
+        for (let i = 0; i < n; i++)
+            keys.push(Gir.struct_info_get_field(info, i).get_name());
+
+        n = Gir.struct_info_get_n_methods(info);
+        for (let i = 0; i < n; i++)
+            keys.push(Gir.struct_info_get_method(info, i).get_name());
+
+        info = Gir.object_info_get_parent(info);
+    }
+    return keys;
+}
+
+// get a list of fields and methods for a gi object info
+function _giObjectInfoGetKeys(info) {
+    let keys = [];
+    while(info) {
+        let n = Gir.object_info_get_n_constants(info);
+        for (let i = 0; i < n; i++)
+            keys.push(Gir.object_info_get_constant(info, i).get_name());
+
+        n = Gir.object_info_get_n_properties(info);
+        for (let i = 0; i < n; i++) {
+            let propInfo = Gir.object_info_get_property(info, i);
+            let flags = Gir.property_info_get_flags(propInfo);
+            if ((flags & GObject.ParamFlags.READABLE) === GObject.ParamFlags.READABLE)
+                keys.push(propInfo.get_name());
+        }
+
+        n = Gir.object_info_get_n_methods(info);
+        for (let i = 0; i < n; i++)
+            keys.push(Gir.object_info_get_method(info, i).get_name());
+
+        info = Gir.object_info_get_parent(info);
+    }
+    return keys;
 }
 
 // always returns an object we can give back to melange.