// Fix issue adobe#13099

// See https://github.com/adobe/brackets/issues/13099

return !(

filename.match(_invalidChars)|| filename.match(_illegalFilenamesRegEx)

);

// Fix issue adobe#13099

// See https://github.com/adobe/brackets/issues/13099

return !(path.match(_invalidChars));

if (!path) {

return path;

} else if (_pathIsFile(path)) {

return FileSystem.getFileForPath(path);

}

return FileSystem.getDirectoryForPath(path);

if (fsobj && fsobj.fullPath) {

return fsobj.fullPath;

}

return fsobj;

var d = new $.Deferred();

var filename = FileUtils.getBaseName(path);

// Check if filename

if (!isValidFilename(filename)){

return d.reject(ERROR_INVALID_FILENAME).promise();

}

// Check if fullpath with filename is valid

// This check is used to circumvent directory jumps (Like ../..)

if (!isValidPath(path)) {

return d.reject(ERROR_INVALID_FILENAME).promise();

}

FileSystem.resolve(path, function (err) {

if (!err) {

// Item already exists, fail with error

d.reject(FileSystemError.ALREADY_EXISTS);

} else {

if (isFolder) {

var directory = FileSystem.getDirectoryForPath(path);

directory.create(function (err) {

if (err) {

d.reject(err);

} else {

d.resolve(directory);

}

});

} else {

// Create an empty file

var file = FileSystem.getFileForPath(path);

FileUtils.writeText(file, "").then(function () {

d.resolve(file);

}, d.reject);

}

}

});

return d.promise();

initial = initial || {};

if (initial.projectRoot) {

this.projectRoot = initial.projectRoot;

}

if (initial.focused !== undefined) {

this._focused = initial.focused;

}

this._viewModel = new FileTreeViewModel.FileTreeViewModel();

this._viewModel.on(FileTreeViewModel.EVENT_CHANGE, function () {

this.trigger(EVENT_CHANGE);

}.bind(this));

this._selections = {};

this._focused = focused;

if (!focused) {

this.setSelected(null);

}

// Ensure trailing slash to be consistent with projectRoot.fullPath

// so they're interchangable (i.e. easy to convert back and forth)

if (projectBaseUrl.length > 0 && projectBaseUrl[projectBaseUrl.length - 1] !== "/") {

projectBaseUrl += "/";

}

this._projectBaseUrl = projectBaseUrl;

return projectBaseUrl;

if (absPath && this.isWithinProject(absPath)) {

return absPath.slice(this.projectRoot.fullPath.length);

}

return absPath;

if (path && typeof path === "string") {

if (_.last(path) !== "/") {

path += "/";

}

} else if (path && path.isDirectory) {

path = path.fullPath;

} else {

path = null;

}

if (!path || (typeof path !== "string") || !this.isWithinProject(path)) {

path = this.projectRoot.fullPath;

}

return path;

if (!this._allFilesCachePromise) {

var deferred = new $.Deferred(),

allFiles = [],

allFilesVisitor = function (entry) {

if (shouldShow(entry)) {

if (entry.isFile) {

allFiles.push(entry);

}

return true;

}

return false;

};

this._allFilesCachePromise = deferred.promise();

var projectIndexTimer = PerfUtils.markStart("Creating project files cache: " +

this.projectRoot.fullPath),

options = {

sortList : sort

};

this.projectRoot.visit(allFilesVisitor, options, function (err) {

if (err) {

PerfUtils.finalizeMeasurement(projectIndexTimer);

deferred.reject(err);

} else {

PerfUtils.addMeasurement(projectIndexTimer);

deferred.resolve(allFiles);

}

}.bind(this));

}

return this._allFilesCachePromise;

// The filter and includeWorkingSet params are both optional.

// Handle the case where filter is omitted but includeWorkingSet is

// specified.

if (additionalFiles === undefined && typeof (filter) !== "function") {

additionalFiles = filter;

filter = null;

}

var filteredFilesDeferred = new $.Deferred();

// First gather all files in project proper

// Note that with proper promises we may be able to fix this so that we're not doing this

// anti-pattern of creating a separate deferred rather than just chaining off of the promise

// from _getAllFilesCache

this._getAllFilesCache(sort).done(function (result) {

// Add working set entries, if requested

if (additionalFiles) {

additionalFiles.forEach(function (file) {

if (result.indexOf(file) === -1 && !(file instanceof InMemoryFile)) {

result.push(file);

}

});

}

// Filter list, if requested

if (filter) {

result = result.filter(filter);

}

// If a done handler attached to the returned filtered files promise

// throws an exception that isn't handled here then it will leave

// _allFilesCachePromise in an inconsistent state such that no

// additional done handlers will ever be called!

try {

filteredFilesDeferred.resolve(result);

} catch (e) {

console.error("Unhandled exception in getAllFiles handler: " + e, e.stack);

}

}).fail(function (err) {

try {

filteredFilesDeferred.reject(err);

} catch (e) {

console.error("Unhandled exception in getAllFiles handler: " + e, e.stack);

}

});

return filteredFilesDeferred.promise();

this.projectRoot = projectRoot;

this._resetCache();

this._viewModel._rootChanged();

var d = new $.Deferred(),

self = this;

projectRoot.getContents(function (err, contents) {

if (err) {

d.reject(err);

} else {

self._viewModel.setDirectoryContents("", contents);

d.resolve();

}

});

return d.promise();

var d = new $.Deferred();

FileSystem.getDirectoryForPath(path).getContents(function (err, contents) {

if (err) {

d.reject(err);

} else {

d.resolve(contents);

}

});

return d.promise();

var projectRelative = this.makeProjectRelativeIfPossible(path),

needsLoading = !this._viewModel.isPathLoaded(projectRelative),

d = new $.Deferred(),

self = this;

function onSuccess(contents) {

// Update the view model

if (contents) {

self._viewModel.setDirectoryContents(projectRelative, contents);

}

if (open) {

self._viewModel.openPath(projectRelative);

if (self._focused) {

var currentPathInProject = self.makeProjectRelativeIfPossible(self._currentPath);

if (self._viewModel.isFilePathVisible(currentPathInProject)) {

self.setSelected(self._currentPath, true);

} else {

self.setSelected(null);

}

}

} else {

self._viewModel.setDirectoryOpen(projectRelative, false);

var selected = self._selections.selected;

if (selected) {

var relativeSelected = self.makeProjectRelativeIfPossible(selected);

if (!self._viewModel.isFilePathVisible(relativeSelected)) {

self.setSelected(null);

}

}

}

d.resolve();

}

// If the view model doesn't have the data it needs, we load it now, otherwise we can just

// manage the selection and resovle the promise.

if (open && needsLoading) {

var parentDirectory = FileUtils.getDirectoryPath(FileUtils.stripTrailingSlash(path));

this.setDirectoryOpen(parentDirectory, true).then(function () {

self._getDirectoryContents(path).then(onSuccess).fail(function (err) {

d.reject(err);

});

}, function (err) {

d.reject(err);

});

} else {

onSuccess();

}

return d.promise();

var d = new $.Deferred();

path = _getPathFromFSObject(path);

if (!this.isWithinProject(path)) {

return d.resolve().promise();

}

var parentDirectory = FileUtils.getDirectoryPath(path),

self = this;

this.setDirectoryOpen(parentDirectory, true).then(function () {

if (_pathIsFile(path)) {

self.setSelected(path);

}

d.resolve();

}, function (err) {

d.reject(err);

});

return d.promise();

path = _getPathFromFSObject(path);

// Directories are not selectable

if (!_pathIsFile(path)) {

return;

}

var oldProjectPath = this.makeProjectRelativeIfPossible(this._selections.selected),

pathInProject = this.makeProjectRelativeIfPossible(path);

if (path && !this._viewModel.isFilePathVisible(pathInProject)) {

path = null;

pathInProject = null;

}

this.performRename();

this._viewModel.moveMarker("selected", oldProjectPath, pathInProject);

if (this._selections.context) {

this._viewModel.moveMarker("context", this.makeProjectRelativeIfPossible(this._selections.context), null);

delete this._selections.context;

}

var previousSelection = this._selections.selected;

this._selections.selected = path;

if (path) {

if (!doNotOpen) {

this.trigger(EVENT_SHOULD_SELECT, {

path: path,

previousPath: previousSelection,

hadFocus: this._focused

});

}

this.trigger(EVENT_SHOULD_FOCUS);

}

this.performRename();

this.trigger(EVENT_SHOULD_SELECT, {

path: path,

add: true

});

// This bit is not ideal: when the user right-clicks on an item in the file tree

// and there is already a context menu up, the FileTreeView sends a signal to set the

// context to the new element but the PopupManager follows that with a message that it's

// closing the context menu (because it closes the previous one and then opens the new

// one.) This timing means that we need to provide some special case handling here.

if (_saveContext) {

if (!path) {

this._selections.previousContext = this._selections.context;

} else {

this._selections.previousContext = path;

}

} else {

delete this._selections.previousContext;

}

path = _getPathFromFSObject(path);

if (!_doNotRename) {

this.performRename();

}

var currentContext = this._selections.context;

this._selections.context = path;

this._viewModel.moveMarker("context", this.makeProjectRelativeIfPossible(currentContext),

this.makeProjectRelativeIfPossible(path));

if (this._selections.previousContext) {

this.setContext(this._selections.previousContext);

}

var d = new $.Deferred();

path = _getPathFromFSObject(path);

if (!path) {

path = this._selections.context;

if (!path) {

return d.resolve().promise();

}

}

if (this._selections.rename && this._selections.rename.path === path) {

return d.resolve().promise();

}

if (!this.isWithinProject(path)) {

return d.reject({

type: ERROR_NOT_IN_PROJECT,

isFolder: !_pathIsFile(path),

fullPath: path

}).promise();

}

var projectRelativePath = this.makeProjectRelativeIfPossible(path);

if (!this._viewModel.isFilePathVisible(projectRelativePath)) {

this.showInTree(path);

}

if (!isMoved) {

if (path !== this._selections.context) {

this.setContext(path);

} else {

this.performRename();

}

this._viewModel.moveMarker("rename", null,

projectRelativePath);

}

this._selections.rename = {

deferred: d,

type: FILE_RENAMING,

path: path,

newPath: path

};

return d.promise();

if (!this._selections.rename) {

return;

}

this._selections.rename.newPath = newPath;

var renameInfo = this._selections.rename;

if (!renameInfo) {

return;

}

// File creation is a special case.

if (renameInfo.type === FILE_CREATING) {

this._cancelCreating();

return;

}

this._viewModel.moveMarker("rename", this.makeProjectRelativeIfPossible(renameInfo.path), null);

renameInfo.deferred.resolve(RENAME_CANCELLED);

delete this._selections.rename;

this.setContext(null);

var result = new $.Deferred();

if (oldPath === newPath) {

result.resolve();

} else if (!isValidFilename(newName)) {

result.reject(ERROR_INVALID_FILENAME);

} else {

var entry = isFolder ? FileSystem.getDirectoryForPath(oldPath) : FileSystem.getFileForPath(oldPath);

entry.rename(newPath, function (err) {

if (err) {

result.reject(err);

} else {

result.resolve();

}

});

}

return result.promise();