reek 1.1.3 → 1.2.0

data/lib/reek/smells/long_method.rb

@@ -16,27 +16,29 @@ module Reek
       # statements permitted in any method.
       MAX_ALLOWED_STATEMENTS_KEY = 'max_statements'
 
+      DEFAULT_MAX_STATEMENTS = 5
+
       def self.default_config
         super.adopt(
-          MAX_ALLOWED_STATEMENTS_KEY => 5,
+          MAX_ALLOWED_STATEMENTS_KEY => DEFAULT_MAX_STATEMENTS,
           EXCLUDE_KEY => ['initialize']
         )
       end
 
+      attr_reader :max_statements
+
       def initialize(config = LongMethod.default_config)
-        super
-        @max_statements = config[MAX_ALLOWED_STATEMENTS_KEY]
+        super(config)
       end
 
       #
       # Checks the length of the given +method+.
-      # Any smells found are added to the +report+.
+      # Remembers any smells found.
       #
-      def examine_context(method, report)
+      def examine_context(method)
         num = method.num_statements
-        return false if num <= @max_statements
-        report << SmellWarning.new(self, method,
-                    "has approx #{num} statements")
+        return false if num <= value(MAX_ALLOWED_STATEMENTS_KEY, method, DEFAULT_MAX_STATEMENTS)
+        found(method, "has approx #{num} statements")
       end
     end
   end

data/lib/reek/smells/long_parameter_list.rb

@@ -1,5 +1,4 @@
 require 'reek/smells/smell_detector'
-require 'reek/smell_warning'
 
 module Reek
   module Smells
@@ -18,25 +17,32 @@ module Reek
       # parameters permitted in any method or block.
       MAX_ALLOWED_PARAMS_KEY = 'max_params'
 
+      # The default value of the +MAX_ALLOWED_PARAMS_KEY+ configuration
+      # value.
+      DEFAULT_MAX_ALLOWED_PARAMS = 3
+
       def self.default_config
-        super.adopt(MAX_ALLOWED_PARAMS_KEY => 3)
+        super.adopt(
+          MAX_ALLOWED_PARAMS_KEY => DEFAULT_MAX_ALLOWED_PARAMS,
+          SmellConfiguration::OVERRIDES_KEY => {
+            "initialize" => {MAX_ALLOWED_PARAMS_KEY => 5}
+            }
+        )
       end
 
-      def initialize(config)
-        super
-        @max_params = config['max_params']
+      def initialize(config = LongParameterList.default_config)
+        super(config)
         @action = 'has'
       end
 
       #
       # Checks the number of parameters in the given scope.
-      # Any smells found are added to the +report+.
+      # Remembers any smells found.
       #
-      def examine_context(ctx, report)
+      def examine_context(ctx)
         num_params = ctx.parameters.length
-        return false if num_params <= @max_params
-        report << SmellWarning.new(self, ctx,
-                    "#{@action} #{num_params} parameters")
+        return false if num_params <= value(MAX_ALLOWED_PARAMS_KEY, ctx, DEFAULT_MAX_ALLOWED_PARAMS)
+        found(ctx, "#{@action} #{num_params} parameters")
       end
     end
   end

data/lib/reek/smells/long_yield_list.rb

@@ -9,7 +9,7 @@ module Reek
         [:yield]
       end
 
-      def initialize(config)
+      def initialize(config = LongYieldList.default_config)
         super
         @action = 'yields'
       end

data/lib/reek/smells/nested_iterators.rb

@@ -17,11 +17,11 @@ module Reek
 
       #
       # Checks whether the given +block+ is inside another.
-      # Any smells found are added to the +report+.
+      # Remembers any smells found.
       #
-      def examine_context(block, report)
+      def examine_context(block)
         return false unless block.nested_block?
-        report << SmellWarning.new(self, block, 'is nested')
+        found(block, 'is nested')
       end
     end
   end

data/lib/reek/smells/simulated_polymorphism.rb

@@ -0,0 +1,58 @@
+require 'reek/smells/smell_detector'
+require 'reek/smell_warning'
+require 'reek/sexp_formatter'
+
+module Reek
+  module Smells
+
+    #
+    # Simulated Polymorphism occurs when
+    # * code uses a case statement (especially on a type field);
+    # * or code has several if statements in a row (especially if they're comparing against the same value);
+    # * or code uses instance_of?, kind_of?, is_a?, or === to decide what type it's working with;
+    # * or multiple conditionals in different places test the same value.
+    #
+    # Conditional code is hard to read and understand, because the reader must
+    # hold more state in his head.
+    # When the same value is tested in multiple places throughout an application,
+    # any change to the set of possible values will require many methods and
+    # 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
+    # testing the same value throughout a single class.
+    #
+    class SimulatedPolymorphism < SmellDetector
+
+      def self.contexts      # :nodoc:
+        [:class]
+      end
+
+      # The name of the config field that sets the maximum number of
+      # identical conditionals permitted within any single class.
+      MAX_IDENTICAL_IFS_KEY = 'max_ifs'
+
+      DEFAULT_MAX_IFS = 2
+
+      def self.default_config
+        super.adopt(MAX_IDENTICAL_IFS_KEY => DEFAULT_MAX_IFS)
+      end
+
+      def initialize(config = SimulatedPolymorphism.default_config)
+        super(config)
+      end
+
+      #
+      # Checks the given ClassContext for multiple identical conditional tests.
+      # Remembers any smells found.
+      #
+      def examine_context(klass)
+        counts = Hash.new(0)
+        klass.conditionals.each {|cond| counts[cond] += 1}
+        counts.each do |key, val|
+          found(klass, "tests #{SexpFormatter.format(key)} at least #{val} times") if val > value(MAX_IDENTICAL_IFS_KEY, klass, DEFAULT_MAX_IFS)
+        end
+      end
+    end
+  end
+end

data/lib/reek/smells/smell_detector.rb

@@ -1,3 +1,5 @@
+require 'reek/configuration'
+
 class Class
   def name_words
     class_name = name.split(/::/)[-1]
@@ -15,52 +17,117 @@ module Reek
       # smell that should ignore this code element.
       EXCLUDE_KEY = 'exclude'
 
-      # The name fo the config field that specifies whether a smell is
-      # enabled. Set to +true+ or +false+.
-      ENABLED_KEY = 'enabled'
-      
-      def self.class_name
-        self.name.split(/::/)[-1]
+      # The default value for the +EXCLUDE_KEY+ if it isn't specified
+      # in any configuration file.
+      DEFAULT_EXCLUDE_SET = []
+
+      class << self
+        def class_name
+          self.name.split(/::/)[-1]
+        end
+
+        def contexts      # :nodoc:
+          [:defn, :defs]
+        end
+
+        def default_config
+          {
+            SmellConfiguration::ENABLED_KEY => true,
+            EXCLUDE_KEY => DEFAULT_EXCLUDE_SET
+          }
+        end
+
+        def create(config)
+          new(config[class_name])
+        end
+
+        def listen(hooks, config)
+          detector = create(config)
+          detector.listen_to(hooks)
+          detector
+        end
       end
 
-      def self.contexts      # :nodoc:
-        [:defn, :defs]
+      def initialize(config = self.class.default_config)
+        @config = SmellConfiguration.new(config)
+        @smells_found = Set.new
+        @masked = false
       end
-      
-      def self.default_config
-        {
-          ENABLED_KEY => true,
-          EXCLUDE_KEY => []
-        }
+
+      def listen_to(hooks)
+        self.class.contexts.each { |ctx| hooks[ctx] << self }
+      end
+
+      # SMELL: Getter (only used in 1 test)
+      def enabled?
+        @config.enabled?
       end
 
-      def self.listen(hooks, config)
-        detector = new(config[class_name])
-        contexts.each { |ctx| hooks[ctx] << detector }
+      def configure(config)
+        my_part = config[self.class.name.split(/::/)[-1]]
+        return unless my_part
+        configure_with(my_part)
       end
 
-      def initialize(config)
-        @enabled = config[ENABLED_KEY]
-        @exceptions = config[EXCLUDE_KEY]
+      def configure_with(config)
+        @config.hash.adopt!(config)
       end
 
-      def examine(context, report)
-        before = report.size
-        examine_context(context, report) if @enabled and !exception?(context)
-        report.length > before
+      def copy
+        self.class.new(@config.hash.deep_copy)
       end
 
-      def examine_context(context, report)
+      def supersede_with(config)
+        clone = self.copy
+        @masked = true
+        clone.configure_with(config)
+        clone
+      end
+
+      def examine(context)
+        before = @smells_found.size
+        examine_context(context) if @config.enabled? and !exception?(context)
+        @smells_found.length > before
+      end
+
+      def examine_context(context)
       end
       
       def exception?(context)
-        return false if @exceptions.nil? or @exceptions.length == 0
-        context.matches?(@exceptions)
+        context.matches?(value(EXCLUDE_KEY, context, DEFAULT_EXCLUDE_SET))
+      end
+
+      def found(scope, warning)
+        smell = SmellWarning.new(self, scope, warning, @masked)
+        @smells_found << smell
+        smell
+      end
+
+      def has_smell?(patterns)
+        return false if @masked
+        @smells_found.each { |warning| return true if warning.contains_all?(patterns) }
+        false
+      end
+
+      def report_on(report)
+        @smells_found.each { |smell| smell.report_on(report) }
+      end
+
+      def num_smells
+        @masked ? 0 : @smells_found.length
+      end
+
+      def smelly?
+        (not @masked) and (@smells_found.length > 0)
       end
 
       def smell_name
         self.class.name_words.join(' ')
       end
+
+      def value(key, ctx, fall_back)
+        @config.value(key, ctx, fall_back)
+      end
     end
   end
 end

data/lib/reek/smells/uncommunicative_name.rb

@@ -15,23 +15,27 @@ module Reek
     #
     # Currently +UncommunicativeName+ checks for
     # * 1-character names
-    # * names consisting of a single character followed by a number
+    # * names ending with a number
     #
     class UncommunicativeName < SmellDetector
 
       # The name of the config field that lists the regexps of
-      # smelly names to be rejected.
+      # smelly names to be reported.
       REJECT_KEY = 'reject'
+
+      DEFAULT_REJECT_SET = [/^.$/, /[0-9]$/]
       
       # The name of the config field that lists the specific names that are
       # to be treated as exceptions; these names will not be reported as
       # uncommunicative.
       ACCEPT_KEY = 'accept'
 
+      DEFAULT_ACCEPT_SET = ['Inline::C']
+
       def self.default_config
         super.adopt(
-          REJECT_KEY => [/^.[0-9]*$/],
-          ACCEPT_KEY => ['Inline::C']
+          REJECT_KEY => DEFAULT_REJECT_SET,
+          ACCEPT_KEY => DEFAULT_ACCEPT_SET
         )
       end
 
@@ -40,40 +44,36 @@ module Reek
       end
 
       def initialize(config = UncommunicativeName.default_config)
-        super
-        @reject = config[REJECT_KEY]
-        @accept = config[ACCEPT_KEY]
+        super(config)
       end
 
       #
       # Checks the given +context+ for uncommunicative names.
-      # Any smells found are added to the +report+.
+      # Remembers any smells found.
       #
-      def examine_context(context, report)
-        consider_name(context, report)
-        consider_variables(context, report)
+      def examine_context(context)
+        consider_name(context)
+        consider_variables(context)
       end
 
-      def consider_variables(context, report) # :nodoc:
+      def consider_variables(context) # :nodoc:
         context.variable_names.each do |name|
-          next unless is_bad_name?(name)
-          report << SmellWarning.new(self, context,
-                      "has the variable name '#{name}'")
+          next unless is_bad_name?(name, context)
+          found(context, "has the variable name '#{name}'")
         end
       end
 
-      def consider_name(context, report)  # :nodoc:
+      def consider_name(context)  # :nodoc:
         name = context.name
-        return false if @accept.include?(context.to_s)  # TODO: fq_name() ?
-        return false unless is_bad_name?(name)
-        report << SmellWarning.new(self, context,
-                      "has the name '#{name}'")
+        return false if value(ACCEPT_KEY, context, DEFAULT_ACCEPT_SET).include?(context.to_s)  # TODO: fq_name() ?
+        return false unless is_bad_name?(name, context)
+        found(context, "has the name '#{name}'")
       end
 
-      def is_bad_name?(name)  # :nodoc:
+      def is_bad_name?(name, context)  # :nodoc:
         var = name.effective_name
-        return false if var == '*' or @accept.include?(var)
-        @reject.detect {|patt| patt === var}
+        return false if var == '*' or value(ACCEPT_KEY, context, DEFAULT_ACCEPT_SET).include?(var)
+        value(REJECT_KEY, context, DEFAULT_REJECT_SET).detect {|patt| patt === var}
       end
     end
   end

data/lib/reek/smells/utility_function.rb

@@ -10,24 +10,40 @@ module Reek
     # 
     # Currently +UtilityFunction+ will warn about any method that:
     # 
-    # * is non-empty
-    # * does not override an inherited method
-    # * calls at least one method on another object
-    # * doesn't use any of self's instance variables
+    # * is non-empty, and
+    # * does not override an inherited method, and
+    # * calls at least one method on another object, and
+    # * doesn't use any of self's instance variables, and
     # * doesn't use any of self's methods
     #
     class UtilityFunction < SmellDetector
 
+      # The name of the config field that sets the maximum number of
+      # calls permitted within a helper method. Any method with more than
+      # this number of method calls on other objects will be considered a
+      # candidate Utility Function.
+      HELPER_CALLS_LIMIT_KEY = 'max_helper_calls'
+
+      DEFAULT_HELPER_CALLS_LIMIT = 1
+
+      def self.default_config
+        super.adopt(HELPER_CALLS_LIMIT_KEY => DEFAULT_HELPER_CALLS_LIMIT)
+      end
+
+      def initialize(config = Duplication.default_config)
+        super(config)
+      end
+
       #
       # Checks whether the given +method+ is a utility function.
-      # Any smells found are added to the +report+.
+      # Remembers any smells found.
       #
-      def examine_context(method, report)
-        return false if method.calls.keys.length == 0 or
-          method.num_statements == 0 or
-          method.depends_on_instance?
-        report << SmellWarning.new(self, method,
-                      "doesn't depend on instance state")
+      def examine_context(method)
+        return false if method.num_statements == 0 or
+          method.depends_on_instance? or
+          method.calls.keys.length <= value(HELPER_CALLS_LIMIT_KEY, method, DEFAULT_HELPER_CALLS_LIMIT)
+          # SMELL: loads of calls to value{} with the above pattern
+        found(method, "doesn't depend on instance state")
       end
     end
   end