excellent 1.5.4

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

@@ -0,0 +1,38 @@
+require 'simplabs/excellent/checks/name_check'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      # This check reports classes with bad names. Badly named classes make reading and understanding the code much harder. Class names regarded as bad
+      # are for example:
+      #
+      # * names that are not Pascal cased (camel cased, starting with an upper case letter)
+      #
+      # ==== Applies to
+      #
+      # * classes
+      class ClassNameCheck < NameCheck
+
+        DEFAULT_PATTERN = /^[A-Z]{1}[a-zA-Z0-9]*$/
+      
+        def initialize(options = {}) #:nodoc:
+          pattern = options[:pattern] || DEFAULT_PATTERN
+          super([:class], pattern)
+        end
+      
+        protected
+
+          def warning_args(context) #:nodoc:
+            [context, 'Bad class name {{class}}.', { :class => context.full_name }]
+          end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,35 @@
+require 'simplabs/excellent/checks/base'
+
+module Simplabs
+
+  module Excellent
+
+    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 initialize #:nodoc:
+          super
+          @interesting_nodes = [:if, :case]
+        end
+
+        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
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,48 @@
+require 'simplabs/excellent/checks/cyclomatic_complexity_check'
+
+module Simplabs
+
+  module Excellent
+
+    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 = {}) #:nodoc:
+          threshold = options[:threshold] || DEFAULT_THRESHOLD
+          super([:iter], threshold)
+        end
+      
+        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
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,23 @@
+require 'simplabs/excellent/checks/base'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      class CyclomaticComplexityCheck < Base #:nodoc:
+
+        def initialize(interesting_nodes, threshold)
+          super()
+          @interesting_nodes = interesting_nodes
+          @threshold         = threshold
+        end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,48 @@
+require 'simplabs/excellent/checks/cyclomatic_complexity_check'
+
+module Simplabs
+
+  module Excellent
+
+    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 = {}) #:nodoc:
+          threshold = options[:threshold] || DEFAULT_THRESHOLD
+          super([:defn, :defs], threshold)
+        end
+
+        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
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,31 @@
+require 'simplabs/excellent/checks/base'
+
+module Simplabs
+
+  module Excellent
+
+    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
+
+        def initialize #:nodoc:
+          super
+          @interesting_nodes = [:resbody]
+        end
+
+        def evaluate(context) #:nodoc:
+          add_warning(context, 'Rescue block is empty.', {}, -1) unless context.has_statements?
+        end
+
+      end
+
+    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

@@ -0,0 +1,42 @@
+require 'simplabs/excellent/checks/base'
+
+module Simplabs
+
+  module Excellent
+
+    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 initialize #:nodoc:
+          super
+          @interesting_nodes = [:for]
+          @interesting_files = [/\.rb$/, /\.erb$/]
+        end
+
+        def evaluate(context) #:nodoc:
+          add_warning(context, 'For loop used.')
+        end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,33 @@
+require 'simplabs/excellent/checks/base'
+
+module Simplabs
+
+  module Excellent
+
+    module Checks
+
+      # This check reports global variables. Global variables introduce strong dependencies between otherwise unrelated parts of code and their use is
+      # usually considered extremely bad style.
+      #
+      # ==== Applies to
+      #
+      # * global variables
+      class GlobalVariableCheck < Base
+
+        def initialize #:nodoc:
+          super
+          @interesting_nodes = [:gvar, :gasgn]
+          @interesting_files = [/\.rb$/, /\.erb$/]
+        end
+
+        def evaluate(context) #:nodoc:
+          add_warning(context, 'Global variable {{variable}} used.', { :variable => context.full_name })
+        end
+
+      end
+
+    end
+
+  end
+
+end