metric_fu-roodi 2.2.0

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_start(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,76 @@
+require 'roodi/core/error'
+
+module Roodi
+  module Checks
+    class Check
+
+      NODE_TYPES = [:defn, :module, :resbody, :lvar, :cvar, :class, :if, :while, :until, :for, :rescue, :case, :when, :and, :or]
+
+      class << self
+      
+        def make(options = nil)
+          check = new
+          if options
+            options.each do |name, value|
+              check.send("#{name}=", value)
+            end
+          end
+          check
+        end
+
+      end
+
+      def initialize
+        @errors = []
+      end
+  
+      NODE_TYPES.each do |node|
+        start_node_method = "evaluate_start_#{node}"
+        end_node_method = "evaluate_end_#{node}"
+        define_method(start_node_method) { |node| return } unless self.respond_to?(start_node_method)
+        define_method(end_node_method) { |node| return } unless self.respond_to?(end_node_method)
+      end
+
+      def position(offset = 0)
+        "#{@line[2]}:#{@line[1] + offset}"
+      end
+
+      def start_file(filename)
+      end
+      
+      def end_file(filename)
+      end
+      
+      def evaluate_start(node)
+      end
+
+      def evaluate_end(node)
+      end
+
+      def evaluate_node(position, node)
+        @node = node
+        eval_method = "evaluate_#{position}_#{node.node_type}"
+        self.send(eval_method, node)
+      end
+
+      def evaluate_node_start(node)
+        evaluate_node(:start, node)
+        evaluate_start(node)
+      end
+  
+      def evaluate_node_end(node)
+        evaluate_node(:end, node)
+        evaluate_end(node)
+      end
+  
+      def add_error(error, filename = @node.file, line = @node.line)
+        @errors ||= []
+        @errors << Roodi::Core::Error.new("#{filename}", "#{line}", error)
+      end
+  
+      def errors
+        @errors
+      end
+    end
+  end
+end

data/lib/roodi/checks/class_line_count_check.rb

@@ -0,0 +1,28 @@
+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
+        super()
+        self.line_count = DEFAULT_LINE_COUNT
+      end
+
+      def interesting_nodes
+        [:class]
+      end
+
+      def message_prefix
+        'Class'
+      end
+
+    end
+  end
+end

data/lib/roodi/checks/class_name_check.rb

@@ -0,0 +1,31 @@
+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
+        super()
+        self.pattern = DEFAULT_PATTERN
+      end
+      
+      def interesting_nodes
+        [:class]
+      end
+
+      def message_prefix
+        '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_start(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_start_defn(node)
+        @method_name = node[1]
+        @arguments = node[2][1..-1]
+      end
+        
+      def evaluate_start_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,41 @@
+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
+        super()
+        self.complexity = DEFAULT_COMPLEXITY
+      end
+      
+      def interesting_nodes
+        [:iter] + COMPLEXITY_NODE_TYPES
+      end
+
+      def evaluate_start_iter(node)
+        increase_depth
+      end
+
+      def evaluate_end_iter(node)
+        decrease_depth
+      end
+      
+      def evaluate_matching_end
+        add_error "Block cyclomatic complexity is #{@count}.  It should be #{@complexity} or less." unless @count <= @complexity
+      end
+
+    end
+  end
+end

data/lib/roodi/checks/cyclomatic_complexity_check.rb

@@ -0,0 +1,50 @@
+require 'roodi/checks/check'
+
+module Roodi
+  module Checks
+    class CyclomaticComplexityCheck < Check
+      
+      COMPLEXITY_NODE_TYPES = [:if, :while, :until, :for, :rescue, :case, :when, :and, :or]
+
+      attr_accessor :complexity
+
+      def initialize
+        super()
+        @count = 0
+        @counting = 0
+      end
+      
+      COMPLEXITY_NODE_TYPES.each do |type|
+        define_method "evaluate_start_#{type}" do |node|
+          @count = @count + 1 if counting?
+        end
+      end
+      
+      protected
+      
+      def count_complexity(node)
+        count_branches(node) + 1
+      end
+      
+      def increase_depth
+        @count = 1 unless counting?
+        @counting = @counting + 1
+      end
+
+      def decrease_depth
+        @counting = @counting - 1
+        if @counting <= 0
+          @counting = 0
+          evaluate_matching_end
+        end
+      end
+      
+      private
+      
+      def counting?
+        @counting > 0
+      end
+
+    end
+  end
+end

data/lib/roodi/checks/cyclomatic_complexity_method_check.rb

@@ -0,0 +1,42 @@
+require 'roodi/checks/cyclomatic_complexity_check'
+
+module Roodi
+  module Checks
+    # Checks cyclomatic complexity of a method 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 method, 1-4 is considered good, 5-8 ok, 9-10 consider re-factoring, and 
+    # 11+ re-factor now!
+    class CyclomaticComplexityMethodCheck < CyclomaticComplexityCheck
+      
+      DEFAULT_COMPLEXITY = 8
+      
+      def initialize
+        super()
+        self.complexity = DEFAULT_COMPLEXITY
+      end
+      
+      def interesting_nodes
+        [:defn] + COMPLEXITY_NODE_TYPES
+      end
+
+      def evaluate_start_defn(node)
+        @method_name = @node[1]
+        increase_depth
+      end
+
+      def evaluate_end_defn(node)
+        decrease_depth
+      end
+      
+      def evaluate_matching_end
+        add_error "Method name \"#{@method_name}\" cyclomatic complexity is #{@count}.  It should be #{@complexity} or less." unless @count <= @complexity
+      end
+
+    end
+  end
+end

data/lib/roodi/checks/empty_rescue_body_check.rb

@@ -0,0 +1,32 @@
+require 'roodi/checks/check'
+
+module Roodi
+  module Checks
+    # Checks the body of a rescue block to make sure it's not empty..
+    # 
+    # When the body of a rescue block is empty, exceptions can get caught and swallowed without
+    # any feedback to the user.
+    class EmptyRescueBodyCheck < Check
+      STATEMENT_NODES = [:fcall, :return, :attrasgn, :vcall, :nil, :call, :lasgn, :true, :false]
+      
+      def interesting_nodes
+        [:resbody]
+      end
+
+      def evaluate_start(node)
+        add_error("Rescue block should not be empty.") unless has_statement?(node.children[1])
+      end
+  
+      private
+  
+      def has_statement?(node)
+        false unless node
+        has_local_statement?(node) or node.children.any? { |child| has_statement?(child) } if node
+      end
+
+      def has_local_statement?(node)
+        STATEMENT_NODES.include?(node.node_type)
+      end
+    end
+  end
+end

data/lib/roodi/checks/for_loop_check.rb

@@ -0,0 +1,20 @@
+require 'roodi/checks/check'
+
+module Roodi
+  module Checks
+    # Checks to make sure for loops are not being used..
+    # 
+    # Using a for loop is not idiomatic use of Ruby, and is usually a sign that someone with 
+    # more experience in a different programming language is trying out Ruby.  Use 
+    # Enumerable.each with a block instead.
+    class ForLoopCheck < Check
+      def interesting_nodes
+        [:for]
+      end
+
+      def evaluate_start(node)
+        add_error "Don't use 'for' loops. Use Enumerable.each instead."
+      end
+    end
+  end
+end

data/lib/roodi/checks/line_count_check.rb

@@ -0,0 +1,22 @@
+require 'roodi/checks/check'
+
+module Roodi
+  module Checks
+    class LineCountCheck < Check
+      
+      attr_accessor :line_count
+
+      def evaluate_start(node)
+        line_count = count_lines(node)
+        add_error "#{message_prefix} \"#{node[1]}\" has #{line_count} lines.  It should have #{@line_count} or less." unless line_count <= @line_count
+      end
+
+      protected
+  
+      def count_lines(node)
+        node.last.line - node.line - 1
+      end
+
+    end
+  end
+end

data/lib/roodi/checks/method_line_count_check.rb

@@ -0,0 +1,29 @@
+require 'roodi/checks/line_count_check'
+
+module Roodi
+  module Checks
+    # Checks a method to make sure the number of lines it has is under the specified limit.
+    # 
+    # A method getting too large is a code smell that indicates it might be doing more than one 
+    # thing and becoming hard to test.  It should probably be refactored into multiple methods 
+    # that each do a single thing well. 
+    class MethodLineCountCheck < LineCountCheck
+
+      DEFAULT_LINE_COUNT = 20
+      
+      def initialize
+        super()
+        self.line_count = DEFAULT_LINE_COUNT
+      end
+
+      def interesting_nodes
+        [:defn]
+      end
+
+      def message_prefix
+        'Method'
+      end
+
+    end
+  end
+end