Refactoring is a disciplined technique for restructuring an existing body of code, altering its internal structure without changing its external behavior. Its heart is a series of small behavior preserving transformations. Each transformation (called a ‘refactoring’) does little, but a sequence of transformations can produce a significant restructuring. Since each refactoring is small, it’s less likely to go wrong. The system is also kept fully working after each small refactoring, reducing the chances that a system can get seriously broken during the restructuring.  — Martin Fowler  http://www.refactoring.com/

In other words, refactoring is making your code cleaner, safer, and easier to use. Understand can be a very powerful tool in your re-factoring arsenal. Here are a few ways you can use Understand in your refactoring process.

Quickly Identify References

In the long list of refactorings, many of the suggested refactorings involve replacing one data type with another. In many cases that can involve changing the calls to that data type as well. Understand can instantly show you everywhere that that entity is used, called, referenced, modified or typed. Just right click on the entity, select View Information, and expand the references section.

Identify Complex Functions

Many overly-complex functions can be refactored into smaller, more maintainable units. Knowing the McCabe Cyclomatic complexity can help you quickly identify functions and methods that are overly complicated and may be good candidates for refactoring. You can quickly find the complexity of every function in an Understand project by selecting Metrics –> Export Metrics. If you’re just looking for a quick list of complex functions, this plugin will show you the most complex functions in your project.

Download it from our Plugin page and you’ll see a list of the most complex functions in your project.

Reformat your code

If you have ugly code, you can beautify it quickly with the the tip reported in this entry:

Tip – Beautify your code

With one button press, turn a file that looks like this:

into this:

Rename Entities

Sometimes renaming an entity can go a long way towards making the code readable, perhaps a missed name class or method.

Download rename.zip for a user tool to quickly rename entities in Understand – it goes through the references and replaces each instance of the class or object with the new name.

Save the .pl script to your hard drive, and then in Understand under Tools | User Tools| Configure select Import to load the .ini file. Change the path to the location of the .pl file. Then to use it, right click on any entity in Understand and select User Tools | Replace. You’ll be prompted for the new text, and then all references to that entity will be renamed. You’ll want to reparse the changed files after each rename so that the database stays up to date (Ctrl+R by default).

Follow Dependencies

Understand’s new Dependency features can help you to quickly get a handle on what parts of the code are dependant on other parts of the code, letting you define what logical lines to divide your code into. Dependency Browser Dependency Graphs Exporting Dependencies

So you can quickly turn this:

Into this:

We plan on implementing astyle into the editor at some point in the future, but I’m not so patient, and I decided to use our plugin mechanism to do it now, and will show you how.

There are two ways to run astyle from inside Understand, as an Interactive Report plugin, or as a custom user tool. Either way, first you’ll need to install or build astyle you can download it from here.

Interactive Report

The Interactive report integrates directly with the file context menu in Understand. Download the plugin from here(right click and save as). To install it, just move the file to SciTools\conf\plugin\User\IReport\ and restart Understand.
To run the plugin, right click on a File, select Interactive Reports and Beautify

At which point you’ll be presented with the options window:

The first field is pretty straight forward, just navigate to where the astyle executable is installed.

The rest of the dialog may seem overwhelming, but the tricky part is figuring out what your “style” is. Astyle has 5 predefined styles, and chances are that one of them will be pretty close to what you like.

Astyle’s documentation goes into more detail about each of these styles, but here is a rough overview:

namespace foospace
{
int Foo()
{
if (isBar)
{
bar();
return 1;
}
else
return 0;
}
}

namespace foospace
{
int Foo()
{
if (isBar)
{
bar();
return 1;
}
else
return 0;
}
}

namespace foospace {
int Foo() {
if (isBar) {
bar();
return 1;
} else
return 0;
}
}

namespace foospace
{
int Foo()
{
if (isBar) {
bar();
return 1;
} else
return 0;
}
}

class foospace {
int Foo() {
if (isBar) {
bar();
return 1;
} else
return 0;
}
}

If one of these appeals to you as is, just select it from the “Predefined Style” section. If you want to modify one, select it and the other options in the dialog will allow you to override the default settings for a style. For more details about what the command does, select “Display the help text” in the Action section:

When you are ready to run it, you can either preview the changes in a separate window, or apply them directly to the source code. Of course I would suggest previewing the changes until you figure out exactly what your style is. Note that if your project uses relative paths or named roots, only the preview will work right now since the file naming is different, but you can still copy and paste

User Tool

If you already know what astyle command line options you want to use, you can setup a user tool  to quickly transform a file. Again, this only works for projects with absolute paths.

So here are the command line options I want to use with astyle:

astyle –style=ansi -t -B -w

To implement these as a user tool, I select Tools | User Tools | Configure

Then I create a new tool. I name it and provide the path to the astyle executable. Then I provide the parameters. The lipstick icon is optional

I also decided to bind this to a keyboard shortcut (Ctrl Shift B). You can set the keyboard shortcuts in Tool | Options | Key Bindings.

Now if I run into an ugly file, I can just hit Ctrl Shift B, and bam, pretty code!