Expose caseSensitive and includePerfectMatches completer settings

Author: krassowski

packages/jupyterlab-lsp/schema/completion.json

@@ -58,6 +58,18 @@
       "default": false,
       "description": "In case of ties when sorting completions, should the kernel completions receive higher priority than the language server completions?"
     },
+    "caseSensitive": {
+      "title": "Case-sensitive filtering",
+      "default": true,
+      "type": "boolean",
+      "description": "Should completion filtering be case-sensitive?"
+    },
+    "includePerfectMatches": {
+      "title": "Include perfect matches",
+      "default": true,
+      "type": "boolean",
+      "description": "Should perfect matches be included in the completion suggestions list?"
+    },
     "typesMap": {
       "title": "Mapping of custom kernel types to valid completion kind names",
       "description": "Mapping used for icon selection. The kernel types (keys) are case-insensitive. Accepted values are the names of CompletionItemKind and 'Kernel' literal. The defaults aim to provide good initial experience for Julia, Python and R kernels.",

packages/jupyterlab-lsp/src/features/completion/completion.ts

@@ -111,6 +111,8 @@ export class CompletionLabIntegration implements IFeatureLabIntegration {
       completionThemeManager.set_icons_overrides(
         this.settings.composite.typesMap
       );
+      this.model.settings.caseSensitive = this.settings.composite.caseSensitive;
+      this.model.settings.includePerfectMatches = this.settings.composite.includePerfectMatches;
     });
   }
 
@@ -195,7 +197,10 @@ export class CompletionLabIntegration implements IFeatureLabIntegration {
     ) as CompletionHandler;
     let completer = this.completer;
     completer.addClass('lsp-completer');
-    completer.model = new LSPCompleterModel();
+    completer.model = new LSPCompleterModel({
+      caseSensitive: this.settings.composite.caseSensitive,
+      includePerfectMatches: this.settings.composite.includePerfectMatches
+    });
   }
 
   protected get completer() {

packages/jupyterlab-lsp/src/features/completion/model.spec.ts

@@ -30,9 +30,16 @@ describe('LSPCompleterModel', () => {
     label: 'test',
     sortText: 'c'
   });
+  const test_test_completion = create_dummy_item({
+    label: 'test_test',
+    sortText: 'test_test'
+  });
 
   beforeEach(() => {
-    model = new LSPCompleterModel();
+    model = new LSPCompleterModel({
+      caseSensitive: true,
+      includePerfectMatches: true
+    });
   });
 
   it('returns escaped when no query', () => {
@@ -70,6 +77,33 @@ describe('LSPCompleterModel', () => {
     ]);
   });
 
+  it('ignores perfect matches when asked', () => {
+    model = new LSPCompleterModel({
+      includePerfectMatches: false
+    });
+
+    model.setCompletionItems([test_a_completion, test_test_completion]);
+    model.query = 'test';
+    let items = model.completionItems();
+    // should not include the perfect match 'test'
+    expect(items.length).to.equal(1);
+    expect(items.map(item => item.sortText)).to.deep.equal(['test_test']);
+  });
+
+  it('case-sensitivity can be changed', () => {
+    model = new LSPCompleterModel();
+    model.setCompletionItems([test_a_completion]);
+    model.query = 'Test';
+
+    model.settings.caseSensitive = true;
+    let items = model.completionItems();
+    expect(items.length).to.equal(0);
+
+    model.settings.caseSensitive = false;
+    items = model.completionItems();
+    expect(items.length).to.equal(1);
+  });
+
   it('filters use filterText', () => {
     model.setCompletionItems([jupyter_icon_completion]);
     // font is in filterText but not in label

packages/jupyterlab-lsp/src/features/completion/model.ts

@@ -27,7 +27,13 @@ function escapeHTML(text: string) {
 export class GenericCompleterModel<
   T extends CompletionHandler.ICompletionItem
 > extends CompleterModel {
-  public caseSensitive = true;
+  public settings: GenericCompleterModel.IOptions;
+
+  constructor(settings: GenericCompleterModel.IOptions = {}) {
+    super();
+    // TODO: refactor upstream so that it does not block "options"?
+    this.settings = { ...GenericCompleterModel.defaultOptions, ...settings };
+  }
 
   completionItems(): T[] {
     let query = this.query;
@@ -76,11 +82,22 @@ export class GenericCompleterModel<
       let filterText: string = null;
       let filterMatch: StringExt.IMatchResult;
 
+      let lowerCaseQuery = query.toLowerCase();
+
       if (query) {
         filterText = this.getFilterText(item);
-        filterMatch = StringExt.matchSumOfSquares(filterText, query);
-        // ignore perfect matches (those are not useful)
-        matched = !!filterMatch && filterText != query;
+        if (this.settings.caseSensitive) {
+          filterMatch = StringExt.matchSumOfSquares(filterText, query);
+        } else {
+          filterMatch = StringExt.matchSumOfSquares(
+            filterText.toLowerCase(),
+            lowerCaseQuery
+          );
+        }
+        matched = !!filterMatch;
+        if (!this.settings.includePerfectMatches) {
+          matched = matched && filterText != query;
+        }
       } else {
         matched = true;
       }
@@ -152,13 +169,26 @@ export class GenericCompleterModel<
   }
 }
 
+export namespace GenericCompleterModel {
+  export interface IOptions {
+    /**
+     * Whether matching should be case-sensitive (default = true)
+     */
+    caseSensitive?: boolean;
+    /**
+     * Whether perfect matches should be included (default = true)
+     */
+    includePerfectMatches?: boolean;
+  }
+  export const defaultOptions: IOptions = {
+    caseSensitive: true,
+    includePerfectMatches: true
+  };
+}
+
 export class LSPCompleterModel extends GenericCompleterModel<
   LazyCompletionItem
 > {
-  constructor() {
-    super();
-  }
-
   protected getFilterText(item: LazyCompletionItem): string {
     if (item.filterText) {
       return item.filterText;