roodi 0.5

data/History.txt

@@ -0,0 +1,27 @@
+= 0.5
+
+* expanded regex matching for method name check.
+* suppressed noisy output from ParseTree using facets API.
+* updated dependencies and version as a result of facets change.
+* made Roodi tolerant of being asked to parse files which aren't really Ruby files.
+* updated the documentation with usage examples.
+
+= 0.4
+
+* Added support back in for line numbers in error messages.
+* Re-enabled MethodLineCountCheck as part of the default check set.
+
+= 0.3
+
+* First version of Roodi to be published to Rubyforge.
+
+= 0.2
+
+* Now use ParseTree instead of JRuby, which makes the tool much more accessible.
+* Removed MagicNumberCheck
+* Line numbers no longer supported as a result of the move.
+
+= 0.1
+
+* A first version of a design checking tool for Ruby, with a few checks built in to get started.
+

data/Manifest.txt

@@ -0,0 +1,32 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/roodi
+bin/roodi-describe
+lib/roodi.rb
+lib/roodi/checks.rb
+lib/roodi/checks/check.rb
+lib/roodi/checks/class_name_check.rb
+lib/roodi/checks/cyclomatic_complexity_block_check.rb
+lib/roodi/checks/cyclomatic_complexity_check.rb
+lib/roodi/checks/cyclomatic_complexity_method_check.rb
+lib/roodi/checks/empty_rescue_body_check.rb
+lib/roodi/checks/for_loop_check.rb
+lib/roodi/checks/method_line_count_check.rb
+lib/roodi/checks/method_name_check.rb
+lib/roodi/core.rb
+lib/roodi/core/checking_visitor.rb
+lib/roodi/core/iterator_visitor.rb
+lib/roodi/core/parse_tree_runner.rb
+lib/roodi/core/parser.rb
+lib/roodi/core/visitable_sexp.rb
+roodi.yml
+spec/checks/class_name_check_spec.rb
+spec/checks/cyclomatic_complexity_block_check_spec.rb
+spec/checks/cyclomatic_complexity_method_check_spec.rb
+spec/checks/empty_rescue_body_check_spec.rb
+spec/checks/for_loop_check_spec.rb
+spec/checks/method_line_count_check_spec.rb
+spec/checks/method_name_check_spec.rb
+spec/spec_helper.rb

data/README.txt

@@ -0,0 +1,66 @@
+= roodi
+
+* http://roodi.rubyforge.org
+
+== DESCRIPTION:
+
+Roodi stands for Ruby Object Oriented Design Inferometer.  It parses your Ruby code and warns you about design issues you have based on the checks that is has configured.
+
+== INSTALL:
+
+* sudo gem install roodi
+
+== SYNOPSIS:
+
+To check one or more files using the default configuration that comes with Roodi, use:
+    roodi [patterns]
+
+=== EXAMPLE USAGE
+
+Check all ruby files in a rails app:
+    roodi "rails_app/**/*.rb"
+
+Check one controller and one model file in a rails app:
+    roodi app/controller/sample_controller.rb app/models/sample.rb
+
+Check one controller and all model files in a rails app:
+    roodi app/controller/sample_controller.rb "app/models/*.rb"
+
+
+If you're writing a check, it is useful to see the structure of a file the way that Roodi tokenizes it (via ParesTree). Use:
+    roodi-describe [filename]
+
+== SUPPORTED CHECKS:
+
+* ClassNameCheck - Check that class names match convention.
+* CyclomaticComplexityBlockCheck - Check that the cyclomatic complexity of all blocks is below the threshold.
+* CyclomaticComplexityMethodCheck - Check that the cyclomatic complexity of all methods is below the threshold.
+* EmptyRescueBodyCheck - Check that there are no empty rescue blocks.
+* ForLoopCheck - Check that for loops aren't used (Use Enumerable.each instead)
+* MethodNameCheck - Check that method names match convention.
+* MethodLineCountCheck - Check that the number of lines in a method is below the threshold.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 Marty Andrews
+
+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/Rakefile

@@ -0,0 +1,32 @@
+$:.unshift(File.join(File.dirname(__FILE__), 'lib'))
+
+require 'rubygems'
+require 'hoe'
+require 'rake'
+require 'spec/rake/spectask'
+require 'roodi'
+
+Hoe.new('roodi', Roodi::VERSION) do |p|
+  p.developer('Marty Andrews', 'marty@cogentconsulting.com.au')
+  p.extra_deps = ['ParseTree', 'facets']
+  p.remote_rdoc_dir = ''
+end
+
+def roodi(ruby_files)
+  roodi = Roodi::Core::ParseTreeRunner.new
+  ruby_files.each { |file| roodi.check_file(file) }
+  roodi.errors.each {|error| puts error}
+  puts "\nFound #{roodi.errors.size} errors."
+end
+
+desc "Run all specs"
+Spec::Rake::SpecTask.new('spec') do |t|
+  t.spec_files = FileList['spec/**/*spec.rb']
+end
+
+desc "Run Roodi against all source files"
+task :roodi do
+  pattern = File.join(File.dirname(__FILE__), "**", "*.rb")
+  roodi(Dir.glob(pattern))
+end
+

data/bin/roodi

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/../lib"))
+
+require 'roodi'
+
+runner = Roodi::Core::ParseTreeRunner.new
+
+config_param = ARGV.detect {|arg| arg =~ /-config=.*/}
+runner.config = config_param.split("=")[1] if config_param
+ARGV.delete config_param
+
+ARGV.each do |arg|
+  Dir.glob(arg).each { |file| runner.check_file(file) }
+end
+
+runner.errors.each {|error| puts error}
+
+puts "\nFound #{runner.errors.size} errors."
+
+exit runner.errors.size

data/bin/roodi-describe

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/../lib"))
+require 'roodi'
+
+roodi = Roodi::Core::ParseTreeRunner.new
+roodi.print_file(ARGV[0])

data/lib/roodi.rb

@@ -0,0 +1,6 @@
+require 'roodi/checks'
+require 'roodi/core'
+
+module Roodi
+  VERSION = '0.5'
+end

data/lib/roodi/checks.rb

@@ -0,0 +1,7 @@
+require 'roodi/checks/class_name_check'
+require 'roodi/checks/cyclomatic_complexity_block_check'
+require 'roodi/checks/cyclomatic_complexity_method_check'
+require 'roodi/checks/empty_rescue_body_check'
+require 'roodi/checks/for_loop_check'
+require 'roodi/checks/method_name_check'
+require 'roodi/checks/method_line_count_check'

data/lib/roodi/checks/check.rb

@@ -0,0 +1,26 @@
+module Roodi
+  module Checks
+    class Check
+      def initialize
+        @errors = []
+      end
+  
+      def position(offset = 0)
+        "#{@line[2]}:#{@line[1] + offset}"
+      end
+  
+      def evaluate_node_at_line(node, line)
+        @line = line
+        evaluate(node)
+      end
+  
+      def add_error(error, offset = 0)
+        @errors << "#{position(offset)} - #{error}"
+      end
+  
+      def errors
+        @errors
+      end
+    end
+  end
+end

data/lib/roodi/checks/class_name_check.rb

@@ -0,0 +1,16 @@
+require 'roodi/checks/check'
+
+module Roodi
+  module Checks
+    class ClassNameCheck < Check
+      def interesting_nodes
+        [:class]
+      end
+  
+      def evaluate(node)
+        pattern = /^[A-Z][a-zA-Z0-9]*$/
+        add_error "Class name \"#{node[1]}\" should match pattern #{pattern.inspect}" unless node[1].to_s =~ pattern
+      end
+    end
+  end
+end

data/lib/roodi/checks/cyclomatic_complexity_block_check.rb

@@ -0,0 +1,20 @@
+require 'roodi/checks/cyclomatic_complexity_check'
+
+module Roodi
+  module Checks
+    class CyclomaticComplexityBlockCheck < CyclomaticComplexityCheck
+      def initialize(complexity = 4)
+        super(complexity)
+      end
+      
+      def interesting_nodes
+        [:iter]
+      end
+
+      def evaluate(node)
+        complexity = count_complexity(node)
+        add_error "Block cyclomatic complexity is #{complexity}.  It should be #{@complexity} or less." unless complexity <= @complexity
+      end
+    end
+  end
+end

data/lib/roodi/checks/cyclomatic_complexity_check.rb

@@ -0,0 +1,36 @@
+require 'roodi/checks/check'
+
+module Roodi
+  module Checks
+    # Checks cyclomatic complexity against a specified limit. The complexity is
+    # measured by the number of "if", "unless", "elsif", "?:", "while", "until", 
+    # "for", "rescue", "case", "when", "&&", "and", "||" and "or" statements (plus 
+    # one) in the body of the member. It is a measure of the minimum number of 
+    # possible paths through the source and therefore the number of required tests. 
+    # Generally 1-4 is considered good, 5-7 ok, 8-10 consider re-factoring, and 
+    # 11+ re-factor now!
+    class CyclomaticComplexityCheck < Check
+      def initialize(complexity = 8)
+        super()
+        @complexity = complexity
+      end
+      
+      protected
+      
+      def count_complexity(node)
+        count_branches(node) + 1
+      end
+
+      private
+
+      def count_branches(node)
+        complexity_node_types = [:if, :while, :until, :for, :rescue, :case, :when, :and, :or]
+        
+        count = 0
+        count = count + 1 if complexity_node_types.include? node.node_type
+        node.children.each {|node| count += count_branches(node)}
+        count
+      end
+    end
+  end
+end

data/lib/roodi/checks/cyclomatic_complexity_method_check.rb

@@ -0,0 +1,20 @@
+require 'roodi/checks/cyclomatic_complexity_check'
+
+module Roodi
+  module Checks
+    class CyclomaticComplexityMethodCheck < CyclomaticComplexityCheck
+      def initialize(complexity = 8)
+        super(complexity)
+      end
+      
+      def interesting_nodes
+        [:defn]
+      end
+
+      def evaluate(node)
+        complexity = count_complexity(node)
+        add_error "Method name \"#{node[1]}\" has a cyclomatic complexity is #{complexity}.  It should be #{@complexity} or less." unless complexity <= @complexity
+      end
+    end
+  end
+end

data/lib/roodi/checks/empty_rescue_body_check.rb

@@ -0,0 +1,24 @@
+require 'roodi/checks/check'
+
+module Roodi
+  module Checks
+    class EmptyRescueBodyCheck < Check
+      def interesting_nodes
+        [:resbody]
+      end
+
+      def evaluate(node)
+        add_error("Rescue block should not be empty.", 1) unless has_statement?(node)
+      end
+  
+      private
+  
+      def has_statement?(node)
+        found_statement = false
+        found_statement = found_statement || node.node_type == :fcall
+        node.children.each { |child| found_statement = found_statement || has_statement?(child) }
+        found_statement
+      end
+    end
+  end
+end

data/lib/roodi/checks/for_loop_check.rb

@@ -0,0 +1,15 @@
+require 'roodi/checks/check'
+
+module Roodi
+  module Checks
+    class ForLoopCheck < Check
+      def interesting_nodes
+        [:for]
+      end
+
+      def evaluate(node)
+        add_error "Don't use 'for' loops. Use Enumerable.each instead."
+      end
+    end
+  end
+end

data/lib/roodi/checks/method_line_count_check.rb

@@ -0,0 +1,30 @@
+require 'roodi/checks/check'
+
+module Roodi
+  module Checks
+    class MethodLineCountCheck < Check
+      def initialize(line_count = 20)
+        super()
+        @line_count = line_count
+      end
+      
+      def interesting_nodes
+        [:defn]
+      end
+
+      def evaluate(node)
+        line_count = count_lines(node)
+        add_error "Method name \"#{node[1]}\" has #{line_count} lines.  It should have #{@line_count} or less." unless line_count <= @line_count
+      end
+  
+      private
+  
+      def count_lines(node)
+        count = 0
+        count = count + 1 if node.node_type == :newline
+        node.children.each {|node| count += count_lines(node)}
+        count
+      end
+    end
+  end
+end

data/lib/roodi/checks/method_name_check.rb

@@ -0,0 +1,16 @@
+require 'roodi/checks/check'
+
+module Roodi
+  module Checks
+    class MethodNameCheck < Check
+      def interesting_nodes
+        [:defn]
+      end
+
+      def evaluate(node)
+        pattern = /^[_a-z<>=\[\]|+-\/\*`]+[_a-z0-9_<>=~@\[\]]*[=!\?]?$/
+        add_error "Method name \"#{node[1]}\" should match pattern #{pattern.inspect}" unless node[1].to_s =~ pattern
+      end
+    end
+  end
+end

data/lib/roodi/core.rb

@@ -0,0 +1,6 @@
+# require 'roodi/core/checking_visitor'
+# require 'roodi/core/iterator_visitor'
+require 'roodi/core/parse_tree_runner'
+# require 'roodi/core/printing_visitor'
+# require 'roodi/core/runner'
+# require 'roodi/core/tree_walker'

data/lib/roodi/core/checking_visitor.rb

@@ -0,0 +1,24 @@
+module Roodi
+  module Core
+    class CheckingVisitor
+      def initialize(*checks)
+        @checks ||= {}
+        checks.first.each do |check|
+          nodes = check.interesting_nodes
+          nodes.each do |node|
+            @checks[node] ||= []
+            @checks[node] << check
+            @checks[node].uniq!
+          end
+        end
+      end
+
+      def visit(node)
+        @last_newline = node if node.node_type == :newline
+        checks = @checks[node.node_type]
+        checks.each {|check| check.evaluate_node_at_line(node, @last_newline)} unless checks.nil?
+        nil
+      end
+    end
+  end
+end

data/lib/roodi/core/iterator_visitor.rb

@@ -0,0 +1,19 @@
+module Roodi
+  module Core
+    class IteratorVisitor
+    	def initialize(payload)
+      	@payload = payload
+    	end
+	
+    	def visit(visited)
+    		visited.accept(@payload)
+    		visitable_nodes = visited.is_language_node? ? visited.sexp_body : visited
+    		visitable_nodes.each do |child| 
+    		  if child.class == VisitableSexp then
+      		  child.accept(self)
+    		  end
+  		  end
+    	end
+    end
+  end
+end

data/lib/roodi/core/parse_tree_runner.rb

@@ -0,0 +1,69 @@
+require 'pp'
+require 'yaml'
+
+require 'roodi/core/checking_visitor'
+require 'roodi/core/iterator_visitor'
+require 'roodi/core/parser'
+require 'roodi/core/visitable_sexp'
+
+module Roodi
+  module Core
+    class ParseTreeRunner
+      DEFAULT_CONFIG = File.join(File.dirname(__FILE__), "..", "..", "..", "roodi.yml")
+      
+      def initialize(*checks)
+        @config = DEFAULT_CONFIG
+        @checks = checks unless checks.empty?
+        @parser = Parser.new
+      end
+      
+      def check(filename, content)
+        @checks ||= load_checks
+        begin
+          node = @parser.parse(content, filename)
+          node.accept(IteratorVisitor.new(CheckingVisitor.new(@checks)))
+        rescue Exception => e
+          # puts e
+          puts "#{filename} looks like it's not a valid Ruby file.  Skipping..."
+        end
+      end
+
+      def check_content(content)
+        check("dummy-file.rb", content)
+      end
+  
+      def check_file(filename)
+        check(filename, File.read(filename))
+      end
+  
+      def print(filename, content)
+        node = @parser.parse(content, filename)
+        pp node
+      end
+
+      def print_content(content)
+        print("dummy-file.rb", content)
+      end
+  
+      def print_file(filename)
+        print(filename, File.read(filename))
+      end
+  
+      def errors
+        @checks ||= []
+        all_errors = @checks.collect {|check| check.errors}
+        all_errors.flatten
+      end
+      
+      private
+      
+      def load_checks
+        check_objects = []
+        check_config = YAML.load_file @config
+        checks = check_config["checks"]
+        checks.each { |check| check_objects << eval("Roodi::Checks::#{check['name']}.new") }
+        check_objects
+      end
+    end
+  end
+end

data/lib/roodi/core/parser.rb

@@ -0,0 +1,26 @@
+require 'rubygems'
+require 'parse_tree'
+require 'facets'
+
+
+module Roodi
+  module Core
+    class Parser
+      def parse(content, filename)
+        silence_stream(STDERR) do 
+          return silent_parse(content, filename)
+        end
+      end
+      
+      private
+      
+      def silent_parse(content, filename)
+        @parser ||= ParseTree.new(true)
+        node = @parser.parse_tree_for_string(content, filename)
+        sexp = VisitableSexp.from_array node
+        sexp.filename = filename
+        sexp
+      end
+    end
+  end
+end

data/lib/roodi/core/visitable_sexp.rb

@@ -0,0 +1,24 @@
+require 'rubygems'
+require 'sexp'
+
+module Roodi
+  module Core
+    class VisitableSexp < Sexp
+      def accept(visitor)
+        visitor.visit(self)
+      end
+      
+      def node_type
+        first
+      end
+      
+      def children
+        sexp_body.select {|each| each.class == VisitableSexp }
+      end
+      
+      def is_language_node?
+        first.class == Symbol
+      end
+    end
+  end
+end

data/roodi.yml

@@ -0,0 +1,9 @@
+checks:
+- { name: ClassNameCheck }
+- { name: CyclomaticComplexityBlockCheck, complexity: 2 }
+- { name: CyclomaticComplexityMethodCheck, complexity: 5 }
+- { name: EmptyRescueBodyCheck }
+- { name: ForLoopCheck }
+- { name: MethodLineCountCheck }
+- { name: MethodNameCheck }
+

data/spec/checks/class_name_check_spec.rb

@@ -0,0 +1,27 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Roodi::Checks::ClassNameCheck do
+  before(:each) do
+    @roodi = Roodi::Core::ParseTreeRunner.new(Roodi::Checks::ClassNameCheck.new)
+  end
+  
+  it "should accept camel case class names starting in capitals" do
+    content = <<-END
+    class GoodClassName 
+    end
+    END
+    @roodi.check_content(content)
+    @roodi.errors.should be_empty
+  end
+
+  it "should reject class names with underscores" do
+    content = <<-END
+    class Bad_ClassName 
+    end
+    END
+    @roodi.check_content(content)
+    errors = @roodi.errors
+    errors.should_not be_empty
+    errors[0].should eql("dummy-file.rb:1 - Class name \"Bad_ClassName\" should match pattern /^[A-Z][a-zA-Z0-9]*$/")
+  end
+end

data/spec/checks/cyclomatic_complexity_block_check_spec.rb

@@ -0,0 +1,36 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Roodi::Checks::CyclomaticComplexityBlockCheck do
+  before(:each) do
+    @roodi = Roodi::Core::ParseTreeRunner.new(Roodi::Checks::CyclomaticComplexityBlockCheck.new(0))
+  end
+
+  def verify_content_complexity(content, complexity)
+    @roodi.check_content(content)
+    errors = @roodi.errors
+    errors.should_not be_empty
+    errors[0].should eql("dummy-file.rb:2 - Block cyclomatic complexity is #{complexity}.  It should be 0 or less.")
+  end
+  
+  it "should find a simple block" do
+    content = <<-END
+    def method_name
+      it "should be a simple block" do
+        call_foo
+      end
+    end
+    END
+    verify_content_complexity(content, 1)
+  end
+
+  it "should find a block with multiple paths" do
+    content = <<-END
+    def method_name
+      it "should be a complex block" do
+        call_foo if some_condition
+      end
+    end
+    END
+    verify_content_complexity(content, 2)
+  end
+end

data/spec/checks/cyclomatic_complexity_method_check_spec.rb

@@ -0,0 +1,183 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Roodi::Checks::CyclomaticComplexityMethodCheck do
+  before(:each) do
+    @roodi = Roodi::Core::ParseTreeRunner.new(Roodi::Checks::CyclomaticComplexityMethodCheck.new(0))
+  end
+
+  def verify_content_complexity(content, complexity)
+    @roodi.check_content(content)
+    errors = @roodi.errors
+    errors.should_not be_empty
+    errors[0].should eql("dummy-file.rb:1 - Method name \"method_name\" has a cyclomatic complexity is #{complexity}.  It should be 0 or less.")
+  end
+  
+  it "should find an if block" do
+    content = <<-END
+    def method_name
+      call_foo if some_condition
+    end
+    END
+    verify_content_complexity(content, 2)
+  end
+
+  it "should find an unless block" do
+    content = <<-END
+    def method_name
+      call_foo unless some_condition
+    end
+    END
+    verify_content_complexity(content, 2)
+  end
+
+  it "should find an elsif block" do
+    content = <<-END
+    def method_name
+      if first_condition then
+        call_foo
+      elsif second_condition then
+        call_bar
+      else
+        call_bam
+      end
+    end
+    END
+    verify_content_complexity(content, 3)
+  end
+
+  it "should find a ternary operator" do
+    content = <<-END
+    def method_name
+      value = some_condition ? 1 : 2
+    end
+    END
+    verify_content_complexity(content, 2)
+  end
+
+  it "should find a while loop" do
+    content = <<-END
+    def method_name
+      while some_condition do
+        call_foo
+      end
+    end
+    END
+    verify_content_complexity(content, 2)
+  end
+
+  it "should find an until loop" do
+    content = <<-END
+    def method_name
+      until some_condition do
+        call_foo
+      end
+    end
+    END
+    verify_content_complexity(content, 2)
+  end
+
+  it "should find a for loop" do
+    content = <<-END
+    def method_name
+      for i in 1..2 do
+        call_method
+      end
+    end
+    END
+    verify_content_complexity(content, 2)
+  end
+
+  it "should find a rescue block" do
+    content = <<-END
+    def method_name
+      begin
+        call_foo
+      rescue Exception
+        call_bar
+      end
+    end
+    END
+    verify_content_complexity(content, 2)
+  end
+
+  it "should find a case and when block" do
+    content = <<-END
+    def method_name
+      case value
+      when 1
+        call_foo
+      when 2
+        call_bar
+      end
+    end
+    END
+    verify_content_complexity(content, 4)
+  end
+
+  it "should find the && symbol" do
+    content = <<-END
+    def method_name
+      call_foo && call_bar
+    end
+    END
+    verify_content_complexity(content, 2)
+  end
+
+  it "should find the and symbol" do
+    content = <<-END
+    def method_name
+      call_foo and call_bar
+    end
+    END
+    verify_content_complexity(content, 2)
+  end
+
+  it "should find the || symbol" do
+    content = <<-END
+    def method_name
+      call_foo || call_bar
+    end
+    END
+    verify_content_complexity(content, 2)
+  end
+
+  it "should find the or symbol" do
+    content = <<-END
+    def method_name
+      call_foo or call_bar
+    end
+    END
+    verify_content_complexity(content, 2)
+  end
+
+  it "should deal with nested if blocks containing && and ||" do
+    content = <<-END
+    def method_name
+      if first_condition then
+        call_foo if second_condition && third_condition
+        call_bar if fourth_condition || fifth_condition
+      end
+    end
+    END
+    verify_content_complexity(content, 6)
+  end
+
+  it "should count stupid nested if and else blocks" do
+    content = <<-END
+    def method_name
+      if first_condition then
+        call_foo
+      else
+        if second_condition then
+          call_bar
+        else
+          call_bam if third_condition
+        end
+        call_baz if fourth_condition
+      end
+    end
+    END
+    verify_content_complexity(content, 5)
+  end
+
+end

data/spec/checks/empty_rescue_body_check_spec.rb

@@ -0,0 +1,57 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Roodi::Checks::EmptyRescueBodyCheck do
+  before(:each) do
+    @roodi = Roodi::Core::ParseTreeRunner.new(Roodi::Checks::EmptyRescueBodyCheck.new)
+  end
+  
+  it "should accept a rescue body with content and no parameter" do
+    content = <<-END
+    begin
+      call_method
+    rescue
+      puts "Recover from the call"
+    end
+    END
+    @roodi.check_content(content)
+    @roodi.errors.should be_empty
+  end
+
+  it "should accept a rescue body with content and a parameter" do
+    content = <<-END
+    begin
+      call_method
+    rescue Exception => e
+      puts "Recover from the call"
+    end
+    END
+    @roodi.check_content(content)
+    @roodi.errors.should be_empty
+  end
+
+  it "should reject an empty rescue block with no parameter" do
+    content = <<-END
+    begin
+      call_method
+    rescue
+    end
+    END
+    @roodi.check_content(content)
+    errors = @roodi.errors
+    errors.should_not be_empty
+    errors[0].should eql("dummy-file.rb:3 - Rescue block should not be empty.")
+  end
+
+  it "should reject an empty rescue block with a parameter" do
+    content = <<-END
+    begin
+      call_method
+    rescue Exception => e
+    end
+    END
+    @roodi.check_content(content)
+    errors = @roodi.errors
+    errors.should_not be_empty
+    errors[0].should eql("dummy-file.rb:3 - Rescue block should not be empty.")
+  end
+end

data/spec/checks/for_loop_check_spec.rb

@@ -0,0 +1,18 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Roodi::Checks::ForLoopCheck do
+  before(:each) do
+    @roodi = Roodi::Core::ParseTreeRunner.new(Roodi::Checks::ForLoopCheck.new)
+  end
+  
+  it "should reject for loops" do
+    content = <<-END
+    for i in 1..2
+    end
+    END
+    @roodi.check_content(content)
+    errors = @roodi.errors
+    errors.should_not be_empty
+    errors[0].should eql("dummy-file.rb:1 - Don't use 'for' loops. Use Enumerable.each instead.")
+  end
+end

data/spec/checks/method_line_count_check_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Roodi::Checks::MethodLineCountCheck do
+  before(:each) do
+    @roodi = Roodi::Core::ParseTreeRunner.new(Roodi::Checks::MethodLineCountCheck.new(1))
+  end
+  
+  it "should accept methods with less lines than the threshold" do
+    content = <<-END
+    def zero_line_method
+    end
+    END
+    @roodi.check_content(content)
+    @roodi.errors.should be_empty
+  end
+
+  it "should accept methods with the same number of lines as the threshold" do
+    content = <<-END
+    def one_line_method
+      1
+    end
+    END
+    @roodi.check_content(content)
+    @roodi.errors.should be_empty
+  end
+
+  it "should reject methods with more lines than the threshold" do
+    content = <<-END
+    def two_line_method
+      puts 1
+      puts 2
+    end
+    END
+    @roodi.check_content(content)
+    errors = @roodi.errors
+    errors.should_not be_empty
+    errors[0].should eql("dummy-file.rb:1 - Method name \"two_line_method\" has 2 lines.  It should have 1 or less.")
+  end
+end

data/spec/checks/method_name_check_spec.rb

@@ -0,0 +1,153 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Roodi::Checks::MethodNameCheck do
+  before(:each) do
+    @roodi = Roodi::Core::ParseTreeRunner.new(Roodi::Checks::MethodNameCheck.new)
+  end
+  
+  it "should accept method names with underscores" do
+    content = <<-END
+    def good_method_name
+    end
+    END
+    @roodi.check_content(content)
+    @roodi.errors.should be_empty
+  end
+
+  it "should accept method names with numbers" do
+    content = <<-END
+    def good_method_1_name
+    end
+    END
+    @roodi.check_content(content)
+    @roodi.errors.should be_empty
+  end
+
+  it "should accept method names ending a question mark" do
+    content = <<-END
+    def good_method_name?
+    end
+    END
+    @roodi.check_content(content)
+    @roodi.errors.should be_empty
+  end
+
+  it "should accept method names ending an exclamation mark" do
+    content = <<-END
+    def good_method_name!
+    end
+    END
+    @roodi.check_content(content)
+    @roodi.errors.should be_empty
+  end
+
+  it "should accept method names ending an equals sign" do
+    content = <<-END
+    def good_method_name=
+    end
+    END
+    @roodi.check_content(content)
+    @roodi.errors.should be_empty
+  end
+
+  it "should accept << as a method name" do
+    content = <<-END
+    def <<
+    end
+    END
+    @roodi.check_content(content)
+    @roodi.errors.should be_empty
+  end
+
+  it "should accept >> as a method name" do
+    content = <<-END
+    def >>
+    end
+    END
+    @roodi.check_content(content)
+    @roodi.errors.should be_empty
+  end
+
+  it "should accept == as a method name" do
+    content = <<-END
+    def ==
+    end
+    END
+    @roodi.check_content(content)
+    @roodi.errors.should be_empty
+  end
+
+  it "should accept === as a method name" do
+    content = <<-END
+    def ===
+    end
+    END
+    @roodi.check_content(content)
+    @roodi.errors.should be_empty
+  end
+
+  it "should accept < as a method name" do
+    content = <<-END
+    def <
+    end
+    END
+    @roodi.check_content(content)
+    @roodi.errors.should be_empty
+  end
+
+  it "should accept <= as a method name" do
+    content = <<-END
+    def <=
+    end
+    END
+    @roodi.check_content(content)
+    @roodi.errors.should be_empty
+  end
+
+  it "should accept > as a method name" do
+    content = <<-END
+    def >
+    end
+    END
+    @roodi.check_content(content)
+    @roodi.errors.should be_empty
+  end
+
+  it "should accept >= as a method name" do
+    content = <<-END
+    def >=
+    end
+    END
+    @roodi.check_content(content)
+    @roodi.errors.should be_empty
+  end
+
+  it "should accept [] as a method name" do
+    content = <<-END
+    def []
+    end
+    END
+    @roodi.check_content(content)
+    @roodi.errors.should be_empty
+  end
+
+  it "should accept []= as a method name" do
+    content = <<-END
+    def []=
+    end
+    END
+    @roodi.check_content(content)
+    @roodi.errors.should be_empty
+  end
+
+  it "should reject camel case method names" do
+    content = <<-END
+    def badMethodName
+    end
+    END
+    @roodi.check_content(content)
+    errors = @roodi.errors
+    errors.should_not be_empty
+    errors[0].should eql("dummy-file.rb:1 - Method name \"badMethodName\" should match pattern /^[_a-z<>=\\[\\]|+-\\/\\*`]+[_a-z0-9_<>=~@\\[\\]]*[=!\\?]?$/")
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/../lib"))
+require 'roodi'

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification 
+name: roodi
+version: !ruby/object:Gem::Version 
+  version: "0.5"
+platform: ruby
+authors: 
+- Marty Andrews
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-09-10 00:00:00 +10:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ParseTree
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: facets
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.7.0
+    version: 
+description: Roodi stands for Ruby Object Oriented Design Inferometer.  It parses your Ruby code and warns you about design issues you have based on the checks that is has configured.
+email: 
+- marty@cogentconsulting.com.au
+executables: 
+- roodi
+- roodi-describe
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/roodi
+- bin/roodi-describe
+- lib/roodi.rb
+- lib/roodi/checks.rb
+- lib/roodi/checks/check.rb
+- lib/roodi/checks/class_name_check.rb
+- lib/roodi/checks/cyclomatic_complexity_block_check.rb
+- lib/roodi/checks/cyclomatic_complexity_check.rb
+- lib/roodi/checks/cyclomatic_complexity_method_check.rb
+- lib/roodi/checks/empty_rescue_body_check.rb
+- lib/roodi/checks/for_loop_check.rb
+- lib/roodi/checks/method_line_count_check.rb
+- lib/roodi/checks/method_name_check.rb
+- lib/roodi/core.rb
+- lib/roodi/core/checking_visitor.rb
+- lib/roodi/core/iterator_visitor.rb
+- lib/roodi/core/parse_tree_runner.rb
+- lib/roodi/core/parser.rb
+- lib/roodi/core/visitable_sexp.rb
+- roodi.yml
+- spec/checks/class_name_check_spec.rb
+- spec/checks/cyclomatic_complexity_block_check_spec.rb
+- spec/checks/cyclomatic_complexity_method_check_spec.rb
+- spec/checks/empty_rescue_body_check_spec.rb
+- spec/checks/for_loop_check_spec.rb
+- spec/checks/method_line_count_check_spec.rb
+- spec/checks/method_name_check_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://roodi.rubyforge.org
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+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: roodi
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Roodi stands for Ruby Object Oriented Design Inferometer
+test_files: []
+