reek 1.2.7.3 → 1.2.8

data/lib/reek/examiner.rb

@@ -27,7 +27,7 @@ module Reek
     #   and if it is an Array, it is assumed to be a list of file paths,
     #   each of which is opened and parsed for source code.
     #
-    def initialize(source)
+    def initialize(source, config_files = [])
       sources = case source
       when Array
         @description = 'dir'
@@ -41,7 +41,7 @@ module Reek
         [src]
       end
       collector = Core::WarningCollector.new
-      sources.each { |src| Core::Sniffer.new(src).report_on(collector) }
+      sources.each { |src| Core::Sniffer.new(src, config_files).report_on(collector) }
       @smells = collector.warnings
     end
 

data/lib/reek/rake/task.rb

@@ -7,6 +7,8 @@ module Reek
 
   #
   # Defines a task library for running reek.
+  # (Classes here will be configured via the Rakefile, and therefore will
+  # possess a :reek:attribute or two.)
   #
   module Rake
 
@@ -40,6 +42,11 @@ module Reek
       # Defaults to ['<the absolute path to reek's lib directory>']
       attr_accessor :libs
 
+      # Glob pattern to match config files.
+      # Setting the REEK_CFG environment variable overrides this.
+      # Defaults to 'config/**/*.reek'.
+      attr_accessor :config_files
+
       # Glob pattern to match source files.
       # Setting the REEK_SRC environment variable overrides this.
       # Defaults to 'lib/**/*.rb'.
@@ -65,6 +72,7 @@ module Reek
       def initialize(name = :reek)
         @name = name
         @libs = [File.expand_path(File.dirname(__FILE__) + '/../../../lib')]
+        @config_files = nil
         @source_files = nil
         @ruby_opts = []
         @reek_opts = ''
@@ -72,6 +80,7 @@ module Reek
         @sort = nil
 
         yield self if block_given?
+        @config_files ||= 'config/**/*.reek'
         @source_files ||= 'lib/**/*.rb'
         define
       end
@@ -104,9 +113,16 @@ module Reek
             ruby_options +
             [ %Q|"#{Task.reek_script}"| ] +
             [sort_option] +
+            config_file_list.collect { |fn| ['-c', %["#{fn}"]] }.flatten +
             source_file_list.collect { |fn| %["#{fn}"] }
       end
 
+      def config_file_list
+        files = ENV['REEK_CFG'] || @config_files
+        return [] unless files
+        return FileList[files]
+      end
+
       def ruby_options
         lib_path = @libs.join(File::PATH_SEPARATOR)
         @ruby_opts.clone << "-I\"#{lib_path}\""

data/lib/reek/smell_warning.rb

@@ -3,6 +3,7 @@ module Reek
 
   #
   # Reports a warning that a smell has been found.
+  # This object is essentially a DTO, and therefore contains a :reek:attribute or two.
   #
   class SmellWarning
 
@@ -71,7 +72,7 @@ module Reek
 
     def is_active() @status[ACTIVE_KEY] end
 
-    def hash  # :nodoc:
+    def hash
       sort_key.hash
     end
 
@@ -85,7 +86,7 @@ module Reek
 
     def contains_all?(patterns)
       rpt = sort_key.to_s
-      return patterns.all? {|patt| patt === rpt}
+      return patterns.all? {|pattern| pattern === rpt}
     end
 
     def matches?(klass, patterns)

data/lib/reek/smells/attribute.rb

@@ -21,6 +21,8 @@ module Reek
     class Attribute < SmellDetector
 
       SMELL_CLASS = self.name.split(/::/)[-1]
+      SMELL_SUBCLASS = SMELL_CLASS
+
       ATTRIBUTE_KEY = 'attribute'
 
       def self.contexts      # :nodoc:
@@ -37,19 +39,21 @@ module Reek
 
       #
       # Checks whether the given class declares any attributes.
-      # Remembers any smells found.
       #
-      def examine_context(module_ctx)
-        attributes_in(module_ctx).each do |attr, line|
-          found(module_ctx, "declares the attribute #{attr}", '',
-            {'attribute' => attr.to_s}, [line])
+      # @return [Array<SmellWarning>]
+      #
+      def examine_context(ctx)
+        attributes_in(ctx).map do |attr, line|
+          smell = SmellWarning.new(SMELL_CLASS, ctx.full_name, [line],
+            "declares the attribute #{attr}",
+            @source, SMELL_SUBCLASS,
+            {ATTRIBUTE_KEY => attr.to_s})
+          smell
         end
       end
 
-      #
-      # Collects the names of the class variables declared and/or used
-      # in the given module.
-      #
+    private
+      
       def attributes_in(module_ctx)
         result = Set.new
         attr_defn_methods = [:attr, :attr_reader, :attr_writer, :attr_accessor]

data/lib/reek/smells/boolean_parameter.rb

@@ -14,18 +14,23 @@ module Reek
     #
     class BooleanParameter < SmellDetector
 
+      SMELL_CLASS = 'ControlCouple'
+      SMELL_SUBCLASS = self.name.split(/::/)[-1]
+
+      PARAMETER_KEY = 'parameter'
+
+      #
+      # Checks whether the given method has any Boolean parameters.
       #
-      # Checks whether the given method has a Boolean parameter.
-      # Remembers any smells found.
+      # @return [Array<SmellWarning>]
       #
       def examine_context(method_ctx)
-        method_ctx.parameters.default_assignments.each do |param, value|
-          next unless [:true, :false].include?(value[0])
-          smell = SmellWarning.new('ControlCouple', method_ctx.full_name, [method_ctx.exp.line],
-            "has boolean parameter '#{param.to_s}'",
-            @source, 'BooleanParameter', {'parameter' => param.to_s})
-          @smells_found << smell
-          #SMELL: serious duplication
+        method_ctx.parameters.default_assignments.select do |param, value|
+          [:true, :false].include?(value[0])
+        end.map do |param, value|
+          SmellWarning.new(SMELL_CLASS, method_ctx.full_name, [method_ctx.exp.line],
+                           "has boolean parameter '#{param.to_s}'",
+                           @source, SMELL_SUBCLASS, {PARAMETER_KEY => param.to_s})
         end
       end
     end

data/lib/reek/smells/class_variable.rb

@@ -15,17 +15,26 @@ module Reek
     #
     class ClassVariable < SmellDetector
 
+      SMELL_CLASS = self.name.split(/::/)[-1]
+      SMELL_SUBCLASS = SMELL_CLASS
+      VARIABLE_KEY = 'variable'
+
       def self.contexts      # :nodoc:
         [:class, :module]
       end
 
       #
       # Checks whether the given class or module declares any class variables.
-      # Remembers any smells found.
+      #
+      # @return [Array<SmellWarning>]
       #
       def examine_context(ctx)
-        class_variables_in(ctx.exp).each do |cvar_name|
-          found(ctx, "declares the class variable #{cvar_name}", '', {'variable' => cvar_name.to_s})
+        class_variables_in(ctx.exp).map do |attr_name, lines|
+          smell = SmellWarning.new(SMELL_CLASS, ctx.full_name, lines,
+            "declares the class variable #{attr_name.to_s}",
+            @source, SMELL_SUBCLASS,
+            {VARIABLE_KEY => attr_name.to_s})
+          smell
         end
       end
 
@@ -34,8 +43,10 @@ module Reek
       # in the given module.
       #
       def class_variables_in(ast)
-        result = Set.new
-        collector = proc { |cvar_node| result << cvar_node.name }
+        result = Hash.new {|hash,key| hash[key] = []}
+        collector = proc do |cvar_node|
+          result[cvar_node.name].push(cvar_node.line)
+        end
         [:cvar, :cvasgn, :cvdecl].each do |stmt_type|
           ast.each_node(stmt_type, [:class, :module], &collector)
         end

data/lib/reek/smells/control_couple.rb

@@ -45,18 +45,23 @@ module Reek
 
       SMELL_CLASS = self.name.split(/::/)[-1]
       SMELL_SUBCLASS = 'ControlParameter'
+      PARAMETER_KEY = 'parameter'
 
       #
       # Checks whether the given method chooses its execution path
       # by testing the value of one of its parameters.
-      # Remembers any smells found.
       #
-      def examine_context(method_ctx)
-        control_parameters(method_ctx).each do |cond, occurs|
-          param = cond.format
+      # @return [Array<SmellWarning>]
+      #
+      def examine_context(ctx)
+        control_parameters(ctx).map do |cond, occurs|
+          param = cond.format_ruby
           lines = occurs.map {|exp| exp.line}
-          found(method_ctx, "is controlled by argument #{param}",
-            SMELL_SUBCLASS, {'parameter' => param}, lines)
+          smell = SmellWarning.new(SMELL_CLASS, ctx.full_name, lines,
+            "is controlled by argument #{param}",
+            @source, SMELL_SUBCLASS,
+            {PARAMETER_KEY => param})
+          smell
         end
       end
 

data/lib/reek/smells/data_clump.rb

@@ -34,23 +34,32 @@ module Reek
       OCCURRENCES_KEY = 'occurrences'
       PARAMETERS_KEY = 'parameters'
 
-      def self.contexts      # :nodoc:
+      # @private
+      def self.contexts
         [:class, :module]
       end
 
+      #
       # The name of the config field that sets the maximum allowed
-      # copies of any clump.
+      # copies of any clump. No group of common parameters will be
+      # reported as a DataClump unless there are more than this many
+      # methods containing those parameters.
+      #
       MAX_COPIES_KEY = 'max_copies'
-
       DEFAULT_MAX_COPIES = 2
 
+      #
+      # The name of the config field that sets the minimum clump
+      # size. No group of common parameters will be reported as
+      # a DataClump unless it contains at least this many parameters.
+      #
       MIN_CLUMP_SIZE_KEY = 'min_clump_size'
       DEFAULT_MIN_CLUMP_SIZE = 2
 
       def self.default_config
         super.adopt(
-          MAX_COPIES_KEY => DEFAULT_MAX_COPIES,
-          MIN_CLUMP_SIZE_KEY => DEFAULT_MIN_CLUMP_SIZE
+                MAX_COPIES_KEY => DEFAULT_MAX_COPIES,
+                MIN_CLUMP_SIZE_KEY => DEFAULT_MIN_CLUMP_SIZE
         )
       end
 
@@ -60,26 +69,25 @@ module Reek
 
       #
       # Checks the given class or module for multiple identical parameter sets.
-      # Remembers any smells found.
+      #
+      # @return [Array<SmellWarning>]
       #
       def examine_context(ctx)
-        max_copies = value(MAX_COPIES_KEY, ctx, DEFAULT_MAX_COPIES)
-        min_clump_size = value(MIN_CLUMP_SIZE_KEY, ctx, DEFAULT_MIN_CLUMP_SIZE)
-        MethodGroup.new(ctx, min_clump_size, max_copies).clumps.each do |clump, methods|
-          smell = SmellWarning.new('DataClump', ctx.full_name,
-            methods.map {|meth| meth.line},
-            "takes parameters #{DataClump.print_clump(clump)} to #{methods.length} methods",
-            @source, 'DataClump', {
-              PARAMETERS_KEY => clump.map {|name| name.to_s},
-              OCCURRENCES_KEY => methods.length,
-              METHODS_KEY => methods.map {|meth| meth.name}
-            })
-          @smells_found << smell
-          #SMELL: serious duplication
-          # SMELL: name.to_s is becoming a nuisance
+        @max_copies = value(MAX_COPIES_KEY, ctx, DEFAULT_MAX_COPIES)
+        @min_clump_size = value(MIN_CLUMP_SIZE_KEY, ctx, DEFAULT_MIN_CLUMP_SIZE)
+        MethodGroup.new(ctx, @min_clump_size, @max_copies).clumps.map do |clump, methods|
+          SmellWarning.new('DataClump', ctx.full_name,
+                           methods.map {|meth| meth.line},
+                           "takes parameters #{DataClump.print_clump(clump)} to #{methods.length} methods",
+                           @source, 'DataClump', {
+                          PARAMETERS_KEY => clump.map {|name| name.to_s},
+                          OCCURRENCES_KEY => methods.length,
+                          METHODS_KEY => methods.map {|meth| meth.name}
+                  })
         end
       end
 
+      # @private
       def self.print_clump(clump)
         "[#{clump.map {|name| name.to_s}.join(', ')}]"
       end
@@ -108,14 +116,12 @@ module Reek
       methods.each do |other_method|
         clump = [method.arg_names, other_method.arg_names].intersection
         if clump.length >= @min_clump_size
-          others = methods.select do |other|    # BUG: early ones have already been eliminated
-            clump - other.arg_names == []
-          end
+          others = methods.select { |other| clump - other.arg_names == [] }
           results[clump] += [method] + others
         end
       end
     end
-    
+
     def collect_clumps_in(methods, results)
       return if methods.length <= @max_copies
       tail = methods[1..-1]
@@ -126,9 +132,7 @@ module Reek
     def clumps
       results = Hash.new([])
       collect_clumps_in(@candidate_methods, results)
-      results.each_key do |key|
-        results[key].uniq!
-      end
+      results.each_key { |key| results[key].uniq! }
       results
     end
 
@@ -148,13 +152,12 @@ module Reek
     end
   end
 
-  #
   # A method definition and a copy of its parameters
-  #
+  # @private
   class CandidateMethod
     def initialize(defn_node)
       @defn = defn_node
-      @params = defn_node.arg_names.clone.sort {|a,b| a.to_s <=> b.to_s}
+      @params = defn_node.arg_names.clone.sort {|first, second| first.to_s <=> second.to_s}
     end
 
     def arg_names

data/lib/reek/smells/duplication.rb

@@ -19,32 +19,59 @@ module Reek
     #
     class Duplication < SmellDetector
 
+      SMELL_CLASS = self.name.split(/::/)[-1]
+      SMELL_SUBCLASS = 'DuplicateMethodCall'
+      CALL_KEY = 'call'
+      OCCURRENCES_KEY = 'occurrences'
+
       # The name of the config field that sets the maximum number of
       # identical calls to be permitted within any single method.
       MAX_ALLOWED_CALLS_KEY = 'max_calls'
 
       DEFAULT_MAX_CALLS = 1
 
+      # The name of the config field that sets the names of any
+      # methods for which identical calls should be to be permitted
+      # within any single method.
+      ALLOW_CALLS_KEY = 'allow_calls'
+
+      DEFAULT_ALLOW_CALLS = []
+
       def self.default_config
-        super.adopt(MAX_ALLOWED_CALLS_KEY => DEFAULT_MAX_CALLS)
+        super.adopt(
+          MAX_ALLOWED_CALLS_KEY => DEFAULT_MAX_CALLS,
+          ALLOW_CALLS_KEY => DEFAULT_ALLOW_CALLS
+        )
       end
 
       def initialize(source, config = Duplication.default_config)
         super(source, config)
       end
 
-      def examine_context(method_ctx)
-        calls(method_ctx).each do |call_exp, copies|
+      #
+      # Looks for duplicate calls within the body of the method +ctx+.
+      #
+      # @return [Array<SmellWarning>]
+      #
+      def examine_context(ctx)
+        @max_allowed_calls = value(MAX_ALLOWED_CALLS_KEY, ctx, DEFAULT_MAX_CALLS)
+        @allow_calls = value(ALLOW_CALLS_KEY, ctx, DEFAULT_ALLOW_CALLS)
+        calls(ctx).select do |call_exp, copies|
+          copies.length > @max_allowed_calls and not allow_calls?(call_exp.format_ruby)
+        end.map do |call_exp, copies|
           occurs = copies.length
-          next if occurs <= value(MAX_ALLOWED_CALLS_KEY, method_ctx, DEFAULT_MAX_CALLS)
-          call = call_exp.format
+          call = call_exp.format_ruby
           multiple = occurs == 2 ? 'twice' : "#{occurs} times"
-          found(method_ctx, "calls #{call} #{multiple}",
-            'DuplicateMethodCall', {'call' => call, 'occurrences' => occurs},
-            copies.map {|exp| exp.line})
+          smell = SmellWarning.new(SMELL_CLASS, ctx.full_name, copies.map {|exp| exp.line},
+            "calls #{call} #{multiple}",
+            @source, SMELL_SUBCLASS,
+            {CALL_KEY => call, OCCURRENCES_KEY => occurs})
+          smell
         end
       end
 
+    private
+
       def calls(method_ctx)
         result = Hash.new {|hash,key| hash[key] = []}
         method_ctx.local_nodes(:call) do |call_node|
@@ -56,6 +83,10 @@ module Reek
         end
         result
       end
+
+      def allow_calls?(method)
+        @allow_calls.any? { |allow| /#{allow}/ === method }
+      end
     end
   end
 end

data/lib/reek/smells/feature_envy.rb

@@ -43,16 +43,15 @@ module Reek
       #
       # Checks whether the given +context+ includes any code fragment that
       # might "belong" on another class.
-      # Remembers any smells found.
+      #
+      # @return [Array<SmellWarning>]
       #
       def examine_context(method_ctx)
-        method_ctx.envious_receivers.each do |ref, occurs|
-          target = ref.format
-          smell = SmellWarning.new(SMELL_CLASS, method_ctx.full_name, [method_ctx.exp.line],
-            "refers to #{target} more than self",
-            @source, SMELL_SUBCLASS, {RECEIVER_KEY => target, REFERENCES_KEY => occurs})
-          @smells_found << smell
-          #SMELL: serious duplication
+        method_ctx.envious_receivers.map do |ref, occurs|
+          target = ref.format_ruby
+          SmellWarning.new(SMELL_CLASS, method_ctx.full_name, [method_ctx.exp.line],
+                           "refers to #{target} more than self",
+                           @source, SMELL_SUBCLASS, {RECEIVER_KEY => target, REFERENCES_KEY => occurs})
         end
       end
     end