roodi1.9 2.0.1

data/lib/roodi/checks/cyclomatic_complexity_check.rb

@@ -0,0 +1,47 @@
+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
+        @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,40 @@
+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(options = {})
+        complexity = options['complexity'] || DEFAULT_COMPLEXITY
+        super(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,29 @@
+require 'roodi/checks/check'
+
+module Roodi
+  module Checks
+    class LineCountCheck < Check
+      def initialize(interesting_nodes, line_count, message_prefix)
+        super()
+        @interesting_nodes = interesting_nodes
+        @line_count = line_count
+        @message_prefix = message_prefix
+      end
+
+      def interesting_nodes
+        @interesting_nodes
+      end
+
+      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,19 @@
+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(options = {})
+        line_count = options['line_count'] || DEFAULT_LINE_COUNT
+        super([:defn], line_count, 'Method')
+      end
+    end
+  end
+end

data/lib/roodi/checks/method_name_check.rb

@@ -0,0 +1,21 @@
+require 'roodi/checks/name_check'
+
+module Roodi
+  module Checks
+    # Checks a method name to make sure it matches the specified pattern.
+    # 
+    # Keeping to a consistent nameing convention makes your code easier to read.
+    class MethodNameCheck < NameCheck
+      DEFAULT_PATTERN = /^[_a-z<>=\[|+-\/\*`]+[_a-z0-9_<>=~@\[\]]*[=!\?]?$/
+      
+      def initialize(options = {})
+        pattern = options['pattern'] || DEFAULT_PATTERN
+        super([:defn], pattern, 'Method')
+      end
+      
+      def find_name(node)
+        node[1]
+      end
+    end
+  end
+end

data/lib/roodi/checks/missing_foreign_key_index_check.rb

@@ -0,0 +1,98 @@
+require 'roodi/checks/check'
+require 'pathname'
+
+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 MissingForeignKeyIndexCheck < Check
+      def initialize
+        @foreign_keys = {}
+        @indexes = {}
+      end
+
+      def interesting_nodes
+        [:call]
+      end
+
+      def evaluate_start_call(node)
+        if analyzing_schema(node)
+          if creating_table(node)
+            @current_table = create_table_name(node)
+          end
+
+          if creating_foreign_key(node)
+            @foreign_keys[@current_table] ||= []
+            @foreign_keys[@current_table] << foreign_key_column_name(node)
+          end
+
+          if adding_index(node)
+            @indexes[index_table_name(node)] ||= []
+            @indexes[index_table_name(node)] << index_column_name(node)
+          end
+        end
+      end
+      
+      def evaluate_end_call(node)
+        #ignored
+      end
+
+      def analyzing_schema(node)
+        pathname = Pathname.new(node.file)
+        @analyzing_schema ||= ("schema.rb" == pathname.basename.to_s)
+      end
+
+      def creating_table(node)
+        :create_table == node[2]
+      end
+
+      def create_table_name(node)
+        # Get table name out of this:
+        # s(:call, nil, :create_table, s(:arglist, s(:str, "duplicate_blocks"), s(:hash, s(:lit, :force), s(:true))))
+        node[3][1][1]
+      end
+
+      def creating_foreign_key(node)
+        #s(:call, s(:lvar, :t), :integer, s(:arglist, s(:str, "duplicate_set_id"), s(:hash, s(:lit, :null), s(:false))))
+        column_type = node[2]
+        column_name = node[3][1][1]
+        :integer == column_type && "_id" == column_name[-3,3]
+      end
+
+      def foreign_key_column_name(node)
+        #s(:call, s(:lvar, :t), :integer, s(:arglist, s(:str, "duplicate_set_id"), s(:hash, s(:lit, :null), s(:false))))
+        column_name = node[3][1][1]
+      end
+
+      def adding_index(node)
+        :add_index == node[2]
+      end
+
+      def index_table_name(node)
+        # Get table name out of this:
+        # s(:call, nil, :add_index, s(:arglist, s(:str, "duplicate_blocks"), s(:array, s(:str, "duplicate_set_id")), s(:hash, s(:lit, :name), s(:str, "index_duplicate_blocks_on_duplicate_set_id"))))
+        node[3][1][1]
+      end
+
+      def index_column_name(node)
+        # Get index column name out of this:
+        # s(:call, nil, :add_index, s(:arglist, s(:str, "duplicate_blocks"), s(:array, s(:str, "duplicate_set_id")), s(:hash, s(:lit, :name), s(:str, "index_duplicate_blocks_on_duplicate_set_id"))))
+        node[3][2][1][1]
+      end
+
+      def end_file(filename)
+        @foreign_keys.keys.each do |table|
+          foreign_keys = @foreign_keys[table] || []
+          indexes = @indexes[table] || []
+          missing_indexes = foreign_keys - indexes
+          missing_indexes.each do |fkey| 
+            add_error("Table '#{table}' is missing an index on the foreign key '#{fkey}'", filename, 1)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roodi/checks/module_line_count_check.rb

@@ -0,0 +1,18 @@
+require 'roodi/checks/line_count_check'
+
+module Roodi
+  module Checks
+    # Checks a module to make sure the number of lines it has is under the specified limit.
+    # 
+    # A module 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 modules. 
+    class ModuleLineCountCheck < LineCountCheck
+      DEFAULT_LINE_COUNT = 300
+      
+      def initialize(options = {})
+        line_count = options['line_count'] || DEFAULT_LINE_COUNT
+        super([:module], line_count, 'Module')
+      end
+    end
+  end
+end

data/lib/roodi/checks/module_name_check.rb

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

data/lib/roodi/checks/name_check.rb

@@ -0,0 +1,23 @@
+require 'roodi/checks/check'
+
+module Roodi
+  module Checks
+    class NameCheck < Check
+      def initialize(interesting_nodes, pattern, message_prefix)
+        super()
+        @interesting_nodes = interesting_nodes
+        @pattern = pattern
+        @message_prefix = message_prefix
+      end
+
+      def interesting_nodes
+        @interesting_nodes
+      end
+
+      def evaluate_start(node)
+        name = find_name(node)
+        add_error "#{@message_prefix} name \"#{name}\" should match pattern #{@pattern.inspect}" unless name.to_s =~ @pattern
+      end
+    end
+  end
+end

data/lib/roodi/checks/npath_complexity_check.rb

@@ -0,0 +1,73 @@
+require 'roodi/checks/check'
+
+module Roodi
+  module Checks
+    class NpathComplexityCheck < Check
+      # , :when, :and, :or
+      MULTIPLYING_NODE_TYPES = [:if, :while, :until, :for, :case]
+      ADDING_NODE_TYPES = [:rescue]
+      COMPLEXITY_NODE_TYPES = MULTIPLYING_NODE_TYPES + ADDING_NODE_TYPES
+
+      def initialize(complexity)
+        super()
+        @complexity = complexity
+        @value_stack = []
+        @current_value = 1
+      end
+      
+      def evalute_start_if(node)
+        push_value
+      end
+      
+      def evalute_start_while(node)
+        push_value
+      end
+
+      def evalute_start_until(node)
+        push_value
+      end
+
+      def evalute_start_for(node)
+        push_value
+      end
+
+      def evalute_start_case(node)
+        push_value
+      end
+
+      def evalute_start_rescue(node)
+        push_value
+      end
+      
+      MULTIPLYING_NODE_TYPES.each do |type|
+        define_method "evaluate_end_#{type}" do |node|
+          leave_multiplying_conditional
+        end
+      end
+
+      ADDING_NODE_TYPES.each do |type|
+        define_method "evaluate_end_#{type}" do |node|
+          leave_multiplying_conditional
+        end
+      end
+      
+      protected
+      
+      def push_value
+        @value_stack.push @current_value
+        @current_value = 1
+      end
+
+      def leave_multiplying_conditional
+        pop = @value_stack.pop
+        @current_value = (@current_value + 1) * pop
+      end
+      
+      def leave_adding_conditional
+        pop = @value_stack.pop
+        puts "#{type}, so adding #{pop}"
+        @current_value = @current_value - 1 + pop
+      end
+    end
+  end
+end

data/lib/roodi/checks/npath_complexity_method_check.rb

@@ -0,0 +1,28 @@
+require 'roodi/checks/npath_complexity_check'
+
+module Roodi
+  module Checks
+    # Checks Npath complexity of a method against a specified limit. 
+    class NpathComplexityMethodCheck < NpathComplexityCheck
+      DEFAULT_COMPLEXITY = 8
+      
+      def initialize(options = {})
+        complexity = options['complexity'] || DEFAULT_COMPLEXITY
+        super(complexity)
+      end
+      
+      def interesting_nodes
+        [:defn] + COMPLEXITY_NODE_TYPES
+      end
+
+      def evaluate_start_defn(node)
+        @method_name = @node[1]
+        push_value
+      end
+
+      def evaluate_end_defn(node)
+        add_error "Method name \"#{@method_name}\" n-path complexity is #{@current_value}.  It should be #{@complexity} or less." unless @current_value <= @complexity
+      end
+    end
+  end
+end

data/lib/roodi/checks/parameter_number_check.rb

@@ -0,0 +1,30 @@
+require 'roodi/checks/check'
+
+module Roodi
+  module Checks
+    # Checks a method to make sure the number of parameters it has is under the specified limit.
+    # 
+    # A method taking too many parameters is a code smell that indicates it might be doing too 
+    # much, or that the parameters should be grouped into one or more objects of their own.  It
+    # probably needs some refactoring. 
+    class ParameterNumberCheck < Check
+      DEFAULT_PARAMETER_COUNT = 5
+      
+      def initialize(options = {})
+        super()
+        @parameter_count = options['parameter_count'] || DEFAULT_PARAMETER_COUNT
+      end
+      
+      def interesting_nodes
+        [:defn]
+      end
+
+      def evaluate_start(node)
+        method_name = node[1]
+        arguments = node[2]
+        parameter_count = arguments.inject(-1) { |count, each| count = count + (each.class == Symbol ? 1 : 0) }
+        add_error "Method name \"#{method_name}\" has #{parameter_count} parameters.  It should have #{@parameter_count} or less." unless parameter_count <= @parameter_count
+      end
+    end
+  end
+end

data/lib/roodi/checks.rb

@@ -0,0 +1,18 @@
+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/missing_foreign_key_index_check'
+require 'roodi/checks/module_line_count_check'
+require 'roodi/checks/module_name_check'
+require 'roodi/checks/npath_complexity_method_check'
+require 'roodi/checks/parameter_number_check'

data/lib/roodi/core/checking_visitor.rb

@@ -0,0 +1,26 @@
+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)
+        checks = @checks[node.node_type]
+        checks.each {|check| check.evaluate_node_start(node)} unless checks.nil?
+
+        node.visitable_children.each {|sexp| sexp.accept(self)}
+
+        checks.each {|check| check.evaluate_node_end(node)} unless checks.nil?
+      end
+    end
+  end
+end

data/lib/roodi/core/error.rb

@@ -0,0 +1,17 @@
+module Roodi
+  module Core
+    class Error
+      attr_reader :filename, :line_number, :message
+      
+      def initialize(filename, line_number, message)
+        @filename = filename
+        @line_number = line_number
+        @message = message
+      end
+      
+      def to_s
+        "#{@filename}:#{@line_number} - #{@message}"
+      end
+    end
+  end
+end

data/lib/roodi/core/parser.rb

@@ -0,0 +1,30 @@
+require 'rubygems'
+require 'ruby_parser'
+
+module Roodi
+  module Core
+    class Parser
+      def parse(content, filename)
+        silence_stream(STDERR) do 
+          return silent_parse(content, filename)
+        end
+      end
+      
+      private
+      
+      def silence_stream(stream)
+        old_stream = stream.dup
+        stream.reopen(RUBY_PLATFORM =~ /mswin/ ? 'NUL:' : '/dev/null')
+        stream.sync = true
+        yield
+      ensure
+        stream.reopen(old_stream)
+      end
+      
+      def silent_parse(content, filename)
+        @parser ||= RubyParser.new
+        @parser.parse(content, filename)
+      end
+    end
+  end
+end

data/lib/roodi/core/runner.rb

@@ -0,0 +1,80 @@
+require 'pp'
+require 'yaml'
+
+require 'roodi/core/checking_visitor'
+require 'roodi/core/parser'
+require 'roodi/core/visitable_sexp'
+
+module Roodi
+  module Core
+    class Runner
+      DEFAULT_CONFIG = File.join(File.dirname(__FILE__), "..", "..", "..", "roodi.yml")
+      
+      attr_writer :config
+      
+      def initialize(*checks)
+        @config = DEFAULT_CONFIG
+        @checks = checks unless checks.empty?
+        @parser = Parser.new
+      end
+      
+      def check(filename, content)
+        @checks ||= load_checks
+        @checker ||= CheckingVisitor.new(@checks)
+        @checks.each {|check| check.start_file(filename)}
+        node = parse(filename, content)
+        node.accept(@checker) if node
+        @checks.each {|check| check.end_file(filename)}
+      end
+
+      def check_content(content, filename = "dummy-file.rb")
+        check(filename, content)
+      end
+  
+      def check_file(filename)
+        check(filename, File.read(filename))
+      end
+  
+      def print(filename, content)
+        node = @parser.parse(content, filename)
+        puts "Line: #{node.line}"
+        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 parse(filename, content)
+        begin
+          @parser.parse(content, filename)
+        rescue Exception => e
+          puts "#{filename} looks like it's not a valid Ruby file.  Skipping..." if ENV["ROODI_DEBUG"]
+          nil
+        end
+      end
+
+      def load_checks
+        check_objects = []
+        checks = YAML.load_file @config
+        checks.each do |check| 
+          klass = eval("Roodi::Checks::#{check[0]}")
+          check_objects << (check[1].empty? ? klass.new : klass.new(check[1]))
+        end
+        check_objects
+      end
+    end
+  end
+end