443 lines
16 KiB
JavaScript
Executable File
443 lines
16 KiB
JavaScript
Executable File
"use strict";
|
|
/**
|
|
* @license
|
|
* Copyright Google LLC All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.FilterHostTree = exports.HostCreateTree = exports.HostTree = exports.HostDirEntry = void 0;
|
|
const core_1 = require("@angular-devkit/core");
|
|
const jsonc_parser_1 = require("jsonc-parser");
|
|
const rxjs_1 = require("rxjs");
|
|
const util_1 = require("util");
|
|
const exception_1 = require("../exception/exception");
|
|
const delegate_1 = require("./delegate");
|
|
const entry_1 = require("./entry");
|
|
const interface_1 = require("./interface");
|
|
const recorder_1 = require("./recorder");
|
|
const scoped_1 = require("./scoped");
|
|
let _uniqueId = 0;
|
|
class HostDirEntry {
|
|
parent;
|
|
path;
|
|
_host;
|
|
_tree;
|
|
constructor(parent, path, _host, _tree) {
|
|
this.parent = parent;
|
|
this.path = path;
|
|
this._host = _host;
|
|
this._tree = _tree;
|
|
}
|
|
get subdirs() {
|
|
return this._host
|
|
.list(this.path)
|
|
.filter((fragment) => this._host.isDirectory((0, core_1.join)(this.path, fragment)));
|
|
}
|
|
get subfiles() {
|
|
return this._host
|
|
.list(this.path)
|
|
.filter((fragment) => this._host.isFile((0, core_1.join)(this.path, fragment)));
|
|
}
|
|
dir(name) {
|
|
return this._tree.getDir((0, core_1.join)(this.path, name));
|
|
}
|
|
file(name) {
|
|
return this._tree.get((0, core_1.join)(this.path, name));
|
|
}
|
|
visit(visitor) {
|
|
try {
|
|
this.getSubfilesRecursively().forEach((file) => visitor(file.path, file));
|
|
}
|
|
catch (e) {
|
|
if (e !== interface_1.FileVisitorCancelToken) {
|
|
throw e;
|
|
}
|
|
}
|
|
}
|
|
getSubfilesRecursively() {
|
|
function _recurse(entry) {
|
|
return entry.subdirs.reduce((files, subdir) => [...files, ..._recurse(entry.dir(subdir))], entry.subfiles.map((subfile) => entry.file(subfile)));
|
|
}
|
|
return _recurse(this);
|
|
}
|
|
}
|
|
exports.HostDirEntry = HostDirEntry;
|
|
class HostTree {
|
|
_backend;
|
|
_id = --_uniqueId;
|
|
_record;
|
|
_recordSync;
|
|
_ancestry = new Set();
|
|
_dirCache = new Map();
|
|
[interface_1.TreeSymbol]() {
|
|
return this;
|
|
}
|
|
static isHostTree(tree) {
|
|
if (tree instanceof HostTree) {
|
|
return true;
|
|
}
|
|
if (typeof tree === 'object' && typeof tree._ancestry === 'object') {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
constructor(_backend = new core_1.virtualFs.Empty()) {
|
|
this._backend = _backend;
|
|
this._record = new core_1.virtualFs.CordHost(new core_1.virtualFs.SafeReadonlyHost(_backend));
|
|
this._recordSync = new core_1.virtualFs.SyncDelegateHost(this._record);
|
|
}
|
|
_normalizePath(path) {
|
|
return (0, core_1.normalize)('/' + path);
|
|
}
|
|
_willCreate(path) {
|
|
return this._record.willCreate(path);
|
|
}
|
|
_willOverwrite(path) {
|
|
return this._record.willOverwrite(path);
|
|
}
|
|
_willDelete(path) {
|
|
return this._record.willDelete(path);
|
|
}
|
|
_willRename(path) {
|
|
return this._record.willRename(path);
|
|
}
|
|
branch() {
|
|
const branchedTree = new HostTree(this._backend);
|
|
branchedTree._record = this._record.clone();
|
|
branchedTree._recordSync = new core_1.virtualFs.SyncDelegateHost(branchedTree._record);
|
|
branchedTree._ancestry = new Set(this._ancestry).add(this._id);
|
|
return branchedTree;
|
|
}
|
|
isAncestorOf(tree) {
|
|
if (tree instanceof HostTree) {
|
|
return tree._ancestry.has(this._id);
|
|
}
|
|
if (tree instanceof delegate_1.DelegateTree) {
|
|
return this.isAncestorOf(tree._other);
|
|
}
|
|
if (tree instanceof scoped_1.ScopedTree) {
|
|
return this.isAncestorOf(tree._base);
|
|
}
|
|
return false;
|
|
}
|
|
merge(other, strategy = interface_1.MergeStrategy.Default) {
|
|
if (other === this) {
|
|
// Merging with yourself? Tsk tsk. Nothing to do at least.
|
|
return;
|
|
}
|
|
if (this.isAncestorOf(other)) {
|
|
// Workaround for merging a branch back into one of its ancestors
|
|
// More complete branch point tracking is required to avoid
|
|
strategy |= interface_1.MergeStrategy.Overwrite;
|
|
}
|
|
const creationConflictAllowed = (strategy & interface_1.MergeStrategy.AllowCreationConflict) == interface_1.MergeStrategy.AllowCreationConflict;
|
|
const overwriteConflictAllowed = (strategy & interface_1.MergeStrategy.AllowOverwriteConflict) == interface_1.MergeStrategy.AllowOverwriteConflict;
|
|
const deleteConflictAllowed = (strategy & interface_1.MergeStrategy.AllowDeleteConflict) == interface_1.MergeStrategy.AllowDeleteConflict;
|
|
other.actions.forEach((action) => {
|
|
switch (action.kind) {
|
|
case 'c': {
|
|
const { path, content } = action;
|
|
if (this._willCreate(path) || this._willOverwrite(path) || this.exists(path)) {
|
|
const existingContent = this.read(path);
|
|
if (existingContent && content.equals(existingContent)) {
|
|
// Identical outcome; no action required
|
|
return;
|
|
}
|
|
if (!creationConflictAllowed) {
|
|
throw new exception_1.MergeConflictException(path);
|
|
}
|
|
this._record.overwrite(path, content).subscribe();
|
|
}
|
|
else {
|
|
this._record.create(path, content).subscribe();
|
|
}
|
|
return;
|
|
}
|
|
case 'o': {
|
|
const { path, content } = action;
|
|
if (this._willDelete(path) && !overwriteConflictAllowed) {
|
|
throw new exception_1.MergeConflictException(path);
|
|
}
|
|
// Ignore if content is the same (considered the same change).
|
|
if (this._willOverwrite(path)) {
|
|
const existingContent = this.read(path);
|
|
if (existingContent && content.equals(existingContent)) {
|
|
// Identical outcome; no action required
|
|
return;
|
|
}
|
|
if (!overwriteConflictAllowed) {
|
|
throw new exception_1.MergeConflictException(path);
|
|
}
|
|
}
|
|
// We use write here as merge validation has already been done, and we want to let
|
|
// the CordHost do its job.
|
|
this._record.write(path, content).subscribe();
|
|
return;
|
|
}
|
|
case 'r': {
|
|
const { path, to } = action;
|
|
if (this._willDelete(path)) {
|
|
throw new exception_1.MergeConflictException(path);
|
|
}
|
|
if (this._willRename(path)) {
|
|
if (this._record.willRenameTo(path, to)) {
|
|
// Identical outcome; no action required
|
|
return;
|
|
}
|
|
// No override possible for renaming.
|
|
throw new exception_1.MergeConflictException(path);
|
|
}
|
|
this.rename(path, to);
|
|
return;
|
|
}
|
|
case 'd': {
|
|
const { path } = action;
|
|
if (this._willDelete(path)) {
|
|
// TODO: This should technically check the content (e.g., hash on delete)
|
|
// Identical outcome; no action required
|
|
return;
|
|
}
|
|
if (!this.exists(path) && !deleteConflictAllowed) {
|
|
throw new exception_1.MergeConflictException(path);
|
|
}
|
|
this._recordSync.delete(path);
|
|
return;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
get root() {
|
|
return this.getDir('/');
|
|
}
|
|
// Readonly.
|
|
read(path) {
|
|
const entry = this.get(path);
|
|
return entry ? entry.content : null;
|
|
}
|
|
readText(path) {
|
|
const data = this.read(path);
|
|
if (data === null) {
|
|
throw new exception_1.FileDoesNotExistException(path);
|
|
}
|
|
const decoder = new util_1.TextDecoder('utf-8', { fatal: true });
|
|
try {
|
|
// With the `fatal` option enabled, invalid data will throw a TypeError
|
|
return decoder.decode(data);
|
|
}
|
|
catch (e) {
|
|
if (e instanceof TypeError) {
|
|
throw new Error(`Failed to decode "${path}" as UTF-8 text.`);
|
|
}
|
|
throw e;
|
|
}
|
|
}
|
|
readJson(path) {
|
|
const content = this.readText(path);
|
|
const errors = [];
|
|
const result = (0, jsonc_parser_1.parse)(content, errors, { allowTrailingComma: true });
|
|
// If there is a parse error throw with the error information
|
|
if (errors[0]) {
|
|
const { error, offset } = errors[0];
|
|
throw new Error(`Failed to parse "${path}" as JSON. ${(0, jsonc_parser_1.printParseErrorCode)(error)} at offset: ${offset}.`);
|
|
}
|
|
return result;
|
|
}
|
|
exists(path) {
|
|
return this._recordSync.isFile(this._normalizePath(path));
|
|
}
|
|
get(path) {
|
|
const p = this._normalizePath(path);
|
|
if (this._recordSync.isDirectory(p)) {
|
|
throw new core_1.PathIsDirectoryException(p);
|
|
}
|
|
if (!this._recordSync.exists(p)) {
|
|
return null;
|
|
}
|
|
return new entry_1.LazyFileEntry(p, () => Buffer.from(this._recordSync.read(p)));
|
|
}
|
|
getDir(path) {
|
|
const p = this._normalizePath(path);
|
|
if (this._recordSync.isFile(p)) {
|
|
throw new core_1.PathIsFileException(p);
|
|
}
|
|
let maybeCache = this._dirCache.get(p);
|
|
if (!maybeCache) {
|
|
let parent = (0, core_1.dirname)(p);
|
|
if (p === parent) {
|
|
parent = null;
|
|
}
|
|
maybeCache = new HostDirEntry(parent && this.getDir(parent), p, this._recordSync, this);
|
|
this._dirCache.set(p, maybeCache);
|
|
}
|
|
return maybeCache;
|
|
}
|
|
visit(visitor) {
|
|
this.root.visit((path, entry) => {
|
|
visitor(path, entry);
|
|
});
|
|
}
|
|
// Change content of host files.
|
|
overwrite(path, content) {
|
|
const p = this._normalizePath(path);
|
|
if (!this._recordSync.exists(p)) {
|
|
throw new exception_1.FileDoesNotExistException(p);
|
|
}
|
|
const c = typeof content == 'string' ? Buffer.from(content) : content;
|
|
this._record.overwrite(p, c).subscribe();
|
|
}
|
|
beginUpdate(path) {
|
|
const entry = this.get(path);
|
|
if (!entry) {
|
|
throw new exception_1.FileDoesNotExistException(path);
|
|
}
|
|
return recorder_1.UpdateRecorderBase.createFromFileEntry(entry);
|
|
}
|
|
commitUpdate(record) {
|
|
if (record instanceof recorder_1.UpdateRecorderBase) {
|
|
const path = record.path;
|
|
const entry = this.get(path);
|
|
if (!entry) {
|
|
throw new exception_1.ContentHasMutatedException(path);
|
|
}
|
|
else {
|
|
const newContent = record.apply(entry.content);
|
|
if (!newContent.equals(entry.content)) {
|
|
this.overwrite(path, newContent);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
throw new exception_1.InvalidUpdateRecordException();
|
|
}
|
|
}
|
|
// Structural methods.
|
|
create(path, content) {
|
|
const p = this._normalizePath(path);
|
|
if (this._recordSync.exists(p)) {
|
|
throw new exception_1.FileAlreadyExistException(p);
|
|
}
|
|
const c = typeof content == 'string' ? Buffer.from(content) : content;
|
|
this._record.create(p, c).subscribe();
|
|
}
|
|
delete(path) {
|
|
this._recordSync.delete(this._normalizePath(path));
|
|
}
|
|
rename(from, to) {
|
|
this._recordSync.rename(this._normalizePath(from), this._normalizePath(to));
|
|
}
|
|
apply(action, strategy) {
|
|
throw new exception_1.SchematicsException('Apply not implemented on host trees.');
|
|
}
|
|
*generateActions() {
|
|
for (const record of this._record.records()) {
|
|
switch (record.kind) {
|
|
case 'create':
|
|
yield {
|
|
id: this._id,
|
|
parent: 0,
|
|
kind: 'c',
|
|
path: record.path,
|
|
content: Buffer.from(record.content),
|
|
};
|
|
break;
|
|
case 'overwrite':
|
|
yield {
|
|
id: this._id,
|
|
parent: 0,
|
|
kind: 'o',
|
|
path: record.path,
|
|
content: Buffer.from(record.content),
|
|
};
|
|
break;
|
|
case 'rename':
|
|
yield {
|
|
id: this._id,
|
|
parent: 0,
|
|
kind: 'r',
|
|
path: record.from,
|
|
to: record.to,
|
|
};
|
|
break;
|
|
case 'delete':
|
|
yield {
|
|
id: this._id,
|
|
parent: 0,
|
|
kind: 'd',
|
|
path: record.path,
|
|
};
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
get actions() {
|
|
// Create a list of all records until we hit our original backend. This is to support branches
|
|
// that diverge from each others.
|
|
return Array.from(this.generateActions());
|
|
}
|
|
}
|
|
exports.HostTree = HostTree;
|
|
class HostCreateTree extends HostTree {
|
|
constructor(host) {
|
|
super();
|
|
const tempHost = new HostTree(host);
|
|
tempHost.visit((path) => {
|
|
const content = tempHost.read(path);
|
|
if (content) {
|
|
this.create(path, content);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
exports.HostCreateTree = HostCreateTree;
|
|
class FilterHostTree extends HostTree {
|
|
constructor(tree, filter = () => true) {
|
|
const newBackend = new core_1.virtualFs.SimpleMemoryHost();
|
|
// cast to allow access
|
|
const originalBackend = tree._backend;
|
|
const recurse = (base) => {
|
|
return originalBackend.list(base).pipe((0, rxjs_1.mergeMap)((x) => x), (0, rxjs_1.map)((path) => (0, core_1.join)(base, path)), (0, rxjs_1.concatMap)((path) => {
|
|
let isDirectory = false;
|
|
originalBackend.isDirectory(path).subscribe((val) => (isDirectory = val));
|
|
if (isDirectory) {
|
|
return recurse(path);
|
|
}
|
|
let isFile = false;
|
|
originalBackend.isFile(path).subscribe((val) => (isFile = val));
|
|
if (!isFile || !filter(path)) {
|
|
return rxjs_1.EMPTY;
|
|
}
|
|
let content = null;
|
|
originalBackend.read(path).subscribe((val) => (content = val));
|
|
if (!content) {
|
|
return rxjs_1.EMPTY;
|
|
}
|
|
return newBackend.write(path, content);
|
|
}));
|
|
};
|
|
recurse((0, core_1.normalize)('/')).subscribe();
|
|
super(newBackend);
|
|
for (const action of tree.actions) {
|
|
if (!filter(action.path)) {
|
|
continue;
|
|
}
|
|
switch (action.kind) {
|
|
case 'c':
|
|
this.create(action.path, action.content);
|
|
break;
|
|
case 'd':
|
|
this.delete(action.path);
|
|
break;
|
|
case 'o':
|
|
this.overwrite(action.path, action.content);
|
|
break;
|
|
case 'r':
|
|
this.rename(action.path, action.to);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
exports.FilterHostTree = FilterHostTree;
|