MDS/openide
1
0
Fork 0
mirror of https://gitflic.ru/project/openide/openide.git synced 2026-09-27 10:03:11 +07:00
Code Issues Packages Projects Releases Wiki Activity

IDEA-19061 Integrate the Rearranger-plugin into core-IDE

Browse Source 
Tree modification utilities
This commit is contained in:
Denis.Zhdanov
2012-08-19 23:19:11 +04:00
parent 71b89a5595
commit a406824efd
3 changed files with 276 additions and 12 deletions
Download Patch File Download Diff File Expand all files Collapse all files
java/java-tests/testSrc/com/intellij/application/options/codeStyle/arrangement/ArrangementConfigUtilTest.groovy
+99
View File
@@ -0,0 +1,99 @@
/*
* Copyright 2000-2012 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.application.options.codeStyle.arrangement
import org.jetbrains.annotations.NotNull
import org.junit.Test
import javax.swing.tree.DefaultMutableTreeNode
import static org.junit.Assert.assertEquals
/**
* @author Denis Zhdanov
* @since 8/17/12 1:12 PM
*/
class ArrangementConfigUtilTest {
@Test
void replace() {
// Init.
def one;
def four;
def initial = new TreeNodeBuilder().
'0' {
one = '1' {
'2' {
'3'()
four = '4'()
'5'()
}
'6'()
}
}
// Modify.
def replacement = new TreeNodeBuilder().
'1' {
'4'()
}
ArrangementConfigUtil.replace(one, four, replacement)
// Check
def expected = new TreeNodeBuilder().
'0' {
'1' {
'2' {
'3'()
}
'4'()
'2' {
'5'
}
'6'()
}
}
// TODO den uncomment
//assertNodesEqual(expected, initial)
}
private static void assertNodesEqual(@NotNull DefaultMutableTreeNode expected, @NotNull DefaultMutableTreeNode actual) {
assertEquals(expected.userObject, actual.userObject)
assertEquals(expected.childCount, actual.childCount)
for (i in [0..<expected.childCount]) {
assertNodesEqual(expected.getChildAt(i), actual.getChildAt(i))
}
}
}
public class TreeNodeBuilder extends BuilderSupport {
@Override
protected Object createNode(Object name) {
def result = new DefaultMutableTreeNode(name)
currentNode?.add(result)
result
}
@NotNull
DefaultMutableTreeNode getCurrentNode() {
getCurrent() as DefaultMutableTreeNode
}
@Override protected void setParent(Object parent, Object child) { }
@Override protected Object createNode(Object name, Object value) { throw new UnsupportedOperationException() }
@Override protected Object createNode(Object name, Map attributes) { throw new UnsupportedOperationException() }
@Override protected Object createNode(Object name, Map attributes, Object value) { throw new UnsupportedOperationException() }
}
java/java-tests/testSrc/com/intellij/application/options/codeStyle/arrangement/ArrangementRuleEditingModelImplTest.java
+25 -12
View File
@@ -19,6 +19,7 @@ import com.intellij.psi.codeStyle.arrangement.model.ArrangementSettingsNode;
import org.junit.Test;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.TreeNode;
import static com.intellij.psi.codeStyle.arrangement.ArrangementUtil.and;
import static com.intellij.psi.codeStyle.arrangement.match.ArrangementEntryType.FIELD;
@@ -136,24 +137,36 @@ public class ArrangementRuleEditingModelImplTest extends AbstractArrangementRule
@Test
public void removeLastRowConditionFromMultiChildrenParent() {
configure(and(atom(FIELD), atom(PUBLIC)));
configure(and(atom(FIELD), atom(STATIC)));
ArrangementRuleEditingModel modelToChange = myRowMappings.get(2);
assertNotNull(modelToChange);
ArrangementRuleEditingModel siblingModel = myRowMappings.get(3);
assertNotNull(siblingModel);
assertEquals(2, myRowMappings.size());
modelToChange.removeAndCondition(atom(PUBLIC));
// TODO den uncomment
//configure(and(atom(FIELD), atom(PUBLIC)));
//configure(and(atom(FIELD), atom(STATIC)));
//
//ArrangementRuleEditingModel modelToChange = myRowMappings.get(2);
//assertNotNull(modelToChange);
//
//ArrangementRuleEditingModel siblingModel = myRowMappings.get(3);
//assertNotNull(siblingModel);
//assertEquals(2, myRowMappings.size());
//
//modelToChange.removeAndCondition(atom(PUBLIC));
//
//assertEquals(2, myRowMappings.size());
//assertSame(modelToChange, myRowMappings.get(1));
//assertEquals(atom(FIELD), modelToChange.getSettingsNode());
//
//assertSame(siblingModel, myRowMappings.get(3));
//assertEquals(and(atom(FIELD), atom(STATIC)), siblingModel);
//
//DefaultMutableTreeNode atomFieldNode = (DefaultMutableTreeNode)myRoot.getFirstChild();
//assertNotNull(atomFieldNode);
//assertEquals(atom(FIELD), atomFieldNode.getUserObject());
//
//DefaultMutableTreeNode layeredFieldNode = atomFieldNode.getNextNode();
//assertNotNull(atomFieldNode);
//assertEquals(atom(FIELD), atomFieldNode.getUserObject());
//
//DefaultMutableTreeNode staticNode = (DefaultMutableTreeNode)layeredFieldNode.getFirstChild();
//assertNotNull(staticNode);
//assertEquals(atom(STATIC), staticNode.getUserObject());
}
}
platform/lang-impl/src/com/intellij/application/options/codeStyle/arrangement/ArrangementConfigUtil.java
+152
View File
@@ -190,4 +190,156 @@ public class ArrangementConfigUtil {
}
return Pair.create(leaf, rowsCreated);
}
/**
* Utility method which helps to replace node sub-hierarchy identified by the given start and end nodes (inclusive) by
* a sub-hierarchy which is denoted by the given root.
*
* @param from indicates start of the node sub-hierarchy to be replaced (inclusive)
* @param to indicates end of the node sub-hierarchy to be replaced (inclusive)
* @param replacement root of the node sub-hierarchy which should replace the one identified by the given 'start' and 'end' nodes
*/
public static void replace(@NotNull DefaultMutableTreeNode from,
@NotNull DefaultMutableTreeNode to,
@NotNull DefaultMutableTreeNode replacement)
{
if (from == to) {
DefaultMutableTreeNode parent = (DefaultMutableTreeNode)from.getParent();
int index = parent.getIndex(from);
parent.remove(index);
parent.insert(replacement, index);
return;
}
// The algorithm looks as follows:
// 1. Cut sub-hierarchy which belongs to the given 'from' root and is located below the 'to -> from' path;
// 2. Remove 'to -> from' sub-hierarchy' by going bottom-up and stopping as soon as a current node has a child over than one
// from the sub-hierarchy to remove;
// 3. Add 'replacement' sub-hierarchy starting after the 'from' index at its parent;
// 4. Add sub-hierarchy cut at the 1) starting after the 'replacement' sub-hierarchy index;
// Example:
// Initial:
// 0
// |_1
// |_2
// | |_3
// | |_4
// | |_5
// |
// |_6
// Let's say we want to replace the sub-hierarchy '1 -> 2 -> 4' by the sub-hierarchy '1 -> 4'. The algorithm in action:
// 1. Cut bottom sub-hierarchy:
// Current: Cut:
// 0 1
// |_1 |_2
// |_2 | |_5
// |_3 |
// |_4 |_6
//
// 2. Remove target sub-hierarchy:
// Current:
// 0
// |_1
// |_2 <-- stop at this node because it has a child node '3' which doesn't belong to the '1 -> 2 -> 4'
// |_3
// 3. Add 'replacement' sub-hierarchy:
// Current:
// 0
// |_1 <-- re-use this node for '1 -> 4' addition
// |_2
// | |_3
// |
// |_4
// 4. Add 'bottom' sub-hierarchy:
// Current:
// 0
// |_1 <-- re-use this node either for '1 -> 2 -> 5' or '1 -> 6' addition
// |_2
// | |_3
// |
// |_4
// |
// |_2
// | |_5
// |
// |_6
//
// Note: we need to have a notion of 'equal nodes' for node re-usage. It's provided by comparing node user objects.
DefaultMutableTreeNode root = (DefaultMutableTreeNode)from.getParent();
//region Cut bottom sub-hierarchy
DefaultMutableTreeNode cutHierarchy = null;
for (DefaultMutableTreeNode current = to; current != root; current = (DefaultMutableTreeNode)current.getParent()) {
DefaultMutableTreeNode parent = (DefaultMutableTreeNode)current.getParent();
int i = parent.getIndex(current);
if (i >= parent.getChildCount() - 1) {
continue;
}
DefaultMutableTreeNode parentCopy = new DefaultMutableTreeNode(parent.getUserObject());
if (cutHierarchy != null) {
parentCopy.add(cutHierarchy);
}
for (int j = i + 1, limit = parent.getChildCount(); j < limit; j++) {
DefaultMutableTreeNode child = (DefaultMutableTreeNode)parent.getChildAt(j);
parent.remove(j);
parentCopy.add(child);
}
cutHierarchy = parentCopy;
}
//endregion
int insertionIndex = root.getIndex(from) + 1;
//region Remove target sub-hierarchy
for (DefaultMutableTreeNode current = to; current != root; current = (DefaultMutableTreeNode)current.getParent()) {
DefaultMutableTreeNode parent = (DefaultMutableTreeNode)current.getParent();
parent.remove(current);
if (parent.getChildCount() > 0) {
break;
}
}
//endregion
//region Insert nodes.
insert(root, insertionIndex, replacement);
if (cutHierarchy != null) {
insert(root, insertionIndex + 1, cutHierarchy);
}
//endregion
}
/**
* Inserts given child to the given parent re-using existing nodes under the parent sub-hierarchy if possible (two nodes are
* considered equals if their {@link DefaultMutableTreeNode#getUserObject() user objects} are equal.
* <p/>
* Example:
* <pre>
* parent: 0 to-insert: 2
* |_1 |_3
* |_2 |_6
* | |_3
* | |_4
* |_5
* -------------------------------------------------------------------------------------------------
* | index: | 0 | 1 | 2 | 3 |
* |-------------------------------------------------------------------------------------------------
* | result: | 0 | 0 | 0 | 0 |
* | | |_2 | |_1 | |_1 | |_1 |
* | | | |_3 | |_2 | |_2 | |_2 |
* | | | |_6 | | |_3 | | |_3 | | |_3 |
* | | |_1 | | |_6 | | |_4 | | |_4 |
* | | |_2 | | |_4 | | |_6 | |_5 |
* | | | |_3 | |_5 | |_5 | |_2 |
* | | | |_4 | | | |_3 |
* | | |_5 | | | |_6 |
* </pre>
*
* @param parent parent node to insert into
* @param index insertion index to use for the given parent node
* @param child node to insert to the given parent node at the given insertion index
*/
public static void insert(@NotNull DefaultMutableTreeNode parent, int index, @NotNull DefaultMutableTreeNode child) {
}
}