metric_fu-roodi 2.2.2 → 3.0.0

data/lib/roodi/checks/cyclomatic_complexity_method_check.rb

@@ -1,42 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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, :next]
-      
-      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

@@ -1,20 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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
-      rescue NoMethodError => e
-        if ENV['DEBUG'] =~ /true/i
-          STDERR.puts "!! line counting error #{e.message}\t #{node.inspect}"
-          STDERR.puts "!! Does the node have any lines?"
-        end
-        0
-      end
-
-    end
-  end
-end

data/lib/roodi/checks/method_line_count_check.rb

@@ -1,29 +0,0 @@
-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

data/lib/roodi/checks/method_name_check.rb

@@ -1,31 +0,0 @@
-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
-        super()
-        self.pattern = DEFAULT_PATTERN
-      end
-      
-      def interesting_nodes
-        [:defn]
-      end
-
-      def message_prefix
-        'Method'
-      end
-
-      def find_name(node)
-        node[1]
-      end
-
-    end
-  end
-end

data/lib/roodi/checks/missing_foreign_key_index_check.rb

@@ -1,99 +0,0 @@
-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
-        super()
-        @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

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

data/lib/roodi/checks/module_name_check.rb

@@ -1,31 +0,0 @@
-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
-        super()
-        self.pattern = DEFAULT_PATTERN
-      end
-
-      def interesting_nodes
-        [:module]
-      end
-
-      def message_prefix
-        '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

@@ -1,16 +0,0 @@
-require 'roodi/checks/check'
-
-module Roodi
-  module Checks
-    class NameCheck < Check
-
-      attr_accessor :pattern
-
-      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

@@ -1,75 +0,0 @@
-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
-
-      attr_accessor :complexity
-      
-      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

@@ -1,29 +0,0 @@
-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
-        super(DEFAULT_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