theprojecter / flexible-refactoring-tools Goto Github PK

Xi - please commit your code to this repo. That way we can all see what you've 
done. Also be sure to commit often when working on it.

It may sometimes fail to updated the latest version of CompilationUnit.

add Bar.c(); to RefactoringTrial
VVVV
change c() to b()
VVVV
shows incorrect percentage

Here's the CFP.
http://splashcon.org/2011/cfp/105

Feel free to reuse pieces of Emerson's grant proposal.

Download Eclipse and do some different types of refactoring 
(http://en.wikipedia.org/wiki/Code_refactoring). Try them with and without the 
refactoring tools.

Do this just for rename, should actually do refactoring when selected. Should 
be used in screenshot in paper, if possible.

Once a rename is detected, try to rename the variable/field/method by invoking 
the refactoring API.

here's some code that works:

new InlineTempRefactoring(astNode).checkAllConditions(new NullProgressMonitor);

if(!conditions.isOK())
 throw new Exception(conditions.getEntries()[0].getMessage());

r.createChange(progressMonitor).perform(progressMonitor);

Problem marker should have "Finish E.M. Refactoring". Should do refactoring 
when selected. 

Study package should include:
 - Pre-test questinonnaire
 - Post-test questionnaire
 - What's going to happen during the study (maybe experimenter's notebook or directions for participant)
 - Consent form

Anything else that was included in the previous package.

Original code:

public class LittleClass {

    public void method(){
        System.out.println("bloo");
        System.out.println("foo");
    }
}

Next:

public class LittleClass {

    public void method(){
        System.out.println("bloo");
        *cut*
    }
}

Next:

public class LittleClass {

    public void method(){
        System.out.println("bloo");
        System.err.println("foo");
    }
}

Next: 

public class LittleClass {

    public void method(){
        System.out.println("bloo");
        System.err.println("foo");
    }

  public void foo()
}

Then do quick fix to finish the Extract Method. Result:

public class LittleClass {

    public void method(){
        System.out.println("bloo");
        foo();
    }

  public void foo(){
        System.err.println("foo");
  }
}

Expected result:


public class LittleClass {

    public void method(){
        System.out.println("bloo");
        System.err.println("foo");
        foo();
    }

  public void foo(){
        System.err.println("foo");
  }
}

new feature:
1. After extracting method, users can edit the method name at the invocation 
and the declaration simultaneously.
2. place to look at: package org.eclipse.jface.text.link.LinkedPositionGroup

The refactoring has two steps, undoing changes then doing the refactoring. 
Between these two steps, the code is shown in the editor. I think only the 
final code should be shown.

So the tricky issue is figuring out which existing errors correspond to the 
refactoring I'm trying to do. Two approaches:
1) Keep track of the number of Problem Markers at all times. If the number of 
errors increased in response to my refactoring change, then the new Problem 
Markers must be due to my refactoring. Add Quick Fixes to just those Problem 
Markers.
2) All Problem Markers that occur on lines for which that line was changed as 
part of my refactoring, add Quick Fixes to those Problem Markers.

In the case where there is no Problem Markers associated with my refactoring 
(e.g., Extract Method most of the time), add a new Marker with a refactoring 
icon (R).

Extract Method now only works for cut, etc. Should work for all workflows 
observed in empirical study.

The rename refactoring API is usually applied to the current program. We need 
it to apply to an old AST that we have stored in memory. Please create an 
example snippet that does that.

By study, we mean both in the survey and also in the Benefactor's 
implementation, We currently decides the following eight:
1. Introduce Parameter
2. Extract Constant
3. Move 
4. Rename 
5. Inline
6. Extract Local Variable
7. Change Method Signature
8. Extract Method
A subset of six may be chosen from the eight. This list is tentative.

I sent Quinton an old IRB study application. Read through it -- your study 
materials will likely look similar. Please change the status of this issue to 
"Done" when complete (and do this for future assigned issues as well).

Does it do something close to what we're doing?

Xi will get Suprit the VS2010 CD.

Moving static field is not successful when the field declaration has assignment.

int i = 0;
i++;
i++;

VVVVVVVVVVVVVVV

int i = 0;
j++;
i++;

---------------

This change not detected as rename refactoring. It should be.

Use the "undo" strategy.
1) Store non-refactoring changes.
2) Go back before the refactoring was applied.
3) Use the tool to apply the refactoring.
4) Re-apply the non-refactoring changes.

For rename and extract method.

The refactoring icon shows up whenever you start refactoring. It should be 
removed (at least for now) under one of two conditions:

1) if another refactoring happens later (e.g., only one icon shown at any time)
2) if the user completes the refactoring (that is, 100% of refactoring done)

class Foo{
 static void f(){f()}
}

class Bar{
 void x(){Foo.f()}
}

VVVVVVVVVVVVVVVVVVVVV

class Foo{
 static void f(){f()}
}

class Bar{
 void x(){Foo.z()}   (33%)
}

VVVVVVVVVVVVVVVVVVVVV

class Foo{
 static void f(){z()}
}

class Bar{
 void x(){Foo.z()}   (66%)
}

VVVVVVVVVVVVVVVVVVVV

class Foo{
 static void z(){z()}
}

class Bar{
 void x(){Foo.z()}   (100%)
}

Should work for variables and methods.

Xi can detect different types of refactorings (he will that commit code soon). 
Rather than printing to the console (as it does now), please show a standard 
Eclipse QuickFix that is labeled by the type of rename refactoring detected. 
The quickfix doesn't have to do anything at this point.

We've already got an icon for "I noticed you maybe did a refactoring. Now we 
need a "quick fix" icon for each one. The whole iconset should be consistent, 
but each refactoring should be different.

This task is to create small images. We'll integrate it into the plugins later.

Renaming local variable is not successful when its declaration has assignment.

BeneFactor is now not working on large-scale project because retrieving names 
in all of the files in the project consumes a long time. Change a strategy, 
maybe find reference utility. 

Update Xi's document about ways of manual refactoring:

http://code.google.com/p/flexible-refactoring-tools/wiki/PageName?ts=1304597895

Some of these are missing descriptions (e.g., infer generic type arguments). 
Some are overloaded ("inline" should be expanded into "inline method" and 
"inline local variable"). Some have multiple methods of manual refactoring; 
those methods should be added.

Assigning to Suprit. Moin and Xi, please assist.

There are some thread sleeps like so:
Thread.sleep(WAIT_TIME);

Remove them and replace with a more elegant solution.

If you rename the second var, the first one is renamed with benefactor:

public class LittleClass {

    public void m1(){
        int i = 0;
    }

    public void m2(){
        int i = 0;//rename this one
    }
}

Move a constant from one class to another. This is interesting because classes 
are typically in different editors.

cross files renaming method is not successful.

Paper needs to be written. Not a small task.

When user starts EM refactoring, she puts in important data:

/*
 * My comment
 */
public void foo(String s, String p_){

}

Make sure that this information is captured. For now, just print it to console. 
In the future, use it as input to refactoring tool.

Important information to capture:
1) name of method
2) name of a parameters
3) order of parameters
4) visibility of method
5) comment added
6) position of method (what point in class it was inserted into)

Right now, we only look back 1 AST to see if there was a rename. Look back as 
many as needed.

For example:

x = 1 -> y = 1
gets detected now

x = 1 -> = 1 -> y = 1
does not get detected. Fix this bug.

Also:

x = 1 -> y = 1 -> yam = 1

More complicated case (if easy fix):

x = 1;
System.out.println(x);

VVVVVVVVV

y = 1;
System.out.println(x);

VVVVVVVVV

y = 1;
System.out.println(y);
System.out.println(x);

VVVVVVVVV

y = 1;
System.out.println(y);
System.out.println(y);

Does IDEA support half-refactorings?

If there are 10 variable references, and X of them has been changed to the new 
name, then print X/10.

Once NCSU grants you the permissions, please create a new VCL image 
(http://vcl.ncsu.edu/faq?q=node/145).

Software to load it with:
- Eclipse
- Some open source software downloaded from the web to use in Eclipse (say, 
Vuze http://wiki.vuze.com/w/Using_Eclipse#Import_Vuze_source_code)
- CamStudio
- SharedView (http://connect.microsoft.com/site94)

Please submit your suggestions for a new name here.

When users are changing the names, they have to type fast to get BeneFactor 
work correctly. 

Create two sets of files:
Set 1: Keep the whole file that was changed, where name of file is timestamp
Set 2: Keep just the changed part, also file name time stamp

If files happen to have same timestamp, then add character to end.

I sent Quinton the project proposal. Please read it over, and ask me questions 
about it at our next meeting.

1. Go through each manual refactoring on the wiki page.
2. Below each one, write down (in a different color):

(a) At what point(s) would would you detect when a refactoring is happening (if 
any)

Example Extract Method:

 p1 - cuts statements
 p2 - create a new method
 p3 - paste in the thing they cut into the method
 p4 - ... 

(b) At each point, how clear is it that the person is really doing a 
refactoring?

Continuing example:

 p1 - 50%
 p2 - 60%
 p3 - 80%
 ...

When you cut the single statement from the following code, there's no quick fix 
shown:

public class LittleClass {
    public static void main(String[] args) {
        int i = 1;
    }
}

When the developer cuts 1..n statements, automatically invoke the extract 
method tool on what was cut.

If you want to get fancy, you can wait for the person to paste the statements 
in the class, then put the extracted method where they pasted.

void foo(int i){
 i++;
}

VVVVVVVVVVVVVV

Select "i++"
Cut "i++"

VVVVVVVVVVVVVV

void foo(int i){

}

<refactoring is detected>
<automatic refactoring is performed>

VVVVVVVVVVVVV

void foo(int i){
  bar(i);
}

void bar(int i){
  i++;
}