metric_fu-roodi 2.2.0

data/lib/roodi/checks/method_name_check.rb

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

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

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

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

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

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

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

data/lib/roodi/checks/parameter_number_check.rb

@@ -0,0 +1,34 @@
+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
+      
+      attr_accessor :parameter_count
+
+      def initialize
+        super()
+        self.parameter_count = DEFAULT_PARAMETER_COUNT
+      end
+      
+      def interesting_nodes
+        [:defn]
+      end
+
+      def evaluate_start(node)
+        method_name = node[1]
+        arguments = node[2]
+        actual_parameter_count = arguments.inject(-1) { |count, each| count = count + (each.class == Symbol ? 1 : 0) }
+        add_error "Method name \"#{method_name}\" has #{actual_parameter_count} parameters.  It should have #{@parameter_count} or less." unless actual_parameter_count <= @parameter_count
+      end
+
+    end
+  end
+end

data/lib/roodi/core.rb

@@ -0,0 +1 @@
+require 'roodi/core/runner'

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,81 @@
+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?
+      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)
+        return unless File.exists?(filename)
+        check(filename, File.read(filename))
+      end
+  
+      def print(filename, content)
+        node = parse(filename, content)
+        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.new.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_class_name, options|
+          check_class = Roodi::Checks.const_get(check_class_name)
+          check_objects << check_class.make(options || {})
+        end
+        check_objects
+      end
+
+    end
+  end
+end