Refactored grouped resource tree data provider to use new matcher

packages/foam-vscode/src/core/services/datastore.ts

@@ -109,4 +109,48 @@ export class FileListBasedMatcher implements IMatcher {
   async refresh() {
     this.files = (await this.listFiles()).map(f => f.path);
   }
+
+  static async createFromListFn(listFiles: () => Promise<URI[]>) {
+    const files = await listFiles();
+    return new FileListBasedMatcher(files, listFiles);
+  }
+}
+
+/**
+ * A matcher that includes all URIs passed to it
+ */
+export class AlwaysIncludeMatcher implements IMatcher {
+  include: string[] = ['**/*'];
+  exclude: string[] = [];
+  match(files: URI[]): URI[] {
+    return files;
+  }
+
+  isMatch(uri: URI): boolean {
+    return true;
+  }
+
+  refresh(): Promise<void> {
+    return;
+  }
+}
+
+export class SubstringExcludeMatcher implements IMatcher {
+  include: string[] = ['**/*'];
+  exclude: string[] = [];
+  constructor(exclude: string) {
+    this.exclude = [exclude];
+  }
+
+  match(files: URI[]): URI[] {
+    return files.filter(f => this.isMatch(f));
+  }
+
+  isMatch(uri: URI): boolean {
+    return !uri.path.includes(this.exclude[0]);
+  }
+
+  refresh(): Promise<void> {
+    return;
+  }
 }

packages/foam-vscode/src/extension.ts

@@ -1,28 +1,16 @@
-import {
-  workspace,
-  ExtensionContext,
-  window,
-  commands,
-  RelativePattern,
-  Uri,
-} from 'vscode';
+import { workspace, ExtensionContext, window, commands } from 'vscode';
 import { MarkdownResourceProvider } from './core/services/markdown-provider';
 import { bootstrap } from './core/model/foam';
-import { URI } from './core/model/uri';
-import {
-  FileListBasedMatcher,
-  GenericDataStore,
-} from './core/services/datastore';
 import { Logger } from './core/utils/log';
 
 import { features } from './features';
 import { VsCodeOutputLogger, exposeLogger } from './services/logging';
 import { getIgnoredFilesSetting } from './settings';
-import { fromVsCodeUri, toVsCodeUri } from './utils/vsc-utils';
 import { AttachmentResourceProvider } from './core/services/attachment-provider';
 import { VsCodeWatcher } from './services/watcher';
 import { createMarkdownParser } from './core/services/markdown-parser';
 import VsCodeBasedParserCache from './services/cache';
+import { createMatcherAndDataStore } from './services/editor';
 
 export async function activate(context: ExtensionContext) {
   const logger = new VsCodeOutputLogger();
@@ -38,23 +26,12 @@ export async function activate(context: ExtensionContext) {
     }
 
     // Prepare Foam
-    const excludePatterns = new Map<string, string[]>();
-    workspace.workspaceFolders.forEach(f => excludePatterns.set(f.name, []));
-
     const excludes = getIgnoredFilesSetting().map(g => g.toString());
-    for (const exclude of excludes) {
-      const tokens = exclude.split('/');
-      const matchesFolder = workspace.workspaceFolders.find(
-        f => f.name === tokens[0]
-      );
-      if (matchesFolder) {
-        excludePatterns.get(tokens[0]).push(tokens.slice(1).join('/'));
-      } else {
-        for (const [, value] of excludePatterns.entries()) {
-          value.push(exclude);
-        }
-      }
-    }
+    const {
+      matcher,
+      dataStore,
+      excludePatterns,
+    } = await createMatcherAndDataStore(excludes);
 
     Logger.info('Loading from directories:');
     for (const folder of workspace.workspaceFolders) {
@@ -63,30 +40,6 @@ export async function activate(context: ExtensionContext) {
       Logger.info('  Exclude: ' + excludePatterns.get(folder.name).join(','));
     }
 
-    const listFiles = async () => {
-      let files: Uri[] = [];
-      for (const folder of workspace.workspaceFolders) {
-        const uris = await workspace.findFiles(
-          new RelativePattern(folder.uri.path, '**/*'),
-          new RelativePattern(
-            folder.uri.path,
-            `{${excludePatterns.get(folder.name).join(',')}}`
-          )
-        );
-        files = [...files, ...uris];
-      }
-
-      return files.map(fromVsCodeUri);
-    };
-
-    const readFile = async (uri: URI) =>
-      (await workspace.fs.readFile(toVsCodeUri(uri))).toString();
-
-    const dataStore = new GenericDataStore(listFiles, readFile);
-
-    const files = await dataStore.list();
-
-    const matcher = new FileListBasedMatcher(files, listFiles);
     const watcher = new VsCodeWatcher(
       workspace.createFileSystemWatcher('**/*')
     );

packages/foam-vscode/src/features/panels/orphans.ts

@@ -1,15 +1,13 @@
 import * as vscode from 'vscode';
 import { Foam } from '../../core/model/foam';
-import { FoamGraph } from '../../core/model/graph';
-import { URI } from '../../core/model/uri';
+import { createMatcherAndDataStore } from '../../services/editor';
 import { getOrphansConfig } from '../../settings';
 import { FoamFeature } from '../../types';
 import {
   GroupedResourcesTreeDataProvider,
   ResourceTreeItem,
   UriTreeItem,
 } from '../../utils/grouped-resources-tree-data-provider';
-import { fromVsCodeUri } from '../../utils/vsc-utils';
 
 const feature: FoamFeature = {
   activate: async (
@@ -18,24 +16,24 @@ const feature: FoamFeature = {
   ) => {
     const foam = await foamPromise;
 
-    const workspacesURIs = vscode.workspace.workspaceFolders.map(dir =>
-      fromVsCodeUri(dir.uri)
+    const { matcher } = await createMatcherAndDataStore(
+      getOrphansConfig().exclude
     );
-
     const provider = new GroupedResourcesTreeDataProvider(
       'orphans',
       'orphan',
-      getOrphansConfig(),
-      workspacesURIs,
-      () => foam.graph.getAllNodes().filter(uri => isOrphan(uri, foam.graph)),
+      () =>
+        foam.graph
+          .getAllNodes()
+          .filter(uri => foam.graph.getConnections(uri).length === 0),
       uri => {
-        if (uri.isPlaceholder()) {
-          return new UriTreeItem(uri);
-        }
-        const resource = foam.workspace.find(uri);
-        return new ResourceTreeItem(resource, foam.workspace);
-      }
+        return uri.isPlaceholder()
+          ? new UriTreeItem(uri)
+          : new ResourceTreeItem(foam.workspace.find(uri), foam.workspace);
+      },
+      matcher
     );
+    provider.setGroupBy(getOrphansConfig().groupBy);
 
     context.subscriptions.push(
       vscode.window.registerTreeDataProvider('foam-vscode.orphans', provider),
@@ -45,7 +43,4 @@ const feature: FoamFeature = {
   },
 };
 
-export const isOrphan = (uri: URI, graph: FoamGraph) =>
-  graph.getConnections(uri).length === 0;
-
 export default feature;

packages/foam-vscode/src/features/panels/placeholders.ts

@@ -1,32 +1,32 @@
 import * as vscode from 'vscode';
 import { Foam } from '../../core/model/foam';
+import { createMatcherAndDataStore } from '../../services/editor';
 import { getPlaceholdersConfig } from '../../settings';
 import { FoamFeature } from '../../types';
 import {
   GroupedResourcesTreeDataProvider,
   UriTreeItem,
 } from '../../utils/grouped-resources-tree-data-provider';
-import { fromVsCodeUri } from '../../utils/vsc-utils';
 
 const feature: FoamFeature = {
   activate: async (
     context: vscode.ExtensionContext,
     foamPromise: Promise<Foam>
   ) => {
     const foam = await foamPromise;
-    const workspacesURIs = vscode.workspace.workspaceFolders.map(dir =>
-      fromVsCodeUri(dir.uri)
+    const { matcher } = await createMatcherAndDataStore(
+      getPlaceholdersConfig().exclude
     );
     const provider = new GroupedResourcesTreeDataProvider(
       'placeholders',
       'placeholder',
-      getPlaceholdersConfig(),
-      workspacesURIs,
       () => foam.graph.getAllNodes().filter(uri => uri.isPlaceholder()),
       uri => {
         return new UriTreeItem(uri);
-      }
+      },
+      matcher
     );
+    provider.setGroupBy(getPlaceholdersConfig().groupBy);
 
     context.subscriptions.push(
       vscode.window.registerTreeDataProvider(

packages/foam-vscode/src/services/editor.ts

@@ -1,10 +1,13 @@
+import { isEmpty } from 'lodash';
 import { asAbsoluteUri, URI } from '../core/model/uri';
 import { TextEncoder } from 'util';
 import {
   FileType,
+  RelativePattern,
   Selection,
   SnippetString,
   TextDocument,
+  Uri,
   ViewColumn,
   window,
   workspace,
@@ -13,6 +16,13 @@ import {
 import { focusNote } from '../utils';
 import { fromVsCodeUri, toVsCodeUri } from '../utils/vsc-utils';
 import { isSome } from '../core/utils';
+import {
+  AlwaysIncludeMatcher,
+  FileListBasedMatcher,
+  GenericDataStore,
+  IDataStore,
+  IMatcher,
+} from '../core/services/datastore';
 
 interface SelectionInfo {
   document: TextDocument;
@@ -124,3 +134,54 @@ export function asAbsoluteWorkspaceUri(uri: URI): URI {
   const res = asAbsoluteUri(uri, folders);
   return res;
 }
+
+export const createMatcherAndDataStore = async (
+  excludes: string[]
+): Promise<{
+  matcher: IMatcher;
+  dataStore: IDataStore;
+  excludePatterns: Map<string, string[]>;
+}> => {
+  const excludePatterns = new Map<string, string[]>();
+  workspace.workspaceFolders.forEach(f => excludePatterns.set(f.name, []));
+
+  for (const exclude of excludes) {
+    const tokens = exclude.split('/');
+    const matchesFolder = workspace.workspaceFolders.find(
+      f => f.name === tokens[0]
+    );
+    if (matchesFolder) {
+      excludePatterns.get(tokens[0]).push(tokens.slice(1).join('/'));
+    } else {
+      for (const [, value] of excludePatterns.entries()) {
+        value.push(exclude);
+      }
+    }
+  }
+
+  const listFiles = async () => {
+    let files: Uri[] = [];
+    for (const folder of workspace.workspaceFolders) {
+      const uris = await workspace.findFiles(
+        new RelativePattern(folder.uri.path, '**/*'),
+        new RelativePattern(
+          folder.uri.path,
+          `{${excludePatterns.get(folder.name).join(',')}}`
+        )
+      );
+      files = [...files, ...uris];
+    }
+
+    return files.map(fromVsCodeUri);
+  };
+
+  const readFile = async (uri: URI) =>
+    (await workspace.fs.readFile(toVsCodeUri(uri))).toString();
+
+  const dataStore = new GenericDataStore(listFiles, readFile);
+  const matcher = isEmpty(excludes)
+    ? new AlwaysIncludeMatcher()
+    : await FileListBasedMatcher.createFromListFn(listFiles);
+
+  return { matcher, dataStore, excludePatterns };
+};

packages/foam-vscode/src/utils.ts

@@ -8,7 +8,6 @@ import {
   workspace,
   Selection,
   MarkdownString,
-  version,
   ViewColumn,
 } from 'vscode';
 import matter from 'gray-matter';