reek 3.3.1 → 3.4.0

data/lib/reek/smells/too_many_statements.rb

@@ -9,7 +9,6 @@ module Reek
     # +TooManyStatements+ reports any method with more than 5 statements.
     #
     # See {file:docs/Too-Many-Statements.md} for details.
-    # @api private
     class TooManyStatements < SmellDetector
       # The name of the config field that sets the maximum number of
       # statements permitted in any method.
@@ -38,11 +37,11 @@ module Reek
                                        DEFAULT_MAX_STATEMENTS)
         count = ctx.num_statements
         return [] if count <= max_allowed_statements
-        [SmellWarning.new(self,
-                          context: ctx.full_name,
-                          lines: [ctx.exp.line],
-                          message: "has approx #{count} statements",
-                          parameters: { count: count })]
+        [smell_warning(
+          context: ctx,
+          lines: [ctx.exp.line],
+          message: "has approx #{count} statements",
+          parameters: { count: count })]
       end
     end
   end

data/lib/reek/smells/uncommunicative_method_name.rb

@@ -17,7 +17,6 @@ module Reek
     # * names ending with a number
     #
     # See {file:docs/Uncommunicative-Method-Name.md} for details.
-    # @api private
     class UncommunicativeMethodName < SmellDetector
       # The name of the config field that lists the regexps of
       # smelly names to be reported.
@@ -46,6 +45,7 @@ module Reek
       #
       # @return [Array<SmellWarning>]
       #
+      # :reek:TooManyStatements: { max_statements: 9 }
       def examine_context(ctx)
         reject_names = value(REJECT_KEY, ctx, DEFAULT_REJECT_SET)
         accept_names = value(ACCEPT_KEY, ctx, DEFAULT_ACCEPT_SET)
@@ -54,11 +54,11 @@ module Reek
         var = name.gsub(/^[@\*\&]*/, '')
         return [] if accept_names.include?(var)
         return [] unless reject_names.find { |patt| patt =~ var }
-        [SmellWarning.new(self,
-                          context: ctx.full_name,
-                          lines: [ctx.exp.line],
-                          message: "has the name '#{name}'",
-                          parameters: { name: name })]
+        [smell_warning(
+          context: ctx,
+          lines: [ctx.exp.line],
+          message: "has the name '#{name}'",
+          parameters: { name: name })]
       end
     end
   end

data/lib/reek/smells/uncommunicative_module_name.rb

@@ -17,18 +17,17 @@ module Reek
     # * names ending with a number
     #
     # See {file:docs/Uncommunicative-Module-Name.md} for details.
-    # @api private
     class UncommunicativeModuleName < SmellDetector
       # The name of the config field that lists the regexps of
       # smelly names to be reported.
       REJECT_KEY = 'reject'
-      DEFAULT_REJECT_SET = [/^.$/, /[0-9]$/]
+      DEFAULT_REJECT_PATTERNS = [/^.$/, /[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']
+      DEFAULT_ACCEPT_NAMES = []
 
       def self.smell_category
         'UncommunicativeName'
@@ -36,12 +35,12 @@ module Reek
 
       def self.default_config
         super.merge(
-          REJECT_KEY => DEFAULT_REJECT_SET,
-          ACCEPT_KEY => DEFAULT_ACCEPT_SET
+          REJECT_KEY => DEFAULT_REJECT_PATTERNS,
+          ACCEPT_KEY => DEFAULT_ACCEPT_NAMES
         )
       end
 
-      def self.contexts # :nodoc:
+      def self.contexts
         [:module, :class]
       end
 
@@ -50,22 +49,37 @@ module Reek
       #
       # @return [Array<SmellWarning>]
       #
-      # :reek:Duplication { allow_calls: [ to_s ] }
-      def examine_context(ctx)
-        reject_names = value(REJECT_KEY, ctx, DEFAULT_REJECT_SET)
-        accept_names = value(ACCEPT_KEY, ctx, DEFAULT_ACCEPT_SET)
-        exp = ctx.exp
-        full_name = ctx.full_name
-        name = exp.simple_name.to_s
-        return [] if accept_names.include?(full_name)
-        var = name.gsub(/^[@\*\&]*/, '')
-        return [] if accept_names.include?(var)
-        return [] unless reject_names.find { |patt| patt =~ var }
-        [SmellWarning.new(self,
-                          context: full_name,
-                          lines: [exp.line],
-                          message: "has the name '#{name}'",
-                          parameters: { name: name })]
+      def examine_context(context)
+        fully_qualified_name = context.full_name
+        exp                  = context.exp
+        module_name          = exp.simple_name
+
+        return [] if acceptable_name?(context: context,
+                                      module_name: module_name,
+                                      fully_qualified_name: fully_qualified_name)
+
+        [smell_warning(
+          context: context,
+          lines: [exp.line],
+          message: "has the name '#{module_name}'",
+          parameters: { name: module_name })]
+      end
+
+      private
+
+      # FIXME: switch to required kwargs when dropping Ruby 2.0 compatibility
+      # :reek:ControlParameter
+      def acceptable_name?(context: raise, module_name: raise, fully_qualified_name: raise)
+        accept_names(context).any? { |accept_name| fully_qualified_name == accept_name } ||
+          reject_patterns(context).none? { |pattern| module_name.match pattern }
+      end
+
+      def reject_patterns(context)
+        value(REJECT_KEY, context, DEFAULT_REJECT_PATTERNS)
+      end
+
+      def accept_names(context)
+        value(ACCEPT_KEY, context, DEFAULT_ACCEPT_NAMES)
       end
     end
   end

data/lib/reek/smells/uncommunicative_parameter_name.rb

@@ -17,18 +17,17 @@ module Reek
     # * names ending with a number
     #
     # See {file:docs/Uncommunicative-Parameter-Name.md} for details.
-    # @api private
     class UncommunicativeParameterName < SmellDetector
       # The name of the config field that lists the regexps of
       # smelly names to be reported.
       REJECT_KEY = 'reject'
-      DEFAULT_REJECT_SET = [/^.$/, /[0-9]$/, /[A-Z]/, /^_/]
+      DEFAULT_REJECT_PATTERNS = [/^.$/, /[0-9]$/, /[A-Z]/, /^_/]
 
       # 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 = []
+      DEFAULT_ACCEPT_NAMES = []
 
       def self.smell_category
         'UncommunicativeName'
@@ -36,8 +35,8 @@ module Reek
 
       def self.default_config
         super.merge(
-          REJECT_KEY => DEFAULT_REJECT_SET,
-          ACCEPT_KEY => DEFAULT_ACCEPT_SET
+          REJECT_KEY => DEFAULT_REJECT_PATTERNS,
+          ACCEPT_KEY => DEFAULT_ACCEPT_NAMES
         )
       end
 
@@ -47,29 +46,38 @@ module Reek
       # @return [Array<SmellWarning>]
       #
       def examine_context(ctx)
-        self.reject_names = value(REJECT_KEY, ctx, DEFAULT_REJECT_SET)
-        self.accept_names = value(ACCEPT_KEY, ctx, DEFAULT_ACCEPT_SET)
         context_expression = ctx.exp
         context_expression.parameter_names.select do |name|
-          bad_name?(name) && ctx.uses_param?(name)
+          bad_name?(ctx, name) && ctx.uses_param?(name)
         end.map do |name|
-          SmellWarning.new(self,
-                           context: ctx.full_name,
-                           lines: [context_expression.line],
-                           message: "has the parameter name '#{name}'",
-                           parameters: { name: name.to_s })
+          smell_warning(
+            context: ctx,
+            lines: [context_expression.line],
+            message: "has the parameter name '#{name}'",
+            parameters: { name: name.to_s })
         end
       end
 
-      def bad_name?(name)
-        var = name.to_s.gsub(/^[@\*\&]*/, '')
-        return false if var == '*' || accept_names.include?(var)
-        reject_names.find { |patt| patt =~ var }
+      private
+
+      def bad_name?(ctx, name)
+        sanitized_name = sanitize name
+        return false if sanitized_name == '*' || accept_names(ctx).include?(sanitized_name)
+        reject_patterns(ctx).any? { |pattern| sanitized_name.match pattern }
       end
 
-      private
+      def reject_patterns(context)
+        value(REJECT_KEY, context, DEFAULT_REJECT_PATTERNS)
+      end
 
-      private_attr_accessor :accept_names, :reject_names
+      def accept_names(context)
+        value(ACCEPT_KEY, context, DEFAULT_ACCEPT_NAMES)
+      end
+
+      # :reek:UtilityFunction
+      def sanitize(name)
+        name.to_s.gsub(/^[@\*\&]*/, '')
+      end
     end
   end
 end

data/lib/reek/smells/uncommunicative_variable_name.rb

@@ -17,7 +17,8 @@ module Reek
     # * names ending with a number
     #
     # See {file:docs/Uncommunicative-Variable-Name.md} for details.
-    # @api private
+    #
+    # :reek:DataClump: { max_copies: 4 }
     class UncommunicativeVariableName < SmellDetector
       # The name of the config field that lists the regexps of
       # smelly names to be reported.
@@ -41,7 +42,7 @@ module Reek
         )
       end
 
-      def self.contexts # :nodoc:
+      def self.contexts
         [:module, :class, :def, :defs]
       end
 
@@ -56,11 +57,11 @@ module Reek
         variable_names(ctx.exp).select do |name, _lines|
           bad_name?(name, ctx)
         end.map do |name, lines|
-          SmellWarning.new(self,
-                           context: ctx.full_name,
-                           lines: lines,
-                           message: "has the variable name '#{name}'",
-                           parameters: { name: name.to_s })
+          smell_warning(
+            context: ctx,
+            lines: lines,
+            message: "has the variable name '#{name}'",
+            parameters: { name: name.to_s })
         end
       end
 
@@ -70,6 +71,7 @@ module Reek
         reject_names.find { |patt| patt =~ var }
       end
 
+      # :reek:TooManyStatements: { max_statements: 6 }
       def variable_names(exp)
         result = Hash.new { |hash, key| hash[key] = [] }
         find_assignment_variable_names(exp, result)
@@ -77,6 +79,7 @@ module Reek
         result.to_a.sort_by { |name, _| name.to_s }
       end
 
+      # :reek:UtilityFunction
       def find_assignment_variable_names(exp, accumulator)
         assignment_nodes = exp.each_node(:lvasgn, [:class, :module, :defs, :def])
 
@@ -88,6 +91,8 @@ module Reek
         assignment_nodes.each { |asgn| accumulator[asgn[1]].push(asgn.line) }
       end
 
+      # :reek:FeatureEnvy
+      # :reek:TooManyStatements: { max_statements: 6 }
       def find_block_argument_variable_names(exp, accumulator)
         arg_search_exp = case exp.first
                          when :class, :module
@@ -115,6 +120,7 @@ module Reek
         end
       end
 
+      # :reek:UtilityFunction
       def record_variable_name(exp, symbol, accumulator)
         varname = symbol.to_s.sub(/^\*/, '')
         return if varname == ''

data/lib/reek/smells/unused_parameters.rb

@@ -7,7 +7,6 @@ module Reek
     # Methods should use their parameters.
     #
     # See {file:docs/Unused-Parameters.md} for details.
-    # @api private
     class UnusedParameters < SmellDetector
       def self.smell_category
         'UnusedCode'
@@ -18,14 +17,16 @@ module Reek
       #
       # @return [Array<SmellWarning>]
       #
-      def examine_context(method_ctx)
-        return [] if method_ctx.uses_super_with_implicit_arguments?
-        method_ctx.unused_params.map do |param|
-          SmellWarning.new(self,
-                           context: method_ctx.full_name,
-                           lines: [method_ctx.exp.line],
-                           message: "has unused parameter '#{param.name}'",
-                           parameters: { name: param.name.to_s })
+      # :reek:FeatureEnvy
+      def examine_context(ctx)
+        return [] if ctx.uses_super_with_implicit_arguments?
+        ctx.unused_params.map do |param|
+          name = param.name.to_s
+          smell_warning(
+            context: ctx,
+            lines: [ctx.exp.line],
+            message: "has unused parameter '#{name}'",
+            parameters: { name: name })
         end
       end
     end

data/lib/reek/smells/utility_function.rb

@@ -36,8 +36,10 @@ module Reek
     # +FeatureEnvy+ is reported instead.
     #
     # See {file:docs/Utility-Function.md} for details.
-    # @api private
     class UtilityFunction < SmellDetector
+      PUBLIC_METHODS_ONLY_KEY     = 'public_methods_only'.freeze
+      PUBLIC_METHODS_ONLY_DEFAULT = false
+
       def self.smell_category
         'LowCohesion'
       end
@@ -53,24 +55,33 @@ module Reek
       #
       # @return [Array<SmellWarning>]
       #
-      def examine_context(method_ctx)
-        return [] if method_ctx.singleton_method?
-        return [] if method_ctx.num_statements == 0
-        return [] if method_ctx.references_self?
-        return [] if num_helper_methods(method_ctx).zero?
+      # :reek:FeatureEnvy
+      # :reek:TooManyStatements: { max_statements: 6 }
+      def examine_context(ctx)
+        return [] if ctx.singleton_method?
+        return [] if ctx.num_statements == 0
+        return [] if ctx.references_self?
+        return [] if num_helper_methods(ctx).zero?
+        return [] if ignore_method?(ctx)
 
-        [SmellWarning.new(self,
-                          context: method_ctx.full_name,
-                          lines: [method_ctx.exp.line],
-                          message: "doesn't depend on instance state",
-                          parameters: { name: method_ctx.full_name })]
+        [smell_warning(
+          context: ctx,
+          lines: [ctx.exp.line],
+          message: "doesn't depend on instance state (maybe move it to another class?)",
+          parameters: { name: ctx.full_name })]
       end
 
       private
 
+      # :reek:UtilityFunction
       def num_helper_methods(method_ctx)
         method_ctx.local_nodes(:send).length
       end
+
+      def ignore_method?(method_ctx)
+        method_ctx.non_public_visibility? &&
+          value(PUBLIC_METHODS_ONLY_KEY, method_ctx, PUBLIC_METHODS_ONLY_DEFAULT)
+      end
     end
   end
 end

data/lib/reek/source/source_code.rb

@@ -6,27 +6,25 @@ require_relative '../tree_dresser'
 require_relative '../ast/node'
 
 module Reek
-  # @api private
   module Source
     #
     # A +Source+ object represents a chunk of Ruby source code.
     #
-    # @api private
     class SourceCode
       IO_IDENTIFIER     = 'STDIN'
       STRING_IDENTIFIER = 'string'
 
-      attr_reader :description
+      attr_reader :origin
 
       # Initializer.
       #
-      # code        - Ruby code as String
-      # description - 'STDIN', 'string' or a filepath as String
-      # parser      - the parser to use for generating AST's out of the given source
-      def initialize(code, description, parser: Parser::Ruby22)
-        @source      = code
-        @description = description
-        @parser      = parser
+      # code   - Ruby code as String
+      # origin - 'STDIN', 'string' or a filepath as String
+      # parser - the parser to use for generating AST's out of the given source
+      def initialize(code, origin, parser: Parser::Ruby22)
+        @source = code
+        @origin = origin
+        @parser = parser
       end
 
       # Initializes an instance of SourceCode given a source.
@@ -38,6 +36,7 @@ module Reek
       # @param source [File|IO|String] - the given source
       #
       # @return an instance of SourceCode
+      # :reek:DuplicateMethodCall: { max_calls: 2 }
       def self.from(source)
         case source
         when File     then new(source.read, source.path)
@@ -82,9 +81,9 @@ module Reek
         @syntax_tree ||=
           begin
             begin
-              ast, comments = parser.parse_with_comments(source, description)
+              ast, comments = parser.parse_with_comments(source, origin)
             rescue Racc::ParseError, Parser::SyntaxError => error
-              $stderr.puts "#{description}: #{error.class.name}: #{error}"
+              $stderr.puts "#{origin}: #{error.class.name}: #{error}"
             end
 
             # See https://whitequark.github.io/parser/Parser/Source/Comment/Associator.html

data/lib/reek/source/source_locator.rb

@@ -7,7 +7,6 @@ module Reek
     #
     # Finds Ruby source files in a filesystem.
     #
-    # @api private
     class SourceLocator
       # Initialize with the paths we want to search.
       #
@@ -32,6 +31,8 @@ module Reek
 
       private_attr_reader :configuration, :paths
 
+      # :reek:TooManyStatements: { max_statements: 6 }
+      # :reek:NestedIterators: { max_allowed_nesting: 2 }
       def source_paths
         paths.each_with_object([]) do |given_path, relevant_paths|
           print_no_such_file_error(given_path) && next unless given_path.exist?
@@ -49,10 +50,12 @@ module Reek
         configuration.path_excluded?(path)
       end
 
+      # :reek:UtilityFunction
       def print_no_such_file_error(path)
         $stderr.puts "Error: No such file - #{path}"
       end
 
+      # :reek:UtilityFunction
       def hidden_directory?(path)
         path.basename.to_s.start_with? '.'
       end
@@ -61,10 +64,12 @@ module Reek
         path_excluded?(path) || hidden_directory?(path)
       end
 
+      # :reek:UtilityFunction
       def ruby_file?(path)
         path.extname == '.rb'
       end
 
+      # :reek:UtilityFunction
       def current_directory?(path)
         [Pathname.new('.'), Pathname.new('./')].include?(path)
       end