Called after a file or folder has been deleted. This function is responsible
for updating underlying model data and notifying all views of the change.

@param {string} fullPath The path of the file/folder that has been deleted
166570
function notifyPathDeleted(fullPath) {
        // FileSyncManager.syncOpenDocuments() does all the work prompting
        //  the user to save any unsaved changes and then calls us back
        //  via notifyFileDeleted
        FileSyncManager.syncOpenDocuments(Strings.FILE_DELETED_TITLE);

        var projectRoot = ProjectManager.getProjectRoot(),
            context = {
                location : {
                    scope: "user",
                    layer: "project",
                    layerID: projectRoot.fullPath
                }
            };
        var encoding = PreferencesManager.getViewState("encoding", context);
        delete encoding[fullPath];
        PreferencesManager.setViewState("encoding", encoding, context);

        if (!getOpenDocumentForPath(fullPath) &&
                !MainViewManager.findInAllWorkingSets(fullPath).length) {
            // For images not open in the workingset,
            // FileSyncManager.syncOpenDocuments() will
            //  not tell us to close those views
            exports.trigger("pathDeleted", fullPath);
        }
    }
49494
function () {
      var fileContent = self._readFileSync();

      if (fileContent.instances && fileContent.instances[this._id]) {
        delete fileContent.instances[this._id];

        self._writeFileSync(fileContent);
      }
      else {
        debug('deleteSync instance %s not exists for app: %s', this._id, self._app);
      }
    }
1179042
function(filePath, callback) {
	if (!fs.existsSync(filePath)) {
		errorHandler("File " + filePath + " does not exist. Please specify a valid path.");
	}
	var body = '';
	var reader = fs.createReadStream(filePath);
	reader.on('data', function(chunks) {
		body += chunks;
	}).on('end', function() {
		callback(body);
	}).on('error', function(e) {
		throw e;
	});
}
900766
function(path) {
    var state = window.history.state,
        initialURL = get(this, '_initialURL');

    path = this.formatPath(path);

    if ((initialURL !== path && !state) || (state && state.path !== path)) {
      window.history.pushState({ path: path }, null, path);
    }
  }
911859
function resolver(filePath, callback) {
    var fullPath = path.join(this.config.publicPath, filePath);
    var options = {
      resourceURL: filePath,
      contents: fs.readFileSync(fullPath).toString()
    };

    // If we defined a custom browser-side message system, use it.
    if (this.update) {
      options.update = this.update;
    }
    // If we specified a `match` option for fb-flo notifications, use it.
    if (this.config.resolverMatch) {
      options.match = this.config.resolverMatch;
    }
    // If we defined an advanced reload mechanism (fb-flo only has true/false,
    // we also allow anymatch sets), use it.
    if (this.config.resolverReload) {
      options.reload = this.config.resolverReload(filePath);
    }

    // Hand the notification over to the fb-flo server.
    callback(options);
  }
43210
function onDeleted(files: Array<Object>) {
  if (!files) {
    return;
  }

  this._cache.remove(files); // No await on purpose
  files.forEach((file) => {
    file.status = ActionStatus.Deleted;
  });
  this::emitProgress("delete", files, 0, 1);
}
888534
public void setEditedFilePath(final String editedFilePath) {

        m_filePathField.setReadOnly(false);
        m_filePathField.setValue(editedFilePath);
        m_filePathField.setReadOnly(true);

    }
1287453
function _deleteAtPath(treeData, path) {
        var objectPath = _filePathToObjectPath(treeData, path);

        if (!objectPath) {
            return;
        }

        var originalName = _.last(objectPath);

        // Back up to the parent directory
        objectPath.pop();

        treeData = treeData.updateIn(objectPath, function (directory) {
            directory = directory.delete(originalName);
            return directory;
        });

        return treeData;
    }
890054
protected function afterDelete() 
	{
		parent::afterDelete();
		
		//delete article image
		$page_path = 'public/page';

		if($this->media != '' && file_exists($page_path.'/'.$this->media))
			rename($page_path.'/'.$this->media, 'public/page/verwijderen/'.$this->page_id.'_'.$this->media);
	}
1196963
function refresh(file, event, full) {
      views.forEach(function loopViews(path) {
        if (path !== full) return;

        tempers.forEach(function eachTemper(temper) {
          delete temper.file[path];
          delete temper.compiled[path];

          temper.prefetch(path);
        });
      });

      assets.forEach(function loopAssets(path) {
        if (path !== full) return;

        bigpipe.compiler.put(path);
      });

      bigpipe.emit('change', file, event, full);
      console.log([
        '[watch] detected content changes --'.blue,
        file.white,
        'changed'.white
      ].join(' '));
    }
896613
protected function createSingleFolderIfNotExists($fullPath) {
        $tempDir = codemonkey_pathTempDir;
        if (file_exists($tempDir.$fullPath) && is_dir($tempDir.$fullPath)) {
            return;
        }
        mkdir($tempDir.$fullPath);
        chmod($tempDir.$fullPath, 0775);
    }
928201
@Override
    protected void refresh(@NonNull Metadata nextPath) {
        super.refresh(nextPath);
        if (isLoading) {
            progressBar.setVisibility(View.VISIBLE);
            recyclerView.setVisibility(View.INVISIBLE);
        }
    }
1174735
function(callback) {
                //We want it once for the object path.
                e.once('mv#complete', function(err, path) {
                    if (err) {
                        console.error(err.stack)
                    }
                    callback(err, path)
                })
            }
643681
function(dirPath, callback) {
    logger.info('getDelta start', {category: 'sync-local-delta'});

    async.series([
      (cb) => {
        logger.debug('findDeletedNodes start', {category: 'sync-local-delta'});

        this.findDeletedNodes(cb)
      },
      (cb) => {
        logger.debug('findChanges start', {category: 'sync-local-delta'});

        this.findChanges(dirPath, undefined, null, cb);
      },
      (cb) => {
        logger.debug('resolveConflicts start', {category: 'sync-local-delta'});

        this.resolveConflicts(cb);
      }
    ], (err, resuls) => {
      logger.info('getDelta end', {category: 'sync-local-delta'});

      return callback(null);
    });
  }
1121003
public void rebuildNode(String fullPath) throws Exception
    {
        Preconditions.checkArgument(ZKPaths.getPathAndNode(fullPath).getPath().equals(path), "Node is not part of this cache: " + fullPath);
        Preconditions.checkState(!executorService.isShutdown(), "cache has been closed");

        ensurePath();
        internalRebuildNode(fullPath);

        // this is necessary so that any updates that occurred while rebuilding are taken
        // have to rebuild entire tree in case this node got deleted in the interim
        offerOperation(new RefreshOperation(this, RefreshMode.FORCE_GET_DATA_AND_STAT));
    }
857810
public static Message buildFileReceived(String fullPath) {
    ZabMessage.FileReceived received = ZabMessage.FileReceived
                                                 .newBuilder()
                                                 .setFullPath(fullPath)
                                                 .build();
    return Message.newBuilder().setType(MessageType.FILE_RECEIVED)
                               .setFileReceived(received).build();
  }
978401
function cleanPath(cleanPath) {
    const removePath = path.resolve(process.cwd(), cleanPath)
    rimraf(removePath, () => {
        console.log(removePath, "cleaned");
    });
}