public void testMoveProjectWithVirtualFolder() {
    IPath fileLocation = getRandomLocation();
    IPath folderLocation = getRandomLocation();

    IFile file = existingVirtualFolderInExistingProject.getFile(getUniqueString());
    IFolder folder = existingVirtualFolderInExistingProject.getFolder(getUniqueString());
    IFile childFile = folder.getFile(getUniqueString());
    IResource[] oldResources = new IResource[] {existingProject, file, folder, childFile};

    try {
      assertDoesNotExistInWorkspace("1.0", new IResource[] {folder, file, childFile});

      try {
        createFileInFileSystem(fileLocation);
        folderLocation.toFile().mkdir();

        folder.createLink(folderLocation, IResource.NONE, getMonitor());
        file.createLink(fileLocation, IResource.NONE, getMonitor());

        childFile.create(getRandomContents(), true, getMonitor());
      } catch (CoreException e) {
        fail("2.0", e);
      }

      // move the project
      IProject destinationProject = getWorkspace().getRoot().getProject("MoveTargetProject");
      assertDoesNotExistInWorkspace("3.0", destinationProject);

      try {
        existingProject.move(destinationProject.getFullPath(), IResource.SHALLOW, getMonitor());
      } catch (CoreException e) {
        fail("4.0", e);
      }

      IFile newFile = destinationProject.getFile(file.getProjectRelativePath());
      IFolder newFolder = destinationProject.getFolder(folder.getProjectRelativePath());
      IFile newChildFile = newFolder.getFile(childFile.getName());
      IResource[] newResources =
          new IResource[] {destinationProject, newFile, newFolder, newChildFile};

      assertExistsInWorkspace("5.0", newResources);
      assertDoesNotExistInWorkspace("6.1", oldResources);
      assertTrue("7.0", existingProject.isSynchronized(IResource.DEPTH_INFINITE));
      assertTrue("8.0", destinationProject.isSynchronized(IResource.DEPTH_INFINITE));

      assertTrue("9.0", newFile.getParent().isVirtual());
      assertTrue("10.0", newFile.isLinked());

      assertTrue("11.0", newFolder.isLinked());
      assertTrue("12.0", newFolder.getParent().isVirtual());
    } finally {
      Workspace.clear(fileLocation.toFile());
      Workspace.clear(folderLocation.toFile());
    }
  }
 @Override
 protected void checkFile(IFile file, Set<NodeDescriptor> cluster) {
   final String name = parser.containedModule(file);
   if (name == null) {
     return;
   }
   if (file.isLinked()) {
     checkLinkedFile(
         name,
         "Linked from "
             + ClusteringTools.truncate(file.getLocation().removeLastSegments(1).toOSString()));
   } else {
     addNodeToCluster(name, cluster);
   }
 }
 /**
  * Write the passed resource to the current archive.
  *
  * @param resource org.eclipse.core.resources.IFile
  * @param destinationPath java.lang.String
  * @exception java.io.IOException
  * @exception org.eclipse.core.runtime.CoreException
  */
 @Override
 public void write(IFile resource, String destinationPath) throws IOException, CoreException {
   if (!resolveLinks && resource.isLinked(IResource.DEPTH_INFINITE)) {
     return;
   }
   TarEntry newEntry = new TarEntry(destinationPath);
   if (resource.getLocalTimeStamp() != IResource.NULL_STAMP) {
     newEntry.setTime(resource.getLocalTimeStamp() / 1000);
   }
   ResourceAttributes attributes = resource.getResourceAttributes();
   if (attributes != null && attributes.isExecutable()) {
     newEntry.setMode(newEntry.getMode() | 0111);
   }
   if (attributes != null && attributes.isReadOnly()) {
     newEntry.setMode(newEntry.getMode() & ~0222);
   }
   write(newEntry, resource);
 }
Пример #4
0
 private void handleLinkedFiles(Collection<File> tmpToDelete, final File baseDir) {
   // Handle linked files
   for (IFile file : request.getOnlyOnFiles()) {
     if (file.isLinked()) {
       File tmp = new File(baseDir, file.getProjectRelativePath().toString());
       SonarLintCorePlugin.getDefault()
           .debug(
               file.getName()
                   + " is a linked resource. Will create a temporary copy"
                   + System.lineSeparator());
       try {
         Files.copy(file.getContents(), tmp.toPath());
         tmpToDelete.add(tmp);
       } catch (IOException | CoreException e) {
         SonarLintCorePlugin.getDefault()
             .error(
                 "Unable to create temporary copy for linked resource" + System.lineSeparator(),
                 e);
       }
     }
   }
 }
  public void testCopyProjectWithVirtualFolder() {
    IPath fileLocation = getRandomLocation();
    IPath folderLocation = getRandomLocation();

    IFile linkedFile = existingVirtualFolderInExistingProject.getFile(getUniqueString());
    IFolder linkedFolder = existingVirtualFolderInExistingProject.getFolder(getUniqueString());

    try {
      try {
        createFileInFileSystem(fileLocation, getRandomContents());
        folderLocation.toFile().mkdir();

        linkedFolder.createLink(folderLocation, IResource.NONE, getMonitor());
        linkedFile.createLink(fileLocation, IResource.NONE, getMonitor());
      } catch (CoreException e) {
        fail("1.0", e);
      }

      // copy the project
      IProject destinationProject = getWorkspace().getRoot().getProject("CopyTargetProject");
      try {
        existingProject.copy(destinationProject.getFullPath(), IResource.SHALLOW, getMonitor());
      } catch (CoreException e) {
        fail("2.0", e);
      }

      IFile newFile = destinationProject.getFile(linkedFile.getProjectRelativePath());
      assertTrue("3.0", newFile.isLinked());
      assertEquals("3.1", linkedFile.getLocation(), newFile.getLocation());
      assertTrue("3.2", newFile.getParent().isVirtual());

      IFolder newFolder = destinationProject.getFolder(linkedFolder.getProjectRelativePath());
      assertTrue("4.0", newFolder.isLinked());
      assertEquals("4.1", linkedFolder.getLocation(), newFolder.getLocation());
      assertTrue("4.2", newFolder.getParent().isVirtual());

      // test project deep copy
      try {
        destinationProject.delete(IResource.NONE, getMonitor());
        existingProject.copy(destinationProject.getFullPath(), IResource.NONE, getMonitor());
      } catch (CoreException e) {
        fail("5.0", e);
      }

      assertTrue("5.1", newFile.isLinked());
      assertEquals("5.2", linkedFile.getLocation(), newFile.getLocation());
      assertTrue("5.3", newFile.getParent().isVirtual());
      assertTrue("5.4", newFolder.isLinked());
      assertEquals("5.5", linkedFolder.getLocation(), newFolder.getLocation());
      assertTrue("5.6", newFolder.getParent().isVirtual());

      try {
        destinationProject.delete(IResource.NONE, getMonitor());
      } catch (CoreException e) {
        fail("6.0", e);
      }
    } finally {
      Workspace.clear(fileLocation.toFile());
      Workspace.clear(folderLocation.toFile());
    }
  }
Пример #6
0
  /**
   * @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;
  }