reek 0.3.1 → 1.0.0

data/lib/reek/smells/long_method.rb

@@ -1,6 +1,5 @@
-$:.unshift File.dirname(__FILE__)
-
-require 'reek/smells/smell'
+require 'reek/smells/smell_detector'
+require 'reek/smell_warning'
 
 module Reek
   module Smells
@@ -9,27 +8,36 @@ module Reek
     # A Long Method is any method that has a large number of lines.
     #
     # Currently +LongMethod+ reports any method with more than
-    # +MAX_ALLOWED+ statements.
+    # 5 statements.
     #
-    class LongMethod < Smell
+    class LongMethod < SmellDetector
 
-      MAX_ALLOWED = 5
+      # The name of the config field that sets the maximum number of
+      # statements permitted in any method.
+      MAX_ALLOWED_STATEMENTS_KEY = 'max_statements'
 
-      def self.examine(method, report)
-        return if method.name == 'initialize'
-        num = method.num_statements
-        report << new(method, num) if num > MAX_ALLOWED
+      def self.default_config
+        super.adopt(
+          MAX_ALLOWED_STATEMENTS_KEY => 5,
+          EXCLUDE_KEY => ['initialize']
+        )
       end
 
-      def initialize(context, num)
-        super(context)
-        @num_stmts = num
+      def initialize(config = LongMethod.default_config)
+        super
+        @max_statements = config[MAX_ALLOWED_STATEMENTS_KEY]
       end
 
-      def detailed_report
-        "#{@context} has approx #{@num_stmts} statements"
+      #
+      # Checks the length of the given +method+.
+      # Any smells found are added to the +report+.
+      #
+      def examine_context(method, report)
+        num = method.num_statements
+        return false if num <= @max_statements
+        report << SmellWarning.new(self, method,
+                    "has approx #{num} statements")
       end
     end
-
   end
 end

data/lib/reek/smells/long_parameter_list.rb

@@ -1,6 +1,5 @@
-$:.unshift File.dirname(__FILE__)
-
-require 'reek/smells/smell'
+require 'reek/smells/smell_detector'
+require 'reek/smell_warning'
 
 module Reek
   module Smells
@@ -10,27 +9,35 @@ module Reek
     # or two parameters, or when a method yields more than one or
     # two objects to an associated block.
     #
-    # Currently +LongParameterList+ reports any method with more
-    # than +MAX_ALLOWED+ parameters.
+    # Currently +LongParameterList+ reports any method or block with too
+    # many parameters.
     #
-    class LongParameterList < Smell
-      MAX_ALLOWED = 3
+    class LongParameterList < SmellDetector
 
-      def self.count_parameters(exp)
-        result = exp.length - 1
-        result -= 1 if Array === exp[-1] and exp[-1][0] == :block
-        result
-      end
+      # The name of the config field that sets the maximum number of
+      # parameters permitted in any method or block.
+      MAX_ALLOWED_PARAMS_KEY = 'max_params'
 
-      def recognise?(args)
-        @num_params = LongParameterList.count_parameters(args)
-        @num_params > MAX_ALLOWED
+      def self.default_config
+        super.adopt(MAX_ALLOWED_PARAMS_KEY => 3)
       end
 
-      def detailed_report
-        "#{@context.to_s} has #{@num_params} parameters"
+      def initialize(config)
+        super
+        @max_params = config['max_params']
+        @action = 'has'
+      end
+      
+      #
+      # Checks the number of parameters in the given scope.
+      # Any smells found are added to the +report+.
+      #
+      def examine_context(ctx, report)
+        num_params = ctx.parameters.length
+        return false if num_params <= @max_params
+        report << SmellWarning.new(self, ctx,
+                    "#{@action} #{num_params} parameters")
       end
     end
-
   end
 end

data/lib/reek/smells/long_yield_list.rb

@@ -1,20 +1,18 @@
-$:.unshift File.dirname(__FILE__)
-
-require 'reek/smells/smell'
+require 'reek/smells/smell_detector'
 
 module Reek
   module Smells
 
     class LongYieldList < LongParameterList
-      def recognise?(args)
-        @num_params = args.length
-        Array === args and @num_params > MAX_ALLOWED
+
+      def self.contexts      # :nodoc:
+        [:yield]
       end
 
-      def detailed_report
-        "#{@context} yields #{@num_params} parameters"
+      def initialize(config)
+        super
+        @action = 'yields'
       end
     end
-
   end
 end

data/lib/reek/smells/nested_iterators.rb

@@ -1,6 +1,5 @@
-$:.unshift File.dirname(__FILE__)
-
-require 'reek/smells/smell'
+require 'reek/smells/smell_detector'
+require 'reek/smell_warning'
 
 module Reek
   module Smells
@@ -10,15 +9,20 @@ module Reek
     #
     # +NestedIterators+ reports failing methods only once.
     #
-    class NestedIterators < Smell
-      def recognise?(already_in_iter)
-        already_in_iter && @context
+    class NestedIterators < SmellDetector
+
+      def self.contexts      # :nodoc:
+        [:iter]
       end
 
-      def detailed_report
-        "#{@context} has nested iterators"
+      #
+      # Checks whether the given +block+ is inside another.
+      # Any smells found are added to the +report+.
+      #
+      def examine_context(block, report)
+        return false unless block.nested_block?
+        report << SmellWarning.new(self, block, 'is nested')
       end
     end
-
   end
 end

data/lib/reek/smells/smell_detector.rb

@@ -0,0 +1,66 @@
+class Class
+  def name_words
+    class_name = name.split(/::/)[-1]
+    class_name.gsub(/([a-z])([A-Z])/) { |sub| "#{$1} #{$2}"}.split
+  end
+end
+
+module Reek
+  module Smells
+
+    class SmellDetector
+
+      # The name of the config field that lists the names of code contexts
+      # that should not be checked. Add this field to the config for each
+      # 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]
+      end
+
+      def self.contexts      # :nodoc:
+        [:defn, :defs]
+      end
+      
+      def self.default_config
+        {
+          ENABLED_KEY => true,
+          EXCLUDE_KEY => []
+        }
+      end
+
+      def self.listen(hooks, config)
+        detector = new(config[class_name])
+        contexts.each { |ctx| hooks[ctx] << detector }
+      end
+
+      def initialize(config)
+        @enabled = config[ENABLED_KEY]
+        @exceptions = config[EXCLUDE_KEY]
+      end
+
+      def examine(context, report)
+        before = report.size
+        examine_context(context, report) if @enabled and !exception?(context)
+        report.length > before
+      end
+
+      def examine_context(context, report)
+      end
+      
+      def exception?(context)
+        return false if @exceptions.nil? or @exceptions.length == 0
+        context.matches?(@exceptions)
+      end
+
+      def smell_name
+        self.class.name_words.join(' ')
+      end
+    end
+  end
+end

data/lib/reek/smells/smells.rb

@@ -1,24 +1,85 @@
-$:.unshift File.dirname(__FILE__)
-
 require 'reek/smells/control_couple'
 require 'reek/smells/duplication'
 require 'reek/smells/feature_envy'
+require 'reek/smells/large_class'
 require 'reek/smells/long_method'
 require 'reek/smells/long_parameter_list'
 require 'reek/smells/long_yield_list'
 require 'reek/smells/nested_iterators'
 require 'reek/smells/uncommunicative_name'
 require 'reek/smells/utility_function'
+require 'yaml'
 
-module Reek
+class Hash
+  def value_merge!(other)
+    other.keys.each do |key|
+      self[key].adopt!(other[key])
+    end
+    self
+  end
   
-  SMELLS = {
-    :defn => [
-      Smells::UncommunicativeName,
-      Smells::LongMethod,
+  def adopt!(other)
+    other.keys.each do |key|
+      ov = other[key]
+      if Array === ov and has_key?(key)
+        self[key] += ov
+      else
+        self[key] = ov
+      end
+    end
+    self
+  end
+  
+  def adopt(other)
+    self.deep_copy.adopt!(other)
+  end
+  
+  def deep_copy
+    YAML::load(YAML::dump(self))
+  end
+end
+
+module Reek
+  class SmellConfig
+
+    SMELL_CLASSES = [
+      Smells::ControlCouple,
       Smells::Duplication,
+      Smells::FeatureEnvy,
+      Smells::LargeClass,
+      Smells::LongMethod,
+      Smells::LongParameterList,
+      Smells::LongYieldList,
+      Smells::NestedIterators,
+      Smells::UncommunicativeName,
       Smells::UtilityFunction,
-      Smells::FeatureEnvy
-      ]
-  }
+    ]
+
+    def initialize
+      defaults_file = File.join(File.dirname(__FILE__), '..', '..', '..', 'config', 'defaults.reek')
+      @config = YAML.load_file(defaults_file)
+    end
+
+    def smell_listeners()
+      result = Hash.new {|hash,key| hash[key] = [] }
+      SMELL_CLASSES.each { |smell| smell.listen(result, @config) }
+      return result
+    end
+
+    def load_local(file)
+      path = File.expand_path(file)
+      all_reekfiles(path).each do |rfile|
+        cf = YAML.load_file(rfile)
+        @config.value_merge!(cf)
+      end
+      self
+    end
+
+    def all_reekfiles(path)
+      return [] unless File.exist?(path)
+      parent = File.dirname(path)
+      return [] if path == parent
+      all_reekfiles(parent) + Dir["#{path}/*.reek"]
+    end
+  end
 end

data/lib/reek/smells/uncommunicative_name.rb

@@ -1,6 +1,5 @@
-$:.unshift File.dirname(__FILE__)
-
-require 'reek/smells/smell'
+require 'reek/smells/smell_detector'
+require 'reek/smell_warning'
 
 module Reek
   module Smells
@@ -18,55 +17,64 @@ module Reek
     # * 1-character names
     # * names consisting of a single character followed by a number
     #
-    class UncommunicativeName < Smell
+    class UncommunicativeName < SmellDetector
+
+      # The name of the config field that lists the regexps of
+      # smelly names to be rejected.
+      REJECT_KEY = 'reject'
+      
+      # 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'
+
+      def self.default_config
+        super.adopt(
+          REJECT_KEY => [/^.[0-9]*$/],
+          ACCEPT_KEY => ['Inline::C']
+        )
+      end
+
+      def self.contexts      # :nodoc:
+        [:module, :class, :defn, :defs, :iter]
+      end
+
+      def initialize(config = UncommunicativeName.default_config)
+        super
+        @reject = config[REJECT_KEY]
+        @accept = config[ACCEPT_KEY]
+      end
 
       #
-      # Checks the given +method+ for uncommunicative method name,
-      # parameter names, local variable names and instance variable names.
-      # Any smells found are added to the +report+; returns true in that case,
-      # and false otherwise.
+      # Checks the given +context+ for uncommunicative names.
+      # Any smells found are added to the +report+.
       #
-      def self.examine(method, report)
-        smell_reported = consider(method.name, method, report, 'method')
-        method.parameters.each do |param|
-          smell_reported = consider(param, method, report, 'parameter') || smell_reported
-        end
-        method.local_variables.each do |lvar|
-          smell_reported = consider(lvar, method, report, 'local variable') || smell_reported
-        end
-        method.instance_variables.each do |ivar|
-          smell_reported = consider(ivar, method, report, 'field') || smell_reported
-        end
-        smell_reported
+      def examine_context(context, report)
+        consider_name(context, report)
+        consider_variables(context, report)
       end
 
-      def self.consider(sym, method, report, type)  # :nodoc:
-        name = sym.to_s
-        if is_bad_name?(name)
-          report << new(name, method, type)
-          return true
+      def consider_variables(context, report) # :nodoc:
+        context.variable_names.each do |name|
+          next unless is_bad_name?(name)
+          report << SmellWarning.new(self, context,
+                      "has the variable name '#{name}'")
         end
-        return false
       end
 
-      def self.is_bad_name?(name)
-        return false if name == '*'
-        name = name[1..-1] while /^@/ === name
-        return true if name.length < 2
-        return true if /^.[0-9]$/ === name
-        false
+      def consider_name(context, report)  # :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}'")
       end
 
-      def initialize(name, context, symbol_type)
-        super(context, symbol_type)
-        @bad_name = name
-        @symbol_type = symbol_type
-      end
-
-      def detailed_report
-        "#{@context} uses the #{@symbol_type} name '#{@bad_name}'"
+      def is_bad_name?(name)  # :nodoc:
+        var = name.effective_name
+        return false if var == '*' or @accept.include?(var)
+        @reject.detect {|patt| patt === var}
       end
     end
-
   end
 end