reek 1.3.1 → 1.3.2

data/lib/reek/smells/{duplication.rb → duplicate_method_call.rb}

@@ -1,5 +1,5 @@
-require File.join( File.dirname( File.expand_path(__FILE__)), 'smell_detector')
-require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'smell_warning')
+require 'reek/smells/smell_detector'
+require 'reek/smell_warning'
 
 module Reek
   module Smells
@@ -9,7 +9,7 @@ module Reek
     # or when two fragments of code have nearly identical effects
     # at some conceptual level.
     # 
-    # Currently +Duplication+ checks for repeated identical method calls
+    # +DuplicateMethodCall+ checks for repeated identical method calls
     # within any one method definition. For example, the following method
     # will report a warning:
     # 
@@ -17,10 +17,11 @@ module Reek
     #     @other.thing + @other.thing
     #   end
     #
-    class Duplication < SmellDetector
+    class DuplicateMethodCall < SmellDetector
+
+      SMELL_CLASS = 'Duplication'
+      SMELL_SUBCLASS = self.name.split(/::/)[-1]
 
-      SMELL_CLASS = self.name.split(/::/)[-1]
-      SMELL_SUBCLASS = 'DuplicateMethodCall'
       CALL_KEY = 'call'
       OCCURRENCES_KEY = 'occurrences'
 
@@ -44,10 +45,6 @@ module Reek
         )
       end
 
-      def initialize(source, config = Duplication.default_config)
-        super(source, config)
-      end
-
       #
       # Looks for duplicate calls within the body of the method +ctx+.
       #
@@ -76,12 +73,13 @@ module Reek
         result = Hash.new {|hash,key| hash[key] = []}
         method_ctx.local_nodes(:call) do |call_node|
           next if call_node.method_name == :new
+          next if call_node.receiver.nil? && call_node.args.empty?
           result[call_node].push(call_node)
         end
         method_ctx.local_nodes(:attrasgn) do |asgn_node|
           result[asgn_node].push(asgn_node) unless asgn_node.args.nil?
         end
-        result
+        result.to_a.sort_by {|call_exp, _| call_exp.format_ruby}
       end
 
       def allow_calls?(method)

data/lib/reek/smells/feature_envy.rb

@@ -1,5 +1,5 @@
-require File.join( File.dirname( File.expand_path(__FILE__)), 'smell_detector')
-require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'smell_warning')
+require 'reek/smells/smell_detector'
+require 'reek/smell_warning'
 
 module Reek
   module Smells

data/lib/reek/smells/irresponsible_module.rb

@@ -1,5 +1,6 @@
-require File.join( File.dirname( File.expand_path(__FILE__)), 'smell_detector')
-require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'source')
+require 'reek/smells/smell_detector'
+require 'reek/smell_warning'
+require 'reek/source/code_comment'
 
 module Reek
   module Smells

data/lib/reek/smells/long_parameter_list.rb

@@ -1,6 +1,6 @@
-require File.join( File.dirname( File.expand_path(__FILE__)), 'smell_detector')
-require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'smell_warning')
-require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'core', 'smell_configuration')
+require 'reek/smells/smell_detector'
+require 'reek/smell_warning'
+require 'reek/core/smell_configuration'
 
 module Reek
   module Smells
@@ -15,8 +15,8 @@ module Reek
     #
     class LongParameterList < SmellDetector
 
-      SMELL_CLASS = self.name.split(/::/)[-1]
-      SMELL_SUBCLASS = 'LongParameterList'
+      SMELL_CLASS = 'LongParameterList'
+      SMELL_SUBCLASS = self.name.split(/::/)[-1]
 
       PARAMETER_COUNT_KEY = 'parameter_count'
 
@@ -33,14 +33,10 @@ module Reek
           MAX_ALLOWED_PARAMS_KEY => DEFAULT_MAX_ALLOWED_PARAMS,
           Core::SmellConfiguration::OVERRIDES_KEY => {
             "initialize" => {MAX_ALLOWED_PARAMS_KEY => 5}
-            }
+          }
         )
       end
 
-      def initialize(source, config = LongParameterList.default_config)
-        super(source, config)
-      end
-
       #
       # Checks the number of parameters in the given method.
       #

data/lib/reek/smells/long_yield_list.rb

@@ -1,5 +1,5 @@
-require File.join( File.dirname( File.expand_path(__FILE__)), 'smell_detector')
-require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'smell_warning')
+require 'reek/smells/smell_detector'
+require 'reek/smell_warning'
 
 module Reek
   module Smells
@@ -10,8 +10,8 @@ module Reek
     #
     class LongYieldList < SmellDetector
 
-      SMELL_SUBCLASS = self.name.split(/::/)[-1]
       SMELL_CLASS = 'LongParameterList'
+      SMELL_SUBCLASS = self.name.split(/::/)[-1]
 
       # The name of the config field that sets the maximum number of
       # parameters permitted in any method or block.
@@ -25,14 +25,10 @@ module Reek
 
       def self.default_config
         super.adopt(
-                MAX_ALLOWED_PARAMS_KEY => DEFAULT_MAX_ALLOWED_PARAMS
+          MAX_ALLOWED_PARAMS_KEY => DEFAULT_MAX_ALLOWED_PARAMS
         )
       end
 
-      def initialize(source, config = LongYieldList.default_config)
-        super(source, config)
-      end
-
       #
       # Checks the number of parameters in the given scope.
       #

data/lib/reek/smells/nested_iterators.rb

@@ -1,5 +1,5 @@
-require File.join( File.dirname( File.expand_path(__FILE__)), 'smell_detector')
-require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'smell_warning')
+require 'reek/smells/smell_detector'
+require 'reek/smell_warning'
 
 module Reek
   module Smells
@@ -35,53 +35,59 @@ module Reek
         )
       end
 
-      def initialize(source, config = NestedIterators.default_config)
-        super(source, config)
-      end
-
       #
       # Checks whether the given +block+ is inside another.
       #
       # @return [Array<SmellWarning>]
       #
       def examine_context(ctx)
-        @ignore_iterators = value(IGNORE_ITERATORS_KEY, ctx, DEFAULT_IGNORE_ITERATORS)
-        @max_allowed_nesting = value(MAX_ALLOWED_NESTING_KEY, ctx, DEFAULT_MAX_ALLOWED_NESTING)
-        find_deepest_iterators(ctx).map do |iter|
-          depth = iter[1]
-          SmellWarning.new(SMELL_CLASS, ctx.full_name, [iter[0].line],
+        exp, depth = *find_deepest_iterator(ctx)
+
+        if depth && depth > value(MAX_ALLOWED_NESTING_KEY, ctx, DEFAULT_MAX_ALLOWED_NESTING)
+          smell = SmellWarning.new(SMELL_CLASS, ctx.full_name, [exp.line],
             "contains iterators nested #{depth} deep",
             @source, SMELL_SUBCLASS,
             {NESTING_DEPTH_KEY => depth})
+          [smell]
+        else
+          []
         end
         # BUG: no longer reports nesting outside methods (eg. in Optparse)
       end
 
     private
 
-      def find_deepest_iterators(ctx)
-        result = []
-        find_iters(ctx.exp, 1, result)
-        result.select {|item| item[1] > @max_allowed_nesting}
+      def find_deepest_iterator(ctx)
+        @ignore_iterators = value(IGNORE_ITERATORS_KEY, ctx, DEFAULT_IGNORE_ITERATORS)
+
+        find_iters(ctx.exp, 1).sort_by {|item| item[1]}.last
       end
 
-      def find_iters(exp, depth, result)
-        exp.each do |elem|
+      def find_iters(exp, depth)
+        exp.map do |elem|
           next unless Sexp === elem
           case elem.first
           when :iter
-            find_iters([elem.call], depth, result)
-            current = result.length
-            call = Source::SexpFormatter.format(elem.call)
-            ignored = @ignore_iterators.any? { |ignore| /#{ignore}/ === call }
-            find_iters([elem.block], depth + (ignored ? 0 : 1), result)
-            result << [elem, depth] if result.length == current unless ignored
+            find_iters_for_iter_node(elem, depth)
           when :class, :defn, :defs, :module
             next
           else
-            find_iters(elem, depth, result)
+            find_iters(elem, depth)
           end
-        end
+        end.flatten(1).compact
+      end
+
+      def find_iters_for_iter_node(exp, depth)
+        ignored = ignored_iterator? exp
+        result = find_iters([exp.call], depth) +
+          find_iters([exp.block], depth + (ignored ? 0 : 1))
+        result << [exp, depth] unless ignored
+        result
+      end
+
+      def ignored_iterator?(exp)
+        name = exp.call.method_name.to_s
+        @ignore_iterators.any? { |pattern| /#{pattern}/ === name }
       end
     end
   end

data/lib/reek/smells/nil_check.rb

@@ -1,17 +1,15 @@
-require File.join( File.dirname( File.expand_path(__FILE__)), 'smell_detector')
-require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'smell_warning')
+require 'reek/smells/smell_detector'
+require 'reek/smell_warning'
 
 module Reek
   module Smells
 
+    # Checking for nil is a special kind of type check, and therefore a case of
+    # SimulatedPolymorphism.
     class NilCheck < SmellDetector
 
-      SMELL_CLASS = 'NilCheck'
-      SMELL_SUBCLASS = SMELL_CLASS
-
-      def initialize(source, config = NilCheck.default_config)
-        super(source, config)
-      end
+      SMELL_CLASS = 'SimulatedPolymorphism'
+      SMELL_SUBCLASS = self.name.split(/::/)[-1]
 
       def examine_context(ctx)
 
@@ -23,9 +21,9 @@ module Reek
         smelly_nodes = smelly_calls + smelly_cases
 
         smelly_nodes.map do |node|
-          SmellWarning.new(SMELL_CLASS, ctx.full_name, node.line,
+          SmellWarning.new(SMELL_CLASS, ctx.full_name, Array(node.line),
                            "performs a nil-check.",
-                           @source, SMELL_SUBCLASS )
+                           @source, SMELL_SUBCLASS)
         end
       end
 
@@ -66,13 +64,14 @@ module Reek
 
       class CaseNodeFinder < NodeFinder
         CASE_NIL_NODE = Sexp.new(:array, SEXP_NIL)
+
         def initialize(ctx)
           super(ctx, :when)
-          end
+        end
 
         def smelly
           @nodes.select{ |when_node|
-            nil_chk?(when_node) 
+            nil_chk?(when_node)
           }
         end
 

data/lib/reek/smells/{simulated_polymorphism.rb → repeated_conditional.rb}

@@ -1,5 +1,5 @@
-require File.join( File.dirname( File.expand_path(__FILE__)), 'smell_detector')
-require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'smell_warning')
+require 'reek/smells/smell_detector'
+require 'reek/smell_warning'
 
 module Reek
   module Smells
@@ -18,13 +18,13 @@ module Reek
     # classes to change. Tests for the type of an object may indicate that the
     # abstraction represented by that type is not completely defined (or understood).
     #
-    # In the current implementation, Reek only checks for multiple conditionals
+    # +RepeatedConditional+ checks for multiple conditionals
     # testing the same value throughout a single class.
     #
-    class SimulatedPolymorphism < SmellDetector
+    class RepeatedConditional < SmellDetector
 
-      SMELL_CLASS = self.name.split(/::/)[-1]
-      SMELL_SUBCLASS = 'RepeatedConditional'
+      SMELL_CLASS = 'SimulatedPolymorphism'
+      SMELL_SUBCLASS = self.name.split(/::/)[-1]
 
       def self.contexts      # :nodoc:
         [:class]
@@ -40,10 +40,6 @@ module Reek
         super.adopt(MAX_IDENTICAL_IFS_KEY => DEFAULT_MAX_IFS)
       end
 
-      def initialize(source, config = SimulatedPolymorphism.default_config)
-        super(source, config)
-      end
-
       #
       # Checks the given class for multiple identical conditional tests.
       #

data/lib/reek/smells/smell_detector.rb

@@ -1,6 +1,6 @@
 require 'set'
-require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'smell_warning')
-require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'core', 'smell_configuration')
+require 'reek/smell_warning'
+require 'reek/core/smell_configuration'
 
 module Reek
   module Smells
@@ -9,9 +9,6 @@ module Reek
       def self.default_config
         super.adopt(EXCLUDE_KEY => ['initialize'])
       end
-      def initialize(source, config = self.class.default_config)
-        super(source, config)
-      end
     end
 
     #
@@ -36,7 +33,7 @@ module Reek
         def default_config
           {
             Core::SmellConfiguration::ENABLED_KEY => true,
-            EXCLUDE_KEY => DEFAULT_EXCLUDE_SET
+            EXCLUDE_KEY => DEFAULT_EXCLUDE_SET.dup
           }
         end
       end

data/lib/reek/smells/too_many_instance_variables.rb

@@ -0,0 +1,60 @@
+require 'reek/smells/smell_detector'
+require 'reek/smell_warning'
+
+module Reek
+  module Smells
+
+    #
+    # A Large Class is a class or module that has a large number of
+    # instance variables, methods or lines of code.
+    # 
+    # +TooManyInstanceVariables' reports classes having more than a
+    # configurable number of instance variables.
+    #
+    class TooManyInstanceVariables < SmellDetector
+
+      SMELL_CLASS = 'LargeClass'
+      SMELL_SUBCLASS = self.name.split(/::/)[-1]
+      IVAR_COUNT_KEY = 'ivar_count'
+
+      # The name of the config field that sets the maximum number of instance
+      # variables permitted in a class.
+      MAX_ALLOWED_IVARS_KEY = 'max_instance_variables'
+
+      DEFAULT_MAX_IVARS = 9
+
+      def self.contexts      # :nodoc:
+        [:class]
+      end
+
+      def self.default_config
+        super.adopt(
+          MAX_ALLOWED_IVARS_KEY => DEFAULT_MAX_IVARS,
+          EXCLUDE_KEY => []
+        )
+      end
+
+      #
+      # Checks +klass+ for too many instance variables.
+      #
+      # @return [Array<SmellWarning>]
+      #
+      def examine_context(ctx)
+        @max_allowed_ivars = value(MAX_ALLOWED_IVARS_KEY, ctx, DEFAULT_MAX_IVARS)
+        check_num_ivars(ctx)
+      end
+
+    private
+
+      def check_num_ivars(ctx)  # :nodoc:
+        count = ctx.local_nodes(:iasgn).map {|iasgn| iasgn[1]}.uniq.length
+        return [] if count <= @max_allowed_ivars
+        smell = SmellWarning.new(SMELL_CLASS, ctx.full_name, [ctx.exp.line],
+          "has at least #{count} instance variables",
+          @source, SMELL_SUBCLASS,
+          {IVAR_COUNT_KEY => count})
+        [smell]
+      end
+    end
+  end
+end

data/lib/reek/smells/too_many_methods.rb

@@ -0,0 +1,62 @@
+require 'reek/smells/smell_detector'
+require 'reek/smell_warning'
+
+module Reek
+  module Smells
+
+    #
+    # A Large Class is a class or module that has a large number of
+    # instance variables, methods or lines of code.
+    # 
+    # +TooManyMethods+ reports classes having more than a configurable number
+    # of methods. The method count includes public, protected and private
+    # methods, and excludes methods inherited from superclasses or included
+    # modules.
+    #
+    class TooManyMethods < SmellDetector
+
+      SMELL_CLASS = 'LargeClass'
+      SMELL_SUBCLASS = self.name.split(/::/)[-1]
+      METHOD_COUNT_KEY = 'method_count'
+
+      # The name of the config field that sets the maximum number of methods
+      # permitted in a class.
+      MAX_ALLOWED_METHODS_KEY = 'max_methods'
+
+      DEFAULT_MAX_METHODS = 25
+
+      def self.contexts      # :nodoc:
+        [:class]
+      end
+
+      def self.default_config
+        super.adopt(
+          MAX_ALLOWED_METHODS_KEY => DEFAULT_MAX_METHODS,
+          EXCLUDE_KEY => []
+        )
+      end
+
+      #
+      # Checks +ctx+ for too many methods
+      #
+      # @return [Array<SmellWarning>]
+      #
+      def examine_context(ctx)
+        @max_allowed_methods = value(MAX_ALLOWED_METHODS_KEY, ctx, DEFAULT_MAX_METHODS)
+        check_num_methods(ctx)
+      end
+
+    private
+
+      def check_num_methods(ctx)  # :nodoc:
+        actual = ctx.local_nodes(:defn).length
+        return [] if actual <= @max_allowed_methods
+        smell = SmellWarning.new(SMELL_CLASS, ctx.full_name, [ctx.exp.line],
+          "has at least #{actual} methods",
+          @source, SMELL_SUBCLASS,
+          {METHOD_COUNT_KEY => actual})
+        [smell]
+      end
+    end
+  end
+end