ckaczor/vscode-gitlens
1
0
Fork 0
mirror of https://github.com/ckaczor/vscode-gitlens.git synced 2026-02-16 18:48:45 -05:00
Code Issues Packages Projects Releases Wiki Activity

Reworks more commands deal with context

Browse Source
This commit is contained in:
Eric Amodio
2017-06-27 01:19:39 -04:00
parent 9179b70875
commit 1751987868
5 changed files with 220 additions and 144 deletions
Download Patch File Download Diff File Expand all files Collapse all files

174
src/commands/closeUnchangedFiles.ts
View File

@@ -1,85 +1,101 @@
'use strict'; 'use strict';
import { commands, TextEditor, Uri, window } from 'vscode'; import { commands, TextEditor, Uri, window } from 'vscode';
import { ActiveEditorTracker } from '../activeEditorTracker'; import { ActiveEditorTracker } from '../activeEditorTracker';
import { ActiveEditorCommand, Commands, getCommandUri } from './common'; import { ActiveEditorCommand, CommandContext, Commands, getCommandUri } from './common';
import { TextEditorComparer, UriComparer } from '../comparers'; import { TextEditorComparer, UriComparer } from '../comparers';
import { BuiltInCommands } from '../constants'; import { BuiltInCommands } from '../constants';
import { GitService } from '../gitService'; import { GitService } from '../gitService';
import { Logger } from '../logger'; import { Logger } from '../logger';
import { Messages } from '../messages'; import { Messages } from '../messages';
export interface CloseUnchangedFilesCommandArgs { export interface CloseUnchangedFilesCommandArgs {
uris?: Uri[]; uris?: Uri[];
} }
export class CloseUnchangedFilesCommand extends ActiveEditorCommand { export class CloseUnchangedFilesCommand extends ActiveEditorCommand {
constructor(private git: GitService) { constructor(private git: GitService) {
super(Commands.CloseUnchangedFiles); super(Commands.CloseUnchangedFiles);
} }
async execute(editor: TextEditor, uri?: Uri, args: CloseUnchangedFilesCommandArgs = {}) { async run(context: CommandContext, args: CloseUnchangedFilesCommandArgs = {}): Promise<any> {
uri = getCommandUri(uri, editor); // Since we can change the args and they could be cached -- make a copy
switch (context.type) {
try { case 'uri':
if (args.uris === undefined) { return this.execute(context.editor, context.uri, { ...args });
const repoPath = await this.git.getRepoPathFromUri(uri); case 'scm-states':
if (!repoPath) return Messages.showNoRepositoryWarningMessage(`Unable to close unchanged files`); return undefined;
case 'scm-groups':
const status = await this.git.getStatusForRepo(repoPath); // const group = context.scmResourceGroups[0];
if (status === undefined) return window.showWarningMessage(`Unable to close unchanged files`); // args.uris = group.resourceStates.map(_ => _.resourceUri);
return this.execute(undefined, undefined, { ...args });
args.uris = status.files.map(_ => _.Uri); default:
} return this.execute(context.editor, undefined, { ...args });
}
if (args.uris.length === 0) return commands.executeCommand(BuiltInCommands.CloseAllEditors); }
const editorTracker = new ActiveEditorTracker(); async execute(editor: TextEditor | undefined, uri?: Uri, args: CloseUnchangedFilesCommandArgs = {}) {
uri = getCommandUri(uri, editor);
let count = 0;
let previous = undefined; try {
let editor = window.activeTextEditor; if (args.uris === undefined) {
while (true) { const repoPath = await this.git.getRepoPathFromUri(uri);
if (editor !== undefined) { if (!repoPath) return Messages.showNoRepositoryWarningMessage(`Unable to close unchanged files`);
if (TextEditorComparer.equals(previous, editor, { useId: true, usePosition: true })) {
break; const status = await this.git.getStatusForRepo(repoPath);
} if (status === undefined) return window.showWarningMessage(`Unable to close unchanged files`);
if (editor.document !== undefined && args.uris = status.files.map(_ => _.Uri);
(editor.document.isDirty || args.uris.some(_ => UriComparer.equals(_, editor!.document && editor!.document.uri)))) { }
if (args.uris.length === 0) return commands.executeCommand(BuiltInCommands.CloseAllEditors);
const editorTracker = new ActiveEditorTracker();
let count = 0;
let previous = undefined;
let editor = window.activeTextEditor;
while (true) {
if (editor !== undefined) {
if (TextEditorComparer.equals(previous, editor, { useId: true, usePosition: true })) {
break;
}
if (editor.document !== undefined &&
(editor.document.isDirty || args.uris.some(_ => UriComparer.equals(_, editor!.document && editor!.document.uri)))) {
const lastPrevious = previous; const lastPrevious = previous;
previous = editor; previous = editor;
editor = await editorTracker.awaitNext(500); editor = await editorTracker.awaitNext(500);
if (TextEditorComparer.equals(lastPrevious, editor, { useId: true, usePosition: true })) { if (TextEditorComparer.equals(lastPrevious, editor, { useId: true, usePosition: true })) {
break; break;
} }
continue; continue;
} }
} }
previous = editor; previous = editor;
editor = await editorTracker.awaitClose(500); editor = await editorTracker.awaitClose(500);
if (previous === undefined && editor === undefined) { if (previous === undefined && editor === undefined) {
count++; count++;
// This is such a shitty hack, but I can't figure out any other reliable way to know that we've cycled through all the editors :( // This is such a shitty hack, but I can't figure out any other reliable way to know that we've cycled through all the editors :(
if (count >= 4) { if (count >= 4) {
break; break;
} }
} }
else { else {
count = 0; count = 0;
} }
} }
editorTracker.dispose(); editorTracker.dispose();
return undefined; return undefined;
} }
catch (ex) { catch (ex) {
Logger.error(ex, 'CloseUnchangedFilesCommand'); Logger.error(ex, 'CloseUnchangedFilesCommand');
return window.showErrorMessage(`Unable to close unchanged files. See output channel for more details`); return window.showErrorMessage(`Unable to close unchanged files. See output channel for more details`);
} }
} }
} }

133
src/commands/diffWithBranch.ts
View File

@@ -1,63 +1,78 @@
'use strict'; 'use strict';
import { commands, TextDocumentShowOptions, TextEditor, Uri, window } from 'vscode'; import { commands, TextDocumentShowOptions, TextEditor, Uri, window } from 'vscode';
import { ActiveEditorCommand, Commands, getCommandUri } from './common'; import { ActiveEditorCommand, CommandContext, Commands, getCommandUri } from './common';
import { BuiltInCommands, GlyphChars } from '../constants'; import { BuiltInCommands, GlyphChars } from '../constants';
import { GitService, GitUri } from '../gitService'; import { GitService, GitUri } from '../gitService';
import { Logger } from '../logger'; import { Logger } from '../logger';
import { Messages } from '../messages'; import { Messages } from '../messages';
import { BranchesQuickPick, CommandQuickPickItem } from '../quickPicks'; import { BranchesQuickPick, CommandQuickPickItem } from '../quickPicks';
import * as path from 'path'; import * as path from 'path';
export interface DiffWithBranchCommandArgs { export interface DiffWithBranchCommandArgs {
line?: number; line?: number;
showOptions?: TextDocumentShowOptions; showOptions?: TextDocumentShowOptions;
goBackCommand?: CommandQuickPickItem; goBackCommand?: CommandQuickPickItem;
} }
export class DiffWithBranchCommand extends ActiveEditorCommand { export class DiffWithBranchCommand extends ActiveEditorCommand {
constructor(private git: GitService) { constructor(private git: GitService) {
super(Commands.DiffWithBranch); super(Commands.DiffWithBranch);
} }
async execute(editor: TextEditor, uri?: Uri, args: DiffWithBranchCommandArgs = {}): Promise<any> { async run(context: CommandContext, args: DiffWithBranchCommandArgs = {}): Promise<any> {
uri = getCommandUri(uri, editor); // Since we can change the args and they could be cached -- make a copy
if (uri === undefined) return undefined; switch (context.type) {
case 'uri':
return this.execute(context.editor, context.uri, { ...args });
case 'scm-states':
const resource = context.scmResourceStates[0];
return this.execute(undefined, resource.resourceUri, { ...args });
case 'scm-groups':
return undefined;
default:
return this.execute(context.editor, undefined, { ...args });
}
}
async execute(editor: TextEditor | undefined, uri?: Uri, args: DiffWithBranchCommandArgs = {}): Promise<any> {
uri = getCommandUri(uri, editor);
if (uri === undefined) return undefined;
if (args.line === undefined) { if (args.line === undefined) {
args.line = editor === undefined ? 0 : editor.selection.active.line; args.line = editor === undefined ? 0 : editor.selection.active.line;
} }
const gitUri = await GitUri.fromUri(uri, this.git); const gitUri = await GitUri.fromUri(uri, this.git);
if (!gitUri.repoPath) return Messages.showNoRepositoryWarningMessage(`Unable to open branch compare`); if (!gitUri.repoPath) return Messages.showNoRepositoryWarningMessage(`Unable to open branch compare`);
const branches = await this.git.getBranches(gitUri.repoPath); const branches = await this.git.getBranches(gitUri.repoPath);
const pick = await BranchesQuickPick.show(branches, `Compare ${path.basename(gitUri.fsPath)} to ${GlyphChars.Ellipsis}`, args.goBackCommand); const pick = await BranchesQuickPick.show(branches, `Compare ${path.basename(gitUri.fsPath)} to ${GlyphChars.Ellipsis}`, args.goBackCommand);
if (pick === undefined) return undefined; if (pick === undefined) return undefined;
if (pick instanceof CommandQuickPickItem) return pick.execute(); if (pick instanceof CommandQuickPickItem) return pick.execute();
const branch = pick.branch.name; const branch = pick.branch.name;
if (branch === undefined) return undefined; if (branch === undefined) return undefined;
try { try {
const compare = await this.git.getVersionedFile(gitUri.repoPath, gitUri.fsPath, branch); const compare = await this.git.getVersionedFile(gitUri.repoPath, gitUri.fsPath, branch);
await commands.executeCommand(BuiltInCommands.Diff, await commands.executeCommand(BuiltInCommands.Diff,
Uri.file(compare), Uri.file(compare),
gitUri.fileUri(), gitUri.fileUri(),
`${path.basename(gitUri.fsPath)} (${branch}) ${GlyphChars.ArrowLeftRight} ${path.basename(gitUri.fsPath)}`, `${path.basename(gitUri.fsPath)} (${branch}) ${GlyphChars.ArrowLeftRight} ${path.basename(gitUri.fsPath)}`,
args.showOptions); args.showOptions);
if (args.line === undefined || args.line === 0) return undefined; if (args.line === undefined || args.line === 0) return undefined;
// TODO: Figure out how to focus the left pane // TODO: Figure out how to focus the left pane
return await commands.executeCommand(BuiltInCommands.RevealLine, { lineNumber: args.line, at: 'center' }); return await commands.executeCommand(BuiltInCommands.RevealLine, { lineNumber: args.line, at: 'center' });
} }
catch (ex) { catch (ex) {
Logger.error(ex, 'DiffWithBranchCommand', 'getVersionedFile'); Logger.error(ex, 'DiffWithBranchCommand', 'getVersionedFile');
return window.showErrorMessage(`Unable to open branch compare. See output channel for more details`); return window.showErrorMessage(`Unable to open branch compare. See output channel for more details`);
} }
} }
} }

20
src/commands/openChangedFiles.ts
View File

@@ -1,6 +1,6 @@
'use strict'; 'use strict';
import { TextDocumentShowOptions, TextEditor, Uri, window } from 'vscode'; import { TextDocumentShowOptions, TextEditor, Uri, window } from 'vscode';
import { ActiveEditorCommand, Commands, getCommandUri, openEditor } from './common'; import { ActiveEditorCommand, CommandContext, Commands, getCommandUri, openEditor } from './common';
import { GitService } from '../gitService'; import { GitService } from '../gitService';
import { Logger } from '../logger'; import { Logger } from '../logger';
import { Messages } from '../messages'; import { Messages } from '../messages';
@@ -15,7 +15,23 @@ export class OpenChangedFilesCommand extends ActiveEditorCommand {
super(Commands.OpenChangedFiles); super(Commands.OpenChangedFiles);
} }
async execute(editor: TextEditor, uri?: Uri, args: OpenChangedFilesCommandArgs = {}) { async run(context: CommandContext, args: OpenChangedFilesCommandArgs = {}): Promise<any> {
// Since we can change the args and they could be cached -- make a copy
switch (context.type) {
case 'uri':
return this.execute(context.editor, context.uri, { ...args });
case 'scm-states':
return undefined;
case 'scm-groups':
// const group = context.scmResourceGroups[0];
// args.uris = group.resourceStates.map(_ => _.resourceUri);
return this.execute(undefined, undefined, { ...args });
default:
return this.execute(context.editor, undefined, { ...args });
}
}
async execute(editor: TextEditor | undefined, uri?: Uri, args: OpenChangedFilesCommandArgs = {}) {
uri = getCommandUri(uri, editor); uri = getCommandUri(uri, editor);
try { try {

18
src/commands/openFileInRemote.ts
View File

@@ -1,7 +1,7 @@
'use strict'; 'use strict';
import { Arrays } from '../system'; import { Arrays } from '../system';
import { commands, Range, TextEditor, Uri, window } from 'vscode'; import { commands, Range, TextEditor, Uri, window } from 'vscode';
import { ActiveEditorCommand, Commands, getCommandUri } from './common'; import { ActiveEditorCommand, CommandContext, Commands, getCommandUri } from './common';
import { GitService, GitUri } from '../gitService'; import { GitService, GitUri } from '../gitService';
import { Logger } from '../logger'; import { Logger } from '../logger';
import { OpenInRemoteCommandArgs } from './openInRemote'; import { OpenInRemoteCommandArgs } from './openInRemote';
@@ -12,7 +12,21 @@ export class OpenFileInRemoteCommand extends ActiveEditorCommand {
super(Commands.OpenFileInRemote); super(Commands.OpenFileInRemote);
} }
async execute(editor: TextEditor, uri?: Uri) { async run(context: CommandContext): Promise<any> {
switch (context.type) {
case 'uri':
return this.execute(context.editor, context.uri);
case 'scm-states':
const resource = context.scmResourceStates[0];
return this.execute(undefined, resource.resourceUri);
case 'scm-groups':
return undefined;
default:
return this.execute(context.editor, undefined);
}
}
async execute(editor: TextEditor | undefined, uri?: Uri) {
uri = getCommandUri(uri, editor); uri = getCommandUri(uri, editor);
if (uri === undefined) return undefined; if (uri === undefined) return undefined;

19
src/commands/showQuickFileHistory.ts
View File

@@ -1,7 +1,7 @@
'use strict'; 'use strict';
import { Strings } from '../system'; import { Strings } from '../system';
import { commands, Range, TextEditor, Uri, window } from 'vscode'; import { commands, Range, TextEditor, Uri, window } from 'vscode';
import { ActiveEditorCachedCommand, Commands, getCommandUri } from './common'; import { ActiveEditorCachedCommand, CommandContext, Commands, getCommandUri } from './common';
import { GlyphChars } from '../constants'; import { GlyphChars } from '../constants';
import { GitLog, GitService, GitUri } from '../gitService'; import { GitLog, GitService, GitUri } from '../gitService';
import { Logger } from '../logger'; import { Logger } from '../logger';
@@ -25,7 +25,22 @@ export class ShowQuickFileHistoryCommand extends ActiveEditorCachedCommand {
super(Commands.ShowQuickFileHistory); super(Commands.ShowQuickFileHistory);
} }
async execute(editor: TextEditor, uri?: Uri, args: ShowQuickFileHistoryCommandArgs = {}) { async run(context: CommandContext, args: ShowQuickFileHistoryCommandArgs = {}): Promise<any> {
// Since we can change the args and they could be cached -- make a copy
switch (context.type) {
case 'uri':
return this.execute(context.editor, context.uri, { ...args });
case 'scm-states':
const resource = context.scmResourceStates[0];
return this.execute(undefined, resource.resourceUri, { ...args });
case 'scm-groups':
return undefined;
default:
return this.execute(context.editor, undefined, { ...args });
}
}
async execute(editor: TextEditor | undefined, uri?: Uri, args: ShowQuickFileHistoryCommandArgs = {}) {
uri = getCommandUri(uri, editor); uri = getCommandUri(uri, editor);
if (uri === undefined) return commands.executeCommand(Commands.ShowQuickCurrentBranchHistory); if (uri === undefined) return commands.executeCommand(Commands.ShowQuickCurrentBranchHistory);