Creating Netbeans Ruby Hints with Scala, Part 1

In this post I'm going to show a little experiment of creating a Netbeans Ruby Hint using the Scala language. This is the first of a two-part series of posts on this topic.

Netbeans Ruby Hints and Quick Fixes is a very nice feature that will be part of Netbeans 6.0 Ruby integration. This feature can be used to identify potential problems or to promote best practices in Ruby programs. I first learned about it by reading Tor Norbye's blog.

I really like the idea of mixing languages to accomplish something. This is the main reason I chose Scala to do this experiment. Also I wanted to try to apply some ideas from previous posts. For a future experiment it will be very nice to write this code using JRuby.

For this post I'm using Netbeans 6.0 Beta 2. As described below the APIs for writing hints are still not officially public because they're still under development. Again, as with previous posts, this is only an experiment to see how different programming languages could be used solve special tasks.

Motivation

Several weeks ago I wrote a post on Ruby's yield statement, there I showed a function that calculates the Fibonacci sequence using a while statement in a pretty traditional way. Then someone posted a comment with a much compact version of it by using some nice Ruby features. That got me thinking how Netbeans Ruby Hints could also be used to help Ruby beginners(like me) to find out about alternative ways to do something.

The Hint

One of the things I like about Ruby is statement modifiers. That's one of the first things you notice while reading the Why's (Poignant) Guide to Ruby.

I think statement modifiers makes the code look nice if used carefully.

So the hint that will be implement it's going to identify opportunities to apply the if or unless statement modifiers. For example:

table = Hash.new
...
if table.empty? then
   puts "No items" 
end
...

Could also be written as:

table = Hash.new
...
puts "No items" if table.empty?
...

Creating the Netbeans module

The biggest challenge I had was to create a Netbeans module using only Scala. The main issue is not having all the nice GUI facilities available to create to module.

Luckily there's a series of articles in Geertjan's Weblog called NetBeans Modules for Dummies Part 1,2,3,4. These articles provided a lot of information on how to create an NBM file using Ant tasks .

I also had to create a some Netbeans modules using Java to dissect the resulting NBM file and to provide some of the missing arguments. The resulting Ant file is can be found here.

Another challenge that I had was that some of the classes that I needed to access were only available to friend packages, this mainly because I was trying to access APIs that are still changing. Luckly, Tor Norbye from the Netbeans Ruby development list, provided a solution for this issue which could be found here. Again this is a consequence of using API's that are still not public.

The last issue that I had was to add the Scala Runtime Jar file as part of the package. The How do module dependencies/classloading work? Netbeans Faq entry was very helpful to solve this.

The code

By reading the code of existing hints, I learned that, the way to define hints (which is still under development) is very nice and very simple. Also there's useful documentation in the Writing New Ruby Hints entry from the Netbeans wiki.

Here's the code:

class IfToStatementModifierHint extends AstRule {

    def appliesTo(info : CompilationInfo) = true

    def getKinds() : Set = {
        val nodeKinds = new HashSet()
        nodeKinds.add(NodeTypes.IFNODE)
        nodeKinds
    }

    def run(info :CompilationInfo,
            node : Node,
            path : AstPath ,
            caretOffset : int,
            result : java.util.List) : unit = {

        node match {
           case IfStatement(callNode : CallNode,
                            NewlineNode(thenStat),
                            null) => {
              
              val range = AstUtilities.getRange(node)
 
              val desc = 
                   new Description(this,
                                   recomendationText,
                                   info.getFileObject,range,
                                   Collections.emptyList,
                                   600)
              result.add(desc)
       }
           case IfStatement(NotNode(EqualComparison(x,_ : NilNode)),
                            NewlineNode(thenStat),
                            null) => {
              
              
              val range = AstUtilities.getRange(node)
 
              val desc = 
                   new Description(this,
                                   recomendationText,
                                   info.getFileObject,range,
                                   Collections.emptyList,
                                   600)
              result.add(desc)
           }
           case _ =>
               {
               }
        } 
    }

    def getId() = "TestHint1"
 
    def getDisplayName() = "If statement as statement modifier"
 
    def getDescription() = "Identifies certain ..."

    def getDefaultEnabled() = true
  
    def getDefaultSeverity() = HintSeverity.WARNING 

    def getCustomizer(node: Preferences) : JComponent = null

    def showInTasklist() = true     

    def recomendationText = "Consider changing..."
   
}

The most interesting methods of this class are getHints and run.

The getHints method defines the kinds of AST nodes this method applies to. The run method identifies which kinds of if statement apply to this hint. To do this a couple of extractor objects defined in previous posts are used. Two special cases are identified:

• One if statement with a method call as condition, one statement in the then section and no statements in the else section.


• One if statement with an equal comparison to nil as condition, one statement in the then section and no statements in the else section.

This Hint is shown as a WARNING because it's the how severity that seems to apply. Although it will be very nice to have a RECOMMENDATION severity which seems to be more appropriate for this hint.

I really like this way of defining hints because you have to write exactly the code related to your problem.

Here's and example in action:




Code for this experiment can be found here.

For the next post I'll try to implement a quick fix for this hint.