simplabs-excellent 1.0.1 → 1.2.1

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

@@ -6,20 +6,23 @@ module Simplabs
 
     module Checks
 
+      # This check reports methods that check the value of a parameter to decide which execution path to take. Control Coupling introduces a
+      # dependency between the caller and the callee. Any changes to the possible values of the parameter must be reflected at the caller side
+      # as well as at the called method.
+      #
+      # ==== Applies to
+      #
+      # * methods
       class ControlCouplingCheck < Base
 
-        def interesting_nodes
-          [:defn, :lvar]
+        def initialize #:nodoc:
+          super
+          @interesting_nodes = [:if, :case]
         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)
+        def evaluate(context) #:nodoc:
+          if tested_parameter = context.tests_parameter?
+            add_warning(context, '{{method}} is coupled to {{argument}}.', { :method => context.parent.full_name, :argument => tested_parameter.to_s }, -2)
           end
         end
 

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

@@ -6,21 +6,37 @@ module Simplabs
 
     module Checks
 
+      # This check reports blocks with a cyclomatic complexity metric score that is higher than the threshold. The cyclomatic complexity metric counts
+      # the number of linearly independent paths through the code. This is basically the number of the following statements + 1:
+      #
+      # * +if+
+      # * +else+
+      # * +unless+
+      # * +while+
+      # * +until+
+      # * +for+
+      # * +rescue+
+      # * +case+
+      # * +when+
+      # * +and+
+      # * +or+
+      #
+      # ==== Applies to
+      #
+      # * blocks
       class CyclomaticComplexityBlockCheck < CyclomaticComplexityCheck
 
         DEFAULT_THRESHOLD = 4
       
-        def initialize(options = {})
-          super(options[:threshold] || DEFAULT_THRESHOLD)
+        def initialize(options = {}) #:nodoc:
+          threshold = options[:threshold] || DEFAULT_THRESHOLD
+          super([:iter], 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
+        def evaluate(context) #:nodoc:
+          unless context.cc_score <= @threshold
+            add_warning(context, '{{block}} has cyclomatic complexity of {{score}}.', { :block => context.full_name, :score => context.cc_score })
+          end
         end
 
       end

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

@@ -6,30 +6,14 @@ module Simplabs
 
     module Checks
 
-      class CyclomaticComplexityCheck < Base
+      class CyclomaticComplexityCheck < Base #:nodoc:
 
-        COMPLEXITY_NODE_TYPES = [:if, :while, :until, :for, :rescue, :case, :when, :and, :or]
-
-        def initialize(threshold)
+        def initialize(interesting_nodes, threshold)
           super()
-          @threshold = threshold
+          @interesting_nodes = interesting_nodes
+          @threshold         = threshold
         end
 
-        protected
-
-          def count_complexity(node)
-            count_branches(node) + 1
-          end
-
-        private
-
-          def count_branches(node)
-            count = 0
-            count = count + 1 if COMPLEXITY_NODE_TYPES.include? node.node_type
-            node.children.each { |child| count += count_branches(child) }
-            count
-          end
-
       end
 
     end

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

@@ -6,22 +6,37 @@ module Simplabs
 
     module Checks
 
+      # This check reports methods with a cyclomatic complexity metric score that is higher than the threshold. The cyclomatic complexity metric counts
+      # the number of linearly independent paths through the code. This is basically the number of the following statements + 1:
+      #
+      # * +if+
+      # * +else+
+      # * unless
+      # * +while+
+      # * +until+
+      # * +for+
+      # * +rescue+
+      # * +case+
+      # * +when+
+      # * +and+
+      # * +or+
+      #
+      # ==== Applies to
+      #
+      # * methods
       class CyclomaticComplexityMethodCheck < CyclomaticComplexityCheck
 
         DEFAULT_THRESHOLD = 8
 
-        def initialize(options = {})
-          complexity = options[:threshold] || DEFAULT_THRESHOLD
-          super(complexity)
+        def initialize(options = {}) #:nodoc:
+          threshold = options[:threshold] || DEFAULT_THRESHOLD
+          super([:defn, :defs], threshold)
         end
 
-        def interesting_nodes
-          [:defn]
-        end
-
-        def evaluate(node)
-          score = count_complexity(node)
-          add_error('Method {{method}} has cyclomatic complexity of {{score}}.', { :method => node[1], :score => score }) unless score <= @threshold
+        def evaluate(context) #:nodoc:
+          unless context.cc_score <= @threshold
+            add_warning(context, '{{method}} has cyclomatic complexity of {{score}}.', { :method => context.full_name, :score => context.cc_score })
+          end
         end
 
       end

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

@@ -0,0 +1,50 @@
+require 'simplabs/excellent/checks/base'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      # This check reports duplicated code. It currently finds repeated identical method calls such as:
+      #
+      #  def method
+      #    other_method + other_method
+      #  end
+      #
+      # ==== Applies to
+      #
+      # * methods
+      # * blocks
+      class DuplicationCheck < Base
+
+        DEFAULT_THRESHOLD = 1
+
+        def initialize(options = {}) #:nodoc:
+          super()
+          @threshold         = options[:threshold] || DEFAULT_THRESHOLD
+          @interesting_nodes = [:defn, :defs, :iter]
+        end
+
+        def evaluate(context) #:nodoc:
+          context.calls.each do |call, number|
+            if number > @threshold && call.method != 'new'
+              add_warning(
+                context,
+                '{{method}} calls {{statement}} {{duplication_number}} times.', {
+                  :method             => context.full_name,
+                  :statement          => call.full_name,
+                  :duplication_number => number
+                }
+              )
+            end
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -6,30 +6,22 @@ module Simplabs
 
     module Checks
 
+      # This check reports empty +rescue+ blocks. Empty +rescue+ blocks suppress all errors which is usually not a good technique.
+      #
+      # ==== Applies to
+      #
+      # * +rescue+ blocks
       class EmptyRescueBodyCheck < Base
 
-        STATEMENT_NODES = [:fcall, :return, :attrasgn, :vcall, :call, :str, :lit]
-
-        def interesting_nodes
-          [:resbody]
+        def initialize #:nodoc:
+          super
+          @interesting_nodes = [:resbody]
         end
 
-        def evaluate(node)
-          add_error('Rescue block is empty.', {}, -1) unless has_statement?(node)
+        def evaluate(context) #:nodoc:
+          add_warning(context, 'Rescue block is empty.', {}, -1) unless context.has_statements?
         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

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

@@ -0,0 +1,40 @@
+require 'simplabs/excellent/checks/flog_check'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      # This check reports blocks with a Flog metric score that is higher than the threshold. The Flog metric is very similar to the cyclomatic complexity
+      # measure but also takes Ruby specific statements into account. For example, calls to metaprogramming methods such as +define_method+ or
+      # +class_eval+ are weighted higher than regular method calls.
+      #
+      # Excellent does not calculate the score exactly the same way as Flog does, so scores may vary. For Flog also see
+      # http://github.com/seattlerb/flog.
+      #
+      # ==== Applies to
+      #
+      # * blocks
+      class FlogBlockCheck < FlogCheck
+
+        DEFAULT_THRESHOLD = 15
+
+        def initialize(options = {}) #:nodoc:
+          threshold = options[:threshold] || DEFAULT_THRESHOLD
+          super([:iter], threshold)
+        end
+
+        protected
+
+          def warning_args(context) #:nodoc:
+            [context, '{{block}} has flog score of {{score}}.', { :block => context.full_name, :score => context.flog_score }]
+          end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,27 @@
+require 'simplabs/excellent/checks/base'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      class FlogCheck < Base #:nodoc:
+
+        def initialize(interesting_nodes, threshold)
+          super()
+          @interesting_nodes = interesting_nodes
+          @threshold         = threshold
+        end
+
+        def evaluate(context)
+          add_warning(*warning_args(context)) unless context.flog_score <= @threshold
+        end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,40 @@
+require 'simplabs/excellent/checks/flog_check'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      # This check reports classes with a Flog metric score that is higher than the threshold. The Flog metric is very similar to the cyclomatic complexity
+      # measure but also takes Ruby specific statements into account. For example, calls to metaprogramming methods such as +define_method+ or
+      # +class_eval+ are weighted higher than regular method calls.
+      #
+      # Excellent does not calculate the score exactly the same way as Flog does, so scores may vary. For Flog also see
+      # http://github.com/seattlerb/flog.
+      #
+      # ==== Applies to
+      #
+      # * classes
+      class FlogClassCheck < FlogCheck
+
+        DEFAULT_THRESHOLD = 300
+
+        def initialize(options = {}) #:nodoc:
+          threshold = options[:threshold] || DEFAULT_THRESHOLD
+          super([:class], threshold)
+        end
+
+        protected
+
+          def warning_args(context) #:nodoc:
+            [context, '{{class}} has flog score of {{score}}.', { :class => context.full_name, :score => context.flog_score }]
+          end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,40 @@
+require 'simplabs/excellent/checks/flog_check'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      # This check reports methods with a Flog metric score that is higher than the threshold. The Flog metric is very similar to the cyclomatic complexity
+      # measure but also takes Ruby specific statements into account. For example, calls to metaprogramming methods such as +define_method+ or
+      # +class_eval+ are weighted higher than regular method calls.
+      #
+      # Excellent does not calculate the score exactly the same way as Flog does, so scores may vary. For Flog also see
+      # http://github.com/seattlerb/flog.
+      #
+      # ==== Applies to
+      #
+      # * methods
+      class FlogMethodCheck < FlogCheck
+
+        DEFAULT_THRESHOLD = 30
+
+        def initialize(options = {}) #:nodoc:
+          threshold = options[:threshold] || DEFAULT_THRESHOLD
+          super([:defn, :defs], threshold)
+        end
+
+        protected
+
+          def warning_args(context) #:nodoc:
+            [context, '{{method}} has flog score of {{score}}.', { :method => context.full_name, :score => context.flog_score }]
+          end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -6,14 +6,30 @@ module Simplabs
 
     module Checks
 
+      # This check reports code that uses +for+ loops as in:
+      #
+      #  for user in @users
+      #    do_something(user)
+      #  end
+      #
+      # The use of for loops in Ruby is contrary to the language's basic concept of iterators. The above statement would better be written as:
+      #
+      #  @users.each do |user|
+      #    do_something(user)
+      #  end
+      #
+      # ==== Applies to
+      #
+      # * +for+ loops
       class ForLoopCheck < Base
 
-        def interesting_nodes
-          [:for]
+        def initialize #:nodoc:
+          super
+          @interesting_nodes = [:for]
         end
 
-        def evaluate(node)
-          add_error('For loop used.')
+        def evaluate(context) #:nodoc:
+          add_warning(context, 'For loop used.')
         end
 
       end