Example #1
0
  private void onDescriptorsChanged() {
    IStructuredModel model = getModelForRead();
    if (model != null) {
      try {
        Node node = getManifestXmlNode(getXmlDocument(model));
        mUiManifestNode.reloadFromXmlNode(node);
      } finally {
        model.releaseFromRead();
      }
    }

    if (mOverviewPage != null) {
      mOverviewPage.refreshUiApplicationNode();
    }

    if (mAppPage != null) {
      mAppPage.refreshUiApplicationNode();
    }

    if (mPermissionPage != null) {
      mPermissionPage.refreshUiNode();
    }

    if (mInstrumentationPage != null) {
      mInstrumentationPage.refreshUiNode();
    }
  }
  public void connect(IDocument document) {
    fDocument = document;

    // special checks to see source validation should really execute
    IFile file = null;
    IStructuredModel model = null;
    try {
      model = StructuredModelManager.getModelManager().getExistingModelForRead(document);
      if (model != null) {
        String baseLocation = model.getBaseLocation();
        // The baseLocation may be a path on disk or relative to the
        // workspace root. Don't translate on-disk paths to
        // in-workspace resources.
        IPath basePath = new Path(baseLocation);
        if (basePath.segmentCount() > 1) {
          file = ResourcesPlugin.getWorkspace().getRoot().getFile(basePath);
          /*
           * If the IFile doesn't exist, make sure it's not returned
           */
          if (!file.exists()) file = null;
        }
      }
    } finally {
      if (model != null) {
        model.releaseFromRead();
      }
    }
    fEnableSourceValidation =
        (file != null
            && isBatchValidatorPreferenceEnabled(file)
            && shouldValidate(file)
            && fragmentCheck(file));
  }
  public static IJavaProject findJavaProject(ITextViewer viewer) {

    if (viewer == null) return null;

    IStructuredModel existingModelForRead =
        StructuredModelManager.getModelManager().getExistingModelForRead(viewer.getDocument());

    if (existingModelForRead == null) return null;

    IJavaProject javaProject = null;
    try {
      String baseLocation = existingModelForRead.getBaseLocation();
      // 20041129 (pa) the base location changed for XML model
      // because of FileBuffers, so this code had to be updated
      // https://bugs.eclipse.org/bugs/show_bug.cgi?id=79686
      IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
      IPath filePath = new Path(baseLocation);
      IProject project = null;
      if (filePath.segmentCount() > 0) {
        project = root.getProject(filePath.segment(0));
      }
      if (project != null) {
        javaProject = JavaCore.create(project);
      }
    } catch (Exception ex) {
      MapperPlugin.getDefault().logException(ex);
    }
    return javaProject;
  }
  public List collectJSONNodes(IStructuredModel model, int start, int length) {
    List nodes = new ArrayList();

    IndexedRegion startNode = model.getIndexedRegion(start);
    IndexedRegion endNode = model.getIndexedRegion(start + length - 1);

    if (startNode == null || endNode == null) {
      return nodes;
    }

    if (model instanceof IJSONModel
        && startNode instanceof IJSONNode
        && endNode instanceof IJSONNode) {
      // JSON model
      IJSONNode ca = getCommonAncestor((IJSONNode) startNode, (IJSONNode) endNode);
      if (ca != null) {
        for (IJSONNode node = ca.getFirstChild();
            node != null && start + length < ((IndexedRegion) node).getStartOffset();
            node = node.getNextSibling()) {
          if (start < ((IndexedRegion) node).getEndOffset()) {
            nodes.add(node);
          }
        }
      }
    }
    return nodes;
  }
Example #5
0
 /**
  * To see whether the textSelection start and end are on the same.
  *
  * @param model
  * @param textSelection
  * @return the node
  */
 static boolean isSame(IStructuredModel model, TextSelection textSelection) {
   if (model != null && textSelection != null) {
     int t1 = textSelection.getOffset();
     int t2 = textSelection.getLength() + t1;
     return model.getIndexedRegion(t1) == model.getIndexedRegion(t2);
   }
   return false;
 }
 public void testIsSaveNeeded() throws IOException, CoreException {
   IStructuredModel model = getTestModel();
   try {
     assertFalse("save should not be needed", model.isSaveNeeded());
   } finally {
     if (model != null) {
       model.releaseFromEdit();
     }
   }
 }
 public void testIsModelStateChanging() throws IOException, CoreException {
   IStructuredModel model = getTestModel();
   try {
     assertFalse("model should not be changing", model.isModelStateChanging());
   } finally {
     if (model != null) {
       model.releaseFromEdit();
     }
   }
 }
 public void testGetStructuredDocument() throws IOException, CoreException {
   IStructuredModel model = getTestModel();
   try {
     IStructuredDocument doc = model.getStructuredDocument();
     assertNotNull("document is null", doc);
   } finally {
     if (model != null) {
       model.releaseFromEdit();
     }
   }
 }
 public void testAboutToChangeModel() throws IOException, CoreException {
   IStructuredModel model = getTestModel();
   try {
     model.aboutToChangeModel();
     assertTrue(true);
   } finally {
     if (model != null) {
       model.releaseFromEdit();
     }
   }
 }
 public void testIsNew() throws IOException, CoreException {
   IStructuredModel model = getTestModel();
   try {
     // this API seems strange
     // assertFalse("new model check failed", model.isNew());
   } finally {
     if (model != null) {
       model.releaseFromEdit();
     }
   }
 }
 public void testGetIndexedRegions() throws IOException, CoreException {
   IStructuredModel model = getTestModel();
   try {
     // not implemented yet...
     // model.getIndexedRegions();
   } finally {
     if (model != null) {
       model.releaseFromEdit();
     }
   }
 }
 public void testGetIndexedRegion() throws IOException, CoreException {
   IStructuredModel model = getTestModel();
   try {
     model.getIndexedRegion(0);
     assertTrue(true);
   } finally {
     if (model != null) {
       model.releaseFromEdit();
     }
   }
 }
 public void testGetBaseLocation() throws IOException, CoreException {
   IStructuredModel model = getTestModel();
   try {
     String location = model.getBaseLocation();
     assertTrue("wrong base location", location.equals("/" + fProjectName + "/files/simple.xml"));
   } finally {
     if (model != null) {
       model.releaseFromEdit();
     }
   }
 }
 protected IndexedRegion getCorrespondingNode(IStructuredDocumentRegion sdRegion) {
   IStructuredModel sModel =
       StructuredModelManager.getModelManager().getExistingModelForRead(fDocument);
   IndexedRegion indexedRegion = null;
   try {
     if (sModel != null) indexedRegion = sModel.getIndexedRegion(sdRegion.getStart());
   } finally {
     if (sModel != null) sModel.releaseFromRead();
   }
   return indexedRegion;
 }
 public void testGetContentType() throws IOException, CoreException {
   IStructuredModel model = getTestModel();
   try {
     String ct = model.getContentTypeIdentifier();
     assertTrue(
         "model has wrong content type:" + ct + " != " + ContentTypeIdForXML.ContentTypeID_XML,
         ct.equals(ContentTypeIdForXML.ContentTypeID_XML));
   } finally {
     if (model != null) {
       model.releaseFromEdit();
     }
   }
 }
  @Test
  public void test(String fileName) {
    PdttFileExt testFile = filesMap.get(fileName);
    IFile file = project.findFile(testFile.getTestFiles().get(0).getName());

    IStructuredModel model = null;
    try {
      model = createUnManagedStructuredModelFor(file);
    } catch (IOException e) {
      fail(e.getMessage());
    } catch (CoreException e) {
      fail(e.getMessage());
    }
    assertNotNull(model);

    IStructuredDocument structuredDocument = model.getStructuredDocument();
    assertNotNull(structuredDocument);

    int start = Integer.valueOf(testFile.getConfig().get("start"));

    int length = Integer.valueOf(testFile.getConfig().get("length"));

    String visibility = testFile.getConfig().get("visibility");

    ExtractFunctionRefactoring processor =
        new ExtractFunctionRefactoring(
            DLTKCore.createSourceModuleFrom(file), structuredDocument, start, length);

    if ("default".equals(visibility)) {
      processor.setVisibility(Modifiers.AccDefault);
    }

    if ("public".equals(visibility)) {
      processor.setVisibility(Modifiers.AccPublic);
    }

    if ("prvate".equals(visibility)) {
      processor.setVisibility(Modifiers.AccPrivate);
    }

    if ("protected".equals(visibility)) {
      processor.setVisibility(Modifiers.AccProtected);
    }

    processor.setNewFunctionName(testFile.getConfig().get("newName"));

    checkInitCondition(processor);
    performChange(processor);
    checkTestResult(testFile, structuredDocument);
  }
 /**
  * Test expectes an exception since only a changedModel sent, without beginning
  * 'aboutToChangeModel'
  *
  * @throws CoreException
  * @throws IOException
  */
 public void testChangedModel() throws IOException, CoreException {
   IStructuredModel model = getTestModel();
   try {
     try {
       model.changedModel();
     } catch (Exception e) {
       assertTrue(e instanceof IllegalStateException);
     }
   } finally {
     if (model != null) {
       model.releaseFromEdit();
     }
   }
 }
 public boolean isShownInEditor(Match match, IEditorPart editor) {
   Object element = match.getElement();
   if (element instanceof IDOMNode) {
     // DOMNode matched
     IDOMNode node = (IDOMNode) element;
     IStructuredModel editorModel = (IStructuredModel) editor.getAdapter(IStructuredModel.class);
     if (editorModel != null) {
       // Returns true if found node belong to the current XML editor
       // which
       // has launched the search and false otherwise.
       return editorModel.equals(node.getModel());
     }
   }
   return false;
 }
 public void testNewInstance() throws IOException, CoreException {
   IStructuredModel model = getTestModel();
   try {
     IStructuredModel newInstance = null;
     try {
       newInstance = model.newInstance();
     } catch (IOException e) {
       assertTrue("IOException during model new instance", false);
     }
     assertNotNull("new instance is null", newInstance);
   } finally {
     if (model != null) {
       model.releaseFromEdit();
     }
   }
 }
 SourceViewer doCreateViewer(Composite parent, SourceViewerConfiguration viewerConfiguration) {
   SourceViewer viewer = null;
   String contentTypeID = ContentTypeIdForHTML.ContentTypeID_HTML;
   viewer =
       new StructuredTextViewer(
           parent, null, null, false, SWT.BORDER | SWT.V_SCROLL | SWT.H_SCROLL);
   viewer
       .getTextWidget()
       .setFont(JFaceResources.getFont("org.eclipse.wst.sse.ui.textfont")); // $NON-NLS-1$
   IStructuredModel scratchModel =
       StructuredModelManager.getModelManager().createUnManagedStructuredModelFor(contentTypeID);
   IDocument document = scratchModel.getStructuredDocument();
   viewer.configure(viewerConfiguration);
   viewer.setDocument(document);
   return viewer;
 }
  private boolean addXmlFileChanges(IFile file, CompositeChange changes, boolean isManifest) {
    IModelManager modelManager = StructuredModelManager.getModelManager();
    IStructuredModel model = null;
    try {
      model = modelManager.getExistingModelForRead(file);
      if (model == null) {
        model = modelManager.getModelForRead(file);
      }
      if (model != null) {
        IStructuredDocument document = model.getStructuredDocument();
        if (model instanceof IDOMModel) {
          IDOMModel domModel = (IDOMModel) model;
          Element root = domModel.getDocument().getDocumentElement();
          if (root != null) {
            List<TextEdit> edits = new ArrayList<TextEdit>();
            if (isManifest) {
              addManifestReplacements(edits, root, document);
            } else {
              addLayoutReplacements(edits, root, document);
            }
            if (!edits.isEmpty()) {
              MultiTextEdit rootEdit = new MultiTextEdit();
              rootEdit.addChildren(edits.toArray(new TextEdit[edits.size()]));
              TextFileChange change = new TextFileChange(file.getName(), file);
              change.setTextType(EXT_XML);
              change.setEdit(rootEdit);
              changes.add(change);
            }
          }
        } else {
          return false;
        }
      }

      return true;
    } catch (IOException e) {
      AdtPlugin.log(e, null);
    } catch (CoreException e) {
      AdtPlugin.log(e, null);
    } finally {
      if (model != null) {
        model.releaseFromRead();
      }
    }

    return false;
  }
  protected void updateDtdVersion(IProject project, String dtdVersion, String archetypeVesion) {
    final String tmpPublicId = dtdVersion;
    final String tmpSystemId = dtdVersion.replaceAll("\\.", "_");

    IStructuredModel editModel = null;

    final IFile[] metaFiles = getLiferayMetaFiles(project);

    for (IFile file : metaFiles) {
      try {
        editModel = StructuredModelManager.getModelManager().getModelForEdit(file);

        if (editModel != null && editModel instanceof IDOMModel) {
          final IDOMDocument xmlDocument = ((IDOMModel) editModel).getDocument();
          final DocumentTypeImpl docType = (DocumentTypeImpl) xmlDocument.getDoctype();

          final String publicId = docType.getPublicId();
          final String newPublicId = getNewDoctTypeSetting(publicId, tmpPublicId, publicid_pattern);

          if (newPublicId != null) {
            docType.setPublicId(newPublicId);
          }

          final String systemId = docType.getSystemId();
          final String newSystemId = getNewDoctTypeSetting(systemId, tmpSystemId, systemid_pattern);

          if (newSystemId != null) {
            docType.setSystemId(newSystemId);
          }

          editModel.save();
        }
      } catch (Exception e) {
        final IStatus error =
            ProjectCore.createErrorStatus(
                "Unable to upgrade deployment meta file for " + file.getName(), e);
        ProjectCore.logError(error);
      } finally {
        if (editModel != null) {
          editModel.releaseFromEdit();
        }
      }
    }

    ProjectCore.operate(
        project, UpdateDescriptorVersionOperation.class, archetypeVesion, dtdVersion);
  }
    /**
     * Returns the content type of document
     *
     * @param document - assumes document is not null
     * @return String content type of given document
     */
    private String getContentType() {
      String type = null;

      IModelManager mgr = StructuredModelManager.getModelManager();
      IStructuredModel model = null;
      try {
        model = mgr.getExistingModelForRead(document);
        if (model != null) {
          type = model.getContentTypeIdentifier();
        }
      } finally {
        if (model != null) {
          model.releaseFromRead();
        }
      }
      return type;
    }
Example #24
0
 private void tryConnectTo(IWorkbenchPart part) {
   if (part instanceof IEditorPart) {
     IStructuredModel model = (IStructuredModel) part.getAdapter(IStructuredModel.class);
     if (part != swtXmlEditorPart
         && model != null
         && SwtXmlModelHandler.associatedContentTypeID.equals(model.getContentTypeIdentifier())) {
       connectTo(part);
     } else if (((IEditorPart) part).getEditorInput() instanceof FileEditorInput) {
       if (((FileEditorInput) (((IEditorPart) part).getEditorInput()))
           .getFile()
           .toString()
           .endsWith(".properties")) {
         propertiesFileEditorPart = (IEditorPart) part;
         propertiesFileEditorPart.addPropertyListener(updatePreviewOnSavePropertiesFile);
       }
     }
   }
 }
  /**
   * Method validateEdit.
   *
   * @param file org.eclipse.core.resources.IFile
   * @param context org.eclipse.swt.widgets.Shell
   * @return IStatus
   */
  private static IStatus validateEdit(IFile file, Shell context) {
    if (file == null || !file.exists()) return STATUS_ERROR;
    if (!(file.isReadOnly())) return STATUS_OK;

    IPath location = file.getLocation();

    final long beforeModifiedFromJavaIO =
        (location != null) ? location.toFile().lastModified() : IResource.NULL_STAMP;
    final long beforeModifiedFromIFile = file.getModificationStamp();

    IStatus status = ResourcesPlugin.getWorkspace().validateEdit(new IFile[] {file}, context);
    if (!status.isOK()) return status;

    final long afterModifiedFromJavaIO =
        (location != null) ? location.toFile().lastModified() : IResource.NULL_STAMP;
    final long afterModifiedFromIFile = file.getModificationStamp();

    if (beforeModifiedFromJavaIO != afterModifiedFromJavaIO
        || beforeModifiedFromIFile != afterModifiedFromIFile) {
      IModelManager manager = StructuredModelManager.getModelManager();
      IStructuredModel model = manager.getExistingModelForRead(file);
      if (model != null) {
        if (!model.isDirty()) {
          try {
            file.refreshLocal(IResource.DEPTH_ONE, null);
          } catch (CoreException e) {
            return STATUS_ERROR;
          } finally {
            model.releaseFromRead();
          }
        } else {
          model.releaseFromRead();
        }
      }
    }

    if ((beforeModifiedFromJavaIO != afterModifiedFromJavaIO)
        || (beforeModifiedFromIFile != afterModifiedFromIFile)) {
      // the file is replaced. Modification cannot be
      // applied.
      return STATUS_ERROR;
    }
    return STATUS_OK;
  }
  public void testAddRemoveModelStateListener() throws IOException, CoreException {
    IStructuredModel model = getTestModel();
    try {
      IModelStateListener listener =
          new IModelStateListener() {

            public void modelAboutToBeChanged(IStructuredModel model) {
              //
            }

            public void modelChanged(IStructuredModel model) {
              //
            }

            public void modelDirtyStateChanged(IStructuredModel model, boolean isDirty) {
              //
            }

            public void modelResourceDeleted(IStructuredModel model) {
              //
            }

            public void modelResourceMoved(IStructuredModel oldModel, IStructuredModel newModel) {
              //
            }

            public void modelAboutToBeReinitialized(IStructuredModel structuredModel) {
              //
            }

            public void modelReinitialized(IStructuredModel structuredModel) {
              //
            }
          };

      model.aboutToChangeModel();

      model.removeModelStateListener(listener);
    } finally {
      if (model != null) {
        model.releaseFromEdit();
      }
    }
  }
  private void formatAndAssertEquals(
      String beforePath, String afterPath, XMLFormattingPreferences prefs)
      throws UnsupportedEncodingException, IOException, CoreException {
    IStructuredModel beforeModel = null, afterModel = null;
    try {
      beforeModel = getModelForEdit(beforePath);
      assertNotNull("could not retrieve structured model for : " + beforePath, beforeModel);

      afterModel = getModelForEdit(afterPath);
      assertNotNull("could not retrieve structured model for : " + afterPath, afterModel);

      IStructuredDocument document = beforeModel.getStructuredDocument();

      String normalizedContents = document.get();
      normalizedContents = StringUtils.replace(normalizedContents, "\r\n", "\n");
      normalizedContents = StringUtils.replace(normalizedContents, "\r", "\n");
      document.set(normalizedContents);

      if (prefs == null) prefs = new XMLFormattingPreferences();
      TextEdit edit = partitionFormatter.format(beforeModel, 0, document.getLength(), prefs);
      try {
        edit.apply(document);
      } catch (MalformedTreeException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      } catch (BadLocationException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      }

      ByteArrayOutputStream formattedBytes = new ByteArrayOutputStream();
      beforeModel.save(formattedBytes); // "beforeModel" should now be
      // after the formatter

      ByteArrayOutputStream afterBytes = new ByteArrayOutputStream();
      afterModel.save(afterBytes);

      String expectedContents = new String(afterBytes.toByteArray(), UTF_8);
      String actualContents = new String(formattedBytes.toByteArray(), UTF_8);

      /* Make some adjustments to ignore cross platform line delimiter issues */
      expectedContents = StringUtils.replace(expectedContents, "\r\n", "\n");
      expectedContents = StringUtils.replace(expectedContents, "\r", "\n");
      actualContents = StringUtils.replace(actualContents, "\r\n", "\n");
      actualContents = StringUtils.replace(actualContents, "\r", "\n");

      assertTrue(
          "Formatted document differs from the expected.\nExpected Contents:\n"
              + expectedContents
              + "\nActual Contents:\n"
              + actualContents,
          fStringCompareUtil.equalsIgnoreLineSeperator(expectedContents, actualContents));
    } finally {
      if (beforeModel != null) beforeModel.releaseFromEdit();
      if (afterModel != null) afterModel.releaseFromEdit();
    }
  }
 public static IProject getProject(IDocument document) {
   IStructuredModel model = null;
   try {
     model = StructuredModelManager.getModelManager().getExistingModelForRead(document);
     if (model != null) {
       String baselocation = model.getBaseLocation();
       if (baselocation != null) {
         // copied from JSPTranslationAdapter#getJavaProject
         IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
         IPath filePath = new Path(baselocation);
         if (filePath.segmentCount() > 0) {
           return root.getProject(filePath.segment(0));
         }
       }
     }
     return null;
   } finally {
     if (model != null) model.releaseFromRead();
   }
 }
Example #29
0
  void processAction(ITextEditor textEditor, IDocument document, ITextSelection textSelection) {
    int openCommentOffset = textSelection.getOffset();
    int closeCommentOffset = openCommentOffset + textSelection.getLength();

    if (textSelection.getLength() == 0) {
      return;
    }

    IStructuredModel model =
        StructuredModelManager.getModelManager().getExistingModelForEdit(document);
    if (model != null) {
      try {
        model.beginRecording(this, PHPUIMessages.AddBlockComment_tooltip);
        model.aboutToChangeModel();

        try {
          document.replace(closeCommentOffset, 0, CLOSE_COMMENT);
          document.replace(openCommentOffset, 0, OPEN_COMMENT);
        } catch (BadLocationException e) {
          Logger.log(Logger.WARNING_DEBUG, e.getMessage(), e);
        } finally {
          model.changedModel();
          model.endRecording(this);
        }
      } finally {
        model.releaseFromEdit();
      }
    }
  }
Example #30
0
 /**
  * Get node at indexed position.
  *
  * @param model
  * @param position
  * @return the node at position
  */
 static Node getNodeAt(IStructuredModel model, int position) {
   try {
     IndexedRegion region = model.getIndexedRegion(position);
     if (region instanceof Node) {
       return (Node) region;
     }
     return null;
   } catch (Exception e) {
     // "Error in region node creation"
     _log.error("Error.EditModelQuery.1", e); // $NON-NLS-1$
     return null;
   }
 }