reek 1.3.8 → 1.4.0

data/lib/reek/smells/duplicate_method_call.rb

@@ -3,23 +3,22 @@ require 'reek/smell_warning'
 
 module Reek
   module Smells
-
     #
     # Duplication occurs when two fragments of code look nearly identical,
     # or when two fragments of code have nearly identical effects
     # at some conceptual level.
-    # 
+    #
     # +DuplicateMethodCall+ checks for repeated identical method calls
     # within any one method definition. For example, the following method
     # will report a warning:
-    # 
+    #
     #   def double_thing()
     #     @other.thing + @other.thing
     #   end
     #
     class DuplicateMethodCall < SmellDetector
       SMELL_CLASS = 'Duplication'
-      SMELL_SUBCLASS = self.name.split(/::/)[-1]
+      SMELL_SUBCLASS = name.split(/::/)[-1]
 
       CALL_KEY = 'call'
       OCCURRENCES_KEY = 'occurrences'
@@ -57,7 +56,7 @@ module Reek
           SmellWarning.new(SMELL_CLASS, ctx.full_name, found_call.lines,
                            found_call.smell_message,
                            @source, SMELL_SUBCLASS,
-                           {CALL_KEY => found_call.call, OCCURRENCES_KEY => found_call.occurs})
+                           CALL_KEY => found_call.call, OCCURRENCES_KEY => found_call.occurs)
         end
       end
 
@@ -86,7 +85,7 @@ module Reek
         end
 
         def lines
-          @occurences.map {|exp| exp.line}
+          @occurences.map(&:line)
         end
       end
 
@@ -101,14 +100,14 @@ module Reek
         end
 
         def calls
-          result = Hash.new {|hash,key| hash[key] = FoundCall.new(key)}
+          result = Hash.new { |hash, key| hash[key] = FoundCall.new(key) }
           collect_calls(result)
           collect_assignments(result)
-          result.values.sort_by {|found_call| found_call.call}
+          result.values.sort_by(&:call)
         end
 
         def smelly_calls
-          calls.select {|found_call| smelly_call? found_call }
+          calls.select { |found_call| smelly_call? found_call }
         end
 
         private
@@ -125,14 +124,17 @@ module Reek
             next if !call_node.receiver && call_node.args.empty?
             result[call_node].record(call_node)
           end
+          context.local_nodes(:iter) do |call_node|
+            result[call_node].record(call_node)
+          end
         end
 
         def smelly_call?(found_call)
-          found_call.occurs > @max_allowed_calls and not allow_calls?(found_call.call)
+          found_call.occurs > @max_allowed_calls && !allow_calls?(found_call.call)
         end
 
         def allow_calls?(method)
-          @allow_calls.any? { |allow| /#{allow}/ === method }
+          @allow_calls.any? { |allow| /#{allow}/ =~ method }
         end
       end
     end

data/lib/reek/smells/feature_envy.rb

@@ -3,15 +3,14 @@ require 'reek/smell_warning'
 
 module Reek
   module Smells
-
     #
     # Feature Envy occurs when a code fragment references another object
     # more often than it references itself, or when several clients do
     # the same series of manipulations on a particular type of object.
-    # 
+    #
     # A simple example would be the following method, which "belongs"
     # on the Item class and not on the Cart class:
-    # 
+    #
     #  class Cart
     #    def price
     #      @item.price + @item.tax
@@ -22,12 +21,12 @@ module Reek
     # code that "belongs" on one class but which is located in another
     # can be hard to find, and may upset the "System of Names"
     # in the host class.
-    # 
+    #
     # Feature Envy also affects the design's flexibility: A code fragment
     # that is in the wrong class creates couplings that may not be natural
     # within the application's domain, and creates a loss of cohesion
     # in the unwilling host class.
-    # 
+    #
     # Currently +FeatureEnvy+ reports any method that refers to self less
     # often than it refers to (ie. send messages to) some other object.
     #
@@ -35,7 +34,7 @@ module Reek
       include ExcludeInitialize
 
       SMELL_CLASS = 'LowCohesion'
-      SMELL_SUBCLASS = self.name.split(/::/)[-1]
+      SMELL_SUBCLASS = name.split(/::/)[-1]
 
       RECEIVER_KEY = 'receiver'
       REFERENCES_KEY = 'references'
@@ -51,7 +50,7 @@ module Reek
           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})
+                           @source, SMELL_SUBCLASS, RECEIVER_KEY => target, REFERENCES_KEY => occurs)
         end
       end
     end

data/lib/reek/smells/irresponsible_module.rb

@@ -4,14 +4,12 @@ require 'reek/source/code_comment'
 
 module Reek
   module Smells
-
     #
     # It is considered good practice to annotate every class and module
     # with a brief comment outlining its responsibilities.
     #
     class IrresponsibleModule < SmellDetector
-
-      SMELL_CLASS = self.name.split(/::/)[-1]
+      SMELL_CLASS = name.split(/::/)[-1]
       SMELL_SUBCLASS = SMELL_CLASS
 
       MODULE_NAME_KEY = 'module_name'
@@ -31,10 +29,10 @@ module Reek
       #
       def examine_context(ctx)
         comment = Source::CodeComment.new(ctx.exp.comments)
-        return [] if self.class.descriptive[ctx.full_name] ||= comment.is_descriptive?
+        return [] if self.class.descriptive[ctx.full_name] ||= comment.descriptive?
         smell = SmellWarning.new(SMELL_CLASS, ctx.full_name, [ctx.exp.line],
-          'has no descriptive comment',
-          @source, SMELL_SUBCLASS, {MODULE_NAME_KEY => ctx.exp.text_name})
+                                 'has no descriptive comment',
+                                 @source, SMELL_SUBCLASS, MODULE_NAME_KEY => ctx.exp.text_name)
         [smell]
       end
     end

data/lib/reek/smells/long_parameter_list.rb

@@ -4,7 +4,6 @@ require 'reek/core/smell_configuration'
 
 module Reek
   module Smells
-
     #
     # A Long Parameter List occurs when a method has more than one
     # or two parameters, or when a method yields more than one or
@@ -14,9 +13,8 @@ module Reek
     # many parameters.
     #
     class LongParameterList < SmellDetector
-
       SMELL_CLASS = 'LongParameterList'
-      SMELL_SUBCLASS = self.name.split(/::/)[-1]
+      SMELL_SUBCLASS = name.split(/::/)[-1]
 
       PARAMETER_COUNT_KEY = 'parameter_count'
 
@@ -32,7 +30,7 @@ module Reek
         super.merge(
           MAX_ALLOWED_PARAMS_KEY => DEFAULT_MAX_ALLOWED_PARAMS,
           Core::SmellConfiguration::OVERRIDES_KEY => {
-            "initialize" => {MAX_ALLOWED_PARAMS_KEY => 5}
+            'initialize' => { MAX_ALLOWED_PARAMS_KEY => 5 }
           }
         )
       end
@@ -47,9 +45,9 @@ module Reek
         num_params = ctx.exp.arg_names.length
         return [] if num_params <= @max_allowed_params
         smell = SmellWarning.new(SMELL_CLASS, ctx.full_name, [ctx.exp.line],
-          "has #{num_params} parameters",
-          @source, SMELL_SUBCLASS,
-          {PARAMETER_COUNT_KEY => num_params})
+                                 "has #{num_params} parameters",
+                                 @source, SMELL_SUBCLASS,
+                                 PARAMETER_COUNT_KEY => num_params)
         [smell]
       end
     end

data/lib/reek/smells/long_yield_list.rb

@@ -3,15 +3,13 @@ require 'reek/smell_warning'
 
 module Reek
   module Smells
-
     #
     # A variant on LongParameterList that checks the number of items
     # passed to a block by a +yield+ call.
     #
     class LongYieldList < SmellDetector
-
       SMELL_CLASS = 'LongParameterList'
-      SMELL_SUBCLASS = self.name.split(/::/)[-1]
+      SMELL_SUBCLASS = name.split(/::/)[-1]
 
       # The name of the config field that sets the maximum number of
       # parameters permitted in any method or block.
@@ -42,7 +40,7 @@ module Reek
           num_params = yield_node.args.length
           SmellWarning.new(SMELL_CLASS, method_ctx.full_name, [yield_node.line],
                            "yields #{num_params} parameters",
-                           @source, SMELL_SUBCLASS, {PARAMETER_COUNT_KEY => num_params})
+                           @source, SMELL_SUBCLASS, PARAMETER_COUNT_KEY => num_params)
         end
       end
     end

data/lib/reek/smells/nested_iterators.rb

@@ -3,15 +3,13 @@ require 'reek/smell_warning'
 
 module Reek
   module Smells
-
     #
     # A Nested Iterator occurs when a block contains another block.
     #
     # +NestedIterators+ reports failing methods only once.
     #
     class NestedIterators < SmellDetector
-
-      SMELL_CLASS = self.name.split(/::/)[-1]
+      SMELL_CLASS = name.split(/::/)[-1]
       SMELL_SUBCLASS = SMELL_CLASS
       # SMELL: should be a subclass of UnnecessaryComplexity
       NESTING_DEPTH_KEY = 'depth'
@@ -45,9 +43,9 @@ module Reek
 
         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})
+                                   "contains iterators nested #{depth} deep",
+                                   @source, SMELL_SUBCLASS,
+                                   NESTING_DEPTH_KEY => depth)
           [smell]
         else
           []
@@ -55,39 +53,31 @@ module Reek
         # BUG: no longer reports nesting outside methods (eg. in Optparse)
       end
 
-    private
+      private
 
       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
+        find_iters(ctx.exp, 1).sort_by { |item| item[1] }.last
       end
 
       def find_iters(exp, depth)
-        exp.map do |elem|
-          next unless Sexp === elem
-          case elem.first
-          when :iter
-            find_iters_for_iter_node(elem, depth)
-          when :class, :defn, :defs, :module
-            next
-          else
-            find_iters(elem, depth)
-          end
-        end.flatten(1).compact
+        exp.unnested_nodes([:iter]).flat_map do |elem|
+          find_iters_for_iter_node(elem, depth)
+        end
       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 = 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 }
+        @ignore_iterators.any? { |pattern| /#{pattern}/ =~ name }
       end
     end
   end

data/lib/reek/smells/nil_check.rb

@@ -3,22 +3,20 @@ 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 = 'SimulatedPolymorphism'
-      SMELL_SUBCLASS = self.name.split(/::/)[-1]
+      SMELL_SUBCLASS = name.split(/::/)[-1]
 
       def examine_context(ctx)
-        call_nodes = CallNodeFinder.new(ctx)
-        case_nodes = CaseNodeFinder.new(ctx)
-        smelly_nodes = call_nodes.smelly + case_nodes.smelly
+        call_node_finder = NodeFinder.new(ctx, :call, NilCallNodeDetector)
+        case_node_finder = NodeFinder.new(ctx, :when, NilWhenNodeDetector)
+        smelly_nodes = call_node_finder.smelly_nodes + case_node_finder.smelly_nodes
 
         smelly_nodes.map do |node|
           SmellWarning.new(SMELL_CLASS, ctx.full_name, Array(node.line),
-                           "performs a nil-check.",
+                           'performs a nil-check.',
                            @source, SMELL_SUBCLASS)
         end
       end
@@ -27,64 +25,55 @@ module Reek
       # A base class that allows to work on all nodes of a certain type.
       #
       class NodeFinder
-        SEXP_NIL = Sexp.new(:nil)
-        def initialize(ctx, type)
-          @nodes = Array(ctx.local_nodes(type))
+        def initialize(ctx, type, detector = nil)
+          @nodes = ctx.local_nodes(type)
+          @detector = detector
         end
-      end
 
-      #
-      # Find call nodes which perform a nil check.
-      #
-      class CallNodeFinder < NodeFinder
-        def initialize(ctx)
-          super(ctx, :call)
+        def smelly_nodes
+          @nodes.select do |when_node|
+            @detector.detect(when_node)
+          end
         end
+      end
 
-        def smelly
-          @nodes.select{ |call|
-            nil_chk?(call) 
-          }
-        end
+      # Detect 'call' nodes which perform a nil check.
+      module NilCallNodeDetector
+        module_function
 
-        def nil_chk?(call)
-          nilQ_use?(call) || eq_nil_use?(call) 
+        def detect(node)
+          nil_query?(node) || nil_comparison?(node)
         end
 
-        def nilQ_use?(call)
-          call.last == :nil?
+        def nil_query?(call)
+          call.method_name == :nil?
         end
 
-        def eq_nil_use?(call)
-          include_eq?(call) && call.include?(SEXP_NIL)
+        def nil_comparison?(call)
+          is_comparison_call?(call) && involves_nil?(call)
         end
 
-        def include_eq?(call)
-          [:==, :===].any? { |operator| call.include?(operator) }
+        def is_comparison_call?(call)
+          comparison_methods.include? call.method_name
         end
-      end
-
-      #
-      # Finds when statements that perform a nil check.
-      #
-      class CaseNodeFinder < NodeFinder
-        CASE_NIL_NODE = Sexp.new(:array, SEXP_NIL)
 
-        def initialize(ctx)
-          super(ctx, :when)
+        def involves_nil?(call)
+          call.receiver.nil_node? || call.args.any?(&:nil_node?)
         end
 
-        def smelly
-          @nodes.select{ |when_node|
-            nil_chk?(when_node)
-          }
+        def comparison_methods
+          [:==, :===]
         end
+      end
+
+      # Detect 'when' statements that perform a nil check.
+      module NilWhenNodeDetector
+        module_function
 
-        def nil_chk?(when_node)
-          when_node.include?(CASE_NIL_NODE)
+        def detect(node)
+          node.condition_list.any?(&:nil_node?)
         end
       end
-
     end
   end
 end

data/lib/reek/smells/prima_donna_method.rb

@@ -6,19 +6,22 @@ module Reek
     # Excerpt from:
     # http://dablog.rubypal.com/2007/8/15/bang-methods-or-danger-will-rubyist
     # since this sums it up really well:
-    # ------------------------------
-    # The ! in method names that end with ! means, “This method is dangerous”
-    # or, more precisely, this method is the “dangerous” version of an
-    # equivalent method, with the same name minus the !.  “Danger” is relative;
-    # the ! doesn’t mean anything at all unless the method name it’s in
-    # corresponds to a similar but bang-less method name.  Don’t add ! to your
-    # destructive (receiver-changing) methods’ names, unless you consider the
-    # changing to be “dangerous” and you have a “non-dangerous” equivalent
-    # method without the !.  If some arbitrary subset of destructive methods end
-    # with !, then the whole point of ! gets distorted and diluted, and ! ceases
-    # to convey any information whatsoever
-    # ------------------------------
+    #
+    #   The ! in method names that end with ! means, "This method is dangerous"
+    #   -- or, more precisely, this method is the "dangerous" version of an
+    #   equivalent method, with the same name minus the !. "Danger" is
+    #   relative; the ! doesn't mean anything at all unless the method name
+    #   it's in corresponds to a similar but bang-less method name.
+    #
+    #   Don't add ! to your destructive (receiver-changing) methods' names,
+    #   unless you consider the changing to be "dangerous" and you have a
+    #   "non-dangerous" equivalent method without the !. If some arbitrary
+    #   subset of destructive methods end with !, then the whole point of !
+    #   gets distorted and diluted, and ! ceases to convey any information
+    #   whatsoever.
+    #
     # Such a method is called PrimaDonnaMethod and is reported as a smell.
+    #
     class PrimaDonnaMethod < SmellDetector
       SMELL_CLASS    = smell_class_name
       SMELL_SUBCLASS = smell_class_name
@@ -29,11 +32,16 @@ module Reek
 
       def examine_context(ctx)
         ctx.node_instance_methods.map do |method_sexp|
-          if method_sexp.ends_with_bang?
-            SmellWarning.new(SMELL_CLASS, ctx.full_name, [ctx.exp.line],
-                             %Q!has prima donna method `#{method_sexp.name}`!,
-                             @source, SMELL_SUBCLASS) unless ctx.node_instance_methods.detect {|sexp_item| sexp_item.name.to_s == method_sexp.name_without_bang }
+          next unless method_sexp.ends_with_bang?
+
+          version_without_bang = ctx.node_instance_methods.find do |sexp_item|
+            sexp_item.name.to_s == method_sexp.name_without_bang
           end
+          next if version_without_bang
+
+          SmellWarning.new(SMELL_CLASS, ctx.full_name, [ctx.exp.line],
+                           "has prima donna method `#{method_sexp.name}`",
+                           @source, SMELL_SUBCLASS)
         end.compact
       end
     end