diff --git a/java/java-impl/src/com/intellij/psi/codeStyle/arrangement/JavaRearranger.java b/java/java-impl/src/com/intellij/psi/codeStyle/arrangement/JavaRearranger.java index 2529fcc77a3e..89c7d477087e 100644 --- a/java/java-impl/src/com/intellij/psi/codeStyle/arrangement/JavaRearranger.java +++ b/java/java-impl/src/com/intellij/psi/codeStyle/arrangement/JavaRearranger.java @@ -58,18 +58,25 @@ import static com.intellij.psi.codeStyle.arrangement.std.StdArrangementTokens.Ge public class JavaRearranger implements Rearranger, ArrangementStandardSettingsAware, ArrangementColorsAware { // Type - @NotNull private static final Set SUPPORTED_TYPES = ContainerUtilRt.newLinkedHashSet( - FIELD, CONSTRUCTOR, METHOD, CLASS, INTERFACE, ENUM - ); + @NotNull private static final Set SUPPORTED_TYPES = + ContainerUtilRt.newLinkedHashSet( + FIELD, CONSTRUCTOR, METHOD, CLASS, INTERFACE, ENUM + ); // Modifier - @NotNull private static final Set SUPPORTED_MODIFIERS = ContainerUtilRt.newLinkedHashSet( - PUBLIC, PROTECTED, PACKAGE_PRIVATE, PRIVATE, STATIC, FINAL, ABSTRACT, SYNCHRONIZED, TRANSIENT, VOLATILE - ); - @NotNull private static final List SUPPORTED_ORDERS = ContainerUtilRt.newArrayList(KEEP, BY_NAME); - @NotNull private static final ArrangementSettingsToken NO_TYPE = new ArrangementSettingsToken("NO_TYPE", "NO_TYPE"); + @NotNull private static final Set SUPPORTED_MODIFIERS = + ContainerUtilRt.newLinkedHashSet( + PUBLIC, PROTECTED, PACKAGE_PRIVATE, PRIVATE, STATIC, FINAL, ABSTRACT, SYNCHRONIZED, TRANSIENT, VOLATILE + ); + @NotNull private static final List SUPPORTED_ORDERS = + ContainerUtilRt.newArrayList(KEEP, BY_NAME); + @NotNull private static final ArrangementSettingsToken NO_TYPE = + new ArrangementSettingsToken("NO_TYPE", "NO_TYPE"); @NotNull - private static final Map> MODIFIERS_BY_TYPE = ContainerUtilRt.newHashMap(); - @NotNull private static final Collection> MUTEXES = ContainerUtilRt.newArrayList(); + private static final Map> MODIFIERS_BY_TYPE = + ContainerUtilRt.newHashMap(); + @NotNull private static final Collection> MUTEXES = + ContainerUtilRt.newArrayList(); + static { Set visibilityModifiers = ContainerUtilRt.newHashSet(PUBLIC, PROTECTED, PACKAGE_PRIVATE, PRIVATE); MUTEXES.add(visibilityModifiers); @@ -85,7 +92,9 @@ public class JavaRearranger implements Rearranger, MODIFIERS_BY_TYPE.put(CONSTRUCTOR, concat(commonModifiers, SYNCHRONIZED)); MODIFIERS_BY_TYPE.put(FIELD, concat(commonModifiers, TRANSIENT, VOLATILE)); } + private static final Map> GROUPING_RULES = ContainerUtilRt.newLinkedHashMap(); + static { GROUPING_RULES.put(GETTERS_AND_SETTERS, Collections.emptyList()); GROUPING_RULES.put(OVERRIDDEN_METHODS, ContainerUtilRt.newArrayList(BY_NAME, KEEP)); @@ -302,14 +311,14 @@ public class JavaRearranger implements Rearranger, return ContainerUtilRt.newArrayList( new CompositeArrangementSettingsToken(TYPE, SUPPORTED_TYPES), new CompositeArrangementSettingsToken(MODIFIER, SUPPORTED_MODIFIERS), - new CompositeArrangementSettingsToken(NAME), + new CompositeArrangementSettingsToken(StdArrangementTokens.Regexp.NAME), new CompositeArrangementSettingsToken(ORDER, KEEP, BY_NAME) ); } @Override public boolean isEnabled(@NotNull ArrangementSettingsToken token, @Nullable ArrangementMatchCondition current) { - if (SUPPORTED_TYPES.contains(token) || SUPPORTED_ORDERS.contains(token) || NAME.equals(token)) { + if (SUPPORTED_TYPES.contains(token) || SUPPORTED_ORDERS.contains(token) || StdArrangementTokens.Regexp.NAME.equals(token)) { return true; } ArrangementSettingsToken type = null; diff --git a/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/ArrangementUtil.java b/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/ArrangementUtil.java index 93c0efd84e73..a210602aa2a2 100644 --- a/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/ArrangementUtil.java +++ b/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/ArrangementUtil.java @@ -245,15 +245,17 @@ public class ArrangementUtil { else if (StdArrangementTokens.Modifier.is(condition.getType())) { return new ByModifierArrangementEntryMatcher(condition.getType()); } - else if (StdArrangementTokens.General.NAME.equals(condition.getType())) { + else if (StdArrangementTokens.Regexp.NAME.equals(condition.getType())) { return new ByNameArrangementEntryMatcher(condition.getValue().toString()); } + else if (StdArrangementTokens.Regexp.XML_NAMESPACE.equals(condition.getType())) { + return new ByNamespaceArrangementEntryMatcher(condition.getValue().toString()); + } else { return null; } } - // TODO den add doc @NotNull public static ArrangementUiComponent buildUiComponent(@NotNull StdArrangementTokenUiRole role, @NotNull List tokens, diff --git a/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/NamespaceAwareArrangementEntry.java b/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/NamespaceAwareArrangementEntry.java new file mode 100644 index 000000000000..e26fd2c50b2d --- /dev/null +++ b/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/NamespaceAwareArrangementEntry.java @@ -0,0 +1,28 @@ +/* + * Copyright 2000-2013 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.intellij.psi.codeStyle.arrangement; + +import org.jetbrains.annotations.Nullable; + +/** + * @author Denis Zhdanov + * @since 3/14/13 1:00 PM + */ +public interface NamespaceAwareArrangementEntry { + + @Nullable + String getNamespace(); +} diff --git a/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/match/AbstractRegexpArrangementMatcher.java b/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/match/AbstractRegexpArrangementMatcher.java new file mode 100644 index 000000000000..09b33c6e3214 --- /dev/null +++ b/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/match/AbstractRegexpArrangementMatcher.java @@ -0,0 +1,81 @@ +/* + * Copyright 2000-2013 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.intellij.psi.codeStyle.arrangement.match; + +import com.intellij.psi.codeStyle.arrangement.ArrangementEntry; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.regex.Pattern; + +/** + * @author Denis Zhdanov + * @since 3/14/13 1:02 PM + */ +public abstract class AbstractRegexpArrangementMatcher implements ArrangementEntryMatcher { + + @NotNull private final String myPattern; + + @Nullable private final Pattern myCompiledPattern; + + public AbstractRegexpArrangementMatcher(@NotNull String pattern) { + myPattern = pattern; + Pattern p = null; + try { + p = Pattern.compile(pattern); + } + catch (Exception e) { + // ignore + } + myCompiledPattern = p; + } + + @Override + public boolean isMatched(@NotNull ArrangementEntry entry) { + if (myCompiledPattern == null) { + return false; + } + String text = getTextToMatch(entry); + return text != null && myCompiledPattern.matcher(text).matches(); + } + + @Nullable + protected abstract String getTextToMatch(@NotNull ArrangementEntry entry); + + @NotNull + public String getPattern() { + return myPattern; + } + + @Override + public int hashCode() { + return myPattern.hashCode(); + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + AbstractRegexpArrangementMatcher that = (AbstractRegexpArrangementMatcher)o; + return myPattern.equals(that.myPattern); + } + + @Override + public String toString() { + return String.format("regexp '%s'", myPattern); + } +} diff --git a/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/match/ByNameArrangementEntryMatcher.java b/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/match/ByNameArrangementEntryMatcher.java index 4710ed67dda4..aed91f37d22b 100644 --- a/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/match/ByNameArrangementEntryMatcher.java +++ b/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/match/ByNameArrangementEntryMatcher.java @@ -20,66 +20,24 @@ import com.intellij.psi.codeStyle.arrangement.NameAwareArrangementEntry; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import java.util.regex.Pattern; - /** * @author Denis Zhdanov * @since 7/19/12 6:36 PM */ -public class ByNameArrangementEntryMatcher implements ArrangementEntryMatcher { - - @NotNull private final String myPattern; - - @Nullable private final Pattern myCompiledPattern; +public class ByNameArrangementEntryMatcher extends AbstractRegexpArrangementMatcher { public ByNameArrangementEntryMatcher(@NotNull String pattern) { - myPattern = pattern; - Pattern p = null; - try { - p = Pattern.compile(pattern); - } - catch (Exception e) { - // ignore - } - myCompiledPattern = p; + super(pattern); } + @Nullable @Override - public boolean isMatched(@NotNull ArrangementEntry entry) { - if (myCompiledPattern == null) { - return false; - } + protected String getTextToMatch(@NotNull ArrangementEntry entry) { if (entry instanceof NameAwareArrangementEntry) { - String name = ((NameAwareArrangementEntry)entry).getName(); - if (name == null) { - return false; - } - return myCompiledPattern.matcher(name).matches(); + return ((NameAwareArrangementEntry)entry).getName(); + } + else { + return null; } - return false; - } - - @NotNull - public String getPattern() { - return myPattern; - } - - @Override - public int hashCode() { - return myPattern.hashCode(); - } - - @Override - public boolean equals(Object o) { - if (this == o) return true; - if (o == null || getClass() != o.getClass()) return false; - - ByNameArrangementEntryMatcher that = (ByNameArrangementEntryMatcher)o; - return myPattern.equals(that.myPattern); - } - - @Override - public String toString() { - return String.format("with name like '%s'", myPattern); } } diff --git a/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/match/ByNamespaceArrangementEntryMatcher.java b/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/match/ByNamespaceArrangementEntryMatcher.java new file mode 100644 index 000000000000..ce44528333aa --- /dev/null +++ b/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/match/ByNamespaceArrangementEntryMatcher.java @@ -0,0 +1,43 @@ +/* + * Copyright 2000-2013 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.intellij.psi.codeStyle.arrangement.match; + +import com.intellij.psi.codeStyle.arrangement.ArrangementEntry; +import com.intellij.psi.codeStyle.arrangement.NamespaceAwareArrangementEntry; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +/** + * @author Denis Zhdanov + * @since 3/14/13 1:01 PM + */ +public class ByNamespaceArrangementEntryMatcher extends AbstractRegexpArrangementMatcher { + + public ByNamespaceArrangementEntryMatcher(@NotNull String pattern) { + super(pattern); + } + + @Nullable + @Override + protected String getTextToMatch(@NotNull ArrangementEntry entry) { + if (entry instanceof NamespaceAwareArrangementEntry) { + return ((NamespaceAwareArrangementEntry)entry).getNamespace(); + } + else { + return null; + } + } +} diff --git a/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/match/DefaultArrangementEntryMatcherSerializer.java b/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/match/DefaultArrangementEntryMatcherSerializer.java index d828a908cc83..bc1a813a8386 100644 --- a/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/match/DefaultArrangementEntryMatcherSerializer.java +++ b/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/match/DefaultArrangementEntryMatcherSerializer.java @@ -162,8 +162,9 @@ public class DefaultArrangementEntryMatcherSerializer { @Override public void visit(@NotNull ArrangementAtomMatchCondition condition) { - final Element element = new Element(condition.getType().getId()); - if (StdArrangementTokens.General.NAME.equals(condition.getType())) { + ArrangementSettingsToken type = condition.getType(); + final Element element = new Element(type.getId()); + if (StdArrangementTokens.Regexp.is(type)) { element.setText(StringUtil.escapeStringCharacters(condition.getValue().toString())); } register(element); diff --git a/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/match/StdArrangementEntryMatcher.java b/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/match/StdArrangementEntryMatcher.java index 66289580538a..fe0d9ff95c44 100644 --- a/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/match/StdArrangementEntryMatcher.java +++ b/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/match/StdArrangementEntryMatcher.java @@ -91,15 +91,19 @@ public class StdArrangementEntryMatcher implements ArrangementEntryMatcher { @NotNull private final Set myModifiers = ContainerUtilRt.newHashSet(); @Nullable private String myNamePattern; + @Nullable private String myNamespacePattern; private boolean nestedComposite; @Override public void visit(@NotNull ArrangementAtomMatchCondition condition) { - if (StdArrangementTokens.General.NAME.equals(condition.getType())) { + if (StdArrangementTokens.Regexp.NAME.equals(condition.getType())) { myNamePattern = condition.getValue().toString(); return; } + else if (StdArrangementTokens.Regexp.XML_NAMESPACE.equals(condition.getType())) { + myNamespacePattern = condition.getValue().toString(); + } Object v = condition.getValue(); if (v instanceof ArrangementSettingsToken) { ArrangementSettingsToken token = (ArrangementSettingsToken)v; @@ -131,6 +135,8 @@ public class StdArrangementEntryMatcher implements ArrangementEntryMatcher { ByTypeArrangementEntryMatcher byType = myTypes.isEmpty() ? null : new ByTypeArrangementEntryMatcher(myTypes); ByModifierArrangementEntryMatcher byModifiers = myModifiers.isEmpty() ? null : new ByModifierArrangementEntryMatcher(myModifiers); ByNameArrangementEntryMatcher byName = myNamePattern == null ? null : new ByNameArrangementEntryMatcher(myNamePattern); + ByNamespaceArrangementEntryMatcher byNamespace = myNamespacePattern == null + ? null : new ByNamespaceArrangementEntryMatcher(myNamespacePattern); int i = countNonNulls(byType, byModifiers, byName); if (i == 0 && myMatchers.isEmpty()) { return ArrangementEntryMatcher.EMPTY; @@ -142,9 +148,12 @@ public class StdArrangementEntryMatcher implements ArrangementEntryMatcher { else if (byModifiers != null) { return byModifiers; } - else { + else if (byName != null) { return byName; } + else { + return byNamespace; + } } else if (myMatchers.size() == 1) { return myMatchers.get(0); @@ -163,6 +172,9 @@ public class StdArrangementEntryMatcher implements ArrangementEntryMatcher { if (byName != null) { result.addMatcher(byName); } + if (byNamespace != null) { + result.addMatcher(byNamespace); + } return result; } } diff --git a/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/std/StdArrangementTokens.java b/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/std/StdArrangementTokens.java index 3910660b4c13..884391c7ef11 100644 --- a/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/std/StdArrangementTokens.java +++ b/platform/lang-api/src/com/intellij/psi/codeStyle/arrangement/std/StdArrangementTokens.java @@ -29,7 +29,7 @@ import java.util.Set; import static com.intellij.psi.codeStyle.arrangement.std.StdArrangementTokenUiRole.*; /** - * // TODO den add doc + * Holds settings tokens used by built-in IJ arrangers. * * @author Denis Zhdanov * @since 3/6/13 3:16 PM @@ -119,7 +119,6 @@ public class StdArrangementTokens { @NotNull public static final ArrangementSettingsToken TYPE = token("TYPE", "arrangement.settings.text.general.type", LABEL); @NotNull public static final ArrangementSettingsToken MODIFIER = token("MODIFIER", "arrangement.settings.text.general.modifier", LABEL); - @NotNull public static final ArrangementSettingsToken NAME = token("NAME", "arrangement.settings.text.general.name", TEXT_FIELD); @NotNull public static final ArrangementSettingsToken ORDER = token("ORDER", "arrangement.settings.text.general.order", LABEL); private static final NotNullLazyValue> TOKENS = collectFields(General.class); @@ -131,6 +130,23 @@ public class StdArrangementTokens { return TOKENS.getValue().contains(token); } } + + public static class Regexp { + + @NotNull public static final ArrangementSettingsToken NAME = token("NAME", "arrangement.settings.text.general.name", TEXT_FIELD); + + @NotNull public static final ArrangementSettingsToken XML_NAMESPACE = + token("XML_NAMESPACE", "arrangement.settings.text.general.xml.namespace", TEXT_FIELD); + + private static final NotNullLazyValue> TOKENS = collectFields(Regexp.class); + + private Regexp() { + } + + public static boolean is(@NotNull ArrangementSettingsToken token) { + return TOKENS.getValue().contains(token); + } + } public static class EntryType { @@ -214,9 +230,9 @@ public class StdArrangementTokens { public static class Order { - @NotNull public static final ArrangementSettingsToken KEEP = token("KEEP", "arrangement.settings.order.type.keep", - COMBO_BOX); - @NotNull public static final ArrangementSettingsToken BY_NAME = token("BY_NAME", "arrangement.settings.order.type.by.name", + @NotNull public static final ArrangementSettingsToken KEEP = token("KEEP", "arrangement.settings.order.type.keep", + COMBO_BOX); + @NotNull public static final ArrangementSettingsToken BY_NAME = token("BY_NAME", "arrangement.settings.order.type.by.name", COMBO_BOX); @NotNull public static final ArrangementSettingsToken DEPTH_FIRST = token("DEPTH_FIRST", "arrangement.settings.order.type.depth.first", diff --git a/platform/lang-api/testSources/com/intellij/psi/codeStyle/arrangement/match/DefaultArrangementEntryMatcherSerializerTest.java b/platform/lang-api/testSources/com/intellij/psi/codeStyle/arrangement/match/DefaultArrangementEntryMatcherSerializerTest.java index 082d56c4c1e6..5b1c8cdc475d 100644 --- a/platform/lang-api/testSources/com/intellij/psi/codeStyle/arrangement/match/DefaultArrangementEntryMatcherSerializerTest.java +++ b/platform/lang-api/testSources/com/intellij/psi/codeStyle/arrangement/match/DefaultArrangementEntryMatcherSerializerTest.java @@ -31,7 +31,6 @@ import java.util.List; import java.util.Set; import static com.intellij.psi.codeStyle.arrangement.std.StdArrangementTokens.EntryType.*; -import static com.intellij.psi.codeStyle.arrangement.std.StdArrangementTokens.General.*; import static com.intellij.psi.codeStyle.arrangement.std.StdArrangementTokens.Modifier.*; import static org.junit.Assert.*; @@ -109,7 +108,7 @@ public class DefaultArrangementEntryMatcherSerializerTest { @Test public void nameConditionOnly() { - ArrangementAtomMatchCondition condition = new ArrangementAtomMatchCondition(NAME, "get*"); + ArrangementAtomMatchCondition condition = new ArrangementAtomMatchCondition(StdArrangementTokens.Regexp.NAME, "get*"); doTest(condition); } @@ -118,7 +117,7 @@ public class DefaultArrangementEntryMatcherSerializerTest { ArrangementCompositeMatchCondition condition = new ArrangementCompositeMatchCondition(); condition.addOperand(new ArrangementAtomMatchCondition(METHOD)); condition.addOperand(new ArrangementAtomMatchCondition(SYNCHRONIZED)); - condition.addOperand(new ArrangementAtomMatchCondition(NAME, ("get*"))); + condition.addOperand(new ArrangementAtomMatchCondition(StdArrangementTokens.Regexp.NAME, ("get*"))); doTest(condition); } diff --git a/platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/component/ArrangementAtomMatchConditionComponent.java b/platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/component/ArrangementAtomMatchConditionComponent.java index a0c277cab664..f7b6c753ca07 100644 --- a/platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/component/ArrangementAtomMatchConditionComponent.java +++ b/platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/component/ArrangementAtomMatchConditionComponent.java @@ -51,7 +51,7 @@ import java.awt.event.MouseEvent; */ public class ArrangementAtomMatchConditionComponent implements ArrangementUiComponent { - @NotNull private static final BorderStrategy NAME_BORDER_STRATEGY = new NameBorderStrategy(); + @NotNull private static final BorderStrategy TEXT_BORDER_STRATEGY = new NameBorderStrategy(); @NotNull private static final BorderStrategy PREDEFINED_BORDER_STRATEGY = new PredefinedConditionBorderStrategy(); @NotNull @@ -92,7 +92,7 @@ public class ArrangementAtomMatchConditionComponent implements ArrangementUiComp @Nullable private Dimension myTextControlSize; @Nullable private Rectangle myScreenBounds; - @Nullable private Listener myListener; + @Nullable private Listener myListener; private boolean myEnabled = true; private boolean mySelected; @@ -106,18 +106,27 @@ public class ArrangementAtomMatchConditionComponent implements ArrangementUiComp myColorsProvider = colorsProvider; myCondition = condition; myCloseCallback = closeCallback; - myBorderStrategy = StdArrangementTokens.General.NAME.equals(condition.getType()) ? NAME_BORDER_STRATEGY : PREDEFINED_BORDER_STRATEGY; - if (condition.getType().equals(condition.getValue())) { - myText = condition.getType().getRepresentationValue(); + ArrangementSettingsToken type = condition.getType(); + if (StdArrangementTokens.Regexp.is(type)) { + myBorderStrategy = TEXT_BORDER_STRATEGY; + } + else { + myBorderStrategy = PREDEFINED_BORDER_STRATEGY; + } + if (type.equals(condition.getValue())) { + myText = type.getRepresentationValue(); + } + else if (StdArrangementTokens.Regexp.is(type)) { + myText = String.format("%s %s", type.getRepresentationValue().toLowerCase(), condition.getValue()); } else { myText = condition.getValue().toString(); } myTextControl.setTextAlign(SwingConstants.CENTER); - myTextControl.append(myText, SimpleTextAttributes.fromTextAttributes(colorsProvider.getTextAttributes(condition.getType(), false))); + myTextControl.append(myText, SimpleTextAttributes.fromTextAttributes(colorsProvider.getTextAttributes(type, false))); myTextControl.setOpaque(false); - int maxWidth = manager.getWidth(condition.getType()); - if (maxWidth > 0) { + int maxWidth = manager.getWidth(type); + if (!StdArrangementTokens.Regexp.is(type) && maxWidth > 0) { myTextControlSize = new Dimension(maxWidth, myTextControl.getPreferredSize().height); } else { diff --git a/platform/platform-resources-en/src/messages/ApplicationBundle.properties b/platform/platform-resources-en/src/messages/ApplicationBundle.properties index c6dc3577410b..c1a6f9346bf8 100644 --- a/platform/platform-resources-en/src/messages/ApplicationBundle.properties +++ b/platform/platform-resources-en/src/messages/ApplicationBundle.properties @@ -593,6 +593,7 @@ arrangement.settings.text.general.type=Type: arrangement.settings.text.general.modifier=Modifier: arrangement.settings.text.general.name=Name: arrangement.settings.text.general.order=Order: +arrangement.settings.text.general.xml.namespace=Namespace: arrangement.settings.text.entry.type.xml.tag=tag arrangement.settings.text.entry.type.xml.attribute=attribute diff --git a/platform/testFramework/testSrc/com/intellij/psi/codeStyle/arrangement/AbstractRearrangerTest.groovy b/platform/testFramework/testSrc/com/intellij/psi/codeStyle/arrangement/AbstractRearrangerTest.groovy index e7a67b796b62..c66f62e09127 100644 --- a/platform/testFramework/testSrc/com/intellij/psi/codeStyle/arrangement/AbstractRearrangerTest.groovy +++ b/platform/testFramework/testSrc/com/intellij/psi/codeStyle/arrangement/AbstractRearrangerTest.groovy @@ -120,7 +120,7 @@ abstract class AbstractRearrangerTest extends LightPlatformCodeInsightFixtureTes @NotNull protected static ArrangementAtomMatchCondition atom(@NotNull String nameFilter) { - new ArrangementAtomMatchCondition(StdArrangementTokens.General.NAME, nameFilter) + new ArrangementAtomMatchCondition(StdArrangementTokens.Regexp.NAME, nameFilter) } protected void doTest(@NotNull args) { diff --git a/xml/impl/src/com/intellij/xml/arrangement/XmlRearranger.java b/xml/impl/src/com/intellij/xml/arrangement/XmlRearranger.java index 261fd6982f39..c167236ae7d8 100644 --- a/xml/impl/src/com/intellij/xml/arrangement/XmlRearranger.java +++ b/xml/impl/src/com/intellij/xml/arrangement/XmlRearranger.java @@ -11,10 +11,7 @@ import com.intellij.psi.codeStyle.arrangement.group.ArrangementGroupingRule; import com.intellij.psi.codeStyle.arrangement.match.ArrangementEntryMatcher; import com.intellij.psi.codeStyle.arrangement.match.StdArrangementMatchRule; import com.intellij.psi.codeStyle.arrangement.model.ArrangementMatchCondition; -import com.intellij.psi.codeStyle.arrangement.std.ArrangementSettingsToken; -import com.intellij.psi.codeStyle.arrangement.std.ArrangementStandardSettingsAware; -import com.intellij.psi.codeStyle.arrangement.std.CompositeArrangementSettingsToken; -import com.intellij.psi.codeStyle.arrangement.std.StdArrangementSettings; +import com.intellij.psi.codeStyle.arrangement.std.*; import com.intellij.util.containers.ContainerUtilRt; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -23,9 +20,7 @@ import java.util.*; import static com.intellij.psi.codeStyle.arrangement.std.StdArrangementTokens.EntryType.XML_ATTRIBUTE; import static com.intellij.psi.codeStyle.arrangement.std.StdArrangementTokens.EntryType.XML_TAG; -import static com.intellij.psi.codeStyle.arrangement.std.StdArrangementTokens.General.NAME; -import static com.intellij.psi.codeStyle.arrangement.std.StdArrangementTokens.General.ORDER; -import static com.intellij.psi.codeStyle.arrangement.std.StdArrangementTokens.General.TYPE; +import static com.intellij.psi.codeStyle.arrangement.std.StdArrangementTokens.General.*; import static com.intellij.psi.codeStyle.arrangement.std.StdArrangementTokens.Order.BY_NAME; import static com.intellij.psi.codeStyle.arrangement.std.StdArrangementTokens.Order.KEEP; @@ -50,7 +45,8 @@ public class XmlRearranger @Override public boolean isEnabled(@NotNull ArrangementSettingsToken token, @Nullable ArrangementMatchCondition current) { - return NAME.equals(token) || KEEP.equals(token) || BY_NAME.equals(token) || SUPPORTED_TYPES.contains(token); + return SUPPORTED_TYPES.contains(token) || StdArrangementTokens.Regexp.NAME.equals(token) || StdArrangementTokens.Regexp.XML_NAMESPACE.equals(token) || KEEP.equals(token) + || BY_NAME.equals(token) || SUPPORTED_TYPES.contains(token); } @NotNull @@ -109,7 +105,8 @@ public class XmlRearranger public List getSupportedMatchingTokens() { return ContainerUtilRt.newArrayList( new CompositeArrangementSettingsToken(TYPE, SUPPORTED_TYPES), - new CompositeArrangementSettingsToken(NAME), + new CompositeArrangementSettingsToken(StdArrangementTokens.Regexp.NAME), + new CompositeArrangementSettingsToken(StdArrangementTokens.Regexp.XML_NAMESPACE), new CompositeArrangementSettingsToken(ORDER, KEEP, BY_NAME) ); }