From e5465841f8de0e89222b4a6827d51f6e19fcf655 Mon Sep 17 00:00:00 2001 From: Alex Ross Date: Fri, 7 Sep 2018 15:29:51 -0700 Subject: [PATCH] Responded to feedback and fixed the returned found term --- demo/main.js | 14 ++++++++++++-- src/addons/search/Interfaces.ts | 10 ++++++++-- src/addons/search/SearchHelper.ts | 28 ++++++++++++++-------------- src/addons/search/search.test.ts | 26 +++++++++++++++++++------- src/addons/search/search.ts | 22 +++++++++++----------- 5 files changed, 64 insertions(+), 36 deletions(-) diff --git a/demo/main.js b/demo/main.js index 79116efb..12537db2 100644 --- a/demo/main.js +++ b/demo/main.js @@ -83,13 +83,23 @@ function createTerminal() { addDomListener(actionElements.findNext, 'keypress', function (e) { if (e.key === "Enter") { e.preventDefault(); - term.findNext(actionElements.findNext.value, document.getElementById('regex').checked); + let searchOptions = { + regex: document.getElementById('regex').checked, + wholeWord: false, + caseSensitive: false + }; + term.findNext(actionElements.findNext.value, searchOptions); } }); addDomListener(actionElements.findPrevious, 'keypress', function (e) { if (e.key === "Enter") { e.preventDefault(); - term.findPrevious(actionElements.findPrevious.value, document.getElementById('regex').checked); + let searchOptions = { + regex: document.getElementById('regex').checked, + wholeWord: false, + caseSensitive: false + }; + term.findPrevious(actionElements.findPrevious.value, searchOptions); } }); diff --git a/src/addons/search/Interfaces.ts b/src/addons/search/Interfaces.ts index e0ed1173..4fa8b77e 100644 --- a/src/addons/search/Interfaces.ts +++ b/src/addons/search/Interfaces.ts @@ -17,6 +17,12 @@ export interface ISearchAddonTerminal extends Terminal { } export interface ISearchHelper { - findNext(term: string, regex: boolean): boolean; - findPrevious(term: string, regex: boolean): boolean; + findNext(term: string, searchOptions: ISearchOptions): boolean; + findPrevious(term: string, searchOptions: ISearchOptions): boolean; +} + +export interface ISearchOptions { + regex: boolean; + wholeWord: boolean; + caseSensitive: boolean; } diff --git a/src/addons/search/SearchHelper.ts b/src/addons/search/SearchHelper.ts index 0a22a57e..be1a1475 100644 --- a/src/addons/search/SearchHelper.ts +++ b/src/addons/search/SearchHelper.ts @@ -3,7 +3,7 @@ * @license MIT */ -import { ISearchHelper, ISearchAddonTerminal } from './Interfaces'; +import { ISearchHelper, ISearchAddonTerminal, ISearchOptions } from './Interfaces'; interface ISearchResult { term: string; @@ -19,17 +19,16 @@ export class SearchHelper implements ISearchHelper { // TODO: Search for multiple instances on 1 line // TODO: Don't use the actual selection, instead use a "find selection" so multiple instances can be highlighted // TODO: Highlight other instances in the viewport - // TODO: Support regex, case sensitivity, etc. } /** * Find the next instance of the term, then scroll to and select it. If it * doesn't exist, do nothing. * @param term Tne search term. - * @param regex Should use regular expressions + * @param searchOptions Search options. * @return Whether a result was found. */ - public findNext(term: string, regex: boolean = false): boolean { + public findNext(term: string, searchOptions: ISearchOptions): boolean { if (!term || term.length === 0) { return false; } @@ -44,7 +43,7 @@ export class SearchHelper implements ISearchHelper { // Search from ydisp + 1 to end for (let y = startRow + 1; y < this._terminal._core.buffer.ybase + this._terminal.rows; y++) { - result = this._findInLine(term, y, regex); + result = this._findInLine(term, y, searchOptions); if (result) { break; } @@ -53,7 +52,7 @@ export class SearchHelper implements ISearchHelper { // Search from the top to the current ydisp if (!result) { for (let y = 0; y < startRow; y++) { - result = this._findInLine(term, y, regex); + result = this._findInLine(term, y, searchOptions); if (result) { break; } @@ -68,10 +67,10 @@ export class SearchHelper implements ISearchHelper { * Find the previous instance of the term, then scroll to and select it. If it * doesn't exist, do nothing. * @param term Tne search term. - * @param regex Should use regular expressions + * @param searchOptions Search options. * @return Whether a result was found. */ - public findPrevious(term: string, regex: boolean = false): boolean { + public findPrevious(term: string, searchOptions: ISearchOptions): boolean { if (!term || term.length === 0) { return false; } @@ -86,7 +85,7 @@ export class SearchHelper implements ISearchHelper { // Search from ydisp + 1 to end for (let y = startRow - 1; y >= 0; y--) { - result = this._findInLine(term, y, regex); + result = this._findInLine(term, y, searchOptions); if (result) { break; } @@ -95,7 +94,7 @@ export class SearchHelper implements ISearchHelper { // Search from the top to the current ydisp if (!result) { for (let y = this._terminal._core.buffer.ybase + this._terminal.rows - 1; y > startRow; y--) { - result = this._findInLine(term, y, regex); + result = this._findInLine(term, y, searchOptions); if (result) { break; } @@ -108,20 +107,21 @@ export class SearchHelper implements ISearchHelper { /** * Searches a line for a search term. - * @param term Tne search term. + * @param term The search term. * @param y The line to search. - * @param regex Should use regular expressions + * @param searchOptions Search options. * @return The search result if it was found. */ - private _findInLine(term: string, y: number, regex: boolean): ISearchResult { + private _findInLine(term: string, y: number, searchOptions: ISearchOptions = {regex: false, wholeWord: false, caseSensitive: false}): ISearchResult { const lowerStringLine = this._terminal._core.buffer.translateBufferLineToString(y, true).toLowerCase(); const lowerTerm = term.toLowerCase(); let searchIndex = -1; - if (regex) { + if (searchOptions.regex) { const searchRegex = RegExp(lowerTerm, 'g'); const foundTerm = searchRegex.exec(lowerStringLine); if (foundTerm) { searchIndex = searchRegex.lastIndex - foundTerm[0].length; + term = foundTerm[0]; } } else { searchIndex = lowerStringLine.indexOf(lowerTerm); diff --git a/src/addons/search/search.test.ts b/src/addons/search/search.test.ts index 891418f4..9616ae3c 100644 --- a/src/addons/search/search.test.ts +++ b/src/addons/search/search.test.ts @@ -48,19 +48,31 @@ describe('search addon', function(): void { }); it('should respect search regex', function(): void { search.apply(MockTerminal); - const term = new MockTerminal({cols: 10, rows: 3}); - term.core.write('abcdefghijklmnopqrstuvwxyz'); + const term = new MockTerminal({cols: 10, rows: 4}); + term.core.write('abcdefghijklmnopqrstuvwxyz\r\n~/dev '); /* abcdefghij klmnopqrst uvwxyz + ~/dev */ term.pushWriteData(); - const hello0 = (term.searchHelper as any)._findInLine('dee*', 0, true); - const hello1 = (term.searchHelper as any)._findInLine('jkk*', 0, true); - const hello2 = (term.searchHelper as any)._findInLine('mnn*', 1, true); - expect(hello0).eql({col: 3, row: 0, term: 'dee*'}); - // TODO: uncomment this test when line wrap search is checked in expect(hello1).eql({col: 9, row: 0, term: 'jkk*'}); + const searchOptions = { + regex: true, + wholeWord: false, + caseSensitive: false + }; + const hello0 = (term.searchHelper as any)._findInLine('dee*', 0, searchOptions); + const hello1 = (term.searchHelper as any)._findInLine('jkk*', 0, searchOptions); + const hello2 = (term.searchHelper as any)._findInLine('mnn*', 1, searchOptions); + const tilda0 = (term.searchHelper as any)._findInLine('^~', 3, searchOptions); + const tilda1 = (term.searchHelper as any)._findInLine('^[~]', 3, searchOptions); + const tilda2 = (term.searchHelper as any)._findInLine('^\\~', 3, searchOptions); + expect(hello0).eql({col: 3, row: 0, term: 'de'}); + // TODO: uncomment this test when line wrap search is checked in expect(hello1).eql({col: 9, row: 0, term: 'jk'}); // TODO: uncomment this test when line wrap search is checked in expect(hello2).eql(undefined); + expect(tilda0).eql({col: 0, row: 3, term: '~'}); + expect(tilda1).eql({col: 0, row: 3, term: '~'}); + expect(tilda2).eql({col: 0, row: 3, term: '~'}); }); }); diff --git a/src/addons/search/search.ts b/src/addons/search/search.ts index 4e97dd90..93ac8843 100644 --- a/src/addons/search/search.ts +++ b/src/addons/search/search.ts @@ -5,44 +5,44 @@ import { SearchHelper } from './SearchHelper'; import { Terminal } from 'xterm'; -import { ISearchAddonTerminal } from './Interfaces'; +import { ISearchAddonTerminal, ISearchOptions } from './Interfaces'; /** * Find the next instance of the term, then scroll to and select it. If it * doesn't exist, do nothing. * @param term Tne search term. - * @param regex Should use regular expressions + * @param searchOptions Search options * @return Whether a result was found. */ -export function findNext(terminal: Terminal, term: string, regex: boolean): boolean { +export function findNext(terminal: Terminal, term: string, searchOptions: ISearchOptions = {regex: false, wholeWord: false, caseSensitive: false}): boolean { const addonTerminal = terminal; if (!addonTerminal.__searchHelper) { addonTerminal.__searchHelper = new SearchHelper(addonTerminal); } - return addonTerminal.__searchHelper.findNext(term, regex); + return addonTerminal.__searchHelper.findNext(term, searchOptions); } /** * Find the previous instance of the term, then scroll to and select it. If it * doesn't exist, do nothing. * @param term Tne search term. - * @param regex Should use regular expressions + * @param searchOptions Search options * @return Whether a result was found. */ -export function findPrevious(terminal: Terminal, term: string, regex: boolean): boolean { +export function findPrevious(terminal: Terminal, term: string, searchOptions: ISearchOptions = {regex: false, wholeWord: false, caseSensitive: false}): boolean { const addonTerminal = terminal; if (!addonTerminal.__searchHelper) { addonTerminal.__searchHelper = new SearchHelper(addonTerminal); } - return addonTerminal.__searchHelper.findPrevious(term, regex); + return addonTerminal.__searchHelper.findPrevious(term, searchOptions); } export function apply(terminalConstructor: typeof Terminal): void { - (terminalConstructor.prototype).findNext = function(term: string, regex: boolean): boolean { - return findNext(this, term, regex); + (terminalConstructor.prototype).findNext = function(term: string, searchOptions: ISearchOptions): boolean { + return findNext(this, term, searchOptions); }; - (terminalConstructor.prototype).findPrevious = function(term: string, regex: boolean): boolean { - return findPrevious(this, term, regex); + (terminalConstructor.prototype).findPrevious = function(term: string, searchOptions: ISearchOptions): boolean { + return findPrevious(this, term, searchOptions); }; }