complexity 1.0.0

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2009 Loren Segal
+ 
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+ 
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+Complexity
+==========
+
+Written by Loren Segal in 2009
+
+SYNOPSIS
+--------
+
+Calculates the McCabe [cyclomatic complexity][1] index of the methods in your Ruby code.
+The calculation is a basic `NUMBER_OF_BRANCHES + 1` calculation which can be used 
+this calculation to approximate the minimum number of test cases for each of
+your methods ([complexity should equal number of test cases][3]). You can also use
+this value to find overly complex method and refactor them into simpler ones.
+
+Some more reading can be found at [http://www.linuxjournal.com/article/8035][1].
+
+USAGE
+-----
+
+* Requires [YARD][3]
+
+Syntax: `ruby complexity.rb [--csv] GLOB_OF_FILES` 
+
+If you want CSV output, add --csv. `GLOB_OF_FILES` defaults to `lib/**/*.rb`.
+
+[1]: http://en.wikipedia.org/wiki/Cyclomatic_complexity "Cyclomatic Complexity"
+[2]: http://users.csc.calpoly.edu/~jdalbey/206/Lectures/BasisPathTutorial/index.html "Basis Path Testing"
+[3]: http://yard.soen.ca "Yay! A Ruby Documentation Tool"
+[4]: http://www.linuxjournal.com/article/8035

data/Rakefile

@@ -0,0 +1,23 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/testtask'
+
+WINDOWS = (PLATFORM =~ /win32|cygwin/ ? true : false) rescue false
+SUDO = WINDOWS ? '' : 'sudo'
+
+task :default => :test
+
+Rake::TestTask.new
+
+load 'complexity.gemspec'
+Rake::GemPackageTask.new(SPEC) do |pkg|
+  pkg.gem_spec = SPEC
+  pkg.need_zip = true
+  pkg.need_tar = true
+end
+
+desc "Install the gem locally"
+task :install => :package do 
+  sh "#{SUDO} gem install pkg/#{SPEC.name}-#{SPEC.version}.gem --local"
+  sh "rm -rf pkg/#{SPEC.name}-#{SPEC.version}" unless ENV['KEEP_FILES']
+end

data/bin/complexity

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../lib/complexity'
+require 'optparse'
+
+csv = false
+OptionParser.new do |opts|
+  opts.banner = "Usage: complexity [--csv] [FILES]"
+  opts.on('--csv', "Print CSV formatted output") { csv = true }
+  opts.on('-v', '--version') { puts "complexity 1.0.0, yard #{YARD::VERSION}"; exit }
+end.parse!
+YARD.parse(ARGV[0] || 'lib/**/*.rb')
+
+YARD::Registry.all(:method).each do |meth|
+  meth[:complexity] ||= 1
+end
+
+if csv
+  puts YARD::Registry.all(:method).map {|m| [m.path, m.complexity].join(',') }
+else
+  max = 40
+  YARD::Registry.all(:method).each {|m| max = m.path.length if m.path.length > max }
+  YARD::Registry.all(:method).each do |meth|
+    puts "#{meth.path}#{' ' * (max - meth.path.size)}#{meth.complexity}"
+  end
+end

data/lib/complexity.rb

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'yard'
+
+class ComplexityHandler < YARD::Handlers::Ruby::Base
+  handles %r{.*}
+  
+  BRANCH_TYPES = [:if, :if_mod, :unless, :unless_mod, :when, :elsif, :else,
+    :while, :while_mod, :until, :until_mod, :for, :do_block, :brace_block, :rescue]
+  
+  def process
+    return unless YARD::CodeObjects::MethodObject === owner
+    return unless [:def, :defs].include? statement.parent.parent.type
+    
+    owner[:complexity] = 1
+    statement.parent.last.traverse do |node|
+      owner[:complexity] += 1 if BRANCH_TYPES.include?(node.type)
+      owner[:complexity] += 2 if node.type == :ifop
+    end
+  end
+end
+
+class LegacyComplexityHandler < YARD::Handlers::Ruby::Legacy::Base
+  handles TkDEF
+  
+  BRANCH_TYPES = [TkRESCUE, TkENSURE, TkIF, TkIF_MOD, TkELSIF, TkELSE, TkUNLESS,
+    TkWHEN, TkWHILE, TkWHILE_MOD, TkUNTIL, TkUNTIL_MOD, TkFOR, TkQUESTION, TkCOLON,
+    TkLBRACE, TkDO]
+  
+  def process
+    nobj, mscope = namespace, scope
+    if statement.tokens.to_s =~ /^def\s+(#{METHODMATCH})/m
+      meth = $1.gsub(/\s+/,'')
+      if meth =~ /(?:#{NSEPQ}|#{CSEPQ})([^#{NSEP}#{CSEPQ}]+)$/
+        mscope, meth = :class, $1
+        nobj = P(namespace, $`) unless $` == "self"
+      end
+      
+      obj = MethodObject.new(nobj, meth, mscope)
+      obj[:complexity] = 1
+      statement.block.each do |token|
+        obj[:complexity] += 1 if BRANCH_TYPES.include?(token.class)
+      end
+    end
+  end
+end

data/test/test_complexity.rb

@@ -0,0 +1,43 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require "test/unit"
+require "complexity"
+
+METH_NAME = 'Test#meth'
+
+def meth(src = nil)
+  YARD.parse_string("class Test; def meth; #{src} end end") if src
+  YARD::Registry.at(METH_NAME).complexity
+end
+
+class TestComplexity < Test::Unit::TestCase
+  def test_empty_method
+    assert_equal 1, meth("")
+  end
+  
+  def test_if
+    assert_equal 2, meth("if x == 2 then do_something end")
+    assert_equal 2, meth("do_something if x == 2")
+  end
+  
+  def test_if_elsif
+    assert_equal 3, meth("if x == 2; A elsif x == 3; B end")
+  end
+  
+  def test_if_elsif_else
+    assert_equal 4, meth("if x == 2; A elsif x == 3; B; else C end")
+  end
+  
+  def test_case
+    assert_equal 5, meth("case X; when 1; A; when 2; B; when 3; C; when 4; D end")
+  end
+  
+  def test_ifop
+    assert_equal 5, meth("1 ? 2 : 3 ? 4 : 5")
+  end
+  
+  def test_block
+    assert_equal 2, meth("loop do X end")
+    assert_equal 4, meth("loop { 1 ? 2 : 1 }")
+  end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: complexity
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Loren Segal
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-05 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: yard
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: 
+email: lsegal@soen.ca
+executables: 
+- complexity
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/complexity.rb
+- bin/complexity
+- test/test_complexity.rb
+- LICENSE
+- README.md
+- Rakefile
+has_rdoc: yard
+homepage: http://github.com/lsegal/complexity
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: complexity
+rubygems_version: 1.3.4
+signing_key: 
+specification_version: 3
+summary: Calculates
+test_files: 
+- test/test_complexity.rb