development/vscode
development/vscode
1
0
Fork 0
mirror of https://github.com/Microsoft/vscode synced 2024-10-12 22:37:41 +00:00
Code Issues Packages Projects Releases Wiki Activity

workbench editor model: getResource => resource

Browse source
This commit is contained in:
Benjamin Pasero 2019-11-12 17:04:49 +01:00
parent dc315fcb0f
commit da5f408834
16 changed files with 88 additions and 104 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/vs/workbench/api/browser/mainThreadDocuments.ts
View file

@ -233,7 +233,7 @@ export class MainThreadDocuments implements MainThreadDocumentsShape {
initialValue,
useResourcePath: Boolean(resource && resource.path)
}).then(model => {
const resource = model.getResource();
const resource = model.resource;
if (!this._modelIsSynced.has(resource.toString())) {
throw new Error(`expected URI ${resource.toString()} to have come to LIFE`);

10
src/vs/workbench/api/browser/mainThreadSaveParticipant.ts
View file

@ -51,7 +51,7 @@ class TrimWhitespaceParticipant implements ISaveParticipantParticipant {
}
async participate(model: IResolvedTextFileEditorModel, env: { reason: SaveReason; }): Promise<void> {
if (this.configurationService.getValue('files.trimTrailingWhitespace', { overrideIdentifier: model.textEditorModel.getLanguageIdentifier().language, resource: model.getResource() })) {
if (this.configurationService.getValue('files.trimTrailingWhitespace', { overrideIdentifier: model.textEditorModel.getLanguageIdentifier().language, resource: model.resource })) {
this.doTrimTrailingWhitespace(model.textEditorModel, env.reason === SaveReason.AUTO);
}
}
@ -113,7 +113,7 @@ export class FinalNewLineParticipant implements ISaveParticipantParticipant {
}
async participate(model: IResolvedTextFileEditorModel, env: { reason: SaveReason; }): Promise<void> {
if (this.configurationService.getValue('files.insertFinalNewline', { overrideIdentifier: model.textEditorModel.getLanguageIdentifier().language, resource: model.getResource() })) {
if (this.configurationService.getValue('files.insertFinalNewline', { overrideIdentifier: model.textEditorModel.getLanguageIdentifier().language, resource: model.resource })) {
this.doInsertFinalNewLine(model.textEditorModel);
}
}
@ -147,7 +147,7 @@ export class TrimFinalNewLinesParticipant implements ISaveParticipantParticipant
}
async participate(model: IResolvedTextFileEditorModel, env: { reason: SaveReason; }): Promise<void> {
if (this.configurationService.getValue('files.trimFinalNewlines', { overrideIdentifier: model.textEditorModel.getLanguageIdentifier().language, resource: model.getResource() })) {
if (this.configurationService.getValue('files.trimFinalNewlines', { overrideIdentifier: model.textEditorModel.getLanguageIdentifier().language, resource: model.resource })) {
this.doTrimFinalNewLines(model.textEditorModel, env.reason === SaveReason.AUTO);
}
}
@ -257,7 +257,7 @@ class CodeActionOnSaveParticipant implements ISaveParticipant {
const model = editorModel.textEditorModel;
const settingsOverrides = { overrideIdentifier: model.getLanguageIdentifier().language, resource: editorModel.getResource() };
const settingsOverrides = { overrideIdentifier: model.getLanguageIdentifier().language, resource: editorModel.resource };
const setting = this._configurationService.getValue<ICodeActionsOnSaveOptions>('editor.codeActionsOnSave', settingsOverrides);
if (!setting) {
return undefined;
@ -343,7 +343,7 @@ class ExtHostSaveParticipant implements ISaveParticipantParticipant {
return new Promise<any>((resolve, reject) => {
setTimeout(() => reject(localize('timeout.onWillSave', "Aborted onWillSaveTextDocument-event after 1750ms")), 1750);
this._proxy.$participateInSave(editorModel.getResource(), env.reason).then(values => {
this._proxy.$participateInSave(editorModel.resource, env.reason).then(values => {
if (!values.every(success => success)) {
return Promise.reject(new Error('listener failed'));
}

2
src/vs/workbench/browser/parts/editor/binaryEditor.ts
View file

@ -93,7 +93,7 @@ export abstract class BaseBinaryResourceEditor extends BaseEditor {
}
const [binaryContainer, scrollbar] = assertAllDefined(this.binaryContainer, this.scrollbar);
this.resourceViewerContext = ResourceViewer.show({ name: model.getName(), resource: model.getResource(), size: model.getSize(), etag: model.getETag(), mime: model.getMime() }, binaryContainer, scrollbar, {
this.resourceViewerContext = ResourceViewer.show({ name: model.getName(), resource: model.resource, size: model.getSize(), etag: model.getETag(), mime: model.getMime() }, binaryContainer, scrollbar, {
openInternalClb: () => this.handleOpenInternalCallback(input, options),
openExternalClb: this.environmentService.configuration.remoteAuthority ? undefined : resource => this.callbacks.openExternal(resource),
metadataClb: meta => this.handleMetadataChanged(meta)

9
src/vs/workbench/common/editor/binaryEditorModel.ts
View file

@ -19,7 +19,7 @@ export class BinaryEditorModel extends EditorModel {
private readonly mime: string;
constructor(
private readonly resource: URI,
public readonly resource: URI,
private readonly name: string | undefined,
@IFileService private readonly fileService: IFileService
) {
@ -49,13 +49,6 @@ export class BinaryEditorModel extends EditorModel {
return this.name || basename(this.resource);
}
/**
* The resource of the binary resource.
*/
getResource(): URI {
return this.resource;
}
/**
* The size of the binary resource if known.
*/

4
src/vs/workbench/common/editor/untitledTextEditorModel.ts
View file

@ -115,10 +115,6 @@ export class UntitledTextEditorModel extends BaseTextEditorModel implements IEnc
this._onDidChangeDirty.fire();
}
getResource(): URI {
return this.resource;
}
revert(): void {
this.setDirty(false);

6
src/vs/workbench/contrib/files/browser/editors/fileEditorTracker.ts
View file

@ -98,7 +98,7 @@ export class FileEditorTracker extends Disposable implements IWorkbenchContribut
return resource ? this.textFileService.models.get(resource) : undefined;
}))
.filter(model => !model.isDirty()),
m => m.getResource().toString()
m => m.resource.toString()
).forEach(model => this.queueModelLoad(model));
}
}
@ -299,7 +299,7 @@ export class FileEditorTracker extends Disposable implements IWorkbenchContribut
// and updated right after.
distinct(coalesce([...e.getUpdated(), ...e.getAdded()]
.map(u => this.textFileService.models.get(u.resource)))
.filter(model => model && !model.isDirty()), m => m.getResource().toString())
.filter(model => model && !model.isDirty()), m => m.resource.toString())
.forEach(model => this.queueModelLoad(model));
}
@ -308,7 +308,7 @@ export class FileEditorTracker extends Disposable implements IWorkbenchContribut
// Load model to update (use a queue to prevent accumulation of loads
// when the load actually takes long. At most we only want the queue
// to have a size of 2 (1 running load and 1 queued load).
const queue = this.modelLoadQueue.queueFor(model.getResource());
const queue = this.modelLoadQueue.queueFor(model.resource);
if (queue.size <= 1) {
queue.queue(() => model.load().then(undefined, onUnexpectedError));
}

12
src/vs/workbench/contrib/files/browser/saveErrorHandler.ts
View file

@ -103,7 +103,7 @@ export class SaveErrorHandler extends Disposable implements ISaveErrorHandler, I
onSaveError(error: any, model: ITextFileEditorModel): void {
const fileOperationError = error as FileOperationError;
const resource = model.getResource();
const resource = model.resource;
let message: string;
const primaryActions: IAction[] = [];
@ -113,7 +113,7 @@ export class SaveErrorHandler extends Disposable implements ISaveErrorHandler, I
if (fileOperationError.fileOperationResult === FileOperationResult.FILE_MODIFIED_SINCE) {
// If the user tried to save from the opened conflict editor, show its message again
if (this.activeConflictResolutionResource && this.activeConflictResolutionResource.toString() === model.getResource().toString()) {
if (this.activeConflictResolutionResource && this.activeConflictResolutionResource.toString() === model.resource.toString()) {
if (this.storageService.getBoolean(LEARN_MORE_DIRTY_WRITE_IGNORE_KEY, StorageScope.GLOBAL)) {
return; // return if this message is ignored
}
@ -178,7 +178,7 @@ export class SaveErrorHandler extends Disposable implements ISaveErrorHandler, I
const actions: INotificationActions = { primary: primaryActions, secondary: secondaryActions };
const handle = this.notificationService.notify({ severity: Severity.Error, message, actions });
Event.once(handle.onDidClose)(() => { dispose(primaryActions), dispose(secondaryActions); });
this.messages.set(model.getResource(), handle);
this.messages.set(model.resource, handle);
}
dispose(): void {
@ -243,7 +243,7 @@ class ResolveSaveConflictAction extends Action {
async run(): Promise<any> {
if (!this.model.isDisposed()) {
const resource = this.model.getResource();
const resource = this.model.resource;
const name = basename(resource);
const editorLabel = nls.localize('saveConflictDiffLabel', "{0} (in file) ↔ {1} (in {2}) - Resolve save conflict", name, name, this.productService.nameLong);
@ -332,7 +332,7 @@ export const acceptLocalChangesCommand = async (accessor: ServicesAccessor, reso
await model.save();
// Reopen file input
await editorService.openEditor({ resource: model.getResource() }, group);
await editorService.openEditor({ resource: model.resource }, group);
// Clean up
group.closeEditor(editor);
@ -361,7 +361,7 @@ export const revertLocalChangesCommand = async (accessor: ServicesAccessor, reso
await model.revert();
// Reopen file input
await editorService.openEditor({ resource: model.getResource() }, group);
await editorService.openEditor({ resource: model.resource }, group);
// Clean up
group.closeEditor(editor);

28
src/vs/workbench/services/textfile/browser/textFileService.ts
View file

@ -467,7 +467,7 @@ export abstract class AbstractTextFileService extends Disposable implements ITex
const sourceModels: ITextFileEditorModel[] = [];
const conflictingModels: ITextFileEditorModel[] = [];
for (const model of this.getFileModels()) {
const resource = model.getResource();
const resource = model.resource;
if (isEqualOrParent(resource, target, false /* do not ignorecase, see https://github.com/Microsoft/vscode/issues/56384 */)) {
conflictingModels.push(model);
@ -483,7 +483,7 @@ export abstract class AbstractTextFileService extends Disposable implements ITex
type ModelToRestore = { resource: URI; snapshot?: ITextSnapshot };
const modelsToRestore: ModelToRestore[] = [];
for (const sourceModel of sourceModels) {
const sourceModelResource = sourceModel.getResource();
const sourceModelResource = sourceModel.resource;
// If the source is the actual model, just use target as new resource
let modelToRestoreResource: URI;
@ -508,7 +508,7 @@ export abstract class AbstractTextFileService extends Disposable implements ITex
// in order to move, we need to soft revert all dirty models,
// both from the source as well as the target if any
const dirtyModels = [...sourceModels, ...conflictingModels].filter(model => model.isDirty());
await this.revertAll(dirtyModels.map(dirtyModel => dirtyModel.getResource()), { soft: true });
await this.revertAll(dirtyModels.map(dirtyModel => dirtyModel.resource), { soft: true });
// now we can rename the source to target via file operation
let stat: IFileStatWithMetadata;
@ -735,9 +735,9 @@ export abstract class AbstractTextFileService extends Disposable implements ITex
});
const mapResourceToResult = new ResourceMap<IResult>();
dirtyFileModels.forEach(m => {
mapResourceToResult.set(m.getResource(), {
source: m.getResource()
dirtyFileModels.forEach(dirtyModel => {
mapResourceToResult.set(dirtyModel.resource, {
source: dirtyModel.resource
});
});
@ -745,7 +745,7 @@ export abstract class AbstractTextFileService extends Disposable implements ITex
await model.save(options);
if (!model.isDirty()) {
const result = mapResourceToResult.get(model.getResource());
const result = mapResourceToResult.get(model.resource);
if (result) {
result.success = true;
}
@ -861,7 +861,7 @@ export abstract class AbstractTextFileService extends Disposable implements ITex
// path. This can happen if the file was created after the untitled file was opened.
// See https://github.com/Microsoft/vscode/issues/67946
let write: boolean;
if (sourceModel instanceof UntitledTextEditorModel && sourceModel.hasAssociatedFilePath && targetExists && isEqual(target, toLocalResource(sourceModel.getResource(), this.environmentService.configuration.remoteAuthority))) {
if (sourceModel instanceof UntitledTextEditorModel && sourceModel.hasAssociatedFilePath && targetExists && isEqual(target, toLocalResource(sourceModel.resource, this.environmentService.configuration.remoteAuthority))) {
write = await this.confirmOverwrite(target);
} else {
write = true;
@ -944,9 +944,9 @@ export abstract class AbstractTextFileService extends Disposable implements ITex
const fileModels = options?.force ? this.getFileModels(resources) : this.getDirtyFileModels(resources);
const mapResourceToResult = new ResourceMap<IResult>();
fileModels.forEach(m => {
mapResourceToResult.set(m.getResource(), {
source: m.getResource()
fileModels.forEach(fileModel => {
mapResourceToResult.set(fileModel.resource, {
source: fileModel.resource
});
});
@ -955,7 +955,7 @@ export abstract class AbstractTextFileService extends Disposable implements ITex
await model.revert(options?.soft);
if (!model.isDirty()) {
const result = mapResourceToResult.get(model.getResource());
const result = mapResourceToResult.get(model.resource);
if (result) {
result.success = true;
}
@ -964,7 +964,7 @@ export abstract class AbstractTextFileService extends Disposable implements ITex
// FileNotFound means the file got deleted meanwhile, so still record as successful revert
if ((<FileOperationError>error).fileOperationResult === FileOperationResult.FILE_NOT_FOUND) {
const result = mapResourceToResult.get(model.getResource());
const result = mapResourceToResult.get(model.resource);
if (result) {
result.success = true;
}
@ -983,7 +983,7 @@ export abstract class AbstractTextFileService extends Disposable implements ITex
getDirty(resources?: URI[]): URI[] {
// Collect files
const dirty = this.getDirtyFileModels(resources).map(m => m.getResource());
const dirty = this.getDirtyFileModels(resources).map(dirtyFileModel => dirtyFileModel.resource);
// Add untitled ones
dirty.push(...this.untitledTextEditorService.getDirty(resources));

10
src/vs/workbench/services/textfile/common/textFileEditorModel.ts
View file

@ -29,7 +29,7 @@ import { ILogService } from 'vs/platform/log/common/log';
import { isEqual, isEqualOrParent, extname, basename, joinPath } from 'vs/base/common/resources';
import { onUnexpectedError } from 'vs/base/common/errors';
import { Schemas } from 'vs/base/common/network';
import { IWorkingCopyService, IWorkingCopy, WorkingCopyCapabilities } from 'vs/workbench/services/workingCopy/common/workingCopyService';
import { IWorkingCopyService, WorkingCopyCapabilities } from 'vs/workbench/services/workingCopy/common/workingCopyService';
export interface IBackupMetaData {
mtime: number;
@ -58,7 +58,7 @@ type TelemetryData = {
/**
* The text file editor model listens to changes to its underlying code editor model and saves these changes through the file service back to the disk.
*/
export class TextFileEditorModel extends BaseTextEditorModel implements ITextFileEditorModel, IWorkingCopy {
export class TextFileEditorModel extends BaseTextEditorModel implements ITextFileEditorModel {
static DEFAULT_CONTENT_CHANGE_BUFFER_DELAY = CONTENT_CHANGE_EVENT_BUFFER_DELAY;
static DEFAULT_ORPHANED_CHANGE_BUFFER_DELAY = 100;
@ -1030,10 +1030,6 @@ export class TextFileEditorModel extends BaseTextEditorModel implements ITextFil
return this.disposed;
}
getResource(): URI {
return this.resource;
}
getStat(): IFileStatWithMetadata | undefined {
return this.lastResolvedFileStat;
}
@ -1144,6 +1140,6 @@ class DefaultSaveErrorHandler implements ISaveErrorHandler {
constructor(@INotificationService private readonly notificationService: INotificationService) { }
onSaveError(error: Error, model: TextFileEditorModel): void {
this.notificationService.error(nls.localize('genericSaveError', "Failed to save '{0}': {1}", basename(model.getResource()), toErrorMessage(error, false)));
this.notificationService.error(nls.localize('genericSaveError', "Failed to save '{0}': {1}", basename(model.resource), toErrorMessage(error, false)));
}
}

2
src/vs/workbench/services/textfile/common/textFileEditorModelManager.ts
View file

@ -304,7 +304,7 @@ export class TextFileEditorModelManager extends Disposable implements ITextFileE
return; // already disposed
}
if (this.mapResourceToPendingModelLoaders.has(model.getResource())) {
if (this.mapResourceToPendingModelLoaders.has(model.resource)) {
return; // not yet loaded
}

7
src/vs/workbench/services/textfile/common/textfiles.ts
View file

@ -15,6 +15,7 @@ import { RawContextKey } from 'vs/platform/contextkey/common/contextkey';
import { VSBuffer, VSBufferReadable } from 'vs/base/common/buffer';
import { isUndefinedOrNull } from 'vs/base/common/types';
import { isNative } from 'vs/base/common/platform';
import { IWorkingCopy } from 'vs/workbench/services/workingCopy/common/workingCopyService';
export const ITextFileService = createDecorator<ITextFileService>('textFileService');
@ -328,7 +329,7 @@ export class TextFileModelChangeEvent {
private _resource: URI;
constructor(model: ITextFileEditorModel, private _kind: StateChange) {
this._resource = model.getResource();
this._resource = model.resource;
}
get resource(): URI {
@ -492,13 +493,11 @@ export interface ILoadOptions {
reason?: LoadReason;
}
export interface ITextFileEditorModel extends ITextEditorModel, IEncodingSupport, IModeSupport {
export interface ITextFileEditorModel extends ITextEditorModel, IEncodingSupport, IModeSupport, IWorkingCopy {
readonly onDidContentChange: Event<StateChange>;
readonly onDidStateChange: Event<StateChange>;
getResource(): URI;
hasState(state: ModelState): boolean;
updatePreferredEncoding(encoding: string | undefined): void;

8
src/vs/workbench/services/textfile/test/textFileEditorModel.test.ts
View file

@ -95,7 +95,7 @@ suite('Files - TextFileEditorModel', () => {
assert.equal(accessor.workingCopyService.isDirty(model.resource), false);
model.dispose();
assert.ok(!accessor.modelService.getModel(model.getResource()));
assert.ok(!accessor.modelService.getModel(model.resource));
});
test('save - touching also emits saved event', async function () {
@ -123,7 +123,7 @@ suite('Files - TextFileEditorModel', () => {
assert.ok(!workingCopyEvent);
model.dispose();
assert.ok(!accessor.modelService.getModel(model.getResource()));
assert.ok(!accessor.modelService.getModel(model.resource));
});
test('setEncoding - encode', function () {
@ -162,7 +162,7 @@ suite('Files - TextFileEditorModel', () => {
assert.equal(model.textEditorModel!.getModeId(), mode);
model.dispose();
assert.ok(!accessor.modelService.getModel(model.getResource()));
assert.ok(!accessor.modelService.getModel(model.resource));
});
test('disposes when underlying model is destroyed', async function () {
@ -185,7 +185,7 @@ suite('Files - TextFileEditorModel', () => {
await model.load();
assert.ok(model.isResolved());
model.dispose();
assert.ok(!accessor.modelService.getModel(model.getResource()));
assert.ok(!accessor.modelService.getModel(model.resource));
});
test('Load returns dirty model as long as model is dirty', async function () {

2
src/vs/workbench/services/textfile/test/textFileEditorModelManager.test.ts
View file

@ -273,7 +273,7 @@ suite('Files - TextFileEditorModelManager', () => {
const model = await manager.loadOrCreate(resource, { encoding: 'utf8' });
model.dispose();
assert.ok(!manager.get(resource));
assert.ok(!accessor.modelService.getModel(model.getResource()));
assert.ok(!accessor.modelService.getModel(model.resource));
manager.dispose();
});

82
src/vs/workbench/services/textfile/test/textFileService.test.ts
View file

@ -67,7 +67,7 @@ suite('Files - TextFileService', () => {
test('confirm onWillShutdown - no veto', async function () {
model = instantiationService.createInstance(TextFileEditorModel, toResource.call(this, '/path/file.txt'), 'utf8', undefined);
(<TextFileEditorModelManager>accessor.textFileService.models).add(model.getResource(), model);
(<TextFileEditorModelManager>accessor.textFileService.models).add(model.resource, model);
const event = new BeforeShutdownEventImpl();
accessor.lifecycleService.fireWillShutdown(event);
@ -82,7 +82,7 @@ suite('Files - TextFileService', () => {
test('confirm onWillShutdown - veto if user cancels', async function () {
model = instantiationService.createInstance(TextFileEditorModel, toResource.call(this, '/path/file.txt'), 'utf8', undefined);
(<TextFileEditorModelManager>accessor.textFileService.models).add(model.getResource(), model);
(<TextFileEditorModelManager>accessor.textFileService.models).add(model.resource, model);
const service = accessor.textFileService;
service.setConfirmResult(ConfirmResult.CANCEL);
@ -98,7 +98,7 @@ suite('Files - TextFileService', () => {
test('confirm onWillShutdown - no veto and backups cleaned up if user does not want to save (hot.exit: off)', async function () {
model = instantiationService.createInstance(TextFileEditorModel, toResource.call(this, '/path/file.txt'), 'utf8', undefined);
(<TextFileEditorModelManager>accessor.textFileService.models).add(model.getResource(), model);
(<TextFileEditorModelManager>accessor.textFileService.models).add(model.resource, model);
const service = accessor.textFileService;
service.setConfirmResult(ConfirmResult.DONT_SAVE);
@ -124,7 +124,7 @@ suite('Files - TextFileService', () => {
test('confirm onWillShutdown - save (hot.exit: off)', async function () {
model = instantiationService.createInstance(TextFileEditorModel, toResource.call(this, '/path/file.txt'), 'utf8', undefined);
(<TextFileEditorModelManager>accessor.textFileService.models).add(model.getResource(), model);
(<TextFileEditorModelManager>accessor.textFileService.models).add(model.resource, model);
const service = accessor.textFileService;
service.setConfirmResult(ConfirmResult.SAVE);
@ -143,18 +143,18 @@ suite('Files - TextFileService', () => {
test('isDirty/getDirty - files and untitled', async function () {
model = instantiationService.createInstance(TextFileEditorModel, toResource.call(this, '/path/file.txt'), 'utf8', undefined);
(<TextFileEditorModelManager>accessor.textFileService.models).add(model.getResource(), model);
(<TextFileEditorModelManager>accessor.textFileService.models).add(model.resource, model);
const service = accessor.textFileService;
await model.load();
assert.ok(!service.isDirty(model.getResource()));
assert.ok(!service.isDirty(model.resource));
model.textEditorModel!.setValue('foo');
assert.ok(service.isDirty(model.getResource()));
assert.ok(service.isDirty(model.resource));
assert.equal(service.getDirty().length, 1);
assert.equal(service.getDirty([model.getResource()])[0].toString(), model.getResource().toString());
assert.equal(service.getDirty([model.resource])[0].toString(), model.resource.toString());
const untitled = accessor.untitledTextEditorService.createOrGet();
const untitledModel = await untitled.resolve();
@ -170,23 +170,23 @@ suite('Files - TextFileService', () => {
test('save - file', async function () {
model = instantiationService.createInstance(TextFileEditorModel, toResource.call(this, '/path/file.txt'), 'utf8', undefined);
(<TextFileEditorModelManager>accessor.textFileService.models).add(model.getResource(), model);
(<TextFileEditorModelManager>accessor.textFileService.models).add(model.resource, model);
const service = accessor.textFileService;
await model.load();
model.textEditorModel!.setValue('foo');
assert.ok(service.isDirty(model.getResource()));
assert.ok(service.isDirty(model.resource));
const res = await service.save(model.getResource());
const res = await service.save(model.resource);
assert.ok(res);
assert.ok(!service.isDirty(model.getResource()));
assert.ok(!service.isDirty(model.resource));
});
test('save - UNC path', async function () {
const untitledUncUri = URI.from({ scheme: 'untitled', authority: 'server', path: '/share/path/file.txt' });
model = instantiationService.createInstance(TextFileEditorModel, untitledUncUri, 'utf8', undefined);
(<TextFileEditorModelManager>accessor.textFileService.models).add(model.getResource(), model);
(<TextFileEditorModelManager>accessor.textFileService.models).add(model.resource, model);
const mockedFileUri = untitledUncUri.with({ scheme: Schemas.file });
const mockedEditorInput = instantiationService.createInstance(TextFileEditorModel, mockedFileUri, 'utf8', undefined);
@ -210,65 +210,65 @@ suite('Files - TextFileService', () => {
test('saveAll - file', async function () {
model = instantiationService.createInstance(TextFileEditorModel, toResource.call(this, '/path/file.txt'), 'utf8', undefined);
(<TextFileEditorModelManager>accessor.textFileService.models).add(model.getResource(), model);
(<TextFileEditorModelManager>accessor.textFileService.models).add(model.resource, model);
const service = accessor.textFileService;
await model.load();
model.textEditorModel!.setValue('foo');
assert.ok(service.isDirty(model.getResource()));
assert.ok(service.isDirty(model.resource));
const res = await service.saveAll([model.getResource()]);
const res = await service.saveAll([model.resource]);
assert.ok(res);
assert.ok(!service.isDirty(model.getResource()));
assert.ok(!service.isDirty(model.resource));
assert.equal(res.results.length, 1);
assert.equal(res.results[0].source.toString(), model.getResource().toString());
assert.equal(res.results[0].source.toString(), model.resource.toString());
});
test('saveAs - file', async function () {
model = instantiationService.createInstance(TextFileEditorModel, toResource.call(this, '/path/file.txt'), 'utf8', undefined);
(<TextFileEditorModelManager>accessor.textFileService.models).add(model.getResource(), model);
(<TextFileEditorModelManager>accessor.textFileService.models).add(model.resource, model);
const service = accessor.textFileService;
service.setPromptPath(model.getResource());
service.setPromptPath(model.resource);
await model.load();
model.textEditorModel!.setValue('foo');
assert.ok(service.isDirty(model.getResource()));
assert.ok(service.isDirty(model.resource));
const res = await service.saveAs(model.getResource());
assert.equal(res!.toString(), model.getResource().toString());
assert.ok(!service.isDirty(model.getResource()));
const res = await service.saveAs(model.resource);
assert.equal(res!.toString(), model.resource.toString());
assert.ok(!service.isDirty(model.resource));
});
test('revert - file', async function () {
model = instantiationService.createInstance(TextFileEditorModel, toResource.call(this, '/path/file.txt'), 'utf8', undefined);
(<TextFileEditorModelManager>accessor.textFileService.models).add(model.getResource(), model);
(<TextFileEditorModelManager>accessor.textFileService.models).add(model.resource, model);
const service = accessor.textFileService;
service.setPromptPath(model.getResource());
service.setPromptPath(model.resource);
await model.load();
model!.textEditorModel!.setValue('foo');
assert.ok(service.isDirty(model.getResource()));
assert.ok(service.isDirty(model.resource));
const res = await service.revert(model.getResource());
const res = await service.revert(model.resource);
assert.ok(res);
assert.ok(!service.isDirty(model.getResource()));
assert.ok(!service.isDirty(model.resource));
});
test('delete - dirty file', async function () {
model = instantiationService.createInstance(TextFileEditorModel, toResource.call(this, '/path/file.txt'), 'utf8', undefined);
(<TextFileEditorModelManager>accessor.textFileService.models).add(model.getResource(), model);
(<TextFileEditorModelManager>accessor.textFileService.models).add(model.resource, model);
const service = accessor.textFileService;
await model.load();
model!.textEditorModel!.setValue('foo');
assert.ok(service.isDirty(model.getResource()));
assert.ok(service.isDirty(model.resource));
await service.delete(model.getResource());
assert.ok(!service.isDirty(model.getResource()));
await service.delete(model.resource);
assert.ok(!service.isDirty(model.resource));
});
test('move - dirty file', async function () {
@ -282,27 +282,27 @@ suite('Files - TextFileService', () => {
async function testMove(source: URI, target: URI, targetDirty?: boolean): Promise<void> {
let sourceModel: TextFileEditorModel = instantiationService.createInstance(TextFileEditorModel, source, 'utf8', undefined);
let targetModel: TextFileEditorModel = instantiationService.createInstance(TextFileEditorModel, target, 'utf8', undefined);
(<TextFileEditorModelManager>accessor.textFileService.models).add(sourceModel.getResource(), sourceModel);
(<TextFileEditorModelManager>accessor.textFileService.models).add(targetModel.getResource(), targetModel);
(<TextFileEditorModelManager>accessor.textFileService.models).add(sourceModel.resource, sourceModel);
(<TextFileEditorModelManager>accessor.textFileService.models).add(targetModel.resource, targetModel);
const service = accessor.textFileService;
await sourceModel.load();
sourceModel.textEditorModel!.setValue('foo');
assert.ok(service.isDirty(sourceModel.getResource()));
assert.ok(service.isDirty(sourceModel.resource));
if (targetDirty) {
await targetModel.load();
targetModel.textEditorModel!.setValue('bar');
assert.ok(service.isDirty(targetModel.getResource()));
assert.ok(service.isDirty(targetModel.resource));
}
await service.move(sourceModel.getResource(), targetModel.getResource(), true);
await service.move(sourceModel.resource, targetModel.resource, true);
assert.equal(targetModel.textEditorModel!.getValue(), 'foo');
assert.ok(!service.isDirty(sourceModel.getResource()));
assert.ok(service.isDirty(targetModel.getResource()));
assert.ok(!service.isDirty(sourceModel.resource));
assert.ok(service.isDirty(targetModel.resource));
sourceModel.dispose();
targetModel.dispose();
@ -413,7 +413,7 @@ suite('Files - TextFileService', () => {
async function hotExitTest(this: any, setting: string, shutdownReason: ShutdownReason, multipleWindows: boolean, workspace: true, shouldVeto: boolean): Promise<void> {
model = instantiationService.createInstance(TextFileEditorModel, toResource.call(this, '/path/file.txt'), 'utf8', undefined);
(<TextFileEditorModelManager>accessor.textFileService.models).add(model.getResource(), model);
(<TextFileEditorModelManager>accessor.textFileService.models).add(model.resource, model);
const service = accessor.textFileService;
// Set hot exit config

4
src/vs/workbench/services/textmodelResolver/test/textModelResolverService.test.ts
View file

@ -88,11 +88,11 @@ suite('Workbench - TextModelResolverService', () => {
test('resolve file', async function () {
const textModel = instantiationService.createInstance(TextFileEditorModel, toResource.call(this, '/path/file_resolver.txt'), 'utf8', undefined);
(<TextFileEditorModelManager>accessor.textFileService.models).add(textModel.getResource(), textModel);
(<TextFileEditorModelManager>accessor.textFileService.models).add(textModel.resource, textModel);
await textModel.load();
const ref = await accessor.textModelResolverService.createModelReference(textModel.getResource());
const ref = await accessor.textModelResolverService.createModelReference(textModel.resource);
const model = ref.object;
const editorModel = model.textEditorModel;

4
src/vs/workbench/test/common/editor/untitledTextEditor.test.ts
View file

@ -151,11 +151,11 @@ suite('Workbench untitled text editors', () => {
const model3 = await service.loadOrCreate({ resource: input.getResource() });
assert.equal(model3.getResource().toString(), input.getResource().toString());
assert.equal(model3.resource.toString(), input.getResource().toString());
const file = URI.file(join('C:\\', '/foo/file44.txt'));
const model4 = await service.loadOrCreate({ resource: file });
assert.ok(service.hasAssociatedFilePath(model4.getResource()));
assert.ok(service.hasAssociatedFilePath(model4.resource));
assert.ok(model4.isDirty());
model1.dispose();