japgolly-Saikuro

The japgolly fork is a part of an attempt to get metric_fu working in a modern Ruby environment, specifically compatibility with Ruby 1.9 and Bundler.

===============================================================================

Version 0.2

Saikuro: Saikuro is a Ruby cyclomatic complexity analyzer. When given Ruby source code Saikuro will generate a report listing the cyclomatic complexity of each method found. In addition, Saikuro counts the number of lines per method and can generate a listing of the number of tokens on each line of code.

License: Saikuro uses the BSD license.

Installation: Option 1: Using setup.rb

• login as root
• run "ruby setup.rb all"

Option 2: The manual way Saikuro is a single Ruby file that is executable. You can run it where you unpacked it or you can move it your preferred location such as "/usr/local/bin" or "~/bin".

Note: Ruby 1.8.5 has a bug in ri_options that will prevent Saikuro from running. If you are using 1.8.5 please apply this patch : http://www.ruby-lang.org/cgi-bin/cvsweb.cgi/ruby/lib/rdoc/ri/ri_options.rb.diff?r1=1.2.2.13;r2=1.2.2.14

Usage: Saikuro is a command line program. Running "saikuro -h" will output a usage statement describing all the various arguments you can pass to it.

"saikuro -c -p tests/samples.rb"

The above command is a simple example that generates a cyclomatic complexity report on the samples.rb file, using the default filter, warning and error settings. The report is saved in the current directory.

A more detailed example is "saikuro -c -t -i tests -y 0 -w 11 -e 16 -o out/"

This will analyze all Ruby files found in the "tests/" directory. Saikuro will generate a token count report and a cyclomatic complexity report in the "out" directory . The "-y 0" command will turn off filtering and thus show the complexity of all methods. The "-w 11" will mark all methods with a complexity of 11 or higher with a warning. Finally, "-e 16" will flag all methods with a complexity of 16 or higher with an error.

About Cyclomatic Complexity:

The following document provides a very good and detailed description by the author of cyclomatic complexity.

NIST Special Publication 500-235 Structured Testing: A Testing Methodology Using the Cyclomatic Complexity Metric

By Arthur H. Watson and Thomas J. McCabe HTML http://hissa.nist.gov/HHRFdata/Artifacts/ITLdoc/235/title.htm PDF http://www.mccabe.com/iq_research_nist.htm

How and what Saikuro counts to calculate the cyclomatic complexity:

Saikuro uses the Simplified Complexity Calculation, which is just adding up the number of branch points in a method.

Each method starts with a complexity of 1, because there is at least one path through the code. Then each conditional or looping operator (if, unless, while, until, for, elsif, when) adds one point to the complexity. Each "when" in a case statement adds one point. Also each "rescue" statement adds one.

Saikuro also regards blocks as an addition to a method's complexity because in many cases a block does add a path that may be traversed. For example, invoking the "each" method of an array with a block would only traverse the give block if the array is not empty. Thus if you want to find the basis set to get 100% coverage of your code then a block should add one point to the method's complexity. It is not yet for sure however to what level the accuracy is decreased through this measurement, as normal Ruby code uses blocks quite heavily and new paths are not necessarily introduced by every block.

In addition, the short-circuiting "and" operators (&& and "and") currently do not contribute to a method's complexity, although McCabe's paper listed above suggests doing so.

#Example for "and" operator handling:

Starting values for case 1 and 2

x = false y = 15 r, q = nil

case 1

puts "W" if ((r = x) && (q = y)) puts r # => false puts q # => nil

case 2

puts "W" if ((q = y) && (r = x)) puts r # => false puts q # => 15

Case 1 illustrates why "and" operators should add to a method's complexity, because the result of ( r = x ) is false the if statement stops and returns false without evaluating the ( q = y ) branch. Thus if a total coverage of source code is desired, one point should be added to the method's complexity.

So why is it not added? Mainly, because we have not gotten around to it. We are wondering if this would increase the noise more than it should.

Tests: In the test directory is a sample file that has examples of the various possible cases that we examined and documented the expected cyclomatic complexity result. If you find mistakes or missing tests please report them.

Contact: Saikuro is written by Zev Blut (zb at ubit dot com)

Acknowledgments: Thanks to Elbert Corpuz for writing the CSS for the HTML output!

Other metric tools for Ruby: Ryan Davis has an abc metric program as an example in his ParseTree product: http://www.zenspider.com/ZSS/Products/ParseTree/

The PMD project has a tool called CPD that can scan Ruby source code looking for source duplication: http://pmd.sourceforge.net/