simplabs-excellent 1.0.0

data/History.txt

@@ -0,0 +1,3 @@
+= 1.0.0
+
+* this is basically just a custom version of roodi, converted to ruby_parser to be 1.9 safe

data/README.markdown

@@ -0,0 +1,30 @@
+simplabs-excellent
+==================
+
+Excellent is a source code analysis gem. It detects commonly regarded bad code snippets
+like empty rescue blocks etc.
+
+Installation
+------------
+
+    gem sources -a http://gems.github.com
+    sudo gem install simplabs-excellent
+
+Example
+-------
+
+To analyse all the models in your Rails application, just do
+
+    excellent "app/models/**/*.rb"
+
+in your RAILS_ROOT.
+
+Acknowledgements
+----------------
+
+Excellent is based on roodi by Marty Andrews. However, it will get more functionaliy than roodi in the future.
+
+Author
+------
+
+Copyright (c) 2009 Marco Otte-Witte (http://simplabs.com), released under the MIT license

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 1
+:minor: 0
+:patch: 0

data/bin/excellent

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/../lib"))
+
+require 'simplabs/excellent'
+require 'pathname'
+
+excellent = Simplabs::Excellent::Core::ParseTreeRunner.new
+
+ARGV.each do |arg|
+  Dir.glob(arg).each { |file| excellent.check_file(file) }
+end
+
+puts "\nExcellent found #{excellent.errors.size} errors.\n"
+excellent.errors.each do |error|
+  relative_path = Pathname.new(error.filename).relative_path_from(Pathname.new(File.dirname(__FILE__)))
+  puts "  * File #{relative_path}, line #{error.line_number}: #{error.message}"
+end
+puts ''
+
+exit 0

data/lib/simplabs/excellent.rb

@@ -0,0 +1,12 @@
+require 'simplabs/excellent/checks'
+require 'simplabs/excellent/core'
+require 'rubygems'
+require 'sexp'
+
+module Excellent
+
+  VERSION = '1.0.0'
+
+end
+
+Sexp.send(:include, Simplabs::Excellent::Core::VisitableSexp)

data/lib/simplabs/excellent/checks.rb

@@ -0,0 +1,16 @@
+require 'simplabs/excellent/checks/abc_metric_method_check'
+require 'simplabs/excellent/checks/assignment_in_conditional_check'
+require 'simplabs/excellent/checks/case_missing_else_check'
+require 'simplabs/excellent/checks/class_line_count_check'
+require 'simplabs/excellent/checks/class_name_check'
+require 'simplabs/excellent/checks/class_variable_check'
+require 'simplabs/excellent/checks/control_coupling_check'
+require 'simplabs/excellent/checks/cyclomatic_complexity_block_check'
+require 'simplabs/excellent/checks/cyclomatic_complexity_method_check'
+require 'simplabs/excellent/checks/empty_rescue_body_check'
+require 'simplabs/excellent/checks/for_loop_check'
+require 'simplabs/excellent/checks/method_line_count_check'
+require 'simplabs/excellent/checks/method_name_check'
+require 'simplabs/excellent/checks/module_line_count_check'
+require 'simplabs/excellent/checks/module_name_check'
+require 'simplabs/excellent/checks/parameter_number_check'

data/lib/simplabs/excellent/checks/abc_metric_method_check.rb

@@ -0,0 +1,80 @@
+require 'simplabs/excellent/checks/base'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      class AbcMetricMethodCheck < Base
+
+        ASSIGNMENTS       = [:lasgn]
+        BRANCHES          = [:vcall, :call]
+        CONDITIONS        = [:==, :<=, :>=, :<, :>]
+        OPERATORS         = [:*, :/, :%, :+, :<<, :>>, :&, :|, :^, :-, :**]
+        DEFAULT_THRESHOLD = 10
+
+        def initialize(options = {})
+          super()
+          @threshold = options[:threshold] || DEFAULT_THRESHOLD
+        end
+
+        def interesting_nodes
+          [:defn]
+        end
+
+        def evaluate(node)
+          method_name = node[1]
+          a = count_assignments(node)
+          b = count_branches(node)
+          c = count_conditionals(node)
+          score = Math.sqrt(a*a + b*b + c*c)
+          add_error('Method {{method}} has abc score of {{score}}.', { :method => method_name, :score => score }) unless score <= @threshold
+        end
+
+        private
+
+          def count_assignments(node)
+            count = 0
+            count = count + 1 if assignment?(node)
+            node.children.each { |node| count += count_assignments(node) }
+            count
+          end
+
+          def count_branches(node)
+            count = 0
+            count = count + 1 if branch?(node)
+            node.children.each { |node| count += count_branches(node) }
+            count
+          end
+
+          def count_conditionals(node)
+            count = 0
+            count = count + 1 if conditional?(node)
+            node.children.each { |node| count += count_conditionals(node) }
+            count
+          end
+
+          def assignment?(node)
+            ASSIGNMENTS.include?(node.node_type)
+          end
+
+          def branch?(node)
+            BRANCHES.include?(node.node_type) && !conditional?(node) && !operator?(node)
+          end
+
+          def conditional?(node)
+            (:call == node.node_type) && CONDITIONS.include?(node[2]) 
+          end
+
+          def operator?(node)
+            (:call == node.node_type) && OPERATORS.include?(node[2]) 
+          end      
+
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/checks/assignment_in_conditional_check.rb

@@ -0,0 +1,38 @@
+require 'simplabs/excellent/checks/base'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      class AssignmentInConditionalCheck < Base
+
+        def initialize(options = {})
+          super()
+        end
+
+        def interesting_nodes
+          [:if, :while, :until]
+        end
+
+        def evaluate(node)
+          add_error('Assignment in condition.') if has_assignment?(node[1])
+        end
+
+        private
+
+          def has_assignment?(node)
+            found_assignment = false
+            found_assignment = found_assignment || node.node_type == :lasgn
+            node.children.each { |child| found_assignment = found_assignment || has_assignment?(child) }
+            found_assignment
+          end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/checks/base.rb

@@ -0,0 +1,42 @@
+require 'simplabs/excellent/core/error'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      class Base
+
+        def initialize
+          @errors = []
+        end
+  
+        def position(offset = 0)
+          "#{@line[2]}:#{@line[1] + offset}"
+        end
+  
+        def evaluate_node(node)
+          @file = node.file
+          @line = node.line
+          eval_method = "evaluate_#{node.node_type}"
+          self.send(eval_method, node) if self.respond_to? eval_method
+          evaluate(node) if self.respond_to? :evaluate
+        end
+  
+        def add_error(message, info = {}, offset = 0)
+          klass = self.class
+          @errors << Simplabs::Excellent::Core::Error.new(klass, message, @file, @line + offset, info)
+        end
+  
+        def errors
+          @errors
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/checks/case_missing_else_check.rb

@@ -0,0 +1,25 @@
+require 'simplabs/excellent/checks/base'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      class CaseMissingElseCheck < Base
+
+        def interesting_nodes
+          [:case]
+        end
+  
+        def evaluate(node)
+          add_error('Case statement is missing else clause.') unless node.last
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/checks/class_line_count_check.rb

@@ -0,0 +1,34 @@
+require 'simplabs/excellent/checks/line_count_check'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      class ClassLineCountCheck < LineCountCheck
+
+        DEFAULT_THRESHOLD = 300
+
+        def initialize(options = {})
+          threshold = options[:threshold] || DEFAULT_THRESHOLD
+          super([:class], threshold)
+        end
+
+        protected
+
+          def node_to_count(node)
+            node[3]
+          end
+
+          def error_args(node, line_count)
+            ['Class {{class}} has {{count}} lines.', { :class => node[1], :count => line_count }]
+          end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/checks/class_name_check.rb

@@ -0,0 +1,37 @@
+require 'simplabs/excellent/checks/name_check'
+
+module Simplabs
+
+  module Excellent
+
+    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]{1}[a-zA-Z0-9]*$/
+      
+        def initialize(options = {})
+          pattern = options[:pattern] || DEFAULT_PATTERN
+          super([:class], pattern)
+        end
+      
+        def find_name(node)
+          node[1].class == Symbol ? node[1] : node[1].last
+        end
+
+        protected
+
+          def error_args(node)
+            ['Bad class name {{class}}.', { :class => node[1] }]
+          end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/checks/class_variable_check.rb

@@ -0,0 +1,25 @@
+require 'simplabs/excellent/checks/base'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      class ClassVariableCheck < Base
+
+        def interesting_nodes
+          [:cvar]
+        end
+
+        def evaluate(node)
+          add_error('Class variable {{variable}}.', { :variable => node.value }, -1)
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/checks/control_coupling_check.rb

@@ -0,0 +1,32 @@
+require 'simplabs/excellent/checks/base'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      class ControlCouplingCheck < Base
+
+        def interesting_nodes
+          [:defn, :lvar]
+        end
+
+        def evaluate_defn(node)
+          @method_name = node[1]
+          @arguments   = node[2][1..-1]
+        end
+
+        def evaluate_lvar(node)
+          if @arguments.detect { |argument| argument == node[1] }
+            add_error('Control of {{method}} is coupled to {{argument}}.', { :method => @method_name, :argument => node[1] }, -1)
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/simplabs/excellent/checks/cyclomatic_complexity_block_check.rb

@@ -0,0 +1,32 @@
+require 'simplabs/excellent/checks/cyclomatic_complexity_check'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      class CyclomaticComplexityBlockCheck < CyclomaticComplexityCheck
+
+        DEFAULT_THRESHOLD = 4
+      
+        def initialize(options = {})
+          super(options[:threshold] || DEFAULT_THRESHOLD)
+        end
+      
+        def interesting_nodes
+          [:iter]
+        end
+
+        def evaluate(node)
+          complexity = count_complexity(node)
+          add_error('Block has cyclomatic complexity of {{score}}.', { :score => complexity }, -(node.line - node[1].line)) unless complexity <= @threshold
+        end
+
+      end
+
+    end
+
+  end
+
+end