🏷 Propagate block metatags to code node and output node

packages/myst-cli/src/process/mdast.ts

@@ -46,6 +46,7 @@ import {
   transformThumbnail,
   StaticFileTransformer,
   inlineExpressionsPlugin,
+  propagateBlockDataToCode,
 } from '../transforms';
 import type { ImageExtensions } from '../utils';
 import { logMessagesFromVFile } from '../utils';
@@ -140,6 +141,9 @@ export async function transformMdast(
     .use(joinGatesPlugin)
     .run(mdast, vfile);
 
+  // This needs to come after basic transformations since meta tags are added there
+  propagateBlockDataToCode(session, file, mdast);
+
   // Run the link transformations that can be done without knowledge of other files
   const intersphinx = projectPath ? await loadIntersphinx(session, { projectPath }) : [];
   const transformers = [

packages/myst-cli/src/transforms/code.spec.ts

@@ -1,5 +1,5 @@
 import { Session } from '../session';
-import { liftCodeMetadataToBlock, metadataFromCode } from './code';
+import { liftCodeMetadataToBlock, metadataFromCode, propagateBlockDataToCode } from './code';
 
 describe('metadataFromCode', () => {
   it('empty code returns self', async () => {
@@ -114,3 +114,65 @@ describe('liftCodeMetadataToBlock', () => {
     expect(mdast.children[0].children[1].value).toEqual('print("hello world2")');
   });
 });
+
+function build_mdast_by_tags(tags: string[]) {
+  const mdast: any = {
+    type: 'root',
+    children: [
+      {
+        type: 'block',
+        children: [
+          {
+            type: 'code',
+          },
+          {
+            type: 'output',
+          },
+        ],
+        data: {
+          tags: tags,
+        },
+      },
+    ],
+  };
+  return mdast;
+}
+
+describe('propagateBlockDataToCode', () => {
+  it('single tag propagation', async () => {
+    for (const action of ['hide', 'remove']) {
+      for (const target of ['cell', 'input', 'output']) {
+        const tag = `${action}-${target}`;
+        const mdast = build_mdast_by_tags([tag]);
+        propagateBlockDataToCode(new Session(), '', mdast);
+        let result = '';
+        switch (target) {
+          case 'cell':
+            result = mdast.children[0].visibility;
+            break;
+          case 'input':
+            result = mdast.children[0].children[0].visibility;
+            break;
+          case 'output':
+            result = mdast.children[0].children[1].visibility;
+            break;
+        }
+        expect(result).toEqual(action);
+      }
+    }
+  });
+  it('multi tags propagation', async () => {
+    for (const action of [`hide`, `remove`]) {
+      const tags = [`${action}-cell`, `${action}-input`, `${action}-output`];
+      const mdast = build_mdast_by_tags(tags);
+      propagateBlockDataToCode(new Session(), '', mdast);
+      for (const node of [
+        mdast.children[0],
+        mdast.children[0].children[0],
+        mdast.children[0].children[1],
+      ]) {
+        expect(node.visibility).toEqual(action);
+      }
+    }
+  });
+});

packages/myst-cli/src/transforms/code.ts

@@ -1,6 +1,6 @@
 import type { Root } from 'mdast';
 import type { GenericNode } from 'myst-common';
-import { selectAll } from 'unist-util-select';
+import { select, selectAll } from 'unist-util-select';
 import yaml from 'js-yaml';
 import type { ISession } from '../session/types';
 
@@ -83,3 +83,48 @@ export function liftCodeMetadataToBlock(session: ISession, filename: string, mda
     }
   });
 }
+
+/**
+ * Traverse mdast, propagate block tags to code and output
+ */
+export function propagateBlockDataToCode(session: ISession, filename: string, mdast: Root) {
+  const blocks = selectAll('block', mdast) as GenericNode[];
+  blocks.forEach((block) => {
+    if (!block.data || !block.data.tags) return;
+    if (!Array.isArray(block.data.tags)) {
+      session.log.error(`tags in code-cell directive must be a list of strings`);
+    }
+    // only single ('code', 'output') pair?
+    const codeNode = select('code', block) as GenericNode;
+    const outputNode = select('output', block) as GenericNode;
+    block.data.tags.forEach((tag: string) => {
+      switch (tag) {
+        // should we raise when hide and remove both exist?
+        case 'hide-cell':
+          block.visibility = 'hide';
+          break;
+        case 'remove-cell':
+          block.visibility = 'remove';
+          break;
+        case 'hide-input':
+          codeNode.visibility = 'hide';
+          break;
+        case 'remove-input':
+          codeNode.visibility = 'remove';
+          break;
+        case 'hide-output':
+          outputNode.visibility = 'hide';
+          break;
+        case 'remove-output':
+          outputNode.visibility = 'remove';
+          break;
+        default:
+          session.log.warn(`tag '${tag}' is not valid in code-cell tags'`);
+      }
+    });
+    if (!block.visibility) block.visibility = 'show';
+    if (!codeNode.visibility) codeNode.visibility = 'show';
+    if (!outputNode.visibility) outputNode.visibility = 'show';
+    delete block.data.tags;
+  });
+}

packages/myst-spec-ext/src/types.ts

@@ -70,6 +70,7 @@ export type Admonition = SpecAdmonition & {
 
 export type Code = SpecCode & {
   executable?: boolean;
+  visibility?: 'show' | 'hide' | 'remove';
 };
 
 export type ListItem = SpecListItem & {