private void validateModule(@NotNull Module module) throws Exception {
    final String importedModulePath = getProject().getBaseDir().getPath();

    final Element actualImlElement = new Element("root");
    ((ModuleRootManagerImpl) ModuleRootManager.getInstance(module))
        .getState()
        .writeExternal(actualImlElement);
    PathMacros.getInstance().setMacro(MODULE_DIR, importedModulePath);
    PathMacroManager.getInstance(module).collapsePaths(actualImlElement);
    PathMacroManager.getInstance(getProject()).collapsePaths(actualImlElement);
    PathMacros.getInstance().removeMacro(MODULE_DIR);

    final String projectPath = getProject().getBaseDir().getPath();
    final File expectedImlFile = new File(projectPath + "/expected/" + module.getName() + ".iml");
    final Document expectedIml = JDOMUtil.loadDocument(expectedImlFile);
    final Element expectedImlElement = expectedIml.getRootElement();

    final String errorMsg =
        "Configuration of module "
            + module.getName()
            + " does not meet expectations.\nExpected:\n"
            + new String(JDOMUtil.printDocument(expectedIml, "\n"))
            + "\nBut got:\n"
            + new String(JDOMUtil.printDocument(new Document(actualImlElement), "\n"));
    Assert.assertTrue(errorMsg, JDOMUtil.areElementsEqual(expectedImlElement, actualImlElement));
    validateFacet(module);
  }
 /** Parse and print pretty-formatted XML to {@code logger}, if its level is DEBUG or below. */
 public static void prettyFormatXmlToLog(@NotNull Logger logger, @NotNull String xml) {
   if (logger.isDebugEnabled()) {
     try {
       logger.debug(
           "\n" + JDOMUtil.createOutputter("\n").outputString(JDOMUtil.loadDocument(xml)));
     } catch (Exception e) {
       logger.debug(e);
     }
   }
 }
Exemple #3
0
 public static boolean isEmpty(@Nullable Parent element) {
   if (element == null) {
     return true;
   } else if (element instanceof Element) {
     return JDOMUtil.isEmpty((Element) element);
   } else {
     Document document = (Document) element;
     return !document.hasRootElement() || JDOMUtil.isEmpty(document.getRootElement());
   }
 }
  @SuppressWarnings("deprecation")
  protected static void checkSettingsEqual(
      JDOMExternalizable expected, JDOMExternalizable settings, String message) throws Exception {
    if (expected == null || settings == null) return;

    Element oldS = new Element("temp");
    expected.writeExternal(oldS);
    Element newS = new Element("temp");
    settings.writeExternal(newS);

    String newString = JDOMUtil.writeElement(newS, "\n");
    String oldString = JDOMUtil.writeElement(oldS, "\n");
    Assert.assertEquals(message, oldString, newString);
  }
 private static void fillSdks(List<GlobalLibrary> globals) {
   for (Sdk sdk : ProjectJdkTable.getInstance().getAllJdks()) {
     final String name = sdk.getName();
     final String homePath = sdk.getHomePath();
     if (homePath == null) {
       continue;
     }
     final SdkAdditionalData data = sdk.getSdkAdditionalData();
     final String additionalDataXml;
     final SdkType sdkType = (SdkType) sdk.getSdkType();
     if (data == null) {
       additionalDataXml = null;
     } else {
       final Element element = new Element("additional");
       sdkType.saveAdditionalData(data, element);
       additionalDataXml = JDOMUtil.writeElement(element, "\n");
     }
     final List<String> paths =
         convertToLocalPaths(sdk.getRootProvider().getFiles(OrderRootType.CLASSES));
     String versionString = sdk.getVersionString();
     if (versionString != null && sdkType instanceof JavaSdk) {
       final JavaSdkVersion version = ((JavaSdk) sdkType).getVersion(versionString);
       if (version != null) {
         versionString = version.getDescription();
       }
     }
     globals.add(
         new SdkLibrary(
             name, sdkType.getName(), versionString, homePath, paths, additionalDataXml));
   }
 }
  @Override
  public void performPaste(@NotNull DataContext dataContext) {
    TemplateGroup group = myConfigurable.getSingleSelectedGroup();
    assert group != null;

    String buffer = CopyPasteManager.getInstance().getContents(DataFlavor.stringFlavor);
    assert buffer != null;

    try {
      for (Element templateElement :
          JDOMUtil.load(new StringReader("<root>" + buffer + "</root>"))
              .getChildren(TemplateSettings.TEMPLATE)) {
        TemplateImpl template =
            TemplateSettings.readTemplateFromElement(
                group.getName(), templateElement, getClass().getClassLoader());
        while (group.containsTemplate(template.getKey(), template.getId())) {
          template.setKey(template.getKey() + "1");
          if (template.getId() != null) {
            template.setId(template.getId() + "1");
          }
        }
        myConfigurable.addTemplate(template);
      }
    } catch (JDOMException ignore) {
    } catch (IOException ignore) {
    }
  }
    public ImportRunProfile(VirtualFile file, Project project) {
      myFile = file;
      myProject = project;
      try {
        final Document document = JDOMUtil.loadDocument(VfsUtilCore.virtualToIoFile(myFile));
        final Element config = document.getRootElement().getChild("config");
        if (config != null) {
          String configTypeId = config.getAttributeValue("configId");
          if (configTypeId != null) {
            final ConfigurationType configurationType =
                ConfigurationTypeUtil.findConfigurationType(configTypeId);
            if (configurationType != null) {
              myConfiguration =
                  configurationType.getConfigurationFactories()[0].createTemplateConfiguration(
                      project);
              myConfiguration.setName(config.getAttributeValue("name"));
              myConfiguration.readExternal(config);

              final Executor executor =
                  ExecutorRegistry.getInstance().getExecutorById(DefaultRunExecutor.EXECUTOR_ID);
              if (executor != null) {
                if (myConfiguration instanceof SMRunnerConsolePropertiesProvider) {
                  myProperties =
                      ((SMRunnerConsolePropertiesProvider) myConfiguration)
                          .createTestConsoleProperties(executor);
                }
              }
            }
          }
        }
      } catch (Exception ignore) {
      }
    }
 /** Print pretty-formatted XML to {@code logger}, if its level is DEBUG or below. */
 public static void prettyFormatXmlToLog(@NotNull Logger logger, @NotNull Element element) {
   if (logger.isDebugEnabled()) {
     // alternatively
     // new XMLOutputter(Format.getPrettyFormat()).outputString(root)
     logger.debug("\n" + JDOMUtil.createOutputter("\n").outputString(element));
   }
 }
 @Nullable
 public static Configuration load(final InputStream is) throws IOException, JDOMException {
   try {
     final Document document = JDOMUtil.loadDocument(is);
     final ArrayList<Element> elements = new ArrayList<Element>();
     elements.add(document.getRootElement());
     elements.addAll(document.getRootElement().getChildren("component"));
     final Element element =
         ContainerUtil.find(
             elements,
             new Condition<Element>() {
               public boolean value(final Element element) {
                 return "component".equals(element.getName())
                     && COMPONENT_NAME.equals(element.getAttributeValue("name"));
               }
             });
     if (element != null) {
       final Configuration cfg = new Configuration();
       cfg.loadState(element, false);
       return cfg;
     }
     return null;
   } finally {
     is.close();
   }
 }
  public void serializeInto(
      @NotNull Object o, @NotNull Element element, @NotNull SerializationFilter filter) {
    for (Binding binding : myPropertyBindings.keySet()) {
      Accessor accessor = myPropertyBindings.get(binding);
      if (!filter.accepts(accessor, o)) {
        continue;
      }

      // todo: optimize. Cache it.
      Property property = accessor.getAnnotation(Property.class);
      if (property != null && property.filter() != SerializationFilter.class) {
        try {
          if (!ReflectionUtil.newInstance(property.filter()).accepts(accessor, o)) {
            continue;
          }
        } catch (RuntimeException e) {
          throw new XmlSerializationException(e);
        }
      }

      Object node = binding.serialize(o, element, filter);
      if (node != null) {
        if (node instanceof org.jdom.Attribute) {
          element.setAttribute((org.jdom.Attribute) node);
        } else {
          JDOMUtil.addContent(element, node);
        }
      }
    }
  }
 private static void loadAdditionalRoots(
     Element rootModelComponent, final String rootsTagName, final JpsUrlList result) {
   final Element roots = rootModelComponent.getChild(rootsTagName);
   for (Element root : JDOMUtil.getChildren(roots, ROOT_TAG)) {
     result.addUrl(root.getAttributeValue(URL_ATTRIBUTE));
   }
 }
 public String getReportText() {
   final Element rootElement = new Element("root");
   rootElement.setAttribute("isBackward", String.valueOf(!myForward));
   final List<PsiFile> files = new ArrayList<PsiFile>(myDependencies.keySet());
   Collections.sort(
       files,
       new Comparator<PsiFile>() {
         @Override
         public int compare(PsiFile f1, PsiFile f2) {
           final VirtualFile virtualFile1 = f1.getVirtualFile();
           final VirtualFile virtualFile2 = f2.getVirtualFile();
           if (virtualFile1 != null && virtualFile2 != null) {
             return virtualFile1.getPath().compareToIgnoreCase(virtualFile2.getPath());
           }
           return 0;
         }
       });
   for (PsiFile file : files) {
     final Element fileElement = new Element("file");
     fileElement.setAttribute("path", file.getVirtualFile().getPath());
     for (PsiFile dep : myDependencies.get(file)) {
       Element depElement = new Element("dependency");
       depElement.setAttribute("path", dep.getVirtualFile().getPath());
       fileElement.addContent(depElement);
     }
     rootElement.addContent(fileElement);
   }
   PathMacroManager.getInstance(myProject).collapsePaths(rootElement);
   return JDOMUtil.writeDocument(new Document(rootElement), SystemProperties.getLineSeparator());
 }
Exemple #13
0
 @NotNull
 public static BufferExposingByteArrayOutputStream writeToBytes(
     @NotNull Parent element, @NotNull String lineSeparator) throws IOException {
   BufferExposingByteArrayOutputStream out = new BufferExposingByteArrayOutputStream(512);
   JDOMUtil.writeParent(element, out, lineSeparator);
   return out;
 }
  @NotNull
  private GradleProjectConfiguration loadLastConfiguration(@NotNull File gradleConfigFile) {
    final GradleProjectConfiguration projectConfig = new GradleProjectConfiguration();
    if (gradleConfigFile.exists()) {
      try {
        final Document document = JDOMUtil.loadDocument(gradleConfigFile);
        XmlSerializer.deserializeInto(projectConfig, document.getRootElement());

        // filter orphan modules
        final Set<String> actualModules = myModulesConfigurationHash.keySet();
        for (Iterator<Map.Entry<String, GradleModuleResourceConfiguration>> iterator =
                projectConfig.moduleConfigurations.entrySet().iterator();
            iterator.hasNext(); ) {
          Map.Entry<String, GradleModuleResourceConfiguration> configurationEntry = iterator.next();
          if (!actualModules.contains(configurationEntry.getKey())) {
            iterator.remove();
          }
        }
      } catch (Exception e) {
        LOG.info(e);
      }
    }

    return projectConfig;
  }
  @Override
  @Nullable
  public Object deserialize(Object o, @NotNull Object... nodes) {
    assert nodes.length > 0;
    Object[] children;
    if (nodes.length == 1) {
      children = JDOMUtil.getContent((Element) nodes[0]);
    } else {
      String name = ((Element) nodes[0]).getName();
      List<Content> childrenList = new SmartList<Content>();
      for (Object node : nodes) {
        assert ((Element) node).getName().equals(name);
        childrenList.addAll(((Element) node).getContent());
      }
      children = ArrayUtil.toObjectArray(childrenList);
    }

    if (children.length == 0) {
      children = new Object[] {new Text(myTagAnnotation.textIfEmpty())};
    }

    assert myBinding != null;
    Object v = myBinding.deserialize(myAccessor.read(o), children);
    Object value = XmlSerializerImpl.convert(v, myAccessor.getValueClass());
    myAccessor.write(o, value);
    return o;
  }
  @NotNull
  public static TreeMap<String, Element> load(
      @NotNull Element rootElement,
      @Nullable PathMacroSubstitutor pathMacroSubstitutor,
      boolean intern) {
    if (pathMacroSubstitutor != null) {
      pathMacroSubstitutor.expandPaths(rootElement);
    }

    StringInterner interner = intern ? new StringInterner() : null;
    List<Element> children = rootElement.getChildren(COMPONENT);
    TreeMap<String, Element> map = new TreeMap<String, Element>();
    for (Element element : children) {
      String name = getComponentNameIfValid(element);
      if (name == null
          || !(element.getAttributes().size() > 1 || !element.getChildren().isEmpty())) {
        continue;
      }

      if (interner != null) {
        JDOMUtil.internElement(element, interner);
      }

      map.put(name, element);

      if (pathMacroSubstitutor instanceof TrackingPathMacroSubstitutor) {
        ((TrackingPathMacroSubstitutor) pathMacroSubstitutor)
            .addUnknownMacros(name, PathMacrosCollector.getMacroNames(element));
      }

      // remove only after "getMacroNames" - some PathMacroFilter requires element name attribute
      element.removeAttribute(NAME);
    }
    return map;
  }
  @Override
  public boolean accepts(final Accessor accessor, final Object bean) {
    if (bean == null) {
      return true;
    }
    Object defaultBean = getDefaultBean(bean);

    final Object defValue = accessor.read(defaultBean);
    final Object beanValue = accessor.read(bean);
    if (defValue instanceof Element && beanValue instanceof Element) {
      return !JDOMUtil.writeElement((Element) defValue, "\n")
          .equals(JDOMUtil.writeElement((Element) beanValue, "\n"));
    }

    return !Comparing.equal(beanValue, defValue);
  }
 public void readExternal(
     @NotNull Document document, @NotNull URL url, boolean ignoreMissingInclude)
     throws InvalidDataException, FileNotFoundException {
   document = JDOMXIncluder.resolve(document, url.toExternalForm(), ignoreMissingInclude);
   Element rootElement = document.getRootElement();
   JDOMUtil.internElement(rootElement, new StringInterner());
   readExternal(document.getRootElement());
 }
 ApplicationInfoImpl() {
   String resource = IDEA_PATH + ApplicationNamesInfo.getComponentName() + XML_EXTENSION;
   try {
     Document doc = JDOMUtil.loadDocument(ApplicationInfoImpl.class, resource);
     loadState(doc.getRootElement());
   } catch (Exception e) {
     throw new RuntimeException("Cannot load resource: " + resource, e);
   }
 }
 @Nullable
 public static Element getSettingsElement(@Nullable Element element, String name) {
   for (Element child : JDOMUtil.getChildren(element, "setting")) {
     if (child.getAttributeValue("name").equals(name)) {
       return child;
     }
   }
   return null;
 }
 @Nullable
 private static Element findComponent(Element root, String componentName) {
   for (Element element : JDOMUtil.getChildren(root, "component")) {
     if (componentName.equals(element.getAttributeValue("name"))) {
       return element;
     }
   }
   return null;
 }
 @Nullable
 static String getComponentNameIfValid(@NotNull Element element) {
   String name = element.getAttributeValue(NAME);
   if (StringUtil.isEmpty(name)) {
     LOG.warn("No name attribute for component in " + JDOMUtil.writeElement(element));
     return null;
   }
   return name;
 }
 public static Document loadDocument(File file) throws CannotConvertException {
   try {
     return JDOMUtil.loadDocument(file);
   } catch (JDOMException e) {
     throw new CannotConvertException(file.getAbsolutePath() + ": " + e.getMessage(), e);
   } catch (IOException e) {
     throw new CannotConvertException(file.getAbsolutePath() + ": " + e.getMessage(), e);
   }
 }
 private static boolean isValidExternalFile(String version, File toCheck) {
   try {
     Document document = JDOMUtil.loadDocument(toCheck);
     String versionPattern = document.getRootElement().getChildText("version");
     return Pattern.compile(versionPattern).matcher(version).find();
   } catch (Exception e) {
     e.printStackTrace();
   }
   return false;
 }
 private void loadModules(Element root) {
   Element componentRoot = findComponent(root, "ProjectModuleManager");
   if (componentRoot == null) return;
   final Element modules = componentRoot.getChild("modules");
   for (Element moduleElement : JDOMUtil.getChildren(modules, "module")) {
     final String path = moduleElement.getAttributeValue("filepath");
     JpsModule module = loadModule(path);
     myProject.addModule(module);
   }
 }
 private Element loadRootElement(final File file) {
   try {
     final Element element = JDOMUtil.loadDocument(file).getRootElement();
     myMacroToPathMap.substitute(element, SystemInfo.isFileSystemCaseSensitive);
     return element;
   } catch (JDOMException e) {
     throw new RuntimeException(e);
   } catch (IOException e) {
     throw new RuntimeException(e);
   }
 }
 public void readExternal(@NotNull URL url) throws InvalidDataException, FileNotFoundException {
   try {
     Document document = JDOMUtil.loadDocument(url);
     readExternal(document, url);
   } catch (FileNotFoundException e) {
     throw e;
   } catch (IOException e) {
     throw new InvalidDataException(e);
   } catch (JDOMException e) {
     throw new InvalidDataException(e);
   }
 }
Exemple #28
0
 @Nullable
 public static Document loadDocument(final byte[] bytes) {
   try {
     return bytes == null || bytes.length == 0
         ? null
         : JDOMUtil.loadDocument(new ByteArrayInputStream(bytes));
   } catch (JDOMException e) {
     return null;
   } catch (IOException e) {
     return null;
   }
 }
  public void writeConfiguration(ProjectDescriptor pd, final PrintWriter out) {
    out.println("id: " + myId);

    out.println(
        JDOMUtil.writeElement(XmlSerializer.serialize(JpsFlexBCState.getState(myBC)), "\n"));

    final JpsFlexModuleOrProjectCompilerOptions moduleOptions =
        myBC.getModule().getProperties().getModuleLevelCompilerOptions();
    out.println(
        JDOMUtil.writeElement(
            XmlSerializer.serialize(((JpsFlexCompilerOptionsImpl) moduleOptions).getState()),
            "\n"));

    final JpsFlexModuleOrProjectCompilerOptions projectOptions =
        JpsFlexProjectLevelCompilerOptionsExtension.getProjectLevelCompilerOptions(
            myBC.getModule().getProject());
    out.println(
        JDOMUtil.writeElement(
            XmlSerializer.serialize(((JpsFlexCompilerOptionsImpl) projectOptions).getState()),
            "\n"));
  }
Exemple #30
0
  /**
   * Changes parent keymap for the Vim
   *
   * @return true if document was changed successfully
   */
  private static boolean configureVimParentKeymap(
      final String path, @NotNull final Document document, final boolean showNotification)
      throws IOException, InvalidDataException {
    final Element rootElement = document.getRootElement();
    final String parentKeymapName = rootElement.getAttributeValue("parent");
    final VimKeymapDialog vimKeymapDialog = new VimKeymapDialog(parentKeymapName);
    vimKeymapDialog.show();
    if (vimKeymapDialog.getExitCode() != DialogWrapper.OK_EXIT_CODE) {
      return false;
    }
    rootElement.removeAttribute("parent");
    final Keymap parentKeymap = vimKeymapDialog.getSelectedKeymap();
    final String keymapName = parentKeymap.getName();
    VimKeymapConflictResolveUtil.resolveConflicts(rootElement, parentKeymap);
    // We cannot set a user-defined modifiable keymap as the parent of our Vim keymap so we have to
    // copy its shortcuts
    if (parentKeymap.canModify()) {
      final KeymapImpl vimKeyMap = new KeymapImpl();
      final KeymapManager keymapManager = KeymapManager.getInstance();
      final KeymapManagerImpl keymapManagerImpl = (KeymapManagerImpl) keymapManager;
      final Keymap[] allKeymaps = keymapManagerImpl.getAllKeymaps();
      vimKeyMap.readExternal(rootElement, allKeymaps);
      final HashSet<String> ownActions =
          new HashSet<String>(Arrays.asList(vimKeyMap.getOwnActionIds()));
      final KeymapImpl parentKeymapImpl = (KeymapImpl) parentKeymap;
      for (String parentAction : parentKeymapImpl.getOwnActionIds()) {
        if (!ownActions.contains(parentAction)) {
          final List<Shortcut> shortcuts = Arrays.asList(parentKeymap.getShortcuts(parentAction));
          rootElement.addContent(
              VimKeymapConflictResolveUtil.createActionElement(parentAction, shortcuts));
        }
      }
      final Keymap grandParentKeymap = parentKeymap.getParent();
      rootElement.setAttribute("parent", grandParentKeymap.getName());
    } else {
      rootElement.setAttribute("parent", keymapName);
    }
    VimPlugin.getInstance().setPreviousKeyMap(keymapName);
    // Save modified keymap to the file
    JDOMUtil.writeDocument(document, path, "\n");
    if (showNotification) {
      Notifications.Bus.notify(
          new Notification(
              VimPlugin.IDEAVIM_NOTIFICATION_ID,
              VimPlugin.IDEAVIM_NOTIFICATION_TITLE,
              "Successfully configured vim keymap to be based on "
                  + parentKeymap.getPresentableName(),
              NotificationType.INFORMATION));
    }

    return true;
  }