Attachment #21970 for bug #58561

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 58561
Collapse All | Expand All




import org.netbeans.jmi.javamodel.JavaClass;
import org.netbeans.modules.java.JavaDataObject;
import org.netbeans.modules.javacore.api.JavaModel;
import org.netbeans.modules.javacore.internalapi.JavaMetamodel;
import org.netbeans.modules.refactoring.classpath.Util;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;
import org.openide.loaders.DataFolder;
import org.openide.loaders.DataObject;
import org.openide.loaders.DataObjectNotFoundException;

/**
 * Move class/classes refactoring.

    
    private Collection/*<Resource>*/        resources;
    private Collection                      otherDataObjects = Collections.EMPTY_LIST;
    private boolean                         particularClassSelected = false;
    private FileObject                      folder = null;
    private Map                             packagePostfix;
    private Collection dataObjects = Collections.EMPTY_LIST;
    //private String targetPrefix = ""; //NOI18N
    //private DataObject movedSource;
    
    private Map checkedSourcesMap;
    private boolean packageRename;
    private boolean isPackageRename = false;
    private String newPackageName;
    private FileObject target;
    
    /**
     * Creates a new instance of MoveClassRefactoring. All classes within given folder will be moved.
     * @param sourceFolder Folder where classes are held
     * @param isPackage true - given sourceFolder is considered as java package - only direct children will be moved.
     *                  false - given sourceFolder is considered as folder - move fill be performed recursively
     */
    public MoveClassRefactoring(FileObject sourceFolder, boolean isPackage) {
        isPackageRename = true;
        this.packageRename = isPackage;
        if (packageRename) {
            this.folder = sourceFolder;
            DataObject[] children = DataFolder.findFolder(folder).getChildren();
            resources = new HashSet();
            otherDataObjects = new HashSet();
            for (int i = 0; i < children.length; i++) {
                if (children[i] instanceof JavaDataObject) {
                    resources.add(JavaModel.getResource(children[i].getPrimaryFile()));
                } else if (!(children[i] instanceof DataFolder)) {
                    otherDataObjects.add(children[i]);
                }
            }
        } else {
            this.folder = sourceFolder;
            LinkedList children = new LinkedList(Arrays.asList(DataFolder.findFolder(folder).getChildren()));
            resources = new HashSet();
            otherDataObjects = new HashSet();
            while(!children.isEmpty()) {
                DataObject dob = (DataObject) children.removeFirst();
                if (dob instanceof JavaDataObject) {
                    resources.add(JavaModel.getResource(dob.getPrimaryFile()));
                } else if (dob instanceof DataFolder) {
                    children.addAll(Arrays.asList(((DataFolder)dob).getChildren()));
                } else {
                    otherDataObjects.add(dob);
                }
            }
        }
    }

    /**
     * Getter for property sourceFolder
     * @return Value of sourceFolder or null if no surce folder was specified
     */
    public FileObject getSourceFolder() {
        return folder;
    }
    
    /**
     * Creates a new instance of MoveClassRefactoring.
     * @param javaClass a JavaClass which will be moved
     */
    public MoveClassRefactoring(JavaClass javaClass) {
        resources = new ArrayList(1);
        resources.add(javaClass.getResource());
        particularClassSelected = true;
    }
    
    /**
     * Creates a new instance of MoveClassRefactoring.
     * @param resources All Resources from this collection will be moved
     */
    public MoveClassRefactoring(Collection resources) {
        this.resources = resources;
    }
    
    /**
     * Creates a new instance of MoveClassRefactoring.
     * @param dataObjects DataObjects that are being moved
     * @param target target folder
     */
    public MoveClassRefactoring(Collection dataObjects, FileObject target) {
        this.target = target;
        resources = new ArrayList(1);
        packagePostfix = new HashMap(dataObjects.size());
        otherDataObjects = new HashSet();
        this.dataObjects=dataObjects;
        setup(dataObjects, "");
    }
    
    /**
     * Getter for property sourceFolder
     * @return Value of sourceFolder or null if no surce folder was specified
     */
    public FileObject getSourceFolder() {
        return folder;
    }

    protected void setClassPath() {
        Util.setClassPath(resources);
    }

    }
    
    /**
     * Getter for property targetPackageName
     * @return Value of property targetPackageName
     */
    public String getTargetPackageName() {
        return newPackageName;
    }

    /**
     * Getter for targetPackageName for specified Resource
     * @return Value of property targetPackageName
     * @param r Resource for which target package name is requested
     */
    public String getTargetPackageName(Resource r) {
        return getTargetPackageName(JavaModel.getFileObject(r));
    }
    
    /**
     * Getter for targetPackageName for specified FileObject
     * @return Value of property targetPackageName
     * @param fo FileObject for which target package name is requested
     */
    public String getTargetPackageName(FileObject fo) {
        if (isPackageRename) {
            if (packageRename)
                return newPackageName;
            else {
                //folder rename
                ClassPath cp = ClassPath.getClassPath(folder, ClassPath.SOURCE);
                FileObject root = cp.findOwnerRoot(folder);
                String prefix = FileUtil.getRelativePath(root, folder.getParent()).replace('/','.');
                String postfix = FileUtil.getRelativePath(folder, fo.getParent()).replace('/', '.');
                String t = concat(prefix, newPackageName, postfix);
                return t;
            }
        }

        if (packagePostfix != null) {
            String postfix = (String) packagePostfix.get(fo);
            String packageName = concat(null, newPackageName, postfix);
            return packageName;
        } else
            return newPackageName;
    }

    /**
     * Getter for property otherDataObjects
     * @return Value of property otherDataObjects

    }
    
    /**
     * Getter for property targetClassPathRoot
     * @return returns target class path root
     */
    public FileObject getTargetClassPathRoot() {
        FileObject f = isPackageRename ? folder : target;
        return ClassPath.getClassPath(f, ClassPath.SOURCE).findOwnerRoot(f);
    }
    
    private boolean isPackageRename = false;
    private String newPackageName;
    private FileObject target;
    
    /**
     * Setter for property targetClassPath root
     * @param target New value of property targetClassPath root
     */
    public void setTargetClassPathRoot(FileObject target) {
        this.target = target;
    }
    
    /**
     * Setter for property newPackageName
     * @param name New value of property newPackageName
     */
    public void setTargetPackageName(String name) {
        isPackageRename = true;
        this.newPackageName = name;
    }
    
    /**
     * Getter for property selectedDataObjects
     * @return Value of property selectedDataObjects
     */
    public Collection getSelectedDataObjects() {
        if (isPackageRename) {
            try {
                if (!packageRename)
                    return Collections.singletonList(DataObject.find(folder));
                else {
                    FileObject f = folder;
                    FileObject cpRoot = getTargetClassPathRoot();
                    while (f.getParent() != cpRoot) {
                        f = f.getParent();
                    }
                    return Collections.singletonList(DataObject.find(f));
                }
            } catch (DataObjectNotFoundException notFound) {
                
            }
        }
        return dataObjects;
    }
    
    private void setup(Collection dataObjects, String postfix) {
        for (Iterator i = dataObjects.iterator(); i.hasNext(); ) {
            DataObject o = (DataObject) i.next();
            FileObject fo = o.getPrimaryFile();
            if (o instanceof JavaDataObject) {
                Resource r = JavaModel.getResource(fo);
                resources.add(r);
                packagePostfix.put(fo, postfix.replace('/', '.'));
            } else if (!(o instanceof DataFolder)) {
                otherDataObjects.add(o);
                packagePostfix.put(fo, postfix.replace('/', '.'));
            } else {
                
                boolean addDot = !"".equals(postfix);
                Collection col = new ArrayList();
                for (Enumeration en = ((DataFolder) o).children(); en.hasMoreElements(); col.add(en.nextElement()));
                
                setup(col, postfix +(addDot?".":"") +o.getName());
            }
        }
    }
 
    private String concat(String s1, String s2, String s3) {
        String result = "";
        if (s1 != null && !"".equals(s1)) {
            result += s1 + ".";
        }
        result +=s2;
        if (s3 != null && !"".equals(s3)) {
            result += ("".equals(result)? "" : ".") + s3;
        }
        return result;
    }
}  


Return to bug 58561

Lines 18-28 Link Here

(-)MoveClassRefactoring.java (-73 / +155 lines)
18	import org.netbeans.jmi.javamodel.JavaClass;	18	import org.netbeans.jmi.javamodel.JavaClass;
19	import org.netbeans.modules.java.JavaDataObject;	19	import org.netbeans.modules.java.JavaDataObject;
20	import org.netbeans.modules.javacore.api.JavaModel;	20	import org.netbeans.modules.javacore.api.JavaModel;
21	import org.netbeans.modules.javacore.internalapi.JavaMetamodel;
22	import org.netbeans.modules.refactoring.classpath.Util;	21	import org.netbeans.modules.refactoring.classpath.Util;
23	import org.openide.filesystems.FileObject;	22	import org.openide.filesystems.FileObject;
		23	import org.openide.filesystems.FileUtil;
24	import org.openide.loaders.DataFolder;	24	import org.openide.loaders.DataFolder;
25	import org.openide.loaders.DataObject;	25	import org.openide.loaders.DataObject;
		26	import org.openide.loaders.DataObjectNotFoundException;
26		27
27	/**	28	/**
28	* Move class/classes refactoring.	29	* Move class/classes refactoring.
Lines 32-102 Link Here
32		33
33	private Collection/<Resource>/ resources;	34	private Collection/<Resource>/ resources;
34	private Collection otherDataObjects = Collections.EMPTY_LIST;	35	private Collection otherDataObjects = Collections.EMPTY_LIST;
35	private boolean particularClassSelected = false;
36	private FileObject folder = null;	36	private FileObject folder = null;
37	private boolean invokedAfterDOMove = false;	37	private Map packagePostfix;
38		38	private Collection dataObjects = Collections.EMPTY_LIST;
39	//private String targetPrefix = ""; //NOI18N
40	//private DataObject movedSource;
41
42	private Map checkedSourcesMap;	39	private Map checkedSourcesMap;
43		40	private boolean packageRename;
44	private int size;	41	private boolean isPackageRename = false;
		42	private String newPackageName;
		43	private FileObject target;
45		44
46	/**	45	/**
47	* Creates a new instance of MoveClassRefactoring. All classes within given folder will be moved.	46	* Creates a new instance of MoveClassRefactoring. All classes within given folder will be moved.
48	* @param folder Folder where classes are held	47	* @param sourceFolder Folder where classes are held
		48	* @param isPackage true - given sourceFolder is considered as java package - only direct children will be moved.
		49	* false - given sourceFolder is considered as folder - move fill be performed recursively
49	*/	50	*/
50	public MoveClassRefactoring(FileObject sourceFolder) {	51	public MoveClassRefactoring(FileObject sourceFolder, boolean isPackage) {
51	this.folder = sourceFolder;	52	isPackageRename = true;
52	DataObject[] children = DataFolder.findFolder(folder).getChildren();	53	this.packageRename = isPackage;
53	resources = new HashSet();	54	if (packageRename) {
54	otherDataObjects = new HashSet();	55	this.folder = sourceFolder;
55	for (int i = 0; i < children.length; i++) {	56	DataObject[] children = DataFolder.findFolder(folder).getChildren();
56	if (children[i] instanceof JavaDataObject) {	57	resources = new HashSet();
57	resources.add(JavaModel.getResource(children[i].getPrimaryFile()));	58	otherDataObjects = new HashSet();
58	} else if (!(children[i] instanceof DataFolder)) {	59	for (int i = 0; i < children.length; i++) {
59	otherDataObjects.add(children[i]);	60	if (children[i] instanceof JavaDataObject) {
		61	resources.add(JavaModel.getResource(children[i].getPrimaryFile()));
		62	} else if (!(children[i] instanceof DataFolder)) {
		63	otherDataObjects.add(children[i]);
		64	}
		65	}
		66	} else {
		67	this.folder = sourceFolder;
		68	LinkedList children = new LinkedList(Arrays.asList(DataFolder.findFolder(folder).getChildren()));
		69	resources = new HashSet();
		70	otherDataObjects = new HashSet();
		71	while(!children.isEmpty()) {
		72	DataObject dob = (DataObject) children.removeFirst();
		73	if (dob instanceof JavaDataObject) {
		74	resources.add(JavaModel.getResource(dob.getPrimaryFile()));
		75	} else if (dob instanceof DataFolder) {
		76	children.addAll(Arrays.asList(((DataFolder)dob).getChildren()));
		77	} else {
		78	otherDataObjects.add(dob);
		79	}
60	}	80	}
61	}	81	}
62	}	82	}
63		83
64	/**	84	/**
65	* Getter for property sourceFolder
66	* @return Value of sourceFolder or null if no surce folder was specified
67	*/
68	public FileObject getSourceFolder() {
69	return folder;
70	}
71
72	/**
73	* Creates a new instance of MoveClassRefactoring.	85	* Creates a new instance of MoveClassRefactoring.
74	* @param javaClass a JavaClass which will be moved	86	* @param javaClass a JavaClass which will be moved
75	*/	87	*/
76	public MoveClassRefactoring(JavaClass javaClass) {	88	public MoveClassRefactoring(JavaClass javaClass) {
77	resources = new ArrayList(1);	89	resources = new ArrayList(1);
78	resources.add(javaClass.getResource());	90	resources.add(javaClass.getResource());
79	particularClassSelected = true;
80	}	91	}
81		92
82	/**	93	/**
83	* Creates a new instance of MoveClassRefactoring.	94	* Creates a new instance of MoveClassRefactoring.
84	* @param resources All resources from this collection will be moved	95	* @param resources All Resources from this collection will be moved
85	*/	96	*/
86	public MoveClassRefactoring(Collection resources) {	97	public MoveClassRefactoring(Collection resources) {
87	this.resources = resources;	98	this.resources = resources;
88	}	99	}
89		100
90	/**	101	/**
91	* Creates a new instance of MoveClassRefactoring	102	* Creates a new instance of MoveClassRefactoring.
92	* @param resources All resources from this collection will be moved	103	* @param dataObjects DataObjects that are being moved
93	* @param invokedAfterDOMove true if files has been already moved on disk	104	* @param target target folder
94	*/	105	*/
95	public MoveClassRefactoring(Collection resources, boolean invokedAfterDOMove) {	106	public MoveClassRefactoring(Collection dataObjects, FileObject target) {
96	this.invokedAfterDOMove = invokedAfterDOMove;	107	this.target = target;
97	this.resources = resources;	108	resources = new ArrayList(1);
		109	packagePostfix = new HashMap(dataObjects.size());
		110	otherDataObjects = new HashSet();
		111	this.dataObjects=dataObjects;
		112	setup(dataObjects, "");
98	}	113	}
99		114
		115	/**
		116	* Getter for property sourceFolder
		117	* @return Value of sourceFolder or null if no surce folder was specified
		118	*/
		119	public FileObject getSourceFolder() {
		120	return folder;
		121	}
		122
100	protected void setClassPath() {	123	protected void setClassPath() {
101	Util.setClassPath(resources);	124	Util.setClassPath(resources);
102	}	125	}
Lines 110-138 Link Here
110	}	133	}
111		134
112	/**	135	/**
113	* Getter for property target	136	* Getter for property targetPackageName
114	* @return Value of property target	137	* @return Value of property targetPackageName
115	*/	138	*/
116	public FileObject getTarget() {	139	public String getTargetPackageName() {
117	return target;	140	return newPackageName;
118	}	141	}
119		142
120	/**	143	/**
121	* Getter for property target	144	* Getter for targetPackageName for specified Resource
122	* @return Value of property target	145	* @return Value of property targetPackageName
		146	* @param r Resource for which target package name is requested
123	*/	147	*/
124	public String getTargetPackageName(Resource r) {	148	public String getTargetPackageName(Resource r) {
125	return isPackageRename ? newPackageName : getPackageName(getTargetFile(r));	149	return getTargetPackageName(JavaModel.getFileObject(r));
126	}	150	}
127		151
128	/**	152	/**
129	* Getter for property newPackageName	153	* Getter for targetPackageName for specified FileObject
130	* @return Value of property newPackageName	154	* @return Value of property targetPackageName
131	*/	155	* @param fo FileObject for which target package name is requested
132	public String getNewPackageName() {	156	*/
133	return newPackageName;	157	public String getTargetPackageName(FileObject fo) {
		158	if (isPackageRename) {
		159	if (packageRename)
		160	return newPackageName;
		161	else {
		162	//folder rename
		163	ClassPath cp = ClassPath.getClassPath(folder, ClassPath.SOURCE);
		164	FileObject root = cp.findOwnerRoot(folder);
		165	String prefix = FileUtil.getRelativePath(root, folder.getParent()).replace('/','.');
		166	String postfix = FileUtil.getRelativePath(folder, fo.getParent()).replace('/', '.');
		167	String t = concat(prefix, newPackageName, postfix);
		168	return t;
		169	}
		170	}
		171
		172	if (packagePostfix != null) {
		173	String postfix = (String) packagePostfix.get(fo);
		174	String packageName = concat(null, newPackageName, postfix);
		175	return packageName;
		176	} else
		177	return newPackageName;
134	}	178	}
135		179
136	/**	180	/**
137	* Getter for property otherDataObjects	181	* Getter for property otherDataObjects
138	* @return Value of property otherDataObjects	182	* @return Value of property otherDataObjects
Lines 142-188 Link Here
142	}	186	}
143		187
144	/**	188	/**
145	* @return retrurns class path root of target folder for given resource	189	* Getter for property targetClassPathRoot
		190	* @return returns target class path root
146	*/	191	*/
147	public FileObject getTargetClassPathRoot(Resource r) {	192	public FileObject getTargetClassPathRoot() {
148	FileObject f = isPackageRename ? folder : getTargetFile(r);	193	FileObject f = isPackageRename ? folder : target;
149	return ClassPath.getClassPath(f, ClassPath.SOURCE).findOwnerRoot(f);	194	return ClassPath.getClassPath(f, ClassPath.SOURCE).findOwnerRoot(f);
150	}	195	}
151		196
152	private boolean isPackageRename = false;
153	private String newPackageName;
154	private FileObject target;
155
156	/**	197	/**
157	* Setter for property target	198	* Setter for property targetClassPath root
158	* @param target New value of property target	199	* @param target New value of property targetClassPath root
159	*/	200	*/
160	public void setTarget(FileObject target) {	201	public void setTargetClassPathRoot(FileObject target) {
161	this.target = target;	202	this.target = target;
162	}	203	}
163		204
164	/**	205	/**
165	* Setter for property newPackageNam	206	* Setter for property newPackageName
166	* @param name New value of property newPackageNam	207	* @param name New value of property newPackageName
167	*/	208	*/
168	public void setNewPackageName(String name) {	209	public void setTargetPackageName(String name) {
169	isPackageRename = true;
170	this.newPackageName = name;	210	this.newPackageName = name;
171	}	211	}
172		212
173	/**	213	/**
174	* Getter for property invokedAfterDOMove	214	* Getter for property selectedDataObjects
175	* @return true if Files has been already moved	215	* @return Value of property selectedDataObjects
176	*/	216	*/
177	public boolean isInvokedAfterFileMove() {	217	public Collection getSelectedDataObjects() {
178	return invokedAfterDOMove;	218	if (isPackageRename) {
		219	try {
		220	if (!packageRename)
		221	return Collections.singletonList(DataObject.find(folder));
		222	else {
		223	FileObject f = folder;
		224	FileObject cpRoot = getTargetClassPathRoot();
		225	while (f.getParent() != cpRoot) {
		226	f = f.getParent();
		227	}
		228	return Collections.singletonList(DataObject.find(f));
		229	}
		230	} catch (DataObjectNotFoundException notFound) {
		231
		232	}
		233	}
		234	return dataObjects;
179	}	235	}
180		236
181	private static String getPackageName(FileObject f) {	237	private void setup(Collection dataObjects, String postfix) {
182	return ClassPath.getClassPath(f, ClassPath.SOURCE).getResourceName(f, '.', false);	238	for (Iterator i = dataObjects.iterator(); i.hasNext(); ) {
		239	DataObject o = (DataObject) i.next();
		240	FileObject fo = o.getPrimaryFile();
		241	if (o instanceof JavaDataObject) {
		242	Resource r = JavaModel.getResource(fo);
		243	resources.add(r);
		244	packagePostfix.put(fo, postfix.replace('/', '.'));
		245	} else if (!(o instanceof DataFolder)) {
		246	otherDataObjects.add(o);
		247	packagePostfix.put(fo, postfix.replace('/', '.'));
		248	} else {
		249
		250	boolean addDot = !"".equals(postfix);
		251	Collection col = new ArrayList();
		252	for (Enumeration en = ((DataFolder) o).children(); en.hasMoreElements(); col.add(en.nextElement()));
		253
		254	setup(col, postfix +(addDot?".":"") +o.getName());
		255	}
		256	}
183	}	257	}
184		258
185	private FileObject getTargetFile(Resource r) {	259	private String concat(String s1, String s2, String s3) {
186	return target != null \|\| isPackageRename ? target : JavaMetamodel.getManager().getDataObject(r).getFolder().getPrimaryFile();	260	String result = "";
		261	if (s1 != null && !"".equals(s1)) {
		262	result += s1 + ".";
		263	}
		264	result +=s2;
		265	if (s3 != null && !"".equals(s3)) {
		266	result += ("".equals(result)? "" : ".") + s3;
		267	}
		268	return result;
187	}	269	}
188	}	270	}
189		271