CSC/ECE 517 Fall 2009/wiki 1a 9b SJ: Difference between revisions

From Expertiza_Wiki
Jump to navigation Jump to search
 
(53 intermediate revisions by the same user not shown)
Line 1: Line 1:
'''Refactoring tools for Ruby and Ruby on Rails.'''
== What is Code Refactoring ==
== What is Code Refactoring ==


Line 5: Line 7:
=== Motivation of Refactoring ===
=== Motivation of Refactoring ===


Refactoring is very useful for software engineer to maintain the quality of their code in different environment. In fact, no software can be guaranteed to be perfect when it is first developed. Usually when the source code is applied to different customer needs, we want to improve the inner-structure without modify the external behavior. The ability to refactor your code takes the pressure off the design phase of software development. Refactoring gives you the ability to change the design of the code at a later stage. This means that you don’t have to get the design absolutely right before you write any code. You can get a rough design worked out, code it up and then if (when) you spot a better design you can refactor your code towards the better design.
Refactoring is very useful for software engineer to maintain the quality of their code in different environment. In fact, no software can be guaranteed to be perfect when it is first developed. Usually when the source code is applied to different customer needs, we want to improve the inner-structure without modify the external behavior. The ability to refactor your code takes the pressure off the design phase of software development. Refactoring gives you the ability to change the design of the code at a later stage. This means that you don’t have to get the design absolutely right before you write any code. You can get a rough design worked out, code it up and then if (when) you spot a better design you can refactor your code towards the better design.


=== List of Common Refactorings ===
=== List of Common Refactorings ===
Line 43: Line 45:
=== Ruby Example of Refactoring ===
=== Ruby Example of Refactoring ===


before rename:
*Before Rename:
 
<pre>
def badRenameMethod
def badRenameMethod
     puts("Hello World");
     puts("Hello World");
end
end
</pre>


after rename:
*After Rename:
 
<pre>
def hello
def hello
     puts("Hello World");
     puts("Hello World");
end
end
</pre>


before encapsulation:
*Before Encapsulation:
<pre>
class SomeClass
class SomeClass
     def initialize
     def initialize
         @field = 0;
         @field = 0;
     end
     end
end
end
 
</pre>
after encapsulation:


class SomeClass                 
*After Encapsulation:
<pre>
class SomeClass                 
     def initialize
     def initialize
         @field = 0;
         @field = 0;
Line 79: Line 84:
     end
     end
     private :field=
     private :field=
end
end
</pre>


=== Java Example of Refactoring ===
=== Java Example of Refactoring ===


before rename:
*Before Rename:
 
<pre>
public class rename_method
public class rename_method
{
{
     static void badRenameMethod()
     static void badRenameMethod()
     {
     {
         System.out.println("Hello, world!");
         System.out.println("Hello, world!");
     }
     }
}
}
</pre>


after rename:
*After Rename:
 
<pre>
public class rename_method
public class rename_method
{
{
     static void hello()
     static void hello()
     {
     {
         System.out.println("Hello, world!");
         System.out.println("Hello, world!");
     }
     }
}
}
</pre>


 
*Before Encapsulation:
before encapsulation:
<pre>
 
public class encap_field
public class encap_field
{
{
     public String field;
     public String field;
}
}
 
</pre>
after encapsulation:


public class encap_field
*After Encapsulation:
{
<pre>
public class encap_field
{
     private int field;
     private int field;


Line 126: Line 134:
         return field;
         return field;
     }
     }
}
}
</pre>


== Refactoring support for Current Ruby IDE ==
== Refactoring support for Current Ruby IDE ==
Line 134: Line 143:
  | Current Ruby IDE || Refactoring Support (Y/N)
  | Current Ruby IDE || Refactoring Support (Y/N)
|-
|-
  | ActiveState Komodo || N
  | [http://www.activestate.com/komodo/ ActiveState Komodo] || N
  |-  
  |-  
  | NetBeans || N
  | [http://www.netbeans.org/ NetBeans] || N
  |-
  |-
  | Arachno Ruby || N
  | [http://www.ruby-ide.com/ruby/ruby_ide_and_ruby_editor.php Arachno Ruby] || N
|-
|-
  | FreeRIDE || N
  | [http://freeride.rubyforge.org/wiki/wiki.pl FreeRIDE] || N
|-
|-
  | Mondrian Ruby IDE || N
  | [http://www.mondrian-ide.com/ Mondrian Ruby IDE] || N
|-
|-
  | Ruby in Steel || N
  | [http://www.sapphiresteel.com/ Ruby in Steel] || N
|-
|-
  | RubyMine || Y
  | [http://www.jetbrains.com/ruby/index.html RubyMine] || Y
|-
|-
  | Eclipse (Aptana) || Y   
  | [http://www.eclipse.org/ Eclipse] ([http://aptana.com/ Aptana]) || Y   
  |}
  |}


Line 154: Line 163:
Here the renaming of the method "badRenameMethod" to "Hello" is illustrated for Ruby.  The source code is shown in section 1.3.
Here the renaming of the method "badRenameMethod" to "Hello" is illustrated for Ruby.  The source code is shown in section 1.3.
{|
{|
| [[Image:r00.jpg|thumb|upright|alt= rename step 1]]
| [[Image:r00.jpg|thumb|upright|The badly named method "badRenameMethod is shown with a call to this method.]]
| [[Image:r01.jpg|thumb|upright|alt= rename step 2]]
| [[Image:r01.jpg|thumb|upright|The method is highlighted and then right clicked on.  Refactor then Rename is selected.]]
| [[Image:r02.jpg|thumb|upright|alt= rename step 3]]
| [[Image:r02.jpg|thumb|upright|The method is renamed to "hello"]]
| [[Image:r03.jpg|thumb|upright|alt= rename step 4]]
| [[Image:r03.jpg|thumb|upright|A preview of each call to the method.]]
| [[Image:r04.jpg|thumb|upright|alt= rename step 5]]
| [[Image:r04.jpg|thumb|upright|The resulting code after refactoring is shown with newly renamed method.]]
|}
|}


Here the encapsulation of the field "field" is illustrated for Ruby.  The source code is show in section 1.3.
Here the encapsulation of the field "field" is illustrated for Ruby.  The source code is show in section 1.3.
{|
{|
| [[Image:r05.jpg|thumb|upright|alt= encapsulation step 1]]
| [[Image:r05.jpg|thumb|upright|The field to be encapsulated is shown inside its class.]]
| [[Image:r06.jpg|thumb|upright|alt= encapsulation step 2]]
| [[Image:r06.jpg|thumb|upright|The field is highlighted and then right clicked on.  Refactor then Encapsulate Field is selected.]]
| [[Image:r07.jpg|thumb|upright|alt= encapsulation step 3]]
| [[Image:r07.jpg|thumb|upright|A reader and writer method is selected to be generated and labeled private.]]
| [[Image:r08.jpg|thumb|upright|alt= encapsulation step 4]]
| [[Image:r08.jpg|thumb|upright|A preview of the encapsulation.]]
| [[Image:r09.jpg|thumb|upright|alt= encapsulation step 5]]
| [[Image:r09.jpg|thumb|upright|The resulting code after refactoring is shown with encapsulated field.]]
|}
|}


Line 174: Line 183:


{|
{|
| [[Image:j00.jpg|thumb|upright|alt= rename step 1]]
| [[Image:j00.jpg|thumb|upright|The badly named method "badRenameMethod is shown.]]
| [[Image:j01.jpg|thumb|upright|alt= rename step 2]]
| [[Image:j01.jpg|thumb|upright|The badly named method is called.]]
| [[Image:j02.jpg|thumb|upright|alt= rename step 3]]
| [[Image:j02.jpg|thumb|upright|The method is highlighted and then right clicked on.  Refactor then Rename is selected.]]
| [[Image:j03.jpg|thumb|upright|alt= rename step 4]]
| [[Image:j03.jpg|thumb|upright|The method is renamed to "hello" as shown and preview is selected.]]
| [[Image:j04.jpg|thumb|upright|alt= rename step 5]]
| [[Image:j04.jpg|thumb|upright|A preview of each call to the method.]]
| [[Image:j05.jpg|thumb|upright|alt= rename step 6]]
| [[Image:j05.jpg|thumb|upright|The resulting code after refactoring is shown with newly renamed method.  The call is shown here.]]
|}
|}
Here the encapsulation of the field "field" is illustrated for Java. The source code is show in section 1.4.
Here the encapsulation of the field "field" is illustrated for Java. The source code is show in section 1.4.
   
   
{|
{|
| [[Image:j06.jpg|thumb|upright|alt= encapsulation step 1]]
| [[Image:j06.jpg|thumb|upright|The field to be encapsulated is shown inside its class.]]
| [[Image:j07.jpg|thumb|upright|alt= encapsulation step 2]]
| [[Image:j07.jpg|thumb|upright|The field is highlighted and then right clicked on.  Refactor then Encapsulate Field is selected.]]
| [[Image:j08.jpg|thumb|upright|alt= encapsulation step 3]]
| [[Image:j08.jpg|thumb|upright|A getter(reader) and setter(writer) mehtod is selected and named.]]
| [[Image:j09.jpg|thumb|upright|alt= encapsulation step 4]]
| [[Image:j09.jpg|thumb|upright|The resulting code after refactoring is shown with encapsulated field.]]
|}
|}


Line 197: Line 206:


{|
{|
|1. Refactoring Options for Java in Eclipse  ||||  2. Refactoring Options in Eclipse for Ruby
|'''Refactoring Options for Java in Eclipse''' ||||  '''Refactoring Options for Ruby in Eclipse'''
|-
|-
|Rename  || || Rename
|Rename  || || Rename
Line 244: Line 253:
|}
|}


=== Ease of Use and IDE Integtation ===
=== Ease of Use and Integrated Develop Environment(IDE) Integration ===


The refactoring options for Ruby and Java cover all the basic refactorings.  The differences in the number of options mainly come from the difference in the two languages. Ruby is a dynamically typed language, has unbounded polymorphism, and all classes are open to extension.  On the other hand, Java is a statically typed language, polymorphism is mainly implemented via interfaces and inheritance, and classes cannot be extended at run-time.  The given examples (in section 1.3, 1.4) illustrate the ease of use of the refactoring tools for both Ruby and Java and how well these tools are integrated into the Eclipse IDE.
The refactoring options for Ruby and Java cover all the basic refactorings.  The differences in the number of options mainly come from the difference in the two languages. Ruby is a [http://en.wikipedia.org/wiki/Type_system#Dynamic_typing dynamically typed language], has unbounded [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism], and all classes are open to extension or can be inherited.  On the other hand, Java is a [http://en.wikipedia.org/wiki/Type_system#Static_typing statically typed language], polymorphism is mainly implemented via [http://en.wikipedia.org/wiki/Interface_%28computer_science%29 interfaces] and [http://en.wikipedia.org/wiki/Implementation_inheritance inheritance], and classes cannot be extended at run-time.  The given examples (in section [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki_1a_9b_SJ#Ruby_Example_of_Refactoring [1.3]], [http://pg-server.csc.ncsu.edu/mediawiki/index.php/CSC/ECE_517_Fall_2009/wiki_1a_9b_SJ#Java_Example_of_Refactoring [1.4]]) illustrate the ease of use of the refactoring tools for both Ruby and Java and how well these tools are integrated into the Eclipse IDE.


== References ==
== References ==

Latest revision as of 23:22, 16 September 2009

Refactoring tools for Ruby and Ruby on Rails.

What is Code Refactoring

According to the famous book "Refactoring: Improving the Design of Existing Code " by Martin Fowler: [5], refactoring is the process of applying behavior-preserving transformations to a program with the objective of improving the program’s design. Intuitively people refer to code refactoring as "cleaning it up."

Motivation of Refactoring

Refactoring is very useful for software engineer to maintain the quality of their code in different environment. In fact, no software can be guaranteed to be perfect when it is first developed. Usually when the source code is applied to different customer needs, we want to improve the inner-structure without modify the external behavior. The ability to refactor your code takes the pressure off the design phase of software development. Refactoring gives you the ability to change the design of the code at a later stage. This means that you don’t have to get the design absolutely right before you write any code. You can get a rough design worked out, code it up and then if (when) you spot a better design you can refactor your code towards the better design.

List of Common Refactorings

In the following we list some popular refactoring to specify how refactoring transform the code. For more detail information, the reader please refer to the section 2.1.2 of the thesis of Thomas Corbat [1]. [1] provide Ruby example for each refactoring this list.

1. Merge Class Parts
2. Convert Local Variable to Field
3. Encapsulate Field
4. Extract Method
5. Inline Class
6. Inline Method
7. Move Field
8. Move Method
9. Rename Class
10. Rename Field
11. Rename Local Variable
12. Rename Method
13. Replace Temporary Variable with Query
14. Split Temporary Variable

Ruby Example of Refactoring

  • Before Rename:
def badRenameMethod
    puts("Hello World");
end
  • After Rename:
def hello
    puts("Hello World");
end
  • Before Encapsulation:
class SomeClass
    def initialize
        @field = 0;
    end
end
  • After Encapsulation:
class SomeClass                
    def initialize
        @field = 0;
    end
    
    def field
        @field
    end
    private :field
    
    def field= field
        @field = field
    end
    private :field=
end

Java Example of Refactoring

  • Before Rename:
public class rename_method
{
    static void badRenameMethod()
    {
        System.out.println("Hello, world!");
    }
}
  • After Rename:
public class rename_method
{
    static void hello()
    {
        System.out.println("Hello, world!");
    }
}
  • Before Encapsulation:
public class encap_field
{
    public String field;
}
  • After Encapsulation:
public class encap_field
{
    private int field;

    public void setField(int field)
    {
        this.field = field;
    }

    public int getField()
    {
        return field;
    }
}

Refactoring support for Current Ruby IDE

This the following table we summary the current ruby IDE and their refactoring support situation.

Current Ruby IDE Refactoring Support (Y/N)
ActiveState Komodo N
NetBeans N
Arachno Ruby N
FreeRIDE N
Mondrian Ruby IDE N
Ruby in Steel N
RubyMine Y
Eclipse (Aptana) Y

Example of Using Ruby Refactoring Tools in Eclipse

Here the renaming of the method "badRenameMethod" to "Hello" is illustrated for Ruby. The source code is shown in section 1.3.

The badly named method "badRenameMethod is shown with a call to this method.
The method is highlighted and then right clicked on. Refactor then Rename is selected.
The method is renamed to "hello"
A preview of each call to the method.
The resulting code after refactoring is shown with newly renamed method.

Here the encapsulation of the field "field" is illustrated for Ruby. The source code is show in section 1.3.

The field to be encapsulated is shown inside its class.
The field is highlighted and then right clicked on. Refactor then Encapsulate Field is selected.
A reader and writer method is selected to be generated and labeled private.
A preview of the encapsulation.
The resulting code after refactoring is shown with encapsulated field.

Example of Using Java Refactoring Tools in Eclipse

Here the renaming of the method "badRenameMethod" to "Hello" is illustrated for Java. The source code is show in section 1.4.

The badly named method "badRenameMethod is shown.
The badly named method is called.
The method is highlighted and then right clicked on. Refactor then Rename is selected.
The method is renamed to "hello" as shown and preview is selected.
A preview of each call to the method.
The resulting code after refactoring is shown with newly renamed method. The call is shown here.

Here the encapsulation of the field "field" is illustrated for Java. The source code is show in section 1.4.

The field to be encapsulated is shown inside its class.
The field is highlighted and then right clicked on. Refactor then Encapsulate Field is selected.
A getter(reader) and setter(writer) mehtod is selected and named.
The resulting code after refactoring is shown with encapsulated field.

Comparison of Ruby and Java Refactoring Tools

Comprehensiveness

These are the following refactoring options available in eclipse for Ruby and Java.

Refactoring Options for Java in Eclipse Refactoring Options for Ruby in Eclipse
Rename Rename
Move Move
Change Method Signature Merge Class Parts in File
Extract Local Variable Pull Up
Extract Constant Pull Down
Inline Merge With External Class Parts
Convert Anonymous Class to Nested Split Local Variable
Convert Member to Top Level Merge With External Class Parts
Convert Local Variable to Field Inline
Extract Super Class Extract Constant
Extract Interface Encapsulate Field
Extract Class Convert Local Variable to Field
Use Supertype where possible
Pull Up
Pull Down
Introduce Parameter Object
Introduce Indirection
Introduce Factory
Introduce Parameter
Encapsulate Field
Generalize Declared Type
Infer Generic Type Arguments

Ease of Use and Integrated Develop Environment(IDE) Integration

The refactoring options for Ruby and Java cover all the basic refactorings. The differences in the number of options mainly come from the difference in the two languages. Ruby is a dynamically typed language, has unbounded polymorphism, and all classes are open to extension or can be inherited. On the other hand, Java is a statically typed language, polymorphism is mainly implemented via interfaces and inheritance, and classes cannot be extended at run-time. The given examples (in section [1.3], [1.4]) illustrate the ease of use of the refactoring tools for both Ruby and Java and how well these tools are integrated into the Eclipse IDE.

References

[1] Thomas Corbat, Lukas Felber, Mirko Stocker Refactoring Support for the Eclipse Ruby Development Tools, Diploma Thesis, HSR University of Applied Sciences Rapperswil Institute for Software.

[2] Code Refactoring Wiki, http://en.wikipedia.org/wiki/Code_refactoring.

[3] The First Workshop on Refactoring, https://netfiles.uiuc.edu/dig/RefactoringWorkshop

[4] Refactoring Tutorial for Ruby on Rails, http://www.good-tutorials.com/tutorials/ruby-on-rails/refactoring

[5] Martin Fowler Refactoring: Improving the Design of Existing Code