platform/projectModel-impl/src/com/intellij/application/options/PathMacrosImpl.java

   1 /*
   2  * Copyright 2000-2016 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package com.intellij.application.options;
  17
  18 import com.intellij.openapi.application.PathMacros;
  19 import com.intellij.openapi.components.*;
  20 import com.intellij.openapi.diagnostic.Logger;
  21 import com.intellij.openapi.util.text.StringUtil;
  22 import com.intellij.util.containers.ContainerUtil;
  23 import com.intellij.util.containers.hash.LinkedHashMap;
  24 import gnu.trove.THashMap;
  25 import gnu.trove.THashSet;
  26 import org.jdom.Element;
  27 import org.jetbrains.annotations.NonNls;
  28 import org.jetbrains.annotations.NotNull;
  29 import org.jetbrains.annotations.Nullable;
  30 import org.jetbrains.jps.model.serialization.JpsGlobalLoader;
  31 import org.jetbrains.jps.model.serialization.PathMacroUtil;
  32
  33 import java.util.Collection;
  34 import java.util.List;
  35 import java.util.Map;
  36 import java.util.Set;
  37 import java.util.concurrent.locks.ReentrantReadWriteLock;
  38
  39 @State(
  40   name = "PathMacrosImpl",
  41   storages = @Storage(value = "path.macros.xml", roamingType = RoamingType.PER_OS)
  42 )
  43 public class PathMacrosImpl extends PathMacros implements PersistentStateComponent<Element> {
  44   private static final Logger LOG = Logger.getInstance(PathMacrosImpl.class);
  45
  46   private final Map<String, String> myLegacyMacros = new THashMap<>();
  47   private final Map<String, String> myMacros = new LinkedHashMap<>();
  48   private int myModificationStamp = 0;
  49   private final ReentrantReadWriteLock myLock = new ReentrantReadWriteLock();
  50   private final List<String> myIgnoredMacros = ContainerUtil.createLockFreeCopyOnWriteList();
  51
  52   private static final String MACRO_ELEMENT = JpsGlobalLoader.PathVariablesSerializer.MACRO_TAG;
  53   private static final String NAME_ATTR = JpsGlobalLoader.PathVariablesSerializer.NAME_ATTRIBUTE;
  54   private static final String VALUE_ATTR = JpsGlobalLoader.PathVariablesSerializer.VALUE_ATTRIBUTE;
  55
  56   @NonNls
  57   public static final String IGNORED_MACRO_ELEMENT = "ignoredMacro";
  58
  59   // predefined macros
  60   @NonNls
  61   public static final String APPLICATION_HOME_MACRO_NAME = PathMacroUtil.APPLICATION_HOME_DIR;
  62   @NonNls
  63   public static final String PROJECT_DIR_MACRO_NAME = PathMacroUtil.PROJECT_DIR_MACRO_NAME;
  64   @NonNls
  65   public static final String MODULE_DIR_MACRO_NAME = PathMacroUtil.MODULE_DIR_MACRO_NAME;
  66   @NonNls
  67   public static final String USER_HOME_MACRO_NAME = PathMacroUtil.USER_HOME_NAME;
  68
  69   private static final Set<String> SYSTEM_MACROS = new THashSet<>();
  70   @NonNls public static final String EXT_FILE_NAME = "path.macros";
  71
  72   static {
  73     SYSTEM_MACROS.add(APPLICATION_HOME_MACRO_NAME);
  74     SYSTEM_MACROS.add(PathMacroUtil.APPLICATION_PLUGINS_DIR);
  75     SYSTEM_MACROS.add(PROJECT_DIR_MACRO_NAME);
  76     SYSTEM_MACROS.add(MODULE_DIR_MACRO_NAME);
  77     SYSTEM_MACROS.add(USER_HOME_MACRO_NAME);
  78   }
  79
  80   @SuppressWarnings("SpellCheckingInspection")
  81   private static final Set<String> ourToolsMacros = ContainerUtil.immutableSet(
  82     "ClasspathEntry",
  83     "Classpath",
  84     "ColumnNumber",
  85     "ContentRoot",
  86     "FileClass",
  87     "FileDir",
  88     "FileParentDir",
  89     "FileDirName",
  90     "FileDirPathFromParent",
  91     "FileDirRelativeToProjectRoot",
  92     "/FileDirRelativeToProjectRoot",
  93     "FileDirRelativeToSourcepath",
  94     "/FileDirRelativeToSourcepath",
  95     "FileExt",
  96     "FileFQPackage",
  97     "FileName",
  98     "FileNameWithoutExtension",
  99     "FileNameWithoutAllExtensions",
 100     "FilePackage",
 101     "FilePath",
 102     "UnixSeparators",
 103     "FilePathRelativeToProjectRoot",
 104     "/FilePathRelativeToProjectRoot",
 105     "FilePathRelativeToSourcepath",
 106     "/FilePathRelativeToSourcepath",
 107     "FilePrompt",
 108     "FileRelativeDir",
 109     "/FileRelativeDir",
 110     "FileRelativePath",
 111     "/FileRelativePath",
 112     "FileEncoding",
 113     "JavaDocPath",
 114     "JDKPath",
 115     "LineNumber",
 116     "ModuleFileDir",
 117     "ModuleFilePath",
 118     "ModuleName",
 119     "ModuleSourcePath",
 120     "ModuleSdkPath",
 121     "OutputPath",
 122     "PhpExecutable",
 123     "ProjectFileDir",
 124     "ProjectFilePath",
 125     "ProjectName",
 126     "Projectpath",
 127     "Prompt",
 128     "SourcepathEntry",
 129     "Sourcepath",
 130     "SHOW_CHANGES",
 131     "ClipboardContent",
 132     "SelectedText",
 133     "SelectionStartLine",
 134     "SelectionEndLine",
 135     "SelectionStartColumn",
 136     "SelectionEndColumn",
 137     "PyInterpreterDirectory",
 138     "ExecutableByFileExt"
 139   );
 140
 141   public PathMacrosImpl() {
 142   }
 143
 144   public static PathMacrosImpl getInstanceEx() {
 145     return (PathMacrosImpl)getInstance();
 146   }
 147
 148   @Override
 149   public Set<String> getUserMacroNames() {
 150     myLock.readLock().lock();
 151     try {
 152       return new THashSet<>(myMacros.keySet()); // keyset should not escape the lock
 153     }
 154     finally {
 155       myLock.readLock().unlock();
 156     }
 157   }
 158
 159   public static Set<String> getToolMacroNames() {
 160     return ourToolsMacros;
 161   }
 162
 163   @Override
 164   public Set<String> getSystemMacroNames() {
 165     return SYSTEM_MACROS;
 166   }
 167
 168   @Override
 169   public Collection<String> getIgnoredMacroNames() {
 170     return myIgnoredMacros;
 171   }
 172
 173   @Override
 174   public void setIgnoredMacroNames(@NotNull final Collection<String> names) {
 175     myIgnoredMacros.clear();
 176     myIgnoredMacros.addAll(names);
 177   }
 178
 179   @Override
 180   public void addIgnoredMacro(@NotNull String name) {
 181     if (!myIgnoredMacros.contains(name)) myIgnoredMacros.add(name);
 182   }
 183
 184   public int getModificationStamp() {
 185     myLock.readLock().lock();
 186     try {
 187       return myModificationStamp;
 188     }
 189     finally {
 190       myLock.readLock().unlock();
 191     }
 192   }
 193
 194   @Override
 195   public boolean isIgnoredMacroName(@NotNull String macro) {
 196     return myIgnoredMacros.contains(macro);
 197   }
 198
 199   @Override
 200   public Set<String> getAllMacroNames() {
 201     return ContainerUtil.union(getUserMacroNames(), getSystemMacroNames());
 202   }
 203
 204   @Override
 205   public String getValue(String name) {
 206     try {
 207       myLock.readLock().lock();
 208       return myMacros.get(name);
 209     }
 210     finally {
 211       myLock.readLock().unlock();
 212     }
 213   }
 214
 215   @Override
 216   public void removeAllMacros() {
 217     try {
 218       myLock.writeLock().lock();
 219       myMacros.clear();
 220     }
 221     finally {
 222       myModificationStamp++;
 223       myLock.writeLock().unlock();
 224     }
 225   }
 226
 227   @Override
 228   public Collection<String> getLegacyMacroNames() {
 229     try {
 230       myLock.readLock().lock();
 231       // keyset should not escape the lock
 232       return new THashSet<>(myLegacyMacros.keySet());
 233     }
 234     finally {
 235       myLock.readLock().unlock();
 236     }
 237   }
 238
 239   @Override
 240   public void setMacro(@NotNull String name, @NotNull String value) {
 241     if (StringUtil.isEmptyOrSpaces(value)) {
 242       return;
 243     }
 244
 245     try {
 246       myLock.writeLock().lock();
 247       myMacros.put(name, value);
 248     }
 249     finally {
 250       myModificationStamp++;
 251       myLock.writeLock().unlock();
 252     }
 253   }
 254
 255   @Override
 256   public void addLegacyMacro(@NotNull String name, @NotNull String value) {
 257     try {
 258       myLock.writeLock().lock();
 259       myLegacyMacros.put(name, value);
 260       myMacros.remove(name);
 261     }
 262     finally {
 263       myModificationStamp++;
 264       myLock.writeLock().unlock();
 265     }
 266   }
 267
 268   @Override
 269   public void removeMacro(String name) {
 270     try {
 271       myLock.writeLock().lock();
 272       final String value = myMacros.remove(name);
 273       LOG.assertTrue(value != null);
 274     }
 275     finally {
 276       myModificationStamp++;
 277       myLock.writeLock().unlock();
 278     }
 279   }
 280
 281   @Nullable
 282   @Override
 283   public Element getState() {
 284     try {
 285       Element element = new Element("state");
 286       myLock.writeLock().lock();
 287
 288       for (Map.Entry<String, String> entry : myMacros.entrySet()) {
 289         String value = entry.getValue();
 290         if (!StringUtil.isEmptyOrSpaces(value)) {
 291           final Element macro = new Element(MACRO_ELEMENT);
 292           macro.setAttribute(NAME_ATTR, entry.getKey());
 293           macro.setAttribute(VALUE_ATTR, value);
 294           element.addContent(macro);
 295         }
 296       }
 297
 298       for (final String macro : myIgnoredMacros) {
 299         final Element macroElement = new Element(IGNORED_MACRO_ELEMENT);
 300         macroElement.setAttribute(NAME_ATTR, macro);
 301         element.addContent(macroElement);
 302       }
 303       return element;
 304     }
 305     finally {
 306       myLock.writeLock().unlock();
 307     }
 308   }
 309
 310   @Override
 311   public void loadState(Element element) {
 312     try {
 313       myLock.writeLock().lock();
 314
 315       for (Element macro : element.getChildren(MACRO_ELEMENT)) {
 316         final String name = macro.getAttributeValue(NAME_ATTR);
 317         String value = macro.getAttributeValue(VALUE_ATTR);
 318         if (name == null || value == null) {
 319           continue;
 320         }
 321
 322         if (SYSTEM_MACROS.contains(name)) {
 323           continue;
 324         }
 325
 326         if (value.length() > 1 && value.charAt(value.length() - 1) == '/') {
 327           value = value.substring(0, value.length() - 1);
 328         }
 329
 330         myMacros.put(name, value);
 331       }
 332
 333       for (Element macroElement : element.getChildren(IGNORED_MACRO_ELEMENT)) {
 334         String ignoredName = macroElement.getAttributeValue(NAME_ATTR);
 335         if (!StringUtil.isEmpty(ignoredName) && !myIgnoredMacros.contains(ignoredName)) {
 336           myIgnoredMacros.add(ignoredName);
 337         }
 338       }
 339     }
 340     finally {
 341       myModificationStamp++;
 342       myLock.writeLock().unlock();
 343     }
 344   }
 345
 346   public void addMacroReplacements(ReplacePathToMacroMap result) {
 347     for (String name : getUserMacroNames()) {
 348       String value = getValue(name);
 349       if (!StringUtil.isEmptyOrSpaces(value)) {
 350         result.addMacroReplacement(value, name);
 351       }
 352     }
 353   }
 354
 355   public void addMacroExpands(ExpandMacroToPathMap result) {
 356     for (String name : getUserMacroNames()) {
 357       String value = getValue(name);
 358       if (!StringUtil.isEmptyOrSpaces(value)) {
 359         result.addMacroExpand(name, value);
 360       }
 361     }
 362
 363     myLock.readLock().lock();
 364     try {
 365       for (Map.Entry<String, String> entry : myLegacyMacros.entrySet()) {
 366         result.addMacroExpand(entry.getKey(), entry.getValue());
 367       }
 368     }
 369     finally {
 370       myLock.readLock().unlock();
 371     }
 372   }
 373 }