I am finally getting to grips with NetBeans and hope to have a fully integrated version of JRefactory in the next few weeks.
After a three month break, I've started development again, I plan to devote one evening a week to JRefactory. Look for a new release in a week or so.
I'm busy adding the new redesigned UML viewer and refactoring action code to the net.sourceforge.jrefactory namespace.
As well as improving the design, I will have cut the number of lines of code by about half, made things more consistent and improved functionality.
All this is taking lots of time and effort, and I don't want to commit until I have a working version significantly better than that in 2.9.11. I also will not be able to spend so much time on it over the next couple of weeks.
For the first time since I took over as maintainer from Chris Seguin I'm looking at the refactoring code, there are I believe quite a number of bugs in it. Its going to take some time to develop test cases for these and then to fix them. There are also many obvious refactorings missing, many of which fit in really well with fixing Coding Standards deficiencies.
The latest releases are looking good, thanks to David Warwick, Alex Harvey and David Bolsover for pointing out bugs.
As stated on the Roadmap at http://jrefactory.sourceforge.net/ I intend to complete the 2.9.x series of releases shortly after j2sdk 1.5 beta is released. As I have no idea how much time I have I'll keep adding features, but mainly in smaller steps so that the builds stay usable.
I have a completely rewritten UML viewer waiting in the wings, but it still does not work to my satisfaction, in particular it does not print properly. I'll gradually add to it annotations and generics, that will probably mean updating the Summary data structures as well.
The second priority is support for IDEs, the jEdit support is almost complete, only refactorings directly from the text are to be added.
Annotations as defined in JSR 175 have been added for parsing and pretty printing.
There are still fairly minor issues with pretty printing annotations, but this is good enough, at least until the final specification is released, as further changes may be required then anyway.
The JSR 175 - "A Metadata Facility for the JavaTM Programming Language" has been released for public review. I will now implement it, which will take a couple of weeks.
In the meantime I've updated the jEdit JavaStyle release to 2.9.3 to fix a few deficiencies in the previous jEdit JavaStyle plugin.
The new Development builds are coming along well, I've fixed several bugs and implemented various requested featues. Also of note are a source code Navigator and a nicer package selector.
The Java Parser is now moved to nav.sourceforge.jrefactory and is built as a separate component (parser-2.9.2.zip). It has been tidied up and should be faster.
There is a new "hacking JRefactory" page on the website, that contains useful information for potential contributors.
The new JRefactory website has now gone live.
The 2.8.9 release will be the final release in the 2.8.x series.
The next release (2.9) will mainly be for bug-fixes.
The 2.8.07 development builds are release candidates, I think there are no major bugs. In a week (Thursday 9th October) I will make them final if no show-stoppers are found.
I may update some of the documentatiion in the meantime, and try and find out why the JBuilder9 plugin does not show up in the JBuilder interface.
The next release (2.9) will mainly be for bug-fixes.
Objective - to be able to detect common design patterns (such as immutable objects, factories, JavaBeans) and classes that nearly obey those patterns (e.g. a class with only one mutator method).
Generate JavaDoc in the pretty-printer for the detected design patterns. Advise on how to transform classes into those that obey the patterns, including the possible refactoring required.
The cut and paste detector (inherited from PMD) does a good job of finding cut and pasted sections of code. But it only works if the tokens are exactly the same.
It would be nice to have a Common Code Detector that finds code segments that are similar (but not identical).
Such common code segments are ripe for refactoring, especially within a class or between classes in a heirarchy.
An added feature would be to create the refactoring required to eliminate the common code.
JSR 163 - JavaTM Platform Profiling Architecture is defining a new profiling architecture to replace JVMPI.
For refactoring it is useful to know where the hotspots in a program are.
The task would be to create a JPPA client to fit into JRefactory and use it to mark classes and methods within the class diagram as regards to processor usage and object creation. Starting and stopping the target program profiling during a run would allow profiling during specific sections of a targets operation. It would be great to include animation of the class diagram (changing colours of the classe & method hotspots as the target runs).
This plugin for jEdit is now available in the development releases as 2.8.03
It should be mostly working, only a few minor bugs and some UI cleanup to do.
I've come across FindBugs http://www.cs.umd.edu/~pugh/java/bugs/ which I will incorporate into JRefactory. It complements the coding standards support of PMD.
So JRefactory 2.8.xx will include the following functionality:
I've factored out only those classes required for the jEdit JavaStyle plugin and will be releasing a JavaStyle-1.5-beta2 soon with all the above features. There are still a few must fix bugs before that can be done however.
I plan to have JavaStyle-1.5-rc1 and the stand-alone JRefactory-2.8-rc1 ready in a couple of weeks. Then work on the plugins for JBuilder9 and NetBeans. The final release in the 2.8.xx series will be about mid October.
The 2.9.xx series will concentrate on better integration between components. Fixing bugs and targeting the 1.5 beta JDK when it becomes available. It will include some metadata support.
The 3.0.xx series will concentrate on additional functionality of the components. Particularly refactoring and metrics. It will be targeted to become final when the 1.5 JDK rc1 is released. I will release plugins for as many IDEs as possible.
The 3.1.xx series will be bugfix only.
The new 2.8.01 release now has most of the features I plan for the 2.8.xx series. I'll concentrate from now on in improving the PMD integration, fixing bugs and enhancement requests.
The latest jEdit JavaStyle plugin is included with this release. It works with jEdit 4.2pre2 or later and when used with the ProjectViewer plugin allows the pretty settings for different projects to be specified separately.
My new computer comes tomorrow, at last I'll have enough disk space for efficient development, 10x processor speed won't harm productivity either :-)
Development will be on hold for a few days while I set up the computer.
After coming back from vacation, I've been concentrating on the parser. I've just committed changes that allow the latest generics spec to be parsed. All of the code in the adding-generics-2.2-ea\src directory parses correctly.
There are still a few regressions in the refactoring code.
Getting a new much faster computer next week, I won't be limited by disk size or processor speed (no longer will I require up to 15 mins to perform the JUnit tests).
This is available from http://www.ladyshot.demon.co.uk/ it includes JDK 1.5 support, UML diagram improvements and many bug fixes, these changes will soon be integrated into CVS.
I've started development on the 2.8.xx seriers of JRefactory. So far I've integrated PMD (working except for XPath rules) programming standard checking and I've fixed a few bugs.
The latest JDK 1.5 spec (version 2.2, Variance is gone, Wildcard is in) is now supported.