public void insertOrUpdateTranslation(
      String key, String value, final PropertiesFile propertiesFile)
      throws IncorrectOperationException {
    final IProperty property = propertiesFile.findPropertyByKey(key);
    if (property != null) {
      final String oldValue = property.getValue();
      if (!Comparing.equal(oldValue, value)) {
        property.setValue(value);
        myCodeStyleManager.reformat(property.getPsiElement());
      }
      return;
    }

    if (myOrdered) {
      if (myAlphaSorted) {
        myCodeStyleManager.reformat(propertiesFile.addProperty(key, value).getPsiElement());
        return;
      }
      final Pair<IProperty, Integer> propertyAndPosition =
          findExistedPrevSiblingProperty(key, propertiesFile);
      myCodeStyleManager.reformat(
          propertiesFile
              .addPropertyAfter(
                  key,
                  value,
                  propertyAndPosition == null ? null : (Property) propertyAndPosition.getFirst())
              .getPsiElement());
    } else {
      insertPropertyLast(key, value, propertiesFile);
    }
  }
  @Nullable
  public PropertiesFile findPropertiesFile(
      final Module module, final String bundleName, final Locale locale) {
    List<PropertiesFile> propFiles = findPropertiesFiles(module, bundleName);
    if (locale != null) {
      for (PropertiesFile propFile : propFiles) {
        if (propFile.getLocale().equals(locale)) {
          return propFile;
        }
      }
    }

    // fallback to default locale
    for (PropertiesFile propFile : propFiles) {
      if (propFile.getLocale().getLanguage().length() == 0
          || propFile.getLocale().equals(Locale.getDefault())) {
        return propFile;
      }
    }

    // fallback to any file
    if (!propFiles.isEmpty()) {
      return propFiles.get(0);
    }

    return null;
  }
 private void insertPropertyLast(String key, String value, PropertiesFile propertiesFile) {
   final List<IProperty> properties = propertiesFile.getProperties();
   final IProperty lastProperty =
       properties.isEmpty() ? null : properties.get(properties.size() - 1);
   myCodeStyleManager.reformat(
       propertiesFile.addPropertyAfter(key, value, lastProperty).getPsiElement());
 }
  public static void createProperty(
      @NotNull final Project project,
      @NotNull final PsiElement psiElement,
      @NotNull final Collection<PropertiesFile> selectedPropertiesFiles,
      @NotNull final String key,
      @NotNull final String value) {
    for (PropertiesFile selectedFile : selectedPropertiesFiles) {
      if (!FileModificationService.getInstance()
          .prepareFileForWrite(selectedFile.getContainingFile())) return;
    }
    UndoUtil.markPsiFileForUndo(psiElement.getContainingFile());

    ApplicationManager.getApplication()
        .runWriteAction(
            new Runnable() {
              public void run() {
                CommandProcessor.getInstance()
                    .executeCommand(
                        project,
                        new Runnable() {
                          public void run() {
                            try {
                              I18nUtil.createProperty(project, selectedPropertiesFiles, key, value);
                            } catch (IncorrectOperationException e) {
                              LOG.error(e);
                            }
                          }
                        },
                        CodeInsightBundle.message("quickfix.i18n.command.name"),
                        project);
              }
            });
  }
 @Override
 public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) {
   final boolean force = myFilesToSort.length == 1;
   for (PropertiesFile file : myFilesToSort) {
     if (!force && file.isAlphaSorted()) {
       continue;
     }
     sortPropertiesFile(file);
   }
 }
 public void insertAfter(@NotNull String key, @NotNull String value, @NotNull String anchor) {
   if (myAlphaSorted || !myOrdered) {
     throw new IllegalStateException(
         "Can't insert new properties by anchor while resource bundle is alpha-sorted");
   }
   final PropertiesFile file = myResourceBundle.getDefaultPropertiesFile();
   final IProperty anchorProperty = file.findPropertyByKey(anchor);
   file.addPropertyAfter(key, value, anchorProperty);
   final int anchorIndex = myKeysOrder.indexOf(anchor);
   myKeysOrder.add(anchorIndex + 1, key);
 }
示例#7
0
  public static void doI18nSelectedString(
      final @NotNull Project project,
      final @NotNull Editor editor,
      final @NotNull PsiFile psiFile,
      final @NotNull I18nQuickFixHandler handler) {
    try {
      handler.checkApplicability(psiFile, editor);
    } catch (IncorrectOperationException ex) {
      CommonRefactoringUtil.showErrorHint(
          project, editor, ex.getMessage(), CodeInsightBundle.message("i18nize.error.title"), null);
      return;
    }

    final JavaI18nizeQuickFixDialog dialog = handler.createDialog(project, editor, psiFile);
    if (dialog == null) return;
    dialog.show();
    if (!dialog.isOK()) return;

    if (!CodeInsightUtilBase.prepareFileForWrite(psiFile)) return;
    final Collection<PropertiesFile> propertiesFiles = dialog.getAllPropertiesFiles();
    for (PropertiesFile file : propertiesFiles) {
      if (!CodeInsightUtilBase.prepareFileForWrite(file.getContainingFile())) return;
    }

    ApplicationManager.getApplication()
        .runWriteAction(
            new Runnable() {
              public void run() {
                CommandProcessor.getInstance()
                    .executeCommand(
                        project,
                        new Runnable() {
                          public void run() {
                            try {
                              handler.performI18nization(
                                  psiFile,
                                  editor,
                                  dialog.getLiteralExpression(),
                                  propertiesFiles,
                                  dialog.getKey(),
                                  dialog.getValue(),
                                  dialog.getI18nizedText(),
                                  dialog.getParameters(),
                                  dialog.getPropertyCreationHandler());
                            } catch (IncorrectOperationException e) {
                              LOG.error(e);
                            }
                          }
                        },
                        CodeInsightBundle.message("quickfix.i18n.command.name"),
                        project);
              }
            });
  }
 @Nullable
 private BaseNameError checkBaseName(final String baseNameCandidate) {
   for (PropertiesFile propertiesFile : myPropertiesFiles) {
     final String name = propertiesFile.getVirtualFile().getName();
     if (!name.startsWith(baseNameCandidate)
         || !PropertiesUtil.BASE_NAME_BORDER_CHAR.contains(
             name.charAt(baseNameCandidate.length()))) {
       return new BaseNameError(name);
     }
   }
   return null;
 }
 private static boolean isResourceBundleAlphaSortedExceptOneFile(
     final @NotNull ResourceBundle resourceBundle, final @NotNull PropertiesFile exceptedFile) {
   for (PropertiesFile file : resourceBundle.getPropertiesFiles()) {
     if (!(file instanceof PropertiesFileImpl)) {
       return true;
     }
     if (!file.equals(exceptedFile) && !file.isAlphaSorted()) {
       return false;
     }
   }
   return true;
 }
 public void insertNewProperty(String key, String value) {
   if (ApplicationManager.getApplication().isUnitTestMode() && myKeysOrder != null) {
     LOG.assertTrue(!myKeysOrder.contains(key));
   }
   final PropertiesFile propertiesFile = myResourceBundle.getDefaultPropertiesFile();
   if (myAlphaSorted) {
     myCodeStyleManager.reformat(propertiesFile.addProperty(key, value).getPsiElement());
   } else {
     insertPropertyLast(key, value, propertiesFile);
     if (myOrdered) {
       myKeysOrder.add(key);
     }
   }
 }
 ResourceBundleKeyRenameValidator(
     Project project,
     ResourceBundleEditor editor,
     ResourceBundle bundle,
     String oldPropertyName) {
   myEditor = editor;
   myOldPropertyName = oldPropertyName;
   for (PropertiesFile file : bundle.getPropertiesFiles(project)) {
     for (IProperty property : file.getProperties()) {
       myExistingProperties.add(property.getKey());
     }
   }
   myExistingProperties.remove(oldPropertyName);
 }
 @Override
 public void update(final AnActionEvent e) {
   final List<PropertiesFile> propertiesFiles = getPropertiesFiles(e);
   boolean isAvailable = propertiesFiles != null && propertiesFiles.size() > 1;
   if (isAvailable) {
     for (PropertiesFile propertiesFile : propertiesFiles) {
       if (propertiesFile.getResourceBundle().getPropertiesFiles().size() != 1) {
         isAvailable = false;
         break;
       }
     }
   }
   e.getPresentation().setVisible(isAvailable);
 }
 @Nullable
 static PsiDirectory getResourceBundlePlacementDirectory(ResourceBundle resourceBundle) {
   PsiDirectory containingDirectory = null;
   for (PropertiesFile propertiesFile : resourceBundle.getPropertiesFiles()) {
     if (containingDirectory == null) {
       containingDirectory = propertiesFile.getContainingFile().getContainingDirectory();
     } else if (!containingDirectory.isEquivalentTo(
         propertiesFile.getContainingFile().getContainingDirectory())) {
       return null;
     }
   }
   LOG.assertTrue(containingDirectory != null);
   return containingDirectory;
 }
 public static boolean isPropertyRef(
     final PsiLiteralExpression expression, final String key, final String resourceBundleName) {
   if (resourceBundleName == null) {
     return !PropertiesImplUtil.findPropertiesByKey(expression.getProject(), key).isEmpty();
   } else {
     final List<PropertiesFile> propertiesFiles =
         propertiesFilesByBundleName(resourceBundleName, expression);
     boolean containedInPropertiesFile = false;
     for (PropertiesFile propertiesFile : propertiesFiles) {
       containedInPropertiesFile |= propertiesFile.findPropertyByKey(key) != null;
     }
     return containedInPropertiesFile;
   }
 }
  public void testPropertiesFileNotAssociatedWhileLanguageCodeNotRecognized() {
    final PsiFile file = myFixture.addFileToProject("some_property_file.properties", "");
    final PsiFile file2 = myFixture.addFileToProject("some_property_fil.properties", "");
    final PropertiesFile propertiesFile = PropertiesImplUtil.getPropertiesFile(file);
    assertNotNull(propertiesFile);
    final ResourceBundle resourceBundle = propertiesFile.getResourceBundle();
    assertSize(1, resourceBundle.getPropertiesFiles());

    final PropertiesFile propertiesFile2 = PropertiesImplUtil.getPropertiesFile(file2);
    assertNotNull(propertiesFile2);
    final ResourceBundle resourceBundle2 = propertiesFile.getResourceBundle();
    assertSize(1, resourceBundle2.getPropertiesFiles());

    assertEquals(PropertiesUtil.DEFAULT_LOCALE, propertiesFile.getLocale());
  }
 @Override
 public boolean accept(@NotNull final Project project, @NotNull final VirtualFile file) {
   if (file instanceof ResourceBundleAsVirtualFile) return true;
   if (!file.isValid()) return false;
   PsiFile psiFile =
       ApplicationManager.getApplication()
           .runReadAction(
               new Computable<PsiFile>() {
                 @Override
                 public PsiFile compute() {
                   return PsiManager.getInstance(project).findFile(file);
                 }
               });
   PropertiesFile propertiesFile = PropertiesImplUtil.getPropertiesFile(psiFile);
   return propertiesFile != null
       && propertiesFile.getResourceBundle().getPropertiesFiles().size() > 1;
 }
  public void testResourceBundleManagerUpdatesProperlyWhileDirRemoval() {
    myFixture.addFileToProject("qwe/asd/p.properties", "");
    final PsiFile file = myFixture.addFileToProject("qwe/asd/p_en.properties", "");
    final PropertiesFile propertiesFile = PropertiesImplUtil.getPropertiesFile(file);
    assertNotNull(propertiesFile);
    final ResourceBundleManager resourceBundleManager =
        ResourceBundleManager.getInstance(getProject());
    resourceBundleManager.dissociateResourceBundle(propertiesFile.getResourceBundle());

    final PropertiesFile propFile1 =
        PropertiesImplUtil.getPropertiesFile(
            myFixture.addFileToProject("qwe1/asd1/p.properties", ""));
    final PropertiesFile propFile2 =
        PropertiesImplUtil.getPropertiesFile(
            myFixture.addFileToProject("qwe1/asd1/p_abc.properties", ""));
    assertNotNull(propFile1);
    assertNotNull(propFile2);
    resourceBundleManager.combineToResourceBundle(
        ContainerUtil.newArrayList(propFile1, propFile2), "p");

    final PsiFile someFile = myFixture.addFileToProject("to_remove/asd.txt", "");
    final PsiDirectory toRemove = someFile.getParent();
    assertNotNull(toRemove);
    ApplicationManager.getApplication().runWriteAction(toRemove::delete);

    final ResourceBundleManagerState state = resourceBundleManager.getState();
    assertNotNull(state);
    assertSize(1, state.getCustomResourceBundles());
    assertSize(2, state.getDissociatedFiles());

    final PsiDirectory directory = propertiesFile.getParent().getParent();
    assertNotNull(directory);
    ApplicationManager.getApplication().runWriteAction(directory::delete);

    assertSize(1, state.getCustomResourceBundles());
    assertSize(0, state.getDissociatedFiles());

    final PsiDirectory directory1 = propFile1.getParent().getParent();
    assertNotNull(directory1);
    ApplicationManager.getApplication().runWriteAction(directory1::delete);

    assertSize(0, state.getCustomResourceBundles());
    assertSize(0, state.getDissociatedFiles());
  }
  public void testCustomResourceBundleFilesMovedOrDeleted() throws IOException {
    final PropertiesFile file =
        PropertiesImplUtil.getPropertiesFile(
            myFixture.addFileToProject("resources-dev/my-app-dev.properties", ""));
    final PropertiesFile file2 =
        PropertiesImplUtil.getPropertiesFile(
            myFixture.addFileToProject("resources-dev/my-app-test.properties", ""));
    final PropertiesFile file3 =
        PropertiesImplUtil.getPropertiesFile(
            myFixture.addFileToProject("resources-prod/my-app-prod.properties", ""));
    assertNotNull(file);
    assertNotNull(file2);
    assertNotNull(file3);
    assertOneElement(file.getResourceBundle().getPropertiesFiles());
    assertOneElement(file2.getResourceBundle().getPropertiesFiles());
    assertOneElement(file3.getResourceBundle().getPropertiesFiles());
    final ResourceBundleManager resourceBundleBaseNameManager =
        ResourceBundleManager.getInstance(getProject());
    resourceBundleBaseNameManager.combineToResourceBundle(list(file, file2, file3), "my-app");

    assertSize(3, file.getResourceBundle().getPropertiesFiles());

    final PsiDirectory newDir =
        PsiManager.getInstance(getProject())
            .findDirectory(myFixture.getTempDirFixture().findOrCreateDir("new-resources-dir"));
    new MoveFilesOrDirectoriesProcessor(
            getProject(),
            new PsiElement[] {file2.getContainingFile()},
            newDir,
            false,
            false,
            null,
            null)
        .run();
    ApplicationManager.getApplication().runWriteAction(() -> file3.getContainingFile().delete());

    assertSize(2, file.getResourceBundle().getPropertiesFiles());

    final ResourceBundleManagerState state =
        ResourceBundleManager.getInstance(getProject()).getState();
    assertNotNull(state);
    assertSize(1, state.getCustomResourceBundles());
    assertSize(2, state.getCustomResourceBundles().get(0).getFileUrls());
  }
  protected static void collectPropertiesFileVariants(
      @Nullable PropertiesFile file, @Nullable String prefix, List<Object> result) {
    if (file == null) return;

    for (IProperty each : file.getProperties()) {
      String name = each.getKey();
      if (name != null) {
        if (prefix != null) name = prefix + name;
        result.add(createLookupElement(each, name, PlatformIcons.PROPERTY_ICON));
      }
    }
  }
  private void combineToResourceBundleIfNeed(Collection<PsiFile> files) {
    Collection<PropertiesFile> createdFiles =
        ContainerUtil.map(
            files,
            (NotNullFunction<PsiFile, PropertiesFile>)
                dom -> {
                  final PropertiesFile file = PropertiesImplUtil.getPropertiesFile(dom);
                  LOG.assertTrue(file != null, dom.getName());
                  return file;
                });

    ResourceBundle mainBundle = myResourceBundle;
    final Set<ResourceBundle> allBundles = new HashSet<>();
    if (mainBundle != null) {
      allBundles.add(mainBundle);
    }
    boolean needCombining = false;
    for (PropertiesFile file : createdFiles) {
      final ResourceBundle rb = file.getResourceBundle();
      if (mainBundle == null) {
        mainBundle = rb;
      } else if (!mainBundle.equals(rb)) {
        needCombining = true;
      }
      allBundles.add(rb);
    }

    if (needCombining) {
      final List<PropertiesFile> toCombine = new ArrayList<>(createdFiles);
      final String baseName = getBaseName();
      if (myResourceBundle != null) {
        toCombine.addAll(myResourceBundle.getPropertiesFiles());
      }
      ResourceBundleManager manager = ResourceBundleManager.getInstance(mainBundle.getProject());
      for (ResourceBundle bundle : allBundles) {
        manager.dissociateResourceBundle(bundle);
      }
      manager.combineToResourceBundle(toCombine, baseName);
    }
  }
 private String canCreateAllFilesForAllLocales() {
   final String name = getBaseName();
   if (name.isEmpty()) {
     return "Base name is empty";
   }
   final Set<String> files = getFileNamesToCreate();
   if (files.isEmpty()) {
     return "No locales added";
   }
   for (PsiElement element : myDirectory.getChildren()) {
     if (element instanceof PsiFile) {
       if (element instanceof PropertiesFile) {
         PropertiesFile propertiesFile = (PropertiesFile) element;
         final String propertiesFileName = propertiesFile.getName();
         if (files.contains(propertiesFileName)) {
           return "Some of files already exist";
         }
       }
     }
   }
   return null;
 }
 private Pair<IProperty, Integer> findExistedPrevSiblingProperty(String key, PropertiesFile file) {
   if (myKeysOrder.isEmpty()) {
     return null;
   }
   final int prevPosition = myKeysOrder.indexOf(key);
   for (int i = prevPosition; i >= 0; i--) {
     final String prevKey = myKeysOrder.get(i);
     final IProperty property = file.findPropertyByKey(prevKey);
     if (property != null) {
       return Pair.create(property, prevPosition + 1);
     }
   }
   return null;
 }
  private void updateEditorsFromProperties() {
    String propertyName = getSelectedPropertyName();
    ((CardLayout) myValuesPanel.getLayout())
        .show(myValuesPanel, propertyName == null ? NO_PROPERTY_SELECTED : VALUES);
    if (propertyName == null) return;

    for (final PropertiesFile propertiesFile : myResourceBundle.getPropertiesFiles(myProject)) {
      final EditorEx editor = (EditorEx) myEditors.get(propertiesFile);
      if (editor == null) continue;
      final IProperty property = propertiesFile.findPropertyByKey(propertyName);
      final Document document = editor.getDocument();
      CommandProcessor.getInstance()
          .executeCommand(
              null,
              new Runnable() {
                @Override
                public void run() {
                  ApplicationManager.getApplication()
                      .runWriteAction(
                          new Runnable() {
                            @Override
                            public void run() {
                              updateDocumentFromPropertyValue(
                                  getPropertyEditorValue(property), document, propertiesFile);
                            }
                          });
                }
              },
              "",
              this);

      JPanel titledPanel = myTitledPanels.get(propertiesFile);
      ((TitledBorder) titledPanel.getBorder())
          .setTitleColor(property == null ? JBColor.RED : UIUtil.getLabelTextForeground());
      titledPanel.repaint();
    }
  }
 public void deletePropertyIfExist(String key, PropertiesFile file) {
   final IProperty property = file.findPropertyByKey(key);
   if (property != null && myKeysOrder != null) {
     boolean keyExistInOtherPropertiesFiles = false;
     for (PropertiesFile propertiesFile : myResourceBundle.getPropertiesFiles()) {
       if (!propertiesFile.equals(file) && propertiesFile.findPropertyByKey(key) != null) {
         keyExistInOtherPropertiesFiles = true;
         break;
       }
     }
     if (!keyExistInOtherPropertiesFiles) {
       myKeysOrder.remove(key);
     }
   }
   if (property != null) {
     PsiElement anElement = property.getPsiElement();
     if (anElement instanceof PomTargetPsiElement) {
       final PomTarget xmlProperty = ((PomTargetPsiElement) anElement).getTarget();
       LOG.assertTrue(xmlProperty instanceof XmlProperty);
       anElement = ((XmlProperty) xmlProperty).getNavigationElement();
     }
     anElement.delete();
   }
 }
  public void testLanguageCodeNotRecognized() {
    final PsiFile file = myFixture.addFileToProject("p.properties", "");
    final PsiFile file2 = myFixture.addFileToProject("p_asd.properties", "");

    final PropertiesFile propertiesFile = PropertiesImplUtil.getPropertiesFile(file);
    final PropertiesFile propertiesFile2 = PropertiesImplUtil.getPropertiesFile(file2);
    assertNotNull(propertiesFile);
    assertNotNull(propertiesFile2);
    final ResourceBundle bundle = propertiesFile.getResourceBundle();
    final ResourceBundle bundle2 = propertiesFile2.getResourceBundle();
    assertSize(1, bundle.getPropertiesFiles());
    assertSize(1, bundle2.getPropertiesFiles());
    assertEquals("p", bundle.getBaseName());
    assertEquals("p_asd", bundle2.getBaseName());

    final ResourceBundleManager manager = ResourceBundleManager.getInstance(getProject());
    final ArrayList<PropertiesFile> rawBundle =
        ContainerUtil.newArrayList(propertiesFile, propertiesFile2);
    final String suggestedBaseName = PropertiesUtil.getDefaultBaseName(rawBundle);
    assertEquals("p", suggestedBaseName);
    manager.combineToResourceBundle(rawBundle, suggestedBaseName);

    assertEquals("asd", propertiesFile2.getLocale().getLanguage());
  }
  public void testPropertiesFilesDefaultCombiningToResourceBundle() {
    final PsiFile file = myFixture.addFileToProject("prop_core_en.properties", "");
    final PsiFile file2 = myFixture.addFileToProject("prop_core_fi.properties", "");
    final PropertiesFile propertiesFile = PropertiesImplUtil.getPropertiesFile(file);
    final PropertiesFile propertiesFile2 = PropertiesImplUtil.getPropertiesFile(file2);
    assertNotNull(propertiesFile);
    assertNotNull(propertiesFile2);
    final ResourceBundle bundle = propertiesFile.getResourceBundle();
    final ResourceBundle bundle2 = propertiesFile2.getResourceBundle();
    assertTrue(bundle.equals(bundle2));
    assertSize(2, bundle.getPropertiesFiles());
    assertTrue(bundle.getDefaultPropertiesFile().equals(bundle2.getDefaultPropertiesFile()));
    assertEquals("prop_core", bundle.getBaseName());

    assertNotSame(
        propertiesFile.getLocale().getLanguage(), propertiesFile.getLocale().getDisplayLanguage());
    assertNotSame(
        propertiesFile2.getLocale().getLanguage(),
        propertiesFile2.getLocale().getDisplayLanguage());
  }
  public void testCombineToCustomResourceBundleAndDissociateAfter() {
    final PropertiesFile file =
        PropertiesImplUtil.getPropertiesFile(
            myFixture.addFileToProject("resources-dev/my-app-dev.properties", ""));
    final PropertiesFile file2 =
        PropertiesImplUtil.getPropertiesFile(
            myFixture.addFileToProject("resources-prod/my-app-prod.properties", ""));
    assertNotNull(file);
    assertNotNull(file2);
    assertOneElement(file.getResourceBundle().getPropertiesFiles());
    assertOneElement(file2.getResourceBundle().getPropertiesFiles());

    final ResourceBundleManager resourceBundleBaseNameManager =
        ResourceBundleManager.getInstance(getProject());
    final String newBaseName = "my-app";
    resourceBundleBaseNameManager.combineToResourceBundle(list(file, file2), newBaseName);
    final ResourceBundle resourceBundle = file.getResourceBundle();
    assertEquals(2, resourceBundle.getPropertiesFiles().size());
    assertEquals(newBaseName, resourceBundle.getBaseName());

    resourceBundleBaseNameManager.dissociateResourceBundle(resourceBundle);
    assertOneElement(file.getResourceBundle().getPropertiesFiles());
    assertOneElement(file2.getResourceBundle().getPropertiesFiles());
  }
  private static void sortPropertiesFile(final PropertiesFile file) {
    final List<IProperty> properties = new ArrayList<IProperty>(file.getProperties());

    Collections.sort(
        properties,
        new Comparator<IProperty>() {
          @Override
          public int compare(IProperty p1, IProperty p2) {
            return Comparing.compare(p1.getKey(), p2.getKey());
          }
        });
    final char delimiter =
        PropertiesCodeStyleSettings.getInstance(file.getProject()).KEY_VALUE_DELIMITER;
    final StringBuilder rawText = new StringBuilder();
    for (int i = 0; i < properties.size(); i++) {
      IProperty property = properties.get(i);
      final String value = property.getUnescapedValue();
      rawText.append(
          PropertiesElementFactory.getPropertyText(
              property.getKey(), value != null ? value : "", delimiter, null));
      if (i != properties.size() - 1) {
        rawText.append("\n");
      }
    }

    final PropertiesFile fakeFile =
        PropertiesElementFactory.createPropertiesFile(file.getProject(), rawText.toString());

    final PropertiesList propertiesList =
        PsiTreeUtil.findChildOfType(file.getContainingFile(), PropertiesList.class);
    LOG.assertTrue(propertiesList != null);
    final PropertiesList fakePropertiesList =
        PsiTreeUtil.findChildOfType(fakeFile.getContainingFile(), PropertiesList.class);
    LOG.assertTrue(fakePropertiesList != null);
    propertiesList.replace(fakePropertiesList);
  }
示例#29
0
 @Nullable
 public static IProperty findProperty(
     @NotNull Project project, @NotNull VirtualFile file, @NotNull String propName) {
   PropertiesFile propertiesFile = getPropertiesFile(project, file);
   return propertiesFile == null ? null : propertiesFile.findPropertyByKey(propName);
 }
 @Override
 public PsiElement fun(PropertiesFile propertiesFile) {
   return propertiesFile.getContainingFile();
 }