I would like to share with you a little screencast I’ve done showing how NAnt executes Gendarme.

Enjoy!

PS.- Thanks to Garuma for his post about Quick and Dirty solution for the wordpress posts!!

It still needs a bit of autotools love, but enjoy the screenshot

I will start by the beginning

There are new rules:

• Avoid Calling Problematic Methods [IN TRUNK]
• Attribute String Literals Should Parse Correctly [IN TRUNK]
• Provide Correct Arguments To Formatting Methods [IN TRUNK]
• Declare Event Handlers Correctly
• Instantiate Argument Exception Correctly [IN TRUNK]
• Call Base Methods On ISerializable Types [IN TRUNK]
• Implement ISerializable Correctly [IN TRUNK]
• Mark All NonSerializable Fields [IN TRUNK]

There are 7 new rules in the SVN and the other is in the mono-soc-2008 svn, because I want review it in order to avoid false positives and commit code that works Almost of them, are rules which deals with the implementation and I think they are more useful to the other mono developers.

In the second place, I should say something about the reporter.

The reporter is a tool which takes the gendarme reports, in xml format. The report is passed to a pipeline (you can write your own!) and the pipeline applies some actions (you can write your owns too!) to the input and the input is transformed to other documents. Let me show you an example:

You runs gendarme against the corlib, then a report file is generated. You take the reporter and can generate a master index report or you can filter the defects per severity or …

And in the third place, I automated the report generation and publication with a little bash script (which needs a bit more of love). The script runs gendarme, and pass the output to the report and I publish the results (more or less) frequently, and you can see a little example in: The classlib and the tools. It’s a great chance for the newcomers for getting involved in the mono development

And this week is the Novell’s Hack Week, and I hope get some time in order to talk and code with Sebastien, and I’m sure we will have more cool news

Hope you like all the news!

• Gendarme has reached the 0.2 release. You can read the release notes if you want more information.
• I have passed the mid-term evaluation and I will continue adding rules, fixes, trimming down false positives …
• I’m generating with more or less frequence, some gendarme reports applied to the base class library and for other mono tools. This help me (I hope others too) for write new rules and for trimming down false positives. When I start to publish them daily I will put the link here

Let me talk a little about me, my name is Néstor Salceda and I’m studying Computer Science and, perhaps, someone will known me yet because this is my second year as student in the Summer of Code, the first year was wonderful and I decided apply other time

This year, my goal is to enhace Gendarme in order to be more useful to the Mono Project itself. For achieving this goal I have identified 4 key tasks:

• Apply the existing rules.
• Write new rules, putting special effort in write useful rules for implementing the class libraries.
• Apply the new rules to the class libraries.
• Automated Gendarme Reports generation and publication.

And finally, good luck for all students, and thanks to Mono Project for the opportunity

Also give a big thank to all people that was yesterday in the IRC with us (you rocks dudes!). Thanks for your time, thanks for your ideas, thanks for your presence, thanks for the thanks, thanks for the laughings … thanks for all.

Numbers:

In this edition, if my review doesn’t fail, we have 10 more rules and 3 nice enhacements to existing rules. And a lot of new ideas for great features. And also we have new friends and 2 new rule makers: Cedric Vivier and Andrés.

Next steps:

Well, by myself, I should start finishing several tasks I had started in the past:

• Gendarme and NAnt integration
• Message Chains Smell
• A new way to express custom parameters to the rules in the XML file

And for finishing, I’m proud of being part of the Gendarme Team, thanks mates for the reminders, thanks for your help planning, giving nice tips, staying there and writting new rules. All I can to say is that we can’t stop rocking

• If you have a nice idea for a rule which you’d like to write or discuss.
• Or if you don’t have a specific idea but you’d like to try Gendarme and write a new rule.
• Or if you’d like improve an existing rule.
• Or if you want to learn more about Gendarme ecosystem or Gendarme developer’s and fans …

Please join us April 26th in the #gendarme IRC channel (in irc.gimp.org) for an interactive, collaborative and intense rule writing effort.

We will be there with you!

I decided spent some time on integration tasks with others applications (NAnt, XBuild, CC.NET …) You can read the thread on Gendarme Google Group. And I started writting a Gendarme Task for NAnt.

By the moment, as I can’t capture all in an screenshot, you can see it in action in a screencast: Gendarme and NAnt

Note that it’s only a prototype, and is under heavy development and it’s far away to be a usable stuff (by the moment).

• Make simpler write rules, and easier to understand.
• Make rules uniform, reduce code duplication, easy testing.

These topics are a bit abstract and is a hard task get it completed. But I believe this is the first step for achieve these topics.

The main problem when we are writting new rules, is the code duplication. There are several things we should prepare before write the rule logic. By example, when a rule is applied? We have a lot of scenarios before appliying the rule, if the method is anonymous doesn’t make sense check about the naming conventions, or if a rule must check only the setters. And is always the same code, repeated one time, other time, another time …

It’s easy to understand that this code should be extracted to other class but, where should we put this code? The first impression was create static helpers classes, then you can get this code in the rules:


public MessageCollection CheckMethod (...)
{
if (!MethodHelpers.IsSetter (method))
return runner.RuleSuccess;
//Imagine more rule logic
}


It’s okey, but if we use static classes with static methods and thinking a bit … Eureka! We can use extension methods to Cecil types, following the JB’s Mono.Rocks, and the rules looks like:


public MessageCollection CheckMethod (...)
{
if (!method.IsSetter ())
return runner.RuleSuccess;
//Imagine more rule logic
}


Beautiful code, isn’t it?

Then, Sebastien and GHOP participants (Daniel Abramov, Adrian Tsai and Andreas Noever) implemented some of these Rocks (Good work guys !). The Rocks have unit tests and documentation, and we can use it for concentrate our effort writting more complete rules (click the image for a bigger size).

Finally, as all people loves screenshots, this is one screenshot of Monodoc showing the rocks documentation:

The first day, I was really excited and a bit nervous because I didn’t know anyone, but quickly I found Sebastien and JB and I sat by them (thanks you for all guys!) and we started talking, and hacking.

I also can see other people from the Mono-Hispano community (Andres, Carlos, Juan Ramon …) but I missed Marcos a mate from the GSoC, I didn’t meet you, but I hope the next time we will meet.

All talks also was really interesting: MonoDevelop, NUnit, Boo, Db4o, C# 3.0, Moonlight, Build Service, Boxerp, Debugger …

Summarizing, the best: all the people. Thanks you very much!

Finally the last day, we discussed the new features for the next Gendarme release, you can see it here. There are some killer features and a lot of new ideas.