DEV/microsoft_vscode
1
0
Fork 0
mirror of https://github.com/microsoft/vscode.git synced 2026-04-20 00:04:14 +08:00
Code Issues Packages Projects Releases Wiki Activity

text files - rename models => files

Browse Source
This commit is contained in:
Benjamin Pasero 2020-01-16 12:47:46 +01:00
parent 3d9d1f9f2a
commit 41eabcfcd6
27 changed files with 79 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/vs/workbench/api/browser/mainThreadDocuments.ts
View File

@ -98,12 +98,12 @@ export class MainThreadDocuments implements MainThreadDocumentsShape {
this._toDispose.add(this._modelReferenceCollection);
this._toDispose.add(modelService.onModelModeChanged(this._onModelModeChanged, this));
this._toDispose.add(textFileService.models.onDidSave(e => {
this._toDispose.add(textFileService.files.onDidSave(e => {
if (this._shouldHandleFileEvent(e.model.resource)) {
this._proxy.$acceptModelSaved(e.model.resource);
}
}));
this._toDispose.add(textFileService.models.onDidChangeDirty(m => {
this._toDispose.add(textFileService.files.onDidChangeDirty(m => {
if (this._shouldHandleFileEvent(m.resource)) {
this._proxy.$acceptDirtyStateChanged(m.resource, m.isDirty());
}

2
src/vs/workbench/browser/dnd.ts
View File

@ -377,7 +377,7 @@ export function fillResourceDataTransfers(accessor: ServicesAccessor, resources:
encoding = model.getEncoding();
mode = model.getMode();
} else {
const model = textFileService.models.get(file.resource);
const model = textFileService.files.get(file.resource);
if (model) {
encoding = model.getEncoding();
mode = model.getMode();

2
src/vs/workbench/browser/parts/editor/editorStatus.ts
View File

@ -312,7 +312,7 @@ export class EditorStatus extends Disposable implements IWorkbenchContribution {
private registerListeners(): void {
this._register(this.editorService.onDidActiveEditorChange(() => this.updateStatusBar()));
this._register(this.textFileService.untitled.onDidChangeEncoding(r => this.onResourceEncodingChange(r)));
this._register(this.textFileService.models.onDidChangeEncoding(m => this.onResourceEncodingChange((m.resource))));
this._register(this.textFileService.files.onDidChangeEncoding(m => this.onResourceEncodingChange((m.resource))));
this._register(TabFocus.onDidChangeTabFocus(e => this.onTabFocusModeChange()));
}

12
src/vs/workbench/contrib/backup/test/electron-browser/backupOnShutdown.test.ts
View File

@ -66,13 +66,13 @@ suite('BackupOnShutdown', () => {
if (model) {
model.dispose();
}
(<TextFileEditorModelManager>accessor.textFileService.models).dispose();
(<TextFileEditorModelManager>accessor.textFileService.files).dispose();
backupOnShutdown.dispose();
});
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.resource, model);
(<TextFileEditorModelManager>accessor.textFileService.files).add(model.resource, model);
const event = new BeforeShutdownEventImpl();
accessor.lifecycleService.fireWillShutdown(event);
@ -87,7 +87,7 @@ suite('BackupOnShutdown', () => {
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.resource, model);
(<TextFileEditorModelManager>accessor.textFileService.files).add(model.resource, model);
accessor.fileDialogService.setConfirmResult(ConfirmResult.CANCEL);
@ -102,7 +102,7 @@ suite('BackupOnShutdown', () => {
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.resource, model);
(<TextFileEditorModelManager>accessor.textFileService.files).add(model.resource, model);
accessor.fileDialogService.setConfirmResult(ConfirmResult.DONT_SAVE);
accessor.filesConfigurationService.onFilesConfigurationChange({ files: { hotExit: 'off' } });
@ -127,7 +127,7 @@ suite('BackupOnShutdown', () => {
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.resource, model);
(<TextFileEditorModelManager>accessor.textFileService.files).add(model.resource, model);
accessor.fileDialogService.setConfirmResult(ConfirmResult.SAVE);
accessor.filesConfigurationService.onFilesConfigurationChange({ files: { hotExit: 'off' } });
@ -248,7 +248,7 @@ suite('BackupOnShutdown', () => {
async function hotExitTest(this: any, setting: string, shutdownReason: ShutdownReason, multipleWindows: boolean, workspace: boolean, shouldVeto: boolean): Promise<void> {
model = instantiationService.createInstance(TextFileEditorModel, toResource.call(this, '/path/file.txt'), 'utf8', undefined);
(<TextFileEditorModelManager>accessor.textFileService.models).add(model.resource, model);
(<TextFileEditorModelManager>accessor.textFileService.files).add(model.resource, model);
// Set hot exit config
accessor.filesConfigurationService.onFilesConfigurationChange({ files: { hotExit: setting } });

6
src/vs/workbench/contrib/backup/test/electron-browser/backupRestorer.test.ts
View File

@ -84,7 +84,7 @@ suite('BackupRestorer', () => {
dispose(disposables);
disposables = [];
(<TextFileEditorModelManager>accessor.textFileService.models).dispose();
(<TextFileEditorModelManager>accessor.textFileService.files).dispose();
return pfs.rimraf(backupHome, pfs.RimRafMode.MOVE);
});
@ -137,11 +137,11 @@ suite('BackupRestorer', () => {
model.dispose();
counter++;
} else if (isEqual(resource, fooFile)) {
const model = await accessor.textFileService.models.get(resource!)?.load();
const model = await accessor.textFileService.files.get(resource!)?.load();
assert.equal(model?.textEditorModel?.getValue(), 'fooFile');
counter++;
} else {
const model = await accessor.textFileService.models.get(resource!)?.load();
const model = await accessor.textFileService.files.get(resource!)?.load();
assert.equal(model?.textEditorModel?.getValue(), 'barFile');
counter++;
}

4
src/vs/workbench/contrib/backup/test/electron-browser/backupTracker.test.ts
View File

@ -90,7 +90,7 @@ suite('BackupTracker', () => {
dispose(disposables);
disposables = [];
(<TextFileEditorModelManager>accessor.textFileService.models).dispose();
(<TextFileEditorModelManager>accessor.textFileService.files).dispose();
return pfs.rimraf(backupHome, pfs.RimRafMode.MOVE);
});
@ -151,7 +151,7 @@ suite('BackupTracker', () => {
const resource = toResource.call(this, '/path/index.txt');
await accessor.editorService.openEditor({ resource, options: { pinned: true } });
const fileModel = accessor.textFileService.models.get(resource);
const fileModel = accessor.textFileService.files.get(resource);
fileModel?.textEditorModel?.setValue('Super Good');
await accessor.backupFileService.joinBackupResource();

2
src/vs/workbench/contrib/experiments/common/experimentService.ts
View File

@ -448,7 +448,7 @@ export class ExperimentService extends Disposable implements IExperimentService
}
}, 250));
const onSaveHandler = this._register(this.textFileService.models.onDidSave(e => onModelsSavedWorker.work(e.model)));
const onSaveHandler = this._register(this.textFileService.files.onDidSave(e => onModelsSavedWorker.work(e.model)));
return ExperimentState.Evaluating;
});
}

10
src/vs/workbench/contrib/files/browser/editors/fileEditorTracker.ts
View File

@ -58,8 +58,8 @@ export class FileEditorTracker extends Disposable implements IWorkbenchContribut
this._register(this.fileService.onFileChanges(e => this.onFileChanges(e)));
// Ensure dirty text file and untitled models are always opened as editors
this._register(this.textFileService.models.onDidChangeDirty(m => this.ensureDirtyFilesAreOpenedWorker.work(m.resource)));
this._register(this.textFileService.models.onDidSaveError(m => this.ensureDirtyFilesAreOpenedWorker.work(m.resource)));
this._register(this.textFileService.files.onDidChangeDirty(m => this.ensureDirtyFilesAreOpenedWorker.work(m.resource)));
this._register(this.textFileService.files.onDidSaveError(m => this.ensureDirtyFilesAreOpenedWorker.work(m.resource)));
this._register(this.textFileService.untitled.onDidChangeDirty(r => this.ensureDirtyFilesAreOpenedWorker.work(r)));
// Out of workspace file watchers
@ -112,7 +112,7 @@ export class FileEditorTracker extends Disposable implements IWorkbenchContribut
}
let encoding: string | undefined = undefined;
const model = this.textFileService.models.get(resource);
const model = this.textFileService.files.get(resource);
if (model) {
encoding = model.getEncoding();
}
@ -283,7 +283,7 @@ export class FileEditorTracker extends Disposable implements IWorkbenchContribut
return false; // resource must be dirty
}
const model = this.textFileService.models.get(resource);
const model = this.textFileService.files.get(resource);
if (model?.hasState(ModelState.PENDING_SAVE)) {
return false; // resource must not be pending to save
}
@ -362,7 +362,7 @@ export class FileEditorTracker extends Disposable implements IWorkbenchContribut
return undefined;
}
const model = this.textFileService.models.get(resource);
const model = this.textFileService.files.get(resource);
if (!model) {
return undefined;
}

4
src/vs/workbench/contrib/files/browser/editors/textFileSaveErrorHandler.ts
View File

@ -71,8 +71,8 @@ export class TextFileSaveErrorHandler extends Disposable implements ISaveErrorHa
}
private registerListeners(): void {
this._register(this.textFileService.models.onDidSave(e => this.onFileSavedOrReverted(e.model.resource)));
this._register(this.textFileService.models.onDidRevert(m => this.onFileSavedOrReverted(m.resource)));
this._register(this.textFileService.files.onDidSave(e => this.onFileSavedOrReverted(e.model.resource)));
this._register(this.textFileService.files.onDidRevert(m => this.onFileSavedOrReverted(m.resource)));
this._register(this.editorService.onDidActiveEditorChange(() => this.onActiveEditorChanged()));
}

2
src/vs/workbench/contrib/files/browser/fileCommands.ts
View File

@ -358,7 +358,7 @@ async function saveSelectedEditors(accessor: ServicesAccessor, options?: ISaveEd
// Check that the resource of the model was not saved already
if (resource && !editors.some(({ editor }) => isEqual(toResource(editor, { supportSideBySide: SideBySideEditor.MASTER }), resource))) {
const model = textFileService.models.get(resource);
const model = textFileService.files.get(resource);
if (!model?.isReadonly()) {
await textFileService.save(resource, options);
}

28
src/vs/workbench/contrib/files/common/editors/fileEditorInput.ts
View File

@ -70,15 +70,15 @@ export class FileEditorInput extends TextEditorInput implements IFileEditorInput
private registerListeners(): void {
// Dirty changes
this._register(this.textFileService.models.onDidChangeDirty(m => this.onDirtyStateChange(m)));
this._register(this.textFileService.models.onDidSaveError(m => this.onDirtyStateChange(m)));
this._register(this.textFileService.models.onDidSave(e => this.onDirtyStateChange(e.model)));
this._register(this.textFileService.models.onDidRevert(m => this.onDirtyStateChange(m)));
this._register(this.textFileService.files.onDidChangeDirty(m => this.onDirtyStateChange(m)));
this._register(this.textFileService.files.onDidSaveError(m => this.onDirtyStateChange(m)));
this._register(this.textFileService.files.onDidSave(e => this.onDirtyStateChange(e.model)));
this._register(this.textFileService.files.onDidRevert(m => this.onDirtyStateChange(m)));
// Label changes
this._register(this.labelService.onDidChangeFormatters(() => FileEditorInput.MEMOIZER.clear()));
this._register(this.fileService.onDidChangeFileSystemProviderRegistrations(() => FileEditorInput.MEMOIZER.clear()));
this._register(this.textFileService.models.onDidChangeOrphaned(model => this.onModelOrphanedChanged(model)));
this._register(this.textFileService.files.onDidChangeOrphaned(model => this.onModelOrphanedChanged(model)));
}
private onDirtyStateChange(model: ITextFileEditorModel): void {
@ -95,7 +95,7 @@ export class FileEditorInput extends TextEditorInput implements IFileEditorInput
}
getEncoding(): string | undefined {
const textModel = this.textFileService.models.get(this.resource);
const textModel = this.textFileService.files.get(this.resource);
if (textModel) {
return textModel.getEncoding();
}
@ -110,7 +110,7 @@ export class FileEditorInput extends TextEditorInput implements IFileEditorInput
setEncoding(encoding: string, mode: EncodingMode): void {
this.setPreferredEncoding(encoding);
const textModel = this.textFileService.models.get(this.resource);
const textModel = this.textFileService.files.get(this.resource);
if (textModel) {
textModel.setEncoding(encoding, mode);
}
@ -128,7 +128,7 @@ export class FileEditorInput extends TextEditorInput implements IFileEditorInput
setMode(mode: string): void {
this.setPreferredMode(mode);
const textModel = this.textFileService.models.get(this.resource);
const textModel = this.textFileService.files.get(this.resource);
if (textModel) {
textModel.setMode(mode);
}
@ -212,7 +212,7 @@ export class FileEditorInput extends TextEditorInput implements IFileEditorInput
}
private decorateLabel(label: string): string {
const model = this.textFileService.models.get(this.resource);
const model = this.textFileService.files.get(this.resource);
if (model?.hasState(ModelState.ORPHAN)) {
return localize('orphanedFile', "{0} (deleted)", label);
@ -226,13 +226,13 @@ export class FileEditorInput extends TextEditorInput implements IFileEditorInput
}
isReadonly(): boolean {
const model = this.textFileService.models.get(this.resource);
const model = this.textFileService.files.get(this.resource);
return model?.isReadonly() || this.fileService.hasCapability(this.resource, FileSystemProviderCapabilities.Readonly);
}
isDirty(): boolean {
const model = this.textFileService.models.get(this.resource);
const model = this.textFileService.files.get(this.resource);
if (!model) {
return false;
}
@ -241,7 +241,7 @@ export class FileEditorInput extends TextEditorInput implements IFileEditorInput
}
isSaving(): boolean {
const model = this.textFileService.models.get(this.resource);
const model = this.textFileService.files.get(this.resource);
if (!model) {
return false;
}
@ -285,7 +285,7 @@ export class FileEditorInput extends TextEditorInput implements IFileEditorInput
// Resolve as text
try {
await this.textFileService.models.loadOrCreate(this.resource, {
await this.textFileService.files.loadOrCreate(this.resource, {
mode: this.preferredMode,
encoding: this.preferredEncoding,
reload: { async: true }, // trigger a reload of the model if it exists already but do not wait to show the model
@ -324,7 +324,7 @@ export class FileEditorInput extends TextEditorInput implements IFileEditorInput
}
isResolved(): boolean {
return !!this.textFileService.models.get(this.resource);
return !!this.textFileService.files.get(this.resource);
}
dispose(): void {

4
src/vs/workbench/contrib/files/test/browser/editorAutoSave.test.ts
View File

@ -87,7 +87,7 @@ suite('EditorAutoSave', () => {
const resource = toResource.call(this, '/path/index.txt');
const model = await accessor.textFileService.models.loadOrCreate(resource) as IResolvedTextFileEditorModel;
const model = await accessor.textFileService.files.loadOrCreate(resource) as IResolvedTextFileEditorModel;
model.textEditorModel.setValue('Super Good');
@ -99,7 +99,7 @@ suite('EditorAutoSave', () => {
part.dispose();
editorAutoSave.dispose();
(<TextFileEditorModelManager>accessor.textFileService.models).dispose();
(<TextFileEditorModelManager>accessor.textFileService.files).dispose();
});
function awaitModelSaved(model: ITextFileEditorModel): Promise<void> {

8
src/vs/workbench/contrib/files/test/browser/fileEditorTracker.test.ts
View File

@ -62,7 +62,7 @@ suite('Files - FileEditorTracker', () => {
const resource = toResource.call(this, '/path/index.txt');
const model = await accessor.textFileService.models.loadOrCreate(resource) as IResolvedTextFileEditorModel;
const model = await accessor.textFileService.files.loadOrCreate(resource) as IResolvedTextFileEditorModel;
model.textEditorModel.setValue('Super Good');
assert.equal(snapshotToString(model.createSnapshot()!), 'Super Good');
@ -77,7 +77,7 @@ suite('Files - FileEditorTracker', () => {
assert.equal(snapshotToString(model.createSnapshot()!), 'Hello Html');
tracker.dispose();
(<TextFileEditorModelManager>accessor.textFileService.models).dispose();
(<TextFileEditorModelManager>accessor.textFileService.files).dispose();
});
async function createTracker(): Promise<[EditorPart, ServiceAccessor, FileEditorTracker]> {
@ -108,7 +108,7 @@ suite('Files - FileEditorTracker', () => {
assert.ok(!accessor.editorService.isOpen({ resource }));
const model = await accessor.textFileService.models.loadOrCreate(resource) as IResolvedTextFileEditorModel;
const model = await accessor.textFileService.files.loadOrCreate(resource) as IResolvedTextFileEditorModel;
model.textEditorModel.setValue('Super Good');
@ -117,7 +117,7 @@ suite('Files - FileEditorTracker', () => {
part.dispose();
tracker.dispose();
(<TextFileEditorModelManager>accessor.textFileService.models).dispose();
(<TextFileEditorModelManager>accessor.textFileService.files).dispose();
});
test('dirty untitled text file model opens as editor', async function () {

2
src/vs/workbench/contrib/search/browser/replaceService.ts
View File

@ -105,7 +105,7 @@ export class ReplaceService implements IReplaceService {
await this.bulkEditorService.apply({ edits }, { progress });
return Promise.all(edits.map(e => {
const model = this.textFileService.models.get(e.resource);
const model = this.textFileService.files.get(e.resource);
if (model) {
return model.save();
}

2
src/vs/workbench/contrib/surveys/browser/languageSurveys.contribution.ts
View File

@ -62,7 +62,7 @@ class LanguageSurvey extends Disposable {
});
}, 250));
this._register(textFileService.models.onDidSave(e => onModelsSavedWorker.work(e.model)));
this._register(textFileService.files.onDidSave(e => onModelsSavedWorker.work(e.model)));
}
const lastSessionDate = storageService.get(LAST_SESSION_DATE_KEY, StorageScope.GLOBAL, new Date(0).toDateString());

4
src/vs/workbench/contrib/telemetry/browser/telemetry.contribution.ts
View File

@ -124,8 +124,8 @@ export class TelemetryContribution extends Disposable implements IWorkbenchContr
this._register(configurationTelemetry(telemetryService, configurationService));
// Files Telemetry
this._register(textFileService.models.onDidLoad(e => this.onTextFileModelLoaded(e)));
this._register(textFileService.models.onDidSave(e => this.onTextFileModelSaved(e)));
this._register(textFileService.files.onDidLoad(e => this.onTextFileModelLoaded(e)));
this._register(textFileService.files.onDidSave(e => this.onTextFileModelSaved(e)));
// Lifecycle
this._register(lifecycleService.onShutdown(() => this.dispose()));

2
src/vs/workbench/services/textfile/browser/browserTextFileService.ts
View File

@ -24,7 +24,7 @@ export class BrowserTextFileService extends AbstractTextFileService {
}
protected onBeforeShutdown(reason: ShutdownReason): boolean {
if (this.models.getAll().some(model => model.hasState(ModelState.PENDING_SAVE))) {
if (this.files.getAll().some(model => model.hasState(ModelState.PENDING_SAVE))) {
console.warn('Unload prevented: pending file saves');
return true; // files are pending to be saved: veto

18
src/vs/workbench/services/textfile/browser/textFileService.ts
View File

@ -54,7 +54,7 @@ export abstract class AbstractTextFileService extends Disposable implements ITex
//#endregion
readonly models = this._register(this.instantiationService.createInstance(TextFileEditorModelManager));
readonly files = this._register(this.instantiationService.createInstance(TextFileEditorModelManager));
private _untitled: IUntitledTextEditorModelManager;
get untitled(): IUntitledTextEditorModelManager {
@ -159,7 +159,7 @@ export abstract class AbstractTextFileService extends Disposable implements ITex
// it again to make sure it is up to date with the contents
// we just wrote into the underlying resource by calling
// revert()
const existingModel = this.models.get(resource);
const existingModel = this.files.get(resource);
if (existingModel && !existingModel.isDisposed()) {
await existingModel.revert();
}
@ -275,7 +275,7 @@ export abstract class AbstractTextFileService extends Disposable implements ITex
// we know the file has changed on disk after the move and the
// model might have still existed with the previous state. this
// ensures we are not tracking a stale state.
const restoredModel = await this.models.loadOrCreate(modelToRestore.resource, { reload: { async: false }, encoding: modelToRestore.encoding, mode: modelToRestore.mode });
const restoredModel = await this.files.loadOrCreate(modelToRestore.resource, { reload: { async: false }, encoding: modelToRestore.encoding, mode: modelToRestore.mode });
// restore previous dirty content if any and ensure to mark
// the model as dirty
@ -324,7 +324,7 @@ export abstract class AbstractTextFileService extends Disposable implements ITex
// File
else {
const model = this.models.get(resource);
const model = this.files.get(resource);
if (model) {
// Save with options
@ -408,7 +408,7 @@ export abstract class AbstractTextFileService extends Disposable implements ITex
return models;
}
return this.models.getAll(arg1);
return this.files.getAll(arg1);
}
private getDirtyFileModels(resources?: URI | URI[]): ITextFileEditorModel[] {
@ -447,7 +447,7 @@ export abstract class AbstractTextFileService extends Disposable implements ITex
// If the source is an existing text file model, we can directly
// use that model to copy the contents to the target destination
const textFileModel = this.models.get(source);
const textFileModel = this.files.get(source);
if (textFileModel && textFileModel.isResolved()) {
success = await this.doSaveAsTextFile(textFileModel, source, target, options);
}
@ -498,7 +498,7 @@ export abstract class AbstractTextFileService extends Disposable implements ITex
// Prefer an existing model if it is already loaded for the given target resource
let targetExists: boolean = false;
let targetModel = this.models.get(target);
let targetModel = this.files.get(target);
if (targetModel?.isResolved()) {
targetExists = true;
}
@ -522,7 +522,7 @@ export abstract class AbstractTextFileService extends Disposable implements ITex
}
try {
targetModel = await this.models.loadOrCreate(target, { encoding: sourceModelEncoding, mode });
targetModel = await this.files.loadOrCreate(target, { encoding: sourceModelEncoding, mode });
} catch (error) {
// if the target already exists and was not created by us, it is possible
// that we cannot load the target as text model if it is binary or too
@ -680,7 +680,7 @@ export abstract class AbstractTextFileService extends Disposable implements ITex
isDirty(resource: URI): boolean {
// Check for dirty file
if (this.models.getAll(resource).some(model => model.isDirty())) {
if (this.files.getAll(resource).some(model => model.isDirty())) {
return true;
}

2
src/vs/workbench/services/textfile/common/textfiles.ts
View File

@ -37,7 +37,7 @@ export interface ITextFileService extends IDisposable {
* Access to the manager of text file editor models providing further
* methods to work with them.
*/
readonly models: ITextFileEditorModelManager;
readonly files: ITextFileEditorModelManager;
/**
* Access to the manager of untitled text editor models providing further

2
src/vs/workbench/services/textfile/test/textFileEditorModel.test.ts
View File

@ -47,7 +47,7 @@ suite('Files - TextFileEditorModel', () => {
});
teardown(() => {
(<TextFileEditorModelManager>accessor.textFileService.models).dispose();
(<TextFileEditorModelManager>accessor.textFileService.files).dispose();
TextFileEditorModel.setSaveParticipant(null); // reset any set participant
accessor.fileService.setContent(content);
});

2
src/vs/workbench/services/textfile/test/textFileService.io.test.ts
View File

@ -92,7 +92,7 @@ suite('Files - TextFileService i/o', () => {
});
teardown(async () => {
(<TextFileEditorModelManager>accessor.textFileService.models).dispose();
(<TextFileEditorModelManager>accessor.textFileService.files).dispose();
disposables.clear();

22
src/vs/workbench/services/textfile/test/textFileService.test.ts
View File

@ -50,12 +50,12 @@ suite('Files - TextFileService', () => {
if (model) {
model.dispose();
}
(<TextFileEditorModelManager>accessor.textFileService.models).dispose();
(<TextFileEditorModelManager>accessor.textFileService.files).dispose();
});
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.resource, model);
(<TextFileEditorModelManager>accessor.textFileService.files).add(model.resource, model);
await model.load();
@ -77,7 +77,7 @@ 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.resource, model);
(<TextFileEditorModelManager>accessor.textFileService.files).add(model.resource, model);
await model.load();
model.textEditorModel!.setValue('foo');
@ -91,11 +91,11 @@ suite('Files - TextFileService', () => {
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.resource, model);
(<TextFileEditorModelManager>accessor.textFileService.files).add(model.resource, model);
const mockedFileUri = untitledUncUri.with({ scheme: Schemas.file });
const mockedEditorInput = instantiationService.createInstance(TextFileEditorModel, mockedFileUri, 'utf8', undefined);
const loadOrCreateStub = sinon.stub(accessor.textFileService.models, 'loadOrCreate', () => Promise.resolve(mockedEditorInput));
const loadOrCreateStub = sinon.stub(accessor.textFileService.files, 'loadOrCreate', () => Promise.resolve(mockedEditorInput));
sinon.stub(accessor.textFileService.untitled, 'exists', () => true);
sinon.stub(accessor.textFileService.untitled, 'hasAssociatedFilePath', () => true);
@ -111,7 +111,7 @@ 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.resource, model);
(<TextFileEditorModelManager>accessor.textFileService.files).add(model.resource, model);
await model.load();
model.textEditorModel!.setValue('foo');
@ -124,7 +124,7 @@ suite('Files - TextFileService', () => {
test('saveAs - file', async function () {
model = instantiationService.createInstance(TextFileEditorModel, toResource.call(this, '/path/file.txt'), 'utf8', undefined);
(<TextFileEditorModelManager>accessor.textFileService.models).add(model.resource, model);
(<TextFileEditorModelManager>accessor.textFileService.files).add(model.resource, model);
accessor.textFileService.setPromptPath(model.resource);
await model.load();
@ -138,7 +138,7 @@ suite('Files - TextFileService', () => {
test('revert - file', async function () {
model = instantiationService.createInstance(TextFileEditorModel, toResource.call(this, '/path/file.txt'), 'utf8', undefined);
(<TextFileEditorModelManager>accessor.textFileService.models).add(model.resource, model);
(<TextFileEditorModelManager>accessor.textFileService.files).add(model.resource, model);
accessor.textFileService.setPromptPath(model.resource);
await model.load();
@ -152,7 +152,7 @@ suite('Files - TextFileService', () => {
test('delete - dirty file', async function () {
model = instantiationService.createInstance(TextFileEditorModel, toResource.call(this, '/path/file.txt'), 'utf8', undefined);
(<TextFileEditorModelManager>accessor.textFileService.models).add(model.resource, model);
(<TextFileEditorModelManager>accessor.textFileService.files).add(model.resource, model);
await model.load();
model!.textEditorModel!.setValue('foo');
@ -173,8 +173,8 @@ 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.resource, sourceModel);
(<TextFileEditorModelManager>accessor.textFileService.models).add(targetModel.resource, targetModel);
(<TextFileEditorModelManager>accessor.textFileService.files).add(sourceModel.resource, sourceModel);
(<TextFileEditorModelManager>accessor.textFileService.files).add(targetModel.resource, targetModel);
await sourceModel.load();
sourceModel.textEditorModel!.setValue('foo');

4
src/vs/workbench/services/textmodelResolver/common/textModelResolverService.ts
View File

@ -38,7 +38,7 @@ class ResourceModelCollection extends ReferenceCollection<Promise<ITextEditorMod
// File or remote file provider already known
if (this.fileService.canHandleResource(resource)) {
return this.textFileService.models.loadOrCreate(resource, { reason: LoadReason.REFERENCE });
return this.textFileService.files.loadOrCreate(resource, { reason: LoadReason.REFERENCE });
}
// Virtual documents
@ -64,7 +64,7 @@ class ResourceModelCollection extends ReferenceCollection<Promise<ITextEditorMod
modelPromise.then(model => {
if (this.modelsToDispose.has(key)) {
if (model instanceof TextFileEditorModel) {
this.textFileService.models.disposeModel(model);
this.textFileService.files.disposeModel(model);
} else {
model.dispose();
}

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

@ -48,7 +48,7 @@ suite('Workbench - TextModelResolverService', () => {
model.dispose();
model = (undefined)!;
}
(<TextFileEditorModelManager>accessor.textFileService.models).dispose();
(<TextFileEditorModelManager>accessor.textFileService.files).dispose();
});
test('resolve resource', async () => {
@ -86,7 +86,7 @@ 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.resource, textModel);
(<TextFileEditorModelManager>accessor.textFileService.files).add(textModel.resource, textModel);
await textModel.load();

2
src/vs/workbench/test/electron-browser/api/mainThreadDocumentsAndEditors.test.ts
View File

@ -48,7 +48,7 @@ suite('MainThreadDocumentsAndEditors', () => {
codeEditorService = new TestCodeEditorService();
textFileService = new class extends mock<ITextFileService>() {
isDirty() { return false; }
models = <any>{
files = <any>{
onDidSave: Event.None,
onDidRevert: Event.None,
onDidChangeDirty: Event.None

2
src/vs/workbench/test/electron-browser/api/mainThreadEditors.test.ts
View File

@ -72,7 +72,7 @@ suite('MainThreadEditors', () => {
copiedResources.set(source, target);
return Promise.resolve(Object.create(null));
}
models = <any>{
files = <any>{
onDidSave: Event.None,
onDidRevert: Event.None,
onDidChangeDirty: Event.None

2
src/vs/workbench/test/electron-browser/api/mainThreadSaveParticipant.test.ts
View File

@ -33,7 +33,7 @@ suite('MainThreadSaveParticipant', function () {
});
teardown(() => {
(<TextFileEditorModelManager>accessor.textFileService.models).dispose();
(<TextFileEditorModelManager>accessor.textFileService.files).dispose();
TextFileEditorModel.setSaveParticipant(null); // reset any set participant
});