public IFile createModuleFile(final Spec spec, String moduleFileName, final IPath modulePath) {
// Convert the OS specific absolute path to an Eclipse
// specific relative one that is portable iff the resource
// is in the project's folder hierarchy.
// Technically this will always evaluate to true. One of the
// checks above makes sure that one can only add modules
// residing in the project's parent.
if (ResourceHelper.isProjectParent(modulePath.removeLastSegments(1), spec.getProject())) {
moduleFileName = ResourceHelper.PARENT_ONE_PROJECT_LOC + modulePath.lastSegment();
}
// adding the file to the spec
return ResourceHelper.getLinkedFile(spec.getProject(), moduleFileName, true);
}
/**
* Renames the given spec to the given name
*
* @param spec
* @param newName
*/
public void renameSpec(Spec spec, final String newName, final IProgressMonitor aMonitor) {
this.lifecycleManager.sendEvent(new SpecRenameEvent(spec, newName));
// remove from storage
specStorage.remove(spec.getName());
// rename the underlying resource
IProject project = ResourceHelper.projectRename(spec.getProject(), newName, aMonitor);
// create new project with updated name
spec = new Spec(project);
spec.setLastModified();
// add it to storage
addSpec(spec);
}
/**
* @see
* org.eclipse.core.commands.AbstractHandler#execute(org.eclipse.core.commands.ExecutionEvent)
*/
public Object execute(ExecutionEvent event) throws ExecutionException {
IWorkbenchWindow window = HandlerUtil.getActiveWorkbenchWindowChecked(event);
Spec spec = Activator.getSpecManager().getSpecLoaded();
FileDialog openFileDialog = UIHelper.getFileDialog(window.getShell());
openFileDialog.setText("Add TLA+ module to the spec");
openFileDialog.setFilterPath(ResourceHelper.getParentDirName(spec.getRootFile()));
openFileDialog.setFilterExtensions(ACCEPTED_EXTENSIONS);
String moduleFileName = openFileDialog.open();
if (moduleFileName != null) {
IFile module = ResourceHelper.getLinkedFile(spec.getProject(), moduleFileName, false);
// add .tla extension is the file does not have any extension
if (module != null && module.getFileExtension() == null) {
moduleFileName = ResourceHelper.getModuleFileName(moduleFileName);
module = ResourceHelper.getLinkedFile(spec.getProject(), moduleFileName, false);
}
// check if it a TLA file
if (!ResourceHelper.isModule(module)) {
// selected non-TLA file
// module exists and is already registered in the spec
MessageDialog.openInformation(
window.getShell(),
"The selected file is not a TLA+ file",
"The provided file "
+ module.getName()
+ " is not a TLA+ file.\n Please select a file with .tla extension.");
return null;
} else {
if (module.isLinked()) {
// module exists and is already registered in the spec
MessageDialog.openInformation(
window.getShell(),
"TLA+ Module is part of the spec",
"The provided module "
+ module.getName()
+ " has already been added to the specification previously.");
} else {
IPath modulePath = new Path(moduleFileName);
// check the folder we are in
if (!ResourceHelper.isProjectParent(
modulePath.removeLastSegments(1), spec.getProject())) {
// the selected resource is not in the same directory as
// the root file
MessageDialog.openInformation(
window.getShell(),
"TLA+ Module is not part of the current spec.",
"The provided module "
+ module.getName()
+ " is not part of the spec which is currently open. It will therefore be opened in read-only mode.\n"
+ "If you want to make changes to this file, you will have to open the corresponding spec first.");
// Open TLA's read-only editor on a .tla file that does
// *not* belong to the current spec. It is opened
// read-only, because we want to allow any changes,
// because we couldn't parse the spec anyway. The reason
// why this functionality is offered, is to allow users
// to look at .tla files of closed spec.
// http://wiki.eclipse.org/FAQ_How_do_I_open_an_editor_on_a_file_outside_the_workspace%3F
final IFileStore fileStore =
EFS.getLocalFileSystem().getStore(new Path(moduleFileName));
if (!fileStore.fetchInfo().isDirectory() && fileStore.fetchInfo().exists()) {
UIHelper.openEditor(
"org.lamport.tla.toolbox.editor.basic.TLAEditorReadOnly",
new FileStoreEditorInput(fileStore));
} else {
throw new ExecutionException(
moduleFileName
+ " cannot be opened in read-only mode because its file content could not be obtained.");
}
return null;
}
// !module.exists()
if (!modulePath.toFile().exists()) {
// the provided file does not exist
boolean createNew =
MessageDialog.openQuestion(
window.getShell(),
"TLA+ Module is not found",
"The provided module "
+ module.getName()
+ " does not exist. Should the new file be created?");
if (createNew) {
// the module point to a virtual path /WS_ROOT/SPEC_NAME/module_name.tla
// assuming the fact that the root file is located in directory
// /ROOT_DIR/SPEC_NAME.tla
// and the Spec's project name is /ROOT_DIR/SPEC_NAME.project
// the file should be created in /ROOT_DIR/module_name.tla and linked to the virtual
// path.
try {
ResourcesPlugin.getWorkspace()
.run(ResourceHelper.createTLAModuleCreationOperation(modulePath), null);
} catch (CoreException e) {
e.printStackTrace();
// exception, no chance to recover
return null;
}
} else {
return null;
}
}
// adding the file to the spec
module = createModuleFile(spec, moduleFileName, modulePath);
}
// create parameters for the handler
Map<String, String> parameters = new HashMap<String, String>();
parameters.put(
OpenModuleHandler.PARAM_MODULE,
ResourceHelper.getModuleNameChecked(module.getName(), false));
// runs the command and opens the module in the editor
UIHelper.runCommand(OpenModuleHandler.COMMAND_ID, parameters);
}
}
return null;
}
/**
* Removes the specification. Modified 3 August 2011 by LL to add the boolean argument to say if
* this is a Forget command, which doesn't delete the spec's .toolbox directory, or a Delete
* command, which does.
*
* @param spec specification to remove
* @param aMonitor a monitor to track progress
* @param isForget do not delete .toolbox directory
*/
public void removeSpec(final Spec spec, final IProgressMonitor aMonitor, boolean isForget) {
this.lifecycleManager.sendEvent(new SpecEvent(spec, SpecEvent.TYPE_DELETE));
ResourceHelper.deleteProject(spec.getProject(), aMonitor, isForget);
specStorage.remove(spec.getName());
}