Expansion depth should be stable across updates

packages/perspective-viewer-hypergrid/src/js/PerspectiveDataModel.js

@@ -70,10 +70,10 @@ module.exports = require("datasaur-local").extend("PerspectiveDataModel", {
                     if (this.data[row][col].rowPath.length === 1) {
                         this._view.collapse(row);
                     } else {
-                        this._view.collapse_to_depth(this.data[row][col].rowPath.length - 2);
+                        this._view.set_depth(this.data[row][col].rowPath.length - 2);
                     }
                 } else {
-                    this._view.expand_to_depth(this.data[row][col].rowPath.length - 1);
+                    this._view.set_depth(this.data[row][col].rowPath.length - 1);
                 }
             } else {
                 if (is_expanded) {

packages/perspective-viewer-hypergrid/test/js/superstore.spec.js

@@ -33,7 +33,7 @@ utils.with_server({}, () => {
                 await page.waitForSelector("perspective-viewer:not([updating])");
 
                 await page.evaluate(element => {
-                    element.view.collapse_to_depth(0);
+                    element.view.set_depth(0);
                     element.notifyResize();
                 }, viewer);
                 await page.waitForSelector("perspective-viewer:not([updating])");

packages/perspective/src/js/api.js

@@ -69,9 +69,7 @@ view.prototype.num_columns = async_queue("num_columns");
 
 view.prototype.num_rows = async_queue("num_rows");
 
-view.prototype.expand_to_depth = async_queue("expand_to_depth");
-
-view.prototype.collapse_to_depth = async_queue("collapse_to_depth");
+view.prototype.set_depth = async_queue("set_depth");
 
 view.prototype.get_row_expanded = async_queue("get_row_expanded");
 

packages/perspective/src/js/perspective.js

@@ -797,37 +797,21 @@ module.exports = function(Module) {
     };
 
     /**
-     * Expand the tree down to `depth`.
+     * Set expansion `depth` pf the pivot tree.
      *
      */
-    view.prototype.expand_to_depth = async function(depth) {
+    view.prototype.set_depth = async function(depth) {
         if (this.config.row_pivot.length >= depth) {
             if (this.nsides === 2) {
-                return this.ctx.expand_to_depth(__MODULE__.t_header.HEADER_ROW, depth);
+                return this.ctx.set_depth(__MODULE__.t_header.HEADER_ROW, depth);
             } else {
-                return this.ctx.expand_to_depth(depth);
+                return this.ctx.set_depth(depth);
             }
         } else {
             console.warn(`Cannot expand past ${this.config.row_pivot.length}`);
         }
     };
 
-    /**
-     * Collapse the tree down to `depth`.
-     *
-     */
-    view.prototype.collapse_to_depth = async function(depth) {
-        if (this.config.row_pivot.length >= depth) {
-            if (this.nsides === 2) {
-                return this.ctx.collapse_to_depth(__MODULE__.t_header.HEADER_ROW, depth);
-            } else {
-                return this.ctx.collapse_to_depth(depth);
-            }
-        } else {
-            console.warn(`Cannot collapse past ${this.config.row_pivot.length}`);
-        }
-    };
-
     /**
      * Register a callback with this {@link view}.  Whenever the {@link view}'s
      * underlying table emits an update, this callback will be invoked with the
@@ -1247,15 +1231,15 @@ module.exports = function(Module) {
                 this.pool.register_context(this.gnode.get_id(), name, __MODULE__.t_ctx_type.TWO_SIDED_CONTEXT, context.$$.ptr);
 
                 if (config.row_pivot_depth !== undefined) {
-                    context.expand_to_depth(__MODULE__.t_header.HEADER_ROW, config.row_pivot_depth - 1);
+                    context.set_depth(__MODULE__.t_header.HEADER_ROW, config.row_pivot_depth - 1);
                 } else {
-                    context.expand_to_depth(__MODULE__.t_header.HEADER_ROW, config.row_pivot.length);
+                    context.set_depth(__MODULE__.t_header.HEADER_ROW, config.row_pivot.length);
                 }
 
                 if (config.column_pivot_depth !== undefined) {
-                    context.expand_to_depth(__MODULE__.t_header.HEADER_COLUMN, config.column_pivot_depth - 1);
+                    context.set_depth(__MODULE__.t_header.HEADER_COLUMN, config.column_pivot_depth - 1);
                 } else {
-                    context.expand_to_depth(__MODULE__.t_header.HEADER_COLUMN, config.column_pivot.length);
+                    context.set_depth(__MODULE__.t_header.HEADER_COLUMN, config.column_pivot.length);
                 }
 
                 const groups = context.unity_get_column_count() / aggregates.length;
@@ -1276,9 +1260,9 @@ module.exports = function(Module) {
                 this.pool.register_context(this.gnode.get_id(), name, __MODULE__.t_ctx_type.ONE_SIDED_CONTEXT, context.$$.ptr);
 
                 if (config.row_pivot_depth !== undefined) {
-                    context.expand_to_depth(config.row_pivot_depth - 1);
+                    context.set_depth(config.row_pivot_depth - 1);
                 } else {
-                    context.expand_to_depth(config.row_pivot.length);
+                    context.set_depth(config.row_pivot.length);
                 }
             }
         } else {

packages/perspective/test/js/updates.js

@@ -359,6 +359,28 @@ module.exports = perspective => {
             table.update(data_2);
         });
 
+        it("update with depth expansion", async function() {
+            var table = perspective.table(meta, {index: "y"});
+            var view = table.view({
+                row_pivot: ["z", "y"],
+                aggregate: []
+            });
+            table.update(data);
+
+            let result = await view.to_json();
+
+            let expected = [
+                {__ROW_PATH__: []},
+                {__ROW_PATH__: [false]},
+                {__ROW_PATH__: [false, "b"]},
+                {__ROW_PATH__: [false, "d"]},
+                {__ROW_PATH__: [true]},
+                {__ROW_PATH__: [true, "a"]},
+                {__ROW_PATH__: [true, "c"]}
+            ];
+            expect(expected).toEqual(result);
+        });
+
         it("partial update", function(done) {
             var partial = [{x: 5, y: "a"}, {y: "b", z: true}];
             var expected = [{x: 5, y: "a", z: true}, {x: 2, y: "b", z: true}, {x: 3, y: "c", z: true}, {x: 4, y: "d", z: false}];

src/cpp/context_grouped_pkey.cpp

@@ -17,13 +17,17 @@
 #include <perspective/sparse_tree_node.h>
 #include <perspective/logtime.h>
 #include <perspective/traversal.h>
+#include <perspective/env_vars.h>
 #include <perspective/filter_utils.h>
 #include <queue>
 #include <tuple>
 #include <unordered_set>
 
 namespace perspective {
 
+t_ctx_grouped_pkey::t_ctx_grouped_pkey()
+  : m_depth_set(false), m_depth(0) {}
+
 t_ctx_grouped_pkey::~t_ctx_grouped_pkey() {}
 
 void
@@ -69,22 +73,32 @@ t_index
 t_ctx_grouped_pkey::open(t_tvidx idx) {
     PSP_TRACE_SENTINEL();
     PSP_VERBOSE_ASSERT(m_init, "touching uninited object");
+    // If we manually open/close a node, stop automatically expanding
+    m_depth_set = false;
+    m_depth = 0;
+
     if (idx >= t_tvidx(m_traversal->size()))
         return 0;
 
-    m_rows_changed = true;
-    return m_traversal->expand_node(m_sortby, idx);
+    t_index retval = m_traversal->expand_node(m_sortby, idx);
+    m_rows_changed = (retval > 0);
+    return retval;
 }
 
 t_index
 t_ctx_grouped_pkey::close(t_tvidx idx) {
     PSP_TRACE_SENTINEL();
     PSP_VERBOSE_ASSERT(m_init, "touching uninited object");
+    // If we manually open/close a node, stop automatically expanding
+    m_depth_set = false;
+    m_depth = 0;
+
     if (idx >= t_tvidx(m_traversal->size()))
         return 0;
 
-    m_rows_changed = true;
-    return m_traversal->collapse_node(idx);
+    t_index retval = m_traversal->collapse_node(idx);
+    m_rows_changed = (retval > 0);
+    return retval;
 }
 
 t_tscalvec
@@ -172,6 +186,10 @@ t_ctx_grouped_pkey::step_end() {
     PSP_TRACE_SENTINEL();
     PSP_VERBOSE_ASSERT(m_init, "touching uninited object");
     m_minmax = m_tree->get_min_max();
+    sort_by(m_sortby);
+    if (m_depth_set) {
+        set_depth(m_depth);
+    }
 }
 
 t_aggspecvec
@@ -258,18 +276,15 @@ t_ctx_grouped_pkey::sort_by(const t_sortsvec& sortby) {
 }
 
 void
-t_ctx_grouped_pkey::expand_to_depth(t_depth depth) {
-    PSP_TRACE_SENTINEL();
-    PSP_VERBOSE_ASSERT(m_init, "touching uninited object");
-    t_depth expand_depth = std::min<t_depth>(m_config.get_num_rpivots() - 1, depth);
-    m_traversal->expand_to_depth(m_sortby, expand_depth);
-}
-
-void
-t_ctx_grouped_pkey::collapse_to_depth(t_depth depth) {
+t_ctx_grouped_pkey::set_depth(t_depth depth) {
     PSP_TRACE_SENTINEL();
     PSP_VERBOSE_ASSERT(m_init, "touching uninited object");
-    m_traversal->collapse_to_depth(depth);
+    t_depth final_depth = std::min<t_depth>(m_config.get_num_rpivots() - 1, depth);
+    t_index retval = 0;
+    retval = m_traversal->set_depth(m_sortby, final_depth);
+    m_rows_changed = (retval > 0);
+    m_depth = depth;
+    m_depth_set = true;
 }
 
 t_tscalvec
@@ -424,7 +439,13 @@ t_ctx_grouped_pkey::reset() {
 }
 
 void
-t_ctx_grouped_pkey::reset_step_state() {}
+t_ctx_grouped_pkey::reset_step_state() {
+    m_rows_changed = false;
+    m_columns_changed = false;
+    if (t_env::log_progress()) {
+        std::cout << "t_ctx_grouped_pkey.reset_step_state " << repr() << std::endl;
+    }    
+}
 
 t_streeptr_vec
 t_ctx_grouped_pkey::get_trees() {

src/cpp/context_one.cpp

@@ -22,7 +22,7 @@
 namespace perspective {
 
 t_ctx1::t_ctx1(const t_schema& schema, const t_config& pivot_config)
-    : t_ctxbase<t_ctx1>(schema, pivot_config) {}
+    : t_ctxbase<t_ctx1>(schema, pivot_config), m_depth_set(false), m_depth(0) {}
 
 t_ctx1::~t_ctx1() {}
 
@@ -69,22 +69,32 @@ t_index
 t_ctx1::open(t_tvidx idx) {
     PSP_TRACE_SENTINEL();
     PSP_VERBOSE_ASSERT(m_init, "touching uninited object");
+    // If we manually open/close a node, stop automatically expanding
+    m_depth_set = false;
+    m_depth = 0;
+
     if (idx >= t_tvidx(m_traversal->size()))
         return 0;
 
-    m_rows_changed = true;
-    return m_traversal->expand_node(m_sortby, idx);
+    t_index retval = m_traversal->expand_node(m_sortby, idx);
+    m_rows_changed = (retval > 0);
+    return retval;
 }
 
 t_index
 t_ctx1::close(t_tvidx idx) {
     PSP_TRACE_SENTINEL();
     PSP_VERBOSE_ASSERT(m_init, "touching uninited object");
+    // If we manually open/close a node, stop automatically expanding
+    m_depth_set = false;
+    m_depth = 0;
+
     if (idx >= t_tvidx(m_traversal->size()))
         return 0;
 
-    m_rows_changed = true;
-    return m_traversal->collapse_node(idx);
+    t_index retval = m_traversal->collapse_node(idx);
+    m_rows_changed = (retval > 0);
+    return retval;
 }
 
 t_tscalvec
@@ -167,6 +177,9 @@ t_ctx1::step_end() {
     PSP_VERBOSE_ASSERT(m_init, "touching uninited object");
     m_minmax = m_tree->get_min_max();
     sort_by(m_sortby);
+    if (m_depth_set) {
+        set_depth(m_depth);
+    }
 }
 
 t_aggspec
@@ -213,20 +226,17 @@ t_ctx1::sort_by(const t_sortsvec& sortby) {
 }
 
 void
-t_ctx1::expand_to_depth(t_depth depth) {
+t_ctx1::set_depth(t_depth depth) {
     PSP_TRACE_SENTINEL();
     PSP_VERBOSE_ASSERT(m_init, "touching uninited object");
     if (m_config.get_num_rpivots() == 0)
         return;
-    t_depth expand_depth = std::min<t_depth>(m_config.get_num_rpivots() - 1, depth);
-    m_traversal->expand_to_depth(m_sortby, expand_depth);
-}
-
-void
-t_ctx1::collapse_to_depth(t_depth depth) {
-    PSP_TRACE_SENTINEL();
-    PSP_VERBOSE_ASSERT(m_init, "touching uninited object");
-    m_traversal->collapse_to_depth(depth);
+    depth = std::min<t_depth>(m_config.get_num_rpivots() - 1, depth);
+    t_index retval = 0;
+    retval = m_traversal->set_depth(m_sortby, depth);
+    m_rows_changed = (retval > 0);
+    m_depth = depth;
+    m_depth_set = true;
 }
 
 t_tscalvec
@@ -359,6 +369,8 @@ t_ctx1::reset() {
 
 void
 t_ctx1::reset_step_state() {
+    m_rows_changed = false;
+    m_columns_changed = false;
     if (t_env::log_progress()) {
         std::cout << "t_ctx1.reset_step_state " << repr() << std::endl;
     }