reek 1.3.8 → 1.4.0

data/lib/reek/smells/repeated_conditional.rb

@@ -3,7 +3,6 @@ require 'reek/smell_warning'
 
 module Reek
   module Smells
-
     #
     # Simulated Polymorphism occurs when
     # * code uses a case statement (especially on a type field);
@@ -22,9 +21,8 @@ module Reek
     # testing the same value throughout a single class.
     #
     class RepeatedConditional < SmellDetector
-
       SMELL_CLASS = 'SimulatedPolymorphism'
-      SMELL_SUBCLASS = self.name.split(/::/)[-1]
+      SMELL_SUBCLASS = name.split(/::/)[-1]
 
       def self.contexts      # :nodoc:
         [:class]
@@ -47,7 +45,7 @@ module Reek
       #
       def examine_context(ctx)
         @max_identical_ifs = value(MAX_IDENTICAL_IFS_KEY, ctx, DEFAULT_MAX_IFS)
-        conditional_counts(ctx).select do |key, lines|
+        conditional_counts(ctx).select do |_key, lines|
           lines.length > @max_identical_ifs
         end.map do |key, lines|
           occurs = lines.length
@@ -55,7 +53,7 @@ module Reek
           SmellWarning.new(SMELL_CLASS, ctx.full_name, lines,
                            "tests #{expr} at least #{occurs} times",
                            @source, SMELL_SUBCLASS,
-                           {'expression' => expr, 'occurrences' => occurs})
+                           'expression' => expr, 'occurrences' => occurs)
         end
       end
 
@@ -65,13 +63,13 @@ module Reek
       # occurs. Ignores nested classes and modules.
       #
       def conditional_counts(sexp)
-        result = Hash.new {|hash, key| hash[key] = []}
-        collector = proc { |node|
+        result = Hash.new { |hash, key| hash[key] = [] }
+        collector = proc do |node|
           condition = node.condition
-          next if condition.nil? or condition == s(:call, nil, :block_given?)
+          next if condition.nil? || condition == s(:call, nil, :block_given?)
           result[condition].push(condition.line)
-        }
-        [:if, :case].each {|stmt| sexp.local_nodes(stmt, &collector) }
+        end
+        [:if, :case].each { |stmt| sexp.local_nodes(stmt, &collector) }
         result
       end
     end

data/lib/reek/smells/smell_detector.rb

@@ -4,7 +4,6 @@ require 'reek/core/smell_configuration'
 
 module Reek
   module Smells
-
     module ExcludeInitialize
       def self.default_config
         super.merge(EXCLUDE_KEY => ['initialize'])
@@ -15,7 +14,6 @@ module Reek
     # Shared responsibilities of all smell detectors.
     #
     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.
@@ -65,11 +63,15 @@ module Reek
       end
 
       def examine(context)
-        enabled = @config.enabled? && config_for(context)[Core::SmellConfiguration::ENABLED_KEY] != false
-        if enabled && !exception?(context)
-          sm = examine_context(context)
-          @smells_found += sm
-        end
+        return unless enabled_for? context
+        return if exception?(context)
+
+        sm = examine_context(context)
+        @smells_found += sm
+      end
+
+      def enabled_for?(context)
+        enabled? && config_for(context)[Core::SmellConfiguration::ENABLED_KEY] != false
       end
 
       def exception?(context)

data/lib/reek/smells/too_many_instance_variables.rb

@@ -3,18 +3,16 @@ 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]
+      SMELL_SUBCLASS = name.split(/::/)[-1]
       IVAR_COUNT_KEY = 'ivar_count'
 
       # The name of the config field that sets the maximum number of instance
@@ -44,15 +42,15 @@ module Reek
         check_num_ivars(ctx)
       end
 
-    private
+      private
 
       def check_num_ivars(ctx)  # :nodoc:
-        count = ctx.local_nodes(:iasgn).map {|iasgn| iasgn[1]}.uniq.length
+        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})
+                                 "has at least #{count} instance variables",
+                                 @source, SMELL_SUBCLASS,
+                                 IVAR_COUNT_KEY => count)
         [smell]
       end
     end

data/lib/reek/smells/too_many_methods.rb

@@ -3,20 +3,18 @@ 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]
+      SMELL_SUBCLASS = name.split(/::/)[-1]
       METHOD_COUNT_KEY = 'method_count'
 
       # The name of the config field that sets the maximum number of methods
@@ -46,15 +44,15 @@ module Reek
         check_num_methods(ctx)
       end
 
-    private
+      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})
+                                 "has at least #{actual} methods",
+                                 @source, SMELL_SUBCLASS,
+                                 METHOD_COUNT_KEY => actual)
         [smell]
       end
     end

data/lib/reek/smells/too_many_statements.rb

@@ -3,16 +3,14 @@ require 'reek/smell_warning'
 
 module Reek
   module Smells
-
     #
     # A Long Method is any method that has a large number of lines.
     #
     # +TooManyStatements+ reports any method with more than 5 statements.
     #
     class TooManyStatements < SmellDetector
-
       SMELL_CLASS = 'LongMethod'
-      SMELL_SUBCLASS = self.name.split(/::/)[-1]
+      SMELL_SUBCLASS = name.split(/::/)[-1]
 
       STATEMENT_COUNT_KEY = 'statement_count'
 
@@ -39,9 +37,9 @@ module Reek
         num = ctx.num_statements
         return [] if num <= @max_allowed_statements
         smell = SmellWarning.new(SMELL_CLASS, ctx.full_name, [ctx.exp.line],
-          "has approx #{num} statements",
-          @source, SMELL_SUBCLASS,
-          {STATEMENT_COUNT_KEY => num})
+                                 "has approx #{num} statements",
+                                 @source, SMELL_SUBCLASS,
+                                 STATEMENT_COUNT_KEY => num)
         [smell]
       end
     end

data/lib/reek/smells/uncommunicative_method_name.rb

@@ -3,11 +3,10 @@ require 'reek/smell_warning'
 
 module Reek
   module Smells
-
     #
     # An Uncommunicative Name is a name that doesn't communicate its intent
     # well enough.
-    # 
+    #
     # Poor names make it hard for the reader to build a mental picture
     # of what's going on in the code. They can also be mis-interpreted;
     # and they hurt the flow of reading, because the reader must slow
@@ -18,9 +17,8 @@ module Reek
     # * names ending with a number
     #
     class UncommunicativeMethodName < SmellDetector
-
       SMELL_CLASS = 'UncommunicativeName'
-      SMELL_SUBCLASS = self.name.split(/::/)[-1]
+      SMELL_SUBCLASS = name.split(/::/)[-1]
       METHOD_NAME_KEY = 'method_name'
 
       # The name of the config field that lists the regexps of
@@ -59,10 +57,10 @@ module Reek
         return [] if @accept_names.include?(ctx.full_name)
         var = name.gsub(/^[@\*\&]*/, '')
         return [] if @accept_names.include?(var)
-        return [] unless @reject_names.detect {|patt| patt === var}
+        return [] unless @reject_names.find { |patt| patt =~ var }
         smell = SmellWarning.new('UncommunicativeName', ctx.full_name, [ctx.exp.line],
-          "has the name '#{name}'",
-          @source, 'UncommunicativeMethodName', {METHOD_NAME_KEY => name})
+                                 "has the name '#{name}'",
+                                 @source, 'UncommunicativeMethodName', METHOD_NAME_KEY => name)
         [smell]
       end
     end

data/lib/reek/smells/uncommunicative_module_name.rb

@@ -3,11 +3,10 @@ require 'reek/smell_warning'
 
 module Reek
   module Smells
-
     #
     # An Uncommunicative Name is a name that doesn't communicate its intent
     # well enough.
-    # 
+    #
     # Poor names make it hard for the reader to build a mental picture
     # of what's going on in the code. They can also be mis-interpreted;
     # and they hurt the flow of reading, because the reader must slow
@@ -18,9 +17,8 @@ module Reek
     # * names ending with a number
     #
     class UncommunicativeModuleName < SmellDetector
-
       SMELL_CLASS = 'UncommunicativeName'
-      SMELL_SUBCLASS = self.name.split(/::/)[-1]
+      SMELL_SUBCLASS = name.split(/::/)[-1]
       MODULE_NAME_KEY = 'module_name'
 
       # The name of the config field that lists the regexps of
@@ -62,10 +60,10 @@ module Reek
         return [] if @accept_names.include?(full_name)
         var = name.gsub(/^[@\*\&]*/, '')
         return [] if @accept_names.include?(var)
-        return [] unless @reject_names.detect {|patt| patt === var}
+        return [] unless @reject_names.find { |patt| patt =~ var }
         smell = SmellWarning.new(SMELL_CLASS, full_name, [exp.line],
-          "has the name '#{name}'",
-          @source, SMELL_SUBCLASS, {MODULE_NAME_KEY => name})
+                                 "has the name '#{name}'",
+                                 @source, SMELL_SUBCLASS, MODULE_NAME_KEY => name)
         [smell]
       end
     end

data/lib/reek/smells/uncommunicative_parameter_name.rb

@@ -3,11 +3,10 @@ require 'reek/smell_warning'
 
 module Reek
   module Smells
-
     #
     # An Uncommunicative Name is a name that doesn't communicate its intent
     # well enough.
-    # 
+    #
     # Poor names make it hard for the reader to build a mental picture
     # of what's going on in the code. They can also be mis-interpreted;
     # and they hurt the flow of reading, because the reader must slow
@@ -18,9 +17,8 @@ module Reek
     # * names ending with a number
     #
     class UncommunicativeParameterName < SmellDetector
-
       SMELL_CLASS = 'UncommunicativeName'
-      SMELL_SUBCLASS = self.name.split(/::/)[-1]
+      SMELL_SUBCLASS = name.split(/::/)[-1]
       PARAMETER_NAME_KEY = 'parameter_name'
 
       # The name of the config field that lists the regexps of
@@ -57,18 +55,18 @@ module Reek
         @accept_names = value(ACCEPT_KEY, ctx, DEFAULT_ACCEPT_SET)
         context_expression = ctx.exp
         context_expression.parameter_names.select do |name|
-          is_bad_name?(name) && ctx.uses_param?(name)
+          bad_name?(name) && ctx.uses_param?(name)
         end.map do |name|
           SmellWarning.new(SMELL_CLASS, ctx.full_name, [context_expression.line],
                            "has the parameter name '#{name}'",
-                           @source, SMELL_SUBCLASS, {PARAMETER_NAME_KEY => name.to_s})
+                           @source, SMELL_SUBCLASS, PARAMETER_NAME_KEY => name.to_s)
         end
       end
 
-      def is_bad_name?(name)
+      def bad_name?(name)
         var = name.to_s.gsub(/^[@\*\&]*/, '')
-        return false if var == '*' or @accept_names.include?(var)
-        @reject_names.detect {|patt| patt === var}
+        return false if var == '*' || @accept_names.include?(var)
+        @reject_names.find { |patt| patt =~ var }
       end
     end
   end

data/lib/reek/smells/uncommunicative_variable_name.rb

@@ -3,11 +3,10 @@ require 'reek/smell_warning'
 
 module Reek
   module Smells
-
     #
     # An Uncommunicative Name is a name that doesn't communicate its intent
     # well enough.
-    # 
+    #
     # Poor names make it hard for the reader to build a mental picture
     # of what's going on in the code. They can also be mis-interpreted;
     # and they hurt the flow of reading, because the reader must slow
@@ -18,9 +17,8 @@ module Reek
     # * names ending with a number
     #
     class UncommunicativeVariableName < SmellDetector
-
       SMELL_CLASS = 'UncommunicativeName'
-      SMELL_SUBCLASS = self.name.split(/::/)[-1]
+      SMELL_SUBCLASS = name.split(/::/)[-1]
       VARIABLE_NAME_KEY = 'variable_name'
 
       # The name of the config field that lists the regexps of
@@ -55,37 +53,37 @@ module Reek
       def examine_context(ctx)
         @reject_names = value(REJECT_KEY, ctx, DEFAULT_REJECT_SET)
         @accept_names = value(ACCEPT_KEY, ctx, DEFAULT_ACCEPT_SET)
-        variable_names(ctx.exp).select do |name, lines|
-          is_bad_name?(name, ctx)
+        variable_names(ctx.exp).select do |name, _lines|
+          bad_name?(name, ctx)
         end.map do |name, lines|
           SmellWarning.new(SMELL_CLASS, ctx.full_name, lines,
                            "has the variable name '#{name}'",
-                           @source, SMELL_SUBCLASS, {VARIABLE_NAME_KEY => name.to_s})
+                           @source, SMELL_SUBCLASS, VARIABLE_NAME_KEY => name.to_s)
         end
       end
 
-      def is_bad_name?(name, ctx)
+      def bad_name?(name, _ctx)
         var = name.to_s.gsub(/^[@\*\&]*/, '')
         return false if @accept_names.include?(var)
-        @reject_names.detect {|patt| patt === var}
+        @reject_names.find { |patt| patt =~ var }
       end
 
       def variable_names(exp)
-        result = Hash.new {|hash, key| hash[key] = []}
+        result = Hash.new { |hash, key| hash[key] = [] }
         find_assignment_variable_names(exp, result)
         find_block_argument_variable_names(exp, result)
-        result.to_a.sort_by {|name, _| name.to_s}
+        result.to_a.sort_by { |name, _| name.to_s }
       end
 
       def find_assignment_variable_names(exp, accumulator)
         assignment_nodes = exp.each_node(:lasgn, [:class, :module, :defs, :defn])
 
         case exp.first
-          when :class, :module
-            assignment_nodes += exp.each_node(:iasgn, [:class, :module])
+        when :class, :module
+          assignment_nodes += exp.each_node(:iasgn, [:class, :module])
         end
 
-        assignment_nodes.each {|asgn| accumulator[asgn[1]].push(asgn.line) }
+        assignment_nodes.each { |asgn| accumulator[asgn[1]].push(asgn.line) }
       end
 
       def find_block_argument_variable_names(exp, accumulator)
@@ -115,10 +113,9 @@ module Reek
 
       def record_variable_name(exp, symbol, accumulator)
         varname = symbol.to_s.sub(/^\*/, '')
-        if varname != ""
-          var = varname.to_sym
-          accumulator[var].push(exp.line)
-        end
+        return if varname == ''
+        var = varname.to_sym
+        accumulator[var].push(exp.line)
       end
     end
   end

data/lib/reek/smells/unused_parameters.rb

@@ -3,81 +3,41 @@ require 'reek/smell_warning'
 
 module Reek
   module Smells
-
     #
     # Methods should use their parameters.
     #
     class UnusedParameters < SmellDetector
-
       SMELL_CLASS = 'UnusedCode'
       SMELL_SUBCLASS = name.split(/::/)[-1]
 
       PARAMETER_KEY = 'parameter'
 
-      EMPTY_ARRAY  = [].freeze
-      EMPTY_STRING = ''.freeze
-      SPLAT_MATCH  = /^\*/.freeze
-      UNDERSCORE   = '_'.freeze
-
       #
       # Checks whether the given method has any unused parameters.
       #
       # @return [Array<SmellWarning>]
       #
       def examine_context(method_ctx)
-        return EMPTY_ARRAY if zsuper?(method_ctx)
-        unused_params(method_ctx).map do |param|
+        return [] if method_ctx.uses_super_with_implicit_arguments?
+        method_ctx.unused_params.map do |param|
           smell_warning(method_ctx, param)
         end
       end
 
       private
 
-      def unused_params(method_ctx)
-        params(method_ctx).select do |param|
-          param = sanitized_param(param)
-          next if skip?(param)
-          !method_ctx.uses_param?(param)
-        end
-      end
-
-      def skip?(param)
-        anonymous_splat?(param) || marked_unused?(param)
-      end
-
-      def params(method_ctx)
-        method_ctx.exp.arg_names || EMPTY_ARRAY
-      end
-
-      def sanitized_param(param)
-        param.to_s.sub(SPLAT_MATCH, EMPTY_STRING)
-      end
-
-      def marked_unused?(param)
-        param.start_with?(UNDERSCORE)
-      end
-
-      def anonymous_splat?(param)
-        param == EMPTY_STRING
-      end
-
-      def zsuper?(method_ctx)
-        method_ctx.exp.body.has_nested_node? :zsuper
-      end
-
       def smell_warning(method_ctx, param)
-        param_name = param.to_s
+        param_name = param.name.to_s
         SmellWarning.new(
           SMELL_CLASS,
           method_ctx.full_name,
-          [ method_ctx.exp.line ],
+          [method_ctx.exp.line],
           "has unused parameter '#{param_name}'",
           @source,
           SMELL_SUBCLASS,
-          { PARAMETER_KEY => param_name }
+          PARAMETER_KEY => param_name
         )
       end
-
     end
   end
 end