threedaymonk-roodi 1.3.8

data/lib/roodi/checks/cyclomatic_complexity_method_check.rb

@@ -0,0 +1,32 @@
+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]
+      end
+
+      def evaluate(node)
+        complexity = count_complexity(node)
+        add_error "Method name \"#{node[1]}\" cyclomatic complexity is #{complexity}.  It should be #{@complexity} or less." unless complexity <= @complexity
+      end
+    end
+  end
+end

data/lib/roodi/checks/empty_rescue_body_check.rb

@@ -0,0 +1,33 @@
+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]
+      
+      def interesting_nodes
+        [:resbody]
+      end
+
+      def evaluate(node)
+        add_error("Rescue block should not be empty.") unless has_statement?(node)
+      end
+  
+      private
+  
+      def has_statement?(node)
+        return true if STATEMENT_NODES.include?(node.node_type)
+        return true if assigning_other_than_exception_to_local_variable?(node) 
+        return true if node.children.any? { |child| has_statement?(child) }
+      end
+
+      def assigning_other_than_exception_to_local_variable?(node)
+        node.node_type == :lasgn && node[2].to_a != [:gvar, :$!]
+      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(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(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 - 2
+      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/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(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/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(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/core.rb

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

data/lib/roodi/core/checking_visitor.rb

@@ -0,0 +1,23 @@
+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(node)} unless checks.nil?
+        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/iterator_visitor.rb

@@ -0,0 +1,19 @@
+module Roodi
+  module Core
+    class IteratorVisitor
+    	def initialize(payload)
+      	@payload = payload
+    	end
+	
+    	def visit(visited)
+    		visited.accept(@payload)
+    		visitable_nodes = visited.is_language_node? ? visited.sexp_body : visited
+    		visitable_nodes.each do |child| 
+    		  if child.class == Sexp then
+      		  child.accept(self)
+    		  end
+  		  end
+    	end
+    end
+  end
+end

data/lib/roodi/core/parser.rb

@@ -0,0 +1,35 @@
+require 'rubygems'
+require 'ruby_parser'
+
+module Roodi
+  module Core
+    class Parser
+
+      def silence_stream(*streams)
+        on_hold = streams.collect{ |stream| stream.dup }
+        streams.each do |stream|
+          stream.reopen(RUBY_PLATFORM =~ /mswin/ ? 'NUL:' : '/dev/null')
+          stream.sync = true
+        end
+        yield
+      ensure
+        streams.each_with_index do |stream, i|
+          stream.reopen(on_hold[i])
+        end
+      end
+
+      def parse(content, filename)
+        silence_stream(STDERR) do
+          return silent_parse(content, filename)
+        end
+      end
+
+      private
+
+      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,78 @@
+require 'pp'
+require 'yaml'
+
+require 'roodi/core/checking_visitor'
+require 'roodi/core/iterator_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
+        node = parse(filename, content)
+        node.accept(IteratorVisitor.new(CheckingVisitor.new(@checks))) if node
+      end
+
+      def check_content(content)
+        check("dummy-file.rb", 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