melange/lookingGlass: better object inspection

itzexor · itzexor · commit af68bf901ece · 2018-10-29T16:01:38.000-07:00
Reworks object parsing code so that we can inspect more types,
present the information more clearly, and prevents misbehavior
with types we shouldn't iterate like importers and other special
objects.

Notable behavior changes:
 - Boxed instance proxies such as Clutter.Color, Clutter.Rect, etc
   are now inspectable like other objects.

 - Inspecting or calling Eval() on non-iterable types no longer
   freezes up or shows warnings.

 - Errors during command eval() are now inspectable.
diff --git a/files/usr/share/cinnamon/cinnamon-looking-glass/page_inspect.py b/files/usr/share/cinnamon/cinnamon-looking-glass/page_inspect.py
@@ -3,6 +3,14 @@
 import pageutils
 from gi.repository import Gtk
 
+# keep in sync with lookingGlass.js
+NON_INSPECTABLE_TYPES = [
+    "null",
+    "undefined",
+    "importer",
+    "gimporter"
+]
+
 class InspectView(pageutils.BaseListView):
     def __init__(self, parent):
         self.parent = parent
@@ -124,7 +132,7 @@ def pushInspectionElement(self):
             self.insert.set_sensitive(True)
 
     def updateInspector(self, path, objType, name, value, pushToStack=False):
-        if objType == "object":
+        if objType not in NON_INSPECTABLE_TYPES:
             if pushToStack:
                 self.pushInspectionElement()
 
diff --git a/js/ui/lookingGlass.js b/js/ui/lookingGlass.js
@@ -5,6 +5,7 @@ const Clutter = imports.gi.Clutter;
 const Cogl = imports.gi.Cogl;
 const Gio = imports.gi.Gio;
 const GLib = imports.gi.GLib;
+const GObject = imports.gi.GObject;
 const Lang = imports.lang;
 const Meta = imports.gi.Meta;
 const Signals = imports.signals;
@@ -36,13 +37,126 @@ var commandHeader = 'const Clutter = imports.gi.Clutter; ' +
                     'const r = Lang.bind(Main.lookingGlass, Main.lookingGlass.getResult); ';
 
 const HISTORY_KEY = 'looking-glass-history';
-function objectToString(o) {
-    if (typeof(o) == typeof(objectToString)) {
-        // special case this since the default is way, way too verbose
-        return '<js function>';
-    } else {
-        return '' + o;
+
+/* looking glass types:
+ *
+ * We use a couple of custom type strings in addition to normal js type strings(from typeof):
+ *  -"array": for objects which pass Array.isArray() and should only show indexed properties
+ *  -"delegate": objects with an 'actor' property pointing to an st/clutter actor
+ *  -"importer": importer objects like "imports" which shouldn't be probed
+ *  -"gimporter": "imports.gi" object
+ *  -"boxed": structs and other non-gobject c data types
+ *  -"gobject": gobjects
+ *  -"unknown": unidentifiable c object
+ */
+
+// types with no properties or import files on get()
+const NON_INSPECTABLE_TYPES = [
+    "null",
+    "undefined",
+    "importer",
+    "gimporter"
+];
+
+// not in use
+const IGNORE_PROPERTIES = [
+    "toString",
+    "constructor"
+];
+
+// returns [typeString, valueString] for any object
+function getObjInfo(o) {
+    let type, value;
+    if (o === null) {
+        type = "null";
+        value = "[" + type + "]";
+    } else if (o === undefined) {
+        type = "undefined";
+        value = "[" + type + "]";
+    }
+
+    if (!value) {
+        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 as 'this'
+                value = GObject.Object.prototype.toString.call(o);
+            } else {
+                value = "[error getting value]";
+            }
+        }
+        if (value.startsWith("[object Object delegate for")) {
+            type = "delegate";
+        } else if (value.includes("CinnamonGenericContainer")) {
+            type = "gobject";
+        } else if (value.includes("GIName:")) {
+            try {
+                type = value.match(/\[(.+) (?:instance proxy|prototype of) GIName:.+\]/)[1];
+                if (type === "object")
+                    type = "gobject";
+            } catch (e) {
+                type = "unknown";
+            }
+        } else if (value.startsWith("[GjsFileImporter")) {
+            type = "importer";
+        } else if (value.includes("GjsModule")) {
+            if (value === "[object GjsModule gi]")
+                type = "gimporter";
+            else
+                type = "module";
+        } else if (Array.isArray(o)) {
+            type = "array";
+        } else {
+            type = typeof(o);
+        }
     }
+
+    if (value === "")
+        value = "[empty]";
+
+    return [type, value];
+}
+
+function getObjKeysInfo(obj) {
+    let [type, ] = getObjInfo(obj);
+    if (NON_INSPECTABLE_TYPES.includes(type))
+        return [];
+
+    let keys = new Set();
+    let curProto = obj;
+
+    // we ignore the Object prototype for everything except basic objects,
+    // to skip the common object properties unless we can't avoid it
+    while (curProto && (type === "object" || curProto !== Object.prototype)) {
+        let ownKeys;
+        if (type === "array") {
+            ownKeys = curProto.keys(); // index properties only
+        } else {
+            ownKeys = Reflect.ownKeys(curProto); // all own properties and symbols
+        }
+
+        for (let key of ownKeys)
+            keys.add(key);
+
+        curProto = Object.getPrototypeOf(curProto);
+    }
+
+    return Array.from(keys).map((k) => {
+        let [t, v] = getObjInfo(obj[k]);
+        return { name: k.toString(), type: t, value: v, shortValue: v.split(`\n`)[0] }
+    });
+}
+
+function tryEval(js) {
+    let out;
+    try {
+        out = eval(js);
+    } catch (e) {
+        out = e;
+    }
+    return out;
 }
 
 function WindowList() {
@@ -93,13 +207,13 @@ WindowList.prototype = {
 
             let lgInfo = {
                 id: metaWindow._lgId.toString(),
-                title: objectToString(metaWindow.title),
-                wmclass: objectToString(metaWindow.get_wm_class()),
+                title: metaWindow.title + '',
+                wmclass: metaWindow.get_wm_class() + '',
                 app: '' };
 
             let app = tracker.get_window_app(metaWindow);
             if (app != null && !app.is_window_backed()) {
-                lgInfo.app = objectToString(app.get_id());
+                lgInfo.app = app.get_id() + '';
             } else {
                 lgInfo.app = '<untracked>';
             }
@@ -454,43 +568,18 @@ Melange.prototype = {
     _pushResult: function(command, obj, tooltip) {
         let index = this._results.length;
         let result = {"o": obj, "index": index};
-        this.rawResults.push({command: command, type: typeof(obj), object: objectToString(obj), index: index.toString(), tooltip: tooltip});
+        let [type, value] = getObjInfo(obj);
+        this.rawResults.push({command: command, type: type, object: value, index: index.toString(), tooltip: tooltip});
         this.emitResultUpdate();
-
+        
         this._results.push(result);
         this._it = obj;
     },
 
     inspect: function(path) {
         let fullCmd = commandHeader + path;
-
-        let result = eval(fullCmd);
-        let resultObj = [];
-        for (let key in result) {
-            let type = typeof(result[key]);
-
-            //fixme: move this shortvalue stuff to python lg
-            let shortValue, value;
-            if (type === "undefined") {
-                value = "";
-                shortValue = "";
-            } else if (result[key] === null) {
-                value = "[null]";
-                shortValue = value;
-            } else {
-                value = result[key].toString();
-                shortValue = value;
-                let i = value.indexOf('\n');
-                let j = value.indexOf('\r');
-                if (j != -1 && (i == -1 || i > j))
-                    i = j;
-                if (i != -1)
-                    shortValue = value.substr(0, i) + '.. <more>';
-            }
-            resultObj.push({ name: key, type: type, value: value, shortValue: shortValue});
-        }
-
-        return resultObj;
+        let result = tryEval(fullCmd);
+        return getObjKeysInfo(result);
     },
 
     getIt: function () {
@@ -519,24 +608,14 @@ Melange.prototype = {
         this._history.addItem(command);
 
         let fullCmd = commandHeader + command;
-
-        let resultObj;
-
         let ts = GLib.get_monotonic_time();
 
-        try {
-            resultObj = eval(fullCmd);
-        } catch (e) {
-            resultObj = '<exception ' + e + '>';
-        }
+        let resultObj = tryEval(fullCmd);
 
         let ts2 = GLib.get_monotonic_time();
-
         let tooltip = _("Execution time (ms): ") + (ts2 - ts) / 1000;
 
         this._pushResult(command, resultObj, tooltip);
-
-        return;
     },
 
     // DBus function
@@ -547,14 +626,7 @@ Melange.prototype = {
     // DBus function
     AddResult: function(path) {
         let fullCmd = commandHeader + path;
-
-        let resultObj;
-        try {
-            resultObj = eval(fullCmd);
-        } catch (e) {
-            resultObj = '<exception ' + e + '>';
-        }
-        this._pushResult(path, resultObj, "");
+        this._pushResult(path, tryEval(fullCmd), "");
     },
 
     // DBus function
