Menu
▾
▴
[Rubyeclipse-commit] SF.net SVN: rubyeclipse: [2333] trunk/org.rubypeople.rdt.refactoring/src/ org/rubypeople/rdt/refactoring/core/pullup
|
From: <caw...@us...> - 2007-04-18 19:15:24
|
Revision: 2333
http://svn.sourceforge.net/rubyeclipse/?rev=2333&view=rev
Author: cawilliams
Date: 2007-04-18 12:15:23 -0700 (Wed, 18 Apr 2007)
Log Message:
-----------
pull up method refactoring
Added Paths:
-----------
trunk/org.rubypeople.rdt.refactoring/src/org/rubypeople/rdt/refactoring/core/pullup/MethodUpPuller.java
trunk/org.rubypeople.rdt.refactoring/src/org/rubypeople/rdt/refactoring/core/pullup/PullUpRefactoring.java
trunk/org.rubypeople.rdt.refactoring/src/org/rubypeople/rdt/refactoring/core/pullup/UpPulledMethods.java
trunk/org.rubypeople.rdt.refactoring/src/org/rubypeople/rdt/refactoring/core/pullup/UpPulledMethodsClass.java
Added: trunk/org.rubypeople.rdt.refactoring/src/org/rubypeople/rdt/refactoring/core/pullup/MethodUpPuller.java
===================================================================
--- trunk/org.rubypeople.rdt.refactoring/src/org/rubypeople/rdt/refactoring/core/pullup/MethodUpPuller.java (rev 0)
+++ trunk/org.rubypeople.rdt.refactoring/src/org/rubypeople/rdt/refactoring/core/pullup/MethodUpPuller.java 2007-04-18 19:15:23 UTC (rev 2333)
@@ -0,0 +1,180 @@
+/**
+ * Copyright (c) 2007 Aptana, Inc.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl -v10.html. If redistributing this code,
+ * this entire header must remain intact.
+ */
+package org.rubypeople.rdt.refactoring.core.pullup;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+
+import org.rubypeople.rdt.refactoring.classnodeprovider.ClassNodeProvider;
+import org.rubypeople.rdt.refactoring.documentprovider.DocumentProvider;
+import org.rubypeople.rdt.refactoring.editprovider.DeleteEditProvider;
+import org.rubypeople.rdt.refactoring.editprovider.EditAndTreeContentProvider;
+import org.rubypeople.rdt.refactoring.editprovider.EditProvider;
+import org.rubypeople.rdt.refactoring.editprovider.EditProviderGroups;
+import org.rubypeople.rdt.refactoring.editprovider.ITreeClass;
+import org.rubypeople.rdt.refactoring.nodewrapper.ClassNodeWrapper;
+import org.rubypeople.rdt.refactoring.nodewrapper.MethodNodeWrapper;
+import org.rubypeople.rdt.refactoring.ui.IItemSelectionReceiver;
+import org.rubypeople.rdt.refactoring.ui.IParentProvider;
+
+public class MethodUpPuller extends EditAndTreeContentProvider implements IItemSelectionReceiver {
+
+
+ private Object[] selectedTreeItems;
+
+ private ClassNodeProvider projectClassNodeProvider;
+
+ private ClassNodeProvider classNodeProvider;
+
+ public MethodUpPuller(DocumentProvider documentProvider) {
+ this.projectClassNodeProvider = documentProvider.getProjectClassNodeProvider();
+ this.classNodeProvider = documentProvider.getClassNodeProvider();
+
+ initTreeClasses(classNodeProvider);
+ }
+
+ @Override
+ protected ITreeClass createTreeClass(ClassNodeWrapper classNode) {
+ return new TreeClass(classNode);
+ }
+
+ @Override
+ public Collection<EditProvider> getEditProviders() {
+ EditProviderGroups editProviderGroups = new EditProviderGroups();
+ if (selectedTreeItems != null) {
+ for (Object o : selectedTreeItems) {
+ if (o instanceof TreeClass) {
+ TreeClass treeClass = (TreeClass) o;
+ treeClass.addUpPulledMethods(editProviderGroups);
+ }
+ }
+ }
+ return editProviderGroups.getAllEditProviders();
+ }
+
+ public void setSelectedItems(Object[] checkedElements) {
+ selectedTreeItems = checkedElements.clone();
+ }
+
+ public class TreeClass implements org.rubypeople.rdt.refactoring.ui.IChildrenProvider, ITreeClass {
+ private ClassNodeWrapper classNode;
+ private Collection<DownPushableMethod> downPushableMethods;
+ private ClassNodeWrapper superClass;
+
+ public TreeClass(ClassNodeWrapper classNode) {
+ this.classNode = classNode;
+ downPushableMethods = new ArrayList<DownPushableMethod>();
+ superClass = projectClassNodeProvider.getSuperClassOf(classNode.getSuperClassName());
+
+ if (superClass != null) {
+ for (MethodNodeWrapper methodNode : classNode.getMethods()) {
+ downPushableMethods.add(new DownPushableMethod(methodNode));
+ }
+ }
+ }
+
+ public void addUpPulledMethods(EditProviderGroups editProviderGroups) {
+ Collection<MethodNodeWrapper> checkedMethods = getCheckedMethods();
+
+ String childClassName = superClass.getName();
+ if (classNodeProvider.hasClassNode(childClassName)) {
+ ClassNodeWrapper classNode = classNodeProvider.getClassNode(childClassName);
+ addUpPulledMethods(classNode, checkedMethods, editProviderGroups);
+ } else {
+ addUpPulledMethodsClass(childClassName, checkedMethods, editProviderGroups);
+ }
+
+ addRemoveEdits(checkedMethods, editProviderGroups);
+ }
+
+ private void addRemoveEdits(Collection<MethodNodeWrapper> checkedMethods, EditProviderGroups editProviderGroups) {
+ for (MethodNodeWrapper methodNode : checkedMethods) {
+ editProviderGroups.add("removeOldMethods", new DeleteEditProvider(methodNode.getWrappedNode()));
+ }
+ }
+
+ private void addUpPulledMethods(ClassNodeWrapper childClassNode, Collection<MethodNodeWrapper> checkedMethods,
+ EditProviderGroups editProviderGroups) {
+ Collection<MethodNodeWrapper> constructorNodes = new ArrayList<MethodNodeWrapper>();
+ Collection<MethodNodeWrapper> methodNodes = new ArrayList<MethodNodeWrapper>();
+ separateConstructors(checkedMethods, methodNodes, constructorNodes);
+ if (!constructorNodes.isEmpty()) {
+ UpPulledMethods constructors = new UpPulledMethods(constructorNodes, childClassNode, true);
+ editProviderGroups.add("constructors_" + childClassNode.getName(), constructors);
+ }
+ if (!methodNodes.isEmpty()) {
+ UpPulledMethods methods = new UpPulledMethods(methodNodes, childClassNode, false);
+ editProviderGroups.add("methods_" + childClassNode.getName(), methods);
+ }
+ }
+
+ private void separateConstructors(Collection<MethodNodeWrapper> nodes, Collection<MethodNodeWrapper> methodNodes,
+ Collection<MethodNodeWrapper> constructorNodes) {
+ for (MethodNodeWrapper method : nodes) {
+ if (method.getSignature().isConstructor())
+ constructorNodes.add(method);
+ else
+ methodNodes.add(method);
+ }
+ }
+
+ private Collection<MethodNodeWrapper> getCheckedMethods() {
+ Collection<Object> allCheckedItems = Arrays.asList(selectedTreeItems);
+ Collection<MethodNodeWrapper> checkedMethods = new ArrayList<MethodNodeWrapper>();
+ for (DownPushableMethod method : downPushableMethods) {
+ if (allCheckedItems.contains(method))
+ checkedMethods.add(method.getMethodNode());
+ }
+ return checkedMethods;
+ }
+
+ private void addUpPulledMethodsClass(String className, Collection<MethodNodeWrapper> checkedMethods, EditProviderGroups editProviderGroups) {
+ UpPulledMethodsClass methodsClass = new UpPulledMethodsClass(className, checkedMethods);
+ editProviderGroups.add("newClasses_", methodsClass);
+ }
+
+ public String toString() {
+ return classNode.getName();
+ }
+
+ public Object[] getChildren() {
+ return downPushableMethods.toArray();
+ }
+
+ public boolean hasChildren() {
+ return !downPushableMethods.isEmpty();
+ }
+
+ public class DownPushableMethod implements IParentProvider {
+ private MethodNodeWrapper methodNode;
+
+ public DownPushableMethod(MethodNodeWrapper methodNode) {
+ this.methodNode = methodNode;
+ }
+
+ public String toString() {
+ return methodNode.getName();
+ }
+
+ public Object getParent() {
+ return TreeClass.this;
+ }
+
+ public TreeClass getTreeClass() {
+ return TreeClass.this;
+ }
+
+ public MethodNodeWrapper getMethodNode() {
+ return methodNode;
+ }
+ }
+ }
+}
Added: trunk/org.rubypeople.rdt.refactoring/src/org/rubypeople/rdt/refactoring/core/pullup/PullUpRefactoring.java
===================================================================
--- trunk/org.rubypeople.rdt.refactoring/src/org/rubypeople/rdt/refactoring/core/pullup/PullUpRefactoring.java (rev 0)
+++ trunk/org.rubypeople.rdt.refactoring/src/org/rubypeople/rdt/refactoring/core/pullup/PullUpRefactoring.java 2007-04-18 19:15:23 UTC (rev 2333)
@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) 2007 Aptana, Inc.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl -v10.html. If redistributing this code,
+ * this entire header must remain intact.
+ */
+package org.rubypeople.rdt.refactoring.core.pullup;
+
+import org.rubypeople.rdt.refactoring.core.RubyRefactoring;
+import org.rubypeople.rdt.refactoring.ui.pages.MethodUpPullerSelectionPage;
+
+public class PullUpRefactoring extends RubyRefactoring {
+
+ public static final String NAME = "Pull up";
+
+ public PullUpRefactoring() {
+ super(NAME);
+ MethodUpPuller upPuller = new MethodUpPuller(getDocumentProvider());
+ setEditProvider(upPuller);
+ pages.add(new MethodUpPullerSelectionPage(upPuller));
+ }
+}
Added: trunk/org.rubypeople.rdt.refactoring/src/org/rubypeople/rdt/refactoring/core/pullup/UpPulledMethods.java
===================================================================
--- trunk/org.rubypeople.rdt.refactoring/src/org/rubypeople/rdt/refactoring/core/pullup/UpPulledMethods.java (rev 0)
+++ trunk/org.rubypeople.rdt.refactoring/src/org/rubypeople/rdt/refactoring/core/pullup/UpPulledMethods.java 2007-04-18 19:15:23 UTC (rev 2333)
@@ -0,0 +1,70 @@
+/**
+ * Copyright (c) 2007 Aptana, Inc.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl -v10.html. If redistributing this code,
+ * this entire header must remain intact.
+ */
+package org.rubypeople.rdt.refactoring.core.pullup;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+import org.jruby.ast.BlockNode;
+import org.jruby.ast.Node;
+import org.rubypeople.rdt.refactoring.core.NodeFactory;
+import org.rubypeople.rdt.refactoring.editprovider.InsertEditProvider;
+import org.rubypeople.rdt.refactoring.nodewrapper.ClassNodeWrapper;
+import org.rubypeople.rdt.refactoring.nodewrapper.MethodNodeWrapper;
+import org.rubypeople.rdt.refactoring.offsetprovider.ConstructorOffsetProvider;
+import org.rubypeople.rdt.refactoring.offsetprovider.IOffsetProvider;
+import org.rubypeople.rdt.refactoring.offsetprovider.MethodOffsetProvider;
+
+public class UpPulledMethods extends InsertEditProvider {
+
+ private Collection<MethodNodeWrapper> methodNodes;
+
+ private boolean constructors;
+
+ private ClassNodeWrapper classNode;
+
+ public UpPulledMethods(Collection<MethodNodeWrapper> methodNodes, ClassNodeWrapper classNode, boolean constructors) {
+ super(true);
+ this.methodNodes = methodNodes;
+ this.constructors = constructors;
+ this.classNode = classNode;
+ }
+
+ @Override
+ protected BlockNode getInsertNode(int offset, String document) {
+ boolean needsNewLineAtEndOfBlock = lastEditInGroup && !isNextLineEmpty(offset, document);
+ return NodeFactory.createBlockNode(needsNewLineAtEndOfBlock, getMethodNodes(methodNodes));
+ }
+
+ private Node[] getMethodNodes(Collection<MethodNodeWrapper> nodeCollection) {
+ Collection<Node> nodes = new ArrayList<Node>();
+ boolean first = true;
+ for (MethodNodeWrapper methodNode : nodeCollection) {
+ if (first) {
+ first = false;
+ } else {
+ nodes.add(NodeFactory.createNewLineNode(null));
+ }
+ nodes.add(NodeFactory.createNewLineNode(methodNode.getWrappedNode()));
+ }
+ return nodes.toArray(new Node[nodes.size()]);
+ }
+
+ @Override
+ protected int getOffset(String document) {
+ IOffsetProvider offsetProvider;
+ if (constructors) {
+ offsetProvider = new ConstructorOffsetProvider(classNode, document);
+ } else {
+ offsetProvider = new MethodOffsetProvider(classNode, document);
+ }
+ return offsetProvider.getOffset();
+ }
+}
Added: trunk/org.rubypeople.rdt.refactoring/src/org/rubypeople/rdt/refactoring/core/pullup/UpPulledMethodsClass.java
===================================================================
--- trunk/org.rubypeople.rdt.refactoring/src/org/rubypeople/rdt/refactoring/core/pullup/UpPulledMethodsClass.java (rev 0)
+++ trunk/org.rubypeople.rdt.refactoring/src/org/rubypeople/rdt/refactoring/core/pullup/UpPulledMethodsClass.java 2007-04-18 19:15:23 UTC (rev 2333)
@@ -0,0 +1,87 @@
+/**
+ * Copyright (c) 2007 Aptana, Inc.
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl -v10.html. If redistributing this code,
+ * this entire header must remain intact.
+ */
+package org.rubypeople.rdt.refactoring.core.pullup;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+import org.jruby.ast.BlockNode;
+import org.jruby.ast.Node;
+import org.jruby.lexer.yacc.SourcePosition;
+import org.rubypeople.rdt.refactoring.core.NodeFactory;
+import org.rubypeople.rdt.refactoring.core.pushdown.NewClassOffsetProvier;
+import org.rubypeople.rdt.refactoring.editprovider.InsertEditProvider;
+import org.rubypeople.rdt.refactoring.nodewrapper.MethodNodeWrapper;
+import org.rubypeople.rdt.refactoring.offsetprovider.IOffsetProvider;
+
+public class UpPulledMethodsClass extends InsertEditProvider {
+ private Collection<MethodNodeWrapper> methodNodes;
+
+ private Collection<MethodNodeWrapper> constructorNodes;
+
+ private String className;
+
+ public UpPulledMethodsClass(String className, Collection<MethodNodeWrapper> allMethodNodes) {
+ super(true);
+ this.className = className;
+ initConstrucorAndMethodNodes(allMethodNodes);
+ }
+
+ private void initConstrucorAndMethodNodes(Collection<MethodNodeWrapper> allMethodNodes) {
+ methodNodes = new ArrayList<MethodNodeWrapper>();
+ constructorNodes = new ArrayList<MethodNodeWrapper>();
+ for (MethodNodeWrapper node : allMethodNodes) {
+ if (node.getSignature().isConstructor())
+ constructorNodes.add(node);
+ else
+ methodNodes.add(node);
+ }
+ }
+
+ @Override
+ protected BlockNode getInsertNode(int offset, String document) {
+ if (firstEditInGroup) {
+ setInsertType(INSERT_AT_BEGIN_OF_LINE);
+ }
+ boolean needsNewLineAtEndOfBlock = lastEditInGroup && !isNextLineEmpty(offset, document);
+ Node classNode = getClassNode();
+
+ BlockNode blockNode = NodeFactory.createBlockNode();
+ blockNode.add(classNode);
+ if (!firstEditInGroup)
+ blockNode.add(NodeFactory.createNewLineNode(null));
+ if (needsNewLineAtEndOfBlock)
+ blockNode.add(NodeFactory.createNewLineNode(null));
+ return blockNode;
+ }
+
+ private Node getClassNode() {
+ return NodeFactory.createNewLineNode(NodeFactory.createClassNode(className, getBody()));
+ }
+
+ private Node getBody() {
+ BlockNode body = new BlockNode(new SourcePosition());
+ body.add(NodeFactory.createNewLineNode(null));
+ for (MethodNodeWrapper constructor : constructorNodes) {
+ body.add(NodeFactory.createNewLineNode(constructor.getWrappedNode()));
+ }
+ for (MethodNodeWrapper method : methodNodes) {
+ body.add(NodeFactory.createNewLineNode(method.getWrappedNode()));
+ }
+ body.add(NodeFactory.createNewLineNode(null));
+ return body;
+ }
+
+ @Override
+ protected int getOffset(String document) {
+ IOffsetProvider offsetProvider = new NewClassOffsetProvier();
+ return offsetProvider.getOffset();
+ }
+}
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
