threedaymonk-roodi 1.3.8

data/README.txt

@@ -0,0 +1,96 @@
+= 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 [-config=file] [pattern ...]
+
+=== 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"
+
+Check all ruby files in a rails app with a custom configuration file:
+    roodi -config=my_roodi_config.yml "rails_app/**/*.rb"
+
+If you're writing a check, it is useful to see the structure of a file the way that Roodi tokenizes it (via ruby_parser). Use:
+    roodi-describe [filename]
+
+== CUSTOM CONFIGURATION
+
+To change the set of checks included, or to change the default values of the checks, you can provide your own config file.  The config file is a YAML file that lists the checks to be included.  Each check can optionally include a hash of options that are passed to the check to configure it.  For example, the default config file looks like this:
+
+    AssignmentInConditionalCheck:    { }
+    CaseMissingElseCheck:            { }
+    ClassLineCountCheck:             { line_count: 300 }
+    ClassNameCheck:                  { pattern: !ruby/regexp /^[A-Z][a-zA-Z0-9]*$/ }
+    CyclomaticComplexityBlockCheck:  { complexity: 4 }
+    CyclomaticComplexityMethodCheck: { complexity: 8 }
+    EmptyRescueBodyCheck:            { }
+    ForLoopCheck:                    { }
+    MethodLineCountCheck:            { line_count: 20 }
+    MethodNameCheck:                 { pattern: !ruby/regexp /^[_a-z<>=\[\]|+-\/\*`]+[_a-z0-9_<>=~@\[\]]*[=!\?]?$/ }
+    ModuleLineCountCheck:            { line_count: 300 }
+    ModuleNameCheck:                 { pattern: !ruby/regexp /^[A-Z][a-zA-Z0-9]*$/ }
+    ParameterNumberCheck:            { parameter_count: 5 }
+
+== SUPPORTED CHECKS:
+
+* AssignmentInConditionalCheck - Check for an assignment inside a conditional.  It's probably a mistaken equality comparison.
+* CaseMissingElseCheck - Check that case statements have an else statement so that all cases are covered.
+* ClassLineCountCheck - Check that the number of lines in a class is below the threshold.
+* 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)
+* MethodLineCountCheck - Check that the number of lines in a method is below the threshold.
+* MethodNameCheck - Check that method names match convention.
+* ModuleLineCountCheck - Check that the number of lines in a module is below the threshold.
+* ModuleNameCheck - Check that module names match convention.
+* ParameterNumberCheck - Check that the number of parameters on a method is below the threshold.
+
+== SUGGESTED CHECKS:
+
+* BlockVariableShadowCheck - Check that a block variable does not have the same name as a method parameter or local variable.  It may be mistakenly referenced within the block.
+
+== 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/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::Runner.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::Runner.new
+roodi.print_file(ARGV[0])

data/lib/roodi.rb

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

data/lib/roodi/checks.rb

@@ -0,0 +1,16 @@
+require 'roodi/checks/abc_metric_method_check'
+require 'roodi/checks/assignment_in_conditional_check'
+require 'roodi/checks/case_missing_else_check'
+require 'roodi/checks/class_line_count_check'
+require 'roodi/checks/class_name_check'
+require 'roodi/checks/class_variable_check'
+require 'roodi/checks/control_coupling_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_line_count_check'
+require 'roodi/checks/method_name_check'
+require 'roodi/checks/module_line_count_check'
+require 'roodi/checks/module_name_check'
+require 'roodi/checks/parameter_number_check'

data/lib/roodi/checks/abc_metric_method_check.rb

@@ -0,0 +1,77 @@
+require 'roodi/checks/check'
+
+module Roodi
+  module Checks
+    # TODO:  Add summary
+    # 
+    # TODO:  Add detail
+    class AbcMetricMethodCheck < Check
+      # ASSIGNMENTS = [:attrasgn, :attrset, :dasgn_curr, :iasgn, :lasgn, :masgn]
+      ASSIGNMENTS = [:lasgn]
+      # BRANCHES = [:if, :else, :while, :until, :for, :rescue, :case, :when, :and, :or]
+      BRANCHES = [:vcall, :call]
+      # CONDITIONS = [:and, :or]
+      CONDITIONS = [:==, :<=, :>=, :<, :>]
+      #  =  *=  /=  %=  +=  <<=  >>=  &=  |=  ^=
+      OPERATORS = [:*, :/, :%, :+, :<<, :>>, :&, :|, :^]
+      DEFAULT_SCORE = 10
+      
+      def initialize(options = {})
+        super()
+        @score = options['score'] || DEFAULT_SCORE
+      end
+      
+      def interesting_nodes
+        [:defn]
+      end
+
+      def evaluate(node)
+        method_name = node[1]
+        a = count_assignments(node)
+        b = count_branches(node)
+        c = count_conditionals(node)
+        score = Math.sqrt(a*a + b*b + c*c)
+        add_error "Method name \"#{method_name}\" has an ABC metric score of <#{a},#{b},#{c}> = #{score}.  It should be #{@score} or less." unless score <= @score
+      end
+      
+      private
+
+      def count_assignments(node)
+        count = 0
+        count = count + 1 if assignment?(node)
+        node.children.each {|node| count += count_assignments(node)}
+        count
+      end
+      
+      def count_branches(node)
+        count = 0
+        count = count + 1 if branch?(node)
+        node.children.each {|node| count += count_branches(node)}
+        count
+      end
+
+      def count_conditionals(node)
+        count = 0
+        count = count + 1 if conditional?(node)
+        node.children.each {|node| count += count_conditionals(node)}
+        count
+      end
+      
+      def assignment?(node)
+        ASSIGNMENTS.include?(node.node_type)
+      end
+      
+      def branch?(node)
+        BRANCHES.include?(node.node_type) && !conditional?(node) && !operator?(node)
+      end
+      
+      def conditional?(node)
+        (:call == node.node_type) && CONDITIONS.include?(node[2]) 
+      end
+      
+      def operator?(node)
+        (:call == node.node_type) && OPERATORS.include?(node[2]) 
+      end      
+    end
+  end
+end

data/lib/roodi/checks/assignment_in_conditional_check.rb

@@ -0,0 +1,32 @@
+require 'roodi/checks/check'
+
+module Roodi
+  module Checks
+    # Checks a conditional to see if it contains an assignment.
+    # 
+    # A conditional containing an assignment is likely to be a mistyped equality check.  You
+    # should either fix the typo or factor out the assignment so that the code is clearer.
+    class AssignmentInConditionalCheck < Check
+      def initialize(options = {})
+        super()
+      end
+      
+      def interesting_nodes
+        [:if, :while]
+      end
+
+      def evaluate(node)
+        add_error("Found = in conditional.  It should probably be an ==") if has_assignment?(node[1])
+      end
+      
+      private
+      
+      def has_assignment?(node)
+        found_assignment = false
+        found_assignment = found_assignment || node.node_type == :lasgn
+        node.children.each { |child| found_assignment = found_assignment || has_assignment?(child) }
+        found_assignment
+      end
+    end
+  end
+end

data/lib/roodi/checks/case_missing_else_check.rb

@@ -0,0 +1,20 @@
+require 'roodi/checks/check'
+
+module Roodi
+  module Checks
+    # Checks a case statement to make sure it has an 'else' clause.
+    # 
+    # It's usually a good idea to have an else clause in every case statement. Even if the 
+    # developer is sure that all currently possible cases are covered, this should be 
+    # expressed in the else clause. This way the code is protected aginst later changes, 
+    class CaseMissingElseCheck < Check
+      def interesting_nodes
+        [:case]
+      end
+  
+      def evaluate(node)
+        add_error "Case statement is missing an else clause." unless node.last
+      end
+    end
+  end
+end

data/lib/roodi/checks/check.rb

@@ -0,0 +1,30 @@
+require 'roodi/core/error'
+
+module Roodi
+  module Checks
+    class Check
+      def initialize
+        @errors = []
+      end
+  
+      def position(offset = 0)
+        "#{@line[2]}:#{@line[1] + offset}"
+      end
+
+      def evaluate_node(node)
+        @node = node
+        eval_method = "evaluate_#{node.node_type}"
+        self.send(eval_method, node) if self.respond_to? eval_method
+        evaluate(node) if self.respond_to? :evaluate
+      end
+  
+      def add_error(error)
+        @errors << Roodi::Core::Error.new("#{@node.file}", "#{@node.line}", error)
+      end
+  
+      def errors
+        @errors
+      end
+    end
+  end
+end

data/lib/roodi/checks/class_line_count_check.rb

@@ -0,0 +1,18 @@
+require 'roodi/checks/line_count_check'
+
+module Roodi
+  module Checks
+    # Checks a class to make sure the number of lines it has is under the specified limit.
+    # 
+    # A class getting too large is a code smell that indicates it might be taking on too many 
+    # responsibilities.  It should probably be refactored into multiple smaller classes. 
+    class ClassLineCountCheck < LineCountCheck
+      DEFAULT_LINE_COUNT = 300
+      
+      def initialize(options = {})
+        line_count = options['line_count'] || DEFAULT_LINE_COUNT
+        super([:class], line_count, 'Class')
+      end
+    end
+  end
+end

data/lib/roodi/checks/class_name_check.rb

@@ -0,0 +1,21 @@
+require 'roodi/checks/name_check'
+
+module Roodi
+  module Checks
+    # Checks a class name to make sure it matches the specified pattern.
+    # 
+    # Keeping to a consistent naming convention makes your code easier to read.
+    class ClassNameCheck < NameCheck
+      DEFAULT_PATTERN = /^[A-Z][a-zA-Z0-9]*$/
+      
+      def initialize(options = {})
+        pattern = options['pattern'] || DEFAULT_PATTERN
+        super([:class], pattern, 'Class')
+      end
+      
+      def find_name(node)
+        node[1].class == Symbol ? node[1] : node[1].last
+      end
+    end
+  end
+end

data/lib/roodi/checks/class_variable_check.rb

@@ -0,0 +1,24 @@
+require 'roodi/checks/check'
+
+module Roodi
+  module Checks
+    # Checks to make sure class variables are not being used..
+    # 
+    # Class variables in Ruby have a complicated inheritance policy, and their use 
+    # can lead to mistakes.  Often an alternate design can be used to solve the 
+    # problem instead.
+    #
+    # This check is looking for a code smell rather than a definite error.  If you're 
+    # sure that you're doing the right thing, try turning this check off in your 
+    # config file.
+    class ClassVariableCheck < Check
+      def interesting_nodes
+        [:cvar]
+      end
+
+      def evaluate(node)
+        add_error "Don't use class variables. You might want to try a different design."
+      end
+    end
+  end
+end

data/lib/roodi/checks/control_coupling_check.rb

@@ -0,0 +1,20 @@
+require 'roodi/checks/check'
+
+module Roodi
+  module Checks
+    class ControlCouplingCheck < Check
+      def interesting_nodes
+        [:defn, :lvar]
+      end
+
+      def evaluate_defn(node)
+        @method_name = node[1]
+        @arguments = node[2][1..-1]
+      end
+        
+      def evaluate_lvar(node)
+        add_error "Method \"#{@method_name}\" uses the argument \"#{node[1]}\" for internal control." if @arguments.detect {|each| each == node[1]}
+      end
+    end
+  end
+end

data/lib/roodi/checks/cyclomatic_complexity_block_check.rb

@@ -0,0 +1,32 @@
+require 'roodi/checks/cyclomatic_complexity_check'
+
+module Roodi
+  module Checks
+    # Checks cyclomatic complexity of a block against a specified limit. 
+    # 
+    # The cyclomatic 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, for a block, 1-2 is considered good, 3-4 ok, 5-8 consider re-factoring, and 8+ 
+    # re-factor now!
+    class CyclomaticComplexityBlockCheck < CyclomaticComplexityCheck
+      DEFAULT_COMPLEXITY = 4
+      
+      def initialize(options = {})
+        complexity = options['complexity'] || DEFAULT_COMPLEXITY
+        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,29 @@
+require 'roodi/checks/check'
+
+module Roodi
+  module Checks
+    class CyclomaticComplexityCheck < Check
+      COMPLEXITY_NODE_TYPES = [:if, :while, :until, :for, :rescue, :case, :when, :and, :or]
+
+      def initialize(complexity)
+        super()
+        @complexity = complexity
+      end
+      
+      protected
+      
+      def count_complexity(node)
+        count_branches(node) + 1
+      end
+
+      private
+
+      def count_branches(node)
+        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